mono_reflection_init ()
{

}


mono_class_get_ref_info (struct MonoClass * klass)
{
  unsigned int D.23796;
  void * D.23799;

  D.23796 = klass->ref_info_handle;
  if (D.23796 == 0) goto <D.23797>; else goto <D.23798>;
  <D.23797>:
  D.23799 = 0B;
  return D.23799;
  <D.23798>:
  D.23796 = klass->ref_info_handle;
  D.23799 = mono_gchandle_get_target (D.23796);
  return D.23799;
}


mono_class_set_ref_info (struct MonoClass * klass, void * obj)
{
  unsigned int D.23801;
  unsigned int D.23802;
  _Bool D.23803;
  long int D.23804;
  long int D.23805;

  D.23801 = mono_gchandle_new (obj, 0);
  klass->ref_info_handle = D.23801;
  D.23802 = klass->ref_info_handle;
  D.23803 = D.23802 == 0;
  D.23804 = (long int) D.23803;
  D.23805 = __builtin_expect (D.23804, 0);
  if (D.23805 != 0) goto <D.23806>; else goto <D.23807>;
  <D.23806>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 641, "klass->ref_info_handle != 0");
  <D.23807>:
}


mono_class_free_ref_info (struct MonoClass * klass)
{
  unsigned int D.23808;

  D.23808 = klass->ref_info_handle;
  if (D.23808 != 0) goto <D.23809>; else goto <D.23810>;
  <D.23809>:
  D.23808 = klass->ref_info_handle;
  mono_gchandle_free (D.23808);
  klass->ref_info_handle = 0;
  <D.23810>:
}


mono_custom_attrs_free (struct MonoCustomAttrInfo * ainfo)
{
  int D.23811;

  D.23811 = ainfo->cached;
  if (D.23811 == 0) goto <D.23812>; else goto <D.23813>;
  <D.23812>:
  monoeg_g_free (ainfo);
  <D.23813>:
}


mono_image_build_metadata (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.23814;
  unsigned int D.23815;
  int D.23818;
  unsigned int D.23821;
  unsigned int D.23822;
  unsigned int D.23823;
  guint32 * D.23824;
  unsigned char D.23825;
  unsigned int D.23826;
  unsigned int D.23827;
  guint32 * D.23828;
  struct MonoDynamicStream * D.23829;
  unsigned int D.23830;
  guint32 * D.23831;
  unsigned int D.23832;
  guint32 * D.23833;
  guint32 * D.23834;
  guint32 * D.23835;
  struct MonoArray * D.23836;
  unsigned int D.23839;
  unsigned int D.23840;
  unsigned int i.0;
  char * D.23842;
  struct MonoReflectionMethodBuilder * D.23843;
  unsigned int D.23844;
  struct MonoArray * D.23845;
  unsigned int D.23848;
  unsigned int D.23849;
  char * D.23850;
  struct MonoReflectionFieldBuilder * D.23851;
  unsigned int D.23852;
  int D.23853;
  int D.23854;
  void * iftmp.1;
  unsigned int D.23858;
  unsigned int D.23859;
  void * D.23860;
  struct MonoArray * D.23862;
  char * D.23865;
  void * * D.23866;
  int D.23867;
  unsigned int D.23868;
  unsigned int D.23869;
  unsigned int D.23870;
  unsigned int i.2;
  unsigned int D.23872;
  void * * D.23873;
  struct MonoString * D.23874;
  struct MonoString * D.23875;
  struct MonoArray * D.23876;
  struct MonoArray * D.23877;
  struct MonoArray * D.23880;
  struct MonoArray * D.23883;
  struct MonoGHashTable * D.23886;
  char * D.23889;
  unsigned int D.23890;
  struct MonoArray * D.23891;
  unsigned int j.3;
  char * D.23895;
  int D.23896;
  int D.23897;
  struct MonoDynamicTable * table;
  struct MonoDynamicImage * assembly;
  struct MonoReflectionAssemblyBuilder * assemblyb;
  struct MonoDomain * domain;
  struct MonoPtrArray types;
  guint32 * values;
  int i;
  int j;

  try
    {
      assemblyb = moduleb->assemblyb;
      assembly = moduleb->dynamic_image;
      D.23814 = MEM[(struct MonoObject *)assemblyb].vtable;
      domain = D.23814->domain;
      D.23815 = assembly->text_rva;
      if (D.23815 != 0) goto <D.23816>; else goto <D.23817>;
      <D.23816>:
      return;
      <D.23817>:
      assembly->text_rva = 8192;
      D.23818 = moduleb->is_main;
      if (D.23818 != 0) goto <D.23819>; else goto <D.23820>;
      <D.23819>:
      mono_image_emit_manifest (moduleb);
      <D.23820>:
      table = &assembly->tables[2];
      table->rows = 1;
      D.23821 = table->next_idx;
      D.23822 = D.23821 + 1;
      table->next_idx = D.23822;
      D.23823 = table->rows;
      alloc_table (table, D.23823);
      D.23824 = table->values;
      D.23825 = table->columns;
      D.23826 = (unsigned int) D.23825;
      D.23827 = D.23826 * 4;
      values = D.23824 + D.23827;
      *values = 0;
      D.23828 = values + 4;
      D.23829 = &assembly->sheap;
      D.23830 = string_heap_insert (D.23829, "<Module>");
      *D.23828 = D.23830;
      D.23831 = values + 8;
      D.23829 = &assembly->sheap;
      D.23832 = string_heap_insert (D.23829, "");
      *D.23831 = D.23832;
      D.23833 = values + 12;
      *D.23833 = 0;
      D.23834 = values + 16;
      *D.23834 = 1;
      D.23835 = values + 20;
      *D.23835 = 1;
      D.23836 = moduleb->global_methods;
      if (D.23836 != 0B) goto <D.23837>; else goto <D.23838>;
      <D.23837>:
      table = &assembly->tables[6];
      D.23836 = moduleb->global_methods;
      D.23839 = mono_array_length (D.23836);
      D.23823 = table->rows;
      D.23840 = D.23823 + D.23839;
      table->rows = D.23840;
      D.23823 = table->rows;
      alloc_table (table, D.23823);
      i = 0;
      goto <D.20008>;
      <D.20007>:
      D.23836 = moduleb->global_methods;
      i.0 = (unsigned int) i;
      D.23842 = mono_array_addr_with_size (D.23836, 4, i.0);
      D.23843 = MEM[(struct MonoReflectionMethodBuilder * *)D.23842];
      mono_image_get_method_info (D.23843, assembly);
      i = i + 1;
      <D.20008>:
      i.0 = (unsigned int) i;
      D.23836 = moduleb->global_methods;
      D.23844 = mono_array_length (D.23836);
      if (i.0 < D.23844) goto <D.20007>; else goto <D.20009>;
      <D.20009>:
      <D.23838>:
      D.23845 = moduleb->global_fields;
      if (D.23845 != 0B) goto <D.23846>; else goto <D.23847>;
      <D.23846>:
      table = &assembly->tables[4];
      D.23845 = moduleb->global_fields;
      D.23848 = mono_array_length (D.23845);
      D.23823 = table->rows;
      D.23849 = D.23823 + D.23848;
      table->rows = D.23849;
      D.23823 = table->rows;
      alloc_table (table, D.23823);
      i = 0;
      goto <D.20011>;
      <D.20010>:
      D.23845 = moduleb->global_fields;
      i.0 = (unsigned int) i;
      D.23850 = mono_array_addr_with_size (D.23845, 4, i.0);
      D.23851 = MEM[(struct MonoReflectionFieldBuilder * *)D.23850];
      mono_image_get_field_info (D.23851, assembly);
      i = i + 1;
      <D.20011>:
      i.0 = (unsigned int) i;
      D.23845 = moduleb->global_fields;
      D.23852 = mono_array_length (D.23845);
      if (i.0 < D.23852) goto <D.20010>; else goto <D.20012>;
      <D.20012>:
      <D.23847>:
      table = &assembly->tables[0];
      alloc_table (table, 1);
      mono_image_fill_module_table (domain, moduleb, assembly);
      types.size = 0;
      D.23853 = moduleb->num_types;
      D.23854 = MAX_EXPR <D.23853, 16>;
      types.capacity = D.23854;
      D.23853 = moduleb->num_types;
      if (D.23853 > 16) goto <D.23856>; else goto <D.23857>;
      <D.23856>:
      D.23853 = moduleb->num_types;
      D.23858 = (unsigned int) D.23853;
      D.23859 = D.23858 * 4;
      D.23853 = moduleb->num_types;
      D.23860 = mono_gc_make_root_descr_all_refs (D.23853);
      iftmp.1 = mono_gc_alloc_fixed (D.23859, D.23860);
      goto <D.23861>;
      <D.23857>:
      iftmp.1 = __builtin_alloca (64);
      <D.23861>:
      types.data = iftmp.1;
      D.23862 = moduleb->types;
      if (D.23862 != 0B) goto <D.23863>; else goto <D.23864>;
      <D.23863>:
      i = 0;
      goto <D.20015>;
      <D.20014>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.23862 = moduleb->types;
        i.0 = (unsigned int) i;
        D.23865 = mono_array_addr_with_size (D.23862, 4, i.0);
        type = MEM[(struct MonoReflectionTypeBuilder * *)D.23865];
        collect_types (&types, type);
      }
      i = i + 1;
      <D.20015>:
      D.23853 = moduleb->num_types;
      if (D.23853 > i) goto <D.20014>; else goto <D.20016>;
      <D.20016>:
      <D.23864>:
      D.23866 = types.data;
      D.23867 = types.size;
      D.23868 = (unsigned int) D.23867;
      qsort (D.23866, D.23868, 4, compare_types_by_table_idx);
      table = &assembly->tables[2];
      D.23823 = table->rows;
      D.23867 = types.size;
      D.23869 = (unsigned int) D.23867;
      D.23870 = D.23823 + D.23869;
      table->rows = D.23870;
      D.23823 = table->rows;
      alloc_table (table, D.23823);
      i = 0;
      goto <D.20019>;
      <D.20018>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.23866 = types.data;
        i.2 = (unsigned int) i;
        D.23872 = i.2 * 4;
        D.23873 = D.23866 + D.23872;
        tb = *D.23873;
        D.23829 = &assembly->sheap;
        D.23874 = tb->nspace;
        string_heap_insert_mstring (D.23829, D.23874);
      }
      i = i + 1;
      <D.20019>:
      D.23867 = types.size;
      if (D.23867 > i) goto <D.20018>; else goto <D.20020>;
      <D.20020>:
      i = 0;
      goto <D.20023>;
      <D.20022>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.23866 = types.data;
        i.2 = (unsigned int) i;
        D.23872 = i.2 * 4;
        D.23873 = D.23866 + D.23872;
        tb = *D.23873;
        D.23829 = &assembly->sheap;
        D.23875 = tb->name;
        string_heap_insert_mstring (D.23829, D.23875);
      }
      i = i + 1;
      <D.20023>:
      D.23867 = types.size;
      if (D.23867 > i) goto <D.20022>; else goto <D.20024>;
      <D.20024>:
      i = 0;
      goto <D.20027>;
      <D.20026>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.23866 = types.data;
        i.2 = (unsigned int) i;
        D.23872 = i.2 * 4;
        D.23873 = D.23866 + D.23872;
        type = *D.23873;
        mono_image_get_type_info (domain, type, assembly);
      }
      i = i + 1;
      <D.20027>:
      D.23867 = types.size;
      if (D.23867 > i) goto <D.20026>; else goto <D.20028>;
      <D.20028>:
      D.23876 = assemblyb->cattrs;
      mono_image_add_cattrs (assembly, 1, 14, D.23876);
      D.23877 = assemblyb->permissions_minimum;
      if (D.23877 != 0B) goto <D.23878>; else goto <D.23879>;
      <D.23878>:
      D.23877 = assemblyb->permissions_minimum;
      mono_image_add_decl_security (assembly, 536870913, D.23877);
      <D.23879>:
      D.23880 = assemblyb->permissions_optional;
      if (D.23880 != 0B) goto <D.23881>; else goto <D.23882>;
      <D.23881>:
      D.23880 = assemblyb->permissions_optional;
      mono_image_add_decl_security (assembly, 536870913, D.23880);
      <D.23882>:
      D.23883 = assemblyb->permissions_refused;
      if (D.23883 != 0B) goto <D.23884>; else goto <D.23885>;
      <D.23884>:
      D.23883 = assemblyb->permissions_refused;
      mono_image_add_decl_security (assembly, 536870913, D.23883);
      <D.23885>:
      module_add_cattrs (assembly, moduleb);
      D.23886 = assembly->token_fixups;
      mono_g_hash_table_foreach (D.23886, fixup_method, assembly);
      D.23836 = moduleb->global_methods;
      if (D.23836 != 0B) goto <D.23887>; else goto <D.23888>;
      <D.23887>:
      i = 0;
      goto <D.20031>;
      <D.20030>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.23836 = moduleb->global_methods;
        i.0 = (unsigned int) i;
        D.23889 = mono_array_addr_with_size (D.23836, 4, i.0);
        mb = MEM[(struct MonoReflectionMethodBuilder * *)D.23889];
        mono_image_add_methodimpl (assembly, mb);
      }
      i = i + 1;
      <D.20031>:
      i.0 = (unsigned int) i;
      D.23836 = moduleb->global_methods;
      D.23890 = mono_array_length (D.23836);
      if (i.0 < D.23890) goto <D.20030>; else goto <D.20032>;
      <D.20032>:
      <D.23888>:
      i = 0;
      goto <D.20039>;
      <D.20038>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.23866 = types.data;
        i.2 = (unsigned int) i;
        D.23872 = i.2 * 4;
        D.23873 = D.23866 + D.23872;
        type = *D.23873;
        D.23891 = type->methods;
        if (D.23891 != 0B) goto <D.23892>; else goto <D.23893>;
        <D.23892>:
        j = 0;
        goto <D.20036>;
        <D.20035>:
        {
          struct MonoReflectionMethodBuilder * mb;

          D.23891 = type->methods;
          j.3 = (unsigned int) j;
          D.23895 = mono_array_addr_with_size (D.23891, 4, j.3);
          mb = MEM[(struct MonoReflectionMethodBuilder * *)D.23895];
          mono_image_add_methodimpl (assembly, mb);
        }
        j = j + 1;
        <D.20036>:
        D.23896 = type->num_methods;
        if (D.23896 > j) goto <D.20035>; else goto <D.20037>;
        <D.20037>:
        <D.23893>:
      }
      i = i + 1;
      <D.20039>:
      D.23867 = types.size;
      if (D.23867 > i) goto <D.20038>; else goto <D.20040>;
      <D.20040>:
      D.23897 = types.capacity;
      if (D.23897 > 16) goto <D.23898>; else goto <D.23899>;
      <D.23898>:
      D.23866 = types.data;
      mono_gc_free_fixed (D.23866);
      <D.23899>:
      fixup_cattrs (assembly);
    }
  finally
    {
      types = {CLOBBER};
    }
}


fixup_method (struct MonoReflectionILGen * ilgen, void * value, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.23903;
  char * D.23904;
  int D.23905;
  sizetype D.23906;
  sizetype D.23907;
  unsigned char * D.23908;
  unsigned char D.23909;
  int D.23910;
  int D.19677;
  int iftmp.4;
  int D.19676;
  struct MonoObject * D.23914;
  struct MonoVTable * D.23915;
  struct MonoClass * D.23916;
  const char[13] * D.23917;
  unsigned char D.23918;
  int D.23919;
  unsigned char D.23920;
  int D.23921;
  const unsigned char * D.23926;
  unsigned char D.23927;
  int D.23928;
  const unsigned char * D.23929;
  unsigned char D.23930;
  int D.23931;
  const unsigned char * D.23936;
  unsigned char D.23937;
  int D.23938;
  const unsigned char * D.23939;
  unsigned char D.23940;
  int D.23941;
  const unsigned char * D.23946;
  unsigned char D.23947;
  int D.23948;
  const unsigned char * D.23949;
  unsigned char D.23950;
  int D.23951;
  const char * D.23953;
  int D.23956;
  int D.19686;
  int iftmp.5;
  int D.19685;
  const char[10] * D.23961;
  unsigned char D.23962;
  int D.23963;
  unsigned char D.23964;
  int D.23965;
  const unsigned char * D.23970;
  unsigned char D.23971;
  int D.23972;
  const unsigned char * D.23973;
  unsigned char D.23974;
  int D.23975;
  const unsigned char * D.23980;
  unsigned char D.23981;
  int D.23982;
  const unsigned char * D.23983;
  unsigned char D.23984;
  int D.23985;
  const unsigned char * D.23990;
  unsigned char D.23991;
  int D.23992;
  const unsigned char * D.23993;
  unsigned char D.23994;
  int D.23995;
  struct GHashTable * D.23999;
  void * D.24000;
  int D.19698;
  int iftmp.6;
  int D.19697;
  const char[14] * D.24005;
  unsigned char D.24006;
  int D.24007;
  unsigned char D.24008;
  int D.24009;
  const unsigned char * D.24014;
  unsigned char D.24015;
  int D.24016;
  const unsigned char * D.24017;
  unsigned char D.24018;
  int D.24019;
  const unsigned char * D.24024;
  unsigned char D.24025;
  int D.24026;
  const unsigned char * D.24027;
  unsigned char D.24028;
  int D.24029;
  const unsigned char * D.24034;
  unsigned char D.24035;
  int D.24036;
  const unsigned char * D.24037;
  unsigned char D.24038;
  int D.24039;
  int D.19707;
  int iftmp.7;
  int D.19706;
  const char[19] * D.24047;
  unsigned char D.24048;
  int D.24049;
  unsigned char D.24050;
  int D.24051;
  const unsigned char * D.24056;
  unsigned char D.24057;
  int D.24058;
  const unsigned char * D.24059;
  unsigned char D.24060;
  int D.24061;
  const unsigned char * D.24066;
  unsigned char D.24067;
  int D.24068;
  const unsigned char * D.24069;
  unsigned char D.24070;
  int D.24071;
  const unsigned char * D.24076;
  unsigned char D.24077;
  int D.24078;
  const unsigned char * D.24079;
  unsigned char D.24080;
  int D.24081;
  int D.19716;
  int iftmp.8;
  int D.19715;
  const char[11] * D.24092;
  unsigned char D.24093;
  int D.24094;
  unsigned char D.24095;
  int D.24096;
  const unsigned char * D.24101;
  unsigned char D.24102;
  int D.24103;
  const unsigned char * D.24104;
  unsigned char D.24105;
  int D.24106;
  const unsigned char * D.24111;
  unsigned char D.24112;
  int D.24113;
  const unsigned char * D.24114;
  unsigned char D.24115;
  int D.24116;
  const unsigned char * D.24121;
  unsigned char D.24122;
  int D.24123;
  const unsigned char * D.24124;
  unsigned char D.24125;
  int D.24126;
  int D.19725;
  int iftmp.9;
  int D.19724;
  const char[12] * D.24132;
  unsigned char D.24133;
  int D.24134;
  unsigned char D.24135;
  int D.24136;
  const unsigned char * D.24141;
  unsigned char D.24142;
  int D.24143;
  const unsigned char * D.24144;
  unsigned char D.24145;
  int D.24146;
  const unsigned char * D.24151;
  unsigned char D.24152;
  int D.24153;
  const unsigned char * D.24154;
  unsigned char D.24155;
  int D.24156;
  const unsigned char * D.24161;
  unsigned char D.24162;
  int D.24163;
  const unsigned char * D.24164;
  unsigned char D.24165;
  int D.24166;
  struct GHashTable * D.24168;
  void * D.24169;
  int D.19736;
  int iftmp.10;
  int D.19735;
  const char[12] * D.24173;
  unsigned char D.24174;
  int D.24175;
  unsigned char D.24176;
  int D.24177;
  const unsigned char * D.24182;
  unsigned char D.24183;
  int D.24184;
  const unsigned char * D.24185;
  unsigned char D.24186;
  int D.24187;
  const unsigned char * D.24192;
  unsigned char D.24193;
  int D.24194;
  const unsigned char * D.24195;
  unsigned char D.24196;
  int D.24197;
  const unsigned char * D.24202;
  unsigned char D.24203;
  int D.24204;
  const unsigned char * D.24205;
  unsigned char D.24206;
  int D.24207;
  int D.19746;
  int iftmp.11;
  int D.19745;
  const char[16] * D.24214;
  unsigned char D.24215;
  int D.24216;
  unsigned char D.24217;
  int D.24218;
  const unsigned char * D.24223;
  unsigned char D.24224;
  int D.24225;
  const unsigned char * D.24226;
  unsigned char D.24227;
  int D.24228;
  const unsigned char * D.24233;
  unsigned char D.24234;
  int D.24235;
  const unsigned char * D.24236;
  unsigned char D.24237;
  int D.24238;
  const unsigned char * D.24243;
  unsigned char D.24244;
  int D.24245;
  const unsigned char * D.24246;
  unsigned char D.24247;
  int D.24248;
  int D.19755;
  int iftmp.12;
  int D.19754;
  unsigned char D.24258;
  int D.24259;
  const unsigned char * D.24264;
  unsigned char D.24265;
  int D.24266;
  const unsigned char * D.24271;
  unsigned char D.24272;
  int D.24273;
  const unsigned char * D.24278;
  unsigned char D.24279;
  int D.24280;
  int D.19764;
  int iftmp.13;
  int D.19763;
  unsigned char D.24286;
  int D.24287;
  const unsigned char * D.24292;
  unsigned char D.24293;
  int D.24294;
  const unsigned char * D.24299;
  unsigned char D.24300;
  int D.24301;
  const unsigned char * D.24306;
  unsigned char D.24307;
  int D.24308;
  int D.19773;
  int iftmp.14;
  int D.19772;
  const char[18] * D.24314;
  unsigned char D.24315;
  int D.24316;
  unsigned char D.24317;
  int D.24318;
  const unsigned char * D.24323;
  unsigned char D.24324;
  int D.24325;
  const unsigned char * D.24326;
  unsigned char D.24327;
  int D.24328;
  const unsigned char * D.24333;
  unsigned char D.24334;
  int D.24335;
  const unsigned char * D.24336;
  unsigned char D.24337;
  int D.24338;
  const unsigned char * D.24343;
  unsigned char D.24344;
  int D.24345;
  const unsigned char * D.24346;
  unsigned char D.24347;
  int D.24348;
  int D.19782;
  int iftmp.15;
  int D.19781;
  const char[19] * D.24354;
  unsigned char D.24355;
  int D.24356;
  unsigned char D.24357;
  int D.24358;
  const unsigned char * D.24363;
  unsigned char D.24364;
  int D.24365;
  const unsigned char * D.24366;
  unsigned char D.24367;
  int D.24368;
  const unsigned char * D.24373;
  unsigned char D.24374;
  int D.24375;
  const unsigned char * D.24376;
  unsigned char D.24377;
  int D.24378;
  const unsigned char * D.24383;
  unsigned char D.24384;
  int D.24385;
  const unsigned char * D.24386;
  unsigned char D.24387;
  int D.24388;
  int iftmp.16;
  struct MonoClass * D.24393;
  struct MonoGenericClass * D.24394;
  struct MonoGenericContainer * D.24396;
  _Bool D.24398;
  long int D.24399;
  long int D.24400;
  int D.19793;
  int iftmp.17;
  int D.19792;
  unsigned char D.24406;
  int D.24407;
  const unsigned char * D.24412;
  unsigned char D.24413;
  int D.24414;
  const unsigned char * D.24419;
  unsigned char D.24420;
  int D.24421;
  const unsigned char * D.24426;
  unsigned char D.24427;
  int D.24428;
  int D.19802;
  int iftmp.18;
  int D.19801;
  unsigned char D.24435;
  int D.24436;
  const unsigned char * D.24441;
  unsigned char D.24442;
  int D.24443;
  const unsigned char * D.24448;
  unsigned char D.24449;
  int D.24450;
  const unsigned char * D.24455;
  unsigned char D.24456;
  int D.24457;
  int D.24461;
  _Bool D.24462;
  long int D.24463;
  long int D.24464;
  int D.19812;
  int iftmp.19;
  int D.19811;
  unsigned char D.24472;
  int D.24473;
  const unsigned char * D.24478;
  unsigned char D.24479;
  int D.24480;
  const unsigned char * D.24485;
  unsigned char D.24486;
  int D.24487;
  const unsigned char * D.24492;
  unsigned char D.24493;
  int D.24494;
  int D.19821;
  int iftmp.20;
  int D.19820;
  unsigned char D.24500;
  int D.24501;
  const unsigned char * D.24506;
  unsigned char D.24507;
  int D.24508;
  const unsigned char * D.24513;
  unsigned char D.24514;
  int D.24515;
  const unsigned char * D.24520;
  unsigned char D.24521;
  int D.24522;
  int D.19830;
  int iftmp.21;
  int D.19829;
  const char[23] * D.24527;
  unsigned char D.24528;
  int D.24529;
  unsigned char D.24530;
  int D.24531;
  const unsigned char * D.24536;
  unsigned char D.24537;
  int D.24538;
  const unsigned char * D.24539;
  unsigned char D.24540;
  int D.24541;
  const unsigned char * D.24546;
  unsigned char D.24547;
  int D.24548;
  const unsigned char * D.24549;
  unsigned char D.24550;
  int D.24551;
  const unsigned char * D.24556;
  unsigned char D.24557;
  int D.24558;
  const unsigned char * D.24559;
  unsigned char D.24560;
  int D.24561;
  int D.19839;
  int iftmp.22;
  int D.19838;
  const char[24] * D.24568;
  unsigned char D.24569;
  int D.24570;
  unsigned char D.24571;
  int D.24572;
  const unsigned char * D.24577;
  unsigned char D.24578;
  int D.24579;
  const unsigned char * D.24580;
  unsigned char D.24581;
  int D.24582;
  const unsigned char * D.24587;
  unsigned char D.24588;
  int D.24589;
  const unsigned char * D.24590;
  unsigned char D.24591;
  int D.24592;
  const unsigned char * D.24597;
  unsigned char D.24598;
  int D.24599;
  const unsigned char * D.24600;
  unsigned char D.24601;
  int D.24602;
  int D.19848;
  int iftmp.23;
  int D.19847;
  const char[29] * D.24609;
  unsigned char D.24610;
  int D.24611;
  unsigned char D.24612;
  int D.24613;
  const unsigned char * D.24618;
  unsigned char D.24619;
  int D.24620;
  const unsigned char * D.24621;
  unsigned char D.24622;
  int D.24623;
  const unsigned char * D.24628;
  unsigned char D.24629;
  int D.24630;
  const unsigned char * D.24631;
  unsigned char D.24632;
  int D.24633;
  const unsigned char * D.24638;
  unsigned char D.24639;
  int D.24640;
  const unsigned char * D.24641;
  unsigned char D.24642;
  int D.24643;
  int D.19858;
  int iftmp.24;
  int D.19857;
  unsigned char D.24650;
  int D.24651;
  const unsigned char * D.24656;
  unsigned char D.24657;
  int D.24658;
  const unsigned char * D.24663;
  unsigned char D.24664;
  int D.24665;
  const unsigned char * D.24670;
  unsigned char D.24671;
  int D.24672;
  struct MonoMethodSignature * D.24676;
  short unsigned int D.24677;
  _Bool D.24678;
  long int D.24679;
  long int D.24680;
  int D.19868;
  int iftmp.25;
  int D.19867;
  unsigned char D.24686;
  int D.24687;
  const unsigned char * D.24692;
  unsigned char D.24693;
  int D.24694;
  const unsigned char * D.24699;
  unsigned char D.24700;
  int D.24701;
  const unsigned char * D.24706;
  unsigned char D.24707;
  int D.24708;
  int D.19877;
  int iftmp.26;
  int D.19876;
  unsigned char D.24715;
  int D.24716;
  const unsigned char * D.24721;
  unsigned char D.24722;
  int D.24723;
  const unsigned char * D.24728;
  unsigned char D.24729;
  int D.24730;
  const unsigned char * D.24735;
  unsigned char D.24736;
  int D.24737;
  unsigned char D.24741;
  unsigned char * D.24742;
  unsigned int D.24743;
  unsigned char D.24744;
  unsigned char * D.24745;
  unsigned int D.24746;
  unsigned char D.24747;
  int D.24748;
  unsigned int D.24749;
  guint32 code_idx;
  struct MonoReflectionILTokenInfo * iltoken;
  struct MonoReflectionFieldBuilder * field;
  struct MonoReflectionCtorBuilder * ctor;
  struct MonoReflectionMethodBuilder * method;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoReflectionArrayMethod * am;
  guint32 i;
  guint32 idx;
  unsigned char * target;

  code_idx = (guint32) value;
  idx = 0;
  i = 0;
  goto <D.19881>;
  <D.19880>:
  D.23903 = ilgen->token_fixups;
  iltoken = mono_array_addr_with_size (D.23903, 8, i);
  D.23904 = assembly->code.data;
  D.23905 = iltoken->code_pos;
  D.23906 = (sizetype) D.23905;
  D.23907 = D.23906 + code_idx;
  target = D.23904 + D.23907;
  D.23908 = target + 3;
  D.23909 = *D.23908;
  D.23910 = (int) D.23909;
  switch (D.23910) <default: <D.19878>, case 2: <D.19727>, case 4: <D.19668>, case 6: <D.19689>, case 10: <D.19737>, case 43: <D.19849>>
  <D.19668>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.23917 = "FieldBuilder";
      D.23918 = MEM[(const unsigned char *)D.23917];
      D.23919 = (int) D.23918;
      D.23920 = *__s2;
      D.23921 = (int) D.23920;
      __result = D.23919 - D.23921;
      {
        if (__s2_len != 0) goto <D.23922>; else goto <D.23923>;
        <D.23922>:
        if (__result == 0) goto <D.23924>; else goto <D.23925>;
        <D.23924>:
        D.23926 = &MEM[(void *)"FieldBuilder" + 1B];
        D.23927 = *D.23926;
        D.23928 = (int) D.23927;
        D.23929 = __s2 + 1;
        D.23930 = *D.23929;
        D.23931 = (int) D.23930;
        __result = D.23928 - D.23931;
        if (__s2_len > 1) goto <D.23932>; else goto <D.23933>;
        <D.23932>:
        if (__result == 0) goto <D.23934>; else goto <D.23935>;
        <D.23934>:
        D.23936 = &MEM[(void *)"FieldBuilder" + 2B];
        D.23937 = *D.23936;
        D.23938 = (int) D.23937;
        D.23939 = __s2 + 2;
        D.23940 = *D.23939;
        D.23941 = (int) D.23940;
        __result = D.23938 - D.23941;
        if (__s2_len > 2) goto <D.23942>; else goto <D.23943>;
        <D.23942>:
        if (__result == 0) goto <D.23944>; else goto <D.23945>;
        <D.23944>:
        D.23946 = &MEM[(void *)"FieldBuilder" + 3B];
        D.23947 = *D.23946;
        D.23948 = (int) D.23947;
        D.23949 = __s2 + 3;
        D.23950 = *D.23949;
        D.23951 = (int) D.23950;
        __result = D.23948 - D.23951;
        <D.23945>:
        <D.23943>:
        <D.23935>:
        <D.23933>:
        <D.23925>:
        <D.23923>:
      }
      D.19676 = __result;
    }
    iftmp.4 = -D.19676;
    goto <D.23952>;
    <D.23913>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.4 = __builtin_strcmp (D.23953, "FieldBuilder");
    <D.23952>:
    D.19677 = iftmp.4;
  }
  if (D.19677 == 0) goto <D.23954>; else goto <D.23955>;
  <D.23954>:
  field = iltoken->member;
  D.23956 = field->table_idx;
  idx = (guint32) D.23956;
  goto <D.23957>;
  <D.23955>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.23961 = "MonoField";
      D.23962 = MEM[(const unsigned char *)D.23961];
      D.23963 = (int) D.23962;
      D.23964 = *__s2;
      D.23965 = (int) D.23964;
      __result = D.23963 - D.23965;
      {
        if (__s2_len != 0) goto <D.23966>; else goto <D.23967>;
        <D.23966>:
        if (__result == 0) goto <D.23968>; else goto <D.23969>;
        <D.23968>:
        D.23970 = &MEM[(void *)"MonoField" + 1B];
        D.23971 = *D.23970;
        D.23972 = (int) D.23971;
        D.23973 = __s2 + 1;
        D.23974 = *D.23973;
        D.23975 = (int) D.23974;
        __result = D.23972 - D.23975;
        if (__s2_len > 1) goto <D.23976>; else goto <D.23977>;
        <D.23976>:
        if (__result == 0) goto <D.23978>; else goto <D.23979>;
        <D.23978>:
        D.23980 = &MEM[(void *)"MonoField" + 2B];
        D.23981 = *D.23980;
        D.23982 = (int) D.23981;
        D.23983 = __s2 + 2;
        D.23984 = *D.23983;
        D.23985 = (int) D.23984;
        __result = D.23982 - D.23985;
        if (__s2_len > 2) goto <D.23986>; else goto <D.23987>;
        <D.23986>:
        if (__result == 0) goto <D.23988>; else goto <D.23989>;
        <D.23988>:
        D.23990 = &MEM[(void *)"MonoField" + 3B];
        D.23991 = *D.23990;
        D.23992 = (int) D.23991;
        D.23993 = __s2 + 3;
        D.23994 = *D.23993;
        D.23995 = (int) D.23994;
        __result = D.23992 - D.23995;
        <D.23989>:
        <D.23987>:
        <D.23979>:
        <D.23977>:
        <D.23969>:
        <D.23967>:
      }
      D.19685 = __result;
    }
    iftmp.5 = -D.19685;
    goto <D.23996>;
    <D.23960>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.5 = __builtin_strcmp (D.23953, "MonoField");
    <D.23996>:
    D.19686 = iftmp.5;
  }
  if (D.19686 == 0) goto <D.23997>; else goto <D.23998>;
  <D.23997>:
  {
    struct MonoClassField * f;

    D.23914 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.23914].field;
    D.23999 = assembly->field_to_table_idx;
    D.24000 = monoeg_g_hash_table_lookup (D.23999, f);
    idx = (guint32) D.24000;
  }
  goto <D.24001>;
  <D.23998>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4237);
  <D.24001>:
  <D.23957>:
  goto <D.19688>;
  <D.19689>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24005 = "MethodBuilder";
      D.24006 = MEM[(const unsigned char *)D.24005];
      D.24007 = (int) D.24006;
      D.24008 = *__s2;
      D.24009 = (int) D.24008;
      __result = D.24007 - D.24009;
      {
        if (__s2_len != 0) goto <D.24010>; else goto <D.24011>;
        <D.24010>:
        if (__result == 0) goto <D.24012>; else goto <D.24013>;
        <D.24012>:
        D.24014 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24015 = *D.24014;
        D.24016 = (int) D.24015;
        D.24017 = __s2 + 1;
        D.24018 = *D.24017;
        D.24019 = (int) D.24018;
        __result = D.24016 - D.24019;
        if (__s2_len > 1) goto <D.24020>; else goto <D.24021>;
        <D.24020>:
        if (__result == 0) goto <D.24022>; else goto <D.24023>;
        <D.24022>:
        D.24024 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24025 = *D.24024;
        D.24026 = (int) D.24025;
        D.24027 = __s2 + 2;
        D.24028 = *D.24027;
        D.24029 = (int) D.24028;
        __result = D.24026 - D.24029;
        if (__s2_len > 2) goto <D.24030>; else goto <D.24031>;
        <D.24030>:
        if (__result == 0) goto <D.24032>; else goto <D.24033>;
        <D.24032>:
        D.24034 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24035 = *D.24034;
        D.24036 = (int) D.24035;
        D.24037 = __s2 + 3;
        D.24038 = *D.24037;
        D.24039 = (int) D.24038;
        __result = D.24036 - D.24039;
        <D.24033>:
        <D.24031>:
        <D.24023>:
        <D.24021>:
        <D.24013>:
        <D.24011>:
      }
      D.19697 = __result;
    }
    iftmp.6 = -D.19697;
    goto <D.24040>;
    <D.24004>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.6 = __builtin_strcmp (D.23953, "MethodBuilder");
    <D.24040>:
    D.19698 = iftmp.6;
  }
  if (D.19698 == 0) goto <D.24041>; else goto <D.24042>;
  <D.24041>:
  method = iltoken->member;
  idx = method->table_idx;
  goto <D.24043>;
  <D.24042>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24047 = "ConstructorBuilder";
      D.24048 = MEM[(const unsigned char *)D.24047];
      D.24049 = (int) D.24048;
      D.24050 = *__s2;
      D.24051 = (int) D.24050;
      __result = D.24049 - D.24051;
      {
        if (__s2_len != 0) goto <D.24052>; else goto <D.24053>;
        <D.24052>:
        if (__result == 0) goto <D.24054>; else goto <D.24055>;
        <D.24054>:
        D.24056 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24057 = *D.24056;
        D.24058 = (int) D.24057;
        D.24059 = __s2 + 1;
        D.24060 = *D.24059;
        D.24061 = (int) D.24060;
        __result = D.24058 - D.24061;
        if (__s2_len > 1) goto <D.24062>; else goto <D.24063>;
        <D.24062>:
        if (__result == 0) goto <D.24064>; else goto <D.24065>;
        <D.24064>:
        D.24066 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24067 = *D.24066;
        D.24068 = (int) D.24067;
        D.24069 = __s2 + 2;
        D.24070 = *D.24069;
        D.24071 = (int) D.24070;
        __result = D.24068 - D.24071;
        if (__s2_len > 2) goto <D.24072>; else goto <D.24073>;
        <D.24072>:
        if (__result == 0) goto <D.24074>; else goto <D.24075>;
        <D.24074>:
        D.24076 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24077 = *D.24076;
        D.24078 = (int) D.24077;
        D.24079 = __s2 + 3;
        D.24080 = *D.24079;
        D.24081 = (int) D.24080;
        __result = D.24078 - D.24081;
        <D.24075>:
        <D.24073>:
        <D.24065>:
        <D.24063>:
        <D.24055>:
        <D.24053>:
      }
      D.19706 = __result;
    }
    iftmp.7 = -D.19706;
    goto <D.24082>;
    <D.24046>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.7 = __builtin_strcmp (D.23953, "ConstructorBuilder");
    <D.24082>:
    D.19707 = iftmp.7;
  }
  if (D.19707 == 0) goto <D.24083>; else goto <D.24084>;
  <D.24083>:
  ctor = iltoken->member;
  idx = ctor->table_idx;
  goto <D.24085>;
  <D.24084>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24092 = "MonoMethod";
      D.24093 = MEM[(const unsigned char *)D.24092];
      D.24094 = (int) D.24093;
      D.24095 = *__s2;
      D.24096 = (int) D.24095;
      __result = D.24094 - D.24096;
      {
        if (__s2_len != 0) goto <D.24097>; else goto <D.24098>;
        <D.24097>:
        if (__result == 0) goto <D.24099>; else goto <D.24100>;
        <D.24099>:
        D.24101 = &MEM[(void *)"MonoMethod" + 1B];
        D.24102 = *D.24101;
        D.24103 = (int) D.24102;
        D.24104 = __s2 + 1;
        D.24105 = *D.24104;
        D.24106 = (int) D.24105;
        __result = D.24103 - D.24106;
        if (__s2_len > 1) goto <D.24107>; else goto <D.24108>;
        <D.24107>:
        if (__result == 0) goto <D.24109>; else goto <D.24110>;
        <D.24109>:
        D.24111 = &MEM[(void *)"MonoMethod" + 2B];
        D.24112 = *D.24111;
        D.24113 = (int) D.24112;
        D.24114 = __s2 + 2;
        D.24115 = *D.24114;
        D.24116 = (int) D.24115;
        __result = D.24113 - D.24116;
        if (__s2_len > 2) goto <D.24117>; else goto <D.24118>;
        <D.24117>:
        if (__result == 0) goto <D.24119>; else goto <D.24120>;
        <D.24119>:
        D.24121 = &MEM[(void *)"MonoMethod" + 3B];
        D.24122 = *D.24121;
        D.24123 = (int) D.24122;
        D.24124 = __s2 + 3;
        D.24125 = *D.24124;
        D.24126 = (int) D.24125;
        __result = D.24123 - D.24126;
        <D.24120>:
        <D.24118>:
        <D.24110>:
        <D.24108>:
        <D.24100>:
        <D.24098>:
      }
      D.19715 = __result;
    }
    iftmp.8 = -D.19715;
    goto <D.24127>;
    <D.24091>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.8 = __builtin_strcmp (D.23953, "MonoMethod");
    <D.24127>:
    D.19716 = iftmp.8;
  }
  if (D.19716 == 0) goto <D.24086>; else goto <D.24128>;
  <D.24128>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24132 = "MonoCMethod";
      D.24133 = MEM[(const unsigned char *)D.24132];
      D.24134 = (int) D.24133;
      D.24135 = *__s2;
      D.24136 = (int) D.24135;
      __result = D.24134 - D.24136;
      {
        if (__s2_len != 0) goto <D.24137>; else goto <D.24138>;
        <D.24137>:
        if (__result == 0) goto <D.24139>; else goto <D.24140>;
        <D.24139>:
        D.24141 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24142 = *D.24141;
        D.24143 = (int) D.24142;
        D.24144 = __s2 + 1;
        D.24145 = *D.24144;
        D.24146 = (int) D.24145;
        __result = D.24143 - D.24146;
        if (__s2_len > 1) goto <D.24147>; else goto <D.24148>;
        <D.24147>:
        if (__result == 0) goto <D.24149>; else goto <D.24150>;
        <D.24149>:
        D.24151 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24152 = *D.24151;
        D.24153 = (int) D.24152;
        D.24154 = __s2 + 2;
        D.24155 = *D.24154;
        D.24156 = (int) D.24155;
        __result = D.24153 - D.24156;
        if (__s2_len > 2) goto <D.24157>; else goto <D.24158>;
        <D.24157>:
        if (__result == 0) goto <D.24159>; else goto <D.24160>;
        <D.24159>:
        D.24161 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24162 = *D.24161;
        D.24163 = (int) D.24162;
        D.24164 = __s2 + 3;
        D.24165 = *D.24164;
        D.24166 = (int) D.24165;
        __result = D.24163 - D.24166;
        <D.24160>:
        <D.24158>:
        <D.24150>:
        <D.24148>:
        <D.24140>:
        <D.24138>:
      }
      D.19724 = __result;
    }
    iftmp.9 = -D.19724;
    goto <D.24167>;
    <D.24131>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.9 = __builtin_strcmp (D.23953, "MonoCMethod");
    <D.24167>:
    D.19725 = iftmp.9;
  }
  if (D.19725 == 0) goto <D.24086>; else goto <D.24087>;
  <D.24086>:
  {
    struct MonoMethod * m;

    D.23914 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23914].method;
    D.24168 = assembly->method_to_table_idx;
    D.24169 = monoeg_g_hash_table_lookup (D.24168, m);
    idx = (guint32) D.24169;
  }
  goto <D.24088>;
  <D.24087>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4252);
  <D.24088>:
  <D.24085>:
  <D.24043>:
  goto <D.19688>;
  <D.19727>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24173 = "TypeBuilder";
      D.24174 = MEM[(const unsigned char *)D.24173];
      D.24175 = (int) D.24174;
      D.24176 = *__s2;
      D.24177 = (int) D.24176;
      __result = D.24175 - D.24177;
      {
        if (__s2_len != 0) goto <D.24178>; else goto <D.24179>;
        <D.24178>:
        if (__result == 0) goto <D.24180>; else goto <D.24181>;
        <D.24180>:
        D.24182 = &MEM[(void *)"TypeBuilder" + 1B];
        D.24183 = *D.24182;
        D.24184 = (int) D.24183;
        D.24185 = __s2 + 1;
        D.24186 = *D.24185;
        D.24187 = (int) D.24186;
        __result = D.24184 - D.24187;
        if (__s2_len > 1) goto <D.24188>; else goto <D.24189>;
        <D.24188>:
        if (__result == 0) goto <D.24190>; else goto <D.24191>;
        <D.24190>:
        D.24192 = &MEM[(void *)"TypeBuilder" + 2B];
        D.24193 = *D.24192;
        D.24194 = (int) D.24193;
        D.24195 = __s2 + 2;
        D.24196 = *D.24195;
        D.24197 = (int) D.24196;
        __result = D.24194 - D.24197;
        if (__s2_len > 2) goto <D.24198>; else goto <D.24199>;
        <D.24198>:
        if (__result == 0) goto <D.24200>; else goto <D.24201>;
        <D.24200>:
        D.24202 = &MEM[(void *)"TypeBuilder" + 3B];
        D.24203 = *D.24202;
        D.24204 = (int) D.24203;
        D.24205 = __s2 + 3;
        D.24206 = *D.24205;
        D.24207 = (int) D.24206;
        __result = D.24204 - D.24207;
        <D.24201>:
        <D.24199>:
        <D.24191>:
        <D.24189>:
        <D.24181>:
        <D.24179>:
      }
      D.19735 = __result;
    }
    iftmp.10 = -D.19735;
    goto <D.24208>;
    <D.24172>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.10 = __builtin_strcmp (D.23953, "TypeBuilder");
    <D.24208>:
    D.19736 = iftmp.10;
  }
  if (D.19736 != 0) goto <D.24209>; else goto <D.24210>;
  <D.24209>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4257);
  <D.24210>:
  tb = iltoken->member;
  idx = tb->table_idx;
  goto <D.19688>;
  <D.19737>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24214 = "MonoArrayMethod";
      D.24215 = MEM[(const unsigned char *)D.24214];
      D.24216 = (int) D.24215;
      D.24217 = *__s2;
      D.24218 = (int) D.24217;
      __result = D.24216 - D.24218;
      {
        if (__s2_len != 0) goto <D.24219>; else goto <D.24220>;
        <D.24219>:
        if (__result == 0) goto <D.24221>; else goto <D.24222>;
        <D.24221>:
        D.24223 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.24224 = *D.24223;
        D.24225 = (int) D.24224;
        D.24226 = __s2 + 1;
        D.24227 = *D.24226;
        D.24228 = (int) D.24227;
        __result = D.24225 - D.24228;
        if (__s2_len > 1) goto <D.24229>; else goto <D.24230>;
        <D.24229>:
        if (__result == 0) goto <D.24231>; else goto <D.24232>;
        <D.24231>:
        D.24233 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.24234 = *D.24233;
        D.24235 = (int) D.24234;
        D.24236 = __s2 + 2;
        D.24237 = *D.24236;
        D.24238 = (int) D.24237;
        __result = D.24235 - D.24238;
        if (__s2_len > 2) goto <D.24239>; else goto <D.24240>;
        <D.24239>:
        if (__result == 0) goto <D.24241>; else goto <D.24242>;
        <D.24241>:
        D.24243 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.24244 = *D.24243;
        D.24245 = (int) D.24244;
        D.24246 = __s2 + 3;
        D.24247 = *D.24246;
        D.24248 = (int) D.24247;
        __result = D.24245 - D.24248;
        <D.24242>:
        <D.24240>:
        <D.24232>:
        <D.24230>:
        <D.24222>:
        <D.24220>:
      }
      D.19745 = __result;
    }
    iftmp.11 = -D.19745;
    goto <D.24249>;
    <D.24213>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.11 = __builtin_strcmp (D.23953, "MonoArrayMethod");
    <D.24249>:
    D.19746 = iftmp.11;
  }
  if (D.19746 == 0) goto <D.24250>; else goto <D.24251>;
  <D.24250>:
  am = iltoken->member;
  idx = am->table_idx;
  goto <D.24252>;
  <D.24251>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24092 = "MonoMethod";
      D.24093 = MEM[(const unsigned char *)D.24092];
      D.24094 = (int) D.24093;
      D.24258 = *__s2;
      D.24259 = (int) D.24258;
      __result = D.24094 - D.24259;
      {
        if (__s2_len != 0) goto <D.24260>; else goto <D.24261>;
        <D.24260>:
        if (__result == 0) goto <D.24262>; else goto <D.24263>;
        <D.24262>:
        D.24101 = &MEM[(void *)"MonoMethod" + 1B];
        D.24102 = *D.24101;
        D.24103 = (int) D.24102;
        D.24264 = __s2 + 1;
        D.24265 = *D.24264;
        D.24266 = (int) D.24265;
        __result = D.24103 - D.24266;
        if (__s2_len > 1) goto <D.24267>; else goto <D.24268>;
        <D.24267>:
        if (__result == 0) goto <D.24269>; else goto <D.24270>;
        <D.24269>:
        D.24111 = &MEM[(void *)"MonoMethod" + 2B];
        D.24112 = *D.24111;
        D.24113 = (int) D.24112;
        D.24271 = __s2 + 2;
        D.24272 = *D.24271;
        D.24273 = (int) D.24272;
        __result = D.24113 - D.24273;
        if (__s2_len > 2) goto <D.24274>; else goto <D.24275>;
        <D.24274>:
        if (__result == 0) goto <D.24276>; else goto <D.24277>;
        <D.24276>:
        D.24121 = &MEM[(void *)"MonoMethod" + 3B];
        D.24122 = *D.24121;
        D.24123 = (int) D.24122;
        D.24278 = __s2 + 3;
        D.24279 = *D.24278;
        D.24280 = (int) D.24279;
        __result = D.24123 - D.24280;
        <D.24277>:
        <D.24275>:
        <D.24270>:
        <D.24268>:
        <D.24263>:
        <D.24261>:
      }
      D.19754 = __result;
    }
    iftmp.12 = -D.19754;
    goto <D.24281>;
    <D.24257>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.12 = __builtin_strcmp (D.23953, "MonoMethod");
    <D.24281>:
    D.19755 = iftmp.12;
  }
  if (D.19755 == 0) goto <D.24253>; else goto <D.24282>;
  <D.24282>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24132 = "MonoCMethod";
      D.24133 = MEM[(const unsigned char *)D.24132];
      D.24134 = (int) D.24133;
      D.24286 = *__s2;
      D.24287 = (int) D.24286;
      __result = D.24134 - D.24287;
      {
        if (__s2_len != 0) goto <D.24288>; else goto <D.24289>;
        <D.24288>:
        if (__result == 0) goto <D.24290>; else goto <D.24291>;
        <D.24290>:
        D.24141 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24142 = *D.24141;
        D.24143 = (int) D.24142;
        D.24292 = __s2 + 1;
        D.24293 = *D.24292;
        D.24294 = (int) D.24293;
        __result = D.24143 - D.24294;
        if (__s2_len > 1) goto <D.24295>; else goto <D.24296>;
        <D.24295>:
        if (__result == 0) goto <D.24297>; else goto <D.24298>;
        <D.24297>:
        D.24151 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24152 = *D.24151;
        D.24153 = (int) D.24152;
        D.24299 = __s2 + 2;
        D.24300 = *D.24299;
        D.24301 = (int) D.24300;
        __result = D.24153 - D.24301;
        if (__s2_len > 2) goto <D.24302>; else goto <D.24303>;
        <D.24302>:
        if (__result == 0) goto <D.24304>; else goto <D.24305>;
        <D.24304>:
        D.24161 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24162 = *D.24161;
        D.24163 = (int) D.24162;
        D.24306 = __s2 + 3;
        D.24307 = *D.24306;
        D.24308 = (int) D.24307;
        __result = D.24163 - D.24308;
        <D.24305>:
        <D.24303>:
        <D.24298>:
        <D.24296>:
        <D.24291>:
        <D.24289>:
      }
      D.19763 = __result;
    }
    iftmp.13 = -D.19763;
    goto <D.24309>;
    <D.24285>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.13 = __builtin_strcmp (D.23953, "MonoCMethod");
    <D.24309>:
    D.19764 = iftmp.13;
  }
  if (D.19764 == 0) goto <D.24253>; else goto <D.24310>;
  <D.24310>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24314 = "MonoGenericMethod";
      D.24315 = MEM[(const unsigned char *)D.24314];
      D.24316 = (int) D.24315;
      D.24317 = *__s2;
      D.24318 = (int) D.24317;
      __result = D.24316 - D.24318;
      {
        if (__s2_len != 0) goto <D.24319>; else goto <D.24320>;
        <D.24319>:
        if (__result == 0) goto <D.24321>; else goto <D.24322>;
        <D.24321>:
        D.24323 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24324 = *D.24323;
        D.24325 = (int) D.24324;
        D.24326 = __s2 + 1;
        D.24327 = *D.24326;
        D.24328 = (int) D.24327;
        __result = D.24325 - D.24328;
        if (__s2_len > 1) goto <D.24329>; else goto <D.24330>;
        <D.24329>:
        if (__result == 0) goto <D.24331>; else goto <D.24332>;
        <D.24331>:
        D.24333 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24334 = *D.24333;
        D.24335 = (int) D.24334;
        D.24336 = __s2 + 2;
        D.24337 = *D.24336;
        D.24338 = (int) D.24337;
        __result = D.24335 - D.24338;
        if (__s2_len > 2) goto <D.24339>; else goto <D.24340>;
        <D.24339>:
        if (__result == 0) goto <D.24341>; else goto <D.24342>;
        <D.24341>:
        D.24343 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24344 = *D.24343;
        D.24345 = (int) D.24344;
        D.24346 = __s2 + 3;
        D.24347 = *D.24346;
        D.24348 = (int) D.24347;
        __result = D.24345 - D.24348;
        <D.24342>:
        <D.24340>:
        <D.24332>:
        <D.24330>:
        <D.24322>:
        <D.24320>:
      }
      D.19772 = __result;
    }
    iftmp.14 = -D.19772;
    goto <D.24349>;
    <D.24313>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.14 = __builtin_strcmp (D.23953, "MonoGenericMethod");
    <D.24349>:
    D.19773 = iftmp.14;
  }
  if (D.19773 == 0) goto <D.24253>; else goto <D.24350>;
  <D.24350>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24354 = "MonoGenericCMethod";
      D.24355 = MEM[(const unsigned char *)D.24354];
      D.24356 = (int) D.24355;
      D.24357 = *__s2;
      D.24358 = (int) D.24357;
      __result = D.24356 - D.24358;
      {
        if (__s2_len != 0) goto <D.24359>; else goto <D.24360>;
        <D.24359>:
        if (__result == 0) goto <D.24361>; else goto <D.24362>;
        <D.24361>:
        D.24363 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.24364 = *D.24363;
        D.24365 = (int) D.24364;
        D.24366 = __s2 + 1;
        D.24367 = *D.24366;
        D.24368 = (int) D.24367;
        __result = D.24365 - D.24368;
        if (__s2_len > 1) goto <D.24369>; else goto <D.24370>;
        <D.24369>:
        if (__result == 0) goto <D.24371>; else goto <D.24372>;
        <D.24371>:
        D.24373 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.24374 = *D.24373;
        D.24375 = (int) D.24374;
        D.24376 = __s2 + 2;
        D.24377 = *D.24376;
        D.24378 = (int) D.24377;
        __result = D.24375 - D.24378;
        if (__s2_len > 2) goto <D.24379>; else goto <D.24380>;
        <D.24379>:
        if (__result == 0) goto <D.24381>; else goto <D.24382>;
        <D.24381>:
        D.24383 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.24384 = *D.24383;
        D.24385 = (int) D.24384;
        D.24386 = __s2 + 3;
        D.24387 = *D.24386;
        D.24388 = (int) D.24387;
        __result = D.24385 - D.24388;
        <D.24382>:
        <D.24380>:
        <D.24372>:
        <D.24370>:
        <D.24362>:
        <D.24360>:
      }
      D.19781 = __result;
    }
    iftmp.15 = -D.19781;
    goto <D.24389>;
    <D.24353>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.15 = __builtin_strcmp (D.23953, "MonoGenericCMethod");
    <D.24389>:
    D.19782 = iftmp.15;
  }
  if (D.19782 == 0) goto <D.24253>; else goto <D.24254>;
  <D.24253>:
  {
    struct MonoMethod * m;

    D.23914 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23914].method;
    D.24393 = m->klass;
    D.24394 = D.24393->generic_class;
    if (D.24394 == 0B) goto <D.24395>; else goto <D.24391>;
    <D.24395>:
    D.24393 = m->klass;
    D.24396 = D.24393->generic_container;
    if (D.24396 == 0B) goto <D.24397>; else goto <D.24391>;
    <D.24397>:
    iftmp.16 = 1;
    goto <D.24392>;
    <D.24391>:
    iftmp.16 = 0;
    <D.24392>:
    D.24398 = iftmp.16 != 0;
    D.24399 = (long int) D.24398;
    D.24400 = __builtin_expect (D.24399, 0);
    if (D.24400 != 0) goto <D.24401>; else goto <D.24402>;
    <D.24401>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4270, "m->klass->generic_class || m->klass->generic_container");
    <D.24402>:
    // predicted unlikely by continue predictor.
    goto <D.19784>;
  }
  <D.24254>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.23917 = "FieldBuilder";
      D.23918 = MEM[(const unsigned char *)D.23917];
      D.23919 = (int) D.23918;
      D.24406 = *__s2;
      D.24407 = (int) D.24406;
      __result = D.23919 - D.24407;
      {
        if (__s2_len != 0) goto <D.24408>; else goto <D.24409>;
        <D.24408>:
        if (__result == 0) goto <D.24410>; else goto <D.24411>;
        <D.24410>:
        D.23926 = &MEM[(void *)"FieldBuilder" + 1B];
        D.23927 = *D.23926;
        D.23928 = (int) D.23927;
        D.24412 = __s2 + 1;
        D.24413 = *D.24412;
        D.24414 = (int) D.24413;
        __result = D.23928 - D.24414;
        if (__s2_len > 1) goto <D.24415>; else goto <D.24416>;
        <D.24415>:
        if (__result == 0) goto <D.24417>; else goto <D.24418>;
        <D.24417>:
        D.23936 = &MEM[(void *)"FieldBuilder" + 2B];
        D.23937 = *D.23936;
        D.23938 = (int) D.23937;
        D.24419 = __s2 + 2;
        D.24420 = *D.24419;
        D.24421 = (int) D.24420;
        __result = D.23938 - D.24421;
        if (__s2_len > 2) goto <D.24422>; else goto <D.24423>;
        <D.24422>:
        if (__result == 0) goto <D.24424>; else goto <D.24425>;
        <D.24424>:
        D.23946 = &MEM[(void *)"FieldBuilder" + 3B];
        D.23947 = *D.23946;
        D.23948 = (int) D.23947;
        D.24426 = __s2 + 3;
        D.24427 = *D.24426;
        D.24428 = (int) D.24427;
        __result = D.23948 - D.24428;
        <D.24425>:
        <D.24423>:
        <D.24418>:
        <D.24416>:
        <D.24411>:
        <D.24409>:
      }
      D.19792 = __result;
    }
    iftmp.17 = -D.19792;
    goto <D.24429>;
    <D.24405>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.17 = __builtin_strcmp (D.23953, "FieldBuilder");
    <D.24429>:
    D.19793 = iftmp.17;
  }
  if (D.19793 == 0) goto <D.24430>; else goto <D.24431>;
  <D.24430>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24431>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.23961 = "MonoField";
      D.23962 = MEM[(const unsigned char *)D.23961];
      D.23963 = (int) D.23962;
      D.24435 = *__s2;
      D.24436 = (int) D.24435;
      __result = D.23963 - D.24436;
      {
        if (__s2_len != 0) goto <D.24437>; else goto <D.24438>;
        <D.24437>:
        if (__result == 0) goto <D.24439>; else goto <D.24440>;
        <D.24439>:
        D.23970 = &MEM[(void *)"MonoField" + 1B];
        D.23971 = *D.23970;
        D.23972 = (int) D.23971;
        D.24441 = __s2 + 1;
        D.24442 = *D.24441;
        D.24443 = (int) D.24442;
        __result = D.23972 - D.24443;
        if (__s2_len > 1) goto <D.24444>; else goto <D.24445>;
        <D.24444>:
        if (__result == 0) goto <D.24446>; else goto <D.24447>;
        <D.24446>:
        D.23980 = &MEM[(void *)"MonoField" + 2B];
        D.23981 = *D.23980;
        D.23982 = (int) D.23981;
        D.24448 = __s2 + 2;
        D.24449 = *D.24448;
        D.24450 = (int) D.24449;
        __result = D.23982 - D.24450;
        if (__s2_len > 2) goto <D.24451>; else goto <D.24452>;
        <D.24451>:
        if (__result == 0) goto <D.24453>; else goto <D.24454>;
        <D.24453>:
        D.23990 = &MEM[(void *)"MonoField" + 3B];
        D.23991 = *D.23990;
        D.23992 = (int) D.23991;
        D.24455 = __s2 + 3;
        D.24456 = *D.24455;
        D.24457 = (int) D.24456;
        __result = D.23992 - D.24457;
        <D.24454>:
        <D.24452>:
        <D.24447>:
        <D.24445>:
        <D.24440>:
        <D.24438>:
      }
      D.19801 = __result;
    }
    iftmp.18 = -D.19801;
    goto <D.24458>;
    <D.24434>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.18 = __builtin_strcmp (D.23953, "MonoField");
    <D.24458>:
    D.19802 = iftmp.18;
  }
  if (D.19802 == 0) goto <D.24459>; else goto <D.24460>;
  <D.24459>:
  {
    struct MonoClassField * f;

    D.23914 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.23914].field;
    D.24461 = is_field_on_inst (f);
    D.24462 = D.24461 == 0;
    D.24463 = (long int) D.24462;
    D.24464 = __builtin_expect (D.24463, 0);
    if (D.24464 != 0) goto <D.24465>; else goto <D.24466>;
    <D.24465>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4276, "is_field_on_inst (f)");
    <D.24466>:
    // predicted unlikely by continue predictor.
    goto <D.19784>;
  }
  <D.24460>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24005 = "MethodBuilder";
      D.24006 = MEM[(const unsigned char *)D.24005];
      D.24007 = (int) D.24006;
      D.24472 = *__s2;
      D.24473 = (int) D.24472;
      __result = D.24007 - D.24473;
      {
        if (__s2_len != 0) goto <D.24474>; else goto <D.24475>;
        <D.24474>:
        if (__result == 0) goto <D.24476>; else goto <D.24477>;
        <D.24476>:
        D.24014 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24015 = *D.24014;
        D.24016 = (int) D.24015;
        D.24478 = __s2 + 1;
        D.24479 = *D.24478;
        D.24480 = (int) D.24479;
        __result = D.24016 - D.24480;
        if (__s2_len > 1) goto <D.24481>; else goto <D.24482>;
        <D.24481>:
        if (__result == 0) goto <D.24483>; else goto <D.24484>;
        <D.24483>:
        D.24024 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24025 = *D.24024;
        D.24026 = (int) D.24025;
        D.24485 = __s2 + 2;
        D.24486 = *D.24485;
        D.24487 = (int) D.24486;
        __result = D.24026 - D.24487;
        if (__s2_len > 2) goto <D.24488>; else goto <D.24489>;
        <D.24488>:
        if (__result == 0) goto <D.24490>; else goto <D.24491>;
        <D.24490>:
        D.24034 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24035 = *D.24034;
        D.24036 = (int) D.24035;
        D.24492 = __s2 + 3;
        D.24493 = *D.24492;
        D.24494 = (int) D.24493;
        __result = D.24036 - D.24494;
        <D.24491>:
        <D.24489>:
        <D.24484>:
        <D.24482>:
        <D.24477>:
        <D.24475>:
      }
      D.19811 = __result;
    }
    iftmp.19 = -D.19811;
    goto <D.24495>;
    <D.24471>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.19 = __builtin_strcmp (D.23953, "MethodBuilder");
    <D.24495>:
    D.19812 = iftmp.19;
  }
  if (D.19812 == 0) goto <D.24467>; else goto <D.24496>;
  <D.24496>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24047 = "ConstructorBuilder";
      D.24048 = MEM[(const unsigned char *)D.24047];
      D.24049 = (int) D.24048;
      D.24500 = *__s2;
      D.24501 = (int) D.24500;
      __result = D.24049 - D.24501;
      {
        if (__s2_len != 0) goto <D.24502>; else goto <D.24503>;
        <D.24502>:
        if (__result == 0) goto <D.24504>; else goto <D.24505>;
        <D.24504>:
        D.24056 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24057 = *D.24056;
        D.24058 = (int) D.24057;
        D.24506 = __s2 + 1;
        D.24507 = *D.24506;
        D.24508 = (int) D.24507;
        __result = D.24058 - D.24508;
        if (__s2_len > 1) goto <D.24509>; else goto <D.24510>;
        <D.24509>:
        if (__result == 0) goto <D.24511>; else goto <D.24512>;
        <D.24511>:
        D.24066 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24067 = *D.24066;
        D.24068 = (int) D.24067;
        D.24513 = __s2 + 2;
        D.24514 = *D.24513;
        D.24515 = (int) D.24514;
        __result = D.24068 - D.24515;
        if (__s2_len > 2) goto <D.24516>; else goto <D.24517>;
        <D.24516>:
        if (__result == 0) goto <D.24518>; else goto <D.24519>;
        <D.24518>:
        D.24076 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24077 = *D.24076;
        D.24078 = (int) D.24077;
        D.24520 = __s2 + 3;
        D.24521 = *D.24520;
        D.24522 = (int) D.24521;
        __result = D.24078 - D.24522;
        <D.24519>:
        <D.24517>:
        <D.24512>:
        <D.24510>:
        <D.24505>:
        <D.24503>:
      }
      D.19820 = __result;
    }
    iftmp.20 = -D.19820;
    goto <D.24523>;
    <D.24499>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.20 = __builtin_strcmp (D.23953, "ConstructorBuilder");
    <D.24523>:
    D.19821 = iftmp.20;
  }
  if (D.19821 == 0) goto <D.24467>; else goto <D.24468>;
  <D.24467>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24468>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24527 = "FieldOnTypeBuilderInst";
      D.24528 = MEM[(const unsigned char *)D.24527];
      D.24529 = (int) D.24528;
      D.24530 = *__s2;
      D.24531 = (int) D.24530;
      __result = D.24529 - D.24531;
      {
        if (__s2_len != 0) goto <D.24532>; else goto <D.24533>;
        <D.24532>:
        if (__result == 0) goto <D.24534>; else goto <D.24535>;
        <D.24534>:
        D.24536 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.24537 = *D.24536;
        D.24538 = (int) D.24537;
        D.24539 = __s2 + 1;
        D.24540 = *D.24539;
        D.24541 = (int) D.24540;
        __result = D.24538 - D.24541;
        if (__s2_len > 1) goto <D.24542>; else goto <D.24543>;
        <D.24542>:
        if (__result == 0) goto <D.24544>; else goto <D.24545>;
        <D.24544>:
        D.24546 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.24547 = *D.24546;
        D.24548 = (int) D.24547;
        D.24549 = __s2 + 2;
        D.24550 = *D.24549;
        D.24551 = (int) D.24550;
        __result = D.24548 - D.24551;
        if (__s2_len > 2) goto <D.24552>; else goto <D.24553>;
        <D.24552>:
        if (__result == 0) goto <D.24554>; else goto <D.24555>;
        <D.24554>:
        D.24556 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.24557 = *D.24556;
        D.24558 = (int) D.24557;
        D.24559 = __s2 + 3;
        D.24560 = *D.24559;
        D.24561 = (int) D.24560;
        __result = D.24558 - D.24561;
        <D.24555>:
        <D.24553>:
        <D.24545>:
        <D.24543>:
        <D.24535>:
        <D.24533>:
      }
      D.19829 = __result;
    }
    iftmp.21 = -D.19829;
    goto <D.24562>;
    <D.24526>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.21 = __builtin_strcmp (D.23953, "FieldOnTypeBuilderInst");
    <D.24562>:
    D.19830 = iftmp.21;
  }
  if (D.19830 == 0) goto <D.24563>; else goto <D.24564>;
  <D.24563>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24564>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24568 = "MethodOnTypeBuilderInst";
      D.24569 = MEM[(const unsigned char *)D.24568];
      D.24570 = (int) D.24569;
      D.24571 = *__s2;
      D.24572 = (int) D.24571;
      __result = D.24570 - D.24572;
      {
        if (__s2_len != 0) goto <D.24573>; else goto <D.24574>;
        <D.24573>:
        if (__result == 0) goto <D.24575>; else goto <D.24576>;
        <D.24575>:
        D.24577 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24578 = *D.24577;
        D.24579 = (int) D.24578;
        D.24580 = __s2 + 1;
        D.24581 = *D.24580;
        D.24582 = (int) D.24581;
        __result = D.24579 - D.24582;
        if (__s2_len > 1) goto <D.24583>; else goto <D.24584>;
        <D.24583>:
        if (__result == 0) goto <D.24585>; else goto <D.24586>;
        <D.24585>:
        D.24587 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.24588 = *D.24587;
        D.24589 = (int) D.24588;
        D.24590 = __s2 + 2;
        D.24591 = *D.24590;
        D.24592 = (int) D.24591;
        __result = D.24589 - D.24592;
        if (__s2_len > 2) goto <D.24593>; else goto <D.24594>;
        <D.24593>:
        if (__result == 0) goto <D.24595>; else goto <D.24596>;
        <D.24595>:
        D.24597 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.24598 = *D.24597;
        D.24599 = (int) D.24598;
        D.24600 = __s2 + 3;
        D.24601 = *D.24600;
        D.24602 = (int) D.24601;
        __result = D.24599 - D.24602;
        <D.24596>:
        <D.24594>:
        <D.24586>:
        <D.24584>:
        <D.24576>:
        <D.24574>:
      }
      D.19838 = __result;
    }
    iftmp.22 = -D.19838;
    goto <D.24603>;
    <D.24567>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.22 = __builtin_strcmp (D.23953, "MethodOnTypeBuilderInst");
    <D.24603>:
    D.19839 = iftmp.22;
  }
  if (D.19839 == 0) goto <D.24604>; else goto <D.24605>;
  <D.24604>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24605>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24609 = "ConstructorOnTypeBuilderInst";
      D.24610 = MEM[(const unsigned char *)D.24609];
      D.24611 = (int) D.24610;
      D.24612 = *__s2;
      D.24613 = (int) D.24612;
      __result = D.24611 - D.24613;
      {
        if (__s2_len != 0) goto <D.24614>; else goto <D.24615>;
        <D.24614>:
        if (__result == 0) goto <D.24616>; else goto <D.24617>;
        <D.24616>:
        D.24618 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.24619 = *D.24618;
        D.24620 = (int) D.24619;
        D.24621 = __s2 + 1;
        D.24622 = *D.24621;
        D.24623 = (int) D.24622;
        __result = D.24620 - D.24623;
        if (__s2_len > 1) goto <D.24624>; else goto <D.24625>;
        <D.24624>:
        if (__result == 0) goto <D.24626>; else goto <D.24627>;
        <D.24626>:
        D.24628 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.24629 = *D.24628;
        D.24630 = (int) D.24629;
        D.24631 = __s2 + 2;
        D.24632 = *D.24631;
        D.24633 = (int) D.24632;
        __result = D.24630 - D.24633;
        if (__s2_len > 2) goto <D.24634>; else goto <D.24635>;
        <D.24634>:
        if (__result == 0) goto <D.24636>; else goto <D.24637>;
        <D.24636>:
        D.24638 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.24639 = *D.24638;
        D.24640 = (int) D.24639;
        D.24641 = __s2 + 3;
        D.24642 = *D.24641;
        D.24643 = (int) D.24642;
        __result = D.24640 - D.24643;
        <D.24637>:
        <D.24635>:
        <D.24627>:
        <D.24625>:
        <D.24617>:
        <D.24615>:
      }
      D.19847 = __result;
    }
    iftmp.23 = -D.19847;
    goto <D.24644>;
    <D.24608>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.23 = __builtin_strcmp (D.23953, "ConstructorOnTypeBuilderInst");
    <D.24644>:
    D.19848 = iftmp.23;
  }
  if (D.19848 == 0) goto <D.24645>; else goto <D.24646>;
  <D.24645>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24646>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4288);
  <D.24252>:
  goto <D.19688>;
  <D.19849>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24314 = "MonoGenericMethod";
      D.24315 = MEM[(const unsigned char *)D.24314];
      D.24316 = (int) D.24315;
      D.24650 = *__s2;
      D.24651 = (int) D.24650;
      __result = D.24316 - D.24651;
      {
        if (__s2_len != 0) goto <D.24652>; else goto <D.24653>;
        <D.24652>:
        if (__result == 0) goto <D.24654>; else goto <D.24655>;
        <D.24654>:
        D.24323 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24324 = *D.24323;
        D.24325 = (int) D.24324;
        D.24656 = __s2 + 1;
        D.24657 = *D.24656;
        D.24658 = (int) D.24657;
        __result = D.24325 - D.24658;
        if (__s2_len > 1) goto <D.24659>; else goto <D.24660>;
        <D.24659>:
        if (__result == 0) goto <D.24661>; else goto <D.24662>;
        <D.24661>:
        D.24333 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24334 = *D.24333;
        D.24335 = (int) D.24334;
        D.24663 = __s2 + 2;
        D.24664 = *D.24663;
        D.24665 = (int) D.24664;
        __result = D.24335 - D.24665;
        if (__s2_len > 2) goto <D.24666>; else goto <D.24667>;
        <D.24666>:
        if (__result == 0) goto <D.24668>; else goto <D.24669>;
        <D.24668>:
        D.24343 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24344 = *D.24343;
        D.24345 = (int) D.24344;
        D.24670 = __s2 + 3;
        D.24671 = *D.24670;
        D.24672 = (int) D.24671;
        __result = D.24345 - D.24672;
        <D.24669>:
        <D.24667>:
        <D.24662>:
        <D.24660>:
        <D.24655>:
        <D.24653>:
      }
      D.19857 = __result;
    }
    iftmp.24 = -D.19857;
    goto <D.24673>;
    <D.24649>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.24 = __builtin_strcmp (D.23953, "MonoGenericMethod");
    <D.24673>:
    D.19858 = iftmp.24;
  }
  if (D.19858 == 0) goto <D.24674>; else goto <D.24675>;
  <D.24674>:
  {
    struct MonoMethod * m;

    D.23914 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23914].method;
    D.24676 = mono_method_signature (m);
    D.24677 = D.24676->generic_param_count;
    D.24678 = D.24677 == 0;
    D.24679 = (long int) D.24678;
    D.24680 = __builtin_expect (D.24679, 0);
    if (D.24680 != 0) goto <D.24681>; else goto <D.24682>;
    <D.24681>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4294, "mono_method_signature (m)->generic_param_count");
    <D.24682>:
    // predicted unlikely by continue predictor.
    goto <D.19784>;
  }
  <D.24675>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24005 = "MethodBuilder";
      D.24006 = MEM[(const unsigned char *)D.24005];
      D.24007 = (int) D.24006;
      D.24686 = *__s2;
      D.24687 = (int) D.24686;
      __result = D.24007 - D.24687;
      {
        if (__s2_len != 0) goto <D.24688>; else goto <D.24689>;
        <D.24688>:
        if (__result == 0) goto <D.24690>; else goto <D.24691>;
        <D.24690>:
        D.24014 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24015 = *D.24014;
        D.24016 = (int) D.24015;
        D.24692 = __s2 + 1;
        D.24693 = *D.24692;
        D.24694 = (int) D.24693;
        __result = D.24016 - D.24694;
        if (__s2_len > 1) goto <D.24695>; else goto <D.24696>;
        <D.24695>:
        if (__result == 0) goto <D.24697>; else goto <D.24698>;
        <D.24697>:
        D.24024 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24025 = *D.24024;
        D.24026 = (int) D.24025;
        D.24699 = __s2 + 2;
        D.24700 = *D.24699;
        D.24701 = (int) D.24700;
        __result = D.24026 - D.24701;
        if (__s2_len > 2) goto <D.24702>; else goto <D.24703>;
        <D.24702>:
        if (__result == 0) goto <D.24704>; else goto <D.24705>;
        <D.24704>:
        D.24034 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24035 = *D.24034;
        D.24036 = (int) D.24035;
        D.24706 = __s2 + 3;
        D.24707 = *D.24706;
        D.24708 = (int) D.24707;
        __result = D.24036 - D.24708;
        <D.24705>:
        <D.24703>:
        <D.24698>:
        <D.24696>:
        <D.24691>:
        <D.24689>:
      }
      D.19867 = __result;
    }
    iftmp.25 = -D.19867;
    goto <D.24709>;
    <D.24685>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.25 = __builtin_strcmp (D.23953, "MethodBuilder");
    <D.24709>:
    D.19868 = iftmp.25;
  }
  if (D.19868 == 0) goto <D.24710>; else goto <D.24711>;
  <D.24710>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24711>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23914 = iltoken->member;
      D.23915 = D.23914->vtable;
      D.23916 = D.23915->klass;
      __s2 = D.23916->name;
      D.24568 = "MethodOnTypeBuilderInst";
      D.24569 = MEM[(const unsigned char *)D.24568];
      D.24570 = (int) D.24569;
      D.24715 = *__s2;
      D.24716 = (int) D.24715;
      __result = D.24570 - D.24716;
      {
        if (__s2_len != 0) goto <D.24717>; else goto <D.24718>;
        <D.24717>:
        if (__result == 0) goto <D.24719>; else goto <D.24720>;
        <D.24719>:
        D.24577 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24578 = *D.24577;
        D.24579 = (int) D.24578;
        D.24721 = __s2 + 1;
        D.24722 = *D.24721;
        D.24723 = (int) D.24722;
        __result = D.24579 - D.24723;
        if (__s2_len > 1) goto <D.24724>; else goto <D.24725>;
        <D.24724>:
        if (__result == 0) goto <D.24726>; else goto <D.24727>;
        <D.24726>:
        D.24587 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.24588 = *D.24587;
        D.24589 = (int) D.24588;
        D.24728 = __s2 + 2;
        D.24729 = *D.24728;
        D.24730 = (int) D.24729;
        __result = D.24589 - D.24730;
        if (__s2_len > 2) goto <D.24731>; else goto <D.24732>;
        <D.24731>:
        if (__result == 0) goto <D.24733>; else goto <D.24734>;
        <D.24733>:
        D.24597 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.24598 = *D.24597;
        D.24599 = (int) D.24598;
        D.24735 = __s2 + 3;
        D.24736 = *D.24735;
        D.24737 = (int) D.24736;
        __result = D.24599 - D.24737;
        <D.24734>:
        <D.24732>:
        <D.24727>:
        <D.24725>:
        <D.24720>:
        <D.24718>:
      }
      D.19876 = __result;
    }
    iftmp.26 = -D.19876;
    goto <D.24738>;
    <D.24714>:
    D.23914 = iltoken->member;
    D.23915 = D.23914->vtable;
    D.23916 = D.23915->klass;
    D.23953 = D.23916->name;
    iftmp.26 = __builtin_strcmp (D.23953, "MethodOnTypeBuilderInst");
    <D.24738>:
    D.19877 = iftmp.26;
  }
  if (D.19877 == 0) goto <D.24739>; else goto <D.24740>;
  <D.24739>:
  // predicted unlikely by continue predictor.
  goto <D.19784>;
  <D.24740>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4301);
  <D.19878>:
  D.23908 = target + 3;
  D.23909 = *D.23908;
  D.23910 = (int) D.23909;
  monoeg_g_log (0B, 4, "got unexpected table 0x%02x in fixup", D.23910);
  <D.19879>:
  goto <D.19879>;
  <D.19688>:
  D.24741 = (unsigned char) idx;
  *target = D.24741;
  D.24742 = target + 1;
  D.24743 = idx >> 8;
  D.24744 = (unsigned char) D.24743;
  *D.24742 = D.24744;
  D.24745 = target + 2;
  D.24746 = idx >> 16;
  D.24747 = (unsigned char) D.24746;
  *D.24745 = D.24747;
  <D.19784>:
  i = i + 1;
  <D.19881>:
  D.24748 = ilgen->num_token_fixups;
  D.24749 = (unsigned int) D.24748;
  if (D.24749 > i) goto <D.19880>; else goto <D.19882>;
  <D.19882>:
}


is_field_on_inst (struct MonoClassField * field)
{
  gboolean D.24750;
  int iftmp.27;
  struct MonoClass * D.24754;
  struct MonoGenericClass * D.24755;
  unsigned int D.24757;
  unsigned int D.24758;
  struct MonoClassField * D.24760;

  D.24754 = field->parent;
  D.24755 = D.24754->generic_class;
  if (D.24755 != 0B) goto <D.24756>; else goto <D.24752>;
  <D.24756>:
  D.24754 = field->parent;
  D.24755 = D.24754->generic_class;
  D.24757 = BIT_FIELD_REF <*D.24755, 32, 96>;
  D.24758 = D.24757 & 1;
  if (D.24758 != 0) goto <D.24759>; else goto <D.24752>;
  <D.24759>:
  D.24754 = field->parent;
  D.24755 = D.24754->generic_class;
  D.24760 = MEM[(struct MonoDynamicGenericClass *)D.24755].fields;
  if (D.24760 != 0B) goto <D.24761>; else goto <D.24752>;
  <D.24761>:
  iftmp.27 = 1;
  goto <D.24753>;
  <D.24752>:
  iftmp.27 = 0;
  <D.24753>:
  D.24750 = iftmp.27;
  return D.24750;
}


compare_types_by_table_idx (struct MonoReflectionTypeBuilder * * type1, struct MonoReflectionTypeBuilder * * type2)
{
  struct MonoReflectionTypeBuilder * D.24763;
  unsigned int D.24764;
  struct MonoReflectionTypeBuilder * D.24765;
  unsigned int D.24766;
  gint D.24769;

  D.24763 = *type1;
  D.24764 = D.24763->table_idx;
  D.24765 = *type2;
  D.24766 = D.24765->table_idx;
  if (D.24764 < D.24766) goto <D.24767>; else goto <D.24768>;
  <D.24767>:
  D.24769 = -1;
  return D.24769;
  <D.24768>:
  D.24763 = *type1;
  D.24764 = D.24763->table_idx;
  D.24765 = *type2;
  D.24766 = D.24765->table_idx;
  if (D.24764 > D.24766) goto <D.24770>; else goto <D.24771>;
  <D.24770>:
  D.24769 = 1;
  return D.24769;
  <D.24771>:
  D.24769 = 0;
  return D.24769;
}


mono_image_emit_manifest (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.24773;
  guint32 * D.24774;
  guint32 iftmp.28;
  unsigned int D.24776;
  guint32 * D.24780;
  struct MonoDynamicStream * D.24781;
  struct MonoString * D.24782;
  unsigned int D.24783;
  struct MonoString * D.24784;
  guint32 * D.24787;
  unsigned int D.24788;
  unsigned int D.24790;
  guint32 * D.24791;
  struct MonoArray * D.24792;
  unsigned int D.24793;
  guint32 * D.24794;
  unsigned int D.24795;
  struct MonoString * D.24796;
  struct MonoArray * D.24797;
  unsigned int i.29;
  char * D.24799;
  struct MonoArray * D.24802;
  unsigned int j.30;
  char * D.24806;
  int D.24807;
  unsigned int D.24808;
  struct MonoArray * D.24809;
  char * D.24812;
  unsigned int D.24813;
  struct MonoArray * D.24814;
  char * D.24817;
  struct MonoArray * D.24820;
  unsigned int D.24823;
  unsigned int j.31;
  unsigned int D.24825;
  unsigned int D.24826;
  struct MonoDynamicTable * table;
  struct MonoDynamicImage * assembly;
  struct MonoReflectionAssemblyBuilder * assemblyb;
  struct MonoDomain * domain;
  guint32 * values;
  int i;
  guint32 module_index;

  assemblyb = moduleb->assemblyb;
  assembly = moduleb->dynamic_image;
  D.24773 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.24773->domain;
  table = &assembly->tables[32];
  alloc_table (table, 1);
  D.24774 = table->values;
  values = D.24774 + 36;
  D.24776 = assemblyb->algid;
  if (D.24776 != 0) goto <D.24777>; else goto <D.24778>;
  <D.24777>:
  iftmp.28 = assemblyb->algid;
  goto <D.24779>;
  <D.24778>:
  iftmp.28 = 32772;
  <D.24779>:
  *values = iftmp.28;
  D.24780 = values + 28;
  D.24781 = &assembly->sheap;
  D.24782 = assemblyb->name;
  D.24783 = string_heap_insert_mstring (D.24781, D.24782);
  *D.24780 = D.24783;
  D.24784 = assemblyb->culture;
  if (D.24784 != 0B) goto <D.24785>; else goto <D.24786>;
  <D.24785>:
  D.24787 = values + 32;
  D.24781 = &assembly->sheap;
  D.24784 = assemblyb->culture;
  D.24788 = string_heap_insert_mstring (D.24781, D.24784);
  *D.24787 = D.24788;
  goto <D.24789>;
  <D.24786>:
  D.24787 = values + 32;
  D.24781 = &assembly->sheap;
  D.24790 = string_heap_insert (D.24781, "");
  *D.24787 = D.24790;
  <D.24789>:
  D.24791 = values + 24;
  D.24792 = assemblyb->public_key;
  D.24793 = load_public_key (D.24792, assembly);
  *D.24791 = D.24793;
  D.24794 = values + 20;
  D.24795 = assemblyb->flags;
  *D.24794 = D.24795;
  D.24796 = assemblyb->version;
  set_version_from_string (D.24796, values);
  module_index = 0;
  i = 0;
  goto <D.19980>;
  <D.19979>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.24797 = assemblyb->modules;
    i.29 = (unsigned int) i;
    D.24799 = mono_array_addr_with_size (D.24797, 4, i.29);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.24799];
    if (file_module != moduleb) goto <D.24800>; else goto <D.24801>;
    <D.24800>:
    mono_image_fill_file_table (domain, file_module, assembly);
    module_index = module_index + 1;
    D.24802 = file_module->types;
    if (D.24802 != 0B) goto <D.24803>; else goto <D.24804>;
    <D.24803>:
    j = 0;
    goto <D.19977>;
    <D.19976>:
    {
      struct MonoReflectionTypeBuilder * tb;

      D.24802 = file_module->types;
      j.30 = (unsigned int) j;
      D.24806 = mono_array_addr_with_size (D.24802, 4, j.30);
      tb = MEM[(struct MonoReflectionTypeBuilder * *)D.24806];
      mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
    }
    j = j + 1;
    <D.19977>:
    D.24807 = file_module->num_types;
    if (D.24807 > j) goto <D.19976>; else goto <D.19978>;
    <D.19978>:
    <D.24804>:
    <D.24801>:
  }
  i = i + 1;
  <D.19980>:
  i.29 = (unsigned int) i;
  D.24797 = assemblyb->modules;
  D.24808 = mono_array_length (D.24797);
  if (i.29 < D.24808) goto <D.19979>; else goto <D.19981>;
  <D.19981>:
  D.24809 = assemblyb->loaded_modules;
  if (D.24809 != 0B) goto <D.24810>; else goto <D.24811>;
  <D.24810>:
  i = 0;
  goto <D.19984>;
  <D.19983>:
  {
    struct MonoReflectionModule * file_module;

    D.24809 = assemblyb->loaded_modules;
    i.29 = (unsigned int) i;
    D.24812 = mono_array_addr_with_size (D.24809, 4, i.29);
    file_module = MEM[(struct MonoReflectionModule * *)D.24812];
    mono_image_fill_file_table (domain, file_module, assembly);
    module_index = module_index + 1;
    mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
  }
  i = i + 1;
  <D.19984>:
  i.29 = (unsigned int) i;
  D.24809 = assemblyb->loaded_modules;
  D.24813 = mono_array_length (D.24809);
  if (i.29 < D.24813) goto <D.19983>; else goto <D.19985>;
  <D.19985>:
  <D.24811>:
  D.24814 = assemblyb->type_forwarders;
  if (D.24814 != 0B) goto <D.24815>; else goto <D.24816>;
  <D.24815>:
  mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
  <D.24816>:
  module_index = 0;
  i = 0;
  goto <D.19994>;
  <D.19993>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.24797 = assemblyb->modules;
    i.29 = (unsigned int) i;
    D.24817 = mono_array_addr_with_size (D.24797, 4, i.29);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.24817];
    if (file_module != moduleb) goto <D.24818>; else goto <D.24819>;
    <D.24818>:
    module_index = module_index + 1;
    D.24820 = file_module->resources;
    if (D.24820 != 0B) goto <D.24821>; else goto <D.24822>;
    <D.24821>:
    {
      int len;

      D.24820 = file_module->resources;
      D.24823 = mono_array_length (D.24820);
      len = (int) D.24823;
      j = 0;
      goto <D.19991>;
      <D.19990>:
      {
        struct MonoReflectionResource * res;

        D.24820 = file_module->resources;
        j.31 = (unsigned int) j;
        res = mono_array_addr_with_size (D.24820, 24, j.31);
        D.24825 = module_index << 2;
        assembly_add_resource_manifest (file_module, assembly, res, D.24825);
      }
      j = j + 1;
      <D.19991>:
      if (j < len) goto <D.19990>; else goto <D.19992>;
      <D.19992>:
    }
    <D.24822>:
    <D.24819>:
  }
  i = i + 1;
  <D.19994>:
  i.29 = (unsigned int) i;
  D.24797 = assemblyb->modules;
  D.24826 = mono_array_length (D.24797);
  if (i.29 < D.24826) goto <D.19993>; else goto <D.19995>;
  <D.19995>:
}


load_public_key (struct MonoArray * pkey, struct MonoDynamicImage * assembly)
{
  guint32 D.24829;
  char * b.32;
  struct MonoDynamicStream * D.24831;
  int b.33;
  int blob_size.34;
  int D.24834;
  unsigned int D.24835;
  char * D.24836;
  void * D.24837;
  guint8 * D.24838;
  char * D.24839;
  int len.35;
  char * D.24844;
  int D.24845;
  unsigned int D.24849;
  unsigned int D.24851;
  int D.24852;
  unsigned int D.24853;
  void * D.24854;
  gsize len;
  guint32 token;
  char blob_size[6];
  char * b;

  try
    {
      token = 0;
      b = &blob_size;
      if (pkey == 0B) goto <D.24827>; else goto <D.24828>;
      <D.24827>:
      D.24829 = token;
      return D.24829;
      <D.24828>:
      len = mono_array_length (pkey);
      b.32 = b;
      mono_metadata_encode_value (len, b.32, &b);
      D.24831 = &assembly->blob;
      b.32 = b;
      b.33 = (int) b.32;
      blob_size.34 = (int) &blob_size;
      D.24834 = b.33 - blob_size.34;
      D.24835 = (unsigned int) D.24834;
      token = mono_image_add_stream_data (D.24831, &blob_size, D.24835);
      D.24831 = &assembly->blob;
      D.24836 = mono_array_addr_with_size (pkey, 1, 0);
      mono_image_add_stream_data (D.24831, D.24836, len);
      D.24837 = monoeg_malloc (len);
      assembly->public_key = D.24837;
      D.24838 = assembly->public_key;
      D.24839 = mono_array_addr_with_size (pkey, 1, 0);
      memcpy (D.24838, D.24839, len);
      len.35 = (int) len;
      assembly->public_key_len = len.35;
      if (len == 16) goto <D.24843>; else goto <D.24841>;
      <D.24843>:
      D.24844 = mono_array_addr_with_size (pkey, 1, 0);
      len.35 = (int) len;
      D.24845 = mono_is_ecma_key (D.24844, len.35);
      if (D.24845 != 0) goto <D.24846>; else goto <D.24841>;
      <D.24846>:
      assembly->strong_name_size = 128;
      goto <D.24842>;
      <D.24841>:
      if (len > 79) goto <D.24847>; else goto <D.24848>;
      <D.24847>:
      D.24849 = len + 4294967264;
      assembly->strong_name_size = D.24849;
      goto <D.24850>;
      <D.24848>:
      D.24849 = len + 4294967264;
      D.24851 = D.24849 << 3;
      D.24852 = (int) D.24851;
      len.35 = (int) len;
      monoeg_g_log (0B, 16, "Invalid public key length: %d bits (total: %d)", D.24852, len.35);
      assembly->strong_name_size = 128;
      <D.24850>:
      <D.24842>:
      D.24853 = assembly->strong_name_size;
      D.24854 = monoeg_malloc0 (D.24853);
      assembly->strong_name = D.24854;
      D.24829 = token;
      return D.24829;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.24857;
  unsigned int D.24858;
  int D.24859;
  char * D.24860;
  char * D.24861;
  guint32 D.24862;
  guint32 idx;

  D.24857 = stream->index;
  D.24858 = D.24857 + len;
  D.24859 = (int) D.24858;
  make_room_in_stream (stream, D.24859);
  D.24860 = stream->data;
  D.24857 = stream->index;
  D.24861 = D.24860 + D.24857;
  memcpy (D.24861, data, len);
  idx = stream->index;
  D.24857 = stream->index;
  D.24858 = D.24857 + len;
  stream->index = D.24858;
  D.24862 = idx;
  return D.24862;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.36;
  unsigned int D.24865;
  unsigned int D.24871;
  char * D.24872;
  void * D.24873;

  size.36 = (unsigned int) size;
  D.24865 = stream->alloc_size;
  if (size.36 <= D.24865) goto <D.24866>; else goto <D.24867>;
  <D.24866>:
  return;
  <D.24867>:
  goto <D.18317>;
  <D.18316>:
  D.24865 = stream->alloc_size;
  if (D.24865 <= 4095) goto <D.24868>; else goto <D.24869>;
  <D.24868>:
  stream->alloc_size = 4096;
  goto <D.24870>;
  <D.24869>:
  D.24865 = stream->alloc_size;
  D.24871 = D.24865 * 2;
  stream->alloc_size = D.24871;
  <D.24870>:
  <D.18317>:
  D.24865 = stream->alloc_size;
  size.36 = (unsigned int) size;
  if (D.24865 <= size.36) goto <D.18316>; else goto <D.18318>;
  <D.18318>:
  D.24872 = stream->data;
  D.24865 = stream->alloc_size;
  D.24873 = monoeg_realloc (D.24872, D.24865);
  stream->data = D.24873;
}


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

  D.24876 = __builtin_object_size (__dest, 0);
  D.24875 = __builtin___memcpy_chk (__dest, __src, __len, D.24876);
  return D.24875;
}


set_version_from_string (struct MonoString * version, guint32 * values)
{
  guint32 * D.24878;
  guint32 * D.24879;
  guint32 * D.24880;
  guint32 * D.24881;
  unsigned int D.24884;
  unsigned int D.24885;
  guint32 * D.24886;
  long int D.24887;
  unsigned int D.24888;
  gchar * p.37;
  char D.24890;
  int D.24891;
  gchar * p.38;
  gchar * ver;
  gchar * p;
  gchar * str;
  guint32 i;

  try
    {
      D.24878 = values + 4;
      *D.24878 = 0;
      D.24879 = values + 8;
      *D.24879 = 0;
      D.24880 = values + 16;
      *D.24880 = 0;
      D.24881 = values + 12;
      *D.24881 = 0;
      if (version == 0B) goto <D.24882>; else goto <D.24883>;
      <D.24882>:
      return;
      <D.24883>:
      str = mono_string_to_utf8 (version);
      ver = str;
      i = 0;
      goto <D.19953>;
      <D.19952>:
      D.24884 = i + 1;
      D.24885 = D.24884 * 4;
      D.24886 = values + D.24885;
      D.24887 = strtol (ver, &p, 10);
      D.24888 = (unsigned int) D.24887;
      *D.24886 = D.24888;
      p.37 = p;
      D.24890 = *p.37;
      D.24891 = (int) D.24890;
      switch (D.24891) <default: <D.24893>, case 42: <D.19951>, case 46: <D.19949>>
      <D.19949>:
      p.37 = p;
      p.38 = p.37 + 1;
      p = p.38;
      goto <D.19950>;
      <D.19951>:
      p.37 = p;
      p.38 = p.37 + 1;
      p = p.38;
      goto <D.19950>;
      <D.24893>:
      <D.19950>:
      ver = p;
      i = i + 1;
      <D.19953>:
      if (i <= 3) goto <D.19952>; else goto <D.19954>;
      <D.19954>:
      monoeg_g_free (str);
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_image_fill_export_table (struct MonoDomain * domain, struct MonoReflectionTypeBuilder * tb, guint32 module_index, guint32 parent_index, struct MonoDynamicImage * assembly)
{
  struct MonoType * D.24897;
  unsigned int D.24898;
  unsigned int D.24899;
  struct MonoArray * D.24900;
  char * D.24903;
  struct MonoReflectionTypeBuilder * D.24904;
  unsigned int D.24905;
  struct MonoClass * klass;
  guint32 idx;
  guint32 i;

  D.24897 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.24897);
  D.24898 = tb->table_idx;
  D.24899 = D.24898 | 33554432;
  klass->type_token = D.24899;
  idx = mono_image_fill_export_table_from_class (domain, klass, module_index, parent_index, assembly);
  D.24900 = tb->subtypes;
  if (D.24900 != 0B) goto <D.24901>; else goto <D.24902>;
  <D.24901>:
  i = 0;
  goto <D.19494>;
  <D.19493>:
  D.24900 = tb->subtypes;
  D.24903 = mono_array_addr_with_size (D.24900, 4, i);
  D.24904 = MEM[(struct MonoReflectionTypeBuilder * *)D.24903];
  mono_image_fill_export_table (domain, D.24904, module_index, idx, assembly);
  i = i + 1;
  <D.19494>:
  D.24900 = tb->subtypes;
  D.24905 = mono_array_length (D.24900);
  if (D.24905 > i) goto <D.19493>; else goto <D.19495>;
  <D.19495>:
  <D.24902>:
}


mono_image_fill_export_table_from_class (struct MonoDomain * domain, struct MonoClass * klass, guint32 module_index, guint32 parent_index, struct MonoDynamicImage * assembly)
{
  unsigned int D.24906;
  unsigned int D.24907;
  guint32 D.24910;
  unsigned int D.24911;
  unsigned int D.24912;
  guint32 * D.24913;
  unsigned int D.24914;
  unsigned int D.24915;
  guint32 * D.24916;
  unsigned int D.24917;
  struct MonoClass * D.24918;
  guint32 * D.24921;
  unsigned int D.24922;
  unsigned int D.24923;
  unsigned int D.24925;
  guint32 * D.24926;
  struct MonoDynamicStream * D.24927;
  const char * D.24928;
  unsigned int D.24929;
  guint32 * D.24930;
  const char * D.24931;
  unsigned int D.24932;
  unsigned int D.24933;
  struct MonoClassExt * D.24934;
  struct GList * D.24937;
  void * D.24940;
  unsigned int D.24941;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 visib;
  guint32 res;

  D.24906 = klass->flags;
  visib = D.24906 & 7;
  D.24907 = visib & 3;
  if (D.24907 == 0) goto <D.24908>; else goto <D.24909>;
  <D.24908>:
  D.24910 = 0;
  return D.24910;
  <D.24909>:
  table = &assembly->tables[39];
  D.24911 = table->rows;
  D.24912 = D.24911 + 1;
  table->rows = D.24912;
  D.24911 = table->rows;
  alloc_table (table, D.24911);
  D.24913 = table->values;
  D.24914 = table->next_idx;
  D.24915 = D.24914 * 20;
  values = D.24913 + D.24915;
  D.24906 = klass->flags;
  *values = D.24906;
  D.24916 = values + 4;
  D.24917 = klass->type_token;
  *D.24916 = D.24917;
  D.24918 = klass->nested_in;
  if (D.24918 != 0B) goto <D.24919>; else goto <D.24920>;
  <D.24919>:
  D.24921 = values + 16;
  D.24922 = parent_index << 2;
  D.24923 = D.24922 + 2;
  *D.24921 = D.24923;
  goto <D.24924>;
  <D.24920>:
  D.24921 = values + 16;
  D.24925 = module_index << 2;
  *D.24921 = D.24925;
  <D.24924>:
  D.24926 = values + 8;
  D.24927 = &assembly->sheap;
  D.24928 = klass->name;
  D.24929 = string_heap_insert (D.24927, D.24928);
  *D.24926 = D.24929;
  D.24930 = values + 12;
  D.24927 = &assembly->sheap;
  D.24931 = klass->name_space;
  D.24932 = string_heap_insert (D.24927, D.24931);
  *D.24930 = D.24932;
  res = table->next_idx;
  D.24914 = table->next_idx;
  D.24933 = D.24914 + 1;
  table->next_idx = D.24933;
  D.24934 = klass->ext;
  if (D.24934 != 0B) goto <D.24935>; else goto <D.24936>;
  <D.24935>:
  D.24934 = klass->ext;
  D.24937 = D.24934->nested_classes;
  if (D.24937 != 0B) goto <D.24938>; else goto <D.24939>;
  <D.24938>:
  {
    struct GList * tmp;

    D.24934 = klass->ext;
    tmp = D.24934->nested_classes;
    goto <D.19481>;
    <D.19480>:
    D.24940 = tmp->data;
    D.24914 = table->next_idx;
    D.24941 = D.24914 + 4294967295;
    mono_image_fill_export_table_from_class (domain, D.24940, module_index, D.24941, assembly);
    tmp = tmp->next;
    <D.19481>:
    if (tmp != 0B) goto <D.19480>; else goto <D.19482>;
    <D.19482>:
  }
  <D.24939>:
  <D.24936>:
  D.24910 = res;
  return D.24910;
}


mono_image_fill_file_table (struct MonoDomain * domain, struct MonoReflectionModule * module, struct MonoDynamicImage * assembly)
{
  unsigned int D.24943;
  unsigned int D.24944;
  guint32 * D.24945;
  unsigned int D.24946;
  unsigned int D.24947;
  guint32 * D.24948;
  struct MonoDynamicStream * D.24949;
  struct MonoImage * D.24950;
  const char * D.24951;
  unsigned int D.24952;
  unsigned int D.24953;
  unsigned int D.24954;
  struct MonoReflectionAssemblyBuilder * D.24957;
  struct MonoString * D.24958;
  char * D.24960;
  char * b.39;
  guint32 * D.24962;
  struct MonoDynamicStream * D.24963;
  int b.40;
  int blob_size.41;
  int D.24966;
  unsigned int D.24967;
  unsigned int D.24968;
  unsigned int D.24969;
  struct MonoDynamicTable * table;
  guint32 * values;
  char blob_size[6];
  guchar hash[20];
  char * b;
  char * dir;
  char * path;

  try
    {
      b = &blob_size;
      table = &assembly->tables[38];
      D.24943 = table->rows;
      D.24944 = D.24943 + 1;
      table->rows = D.24944;
      D.24943 = table->rows;
      alloc_table (table, D.24943);
      D.24945 = table->values;
      D.24946 = table->next_idx;
      D.24947 = D.24946 * 12;
      values = D.24945 + D.24947;
      *values = 0;
      D.24948 = values + 4;
      D.24949 = &assembly->sheap;
      D.24950 = module->image;
      D.24951 = D.24950->module_name;
      D.24952 = string_heap_insert (D.24949, D.24951);
      *D.24948 = D.24952;
      D.24950 = module->image;
      D.24953 = BIT_FIELD_REF <*D.24950, 32, 128>;
      D.24954 = D.24953 & 8;
      if (D.24954 != 0) goto <D.24955>; else goto <D.24956>;
      <D.24955>:
      D.24957 = MEM[(struct MonoReflectionModuleBuilder *)module].assemblyb;
      D.24958 = D.24957->dir;
      dir = mono_string_to_utf8 (D.24958);
      D.24950 = module->image;
      D.24951 = D.24950->module_name;
      path = monoeg_g_strdup_printf ("%s%c%s", dir, 47, D.24951);
      goto <D.24959>;
      <D.24956>:
      dir = 0B;
      D.24950 = module->image;
      D.24960 = D.24950->name;
      path = monoeg_strdup (D.24960);
      <D.24959>:
      mono_sha1_get_digest_from_file (path, &hash);
      monoeg_g_free (dir);
      monoeg_g_free (path);
      b.39 = b;
      mono_metadata_encode_value (20, b.39, &b);
      D.24962 = values + 8;
      D.24963 = &assembly->blob;
      b.39 = b;
      b.40 = (int) b.39;
      blob_size.41 = (int) &blob_size;
      D.24966 = b.40 - blob_size.41;
      D.24967 = (unsigned int) D.24966;
      D.24968 = mono_image_add_stream_data (D.24963, &blob_size, D.24967);
      *D.24962 = D.24968;
      D.24963 = &assembly->blob;
      mono_image_add_stream_data (D.24963, &hash, 20);
      D.24946 = table->next_idx;
      D.24969 = D.24946 + 1;
      table->next_idx = D.24969;
    }
  finally
    {
      blob_size = {CLOBBER};
      hash = {CLOBBER};
      b = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.24970>; else goto <D.24971>;
  <D.24970>:
  D.24972 = __strdup (str);
  return D.24972;
  <D.24971>:
  D.24972 = 0B;
  return D.24972;
}


mono_image_fill_export_table_from_module (struct MonoDomain * domain, struct MonoReflectionModule * module, guint32 module_index, struct MonoDynamicImage * assembly)
{
  unsigned int D.24974;
  unsigned int D.24975;
  unsigned int D.24976;
  unsigned int D.24977;
  <unnamed-unsigned:24> D.24980;
  unsigned int D.24981;
  struct MonoImage * image;
  struct MonoTableInfo * t;
  guint32 i;

  image = module->image;
  t = &image->tables[2];
  i = 0;
  goto <D.19507>;
  <D.19506>:
  {
    struct MonoClass * klass;

    D.24974 = i + 1;
    D.24975 = D.24974 | 33554432;
    klass = mono_class_get (image, D.24975);
    D.24976 = klass->flags;
    D.24977 = D.24976 & 1;
    if (D.24977 != 0) goto <D.24978>; else goto <D.24979>;
    <D.24978>:
    mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
    <D.24979>:
  }
  i = i + 1;
  <D.19507>:
  D.24980 = t->rows;
  D.24981 = (unsigned int) D.24980;
  if (D.24981 > i) goto <D.19506>; else goto <D.19508>;
  <D.19508>:
}


mono_image_fill_export_table_from_type_forwarders (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.24982;
  unsigned int i.42;
  char * D.24986;
  _Bool D.24989;
  long int D.24990;
  long int D.24991;
  unsigned int D.24994;
  struct MonoClass * klass;
  int i;

  D.24982 = assemblyb->type_forwarders;
  if (D.24982 == 0B) goto <D.24983>; else goto <D.24984>;
  <D.24983>:
  return;
  <D.24984>:
  i = 0;
  goto <D.19537>;
  <D.19536>:
  {
    struct MonoReflectionType * t;
    struct MonoType * type;

    D.24982 = assemblyb->type_forwarders;
    i.42 = (unsigned int) i;
    D.24986 = mono_array_addr_with_size (D.24982, 4, i.42);
    t = MEM[(struct MonoReflectionType * *)D.24986];
    if (t == 0B) goto <D.24987>; else goto <D.24988>;
    <D.24987>:
    // predicted unlikely by continue predictor.
    goto <D.19535>;
    <D.24988>:
    type = mono_reflection_type_get_handle (t);
    D.24989 = type == 0B;
    D.24990 = (long int) D.24989;
    D.24991 = __builtin_expect (D.24990, 0);
    if (D.24991 != 0) goto <D.24992>; else goto <D.24993>;
    <D.24992>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3863, "type");
    <D.24993>:
    klass = mono_class_from_mono_type (type);
    add_exported_type (assemblyb, assembly, klass, 0);
  }
  <D.19535>:
  i = i + 1;
  <D.19537>:
  i.42 = (unsigned int) i;
  D.24982 = assemblyb->type_forwarders;
  D.24994 = mono_array_length (D.24982);
  if (i.42 < D.24994) goto <D.19536>; else goto <D.19538>;
  <D.19538>:
}


add_exported_type (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly, struct MonoClass * klass, guint32 parent_index)
{
  struct MonoClass * D.24996;
  unsigned int D.24999;
  struct MonoImage * D.25001;
  unsigned int D.25002;
  _Bool D.25003;
  long int D.25004;
  long int D.25005;
  unsigned int D.25008;
  unsigned int D.25009;
  unsigned int D.25010;
  guint32 * D.25011;
  unsigned int D.25012;
  guint32 iftmp.43;
  guint32 * D.25017;
  guint32 * D.25018;
  guint32 * D.25019;
  struct MonoDynamicStream * D.25020;
  const char * D.25021;
  unsigned int D.25022;
  guint32 * D.25023;
  const char * D.25024;
  unsigned int D.25025;
  unsigned int D.25026;
  unsigned int D.25027;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 scope;
  guint32 scope_idx;
  guint32 impl;
  guint32 current_idx;
  gboolean forwarder;
  void * iter;
  struct MonoClass * nested;

  try
    {
      forwarder = 1;
      iter = 0B;
      D.24996 = klass->nested_in;
      if (D.24996 != 0B) goto <D.24997>; else goto <D.24998>;
      <D.24997>:
      D.24999 = parent_index << 2;
      impl = D.24999 + 2;
      forwarder = 0;
      goto <D.25000>;
      <D.24998>:
      D.25001 = klass->image;
      scope = resolution_scope_from_image (assembly, D.25001);
      D.25002 = scope & 3;
      D.25003 = D.25002 != 2;
      D.25004 = (long int) D.25003;
      D.25005 = __builtin_expect (D.25004, 0);
      if (D.25005 != 0) goto <D.25006>; else goto <D.25007>;
      <D.25006>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3823, "(scope & MONO_RESOLTION_SCOPE_MASK) == MONO_RESOLTION_SCOPE_ASSEMBLYREF");
      <D.25007>:
      scope_idx = scope >> 2;
      D.25008 = scope_idx << 2;
      impl = D.25008 + 1;
      <D.25000>:
      table = &assembly->tables[39];
      D.25009 = table->rows;
      D.25010 = D.25009 + 1;
      table->rows = D.25010;
      D.25009 = table->rows;
      alloc_table (table, D.25009);
      current_idx = table->next_idx;
      D.25011 = table->values;
      D.25012 = current_idx * 20;
      values = D.25011 + D.25012;
      if (forwarder != 0) goto <D.25014>; else goto <D.25015>;
      <D.25014>:
      iftmp.43 = 2097152;
      goto <D.25016>;
      <D.25015>:
      iftmp.43 = 0;
      <D.25016>:
      *values = iftmp.43;
      D.25017 = values + 4;
      *D.25017 = 0;
      D.25018 = values + 16;
      *D.25018 = impl;
      D.25019 = values + 8;
      D.25020 = &assembly->sheap;
      D.25021 = klass->name;
      D.25022 = string_heap_insert (D.25020, D.25021);
      *D.25019 = D.25022;
      D.25023 = values + 12;
      D.25020 = &assembly->sheap;
      D.25024 = klass->name_space;
      D.25025 = string_heap_insert (D.25020, D.25024);
      *D.25023 = D.25025;
      D.25026 = table->next_idx;
      D.25027 = D.25026 + 1;
      table->next_idx = D.25027;
      goto <D.19525>;
      <D.19524>:
      add_exported_type (assemblyb, assembly, nested, current_idx);
      <D.19525>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.19524>; else goto <D.19526>;
      <D.19526>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


resolution_scope_from_image (struct MonoDynamicImage * assembly, struct MonoImage * image)
{
  struct GHashTable * D.25028;
  void * D.25029;
  guint32 D.25032;
  struct MonoAssembly * D.25033;
  unsigned char D.25034;
  struct MonoAssembly * D.25037;
  unsigned int D.25040;
  unsigned int token.44;
  unsigned int D.25042;
  unsigned int D.25043;
  unsigned int D.25044;
  guint32 * D.25045;
  unsigned int D.25046;
  struct MonoDynamicStream * D.25047;
  const char * D.25048;
  unsigned int D.25049;
  void * token.45;
  struct MonoTableInfo * D.25054;
  unsigned int token.46;
  unsigned int D.25056;
  unsigned int D.25057;
  guint32 * D.25058;
  const char * D.25059;
  unsigned int D.25060;
  unsigned int D.25061;
  guint32 * D.25062;
  unsigned int D.25063;
  guint32 * D.25064;
  unsigned int D.25065;
  guint32 * D.25066;
  unsigned int D.25067;
  guint32 * D.25068;
  guint32 * D.25069;
  guint32 * D.25070;
  int D.18961;
  int iftmp.47;
  int D.18957;
  const char[1] * D.25074;
  unsigned char D.25075;
  int D.25076;
  unsigned char D.25077;
  int D.25078;
  const unsigned char * D.25083;
  unsigned char D.25084;
  int D.25085;
  const unsigned char * D.25086;
  unsigned char D.25087;
  int D.25088;
  const unsigned char * D.25093;
  unsigned char D.25094;
  int D.25095;
  const unsigned char * D.25096;
  unsigned char D.25097;
  int D.25098;
  const unsigned char * D.25103;
  unsigned char D.25104;
  int D.25105;
  const unsigned char * D.25106;
  unsigned char D.25107;
  int D.25108;
  const char * D.25110;
  unsigned char D.25111;
  int D.25112;
  unsigned int D.25115;
  unsigned int publen.48;
  guint32 * D.25119;
  struct MonoDynamicStream * D.25120;
  unsigned int D.25121;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;
  guint32 cols[9];
  const char * pubkey;
  guint32 publen;

  try
    {
      D.25028 = assembly->handleref;
      D.25029 = monoeg_g_hash_table_lookup (D.25028, image);
      token = (guint32) D.25029;
      if (token != 0) goto <D.25030>; else goto <D.25031>;
      <D.25030>:
      D.25032 = token;
      return D.25032;
      <D.25031>:
      D.25033 = image->assembly;
      D.25034 = D.25033->dynamic;
      if (D.25034 != 0) goto <D.25035>; else goto <D.25036>;
      <D.25035>:
      D.25033 = image->assembly;
      D.25037 = assembly->image.assembly;
      if (D.25033 == D.25037) goto <D.25038>; else goto <D.25039>;
      <D.25038>:
      table = &assembly->tables[26];
      D.25040 = table->next_idx;
      token.44 = D.25040;
      D.25042 = token.44 + 1;
      table->next_idx = D.25042;
      token = token.44;
      D.25043 = table->rows;
      D.25044 = D.25043 + 1;
      table->rows = D.25044;
      D.25043 = table->rows;
      alloc_table (table, D.25043);
      D.25045 = table->values;
      D.25046 = token * 4;
      values = D.25045 + D.25046;
      D.25047 = &assembly->sheap;
      D.25048 = image->module_name;
      D.25049 = string_heap_insert (D.25047, D.25048);
      *values = D.25049;
      token = token << 2;
      token = token | 1;
      D.25028 = assembly->handleref;
      token.45 = (void *) token;
      monoeg_g_hash_table_insert_replace (D.25028, image, token.45, 0);
      D.25032 = token;
      return D.25032;
      <D.25039>:
      <D.25036>:
      D.25033 = image->assembly;
      D.25034 = D.25033->dynamic;
      if (D.25034 != 0) goto <D.25051>; else goto <D.25052>;
      <D.25051>:
      memset (&cols, 0, 36);
      goto <D.25053>;
      <D.25052>:
      D.25033 = image->assembly;
      image = D.25033->image;
      D.25054 = &image->tables[32];
      mono_metadata_decode_row (D.25054, 0, &cols, 9);
      <D.25053>:
      table = &assembly->tables[35];
      D.25040 = table->next_idx;
      token.46 = D.25040;
      D.25056 = token.46 + 1;
      table->next_idx = D.25056;
      token = token.46;
      D.25043 = table->rows;
      D.25044 = D.25043 + 1;
      table->rows = D.25044;
      D.25043 = table->rows;
      alloc_table (table, D.25043);
      D.25045 = table->values;
      D.25057 = token * 36;
      values = D.25045 + D.25057;
      D.25058 = values + 24;
      D.25047 = &assembly->sheap;
      D.25059 = image->assembly_name;
      D.25060 = string_heap_insert (D.25047, D.25059);
      *D.25058 = D.25060;
      D.25061 = cols[1];
      *values = D.25061;
      D.25062 = values + 4;
      D.25063 = cols[2];
      *D.25062 = D.25063;
      D.25064 = values + 8;
      D.25065 = cols[3];
      *D.25064 = D.25065;
      D.25066 = values + 12;
      D.25067 = cols[4];
      *D.25066 = D.25067;
      D.25068 = values + 16;
      *D.25068 = 0;
      D.25069 = values + 28;
      *D.25069 = 0;
      D.25070 = values + 32;
      *D.25070 = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

        __s1_len = 0;
        if (__s1_len <= 3) goto <D.25072>; else goto <D.25073>;
        <D.25072>:
        {
          const unsigned char * __s2;
          int __result;

          D.25033 = image->assembly;
          __s2 = D.25033->aname.culture;
          D.25074 = "";
          D.25075 = MEM[(const unsigned char *)D.25074];
          D.25076 = (int) D.25075;
          D.25077 = *__s2;
          D.25078 = (int) D.25077;
          __result = D.25076 - D.25078;
          {
            if (__s1_len != 0) goto <D.25079>; else goto <D.25080>;
            <D.25079>:
            if (__result == 0) goto <D.25081>; else goto <D.25082>;
            <D.25081>:
            D.25083 = &MEM[(void *)"" + 1B];
            D.25084 = *D.25083;
            D.25085 = (int) D.25084;
            D.25086 = __s2 + 1;
            D.25087 = *D.25086;
            D.25088 = (int) D.25087;
            __result = D.25085 - D.25088;
            if (__s1_len > 1) goto <D.25089>; else goto <D.25090>;
            <D.25089>:
            if (__result == 0) goto <D.25091>; else goto <D.25092>;
            <D.25091>:
            D.25093 = &MEM[(void *)"" + 2B];
            D.25094 = *D.25093;
            D.25095 = (int) D.25094;
            D.25096 = __s2 + 2;
            D.25097 = *D.25096;
            D.25098 = (int) D.25097;
            __result = D.25095 - D.25098;
            if (__s1_len > 2) goto <D.25099>; else goto <D.25100>;
            <D.25099>:
            if (__result == 0) goto <D.25101>; else goto <D.25102>;
            <D.25101>:
            D.25103 = &MEM[(void *)"" + 3B];
            D.25104 = *D.25103;
            D.25105 = (int) D.25104;
            D.25106 = __s2 + 3;
            D.25107 = *D.25106;
            D.25108 = (int) D.25107;
            __result = D.25105 - D.25108;
            <D.25102>:
            <D.25100>:
            <D.25092>:
            <D.25090>:
            <D.25082>:
            <D.25080>:
          }
          D.18957 = __result;
        }
        iftmp.47 = D.18957;
        goto <D.25109>;
        <D.25073>:
        D.25033 = image->assembly;
        D.25110 = D.25033->aname.culture;
        D.25111 = MEM[(const unsigned char * {ref-all})D.25110];
        D.25112 = (int) D.25111;
        iftmp.47 = -D.25112;
        <D.25109>:
        D.18961 = iftmp.47;
      }
      if (D.18961 != 0) goto <D.25113>; else goto <D.25114>;
      <D.25113>:
      D.25069 = values + 28;
      D.25047 = &assembly->sheap;
      D.25033 = image->assembly;
      D.25110 = D.25033->aname.culture;
      D.25115 = string_heap_insert (D.25047, D.25110);
      *D.25069 = D.25115;
      <D.25114>:
      pubkey = mono_image_get_public_key (image, &publen);
      if (pubkey != 0B) goto <D.25116>; else goto <D.25117>;
      <D.25116>:
      {
        guchar pubtoken[9];

        try
          {
            pubtoken[0] = 8;
            publen.48 = publen;
            mono_digest_get_public_token (&MEM[(void *)&pubtoken + 1B], pubkey, publen.48);
            D.25119 = values + 20;
            D.25120 = &assembly->blob;
            D.25121 = mono_image_add_stream_data (D.25120, &pubtoken, 9);
            *D.25119 = D.25121;
          }
        finally
          {
            pubtoken = {CLOBBER};
          }
      }
      goto <D.25122>;
      <D.25117>:
      D.25119 = values + 20;
      *D.25119 = 0;
      <D.25122>:
      token = token << 2;
      token = token | 2;
      D.25028 = assembly->handleref;
      token.45 = (void *) token;
      monoeg_g_hash_table_insert_replace (D.25028, image, token.45, 0);
      D.25032 = token;
      return D.25032;
    }
  finally
    {
      cols = {CLOBBER};
      publen = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25127;
  int D.25132;
  void * D.25134;
  unsigned int D.25135;

  D.25127 = __builtin_constant_p (__len);
  if (D.25127 != 0) goto <D.25128>; else goto <D.25129>;
  <D.25128>:
  if (__len == 0) goto <D.25130>; else goto <D.25131>;
  <D.25130>:
  D.25132 = __builtin_constant_p (__ch);
  if (D.25132 == 0) goto <D.25125>; else goto <D.25133>;
  <D.25133>:
  if (__ch != 0) goto <D.25125>; else goto <D.25126>;
  <D.25125>:
  __warn_memset_zero_len ();
  D.25134 = __dest;
  return D.25134;
  <D.25126>:
  <D.25131>:
  <D.25129>:
  D.25135 = __builtin_object_size (__dest, 0);
  D.25134 = __builtin___memset_chk (__dest, __ch, __len, D.25135);
  return D.25134;
}


assembly_add_resource_manifest (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc, guint32 implementation)
{
  unsigned int D.25137;
  unsigned int D.25138;
  guint32 * D.25139;
  unsigned int D.25140;
  unsigned int D.25141;
  unsigned int D.25142;
  guint32 * D.25143;
  unsigned int D.25144;
  guint32 * D.25145;
  struct MonoDynamicStream * D.25146;
  struct MonoString * D.25147;
  unsigned int D.25148;
  guint32 * D.25149;
  unsigned int D.25150;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[40];
  D.25137 = table->rows;
  D.25138 = D.25137 + 1;
  table->rows = D.25138;
  D.25137 = table->rows;
  alloc_table (table, D.25137);
  D.25139 = table->values;
  D.25140 = table->next_idx;
  D.25141 = D.25140 * 16;
  values = D.25139 + D.25141;
  D.25142 = rsrc->offset;
  *values = D.25142;
  D.25143 = values + 4;
  D.25144 = rsrc->attrs;
  *D.25143 = D.25144;
  D.25145 = values + 8;
  D.25146 = &assembly->sheap;
  D.25147 = rsrc->name;
  D.25148 = string_heap_insert_mstring (D.25146, D.25147);
  *D.25145 = D.25148;
  D.25149 = values + 12;
  *D.25149 = implementation;
  D.25140 = table->next_idx;
  D.25150 = D.25140 + 1;
  table->next_idx = D.25150;
}


string_heap_insert (struct MonoDynamicStream * sh, const char * str)
{
  struct GHashTable * D.25151;
  int D.25152;
  guint32 D.25155;
  void * oldval.49;
  unsigned int D.25157;
  unsigned int D.25158;
  int D.25159;
  gchar * D.25160;
  void * idx.50;
  char * D.25162;
  char * D.25163;
  unsigned int D.25164;
  unsigned int D.25165;
  guint32 idx;
  guint32 len;
  void * oldkey;
  void * oldval;

  try
    {
      D.25151 = sh->hash;
      D.25152 = monoeg_g_hash_table_lookup_extended (D.25151, str, &oldkey, &oldval);
      if (D.25152 != 0) goto <D.25153>; else goto <D.25154>;
      <D.25153>:
      oldval.49 = oldval;
      D.25155 = (guint32) oldval.49;
      return D.25155;
      <D.25154>:
      D.25157 = strlen (str);
      len = D.25157 + 1;
      idx = sh->index;
      D.25158 = idx + len;
      D.25159 = (int) D.25158;
      make_room_in_stream (sh, D.25159);
      D.25151 = sh->hash;
      D.25160 = monoeg_strdup (str);
      idx.50 = (void *) idx;
      monoeg_g_hash_table_insert_replace (D.25151, D.25160, idx.50, 0);
      D.25162 = sh->data;
      D.25163 = D.25162 + idx;
      memcpy (D.25163, str, len);
      D.25164 = sh->index;
      D.25165 = D.25164 + len;
      sh->index = D.25165;
      D.25155 = idx;
      return D.25155;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


mono_image_get_method_info (struct MonoReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25168;
  unsigned int D.25169;
  struct MonoString * D.25170;
  int iftmp.51;
  unsigned int D.25174;
  unsigned int D.25177;
  unsigned int D.25178;
  unsigned int D.25180;
  unsigned int D.25181;
  unsigned int D.25182;
  guint32 * D.25183;
  unsigned int D.25184;
  unsigned int D.25185;
  unsigned int D.25186;
  unsigned int ncharset.52;
  unsigned int D.25188;
  unsigned int extra_flags.53;
  unsigned int D.25190;
  guint32 * D.25191;
  unsigned int D.25192;
  unsigned int D.25193;
  unsigned int D.25194;
  struct MonoString * D.25195;
  guint32 * D.25198;
  struct MonoDynamicStream * D.25199;
  unsigned int D.25200;
  struct MonoString * D.25202;
  unsigned int D.25203;
  guint32 * D.25204;
  unsigned int D.25205;
  unsigned int D.25206;
  unsigned int D.25209;
  guint32 * D.25210;
  struct MonoArray * D.25211;
  unsigned int D.25214;
  unsigned int D.25215;
  unsigned int i.54;
  char * D.25217;
  void * D.25218;
  unsigned int D.25219;
  struct MonoDynamicTable * table;
  guint32 * values;
  struct ReflectionMethodBuilder rmb;
  int i;

  try
    {
      reflection_methodbuilder_from_method_builder (&rmb, mb);
      mono_image_basic_method (&rmb, assembly);
      D.25168 = rmb.table_idx;
      D.25169 = *D.25168;
      mb->table_idx = D.25169;
      D.25170 = mb->dll;
      if (D.25170 != 0B) goto <D.25171>; else goto <D.25172>;
      <D.25171>:
      {
        guint32 moduleref;
        int ncharset;
        int extra_flags;

        D.25174 = mb->charset;
        if (D.25174 != 0) goto <D.25175>; else goto <D.25176>;
        <D.25175>:
        D.25174 = mb->charset;
        D.25177 = D.25174 + 2147483647;
        D.25178 = D.25177 * 2;
        iftmp.51 = (int) D.25178;
        goto <D.25179>;
        <D.25176>:
        iftmp.51 = 0;
        <D.25179>:
        ncharset = iftmp.51;
        D.25180 = mb->extra_flags;
        extra_flags = (int) D.25180;
        table = &assembly->tables[28];
        D.25181 = table->rows;
        D.25182 = D.25181 + 1;
        table->rows = D.25182;
        D.25181 = table->rows;
        alloc_table (table, D.25181);
        D.25183 = table->values;
        D.25181 = table->rows;
        D.25184 = D.25181 * 16;
        values = D.25183 + D.25184;
        D.25185 = mb->native_cc;
        D.25186 = D.25185 << 8;
        ncharset.52 = (unsigned int) ncharset;
        D.25188 = D.25186 | ncharset.52;
        extra_flags.53 = (unsigned int) extra_flags;
        D.25190 = D.25188 | extra_flags.53;
        *values = D.25190;
        D.25191 = values + 4;
        D.25192 = mb->table_idx;
        D.25193 = D.25192 << 1;
        D.25194 = D.25193 | 1;
        *D.25191 = D.25194;
        D.25195 = mb->dllentry;
        if (D.25195 != 0B) goto <D.25196>; else goto <D.25197>;
        <D.25196>:
        D.25198 = values + 8;
        D.25199 = &assembly->sheap;
        D.25195 = mb->dllentry;
        D.25200 = string_heap_insert_mstring (D.25199, D.25195);
        *D.25198 = D.25200;
        goto <D.25201>;
        <D.25197>:
        D.25198 = values + 8;
        D.25199 = &assembly->sheap;
        D.25202 = mb->name;
        D.25203 = string_heap_insert_mstring (D.25199, D.25202);
        *D.25198 = D.25203;
        <D.25201>:
        D.25199 = &assembly->sheap;
        D.25170 = mb->dll;
        moduleref = string_heap_insert_mstring (D.25199, D.25170);
        D.25204 = values + 12;
        D.25205 = find_index_in_table (assembly, 26, 0, moduleref);
        *D.25204 = D.25205;
        D.25206 = *D.25204;
        if (D.25206 == 0) goto <D.25207>; else goto <D.25208>;
        <D.25207>:
        table = &assembly->tables[26];
        D.25181 = table->rows;
        D.25182 = D.25181 + 1;
        table->rows = D.25182;
        D.25181 = table->rows;
        alloc_table (table, D.25181);
        D.25183 = table->values;
        D.25181 = table->rows;
        D.25209 = D.25181 * 4;
        D.25210 = D.25183 + D.25209;
        *D.25210 = moduleref;
        D.25204 = values + 12;
        D.25181 = table->rows;
        *D.25204 = D.25181;
        <D.25208>:
      }
      <D.25172>:
      D.25211 = mb->generic_params;
      if (D.25211 != 0B) goto <D.25212>; else goto <D.25213>;
      <D.25212>:
      table = &assembly->tables[42];
      D.25211 = mb->generic_params;
      D.25214 = mono_array_length (D.25211);
      D.25181 = table->rows;
      D.25215 = D.25181 + D.25214;
      table->rows = D.25215;
      D.25181 = table->rows;
      alloc_table (table, D.25181);
      i = 0;
      goto <D.18763>;
      <D.18762>:
      {
        guint32 owner;

        D.25192 = mb->table_idx;
        D.25193 = D.25192 << 1;
        owner = D.25193 | 1;
        D.25211 = mb->generic_params;
        i.54 = (unsigned int) i;
        D.25217 = mono_array_addr_with_size (D.25211, 4, i.54);
        D.25218 = MEM[(void * *)D.25217];
        mono_image_get_generic_param_info (D.25218, owner, assembly);
      }
      i = i + 1;
      <D.18763>:
      i.54 = (unsigned int) i;
      D.25211 = mb->generic_params;
      D.25219 = mono_array_length (D.25211);
      if (i.54 < D.25219) goto <D.18762>; else goto <D.18764>;
      <D.18764>:
      <D.25213>:
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


reflection_methodbuilder_from_method_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoReflectionILGen * D.25220;
  struct MonoObject * D.25221;
  struct MonoReflectionType * D.25222;
  struct MonoArray * D.25223;
  struct MonoArray * D.25224;
  struct MonoGenericContainer * D.25225;
  struct MonoArray * D.25226;
  unsigned int D.25227;
  unsigned int D.25228;
  unsigned int D.25229;
  struct MonoArray * D.25230;
  struct MonoObject * D.25231;
  struct MonoString * D.25232;
  guint32 * D.25233;
  unsigned char D.25234;
  struct MonoArray * D.25235;
  struct MonoArray * D.25236;
  struct MonoArray * D.25237;
  struct MonoArray * D.25238;
  struct MonoArray * D.25239;
  struct MonoMethod * D.25240;
  struct MonoString * D.25241;
  unsigned int D.25244;
  int D.25245;
  unsigned int D.25246;
  int D.25247;
  unsigned int D.25248;
  int D.25249;
  struct MonoString * D.25250;

  memset (rmb, 0, 112);
  D.25220 = mb->ilgen;
  rmb->ilgen = D.25220;
  D.25221 = mb->rtype;
  D.25222 = mono_reflection_type_resolve_user_types (D.25221);
  rmb->rtype = D.25222;
  D.25223 = mb->parameters;
  rmb->parameters = D.25223;
  D.25224 = mb->generic_params;
  rmb->generic_params = D.25224;
  D.25225 = mb->generic_container;
  rmb->generic_container = D.25225;
  rmb->opt_types = 0B;
  D.25226 = mb->pinfo;
  rmb->pinfo = D.25226;
  D.25227 = mb->attrs;
  rmb->attrs = D.25227;
  D.25228 = mb->iattrs;
  rmb->iattrs = D.25228;
  D.25229 = mb->call_conv;
  rmb->call_conv = D.25229;
  D.25230 = mb->code;
  rmb->code = D.25230;
  D.25231 = mb->type;
  rmb->type = D.25231;
  D.25232 = mb->name;
  rmb->name = D.25232;
  D.25233 = &mb->table_idx;
  rmb->table_idx = D.25233;
  D.25234 = mb->init_locals;
  rmb->init_locals = D.25234;
  rmb->skip_visibility = 0;
  D.25235 = mb->return_modreq;
  rmb->return_modreq = D.25235;
  D.25236 = mb->return_modopt;
  rmb->return_modopt = D.25236;
  D.25237 = mb->param_modreq;
  rmb->param_modreq = D.25237;
  D.25238 = mb->param_modopt;
  rmb->param_modopt = D.25238;
  D.25239 = mb->permissions;
  rmb->permissions = D.25239;
  D.25240 = mb->mhandle;
  rmb->mhandle = D.25240;
  rmb->nrefs = 0;
  rmb->refs = 0B;
  D.25241 = mb->dll;
  if (D.25241 != 0B) goto <D.25242>; else goto <D.25243>;
  <D.25242>:
  D.25244 = mb->charset;
  D.25245 = (int) D.25244;
  rmb->charset = D.25245;
  D.25246 = mb->extra_flags;
  D.25247 = (int) D.25246;
  rmb->extra_flags = D.25247;
  D.25248 = mb->native_cc;
  D.25249 = (int) D.25248;
  rmb->native_cc = D.25249;
  D.25250 = mb->dllentry;
  rmb->dllentry = D.25250;
  D.25241 = mb->dll;
  rmb->dll = D.25241;
  <D.25243>:
}


mono_reflection_type_resolve_user_types (struct MonoReflectionType * type)
{
  struct MonoType * D.25254;
  struct MonoReflectionType * D.25255;
  int D.25256;
  int D.25259;
  struct MonoException * D.25262;

  if (type == 0B) goto <D.25251>; else goto <D.25253>;
  <D.25253>:
  D.25254 = type->type;
  if (D.25254 != 0B) goto <D.25251>; else goto <D.25252>;
  <D.25251>:
  D.25255 = type;
  return D.25255;
  <D.25252>:
  D.25256 = is_usertype (type);
  if (D.25256 != 0) goto <D.25257>; else goto <D.25258>;
  <D.25257>:
  type = mono_reflection_type_get_underlying_system_type (type);
  D.25259 = is_usertype (type);
  if (D.25259 != 0) goto <D.25260>; else goto <D.25261>;
  <D.25260>:
  D.25262 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported22");
  mono_raise_exception (D.25262);
  <D.25261>:
  <D.25258>:
  D.25255 = type;
  return D.25255;
}


mono_reflection_type_get_underlying_system_type (struct MonoReflectionType * t)
{
  struct MonoMethod * method_get_underlying_system_type.55;
  struct MonoClass * D.25267;
  struct MonoMethod * method_get_underlying_system_type.56;
  struct MonoReflectionType * D.25269;
  static struct MonoMethod * method_get_underlying_system_type = 0B;
  struct MonoMethod * usertype_method;

  method_get_underlying_system_type.55 = method_get_underlying_system_type;
  if (method_get_underlying_system_type.55 == 0B) goto <D.25265>; else goto <D.25266>;
  <D.25265>:
  D.25267 = mono_defaults.systemtype_class;
  method_get_underlying_system_type.56 = mono_class_get_method_from_name (D.25267, "get_UnderlyingSystemType", 0);
  method_get_underlying_system_type = method_get_underlying_system_type.56;
  <D.25266>:
  method_get_underlying_system_type.55 = method_get_underlying_system_type;
  usertype_method = mono_object_get_virtual_method (t, method_get_underlying_system_type.55);
  D.25269 = mono_runtime_invoke (usertype_method, t, 0B, 0B);
  return D.25269;
}


is_usertype (struct MonoReflectionType * ref)
{
  struct MonoVTable * D.25271;
  gboolean D.25272;
  int iftmp.57;
  struct MonoImage * D.25277;
  struct MonoImage * D.25278;
  int D.22555;
  int iftmp.58;
  int D.22551;
  const char[14] * D.25283;
  unsigned char D.25284;
  int D.25285;
  unsigned char D.25286;
  int D.25287;
  const unsigned char * D.25292;
  unsigned char D.25293;
  int D.25294;
  const unsigned char * D.25295;
  unsigned char D.25296;
  int D.25297;
  const unsigned char * D.25302;
  unsigned char D.25303;
  int D.25304;
  const unsigned char * D.25305;
  unsigned char D.25306;
  int D.25307;
  const unsigned char * D.25312;
  unsigned char D.25313;
  int D.25314;
  const unsigned char * D.25315;
  unsigned char D.25316;
  int D.25317;
  const char * D.25319;
  struct MonoClass * class;

  D.25271 = MEM[(struct MonoObject *)ref].vtable;
  class = D.25271->klass;
  D.25277 = class->image;
  D.25278 = mono_defaults.corlib;
  if (D.25277 != D.25278) goto <D.25274>; else goto <D.25279>;
  <D.25279>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 13;
    if (__s1_len <= 3) goto <D.25281>; else goto <D.25282>;
    <D.25281>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = class->name;
      D.25283 = "TypeDelegator";
      D.25284 = MEM[(const unsigned char *)D.25283];
      D.25285 = (int) D.25284;
      D.25286 = *__s2;
      D.25287 = (int) D.25286;
      __result = D.25285 - D.25287;
      {
        if (__s1_len != 0) goto <D.25288>; else goto <D.25289>;
        <D.25288>:
        if (__result == 0) goto <D.25290>; else goto <D.25291>;
        <D.25290>:
        D.25292 = &MEM[(void *)"TypeDelegator" + 1B];
        D.25293 = *D.25292;
        D.25294 = (int) D.25293;
        D.25295 = __s2 + 1;
        D.25296 = *D.25295;
        D.25297 = (int) D.25296;
        __result = D.25294 - D.25297;
        if (__s1_len > 1) goto <D.25298>; else goto <D.25299>;
        <D.25298>:
        if (__result == 0) goto <D.25300>; else goto <D.25301>;
        <D.25300>:
        D.25302 = &MEM[(void *)"TypeDelegator" + 2B];
        D.25303 = *D.25302;
        D.25304 = (int) D.25303;
        D.25305 = __s2 + 2;
        D.25306 = *D.25305;
        D.25307 = (int) D.25306;
        __result = D.25304 - D.25307;
        if (__s1_len > 2) goto <D.25308>; else goto <D.25309>;
        <D.25308>:
        if (__result == 0) goto <D.25310>; else goto <D.25311>;
        <D.25310>:
        D.25312 = &MEM[(void *)"TypeDelegator" + 3B];
        D.25313 = *D.25312;
        D.25314 = (int) D.25313;
        D.25315 = __s2 + 3;
        D.25316 = *D.25315;
        D.25317 = (int) D.25316;
        __result = D.25314 - D.25317;
        <D.25311>:
        <D.25309>:
        <D.25301>:
        <D.25299>:
        <D.25291>:
        <D.25289>:
      }
      D.22551 = __result;
    }
    iftmp.58 = D.22551;
    goto <D.25318>;
    <D.25282>:
    D.25319 = class->name;
    iftmp.58 = __builtin_strcmp ("TypeDelegator", D.25319);
    <D.25318>:
    D.22555 = iftmp.58;
  }
  if (D.22555 == 0) goto <D.25274>; else goto <D.25275>;
  <D.25274>:
  iftmp.57 = 1;
  goto <D.25276>;
  <D.25275>:
  iftmp.57 = 0;
  <D.25276>:
  D.25272 = iftmp.57;
  return D.25272;
}


mono_image_basic_method (struct ReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25321;
  unsigned int D.25322;
  unsigned int D.25323;
  unsigned int D.25324;
  struct GHashTable * D.25325;
  struct MonoMethod * D.25326;
  unsigned int D.25327;
  void * D.25328;
  guint32 * D.25329;
  unsigned int D.25330;
  guint32 * D.25331;
  struct MonoDynamicStream * D.25332;
  struct MonoString * D.25333;
  unsigned int D.25334;
  guint32 * D.25335;
  unsigned int D.25336;
  guint32 * D.25337;
  unsigned int D.25338;
  guint32 * D.25339;
  unsigned int D.25340;
  unsigned int D.25341;
  guint32 * D.25342;
  unsigned int D.25343;
  struct MonoArray * D.25344;
  struct MonoArray * D.25345;
  guint32 * D.25348;
  unsigned int D.25349;
  unsigned int D.25350;
  char * D.25351;
  void * D.25352;
  unsigned int D.25355;
  unsigned int D.25356;
  unsigned int D.25357;
  unsigned int D.25358;
  char * D.25359;
  unsigned int D.25362;
  struct MonoString * D.25363;
  unsigned int D.25366;
  struct MonoReflectionMarshal * D.25368;
  unsigned int D.25371;
  unsigned int D.25372;
  unsigned int D.25373;
  unsigned int D.25374;
  unsigned int D.25375;
  guint32 * D.25376;
  unsigned int D.25377;
  unsigned int D.25378;
  unsigned int D.25379;
  unsigned int D.25380;
  unsigned int D.25383;
  guint32 * D.25384;
  unsigned int D.25385;
  unsigned int D.25386;
  unsigned int D.25387;
  guint32 * D.25388;
  struct MonoObject * D.25389;
  unsigned int D.25390;
  unsigned int field_type.59;
  unsigned int D.25392;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint i;
  guint count;

  table = &assembly->tables[6];
  D.25321 = mb->table_idx;
  D.25322 = table->next_idx;
  D.25323 = D.25322;
  D.25324 = D.25323 + 1;
  table->next_idx = D.25324;
  *D.25321 = D.25323;
  D.25325 = assembly->method_to_table_idx;
  D.25326 = mb->mhandle;
  D.25321 = mb->table_idx;
  D.25327 = *D.25321;
  D.25328 = (void *) D.25327;
  monoeg_g_hash_table_insert_replace (D.25325, D.25326, D.25328, 0);
  D.25329 = table->values;
  D.25321 = mb->table_idx;
  D.25327 = *D.25321;
  D.25330 = D.25327 * 24;
  values = D.25329 + D.25330;
  D.25331 = values + 12;
  D.25332 = &assembly->sheap;
  D.25333 = mb->name;
  D.25334 = string_heap_insert_mstring (D.25332, D.25333);
  *D.25331 = D.25334;
  D.25335 = values + 8;
  D.25336 = mb->attrs;
  *D.25335 = D.25336;
  D.25337 = values + 4;
  D.25338 = mb->iattrs;
  *D.25337 = D.25338;
  D.25339 = values + 16;
  D.25340 = method_builder_encode_signature (assembly, mb);
  *D.25339 = D.25340;
  D.25341 = method_encode_code (assembly, mb);
  *values = D.25341;
  table = &assembly->tables[8];
  D.25342 = values + 20;
  D.25322 = table->next_idx;
  *D.25342 = D.25322;
  D.25321 = mb->table_idx;
  D.25327 = *D.25321;
  D.25343 = D.25327 | 100663296;
  D.25344 = mb->permissions;
  mono_image_add_decl_security (assembly, D.25343, D.25344);
  D.25345 = mb->pinfo;
  if (D.25345 != 0B) goto <D.25346>; else goto <D.25347>;
  <D.25346>:
  {
    struct MonoDynamicTable * mtable;
    guint32 * mvalues;

    mtable = &assembly->tables[13];
    D.25348 = mtable->values;
    D.25349 = mtable->next_idx;
    D.25350 = D.25349 * 8;
    mvalues = D.25348 + D.25350;
    count = 0;
    i = 0;
    goto <D.18713>;
    <D.18712>:
    D.25345 = mb->pinfo;
    D.25351 = mono_array_addr_with_size (D.25345, 4, i);
    D.25352 = MEM[(void * *)D.25351];
    if (D.25352 != 0B) goto <D.25353>; else goto <D.25354>;
    <D.25353>:
    count = count + 1;
    <D.25354>:
    i = i + 1;
    <D.18713>:
    D.25345 = mb->pinfo;
    D.25355 = mono_array_length (D.25345);
    if (D.25355 > i) goto <D.18712>; else goto <D.18714>;
    <D.18714>:
    D.25356 = table->rows;
    D.25357 = D.25356 + count;
    table->rows = D.25357;
    D.25356 = table->rows;
    alloc_table (table, D.25356);
    D.25329 = table->values;
    D.25322 = table->next_idx;
    D.25358 = D.25322 * 12;
    values = D.25329 + D.25358;
    i = 0;
    goto <D.18718>;
    <D.18717>:
    {
      struct MonoReflectionParamBuilder * pb;

      D.25345 = mb->pinfo;
      D.25359 = mono_array_addr_with_size (D.25345, 4, i);
      pb = MEM[(struct MonoReflectionParamBuilder * *)D.25359];
      if (pb != 0B) goto <D.25360>; else goto <D.25361>;
      <D.25360>:
      D.25362 = pb->attrs;
      *values = D.25362;
      D.25337 = values + 4;
      *D.25337 = i;
      D.25363 = pb->name;
      if (D.25363 != 0B) goto <D.25364>; else goto <D.25365>;
      <D.25364>:
      D.25335 = values + 8;
      D.25332 = &assembly->sheap;
      D.25363 = pb->name;
      D.25366 = string_heap_insert_mstring (D.25332, D.25363);
      *D.25335 = D.25366;
      goto <D.25367>;
      <D.25365>:
      D.25335 = values + 8;
      *D.25335 = 0;
      <D.25367>:
      values = values + 12;
      D.25368 = pb->marshal_info;
      if (D.25368 != 0B) goto <D.25369>; else goto <D.25370>;
      <D.25369>:
      D.25371 = mtable->rows;
      D.25372 = D.25371 + 1;
      mtable->rows = D.25372;
      D.25371 = mtable->rows;
      alloc_table (mtable, D.25371);
      D.25348 = mtable->values;
      D.25371 = mtable->rows;
      D.25373 = D.25371 * 8;
      mvalues = D.25348 + D.25373;
      D.25322 = table->next_idx;
      D.25374 = D.25322 << 1;
      D.25375 = D.25374 | 1;
      *mvalues = D.25375;
      D.25376 = mvalues + 4;
      D.25368 = pb->marshal_info;
      D.25377 = encode_marshal_blob (assembly, D.25368);
      *D.25376 = D.25377;
      <D.25370>:
      D.25322 = table->next_idx;
      D.25378 = D.25322;
      D.25379 = D.25378 + 1;
      table->next_idx = D.25379;
      pb->table_idx = D.25378;
      D.25362 = pb->attrs;
      D.25380 = D.25362 & 4096;
      if (D.25380 != 0) goto <D.25381>; else goto <D.25382>;
      <D.25381>:
      {
        guint32 field_type;

        try
          {
            field_type = 0;
            mtable = &assembly->tables[11];
            D.25371 = mtable->rows;
            D.25372 = D.25371 + 1;
            mtable->rows = D.25372;
            D.25371 = mtable->rows;
            alloc_table (mtable, D.25371);
            D.25348 = mtable->values;
            D.25371 = mtable->rows;
            D.25383 = D.25371 * 16;
            mvalues = D.25348 + D.25383;
            D.25384 = mvalues + 8;
            D.25385 = pb->table_idx;
            D.25386 = D.25385 << 2;
            D.25387 = D.25386 | 1;
            *D.25384 = D.25387;
            D.25388 = mvalues + 12;
            D.25389 = pb->def_value;
            D.25390 = encode_constant (assembly, D.25389, &field_type);
            *D.25388 = D.25390;
            field_type.59 = field_type;
            *mvalues = field_type.59;
            D.25376 = mvalues + 4;
            *D.25376 = 0;
          }
        finally
          {
            field_type = {CLOBBER};
          }
      }
      <D.25382>:
      <D.25361>:
    }
    i = i + 1;
    <D.18718>:
    D.25345 = mb->pinfo;
    D.25392 = mono_array_length (D.25345);
    if (D.25392 > i) goto <D.18717>; else goto <D.18719>;
    <D.18719>:
  }
  <D.25347>:
}


method_builder_encode_signature (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  uintptr_t iftmp.60;
  struct MonoArray * D.25394;
  uintptr_t iftmp.61;
  struct MonoArray * D.25399;
  uintptr_t iftmp.62;
  struct MonoArray * D.25404;
  unsigned int D.25408;
  unsigned int D.25409;
  unsigned int D.25412;
  unsigned int D.25413;
  unsigned char D.25418;
  int D.25419;
  unsigned int D.25422;
  struct MonoArray * D.25423;
  struct MonoArray * D.25424;
  struct MonoReflectionType * D.25425;
  struct MonoArray * D.25426;
  unsigned int i.63;
  unsigned int D.25430;
  char * D.25433;
  struct MonoArray * D.25434;
  unsigned int D.25437;
  char * D.25440;
  char * D.25441;
  unsigned int i.64;
  char * D.25445;
  guint32 D.25446;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 ngparams;
  guint32 notypes;
  guint32 idx;

  try
    {
      D.25394 = mb->parameters;
      if (D.25394 != 0B) goto <D.25395>; else goto <D.25396>;
      <D.25395>:
      D.25394 = mb->parameters;
      iftmp.60 = mono_array_length (D.25394);
      goto <D.25397>;
      <D.25396>:
      iftmp.60 = 0;
      <D.25397>:
      nparams = iftmp.60;
      D.25399 = mb->generic_params;
      if (D.25399 != 0B) goto <D.25400>; else goto <D.25401>;
      <D.25400>:
      D.25399 = mb->generic_params;
      iftmp.61 = mono_array_length (D.25399);
      goto <D.25402>;
      <D.25401>:
      iftmp.61 = 0;
      <D.25402>:
      ngparams = iftmp.61;
      D.25404 = mb->opt_types;
      if (D.25404 != 0B) goto <D.25405>; else goto <D.25406>;
      <D.25405>:
      D.25404 = mb->opt_types;
      iftmp.62 = mono_array_length (D.25404);
      goto <D.25407>;
      <D.25406>:
      iftmp.62 = 0;
      <D.25407>:
      notypes = iftmp.62;
      sigbuffer_init (&buf, 32);
      D.25408 = mb->call_conv;
      idx = D.25408 & 96;
      D.25408 = mb->call_conv;
      D.25409 = D.25408 & 2;
      if (D.25409 != 0) goto <D.25410>; else goto <D.25411>;
      <D.25410>:
      idx = idx | 5;
      <D.25411>:
      D.25412 = mb->attrs;
      D.25413 = D.25412 & 16;
      if (D.25413 == 0) goto <D.25414>; else goto <D.25415>;
      <D.25414>:
      idx = idx | 32;
      <D.25415>:
      if (ngparams != 0) goto <D.25416>; else goto <D.25417>;
      <D.25416>:
      idx = idx | 16;
      <D.25417>:
      D.25418 = (unsigned char) idx;
      D.25419 = (int) D.25418;
      sigbuffer_add_byte (&buf, D.25419);
      if (ngparams != 0) goto <D.25420>; else goto <D.25421>;
      <D.25420>:
      sigbuffer_add_value (&buf, ngparams);
      <D.25421>:
      D.25422 = nparams + notypes;
      sigbuffer_add_value (&buf, D.25422);
      D.25423 = mb->return_modreq;
      D.25424 = mb->return_modopt;
      encode_custom_modifiers (assembly, D.25423, D.25424, &buf);
      D.25425 = mb->rtype;
      encode_reflection_type (assembly, D.25425, &buf);
      i = 0;
      goto <D.18524>;
      <D.18523>:
      {
        struct MonoArray * modreq;
        struct MonoArray * modopt;
        struct MonoReflectionType * pt;

        modreq = 0B;
        modopt = 0B;
        D.25426 = mb->param_modreq;
        if (D.25426 != 0B) goto <D.25427>; else goto <D.25428>;
        <D.25427>:
        i.63 = (unsigned int) i;
        D.25426 = mb->param_modreq;
        D.25430 = mono_array_length (D.25426);
        if (i.63 < D.25430) goto <D.25431>; else goto <D.25432>;
        <D.25431>:
        D.25426 = mb->param_modreq;
        i.63 = (unsigned int) i;
        D.25433 = mono_array_addr_with_size (D.25426, 4, i.63);
        modreq = MEM[(struct MonoArray * *)D.25433];
        <D.25432>:
        <D.25428>:
        D.25434 = mb->param_modopt;
        if (D.25434 != 0B) goto <D.25435>; else goto <D.25436>;
        <D.25435>:
        i.63 = (unsigned int) i;
        D.25434 = mb->param_modopt;
        D.25437 = mono_array_length (D.25434);
        if (i.63 < D.25437) goto <D.25438>; else goto <D.25439>;
        <D.25438>:
        D.25434 = mb->param_modopt;
        i.63 = (unsigned int) i;
        D.25440 = mono_array_addr_with_size (D.25434, 4, i.63);
        modopt = MEM[(struct MonoArray * *)D.25440];
        <D.25439>:
        <D.25436>:
        encode_custom_modifiers (assembly, modreq, modopt, &buf);
        D.25394 = mb->parameters;
        i.63 = (unsigned int) i;
        D.25441 = mono_array_addr_with_size (D.25394, 4, i.63);
        pt = MEM[(struct MonoReflectionType * *)D.25441];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18524>:
      i.64 = (unsigned int) i;
      if (i.64 < nparams) goto <D.18523>; else goto <D.18525>;
      <D.18525>:
      if (notypes != 0) goto <D.25443>; else goto <D.25444>;
      <D.25443>:
      sigbuffer_add_byte (&buf, 65);
      <D.25444>:
      i = 0;
      goto <D.18528>;
      <D.18527>:
      {
        struct MonoReflectionType * pt;

        D.25404 = mb->opt_types;
        i.63 = (unsigned int) i;
        D.25445 = mono_array_addr_with_size (D.25404, 4, i.63);
        pt = MEM[(struct MonoReflectionType * *)D.25445];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18528>:
      i.64 = (unsigned int) i;
      if (i.64 < notypes) goto <D.18527>; else goto <D.18529>;
      <D.18529>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25446 = idx;
      return D.25446;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sigbuffer_init (struct SigBuffer * buf, int size)
{
  unsigned int size.65;
  void * D.25450;
  char * D.25451;
  sizetype size.66;
  char * D.25453;

  size.65 = (unsigned int) size;
  D.25450 = monoeg_malloc (size.65);
  buf->buf = D.25450;
  D.25451 = buf->buf;
  buf->p = D.25451;
  D.25451 = buf->buf;
  size.66 = (sizetype) size;
  D.25453 = D.25451 + size.66;
  buf->end = D.25453;
}


sigbuffer_add_value (struct SigBuffer * buf, guint32 val)
{
  char * D.25454;
  char * * D.25455;

  sigbuffer_make_room (buf, 6);
  D.25454 = buf->p;
  D.25455 = &buf->p;
  mono_metadata_encode_value (val, D.25454, D.25455);
}


sigbuffer_make_room (struct SigBuffer * buf, int size)
{
  char * D.25456;
  int D.25457;
  char * D.25458;
  int D.25459;
  int D.25460;
  char * D.25463;
  int D.25464;
  int D.25465;
  int D.25466;
  unsigned int new_size.67;
  sizetype size.68;
  char * D.25469;
  sizetype new_size.69;
  char * D.25471;

  D.25456 = buf->end;
  D.25457 = (int) D.25456;
  D.25458 = buf->p;
  D.25459 = (int) D.25458;
  D.25460 = D.25457 - D.25459;
  if (D.25460 < size) goto <D.25461>; else goto <D.25462>;
  <D.25461>:
  {
    int new_size;
    char * p;

    D.25456 = buf->end;
    D.25457 = (int) D.25456;
    D.25463 = buf->buf;
    D.25464 = (int) D.25463;
    D.25465 = D.25457 - D.25464;
    D.25466 = D.25465 + size;
    new_size = D.25466 + 32;
    D.25463 = buf->buf;
    new_size.67 = (unsigned int) new_size;
    p = monoeg_realloc (D.25463, new_size.67);
    D.25458 = buf->p;
    D.25459 = (int) D.25458;
    D.25463 = buf->buf;
    D.25464 = (int) D.25463;
    size = D.25459 - D.25464;
    buf->buf = p;
    size.68 = (sizetype) size;
    D.25469 = p + size.68;
    buf->p = D.25469;
    D.25463 = buf->buf;
    new_size.69 = (sizetype) new_size;
    D.25471 = D.25463 + new_size.69;
    buf->end = D.25471;
  }
  <D.25462>:
}


encode_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoArray * modreq, struct MonoArray * modopt, struct SigBuffer * buf)
{
  unsigned int i.70;
  char * D.25475;
  void * D.25476;
  unsigned int D.25477;
  unsigned int D.25478;
  char * D.25481;
  void * D.25482;
  unsigned int D.25483;
  unsigned int D.25484;
  int i;

  if (modreq != 0B) goto <D.25472>; else goto <D.25473>;
  <D.25472>:
  i = 0;
  goto <D.18493>;
  <D.18492>:
  {
    struct MonoType * mod;

    i.70 = (unsigned int) i;
    D.25475 = mono_array_addr_with_size (modreq, 4, i.70);
    D.25476 = MEM[(void * *)D.25475];
    mod = mono_reflection_type_get_handle (D.25476);
    sigbuffer_add_byte (buf, 31);
    D.25477 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25477);
  }
  i = i + 1;
  <D.18493>:
  i.70 = (unsigned int) i;
  D.25478 = mono_array_length (modreq);
  if (i.70 < D.25478) goto <D.18492>; else goto <D.18494>;
  <D.18494>:
  <D.25473>:
  if (modopt != 0B) goto <D.25479>; else goto <D.25480>;
  <D.25479>:
  i = 0;
  goto <D.18497>;
  <D.18496>:
  {
    struct MonoType * mod;

    i.70 = (unsigned int) i;
    D.25481 = mono_array_addr_with_size (modopt, 4, i.70);
    D.25482 = MEM[(void * *)D.25481];
    mod = mono_reflection_type_get_handle (D.25482);
    sigbuffer_add_byte (buf, 32);
    D.25483 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25483);
  }
  i = i + 1;
  <D.18497>:
  i.70 = (unsigned int) i;
  D.25484 = mono_array_length (modopt);
  if (i.70 < D.25484) goto <D.18496>; else goto <D.18498>;
  <D.18498>:
  <D.25480>:
}


mono_image_typedef_or_ref (struct MonoDynamicImage * assembly, struct MonoType * type)
{
  guint32 D.25485;

  D.25485 = mono_image_typedef_or_ref_full (assembly, type, 1);
  return D.25485;
}


mono_image_typedef_or_ref_full (struct MonoDynamicImage * assembly, struct MonoType * type, gboolean try_typespec)
{
  guint32 D.25491;
  struct GHashTable * D.25492;
  void * D.25493;
  struct MonoImage * D.25498;
  struct MonoImage * D.25499;
  unsigned char D.25502;
  unsigned int D.25507;
  struct MonoGHashTable * D.25508;
  void * token.71;
  void * D.25510;
  struct MonoClass * D.25511;
  struct MonoType * D.25514;
  unsigned int D.25515;
  int D.25517;
  unsigned int D.25520;
  unsigned int D.25521;
  guint32 * D.25522;
  unsigned int D.25523;
  unsigned int D.25524;
  guint32 * D.25525;
  struct MonoDynamicStream * D.25526;
  const char * D.25527;
  unsigned int D.25528;
  guint32 * D.25529;
  const char * D.25530;
  unsigned int D.25531;
  unsigned int D.25532;
  unsigned int D.25533;
  void * D.25534;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 scope;
  guint32 enclosing;
  struct MonoClass * klass;

  if (try_typespec != 0) goto <D.25487>; else goto <D.25488>;
  <D.25487>:
  token = create_typespec (assembly, type);
  if (token != 0) goto <D.25489>; else goto <D.25490>;
  <D.25489>:
  D.25491 = token;
  return D.25491;
  <D.25490>:
  <D.25488>:
  D.25492 = assembly->typeref;
  D.25493 = monoeg_g_hash_table_lookup (D.25492, type);
  token = (guint32) D.25493;
  if (token != 0) goto <D.25494>; else goto <D.25495>;
  <D.25494>:
  D.25491 = token;
  return D.25491;
  <D.25495>:
  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.25496>; else goto <D.25497>;
  <D.25496>:
  klass = mono_class_from_mono_type (type);
  <D.25497>:
  D.25498 = klass->image;
  D.25499 = &assembly->image;
  if (D.25498 == D.25499) goto <D.25500>; else goto <D.25501>;
  <D.25500>:
  D.25502 = type->type;
  if (D.25502 != 19) goto <D.25503>; else goto <D.25504>;
  <D.25503>:
  D.25502 = type->type;
  if (D.25502 != 30) goto <D.25505>; else goto <D.25506>;
  <D.25505>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.25507 = tb->table_idx;
    token = D.25507 << 2;
    D.25508 = assembly->tokens;
    token.71 = (void *) token;
    D.25510 = mono_class_get_ref_info (klass);
    mono_g_hash_table_insert (D.25508, token.71, D.25510);
    D.25491 = token;
    return D.25491;
  }
  <D.25506>:
  <D.25504>:
  <D.25501>:
  D.25511 = klass->nested_in;
  if (D.25511 != 0B) goto <D.25512>; else goto <D.25513>;
  <D.25512>:
  D.25511 = klass->nested_in;
  D.25514 = &D.25511->byval_arg;
  enclosing = mono_image_typedef_or_ref_full (assembly, D.25514, 0);
  enclosing = enclosing >> 2;
  D.25515 = enclosing << 2;
  scope = D.25515 | 3;
  goto <D.25516>;
  <D.25513>:
  D.25498 = klass->image;
  scope = resolution_scope_from_image (assembly, D.25498);
  <D.25516>:
  table = &assembly->tables[1];
  D.25517 = assembly->save;
  if (D.25517 != 0) goto <D.25518>; else goto <D.25519>;
  <D.25518>:
  D.25520 = table->rows;
  D.25521 = D.25520 + 1;
  alloc_table (table, D.25521);
  D.25522 = table->values;
  D.25523 = table->next_idx;
  D.25524 = D.25523 * 12;
  values = D.25522 + D.25524;
  *values = scope;
  D.25525 = values + 4;
  D.25526 = &assembly->sheap;
  D.25527 = klass->name;
  D.25528 = string_heap_insert (D.25526, D.25527);
  *D.25525 = D.25528;
  D.25529 = values + 8;
  D.25526 = &assembly->sheap;
  D.25530 = klass->name_space;
  D.25531 = string_heap_insert (D.25526, D.25530);
  *D.25529 = D.25531;
  <D.25519>:
  D.25523 = table->next_idx;
  D.25532 = D.25523 << 2;
  token = D.25532 | 1;
  D.25492 = assembly->typeref;
  token.71 = (void *) token;
  monoeg_g_hash_table_insert_replace (D.25492, type, token.71, 0);
  D.25523 = table->next_idx;
  D.25533 = D.25523 + 1;
  table->next_idx = D.25533;
  D.25508 = assembly->tokens;
  token.71 = (void *) token;
  D.25534 = mono_class_get_ref_info (klass);
  mono_g_hash_table_insert (D.25508, token.71, D.25534);
  D.25491 = token;
  return D.25491;
}


create_typespec (struct MonoDynamicImage * assembly, struct MonoType * type)
{
  struct GHashTable * D.25536;
  void * D.25537;
  guint32 D.25540;
  unsigned char D.25541;
  int D.25542;
  struct MonoGenericContainer * D.25546;
  int D.25547;
  unsigned int D.25550;
  unsigned int D.25551;
  guint32 * D.25552;
  unsigned int D.25553;
  unsigned int D.25554;
  unsigned int D.25555;
  void * token.72;
  unsigned int D.25557;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  struct SigBuffer buf;

  try
    {
      D.25536 = assembly->typespec;
      D.25537 = monoeg_g_hash_table_lookup (D.25536, type);
      token = (guint32) D.25537;
      if (token != 0) goto <D.25538>; else goto <D.25539>;
      <D.25538>:
      D.25540 = token;
      return D.25540;
      <D.25539>:
      sigbuffer_init (&buf, 32);
      D.25541 = type->type;
      D.25542 = (int) D.25541;
      switch (D.25542) <default: <D.18982>, case 15: <D.18972>, case 17: <D.18980>, case 18: <D.18979>, case 19: <D.18975>, case 20: <D.18974>, case 21: <D.18977>, case 27: <D.18971>, case 29: <D.18973>, case 30: <D.18976>>
      <D.18971>:
      <D.18972>:
      <D.18973>:
      <D.18974>:
      <D.18975>:
      <D.18976>:
      <D.18977>:
      encode_type (assembly, type, &buf);
      goto <D.18978>;
      <D.18979>:
      <D.18980>:
      {
        struct MonoClass * k;

        k = mono_class_from_mono_type (type);
        if (k == 0B) goto <D.25543>; else goto <D.25545>;
        <D.25545>:
        D.25546 = k->generic_container;
        if (D.25546 == 0B) goto <D.25543>; else goto <D.25544>;
        <D.25543>:
        sigbuffer_free (&buf);
        D.25540 = 0;
        return D.25540;
        <D.25544>:
        encode_type (assembly, type, &buf);
        goto <D.18978>;
      }
      <D.18982>:
      sigbuffer_free (&buf);
      D.25540 = 0;
      return D.25540;
      <D.18978>:
      table = &assembly->tables[27];
      D.25547 = assembly->save;
      if (D.25547 != 0) goto <D.25548>; else goto <D.25549>;
      <D.25548>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.25550 = table->rows;
      D.25551 = D.25550 + 1;
      alloc_table (table, D.25551);
      D.25552 = table->values;
      D.25553 = table->next_idx;
      D.25554 = D.25553 * 4;
      values = D.25552 + D.25554;
      *values = token;
      <D.25549>:
      sigbuffer_free (&buf);
      D.25553 = table->next_idx;
      D.25555 = D.25553 << 2;
      token = D.25555 | 2;
      D.25536 = assembly->typespec;
      token.72 = (void *) token;
      monoeg_g_hash_table_insert_replace (D.25536, type, token.72, 0);
      D.25553 = table->next_idx;
      D.25557 = D.25553 + 1;
      table->next_idx = D.25557;
      D.25540 = token;
      return D.25540;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_type (struct MonoDynamicImage * assembly, struct MonoType * type, struct SigBuffer * buf)
{
  unsigned int D.25562;
  unsigned int D.25563;
  unsigned char D.25566;
  int D.25567;
  unsigned int D.25568;
  struct MonoType * D.25569;
  struct MonoClass * D.25570;
  struct MonoType * D.25571;
  struct MonoGenericContainer * D.25572;
  struct MonoGenericInst * D.25575;
  unsigned char D.25577;
  unsigned int D.25578;
  struct MonoType * D.25579;
  unsigned int D.25580;
  struct MonoArrayType * D.25581;
  struct MonoClass * D.25582;
  struct MonoType * D.25583;
  unsigned char D.25584;
  unsigned int D.25585;
  struct MonoGenericClass * D.25586;
  struct MonoGenericParam * D.25587;
  short unsigned int D.25588;
  unsigned int D.25589;

  if (type == 0B) goto <D.25560>; else goto <D.25561>;
  <D.25560>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 679);
  return;
  <D.25561>:
  D.25562 = BIT_FIELD_REF <*type, 32, 32>;
  D.25563 = D.25562 & 1073741824;
  if (D.25563 != 0) goto <D.25564>; else goto <D.25565>;
  <D.25564>:
  sigbuffer_add_value (buf, 16);
  <D.25565>:
  D.25566 = type->type;
  D.25567 = (int) D.25566;
  switch (D.25567) <default: <D.18477>, case 1: <D.18448>, case 2: <D.18449>, case 3: <D.18450>, case 4: <D.18451>, case 5: <D.18452>, case 6: <D.18453>, case 7: <D.18454>, case 8: <D.18455>, case 9: <D.18456>, case 10: <D.18457>, case 11: <D.18458>, case 12: <D.18459>, case 13: <D.18460>, case 14: <D.18463>, case 15: <D.18467>, case 17: <D.18469>, case 18: <D.18470>, case 19: <D.18475>, case 20: <D.18473>, case 21: <D.18474>, case 22: <D.18465>, case 24: <D.18461>, case 25: <D.18462>, case 28: <D.18464>, case 29: <D.18468>, case 30: <D.18476>>
  <D.18448>:
  <D.18449>:
  <D.18450>:
  <D.18451>:
  <D.18452>:
  <D.18453>:
  <D.18454>:
  <D.18455>:
  <D.18456>:
  <D.18457>:
  <D.18458>:
  <D.18459>:
  <D.18460>:
  <D.18461>:
  <D.18462>:
  <D.18463>:
  <D.18464>:
  <D.18465>:
  D.25566 = type->type;
  D.25568 = (unsigned int) D.25566;
  sigbuffer_add_value (buf, D.25568);
  goto <D.18466>;
  <D.18467>:
  D.25566 = type->type;
  D.25568 = (unsigned int) D.25566;
  sigbuffer_add_value (buf, D.25568);
  D.25569 = type->data.type;
  encode_type (assembly, D.25569, buf);
  goto <D.18466>;
  <D.18468>:
  D.25566 = type->type;
  D.25568 = (unsigned int) D.25566;
  sigbuffer_add_value (buf, D.25568);
  D.25570 = type->data.klass;
  D.25571 = &D.25570->byval_arg;
  encode_type (assembly, D.25571, buf);
  goto <D.18466>;
  <D.18469>:
  <D.18470>:
  {
    struct MonoClass * k;

    k = mono_class_from_mono_type (type);
    D.25572 = k->generic_container;
    if (D.25572 != 0B) goto <D.25573>; else goto <D.25574>;
    <D.25573>:
    {
      struct MonoGenericClass * gclass;

      D.25572 = k->generic_container;
      D.25575 = D.25572->context.class_inst;
      gclass = mono_metadata_lookup_generic_class (k, D.25575, 1);
      encode_generic_class (assembly, gclass, buf);
    }
    goto <D.25576>;
    <D.25574>:
    D.25577 = k->byval_arg.type;
    D.25578 = (unsigned int) D.25577;
    sigbuffer_add_value (buf, D.25578);
    D.25579 = &k->byval_arg;
    D.25580 = mono_image_typedef_or_ref (assembly, D.25579);
    sigbuffer_add_value (buf, D.25580);
    <D.25576>:
    goto <D.18466>;
  }
  <D.18473>:
  D.25566 = type->type;
  D.25568 = (unsigned int) D.25566;
  sigbuffer_add_value (buf, D.25568);
  D.25581 = type->data.array;
  D.25582 = D.25581->eklass;
  D.25583 = &D.25582->byval_arg;
  encode_type (assembly, D.25583, buf);
  D.25581 = type->data.array;
  D.25584 = D.25581->rank;
  D.25585 = (unsigned int) D.25584;
  sigbuffer_add_value (buf, D.25585);
  sigbuffer_add_value (buf, 0);
  sigbuffer_add_value (buf, 0);
  goto <D.18466>;
  <D.18474>:
  D.25586 = type->data.generic_class;
  encode_generic_class (assembly, D.25586, buf);
  goto <D.18466>;
  <D.18475>:
  <D.18476>:
  D.25566 = type->type;
  D.25568 = (unsigned int) D.25566;
  sigbuffer_add_value (buf, D.25568);
  D.25587 = type->data.generic_param;
  D.25588 = D.25587->num;
  D.25589 = (unsigned int) D.25588;
  sigbuffer_add_value (buf, D.25589);
  goto <D.18466>;
  <D.18477>:
  D.25566 = type->type;
  D.25567 = (int) D.25566;
  monoeg_g_log (0B, 4, "need to encode type %x", D.25567);
  <D.18478>:
  goto <D.18478>;
  <D.18466>:
}


encode_generic_class (struct MonoDynamicImage * assembly, struct MonoGenericClass * gclass, struct SigBuffer * buf)
{
  _Bool D.25590;
  long int D.25591;
  long int D.25592;
  unsigned char D.25595;
  unsigned int D.25596;
  struct MonoType * D.25597;
  unsigned int D.25598;
  <unnamed-unsigned:22> D.25599;
  unsigned int D.25600;
  struct MonoType * D.25601;
  int D.25602;
  int i;
  struct MonoGenericInst * class_inst;
  struct MonoClass * klass;

  D.25590 = gclass == 0B;
  D.25591 = (long int) D.25590;
  D.25592 = __builtin_expect (D.25591, 0);
  if (D.25592 != 0) goto <D.25593>; else goto <D.25594>;
  <D.25593>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 660, "gclass");
  <D.25594>:
  class_inst = gclass->context.class_inst;
  sigbuffer_add_value (buf, 21);
  klass = gclass->container_class;
  D.25595 = klass->byval_arg.type;
  D.25596 = (unsigned int) D.25595;
  sigbuffer_add_value (buf, D.25596);
  D.25597 = &klass->byval_arg;
  D.25598 = mono_image_typedef_or_ref_full (assembly, D.25597, 0);
  sigbuffer_add_value (buf, D.25598);
  D.25599 = class_inst->type_argc;
  D.25600 = (unsigned int) D.25599;
  sigbuffer_add_value (buf, D.25600);
  i = 0;
  goto <D.18441>;
  <D.18440>:
  D.25601 = class_inst->type_argv[i];
  encode_type (assembly, D.25601, buf);
  i = i + 1;
  <D.18441>:
  D.25599 = class_inst->type_argc;
  D.25602 = (int) D.25599;
  if (D.25602 > i) goto <D.18440>; else goto <D.18442>;
  <D.18442>:
}


sigbuffer_add_byte (struct SigBuffer * buf, guint8 val)
{
  char * D.25603;
  char val.73;
  char * D.25605;

  sigbuffer_make_room (buf, 1);
  D.25603 = buf->p;
  val.73 = (char) val;
  *D.25603 = val.73;
  D.25603 = buf->p;
  D.25605 = D.25603 + 1;
  buf->p = D.25605;
}


encode_reflection_type (struct MonoDynamicImage * assembly, struct MonoReflectionType * type, struct SigBuffer * buf)
{
  struct MonoType * D.25608;

  if (type == 0B) goto <D.25606>; else goto <D.25607>;
  <D.25606>:
  sigbuffer_add_value (buf, 1);
  return;
  <D.25607>:
  D.25608 = mono_reflection_type_get_handle (type);
  encode_type (assembly, D.25608, buf);
}


sigbuffer_add_to_blob_cached (struct MonoDynamicImage * assembly, struct SigBuffer * buf)
{
  char * D.25610;
  int D.25611;
  char * D.25612;
  int D.25613;
  int D.25614;
  char * D.25615;
  int D.25616;
  int D.25617;
  unsigned int D.25618;
  _Bool D.25619;
  long int D.25620;
  long int D.25621;
  char * b.74;
  guint32 D.25625;
  int b.75;
  int blob_size.76;
  int D.25628;
  int size.77;
  char blob_size[8];
  char * b;
  guint32 size;

  try
    {
      b = &blob_size;
      D.25610 = buf->p;
      D.25611 = (int) D.25610;
      D.25612 = buf->buf;
      D.25613 = (int) D.25612;
      D.25614 = D.25611 - D.25613;
      size = (guint32) D.25614;
      D.25615 = buf->end;
      D.25616 = (int) D.25615;
      D.25612 = buf->buf;
      D.25613 = (int) D.25612;
      D.25617 = D.25616 - D.25613;
      D.25618 = (unsigned int) D.25617;
      D.25619 = D.25618 < size;
      D.25620 = (long int) D.25619;
      D.25621 = __builtin_expect (D.25620, 0);
      if (D.25621 != 0) goto <D.25622>; else goto <D.25623>;
      <D.25622>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 501, "size <= (buf->end - buf->buf)");
      <D.25623>:
      b.74 = b;
      mono_metadata_encode_value (size, b.74, &b);
      b.74 = b;
      b.75 = (int) b.74;
      blob_size.76 = (int) &blob_size;
      D.25628 = b.75 - blob_size.76;
      D.25612 = buf->buf;
      size.77 = (int) size;
      D.25625 = add_to_blob_cached (assembly, &blob_size, D.25628, D.25612, size.77);
      return D.25625;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


add_to_blob_cached (struct MonoDynamicImage * assembly, char * b1, int s1, char * b2, int s2)
{
  int D.25632;
  unsigned int D.25633;
  unsigned int s1.78;
  sizetype s1.79;
  char * D.25636;
  unsigned int s2.80;
  struct GHashTable * D.25638;
  int D.25639;
  void * oldval.81;
  struct MonoDynamicStream * D.25644;
  unsigned int s1.82;
  unsigned int s2.83;
  void * idx.84;
  guint32 D.25648;
  guint32 idx;
  char * copy;
  void * oldkey;
  void * oldval;

  try
    {
      D.25632 = s1 + s2;
      D.25633 = (unsigned int) D.25632;
      copy = monoeg_malloc (D.25633);
      s1.78 = (unsigned int) s1;
      memcpy (copy, b1, s1.78);
      s1.79 = (sizetype) s1;
      D.25636 = copy + s1.79;
      s2.80 = (unsigned int) s2;
      memcpy (D.25636, b2, s2.80);
      D.25638 = assembly->blob_cache;
      D.25639 = monoeg_g_hash_table_lookup_extended (D.25638, copy, &oldkey, &oldval);
      if (D.25639 != 0) goto <D.25640>; else goto <D.25641>;
      <D.25640>:
      monoeg_g_free (copy);
      oldval.81 = oldval;
      idx = (guint32) oldval.81;
      goto <D.25643>;
      <D.25641>:
      D.25644 = &assembly->blob;
      s1.82 = (unsigned int) s1;
      idx = mono_image_add_stream_data (D.25644, b1, s1.82);
      D.25644 = &assembly->blob;
      s2.83 = (unsigned int) s2;
      mono_image_add_stream_data (D.25644, b2, s2.83);
      D.25638 = assembly->blob_cache;
      idx.84 = (void *) idx;
      monoeg_g_hash_table_insert_replace (D.25638, copy, idx.84, 0);
      <D.25643>:
      D.25648 = idx;
      return D.25648;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


sigbuffer_free (struct SigBuffer * buf)
{
  char * D.25651;

  D.25651 = buf->buf;
  monoeg_g_free (D.25651);
}


method_encode_code (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  unsigned int D.25654;
  unsigned int D.25655;
  unsigned int D.25657;
  unsigned int D.25658;
  guint32 D.25659;
  struct MonoReflectionILGen * D.25660;
  int D.25663;
  gint32 iftmp.85;
  struct MonoArray * D.25665;
  unsigned int D.25668;
  struct MonoArray * D.25670;
  unsigned int D.25673;
  struct MonoString * D.25677;
  struct MonoDynamicStream * D.25678;
  int iftmp.86;
  unsigned int D.25690;
  unsigned char D.25692;
  unsigned char D.25693;
  unsigned char D.25694;
  char flags.87;
  unsigned char D.25698;
  char flags.88;
  int D.25702;
  struct MonoGHashTable * D.25705;
  unsigned int D.25706;
  void * D.25707;
  char * D.25708;
  unsigned int D.25709;
  unsigned int D.25712;
  unsigned char D.25715;
  char D.25718;
  unsigned int D.25719;
  unsigned int D.25720;
  char D.25721;
  short unsigned int short_value.89;
  unsigned int D.25727;
  void * D.25728;
  char * D.25729;
  unsigned int num_exception.90;
  unsigned int D.25733;
  unsigned char D.25734;
  int D.25735;
  unsigned char D.25736;
  int D.25737;
  unsigned char D.25738;
  unsigned int D.25739;
  unsigned int D.25740;
  unsigned int i.91;
  struct MonoArray * D.25742;
  int D.25745;
  int D.25746;
  unsigned int j.92;
  int D.25748;
  unsigned int val.93;
  unsigned int val.94;
  int D.25753;
  unsigned int val.95;
  unsigned int val.96;
  int D.25757;
  unsigned int val.97;
  int D.25759;
  unsigned int val.98;
  struct MonoObject * D.25761;
  struct MonoType * D.25764;
  unsigned int D.25765;
  unsigned int val.99;
  int D.25770;
  unsigned int val.100;
  unsigned int val.101;
  unsigned int D.25774;
  char flags;
  guint32 idx;
  guint32 code_size;
  gint32 max_stack;
  gint32 i;
  gint32 num_locals;
  gint32 num_exception;
  gint maybe_small;
  guint32 fat_flags;
  char fat_header[12];
  guint32 int_value;
  guint16 short_value;
  guint32 local_sig;
  guint32 header_size;
  struct MonoArray * code;
  void fat_header = <<< error >>>;

  try
    {
      flags = 0;
      num_locals = 0;
      num_exception = 0;
      local_sig = 0;
      header_size = 12;
      D.25654 = mb->attrs;
      D.25655 = D.25654 & 9216;
      if (D.25655 != 0) goto <D.25652>; else goto <D.25656>;
      <D.25656>:
      D.25657 = mb->iattrs;
      D.25658 = D.25657 & 4099;
      if (D.25658 != 0) goto <D.25652>; else goto <D.25653>;
      <D.25652>:
      D.25659 = 0;
      return D.25659;
      <D.25653>:
      D.25660 = mb->ilgen;
      if (D.25660 != 0B) goto <D.25661>; else goto <D.25662>;
      <D.25661>:
      D.25660 = mb->ilgen;
      code = D.25660->code;
      D.25660 = mb->ilgen;
      D.25663 = D.25660->code_len;
      code_size = (guint32) D.25663;
      D.25660 = mb->ilgen;
      max_stack = D.25660->max_stack;
      D.25660 = mb->ilgen;
      D.25665 = D.25660->locals;
      if (D.25665 != 0B) goto <D.25666>; else goto <D.25667>;
      <D.25666>:
      D.25660 = mb->ilgen;
      D.25665 = D.25660->locals;
      D.25668 = mono_array_length (D.25665);
      iftmp.85 = (gint32) D.25668;
      goto <D.25669>;
      <D.25667>:
      iftmp.85 = 0;
      <D.25669>:
      num_locals = iftmp.85;
      D.25660 = mb->ilgen;
      D.25670 = D.25660->ex_handlers;
      if (D.25670 != 0B) goto <D.25671>; else goto <D.25672>;
      <D.25671>:
      D.25660 = mb->ilgen;
      D.25673 = method_count_clauses (D.25660);
      num_exception = (gint32) D.25673;
      <D.25672>:
      goto <D.25674>;
      <D.25662>:
      code = mb->code;
      if (code == 0B) goto <D.25675>; else goto <D.25676>;
      <D.25675>:
      {
        char * name;
        char * str;
        struct MonoException * exception;

        D.25677 = mb->name;
        name = mono_string_to_utf8 (D.25677);
        str = monoeg_g_strdup_printf ("Method %s does not have any IL associated", name);
        exception = mono_get_exception_argument (0B, "a method does not have any IL associated");
        monoeg_g_free (str);
        monoeg_g_free (name);
        mono_raise_exception (exception);
      }
      <D.25676>:
      code_size = mono_array_length (code);
      max_stack = 8;
      <D.25674>:
      D.25678 = &assembly->code;
      stream_data_align (D.25678);
      if (max_stack <= 8) goto <D.25682>; else goto <D.25680>;
      <D.25682>:
      if (num_locals == 0) goto <D.25683>; else goto <D.25680>;
      <D.25683>:
      if (num_exception == 0) goto <D.25684>; else goto <D.25680>;
      <D.25684>:
      iftmp.86 = 1;
      goto <D.25681>;
      <D.25680>:
      iftmp.86 = 0;
      <D.25681>:
      maybe_small = iftmp.86;
      if (maybe_small != 0) goto <D.25685>; else goto <D.25686>;
      <D.25685>:
      if (code_size <= 63) goto <D.25689>; else goto <D.25687>;
      <D.25689>:
      D.25690 = code_size & 1;
      if (D.25690 == 0) goto <D.25691>; else goto <D.25687>;
      <D.25691>:
      D.25692 = (unsigned char) code_size;
      D.25693 = D.25692 << 2;
      D.25694 = D.25693 | 2;
      flags.87 = (char) D.25694;
      flags = flags.87;
      goto <D.25688>;
      <D.25687>:
      if (code_size <= 31) goto <D.25696>; else goto fat_header;
      <D.25696>:
      D.25690 = code_size & 1;
      if (D.25690 != 0) goto <D.25697>; else goto fat_header;
      <D.25697>:
      D.25692 = (unsigned char) code_size;
      D.25693 = D.25692 << 2;
      D.25698 = D.25693 | 6;
      flags.88 = (char) D.25698;
      flags = flags.88;
      <D.25688>:
      D.25678 = &assembly->code;
      idx = mono_image_add_stream_data (D.25678, &flags, 1);
      D.25660 = mb->ilgen;
      if (D.25660 != 0B) goto <D.25700>; else goto <D.25701>;
      <D.25700>:
      D.25660 = mb->ilgen;
      D.25702 = D.25660->num_token_fixups;
      if (D.25702 != 0) goto <D.25703>; else goto <D.25704>;
      <D.25703>:
      D.25705 = assembly->token_fixups;
      D.25660 = mb->ilgen;
      D.25706 = idx + 1;
      D.25707 = (void *) D.25706;
      mono_g_hash_table_insert (D.25705, D.25660, D.25707);
      <D.25704>:
      <D.25701>:
      D.25678 = &assembly->code;
      D.25708 = mono_array_addr_with_size (code, 1, 0);
      mono_image_add_stream_data (D.25678, D.25708, code_size);
      D.25709 = assembly->text_rva;
      D.25659 = D.25709 + idx;
      return D.25659;
      <D.25686>:
      fat_header:
      if (num_locals != 0) goto <D.25710>; else goto <D.25711>;
      <D.25710>:
      D.25660 = mb->ilgen;
      D.25712 = encode_locals (assembly, D.25660);
      local_sig = D.25712 | 285212672;
      <D.25711>:
      fat_flags = 3;
      if (num_exception != 0) goto <D.25713>; else goto <D.25714>;
      <D.25713>:
      fat_flags = fat_flags | 8;
      <D.25714>:
      D.25715 = mb->init_locals;
      if (D.25715 != 0) goto <D.25716>; else goto <D.25717>;
      <D.25716>:
      fat_flags = fat_flags | 16;
      <D.25717>:
      D.25718 = (char) fat_flags;
      fat_header[0] = D.25718;
      D.25719 = header_size / 4;
      D.25720 = D.25719 << 4;
      D.25721 = (char) D.25720;
      fat_header[1] = D.25721;
      short_value.89 = (short unsigned int) max_stack;
      short_value = short_value.89;
      memcpy (&MEM[(void *)&fat_header + 2B], &short_value, 2);
      int_value = code_size;
      memcpy (&MEM[(void *)&fat_header + 4B], &int_value, 4);
      int_value = local_sig;
      memcpy (&MEM[(void *)&fat_header + 8B], &int_value, 4);
      D.25678 = &assembly->code;
      idx = mono_image_add_stream_data (D.25678, &fat_header, 12);
      D.25660 = mb->ilgen;
      if (D.25660 != 0B) goto <D.25723>; else goto <D.25724>;
      <D.25723>:
      D.25660 = mb->ilgen;
      D.25702 = D.25660->num_token_fixups;
      if (D.25702 != 0) goto <D.25725>; else goto <D.25726>;
      <D.25725>:
      D.25705 = assembly->token_fixups;
      D.25660 = mb->ilgen;
      D.25727 = idx + 12;
      D.25728 = (void *) D.25727;
      mono_g_hash_table_insert (D.25705, D.25660, D.25728);
      <D.25726>:
      <D.25724>:
      D.25678 = &assembly->code;
      D.25729 = mono_array_addr_with_size (code, 1, 0);
      mono_image_add_stream_data (D.25678, D.25729, code_size);
      if (num_exception != 0) goto <D.25730>; else goto <D.25731>;
      <D.25730>:
      {
        unsigned char sheader[4];
        struct MonoILExceptionInfo * ex_info;
        struct MonoILExceptionBlock * ex_block;
        int j;

        try
          {
            D.25678 = &assembly->code;
            stream_data_align (D.25678);
            sheader[0] = 65;
            num_exception.90 = (unsigned int) num_exception;
            D.25733 = num_exception.90 * 24;
            num_exception = (gint32) D.25733;
            num_exception = num_exception + 4;
            D.25734 = (unsigned char) num_exception;
            sheader[1] = D.25734;
            D.25735 = num_exception >> 8;
            D.25736 = (unsigned char) D.25735;
            sheader[2] = D.25736;
            D.25737 = num_exception >> 16;
            D.25738 = (unsigned char) D.25737;
            sheader[3] = D.25738;
            D.25678 = &assembly->code;
            mono_image_add_stream_data (D.25678, &sheader, 4);
            D.25660 = mb->ilgen;
            D.25670 = D.25660->ex_handlers;
            D.25739 = mono_array_length (D.25670);
            D.25740 = D.25739 + 4294967295;
            i = (gint32) D.25740;
            goto <D.18609>;
            <D.18608>:
            D.25660 = mb->ilgen;
            D.25670 = D.25660->ex_handlers;
            i.91 = (unsigned int) i;
            ex_info = mono_array_addr_with_size (D.25670, 16, i.91);
            D.25742 = ex_info->handlers;
            if (D.25742 != 0B) goto <D.25743>; else goto <D.25744>;
            <D.25743>:
            {
              int finally_start;

              D.25745 = ex_info->start;
              D.25746 = ex_info->len;
              finally_start = D.25745 + D.25746;
              j = 0;
              goto <D.18605>;
              <D.18604>:
              {
                guint32 val;

                try
                  {
                    D.25742 = ex_info->handlers;
                    j.92 = (unsigned int) j;
                    ex_block = mono_array_addr_with_size (D.25742, 20, j.92);
                    D.25748 = ex_block->type;
                    val.93 = (unsigned int) D.25748;
                    val = val.93;
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                    D.25745 = ex_info->start;
                    val.94 = (unsigned int) D.25745;
                    val = val.94;
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                    D.25748 = ex_block->type;
                    if (D.25748 == 2) goto <D.25751>; else goto <D.25752>;
                    <D.25751>:
                    D.25745 = ex_info->start;
                    D.25753 = finally_start - D.25745;
                    val.95 = (unsigned int) D.25753;
                    val = val.95;
                    goto <D.25755>;
                    <D.25752>:
                    D.25746 = ex_info->len;
                    val.96 = (unsigned int) D.25746;
                    val = val.96;
                    <D.25755>:
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                    D.25757 = ex_block->start;
                    val.97 = (unsigned int) D.25757;
                    val = val.97;
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                    D.25759 = ex_block->len;
                    val.98 = (unsigned int) D.25759;
                    val = val.98;
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                    D.25757 = ex_block->start;
                    D.25759 = ex_block->len;
                    finally_start = D.25757 + D.25759;
                    D.25761 = ex_block->extype;
                    if (D.25761 != 0B) goto <D.25762>; else goto <D.25763>;
                    <D.25762>:
                    D.25761 = ex_block->extype;
                    D.25764 = mono_reflection_type_get_handle (D.25761);
                    D.25765 = mono_image_typedef_or_ref (assembly, D.25764);
                    val.99 = mono_metadata_token_from_dor (D.25765);
                    val = val.99;
                    goto <D.25767>;
                    <D.25763>:
                    D.25748 = ex_block->type;
                    if (D.25748 == 1) goto <D.25768>; else goto <D.25769>;
                    <D.25768>:
                    D.25770 = ex_block->filter_offset;
                    val.100 = (unsigned int) D.25770;
                    val = val.100;
                    goto <D.25772>;
                    <D.25769>:
                    val = 0;
                    <D.25772>:
                    <D.25767>:
                    val.101 = val;
                    val = val.101;
                    D.25678 = &assembly->code;
                    mono_image_add_stream_data (D.25678, &val, 4);
                  }
                finally
                  {
                    val = {CLOBBER};
                  }
              }
              j = j + 1;
              <D.18605>:
              j.92 = (unsigned int) j;
              D.25742 = ex_info->handlers;
              D.25774 = mono_array_length (D.25742);
              if (j.92 < D.25774) goto <D.18604>; else goto <D.18606>;
              <D.18606>:
            }
            goto <D.25775>;
            <D.25744>:
            monoeg_g_log (0B, 4, "No clauses for ex info block %d", i);
            <D.18607>:
            goto <D.18607>;
            <D.25775>:
            i = i + -1;
            <D.18609>:
            if (i >= 0) goto <D.18608>; else goto <D.18610>;
            <D.18610>:
          }
        finally
          {
            sheader = {CLOBBER};
          }
      }
      <D.25731>:
      D.25709 = assembly->text_rva;
      D.25659 = D.25709 + idx;
      return D.25659;
    }
  finally
    {
      flags = {CLOBBER};
      fat_header = {CLOBBER};
      int_value = {CLOBBER};
      short_value = {CLOBBER};
    }
}


method_count_clauses (struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.25778;
  unsigned int i.102;
  struct MonoArray * D.25780;
  unsigned int D.25783;
  unsigned int D.25785;
  guint32 D.25786;
  guint32 num_clauses;
  int i;
  struct MonoILExceptionInfo * ex_info;

  num_clauses = 0;
  i = 0;
  goto <D.18552>;
  <D.18551>:
  D.25778 = ilgen->ex_handlers;
  i.102 = (unsigned int) i;
  ex_info = mono_array_addr_with_size (D.25778, 16, i.102);
  D.25780 = ex_info->handlers;
  if (D.25780 != 0B) goto <D.25781>; else goto <D.25782>;
  <D.25781>:
  D.25780 = ex_info->handlers;
  D.25783 = mono_array_length (D.25780);
  num_clauses = D.25783 + num_clauses;
  goto <D.25784>;
  <D.25782>:
  num_clauses = num_clauses + 1;
  <D.25784>:
  i = i + 1;
  <D.18552>:
  i.102 = (unsigned int) i;
  D.25778 = ilgen->ex_handlers;
  D.25785 = mono_array_length (D.25778);
  if (i.102 < D.25785) goto <D.18551>; else goto <D.18553>;
  <D.18553>:
  D.25786 = num_clauses;
  return D.25786;
}


encode_locals (struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.25788;
  unsigned int i.103;
  char * D.25790;
  unsigned char D.25791;
  struct MonoObject * D.25794;
  unsigned int i.104;
  struct GHashTable * D.25796;
  struct GHashTable * D.25799;
  const void * sig_idx.105;
  void * D.25801;
  guint32 D.25804;
  unsigned int D.25805;
  unsigned int idx.106;
  unsigned int D.25807;
  unsigned int D.25808;
  unsigned int D.25809;
  guint32 * D.25810;
  unsigned int D.25811;
  void * sig_idx.107;
  void * idx.108;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 idx;
  guint32 sig_idx;
  guint nl;
  struct SigBuffer buf;
  int i;

  try
    {
      D.25788 = ilgen->locals;
      nl = mono_array_length (D.25788);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, nl);
      i = 0;
      goto <D.18543>;
      <D.18542>:
      {
        struct MonoReflectionLocalBuilder * lb;

        D.25788 = ilgen->locals;
        i.103 = (unsigned int) i;
        D.25790 = mono_array_addr_with_size (D.25788, 4, i.103);
        lb = MEM[(struct MonoReflectionLocalBuilder * *)D.25790];
        D.25791 = lb->is_pinned;
        if (D.25791 != 0) goto <D.25792>; else goto <D.25793>;
        <D.25792>:
        sigbuffer_add_value (&buf, 69);
        <D.25793>:
        D.25794 = lb->type;
        encode_reflection_type (assembly, D.25794, &buf);
      }
      i = i + 1;
      <D.18543>:
      i.104 = (unsigned int) i;
      if (i.104 < nl) goto <D.18542>; else goto <D.18544>;
      <D.18544>:
      sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25796 = assembly->standalonesig_cache;
      if (D.25796 == 0B) goto <D.25797>; else goto <D.25798>;
      <D.25797>:
      D.25799 = monoeg_g_hash_table_new (0B, 0B);
      assembly->standalonesig_cache = D.25799;
      <D.25798>:
      D.25796 = assembly->standalonesig_cache;
      sig_idx.105 = (const void *) sig_idx;
      D.25801 = monoeg_g_hash_table_lookup (D.25796, sig_idx.105);
      idx = (guint32) D.25801;
      if (idx != 0) goto <D.25802>; else goto <D.25803>;
      <D.25802>:
      D.25804 = idx;
      return D.25804;
      <D.25803>:
      table = &assembly->tables[17];
      D.25805 = table->next_idx;
      idx.106 = D.25805;
      D.25807 = idx.106 + 1;
      table->next_idx = D.25807;
      idx = idx.106;
      D.25808 = table->rows;
      D.25809 = D.25808 + 1;
      table->rows = D.25809;
      D.25808 = table->rows;
      alloc_table (table, D.25808);
      D.25810 = table->values;
      D.25811 = idx * 4;
      values = D.25810 + D.25811;
      *values = sig_idx;
      D.25796 = assembly->standalonesig_cache;
      sig_idx.107 = (void *) sig_idx;
      idx.108 = (void *) idx;
      monoeg_g_hash_table_insert_replace (D.25796, sig_idx.107, idx.108, 0);
      D.25804 = idx;
      return D.25804;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


stream_data_align (struct MonoDynamicStream * stream)
{
  unsigned int D.25816;
  unsigned int D.25819;
  char buf[4];
  guint32 count;

  try
    {
      buf = {};
      D.25816 = stream->index;
      count = D.25816 & 3;
      if (count != 0) goto <D.25817>; else goto <D.25818>;
      <D.25817>:
      D.25819 = 4 - count;
      mono_image_add_stream_data (stream, &buf, D.25819);
      <D.25818>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_marshal_blob (struct MonoDynamicImage * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.25820;
  unsigned int D.25821;
  int D.25822;
  unsigned int D.25823;
  int D.25826;
  unsigned char D.25828;
  unsigned int D.25829;
  guint32 iftmp.109;
  int D.25833;
  guint32 iftmp.110;
  _Bool D.25841;
  unsigned int D.25842;
  struct MonoString * D.25845;
  struct MonoString * D.25852;
  struct MonoObject * D.25854;
  struct MonoType * D.25857;
  struct MonoString * D.25859;
  guint32 D.25863;
  char * str;
  struct SigBuffer buf;
  guint32 idx;
  guint32 len;

  try
    {
      sigbuffer_init (&buf, 32);
      D.25820 = minfo->type;
      D.25821 = (unsigned int) D.25820;
      sigbuffer_add_value (&buf, D.25821);
      D.25820 = minfo->type;
      switch (D.25820) <default: <D.18871>, case 23: <D.18865>, case 29: <D.18869>, case 30: <D.18866>, case 42: <D.18868>, case 44: <D.18870>>
      <D.18865>:
      <D.18866>:
      D.25822 = minfo->count;
      D.25823 = (unsigned int) D.25822;
      sigbuffer_add_value (&buf, D.25823);
      goto <D.18867>;
      <D.18868>:
      D.25826 = minfo->eltype;
      if (D.25826 != 0) goto <D.25824>; else goto <D.25827>;
      <D.25827>:
      D.25828 = minfo->has_size;
      if (D.25828 != 0) goto <D.25824>; else goto <D.25825>;
      <D.25824>:
      D.25826 = minfo->eltype;
      D.25829 = (unsigned int) D.25826;
      sigbuffer_add_value (&buf, D.25829);
      D.25828 = minfo->has_size;
      if (D.25828 != 0) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      D.25833 = minfo->param_num;
      if (D.25833 != -1) goto <D.25834>; else goto <D.25835>;
      <D.25834>:
      D.25833 = minfo->param_num;
      iftmp.109 = (guint32) D.25833;
      goto <D.25836>;
      <D.25835>:
      iftmp.109 = 0;
      <D.25836>:
      sigbuffer_add_value (&buf, iftmp.109);
      D.25822 = minfo->count;
      if (D.25822 != -1) goto <D.25838>; else goto <D.25839>;
      <D.25838>:
      D.25822 = minfo->count;
      iftmp.110 = (guint32) D.25822;
      goto <D.25840>;
      <D.25839>:
      iftmp.110 = 0;
      <D.25840>:
      sigbuffer_add_value (&buf, iftmp.110);
      D.25833 = minfo->param_num;
      D.25841 = D.25833 != -1;
      D.25842 = (unsigned int) D.25841;
      sigbuffer_add_value (&buf, D.25842);
      <D.25831>:
      <D.25825>:
      goto <D.18867>;
      <D.18869>:
      D.25826 = minfo->eltype;
      if (D.25826 != 0) goto <D.25843>; else goto <D.25844>;
      <D.25843>:
      D.25826 = minfo->eltype;
      D.25829 = (unsigned int) D.25826;
      sigbuffer_add_value (&buf, D.25829);
      <D.25844>:
      goto <D.18867>;
      <D.18870>:
      D.25845 = minfo->guid;
      if (D.25845 != 0B) goto <D.25846>; else goto <D.25847>;
      <D.25846>:
      D.25845 = minfo->guid;
      str = mono_string_to_utf8 (D.25845);
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25848>;
      <D.25847>:
      sigbuffer_add_value (&buf, 0);
      <D.25848>:
      sigbuffer_add_value (&buf, 0);
      D.25852 = minfo->marshaltype;
      if (D.25852 != 0B) goto <D.25849>; else goto <D.25853>;
      <D.25853>:
      D.25854 = minfo->marshaltyperef;
      if (D.25854 != 0B) goto <D.25849>; else goto <D.25850>;
      <D.25849>:
      D.25854 = minfo->marshaltyperef;
      if (D.25854 != 0B) goto <D.25855>; else goto <D.25856>;
      <D.25855>:
      D.25854 = minfo->marshaltyperef;
      D.25857 = mono_reflection_type_get_handle (D.25854);
      str = type_get_fully_qualified_name (D.25857);
      goto <D.25858>;
      <D.25856>:
      D.25852 = minfo->marshaltype;
      str = mono_string_to_utf8 (D.25852);
      <D.25858>:
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25851>;
      <D.25850>:
      sigbuffer_add_value (&buf, 0);
      <D.25851>:
      D.25859 = minfo->mcookie;
      if (D.25859 != 0B) goto <D.25860>; else goto <D.25861>;
      <D.25860>:
      D.25859 = minfo->mcookie;
      str = mono_string_to_utf8 (D.25859);
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25862>;
      <D.25861>:
      sigbuffer_add_value (&buf, 0);
      <D.25862>:
      goto <D.18867>;
      <D.18871>:
      goto <D.18867>;
      <D.18867>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25863 = idx;
      return D.25863;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


type_get_fully_qualified_name (struct MonoType * type)
{
  char * D.25867;

  D.25867 = mono_type_get_name_full (type, 3);
  return D.25867;
}


sigbuffer_add_mem (struct SigBuffer * buf, char * p, guint32 size)
{
  int size.111;
  char * D.25870;
  char * D.25871;

  size.111 = (int) size;
  sigbuffer_make_room (buf, size.111);
  D.25870 = buf->p;
  memcpy (D.25870, p, size);
  D.25870 = buf->p;
  D.25871 = D.25870 + size;
  buf->p = D.25871;
}


encode_constant (struct MonoDynamicImage * assembly, struct MonoObject * val, guint32 * ret_type)
{
  struct MonoVTable * D.25875;
  struct MonoClass * D.25876;
  unsigned char D.25877;
  unsigned int D.25878;
  unsigned int D.25879;
  unsigned int D.25880;
  unsigned int D.25881;
  struct MonoType * D.25884;
  unsigned char D.25885;
  unsigned int D.25886;
  struct MonoImage * D.25889;
  int D.25890;
  int D.18840;
  int iftmp.112;
  int D.18839;
  const char[7] * D.25895;
  unsigned char D.25896;
  int D.25897;
  unsigned char D.25898;
  int D.25899;
  const unsigned char * D.25904;
  unsigned char D.25905;
  int D.25906;
  const unsigned char * D.25907;
  unsigned char D.25908;
  int D.25909;
  const unsigned char * D.25914;
  unsigned char D.25915;
  int D.25916;
  const unsigned char * D.25917;
  unsigned char D.25918;
  int D.25919;
  const unsigned char * D.25924;
  unsigned char D.25925;
  int D.25926;
  const unsigned char * D.25927;
  unsigned char D.25928;
  int D.25929;
  const char * D.25931;
  int D.18849;
  int iftmp.113;
  int D.18848;
  const char[9] * D.25936;
  unsigned char D.25937;
  int D.25938;
  unsigned char D.25939;
  int D.25940;
  const unsigned char * D.25945;
  unsigned char D.25946;
  int D.25947;
  const unsigned char * D.25948;
  unsigned char D.25949;
  int D.25950;
  const unsigned char * D.25955;
  unsigned char D.25956;
  int D.25957;
  const unsigned char * D.25958;
  unsigned char D.25959;
  int D.25960;
  const unsigned char * D.25965;
  unsigned char D.25966;
  int D.25967;
  const unsigned char * D.25968;
  unsigned char D.25969;
  int D.25970;
  const char * D.25972;
  int D.25974;
  int D.25975;
  char * b.114;
  int b.115;
  int blob_size.116;
  int D.25979;
  mono_unichar2 * D.25980;
  int len.117;
  guint32 D.25982;
  struct MonoGenericClass * D.25983;
  struct MonoClass * D.25984;
  unsigned char D.25985;
  unsigned int D.25986;
  char blob_size[64];
  char * b;
  char * p;
  char * box_val;
  char * buf;
  guint32 idx;
  guint32 len;
  guint32 dummy;
  void handle_enum = <<< error >>>;

  try
    {
      b = &blob_size;
      idx = 0;
      len = 0;
      dummy = 0;
      buf = monoeg_malloc (64);
      p = buf;
      if (val == 0B) goto <D.25872>; else goto <D.25873>;
      <D.25872>:
      *ret_type = 18;
      len = 4;
      box_val = &dummy;
      goto <D.25874>;
      <D.25873>:
      box_val = val + 8;
      D.25875 = val->vtable;
      D.25876 = D.25875->klass;
      D.25877 = D.25876->byval_arg.type;
      D.25878 = (unsigned int) D.25877;
      *ret_type = D.25878;
      <D.25874>:
      handle_enum:
      D.25879 = *ret_type;
      switch (D.25879) <default: <D.18855>, case 2: <D.18817>, case 3: <D.18821>, case 4: <D.18819>, case 5: <D.18818>, case 6: <D.18823>, case 7: <D.18822>, case 8: <D.18825>, case 9: <D.18824>, case 10: <D.18828>, case 11: <D.18827>, case 12: <D.18826>, case 13: <D.18829>, case 14: <D.18852>, case 17: <D.18830>, case 18: <D.18851>, case 21: <D.18854>>
      <D.18817>:
      <D.18818>:
      <D.18819>:
      len = 1;
      goto <D.18820>;
      <D.18821>:
      <D.18822>:
      <D.18823>:
      len = 2;
      goto <D.18820>;
      <D.18824>:
      <D.18825>:
      <D.18826>:
      len = 4;
      goto <D.18820>;
      <D.18827>:
      <D.18828>:
      len = 8;
      goto <D.18820>;
      <D.18829>:
      len = 8;
      goto <D.18820>;
      <D.18830>:
      {
        struct MonoClass * klass;

        D.25875 = val->vtable;
        klass = D.25875->klass;
        D.25880 = BIT_FIELD_REF <*klass, 32, 160>;
        D.25881 = D.25880 & 16;
        if (D.25881 != 0) goto <D.25882>; else goto <D.25883>;
        <D.25882>:
        D.25884 = mono_class_enum_basetype (klass);
        D.25885 = D.25884->type;
        D.25886 = (unsigned int) D.25885;
        *ret_type = D.25886;
        goto handle_enum;
        <D.25883>:
        D.25889 = klass->image;
        D.25890 = mono_is_corlib_image (D.25889);
        if (D.25890 != 0) goto <D.25891>; else goto <D.25887>;
        <D.25891>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.25895 = "System";
            D.25896 = MEM[(const unsigned char *)D.25895];
            D.25897 = (int) D.25896;
            D.25898 = *__s2;
            D.25899 = (int) D.25898;
            __result = D.25897 - D.25899;
            {
              if (__s2_len != 0) goto <D.25900>; else goto <D.25901>;
              <D.25900>:
              if (__result == 0) goto <D.25902>; else goto <D.25903>;
              <D.25902>:
              D.25904 = &MEM[(void *)"System" + 1B];
              D.25905 = *D.25904;
              D.25906 = (int) D.25905;
              D.25907 = __s2 + 1;
              D.25908 = *D.25907;
              D.25909 = (int) D.25908;
              __result = D.25906 - D.25909;
              if (__s2_len > 1) goto <D.25910>; else goto <D.25911>;
              <D.25910>:
              if (__result == 0) goto <D.25912>; else goto <D.25913>;
              <D.25912>:
              D.25914 = &MEM[(void *)"System" + 2B];
              D.25915 = *D.25914;
              D.25916 = (int) D.25915;
              D.25917 = __s2 + 2;
              D.25918 = *D.25917;
              D.25919 = (int) D.25918;
              __result = D.25916 - D.25919;
              if (__s2_len > 2) goto <D.25920>; else goto <D.25921>;
              <D.25920>:
              if (__result == 0) goto <D.25922>; else goto <D.25923>;
              <D.25922>:
              D.25924 = &MEM[(void *)"System" + 3B];
              D.25925 = *D.25924;
              D.25926 = (int) D.25925;
              D.25927 = __s2 + 3;
              D.25928 = *D.25927;
              D.25929 = (int) D.25928;
              __result = D.25926 - D.25929;
              <D.25923>:
              <D.25921>:
              <D.25913>:
              <D.25911>:
              <D.25903>:
              <D.25901>:
            }
            D.18839 = __result;
          }
          iftmp.112 = -D.18839;
          goto <D.25930>;
          <D.25894>:
          D.25931 = klass->name_space;
          iftmp.112 = __builtin_strcmp (D.25931, "System");
          <D.25930>:
          D.18840 = iftmp.112;
        }
        if (D.18840 == 0) goto <D.25932>; else goto <D.25887>;
        <D.25932>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.25936 = "DateTime";
            D.25937 = MEM[(const unsigned char *)D.25936];
            D.25938 = (int) D.25937;
            D.25939 = *__s2;
            D.25940 = (int) D.25939;
            __result = D.25938 - D.25940;
            {
              if (__s2_len != 0) goto <D.25941>; else goto <D.25942>;
              <D.25941>:
              if (__result == 0) goto <D.25943>; else goto <D.25944>;
              <D.25943>:
              D.25945 = &MEM[(void *)"DateTime" + 1B];
              D.25946 = *D.25945;
              D.25947 = (int) D.25946;
              D.25948 = __s2 + 1;
              D.25949 = *D.25948;
              D.25950 = (int) D.25949;
              __result = D.25947 - D.25950;
              if (__s2_len > 1) goto <D.25951>; else goto <D.25952>;
              <D.25951>:
              if (__result == 0) goto <D.25953>; else goto <D.25954>;
              <D.25953>:
              D.25955 = &MEM[(void *)"DateTime" + 2B];
              D.25956 = *D.25955;
              D.25957 = (int) D.25956;
              D.25958 = __s2 + 2;
              D.25959 = *D.25958;
              D.25960 = (int) D.25959;
              __result = D.25957 - D.25960;
              if (__s2_len > 2) goto <D.25961>; else goto <D.25962>;
              <D.25961>:
              if (__result == 0) goto <D.25963>; else goto <D.25964>;
              <D.25963>:
              D.25965 = &MEM[(void *)"DateTime" + 3B];
              D.25966 = *D.25965;
              D.25967 = (int) D.25966;
              D.25968 = __s2 + 3;
              D.25969 = *D.25968;
              D.25970 = (int) D.25969;
              __result = D.25967 - D.25970;
              <D.25964>:
              <D.25962>:
              <D.25954>:
              <D.25952>:
              <D.25944>:
              <D.25942>:
            }
            D.18848 = __result;
          }
          iftmp.113 = -D.18848;
          goto <D.25971>;
          <D.25935>:
          D.25972 = klass->name;
          iftmp.113 = __builtin_strcmp (D.25972, "DateTime");
          <D.25971>:
          D.18849 = iftmp.113;
        }
        if (D.18849 == 0) goto <D.25973>; else goto <D.25887>;
        <D.25973>:
        len = 8;
        goto <D.25888>;
        <D.25887>:
        monoeg_g_log (0B, 4, "we can\'t encode valuetypes, we should have never reached this line");
        <D.18850>:
        goto <D.18850>;
        <D.25888>:
        goto <D.18820>;
      }
      <D.18851>:
      goto <D.18820>;
      <D.18852>:
      {
        struct MonoString * str;

        str = val;
        D.25974 = str->length;
        D.25975 = D.25974 * 2;
        len = (guint32) D.25975;
        b.114 = b;
        mono_metadata_encode_value (len, b.114, &b);
        b.114 = b;
        b.115 = (int) b.114;
        blob_size.116 = (int) &blob_size;
        D.25979 = b.115 - blob_size.116;
        D.25980 = mono_string_chars (str);
        len.117 = (int) len;
        idx = add_to_blob_cached (assembly, &blob_size, D.25979, D.25980, len.117);
        monoeg_g_free (buf);
        D.25982 = idx;
        return D.25982;
      }
      <D.18854>:
      D.25875 = val->vtable;
      D.25876 = D.25875->klass;
      D.25983 = D.25876->generic_class;
      D.25984 = D.25983->container_class;
      D.25985 = D.25984->byval_arg.type;
      D.25986 = (unsigned int) D.25985;
      *ret_type = D.25986;
      goto handle_enum;
      <D.18855>:
      D.25879 = *ret_type;
      monoeg_g_log (0B, 4, "we don\'t encode constant type 0x%02x yet", D.25879);
      <D.18856>:
      goto <D.18856>;
      <D.18820>:
      b.114 = b;
      mono_metadata_encode_value (len, b.114, &b);
      b.114 = b;
      b.115 = (int) b.114;
      blob_size.116 = (int) &blob_size;
      D.25979 = b.115 - blob_size.116;
      len.117 = (int) len;
      idx = add_to_blob_cached (assembly, &blob_size, D.25979, box_val, len.117);
      monoeg_g_free (buf);
      D.25982 = idx;
      return D.25982;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
      dummy = {CLOBBER};
    }
}


find_index_in_table (struct MonoDynamicImage * assembly, int table_idx, int col, guint32 token)
{
  unsigned char D.25990;
  int D.25991;
  _Bool D.25992;
  long int D.25993;
  long int D.25994;
  guint32 * D.25997;
  unsigned int D.25998;
  unsigned int D.25999;
  unsigned int col.118;
  unsigned int D.26001;
  guint32 * D.26002;
  unsigned int D.26003;
  guint32 D.26006;
  unsigned int i.119;
  unsigned int D.26008;
  int i;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[table_idx];
  D.25990 = table->columns;
  D.25991 = (int) D.25990;
  D.25992 = D.25991 <= col;
  D.25993 = (long int) D.25992;
  D.25994 = __builtin_expect (D.25993, 0);
  if (D.25994 != 0) goto <D.25995>; else goto <D.25996>;
  <D.25995>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1155, "col < table->columns");
  <D.25996>:
  D.25997 = table->values;
  D.25990 = table->columns;
  D.25998 = (unsigned int) D.25990;
  D.25999 = D.25998 * 4;
  values = D.25997 + D.25999;
  i = 1;
  goto <D.18621>;
  <D.18620>:
  col.118 = (unsigned int) col;
  D.26001 = col.118 * 4;
  D.26002 = values + D.26001;
  D.26003 = *D.26002;
  if (D.26003 == token) goto <D.26004>; else goto <D.26005>;
  <D.26004>:
  D.26006 = (guint32) i;
  return D.26006;
  <D.26005>:
  D.25990 = table->columns;
  D.25998 = (unsigned int) D.25990;
  D.25999 = D.25998 * 4;
  values = values + D.25999;
  i = i + 1;
  <D.18621>:
  i.119 = (unsigned int) i;
  D.26008 = table->rows;
  if (i.119 <= D.26008) goto <D.18620>; else goto <D.18622>;
  <D.18622>:
  D.26006 = 0;
  return D.26006;
}


mono_image_get_generic_param_info (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  int D.26010;
  struct MonoReflectionGenericParam * * D.26015;
  void * D.26016;
  struct GPtrArray * D.26017;
  struct GenericParamTableEntry * entry;

  entry = monoeg_malloc0 (8);
  entry->owner = owner;
  D.26010 = mono_gc_is_moving ();
  if (D.26010 != 0) goto <D.26011>; else goto <D.26012>;
  <D.26011>:
  if (0 != 0) goto <D.26013>; else goto <D.26014>;
  <D.26013>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2206, "sizeof (entry->gparam) == sizeof (MonoObject*)");
  <D.26014>:
  D.26015 = &entry->gparam;
  D.26016 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.26015, 4, D.26016);
  <D.26012>:
  entry->gparam = gparam;
  D.26017 = assembly->gen_params;
  monoeg_g_ptr_array_add (D.26017, entry);
}


mono_image_get_field_info (struct MonoReflectionFieldBuilder * fb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26018;
  unsigned int D.26019;
  unsigned int D.26022;
  unsigned int D.26023;
  unsigned int D.26024;
  unsigned int D.26025;
  int D.26026;
  struct GHashTable * D.26027;
  struct MonoClassField * D.26028;
  int D.26029;
  void * D.26030;
  guint32 * D.26031;
  unsigned int D.26032;
  unsigned int D.26033;
  guint32 * D.26034;
  struct MonoDynamicStream * D.26035;
  struct MonoString * D.26036;
  unsigned int D.26037;
  guint32 * D.26038;
  unsigned int D.26039;
  int D.26040;
  unsigned int D.26043;
  unsigned int D.26044;
  unsigned int D.26045;
  unsigned int D.26046;
  unsigned int D.26047;
  unsigned int D.26050;
  int D.26051;
  unsigned int D.26052;
  guint32 * D.26053;
  struct MonoObject * D.26054;
  unsigned int D.26055;
  unsigned int field_type.120;
  unsigned int D.26057;
  struct MonoArray * D.26060;
  unsigned int D.26063;
  struct MonoDynamicStream * D.26066;
  char * D.26067;
  unsigned int D.26068;
  struct MonoClass * D.26070;
  int D.26071;
  unsigned int D.26072;
  unsigned int D.26073;
  unsigned int D.26074;
  struct MonoReflectionMarshal * D.26075;
  int D.26078;
  unsigned int D.26079;
  unsigned int D.26080;
  struct MonoDynamicTable * table;
  guint32 * values;

  D.26018 = fb->attrs;
  D.26019 = D.26018 & 64;
  if (D.26019 != 0) goto <D.26020>; else goto <D.26021>;
  <D.26020>:
  D.26018 = fb->attrs;
  D.26022 = D.26018 | 32768;
  fb->attrs = D.26022;
  <D.26021>:
  table = &assembly->tables[4];
  D.26023 = table->next_idx;
  D.26024 = D.26023;
  D.26025 = D.26024 + 1;
  table->next_idx = D.26025;
  D.26026 = (int) D.26024;
  fb->table_idx = D.26026;
  D.26027 = assembly->field_to_table_idx;
  D.26028 = fb->handle;
  D.26029 = fb->table_idx;
  D.26030 = (void *) D.26029;
  monoeg_g_hash_table_insert_replace (D.26027, D.26028, D.26030, 0);
  D.26031 = table->values;
  D.26029 = fb->table_idx;
  D.26032 = (unsigned int) D.26029;
  D.26033 = D.26032 * 12;
  values = D.26031 + D.26033;
  D.26034 = values + 4;
  D.26035 = &assembly->sheap;
  D.26036 = fb->name;
  D.26037 = string_heap_insert_mstring (D.26035, D.26036);
  *D.26034 = D.26037;
  D.26018 = fb->attrs;
  *values = D.26018;
  D.26038 = values + 8;
  D.26039 = field_encode_signature (assembly, fb);
  *D.26038 = D.26039;
  D.26040 = fb->offset;
  if (D.26040 != -1) goto <D.26041>; else goto <D.26042>;
  <D.26041>:
  table = &assembly->tables[16];
  D.26043 = table->rows;
  D.26044 = D.26043 + 1;
  table->rows = D.26044;
  D.26043 = table->rows;
  alloc_table (table, D.26043);
  D.26031 = table->values;
  D.26043 = table->rows;
  D.26045 = D.26043 * 8;
  values = D.26031 + D.26045;
  D.26034 = values + 4;
  D.26029 = fb->table_idx;
  D.26046 = (unsigned int) D.26029;
  *D.26034 = D.26046;
  D.26040 = fb->offset;
  D.26047 = (unsigned int) D.26040;
  *values = D.26047;
  <D.26042>:
  D.26018 = fb->attrs;
  D.26019 = D.26018 & 64;
  if (D.26019 != 0) goto <D.26048>; else goto <D.26049>;
  <D.26048>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.26043 = table->rows;
        D.26044 = D.26043 + 1;
        table->rows = D.26044;
        D.26043 = table->rows;
        alloc_table (table, D.26043);
        D.26031 = table->values;
        D.26043 = table->rows;
        D.26050 = D.26043 * 16;
        values = D.26031 + D.26050;
        D.26038 = values + 8;
        D.26029 = fb->table_idx;
        D.26051 = D.26029 << 2;
        D.26052 = (unsigned int) D.26051;
        *D.26038 = D.26052;
        D.26053 = values + 12;
        D.26054 = fb->def_value;
        D.26055 = encode_constant (assembly, D.26054, &field_type);
        *D.26053 = D.26055;
        field_type.120 = field_type;
        *values = field_type.120;
        D.26034 = values + 4;
        *D.26034 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.26049>:
  D.26018 = fb->attrs;
  D.26057 = D.26018 & 256;
  if (D.26057 != 0) goto <D.26058>; else goto <D.26059>;
  <D.26058>:
  {
    guint32 rva_idx;

    table = &assembly->tables[29];
    D.26043 = table->rows;
    D.26044 = D.26043 + 1;
    table->rows = D.26044;
    D.26043 = table->rows;
    alloc_table (table, D.26043);
    D.26031 = table->values;
    D.26043 = table->rows;
    D.26045 = D.26043 * 8;
    values = D.26031 + D.26045;
    D.26034 = values + 4;
    D.26029 = fb->table_idx;
    D.26046 = (unsigned int) D.26029;
    *D.26034 = D.26046;
    D.26060 = fb->rva_data;
    if (D.26060 != 0B) goto <D.26061>; else goto <D.26062>;
    <D.26061>:
    D.26060 = fb->rva_data;
    D.26063 = mono_array_length (D.26060);
    if (D.26063 > 9) goto <D.26064>; else goto <D.26065>;
    <D.26064>:
    D.26066 = &assembly->code;
    stream_data_align (D.26066);
    <D.26065>:
    D.26066 = &assembly->code;
    D.26060 = fb->rva_data;
    D.26067 = mono_array_addr_with_size (D.26060, 1, 0);
    D.26060 = fb->rva_data;
    D.26068 = mono_array_length (D.26060);
    rva_idx = mono_image_add_stream_data (D.26066, D.26067, D.26068);
    goto <D.26069>;
    <D.26062>:
    D.26066 = &assembly->code;
    D.26028 = fb->handle;
    D.26070 = D.26028->parent;
    D.26071 = mono_class_value_size (D.26070, 0B);
    D.26072 = (unsigned int) D.26071;
    rva_idx = mono_image_add_stream_zero (D.26066, D.26072);
    <D.26069>:
    D.26073 = assembly->text_rva;
    D.26074 = D.26073 + rva_idx;
    *values = D.26074;
  }
  <D.26059>:
  D.26075 = fb->marshal_info;
  if (D.26075 != 0B) goto <D.26076>; else goto <D.26077>;
  <D.26076>:
  table = &assembly->tables[13];
  D.26043 = table->rows;
  D.26044 = D.26043 + 1;
  table->rows = D.26044;
  D.26043 = table->rows;
  alloc_table (table, D.26043);
  D.26031 = table->values;
  D.26043 = table->rows;
  D.26045 = D.26043 * 8;
  values = D.26031 + D.26045;
  D.26029 = fb->table_idx;
  D.26078 = D.26029 << 1;
  D.26079 = (unsigned int) D.26078;
  *values = D.26079;
  D.26034 = values + 4;
  D.26075 = fb->marshal_info;
  D.26080 = encode_marshal_blob (assembly, D.26075);
  *D.26034 = D.26080;
  <D.26077>:
}


field_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoObject * D.26081;
  struct MonoArray * D.26082;
  struct MonoArray * D.26083;
  struct MonoGenericContainer * D.26084;
  struct MonoGenericInst * D.26089;
  guint32 D.26091;
  struct SigBuffer buf;
  guint32 idx;
  guint32 typespec;
  struct MonoType * type;
  struct MonoClass * class;

  try
    {
      typespec = 0;
      D.26081 = fb->type;
      init_type_builder_generics (D.26081);
      D.26081 = fb->type;
      type = mono_reflection_type_get_handle (D.26081);
      class = mono_class_from_mono_type (type);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.26082 = fb->modreq;
      D.26083 = fb->modopt;
      encode_custom_modifiers (assembly, D.26082, D.26083, &buf);
      D.26084 = class->generic_container;
      if (D.26084 != 0B) goto <D.26085>; else goto <D.26086>;
      <D.26085>:
      typespec = create_typespec (assembly, type);
      <D.26086>:
      if (typespec != 0) goto <D.26087>; else goto <D.26088>;
      <D.26087>:
      {
        struct MonoGenericClass * gclass;

        D.26084 = class->generic_container;
        D.26089 = D.26084->context.class_inst;
        gclass = mono_metadata_lookup_generic_class (class, D.26089, 1);
        encode_generic_class (assembly, gclass, &buf);
      }
      goto <D.26090>;
      <D.26088>:
      encode_type (assembly, type, &buf);
      <D.26090>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26091 = idx;
      return D.26091;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


init_type_builder_generics (struct MonoObject * type)
{
  struct MonoVTable * D.26094;
  struct MonoClass * D.26095;
  int D.26096;
  struct MonoGenericContainer * D.26101;
  struct MonoReflectionTypeBuilder * tb;

  D.26094 = type->vtable;
  D.26095 = D.26094->klass;
  D.26096 = is_sre_type_builder (D.26095);
  if (D.26096 == 0) goto <D.26097>; else goto <D.26098>;
  <D.26097>:
  return;
  <D.26098>:
  tb = type;
  if (tb != 0B) goto <D.26099>; else goto <D.26100>;
  <D.26099>:
  D.26101 = tb->generic_container;
  if (D.26101 != 0B) goto <D.26102>; else goto <D.26103>;
  <D.26102>:
  mono_reflection_create_generic_class (tb);
  <D.26103>:
  <D.26100>:
}


is_sre_type_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.121;
  gboolean D.26108;
  _Bool D.26109;
  int D.26110;
  int D.22196;
  int iftmp.122;
  int D.22192;
  const char[12] * D.26116;
  unsigned char D.26117;
  int D.26118;
  unsigned char D.26119;
  int D.26120;
  const unsigned char * D.26125;
  unsigned char D.26126;
  int D.26127;
  const unsigned char * D.26128;
  unsigned char D.26129;
  int D.26130;
  const unsigned char * D.26135;
  unsigned char D.26136;
  int D.26137;
  const unsigned char * D.26138;
  unsigned char D.26139;
  int D.26140;
  const unsigned char * D.26145;
  unsigned char D.26146;
  int D.26147;
  const unsigned char * D.26148;
  unsigned char D.26149;
  int D.26150;
  const char * D.26152;
  int D.22205;
  int iftmp.123;
  int D.22201;
  const char[23] * D.26158;
  unsigned char D.26159;
  int D.26160;
  unsigned char D.26161;
  int D.26162;
  const unsigned char * D.26167;
  unsigned char D.26168;
  int D.26169;
  const unsigned char * D.26170;
  unsigned char D.26171;
  int D.26172;
  const unsigned char * D.26177;
  unsigned char D.26178;
  int D.26179;
  const unsigned char * D.26180;
  unsigned char D.26181;
  int D.26182;
  const unsigned char * D.26187;
  unsigned char D.26188;
  int D.26189;
  const unsigned char * D.26190;
  unsigned char D.26191;
  int D.26192;
  const char * D.26194;

  {
    static struct MonoClass * cached_class;

    cached_class.121 = cached_class;
    if (cached_class.121 != 0B) goto <D.26106>; else goto <D.26107>;
    <D.26106>:
    cached_class.121 = cached_class;
    D.26109 = cached_class.121 == class;
    D.26108 = (gboolean) D.26109;
    return D.26108;
    <D.26107>:
    D.26110 = is_corlib_type (class);
    if (D.26110 != 0) goto <D.26111>; else goto <D.26112>;
    <D.26111>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 11;
      if (__s1_len <= 3) goto <D.26114>; else goto <D.26115>;
      <D.26114>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.26116 = "TypeBuilder";
        D.26117 = MEM[(const unsigned char *)D.26116];
        D.26118 = (int) D.26117;
        D.26119 = *__s2;
        D.26120 = (int) D.26119;
        __result = D.26118 - D.26120;
        {
          if (__s1_len != 0) goto <D.26121>; else goto <D.26122>;
          <D.26121>:
          if (__result == 0) goto <D.26123>; else goto <D.26124>;
          <D.26123>:
          D.26125 = &MEM[(void *)"TypeBuilder" + 1B];
          D.26126 = *D.26125;
          D.26127 = (int) D.26126;
          D.26128 = __s2 + 1;
          D.26129 = *D.26128;
          D.26130 = (int) D.26129;
          __result = D.26127 - D.26130;
          if (__s1_len > 1) goto <D.26131>; else goto <D.26132>;
          <D.26131>:
          if (__result == 0) goto <D.26133>; else goto <D.26134>;
          <D.26133>:
          D.26135 = &MEM[(void *)"TypeBuilder" + 2B];
          D.26136 = *D.26135;
          D.26137 = (int) D.26136;
          D.26138 = __s2 + 2;
          D.26139 = *D.26138;
          D.26140 = (int) D.26139;
          __result = D.26137 - D.26140;
          if (__s1_len > 2) goto <D.26141>; else goto <D.26142>;
          <D.26141>:
          if (__result == 0) goto <D.26143>; else goto <D.26144>;
          <D.26143>:
          D.26145 = &MEM[(void *)"TypeBuilder" + 3B];
          D.26146 = *D.26145;
          D.26147 = (int) D.26146;
          D.26148 = __s2 + 3;
          D.26149 = *D.26148;
          D.26150 = (int) D.26149;
          __result = D.26147 - D.26150;
          <D.26144>:
          <D.26142>:
          <D.26134>:
          <D.26132>:
          <D.26124>:
          <D.26122>:
        }
        D.22192 = __result;
      }
      iftmp.122 = D.22192;
      goto <D.26151>;
      <D.26115>:
      D.26152 = class->name;
      iftmp.122 = __builtin_strcmp ("TypeBuilder", D.26152);
      <D.26151>:
      D.22196 = iftmp.122;
    }
    if (D.22196 == 0) goto <D.26153>; else goto <D.26154>;
    <D.26153>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.26156>; else goto <D.26157>;
      <D.26156>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.26158 = "System.Reflection.Emit";
        D.26159 = MEM[(const unsigned char *)D.26158];
        D.26160 = (int) D.26159;
        D.26161 = *__s2;
        D.26162 = (int) D.26161;
        __result = D.26160 - D.26162;
        {
          if (__s1_len != 0) goto <D.26163>; else goto <D.26164>;
          <D.26163>:
          if (__result == 0) goto <D.26165>; else goto <D.26166>;
          <D.26165>:
          D.26167 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.26168 = *D.26167;
          D.26169 = (int) D.26168;
          D.26170 = __s2 + 1;
          D.26171 = *D.26170;
          D.26172 = (int) D.26171;
          __result = D.26169 - D.26172;
          if (__s1_len > 1) goto <D.26173>; else goto <D.26174>;
          <D.26173>:
          if (__result == 0) goto <D.26175>; else goto <D.26176>;
          <D.26175>:
          D.26177 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.26178 = *D.26177;
          D.26179 = (int) D.26178;
          D.26180 = __s2 + 2;
          D.26181 = *D.26180;
          D.26182 = (int) D.26181;
          __result = D.26179 - D.26182;
          if (__s1_len > 2) goto <D.26183>; else goto <D.26184>;
          <D.26183>:
          if (__result == 0) goto <D.26185>; else goto <D.26186>;
          <D.26185>:
          D.26187 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.26188 = *D.26187;
          D.26189 = (int) D.26188;
          D.26190 = __s2 + 3;
          D.26191 = *D.26190;
          D.26192 = (int) D.26191;
          __result = D.26189 - D.26192;
          <D.26186>:
          <D.26184>:
          <D.26176>:
          <D.26174>:
          <D.26166>:
          <D.26164>:
        }
        D.22201 = __result;
      }
      iftmp.123 = D.22201;
      goto <D.26193>;
      <D.26157>:
      D.26194 = class->name_space;
      iftmp.123 = __builtin_strcmp ("System.Reflection.Emit", D.26194);
      <D.26193>:
      D.22205 = iftmp.123;
    }
    if (D.22205 == 0) goto <D.26195>; else goto <D.26196>;
    <D.26195>:
    cached_class = class;
    D.26108 = 1;
    return D.26108;
    <D.26196>:
    <D.26154>:
    <D.26112>:
    D.26108 = 0;
    return D.26108;
  }
}


is_corlib_type (struct MonoClass * class)
{
  gboolean D.26198;
  struct MonoImage * D.26199;
  struct MonoImage * D.26200;
  _Bool D.26201;

  D.26199 = class->image;
  D.26200 = mono_defaults.corlib;
  D.26201 = D.26199 == D.26200;
  D.26198 = (gboolean) D.26201;
  return D.26198;
}


mono_image_add_stream_zero (struct MonoDynamicStream * stream, guint32 len)
{
  unsigned int D.26203;
  unsigned int D.26204;
  int D.26205;
  char * D.26206;
  void * D.26207;
  guint32 D.26208;
  guint32 idx;

  D.26203 = stream->index;
  D.26204 = D.26203 + len;
  D.26205 = (int) D.26204;
  make_room_in_stream (stream, D.26205);
  D.26206 = stream->data;
  D.26203 = stream->index;
  D.26207 = D.26206 + D.26203;
  memset (D.26207, 0, len);
  idx = stream->index;
  D.26203 = stream->index;
  D.26204 = D.26203 + len;
  stream->index = D.26204;
  D.26208 = idx;
  return D.26208;
}


mono_image_fill_module_table (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26210;
  unsigned int D.26211;
  unsigned int D.26212;
  guint32 * D.26213;
  unsigned int D.26214;
  unsigned int D.26215;
  sizetype D.26216;
  guint32 * D.26217;
  struct MonoDynamicStream * D.26218;
  struct MonoString * D.26219;
  unsigned int D.26220;
  struct MonoDynamicStream * D.26221;
  struct MonoArray * D.26222;
  char * D.26223;
  unsigned int D.26224;
  guint32 * D.26225;
  sizetype D.26226;
  guint32 * D.26227;
  unsigned int i.124;
  sizetype D.26229;
  guint32 * D.26230;
  sizetype D.26231;
  guint32 * D.26232;
  struct MonoDynamicTable * table;
  int i;

  table = &assembly->tables[0];
  D.26210 = table->next_idx;
  D.26211 = D.26210;
  D.26212 = D.26211 + 1;
  table->next_idx = D.26212;
  mb->table_idx = D.26211;
  D.26213 = table->values;
  D.26214 = mb->table_idx;
  D.26215 = D.26214 * 20;
  D.26216 = D.26215 + 4;
  D.26217 = D.26213 + D.26216;
  D.26218 = &assembly->sheap;
  D.26219 = mb->module.name;
  D.26220 = string_heap_insert_mstring (D.26218, D.26219);
  *D.26217 = D.26220;
  D.26221 = &assembly->guid;
  D.26222 = mb->guid;
  D.26223 = mono_array_addr_with_size (D.26222, 1, 0);
  D.26224 = mono_image_add_stream_data (D.26221, D.26223, 16);
  i = (int) D.26224;
  i = i / 16;
  i = i + 1;
  D.26213 = table->values;
  D.26214 = mb->table_idx;
  D.26215 = D.26214 * 20;
  D.26225 = D.26213 + D.26215;
  *D.26225 = 0;
  D.26213 = table->values;
  D.26214 = mb->table_idx;
  D.26215 = D.26214 * 20;
  D.26226 = D.26215 + 8;
  D.26227 = D.26213 + D.26226;
  i.124 = (unsigned int) i;
  *D.26227 = i.124;
  D.26213 = table->values;
  D.26214 = mb->table_idx;
  D.26215 = D.26214 * 20;
  D.26229 = D.26215 + 12;
  D.26230 = D.26213 + D.26229;
  *D.26230 = 0;
  D.26213 = table->values;
  D.26214 = mb->table_idx;
  D.26215 = D.26214 * 20;
  D.26231 = D.26215 + 16;
  D.26232 = D.26213 + D.26231;
  *D.26232 = 0;
}


collect_types (struct MonoPtrArray * types, struct MonoReflectionTypeBuilder * type)
{
  int D.26233;
  int D.26234;
  unsigned int D.26237;
  unsigned int D.26238;
  int D.26239;
  void * D.26240;
  void * * D.26241;
  unsigned int D.26242;
  int D.26245;
  int D.26246;
  unsigned int D.26247;
  unsigned int D.26248;
  void * * D.26249;
  struct MonoArray * D.26250;
  unsigned int i.125;
  char * D.26254;
  unsigned int D.26255;
  int i;

  D.26233 = types->size;
  D.26234 = types->capacity;
  if (D.26233 >= D.26234) goto <D.26235>; else goto <D.26236>;
  <D.26235>:
  {
    void * __tmp;

    D.26234 = types->capacity;
    D.26237 = (unsigned int) D.26234;
    D.26238 = D.26237 * 8;
    D.26234 = types->capacity;
    D.26239 = D.26234 * 2;
    D.26240 = mono_gc_make_root_descr_all_refs (D.26239);
    __tmp = mono_gc_alloc_fixed (D.26238, D.26240);
    D.26241 = types->data;
    D.26234 = types->capacity;
    D.26237 = (unsigned int) D.26234;
    D.26242 = D.26237 * 4;
    mono_gc_memmove_aligned (__tmp, D.26241, D.26242);
    D.26234 = types->capacity;
    if (D.26234 > 16) goto <D.26243>; else goto <D.26244>;
    <D.26243>:
    D.26241 = types->data;
    mono_gc_free_fixed (D.26241);
    <D.26244>:
    types->data = __tmp;
    D.26234 = types->capacity;
    D.26239 = D.26234 * 2;
    types->capacity = D.26239;
  }
  <D.26236>:
  D.26241 = types->data;
  D.26233 = types->size;
  D.26245 = D.26233;
  D.26246 = D.26245 + 1;
  types->size = D.26246;
  D.26247 = (unsigned int) D.26245;
  D.26248 = D.26247 * 4;
  D.26249 = D.26241 + D.26248;
  *D.26249 = type;
  D.26250 = type->subtypes;
  if (D.26250 == 0B) goto <D.26251>; else goto <D.26252>;
  <D.26251>:
  return;
  <D.26252>:
  i = 0;
  goto <D.19389>;
  <D.19388>:
  {
    struct MonoReflectionTypeBuilder * subtype;

    D.26250 = type->subtypes;
    i.125 = (unsigned int) i;
    D.26254 = mono_array_addr_with_size (D.26250, 4, i.125);
    subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.26254];
    collect_types (types, subtype);
  }
  i = i + 1;
  <D.19389>:
  i.125 = (unsigned int) i;
  D.26250 = type->subtypes;
  D.26255 = mono_array_length (D.26250);
  if (i.125 < D.26255) goto <D.19388>; else goto <D.19390>;
  <D.19390>:
}


alloc_table (struct MonoDynamicTable * table, guint nrows)
{
  unsigned char D.26257;
  _Bool D.26258;
  long int D.26259;
  long int D.26260;
  unsigned int D.26263;
  unsigned int D.26264;
  unsigned int D.26270;
  guint32 * D.26271;
  unsigned int D.26272;
  unsigned int D.26273;
  unsigned int D.26274;
  void * D.26275;

  table->rows = nrows;
  D.26257 = table->columns;
  D.26258 = D.26257 == 0;
  D.26259 = (long int) D.26258;
  D.26260 = __builtin_expect (D.26259, 0);
  if (D.26260 != 0) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 327, "table->columns");
  <D.26262>:
  D.26263 = nrows + 1;
  D.26264 = table->alloc_rows;
  if (D.26263 >= D.26264) goto <D.26265>; else goto <D.26266>;
  <D.26265>:
  goto <D.18310>;
  <D.18309>:
  D.26264 = table->alloc_rows;
  if (D.26264 == 0) goto <D.26267>; else goto <D.26268>;
  <D.26267>:
  table->alloc_rows = 16;
  goto <D.26269>;
  <D.26268>:
  D.26264 = table->alloc_rows;
  D.26270 = D.26264 * 2;
  table->alloc_rows = D.26270;
  <D.26269>:
  <D.18310>:
  D.26263 = nrows + 1;
  D.26264 = table->alloc_rows;
  if (D.26263 >= D.26264) goto <D.18309>; else goto <D.18311>;
  <D.18311>:
  D.26271 = table->values;
  D.26264 = table->alloc_rows;
  D.26257 = table->columns;
  D.26272 = (unsigned int) D.26257;
  D.26273 = D.26264 * D.26272;
  D.26274 = D.26273 * 4;
  D.26275 = monoeg_realloc (D.26271, D.26274);
  table->values = D.26275;
  <D.26266>:
}


string_heap_insert_mstring (struct MonoDynamicStream * sh, struct MonoString * str)
{
  guint32 D.26276;
  char * name;
  guint32 idx;

  name = mono_string_to_utf8 (str);
  idx = string_heap_insert (sh, name);
  monoeg_g_free (name);
  D.26276 = idx;
  return D.26276;
}


mono_image_get_type_info (struct MonoDomain * domain, struct MonoReflectionTypeBuilder * tb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26278;
  unsigned int D.26279;
  unsigned int D.26280;
  unsigned int D.26281;
  struct MonoString * D.26282;
  int D.19343;
  int iftmp.126;
  int D.19342;
  const char[7] * D.26286;
  unsigned char D.26287;
  int D.26288;
  unsigned char D.26289;
  int D.26290;
  const unsigned char * D.26295;
  unsigned char D.26296;
  int D.26297;
  const unsigned char * D.26298;
  unsigned char D.26299;
  int D.26300;
  const unsigned char * D.26305;
  unsigned char D.26306;
  int D.26307;
  const unsigned char * D.26308;
  unsigned char D.26309;
  int D.26310;
  const unsigned char * D.26315;
  unsigned char D.26316;
  int D.26317;
  const unsigned char * D.26318;
  unsigned char D.26319;
  int D.26320;
  guint * D.26324;
  struct MonoDynamicStream * D.26325;
  unsigned int D.26326;
  struct MonoString * D.26327;
  int D.19352;
  int iftmp.127;
  int D.19351;
  const char[7] * D.26331;
  unsigned char D.26332;
  int D.26333;
  unsigned char D.26334;
  int D.26335;
  const unsigned char * D.26340;
  unsigned char D.26341;
  int D.26342;
  const unsigned char * D.26343;
  unsigned char D.26344;
  int D.26345;
  const unsigned char * D.26350;
  unsigned char D.26351;
  int D.26352;
  const unsigned char * D.26353;
  unsigned char D.26354;
  int D.26355;
  const unsigned char * D.26360;
  unsigned char D.26361;
  int D.26362;
  const unsigned char * D.26363;
  unsigned char D.26364;
  int D.26365;
  guint * D.26369;
  unsigned int D.26370;
  struct MonoObject * D.26374;
  unsigned int D.26377;
  guint * D.26379;
  struct MonoType * D.26380;
  unsigned int D.26381;
  guint * D.26382;
  unsigned int D.26383;
  guint * D.26384;
  unsigned int D.26385;
  unsigned int D.26388;
  int D.26391;
  int D.26393;
  unsigned int D.26394;
  unsigned int D.26395;
  unsigned int D.26396;
  unsigned int D.26397;
  unsigned int D.26398;
  struct MonoArray * D.26399;
  unsigned int D.26402;
  unsigned int D.26403;
  int D.26404;
  unsigned int D.26405;
  unsigned int D.26406;
  unsigned int i.128;
  char * D.26408;
  struct MonoType * D.26409;
  unsigned int D.26410;
  unsigned int D.26411;
  struct MonoArray * D.26412;
  int D.26415;
  unsigned int D.26416;
  unsigned int D.26417;
  char * D.26418;
  struct MonoReflectionFieldBuilder * D.26419;
  struct MonoArray * D.26420;
  unsigned int D.26423;
  unsigned int D.26424;
  char * D.26425;
  struct MonoReflectionCtorBuilder * D.26426;
  unsigned int D.26427;
  struct MonoArray * D.26428;
  int D.26431;
  unsigned int D.26432;
  unsigned int D.26433;
  char * D.26434;
  struct MonoReflectionMethodBuilder * D.26435;
  struct MonoArray * D.26436;
  unsigned int D.26439;
  unsigned int D.26442;
  unsigned int D.26443;
  unsigned int D.26444;
  unsigned int D.26445;
  char * D.26446;
  struct MonoReflectionEventBuilder * D.26447;
  unsigned int D.26448;
  struct MonoArray * D.26449;
  unsigned int D.26452;
  unsigned int D.26455;
  unsigned int D.26456;
  unsigned int D.26457;
  char * D.26458;
  struct MonoReflectionPropertyBuilder * D.26459;
  unsigned int D.26460;
  struct MonoArray * D.26461;
  unsigned int D.26464;
  unsigned int D.26465;
  char * D.26466;
  struct MonoReflectionGenericParam * D.26467;
  unsigned int D.26468;
  unsigned int D.26469;
  struct MonoArray * D.26470;
  struct MonoArray * D.26471;
  unsigned int D.26474;
  unsigned int D.26475;
  unsigned int D.26476;
  guint32 * D.26477;
  unsigned int D.26478;
  unsigned int D.26479;
  char * D.26480;
  unsigned int D.26481;
  unsigned int D.26482;
  unsigned int D.26483;
  struct MonoDynamicTable * table;
  guint * values;
  int i;
  int is_object;
  int is_system;
  char * n;

  is_object = 0;
  is_system = 0;
  table = &assembly->tables[2];
  D.26278 = table->values;
  D.26279 = tb->table_idx;
  D.26280 = D.26279 * 24;
  values = D.26278 + D.26280;
  D.26281 = tb->attrs;
  *values = D.26281;
  D.26282 = tb->name;
  n = mono_string_to_utf8 (D.26282);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26286 = "Object";
      D.26287 = MEM[(const unsigned char *)D.26286];
      D.26288 = (int) D.26287;
      D.26289 = *__s2;
      D.26290 = (int) D.26289;
      __result = D.26288 - D.26290;
      {
        if (__s2_len != 0) goto <D.26291>; else goto <D.26292>;
        <D.26291>:
        if (__result == 0) goto <D.26293>; else goto <D.26294>;
        <D.26293>:
        D.26295 = &MEM[(void *)"Object" + 1B];
        D.26296 = *D.26295;
        D.26297 = (int) D.26296;
        D.26298 = __s2 + 1;
        D.26299 = *D.26298;
        D.26300 = (int) D.26299;
        __result = D.26297 - D.26300;
        if (__s2_len > 1) goto <D.26301>; else goto <D.26302>;
        <D.26301>:
        if (__result == 0) goto <D.26303>; else goto <D.26304>;
        <D.26303>:
        D.26305 = &MEM[(void *)"Object" + 2B];
        D.26306 = *D.26305;
        D.26307 = (int) D.26306;
        D.26308 = __s2 + 2;
        D.26309 = *D.26308;
        D.26310 = (int) D.26309;
        __result = D.26307 - D.26310;
        if (__s2_len > 2) goto <D.26311>; else goto <D.26312>;
        <D.26311>:
        if (__result == 0) goto <D.26313>; else goto <D.26314>;
        <D.26313>:
        D.26315 = &MEM[(void *)"Object" + 3B];
        D.26316 = *D.26315;
        D.26317 = (int) D.26316;
        D.26318 = __s2 + 3;
        D.26319 = *D.26318;
        D.26320 = (int) D.26319;
        __result = D.26317 - D.26320;
        <D.26314>:
        <D.26312>:
        <D.26304>:
        <D.26302>:
        <D.26294>:
        <D.26292>:
      }
      D.19342 = __result;
    }
    iftmp.126 = -D.19342;
    goto <D.26321>;
    <D.26285>:
    iftmp.126 = __builtin_strcmp (n, "Object");
    <D.26321>:
    D.19343 = iftmp.126;
  }
  if (D.19343 == 0) goto <D.26322>; else goto <D.26323>;
  <D.26322>:
  is_object = is_object + 1;
  <D.26323>:
  D.26324 = values + 4;
  D.26325 = &assembly->sheap;
  D.26326 = string_heap_insert (D.26325, n);
  *D.26324 = D.26326;
  monoeg_g_free (n);
  D.26327 = tb->nspace;
  n = mono_string_to_utf8 (D.26327);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26331 = "System";
      D.26332 = MEM[(const unsigned char *)D.26331];
      D.26333 = (int) D.26332;
      D.26334 = *__s2;
      D.26335 = (int) D.26334;
      __result = D.26333 - D.26335;
      {
        if (__s2_len != 0) goto <D.26336>; else goto <D.26337>;
        <D.26336>:
        if (__result == 0) goto <D.26338>; else goto <D.26339>;
        <D.26338>:
        D.26340 = &MEM[(void *)"System" + 1B];
        D.26341 = *D.26340;
        D.26342 = (int) D.26341;
        D.26343 = __s2 + 1;
        D.26344 = *D.26343;
        D.26345 = (int) D.26344;
        __result = D.26342 - D.26345;
        if (__s2_len > 1) goto <D.26346>; else goto <D.26347>;
        <D.26346>:
        if (__result == 0) goto <D.26348>; else goto <D.26349>;
        <D.26348>:
        D.26350 = &MEM[(void *)"System" + 2B];
        D.26351 = *D.26350;
        D.26352 = (int) D.26351;
        D.26353 = __s2 + 2;
        D.26354 = *D.26353;
        D.26355 = (int) D.26354;
        __result = D.26352 - D.26355;
        if (__s2_len > 2) goto <D.26356>; else goto <D.26357>;
        <D.26356>:
        if (__result == 0) goto <D.26358>; else goto <D.26359>;
        <D.26358>:
        D.26360 = &MEM[(void *)"System" + 3B];
        D.26361 = *D.26360;
        D.26362 = (int) D.26361;
        D.26363 = __s2 + 3;
        D.26364 = *D.26363;
        D.26365 = (int) D.26364;
        __result = D.26362 - D.26365;
        <D.26359>:
        <D.26357>:
        <D.26349>:
        <D.26347>:
        <D.26339>:
        <D.26337>:
      }
      D.19351 = __result;
    }
    iftmp.127 = -D.19351;
    goto <D.26366>;
    <D.26330>:
    iftmp.127 = __builtin_strcmp (n, "System");
    <D.26366>:
    D.19352 = iftmp.127;
  }
  if (D.19352 == 0) goto <D.26367>; else goto <D.26368>;
  <D.26367>:
  is_system = is_system + 1;
  <D.26368>:
  D.26369 = values + 8;
  D.26325 = &assembly->sheap;
  D.26370 = string_heap_insert (D.26325, n);
  *D.26369 = D.26370;
  monoeg_g_free (n);
  D.26374 = tb->parent;
  if (D.26374 != 0B) goto <D.26375>; else goto <D.26371>;
  <D.26375>:
  if (is_system == 0) goto <D.26372>; else goto <D.26376>;
  <D.26376>:
  if (is_object == 0) goto <D.26372>; else goto <D.26371>;
  <D.26372>:
  D.26281 = tb->attrs;
  D.26377 = D.26281 & 32;
  if (D.26377 == 0) goto <D.26378>; else goto <D.26371>;
  <D.26378>:
  D.26379 = values + 12;
  D.26374 = tb->parent;
  D.26380 = mono_reflection_type_get_handle (D.26374);
  D.26381 = mono_image_typedef_or_ref (assembly, D.26380);
  *D.26379 = D.26381;
  goto <D.26373>;
  <D.26371>:
  D.26379 = values + 12;
  *D.26379 = 0;
  <D.26373>:
  D.26382 = values + 16;
  D.26383 = assembly->tables[4].next_idx;
  *D.26382 = D.26383;
  D.26384 = values + 20;
  D.26385 = assembly->tables[6].next_idx;
  *D.26384 = D.26385;
  D.26281 = tb->attrs;
  D.26388 = D.26281 & 24;
  if (D.26388 != 0) goto <D.26389>; else goto <D.26390>;
  <D.26389>:
  D.26391 = tb->class_size;
  if (D.26391 > 0) goto <D.26386>; else goto <D.26392>;
  <D.26392>:
  D.26393 = tb->packing_size;
  if (D.26393 > 0) goto <D.26386>; else goto <D.26387>;
  <D.26386>:
  table = &assembly->tables[15];
  D.26394 = table->rows;
  D.26395 = D.26394 + 1;
  table->rows = D.26395;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  D.26278 = table->values;
  D.26394 = table->rows;
  D.26396 = D.26394 * 12;
  values = D.26278 + D.26396;
  D.26369 = values + 8;
  D.26279 = tb->table_idx;
  *D.26369 = D.26279;
  D.26324 = values + 4;
  D.26391 = tb->class_size;
  D.26397 = (unsigned int) D.26391;
  *D.26324 = D.26397;
  D.26393 = tb->packing_size;
  D.26398 = (unsigned int) D.26393;
  *values = D.26398;
  <D.26387>:
  <D.26390>:
  D.26399 = tb->interfaces;
  if (D.26399 != 0B) goto <D.26400>; else goto <D.26401>;
  <D.26400>:
  table = &assembly->tables[9];
  D.26394 = table->rows;
  i = (int) D.26394;
  D.26399 = tb->interfaces;
  D.26402 = mono_array_length (D.26399);
  D.26394 = table->rows;
  D.26403 = D.26394 + D.26402;
  table->rows = D.26403;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  D.26278 = table->values;
  D.26404 = i + 1;
  D.26405 = (unsigned int) D.26404;
  D.26406 = D.26405 * 8;
  values = D.26278 + D.26406;
  i = 0;
  goto <D.19355>;
  <D.19354>:
  {
    struct MonoReflectionType * iface;

    D.26399 = tb->interfaces;
    i.128 = (unsigned int) i;
    D.26408 = mono_array_addr_with_size (D.26399, 4, i.128);
    iface = MEM[(void * *)D.26408];
    D.26279 = tb->table_idx;
    *values = D.26279;
    D.26324 = values + 4;
    D.26409 = mono_reflection_type_get_handle (iface);
    D.26410 = mono_image_typedef_or_ref (assembly, D.26409);
    *D.26324 = D.26410;
    values = values + 8;
  }
  i = i + 1;
  <D.19355>:
  i.128 = (unsigned int) i;
  D.26399 = tb->interfaces;
  D.26411 = mono_array_length (D.26399);
  if (i.128 < D.26411) goto <D.19354>; else goto <D.19356>;
  <D.19356>:
  <D.26401>:
  D.26412 = tb->fields;
  if (D.26412 != 0B) goto <D.26413>; else goto <D.26414>;
  <D.26413>:
  table = &assembly->tables[4];
  D.26394 = table->rows;
  D.26415 = tb->num_fields;
  D.26416 = (unsigned int) D.26415;
  D.26417 = D.26394 + D.26416;
  table->rows = D.26417;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  i = 0;
  goto <D.19358>;
  <D.19357>:
  D.26412 = tb->fields;
  i.128 = (unsigned int) i;
  D.26418 = mono_array_addr_with_size (D.26412, 4, i.128);
  D.26419 = MEM[(struct MonoReflectionFieldBuilder * *)D.26418];
  mono_image_get_field_info (D.26419, assembly);
  i = i + 1;
  <D.19358>:
  D.26415 = tb->num_fields;
  if (D.26415 > i) goto <D.19357>; else goto <D.19359>;
  <D.19359>:
  <D.26414>:
  D.26420 = tb->ctors;
  if (D.26420 != 0B) goto <D.26421>; else goto <D.26422>;
  <D.26421>:
  table = &assembly->tables[6];
  D.26420 = tb->ctors;
  D.26423 = mono_array_length (D.26420);
  D.26394 = table->rows;
  D.26424 = D.26394 + D.26423;
  table->rows = D.26424;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  i = 0;
  goto <D.19361>;
  <D.19360>:
  D.26420 = tb->ctors;
  i.128 = (unsigned int) i;
  D.26425 = mono_array_addr_with_size (D.26420, 4, i.128);
  D.26426 = MEM[(struct MonoReflectionCtorBuilder * *)D.26425];
  mono_image_get_ctor_info (domain, D.26426, assembly);
  i = i + 1;
  <D.19361>:
  i.128 = (unsigned int) i;
  D.26420 = tb->ctors;
  D.26427 = mono_array_length (D.26420);
  if (i.128 < D.26427) goto <D.19360>; else goto <D.19362>;
  <D.19362>:
  <D.26422>:
  D.26428 = tb->methods;
  if (D.26428 != 0B) goto <D.26429>; else goto <D.26430>;
  <D.26429>:
  table = &assembly->tables[6];
  D.26394 = table->rows;
  D.26431 = tb->num_methods;
  D.26432 = (unsigned int) D.26431;
  D.26433 = D.26394 + D.26432;
  table->rows = D.26433;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  i = 0;
  goto <D.19364>;
  <D.19363>:
  D.26428 = tb->methods;
  i.128 = (unsigned int) i;
  D.26434 = mono_array_addr_with_size (D.26428, 4, i.128);
  D.26435 = MEM[(struct MonoReflectionMethodBuilder * *)D.26434];
  mono_image_get_method_info (D.26435, assembly);
  i = i + 1;
  <D.19364>:
  D.26431 = tb->num_methods;
  if (D.26431 > i) goto <D.19363>; else goto <D.19365>;
  <D.19365>:
  <D.26430>:
  D.26436 = tb->events;
  if (D.26436 != 0B) goto <D.26437>; else goto <D.26438>;
  <D.26437>:
  D.26436 = tb->events;
  D.26439 = mono_array_length (D.26436);
  if (D.26439 != 0) goto <D.26440>; else goto <D.26441>;
  <D.26440>:
  table = &assembly->tables[20];
  D.26436 = tb->events;
  D.26442 = mono_array_length (D.26436);
  D.26394 = table->rows;
  D.26443 = D.26394 + D.26442;
  table->rows = D.26443;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  table = &assembly->tables[18];
  D.26394 = table->rows;
  D.26395 = D.26394 + 1;
  table->rows = D.26395;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  D.26278 = table->values;
  D.26394 = table->rows;
  D.26444 = D.26394 * 8;
  values = D.26278 + D.26444;
  D.26279 = tb->table_idx;
  *values = D.26279;
  D.26324 = values + 4;
  D.26445 = assembly->tables[20].next_idx;
  *D.26324 = D.26445;
  i = 0;
  goto <D.19367>;
  <D.19366>:
  D.26436 = tb->events;
  i.128 = (unsigned int) i;
  D.26446 = mono_array_addr_with_size (D.26436, 4, i.128);
  D.26447 = MEM[(struct MonoReflectionEventBuilder * *)D.26446];
  mono_image_get_event_info (D.26447, assembly);
  i = i + 1;
  <D.19367>:
  i.128 = (unsigned int) i;
  D.26436 = tb->events;
  D.26448 = mono_array_length (D.26436);
  if (i.128 < D.26448) goto <D.19366>; else goto <D.19368>;
  <D.19368>:
  <D.26441>:
  <D.26438>:
  D.26449 = tb->properties;
  if (D.26449 != 0B) goto <D.26450>; else goto <D.26451>;
  <D.26450>:
  D.26449 = tb->properties;
  D.26452 = mono_array_length (D.26449);
  if (D.26452 != 0) goto <D.26453>; else goto <D.26454>;
  <D.26453>:
  table = &assembly->tables[23];
  D.26449 = tb->properties;
  D.26455 = mono_array_length (D.26449);
  D.26394 = table->rows;
  D.26456 = D.26394 + D.26455;
  table->rows = D.26456;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  table = &assembly->tables[21];
  D.26394 = table->rows;
  D.26395 = D.26394 + 1;
  table->rows = D.26395;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  D.26278 = table->values;
  D.26394 = table->rows;
  D.26444 = D.26394 * 8;
  values = D.26278 + D.26444;
  D.26279 = tb->table_idx;
  *values = D.26279;
  D.26324 = values + 4;
  D.26457 = assembly->tables[23].next_idx;
  *D.26324 = D.26457;
  i = 0;
  goto <D.19370>;
  <D.19369>:
  D.26449 = tb->properties;
  i.128 = (unsigned int) i;
  D.26458 = mono_array_addr_with_size (D.26449, 4, i.128);
  D.26459 = MEM[(struct MonoReflectionPropertyBuilder * *)D.26458];
  mono_image_get_property_info (D.26459, assembly);
  i = i + 1;
  <D.19370>:
  i.128 = (unsigned int) i;
  D.26449 = tb->properties;
  D.26460 = mono_array_length (D.26449);
  if (i.128 < D.26460) goto <D.19369>; else goto <D.19371>;
  <D.19371>:
  <D.26454>:
  <D.26451>:
  D.26461 = tb->generic_params;
  if (D.26461 != 0B) goto <D.26462>; else goto <D.26463>;
  <D.26462>:
  table = &assembly->tables[42];
  D.26461 = tb->generic_params;
  D.26464 = mono_array_length (D.26461);
  D.26394 = table->rows;
  D.26465 = D.26394 + D.26464;
  table->rows = D.26465;
  D.26394 = table->rows;
  alloc_table (table, D.26394);
  i = 0;
  goto <D.19374>;
  <D.19373>:
  {
    guint32 owner;

    D.26279 = tb->table_idx;
    owner = D.26279 << 1;
    D.26461 = tb->generic_params;
    i.128 = (unsigned int) i;
    D.26466 = mono_array_addr_with_size (D.26461, 4, i.128);
    D.26467 = MEM[(struct MonoReflectionGenericParam * *)D.26466];
    mono_image_get_generic_param_info (D.26467, owner, assembly);
  }
  i = i + 1;
  <D.19374>:
  i.128 = (unsigned int) i;
  D.26461 = tb->generic_params;
  D.26468 = mono_array_length (D.26461);
  if (i.128 < D.26468) goto <D.19373>; else goto <D.19375>;
  <D.19375>:
  <D.26463>:
  D.26279 = tb->table_idx;
  D.26469 = D.26279 | 33554432;
  D.26470 = tb->permissions;
  mono_image_add_decl_security (assembly, D.26469, D.26470);
  D.26471 = tb->subtypes;
  if (D.26471 != 0B) goto <D.26472>; else goto <D.26473>;
  <D.26472>:
  {
    struct MonoDynamicTable * ntable;

    ntable = &assembly->tables[41];
    D.26471 = tb->subtypes;
    D.26474 = mono_array_length (D.26471);
    D.26475 = ntable->rows;
    D.26476 = D.26475 + D.26474;
    ntable->rows = D.26476;
    D.26475 = ntable->rows;
    alloc_table (ntable, D.26475);
    D.26477 = ntable->values;
    D.26478 = ntable->next_idx;
    D.26479 = D.26478 * 8;
    values = D.26477 + D.26479;
    i = 0;
    goto <D.19379>;
    <D.19378>:
    {
      struct MonoReflectionTypeBuilder * subtype;

      D.26471 = tb->subtypes;
      i.128 = (unsigned int) i;
      D.26480 = mono_array_addr_with_size (D.26471, 4, i.128);
      subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.26480];
      D.26481 = subtype->table_idx;
      *values = D.26481;
      D.26324 = values + 4;
      D.26279 = tb->table_idx;
      *D.26324 = D.26279;
      values = values + 8;
      D.26478 = ntable->next_idx;
      D.26482 = D.26478 + 1;
      ntable->next_idx = D.26482;
    }
    i = i + 1;
    <D.19379>:
    i.128 = (unsigned int) i;
    D.26471 = tb->subtypes;
    D.26483 = mono_array_length (D.26471);
    if (i.128 < D.26483) goto <D.19378>; else goto <D.19380>;
    <D.19380>:
  }
  <D.26473>:
}


mono_image_get_ctor_info (struct MonoDomain * domain, struct MonoReflectionCtorBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26484;
  unsigned int D.26485;
  struct ReflectionMethodBuilder rmb;

  try
    {
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      mono_image_basic_method (&rmb, assembly);
      D.26484 = rmb.table_idx;
      D.26485 = *D.26484;
      mb->table_idx = D.26485;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


reflection_methodbuilder_from_ctor_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionCtorBuilder * mb)
{
  const char * iftmp.129;
  unsigned int D.26487;
  unsigned int D.26488;
  struct MonoReflectionILGen * D.26492;
  struct MonoDomain * D.26493;
  struct MonoClass * D.26494;
  struct MonoType * D.26495;
  struct MonoReflectionType * D.26496;
  struct MonoArray * D.26497;
  struct MonoArray * D.26498;
  unsigned int D.26499;
  unsigned int D.26500;
  struct MonoObject * D.26501;
  struct MonoDomain * D.26502;
  struct MonoString * D.26503;
  guint32 * D.26504;
  unsigned char D.26505;
  struct MonoArray * D.26506;
  struct MonoArray * D.26507;
  struct MonoArray * D.26508;
  struct MonoMethod * D.26509;
  const char * name;

  D.26487 = mb->attrs;
  D.26488 = D.26487 & 16;
  if (D.26488 != 0) goto <D.26489>; else goto <D.26490>;
  <D.26489>:
  iftmp.129 = ".cctor";
  goto <D.26491>;
  <D.26490>:
  iftmp.129 = ".ctor";
  <D.26491>:
  name = iftmp.129;
  memset (rmb, 0, 112);
  D.26492 = mb->ilgen;
  rmb->ilgen = D.26492;
  D.26493 = mono_domain_get ();
  D.26494 = mono_defaults.void_class;
  D.26495 = &D.26494->byval_arg;
  D.26496 = mono_type_get_object (D.26493, D.26495);
  rmb->rtype = D.26496;
  D.26497 = mb->parameters;
  rmb->parameters = D.26497;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  D.26498 = mb->pinfo;
  rmb->pinfo = D.26498;
  D.26487 = mb->attrs;
  rmb->attrs = D.26487;
  D.26499 = mb->iattrs;
  rmb->iattrs = D.26499;
  D.26500 = mb->call_conv;
  rmb->call_conv = D.26500;
  rmb->code = 0B;
  D.26501 = mb->type;
  rmb->type = D.26501;
  D.26502 = mono_domain_get ();
  D.26503 = mono_string_new (D.26502, name);
  rmb->name = D.26503;
  D.26504 = &mb->table_idx;
  rmb->table_idx = D.26504;
  D.26505 = mb->init_locals;
  rmb->init_locals = D.26505;
  rmb->skip_visibility = 0;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  D.26506 = mb->param_modreq;
  rmb->param_modreq = D.26506;
  D.26507 = mb->param_modopt;
  rmb->param_modopt = D.26507;
  D.26508 = mb->permissions;
  rmb->permissions = D.26508;
  D.26509 = mb->mhandle;
  rmb->mhandle = D.26509;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


mono_image_get_event_info (struct MonoReflectionEventBuilder * eb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26510;
  unsigned int D.26511;
  unsigned int D.26512;
  guint32 * D.26513;
  unsigned int D.26514;
  unsigned int D.26515;
  guint32 * D.26516;
  struct MonoDynamicStream * D.26517;
  struct MonoString * D.26518;
  unsigned int D.26519;
  unsigned int D.26520;
  guint32 * D.26521;
  struct MonoReflectionType * D.26522;
  struct MonoType * D.26523;
  unsigned int D.26524;
  struct MonoReflectionMethodBuilder * D.26525;
  struct MonoReflectionMethodBuilder * D.26528;
  struct MonoReflectionMethodBuilder * D.26531;
  unsigned int D.26534;
  unsigned int D.26535;
  unsigned int semaidx.130;
  unsigned int D.26539;
  unsigned int D.26540;
  unsigned int D.26541;
  unsigned int D.26542;
  unsigned int semaidx.131;
  unsigned int D.26546;
  unsigned int D.26547;
  unsigned int semaidx.132;
  unsigned int D.26551;
  unsigned int D.26552;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[20];
  D.26510 = table->next_idx;
  D.26511 = D.26510;
  D.26512 = D.26511 + 1;
  table->next_idx = D.26512;
  eb->table_idx = D.26511;
  D.26513 = table->values;
  D.26514 = eb->table_idx;
  D.26515 = D.26514 * 12;
  values = D.26513 + D.26515;
  D.26516 = values + 4;
  D.26517 = &assembly->sheap;
  D.26518 = eb->name;
  D.26519 = string_heap_insert_mstring (D.26517, D.26518);
  *D.26516 = D.26519;
  D.26520 = eb->attrs;
  *values = D.26520;
  D.26521 = values + 8;
  D.26522 = eb->type;
  D.26523 = mono_reflection_type_get_handle (D.26522);
  D.26524 = mono_image_typedef_or_ref (assembly, D.26523);
  *D.26521 = D.26524;
  D.26525 = eb->add_method;
  if (D.26525 != 0B) goto <D.26526>; else goto <D.26527>;
  <D.26526>:
  num_methods = num_methods + 1;
  <D.26527>:
  D.26528 = eb->remove_method;
  if (D.26528 != 0B) goto <D.26529>; else goto <D.26530>;
  <D.26529>:
  num_methods = num_methods + 1;
  <D.26530>:
  D.26531 = eb->raise_method;
  if (D.26531 != 0B) goto <D.26532>; else goto <D.26533>;
  <D.26532>:
  num_methods = num_methods + 1;
  <D.26533>:
  table = &assembly->tables[24];
  D.26534 = table->rows;
  D.26535 = D.26534 + num_methods;
  table->rows = D.26535;
  D.26534 = table->rows;
  alloc_table (table, D.26534);
  D.26525 = eb->add_method;
  if (D.26525 != 0B) goto <D.26536>; else goto <D.26537>;
  <D.26536>:
  D.26510 = table->next_idx;
  semaidx.130 = D.26510;
  D.26539 = semaidx.130 + 1;
  table->next_idx = D.26539;
  semaidx = semaidx.130;
  D.26513 = table->values;
  D.26540 = semaidx * 12;
  values = D.26513 + D.26540;
  *values = 8;
  D.26516 = values + 4;
  D.26525 = eb->add_method;
  D.26541 = D.26525->table_idx;
  *D.26516 = D.26541;
  D.26521 = values + 8;
  D.26514 = eb->table_idx;
  D.26542 = D.26514 << 1;
  *D.26521 = D.26542;
  <D.26537>:
  D.26528 = eb->remove_method;
  if (D.26528 != 0B) goto <D.26543>; else goto <D.26544>;
  <D.26543>:
  D.26510 = table->next_idx;
  semaidx.131 = D.26510;
  D.26546 = semaidx.131 + 1;
  table->next_idx = D.26546;
  semaidx = semaidx.131;
  D.26513 = table->values;
  D.26540 = semaidx * 12;
  values = D.26513 + D.26540;
  *values = 16;
  D.26516 = values + 4;
  D.26528 = eb->remove_method;
  D.26547 = D.26528->table_idx;
  *D.26516 = D.26547;
  D.26521 = values + 8;
  D.26514 = eb->table_idx;
  D.26542 = D.26514 << 1;
  *D.26521 = D.26542;
  <D.26544>:
  D.26531 = eb->raise_method;
  if (D.26531 != 0B) goto <D.26548>; else goto <D.26549>;
  <D.26548>:
  D.26510 = table->next_idx;
  semaidx.132 = D.26510;
  D.26551 = semaidx.132 + 1;
  table->next_idx = D.26551;
  semaidx = semaidx.132;
  D.26513 = table->values;
  D.26540 = semaidx * 12;
  values = D.26513 + D.26540;
  *values = 32;
  D.26516 = values + 4;
  D.26531 = eb->raise_method;
  D.26552 = D.26531->table_idx;
  *D.26516 = D.26552;
  D.26521 = values + 8;
  D.26514 = eb->table_idx;
  D.26542 = D.26514 << 1;
  *D.26521 = D.26542;
  <D.26549>:
}


mono_image_get_property_info (struct MonoReflectionPropertyBuilder * pb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26553;
  unsigned int D.26554;
  unsigned int D.26555;
  int D.26556;
  guint32 * D.26557;
  int D.26558;
  unsigned int D.26559;
  unsigned int D.26560;
  guint32 * D.26561;
  struct MonoDynamicStream * D.26562;
  struct MonoString * D.26563;
  unsigned int D.26564;
  unsigned int D.26565;
  guint32 * D.26566;
  unsigned int D.26567;
  struct MonoReflectionMethodBuilder * D.26568;
  struct MonoReflectionMethodBuilder * D.26571;
  unsigned int D.26574;
  unsigned int D.26575;
  unsigned int semaidx.133;
  unsigned int D.26579;
  unsigned int D.26580;
  unsigned int D.26581;
  int D.26582;
  int D.26583;
  unsigned int D.26584;
  unsigned int semaidx.134;
  unsigned int D.26588;
  unsigned int D.26589;
  unsigned int D.26590;
  unsigned int D.26593;
  unsigned int D.26594;
  int D.26595;
  int D.26596;
  unsigned int D.26597;
  guint32 * D.26598;
  struct MonoObject * D.26599;
  unsigned int D.26600;
  unsigned int field_type.135;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[23];
  D.26553 = table->next_idx;
  D.26554 = D.26553;
  D.26555 = D.26554 + 1;
  table->next_idx = D.26555;
  D.26556 = (int) D.26554;
  pb->table_idx = D.26556;
  D.26557 = table->values;
  D.26558 = pb->table_idx;
  D.26559 = (unsigned int) D.26558;
  D.26560 = D.26559 * 12;
  values = D.26557 + D.26560;
  D.26561 = values + 4;
  D.26562 = &assembly->sheap;
  D.26563 = pb->name;
  D.26564 = string_heap_insert_mstring (D.26562, D.26563);
  *D.26561 = D.26564;
  D.26565 = pb->attrs;
  *values = D.26565;
  D.26566 = values + 8;
  D.26567 = property_encode_signature (assembly, pb);
  *D.26566 = D.26567;
  D.26568 = pb->get_method;
  if (D.26568 != 0B) goto <D.26569>; else goto <D.26570>;
  <D.26569>:
  num_methods = num_methods + 1;
  <D.26570>:
  D.26571 = pb->set_method;
  if (D.26571 != 0B) goto <D.26572>; else goto <D.26573>;
  <D.26572>:
  num_methods = num_methods + 1;
  <D.26573>:
  table = &assembly->tables[24];
  D.26574 = table->rows;
  D.26575 = D.26574 + num_methods;
  table->rows = D.26575;
  D.26574 = table->rows;
  alloc_table (table, D.26574);
  D.26568 = pb->get_method;
  if (D.26568 != 0B) goto <D.26576>; else goto <D.26577>;
  <D.26576>:
  D.26553 = table->next_idx;
  semaidx.133 = D.26553;
  D.26579 = semaidx.133 + 1;
  table->next_idx = D.26579;
  semaidx = semaidx.133;
  D.26557 = table->values;
  D.26580 = semaidx * 12;
  values = D.26557 + D.26580;
  *values = 2;
  D.26561 = values + 4;
  D.26568 = pb->get_method;
  D.26581 = D.26568->table_idx;
  *D.26561 = D.26581;
  D.26566 = values + 8;
  D.26558 = pb->table_idx;
  D.26582 = D.26558 << 1;
  D.26583 = D.26582 | 1;
  D.26584 = (unsigned int) D.26583;
  *D.26566 = D.26584;
  <D.26577>:
  D.26571 = pb->set_method;
  if (D.26571 != 0B) goto <D.26585>; else goto <D.26586>;
  <D.26585>:
  D.26553 = table->next_idx;
  semaidx.134 = D.26553;
  D.26588 = semaidx.134 + 1;
  table->next_idx = D.26588;
  semaidx = semaidx.134;
  D.26557 = table->values;
  D.26580 = semaidx * 12;
  values = D.26557 + D.26580;
  *values = 1;
  D.26561 = values + 4;
  D.26571 = pb->set_method;
  D.26589 = D.26571->table_idx;
  *D.26561 = D.26589;
  D.26566 = values + 8;
  D.26558 = pb->table_idx;
  D.26582 = D.26558 << 1;
  D.26583 = D.26582 | 1;
  D.26584 = (unsigned int) D.26583;
  *D.26566 = D.26584;
  <D.26586>:
  D.26565 = pb->attrs;
  D.26590 = D.26565 & 4096;
  if (D.26590 != 0) goto <D.26591>; else goto <D.26592>;
  <D.26591>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.26574 = table->rows;
        D.26593 = D.26574 + 1;
        table->rows = D.26593;
        D.26574 = table->rows;
        alloc_table (table, D.26574);
        D.26557 = table->values;
        D.26574 = table->rows;
        D.26594 = D.26574 * 16;
        values = D.26557 + D.26594;
        D.26566 = values + 8;
        D.26558 = pb->table_idx;
        D.26595 = D.26558 << 2;
        D.26596 = D.26595 | 2;
        D.26597 = (unsigned int) D.26596;
        *D.26566 = D.26597;
        D.26598 = values + 12;
        D.26599 = pb->def_value;
        D.26600 = encode_constant (assembly, D.26599, &field_type);
        *D.26598 = D.26600;
        field_type.135 = field_type;
        *values = field_type.135;
        D.26561 = values + 4;
        *D.26561 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.26592>:
}


property_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionPropertyBuilder * fb)
{
  struct MonoArray * D.26604;
  struct MonoArray * D.26611;
  unsigned int D.26614;
  unsigned int D.26615;
  unsigned int D.26616;
  struct MonoObject * D.26622;
  char * D.26623;
  char * D.26629;
  struct MonoReflectionType * D.26630;
  char * D.26631;
  struct MonoObject * D.26632;
  guint32 D.26633;
  struct SigBuffer buf;
  guint32 nparams;
  struct MonoReflectionMethodBuilder * mb;
  struct MonoReflectionMethodBuilder * smb;
  guint32 idx;
  guint32 i;

  try
    {
      nparams = 0;
      mb = fb->get_method;
      smb = fb->set_method;
      if (mb != 0B) goto <D.26602>; else goto <D.26603>;
      <D.26602>:
      D.26604 = mb->parameters;
      if (D.26604 != 0B) goto <D.26605>; else goto <D.26606>;
      <D.26605>:
      D.26604 = mb->parameters;
      nparams = mono_array_length (D.26604);
      <D.26606>:
      <D.26603>:
      if (mb == 0B) goto <D.26607>; else goto <D.26608>;
      <D.26607>:
      if (smb != 0B) goto <D.26609>; else goto <D.26610>;
      <D.26609>:
      D.26611 = smb->parameters;
      if (D.26611 != 0B) goto <D.26612>; else goto <D.26613>;
      <D.26612>:
      D.26611 = smb->parameters;
      D.26614 = mono_array_length (D.26611);
      nparams = D.26614 + 4294967295;
      <D.26613>:
      <D.26610>:
      <D.26608>:
      sigbuffer_init (&buf, 32);
      D.26615 = fb->call_conv;
      D.26616 = D.26615 & 32;
      if (D.26616 != 0) goto <D.26617>; else goto <D.26618>;
      <D.26617>:
      sigbuffer_add_byte (&buf, 40);
      goto <D.26619>;
      <D.26618>:
      sigbuffer_add_byte (&buf, 8);
      <D.26619>:
      sigbuffer_add_value (&buf, nparams);
      if (mb != 0B) goto <D.26620>; else goto <D.26621>;
      <D.26620>:
      D.26622 = mb->rtype;
      encode_reflection_type (assembly, D.26622, &buf);
      i = 0;
      goto <D.18892>;
      <D.18891>:
      {
        struct MonoReflectionType * pt;

        D.26604 = mb->parameters;
        D.26623 = mono_array_addr_with_size (D.26604, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.26623];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18892>:
      if (i < nparams) goto <D.18891>; else goto <D.18893>;
      <D.18893>:
      goto <D.26624>;
      <D.26621>:
      if (smb != 0B) goto <D.26627>; else goto <D.26625>;
      <D.26627>:
      D.26611 = smb->parameters;
      if (D.26611 != 0B) goto <D.26628>; else goto <D.26625>;
      <D.26628>:
      D.26611 = smb->parameters;
      D.26629 = mono_array_addr_with_size (D.26611, 4, nparams);
      D.26630 = MEM[(struct MonoReflectionType * *)D.26629];
      encode_reflection_type (assembly, D.26630, &buf);
      i = 0;
      goto <D.18896>;
      <D.18895>:
      {
        struct MonoReflectionType * pt;

        D.26611 = smb->parameters;
        D.26631 = mono_array_addr_with_size (D.26611, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.26631];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18896>:
      if (i < nparams) goto <D.18895>; else goto <D.18897>;
      <D.18897>:
      goto <D.26626>;
      <D.26625>:
      D.26632 = fb->type;
      encode_reflection_type (assembly, D.26632, &buf);
      <D.26626>:
      <D.26624>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26633 = idx;
      return D.26633;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_cattrs (struct MonoDynamicImage * assembly, guint32 idx, guint32 type, struct MonoArray * cattrs)
{
  unsigned int D.26638;
  unsigned int D.26639;
  guint32 * D.26640;
  unsigned int D.26641;
  unsigned int D.26642;
  char * D.26643;
  struct MonoReflectionMethod * D.26644;
  unsigned int D.26645;
  struct MonoGHashTable * D.26646;
  void * token.136;
  guint32 * D.26648;
  struct MonoArray * D.26649;
  unsigned int D.26650;
  char * p.137;
  guint32 * D.26652;
  int p.138;
  int blob_size.139;
  int D.26655;
  char * D.26656;
  unsigned int D.26657;
  int D.26658;
  unsigned int D.26659;
  unsigned int D.26660;
  struct MonoDynamicTable * table;
  struct MonoReflectionCustomAttr * cattr;
  guint32 * values;
  guint32 count;
  guint32 i;
  guint32 token;
  char blob_size[6];
  char * p;

  try
    {
      p = &blob_size;
      if (cattrs == 0B) goto <D.26636>; else goto <D.26637>;
      <D.26636>:
      return;
      <D.26637>:
      count = mono_array_length (cattrs);
      table = &assembly->tables[12];
      D.26638 = table->rows;
      D.26639 = D.26638 + count;
      table->rows = D.26639;
      D.26638 = table->rows;
      alloc_table (table, D.26638);
      D.26640 = table->values;
      D.26641 = table->next_idx;
      D.26642 = D.26641 * 12;
      values = D.26640 + D.26642;
      idx = idx << 5;
      idx = idx | type;
      i = 0;
      goto <D.18681>;
      <D.18680>:
      D.26643 = mono_array_addr_with_size (cattrs, 4, i);
      cattr = MEM[(void * *)D.26643];
      *values = idx;
      D.26644 = cattr->ctor;
      token = mono_image_create_token (assembly, D.26644, 0, 0);
      type = token & 16777215;
      type = type << 3;
      D.26645 = token >> 24;
      switch (D.26645) <default: <D.18678>, case 6: <D.18675>, case 10: <D.18677>>
      <D.18675>:
      type = type | 2;
      D.26646 = assembly->remapped_tokens;
      token.136 = (void *) token;
      D.26644 = cattr->ctor;
      mono_g_hash_table_insert (D.26646, token.136, D.26644);
      goto <D.18676>;
      <D.18677>:
      type = type | 3;
      goto <D.18676>;
      <D.18678>:
      monoeg_g_log (0B, 16, "got wrong token in custom attr");
      // predicted unlikely by continue predictor.
      goto <D.18679>;
      <D.18676>:
      D.26648 = values + 4;
      *D.26648 = type;
      p = &blob_size;
      D.26649 = cattr->data;
      D.26650 = mono_array_length (D.26649);
      p.137 = p;
      mono_metadata_encode_value (D.26650, p.137, &p);
      D.26652 = values + 8;
      p.137 = p;
      p.138 = (int) p.137;
      blob_size.139 = (int) &blob_size;
      D.26655 = p.138 - blob_size.139;
      D.26649 = cattr->data;
      D.26656 = mono_array_addr_with_size (D.26649, 1, 0);
      D.26649 = cattr->data;
      D.26657 = mono_array_length (D.26649);
      D.26658 = (int) D.26657;
      D.26659 = add_to_blob_cached (assembly, &blob_size, D.26655, D.26656, D.26658);
      *D.26652 = D.26659;
      values = values + 12;
      D.26641 = table->next_idx;
      D.26660 = D.26641 + 1;
      table->next_idx = D.26660;
      <D.18679>:
      i = i + 1;
      <D.18681>:
      if (i < count) goto <D.18680>; else goto <D.18682>;
      <D.18682>:
    }
  finally
    {
      blob_size = {CLOBBER};
      p = {CLOBBER};
    }
}


mono_image_add_decl_security (struct MonoDynamicImage * assembly, guint32 parent_token, struct MonoArray * permissions)
{
  unsigned int D.26666;
  unsigned int D.26667;
  guint32 * D.26668;
  unsigned int D.26669;
  unsigned int D.26670;
  unsigned int D.26671;
  unsigned int D.26672;
  guint32 * D.26673;
  guint32 * D.26674;
  struct MonoString * D.26675;
  unsigned int D.26676;
  unsigned int D.26677;
  unsigned int D.26678;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 count;
  guint32 i;
  guint32 idx;
  struct MonoReflectionPermissionSet * perm;

  if (permissions == 0B) goto <D.26664>; else goto <D.26665>;
  <D.26664>:
  return;
  <D.26665>:
  count = mono_array_length (permissions);
  table = &assembly->tables[14];
  D.26666 = table->rows;
  D.26667 = D.26666 + count;
  table->rows = D.26667;
  D.26666 = table->rows;
  alloc_table (table, D.26666);
  i = 0;
  goto <D.18700>;
  <D.18699>:
  perm = mono_array_addr_with_size (permissions, 8, i);
  D.26668 = table->values;
  D.26669 = table->next_idx;
  D.26670 = D.26669 * 12;
  values = D.26668 + D.26670;
  idx = parent_token & 16777215;
  idx = idx << 2;
  D.26671 = parent_token >> 24;
  switch (D.26671) <default: <D.18698>, case 2: <D.18694>, case 6: <D.18696>, case 32: <D.18697>>
  <D.18694>:
  idx = idx;
  goto <D.18695>;
  <D.18696>:
  idx = idx | 1;
  goto <D.18695>;
  <D.18697>:
  idx = idx | 2;
  goto <D.18695>;
  <D.18698>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1363);
  <D.18695>:
  D.26672 = perm->action;
  *values = D.26672;
  D.26673 = values + 4;
  *D.26673 = idx;
  D.26674 = values + 8;
  D.26675 = perm->pset;
  D.26676 = add_mono_string_to_blob_cached (assembly, D.26675);
  *D.26674 = D.26676;
  D.26669 = table->next_idx;
  D.26677 = D.26669 + 1;
  table->next_idx = D.26677;
  i = i + 1;
  <D.18700>:
  D.26678 = mono_array_length (permissions);
  if (D.26678 > i) goto <D.18699>; else goto <D.18701>;
  <D.18701>:
}


add_mono_string_to_blob_cached (struct MonoDynamicImage * assembly, struct MonoString * str)
{
  int D.26680;
  int D.26681;
  char * b.140;
  int b.141;
  int blob_size.142;
  int D.26685;
  mono_unichar2 * D.26686;
  int len.143;
  guint32 D.26688;
  char blob_size[64];
  char * b;
  guint32 idx;
  guint32 len;

  try
    {
      b = &blob_size;
      idx = 0;
      D.26680 = str->length;
      D.26681 = D.26680 * 2;
      len = (guint32) D.26681;
      b.140 = b;
      mono_metadata_encode_value (len, b.140, &b);
      b.140 = b;
      b.141 = (int) b.140;
      blob_size.142 = (int) &blob_size;
      D.26685 = b.141 - blob_size.142;
      D.26686 = mono_string_chars (str);
      len.143 = (int) len;
      idx = add_to_blob_cached (assembly, &blob_size, D.26685, D.26686, len.143);
      D.26688 = idx;
      return D.26688;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


module_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionModuleBuilder * moduleb)
{
  unsigned int D.26691;
  struct MonoArray * D.26692;
  struct MonoArray * D.26693;
  unsigned int i.144;
  char * D.26697;
  unsigned int D.26698;
  struct MonoArray * D.26699;
  struct MonoArray * D.26700;
  unsigned int D.26701;
  struct MonoArray * D.26702;
  char * D.26705;
  int D.26706;
  unsigned int D.26707;
  struct MonoArray * D.26708;
  unsigned int D.26709;
  struct MonoArray * D.26710;
  char * D.26713;
  struct MonoReflectionTypeBuilder * D.26714;
  int D.26715;
  int i;

  D.26691 = moduleb->table_idx;
  D.26692 = moduleb->cattrs;
  mono_image_add_cattrs (assembly, D.26691, 7, D.26692);
  D.26693 = moduleb->global_methods;
  if (D.26693 != 0B) goto <D.26694>; else goto <D.26695>;
  <D.26694>:
  i = 0;
  goto <D.19440>;
  <D.19439>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.26693 = moduleb->global_methods;
    i.144 = (unsigned int) i;
    D.26697 = mono_array_addr_with_size (D.26693, 4, i.144);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.26697];
    D.26698 = mb->table_idx;
    D.26699 = mb->cattrs;
    mono_image_add_cattrs (assembly, D.26698, 0, D.26699);
    D.26700 = mb->pinfo;
    params_add_cattrs (assembly, D.26700);
  }
  i = i + 1;
  <D.19440>:
  i.144 = (unsigned int) i;
  D.26693 = moduleb->global_methods;
  D.26701 = mono_array_length (D.26693);
  if (i.144 < D.26701) goto <D.19439>; else goto <D.19441>;
  <D.19441>:
  <D.26695>:
  D.26702 = moduleb->global_fields;
  if (D.26702 != 0B) goto <D.26703>; else goto <D.26704>;
  <D.26703>:
  i = 0;
  goto <D.19444>;
  <D.19443>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.26702 = moduleb->global_fields;
    i.144 = (unsigned int) i;
    D.26705 = mono_array_addr_with_size (D.26702, 4, i.144);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.26705];
    D.26706 = fb->table_idx;
    D.26707 = (unsigned int) D.26706;
    D.26708 = fb->cattrs;
    mono_image_add_cattrs (assembly, D.26707, 1, D.26708);
  }
  i = i + 1;
  <D.19444>:
  i.144 = (unsigned int) i;
  D.26702 = moduleb->global_fields;
  D.26709 = mono_array_length (D.26702);
  if (i.144 < D.26709) goto <D.19443>; else goto <D.19445>;
  <D.19445>:
  <D.26704>:
  D.26710 = moduleb->types;
  if (D.26710 != 0B) goto <D.26711>; else goto <D.26712>;
  <D.26711>:
  i = 0;
  goto <D.19447>;
  <D.19446>:
  D.26710 = moduleb->types;
  i.144 = (unsigned int) i;
  D.26713 = mono_array_addr_with_size (D.26710, 4, i.144);
  D.26714 = MEM[(struct MonoReflectionTypeBuilder * *)D.26713];
  type_add_cattrs (assembly, D.26714);
  i = i + 1;
  <D.19447>:
  D.26715 = moduleb->num_types;
  if (D.26715 > i) goto <D.19446>; else goto <D.19448>;
  <D.19448>:
  <D.26712>:
}


params_add_cattrs (struct MonoDynamicImage * assembly, struct MonoArray * pinfo)
{
  unsigned int i.145;
  char * D.26719;
  unsigned int D.26722;
  struct MonoArray * D.26723;
  unsigned int D.26724;
  int i;

  if (pinfo == 0B) goto <D.26716>; else goto <D.26717>;
  <D.26716>:
  return;
  <D.26717>:
  i = 0;
  goto <D.19403>;
  <D.19402>:
  {
    struct MonoReflectionParamBuilder * pb;

    i.145 = (unsigned int) i;
    D.26719 = mono_array_addr_with_size (pinfo, 4, i.145);
    pb = MEM[(struct MonoReflectionParamBuilder * *)D.26719];
    if (pb == 0B) goto <D.26720>; else goto <D.26721>;
    <D.26720>:
    // predicted unlikely by continue predictor.
    goto <D.19401>;
    <D.26721>:
    D.26722 = pb->table_idx;
    D.26723 = pb->cattrs;
    mono_image_add_cattrs (assembly, D.26722, 4, D.26723);
  }
  <D.19401>:
  i = i + 1;
  <D.19403>:
  i.145 = (unsigned int) i;
  D.26724 = mono_array_length (pinfo);
  if (i.145 < D.26724) goto <D.19402>; else goto <D.19404>;
  <D.19404>:
}


type_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  unsigned int D.26726;
  struct MonoArray * D.26727;
  struct MonoArray * D.26728;
  unsigned int i.146;
  char * D.26732;
  int D.26733;
  unsigned int D.26734;
  struct MonoArray * D.26735;
  int D.26736;
  struct MonoArray * D.26737;
  char * D.26740;
  unsigned int D.26741;
  struct MonoArray * D.26742;
  unsigned int D.26743;
  struct MonoArray * D.26744;
  char * D.26747;
  int D.26748;
  unsigned int D.26749;
  struct MonoArray * D.26750;
  unsigned int D.26751;
  struct MonoArray * D.26752;
  char * D.26755;
  unsigned int D.26756;
  struct MonoArray * D.26757;
  struct MonoArray * D.26758;
  unsigned int D.26759;
  struct MonoArray * D.26760;
  char * D.26763;
  unsigned int D.26764;
  struct MonoArray * D.26765;
  struct MonoArray * D.26766;
  int D.26767;
  struct MonoArray * D.26768;
  char * D.26771;
  struct MonoReflectionTypeBuilder * D.26772;
  unsigned int D.26773;
  int i;

  D.26726 = tb->table_idx;
  D.26727 = tb->cattrs;
  mono_image_add_cattrs (assembly, D.26726, 3, D.26727);
  D.26728 = tb->fields;
  if (D.26728 != 0B) goto <D.26729>; else goto <D.26730>;
  <D.26729>:
  i = 0;
  goto <D.19412>;
  <D.19411>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.26728 = tb->fields;
    i.146 = (unsigned int) i;
    D.26732 = mono_array_addr_with_size (D.26728, 4, i.146);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.26732];
    D.26733 = fb->table_idx;
    D.26734 = (unsigned int) D.26733;
    D.26735 = fb->cattrs;
    mono_image_add_cattrs (assembly, D.26734, 1, D.26735);
  }
  i = i + 1;
  <D.19412>:
  D.26736 = tb->num_fields;
  if (D.26736 > i) goto <D.19411>; else goto <D.19413>;
  <D.19413>:
  <D.26730>:
  D.26737 = tb->events;
  if (D.26737 != 0B) goto <D.26738>; else goto <D.26739>;
  <D.26738>:
  i = 0;
  goto <D.19416>;
  <D.19415>:
  {
    struct MonoReflectionEventBuilder * eb;

    D.26737 = tb->events;
    i.146 = (unsigned int) i;
    D.26740 = mono_array_addr_with_size (D.26737, 4, i.146);
    eb = MEM[(struct MonoReflectionEventBuilder * *)D.26740];
    D.26741 = eb->table_idx;
    D.26742 = eb->cattrs;
    mono_image_add_cattrs (assembly, D.26741, 10, D.26742);
  }
  i = i + 1;
  <D.19416>:
  i.146 = (unsigned int) i;
  D.26737 = tb->events;
  D.26743 = mono_array_length (D.26737);
  if (i.146 < D.26743) goto <D.19415>; else goto <D.19417>;
  <D.19417>:
  <D.26739>:
  D.26744 = tb->properties;
  if (D.26744 != 0B) goto <D.26745>; else goto <D.26746>;
  <D.26745>:
  i = 0;
  goto <D.19420>;
  <D.19419>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    D.26744 = tb->properties;
    i.146 = (unsigned int) i;
    D.26747 = mono_array_addr_with_size (D.26744, 4, i.146);
    pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.26747];
    D.26748 = pb->table_idx;
    D.26749 = (unsigned int) D.26748;
    D.26750 = pb->cattrs;
    mono_image_add_cattrs (assembly, D.26749, 9, D.26750);
  }
  i = i + 1;
  <D.19420>:
  i.146 = (unsigned int) i;
  D.26744 = tb->properties;
  D.26751 = mono_array_length (D.26744);
  if (i.146 < D.26751) goto <D.19419>; else goto <D.19421>;
  <D.19421>:
  <D.26746>:
  D.26752 = tb->ctors;
  if (D.26752 != 0B) goto <D.26753>; else goto <D.26754>;
  <D.26753>:
  i = 0;
  goto <D.19424>;
  <D.19423>:
  {
    struct MonoReflectionCtorBuilder * cb;

    D.26752 = tb->ctors;
    i.146 = (unsigned int) i;
    D.26755 = mono_array_addr_with_size (D.26752, 4, i.146);
    cb = MEM[(struct MonoReflectionCtorBuilder * *)D.26755];
    D.26756 = cb->table_idx;
    D.26757 = cb->cattrs;
    mono_image_add_cattrs (assembly, D.26756, 0, D.26757);
    D.26758 = cb->pinfo;
    params_add_cattrs (assembly, D.26758);
  }
  i = i + 1;
  <D.19424>:
  i.146 = (unsigned int) i;
  D.26752 = tb->ctors;
  D.26759 = mono_array_length (D.26752);
  if (i.146 < D.26759) goto <D.19423>; else goto <D.19425>;
  <D.19425>:
  <D.26754>:
  D.26760 = tb->methods;
  if (D.26760 != 0B) goto <D.26761>; else goto <D.26762>;
  <D.26761>:
  i = 0;
  goto <D.19428>;
  <D.19427>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.26760 = tb->methods;
    i.146 = (unsigned int) i;
    D.26763 = mono_array_addr_with_size (D.26760, 4, i.146);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.26763];
    D.26764 = mb->table_idx;
    D.26765 = mb->cattrs;
    mono_image_add_cattrs (assembly, D.26764, 0, D.26765);
    D.26766 = mb->pinfo;
    params_add_cattrs (assembly, D.26766);
  }
  i = i + 1;
  <D.19428>:
  D.26767 = tb->num_methods;
  if (D.26767 > i) goto <D.19427>; else goto <D.19429>;
  <D.19429>:
  <D.26762>:
  D.26768 = tb->subtypes;
  if (D.26768 != 0B) goto <D.26769>; else goto <D.26770>;
  <D.26769>:
  i = 0;
  goto <D.19431>;
  <D.19430>:
  D.26768 = tb->subtypes;
  i.146 = (unsigned int) i;
  D.26771 = mono_array_addr_with_size (D.26768, 4, i.146);
  D.26772 = MEM[(struct MonoReflectionTypeBuilder * *)D.26771];
  type_add_cattrs (assembly, D.26772);
  i = i + 1;
  <D.19431>:
  i.146 = (unsigned int) i;
  D.26768 = tb->subtypes;
  D.26773 = mono_array_length (D.26768);
  if (i.146 < D.26773) goto <D.19430>; else goto <D.19432>;
  <D.19432>:
  <D.26770>:
}


mono_image_add_methodimpl (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.26774;
  unsigned int i.147;
  char * D.26778;
  unsigned int D.26779;
  unsigned int D.26780;
  guint32 * D.26781;
  unsigned int D.26782;
  unsigned int D.26783;
  guint32 * D.26784;
  unsigned int D.26785;
  unsigned int D.26786;
  unsigned int D.26787;
  unsigned int D.26788;
  unsigned int D.26789;
  guint32 * D.26790;
  unsigned int D.26791;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 tok;
  struct MonoReflectionMethod * m;
  int i;

  tb = mb->type;
  D.26774 = mb->override_methods;
  if (D.26774 == 0B) goto <D.26775>; else goto <D.26776>;
  <D.26775>:
  return;
  <D.26776>:
  i = 0;
  goto <D.18748>;
  <D.18747>:
  D.26774 = mb->override_methods;
  i.147 = (unsigned int) i;
  D.26778 = mono_array_addr_with_size (D.26774, 4, i.147);
  m = MEM[(struct MonoReflectionMethod * *)D.26778];
  table = &assembly->tables[25];
  D.26779 = table->rows;
  D.26780 = D.26779 + 1;
  table->rows = D.26780;
  D.26779 = table->rows;
  alloc_table (table, D.26779);
  D.26781 = table->values;
  D.26779 = table->rows;
  D.26782 = D.26779 * 12;
  values = D.26781 + D.26782;
  D.26783 = tb->table_idx;
  *values = D.26783;
  D.26784 = values + 4;
  D.26785 = mb->table_idx;
  D.26786 = D.26785 << 1;
  *D.26784 = D.26786;
  tok = mono_image_create_token (assembly, m, 0, 0);
  D.26787 = tok >> 24;
  switch (D.26787) <default: <D.18746>, case 6: <D.18745>, case 10: <D.18743>>
  <D.18743>:
  D.26788 = tok & 16777215;
  D.26789 = D.26788 << 1;
  tok = D.26789 | 1;
  goto <D.18744>;
  <D.18745>:
  D.26788 = tok & 16777215;
  tok = D.26788 << 1;
  goto <D.18744>;
  <D.18746>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1589);
  <D.18744>:
  D.26790 = values + 8;
  *D.26790 = tok;
  i = i + 1;
  <D.18748>:
  i.147 = (unsigned int) i;
  D.26774 = mb->override_methods;
  D.26791 = mono_array_length (D.26774);
  if (i.147 < D.26791) goto <D.18747>; else goto <D.18749>;
  <D.18749>:
}


fixup_cattrs (struct MonoDynamicImage * assembly)
{
  guint32 * D.26793;
  unsigned int D.26794;
  unsigned int D.26795;
  unsigned int D.26796;
  struct MonoGHashTable * D.26799;
  const void * token.148;
  _Bool D.26801;
  long int D.26802;
  long int D.26803;
  int D.19901;
  int iftmp.149;
  int D.19900;
  struct MonoVTable * D.26809;
  struct MonoClass * D.26810;
  const char[12] * D.26811;
  unsigned char D.26812;
  int D.26813;
  unsigned char D.26814;
  int D.26815;
  const unsigned char * D.26820;
  unsigned char D.26821;
  int D.26822;
  const unsigned char * D.26823;
  unsigned char D.26824;
  int D.26825;
  const unsigned char * D.26830;
  unsigned char D.26831;
  int D.26832;
  const unsigned char * D.26833;
  unsigned char D.26834;
  int D.26835;
  const unsigned char * D.26840;
  unsigned char D.26841;
  int D.26842;
  const unsigned char * D.26843;
  unsigned char D.26844;
  int D.26845;
  const char * D.26847;
  struct GHashTable * D.26850;
  void * D.26851;
  guint32 * D.26852;
  unsigned int D.26853;
  unsigned int D.26854;
  int D.19911;
  int iftmp.150;
  int D.19910;
  const char[19] * D.26859;
  unsigned char D.26860;
  int D.26861;
  unsigned char D.26862;
  int D.26863;
  const unsigned char * D.26868;
  unsigned char D.26869;
  int D.26870;
  const unsigned char * D.26871;
  unsigned char D.26872;
  int D.26873;
  const unsigned char * D.26878;
  unsigned char D.26879;
  int D.26880;
  const unsigned char * D.26881;
  unsigned char D.26882;
  int D.26883;
  const unsigned char * D.26888;
  unsigned char D.26889;
  int D.26890;
  const unsigned char * D.26891;
  unsigned char D.26892;
  int D.26893;
  void * D.26897;
  unsigned int D.26898;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 type;
  guint32 i;
  guint32 idx;
  guint32 token;
  struct MonoObject * ctor;

  table = &assembly->tables[12];
  i = 0;
  goto <D.19914>;
  <D.19913>:
  D.26793 = table->values;
  D.26794 = i + 1;
  D.26795 = D.26794 * 12;
  values = D.26793 + D.26795;
  type = MEM[(guint32 *)values + 4B];
  D.26796 = type & 7;
  if (D.26796 == 2) goto <D.26797>; else goto <D.26798>;
  <D.26797>:
  idx = type >> 3;
  token = idx | 100663296;
  D.26799 = assembly->remapped_tokens;
  token.148 = (const void *) token;
  ctor = mono_g_hash_table_lookup (D.26799, token.148);
  D.26801 = ctor == 0B;
  D.26802 = (long int) D.26801;
  D.26803 = __builtin_expect (D.26802, 0);
  if (D.26803 != 0) goto <D.26804>; else goto <D.26805>;
  <D.26804>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4337, "ctor");
  <D.26805>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26809 = ctor->vtable;
      D.26810 = D.26809->klass;
      __s2 = D.26810->name;
      D.26811 = "MonoCMethod";
      D.26812 = MEM[(const unsigned char *)D.26811];
      D.26813 = (int) D.26812;
      D.26814 = *__s2;
      D.26815 = (int) D.26814;
      __result = D.26813 - D.26815;
      {
        if (__s2_len != 0) goto <D.26816>; else goto <D.26817>;
        <D.26816>:
        if (__result == 0) goto <D.26818>; else goto <D.26819>;
        <D.26818>:
        D.26820 = &MEM[(void *)"MonoCMethod" + 1B];
        D.26821 = *D.26820;
        D.26822 = (int) D.26821;
        D.26823 = __s2 + 1;
        D.26824 = *D.26823;
        D.26825 = (int) D.26824;
        __result = D.26822 - D.26825;
        if (__s2_len > 1) goto <D.26826>; else goto <D.26827>;
        <D.26826>:
        if (__result == 0) goto <D.26828>; else goto <D.26829>;
        <D.26828>:
        D.26830 = &MEM[(void *)"MonoCMethod" + 2B];
        D.26831 = *D.26830;
        D.26832 = (int) D.26831;
        D.26833 = __s2 + 2;
        D.26834 = *D.26833;
        D.26835 = (int) D.26834;
        __result = D.26832 - D.26835;
        if (__s2_len > 2) goto <D.26836>; else goto <D.26837>;
        <D.26836>:
        if (__result == 0) goto <D.26838>; else goto <D.26839>;
        <D.26838>:
        D.26840 = &MEM[(void *)"MonoCMethod" + 3B];
        D.26841 = *D.26840;
        D.26842 = (int) D.26841;
        D.26843 = __s2 + 3;
        D.26844 = *D.26843;
        D.26845 = (int) D.26844;
        __result = D.26842 - D.26845;
        <D.26839>:
        <D.26837>:
        <D.26829>:
        <D.26827>:
        <D.26819>:
        <D.26817>:
      }
      D.19900 = __result;
    }
    iftmp.149 = -D.19900;
    goto <D.26846>;
    <D.26808>:
    D.26809 = ctor->vtable;
    D.26810 = D.26809->klass;
    D.26847 = D.26810->name;
    iftmp.149 = __builtin_strcmp (D.26847, "MonoCMethod");
    <D.26846>:
    D.19901 = iftmp.149;
  }
  if (D.19901 == 0) goto <D.26848>; else goto <D.26849>;
  <D.26848>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionMethod *)ctor].method;
    D.26850 = assembly->method_to_table_idx;
    D.26851 = monoeg_g_hash_table_lookup (D.26850, m);
    idx = (guint32) D.26851;
    D.26852 = values + 4;
    D.26853 = idx << 3;
    D.26854 = D.26853 | 2;
    *D.26852 = D.26854;
  }
  goto <D.26855>;
  <D.26849>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26809 = ctor->vtable;
      D.26810 = D.26809->klass;
      __s2 = D.26810->name;
      D.26859 = "ConstructorBuilder";
      D.26860 = MEM[(const unsigned char *)D.26859];
      D.26861 = (int) D.26860;
      D.26862 = *__s2;
      D.26863 = (int) D.26862;
      __result = D.26861 - D.26863;
      {
        if (__s2_len != 0) goto <D.26864>; else goto <D.26865>;
        <D.26864>:
        if (__result == 0) goto <D.26866>; else goto <D.26867>;
        <D.26866>:
        D.26868 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.26869 = *D.26868;
        D.26870 = (int) D.26869;
        D.26871 = __s2 + 1;
        D.26872 = *D.26871;
        D.26873 = (int) D.26872;
        __result = D.26870 - D.26873;
        if (__s2_len > 1) goto <D.26874>; else goto <D.26875>;
        <D.26874>:
        if (__result == 0) goto <D.26876>; else goto <D.26877>;
        <D.26876>:
        D.26878 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.26879 = *D.26878;
        D.26880 = (int) D.26879;
        D.26881 = __s2 + 2;
        D.26882 = *D.26881;
        D.26883 = (int) D.26882;
        __result = D.26880 - D.26883;
        if (__s2_len > 2) goto <D.26884>; else goto <D.26885>;
        <D.26884>:
        if (__result == 0) goto <D.26886>; else goto <D.26887>;
        <D.26886>:
        D.26888 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.26889 = *D.26888;
        D.26890 = (int) D.26889;
        D.26891 = __s2 + 3;
        D.26892 = *D.26891;
        D.26893 = (int) D.26892;
        __result = D.26890 - D.26893;
        <D.26887>:
        <D.26885>:
        <D.26877>:
        <D.26875>:
        <D.26867>:
        <D.26865>:
      }
      D.19910 = __result;
    }
    iftmp.150 = -D.19910;
    goto <D.26894>;
    <D.26858>:
    D.26809 = ctor->vtable;
    D.26810 = D.26809->klass;
    D.26847 = D.26810->name;
    iftmp.150 = __builtin_strcmp (D.26847, "ConstructorBuilder");
    <D.26894>:
    D.19911 = iftmp.150;
  }
  if (D.19911 == 0) goto <D.26895>; else goto <D.26896>;
  <D.26895>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionCtorBuilder *)ctor].mhandle;
    D.26850 = assembly->method_to_table_idx;
    D.26897 = monoeg_g_hash_table_lookup (D.26850, m);
    idx = (guint32) D.26897;
    D.26852 = values + 4;
    D.26853 = idx << 3;
    D.26854 = D.26853 | 2;
    *D.26852 = D.26854;
  }
  <D.26896>:
  <D.26855>:
  <D.26798>:
  i = i + 1;
  <D.19914>:
  D.26898 = table->rows;
  if (D.26898 > i) goto <D.19913>; else goto <D.19915>;
  <D.19915>:
}


mono_image_insert_string (struct MonoReflectionModuleBuilder * module, struct MonoString * str)
{
  struct MonoDynamicImage * D.26899;
  int D.26902;
  int D.26905;
  int D.26906;
  int D.26907;
  unsigned int D.26908;
  char * b.151;
  struct MonoDynamicStream * D.26910;
  int b.152;
  int buf.153;
  int D.26913;
  unsigned int D.26914;
  mono_unichar2 * D.26915;
  unsigned int D.26916;
  unsigned int D.26918;
  unsigned int idx.154;
  unsigned int D.26920;
  struct MonoGHashTable * D.26921;
  unsigned int D.26922;
  void * D.26923;
  guint32 D.26924;
  struct MonoDynamicImage * assembly;
  guint32 idx;
  char buf[16];
  char * b;

  try
    {
      b = &buf;
      D.26899 = module->dynamic_image;
      if (D.26899 == 0B) goto <D.26900>; else goto <D.26901>;
      <D.26900>:
      mono_image_module_basic_init (module);
      <D.26901>:
      assembly = module->dynamic_image;
      D.26902 = assembly->save;
      if (D.26902 != 0) goto <D.26903>; else goto <D.26904>;
      <D.26903>:
      D.26905 = str->length;
      D.26906 = D.26905 * 2;
      D.26907 = D.26906 | 1;
      D.26908 = (unsigned int) D.26907;
      b.151 = b;
      mono_metadata_encode_value (D.26908, b.151, &b);
      D.26910 = &assembly->us;
      b.151 = b;
      b.152 = (int) b.151;
      buf.153 = (int) &buf;
      D.26913 = b.152 - buf.153;
      D.26914 = (unsigned int) D.26913;
      idx = mono_image_add_stream_data (D.26910, &buf, D.26914);
      D.26910 = &assembly->us;
      D.26915 = mono_string_chars (str);
      D.26905 = str->length;
      D.26906 = D.26905 * 2;
      D.26916 = (unsigned int) D.26906;
      mono_image_add_stream_data (D.26910, D.26915, D.26916);
      D.26910 = &assembly->us;
      mono_image_add_stream_data (D.26910, "", 1);
      goto <D.26917>;
      <D.26904>:
      D.26918 = assembly->us.index;
      idx.154 = D.26918;
      D.26920 = idx.154 + 1;
      assembly->us.index = D.26920;
      idx = idx.154;
      <D.26917>:
      D.26921 = assembly->tokens;
      D.26922 = idx | 1879048192;
      D.26923 = (void *) D.26922;
      mono_g_hash_table_insert (D.26921, D.26923, str);
      D.26924 = idx | 1879048192;
      return D.26924;
    }
  finally
    {
      buf = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_create_method_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, struct MonoArray * opt_param_types)
{
  struct MonoVTable * D.26927;
  int D.20076;
  int iftmp.155;
  int D.20075;
  const char[11] * D.26934;
  unsigned char D.26935;
  int D.26936;
  unsigned char D.26937;
  int D.26938;
  const unsigned char * D.26943;
  unsigned char D.26944;
  int D.26945;
  const unsigned char * D.26946;
  unsigned char D.26947;
  int D.26948;
  const unsigned char * D.26953;
  unsigned char D.26954;
  int D.26955;
  const unsigned char * D.26956;
  unsigned char D.26957;
  int D.26958;
  const unsigned char * D.26963;
  unsigned char D.26964;
  int D.26965;
  const unsigned char * D.26966;
  unsigned char D.26967;
  int D.26968;
  const char * D.26970;
  int D.20085;
  int iftmp.156;
  int D.20084;
  const char[12] * D.26975;
  unsigned char D.26976;
  int D.26977;
  unsigned char D.26978;
  int D.26979;
  const unsigned char * D.26984;
  unsigned char D.26985;
  int D.26986;
  const unsigned char * D.26987;
  unsigned char D.26988;
  int D.26989;
  const unsigned char * D.26994;
  unsigned char D.26995;
  int D.26996;
  const unsigned char * D.26997;
  unsigned char D.26998;
  int D.26999;
  const unsigned char * D.27004;
  unsigned char D.27005;
  int D.27006;
  const unsigned char * D.27007;
  unsigned char D.27008;
  int D.27009;
  int iftmp.157;
  struct MonoMethodSignature * D.27016;
  short int D.27017;
  _Bool D.27018;
  long int D.27019;
  long int D.27020;
  unsigned int D.27023;
  struct MonoImage * D.27024;
  short unsigned int D.27025;
  int D.27026;
  int D.27027;
  unsigned int D.27028;
  <unnamed-unsigned:1> D.27029;
  <unnamed-unsigned:1> D.27030;
  <unnamed-unsigned:6> D.27031;
  short unsigned int D.27032;
  short unsigned int D.27033;
  short unsigned int D.27034;
  short int D.27035;
  struct MonoType * D.27036;
  struct MonoType * D.27037;
  unsigned int i.158;
  char * D.27039;
  int D.27040;
  struct MonoType * D.27041;
  struct MonoClass * D.27042;
  struct MonoType * D.27043;
  unsigned int D.27044;
  _Bool D.27045;
  long int D.27046;
  long int D.27047;
  const char * D.27050;
  int D.20107;
  int iftmp.159;
  int D.20106;
  const char[14] * D.27054;
  unsigned char D.27055;
  int D.27056;
  unsigned char D.27057;
  int D.27058;
  const unsigned char * D.27063;
  unsigned char D.27064;
  int D.27065;
  const unsigned char * D.27066;
  unsigned char D.27067;
  int D.27068;
  const unsigned char * D.27073;
  unsigned char D.27074;
  int D.27075;
  const unsigned char * D.27076;
  unsigned char D.27077;
  int D.27078;
  const unsigned char * D.27083;
  unsigned char D.27084;
  int D.27085;
  const unsigned char * D.27086;
  unsigned char D.27087;
  int D.27088;
  unsigned int D.27092;
  int iftmp.160;
  struct MonoArray * D.27094;
  unsigned int D.27097;
  int iftmp.161;
  struct MonoArray * D.27100;
  unsigned int D.27103;
  int D.27105;
  unsigned int D.27106;
  unsigned int D.27107;
  unsigned int D.27108;
  _Bool D.27109;
  unsigned int D.27110;
  unsigned int D.27111;
  _Bool D.27112;
  unsigned char D.27113;
  <unnamed-unsigned:6> D.27114;
  short unsigned int D.27115;
  short unsigned int D.27116;
  short unsigned int D.27117;
  short unsigned int D.27118;
  short int D.27119;
  struct MonoReflectionType * D.27120;
  struct MonoType * D.27121;
  unsigned int i.162;
  char * D.27123;
  struct MonoType * D.27124;
  char * D.27125;
  int D.27126;
  struct MonoType * D.27127;
  unsigned int D.27128;
  _Bool D.27129;
  long int D.27130;
  long int D.27131;
  unsigned int D.27134;
  struct MonoString * D.27135;
  struct GHashTable * D.27137;
  void * token.163;
  struct MonoGHashTable * D.27139;
  guint32 D.27140;
  struct MonoClass * klass;
  guint32 token;
  struct MonoMethodSignature * sig;

  token = 0;
  D.26927 = obj->vtable;
  klass = D.26927->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.26934 = "MonoMethod";
      D.26935 = MEM[(const unsigned char *)D.26934];
      D.26936 = (int) D.26935;
      D.26937 = *__s2;
      D.26938 = (int) D.26937;
      __result = D.26936 - D.26938;
      {
        if (__s2_len != 0) goto <D.26939>; else goto <D.26940>;
        <D.26939>:
        if (__result == 0) goto <D.26941>; else goto <D.26942>;
        <D.26941>:
        D.26943 = &MEM[(void *)"MonoMethod" + 1B];
        D.26944 = *D.26943;
        D.26945 = (int) D.26944;
        D.26946 = __s2 + 1;
        D.26947 = *D.26946;
        D.26948 = (int) D.26947;
        __result = D.26945 - D.26948;
        if (__s2_len > 1) goto <D.26949>; else goto <D.26950>;
        <D.26949>:
        if (__result == 0) goto <D.26951>; else goto <D.26952>;
        <D.26951>:
        D.26953 = &MEM[(void *)"MonoMethod" + 2B];
        D.26954 = *D.26953;
        D.26955 = (int) D.26954;
        D.26956 = __s2 + 2;
        D.26957 = *D.26956;
        D.26958 = (int) D.26957;
        __result = D.26955 - D.26958;
        if (__s2_len > 2) goto <D.26959>; else goto <D.26960>;
        <D.26959>:
        if (__result == 0) goto <D.26961>; else goto <D.26962>;
        <D.26961>:
        D.26963 = &MEM[(void *)"MonoMethod" + 3B];
        D.26964 = *D.26963;
        D.26965 = (int) D.26964;
        D.26966 = __s2 + 3;
        D.26967 = *D.26966;
        D.26968 = (int) D.26967;
        __result = D.26965 - D.26968;
        <D.26962>:
        <D.26960>:
        <D.26952>:
        <D.26950>:
        <D.26942>:
        <D.26940>:
      }
      D.20075 = __result;
    }
    iftmp.155 = -D.20075;
    goto <D.26969>;
    <D.26933>:
    D.26970 = klass->name;
    iftmp.155 = __builtin_strcmp (D.26970, "MonoMethod");
    <D.26969>:
    D.20076 = iftmp.155;
  }
  if (D.20076 == 0) goto <D.26928>; else goto <D.26971>;
  <D.26971>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.26975 = "MonoCMethod";
      D.26976 = MEM[(const unsigned char *)D.26975];
      D.26977 = (int) D.26976;
      D.26978 = *__s2;
      D.26979 = (int) D.26978;
      __result = D.26977 - D.26979;
      {
        if (__s2_len != 0) goto <D.26980>; else goto <D.26981>;
        <D.26980>:
        if (__result == 0) goto <D.26982>; else goto <D.26983>;
        <D.26982>:
        D.26984 = &MEM[(void *)"MonoCMethod" + 1B];
        D.26985 = *D.26984;
        D.26986 = (int) D.26985;
        D.26987 = __s2 + 1;
        D.26988 = *D.26987;
        D.26989 = (int) D.26988;
        __result = D.26986 - D.26989;
        if (__s2_len > 1) goto <D.26990>; else goto <D.26991>;
        <D.26990>:
        if (__result == 0) goto <D.26992>; else goto <D.26993>;
        <D.26992>:
        D.26994 = &MEM[(void *)"MonoCMethod" + 2B];
        D.26995 = *D.26994;
        D.26996 = (int) D.26995;
        D.26997 = __s2 + 2;
        D.26998 = *D.26997;
        D.26999 = (int) D.26998;
        __result = D.26996 - D.26999;
        if (__s2_len > 2) goto <D.27000>; else goto <D.27001>;
        <D.27000>:
        if (__result == 0) goto <D.27002>; else goto <D.27003>;
        <D.27002>:
        D.27004 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27005 = *D.27004;
        D.27006 = (int) D.27005;
        D.27007 = __s2 + 3;
        D.27008 = *D.27007;
        D.27009 = (int) D.27008;
        __result = D.27006 - D.27009;
        <D.27003>:
        <D.27001>:
        <D.26993>:
        <D.26991>:
        <D.26983>:
        <D.26981>:
      }
      D.20084 = __result;
    }
    iftmp.156 = -D.20084;
    goto <D.27010>;
    <D.26974>:
    D.26970 = klass->name;
    iftmp.156 = __builtin_strcmp (D.26970, "MonoCMethod");
    <D.27010>:
    D.20085 = iftmp.156;
  }
  if (D.20085 == 0) goto <D.26928>; else goto <D.26929>;
  <D.26928>:
  {
    struct MonoMethod * method;
    struct MonoMethodSignature * old;
    guint32 sig_token;
    guint32 parent;
    int nargs;
    int i;

    method = MEM[(struct MonoReflectionMethod *)obj].method;
    if (opt_param_types == 0B) goto <D.27012>; else goto <D.27015>;
    <D.27015>:
    D.27016 = mono_method_signature (method);
    D.27017 = D.27016->sentinelpos;
    if (D.27017 < 0) goto <D.27012>; else goto <D.27013>;
    <D.27012>:
    iftmp.157 = 1;
    goto <D.27014>;
    <D.27013>:
    iftmp.157 = 0;
    <D.27014>:
    D.27018 = iftmp.157 != 0;
    D.27019 = (long int) D.27018;
    D.27020 = __builtin_expect (D.27019, 0);
    if (D.27020 != 0) goto <D.27021>; else goto <D.27022>;
    <D.27021>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4813, "opt_param_types && (mono_method_signature (method)->sentinelpos >= 0)");
    <D.27022>:
    D.27023 = mono_array_length (opt_param_types);
    nargs = (int) D.27023;
    old = mono_method_signature (method);
    D.27024 = &assembly->image;
    D.27025 = old->param_count;
    D.27026 = (int) D.27025;
    D.27027 = D.27026 + nargs;
    D.27028 = (unsigned int) D.27027;
    sig = mono_metadata_signature_alloc (D.27024, D.27028);
    D.27029 = old->hasthis;
    sig->hasthis = D.27029;
    D.27030 = old->explicit_this;
    sig->explicit_this = D.27030;
    D.27031 = old->call_convention;
    sig->call_convention = D.27031;
    D.27032 = old->generic_param_count;
    sig->generic_param_count = D.27032;
    D.27025 = old->param_count;
    D.27033 = (short unsigned int) nargs;
    D.27034 = D.27025 + D.27033;
    sig->param_count = D.27034;
    D.27025 = old->param_count;
    D.27035 = (short int) D.27025;
    sig->sentinelpos = D.27035;
    D.27036 = old->ret;
    sig->ret = D.27036;
    i = 0;
    goto <D.20093>;
    <D.20092>:
    D.27037 = old->params[i];
    sig->params[i] = D.27037;
    i = i + 1;
    <D.20093>:
    D.27025 = old->param_count;
    D.27026 = (int) D.27025;
    if (D.27026 > i) goto <D.20092>; else goto <D.20094>;
    <D.20094>:
    i = 0;
    goto <D.20097>;
    <D.20096>:
    {
      struct MonoReflectionType * rt;

      i.158 = (unsigned int) i;
      D.27039 = mono_array_addr_with_size (opt_param_types, 4, i.158);
      rt = MEM[(struct MonoReflectionType * *)D.27039];
      D.27025 = old->param_count;
      D.27026 = (int) D.27025;
      D.27040 = D.27026 + i;
      D.27041 = mono_reflection_type_get_handle (rt);
      sig->params[D.27040] = D.27041;
    }
    i = i + 1;
    <D.20097>:
    if (i < nargs) goto <D.20096>; else goto <D.20098>;
    <D.20098>:
    D.27042 = method->klass;
    D.27043 = &D.27042->byval_arg;
    parent = mono_image_typedef_or_ref (assembly, D.27043);
    D.27044 = parent & 3;
    D.27045 = D.27044 != 1;
    D.27046 = (long int) D.27045;
    D.27047 = __builtin_expect (D.27046, 0);
    if (D.27047 != 0) goto <D.27048>; else goto <D.27049>;
    <D.27048>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4836, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF");
    <D.27049>:
    parent = parent >> 2;
    parent = parent << 3;
    parent = parent | 1;
    sig_token = method_encode_signature (assembly, sig);
    D.27050 = method->name;
    token = mono_image_get_varargs_method_token (assembly, parent, D.27050, sig_token);
  }
  goto <D.26930>;
  <D.26929>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27054 = "MethodBuilder";
      D.27055 = MEM[(const unsigned char *)D.27054];
      D.27056 = (int) D.27055;
      D.27057 = *__s2;
      D.27058 = (int) D.27057;
      __result = D.27056 - D.27058;
      {
        if (__s2_len != 0) goto <D.27059>; else goto <D.27060>;
        <D.27059>:
        if (__result == 0) goto <D.27061>; else goto <D.27062>;
        <D.27061>:
        D.27063 = &MEM[(void *)"MethodBuilder" + 1B];
        D.27064 = *D.27063;
        D.27065 = (int) D.27064;
        D.27066 = __s2 + 1;
        D.27067 = *D.27066;
        D.27068 = (int) D.27067;
        __result = D.27065 - D.27068;
        if (__s2_len > 1) goto <D.27069>; else goto <D.27070>;
        <D.27069>:
        if (__result == 0) goto <D.27071>; else goto <D.27072>;
        <D.27071>:
        D.27073 = &MEM[(void *)"MethodBuilder" + 2B];
        D.27074 = *D.27073;
        D.27075 = (int) D.27074;
        D.27076 = __s2 + 2;
        D.27077 = *D.27076;
        D.27078 = (int) D.27077;
        __result = D.27075 - D.27078;
        if (__s2_len > 2) goto <D.27079>; else goto <D.27080>;
        <D.27079>:
        if (__result == 0) goto <D.27081>; else goto <D.27082>;
        <D.27081>:
        D.27083 = &MEM[(void *)"MethodBuilder" + 3B];
        D.27084 = *D.27083;
        D.27085 = (int) D.27084;
        D.27086 = __s2 + 3;
        D.27087 = *D.27086;
        D.27088 = (int) D.27087;
        __result = D.27085 - D.27088;
        <D.27082>:
        <D.27080>:
        <D.27072>:
        <D.27070>:
        <D.27062>:
        <D.27060>:
      }
      D.20106 = __result;
    }
    iftmp.159 = -D.20106;
    goto <D.27089>;
    <D.27053>:
    D.26970 = klass->name;
    iftmp.159 = __builtin_strcmp (D.26970, "MethodBuilder");
    <D.27089>:
    D.20107 = iftmp.159;
  }
  if (D.20107 == 0) goto <D.27090>; else goto <D.27091>;
  <D.27090>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct ReflectionMethodBuilder rmb;
    guint32 parent;
    guint32 sig_token;
    int nopt_args;
    int nparams;
    int ngparams;
    int i;
    char * name;

    try
      {
        mb = obj;
        reflection_methodbuilder_from_method_builder (&rmb, mb);
        rmb.opt_types = opt_param_types;
        D.27092 = mono_array_length (opt_param_types);
        nopt_args = (int) D.27092;
        D.27094 = rmb.parameters;
        if (D.27094 != 0B) goto <D.27095>; else goto <D.27096>;
        <D.27095>:
        D.27094 = rmb.parameters;
        D.27097 = mono_array_length (D.27094);
        iftmp.160 = (int) D.27097;
        goto <D.27098>;
        <D.27096>:
        iftmp.160 = 0;
        <D.27098>:
        nparams = iftmp.160;
        D.27100 = rmb.generic_params;
        if (D.27100 != 0B) goto <D.27101>; else goto <D.27102>;
        <D.27101>:
        D.27100 = rmb.generic_params;
        D.27103 = mono_array_length (D.27100);
        iftmp.161 = (int) D.27103;
        goto <D.27104>;
        <D.27102>:
        iftmp.161 = 0;
        <D.27104>:
        ngparams = iftmp.161;
        D.27024 = &assembly->image;
        D.27105 = nparams + nopt_args;
        D.27106 = (unsigned int) D.27105;
        sig = mono_metadata_signature_alloc (D.27024, D.27106);
        D.27107 = rmb.attrs;
        D.27108 = D.27107 & 16;
        D.27109 = D.27108 == 0;
        sig->hasthis = D.27109;
        D.27110 = rmb.call_conv;
        D.27111 = D.27110 & 64;
        D.27112 = D.27111 != 0;
        sig->explicit_this = D.27112;
        D.27110 = rmb.call_conv;
        D.27113 = (unsigned char) D.27110;
        D.27114 = (<unnamed-unsigned:6>) D.27113;
        sig->call_convention = D.27114;
        D.27115 = (short unsigned int) ngparams;
        sig->generic_param_count = D.27115;
        D.27116 = (short unsigned int) nparams;
        D.27117 = (short unsigned int) nopt_args;
        D.27118 = D.27116 + D.27117;
        sig->param_count = D.27118;
        D.27119 = (short int) nparams;
        sig->sentinelpos = D.27119;
        D.27120 = rmb.rtype;
        D.27121 = mono_reflection_type_get_handle (D.27120);
        sig->ret = D.27121;
        i = 0;
        goto <D.20119>;
        <D.20118>:
        {
          struct MonoReflectionType * rt;

          D.27094 = rmb.parameters;
          i.162 = (unsigned int) i;
          D.27123 = mono_array_addr_with_size (D.27094, 4, i.162);
          rt = MEM[(struct MonoReflectionType * *)D.27123];
          D.27124 = mono_reflection_type_get_handle (rt);
          sig->params[i] = D.27124;
        }
        i = i + 1;
        <D.20119>:
        if (i < nparams) goto <D.20118>; else goto <D.20120>;
        <D.20120>:
        i = 0;
        goto <D.20123>;
        <D.20122>:
        {
          struct MonoReflectionType * rt;

          i.162 = (unsigned int) i;
          D.27125 = mono_array_addr_with_size (opt_param_types, 4, i.162);
          rt = MEM[(struct MonoReflectionType * *)D.27125];
          D.27126 = nparams + i;
          D.27127 = mono_reflection_type_get_handle (rt);
          sig->params[D.27126] = D.27127;
        }
        i = i + 1;
        <D.20123>:
        if (i < nopt_args) goto <D.20122>; else goto <D.20124>;
        <D.20124>:
        sig_token = method_builder_encode_signature (assembly, &rmb);
        parent = mono_image_create_token (assembly, obj, 1, 1);
        D.27128 = parent >> 24;
        D.27129 = D.27128 != 6;
        D.27130 = (long int) D.27129;
        D.27131 = __builtin_expect (D.27130, 0);
        if (D.27131 != 0) goto <D.27132>; else goto <D.27133>;
        <D.27132>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4880, "mono_metadata_token_table (parent) == MONO_TABLE_METHOD");
        <D.27133>:
        D.27134 = parent & 16777215;
        parent = D.27134 << 3;
        parent = parent | 3;
        D.27135 = rmb.name;
        name = mono_string_to_utf8 (D.27135);
        token = mono_image_get_varargs_method_token (assembly, parent, name, sig_token);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.27136>;
  <D.27091>:
  D.26970 = klass->name;
  monoeg_g_log (0B, 4, "requested method token for %s\n", D.26970);
  <D.20125>:
  goto <D.20125>;
  <D.27136>:
  <D.26930>:
  D.27137 = assembly->vararg_aux_hash;
  token.163 = (void *) token;
  monoeg_g_hash_table_insert_replace (D.27137, token.163, sig, 0);
  D.27139 = assembly->tokens;
  token.163 = (void *) token;
  mono_g_hash_table_insert (D.27139, token.163, obj);
  D.27140 = token;
  return D.27140;
}


method_encode_signature (struct MonoDynamicImage * assembly, struct MonoMethodSignature * sig)
{
  short unsigned int D.27142;
  int D.27143;
  guint32 D.27146;
  <unnamed-unsigned:6> D.27147;
  unsigned int D.27148;
  unsigned int D.27149;
  short unsigned int D.27152;
  unsigned char D.27155;
  int D.27156;
  unsigned int D.27159;
  struct MonoType * D.27160;
  short int D.27161;
  int D.27162;
  struct MonoType * D.27165;
  unsigned int i.164;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.27142 = sig->param_count;
      nparams = (guint32) D.27142;
      D.27143 = assembly->save;
      if (D.27143 == 0) goto <D.27144>; else goto <D.27145>;
      <D.27144>:
      D.27146 = 0;
      return D.27146;
      <D.27145>:
      sigbuffer_init (&buf, 32);
      D.27147 = sig->call_convention;
      idx = (guint32) D.27147;
      D.27148 = BIT_FIELD_REF <*sig, 32, 64>;
      D.27149 = D.27148 & 4194304;
      if (D.27149 != 0) goto <D.27150>; else goto <D.27151>;
      <D.27150>:
      idx = idx | 32;
      <D.27151>:
      D.27152 = sig->generic_param_count;
      if (D.27152 != 0) goto <D.27153>; else goto <D.27154>;
      <D.27153>:
      idx = idx | 16;
      <D.27154>:
      D.27155 = (unsigned char) idx;
      D.27156 = (int) D.27155;
      sigbuffer_add_byte (&buf, D.27156);
      D.27152 = sig->generic_param_count;
      if (D.27152 != 0) goto <D.27157>; else goto <D.27158>;
      <D.27157>:
      D.27152 = sig->generic_param_count;
      D.27159 = (unsigned int) D.27152;
      sigbuffer_add_value (&buf, D.27159);
      <D.27158>:
      sigbuffer_add_value (&buf, nparams);
      D.27160 = sig->ret;
      encode_type (assembly, D.27160, &buf);
      i = 0;
      goto <D.18508>;
      <D.18507>:
      D.27161 = sig->sentinelpos;
      D.27162 = (int) D.27161;
      if (D.27162 == i) goto <D.27163>; else goto <D.27164>;
      <D.27163>:
      sigbuffer_add_byte (&buf, 65);
      <D.27164>:
      D.27165 = sig->params[i];
      encode_type (assembly, D.27165, &buf);
      i = i + 1;
      <D.18508>:
      i.164 = (unsigned int) i;
      if (i.164 < nparams) goto <D.18507>; else goto <D.18509>;
      <D.18509>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27146 = idx;
      return D.27146;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_varargs_method_token (struct MonoDynamicImage * assembly, guint32 original, const gchar * name, guint32 sig)
{
  int D.27169;
  unsigned int D.27172;
  unsigned int D.27173;
  guint32 * D.27174;
  unsigned int D.27175;
  unsigned int D.27176;
  guint32 * D.27177;
  struct MonoDynamicStream * D.27178;
  unsigned int D.27179;
  guint32 * D.27180;
  unsigned int D.27181;
  guint32 D.27182;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;

  table = &assembly->tables[10];
  D.27169 = assembly->save;
  if (D.27169 != 0) goto <D.27170>; else goto <D.27171>;
  <D.27170>:
  D.27172 = table->rows;
  D.27173 = D.27172 + 1;
  alloc_table (table, D.27173);
  D.27174 = table->values;
  D.27175 = table->next_idx;
  D.27176 = D.27175 * 12;
  values = D.27174 + D.27176;
  *values = original;
  D.27177 = values + 4;
  D.27178 = &assembly->sheap;
  D.27179 = string_heap_insert (D.27178, name);
  *D.27177 = D.27179;
  D.27180 = values + 8;
  *D.27180 = sig;
  <D.27171>:
  D.27175 = table->next_idx;
  token = D.27175 | 167772160;
  D.27175 = table->next_idx;
  D.27181 = D.27175 + 1;
  table->next_idx = D.27181;
  D.27182 = token;
  return D.27182;
}


mono_image_create_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, gboolean create_open_instance, gboolean register_token)
{
  struct MonoVTable * D.27184;
  struct MonoImage * D.27187;
  struct MonoImage * D.27188;
  int D.20142;
  int iftmp.165;
  int D.20141;
  const char[14] * D.27193;
  unsigned char D.27194;
  int D.27195;
  unsigned char D.27196;
  int D.27197;
  const unsigned char * D.27202;
  unsigned char D.27203;
  int D.27204;
  const unsigned char * D.27205;
  unsigned char D.27206;
  int D.27207;
  const unsigned char * D.27212;
  unsigned char D.27213;
  int D.27214;
  const unsigned char * D.27215;
  unsigned char D.27216;
  int D.27217;
  const unsigned char * D.27222;
  unsigned char D.27223;
  int D.27224;
  const unsigned char * D.27225;
  unsigned char D.27226;
  int D.27227;
  const char * D.27229;
  struct MonoException * D.27230;
  int D.20151;
  int iftmp.166;
  int D.20150;
  const char[14] * D.27234;
  unsigned char D.27235;
  int D.27236;
  unsigned char D.27237;
  int D.27238;
  const unsigned char * D.27243;
  unsigned char D.27244;
  int D.27245;
  const unsigned char * D.27246;
  unsigned char D.27247;
  int D.27248;
  const unsigned char * D.27253;
  unsigned char D.27254;
  int D.27255;
  const unsigned char * D.27256;
  unsigned char D.27257;
  int D.27258;
  const unsigned char * D.27263;
  unsigned char D.27264;
  int D.27265;
  const unsigned char * D.27266;
  unsigned char D.27267;
  int D.27268;
  struct MonoReflectionModuleBuilder * D.27274;
  struct MonoDynamicImage * D.27275;
  struct MonoArray * D.27277;
  struct MonoArray * D.27279;
  unsigned int D.27281;
  int D.20162;
  int iftmp.167;
  int D.20161;
  const char[19] * D.27286;
  unsigned char D.27287;
  int D.27288;
  unsigned char D.27289;
  int D.27290;
  const unsigned char * D.27295;
  unsigned char D.27296;
  int D.27297;
  const unsigned char * D.27298;
  unsigned char D.27299;
  int D.27300;
  const unsigned char * D.27305;
  unsigned char D.27306;
  int D.27307;
  const unsigned char * D.27308;
  unsigned char D.27309;
  int D.27310;
  const unsigned char * D.27315;
  unsigned char D.27316;
  int D.27317;
  const unsigned char * D.27318;
  unsigned char D.27319;
  int D.27320;
  struct MonoReflectionModuleBuilder * D.27326;
  struct MonoDynamicImage * D.27327;
  struct MonoArray * D.27329;
  unsigned int D.27331;
  int D.20173;
  int iftmp.168;
  int D.20172;
  const char[13] * D.27336;
  unsigned char D.27337;
  int D.27338;
  unsigned char D.27339;
  int D.27340;
  const unsigned char * D.27345;
  unsigned char D.27346;
  int D.27347;
  const unsigned char * D.27348;
  unsigned char D.27349;
  int D.27350;
  const unsigned char * D.27355;
  unsigned char D.27356;
  int D.27357;
  const unsigned char * D.27358;
  unsigned char D.27359;
  int D.27360;
  const unsigned char * D.27365;
  unsigned char D.27366;
  int D.27367;
  const unsigned char * D.27368;
  unsigned char D.27369;
  int D.27370;
  struct MonoArray * D.27374;
  struct MonoReflectionModuleBuilder * D.27378;
  struct MonoDynamicImage * D.27379;
  int D.27382;
  int D.27383;
  struct MonoClassField * D.27385;
  int D.20184;
  int iftmp.169;
  int D.20183;
  const char[12] * D.27390;
  unsigned char D.27391;
  int D.27392;
  unsigned char D.27393;
  int D.27394;
  const unsigned char * D.27399;
  unsigned char D.27400;
  int D.27401;
  const unsigned char * D.27402;
  unsigned char D.27403;
  int D.27404;
  const unsigned char * D.27409;
  unsigned char D.27410;
  int D.27411;
  const unsigned char * D.27412;
  unsigned char D.27413;
  int D.27414;
  const unsigned char * D.27419;
  unsigned char D.27420;
  int D.27421;
  const unsigned char * D.27422;
  unsigned char D.27423;
  int D.27424;
  struct MonoArray * D.27431;
  struct MonoReflectionModuleBuilder * D.27433;
  struct MonoDynamicImage * D.27434;
  unsigned int D.27437;
  unsigned int D.27439;
  int D.20196;
  int iftmp.170;
  int D.20195;
  const char[9] * D.27444;
  unsigned char D.27445;
  int D.27446;
  unsigned char D.27447;
  int D.27448;
  const unsigned char * D.27453;
  unsigned char D.27454;
  int D.27455;
  const unsigned char * D.27456;
  unsigned char D.27457;
  int D.27458;
  const unsigned char * D.27463;
  unsigned char D.27464;
  int D.27465;
  const unsigned char * D.27466;
  unsigned char D.27467;
  int D.27468;
  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 iftmp.171;
  struct MonoGenericContainer * D.27486;
  unsigned int D.27488;
  int D.20207;
  int iftmp.172;
  int D.20206;
  const char[28] * D.27493;
  unsigned char D.27494;
  int D.27495;
  unsigned char D.27496;
  int D.27497;
  const unsigned char * D.27502;
  unsigned char D.27503;
  int D.27504;
  const unsigned char * D.27505;
  unsigned char D.27506;
  int D.27507;
  const unsigned char * D.27512;
  unsigned char D.27513;
  int D.27514;
  const unsigned char * D.27515;
  unsigned char D.27516;
  int D.27517;
  const unsigned char * D.27522;
  unsigned char D.27523;
  int D.27524;
  const unsigned char * D.27525;
  unsigned char D.27526;
  int D.27527;
  unsigned int D.27531;
  int D.20217;
  int iftmp.173;
  int D.20216;
  const char[17] * D.27536;
  unsigned char D.27537;
  int D.27538;
  unsigned char D.27539;
  int D.27540;
  const unsigned char * D.27545;
  unsigned char D.27546;
  int D.27547;
  const unsigned char * D.27548;
  unsigned char D.27549;
  int D.27550;
  const unsigned char * D.27555;
  unsigned char D.27556;
  int D.27557;
  const unsigned char * D.27558;
  unsigned char D.27559;
  int D.27560;
  const unsigned char * D.27565;
  unsigned char D.27566;
  int D.27567;
  const unsigned char * D.27568;
  unsigned char D.27569;
  int D.27570;
  unsigned int D.27574;
  int D.20227;
  int iftmp.174;
  int D.20226;
  const char[12] * D.27582;
  unsigned char D.27583;
  int D.27584;
  unsigned char D.27585;
  int D.27586;
  const unsigned char * D.27591;
  unsigned char D.27592;
  int D.27593;
  const unsigned char * D.27594;
  unsigned char D.27595;
  int D.27596;
  const unsigned char * D.27601;
  unsigned char D.27602;
  int D.27603;
  const unsigned char * D.27604;
  unsigned char D.27605;
  int D.27606;
  const unsigned char * D.27611;
  unsigned char D.27612;
  int D.27613;
  const unsigned char * D.27614;
  unsigned char D.27615;
  int D.27616;
  int D.20236;
  int iftmp.175;
  int D.20235;
  const char[11] * D.27622;
  unsigned char D.27623;
  int D.27624;
  unsigned char D.27625;
  int D.27626;
  const unsigned char * D.27631;
  unsigned char D.27632;
  int D.27633;
  const unsigned char * D.27634;
  unsigned char D.27635;
  int D.27636;
  const unsigned char * D.27641;
  unsigned char D.27642;
  int D.27643;
  const unsigned char * D.27644;
  unsigned char D.27645;
  int D.27646;
  const unsigned char * D.27651;
  unsigned char D.27652;
  int D.27653;
  const unsigned char * D.27654;
  unsigned char D.27655;
  int D.27656;
  int D.20245;
  int iftmp.176;
  int D.20244;
  const char[18] * D.27662;
  unsigned char D.27663;
  int D.27664;
  unsigned char D.27665;
  int D.27666;
  const unsigned char * D.27671;
  unsigned char D.27672;
  int D.27673;
  const unsigned char * D.27674;
  unsigned char D.27675;
  int D.27676;
  const unsigned char * D.27681;
  unsigned char D.27682;
  int D.27683;
  const unsigned char * D.27684;
  unsigned char D.27685;
  int D.27686;
  const unsigned char * D.27691;
  unsigned char D.27692;
  int D.27693;
  const unsigned char * D.27694;
  unsigned char D.27695;
  int D.27696;
  int D.20254;
  int iftmp.177;
  int D.20253;
  const char[19] * D.27702;
  unsigned char D.27703;
  int D.27704;
  unsigned char D.27705;
  int D.27706;
  const unsigned char * D.27711;
  unsigned char D.27712;
  int D.27713;
  const unsigned char * D.27714;
  unsigned char D.27715;
  int D.27716;
  const unsigned char * D.27721;
  unsigned char D.27722;
  int D.27723;
  const unsigned char * D.27724;
  unsigned char D.27725;
  int D.27726;
  const unsigned char * D.27731;
  unsigned char D.27732;
  int D.27733;
  const unsigned char * D.27734;
  unsigned char D.27735;
  int D.27736;
  struct MonoMethod * D.27738;
  unsigned int D.27739;
  unsigned int D.27740;
  struct MonoClass * D.27749;
  struct MonoImage * D.27750;
  struct MonoImage * D.27751;
  struct MonoGenericClass * D.27753;
  unsigned int D.27755;
  unsigned int D.27756;
  unsigned int method_table_idx.178;
  unsigned int method_table_idx.179;
  int D.20265;
  int iftmp.180;
  int D.20264;
  const char[10] * D.27765;
  unsigned char D.27766;
  int D.27767;
  unsigned char D.27768;
  int D.27769;
  const unsigned char * D.27774;
  unsigned char D.27775;
  int D.27776;
  const unsigned char * D.27777;
  unsigned char D.27778;
  int D.27779;
  const unsigned char * D.27784;
  unsigned char D.27785;
  int D.27786;
  const unsigned char * D.27787;
  unsigned char D.27788;
  int D.27789;
  const unsigned char * D.27794;
  unsigned char D.27795;
  int D.27796;
  const unsigned char * D.27797;
  unsigned char D.27798;
  int D.27799;
  struct MonoClassField * D.27805;
  struct MonoClass * D.27806;
  struct MonoImage * D.27807;
  int D.27809;
  unsigned int field_table_idx.181;
  unsigned int field_table_idx.182;
  int D.20276;
  int iftmp.183;
  int D.20275;
  const char[16] * D.27817;
  unsigned char D.27818;
  int D.27819;
  unsigned char D.27820;
  int D.27821;
  const unsigned char * D.27826;
  unsigned char D.27827;
  int D.27828;
  const unsigned char * D.27829;
  unsigned char D.27830;
  int D.27831;
  const unsigned char * D.27836;
  unsigned char D.27837;
  int D.27838;
  const unsigned char * D.27839;
  unsigned char D.27840;
  int D.27841;
  const unsigned char * D.27846;
  unsigned char D.27847;
  int D.27848;
  const unsigned char * D.27849;
  unsigned char D.27850;
  int D.27851;
  int D.20286;
  int iftmp.184;
  int D.20285;
  const char[16] * D.27859;
  unsigned char D.27860;
  int D.27861;
  unsigned char D.27862;
  int D.27863;
  const unsigned char * D.27868;
  unsigned char D.27869;
  int D.27870;
  const unsigned char * D.27871;
  unsigned char D.27872;
  int D.27873;
  const unsigned char * D.27878;
  unsigned char D.27879;
  int D.27880;
  const unsigned char * D.27881;
  unsigned char D.27882;
  int D.27883;
  const unsigned char * D.27888;
  unsigned char D.27889;
  int D.27890;
  const unsigned char * D.27891;
  unsigned char D.27892;
  int D.27893;
  unsigned int D.27897;
  int D.20296;
  int iftmp.185;
  int D.20295;
  const char[12] * D.27902;
  unsigned char D.27903;
  int D.27904;
  unsigned char D.27905;
  int D.27906;
  const unsigned char * D.27911;
  unsigned char D.27912;
  int D.27913;
  const unsigned char * D.27914;
  unsigned char D.27915;
  int D.27916;
  const unsigned char * D.27921;
  unsigned char D.27922;
  int D.27923;
  const unsigned char * D.27924;
  unsigned char D.27925;
  int D.27926;
  const unsigned char * D.27931;
  unsigned char D.27932;
  int D.27933;
  const unsigned char * D.27934;
  unsigned char D.27935;
  int D.27936;
  unsigned int D.27940;
  int D.20306;
  int iftmp.186;
  int D.20305;
  const char[23] * D.27945;
  unsigned char D.27946;
  int D.27947;
  unsigned char D.27948;
  int D.27949;
  const unsigned char * D.27954;
  unsigned char D.27955;
  int D.27956;
  const unsigned char * D.27957;
  unsigned char D.27958;
  int D.27959;
  const unsigned char * D.27964;
  unsigned char D.27965;
  int D.27966;
  const unsigned char * D.27967;
  unsigned char D.27968;
  int D.27969;
  const unsigned char * D.27974;
  unsigned char D.27975;
  int D.27976;
  const unsigned char * D.27977;
  unsigned char D.27978;
  int D.27979;
  int D.20316;
  int iftmp.187;
  int D.20315;
  const char[29] * D.27987;
  unsigned char D.27988;
  int D.27989;
  unsigned char D.27990;
  int D.27991;
  const unsigned char * D.27996;
  unsigned char D.27997;
  int D.27998;
  const unsigned char * D.27999;
  unsigned char D.28000;
  int D.28001;
  const unsigned char * D.28006;
  unsigned char D.28007;
  int D.28008;
  const unsigned char * D.28009;
  unsigned char D.28010;
  int D.28011;
  const unsigned char * D.28016;
  unsigned char D.28017;
  int D.28018;
  const unsigned char * D.28019;
  unsigned char D.28020;
  int D.28021;
  int D.20326;
  int iftmp.188;
  int D.20325;
  const char[24] * D.28029;
  unsigned char D.28030;
  int D.28031;
  unsigned char D.28032;
  int D.28033;
  const unsigned char * D.28038;
  unsigned char D.28039;
  int D.28040;
  const unsigned char * D.28041;
  unsigned char D.28042;
  int D.28043;
  const unsigned char * D.28048;
  unsigned char D.28049;
  int D.28050;
  const unsigned char * D.28051;
  unsigned char D.28052;
  int D.28053;
  const unsigned char * D.28058;
  unsigned char D.28059;
  int D.28060;
  const unsigned char * D.28061;
  unsigned char D.28062;
  int D.28063;
  int D.28071;
  int D.28073;
  int D.28075;
  struct MonoType * D.28076;
  unsigned int D.28077;
  guint32 D.28080;
  struct MonoClass * klass;
  guint32 token;

  token = 0;
  D.27184 = obj->vtable;
  klass = D.27184->klass;
  D.27187 = klass->image;
  D.27188 = mono_defaults.corlib;
  if (D.27187 != D.27188) goto <D.27185>; else goto <D.27189>;
  <D.27189>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27193 = "TypeDelegator";
      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;
      {
        if (__s2_len != 0) goto <D.27198>; else goto <D.27199>;
        <D.27198>:
        if (__result == 0) goto <D.27200>; else goto <D.27201>;
        <D.27200>:
        D.27202 = &MEM[(void *)"TypeDelegator" + 1B];
        D.27203 = *D.27202;
        D.27204 = (int) D.27203;
        D.27205 = __s2 + 1;
        D.27206 = *D.27205;
        D.27207 = (int) D.27206;
        __result = D.27204 - D.27207;
        if (__s2_len > 1) goto <D.27208>; else goto <D.27209>;
        <D.27208>:
        if (__result == 0) goto <D.27210>; else goto <D.27211>;
        <D.27210>:
        D.27212 = &MEM[(void *)"TypeDelegator" + 2B];
        D.27213 = *D.27212;
        D.27214 = (int) D.27213;
        D.27215 = __s2 + 2;
        D.27216 = *D.27215;
        D.27217 = (int) D.27216;
        __result = D.27214 - D.27217;
        if (__s2_len > 2) goto <D.27218>; else goto <D.27219>;
        <D.27218>:
        if (__result == 0) goto <D.27220>; else goto <D.27221>;
        <D.27220>:
        D.27222 = &MEM[(void *)"TypeDelegator" + 3B];
        D.27223 = *D.27222;
        D.27224 = (int) D.27223;
        D.27225 = __s2 + 3;
        D.27226 = *D.27225;
        D.27227 = (int) D.27226;
        __result = D.27224 - D.27227;
        <D.27221>:
        <D.27219>:
        <D.27211>:
        <D.27209>:
        <D.27201>:
        <D.27199>:
      }
      D.20141 = __result;
    }
    iftmp.165 = -D.20141;
    goto <D.27228>;
    <D.27192>:
    D.27229 = klass->name;
    iftmp.165 = __builtin_strcmp (D.27229, "TypeDelegator");
    <D.27228>:
    D.20142 = iftmp.165;
  }
  if (D.20142 == 0) goto <D.27185>; else goto <D.27186>;
  <D.27185>:
  D.27230 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported");
  mono_raise_exception (D.27230);
  <D.27186>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27234 = "MethodBuilder";
      D.27235 = MEM[(const unsigned char *)D.27234];
      D.27236 = (int) D.27235;
      D.27237 = *__s2;
      D.27238 = (int) D.27237;
      __result = D.27236 - D.27238;
      {
        if (__s2_len != 0) goto <D.27239>; else goto <D.27240>;
        <D.27239>:
        if (__result == 0) goto <D.27241>; else goto <D.27242>;
        <D.27241>:
        D.27243 = &MEM[(void *)"MethodBuilder" + 1B];
        D.27244 = *D.27243;
        D.27245 = (int) D.27244;
        D.27246 = __s2 + 1;
        D.27247 = *D.27246;
        D.27248 = (int) D.27247;
        __result = D.27245 - D.27248;
        if (__s2_len > 1) goto <D.27249>; else goto <D.27250>;
        <D.27249>:
        if (__result == 0) goto <D.27251>; else goto <D.27252>;
        <D.27251>:
        D.27253 = &MEM[(void *)"MethodBuilder" + 2B];
        D.27254 = *D.27253;
        D.27255 = (int) D.27254;
        D.27256 = __s2 + 2;
        D.27257 = *D.27256;
        D.27258 = (int) D.27257;
        __result = D.27255 - D.27258;
        if (__s2_len > 2) goto <D.27259>; else goto <D.27260>;
        <D.27259>:
        if (__result == 0) goto <D.27261>; else goto <D.27262>;
        <D.27261>:
        D.27263 = &MEM[(void *)"MethodBuilder" + 3B];
        D.27264 = *D.27263;
        D.27265 = (int) D.27264;
        D.27266 = __s2 + 3;
        D.27267 = *D.27266;
        D.27268 = (int) D.27267;
        __result = D.27265 - D.27268;
        <D.27262>:
        <D.27260>:
        <D.27252>:
        <D.27250>:
        <D.27242>:
        <D.27240>:
      }
      D.20150 = __result;
    }
    iftmp.166 = -D.20150;
    goto <D.27269>;
    <D.27233>:
    D.27229 = klass->name;
    iftmp.166 = __builtin_strcmp (D.27229, "MethodBuilder");
    <D.27269>:
    D.20151 = iftmp.166;
  }
  if (D.20151 == 0) goto <D.27270>; else goto <D.27271>;
  <D.27270>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.27274 = tb->module;
    D.27275 = D.27274->dynamic_image;
    if (D.27275 == assembly) goto <D.27276>; else goto <D.27272>;
    <D.27276>:
    D.27277 = tb->generic_params;
    if (D.27277 == 0B) goto <D.27278>; else goto <D.27272>;
    <D.27278>:
    D.27279 = mb->generic_params;
    if (D.27279 == 0B) goto <D.27280>; else goto <D.27272>;
    <D.27280>:
    D.27281 = mb->table_idx;
    token = D.27281 | 100663296;
    goto <D.27273>;
    <D.27272>:
    token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
    <D.27273>:
  }
  goto <D.27282>;
  <D.27271>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27286 = "ConstructorBuilder";
      D.27287 = MEM[(const unsigned char *)D.27286];
      D.27288 = (int) D.27287;
      D.27289 = *__s2;
      D.27290 = (int) D.27289;
      __result = D.27288 - D.27290;
      {
        if (__s2_len != 0) goto <D.27291>; else goto <D.27292>;
        <D.27291>:
        if (__result == 0) goto <D.27293>; else goto <D.27294>;
        <D.27293>:
        D.27295 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.27296 = *D.27295;
        D.27297 = (int) D.27296;
        D.27298 = __s2 + 1;
        D.27299 = *D.27298;
        D.27300 = (int) D.27299;
        __result = D.27297 - D.27300;
        if (__s2_len > 1) goto <D.27301>; else goto <D.27302>;
        <D.27301>:
        if (__result == 0) goto <D.27303>; else goto <D.27304>;
        <D.27303>:
        D.27305 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.27306 = *D.27305;
        D.27307 = (int) D.27306;
        D.27308 = __s2 + 2;
        D.27309 = *D.27308;
        D.27310 = (int) D.27309;
        __result = D.27307 - D.27310;
        if (__s2_len > 2) goto <D.27311>; else goto <D.27312>;
        <D.27311>:
        if (__result == 0) goto <D.27313>; else goto <D.27314>;
        <D.27313>:
        D.27315 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.27316 = *D.27315;
        D.27317 = (int) D.27316;
        D.27318 = __s2 + 3;
        D.27319 = *D.27318;
        D.27320 = (int) D.27319;
        __result = D.27317 - D.27320;
        <D.27314>:
        <D.27312>:
        <D.27304>:
        <D.27302>:
        <D.27294>:
        <D.27292>:
      }
      D.20161 = __result;
    }
    iftmp.167 = -D.20161;
    goto <D.27321>;
    <D.27285>:
    D.27229 = klass->name;
    iftmp.167 = __builtin_strcmp (D.27229, "ConstructorBuilder");
    <D.27321>:
    D.20162 = iftmp.167;
  }
  if (D.20162 == 0) goto <D.27322>; else goto <D.27323>;
  <D.27322>:
  {
    struct MonoReflectionCtorBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.27326 = tb->module;
    D.27327 = D.27326->dynamic_image;
    if (D.27327 == assembly) goto <D.27328>; else goto <D.27324>;
    <D.27328>:
    D.27329 = tb->generic_params;
    if (D.27329 == 0B) goto <D.27330>; else goto <D.27324>;
    <D.27330>:
    D.27331 = mb->table_idx;
    token = D.27331 | 100663296;
    goto <D.27325>;
    <D.27324>:
    token = mono_image_get_ctorbuilder_token (assembly, mb);
    <D.27325>:
  }
  goto <D.27332>;
  <D.27323>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27336 = "FieldBuilder";
      D.27337 = MEM[(const unsigned char *)D.27336];
      D.27338 = (int) D.27337;
      D.27339 = *__s2;
      D.27340 = (int) D.27339;
      __result = D.27338 - D.27340;
      {
        if (__s2_len != 0) goto <D.27341>; else goto <D.27342>;
        <D.27341>:
        if (__result == 0) goto <D.27343>; else goto <D.27344>;
        <D.27343>:
        D.27345 = &MEM[(void *)"FieldBuilder" + 1B];
        D.27346 = *D.27345;
        D.27347 = (int) D.27346;
        D.27348 = __s2 + 1;
        D.27349 = *D.27348;
        D.27350 = (int) D.27349;
        __result = D.27347 - D.27350;
        if (__s2_len > 1) goto <D.27351>; else goto <D.27352>;
        <D.27351>:
        if (__result == 0) goto <D.27353>; else goto <D.27354>;
        <D.27353>:
        D.27355 = &MEM[(void *)"FieldBuilder" + 2B];
        D.27356 = *D.27355;
        D.27357 = (int) D.27356;
        D.27358 = __s2 + 2;
        D.27359 = *D.27358;
        D.27360 = (int) D.27359;
        __result = D.27357 - D.27360;
        if (__s2_len > 2) goto <D.27361>; else goto <D.27362>;
        <D.27361>:
        if (__result == 0) goto <D.27363>; else goto <D.27364>;
        <D.27363>:
        D.27365 = &MEM[(void *)"FieldBuilder" + 3B];
        D.27366 = *D.27365;
        D.27367 = (int) D.27366;
        D.27368 = __s2 + 3;
        D.27369 = *D.27368;
        D.27370 = (int) D.27369;
        __result = D.27367 - D.27370;
        <D.27364>:
        <D.27362>:
        <D.27354>:
        <D.27352>:
        <D.27344>:
        <D.27342>:
      }
      D.20172 = __result;
    }
    iftmp.168 = -D.20172;
    goto <D.27371>;
    <D.27335>:
    D.27229 = klass->name;
    iftmp.168 = __builtin_strcmp (D.27229, "FieldBuilder");
    <D.27371>:
    D.20173 = iftmp.168;
  }
  if (D.20173 == 0) goto <D.27372>; else goto <D.27373>;
  <D.27372>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoReflectionTypeBuilder * tb;

    fb = obj;
    tb = fb->typeb;
    D.27374 = tb->generic_params;
    if (D.27374 != 0B) goto <D.27375>; else goto <D.27376>;
    <D.27375>:
    token = mono_image_get_generic_field_token (assembly, fb);
    goto <D.27377>;
    <D.27376>:
    D.27378 = tb->module;
    D.27379 = D.27378->dynamic_image;
    if (D.27379 == assembly) goto <D.27380>; else goto <D.27381>;
    <D.27380>:
    D.27382 = fb->table_idx;
    D.27383 = D.27382 | 67108864;
    token = (guint32) D.27383;
    goto <D.27384>;
    <D.27381>:
    D.27385 = fb->handle;
    token = mono_image_get_fieldref_token (assembly, fb, D.27385);
    <D.27384>:
    <D.27377>:
  }
  goto <D.27386>;
  <D.27373>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27390 = "TypeBuilder";
      D.27391 = MEM[(const unsigned char *)D.27390];
      D.27392 = (int) D.27391;
      D.27393 = *__s2;
      D.27394 = (int) D.27393;
      __result = D.27392 - D.27394;
      {
        if (__s2_len != 0) goto <D.27395>; else goto <D.27396>;
        <D.27395>:
        if (__result == 0) goto <D.27397>; else goto <D.27398>;
        <D.27397>:
        D.27399 = &MEM[(void *)"TypeBuilder" + 1B];
        D.27400 = *D.27399;
        D.27401 = (int) D.27400;
        D.27402 = __s2 + 1;
        D.27403 = *D.27402;
        D.27404 = (int) D.27403;
        __result = D.27401 - D.27404;
        if (__s2_len > 1) goto <D.27405>; else goto <D.27406>;
        <D.27405>:
        if (__result == 0) goto <D.27407>; else goto <D.27408>;
        <D.27407>:
        D.27409 = &MEM[(void *)"TypeBuilder" + 2B];
        D.27410 = *D.27409;
        D.27411 = (int) D.27410;
        D.27412 = __s2 + 2;
        D.27413 = *D.27412;
        D.27414 = (int) D.27413;
        __result = D.27411 - D.27414;
        if (__s2_len > 2) goto <D.27415>; else goto <D.27416>;
        <D.27415>:
        if (__result == 0) goto <D.27417>; else goto <D.27418>;
        <D.27417>:
        D.27419 = &MEM[(void *)"TypeBuilder" + 3B];
        D.27420 = *D.27419;
        D.27421 = (int) D.27420;
        D.27422 = __s2 + 3;
        D.27423 = *D.27422;
        D.27424 = (int) D.27423;
        __result = D.27421 - D.27424;
        <D.27418>:
        <D.27416>:
        <D.27408>:
        <D.27406>:
        <D.27398>:
        <D.27396>:
      }
      D.20183 = __result;
    }
    iftmp.169 = -D.20183;
    goto <D.27425>;
    <D.27389>:
    D.27229 = klass->name;
    iftmp.169 = __builtin_strcmp (D.27229, "TypeBuilder");
    <D.27425>:
    D.20184 = iftmp.169;
  }
  if (D.20184 == 0) goto <D.27426>; else goto <D.27427>;
  <D.27426>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    if (create_open_instance != 0) goto <D.27430>; else goto <D.27428>;
    <D.27430>:
    D.27431 = tb->generic_params;
    if (D.27431 != 0B) goto <D.27432>; else goto <D.27428>;
    <D.27432>:
    {
      struct MonoType * type;

      init_type_builder_generics (obj);
      type = mono_reflection_type_get_handle (obj);
      token = mono_image_typedef_or_ref_full (assembly, type, 1);
      token = mono_metadata_token_from_dor (token);
    }
    goto <D.27429>;
    <D.27428>:
    D.27433 = tb->module;
    D.27434 = D.27433->dynamic_image;
    if (D.27434 == assembly) goto <D.27435>; else goto <D.27436>;
    <D.27435>:
    D.27437 = tb->table_idx;
    token = D.27437 | 33554432;
    goto <D.27438>;
    <D.27436>:
    {
      struct MonoType * type;

      type = mono_reflection_type_get_handle (obj);
      D.27439 = mono_image_typedef_or_ref (assembly, type);
      token = mono_metadata_token_from_dor (D.27439);
    }
    <D.27438>:
    <D.27429>:
  }
  goto <D.27440>;
  <D.27427>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27444 = "MonoType";
      D.27445 = MEM[(const unsigned char *)D.27444];
      D.27446 = (int) D.27445;
      D.27447 = *__s2;
      D.27448 = (int) D.27447;
      __result = D.27446 - D.27448;
      {
        if (__s2_len != 0) goto <D.27449>; else goto <D.27450>;
        <D.27449>:
        if (__result == 0) goto <D.27451>; else goto <D.27452>;
        <D.27451>:
        D.27453 = &MEM[(void *)"MonoType" + 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;
        if (__s2_len > 1) goto <D.27459>; else goto <D.27460>;
        <D.27459>:
        if (__result == 0) goto <D.27461>; else goto <D.27462>;
        <D.27461>:
        D.27463 = &MEM[(void *)"MonoType" + 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;
        if (__s2_len > 2) goto <D.27469>; else goto <D.27470>;
        <D.27469>:
        if (__result == 0) goto <D.27471>; else goto <D.27472>;
        <D.27471>:
        D.27473 = &MEM[(void *)"MonoType" + 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.27470>:
        <D.27462>:
        <D.27460>:
        <D.27452>:
        <D.27450>:
      }
      D.20195 = __result;
    }
    iftmp.170 = -D.20195;
    goto <D.27479>;
    <D.27443>:
    D.27229 = klass->name;
    iftmp.170 = __builtin_strcmp (D.27229, "MonoType");
    <D.27479>:
    D.20196 = iftmp.170;
  }
  if (D.20196 == 0) goto <D.27480>; else goto <D.27481>;
  <D.27480>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.27486 = mc->generic_container;
    if (D.27486 == 0B) goto <D.27483>; else goto <D.27487>;
    <D.27487>:
    if (create_open_instance != 0) goto <D.27483>; else goto <D.27484>;
    <D.27483>:
    iftmp.171 = 1;
    goto <D.27485>;
    <D.27484>:
    iftmp.171 = 0;
    <D.27485>:
    D.27488 = mono_image_typedef_or_ref_full (assembly, type, iftmp.171);
    token = mono_metadata_token_from_dor (D.27488);
  }
  goto <D.27489>;
  <D.27481>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27493 = "GenericTypeParameterBuilder";
      D.27494 = MEM[(const unsigned char *)D.27493];
      D.27495 = (int) D.27494;
      D.27496 = *__s2;
      D.27497 = (int) D.27496;
      __result = D.27495 - D.27497;
      {
        if (__s2_len != 0) goto <D.27498>; else goto <D.27499>;
        <D.27498>:
        if (__result == 0) goto <D.27500>; else goto <D.27501>;
        <D.27500>:
        D.27502 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.27503 = *D.27502;
        D.27504 = (int) D.27503;
        D.27505 = __s2 + 1;
        D.27506 = *D.27505;
        D.27507 = (int) D.27506;
        __result = D.27504 - D.27507;
        if (__s2_len > 1) goto <D.27508>; else goto <D.27509>;
        <D.27508>:
        if (__result == 0) goto <D.27510>; else goto <D.27511>;
        <D.27510>:
        D.27512 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.27513 = *D.27512;
        D.27514 = (int) D.27513;
        D.27515 = __s2 + 2;
        D.27516 = *D.27515;
        D.27517 = (int) D.27516;
        __result = D.27514 - D.27517;
        if (__s2_len > 2) goto <D.27518>; else goto <D.27519>;
        <D.27518>:
        if (__result == 0) goto <D.27520>; else goto <D.27521>;
        <D.27520>:
        D.27522 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.27523 = *D.27522;
        D.27524 = (int) D.27523;
        D.27525 = __s2 + 3;
        D.27526 = *D.27525;
        D.27527 = (int) D.27526;
        __result = D.27524 - D.27527;
        <D.27521>:
        <D.27519>:
        <D.27511>:
        <D.27509>:
        <D.27501>:
        <D.27499>:
      }
      D.20206 = __result;
    }
    iftmp.172 = -D.20206;
    goto <D.27528>;
    <D.27492>:
    D.27229 = klass->name;
    iftmp.172 = __builtin_strcmp (D.27229, "GenericTypeParameterBuilder");
    <D.27528>:
    D.20207 = iftmp.172;
  }
  if (D.20207 == 0) goto <D.27529>; else goto <D.27530>;
  <D.27529>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.27531 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.27531);
  }
  goto <D.27532>;
  <D.27530>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27536 = "MonoGenericClass";
      D.27537 = MEM[(const unsigned char *)D.27536];
      D.27538 = (int) D.27537;
      D.27539 = *__s2;
      D.27540 = (int) D.27539;
      __result = D.27538 - D.27540;
      {
        if (__s2_len != 0) goto <D.27541>; else goto <D.27542>;
        <D.27541>:
        if (__result == 0) goto <D.27543>; else goto <D.27544>;
        <D.27543>:
        D.27545 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.27546 = *D.27545;
        D.27547 = (int) D.27546;
        D.27548 = __s2 + 1;
        D.27549 = *D.27548;
        D.27550 = (int) D.27549;
        __result = D.27547 - D.27550;
        if (__s2_len > 1) goto <D.27551>; else goto <D.27552>;
        <D.27551>:
        if (__result == 0) goto <D.27553>; else goto <D.27554>;
        <D.27553>:
        D.27555 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.27556 = *D.27555;
        D.27557 = (int) D.27556;
        D.27558 = __s2 + 2;
        D.27559 = *D.27558;
        D.27560 = (int) D.27559;
        __result = D.27557 - D.27560;
        if (__s2_len > 2) goto <D.27561>; else goto <D.27562>;
        <D.27561>:
        if (__result == 0) goto <D.27563>; else goto <D.27564>;
        <D.27563>:
        D.27565 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.27566 = *D.27565;
        D.27567 = (int) D.27566;
        D.27568 = __s2 + 3;
        D.27569 = *D.27568;
        D.27570 = (int) D.27569;
        __result = D.27567 - D.27570;
        <D.27564>:
        <D.27562>:
        <D.27554>:
        <D.27552>:
        <D.27544>:
        <D.27542>:
      }
      D.20216 = __result;
    }
    iftmp.173 = -D.20216;
    goto <D.27571>;
    <D.27535>:
    D.27229 = klass->name;
    iftmp.173 = __builtin_strcmp (D.27229, "MonoGenericClass");
    <D.27571>:
    D.20217 = iftmp.173;
  }
  if (D.20217 == 0) goto <D.27572>; else goto <D.27573>;
  <D.27572>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.27574 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.27574);
  }
  goto <D.27575>;
  <D.27573>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27582 = "MonoCMethod";
      D.27583 = MEM[(const unsigned char *)D.27582];
      D.27584 = (int) D.27583;
      D.27585 = *__s2;
      D.27586 = (int) D.27585;
      __result = D.27584 - D.27586;
      {
        if (__s2_len != 0) goto <D.27587>; else goto <D.27588>;
        <D.27587>:
        if (__result == 0) goto <D.27589>; else goto <D.27590>;
        <D.27589>:
        D.27591 = &MEM[(void *)"MonoCMethod" + 1B];
        D.27592 = *D.27591;
        D.27593 = (int) D.27592;
        D.27594 = __s2 + 1;
        D.27595 = *D.27594;
        D.27596 = (int) D.27595;
        __result = D.27593 - D.27596;
        if (__s2_len > 1) goto <D.27597>; else goto <D.27598>;
        <D.27597>:
        if (__result == 0) goto <D.27599>; else goto <D.27600>;
        <D.27599>:
        D.27601 = &MEM[(void *)"MonoCMethod" + 2B];
        D.27602 = *D.27601;
        D.27603 = (int) D.27602;
        D.27604 = __s2 + 2;
        D.27605 = *D.27604;
        D.27606 = (int) D.27605;
        __result = D.27603 - D.27606;
        if (__s2_len > 2) goto <D.27607>; else goto <D.27608>;
        <D.27607>:
        if (__result == 0) goto <D.27609>; else goto <D.27610>;
        <D.27609>:
        D.27611 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27612 = *D.27611;
        D.27613 = (int) D.27612;
        D.27614 = __s2 + 3;
        D.27615 = *D.27614;
        D.27616 = (int) D.27615;
        __result = D.27613 - D.27616;
        <D.27610>:
        <D.27608>:
        <D.27600>:
        <D.27598>:
        <D.27590>:
        <D.27588>:
      }
      D.20226 = __result;
    }
    iftmp.174 = -D.20226;
    goto <D.27617>;
    <D.27581>:
    D.27229 = klass->name;
    iftmp.174 = __builtin_strcmp (D.27229, "MonoCMethod");
    <D.27617>:
    D.20227 = iftmp.174;
  }
  if (D.20227 == 0) goto <D.27576>; else goto <D.27618>;
  <D.27618>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27622 = "MonoMethod";
      D.27623 = MEM[(const unsigned char *)D.27622];
      D.27624 = (int) D.27623;
      D.27625 = *__s2;
      D.27626 = (int) D.27625;
      __result = D.27624 - D.27626;
      {
        if (__s2_len != 0) goto <D.27627>; else goto <D.27628>;
        <D.27627>:
        if (__result == 0) goto <D.27629>; else goto <D.27630>;
        <D.27629>:
        D.27631 = &MEM[(void *)"MonoMethod" + 1B];
        D.27632 = *D.27631;
        D.27633 = (int) D.27632;
        D.27634 = __s2 + 1;
        D.27635 = *D.27634;
        D.27636 = (int) D.27635;
        __result = D.27633 - D.27636;
        if (__s2_len > 1) goto <D.27637>; else goto <D.27638>;
        <D.27637>:
        if (__result == 0) goto <D.27639>; else goto <D.27640>;
        <D.27639>:
        D.27641 = &MEM[(void *)"MonoMethod" + 2B];
        D.27642 = *D.27641;
        D.27643 = (int) D.27642;
        D.27644 = __s2 + 2;
        D.27645 = *D.27644;
        D.27646 = (int) D.27645;
        __result = D.27643 - D.27646;
        if (__s2_len > 2) goto <D.27647>; else goto <D.27648>;
        <D.27647>:
        if (__result == 0) goto <D.27649>; else goto <D.27650>;
        <D.27649>:
        D.27651 = &MEM[(void *)"MonoMethod" + 3B];
        D.27652 = *D.27651;
        D.27653 = (int) D.27652;
        D.27654 = __s2 + 3;
        D.27655 = *D.27654;
        D.27656 = (int) D.27655;
        __result = D.27653 - D.27656;
        <D.27650>:
        <D.27648>:
        <D.27640>:
        <D.27638>:
        <D.27630>:
        <D.27628>:
      }
      D.20235 = __result;
    }
    iftmp.175 = -D.20235;
    goto <D.27657>;
    <D.27621>:
    D.27229 = klass->name;
    iftmp.175 = __builtin_strcmp (D.27229, "MonoMethod");
    <D.27657>:
    D.20236 = iftmp.175;
  }
  if (D.20236 == 0) goto <D.27576>; else goto <D.27658>;
  <D.27658>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27662 = "MonoGenericMethod";
      D.27663 = MEM[(const unsigned char *)D.27662];
      D.27664 = (int) D.27663;
      D.27665 = *__s2;
      D.27666 = (int) D.27665;
      __result = D.27664 - D.27666;
      {
        if (__s2_len != 0) goto <D.27667>; else goto <D.27668>;
        <D.27667>:
        if (__result == 0) goto <D.27669>; else goto <D.27670>;
        <D.27669>:
        D.27671 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.27672 = *D.27671;
        D.27673 = (int) D.27672;
        D.27674 = __s2 + 1;
        D.27675 = *D.27674;
        D.27676 = (int) D.27675;
        __result = D.27673 - D.27676;
        if (__s2_len > 1) goto <D.27677>; else goto <D.27678>;
        <D.27677>:
        if (__result == 0) goto <D.27679>; else goto <D.27680>;
        <D.27679>:
        D.27681 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.27682 = *D.27681;
        D.27683 = (int) D.27682;
        D.27684 = __s2 + 2;
        D.27685 = *D.27684;
        D.27686 = (int) D.27685;
        __result = D.27683 - D.27686;
        if (__s2_len > 2) goto <D.27687>; else goto <D.27688>;
        <D.27687>:
        if (__result == 0) goto <D.27689>; else goto <D.27690>;
        <D.27689>:
        D.27691 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.27692 = *D.27691;
        D.27693 = (int) D.27692;
        D.27694 = __s2 + 3;
        D.27695 = *D.27694;
        D.27696 = (int) D.27695;
        __result = D.27693 - D.27696;
        <D.27690>:
        <D.27688>:
        <D.27680>:
        <D.27678>:
        <D.27670>:
        <D.27668>:
      }
      D.20244 = __result;
    }
    iftmp.176 = -D.20244;
    goto <D.27697>;
    <D.27661>:
    D.27229 = klass->name;
    iftmp.176 = __builtin_strcmp (D.27229, "MonoGenericMethod");
    <D.27697>:
    D.20245 = iftmp.176;
  }
  if (D.20245 == 0) goto <D.27576>; else goto <D.27698>;
  <D.27698>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27702 = "MonoGenericCMethod";
      D.27703 = MEM[(const unsigned char *)D.27702];
      D.27704 = (int) D.27703;
      D.27705 = *__s2;
      D.27706 = (int) D.27705;
      __result = D.27704 - D.27706;
      {
        if (__s2_len != 0) goto <D.27707>; else goto <D.27708>;
        <D.27707>:
        if (__result == 0) goto <D.27709>; else goto <D.27710>;
        <D.27709>:
        D.27711 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.27712 = *D.27711;
        D.27713 = (int) D.27712;
        D.27714 = __s2 + 1;
        D.27715 = *D.27714;
        D.27716 = (int) D.27715;
        __result = D.27713 - D.27716;
        if (__s2_len > 1) goto <D.27717>; else goto <D.27718>;
        <D.27717>:
        if (__result == 0) goto <D.27719>; else goto <D.27720>;
        <D.27719>:
        D.27721 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.27722 = *D.27721;
        D.27723 = (int) D.27722;
        D.27724 = __s2 + 2;
        D.27725 = *D.27724;
        D.27726 = (int) D.27725;
        __result = D.27723 - D.27726;
        if (__s2_len > 2) goto <D.27727>; else goto <D.27728>;
        <D.27727>:
        if (__result == 0) goto <D.27729>; else goto <D.27730>;
        <D.27729>:
        D.27731 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.27732 = *D.27731;
        D.27733 = (int) D.27732;
        D.27734 = __s2 + 3;
        D.27735 = *D.27734;
        D.27736 = (int) D.27735;
        __result = D.27733 - D.27736;
        <D.27730>:
        <D.27728>:
        <D.27720>:
        <D.27718>:
        <D.27710>:
        <D.27708>:
      }
      D.20253 = __result;
    }
    iftmp.177 = -D.20253;
    goto <D.27737>;
    <D.27701>:
    D.27229 = klass->name;
    iftmp.177 = __builtin_strcmp (D.27229, "MonoGenericCMethod");
    <D.27737>:
    D.20254 = iftmp.177;
  }
  if (D.20254 == 0) goto <D.27576>; else goto <D.27577>;
  <D.27576>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.27738 = m->method;
    D.27739 = BIT_FIELD_REF <*D.27738, 32, 160>;
    D.27740 = D.27739 & 4096;
    if (D.27740 != 0) goto <D.27741>; else goto <D.27742>;
    <D.27741>:
    if (create_open_instance != 0) goto <D.27743>; else goto <D.27744>;
    <D.27743>:
    D.27738 = m->method;
    token = mono_image_get_methodspec_token (assembly, D.27738);
    goto <D.27745>;
    <D.27744>:
    D.27738 = m->method;
    token = mono_image_get_inflated_method_token (assembly, D.27738);
    <D.27745>:
    goto <D.27746>;
    <D.27742>:
    D.27738 = m->method;
    D.27749 = D.27738->klass;
    D.27750 = D.27749->image;
    D.27751 = &assembly->image;
    if (D.27750 == D.27751) goto <D.27752>; else goto <D.27747>;
    <D.27752>:
    D.27738 = m->method;
    D.27749 = D.27738->klass;
    D.27753 = D.27749->generic_class;
    if (D.27753 == 0B) goto <D.27754>; else goto <D.27747>;
    <D.27754>:
    {
      static guint32 method_table_idx = 16777215;

      D.27738 = m->method;
      D.27749 = D.27738->klass;
      D.27755 = BIT_FIELD_REF <*D.27749, 32, 160>;
      D.27756 = D.27755 & 128;
      if (D.27756 != 0) goto <D.27757>; else goto <D.27758>;
      <D.27757>:
      D.27738 = m->method;
      token = D.27738->token;
      goto <D.27759>;
      <D.27758>:
      method_table_idx.178 = method_table_idx;
      method_table_idx.179 = method_table_idx.178 + 4294967295;
      method_table_idx = method_table_idx.179;
      method_table_idx.178 = method_table_idx;
      token = method_table_idx.178 | 100663296;
      <D.27759>:
    }
    goto <D.27748>;
    <D.27747>:
    D.27738 = m->method;
    token = mono_image_get_methodref_token (assembly, D.27738, create_open_instance);
    <D.27748>:
    <D.27746>:
  }
  goto <D.27578>;
  <D.27577>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27765 = "MonoField";
      D.27766 = MEM[(const unsigned char *)D.27765];
      D.27767 = (int) D.27766;
      D.27768 = *__s2;
      D.27769 = (int) D.27768;
      __result = D.27767 - D.27769;
      {
        if (__s2_len != 0) goto <D.27770>; else goto <D.27771>;
        <D.27770>:
        if (__result == 0) goto <D.27772>; else goto <D.27773>;
        <D.27772>:
        D.27774 = &MEM[(void *)"MonoField" + 1B];
        D.27775 = *D.27774;
        D.27776 = (int) D.27775;
        D.27777 = __s2 + 1;
        D.27778 = *D.27777;
        D.27779 = (int) D.27778;
        __result = D.27776 - D.27779;
        if (__s2_len > 1) goto <D.27780>; else goto <D.27781>;
        <D.27780>:
        if (__result == 0) goto <D.27782>; else goto <D.27783>;
        <D.27782>:
        D.27784 = &MEM[(void *)"MonoField" + 2B];
        D.27785 = *D.27784;
        D.27786 = (int) D.27785;
        D.27787 = __s2 + 2;
        D.27788 = *D.27787;
        D.27789 = (int) D.27788;
        __result = D.27786 - D.27789;
        if (__s2_len > 2) goto <D.27790>; else goto <D.27791>;
        <D.27790>:
        if (__result == 0) goto <D.27792>; else goto <D.27793>;
        <D.27792>:
        D.27794 = &MEM[(void *)"MonoField" + 3B];
        D.27795 = *D.27794;
        D.27796 = (int) D.27795;
        D.27797 = __s2 + 3;
        D.27798 = *D.27797;
        D.27799 = (int) D.27798;
        __result = D.27796 - D.27799;
        <D.27793>:
        <D.27791>:
        <D.27783>:
        <D.27781>:
        <D.27773>:
        <D.27771>:
      }
      D.20264 = __result;
    }
    iftmp.180 = -D.20264;
    goto <D.27800>;
    <D.27764>:
    D.27229 = klass->name;
    iftmp.180 = __builtin_strcmp (D.27229, "MonoField");
    <D.27800>:
    D.20265 = iftmp.180;
  }
  if (D.20265 == 0) goto <D.27801>; else goto <D.27802>;
  <D.27801>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.27805 = f->field;
    D.27806 = D.27805->parent;
    D.27807 = D.27806->image;
    D.27751 = &assembly->image;
    if (D.27807 == D.27751) goto <D.27808>; else goto <D.27803>;
    <D.27808>:
    D.27805 = f->field;
    D.27809 = is_field_on_inst (D.27805);
    if (D.27809 == 0) goto <D.27810>; else goto <D.27803>;
    <D.27810>:
    {
      static guint32 field_table_idx = 16777215;

      field_table_idx.181 = field_table_idx;
      field_table_idx.182 = field_table_idx.181 + 4294967295;
      field_table_idx = field_table_idx.182;
      field_table_idx.181 = field_table_idx;
      token = field_table_idx.181 | 67108864;
    }
    goto <D.27804>;
    <D.27803>:
    D.27805 = f->field;
    token = mono_image_get_fieldref_token (assembly, f, D.27805);
    <D.27804>:
  }
  goto <D.27813>;
  <D.27802>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27817 = "MonoArrayMethod";
      D.27818 = MEM[(const unsigned char *)D.27817];
      D.27819 = (int) D.27818;
      D.27820 = *__s2;
      D.27821 = (int) D.27820;
      __result = D.27819 - D.27821;
      {
        if (__s2_len != 0) goto <D.27822>; else goto <D.27823>;
        <D.27822>:
        if (__result == 0) goto <D.27824>; else goto <D.27825>;
        <D.27824>:
        D.27826 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.27827 = *D.27826;
        D.27828 = (int) D.27827;
        D.27829 = __s2 + 1;
        D.27830 = *D.27829;
        D.27831 = (int) D.27830;
        __result = D.27828 - D.27831;
        if (__s2_len > 1) goto <D.27832>; else goto <D.27833>;
        <D.27832>:
        if (__result == 0) goto <D.27834>; else goto <D.27835>;
        <D.27834>:
        D.27836 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.27837 = *D.27836;
        D.27838 = (int) D.27837;
        D.27839 = __s2 + 2;
        D.27840 = *D.27839;
        D.27841 = (int) D.27840;
        __result = D.27838 - D.27841;
        if (__s2_len > 2) goto <D.27842>; else goto <D.27843>;
        <D.27842>:
        if (__result == 0) goto <D.27844>; else goto <D.27845>;
        <D.27844>:
        D.27846 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.27847 = *D.27846;
        D.27848 = (int) D.27847;
        D.27849 = __s2 + 3;
        D.27850 = *D.27849;
        D.27851 = (int) D.27850;
        __result = D.27848 - D.27851;
        <D.27845>:
        <D.27843>:
        <D.27835>:
        <D.27833>:
        <D.27825>:
        <D.27823>:
      }
      D.20275 = __result;
    }
    iftmp.183 = -D.20275;
    goto <D.27852>;
    <D.27816>:
    D.27229 = klass->name;
    iftmp.183 = __builtin_strcmp (D.27229, "MonoArrayMethod");
    <D.27852>:
    D.20276 = iftmp.183;
  }
  if (D.20276 == 0) goto <D.27853>; else goto <D.27854>;
  <D.27853>:
  {
    struct MonoReflectionArrayMethod * m;

    m = obj;
    token = mono_image_get_array_token (assembly, m);
  }
  goto <D.27855>;
  <D.27854>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27859 = "SignatureHelper";
      D.27860 = MEM[(const unsigned char *)D.27859];
      D.27861 = (int) D.27860;
      D.27862 = *__s2;
      D.27863 = (int) D.27862;
      __result = D.27861 - D.27863;
      {
        if (__s2_len != 0) goto <D.27864>; else goto <D.27865>;
        <D.27864>:
        if (__result == 0) goto <D.27866>; else goto <D.27867>;
        <D.27866>:
        D.27868 = &MEM[(void *)"SignatureHelper" + 1B];
        D.27869 = *D.27868;
        D.27870 = (int) D.27869;
        D.27871 = __s2 + 1;
        D.27872 = *D.27871;
        D.27873 = (int) D.27872;
        __result = D.27870 - D.27873;
        if (__s2_len > 1) goto <D.27874>; else goto <D.27875>;
        <D.27874>:
        if (__result == 0) goto <D.27876>; else goto <D.27877>;
        <D.27876>:
        D.27878 = &MEM[(void *)"SignatureHelper" + 2B];
        D.27879 = *D.27878;
        D.27880 = (int) D.27879;
        D.27881 = __s2 + 2;
        D.27882 = *D.27881;
        D.27883 = (int) D.27882;
        __result = D.27880 - D.27883;
        if (__s2_len > 2) goto <D.27884>; else goto <D.27885>;
        <D.27884>:
        if (__result == 0) goto <D.27886>; else goto <D.27887>;
        <D.27886>:
        D.27888 = &MEM[(void *)"SignatureHelper" + 3B];
        D.27889 = *D.27888;
        D.27890 = (int) D.27889;
        D.27891 = __s2 + 3;
        D.27892 = *D.27891;
        D.27893 = (int) D.27892;
        __result = D.27890 - D.27893;
        <D.27887>:
        <D.27885>:
        <D.27877>:
        <D.27875>:
        <D.27867>:
        <D.27865>:
      }
      D.20285 = __result;
    }
    iftmp.184 = -D.20285;
    goto <D.27894>;
    <D.27858>:
    D.27229 = klass->name;
    iftmp.184 = __builtin_strcmp (D.27229, "SignatureHelper");
    <D.27894>:
    D.20286 = iftmp.184;
  }
  if (D.20286 == 0) goto <D.27895>; else goto <D.27896>;
  <D.27895>:
  {
    struct MonoReflectionSigHelper * s;

    s = obj;
    D.27897 = mono_image_get_sighelper_token (assembly, s);
    token = D.27897 | 285212672;
  }
  goto <D.27898>;
  <D.27896>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27902 = "EnumBuilder";
      D.27903 = MEM[(const unsigned char *)D.27902];
      D.27904 = (int) D.27903;
      D.27905 = *__s2;
      D.27906 = (int) D.27905;
      __result = D.27904 - D.27906;
      {
        if (__s2_len != 0) goto <D.27907>; else goto <D.27908>;
        <D.27907>:
        if (__result == 0) goto <D.27909>; else goto <D.27910>;
        <D.27909>:
        D.27911 = &MEM[(void *)"EnumBuilder" + 1B];
        D.27912 = *D.27911;
        D.27913 = (int) D.27912;
        D.27914 = __s2 + 1;
        D.27915 = *D.27914;
        D.27916 = (int) D.27915;
        __result = D.27913 - D.27916;
        if (__s2_len > 1) goto <D.27917>; else goto <D.27918>;
        <D.27917>:
        if (__result == 0) goto <D.27919>; else goto <D.27920>;
        <D.27919>:
        D.27921 = &MEM[(void *)"EnumBuilder" + 2B];
        D.27922 = *D.27921;
        D.27923 = (int) D.27922;
        D.27924 = __s2 + 2;
        D.27925 = *D.27924;
        D.27926 = (int) D.27925;
        __result = D.27923 - D.27926;
        if (__s2_len > 2) goto <D.27927>; else goto <D.27928>;
        <D.27927>:
        if (__result == 0) goto <D.27929>; else goto <D.27930>;
        <D.27929>:
        D.27931 = &MEM[(void *)"EnumBuilder" + 3B];
        D.27932 = *D.27931;
        D.27933 = (int) D.27932;
        D.27934 = __s2 + 3;
        D.27935 = *D.27934;
        D.27936 = (int) D.27935;
        __result = D.27933 - D.27936;
        <D.27930>:
        <D.27928>:
        <D.27920>:
        <D.27918>:
        <D.27910>:
        <D.27908>:
      }
      D.20295 = __result;
    }
    iftmp.185 = -D.20295;
    goto <D.27937>;
    <D.27901>:
    D.27229 = klass->name;
    iftmp.185 = __builtin_strcmp (D.27229, "EnumBuilder");
    <D.27937>:
    D.20296 = iftmp.185;
  }
  if (D.20296 == 0) goto <D.27938>; else goto <D.27939>;
  <D.27938>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.27940 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.27940);
  }
  goto <D.27941>;
  <D.27939>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27945 = "FieldOnTypeBuilderInst";
      D.27946 = MEM[(const unsigned char *)D.27945];
      D.27947 = (int) D.27946;
      D.27948 = *__s2;
      D.27949 = (int) D.27948;
      __result = D.27947 - D.27949;
      {
        if (__s2_len != 0) goto <D.27950>; else goto <D.27951>;
        <D.27950>:
        if (__result == 0) goto <D.27952>; else goto <D.27953>;
        <D.27952>:
        D.27954 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.27955 = *D.27954;
        D.27956 = (int) D.27955;
        D.27957 = __s2 + 1;
        D.27958 = *D.27957;
        D.27959 = (int) D.27958;
        __result = D.27956 - D.27959;
        if (__s2_len > 1) goto <D.27960>; else goto <D.27961>;
        <D.27960>:
        if (__result == 0) goto <D.27962>; else goto <D.27963>;
        <D.27962>:
        D.27964 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.27965 = *D.27964;
        D.27966 = (int) D.27965;
        D.27967 = __s2 + 2;
        D.27968 = *D.27967;
        D.27969 = (int) D.27968;
        __result = D.27966 - D.27969;
        if (__s2_len > 2) goto <D.27970>; else goto <D.27971>;
        <D.27970>:
        if (__result == 0) goto <D.27972>; else goto <D.27973>;
        <D.27972>:
        D.27974 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.27975 = *D.27974;
        D.27976 = (int) D.27975;
        D.27977 = __s2 + 3;
        D.27978 = *D.27977;
        D.27979 = (int) D.27978;
        __result = D.27976 - D.27979;
        <D.27973>:
        <D.27971>:
        <D.27963>:
        <D.27961>:
        <D.27953>:
        <D.27951>:
      }
      D.20305 = __result;
    }
    iftmp.186 = -D.20305;
    goto <D.27980>;
    <D.27944>:
    D.27229 = klass->name;
    iftmp.186 = __builtin_strcmp (D.27229, "FieldOnTypeBuilderInst");
    <D.27980>:
    D.20306 = iftmp.186;
  }
  if (D.20306 == 0) goto <D.27981>; else goto <D.27982>;
  <D.27981>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;

    f = obj;
    token = mono_image_get_field_on_inst_token (assembly, f);
  }
  goto <D.27983>;
  <D.27982>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27987 = "ConstructorOnTypeBuilderInst";
      D.27988 = MEM[(const unsigned char *)D.27987];
      D.27989 = (int) D.27988;
      D.27990 = *__s2;
      D.27991 = (int) D.27990;
      __result = D.27989 - D.27991;
      {
        if (__s2_len != 0) goto <D.27992>; else goto <D.27993>;
        <D.27992>:
        if (__result == 0) goto <D.27994>; else goto <D.27995>;
        <D.27994>:
        D.27996 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.27997 = *D.27996;
        D.27998 = (int) D.27997;
        D.27999 = __s2 + 1;
        D.28000 = *D.27999;
        D.28001 = (int) D.28000;
        __result = D.27998 - D.28001;
        if (__s2_len > 1) goto <D.28002>; else goto <D.28003>;
        <D.28002>:
        if (__result == 0) goto <D.28004>; else goto <D.28005>;
        <D.28004>:
        D.28006 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.28007 = *D.28006;
        D.28008 = (int) D.28007;
        D.28009 = __s2 + 2;
        D.28010 = *D.28009;
        D.28011 = (int) D.28010;
        __result = D.28008 - D.28011;
        if (__s2_len > 2) goto <D.28012>; else goto <D.28013>;
        <D.28012>:
        if (__result == 0) goto <D.28014>; else goto <D.28015>;
        <D.28014>:
        D.28016 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.28017 = *D.28016;
        D.28018 = (int) D.28017;
        D.28019 = __s2 + 3;
        D.28020 = *D.28019;
        D.28021 = (int) D.28020;
        __result = D.28018 - D.28021;
        <D.28015>:
        <D.28013>:
        <D.28005>:
        <D.28003>:
        <D.27995>:
        <D.27993>:
      }
      D.20315 = __result;
    }
    iftmp.187 = -D.20315;
    goto <D.28022>;
    <D.27986>:
    D.27229 = klass->name;
    iftmp.187 = __builtin_strcmp (D.27229, "ConstructorOnTypeBuilderInst");
    <D.28022>:
    D.20316 = iftmp.187;
  }
  if (D.20316 == 0) goto <D.28023>; else goto <D.28024>;
  <D.28023>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;

    c = obj;
    token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance);
  }
  goto <D.28025>;
  <D.28024>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28029 = "MethodOnTypeBuilderInst";
      D.28030 = MEM[(const unsigned char *)D.28029];
      D.28031 = (int) D.28030;
      D.28032 = *__s2;
      D.28033 = (int) D.28032;
      __result = D.28031 - D.28033;
      {
        if (__s2_len != 0) goto <D.28034>; else goto <D.28035>;
        <D.28034>:
        if (__result == 0) goto <D.28036>; else goto <D.28037>;
        <D.28036>:
        D.28038 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.28039 = *D.28038;
        D.28040 = (int) D.28039;
        D.28041 = __s2 + 1;
        D.28042 = *D.28041;
        D.28043 = (int) D.28042;
        __result = D.28040 - D.28043;
        if (__s2_len > 1) goto <D.28044>; else goto <D.28045>;
        <D.28044>:
        if (__result == 0) goto <D.28046>; else goto <D.28047>;
        <D.28046>:
        D.28048 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.28049 = *D.28048;
        D.28050 = (int) D.28049;
        D.28051 = __s2 + 2;
        D.28052 = *D.28051;
        D.28053 = (int) D.28052;
        __result = D.28050 - D.28053;
        if (__s2_len > 2) goto <D.28054>; else goto <D.28055>;
        <D.28054>:
        if (__result == 0) goto <D.28056>; else goto <D.28057>;
        <D.28056>:
        D.28058 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.28059 = *D.28058;
        D.28060 = (int) D.28059;
        D.28061 = __s2 + 3;
        D.28062 = *D.28061;
        D.28063 = (int) D.28062;
        __result = D.28060 - D.28063;
        <D.28057>:
        <D.28055>:
        <D.28047>:
        <D.28045>:
        <D.28037>:
        <D.28035>:
      }
      D.20325 = __result;
    }
    iftmp.188 = -D.20325;
    goto <D.28064>;
    <D.28028>:
    D.27229 = klass->name;
    iftmp.188 = __builtin_strcmp (D.27229, "MethodOnTypeBuilderInst");
    <D.28064>:
    D.20326 = iftmp.188;
  }
  if (D.20326 == 0) goto <D.28065>; else goto <D.28066>;
  <D.28065>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
  }
  goto <D.28067>;
  <D.28066>:
  D.28071 = is_sre_array (klass);
  if (D.28071 != 0) goto <D.28068>; else goto <D.28072>;
  <D.28072>:
  D.28073 = is_sre_byref (klass);
  if (D.28073 != 0) goto <D.28068>; else goto <D.28074>;
  <D.28074>:
  D.28075 = is_sre_pointer (klass);
  if (D.28075 != 0) goto <D.28068>; else goto <D.28069>;
  <D.28068>:
  {
    struct MonoReflectionType * type;

    type = obj;
    D.28076 = mono_reflection_type_get_handle (type);
    D.28077 = mono_image_typedef_or_ref (assembly, D.28076);
    token = mono_metadata_token_from_dor (D.28077);
  }
  goto <D.28070>;
  <D.28069>:
  D.27229 = klass->name;
  monoeg_g_log (0B, 4, "requested token for %s\n", D.27229);
  <D.20329>:
  goto <D.20329>;
  <D.28070>:
  <D.28067>:
  <D.28025>:
  <D.27983>:
  <D.27941>:
  <D.27898>:
  <D.27855>:
  <D.27813>:
  <D.27578>:
  <D.27575>:
  <D.27532>:
  <D.27489>:
  <D.27440>:
  <D.27386>:
  <D.27332>:
  <D.27282>:
  if (register_token != 0) goto <D.28078>; else goto <D.28079>;
  <D.28078>:
  mono_image_register_token (assembly, token, obj);
  <D.28079>:
  D.28080 = token;
  return D.28080;
}


mono_image_get_methodbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb, gboolean create_methodspec)
{
  struct MonoArray * D.28082;
  guint32 D.28087;
  struct MonoGHashTable * D.28088;
  void * D.28089;
  void * token.189;
  guint32 token;

  D.28082 = mb->generic_params;
  if (D.28082 != 0B) goto <D.28083>; else goto <D.28084>;
  <D.28083>:
  if (create_methodspec != 0) goto <D.28085>; else goto <D.28086>;
  <D.28085>:
  D.28087 = mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
  return D.28087;
  <D.28086>:
  <D.28084>:
  D.28088 = assembly->handleref_managed;
  D.28089 = mono_g_hash_table_lookup (D.28088, mb);
  token = (guint32) D.28089;
  if (token != 0) goto <D.28090>; else goto <D.28091>;
  <D.28090>:
  D.28087 = token;
  return D.28087;
  <D.28091>:
  token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.28088 = assembly->handleref_managed;
  token.189 = (void *) token;
  mono_g_hash_table_insert (D.28088, mb, token.189);
  D.28087 = token;
  return D.28087;
}


mono_image_get_methodspec_token_for_generic_method_definition (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoGHashTable * D.28094;
  void * D.28095;
  guint32 D.28098;
  unsigned int D.28099;
  unsigned int D.28100;
  unsigned int D.28101;
  int D.28102;
  unsigned int D.28105;
  unsigned int D.28106;
  guint32 * D.28107;
  unsigned int D.28108;
  unsigned int D.28109;
  guint32 * D.28110;
  unsigned int D.28111;
  unsigned int D.28112;
  void * token.190;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;

  mtoken = 0;
  D.28094 = assembly->methodspec;
  D.28095 = mono_g_hash_table_lookup (D.28094, mb);
  token = (guint32) D.28095;
  if (token != 0) goto <D.28096>; else goto <D.28097>;
  <D.28096>:
  D.28098 = token;
  return D.28098;
  <D.28097>:
  table = &assembly->tables[43];
  mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.28099 = mtoken >> 24;
  switch (D.28099) <default: <D.19071>, case 6: <D.19070>, case 10: <D.19068>>
  <D.19068>:
  D.28100 = mtoken & 16777215;
  D.28101 = D.28100 << 1;
  mtoken = D.28101 | 1;
  goto <D.19069>;
  <D.19070>:
  D.28100 = mtoken & 16777215;
  mtoken = D.28100 << 1;
  goto <D.19069>;
  <D.19071>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2637);
  <D.19069>:
  D.28102 = assembly->save;
  if (D.28102 != 0) goto <D.28103>; else goto <D.28104>;
  <D.28103>:
  D.28105 = table->rows;
  D.28106 = D.28105 + 1;
  alloc_table (table, D.28106);
  D.28107 = table->values;
  D.28108 = table->next_idx;
  D.28109 = D.28108 * 8;
  values = D.28107 + D.28109;
  *values = mtoken;
  D.28110 = values + 4;
  D.28111 = encode_generic_method_definition_sig (assembly, mb);
  *D.28110 = D.28111;
  <D.28104>:
  D.28108 = table->next_idx;
  token = D.28108 | 721420288;
  D.28108 = table->next_idx;
  D.28112 = D.28108 + 1;
  table->next_idx = D.28112;
  D.28094 = assembly->methodspec;
  token.190 = (void *) token;
  mono_g_hash_table_insert (D.28094, mb, token.190);
  D.28098 = token;
  return D.28098;
}


encode_generic_method_definition_sig (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.28115;
  int D.28116;
  guint32 D.28119;
  unsigned int i.191;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.28115 = mb->generic_params;
      nparams = mono_array_length (D.28115);
      D.28116 = assembly->save;
      if (D.28116 == 0) goto <D.28117>; else goto <D.28118>;
      <D.28117>:
      D.28119 = 0;
      return D.28119;
      <D.28118>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19058>;
      <D.19057>:
      sigbuffer_add_value (&buf, 30);
      i.191 = (unsigned int) i;
      sigbuffer_add_value (&buf, i.191);
      i = i + 1;
      <D.19058>:
      i.191 = (unsigned int) i;
      if (i.191 < nparams) goto <D.19057>; else goto <D.19059>;
      <D.19059>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28119 = idx;
      return D.28119;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodref_token_for_methodbuilder (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * method)
{
  struct GHashTable * D.28123;
  void * D.28124;
  guint32 D.28127;
  struct MonoString * D.28128;
  unsigned int D.28129;
  unsigned int D.28130;
  unsigned int D.28135;
  struct MonoArray * D.28136;
  struct MonoObject * D.28140;
  struct MonoType * D.28141;
  void * token.192;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = method->type;
      D.28123 = assembly->handleref;
      D.28124 = monoeg_g_hash_table_lookup (D.28123, method);
      token = (guint32) D.28124;
      if (token != 0) goto <D.28125>; else goto <D.28126>;
      <D.28125>:
      D.28127 = token;
      return D.28127;
      <D.28126>:
      D.28128 = method->name;
      name = mono_string_to_utf8 (D.28128);
      reflection_methodbuilder_from_method_builder (&rmb, method);
      D.28129 = rmb.call_conv;
      D.28130 = D.28129 & 4294967199;
      if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
      <D.28131>:
      D.28129 = rmb.call_conv;
      D.28130 = D.28129 & 4294967199;
      if (D.28130 != 5) goto <D.28133>; else goto <D.28134>;
      <D.28133>:
      D.28129 = rmb.call_conv;
      D.28135 = D.28129 & 96;
      rmb.call_conv = D.28135;
      <D.28134>:
      <D.28132>:
      sig = method_builder_encode_signature (assembly, &rmb);
      D.28136 = tb->generic_params;
      if (D.28136 != 0B) goto <D.28137>; else goto <D.28138>;
      <D.28137>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28139>;
      <D.28138>:
      D.28140 = rmb.type;
      D.28141 = mono_reflection_type_get_handle (D.28140);
      parent = mono_image_typedef_or_ref (assembly, D.28141);
      <D.28139>:
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.28123 = assembly->handleref;
      token.192 = (void *) token;
      monoeg_g_hash_table_insert_replace (D.28123, method, token.192, 0);
      D.28127 = token;
      return D.28127;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


create_generic_typespec (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct GHashTable * D.28145;
  void * D.28146;
  guint32 D.28149;
  struct MonoArray * D.28150;
  _Bool D.28151;
  long int D.28152;
  long int D.28153;
  struct MonoGenericContainer * D.28156;
  struct MonoGenericContainer * D.28159;
  _Bool D.28160;
  long int D.28161;
  long int D.28162;
  unsigned char D.28165;
  unsigned int D.28166;
  struct MonoType * D.28167;
  unsigned int D.28168;
  unsigned int D.28169;
  unsigned int count.193;
  unsigned int i.194;
  char * D.28172;
  struct MonoType * D.28173;
  int D.28174;
  unsigned int D.28177;
  unsigned int D.28178;
  guint32 * D.28179;
  unsigned int D.28180;
  unsigned int D.28181;
  unsigned int D.28182;
  void * token.195;
  unsigned int D.28184;
  struct MonoDynamicTable * table;
  struct MonoClass * klass;
  struct MonoType * type;
  guint32 * values;
  guint32 token;
  struct SigBuffer buf;
  int count;
  int i;

  try
    {
      type = mono_reflection_type_get_handle (tb);
      D.28145 = assembly->typespec;
      D.28146 = monoeg_g_hash_table_lookup (D.28145, type);
      token = (guint32) D.28146;
      if (token != 0) goto <D.28147>; else goto <D.28148>;
      <D.28147>:
      D.28149 = token;
      return D.28149;
      <D.28148>:
      sigbuffer_init (&buf, 32);
      D.28150 = tb->generic_params;
      D.28151 = D.28150 == 0B;
      D.28152 = (long int) D.28151;
      D.28153 = __builtin_expect (D.28152, 0);
      if (D.28153 != 0) goto <D.28154>; else goto <D.28155>;
      <D.28154>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3096, "tb->generic_params");
      <D.28155>:
      klass = mono_class_from_mono_type (type);
      D.28156 = tb->generic_container;
      if (D.28156 != 0B) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      mono_reflection_create_generic_class (tb);
      <D.28158>:
      sigbuffer_add_value (&buf, 21);
      D.28159 = klass->generic_container;
      D.28160 = D.28159 == 0B;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3103, "klass->generic_container");
      <D.28164>:
      D.28165 = klass->byval_arg.type;
      D.28166 = (unsigned int) D.28165;
      sigbuffer_add_value (&buf, D.28166);
      D.28167 = &klass->byval_arg;
      D.28168 = mono_image_typedef_or_ref_full (assembly, D.28167, 0);
      sigbuffer_add_value (&buf, D.28168);
      D.28150 = tb->generic_params;
      D.28169 = mono_array_length (D.28150);
      count = (int) D.28169;
      count.193 = (unsigned int) count;
      sigbuffer_add_value (&buf, count.193);
      i = 0;
      goto <D.19224>;
      <D.19223>:
      {
        struct MonoReflectionGenericParam * gparam;

        D.28150 = tb->generic_params;
        i.194 = (unsigned int) i;
        D.28172 = mono_array_addr_with_size (D.28150, 4, i.194);
        gparam = MEM[(struct MonoReflectionGenericParam * *)D.28172];
        D.28173 = mono_reflection_type_get_handle (gparam);
        encode_type (assembly, D.28173, &buf);
      }
      i = i + 1;
      <D.19224>:
      if (i < count) goto <D.19223>; else goto <D.19225>;
      <D.19225>:
      table = &assembly->tables[27];
      D.28174 = assembly->save;
      if (D.28174 != 0) goto <D.28175>; else goto <D.28176>;
      <D.28175>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.28177 = table->rows;
      D.28178 = D.28177 + 1;
      alloc_table (table, D.28178);
      D.28179 = table->values;
      D.28180 = table->next_idx;
      D.28181 = D.28180 * 4;
      values = D.28179 + D.28181;
      *values = token;
      <D.28176>:
      sigbuffer_free (&buf);
      D.28180 = table->next_idx;
      D.28182 = D.28180 << 2;
      token = D.28182 | 2;
      D.28145 = assembly->typespec;
      token.195 = (void *) token;
      monoeg_g_hash_table_insert_replace (D.28145, type, token.195, 0);
      D.28180 = table->next_idx;
      D.28184 = D.28180 + 1;
      table->next_idx = D.28184;
      D.28149 = token;
      return D.28149;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_memberef_row (struct MonoDynamicImage * assembly, guint32 parent, const char * name, guint32 sig)
{
  unsigned int D.28187;
  guint32 D.28188;
  int D.28189;
  unsigned int D.28192;
  unsigned int D.28193;
  guint32 * D.28194;
  unsigned int D.28195;
  unsigned int D.28196;
  unsigned int D.28197;
  unsigned int D.28198;
  guint32 * D.28199;
  struct MonoDynamicStream * D.28200;
  unsigned int D.28201;
  guint32 * D.28202;
  unsigned int D.28203;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 pclass;

  D.28187 = parent & 3;
  switch (D.28187) <default: <D.19013>, case 0: <D.19012>, case 1: <D.19009>, case 2: <D.19011>>
  <D.19009>:
  pclass = 1;
  goto <D.19010>;
  <D.19011>:
  pclass = 4;
  goto <D.19010>;
  <D.19012>:
  pclass = 0;
  goto <D.19010>;
  <D.19013>:
  monoeg_g_log (0B, 16, "unknown typeref or def token 0x%08x for %s", parent, name);
  D.28188 = 0;
  return D.28188;
  <D.19010>:
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28189 = assembly->save;
  if (D.28189 != 0) goto <D.28190>; else goto <D.28191>;
  <D.28190>:
  D.28192 = table->rows;
  D.28193 = D.28192 + 1;
  alloc_table (table, D.28193);
  D.28194 = table->values;
  D.28195 = table->next_idx;
  D.28196 = D.28195 * 12;
  values = D.28194 + D.28196;
  D.28197 = parent << 3;
  D.28198 = D.28197 | pclass;
  *values = D.28198;
  D.28199 = values + 4;
  D.28200 = &assembly->sheap;
  D.28201 = string_heap_insert (D.28200, name);
  *D.28199 = D.28201;
  D.28202 = values + 8;
  *D.28202 = sig;
  <D.28191>:
  D.28195 = table->next_idx;
  token = D.28195 | 167772160;
  D.28195 = table->next_idx;
  D.28203 = D.28195 + 1;
  table->next_idx = D.28203;
  D.28188 = token;
  return D.28188;
}


mono_image_get_ctorbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoGHashTable * D.28205;
  void * D.28206;
  guint32 D.28209;
  struct MonoArray * D.28210;
  struct MonoType * D.28214;
  struct MonoString * D.28215;
  void * token.196;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = mb->type;
      D.28205 = assembly->handleref_managed;
      D.28206 = mono_g_hash_table_lookup (D.28205, mb);
      token = (guint32) D.28206;
      if (token != 0) goto <D.28207>; else goto <D.28208>;
      <D.28207>:
      D.28209 = token;
      return D.28209;
      <D.28208>:
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.28210 = tb->generic_params;
      if (D.28210 != 0B) goto <D.28211>; else goto <D.28212>;
      <D.28211>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28213>;
      <D.28212>:
      D.28214 = mono_reflection_type_get_handle (tb);
      parent = mono_image_typedef_or_ref (assembly, D.28214);
      <D.28213>:
      D.28215 = rmb.name;
      name = mono_string_to_utf8 (D.28215);
      sig = method_builder_encode_signature (assembly, &rmb);
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.28205 = assembly->handleref_managed;
      token.196 = (void *) token;
      mono_g_hash_table_insert (D.28205, mb, token.196);
      D.28209 = token;
      return D.28209;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


mono_image_get_generic_field_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoGHashTable * D.28219;
  void * D.28220;
  guint32 D.28223;
  struct MonoReflectionType * D.28224;
  struct MonoType * D.28225;
  struct MonoString * D.28226;
  struct MonoObject * D.28227;
  struct MonoArray * D.28230;
  struct MonoArray * D.28232;
  unsigned int D.28233;
  _Bool D.28234;
  long int D.28235;
  long int D.28236;
  int D.28239;
  unsigned int D.28242;
  unsigned int D.28243;
  guint32 * D.28244;
  unsigned int D.28245;
  unsigned int D.28246;
  unsigned int D.28247;
  unsigned int D.28248;
  guint32 * D.28249;
  struct MonoDynamicStream * D.28250;
  unsigned int D.28251;
  guint32 * D.28252;
  unsigned int D.28253;
  void * token.197;
  struct MonoDynamicTable * table;
  struct MonoClass * klass;
  struct MonoType * custom;
  struct MonoType * type;
  guint32 * values;
  guint32 token;
  guint32 pclass;
  guint32 parent;
  guint32 sig;
  gchar * name;

  custom = 0B;
  D.28219 = assembly->handleref_managed;
  D.28220 = mono_g_hash_table_lookup (D.28219, fb);
  token = (guint32) D.28220;
  if (token != 0) goto <D.28221>; else goto <D.28222>;
  <D.28221>:
  D.28223 = token;
  return D.28223;
  <D.28222>:
  D.28224 = fb->typeb;
  D.28225 = mono_reflection_type_get_handle (D.28224);
  klass = mono_class_from_mono_type (D.28225);
  D.28226 = fb->name;
  name = mono_string_to_utf8 (D.28226);
  D.28227 = fb->type;
  init_type_builder_generics (D.28227);
  D.28227 = fb->type;
  type = mono_reflection_type_get_handle (D.28227);
  D.28230 = fb->modreq;
  if (D.28230 != 0B) goto <D.28228>; else goto <D.28231>;
  <D.28231>:
  D.28232 = fb->modopt;
  if (D.28232 != 0B) goto <D.28228>; else goto <D.28229>;
  <D.28228>:
  D.28230 = fb->modreq;
  D.28232 = fb->modopt;
  custom = add_custom_modifiers (assembly, type, D.28230, D.28232);
  type = custom;
  <D.28229>:
  sig = fieldref_encode_signature (assembly, 0B, type);
  monoeg_g_free (custom);
  D.28224 = fb->typeb;
  parent = create_generic_typespec (assembly, D.28224);
  D.28233 = parent & 3;
  D.28234 = D.28233 != 2;
  D.28235 = (long int) D.28234;
  D.28236 = __builtin_expect (D.28235, 0);
  if (D.28236 != 0) goto <D.28237>; else goto <D.28238>;
  <D.28237>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3220, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC");
  <D.28238>:
  pclass = 4;
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28239 = assembly->save;
  if (D.28239 != 0) goto <D.28240>; else goto <D.28241>;
  <D.28240>:
  D.28242 = table->rows;
  D.28243 = D.28242 + 1;
  alloc_table (table, D.28243);
  D.28244 = table->values;
  D.28245 = table->next_idx;
  D.28246 = D.28245 * 12;
  values = D.28244 + D.28246;
  D.28247 = parent << 3;
  D.28248 = D.28247 | pclass;
  *values = D.28248;
  D.28249 = values + 4;
  D.28250 = &assembly->sheap;
  D.28251 = string_heap_insert (D.28250, name);
  *D.28249 = D.28251;
  D.28252 = values + 8;
  *D.28252 = sig;
  <D.28241>:
  D.28245 = table->next_idx;
  token = D.28245 | 167772160;
  D.28245 = table->next_idx;
  D.28253 = D.28245 + 1;
  table->next_idx = D.28253;
  D.28219 = assembly->handleref_managed;
  token.197 = (void *) token;
  mono_g_hash_table_insert (D.28219, fb, token.197);
  monoeg_g_free (name);
  D.28223 = token;
  return D.28223;
}


add_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoType * type, struct MonoArray * modreq, struct MonoArray * modopt)
{
  unsigned int D.28258;
  unsigned int count.198;
  unsigned int D.28260;
  unsigned int D.28263;
  unsigned int D.28264;
  struct MonoType * D.28267;
  unsigned int count.199;
  unsigned int D.28269;
  unsigned int D.28270;
  unsigned int len.200;
  unsigned char D.28272;
  <unnamed-unsigned:6> D.28273;
  unsigned int i.201;
  char * D.28277;
  void * D.28278;
  unsigned int D.28279;
  <unnamed-unsigned:31> D.28280;
  unsigned int D.28281;
  char * D.28284;
  void * D.28285;
  unsigned int D.28286;
  <unnamed-unsigned:31> D.28287;
  unsigned int D.28288;
  int i;
  int count;
  int len;
  int pos;
  struct MonoType * t;

  count = 0;
  if (modreq != 0B) goto <D.28256>; else goto <D.28257>;
  <D.28256>:
  D.28258 = mono_array_length (modreq);
  count.198 = (unsigned int) count;
  D.28260 = D.28258 + count.198;
  count = (int) D.28260;
  <D.28257>:
  if (modopt != 0B) goto <D.28261>; else goto <D.28262>;
  <D.28261>:
  D.28263 = mono_array_length (modopt);
  count.198 = (unsigned int) count;
  D.28264 = D.28263 + count.198;
  count = (int) D.28264;
  <D.28262>:
  if (count == 0) goto <D.28265>; else goto <D.28266>;
  <D.28265>:
  D.28267 = mono_metadata_type_dup (0B, type);
  return D.28267;
  <D.28266>:
  count.199 = (unsigned int) count;
  D.28269 = count.199 + 2;
  D.28270 = D.28269 * 4;
  len = (int) D.28270;
  len.200 = (unsigned int) len;
  t = monoeg_malloc (len.200);
  memcpy (t, type, 8);
  D.28272 = (unsigned char) count;
  D.28273 = (<unnamed-unsigned:6>) D.28272;
  t->num_mods = D.28273;
  pos = 0;
  if (modreq != 0B) goto <D.28274>; else goto <D.28275>;
  <D.28274>:
  i = 0;
  goto <D.19239>;
  <D.19238>:
  {
    struct MonoType * mod;

    i.201 = (unsigned int) i;
    D.28277 = mono_array_addr_with_size (modreq, 4, i.201);
    D.28278 = MEM[(void * *)D.28277];
    mod = mono_reflection_type_get_handle (D.28278);
    t->modifiers[pos].required = 1;
    D.28279 = mono_image_typedef_or_ref (assembly, mod);
    D.28280 = (<unnamed-unsigned:31>) D.28279;
    t->modifiers[pos].token = D.28280;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19239>:
  i.201 = (unsigned int) i;
  D.28281 = mono_array_length (modreq);
  if (i.201 < D.28281) goto <D.19238>; else goto <D.19240>;
  <D.19240>:
  <D.28275>:
  if (modopt != 0B) goto <D.28282>; else goto <D.28283>;
  <D.28282>:
  i = 0;
  goto <D.19243>;
  <D.19242>:
  {
    struct MonoType * mod;

    i.201 = (unsigned int) i;
    D.28284 = mono_array_addr_with_size (modopt, 4, i.201);
    D.28285 = MEM[(void * *)D.28284];
    mod = mono_reflection_type_get_handle (D.28285);
    t->modifiers[pos].required = 0;
    D.28286 = mono_image_typedef_or_ref (assembly, mod);
    D.28287 = (<unnamed-unsigned:31>) D.28286;
    t->modifiers[pos].token = D.28287;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19243>:
  i.201 = (unsigned int) i;
  D.28288 = mono_array_length (modopt);
  if (i.201 < D.28288) goto <D.19242>; else goto <D.19244>;
  <D.19244>:
  <D.28283>:
  D.28267 = t;
  return D.28267;
}


fieldref_encode_signature (struct MonoDynamicImage * assembly, struct MonoImage * field_image, struct MonoType * type)
{
  int D.28290;
  guint32 D.28293;
  unsigned int D.28294;
  unsigned int D.28295;
  <unnamed-unsigned:31> D.28300;
  unsigned int D.28301;
  _Bool D.28302;
  long int D.28303;
  long int D.28304;
  struct MonoType * D.28307;
  <unnamed-unsigned:1> D.28309;
  <unnamed-unsigned:6> D.28313;
  unsigned int D.28314;
  struct SigBuffer buf;
  guint32 idx;
  guint32 i;
  guint32 token;

  try
    {
      D.28290 = assembly->save;
      if (D.28290 == 0) goto <D.28291>; else goto <D.28292>;
      <D.28291>:
      D.28293 = 0;
      return D.28293;
      <D.28292>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.28294 = BIT_FIELD_REF <*type, 32, 32>;
      D.28295 = D.28294 & 1056964608;
      if (D.28295 != 0) goto <D.28296>; else goto <D.28297>;
      <D.28296>:
      i = 0;
      goto <D.18791>;
      <D.18790>:
      if (field_image != 0B) goto <D.28298>; else goto <D.28299>;
      <D.28298>:
      {
        struct MonoClass * class;

        D.28300 = type->modifiers[i].token;
        D.28301 = (unsigned int) D.28300;
        class = mono_class_get (field_image, D.28301);
        D.28302 = class == 0B;
        D.28303 = (long int) D.28302;
        D.28304 = __builtin_expect (D.28303, 0);
        if (D.28304 != 0) goto <D.28305>; else goto <D.28306>;
        <D.28305>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1706, "class");
        <D.28306>:
        D.28307 = &class->byval_arg;
        token = mono_image_typedef_or_ref (assembly, D.28307);
      }
      goto <D.28308>;
      <D.28299>:
      D.28300 = type->modifiers[i].token;
      token = (guint32) D.28300;
      <D.28308>:
      D.28309 = type->modifiers[i].required;
      if (D.28309 != 0) goto <D.28310>; else goto <D.28311>;
      <D.28310>:
      sigbuffer_add_byte (&buf, 31);
      goto <D.28312>;
      <D.28311>:
      sigbuffer_add_byte (&buf, 32);
      <D.28312>:
      sigbuffer_add_value (&buf, token);
      i = i + 1;
      <D.18791>:
      D.28313 = type->num_mods;
      D.28314 = (unsigned int) D.28313;
      if (D.28314 > i) goto <D.18790>; else goto <D.18792>;
      <D.18792>:
      <D.28297>:
      encode_type (assembly, type, &buf);
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28293 = idx;
      return D.28293;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodspec_token (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  struct GHashTable * D.28317;
  void * D.28318;
  guint32 D.28321;
  unsigned int D.28322;
  unsigned int D.28323;
  _Bool D.28324;
  long int D.28325;
  long int D.28326;
  struct MonoMethod * D.28329;
  struct MonoMethodSignature * D.28330;
  short unsigned int D.28331;
  struct MonoMethodSignature * D.28335;
  struct MonoClass * D.28336;
  struct MonoType * D.28337;
  const char * D.28338;
  void * token.202;
  struct MonoMethodInflated * imethod;
  guint32 token;

  D.28317 = assembly->handleref;
  D.28318 = monoeg_g_hash_table_lookup (D.28317, method);
  token = (guint32) D.28318;
  if (token != 0) goto <D.28319>; else goto <D.28320>;
  <D.28319>:
  D.28321 = token;
  return D.28321;
  <D.28320>:
  D.28322 = BIT_FIELD_REF <*method, 32, 160>;
  D.28323 = D.28322 & 4096;
  D.28324 = D.28323 == 0;
  D.28325 = (long int) D.28324;
  D.28326 = __builtin_expect (D.28325, 0);
  if (D.28326 != 0) goto <D.28327>; else goto <D.28328>;
  <D.28327>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3044, "method->is_inflated");
  <D.28328>:
  imethod = method;
  D.28329 = imethod->declaring;
  D.28330 = mono_method_signature (D.28329);
  D.28331 = D.28330->generic_param_count;
  if (D.28331 != 0) goto <D.28332>; else goto <D.28333>;
  <D.28332>:
  token = method_encode_methodspec (assembly, method);
  goto <D.28334>;
  <D.28333>:
  {
    guint32 sig;

    D.28329 = imethod->declaring;
    D.28335 = mono_method_signature (D.28329);
    sig = method_encode_signature (assembly, D.28335);
    D.28336 = method->klass;
    D.28337 = &D.28336->byval_arg;
    D.28338 = method->name;
    token = mono_image_get_memberref_token (assembly, D.28337, D.28338, sig);
  }
  <D.28334>:
  D.28317 = assembly->handleref;
  token.202 = (void *) token;
  monoeg_g_hash_table_insert_replace (D.28317, method, token.202, 0);
  D.28321 = token;
  return D.28321;
}


method_encode_methodspec (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  unsigned int D.28341;
  unsigned int D.28342;
  _Bool D.28343;
  long int D.28344;
  long int D.28345;
  struct MonoMethodSignature * D.28348;
  struct MonoClass * D.28349;
  struct MonoType * D.28350;
  const char * D.28351;
  struct MonoMethodSignature * D.28352;
  short unsigned int D.28353;
  guint32 D.28356;
  unsigned int D.28357;
  unsigned int D.28358;
  unsigned int D.28359;
  struct MonoGenericContext * D.28360;
  int D.28361;
  unsigned int D.28364;
  unsigned int D.28365;
  guint32 * D.28366;
  unsigned int D.28367;
  unsigned int D.28368;
  guint32 * D.28369;
  unsigned int D.28370;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;
  guint32 sig;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * declaring;

  mtoken = 0;
  table = &assembly->tables[43];
  D.28341 = BIT_FIELD_REF <*method, 32, 160>;
  D.28342 = D.28341 & 4096;
  D.28343 = D.28342 == 0;
  D.28344 = (long int) D.28343;
  D.28345 = __builtin_expect (D.28344, 0);
  if (D.28345 != 0) goto <D.28346>; else goto <D.28347>;
  <D.28346>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2998, "method->is_inflated");
  <D.28347>:
  imethod = method;
  declaring = imethod->declaring;
  D.28348 = mono_method_signature (declaring);
  sig = method_encode_signature (assembly, D.28348);
  D.28349 = method->klass;
  D.28350 = &D.28349->byval_arg;
  D.28351 = declaring->name;
  mtoken = mono_image_get_memberref_token (assembly, D.28350, D.28351, sig);
  D.28352 = mono_method_signature (declaring);
  D.28353 = D.28352->generic_param_count;
  if (D.28353 == 0) goto <D.28354>; else goto <D.28355>;
  <D.28354>:
  D.28356 = mtoken;
  return D.28356;
  <D.28355>:
  D.28357 = mtoken >> 24;
  switch (D.28357) <default: <D.19195>, case 6: <D.19194>, case 10: <D.19192>>
  <D.19192>:
  D.28358 = mtoken & 16777215;
  D.28359 = D.28358 << 1;
  mtoken = D.28359 | 1;
  goto <D.19193>;
  <D.19194>:
  D.28358 = mtoken & 16777215;
  mtoken = D.28358 << 1;
  goto <D.19193>;
  <D.19195>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3016);
  <D.19193>:
  D.28360 = mono_method_get_context (method);
  sig = encode_generic_method_sig (assembly, D.28360);
  D.28361 = assembly->save;
  if (D.28361 != 0) goto <D.28362>; else goto <D.28363>;
  <D.28362>:
  D.28364 = table->rows;
  D.28365 = D.28364 + 1;
  alloc_table (table, D.28365);
  D.28366 = table->values;
  D.28367 = table->next_idx;
  D.28368 = D.28367 * 8;
  values = D.28366 + D.28368;
  *values = mtoken;
  D.28369 = values + 4;
  *D.28369 = sig;
  <D.28363>:
  D.28367 = table->next_idx;
  token = D.28367 | 721420288;
  D.28367 = table->next_idx;
  D.28370 = D.28367 + 1;
  table->next_idx = D.28370;
  D.28356 = token;
  return D.28356;
}


encode_generic_method_sig (struct MonoDynamicImage * assembly, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.28372;
  <unnamed-unsigned:22> D.28373;
  int D.28374;
  guint32 D.28377;
  struct MonoType * D.28378;
  unsigned int i.203;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.28372 = context->method_inst;
      D.28373 = D.28372->type_argc;
      nparams = (guint32) D.28373;
      D.28374 = assembly->save;
      if (D.28374 == 0) goto <D.28375>; else goto <D.28376>;
      <D.28375>:
      D.28377 = 0;
      return D.28377;
      <D.28376>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19179>;
      <D.19178>:
      D.28372 = context->method_inst;
      D.28378 = D.28372->type_argv[i];
      encode_type (assembly, D.28378, &buf);
      i = i + 1;
      <D.19179>:
      i.203 = (unsigned int) i;
      if (i.203 < nparams) goto <D.19178>; else goto <D.19180>;
      <D.19180>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28377 = idx;
      return D.28377;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_memberref_token (struct MonoDynamicImage * assembly, struct MonoType * type, const char * name, guint32 sig)
{
  guint32 D.28382;
  guint32 parent;

  parent = mono_image_typedef_or_ref (assembly, type);
  D.28382 = mono_image_add_memberef_row (assembly, parent, name, sig);
  return D.28382;
}


mono_image_get_inflated_method_token (struct MonoDynamicImage * assembly, struct MonoMethod * m)
{
  struct MonoMethod * D.28384;
  struct MonoMethodSignature * D.28385;
  struct MonoClass * D.28386;
  struct MonoType * D.28387;
  const char * D.28388;
  guint32 D.28389;
  struct MonoMethodInflated * imethod;
  guint32 sig;
  guint32 token;

  imethod = m;
  D.28384 = imethod->declaring;
  D.28385 = mono_method_signature (D.28384);
  sig = method_encode_signature (assembly, D.28385);
  D.28386 = m->klass;
  D.28387 = &D.28386->byval_arg;
  D.28388 = m->name;
  token = mono_image_get_memberref_token (assembly, D.28387, D.28388, sig);
  D.28389 = token;
  return D.28389;
}


mono_image_get_methodref_token (struct MonoDynamicImage * assembly, struct MonoMethod * method, gboolean create_typespec)
{
  int iftmp.204;
  unsigned int D.28395;
  unsigned int D.28396;
  struct MonoClass * D.28398;
  struct MonoImage * D.28399;
  struct MonoImage * D.28400;
  struct GHashTable * D.28404;
  unsigned int method.205;
  unsigned int D.28406;
  const void * D.28407;
  void * D.28408;
  guint32 D.28411;
  void * D.28412;
  unsigned int D.28417;
  _Bool D.28418;
  long int D.28419;
  long int D.28420;
  struct MonoMethodSignature * D.28425;
  unsigned int D.28426;
  unsigned int D.28427;
  struct MonoType * D.28432;
  const char * D.28433;
  unsigned int D.28434;
  void * token.206;
  unsigned int D.28438;
  _Bool D.28439;
  long int D.28440;
  long int D.28441;
  unsigned int D.28444;
  unsigned int D.28445;
  int D.28446;
  unsigned int D.28449;
  unsigned int D.28450;
  guint32 * D.28451;
  unsigned int D.28452;
  unsigned int D.28453;
  guint32 * D.28454;
  struct MonoGenericContainer * D.28455;
  struct MonoGenericContext * D.28456;
  unsigned int D.28457;
  unsigned int D.28458;
  void * D.28459;
  guint32 token;
  struct MonoMethodSignature * sig;

  if (create_typespec != 0) goto <D.28394>; else goto <D.28392>;
  <D.28394>:
  D.28395 = BIT_FIELD_REF <*method, 32, 160>;
  D.28396 = D.28395 & 2048;
  if (D.28396 != 0) goto <D.28397>; else goto <D.28392>;
  <D.28397>:
  D.28398 = method->klass;
  D.28399 = D.28398->image;
  D.28400 = &assembly->image;
  if (D.28399 != D.28400) goto <D.28401>; else goto <D.28392>;
  <D.28401>:
  iftmp.204 = 1;
  goto <D.28393>;
  <D.28392>:
  iftmp.204 = 0;
  <D.28393>:
  create_typespec = iftmp.204;
  if (create_typespec != 0) goto <D.28402>; else goto <D.28403>;
  <D.28402>:
  D.28404 = assembly->handleref;
  method.205 = (unsigned int) method;
  D.28406 = method.205 + 1;
  D.28407 = (const void *) D.28406;
  D.28408 = monoeg_g_hash_table_lookup (D.28404, D.28407);
  token = (guint32) D.28408;
  if (token != 0) goto <D.28409>; else goto <D.28410>;
  <D.28409>:
  D.28411 = token;
  return D.28411;
  <D.28410>:
  <D.28403>:
  D.28404 = assembly->handleref;
  D.28412 = monoeg_g_hash_table_lookup (D.28404, method);
  token = (guint32) D.28412;
  if (token != 0) goto <D.28413>; else goto <D.28414>;
  <D.28413>:
  if (create_typespec == 0) goto <D.28415>; else goto <D.28416>;
  <D.28415>:
  D.28411 = token;
  return D.28411;
  <D.28416>:
  <D.28414>:
  D.28395 = BIT_FIELD_REF <*method, 32, 160>;
  D.28417 = D.28395 & 4096;
  D.28418 = D.28417 != 0;
  D.28419 = (long int) D.28418;
  D.28420 = __builtin_expect (D.28419, 0);
  if (D.28420 != 0) goto <D.28421>; else goto <D.28422>;
  <D.28421>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2492, "!method->is_inflated");
  <D.28422>:
  if (token == 0) goto <D.28423>; else goto <D.28424>;
  <D.28423>:
  D.28425 = mono_method_signature (method);
  sig = mono_metadata_signature_dup (D.28425);
  D.28426 = BIT_FIELD_REF <*sig, 32, 64>;
  D.28427 = D.28426 & 4128768;
  if (D.28427 != 0) goto <D.28428>; else goto <D.28429>;
  <D.28428>:
  D.28426 = BIT_FIELD_REF <*sig, 32, 64>;
  D.28427 = D.28426 & 4128768;
  if (D.28427 != 327680) goto <D.28430>; else goto <D.28431>;
  <D.28430>:
  sig->call_convention = 0;
  <D.28431>:
  <D.28429>:
  D.28398 = method->klass;
  D.28432 = &D.28398->byval_arg;
  D.28433 = method->name;
  D.28434 = method_encode_signature (assembly, sig);
  token = mono_image_get_memberref_token (assembly, D.28432, D.28433, D.28434);
  monoeg_g_free (sig);
  D.28404 = assembly->handleref;
  token.206 = (void *) token;
  monoeg_g_hash_table_insert_replace (D.28404, method, token.206, 0);
  <D.28424>:
  if (create_typespec != 0) goto <D.28436>; else goto <D.28437>;
  <D.28436>:
  {
    struct MonoDynamicTable * table;

    table = &assembly->tables[43];
    D.28438 = token >> 24;
    D.28439 = D.28438 != 10;
    D.28440 = (long int) D.28439;
    D.28441 = __builtin_expect (D.28440, 0);
    if (D.28441 != 0) goto <D.28442>; else goto <D.28443>;
    <D.28442>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2508, "mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF");
    <D.28443>:
    D.28444 = token & 16777215;
    D.28445 = D.28444 << 1;
    token = D.28445 | 1;
    D.28446 = assembly->save;
    if (D.28446 != 0) goto <D.28447>; else goto <D.28448>;
    <D.28447>:
    {
      guint32 * values;

      D.28449 = table->rows;
      D.28450 = D.28449 + 1;
      alloc_table (table, D.28450);
      D.28451 = table->values;
      D.28452 = table->next_idx;
      D.28453 = D.28452 * 8;
      values = D.28451 + D.28453;
      *values = token;
      D.28454 = values + 4;
      D.28455 = mono_method_get_generic_container (method);
      D.28456 = &D.28455->context;
      D.28457 = encode_generic_method_sig (assembly, D.28456);
      *D.28454 = D.28457;
    }
    <D.28448>:
    D.28452 = table->next_idx;
    token = D.28452 | 721420288;
    D.28452 = table->next_idx;
    D.28458 = D.28452 + 1;
    table->next_idx = D.28458;
    D.28404 = assembly->handleref;
    method.205 = (unsigned int) method;
    D.28406 = method.205 + 1;
    D.28459 = (void *) D.28406;
    token.206 = (void *) token;
    monoeg_g_hash_table_insert_replace (D.28404, D.28459, token.206, 0);
    D.28411 = token;
    return D.28411;
  }
  <D.28437>:
  D.28411 = token;
  return D.28411;
}


mono_image_get_fieldref_token (struct MonoDynamicImage * assembly, struct MonoObject * f, struct MonoClassField * field)
{
  _Bool D.28461;
  long int D.28462;
  long int D.28463;
  struct MonoClass * D.28466;
  _Bool D.28467;
  long int D.28468;
  long int D.28469;
  struct MonoGHashTable * D.28472;
  void * D.28473;
  guint32 D.28476;
  struct MonoGenericClass * D.28479;
  struct MonoClass * D.28481;
  struct MonoClassField * D.28483;
  int field.207;
  struct MonoClassField * D.28486;
  int D.28487;
  int D.28488;
  unsigned int index.208;
  unsigned int D.28490;
  struct MonoClassField * D.28491;
  int D.28492;
  struct MonoType * D.28496;
  const char * D.28497;
  struct MonoImage * D.28498;
  unsigned int D.28499;
  void * token.209;
  struct MonoType * type;
  guint32 token;

  D.28461 = field == 0B;
  D.28462 = (long int) D.28461;
  D.28463 = __builtin_expect (D.28462, 0);
  if (D.28463 != 0) goto <D.28464>; else goto <D.28465>;
  <D.28464>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2745, "field");
  <D.28465>:
  D.28466 = field->parent;
  D.28467 = D.28466 == 0B;
  D.28468 = (long int) D.28467;
  D.28469 = __builtin_expect (D.28468, 0);
  if (D.28469 != 0) goto <D.28470>; else goto <D.28471>;
  <D.28470>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2746, "field->parent");
  <D.28471>:
  D.28472 = assembly->handleref_managed;
  D.28473 = mono_g_hash_table_lookup (D.28472, f);
  token = (guint32) D.28473;
  if (token != 0) goto <D.28474>; else goto <D.28475>;
  <D.28474>:
  D.28476 = token;
  return D.28476;
  <D.28475>:
  D.28466 = field->parent;
  D.28479 = D.28466->generic_class;
  if (D.28479 != 0B) goto <D.28480>; else goto <D.28477>;
  <D.28480>:
  D.28466 = field->parent;
  D.28479 = D.28466->generic_class;
  D.28481 = D.28479->container_class;
  if (D.28481 != 0B) goto <D.28482>; else goto <D.28477>;
  <D.28482>:
  D.28466 = field->parent;
  D.28479 = D.28466->generic_class;
  D.28481 = D.28479->container_class;
  D.28483 = D.28481->fields;
  if (D.28483 != 0B) goto <D.28484>; else goto <D.28477>;
  <D.28484>:
  {
    int index;

    field.207 = (int) field;
    D.28466 = field->parent;
    D.28486 = D.28466->fields;
    D.28487 = (int) D.28486;
    D.28488 = field.207 - D.28487;
    index = D.28488 /[ex] 16;
    D.28466 = field->parent;
    D.28479 = D.28466->generic_class;
    D.28481 = D.28479->container_class;
    D.28483 = D.28481->fields;
    index.208 = (unsigned int) index;
    D.28490 = index.208 * 16;
    D.28491 = D.28483 + D.28490;
    type = mono_field_get_type (D.28491);
  }
  goto <D.28478>;
  <D.28477>:
  D.28492 = is_field_on_inst (field);
  if (D.28492 != 0) goto <D.28493>; else goto <D.28494>;
  <D.28493>:
  type = get_field_on_inst_generic_type (field);
  goto <D.28495>;
  <D.28494>:
  type = mono_field_get_type (field);
  <D.28495>:
  <D.28478>:
  D.28466 = field->parent;
  D.28496 = &D.28466->byval_arg;
  D.28497 = mono_field_get_name (field);
  D.28466 = field->parent;
  D.28498 = D.28466->image;
  D.28499 = fieldref_encode_signature (assembly, D.28498, type);
  token = mono_image_get_memberref_token (assembly, D.28496, D.28497, D.28499);
  D.28472 = assembly->handleref_managed;
  token.209 = (void *) token;
  mono_g_hash_table_insert (D.28472, f, token.209);
  D.28476 = token;
  return D.28476;
}


get_field_on_inst_generic_type (struct MonoClassField * field)
{
  int D.28502;
  _Bool D.28503;
  long int D.28504;
  long int D.28505;
  struct MonoClass * D.28508;
  struct MonoClassField * D.28509;
  int field.210;
  int D.28513;
  int D.28514;
  int D.28515;
  int D.28516;
  struct MonoType * D.28519;
  struct MonoType * * D.28520;
  unsigned int field_index.211;
  unsigned int D.28522;
  struct MonoType * * D.28523;
  struct MonoGenericClass * D.28524;
  struct MonoClassField * D.28525;
  int D.28528;
  int D.28529;
  int D.28530;
  unsigned int D.28531;
  unsigned int D.28532;
  struct MonoClassField * D.28535;
  unsigned int D.28536;
  struct MonoClassField * D.28537;
  struct MonoClass * class;
  struct MonoClass * gtd;
  struct MonoDynamicGenericClass * dgclass;
  int field_index;

  D.28502 = is_field_on_inst (field);
  D.28503 = D.28502 == 0;
  D.28504 = (long int) D.28503;
  D.28505 = __builtin_expect (D.28504, 0);
  if (D.28505 != 0) goto <D.28506>; else goto <D.28507>;
  <D.28506>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2717, "is_field_on_inst (field)");
  <D.28507>:
  D.28508 = field->parent;
  dgclass = D.28508->generic_class;
  D.28509 = dgclass->fields;
  if (D.28509 <= field) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  field.210 = (int) field;
  D.28509 = dgclass->fields;
  D.28513 = (int) D.28509;
  D.28514 = field.210 - D.28513;
  D.28515 = D.28514 /[ex] 16;
  D.28516 = dgclass->count_fields;
  if (D.28515 < D.28516) goto <D.28517>; else goto <D.28518>;
  <D.28517>:
  field.210 = (int) field;
  D.28509 = dgclass->fields;
  D.28513 = (int) D.28509;
  D.28514 = field.210 - D.28513;
  field_index = D.28514 /[ex] 16;
  D.28520 = dgclass->field_generic_types;
  field_index.211 = (unsigned int) field_index;
  D.28522 = field_index.211 * 4;
  D.28523 = D.28520 + D.28522;
  D.28519 = *D.28523;
  return D.28519;
  <D.28518>:
  <D.28511>:
  class = field->parent;
  D.28524 = class->generic_class;
  gtd = D.28524->container_class;
  D.28525 = class->fields;
  if (D.28525 <= field) goto <D.28526>; else goto <D.28527>;
  <D.28526>:
  field.210 = (int) field;
  D.28525 = class->fields;
  D.28528 = (int) D.28525;
  D.28529 = field.210 - D.28528;
  D.28530 = D.28529 /[ex] 16;
  D.28531 = (unsigned int) D.28530;
  D.28532 = class->field.count;
  if (D.28531 < D.28532) goto <D.28533>; else goto <D.28534>;
  <D.28533>:
  field.210 = (int) field;
  D.28525 = class->fields;
  D.28528 = (int) D.28525;
  D.28529 = field.210 - D.28528;
  field_index = D.28529 /[ex] 16;
  D.28535 = gtd->fields;
  field_index.211 = (unsigned int) field_index;
  D.28536 = field_index.211 * 16;
  D.28537 = D.28535 + D.28536;
  D.28519 = D.28537->type;
  return D.28519;
  <D.28534>:
  <D.28527>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2734);
  D.28519 = 0B;
  return D.28519;
}


mono_image_get_array_token (struct MonoDynamicImage * assembly, struct MonoReflectionArrayMethod * m)
{
  struct MonoString * D.28539;
  struct MonoArray * D.28540;
  unsigned int D.28541;
  unsigned int D.28542;
  unsigned int D.28543;
  int D.28544;
  int D.28545;
  unsigned char D.28546;
  <unnamed-unsigned:6> D.28547;
  short unsigned int D.28548;
  struct MonoType * iftmp.212;
  struct MonoReflectionType * D.28550;
  struct MonoClass * D.28554;
  struct MonoReflectionType * D.28555;
  char * D.28556;
  void * D.28557;
  struct MonoType * D.28558;
  int D.19320;
  char * D.28559;
  struct MonoType * D.28562;
  int D.28563;
  struct MonoMethodSignature * D.28566;
  int D.28567;
  unsigned int D.28570;
  unsigned int D.28571;
  guint32 D.28572;
  unsigned int D.28573;
  unsigned int D.28574;
  struct GList * D.28575;
  struct GList * D.28576;
  guint32 nparams;
  guint32 i;
  struct GList * tmp;
  char * name;
  struct MonoMethodSignature * sig;
  struct ArrayMethod * am;
  struct MonoType * mtype;

  D.28539 = m->name;
  name = mono_string_to_utf8 (D.28539);
  D.28540 = m->parameters;
  nparams = mono_array_length (D.28540);
  D.28541 = nparams + 3;
  D.28542 = D.28541 * 4;
  sig = monoeg_malloc0 (D.28542);
  sig->hasthis = 1;
  sig->sentinelpos = -1;
  D.28543 = m->call_conv;
  D.28544 = (int) D.28543;
  D.28545 = reflection_cc_to_file (D.28544);
  D.28546 = (unsigned char) D.28545;
  D.28547 = (<unnamed-unsigned:6>) D.28546;
  sig->call_convention = D.28547;
  D.28548 = (short unsigned int) nparams;
  sig->param_count = D.28548;
  D.28550 = m->ret;
  if (D.28550 != 0B) goto <D.28551>; else goto <D.28552>;
  <D.28551>:
  D.28550 = m->ret;
  iftmp.212 = mono_reflection_type_get_handle (D.28550);
  goto <D.28553>;
  <D.28552>:
  D.28554 = mono_defaults.void_class;
  iftmp.212 = &D.28554->byval_arg;
  <D.28553>:
  sig->ret = iftmp.212;
  D.28555 = m->parent;
  mtype = mono_reflection_type_get_handle (D.28555);
  i = 0;
  goto <D.19310>;
  <D.19309>:
  D.28540 = m->parameters;
  D.28556 = mono_array_addr_with_size (D.28540, 4, i);
  D.28557 = MEM[(void * *)D.28556];
  D.28558 = mono_reflection_type_get_handle (D.28557);
  sig->params[i] = D.28558;
  i = i + 1;
  <D.19310>:
  if (i < nparams) goto <D.19309>; else goto <D.19311>;
  <D.19311>:
  tmp = assembly->array_methods;
  goto <D.19322>;
  <D.19321>:
  am = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.28559 = am->name;
    D.19320 = __builtin_strcmp (name, D.28559);
  }
  if (D.19320 == 0) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  D.28562 = am->parent;
  D.28563 = mono_metadata_type_equal (D.28562, mtype);
  if (D.28563 != 0) goto <D.28564>; else goto <D.28565>;
  <D.28564>:
  D.28566 = am->sig;
  D.28567 = mono_metadata_signature_equal (D.28566, sig);
  if (D.28567 != 0) goto <D.28568>; else goto <D.28569>;
  <D.28568>:
  monoeg_g_free (name);
  monoeg_g_free (sig);
  D.28570 = am->token;
  D.28571 = D.28570 & 16777215;
  m->table_idx = D.28571;
  D.28572 = am->token;
  return D.28572;
  <D.28569>:
  <D.28565>:
  <D.28561>:
  tmp = tmp->next;
  <D.19322>:
  if (tmp != 0B) goto <D.19321>; else goto <D.19323>;
  <D.19323>:
  am = monoeg_malloc0 (16);
  am->name = name;
  am->sig = sig;
  am->parent = mtype;
  D.28562 = am->parent;
  D.28573 = method_encode_signature (assembly, sig);
  D.28574 = mono_image_get_memberref_token (assembly, D.28562, name, D.28573);
  am->token = D.28574;
  D.28575 = assembly->array_methods;
  D.28576 = monoeg_g_list_prepend (D.28575, am);
  assembly->array_methods = D.28576;
  D.28570 = am->token;
  D.28571 = D.28570 & 16777215;
  m->table_idx = D.28571;
  D.28572 = am->token;
  return D.28572;
}


reflection_cc_to_file (int call_conv)
{
  int D.28578;
  int D.28579;

  D.28578 = call_conv & 3;
  switch (D.28578) <default: <D.19291>, case 0: <D.19288>, case 1: <D.19289>, case 2: <D.19290>>
  <D.19288>:
  <D.19289>:
  D.28579 = 0;
  return D.28579;
  <D.19290>:
  D.28579 = 5;
  return D.28579;
  <D.19291>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3331);
  D.28579 = 0;
  return D.28579;
}


mono_image_get_sighelper_token (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  unsigned int D.28581;
  unsigned int idx.213;
  unsigned int D.28583;
  unsigned int D.28584;
  unsigned int D.28585;
  guint32 * D.28586;
  unsigned int D.28587;
  unsigned int D.28588;
  guint32 D.28589;
  guint32 idx;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[17];
  D.28581 = table->next_idx;
  idx.213 = D.28581;
  D.28583 = idx.213 + 1;
  table->next_idx = D.28583;
  idx = idx.213;
  D.28584 = table->rows;
  D.28585 = D.28584 + 1;
  table->rows = D.28585;
  D.28584 = table->rows;
  alloc_table (table, D.28584);
  D.28586 = table->values;
  D.28587 = idx * 4;
  values = D.28586 + D.28587;
  D.28588 = mono_reflection_encode_sighelper (assembly, helper);
  *values = D.28588;
  D.28589 = idx;
  return D.28589;
}


mono_reflection_encode_sighelper (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  int D.28591;
  guint32 D.28594;
  unsigned int D.28595;
  _Bool D.28596;
  long int D.28597;
  long int D.28598;
  struct MonoArray * D.28601;
  unsigned int D.28605;
  unsigned int D.28606;
  unsigned int D.28607;
  unsigned int D.28610;
  unsigned int D.28613;
  unsigned int D.28616;
  unsigned int D.28618;
  unsigned char D.28621;
  int D.28622;
  struct MonoReflectionType * D.28623;
  struct MonoArray * D.28624;
  unsigned int D.28627;
  char * D.28630;
  struct MonoArray * D.28631;
  unsigned int D.28634;
  char * D.28637;
  char * D.28638;
  struct SigBuffer buf;
  guint32 nargs;
  guint32 size;
  guint32 i;
  guint32 idx;

  try
    {
      D.28591 = assembly->save;
      if (D.28591 == 0) goto <D.28592>; else goto <D.28593>;
      <D.28592>:
      D.28594 = 0;
      return D.28594;
      <D.28593>:
      D.28595 = helper->type;
      D.28596 = D.28595 != 2;
      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", "reflection.c", 3254, "helper->type == 2");
      <D.28600>:
      D.28601 = helper->arguments;
      if (D.28601 != 0B) goto <D.28602>; else goto <D.28603>;
      <D.28602>:
      D.28601 = helper->arguments;
      nargs = mono_array_length (D.28601);
      goto <D.28604>;
      <D.28603>:
      nargs = 0;
      <D.28604>:
      D.28605 = nargs + 1;
      size = D.28605 * 10;
      sigbuffer_init (&buf, 32);
      D.28606 = helper->call_conv;
      D.28607 = D.28606 & 3;
      if (D.28607 == 3) goto <D.28608>; else goto <D.28609>;
      <D.28608>:
      helper->call_conv = 1;
      <D.28609>:
      D.28606 = helper->call_conv;
      D.28610 = D.28606 & 64;
      if (D.28610 != 0) goto <D.28611>; else goto <D.28612>;
      <D.28611>:
      D.28606 = helper->call_conv;
      D.28613 = D.28606 & 32;
      helper->call_conv = D.28613;
      <D.28612>:
      D.28606 = helper->call_conv;
      if (D.28606 == 0) goto <D.28614>; else goto <D.28615>;
      <D.28614>:
      D.28616 = helper->unmanaged_call_conv;
      idx = D.28616 + 4294967295;
      goto <D.28617>;
      <D.28615>:
      D.28606 = helper->call_conv;
      idx = D.28606 & 96;
      D.28606 = helper->call_conv;
      D.28618 = D.28606 & 2;
      if (D.28618 != 0) goto <D.28619>; else goto <D.28620>;
      <D.28619>:
      idx = idx + 5;
      <D.28620>:
      <D.28617>:
      D.28621 = (unsigned char) idx;
      D.28622 = (int) D.28621;
      sigbuffer_add_byte (&buf, D.28622);
      sigbuffer_add_value (&buf, nargs);
      D.28623 = helper->return_type;
      encode_reflection_type (assembly, D.28623, &buf);
      i = 0;
      goto <D.19276>;
      <D.19275>:
      {
        struct MonoArray * modreqs;
        struct MonoArray * modopts;
        struct MonoReflectionType * pt;

        modreqs = 0B;
        modopts = 0B;
        D.28624 = helper->modreqs;
        if (D.28624 != 0B) goto <D.28625>; else goto <D.28626>;
        <D.28625>:
        D.28624 = helper->modreqs;
        D.28627 = mono_array_length (D.28624);
        if (D.28627 > i) goto <D.28628>; else goto <D.28629>;
        <D.28628>:
        D.28624 = helper->modreqs;
        D.28630 = mono_array_addr_with_size (D.28624, 4, i);
        modreqs = MEM[(struct MonoArray * *)D.28630];
        <D.28629>:
        <D.28626>:
        D.28631 = helper->modopts;
        if (D.28631 != 0B) goto <D.28632>; else goto <D.28633>;
        <D.28632>:
        D.28631 = helper->modopts;
        D.28634 = mono_array_length (D.28631);
        if (D.28634 > i) goto <D.28635>; else goto <D.28636>;
        <D.28635>:
        D.28631 = helper->modopts;
        D.28637 = mono_array_addr_with_size (D.28631, 4, i);
        modopts = MEM[(struct MonoArray * *)D.28637];
        <D.28636>:
        <D.28633>:
        encode_custom_modifiers (assembly, modreqs, modopts, &buf);
        D.28601 = helper->arguments;
        D.28638 = mono_array_addr_with_size (D.28601, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.28638];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19276>:
      if (i < nargs) goto <D.19275>; else goto <D.19277>;
      <D.19277>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28594 = idx;
      return D.28594;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_field_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldOnTypeBuilderInst * f)
{
  struct MonoGHashTable * D.28641;
  void * D.28642;
  guint32 D.28645;
  struct MonoObject * D.28646;
  struct MonoVTable * D.28647;
  struct MonoClass * D.28648;
  int D.28649;
  struct MonoReflectionGenericClass * D.28652;
  unsigned int D.28653;
  unsigned int D.28654;
  _Bool D.28655;
  long int D.28656;
  long int D.28657;
  struct MonoString * D.28660;
  struct MonoType * D.28661;
  unsigned int D.28662;
  int D.28664;
  struct MonoClass * D.28667;
  struct MonoImage * D.28668;
  struct MonoType * D.28669;
  const char * D.28670;
  void * token.214;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoDynamicGenericClass * dgclass;
  struct MonoType * type;
  char * name;

  D.28641 = assembly->handleref_managed;
  D.28642 = mono_g_hash_table_lookup (D.28641, f);
  token = (guint32) D.28642;
  if (token != 0) goto <D.28643>; else goto <D.28644>;
  <D.28643>:
  D.28645 = token;
  return D.28645;
  <D.28644>:
  D.28646 = f->fb;
  D.28647 = D.28646->vtable;
  D.28648 = D.28647->klass;
  D.28649 = is_sre_field_builder (D.28648);
  if (D.28649 != 0) goto <D.28650>; else goto <D.28651>;
  <D.28650>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = f->fb;
    D.28652 = f->inst;
    type = mono_reflection_type_get_handle (D.28652);
    klass = mono_class_from_mono_type (type);
    gclass = type->data.generic_class;
    D.28653 = BIT_FIELD_REF <*gclass, 32, 96>;
    D.28654 = D.28653 & 1;
    D.28655 = D.28654 == 0;
    D.28656 = (long int) D.28655;
    D.28657 = __builtin_expect (D.28656, 0);
    if (D.28657 != 0) goto <D.28658>; else goto <D.28659>;
    <D.28658>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2786, "gclass->is_dynamic");
    <D.28659>:
    dgclass = gclass;
    D.28660 = fb->name;
    name = mono_string_to_utf8 (D.28660);
    D.28661 = &klass->byval_arg;
    D.28662 = field_encode_signature (assembly, fb);
    token = mono_image_get_memberref_token (assembly, D.28661, name, D.28662);
    monoeg_g_free (name);
  }
  goto <D.28663>;
  <D.28651>:
  D.28646 = f->fb;
  D.28647 = D.28646->vtable;
  D.28648 = D.28647->klass;
  D.28664 = is_sr_mono_field (D.28648);
  if (D.28664 != 0) goto <D.28665>; else goto <D.28666>;
  <D.28665>:
  {
    guint32 sig;
    struct MonoClassField * field;

    D.28646 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.28646].field;
    D.28652 = f->inst;
    type = mono_reflection_type_get_handle (D.28652);
    klass = mono_class_from_mono_type (type);
    D.28667 = field->parent;
    D.28668 = D.28667->image;
    D.28669 = field->type;
    sig = fieldref_encode_signature (assembly, D.28668, D.28669);
    D.28661 = &klass->byval_arg;
    D.28670 = field->name;
    token = mono_image_get_memberref_token (assembly, D.28661, D.28670, sig);
  }
  goto <D.28671>;
  <D.28666>:
  {
    char * name;

    D.28646 = f->fb;
    D.28647 = D.28646->vtable;
    D.28648 = D.28647->klass;
    name = mono_type_get_full_name (D.28648);
    monoeg_g_log (0B, 4, "mono_image_get_field_on_inst_token: don\'t know how to handle %s", name);
    <D.19120>:
    goto <D.19120>;
  }
  <D.28671>:
  <D.28663>:
  D.28641 = assembly->handleref_managed;
  token.214 = (void *) token;
  mono_g_hash_table_insert (D.28641, f, token.214);
  D.28645 = token;
  return D.28645;
}


is_sre_field_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.215;
  gboolean D.28677;
  _Bool D.28678;
  int D.28679;
  int D.22262;
  int iftmp.216;
  int D.22258;
  const char[13] * D.28685;
  unsigned char D.28686;
  int D.28687;
  unsigned char D.28688;
  int D.28689;
  const unsigned char * D.28694;
  unsigned char D.28695;
  int D.28696;
  const unsigned char * D.28697;
  unsigned char D.28698;
  int D.28699;
  const unsigned char * D.28704;
  unsigned char D.28705;
  int D.28706;
  const unsigned char * D.28707;
  unsigned char D.28708;
  int D.28709;
  const unsigned char * D.28714;
  unsigned char D.28715;
  int D.28716;
  const unsigned char * D.28717;
  unsigned char D.28718;
  int D.28719;
  const char * D.28721;
  int D.22271;
  int iftmp.217;
  int D.22267;
  const char[23] * D.28727;
  unsigned char D.28728;
  int D.28729;
  unsigned char D.28730;
  int D.28731;
  const unsigned char * D.28736;
  unsigned char D.28737;
  int D.28738;
  const unsigned char * D.28739;
  unsigned char D.28740;
  int D.28741;
  const unsigned char * D.28746;
  unsigned char D.28747;
  int D.28748;
  const unsigned char * D.28749;
  unsigned char D.28750;
  int D.28751;
  const unsigned char * D.28756;
  unsigned char D.28757;
  int D.28758;
  const unsigned char * D.28759;
  unsigned char D.28760;
  int D.28761;
  const char * D.28763;

  {
    static struct MonoClass * cached_class;

    cached_class.215 = cached_class;
    if (cached_class.215 != 0B) goto <D.28675>; else goto <D.28676>;
    <D.28675>:
    cached_class.215 = cached_class;
    D.28678 = cached_class.215 == class;
    D.28677 = (gboolean) D.28678;
    return D.28677;
    <D.28676>:
    D.28679 = is_corlib_type (class);
    if (D.28679 != 0) goto <D.28680>; else goto <D.28681>;
    <D.28680>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.28685 = "FieldBuilder";
        D.28686 = MEM[(const unsigned char *)D.28685];
        D.28687 = (int) D.28686;
        D.28688 = *__s2;
        D.28689 = (int) D.28688;
        __result = D.28687 - D.28689;
        {
          if (__s1_len != 0) goto <D.28690>; else goto <D.28691>;
          <D.28690>:
          if (__result == 0) goto <D.28692>; else goto <D.28693>;
          <D.28692>:
          D.28694 = &MEM[(void *)"FieldBuilder" + 1B];
          D.28695 = *D.28694;
          D.28696 = (int) D.28695;
          D.28697 = __s2 + 1;
          D.28698 = *D.28697;
          D.28699 = (int) D.28698;
          __result = D.28696 - D.28699;
          if (__s1_len > 1) goto <D.28700>; else goto <D.28701>;
          <D.28700>:
          if (__result == 0) goto <D.28702>; else goto <D.28703>;
          <D.28702>:
          D.28704 = &MEM[(void *)"FieldBuilder" + 2B];
          D.28705 = *D.28704;
          D.28706 = (int) D.28705;
          D.28707 = __s2 + 2;
          D.28708 = *D.28707;
          D.28709 = (int) D.28708;
          __result = D.28706 - D.28709;
          if (__s1_len > 2) goto <D.28710>; else goto <D.28711>;
          <D.28710>:
          if (__result == 0) goto <D.28712>; else goto <D.28713>;
          <D.28712>:
          D.28714 = &MEM[(void *)"FieldBuilder" + 3B];
          D.28715 = *D.28714;
          D.28716 = (int) D.28715;
          D.28717 = __s2 + 3;
          D.28718 = *D.28717;
          D.28719 = (int) D.28718;
          __result = D.28716 - D.28719;
          <D.28713>:
          <D.28711>:
          <D.28703>:
          <D.28701>:
          <D.28693>:
          <D.28691>:
        }
        D.22258 = __result;
      }
      iftmp.216 = D.22258;
      goto <D.28720>;
      <D.28684>:
      D.28721 = class->name;
      iftmp.216 = __builtin_strcmp ("FieldBuilder", D.28721);
      <D.28720>:
      D.22262 = iftmp.216;
    }
    if (D.22262 == 0) goto <D.28722>; else goto <D.28723>;
    <D.28722>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.28725>; else goto <D.28726>;
      <D.28725>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.28727 = "System.Reflection.Emit";
        D.28728 = MEM[(const unsigned char *)D.28727];
        D.28729 = (int) D.28728;
        D.28730 = *__s2;
        D.28731 = (int) D.28730;
        __result = D.28729 - D.28731;
        {
          if (__s1_len != 0) goto <D.28732>; else goto <D.28733>;
          <D.28732>:
          if (__result == 0) goto <D.28734>; else goto <D.28735>;
          <D.28734>:
          D.28736 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.28737 = *D.28736;
          D.28738 = (int) D.28737;
          D.28739 = __s2 + 1;
          D.28740 = *D.28739;
          D.28741 = (int) D.28740;
          __result = D.28738 - D.28741;
          if (__s1_len > 1) goto <D.28742>; else goto <D.28743>;
          <D.28742>:
          if (__result == 0) goto <D.28744>; else goto <D.28745>;
          <D.28744>:
          D.28746 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.28747 = *D.28746;
          D.28748 = (int) D.28747;
          D.28749 = __s2 + 2;
          D.28750 = *D.28749;
          D.28751 = (int) D.28750;
          __result = D.28748 - D.28751;
          if (__s1_len > 2) goto <D.28752>; else goto <D.28753>;
          <D.28752>:
          if (__result == 0) goto <D.28754>; else goto <D.28755>;
          <D.28754>:
          D.28756 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.28757 = *D.28756;
          D.28758 = (int) D.28757;
          D.28759 = __s2 + 3;
          D.28760 = *D.28759;
          D.28761 = (int) D.28760;
          __result = D.28758 - D.28761;
          <D.28755>:
          <D.28753>:
          <D.28745>:
          <D.28743>:
          <D.28735>:
          <D.28733>:
        }
        D.22267 = __result;
      }
      iftmp.217 = D.22267;
      goto <D.28762>;
      <D.28726>:
      D.28763 = class->name_space;
      iftmp.217 = __builtin_strcmp ("System.Reflection.Emit", D.28763);
      <D.28762>:
      D.22271 = iftmp.217;
    }
    if (D.22271 == 0) goto <D.28764>; else goto <D.28765>;
    <D.28764>:
    cached_class = class;
    D.28677 = 1;
    return D.28677;
    <D.28765>:
    <D.28723>:
    <D.28681>:
    D.28677 = 0;
    return D.28677;
  }
}


is_sr_mono_field (struct MonoClass * class)
{
  struct MonoClass * cached_class.218;
  gboolean D.28770;
  _Bool D.28771;
  int D.28772;
  int D.22420;
  int iftmp.219;
  int D.22416;
  const char[10] * D.28778;
  unsigned char D.28779;
  int D.28780;
  unsigned char D.28781;
  int D.28782;
  const unsigned char * D.28787;
  unsigned char D.28788;
  int D.28789;
  const unsigned char * D.28790;
  unsigned char D.28791;
  int D.28792;
  const unsigned char * D.28797;
  unsigned char D.28798;
  int D.28799;
  const unsigned char * D.28800;
  unsigned char D.28801;
  int D.28802;
  const unsigned char * D.28807;
  unsigned char D.28808;
  int D.28809;
  const unsigned char * D.28810;
  unsigned char D.28811;
  int D.28812;
  const char * D.28814;
  int D.22429;
  int iftmp.220;
  int D.22425;
  const char[18] * D.28820;
  unsigned char D.28821;
  int D.28822;
  unsigned char D.28823;
  int D.28824;
  const unsigned char * D.28829;
  unsigned char D.28830;
  int D.28831;
  const unsigned char * D.28832;
  unsigned char D.28833;
  int D.28834;
  const unsigned char * D.28839;
  unsigned char D.28840;
  int D.28841;
  const unsigned char * D.28842;
  unsigned char D.28843;
  int D.28844;
  const unsigned char * D.28849;
  unsigned char D.28850;
  int D.28851;
  const unsigned char * D.28852;
  unsigned char D.28853;
  int D.28854;
  const char * D.28856;

  {
    static struct MonoClass * cached_class;

    cached_class.218 = cached_class;
    if (cached_class.218 != 0B) goto <D.28768>; else goto <D.28769>;
    <D.28768>:
    cached_class.218 = cached_class;
    D.28771 = cached_class.218 == class;
    D.28770 = (gboolean) D.28771;
    return D.28770;
    <D.28769>:
    D.28772 = is_corlib_type (class);
    if (D.28772 != 0) goto <D.28773>; else goto <D.28774>;
    <D.28773>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 9;
      if (__s1_len <= 3) goto <D.28776>; else goto <D.28777>;
      <D.28776>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.28778 = "MonoField";
        D.28779 = MEM[(const unsigned char *)D.28778];
        D.28780 = (int) D.28779;
        D.28781 = *__s2;
        D.28782 = (int) D.28781;
        __result = D.28780 - D.28782;
        {
          if (__s1_len != 0) goto <D.28783>; else goto <D.28784>;
          <D.28783>:
          if (__result == 0) goto <D.28785>; else goto <D.28786>;
          <D.28785>:
          D.28787 = &MEM[(void *)"MonoField" + 1B];
          D.28788 = *D.28787;
          D.28789 = (int) D.28788;
          D.28790 = __s2 + 1;
          D.28791 = *D.28790;
          D.28792 = (int) D.28791;
          __result = D.28789 - D.28792;
          if (__s1_len > 1) goto <D.28793>; else goto <D.28794>;
          <D.28793>:
          if (__result == 0) goto <D.28795>; else goto <D.28796>;
          <D.28795>:
          D.28797 = &MEM[(void *)"MonoField" + 2B];
          D.28798 = *D.28797;
          D.28799 = (int) D.28798;
          D.28800 = __s2 + 2;
          D.28801 = *D.28800;
          D.28802 = (int) D.28801;
          __result = D.28799 - D.28802;
          if (__s1_len > 2) goto <D.28803>; else goto <D.28804>;
          <D.28803>:
          if (__result == 0) goto <D.28805>; else goto <D.28806>;
          <D.28805>:
          D.28807 = &MEM[(void *)"MonoField" + 3B];
          D.28808 = *D.28807;
          D.28809 = (int) D.28808;
          D.28810 = __s2 + 3;
          D.28811 = *D.28810;
          D.28812 = (int) D.28811;
          __result = D.28809 - D.28812;
          <D.28806>:
          <D.28804>:
          <D.28796>:
          <D.28794>:
          <D.28786>:
          <D.28784>:
        }
        D.22416 = __result;
      }
      iftmp.219 = D.22416;
      goto <D.28813>;
      <D.28777>:
      D.28814 = class->name;
      iftmp.219 = __builtin_strcmp ("MonoField", D.28814);
      <D.28813>:
      D.22420 = iftmp.219;
    }
    if (D.22420 == 0) goto <D.28815>; else goto <D.28816>;
    <D.28815>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.28818>; else goto <D.28819>;
      <D.28818>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.28820 = "System.Reflection";
        D.28821 = MEM[(const unsigned char *)D.28820];
        D.28822 = (int) D.28821;
        D.28823 = *__s2;
        D.28824 = (int) D.28823;
        __result = D.28822 - D.28824;
        {
          if (__s1_len != 0) goto <D.28825>; else goto <D.28826>;
          <D.28825>:
          if (__result == 0) goto <D.28827>; else goto <D.28828>;
          <D.28827>:
          D.28829 = &MEM[(void *)"System.Reflection" + 1B];
          D.28830 = *D.28829;
          D.28831 = (int) D.28830;
          D.28832 = __s2 + 1;
          D.28833 = *D.28832;
          D.28834 = (int) D.28833;
          __result = D.28831 - D.28834;
          if (__s1_len > 1) goto <D.28835>; else goto <D.28836>;
          <D.28835>:
          if (__result == 0) goto <D.28837>; else goto <D.28838>;
          <D.28837>:
          D.28839 = &MEM[(void *)"System.Reflection" + 2B];
          D.28840 = *D.28839;
          D.28841 = (int) D.28840;
          D.28842 = __s2 + 2;
          D.28843 = *D.28842;
          D.28844 = (int) D.28843;
          __result = D.28841 - D.28844;
          if (__s1_len > 2) goto <D.28845>; else goto <D.28846>;
          <D.28845>:
          if (__result == 0) goto <D.28847>; else goto <D.28848>;
          <D.28847>:
          D.28849 = &MEM[(void *)"System.Reflection" + 3B];
          D.28850 = *D.28849;
          D.28851 = (int) D.28850;
          D.28852 = __s2 + 3;
          D.28853 = *D.28852;
          D.28854 = (int) D.28853;
          __result = D.28851 - D.28854;
          <D.28848>:
          <D.28846>:
          <D.28838>:
          <D.28836>:
          <D.28828>:
          <D.28826>:
        }
        D.22425 = __result;
      }
      iftmp.220 = D.22425;
      goto <D.28855>;
      <D.28819>:
      D.28856 = class->name_space;
      iftmp.220 = __builtin_strcmp ("System.Reflection", D.28856);
      <D.28855>:
      D.22429 = iftmp.220;
    }
    if (D.22429 == 0) goto <D.28857>; else goto <D.28858>;
    <D.28857>:
    cached_class = class;
    D.28770 = 1;
    return D.28770;
    <D.28858>:
    <D.28816>:
    <D.28774>:
    D.28770 = 0;
    return D.28770;
  }
}


mono_image_get_ctor_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorOnTypeBuilderInst * c, gboolean create_methodspec)
{
  struct MonoGHashTable * D.28860;
  void * D.28861;
  guint32 D.28864;
  struct MonoObject * D.28865;
  struct MonoVTable * D.28866;
  struct MonoClass * D.28867;
  int D.28868;
  struct MonoReflectionGenericClass * D.28871;
  unsigned int D.28872;
  unsigned int D.28873;
  _Bool D.28874;
  long int D.28875;
  long int D.28876;
  struct MonoString * D.28879;
  struct MonoType * D.28880;
  int D.28882;
  struct MonoMethodSignature * D.28885;
  const char * D.28886;
  void * token.221;
  guint32 sig;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoType * type;

  D.28860 = assembly->handleref_managed;
  D.28861 = mono_g_hash_table_lookup (D.28860, c);
  token = (guint32) D.28861;
  if (token != 0) goto <D.28862>; else goto <D.28863>;
  <D.28862>:
  D.28864 = token;
  return D.28864;
  <D.28863>:
  D.28865 = c->cb;
  D.28866 = D.28865->vtable;
  D.28867 = D.28866->klass;
  D.28868 = is_sre_ctor_builder (D.28867);
  if (D.28868 != 0) goto <D.28869>; else goto <D.28870>;
  <D.28869>:
  {
    struct MonoReflectionCtorBuilder * cb;
    struct MonoDynamicGenericClass * dgclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        cb = c->cb;
        D.28871 = c->inst;
        type = mono_reflection_type_get_handle (D.28871);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.28872 = BIT_FIELD_REF <*gclass, 32, 96>;
        D.28873 = D.28872 & 1;
        D.28874 = D.28873 == 0;
        D.28875 = (long int) D.28874;
        D.28876 = __builtin_expect (D.28875, 0);
        if (D.28876 != 0) goto <D.28877>; else goto <D.28878>;
        <D.28877>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2835, "gclass->is_dynamic");
        <D.28878>:
        dgclass = gclass;
        reflection_methodbuilder_from_ctor_builder (&rmb, cb);
        D.28879 = rmb.name;
        name = mono_string_to_utf8 (D.28879);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.28880 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.28880, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.28881>;
  <D.28870>:
  D.28865 = c->cb;
  D.28866 = D.28865->vtable;
  D.28867 = D.28866->klass;
  D.28882 = is_sr_mono_cmethod (D.28867);
  if (D.28882 != 0) goto <D.28883>; else goto <D.28884>;
  <D.28883>:
  {
    struct MonoMethod * mm;

    D.28865 = c->cb;
    mm = MEM[(struct MonoReflectionMethod *)D.28865].method;
    D.28871 = c->inst;
    type = mono_reflection_type_get_handle (D.28871);
    klass = mono_class_from_mono_type (type);
    D.28885 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.28885);
    D.28880 = &klass->byval_arg;
    D.28886 = mm->name;
    token = mono_image_get_memberref_token (assembly, D.28880, D.28886, sig);
  }
  goto <D.28887>;
  <D.28884>:
  {
    char * name;

    D.28865 = c->cb;
    D.28866 = D.28865->vtable;
    D.28867 = D.28866->klass;
    name = mono_type_get_full_name (D.28867);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19137>:
    goto <D.19137>;
  }
  <D.28887>:
  <D.28881>:
  D.28860 = assembly->handleref_managed;
  token.221 = (void *) token;
  mono_g_hash_table_insert (D.28860, c, token.221);
  D.28864 = token;
  return D.28864;
}


is_sre_ctor_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.222;
  gboolean D.28893;
  _Bool D.28894;
  int D.28895;
  int D.22240;
  int iftmp.223;
  int D.22236;
  const char[19] * D.28901;
  unsigned char D.28902;
  int D.28903;
  unsigned char D.28904;
  int D.28905;
  const unsigned char * D.28910;
  unsigned char D.28911;
  int D.28912;
  const unsigned char * D.28913;
  unsigned char D.28914;
  int D.28915;
  const unsigned char * D.28920;
  unsigned char D.28921;
  int D.28922;
  const unsigned char * D.28923;
  unsigned char D.28924;
  int D.28925;
  const unsigned char * D.28930;
  unsigned char D.28931;
  int D.28932;
  const unsigned char * D.28933;
  unsigned char D.28934;
  int D.28935;
  const char * D.28937;
  int D.22249;
  int iftmp.224;
  int D.22245;
  const char[23] * D.28943;
  unsigned char D.28944;
  int D.28945;
  unsigned char D.28946;
  int D.28947;
  const unsigned char * D.28952;
  unsigned char D.28953;
  int D.28954;
  const unsigned char * D.28955;
  unsigned char D.28956;
  int D.28957;
  const unsigned char * D.28962;
  unsigned char D.28963;
  int D.28964;
  const unsigned char * D.28965;
  unsigned char D.28966;
  int D.28967;
  const unsigned char * D.28972;
  unsigned char D.28973;
  int D.28974;
  const unsigned char * D.28975;
  unsigned char D.28976;
  int D.28977;
  const char * D.28979;

  {
    static struct MonoClass * cached_class;

    cached_class.222 = cached_class;
    if (cached_class.222 != 0B) goto <D.28891>; else goto <D.28892>;
    <D.28891>:
    cached_class.222 = cached_class;
    D.28894 = cached_class.222 == class;
    D.28893 = (gboolean) D.28894;
    return D.28893;
    <D.28892>:
    D.28895 = is_corlib_type (class);
    if (D.28895 != 0) goto <D.28896>; else goto <D.28897>;
    <D.28896>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 18;
      if (__s1_len <= 3) goto <D.28899>; else goto <D.28900>;
      <D.28899>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.28901 = "ConstructorBuilder";
        D.28902 = MEM[(const unsigned char *)D.28901];
        D.28903 = (int) D.28902;
        D.28904 = *__s2;
        D.28905 = (int) D.28904;
        __result = D.28903 - D.28905;
        {
          if (__s1_len != 0) goto <D.28906>; else goto <D.28907>;
          <D.28906>:
          if (__result == 0) goto <D.28908>; else goto <D.28909>;
          <D.28908>:
          D.28910 = &MEM[(void *)"ConstructorBuilder" + 1B];
          D.28911 = *D.28910;
          D.28912 = (int) D.28911;
          D.28913 = __s2 + 1;
          D.28914 = *D.28913;
          D.28915 = (int) D.28914;
          __result = D.28912 - D.28915;
          if (__s1_len > 1) goto <D.28916>; else goto <D.28917>;
          <D.28916>:
          if (__result == 0) goto <D.28918>; else goto <D.28919>;
          <D.28918>:
          D.28920 = &MEM[(void *)"ConstructorBuilder" + 2B];
          D.28921 = *D.28920;
          D.28922 = (int) D.28921;
          D.28923 = __s2 + 2;
          D.28924 = *D.28923;
          D.28925 = (int) D.28924;
          __result = D.28922 - D.28925;
          if (__s1_len > 2) goto <D.28926>; else goto <D.28927>;
          <D.28926>:
          if (__result == 0) goto <D.28928>; else goto <D.28929>;
          <D.28928>:
          D.28930 = &MEM[(void *)"ConstructorBuilder" + 3B];
          D.28931 = *D.28930;
          D.28932 = (int) D.28931;
          D.28933 = __s2 + 3;
          D.28934 = *D.28933;
          D.28935 = (int) D.28934;
          __result = D.28932 - D.28935;
          <D.28929>:
          <D.28927>:
          <D.28919>:
          <D.28917>:
          <D.28909>:
          <D.28907>:
        }
        D.22236 = __result;
      }
      iftmp.223 = D.22236;
      goto <D.28936>;
      <D.28900>:
      D.28937 = class->name;
      iftmp.223 = __builtin_strcmp ("ConstructorBuilder", D.28937);
      <D.28936>:
      D.22240 = iftmp.223;
    }
    if (D.22240 == 0) goto <D.28938>; else goto <D.28939>;
    <D.28938>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.28941>; else goto <D.28942>;
      <D.28941>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.28943 = "System.Reflection.Emit";
        D.28944 = MEM[(const unsigned char *)D.28943];
        D.28945 = (int) D.28944;
        D.28946 = *__s2;
        D.28947 = (int) D.28946;
        __result = D.28945 - D.28947;
        {
          if (__s1_len != 0) goto <D.28948>; else goto <D.28949>;
          <D.28948>:
          if (__result == 0) goto <D.28950>; else goto <D.28951>;
          <D.28950>:
          D.28952 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.28953 = *D.28952;
          D.28954 = (int) D.28953;
          D.28955 = __s2 + 1;
          D.28956 = *D.28955;
          D.28957 = (int) D.28956;
          __result = D.28954 - D.28957;
          if (__s1_len > 1) goto <D.28958>; else goto <D.28959>;
          <D.28958>:
          if (__result == 0) goto <D.28960>; else goto <D.28961>;
          <D.28960>:
          D.28962 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.28963 = *D.28962;
          D.28964 = (int) D.28963;
          D.28965 = __s2 + 2;
          D.28966 = *D.28965;
          D.28967 = (int) D.28966;
          __result = D.28964 - D.28967;
          if (__s1_len > 2) goto <D.28968>; else goto <D.28969>;
          <D.28968>:
          if (__result == 0) goto <D.28970>; else goto <D.28971>;
          <D.28970>:
          D.28972 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.28973 = *D.28972;
          D.28974 = (int) D.28973;
          D.28975 = __s2 + 3;
          D.28976 = *D.28975;
          D.28977 = (int) D.28976;
          __result = D.28974 - D.28977;
          <D.28971>:
          <D.28969>:
          <D.28961>:
          <D.28959>:
          <D.28951>:
          <D.28949>:
        }
        D.22245 = __result;
      }
      iftmp.224 = D.22245;
      goto <D.28978>;
      <D.28942>:
      D.28979 = class->name_space;
      iftmp.224 = __builtin_strcmp ("System.Reflection.Emit", D.28979);
      <D.28978>:
      D.22249 = iftmp.224;
    }
    if (D.22249 == 0) goto <D.28980>; else goto <D.28981>;
    <D.28980>:
    cached_class = class;
    D.28893 = 1;
    return D.28893;
    <D.28981>:
    <D.28939>:
    <D.28897>:
    D.28893 = 0;
    return D.28893;
  }
}


is_sr_mono_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.225;
  gboolean D.28986;
  _Bool D.28987;
  int D.28988;
  int D.22486;
  int iftmp.226;
  int D.22482;
  const char[12] * D.28994;
  unsigned char D.28995;
  int D.28996;
  unsigned char D.28997;
  int D.28998;
  const unsigned char * D.29003;
  unsigned char D.29004;
  int D.29005;
  const unsigned char * D.29006;
  unsigned char D.29007;
  int D.29008;
  const unsigned char * D.29013;
  unsigned char D.29014;
  int D.29015;
  const unsigned char * D.29016;
  unsigned char D.29017;
  int D.29018;
  const unsigned char * D.29023;
  unsigned char D.29024;
  int D.29025;
  const unsigned char * D.29026;
  unsigned char D.29027;
  int D.29028;
  const char * D.29030;
  int D.22495;
  int iftmp.227;
  int D.22491;
  const char[18] * D.29036;
  unsigned char D.29037;
  int D.29038;
  unsigned char D.29039;
  int D.29040;
  const unsigned char * D.29045;
  unsigned char D.29046;
  int D.29047;
  const unsigned char * D.29048;
  unsigned char D.29049;
  int D.29050;
  const unsigned char * D.29055;
  unsigned char D.29056;
  int D.29057;
  const unsigned char * D.29058;
  unsigned char D.29059;
  int D.29060;
  const unsigned char * D.29065;
  unsigned char D.29066;
  int D.29067;
  const unsigned char * D.29068;
  unsigned char D.29069;
  int D.29070;
  const char * D.29072;

  {
    static struct MonoClass * cached_class;

    cached_class.225 = cached_class;
    if (cached_class.225 != 0B) goto <D.28984>; else goto <D.28985>;
    <D.28984>:
    cached_class.225 = cached_class;
    D.28987 = cached_class.225 == class;
    D.28986 = (gboolean) D.28987;
    return D.28986;
    <D.28985>:
    D.28988 = is_corlib_type (class);
    if (D.28988 != 0) goto <D.28989>; else goto <D.28990>;
    <D.28989>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 11;
      if (__s1_len <= 3) goto <D.28992>; else goto <D.28993>;
      <D.28992>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.28994 = "MonoCMethod";
        D.28995 = MEM[(const unsigned char *)D.28994];
        D.28996 = (int) D.28995;
        D.28997 = *__s2;
        D.28998 = (int) D.28997;
        __result = D.28996 - D.28998;
        {
          if (__s1_len != 0) goto <D.28999>; else goto <D.29000>;
          <D.28999>:
          if (__result == 0) goto <D.29001>; else goto <D.29002>;
          <D.29001>:
          D.29003 = &MEM[(void *)"MonoCMethod" + 1B];
          D.29004 = *D.29003;
          D.29005 = (int) D.29004;
          D.29006 = __s2 + 1;
          D.29007 = *D.29006;
          D.29008 = (int) D.29007;
          __result = D.29005 - D.29008;
          if (__s1_len > 1) goto <D.29009>; else goto <D.29010>;
          <D.29009>:
          if (__result == 0) goto <D.29011>; else goto <D.29012>;
          <D.29011>:
          D.29013 = &MEM[(void *)"MonoCMethod" + 2B];
          D.29014 = *D.29013;
          D.29015 = (int) D.29014;
          D.29016 = __s2 + 2;
          D.29017 = *D.29016;
          D.29018 = (int) D.29017;
          __result = D.29015 - D.29018;
          if (__s1_len > 2) goto <D.29019>; else goto <D.29020>;
          <D.29019>:
          if (__result == 0) goto <D.29021>; else goto <D.29022>;
          <D.29021>:
          D.29023 = &MEM[(void *)"MonoCMethod" + 3B];
          D.29024 = *D.29023;
          D.29025 = (int) D.29024;
          D.29026 = __s2 + 3;
          D.29027 = *D.29026;
          D.29028 = (int) D.29027;
          __result = D.29025 - D.29028;
          <D.29022>:
          <D.29020>:
          <D.29012>:
          <D.29010>:
          <D.29002>:
          <D.29000>:
        }
        D.22482 = __result;
      }
      iftmp.226 = D.22482;
      goto <D.29029>;
      <D.28993>:
      D.29030 = class->name;
      iftmp.226 = __builtin_strcmp ("MonoCMethod", D.29030);
      <D.29029>:
      D.22486 = iftmp.226;
    }
    if (D.22486 == 0) goto <D.29031>; else goto <D.29032>;
    <D.29031>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.29034>; else goto <D.29035>;
      <D.29034>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.29036 = "System.Reflection";
        D.29037 = MEM[(const unsigned char *)D.29036];
        D.29038 = (int) D.29037;
        D.29039 = *__s2;
        D.29040 = (int) D.29039;
        __result = D.29038 - D.29040;
        {
          if (__s1_len != 0) goto <D.29041>; else goto <D.29042>;
          <D.29041>:
          if (__result == 0) goto <D.29043>; else goto <D.29044>;
          <D.29043>:
          D.29045 = &MEM[(void *)"System.Reflection" + 1B];
          D.29046 = *D.29045;
          D.29047 = (int) D.29046;
          D.29048 = __s2 + 1;
          D.29049 = *D.29048;
          D.29050 = (int) D.29049;
          __result = D.29047 - D.29050;
          if (__s1_len > 1) goto <D.29051>; else goto <D.29052>;
          <D.29051>:
          if (__result == 0) goto <D.29053>; else goto <D.29054>;
          <D.29053>:
          D.29055 = &MEM[(void *)"System.Reflection" + 2B];
          D.29056 = *D.29055;
          D.29057 = (int) D.29056;
          D.29058 = __s2 + 2;
          D.29059 = *D.29058;
          D.29060 = (int) D.29059;
          __result = D.29057 - D.29060;
          if (__s1_len > 2) goto <D.29061>; else goto <D.29062>;
          <D.29061>:
          if (__result == 0) goto <D.29063>; else goto <D.29064>;
          <D.29063>:
          D.29065 = &MEM[(void *)"System.Reflection" + 3B];
          D.29066 = *D.29065;
          D.29067 = (int) D.29066;
          D.29068 = __s2 + 3;
          D.29069 = *D.29068;
          D.29070 = (int) D.29069;
          __result = D.29067 - D.29070;
          <D.29064>:
          <D.29062>:
          <D.29054>:
          <D.29052>:
          <D.29044>:
          <D.29042>:
        }
        D.22491 = __result;
      }
      iftmp.227 = D.22491;
      goto <D.29071>;
      <D.29035>:
      D.29072 = class->name_space;
      iftmp.227 = __builtin_strcmp ("System.Reflection", D.29072);
      <D.29071>:
      D.22495 = iftmp.227;
    }
    if (D.22495 == 0) goto <D.29073>; else goto <D.29074>;
    <D.29073>:
    cached_class = class;
    D.28986 = 1;
    return D.28986;
    <D.29074>:
    <D.29032>:
    <D.28990>:
    D.28986 = 0;
    return D.28986;
  }
}


mono_image_get_method_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodOnTypeBuilderInst * m, gboolean create_methodspec)
{
  struct MonoArray * D.29076;
  guint32 D.29082;
  struct MonoGHashTable * D.29083;
  void * D.29084;
  struct MonoObject * D.29087;
  struct MonoVTable * D.29088;
  struct MonoClass * D.29089;
  int D.29090;
  struct MonoReflectionType * D.29093;
  unsigned int D.29094;
  unsigned int D.29095;
  _Bool D.29096;
  long int D.29097;
  long int D.29098;
  struct MonoString * D.29101;
  struct MonoType * D.29102;
  int D.29104;
  struct MonoMethodSignature * D.29107;
  const char * D.29108;
  void * token.228;
  guint32 sig;
  guint32 token;
  struct MonoType * type;
  struct MonoClass * klass;

  token = 0;
  D.29076 = m->method_args;
  if (D.29076 != 0B) goto <D.29077>; else goto <D.29078>;
  <D.29077>:
  {
    struct MonoMethod * inflated;

    inflated = mono_reflection_method_on_tb_inst_get_handle (m);
    if (create_methodspec != 0) goto <D.29079>; else goto <D.29080>;
    <D.29079>:
    token = mono_image_get_methodspec_token (assembly, inflated);
    goto <D.29081>;
    <D.29080>:
    token = mono_image_get_inflated_method_token (assembly, inflated);
    <D.29081>:
    D.29082 = token;
    return D.29082;
  }
  <D.29078>:
  D.29083 = assembly->handleref_managed;
  D.29084 = mono_g_hash_table_lookup (D.29083, m);
  token = (guint32) D.29084;
  if (token != 0) goto <D.29085>; else goto <D.29086>;
  <D.29085>:
  D.29082 = token;
  return D.29082;
  <D.29086>:
  D.29087 = m->mb;
  D.29088 = D.29087->vtable;
  D.29089 = D.29088->klass;
  D.29090 = is_sre_method_builder (D.29089);
  if (D.29090 != 0) goto <D.29091>; else goto <D.29092>;
  <D.29091>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoGenericClass * gclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        mb = m->mb;
        D.29093 = m->inst;
        type = mono_reflection_type_get_handle (D.29093);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.29094 = BIT_FIELD_REF <*gclass, 32, 96>;
        D.29095 = D.29094 & 1;
        D.29096 = D.29095 == 0;
        D.29097 = (long int) D.29096;
        D.29098 = __builtin_expect (D.29097, 0);
        if (D.29098 != 0) goto <D.29099>; else goto <D.29100>;
        <D.29099>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2934, "gclass->is_dynamic");
        <D.29100>:
        reflection_methodbuilder_from_method_builder (&rmb, mb);
        D.29101 = rmb.name;
        name = mono_string_to_utf8 (D.29101);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.29102 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.29102, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.29103>;
  <D.29092>:
  D.29087 = m->mb;
  D.29088 = D.29087->vtable;
  D.29089 = D.29088->klass;
  D.29104 = is_sr_mono_method (D.29089);
  if (D.29104 != 0) goto <D.29105>; else goto <D.29106>;
  <D.29105>:
  {
    struct MonoMethod * mm;

    D.29087 = m->mb;
    mm = MEM[(struct MonoReflectionMethod *)D.29087].method;
    D.29093 = m->inst;
    type = mono_reflection_type_get_handle (D.29093);
    klass = mono_class_from_mono_type (type);
    D.29107 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.29107);
    D.29102 = &klass->byval_arg;
    D.29108 = mm->name;
    token = mono_image_get_memberref_token (assembly, D.29102, D.29108, sig);
  }
  goto <D.29109>;
  <D.29106>:
  {
    char * name;

    D.29087 = m->mb;
    D.29088 = D.29087->vtable;
    D.29089 = D.29088->klass;
    name = mono_type_get_full_name (D.29089);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19169>:
    goto <D.19169>;
  }
  <D.29109>:
  <D.29103>:
  D.29083 = assembly->handleref_managed;
  token.228 = (void *) token;
  mono_g_hash_table_insert (D.29083, m, token.228);
  D.29082 = token;
  return D.29082;
}


mono_reflection_method_on_tb_inst_get_handle (struct MonoReflectionMethodOnTypeBuilderInst * m)
{
  struct MonoReflectionType * D.29112;
  struct MonoObject * D.29113;
  struct MonoArray * D.29114;
  struct MonoMethod * D.29117;
  unsigned int D.29118;
  unsigned int D.29119;
  unsigned int D.29122;
  unsigned int count.229;
  unsigned int D.29124;
  unsigned int i.230;
  char * D.29126;
  unsigned int i.231;
  unsigned int D.29128;
  struct MonoType * * D.29129;
  struct MonoType * D.29130;
  struct MonoGenericInst * iftmp.232;
  struct MonoGenericClass * D.29132;
  struct MonoClass * klass;
  struct MonoGenericContext tmp_context;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  struct MonoMethod * method;
  struct MonoMethod * inflated;
  int count;
  int i;

  try
    {
      D.29112 = m->inst;
      init_type_builder_generics (D.29112);
      D.29112 = m->inst;
      D.29113 = m->mb;
      method = inflate_method (D.29112, D.29113);
      klass = method->klass;
      D.29114 = m->method_args;
      if (D.29114 == 0B) goto <D.29115>; else goto <D.29116>;
      <D.29115>:
      D.29117 = method;
      return D.29117;
      <D.29116>:
      D.29118 = BIT_FIELD_REF <*method, 32, 160>;
      D.29119 = D.29118 & 4096;
      if (D.29119 != 0) goto <D.29120>; else goto <D.29121>;
      <D.29120>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.29121>:
      D.29114 = m->method_args;
      D.29122 = mono_array_length (D.29114);
      count = (int) D.29122;
      count.229 = (unsigned int) count;
      D.29124 = count.229 * 4;
      type_argv = monoeg_malloc0 (D.29124);
      i = 0;
      goto <D.19151>;
      <D.19150>:
      {
        struct MonoReflectionType * garg;

        D.29114 = m->method_args;
        i.230 = (unsigned int) i;
        D.29126 = mono_array_addr_with_size (D.29114, 4, i.230);
        garg = MEM[(void * *)D.29126];
        i.231 = (unsigned int) i;
        D.29128 = i.231 * 4;
        D.29129 = type_argv + D.29128;
        D.29130 = mono_reflection_type_get_handle (garg);
        *D.29129 = D.29130;
      }
      i = i + 1;
      <D.19151>:
      if (i < count) goto <D.19150>; else goto <D.19152>;
      <D.19152>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.29132 = klass->generic_class;
      if (D.29132 != 0B) goto <D.29133>; else goto <D.29134>;
      <D.29133>:
      D.29132 = klass->generic_class;
      iftmp.232 = D.29132->context.class_inst;
      goto <D.29135>;
      <D.29134>:
      iftmp.232 = 0B;
      <D.29135>:
      tmp_context.class_inst = iftmp.232;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      D.29117 = inflated;
      return D.29117;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_method (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoVTable * D.29138;
  int D.29139;
  struct MonoReflectionType * D.29142;
  struct MonoType * D.29143;
  int D.29145;
  struct MonoType * D.29148;
  struct MonoType * D.29150;
  struct MonoClass * D.29154;
  char * D.29155;
  int D.22992;
  int iftmp.233;
  int D.22991;
  struct MonoVTable * D.29159;
  struct MonoClass * D.29160;
  const char[14] * D.29161;
  unsigned char D.29162;
  int D.29163;
  unsigned char D.29164;
  int D.29165;
  const unsigned char * D.29170;
  unsigned char D.29171;
  int D.29172;
  const unsigned char * D.29173;
  unsigned char D.29174;
  int D.29175;
  const unsigned char * D.29180;
  unsigned char D.29181;
  int D.29182;
  const unsigned char * D.29183;
  unsigned char D.29184;
  int D.29185;
  const unsigned char * D.29190;
  unsigned char D.29191;
  int D.29192;
  const unsigned char * D.29193;
  unsigned char D.29194;
  int D.29195;
  const char * D.29197;
  struct MonoMethod * D.29200;
  int D.23001;
  int iftmp.234;
  int D.23000;
  const char[19] * D.29208;
  unsigned char D.29209;
  int D.29210;
  unsigned char D.29211;
  int D.29212;
  const unsigned char * D.29217;
  unsigned char D.29218;
  int D.29219;
  const unsigned char * D.29220;
  unsigned char D.29221;
  int D.29222;
  const unsigned char * D.29227;
  unsigned char D.29228;
  int D.29229;
  const unsigned char * D.29230;
  unsigned char D.29231;
  int D.29232;
  const unsigned char * D.29237;
  unsigned char D.29238;
  int D.29239;
  const unsigned char * D.29240;
  unsigned char D.29241;
  int D.29242;
  int D.23010;
  int iftmp.235;
  int D.23009;
  const char[11] * D.29253;
  unsigned char D.29254;
  int D.29255;
  unsigned char D.29256;
  int D.29257;
  const unsigned char * D.29262;
  unsigned char D.29263;
  int D.29264;
  const unsigned char * D.29265;
  unsigned char D.29266;
  int D.29267;
  const unsigned char * D.29272;
  unsigned char D.29273;
  int D.29274;
  const unsigned char * D.29275;
  unsigned char D.29276;
  int D.29277;
  const unsigned char * D.29282;
  unsigned char D.29283;
  int D.29284;
  const unsigned char * D.29285;
  unsigned char D.29286;
  int D.29287;
  int D.23019;
  int iftmp.236;
  int D.23018;
  const char[12] * D.29293;
  unsigned char D.29294;
  int D.29295;
  unsigned char D.29296;
  int D.29297;
  const unsigned char * D.29302;
  unsigned char D.29303;
  int D.29304;
  const unsigned char * D.29305;
  unsigned char D.29306;
  int D.29307;
  const unsigned char * D.29312;
  unsigned char D.29313;
  int D.29314;
  const unsigned char * D.29315;
  unsigned char D.29316;
  int D.29317;
  const unsigned char * D.29322;
  unsigned char D.29323;
  int D.29324;
  const unsigned char * D.29325;
  unsigned char D.29326;
  int D.29327;
  struct MonoMethod * D.29329;
  struct MonoType * D.29330;
  struct MonoClass * D.29331;
  struct MonoMethod * method;
  struct MonoClass * gklass;
  struct MonoClass * type_class;

  D.29138 = MEM[(struct MonoObject *)type].vtable;
  type_class = D.29138->klass;
  D.29139 = is_sre_generic_instance (type_class);
  if (D.29139 != 0) goto <D.29140>; else goto <D.29141>;
  <D.29140>:
  {
    struct MonoReflectionGenericClass * mgc;

    mgc = type;
    D.29142 = mgc->generic_type;
    D.29143 = mono_reflection_type_get_handle (D.29142);
    gklass = mono_class_from_mono_type (D.29143);
  }
  goto <D.29144>;
  <D.29141>:
  D.29145 = is_sre_type_builder (type_class);
  if (D.29145 != 0) goto <D.29146>; else goto <D.29147>;
  <D.29146>:
  D.29148 = mono_reflection_type_get_handle (type);
  gklass = mono_class_from_mono_type (D.29148);
  goto <D.29149>;
  <D.29147>:
  D.29150 = type->type;
  if (D.29150 != 0B) goto <D.29151>; else goto <D.29152>;
  <D.29151>:
  D.29150 = type->type;
  gklass = mono_class_from_mono_type (D.29150);
  gklass = mono_class_get_generic_type_definition (gklass);
  goto <D.29153>;
  <D.29152>:
  D.29138 = MEM[(struct MonoObject *)type].vtable;
  D.29154 = D.29138->klass;
  D.29155 = mono_type_get_full_name (D.29154);
  monoeg_g_log (0B, 4, "Can\'t handle type %s", D.29155);
  <D.22983>:
  goto <D.22983>;
  <D.29153>:
  <D.29149>:
  <D.29144>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29159 = obj->vtable;
      D.29160 = D.29159->klass;
      __s2 = D.29160->name;
      D.29161 = "MethodBuilder";
      D.29162 = MEM[(const unsigned char *)D.29161];
      D.29163 = (int) D.29162;
      D.29164 = *__s2;
      D.29165 = (int) D.29164;
      __result = D.29163 - D.29165;
      {
        if (__s2_len != 0) goto <D.29166>; else goto <D.29167>;
        <D.29166>:
        if (__result == 0) goto <D.29168>; else goto <D.29169>;
        <D.29168>:
        D.29170 = &MEM[(void *)"MethodBuilder" + 1B];
        D.29171 = *D.29170;
        D.29172 = (int) D.29171;
        D.29173 = __s2 + 1;
        D.29174 = *D.29173;
        D.29175 = (int) D.29174;
        __result = D.29172 - D.29175;
        if (__s2_len > 1) goto <D.29176>; else goto <D.29177>;
        <D.29176>:
        if (__result == 0) goto <D.29178>; else goto <D.29179>;
        <D.29178>:
        D.29180 = &MEM[(void *)"MethodBuilder" + 2B];
        D.29181 = *D.29180;
        D.29182 = (int) D.29181;
        D.29183 = __s2 + 2;
        D.29184 = *D.29183;
        D.29185 = (int) D.29184;
        __result = D.29182 - D.29185;
        if (__s2_len > 2) goto <D.29186>; else goto <D.29187>;
        <D.29186>:
        if (__result == 0) goto <D.29188>; else goto <D.29189>;
        <D.29188>:
        D.29190 = &MEM[(void *)"MethodBuilder" + 3B];
        D.29191 = *D.29190;
        D.29192 = (int) D.29191;
        D.29193 = __s2 + 3;
        D.29194 = *D.29193;
        D.29195 = (int) D.29194;
        __result = D.29192 - D.29195;
        <D.29189>:
        <D.29187>:
        <D.29179>:
        <D.29177>:
        <D.29169>:
        <D.29167>:
      }
      D.22991 = __result;
    }
    iftmp.233 = -D.22991;
    goto <D.29196>;
    <D.29158>:
    D.29159 = obj->vtable;
    D.29160 = D.29159->klass;
    D.29197 = D.29160->name;
    iftmp.233 = __builtin_strcmp (D.29197, "MethodBuilder");
    <D.29196>:
    D.22992 = iftmp.233;
  }
  if (D.22992 == 0) goto <D.29198>; else goto <D.29199>;
  <D.29198>:
  D.29200 = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  if (D.29200 != 0B) goto <D.29201>; else goto <D.29202>;
  <D.29201>:
  method = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  goto <D.29203>;
  <D.29202>:
  method = methodbuilder_to_mono_method (gklass, obj);
  <D.29203>:
  goto <D.29204>;
  <D.29199>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29159 = obj->vtable;
      D.29160 = D.29159->klass;
      __s2 = D.29160->name;
      D.29208 = "ConstructorBuilder";
      D.29209 = MEM[(const unsigned char *)D.29208];
      D.29210 = (int) D.29209;
      D.29211 = *__s2;
      D.29212 = (int) D.29211;
      __result = D.29210 - D.29212;
      {
        if (__s2_len != 0) goto <D.29213>; else goto <D.29214>;
        <D.29213>:
        if (__result == 0) goto <D.29215>; else goto <D.29216>;
        <D.29215>:
        D.29217 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.29218 = *D.29217;
        D.29219 = (int) D.29218;
        D.29220 = __s2 + 1;
        D.29221 = *D.29220;
        D.29222 = (int) D.29221;
        __result = D.29219 - D.29222;
        if (__s2_len > 1) goto <D.29223>; else goto <D.29224>;
        <D.29223>:
        if (__result == 0) goto <D.29225>; else goto <D.29226>;
        <D.29225>:
        D.29227 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.29228 = *D.29227;
        D.29229 = (int) D.29228;
        D.29230 = __s2 + 2;
        D.29231 = *D.29230;
        D.29232 = (int) D.29231;
        __result = D.29229 - D.29232;
        if (__s2_len > 2) goto <D.29233>; else goto <D.29234>;
        <D.29233>:
        if (__result == 0) goto <D.29235>; else goto <D.29236>;
        <D.29235>:
        D.29237 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.29238 = *D.29237;
        D.29239 = (int) D.29238;
        D.29240 = __s2 + 3;
        D.29241 = *D.29240;
        D.29242 = (int) D.29241;
        __result = D.29239 - D.29242;
        <D.29236>:
        <D.29234>:
        <D.29226>:
        <D.29224>:
        <D.29216>:
        <D.29214>:
      }
      D.23000 = __result;
    }
    iftmp.234 = -D.23000;
    goto <D.29243>;
    <D.29207>:
    D.29159 = obj->vtable;
    D.29160 = D.29159->klass;
    D.29197 = D.29160->name;
    iftmp.234 = __builtin_strcmp (D.29197, "ConstructorBuilder");
    <D.29243>:
    D.23001 = iftmp.234;
  }
  if (D.23001 == 0) goto <D.29244>; else goto <D.29245>;
  <D.29244>:
  method = ctorbuilder_to_mono_method (gklass, obj);
  goto <D.29246>;
  <D.29245>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29159 = obj->vtable;
      D.29160 = D.29159->klass;
      __s2 = D.29160->name;
      D.29253 = "MonoMethod";
      D.29254 = MEM[(const unsigned char *)D.29253];
      D.29255 = (int) D.29254;
      D.29256 = *__s2;
      D.29257 = (int) D.29256;
      __result = D.29255 - D.29257;
      {
        if (__s2_len != 0) goto <D.29258>; else goto <D.29259>;
        <D.29258>:
        if (__result == 0) goto <D.29260>; else goto <D.29261>;
        <D.29260>:
        D.29262 = &MEM[(void *)"MonoMethod" + 1B];
        D.29263 = *D.29262;
        D.29264 = (int) D.29263;
        D.29265 = __s2 + 1;
        D.29266 = *D.29265;
        D.29267 = (int) D.29266;
        __result = D.29264 - D.29267;
        if (__s2_len > 1) goto <D.29268>; else goto <D.29269>;
        <D.29268>:
        if (__result == 0) goto <D.29270>; else goto <D.29271>;
        <D.29270>:
        D.29272 = &MEM[(void *)"MonoMethod" + 2B];
        D.29273 = *D.29272;
        D.29274 = (int) D.29273;
        D.29275 = __s2 + 2;
        D.29276 = *D.29275;
        D.29277 = (int) D.29276;
        __result = D.29274 - D.29277;
        if (__s2_len > 2) goto <D.29278>; else goto <D.29279>;
        <D.29278>:
        if (__result == 0) goto <D.29280>; else goto <D.29281>;
        <D.29280>:
        D.29282 = &MEM[(void *)"MonoMethod" + 3B];
        D.29283 = *D.29282;
        D.29284 = (int) D.29283;
        D.29285 = __s2 + 3;
        D.29286 = *D.29285;
        D.29287 = (int) D.29286;
        __result = D.29284 - D.29287;
        <D.29281>:
        <D.29279>:
        <D.29271>:
        <D.29269>:
        <D.29261>:
        <D.29259>:
      }
      D.23009 = __result;
    }
    iftmp.235 = -D.23009;
    goto <D.29288>;
    <D.29252>:
    D.29159 = obj->vtable;
    D.29160 = D.29159->klass;
    D.29197 = D.29160->name;
    iftmp.235 = __builtin_strcmp (D.29197, "MonoMethod");
    <D.29288>:
    D.23010 = iftmp.235;
  }
  if (D.23010 == 0) goto <D.29247>; else goto <D.29289>;
  <D.29289>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29159 = obj->vtable;
      D.29160 = D.29159->klass;
      __s2 = D.29160->name;
      D.29293 = "MonoCMethod";
      D.29294 = MEM[(const unsigned char *)D.29293];
      D.29295 = (int) D.29294;
      D.29296 = *__s2;
      D.29297 = (int) D.29296;
      __result = D.29295 - D.29297;
      {
        if (__s2_len != 0) goto <D.29298>; else goto <D.29299>;
        <D.29298>:
        if (__result == 0) goto <D.29300>; else goto <D.29301>;
        <D.29300>:
        D.29302 = &MEM[(void *)"MonoCMethod" + 1B];
        D.29303 = *D.29302;
        D.29304 = (int) D.29303;
        D.29305 = __s2 + 1;
        D.29306 = *D.29305;
        D.29307 = (int) D.29306;
        __result = D.29304 - D.29307;
        if (__s2_len > 1) goto <D.29308>; else goto <D.29309>;
        <D.29308>:
        if (__result == 0) goto <D.29310>; else goto <D.29311>;
        <D.29310>:
        D.29312 = &MEM[(void *)"MonoCMethod" + 2B];
        D.29313 = *D.29312;
        D.29314 = (int) D.29313;
        D.29315 = __s2 + 2;
        D.29316 = *D.29315;
        D.29317 = (int) D.29316;
        __result = D.29314 - D.29317;
        if (__s2_len > 2) goto <D.29318>; else goto <D.29319>;
        <D.29318>:
        if (__result == 0) goto <D.29320>; else goto <D.29321>;
        <D.29320>:
        D.29322 = &MEM[(void *)"MonoCMethod" + 3B];
        D.29323 = *D.29322;
        D.29324 = (int) D.29323;
        D.29325 = __s2 + 3;
        D.29326 = *D.29325;
        D.29327 = (int) D.29326;
        __result = D.29324 - D.29327;
        <D.29321>:
        <D.29319>:
        <D.29311>:
        <D.29309>:
        <D.29301>:
        <D.29299>:
      }
      D.23018 = __result;
    }
    iftmp.236 = -D.23018;
    goto <D.29328>;
    <D.29292>:
    D.29159 = obj->vtable;
    D.29160 = D.29159->klass;
    D.29197 = D.29160->name;
    iftmp.236 = __builtin_strcmp (D.29197, "MonoCMethod");
    <D.29328>:
    D.23019 = iftmp.236;
  }
  if (D.23019 == 0) goto <D.29247>; else goto <D.29248>;
  <D.29247>:
  method = MEM[(struct MonoReflectionMethod *)obj].method;
  goto <D.29249>;
  <D.29248>:
  method = 0B;
  D.29159 = obj->vtable;
  D.29160 = D.29159->klass;
  D.29197 = D.29160->name;
  monoeg_g_log (0B, 4, "can\'t handle type %s", D.29197);
  <D.23020>:
  goto <D.23020>;
  <D.29249>:
  <D.29246>:
  <D.29204>:
  D.29330 = mono_reflection_type_get_handle (type);
  D.29331 = mono_class_from_mono_type (D.29330);
  D.29329 = inflate_mono_method (D.29331, method, obj);
  return D.29329;
}


is_sre_generic_instance (struct MonoClass * class)
{
  struct MonoClass * cached_class.237;
  gboolean D.29336;
  _Bool D.29337;
  int D.29338;
  int D.22174;
  int iftmp.238;
  int D.22170;
  const char[17] * D.29344;
  unsigned char D.29345;
  int D.29346;
  unsigned char D.29347;
  int D.29348;
  const unsigned char * D.29353;
  unsigned char D.29354;
  int D.29355;
  const unsigned char * D.29356;
  unsigned char D.29357;
  int D.29358;
  const unsigned char * D.29363;
  unsigned char D.29364;
  int D.29365;
  const unsigned char * D.29366;
  unsigned char D.29367;
  int D.29368;
  const unsigned char * D.29373;
  unsigned char D.29374;
  int D.29375;
  const unsigned char * D.29376;
  unsigned char D.29377;
  int D.29378;
  const char * D.29380;
  int D.22183;
  int iftmp.239;
  int D.22179;
  const char[18] * D.29386;
  unsigned char D.29387;
  int D.29388;
  unsigned char D.29389;
  int D.29390;
  const unsigned char * D.29395;
  unsigned char D.29396;
  int D.29397;
  const unsigned char * D.29398;
  unsigned char D.29399;
  int D.29400;
  const unsigned char * D.29405;
  unsigned char D.29406;
  int D.29407;
  const unsigned char * D.29408;
  unsigned char D.29409;
  int D.29410;
  const unsigned char * D.29415;
  unsigned char D.29416;
  int D.29417;
  const unsigned char * D.29418;
  unsigned char D.29419;
  int D.29420;
  const char * D.29422;

  {
    static struct MonoClass * cached_class;

    cached_class.237 = cached_class;
    if (cached_class.237 != 0B) goto <D.29334>; else goto <D.29335>;
    <D.29334>:
    cached_class.237 = cached_class;
    D.29337 = cached_class.237 == class;
    D.29336 = (gboolean) D.29337;
    return D.29336;
    <D.29335>:
    D.29338 = is_corlib_type (class);
    if (D.29338 != 0) goto <D.29339>; else goto <D.29340>;
    <D.29339>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 16;
      if (__s1_len <= 3) goto <D.29342>; else goto <D.29343>;
      <D.29342>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.29344 = "MonoGenericClass";
        D.29345 = MEM[(const unsigned char *)D.29344];
        D.29346 = (int) D.29345;
        D.29347 = *__s2;
        D.29348 = (int) D.29347;
        __result = D.29346 - D.29348;
        {
          if (__s1_len != 0) goto <D.29349>; else goto <D.29350>;
          <D.29349>:
          if (__result == 0) goto <D.29351>; else goto <D.29352>;
          <D.29351>:
          D.29353 = &MEM[(void *)"MonoGenericClass" + 1B];
          D.29354 = *D.29353;
          D.29355 = (int) D.29354;
          D.29356 = __s2 + 1;
          D.29357 = *D.29356;
          D.29358 = (int) D.29357;
          __result = D.29355 - D.29358;
          if (__s1_len > 1) goto <D.29359>; else goto <D.29360>;
          <D.29359>:
          if (__result == 0) goto <D.29361>; else goto <D.29362>;
          <D.29361>:
          D.29363 = &MEM[(void *)"MonoGenericClass" + 2B];
          D.29364 = *D.29363;
          D.29365 = (int) D.29364;
          D.29366 = __s2 + 2;
          D.29367 = *D.29366;
          D.29368 = (int) D.29367;
          __result = D.29365 - D.29368;
          if (__s1_len > 2) goto <D.29369>; else goto <D.29370>;
          <D.29369>:
          if (__result == 0) goto <D.29371>; else goto <D.29372>;
          <D.29371>:
          D.29373 = &MEM[(void *)"MonoGenericClass" + 3B];
          D.29374 = *D.29373;
          D.29375 = (int) D.29374;
          D.29376 = __s2 + 3;
          D.29377 = *D.29376;
          D.29378 = (int) D.29377;
          __result = D.29375 - D.29378;
          <D.29372>:
          <D.29370>:
          <D.29362>:
          <D.29360>:
          <D.29352>:
          <D.29350>:
        }
        D.22170 = __result;
      }
      iftmp.238 = D.22170;
      goto <D.29379>;
      <D.29343>:
      D.29380 = class->name;
      iftmp.238 = __builtin_strcmp ("MonoGenericClass", D.29380);
      <D.29379>:
      D.22174 = iftmp.238;
    }
    if (D.22174 == 0) goto <D.29381>; else goto <D.29382>;
    <D.29381>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.29384>; else goto <D.29385>;
      <D.29384>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.29386 = "System.Reflection";
        D.29387 = MEM[(const unsigned char *)D.29386];
        D.29388 = (int) D.29387;
        D.29389 = *__s2;
        D.29390 = (int) D.29389;
        __result = D.29388 - D.29390;
        {
          if (__s1_len != 0) goto <D.29391>; else goto <D.29392>;
          <D.29391>:
          if (__result == 0) goto <D.29393>; else goto <D.29394>;
          <D.29393>:
          D.29395 = &MEM[(void *)"System.Reflection" + 1B];
          D.29396 = *D.29395;
          D.29397 = (int) D.29396;
          D.29398 = __s2 + 1;
          D.29399 = *D.29398;
          D.29400 = (int) D.29399;
          __result = D.29397 - D.29400;
          if (__s1_len > 1) goto <D.29401>; else goto <D.29402>;
          <D.29401>:
          if (__result == 0) goto <D.29403>; else goto <D.29404>;
          <D.29403>:
          D.29405 = &MEM[(void *)"System.Reflection" + 2B];
          D.29406 = *D.29405;
          D.29407 = (int) D.29406;
          D.29408 = __s2 + 2;
          D.29409 = *D.29408;
          D.29410 = (int) D.29409;
          __result = D.29407 - D.29410;
          if (__s1_len > 2) goto <D.29411>; else goto <D.29412>;
          <D.29411>:
          if (__result == 0) goto <D.29413>; else goto <D.29414>;
          <D.29413>:
          D.29415 = &MEM[(void *)"System.Reflection" + 3B];
          D.29416 = *D.29415;
          D.29417 = (int) D.29416;
          D.29418 = __s2 + 3;
          D.29419 = *D.29418;
          D.29420 = (int) D.29419;
          __result = D.29417 - D.29420;
          <D.29414>:
          <D.29412>:
          <D.29404>:
          <D.29402>:
          <D.29394>:
          <D.29392>:
        }
        D.22179 = __result;
      }
      iftmp.239 = D.22179;
      goto <D.29421>;
      <D.29385>:
      D.29422 = class->name_space;
      iftmp.239 = __builtin_strcmp ("System.Reflection", D.29422);
      <D.29421>:
      D.22183 = iftmp.239;
    }
    if (D.22183 == 0) goto <D.29423>; else goto <D.29424>;
    <D.29423>:
    cached_class = class;
    D.29336 = 1;
    return D.29336;
    <D.29424>:
    <D.29382>:
    <D.29340>:
    D.29336 = 0;
    return D.29336;
  }
}


methodbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoImage * D.29426;
  struct MonoMethod * D.29427;
  struct MonoMethod * D.29428;
  struct MonoArray * D.29429;
  int D.29430;
  struct MonoGenericContainer * D.29433;
  struct MonoMethod * D.29436;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.29426 = klass->image;
      sig = method_builder_to_signature (D.29426, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_method_builder (&rmb, mb);
      D.29427 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.29427;
      D.29426 = klass->image;
      D.29428 = mb->mhandle;
      D.29429 = mb->cattrs;
      mono_save_custom_attrs (D.29426, D.29428, D.29429);
      D.29426 = klass->image;
      D.29430 = MEM[(struct MonoDynamicImage *)D.29426].save;
      if (D.29430 == 0) goto <D.29431>; else goto <D.29432>;
      <D.29431>:
      D.29433 = klass->generic_container;
      if (D.29433 == 0B) goto <D.29434>; else goto <D.29435>;
      <D.29434>:
      mb->ilgen = 0B;
      <D.29435>:
      <D.29432>:
      D.29436 = mb->mhandle;
      return D.29436;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


method_builder_to_signature (struct MonoImage * image, struct MonoReflectionMethodBuilder * method)
{
  struct MonoArray * D.29439;
  unsigned int D.29440;
  unsigned int D.29441;
  _Bool D.29442;
  struct MonoType * iftmp.240;
  struct MonoObject * D.29444;
  struct MonoClass * D.29448;
  short unsigned int iftmp.241;
  struct MonoArray * D.29450;
  unsigned int D.29453;
  struct MonoMethodSignature * D.29455;
  struct MonoMethodSignature * sig;

  D.29439 = method->parameters;
  sig = parameters_to_signature (image, D.29439);
  D.29440 = method->attrs;
  D.29441 = D.29440 & 16;
  D.29442 = D.29441 == 0;
  sig->hasthis = D.29442;
  D.29444 = method->rtype;
  if (D.29444 != 0B) goto <D.29445>; else goto <D.29446>;
  <D.29445>:
  D.29444 = method->rtype;
  iftmp.240 = mono_reflection_type_get_handle (D.29444);
  goto <D.29447>;
  <D.29446>:
  D.29448 = mono_defaults.void_class;
  iftmp.240 = &D.29448->byval_arg;
  <D.29447>:
  sig->ret = iftmp.240;
  D.29450 = method->generic_params;
  if (D.29450 != 0B) goto <D.29451>; else goto <D.29452>;
  <D.29451>:
  D.29450 = method->generic_params;
  D.29453 = mono_array_length (D.29450);
  iftmp.241 = (short unsigned int) D.29453;
  goto <D.29454>;
  <D.29452>:
  iftmp.241 = 0;
  <D.29454>:
  sig->generic_param_count = iftmp.241;
  D.29455 = sig;
  return D.29455;
}


parameters_to_signature (struct MonoImage * image, struct MonoArray * parameters)
{
  int iftmp.242;
  unsigned int D.29460;
  unsigned int count.243;
  unsigned int D.29463;
  unsigned int D.29464;
  short unsigned int D.29465;
  unsigned int i.244;
  char * D.29467;
  void * D.29468;
  struct MonoType * D.29469;
  struct MonoMethodSignature * D.29470;
  struct MonoMethodSignature * sig;
  int count;
  int i;

  if (parameters != 0B) goto <D.29458>; else goto <D.29459>;
  <D.29458>:
  D.29460 = mono_array_length (parameters);
  iftmp.242 = (int) D.29460;
  goto <D.29461>;
  <D.29459>:
  iftmp.242 = 0;
  <D.29461>:
  count = iftmp.242;
  count.243 = (unsigned int) count;
  D.29463 = count.243 + 3;
  D.29464 = D.29463 * 4;
  sig = image_g_malloc0 (image, D.29464);
  D.29465 = (short unsigned int) count;
  sig->param_count = D.29465;
  sig->sentinelpos = -1;
  i = 0;
  goto <D.22358>;
  <D.22357>:
  i.244 = (unsigned int) i;
  D.29467 = mono_array_addr_with_size (parameters, 4, i.244);
  D.29468 = MEM[(void * *)D.29467];
  D.29469 = mono_reflection_type_get_handle (D.29468);
  sig->params[i] = D.29469;
  i = i + 1;
  <D.22358>:
  if (i < count) goto <D.22357>; else goto <D.22359>;
  <D.22359>:
  D.29470 = sig;
  return D.29470;
}


image_g_malloc0 (struct MonoImage * image, guint size)
{
  void * D.29474;

  if (image != 0B) goto <D.29472>; else goto <D.29473>;
  <D.29472>:
  D.29474 = mono_image_alloc0 (image, size);
  return D.29474;
  <D.29473>:
  D.29474 = monoeg_malloc0 (size);
  return D.29474;
}


reflection_methodbuilder_to_mono_method (struct MonoClass * klass, struct ReflectionMethodBuilder * rmb, struct MonoMethodSignature * sig)
{
  void * * D.29476;
  _Bool D.29477;
  struct MonoImage * iftmp.245;
  struct MonoGenericClass * D.29484;
  _Bool D.29485;
  long int D.29486;
  long int D.29487;
  unsigned int D.29493;
  unsigned int D.29494;
  unsigned int D.29496;
  unsigned int D.29497;
  unsigned char D.29498;
  <unnamed-unsigned:1> D.29499;
  short unsigned int D.29500;
  short unsigned int D.29501;
  struct MonoString * D.29502;
  char * D.29503;
  unsigned char D.29504;
  <unnamed-unsigned:1> D.29505;
  guint32 * D.29506;
  unsigned int D.29509;
  unsigned int D.29510;
  short unsigned int D.29511;
  int D.29512;
  int D.29513;
  struct MonoClass * D.29516;
  int D.22850;
  int iftmp.246;
  int D.22849;
  const char[6] * D.29522;
  unsigned char D.29523;
  int D.29524;
  unsigned char D.29525;
  int D.29526;
  const unsigned char * D.29531;
  unsigned char D.29532;
  int D.29533;
  const unsigned char * D.29534;
  unsigned char D.29535;
  int D.29536;
  const unsigned char * D.29541;
  unsigned char D.29542;
  int D.29543;
  const unsigned char * D.29544;
  unsigned char D.29545;
  int D.29546;
  const unsigned char * D.29551;
  unsigned char D.29552;
  int D.29553;
  const unsigned char * D.29554;
  unsigned char D.29555;
  int D.29556;
  const char * D.29558;
  struct MonoMethodSignature * D.29561;
  short unsigned int D.29563;
  int D.29564;
  int D.29565;
  char * iftmp.247;
  struct MonoString * D.29569;
  int D.29573;
  _Bool D.29574;
  long int D.29575;
  long int D.29576;
  struct MonoString * D.29579;
  char * D.29580;
  int D.29581;
  _Bool D.29582;
  long int D.29583;
  long int D.29584;
  int D.29587;
  int D.29588;
  signed short D.29589;
  signed short iftmp.248;
  int D.29591;
  int D.29594;
  unsigned short D.29595;
  unsigned short D.29596;
  signed short D.29598;
  int D.29599;
  signed short D.29600;
  signed short D.29601;
  short unsigned int D.29602;
  struct MonoImage * D.29603;
  unsigned int D.29604;
  unsigned int D.29605;
  struct GHashTable * D.29608;
  struct MonoMethod * D.29609;
  int D.29610;
  int D.29613;
  struct MonoReflectionILGen * D.29616;
  struct MonoArray * D.29619;
  int D.29620;
  gint32 iftmp.249;
  struct MonoArray * D.29622;
  unsigned int D.29625;
  struct MonoArray * D.29627;
  unsigned int D.29630;
  struct MonoArray * D.29632;
  unsigned int num_locals.250;
  unsigned int D.29637;
  unsigned int D.29638;
  void * D.29639;
  const unsigned char * D.29640;
  short unsigned int D.29641;
  <unnamed-unsigned:15> D.29642;
  unsigned char D.29643;
  <unnamed-unsigned:1> D.29644;
  short unsigned int D.29645;
  unsigned int i.251;
  char * D.29647;
  void * D.29648;
  struct MonoType * D.29649;
  struct MonoObject * D.29650;
  struct MonoType * D.29651;
  short unsigned int D.29652;
  <unnamed-unsigned:15> D.29653;
  unsigned int num_clauses.252;
  struct MonoExceptionClause * D.29657;
  struct MonoArray * D.29658;
  unsigned int D.29661;
  _Bool D.29662;
  long int D.29663;
  long int D.29664;
  <unnamed-signed:31> D.29667;
  unsigned int count.253;
  unsigned int D.29669;
  void * D.29670;
  unsigned int i.254;
  char * D.29672;
  struct MonoType * D.29673;
  struct MonoGenericParamFull * D.29674;
  unsigned int i.255;
  unsigned int D.29676;
  struct MonoGenericParamFull * D.29677;
  unsigned char D.29678;
  short unsigned int D.29681;
  int D.29682;
  struct MonoType * D.29685;
  struct MonoType * D.29686;
  unsigned int D.29687;
  unsigned int D.29688;
  struct MonoGenericParam * D.29689;
  short unsigned int D.29690;
  int D.29691;
  struct MonoGenericContainer * D.29692;
  struct MonoGenericInst * D.29695;
  struct MonoGenericInst * D.29696;
  unsigned int D.29699;
  unsigned int D.29700;
  unsigned int D.29701;
  void * D.29702;
  sizetype i.256;
  sizetype D.29704;
  sizetype D.29705;
  void * * D.29706;
  unsigned int i.257;
  unsigned int D.29708;
  void * * D.29709;
  void * D.29710;
  unsigned int i.258;
  struct MonoArray * D.29712;
  struct MonoMethodSignature * D.29717;
  short unsigned int D.29718;
  int D.29719;
  int D.29720;
  unsigned int D.29721;
  unsigned int D.29722;
  void * D.29723;
  char * D.29724;
  unsigned int D.29729;
  int D.29732;
  struct MonoType * D.29733;
  struct MonoType * D.29734;
  short unsigned int D.29735;
  unsigned int D.29736;
  uint8_t * * D.29739;
  int D.29742;
  unsigned int D.29743;
  unsigned int D.29744;
  void * D.29745;
  void * D.29746;
  struct MonoObject * D.29747;
  char * D.29748;
  const char * p2.259;
  int p2.260;
  int p.261;
  int D.29752;
  unsigned int D.29753;
  unsigned int D.29754;
  uint8_t * * D.29755;
  void * D.29756;
  uint32_t * D.29757;
  uint32_t * D.29758;
  unsigned int def_type.262;
  uint8_t * D.29760;
  struct MonoString * D.29761;
  char * * D.29764;
  char * * D.29765;
  char * D.29766;
  int D.29767;
  _Bool D.29768;
  long int D.29769;
  long int D.29770;
  struct MonoArray * D.29773;
  struct MonoCustomAttrInfo * * D.29776;
  void * D.29779;
  struct MonoCustomAttrInfo * * D.29780;
  struct MonoCustomAttrInfo * D.29781;
  char * D.29784;
  struct MonoReflectionMarshal * D.29787;
  short unsigned int D.29792;
  int D.29793;
  int D.29794;
  unsigned int D.29795;
  unsigned int D.29796;
  int D.29797;
  unsigned int D.29798;
  unsigned int D.29799;
  struct MonoMarshalSpec * * D.29800;
  struct MonoAssembly * D.29801;
  struct MonoMarshalSpec * D.29802;
  unsigned int D.29803;
  struct MonoError error;
  struct MonoMethod * m;
  struct MonoMethodWrapper * wrapperm;
  struct MonoMarshalSpec * * specs;
  struct MonoReflectionMethodAux * method_aux;
  struct MonoImage * image;
  gboolean dynamic;
  int i;

  try
    {
      mono_error_init (&error);
      D.29476 = rmb->refs;
      D.29477 = D.29476 != 0B;
      dynamic = (gboolean) D.29477;
      if (dynamic == 0) goto <D.29479>; else goto <D.29480>;
      <D.29479>:
      iftmp.245 = klass->image;
      goto <D.29481>;
      <D.29480>:
      iftmp.245 = 0B;
      <D.29481>:
      image = iftmp.245;
      if (dynamic == 0) goto <D.29482>; else goto <D.29483>;
      <D.29482>:
      D.29484 = klass->generic_class;
      D.29485 = D.29484 != 0B;
      D.29486 = (long int) D.29485;
      D.29487 = __builtin_expect (D.29486, 0);
      if (D.29487 != 0) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10133, "!klass->generic_class");
      <D.29489>:
      <D.29483>:
      mono_loader_lock ();
      D.29493 = rmb->attrs;
      D.29494 = D.29493 & 8192;
      if (D.29494 != 0) goto <D.29490>; else goto <D.29495>;
      <D.29495>:
      D.29496 = rmb->iattrs;
      D.29497 = D.29496 & 4096;
      if (D.29497 != 0) goto <D.29490>; else goto <D.29491>;
      <D.29490>:
      m = image_g_malloc0 (image, 32);
      goto <D.29492>;
      <D.29491>:
      m = image_g_malloc0 (image, 32);
      <D.29492>:
      wrapperm = m;
      D.29498 = (unsigned char) dynamic;
      D.29499 = (<unnamed-unsigned:1>) D.29498;
      m->dynamic = D.29499;
      m->slot = -1;
      D.29493 = rmb->attrs;
      D.29500 = (short unsigned int) D.29493;
      m->flags = D.29500;
      D.29496 = rmb->iattrs;
      D.29501 = (short unsigned int) D.29496;
      m->iflags = D.29501;
      D.29502 = rmb->name;
      D.29503 = mono_string_to_utf8_image_ignore (image, D.29502);
      m->name = D.29503;
      m->klass = klass;
      m->signature = sig;
      m->sre_method = 1;
      D.29504 = rmb->skip_visibility;
      D.29505 = (<unnamed-unsigned:1>) D.29504;
      m->skip_visibility = D.29505;
      D.29506 = rmb->table_idx;
      if (D.29506 != 0B) goto <D.29507>; else goto <D.29508>;
      <D.29507>:
      D.29506 = rmb->table_idx;
      D.29509 = *D.29506;
      D.29510 = D.29509 | 100663296;
      m->token = D.29510;
      <D.29508>:
      D.29511 = m->iflags;
      D.29512 = (int) D.29511;
      D.29513 = D.29512 & 4096;
      if (D.29513 != 0) goto <D.29514>; else goto <D.29515>;
      <D.29514>:
      D.29516 = mono_defaults.string_class;
      if (D.29516 == klass) goto <D.29517>; else goto <D.29518>;
      <D.29517>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.29522 = ".ctor";
          D.29523 = MEM[(const unsigned char *)D.29522];
          D.29524 = (int) D.29523;
          D.29525 = *__s2;
          D.29526 = (int) D.29525;
          __result = D.29524 - D.29526;
          {
            if (__s2_len != 0) goto <D.29527>; else goto <D.29528>;
            <D.29527>:
            if (__result == 0) goto <D.29529>; else goto <D.29530>;
            <D.29529>:
            D.29531 = &MEM[(void *)".ctor" + 1B];
            D.29532 = *D.29531;
            D.29533 = (int) D.29532;
            D.29534 = __s2 + 1;
            D.29535 = *D.29534;
            D.29536 = (int) D.29535;
            __result = D.29533 - D.29536;
            if (__s2_len > 1) goto <D.29537>; else goto <D.29538>;
            <D.29537>:
            if (__result == 0) goto <D.29539>; else goto <D.29540>;
            <D.29539>:
            D.29541 = &MEM[(void *)".ctor" + 2B];
            D.29542 = *D.29541;
            D.29543 = (int) D.29542;
            D.29544 = __s2 + 2;
            D.29545 = *D.29544;
            D.29546 = (int) D.29545;
            __result = D.29543 - D.29546;
            if (__s2_len > 2) goto <D.29547>; else goto <D.29548>;
            <D.29547>:
            if (__result == 0) goto <D.29549>; else goto <D.29550>;
            <D.29549>:
            D.29551 = &MEM[(void *)".ctor" + 3B];
            D.29552 = *D.29551;
            D.29553 = (int) D.29552;
            D.29554 = __s2 + 3;
            D.29555 = *D.29554;
            D.29556 = (int) D.29555;
            __result = D.29553 - D.29556;
            <D.29550>:
            <D.29548>:
            <D.29540>:
            <D.29538>:
            <D.29530>:
            <D.29528>:
          }
          D.22849 = __result;
        }
        iftmp.246 = -D.22849;
        goto <D.29557>;
        <D.29521>:
        D.29558 = m->name;
        iftmp.246 = __builtin_strcmp (D.29558, ".ctor");
        <D.29557>:
        D.22850 = iftmp.246;
      }
      if (D.22850 == 0) goto <D.29559>; else goto <D.29560>;
      <D.29559>:
      m->string_ctor = 1;
      <D.29560>:
      <D.29518>:
      D.29561 = m->signature;
      D.29561->pinvoke = 1;
      goto <D.29562>;
      <D.29515>:
      D.29563 = m->flags;
      D.29564 = (int) D.29563;
      D.29565 = D.29564 & 8192;
      if (D.29565 != 0) goto <D.29566>; else goto <D.29567>;
      <D.29566>:
      D.29561 = m->signature;
      D.29561->pinvoke = 1;
      method_aux = image_g_malloc0 (image, 28);
      D.29569 = rmb->dllentry;
      if (D.29569 != 0B) goto <D.29570>; else goto <D.29571>;
      <D.29570>:
      D.29569 = rmb->dllentry;
      iftmp.247 = mono_string_to_utf8_image (image, D.29569, &error);
      goto <D.29572>;
      <D.29571>:
      D.29558 = m->name;
      iftmp.247 = image_strdup (image, D.29558);
      <D.29572>:
      method_aux->dllentry = iftmp.247;
      D.29573 = mono_error_ok (&error);
      D.29574 = D.29573 == 0;
      D.29575 = (long int) D.29574;
      D.29576 = __builtin_expect (D.29575, 0);
      if (D.29576 != 0) goto <D.29577>; else goto <D.29578>;
      <D.29577>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10168, "mono_error_ok (&error)");
      <D.29578>:
      D.29579 = rmb->dll;
      D.29580 = mono_string_to_utf8_image (image, D.29579, &error);
      method_aux->dll = D.29580;
      D.29581 = mono_error_ok (&error);
      D.29582 = D.29581 == 0;
      D.29583 = (long int) D.29582;
      D.29584 = __builtin_expect (D.29583, 0);
      if (D.29584 != 0) goto <D.29585>; else goto <D.29586>;
      <D.29585>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10170, "mono_error_ok (&error)");
      <D.29586>:
      D.29587 = rmb->native_cc;
      D.29588 = D.29587 << 8;
      D.29589 = (signed short) D.29588;
      D.29591 = rmb->charset;
      if (D.29591 != 0) goto <D.29592>; else goto <D.29593>;
      <D.29592>:
      D.29591 = rmb->charset;
      D.29594 = D.29591 + -1;
      D.29595 = (unsigned short) D.29594;
      D.29596 = D.29595 * 2;
      iftmp.248 = (signed short) D.29596;
      goto <D.29597>;
      <D.29593>:
      iftmp.248 = 0;
      <D.29597>:
      D.29598 = D.29589 | iftmp.248;
      D.29599 = rmb->extra_flags;
      D.29600 = (signed short) D.29599;
      D.29601 = D.29598 | D.29600;
      D.29602 = (short unsigned int) D.29601;
      MEM[(struct MonoMethodPInvoke *)m].piflags = D.29602;
      D.29603 = klass->image;
      D.29604 = BIT_FIELD_REF <*D.29603, 32, 128>;
      D.29605 = D.29604 & 8;
      if (D.29605 != 0) goto <D.29606>; else goto <D.29607>;
      <D.29606>:
      D.29603 = klass->image;
      D.29608 = MEM[(struct MonoDynamicImage *)D.29603].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.29608, m, method_aux, 0);
      <D.29607>:
      mono_loader_unlock ();
      D.29609 = m;
      return D.29609;
      <D.29567>:
      D.29563 = m->flags;
      D.29564 = (int) D.29563;
      D.29610 = D.29564 & 1024;
      if (D.29610 == 0) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      D.29511 = m->iflags;
      D.29512 = (int) D.29511;
      D.29613 = D.29512 & 3;
      if (D.29613 == 0) goto <D.29614>; else goto <D.29615>;
      <D.29614>:
      {
        struct MonoMethodHeader * header;
        guint32 code_size;
        gint32 max_stack;
        gint32 i;
        gint32 num_locals;
        gint32 num_clauses;
        guint8 * code;

        num_locals = 0;
        num_clauses = 0;
        D.29616 = rmb->ilgen;
        if (D.29616 != 0B) goto <D.29617>; else goto <D.29618>;
        <D.29617>:
        D.29616 = rmb->ilgen;
        D.29619 = D.29616->code;
        code = mono_array_addr_with_size (D.29619, 1, 0);
        D.29616 = rmb->ilgen;
        D.29620 = D.29616->code_len;
        code_size = (guint32) D.29620;
        D.29616 = rmb->ilgen;
        max_stack = D.29616->max_stack;
        D.29616 = rmb->ilgen;
        D.29622 = D.29616->locals;
        if (D.29622 != 0B) goto <D.29623>; else goto <D.29624>;
        <D.29623>:
        D.29616 = rmb->ilgen;
        D.29622 = D.29616->locals;
        D.29625 = mono_array_length (D.29622);
        iftmp.249 = (gint32) D.29625;
        goto <D.29626>;
        <D.29624>:
        iftmp.249 = 0;
        <D.29626>:
        num_locals = iftmp.249;
        D.29616 = rmb->ilgen;
        D.29627 = D.29616->ex_handlers;
        if (D.29627 != 0B) goto <D.29628>; else goto <D.29629>;
        <D.29628>:
        D.29616 = rmb->ilgen;
        D.29630 = method_count_clauses (D.29616);
        num_clauses = (gint32) D.29630;
        <D.29629>:
        goto <D.29631>;
        <D.29618>:
        D.29632 = rmb->code;
        if (D.29632 != 0B) goto <D.29633>; else goto <D.29634>;
        <D.29633>:
        D.29632 = rmb->code;
        code = mono_array_addr_with_size (D.29632, 1, 0);
        D.29632 = rmb->code;
        code_size = mono_array_length (D.29632);
        max_stack = 8;
        goto <D.29635>;
        <D.29634>:
        code = 0B;
        code_size = 0;
        max_stack = 8;
        <D.29635>:
        <D.29631>:
        num_locals.250 = (unsigned int) num_locals;
        D.29637 = num_locals.250 + 5;
        D.29638 = D.29637 * 4;
        header = image_g_malloc0 (image, D.29638);
        header->code_size = code_size;
        D.29639 = image_g_malloc (image, code_size);
        header->code = D.29639;
        D.29640 = header->code;
        memcpy (D.29640, code, code_size);
        D.29641 = (short unsigned int) max_stack;
        D.29642 = (<unnamed-unsigned:15>) D.29641;
        header->max_stack = D.29642;
        D.29643 = rmb->init_locals;
        D.29644 = (<unnamed-unsigned:1>) D.29643;
        header->init_locals = D.29644;
        D.29645 = (short unsigned int) num_locals;
        header->num_locals = D.29645;
        i = 0;
        goto <D.22860>;
        <D.22859>:
        {
          struct MonoReflectionLocalBuilder * lb;

          D.29616 = rmb->ilgen;
          D.29622 = D.29616->locals;
          i.251 = (unsigned int) i;
          D.29647 = mono_array_addr_with_size (D.29622, 4, i.251);
          lb = MEM[(struct MonoReflectionLocalBuilder * *)D.29647];
          D.29648 = image_g_malloc0 (image, 8);
          header->locals[i] = D.29648;
          D.29649 = header->locals[i];
          D.29650 = lb->type;
          D.29651 = mono_reflection_type_get_handle (D.29650);
          memcpy (D.29649, D.29651, 8);
        }
        i = i + 1;
        <D.22860>:
        if (i < num_locals) goto <D.22859>; else goto <D.22861>;
        <D.22861>:
        D.29652 = (short unsigned int) num_clauses;
        D.29653 = (<unnamed-unsigned:15>) D.29652;
        header->num_clauses = D.29653;
        if (num_clauses != 0) goto <D.29654>; else goto <D.29655>;
        <D.29654>:
        D.29603 = klass->image;
        D.29616 = rmb->ilgen;
        num_clauses.252 = (unsigned int) num_clauses;
        D.29657 = method_encode_clauses (image, D.29603, D.29616, num_clauses.252);
        header->clauses = D.29657;
        <D.29655>:
        wrapperm->header = header;
      }
      <D.29615>:
      <D.29612>:
      <D.29562>:
      D.29658 = rmb->generic_params;
      if (D.29658 != 0B) goto <D.29659>; else goto <D.29660>;
      <D.29659>:
      {
        int count;
        struct MonoGenericContainer * container;

        D.29658 = rmb->generic_params;
        D.29661 = mono_array_length (D.29658);
        count = (int) D.29661;
        container = rmb->generic_container;
        D.29662 = container == 0B;
        D.29663 = (long int) D.29662;
        D.29664 = __builtin_expect (D.29663, 0);
        if (D.29664 != 0) goto <D.29665>; else goto <D.29666>;
        <D.29665>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10239, "container");
        <D.29666>:
        D.29667 = (<unnamed-signed:31>) count;
        container->type_argc = D.29667;
        count.253 = (unsigned int) count;
        D.29669 = count.253 * 32;
        D.29670 = image_g_malloc0 (image, D.29669);
        container->type_params = D.29670;
        container->owner.method = m;
        m->is_generic = 1;
        mono_method_set_generic_container (m, container);
        i = 0;
        goto <D.22867>;
        <D.22866>:
        {
          struct MonoReflectionGenericParam * gp;
          struct MonoGenericParamFull * param;

          D.29658 = rmb->generic_params;
          i.254 = (unsigned int) i;
          D.29672 = mono_array_addr_with_size (D.29658, 4, i.254);
          gp = MEM[(struct MonoReflectionGenericParam * *)D.29672];
          D.29673 = mono_reflection_type_get_handle (gp);
          param = D.29673->data.generic_param;
          D.29674 = container->type_params;
          i.255 = (unsigned int) i;
          D.29676 = i.255 * 32;
          D.29677 = D.29674 + D.29676;
          *D.29677 = *param;
        }
        i = i + 1;
        <D.22867>:
        if (i < count) goto <D.22866>; else goto <D.22868>;
        <D.22868>:
        i = 0;
        goto <D.22872>;
        <D.22871>:
        {
          struct MonoType * t;

          D.29561 = m->signature;
          t = D.29561->params[i];
          D.29678 = t->type;
          if (D.29678 == 30) goto <D.29679>; else goto <D.29680>;
          <D.29679>:
          {
            struct MonoGenericParam * gparam;

            gparam = t->data.generic_param;
            D.29681 = gparam->num;
            D.29682 = (int) D.29681;
            if (D.29682 < count) goto <D.29683>; else goto <D.29684>;
            <D.29683>:
            D.29561 = m->signature;
            D.29561 = m->signature;
            D.29685 = D.29561->params[i];
            D.29686 = mono_metadata_type_dup (image, D.29685);
            D.29561->params[i] = D.29686;
            D.29561 = m->signature;
            D.29685 = D.29561->params[i];
            D.29674 = container->type_params;
            D.29681 = gparam->num;
            D.29687 = (unsigned int) D.29681;
            D.29688 = D.29687 * 32;
            D.29689 = D.29674 + D.29688;
            D.29685->data.generic_param = D.29689;
            <D.29684>:
          }
          <D.29680>:
        }
        i = i + 1;
        <D.22872>:
        D.29561 = m->signature;
        D.29690 = D.29561->param_count;
        D.29691 = (int) D.29690;
        if (D.29691 > i) goto <D.22871>; else goto <D.22873>;
        <D.22873>:
        D.29692 = klass->generic_container;
        if (D.29692 != 0B) goto <D.29693>; else goto <D.29694>;
        <D.29693>:
        D.29692 = klass->generic_container;
        container->parent = D.29692;
        D.29692 = klass->generic_container;
        D.29695 = D.29692->context.class_inst;
        container->context.class_inst = D.29695;
        <D.29694>:
        D.29696 = mono_get_shared_generic_inst (container);
        container->context.method_inst = D.29696;
      }
      <D.29660>:
      D.29476 = rmb->refs;
      if (D.29476 != 0B) goto <D.29697>; else goto <D.29698>;
      <D.29697>:
      {
        struct MonoMethodWrapper * mw;
        int i;
        void * * data;

        mw = m;
        m->wrapper_type = 17;
        D.29699 = rmb->nrefs;
        D.29700 = D.29699 + 1;
        D.29701 = D.29700 * 4;
        data = image_g_malloc (image, D.29701);
        mw->method_data = data;
        D.29699 = rmb->nrefs;
        D.29702 = (void *) D.29699;
        *data = D.29702;
        i = 0;
        goto <D.22878>;
        <D.22877>:
        i.256 = (sizetype) i;
        D.29704 = i.256 + 1;
        D.29705 = D.29704 * 4;
        D.29706 = data + D.29705;
        D.29476 = rmb->refs;
        i.257 = (unsigned int) i;
        D.29708 = i.257 * 4;
        D.29709 = D.29476 + D.29708;
        D.29710 = *D.29709;
        *D.29706 = D.29710;
        i = i + 1;
        <D.22878>:
        i.258 = (unsigned int) i;
        D.29699 = rmb->nrefs;
        if (i.258 < D.29699) goto <D.22877>; else goto <D.22879>;
        <D.22879>:
      }
      <D.29698>:
      method_aux = 0B;
      D.29712 = rmb->pinfo;
      if (D.29712 != 0B) goto <D.29713>; else goto <D.29714>;
      <D.29713>:
      if (method_aux == 0B) goto <D.29715>; else goto <D.29716>;
      <D.29715>:
      method_aux = image_g_malloc0 (image, 28);
      <D.29716>:
      D.29717 = mono_method_signature (m);
      D.29718 = D.29717->param_count;
      D.29719 = (int) D.29718;
      D.29720 = D.29719 + 1;
      D.29721 = (unsigned int) D.29720;
      D.29722 = D.29721 * 4;
      D.29723 = image_g_malloc0 (image, D.29722);
      method_aux->param_names = D.29723;
      i = 0;
      goto <D.22888>;
      <D.22887>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.29712 = rmb->pinfo;
        i.254 = (unsigned int) i;
        D.29724 = mono_array_addr_with_size (D.29712, 4, i.254);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.29724];
        if (pb != 0B) goto <D.29725>; else goto <D.29726>;
        <D.29725>:
        if (i > 0) goto <D.29727>; else goto <D.29728>;
        <D.29727>:
        D.29729 = pb->attrs;
        if (D.29729 != 0) goto <D.29730>; else goto <D.29731>;
        <D.29730>:
        D.29561 = m->signature;
        D.29732 = i + -1;
        D.29603 = klass->image;
        D.29561 = m->signature;
        D.29732 = i + -1;
        D.29733 = D.29561->params[D.29732];
        D.29734 = mono_metadata_type_dup (D.29603, D.29733);
        D.29561->params[D.29732] = D.29734;
        D.29561 = m->signature;
        D.29732 = i + -1;
        D.29733 = D.29561->params[D.29732];
        D.29729 = pb->attrs;
        D.29735 = (short unsigned int) D.29729;
        D.29733->attrs = D.29735;
        <D.29731>:
        <D.29728>:
        D.29729 = pb->attrs;
        D.29736 = D.29729 & 4096;
        if (D.29736 != 0) goto <D.29737>; else goto <D.29738>;
        <D.29737>:
        {
          struct MonoDynamicImage * assembly;
          guint32 idx;
          guint32 def_type;
          guint32 len;
          char * p;
          const char * p2;

          try
            {
              D.29739 = method_aux->param_defaults;
              if (D.29739 == 0B) goto <D.29740>; else goto <D.29741>;
              <D.29740>:
              D.29561 = m->signature;
              D.29690 = D.29561->param_count;
              D.29691 = (int) D.29690;
              D.29742 = D.29691 + 1;
              D.29743 = (unsigned int) D.29742;
              D.29744 = D.29743 * 4;
              D.29745 = image_g_malloc0 (image, D.29744);
              method_aux->param_defaults = D.29745;
              D.29561 = m->signature;
              D.29690 = D.29561->param_count;
              D.29691 = (int) D.29690;
              D.29742 = D.29691 + 1;
              D.29743 = (unsigned int) D.29742;
              D.29744 = D.29743 * 4;
              D.29746 = image_g_malloc0 (image, D.29744);
              method_aux->param_default_types = D.29746;
              <D.29741>:
              assembly = klass->image;
              D.29747 = pb->def_value;
              idx = encode_constant (assembly, D.29747, &def_type);
              D.29748 = assembly->blob.data;
              p = D.29748 + idx;
              len = mono_metadata_decode_blob_size (p, &p2);
              p2.259 = p2;
              p2.260 = (int) p2.259;
              p.261 = (int) p;
              D.29752 = p2.260 - p.261;
              D.29753 = (unsigned int) D.29752;
              len = D.29753 + len;
              D.29739 = method_aux->param_defaults;
              i.255 = (unsigned int) i;
              D.29754 = i.255 * 4;
              D.29755 = D.29739 + D.29754;
              D.29756 = image_g_malloc (image, len);
              *D.29755 = D.29756;
              D.29757 = method_aux->param_default_types;
              i.255 = (unsigned int) i;
              D.29754 = i.255 * 4;
              D.29758 = D.29757 + D.29754;
              def_type.262 = def_type;
              *D.29758 = def_type.262;
              D.29739 = method_aux->param_defaults;
              i.255 = (unsigned int) i;
              D.29754 = i.255 * 4;
              D.29755 = D.29739 + D.29754;
              D.29760 = *D.29755;
              memcpy (D.29760, p, len);
            }
          finally
            {
              def_type = {CLOBBER};
              p2 = {CLOBBER};
            }
        }
        <D.29738>:
        D.29761 = pb->name;
        if (D.29761 != 0B) goto <D.29762>; else goto <D.29763>;
        <D.29762>:
        D.29764 = method_aux->param_names;
        i.255 = (unsigned int) i;
        D.29754 = i.255 * 4;
        D.29765 = D.29764 + D.29754;
        D.29761 = pb->name;
        D.29766 = mono_string_to_utf8_image (image, D.29761, &error);
        *D.29765 = D.29766;
        D.29767 = mono_error_ok (&error);
        D.29768 = D.29767 == 0;
        D.29769 = (long int) D.29768;
        D.29770 = __builtin_expect (D.29769, 0);
        if (D.29770 != 0) goto <D.29771>; else goto <D.29772>;
        <D.29771>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10331, "mono_error_ok (&error)");
        <D.29772>:
        <D.29763>:
        D.29773 = pb->cattrs;
        if (D.29773 != 0B) goto <D.29774>; else goto <D.29775>;
        <D.29774>:
        D.29776 = method_aux->param_cattr;
        if (D.29776 == 0B) goto <D.29777>; else goto <D.29778>;
        <D.29777>:
        D.29561 = m->signature;
        D.29690 = D.29561->param_count;
        D.29691 = (int) D.29690;
        D.29742 = D.29691 + 1;
        D.29743 = (unsigned int) D.29742;
        D.29744 = D.29743 * 4;
        D.29779 = image_g_malloc0 (image, D.29744);
        method_aux->param_cattr = D.29779;
        <D.29778>:
        D.29776 = method_aux->param_cattr;
        i.255 = (unsigned int) i;
        D.29754 = i.255 * 4;
        D.29780 = D.29776 + D.29754;
        D.29603 = klass->image;
        D.29773 = pb->cattrs;
        D.29781 = mono_custom_attrs_from_builders (image, D.29603, D.29773);
        *D.29780 = D.29781;
        <D.29775>:
        <D.29726>:
      }
      i = i + 1;
      <D.22888>:
      D.29561 = m->signature;
      D.29690 = D.29561->param_count;
      D.29691 = (int) D.29690;
      if (D.29691 >= i) goto <D.22887>; else goto <D.22889>;
      <D.22889>:
      <D.29714>:
      specs = 0B;
      D.29712 = rmb->pinfo;
      if (D.29712 != 0B) goto <D.29782>; else goto <D.29783>;
      <D.29782>:
      i = 0;
      goto <D.22892>;
      <D.22891>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.29712 = rmb->pinfo;
        i.254 = (unsigned int) i;
        D.29784 = mono_array_addr_with_size (D.29712, 4, i.254);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.29784];
        if (pb != 0B) goto <D.29785>; else goto <D.29786>;
        <D.29785>:
        D.29787 = pb->marshal_info;
        if (D.29787 != 0B) goto <D.29788>; else goto <D.29789>;
        <D.29788>:
        if (specs == 0B) goto <D.29790>; else goto <D.29791>;
        <D.29790>:
        D.29792 = sig->param_count;
        D.29793 = (int) D.29792;
        D.29794 = D.29793 + 1;
        D.29795 = (unsigned int) D.29794;
        D.29796 = D.29795 * 4;
        specs = image_g_malloc0 (image, D.29796);
        <D.29791>:
        D.29797 = pb->position;
        D.29798 = (unsigned int) D.29797;
        D.29799 = D.29798 * 4;
        D.29800 = specs + D.29799;
        D.29603 = klass->image;
        D.29801 = D.29603->assembly;
        D.29787 = pb->marshal_info;
        D.29802 = mono_marshal_spec_from_builder (image, D.29801, D.29787);
        *D.29800 = D.29802;
        <D.29789>:
        <D.29786>:
      }
      i = i + 1;
      <D.22892>:
      i.254 = (unsigned int) i;
      D.29712 = rmb->pinfo;
      D.29803 = mono_array_length (D.29712);
      if (i.254 < D.29803) goto <D.22891>; else goto <D.22893>;
      <D.22893>:
      <D.29783>:
      if (specs != 0B) goto <D.29804>; else goto <D.29805>;
      <D.29804>:
      if (method_aux == 0B) goto <D.29806>; else goto <D.29807>;
      <D.29806>:
      method_aux = image_g_malloc0 (image, 28);
      <D.29807>:
      method_aux->param_marshall = specs;
      <D.29805>:
      D.29603 = klass->image;
      D.29604 = BIT_FIELD_REF <*D.29603, 32, 128>;
      D.29605 = D.29604 & 8;
      if (D.29605 != 0) goto <D.29808>; else goto <D.29809>;
      <D.29808>:
      if (method_aux != 0B) goto <D.29810>; else goto <D.29811>;
      <D.29810>:
      D.29603 = klass->image;
      D.29608 = MEM[(struct MonoDynamicImage *)D.29603].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.29608, m, method_aux, 0);
      <D.29811>:
      <D.29809>:
      mono_loader_unlock ();
      D.29609 = m;
      return D.29609;
    }
  finally
    {
      error = {CLOBBER};
    }
}


image_strdup (struct MonoImage * image, const char * s)
{
  char * D.29816;

  if (image != 0B) goto <D.29814>; else goto <D.29815>;
  <D.29814>:
  D.29816 = mono_image_strdup (image, s);
  return D.29816;
  <D.29815>:
  D.29816 = monoeg_strdup (s);
  return D.29816;
}


method_encode_clauses (struct MonoImage * image, struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen, guint32 num_clauses)
{
  unsigned int D.29818;
  struct MonoArray * D.29819;
  unsigned int D.29820;
  unsigned int D.29821;
  unsigned int i.263;
  int D.29823;
  int D.29824;
  int D.29825;
  struct MonoArray * D.29826;
  unsigned int j.264;
  unsigned int clause_index.265;
  unsigned int D.29831;
  int D.29832;
  unsigned int D.29833;
  unsigned int D.29834;
  unsigned int D.29837;
  unsigned int D.29838;
  unsigned int D.29840;
  int D.29841;
  unsigned int D.29842;
  int D.29843;
  unsigned int D.29844;
  struct MonoObject * D.29845;
  struct MonoType * D.29848;
  struct MonoClass * D.29849;
  int D.29853;
  unsigned int D.29854;
  int D.29856;
  unsigned int D.29857;
  struct MonoExceptionClause * D.29858;
  struct MonoExceptionClause * clauses;
  struct MonoExceptionClause * clause;
  struct MonoILExceptionInfo * ex_info;
  struct MonoILExceptionBlock * ex_block;
  guint32 finally_start;
  int i;
  int j;
  int clause_index;

  D.29818 = num_clauses * 24;
  clauses = image_g_malloc0 (image, D.29818);
  clause_index = 0;
  D.29819 = ilgen->ex_handlers;
  D.29820 = mono_array_length (D.29819);
  D.29821 = D.29820 + 4294967295;
  i = (int) D.29821;
  goto <D.18573>;
  <D.18572>:
  D.29819 = ilgen->ex_handlers;
  i.263 = (unsigned int) i;
  ex_info = mono_array_addr_with_size (D.29819, 16, i.263);
  D.29823 = ex_info->start;
  D.29824 = ex_info->len;
  D.29825 = D.29823 + D.29824;
  finally_start = (guint32) D.29825;
  D.29826 = ex_info->handlers;
  if (D.29826 == 0B) goto <D.29827>; else goto <D.29828>;
  <D.29827>:
  // predicted unlikely by continue predictor.
  goto <D.18568>;
  <D.29828>:
  j = 0;
  goto <D.18570>;
  <D.18569>:
  D.29826 = ex_info->handlers;
  j.264 = (unsigned int) j;
  ex_block = mono_array_addr_with_size (D.29826, 20, j.264);
  clause_index.265 = (unsigned int) clause_index;
  D.29831 = clause_index.265 * 24;
  clause = clauses + D.29831;
  D.29832 = ex_block->type;
  D.29833 = (unsigned int) D.29832;
  clause->flags = D.29833;
  D.29823 = ex_info->start;
  D.29834 = (unsigned int) D.29823;
  clause->try_offset = D.29834;
  D.29832 = ex_block->type;
  if (D.29832 == 2) goto <D.29835>; else goto <D.29836>;
  <D.29835>:
  D.29823 = ex_info->start;
  D.29837 = (unsigned int) D.29823;
  D.29838 = finally_start - D.29837;
  clause->try_len = D.29838;
  goto <D.29839>;
  <D.29836>:
  D.29824 = ex_info->len;
  D.29840 = (unsigned int) D.29824;
  clause->try_len = D.29840;
  <D.29839>:
  D.29841 = ex_block->start;
  D.29842 = (unsigned int) D.29841;
  clause->handler_offset = D.29842;
  D.29843 = ex_block->len;
  D.29844 = (unsigned int) D.29843;
  clause->handler_len = D.29844;
  D.29845 = ex_block->extype;
  if (D.29845 != 0B) goto <D.29846>; else goto <D.29847>;
  <D.29846>:
  D.29845 = ex_block->extype;
  D.29848 = mono_reflection_type_get_handle (D.29845);
  D.29849 = mono_class_from_mono_type (D.29848);
  clause->data.catch_class = D.29849;
  goto <D.29850>;
  <D.29847>:
  D.29832 = ex_block->type;
  if (D.29832 == 1) goto <D.29851>; else goto <D.29852>;
  <D.29851>:
  D.29853 = ex_block->filter_offset;
  D.29854 = (unsigned int) D.29853;
  clause->data.filter_offset = D.29854;
  goto <D.29855>;
  <D.29852>:
  clause->data.filter_offset = 0;
  <D.29855>:
  <D.29850>:
  D.29841 = ex_block->start;
  D.29843 = ex_block->len;
  D.29856 = D.29841 + D.29843;
  finally_start = (guint32) D.29856;
  clause_index = clause_index + 1;
  j = j + 1;
  <D.18570>:
  j.264 = (unsigned int) j;
  D.29826 = ex_info->handlers;
  D.29857 = mono_array_length (D.29826);
  if (j.264 < D.29857) goto <D.18569>; else goto <D.18571>;
  <D.18571>:
  <D.18568>:
  i = i + -1;
  <D.18573>:
  if (i >= 0) goto <D.18572>; else goto <D.18574>;
  <D.18574>:
  D.29858 = clauses;
  return D.29858;
}


image_g_malloc (struct MonoImage * image, guint size)
{
  void * D.29862;

  if (image != 0B) goto <D.29860>; else goto <D.29861>;
  <D.29860>:
  D.29862 = mono_image_alloc (image, size);
  return D.29862;
  <D.29861>:
  D.29862 = monoeg_malloc (size);
  return D.29862;
}


mono_custom_attrs_from_builders (struct MonoImage * alloc_img, struct MonoImage * image, struct MonoArray * cattrs)
{
  struct MonoCustomAttrInfo * D.29866;
  unsigned int D.29867;
  unsigned int i.266;
  char * D.29869;
  int D.29870;
  unsigned int count.267;
  unsigned int D.29874;
  unsigned int D.29875;
  _Bool D.29876;
  int D.29877;
  char * D.29878;
  int D.29879;
  struct MonoArray * D.29882;
  unsigned int D.29883;
  char * D.29884;
  unsigned int D.29885;
  struct MonoReflectionMethod * D.29886;
  struct MonoMethod * D.29887;
  unsigned int D.29888;
  int i;
  int index;
  int count;
  int not_visible;
  struct MonoCustomAttrInfo * ainfo;
  struct MonoReflectionCustomAttr * cattr;

  if (cattrs == 0B) goto <D.29864>; else goto <D.29865>;
  <D.29864>:
  D.29866 = 0B;
  return D.29866;
  <D.29865>:
  D.29867 = mono_array_length (cattrs);
  count = (int) D.29867;
  not_visible = 0;
  i = 0;
  goto <D.18645>;
  <D.18644>:
  i.266 = (unsigned int) i;
  D.29869 = mono_array_addr_with_size (cattrs, 4, i.266);
  cattr = MEM[(void * *)D.29869];
  D.29870 = custom_attr_visible (image, cattr);
  if (D.29870 == 0) goto <D.29871>; else goto <D.29872>;
  <D.29871>:
  not_visible = not_visible + 1;
  <D.29872>:
  i = i + 1;
  <D.18645>:
  if (i < count) goto <D.18644>; else goto <D.18646>;
  <D.18646>:
  count = count - not_visible;
  count.267 = (unsigned int) count;
  D.29874 = count.267 + 1;
  D.29875 = D.29874 * 12;
  ainfo = image_g_malloc0 (alloc_img, D.29875);
  ainfo->image = image;
  ainfo->num_attrs = count;
  D.29876 = alloc_img != 0B;
  D.29877 = (int) D.29876;
  ainfo->cached = D.29877;
  index = 0;
  i = 0;
  goto <D.18649>;
  <D.18648>:
  i.266 = (unsigned int) i;
  D.29878 = mono_array_addr_with_size (cattrs, 4, i.266);
  cattr = MEM[(void * *)D.29878];
  D.29879 = custom_attr_visible (image, cattr);
  if (D.29879 != 0) goto <D.29880>; else goto <D.29881>;
  <D.29880>:
  {
    unsigned char * saved;

    D.29882 = cattr->data;
    D.29883 = mono_array_length (D.29882);
    saved = mono_image_alloc (image, D.29883);
    D.29882 = cattr->data;
    D.29884 = mono_array_addr_with_size (D.29882, 1, 0);
    D.29882 = cattr->data;
    D.29885 = mono_array_length (D.29882);
    memcpy (saved, D.29884, D.29885);
    D.29886 = cattr->ctor;
    D.29887 = D.29886->method;
    ainfo->attrs[index].ctor = D.29887;
    ainfo->attrs[index].data = saved;
    D.29882 = cattr->data;
    D.29888 = mono_array_length (D.29882);
    ainfo->attrs[index].data_size = D.29888;
    index = index + 1;
  }
  <D.29881>:
  i = i + 1;
  <D.18649>:
  if (i < count) goto <D.18648>; else goto <D.18650>;
  <D.18650>:
  D.29866 = ainfo;
  return D.29866;
}


custom_attr_visible (struct MonoImage * image, struct MonoReflectionCustomAttr * cattr)
{
  struct MonoReflectionMethod * D.29890;
  struct MonoMethod * D.29891;
  struct MonoClass * D.29894;
  struct MonoImage * D.29895;
  unsigned int D.29898;
  int D.29899;
  unsigned int visibility.268;
  unsigned int D.29901;
  gboolean D.29904;

  D.29890 = cattr->ctor;
  D.29891 = D.29890->method;
  if (D.29891 != 0B) goto <D.29892>; else goto <D.29893>;
  <D.29892>:
  D.29890 = cattr->ctor;
  D.29891 = D.29890->method;
  D.29894 = D.29891->klass;
  D.29895 = D.29894->image;
  if (D.29895 != image) goto <D.29896>; else goto <D.29897>;
  <D.29896>:
  {
    int visibility;

    D.29890 = cattr->ctor;
    D.29891 = D.29890->method;
    D.29894 = D.29891->klass;
    D.29898 = D.29894->flags;
    D.29899 = (int) D.29898;
    visibility = D.29899 & 7;
    visibility.268 = (unsigned int) visibility;
    D.29901 = visibility.268 + 4294967295;
    if (D.29901 > 1) goto <D.29902>; else goto <D.29903>;
    <D.29902>:
    D.29904 = 0;
    return D.29904;
    <D.29903>:
  }
  <D.29897>:
  <D.29893>:
  D.29904 = 1;
  return D.29904;
}


mono_marshal_spec_from_builder (struct MonoImage * image, struct MonoAssembly * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.29906;
  <unnamed type> D.29907;
  int D.29908;
  <unnamed type> D.29909;
  unsigned char D.29910;
  int D.29913;
  short int D.29914;
  int D.29915;
  _Bool D.29916;
  short int D.29917;
  struct MonoObject * D.29919;
  struct MonoType * D.29922;
  char * D.29923;
  struct MonoString * D.29924;
  char * D.29927;
  struct MonoMarshalSpec * D.29928;
  struct MonoMarshalSpec * res;

  res = image_g_malloc0 (image, 16);
  D.29906 = minfo->type;
  D.29907 = (<unnamed type>) D.29906;
  res->native = D.29907;
  D.29906 = minfo->type;
  switch (D.29906) <default: <D.22814>, case 23: <D.22811>, case 30: <D.22812>, case 42: <D.22809>, case 44: <D.22813>>
  <D.22809>:
  D.29908 = minfo->eltype;
  D.29909 = (<unnamed type>) D.29908;
  res->data.array_data.elem_type = D.29909;
  D.29910 = minfo->has_size;
  if (D.29910 != 0) goto <D.29911>; else goto <D.29912>;
  <D.29911>:
  D.29913 = minfo->param_num;
  D.29914 = (short int) D.29913;
  res->data.array_data.param_num = D.29914;
  D.29915 = minfo->count;
  res->data.array_data.num_elem = D.29915;
  D.29913 = minfo->param_num;
  D.29916 = D.29913 != -1;
  D.29917 = (short int) D.29916;
  res->data.array_data.elem_mult = D.29917;
  goto <D.29918>;
  <D.29912>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  <D.29918>:
  goto <D.22810>;
  <D.22811>:
  <D.22812>:
  D.29915 = minfo->count;
  res->data.array_data.num_elem = D.29915;
  goto <D.22810>;
  <D.22813>:
  D.29919 = minfo->marshaltyperef;
  if (D.29919 != 0B) goto <D.29920>; else goto <D.29921>;
  <D.29920>:
  D.29919 = minfo->marshaltyperef;
  D.29922 = mono_reflection_type_get_handle (D.29919);
  D.29923 = type_get_fully_qualified_name (D.29922);
  res->data.custom_data.custom_name = D.29923;
  <D.29921>:
  D.29924 = minfo->mcookie;
  if (D.29924 != 0B) goto <D.29925>; else goto <D.29926>;
  <D.29925>:
  D.29924 = minfo->mcookie;
  D.29927 = mono_string_to_utf8 (D.29924);
  res->data.custom_data.cookie = D.29927;
  <D.29926>:
  goto <D.22810>;
  <D.22814>:
  goto <D.22810>;
  <D.22810>:
  D.29928 = res;
  return D.29928;
}


mono_save_custom_attrs (struct MonoImage * image, void * obj, struct MonoArray * cattrs)
{
  unsigned int D.29934;
  struct MonoCustomAttrInfo * ainfo;
  struct MonoCustomAttrInfo * tmp;

  if (cattrs == 0B) goto <D.29931>; else goto <D.29933>;
  <D.29933>:
  D.29934 = mono_array_length (cattrs);
  if (D.29934 == 0) goto <D.29931>; else goto <D.29932>;
  <D.29931>:
  return;
  <D.29932>:
  ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
  mono_loader_lock ();
  tmp = mono_image_property_lookup (image, obj, 4096);
  if (tmp != 0B) goto <D.29935>; else goto <D.29936>;
  <D.29935>:
  mono_custom_attrs_free (tmp);
  <D.29936>:
  mono_image_property_insert (image, obj, 4096, ainfo);
  mono_loader_unlock ();
}


ctorbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoImage * D.29938;
  struct MonoMethod * D.29939;
  struct MonoMethod * D.29940;
  struct MonoArray * D.29941;
  int D.29942;
  struct MonoGenericContainer * D.29945;
  struct MonoMethod * D.29948;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.29938 = klass->image;
      sig = ctor_builder_to_signature (D.29938, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.29939 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.29939;
      D.29938 = klass->image;
      D.29940 = mb->mhandle;
      D.29941 = mb->cattrs;
      mono_save_custom_attrs (D.29938, D.29940, D.29941);
      D.29938 = klass->image;
      D.29942 = MEM[(struct MonoDynamicImage *)D.29938].save;
      if (D.29942 == 0) goto <D.29943>; else goto <D.29944>;
      <D.29943>:
      D.29945 = klass->generic_container;
      if (D.29945 == 0B) goto <D.29946>; else goto <D.29947>;
      <D.29946>:
      mb->ilgen = 0B;
      <D.29947>:
      <D.29944>:
      D.29948 = mb->mhandle;
      return D.29948;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


ctor_builder_to_signature (struct MonoImage * image, struct MonoReflectionCtorBuilder * ctor)
{
  struct MonoArray * D.29951;
  unsigned int D.29952;
  unsigned int D.29953;
  _Bool D.29954;
  struct MonoClass * D.29955;
  struct MonoType * D.29956;
  struct MonoMethodSignature * D.29957;
  struct MonoMethodSignature * sig;

  D.29951 = ctor->parameters;
  sig = parameters_to_signature (image, D.29951);
  D.29952 = ctor->attrs;
  D.29953 = D.29952 & 16;
  D.29954 = D.29953 == 0;
  sig->hasthis = D.29954;
  D.29955 = mono_defaults.void_class;
  D.29956 = &D.29955->byval_arg;
  sig->ret = D.29956;
  D.29957 = sig;
  return D.29957;
}


inflate_mono_method (struct MonoClass * klass, struct MonoMethod * method, struct MonoObject * obj)
{
  struct MonoGenericClass * D.29959;
  struct MonoMethod * D.29962;
  unsigned int D.29965;
  struct MonoMethod * * D.29967;
  unsigned int i.269;
  unsigned int D.29970;
  struct MonoMethod * * D.29971;
  struct MonoMethod * D.29972;
  unsigned int D.29973;
  unsigned int D.29974;
  _Bool D.29975;
  long int D.29976;
  long int D.29977;
  struct MonoMethod * D.29980;
  unsigned int i.270;
  _Bool D.29983;
  long int D.29984;
  long int D.29985;
  unsigned int D.29988;
  unsigned int D.29989;
  struct MonoClass * D.29992;
  struct MonoImage * D.29993;
  unsigned int D.29994;
  unsigned int D.29995;
  struct MonoGHashTable * D.29998;
  struct MonoMethodInflated * imethod;
  struct MonoGenericContext * context;
  int i;

  D.29959 = klass->generic_class;
  if (D.29959 == 0B) goto <D.29960>; else goto <D.29961>;
  <D.29960>:
  D.29962 = method;
  return D.29962;
  <D.29961>:
  context = mono_class_get_context (klass);
  D.29965 = klass->method.count;
  if (D.29965 != 0) goto <D.29966>; else goto <D.29963>;
  <D.29966>:
  D.29967 = klass->methods;
  if (D.29967 != 0B) goto <D.29968>; else goto <D.29963>;
  <D.29968>:
  i = 0;
  goto <D.22973>;
  <D.22972>:
  D.29967 = klass->methods;
  i.269 = (unsigned int) i;
  D.29970 = i.269 * 4;
  D.29971 = D.29967 + D.29970;
  D.29972 = *D.29971;
  D.29973 = BIT_FIELD_REF <*D.29972, 32, 160>;
  D.29974 = D.29973 & 4096;
  D.29975 = D.29974 == 0;
  D.29976 = (long int) D.29975;
  D.29977 = __builtin_expect (D.29976, 0);
  if (D.29977 != 0) goto <D.29978>; else goto <D.29979>;
  <D.29978>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10611, "klass->methods [i]->is_inflated");
  <D.29979>:
  D.29967 = klass->methods;
  i.269 = (unsigned int) i;
  D.29970 = i.269 * 4;
  D.29971 = D.29967 + D.29970;
  D.29972 = *D.29971;
  D.29980 = MEM[(struct MonoMethodInflated *)D.29972].declaring;
  if (D.29980 == method) goto <D.22971>; else goto <D.29981>;
  <D.29981>:
  i = i + 1;
  <D.22973>:
  i.270 = (unsigned int) i;
  D.29965 = klass->method.count;
  if (i.270 < D.29965) goto <D.22972>; else goto <D.22971>;
  <D.22971>:
  i.270 = (unsigned int) i;
  D.29965 = klass->method.count;
  D.29983 = i.270 >= D.29965;
  D.29984 = (long int) D.29983;
  D.29985 = __builtin_expect (D.29984, 0);
  if (D.29985 != 0) goto <D.29986>; else goto <D.29987>;
  <D.29986>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10615, "i < klass->method.count");
  <D.29987>:
  D.29967 = klass->methods;
  i.269 = (unsigned int) i;
  D.29970 = i.269 * 4;
  D.29971 = D.29967 + D.29970;
  imethod = *D.29971;
  goto <D.29964>;
  <D.29963>:
  imethod = mono_class_inflate_generic_method_full (method, klass, context);
  <D.29964>:
  D.29988 = BIT_FIELD_REF <*method, 32, 160>;
  D.29989 = D.29988 & 2048;
  if (D.29989 != 0) goto <D.29990>; else goto <D.29991>;
  <D.29990>:
  D.29992 = method->klass;
  D.29993 = D.29992->image;
  D.29994 = BIT_FIELD_REF <*D.29993, 32, 128>;
  D.29995 = D.29994 & 8;
  if (D.29995 != 0) goto <D.29996>; else goto <D.29997>;
  <D.29996>:
  {
    struct MonoDynamicImage * image;

    D.29992 = method->klass;
    image = D.29992->image;
    mono_image_lock (image);
    D.29998 = image->generic_def_objects;
    mono_g_hash_table_insert (D.29998, imethod, obj);
    mono_image_unlock (image);
  }
  <D.29997>:
  <D.29991>:
  D.29962 = imethod;
  return D.29962;
}


is_sre_method_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.271;
  gboolean D.30003;
  _Bool D.30004;
  int D.30005;
  int D.22218;
  int iftmp.272;
  int D.22214;
  const char[14] * D.30011;
  unsigned char D.30012;
  int D.30013;
  unsigned char D.30014;
  int D.30015;
  const unsigned char * D.30020;
  unsigned char D.30021;
  int D.30022;
  const unsigned char * D.30023;
  unsigned char D.30024;
  int D.30025;
  const unsigned char * D.30030;
  unsigned char D.30031;
  int D.30032;
  const unsigned char * D.30033;
  unsigned char D.30034;
  int D.30035;
  const unsigned char * D.30040;
  unsigned char D.30041;
  int D.30042;
  const unsigned char * D.30043;
  unsigned char D.30044;
  int D.30045;
  const char * D.30047;
  int D.22227;
  int iftmp.273;
  int D.22223;
  const char[23] * D.30053;
  unsigned char D.30054;
  int D.30055;
  unsigned char D.30056;
  int D.30057;
  const unsigned char * D.30062;
  unsigned char D.30063;
  int D.30064;
  const unsigned char * D.30065;
  unsigned char D.30066;
  int D.30067;
  const unsigned char * D.30072;
  unsigned char D.30073;
  int D.30074;
  const unsigned char * D.30075;
  unsigned char D.30076;
  int D.30077;
  const unsigned char * D.30082;
  unsigned char D.30083;
  int D.30084;
  const unsigned char * D.30085;
  unsigned char D.30086;
  int D.30087;
  const char * D.30089;

  {
    static struct MonoClass * cached_class;

    cached_class.271 = cached_class;
    if (cached_class.271 != 0B) goto <D.30001>; else goto <D.30002>;
    <D.30001>:
    cached_class.271 = cached_class;
    D.30004 = cached_class.271 == class;
    D.30003 = (gboolean) D.30004;
    return D.30003;
    <D.30002>:
    D.30005 = is_corlib_type (class);
    if (D.30005 != 0) goto <D.30006>; else goto <D.30007>;
    <D.30006>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 13;
      if (__s1_len <= 3) goto <D.30009>; else goto <D.30010>;
      <D.30009>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.30011 = "MethodBuilder";
        D.30012 = MEM[(const unsigned char *)D.30011];
        D.30013 = (int) D.30012;
        D.30014 = *__s2;
        D.30015 = (int) D.30014;
        __result = D.30013 - D.30015;
        {
          if (__s1_len != 0) goto <D.30016>; else goto <D.30017>;
          <D.30016>:
          if (__result == 0) goto <D.30018>; else goto <D.30019>;
          <D.30018>:
          D.30020 = &MEM[(void *)"MethodBuilder" + 1B];
          D.30021 = *D.30020;
          D.30022 = (int) D.30021;
          D.30023 = __s2 + 1;
          D.30024 = *D.30023;
          D.30025 = (int) D.30024;
          __result = D.30022 - D.30025;
          if (__s1_len > 1) goto <D.30026>; else goto <D.30027>;
          <D.30026>:
          if (__result == 0) goto <D.30028>; else goto <D.30029>;
          <D.30028>:
          D.30030 = &MEM[(void *)"MethodBuilder" + 2B];
          D.30031 = *D.30030;
          D.30032 = (int) D.30031;
          D.30033 = __s2 + 2;
          D.30034 = *D.30033;
          D.30035 = (int) D.30034;
          __result = D.30032 - D.30035;
          if (__s1_len > 2) goto <D.30036>; else goto <D.30037>;
          <D.30036>:
          if (__result == 0) goto <D.30038>; else goto <D.30039>;
          <D.30038>:
          D.30040 = &MEM[(void *)"MethodBuilder" + 3B];
          D.30041 = *D.30040;
          D.30042 = (int) D.30041;
          D.30043 = __s2 + 3;
          D.30044 = *D.30043;
          D.30045 = (int) D.30044;
          __result = D.30042 - D.30045;
          <D.30039>:
          <D.30037>:
          <D.30029>:
          <D.30027>:
          <D.30019>:
          <D.30017>:
        }
        D.22214 = __result;
      }
      iftmp.272 = D.22214;
      goto <D.30046>;
      <D.30010>:
      D.30047 = class->name;
      iftmp.272 = __builtin_strcmp ("MethodBuilder", D.30047);
      <D.30046>:
      D.22218 = iftmp.272;
    }
    if (D.22218 == 0) goto <D.30048>; else goto <D.30049>;
    <D.30048>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.30051>; else goto <D.30052>;
      <D.30051>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.30053 = "System.Reflection.Emit";
        D.30054 = MEM[(const unsigned char *)D.30053];
        D.30055 = (int) D.30054;
        D.30056 = *__s2;
        D.30057 = (int) D.30056;
        __result = D.30055 - D.30057;
        {
          if (__s1_len != 0) goto <D.30058>; else goto <D.30059>;
          <D.30058>:
          if (__result == 0) goto <D.30060>; else goto <D.30061>;
          <D.30060>:
          D.30062 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30063 = *D.30062;
          D.30064 = (int) D.30063;
          D.30065 = __s2 + 1;
          D.30066 = *D.30065;
          D.30067 = (int) D.30066;
          __result = D.30064 - D.30067;
          if (__s1_len > 1) goto <D.30068>; else goto <D.30069>;
          <D.30068>:
          if (__result == 0) goto <D.30070>; else goto <D.30071>;
          <D.30070>:
          D.30072 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30073 = *D.30072;
          D.30074 = (int) D.30073;
          D.30075 = __s2 + 2;
          D.30076 = *D.30075;
          D.30077 = (int) D.30076;
          __result = D.30074 - D.30077;
          if (__s1_len > 2) goto <D.30078>; else goto <D.30079>;
          <D.30078>:
          if (__result == 0) goto <D.30080>; else goto <D.30081>;
          <D.30080>:
          D.30082 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30083 = *D.30082;
          D.30084 = (int) D.30083;
          D.30085 = __s2 + 3;
          D.30086 = *D.30085;
          D.30087 = (int) D.30086;
          __result = D.30084 - D.30087;
          <D.30081>:
          <D.30079>:
          <D.30071>:
          <D.30069>:
          <D.30061>:
          <D.30059>:
        }
        D.22223 = __result;
      }
      iftmp.273 = D.22223;
      goto <D.30088>;
      <D.30052>:
      D.30089 = class->name_space;
      iftmp.273 = __builtin_strcmp ("System.Reflection.Emit", D.30089);
      <D.30088>:
      D.22227 = iftmp.273;
    }
    if (D.22227 == 0) goto <D.30090>; else goto <D.30091>;
    <D.30090>:
    cached_class = class;
    D.30003 = 1;
    return D.30003;
    <D.30091>:
    <D.30049>:
    <D.30007>:
    D.30003 = 0;
    return D.30003;
  }
}


is_sr_mono_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.274;
  gboolean D.30096;
  _Bool D.30097;
  int D.30098;
  int D.22464;
  int iftmp.275;
  int D.22460;
  const char[11] * D.30104;
  unsigned char D.30105;
  int D.30106;
  unsigned char D.30107;
  int D.30108;
  const unsigned char * D.30113;
  unsigned char D.30114;
  int D.30115;
  const unsigned char * D.30116;
  unsigned char D.30117;
  int D.30118;
  const unsigned char * D.30123;
  unsigned char D.30124;
  int D.30125;
  const unsigned char * D.30126;
  unsigned char D.30127;
  int D.30128;
  const unsigned char * D.30133;
  unsigned char D.30134;
  int D.30135;
  const unsigned char * D.30136;
  unsigned char D.30137;
  int D.30138;
  const char * D.30140;
  int D.22473;
  int iftmp.276;
  int D.22469;
  const char[18] * D.30146;
  unsigned char D.30147;
  int D.30148;
  unsigned char D.30149;
  int D.30150;
  const unsigned char * D.30155;
  unsigned char D.30156;
  int D.30157;
  const unsigned char * D.30158;
  unsigned char D.30159;
  int D.30160;
  const unsigned char * D.30165;
  unsigned char D.30166;
  int D.30167;
  const unsigned char * D.30168;
  unsigned char D.30169;
  int D.30170;
  const unsigned char * D.30175;
  unsigned char D.30176;
  int D.30177;
  const unsigned char * D.30178;
  unsigned char D.30179;
  int D.30180;
  const char * D.30182;

  {
    static struct MonoClass * cached_class;

    cached_class.274 = cached_class;
    if (cached_class.274 != 0B) goto <D.30094>; else goto <D.30095>;
    <D.30094>:
    cached_class.274 = cached_class;
    D.30097 = cached_class.274 == class;
    D.30096 = (gboolean) D.30097;
    return D.30096;
    <D.30095>:
    D.30098 = is_corlib_type (class);
    if (D.30098 != 0) goto <D.30099>; else goto <D.30100>;
    <D.30099>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 10;
      if (__s1_len <= 3) goto <D.30102>; else goto <D.30103>;
      <D.30102>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.30104 = "MonoMethod";
        D.30105 = MEM[(const unsigned char *)D.30104];
        D.30106 = (int) D.30105;
        D.30107 = *__s2;
        D.30108 = (int) D.30107;
        __result = D.30106 - D.30108;
        {
          if (__s1_len != 0) goto <D.30109>; else goto <D.30110>;
          <D.30109>:
          if (__result == 0) goto <D.30111>; else goto <D.30112>;
          <D.30111>:
          D.30113 = &MEM[(void *)"MonoMethod" + 1B];
          D.30114 = *D.30113;
          D.30115 = (int) D.30114;
          D.30116 = __s2 + 1;
          D.30117 = *D.30116;
          D.30118 = (int) D.30117;
          __result = D.30115 - D.30118;
          if (__s1_len > 1) goto <D.30119>; else goto <D.30120>;
          <D.30119>:
          if (__result == 0) goto <D.30121>; else goto <D.30122>;
          <D.30121>:
          D.30123 = &MEM[(void *)"MonoMethod" + 2B];
          D.30124 = *D.30123;
          D.30125 = (int) D.30124;
          D.30126 = __s2 + 2;
          D.30127 = *D.30126;
          D.30128 = (int) D.30127;
          __result = D.30125 - D.30128;
          if (__s1_len > 2) goto <D.30129>; else goto <D.30130>;
          <D.30129>:
          if (__result == 0) goto <D.30131>; else goto <D.30132>;
          <D.30131>:
          D.30133 = &MEM[(void *)"MonoMethod" + 3B];
          D.30134 = *D.30133;
          D.30135 = (int) D.30134;
          D.30136 = __s2 + 3;
          D.30137 = *D.30136;
          D.30138 = (int) D.30137;
          __result = D.30135 - D.30138;
          <D.30132>:
          <D.30130>:
          <D.30122>:
          <D.30120>:
          <D.30112>:
          <D.30110>:
        }
        D.22460 = __result;
      }
      iftmp.275 = D.22460;
      goto <D.30139>;
      <D.30103>:
      D.30140 = class->name;
      iftmp.275 = __builtin_strcmp ("MonoMethod", D.30140);
      <D.30139>:
      D.22464 = iftmp.275;
    }
    if (D.22464 == 0) goto <D.30141>; else goto <D.30142>;
    <D.30141>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.30144>; else goto <D.30145>;
      <D.30144>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.30146 = "System.Reflection";
        D.30147 = MEM[(const unsigned char *)D.30146];
        D.30148 = (int) D.30147;
        D.30149 = *__s2;
        D.30150 = (int) D.30149;
        __result = D.30148 - D.30150;
        {
          if (__s1_len != 0) goto <D.30151>; else goto <D.30152>;
          <D.30151>:
          if (__result == 0) goto <D.30153>; else goto <D.30154>;
          <D.30153>:
          D.30155 = &MEM[(void *)"System.Reflection" + 1B];
          D.30156 = *D.30155;
          D.30157 = (int) D.30156;
          D.30158 = __s2 + 1;
          D.30159 = *D.30158;
          D.30160 = (int) D.30159;
          __result = D.30157 - D.30160;
          if (__s1_len > 1) goto <D.30161>; else goto <D.30162>;
          <D.30161>:
          if (__result == 0) goto <D.30163>; else goto <D.30164>;
          <D.30163>:
          D.30165 = &MEM[(void *)"System.Reflection" + 2B];
          D.30166 = *D.30165;
          D.30167 = (int) D.30166;
          D.30168 = __s2 + 2;
          D.30169 = *D.30168;
          D.30170 = (int) D.30169;
          __result = D.30167 - D.30170;
          if (__s1_len > 2) goto <D.30171>; else goto <D.30172>;
          <D.30171>:
          if (__result == 0) goto <D.30173>; else goto <D.30174>;
          <D.30173>:
          D.30175 = &MEM[(void *)"System.Reflection" + 3B];
          D.30176 = *D.30175;
          D.30177 = (int) D.30176;
          D.30178 = __s2 + 3;
          D.30179 = *D.30178;
          D.30180 = (int) D.30179;
          __result = D.30177 - D.30180;
          <D.30174>:
          <D.30172>:
          <D.30164>:
          <D.30162>:
          <D.30154>:
          <D.30152>:
        }
        D.22469 = __result;
      }
      iftmp.276 = D.22469;
      goto <D.30181>;
      <D.30145>:
      D.30182 = class->name_space;
      iftmp.276 = __builtin_strcmp ("System.Reflection", D.30182);
      <D.30181>:
      D.22473 = iftmp.276;
    }
    if (D.22473 == 0) goto <D.30183>; else goto <D.30184>;
    <D.30183>:
    cached_class = class;
    D.30096 = 1;
    return D.30096;
    <D.30184>:
    <D.30142>:
    <D.30100>:
    D.30096 = 0;
    return D.30096;
  }
}


is_sre_array (struct MonoClass * class)
{
  struct MonoClass * cached_class.277;
  gboolean D.30189;
  _Bool D.30190;
  int D.30191;
  int D.22108;
  int iftmp.278;
  int D.22104;
  const char[10] * D.30197;
  unsigned char D.30198;
  int D.30199;
  unsigned char D.30200;
  int D.30201;
  const unsigned char * D.30206;
  unsigned char D.30207;
  int D.30208;
  const unsigned char * D.30209;
  unsigned char D.30210;
  int D.30211;
  const unsigned char * D.30216;
  unsigned char D.30217;
  int D.30218;
  const unsigned char * D.30219;
  unsigned char D.30220;
  int D.30221;
  const unsigned char * D.30226;
  unsigned char D.30227;
  int D.30228;
  const unsigned char * D.30229;
  unsigned char D.30230;
  int D.30231;
  const char * D.30233;
  int D.22117;
  int iftmp.279;
  int D.22113;
  const char[23] * D.30239;
  unsigned char D.30240;
  int D.30241;
  unsigned char D.30242;
  int D.30243;
  const unsigned char * D.30248;
  unsigned char D.30249;
  int D.30250;
  const unsigned char * D.30251;
  unsigned char D.30252;
  int D.30253;
  const unsigned char * D.30258;
  unsigned char D.30259;
  int D.30260;
  const unsigned char * D.30261;
  unsigned char D.30262;
  int D.30263;
  const unsigned char * D.30268;
  unsigned char D.30269;
  int D.30270;
  const unsigned char * D.30271;
  unsigned char D.30272;
  int D.30273;
  const char * D.30275;

  {
    static struct MonoClass * cached_class;

    cached_class.277 = cached_class;
    if (cached_class.277 != 0B) goto <D.30187>; else goto <D.30188>;
    <D.30187>:
    cached_class.277 = cached_class;
    D.30190 = cached_class.277 == class;
    D.30189 = (gboolean) D.30190;
    return D.30189;
    <D.30188>:
    D.30191 = is_corlib_type (class);
    if (D.30191 != 0) goto <D.30192>; else goto <D.30193>;
    <D.30192>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 9;
      if (__s1_len <= 3) goto <D.30195>; else goto <D.30196>;
      <D.30195>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.30197 = "ArrayType";
        D.30198 = MEM[(const unsigned char *)D.30197];
        D.30199 = (int) D.30198;
        D.30200 = *__s2;
        D.30201 = (int) D.30200;
        __result = D.30199 - D.30201;
        {
          if (__s1_len != 0) goto <D.30202>; else goto <D.30203>;
          <D.30202>:
          if (__result == 0) goto <D.30204>; else goto <D.30205>;
          <D.30204>:
          D.30206 = &MEM[(void *)"ArrayType" + 1B];
          D.30207 = *D.30206;
          D.30208 = (int) D.30207;
          D.30209 = __s2 + 1;
          D.30210 = *D.30209;
          D.30211 = (int) D.30210;
          __result = D.30208 - D.30211;
          if (__s1_len > 1) goto <D.30212>; else goto <D.30213>;
          <D.30212>:
          if (__result == 0) goto <D.30214>; else goto <D.30215>;
          <D.30214>:
          D.30216 = &MEM[(void *)"ArrayType" + 2B];
          D.30217 = *D.30216;
          D.30218 = (int) D.30217;
          D.30219 = __s2 + 2;
          D.30220 = *D.30219;
          D.30221 = (int) D.30220;
          __result = D.30218 - D.30221;
          if (__s1_len > 2) goto <D.30222>; else goto <D.30223>;
          <D.30222>:
          if (__result == 0) goto <D.30224>; else goto <D.30225>;
          <D.30224>:
          D.30226 = &MEM[(void *)"ArrayType" + 3B];
          D.30227 = *D.30226;
          D.30228 = (int) D.30227;
          D.30229 = __s2 + 3;
          D.30230 = *D.30229;
          D.30231 = (int) D.30230;
          __result = D.30228 - D.30231;
          <D.30225>:
          <D.30223>:
          <D.30215>:
          <D.30213>:
          <D.30205>:
          <D.30203>:
        }
        D.22104 = __result;
      }
      iftmp.278 = D.22104;
      goto <D.30232>;
      <D.30196>:
      D.30233 = class->name;
      iftmp.278 = __builtin_strcmp ("ArrayType", D.30233);
      <D.30232>:
      D.22108 = iftmp.278;
    }
    if (D.22108 == 0) goto <D.30234>; else goto <D.30235>;
    <D.30234>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.30237>; else goto <D.30238>;
      <D.30237>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.30239 = "System.Reflection.Emit";
        D.30240 = MEM[(const unsigned char *)D.30239];
        D.30241 = (int) D.30240;
        D.30242 = *__s2;
        D.30243 = (int) D.30242;
        __result = D.30241 - D.30243;
        {
          if (__s1_len != 0) goto <D.30244>; else goto <D.30245>;
          <D.30244>:
          if (__result == 0) goto <D.30246>; else goto <D.30247>;
          <D.30246>:
          D.30248 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30249 = *D.30248;
          D.30250 = (int) D.30249;
          D.30251 = __s2 + 1;
          D.30252 = *D.30251;
          D.30253 = (int) D.30252;
          __result = D.30250 - D.30253;
          if (__s1_len > 1) goto <D.30254>; else goto <D.30255>;
          <D.30254>:
          if (__result == 0) goto <D.30256>; else goto <D.30257>;
          <D.30256>:
          D.30258 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30259 = *D.30258;
          D.30260 = (int) D.30259;
          D.30261 = __s2 + 2;
          D.30262 = *D.30261;
          D.30263 = (int) D.30262;
          __result = D.30260 - D.30263;
          if (__s1_len > 2) goto <D.30264>; else goto <D.30265>;
          <D.30264>:
          if (__result == 0) goto <D.30266>; else goto <D.30267>;
          <D.30266>:
          D.30268 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30269 = *D.30268;
          D.30270 = (int) D.30269;
          D.30271 = __s2 + 3;
          D.30272 = *D.30271;
          D.30273 = (int) D.30272;
          __result = D.30270 - D.30273;
          <D.30267>:
          <D.30265>:
          <D.30257>:
          <D.30255>:
          <D.30247>:
          <D.30245>:
        }
        D.22113 = __result;
      }
      iftmp.279 = D.22113;
      goto <D.30274>;
      <D.30238>:
      D.30275 = class->name_space;
      iftmp.279 = __builtin_strcmp ("System.Reflection.Emit", D.30275);
      <D.30274>:
      D.22117 = iftmp.279;
    }
    if (D.22117 == 0) goto <D.30276>; else goto <D.30277>;
    <D.30276>:
    cached_class = class;
    D.30189 = 1;
    return D.30189;
    <D.30277>:
    <D.30235>:
    <D.30193>:
    D.30189 = 0;
    return D.30189;
  }
}


is_sre_byref (struct MonoClass * class)
{
  struct MonoClass * cached_class.280;
  gboolean D.30282;
  _Bool D.30283;
  int D.30284;
  int D.22130;
  int iftmp.281;
  int D.22126;
  const char[10] * D.30290;
  unsigned char D.30291;
  int D.30292;
  unsigned char D.30293;
  int D.30294;
  const unsigned char * D.30299;
  unsigned char D.30300;
  int D.30301;
  const unsigned char * D.30302;
  unsigned char D.30303;
  int D.30304;
  const unsigned char * D.30309;
  unsigned char D.30310;
  int D.30311;
  const unsigned char * D.30312;
  unsigned char D.30313;
  int D.30314;
  const unsigned char * D.30319;
  unsigned char D.30320;
  int D.30321;
  const unsigned char * D.30322;
  unsigned char D.30323;
  int D.30324;
  const char * D.30326;
  int D.22139;
  int iftmp.282;
  int D.22135;
  const char[23] * D.30332;
  unsigned char D.30333;
  int D.30334;
  unsigned char D.30335;
  int D.30336;
  const unsigned char * D.30341;
  unsigned char D.30342;
  int D.30343;
  const unsigned char * D.30344;
  unsigned char D.30345;
  int D.30346;
  const unsigned char * D.30351;
  unsigned char D.30352;
  int D.30353;
  const unsigned char * D.30354;
  unsigned char D.30355;
  int D.30356;
  const unsigned char * D.30361;
  unsigned char D.30362;
  int D.30363;
  const unsigned char * D.30364;
  unsigned char D.30365;
  int D.30366;
  const char * D.30368;

  {
    static struct MonoClass * cached_class;

    cached_class.280 = cached_class;
    if (cached_class.280 != 0B) goto <D.30280>; else goto <D.30281>;
    <D.30280>:
    cached_class.280 = cached_class;
    D.30283 = cached_class.280 == class;
    D.30282 = (gboolean) D.30283;
    return D.30282;
    <D.30281>:
    D.30284 = is_corlib_type (class);
    if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
    <D.30285>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 9;
      if (__s1_len <= 3) goto <D.30288>; else goto <D.30289>;
      <D.30288>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.30290 = "ByRefType";
        D.30291 = MEM[(const unsigned char *)D.30290];
        D.30292 = (int) D.30291;
        D.30293 = *__s2;
        D.30294 = (int) D.30293;
        __result = D.30292 - D.30294;
        {
          if (__s1_len != 0) goto <D.30295>; else goto <D.30296>;
          <D.30295>:
          if (__result == 0) goto <D.30297>; else goto <D.30298>;
          <D.30297>:
          D.30299 = &MEM[(void *)"ByRefType" + 1B];
          D.30300 = *D.30299;
          D.30301 = (int) D.30300;
          D.30302 = __s2 + 1;
          D.30303 = *D.30302;
          D.30304 = (int) D.30303;
          __result = D.30301 - D.30304;
          if (__s1_len > 1) goto <D.30305>; else goto <D.30306>;
          <D.30305>:
          if (__result == 0) goto <D.30307>; else goto <D.30308>;
          <D.30307>:
          D.30309 = &MEM[(void *)"ByRefType" + 2B];
          D.30310 = *D.30309;
          D.30311 = (int) D.30310;
          D.30312 = __s2 + 2;
          D.30313 = *D.30312;
          D.30314 = (int) D.30313;
          __result = D.30311 - D.30314;
          if (__s1_len > 2) goto <D.30315>; else goto <D.30316>;
          <D.30315>:
          if (__result == 0) goto <D.30317>; else goto <D.30318>;
          <D.30317>:
          D.30319 = &MEM[(void *)"ByRefType" + 3B];
          D.30320 = *D.30319;
          D.30321 = (int) D.30320;
          D.30322 = __s2 + 3;
          D.30323 = *D.30322;
          D.30324 = (int) D.30323;
          __result = D.30321 - D.30324;
          <D.30318>:
          <D.30316>:
          <D.30308>:
          <D.30306>:
          <D.30298>:
          <D.30296>:
        }
        D.22126 = __result;
      }
      iftmp.281 = D.22126;
      goto <D.30325>;
      <D.30289>:
      D.30326 = class->name;
      iftmp.281 = __builtin_strcmp ("ByRefType", D.30326);
      <D.30325>:
      D.22130 = iftmp.281;
    }
    if (D.22130 == 0) goto <D.30327>; else goto <D.30328>;
    <D.30327>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.30330>; else goto <D.30331>;
      <D.30330>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.30332 = "System.Reflection.Emit";
        D.30333 = MEM[(const unsigned char *)D.30332];
        D.30334 = (int) D.30333;
        D.30335 = *__s2;
        D.30336 = (int) D.30335;
        __result = D.30334 - D.30336;
        {
          if (__s1_len != 0) goto <D.30337>; else goto <D.30338>;
          <D.30337>:
          if (__result == 0) goto <D.30339>; else goto <D.30340>;
          <D.30339>:
          D.30341 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30342 = *D.30341;
          D.30343 = (int) D.30342;
          D.30344 = __s2 + 1;
          D.30345 = *D.30344;
          D.30346 = (int) D.30345;
          __result = D.30343 - D.30346;
          if (__s1_len > 1) goto <D.30347>; else goto <D.30348>;
          <D.30347>:
          if (__result == 0) goto <D.30349>; else goto <D.30350>;
          <D.30349>:
          D.30351 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30352 = *D.30351;
          D.30353 = (int) D.30352;
          D.30354 = __s2 + 2;
          D.30355 = *D.30354;
          D.30356 = (int) D.30355;
          __result = D.30353 - D.30356;
          if (__s1_len > 2) goto <D.30357>; else goto <D.30358>;
          <D.30357>:
          if (__result == 0) goto <D.30359>; else goto <D.30360>;
          <D.30359>:
          D.30361 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30362 = *D.30361;
          D.30363 = (int) D.30362;
          D.30364 = __s2 + 3;
          D.30365 = *D.30364;
          D.30366 = (int) D.30365;
          __result = D.30363 - D.30366;
          <D.30360>:
          <D.30358>:
          <D.30350>:
          <D.30348>:
          <D.30340>:
          <D.30338>:
        }
        D.22135 = __result;
      }
      iftmp.282 = D.22135;
      goto <D.30367>;
      <D.30331>:
      D.30368 = class->name_space;
      iftmp.282 = __builtin_strcmp ("System.Reflection.Emit", D.30368);
      <D.30367>:
      D.22139 = iftmp.282;
    }
    if (D.22139 == 0) goto <D.30369>; else goto <D.30370>;
    <D.30369>:
    cached_class = class;
    D.30282 = 1;
    return D.30282;
    <D.30370>:
    <D.30328>:
    <D.30286>:
    D.30282 = 0;
    return D.30282;
  }
}


is_sre_pointer (struct MonoClass * class)
{
  struct MonoClass * cached_class.283;
  gboolean D.30375;
  _Bool D.30376;
  int D.30377;
  int D.22152;
  int iftmp.284;
  int D.22148;
  const char[12] * D.30383;
  unsigned char D.30384;
  int D.30385;
  unsigned char D.30386;
  int D.30387;
  const unsigned char * D.30392;
  unsigned char D.30393;
  int D.30394;
  const unsigned char * D.30395;
  unsigned char D.30396;
  int D.30397;
  const unsigned char * D.30402;
  unsigned char D.30403;
  int D.30404;
  const unsigned char * D.30405;
  unsigned char D.30406;
  int D.30407;
  const unsigned char * D.30412;
  unsigned char D.30413;
  int D.30414;
  const unsigned char * D.30415;
  unsigned char D.30416;
  int D.30417;
  const char * D.30419;
  int D.22161;
  int iftmp.285;
  int D.22157;
  const char[23] * D.30425;
  unsigned char D.30426;
  int D.30427;
  unsigned char D.30428;
  int D.30429;
  const unsigned char * D.30434;
  unsigned char D.30435;
  int D.30436;
  const unsigned char * D.30437;
  unsigned char D.30438;
  int D.30439;
  const unsigned char * D.30444;
  unsigned char D.30445;
  int D.30446;
  const unsigned char * D.30447;
  unsigned char D.30448;
  int D.30449;
  const unsigned char * D.30454;
  unsigned char D.30455;
  int D.30456;
  const unsigned char * D.30457;
  unsigned char D.30458;
  int D.30459;
  const char * D.30461;

  {
    static struct MonoClass * cached_class;

    cached_class.283 = cached_class;
    if (cached_class.283 != 0B) goto <D.30373>; else goto <D.30374>;
    <D.30373>:
    cached_class.283 = cached_class;
    D.30376 = cached_class.283 == class;
    D.30375 = (gboolean) D.30376;
    return D.30375;
    <D.30374>:
    D.30377 = is_corlib_type (class);
    if (D.30377 != 0) goto <D.30378>; else goto <D.30379>;
    <D.30378>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 11;
      if (__s1_len <= 3) goto <D.30381>; else goto <D.30382>;
      <D.30381>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.30383 = "PointerType";
        D.30384 = MEM[(const unsigned char *)D.30383];
        D.30385 = (int) D.30384;
        D.30386 = *__s2;
        D.30387 = (int) D.30386;
        __result = D.30385 - D.30387;
        {
          if (__s1_len != 0) goto <D.30388>; else goto <D.30389>;
          <D.30388>:
          if (__result == 0) goto <D.30390>; else goto <D.30391>;
          <D.30390>:
          D.30392 = &MEM[(void *)"PointerType" + 1B];
          D.30393 = *D.30392;
          D.30394 = (int) D.30393;
          D.30395 = __s2 + 1;
          D.30396 = *D.30395;
          D.30397 = (int) D.30396;
          __result = D.30394 - D.30397;
          if (__s1_len > 1) goto <D.30398>; else goto <D.30399>;
          <D.30398>:
          if (__result == 0) goto <D.30400>; else goto <D.30401>;
          <D.30400>:
          D.30402 = &MEM[(void *)"PointerType" + 2B];
          D.30403 = *D.30402;
          D.30404 = (int) D.30403;
          D.30405 = __s2 + 2;
          D.30406 = *D.30405;
          D.30407 = (int) D.30406;
          __result = D.30404 - D.30407;
          if (__s1_len > 2) goto <D.30408>; else goto <D.30409>;
          <D.30408>:
          if (__result == 0) goto <D.30410>; else goto <D.30411>;
          <D.30410>:
          D.30412 = &MEM[(void *)"PointerType" + 3B];
          D.30413 = *D.30412;
          D.30414 = (int) D.30413;
          D.30415 = __s2 + 3;
          D.30416 = *D.30415;
          D.30417 = (int) D.30416;
          __result = D.30414 - D.30417;
          <D.30411>:
          <D.30409>:
          <D.30401>:
          <D.30399>:
          <D.30391>:
          <D.30389>:
        }
        D.22148 = __result;
      }
      iftmp.284 = D.22148;
      goto <D.30418>;
      <D.30382>:
      D.30419 = class->name;
      iftmp.284 = __builtin_strcmp ("PointerType", D.30419);
      <D.30418>:
      D.22152 = iftmp.284;
    }
    if (D.22152 == 0) goto <D.30420>; else goto <D.30421>;
    <D.30420>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.30423>; else goto <D.30424>;
      <D.30423>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.30425 = "System.Reflection.Emit";
        D.30426 = MEM[(const unsigned char *)D.30425];
        D.30427 = (int) D.30426;
        D.30428 = *__s2;
        D.30429 = (int) D.30428;
        __result = D.30427 - D.30429;
        {
          if (__s1_len != 0) goto <D.30430>; else goto <D.30431>;
          <D.30430>:
          if (__result == 0) goto <D.30432>; else goto <D.30433>;
          <D.30432>:
          D.30434 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30435 = *D.30434;
          D.30436 = (int) D.30435;
          D.30437 = __s2 + 1;
          D.30438 = *D.30437;
          D.30439 = (int) D.30438;
          __result = D.30436 - D.30439;
          if (__s1_len > 1) goto <D.30440>; else goto <D.30441>;
          <D.30440>:
          if (__result == 0) goto <D.30442>; else goto <D.30443>;
          <D.30442>:
          D.30444 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30445 = *D.30444;
          D.30446 = (int) D.30445;
          D.30447 = __s2 + 2;
          D.30448 = *D.30447;
          D.30449 = (int) D.30448;
          __result = D.30446 - D.30449;
          if (__s1_len > 2) goto <D.30450>; else goto <D.30451>;
          <D.30450>:
          if (__result == 0) goto <D.30452>; else goto <D.30453>;
          <D.30452>:
          D.30454 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30455 = *D.30454;
          D.30456 = (int) D.30455;
          D.30457 = __s2 + 3;
          D.30458 = *D.30457;
          D.30459 = (int) D.30458;
          __result = D.30456 - D.30459;
          <D.30453>:
          <D.30451>:
          <D.30443>:
          <D.30441>:
          <D.30433>:
          <D.30431>:
        }
        D.22157 = __result;
      }
      iftmp.285 = D.22157;
      goto <D.30460>;
      <D.30424>:
      D.30461 = class->name_space;
      iftmp.285 = __builtin_strcmp ("System.Reflection.Emit", D.30461);
      <D.30460>:
      D.22161 = iftmp.285;
    }
    if (D.22161 == 0) goto <D.30462>; else goto <D.30463>;
    <D.30462>:
    cached_class = class;
    D.30375 = 1;
    return D.30375;
    <D.30463>:
    <D.30421>:
    <D.30379>:
    D.30375 = 0;
    return D.30375;
  }
}


mono_image_register_token (struct MonoDynamicImage * assembly, guint32 token, struct MonoObject * obj)
{
  struct MonoGHashTable * D.30465;
  const void * token.286;
  void * token.287;
  struct MonoObject * prev;

  D.30465 = assembly->tokens;
  token.286 = (const void *) token;
  prev = mono_g_hash_table_lookup (D.30465, token.286);
  if (prev != 0B) goto <D.30467>; else goto <D.30468>;
  <D.30467>:
  goto <D.30469>;
  <D.30468>:
  D.30465 = assembly->tokens;
  token.287 = (void *) token;
  mono_g_hash_table_insert (D.30465, token.287, obj);
  <D.30469>:
}


mono_dynamic_image_release_gc_roots (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * * D.30471;
  struct MonoGHashTable * * D.30472;
  struct MonoGHashTable * * D.30473;
  struct MonoGHashTable * * D.30474;
  struct MonoGHashTable * * D.30475;
  struct MonoGHashTable * * D.30476;

  D.30471 = &image->token_fixups;
  release_hashtable (D.30471);
  D.30472 = &image->handleref_managed;
  release_hashtable (D.30472);
  D.30473 = &image->tokens;
  release_hashtable (D.30473);
  D.30474 = &image->remapped_tokens;
  release_hashtable (D.30474);
  D.30475 = &image->generic_def_objects;
  release_hashtable (D.30475);
  D.30476 = &image->methodspec;
  release_hashtable (D.30476);
}


release_hashtable (struct MonoGHashTable * * hash)
{
  struct MonoGHashTable * D.30477;

  D.30477 = *hash;
  if (D.30477 != 0B) goto <D.30478>; else goto <D.30479>;
  <D.30478>:
  D.30477 = *hash;
  mono_g_hash_table_destroy (D.30477);
  *hash = 0B;
  <D.30479>:
}


mono_dynamic_image_free (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * D.30480;
  struct GHashTable * D.30483;
  struct GHashTable * D.30486;
  struct GHashTable * D.30489;
  struct MonoGHashTable * D.30492;
  struct MonoGHashTable * D.30495;
  struct MonoGHashTable * D.30498;
  struct MonoGHashTable * D.30501;
  struct GHashTable * D.30504;
  struct GHashTable * D.30507;
  struct MonoMethodSignature * D.30510;
  char * D.30511;
  struct GList * D.30512;
  struct GPtrArray * D.30513;
  void * * D.30516;
  unsigned int i.288;
  unsigned int D.30518;
  void * * D.30519;
  struct MonoReflectionGenericParam * * D.30520;
  unsigned int i.289;
  unsigned int D.30522;
  struct MonoGHashTable * D.30523;
  struct GHashTable * D.30526;
  struct GHashTable * D.30529;
  struct GHashTable * D.30532;
  struct GHashTable * D.30535;
  char * D.30538;
  char * D.30539;
  guint8 * D.30540;
  struct MonoDynamicStream * D.30543;
  struct MonoDynamicStream * D.30544;
  struct MonoDynamicStream * D.30545;
  struct MonoDynamicStream * D.30546;
  struct MonoDynamicStream * D.30547;
  struct MonoDynamicStream * D.30548;
  struct MonoDynamicStream * D.30549;
  guint32 * D.30550;
  struct MonoDynamicImage * di;
  struct GList * list;
  int i;

  di = image;
  D.30480 = di->methodspec;
  if (D.30480 != 0B) goto <D.30481>; else goto <D.30482>;
  <D.30481>:
  D.30480 = di->methodspec;
  mono_g_hash_table_destroy (D.30480);
  <D.30482>:
  D.30483 = di->typespec;
  if (D.30483 != 0B) goto <D.30484>; else goto <D.30485>;
  <D.30484>:
  D.30483 = di->typespec;
  monoeg_g_hash_table_destroy (D.30483);
  <D.30485>:
  D.30486 = di->typeref;
  if (D.30486 != 0B) goto <D.30487>; else goto <D.30488>;
  <D.30487>:
  D.30486 = di->typeref;
  monoeg_g_hash_table_destroy (D.30486);
  <D.30488>:
  D.30489 = di->handleref;
  if (D.30489 != 0B) goto <D.30490>; else goto <D.30491>;
  <D.30490>:
  D.30489 = di->handleref;
  monoeg_g_hash_table_destroy (D.30489);
  <D.30491>:
  D.30492 = di->handleref_managed;
  if (D.30492 != 0B) goto <D.30493>; else goto <D.30494>;
  <D.30493>:
  D.30492 = di->handleref_managed;
  mono_g_hash_table_destroy (D.30492);
  <D.30494>:
  D.30495 = di->tokens;
  if (D.30495 != 0B) goto <D.30496>; else goto <D.30497>;
  <D.30496>:
  D.30495 = di->tokens;
  mono_g_hash_table_destroy (D.30495);
  <D.30497>:
  D.30498 = di->remapped_tokens;
  if (D.30498 != 0B) goto <D.30499>; else goto <D.30500>;
  <D.30499>:
  D.30498 = di->remapped_tokens;
  mono_g_hash_table_destroy (D.30498);
  <D.30500>:
  D.30501 = di->generic_def_objects;
  if (D.30501 != 0B) goto <D.30502>; else goto <D.30503>;
  <D.30502>:
  D.30501 = di->generic_def_objects;
  mono_g_hash_table_destroy (D.30501);
  <D.30503>:
  D.30504 = di->blob_cache;
  if (D.30504 != 0B) goto <D.30505>; else goto <D.30506>;
  <D.30505>:
  D.30504 = di->blob_cache;
  monoeg_g_hash_table_foreach (D.30504, free_blob_cache_entry, 0B);
  D.30504 = di->blob_cache;
  monoeg_g_hash_table_destroy (D.30504);
  <D.30506>:
  D.30507 = di->standalonesig_cache;
  if (D.30507 != 0B) goto <D.30508>; else goto <D.30509>;
  <D.30508>:
  D.30507 = di->standalonesig_cache;
  monoeg_g_hash_table_destroy (D.30507);
  <D.30509>:
  list = di->array_methods;
  goto <D.20376>;
  <D.20375>:
  {
    struct ArrayMethod * am;

    am = list->data;
    D.30510 = am->sig;
    monoeg_g_free (D.30510);
    D.30511 = am->name;
    monoeg_g_free (D.30511);
    monoeg_g_free (am);
  }
  list = list->next;
  <D.20376>:
  if (list != 0B) goto <D.20375>; else goto <D.20377>;
  <D.20377>:
  D.30512 = di->array_methods;
  monoeg_g_list_free (D.30512);
  D.30513 = di->gen_params;
  if (D.30513 != 0B) goto <D.30514>; else goto <D.30515>;
  <D.30514>:
  i = 0;
  goto <D.20380>;
  <D.20379>:
  {
    struct GenericParamTableEntry * entry;

    D.30513 = di->gen_params;
    D.30516 = D.30513->pdata;
    i.288 = (unsigned int) i;
    D.30518 = i.288 * 4;
    D.30519 = D.30516 + D.30518;
    entry = *D.30519;
    D.30520 = &entry->gparam;
    mono_gc_deregister_root (D.30520);
    monoeg_g_free (entry);
  }
  i = i + 1;
  <D.20380>:
  i.289 = (unsigned int) i;
  D.30513 = di->gen_params;
  D.30522 = D.30513->len;
  if (i.289 < D.30522) goto <D.20379>; else goto <D.20381>;
  <D.20381>:
  D.30513 = di->gen_params;
  monoeg_g_ptr_array_free (D.30513, 1);
  <D.30515>:
  D.30523 = di->token_fixups;
  if (D.30523 != 0B) goto <D.30524>; else goto <D.30525>;
  <D.30524>:
  D.30523 = di->token_fixups;
  mono_g_hash_table_destroy (D.30523);
  <D.30525>:
  D.30526 = di->method_to_table_idx;
  if (D.30526 != 0B) goto <D.30527>; else goto <D.30528>;
  <D.30527>:
  D.30526 = di->method_to_table_idx;
  monoeg_g_hash_table_destroy (D.30526);
  <D.30528>:
  D.30529 = di->field_to_table_idx;
  if (D.30529 != 0B) goto <D.30530>; else goto <D.30531>;
  <D.30530>:
  D.30529 = di->field_to_table_idx;
  monoeg_g_hash_table_destroy (D.30529);
  <D.30531>:
  D.30532 = di->method_aux_hash;
  if (D.30532 != 0B) goto <D.30533>; else goto <D.30534>;
  <D.30533>:
  D.30532 = di->method_aux_hash;
  monoeg_g_hash_table_destroy (D.30532);
  <D.30534>:
  D.30535 = di->vararg_aux_hash;
  if (D.30535 != 0B) goto <D.30536>; else goto <D.30537>;
  <D.30536>:
  D.30535 = di->vararg_aux_hash;
  monoeg_g_hash_table_destroy (D.30535);
  <D.30537>:
  D.30538 = di->strong_name;
  monoeg_g_free (D.30538);
  D.30539 = di->win32_res;
  monoeg_g_free (D.30539);
  D.30540 = di->public_key;
  if (D.30540 != 0B) goto <D.30541>; else goto <D.30542>;
  <D.30541>:
  D.30540 = di->public_key;
  monoeg_g_free (D.30540);
  <D.30542>:
  D.30543 = &di->sheap;
  mono_dynamic_stream_reset (D.30543);
  D.30544 = &di->code;
  mono_dynamic_stream_reset (D.30544);
  D.30545 = &di->resources;
  mono_dynamic_stream_reset (D.30545);
  D.30546 = &di->us;
  mono_dynamic_stream_reset (D.30546);
  D.30547 = &di->blob;
  mono_dynamic_stream_reset (D.30547);
  D.30548 = &di->tstream;
  mono_dynamic_stream_reset (D.30548);
  D.30549 = &di->guid;
  mono_dynamic_stream_reset (D.30549);
  i = 0;
  goto <D.20383>;
  <D.20382>:
  D.30550 = di->tables[i].values;
  monoeg_g_free (D.30550);
  i = i + 1;
  <D.20383>:
  if (i <= 44) goto <D.20382>; else goto <D.20384>;
  <D.20384>:
}


free_blob_cache_entry (void * key, void * val, void * user_data)
{
  monoeg_g_free (key);
}


mono_image_basic_init (struct MonoReflectionAssemblyBuilder * assemblyb)
{
  struct MonoVTable * D.30551;
  struct MonoDynamicAssembly * D.30552;
  void * D.30555;
  struct MonoAssembly * D.30556;
  unsigned char D.30557;
  struct MonoString * D.30558;
  char * D.30559;
  struct MonoString * D.30560;
  char * D.30563;
  gchar * D.30565;
  struct MonoString * D.30566;
  char * * parts.290;
  char * D.30570;
  int D.30571;
  short unsigned int D.30572;
  char * * parts.291;
  char * D.30574;
  int D.30575;
  short unsigned int D.30576;
  uint16_t iftmp.292;
  char * D.30578;
  char * * parts.293;
  char * D.30582;
  int D.30583;
  uint16_t iftmp.294;
  int D.30588;
  unsigned int D.30591;
  _Bool D.30592;
  unsigned char D.30593;
  _Bool D.30594;
  unsigned char D.30595;
  struct MonoString * D.30596;
  char * D.30597;
  gchar * D.30598;
  char * D.30599;
  struct MonoImage * D.30600;
  struct MonoArray * D.30601;
  unsigned int D.30604;
  const char * D.30609;
  mono_byte[17] * D.30610;
  char * D.30611;
  union mono_mutex_t * D.30612;
  _Bool D.30615;
  long int D.30616;
  long int D.30617;
  struct GSList * D.30620;
  struct GSList * D.30621;
  _Bool D.30624;
  long int D.30625;
  long int D.30626;
  struct MonoDomain * D.30629;
  struct MonoReflectionAssembly * D.30630;
  struct MonoDynamicAssembly * assembly;
  struct MonoDynamicImage * image;
  struct MonoDomain * domain;

  D.30551 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.30551->domain;
  D.30552 = assemblyb->dynamic_assembly;
  if (D.30552 != 0B) goto <D.30553>; else goto <D.30554>;
  <D.30553>:
  return;
  <D.30554>:
  D.30555 = monoeg_malloc0 (108);
  assemblyb->dynamic_assembly = D.30555;
  assembly = assemblyb->dynamic_assembly;
  D.30556 = &assembly->assembly;
  mono_profiler_assembly_event (D.30556, 0);
  assembly->assembly.ref_count = 1;
  assembly->assembly.dynamic = 1;
  D.30557 = assemblyb->corlib_internal;
  assembly->assembly.corlib_internal = D.30557;
  assemblyb->assembly.assembly = assembly;
  D.30558 = assemblyb->dir;
  D.30559 = mono_string_to_utf8 (D.30558);
  assembly->assembly.basedir = D.30559;
  D.30560 = assemblyb->culture;
  if (D.30560 != 0B) goto <D.30561>; else goto <D.30562>;
  <D.30561>:
  D.30560 = assemblyb->culture;
  D.30563 = mono_string_to_utf8 (D.30560);
  assembly->assembly.aname.culture = D.30563;
  goto <D.30564>;
  <D.30562>:
  D.30565 = monoeg_strdup ("");
  assembly->assembly.aname.culture = D.30565;
  <D.30564>:
  D.30566 = assemblyb->version;
  if (D.30566 != 0B) goto <D.30567>; else goto <D.30568>;
  <D.30567>:
  {
    char * vstr;
    char * * version;
    char * * parts;

    D.30566 = assemblyb->version;
    vstr = mono_string_to_utf8 (D.30566);
    version = monoeg_g_strsplit (vstr, ".", 4);
    parts = version;
    parts.290 = parts;
    parts = parts.290 + 4;
    D.30570 = *parts.290;
    D.30571 = atoi (D.30570);
    D.30572 = (short unsigned int) D.30571;
    assembly->assembly.aname.major = D.30572;
    parts.291 = parts;
    parts = parts.291 + 4;
    D.30574 = *parts.291;
    D.30575 = atoi (D.30574);
    D.30576 = (short unsigned int) D.30575;
    assembly->assembly.aname.minor = D.30576;
    D.30578 = *parts;
    if (D.30578 != 0B) goto <D.30579>; else goto <D.30580>;
    <D.30579>:
    parts.293 = parts;
    parts = parts.293 + 4;
    D.30582 = *parts.293;
    D.30583 = atoi (D.30582);
    iftmp.292 = (uint16_t) D.30583;
    goto <D.30584>;
    <D.30580>:
    iftmp.292 = 0;
    <D.30584>:
    assembly->assembly.aname.build = iftmp.292;
    D.30578 = *parts;
    if (D.30578 != 0B) goto <D.30586>; else goto <D.30587>;
    <D.30586>:
    D.30578 = *parts;
    D.30588 = atoi (D.30578);
    iftmp.294 = (uint16_t) D.30588;
    goto <D.30589>;
    <D.30587>:
    iftmp.294 = 0;
    <D.30589>:
    assembly->assembly.aname.revision = iftmp.294;
    monoeg_g_strfreev (version);
    monoeg_g_free (vstr);
  }
  goto <D.30590>;
  <D.30568>:
  assembly->assembly.aname.major = 0;
  assembly->assembly.aname.minor = 0;
  assembly->assembly.aname.build = 0;
  assembly->assembly.aname.revision = 0;
  <D.30590>:
  D.30591 = assemblyb->access;
  D.30592 = D.30591 != 2;
  D.30593 = (unsigned char) D.30592;
  assembly->run = D.30593;
  D.30591 = assemblyb->access;
  D.30594 = D.30591 != 1;
  D.30595 = (unsigned char) D.30594;
  assembly->save = D.30595;
  assembly->domain = domain;
  D.30596 = assemblyb->name;
  D.30597 = mono_string_to_utf8 (D.30596);
  D.30598 = monoeg_strdup ("RefEmit_YouForgotToDefineAModule");
  image = create_dynamic_mono_image (assembly, D.30597, D.30598);
  image->initial_image = 1;
  D.30599 = image->image.name;
  assembly->assembly.aname.name = D.30599;
  D.30600 = &image->image;
  assembly->assembly.image = D.30600;
  D.30601 = assemblyb->pktoken;
  if (D.30601 != 0B) goto <D.30602>; else goto <D.30603>;
  <D.30602>:
  D.30601 = assemblyb->pktoken;
  D.30604 = D.30601->max_length;
  if (D.30604 != 0) goto <D.30605>; else goto <D.30606>;
  <D.30605>:
  D.30601 = assemblyb->pktoken;
  D.30604 = D.30601->max_length;
  if (D.30604 != 16) goto <D.30607>; else goto <D.30608>;
  <D.30607>:
  D.30609 = assembly->assembly.aname.name;
  D.30601 = assemblyb->pktoken;
  D.30604 = D.30601->max_length;
  monoeg_g_log (0B, 4, "Public key token length invalid for assembly %s: %i", D.30609, D.30604);
  <D.20394>:
  goto <D.20394>;
  <D.30608>:
  D.30610 = &assembly->assembly.aname.public_key_token;
  D.30601 = assemblyb->pktoken;
  D.30611 = mono_array_addr_with_size (D.30601, 1, 0);
  D.30601 = assemblyb->pktoken;
  D.30604 = D.30601->max_length;
  memcpy (D.30610, D.30611, D.30604);
  <D.30606>:
  <D.30603>:
  {
    int ret;

    D.30612 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.30612);
    if (ret != 0) goto <D.30613>; else goto <D.30614>;
    <D.30613>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30614>:
    D.30615 = ret != 0;
    D.30616 = (long int) D.30615;
    D.30617 = __builtin_expect (D.30616, 0);
    if (D.30617 != 0) goto <D.30618>; else goto <D.30619>;
    <D.30618>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5333, "ret == 0");
    <D.30619>:
  }
  D.30620 = domain->domain_assemblies;
  D.30621 = monoeg_g_slist_append (D.30620, assembly);
  domain->domain_assemblies = D.30621;
  {
    int ret;

    D.30612 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.30612);
    if (ret != 0) goto <D.30622>; else goto <D.30623>;
    <D.30622>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30623>:
    D.30624 = ret != 0;
    D.30625 = (long int) D.30624;
    D.30626 = __builtin_expect (D.30625, 0);
    if (D.30626 != 0) goto <D.30627>; else goto <D.30628>;
    <D.30627>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5335, "ret == 0");
    <D.30628>:
  }
  D.30551 = MEM[(struct MonoObject *)assemblyb].vtable;
  D.30629 = D.30551->domain;
  D.30630 = &assemblyb->assembly;
  D.30556 = &assembly->assembly;
  register_assembly (D.30629, D.30630, D.30556);
  D.30556 = &assembly->assembly;
  mono_profiler_assembly_loaded (D.30556, 0);
  mono_assembly_invoke_load_hook (assembly);
}


atoi (const char * __nptr)
{
  int D.30632;

  D.30632 = strtol (__nptr, 0B, 10);
  return D.30632;
}


create_dynamic_mono_image (struct MonoDynamicAssembly * assembly, char * assembly_name, char * module_name)
{
  int D.20353;
  int iftmp.295;
  int D.20352;
  const struct MonoRuntimeInfo * D.30637;
  const char[4] * D.30638;
  unsigned char D.30639;
  int D.30640;
  unsigned char D.30641;
  int D.30642;
  const unsigned char * D.30647;
  unsigned char D.30648;
  int D.30649;
  const unsigned char * D.30650;
  unsigned char D.30651;
  int D.30652;
  const unsigned char * D.30657;
  unsigned char D.30658;
  int D.30659;
  const unsigned char * D.30660;
  unsigned char D.30661;
  int D.30662;
  const unsigned char * D.30667;
  unsigned char D.30668;
  int D.30669;
  const unsigned char * D.30670;
  unsigned char D.30671;
  int D.30672;
  const struct MonoRuntimeInfo * D.30674;
  const char[4] * D.30675;
  const struct MonoRuntimeInfo * D.30679;
  struct MonoImage * D.30680;
  char * D.30681;
  gchar * D.30682;
  void * D.30683;
  struct MonoAssembly * * D.30684;
  struct MonoGHashTable * D.30685;
  struct GHashTable * D.30686;
  struct GHashTable * D.30687;
  struct GHashTable * D.30688;
  struct GHashTable * D.30689;
  struct GHashTable * D.30690;
  struct MonoGHashTable * D.30691;
  struct MonoGHashTable * D.30692;
  struct MonoGHashTable * D.30693;
  struct MonoGHashTable * D.30694;
  struct GHashTable * D.30695;
  struct GHashTable * D.30696;
  struct GHashTable * D.30697;
  struct GPtrArray * D.30698;
  struct MonoGHashTable * D.30699;
  struct MonoDynamicStream * D.30700;
  struct MonoDynamicStream * D.30701;
  struct MonoDynamicStream * D.30702;
  unsigned int D.30703;
  unsigned int D.30704;
  unsigned int D.30705;
  unsigned int D.30706;
  unsigned int D.30707;
  unsigned char D.30708;
  unsigned char D.30709;
  int D.30710;
  unsigned char D.30711;
  int D.30712;
  struct MonoDynamicImage * D.30713;
  static const guchar entrycode[16] = {255, 37, 0};
  struct MonoDynamicImage * image;
  int i;
  const char * version;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.30637 = mono_get_runtime_info ();
      __s2 = &D.30637->framework_version;
      D.30638 = "2.1";
      D.30639 = MEM[(const unsigned char *)D.30638];
      D.30640 = (int) D.30639;
      D.30641 = *__s2;
      D.30642 = (int) D.30641;
      __result = D.30640 - D.30642;
      {
        if (__s2_len != 0) goto <D.30643>; else goto <D.30644>;
        <D.30643>:
        if (__result == 0) goto <D.30645>; else goto <D.30646>;
        <D.30645>:
        D.30647 = &MEM[(void *)"2.1" + 1B];
        D.30648 = *D.30647;
        D.30649 = (int) D.30648;
        D.30650 = __s2 + 1;
        D.30651 = *D.30650;
        D.30652 = (int) D.30651;
        __result = D.30649 - D.30652;
        if (__s2_len > 1) goto <D.30653>; else goto <D.30654>;
        <D.30653>:
        if (__result == 0) goto <D.30655>; else goto <D.30656>;
        <D.30655>:
        D.30657 = &MEM[(void *)"2.1" + 2B];
        D.30658 = *D.30657;
        D.30659 = (int) D.30658;
        D.30660 = __s2 + 2;
        D.30661 = *D.30660;
        D.30662 = (int) D.30661;
        __result = D.30659 - D.30662;
        if (__s2_len > 2) goto <D.30663>; else goto <D.30664>;
        <D.30663>:
        if (__result == 0) goto <D.30665>; else goto <D.30666>;
        <D.30665>:
        D.30667 = &MEM[(void *)"2.1" + 3B];
        D.30668 = *D.30667;
        D.30669 = (int) D.30668;
        D.30670 = __s2 + 3;
        D.30671 = *D.30670;
        D.30672 = (int) D.30671;
        __result = D.30669 - D.30672;
        <D.30666>:
        <D.30664>:
        <D.30656>:
        <D.30654>:
        <D.30646>:
        <D.30644>:
      }
      D.20352 = __result;
    }
    iftmp.295 = -D.20352;
    goto <D.30673>;
    <D.30636>:
    D.30674 = mono_get_runtime_info ();
    D.30675 = &D.30674->framework_version;
    iftmp.295 = __builtin_strcmp (D.30675, "2.1");
    <D.30673>:
    D.20353 = iftmp.295;
  }
  if (D.20353 == 0) goto <D.30676>; else goto <D.30677>;
  <D.30676>:
  version = "v2.0.50727";
  goto <D.30678>;
  <D.30677>:
  D.30679 = mono_get_runtime_info ();
  version = &D.30679->runtime_version;
  <D.30678>:
  image = monoeg_malloc0 (2220);
  D.30680 = &image->image;
  mono_profiler_module_event (D.30680, 0);
  image->image.name = assembly_name;
  D.30681 = image->image.name;
  image->image.assembly_name = D.30681;
  image->image.module_name = module_name;
  D.30682 = monoeg_strdup (version);
  image->image.version = D.30682;
  image->image.md_version_major = 1;
  image->image.md_version_minor = 1;
  image->image.dynamic = 1;
  D.30683 = monoeg_malloc0 (4);
  image->image.references = D.30683;
  D.30684 = image->image.references;
  *D.30684 = 0B;
  D.30680 = &image->image;
  mono_image_init (D.30680);
  D.30685 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->token_fixups = D.30685;
  D.30686 = monoeg_g_hash_table_new (0B, 0B);
  image->method_to_table_idx = D.30686;
  D.30687 = monoeg_g_hash_table_new (0B, 0B);
  image->field_to_table_idx = D.30687;
  D.30688 = monoeg_g_hash_table_new (0B, 0B);
  image->method_aux_hash = D.30688;
  D.30689 = monoeg_g_hash_table_new (0B, 0B);
  image->vararg_aux_hash = D.30689;
  D.30690 = monoeg_g_hash_table_new (0B, 0B);
  image->handleref = D.30690;
  D.30691 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->handleref_managed = D.30691;
  D.30692 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->tokens = D.30692;
  D.30693 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->generic_def_objects = D.30693;
  D.30694 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->methodspec = D.30694;
  D.30695 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typespec = D.30695;
  D.30696 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typeref = D.30696;
  D.30697 = monoeg_g_hash_table_new (mono_blob_entry_hash, mono_blob_entry_equal);
  image->blob_cache = D.30697;
  D.30698 = monoeg_g_ptr_array_new ();
  image->gen_params = D.30698;
  D.30699 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->remapped_tokens = D.30699;
  D.30700 = &image->sheap;
  string_heap_init (D.30700);
  D.30701 = &image->us;
  mono_image_add_stream_data (D.30701, "", 1);
  add_to_blob_cached (image, "", 1, 0B, 0);
  D.30702 = &image->code;
  mono_image_add_stream_data (D.30702, &entrycode, 16);
  D.30702 = &image->code;
  D.30703 = mono_image_add_stream_zero (D.30702, 8);
  image->iat_offset = D.30703;
  D.30702 = &image->code;
  D.30704 = mono_image_add_stream_zero (D.30702, 40);
  image->idt_offset = D.30704;
  D.30702 = &image->code;
  D.30705 = mono_image_add_stream_zero (D.30702, 2);
  image->imp_names_offset = D.30705;
  D.30702 = &image->code;
  mono_image_add_stream_data (D.30702, "_CorExeMain", 12);
  D.30702 = &image->code;
  mono_image_add_stream_data (D.30702, "mscoree.dll", 12);
  D.30702 = &image->code;
  D.30706 = mono_image_add_stream_zero (D.30702, 8);
  image->ilt_offset = D.30706;
  D.30702 = &image->code;
  stream_data_align (D.30702);
  D.30702 = &image->code;
  D.30707 = mono_image_add_stream_zero (D.30702, 136);
  image->cli_header_offset = D.30707;
  i = 0;
  goto <D.20355>;
  <D.20354>:
  image->tables[i].next_idx = 1;
  D.30708 = table_sizes[i];
  image->tables[i].columns = D.30708;
  i = i + 1;
  <D.20355>:
  if (i <= 44) goto <D.20354>; else goto <D.20356>;
  <D.20356>:
  image->image.assembly = assembly;
  D.30709 = assembly->run;
  D.30710 = (int) D.30709;
  image->run = D.30710;
  D.30711 = assembly->save;
  D.30712 = (int) D.30711;
  image->save = D.30712;
  image->pe_kind = 1;
  image->machine = 332;
  D.30680 = &image->image;
  mono_profiler_module_loaded (D.30680, 0);
  D.30713 = image;
  return D.30713;
}


mono_blob_entry_equal (const char * str1, const char * str2)
{
  unsigned int D.30715;
  unsigned int D.30716;
  gboolean D.30719;
  const char * end1.296;
  const char * end2.297;
  unsigned int len.298;
  int D.30723;
  _Bool D.30724;
  int len;
  int len2;
  const char * end1;
  const char * end2;

  try
    {
      D.30715 = mono_metadata_decode_blob_size (str1, &end1);
      len = (int) D.30715;
      D.30716 = mono_metadata_decode_blob_size (str2, &end2);
      len2 = (int) D.30716;
      if (len != len2) goto <D.30717>; else goto <D.30718>;
      <D.30717>:
      D.30719 = 0;
      return D.30719;
      <D.30718>:
      end1.296 = end1;
      end2.297 = end2;
      len.298 = (unsigned int) len;
      D.30723 = memcmp (end1.296, end2.297, len.298);
      D.30724 = D.30723 == 0;
      D.30719 = (gboolean) D.30724;
      return D.30719;
    }
  finally
    {
      end1 = {CLOBBER};
      end2 = {CLOBBER};
    }
}


mono_blob_entry_hash (const char * str)
{
  const char * str.299;
  char D.30730;
  const char * str.300;
  unsigned int D.30732;
  unsigned int D.30733;
  unsigned int D.30734;
  int D.30735;
  guint len;
  guint h;
  const char * end;

  str.299 = str;
  len = mono_metadata_decode_blob_size (str.299, &str);
  if (len != 0) goto <D.30728>; else goto <D.30729>;
  <D.30728>:
  str.299 = str;
  end = str.299 + len;
  str.299 = str;
  D.30730 = *str.299;
  h = (guint) D.30730;
  str.299 = str;
  str.300 = str.299 + 1;
  str = str.300;
  goto <D.18359>;
  <D.18358>:
  D.30732 = h << 5;
  D.30733 = D.30732 - h;
  str.299 = str;
  D.30730 = *str.299;
  D.30734 = (unsigned int) D.30730;
  h = D.30733 + D.30734;
  str.299 = str;
  str.300 = str.299 + 1;
  str = str.300;
  <D.18359>:
  str.299 = str;
  if (str.299 < end) goto <D.18358>; else goto <D.18360>;
  <D.18360>:
  D.30735 = (int) h;
  return D.30735;
  <D.30729>:
  D.30735 = 0;
  return D.30735;
}


string_heap_init (struct MonoDynamicStream * sh)
{
  void * D.30737;
  struct GHashTable * D.30738;

  sh->index = 0;
  sh->alloc_size = 4096;
  D.30737 = monoeg_malloc (4096);
  sh->data = D.30737;
  D.30738 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  sh->hash = D.30738;
  string_heap_insert (sh, "");
}


register_assembly (struct MonoDomain * domain, struct MonoReflectionAssembly * res, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.30739;
  _Bool D.30742;
  long int D.30743;
  long int D.30744;
  struct MonoGHashTable * D.30747;
  struct MonoGHashTable * D.30750;
  struct MonoMemPool * D.30753;
  _Bool D.30756;
  long int D.30757;
  long int D.30758;
  void * D.30761;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = assembly;
        pe.refclass = 0B;
        {
          int ret;

          D.30739 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.30739);
          if (ret != 0) goto <D.30740>; else goto <D.30741>;
          <D.30740>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.30741>:
          D.30742 = ret != 0;
          D.30743 = (long int) D.30742;
          D.30744 = __builtin_expect (D.30743, 0);
          if (D.30744 != 0) goto <D.30745>; else goto <D.30746>;
          <D.30745>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.30746>:
        }
        D.30747 = domain->refobject_hash;
        if (D.30747 == 0B) goto <D.30748>; else goto <D.30749>;
        <D.30748>:
        D.30750 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.30750;
        <D.30749>:
        D.30747 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.30747, &pe);
        if (_obj == 0B) goto <D.30751>; else goto <D.30752>;
        <D.30751>:
        {
          struct ReflectedEntry * e;

          D.30753 = domain->mp;
          e = mono_mempool_alloc (D.30753, 8);
          e->item = assembly;
          e->refclass = 0B;
          D.30747 = domain->refobject_hash;
          mono_g_hash_table_insert (D.30747, e, res);
          _obj = res;
        }
        <D.30752>:
        {
          int ret;

          D.30739 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.30739);
          if (ret != 0) goto <D.30754>; else goto <D.30755>;
          <D.30754>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.30755>:
          D.30756 = ret != 0;
          D.30757 = (long int) D.30756;
          D.30758 = __builtin_expect (D.30757, 0);
          if (D.30758 != 0) goto <D.30759>; else goto <D.30760>;
          <D.30759>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.30760>:
        }
        D.30761 = _obj;
        return D.30761;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


reflected_equal (const void * a, const void * b)
{
  gboolean D.30764;
  int iftmp.301;
  void * D.30768;
  void * D.30769;
  struct MonoClass * D.30771;
  struct MonoClass * D.30772;
  const struct ReflectedEntry * ea;
  const struct ReflectedEntry * eb;

  ea = a;
  eb = b;
  D.30768 = ea->item;
  D.30769 = eb->item;
  if (D.30768 == D.30769) goto <D.30770>; else goto <D.30766>;
  <D.30770>:
  D.30771 = ea->refclass;
  D.30772 = eb->refclass;
  if (D.30771 == D.30772) goto <D.30773>; else goto <D.30766>;
  <D.30773>:
  iftmp.301 = 1;
  goto <D.30767>;
  <D.30766>:
  iftmp.301 = 0;
  <D.30767>:
  D.30764 = iftmp.301;
  return D.30764;
}


reflected_hash (const void * a)
{
  guint D.30775;
  void * D.30776;
  const struct ReflectedEntry * ea;

  ea = a;
  D.30776 = ea->item;
  D.30775 = mono_aligned_addr_hash (D.30776);
  return D.30775;
}


mono_image_create_pefile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  int D.30778;
  unsigned int D.30779;
  int D.30780;
  unsigned int D.30781;
  struct MonoDynamicAssembly * D.30782;
  struct MonoImage * D.30783;
  int D.30784;
  struct MonoArray * D.30787;
  unsigned int D.30790;
  unsigned int i.302;
  char * D.30792;
  struct MonoArray * D.30793;
  unsigned int D.30796;
  char * D.30797;
  unsigned int nsections.303;
  unsigned int D.30803;
  unsigned int D.30804;
  unsigned int D.30807;
  unsigned int D.30808;
  unsigned int D.30809;
  char * D.30810;
  short unsigned int D.30811;
  short unsigned int D.30812;
  long int D.30813;
  unsigned int D.30814;
  unsigned int D.30815;
  unsigned int D.30819;
  _Bool D.30820;
  long int D.30821;
  long int D.30822;
  unsigned int D.30825;
  short unsigned int kind.304;
  unsigned int D.30830;
  unsigned int D.30831;
  unsigned int D.30832;
  unsigned int D.30833;
  unsigned int D.30834;
  unsigned int D.30835;
  unsigned int D.30836;
  unsigned int D.30837;
  char * D.30840;
  unsigned int D.30841;
  sizetype D.30842;
  char * D.30843;
  unsigned int D.30845;
  unsigned int D.30846;
  unsigned int D.30847;
  sizetype D.30848;
  unsigned int D.30849;
  sizetype D.30850;
  unsigned int D.30851;
  unsigned int D.30852;
  guchar * p.305;
  unsigned char D.30854;
  guchar * p.306;
  unsigned int D.30856;
  unsigned char D.30857;
  guchar * p.307;
  unsigned int D.30859;
  unsigned char D.30860;
  guchar * p.308;
  unsigned int D.30862;
  unsigned char D.30863;
  struct MonoReflectionMethod * D.30864;
  int D.20542;
  int iftmp.309;
  int D.20541;
  struct MonoVTable * D.30870;
  struct MonoClass * D.30871;
  const char[14] * D.30872;
  unsigned char D.30873;
  int D.30874;
  unsigned char D.30875;
  int D.30876;
  const unsigned char * D.30881;
  unsigned char D.30882;
  int D.30883;
  const unsigned char * D.30884;
  unsigned char D.30885;
  int D.30886;
  const unsigned char * D.30891;
  unsigned char D.30892;
  int D.30893;
  const unsigned char * D.30894;
  unsigned char D.30895;
  int D.30896;
  const unsigned char * D.30901;
  unsigned char D.30902;
  int D.30903;
  const unsigned char * D.30904;
  unsigned char D.30905;
  int D.30906;
  const char * D.30908;
  struct GHashTable * D.30912;
  struct MonoMethod * D.30913;
  void * D.30914;
  unsigned int D.30915;
  unsigned int D.30917;
  unsigned int D.30918;
  unsigned int D.30919;
  unsigned int D.30920;
  char[8] * D.30925;
  const char[7] * D.30926;
  unsigned int D.30927;
  unsigned int D.30928;
  unsigned int D.30929;
  unsigned int D.30930;
  unsigned int D.30931;
  unsigned int D.30932;
  unsigned int D.30933;
  unsigned int D.30934;
  int D.30937;
  unsigned int D.30938;
  unsigned int D.30941;
  unsigned int D.30942;
  guchar * p.310;
  guchar * p.311;
  guchar * p.312;
  guchar * p.313;
  char * D.30947;
  char * D.30948;
  char * D.30949;
  char * D.30952;
  unsigned int D.30955;
  int file_offset.314;
  unsigned int D.30957;
  unsigned int D.30960;
  int D.30961;
  unsigned int D.30964;
  struct MonoDynamicStream * D.30965;
  struct MonoDynamicStream * D.30966;
  struct MonoDynamicStream * D.30967;
  struct MonoDynamicStream * D.30968;
  struct MonoDynamicStream * D.30969;
  struct GHashTable * D.30970;
  struct MonoMSDOSHeader * msdos;
  struct MonoDotNetHeader * header;
  struct MonoSectionTable * section;
  struct MonoCLIHeader * cli_header;
  guint32 size;
  guint32 image_size;
  guint32 virtual_base;
  guint32 text_offset;
  guint32 header_start;
  guint32 section_start;
  guint32 file_offset;
  guint32 virtual_offset;
  struct MonoDynamicImage * assembly;
  struct MonoReflectionAssemblyBuilder * assemblyb;
  struct MonoDynamicStream pefile_stream;
  struct MonoDynamicStream * pefile;
  int i;
  int nsections;
  guint32 * rva;
  guint32 value;
  guchar * p;
  static const unsigned char msheader[128] = {77, 90, 144, 0, 3, 0, 0, 0, 4, 0, 0, 0, 255, 255, 0, 0, 184, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 14, 31, 186, 14, 0, 180, 9, 205, 33, 184, 1, 76, 205, 33, 84, 104, 105, 115, 32, 112, 114, 111, 103, 114, 97, 109, 32, 99, 97, 110, 110, 111, 116, 32, 98, 101, 32, 114, 117, 110, 32, 105, 110, 32, 68, 79, 83, 32, 109, 111, 100, 101, 46, 13, 13, 10, 36, 0, 0, 0, 0, 0, 0, 0};

  try
    {
      pefile_stream = {};
      pefile = &pefile_stream;
      assemblyb = mb->assemblyb;
      mono_image_basic_init (assemblyb);
      assembly = mb->dynamic_image;
      D.30778 = assemblyb->pe_kind;
      D.30779 = (unsigned int) D.30778;
      assembly->pe_kind = D.30779;
      D.30780 = assemblyb->machine;
      D.30781 = (unsigned int) D.30780;
      assembly->machine = D.30781;
      D.30782 = assemblyb->dynamic_assembly;
      D.30783 = D.30782->assembly.image;
      D.30778 = assemblyb->pe_kind;
      D.30779 = (unsigned int) D.30778;
      MEM[(struct MonoDynamicImage *)D.30783].pe_kind = D.30779;
      D.30782 = assemblyb->dynamic_assembly;
      D.30783 = D.30782->assembly.image;
      D.30780 = assemblyb->machine;
      D.30781 = (unsigned int) D.30780;
      MEM[(struct MonoDynamicImage *)D.30783].machine = D.30781;
      mono_image_build_metadata (mb);
      D.30784 = mb->is_main;
      if (D.30784 != 0) goto <D.30785>; else goto <D.30786>;
      <D.30785>:
      D.30787 = assemblyb->resources;
      if (D.30787 != 0B) goto <D.30788>; else goto <D.30789>;
      <D.30788>:
      {
        int len;

        D.30787 = assemblyb->resources;
        D.30790 = mono_array_length (D.30787);
        len = (int) D.30790;
        i = 0;
        goto <D.20522>;
        <D.20521>:
        D.30787 = assemblyb->resources;
        i.302 = (unsigned int) i;
        D.30792 = mono_array_addr_with_size (D.30787, 24, i.302);
        assembly_add_resource (mb, assembly, D.30792);
        i = i + 1;
        <D.20522>:
        if (i < len) goto <D.20521>; else goto <D.20523>;
        <D.20523>:
      }
      <D.30789>:
      <D.30786>:
      D.30793 = mb->resources;
      if (D.30793 != 0B) goto <D.30794>; else goto <D.30795>;
      <D.30794>:
      {
        int len;

        D.30793 = mb->resources;
        D.30796 = mono_array_length (D.30793);
        len = (int) D.30796;
        i = 0;
        goto <D.20526>;
        <D.20525>:
        D.30793 = mb->resources;
        i.302 = (unsigned int) i;
        D.30797 = mono_array_addr_with_size (D.30793, 24, i.302);
        assembly_add_resource (mb, assembly, D.30797);
        i = i + 1;
        <D.20526>:
        if (i < len) goto <D.20525>; else goto <D.20527>;
        <D.20527>:
      }
      <D.30795>:
      build_compressed_metadata (assembly);
      D.30784 = mb->is_main;
      if (D.30784 != 0) goto <D.30798>; else goto <D.30799>;
      <D.30798>:
      assembly_add_win32_resources (assembly, assemblyb);
      <D.30799>:
      nsections = calc_section_size (assembly);
      if (0 != 0) goto <D.30800>; else goto <D.30801>;
      <D.30800>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5690, "sizeof (MonoMSDOSHeader) == sizeof (msheader)");
      <D.30801>:
      mono_image_add_stream_data (pefile, &msheader, 128);
      header_start = mono_image_add_stream_zero (pefile, 248);
      nsections.303 = (unsigned int) nsections;
      D.30803 = nsections.303 * 40;
      section_start = mono_image_add_stream_zero (pefile, D.30803);
      nsections.303 = (unsigned int) nsections;
      D.30803 = nsections.303 * 40;
      file_offset = D.30803 + section_start;
      virtual_offset = 8192;
      image_size = 0;
      i = 0;
      goto <D.20530>;
      <D.20529>:
      D.30804 = assembly->sections[i].size;
      if (D.30804 == 0) goto <D.30805>; else goto <D.30806>;
      <D.30805>:
      // predicted unlikely by continue predictor.
      goto <D.20528>;
      <D.30806>:
      file_offset = file_offset + 511;
      file_offset = file_offset & 4294966784;
      virtual_offset = virtual_offset + 8191;
      virtual_offset = virtual_offset & 4294959104;
      assembly->sections[i].offset = file_offset;
      assembly->sections[i].rva = virtual_offset;
      D.30804 = assembly->sections[i].size;
      file_offset = D.30804 + file_offset;
      D.30804 = assembly->sections[i].size;
      virtual_offset = D.30804 + virtual_offset;
      D.30804 = assembly->sections[i].size;
      D.30807 = D.30804 + 8191;
      D.30808 = D.30807 & 4294959104;
      image_size = D.30808 + image_size;
      <D.20528>:
      i = i + 1;
      <D.20530>:
      if (i <= 2) goto <D.20529>; else goto <D.20531>;
      <D.20531>:
      file_offset = file_offset + 511;
      file_offset = file_offset & 4294966784;
      nsections.303 = (unsigned int) nsections;
      D.30803 = nsections.303 * 40;
      D.30809 = D.30803 + section_start;
      image_size = D.30809 + image_size;
      msdos = pefile->data;
      msdos->pe_offset = 128;
      D.30810 = pefile->data;
      header = D.30810 + header_start;
      header->pesig[0] = 80;
      header->pesig[1] = 69;
      D.30780 = assemblyb->machine;
      D.30811 = (short unsigned int) D.30780;
      header->coff.coff_machine = D.30811;
      D.30812 = (short unsigned int) nsections;
      header->coff.coff_sections = D.30812;
      D.30813 = time (0B);
      D.30814 = (unsigned int) D.30813;
      header->coff.coff_time = D.30814;
      header->coff.coff_opt_header_size = 224;
      D.30815 = assemblyb->pekind;
      if (D.30815 == 1) goto <D.30816>; else goto <D.30817>;
      <D.30816>:
      header->coff.coff_attributes = 8462;
      goto <D.30818>;
      <D.30817>:
      header->coff.coff_attributes = 270;
      <D.30818>:
      virtual_base = 4194304;
      header->pe.pe_magic = 267;
      header->pe.pe_major = 6;
      header->pe.pe_minor = 0;
      size = assembly->sections[0].size;
      size = size + 511;
      size = size & 4294966784;
      header->pe.pe_code_size = size;
      size = assembly->sections[1].size;
      size = size + 511;
      size = size & 4294966784;
      header->pe.pe_data_size = size;
      D.30819 = assembly->sections[0].rva;
      D.30820 = D.30819 != 8192;
      D.30821 = (long int) D.30820;
      D.30822 = __builtin_expect (D.30821, 0);
      if (D.30822 != 0) goto <D.30823>; else goto <D.30824>;
      <D.30823>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5758, "START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva");
      <D.30824>:
      D.30819 = assembly->sections[0].rva;
      header->pe.pe_rva_code_base = D.30819;
      D.30825 = assembly->sections[1].rva;
      header->pe.pe_rva_data_base = D.30825;
      D.30819 = assembly->sections[0].rva;
      header->pe.pe_rva_entry_point = D.30819;
      header->nt.pe_image_base = virtual_base;
      header->nt.pe_section_align = 8192;
      header->nt.pe_file_alignment = 512;
      header->nt.pe_os_major = 4;
      header->nt.pe_os_minor = 0;
      header->nt.pe_subsys_major = 4;
      size = section_start;
      size = size + 511;
      size = size & 4294966784;
      header->nt.pe_header_size = size;
      size = image_size;
      size = size + 8191;
      size = size & 4294959104;
      header->nt.pe_image_size = size;
      {
        short int kind;

        D.30815 = assemblyb->pekind;
        if (D.30815 == 3) goto <D.30826>; else goto <D.30827>;
        <D.30826>:
        kind = 2;
        goto <D.30828>;
        <D.30827>:
        kind = 3;
        <D.30828>:
        kind.304 = (short unsigned int) kind;
        header->nt.pe_subsys_required = kind.304;
      }
      header->nt.pe_stack_reserve = 1048576;
      header->nt.pe_stack_commit = 4096;
      header->nt.pe_heap_reserve = 1048576;
      header->nt.pe_heap_commit = 4096;
      header->nt.pe_loader_flags = 0;
      header->nt.pe_data_dir_count = 16;
      D.30830 = assembly->sections[1].size;
      header->datadir.pe_resource_table.size = D.30830;
      D.30825 = assembly->sections[1].rva;
      header->datadir.pe_resource_table.rva = D.30825;
      D.30831 = assembly->sections[2].size;
      header->datadir.pe_reloc_table.size = D.30831;
      D.30832 = assembly->sections[2].rva;
      header->datadir.pe_reloc_table.rva = D.30832;
      header->datadir.pe_cli_header.size = 72;
      D.30833 = assembly->text_rva;
      D.30834 = assembly->cli_header_offset;
      D.30835 = D.30833 + D.30834;
      header->datadir.pe_cli_header.rva = D.30835;
      header->datadir.pe_iat.size = 8;
      D.30833 = assembly->text_rva;
      D.30836 = assembly->iat_offset;
      D.30837 = D.30833 + D.30836;
      header->datadir.pe_iat.rva = D.30837;
      D.30815 = assemblyb->pekind;
      if (D.30815 == 1) goto <D.30838>; else goto <D.30839>;
      <D.30838>:
      D.30840 = assembly->code.data;
      D.30841 = assembly->imp_names_offset;
      D.30842 = D.30841 + 2;
      D.30843 = D.30840 + D.30842;
      memcpy (D.30843, "_CorDllMain", 12);
      goto <D.30844>;
      <D.30839>:
      D.30840 = assembly->code.data;
      D.30841 = assembly->imp_names_offset;
      D.30842 = D.30841 + 2;
      D.30843 = D.30840 + D.30842;
      memcpy (D.30843, "_CorExeMain", 12);
      <D.30844>:
      D.30840 = assembly->code.data;
      D.30836 = assembly->iat_offset;
      rva = D.30840 + D.30836;
      D.30833 = assembly->text_rva;
      D.30841 = assembly->imp_names_offset;
      D.30845 = D.30833 + D.30841;
      *rva = D.30845;
      header->datadir.pe_import_table.size = 79;
      D.30833 = assembly->text_rva;
      D.30846 = assembly->idt_offset;
      D.30847 = D.30833 + D.30846;
      header->datadir.pe_import_table.rva = D.30847;
      D.30840 = assembly->code.data;
      D.30846 = assembly->idt_offset;
      D.30848 = D.30846 + 12;
      rva = D.30840 + D.30848;
      D.30833 = assembly->text_rva;
      D.30841 = assembly->imp_names_offset;
      D.30845 = D.30833 + D.30841;
      D.30849 = D.30845 + 14;
      *rva = D.30849;
      D.30840 = assembly->code.data;
      D.30846 = assembly->idt_offset;
      D.30850 = D.30846 + 16;
      rva = D.30840 + D.30850;
      D.30833 = assembly->text_rva;
      D.30836 = assembly->iat_offset;
      D.30837 = D.30833 + D.30836;
      *rva = D.30837;
      D.30840 = assembly->code.data;
      D.30846 = assembly->idt_offset;
      rva = D.30840 + D.30846;
      D.30833 = assembly->text_rva;
      D.30851 = assembly->ilt_offset;
      D.30852 = D.30833 + D.30851;
      *rva = D.30852;
      D.30840 = assembly->code.data;
      D.30851 = assembly->ilt_offset;
      p = D.30840 + D.30851;
      D.30833 = assembly->text_rva;
      D.30841 = assembly->imp_names_offset;
      value = D.30833 + D.30841;
      p.305 = p;
      p = p.305 + 1;
      D.30854 = (unsigned char) value;
      *p.305 = D.30854;
      p.306 = p;
      p = p.306 + 1;
      D.30856 = value >> 8;
      D.30857 = (unsigned char) D.30856;
      *p.306 = D.30857;
      p.307 = p;
      p = p.307 + 1;
      D.30859 = value >> 16;
      D.30860 = (unsigned char) D.30859;
      *p.307 = D.30860;
      p.308 = p;
      p = p.308 + 1;
      D.30862 = value >> 24;
      D.30863 = (unsigned char) D.30862;
      *p.308 = D.30863;
      D.30840 = assembly->code.data;
      D.30834 = assembly->cli_header_offset;
      cli_header = D.30840 + D.30834;
      cli_header->ch_size = 72;
      cli_header->ch_runtime_major = 2;
      cli_header->ch_runtime_minor = 5;
      D.30778 = assemblyb->pe_kind;
      D.30779 = (unsigned int) D.30778;
      cli_header->ch_flags = D.30779;
      D.30864 = assemblyb->entry_point;
      if (D.30864 != 0B) goto <D.30865>; else goto <D.30866>;
      <D.30865>:
      {
        guint32 table_idx;

        table_idx = 0;
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.30864 = assemblyb->entry_point;
            D.30870 = D.30864->object.vtable;
            D.30871 = D.30870->klass;
            __s2 = D.30871->name;
            D.30872 = "MethodBuilder";
            D.30873 = MEM[(const unsigned char *)D.30872];
            D.30874 = (int) D.30873;
            D.30875 = *__s2;
            D.30876 = (int) D.30875;
            __result = D.30874 - D.30876;
            {
              if (__s2_len != 0) goto <D.30877>; else goto <D.30878>;
              <D.30877>:
              if (__result == 0) goto <D.30879>; else goto <D.30880>;
              <D.30879>:
              D.30881 = &MEM[(void *)"MethodBuilder" + 1B];
              D.30882 = *D.30881;
              D.30883 = (int) D.30882;
              D.30884 = __s2 + 1;
              D.30885 = *D.30884;
              D.30886 = (int) D.30885;
              __result = D.30883 - D.30886;
              if (__s2_len > 1) goto <D.30887>; else goto <D.30888>;
              <D.30887>:
              if (__result == 0) goto <D.30889>; else goto <D.30890>;
              <D.30889>:
              D.30891 = &MEM[(void *)"MethodBuilder" + 2B];
              D.30892 = *D.30891;
              D.30893 = (int) D.30892;
              D.30894 = __s2 + 2;
              D.30895 = *D.30894;
              D.30896 = (int) D.30895;
              __result = D.30893 - D.30896;
              if (__s2_len > 2) goto <D.30897>; else goto <D.30898>;
              <D.30897>:
              if (__result == 0) goto <D.30899>; else goto <D.30900>;
              <D.30899>:
              D.30901 = &MEM[(void *)"MethodBuilder" + 3B];
              D.30902 = *D.30901;
              D.30903 = (int) D.30902;
              D.30904 = __s2 + 3;
              D.30905 = *D.30904;
              D.30906 = (int) D.30905;
              __result = D.30903 - D.30906;
              <D.30900>:
              <D.30898>:
              <D.30890>:
              <D.30888>:
              <D.30880>:
              <D.30878>:
            }
            D.20541 = __result;
          }
          iftmp.309 = -D.20541;
          goto <D.30907>;
          <D.30869>:
          D.30864 = assemblyb->entry_point;
          D.30870 = D.30864->object.vtable;
          D.30871 = D.30870->klass;
          D.30908 = D.30871->name;
          iftmp.309 = __builtin_strcmp (D.30908, "MethodBuilder");
          <D.30907>:
          D.20542 = iftmp.309;
        }
        if (D.20542 == 0) goto <D.30909>; else goto <D.30910>;
        <D.30909>:
        {
          struct MonoReflectionMethodBuilder * methodb;

          methodb = assemblyb->entry_point;
          table_idx = methodb->table_idx;
        }
        goto <D.30911>;
        <D.30910>:
        D.30912 = assembly->method_to_table_idx;
        D.30864 = assemblyb->entry_point;
        D.30913 = D.30864->method;
        D.30914 = monoeg_g_hash_table_lookup (D.30912, D.30913);
        table_idx = (guint32) D.30914;
        <D.30911>:
        D.30915 = table_idx | 100663296;
        cli_header->ch_entry_point = D.30915;
      }
      goto <D.30916>;
      <D.30866>:
      cli_header->ch_entry_point = 0;
      <D.30916>:
      D.30833 = assembly->text_rva;
      D.30917 = assembly->code.index;
      text_offset = D.30833 + D.30917;
      cli_header->ch_resources.rva = text_offset;
      D.30918 = assembly->resources.index;
      cli_header->ch_resources.size = D.30918;
      D.30918 = assembly->resources.index;
      text_offset = D.30918 + text_offset;
      cli_header->ch_metadata.rva = text_offset;
      D.30919 = assembly->meta_size;
      cli_header->ch_metadata.size = D.30919;
      D.30919 = assembly->meta_size;
      text_offset = D.30919 + text_offset;
      D.30920 = assembly->strong_name_size;
      if (D.30920 != 0) goto <D.30921>; else goto <D.30922>;
      <D.30921>:
      cli_header->ch_strong_name.rva = text_offset;
      D.30920 = assembly->strong_name_size;
      cli_header->ch_strong_name.size = D.30920;
      D.30920 = assembly->strong_name_size;
      text_offset = D.30920 + text_offset;
      <D.30922>:
      D.30810 = pefile->data;
      section = D.30810 + section_start;
      i = 0;
      goto <D.20547>;
      <D.20546>:
      {
        static const char section_names[3][7] = {".text", ".rsrc", ".reloc"};

        D.30804 = assembly->sections[i].size;
        if (D.30804 == 0) goto <D.30923>; else goto <D.30924>;
        <D.30923>:
        // predicted unlikely by continue predictor.
        goto <D.20545>;
        <D.30924>:
        D.30925 = &section->st_name;
        D.30926 = &section_names[i];
        strcpy (D.30925, D.30926);
        D.30927 = assembly->sections[i].rva;
        section->st_virtual_address = D.30927;
        D.30804 = assembly->sections[i].size;
        section->st_virtual_size = D.30804;
        D.30928 = section->st_virtual_size;
        D.30929 = D.30928 + 511;
        section->st_raw_data_size = D.30929;
        D.30930 = section->st_raw_data_size;
        D.30931 = D.30930 & 4294966784;
        section->st_raw_data_size = D.30931;
        D.30932 = assembly->sections[i].offset;
        section->st_raw_data_ptr = D.30932;
        D.30933 = assembly->sections[i].attrs;
        section->st_flags = D.30933;
        section = section + 40;
      }
      <D.20545>:
      i = i + 1;
      <D.20547>:
      if (i <= 2) goto <D.20546>; else goto <D.20548>;
      <D.20548>:
      D.30810 = pefile->data;
      D.30934 = pefile->index;
      checked_write_file (file, D.30810, D.30934);
      mono_dynamic_stream_reset (pefile);
      i = 0;
      goto <D.20563>;
      <D.20562>:
      D.30804 = assembly->sections[i].size;
      if (D.30804 == 0) goto <D.30935>; else goto <D.30936>;
      <D.30935>:
      // predicted unlikely by continue predictor.
      goto <D.20549>;
      <D.30936>:
      D.30932 = assembly->sections[i].offset;
      D.30937 = (int) D.30932;
      D.30938 = SetFilePointer (file, D.30937, 0B, 0);
      if (D.30938 == 4294967295) goto <D.30939>; else goto <D.30940>;
      <D.30939>:
      D.30941 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.30941);
      <D.20550>:
      goto <D.20550>;
      <D.30940>:
      switch (i) <default: <D.20561>, case 0: <D.20551>, case 1: <D.20560>, case 2: <D.20553>>
      <D.20551>:
      D.30840 = assembly->code.data;
      p = D.30840 + 2;
      D.30833 = assembly->text_rva;
      D.30942 = D.30833 + virtual_base;
      D.30836 = assembly->iat_offset;
      value = D.30942 + D.30836;
      p.310 = p;
      p = p.310 + 1;
      D.30854 = (unsigned char) value;
      *p.310 = D.30854;
      p.311 = p;
      p = p.311 + 1;
      D.30856 = value >> 8;
      D.30857 = (unsigned char) D.30856;
      *p.311 = D.30857;
      p.312 = p;
      p = p.312 + 1;
      D.30859 = value >> 16;
      D.30860 = (unsigned char) D.30859;
      *p.312 = D.30860;
      p.313 = p;
      p = p.313 + 1;
      D.30862 = value >> 24;
      D.30863 = (unsigned char) D.30862;
      *p.313 = D.30863;
      D.30840 = assembly->code.data;
      D.30917 = assembly->code.index;
      checked_write_file (file, D.30840, D.30917);
      D.30947 = assembly->resources.data;
      D.30918 = assembly->resources.index;
      checked_write_file (file, D.30947, D.30918);
      D.30948 = assembly->image.raw_metadata;
      D.30919 = assembly->meta_size;
      checked_write_file (file, D.30948, D.30919);
      D.30949 = assembly->strong_name;
      D.30920 = assembly->strong_name_size;
      checked_write_file (file, D.30949, D.30920);
      D.30948 = assembly->image.raw_metadata;
      monoeg_g_free (D.30948);
      goto <D.20552>;
      <D.20553>:
      {
        typedef struct 
      {
        guint32 page_rva;
        guint32 block_size;
        guint16 type_and_offset;
        guint16 term;
      } struct struct 
      {
        guint32 page_rva;
        guint32 block_size;
        guint16 type_and_offset;
        guint16 term;
      };
        struct 
      {
        guint32 page_rva;
        guint32 block_size;
        guint16 type_and_offset;
        guint16 term;
      } reloc;

        try
          {
            if (0 != 0) goto <D.30950>; else goto <D.30951>;
            <D.30950>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5935, "sizeof (reloc) == 12");
            <D.30951>:
            D.30833 = assembly->text_rva;
            reloc.page_rva = D.30833;
            reloc.block_size = 12;
            reloc.type_and_offset = 12290;
            reloc.term = 0;
            checked_write_file (file, &reloc, 12);
            goto <D.20552>;
          }
        finally
          {
            reloc = {CLOBBER};
          }
      }
      <D.20560>:
      D.30952 = assembly->win32_res;
      if (D.30952 != 0B) goto <D.30953>; else goto <D.30954>;
      <D.30953>:
      D.30952 = assembly->win32_res;
      D.30952 = assembly->win32_res;
      D.30927 = assembly->sections[i].rva;
      fixup_resource_directory (D.30952, D.30952, D.30927);
      D.30952 = assembly->win32_res;
      D.30955 = assembly->win32_res_size;
      checked_write_file (file, D.30952, D.30955);
      <D.30954>:
      goto <D.20552>;
      <D.20561>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 5961);
      <D.20552>:
      <D.20549>:
      i = i + 1;
      <D.20563>:
      if (i <= 2) goto <D.20562>; else goto <D.20564>;
      <D.20564>:
      file_offset.314 = (int) file_offset;
      D.30957 = SetFilePointer (file, file_offset.314, 0B, 0);
      if (D.30957 == 4294967295) goto <D.30958>; else goto <D.30959>;
      <D.30958>:
      D.30960 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.30960);
      <D.20565>:
      goto <D.20565>;
      <D.30959>:
      D.30961 = SetEndOfFile (file);
      if (D.30961 == 0) goto <D.30962>; else goto <D.30963>;
      <D.30962>:
      D.30964 = GetLastError ();
      monoeg_g_log (0B, 4, "SetEndOfFile returned %d\n", D.30964);
      <D.20566>:
      goto <D.20566>;
      <D.30963>:
      D.30965 = &assembly->code;
      mono_dynamic_stream_reset (D.30965);
      D.30966 = &assembly->us;
      mono_dynamic_stream_reset (D.30966);
      D.30967 = &assembly->blob;
      mono_dynamic_stream_reset (D.30967);
      D.30968 = &assembly->guid;
      mono_dynamic_stream_reset (D.30968);
      D.30969 = &assembly->sheap;
      mono_dynamic_stream_reset (D.30969);
      D.30970 = assembly->blob_cache;
      monoeg_g_hash_table_foreach (D.30970, monoeg_g_free, 0B);
      D.30970 = assembly->blob_cache;
      monoeg_g_hash_table_destroy (D.30970);
      assembly->blob_cache = 0B;
    }
  finally
    {
      pefile_stream = {CLOBBER};
    }
}


assembly_add_resource (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc)
{
  struct MonoString * D.30973;
  unsigned int D.30976;
  unsigned int D.30977;
  guint32 * D.30978;
  unsigned int D.30979;
  unsigned int D.30980;
  guint32 * D.30981;
  struct MonoDynamicStream * D.30982;
  unsigned int D.30983;
  char * b.315;
  guint32 * D.30985;
  struct MonoDynamicStream * D.30986;
  int b.316;
  int blob_size.317;
  int D.30989;
  unsigned int D.30990;
  unsigned int D.30991;
  unsigned int idx.318;
  unsigned int D.30993;
  struct MonoArray * D.30995;
  char D.30999;
  unsigned int D.31000;
  char D.31001;
  unsigned int D.31002;
  char D.31003;
  unsigned int D.31004;
  char D.31005;
  struct MonoDynamicStream * D.31006;
  unsigned int D.31007;
  int D.31008;
  struct MonoDynamicTable * table;
  guint32 * values;
  char blob_size[6];
  guchar hash[20];
  char * b;
  char * name;
  char * sname;
  guint32 idx;
  guint32 offset;

  try
    {
      b = &blob_size;
      D.30973 = rsrc->filename;
      if (D.30973 != 0B) goto <D.30974>; else goto <D.30975>;
      <D.30974>:
      D.30973 = rsrc->filename;
      name = mono_string_to_utf8 (D.30973);
      sname = monoeg_g_path_get_basename (name);
      table = &assembly->tables[38];
      D.30976 = table->rows;
      D.30977 = D.30976 + 1;
      table->rows = D.30977;
      D.30976 = table->rows;
      alloc_table (table, D.30976);
      D.30978 = table->values;
      D.30979 = table->next_idx;
      D.30980 = D.30979 * 12;
      values = D.30978 + D.30980;
      *values = 1;
      D.30981 = values + 4;
      D.30982 = &assembly->sheap;
      D.30983 = string_heap_insert (D.30982, sname);
      *D.30981 = D.30983;
      monoeg_g_free (sname);
      mono_sha1_get_digest_from_file (name, &hash);
      b.315 = b;
      mono_metadata_encode_value (20, b.315, &b);
      D.30985 = values + 8;
      D.30986 = &assembly->blob;
      b.315 = b;
      b.316 = (int) b.315;
      blob_size.317 = (int) &blob_size;
      D.30989 = b.316 - blob_size.317;
      D.30990 = (unsigned int) D.30989;
      D.30991 = mono_image_add_stream_data (D.30986, &blob_size, D.30990);
      *D.30985 = D.30991;
      D.30986 = &assembly->blob;
      mono_image_add_stream_data (D.30986, &hash, 20);
      monoeg_g_free (name);
      D.30979 = table->next_idx;
      idx.318 = D.30979;
      D.30993 = idx.318 + 1;
      table->next_idx = D.30993;
      idx = idx.318;
      rsrc->offset = 0;
      idx = idx << 2;
      goto <D.30994>;
      <D.30975>:
      {
        char sizebuf[4];
        char * data;
        guint len;

        try
          {
            D.30995 = rsrc->data;
            if (D.30995 != 0B) goto <D.30996>; else goto <D.30997>;
            <D.30996>:
            D.30995 = rsrc->data;
            data = mono_array_addr_with_size (D.30995, 1, 0);
            D.30995 = rsrc->data;
            len = mono_array_length (D.30995);
            goto <D.30998>;
            <D.30997>:
            data = 0B;
            len = 0;
            <D.30998>:
            offset = len;
            D.30999 = (char) offset;
            sizebuf[0] = D.30999;
            D.31000 = offset >> 8;
            D.31001 = (char) D.31000;
            sizebuf[1] = D.31001;
            D.31002 = offset >> 16;
            D.31003 = (char) D.31002;
            sizebuf[2] = D.31003;
            D.31004 = offset >> 24;
            D.31005 = (char) D.31004;
            sizebuf[3] = D.31005;
            D.31006 = &assembly->resources;
            D.31007 = mono_image_add_stream_data (D.31006, &sizebuf, 4);
            rsrc->offset = D.31007;
            D.31006 = &assembly->resources;
            mono_image_add_stream_data (D.31006, data, len);
            D.31008 = mb->is_main;
            if (D.31008 == 0) goto <D.31009>; else goto <D.31010>;
            <D.31009>:
            return;
            <D.31010>:
            idx = 0;
          }
        finally
          {
            sizebuf = {CLOBBER};
          }
      }
      <D.30994>:
      assembly_add_resource_manifest (mb, assembly, rsrc, idx);
    }
  finally
    {
      blob_size = {CLOBBER};
      hash = {CLOBBER};
      b = {CLOBBER};
    }
}


build_compressed_metadata (struct MonoDynamicImage * assembly)
{
  struct GPtrArray * D.31016;
  void * * D.31017;
  unsigned int D.31018;
  unsigned int i.319;
  unsigned int D.31020;
  void * * D.31021;
  unsigned int i.320;
  struct MonoDynamicStream * D.31023;
  struct MonoDynamicStream * D.31024;
  struct MonoDynamicStream * D.31025;
  struct MonoDynamicStream * D.31026;
  struct MonoDynamicStream * D.31027;
  unsigned int D.31028;
  _Bool D.31029;
  unsigned int D.31030;
  _Bool D.31031;
  unsigned int D.31032;
  _Bool D.31033;
  unsigned int D.31034;
  unsigned int D.31035;
  <unnamed-unsigned:24> D.31036;
  <unnamed-unsigned:24> D.31037;
  long long unsigned int D.31040;
  guint32 * D.31041;
  int D.31042;
  unsigned char D.31043;
  unsigned char D.31044;
  int D.31045;
  int D.31046;
  int D.31047;
  unsigned int D.31048;
  unsigned int D.31049;
  void * D.31050;
  unsigned char * p.321;
  unsigned char * p.322;
  unsigned char * p.323;
  unsigned char * p.324;
  guint16 * int16val.325;
  short int D.31056;
  short unsigned int D.31057;
  short int D.31058;
  short unsigned int D.31059;
  char * D.31060;
  unsigned int D.31061;
  unsigned int D.31062;
  unsigned int D.31063;
  unsigned int D.31064;
  unsigned int D.31065;
  int p.326;
  char * D.31067;
  int D.31068;
  int D.31069;
  unsigned int D.31070;
  unsigned int D.31073;
  guint16 * int16val.327;
  int D.31075;
  struct MonoDynamicStream * D.31076;
  guint32 * int32val.328;
  unsigned int D.31078;
  const char * D.31079;
  unsigned int D.31080;
  sizetype D.31081;
  unsigned int D.31082;
  unsigned int D.31085;
  unsigned int D.31086;
  unsigned int D.31087;
  _Bool D.31088;
  long int D.31089;
  long int D.31090;
  unsigned char * p.329;
  unsigned char * p.330;
  unsigned int D.31095;
  unsigned int D.31096;
  unsigned char D.31099;
  unsigned char D.31100;
  unsigned int D.31101;
  unsigned char D.31104;
  unsigned int D.31105;
  unsigned char D.31108;
  unsigned char * p.331;
  guint64 * int64val.332;
  guint64 * int64val.333;
  long long unsigned int D.31112;
  guint32 * int32val.334;
  unsigned int D.31116;
  unsigned int D.31117;
  guint32 * D.31120;
  void * D.31121;
  void * D.31124;
  void * D.31129;
  unsigned char D.31138;
  unsigned int D.31139;
  unsigned int D.31140;
  int D.31143;
  guint32 * D.31144;
  int D.31145;
  unsigned int D.31146;
  unsigned int D.31147;
  int D.31148;
  unsigned int D.31149;
  unsigned int D.31150;
  unsigned int D.31151;
  unsigned char * p.335;
  unsigned int col.336;
  unsigned int D.31154;
  guint32 * D.31155;
  unsigned int D.31156;
  unsigned char D.31157;
  unsigned char * p.337;
  unsigned char * p.338;
  unsigned int D.31160;
  unsigned char D.31161;
  unsigned char * p.339;
  unsigned char * p.340;
  unsigned char * p.341;
  unsigned int D.31165;
  unsigned char D.31166;
  unsigned char * p.342;
  unsigned int D.31168;
  unsigned char D.31169;
  const char * D.31170;
  int D.31171;
  int D.31172;
  _Bool D.31173;
  long int D.31174;
  long int D.31175;
  unsigned int D.31178;
  unsigned int D.31179;
  _Bool D.31180;
  long int D.31181;
  long int D.31182;
  unsigned int D.31185;
  char * D.31186;
  char * D.31187;
  unsigned int D.31188;
  char * D.31189;
  char * D.31190;
  unsigned int D.31191;
  char * D.31192;
  char * D.31193;
  char * D.31194;
  char * D.31195;
  struct MonoDynamicTable * table;
  int i;
  guint64 valid_mask;
  guint64 sorted_mask;
  guint32 heapt_size;
  guint32 meta_size;
  guint32 table_offset;
  guint32 ntables;
  guint64 * int64val;
  guint32 * int32val;
  guint16 * int16val;
  struct MonoImage * meta;
  unsigned char * p;
  struct StreamDesc stream_desc[5];

  try
    {
      valid_mask = 0;
      heapt_size = 0;
      meta_size = 256;
      ntables = 0;
      D.31016 = assembly->gen_params;
      D.31017 = D.31016->pdata;
      D.31016 = assembly->gen_params;
      D.31018 = D.31016->len;
      qsort (D.31017, D.31018, 4, compare_genericparam);
      i = 0;
      goto <D.19615>;
      <D.19614>:
      {
        struct GenericParamTableEntry * entry;

        D.31016 = assembly->gen_params;
        D.31017 = D.31016->pdata;
        i.319 = (unsigned int) i;
        D.31020 = i.319 * 4;
        D.31021 = D.31017 + D.31020;
        entry = *D.31021;
        write_generic_param_entry (assembly, entry);
      }
      i = i + 1;
      <D.19615>:
      i.320 = (unsigned int) i;
      D.31016 = assembly->gen_params;
      D.31018 = D.31016->len;
      if (i.320 < D.31018) goto <D.19614>; else goto <D.19616>;
      <D.19616>:
      stream_desc[0].name = "#~";
      D.31023 = &assembly->tstream;
      stream_desc[0].stream = D.31023;
      stream_desc[1].name = "#Strings";
      D.31024 = &assembly->sheap;
      stream_desc[1].stream = D.31024;
      stream_desc[2].name = "#US";
      D.31025 = &assembly->us;
      stream_desc[2].stream = D.31025;
      stream_desc[3].name = "#Blob";
      D.31026 = &assembly->blob;
      stream_desc[3].stream = D.31026;
      stream_desc[4].name = "#GUID";
      D.31027 = &assembly->guid;
      stream_desc[4].stream = D.31027;
      sorted_mask = 6597925534208;
      meta = &assembly->image;
      D.31026 = &assembly->blob;
      pad_heap (D.31026);
      D.31027 = &assembly->guid;
      pad_heap (D.31027);
      D.31024 = &assembly->sheap;
      pad_heap (D.31024);
      D.31025 = &assembly->us;
      pad_heap (D.31025);
      D.31028 = assembly->blob.index;
      D.31029 = D.31028 > 65535;
      meta->idx_blob_wide = D.31029;
      D.31030 = assembly->guid.index;
      D.31031 = D.31030 > 65535;
      meta->idx_guid_wide = D.31031;
      D.31032 = assembly->sheap.index;
      D.31033 = D.31032 > 65535;
      meta->idx_string_wide = D.31033;
      D.31028 = assembly->blob.index;
      meta_size = D.31028 + meta_size;
      D.31030 = assembly->guid.index;
      meta_size = D.31030 + meta_size;
      D.31032 = assembly->sheap.index;
      meta_size = D.31032 + meta_size;
      D.31034 = assembly->us.index;
      meta_size = D.31034 + meta_size;
      i = 0;
      goto <D.19618>;
      <D.19617>:
      D.31035 = assembly->tables[i].rows;
      D.31036 = (<unnamed-unsigned:24>) D.31035;
      meta->tables[i].rows = D.31036;
      i = i + 1;
      <D.19618>:
      if (i <= 44) goto <D.19617>; else goto <D.19619>;
      <D.19619>:
      i = 0;
      goto <D.19622>;
      <D.19621>:
      D.31037 = meta->tables[i].rows;
      if (D.31037 == 0) goto <D.31038>; else goto <D.31039>;
      <D.31038>:
      // predicted unlikely by continue predictor.
      goto <D.19620>;
      <D.31039>:
      D.31040 = 1 << i;
      valid_mask = D.31040 | valid_mask;
      ntables = ntables + 1;
      D.31041 = &meta->tables[i].size_bitfield;
      D.31042 = mono_metadata_compute_size (meta, i, D.31041);
      D.31043 = (unsigned char) D.31042;
      meta->tables[i].row_size = D.31043;
      D.31044 = meta->tables[i].row_size;
      D.31045 = (int) D.31044;
      D.31037 = meta->tables[i].rows;
      D.31046 = (int) D.31037;
      D.31047 = D.31045 * D.31046;
      D.31048 = (unsigned int) D.31047;
      heapt_size = D.31048 + heapt_size;
      <D.19620>:
      i = i + 1;
      <D.19622>:
      if (i <= 44) goto <D.19621>; else goto <D.19623>;
      <D.19623>:
      heapt_size = heapt_size + 24;
      D.31049 = ntables * 4;
      heapt_size = D.31049 + heapt_size;
      heapt_size = heapt_size + 3;
      heapt_size = heapt_size & 4294967292;
      meta_size = meta_size + heapt_size;
      D.31050 = monoeg_malloc0 (meta_size);
      meta->raw_metadata = D.31050;
      p = meta->raw_metadata;
      p.321 = p;
      p = p.321 + 1;
      *p.321 = 66;
      p.322 = p;
      p = p.322 + 1;
      *p.322 = 83;
      p.323 = p;
      p = p.323 + 1;
      *p.323 = 74;
      p.324 = p;
      p = p.324 + 1;
      *p.324 = 66;
      int16val = p;
      int16val.325 = int16val;
      int16val = int16val.325 + 2;
      D.31056 = meta->md_version_major;
      D.31057 = (short unsigned int) D.31056;
      *int16val.325 = D.31057;
      D.31058 = meta->md_version_minor;
      D.31059 = (short unsigned int) D.31058;
      *int16val = D.31059;
      p = p + 8;
      int32val = p;
      D.31060 = meta->version;
      D.31061 = strlen (D.31060);
      D.31062 = D.31061 + 3;
      D.31063 = D.31062 & 4294967292;
      *int32val = D.31063;
      p = p + 4;
      D.31060 = meta->version;
      D.31060 = meta->version;
      D.31064 = strlen (D.31060);
      memcpy (p, D.31060, D.31064);
      D.31065 = *int32val;
      p = p + D.31065;
      {
        guint32 __diff;

        p.326 = (int) p;
        D.31067 = meta->raw_metadata;
        D.31068 = (int) D.31067;
        D.31069 = p.326 - D.31068;
        __diff = (guint32) D.31069;
        D.31070 = __diff & 3;
        if (D.31070 != 0) goto <D.31071>; else goto <D.31072>;
        <D.31071>:
        D.31070 = __diff & 3;
        D.31073 = 4 - D.31070;
        p = p + D.31073;
        <D.31072>:
      }
      int16val = p;
      int16val.327 = int16val;
      int16val = int16val.327 + 2;
      *int16val.327 = 0;
      *int16val = 5;
      p = p + 4;
      p.326 = (int) p;
      D.31067 = meta->raw_metadata;
      D.31068 = (int) D.31067;
      D.31069 = p.326 - D.31068;
      D.31075 = D.31069 + 80;
      table_offset = (guint32) D.31075;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      assembly->tstream.index = heapt_size;
      i = 0;
      goto <D.19627>;
      <D.19626>:
      int32val = p;
      D.31076 = stream_desc[i].stream;
      D.31076->offset = table_offset;
      int32val.328 = int32val;
      int32val = int32val.328 + 4;
      *int32val.328 = table_offset;
      D.31076 = stream_desc[i].stream;
      D.31078 = D.31076->index;
      *int32val = D.31078;
      D.31065 = *int32val;
      table_offset = D.31065 + table_offset;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      p = p + 8;
      D.31079 = stream_desc[i].name;
      strcpy (p, D.31079);
      D.31079 = stream_desc[i].name;
      D.31080 = strlen (D.31079);
      D.31081 = D.31080 + 1;
      p = p + D.31081;
      {
        guint32 __diff;

        p.326 = (int) p;
        D.31067 = meta->raw_metadata;
        D.31068 = (int) D.31067;
        D.31069 = p.326 - D.31068;
        __diff = (guint32) D.31069;
        D.31082 = __diff & 3;
        if (D.31082 != 0) goto <D.31083>; else goto <D.31084>;
        <D.31083>:
        D.31082 = __diff & 3;
        D.31085 = 4 - D.31082;
        p = p + D.31085;
        <D.31084>:
      }
      i = i + 1;
      <D.19627>:
      if (i <= 4) goto <D.19626>; else goto <D.19628>;
      <D.19628>:
      p.326 = (int) p;
      D.31067 = meta->raw_metadata;
      D.31068 = (int) D.31067;
      D.31069 = p.326 - D.31068;
      D.31086 = (unsigned int) D.31069;
      D.31087 = assembly->tstream.offset;
      D.31088 = D.31086 >= D.31087;
      D.31089 = (long int) D.31088;
      D.31090 = __builtin_expect (D.31089, 0);
      if (D.31090 != 0) goto <D.31091>; else goto <D.31092>;
      <D.31091>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4106, "(p - (unsigned char*)meta->raw_metadata) < assembly->tstream.offset");
      <D.31092>:
      D.31067 = meta->raw_metadata;
      D.31087 = assembly->tstream.offset;
      p = D.31067 + D.31087;
      int32val = p;
      *int32val = 0;
      p = p + 4;
      p.329 = p;
      p = p.329 + 1;
      *p.329 = 2;
      p.330 = p;
      p = p.330 + 1;
      *p.330 = 0;
      D.31095 = BIT_FIELD_REF <*meta, 32, 128>;
      D.31096 = D.31095 & 256;
      if (D.31096 != 0) goto <D.31097>; else goto <D.31098>;
      <D.31097>:
      D.31099 = *p;
      D.31100 = D.31099 | 1;
      *p = D.31100;
      <D.31098>:
      D.31095 = BIT_FIELD_REF <*meta, 32, 128>;
      D.31101 = D.31095 & 512;
      if (D.31101 != 0) goto <D.31102>; else goto <D.31103>;
      <D.31102>:
      D.31099 = *p;
      D.31104 = D.31099 | 2;
      *p = D.31104;
      <D.31103>:
      D.31095 = BIT_FIELD_REF <*meta, 32, 128>;
      D.31105 = D.31095 & 1024;
      if (D.31105 != 0) goto <D.31106>; else goto <D.31107>;
      <D.31106>:
      D.31099 = *p;
      D.31108 = D.31099 | 4;
      *p = D.31108;
      <D.31107>:
      p = p + 1;
      p.331 = p;
      p = p.331 + 1;
      *p.331 = 1;
      int64val = p;
      int64val.332 = int64val;
      int64val = int64val.332 + 8;
      *int64val.332 = valid_mask;
      int64val.333 = int64val;
      int64val = int64val.333 + 8;
      D.31112 = valid_mask & sorted_mask;
      *int64val.333 = D.31112;
      p = p + 16;
      int32val = p;
      i = 0;
      goto <D.19631>;
      <D.19630>:
      D.31037 = meta->tables[i].rows;
      if (D.31037 == 0) goto <D.31113>; else goto <D.31114>;
      <D.31113>:
      // predicted unlikely by continue predictor.
      goto <D.19629>;
      <D.31114>:
      int32val.334 = int32val;
      int32val = int32val.334 + 4;
      D.31037 = meta->tables[i].rows;
      D.31116 = (unsigned int) D.31037;
      *int32val.334 = D.31116;
      <D.19629>:
      i = i + 1;
      <D.19631>:
      if (i <= 44) goto <D.19630>; else goto <D.19632>;
      <D.19632>:
      p = int32val;
      table = &assembly->tables[11];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31118>; else goto <D.31119>;
      <D.31118>:
      D.31120 = table->values;
      D.31121 = D.31120 + 16;
      D.31117 = table->rows;
      qsort (D.31121, D.31117, 16, compare_constants);
      <D.31119>:
      table = &assembly->tables[24];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31122>; else goto <D.31123>;
      <D.31122>:
      D.31120 = table->values;
      D.31124 = D.31120 + 12;
      D.31117 = table->rows;
      qsort (D.31124, D.31117, 12, compare_semantics);
      <D.31123>:
      table = &assembly->tables[12];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31125>; else goto <D.31126>;
      <D.31125>:
      D.31120 = table->values;
      D.31124 = D.31120 + 12;
      D.31117 = table->rows;
      qsort (D.31124, D.31117, 12, compare_custom_attrs);
      <D.31126>:
      table = &assembly->tables[13];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31127>; else goto <D.31128>;
      <D.31127>:
      D.31120 = table->values;
      D.31129 = D.31120 + 8;
      D.31117 = table->rows;
      qsort (D.31129, D.31117, 8, compare_field_marshal);
      <D.31128>:
      table = &assembly->tables[41];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31130>; else goto <D.31131>;
      <D.31130>:
      D.31120 = table->values;
      D.31129 = D.31120 + 8;
      D.31117 = table->rows;
      qsort (D.31129, D.31117, 8, compare_nested);
      <D.31131>:
      table = &assembly->tables[14];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31132>; else goto <D.31133>;
      <D.31132>:
      D.31120 = table->values;
      D.31124 = D.31120 + 12;
      D.31117 = table->rows;
      qsort (D.31124, D.31117, 12, compare_declsecurity_attrs);
      <D.31133>:
      table = &assembly->tables[9];
      D.31117 = table->rows;
      if (D.31117 != 0) goto <D.31134>; else goto <D.31135>;
      <D.31134>:
      D.31120 = table->values;
      D.31129 = D.31120 + 8;
      D.31117 = table->rows;
      qsort (D.31129, D.31117, 8, compare_interface_impl);
      <D.31135>:
      i = 0;
      goto <D.19651>;
      <D.19650>:
      {
        int row;
        int col;
        guint32 * values;
        guint32 bitfield;

        bitfield = meta->tables[i].size_bitfield;
        D.31037 = meta->tables[i].rows;
        if (D.31037 == 0) goto <D.31136>; else goto <D.31137>;
        <D.31136>:
        // predicted unlikely by continue predictor.
        goto <D.19637>;
        <D.31137>:
        D.31138 = assembly->tables[i].columns;
        D.31139 = (unsigned int) D.31138;
        D.31140 = bitfield >> 24;
        if (D.31139 != D.31140) goto <D.31141>; else goto <D.31142>;
        <D.31141>:
        D.31138 = assembly->tables[i].columns;
        D.31143 = (int) D.31138;
        D.31140 = bitfield >> 24;
        monoeg_g_log (0B, 4, "col count mismatch in %d: %d %d", i, D.31143, D.31140);
        <D.19638>:
        goto <D.19638>;
        <D.31142>:
        meta->tables[i].base = p;
        row = 1;
        goto <D.19648>;
        <D.19647>:
        D.31144 = assembly->tables[i].values;
        D.31138 = assembly->tables[i].columns;
        D.31143 = (int) D.31138;
        D.31145 = D.31143 * row;
        D.31146 = (unsigned int) D.31145;
        D.31147 = D.31146 * 4;
        values = D.31144 + D.31147;
        col = 0;
        goto <D.19645>;
        <D.19644>:
        D.31148 = col * 2;
        D.31149 = bitfield >> D.31148;
        D.31150 = D.31149 & 3;
        D.31151 = D.31150 + 1;
        switch (D.31151) <default: <D.19643>, case 1: <D.19639>, case 2: <D.19641>, case 4: <D.19642>>
        <D.19639>:
        p.335 = p;
        p = p.335 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31157 = (unsigned char) D.31156;
        *p.335 = D.31157;
        goto <D.19640>;
        <D.19641>:
        p.337 = p;
        p = p.337 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31157 = (unsigned char) D.31156;
        *p.337 = D.31157;
        p.338 = p;
        p = p.338 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31160 = D.31156 >> 8;
        D.31161 = (unsigned char) D.31160;
        *p.338 = D.31161;
        goto <D.19640>;
        <D.19642>:
        p.339 = p;
        p = p.339 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31157 = (unsigned char) D.31156;
        *p.339 = D.31157;
        p.340 = p;
        p = p.340 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31160 = D.31156 >> 8;
        D.31161 = (unsigned char) D.31160;
        *p.340 = D.31161;
        p.341 = p;
        p = p.341 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31165 = D.31156 >> 16;
        D.31166 = (unsigned char) D.31165;
        *p.341 = D.31166;
        p.342 = p;
        p = p.342 + 1;
        col.336 = (unsigned int) col;
        D.31154 = col.336 * 4;
        D.31155 = values + D.31154;
        D.31156 = *D.31155;
        D.31168 = D.31156 >> 24;
        D.31169 = (unsigned char) D.31168;
        *p.342 = D.31169;
        goto <D.19640>;
        <D.19643>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4187);
        <D.19640>:
        col = col + 1;
        <D.19645>:
        D.31138 = assembly->tables[i].columns;
        D.31143 = (int) D.31138;
        if (D.31143 > col) goto <D.19644>; else goto <D.19646>;
        <D.19646>:
        row = row + 1;
        <D.19648>:
        D.31037 = meta->tables[i].rows;
        D.31046 = (int) D.31037;
        if (D.31046 >= row) goto <D.19647>; else goto <D.19649>;
        <D.19649>:
        p.326 = (int) p;
        D.31170 = meta->tables[i].base;
        D.31171 = (int) D.31170;
        D.31172 = p.326 - D.31171;
        D.31037 = meta->tables[i].rows;
        D.31046 = (int) D.31037;
        D.31044 = meta->tables[i].row_size;
        D.31045 = (int) D.31044;
        D.31047 = D.31046 * D.31045;
        D.31173 = D.31172 != D.31047;
        D.31174 = (long int) D.31173;
        D.31175 = __builtin_expect (D.31174, 0);
        if (D.31175 != 0) goto <D.31176>; else goto <D.31177>;
        <D.31176>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4191, "(p - (const unsigned char*)meta->tables [i].base) == (meta->tables [i].rows * meta->tables [i].row_size)");
        <D.31177>:
      }
      <D.19637>:
      i = i + 1;
      <D.19651>:
      if (i <= 44) goto <D.19650>; else goto <D.19652>;
      <D.19652>:
      D.31178 = assembly->guid.offset;
      D.31030 = assembly->guid.index;
      D.31179 = D.31178 + D.31030;
      D.31180 = D.31179 >= meta_size;
      D.31181 = (long int) D.31180;
      D.31182 = __builtin_expect (D.31181, 0);
      if (D.31182 != 0) goto <D.31183>; else goto <D.31184>;
      <D.31183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4194, "assembly->guid.offset + assembly->guid.index < meta_size");
      <D.31184>:
      D.31067 = meta->raw_metadata;
      D.31185 = assembly->sheap.offset;
      D.31186 = D.31067 + D.31185;
      D.31187 = assembly->sheap.data;
      D.31032 = assembly->sheap.index;
      memcpy (D.31186, D.31187, D.31032);
      D.31067 = meta->raw_metadata;
      D.31188 = assembly->us.offset;
      D.31189 = D.31067 + D.31188;
      D.31190 = assembly->us.data;
      D.31034 = assembly->us.index;
      memcpy (D.31189, D.31190, D.31034);
      D.31067 = meta->raw_metadata;
      D.31191 = assembly->blob.offset;
      D.31192 = D.31067 + D.31191;
      D.31193 = assembly->blob.data;
      D.31028 = assembly->blob.index;
      memcpy (D.31192, D.31193, D.31028);
      D.31067 = meta->raw_metadata;
      D.31178 = assembly->guid.offset;
      D.31194 = D.31067 + D.31178;
      D.31195 = assembly->guid.data;
      D.31030 = assembly->guid.index;
      memcpy (D.31194, D.31195, D.31030);
      D.31178 = assembly->guid.offset;
      D.31030 = assembly->guid.index;
      D.31179 = D.31178 + D.31030;
      assembly->meta_size = D.31179;
    }
  finally
    {
      stream_desc = {CLOBBER};
    }
}


compare_interface_impl (const void * a, const void * b)
{
  unsigned int D.31196;
  unsigned int D.31197;
  unsigned int D.31198;
  int D.31201;
  const guint32 * D.31202;
  unsigned int D.31203;
  const guint32 * D.31204;
  unsigned int D.31205;
  unsigned int D.31206;
  const guint32 * a_values;
  const guint32 * b_values;
  int klass;

  a_values = a;
  b_values = b;
  D.31196 = *a_values;
  D.31197 = *b_values;
  D.31198 = D.31196 - D.31197;
  klass = (int) D.31198;
  if (klass != 0) goto <D.31199>; else goto <D.31200>;
  <D.31199>:
  D.31201 = klass;
  return D.31201;
  <D.31200>:
  D.31202 = a_values + 4;
  D.31203 = *D.31202;
  D.31204 = b_values + 4;
  D.31205 = *D.31204;
  D.31206 = D.31203 - D.31205;
  D.31201 = (int) D.31206;
  return D.31201;
}


compare_declsecurity_attrs (const void * a, const void * b)
{
  int D.31208;
  const guint32 * D.31209;
  unsigned int D.31210;
  const guint32 * D.31211;
  unsigned int D.31212;
  unsigned int D.31213;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31209 = a_values + 4;
  D.31210 = *D.31209;
  D.31211 = b_values + 4;
  D.31212 = *D.31211;
  D.31213 = D.31210 - D.31212;
  D.31208 = (int) D.31213;
  return D.31208;
}


compare_nested (const void * a, const void * b)
{
  int D.31215;
  unsigned int D.31216;
  unsigned int D.31217;
  unsigned int D.31218;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31216 = *a_values;
  D.31217 = *b_values;
  D.31218 = D.31216 - D.31217;
  D.31215 = (int) D.31218;
  return D.31215;
}


compare_field_marshal (const void * a, const void * b)
{
  int D.31220;
  unsigned int D.31221;
  unsigned int D.31222;
  unsigned int D.31223;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31221 = *a_values;
  D.31222 = *b_values;
  D.31223 = D.31221 - D.31222;
  D.31220 = (int) D.31223;
  return D.31220;
}


compare_custom_attrs (const void * a, const void * b)
{
  int D.31225;
  unsigned int D.31226;
  unsigned int D.31227;
  unsigned int D.31228;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31226 = *a_values;
  D.31227 = *b_values;
  D.31228 = D.31226 - D.31227;
  D.31225 = (int) D.31228;
  return D.31225;
}


compare_semantics (const void * a, const void * b)
{
  const guint32 * D.31230;
  unsigned int D.31231;
  const guint32 * D.31232;
  unsigned int D.31233;
  unsigned int D.31234;
  int D.31237;
  unsigned int D.31238;
  unsigned int D.31239;
  unsigned int D.31240;
  const guint32 * a_values;
  const guint32 * b_values;
  int assoc;

  a_values = a;
  b_values = b;
  D.31230 = a_values + 8;
  D.31231 = *D.31230;
  D.31232 = b_values + 8;
  D.31233 = *D.31232;
  D.31234 = D.31231 - D.31233;
  assoc = (int) D.31234;
  if (assoc != 0) goto <D.31235>; else goto <D.31236>;
  <D.31235>:
  D.31237 = assoc;
  return D.31237;
  <D.31236>:
  D.31238 = *a_values;
  D.31239 = *b_values;
  D.31240 = D.31238 - D.31239;
  D.31237 = (int) D.31240;
  return D.31237;
}


compare_constants (const void * a, const void * b)
{
  int D.31242;
  const guint32 * D.31243;
  unsigned int D.31244;
  const guint32 * D.31245;
  unsigned int D.31246;
  unsigned int D.31247;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31243 = a_values + 8;
  D.31244 = *D.31243;
  D.31245 = b_values + 8;
  D.31246 = *D.31245;
  D.31247 = D.31244 - D.31246;
  D.31242 = (int) D.31247;
  return D.31242;
}


compare_genericparam (const void * a, const void * b)
{
  const struct GenericParamTableEntry * D.31249;
  unsigned int D.31250;
  const struct GenericParamTableEntry * D.31251;
  unsigned int D.31252;
  int D.31255;
  struct MonoReflectionGenericParam * D.31256;
  struct MonoType * D.31257;
  struct MonoGenericParam * D.31258;
  short unsigned int D.31259;
  int D.31260;
  struct MonoReflectionGenericParam * D.31261;
  struct MonoType * D.31262;
  struct MonoGenericParam * D.31263;
  short unsigned int D.31264;
  int D.31265;
  unsigned int D.31266;
  const struct GenericParamTableEntry * * a_entry;
  const struct GenericParamTableEntry * * b_entry;

  a_entry = a;
  b_entry = b;
  D.31249 = *b_entry;
  D.31250 = D.31249->owner;
  D.31251 = *a_entry;
  D.31252 = D.31251->owner;
  if (D.31250 == D.31252) goto <D.31253>; else goto <D.31254>;
  <D.31253>:
  D.31251 = *a_entry;
  D.31256 = D.31251->gparam;
  D.31257 = mono_reflection_type_get_handle (D.31256);
  D.31258 = D.31257->data.generic_param;
  D.31259 = D.31258->num;
  D.31260 = (int) D.31259;
  D.31249 = *b_entry;
  D.31261 = D.31249->gparam;
  D.31262 = mono_reflection_type_get_handle (D.31261);
  D.31263 = D.31262->data.generic_param;
  D.31264 = D.31263->num;
  D.31265 = (int) D.31264;
  D.31255 = D.31260 - D.31265;
  return D.31255;
  <D.31254>:
  D.31251 = *a_entry;
  D.31252 = D.31251->owner;
  D.31249 = *b_entry;
  D.31250 = D.31249->owner;
  D.31266 = D.31252 - D.31250;
  D.31255 = (int) D.31266;
  return D.31255;
}


write_generic_param_entry (struct MonoDynamicImage * assembly, struct GenericParamTableEntry * entry)
{
  unsigned int D.31268;
  unsigned int table_idx.343;
  unsigned int D.31270;
  guint32 * D.31271;
  unsigned int D.31272;
  struct MonoReflectionGenericParam * D.31273;
  struct MonoType * D.31274;
  guint32 * D.31275;
  unsigned int D.31276;
  guint32 * D.31277;
  unsigned int D.31278;
  short unsigned int D.31279;
  unsigned int D.31280;
  guint32 * D.31281;
  struct MonoDynamicStream * D.31282;
  struct MonoGenericParamInfo * iftmp.344;
  struct MonoGenericContainer * D.31284;
  const char * D.31288;
  unsigned int D.31289;
  struct MonoArray * D.31290;
  struct MonoDynamicTable * table;
  struct MonoGenericParam * param;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[42];
  D.31268 = table->next_idx;
  table_idx.343 = D.31268;
  D.31270 = table_idx.343 + 1;
  table->next_idx = D.31270;
  table_idx = table_idx.343;
  D.31271 = table->values;
  D.31272 = table_idx * 16;
  values = D.31271 + D.31272;
  D.31273 = entry->gparam;
  D.31274 = mono_reflection_type_get_handle (D.31273);
  param = D.31274->data.generic_param;
  D.31275 = values + 8;
  D.31276 = entry->owner;
  *D.31275 = D.31276;
  D.31277 = values + 4;
  D.31273 = entry->gparam;
  D.31278 = D.31273->attrs;
  *D.31277 = D.31278;
  D.31279 = param->num;
  D.31280 = (unsigned int) D.31279;
  *values = D.31280;
  D.31281 = values + 12;
  D.31282 = &assembly->sheap;
  D.31284 = param->owner;
  if (D.31284 != 0B) goto <D.31285>; else goto <D.31286>;
  <D.31285>:
  iftmp.344 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.31287>;
  <D.31286>:
  iftmp.344 = 0B;
  <D.31287>:
  D.31288 = iftmp.344->name;
  D.31289 = string_heap_insert (D.31282, D.31288);
  *D.31281 = D.31289;
  D.31273 = entry->gparam;
  D.31290 = D.31273->cattrs;
  mono_image_add_cattrs (assembly, table_idx, 19, D.31290);
  D.31273 = entry->gparam;
  encode_constraints (D.31273, table_idx, assembly);
}


encode_constraints (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  uintptr_t iftmp.345;
  struct MonoArray * D.31292;
  unsigned int D.31296;
  unsigned int D.31297;
  struct MonoReflectionType * D.31298;
  unsigned int D.31301;
  unsigned int D.31304;
  unsigned int table_idx.346;
  unsigned int D.31306;
  guint32 * D.31307;
  unsigned int D.31308;
  guint32 * D.31309;
  struct MonoType * D.31310;
  unsigned int D.31311;
  char * D.31312;
  unsigned int table_idx.347;
  unsigned int D.31314;
  struct MonoType * D.31315;
  unsigned int D.31316;
  struct MonoDynamicTable * table;
  guint32 num_constraints;
  guint32 i;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[44];
  D.31292 = gparam->iface_constraints;
  if (D.31292 != 0B) goto <D.31293>; else goto <D.31294>;
  <D.31293>:
  D.31292 = gparam->iface_constraints;
  iftmp.345 = mono_array_length (D.31292);
  goto <D.31295>;
  <D.31294>:
  iftmp.345 = 0;
  <D.31295>:
  num_constraints = iftmp.345;
  D.31296 = table->rows;
  D.31297 = D.31296 + num_constraints;
  table->rows = D.31297;
  D.31298 = gparam->base_type;
  if (D.31298 != 0B) goto <D.31299>; else goto <D.31300>;
  <D.31299>:
  D.31296 = table->rows;
  D.31301 = D.31296 + 1;
  table->rows = D.31301;
  <D.31300>:
  D.31296 = table->rows;
  alloc_table (table, D.31296);
  D.31298 = gparam->base_type;
  if (D.31298 != 0B) goto <D.31302>; else goto <D.31303>;
  <D.31302>:
  D.31304 = table->next_idx;
  table_idx.346 = D.31304;
  D.31306 = table_idx.346 + 1;
  table->next_idx = D.31306;
  table_idx = table_idx.346;
  D.31307 = table->values;
  D.31308 = table_idx * 8;
  values = D.31307 + D.31308;
  *values = owner;
  D.31309 = values + 4;
  D.31298 = gparam->base_type;
  D.31310 = mono_reflection_type_get_handle (D.31298);
  D.31311 = mono_image_typedef_or_ref (assembly, D.31310);
  *D.31309 = D.31311;
  <D.31303>:
  i = 0;
  goto <D.18927>;
  <D.18926>:
  {
    struct MonoReflectionType * constraint;

    D.31292 = gparam->iface_constraints;
    D.31312 = mono_array_addr_with_size (D.31292, 4, i);
    constraint = MEM[(void * *)D.31312];
    D.31304 = table->next_idx;
    table_idx.347 = D.31304;
    D.31314 = table_idx.347 + 1;
    table->next_idx = D.31314;
    table_idx = table_idx.347;
    D.31307 = table->values;
    D.31308 = table_idx * 8;
    values = D.31307 + D.31308;
    *values = owner;
    D.31309 = values + 4;
    D.31315 = mono_reflection_type_get_handle (constraint);
    D.31316 = mono_image_typedef_or_ref (assembly, D.31315);
    *D.31309 = D.31316;
  }
  i = i + 1;
  <D.18927>:
  if (i < num_constraints) goto <D.18926>; else goto <D.18928>;
  <D.18928>:
}


pad_heap (struct MonoDynamicStream * sh)
{
  unsigned int D.31317;
  unsigned int D.31318;
  unsigned int D.31321;
  char * D.31322;
  void * D.31323;
  unsigned int sz.348;
  unsigned int sz.349;
  unsigned int D.31326;

  D.31317 = sh->index;
  D.31318 = D.31317 & 3;
  if (D.31318 != 0) goto <D.31319>; else goto <D.31320>;
  <D.31319>:
  {
    int sz;

    D.31317 = sh->index;
    D.31318 = D.31317 & 3;
    D.31321 = 4 - D.31318;
    sz = (int) D.31321;
    D.31322 = sh->data;
    D.31317 = sh->index;
    D.31323 = D.31322 + D.31317;
    sz.348 = (unsigned int) sz;
    memset (D.31323, 0, sz.348);
    D.31317 = sh->index;
    sz.349 = (unsigned int) sz;
    D.31326 = D.31317 + sz.349;
    sh->index = D.31326;
  }
  <D.31320>:
}


assembly_add_win32_resources (struct MonoDynamicImage * assembly, struct MonoReflectionAssemblyBuilder * assemblyb)
{
  struct MonoArray * D.31327;
  struct MonoArray * D.31330;
  unsigned int D.31331;
  unsigned int D.31332;
  unsigned int D.31333;
  unsigned int D.31334;
  char * p.350;
  int p.351;
  int buf.352;
  int D.31338;
  unsigned int D.31339;
  _Bool D.31340;
  long int D.31341;
  long int D.31342;
  unsigned int D.31345;
  void * D.31346;
  char * D.31347;
  unsigned int D.31348;
  char * buf;
  char * p;
  guint32 size;
  guint32 i;
  struct MonoReflectionWin32Resource * win32_res;
  struct ResTreeNode * tree;

  try
    {
      D.31327 = assemblyb->win32_resources;
      if (D.31327 == 0B) goto <D.31328>; else goto <D.31329>;
      <D.31328>:
      return;
      <D.31329>:
      D.31327 = assemblyb->win32_resources;
      tree = resource_tree_create (D.31327);
      size = 0;
      i = 0;
      goto <D.20472>;
      <D.20471>:
      D.31327 = assemblyb->win32_resources;
      win32_res = mono_array_addr_with_size (D.31327, 16, i);
      D.31330 = win32_res->res_data;
      D.31331 = mono_array_length (D.31330);
      size = D.31331 + size;
      i = i + 1;
      <D.20472>:
      D.31327 = assemblyb->win32_resources;
      D.31332 = mono_array_length (D.31327);
      if (D.31332 > i) goto <D.20471>; else goto <D.20473>;
      <D.20473>:
      D.31327 = assemblyb->win32_resources;
      D.31333 = mono_array_length (D.31327);
      D.31334 = D.31333 * 256;
      size = D.31334 + size;
      buf = monoeg_malloc (size);
      p = buf;
      p.350 = p;
      p.350 = p;
      resource_tree_encode (tree, p.350, p.350, &p);
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31338 = p.351 - buf.352;
      D.31339 = (unsigned int) D.31338;
      D.31340 = D.31339 > size;
      D.31341 = (long int) D.31340;
      D.31342 = __builtin_expect (D.31341, 0);
      if (D.31342 != 0) goto <D.31343>; else goto <D.31344>;
      <D.31343>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5585, "p - buf <= size");
      <D.31344>:
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31338 = p.351 - buf.352;
      D.31345 = (unsigned int) D.31338;
      D.31346 = monoeg_malloc (D.31345);
      assembly->win32_res = D.31346;
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31338 = p.351 - buf.352;
      D.31339 = (unsigned int) D.31338;
      assembly->win32_res_size = D.31339;
      D.31347 = assembly->win32_res;
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31338 = p.351 - buf.352;
      D.31348 = (unsigned int) D.31338;
      memcpy (D.31347, buf, D.31348);
      monoeg_g_free (buf);
      resource_tree_free (tree);
    }
  finally
    {
      p = {CLOBBER};
    }
}


resource_tree_create (struct MonoArray * win32_resources)
{
  unsigned int i.353;
  unsigned int D.31353;
  void * D.31354;
  unsigned int D.31355;
  unsigned int D.31356;
  struct GSList * D.31361;
  struct GSList * D.31362;
  unsigned int D.31363;
  struct GSList * D.31368;
  struct GSList * D.31369;
  struct GSList * D.31370;
  struct GSList * D.31371;
  unsigned int D.31372;
  struct ResTreeNode * D.31373;
  struct ResTreeNode * tree;
  struct ResTreeNode * res_node;
  struct ResTreeNode * type_node;
  struct ResTreeNode * lang_node;
  struct GSList * l;
  int i;

  tree = monoeg_malloc0 (16);
  i = 0;
  goto <D.20431>;
  <D.20430>:
  {
    struct MonoReflectionWin32Resource * win32_res;

    i.353 = (unsigned int) i;
    win32_res = mono_array_addr_with_size (win32_resources, 16, i.353);
    lang_node = monoeg_malloc0 (16);
    D.31353 = win32_res->lang_id;
    lang_node->id = D.31353;
    lang_node->win32_res = win32_res;
    type_node = 0B;
    l = tree->children;
    goto <D.20426>;
    <D.20425>:
    D.31354 = l->data;
    D.31355 = MEM[(struct ResTreeNode *)D.31354].id;
    D.31356 = win32_res->res_type;
    if (D.31355 == D.31356) goto <D.31357>; else goto <D.31358>;
    <D.31357>:
    type_node = l->data;
    goto <D.20424>;
    <D.31358>:
    l = l->next;
    <D.20426>:
    if (l != 0B) goto <D.20425>; else goto <D.20424>;
    <D.20424>:
    if (type_node == 0B) goto <D.31359>; else goto <D.31360>;
    <D.31359>:
    type_node = monoeg_malloc0 (16);
    D.31356 = win32_res->res_type;
    type_node->id = D.31356;
    D.31361 = tree->children;
    D.31362 = monoeg_g_slist_insert_sorted (D.31361, type_node, resource_tree_compare_by_id);
    tree->children = D.31362;
    <D.31360>:
    res_node = 0B;
    l = type_node->children;
    goto <D.20429>;
    <D.20428>:
    D.31354 = l->data;
    D.31355 = MEM[(struct ResTreeNode *)D.31354].id;
    D.31363 = win32_res->res_id;
    if (D.31355 == D.31363) goto <D.31364>; else goto <D.31365>;
    <D.31364>:
    res_node = l->data;
    goto <D.20427>;
    <D.31365>:
    l = l->next;
    <D.20429>:
    if (l != 0B) goto <D.20428>; else goto <D.20427>;
    <D.20427>:
    if (res_node == 0B) goto <D.31366>; else goto <D.31367>;
    <D.31366>:
    res_node = monoeg_malloc0 (16);
    D.31363 = win32_res->res_id;
    res_node->id = D.31363;
    D.31368 = type_node->children;
    D.31369 = monoeg_g_slist_append (D.31368, res_node);
    type_node->children = D.31369;
    <D.31367>:
    D.31370 = res_node->children;
    D.31371 = monoeg_g_slist_append (D.31370, lang_node);
    res_node->children = D.31371;
  }
  i = i + 1;
  <D.20431>:
  i.353 = (unsigned int) i;
  D.31372 = mono_array_length (win32_resources);
  if (i.353 < D.31372) goto <D.20430>; else goto <D.20432>;
  <D.20432>:
  D.31373 = tree;
  return D.31373;
}


resource_tree_compare_by_id (const void * a, const void * b)
{
  int D.31375;
  unsigned int D.31376;
  unsigned int D.31377;
  unsigned int D.31378;
  struct ResTreeNode * t1;
  struct ResTreeNode * t2;

  t1 = a;
  t2 = b;
  D.31376 = t1->id;
  D.31377 = t2->id;
  D.31378 = D.31376 - D.31377;
  D.31375 = (int) D.31378;
  return D.31375;
}


resource_tree_encode (struct ResTreeNode * node, char * begin, char * p, char * * endbuf)
{
  char * p.354;
  int p.355;
  int begin.356;
  int D.31389;
  unsigned int D.31390;
  struct GSList * D.31391;
  short unsigned int D.31392;
  char * p.357;
  unsigned int D.31394;
  char * p.358;
  struct MonoReflectionWin32Resource * D.31396;
  unsigned int D.31399;
  unsigned int D.31400;
  struct MonoArray * D.31401;
  char * D.31402;
  char * p.359;
  unsigned int D.31405;
  unsigned int D.31406;
  unsigned int iftmp.360;
  struct MonoReflectionWin32Resource * D.31408;
  unsigned int D.31412;
  unsigned int D.31413;
  unsigned int D.31414;
  char * entries;
  struct MonoPEResourceDir dir;
  struct MonoPEResourceDirEntry dir_entry;
  struct MonoPEResourceDataEntry data_entry;
  struct GSList * l;
  guint32 res_id_entries;

  try
    {
      memset (&dir, 0, 16);
      memset (&dir_entry, 0, 8);
      memset (&data_entry, 0, 16);
      if (0 != 0) goto <D.31380>; else goto <D.31381>;
      <D.31380>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5486, "sizeof (dir) == 16");
      <D.31381>:
      if (0 != 0) goto <D.31382>; else goto <D.31383>;
      <D.31382>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5487, "sizeof (dir_entry) == 8");
      <D.31383>:
      if (0 != 0) goto <D.31384>; else goto <D.31385>;
      <D.31384>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5488, "sizeof (data_entry) == 16");
      <D.31385>:
      p.354 = p;
      p.355 = (int) p.354;
      begin.356 = (int) begin;
      D.31389 = p.355 - begin.356;
      D.31390 = (unsigned int) D.31389;
      node->offset = D.31390;
      D.31391 = node->children;
      res_id_entries = monoeg_g_slist_length (D.31391);
      D.31392 = (short unsigned int) res_id_entries;
      dir.res_id_entries = D.31392;
      p.354 = p;
      memcpy (p.354, &dir, 16);
      p.354 = p;
      p.357 = p.354 + 16;
      p = p.357;
      entries = p;
      p.354 = p;
      D.31394 = res_id_entries * 8;
      p.358 = p.354 + D.31394;
      p = p.358;
      l = node->children;
      goto <D.20448>;
      <D.20447>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.31396 = child->win32_res;
        if (D.31396 != 0B) goto <D.31397>; else goto <D.31398>;
        <D.31397>:
        {
          guint32 size;

          p.354 = p;
          p.355 = (int) p.354;
          begin.356 = (int) begin;
          D.31389 = p.355 - begin.356;
          D.31390 = (unsigned int) D.31389;
          child->offset = D.31390;
          p.354 = p;
          p.355 = (int) p.354;
          begin.356 = (int) begin;
          D.31389 = p.355 - begin.356;
          D.31399 = (unsigned int) D.31389;
          D.31400 = D.31399 + 16;
          data_entry.rde_data_offset = D.31400;
          D.31396 = child->win32_res;
          D.31401 = D.31396->res_data;
          size = mono_array_length (D.31401);
          data_entry.rde_size = size;
          p.354 = p;
          memcpy (p.354, &data_entry, 16);
          p.354 = p;
          p.357 = p.354 + 16;
          p = p.357;
          p.354 = p;
          D.31396 = child->win32_res;
          D.31401 = D.31396->res_data;
          D.31402 = mono_array_addr_with_size (D.31401, 1, 0);
          memcpy (p.354, D.31402, size);
          p.354 = p;
          p.359 = p.354 + size;
          p = p.359;
        }
        goto <D.31404>;
        <D.31398>:
        p.354 = p;
        resource_tree_encode (child, begin, p.354, &p);
        <D.31404>:
      }
      l = l->next;
      <D.20448>:
      if (l != 0B) goto <D.20447>; else goto <D.20449>;
      <D.20449>:
      l = node->children;
      goto <D.20452>;
      <D.20451>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.31405 = child->id;
        D.31406 = D.31405 & 2147483647;
        dir_entry.name = D.31406;
        D.31408 = child->win32_res;
        if (D.31408 == 0B) goto <D.31409>; else goto <D.31410>;
        <D.31409>:
        iftmp.360 = 2147483648;
        goto <D.31411>;
        <D.31410>:
        iftmp.360 = 0;
        <D.31411>:
        D.31412 = child->offset;
        D.31413 = D.31412 & 2147483647;
        D.31414 = iftmp.360 | D.31413;
        dir_entry.dir = D.31414;
        memcpy (entries, &dir_entry, 8);
        entries = entries + 8;
      }
      l = l->next;
      <D.20452>:
      if (l != 0B) goto <D.20451>; else goto <D.20453>;
      <D.20453>:
      p.354 = p;
      *endbuf = p.354;
    }
  finally
    {
      dir = {CLOBBER};
      dir_entry = {CLOBBER};
      data_entry = {CLOBBER};
    }
}


resource_tree_free (struct ResTreeNode * node)
{
  void * D.31415;
  struct GSList * D.31416;
  struct GSList * list;

  list = node->children;
  goto <D.20459>;
  <D.20458>:
  D.31415 = list->data;
  resource_tree_free (D.31415);
  list = list->next;
  <D.20459>:
  if (list != 0B) goto <D.20458>; else goto <D.20460>;
  <D.20460>:
  D.31416 = node->children;
  monoeg_g_slist_free (D.31416);
  monoeg_g_free (node);
}


calc_section_size (struct MonoDynamicImage * assembly)
{
  struct MonoDynamicStream * D.31417;
  unsigned int D.31418;
  unsigned int D.31419;
  unsigned int D.31420;
  _Bool D.31421;
  long int D.31422;
  long int D.31423;
  unsigned int D.31426;
  unsigned int D.31427;
  unsigned int D.31428;
  struct MonoDynamicStream * D.31429;
  unsigned int D.31430;
  unsigned int D.31431;
  unsigned int D.31432;
  _Bool D.31433;
  long int D.31434;
  long int D.31435;
  unsigned int D.31438;
  unsigned int D.31439;
  unsigned int D.31440;
  unsigned int D.31441;
  char * D.31442;
  unsigned int D.31445;
  unsigned int D.31446;
  int D.31447;
  int nsections;

  nsections = 0;
  D.31417 = &assembly->code;
  D.31418 = assembly->code.index;
  D.31419 = D.31418 & 3;
  D.31420 = 4 - D.31419;
  mono_image_add_stream_zero (D.31417, D.31420);
  D.31418 = assembly->code.index;
  D.31419 = D.31418 & 3;
  D.31421 = D.31419 != 0;
  D.31422 = (long int) D.31421;
  D.31423 = __builtin_expect (D.31422, 0);
  if (D.31423 != 0) goto <D.31424>; else goto <D.31425>;
  <D.31424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5355, "(assembly->code.index % 4) == 0");
  <D.31425>:
  D.31426 = assembly->meta_size;
  D.31427 = D.31426 + 3;
  assembly->meta_size = D.31427;
  D.31426 = assembly->meta_size;
  D.31428 = D.31426 & 4294967292;
  assembly->meta_size = D.31428;
  D.31429 = &assembly->resources;
  D.31430 = assembly->resources.index;
  D.31431 = D.31430 & 3;
  D.31432 = 4 - D.31431;
  mono_image_add_stream_zero (D.31429, D.31432);
  D.31430 = assembly->resources.index;
  D.31431 = D.31430 & 3;
  D.31433 = D.31431 != 0;
  D.31434 = (long int) D.31433;
  D.31435 = __builtin_expect (D.31434, 0);
  if (D.31435 != 0) goto <D.31436>; else goto <D.31437>;
  <D.31436>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5359, "(assembly->resources.index % 4) == 0");
  <D.31437>:
  D.31426 = assembly->meta_size;
  D.31418 = assembly->code.index;
  D.31438 = D.31426 + D.31418;
  D.31430 = assembly->resources.index;
  D.31439 = D.31438 + D.31430;
  D.31440 = assembly->strong_name_size;
  D.31441 = D.31439 + D.31440;
  assembly->sections[0].size = D.31441;
  assembly->sections[0].attrs = 1610612768;
  nsections = nsections + 1;
  D.31442 = assembly->win32_res;
  if (D.31442 != 0B) goto <D.31443>; else goto <D.31444>;
  <D.31443>:
  {
    guint32 res_size;

    D.31445 = assembly->win32_res_size;
    D.31446 = D.31445 + 3;
    res_size = D.31446 & 4294967292;
    assembly->sections[1].size = res_size;
    assembly->sections[1].attrs = 1073741888;
    nsections = nsections + 1;
  }
  <D.31444>:
  assembly->sections[2].size = 12;
  assembly->sections[2].attrs = 1107296320;
  nsections = nsections + 1;
  D.31447 = nsections;
  return D.31447;
}


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

  D.31450 = __builtin_object_size (__dest, 1);
  D.31449 = __builtin___strcpy_chk (__dest, __src, D.31450);
  return D.31449;
}


fixup_resource_directory (char * res_section, char * p, guint32 rva)
{
  unsigned int D.31452;
  sizetype D.31453;
  signed int D.31454;
  unsigned int D.31458;
  unsigned int D.31459;
  short unsigned int D.31460;
  int D.31461;
  short unsigned int D.31462;
  int D.31463;
  int D.31464;
  struct MonoPEResourceDir * dir;
  int i;

  dir = p;
  p = p + 16;
  i = 0;
  goto <D.20485>;
  <D.20484>:
  {
    struct MonoPEResourceDirEntry * dir_entry;
    char * child;

    dir_entry = p;
    D.31452 = dir_entry->dir;
    D.31453 = D.31452 & 2147483647;
    child = res_section + D.31453;
    D.31452 = dir_entry->dir;
    D.31454 = (signed int) D.31452;
    if (D.31454 < 0) goto <D.31455>; else goto <D.31456>;
    <D.31455>:
    fixup_resource_directory (res_section, child, rva);
    goto <D.31457>;
    <D.31456>:
    {
      struct MonoPEResourceDataEntry * data_entry;

      data_entry = child;
      D.31458 = data_entry->rde_data_offset;
      D.31459 = D.31458 + rva;
      data_entry->rde_data_offset = D.31459;
    }
    <D.31457>:
    p = p + 8;
  }
  i = i + 1;
  <D.20485>:
  D.31460 = dir->res_named_entries;
  D.31461 = (int) D.31460;
  D.31462 = dir->res_id_entries;
  D.31463 = (int) D.31462;
  D.31464 = D.31461 + D.31463;
  if (D.31464 > i) goto <D.20484>; else goto <D.20486>;
  <D.20486>:
}


checked_write_file (void * f, const void * buffer, guint32 numbytes)
{
  int D.31465;
  unsigned int D.31468;
  guint32 dummy;

  try
    {
      D.31465 = WriteFile (f, buffer, numbytes, &dummy, 0B);
      if (D.31465 == 0) goto <D.31466>; else goto <D.31467>;
      <D.31466>:
      D.31468 = GetLastError ();
      monoeg_g_log (0B, 4, "WriteFile returned %d\n", D.31468);
      <D.20493>:
      goto <D.20493>;
      <D.31467>:
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


mono_image_load_module_dynamic (struct MonoReflectionAssemblyBuilder * ab, struct MonoString * fileName)
{
  <unnamed type> status.361;
  struct MonoAssembly * D.31475;
  struct MonoImage * D.31476;
  unsigned int D.31477;
  unsigned int D.31478;
  struct MonoImage * * D.31479;
  unsigned int D.31482;
  gboolean * D.31483;
  struct MonoImage * * D.31486;
  gboolean * D.31487;
  unsigned int D.31488;
  unsigned int D.31489;
  struct MonoException * D.31492;
  struct MonoReflectionModule * D.31493;
  struct MonoDomain * D.31494;
  char * name;
  struct MonoImage * image;
  MonoImageOpenStatus status;
  struct MonoDynamicAssembly * assembly;
  guint32 module_count;
  struct MonoImage * * new_modules;
  gboolean * new_modules_loaded;

  try
    {
      name = mono_string_to_utf8 (fileName);
      image = mono_image_open (name, &status);
      if (image == 0B) goto <D.31469>; else goto <D.31470>;
      <D.31469>:
      {
        struct MonoException * exc;

        status.361 = status;
        if (status.361 == 1) goto <D.31472>; else goto <D.31473>;
        <D.31472>:
        exc = mono_get_exception_file_not_found (fileName);
        goto <D.31474>;
        <D.31473>:
        exc = mono_get_exception_bad_image_format (name);
        <D.31474>:
        monoeg_g_free (name);
        mono_raise_exception (exc);
      }
      <D.31470>:
      monoeg_g_free (name);
      assembly = ab->dynamic_assembly;
      image->assembly = assembly;
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      module_count = D.31476->module_count;
      D.31477 = module_count + 1;
      D.31478 = D.31477 * 4;
      new_modules = monoeg_malloc0 (D.31478);
      D.31477 = module_count + 1;
      D.31478 = D.31477 * 4;
      new_modules_loaded = monoeg_malloc0 (D.31478);
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31479 = D.31476->modules;
      if (D.31479 != 0B) goto <D.31480>; else goto <D.31481>;
      <D.31480>:
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31479 = D.31476->modules;
      D.31482 = module_count * 4;
      memcpy (new_modules, D.31479, D.31482);
      <D.31481>:
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31483 = D.31476->modules_loaded;
      if (D.31483 != 0B) goto <D.31484>; else goto <D.31485>;
      <D.31484>:
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31483 = D.31476->modules_loaded;
      D.31482 = module_count * 4;
      memcpy (new_modules_loaded, D.31483, D.31482);
      <D.31485>:
      D.31482 = module_count * 4;
      D.31486 = new_modules + D.31482;
      *D.31486 = image;
      D.31482 = module_count * 4;
      D.31487 = new_modules_loaded + D.31482;
      *D.31487 = 1;
      mono_image_addref (image);
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31479 = D.31476->modules;
      monoeg_g_free (D.31479);
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31476->modules = new_modules;
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31476->modules_loaded = new_modules_loaded;
      D.31475 = image->assembly;
      D.31476 = D.31475->image;
      D.31488 = D.31476->module_count;
      D.31489 = D.31488 + 1;
      D.31476->module_count = D.31489;
      mono_assembly_load_references (image, &status);
      status.361 = status;
      if (status.361 != 0) goto <D.31490>; else goto <D.31491>;
      <D.31490>:
      mono_image_close (image);
      D.31492 = mono_get_exception_file_not_found (fileName);
      mono_raise_exception (D.31492);
      <D.31491>:
      D.31494 = mono_domain_get ();
      D.31493 = mono_module_get_object (D.31494, image);
      return D.31493;
    }
  finally
    {
      status = {CLOBBER};
    }
}


mono_reflection_cleanup_domain (struct MonoDomain * domain)
{
  struct MonoGHashTable * D.31497;

  D.31497 = domain->refobject_hash;
  if (D.31497 != 0B) goto <D.31498>; else goto <D.31499>;
  <D.31498>:
  D.31497 = domain->refobject_hash;
  mono_g_hash_table_destroy (D.31497);
  domain->refobject_hash = 0B;
  <D.31499>:
}


mono_image_module_basic_init (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoString * D.31502;
  struct MonoString * D.31503;
  int D.31504;
  struct MonoDynamicAssembly * D.31507;
  struct MonoImage * D.31508;
  struct MonoVTable * D.31509;
  struct MonoDomain * D.31510;
  unsigned int D.31511;
  int D.31512;
  unsigned int D.31513;
  unsigned int D.31514;
  struct MonoImage * * D.31515;
  unsigned int module_count.362;
  unsigned int D.31519;
  struct MonoImage * * D.31520;
  unsigned int D.31521;
  struct MonoDynamicImage * image;
  struct MonoReflectionAssemblyBuilder * ab;

  image = moduleb->dynamic_image;
  ab = moduleb->assemblyb;
  if (image == 0B) goto <D.31500>; else goto <D.31501>;
  <D.31500>:
  {
    struct MonoError error;
    int module_count;
    struct MonoImage * * new_modules;
    struct MonoImage * ass;
    char * name;
    char * fqname;

    try
      {
        D.31502 = ab->name;
        name = mono_string_to_utf8 (D.31502);
        D.31503 = moduleb->module.fqname;
        fqname = mono_string_to_utf8_checked (D.31503, &error);
        D.31504 = mono_error_ok (&error);
        if (D.31504 == 0) goto <D.31505>; else goto <D.31506>;
        <D.31505>:
        monoeg_g_free (name);
        mono_error_raise_exception (&error);
        <D.31506>:
        D.31507 = ab->dynamic_assembly;
        image = create_dynamic_mono_image (D.31507, name, fqname);
        D.31508 = &image->image;
        moduleb->module.image = D.31508;
        moduleb->dynamic_image = image;
        D.31509 = MEM[(struct MonoObject *)moduleb].vtable;
        D.31510 = D.31509->domain;
        register_module (D.31510, moduleb, image);
        D.31507 = ab->dynamic_assembly;
        ass = D.31507->assembly.image;
        D.31511 = ass->module_count;
        module_count = (int) D.31511;
        D.31512 = module_count + 1;
        D.31513 = (unsigned int) D.31512;
        D.31514 = D.31513 * 4;
        new_modules = monoeg_malloc0 (D.31514);
        D.31515 = ass->modules;
        if (D.31515 != 0B) goto <D.31516>; else goto <D.31517>;
        <D.31516>:
        D.31515 = ass->modules;
        module_count.362 = (unsigned int) module_count;
        D.31519 = module_count.362 * 4;
        memcpy (new_modules, D.31515, D.31519);
        <D.31517>:
        module_count.362 = (unsigned int) module_count;
        D.31519 = module_count.362 * 4;
        D.31520 = new_modules + D.31519;
        D.31508 = &image->image;
        *D.31520 = D.31508;
        D.31508 = &image->image;
        mono_image_addref (D.31508);
        D.31515 = ass->modules;
        monoeg_g_free (D.31515);
        ass->modules = new_modules;
        D.31511 = ass->module_count;
        D.31521 = D.31511 + 1;
        ass->module_count = D.31521;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.31501>:
}


register_module (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * res, struct MonoDynamicImage * module)
{
  union mono_mutex_t * D.31522;
  _Bool D.31525;
  long int D.31526;
  long int D.31527;
  struct MonoGHashTable * D.31530;
  struct MonoGHashTable * D.31533;
  struct MonoMemPool * D.31536;
  _Bool D.31539;
  long int D.31540;
  long int D.31541;
  void * D.31544;

  {
    struct MonoReflectionModuleBuilder * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = module;
        pe.refclass = 0B;
        {
          int ret;

          D.31522 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31522);
          if (ret != 0) goto <D.31523>; else goto <D.31524>;
          <D.31523>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31524>:
          D.31525 = ret != 0;
          D.31526 = (long int) D.31525;
          D.31527 = __builtin_expect (D.31526, 0);
          if (D.31527 != 0) goto <D.31528>; else goto <D.31529>;
          <D.31528>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.31529>:
        }
        D.31530 = domain->refobject_hash;
        if (D.31530 == 0B) goto <D.31531>; else goto <D.31532>;
        <D.31531>:
        D.31533 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31533;
        <D.31532>:
        D.31530 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31530, &pe);
        if (_obj == 0B) goto <D.31534>; else goto <D.31535>;
        <D.31534>:
        {
          struct ReflectedEntry * e;

          D.31536 = domain->mp;
          e = mono_mempool_alloc (D.31536, 8);
          e->item = module;
          e->refclass = 0B;
          D.31530 = domain->refobject_hash;
          mono_g_hash_table_insert (D.31530, e, res);
          _obj = res;
        }
        <D.31535>:
        {
          int ret;

          D.31522 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31522);
          if (ret != 0) goto <D.31537>; else goto <D.31538>;
          <D.31537>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31538>:
          D.31539 = ret != 0;
          D.31540 = (long int) D.31539;
          D.31541 = __builtin_expect (D.31540, 0);
          if (D.31541 != 0) goto <D.31542>; else goto <D.31543>;
          <D.31542>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.31543>:
        }
        D.31544 = _obj;
        return D.31544;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_image_set_wrappers_type (struct MonoReflectionModuleBuilder * moduleb, struct MonoReflectionType * type)
{
  struct MonoType * D.31547;
  _Bool D.31548;
  long int D.31549;
  long int D.31550;
  struct MonoClass * D.31553;
  struct MonoDynamicImage * image;

  image = moduleb->dynamic_image;
  D.31547 = type->type;
  D.31548 = D.31547 == 0B;
  D.31549 = (long int) D.31548;
  D.31550 = __builtin_expect (D.31549, 0);
  if (D.31550 != 0) goto <D.31551>; else goto <D.31552>;
  <D.31551>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6226, "type->type");
  <D.31552>:
  D.31547 = type->type;
  D.31553 = mono_class_from_mono_type (D.31547);
  image->wrappers_type = D.31553;
}


mono_assembly_get_object (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.31554;
  _Bool D.31557;
  long int D.31558;
  long int D.31559;
  struct MonoGHashTable * D.31562;
  struct MonoGHashTable * D.31565;
  _Bool D.31570;
  long int D.31571;
  long int D.31572;
  struct MonoReflectionAssembly * D.31575;
  _Bool D.31578;
  long int D.31579;
  long int D.31580;
  struct MonoClass * assembly_type.363;
  struct MonoImage * D.31586;
  _Bool D.31589;
  long int D.31590;
  long int D.31591;
  _Bool D.31596;
  long int D.31597;
  long int D.31598;
  struct MonoGHashTable * D.31603;
  struct MonoMemPool * D.31606;
  _Bool D.31609;
  long int D.31610;
  long int D.31611;
  static struct MonoClass * assembly_type;
  struct MonoReflectionAssembly * res;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = assembly;
        e.refclass = 0B;
        {
          int ret;

          D.31554 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31554);
          if (ret != 0) goto <D.31555>; else goto <D.31556>;
          <D.31555>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31556>:
          D.31557 = ret != 0;
          D.31558 = (long int) D.31557;
          D.31559 = __builtin_expect (D.31558, 0);
          if (D.31559 != 0) goto <D.31560>; else goto <D.31561>;
          <D.31560>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.31561>:
        }
        D.31562 = domain->refobject_hash;
        if (D.31562 == 0B) goto <D.31563>; else goto <D.31564>;
        <D.31563>:
        D.31565 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31565;
        <D.31564>:
        D.31562 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31562, &e);
        if (_obj != 0B) goto <D.31566>; else goto <D.31567>;
        <D.31566>:
        {
          int ret;

          D.31554 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31554);
          if (ret != 0) goto <D.31568>; else goto <D.31569>;
          <D.31568>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31569>:
          D.31570 = ret != 0;
          D.31571 = (long int) D.31570;
          D.31572 = __builtin_expect (D.31571, 0);
          if (D.31572 != 0) goto <D.31573>; else goto <D.31574>;
          <D.31573>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.31574>:
        }
        D.31575 = _obj;
        return D.31575;
        <D.31567>:
        {
          int ret;

          D.31554 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31554);
          if (ret != 0) goto <D.31576>; else goto <D.31577>;
          <D.31576>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31577>:
          D.31578 = ret != 0;
          D.31579 = (long int) D.31578;
          D.31580 = __builtin_expect (D.31579, 0);
          if (D.31580 != 0) goto <D.31581>; else goto <D.31582>;
          <D.31581>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.31582>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  assembly_type.363 = assembly_type;
  if (assembly_type.363 == 0B) goto <D.31584>; else goto <D.31585>;
  <D.31584>:
  {
    struct MonoClass * class;

    D.31586 = mono_defaults.corlib;
    class = mono_class_from_name (D.31586, "System.Reflection", "MonoAssembly");
    if (class == 0B) goto <D.31587>; else goto <D.31588>;
    <D.31587>:
    D.31586 = mono_defaults.corlib;
    class = mono_class_from_name (D.31586, "System.Reflection", "Assembly");
    <D.31588>:
    D.31589 = class == 0B;
    D.31590 = (long int) D.31589;
    D.31591 = __builtin_expect (D.31590, 0);
    if (D.31591 != 0) goto <D.31592>; else goto <D.31593>;
    <D.31592>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6250, "class");
    <D.31593>:
    assembly_type = class;
  }
  <D.31585>:
  assembly_type.363 = assembly_type;
  res = mono_object_new (domain, assembly_type.363);
  res->assembly = assembly;
  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = assembly;
        pe.refclass = 0B;
        {
          int ret;

          D.31554 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31554);
          if (ret != 0) goto <D.31594>; else goto <D.31595>;
          <D.31594>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31595>:
          D.31596 = ret != 0;
          D.31597 = (long int) D.31596;
          D.31598 = __builtin_expect (D.31597, 0);
          if (D.31598 != 0) goto <D.31599>; else goto <D.31600>;
          <D.31599>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.31600>:
        }
        D.31562 = domain->refobject_hash;
        if (D.31562 == 0B) goto <D.31601>; else goto <D.31602>;
        <D.31601>:
        D.31603 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31603;
        <D.31602>:
        D.31562 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31562, &pe);
        if (_obj == 0B) goto <D.31604>; else goto <D.31605>;
        <D.31604>:
        {
          struct ReflectedEntry * e;

          D.31606 = domain->mp;
          e = mono_mempool_alloc (D.31606, 8);
          e->item = assembly;
          e->refclass = 0B;
          D.31562 = domain->refobject_hash;
          mono_g_hash_table_insert (D.31562, e, res);
          _obj = res;
        }
        <D.31605>:
        {
          int ret;

          D.31554 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31554);
          if (ret != 0) goto <D.31607>; else goto <D.31608>;
          <D.31607>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31608>:
          D.31609 = ret != 0;
          D.31610 = (long int) D.31609;
          D.31611 = __builtin_expect (D.31610, 0);
          if (D.31611 != 0) goto <D.31612>; else goto <D.31613>;
          <D.31612>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.31613>:
        }
        D.31575 = _obj;
        return D.31575;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_get_object (struct MonoDomain * domain, struct MonoImage * image)
{
  union mono_mutex_t * D.31618;
  _Bool D.31621;
  long int D.31622;
  long int D.31623;
  struct MonoGHashTable * D.31626;
  struct MonoGHashTable * D.31629;
  _Bool D.31634;
  long int D.31635;
  long int D.31636;
  struct MonoReflectionModule * D.31639;
  _Bool D.31642;
  long int D.31643;
  long int D.31644;
  struct MonoClass * module_type.364;
  struct MonoImage * D.31650;
  _Bool D.31653;
  long int D.31654;
  long int D.31655;
  struct MonoReflectionAssembly * * D.31658;
  struct MonoAssembly * D.31659;
  struct MonoReflectionAssembly * D.31660;
  struct MonoString * * D.31661;
  char * D.31662;
  struct MonoString * D.31663;
  struct MonoString * * D.31664;
  struct MonoString * D.31665;
  struct MonoString * * D.31666;
  const char * D.31667;
  struct MonoString * D.31668;
  struct MonoImage * D.31669;
  struct MonoImage * * D.31673;
  unsigned int i.365;
  unsigned int D.31677;
  struct MonoImage * * D.31678;
  struct MonoImage * D.31679;
  int D.31682;
  int D.31683;
  unsigned int D.31684;
  unsigned int i.366;
  unsigned int D.31686;
  unsigned int D.31687;
  _Bool D.31688;
  long int D.31689;
  long int D.31690;
  _Bool D.31695;
  long int D.31696;
  long int D.31697;
  struct MonoGHashTable * D.31702;
  struct MonoMemPool * D.31705;
  _Bool D.31708;
  long int D.31709;
  long int D.31710;
  static struct MonoClass * module_type;
  struct MonoReflectionModule * res;
  char * basename;

  {
    struct MonoReflectionModule * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = image;
        e.refclass = 0B;
        {
          int ret;

          D.31618 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31618);
          if (ret != 0) goto <D.31619>; else goto <D.31620>;
          <D.31619>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31620>:
          D.31621 = ret != 0;
          D.31622 = (long int) D.31621;
          D.31623 = __builtin_expect (D.31622, 0);
          if (D.31623 != 0) goto <D.31624>; else goto <D.31625>;
          <D.31624>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31625>:
        }
        D.31626 = domain->refobject_hash;
        if (D.31626 == 0B) goto <D.31627>; else goto <D.31628>;
        <D.31627>:
        D.31629 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31629;
        <D.31628>:
        D.31626 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31626, &e);
        if (_obj != 0B) goto <D.31630>; else goto <D.31631>;
        <D.31630>:
        {
          int ret;

          D.31618 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31618);
          if (ret != 0) goto <D.31632>; else goto <D.31633>;
          <D.31632>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31633>:
          D.31634 = ret != 0;
          D.31635 = (long int) D.31634;
          D.31636 = __builtin_expect (D.31635, 0);
          if (D.31636 != 0) goto <D.31637>; else goto <D.31638>;
          <D.31637>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31638>:
        }
        D.31639 = _obj;
        return D.31639;
        <D.31631>:
        {
          int ret;

          D.31618 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31618);
          if (ret != 0) goto <D.31640>; else goto <D.31641>;
          <D.31640>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31641>:
          D.31642 = ret != 0;
          D.31643 = (long int) D.31642;
          D.31644 = __builtin_expect (D.31643, 0);
          if (D.31644 != 0) goto <D.31645>; else goto <D.31646>;
          <D.31645>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31646>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  module_type.364 = module_type;
  if (module_type.364 == 0B) goto <D.31648>; else goto <D.31649>;
  <D.31648>:
  {
    struct MonoClass * class;

    D.31650 = mono_defaults.corlib;
    class = mono_class_from_name (D.31650, "System.Reflection", "MonoModule");
    if (class == 0B) goto <D.31651>; else goto <D.31652>;
    <D.31651>:
    D.31650 = mono_defaults.corlib;
    class = mono_class_from_name (D.31650, "System.Reflection", "Module");
    <D.31652>:
    D.31653 = class == 0B;
    D.31654 = (long int) D.31653;
    D.31655 = __builtin_expect (D.31654, 0);
    if (D.31655 != 0) goto <D.31656>; else goto <D.31657>;
    <D.31656>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6273, "class");
    <D.31657>:
    module_type = class;
  }
  <D.31649>:
  module_type.364 = module_type;
  res = mono_object_new (domain, module_type.364);
  res->image = image;
  D.31658 = &res->assembly;
  D.31659 = image->assembly;
  D.31660 = mono_assembly_get_object (domain, D.31659);
  mono_gc_wbarrier_set_field (res, D.31658, D.31660);
  D.31661 = &res->fqname;
  D.31662 = image->name;
  D.31663 = mono_string_new (domain, D.31662);
  mono_gc_wbarrier_set_field (res, D.31661, D.31663);
  D.31662 = image->name;
  basename = monoeg_g_path_get_basename (D.31662);
  D.31664 = &res->name;
  D.31665 = mono_string_new (domain, basename);
  mono_gc_wbarrier_set_field (res, D.31664, D.31665);
  D.31666 = &res->scopename;
  D.31667 = image->module_name;
  D.31668 = mono_string_new (domain, D.31667);
  mono_gc_wbarrier_set_field (res, D.31666, D.31668);
  monoeg_g_free (basename);
  D.31659 = image->assembly;
  D.31669 = D.31659->image;
  if (D.31669 == image) goto <D.31670>; else goto <D.31671>;
  <D.31670>:
  res->token = 1;
  goto <D.31672>;
  <D.31671>:
  {
    int i;

    res->token = 0;
    D.31659 = image->assembly;
    D.31669 = D.31659->image;
    D.31673 = D.31669->modules;
    if (D.31673 != 0B) goto <D.31674>; else goto <D.31675>;
    <D.31674>:
    i = 0;
    goto <D.20674>;
    <D.20673>:
    D.31659 = image->assembly;
    D.31669 = D.31659->image;
    D.31673 = D.31669->modules;
    i.365 = (unsigned int) i;
    D.31677 = i.365 * 4;
    D.31678 = D.31673 + D.31677;
    D.31679 = *D.31678;
    if (D.31679 == image) goto <D.31680>; else goto <D.31681>;
    <D.31680>:
    D.31682 = i + 1;
    D.31683 = D.31682 | 436207616;
    D.31684 = (unsigned int) D.31683;
    res->token = D.31684;
    <D.31681>:
    i = i + 1;
    <D.20674>:
    i.366 = (unsigned int) i;
    D.31659 = image->assembly;
    D.31669 = D.31659->image;
    D.31686 = D.31669->module_count;
    if (i.366 < D.31686) goto <D.20673>; else goto <D.20675>;
    <D.20675>:
    D.31687 = res->token;
    D.31688 = D.31687 == 0;
    D.31689 = (long int) D.31688;
    D.31690 = __builtin_expect (D.31689, 0);
    if (D.31690 != 0) goto <D.31691>; else goto <D.31692>;
    <D.31691>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6298, "res->token");
    <D.31692>:
    <D.31675>:
  }
  <D.31672>:
  {
    struct MonoReflectionModule * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = image;
        pe.refclass = 0B;
        {
          int ret;

          D.31618 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31618);
          if (ret != 0) goto <D.31693>; else goto <D.31694>;
          <D.31693>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31694>:
          D.31695 = ret != 0;
          D.31696 = (long int) D.31695;
          D.31697 = __builtin_expect (D.31696, 0);
          if (D.31697 != 0) goto <D.31698>; else goto <D.31699>;
          <D.31698>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.31699>:
        }
        D.31626 = domain->refobject_hash;
        if (D.31626 == 0B) goto <D.31700>; else goto <D.31701>;
        <D.31700>:
        D.31702 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31702;
        <D.31701>:
        D.31626 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31626, &pe);
        if (_obj == 0B) goto <D.31703>; else goto <D.31704>;
        <D.31703>:
        {
          struct ReflectedEntry * e;

          D.31705 = domain->mp;
          e = mono_mempool_alloc (D.31705, 8);
          e->item = image;
          e->refclass = 0B;
          D.31626 = domain->refobject_hash;
          mono_g_hash_table_insert (D.31626, e, res);
          _obj = res;
        }
        <D.31704>:
        {
          int ret;

          D.31618 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31618);
          if (ret != 0) goto <D.31706>; else goto <D.31707>;
          <D.31706>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31707>:
          D.31708 = ret != 0;
          D.31709 = (long int) D.31708;
          D.31710 = __builtin_expect (D.31709, 0);
          if (D.31710 != 0) goto <D.31711>; else goto <D.31712>;
          <D.31711>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.31712>:
        }
        D.31639 = _obj;
        return D.31639;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_file_get_object (struct MonoDomain * domain, struct MonoImage * image, int table_index)
{
  struct MonoClass * module_type.367;
  struct MonoImage * D.31720;
  _Bool D.31723;
  long int D.31724;
  long int D.31725;
  <unnamed-unsigned:24> D.31728;
  int D.31729;
  _Bool D.31730;
  long int D.31731;
  long int D.31732;
  struct MonoReflectionAssembly * * D.31735;
  struct MonoAssembly * D.31736;
  struct MonoReflectionAssembly * D.31737;
  unsigned int D.31738;
  int i.368;
  int D.20703;
  struct MonoImage * * D.31742;
  unsigned int D.31743;
  struct MonoImage * * D.31744;
  struct MonoImage * D.31745;
  unsigned int D.31746;
  struct MonoString * * D.31747;
  struct MonoString * D.31748;
  struct MonoString * * D.31749;
  struct MonoString * D.31750;
  struct MonoString * * D.31751;
  struct MonoString * D.31752;
  unsigned int D.31753;
  _Bool D.31754;
  unsigned char D.31755;
  int D.31756;
  int D.31757;
  unsigned int D.31758;
  struct MonoReflectionModule * D.31759;
  static struct MonoClass * module_type;
  struct MonoReflectionModule * res;
  struct MonoTableInfo * table;
  guint32 cols[3];
  const char * name;
  guint32 i;
  guint32 name_idx;
  const char * val;

  try
    {
      module_type.367 = module_type;
      if (module_type.367 == 0B) goto <D.31718>; else goto <D.31719>;
      <D.31718>:
      {
        struct MonoClass * class;

        D.31720 = mono_defaults.corlib;
        class = mono_class_from_name (D.31720, "System.Reflection", "MonoModule");
        if (class == 0B) goto <D.31721>; else goto <D.31722>;
        <D.31721>:
        D.31720 = mono_defaults.corlib;
        class = mono_class_from_name (D.31720, "System.Reflection", "Module");
        <D.31722>:
        D.31723 = class == 0B;
        D.31724 = (long int) D.31723;
        D.31725 = __builtin_expect (D.31724, 0);
        if (D.31725 != 0) goto <D.31726>; else goto <D.31727>;
        <D.31726>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6320, "class");
        <D.31727>:
        module_type = class;
      }
      <D.31719>:
      module_type.367 = module_type;
      res = mono_object_new (domain, module_type.367);
      table = &image->tables[38];
      D.31728 = table->rows;
      D.31729 = (int) D.31728;
      D.31730 = D.31729 <= table_index;
      D.31731 = (long int) D.31730;
      D.31732 = __builtin_expect (D.31731, 0);
      if (D.31732 != 0) goto <D.31733>; else goto <D.31734>;
      <D.31733>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6326, "table_index < table->rows");
      <D.31734>:
      mono_metadata_decode_row (table, table_index, &cols, 3);
      res->image = 0B;
      D.31735 = &res->assembly;
      D.31736 = image->assembly;
      D.31737 = mono_assembly_get_object (domain, D.31736);
      mono_gc_wbarrier_set_field (res, D.31735, D.31737);
      D.31738 = cols[1];
      name = mono_metadata_string_heap (image, D.31738);
      table = &image->tables[26];
      i = 0;
      goto <D.20705>;
      <D.20704>:
      i.368 = (int) i;
      name_idx = mono_metadata_decode_row_col (table, i.368, 0);
      val = mono_metadata_string_heap (image, name_idx);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.20703 = __builtin_strcmp (val, name);
      }
      if (D.20703 == 0) goto <D.31740>; else goto <D.31741>;
      <D.31740>:
      D.31742 = image->modules;
      D.31743 = i * 4;
      D.31744 = D.31742 + D.31743;
      D.31745 = *D.31744;
      res->image = D.31745;
      <D.31741>:
      i = i + 1;
      <D.20705>:
      D.31728 = table->rows;
      D.31746 = (unsigned int) D.31728;
      if (D.31746 > i) goto <D.20704>; else goto <D.20706>;
      <D.20706>:
      D.31747 = &res->fqname;
      D.31748 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.31747, D.31748);
      D.31749 = &res->name;
      D.31750 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.31749, D.31750);
      D.31751 = &res->scopename;
      D.31752 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.31751, D.31752);
      D.31753 = cols[0];
      D.31754 = D.31753 != 0;
      D.31755 = (unsigned char) D.31754;
      res->is_resource = D.31755;
      D.31756 = table_index + 1;
      D.31757 = D.31756 | 637534208;
      D.31758 = (unsigned int) D.31757;
      res->token = D.31758;
      D.31759 = res;
      return D.31759;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_type_get_object (struct MonoDomain * domain, struct MonoType * type)
{
  struct MonoType * iftmp.369;
  <unnamed-unsigned:1> D.31763;
  <unnamed-unsigned:1> D.31764;
  unsigned char D.31768;
  struct MonoObject * D.31771;
  struct MonoReflectionType * D.31774;
  struct MonoType * D.31775;
  struct MonoImage * D.31778;
  unsigned int D.31779;
  unsigned int D.31780;
  void * D.31785;
  union mono_mutex_t * D.31788;
  _Bool D.31791;
  long int D.31792;
  long int D.31793;
  struct MonoGHashTable * D.31796;
  struct MonoGHashTable * D.31799;
  _Bool D.31804;
  long int D.31805;
  long int D.31806;
  _Bool D.31813;
  long int D.31814;
  long int D.31815;
  struct MonoGenericClass * D.31820;
  unsigned int D.31821;
  unsigned int D.31822;
  struct MonoClass * D.31825;
  unsigned int D.31826;
  unsigned int D.31827;
  int D.31832;
  _Bool D.31837;
  long int D.31838;
  long int D.31839;
  struct MonoException * D.31842;
  void * D.31843;
  unsigned int D.31846;
  unsigned int D.31847;
  unsigned char D.31852;
  struct MonoGenericContainer * D.31856;
  unsigned int D.31858;
  unsigned int D.31859;
  struct MonoClass * D.31863;
  struct MonoClass * D.31864;
  unsigned int D.31865;
  unsigned int D.31866;
  struct MonoClass * D.31875;
  unsigned int D.31876;
  unsigned int D.31877;
  unsigned int D.31882;
  unsigned int D.31883;
  _Bool D.31888;
  long int D.31889;
  long int D.31890;
  struct MonoClass * D.31893;
  _Bool D.31898;
  long int D.31899;
  long int D.31900;
  struct MonoType * norm_type;
  struct MonoReflectionType * res;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (type);
  D.31763 = klass->byval_arg.byref;
  D.31764 = type->byref;
  if (D.31763 == D.31764) goto <D.31765>; else goto <D.31766>;
  <D.31765>:
  iftmp.369 = &klass->byval_arg;
  goto <D.31767>;
  <D.31766>:
  iftmp.369 = &klass->this_arg;
  <D.31767>:
  type = iftmp.369;
  D.31768 = type->type;
  if (D.31768 == 1) goto <D.31769>; else goto <D.31770>;
  <D.31769>:
  D.31771 = domain->typeof_void;
  if (D.31771 != 0B) goto <D.31772>; else goto <D.31773>;
  <D.31772>:
  D.31774 = domain->typeof_void;
  return D.31774;
  <D.31773>:
  <D.31770>:
  D.31775 = &klass->byval_arg;
  if (D.31775 == type) goto <D.31776>; else goto <D.31777>;
  <D.31776>:
  D.31778 = klass->image;
  D.31779 = BIT_FIELD_REF <*D.31778, 32, 128>;
  D.31780 = D.31779 & 8;
  if (D.31780 == 0) goto <D.31781>; else goto <D.31782>;
  <D.31781>:
  {
    struct MonoVTable * vtable;

    vtable = mono_class_try_get_vtable (domain, klass);
    if (vtable != 0B) goto <D.31783>; else goto <D.31784>;
    <D.31783>:
    D.31785 = vtable->type;
    if (D.31785 != 0B) goto <D.31786>; else goto <D.31787>;
    <D.31786>:
    D.31774 = vtable->type;
    return D.31774;
    <D.31787>:
    <D.31784>:
  }
  <D.31782>:
  <D.31777>:
  mono_loader_lock ();
  {
    int ret;

    D.31788 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31788);
    if (ret != 0) goto <D.31789>; else goto <D.31790>;
    <D.31789>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31790>:
    D.31791 = ret != 0;
    D.31792 = (long int) D.31791;
    D.31793 = __builtin_expect (D.31792, 0);
    if (D.31793 != 0) goto <D.31794>; else goto <D.31795>;
    <D.31794>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6462, "ret == 0");
    <D.31795>:
  }
  D.31796 = domain->type_hash;
  if (D.31796 == 0B) goto <D.31797>; else goto <D.31798>;
  <D.31797>:
  D.31799 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.31799;
  <D.31798>:
  D.31796 = domain->type_hash;
  res = mono_g_hash_table_lookup (D.31796, type);
  if (res != 0B) goto <D.31800>; else goto <D.31801>;
  <D.31800>:
  {
    int ret;

    D.31788 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31788);
    if (ret != 0) goto <D.31802>; else goto <D.31803>;
    <D.31802>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31803>:
    D.31804 = ret != 0;
    D.31805 = (long int) D.31804;
    D.31806 = __builtin_expect (D.31805, 0);
    if (D.31806 != 0) goto <D.31807>; else goto <D.31808>;
    <D.31807>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6467, "ret == 0");
    <D.31808>:
  }
  mono_loader_unlock ();
  D.31774 = res;
  return D.31774;
  <D.31801>:
  norm_type = mono_type_normalize (type);
  if (norm_type != type) goto <D.31809>; else goto <D.31810>;
  <D.31809>:
  res = mono_type_get_object (domain, norm_type);
  D.31796 = domain->type_hash;
  mono_g_hash_table_insert (D.31796, type, res);
  {
    int ret;

    D.31788 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31788);
    if (ret != 0) goto <D.31811>; else goto <D.31812>;
    <D.31811>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31812>:
    D.31813 = ret != 0;
    D.31814 = (long int) D.31813;
    D.31815 = __builtin_expect (D.31814, 0);
    if (D.31815 != 0) goto <D.31816>; else goto <D.31817>;
    <D.31816>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6483, "ret == 0");
    <D.31817>:
  }
  mono_loader_unlock ();
  D.31774 = res;
  return D.31774;
  <D.31810>:
  D.31768 = type->type;
  if (D.31768 == 21) goto <D.31818>; else goto <D.31819>;
  <D.31818>:
  D.31820 = type->data.generic_class;
  D.31821 = BIT_FIELD_REF <*D.31820, 32, 96>;
  D.31822 = D.31821 & 1;
  if (D.31822 != 0) goto <D.31823>; else goto <D.31824>;
  <D.31823>:
  D.31820 = type->data.generic_class;
  D.31825 = D.31820->container_class;
  D.31826 = BIT_FIELD_REF <*D.31825, 32, 160>;
  D.31827 = D.31826 & 128;
  if (D.31827 == 0) goto <D.31828>; else goto <D.31829>;
  <D.31828>:
  if (1 != 0) goto <D.31830>; else goto <D.31831>;
  <D.31830>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6490, "0");
  <D.31831>:
  <D.31829>:
  <D.31824>:
  <D.31819>:
  D.31832 = verify_safe_for_managed_space (type);
  if (D.31832 == 0) goto <D.31833>; else goto <D.31834>;
  <D.31833>:
  {
    int ret;

    D.31788 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31788);
    if (ret != 0) goto <D.31835>; else goto <D.31836>;
    <D.31835>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31836>:
    D.31837 = ret != 0;
    D.31838 = (long int) D.31837;
    D.31839 = __builtin_expect (D.31838, 0);
    if (D.31839 != 0) goto <D.31840>; else goto <D.31841>;
    <D.31840>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6493, "ret == 0");
    <D.31841>:
  }
  mono_loader_unlock ();
  D.31842 = mono_get_exception_invalid_operation ("This type cannot be propagated to managed space");
  mono_raise_exception (D.31842);
  <D.31834>:
  D.31843 = mono_class_get_ref_info (klass);
  if (D.31843 != 0B) goto <D.31844>; else goto <D.31845>;
  <D.31844>:
  D.31846 = BIT_FIELD_REF <*klass, 32, 160>;
  D.31847 = D.31846 & 128;
  if (D.31847 == 0) goto <D.31848>; else goto <D.31849>;
  <D.31848>:
  {
    gboolean is_type_done;

    is_type_done = 1;
    D.31852 = klass->byval_arg.type;
    if (D.31852 == 30) goto <D.31850>; else goto <D.31853>;
    <D.31853>:
    D.31852 = klass->byval_arg.type;
    if (D.31852 == 19) goto <D.31850>; else goto <D.31851>;
    <D.31850>:
    {
      struct MonoGenericParam * gparam;

      gparam = klass->byval_arg.data.generic_param;
      D.31856 = gparam->owner;
      if (D.31856 != 0B) goto <D.31857>; else goto <D.31854>;
      <D.31857>:
      D.31856 = gparam->owner;
      D.31858 = BIT_FIELD_REF <*D.31856, 32, 128>;
      D.31859 = D.31858 & 2147483648;
      if (D.31859 != 0) goto <D.31860>; else goto <D.31854>;
      <D.31860>:
      {
        struct MonoMethod * method;

        D.31856 = gparam->owner;
        method = D.31856->owner.method;
        if (method != 0B) goto <D.31861>; else goto <D.31862>;
        <D.31861>:
        D.31863 = method->klass;
        D.31864 = mono_class_get_generic_type_definition (D.31863);
        D.31865 = BIT_FIELD_REF <*D.31864, 32, 160>;
        D.31866 = D.31865 & 128;
        if (D.31866 != 0) goto <D.31867>; else goto <D.31868>;
        <D.31867>:
        is_type_done = 0;
        <D.31868>:
        <D.31862>:
      }
      goto <D.31855>;
      <D.31854>:
      D.31856 = gparam->owner;
      if (D.31856 != 0B) goto <D.31869>; else goto <D.31870>;
      <D.31869>:
      D.31856 = gparam->owner;
      D.31858 = BIT_FIELD_REF <*D.31856, 32, 128>;
      D.31859 = D.31858 & 2147483648;
      if (D.31859 == 0) goto <D.31871>; else goto <D.31872>;
      <D.31871>:
      {
        struct MonoClass * klass;

        D.31856 = gparam->owner;
        klass = D.31856->owner.klass;
        if (klass != 0B) goto <D.31873>; else goto <D.31874>;
        <D.31873>:
        D.31875 = mono_class_get_generic_type_definition (klass);
        D.31876 = BIT_FIELD_REF <*D.31875, 32, 160>;
        D.31877 = D.31876 & 128;
        if (D.31877 != 0) goto <D.31878>; else goto <D.31879>;
        <D.31878>:
        is_type_done = 0;
        <D.31879>:
        <D.31874>:
      }
      <D.31872>:
      <D.31870>:
      <D.31855>:
    }
    <D.31851>:
    if (is_type_done != 0) goto <D.31880>; else goto <D.31881>;
    <D.31880>:
    D.31882 = BIT_FIELD_REF <*type, 32, 32>;
    D.31883 = D.31882 & 1073741824;
    if (D.31883 == 0) goto <D.31884>; else goto <D.31885>;
    <D.31884>:
    {
      int ret;

      D.31788 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.31788);
      if (ret != 0) goto <D.31886>; else goto <D.31887>;
      <D.31886>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.31887>:
      D.31888 = ret != 0;
      D.31889 = (long int) D.31888;
      D.31890 = __builtin_expect (D.31889, 0);
      if (D.31890 != 0) goto <D.31891>; else goto <D.31892>;
      <D.31891>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6521, "ret == 0");
      <D.31892>:
    }
    mono_loader_unlock ();
    D.31774 = mono_class_get_ref_info (klass);
    return D.31774;
    <D.31885>:
    <D.31881>:
  }
  <D.31849>:
  <D.31845>:
  D.31893 = mono_defaults.monotype_class;
  res = mono_object_new_pinned (domain, D.31893);
  res->type = type;
  D.31796 = domain->type_hash;
  mono_g_hash_table_insert (D.31796, type, res);
  D.31768 = type->type;
  if (D.31768 == 1) goto <D.31894>; else goto <D.31895>;
  <D.31894>:
  domain->typeof_void = res;
  <D.31895>:
  {
    int ret;

    D.31788 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31788);
    if (ret != 0) goto <D.31896>; else goto <D.31897>;
    <D.31896>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31897>:
    D.31898 = ret != 0;
    D.31899 = (long int) D.31898;
    D.31900 = __builtin_expect (D.31899, 0);
    if (D.31900 != 0) goto <D.31901>; else goto <D.31902>;
    <D.31901>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6534, "ret == 0");
    <D.31902>:
  }
  mono_loader_unlock ();
  D.31774 = res;
  return D.31774;
}


mono_type_normalize (struct MonoType * type)
{
  unsigned char D.31904;
  struct MonoType * D.31907;
  unsigned int D.31908;
  unsigned int D.31909;
  <unnamed-unsigned:22> D.31912;
  unsigned int D.31913;
  unsigned int D.31914;
  unsigned char D.31917;
  struct MonoGenericParam * D.31919;
  short unsigned int D.31920;
  int D.31921;
  struct MonoGenericContainer * D.31923;
  unsigned int i.370;
  unsigned int D.31925;
  struct MonoType * * D.31926;
  int D.31929;
  struct MonoType * iftmp.371;
  <unnamed-unsigned:1> D.31933;
  <unnamed-unsigned:1> D.31934;
  <unnamed-unsigned:1> D.31940;
  int D.31941;
  struct MonoType * iftmp.372;
  <unnamed-unsigned:1> D.31943;
  int i;
  struct MonoGenericClass * gclass;
  struct MonoGenericInst * ginst;
  struct MonoClass * gtd;
  struct MonoGenericContainer * gcontainer;
  struct MonoType * * argv;
  gboolean is_denorm_gtd;
  gboolean requires_rebind;

  argv = 0B;
  is_denorm_gtd = 1;
  requires_rebind = 0;
  D.31904 = type->type;
  if (D.31904 != 21) goto <D.31905>; else goto <D.31906>;
  <D.31905>:
  D.31907 = type;
  return D.31907;
  <D.31906>:
  gclass = type->data.generic_class;
  ginst = gclass->context.class_inst;
  D.31908 = BIT_FIELD_REF <*ginst, 32, 32>;
  D.31909 = D.31908 & 4194304;
  if (D.31909 == 0) goto <D.31910>; else goto <D.31911>;
  <D.31910>:
  D.31907 = type;
  return D.31907;
  <D.31911>:
  gtd = gclass->container_class;
  gcontainer = gtd->generic_container;
  D.31912 = ginst->type_argc;
  D.31913 = (unsigned int) D.31912;
  D.31914 = D.31913 * 4;
  argv = __builtin_alloca (D.31914);
  i = 0;
  goto <D.20726>;
  <D.20725>:
  {
    struct MonoType * t;
    struct MonoType * norm;

    t = ginst->type_argv[i];
    D.31917 = t->type;
    if (D.31917 != 19) goto <D.31915>; else goto <D.31918>;
    <D.31918>:
    D.31919 = t->data.generic_param;
    D.31920 = D.31919->num;
    D.31921 = (int) D.31920;
    if (D.31921 != i) goto <D.31915>; else goto <D.31922>;
    <D.31922>:
    D.31919 = t->data.generic_param;
    D.31923 = D.31919->owner;
    if (D.31923 != gcontainer) goto <D.31915>; else goto <D.31916>;
    <D.31915>:
    is_denorm_gtd = 0;
    <D.31916>:
    norm = mono_type_normalize (t);
    i.370 = (unsigned int) i;
    D.31925 = i.370 * 4;
    D.31926 = argv + D.31925;
    *D.31926 = norm;
    if (norm != t) goto <D.31927>; else goto <D.31928>;
    <D.31927>:
    requires_rebind = 1;
    <D.31928>:
  }
  i = i + 1;
  <D.20726>:
  D.31912 = ginst->type_argc;
  D.31929 = (int) D.31912;
  if (D.31929 > i) goto <D.20725>; else goto <D.20727>;
  <D.20727>:
  if (is_denorm_gtd != 0) goto <D.31930>; else goto <D.31931>;
  <D.31930>:
  D.31933 = type->byref;
  D.31934 = gtd->byval_arg.byref;
  if (D.31933 == D.31934) goto <D.31935>; else goto <D.31936>;
  <D.31935>:
  iftmp.371 = &gtd->byval_arg;
  goto <D.31937>;
  <D.31936>:
  iftmp.371 = &gtd->this_arg;
  <D.31937>:
  D.31907 = iftmp.371;
  return D.31907;
  <D.31931>:
  if (requires_rebind != 0) goto <D.31938>; else goto <D.31939>;
  <D.31938>:
  {
    struct MonoClass * klass;

    D.31912 = ginst->type_argc;
    D.31929 = (int) D.31912;
    D.31940 = gclass->is_dynamic;
    D.31941 = (int) D.31940;
    klass = mono_class_bind_generic_parameters (gtd, D.31929, argv, D.31941);
    D.31933 = type->byref;
    D.31943 = klass->byval_arg.byref;
    if (D.31933 == D.31943) goto <D.31944>; else goto <D.31945>;
    <D.31944>:
    iftmp.372 = &klass->byval_arg;
    goto <D.31946>;
    <D.31945>:
    iftmp.372 = &klass->this_arg;
    <D.31946>:
    D.31907 = iftmp.372;
    return D.31907;
  }
  <D.31939>:
  D.31907 = type;
  return D.31907;
}


verify_safe_for_managed_space (struct MonoType * type)
{
  unsigned char D.31948;
  int D.31949;
  gboolean D.31950;

  D.31948 = type->type;
  D.31949 = (int) D.31948;
  switch (D.31949) <default: <D.31951>, case 19: <D.20710>, case 30: <D.20711>>
  <D.20710>:
  <D.20711>:
  D.31950 = 1;
  return D.31950;
  <D.31951>:
  D.31950 = 1;
  return D.31950;
}


mono_method_get_object (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  unsigned int D.31953;
  unsigned int D.31954;
  union mono_mutex_t * D.31957;
  _Bool D.31960;
  long int D.31961;
  long int D.31962;
  struct MonoGHashTable * D.31965;
  struct MonoGHashTable * D.31968;
  _Bool D.31973;
  long int D.31974;
  long int D.31975;
  struct MonoReflectionMethod * D.31978;
  _Bool D.31981;
  long int D.31982;
  long int D.31983;
  const char * D.31989;
  char D.31990;
  int D.20772;
  int iftmp.373;
  int D.20771;
  const char[6] * D.31995;
  unsigned char D.31996;
  int D.31997;
  unsigned char D.31998;
  int D.31999;
  const unsigned char * D.32004;
  unsigned char D.32005;
  int D.32006;
  const unsigned char * D.32007;
  unsigned char D.32008;
  int D.32009;
  const unsigned char * D.32014;
  unsigned char D.32015;
  int D.32016;
  const unsigned char * D.32017;
  unsigned char D.32018;
  int D.32019;
  const unsigned char * D.32024;
  unsigned char D.32025;
  int D.32026;
  const unsigned char * D.32027;
  unsigned char D.32028;
  int D.32029;
  int D.20781;
  int iftmp.374;
  int D.20780;
  const char[7] * D.32035;
  unsigned char D.32036;
  int D.32037;
  unsigned char D.32038;
  int D.32039;
  const unsigned char * D.32044;
  unsigned char D.32045;
  int D.32046;
  const unsigned char * D.32047;
  unsigned char D.32048;
  int D.32049;
  const unsigned char * D.32054;
  unsigned char D.32055;
  int D.32056;
  const unsigned char * D.32057;
  unsigned char D.32058;
  int D.32059;
  const unsigned char * D.32064;
  unsigned char D.32065;
  int D.32066;
  const unsigned char * D.32067;
  unsigned char D.32068;
  int D.32069;
  struct MonoClass * System_Reflection_MonoGenericCMethod.375;
  struct MonoImage * D.32074;
  struct MonoClass * System_Reflection_MonoGenericCMethod.376;
  struct MonoClass * System_Reflection_MonoGenericMethod.377;
  struct MonoClass * System_Reflection_MonoGenericMethod.378;
  struct MonoString * * D.32080;
  struct MonoString * D.32081;
  struct MonoReflectionType * * D.32082;
  struct MonoType * D.32083;
  struct MonoReflectionType * D.32084;
  _Bool D.32087;
  long int D.32088;
  long int D.32089;
  struct MonoGHashTable * D.32094;
  struct MonoMemPool * D.32097;
  _Bool D.32100;
  long int D.32101;
  long int D.32102;
  _Bool D.32109;
  long int D.32110;
  long int D.32111;
  struct MonoGHashTable * D.32116;
  _Bool D.32121;
  long int D.32122;
  long int D.32123;
  _Bool D.32128;
  long int D.32129;
  long int D.32130;
  int D.20800;
  int iftmp.379;
  int D.20799;
  unsigned char D.32140;
  int D.32141;
  const unsigned char * D.32146;
  unsigned char D.32147;
  int D.32148;
  const unsigned char * D.32153;
  unsigned char D.32154;
  int D.32155;
  const unsigned char * D.32160;
  unsigned char D.32161;
  int D.32162;
  int D.20809;
  int iftmp.380;
  int D.20808;
  unsigned char D.32168;
  int D.32169;
  const unsigned char * D.32174;
  unsigned char D.32175;
  int D.32176;
  const unsigned char * D.32181;
  unsigned char D.32182;
  int D.32183;
  const unsigned char * D.32188;
  unsigned char D.32189;
  int D.32190;
  struct MonoClass * System_Reflection_MonoCMethod.381;
  struct MonoClass * System_Reflection_MonoCMethod.382;
  struct MonoClass * System_Reflection_MonoMethod.383;
  struct MonoClass * System_Reflection_MonoMethod.384;
  struct MonoReflectionType * * D.32200;
  struct MonoReflectionType * D.32201;
  _Bool D.32204;
  long int D.32205;
  long int D.32206;
  struct MonoGHashTable * D.32211;
  _Bool D.32216;
  long int D.32217;
  long int D.32218;
  static struct MonoClass * System_Reflection_MonoMethod = 0B;
  static struct MonoClass * System_Reflection_MonoCMethod = 0B;
  static struct MonoClass * System_Reflection_MonoGenericMethod = 0B;
  static struct MonoClass * System_Reflection_MonoGenericCMethod = 0B;
  struct MonoClass * klass;
  struct MonoReflectionMethod * ret;

  D.31953 = BIT_FIELD_REF <*method, 32, 160>;
  D.31954 = D.31953 & 4096;
  if (D.31954 != 0) goto <D.31955>; else goto <D.31956>;
  <D.31955>:
  {
    struct MonoReflectionGenericMethod * gret;

    refclass = method->klass;
    {
      struct MonoReflectionMethod * _obj;
      struct ReflectedEntry e;

      try
        {
          e.item = method;
          e.refclass = refclass;
          {
            int ret;

            D.31957 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.31957);
            if (ret != 0) goto <D.31958>; else goto <D.31959>;
            <D.31958>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.31959>:
            D.31960 = ret != 0;
            D.31961 = (long int) D.31960;
            D.31962 = __builtin_expect (D.31961, 0);
            if (D.31962 != 0) goto <D.31963>; else goto <D.31964>;
            <D.31963>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.31964>:
          }
          D.31965 = domain->refobject_hash;
          if (D.31965 == 0B) goto <D.31966>; else goto <D.31967>;
          <D.31966>:
          D.31968 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.31968;
          <D.31967>:
          D.31965 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.31965, &e);
          if (_obj != 0B) goto <D.31969>; else goto <D.31970>;
          <D.31969>:
          {
            int ret;

            D.31957 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.31957);
            if (ret != 0) goto <D.31971>; else goto <D.31972>;
            <D.31971>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.31972>:
            D.31973 = ret != 0;
            D.31974 = (long int) D.31973;
            D.31975 = __builtin_expect (D.31974, 0);
            if (D.31975 != 0) goto <D.31976>; else goto <D.31977>;
            <D.31976>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.31977>:
          }
          D.31978 = _obj;
          return D.31978;
          <D.31970>:
          {
            int ret;

            D.31957 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.31957);
            if (ret != 0) goto <D.31979>; else goto <D.31980>;
            <D.31979>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.31980>:
            D.31981 = ret != 0;
            D.31982 = (long int) D.31981;
            D.31983 = __builtin_expect (D.31982, 0);
            if (D.31983 != 0) goto <D.31984>; else goto <D.31985>;
            <D.31984>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.31985>:
          }
        }
      finally
        {
          e = {CLOBBER};
        }
    }
    D.31989 = method->name;
    D.31990 = *D.31989;
    if (D.31990 == 46) goto <D.31991>; else goto <D.31986>;
    <D.31991>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.31995 = ".ctor";
        D.31996 = MEM[(const unsigned char *)D.31995];
        D.31997 = (int) D.31996;
        D.31998 = *__s2;
        D.31999 = (int) D.31998;
        __result = D.31997 - D.31999;
        {
          if (__s2_len != 0) goto <D.32000>; else goto <D.32001>;
          <D.32000>:
          if (__result == 0) goto <D.32002>; else goto <D.32003>;
          <D.32002>:
          D.32004 = &MEM[(void *)".ctor" + 1B];
          D.32005 = *D.32004;
          D.32006 = (int) D.32005;
          D.32007 = __s2 + 1;
          D.32008 = *D.32007;
          D.32009 = (int) D.32008;
          __result = D.32006 - D.32009;
          if (__s2_len > 1) goto <D.32010>; else goto <D.32011>;
          <D.32010>:
          if (__result == 0) goto <D.32012>; else goto <D.32013>;
          <D.32012>:
          D.32014 = &MEM[(void *)".ctor" + 2B];
          D.32015 = *D.32014;
          D.32016 = (int) D.32015;
          D.32017 = __s2 + 2;
          D.32018 = *D.32017;
          D.32019 = (int) D.32018;
          __result = D.32016 - D.32019;
          if (__s2_len > 2) goto <D.32020>; else goto <D.32021>;
          <D.32020>:
          if (__result == 0) goto <D.32022>; else goto <D.32023>;
          <D.32022>:
          D.32024 = &MEM[(void *)".ctor" + 3B];
          D.32025 = *D.32024;
          D.32026 = (int) D.32025;
          D.32027 = __s2 + 3;
          D.32028 = *D.32027;
          D.32029 = (int) D.32028;
          __result = D.32026 - D.32029;
          <D.32023>:
          <D.32021>:
          <D.32013>:
          <D.32011>:
          <D.32003>:
          <D.32001>:
        }
        D.20771 = __result;
      }
      iftmp.373 = -D.20771;
      goto <D.32030>;
      <D.31994>:
      D.31989 = method->name;
      iftmp.373 = __builtin_strcmp (D.31989, ".ctor");
      <D.32030>:
      D.20772 = iftmp.373;
    }
    if (D.20772 == 0) goto <D.31987>; else goto <D.32031>;
    <D.32031>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.32035 = ".cctor";
        D.32036 = MEM[(const unsigned char *)D.32035];
        D.32037 = (int) D.32036;
        D.32038 = *__s2;
        D.32039 = (int) D.32038;
        __result = D.32037 - D.32039;
        {
          if (__s2_len != 0) goto <D.32040>; else goto <D.32041>;
          <D.32040>:
          if (__result == 0) goto <D.32042>; else goto <D.32043>;
          <D.32042>:
          D.32044 = &MEM[(void *)".cctor" + 1B];
          D.32045 = *D.32044;
          D.32046 = (int) D.32045;
          D.32047 = __s2 + 1;
          D.32048 = *D.32047;
          D.32049 = (int) D.32048;
          __result = D.32046 - D.32049;
          if (__s2_len > 1) goto <D.32050>; else goto <D.32051>;
          <D.32050>:
          if (__result == 0) goto <D.32052>; else goto <D.32053>;
          <D.32052>:
          D.32054 = &MEM[(void *)".cctor" + 2B];
          D.32055 = *D.32054;
          D.32056 = (int) D.32055;
          D.32057 = __s2 + 2;
          D.32058 = *D.32057;
          D.32059 = (int) D.32058;
          __result = D.32056 - D.32059;
          if (__s2_len > 2) goto <D.32060>; else goto <D.32061>;
          <D.32060>:
          if (__result == 0) goto <D.32062>; else goto <D.32063>;
          <D.32062>:
          D.32064 = &MEM[(void *)".cctor" + 3B];
          D.32065 = *D.32064;
          D.32066 = (int) D.32065;
          D.32067 = __s2 + 3;
          D.32068 = *D.32067;
          D.32069 = (int) D.32068;
          __result = D.32066 - D.32069;
          <D.32063>:
          <D.32061>:
          <D.32053>:
          <D.32051>:
          <D.32043>:
          <D.32041>:
        }
        D.20780 = __result;
      }
      iftmp.374 = -D.20780;
      goto <D.32070>;
      <D.32034>:
      D.31989 = method->name;
      iftmp.374 = __builtin_strcmp (D.31989, ".cctor");
      <D.32070>:
      D.20781 = iftmp.374;
    }
    if (D.20781 == 0) goto <D.31987>; else goto <D.31986>;
    <D.31987>:
    System_Reflection_MonoGenericCMethod.375 = System_Reflection_MonoGenericCMethod;
    if (System_Reflection_MonoGenericCMethod.375 == 0B) goto <D.32072>; else goto <D.32073>;
    <D.32072>:
    D.32074 = mono_defaults.corlib;
    System_Reflection_MonoGenericCMethod.376 = mono_class_from_name (D.32074, "System.Reflection", "MonoGenericCMethod");
    System_Reflection_MonoGenericCMethod = System_Reflection_MonoGenericCMethod.376;
    <D.32073>:
    klass = System_Reflection_MonoGenericCMethod;
    goto <D.31988>;
    <D.31986>:
    System_Reflection_MonoGenericMethod.377 = System_Reflection_MonoGenericMethod;
    if (System_Reflection_MonoGenericMethod.377 == 0B) goto <D.32077>; else goto <D.32078>;
    <D.32077>:
    D.32074 = mono_defaults.corlib;
    System_Reflection_MonoGenericMethod.378 = mono_class_from_name (D.32074, "System.Reflection", "MonoGenericMethod");
    System_Reflection_MonoGenericMethod = System_Reflection_MonoGenericMethod.378;
    <D.32078>:
    klass = System_Reflection_MonoGenericMethod;
    <D.31988>:
    gret = mono_object_new (domain, klass);
    gret->method.method = method;
    D.32080 = &gret->method.name;
    D.31989 = method->name;
    D.32081 = mono_string_new (domain, D.31989);
    mono_gc_wbarrier_set_field (gret, D.32080, D.32081);
    D.32082 = &gret->method.reftype;
    D.32083 = &refclass->byval_arg;
    D.32084 = mono_type_get_object (domain, D.32083);
    mono_gc_wbarrier_set_field (gret, D.32082, D.32084);
    {
      struct MonoReflectionMethod * _obj;
      struct ReflectedEntry pe;

      try
        {
          pe.item = method;
          pe.refclass = refclass;
          {
            int ret;

            D.31957 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.31957);
            if (ret != 0) goto <D.32085>; else goto <D.32086>;
            <D.32085>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.32086>:
            D.32087 = ret != 0;
            D.32088 = (long int) D.32087;
            D.32089 = __builtin_expect (D.32088, 0);
            if (D.32089 != 0) goto <D.32090>; else goto <D.32091>;
            <D.32090>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.32091>:
          }
          D.31965 = domain->refobject_hash;
          if (D.31965 == 0B) goto <D.32092>; else goto <D.32093>;
          <D.32092>:
          D.32094 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.32094;
          <D.32093>:
          D.31965 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.31965, &pe);
          if (_obj == 0B) goto <D.32095>; else goto <D.32096>;
          <D.32095>:
          {
            struct ReflectedEntry * e;

            D.32097 = domain->mp;
            e = mono_mempool_alloc (D.32097, 8);
            e->item = method;
            e->refclass = refclass;
            D.31965 = domain->refobject_hash;
            mono_g_hash_table_insert (D.31965, e, gret);
            _obj = gret;
          }
          <D.32096>:
          {
            int ret;

            D.31957 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.31957);
            if (ret != 0) goto <D.32098>; else goto <D.32099>;
            <D.32098>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.32099>:
            D.32100 = ret != 0;
            D.32101 = (long int) D.32100;
            D.32102 = __builtin_expect (D.32101, 0);
            if (D.32102 != 0) goto <D.32103>; else goto <D.32104>;
            <D.32103>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.32104>:
          }
          D.31978 = _obj;
          return D.31978;
        }
      finally
        {
          pe = {CLOBBER};
        }
    }
  }
  <D.31956>:
  if (refclass == 0B) goto <D.32105>; else goto <D.32106>;
  <D.32105>:
  refclass = method->klass;
  <D.32106>:
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = method;
        e.refclass = refclass;
        {
          int ret;

          D.31957 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31957);
          if (ret != 0) goto <D.32107>; else goto <D.32108>;
          <D.32107>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32108>:
          D.32109 = ret != 0;
          D.32110 = (long int) D.32109;
          D.32111 = __builtin_expect (D.32110, 0);
          if (D.32111 != 0) goto <D.32112>; else goto <D.32113>;
          <D.32112>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32113>:
        }
        D.31965 = domain->refobject_hash;
        if (D.31965 == 0B) goto <D.32114>; else goto <D.32115>;
        <D.32114>:
        D.32116 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32116;
        <D.32115>:
        D.31965 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31965, &e);
        if (_obj != 0B) goto <D.32117>; else goto <D.32118>;
        <D.32117>:
        {
          int ret;

          D.31957 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31957);
          if (ret != 0) goto <D.32119>; else goto <D.32120>;
          <D.32119>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32120>:
          D.32121 = ret != 0;
          D.32122 = (long int) D.32121;
          D.32123 = __builtin_expect (D.32122, 0);
          if (D.32123 != 0) goto <D.32124>; else goto <D.32125>;
          <D.32124>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32125>:
        }
        D.31978 = _obj;
        return D.31978;
        <D.32118>:
        {
          int ret;

          D.31957 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31957);
          if (ret != 0) goto <D.32126>; else goto <D.32127>;
          <D.32126>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32127>:
          D.32128 = ret != 0;
          D.32129 = (long int) D.32128;
          D.32130 = __builtin_expect (D.32129, 0);
          if (D.32130 != 0) goto <D.32131>; else goto <D.32132>;
          <D.32131>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32132>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.31989 = method->name;
  D.31990 = *D.31989;
  if (D.31990 == 46) goto <D.32136>; else goto <D.32133>;
  <D.32136>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.31995 = ".ctor";
      D.31996 = MEM[(const unsigned char *)D.31995];
      D.31997 = (int) D.31996;
      D.32140 = *__s2;
      D.32141 = (int) D.32140;
      __result = D.31997 - D.32141;
      {
        if (__s2_len != 0) goto <D.32142>; else goto <D.32143>;
        <D.32142>:
        if (__result == 0) goto <D.32144>; else goto <D.32145>;
        <D.32144>:
        D.32004 = &MEM[(void *)".ctor" + 1B];
        D.32005 = *D.32004;
        D.32006 = (int) D.32005;
        D.32146 = __s2 + 1;
        D.32147 = *D.32146;
        D.32148 = (int) D.32147;
        __result = D.32006 - D.32148;
        if (__s2_len > 1) goto <D.32149>; else goto <D.32150>;
        <D.32149>:
        if (__result == 0) goto <D.32151>; else goto <D.32152>;
        <D.32151>:
        D.32014 = &MEM[(void *)".ctor" + 2B];
        D.32015 = *D.32014;
        D.32016 = (int) D.32015;
        D.32153 = __s2 + 2;
        D.32154 = *D.32153;
        D.32155 = (int) D.32154;
        __result = D.32016 - D.32155;
        if (__s2_len > 2) goto <D.32156>; else goto <D.32157>;
        <D.32156>:
        if (__result == 0) goto <D.32158>; else goto <D.32159>;
        <D.32158>:
        D.32024 = &MEM[(void *)".ctor" + 3B];
        D.32025 = *D.32024;
        D.32026 = (int) D.32025;
        D.32160 = __s2 + 3;
        D.32161 = *D.32160;
        D.32162 = (int) D.32161;
        __result = D.32026 - D.32162;
        <D.32159>:
        <D.32157>:
        <D.32152>:
        <D.32150>:
        <D.32145>:
        <D.32143>:
      }
      D.20799 = __result;
    }
    iftmp.379 = -D.20799;
    goto <D.32163>;
    <D.32139>:
    D.31989 = method->name;
    iftmp.379 = __builtin_strcmp (D.31989, ".ctor");
    <D.32163>:
    D.20800 = iftmp.379;
  }
  if (D.20800 == 0) goto <D.32134>; else goto <D.32164>;
  <D.32164>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32035 = ".cctor";
      D.32036 = MEM[(const unsigned char *)D.32035];
      D.32037 = (int) D.32036;
      D.32168 = *__s2;
      D.32169 = (int) D.32168;
      __result = D.32037 - D.32169;
      {
        if (__s2_len != 0) goto <D.32170>; else goto <D.32171>;
        <D.32170>:
        if (__result == 0) goto <D.32172>; else goto <D.32173>;
        <D.32172>:
        D.32044 = &MEM[(void *)".cctor" + 1B];
        D.32045 = *D.32044;
        D.32046 = (int) D.32045;
        D.32174 = __s2 + 1;
        D.32175 = *D.32174;
        D.32176 = (int) D.32175;
        __result = D.32046 - D.32176;
        if (__s2_len > 1) goto <D.32177>; else goto <D.32178>;
        <D.32177>:
        if (__result == 0) goto <D.32179>; else goto <D.32180>;
        <D.32179>:
        D.32054 = &MEM[(void *)".cctor" + 2B];
        D.32055 = *D.32054;
        D.32056 = (int) D.32055;
        D.32181 = __s2 + 2;
        D.32182 = *D.32181;
        D.32183 = (int) D.32182;
        __result = D.32056 - D.32183;
        if (__s2_len > 2) goto <D.32184>; else goto <D.32185>;
        <D.32184>:
        if (__result == 0) goto <D.32186>; else goto <D.32187>;
        <D.32186>:
        D.32064 = &MEM[(void *)".cctor" + 3B];
        D.32065 = *D.32064;
        D.32066 = (int) D.32065;
        D.32188 = __s2 + 3;
        D.32189 = *D.32188;
        D.32190 = (int) D.32189;
        __result = D.32066 - D.32190;
        <D.32187>:
        <D.32185>:
        <D.32180>:
        <D.32178>:
        <D.32173>:
        <D.32171>:
      }
      D.20808 = __result;
    }
    iftmp.380 = -D.20808;
    goto <D.32191>;
    <D.32167>:
    D.31989 = method->name;
    iftmp.380 = __builtin_strcmp (D.31989, ".cctor");
    <D.32191>:
    D.20809 = iftmp.380;
  }
  if (D.20809 == 0) goto <D.32134>; else goto <D.32133>;
  <D.32134>:
  System_Reflection_MonoCMethod.381 = System_Reflection_MonoCMethod;
  if (System_Reflection_MonoCMethod.381 == 0B) goto <D.32193>; else goto <D.32194>;
  <D.32193>:
  D.32074 = mono_defaults.corlib;
  System_Reflection_MonoCMethod.382 = mono_class_from_name (D.32074, "System.Reflection", "MonoCMethod");
  System_Reflection_MonoCMethod = System_Reflection_MonoCMethod.382;
  <D.32194>:
  klass = System_Reflection_MonoCMethod;
  goto <D.32135>;
  <D.32133>:
  System_Reflection_MonoMethod.383 = System_Reflection_MonoMethod;
  if (System_Reflection_MonoMethod.383 == 0B) goto <D.32197>; else goto <D.32198>;
  <D.32197>:
  D.32074 = mono_defaults.corlib;
  System_Reflection_MonoMethod.384 = mono_class_from_name (D.32074, "System.Reflection", "MonoMethod");
  System_Reflection_MonoMethod = System_Reflection_MonoMethod.384;
  <D.32198>:
  klass = System_Reflection_MonoMethod;
  <D.32135>:
  ret = mono_object_new (domain, klass);
  ret->method = method;
  D.32200 = &ret->reftype;
  D.32083 = &refclass->byval_arg;
  D.32201 = mono_type_get_object (domain, D.32083);
  mono_gc_wbarrier_set_field (ret, D.32200, D.32201);
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = method;
        pe.refclass = refclass;
        {
          int ret;

          D.31957 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31957);
          if (ret != 0) goto <D.32202>; else goto <D.32203>;
          <D.32202>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32203>:
          D.32204 = ret != 0;
          D.32205 = (long int) D.32204;
          D.32206 = __builtin_expect (D.32205, 0);
          if (D.32206 != 0) goto <D.32207>; else goto <D.32208>;
          <D.32207>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32208>:
        }
        D.31965 = domain->refobject_hash;
        if (D.31965 == 0B) goto <D.32209>; else goto <D.32210>;
        <D.32209>:
        D.32211 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32211;
        <D.32210>:
        D.31965 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31965, &pe);
        if (_obj == 0B) goto <D.32212>; else goto <D.32213>;
        <D.32212>:
        {
          struct ReflectedEntry * e;

          D.32097 = domain->mp;
          e = mono_mempool_alloc (D.32097, 8);
          e->item = method;
          e->refclass = refclass;
          D.31965 = domain->refobject_hash;
          mono_g_hash_table_insert (D.31965, e, ret);
          _obj = ret;
        }
        <D.32213>:
        {
          int ret;

          D.31957 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31957);
          if (ret != 0) goto <D.32214>; else goto <D.32215>;
          <D.32214>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32215>:
          D.32216 = ret != 0;
          D.32217 = (long int) D.32216;
          D.32218 = __builtin_expect (D.32217, 0);
          if (D.32218 != 0) goto <D.32219>; else goto <D.32220>;
          <D.32219>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32220>:
        }
        D.31978 = _obj;
        return D.31978;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_method_clear_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned int D.32228;
  unsigned int D.32229;
  _Bool D.32230;
  long int D.32231;
  long int D.32232;
  struct MonoMethodSignature * * D.32235;
  struct MonoClass * klass;

  D.32228 = BIT_FIELD_REF <*method, 32, 160>;
  D.32229 = D.32228 & 512;
  D.32230 = D.32229 == 0;
  D.32231 = (long int) D.32230;
  D.32232 = __builtin_expect (D.32231, 0);
  if (D.32232 != 0) goto <D.32233>; else goto <D.32234>;
  <D.32233>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6611, "method->dynamic");
  <D.32234>:
  klass = method->klass;
  goto <D.20821>;
  <D.20820>:
  clear_cached_object (domain, method, klass);
  klass = klass->parent;
  <D.20821>:
  if (klass != 0B) goto <D.20820>; else goto <D.20822>;
  <D.20822>:
  D.32235 = &method->signature;
  clear_cached_object (domain, D.32235, 0B);
  klass = method->klass;
  goto <D.20824>;
  <D.20823>:
  D.32235 = &method->signature;
  clear_cached_object (domain, D.32235, klass);
  klass = klass->parent;
  <D.20824>:
  if (klass != 0B) goto <D.20823>; else goto <D.20825>;
  <D.20825>:
}


clear_cached_object (struct MonoDomain * domain, void * o, struct MonoClass * klass)
{
  union mono_mutex_t * D.32236;
  _Bool D.32239;
  long int D.32240;
  long int D.32241;
  struct MonoGHashTable * D.32244;
  int D.32247;
  _Bool D.32252;
  long int D.32253;
  long int D.32254;

  {
    int ret;

    D.32236 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32236);
    if (ret != 0) goto <D.32237>; else goto <D.32238>;
    <D.32237>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32238>:
    D.32239 = ret != 0;
    D.32240 = (long int) D.32239;
    D.32241 = __builtin_expect (D.32240, 0);
    if (D.32241 != 0) goto <D.32242>; else goto <D.32243>;
    <D.32242>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6127, "ret == 0");
    <D.32243>:
  }
  D.32244 = domain->refobject_hash;
  if (D.32244 != 0B) goto <D.32245>; else goto <D.32246>;
  <D.32245>:
  {
    struct ReflectedEntry pe;
    void * orig_pe;
    void * orig_value;

    try
      {
        pe.item = o;
        pe.refclass = klass;
        D.32244 = domain->refobject_hash;
        D.32247 = mono_g_hash_table_lookup_extended (D.32244, &pe, &orig_pe, &orig_value);
        if (D.32247 != 0) goto <D.32248>; else goto <D.32249>;
        <D.32248>:
        D.32244 = domain->refobject_hash;
        mono_g_hash_table_remove (D.32244, &pe);
        <D.32249>:
      }
    finally
      {
        pe = {CLOBBER};
        orig_pe = {CLOBBER};
        orig_value = {CLOBBER};
      }
  }
  <D.32246>:
  {
    int ret;

    D.32236 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32236);
    if (ret != 0) goto <D.32250>; else goto <D.32251>;
    <D.32250>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32251>:
    D.32252 = ret != 0;
    D.32253 = (long int) D.32252;
    D.32254 = __builtin_expect (D.32253, 0);
    if (D.32254 != 0) goto <D.32255>; else goto <D.32256>;
    <D.32255>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6139, "ret == 0");
    <D.32256>:
  }
}


mono_field_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoClassField * field)
{
  union mono_mutex_t * D.32257;
  _Bool D.32260;
  long int D.32261;
  long int D.32262;
  struct MonoGHashTable * D.32265;
  struct MonoGHashTable * D.32268;
  _Bool D.32273;
  long int D.32274;
  long int D.32275;
  struct MonoReflectionField * D.32278;
  _Bool D.32281;
  long int D.32282;
  long int D.32283;
  struct MonoClass * monofield_klass.385;
  struct MonoImage * D.32289;
  struct MonoClass * monofield_klass.386;
  struct MonoString * * D.32291;
  const char * D.32292;
  struct MonoString * D.32293;
  int D.32294;
  struct MonoType * D.32297;
  short unsigned int D.32298;
  unsigned int D.32299;
  struct MonoReflectionType * * D.32300;
  struct MonoType * D.32301;
  struct MonoReflectionType * D.32302;
  struct MonoReflectionType * D.32306;
  unsigned int D.32307;
  _Bool D.32310;
  long int D.32311;
  long int D.32312;
  struct MonoGHashTable * D.32317;
  struct MonoMemPool * D.32320;
  _Bool D.32323;
  long int D.32324;
  long int D.32325;
  struct MonoReflectionField * res;
  static struct MonoClass * monofield_klass;

  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = field;
        e.refclass = klass;
        {
          int ret;

          D.32257 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32257);
          if (ret != 0) goto <D.32258>; else goto <D.32259>;
          <D.32258>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32259>:
          D.32260 = ret != 0;
          D.32261 = (long int) D.32260;
          D.32262 = __builtin_expect (D.32261, 0);
          if (D.32262 != 0) goto <D.32263>; else goto <D.32264>;
          <D.32263>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32264>:
        }
        D.32265 = domain->refobject_hash;
        if (D.32265 == 0B) goto <D.32266>; else goto <D.32267>;
        <D.32266>:
        D.32268 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32268;
        <D.32267>:
        D.32265 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32265, &e);
        if (_obj != 0B) goto <D.32269>; else goto <D.32270>;
        <D.32269>:
        {
          int ret;

          D.32257 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32257);
          if (ret != 0) goto <D.32271>; else goto <D.32272>;
          <D.32271>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32272>:
          D.32273 = ret != 0;
          D.32274 = (long int) D.32273;
          D.32275 = __builtin_expect (D.32274, 0);
          if (D.32275 != 0) goto <D.32276>; else goto <D.32277>;
          <D.32276>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32277>:
        }
        D.32278 = _obj;
        return D.32278;
        <D.32270>:
        {
          int ret;

          D.32257 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32257);
          if (ret != 0) goto <D.32279>; else goto <D.32280>;
          <D.32279>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32280>:
          D.32281 = ret != 0;
          D.32282 = (long int) D.32281;
          D.32283 = __builtin_expect (D.32282, 0);
          if (D.32283 != 0) goto <D.32284>; else goto <D.32285>;
          <D.32284>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32285>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monofield_klass.385 = monofield_klass;
  if (monofield_klass.385 == 0B) goto <D.32287>; else goto <D.32288>;
  <D.32287>:
  D.32289 = mono_defaults.corlib;
  monofield_klass.386 = mono_class_from_name (D.32289, "System.Reflection", "MonoField");
  monofield_klass = monofield_klass.386;
  <D.32288>:
  monofield_klass.385 = monofield_klass;
  res = mono_object_new (domain, monofield_klass.385);
  res->klass = klass;
  res->field = field;
  D.32291 = &res->name;
  D.32292 = mono_field_get_name (field);
  D.32293 = mono_string_new (domain, D.32292);
  mono_gc_wbarrier_set_field (res, D.32291, D.32293);
  D.32294 = is_field_on_inst (field);
  if (D.32294 != 0) goto <D.32295>; else goto <D.32296>;
  <D.32295>:
  D.32297 = get_field_on_inst_generic_type (field);
  D.32298 = D.32297->attrs;
  D.32299 = (unsigned int) D.32298;
  res->attrs = D.32299;
  D.32300 = &res->type;
  D.32301 = field->type;
  D.32302 = mono_type_get_object (domain, D.32301);
  mono_gc_wbarrier_set_field (res, D.32300, D.32302);
  goto <D.32303>;
  <D.32296>:
  D.32301 = field->type;
  if (D.32301 != 0B) goto <D.32304>; else goto <D.32305>;
  <D.32304>:
  D.32300 = &res->type;
  D.32301 = field->type;
  D.32306 = mono_type_get_object (domain, D.32301);
  mono_gc_wbarrier_set_field (res, D.32300, D.32306);
  <D.32305>:
  D.32307 = mono_field_get_flags (field);
  res->attrs = D.32307;
  <D.32303>:
  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = field;
        pe.refclass = klass;
        {
          int ret;

          D.32257 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32257);
          if (ret != 0) goto <D.32308>; else goto <D.32309>;
          <D.32308>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32309>:
          D.32310 = ret != 0;
          D.32311 = (long int) D.32310;
          D.32312 = __builtin_expect (D.32311, 0);
          if (D.32312 != 0) goto <D.32313>; else goto <D.32314>;
          <D.32313>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.32314>:
        }
        D.32265 = domain->refobject_hash;
        if (D.32265 == 0B) goto <D.32315>; else goto <D.32316>;
        <D.32315>:
        D.32317 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32317;
        <D.32316>:
        D.32265 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32265, &pe);
        if (_obj == 0B) goto <D.32318>; else goto <D.32319>;
        <D.32318>:
        {
          struct ReflectedEntry * e;

          D.32320 = domain->mp;
          e = mono_mempool_alloc (D.32320, 8);
          e->item = field;
          e->refclass = klass;
          D.32265 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32265, e, res);
          _obj = res;
        }
        <D.32319>:
        {
          int ret;

          D.32257 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32257);
          if (ret != 0) goto <D.32321>; else goto <D.32322>;
          <D.32321>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32322>:
          D.32323 = ret != 0;
          D.32324 = (long int) D.32323;
          D.32325 = __builtin_expect (D.32324, 0);
          if (D.32325 != 0) goto <D.32326>; else goto <D.32327>;
          <D.32326>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.32327>:
        }
        D.32278 = _obj;
        return D.32278;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_property_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoProperty * property)
{
  union mono_mutex_t * D.32332;
  _Bool D.32335;
  long int D.32336;
  long int D.32337;
  struct MonoGHashTable * D.32340;
  struct MonoGHashTable * D.32343;
  _Bool D.32348;
  long int D.32349;
  long int D.32350;
  struct MonoReflectionProperty * D.32353;
  _Bool D.32356;
  long int D.32357;
  long int D.32358;
  struct MonoClass * monoproperty_klass.387;
  struct MonoImage * D.32364;
  struct MonoClass * monoproperty_klass.388;
  _Bool D.32368;
  long int D.32369;
  long int D.32370;
  struct MonoGHashTable * D.32375;
  struct MonoMemPool * D.32378;
  _Bool D.32381;
  long int D.32382;
  long int D.32383;
  struct MonoReflectionProperty * res;
  static struct MonoClass * monoproperty_klass;

  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = property;
        e.refclass = klass;
        {
          int ret;

          D.32332 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32332);
          if (ret != 0) goto <D.32333>; else goto <D.32334>;
          <D.32333>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32334>:
          D.32335 = ret != 0;
          D.32336 = (long int) D.32335;
          D.32337 = __builtin_expect (D.32336, 0);
          if (D.32337 != 0) goto <D.32338>; else goto <D.32339>;
          <D.32338>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.32339>:
        }
        D.32340 = domain->refobject_hash;
        if (D.32340 == 0B) goto <D.32341>; else goto <D.32342>;
        <D.32341>:
        D.32343 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32343;
        <D.32342>:
        D.32340 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32340, &e);
        if (_obj != 0B) goto <D.32344>; else goto <D.32345>;
        <D.32344>:
        {
          int ret;

          D.32332 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32332);
          if (ret != 0) goto <D.32346>; else goto <D.32347>;
          <D.32346>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32347>:
          D.32348 = ret != 0;
          D.32349 = (long int) D.32348;
          D.32350 = __builtin_expect (D.32349, 0);
          if (D.32350 != 0) goto <D.32351>; else goto <D.32352>;
          <D.32351>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.32352>:
        }
        D.32353 = _obj;
        return D.32353;
        <D.32345>:
        {
          int ret;

          D.32332 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32332);
          if (ret != 0) goto <D.32354>; else goto <D.32355>;
          <D.32354>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32355>:
          D.32356 = ret != 0;
          D.32357 = (long int) D.32356;
          D.32358 = __builtin_expect (D.32357, 0);
          if (D.32358 != 0) goto <D.32359>; else goto <D.32360>;
          <D.32359>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.32360>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoproperty_klass.387 = monoproperty_klass;
  if (monoproperty_klass.387 == 0B) goto <D.32362>; else goto <D.32363>;
  <D.32362>:
  D.32364 = mono_defaults.corlib;
  monoproperty_klass.388 = mono_class_from_name (D.32364, "System.Reflection", "MonoProperty");
  monoproperty_klass = monoproperty_klass.388;
  <D.32363>:
  monoproperty_klass.387 = monoproperty_klass;
  res = mono_object_new (domain, monoproperty_klass.387);
  res->klass = klass;
  res->property = property;
  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = property;
        pe.refclass = klass;
        {
          int ret;

          D.32332 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32332);
          if (ret != 0) goto <D.32366>; else goto <D.32367>;
          <D.32366>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32367>:
          D.32368 = ret != 0;
          D.32369 = (long int) D.32368;
          D.32370 = __builtin_expect (D.32369, 0);
          if (D.32370 != 0) goto <D.32371>; else goto <D.32372>;
          <D.32371>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.32372>:
        }
        D.32340 = domain->refobject_hash;
        if (D.32340 == 0B) goto <D.32373>; else goto <D.32374>;
        <D.32373>:
        D.32375 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32375;
        <D.32374>:
        D.32340 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32340, &pe);
        if (_obj == 0B) goto <D.32376>; else goto <D.32377>;
        <D.32376>:
        {
          struct ReflectedEntry * e;

          D.32378 = domain->mp;
          e = mono_mempool_alloc (D.32378, 8);
          e->item = property;
          e->refclass = klass;
          D.32340 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32340, e, res);
          _obj = res;
        }
        <D.32377>:
        {
          int ret;

          D.32332 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32332);
          if (ret != 0) goto <D.32379>; else goto <D.32380>;
          <D.32379>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32380>:
          D.32381 = ret != 0;
          D.32382 = (long int) D.32381;
          D.32383 = __builtin_expect (D.32382, 0);
          if (D.32383 != 0) goto <D.32384>; else goto <D.32385>;
          <D.32384>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.32385>:
        }
        D.32353 = _obj;
        return D.32353;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_event_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoEvent * event)
{
  union mono_mutex_t * D.32390;
  _Bool D.32393;
  long int D.32394;
  long int D.32395;
  struct MonoGHashTable * D.32398;
  struct MonoGHashTable * D.32401;
  _Bool D.32406;
  long int D.32407;
  long int D.32408;
  struct MonoReflectionEvent * D.32411;
  _Bool D.32414;
  long int D.32415;
  long int D.32416;
  struct MonoClass * monoevent_klass.389;
  struct MonoImage * D.32422;
  struct MonoClass * monoevent_klass.390;
  _Bool D.32426;
  long int D.32427;
  long int D.32428;
  struct MonoGHashTable * D.32433;
  struct MonoMemPool * D.32436;
  _Bool D.32439;
  long int D.32440;
  long int D.32441;
  struct MonoReflectionEvent * res;
  struct MonoReflectionMonoEvent * mono_event;
  static struct MonoClass * monoevent_klass;

  {
    struct MonoReflectionEvent * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = event;
        e.refclass = klass;
        {
          int ret;

          D.32390 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32390);
          if (ret != 0) goto <D.32391>; else goto <D.32392>;
          <D.32391>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32392>:
          D.32393 = ret != 0;
          D.32394 = (long int) D.32393;
          D.32395 = __builtin_expect (D.32394, 0);
          if (D.32395 != 0) goto <D.32396>; else goto <D.32397>;
          <D.32396>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32397>:
        }
        D.32398 = domain->refobject_hash;
        if (D.32398 == 0B) goto <D.32399>; else goto <D.32400>;
        <D.32399>:
        D.32401 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32401;
        <D.32400>:
        D.32398 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32398, &e);
        if (_obj != 0B) goto <D.32402>; else goto <D.32403>;
        <D.32402>:
        {
          int ret;

          D.32390 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32390);
          if (ret != 0) goto <D.32404>; else goto <D.32405>;
          <D.32404>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32405>:
          D.32406 = ret != 0;
          D.32407 = (long int) D.32406;
          D.32408 = __builtin_expect (D.32407, 0);
          if (D.32408 != 0) goto <D.32409>; else goto <D.32410>;
          <D.32409>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32410>:
        }
        D.32411 = _obj;
        return D.32411;
        <D.32403>:
        {
          int ret;

          D.32390 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32390);
          if (ret != 0) goto <D.32412>; else goto <D.32413>;
          <D.32412>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32413>:
          D.32414 = ret != 0;
          D.32415 = (long int) D.32414;
          D.32416 = __builtin_expect (D.32415, 0);
          if (D.32416 != 0) goto <D.32417>; else goto <D.32418>;
          <D.32417>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32418>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoevent_klass.389 = monoevent_klass;
  if (monoevent_klass.389 == 0B) goto <D.32420>; else goto <D.32421>;
  <D.32420>:
  D.32422 = mono_defaults.corlib;
  monoevent_klass.390 = mono_class_from_name (D.32422, "System.Reflection", "MonoEvent");
  monoevent_klass = monoevent_klass.390;
  <D.32421>:
  monoevent_klass.389 = monoevent_klass;
  mono_event = mono_object_new (domain, monoevent_klass.389);
  mono_event->klass = klass;
  mono_event->event = event;
  res = mono_event;
  {
    struct MonoReflectionEvent * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = event;
        pe.refclass = klass;
        {
          int ret;

          D.32390 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32390);
          if (ret != 0) goto <D.32424>; else goto <D.32425>;
          <D.32424>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32425>:
          D.32426 = ret != 0;
          D.32427 = (long int) D.32426;
          D.32428 = __builtin_expect (D.32427, 0);
          if (D.32428 != 0) goto <D.32429>; else goto <D.32430>;
          <D.32429>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.32430>:
        }
        D.32398 = domain->refobject_hash;
        if (D.32398 == 0B) goto <D.32431>; else goto <D.32432>;
        <D.32431>:
        D.32433 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32433;
        <D.32432>:
        D.32398 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32398, &pe);
        if (_obj == 0B) goto <D.32434>; else goto <D.32435>;
        <D.32434>:
        {
          struct ReflectedEntry * e;

          D.32436 = domain->mp;
          e = mono_mempool_alloc (D.32436, 8);
          e->item = event;
          e->refclass = klass;
          D.32398 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32398, e, res);
          _obj = res;
        }
        <D.32435>:
        {
          int ret;

          D.32390 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32390);
          if (ret != 0) goto <D.32437>; else goto <D.32438>;
          <D.32437>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32438>:
          D.32439 = ret != 0;
          D.32440 = (long int) D.32439;
          D.32441 = __builtin_expect (D.32440, 0);
          if (D.32441 != 0) goto <D.32442>; else goto <D.32443>;
          <D.32442>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.32443>:
        }
        D.32411 = _obj;
        return D.32411;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_param_get_objects_internal (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  struct MonoClass * System_Reflection_ParameterInfo_array.391;
  struct MonoImage * D.32451;
  int D.32454;
  short unsigned int D.32457;
  struct MonoArray * D.32460;
  struct MonoVTable * D.32461;
  struct MonoMethodSignature * * D.32462;
  union mono_mutex_t * D.32463;
  _Bool D.32466;
  long int D.32467;
  long int D.32468;
  struct MonoGHashTable * D.32471;
  struct MonoGHashTable * D.32474;
  _Bool D.32479;
  long int D.32480;
  long int D.32481;
  _Bool D.32486;
  long int D.32487;
  long int D.32488;
  unsigned int D.32491;
  unsigned int D.32492;
  int D.32493;
  int D.32494;
  unsigned int D.32495;
  unsigned int D.32496;
  struct MonoVTable * D.32497;
  unsigned int D.32498;
  struct MonoClass * System_Reflection_ParameterInfo.392;
  struct MonoReflectionType * * D.32500;
  struct MonoType * D.32501;
  struct MonoReflectionType * D.32502;
  struct MonoObject * * D.32503;
  struct MonoString * * D.32504;
  unsigned int i.393;
  unsigned int D.32506;
  char * * D.32507;
  char * D.32508;
  struct MonoString * D.32509;
  short unsigned int D.32510;
  unsigned int D.32511;
  unsigned int D.32512;
  unsigned int D.32513;
  unsigned int D.32516;
  struct MonoObject * * D.32519;
  struct MonoObject * D.32520;
  struct MonoObject * D.32522;
  guint32 * D.32528;
  unsigned int D.32529;
  unsigned char D.32530;
  struct MonoClass * D.32533;
  unsigned char D.32537;
  struct MonoClass * D.32539;
  unsigned int D.32540;
  unsigned int D.32541;
  struct MonoClass * D.32543;
  struct MonoClass * D.32544;
  char * * D.32545;
  char * D.32546;
  struct MonoObject * D.32547;
  struct MonoObject * D.32550;
  struct MonoObject * D.32555;
  struct MonoObject * D.32557;
  sizetype i.394;
  sizetype D.32559;
  sizetype D.32560;
  struct MonoMarshalSpec * * D.32561;
  struct MonoMarshalSpec * D.32562;
  struct MonoObject * * D.32565;
  struct MonoClass * D.32566;
  struct MonoReflectionMarshalAsAttribute * D.32567;
  unsigned int i.395;
  struct MonoMethodSignature * D.32569;
  short unsigned int D.32570;
  struct MonoMarshalSpec * * D.32571;
  struct MonoMarshalSpec * D.32572;
  _Bool D.32577;
  long int D.32578;
  long int D.32579;
  struct MonoGHashTable * D.32584;
  struct MonoMemPool * D.32587;
  _Bool D.32590;
  long int D.32591;
  long int D.32592;
  static struct MonoClass * System_Reflection_ParameterInfo;
  static struct MonoClass * System_Reflection_ParameterInfo_array;
  struct MonoError error;
  struct MonoArray * res;
  struct MonoReflectionMethod * member;
  struct MonoReflectionParameter * param;
  char * * names;
  char * * blobs;
  guint32 * types;
  struct MonoType * type;
  struct MonoObject * dbnull;
  struct MonoObject * missing;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodSignature * sig;
  struct MonoVTable * pinfo_vtable;
  int i;

  try
    {
      res = 0B;
      member = 0B;
      param = 0B;
      blobs = 0B;
      types = 0B;
      type = 0B;
      dbnull = 0B;
      missing = 0B;
      System_Reflection_ParameterInfo_array.391 = System_Reflection_ParameterInfo_array;
      if (System_Reflection_ParameterInfo_array.391 == 0B) goto <D.32449>; else goto <D.32450>;
      <D.32449>:
      {
        struct MonoClass * klass;

        D.32451 = mono_defaults.corlib;
        klass = mono_class_from_name (D.32451, "System.Reflection", "MonoParameterInfo");
        if (klass == 0B) goto <D.32452>; else goto <D.32453>;
        <D.32452>:
        D.32451 = mono_defaults.corlib;
        klass = mono_class_from_name (D.32451, "System.Reflection", "ParameterInfo");
        <D.32453>:
        mono_memory_barrier ();
        System_Reflection_ParameterInfo = klass;
        klass = mono_array_class_get (klass, 1);
        mono_memory_barrier ();
        System_Reflection_ParameterInfo_array = klass;
      }
      <D.32450>:
      sig = mono_method_signature_checked (method, &error);
      D.32454 = mono_error_ok (&error);
      if (D.32454 == 0) goto <D.32455>; else goto <D.32456>;
      <D.32455>:
      mono_error_raise_exception (&error);
      <D.32456>:
      D.32457 = sig->param_count;
      if (D.32457 == 0) goto <D.32458>; else goto <D.32459>;
      <D.32458>:
      System_Reflection_ParameterInfo_array.391 = System_Reflection_ParameterInfo_array;
      D.32461 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.391);
      D.32460 = mono_array_new_specific (D.32461, 0);
      return D.32460;
      <D.32459>:
      {
        struct MonoArray * _obj;
        struct ReflectedEntry e;

        try
          {
            D.32462 = &method->signature;
            e.item = D.32462;
            e.refclass = refclass;
            {
              int ret;

              D.32463 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.32463);
              if (ret != 0) goto <D.32464>; else goto <D.32465>;
              <D.32464>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.32465>:
              D.32466 = ret != 0;
              D.32467 = (long int) D.32466;
              D.32468 = __builtin_expect (D.32467, 0);
              if (D.32468 != 0) goto <D.32469>; else goto <D.32470>;
              <D.32469>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32470>:
            }
            D.32471 = domain->refobject_hash;
            if (D.32471 == 0B) goto <D.32472>; else goto <D.32473>;
            <D.32472>:
            D.32474 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.32474;
            <D.32473>:
            D.32471 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.32471, &e);
            if (_obj != 0B) goto <D.32475>; else goto <D.32476>;
            <D.32475>:
            {
              int ret;

              D.32463 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32463);
              if (ret != 0) goto <D.32477>; else goto <D.32478>;
              <D.32477>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32478>:
              D.32479 = ret != 0;
              D.32480 = (long int) D.32479;
              D.32481 = __builtin_expect (D.32480, 0);
              if (D.32481 != 0) goto <D.32482>; else goto <D.32483>;
              <D.32482>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32483>:
            }
            D.32460 = _obj;
            return D.32460;
            <D.32476>:
            {
              int ret;

              D.32463 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32463);
              if (ret != 0) goto <D.32484>; else goto <D.32485>;
              <D.32484>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32485>:
              D.32486 = ret != 0;
              D.32487 = (long int) D.32486;
              D.32488 = __builtin_expect (D.32487, 0);
              if (D.32488 != 0) goto <D.32489>; else goto <D.32490>;
              <D.32489>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32490>:
            }
          }
        finally
          {
            e = {CLOBBER};
          }
      }
      member = mono_method_get_object (domain, method, refclass);
      D.32457 = sig->param_count;
      D.32491 = (unsigned int) D.32457;
      D.32492 = D.32491 * 4;
      names = monoeg_malloc (D.32492);
      mono_method_get_param_names (method, names);
      D.32457 = sig->param_count;
      D.32493 = (int) D.32457;
      D.32494 = D.32493 + 1;
      D.32495 = (unsigned int) D.32494;
      D.32496 = D.32495 * 4;
      mspecs = monoeg_malloc (D.32496);
      mono_method_get_marshal_info (method, mspecs);
      System_Reflection_ParameterInfo_array.391 = System_Reflection_ParameterInfo_array;
      D.32497 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.391);
      D.32457 = sig->param_count;
      D.32498 = (unsigned int) D.32457;
      res = mono_array_new_specific (D.32497, D.32498);
      System_Reflection_ParameterInfo.392 = System_Reflection_ParameterInfo;
      pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo.392);
      i = 0;
      goto <D.20921>;
      <D.20920>:
      param = mono_object_new_specific (pinfo_vtable);
      D.32500 = &param->ClassImpl;
      D.32501 = sig->params[i];
      D.32502 = mono_type_get_object (domain, D.32501);
      mono_gc_wbarrier_set_field (param, D.32500, D.32502);
      D.32503 = &param->MemberImpl;
      mono_gc_wbarrier_set_field (param, D.32503, member);
      D.32504 = &param->NameImpl;
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32507 = names + D.32506;
      D.32508 = *D.32507;
      D.32509 = mono_string_new (domain, D.32508);
      mono_gc_wbarrier_set_field (param, D.32504, D.32509);
      param->PositionImpl = i;
      D.32501 = sig->params[i];
      D.32510 = D.32501->attrs;
      D.32511 = (unsigned int) D.32510;
      param->AttrsImpl = D.32511;
      D.32512 = param->AttrsImpl;
      D.32513 = D.32512 & 4096;
      if (D.32513 == 0) goto <D.32514>; else goto <D.32515>;
      <D.32514>:
      D.32512 = param->AttrsImpl;
      D.32516 = D.32512 & 16;
      if (D.32516 != 0) goto <D.32517>; else goto <D.32518>;
      <D.32517>:
      D.32519 = &param->DefaultValueImpl;
      D.32520 = get_reflection_missing (domain, &missing);
      mono_gc_wbarrier_set_field (param, D.32519, D.32520);
      goto <D.32521>;
      <D.32518>:
      D.32519 = &param->DefaultValueImpl;
      D.32522 = get_dbnull (domain, &dbnull);
      mono_gc_wbarrier_set_field (param, D.32519, D.32522);
      <D.32521>:
      goto <D.32523>;
      <D.32515>:
      if (blobs == 0B) goto <D.32524>; else goto <D.32525>;
      <D.32524>:
      D.32457 = sig->param_count;
      D.32491 = (unsigned int) D.32457;
      D.32492 = D.32491 * 4;
      blobs = monoeg_malloc0 (D.32492);
      D.32457 = sig->param_count;
      D.32491 = (unsigned int) D.32457;
      D.32492 = D.32491 * 4;
      types = monoeg_malloc0 (D.32492);
      get_default_param_value_blobs (method, blobs, types);
      <D.32525>:
      if (type == 0B) goto <D.32526>; else goto <D.32527>;
      <D.32526>:
      type = monoeg_malloc0 (8);
      <D.32527>:
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32528 = types + D.32506;
      D.32529 = *D.32528;
      D.32530 = (unsigned char) D.32529;
      type->type = D.32530;
      type->data.klass = 0B;
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32528 = types + D.32506;
      D.32529 = *D.32528;
      if (D.32529 == 18) goto <D.32531>; else goto <D.32532>;
      <D.32531>:
      D.32533 = mono_defaults.object_class;
      type->data.klass = D.32533;
      goto <D.32534>;
      <D.32532>:
      D.32501 = sig->params[i];
      D.32537 = D.32501->type;
      if (D.32537 == 17) goto <D.32538>; else goto <D.32535>;
      <D.32538>:
      D.32501 = sig->params[i];
      D.32539 = D.32501->data.klass;
      D.32540 = BIT_FIELD_REF <*D.32539, 32, 160>;
      D.32541 = D.32540 & 16;
      if (D.32541 != 0) goto <D.32542>; else goto <D.32535>;
      <D.32542>:
      type->type = 17;
      D.32501 = sig->params[i];
      D.32543 = mono_class_from_mono_type (D.32501);
      type->data.klass = D.32543;
      goto <D.32536>;
      <D.32535>:
      D.32544 = mono_class_from_mono_type (type);
      type->data.klass = D.32544;
      <D.32536>:
      <D.32534>:
      D.32519 = &param->DefaultValueImpl;
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32545 = blobs + D.32506;
      D.32546 = *D.32545;
      D.32547 = mono_get_object_from_blob (domain, type, D.32546);
      mono_gc_wbarrier_set_field (param, D.32519, D.32547);
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32528 = types + D.32506;
      D.32529 = *D.32528;
      if (D.32529 != 18) goto <D.32548>; else goto <D.32549>;
      <D.32548>:
      D.32550 = param->DefaultValueImpl;
      if (D.32550 == 0B) goto <D.32551>; else goto <D.32552>;
      <D.32551>:
      D.32512 = param->AttrsImpl;
      D.32516 = D.32512 & 16;
      if (D.32516 != 0) goto <D.32553>; else goto <D.32554>;
      <D.32553>:
      D.32519 = &param->DefaultValueImpl;
      D.32555 = get_reflection_missing (domain, &missing);
      mono_gc_wbarrier_set_field (param, D.32519, D.32555);
      goto <D.32556>;
      <D.32554>:
      D.32519 = &param->DefaultValueImpl;
      D.32557 = get_dbnull (domain, &dbnull);
      mono_gc_wbarrier_set_field (param, D.32519, D.32557);
      <D.32556>:
      <D.32552>:
      <D.32549>:
      <D.32523>:
      i.394 = (sizetype) i;
      D.32559 = i.394 + 1;
      D.32560 = D.32559 * 4;
      D.32561 = mspecs + D.32560;
      D.32562 = *D.32561;
      if (D.32562 != 0B) goto <D.32563>; else goto <D.32564>;
      <D.32563>:
      D.32565 = &param->MarshalAsImpl;
      D.32566 = method->klass;
      i.394 = (sizetype) i;
      D.32559 = i.394 + 1;
      D.32560 = D.32559 * 4;
      D.32561 = mspecs + D.32560;
      D.32562 = *D.32561;
      D.32567 = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.32566, D.32562);
      mono_gc_wbarrier_set_field (param, D.32565, D.32567);
      <D.32564>:
      {
        void * * __p;

        i.395 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.395);
        mono_gc_wbarrier_set_arrayref (res, __p, param);
      }
      i = i + 1;
      <D.20921>:
      D.32457 = sig->param_count;
      D.32493 = (int) D.32457;
      if (D.32493 > i) goto <D.20920>; else goto <D.20922>;
      <D.20922>:
      monoeg_g_free (names);
      monoeg_g_free (blobs);
      monoeg_g_free (types);
      monoeg_g_free (type);
      D.32569 = mono_method_signature (method);
      D.32570 = D.32569->param_count;
      i = (int) D.32570;
      goto <D.20924>;
      <D.20923>:
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32571 = mspecs + D.32506;
      D.32572 = *D.32571;
      if (D.32572 != 0B) goto <D.32573>; else goto <D.32574>;
      <D.32573>:
      i.393 = (unsigned int) i;
      D.32506 = i.393 * 4;
      D.32571 = mspecs + D.32506;
      D.32572 = *D.32571;
      mono_metadata_free_marshal_spec (D.32572);
      <D.32574>:
      i = i + -1;
      <D.20924>:
      if (i >= 0) goto <D.20923>; else goto <D.20925>;
      <D.20925>:
      monoeg_g_free (mspecs);
      {
        struct MonoArray * _obj;
        struct ReflectedEntry pe;

        try
          {
            D.32462 = &method->signature;
            pe.item = D.32462;
            pe.refclass = refclass;
            {
              int ret;

              D.32463 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.32463);
              if (ret != 0) goto <D.32575>; else goto <D.32576>;
              <D.32575>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.32576>:
              D.32577 = ret != 0;
              D.32578 = (long int) D.32577;
              D.32579 = __builtin_expect (D.32578, 0);
              if (D.32579 != 0) goto <D.32580>; else goto <D.32581>;
              <D.32580>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.32581>:
            }
            D.32471 = domain->refobject_hash;
            if (D.32471 == 0B) goto <D.32582>; else goto <D.32583>;
            <D.32582>:
            D.32584 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.32584;
            <D.32583>:
            D.32471 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.32471, &pe);
            if (_obj == 0B) goto <D.32585>; else goto <D.32586>;
            <D.32585>:
            {
              struct ReflectedEntry * e;

              D.32587 = domain->mp;
              e = mono_mempool_alloc (D.32587, 8);
              D.32462 = &method->signature;
              e->item = D.32462;
              e->refclass = refclass;
              D.32471 = domain->refobject_hash;
              mono_g_hash_table_insert (D.32471, e, res);
              _obj = res;
            }
            <D.32586>:
            {
              int ret;

              D.32463 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32463);
              if (ret != 0) goto <D.32588>; else goto <D.32589>;
              <D.32588>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32589>:
              D.32590 = ret != 0;
              D.32591 = (long int) D.32590;
              D.32592 = __builtin_expect (D.32591, 0);
              if (D.32592 != 0) goto <D.32593>; else goto <D.32594>;
              <D.32593>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.32594>:
            }
            D.32460 = _obj;
            return D.32460;
          }
        finally
          {
            pe = {CLOBBER};
          }
      }
    }
  finally
    {
      error = {CLOBBER};
      dbnull = {CLOBBER};
      missing = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_default_param_value_blobs (struct MonoMethod * method, char * * blobs, guint32 * types)
{
  short unsigned int D.32600;
  struct MonoImage * D.32603;
  unsigned int D.32604;
  unsigned int D.32605;
  unsigned int D.32608;
  unsigned int D.32609;
  struct MonoClass * D.32612;
  struct MonoImage * D.32613;
  struct GHashTable * D.32614;
  uint8_t * * D.32617;
  uint8_t * * D.32620;
  unsigned int D.32621;
  unsigned int D.32622;
  uint32_t * D.32623;
  uint32_t * D.32624;
  unsigned int D.32625;
  unsigned int D.32626;
  _Bool D.32627;
  long int D.32628;
  long int D.32629;
  int D.32632;
  <unnamed-unsigned:24> D.32633;
  int D.32634;
  <unnamed-unsigned:24> D.32638;
  int D.32639;
  int D.32640;
  unsigned int D.32641;
  int D.32642;
  unsigned int D.32643;
  unsigned int D.32644;
  unsigned int D.32647;
  unsigned int D.32648;
  unsigned int D.32651;
  int D.32652;
  sizetype D.32653;
  sizetype D.32654;
  char * * D.32655;
  unsigned int D.32656;
  const char * D.32657;
  guint32 * D.32658;
  unsigned int D.32659;
  guint32 param_index;
  guint32 i;
  guint32 lastp;
  guint32 crow;
  guint32 param_cols[3];
  guint32 const_cols[4];
  gint32 idx;
  struct MonoClass * klass;
  struct MonoImage * image;
  struct MonoMethodSignature * methodsig;
  struct MonoTableInfo * constt;
  struct MonoTableInfo * methodt;
  struct MonoTableInfo * paramt;

  try
    {
      crow = 0;
      klass = method->klass;
      image = klass->image;
      methodsig = mono_method_signature (method);
      D.32600 = methodsig->param_count;
      if (D.32600 == 0) goto <D.32601>; else goto <D.32602>;
      <D.32601>:
      return;
      <D.32602>:
      mono_class_init (klass);
      D.32603 = klass->image;
      D.32604 = BIT_FIELD_REF <*D.32603, 32, 128>;
      D.32605 = D.32604 & 8;
      if (D.32605 != 0) goto <D.32606>; else goto <D.32607>;
      <D.32606>:
      {
        struct MonoReflectionMethodAux * aux;

        D.32608 = BIT_FIELD_REF <*method, 32, 160>;
        D.32609 = D.32608 & 4096;
        if (D.32609 != 0) goto <D.32610>; else goto <D.32611>;
        <D.32610>:
        method = MEM[(struct MonoMethodInflated *)method].declaring;
        <D.32611>:
        D.32612 = method->klass;
        D.32613 = D.32612->image;
        D.32614 = MEM[(struct MonoDynamicImage *)D.32613].method_aux_hash;
        aux = monoeg_g_hash_table_lookup (D.32614, method);
        if (aux != 0B) goto <D.32615>; else goto <D.32616>;
        <D.32615>:
        D.32617 = aux->param_defaults;
        if (D.32617 != 0B) goto <D.32618>; else goto <D.32619>;
        <D.32618>:
        D.32617 = aux->param_defaults;
        D.32620 = D.32617 + 4;
        D.32600 = methodsig->param_count;
        D.32621 = (unsigned int) D.32600;
        D.32622 = D.32621 * 4;
        memcpy (blobs, D.32620, D.32622);
        D.32623 = aux->param_default_types;
        D.32624 = D.32623 + 4;
        D.32600 = methodsig->param_count;
        D.32621 = (unsigned int) D.32600;
        D.32622 = D.32621 * 4;
        memcpy (types, D.32624, D.32622);
        <D.32619>:
        <D.32616>:
        return;
      }
      <D.32607>:
      D.32603 = klass->image;
      methodt = &D.32603->tables[6];
      D.32603 = klass->image;
      paramt = &D.32603->tables[8];
      constt = &image->tables[11];
      D.32625 = mono_method_get_index (method);
      D.32626 = D.32625 + 4294967295;
      idx = (gint32) D.32626;
      D.32627 = idx == -1;
      D.32628 = (long int) D.32627;
      D.32629 = __builtin_expect (D.32628, 0);
      if (D.32629 != 0) goto <D.32630>; else goto <D.32631>;
      <D.32630>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7061, "idx != -1");
      <D.32631>:
      param_index = mono_metadata_decode_row_col (methodt, idx, 5);
      D.32632 = idx + 1;
      D.32633 = methodt->rows;
      D.32634 = (int) D.32633;
      if (D.32632 < D.32634) goto <D.32635>; else goto <D.32636>;
      <D.32635>:
      D.32632 = idx + 1;
      lastp = mono_metadata_decode_row_col (methodt, D.32632, 5);
      goto <D.32637>;
      <D.32636>:
      D.32638 = paramt->rows;
      D.32639 = (int) D.32638;
      D.32640 = D.32639 + 1;
      lastp = (guint32) D.32640;
      <D.32637>:
      i = param_index;
      goto <D.21010>;
      <D.21009>:
      {
        guint32 paramseq;

        D.32641 = i + 4294967295;
        D.32642 = (int) D.32641;
        mono_metadata_decode_row (paramt, D.32642, &param_cols, 3);
        paramseq = param_cols[1];
        D.32643 = param_cols[0];
        D.32644 = D.32643 & 4096;
        if (D.32644 == 0) goto <D.32645>; else goto <D.32646>;
        <D.32645>:
        // predicted unlikely by continue predictor.
        goto <D.21008>;
        <D.32646>:
        D.32647 = i | 134217728;
        D.32648 = crow + 1;
        crow = mono_metadata_get_constant_index (image, D.32647, D.32648);
        if (crow == 0) goto <D.32649>; else goto <D.32650>;
        <D.32649>:
        // predicted unlikely by continue predictor.
        goto <D.21008>;
        <D.32650>:
        D.32651 = crow + 4294967295;
        D.32652 = (int) D.32651;
        mono_metadata_decode_row (constt, D.32652, &const_cols, 4);
        D.32653 = paramseq + 1073741823;
        D.32654 = D.32653 * 4;
        D.32655 = blobs + D.32654;
        D.32656 = const_cols[3];
        D.32657 = mono_metadata_blob_heap (image, D.32656);
        *D.32655 = D.32657;
        D.32653 = paramseq + 1073741823;
        D.32654 = D.32653 * 4;
        D.32658 = types + D.32654;
        D.32659 = const_cols[0];
        *D.32658 = D.32659;
      }
      <D.21008>:
      i = i + 1;
      <D.21010>:
      if (i < lastp) goto <D.21009>; else goto <D.21011>;
      <D.21011>:
      return;
    }
  finally
    {
      param_cols = {CLOBBER};
      const_cols = {CLOBBER};
    }
}


get_reflection_missing (struct MonoDomain * domain, struct MonoObject * * reflection_missing)
{
  struct MonoObject * D.32662;
  struct MonoObject * D.32665;
  struct MonoObject * D.32666;

  D.32662 = *reflection_missing;
  if (D.32662 == 0B) goto <D.32663>; else goto <D.32664>;
  <D.32663>:
  D.32665 = mono_get_reflection_missing_object (domain);
  *reflection_missing = D.32665;
  <D.32664>:
  D.32666 = *reflection_missing;
  return D.32666;
}


mono_get_reflection_missing_object (struct MonoDomain * domain)
{
  struct MonoClassField * missing_value_field.396;
  struct MonoImage * D.32671;
  struct MonoClassField * missing_value_field.397;
  _Bool D.32673;
  long int D.32674;
  long int D.32675;
  _Bool D.32678;
  long int D.32679;
  long int D.32680;
  struct MonoObject * D.32683;
  struct MonoObject * obj;
  static struct MonoClassField * missing_value_field = 0B;

  missing_value_field.396 = missing_value_field;
  if (missing_value_field.396 == 0B) goto <D.32669>; else goto <D.32670>;
  <D.32669>:
  {
    struct MonoClass * missing_klass;

    D.32671 = mono_defaults.corlib;
    missing_klass = mono_class_from_name (D.32671, "System.Reflection", "Missing");
    mono_class_init (missing_klass);
    missing_value_field.397 = mono_class_get_field_from_name (missing_klass, "Value");
    missing_value_field = missing_value_field.397;
    missing_value_field.396 = missing_value_field;
    D.32673 = missing_value_field.396 == 0B;
    D.32674 = (long int) D.32673;
    D.32675 = __builtin_expect (D.32674, 0);
    if (D.32675 != 0) goto <D.32676>; else goto <D.32677>;
    <D.32676>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6732, "missing_value_field");
    <D.32677>:
  }
  <D.32670>:
  missing_value_field.396 = missing_value_field;
  obj = mono_field_get_value_object (domain, missing_value_field.396, 0B);
  D.32678 = obj == 0B;
  D.32679 = (long int) D.32678;
  D.32680 = __builtin_expect (D.32679, 0);
  if (D.32680 != 0) goto <D.32681>; else goto <D.32682>;
  <D.32681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6735, "obj");
  <D.32682>:
  D.32683 = obj;
  return D.32683;
}


get_dbnull (struct MonoDomain * domain, struct MonoObject * * dbnull)
{
  struct MonoObject * D.32685;
  struct MonoObject * D.32688;
  struct MonoObject * D.32689;

  D.32685 = *dbnull;
  if (D.32685 == 0B) goto <D.32686>; else goto <D.32687>;
  <D.32686>:
  D.32688 = mono_get_dbnull_object (domain);
  *dbnull = D.32688;
  <D.32687>:
  D.32689 = *dbnull;
  return D.32689;
}


mono_param_get_objects (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoArray * D.32691;

  D.32691 = mono_param_get_objects_internal (domain, method, 0B);
  return D.32691;
}


mono_method_body_get_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned int D.32693;
  unsigned int D.32694;
  struct MonoException * D.32697;
  struct MonoClass * System_Reflection_MethodBody.398;
  struct MonoImage * D.32701;
  struct MonoClass * System_Reflection_MethodBody.399;
  struct MonoClass * System_Reflection_LocalVariableInfo.400;
  struct MonoClass * System_Reflection_LocalVariableInfo.401;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.402;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.403;
  union mono_mutex_t * D.32711;
  _Bool D.32714;
  long int D.32715;
  long int D.32716;
  struct MonoGHashTable * D.32719;
  struct MonoGHashTable * D.32722;
  _Bool D.32727;
  long int D.32728;
  long int D.32729;
  struct MonoReflectionMethodBody * D.32732;
  _Bool D.32735;
  long int D.32736;
  long int D.32737;
  short unsigned int D.32742;
  unsigned int D.32743;
  unsigned int D.32744;
  short unsigned int D.32746;
  unsigned int D.32747;
  unsigned int D.32748;
  struct MonoClass * D.32749;
  unsigned int D.32750;
  unsigned int D.32751;
  struct MonoTableInfo * D.32754;
  unsigned int D.32755;
  unsigned int D.32756;
  unsigned int D.32757;
  int D.32758;
  int D.32759;
  <unnamed-unsigned:1> D.32761;
  unsigned char D.32762;
  <unnamed-unsigned:15> D.32763;
  unsigned int D.32764;
  struct MonoArray * * D.32765;
  struct MonoClass * D.20961;
  struct MonoClass * tmp_klass.404;
  struct MonoClass * D.32769;
  struct MonoClass * tmp_klass.405;
  _Bool D.32771;
  long int D.32772;
  long int D.32773;
  struct MonoVTable * D.32776;
  unsigned int D.32777;
  struct MonoArray * D.32778;
  struct MonoArray * D.32779;
  char * D.32780;
  const unsigned char * D.32781;
  struct MonoArray * * D.32782;
  struct MonoClass * D.20963;
  struct MonoClass * tmp_klass.406;
  struct MonoClass * tmp_klass.407;
  _Bool D.32787;
  long int D.32788;
  long int D.32789;
  struct MonoVTable * D.32792;
  short unsigned int D.32793;
  unsigned int D.32794;
  struct MonoArray * D.32795;
  struct MonoReflectionType * * D.32796;
  struct MonoType * D.32797;
  struct MonoReflectionType * D.32798;
  <unnamed-unsigned:1> D.32799;
  unsigned char D.32800;
  short unsigned int D.32801;
  struct MonoArray * D.32802;
  unsigned int i.408;
  int D.32804;
  struct MonoArray * * D.32805;
  struct MonoClass * D.20970;
  struct MonoClass * tmp_klass.409;
  struct MonoClass * tmp_klass.410;
  _Bool D.32810;
  long int D.32811;
  long int D.32812;
  struct MonoVTable * D.32815;
  <unnamed-unsigned:15> D.32816;
  unsigned int D.32817;
  struct MonoArray * D.32818;
  struct MonoExceptionClause * D.32819;
  unsigned int i.411;
  unsigned int D.32821;
  unsigned int D.32822;
  int D.32823;
  unsigned int D.32824;
  int D.32825;
  unsigned int D.32826;
  int D.32827;
  unsigned int D.32828;
  int D.32829;
  unsigned int D.32830;
  int D.32831;
  unsigned int D.32834;
  int D.32835;
  struct MonoClass * D.32837;
  struct MonoObject * * D.32840;
  struct MonoDomain * D.32841;
  struct MonoType * D.32842;
  struct MonoReflectionType * D.32843;
  struct MonoArray * D.32844;
  int D.32845;
  _Bool D.32848;
  long int D.32849;
  long int D.32850;
  struct MonoGHashTable * D.32855;
  struct MonoMemPool * D.32858;
  _Bool D.32861;
  long int D.32862;
  long int D.32863;
  static struct MonoClass * System_Reflection_MethodBody = 0B;
  static struct MonoClass * System_Reflection_LocalVariableInfo = 0B;
  static struct MonoClass * System_Reflection_ExceptionHandlingClause = 0B;
  struct MonoReflectionMethodBody * ret;
  struct MonoMethodHeader * header;
  struct MonoImage * image;
  guint32 method_rva;
  guint32 local_var_sig_token;
  char * ptr;
  unsigned char format;
  unsigned char flags;
  int i;

  D.32693 = BIT_FIELD_REF <*method, 32, 160>;
  D.32694 = D.32693 & 512;
  if (D.32694 != 0) goto <D.32695>; else goto <D.32696>;
  <D.32695>:
  D.32697 = mono_get_exception_invalid_operation (0B);
  mono_raise_exception (D.32697);
  <D.32696>:
  System_Reflection_MethodBody.398 = System_Reflection_MethodBody;
  if (System_Reflection_MethodBody.398 == 0B) goto <D.32699>; else goto <D.32700>;
  <D.32699>:
  D.32701 = mono_defaults.corlib;
  System_Reflection_MethodBody.399 = mono_class_from_name (D.32701, "System.Reflection", "MethodBody");
  System_Reflection_MethodBody = System_Reflection_MethodBody.399;
  <D.32700>:
  System_Reflection_LocalVariableInfo.400 = System_Reflection_LocalVariableInfo;
  if (System_Reflection_LocalVariableInfo.400 == 0B) goto <D.32704>; else goto <D.32705>;
  <D.32704>:
  D.32701 = mono_defaults.corlib;
  System_Reflection_LocalVariableInfo.401 = mono_class_from_name (D.32701, "System.Reflection", "LocalVariableInfo");
  System_Reflection_LocalVariableInfo = System_Reflection_LocalVariableInfo.401;
  <D.32705>:
  System_Reflection_ExceptionHandlingClause.402 = System_Reflection_ExceptionHandlingClause;
  if (System_Reflection_ExceptionHandlingClause.402 == 0B) goto <D.32708>; else goto <D.32709>;
  <D.32708>:
  D.32701 = mono_defaults.corlib;
  System_Reflection_ExceptionHandlingClause.403 = mono_class_from_name (D.32701, "System.Reflection", "ExceptionHandlingClause");
  System_Reflection_ExceptionHandlingClause = System_Reflection_ExceptionHandlingClause.403;
  <D.32709>:
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry e;

    try
      {
        e.item = method;
        e.refclass = 0B;
        {
          int ret;

          D.32711 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32711);
          if (ret != 0) goto <D.32712>; else goto <D.32713>;
          <D.32712>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32713>:
          D.32714 = ret != 0;
          D.32715 = (long int) D.32714;
          D.32716 = __builtin_expect (D.32715, 0);
          if (D.32716 != 0) goto <D.32717>; else goto <D.32718>;
          <D.32717>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32718>:
        }
        D.32719 = domain->refobject_hash;
        if (D.32719 == 0B) goto <D.32720>; else goto <D.32721>;
        <D.32720>:
        D.32722 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32722;
        <D.32721>:
        D.32719 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32719, &e);
        if (_obj != 0B) goto <D.32723>; else goto <D.32724>;
        <D.32723>:
        {
          int ret;

          D.32711 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32711);
          if (ret != 0) goto <D.32725>; else goto <D.32726>;
          <D.32725>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32726>:
          D.32727 = ret != 0;
          D.32728 = (long int) D.32727;
          D.32729 = __builtin_expect (D.32728, 0);
          if (D.32729 != 0) goto <D.32730>; else goto <D.32731>;
          <D.32730>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32731>:
        }
        D.32732 = _obj;
        return D.32732;
        <D.32724>:
        {
          int ret;

          D.32711 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32711);
          if (ret != 0) goto <D.32733>; else goto <D.32734>;
          <D.32733>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32734>:
          D.32735 = ret != 0;
          D.32736 = (long int) D.32735;
          D.32737 = __builtin_expect (D.32736, 0);
          if (D.32737 != 0) goto <D.32738>; else goto <D.32739>;
          <D.32738>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32739>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.32742 = method->flags;
  D.32743 = (unsigned int) D.32742;
  D.32744 = D.32743 & 9216;
  if (D.32744 != 0) goto <D.32740>; else goto <D.32745>;
  <D.32745>:
  D.32746 = method->iflags;
  D.32747 = (unsigned int) D.32746;
  D.32748 = D.32747 & 4099;
  if (D.32748 != 0) goto <D.32740>; else goto <D.32741>;
  <D.32740>:
  D.32732 = 0B;
  return D.32732;
  <D.32741>:
  D.32749 = method->klass;
  image = D.32749->image;
  header = mono_method_get_header (method);
  D.32750 = BIT_FIELD_REF <*image, 32, 128>;
  D.32751 = D.32750 & 8;
  if (D.32751 == 0) goto <D.32752>; else goto <D.32753>;
  <D.32752>:
  D.32754 = &image->tables[6];
  D.32755 = method->token;
  D.32756 = D.32755 & 16777215;
  D.32757 = D.32756 + 4294967295;
  D.32758 = (int) D.32757;
  method_rva = mono_metadata_decode_row_col (D.32754, D.32758, 0);
  ptr = mono_image_rva_map (image, method_rva);
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.32759 = (int) format;
  switch (D.32759) <default: <D.20959>, case 2: <D.20956>, case 3: <D.20958>>
  <D.20956>:
  local_var_sig_token = 0;
  goto <D.20957>;
  <D.20958>:
  ptr = ptr + 2;
  ptr = ptr + 2;
  ptr = ptr + 4;
  local_var_sig_token = mono_read32 (ptr);
  goto <D.20957>;
  <D.20959>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 6951);
  <D.20957>:
  goto <D.32760>;
  <D.32753>:
  local_var_sig_token = 0;
  <D.32760>:
  System_Reflection_MethodBody.398 = System_Reflection_MethodBody;
  ret = mono_object_new (domain, System_Reflection_MethodBody.398);
  D.32761 = header->init_locals;
  D.32762 = (unsigned char) D.32761;
  ret->init_locals = D.32762;
  D.32763 = header->max_stack;
  D.32764 = (unsigned int) D.32763;
  ret->max_stack = D.32764;
  ret->local_var_sig_token = local_var_sig_token;
  D.32765 = &ret->il;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.404 = tmp_klass;
      if (tmp_klass.404 == 0B) goto <D.32767>; else goto <D.32768>;
      <D.32767>:
      D.32769 = mono_defaults.byte_class;
      tmp_klass.405 = mono_array_class_get (D.32769, 1);
      tmp_klass = tmp_klass.405;
      tmp_klass.404 = tmp_klass;
      D.32771 = tmp_klass.404 == 0B;
      D.32772 = (long int) D.32771;
      D.32773 = __builtin_expect (D.32772, 0);
      if (D.32773 != 0) goto <D.32774>; else goto <D.32775>;
      <D.32774>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6961, "tmp_klass");
      <D.32775>:
      <D.32768>:
    }
    D.20961 = tmp_klass;
  }
  D.32776 = mono_class_vtable (domain, D.20961);
  D.32777 = header->code_size;
  D.32778 = mono_array_new_specific (D.32776, D.32777);
  mono_gc_wbarrier_set_field (ret, D.32765, D.32778);
  D.32779 = ret->il;
  D.32780 = mono_array_addr_with_size (D.32779, 1, 0);
  D.32781 = header->code;
  D.32777 = header->code_size;
  memcpy (D.32780, D.32781, D.32777);
  D.32782 = &ret->locals;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.406 = tmp_klass;
      if (tmp_klass.406 == 0B) goto <D.32784>; else goto <D.32785>;
      <D.32784>:
      System_Reflection_LocalVariableInfo.400 = System_Reflection_LocalVariableInfo;
      tmp_klass.407 = mono_array_class_get (System_Reflection_LocalVariableInfo.400, 1);
      tmp_klass = tmp_klass.407;
      tmp_klass.406 = tmp_klass;
      D.32787 = tmp_klass.406 == 0B;
      D.32788 = (long int) D.32787;
      D.32789 = __builtin_expect (D.32788, 0);
      if (D.32789 != 0) goto <D.32790>; else goto <D.32791>;
      <D.32790>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6965, "tmp_klass");
      <D.32791>:
      <D.32785>:
    }
    D.20963 = tmp_klass;
  }
  D.32792 = mono_class_vtable (domain, D.20963);
  D.32793 = header->num_locals;
  D.32794 = (unsigned int) D.32793;
  D.32795 = mono_array_new_specific (D.32792, D.32794);
  mono_gc_wbarrier_set_field (ret, D.32782, D.32795);
  i = 0;
  goto <D.20967>;
  <D.20966>:
  {
    struct MonoReflectionLocalVariableInfo * info;

    System_Reflection_LocalVariableInfo.400 = System_Reflection_LocalVariableInfo;
    info = mono_object_new (domain, System_Reflection_LocalVariableInfo.400);
    D.32796 = &info->local_type;
    D.32797 = header->locals[i];
    D.32798 = mono_type_get_object (domain, D.32797);
    mono_gc_wbarrier_set_field (info, D.32796, D.32798);
    D.32797 = header->locals[i];
    D.32799 = D.32797->pinned;
    D.32800 = (unsigned char) D.32799;
    info->is_pinned = D.32800;
    D.32801 = (short unsigned int) i;
    info->local_index = D.32801;
    {
      void * * __p;

      D.32802 = ret->locals;
      i.408 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.32802, 4, i.408);
      D.32802 = ret->locals;
      mono_gc_wbarrier_set_arrayref (D.32802, __p, info);
    }
  }
  i = i + 1;
  <D.20967>:
  D.32793 = header->num_locals;
  D.32804 = (int) D.32793;
  if (D.32804 > i) goto <D.20966>; else goto <D.20968>;
  <D.20968>:
  D.32805 = &ret->clauses;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.409 = tmp_klass;
      if (tmp_klass.409 == 0B) goto <D.32807>; else goto <D.32808>;
      <D.32807>:
      System_Reflection_ExceptionHandlingClause.402 = System_Reflection_ExceptionHandlingClause;
      tmp_klass.410 = mono_array_class_get (System_Reflection_ExceptionHandlingClause.402, 1);
      tmp_klass = tmp_klass.410;
      tmp_klass.409 = tmp_klass;
      D.32810 = tmp_klass.409 == 0B;
      D.32811 = (long int) D.32810;
      D.32812 = __builtin_expect (D.32811, 0);
      if (D.32812 != 0) goto <D.32813>; else goto <D.32814>;
      <D.32813>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6975, "tmp_klass");
      <D.32814>:
      <D.32808>:
    }
    D.20970 = tmp_klass;
  }
  D.32815 = mono_class_vtable (domain, D.20970);
  D.32816 = header->num_clauses;
  D.32817 = (unsigned int) D.32816;
  D.32818 = mono_array_new_specific (D.32815, D.32817);
  mono_gc_wbarrier_set_field (ret, D.32805, D.32818);
  i = 0;
  goto <D.20975>;
  <D.20974>:
  {
    struct MonoReflectionExceptionHandlingClause * info;
    struct MonoExceptionClause * clause;

    System_Reflection_ExceptionHandlingClause.402 = System_Reflection_ExceptionHandlingClause;
    info = mono_object_new (domain, System_Reflection_ExceptionHandlingClause.402);
    D.32819 = header->clauses;
    i.411 = (unsigned int) i;
    D.32821 = i.411 * 24;
    clause = D.32819 + D.32821;
    D.32822 = clause->flags;
    D.32823 = (int) D.32822;
    info->flags = D.32823;
    D.32824 = clause->try_offset;
    D.32825 = (int) D.32824;
    info->try_offset = D.32825;
    D.32826 = clause->try_len;
    D.32827 = (int) D.32826;
    info->try_length = D.32827;
    D.32828 = clause->handler_offset;
    D.32829 = (int) D.32828;
    info->handler_offset = D.32829;
    D.32830 = clause->handler_len;
    D.32831 = (int) D.32830;
    info->handler_length = D.32831;
    D.32822 = clause->flags;
    if (D.32822 == 1) goto <D.32832>; else goto <D.32833>;
    <D.32832>:
    D.32834 = clause->data.filter_offset;
    D.32835 = (int) D.32834;
    info->filter_offset = D.32835;
    goto <D.32836>;
    <D.32833>:
    D.32837 = clause->data.catch_class;
    if (D.32837 != 0B) goto <D.32838>; else goto <D.32839>;
    <D.32838>:
    D.32840 = &info->catch_type;
    D.32841 = mono_domain_get ();
    D.32837 = clause->data.catch_class;
    D.32842 = &D.32837->byval_arg;
    D.32843 = mono_type_get_object (D.32841, D.32842);
    mono_gc_wbarrier_set_field (info, D.32840, D.32843);
    <D.32839>:
    <D.32836>:
    {
      void * * __p;

      D.32844 = ret->clauses;
      i.408 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.32844, 4, i.408);
      D.32844 = ret->clauses;
      mono_gc_wbarrier_set_arrayref (D.32844, __p, info);
    }
  }
  i = i + 1;
  <D.20975>:
  D.32816 = header->num_clauses;
  D.32845 = (int) D.32816;
  if (D.32845 > i) goto <D.20974>; else goto <D.20976>;
  <D.20976>:
  mono_metadata_free_mh (header);
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry pe;

    try
      {
        pe.item = method;
        pe.refclass = 0B;
        {
          int ret;

          D.32711 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32711);
          if (ret != 0) goto <D.32846>; else goto <D.32847>;
          <D.32846>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32847>:
          D.32848 = ret != 0;
          D.32849 = (long int) D.32848;
          D.32850 = __builtin_expect (D.32849, 0);
          if (D.32850 != 0) goto <D.32851>; else goto <D.32852>;
          <D.32851>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.32852>:
        }
        D.32719 = domain->refobject_hash;
        if (D.32719 == 0B) goto <D.32853>; else goto <D.32854>;
        <D.32853>:
        D.32855 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32855;
        <D.32854>:
        D.32719 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32719, &pe);
        if (_obj == 0B) goto <D.32856>; else goto <D.32857>;
        <D.32856>:
        {
          struct ReflectedEntry * e;

          D.32858 = domain->mp;
          e = mono_mempool_alloc (D.32858, 8);
          e->item = method;
          e->refclass = 0B;
          D.32719 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32719, e, ret);
          _obj = ret;
        }
        <D.32857>:
        {
          int ret;

          D.32711 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32711);
          if (ret != 0) goto <D.32859>; else goto <D.32860>;
          <D.32859>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32860>:
          D.32861 = ret != 0;
          D.32862 = (long int) D.32861;
          D.32863 = __builtin_expect (D.32862, 0);
          if (D.32863 != 0) goto <D.32864>; else goto <D.32865>;
          <D.32864>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.32865>:
        }
        D.32732 = _obj;
        return D.32732;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
  D.32732 = ret;
  return D.32732;
}


mono_get_dbnull_object (struct MonoDomain * domain)
{
  struct MonoClassField * dbnull_value_field.412;
  struct MonoImage * D.32873;
  struct MonoClassField * dbnull_value_field.413;
  _Bool D.32875;
  long int D.32876;
  long int D.32877;
  _Bool D.32880;
  long int D.32881;
  long int D.32882;
  struct MonoObject * D.32885;
  struct MonoObject * obj;
  static struct MonoClassField * dbnull_value_field = 0B;

  dbnull_value_field.412 = dbnull_value_field;
  if (dbnull_value_field.412 == 0B) goto <D.32871>; else goto <D.32872>;
  <D.32871>:
  {
    struct MonoClass * dbnull_klass;

    D.32873 = mono_defaults.corlib;
    dbnull_klass = mono_class_from_name (D.32873, "System", "DBNull");
    mono_class_init (dbnull_klass);
    dbnull_value_field.413 = mono_class_get_field_from_name (dbnull_klass, "Value");
    dbnull_value_field = dbnull_value_field.413;
    dbnull_value_field.412 = dbnull_value_field;
    D.32875 = dbnull_value_field.412 == 0B;
    D.32876 = (long int) D.32875;
    D.32877 = __builtin_expect (D.32876, 0);
    if (D.32877 != 0) goto <D.32878>; else goto <D.32879>;
    <D.32878>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7017, "dbnull_value_field");
    <D.32879>:
  }
  <D.32872>:
  dbnull_value_field.412 = dbnull_value_field;
  obj = mono_field_get_value_object (domain, dbnull_value_field.412, 0B);
  D.32880 = obj == 0B;
  D.32881 = (long int) D.32880;
  D.32882 = __builtin_expect (D.32881, 0);
  if (D.32882 != 0) goto <D.32883>; else goto <D.32884>;
  <D.32883>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7020, "obj");
  <D.32884>:
  D.32885 = obj;
  return D.32885;
}


mono_get_object_from_blob (struct MonoDomain * domain, struct MonoType * type, const char * blob)
{
  struct MonoObject * D.32889;
  unsigned int D.32890;
  unsigned int D.32891;
  struct MonoObject * object.414;
  struct MonoObject * object.415;
  unsigned int D.32896;
  unsigned char D.32900;
  <unnamed type> D.32901;
  int D.32902;
  void * retval;
  struct MonoClass * klass;
  struct MonoObject * object;
  struct MonoType * basetype;

  try
    {
      basetype = type;
      if (blob == 0B) goto <D.32887>; else goto <D.32888>;
      <D.32887>:
      D.32889 = 0B;
      return D.32889;
      <D.32888>:
      klass = mono_class_from_mono_type (type);
      D.32890 = BIT_FIELD_REF <*klass, 32, 160>;
      D.32891 = D.32890 & 8;
      if (D.32891 != 0) goto <D.32892>; else goto <D.32893>;
      <D.32892>:
      object.414 = mono_object_new (domain, klass);
      object = object.414;
      object.415 = object;
      retval = object.415 + 8;
      D.32890 = BIT_FIELD_REF <*klass, 32, 160>;
      D.32896 = D.32890 & 16;
      if (D.32896 != 0) goto <D.32897>; else goto <D.32898>;
      <D.32897>:
      basetype = mono_class_enum_basetype (klass);
      <D.32898>:
      goto <D.32899>;
      <D.32893>:
      retval = &object;
      <D.32899>:
      D.32900 = basetype->type;
      D.32901 = (<unnamed type>) D.32900;
      D.32902 = mono_get_constant_value_from_blob (domain, D.32901, blob, retval);
      if (D.32902 == 0) goto <D.32903>; else goto <D.32904>;
      <D.32903>:
      D.32889 = object;
      return D.32889;
      <D.32904>:
      D.32889 = 0B;
      return D.32889;
    }
  finally
    {
      object = {CLOBBER};
    }
}


mono_reflection_parse_type (char * name, struct MonoTypeNameParse * info)
{
  int D.32907;

  D.32907 = _mono_reflection_parse_type (name, 0B, 0, info);
  return D.32907;
}


_mono_reflection_parse_type (char * name, char * * endptr, gboolean is_recursed, struct MonoTypeNameParse * info)
{
  struct MonoAssemblyName * D.32909;
  char * D.32910;
  char * p.416;
  char * p.417;
  char D.32913;
  int D.32914;
  struct GList * D.32915;
  struct GList * D.32916;
  char * D.32917;
  char * D.32921;
  int D.32931;
  struct GList * D.32932;
  struct GList * D.32933;
  char * p.418;
  char * p.419;
  struct GList * D.32936;
  char * p.420;
  char * p.421;
  char * p.422;
  char * p.423;
  struct GList * D.32953;
  char * p.424;
  char * p.425;
  char D.32957;
  void * rank.426;
  struct GList * D.32961;
  struct GPtrArray * D.32964;
  struct GPtrArray * D.32965;
  int D.32968;
  char * p.427;
  char * p.428;
  char * p.429;
  char * p.430;
  const short unsigned int * * D.32984;
  const short unsigned int * D.32985;
  char D.32986;
  unsigned int D.32987;
  unsigned int D.32988;
  const short unsigned int * D.32989;
  short unsigned int D.32990;
  int D.32991;
  int D.32992;
  struct MonoAssemblyName * D.32998;
  int D.32999;
  char * p.431;
  char * p.432;
  char * p.433;
  char * p.434;
  char * p.435;
  char * p.436;
  char * p.437;
  char * p.438;
  unsigned int D.33018;
  unsigned int D.33019;
  const short unsigned int * D.33020;
  short unsigned int D.33021;
  int D.33022;
  int D.33023;
  int D.33028;
  const char * D.33031;
  char D.33036;
  char * start;
  char * p;
  char * w;
  char * last_point;
  char * startn;
  int in_modifiers;
  int isbyref;
  int rank;
  void end = <<< error >>>;

  try
    {
      in_modifiers = 0;
      isbyref = 0;
      rank = 0;
      w = name;
      p = w;
      start = p;
      D.32909 = &info->assembly;
      memset (D.32909, 0, 60);
      info->name_space = 0B;
      D.32910 = info->name_space;
      info->name = D.32910;
      info->nested = 0B;
      info->modifiers = 0B;
      info->type_arguments = 0B;
      last_point = 0B;
      goto <D.21078>;
      <D.21077>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      start = start + 1;
      w = w + 1;
      name = name + 1;
      <D.21078>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 32) goto <D.21077>; else goto <D.21079>;
      <D.21079>:
      goto <D.21092>;
      <D.21091>:
      p.416 = p;
      D.32913 = *p.416;
      D.32914 = (int) D.32913;
      switch (D.32914) <default: <D.21089>, case 38: <D.21084>, case 42: <D.21085>, case 43: <D.21080>, case 44: <D.21087>, case 46: <D.21082>, case 91: <D.21086>, case 92: <D.21083>, case 93: <D.21088>>
      <D.21080>:
      p.416 = p;
      *p.416 = 0;
      p.416 = p;
      startn = p.416 + 1;
      D.32915 = info->nested;
      D.32916 = monoeg_g_list_append (D.32915, startn);
      info->nested = D.32916;
      D.32917 = info->name;
      if (D.32917 != 0B) goto <D.21081>; else goto <D.32918>;
      <D.32918>:
      if (last_point != 0B) goto <D.32919>; else goto <D.32920>;
      <D.32919>:
      info->name_space = start;
      *last_point = 0;
      D.32921 = last_point + 1;
      info->name = D.32921;
      goto <D.32922>;
      <D.32920>:
      info->name_space = "";
      info->name = start;
      <D.32922>:
      goto <D.21081>;
      <D.21082>:
      last_point = p;
      goto <D.21081>;
      <D.21083>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      goto <D.21081>;
      <D.21084>:
      <D.21085>:
      <D.21086>:
      <D.21087>:
      <D.21088>:
      in_modifiers = 1;
      goto <D.21081>;
      <D.21089>:
      goto <D.21081>;
      <D.21081>:
      if (in_modifiers != 0) goto <D.21090>; else goto <D.32923>;
      <D.32923>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      <D.21092>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 != 0) goto <D.21091>; else goto <D.21090>;
      <D.21090>:
      D.32917 = info->name;
      if (D.32917 == 0B) goto <D.32924>; else goto <D.32925>;
      <D.32924>:
      if (last_point != 0B) goto <D.32926>; else goto <D.32927>;
      <D.32926>:
      info->name_space = start;
      *last_point = 0;
      D.32921 = last_point + 1;
      info->name = D.32921;
      goto <D.32928>;
      <D.32927>:
      info->name_space = "";
      info->name = start;
      <D.32928>:
      <D.32925>:
      goto <D.21121>;
      <D.21120>:
      p.416 = p;
      D.32913 = *p.416;
      D.32914 = (int) D.32913;
      switch (D.32914) <default: <D.21118>, case 38: <D.21093>, case 42: <D.21095>, case 44: <D.21114>, case 91: <D.21096>, case 93: <D.21112>>
      <D.21093>:
      if (isbyref != 0) goto <D.32929>; else goto <D.32930>;
      <D.32929>:
      D.32931 = 0;
      return D.32931;
      <D.32930>:
      isbyref = 1;
      D.32932 = info->modifiers;
      D.32933 = monoeg_g_list_append (D.32932, 0B);
      info->modifiers = D.32933;
      p.416 = p;
      p.418 = p.416;
      p.419 = p.418 + 1;
      p = p.419;
      *p.418 = 0;
      goto <D.21094>;
      <D.21095>:
      D.32932 = info->modifiers;
      D.32936 = monoeg_g_list_append (D.32932, 4294967295B);
      info->modifiers = D.32936;
      p.416 = p;
      p.420 = p.416;
      p.421 = p.420 + 1;
      p = p.421;
      *p.420 = 0;
      goto <D.21094>;
      <D.21096>:
      p.416 = p;
      p.422 = p.416;
      p.423 = p.422 + 1;
      p = p.423;
      *p.422 = 0;
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 0) goto <D.32941>; else goto <D.32942>;
      <D.32941>:
      D.32931 = 0;
      return D.32931;
      <D.32942>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 44) goto <D.32943>; else goto <D.32945>;
      <D.32945>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 42) goto <D.32943>; else goto <D.32946>;
      <D.32946>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 93) goto <D.32943>; else goto <D.32944>;
      <D.32943>:
      rank = 1;
      goto <D.21099>;
      <D.21098>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 93) goto <D.21097>; else goto <D.32947>;
      <D.32947>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 44) goto <D.32948>; else goto <D.32949>;
      <D.32948>:
      rank = rank + 1;
      goto <D.32950>;
      <D.32949>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 42) goto <D.32951>; else goto <D.32952>;
      <D.32951>:
      D.32932 = info->modifiers;
      D.32953 = monoeg_g_list_append (D.32932, 4294967294B);
      info->modifiers = D.32953;
      goto <D.32954>;
      <D.32952>:
      D.32931 = 0;
      return D.32931;
      <D.32954>:
      <D.32950>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      <D.21099>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 != 0) goto <D.21098>; else goto <D.21097>;
      <D.21097>:
      p.416 = p;
      p.424 = p.416;
      p.425 = p.424 + 1;
      p = p.425;
      D.32957 = *p.424;
      if (D.32957 != 93) goto <D.32958>; else goto <D.32959>;
      <D.32958>:
      D.32931 = 0;
      return D.32931;
      <D.32959>:
      D.32932 = info->modifiers;
      rank.426 = (void *) rank;
      D.32961 = monoeg_g_list_append (D.32932, rank.426);
      info->modifiers = D.32961;
      goto <D.21109>;
      <D.32944>:
      if (rank != 0) goto <D.32962>; else goto <D.32963>;
      <D.32962>:
      D.32931 = 0;
      return D.32931;
      <D.32963>:
      D.32964 = monoeg_g_ptr_array_new ();
      info->type_arguments = D.32964;
      goto <D.21111>;
      <D.21110>:
      {
        struct MonoTypeNameParse * subinfo;
        gboolean fqname;

        subinfo = monoeg_malloc0 (80);
        fqname = 0;
        D.32965 = info->type_arguments;
        monoeg_g_ptr_array_add (D.32965, subinfo);
        p.416 = p;
        D.32913 = *p.416;
        if (D.32913 == 91) goto <D.32966>; else goto <D.32967>;
        <D.32966>:
        p.416 = p;
        p.417 = p.416 + 1;
        p = p.417;
        fqname = 1;
        <D.32967>:
        p.416 = p;
        D.32968 = _mono_reflection_parse_type (p.416, &p, 1, subinfo);
        if (D.32968 == 0) goto <D.32969>; else goto <D.32970>;
        <D.32969>:
        D.32931 = 0;
        return D.32931;
        <D.32970>:
        if (fqname != 0) goto <D.32973>; else goto <D.32971>;
        <D.32973>:
        p.416 = p;
        D.32913 = *p.416;
        if (D.32913 != 93) goto <D.32974>; else goto <D.32971>;
        <D.32974>:
        {
          char * aname;

          p.416 = p;
          D.32913 = *p.416;
          if (D.32913 != 44) goto <D.32975>; else goto <D.32976>;
          <D.32975>:
          D.32931 = 0;
          return D.32931;
          <D.32976>:
          p.416 = p;
          p.427 = p.416;
          p.428 = p.427 + 1;
          p = p.428;
          *p.427 = 0;
          aname = p;
          goto <D.21104>;
          <D.21103>:
          p.416 = p;
          p.417 = p.416 + 1;
          p = p.417;
          <D.21104>:
          p.416 = p;
          D.32913 = *p.416;
          if (D.32913 != 0) goto <D.32979>; else goto <D.21105>;
          <D.32979>:
          p.416 = p;
          D.32913 = *p.416;
          if (D.32913 != 93) goto <D.21103>; else goto <D.21105>;
          <D.21105>:
          p.416 = p;
          D.32913 = *p.416;
          if (D.32913 != 93) goto <D.32980>; else goto <D.32981>;
          <D.32980>:
          D.32931 = 0;
          return D.32931;
          <D.32981>:
          p.416 = p;
          p.429 = p.416;
          p.430 = p.429 + 1;
          p = p.430;
          *p.429 = 0;
          goto <D.21106>;
          <D.21108>:
          D.32984 = __ctype_b_loc ();
          D.32985 = *D.32984;
          D.32986 = *aname;
          D.32987 = (unsigned int) D.32986;
          D.32988 = D.32987 * 2;
          D.32989 = D.32985 + D.32988;
          D.32990 = *D.32989;
          D.32991 = (int) D.32990;
          D.32992 = D.32991 & 8192;
          if (D.32992 != 0) goto <D.32993>; else goto <D.32994>;
          <D.32993>:
          aname = aname + 1;
          // predicted unlikely by continue predictor.
          goto <D.21106>;
          <D.32994>:
          goto <D.21107>;
          <D.21106>:
          D.32986 = *aname;
          if (D.32986 != 0) goto <D.21108>; else goto <D.21107>;
          <D.21107>:
          D.32986 = *aname;
          if (D.32986 == 0) goto <D.32995>; else goto <D.32997>;
          <D.32997>:
          D.32998 = &subinfo->assembly;
          D.32999 = assembly_name_to_aname (D.32998, aname);
          if (D.32999 == 0) goto <D.32995>; else goto <D.32996>;
          <D.32995>:
          D.32931 = 0;
          return D.32931;
          <D.32996>:
        }
        goto <D.32972>;
        <D.32971>:
        if (fqname != 0) goto <D.33000>; else goto <D.33001>;
        <D.33000>:
        p.416 = p;
        D.32913 = *p.416;
        if (D.32913 == 93) goto <D.33002>; else goto <D.33003>;
        <D.33002>:
        p.416 = p;
        p.431 = p.416;
        p.432 = p.431 + 1;
        p = p.432;
        *p.431 = 0;
        <D.33003>:
        <D.33001>:
        <D.32972>:
        p.416 = p;
        D.32913 = *p.416;
        if (D.32913 == 93) goto <D.33006>; else goto <D.33007>;
        <D.33006>:
        p.416 = p;
        p.433 = p.416;
        p.434 = p.433 + 1;
        p = p.434;
        *p.433 = 0;
        goto <D.21109>;
        <D.33007>:
        p.416 = p;
        D.32913 = *p.416;
        if (D.32913 == 0) goto <D.33010>; else goto <D.33011>;
        <D.33010>:
        D.32931 = 0;
        return D.32931;
        <D.33011>:
        p.416 = p;
        p.435 = p.416;
        p.436 = p.435 + 1;
        p = p.436;
        *p.435 = 0;
      }
      <D.21111>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 != 0) goto <D.21110>; else goto <D.21109>;
      <D.21109>:
      goto <D.21094>;
      <D.21112>:
      if (is_recursed != 0) goto end; else goto <D.33014>;
      <D.33014>:
      D.32931 = 0;
      return D.32931;
      <D.21114>:
      if (is_recursed != 0) goto end; else goto <D.33015>;
      <D.33015>:
      p.416 = p;
      p.437 = p.416;
      p.438 = p.437 + 1;
      p = p.438;
      *p.437 = 0;
      goto <D.21115>;
      <D.21117>:
      D.32984 = __ctype_b_loc ();
      D.32985 = *D.32984;
      p.416 = p;
      D.32913 = *p.416;
      D.33018 = (unsigned int) D.32913;
      D.33019 = D.33018 * 2;
      D.33020 = D.32985 + D.33019;
      D.33021 = *D.33020;
      D.33022 = (int) D.33021;
      D.33023 = D.33022 & 8192;
      if (D.33023 != 0) goto <D.33024>; else goto <D.33025>;
      <D.33024>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      // predicted unlikely by continue predictor.
      goto <D.21115>;
      <D.33025>:
      goto <D.21116>;
      <D.21115>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 != 0) goto <D.21117>; else goto <D.21116>;
      <D.21116>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 == 0) goto <D.33026>; else goto <D.33027>;
      <D.33026>:
      D.32931 = 0;
      return D.32931;
      <D.33027>:
      D.32909 = &info->assembly;
      p.416 = p;
      D.33028 = assembly_name_to_aname (D.32909, p.416);
      if (D.33028 == 0) goto <D.33029>; else goto <D.33030>;
      <D.33029>:
      D.32931 = 0;
      return D.32931;
      <D.33030>:
      goto <D.21094>;
      <D.21118>:
      D.32931 = 0;
      return D.32931;
      <D.21094>:
      D.33031 = info->assembly.name;
      if (D.33031 != 0B) goto <D.21119>; else goto <D.33032>;
      <D.33032>:
      <D.21121>:
      p.416 = p;
      D.32913 = *p.416;
      if (D.32913 != 0) goto <D.21120>; else goto <D.21119>;
      <D.21119>:
      end:
      D.32917 = info->name;
      if (D.32917 == 0B) goto <D.33033>; else goto <D.33035>;
      <D.33035>:
      D.32917 = info->name;
      D.33036 = *D.32917;
      if (D.33036 == 0) goto <D.33033>; else goto <D.33034>;
      <D.33033>:
      D.32931 = 0;
      return D.32931;
      <D.33034>:
      if (endptr != 0B) goto <D.33037>; else goto <D.33038>;
      <D.33037>:
      p.416 = p;
      *endptr = p.416;
      <D.33038>:
      D.32931 = 1;
      return D.32931;
    }
  finally
    {
      p = {CLOBBER};
    }
}


assembly_name_to_aname (struct MonoAssemblyName * assembly, char * p)
{
  mono_byte[17] * D.33042;
  char D.33043;
  const short unsigned int * * D.33047;
  const short unsigned int * D.33048;
  unsigned int D.33049;
  unsigned int D.33050;
  const short unsigned int * D.33051;
  short unsigned int D.33052;
  int D.33053;
  int D.33054;
  int D.33061;
  int D.33066;
  char * s.439;
  char * s.440;
  char * s.441;
  char * s.442;
  char D.33073;
  unsigned int D.33075;
  unsigned int D.33076;
  const short unsigned int * D.33077;
  short unsigned int D.33078;
  int D.33079;
  int D.33080;
  int D.33084;
  long unsigned int D.33086;
  short unsigned int D.33087;
  char * s.443;
  long unsigned int D.33092;
  short unsigned int D.33093;
  long unsigned int D.33097;
  short unsigned int D.33098;
  long unsigned int D.33102;
  short unsigned int D.33103;
  int D.33109;
  int D.33111;
  int D.33118;
  int D.33120;
  int p.444;
  int start.445;
  int D.33127;
  unsigned int len.446;
  char * p.447;
  int found_sep;
  char * s;
  gboolean quoted;

  try
    {
      quoted = 0;
      memset (assembly, 0, 60);
      assembly->culture = "";
      D.33042 = &assembly->public_key_token;
      memset (D.33042, 0, 17);
      D.33043 = *p;
      if (D.33043 == 34) goto <D.33044>; else goto <D.33045>;
      <D.33044>:
      quoted = 1;
      p = p + 1;
      <D.33045>:
      assembly->name = p;
      goto <D.21029>;
      <D.21028>:
      p = p + 1;
      <D.21029>:
      D.33043 = *p;
      if (D.33043 != 0) goto <D.33046>; else goto <D.21030>;
      <D.33046>:
      D.33047 = __ctype_b_loc ();
      D.33048 = *D.33047;
      D.33043 = *p;
      D.33049 = (unsigned int) D.33043;
      D.33050 = D.33049 * 2;
      D.33051 = D.33048 + D.33050;
      D.33052 = *D.33051;
      D.33053 = (int) D.33052;
      D.33054 = D.33053 & 8;
      if (D.33054 != 0) goto <D.21028>; else goto <D.33055>;
      <D.33055>:
      D.33043 = *p;
      if (D.33043 == 46) goto <D.21028>; else goto <D.33056>;
      <D.33056>:
      D.33043 = *p;
      if (D.33043 == 45) goto <D.21028>; else goto <D.33057>;
      <D.33057>:
      D.33043 = *p;
      if (D.33043 == 95) goto <D.21028>; else goto <D.33058>;
      <D.33058>:
      D.33043 = *p;
      if (D.33043 == 36) goto <D.21028>; else goto <D.33059>;
      <D.33059>:
      D.33043 = *p;
      if (D.33043 == 64) goto <D.21028>; else goto <D.33060>;
      <D.33060>:
      D.33047 = __ctype_b_loc ();
      D.33048 = *D.33047;
      D.33043 = *p;
      D.33049 = (unsigned int) D.33043;
      D.33050 = D.33049 * 2;
      D.33051 = D.33048 + D.33050;
      D.33052 = *D.33051;
      D.33053 = (int) D.33052;
      D.33061 = D.33053 & 8192;
      if (D.33061 != 0) goto <D.21028>; else goto <D.21030>;
      <D.21030>:
      if (quoted != 0) goto <D.33062>; else goto <D.33063>;
      <D.33062>:
      D.33043 = *p;
      if (D.33043 != 34) goto <D.33064>; else goto <D.33065>;
      <D.33064>:
      D.33066 = 1;
      return D.33066;
      <D.33065>:
      *p = 0;
      p = p + 1;
      <D.33063>:
      D.33043 = *p;
      if (D.33043 != 44) goto <D.33067>; else goto <D.33068>;
      <D.33067>:
      D.33066 = 1;
      return D.33066;
      <D.33068>:
      *p = 0;
      s.439 = p + 4294967295;
      s = s.439;
      goto <D.21032>;
      <D.21031>:
      s.440 = s;
      s.441 = s.440;
      s.442 = s.441 + 4294967295;
      s = s.442;
      *s.441 = 0;
      <D.21032>:
      s.440 = s;
      D.33073 = *s.440;
      if (D.33073 != 0) goto <D.33074>; else goto <D.21033>;
      <D.33074>:
      D.33047 = __ctype_b_loc ();
      D.33048 = *D.33047;
      s.440 = s;
      D.33073 = *s.440;
      D.33075 = (unsigned int) D.33073;
      D.33076 = D.33075 * 2;
      D.33077 = D.33048 + D.33076;
      D.33078 = *D.33077;
      D.33079 = (int) D.33078;
      D.33080 = D.33079 & 8192;
      if (D.33080 != 0) goto <D.21031>; else goto <D.21033>;
      <D.21033>:
      p = p + 1;
      goto <D.21035>;
      <D.21034>:
      p = p + 1;
      <D.21035>:
      D.33047 = __ctype_b_loc ();
      D.33048 = *D.33047;
      D.33043 = *p;
      D.33049 = (unsigned int) D.33043;
      D.33050 = D.33049 * 2;
      D.33051 = D.33048 + D.33050;
      D.33052 = *D.33051;
      D.33053 = (int) D.33052;
      D.33061 = D.33053 & 8192;
      if (D.33061 != 0) goto <D.21034>; else goto <D.21036>;
      <D.21036>:
      goto <D.21061>;
      <D.21060>:
      D.33043 = *p;
      if (D.33043 == 86) goto <D.33083>; else goto <D.33081>;
      <D.33083>:
      D.33084 = monoeg_g_ascii_strncasecmp (p, "Version=", 8);
      if (D.33084 == 0) goto <D.33085>; else goto <D.33081>;
      <D.33085>:
      p = p + 8;
      D.33086 = strtoul (p, &s, 10);
      D.33087 = (short unsigned int) D.33086;
      assembly->major = D.33087;
      s.440 = s;
      if (s.440 == p) goto <D.33088>; else goto <D.33090>;
      <D.33090>:
      s.440 = s;
      D.33073 = *s.440;
      if (D.33073 != 46) goto <D.33088>; else goto <D.33089>;
      <D.33088>:
      D.33066 = 1;
      return D.33066;
      <D.33089>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33092 = strtoul (p, &s, 10);
      D.33093 = (short unsigned int) D.33092;
      assembly->minor = D.33093;
      s.440 = s;
      if (s.440 == p) goto <D.33094>; else goto <D.33096>;
      <D.33096>:
      s.440 = s;
      D.33073 = *s.440;
      if (D.33073 != 46) goto <D.33094>; else goto <D.33095>;
      <D.33094>:
      D.33066 = 1;
      return D.33066;
      <D.33095>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33097 = strtoul (p, &s, 10);
      D.33098 = (short unsigned int) D.33097;
      assembly->build = D.33098;
      s.440 = s;
      if (s.440 == p) goto <D.33099>; else goto <D.33101>;
      <D.33101>:
      s.440 = s;
      D.33073 = *s.440;
      if (D.33073 != 46) goto <D.33099>; else goto <D.33100>;
      <D.33099>:
      D.33066 = 1;
      return D.33066;
      <D.33100>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33102 = strtoul (p, &s, 10);
      D.33103 = (short unsigned int) D.33102;
      assembly->revision = D.33103;
      s.440 = s;
      if (s.440 == p) goto <D.33104>; else goto <D.33105>;
      <D.33104>:
      D.33066 = 1;
      return D.33066;
      <D.33105>:
      p = s;
      goto <D.33082>;
      <D.33081>:
      D.33043 = *p;
      if (D.33043 == 67) goto <D.33108>; else goto <D.33106>;
      <D.33108>:
      D.33109 = monoeg_g_ascii_strncasecmp (p, "Culture=", 8);
      if (D.33109 == 0) goto <D.33110>; else goto <D.33106>;
      <D.33110>:
      p = p + 8;
      D.33111 = monoeg_g_ascii_strncasecmp (p, "neutral", 7);
      if (D.33111 == 0) goto <D.33112>; else goto <D.33113>;
      <D.33112>:
      assembly->culture = "";
      p = p + 7;
      goto <D.33114>;
      <D.33113>:
      assembly->culture = p;
      goto <D.21038>;
      <D.21037>:
      p = p + 1;
      <D.21038>:
      D.33043 = *p;
      if (D.33043 != 0) goto <D.33115>; else goto <D.21039>;
      <D.33115>:
      D.33043 = *p;
      if (D.33043 != 44) goto <D.21037>; else goto <D.21039>;
      <D.21039>:
      <D.33114>:
      goto <D.33107>;
      <D.33106>:
      D.33043 = *p;
      if (D.33043 == 80) goto <D.33117>; else goto <D.33116>;
      <D.33117>:
      D.33118 = monoeg_g_ascii_strncasecmp (p, "PublicKeyToken=", 15);
      if (D.33118 == 0) goto <D.33119>; else goto <D.33116>;
      <D.33119>:
      p = p + 15;
      D.33120 = strncmp (p, "null", 4);
      if (D.33120 == 0) goto <D.33121>; else goto <D.33122>;
      <D.33121>:
      p = p + 4;
      goto <D.33123>;
      <D.33122>:
      {
        int len;
        gchar * start;

        start = p;
        goto <D.21052>;
        <D.21051>:
        p = p + 1;
        <D.21052>:
        D.33043 = *p;
        if (D.33043 != 0) goto <D.33124>; else goto <D.21053>;
        <D.33124>:
        D.33043 = *p;
        if (D.33043 != 44) goto <D.21051>; else goto <D.21053>;
        <D.21053>:
        p.444 = (int) p;
        start.445 = (int) start;
        D.33127 = p.444 - start.445;
        len = D.33127 + 1;
        if (len > 17) goto <D.33128>; else goto <D.33129>;
        <D.33128>:
        len = 17;
        <D.33129>:
        D.33042 = &assembly->public_key_token;
        len.446 = (unsigned int) len;
        monoeg_g_strlcpy (D.33042, start, len.446);
      }
      <D.33123>:
      goto <D.21056>;
      <D.33116>:
      goto <D.21055>;
      <D.21054>:
      p = p + 1;
      <D.21055>:
      D.33043 = *p;
      if (D.33043 != 0) goto <D.33131>; else goto <D.21056>;
      <D.33131>:
      D.33043 = *p;
      if (D.33043 != 44) goto <D.21054>; else goto <D.21056>;
      <D.21056>:
      <D.33107>:
      <D.33082>:
      found_sep = 0;
      goto <D.21057>;
      <D.21058>:
      p.447 = p;
      p = p.447 + 1;
      *p.447 = 0;
      found_sep = 1;
      // predicted unlikely by continue predictor.
      goto <D.21057>;
      <D.21057>:
      D.33047 = __ctype_b_loc ();
      D.33048 = *D.33047;
      D.33043 = *p;
      D.33049 = (unsigned int) D.33043;
      D.33050 = D.33049 * 2;
      D.33051 = D.33048 + D.33050;
      D.33052 = *D.33051;
      D.33053 = (int) D.33052;
      D.33061 = D.33053 & 8192;
      if (D.33061 != 0) goto <D.21058>; else goto <D.33133>;
      <D.33133>:
      D.33043 = *p;
      if (D.33043 == 44) goto <D.21058>; else goto <D.21059>;
      <D.21059>:
      if (found_sep == 0) goto <D.33134>; else goto <D.33135>;
      <D.33134>:
      D.33066 = 1;
      return D.33066;
      <D.33135>:
      <D.21061>:
      D.33043 = *p;
      if (D.33043 != 0) goto <D.21060>; else goto <D.21062>;
      <D.21062>:
      D.33066 = 0;
      return D.33066;
    }
  finally
    {
      s = {CLOBBER};
    }
}


mono_reflection_get_type (struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  struct MonoType * D.33138;

  D.33138 = mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve);
  return D.33138;
}


mono_reflection_get_type_with_rootimage (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  unsigned int D.33143;
  unsigned int D.33144;
  struct MonoAssembly * D.33146;
  struct MonoType * D.33149;
  struct MonoDomain * D.33150;
  int D.33151;
  int D.33156;
  char * D.33161;
  char D.33163;
  char * D.33165;
  void * D.33166;
  struct MonoDomain * D.33167;
  char * D.33168;
  struct MonoAssembly * D.33171;
  unsigned char D.33172;
  struct MonoImage * D.33176;
  struct MonoType * type;
  struct MonoReflectionAssembly * assembly;
  struct GString * fullName;
  struct GList * mod;

  if (image != 0B) goto <D.33142>; else goto <D.33140>;
  <D.33142>:
  D.33143 = BIT_FIELD_REF <*image, 32, 128>;
  D.33144 = D.33143 & 8;
  if (D.33144 != 0) goto <D.33145>; else goto <D.33140>;
  <D.33145>:
  D.33146 = image->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33146, info, ignorecase);
  goto <D.33141>;
  <D.33140>:
  type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
  <D.33141>:
  if (type != 0B) goto <D.33147>; else goto <D.33148>;
  <D.33147>:
  D.33149 = type;
  return D.33149;
  <D.33148>:
  D.33150 = mono_domain_get ();
  D.33151 = mono_domain_has_type_resolve (D.33150);
  if (D.33151 == 0) goto <D.33152>; else goto <D.33153>;
  <D.33152>:
  D.33149 = 0B;
  return D.33149;
  <D.33153>:
  if (type_resolve != 0B) goto <D.33154>; else goto <D.33155>;
  <D.33154>:
  D.33156 = *type_resolve;
  if (D.33156 != 0) goto <D.33157>; else goto <D.33158>;
  <D.33157>:
  D.33149 = 0B;
  return D.33149;
  <D.33158>:
  *type_resolve = 1;
  <D.33155>:
  fullName = monoeg_g_string_new ("");
  D.33161 = info->name_space;
  if (D.33161 != 0B) goto <D.33162>; else goto <D.33159>;
  <D.33162>:
  D.33161 = info->name_space;
  D.33163 = *D.33161;
  if (D.33163 != 0) goto <D.33164>; else goto <D.33159>;
  <D.33164>:
  D.33161 = info->name_space;
  D.33165 = info->name;
  monoeg_g_string_printf (fullName, "%s.%s", D.33161, D.33165);
  goto <D.33160>;
  <D.33159>:
  D.33165 = info->name;
  monoeg_g_string_printf (fullName, "%s", D.33165);
  <D.33160>:
  mod = info->nested;
  goto <D.21208>;
  <D.21207>:
  D.33166 = mod->data;
  monoeg_g_string_append_printf (fullName, "+%s", D.33166);
  mod = mod->next;
  <D.21208>:
  if (mod != 0B) goto <D.21207>; else goto <D.21209>;
  <D.21209>:
  D.33167 = mono_domain_get ();
  D.33168 = fullName->str;
  assembly = mono_domain_try_type_resolve (D.33167, D.33168, 0B);
  if (assembly != 0B) goto <D.33169>; else goto <D.33170>;
  <D.33169>:
  D.33171 = assembly->assembly;
  D.33172 = D.33171->dynamic;
  if (D.33172 != 0) goto <D.33173>; else goto <D.33174>;
  <D.33173>:
  D.33171 = assembly->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33171, info, ignorecase);
  goto <D.33175>;
  <D.33174>:
  D.33171 = assembly->assembly;
  D.33176 = D.33171->image;
  type = mono_reflection_get_type_internal (rootimage, D.33176, info, ignorecase);
  <D.33175>:
  <D.33170>:
  monoeg_g_string_free (fullName, 1);
  D.33149 = type;
  return D.33149;
}


mono_reflection_get_type_internal_dynamic (struct MonoImage * rootimage, struct MonoAssembly * assembly, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  unsigned char D.33178;
  _Bool D.33179;
  long int D.33180;
  long int D.33181;
  struct MonoDomain * D.33184;
  struct MonoArray * D.33185;
  unsigned int i.448;
  char * D.33189;
  struct MonoDynamicImage * D.33190;
  struct MonoImage * D.33191;
  unsigned int D.33193;
  struct MonoArray * D.33196;
  char * D.33199;
  struct MonoImage * D.33200;
  unsigned int D.33202;
  struct MonoType * D.33203;
  struct MonoReflectionAssemblyBuilder * abuilder;
  struct MonoType * type;
  int i;

  D.33178 = assembly->dynamic;
  D.33179 = D.33178 == 0;
  D.33180 = (long int) D.33179;
  D.33181 = __builtin_expect (D.33180, 0);
  if (D.33181 != 0) goto <D.33182>; else goto <D.33183>;
  <D.33182>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7574, "assembly->dynamic");
  <D.33183>:
  D.33184 = MEM[(struct MonoDynamicAssembly *)assembly].domain;
  abuilder = mono_assembly_get_object (D.33184, assembly);
  type = 0B;
  D.33185 = abuilder->modules;
  if (D.33185 != 0B) goto <D.33186>; else goto <D.33187>;
  <D.33186>:
  i = 0;
  goto <D.21191>;
  <D.21190>:
  {
    struct MonoReflectionModuleBuilder * mb;

    D.33185 = abuilder->modules;
    i.448 = (unsigned int) i;
    D.33189 = mono_array_addr_with_size (D.33185, 4, i.448);
    mb = MEM[(struct MonoReflectionModuleBuilder * *)D.33189];
    D.33190 = mb->dynamic_image;
    D.33191 = &D.33190->image;
    type = mono_reflection_get_type_internal (rootimage, D.33191, info, ignorecase);
    if (type != 0B) goto <D.21189>; else goto <D.33192>;
    <D.33192>:
  }
  i = i + 1;
  <D.21191>:
  i.448 = (unsigned int) i;
  D.33185 = abuilder->modules;
  D.33193 = mono_array_length (D.33185);
  if (i.448 < D.33193) goto <D.21190>; else goto <D.21189>;
  <D.21189>:
  <D.33187>:
  if (type == 0B) goto <D.33194>; else goto <D.33195>;
  <D.33194>:
  D.33196 = abuilder->loaded_modules;
  if (D.33196 != 0B) goto <D.33197>; else goto <D.33198>;
  <D.33197>:
  i = 0;
  goto <D.21195>;
  <D.21194>:
  {
    struct MonoReflectionModule * mod;

    D.33196 = abuilder->loaded_modules;
    i.448 = (unsigned int) i;
    D.33199 = mono_array_addr_with_size (D.33196, 4, i.448);
    mod = MEM[(struct MonoReflectionModule * *)D.33199];
    D.33200 = mod->image;
    type = mono_reflection_get_type_internal (rootimage, D.33200, info, ignorecase);
    if (type != 0B) goto <D.21193>; else goto <D.33201>;
    <D.33201>:
  }
  i = i + 1;
  <D.21195>:
  i.448 = (unsigned int) i;
  D.33196 = abuilder->loaded_modules;
  D.33202 = mono_array_length (D.33196);
  if (i.448 < D.33202) goto <D.21194>; else goto <D.21193>;
  <D.21193>:
  <D.33198>:
  <D.33195>:
  D.33203 = type;
  return D.33203;
}


mono_reflection_get_type_internal (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  char * D.33209;
  char * D.33210;
  struct MonoType * D.33214;
  const char * D.33217;
  void * D.33218;
  int D.33219;
  int D.21156;
  struct GPtrArray * D.33226;
  unsigned int D.33229;
  unsigned int D.33230;
  void * * D.33231;
  unsigned int i.449;
  unsigned int D.33233;
  void * * D.33234;
  struct MonoType * * D.33235;
  struct MonoType * D.33236;
  struct MonoType * D.33237;
  unsigned int i.450;
  struct MonoDomain * D.33241;
  struct MonoType * D.33242;
  int D.33243;
  unsigned int modval.451;
  struct MonoClass * klass;
  struct GList * mod;
  int modval;
  gboolean bounded;

  bounded = 0;
  if (image == 0B) goto <D.33205>; else goto <D.33206>;
  <D.33205>:
  image = mono_defaults.corlib;
  <D.33206>:
  if (ignorecase != 0) goto <D.33207>; else goto <D.33208>;
  <D.33207>:
  D.33209 = info->name_space;
  D.33210 = info->name;
  klass = mono_class_from_name_case (image, D.33209, D.33210);
  goto <D.33211>;
  <D.33208>:
  D.33209 = info->name_space;
  D.33210 = info->name;
  klass = mono_class_from_name (image, D.33209, D.33210);
  <D.33211>:
  if (klass == 0B) goto <D.33212>; else goto <D.33213>;
  <D.33212>:
  D.33214 = 0B;
  return D.33214;
  <D.33213>:
  mod = info->nested;
  goto <D.21161>;
  <D.21160>:
  {
    void * iter;
    struct MonoClass * parent;

    try
      {
        iter = 0B;
        parent = klass;
        mono_class_init (parent);
        goto <D.21158>;
        <D.21157>:
        if (ignorecase != 0) goto <D.33215>; else goto <D.33216>;
        <D.33215>:
        D.33217 = klass->name;
        D.33218 = mod->data;
        D.33219 = monoeg_ascii_strcasecmp (D.33217, D.33218);
        if (D.33219 == 0) goto <D.21147>; else goto <D.33220>;
        <D.33220>:
        goto <D.33221>;
        <D.33216>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.33217 = klass->name;
          D.33218 = mod->data;
          D.21156 = __builtin_strcmp (D.33217, D.33218);
        }
        if (D.21156 == 0) goto <D.21147>; else goto <D.33222>;
        <D.33222>:
        <D.33221>:
        <D.21158>:
        klass = mono_class_get_nested_types (parent, &iter);
        if (klass != 0B) goto <D.21157>; else goto <D.21147>;
        <D.21147>:
        if (klass == 0B) goto <D.21159>; else goto <D.33223>;
        <D.33223>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  mod = mod->next;
  <D.21161>:
  if (mod != 0B) goto <D.21160>; else goto <D.21159>;
  <D.21159>:
  if (klass == 0B) goto <D.33224>; else goto <D.33225>;
  <D.33224>:
  D.33214 = 0B;
  return D.33214;
  <D.33225>:
  D.33226 = info->type_arguments;
  if (D.33226 != 0B) goto <D.33227>; else goto <D.33228>;
  <D.33227>:
  {
    struct MonoType * * type_args;
    struct MonoReflectionType * the_type;
    struct MonoType * instance;
    int i;

    D.33226 = info->type_arguments;
    D.33229 = D.33226->len;
    D.33230 = D.33229 * 4;
    type_args = monoeg_malloc0 (D.33230);
    i = 0;
    goto <D.21168>;
    <D.21167>:
    {
      struct MonoTypeNameParse * subinfo;

      D.33226 = info->type_arguments;
      D.33231 = D.33226->pdata;
      i.449 = (unsigned int) i;
      D.33233 = i.449 * 4;
      D.33234 = D.33231 + D.33233;
      subinfo = *D.33234;
      i.449 = (unsigned int) i;
      D.33233 = i.449 * 4;
      D.33235 = type_args + D.33233;
      D.33236 = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
      *D.33235 = D.33236;
      i.449 = (unsigned int) i;
      D.33233 = i.449 * 4;
      D.33235 = type_args + D.33233;
      D.33237 = *D.33235;
      if (D.33237 == 0B) goto <D.33238>; else goto <D.33239>;
      <D.33238>:
      monoeg_g_free (type_args);
      D.33214 = 0B;
      return D.33214;
      <D.33239>:
    }
    i = i + 1;
    <D.21168>:
    i.450 = (unsigned int) i;
    D.33226 = info->type_arguments;
    D.33229 = D.33226->len;
    if (i.450 < D.33229) goto <D.21167>; else goto <D.21169>;
    <D.21169>:
    D.33241 = mono_domain_get ();
    D.33242 = &klass->byval_arg;
    the_type = mono_type_get_object (D.33241, D.33242);
    D.33226 = info->type_arguments;
    D.33229 = D.33226->len;
    D.33243 = (int) D.33229;
    instance = mono_reflection_bind_generic_parameters (the_type, D.33243, type_args);
    monoeg_g_free (type_args);
    if (instance == 0B) goto <D.33244>; else goto <D.33245>;
    <D.33244>:
    D.33214 = 0B;
    return D.33214;
    <D.33245>:
    klass = mono_class_from_mono_type (instance);
  }
  <D.33228>:
  mod = info->modifiers;
  goto <D.21171>;
  <D.21170>:
  D.33218 = mod->data;
  modval = (int) D.33218;
  if (modval == 0) goto <D.33246>; else goto <D.33247>;
  <D.33246>:
  D.33214 = &klass->this_arg;
  return D.33214;
  <D.33247>:
  if (modval == -1) goto <D.33248>; else goto <D.33249>;
  <D.33248>:
  D.33242 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.33242);
  goto <D.33250>;
  <D.33249>:
  if (modval == -2) goto <D.33251>; else goto <D.33252>;
  <D.33251>:
  bounded = 1;
  goto <D.33253>;
  <D.33252>:
  modval.451 = (unsigned int) modval;
  klass = mono_bounded_array_class_get (klass, modval.451, bounded);
  <D.33253>:
  <D.33250>:
  mod = mod->next;
  <D.21171>:
  if (mod != 0B) goto <D.21170>; else goto <D.21172>;
  <D.21172>:
  D.33214 = &klass->byval_arg;
  return D.33214;
}


_mono_reflection_get_type_from_info (struct MonoTypeNameParse * info, struct MonoImage * image, gboolean ignorecase)
{
  const char * D.33258;
  struct MonoAssemblyName * D.33261;
  struct MonoAssembly * D.33266;
  struct MonoAssemblyName * D.33269;
  int D.33270;
  struct MonoType * D.33277;
  struct MonoImage * D.33285;
  gboolean type_resolve;
  struct MonoType * type;
  struct MonoImage * rootimage;

  try
    {
      type_resolve = 0;
      rootimage = image;
      D.33258 = info->assembly.name;
      if (D.33258 != 0B) goto <D.33259>; else goto <D.33260>;
      <D.33259>:
      {
        struct MonoAssembly * assembly;

        D.33261 = &info->assembly;
        assembly = mono_assembly_loaded (D.33261);
        if (assembly == 0B) goto <D.33262>; else goto <D.33263>;
        <D.33262>:
        if (image != 0B) goto <D.33264>; else goto <D.33265>;
        <D.33264>:
        D.33266 = image->assembly;
        if (D.33266 != 0B) goto <D.33267>; else goto <D.33268>;
        <D.33267>:
        D.33261 = &info->assembly;
        D.33266 = image->assembly;
        D.33269 = &D.33266->aname;
        D.33270 = mono_assembly_names_equal (D.33261, D.33269);
        if (D.33270 != 0) goto <D.33271>; else goto <D.33272>;
        <D.33271>:
        assembly = image->assembly;
        <D.33272>:
        <D.33268>:
        <D.33265>:
        <D.33263>:
        if (assembly == 0B) goto <D.33273>; else goto <D.33274>;
        <D.33273>:
        D.33261 = &info->assembly;
        assembly = mono_assembly_load (D.33261, 0B, 0B);
        if (assembly == 0B) goto <D.33275>; else goto <D.33276>;
        <D.33275>:
        D.33277 = 0B;
        return D.33277;
        <D.33276>:
        <D.33274>:
        image = assembly->image;
      }
      goto <D.33278>;
      <D.33260>:
      if (image == 0B) goto <D.33279>; else goto <D.33280>;
      <D.33279>:
      image = mono_defaults.corlib;
      <D.33280>:
      <D.33278>:
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      if (type == 0B) goto <D.33281>; else goto <D.33282>;
      <D.33281>:
      D.33258 = info->assembly.name;
      if (D.33258 == 0B) goto <D.33283>; else goto <D.33284>;
      <D.33283>:
      D.33285 = mono_defaults.corlib;
      if (D.33285 != image) goto <D.33286>; else goto <D.33287>;
      <D.33286>:
      image = mono_defaults.corlib;
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      <D.33287>:
      <D.33284>:
      <D.33282>:
      D.33277 = type;
      return D.33277;
    }
  finally
    {
      type_resolve = {CLOBBER};
    }
}


mono_reflection_free_type_info (struct MonoTypeNameParse * info)
{
  struct GList * D.33290;
  struct GList * D.33291;
  struct GPtrArray * D.33292;
  void * * D.33295;
  unsigned int i.452;
  unsigned int D.33297;
  void * * D.33298;
  unsigned int i.453;
  unsigned int D.33300;

  D.33290 = info->modifiers;
  monoeg_g_list_free (D.33290);
  D.33291 = info->nested;
  monoeg_g_list_free (D.33291);
  D.33292 = info->type_arguments;
  if (D.33292 != 0B) goto <D.33293>; else goto <D.33294>;
  <D.33293>:
  {
    int i;

    i = 0;
    goto <D.21216>;
    <D.21215>:
    {
      struct MonoTypeNameParse * subinfo;

      D.33292 = info->type_arguments;
      D.33295 = D.33292->pdata;
      i.452 = (unsigned int) i;
      D.33297 = i.452 * 4;
      D.33298 = D.33295 + D.33297;
      subinfo = *D.33298;
      mono_reflection_free_type_info (subinfo);
      monoeg_g_free (subinfo);
    }
    i = i + 1;
    <D.21216>:
    i.453 = (unsigned int) i;
    D.33292 = info->type_arguments;
    D.33300 = D.33292->len;
    if (i.453 < D.33300) goto <D.21215>; else goto <D.21217>;
    <D.21217>:
    D.33292 = info->type_arguments;
    monoeg_g_ptr_array_free (D.33292, 1);
  }
  <D.33294>:
}


mono_reflection_type_from_name (char * name, struct MonoImage * image)
{
  int D.33301;
  struct MonoType * D.33304;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  char * tmp;

  try
    {
      type = 0B;
      tmp = monoeg_strdup (name);
      D.33301 = mono_reflection_parse_type (tmp, &info);
      if (D.33301 != 0) goto <D.33302>; else goto <D.33303>;
      <D.33302>:
      type = _mono_reflection_get_type_from_info (&info, image, 0);
      <D.33303>:
      monoeg_g_free (tmp);
      mono_reflection_free_type_info (&info);
      D.33304 = type;
      return D.33304;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_reflection_get_token (struct MonoObject * obj)
{
  struct MonoVTable * D.33307;
  int D.21238;
  int iftmp.454;
  int D.21237;
  const char[14] * D.33311;
  unsigned char D.33312;
  int D.33313;
  unsigned char D.33314;
  int D.33315;
  const unsigned char * D.33320;
  unsigned char D.33321;
  int D.33322;
  const unsigned char * D.33323;
  unsigned char D.33324;
  int D.33325;
  const unsigned char * D.33330;
  unsigned char D.33331;
  int D.33332;
  const unsigned char * D.33333;
  unsigned char D.33334;
  int D.33335;
  const unsigned char * D.33340;
  unsigned char D.33341;
  int D.33342;
  const unsigned char * D.33343;
  unsigned char D.33344;
  int D.33345;
  const char * D.33347;
  unsigned int D.33350;
  int D.21248;
  int iftmp.455;
  int D.21247;
  const char[19] * D.33355;
  unsigned char D.33356;
  int D.33357;
  unsigned char D.33358;
  int D.33359;
  const unsigned char * D.33364;
  unsigned char D.33365;
  int D.33366;
  const unsigned char * D.33367;
  unsigned char D.33368;
  int D.33369;
  const unsigned char * D.33374;
  unsigned char D.33375;
  int D.33376;
  const unsigned char * D.33377;
  unsigned char D.33378;
  int D.33379;
  const unsigned char * D.33384;
  unsigned char D.33385;
  int D.33386;
  const unsigned char * D.33387;
  unsigned char D.33388;
  int D.33389;
  unsigned int D.33393;
  int D.21258;
  int iftmp.456;
  int D.21257;
  const char[13] * D.33398;
  unsigned char D.33399;
  int D.33400;
  unsigned char D.33401;
  int D.33402;
  const unsigned char * D.33407;
  unsigned char D.33408;
  int D.33409;
  const unsigned char * D.33410;
  unsigned char D.33411;
  int D.33412;
  const unsigned char * D.33417;
  unsigned char D.33418;
  int D.33419;
  const unsigned char * D.33420;
  unsigned char D.33421;
  int D.33422;
  const unsigned char * D.33427;
  unsigned char D.33428;
  int D.33429;
  const unsigned char * D.33430;
  unsigned char D.33431;
  int D.33432;
  int D.33436;
  int D.33437;
  int D.21268;
  int iftmp.457;
  int D.21267;
  const char[12] * D.33442;
  unsigned char D.33443;
  int D.33444;
  unsigned char D.33445;
  int D.33446;
  const unsigned char * D.33451;
  unsigned char D.33452;
  int D.33453;
  const unsigned char * D.33454;
  unsigned char D.33455;
  int D.33456;
  const unsigned char * D.33461;
  unsigned char D.33462;
  int D.33463;
  const unsigned char * D.33464;
  unsigned char D.33465;
  int D.33466;
  const unsigned char * D.33471;
  unsigned char D.33472;
  int D.33473;
  const unsigned char * D.33474;
  unsigned char D.33475;
  int D.33476;
  unsigned int D.33480;
  int D.21278;
  int iftmp.458;
  int D.21277;
  const char[9] * D.33485;
  unsigned char D.33486;
  int D.33487;
  unsigned char D.33488;
  int D.33489;
  const unsigned char * D.33494;
  unsigned char D.33495;
  int D.33496;
  const unsigned char * D.33497;
  unsigned char D.33498;
  int D.33499;
  const unsigned char * D.33504;
  unsigned char D.33505;
  int D.33506;
  const unsigned char * D.33507;
  unsigned char D.33508;
  int D.33509;
  const unsigned char * D.33514;
  unsigned char D.33515;
  int D.33516;
  const unsigned char * D.33517;
  unsigned char D.33518;
  int D.33519;
  int D.33523;
  struct MonoException * D.33526;
  int D.21289;
  int iftmp.459;
  int D.21288;
  const char[12] * D.33534;
  unsigned char D.33535;
  int D.33536;
  unsigned char D.33537;
  int D.33538;
  const unsigned char * D.33543;
  unsigned char D.33544;
  int D.33545;
  const unsigned char * D.33546;
  unsigned char D.33547;
  int D.33548;
  const unsigned char * D.33553;
  unsigned char D.33554;
  int D.33555;
  const unsigned char * D.33556;
  unsigned char D.33557;
  int D.33558;
  const unsigned char * D.33563;
  unsigned char D.33564;
  int D.33565;
  const unsigned char * D.33566;
  unsigned char D.33567;
  int D.33568;
  int D.21298;
  int iftmp.460;
  int D.21297;
  const char[11] * D.33574;
  unsigned char D.33575;
  int D.33576;
  unsigned char D.33577;
  int D.33578;
  const unsigned char * D.33583;
  unsigned char D.33584;
  int D.33585;
  const unsigned char * D.33586;
  unsigned char D.33587;
  int D.33588;
  const unsigned char * D.33593;
  unsigned char D.33594;
  int D.33595;
  const unsigned char * D.33596;
  unsigned char D.33597;
  int D.33598;
  const unsigned char * D.33603;
  unsigned char D.33604;
  int D.33605;
  const unsigned char * D.33606;
  unsigned char D.33607;
  int D.33608;
  int D.21307;
  int iftmp.461;
  int D.21306;
  const char[18] * D.33614;
  unsigned char D.33615;
  int D.33616;
  unsigned char D.33617;
  int D.33618;
  const unsigned char * D.33623;
  unsigned char D.33624;
  int D.33625;
  const unsigned char * D.33626;
  unsigned char D.33627;
  int D.33628;
  const unsigned char * D.33633;
  unsigned char D.33634;
  int D.33635;
  const unsigned char * D.33636;
  unsigned char D.33637;
  int D.33638;
  const unsigned char * D.33643;
  unsigned char D.33644;
  int D.33645;
  const unsigned char * D.33646;
  unsigned char D.33647;
  int D.33648;
  int D.21316;
  int iftmp.462;
  int D.21315;
  const char[19] * D.33654;
  unsigned char D.33655;
  int D.33656;
  unsigned char D.33657;
  int D.33658;
  const unsigned char * D.33663;
  unsigned char D.33664;
  int D.33665;
  const unsigned char * D.33666;
  unsigned char D.33667;
  int D.33668;
  const unsigned char * D.33673;
  unsigned char D.33674;
  int D.33675;
  const unsigned char * D.33676;
  unsigned char D.33677;
  int D.33678;
  const unsigned char * D.33683;
  unsigned char D.33684;
  int D.33685;
  const unsigned char * D.33686;
  unsigned char D.33687;
  int D.33688;
  struct MonoMethod * D.33690;
  unsigned int D.33691;
  unsigned int D.33692;
  uint32_t D.33695;
  struct MonoMethod * D.33696;
  int D.21327;
  int iftmp.463;
  int D.21326;
  const char[10] * D.33700;
  unsigned char D.33701;
  int D.33702;
  unsigned char D.33703;
  int D.33704;
  const unsigned char * D.33709;
  unsigned char D.33710;
  int D.33711;
  const unsigned char * D.33712;
  unsigned char D.33713;
  int D.33714;
  const unsigned char * D.33719;
  unsigned char D.33720;
  int D.33721;
  const unsigned char * D.33722;
  unsigned char D.33723;
  int D.33724;
  const unsigned char * D.33729;
  unsigned char D.33730;
  int D.33731;
  const unsigned char * D.33732;
  unsigned char D.33733;
  int D.33734;
  struct MonoClassField * D.33738;
  int D.33739;
  struct MonoClass * D.33742;
  int D.33743;
  struct MonoClassField * D.33744;
  int D.33745;
  int D.33746;
  int iftmp.464;
  int D.33752;
  _Bool D.33753;
  long int D.33754;
  long int D.33755;
  struct MonoObject * * D.33758;
  unsigned int field_index.465;
  unsigned int D.33760;
  struct MonoObject * * D.33761;
  int D.21340;
  int iftmp.466;
  int D.21339;
  const char[13] * D.33766;
  unsigned char D.33767;
  int D.33768;
  unsigned char D.33769;
  int D.33770;
  const unsigned char * D.33775;
  unsigned char D.33776;
  int D.33777;
  const unsigned char * D.33778;
  unsigned char D.33779;
  int D.33780;
  const unsigned char * D.33785;
  unsigned char D.33786;
  int D.33787;
  const unsigned char * D.33788;
  unsigned char D.33789;
  int D.33790;
  const unsigned char * D.33795;
  unsigned char D.33796;
  int D.33797;
  const unsigned char * D.33798;
  unsigned char D.33799;
  int D.33800;
  struct MonoProperty * D.33804;
  int D.21350;
  int iftmp.467;
  int D.21349;
  const char[10] * D.33809;
  unsigned char D.33810;
  int D.33811;
  unsigned char D.33812;
  int D.33813;
  const unsigned char * D.33818;
  unsigned char D.33819;
  int D.33820;
  const unsigned char * D.33821;
  unsigned char D.33822;
  int D.33823;
  const unsigned char * D.33828;
  unsigned char D.33829;
  int D.33830;
  const unsigned char * D.33831;
  unsigned char D.33832;
  int D.33833;
  const unsigned char * D.33838;
  unsigned char D.33839;
  int D.33840;
  const unsigned char * D.33841;
  unsigned char D.33842;
  int D.33843;
  struct MonoEvent * D.33847;
  int D.21360;
  int iftmp.468;
  int D.21359;
  const char[14] * D.33855;
  unsigned char D.33856;
  int D.33857;
  unsigned char D.33858;
  int D.33859;
  const unsigned char * D.33864;
  unsigned char D.33865;
  int D.33866;
  const unsigned char * D.33867;
  unsigned char D.33868;
  int D.33869;
  const unsigned char * D.33874;
  unsigned char D.33875;
  int D.33876;
  const unsigned char * D.33877;
  unsigned char D.33878;
  int D.33879;
  const unsigned char * D.33884;
  unsigned char D.33885;
  int D.33886;
  const unsigned char * D.33887;
  unsigned char D.33888;
  int D.33889;
  int D.21369;
  int iftmp.469;
  int D.21368;
  const char[18] * D.33895;
  unsigned char D.33896;
  int D.33897;
  unsigned char D.33898;
  int D.33899;
  const unsigned char * D.33904;
  unsigned char D.33905;
  int D.33906;
  const unsigned char * D.33907;
  unsigned char D.33908;
  int D.33909;
  const unsigned char * D.33914;
  unsigned char D.33915;
  int D.33916;
  const unsigned char * D.33917;
  unsigned char D.33918;
  int D.33919;
  const unsigned char * D.33924;
  unsigned char D.33925;
  int D.33926;
  const unsigned char * D.33927;
  unsigned char D.33928;
  int D.33929;
  struct MonoObject * D.33931;
  struct MonoVTable * D.33932;
  int D.33933;
  _Bool D.33934;
  long int D.33935;
  long int D.33936;
  struct MonoMethod * D.33939;
  int D.33940;
  int D.21380;
  int iftmp.470;
  int D.21379;
  const char[7] * D.33947;
  unsigned char D.33948;
  int D.33949;
  unsigned char D.33950;
  int D.33951;
  const unsigned char * D.33956;
  unsigned char D.33957;
  int D.33958;
  const unsigned char * D.33959;
  unsigned char D.33960;
  int D.33961;
  const unsigned char * D.33966;
  unsigned char D.33967;
  int D.33968;
  const unsigned char * D.33969;
  unsigned char D.33970;
  int D.33971;
  const unsigned char * D.33976;
  unsigned char D.33977;
  int D.33978;
  const unsigned char * D.33979;
  unsigned char D.33980;
  int D.33981;
  int D.21389;
  int iftmp.471;
  int D.21388;
  const char[11] * D.33987;
  unsigned char D.33988;
  int D.33989;
  unsigned char D.33990;
  int D.33991;
  const unsigned char * D.33996;
  unsigned char D.33997;
  int D.33998;
  const unsigned char * D.33999;
  unsigned char D.34000;
  int D.34001;
  const unsigned char * D.34006;
  unsigned char D.34007;
  int D.34008;
  const unsigned char * D.34009;
  unsigned char D.34010;
  int D.34011;
  const unsigned char * D.34016;
  unsigned char D.34017;
  int D.34018;
  const unsigned char * D.34019;
  unsigned char D.34020;
  int D.34021;
  int D.21399;
  int iftmp.472;
  int D.21398;
  const char[9] * D.34029;
  unsigned char D.34030;
  int D.34031;
  unsigned char D.34032;
  int D.34033;
  const unsigned char * D.34038;
  unsigned char D.34039;
  int D.34040;
  const unsigned char * D.34041;
  unsigned char D.34042;
  int D.34043;
  const unsigned char * D.34048;
  unsigned char D.34049;
  int D.34050;
  const unsigned char * D.34051;
  unsigned char D.34052;
  int D.34053;
  const unsigned char * D.34058;
  unsigned char D.34059;
  int D.34060;
  const unsigned char * D.34061;
  unsigned char D.34062;
  int D.34063;
  int D.21408;
  int iftmp.473;
  int D.21407;
  const char[13] * D.34069;
  unsigned char D.34070;
  int D.34071;
  unsigned char D.34072;
  int D.34073;
  const unsigned char * D.34078;
  unsigned char D.34079;
  int D.34080;
  const unsigned char * D.34081;
  unsigned char D.34082;
  int D.34083;
  const unsigned char * D.34088;
  unsigned char D.34089;
  int D.34090;
  const unsigned char * D.34091;
  unsigned char D.34092;
  int D.34093;
  const unsigned char * D.34098;
  unsigned char D.34099;
  int D.34100;
  const unsigned char * D.34101;
  unsigned char D.34102;
  int D.34103;
  const char * D.34105;
  struct MonoClass * klass;
  guint32 token;

  token = 0;
  D.33307 = obj->vtable;
  klass = D.33307->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33311 = "MethodBuilder";
      D.33312 = MEM[(const unsigned char *)D.33311];
      D.33313 = (int) D.33312;
      D.33314 = *__s2;
      D.33315 = (int) D.33314;
      __result = D.33313 - D.33315;
      {
        if (__s2_len != 0) goto <D.33316>; else goto <D.33317>;
        <D.33316>:
        if (__result == 0) goto <D.33318>; else goto <D.33319>;
        <D.33318>:
        D.33320 = &MEM[(void *)"MethodBuilder" + 1B];
        D.33321 = *D.33320;
        D.33322 = (int) D.33321;
        D.33323 = __s2 + 1;
        D.33324 = *D.33323;
        D.33325 = (int) D.33324;
        __result = D.33322 - D.33325;
        if (__s2_len > 1) goto <D.33326>; else goto <D.33327>;
        <D.33326>:
        if (__result == 0) goto <D.33328>; else goto <D.33329>;
        <D.33328>:
        D.33330 = &MEM[(void *)"MethodBuilder" + 2B];
        D.33331 = *D.33330;
        D.33332 = (int) D.33331;
        D.33333 = __s2 + 2;
        D.33334 = *D.33333;
        D.33335 = (int) D.33334;
        __result = D.33332 - D.33335;
        if (__s2_len > 2) goto <D.33336>; else goto <D.33337>;
        <D.33336>:
        if (__result == 0) goto <D.33338>; else goto <D.33339>;
        <D.33338>:
        D.33340 = &MEM[(void *)"MethodBuilder" + 3B];
        D.33341 = *D.33340;
        D.33342 = (int) D.33341;
        D.33343 = __s2 + 3;
        D.33344 = *D.33343;
        D.33345 = (int) D.33344;
        __result = D.33342 - D.33345;
        <D.33339>:
        <D.33337>:
        <D.33329>:
        <D.33327>:
        <D.33319>:
        <D.33317>:
      }
      D.21237 = __result;
    }
    iftmp.454 = -D.21237;
    goto <D.33346>;
    <D.33310>:
    D.33347 = klass->name;
    iftmp.454 = __builtin_strcmp (D.33347, "MethodBuilder");
    <D.33346>:
    D.21238 = iftmp.454;
  }
  if (D.21238 == 0) goto <D.33348>; else goto <D.33349>;
  <D.33348>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.33350 = mb->table_idx;
    token = D.33350 | 100663296;
  }
  goto <D.33351>;
  <D.33349>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33355 = "ConstructorBuilder";
      D.33356 = MEM[(const unsigned char *)D.33355];
      D.33357 = (int) D.33356;
      D.33358 = *__s2;
      D.33359 = (int) D.33358;
      __result = D.33357 - D.33359;
      {
        if (__s2_len != 0) goto <D.33360>; else goto <D.33361>;
        <D.33360>:
        if (__result == 0) goto <D.33362>; else goto <D.33363>;
        <D.33362>:
        D.33364 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.33365 = *D.33364;
        D.33366 = (int) D.33365;
        D.33367 = __s2 + 1;
        D.33368 = *D.33367;
        D.33369 = (int) D.33368;
        __result = D.33366 - D.33369;
        if (__s2_len > 1) goto <D.33370>; else goto <D.33371>;
        <D.33370>:
        if (__result == 0) goto <D.33372>; else goto <D.33373>;
        <D.33372>:
        D.33374 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.33375 = *D.33374;
        D.33376 = (int) D.33375;
        D.33377 = __s2 + 2;
        D.33378 = *D.33377;
        D.33379 = (int) D.33378;
        __result = D.33376 - D.33379;
        if (__s2_len > 2) goto <D.33380>; else goto <D.33381>;
        <D.33380>:
        if (__result == 0) goto <D.33382>; else goto <D.33383>;
        <D.33382>:
        D.33384 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.33385 = *D.33384;
        D.33386 = (int) D.33385;
        D.33387 = __s2 + 3;
        D.33388 = *D.33387;
        D.33389 = (int) D.33388;
        __result = D.33386 - D.33389;
        <D.33383>:
        <D.33381>:
        <D.33373>:
        <D.33371>:
        <D.33363>:
        <D.33361>:
      }
      D.21247 = __result;
    }
    iftmp.455 = -D.21247;
    goto <D.33390>;
    <D.33354>:
    D.33347 = klass->name;
    iftmp.455 = __builtin_strcmp (D.33347, "ConstructorBuilder");
    <D.33390>:
    D.21248 = iftmp.455;
  }
  if (D.21248 == 0) goto <D.33391>; else goto <D.33392>;
  <D.33391>:
  {
    struct MonoReflectionCtorBuilder * mb;

    mb = obj;
    D.33393 = mb->table_idx;
    token = D.33393 | 100663296;
  }
  goto <D.33394>;
  <D.33392>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33398 = "FieldBuilder";
      D.33399 = MEM[(const unsigned char *)D.33398];
      D.33400 = (int) D.33399;
      D.33401 = *__s2;
      D.33402 = (int) D.33401;
      __result = D.33400 - D.33402;
      {
        if (__s2_len != 0) goto <D.33403>; else goto <D.33404>;
        <D.33403>:
        if (__result == 0) goto <D.33405>; else goto <D.33406>;
        <D.33405>:
        D.33407 = &MEM[(void *)"FieldBuilder" + 1B];
        D.33408 = *D.33407;
        D.33409 = (int) D.33408;
        D.33410 = __s2 + 1;
        D.33411 = *D.33410;
        D.33412 = (int) D.33411;
        __result = D.33409 - D.33412;
        if (__s2_len > 1) goto <D.33413>; else goto <D.33414>;
        <D.33413>:
        if (__result == 0) goto <D.33415>; else goto <D.33416>;
        <D.33415>:
        D.33417 = &MEM[(void *)"FieldBuilder" + 2B];
        D.33418 = *D.33417;
        D.33419 = (int) D.33418;
        D.33420 = __s2 + 2;
        D.33421 = *D.33420;
        D.33422 = (int) D.33421;
        __result = D.33419 - D.33422;
        if (__s2_len > 2) goto <D.33423>; else goto <D.33424>;
        <D.33423>:
        if (__result == 0) goto <D.33425>; else goto <D.33426>;
        <D.33425>:
        D.33427 = &MEM[(void *)"FieldBuilder" + 3B];
        D.33428 = *D.33427;
        D.33429 = (int) D.33428;
        D.33430 = __s2 + 3;
        D.33431 = *D.33430;
        D.33432 = (int) D.33431;
        __result = D.33429 - D.33432;
        <D.33426>:
        <D.33424>:
        <D.33416>:
        <D.33414>:
        <D.33406>:
        <D.33404>:
      }
      D.21257 = __result;
    }
    iftmp.456 = -D.21257;
    goto <D.33433>;
    <D.33397>:
    D.33347 = klass->name;
    iftmp.456 = __builtin_strcmp (D.33347, "FieldBuilder");
    <D.33433>:
    D.21258 = iftmp.456;
  }
  if (D.21258 == 0) goto <D.33434>; else goto <D.33435>;
  <D.33434>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.33436 = fb->table_idx;
    D.33437 = D.33436 | 67108864;
    token = (guint32) D.33437;
  }
  goto <D.33438>;
  <D.33435>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33442 = "TypeBuilder";
      D.33443 = MEM[(const unsigned char *)D.33442];
      D.33444 = (int) D.33443;
      D.33445 = *__s2;
      D.33446 = (int) D.33445;
      __result = D.33444 - D.33446;
      {
        if (__s2_len != 0) goto <D.33447>; else goto <D.33448>;
        <D.33447>:
        if (__result == 0) goto <D.33449>; else goto <D.33450>;
        <D.33449>:
        D.33451 = &MEM[(void *)"TypeBuilder" + 1B];
        D.33452 = *D.33451;
        D.33453 = (int) D.33452;
        D.33454 = __s2 + 1;
        D.33455 = *D.33454;
        D.33456 = (int) D.33455;
        __result = D.33453 - D.33456;
        if (__s2_len > 1) goto <D.33457>; else goto <D.33458>;
        <D.33457>:
        if (__result == 0) goto <D.33459>; else goto <D.33460>;
        <D.33459>:
        D.33461 = &MEM[(void *)"TypeBuilder" + 2B];
        D.33462 = *D.33461;
        D.33463 = (int) D.33462;
        D.33464 = __s2 + 2;
        D.33465 = *D.33464;
        D.33466 = (int) D.33465;
        __result = D.33463 - D.33466;
        if (__s2_len > 2) goto <D.33467>; else goto <D.33468>;
        <D.33467>:
        if (__result == 0) goto <D.33469>; else goto <D.33470>;
        <D.33469>:
        D.33471 = &MEM[(void *)"TypeBuilder" + 3B];
        D.33472 = *D.33471;
        D.33473 = (int) D.33472;
        D.33474 = __s2 + 3;
        D.33475 = *D.33474;
        D.33476 = (int) D.33475;
        __result = D.33473 - D.33476;
        <D.33470>:
        <D.33468>:
        <D.33460>:
        <D.33458>:
        <D.33450>:
        <D.33448>:
      }
      D.21267 = __result;
    }
    iftmp.457 = -D.21267;
    goto <D.33477>;
    <D.33441>:
    D.33347 = klass->name;
    iftmp.457 = __builtin_strcmp (D.33347, "TypeBuilder");
    <D.33477>:
    D.21268 = iftmp.457;
  }
  if (D.21268 == 0) goto <D.33478>; else goto <D.33479>;
  <D.33478>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.33480 = tb->table_idx;
    token = D.33480 | 33554432;
  }
  goto <D.33481>;
  <D.33479>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33485 = "MonoType";
      D.33486 = MEM[(const unsigned char *)D.33485];
      D.33487 = (int) D.33486;
      D.33488 = *__s2;
      D.33489 = (int) D.33488;
      __result = D.33487 - D.33489;
      {
        if (__s2_len != 0) goto <D.33490>; else goto <D.33491>;
        <D.33490>:
        if (__result == 0) goto <D.33492>; else goto <D.33493>;
        <D.33492>:
        D.33494 = &MEM[(void *)"MonoType" + 1B];
        D.33495 = *D.33494;
        D.33496 = (int) D.33495;
        D.33497 = __s2 + 1;
        D.33498 = *D.33497;
        D.33499 = (int) D.33498;
        __result = D.33496 - D.33499;
        if (__s2_len > 1) goto <D.33500>; else goto <D.33501>;
        <D.33500>:
        if (__result == 0) goto <D.33502>; else goto <D.33503>;
        <D.33502>:
        D.33504 = &MEM[(void *)"MonoType" + 2B];
        D.33505 = *D.33504;
        D.33506 = (int) D.33505;
        D.33507 = __s2 + 2;
        D.33508 = *D.33507;
        D.33509 = (int) D.33508;
        __result = D.33506 - D.33509;
        if (__s2_len > 2) goto <D.33510>; else goto <D.33511>;
        <D.33510>:
        if (__result == 0) goto <D.33512>; else goto <D.33513>;
        <D.33512>:
        D.33514 = &MEM[(void *)"MonoType" + 3B];
        D.33515 = *D.33514;
        D.33516 = (int) D.33515;
        D.33517 = __s2 + 3;
        D.33518 = *D.33517;
        D.33519 = (int) D.33518;
        __result = D.33516 - D.33519;
        <D.33513>:
        <D.33511>:
        <D.33503>:
        <D.33501>:
        <D.33493>:
        <D.33491>:
      }
      D.21277 = __result;
    }
    iftmp.458 = -D.21277;
    goto <D.33520>;
    <D.33484>:
    D.33347 = klass->name;
    iftmp.458 = __builtin_strcmp (D.33347, "MonoType");
    <D.33520>:
    D.21278 = iftmp.458;
  }
  if (D.21278 == 0) goto <D.33521>; else goto <D.33522>;
  <D.33521>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.33523 = mono_class_init (mc);
    if (D.33523 == 0) goto <D.33524>; else goto <D.33525>;
    <D.33524>:
    D.33526 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.33526);
    <D.33525>:
    token = mc->type_token;
  }
  goto <D.33527>;
  <D.33522>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33534 = "MonoCMethod";
      D.33535 = MEM[(const unsigned char *)D.33534];
      D.33536 = (int) D.33535;
      D.33537 = *__s2;
      D.33538 = (int) D.33537;
      __result = D.33536 - D.33538;
      {
        if (__s2_len != 0) goto <D.33539>; else goto <D.33540>;
        <D.33539>:
        if (__result == 0) goto <D.33541>; else goto <D.33542>;
        <D.33541>:
        D.33543 = &MEM[(void *)"MonoCMethod" + 1B];
        D.33544 = *D.33543;
        D.33545 = (int) D.33544;
        D.33546 = __s2 + 1;
        D.33547 = *D.33546;
        D.33548 = (int) D.33547;
        __result = D.33545 - D.33548;
        if (__s2_len > 1) goto <D.33549>; else goto <D.33550>;
        <D.33549>:
        if (__result == 0) goto <D.33551>; else goto <D.33552>;
        <D.33551>:
        D.33553 = &MEM[(void *)"MonoCMethod" + 2B];
        D.33554 = *D.33553;
        D.33555 = (int) D.33554;
        D.33556 = __s2 + 2;
        D.33557 = *D.33556;
        D.33558 = (int) D.33557;
        __result = D.33555 - D.33558;
        if (__s2_len > 2) goto <D.33559>; else goto <D.33560>;
        <D.33559>:
        if (__result == 0) goto <D.33561>; else goto <D.33562>;
        <D.33561>:
        D.33563 = &MEM[(void *)"MonoCMethod" + 3B];
        D.33564 = *D.33563;
        D.33565 = (int) D.33564;
        D.33566 = __s2 + 3;
        D.33567 = *D.33566;
        D.33568 = (int) D.33567;
        __result = D.33565 - D.33568;
        <D.33562>:
        <D.33560>:
        <D.33552>:
        <D.33550>:
        <D.33542>:
        <D.33540>:
      }
      D.21288 = __result;
    }
    iftmp.459 = -D.21288;
    goto <D.33569>;
    <D.33533>:
    D.33347 = klass->name;
    iftmp.459 = __builtin_strcmp (D.33347, "MonoCMethod");
    <D.33569>:
    D.21289 = iftmp.459;
  }
  if (D.21289 == 0) goto <D.33528>; else goto <D.33570>;
  <D.33570>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33574 = "MonoMethod";
      D.33575 = MEM[(const unsigned char *)D.33574];
      D.33576 = (int) D.33575;
      D.33577 = *__s2;
      D.33578 = (int) D.33577;
      __result = D.33576 - D.33578;
      {
        if (__s2_len != 0) goto <D.33579>; else goto <D.33580>;
        <D.33579>:
        if (__result == 0) goto <D.33581>; else goto <D.33582>;
        <D.33581>:
        D.33583 = &MEM[(void *)"MonoMethod" + 1B];
        D.33584 = *D.33583;
        D.33585 = (int) D.33584;
        D.33586 = __s2 + 1;
        D.33587 = *D.33586;
        D.33588 = (int) D.33587;
        __result = D.33585 - D.33588;
        if (__s2_len > 1) goto <D.33589>; else goto <D.33590>;
        <D.33589>:
        if (__result == 0) goto <D.33591>; else goto <D.33592>;
        <D.33591>:
        D.33593 = &MEM[(void *)"MonoMethod" + 2B];
        D.33594 = *D.33593;
        D.33595 = (int) D.33594;
        D.33596 = __s2 + 2;
        D.33597 = *D.33596;
        D.33598 = (int) D.33597;
        __result = D.33595 - D.33598;
        if (__s2_len > 2) goto <D.33599>; else goto <D.33600>;
        <D.33599>:
        if (__result == 0) goto <D.33601>; else goto <D.33602>;
        <D.33601>:
        D.33603 = &MEM[(void *)"MonoMethod" + 3B];
        D.33604 = *D.33603;
        D.33605 = (int) D.33604;
        D.33606 = __s2 + 3;
        D.33607 = *D.33606;
        D.33608 = (int) D.33607;
        __result = D.33605 - D.33608;
        <D.33602>:
        <D.33600>:
        <D.33592>:
        <D.33590>:
        <D.33582>:
        <D.33580>:
      }
      D.21297 = __result;
    }
    iftmp.460 = -D.21297;
    goto <D.33609>;
    <D.33573>:
    D.33347 = klass->name;
    iftmp.460 = __builtin_strcmp (D.33347, "MonoMethod");
    <D.33609>:
    D.21298 = iftmp.460;
  }
  if (D.21298 == 0) goto <D.33528>; else goto <D.33610>;
  <D.33610>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33614 = "MonoGenericMethod";
      D.33615 = MEM[(const unsigned char *)D.33614];
      D.33616 = (int) D.33615;
      D.33617 = *__s2;
      D.33618 = (int) D.33617;
      __result = D.33616 - D.33618;
      {
        if (__s2_len != 0) goto <D.33619>; else goto <D.33620>;
        <D.33619>:
        if (__result == 0) goto <D.33621>; else goto <D.33622>;
        <D.33621>:
        D.33623 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.33624 = *D.33623;
        D.33625 = (int) D.33624;
        D.33626 = __s2 + 1;
        D.33627 = *D.33626;
        D.33628 = (int) D.33627;
        __result = D.33625 - D.33628;
        if (__s2_len > 1) goto <D.33629>; else goto <D.33630>;
        <D.33629>:
        if (__result == 0) goto <D.33631>; else goto <D.33632>;
        <D.33631>:
        D.33633 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.33634 = *D.33633;
        D.33635 = (int) D.33634;
        D.33636 = __s2 + 2;
        D.33637 = *D.33636;
        D.33638 = (int) D.33637;
        __result = D.33635 - D.33638;
        if (__s2_len > 2) goto <D.33639>; else goto <D.33640>;
        <D.33639>:
        if (__result == 0) goto <D.33641>; else goto <D.33642>;
        <D.33641>:
        D.33643 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.33644 = *D.33643;
        D.33645 = (int) D.33644;
        D.33646 = __s2 + 3;
        D.33647 = *D.33646;
        D.33648 = (int) D.33647;
        __result = D.33645 - D.33648;
        <D.33642>:
        <D.33640>:
        <D.33632>:
        <D.33630>:
        <D.33622>:
        <D.33620>:
      }
      D.21306 = __result;
    }
    iftmp.461 = -D.21306;
    goto <D.33649>;
    <D.33613>:
    D.33347 = klass->name;
    iftmp.461 = __builtin_strcmp (D.33347, "MonoGenericMethod");
    <D.33649>:
    D.21307 = iftmp.461;
  }
  if (D.21307 == 0) goto <D.33528>; else goto <D.33650>;
  <D.33650>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33654 = "MonoGenericCMethod";
      D.33655 = MEM[(const unsigned char *)D.33654];
      D.33656 = (int) D.33655;
      D.33657 = *__s2;
      D.33658 = (int) D.33657;
      __result = D.33656 - D.33658;
      {
        if (__s2_len != 0) goto <D.33659>; else goto <D.33660>;
        <D.33659>:
        if (__result == 0) goto <D.33661>; else goto <D.33662>;
        <D.33661>:
        D.33663 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.33664 = *D.33663;
        D.33665 = (int) D.33664;
        D.33666 = __s2 + 1;
        D.33667 = *D.33666;
        D.33668 = (int) D.33667;
        __result = D.33665 - D.33668;
        if (__s2_len > 1) goto <D.33669>; else goto <D.33670>;
        <D.33669>:
        if (__result == 0) goto <D.33671>; else goto <D.33672>;
        <D.33671>:
        D.33673 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.33674 = *D.33673;
        D.33675 = (int) D.33674;
        D.33676 = __s2 + 2;
        D.33677 = *D.33676;
        D.33678 = (int) D.33677;
        __result = D.33675 - D.33678;
        if (__s2_len > 2) goto <D.33679>; else goto <D.33680>;
        <D.33679>:
        if (__result == 0) goto <D.33681>; else goto <D.33682>;
        <D.33681>:
        D.33683 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.33684 = *D.33683;
        D.33685 = (int) D.33684;
        D.33686 = __s2 + 3;
        D.33687 = *D.33686;
        D.33688 = (int) D.33687;
        __result = D.33685 - D.33688;
        <D.33682>:
        <D.33680>:
        <D.33672>:
        <D.33670>:
        <D.33662>:
        <D.33660>:
      }
      D.21315 = __result;
    }
    iftmp.462 = -D.21315;
    goto <D.33689>;
    <D.33653>:
    D.33347 = klass->name;
    iftmp.462 = __builtin_strcmp (D.33347, "MonoGenericCMethod");
    <D.33689>:
    D.21316 = iftmp.462;
  }
  if (D.21316 == 0) goto <D.33528>; else goto <D.33529>;
  <D.33528>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.33690 = m->method;
    D.33691 = BIT_FIELD_REF <*D.33690, 32, 160>;
    D.33692 = D.33691 & 4096;
    if (D.33692 != 0) goto <D.33693>; else goto <D.33694>;
    <D.33693>:
    {
      struct MonoMethodInflated * inflated;

      inflated = m->method;
      D.33696 = inflated->declaring;
      D.33695 = D.33696->token;
      return D.33695;
    }
    <D.33694>:
    D.33690 = m->method;
    token = D.33690->token;
  }
  goto <D.33530>;
  <D.33529>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33700 = "MonoField";
      D.33701 = MEM[(const unsigned char *)D.33700];
      D.33702 = (int) D.33701;
      D.33703 = *__s2;
      D.33704 = (int) D.33703;
      __result = D.33702 - D.33704;
      {
        if (__s2_len != 0) goto <D.33705>; else goto <D.33706>;
        <D.33705>:
        if (__result == 0) goto <D.33707>; else goto <D.33708>;
        <D.33707>:
        D.33709 = &MEM[(void *)"MonoField" + 1B];
        D.33710 = *D.33709;
        D.33711 = (int) D.33710;
        D.33712 = __s2 + 1;
        D.33713 = *D.33712;
        D.33714 = (int) D.33713;
        __result = D.33711 - D.33714;
        if (__s2_len > 1) goto <D.33715>; else goto <D.33716>;
        <D.33715>:
        if (__result == 0) goto <D.33717>; else goto <D.33718>;
        <D.33717>:
        D.33719 = &MEM[(void *)"MonoField" + 2B];
        D.33720 = *D.33719;
        D.33721 = (int) D.33720;
        D.33722 = __s2 + 2;
        D.33723 = *D.33722;
        D.33724 = (int) D.33723;
        __result = D.33721 - D.33724;
        if (__s2_len > 2) goto <D.33725>; else goto <D.33726>;
        <D.33725>:
        if (__result == 0) goto <D.33727>; else goto <D.33728>;
        <D.33727>:
        D.33729 = &MEM[(void *)"MonoField" + 3B];
        D.33730 = *D.33729;
        D.33731 = (int) D.33730;
        D.33732 = __s2 + 3;
        D.33733 = *D.33732;
        D.33734 = (int) D.33733;
        __result = D.33731 - D.33734;
        <D.33728>:
        <D.33726>:
        <D.33718>:
        <D.33716>:
        <D.33708>:
        <D.33706>:
      }
      D.21326 = __result;
    }
    iftmp.463 = -D.21326;
    goto <D.33735>;
    <D.33699>:
    D.33347 = klass->name;
    iftmp.463 = __builtin_strcmp (D.33347, "MonoField");
    <D.33735>:
    D.21327 = iftmp.463;
  }
  if (D.21327 == 0) goto <D.33736>; else goto <D.33737>;
  <D.33736>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.33738 = f->field;
    D.33739 = is_field_on_inst (D.33738);
    if (D.33739 != 0) goto <D.33740>; else goto <D.33741>;
    <D.33740>:
    {
      struct MonoDynamicGenericClass * dgclass;
      int field_index;
      struct MonoObject * obj;

      D.33738 = f->field;
      D.33742 = D.33738->parent;
      dgclass = D.33742->generic_class;
      D.33738 = f->field;
      D.33743 = (int) D.33738;
      D.33744 = dgclass->fields;
      D.33745 = (int) D.33744;
      D.33746 = D.33743 - D.33745;
      field_index = D.33746 /[ex] 16;
      if (field_index < 0) goto <D.33748>; else goto <D.33751>;
      <D.33751>:
      D.33752 = dgclass->count_fields;
      if (D.33752 <= field_index) goto <D.33748>; else goto <D.33749>;
      <D.33748>:
      iftmp.464 = 1;
      goto <D.33750>;
      <D.33749>:
      iftmp.464 = 0;
      <D.33750>:
      D.33753 = iftmp.464 != 0;
      D.33754 = (long int) D.33753;
      D.33755 = __builtin_expect (D.33754, 0);
      if (D.33755 != 0) goto <D.33756>; else goto <D.33757>;
      <D.33756>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7752, "field_index >= 0 && field_index < dgclass->count_fields");
      <D.33757>:
      D.33758 = dgclass->field_objects;
      field_index.465 = (unsigned int) field_index;
      D.33760 = field_index.465 * 4;
      D.33761 = D.33758 + D.33760;
      obj = *D.33761;
      D.33695 = mono_reflection_get_token (obj);
      return D.33695;
    }
    <D.33741>:
    D.33738 = f->field;
    token = mono_class_get_field_token (D.33738);
  }
  goto <D.33762>;
  <D.33737>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33766 = "MonoProperty";
      D.33767 = MEM[(const unsigned char *)D.33766];
      D.33768 = (int) D.33767;
      D.33769 = *__s2;
      D.33770 = (int) D.33769;
      __result = D.33768 - D.33770;
      {
        if (__s2_len != 0) goto <D.33771>; else goto <D.33772>;
        <D.33771>:
        if (__result == 0) goto <D.33773>; else goto <D.33774>;
        <D.33773>:
        D.33775 = &MEM[(void *)"MonoProperty" + 1B];
        D.33776 = *D.33775;
        D.33777 = (int) D.33776;
        D.33778 = __s2 + 1;
        D.33779 = *D.33778;
        D.33780 = (int) D.33779;
        __result = D.33777 - D.33780;
        if (__s2_len > 1) goto <D.33781>; else goto <D.33782>;
        <D.33781>:
        if (__result == 0) goto <D.33783>; else goto <D.33784>;
        <D.33783>:
        D.33785 = &MEM[(void *)"MonoProperty" + 2B];
        D.33786 = *D.33785;
        D.33787 = (int) D.33786;
        D.33788 = __s2 + 2;
        D.33789 = *D.33788;
        D.33790 = (int) D.33789;
        __result = D.33787 - D.33790;
        if (__s2_len > 2) goto <D.33791>; else goto <D.33792>;
        <D.33791>:
        if (__result == 0) goto <D.33793>; else goto <D.33794>;
        <D.33793>:
        D.33795 = &MEM[(void *)"MonoProperty" + 3B];
        D.33796 = *D.33795;
        D.33797 = (int) D.33796;
        D.33798 = __s2 + 3;
        D.33799 = *D.33798;
        D.33800 = (int) D.33799;
        __result = D.33797 - D.33800;
        <D.33794>:
        <D.33792>:
        <D.33784>:
        <D.33782>:
        <D.33774>:
        <D.33772>:
      }
      D.21339 = __result;
    }
    iftmp.466 = -D.21339;
    goto <D.33801>;
    <D.33765>:
    D.33347 = klass->name;
    iftmp.466 = __builtin_strcmp (D.33347, "MonoProperty");
    <D.33801>:
    D.21340 = iftmp.466;
  }
  if (D.21340 == 0) goto <D.33802>; else goto <D.33803>;
  <D.33802>:
  {
    struct MonoReflectionProperty * p;

    p = obj;
    D.33804 = p->property;
    token = mono_class_get_property_token (D.33804);
  }
  goto <D.33805>;
  <D.33803>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33809 = "MonoEvent";
      D.33810 = MEM[(const unsigned char *)D.33809];
      D.33811 = (int) D.33810;
      D.33812 = *__s2;
      D.33813 = (int) D.33812;
      __result = D.33811 - D.33813;
      {
        if (__s2_len != 0) goto <D.33814>; else goto <D.33815>;
        <D.33814>:
        if (__result == 0) goto <D.33816>; else goto <D.33817>;
        <D.33816>:
        D.33818 = &MEM[(void *)"MonoEvent" + 1B];
        D.33819 = *D.33818;
        D.33820 = (int) D.33819;
        D.33821 = __s2 + 1;
        D.33822 = *D.33821;
        D.33823 = (int) D.33822;
        __result = D.33820 - D.33823;
        if (__s2_len > 1) goto <D.33824>; else goto <D.33825>;
        <D.33824>:
        if (__result == 0) goto <D.33826>; else goto <D.33827>;
        <D.33826>:
        D.33828 = &MEM[(void *)"MonoEvent" + 2B];
        D.33829 = *D.33828;
        D.33830 = (int) D.33829;
        D.33831 = __s2 + 2;
        D.33832 = *D.33831;
        D.33833 = (int) D.33832;
        __result = D.33830 - D.33833;
        if (__s2_len > 2) goto <D.33834>; else goto <D.33835>;
        <D.33834>:
        if (__result == 0) goto <D.33836>; else goto <D.33837>;
        <D.33836>:
        D.33838 = &MEM[(void *)"MonoEvent" + 3B];
        D.33839 = *D.33838;
        D.33840 = (int) D.33839;
        D.33841 = __s2 + 3;
        D.33842 = *D.33841;
        D.33843 = (int) D.33842;
        __result = D.33840 - D.33843;
        <D.33837>:
        <D.33835>:
        <D.33827>:
        <D.33825>:
        <D.33817>:
        <D.33815>:
      }
      D.21349 = __result;
    }
    iftmp.467 = -D.21349;
    goto <D.33844>;
    <D.33808>:
    D.33347 = klass->name;
    iftmp.467 = __builtin_strcmp (D.33347, "MonoEvent");
    <D.33844>:
    D.21350 = iftmp.467;
  }
  if (D.21350 == 0) goto <D.33845>; else goto <D.33846>;
  <D.33845>:
  {
    struct MonoReflectionMonoEvent * p;

    p = obj;
    D.33847 = p->event;
    token = mono_class_get_event_token (D.33847);
  }
  goto <D.33848>;
  <D.33846>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33855 = "ParameterInfo";
      D.33856 = MEM[(const unsigned char *)D.33855];
      D.33857 = (int) D.33856;
      D.33858 = *__s2;
      D.33859 = (int) D.33858;
      __result = D.33857 - D.33859;
      {
        if (__s2_len != 0) goto <D.33860>; else goto <D.33861>;
        <D.33860>:
        if (__result == 0) goto <D.33862>; else goto <D.33863>;
        <D.33862>:
        D.33864 = &MEM[(void *)"ParameterInfo" + 1B];
        D.33865 = *D.33864;
        D.33866 = (int) D.33865;
        D.33867 = __s2 + 1;
        D.33868 = *D.33867;
        D.33869 = (int) D.33868;
        __result = D.33866 - D.33869;
        if (__s2_len > 1) goto <D.33870>; else goto <D.33871>;
        <D.33870>:
        if (__result == 0) goto <D.33872>; else goto <D.33873>;
        <D.33872>:
        D.33874 = &MEM[(void *)"ParameterInfo" + 2B];
        D.33875 = *D.33874;
        D.33876 = (int) D.33875;
        D.33877 = __s2 + 2;
        D.33878 = *D.33877;
        D.33879 = (int) D.33878;
        __result = D.33876 - D.33879;
        if (__s2_len > 2) goto <D.33880>; else goto <D.33881>;
        <D.33880>:
        if (__result == 0) goto <D.33882>; else goto <D.33883>;
        <D.33882>:
        D.33884 = &MEM[(void *)"ParameterInfo" + 3B];
        D.33885 = *D.33884;
        D.33886 = (int) D.33885;
        D.33887 = __s2 + 3;
        D.33888 = *D.33887;
        D.33889 = (int) D.33888;
        __result = D.33886 - D.33889;
        <D.33883>:
        <D.33881>:
        <D.33873>:
        <D.33871>:
        <D.33863>:
        <D.33861>:
      }
      D.21359 = __result;
    }
    iftmp.468 = -D.21359;
    goto <D.33890>;
    <D.33854>:
    D.33347 = klass->name;
    iftmp.468 = __builtin_strcmp (D.33347, "ParameterInfo");
    <D.33890>:
    D.21360 = iftmp.468;
  }
  if (D.21360 == 0) goto <D.33849>; else goto <D.33891>;
  <D.33891>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33895 = "MonoParameterInfo";
      D.33896 = MEM[(const unsigned char *)D.33895];
      D.33897 = (int) D.33896;
      D.33898 = *__s2;
      D.33899 = (int) D.33898;
      __result = D.33897 - D.33899;
      {
        if (__s2_len != 0) goto <D.33900>; else goto <D.33901>;
        <D.33900>:
        if (__result == 0) goto <D.33902>; else goto <D.33903>;
        <D.33902>:
        D.33904 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.33905 = *D.33904;
        D.33906 = (int) D.33905;
        D.33907 = __s2 + 1;
        D.33908 = *D.33907;
        D.33909 = (int) D.33908;
        __result = D.33906 - D.33909;
        if (__s2_len > 1) goto <D.33910>; else goto <D.33911>;
        <D.33910>:
        if (__result == 0) goto <D.33912>; else goto <D.33913>;
        <D.33912>:
        D.33914 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.33915 = *D.33914;
        D.33916 = (int) D.33915;
        D.33917 = __s2 + 2;
        D.33918 = *D.33917;
        D.33919 = (int) D.33918;
        __result = D.33916 - D.33919;
        if (__s2_len > 2) goto <D.33920>; else goto <D.33921>;
        <D.33920>:
        if (__result == 0) goto <D.33922>; else goto <D.33923>;
        <D.33922>:
        D.33924 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.33925 = *D.33924;
        D.33926 = (int) D.33925;
        D.33927 = __s2 + 3;
        D.33928 = *D.33927;
        D.33929 = (int) D.33928;
        __result = D.33926 - D.33929;
        <D.33923>:
        <D.33921>:
        <D.33913>:
        <D.33911>:
        <D.33903>:
        <D.33901>:
      }
      D.21368 = __result;
    }
    iftmp.469 = -D.21368;
    goto <D.33930>;
    <D.33894>:
    D.33347 = klass->name;
    iftmp.469 = __builtin_strcmp (D.33347, "MonoParameterInfo");
    <D.33930>:
    D.21369 = iftmp.469;
  }
  if (D.21369 == 0) goto <D.33849>; else goto <D.33850>;
  <D.33849>:
  {
    struct MonoReflectionParameter * p;
    struct MonoClass * member_class;

    p = obj;
    D.33931 = p->MemberImpl;
    D.33932 = D.33931->vtable;
    member_class = D.33932->klass;
    D.33933 = mono_class_is_reflection_method_or_constructor (member_class);
    D.33934 = D.33933 == 0;
    D.33935 = (long int) D.33934;
    D.33936 = __builtin_expect (D.33935, 0);
    if (D.33936 != 0) goto <D.33937>; else goto <D.33938>;
    <D.33937>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7768, "mono_class_is_reflection_method_or_constructor (member_class)");
    <D.33938>:
    D.33931 = p->MemberImpl;
    D.33939 = MEM[(struct MonoReflectionMethod *)D.33931].method;
    D.33940 = p->PositionImpl;
    token = mono_method_get_param_token (D.33939, D.33940);
  }
  goto <D.33851>;
  <D.33850>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33947 = "Module";
      D.33948 = MEM[(const unsigned char *)D.33947];
      D.33949 = (int) D.33948;
      D.33950 = *__s2;
      D.33951 = (int) D.33950;
      __result = D.33949 - D.33951;
      {
        if (__s2_len != 0) goto <D.33952>; else goto <D.33953>;
        <D.33952>:
        if (__result == 0) goto <D.33954>; else goto <D.33955>;
        <D.33954>:
        D.33956 = &MEM[(void *)"Module" + 1B];
        D.33957 = *D.33956;
        D.33958 = (int) D.33957;
        D.33959 = __s2 + 1;
        D.33960 = *D.33959;
        D.33961 = (int) D.33960;
        __result = D.33958 - D.33961;
        if (__s2_len > 1) goto <D.33962>; else goto <D.33963>;
        <D.33962>:
        if (__result == 0) goto <D.33964>; else goto <D.33965>;
        <D.33964>:
        D.33966 = &MEM[(void *)"Module" + 2B];
        D.33967 = *D.33966;
        D.33968 = (int) D.33967;
        D.33969 = __s2 + 2;
        D.33970 = *D.33969;
        D.33971 = (int) D.33970;
        __result = D.33968 - D.33971;
        if (__s2_len > 2) goto <D.33972>; else goto <D.33973>;
        <D.33972>:
        if (__result == 0) goto <D.33974>; else goto <D.33975>;
        <D.33974>:
        D.33976 = &MEM[(void *)"Module" + 3B];
        D.33977 = *D.33976;
        D.33978 = (int) D.33977;
        D.33979 = __s2 + 3;
        D.33980 = *D.33979;
        D.33981 = (int) D.33980;
        __result = D.33978 - D.33981;
        <D.33975>:
        <D.33973>:
        <D.33965>:
        <D.33963>:
        <D.33955>:
        <D.33953>:
      }
      D.21379 = __result;
    }
    iftmp.470 = -D.21379;
    goto <D.33982>;
    <D.33946>:
    D.33347 = klass->name;
    iftmp.470 = __builtin_strcmp (D.33347, "Module");
    <D.33982>:
    D.21380 = iftmp.470;
  }
  if (D.21380 == 0) goto <D.33941>; else goto <D.33983>;
  <D.33983>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33987 = "MonoModule";
      D.33988 = MEM[(const unsigned char *)D.33987];
      D.33989 = (int) D.33988;
      D.33990 = *__s2;
      D.33991 = (int) D.33990;
      __result = D.33989 - D.33991;
      {
        if (__s2_len != 0) goto <D.33992>; else goto <D.33993>;
        <D.33992>:
        if (__result == 0) goto <D.33994>; else goto <D.33995>;
        <D.33994>:
        D.33996 = &MEM[(void *)"MonoModule" + 1B];
        D.33997 = *D.33996;
        D.33998 = (int) D.33997;
        D.33999 = __s2 + 1;
        D.34000 = *D.33999;
        D.34001 = (int) D.34000;
        __result = D.33998 - D.34001;
        if (__s2_len > 1) goto <D.34002>; else goto <D.34003>;
        <D.34002>:
        if (__result == 0) goto <D.34004>; else goto <D.34005>;
        <D.34004>:
        D.34006 = &MEM[(void *)"MonoModule" + 2B];
        D.34007 = *D.34006;
        D.34008 = (int) D.34007;
        D.34009 = __s2 + 2;
        D.34010 = *D.34009;
        D.34011 = (int) D.34010;
        __result = D.34008 - D.34011;
        if (__s2_len > 2) goto <D.34012>; else goto <D.34013>;
        <D.34012>:
        if (__result == 0) goto <D.34014>; else goto <D.34015>;
        <D.34014>:
        D.34016 = &MEM[(void *)"MonoModule" + 3B];
        D.34017 = *D.34016;
        D.34018 = (int) D.34017;
        D.34019 = __s2 + 3;
        D.34020 = *D.34019;
        D.34021 = (int) D.34020;
        __result = D.34018 - D.34021;
        <D.34015>:
        <D.34013>:
        <D.34005>:
        <D.34003>:
        <D.33995>:
        <D.33993>:
      }
      D.21388 = __result;
    }
    iftmp.471 = -D.21388;
    goto <D.34022>;
    <D.33986>:
    D.33347 = klass->name;
    iftmp.471 = __builtin_strcmp (D.33347, "MonoModule");
    <D.34022>:
    D.21389 = iftmp.471;
  }
  if (D.21389 == 0) goto <D.33941>; else goto <D.33942>;
  <D.33941>:
  {
    struct MonoReflectionModule * m;

    m = obj;
    token = m->token;
  }
  goto <D.33943>;
  <D.33942>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34029 = "Assembly";
      D.34030 = MEM[(const unsigned char *)D.34029];
      D.34031 = (int) D.34030;
      D.34032 = *__s2;
      D.34033 = (int) D.34032;
      __result = D.34031 - D.34033;
      {
        if (__s2_len != 0) goto <D.34034>; else goto <D.34035>;
        <D.34034>:
        if (__result == 0) goto <D.34036>; else goto <D.34037>;
        <D.34036>:
        D.34038 = &MEM[(void *)"Assembly" + 1B];
        D.34039 = *D.34038;
        D.34040 = (int) D.34039;
        D.34041 = __s2 + 1;
        D.34042 = *D.34041;
        D.34043 = (int) D.34042;
        __result = D.34040 - D.34043;
        if (__s2_len > 1) goto <D.34044>; else goto <D.34045>;
        <D.34044>:
        if (__result == 0) goto <D.34046>; else goto <D.34047>;
        <D.34046>:
        D.34048 = &MEM[(void *)"Assembly" + 2B];
        D.34049 = *D.34048;
        D.34050 = (int) D.34049;
        D.34051 = __s2 + 2;
        D.34052 = *D.34051;
        D.34053 = (int) D.34052;
        __result = D.34050 - D.34053;
        if (__s2_len > 2) goto <D.34054>; else goto <D.34055>;
        <D.34054>:
        if (__result == 0) goto <D.34056>; else goto <D.34057>;
        <D.34056>:
        D.34058 = &MEM[(void *)"Assembly" + 3B];
        D.34059 = *D.34058;
        D.34060 = (int) D.34059;
        D.34061 = __s2 + 3;
        D.34062 = *D.34061;
        D.34063 = (int) D.34062;
        __result = D.34060 - D.34063;
        <D.34057>:
        <D.34055>:
        <D.34047>:
        <D.34045>:
        <D.34037>:
        <D.34035>:
      }
      D.21398 = __result;
    }
    iftmp.472 = -D.21398;
    goto <D.34064>;
    <D.34028>:
    D.33347 = klass->name;
    iftmp.472 = __builtin_strcmp (D.33347, "Assembly");
    <D.34064>:
    D.21399 = iftmp.472;
  }
  if (D.21399 == 0) goto <D.34023>; else goto <D.34065>;
  <D.34065>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34069 = "MonoAssembly";
      D.34070 = MEM[(const unsigned char *)D.34069];
      D.34071 = (int) D.34070;
      D.34072 = *__s2;
      D.34073 = (int) D.34072;
      __result = D.34071 - D.34073;
      {
        if (__s2_len != 0) goto <D.34074>; else goto <D.34075>;
        <D.34074>:
        if (__result == 0) goto <D.34076>; else goto <D.34077>;
        <D.34076>:
        D.34078 = &MEM[(void *)"MonoAssembly" + 1B];
        D.34079 = *D.34078;
        D.34080 = (int) D.34079;
        D.34081 = __s2 + 1;
        D.34082 = *D.34081;
        D.34083 = (int) D.34082;
        __result = D.34080 - D.34083;
        if (__s2_len > 1) goto <D.34084>; else goto <D.34085>;
        <D.34084>:
        if (__result == 0) goto <D.34086>; else goto <D.34087>;
        <D.34086>:
        D.34088 = &MEM[(void *)"MonoAssembly" + 2B];
        D.34089 = *D.34088;
        D.34090 = (int) D.34089;
        D.34091 = __s2 + 2;
        D.34092 = *D.34091;
        D.34093 = (int) D.34092;
        __result = D.34090 - D.34093;
        if (__s2_len > 2) goto <D.34094>; else goto <D.34095>;
        <D.34094>:
        if (__result == 0) goto <D.34096>; else goto <D.34097>;
        <D.34096>:
        D.34098 = &MEM[(void *)"MonoAssembly" + 3B];
        D.34099 = *D.34098;
        D.34100 = (int) D.34099;
        D.34101 = __s2 + 3;
        D.34102 = *D.34101;
        D.34103 = (int) D.34102;
        __result = D.34100 - D.34103;
        <D.34097>:
        <D.34095>:
        <D.34087>:
        <D.34085>:
        <D.34077>:
        <D.34075>:
      }
      D.21407 = __result;
    }
    iftmp.473 = -D.21407;
    goto <D.34104>;
    <D.34068>:
    D.33347 = klass->name;
    iftmp.473 = __builtin_strcmp (D.33347, "MonoAssembly");
    <D.34104>:
    D.21408 = iftmp.473;
  }
  if (D.21408 == 0) goto <D.34023>; else goto <D.34024>;
  <D.34023>:
  token = 536870913;
  goto <D.34025>;
  <D.34024>:
  {
    gchar * msg;
    struct MonoException * ex;

    D.34105 = klass->name_space;
    D.33347 = klass->name;
    msg = monoeg_g_strdup_printf ("MetadataToken is not supported for type \'%s.%s\'", D.34105, D.33347);
    ex = mono_get_exception_not_implemented (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34025>:
  <D.33943>:
  <D.33851>:
  <D.33848>:
  <D.33805>:
  <D.33762>:
  <D.33530>:
  <D.33527>:
  <D.33481>:
  <D.33438>:
  <D.33394>:
  <D.33351>:
  D.33695 = token;
  return D.33695;
}


mono_reflection_create_custom_attr_data_args (struct MonoImage * image, struct MonoMethod * method, const guchar * data, guint32 len, struct MonoArray * * typed_args, struct MonoArray * * named_args, struct CattrNamedArg * * named_arg_info, struct MonoError * error)
{
  int D.34107;
  struct MonoClass * D.34110;
  const char * p.474;
  short unsigned int D.34115;
  struct MonoClass * D.34116;
  struct MonoMethodSignature * D.34117;
  short unsigned int D.34118;
  unsigned int D.34119;
  const char * p.475;
  struct MonoMethodSignature * D.34121;
  struct MonoType * D.34122;
  struct MonoObject * iftmp.476;
  struct MonoMethodSignature * D.34124;
  struct MonoType * D.34125;
  int D.34126;
  struct MonoMethodSignature * D.34129;
  struct MonoType * D.34130;
  struct MonoClass * D.34131;
  struct MonoMethodSignature * D.34133;
  struct MonoType * D.34134;
  int D.34135;
  struct MonoMethodSignature * D.34138;
  short unsigned int D.34139;
  unsigned int D.34140;
  const char * named.477;
  short unsigned int D.34142;
  struct MonoClass * D.34143;
  const char * named.478;
  unsigned int D.34145;
  const char * named.479;
  const char * named.480;
  const char * named.481;
  const char * named.482;
  const char * named.483;
  const char * named.484;
  unsigned int D.34156;
  sizetype type_len.485;
  const guchar * D.34158;
  const guchar * D.34159;
  unsigned int type_len.486;
  unsigned int D.34162;
  unsigned int named.487;
  int D.34165;
  unsigned int D.34166;
  unsigned int type_len.488;
  char * D.34168;
  const char * named.489;
  unsigned int D.34170;
  sizetype name_len.490;
  const guchar * D.34172;
  unsigned int name_len.491;
  unsigned int D.34175;
  int D.34177;
  unsigned int D.34178;
  unsigned int name_len.492;
  char * D.34180;
  const char * named.493;
  unsigned int D.34184;
  struct CattrNamedArg * D.34185;
  struct MonoType * D.34186;
  struct MonoObject * iftmp.494;
  int D.34188;
  struct MonoClass * D.34191;
  int D.34193;
  struct MonoType * iftmp.495;
  struct MonoMethod * D.34200;
  struct MonoMethodSignature * D.34203;
  struct MonoMethod * D.34205;
  struct MonoMethodSignature * D.34206;
  struct MonoMethodSignature * D.34207;
  short unsigned int D.34208;
  int D.34209;
  int D.34210;
  struct MonoObject * iftmp.496;
  int D.34212;
  struct MonoClass * D.34215;
  int D.34217;
  struct MonoArray * typedargs;
  struct MonoArray * namedargs;
  struct MonoClass * attrklass;
  struct MonoDomain * domain;
  const char * p;
  const char * named;
  guint32 i;
  guint32 j;
  guint32 num_named;
  struct CattrNamedArg * arginfo;
  void fail = <<< error >>>;

  try
    {
      p = data;
      arginfo = 0B;
      *typed_args = 0B;
      *named_args = 0B;
      *named_arg_info = 0B;
      mono_error_init (error);
      D.34107 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.34107 == 0) goto <D.34108>; else goto <D.34109>;
      <D.34108>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      return;
      <D.34109>:
      D.34110 = method->klass;
      mono_class_init (D.34110);
      domain = mono_domain_get ();
      if (len <= 1) goto <D.34111>; else goto <D.34113>;
      <D.34113>:
      p.474 = p;
      D.34115 = mono_read16 (p.474);
      if (D.34115 != 1) goto <D.34111>; else goto <D.34112>;
      <D.34111>:
      return;
      <D.34112>:
      D.34116 = mono_get_object_class ();
      D.34117 = mono_method_signature (method);
      D.34118 = D.34117->param_count;
      D.34119 = (unsigned int) D.34118;
      typedargs = mono_array_new (domain, D.34116, D.34119);
      p.474 = p;
      p.475 = p.474 + 2;
      p = p.475;
      i = 0;
      goto <D.21671>;
      <D.21670>:
      {
        struct MonoObject * obj;
        void * val;

        D.34121 = mono_method_signature (method);
        D.34122 = D.34121->params[i];
        p.474 = p;
        val = load_cattr_value (image, D.34122, p.474, &p);
        D.34124 = mono_method_signature (method);
        D.34125 = D.34124->params[i];
        D.34126 = type_is_reference (D.34125);
        if (D.34126 == 0) goto <D.34127>; else goto <D.34128>;
        <D.34127>:
        D.34129 = mono_method_signature (method);
        D.34130 = D.34129->params[i];
        D.34131 = mono_class_from_mono_type (D.34130);
        iftmp.476 = mono_value_box (domain, D.34131, val);
        goto <D.34132>;
        <D.34128>:
        iftmp.476 = val;
        <D.34132>:
        obj = iftmp.476;
        {
          void * * __p;

          __p = mono_array_addr_with_size (typedargs, 4, i);
          mono_gc_wbarrier_set_arrayref (typedargs, __p, obj);
        }
        D.34133 = mono_method_signature (method);
        D.34134 = D.34133->params[i];
        D.34135 = type_is_reference (D.34134);
        if (D.34135 == 0) goto <D.34136>; else goto <D.34137>;
        <D.34136>:
        monoeg_g_free (val);
        <D.34137>:
      }
      i = i + 1;
      <D.21671>:
      D.34138 = mono_method_signature (method);
      D.34139 = D.34138->param_count;
      D.34140 = (unsigned int) D.34139;
      if (D.34140 > i) goto <D.21670>; else goto <D.21672>;
      <D.21672>:
      p.474 = p;
      named = p.474;
      named.477 = named;
      D.34142 = mono_read16 (named.477);
      num_named = (guint32) D.34142;
      D.34143 = mono_get_object_class ();
      namedargs = mono_array_new (domain, D.34143, num_named);
      named.477 = named;
      named.478 = named.477 + 2;
      named = named.478;
      attrklass = method->klass;
      D.34145 = num_named * 12;
      arginfo = monoeg_malloc0 (D.34145);
      *named_arg_info = arginfo;
      j = 0;
      goto <D.21690>;
      <D.21689>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.477 = named;
        named.479 = named.477;
        named.480 = named.479 + 1;
        named = named.480;
        named_type = *named.479;
        named.477 = named;
        named.481 = named.477;
        named.482 = named.481 + 1;
        named = named.482;
        data_type = *named.481;
        if (data_type == 29) goto <D.34150>; else goto <D.34151>;
        <D.34150>:
        named.477 = named;
        named.483 = named.477;
        named.484 = named.483 + 1;
        named = named.484;
        data_type = *named.483;
        <D.34151>:
        if (data_type == 85) goto <D.34154>; else goto <D.34155>;
        <D.34154>:
        {
          gint type_len;
          char * type_name;

          named.477 = named;
          D.34156 = mono_metadata_decode_blob_size (named.477, &named);
          type_len = (gint) D.34156;
          named.477 = named;
          type_len.485 = (sizetype) type_len;
          D.34158 = named.477 + type_len.485;
          D.34159 = data + len;
          if (D.34158 > D.34159) goto fail; else goto <D.34160>;
          <D.34160>:
          type_len.486 = (unsigned int) type_len;
          D.34162 = ~type_len.486;
          named.477 = named;
          named.487 = (unsigned int) named.477;
          if (D.34162 < named.487) goto fail; else goto <D.34164>;
          <D.34164>:
          D.34165 = type_len + 1;
          D.34166 = (unsigned int) D.34165;
          type_name = monoeg_malloc (D.34166);
          named.477 = named;
          type_len.488 = (unsigned int) type_len;
          memcpy (type_name, named.477, type_len.488);
          type_len.485 = (sizetype) type_len;
          D.34168 = type_name + type_len.485;
          *D.34168 = 0;
          named.477 = named;
          type_len.485 = (sizetype) type_len;
          named.489 = named.477 + type_len.485;
          named = named.489;
          monoeg_g_free (type_name);
        }
        <D.34155>:
        named.477 = named;
        D.34170 = mono_metadata_decode_blob_size (named.477, &named);
        name_len = (gint) D.34170;
        named.477 = named;
        name_len.490 = (sizetype) name_len;
        D.34172 = named.477 + name_len.490;
        D.34159 = data + len;
        if (D.34172 > D.34159) goto fail; else goto <D.34173>;
        <D.34173>:
        name_len.491 = (unsigned int) name_len;
        D.34175 = ~name_len.491;
        named.477 = named;
        named.487 = (unsigned int) named.477;
        if (D.34175 < named.487) goto fail; else goto <D.34176>;
        <D.34176>:
        D.34177 = name_len + 1;
        D.34178 = (unsigned int) D.34177;
        name = monoeg_malloc (D.34178);
        named.477 = named;
        name_len.492 = (unsigned int) name_len;
        memcpy (name, named.477, name_len.492);
        name_len.490 = (sizetype) name_len;
        D.34180 = name + name_len.490;
        *D.34180 = 0;
        named.477 = named;
        name_len.490 = (sizetype) name_len;
        named.493 = named.477 + name_len.490;
        named = named.493;
        if (named_type == 83) goto <D.34182>; else goto <D.34183>;
        <D.34182>:
        {
          struct MonoObject * obj;
          struct MonoClassField * field;
          void * val;

          field = mono_class_get_field_from_name (attrklass, name);
          D.34184 = j * 12;
          D.34185 = arginfo + D.34184;
          D.34186 = field->type;
          D.34185->type = D.34186;
          D.34184 = j * 12;
          D.34185 = arginfo + D.34184;
          D.34185->field = field;
          D.34186 = field->type;
          named.477 = named;
          val = load_cattr_value (image, D.34186, named.477, &named);
          D.34186 = field->type;
          D.34188 = type_is_reference (D.34186);
          if (D.34188 == 0) goto <D.34189>; else goto <D.34190>;
          <D.34189>:
          D.34186 = field->type;
          D.34191 = mono_class_from_mono_type (D.34186);
          iftmp.494 = mono_value_box (domain, D.34191, val);
          goto <D.34192>;
          <D.34190>:
          iftmp.494 = val;
          <D.34192>:
          obj = iftmp.494;
          {
            void * * __p;

            __p = mono_array_addr_with_size (namedargs, 4, j);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.34186 = field->type;
          D.34193 = type_is_reference (D.34186);
          if (D.34193 == 0) goto <D.34194>; else goto <D.34195>;
          <D.34194>:
          monoeg_g_free (val);
          <D.34195>:
        }
        goto <D.34196>;
        <D.34183>:
        if (named_type == 84) goto <D.34197>; else goto <D.34198>;
        <D.34197>:
        {
          struct MonoObject * obj;
          struct MonoType * prop_type;
          struct MonoProperty * prop;
          void * val;

          prop = mono_class_get_property_from_name (attrklass, name);
          D.34200 = prop->get;
          if (D.34200 != 0B) goto <D.34201>; else goto <D.34202>;
          <D.34201>:
          D.34200 = prop->get;
          D.34203 = mono_method_signature (D.34200);
          iftmp.495 = D.34203->ret;
          goto <D.34204>;
          <D.34202>:
          D.34205 = prop->set;
          D.34206 = mono_method_signature (D.34205);
          D.34205 = prop->set;
          D.34207 = mono_method_signature (D.34205);
          D.34208 = D.34207->param_count;
          D.34209 = (int) D.34208;
          D.34210 = D.34209 + -1;
          iftmp.495 = D.34206->params[D.34210];
          <D.34204>:
          prop_type = iftmp.495;
          D.34184 = j * 12;
          D.34185 = arginfo + D.34184;
          D.34185->type = prop_type;
          D.34184 = j * 12;
          D.34185 = arginfo + D.34184;
          D.34185->prop = prop;
          named.477 = named;
          val = load_cattr_value (image, prop_type, named.477, &named);
          D.34212 = type_is_reference (prop_type);
          if (D.34212 == 0) goto <D.34213>; else goto <D.34214>;
          <D.34213>:
          D.34215 = mono_class_from_mono_type (prop_type);
          iftmp.496 = mono_value_box (domain, D.34215, val);
          goto <D.34216>;
          <D.34214>:
          iftmp.496 = val;
          <D.34216>:
          obj = iftmp.496;
          {
            void * * __p;

            __p = mono_array_addr_with_size (namedargs, 4, j);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.34217 = type_is_reference (prop_type);
          if (D.34217 == 0) goto <D.34218>; else goto <D.34219>;
          <D.34218>:
          monoeg_g_free (val);
          <D.34219>:
        }
        <D.34198>:
        <D.34196>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.21690>:
      if (j < num_named) goto <D.21689>; else goto <D.21691>;
      <D.21691>:
      *typed_args = typedargs;
      *named_args = namedargs;
      return;
      fail:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      monoeg_g_free (arginfo);
      *named_arg_info = 0B;
    }
  finally
    {
      p = {CLOBBER};
      named = {CLOBBER};
    }
}


load_cattr_value (struct MonoImage * image, struct MonoType * t, const char * p, const char * * end)
{
  unsigned char D.34223;
  const char * p.497;
  char D.34225;
  unsigned char D.34226;
  const char * p.504;
  void * D.34228;
  short unsigned int D.34229;
  const char * p.511;
  unsigned int D.34231;
  const char * p.508;
  long long unsigned int D.34233;
  const char * p.514;
  long long unsigned int D.34235;
  double D.34236;
  struct MonoClass * D.34237;
  unsigned int D.34238;
  unsigned int D.34239;
  struct MonoType * D.34242;
  unsigned char D.34243;
  struct MonoImage * D.34244;
  int D.34245;
  int D.21460;
  int iftmp.498;
  int D.21459;
  const char[7] * D.34251;
  unsigned char D.34252;
  int D.34253;
  unsigned char D.34254;
  int D.34255;
  const unsigned char * D.34260;
  unsigned char D.34261;
  int D.34262;
  const unsigned char * D.34263;
  unsigned char D.34264;
  int D.34265;
  const unsigned char * D.34270;
  unsigned char D.34271;
  int D.34272;
  const unsigned char * D.34273;
  unsigned char D.34274;
  int D.34275;
  const unsigned char * D.34280;
  unsigned char D.34281;
  int D.34282;
  const unsigned char * D.34283;
  unsigned char D.34284;
  int D.34285;
  const char * D.34287;
  int D.21469;
  int iftmp.499;
  int D.21468;
  const char[9] * D.34293;
  unsigned char D.34294;
  int D.34295;
  unsigned char D.34296;
  int D.34297;
  const unsigned char * D.34302;
  unsigned char D.34303;
  int D.34304;
  const unsigned char * D.34305;
  unsigned char D.34306;
  int D.34307;
  const unsigned char * D.34312;
  unsigned char D.34313;
  int D.34314;
  const unsigned char * D.34315;
  unsigned char D.34316;
  int D.34317;
  const unsigned char * D.34322;
  unsigned char D.34323;
  int D.34324;
  const unsigned char * D.34325;
  unsigned char D.34326;
  int D.34327;
  const char * D.34329;
  long long unsigned int D.34332;
  const char * D.34333;
  unsigned int D.34336;
  sizetype slen.500;
  const char * p.505;
  struct MonoDomain * D.34339;
  unsigned int slen.501;
  unsigned int D.34343;
  int D.34344;
  unsigned int D.34345;
  char * D.34346;
  struct MonoDomain * D.34351;
  const char * p.502;
  const char * p.503;
  unsigned char D.34367;
  unsigned int D.34370;
  char * D.34371;
  unsigned char subt.506;
  unsigned char D.34376;
  unsigned char subt.507;
  int D.34381;
  struct MonoType * D.34382;
  struct MonoDomain * D.34383;
  unsigned int D.34384;
  unsigned int D.34385;
  _Bool D.34386;
  long int D.34387;
  long int D.34388;
  void * D.34391;
  int D.34392;
  unsigned int D.34393;
  struct MonoDomain * D.34396;
  unsigned char D.34397;
  unsigned int D.34400;
  unsigned int D.34401;
  struct MonoType * D.34404;
  unsigned char D.34405;
  const char * p.509;
  const char * p.510;
  char D.34408;
  long long unsigned int D.34409;
  double val.512;
  double val.513;
  struct MonoType * D.34412;
  int slen;
  int type;
  struct MonoClass * tklass;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  D.34223 = t->type;
  type = (int) D.34223;
  tklass = t->data.klass;
  handle_enum:
  switch (type) <default: <D.21543>, case 2: <D.21432>, case 3: <D.21434>, case 4: <D.21431>, case 5: <D.21430>, case 6: <D.21436>, case 7: <D.21435>, case 8: <D.21442>, case 9: <D.21441>, case 10: <D.21445>, case 11: <D.21444>, case 12: <D.21440>, case 13: <D.21447>, case 14: <D.21472>, case 17: <D.21450>, case 18: <D.21473>, case 24: <D.21439>, case 25: <D.21438>, case 28: <D.21477>, case 29: <D.21489>>
  <D.21430>:
  <D.21431>:
  <D.21432>:
  {
    MonoBoolean * bval;

    bval = monoeg_malloc (1);
    p.497 = p;
    D.34225 = *p.497;
    D.34226 = (unsigned char) D.34225;
    *bval = D.34226;
    p.497 = p;
    p.504 = p.497 + 1;
    *end = p.504;
    D.34228 = bval;
    return D.34228;
  }
  <D.21434>:
  <D.21435>:
  <D.21436>:
  {
    guint16 * val;

    val = monoeg_malloc (2);
    p.497 = p;
    D.34229 = mono_read16 (p.497);
    *val = D.34229;
    p.497 = p;
    p.511 = p.497 + 2;
    *end = p.511;
    D.34228 = val;
    return D.34228;
  }
  <D.21438>:
  <D.21439>:
  <D.21440>:
  <D.21441>:
  <D.21442>:
  {
    guint32 * val;

    val = monoeg_malloc (4);
    p.497 = p;
    D.34231 = mono_read32 (p.497);
    *val = D.34231;
    p.497 = p;
    p.508 = p.497 + 4;
    *end = p.508;
    D.34228 = val;
    return D.34228;
  }
  <D.21444>:
  <D.21445>:
  {
    guint64 * val;

    val = monoeg_malloc (8);
    p.497 = p;
    D.34233 = mono_read64 (p.497);
    *val = D.34233;
    p.497 = p;
    p.514 = p.497 + 8;
    *end = p.514;
    D.34228 = val;
    return D.34228;
  }
  <D.21447>:
  {
    double * val;

    val = monoeg_malloc (8);
    {
      union mono_rdouble mf;

      try
        {
          p.497 = p;
          D.34235 = mono_read64 (p.497);
          mf.ival = D.34235;
          D.34236 = mf.fval;
          *val = D.34236;
        }
      finally
        {
          mf = {CLOBBER};
        }
    }
    p.497 = p;
    p.514 = p.497 + 8;
    *end = p.514;
    D.34228 = val;
    return D.34228;
  }
  <D.21450>:
  D.34237 = t->data.klass;
  D.34238 = BIT_FIELD_REF <*D.34237, 32, 160>;
  D.34239 = D.34238 & 16;
  if (D.34239 != 0) goto <D.34240>; else goto <D.34241>;
  <D.34240>:
  D.34237 = t->data.klass;
  D.34242 = mono_class_enum_basetype (D.34237);
  D.34243 = D.34242->type;
  type = (int) D.34243;
  goto handle_enum;
  <D.34241>:
  {
    struct MonoClass * k;

    k = t->data.klass;
    D.34244 = k->image;
    D.34245 = mono_is_corlib_image (D.34244);
    if (D.34245 != 0) goto <D.34246>; else goto <D.34247>;
    <D.34246>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name_space;
        D.34251 = "System";
        D.34252 = MEM[(const unsigned char *)D.34251];
        D.34253 = (int) D.34252;
        D.34254 = *__s2;
        D.34255 = (int) D.34254;
        __result = D.34253 - D.34255;
        {
          if (__s2_len != 0) goto <D.34256>; else goto <D.34257>;
          <D.34256>:
          if (__result == 0) goto <D.34258>; else goto <D.34259>;
          <D.34258>:
          D.34260 = &MEM[(void *)"System" + 1B];
          D.34261 = *D.34260;
          D.34262 = (int) D.34261;
          D.34263 = __s2 + 1;
          D.34264 = *D.34263;
          D.34265 = (int) D.34264;
          __result = D.34262 - D.34265;
          if (__s2_len > 1) goto <D.34266>; else goto <D.34267>;
          <D.34266>:
          if (__result == 0) goto <D.34268>; else goto <D.34269>;
          <D.34268>:
          D.34270 = &MEM[(void *)"System" + 2B];
          D.34271 = *D.34270;
          D.34272 = (int) D.34271;
          D.34273 = __s2 + 2;
          D.34274 = *D.34273;
          D.34275 = (int) D.34274;
          __result = D.34272 - D.34275;
          if (__s2_len > 2) goto <D.34276>; else goto <D.34277>;
          <D.34276>:
          if (__result == 0) goto <D.34278>; else goto <D.34279>;
          <D.34278>:
          D.34280 = &MEM[(void *)"System" + 3B];
          D.34281 = *D.34280;
          D.34282 = (int) D.34281;
          D.34283 = __s2 + 3;
          D.34284 = *D.34283;
          D.34285 = (int) D.34284;
          __result = D.34282 - D.34285;
          <D.34279>:
          <D.34277>:
          <D.34269>:
          <D.34267>:
          <D.34259>:
          <D.34257>:
        }
        D.21459 = __result;
      }
      iftmp.498 = -D.21459;
      goto <D.34286>;
      <D.34250>:
      D.34287 = k->name_space;
      iftmp.498 = __builtin_strcmp (D.34287, "System");
      <D.34286>:
      D.21460 = iftmp.498;
    }
    if (D.21460 == 0) goto <D.34288>; else goto <D.34289>;
    <D.34288>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name;
        D.34293 = "DateTime";
        D.34294 = MEM[(const unsigned char *)D.34293];
        D.34295 = (int) D.34294;
        D.34296 = *__s2;
        D.34297 = (int) D.34296;
        __result = D.34295 - D.34297;
        {
          if (__s2_len != 0) goto <D.34298>; else goto <D.34299>;
          <D.34298>:
          if (__result == 0) goto <D.34300>; else goto <D.34301>;
          <D.34300>:
          D.34302 = &MEM[(void *)"DateTime" + 1B];
          D.34303 = *D.34302;
          D.34304 = (int) D.34303;
          D.34305 = __s2 + 1;
          D.34306 = *D.34305;
          D.34307 = (int) D.34306;
          __result = D.34304 - D.34307;
          if (__s2_len > 1) goto <D.34308>; else goto <D.34309>;
          <D.34308>:
          if (__result == 0) goto <D.34310>; else goto <D.34311>;
          <D.34310>:
          D.34312 = &MEM[(void *)"DateTime" + 2B];
          D.34313 = *D.34312;
          D.34314 = (int) D.34313;
          D.34315 = __s2 + 2;
          D.34316 = *D.34315;
          D.34317 = (int) D.34316;
          __result = D.34314 - D.34317;
          if (__s2_len > 2) goto <D.34318>; else goto <D.34319>;
          <D.34318>:
          if (__result == 0) goto <D.34320>; else goto <D.34321>;
          <D.34320>:
          D.34322 = &MEM[(void *)"DateTime" + 3B];
          D.34323 = *D.34322;
          D.34324 = (int) D.34323;
          D.34325 = __s2 + 3;
          D.34326 = *D.34325;
          D.34327 = (int) D.34326;
          __result = D.34324 - D.34327;
          <D.34321>:
          <D.34319>:
          <D.34311>:
          <D.34309>:
          <D.34301>:
          <D.34299>:
        }
        D.21468 = __result;
      }
      iftmp.499 = -D.21468;
      goto <D.34328>;
      <D.34292>:
      D.34329 = k->name;
      iftmp.499 = __builtin_strcmp (D.34329, "DateTime");
      <D.34328>:
      D.21469 = iftmp.499;
    }
    if (D.21469 == 0) goto <D.34330>; else goto <D.34331>;
    <D.34330>:
    {
      guint64 * val;

      val = monoeg_malloc (8);
      p.497 = p;
      D.34332 = mono_read64 (p.497);
      *val = D.34332;
      p.497 = p;
      p.514 = p.497 + 8;
      *end = p.514;
      D.34228 = val;
      return D.34228;
    }
    <D.34331>:
    <D.34289>:
    <D.34247>:
  }
  D.34237 = t->data.klass;
  D.34333 = D.34237->name;
  monoeg_g_log (0B, 4, "generic valutype %s not handled in custom attr value decoding", D.34333);
  <D.21471>:
  goto <D.21471>;
  <D.21472>:
  p.497 = p;
  D.34225 = *p.497;
  if (D.34225 == -1) goto <D.34334>; else goto <D.34335>;
  <D.34334>:
  p.497 = p;
  p.504 = p.497 + 1;
  *end = p.504;
  D.34228 = 0B;
  return D.34228;
  <D.34335>:
  p.497 = p;
  D.34336 = mono_metadata_decode_value (p.497, &p);
  slen = (int) D.34336;
  p.497 = p;
  slen.500 = (sizetype) slen;
  p.505 = p.497 + slen.500;
  *end = p.505;
  D.34339 = mono_domain_get ();
  p.497 = p;
  slen.501 = (unsigned int) slen;
  D.34228 = mono_string_new_len (D.34339, p.497, slen.501);
  return D.34228;
  <D.21473>:
  {
    char * n;
    struct MonoType * t;

    p.497 = p;
    D.34225 = *p.497;
    if (D.34225 == -1) goto <D.34341>; else goto <D.34342>;
    <D.34341>:
    p.497 = p;
    p.504 = p.497 + 1;
    *end = p.504;
    D.34228 = 0B;
    return D.34228;
    <D.34342>:
    handle_type:
    p.497 = p;
    D.34343 = mono_metadata_decode_value (p.497, &p);
    slen = (int) D.34343;
    p.497 = p;
    D.34344 = slen + 1;
    D.34345 = (unsigned int) D.34344;
    n = monoeg_g_memdup (p.497, D.34345);
    slen.500 = (sizetype) slen;
    D.34346 = n + slen.500;
    *D.34346 = 0;
    t = mono_reflection_type_from_name (n, image);
    if (t == 0B) goto <D.34347>; else goto <D.34348>;
    <D.34347>:
    monoeg_g_log (0B, 16, "Cannot load type \'%s\'", n);
    <D.34348>:
    monoeg_g_free (n);
    p.497 = p;
    slen.500 = (sizetype) slen;
    p.505 = p.497 + slen.500;
    *end = p.505;
    if (t != 0B) goto <D.34349>; else goto <D.34350>;
    <D.34349>:
    D.34351 = mono_domain_get ();
    D.34228 = mono_type_get_object (D.34351, t);
    return D.34228;
    <D.34350>:
    D.34228 = 0B;
    return D.34228;
  }
  <D.21477>:
  {
    char subt;
    struct MonoObject * obj;
    struct MonoClass * subc;
    void * val;

    p.497 = p;
    p.502 = p.497;
    p.503 = p.502 + 1;
    p = p.503;
    subt = *p.502;
    subc = 0B;
    if (subt == 80) goto handle_type; else goto <D.34354>;
    <D.34354>:
    if (subt == 14) goto <D.34355>; else goto <D.34356>;
    <D.34355>:
    type = 14;
    goto handle_enum;
    <D.34356>:
    if (subt == 29) goto <D.34357>; else goto <D.34358>;
    <D.34357>:
    {
      struct MonoType simple_type;
      int etype;

      try
        {
          simple_type = {};
          p.497 = p;
          D.34225 = *p.497;
          etype = (int) D.34225;
          p.497 = p;
          p.504 = p.497 + 1;
          p = p.504;
          type = 29;
          if (etype == 80) goto <D.34359>; else goto <D.34360>;
          <D.34359>:
          tklass = mono_defaults.systemtype_class;
          goto <D.34361>;
          <D.34360>:
          if (etype == 85) goto <D.34362>; else goto <D.34363>;
          <D.34362>:
          p.497 = p;
          tklass = load_cattr_enum_type (image, p.497, &p);
          goto <D.34364>;
          <D.34363>:
          if (etype == 81) goto <D.34365>; else goto <D.34366>;
          <D.34365>:
          etype = 28;
          <D.34366>:
          D.34367 = (unsigned char) etype;
          simple_type.type = D.34367;
          tklass = mono_class_from_mono_type (&simple_type);
          <D.34364>:
          <D.34361>:
          goto handle_enum;
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    <D.34358>:
    if (subt == 85) goto <D.34368>; else goto <D.34369>;
    <D.34368>:
    {
      char * n;
      struct MonoType * t;

      p.497 = p;
      D.34370 = mono_metadata_decode_value (p.497, &p);
      slen = (int) D.34370;
      p.497 = p;
      D.34344 = slen + 1;
      D.34345 = (unsigned int) D.34344;
      n = monoeg_g_memdup (p.497, D.34345);
      slen.500 = (sizetype) slen;
      D.34371 = n + slen.500;
      *D.34371 = 0;
      t = mono_reflection_type_from_name (n, image);
      if (t == 0B) goto <D.34372>; else goto <D.34373>;
      <D.34372>:
      monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
      <D.21486>:
      goto <D.21486>;
      <D.34373>:
      monoeg_g_free (n);
      p.497 = p;
      slen.500 = (sizetype) slen;
      p.505 = p.497 + slen.500;
      p = p.505;
      subc = mono_class_from_mono_type (t);
    }
    goto <D.34374>;
    <D.34369>:
    subt.506 = (unsigned char) subt;
    D.34376 = subt.506 + 254;
    if (D.34376 <= 11) goto <D.34377>; else goto <D.34378>;
    <D.34377>:
    {
      struct MonoType simple_type;

      try
        {
          simple_type = {};
          subt.507 = (unsigned char) subt;
          simple_type.type = subt.507;
          subc = mono_class_from_mono_type (&simple_type);
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    goto <D.34380>;
    <D.34378>:
    D.34381 = (int) subt;
    monoeg_g_log (0B, 4, "Unknown type 0x%02x for object type encoding in custom attr", D.34381);
    <D.21488>:
    goto <D.21488>;
    <D.34380>:
    <D.34374>:
    D.34382 = &subc->byval_arg;
    p.497 = p;
    val = load_cattr_value (image, D.34382, p.497, end);
    D.34383 = mono_domain_get ();
    obj = mono_object_new (D.34383, subc);
    D.34384 = BIT_FIELD_REF <*subc, 32, 160>;
    D.34385 = D.34384 & 134217728;
    D.34386 = D.34385 != 0;
    D.34387 = (long int) D.34386;
    D.34388 = __builtin_expect (D.34387, 0);
    if (D.34388 != 0) goto <D.34389>; else goto <D.34390>;
    <D.34389>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7953, "!subc->has_references");
    <D.34390>:
    D.34391 = obj + 8;
    D.34392 = mono_class_value_size (subc, 0B);
    D.34393 = (unsigned int) D.34392;
    mono_gc_memmove_atomic (D.34391, val, D.34393);
    monoeg_g_free (val);
    D.34228 = obj;
    return D.34228;
  }
  <D.21489>:
  {
    struct MonoArray * arr;
    guint32 i;
    guint32 alen;
    guint32 basetype;

    p.497 = p;
    alen = mono_read32 (p.497);
    p.497 = p;
    p.508 = p.497 + 4;
    p = p.508;
    if (alen == 4294967295) goto <D.34394>; else goto <D.34395>;
    <D.34394>:
    p.497 = p;
    *end = p.497;
    D.34228 = 0B;
    return D.34228;
    <D.34395>:
    D.34396 = mono_domain_get ();
    arr = mono_array_new (D.34396, tklass, alen);
    D.34397 = tklass->byval_arg.type;
    basetype = (guint32) D.34397;
    if (basetype == 17) goto <D.34398>; else goto <D.34399>;
    <D.34398>:
    D.34400 = BIT_FIELD_REF <*tklass, 32, 160>;
    D.34401 = D.34400 & 16;
    if (D.34401 != 0) goto <D.34402>; else goto <D.34403>;
    <D.34402>:
    D.34404 = mono_class_enum_basetype (tklass);
    D.34405 = D.34404->type;
    basetype = (guint32) D.34405;
    <D.34403>:
    <D.34399>:
    switch (basetype) <default: <D.21541>, case 2: <D.21496>, case 3: <D.21503>, case 4: <D.21495>, case 5: <D.21494>, case 6: <D.21505>, case 7: <D.21504>, case 8: <D.21513>, case 9: <D.21512>, case 10: <D.21527>, case 11: <D.21526>, case 12: <D.21511>, case 13: <D.21519>, case 14: <D.21535>, case 18: <D.21533>, case 28: <D.21534>>
    <D.21494>:
    <D.21495>:
    <D.21496>:
    i = 0;
    goto <D.21500>;
    <D.21499>:
    {
      MonoBoolean val;

      p.497 = p;
      p.509 = p.497;
      p.510 = p.509 + 1;
      p = p.510;
      D.34408 = *p.509;
      val = (MonoBoolean) D.34408;
      {
        MonoBoolean * __p;

        __p = mono_array_addr_with_size (arr, 1, i);
        *__p = val;
      }
    }
    i = i + 1;
    <D.21500>:
    if (i < alen) goto <D.21499>; else goto <D.21501>;
    <D.21501>:
    goto <D.21502>;
    <D.21503>:
    <D.21504>:
    <D.21505>:
    i = 0;
    goto <D.21509>;
    <D.21508>:
    {
      guint16 val;

      p.497 = p;
      val = mono_read16 (p.497);
      {
        guint16 * __p;

        __p = mono_array_addr_with_size (arr, 2, i);
        *__p = val;
      }
      p.497 = p;
      p.511 = p.497 + 2;
      p = p.511;
    }
    i = i + 1;
    <D.21509>:
    if (i < alen) goto <D.21508>; else goto <D.21510>;
    <D.21510>:
    goto <D.21502>;
    <D.21511>:
    <D.21512>:
    <D.21513>:
    i = 0;
    goto <D.21517>;
    <D.21516>:
    {
      guint32 val;

      p.497 = p;
      val = mono_read32 (p.497);
      {
        guint32 * __p;

        __p = mono_array_addr_with_size (arr, 4, i);
        *__p = val;
      }
      p.497 = p;
      p.508 = p.497 + 4;
      p = p.508;
    }
    i = i + 1;
    <D.21517>:
    if (i < alen) goto <D.21516>; else goto <D.21518>;
    <D.21518>:
    goto <D.21502>;
    <D.21519>:
    i = 0;
    goto <D.21524>;
    <D.21523>:
    {
      double val;

      try
        {
          {
            union mono_rdouble mf;

            try
              {
                p.497 = p;
                D.34409 = mono_read64 (p.497);
                mf.ival = D.34409;
                val.512 = mf.fval;
                val = val.512;
              }
            finally
              {
                mf = {CLOBBER};
              }
          }
          {
            double * __p;

            __p = mono_array_addr_with_size (arr, 8, i);
            val.513 = val;
            *__p = val.513;
          }
          p.497 = p;
          p.514 = p.497 + 8;
          p = p.514;
        }
      finally
        {
          val = {CLOBBER};
        }
    }
    i = i + 1;
    <D.21524>:
    if (i < alen) goto <D.21523>; else goto <D.21525>;
    <D.21525>:
    goto <D.21502>;
    <D.21526>:
    <D.21527>:
    i = 0;
    goto <D.21531>;
    <D.21530>:
    {
      guint64 val;

      p.497 = p;
      val = mono_read64 (p.497);
      {
        guint64 * __p;

        __p = mono_array_addr_with_size (arr, 8, i);
        *__p = val;
      }
      p.497 = p;
      p.514 = p.497 + 8;
      p = p.514;
    }
    i = i + 1;
    <D.21531>:
    if (i < alen) goto <D.21530>; else goto <D.21532>;
    <D.21532>:
    goto <D.21502>;
    <D.21533>:
    <D.21534>:
    <D.21535>:
    i = 0;
    goto <D.21539>;
    <D.21538>:
    {
      struct MonoObject * item;

      D.34412 = &tklass->byval_arg;
      p.497 = p;
      item = load_cattr_value (image, D.34412, p.497, &p);
      {
        void * * __p;

        __p = mono_array_addr_with_size (arr, 4, i);
        mono_gc_wbarrier_set_arrayref (arr, __p, item);
      }
    }
    i = i + 1;
    <D.21539>:
    if (i < alen) goto <D.21538>; else goto <D.21540>;
    <D.21540>:
    goto <D.21502>;
    <D.21541>:
    monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr array decoding", basetype);
    <D.21542>:
    goto <D.21542>;
    <D.21502>:
    p.497 = p;
    *end = p.497;
    D.34228 = arr;
    return D.34228;
  }
  <D.21543>:
  monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr value decoding", type);
  <D.21544>:
  goto <D.21544>;
  D.34228 = 0B;
  return D.34228;
}


load_cattr_enum_type (struct MonoImage * image, const char * p, const char * * end)
{
  const char * p.515;
  unsigned int D.34416;
  int D.34417;
  unsigned int D.34418;
  sizetype slen.516;
  char * D.34420;
  const char * p.517;
  struct MonoClass * D.34424;
  char * n;
  struct MonoType * t;
  int slen;

  p.515 = p;
  D.34416 = mono_metadata_decode_value (p.515, &p);
  slen = (int) D.34416;
  p.515 = p;
  D.34417 = slen + 1;
  D.34418 = (unsigned int) D.34417;
  n = monoeg_g_memdup (p.515, D.34418);
  slen.516 = (sizetype) slen;
  D.34420 = n + slen.516;
  *D.34420 = 0;
  t = mono_reflection_type_from_name (n, image);
  if (t == 0B) goto <D.34421>; else goto <D.34422>;
  <D.34421>:
  monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
  <D.21419>:
  goto <D.21419>;
  <D.34422>:
  monoeg_g_free (n);
  p.515 = p;
  slen.516 = (sizetype) slen;
  p.517 = p.515 + slen.516;
  p = p.517;
  p.515 = p;
  *end = p.515;
  D.34424 = mono_class_from_mono_type (t);
  return D.34424;
}


type_is_reference (struct MonoType * type)
{
  unsigned char D.34426;
  int D.34427;
  gboolean D.34428;

  D.34426 = type->type;
  D.34427 = (int) D.34426;
  switch (D.34427) <default: <D.21581>, case 2: <D.21566>, case 3: <D.21567>, case 4: <D.21571>, case 5: <D.21570>, case 6: <D.21573>, case 7: <D.21572>, case 8: <D.21575>, case 9: <D.21574>, case 10: <D.21577>, case 11: <D.21576>, case 12: <D.21579>, case 13: <D.21578>, case 17: <D.21580>, case 24: <D.21569>, case 25: <D.21568>>
  <D.21566>:
  <D.21567>:
  <D.21568>:
  <D.21569>:
  <D.21570>:
  <D.21571>:
  <D.21572>:
  <D.21573>:
  <D.21574>:
  <D.21575>:
  <D.21576>:
  <D.21577>:
  <D.21578>:
  <D.21579>:
  <D.21580>:
  D.34428 = 0;
  return D.34428;
  <D.21581>:
  D.34428 = 1;
  return D.34428;
}


mono_reflection_resolve_custom_attribute_data (struct MonoReflectionMethod * ref_method, struct MonoReflectionAssembly * assembly, void * data, guint32 len, struct MonoArray * * ctor_args, struct MonoArray * * named_args)
{
  struct MonoAssembly * D.34432;
  struct MonoVTable * D.34433;
  struct MonoClass * D.34434;
  int D.34435;
  struct MonoException * D.34438;
  int D.34439;
  struct MonoLoaderError * D.34442;
  struct MonoLoaderError * D.34445;
  struct MonoException * D.34446;
  struct MonoArray * typedargs.518;
  struct MonoArray * namedargs.519;
  struct CattrNamedArg * arginfo.520;
  unsigned int i.521;
  char * D.34454;
  struct MonoMethodSignature * D.34455;
  struct MonoType * D.34456;
  struct MonoMethodSignature * D.34457;
  short unsigned int D.34458;
  int D.34459;
  char * D.34460;
  unsigned int i.522;
  unsigned int D.34462;
  struct CattrNamedArg * D.34463;
  struct MonoProperty * D.34464;
  struct MonoClassField * D.34468;
  struct MonoType * D.34469;
  unsigned int D.34470;
  struct MonoDomain * domain;
  struct MonoArray * typedargs;
  struct MonoArray * namedargs;
  struct MonoImage * image;
  struct MonoMethod * method;
  struct CattrNamedArg * arginfo;
  struct MonoError error;
  int i;

  try
    {
      arginfo = 0B;
      *ctor_args = 0B;
      *named_args = 0B;
      if (len == 0) goto <D.34430>; else goto <D.34431>;
      <D.34430>:
      return;
      <D.34431>:
      D.34432 = assembly->assembly;
      image = D.34432->image;
      method = ref_method->method;
      D.34433 = MEM[(struct MonoObject *)ref_method].vtable;
      domain = D.34433->domain;
      D.34434 = method->klass;
      D.34435 = mono_class_init (D.34434);
      if (D.34435 == 0) goto <D.34436>; else goto <D.34437>;
      <D.34436>:
      D.34434 = method->klass;
      D.34438 = mono_class_get_exception_for_failure (D.34434);
      mono_raise_exception (D.34438);
      <D.34437>:
      mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
      D.34439 = mono_error_ok (&error);
      if (D.34439 == 0) goto <D.34440>; else goto <D.34441>;
      <D.34440>:
      mono_error_raise_exception (&error);
      <D.34441>:
      D.34442 = mono_loader_get_last_error ();
      if (D.34442 != 0B) goto <D.34443>; else goto <D.34444>;
      <D.34443>:
      D.34445 = mono_loader_get_last_error ();
      D.34446 = mono_loader_error_prepare_exception (D.34445);
      mono_raise_exception (D.34446);
      <D.34444>:
      typedargs.518 = typedargs;
      if (typedargs.518 == 0B) goto <D.34447>; else goto <D.34450>;
      <D.34450>:
      namedargs.519 = namedargs;
      if (namedargs.519 == 0B) goto <D.34447>; else goto <D.34448>;
      <D.34447>:
      arginfo.520 = arginfo;
      monoeg_g_free (arginfo.520);
      return;
      <D.34448>:
      i = 0;
      goto <D.21712>;
      <D.21711>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;

        typedargs.518 = typedargs;
        i.521 = (unsigned int) i;
        D.34454 = mono_array_addr_with_size (typedargs.518, 4, i.521);
        obj = MEM[(struct MonoObject * *)D.34454];
        D.34455 = mono_method_signature (method);
        D.34456 = D.34455->params[i];
        typedarg = create_cattr_typed_arg (D.34456, obj);
        {
          void * * __p;

          typedargs.518 = typedargs;
          i.521 = (unsigned int) i;
          __p = mono_array_addr_with_size (typedargs.518, 4, i.521);
          typedargs.518 = typedargs;
          mono_gc_wbarrier_set_arrayref (typedargs.518, __p, typedarg);
        }
      }
      i = i + 1;
      <D.21712>:
      D.34457 = mono_method_signature (method);
      D.34458 = D.34457->param_count;
      D.34459 = (int) D.34458;
      if (D.34459 > i) goto <D.21711>; else goto <D.21713>;
      <D.21713>:
      i = 0;
      goto <D.21720>;
      <D.21719>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;
        struct MonoObject * namedarg;
        struct MonoObject * minfo;

        namedargs.519 = namedargs;
        i.521 = (unsigned int) i;
        D.34460 = mono_array_addr_with_size (namedargs.519, 4, i.521);
        obj = MEM[(struct MonoObject * *)D.34460];
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34462 = i.522 * 12;
        D.34463 = arginfo.520 + D.34462;
        D.34464 = D.34463->prop;
        if (D.34464 != 0B) goto <D.34465>; else goto <D.34466>;
        <D.34465>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34462 = i.522 * 12;
        D.34463 = arginfo.520 + D.34462;
        D.34464 = D.34463->prop;
        minfo = mono_property_get_object (domain, 0B, D.34464);
        goto <D.34467>;
        <D.34466>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34462 = i.522 * 12;
        D.34463 = arginfo.520 + D.34462;
        D.34468 = D.34463->field;
        minfo = mono_field_get_object (domain, 0B, D.34468);
        <D.34467>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34462 = i.522 * 12;
        D.34463 = arginfo.520 + D.34462;
        D.34469 = D.34463->type;
        typedarg = create_cattr_typed_arg (D.34469, obj);
        namedarg = create_cattr_named_arg (minfo, typedarg);
        {
          void * * __p;

          namedargs.519 = namedargs;
          i.521 = (unsigned int) i;
          __p = mono_array_addr_with_size (namedargs.519, 4, i.521);
          namedargs.519 = namedargs;
          mono_gc_wbarrier_set_arrayref (namedargs.519, __p, namedarg);
        }
      }
      i = i + 1;
      <D.21720>:
      i.521 = (unsigned int) i;
      namedargs.519 = namedargs;
      D.34470 = mono_array_length (namedargs.519);
      if (i.521 < D.34470) goto <D.21719>; else goto <D.21721>;
      <D.21721>:
      typedargs.518 = typedargs;
      *ctor_args = typedargs.518;
      namedargs.519 = namedargs;
      *named_args = namedargs.519;
      arginfo.520 = arginfo;
      monoeg_g_free (arginfo.520);
    }
  finally
    {
      typedargs = {CLOBBER};
      namedargs = {CLOBBER};
      arginfo = {CLOBBER};
      error = {CLOBBER};
    }
}


create_cattr_typed_arg (struct MonoType * t, struct MonoObject * val)
{
  struct MonoClass * klass.523;
  struct MonoImage * D.34477;
  struct MonoClass * klass.524;
  struct MonoMethod * ctor.525;
  struct MonoMethod * ctor.526;
  struct MonoDomain * D.34483;
  struct MonoReflectionType * D.34484;
  struct MonoDomain * D.34485;
  struct MonoObject * D.34486;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * params[2];
  void * unboxed;

  try
    {
      klass.523 = klass;
      if (klass.523 == 0B) goto <D.34475>; else goto <D.34476>;
      <D.34475>:
      D.34477 = mono_defaults.corlib;
      klass.524 = mono_class_from_name (D.34477, "System.Reflection", "CustomAttributeTypedArgument");
      klass = klass.524;
      <D.34476>:
      ctor.525 = ctor;
      if (ctor.525 == 0B) goto <D.34480>; else goto <D.34481>;
      <D.34480>:
      klass.523 = klass;
      ctor.526 = mono_class_get_method_from_name (klass.523, ".ctor", 2);
      ctor = ctor.526;
      <D.34481>:
      D.34483 = mono_domain_get ();
      D.34484 = mono_type_get_object (D.34483, t);
      params[0] = D.34484;
      params[1] = val;
      D.34485 = mono_domain_get ();
      klass.523 = klass;
      retval = mono_object_new (D.34485, klass.523);
      unboxed = mono_object_unbox (retval);
      ctor.525 = ctor;
      mono_runtime_invoke (ctor.525, unboxed, &params, 0B);
      D.34486 = retval;
      return D.34486;
    }
  finally
    {
      params = {CLOBBER};
    }
}


create_cattr_named_arg (void * minfo, struct MonoObject * typedarg)
{
  struct MonoClass * klass.527;
  struct MonoImage * D.34492;
  struct MonoClass * klass.528;
  struct MonoMethod * ctor.529;
  struct MonoMethod * ctor.530;
  struct MonoDomain * D.34498;
  struct MonoObject * D.34499;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * unboxed;
  void * params[2];

  try
    {
      klass.527 = klass;
      if (klass.527 == 0B) goto <D.34490>; else goto <D.34491>;
      <D.34490>:
      D.34492 = mono_defaults.corlib;
      klass.528 = mono_class_from_name (D.34492, "System.Reflection", "CustomAttributeNamedArgument");
      klass = klass.528;
      <D.34491>:
      ctor.529 = ctor;
      if (ctor.529 == 0B) goto <D.34495>; else goto <D.34496>;
      <D.34495>:
      klass.527 = klass;
      ctor.530 = mono_class_get_method_from_name (klass.527, ".ctor", 2);
      ctor = ctor.530;
      <D.34496>:
      params[0] = minfo;
      params[1] = typedarg;
      D.34498 = mono_domain_get ();
      klass.527 = klass;
      retval = mono_object_new (D.34498, klass.527);
      unboxed = mono_object_unbox (retval);
      ctor.529 = ctor;
      mono_runtime_invoke (ctor.529, unboxed, &params, 0B);
      D.34499 = retval;
      return D.34499;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_custom_attrs_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoArray * D.34502;
  struct MonoError error;

  try
    {
      D.34502 = mono_custom_attrs_construct_by_type (cinfo, 0B, &error);
      return D.34502;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_custom_attrs_construct_by_type (struct MonoCustomAttrInfo * cinfo, struct MonoClass * attr_klass, struct MonoError * error)
{
  struct MonoMethod * D.34508;
  struct MonoClass * D.34509;
  int D.34510;
  int D.34511;
  struct MonoDomain * D.34512;
  struct MonoClass * D.21743;
  struct MonoClass * tmp_klass.531;
  struct MonoClass * D.34516;
  struct MonoClass * tmp_klass.532;
  _Bool D.34518;
  long int D.34519;
  long int D.34520;
  struct MonoVTable * D.34523;
  unsigned int n.533;
  struct MonoException * D.34527;
  int D.34531;
  struct MonoImage * D.34532;
  const mono_byte * D.34533;
  unsigned int D.34534;
  int D.34535;
  struct MonoArray * D.34538;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;
  int n;

  mono_error_init (error);
  n = 0;
  i = 0;
  goto <D.21740>;
  <D.21739>:
  if (attr_klass == 0B) goto <D.34505>; else goto <D.34507>;
  <D.34507>:
  D.34508 = cinfo->attrs[i].ctor;
  D.34509 = D.34508->klass;
  D.34510 = mono_class_is_assignable_from (attr_klass, D.34509);
  if (D.34510 != 0) goto <D.34505>; else goto <D.34506>;
  <D.34505>:
  n = n + 1;
  <D.34506>:
  i = i + 1;
  <D.21740>:
  D.34511 = cinfo->num_attrs;
  if (D.34511 > i) goto <D.21739>; else goto <D.21741>;
  <D.21741>:
  D.34512 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.531 = tmp_klass;
      if (tmp_klass.531 == 0B) goto <D.34514>; else goto <D.34515>;
      <D.34514>:
      D.34516 = mono_defaults.attribute_class;
      tmp_klass.532 = mono_array_class_get (D.34516, 1);
      tmp_klass = tmp_klass.532;
      tmp_klass.531 = tmp_klass;
      D.34518 = tmp_klass.531 == 0B;
      D.34519 = (long int) D.34518;
      D.34520 = __builtin_expect (D.34519, 0);
      if (D.34520 != 0) goto <D.34521>; else goto <D.34522>;
      <D.34521>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8491, "tmp_klass");
      <D.34522>:
      <D.34515>:
    }
    D.21743 = tmp_klass;
  }
  D.34523 = mono_class_vtable (D.34512, D.21743);
  n.533 = (unsigned int) n;
  result = mono_array_new_specific (D.34523, n.533);
  n = 0;
  i = 0;
  goto <D.21746>;
  <D.21745>:
  D.34508 = cinfo->attrs[i].ctor;
  if (D.34508 == 0B) goto <D.34525>; else goto <D.34526>;
  <D.34525>:
  D.34527 = mono_get_exception_type_load (0B, 0B);
  mono_raise_exception (D.34527);
  <D.34526>:
  if (attr_klass == 0B) goto <D.34528>; else goto <D.34530>;
  <D.34530>:
  D.34508 = cinfo->attrs[i].ctor;
  D.34509 = D.34508->klass;
  D.34531 = mono_class_is_assignable_from (attr_klass, D.34509);
  if (D.34531 != 0) goto <D.34528>; else goto <D.34529>;
  <D.34528>:
  D.34532 = cinfo->image;
  D.34508 = cinfo->attrs[i].ctor;
  D.34533 = cinfo->attrs[i].data;
  D.34534 = cinfo->attrs[i].data_size;
  attr = create_custom_attr (D.34532, D.34508, D.34533, D.34534, error);
  D.34535 = mono_error_ok (error);
  if (D.34535 == 0) goto <D.34536>; else goto <D.34537>;
  <D.34536>:
  D.34538 = result;
  return D.34538;
  <D.34537>:
  {
    void * * __p;

    n.533 = (unsigned int) n;
    __p = mono_array_addr_with_size (result, 4, n.533);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  n = n + 1;
  <D.34529>:
  i = i + 1;
  <D.21746>:
  D.34511 = cinfo->num_attrs;
  if (D.34511 > i) goto <D.21745>; else goto <D.21747>;
  <D.21747>:
  D.34538 = result;
  return D.34538;
}


create_custom_attr (struct MonoImage * image, struct MonoMethod * method, const guchar * data, guint32 len, struct MonoError * error)
{
  struct MonoClass * D.34540;
  int D.34541;
  struct MonoObject * D.34544;
  struct MonoDomain * D.34547;
  const char * p.534;
  short unsigned int D.34552;
  short unsigned int D.34553;
  unsigned int D.34557;
  unsigned int D.34558;
  const char * p.535;
  unsigned int D.34560;
  void * * D.34561;
  struct MonoMethodSignature * D.34562;
  struct MonoType * D.34563;
  void * D.34564;
  struct MonoMethodSignature * D.34565;
  short unsigned int D.34566;
  unsigned int D.34567;
  struct MonoDomain * D.34568;
  struct MonoMethodSignature * D.34569;
  const char * named.536;
  short unsigned int D.34571;
  const char * named.537;
  const char * named.538;
  const char * named.539;
  const char * named.540;
  const char * named.541;
  const char * named.542;
  const char * named.543;
  unsigned int D.34583;
  int D.34584;
  unsigned int D.34585;
  unsigned int type_len.544;
  sizetype type_len.545;
  char * D.34588;
  const char * named.546;
  unsigned int D.34590;
  int D.34591;
  unsigned int D.34592;
  unsigned int name_len.547;
  sizetype name_len.548;
  char * D.34595;
  const char * named.549;
  struct MonoVTable * D.34599;
  struct MonoClass * D.34600;
  struct MonoType * D.34601;
  int D.34602;
  struct MonoType * iftmp.550;
  struct MonoMethod * D.34609;
  struct MonoMethodSignature * D.34612;
  struct MonoMethod * D.34614;
  struct MonoMethodSignature * D.34615;
  struct MonoMethodSignature * D.34616;
  short unsigned int D.34617;
  int D.34618;
  int D.34619;
  void * D.34620;
  int D.34621;
  void * D.34624;
  const char * p;
  const char * named;
  guint32 i;
  guint32 j;
  guint32 num_named;
  struct MonoObject * attr;
  void * params_buf[32];
  void * * params;
  struct MonoMethodSignature * sig;

  try
    {
      p = data;
      mono_error_init (error);
      D.34540 = method->klass;
      mono_class_init (D.34540);
      D.34541 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.34541 == 0) goto <D.34542>; else goto <D.34543>;
      <D.34542>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      D.34544 = 0B;
      return D.34544;
      <D.34543>:
      if (len == 0) goto <D.34545>; else goto <D.34546>;
      <D.34545>:
      D.34547 = mono_domain_get ();
      D.34540 = method->klass;
      attr = mono_object_new (D.34547, D.34540);
      mono_runtime_invoke (method, attr, 0B, 0B);
      D.34544 = attr;
      return D.34544;
      <D.34546>:
      if (len <= 1) goto <D.34548>; else goto <D.34550>;
      <D.34550>:
      p.534 = p;
      D.34552 = mono_read16 (p.534);
      if (D.34552 != 1) goto <D.34548>; else goto <D.34549>;
      <D.34548>:
      D.34544 = 0B;
      return D.34544;
      <D.34549>:
      sig = mono_method_signature (method);
      D.34553 = sig->param_count;
      if (D.34553 <= 31) goto <D.34554>; else goto <D.34555>;
      <D.34554>:
      params = &params_buf;
      goto <D.34556>;
      <D.34555>:
      D.34553 = sig->param_count;
      D.34557 = (unsigned int) D.34553;
      D.34558 = D.34557 * 4;
      params = mono_gc_alloc_fixed (D.34558, 0B);
      <D.34556>:
      p.534 = p;
      p.535 = p.534 + 2;
      p = p.535;
      i = 0;
      goto <D.21631>;
      <D.21630>:
      D.34560 = i * 4;
      D.34561 = params + D.34560;
      D.34562 = mono_method_signature (method);
      D.34563 = D.34562->params[i];
      p.534 = p;
      D.34564 = load_cattr_value (image, D.34563, p.534, &p);
      *D.34561 = D.34564;
      i = i + 1;
      <D.21631>:
      D.34565 = mono_method_signature (method);
      D.34566 = D.34565->param_count;
      D.34567 = (unsigned int) D.34566;
      if (D.34567 > i) goto <D.21630>; else goto <D.21632>;
      <D.21632>:
      p.534 = p;
      named = p.534;
      D.34568 = mono_domain_get ();
      D.34540 = method->klass;
      attr = mono_object_new (D.34568, D.34540);
      mono_runtime_invoke (method, attr, params, 0B);
      D.34569 = method->signature;
      free_param_data (D.34569, params);
      named.536 = named;
      D.34571 = mono_read16 (named.536);
      num_named = (guint32) D.34571;
      named.536 = named;
      named.537 = named.536 + 2;
      named = named.537;
      j = 0;
      goto <D.21645>;
      <D.21644>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.536 = named;
        named.538 = named.536;
        named.539 = named.538 + 1;
        named = named.539;
        named_type = *named.538;
        named.536 = named;
        named.540 = named.536;
        named.541 = named.540 + 1;
        named = named.541;
        data_type = *named.540;
        if (data_type == 29) goto <D.34577>; else goto <D.34578>;
        <D.34577>:
        named.536 = named;
        named.542 = named.536;
        named.543 = named.542 + 1;
        named = named.543;
        data_type = *named.542;
        <D.34578>:
        if (data_type == 85) goto <D.34581>; else goto <D.34582>;
        <D.34581>:
        {
          gint type_len;
          char * type_name;

          named.536 = named;
          D.34583 = mono_metadata_decode_blob_size (named.536, &named);
          type_len = (gint) D.34583;
          D.34584 = type_len + 1;
          D.34585 = (unsigned int) D.34584;
          type_name = monoeg_malloc (D.34585);
          named.536 = named;
          type_len.544 = (unsigned int) type_len;
          memcpy (type_name, named.536, type_len.544);
          type_len.545 = (sizetype) type_len;
          D.34588 = type_name + type_len.545;
          *D.34588 = 0;
          named.536 = named;
          type_len.545 = (sizetype) type_len;
          named.546 = named.536 + type_len.545;
          named = named.546;
          monoeg_g_free (type_name);
        }
        <D.34582>:
        named.536 = named;
        D.34590 = mono_metadata_decode_blob_size (named.536, &named);
        name_len = (gint) D.34590;
        D.34591 = name_len + 1;
        D.34592 = (unsigned int) D.34591;
        name = monoeg_malloc (D.34592);
        named.536 = named;
        name_len.547 = (unsigned int) name_len;
        memcpy (name, named.536, name_len.547);
        name_len.548 = (sizetype) name_len;
        D.34595 = name + name_len.548;
        *D.34595 = 0;
        named.536 = named;
        name_len.548 = (sizetype) name_len;
        named.549 = named.536 + name_len.548;
        named = named.549;
        if (named_type == 83) goto <D.34597>; else goto <D.34598>;
        <D.34597>:
        {
          struct MonoClassField * field;
          void * val;

          D.34599 = attr->vtable;
          D.34600 = D.34599->klass;
          field = mono_class_get_field_from_name (D.34600, name);
          D.34601 = field->type;
          named.536 = named;
          val = load_cattr_value (image, D.34601, named.536, &named);
          mono_field_set_value (attr, field, val);
          D.34601 = field->type;
          D.34602 = type_is_reference (D.34601);
          if (D.34602 == 0) goto <D.34603>; else goto <D.34604>;
          <D.34603>:
          monoeg_g_free (val);
          <D.34604>:
        }
        goto <D.34605>;
        <D.34598>:
        if (named_type == 84) goto <D.34606>; else goto <D.34607>;
        <D.34606>:
        {
          struct MonoProperty * prop;
          void * pparams[1];
          struct MonoType * prop_type;

          try
            {
              D.34599 = attr->vtable;
              D.34600 = D.34599->klass;
              prop = mono_class_get_property_from_name (D.34600, name);
              D.34609 = prop->get;
              if (D.34609 != 0B) goto <D.34610>; else goto <D.34611>;
              <D.34610>:
              D.34609 = prop->get;
              D.34612 = mono_method_signature (D.34609);
              iftmp.550 = D.34612->ret;
              goto <D.34613>;
              <D.34611>:
              D.34614 = prop->set;
              D.34615 = mono_method_signature (D.34614);
              D.34614 = prop->set;
              D.34616 = mono_method_signature (D.34614);
              D.34617 = D.34616->param_count;
              D.34618 = (int) D.34617;
              D.34619 = D.34618 + -1;
              iftmp.550 = D.34615->params[D.34619];
              <D.34613>:
              prop_type = iftmp.550;
              named.536 = named;
              D.34620 = load_cattr_value (image, prop_type, named.536, &named);
              pparams[0] = D.34620;
              mono_property_set_value (prop, attr, &pparams, 0B);
              D.34621 = type_is_reference (prop_type);
              if (D.34621 == 0) goto <D.34622>; else goto <D.34623>;
              <D.34622>:
              D.34624 = pparams[0];
              monoeg_g_free (D.34624);
              <D.34623>:
            }
          finally
            {
              pparams = {CLOBBER};
            }
        }
        <D.34607>:
        <D.34605>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.21645>:
      if (j < num_named) goto <D.21644>; else goto <D.21646>;
      <D.21646>:
      if (&params_buf != params) goto <D.34625>; else goto <D.34626>;
      <D.34625>:
      mono_gc_free_fixed (params);
      <D.34626>:
      D.34544 = attr;
      return D.34544;
    }
  finally
    {
      p = {CLOBBER};
      named = {CLOBBER};
      params_buf = {CLOBBER};
    }
}


free_param_data (struct MonoMethodSignature * sig, void * * params)
{
  struct MonoType * D.34629;
  int D.34630;
  unsigned int i.551;
  unsigned int D.34634;
  void * * D.34635;
  void * D.34636;
  short unsigned int D.34637;
  int D.34638;
  int i;

  i = 0;
  goto <D.21588>;
  <D.21587>:
  D.34629 = sig->params[i];
  D.34630 = type_is_reference (D.34629);
  if (D.34630 == 0) goto <D.34631>; else goto <D.34632>;
  <D.34631>:
  i.551 = (unsigned int) i;
  D.34634 = i.551 * 4;
  D.34635 = params + D.34634;
  D.34636 = *D.34635;
  monoeg_g_free (D.34636);
  <D.34632>:
  i = i + 1;
  <D.21588>:
  D.34637 = sig->param_count;
  D.34638 = (int) D.34637;
  if (D.34638 > i) goto <D.21587>; else goto <D.21589>;
  <D.21589>:
}


mono_custom_attrs_from_index (struct MonoImage * image, guint32 idx)
{
  struct MonoCustomAttrInfo * D.34641;
  int i.552;
  unsigned int D.34643;
  void * i.553;
  <unnamed-unsigned:24> D.34646;
  unsigned int D.34647;
  unsigned int D.34650;
  unsigned int D.34651;
  int len.554;
  void * D.34653;
  int D.34654;
  unsigned int D.34655;
  unsigned int D.34656;
  struct MonoMethod * D.34657;
  struct MonoMethod * D.34658;
  char * D.34661;
  unsigned int D.34662;
  int D.34663;
  const char * data.555;
  const char * data.556;
  unsigned int D.34668;
  guint32 mtoken;
  guint32 i;
  guint32 len;
  guint32 cols[3];
  struct MonoTableInfo * ca;
  struct MonoCustomAttrInfo * ainfo;
  struct GList * tmp;
  struct GList * list;
  const char * data;

  try
    {
      list = 0B;
      ca = &image->tables[12];
      i = mono_metadata_custom_attrs_from_index (image, idx);
      if (i == 0) goto <D.34639>; else goto <D.34640>;
      <D.34639>:
      D.34641 = 0B;
      return D.34641;
      <D.34640>:
      i = i + 4294967295;
      goto <D.21777>;
      <D.21776>:
      i.552 = (int) i;
      D.34643 = mono_metadata_decode_row_col (ca, i.552, 0);
      if (D.34643 != idx) goto <D.21775>; else goto <D.34644>;
      <D.34644>:
      i.553 = (void *) i;
      list = monoeg_g_list_prepend (list, i.553);
      i = i + 1;
      <D.21777>:
      D.34646 = ca->rows;
      D.34647 = (unsigned int) D.34646;
      if (D.34647 > i) goto <D.21776>; else goto <D.21775>;
      <D.21775>:
      len = monoeg_g_list_length (list);
      if (len == 0) goto <D.34648>; else goto <D.34649>;
      <D.34648>:
      D.34641 = 0B;
      return D.34641;
      <D.34649>:
      D.34650 = len + 1;
      D.34651 = D.34650 * 12;
      ainfo = monoeg_malloc0 (D.34651);
      len.554 = (int) len;
      ainfo->num_attrs = len.554;
      ainfo->image = image;
      i = 0;
      tmp = list;
      goto <D.21784>;
      <D.21783>:
      D.34653 = tmp->data;
      D.34654 = (int) D.34653;
      mono_metadata_decode_row (ca, D.34654, &cols, 3);
      D.34655 = cols[1];
      mtoken = D.34655 >> 3;
      D.34655 = cols[1];
      D.34656 = D.34655 & 7;
      switch (D.34656) <default: <D.21781>, case 2: <D.21778>, case 3: <D.21780>>
      <D.21778>:
      mtoken = mtoken | 100663296;
      goto <D.21779>;
      <D.21780>:
      mtoken = mtoken | 167772160;
      goto <D.21779>;
      <D.21781>:
      D.34655 = cols[1];
      monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.34655);
      <D.21782>:
      goto <D.21782>;
      <D.21779>:
      D.34657 = mono_get_method (image, mtoken, 0B);
      ainfo->attrs[i].ctor = D.34657;
      D.34658 = ainfo->attrs[i].ctor;
      if (D.34658 == 0B) goto <D.34659>; else goto <D.34660>;
      <D.34659>:
      D.34661 = image->name;
      monoeg_g_log (0B, 16, "Can\'t find custom attr constructor image: %s mtoken: 0x%08x", D.34661, mtoken);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.34641 = 0B;
      return D.34641;
      <D.34660>:
      D.34662 = cols[2];
      D.34663 = mono_verifier_verify_cattr_blob (image, D.34662, 0B);
      if (D.34663 == 0) goto <D.34664>; else goto <D.34665>;
      <D.34664>:
      D.34661 = image->name;
      monoeg_g_log (0B, 16, "Invalid custom attribute blob on image %s for index %x", D.34661, idx);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.34641 = 0B;
      return D.34641;
      <D.34665>:
      D.34662 = cols[2];
      data.555 = mono_metadata_blob_heap (image, D.34662);
      data = data.555;
      data.556 = data;
      D.34668 = mono_metadata_decode_value (data.556, &data);
      ainfo->attrs[i].data_size = D.34668;
      data.556 = data;
      ainfo->attrs[i].data = data.556;
      i = i + 1;
      tmp = tmp->next;
      <D.21784>:
      if (i < len) goto <D.21783>; else goto <D.21785>;
      <D.21785>:
      monoeg_g_list_free (list);
      D.34641 = ainfo;
      return D.34641;
    }
  finally
    {
      cols = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_custom_attrs_from_method (struct MonoMethod * method)
{
  unsigned int D.34671;
  unsigned int D.34672;
  unsigned int D.34677;
  struct MonoClass * D.34679;
  struct MonoImage * D.34680;
  unsigned int D.34681;
  unsigned int D.34682;
  struct MonoCustomAttrInfo * D.34683;
  unsigned int D.34684;
  guint32 idx;

  D.34671 = BIT_FIELD_REF <*method, 32, 160>;
  D.34672 = D.34671 & 4096;
  if (D.34672 != 0) goto <D.34673>; else goto <D.34674>;
  <D.34673>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.34674>:
  D.34671 = BIT_FIELD_REF <*method, 32, 160>;
  D.34677 = D.34671 & 512;
  if (D.34677 != 0) goto <D.34675>; else goto <D.34678>;
  <D.34678>:
  D.34679 = method->klass;
  D.34680 = D.34679->image;
  D.34681 = BIT_FIELD_REF <*D.34680, 32, 128>;
  D.34682 = D.34681 & 8;
  if (D.34682 != 0) goto <D.34675>; else goto <D.34676>;
  <D.34675>:
  D.34679 = method->klass;
  D.34680 = D.34679->image;
  D.34683 = lookup_custom_attr (D.34680, method);
  return D.34683;
  <D.34676>:
  D.34684 = method->token;
  if (D.34684 == 0) goto <D.34685>; else goto <D.34686>;
  <D.34685>:
  D.34683 = 0B;
  return D.34683;
  <D.34686>:
  idx = mono_method_get_index (method);
  idx = idx << 5;
  idx = idx;
  D.34679 = method->klass;
  D.34680 = D.34679->image;
  D.34683 = mono_custom_attrs_from_index (D.34680, idx);
  return D.34683;
}


lookup_custom_attr (struct MonoImage * image, void * member)
{
  struct MonoCustomAttrInfo * D.34690;
  int D.34691;
  unsigned int D.34692;
  unsigned int D.34693;
  unsigned int D.34694;
  struct MonoCustomAttrInfo * res;

  res = mono_image_property_lookup (image, member, 4096);
  if (res == 0B) goto <D.34688>; else goto <D.34689>;
  <D.34688>:
  D.34690 = 0B;
  return D.34690;
  <D.34689>:
  D.34691 = res->num_attrs;
  D.34692 = (unsigned int) D.34691;
  D.34693 = D.34692 + 1;
  D.34694 = D.34693 * 12;
  res = monoeg_g_memdup (res, D.34694);
  res->cached = 0;
  D.34690 = res;
  return D.34690;
}


mono_custom_attrs_from_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.34696;
  struct MonoImage * D.34699;
  unsigned int D.34700;
  unsigned int D.34701;
  struct MonoCustomAttrInfo * D.34704;
  unsigned char D.34708;
  int D.34710;
  unsigned int D.34711;
  unsigned int D.34712;
  guint32 idx;

  D.34696 = klass->generic_class;
  if (D.34696 != 0B) goto <D.34697>; else goto <D.34698>;
  <D.34697>:
  D.34696 = klass->generic_class;
  klass = D.34696->container_class;
  <D.34698>:
  D.34699 = klass->image;
  D.34700 = BIT_FIELD_REF <*D.34699, 32, 128>;
  D.34701 = D.34700 & 8;
  if (D.34701 != 0) goto <D.34702>; else goto <D.34703>;
  <D.34702>:
  D.34699 = klass->image;
  D.34704 = lookup_custom_attr (D.34699, klass);
  return D.34704;
  <D.34703>:
  D.34708 = klass->byval_arg.type;
  if (D.34708 == 19) goto <D.34705>; else goto <D.34709>;
  <D.34709>:
  D.34708 = klass->byval_arg.type;
  if (D.34708 == 30) goto <D.34705>; else goto <D.34706>;
  <D.34705>:
  D.34710 = klass->sizes.generic_param_token;
  D.34711 = (unsigned int) D.34710;
  idx = D.34711 & 16777215;
  idx = idx << 5;
  idx = idx | 19;
  goto <D.34707>;
  <D.34706>:
  D.34712 = klass->type_token;
  idx = D.34712 & 16777215;
  idx = idx << 5;
  idx = idx | 3;
  <D.34707>:
  D.34699 = klass->image;
  D.34704 = mono_custom_attrs_from_index (D.34699, idx);
  return D.34704;
}


mono_custom_attrs_from_assembly (struct MonoAssembly * assembly)
{
  struct MonoImage * D.34714;
  unsigned int D.34715;
  unsigned int D.34716;
  struct MonoCustomAttrInfo * D.34719;
  guint32 idx;

  D.34714 = assembly->image;
  D.34715 = BIT_FIELD_REF <*D.34714, 32, 128>;
  D.34716 = D.34715 & 8;
  if (D.34716 != 0) goto <D.34717>; else goto <D.34718>;
  <D.34717>:
  D.34714 = assembly->image;
  D.34719 = lookup_custom_attr (D.34714, assembly);
  return D.34719;
  <D.34718>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 14;
  D.34714 = assembly->image;
  D.34719 = mono_custom_attrs_from_index (D.34714, idx);
  return D.34719;
}


mono_custom_attrs_from_property (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoImage * D.34721;
  unsigned int D.34722;
  unsigned int D.34723;
  struct MonoCustomAttrInfo * D.34726;
  guint32 idx;

  D.34721 = klass->image;
  D.34722 = BIT_FIELD_REF <*D.34721, 32, 128>;
  D.34723 = D.34722 & 8;
  if (D.34723 != 0) goto <D.34724>; else goto <D.34725>;
  <D.34724>:
  property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
  D.34721 = klass->image;
  D.34726 = lookup_custom_attr (D.34721, property);
  return D.34726;
  <D.34725>:
  idx = find_property_index (klass, property);
  idx = idx << 5;
  idx = idx | 9;
  D.34721 = klass->image;
  D.34726 = mono_custom_attrs_from_index (D.34721, idx);
  return D.34726;
}


find_property_index (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoClassExt * D.34728;
  struct MonoProperty * D.34729;
  unsigned int i.557;
  unsigned int D.34731;
  struct MonoProperty * D.34732;
  guint32 D.34735;
  unsigned int D.34736;
  unsigned int i.558;
  unsigned int D.34738;
  unsigned int D.34739;
  int i;

  i = 0;
  goto <D.21604>;
  <D.21603>:
  D.34728 = klass->ext;
  D.34729 = D.34728->properties;
  i.557 = (unsigned int) i;
  D.34731 = i.557 * 20;
  D.34732 = D.34729 + D.34731;
  if (D.34732 == property) goto <D.34733>; else goto <D.34734>;
  <D.34733>:
  D.34728 = klass->ext;
  D.34736 = D.34728->property.first;
  i.558 = (unsigned int) i;
  D.34738 = D.34736 + i.558;
  D.34735 = D.34738 + 1;
  return D.34735;
  <D.34734>:
  i = i + 1;
  <D.21604>:
  i.558 = (unsigned int) i;
  D.34728 = klass->ext;
  D.34739 = D.34728->property.count;
  if (i.558 < D.34739) goto <D.21603>; else goto <D.21605>;
  <D.21605>:
  D.34735 = 0;
  return D.34735;
}


mono_custom_attrs_from_event (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoImage * D.34741;
  unsigned int D.34742;
  unsigned int D.34743;
  struct MonoCustomAttrInfo * D.34746;
  guint32 idx;

  D.34741 = klass->image;
  D.34742 = BIT_FIELD_REF <*D.34741, 32, 128>;
  D.34743 = D.34742 & 8;
  if (D.34743 != 0) goto <D.34744>; else goto <D.34745>;
  <D.34744>:
  event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
  D.34741 = klass->image;
  D.34746 = lookup_custom_attr (D.34741, event);
  return D.34746;
  <D.34745>:
  idx = find_event_index (klass, event);
  idx = idx << 5;
  idx = idx | 10;
  D.34741 = klass->image;
  D.34746 = mono_custom_attrs_from_index (D.34741, idx);
  return D.34746;
}


find_event_index (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoClassExt * D.34748;
  struct MonoEvent * D.34749;
  unsigned int i.559;
  unsigned int D.34751;
  struct MonoEvent * D.34752;
  guint32 D.34755;
  unsigned int D.34756;
  unsigned int i.560;
  unsigned int D.34758;
  unsigned int D.34759;
  int i;

  i = 0;
  goto <D.21612>;
  <D.21611>:
  D.34748 = klass->ext;
  D.34749 = D.34748->events;
  i.559 = (unsigned int) i;
  D.34751 = i.559 * 28;
  D.34752 = D.34749 + D.34751;
  if (D.34752 == event) goto <D.34753>; else goto <D.34754>;
  <D.34753>:
  D.34748 = klass->ext;
  D.34756 = D.34748->event.first;
  i.560 = (unsigned int) i;
  D.34758 = D.34756 + i.560;
  D.34755 = D.34758 + 1;
  return D.34755;
  <D.34754>:
  i = i + 1;
  <D.21612>:
  i.560 = (unsigned int) i;
  D.34748 = klass->ext;
  D.34759 = D.34748->event.count;
  if (i.560 < D.34759) goto <D.21611>; else goto <D.21613>;
  <D.21613>:
  D.34755 = 0;
  return D.34755;
}


mono_custom_attrs_from_field (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoImage * D.34761;
  unsigned int D.34762;
  unsigned int D.34763;
  struct MonoCustomAttrInfo * D.34766;
  guint32 idx;

  D.34761 = klass->image;
  D.34762 = BIT_FIELD_REF <*D.34761, 32, 128>;
  D.34763 = D.34762 & 8;
  if (D.34763 != 0) goto <D.34764>; else goto <D.34765>;
  <D.34764>:
  field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
  D.34761 = klass->image;
  D.34766 = lookup_custom_attr (D.34761, field);
  return D.34766;
  <D.34765>:
  idx = find_field_index (klass, field);
  idx = idx << 5;
  idx = idx | 1;
  D.34761 = klass->image;
  D.34766 = mono_custom_attrs_from_index (D.34761, idx);
  return D.34766;
}


find_field_index (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoClassField * D.34768;
  unsigned int i.561;
  unsigned int D.34770;
  struct MonoClassField * D.34771;
  guint32 D.34774;
  unsigned int D.34775;
  unsigned int i.562;
  unsigned int D.34777;
  unsigned int D.34778;
  int i;

  i = 0;
  goto <D.21596>;
  <D.21595>:
  D.34768 = klass->fields;
  i.561 = (unsigned int) i;
  D.34770 = i.561 * 16;
  D.34771 = D.34768 + D.34770;
  if (D.34771 == field) goto <D.34772>; else goto <D.34773>;
  <D.34772>:
  D.34775 = klass->field.first;
  i.562 = (unsigned int) i;
  D.34777 = D.34775 + i.562;
  D.34774 = D.34777 + 1;
  return D.34774;
  <D.34773>:
  i = i + 1;
  <D.21596>:
  i.562 = (unsigned int) i;
  D.34778 = klass->field.count;
  if (i.562 < D.34778) goto <D.21595>; else goto <D.21597>;
  <D.21597>:
  D.34774 = 0;
  return D.34774;
}


mono_custom_attrs_from_param (struct MonoMethod * method, guint32 param)
{
  unsigned int D.34780;
  unsigned int D.34781;
  struct MonoClass * D.34784;
  struct MonoImage * D.34785;
  unsigned int D.34786;
  unsigned int D.34787;
  struct GHashTable * D.34790;
  struct MonoCustomAttrInfo * * D.34794;
  struct MonoCustomAttrInfo * D.34795;
  unsigned int D.34796;
  struct MonoCustomAttrInfo * * D.34797;
  int D.34800;
  unsigned int D.34801;
  unsigned int D.34802;
  unsigned int D.34803;
  unsigned int size.563;
  unsigned int size.564;
  unsigned int D.34808;
  int D.34809;
  <unnamed-unsigned:24> D.34810;
  unsigned int D.34811;
  int D.34814;
  int D.34815;
  int method_index.565;
  unsigned int D.34818;
  int D.34819;
  struct MonoTableInfo * ca;
  guint32 i;
  guint32 idx;
  guint32 method_index;
  guint32 param_list;
  guint32 param_last;
  guint32 param_pos;
  guint32 found;
  struct MonoImage * image;
  struct MonoReflectionMethodAux * aux;

  D.34780 = BIT_FIELD_REF <*method, 32, 160>;
  D.34781 = D.34780 & 4096;
  if (D.34781 != 0) goto <D.34782>; else goto <D.34783>;
  <D.34782>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.34783>:
  D.34784 = method->klass;
  D.34785 = D.34784->image;
  D.34786 = BIT_FIELD_REF <*D.34785, 32, 128>;
  D.34787 = D.34786 & 8;
  if (D.34787 != 0) goto <D.34788>; else goto <D.34789>;
  <D.34788>:
  {
    struct MonoCustomAttrInfo * res;
    struct MonoCustomAttrInfo * ainfo;
    int size;

    D.34784 = method->klass;
    D.34785 = D.34784->image;
    D.34790 = MEM[(struct MonoDynamicImage *)D.34785].method_aux_hash;
    aux = monoeg_g_hash_table_lookup (D.34790, method);
    if (aux == 0B) goto <D.34791>; else goto <D.34793>;
    <D.34793>:
    D.34794 = aux->param_cattr;
    if (D.34794 == 0B) goto <D.34791>; else goto <D.34792>;
    <D.34791>:
    D.34795 = 0B;
    return D.34795;
    <D.34792>:
    D.34794 = aux->param_cattr;
    D.34796 = param * 4;
    D.34797 = D.34794 + D.34796;
    ainfo = *D.34797;
    if (ainfo == 0B) goto <D.34798>; else goto <D.34799>;
    <D.34798>:
    D.34795 = 0B;
    return D.34795;
    <D.34799>:
    D.34800 = ainfo->num_attrs;
    D.34801 = (unsigned int) D.34800;
    D.34802 = D.34801 + 1;
    D.34803 = D.34802 * 12;
    size = (int) D.34803;
    size.563 = (unsigned int) size;
    res = monoeg_malloc0 (size.563);
    size.564 = (unsigned int) size;
    memcpy (res, ainfo, size.564);
    D.34795 = res;
    return D.34795;
  }
  <D.34789>:
  D.34784 = method->klass;
  image = D.34784->image;
  method_index = mono_method_get_index (method);
  if (method_index == 0) goto <D.34806>; else goto <D.34807>;
  <D.34806>:
  D.34795 = 0B;
  return D.34795;
  <D.34807>:
  ca = &image->tables[6];
  D.34808 = method_index + 4294967295;
  D.34809 = (int) D.34808;
  param_list = mono_metadata_decode_row_col (ca, D.34809, 5);
  D.34810 = ca->rows;
  D.34811 = (unsigned int) D.34810;
  if (D.34811 == method_index) goto <D.34812>; else goto <D.34813>;
  <D.34812>:
  ca = &image->tables[8];
  D.34810 = ca->rows;
  D.34814 = (int) D.34810;
  D.34815 = D.34814 + 1;
  param_last = (guint32) D.34815;
  goto <D.34816>;
  <D.34813>:
  method_index.565 = (int) method_index;
  param_last = mono_metadata_decode_row_col (ca, method_index.565, 5);
  ca = &image->tables[8];
  <D.34816>:
  found = 0;
  i = param_list;
  goto <D.21836>;
  <D.21835>:
  D.34818 = i + 4294967295;
  D.34819 = (int) D.34818;
  param_pos = mono_metadata_decode_row_col (ca, D.34819, 1);
  if (param_pos == param) goto <D.34820>; else goto <D.34821>;
  <D.34820>:
  found = 1;
  goto <D.21834>;
  <D.34821>:
  i = i + 1;
  <D.21836>:
  if (i < param_last) goto <D.21835>; else goto <D.21834>;
  <D.21834>:
  if (found == 0) goto <D.34822>; else goto <D.34823>;
  <D.34822>:
  D.34795 = 0B;
  return D.34795;
  <D.34823>:
  idx = i;
  idx = idx << 5;
  idx = idx | 4;
  D.34795 = mono_custom_attrs_from_index (image, idx);
  return D.34795;
}


mono_custom_attrs_has_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.34825;
  int D.34829;
  unsigned int D.34831;
  unsigned int D.34832;
  unsigned char D.34834;
  int D.34836;
  mono_bool D.34837;
  int D.34838;
  int i;
  struct MonoClass * klass;

  i = 0;
  goto <D.21844>;
  <D.21843>:
  D.34825 = ainfo->attrs[i].ctor;
  klass = D.34825->klass;
  D.34829 = mono_class_has_parent (klass, attr_klass);
  if (D.34829 != 0) goto <D.34826>; else goto <D.34830>;
  <D.34830>:
  D.34831 = attr_klass->flags;
  D.34832 = D.34831 & 32;
  if (D.34832 != 0) goto <D.34827>; else goto <D.34833>;
  <D.34833>:
  D.34834 = attr_klass->byval_arg.type;
  if (D.34834 == 19) goto <D.34827>; else goto <D.34835>;
  <D.34835>:
  D.34834 = attr_klass->byval_arg.type;
  if (D.34834 == 30) goto <D.34827>; else goto <D.34828>;
  <D.34827>:
  D.34836 = mono_class_is_assignable_from (attr_klass, klass);
  if (D.34836 != 0) goto <D.34826>; else goto <D.34828>;
  <D.34826>:
  D.34837 = 1;
  return D.34837;
  <D.34828>:
  i = i + 1;
  <D.21844>:
  D.34838 = ainfo->num_attrs;
  if (D.34838 > i) goto <D.21843>; else goto <D.21845>;
  <D.21845>:
  D.34837 = 0;
  return D.34837;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.34840;
  _Bool D.34841;
  long int D.34842;
  long int D.34843;
  struct MonoClass * * D.34846;
  _Bool D.34847;
  long int D.34848;
  long int D.34849;
  gboolean D.34852;

  D.34840 = klass->supertypes;
  D.34841 = D.34840 == 0B;
  D.34842 = (long int) D.34841;
  D.34843 = __builtin_expect (D.34842, 0);
  if (D.34843 != 0) goto <D.34844>; else goto <D.34845>;
  <D.34844>:
  mono_class_setup_supertypes (klass);
  <D.34845>:
  D.34846 = parent->supertypes;
  D.34847 = D.34846 == 0B;
  D.34848 = (long int) D.34847;
  D.34849 = __builtin_expect (D.34848, 0);
  if (D.34849 != 0) goto <D.34850>; else goto <D.34851>;
  <D.34850>:
  mono_class_setup_supertypes (parent);
  <D.34851>:
  D.34852 = mono_class_has_parent_fast (klass, parent);
  return D.34852;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.34854;
  int iftmp.566;
  short unsigned int D.34858;
  short unsigned int D.34859;
  struct MonoClass * * D.34861;
  sizetype D.34862;
  sizetype D.34863;
  sizetype D.34864;
  struct MonoClass * * D.34865;
  struct MonoClass * D.34866;

  D.34858 = klass->idepth;
  D.34859 = parent->idepth;
  if (D.34858 >= D.34859) goto <D.34860>; else goto <D.34856>;
  <D.34860>:
  D.34861 = klass->supertypes;
  D.34859 = parent->idepth;
  D.34862 = (sizetype) D.34859;
  D.34863 = D.34862 + 1073741823;
  D.34864 = D.34863 * 4;
  D.34865 = D.34861 + D.34864;
  D.34866 = *D.34865;
  if (D.34866 == parent) goto <D.34867>; else goto <D.34856>;
  <D.34867>:
  iftmp.566 = 1;
  goto <D.34857>;
  <D.34856>:
  iftmp.566 = 0;
  <D.34857>:
  D.34854 = iftmp.566;
  return D.34854;
}


mono_custom_attrs_get_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.34869;
  int D.34870;
  int D.34873;
  struct MonoObject * D.34876;
  unsigned int attr_index.567;
  char * D.34880;
  int i;
  int attr_index;
  struct MonoClass * klass;
  struct MonoArray * attrs;

  attr_index = -1;
  i = 0;
  goto <D.21856>;
  <D.21855>:
  D.34869 = ainfo->attrs[i].ctor;
  klass = D.34869->klass;
  D.34870 = mono_class_has_parent (klass, attr_klass);
  if (D.34870 != 0) goto <D.34871>; else goto <D.34872>;
  <D.34871>:
  attr_index = i;
  goto <D.21854>;
  <D.34872>:
  i = i + 1;
  <D.21856>:
  D.34873 = ainfo->num_attrs;
  if (D.34873 > i) goto <D.21855>; else goto <D.21854>;
  <D.21854>:
  if (attr_index == -1) goto <D.34874>; else goto <D.34875>;
  <D.34874>:
  D.34876 = 0B;
  return D.34876;
  <D.34875>:
  attrs = mono_custom_attrs_construct (ainfo);
  if (attrs != 0B) goto <D.34877>; else goto <D.34878>;
  <D.34877>:
  attr_index.567 = (unsigned int) attr_index;
  D.34880 = mono_array_addr_with_size (attrs, 4, attr_index.567);
  D.34876 = MEM[(struct MonoObject * *)D.34880];
  return D.34876;
  <D.34878>:
  D.34876 = 0B;
  return D.34876;
}


mono_reflection_get_custom_attrs_info (struct MonoObject * obj)
{
  struct MonoVTable * D.34882;
  struct MonoClass * D.34883;
  int D.21871;
  int iftmp.568;
  int D.21867;
  const char[9] * D.34893;
  unsigned char D.34894;
  int D.34895;
  unsigned char D.34896;
  int D.34897;
  const unsigned char * D.34902;
  unsigned char D.34903;
  int D.34904;
  const unsigned char * D.34905;
  unsigned char D.34906;
  int D.34907;
  const unsigned char * D.34912;
  unsigned char D.34913;
  int D.34914;
  const unsigned char * D.34915;
  unsigned char D.34916;
  int D.34917;
  const unsigned char * D.34922;
  unsigned char D.34923;
  int D.34924;
  const unsigned char * D.34925;
  unsigned char D.34926;
  int D.34927;
  const char * D.34929;
  int D.21880;
  int iftmp.569;
  int D.21876;
  const char[13] * D.34934;
  unsigned char D.34935;
  int D.34936;
  unsigned char D.34937;
  int D.34938;
  const unsigned char * D.34943;
  unsigned char D.34944;
  int D.34945;
  const unsigned char * D.34946;
  unsigned char D.34947;
  int D.34948;
  const unsigned char * D.34953;
  unsigned char D.34954;
  int D.34955;
  const unsigned char * D.34956;
  unsigned char D.34957;
  int D.34958;
  const unsigned char * D.34963;
  unsigned char D.34964;
  int D.34965;
  const unsigned char * D.34966;
  unsigned char D.34967;
  int D.34968;
  struct MonoAssembly * D.34970;
  int D.21890;
  int iftmp.570;
  int D.21886;
  const char[7] * D.34977;
  unsigned char D.34978;
  int D.34979;
  unsigned char D.34980;
  int D.34981;
  const unsigned char * D.34986;
  unsigned char D.34987;
  int D.34988;
  const unsigned char * D.34989;
  unsigned char D.34990;
  int D.34991;
  const unsigned char * D.34996;
  unsigned char D.34997;
  int D.34998;
  const unsigned char * D.34999;
  unsigned char D.35000;
  int D.35001;
  const unsigned char * D.35006;
  unsigned char D.35007;
  int D.35008;
  const unsigned char * D.35009;
  unsigned char D.35010;
  int D.35011;
  int D.21899;
  int iftmp.571;
  int D.21895;
  const char[11] * D.35017;
  unsigned char D.35018;
  int D.35019;
  unsigned char D.35020;
  int D.35021;
  const unsigned char * D.35026;
  unsigned char D.35027;
  int D.35028;
  const unsigned char * D.35029;
  unsigned char D.35030;
  int D.35031;
  const unsigned char * D.35036;
  unsigned char D.35037;
  int D.35038;
  const unsigned char * D.35039;
  unsigned char D.35040;
  int D.35041;
  const unsigned char * D.35046;
  unsigned char D.35047;
  int D.35048;
  const unsigned char * D.35049;
  unsigned char D.35050;
  int D.35051;
  struct MonoImage * D.35053;
  int D.21909;
  int iftmp.572;
  int D.21905;
  const char[13] * D.35057;
  unsigned char D.35058;
  int D.35059;
  unsigned char D.35060;
  int D.35061;
  const unsigned char * D.35066;
  unsigned char D.35067;
  int D.35068;
  const unsigned char * D.35069;
  unsigned char D.35070;
  int D.35071;
  const unsigned char * D.35076;
  unsigned char D.35077;
  int D.35078;
  const unsigned char * D.35079;
  unsigned char D.35080;
  int D.35081;
  const unsigned char * D.35086;
  unsigned char D.35087;
  int D.35088;
  const unsigned char * D.35089;
  unsigned char D.35090;
  int D.35091;
  struct MonoProperty * D.35095;
  struct MonoClass * D.35096;
  int D.21919;
  int iftmp.573;
  int D.21915;
  const char[10] * D.35101;
  unsigned char D.35102;
  int D.35103;
  unsigned char D.35104;
  int D.35105;
  const unsigned char * D.35110;
  unsigned char D.35111;
  int D.35112;
  const unsigned char * D.35113;
  unsigned char D.35114;
  int D.35115;
  const unsigned char * D.35120;
  unsigned char D.35121;
  int D.35122;
  const unsigned char * D.35123;
  unsigned char D.35124;
  int D.35125;
  const unsigned char * D.35130;
  unsigned char D.35131;
  int D.35132;
  const unsigned char * D.35133;
  unsigned char D.35134;
  int D.35135;
  struct MonoEvent * D.35139;
  struct MonoClass * D.35140;
  int D.21929;
  int iftmp.574;
  int D.21925;
  const char[10] * D.35145;
  unsigned char D.35146;
  int D.35147;
  unsigned char D.35148;
  int D.35149;
  const unsigned char * D.35154;
  unsigned char D.35155;
  int D.35156;
  const unsigned char * D.35157;
  unsigned char D.35158;
  int D.35159;
  const unsigned char * D.35164;
  unsigned char D.35165;
  int D.35166;
  const unsigned char * D.35167;
  unsigned char D.35168;
  int D.35169;
  const unsigned char * D.35174;
  unsigned char D.35175;
  int D.35176;
  const unsigned char * D.35177;
  unsigned char D.35178;
  int D.35179;
  struct MonoClassField * D.35183;
  struct MonoClass * D.35184;
  int D.21939;
  int iftmp.575;
  int D.21935;
  const char[11] * D.35192;
  unsigned char D.35193;
  int D.35194;
  unsigned char D.35195;
  int D.35196;
  const unsigned char * D.35201;
  unsigned char D.35202;
  int D.35203;
  const unsigned char * D.35204;
  unsigned char D.35205;
  int D.35206;
  const unsigned char * D.35211;
  unsigned char D.35212;
  int D.35213;
  const unsigned char * D.35214;
  unsigned char D.35215;
  int D.35216;
  const unsigned char * D.35221;
  unsigned char D.35222;
  int D.35223;
  const unsigned char * D.35224;
  unsigned char D.35225;
  int D.35226;
  int D.21948;
  int iftmp.576;
  int D.21944;
  const char[12] * D.35232;
  unsigned char D.35233;
  int D.35234;
  unsigned char D.35235;
  int D.35236;
  const unsigned char * D.35241;
  unsigned char D.35242;
  int D.35243;
  const unsigned char * D.35244;
  unsigned char D.35245;
  int D.35246;
  const unsigned char * D.35251;
  unsigned char D.35252;
  int D.35253;
  const unsigned char * D.35254;
  unsigned char D.35255;
  int D.35256;
  const unsigned char * D.35261;
  unsigned char D.35262;
  int D.35263;
  const unsigned char * D.35264;
  unsigned char D.35265;
  int D.35266;
  struct MonoMethod * D.35268;
  int D.21958;
  int iftmp.577;
  int D.21954;
  const char[18] * D.35275;
  unsigned char D.35276;
  int D.35277;
  unsigned char D.35278;
  int D.35279;
  const unsigned char * D.35284;
  unsigned char D.35285;
  int D.35286;
  const unsigned char * D.35287;
  unsigned char D.35288;
  int D.35289;
  const unsigned char * D.35294;
  unsigned char D.35295;
  int D.35296;
  const unsigned char * D.35297;
  unsigned char D.35298;
  int D.35299;
  const unsigned char * D.35304;
  unsigned char D.35305;
  int D.35306;
  const unsigned char * D.35307;
  unsigned char D.35308;
  int D.35309;
  int D.21967;
  int iftmp.578;
  int D.21963;
  const char[19] * D.35315;
  unsigned char D.35316;
  int D.35317;
  unsigned char D.35318;
  int D.35319;
  const unsigned char * D.35324;
  unsigned char D.35325;
  int D.35326;
  const unsigned char * D.35327;
  unsigned char D.35328;
  int D.35329;
  const unsigned char * D.35334;
  unsigned char D.35335;
  int D.35336;
  const unsigned char * D.35337;
  unsigned char D.35338;
  int D.35339;
  const unsigned char * D.35344;
  unsigned char D.35345;
  int D.35346;
  const unsigned char * D.35347;
  unsigned char D.35348;
  int D.35349;
  struct MonoMethod * D.35351;
  int D.21977;
  int iftmp.579;
  int D.21973;
  const char[14] * D.35358;
  unsigned char D.35359;
  int D.35360;
  unsigned char D.35361;
  int D.35362;
  const unsigned char * D.35367;
  unsigned char D.35368;
  int D.35369;
  const unsigned char * D.35370;
  unsigned char D.35371;
  int D.35372;
  const unsigned char * D.35377;
  unsigned char D.35378;
  int D.35379;
  const unsigned char * D.35380;
  unsigned char D.35381;
  int D.35382;
  const unsigned char * D.35387;
  unsigned char D.35388;
  int D.35389;
  const unsigned char * D.35390;
  unsigned char D.35391;
  int D.35392;
  int D.21986;
  int iftmp.580;
  int D.21982;
  const char[18] * D.35398;
  unsigned char D.35399;
  int D.35400;
  unsigned char D.35401;
  int D.35402;
  const unsigned char * D.35407;
  unsigned char D.35408;
  int D.35409;
  const unsigned char * D.35410;
  unsigned char D.35411;
  int D.35412;
  const unsigned char * D.35417;
  unsigned char D.35418;
  int D.35419;
  const unsigned char * D.35420;
  unsigned char D.35421;
  int D.35422;
  const unsigned char * D.35427;
  unsigned char D.35428;
  int D.35429;
  const unsigned char * D.35430;
  unsigned char D.35431;
  int D.35432;
  struct MonoObject * D.35434;
  struct MonoVTable * D.35435;
  int D.35436;
  struct MonoMethod * D.35439;
  int D.35440;
  int D.35441;
  unsigned int D.35442;
  int D.35444;
  struct MonoProperty * D.35447;
  _Bool D.35450;
  long int D.35451;
  long int D.35452;
  int D.35456;
  int D.35460;
  struct MonoObject * D.35463;
  struct MonoVTable * D.35464;
  struct MonoClass * D.35465;
  int D.35466;
  int D.35470;
  char * D.35474;
  int D.22007;
  int iftmp.581;
  int D.22003;
  const char[16] * D.35479;
  unsigned char D.35480;
  int D.35481;
  unsigned char D.35482;
  int D.35483;
  const unsigned char * D.35488;
  unsigned char D.35489;
  int D.35490;
  const unsigned char * D.35491;
  unsigned char D.35492;
  int D.35493;
  const unsigned char * D.35498;
  unsigned char D.35499;
  int D.35500;
  const unsigned char * D.35501;
  unsigned char D.35502;
  int D.35503;
  const unsigned char * D.35508;
  unsigned char D.35509;
  int D.35510;
  const unsigned char * D.35511;
  unsigned char D.35512;
  int D.35513;
  struct MonoAssembly * D.35517;
  struct MonoImage * D.35518;
  struct MonoArray * D.35519;
  int D.22017;
  int iftmp.582;
  int D.22013;
  const char[12] * D.35524;
  unsigned char D.35525;
  int D.35526;
  unsigned char D.35527;
  int D.35528;
  const unsigned char * D.35533;
  unsigned char D.35534;
  int D.35535;
  const unsigned char * D.35536;
  unsigned char D.35537;
  int D.35538;
  const unsigned char * D.35543;
  unsigned char D.35544;
  int D.35545;
  const unsigned char * D.35546;
  unsigned char D.35547;
  int D.35548;
  const unsigned char * D.35553;
  unsigned char D.35554;
  int D.35555;
  const unsigned char * D.35556;
  unsigned char D.35557;
  int D.35558;
  struct MonoReflectionModuleBuilder * D.35562;
  struct MonoDynamicImage * D.35563;
  struct MonoImage * D.35564;
  struct MonoArray * D.35565;
  int D.22027;
  int iftmp.583;
  int D.22023;
  const char[14] * D.35570;
  unsigned char D.35571;
  int D.35572;
  unsigned char D.35573;
  int D.35574;
  const unsigned char * D.35579;
  unsigned char D.35580;
  int D.35581;
  const unsigned char * D.35582;
  unsigned char D.35583;
  int D.35584;
  const unsigned char * D.35589;
  unsigned char D.35590;
  int D.35591;
  const unsigned char * D.35592;
  unsigned char D.35593;
  int D.35594;
  const unsigned char * D.35599;
  unsigned char D.35600;
  int D.35601;
  const unsigned char * D.35602;
  unsigned char D.35603;
  int D.35604;
  struct MonoDynamicImage * D.35608;
  struct MonoImage * D.35609;
  struct MonoArray * D.35610;
  int D.22037;
  int iftmp.584;
  int D.22033;
  const char[19] * D.35615;
  unsigned char D.35616;
  int D.35617;
  unsigned char D.35618;
  int D.35619;
  const unsigned char * D.35624;
  unsigned char D.35625;
  int D.35626;
  const unsigned char * D.35627;
  unsigned char D.35628;
  int D.35629;
  const unsigned char * D.35634;
  unsigned char D.35635;
  int D.35636;
  const unsigned char * D.35637;
  unsigned char D.35638;
  int D.35639;
  const unsigned char * D.35644;
  unsigned char D.35645;
  int D.35646;
  const unsigned char * D.35647;
  unsigned char D.35648;
  int D.35649;
  struct MonoMethod * D.35653;
  struct MonoClass * D.35654;
  struct MonoImage * D.35655;
  struct MonoArray * D.35656;
  int D.22047;
  int iftmp.585;
  int D.22043;
  const char[14] * D.35661;
  unsigned char D.35662;
  int D.35663;
  unsigned char D.35664;
  int D.35665;
  const unsigned char * D.35670;
  unsigned char D.35671;
  int D.35672;
  const unsigned char * D.35673;
  unsigned char D.35674;
  int D.35675;
  const unsigned char * D.35680;
  unsigned char D.35681;
  int D.35682;
  const unsigned char * D.35683;
  unsigned char D.35684;
  int D.35685;
  const unsigned char * D.35690;
  unsigned char D.35691;
  int D.35692;
  const unsigned char * D.35693;
  unsigned char D.35694;
  int D.35695;
  struct MonoMethod * D.35699;
  struct MonoClass * D.35700;
  struct MonoImage * D.35701;
  struct MonoArray * D.35702;
  int D.22057;
  int iftmp.586;
  int D.22053;
  const char[13] * D.35707;
  unsigned char D.35708;
  int D.35709;
  unsigned char D.35710;
  int D.35711;
  const unsigned char * D.35716;
  unsigned char D.35717;
  int D.35718;
  const unsigned char * D.35719;
  unsigned char D.35720;
  int D.35721;
  const unsigned char * D.35726;
  unsigned char D.35727;
  int D.35728;
  const unsigned char * D.35729;
  unsigned char D.35730;
  int D.35731;
  const unsigned char * D.35736;
  unsigned char D.35737;
  int D.35738;
  const unsigned char * D.35739;
  unsigned char D.35740;
  int D.35741;
  struct MonoReflectionType * D.35745;
  struct MonoReflectionModuleBuilder * D.35746;
  struct MonoDynamicImage * D.35747;
  struct MonoImage * D.35748;
  struct MonoArray * D.35749;
  int D.22067;
  int iftmp.587;
  int D.22063;
  const char[17] * D.35754;
  unsigned char D.35755;
  int D.35756;
  unsigned char D.35757;
  int D.35758;
  const unsigned char * D.35763;
  unsigned char D.35764;
  int D.35765;
  const unsigned char * D.35766;
  unsigned char D.35767;
  int D.35768;
  const unsigned char * D.35773;
  unsigned char D.35774;
  int D.35775;
  const unsigned char * D.35776;
  unsigned char D.35777;
  int D.35778;
  const unsigned char * D.35783;
  unsigned char D.35784;
  int D.35785;
  const unsigned char * D.35786;
  unsigned char D.35787;
  int D.35788;
  struct MonoReflectionType * D.35792;
  struct MonoCustomAttrInfo * D.35794;
  struct MonoClass * klass;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = 0B;
  D.34882 = obj->vtable;
  klass = D.34882->klass;
  D.34883 = mono_defaults.monotype_class;
  if (D.34883 == klass) goto <D.34884>; else goto <D.34885>;
  <D.34884>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    klass = mono_class_from_mono_type (type);
    cinfo = mono_custom_attrs_from_class (klass);
  }
  goto <D.34886>;
  <D.34885>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.34891>; else goto <D.34892>;
    <D.34891>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.34893 = "Assembly";
      D.34894 = MEM[(const unsigned char *)D.34893];
      D.34895 = (int) D.34894;
      D.34896 = *__s2;
      D.34897 = (int) D.34896;
      __result = D.34895 - D.34897;
      {
        if (__s1_len != 0) goto <D.34898>; else goto <D.34899>;
        <D.34898>:
        if (__result == 0) goto <D.34900>; else goto <D.34901>;
        <D.34900>:
        D.34902 = &MEM[(void *)"Assembly" + 1B];
        D.34903 = *D.34902;
        D.34904 = (int) D.34903;
        D.34905 = __s2 + 1;
        D.34906 = *D.34905;
        D.34907 = (int) D.34906;
        __result = D.34904 - D.34907;
        if (__s1_len > 1) goto <D.34908>; else goto <D.34909>;
        <D.34908>:
        if (__result == 0) goto <D.34910>; else goto <D.34911>;
        <D.34910>:
        D.34912 = &MEM[(void *)"Assembly" + 2B];
        D.34913 = *D.34912;
        D.34914 = (int) D.34913;
        D.34915 = __s2 + 2;
        D.34916 = *D.34915;
        D.34917 = (int) D.34916;
        __result = D.34914 - D.34917;
        if (__s1_len > 2) goto <D.34918>; else goto <D.34919>;
        <D.34918>:
        if (__result == 0) goto <D.34920>; else goto <D.34921>;
        <D.34920>:
        D.34922 = &MEM[(void *)"Assembly" + 3B];
        D.34923 = *D.34922;
        D.34924 = (int) D.34923;
        D.34925 = __s2 + 3;
        D.34926 = *D.34925;
        D.34927 = (int) D.34926;
        __result = D.34924 - D.34927;
        <D.34921>:
        <D.34919>:
        <D.34911>:
        <D.34909>:
        <D.34901>:
        <D.34899>:
      }
      D.21867 = __result;
    }
    iftmp.568 = D.21867;
    goto <D.34928>;
    <D.34892>:
    D.34929 = klass->name;
    iftmp.568 = __builtin_strcmp ("Assembly", D.34929);
    <D.34928>:
    D.21871 = iftmp.568;
  }
  if (D.21871 == 0) goto <D.34887>; else goto <D.34930>;
  <D.34930>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34934 = "MonoAssembly";
      D.34935 = MEM[(const unsigned char *)D.34934];
      D.34936 = (int) D.34935;
      D.34937 = *__s2;
      D.34938 = (int) D.34937;
      __result = D.34936 - D.34938;
      {
        if (__s1_len != 0) goto <D.34939>; else goto <D.34940>;
        <D.34939>:
        if (__result == 0) goto <D.34941>; else goto <D.34942>;
        <D.34941>:
        D.34943 = &MEM[(void *)"MonoAssembly" + 1B];
        D.34944 = *D.34943;
        D.34945 = (int) D.34944;
        D.34946 = __s2 + 1;
        D.34947 = *D.34946;
        D.34948 = (int) D.34947;
        __result = D.34945 - D.34948;
        if (__s1_len > 1) goto <D.34949>; else goto <D.34950>;
        <D.34949>:
        if (__result == 0) goto <D.34951>; else goto <D.34952>;
        <D.34951>:
        D.34953 = &MEM[(void *)"MonoAssembly" + 2B];
        D.34954 = *D.34953;
        D.34955 = (int) D.34954;
        D.34956 = __s2 + 2;
        D.34957 = *D.34956;
        D.34958 = (int) D.34957;
        __result = D.34955 - D.34958;
        if (__s1_len > 2) goto <D.34959>; else goto <D.34960>;
        <D.34959>:
        if (__result == 0) goto <D.34961>; else goto <D.34962>;
        <D.34961>:
        D.34963 = &MEM[(void *)"MonoAssembly" + 3B];
        D.34964 = *D.34963;
        D.34965 = (int) D.34964;
        D.34966 = __s2 + 3;
        D.34967 = *D.34966;
        D.34968 = (int) D.34967;
        __result = D.34965 - D.34968;
        <D.34962>:
        <D.34960>:
        <D.34952>:
        <D.34950>:
        <D.34942>:
        <D.34940>:
      }
      D.21876 = __result;
    }
    iftmp.569 = D.21876;
    goto <D.34969>;
    <D.34933>:
    D.34929 = klass->name;
    iftmp.569 = __builtin_strcmp ("MonoAssembly", D.34929);
    <D.34969>:
    D.21880 = iftmp.569;
  }
  if (D.21880 == 0) goto <D.34887>; else goto <D.34888>;
  <D.34887>:
  {
    struct MonoReflectionAssembly * rassembly;

    rassembly = obj;
    D.34970 = rassembly->assembly;
    cinfo = mono_custom_attrs_from_assembly (D.34970);
  }
  goto <D.34889>;
  <D.34888>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34977 = "Module";
      D.34978 = MEM[(const unsigned char *)D.34977];
      D.34979 = (int) D.34978;
      D.34980 = *__s2;
      D.34981 = (int) D.34980;
      __result = D.34979 - D.34981;
      {
        if (__s1_len != 0) goto <D.34982>; else goto <D.34983>;
        <D.34982>:
        if (__result == 0) goto <D.34984>; else goto <D.34985>;
        <D.34984>:
        D.34986 = &MEM[(void *)"Module" + 1B];
        D.34987 = *D.34986;
        D.34988 = (int) D.34987;
        D.34989 = __s2 + 1;
        D.34990 = *D.34989;
        D.34991 = (int) D.34990;
        __result = D.34988 - D.34991;
        if (__s1_len > 1) goto <D.34992>; else goto <D.34993>;
        <D.34992>:
        if (__result == 0) goto <D.34994>; else goto <D.34995>;
        <D.34994>:
        D.34996 = &MEM[(void *)"Module" + 2B];
        D.34997 = *D.34996;
        D.34998 = (int) D.34997;
        D.34999 = __s2 + 2;
        D.35000 = *D.34999;
        D.35001 = (int) D.35000;
        __result = D.34998 - D.35001;
        if (__s1_len > 2) goto <D.35002>; else goto <D.35003>;
        <D.35002>:
        if (__result == 0) goto <D.35004>; else goto <D.35005>;
        <D.35004>:
        D.35006 = &MEM[(void *)"Module" + 3B];
        D.35007 = *D.35006;
        D.35008 = (int) D.35007;
        D.35009 = __s2 + 3;
        D.35010 = *D.35009;
        D.35011 = (int) D.35010;
        __result = D.35008 - D.35011;
        <D.35005>:
        <D.35003>:
        <D.34995>:
        <D.34993>:
        <D.34985>:
        <D.34983>:
      }
      D.21886 = __result;
    }
    iftmp.570 = D.21886;
    goto <D.35012>;
    <D.34976>:
    D.34929 = klass->name;
    iftmp.570 = __builtin_strcmp ("Module", D.34929);
    <D.35012>:
    D.21890 = iftmp.570;
  }
  if (D.21890 == 0) goto <D.34971>; else goto <D.35013>;
  <D.35013>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 10;
    if (__s1_len <= 3) goto <D.35015>; else goto <D.35016>;
    <D.35015>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35017 = "MonoModule";
      D.35018 = MEM[(const unsigned char *)D.35017];
      D.35019 = (int) D.35018;
      D.35020 = *__s2;
      D.35021 = (int) D.35020;
      __result = D.35019 - D.35021;
      {
        if (__s1_len != 0) goto <D.35022>; else goto <D.35023>;
        <D.35022>:
        if (__result == 0) goto <D.35024>; else goto <D.35025>;
        <D.35024>:
        D.35026 = &MEM[(void *)"MonoModule" + 1B];
        D.35027 = *D.35026;
        D.35028 = (int) D.35027;
        D.35029 = __s2 + 1;
        D.35030 = *D.35029;
        D.35031 = (int) D.35030;
        __result = D.35028 - D.35031;
        if (__s1_len > 1) goto <D.35032>; else goto <D.35033>;
        <D.35032>:
        if (__result == 0) goto <D.35034>; else goto <D.35035>;
        <D.35034>:
        D.35036 = &MEM[(void *)"MonoModule" + 2B];
        D.35037 = *D.35036;
        D.35038 = (int) D.35037;
        D.35039 = __s2 + 2;
        D.35040 = *D.35039;
        D.35041 = (int) D.35040;
        __result = D.35038 - D.35041;
        if (__s1_len > 2) goto <D.35042>; else goto <D.35043>;
        <D.35042>:
        if (__result == 0) goto <D.35044>; else goto <D.35045>;
        <D.35044>:
        D.35046 = &MEM[(void *)"MonoModule" + 3B];
        D.35047 = *D.35046;
        D.35048 = (int) D.35047;
        D.35049 = __s2 + 3;
        D.35050 = *D.35049;
        D.35051 = (int) D.35050;
        __result = D.35048 - D.35051;
        <D.35045>:
        <D.35043>:
        <D.35035>:
        <D.35033>:
        <D.35025>:
        <D.35023>:
      }
      D.21895 = __result;
    }
    iftmp.571 = D.21895;
    goto <D.35052>;
    <D.35016>:
    D.34929 = klass->name;
    iftmp.571 = __builtin_strcmp ("MonoModule", D.34929);
    <D.35052>:
    D.21899 = iftmp.571;
  }
  if (D.21899 == 0) goto <D.34971>; else goto <D.34972>;
  <D.34971>:
  {
    struct MonoReflectionModule * module;

    module = obj;
    D.35053 = module->image;
    cinfo = mono_custom_attrs_from_module (D.35053);
  }
  goto <D.34973>;
  <D.34972>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35057 = "MonoProperty";
      D.35058 = MEM[(const unsigned char *)D.35057];
      D.35059 = (int) D.35058;
      D.35060 = *__s2;
      D.35061 = (int) D.35060;
      __result = D.35059 - D.35061;
      {
        if (__s1_len != 0) goto <D.35062>; else goto <D.35063>;
        <D.35062>:
        if (__result == 0) goto <D.35064>; else goto <D.35065>;
        <D.35064>:
        D.35066 = &MEM[(void *)"MonoProperty" + 1B];
        D.35067 = *D.35066;
        D.35068 = (int) D.35067;
        D.35069 = __s2 + 1;
        D.35070 = *D.35069;
        D.35071 = (int) D.35070;
        __result = D.35068 - D.35071;
        if (__s1_len > 1) goto <D.35072>; else goto <D.35073>;
        <D.35072>:
        if (__result == 0) goto <D.35074>; else goto <D.35075>;
        <D.35074>:
        D.35076 = &MEM[(void *)"MonoProperty" + 2B];
        D.35077 = *D.35076;
        D.35078 = (int) D.35077;
        D.35079 = __s2 + 2;
        D.35080 = *D.35079;
        D.35081 = (int) D.35080;
        __result = D.35078 - D.35081;
        if (__s1_len > 2) goto <D.35082>; else goto <D.35083>;
        <D.35082>:
        if (__result == 0) goto <D.35084>; else goto <D.35085>;
        <D.35084>:
        D.35086 = &MEM[(void *)"MonoProperty" + 3B];
        D.35087 = *D.35086;
        D.35088 = (int) D.35087;
        D.35089 = __s2 + 3;
        D.35090 = *D.35089;
        D.35091 = (int) D.35090;
        __result = D.35088 - D.35091;
        <D.35085>:
        <D.35083>:
        <D.35075>:
        <D.35073>:
        <D.35065>:
        <D.35063>:
      }
      D.21905 = __result;
    }
    iftmp.572 = D.21905;
    goto <D.35092>;
    <D.35056>:
    D.34929 = klass->name;
    iftmp.572 = __builtin_strcmp ("MonoProperty", D.34929);
    <D.35092>:
    D.21909 = iftmp.572;
  }
  if (D.21909 == 0) goto <D.35093>; else goto <D.35094>;
  <D.35093>:
  {
    struct MonoReflectionProperty * rprop;

    rprop = obj;
    D.35095 = rprop->property;
    D.35096 = D.35095->parent;
    D.35095 = rprop->property;
    cinfo = mono_custom_attrs_from_property (D.35096, D.35095);
  }
  goto <D.35097>;
  <D.35094>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.35099>; else goto <D.35100>;
    <D.35099>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35101 = "MonoEvent";
      D.35102 = MEM[(const unsigned char *)D.35101];
      D.35103 = (int) D.35102;
      D.35104 = *__s2;
      D.35105 = (int) D.35104;
      __result = D.35103 - D.35105;
      {
        if (__s1_len != 0) goto <D.35106>; else goto <D.35107>;
        <D.35106>:
        if (__result == 0) goto <D.35108>; else goto <D.35109>;
        <D.35108>:
        D.35110 = &MEM[(void *)"MonoEvent" + 1B];
        D.35111 = *D.35110;
        D.35112 = (int) D.35111;
        D.35113 = __s2 + 1;
        D.35114 = *D.35113;
        D.35115 = (int) D.35114;
        __result = D.35112 - D.35115;
        if (__s1_len > 1) goto <D.35116>; else goto <D.35117>;
        <D.35116>:
        if (__result == 0) goto <D.35118>; else goto <D.35119>;
        <D.35118>:
        D.35120 = &MEM[(void *)"MonoEvent" + 2B];
        D.35121 = *D.35120;
        D.35122 = (int) D.35121;
        D.35123 = __s2 + 2;
        D.35124 = *D.35123;
        D.35125 = (int) D.35124;
        __result = D.35122 - D.35125;
        if (__s1_len > 2) goto <D.35126>; else goto <D.35127>;
        <D.35126>:
        if (__result == 0) goto <D.35128>; else goto <D.35129>;
        <D.35128>:
        D.35130 = &MEM[(void *)"MonoEvent" + 3B];
        D.35131 = *D.35130;
        D.35132 = (int) D.35131;
        D.35133 = __s2 + 3;
        D.35134 = *D.35133;
        D.35135 = (int) D.35134;
        __result = D.35132 - D.35135;
        <D.35129>:
        <D.35127>:
        <D.35119>:
        <D.35117>:
        <D.35109>:
        <D.35107>:
      }
      D.21915 = __result;
    }
    iftmp.573 = D.21915;
    goto <D.35136>;
    <D.35100>:
    D.34929 = klass->name;
    iftmp.573 = __builtin_strcmp ("MonoEvent", D.34929);
    <D.35136>:
    D.21919 = iftmp.573;
  }
  if (D.21919 == 0) goto <D.35137>; else goto <D.35138>;
  <D.35137>:
  {
    struct MonoReflectionMonoEvent * revent;

    revent = obj;
    D.35139 = revent->event;
    D.35140 = D.35139->parent;
    D.35139 = revent->event;
    cinfo = mono_custom_attrs_from_event (D.35140, D.35139);
  }
  goto <D.35141>;
  <D.35138>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 9;
    if (__s1_len <= 3) goto <D.35143>; else goto <D.35144>;
    <D.35143>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35145 = "MonoField";
      D.35146 = MEM[(const unsigned char *)D.35145];
      D.35147 = (int) D.35146;
      D.35148 = *__s2;
      D.35149 = (int) D.35148;
      __result = D.35147 - D.35149;
      {
        if (__s1_len != 0) goto <D.35150>; else goto <D.35151>;
        <D.35150>:
        if (__result == 0) goto <D.35152>; else goto <D.35153>;
        <D.35152>:
        D.35154 = &MEM[(void *)"MonoField" + 1B];
        D.35155 = *D.35154;
        D.35156 = (int) D.35155;
        D.35157 = __s2 + 1;
        D.35158 = *D.35157;
        D.35159 = (int) D.35158;
        __result = D.35156 - D.35159;
        if (__s1_len > 1) goto <D.35160>; else goto <D.35161>;
        <D.35160>:
        if (__result == 0) goto <D.35162>; else goto <D.35163>;
        <D.35162>:
        D.35164 = &MEM[(void *)"MonoField" + 2B];
        D.35165 = *D.35164;
        D.35166 = (int) D.35165;
        D.35167 = __s2 + 2;
        D.35168 = *D.35167;
        D.35169 = (int) D.35168;
        __result = D.35166 - D.35169;
        if (__s1_len > 2) goto <D.35170>; else goto <D.35171>;
        <D.35170>:
        if (__result == 0) goto <D.35172>; else goto <D.35173>;
        <D.35172>:
        D.35174 = &MEM[(void *)"MonoField" + 3B];
        D.35175 = *D.35174;
        D.35176 = (int) D.35175;
        D.35177 = __s2 + 3;
        D.35178 = *D.35177;
        D.35179 = (int) D.35178;
        __result = D.35176 - D.35179;
        <D.35173>:
        <D.35171>:
        <D.35163>:
        <D.35161>:
        <D.35153>:
        <D.35151>:
      }
      D.21925 = __result;
    }
    iftmp.574 = D.21925;
    goto <D.35180>;
    <D.35144>:
    D.34929 = klass->name;
    iftmp.574 = __builtin_strcmp ("MonoField", D.34929);
    <D.35180>:
    D.21929 = iftmp.574;
  }
  if (D.21929 == 0) goto <D.35181>; else goto <D.35182>;
  <D.35181>:
  {
    struct MonoReflectionField * rfield;

    rfield = obj;
    D.35183 = rfield->field;
    D.35184 = D.35183->parent;
    D.35183 = rfield->field;
    cinfo = mono_custom_attrs_from_field (D.35184, D.35183);
  }
  goto <D.35185>;
  <D.35182>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 10;
    if (__s1_len <= 3) goto <D.35190>; else goto <D.35191>;
    <D.35190>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35192 = "MonoMethod";
      D.35193 = MEM[(const unsigned char *)D.35192];
      D.35194 = (int) D.35193;
      D.35195 = *__s2;
      D.35196 = (int) D.35195;
      __result = D.35194 - D.35196;
      {
        if (__s1_len != 0) goto <D.35197>; else goto <D.35198>;
        <D.35197>:
        if (__result == 0) goto <D.35199>; else goto <D.35200>;
        <D.35199>:
        D.35201 = &MEM[(void *)"MonoMethod" + 1B];
        D.35202 = *D.35201;
        D.35203 = (int) D.35202;
        D.35204 = __s2 + 1;
        D.35205 = *D.35204;
        D.35206 = (int) D.35205;
        __result = D.35203 - D.35206;
        if (__s1_len > 1) goto <D.35207>; else goto <D.35208>;
        <D.35207>:
        if (__result == 0) goto <D.35209>; else goto <D.35210>;
        <D.35209>:
        D.35211 = &MEM[(void *)"MonoMethod" + 2B];
        D.35212 = *D.35211;
        D.35213 = (int) D.35212;
        D.35214 = __s2 + 2;
        D.35215 = *D.35214;
        D.35216 = (int) D.35215;
        __result = D.35213 - D.35216;
        if (__s1_len > 2) goto <D.35217>; else goto <D.35218>;
        <D.35217>:
        if (__result == 0) goto <D.35219>; else goto <D.35220>;
        <D.35219>:
        D.35221 = &MEM[(void *)"MonoMethod" + 3B];
        D.35222 = *D.35221;
        D.35223 = (int) D.35222;
        D.35224 = __s2 + 3;
        D.35225 = *D.35224;
        D.35226 = (int) D.35225;
        __result = D.35223 - D.35226;
        <D.35220>:
        <D.35218>:
        <D.35210>:
        <D.35208>:
        <D.35200>:
        <D.35198>:
      }
      D.21935 = __result;
    }
    iftmp.575 = D.21935;
    goto <D.35227>;
    <D.35191>:
    D.34929 = klass->name;
    iftmp.575 = __builtin_strcmp ("MonoMethod", D.34929);
    <D.35227>:
    D.21939 = iftmp.575;
  }
  if (D.21939 == 0) goto <D.35186>; else goto <D.35228>;
  <D.35228>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 11;
    if (__s1_len <= 3) goto <D.35230>; else goto <D.35231>;
    <D.35230>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35232 = "MonoCMethod";
      D.35233 = MEM[(const unsigned char *)D.35232];
      D.35234 = (int) D.35233;
      D.35235 = *__s2;
      D.35236 = (int) D.35235;
      __result = D.35234 - D.35236;
      {
        if (__s1_len != 0) goto <D.35237>; else goto <D.35238>;
        <D.35237>:
        if (__result == 0) goto <D.35239>; else goto <D.35240>;
        <D.35239>:
        D.35241 = &MEM[(void *)"MonoCMethod" + 1B];
        D.35242 = *D.35241;
        D.35243 = (int) D.35242;
        D.35244 = __s2 + 1;
        D.35245 = *D.35244;
        D.35246 = (int) D.35245;
        __result = D.35243 - D.35246;
        if (__s1_len > 1) goto <D.35247>; else goto <D.35248>;
        <D.35247>:
        if (__result == 0) goto <D.35249>; else goto <D.35250>;
        <D.35249>:
        D.35251 = &MEM[(void *)"MonoCMethod" + 2B];
        D.35252 = *D.35251;
        D.35253 = (int) D.35252;
        D.35254 = __s2 + 2;
        D.35255 = *D.35254;
        D.35256 = (int) D.35255;
        __result = D.35253 - D.35256;
        if (__s1_len > 2) goto <D.35257>; else goto <D.35258>;
        <D.35257>:
        if (__result == 0) goto <D.35259>; else goto <D.35260>;
        <D.35259>:
        D.35261 = &MEM[(void *)"MonoCMethod" + 3B];
        D.35262 = *D.35261;
        D.35263 = (int) D.35262;
        D.35264 = __s2 + 3;
        D.35265 = *D.35264;
        D.35266 = (int) D.35265;
        __result = D.35263 - D.35266;
        <D.35260>:
        <D.35258>:
        <D.35250>:
        <D.35248>:
        <D.35240>:
        <D.35238>:
      }
      D.21944 = __result;
    }
    iftmp.576 = D.21944;
    goto <D.35267>;
    <D.35231>:
    D.34929 = klass->name;
    iftmp.576 = __builtin_strcmp ("MonoCMethod", D.34929);
    <D.35267>:
    D.21948 = iftmp.576;
  }
  if (D.21948 == 0) goto <D.35186>; else goto <D.35187>;
  <D.35186>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.35268 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.35268);
  }
  goto <D.35188>;
  <D.35187>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 17;
    if (__s1_len <= 3) goto <D.35273>; else goto <D.35274>;
    <D.35273>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35275 = "MonoGenericMethod";
      D.35276 = MEM[(const unsigned char *)D.35275];
      D.35277 = (int) D.35276;
      D.35278 = *__s2;
      D.35279 = (int) D.35278;
      __result = D.35277 - D.35279;
      {
        if (__s1_len != 0) goto <D.35280>; else goto <D.35281>;
        <D.35280>:
        if (__result == 0) goto <D.35282>; else goto <D.35283>;
        <D.35282>:
        D.35284 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.35285 = *D.35284;
        D.35286 = (int) D.35285;
        D.35287 = __s2 + 1;
        D.35288 = *D.35287;
        D.35289 = (int) D.35288;
        __result = D.35286 - D.35289;
        if (__s1_len > 1) goto <D.35290>; else goto <D.35291>;
        <D.35290>:
        if (__result == 0) goto <D.35292>; else goto <D.35293>;
        <D.35292>:
        D.35294 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.35295 = *D.35294;
        D.35296 = (int) D.35295;
        D.35297 = __s2 + 2;
        D.35298 = *D.35297;
        D.35299 = (int) D.35298;
        __result = D.35296 - D.35299;
        if (__s1_len > 2) goto <D.35300>; else goto <D.35301>;
        <D.35300>:
        if (__result == 0) goto <D.35302>; else goto <D.35303>;
        <D.35302>:
        D.35304 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.35305 = *D.35304;
        D.35306 = (int) D.35305;
        D.35307 = __s2 + 3;
        D.35308 = *D.35307;
        D.35309 = (int) D.35308;
        __result = D.35306 - D.35309;
        <D.35303>:
        <D.35301>:
        <D.35293>:
        <D.35291>:
        <D.35283>:
        <D.35281>:
      }
      D.21954 = __result;
    }
    iftmp.577 = D.21954;
    goto <D.35310>;
    <D.35274>:
    D.34929 = klass->name;
    iftmp.577 = __builtin_strcmp ("MonoGenericMethod", D.34929);
    <D.35310>:
    D.21958 = iftmp.577;
  }
  if (D.21958 == 0) goto <D.35269>; else goto <D.35311>;
  <D.35311>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 18;
    if (__s1_len <= 3) goto <D.35313>; else goto <D.35314>;
    <D.35313>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35315 = "MonoGenericCMethod";
      D.35316 = MEM[(const unsigned char *)D.35315];
      D.35317 = (int) D.35316;
      D.35318 = *__s2;
      D.35319 = (int) D.35318;
      __result = D.35317 - D.35319;
      {
        if (__s1_len != 0) goto <D.35320>; else goto <D.35321>;
        <D.35320>:
        if (__result == 0) goto <D.35322>; else goto <D.35323>;
        <D.35322>:
        D.35324 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.35325 = *D.35324;
        D.35326 = (int) D.35325;
        D.35327 = __s2 + 1;
        D.35328 = *D.35327;
        D.35329 = (int) D.35328;
        __result = D.35326 - D.35329;
        if (__s1_len > 1) goto <D.35330>; else goto <D.35331>;
        <D.35330>:
        if (__result == 0) goto <D.35332>; else goto <D.35333>;
        <D.35332>:
        D.35334 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.35335 = *D.35334;
        D.35336 = (int) D.35335;
        D.35337 = __s2 + 2;
        D.35338 = *D.35337;
        D.35339 = (int) D.35338;
        __result = D.35336 - D.35339;
        if (__s1_len > 2) goto <D.35340>; else goto <D.35341>;
        <D.35340>:
        if (__result == 0) goto <D.35342>; else goto <D.35343>;
        <D.35342>:
        D.35344 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.35345 = *D.35344;
        D.35346 = (int) D.35345;
        D.35347 = __s2 + 3;
        D.35348 = *D.35347;
        D.35349 = (int) D.35348;
        __result = D.35346 - D.35349;
        <D.35343>:
        <D.35341>:
        <D.35333>:
        <D.35331>:
        <D.35323>:
        <D.35321>:
      }
      D.21963 = __result;
    }
    iftmp.578 = D.21963;
    goto <D.35350>;
    <D.35314>:
    D.34929 = klass->name;
    iftmp.578 = __builtin_strcmp ("MonoGenericCMethod", D.34929);
    <D.35350>:
    D.21967 = iftmp.578;
  }
  if (D.21967 == 0) goto <D.35269>; else goto <D.35270>;
  <D.35269>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.35351 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.35351);
  }
  goto <D.35271>;
  <D.35270>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 13;
    if (__s1_len <= 3) goto <D.35356>; else goto <D.35357>;
    <D.35356>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35358 = "ParameterInfo";
      D.35359 = MEM[(const unsigned char *)D.35358];
      D.35360 = (int) D.35359;
      D.35361 = *__s2;
      D.35362 = (int) D.35361;
      __result = D.35360 - D.35362;
      {
        if (__s1_len != 0) goto <D.35363>; else goto <D.35364>;
        <D.35363>:
        if (__result == 0) goto <D.35365>; else goto <D.35366>;
        <D.35365>:
        D.35367 = &MEM[(void *)"ParameterInfo" + 1B];
        D.35368 = *D.35367;
        D.35369 = (int) D.35368;
        D.35370 = __s2 + 1;
        D.35371 = *D.35370;
        D.35372 = (int) D.35371;
        __result = D.35369 - D.35372;
        if (__s1_len > 1) goto <D.35373>; else goto <D.35374>;
        <D.35373>:
        if (__result == 0) goto <D.35375>; else goto <D.35376>;
        <D.35375>:
        D.35377 = &MEM[(void *)"ParameterInfo" + 2B];
        D.35378 = *D.35377;
        D.35379 = (int) D.35378;
        D.35380 = __s2 + 2;
        D.35381 = *D.35380;
        D.35382 = (int) D.35381;
        __result = D.35379 - D.35382;
        if (__s1_len > 2) goto <D.35383>; else goto <D.35384>;
        <D.35383>:
        if (__result == 0) goto <D.35385>; else goto <D.35386>;
        <D.35385>:
        D.35387 = &MEM[(void *)"ParameterInfo" + 3B];
        D.35388 = *D.35387;
        D.35389 = (int) D.35388;
        D.35390 = __s2 + 3;
        D.35391 = *D.35390;
        D.35392 = (int) D.35391;
        __result = D.35389 - D.35392;
        <D.35386>:
        <D.35384>:
        <D.35376>:
        <D.35374>:
        <D.35366>:
        <D.35364>:
      }
      D.21973 = __result;
    }
    iftmp.579 = D.21973;
    goto <D.35393>;
    <D.35357>:
    D.34929 = klass->name;
    iftmp.579 = __builtin_strcmp ("ParameterInfo", D.34929);
    <D.35393>:
    D.21977 = iftmp.579;
  }
  if (D.21977 == 0) goto <D.35352>; else goto <D.35394>;
  <D.35394>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 17;
    if (__s1_len <= 3) goto <D.35396>; else goto <D.35397>;
    <D.35396>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35398 = "MonoParameterInfo";
      D.35399 = MEM[(const unsigned char *)D.35398];
      D.35400 = (int) D.35399;
      D.35401 = *__s2;
      D.35402 = (int) D.35401;
      __result = D.35400 - D.35402;
      {
        if (__s1_len != 0) goto <D.35403>; else goto <D.35404>;
        <D.35403>:
        if (__result == 0) goto <D.35405>; else goto <D.35406>;
        <D.35405>:
        D.35407 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.35408 = *D.35407;
        D.35409 = (int) D.35408;
        D.35410 = __s2 + 1;
        D.35411 = *D.35410;
        D.35412 = (int) D.35411;
        __result = D.35409 - D.35412;
        if (__s1_len > 1) goto <D.35413>; else goto <D.35414>;
        <D.35413>:
        if (__result == 0) goto <D.35415>; else goto <D.35416>;
        <D.35415>:
        D.35417 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.35418 = *D.35417;
        D.35419 = (int) D.35418;
        D.35420 = __s2 + 2;
        D.35421 = *D.35420;
        D.35422 = (int) D.35421;
        __result = D.35419 - D.35422;
        if (__s1_len > 2) goto <D.35423>; else goto <D.35424>;
        <D.35423>:
        if (__result == 0) goto <D.35425>; else goto <D.35426>;
        <D.35425>:
        D.35427 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.35428 = *D.35427;
        D.35429 = (int) D.35428;
        D.35430 = __s2 + 3;
        D.35431 = *D.35430;
        D.35432 = (int) D.35431;
        __result = D.35429 - D.35432;
        <D.35426>:
        <D.35424>:
        <D.35416>:
        <D.35414>:
        <D.35406>:
        <D.35404>:
      }
      D.21982 = __result;
    }
    iftmp.580 = D.21982;
    goto <D.35433>;
    <D.35397>:
    D.34929 = klass->name;
    iftmp.580 = __builtin_strcmp ("MonoParameterInfo", D.34929);
    <D.35433>:
    D.21986 = iftmp.580;
  }
  if (D.21986 == 0) goto <D.35352>; else goto <D.35353>;
  <D.35352>:
  {
    struct MonoReflectionParameter * param;
    struct MonoClass * member_class;

    param = obj;
    D.35434 = param->MemberImpl;
    D.35435 = D.35434->vtable;
    member_class = D.35435->klass;
    D.35436 = mono_class_is_reflection_method_or_constructor (member_class);
    if (D.35436 != 0) goto <D.35437>; else goto <D.35438>;
    <D.35437>:
    {
      struct MonoReflectionMethod * rmethod;

      rmethod = param->MemberImpl;
      D.35439 = rmethod->method;
      D.35440 = param->PositionImpl;
      D.35441 = D.35440 + 1;
      D.35442 = (unsigned int) D.35441;
      cinfo = mono_custom_attrs_from_param (D.35439, D.35442);
    }
    goto <D.35443>;
    <D.35438>:
    D.35444 = is_sr_mono_property (member_class);
    if (D.35444 != 0) goto <D.35445>; else goto <D.35446>;
    <D.35445>:
    {
      struct MonoReflectionProperty * prop;
      struct MonoMethod * method;

      prop = param->MemberImpl;
      D.35447 = prop->property;
      method = D.35447->get;
      if (method == 0B) goto <D.35448>; else goto <D.35449>;
      <D.35448>:
      D.35447 = prop->property;
      method = D.35447->set;
      <D.35449>:
      D.35450 = method == 0B;
      D.35451 = (long int) D.35450;
      D.35452 = __builtin_expect (D.35451, 0);
      if (D.35452 != 0) goto <D.35453>; else goto <D.35454>;
      <D.35453>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8889, "method");
      <D.35454>:
      D.35440 = param->PositionImpl;
      D.35441 = D.35440 + 1;
      D.35442 = (unsigned int) D.35441;
      cinfo = mono_custom_attrs_from_param (method, D.35442);
    }
    goto <D.35455>;
    <D.35446>:
    D.35456 = is_sre_method_on_tb_inst (member_class);
    if (D.35456 != 0) goto <D.35457>; else goto <D.35458>;
    <D.35457>:
    {
      struct MonoMethod * method;

      D.35434 = param->MemberImpl;
      method = mono_reflection_method_on_tb_inst_get_handle (D.35434);
      D.35440 = param->PositionImpl;
      D.35441 = D.35440 + 1;
      D.35442 = (unsigned int) D.35441;
      cinfo = mono_custom_attrs_from_param (method, D.35442);
    }
    goto <D.35459>;
    <D.35458>:
    D.35460 = is_sre_ctor_on_tb_inst (member_class);
    if (D.35460 != 0) goto <D.35461>; else goto <D.35462>;
    <D.35461>:
    {
      struct MonoReflectionCtorOnTypeBuilderInst * c;
      struct MonoMethod * method;

      c = param->MemberImpl;
      method = 0B;
      D.35463 = c->cb;
      D.35464 = D.35463->vtable;
      D.35465 = D.35464->klass;
      D.35466 = is_sre_ctor_builder (D.35465);
      if (D.35466 != 0) goto <D.35467>; else goto <D.35468>;
      <D.35467>:
      D.35463 = c->cb;
      method = MEM[(struct MonoReflectionCtorBuilder *)D.35463].mhandle;
      goto <D.35469>;
      <D.35468>:
      D.35463 = c->cb;
      D.35464 = D.35463->vtable;
      D.35465 = D.35464->klass;
      D.35470 = is_sr_mono_cmethod (D.35465);
      if (D.35470 != 0) goto <D.35471>; else goto <D.35472>;
      <D.35471>:
      D.35463 = c->cb;
      method = MEM[(struct MonoReflectionMethod *)D.35463].method;
      goto <D.35473>;
      <D.35472>:
      D.35474 = mono_type_get_full_name (member_class);
      monoeg_g_log (0B, 4, "mono_reflection_get_custom_attrs_info:: can\'t handle a CTBI with base_method of type %s", D.35474);
      <D.21995>:
      goto <D.21995>;
      <D.35473>:
      <D.35469>:
      D.35440 = param->PositionImpl;
      D.35441 = D.35440 + 1;
      D.35442 = (unsigned int) D.35441;
      cinfo = mono_custom_attrs_from_param (method, D.35442);
    }
    goto <D.35475>;
    <D.35462>:
    {
      char * type_name;
      char * msg;
      struct MonoException * ex;

      type_name = mono_type_get_full_name (member_class);
      msg = monoeg_g_strdup_printf ("Custom attributes on a ParamInfo with member %s are not supported", type_name);
      ex = mono_get_exception_not_supported (msg);
      monoeg_g_free (type_name);
      monoeg_g_free (msg);
      mono_raise_exception (ex);
    }
    <D.35475>:
    <D.35459>:
    <D.35455>:
    <D.35443>:
  }
  goto <D.35354>;
  <D.35353>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 15;
    if (__s1_len <= 3) goto <D.35477>; else goto <D.35478>;
    <D.35477>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35479 = "AssemblyBuilder";
      D.35480 = MEM[(const unsigned char *)D.35479];
      D.35481 = (int) D.35480;
      D.35482 = *__s2;
      D.35483 = (int) D.35482;
      __result = D.35481 - D.35483;
      {
        if (__s1_len != 0) goto <D.35484>; else goto <D.35485>;
        <D.35484>:
        if (__result == 0) goto <D.35486>; else goto <D.35487>;
        <D.35486>:
        D.35488 = &MEM[(void *)"AssemblyBuilder" + 1B];
        D.35489 = *D.35488;
        D.35490 = (int) D.35489;
        D.35491 = __s2 + 1;
        D.35492 = *D.35491;
        D.35493 = (int) D.35492;
        __result = D.35490 - D.35493;
        if (__s1_len > 1) goto <D.35494>; else goto <D.35495>;
        <D.35494>:
        if (__result == 0) goto <D.35496>; else goto <D.35497>;
        <D.35496>:
        D.35498 = &MEM[(void *)"AssemblyBuilder" + 2B];
        D.35499 = *D.35498;
        D.35500 = (int) D.35499;
        D.35501 = __s2 + 2;
        D.35502 = *D.35501;
        D.35503 = (int) D.35502;
        __result = D.35500 - D.35503;
        if (__s1_len > 2) goto <D.35504>; else goto <D.35505>;
        <D.35504>:
        if (__result == 0) goto <D.35506>; else goto <D.35507>;
        <D.35506>:
        D.35508 = &MEM[(void *)"AssemblyBuilder" + 3B];
        D.35509 = *D.35508;
        D.35510 = (int) D.35509;
        D.35511 = __s2 + 3;
        D.35512 = *D.35511;
        D.35513 = (int) D.35512;
        __result = D.35510 - D.35513;
        <D.35507>:
        <D.35505>:
        <D.35497>:
        <D.35495>:
        <D.35487>:
        <D.35485>:
      }
      D.22003 = __result;
    }
    iftmp.581 = D.22003;
    goto <D.35514>;
    <D.35478>:
    D.34929 = klass->name;
    iftmp.581 = __builtin_strcmp ("AssemblyBuilder", D.34929);
    <D.35514>:
    D.22007 = iftmp.581;
  }
  if (D.22007 == 0) goto <D.35515>; else goto <D.35516>;
  <D.35515>:
  {
    struct MonoReflectionAssemblyBuilder * assemblyb;

    assemblyb = obj;
    D.35517 = assemblyb->assembly.assembly;
    D.35518 = D.35517->image;
    D.35519 = assemblyb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35518, D.35519);
  }
  goto <D.35520>;
  <D.35516>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 11;
    if (__s1_len <= 3) goto <D.35522>; else goto <D.35523>;
    <D.35522>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35524 = "TypeBuilder";
      D.35525 = MEM[(const unsigned char *)D.35524];
      D.35526 = (int) D.35525;
      D.35527 = *__s2;
      D.35528 = (int) D.35527;
      __result = D.35526 - D.35528;
      {
        if (__s1_len != 0) goto <D.35529>; else goto <D.35530>;
        <D.35529>:
        if (__result == 0) goto <D.35531>; else goto <D.35532>;
        <D.35531>:
        D.35533 = &MEM[(void *)"TypeBuilder" + 1B];
        D.35534 = *D.35533;
        D.35535 = (int) D.35534;
        D.35536 = __s2 + 1;
        D.35537 = *D.35536;
        D.35538 = (int) D.35537;
        __result = D.35535 - D.35538;
        if (__s1_len > 1) goto <D.35539>; else goto <D.35540>;
        <D.35539>:
        if (__result == 0) goto <D.35541>; else goto <D.35542>;
        <D.35541>:
        D.35543 = &MEM[(void *)"TypeBuilder" + 2B];
        D.35544 = *D.35543;
        D.35545 = (int) D.35544;
        D.35546 = __s2 + 2;
        D.35547 = *D.35546;
        D.35548 = (int) D.35547;
        __result = D.35545 - D.35548;
        if (__s1_len > 2) goto <D.35549>; else goto <D.35550>;
        <D.35549>:
        if (__result == 0) goto <D.35551>; else goto <D.35552>;
        <D.35551>:
        D.35553 = &MEM[(void *)"TypeBuilder" + 3B];
        D.35554 = *D.35553;
        D.35555 = (int) D.35554;
        D.35556 = __s2 + 3;
        D.35557 = *D.35556;
        D.35558 = (int) D.35557;
        __result = D.35555 - D.35558;
        <D.35552>:
        <D.35550>:
        <D.35542>:
        <D.35540>:
        <D.35532>:
        <D.35530>:
      }
      D.22013 = __result;
    }
    iftmp.582 = D.22013;
    goto <D.35559>;
    <D.35523>:
    D.34929 = klass->name;
    iftmp.582 = __builtin_strcmp ("TypeBuilder", D.34929);
    <D.35559>:
    D.22017 = iftmp.582;
  }
  if (D.22017 == 0) goto <D.35560>; else goto <D.35561>;
  <D.35560>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.35562 = tb->module;
    D.35563 = D.35562->dynamic_image;
    D.35564 = &D.35563->image;
    D.35565 = tb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35564, D.35565);
  }
  goto <D.35566>;
  <D.35561>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 13;
    if (__s1_len <= 3) goto <D.35568>; else goto <D.35569>;
    <D.35568>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35570 = "ModuleBuilder";
      D.35571 = MEM[(const unsigned char *)D.35570];
      D.35572 = (int) D.35571;
      D.35573 = *__s2;
      D.35574 = (int) D.35573;
      __result = D.35572 - D.35574;
      {
        if (__s1_len != 0) goto <D.35575>; else goto <D.35576>;
        <D.35575>:
        if (__result == 0) goto <D.35577>; else goto <D.35578>;
        <D.35577>:
        D.35579 = &MEM[(void *)"ModuleBuilder" + 1B];
        D.35580 = *D.35579;
        D.35581 = (int) D.35580;
        D.35582 = __s2 + 1;
        D.35583 = *D.35582;
        D.35584 = (int) D.35583;
        __result = D.35581 - D.35584;
        if (__s1_len > 1) goto <D.35585>; else goto <D.35586>;
        <D.35585>:
        if (__result == 0) goto <D.35587>; else goto <D.35588>;
        <D.35587>:
        D.35589 = &MEM[(void *)"ModuleBuilder" + 2B];
        D.35590 = *D.35589;
        D.35591 = (int) D.35590;
        D.35592 = __s2 + 2;
        D.35593 = *D.35592;
        D.35594 = (int) D.35593;
        __result = D.35591 - D.35594;
        if (__s1_len > 2) goto <D.35595>; else goto <D.35596>;
        <D.35595>:
        if (__result == 0) goto <D.35597>; else goto <D.35598>;
        <D.35597>:
        D.35599 = &MEM[(void *)"ModuleBuilder" + 3B];
        D.35600 = *D.35599;
        D.35601 = (int) D.35600;
        D.35602 = __s2 + 3;
        D.35603 = *D.35602;
        D.35604 = (int) D.35603;
        __result = D.35601 - D.35604;
        <D.35598>:
        <D.35596>:
        <D.35588>:
        <D.35586>:
        <D.35578>:
        <D.35576>:
      }
      D.22023 = __result;
    }
    iftmp.583 = D.22023;
    goto <D.35605>;
    <D.35569>:
    D.34929 = klass->name;
    iftmp.583 = __builtin_strcmp ("ModuleBuilder", D.34929);
    <D.35605>:
    D.22027 = iftmp.583;
  }
  if (D.22027 == 0) goto <D.35606>; else goto <D.35607>;
  <D.35606>:
  {
    struct MonoReflectionModuleBuilder * mb;

    mb = obj;
    D.35608 = mb->dynamic_image;
    D.35609 = &D.35608->image;
    D.35610 = mb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35609, D.35610);
  }
  goto <D.35611>;
  <D.35607>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 18;
    if (__s1_len <= 3) goto <D.35613>; else goto <D.35614>;
    <D.35613>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35615 = "ConstructorBuilder";
      D.35616 = MEM[(const unsigned char *)D.35615];
      D.35617 = (int) D.35616;
      D.35618 = *__s2;
      D.35619 = (int) D.35618;
      __result = D.35617 - D.35619;
      {
        if (__s1_len != 0) goto <D.35620>; else goto <D.35621>;
        <D.35620>:
        if (__result == 0) goto <D.35622>; else goto <D.35623>;
        <D.35622>:
        D.35624 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.35625 = *D.35624;
        D.35626 = (int) D.35625;
        D.35627 = __s2 + 1;
        D.35628 = *D.35627;
        D.35629 = (int) D.35628;
        __result = D.35626 - D.35629;
        if (__s1_len > 1) goto <D.35630>; else goto <D.35631>;
        <D.35630>:
        if (__result == 0) goto <D.35632>; else goto <D.35633>;
        <D.35632>:
        D.35634 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.35635 = *D.35634;
        D.35636 = (int) D.35635;
        D.35637 = __s2 + 2;
        D.35638 = *D.35637;
        D.35639 = (int) D.35638;
        __result = D.35636 - D.35639;
        if (__s1_len > 2) goto <D.35640>; else goto <D.35641>;
        <D.35640>:
        if (__result == 0) goto <D.35642>; else goto <D.35643>;
        <D.35642>:
        D.35644 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.35645 = *D.35644;
        D.35646 = (int) D.35645;
        D.35647 = __s2 + 3;
        D.35648 = *D.35647;
        D.35649 = (int) D.35648;
        __result = D.35646 - D.35649;
        <D.35643>:
        <D.35641>:
        <D.35633>:
        <D.35631>:
        <D.35623>:
        <D.35621>:
      }
      D.22033 = __result;
    }
    iftmp.584 = D.22033;
    goto <D.35650>;
    <D.35614>:
    D.34929 = klass->name;
    iftmp.584 = __builtin_strcmp ("ConstructorBuilder", D.34929);
    <D.35650>:
    D.22037 = iftmp.584;
  }
  if (D.22037 == 0) goto <D.35651>; else goto <D.35652>;
  <D.35651>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    D.35653 = cb->mhandle;
    D.35654 = D.35653->klass;
    D.35655 = D.35654->image;
    D.35656 = cb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35655, D.35656);
  }
  goto <D.35657>;
  <D.35652>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 13;
    if (__s1_len <= 3) goto <D.35659>; else goto <D.35660>;
    <D.35659>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35661 = "MethodBuilder";
      D.35662 = MEM[(const unsigned char *)D.35661];
      D.35663 = (int) D.35662;
      D.35664 = *__s2;
      D.35665 = (int) D.35664;
      __result = D.35663 - D.35665;
      {
        if (__s1_len != 0) goto <D.35666>; else goto <D.35667>;
        <D.35666>:
        if (__result == 0) goto <D.35668>; else goto <D.35669>;
        <D.35668>:
        D.35670 = &MEM[(void *)"MethodBuilder" + 1B];
        D.35671 = *D.35670;
        D.35672 = (int) D.35671;
        D.35673 = __s2 + 1;
        D.35674 = *D.35673;
        D.35675 = (int) D.35674;
        __result = D.35672 - D.35675;
        if (__s1_len > 1) goto <D.35676>; else goto <D.35677>;
        <D.35676>:
        if (__result == 0) goto <D.35678>; else goto <D.35679>;
        <D.35678>:
        D.35680 = &MEM[(void *)"MethodBuilder" + 2B];
        D.35681 = *D.35680;
        D.35682 = (int) D.35681;
        D.35683 = __s2 + 2;
        D.35684 = *D.35683;
        D.35685 = (int) D.35684;
        __result = D.35682 - D.35685;
        if (__s1_len > 2) goto <D.35686>; else goto <D.35687>;
        <D.35686>:
        if (__result == 0) goto <D.35688>; else goto <D.35689>;
        <D.35688>:
        D.35690 = &MEM[(void *)"MethodBuilder" + 3B];
        D.35691 = *D.35690;
        D.35692 = (int) D.35691;
        D.35693 = __s2 + 3;
        D.35694 = *D.35693;
        D.35695 = (int) D.35694;
        __result = D.35692 - D.35695;
        <D.35689>:
        <D.35687>:
        <D.35679>:
        <D.35677>:
        <D.35669>:
        <D.35667>:
      }
      D.22043 = __result;
    }
    iftmp.585 = D.22043;
    goto <D.35696>;
    <D.35660>:
    D.34929 = klass->name;
    iftmp.585 = __builtin_strcmp ("MethodBuilder", D.34929);
    <D.35696>:
    D.22047 = iftmp.585;
  }
  if (D.22047 == 0) goto <D.35697>; else goto <D.35698>;
  <D.35697>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.35699 = mb->mhandle;
    D.35700 = D.35699->klass;
    D.35701 = D.35700->image;
    D.35702 = mb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35701, D.35702);
  }
  goto <D.35703>;
  <D.35698>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35707 = "FieldBuilder";
      D.35708 = MEM[(const unsigned char *)D.35707];
      D.35709 = (int) D.35708;
      D.35710 = *__s2;
      D.35711 = (int) D.35710;
      __result = D.35709 - D.35711;
      {
        if (__s1_len != 0) goto <D.35712>; else goto <D.35713>;
        <D.35712>:
        if (__result == 0) goto <D.35714>; else goto <D.35715>;
        <D.35714>:
        D.35716 = &MEM[(void *)"FieldBuilder" + 1B];
        D.35717 = *D.35716;
        D.35718 = (int) D.35717;
        D.35719 = __s2 + 1;
        D.35720 = *D.35719;
        D.35721 = (int) D.35720;
        __result = D.35718 - D.35721;
        if (__s1_len > 1) goto <D.35722>; else goto <D.35723>;
        <D.35722>:
        if (__result == 0) goto <D.35724>; else goto <D.35725>;
        <D.35724>:
        D.35726 = &MEM[(void *)"FieldBuilder" + 2B];
        D.35727 = *D.35726;
        D.35728 = (int) D.35727;
        D.35729 = __s2 + 2;
        D.35730 = *D.35729;
        D.35731 = (int) D.35730;
        __result = D.35728 - D.35731;
        if (__s1_len > 2) goto <D.35732>; else goto <D.35733>;
        <D.35732>:
        if (__result == 0) goto <D.35734>; else goto <D.35735>;
        <D.35734>:
        D.35736 = &MEM[(void *)"FieldBuilder" + 3B];
        D.35737 = *D.35736;
        D.35738 = (int) D.35737;
        D.35739 = __s2 + 3;
        D.35740 = *D.35739;
        D.35741 = (int) D.35740;
        __result = D.35738 - D.35741;
        <D.35735>:
        <D.35733>:
        <D.35725>:
        <D.35723>:
        <D.35715>:
        <D.35713>:
      }
      D.22053 = __result;
    }
    iftmp.586 = D.22053;
    goto <D.35742>;
    <D.35706>:
    D.34929 = klass->name;
    iftmp.586 = __builtin_strcmp ("FieldBuilder", D.34929);
    <D.35742>:
    D.22057 = iftmp.586;
  }
  if (D.22057 == 0) goto <D.35743>; else goto <D.35744>;
  <D.35743>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.35745 = fb->typeb;
    D.35746 = MEM[(struct MonoReflectionTypeBuilder *)D.35745].module;
    D.35747 = D.35746->dynamic_image;
    D.35748 = &D.35747->image;
    D.35749 = fb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.35748, D.35749);
  }
  goto <D.35750>;
  <D.35744>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 16;
    if (__s1_len <= 3) goto <D.35752>; else goto <D.35753>;
    <D.35752>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35754 = "MonoGenericClass";
      D.35755 = MEM[(const unsigned char *)D.35754];
      D.35756 = (int) D.35755;
      D.35757 = *__s2;
      D.35758 = (int) D.35757;
      __result = D.35756 - D.35758;
      {
        if (__s1_len != 0) goto <D.35759>; else goto <D.35760>;
        <D.35759>:
        if (__result == 0) goto <D.35761>; else goto <D.35762>;
        <D.35761>:
        D.35763 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.35764 = *D.35763;
        D.35765 = (int) D.35764;
        D.35766 = __s2 + 1;
        D.35767 = *D.35766;
        D.35768 = (int) D.35767;
        __result = D.35765 - D.35768;
        if (__s1_len > 1) goto <D.35769>; else goto <D.35770>;
        <D.35769>:
        if (__result == 0) goto <D.35771>; else goto <D.35772>;
        <D.35771>:
        D.35773 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.35774 = *D.35773;
        D.35775 = (int) D.35774;
        D.35776 = __s2 + 2;
        D.35777 = *D.35776;
        D.35778 = (int) D.35777;
        __result = D.35775 - D.35778;
        if (__s1_len > 2) goto <D.35779>; else goto <D.35780>;
        <D.35779>:
        if (__result == 0) goto <D.35781>; else goto <D.35782>;
        <D.35781>:
        D.35783 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.35784 = *D.35783;
        D.35785 = (int) D.35784;
        D.35786 = __s2 + 3;
        D.35787 = *D.35786;
        D.35788 = (int) D.35787;
        __result = D.35785 - D.35788;
        <D.35782>:
        <D.35780>:
        <D.35772>:
        <D.35770>:
        <D.35762>:
        <D.35760>:
      }
      D.22063 = __result;
    }
    iftmp.587 = D.22063;
    goto <D.35789>;
    <D.35753>:
    D.34929 = klass->name;
    iftmp.587 = __builtin_strcmp ("MonoGenericClass", D.34929);
    <D.35789>:
    D.22067 = iftmp.587;
  }
  if (D.22067 == 0) goto <D.35790>; else goto <D.35791>;
  <D.35790>:
  {
    struct MonoReflectionGenericClass * gclass;

    gclass = obj;
    D.35792 = gclass->generic_type;
    cinfo = mono_reflection_get_custom_attrs_info (D.35792);
  }
  goto <D.35793>;
  <D.35791>:
  D.34929 = klass->name;
  monoeg_g_log (0B, 4, "get custom attrs not yet supported for %s", D.34929);
  <D.22069>:
  goto <D.22069>;
  <D.35793>:
  <D.35750>:
  <D.35703>:
  <D.35657>:
  <D.35611>:
  <D.35566>:
  <D.35520>:
  <D.35354>:
  <D.35271>:
  <D.35188>:
  <D.35185>:
  <D.35141>:
  <D.35097>:
  <D.34973>:
  <D.34889>:
  <D.34886>:
  D.35794 = cinfo;
  return D.35794;
}


mono_custom_attrs_from_module (struct MonoImage * image)
{
  unsigned int D.35796;
  unsigned int D.35797;
  struct MonoCustomAttrInfo * D.35800;
  guint32 idx;

  D.35796 = BIT_FIELD_REF <*image, 32, 128>;
  D.35797 = D.35796 & 8;
  if (D.35797 != 0) goto <D.35798>; else goto <D.35799>;
  <D.35798>:
  D.35800 = lookup_custom_attr (image, image);
  return D.35800;
  <D.35799>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 7;
  D.35800 = mono_custom_attrs_from_index (image, idx);
  return D.35800;
}


is_sr_mono_property (struct MonoClass * class)
{
  struct MonoClass * cached_class.588;
  gboolean D.35805;
  _Bool D.35806;
  int D.35807;
  int D.22442;
  int iftmp.589;
  int D.22438;
  const char[13] * D.35813;
  unsigned char D.35814;
  int D.35815;
  unsigned char D.35816;
  int D.35817;
  const unsigned char * D.35822;
  unsigned char D.35823;
  int D.35824;
  const unsigned char * D.35825;
  unsigned char D.35826;
  int D.35827;
  const unsigned char * D.35832;
  unsigned char D.35833;
  int D.35834;
  const unsigned char * D.35835;
  unsigned char D.35836;
  int D.35837;
  const unsigned char * D.35842;
  unsigned char D.35843;
  int D.35844;
  const unsigned char * D.35845;
  unsigned char D.35846;
  int D.35847;
  const char * D.35849;
  int D.22451;
  int iftmp.590;
  int D.22447;
  const char[18] * D.35855;
  unsigned char D.35856;
  int D.35857;
  unsigned char D.35858;
  int D.35859;
  const unsigned char * D.35864;
  unsigned char D.35865;
  int D.35866;
  const unsigned char * D.35867;
  unsigned char D.35868;
  int D.35869;
  const unsigned char * D.35874;
  unsigned char D.35875;
  int D.35876;
  const unsigned char * D.35877;
  unsigned char D.35878;
  int D.35879;
  const unsigned char * D.35884;
  unsigned char D.35885;
  int D.35886;
  const unsigned char * D.35887;
  unsigned char D.35888;
  int D.35889;
  const char * D.35891;

  {
    static struct MonoClass * cached_class;

    cached_class.588 = cached_class;
    if (cached_class.588 != 0B) goto <D.35803>; else goto <D.35804>;
    <D.35803>:
    cached_class.588 = cached_class;
    D.35806 = cached_class.588 == class;
    D.35805 = (gboolean) D.35806;
    return D.35805;
    <D.35804>:
    D.35807 = is_corlib_type (class);
    if (D.35807 != 0) goto <D.35808>; else goto <D.35809>;
    <D.35808>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.35813 = "MonoProperty";
        D.35814 = MEM[(const unsigned char *)D.35813];
        D.35815 = (int) D.35814;
        D.35816 = *__s2;
        D.35817 = (int) D.35816;
        __result = D.35815 - D.35817;
        {
          if (__s1_len != 0) goto <D.35818>; else goto <D.35819>;
          <D.35818>:
          if (__result == 0) goto <D.35820>; else goto <D.35821>;
          <D.35820>:
          D.35822 = &MEM[(void *)"MonoProperty" + 1B];
          D.35823 = *D.35822;
          D.35824 = (int) D.35823;
          D.35825 = __s2 + 1;
          D.35826 = *D.35825;
          D.35827 = (int) D.35826;
          __result = D.35824 - D.35827;
          if (__s1_len > 1) goto <D.35828>; else goto <D.35829>;
          <D.35828>:
          if (__result == 0) goto <D.35830>; else goto <D.35831>;
          <D.35830>:
          D.35832 = &MEM[(void *)"MonoProperty" + 2B];
          D.35833 = *D.35832;
          D.35834 = (int) D.35833;
          D.35835 = __s2 + 2;
          D.35836 = *D.35835;
          D.35837 = (int) D.35836;
          __result = D.35834 - D.35837;
          if (__s1_len > 2) goto <D.35838>; else goto <D.35839>;
          <D.35838>:
          if (__result == 0) goto <D.35840>; else goto <D.35841>;
          <D.35840>:
          D.35842 = &MEM[(void *)"MonoProperty" + 3B];
          D.35843 = *D.35842;
          D.35844 = (int) D.35843;
          D.35845 = __s2 + 3;
          D.35846 = *D.35845;
          D.35847 = (int) D.35846;
          __result = D.35844 - D.35847;
          <D.35841>:
          <D.35839>:
          <D.35831>:
          <D.35829>:
          <D.35821>:
          <D.35819>:
        }
        D.22438 = __result;
      }
      iftmp.589 = D.22438;
      goto <D.35848>;
      <D.35812>:
      D.35849 = class->name;
      iftmp.589 = __builtin_strcmp ("MonoProperty", D.35849);
      <D.35848>:
      D.22442 = iftmp.589;
    }
    if (D.22442 == 0) goto <D.35850>; else goto <D.35851>;
    <D.35850>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.35853>; else goto <D.35854>;
      <D.35853>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.35855 = "System.Reflection";
        D.35856 = MEM[(const unsigned char *)D.35855];
        D.35857 = (int) D.35856;
        D.35858 = *__s2;
        D.35859 = (int) D.35858;
        __result = D.35857 - D.35859;
        {
          if (__s1_len != 0) goto <D.35860>; else goto <D.35861>;
          <D.35860>:
          if (__result == 0) goto <D.35862>; else goto <D.35863>;
          <D.35862>:
          D.35864 = &MEM[(void *)"System.Reflection" + 1B];
          D.35865 = *D.35864;
          D.35866 = (int) D.35865;
          D.35867 = __s2 + 1;
          D.35868 = *D.35867;
          D.35869 = (int) D.35868;
          __result = D.35866 - D.35869;
          if (__s1_len > 1) goto <D.35870>; else goto <D.35871>;
          <D.35870>:
          if (__result == 0) goto <D.35872>; else goto <D.35873>;
          <D.35872>:
          D.35874 = &MEM[(void *)"System.Reflection" + 2B];
          D.35875 = *D.35874;
          D.35876 = (int) D.35875;
          D.35877 = __s2 + 2;
          D.35878 = *D.35877;
          D.35879 = (int) D.35878;
          __result = D.35876 - D.35879;
          if (__s1_len > 2) goto <D.35880>; else goto <D.35881>;
          <D.35880>:
          if (__result == 0) goto <D.35882>; else goto <D.35883>;
          <D.35882>:
          D.35884 = &MEM[(void *)"System.Reflection" + 3B];
          D.35885 = *D.35884;
          D.35886 = (int) D.35885;
          D.35887 = __s2 + 3;
          D.35888 = *D.35887;
          D.35889 = (int) D.35888;
          __result = D.35886 - D.35889;
          <D.35883>:
          <D.35881>:
          <D.35873>:
          <D.35871>:
          <D.35863>:
          <D.35861>:
        }
        D.22447 = __result;
      }
      iftmp.590 = D.22447;
      goto <D.35890>;
      <D.35854>:
      D.35891 = class->name_space;
      iftmp.590 = __builtin_strcmp ("System.Reflection", D.35891);
      <D.35890>:
      D.22451 = iftmp.590;
    }
    if (D.22451 == 0) goto <D.35892>; else goto <D.35893>;
    <D.35892>:
    cached_class = class;
    D.35805 = 1;
    return D.35805;
    <D.35893>:
    <D.35851>:
    <D.35809>:
    D.35805 = 0;
    return D.35805;
  }
}


is_sre_method_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.591;
  gboolean D.35898;
  _Bool D.35899;
  int D.35900;
  int D.22284;
  int iftmp.592;
  int D.22280;
  const char[24] * D.35906;
  unsigned char D.35907;
  int D.35908;
  unsigned char D.35909;
  int D.35910;
  const unsigned char * D.35915;
  unsigned char D.35916;
  int D.35917;
  const unsigned char * D.35918;
  unsigned char D.35919;
  int D.35920;
  const unsigned char * D.35925;
  unsigned char D.35926;
  int D.35927;
  const unsigned char * D.35928;
  unsigned char D.35929;
  int D.35930;
  const unsigned char * D.35935;
  unsigned char D.35936;
  int D.35937;
  const unsigned char * D.35938;
  unsigned char D.35939;
  int D.35940;
  const char * D.35942;
  int D.22293;
  int iftmp.593;
  int D.22289;
  const char[23] * D.35948;
  unsigned char D.35949;
  int D.35950;
  unsigned char D.35951;
  int D.35952;
  const unsigned char * D.35957;
  unsigned char D.35958;
  int D.35959;
  const unsigned char * D.35960;
  unsigned char D.35961;
  int D.35962;
  const unsigned char * D.35967;
  unsigned char D.35968;
  int D.35969;
  const unsigned char * D.35970;
  unsigned char D.35971;
  int D.35972;
  const unsigned char * D.35977;
  unsigned char D.35978;
  int D.35979;
  const unsigned char * D.35980;
  unsigned char D.35981;
  int D.35982;
  const char * D.35984;

  {
    static struct MonoClass * cached_class;

    cached_class.591 = cached_class;
    if (cached_class.591 != 0B) goto <D.35896>; else goto <D.35897>;
    <D.35896>:
    cached_class.591 = cached_class;
    D.35899 = cached_class.591 == class;
    D.35898 = (gboolean) D.35899;
    return D.35898;
    <D.35897>:
    D.35900 = is_corlib_type (class);
    if (D.35900 != 0) goto <D.35901>; else goto <D.35902>;
    <D.35901>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 23;
      if (__s1_len <= 3) goto <D.35904>; else goto <D.35905>;
      <D.35904>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.35906 = "MethodOnTypeBuilderInst";
        D.35907 = MEM[(const unsigned char *)D.35906];
        D.35908 = (int) D.35907;
        D.35909 = *__s2;
        D.35910 = (int) D.35909;
        __result = D.35908 - D.35910;
        {
          if (__s1_len != 0) goto <D.35911>; else goto <D.35912>;
          <D.35911>:
          if (__result == 0) goto <D.35913>; else goto <D.35914>;
          <D.35913>:
          D.35915 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
          D.35916 = *D.35915;
          D.35917 = (int) D.35916;
          D.35918 = __s2 + 1;
          D.35919 = *D.35918;
          D.35920 = (int) D.35919;
          __result = D.35917 - D.35920;
          if (__s1_len > 1) goto <D.35921>; else goto <D.35922>;
          <D.35921>:
          if (__result == 0) goto <D.35923>; else goto <D.35924>;
          <D.35923>:
          D.35925 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
          D.35926 = *D.35925;
          D.35927 = (int) D.35926;
          D.35928 = __s2 + 2;
          D.35929 = *D.35928;
          D.35930 = (int) D.35929;
          __result = D.35927 - D.35930;
          if (__s1_len > 2) goto <D.35931>; else goto <D.35932>;
          <D.35931>:
          if (__result == 0) goto <D.35933>; else goto <D.35934>;
          <D.35933>:
          D.35935 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
          D.35936 = *D.35935;
          D.35937 = (int) D.35936;
          D.35938 = __s2 + 3;
          D.35939 = *D.35938;
          D.35940 = (int) D.35939;
          __result = D.35937 - D.35940;
          <D.35934>:
          <D.35932>:
          <D.35924>:
          <D.35922>:
          <D.35914>:
          <D.35912>:
        }
        D.22280 = __result;
      }
      iftmp.592 = D.22280;
      goto <D.35941>;
      <D.35905>:
      D.35942 = class->name;
      iftmp.592 = __builtin_strcmp ("MethodOnTypeBuilderInst", D.35942);
      <D.35941>:
      D.22284 = iftmp.592;
    }
    if (D.22284 == 0) goto <D.35943>; else goto <D.35944>;
    <D.35943>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.35946>; else goto <D.35947>;
      <D.35946>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.35948 = "System.Reflection.Emit";
        D.35949 = MEM[(const unsigned char *)D.35948];
        D.35950 = (int) D.35949;
        D.35951 = *__s2;
        D.35952 = (int) D.35951;
        __result = D.35950 - D.35952;
        {
          if (__s1_len != 0) goto <D.35953>; else goto <D.35954>;
          <D.35953>:
          if (__result == 0) goto <D.35955>; else goto <D.35956>;
          <D.35955>:
          D.35957 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.35958 = *D.35957;
          D.35959 = (int) D.35958;
          D.35960 = __s2 + 1;
          D.35961 = *D.35960;
          D.35962 = (int) D.35961;
          __result = D.35959 - D.35962;
          if (__s1_len > 1) goto <D.35963>; else goto <D.35964>;
          <D.35963>:
          if (__result == 0) goto <D.35965>; else goto <D.35966>;
          <D.35965>:
          D.35967 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.35968 = *D.35967;
          D.35969 = (int) D.35968;
          D.35970 = __s2 + 2;
          D.35971 = *D.35970;
          D.35972 = (int) D.35971;
          __result = D.35969 - D.35972;
          if (__s1_len > 2) goto <D.35973>; else goto <D.35974>;
          <D.35973>:
          if (__result == 0) goto <D.35975>; else goto <D.35976>;
          <D.35975>:
          D.35977 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.35978 = *D.35977;
          D.35979 = (int) D.35978;
          D.35980 = __s2 + 3;
          D.35981 = *D.35980;
          D.35982 = (int) D.35981;
          __result = D.35979 - D.35982;
          <D.35976>:
          <D.35974>:
          <D.35966>:
          <D.35964>:
          <D.35956>:
          <D.35954>:
        }
        D.22289 = __result;
      }
      iftmp.593 = D.22289;
      goto <D.35983>;
      <D.35947>:
      D.35984 = class->name_space;
      iftmp.593 = __builtin_strcmp ("System.Reflection.Emit", D.35984);
      <D.35983>:
      D.22293 = iftmp.593;
    }
    if (D.22293 == 0) goto <D.35985>; else goto <D.35986>;
    <D.35985>:
    cached_class = class;
    D.35898 = 1;
    return D.35898;
    <D.35986>:
    <D.35944>:
    <D.35902>:
    D.35898 = 0;
    return D.35898;
  }
}


is_sre_ctor_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.594;
  gboolean D.35991;
  _Bool D.35992;
  int D.35993;
  int D.22306;
  int iftmp.595;
  int D.22302;
  const char[29] * D.35999;
  unsigned char D.36000;
  int D.36001;
  unsigned char D.36002;
  int D.36003;
  const unsigned char * D.36008;
  unsigned char D.36009;
  int D.36010;
  const unsigned char * D.36011;
  unsigned char D.36012;
  int D.36013;
  const unsigned char * D.36018;
  unsigned char D.36019;
  int D.36020;
  const unsigned char * D.36021;
  unsigned char D.36022;
  int D.36023;
  const unsigned char * D.36028;
  unsigned char D.36029;
  int D.36030;
  const unsigned char * D.36031;
  unsigned char D.36032;
  int D.36033;
  const char * D.36035;
  int D.22315;
  int iftmp.596;
  int D.22311;
  const char[23] * D.36041;
  unsigned char D.36042;
  int D.36043;
  unsigned char D.36044;
  int D.36045;
  const unsigned char * D.36050;
  unsigned char D.36051;
  int D.36052;
  const unsigned char * D.36053;
  unsigned char D.36054;
  int D.36055;
  const unsigned char * D.36060;
  unsigned char D.36061;
  int D.36062;
  const unsigned char * D.36063;
  unsigned char D.36064;
  int D.36065;
  const unsigned char * D.36070;
  unsigned char D.36071;
  int D.36072;
  const unsigned char * D.36073;
  unsigned char D.36074;
  int D.36075;
  const char * D.36077;

  {
    static struct MonoClass * cached_class;

    cached_class.594 = cached_class;
    if (cached_class.594 != 0B) goto <D.35989>; else goto <D.35990>;
    <D.35989>:
    cached_class.594 = cached_class;
    D.35992 = cached_class.594 == class;
    D.35991 = (gboolean) D.35992;
    return D.35991;
    <D.35990>:
    D.35993 = is_corlib_type (class);
    if (D.35993 != 0) goto <D.35994>; else goto <D.35995>;
    <D.35994>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 28;
      if (__s1_len <= 3) goto <D.35997>; else goto <D.35998>;
      <D.35997>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.35999 = "ConstructorOnTypeBuilderInst";
        D.36000 = MEM[(const unsigned char *)D.35999];
        D.36001 = (int) D.36000;
        D.36002 = *__s2;
        D.36003 = (int) D.36002;
        __result = D.36001 - D.36003;
        {
          if (__s1_len != 0) goto <D.36004>; else goto <D.36005>;
          <D.36004>:
          if (__result == 0) goto <D.36006>; else goto <D.36007>;
          <D.36006>:
          D.36008 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
          D.36009 = *D.36008;
          D.36010 = (int) D.36009;
          D.36011 = __s2 + 1;
          D.36012 = *D.36011;
          D.36013 = (int) D.36012;
          __result = D.36010 - D.36013;
          if (__s1_len > 1) goto <D.36014>; else goto <D.36015>;
          <D.36014>:
          if (__result == 0) goto <D.36016>; else goto <D.36017>;
          <D.36016>:
          D.36018 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
          D.36019 = *D.36018;
          D.36020 = (int) D.36019;
          D.36021 = __s2 + 2;
          D.36022 = *D.36021;
          D.36023 = (int) D.36022;
          __result = D.36020 - D.36023;
          if (__s1_len > 2) goto <D.36024>; else goto <D.36025>;
          <D.36024>:
          if (__result == 0) goto <D.36026>; else goto <D.36027>;
          <D.36026>:
          D.36028 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
          D.36029 = *D.36028;
          D.36030 = (int) D.36029;
          D.36031 = __s2 + 3;
          D.36032 = *D.36031;
          D.36033 = (int) D.36032;
          __result = D.36030 - D.36033;
          <D.36027>:
          <D.36025>:
          <D.36017>:
          <D.36015>:
          <D.36007>:
          <D.36005>:
        }
        D.22302 = __result;
      }
      iftmp.595 = D.22302;
      goto <D.36034>;
      <D.35998>:
      D.36035 = class->name;
      iftmp.595 = __builtin_strcmp ("ConstructorOnTypeBuilderInst", D.36035);
      <D.36034>:
      D.22306 = iftmp.595;
    }
    if (D.22306 == 0) goto <D.36036>; else goto <D.36037>;
    <D.36036>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 22;
      if (__s1_len <= 3) goto <D.36039>; else goto <D.36040>;
      <D.36039>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.36041 = "System.Reflection.Emit";
        D.36042 = MEM[(const unsigned char *)D.36041];
        D.36043 = (int) D.36042;
        D.36044 = *__s2;
        D.36045 = (int) D.36044;
        __result = D.36043 - D.36045;
        {
          if (__s1_len != 0) goto <D.36046>; else goto <D.36047>;
          <D.36046>:
          if (__result == 0) goto <D.36048>; else goto <D.36049>;
          <D.36048>:
          D.36050 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.36051 = *D.36050;
          D.36052 = (int) D.36051;
          D.36053 = __s2 + 1;
          D.36054 = *D.36053;
          D.36055 = (int) D.36054;
          __result = D.36052 - D.36055;
          if (__s1_len > 1) goto <D.36056>; else goto <D.36057>;
          <D.36056>:
          if (__result == 0) goto <D.36058>; else goto <D.36059>;
          <D.36058>:
          D.36060 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.36061 = *D.36060;
          D.36062 = (int) D.36061;
          D.36063 = __s2 + 2;
          D.36064 = *D.36063;
          D.36065 = (int) D.36064;
          __result = D.36062 - D.36065;
          if (__s1_len > 2) goto <D.36066>; else goto <D.36067>;
          <D.36066>:
          if (__result == 0) goto <D.36068>; else goto <D.36069>;
          <D.36068>:
          D.36070 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.36071 = *D.36070;
          D.36072 = (int) D.36071;
          D.36073 = __s2 + 3;
          D.36074 = *D.36073;
          D.36075 = (int) D.36074;
          __result = D.36072 - D.36075;
          <D.36069>:
          <D.36067>:
          <D.36059>:
          <D.36057>:
          <D.36049>:
          <D.36047>:
        }
        D.22311 = __result;
      }
      iftmp.596 = D.22311;
      goto <D.36076>;
      <D.36040>:
      D.36077 = class->name_space;
      iftmp.596 = __builtin_strcmp ("System.Reflection.Emit", D.36077);
      <D.36076>:
      D.22315 = iftmp.596;
    }
    if (D.22315 == 0) goto <D.36078>; else goto <D.36079>;
    <D.36078>:
    cached_class = class;
    D.35991 = 1;
    return D.35991;
    <D.36079>:
    <D.36037>:
    <D.35995>:
    D.35991 = 0;
    return D.35991;
  }
}


mono_reflection_get_custom_attrs_by_type (struct MonoObject * obj, struct MonoClass * attr_klass, struct MonoError * error)
{
  int D.36083;
  struct MonoLoaderError * D.36087;
  struct MonoArray * D.36090;
  struct MonoDomain * D.36091;
  struct MonoClass * D.22078;
  struct MonoClass * tmp_klass.597;
  struct MonoClass * D.36095;
  struct MonoClass * tmp_klass.598;
  _Bool D.36097;
  long int D.36098;
  long int D.36099;
  struct MonoVTable * D.36102;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  mono_error_init (error);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36081>; else goto <D.36082>;
  <D.36081>:
  result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
  D.36083 = cinfo->cached;
  if (D.36083 == 0) goto <D.36084>; else goto <D.36085>;
  <D.36084>:
  mono_custom_attrs_free (cinfo);
  <D.36085>:
  goto <D.36086>;
  <D.36082>:
  D.36087 = mono_loader_get_last_error ();
  if (D.36087 != 0B) goto <D.36088>; else goto <D.36089>;
  <D.36088>:
  D.36090 = 0B;
  return D.36090;
  <D.36089>:
  D.36091 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.597 = tmp_klass;
      if (tmp_klass.597 == 0B) goto <D.36093>; else goto <D.36094>;
      <D.36093>:
      D.36095 = mono_defaults.attribute_class;
      tmp_klass.598 = mono_array_class_get (D.36095, 1);
      tmp_klass = tmp_klass.598;
      tmp_klass.597 = tmp_klass;
      D.36097 = tmp_klass.597 == 0B;
      D.36098 = (long int) D.36097;
      D.36099 = __builtin_expect (D.36098, 0);
      if (D.36099 != 0) goto <D.36100>; else goto <D.36101>;
      <D.36100>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8971, "tmp_klass");
      <D.36101>:
      <D.36094>:
    }
    D.22078 = tmp_klass;
  }
  D.36102 = mono_class_vtable (D.36091, D.22078);
  result = mono_array_new_specific (D.36102, 0);
  <D.36086>:
  D.36090 = result;
  return D.36090;
}


mono_reflection_get_custom_attrs (struct MonoObject * obj)
{
  struct MonoArray * D.36104;
  struct MonoError error;

  try
    {
      D.36104 = mono_reflection_get_custom_attrs_by_type (obj, 0B, &error);
      return D.36104;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_get_custom_attrs_data (struct MonoObject * obj)
{
  int D.36109;
  struct MonoDomain * D.36113;
  struct MonoClass * D.36114;
  struct MonoArray * D.36115;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36107>; else goto <D.36108>;
  <D.36107>:
  result = mono_custom_attrs_data_construct (cinfo);
  D.36109 = cinfo->cached;
  if (D.36109 == 0) goto <D.36110>; else goto <D.36111>;
  <D.36110>:
  mono_custom_attrs_free (cinfo);
  <D.36111>:
  goto <D.36112>;
  <D.36108>:
  D.36113 = mono_domain_get ();
  D.36114 = mono_defaults.customattribute_data_class;
  result = mono_array_new (D.36113, D.36114, 0);
  <D.36112>:
  D.36115 = result;
  return D.36115;
}


mono_custom_attrs_data_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoDomain * D.36117;
  struct MonoClass * D.36118;
  int D.36119;
  unsigned int D.36120;
  struct MonoImage * D.36121;
  struct MonoCustomAttrEntry * D.36122;
  unsigned int i.599;
  struct MonoArray * D.36124;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;

  D.36117 = mono_domain_get ();
  D.36118 = mono_defaults.customattribute_data_class;
  D.36119 = cinfo->num_attrs;
  D.36120 = (unsigned int) D.36119;
  result = mono_array_new (D.36117, D.36118, D.36120);
  i = 0;
  goto <D.21760>;
  <D.21759>:
  D.36121 = cinfo->image;
  D.36122 = &cinfo->attrs[i];
  attr = create_custom_attr_data (D.36121, D.36122);
  {
    void * * __p;

    i.599 = (unsigned int) i;
    __p = mono_array_addr_with_size (result, 4, i.599);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  i = i + 1;
  <D.21760>:
  D.36119 = cinfo->num_attrs;
  if (D.36119 > i) goto <D.21759>; else goto <D.21761>;
  <D.21761>:
  D.36124 = result;
  return D.36124;
}


create_custom_attr_data (struct MonoImage * image, struct MonoCustomAttrEntry * cattr)
{
  struct MonoAssembly * D.36126;
  _Bool D.36127;
  long int D.36128;
  long int D.36129;
  struct MonoMethod * ctor.600;
  struct MonoClass * D.36135;
  struct MonoMethod * ctor.601;
  struct MonoMethod * D.36137;
  struct MonoReflectionMethod * D.36138;
  struct MonoReflectionAssembly * D.36139;
  const mono_byte * * D.36140;
  uint32_t * D.36141;
  struct MonoObject * D.36142;
  static struct MonoMethod * ctor;
  struct MonoDomain * domain;
  struct MonoObject * attr;
  void * params[4];

  try
    {
      D.36126 = image->assembly;
      D.36127 = D.36126 == 0B;
      D.36128 = (long int) D.36127;
      D.36129 = __builtin_expect (D.36128, 0);
      if (D.36129 != 0) goto <D.36130>; else goto <D.36131>;
      <D.36130>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8461, "image->assembly");
      <D.36131>:
      ctor.600 = ctor;
      if (ctor.600 == 0B) goto <D.36133>; else goto <D.36134>;
      <D.36133>:
      D.36135 = mono_defaults.customattribute_data_class;
      ctor.601 = mono_class_get_method_from_name (D.36135, ".ctor", 4);
      ctor = ctor.601;
      <D.36134>:
      domain = mono_domain_get ();
      D.36135 = mono_defaults.customattribute_data_class;
      attr = mono_object_new (domain, D.36135);
      D.36137 = cattr->ctor;
      D.36138 = mono_method_get_object (domain, D.36137, 0B);
      params[0] = D.36138;
      D.36126 = image->assembly;
      D.36139 = mono_assembly_get_object (domain, D.36126);
      params[1] = D.36139;
      D.36140 = &cattr->data;
      params[2] = D.36140;
      D.36141 = &cattr->data_size;
      params[3] = D.36141;
      ctor.600 = ctor;
      mono_runtime_invoke (ctor.600, attr, &params, 0B);
      D.36142 = attr;
      return D.36142;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_reflection_type_get_handle (struct MonoReflectionType * ref)
{
  struct MonoType * D.36147;
  struct MonoType * D.36148;
  int D.36151;
  int D.36157;
  struct MonoVTable * D.36160;
  int D.36161;
  struct MonoReflectionType * D.36164;
  _Bool D.36165;
  long int D.36166;
  long int D.36167;
  int D.36170;
  struct MonoClass * D.36173;
  struct MonoClass * D.36174;
  struct MonoClass * D.36176;
  unsigned int D.36177;
  struct MonoClass * D.36178;
  int D.36179;
  struct MonoReflectionType * D.36182;
  _Bool D.36183;
  long int D.36184;
  long int D.36185;
  struct MonoClass * D.36188;
  int D.36189;
  struct MonoReflectionType * D.36192;
  _Bool D.36193;
  long int D.36194;
  long int D.36195;
  struct MonoClass * D.36198;
  int D.36199;
  struct MonoArray * D.36202;
  unsigned int D.36203;
  unsigned int count.602;
  unsigned int D.36205;
  unsigned int i.603;
  char * D.36207;
  unsigned int i.604;
  unsigned int D.36209;
  struct MonoType * * D.36210;
  struct MonoType * D.36211;
  struct MonoType * D.36212;
  struct MonoReflectionType * D.36215;
  _Bool D.36216;
  long int D.36217;
  long int D.36218;
  struct MonoClass * D.36221;
  struct MonoType * D.36222;
  char * D.36223;
  struct MonoClass * class;

  if (ref == 0B) goto <D.36145>; else goto <D.36146>;
  <D.36145>:
  D.36147 = 0B;
  return D.36147;
  <D.36146>:
  D.36148 = ref->type;
  if (D.36148 != 0B) goto <D.36149>; else goto <D.36150>;
  <D.36149>:
  D.36147 = ref->type;
  return D.36147;
  <D.36150>:
  D.36151 = is_usertype (ref);
  if (D.36151 != 0) goto <D.36152>; else goto <D.36153>;
  <D.36152>:
  ref = mono_reflection_type_get_underlying_system_type (ref);
  if (ref == 0B) goto <D.36154>; else goto <D.36156>;
  <D.36156>:
  D.36157 = is_usertype (ref);
  if (D.36157 != 0) goto <D.36154>; else goto <D.36155>;
  <D.36154>:
  D.36147 = 0B;
  return D.36147;
  <D.36155>:
  D.36148 = ref->type;
  if (D.36148 != 0B) goto <D.36158>; else goto <D.36159>;
  <D.36158>:
  D.36147 = ref->type;
  return D.36147;
  <D.36159>:
  <D.36153>:
  D.36160 = MEM[(struct MonoObject *)ref].vtable;
  class = D.36160->klass;
  D.36161 = is_sre_array (class);
  if (D.36161 != 0) goto <D.36162>; else goto <D.36163>;
  <D.36162>:
  {
    struct MonoType * res;
    struct MonoReflectionArrayType * sre_array;
    struct MonoType * base;

    sre_array = ref;
    D.36164 = sre_array->element_type;
    base = mono_reflection_type_get_handle (D.36164);
    D.36165 = base == 0B;
    D.36166 = (long int) D.36165;
    D.36167 = __builtin_expect (D.36166, 0);
    if (D.36167 != 0) goto <D.36168>; else goto <D.36169>;
    <D.36168>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9133, "base");
    <D.36169>:
    D.36170 = sre_array->rank;
    if (D.36170 == 0) goto <D.36171>; else goto <D.36172>;
    <D.36171>:
    D.36173 = mono_class_from_mono_type (base);
    D.36174 = mono_array_class_get (D.36173, 1);
    res = &D.36174->byval_arg;
    goto <D.36175>;
    <D.36172>:
    D.36176 = mono_class_from_mono_type (base);
    D.36170 = sre_array->rank;
    D.36177 = (unsigned int) D.36170;
    D.36178 = mono_bounded_array_class_get (D.36176, D.36177, 1);
    res = &D.36178->byval_arg;
    <D.36175>:
    sre_array->type.type = res;
    D.36147 = res;
    return D.36147;
  }
  <D.36163>:
  D.36179 = is_sre_byref (class);
  if (D.36179 != 0) goto <D.36180>; else goto <D.36181>;
  <D.36180>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_byref;
    struct MonoType * base;

    sre_byref = ref;
    D.36182 = sre_byref->element_type;
    base = mono_reflection_type_get_handle (D.36182);
    D.36183 = base == 0B;
    D.36184 = (long int) D.36183;
    D.36185 = __builtin_expect (D.36184, 0);
    if (D.36185 != 0) goto <D.36186>; else goto <D.36187>;
    <D.36186>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9144, "base");
    <D.36187>:
    D.36188 = mono_class_from_mono_type (base);
    res = &D.36188->this_arg;
    sre_byref->type.type = res;
    D.36147 = res;
    return D.36147;
  }
  <D.36181>:
  D.36189 = is_sre_pointer (class);
  if (D.36189 != 0) goto <D.36190>; else goto <D.36191>;
  <D.36190>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_pointer;
    struct MonoType * base;

    sre_pointer = ref;
    D.36192 = sre_pointer->element_type;
    base = mono_reflection_type_get_handle (D.36192);
    D.36193 = base == 0B;
    D.36194 = (long int) D.36193;
    D.36195 = __builtin_expect (D.36194, 0);
    if (D.36195 != 0) goto <D.36196>; else goto <D.36197>;
    <D.36196>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9152, "base");
    <D.36197>:
    D.36198 = mono_ptr_class_get (base);
    res = &D.36198->byval_arg;
    sre_pointer->type.type = res;
    D.36147 = res;
    return D.36147;
  }
  <D.36191>:
  D.36199 = is_sre_generic_instance (class);
  if (D.36199 != 0) goto <D.36200>; else goto <D.36201>;
  <D.36200>:
  {
    struct MonoType * res;
    struct MonoType * * types;
    struct MonoReflectionGenericClass * gclass;
    int i;
    int count;

    gclass = ref;
    D.36202 = gclass->type_arguments;
    D.36203 = mono_array_length (D.36202);
    count = (int) D.36203;
    count.602 = (unsigned int) count;
    D.36205 = count.602 * 4;
    types = monoeg_malloc0 (D.36205);
    i = 0;
    goto <D.22336>;
    <D.22335>:
    {
      struct MonoReflectionType * t;

      D.36202 = gclass->type_arguments;
      i.603 = (unsigned int) i;
      D.36207 = mono_array_addr_with_size (D.36202, 4, i.603);
      t = MEM[(void * *)D.36207];
      i.604 = (unsigned int) i;
      D.36209 = i.604 * 4;
      D.36210 = types + D.36209;
      D.36211 = mono_reflection_type_get_handle (t);
      *D.36210 = D.36211;
      i.604 = (unsigned int) i;
      D.36209 = i.604 * 4;
      D.36210 = types + D.36209;
      D.36212 = *D.36210;
      if (D.36212 == 0B) goto <D.36213>; else goto <D.36214>;
      <D.36213>:
      monoeg_g_free (types);
      D.36147 = 0B;
      return D.36147;
      <D.36214>:
    }
    i = i + 1;
    <D.22336>:
    if (i < count) goto <D.22335>; else goto <D.22337>;
    <D.22337>:
    D.36215 = gclass->generic_type;
    res = mono_reflection_bind_generic_parameters (D.36215, count, types);
    monoeg_g_free (types);
    D.36216 = res == 0B;
    D.36217 = (long int) D.36216;
    D.36218 = __builtin_expect (D.36217, 0);
    if (D.36218 != 0) goto <D.36219>; else goto <D.36220>;
    <D.36219>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9174, "res");
    <D.36220>:
    gclass->type.type = res;
    D.36147 = res;
    return D.36147;
  }
  <D.36201>:
  D.36160 = MEM[(struct MonoObject *)ref].vtable;
  D.36221 = D.36160->klass;
  D.36222 = &D.36221->byval_arg;
  D.36223 = mono_type_full_name (D.36222);
  monoeg_g_log (0B, 4, "Cannot handle corlib user type %s", D.36223);
  <D.22338>:
  goto <D.22338>;
  D.36147 = 0B;
  return D.36147;
}


mono_reflection_create_unmanaged_type (struct MonoReflectionType * type)
{
  mono_reflection_type_get_handle (type);
}


mono_reflection_register_with_runtime (struct MonoReflectionType * type)
{
  struct MonoVTable * D.36225;
  struct MonoException * D.36228;
  union mono_mutex_t * D.36229;
  _Bool D.36232;
  long int D.36233;
  long int D.36234;
  struct MonoImage * D.36237;
  unsigned int D.36238;
  unsigned int D.36239;
  struct MonoGHashTable * D.36243;
  struct MonoGHashTable * D.36246;
  _Bool D.36249;
  long int D.36250;
  long int D.36251;
  struct MonoType * res;
  struct MonoDomain * domain;
  struct MonoClass * class;

  res = mono_reflection_type_get_handle (type);
  D.36225 = MEM[(struct MonoObject *)type].vtable;
  domain = D.36225->domain;
  if (res == 0B) goto <D.36226>; else goto <D.36227>;
  <D.36226>:
  D.36228 = mono_get_exception_argument (0B, "Invalid generic instantiation, one or more arguments are not proper user types");
  mono_raise_exception (D.36228);
  <D.36227>:
  class = mono_class_from_mono_type (res);
  mono_loader_lock ();
  {
    int ret;

    D.36229 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.36229);
    if (ret != 0) goto <D.36230>; else goto <D.36231>;
    <D.36230>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.36231>:
    D.36232 = ret != 0;
    D.36233 = (long int) D.36232;
    D.36234 = __builtin_expect (D.36233, 0);
    if (D.36234 != 0) goto <D.36235>; else goto <D.36236>;
    <D.36235>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9204, "ret == 0");
    <D.36236>:
  }
  D.36237 = class->image;
  D.36238 = BIT_FIELD_REF <*D.36237, 32, 128>;
  D.36239 = D.36238 & 8;
  if (D.36239 == 0) goto <D.36240>; else goto <D.36241>;
  <D.36240>:
  mono_class_setup_supertypes (class);
  goto <D.36242>;
  <D.36241>:
  D.36243 = domain->type_hash;
  if (D.36243 == 0B) goto <D.36244>; else goto <D.36245>;
  <D.36244>:
  D.36246 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.36246;
  <D.36245>:
  D.36243 = domain->type_hash;
  mono_g_hash_table_insert (D.36243, res, type);
  <D.36242>:
  {
    int ret;

    D.36229 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.36229);
    if (ret != 0) goto <D.36247>; else goto <D.36248>;
    <D.36247>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.36248>:
    D.36249 = ret != 0;
    D.36250 = (long int) D.36249;
    D.36251 = __builtin_expect (D.36250, 0);
    if (D.36251 != 0) goto <D.36252>; else goto <D.36253>;
    <D.36252>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9214, "ret == 0");
    <D.36253>:
  }
  mono_loader_unlock ();
}


mono_class_is_reflection_method_or_constructor (struct MonoClass * class)
{
  gboolean D.36254;
  int iftmp.605;
  int D.36259;
  int D.36261;
  int D.36263;
  int D.36265;

  D.36259 = is_sr_mono_method (class);
  if (D.36259 != 0) goto <D.36256>; else goto <D.36260>;
  <D.36260>:
  D.36261 = is_sr_mono_cmethod (class);
  if (D.36261 != 0) goto <D.36256>; else goto <D.36262>;
  <D.36262>:
  D.36263 = is_sr_mono_generic_method (class);
  if (D.36263 != 0) goto <D.36256>; else goto <D.36264>;
  <D.36264>:
  D.36265 = is_sr_mono_generic_cmethod (class);
  if (D.36265 != 0) goto <D.36256>; else goto <D.36257>;
  <D.36256>:
  iftmp.605 = 1;
  goto <D.36258>;
  <D.36257>:
  iftmp.605 = 0;
  <D.36258>:
  D.36254 = iftmp.605;
  return D.36254;
}


is_sr_mono_generic_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.606;
  gboolean D.36270;
  _Bool D.36271;
  int D.36272;
  int D.22508;
  int iftmp.607;
  int D.22504;
  const char[18] * D.36278;
  unsigned char D.36279;
  int D.36280;
  unsigned char D.36281;
  int D.36282;
  const unsigned char * D.36287;
  unsigned char D.36288;
  int D.36289;
  const unsigned char * D.36290;
  unsigned char D.36291;
  int D.36292;
  const unsigned char * D.36297;
  unsigned char D.36298;
  int D.36299;
  const unsigned char * D.36300;
  unsigned char D.36301;
  int D.36302;
  const unsigned char * D.36307;
  unsigned char D.36308;
  int D.36309;
  const unsigned char * D.36310;
  unsigned char D.36311;
  int D.36312;
  const char * D.36314;
  int D.22517;
  int iftmp.608;
  int D.22513;
  const char[18] * D.36320;
  unsigned char D.36321;
  int D.36322;
  unsigned char D.36323;
  int D.36324;
  const unsigned char * D.36329;
  unsigned char D.36330;
  int D.36331;
  const unsigned char * D.36332;
  unsigned char D.36333;
  int D.36334;
  const unsigned char * D.36339;
  unsigned char D.36340;
  int D.36341;
  const unsigned char * D.36342;
  unsigned char D.36343;
  int D.36344;
  const unsigned char * D.36349;
  unsigned char D.36350;
  int D.36351;
  const unsigned char * D.36352;
  unsigned char D.36353;
  int D.36354;
  const char * D.36356;

  {
    static struct MonoClass * cached_class;

    cached_class.606 = cached_class;
    if (cached_class.606 != 0B) goto <D.36268>; else goto <D.36269>;
    <D.36268>:
    cached_class.606 = cached_class;
    D.36271 = cached_class.606 == class;
    D.36270 = (gboolean) D.36271;
    return D.36270;
    <D.36269>:
    D.36272 = is_corlib_type (class);
    if (D.36272 != 0) goto <D.36273>; else goto <D.36274>;
    <D.36273>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.36276>; else goto <D.36277>;
      <D.36276>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36278 = "MonoGenericMethod";
        D.36279 = MEM[(const unsigned char *)D.36278];
        D.36280 = (int) D.36279;
        D.36281 = *__s2;
        D.36282 = (int) D.36281;
        __result = D.36280 - D.36282;
        {
          if (__s1_len != 0) goto <D.36283>; else goto <D.36284>;
          <D.36283>:
          if (__result == 0) goto <D.36285>; else goto <D.36286>;
          <D.36285>:
          D.36287 = &MEM[(void *)"MonoGenericMethod" + 1B];
          D.36288 = *D.36287;
          D.36289 = (int) D.36288;
          D.36290 = __s2 + 1;
          D.36291 = *D.36290;
          D.36292 = (int) D.36291;
          __result = D.36289 - D.36292;
          if (__s1_len > 1) goto <D.36293>; else goto <D.36294>;
          <D.36293>:
          if (__result == 0) goto <D.36295>; else goto <D.36296>;
          <D.36295>:
          D.36297 = &MEM[(void *)"MonoGenericMethod" + 2B];
          D.36298 = *D.36297;
          D.36299 = (int) D.36298;
          D.36300 = __s2 + 2;
          D.36301 = *D.36300;
          D.36302 = (int) D.36301;
          __result = D.36299 - D.36302;
          if (__s1_len > 2) goto <D.36303>; else goto <D.36304>;
          <D.36303>:
          if (__result == 0) goto <D.36305>; else goto <D.36306>;
          <D.36305>:
          D.36307 = &MEM[(void *)"MonoGenericMethod" + 3B];
          D.36308 = *D.36307;
          D.36309 = (int) D.36308;
          D.36310 = __s2 + 3;
          D.36311 = *D.36310;
          D.36312 = (int) D.36311;
          __result = D.36309 - D.36312;
          <D.36306>:
          <D.36304>:
          <D.36296>:
          <D.36294>:
          <D.36286>:
          <D.36284>:
        }
        D.22504 = __result;
      }
      iftmp.607 = D.22504;
      goto <D.36313>;
      <D.36277>:
      D.36314 = class->name;
      iftmp.607 = __builtin_strcmp ("MonoGenericMethod", D.36314);
      <D.36313>:
      D.22508 = iftmp.607;
    }
    if (D.22508 == 0) goto <D.36315>; else goto <D.36316>;
    <D.36315>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.36318>; else goto <D.36319>;
      <D.36318>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.36320 = "System.Reflection";
        D.36321 = MEM[(const unsigned char *)D.36320];
        D.36322 = (int) D.36321;
        D.36323 = *__s2;
        D.36324 = (int) D.36323;
        __result = D.36322 - D.36324;
        {
          if (__s1_len != 0) goto <D.36325>; else goto <D.36326>;
          <D.36325>:
          if (__result == 0) goto <D.36327>; else goto <D.36328>;
          <D.36327>:
          D.36329 = &MEM[(void *)"System.Reflection" + 1B];
          D.36330 = *D.36329;
          D.36331 = (int) D.36330;
          D.36332 = __s2 + 1;
          D.36333 = *D.36332;
          D.36334 = (int) D.36333;
          __result = D.36331 - D.36334;
          if (__s1_len > 1) goto <D.36335>; else goto <D.36336>;
          <D.36335>:
          if (__result == 0) goto <D.36337>; else goto <D.36338>;
          <D.36337>:
          D.36339 = &MEM[(void *)"System.Reflection" + 2B];
          D.36340 = *D.36339;
          D.36341 = (int) D.36340;
          D.36342 = __s2 + 2;
          D.36343 = *D.36342;
          D.36344 = (int) D.36343;
          __result = D.36341 - D.36344;
          if (__s1_len > 2) goto <D.36345>; else goto <D.36346>;
          <D.36345>:
          if (__result == 0) goto <D.36347>; else goto <D.36348>;
          <D.36347>:
          D.36349 = &MEM[(void *)"System.Reflection" + 3B];
          D.36350 = *D.36349;
          D.36351 = (int) D.36350;
          D.36352 = __s2 + 3;
          D.36353 = *D.36352;
          D.36354 = (int) D.36353;
          __result = D.36351 - D.36354;
          <D.36348>:
          <D.36346>:
          <D.36338>:
          <D.36336>:
          <D.36328>:
          <D.36326>:
        }
        D.22513 = __result;
      }
      iftmp.608 = D.22513;
      goto <D.36355>;
      <D.36319>:
      D.36356 = class->name_space;
      iftmp.608 = __builtin_strcmp ("System.Reflection", D.36356);
      <D.36355>:
      D.22517 = iftmp.608;
    }
    if (D.22517 == 0) goto <D.36357>; else goto <D.36358>;
    <D.36357>:
    cached_class = class;
    D.36270 = 1;
    return D.36270;
    <D.36358>:
    <D.36316>:
    <D.36274>:
    D.36270 = 0;
    return D.36270;
  }
}


is_sr_mono_generic_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.609;
  gboolean D.36363;
  _Bool D.36364;
  int D.36365;
  int D.22530;
  int iftmp.610;
  int D.22526;
  const char[19] * D.36371;
  unsigned char D.36372;
  int D.36373;
  unsigned char D.36374;
  int D.36375;
  const unsigned char * D.36380;
  unsigned char D.36381;
  int D.36382;
  const unsigned char * D.36383;
  unsigned char D.36384;
  int D.36385;
  const unsigned char * D.36390;
  unsigned char D.36391;
  int D.36392;
  const unsigned char * D.36393;
  unsigned char D.36394;
  int D.36395;
  const unsigned char * D.36400;
  unsigned char D.36401;
  int D.36402;
  const unsigned char * D.36403;
  unsigned char D.36404;
  int D.36405;
  const char * D.36407;
  int D.22539;
  int iftmp.611;
  int D.22535;
  const char[18] * D.36413;
  unsigned char D.36414;
  int D.36415;
  unsigned char D.36416;
  int D.36417;
  const unsigned char * D.36422;
  unsigned char D.36423;
  int D.36424;
  const unsigned char * D.36425;
  unsigned char D.36426;
  int D.36427;
  const unsigned char * D.36432;
  unsigned char D.36433;
  int D.36434;
  const unsigned char * D.36435;
  unsigned char D.36436;
  int D.36437;
  const unsigned char * D.36442;
  unsigned char D.36443;
  int D.36444;
  const unsigned char * D.36445;
  unsigned char D.36446;
  int D.36447;
  const char * D.36449;

  {
    static struct MonoClass * cached_class;

    cached_class.609 = cached_class;
    if (cached_class.609 != 0B) goto <D.36361>; else goto <D.36362>;
    <D.36361>:
    cached_class.609 = cached_class;
    D.36364 = cached_class.609 == class;
    D.36363 = (gboolean) D.36364;
    return D.36363;
    <D.36362>:
    D.36365 = is_corlib_type (class);
    if (D.36365 != 0) goto <D.36366>; else goto <D.36367>;
    <D.36366>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 18;
      if (__s1_len <= 3) goto <D.36369>; else goto <D.36370>;
      <D.36369>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36371 = "MonoGenericCMethod";
        D.36372 = MEM[(const unsigned char *)D.36371];
        D.36373 = (int) D.36372;
        D.36374 = *__s2;
        D.36375 = (int) D.36374;
        __result = D.36373 - D.36375;
        {
          if (__s1_len != 0) goto <D.36376>; else goto <D.36377>;
          <D.36376>:
          if (__result == 0) goto <D.36378>; else goto <D.36379>;
          <D.36378>:
          D.36380 = &MEM[(void *)"MonoGenericCMethod" + 1B];
          D.36381 = *D.36380;
          D.36382 = (int) D.36381;
          D.36383 = __s2 + 1;
          D.36384 = *D.36383;
          D.36385 = (int) D.36384;
          __result = D.36382 - D.36385;
          if (__s1_len > 1) goto <D.36386>; else goto <D.36387>;
          <D.36386>:
          if (__result == 0) goto <D.36388>; else goto <D.36389>;
          <D.36388>:
          D.36390 = &MEM[(void *)"MonoGenericCMethod" + 2B];
          D.36391 = *D.36390;
          D.36392 = (int) D.36391;
          D.36393 = __s2 + 2;
          D.36394 = *D.36393;
          D.36395 = (int) D.36394;
          __result = D.36392 - D.36395;
          if (__s1_len > 2) goto <D.36396>; else goto <D.36397>;
          <D.36396>:
          if (__result == 0) goto <D.36398>; else goto <D.36399>;
          <D.36398>:
          D.36400 = &MEM[(void *)"MonoGenericCMethod" + 3B];
          D.36401 = *D.36400;
          D.36402 = (int) D.36401;
          D.36403 = __s2 + 3;
          D.36404 = *D.36403;
          D.36405 = (int) D.36404;
          __result = D.36402 - D.36405;
          <D.36399>:
          <D.36397>:
          <D.36389>:
          <D.36387>:
          <D.36379>:
          <D.36377>:
        }
        D.22526 = __result;
      }
      iftmp.610 = D.22526;
      goto <D.36406>;
      <D.36370>:
      D.36407 = class->name;
      iftmp.610 = __builtin_strcmp ("MonoGenericCMethod", D.36407);
      <D.36406>:
      D.22530 = iftmp.610;
    }
    if (D.22530 == 0) goto <D.36408>; else goto <D.36409>;
    <D.36408>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 17;
      if (__s1_len <= 3) goto <D.36411>; else goto <D.36412>;
      <D.36411>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name_space;
        D.36413 = "System.Reflection";
        D.36414 = MEM[(const unsigned char *)D.36413];
        D.36415 = (int) D.36414;
        D.36416 = *__s2;
        D.36417 = (int) D.36416;
        __result = D.36415 - D.36417;
        {
          if (__s1_len != 0) goto <D.36418>; else goto <D.36419>;
          <D.36418>:
          if (__result == 0) goto <D.36420>; else goto <D.36421>;
          <D.36420>:
          D.36422 = &MEM[(void *)"System.Reflection" + 1B];
          D.36423 = *D.36422;
          D.36424 = (int) D.36423;
          D.36425 = __s2 + 1;
          D.36426 = *D.36425;
          D.36427 = (int) D.36426;
          __result = D.36424 - D.36427;
          if (__s1_len > 1) goto <D.36428>; else goto <D.36429>;
          <D.36428>:
          if (__result == 0) goto <D.36430>; else goto <D.36431>;
          <D.36430>:
          D.36432 = &MEM[(void *)"System.Reflection" + 2B];
          D.36433 = *D.36432;
          D.36434 = (int) D.36433;
          D.36435 = __s2 + 2;
          D.36436 = *D.36435;
          D.36437 = (int) D.36436;
          __result = D.36434 - D.36437;
          if (__s1_len > 2) goto <D.36438>; else goto <D.36439>;
          <D.36438>:
          if (__result == 0) goto <D.36440>; else goto <D.36441>;
          <D.36440>:
          D.36442 = &MEM[(void *)"System.Reflection" + 3B];
          D.36443 = *D.36442;
          D.36444 = (int) D.36443;
          D.36445 = __s2 + 3;
          D.36446 = *D.36445;
          D.36447 = (int) D.36446;
          __result = D.36444 - D.36447;
          <D.36441>:
          <D.36439>:
          <D.36431>:
          <D.36429>:
          <D.36421>:
          <D.36419>:
        }
        D.22535 = __result;
      }
      iftmp.611 = D.22535;
      goto <D.36448>;
      <D.36412>:
      D.36449 = class->name_space;
      iftmp.611 = __builtin_strcmp ("System.Reflection", D.36449);
      <D.36448>:
      D.22539 = iftmp.611;
    }
    if (D.22539 == 0) goto <D.36450>; else goto <D.36451>;
    <D.36450>:
    cached_class = class;
    D.36363 = 1;
    return D.36363;
    <D.36451>:
    <D.36409>:
    <D.36367>:
    D.36363 = 0;
    return D.36363;
  }
}


mono_reflection_get_custom_attrs_blob (struct MonoReflectionAssembly * assembly, struct MonoObject * ctor, struct MonoArray * ctorArgs, struct MonoArray * properties, struct MonoArray * propValues, struct MonoArray * fields, struct MonoArray * fieldValues)
{
  int D.22668;
  int iftmp.612;
  int D.22667;
  struct MonoVTable * D.36456;
  struct MonoClass * D.36457;
  const char[12] * D.36458;
  unsigned char D.36459;
  int D.36460;
  unsigned char D.36461;
  int D.36462;
  const unsigned char * D.36467;
  unsigned char D.36468;
  int D.36469;
  const unsigned char * D.36470;
  unsigned char D.36471;
  int D.36472;
  const unsigned char * D.36477;
  unsigned char D.36478;
  int D.36479;
  const unsigned char * D.36480;
  unsigned char D.36481;
  int D.36482;
  const unsigned char * D.36487;
  unsigned char D.36488;
  int D.36489;
  const unsigned char * D.36490;
  unsigned char D.36491;
  int D.36492;
  const char * D.36494;
  struct MonoMethod * D.36498;
  unsigned int D.36499;
  short unsigned int D.36500;
  unsigned int D.36501;
  _Bool D.36502;
  long int D.36503;
  long int D.36504;
  unsigned int buflen.613;
  void * buffer.614;
  char * buffer.615;
  char * p.616;
  char * p.617;
  char * p.618;
  char * p.619;
  char * p.620;
  char * D.36515;
  struct MonoAssembly * D.36516;
  struct MonoType * D.36517;
  unsigned int D.36518;
  unsigned int D.36521;
  unsigned int D.36524;
  char * p.621;
  char * p.622;
  char D.36527;
  char * p.623;
  char * p.624;
  unsigned int D.36530;
  char D.36531;
  char * D.36534;
  char * p.625;
  char * p.626;
  struct MonoType * ptype.627;
  char * pname.628;
  char * D.36539;
  void * D.36540;
  unsigned int D.36541;
  char * D.36544;
  char * p.629;
  char * p.630;
  struct MonoType * ftype.631;
  char * fname.632;
  char * D.36549;
  void * D.36550;
  unsigned int D.36551;
  int p.633;
  int buffer.634;
  int D.36554;
  unsigned int buflen.635;
  _Bool D.36556;
  long int D.36557;
  long int D.36558;
  struct MonoDomain * D.36561;
  struct MonoClass * D.36562;
  char * p.636;
  int D.22692;
  int iftmp.637;
  int D.22691;
  unsigned char D.36567;
  int D.36568;
  const unsigned char * D.36573;
  unsigned char D.36574;
  int D.36575;
  const unsigned char * D.36580;
  unsigned char D.36581;
  int D.36582;
  const unsigned char * D.36587;
  unsigned char D.36588;
  int D.36589;
  struct MonoArray * D.36593;
  struct MonoArray * result;
  struct MonoMethodSignature * sig;
  struct MonoObject * arg;
  char * buffer;
  char * p;
  guint32 buflen;
  guint32 i;

  try
    {
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.36456 = ctor->vtable;
          D.36457 = D.36456->klass;
          __s2 = D.36457->name;
          D.36458 = "MonoCMethod";
          D.36459 = MEM[(const unsigned char *)D.36458];
          D.36460 = (int) D.36459;
          D.36461 = *__s2;
          D.36462 = (int) D.36461;
          __result = D.36460 - D.36462;
          {
            if (__s2_len != 0) goto <D.36463>; else goto <D.36464>;
            <D.36463>:
            if (__result == 0) goto <D.36465>; else goto <D.36466>;
            <D.36465>:
            D.36467 = &MEM[(void *)"MonoCMethod" + 1B];
            D.36468 = *D.36467;
            D.36469 = (int) D.36468;
            D.36470 = __s2 + 1;
            D.36471 = *D.36470;
            D.36472 = (int) D.36471;
            __result = D.36469 - D.36472;
            if (__s2_len > 1) goto <D.36473>; else goto <D.36474>;
            <D.36473>:
            if (__result == 0) goto <D.36475>; else goto <D.36476>;
            <D.36475>:
            D.36477 = &MEM[(void *)"MonoCMethod" + 2B];
            D.36478 = *D.36477;
            D.36479 = (int) D.36478;
            D.36480 = __s2 + 2;
            D.36481 = *D.36480;
            D.36482 = (int) D.36481;
            __result = D.36479 - D.36482;
            if (__s2_len > 2) goto <D.36483>; else goto <D.36484>;
            <D.36483>:
            if (__result == 0) goto <D.36485>; else goto <D.36486>;
            <D.36485>:
            D.36487 = &MEM[(void *)"MonoCMethod" + 3B];
            D.36488 = *D.36487;
            D.36489 = (int) D.36488;
            D.36490 = __s2 + 3;
            D.36491 = *D.36490;
            D.36492 = (int) D.36491;
            __result = D.36489 - D.36492;
            <D.36486>:
            <D.36484>:
            <D.36476>:
            <D.36474>:
            <D.36466>:
            <D.36464>:
          }
          D.22667 = __result;
        }
        iftmp.612 = -D.22667;
        goto <D.36493>;
        <D.36455>:
        D.36456 = ctor->vtable;
        D.36457 = D.36456->klass;
        D.36494 = D.36457->name;
        iftmp.612 = __builtin_strcmp (D.36494, "MonoCMethod");
        <D.36493>:
        D.22668 = iftmp.612;
      }
      if (D.22668 != 0) goto <D.36495>; else goto <D.36496>;
      <D.36495>:
      sig = ctor_builder_to_signature (0B, ctor);
      goto <D.36497>;
      <D.36496>:
      D.36498 = MEM[(struct MonoReflectionMethod *)ctor].method;
      sig = mono_method_signature (D.36498);
      <D.36497>:
      D.36499 = mono_array_length (ctorArgs);
      D.36500 = sig->param_count;
      D.36501 = (unsigned int) D.36500;
      D.36502 = D.36499 != D.36501;
      D.36503 = (long int) D.36502;
      D.36504 = __builtin_expect (D.36503, 0);
      if (D.36504 != 0) goto <D.36505>; else goto <D.36506>;
      <D.36505>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9719, "mono_array_length (ctorArgs) == sig->param_count");
      <D.36506>:
      buflen = 256;
      buflen.613 = buflen;
      buffer.614 = monoeg_malloc (buflen.613);
      buffer = buffer.614;
      buffer.615 = buffer;
      p = buffer.615;
      p.616 = p;
      p.617 = p.616;
      p.618 = p.617 + 1;
      p = p.618;
      *p.617 = 1;
      p.616 = p;
      p.619 = p.616;
      p.620 = p.619 + 1;
      p = p.620;
      *p.619 = 0;
      i = 0;
      goto <D.22670>;
      <D.22669>:
      D.36515 = mono_array_addr_with_size (ctorArgs, 4, i);
      arg = MEM[(struct MonoObject * *)D.36515];
      D.36516 = assembly->assembly;
      buffer.615 = buffer;
      p.616 = p;
      D.36517 = sig->params[i];
      encode_cattr_value (D.36516, buffer.615, p.616, &buffer, &p, &buflen, D.36517, arg, 0B);
      i = i + 1;
      <D.22670>:
      D.36500 = sig->param_count;
      D.36518 = (unsigned int) D.36500;
      if (D.36518 > i) goto <D.22669>; else goto <D.22671>;
      <D.22671>:
      i = 0;
      if (properties != 0B) goto <D.36519>; else goto <D.36520>;
      <D.36519>:
      D.36521 = mono_array_length (properties);
      i = D.36521 + i;
      <D.36520>:
      if (fields != 0B) goto <D.36522>; else goto <D.36523>;
      <D.36522>:
      D.36524 = mono_array_length (fields);
      i = D.36524 + i;
      <D.36523>:
      p.616 = p;
      p.621 = p.616;
      p.622 = p.621 + 1;
      p = p.622;
      D.36527 = (char) i;
      *p.621 = D.36527;
      p.616 = p;
      p.623 = p.616;
      p.624 = p.623 + 1;
      p = p.624;
      D.36530 = i >> 8;
      D.36531 = (char) D.36530;
      *p.623 = D.36531;
      if (properties != 0B) goto <D.36532>; else goto <D.36533>;
      <D.36532>:
      {
        struct MonoObject * prop;

        i = 0;
        goto <D.22676>;
        <D.22675>:
        {
          struct MonoType * ptype;
          char * pname;

          try
            {
              D.36534 = mono_array_addr_with_size (properties, 4, i);
              prop = MEM[(void * *)D.36534];
              get_prop_name_and_type (prop, &pname, &ptype);
              p.616 = p;
              p.625 = p.616;
              p.626 = p.625 + 1;
              p = p.626;
              *p.625 = 84;
              buffer.615 = buffer;
              p.616 = p;
              ptype.627 = ptype;
              pname.628 = pname;
              D.36539 = mono_array_addr_with_size (propValues, 4, i);
              D.36540 = MEM[(void * *)D.36539];
              encode_named_val (assembly, buffer.615, p.616, &buffer, &p, &buflen, ptype.627, pname.628, D.36540);
              pname.628 = pname;
              monoeg_g_free (pname.628);
            }
          finally
            {
              ptype = {CLOBBER};
              pname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.22676>:
        D.36541 = mono_array_length (properties);
        if (D.36541 > i) goto <D.22675>; else goto <D.22677>;
        <D.22677>:
      }
      <D.36533>:
      if (fields != 0B) goto <D.36542>; else goto <D.36543>;
      <D.36542>:
      {
        struct MonoObject * field;

        i = 0;
        goto <D.22682>;
        <D.22681>:
        {
          struct MonoType * ftype;
          char * fname;

          try
            {
              D.36544 = mono_array_addr_with_size (fields, 4, i);
              field = MEM[(void * *)D.36544];
              get_field_name_and_type (field, &fname, &ftype);
              p.616 = p;
              p.629 = p.616;
              p.630 = p.629 + 1;
              p = p.630;
              *p.629 = 83;
              buffer.615 = buffer;
              p.616 = p;
              ftype.631 = ftype;
              fname.632 = fname;
              D.36549 = mono_array_addr_with_size (fieldValues, 4, i);
              D.36550 = MEM[(void * *)D.36549];
              encode_named_val (assembly, buffer.615, p.616, &buffer, &p, &buflen, ftype.631, fname.632, D.36550);
              fname.632 = fname;
              monoeg_g_free (fname.632);
            }
          finally
            {
              ftype = {CLOBBER};
              fname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.22682>:
        D.36551 = mono_array_length (fields);
        if (D.36551 > i) goto <D.22681>; else goto <D.22683>;
        <D.22683>:
      }
      <D.36543>:
      p.616 = p;
      p.633 = (int) p.616;
      buffer.615 = buffer;
      buffer.634 = (int) buffer.615;
      D.36554 = p.633 - buffer.634;
      buflen.635 = (unsigned int) D.36554;
      buflen.613 = buflen;
      D.36556 = buflen.635 > buflen.613;
      D.36557 = (long int) D.36556;
      D.36558 = __builtin_expect (D.36557, 0);
      if (D.36558 != 0) goto <D.36559>; else goto <D.36560>;
      <D.36559>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9764, "p - buffer <= buflen");
      <D.36560>:
      p.616 = p;
      p.633 = (int) p.616;
      buffer.615 = buffer;
      buffer.634 = (int) buffer.615;
      D.36554 = p.633 - buffer.634;
      buflen.635 = (unsigned int) D.36554;
      buflen = buflen.635;
      D.36561 = mono_domain_get ();
      D.36562 = mono_defaults.byte_class;
      buflen.613 = buflen;
      result = mono_array_new (D.36561, D.36562, buflen.613);
      p.636 = mono_array_addr_with_size (result, 1, 0);
      p = p.636;
      p.616 = p;
      buffer.615 = buffer;
      buflen.613 = buflen;
      memcpy (p.616, buffer.615, buflen.613);
      buffer.615 = buffer;
      monoeg_g_free (buffer.615);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.36456 = ctor->vtable;
          D.36457 = D.36456->klass;
          __s2 = D.36457->name;
          D.36458 = "MonoCMethod";
          D.36459 = MEM[(const unsigned char *)D.36458];
          D.36460 = (int) D.36459;
          D.36567 = *__s2;
          D.36568 = (int) D.36567;
          __result = D.36460 - D.36568;
          {
            if (__s2_len != 0) goto <D.36569>; else goto <D.36570>;
            <D.36569>:
            if (__result == 0) goto <D.36571>; else goto <D.36572>;
            <D.36571>:
            D.36467 = &MEM[(void *)"MonoCMethod" + 1B];
            D.36468 = *D.36467;
            D.36469 = (int) D.36468;
            D.36573 = __s2 + 1;
            D.36574 = *D.36573;
            D.36575 = (int) D.36574;
            __result = D.36469 - D.36575;
            if (__s2_len > 1) goto <D.36576>; else goto <D.36577>;
            <D.36576>:
            if (__result == 0) goto <D.36578>; else goto <D.36579>;
            <D.36578>:
            D.36477 = &MEM[(void *)"MonoCMethod" + 2B];
            D.36478 = *D.36477;
            D.36479 = (int) D.36478;
            D.36580 = __s2 + 2;
            D.36581 = *D.36580;
            D.36582 = (int) D.36581;
            __result = D.36479 - D.36582;
            if (__s2_len > 2) goto <D.36583>; else goto <D.36584>;
            <D.36583>:
            if (__result == 0) goto <D.36585>; else goto <D.36586>;
            <D.36585>:
            D.36487 = &MEM[(void *)"MonoCMethod" + 3B];
            D.36488 = *D.36487;
            D.36489 = (int) D.36488;
            D.36587 = __s2 + 3;
            D.36588 = *D.36587;
            D.36589 = (int) D.36588;
            __result = D.36489 - D.36589;
            <D.36586>:
            <D.36584>:
            <D.36579>:
            <D.36577>:
            <D.36572>:
            <D.36570>:
          }
          D.22691 = __result;
        }
        iftmp.637 = -D.22691;
        goto <D.36590>;
        <D.36566>:
        D.36456 = ctor->vtable;
        D.36457 = D.36456->klass;
        D.36494 = D.36457->name;
        iftmp.637 = __builtin_strcmp (D.36494, "MonoCMethod");
        <D.36590>:
        D.22692 = iftmp.637;
      }
      if (D.22692 != 0) goto <D.36591>; else goto <D.36592>;
      <D.36591>:
      monoeg_g_free (sig);
      <D.36592>:
      D.36593 = result;
      return D.36593;
    }
  finally
    {
      buffer = {CLOBBER};
      p = {CLOBBER};
      buflen = {CLOBBER};
    }
}


encode_cattr_value (struct MonoAssembly * assembly, char * buffer, char * p, char * * retbuffer, char * * retp, guint32 * buflen, struct MonoType * type, struct MonoObject * arg, char * argval)
{
  char * p.638;
  int p.639;
  char * buffer.640;
  int buffer.641;
  int D.36600;
  int D.36601;
  unsigned int D.36602;
  unsigned int D.36603;
  unsigned int D.36606;
  sizetype D.36607;
  char * p.642;
  unsigned char D.36611;
  char * p.643;
  char * p.644;
  char D.36614;
  char * p.645;
  char * p.646;
  char * p.647;
  struct MonoClass * D.36618;
  unsigned int D.36619;
  unsigned int D.36620;
  struct MonoType * D.36623;
  unsigned char D.36624;
  const char * D.36625;
  char * p.648;
  char * p.649;
  unsigned int D.36630;
  unsigned int D.36631;
  unsigned int D.36632;
  unsigned int D.36635;
  char * p.650;
  char * p.651;
  char * p.652;
  char * p.653;
  struct MonoType * D.36642;
  unsigned int D.36643;
  unsigned int D.36644;
  unsigned int D.36647;
  char * p.654;
  char * p.655;
  char * p.656;
  char * p.657;
  char * p.658;
  char * p.659;
  char * p.660;
  char * p.661;
  char * p.662;
  char * p.663;
  unsigned int D.36660;
  char * p.664;
  char * p.665;
  char D.36663;
  char * p.666;
  char * p.667;
  int D.36666;
  char D.36667;
  char * p.668;
  char * p.669;
  int D.36670;
  char D.36671;
  char * p.670;
  char * p.671;
  unsigned int len.672;
  unsigned int D.36675;
  char D.36676;
  struct MonoVTable * D.36677;
  struct MonoClass * D.36678;
  struct MonoClass * D.36683;
  unsigned int D.36685;
  unsigned int D.36686;
  struct MonoType * D.36688;
  sizetype elsize.673;
  unsigned int D.36691;
  unsigned int D.36692;
  struct MonoType * D.36695;
  sizetype elsize.674;
  unsigned int i.675;
  char * D.36698;
  struct MonoObject * D.36699;
  char * p.676;
  char * p.677;
  char * p.678;
  char * p.679;
  struct MonoClass * D.36706;
  struct MonoObject * D.36707;
  char * p.680;
  char * p.681;
  unsigned int D.36712;
  unsigned int D.36713;
  char * p.682;
  char * p.683;
  struct MonoClass * D.36719;
  char * p.684;
  char * p.685;
  unsigned char D.36724;
  char * p.686;
  char * p.687;
  struct MonoClass * D.36729;
  unsigned char D.36730;
  char * p.688;
  char * p.689;
  char * p.690;
  char * p.691;
  char D.36738;
  struct MonoType * D.36739;
  unsigned char D.36740;
  unsigned char D.36741;
  char * p.692;
  char * p.693;
  char D.36746;
  struct MonoType * D.36747;
  unsigned int D.36748;
  unsigned int D.36749;
  unsigned int D.36752;
  char * p.694;
  char * p.695;
  struct MonoType * D.36755;
  unsigned char D.36756;
  MonoTypeEnum simple_type;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  p.638 = p;
  p.639 = (int) p.638;
  buffer.640 = buffer;
  buffer.641 = (int) buffer.640;
  D.36600 = p.639 - buffer.641;
  D.36601 = D.36600 + 10;
  D.36602 = (unsigned int) D.36601;
  D.36603 = *buflen;
  if (D.36602 >= D.36603) goto <D.36604>; else goto <D.36605>;
  <D.36604>:
  {
    char * newbuf;

    D.36603 = *buflen;
    D.36606 = D.36603 * 2;
    *buflen = D.36606;
    buffer.640 = buffer;
    D.36603 = *buflen;
    newbuf = monoeg_realloc (buffer.640, D.36603);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36600 = p.639 - buffer.641;
    D.36607 = (sizetype) D.36600;
    p.642 = newbuf + D.36607;
    p = p.642;
    buffer = newbuf;
  }
  <D.36605>:
  if (argval == 0B) goto <D.36609>; else goto <D.36610>;
  <D.36609>:
  argval = arg + 8;
  <D.36610>:
  D.36611 = type->type;
  simple_type = (MonoTypeEnum) D.36611;
  handle_enum:
  switch (simple_type) <default: <D.22620>, case 2: <D.22573>, case 3: <D.22577>, case 4: <D.22575>, case 5: <D.22574>, case 6: <D.22579>, case 7: <D.22578>, case 8: <D.22581>, case 9: <D.22580>, case 10: <D.22585>, case 11: <D.22584>, case 12: <D.22582>, case 13: <D.22583>, case 14: <D.22587>, case 17: <D.22586>, case 18: <D.22591>, case 28: <D.22614>, case 29: <D.22596>>
  <D.22573>:
  <D.22574>:
  <D.22575>:
  p.638 = p;
  p.643 = p.638;
  p.644 = p.643 + 1;
  p = p.644;
  D.36614 = *argval;
  *p.643 = D.36614;
  goto <D.22576>;
  <D.22577>:
  <D.22578>:
  <D.22579>:
  p.638 = p;
  swap_with_size (p.638, argval, 2, 1);
  p.638 = p;
  p.645 = p.638 + 2;
  p = p.645;
  goto <D.22576>;
  <D.22580>:
  <D.22581>:
  <D.22582>:
  p.638 = p;
  swap_with_size (p.638, argval, 4, 1);
  p.638 = p;
  p.646 = p.638 + 4;
  p = p.646;
  goto <D.22576>;
  <D.22583>:
  p.638 = p;
  swap_with_size (p.638, argval, 8, 1);
  p.638 = p;
  p.647 = p.638 + 8;
  p = p.647;
  goto <D.22576>;
  <D.22584>:
  <D.22585>:
  p.638 = p;
  swap_with_size (p.638, argval, 8, 1);
  p.638 = p;
  p.647 = p.638 + 8;
  p = p.647;
  goto <D.22576>;
  <D.22586>:
  D.36618 = type->data.klass;
  D.36619 = BIT_FIELD_REF <*D.36618, 32, 160>;
  D.36620 = D.36619 & 16;
  if (D.36620 != 0) goto <D.36621>; else goto <D.36622>;
  <D.36621>:
  D.36618 = type->data.klass;
  D.36623 = mono_class_enum_basetype (D.36618);
  D.36624 = D.36623->type;
  simple_type = (MonoTypeEnum) D.36624;
  goto handle_enum;
  <D.36622>:
  D.36618 = type->data.klass;
  D.36625 = D.36618->name;
  monoeg_g_log (0B, 16, "generic valutype %s not handled in custom attr value decoding", D.36625);
  goto <D.22576>;
  <D.22587>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36626>; else goto <D.36627>;
    <D.36626>:
    p.638 = p;
    p.648 = p.638;
    p.649 = p.648 + 1;
    p = p.649;
    *p.648 = -1;
    goto <D.22576>;
    <D.36627>:
    str = mono_string_to_utf8 (arg);
    slen = strlen (str);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36600 = p.639 - buffer.641;
    D.36630 = (unsigned int) D.36600;
    D.36631 = D.36630 + slen;
    D.36632 = D.36631 + 10;
    D.36603 = *buflen;
    if (D.36632 >= D.36603) goto <D.36633>; else goto <D.36634>;
    <D.36633>:
    {
      char * newbuf;

      D.36603 = *buflen;
      D.36606 = D.36603 * 2;
      *buflen = D.36606;
      D.36603 = *buflen;
      D.36635 = D.36603 + slen;
      *buflen = D.36635;
      buffer.640 = buffer;
      D.36603 = *buflen;
      newbuf = monoeg_realloc (buffer.640, D.36603);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36600 = p.639 - buffer.641;
      D.36607 = (sizetype) D.36600;
      p.650 = newbuf + D.36607;
      p = p.650;
      buffer = newbuf;
    }
    <D.36634>:
    p.638 = p;
    mono_metadata_encode_value (slen, p.638, &p);
    p.638 = p;
    memcpy (p.638, str, slen);
    p.638 = p;
    p.651 = p.638 + slen;
    p = p.651;
    monoeg_g_free (str);
    goto <D.22576>;
  }
  <D.22591>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36638>; else goto <D.36639>;
    <D.36638>:
    p.638 = p;
    p.652 = p.638;
    p.653 = p.652 + 1;
    p = p.653;
    *p.652 = -1;
    goto <D.22576>;
    <D.36639>:
    handle_type:
    D.36642 = mono_reflection_type_get_handle (arg);
    str = type_get_qualified_name (D.36642, 0B);
    slen = strlen (str);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36600 = p.639 - buffer.641;
    D.36630 = (unsigned int) D.36600;
    D.36643 = D.36630 + slen;
    D.36644 = D.36643 + 10;
    D.36603 = *buflen;
    if (D.36644 >= D.36603) goto <D.36645>; else goto <D.36646>;
    <D.36645>:
    {
      char * newbuf;

      D.36603 = *buflen;
      D.36606 = D.36603 * 2;
      *buflen = D.36606;
      D.36603 = *buflen;
      D.36647 = D.36603 + slen;
      *buflen = D.36647;
      buffer.640 = buffer;
      D.36603 = *buflen;
      newbuf = monoeg_realloc (buffer.640, D.36603);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36600 = p.639 - buffer.641;
      D.36607 = (sizetype) D.36600;
      p.654 = newbuf + D.36607;
      p = p.654;
      buffer = newbuf;
    }
    <D.36646>:
    p.638 = p;
    mono_metadata_encode_value (slen, p.638, &p);
    p.638 = p;
    memcpy (p.638, str, slen);
    p.638 = p;
    p.655 = p.638 + slen;
    p = p.655;
    monoeg_g_free (str);
    goto <D.22576>;
  }
  <D.22596>:
  {
    int len;
    int i;
    struct MonoClass * eclass;
    struct MonoClass * arg_eclass;

    if (arg == 0B) goto <D.36650>; else goto <D.36651>;
    <D.36650>:
    p.638 = p;
    p.656 = p.638;
    p.657 = p.656 + 1;
    p = p.657;
    *p.656 = -1;
    p.638 = p;
    p.658 = p.638;
    p.659 = p.658 + 1;
    p = p.659;
    *p.658 = -1;
    p.638 = p;
    p.660 = p.638;
    p.661 = p.660 + 1;
    p = p.661;
    *p.660 = -1;
    p.638 = p;
    p.662 = p.638;
    p.663 = p.662 + 1;
    p = p.663;
    *p.662 = -1;
    goto <D.22576>;
    <D.36651>:
    D.36660 = mono_array_length (arg);
    len = (int) D.36660;
    p.638 = p;
    p.664 = p.638;
    p.665 = p.664 + 1;
    p = p.665;
    D.36663 = (char) len;
    *p.664 = D.36663;
    p.638 = p;
    p.666 = p.638;
    p.667 = p.666 + 1;
    p = p.667;
    D.36666 = len >> 8;
    D.36667 = (char) D.36666;
    *p.666 = D.36667;
    p.638 = p;
    p.668 = p.638;
    p.669 = p.668 + 1;
    p = p.669;
    D.36670 = len >> 16;
    D.36671 = (char) D.36670;
    *p.668 = D.36671;
    p.638 = p;
    p.670 = p.638;
    p.671 = p.670 + 1;
    p = p.671;
    len.672 = (unsigned int) len;
    D.36675 = len.672 >> 24;
    D.36676 = (char) D.36675;
    *p.670 = D.36676;
    p.638 = p;
    *retp = p.638;
    buffer.640 = buffer;
    *retbuffer = buffer.640;
    eclass = type->data.klass;
    D.36677 = arg->vtable;
    D.36678 = D.36677->klass;
    arg_eclass = D.36678->element_class;
    if (eclass == 0B) goto <D.36679>; else goto <D.36680>;
    <D.36679>:
    eclass = mono_defaults.object_class;
    <D.36680>:
    D.36683 = mono_defaults.object_class;
    if (D.36683 == eclass) goto <D.36684>; else goto <D.36681>;
    <D.36684>:
    D.36685 = BIT_FIELD_REF <*arg_eclass, 32, 160>;
    D.36686 = D.36685 & 8;
    if (D.36686 != 0) goto <D.36687>; else goto <D.36681>;
    <D.36687>:
    {
      char * elptr;
      int elsize;

      elptr = mono_array_addr_with_size (arg, 1, 0);
      elsize = mono_class_array_element_size (arg_eclass);
      i = 0;
      goto <D.22604>;
      <D.22603>:
      buffer.640 = buffer;
      p.638 = p;
      D.36688 = &arg_eclass->byval_arg;
      encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36688, 0B, elptr);
      elsize.673 = (sizetype) elsize;
      elptr = elptr + elsize.673;
      i = i + 1;
      <D.22604>:
      if (i < len) goto <D.22603>; else goto <D.22605>;
      <D.22605>:
    }
    goto <D.36682>;
    <D.36681>:
    D.36691 = BIT_FIELD_REF <*eclass, 32, 160>;
    D.36692 = D.36691 & 8;
    if (D.36692 != 0) goto <D.36693>; else goto <D.36690>;
    <D.36693>:
    D.36685 = BIT_FIELD_REF <*arg_eclass, 32, 160>;
    D.36686 = D.36685 & 8;
    if (D.36686 != 0) goto <D.36694>; else goto <D.36690>;
    <D.36694>:
    {
      char * elptr;
      int elsize;

      elptr = mono_array_addr_with_size (arg, 1, 0);
      elsize = mono_class_array_element_size (eclass);
      i = 0;
      goto <D.22609>;
      <D.22608>:
      buffer.640 = buffer;
      p.638 = p;
      D.36695 = &eclass->byval_arg;
      encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36695, 0B, elptr);
      elsize.674 = (sizetype) elsize;
      elptr = elptr + elsize.674;
      i = i + 1;
      <D.22609>:
      if (i < len) goto <D.22608>; else goto <D.22610>;
      <D.22610>:
    }
    goto <D.22613>;
    <D.36690>:
    i = 0;
    goto <D.22612>;
    <D.22611>:
    buffer.640 = buffer;
    p.638 = p;
    D.36695 = &eclass->byval_arg;
    i.675 = (unsigned int) i;
    D.36698 = mono_array_addr_with_size (arg, 4, i.675);
    D.36699 = MEM[(struct MonoObject * *)D.36698];
    encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36695, D.36699, 0B);
    i = i + 1;
    <D.22612>:
    if (i < len) goto <D.22611>; else goto <D.22613>;
    <D.22613>:
    <D.36682>:
    goto <D.22576>;
  }
  <D.22614>:
  {
    struct MonoClass * klass;
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36700>; else goto <D.36701>;
    <D.36700>:
    p.638 = p;
    p.676 = p.638;
    p.677 = p.676 + 1;
    p = p.677;
    *p.676 = 14;
    p.638 = p;
    p.678 = p.638;
    p.679 = p.678 + 1;
    p = p.679;
    *p.678 = -1;
    goto <D.22576>;
    <D.36701>:
    D.36677 = arg->vtable;
    klass = D.36677->klass;
    D.36706 = mono_defaults.systemtype_class;
    D.36707 = mono_object_isinst (arg, D.36706);
    if (D.36707 != 0B) goto <D.36708>; else goto <D.36709>;
    <D.36708>:
    p.638 = p;
    p.680 = p.638;
    p.681 = p.680 + 1;
    p = p.681;
    *p.680 = 80;
    goto handle_type;
    <D.36709>:
    D.36712 = BIT_FIELD_REF <*klass, 32, 160>;
    D.36713 = D.36712 & 16;
    if (D.36713 != 0) goto <D.36714>; else goto <D.36715>;
    <D.36714>:
    p.638 = p;
    p.682 = p.638;
    p.683 = p.682 + 1;
    p = p.683;
    *p.682 = 85;
    goto <D.36718>;
    <D.36715>:
    D.36719 = mono_defaults.string_class;
    if (D.36719 == klass) goto <D.36720>; else goto <D.36721>;
    <D.36720>:
    simple_type = 14;
    p.638 = p;
    p.684 = p.638;
    p.685 = p.684 + 1;
    p = p.685;
    *p.684 = 14;
    goto handle_enum;
    <D.36721>:
    D.36724 = klass->rank;
    if (D.36724 == 1) goto <D.36725>; else goto <D.36726>;
    <D.36725>:
    p.638 = p;
    p.686 = p.638;
    p.687 = p.686 + 1;
    p = p.687;
    *p.686 = 29;
    D.36729 = klass->element_class;
    D.36730 = D.36729->byval_arg.type;
    if (D.36730 == 28) goto <D.36731>; else goto <D.36732>;
    <D.36731>:
    p.638 = p;
    p.688 = p.638;
    p.689 = p.688 + 1;
    p = p.689;
    *p.688 = 81;
    goto <D.36735>;
    <D.36732>:
    p.638 = p;
    p.690 = p.638;
    p.691 = p.690 + 1;
    p = p.691;
    D.36729 = klass->element_class;
    D.36730 = D.36729->byval_arg.type;
    D.36738 = (char) D.36730;
    *p.690 = D.36738;
    <D.36735>:
    buffer.640 = buffer;
    p.638 = p;
    D.36739 = &klass->byval_arg;
    encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36739, arg, 0B);
    goto <D.22576>;
    <D.36726>:
    D.36740 = klass->byval_arg.type;
    D.36741 = D.36740 + 254;
    if (D.36741 <= 11) goto <D.36742>; else goto <D.36743>;
    <D.36742>:
    p.638 = p;
    p.692 = p.638;
    p.693 = p.692 + 1;
    p = p.693;
    D.36740 = klass->byval_arg.type;
    simple_type = (MonoTypeEnum) D.36740;
    D.36746 = (char) simple_type;
    *p.692 = D.36746;
    goto handle_enum;
    <D.36743>:
    monoeg_g_log (0B, 4, "unhandled type in custom attr");
    <D.22618>:
    goto <D.22618>;
    <D.36718>:
    D.36747 = mono_class_get_type (klass);
    str = type_get_qualified_name (D.36747, 0B);
    slen = strlen (str);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36600 = p.639 - buffer.641;
    D.36630 = (unsigned int) D.36600;
    D.36748 = D.36630 + slen;
    D.36749 = D.36748 + 10;
    D.36603 = *buflen;
    if (D.36749 >= D.36603) goto <D.36750>; else goto <D.36751>;
    <D.36750>:
    {
      char * newbuf;

      D.36603 = *buflen;
      D.36606 = D.36603 * 2;
      *buflen = D.36606;
      D.36603 = *buflen;
      D.36752 = D.36603 + slen;
      *buflen = D.36752;
      buffer.640 = buffer;
      D.36603 = *buflen;
      newbuf = monoeg_realloc (buffer.640, D.36603);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36600 = p.639 - buffer.641;
      D.36607 = (sizetype) D.36600;
      p.694 = newbuf + D.36607;
      p = p.694;
      buffer = newbuf;
    }
    <D.36751>:
    p.638 = p;
    mono_metadata_encode_value (slen, p.638, &p);
    p.638 = p;
    memcpy (p.638, str, slen);
    p.638 = p;
    p.695 = p.638 + slen;
    p = p.695;
    monoeg_g_free (str);
    D.36755 = mono_class_enum_basetype (klass);
    D.36756 = D.36755->type;
    simple_type = (MonoTypeEnum) D.36756;
    goto handle_enum;
  }
  <D.22620>:
  monoeg_g_log (0B, 4, "type 0x%02x not yet supported in custom attr encoder", simple_type);
  <D.22621>:
  goto <D.22621>;
  <D.22576>:
  p.638 = p;
  *retp = p.638;
  buffer.640 = buffer;
  *retbuffer = buffer.640;
}


swap_with_size (char * dest, const char * val, int len, int nelem)
{
  int D.36757;
  unsigned int D.36758;

  D.36757 = len * nelem;
  D.36758 = (unsigned int) D.36757;
  memcpy (dest, val, D.36758);
}


type_get_qualified_name (struct MonoType * type, struct MonoAssembly * ass)
{
  char * D.36761;
  struct MonoImage * D.36762;
  unsigned char D.36765;
  struct MonoGenericClass * D.36769;
  struct MonoGenericContainer * D.36771;
  struct MonoClass * klass;
  struct MonoAssembly * ta;

  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.36759>; else goto <D.36760>;
  <D.36759>:
  D.36761 = mono_type_get_name_full (type, 1);
  return D.36761;
  <D.36760>:
  D.36762 = klass->image;
  ta = D.36762->assembly;
  D.36765 = ta->dynamic;
  if (D.36765 != 0) goto <D.36763>; else goto <D.36766>;
  <D.36766>:
  if (ta == ass) goto <D.36763>; else goto <D.36764>;
  <D.36763>:
  D.36769 = klass->generic_class;
  if (D.36769 != 0B) goto <D.36767>; else goto <D.36770>;
  <D.36770>:
  D.36771 = klass->generic_container;
  if (D.36771 != 0B) goto <D.36767>; else goto <D.36768>;
  <D.36767>:
  D.36761 = mono_type_get_name_full (type, 2);
  return D.36761;
  <D.36768>:
  D.36761 = mono_type_get_name_full (type, 1);
  return D.36761;
  <D.36764>:
  D.36761 = mono_type_get_name_full (type, 3);
  return D.36761;
}


get_prop_name_and_type (struct MonoObject * prop, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.36773;
  int D.22388;
  int iftmp.696;
  int D.22387;
  const char[16] * D.36777;
  unsigned char D.36778;
  int D.36779;
  unsigned char D.36780;
  int D.36781;
  const unsigned char * D.36786;
  unsigned char D.36787;
  int D.36788;
  const unsigned char * D.36789;
  unsigned char D.36790;
  int D.36791;
  const unsigned char * D.36796;
  unsigned char D.36797;
  int D.36798;
  const unsigned char * D.36799;
  unsigned char D.36800;
  int D.36801;
  const unsigned char * D.36806;
  unsigned char D.36807;
  int D.36808;
  const unsigned char * D.36809;
  unsigned char D.36810;
  int D.36811;
  const char * D.36813;
  struct MonoString * D.36816;
  char * D.36817;
  struct MonoObject * D.36818;
  struct MonoType * D.36819;
  struct MonoProperty * D.36821;
  const char * D.36822;
  gchar * D.36823;
  struct MonoMethod * D.36824;
  struct MonoMethodSignature * D.36827;
  struct MonoType * D.36828;
  struct MonoMethod * D.36830;
  struct MonoMethodSignature * D.36831;
  struct MonoMethodSignature * D.36832;
  short unsigned int D.36833;
  int D.36834;
  int D.36835;
  struct MonoType * D.36836;
  struct MonoClass * klass;

  D.36773 = prop->vtable;
  klass = D.36773->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36777 = "PropertyBuilder";
      D.36778 = MEM[(const unsigned char *)D.36777];
      D.36779 = (int) D.36778;
      D.36780 = *__s2;
      D.36781 = (int) D.36780;
      __result = D.36779 - D.36781;
      {
        if (__s2_len != 0) goto <D.36782>; else goto <D.36783>;
        <D.36782>:
        if (__result == 0) goto <D.36784>; else goto <D.36785>;
        <D.36784>:
        D.36786 = &MEM[(void *)"PropertyBuilder" + 1B];
        D.36787 = *D.36786;
        D.36788 = (int) D.36787;
        D.36789 = __s2 + 1;
        D.36790 = *D.36789;
        D.36791 = (int) D.36790;
        __result = D.36788 - D.36791;
        if (__s2_len > 1) goto <D.36792>; else goto <D.36793>;
        <D.36792>:
        if (__result == 0) goto <D.36794>; else goto <D.36795>;
        <D.36794>:
        D.36796 = &MEM[(void *)"PropertyBuilder" + 2B];
        D.36797 = *D.36796;
        D.36798 = (int) D.36797;
        D.36799 = __s2 + 2;
        D.36800 = *D.36799;
        D.36801 = (int) D.36800;
        __result = D.36798 - D.36801;
        if (__s2_len > 2) goto <D.36802>; else goto <D.36803>;
        <D.36802>:
        if (__result == 0) goto <D.36804>; else goto <D.36805>;
        <D.36804>:
        D.36806 = &MEM[(void *)"PropertyBuilder" + 3B];
        D.36807 = *D.36806;
        D.36808 = (int) D.36807;
        D.36809 = __s2 + 3;
        D.36810 = *D.36809;
        D.36811 = (int) D.36810;
        __result = D.36808 - D.36811;
        <D.36805>:
        <D.36803>:
        <D.36795>:
        <D.36793>:
        <D.36785>:
        <D.36783>:
      }
      D.22387 = __result;
    }
    iftmp.696 = -D.22387;
    goto <D.36812>;
    <D.36776>:
    D.36813 = klass->name;
    iftmp.696 = __builtin_strcmp (D.36813, "PropertyBuilder");
    <D.36812>:
    D.22388 = iftmp.696;
  }
  if (D.22388 == 0) goto <D.36814>; else goto <D.36815>;
  <D.36814>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    pb = prop;
    D.36816 = pb->name;
    D.36817 = mono_string_to_utf8 (D.36816);
    *name = D.36817;
    D.36818 = pb->type;
    D.36819 = mono_reflection_type_get_handle (D.36818);
    *type = D.36819;
  }
  goto <D.36820>;
  <D.36815>:
  {
    struct MonoReflectionProperty * p;

    p = prop;
    D.36821 = p->property;
    D.36822 = D.36821->name;
    D.36823 = monoeg_strdup (D.36822);
    *name = D.36823;
    D.36821 = p->property;
    D.36824 = D.36821->get;
    if (D.36824 != 0B) goto <D.36825>; else goto <D.36826>;
    <D.36825>:
    D.36821 = p->property;
    D.36824 = D.36821->get;
    D.36827 = mono_method_signature (D.36824);
    D.36828 = D.36827->ret;
    *type = D.36828;
    goto <D.36829>;
    <D.36826>:
    D.36821 = p->property;
    D.36830 = D.36821->set;
    D.36831 = mono_method_signature (D.36830);
    D.36821 = p->property;
    D.36830 = D.36821->set;
    D.36832 = mono_method_signature (D.36830);
    D.36833 = D.36832->param_count;
    D.36834 = (int) D.36833;
    D.36835 = D.36834 + -1;
    D.36836 = D.36831->params[D.36835];
    *type = D.36836;
    <D.36829>:
  }
  <D.36820>:
}


get_field_name_and_type (struct MonoObject * field, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.36837;
  int D.22405;
  int iftmp.697;
  int D.22404;
  const char[13] * D.36841;
  unsigned char D.36842;
  int D.36843;
  unsigned char D.36844;
  int D.36845;
  const unsigned char * D.36850;
  unsigned char D.36851;
  int D.36852;
  const unsigned char * D.36853;
  unsigned char D.36854;
  int D.36855;
  const unsigned char * D.36860;
  unsigned char D.36861;
  int D.36862;
  const unsigned char * D.36863;
  unsigned char D.36864;
  int D.36865;
  const unsigned char * D.36870;
  unsigned char D.36871;
  int D.36872;
  const unsigned char * D.36873;
  unsigned char D.36874;
  int D.36875;
  const char * D.36877;
  struct MonoString * D.36880;
  char * D.36881;
  struct MonoObject * D.36882;
  struct MonoType * D.36883;
  struct MonoClassField * D.36885;
  const char * D.36886;
  gchar * D.36887;
  struct MonoType * D.36888;
  struct MonoClass * klass;

  D.36837 = field->vtable;
  klass = D.36837->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36841 = "FieldBuilder";
      D.36842 = MEM[(const unsigned char *)D.36841];
      D.36843 = (int) D.36842;
      D.36844 = *__s2;
      D.36845 = (int) D.36844;
      __result = D.36843 - D.36845;
      {
        if (__s2_len != 0) goto <D.36846>; else goto <D.36847>;
        <D.36846>:
        if (__result == 0) goto <D.36848>; else goto <D.36849>;
        <D.36848>:
        D.36850 = &MEM[(void *)"FieldBuilder" + 1B];
        D.36851 = *D.36850;
        D.36852 = (int) D.36851;
        D.36853 = __s2 + 1;
        D.36854 = *D.36853;
        D.36855 = (int) D.36854;
        __result = D.36852 - D.36855;
        if (__s2_len > 1) goto <D.36856>; else goto <D.36857>;
        <D.36856>:
        if (__result == 0) goto <D.36858>; else goto <D.36859>;
        <D.36858>:
        D.36860 = &MEM[(void *)"FieldBuilder" + 2B];
        D.36861 = *D.36860;
        D.36862 = (int) D.36861;
        D.36863 = __s2 + 2;
        D.36864 = *D.36863;
        D.36865 = (int) D.36864;
        __result = D.36862 - D.36865;
        if (__s2_len > 2) goto <D.36866>; else goto <D.36867>;
        <D.36866>:
        if (__result == 0) goto <D.36868>; else goto <D.36869>;
        <D.36868>:
        D.36870 = &MEM[(void *)"FieldBuilder" + 3B];
        D.36871 = *D.36870;
        D.36872 = (int) D.36871;
        D.36873 = __s2 + 3;
        D.36874 = *D.36873;
        D.36875 = (int) D.36874;
        __result = D.36872 - D.36875;
        <D.36869>:
        <D.36867>:
        <D.36859>:
        <D.36857>:
        <D.36849>:
        <D.36847>:
      }
      D.22404 = __result;
    }
    iftmp.697 = -D.22404;
    goto <D.36876>;
    <D.36840>:
    D.36877 = klass->name;
    iftmp.697 = __builtin_strcmp (D.36877, "FieldBuilder");
    <D.36876>:
    D.22405 = iftmp.697;
  }
  if (D.22405 == 0) goto <D.36878>; else goto <D.36879>;
  <D.36878>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = field;
    D.36880 = fb->name;
    D.36881 = mono_string_to_utf8 (D.36880);
    *name = D.36881;
    D.36882 = fb->type;
    D.36883 = mono_reflection_type_get_handle (D.36882);
    *type = D.36883;
  }
  goto <D.36884>;
  <D.36879>:
  {
    struct MonoReflectionField * f;

    f = field;
    D.36885 = f->field;
    D.36886 = mono_field_get_name (D.36885);
    D.36887 = monoeg_strdup (D.36886);
    *name = D.36887;
    D.36885 = f->field;
    D.36888 = D.36885->type;
    *type = D.36888;
  }
  <D.36884>:
}


encode_named_val (struct MonoReflectionAssembly * assembly, char * buffer, char * p, char * * retbuffer, char * * retp, guint32 * buflen, struct MonoType * type, char * name, struct MonoObject * value)
{
  unsigned char D.36891;
  struct MonoClass * D.36893;
  unsigned int D.36894;
  unsigned int D.36895;
  unsigned int D.36897;
  struct MonoType * D.36902;
  unsigned int D.36903;
  unsigned int D.36904;
  unsigned int len.698;
  unsigned int D.36906;
  char * p.699;
  int p.700;
  char * buffer.701;
  int buffer.702;
  int D.36911;
  int D.36912;
  int D.36913;
  unsigned int D.36914;
  unsigned int D.36915;
  unsigned int D.36918;
  unsigned int len.703;
  unsigned int D.36920;
  sizetype D.36921;
  char * p.704;
  unsigned int D.36923;
  unsigned int len.705;
  sizetype len.706;
  char * p.707;
  struct MonoAssembly * D.36927;
  int len;

  D.36891 = type->type;
  if (D.36891 == 17) goto <D.36892>; else goto <D.36889>;
  <D.36892>:
  D.36893 = type->data.klass;
  D.36894 = BIT_FIELD_REF <*D.36893, 32, 160>;
  D.36895 = D.36894 & 16;
  if (D.36895 != 0) goto <D.36896>; else goto <D.36889>;
  <D.36896>:
  {
    char * str;

    str = type_get_qualified_name (type, 0B);
    D.36897 = strlen (str);
    len = (int) D.36897;
    monoeg_g_free (str);
  }
  goto <D.36890>;
  <D.36889>:
  D.36891 = type->type;
  if (D.36891 == 29) goto <D.36900>; else goto <D.36898>;
  <D.36900>:
  D.36893 = type->data.klass;
  D.36894 = BIT_FIELD_REF <*D.36893, 32, 160>;
  D.36895 = D.36894 & 16;
  if (D.36895 != 0) goto <D.36901>; else goto <D.36898>;
  <D.36901>:
  {
    char * str;

    D.36893 = type->data.klass;
    D.36902 = &D.36893->byval_arg;
    str = type_get_qualified_name (D.36902, 0B);
    D.36903 = strlen (str);
    len = (int) D.36903;
    monoeg_g_free (str);
  }
  goto <D.36899>;
  <D.36898>:
  len = 0;
  <D.36899>:
  <D.36890>:
  D.36904 = strlen (name);
  len.698 = (unsigned int) len;
  D.36906 = D.36904 + len.698;
  len = (int) D.36906;
  p.699 = p;
  p.700 = (int) p.699;
  buffer.701 = buffer;
  buffer.702 = (int) buffer.701;
  D.36911 = p.700 - buffer.702;
  D.36912 = D.36911 + 20;
  D.36913 = D.36912 + len;
  D.36914 = (unsigned int) D.36913;
  D.36915 = *buflen;
  if (D.36914 >= D.36915) goto <D.36916>; else goto <D.36917>;
  <D.36916>:
  {
    char * newbuf;

    D.36915 = *buflen;
    D.36918 = D.36915 * 2;
    *buflen = D.36918;
    D.36915 = *buflen;
    len.703 = (unsigned int) len;
    D.36920 = D.36915 + len.703;
    *buflen = D.36920;
    buffer.701 = buffer;
    D.36915 = *buflen;
    newbuf = monoeg_realloc (buffer.701, D.36915);
    p.699 = p;
    p.700 = (int) p.699;
    buffer.701 = buffer;
    buffer.702 = (int) buffer.701;
    D.36911 = p.700 - buffer.702;
    D.36921 = (sizetype) D.36911;
    p.704 = newbuf + D.36921;
    p = p.704;
    buffer = newbuf;
  }
  <D.36917>:
  p.699 = p;
  encode_field_or_prop_type (type, p.699, &p);
  D.36923 = strlen (name);
  len = (int) D.36923;
  len.705 = (unsigned int) len;
  p.699 = p;
  mono_metadata_encode_value (len.705, p.699, &p);
  p.699 = p;
  len.698 = (unsigned int) len;
  memcpy (p.699, name, len.698);
  p.699 = p;
  len.706 = (sizetype) len;
  p.707 = p.699 + len.706;
  p = p.707;
  D.36927 = assembly->assembly;
  buffer.701 = buffer;
  p.699 = p;
  encode_cattr_value (D.36927, buffer.701, p.699, &buffer, &p, buflen, type, value, 0B);
  p.699 = p;
  *retp = p.699;
  buffer.701 = buffer;
  *retbuffer = buffer.701;
}


encode_field_or_prop_type (struct MonoType * type, char * p, char * * retp)
{
  unsigned char D.36930;
  struct MonoClass * D.36932;
  unsigned int D.36933;
  unsigned int D.36934;
  unsigned int D.36936;
  char * p.708;
  char * p.709;
  char * p.710;
  unsigned int slen.711;
  unsigned int slen.712;
  sizetype slen.713;
  char * p.714;
  char * p.715;
  char * p.716;
  char * p.717;
  char * p.718;
  unsigned int D.36954;
  struct MonoType * D.36957;

  D.36930 = type->type;
  if (D.36930 == 17) goto <D.36931>; else goto <D.36928>;
  <D.36931>:
  D.36932 = type->data.klass;
  D.36933 = BIT_FIELD_REF <*D.36932, 32, 160>;
  D.36934 = D.36933 & 16;
  if (D.36934 != 0) goto <D.36935>; else goto <D.36928>;
  <D.36935>:
  {
    char * str;
    int slen;

    str = type_get_qualified_name (type, 0B);
    D.36936 = strlen (str);
    slen = (int) D.36936;
    p.708 = p;
    p.709 = p.708;
    p.710 = p.709 + 1;
    p = p.710;
    *p.709 = 85;
    slen.711 = (unsigned int) slen;
    p.708 = p;
    mono_metadata_encode_value (slen.711, p.708, &p);
    p.708 = p;
    slen.712 = (unsigned int) slen;
    memcpy (p.708, str, slen.712);
    p.708 = p;
    slen.713 = (sizetype) slen;
    p.714 = p.708 + slen.713;
    p = p.714;
    monoeg_g_free (str);
  }
  goto <D.36929>;
  <D.36928>:
  D.36930 = type->type;
  if (D.36930 == 28) goto <D.36944>; else goto <D.36945>;
  <D.36944>:
  p.708 = p;
  p.715 = p.708;
  p.716 = p.715 + 1;
  p = p.716;
  *p.715 = 81;
  goto <D.36948>;
  <D.36945>:
  D.36930 = type->type;
  if (D.36930 == 18) goto <D.36949>; else goto <D.36950>;
  <D.36949>:
  p.708 = p;
  p.717 = p.708;
  p.718 = p.717 + 1;
  p = p.718;
  *p.717 = 80;
  goto <D.36953>;
  <D.36950>:
  D.36930 = type->type;
  D.36954 = (unsigned int) D.36930;
  p.708 = p;
  mono_metadata_encode_value (D.36954, p.708, &p);
  D.36930 = type->type;
  if (D.36930 == 29) goto <D.36955>; else goto <D.36956>;
  <D.36955>:
  D.36932 = type->data.klass;
  D.36957 = &D.36932->byval_arg;
  p.708 = p;
  encode_field_or_prop_type (D.36957, p.708, &p);
  <D.36956>:
  <D.36953>:
  <D.36948>:
  <D.36929>:
  p.708 = p;
  *retp = p.708;
}


mono_reflection_setup_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoObject * D.36958;
  struct MonoReflectionType * D.36959;
  int D.22707;
  int iftmp.719;
  int D.22706;
  struct MonoVTable * D.36965;
  struct MonoClass * D.36966;
  const char[12] * D.36967;
  unsigned char D.36968;
  int D.36969;
  unsigned char D.36970;
  int D.36971;
  const unsigned char * D.36976;
  unsigned char D.36977;
  int D.36978;
  const unsigned char * D.36979;
  unsigned char D.36980;
  int D.36981;
  const unsigned char * D.36986;
  unsigned char D.36987;
  int D.36988;
  const unsigned char * D.36989;
  unsigned char D.36990;
  int D.36991;
  const unsigned char * D.36996;
  unsigned char D.36997;
  int D.36998;
  const unsigned char * D.36999;
  unsigned char D.37000;
  int D.37001;
  const char * D.37003;
  struct MonoType * D.37006;
  struct MonoType * D.37008;
  struct MonoType * D.37010;
  struct MonoReflectionModuleBuilder * D.37013;
  struct MonoDynamicImage * D.37014;
  struct MonoImage * D.37015;
  struct MonoImage * D.37016;
  struct MonoString * D.37017;
  char * D.37018;
  int D.37019;
  struct MonoString * D.37021;
  char * D.37022;
  int D.37023;
  unsigned int D.37025;
  unsigned int D.37026;
  unsigned int D.37027;
  void * D.37028;
  struct MonoReflectionType * D.37031;
  const char * D.37034;
  const char * D.37035;
  void * D.37037;
  _Bool D.37038;
  long int D.37039;
  long int D.37040;
  struct MonoGHashTable * D.37043;
  void * D.37044;
  int D.22717;
  int iftmp.720;
  int D.22716;
  const char[7] * D.37051;
  unsigned char D.37052;
  int D.37053;
  unsigned char D.37054;
  int D.37055;
  const unsigned char * D.37060;
  unsigned char D.37061;
  int D.37062;
  const unsigned char * D.37063;
  unsigned char D.37064;
  int D.37065;
  const unsigned char * D.37070;
  unsigned char D.37071;
  int D.37072;
  const unsigned char * D.37073;
  unsigned char D.37074;
  int D.37075;
  const unsigned char * D.37080;
  unsigned char D.37081;
  int D.37082;
  const unsigned char * D.37083;
  unsigned char D.37084;
  int D.37085;
  int D.22726;
  int iftmp.721;
  int D.22725;
  const char[7] * D.37092;
  unsigned char D.37093;
  int D.37094;
  unsigned char D.37095;
  int D.37096;
  const unsigned char * D.37101;
  unsigned char D.37102;
  int D.37103;
  const unsigned char * D.37104;
  unsigned char D.37105;
  int D.37106;
  const unsigned char * D.37111;
  unsigned char D.37112;
  int D.37113;
  const unsigned char * D.37114;
  unsigned char D.37115;
  int D.37116;
  const unsigned char * D.37121;
  unsigned char D.37122;
  int D.37123;
  const unsigned char * D.37124;
  unsigned char D.37125;
  int D.37126;
  struct MonoClass * D.37130;
  int D.22736;
  int iftmp.722;
  int D.22735;
  const char[10] * D.37138;
  unsigned char D.37139;
  int D.37140;
  unsigned char D.37141;
  int D.37142;
  const unsigned char * D.37147;
  unsigned char D.37148;
  int D.37149;
  const unsigned char * D.37150;
  unsigned char D.37151;
  int D.37152;
  const unsigned char * D.37157;
  unsigned char D.37158;
  int D.37159;
  const unsigned char * D.37160;
  unsigned char D.37161;
  int D.37162;
  const unsigned char * D.37167;
  unsigned char D.37168;
  int D.37169;
  const unsigned char * D.37170;
  unsigned char D.37171;
  int D.37172;
  int D.22745;
  int iftmp.723;
  int D.22744;
  unsigned char D.37178;
  int D.37179;
  const unsigned char * D.37184;
  unsigned char D.37185;
  int D.37186;
  const unsigned char * D.37191;
  unsigned char D.37192;
  int D.37193;
  const unsigned char * D.37198;
  unsigned char D.37199;
  int D.37200;
  int D.22754;
  int iftmp.724;
  int D.22753;
  unsigned char D.37205;
  int D.37206;
  const unsigned char * D.37211;
  unsigned char D.37212;
  int D.37213;
  const unsigned char * D.37218;
  unsigned char D.37219;
  int D.37220;
  const unsigned char * D.37225;
  unsigned char D.37226;
  int D.37227;
  int D.22763;
  int iftmp.725;
  int D.22762;
  unsigned char D.37233;
  int D.37234;
  const unsigned char * D.37239;
  unsigned char D.37240;
  int D.37241;
  const unsigned char * D.37246;
  unsigned char D.37247;
  int D.37248;
  const unsigned char * D.37253;
  unsigned char D.37254;
  int D.37255;
  int D.22772;
  int iftmp.726;
  int D.22771;
  const char[5] * D.37260;
  unsigned char D.37261;
  int D.37262;
  unsigned char D.37263;
  int D.37264;
  const unsigned char * D.37269;
  unsigned char D.37270;
  int D.37271;
  const unsigned char * D.37272;
  unsigned char D.37273;
  int D.37274;
  const unsigned char * D.37279;
  unsigned char D.37280;
  int D.37281;
  const unsigned char * D.37282;
  unsigned char D.37283;
  int D.37284;
  const unsigned char * D.37289;
  unsigned char D.37290;
  int D.37291;
  const unsigned char * D.37292;
  unsigned char D.37293;
  int D.37294;
  int D.22781;
  int iftmp.727;
  int D.22780;
  unsigned char D.37300;
  int D.37301;
  const unsigned char * D.37306;
  unsigned char D.37307;
  int D.37308;
  const unsigned char * D.37313;
  unsigned char D.37314;
  int D.37315;
  const unsigned char * D.37320;
  unsigned char D.37321;
  int D.37322;
  struct MonoType * D.37324;
  struct MonoType * D.37327;
  _Bool D.37328;
  long int D.37329;
  long int D.37330;
  struct MonoType * D.37333;
  struct MonoClass * D.37334;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoClass * parent;
  void failure = <<< error >>>;

  try
    {
      D.36958 = tb->parent;
      D.36959 = mono_reflection_type_resolve_user_types (D.36958);
      tb->parent = D.36959;
      mono_loader_lock ();
      D.36958 = tb->parent;
      if (D.36958 != 0B) goto <D.36960>; else goto <D.36961>;
      <D.36960>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.36958 = tb->parent;
          D.36965 = D.36958->vtable;
          D.36966 = D.36965->klass;
          __s2 = D.36966->name;
          D.36967 = "TypeBuilder";
          D.36968 = MEM[(const unsigned char *)D.36967];
          D.36969 = (int) D.36968;
          D.36970 = *__s2;
          D.36971 = (int) D.36970;
          __result = D.36969 - D.36971;
          {
            if (__s2_len != 0) goto <D.36972>; else goto <D.36973>;
            <D.36972>:
            if (__result == 0) goto <D.36974>; else goto <D.36975>;
            <D.36974>:
            D.36976 = &MEM[(void *)"TypeBuilder" + 1B];
            D.36977 = *D.36976;
            D.36978 = (int) D.36977;
            D.36979 = __s2 + 1;
            D.36980 = *D.36979;
            D.36981 = (int) D.36980;
            __result = D.36978 - D.36981;
            if (__s2_len > 1) goto <D.36982>; else goto <D.36983>;
            <D.36982>:
            if (__result == 0) goto <D.36984>; else goto <D.36985>;
            <D.36984>:
            D.36986 = &MEM[(void *)"TypeBuilder" + 2B];
            D.36987 = *D.36986;
            D.36988 = (int) D.36987;
            D.36989 = __s2 + 2;
            D.36990 = *D.36989;
            D.36991 = (int) D.36990;
            __result = D.36988 - D.36991;
            if (__s2_len > 2) goto <D.36992>; else goto <D.36993>;
            <D.36992>:
            if (__result == 0) goto <D.36994>; else goto <D.36995>;
            <D.36994>:
            D.36996 = &MEM[(void *)"TypeBuilder" + 3B];
            D.36997 = *D.36996;
            D.36998 = (int) D.36997;
            D.36999 = __s2 + 3;
            D.37000 = *D.36999;
            D.37001 = (int) D.37000;
            __result = D.36998 - D.37001;
            <D.36995>:
            <D.36993>:
            <D.36985>:
            <D.36983>:
            <D.36975>:
            <D.36973>:
          }
          D.22706 = __result;
        }
        iftmp.719 = -D.22706;
        goto <D.37002>;
        <D.36964>:
        D.36958 = tb->parent;
        D.36965 = D.36958->vtable;
        D.36966 = D.36965->klass;
        D.37003 = D.36966->name;
        iftmp.719 = __builtin_strcmp (D.37003, "TypeBuilder");
        <D.37002>:
        D.22707 = iftmp.719;
      }
      if (D.22707 == 0) goto <D.37004>; else goto <D.37005>;
      <D.37004>:
      D.36958 = tb->parent;
      D.37006 = mono_reflection_type_get_handle (D.36958);
      parent = D.37006->data.klass;
      goto <D.37007>;
      <D.37005>:
      D.36958 = tb->parent;
      D.37008 = mono_reflection_type_get_handle (D.36958);
      parent = mono_class_from_mono_type (D.37008);
      <D.37007>:
      goto <D.37009>;
      <D.36961>:
      parent = 0B;
      <D.37009>:
      D.37010 = tb->type.type;
      if (D.37010 != 0B) goto <D.37011>; else goto <D.37012>;
      <D.37011>:
      D.37010 = tb->type.type;
      klass = mono_class_from_mono_type (D.37010);
      klass->parent = 0B;
      klass->supertypes = 0B;
      mono_class_setup_parent (klass, parent);
      mono_class_setup_mono_type (klass);
      mono_loader_unlock ();
      return;
      <D.37012>:
      D.37013 = tb->module;
      D.37014 = D.37013->dynamic_image;
      D.37015 = &D.37014->image;
      klass = mono_image_alloc0 (D.37015, 164);
      D.37013 = tb->module;
      D.37014 = D.37013->dynamic_image;
      D.37015 = &D.37014->image;
      klass->image = D.37015;
      klass->inited = 1;
      D.37016 = klass->image;
      D.37017 = tb->name;
      D.37018 = mono_string_to_utf8_image (D.37016, D.37017, &error);
      klass->name = D.37018;
      D.37019 = mono_error_ok (&error);
      if (D.37019 == 0) goto failure; else goto <D.37020>;
      <D.37020>:
      D.37016 = klass->image;
      D.37021 = tb->nspace;
      D.37022 = mono_string_to_utf8_image (D.37016, D.37021, &error);
      klass->name_space = D.37022;
      D.37023 = mono_error_ok (&error);
      if (D.37023 == 0) goto failure; else goto <D.37024>;
      <D.37024>:
      D.37025 = tb->table_idx;
      D.37026 = D.37025 | 33554432;
      klass->type_token = D.37026;
      D.37027 = tb->attrs;
      klass->flags = D.37027;
      mono_profiler_class_event (klass, 0);
      klass->element_class = klass;
      D.37028 = mono_class_get_ref_info (klass);
      if (D.37028 == 0B) goto <D.37029>; else goto <D.37030>;
      <D.37029>:
      mono_class_set_ref_info (klass, tb);
      D.37031 = tb->nesting_type;
      if (D.37031 == 0B) goto <D.37032>; else goto <D.37033>;
      <D.37032>:
      D.37016 = klass->image;
      D.37034 = klass->name_space;
      D.37035 = klass->name;
      D.37025 = tb->table_idx;
      mono_image_add_to_name_cache (D.37016, D.37034, D.37035, D.37025);
      <D.37033>:
      mono_image_append_class_to_reflection_info_set (klass);
      goto <D.37036>;
      <D.37030>:
      D.37037 = mono_class_get_ref_info (klass);
      D.37038 = D.37037 != tb;
      D.37039 = (long int) D.37038;
      D.37040 = __builtin_expect (D.37039, 0);
      if (D.37040 != 0) goto <D.37041>; else goto <D.37042>;
      <D.37041>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9854, "mono_class_get_ref_info (klass) == tb");
      <D.37042>:
      <D.37036>:
      D.37013 = tb->module;
      D.37014 = D.37013->dynamic_image;
      D.37043 = D.37014->tokens;
      D.37025 = tb->table_idx;
      D.37026 = D.37025 | 33554432;
      D.37044 = (void *) D.37026;
      mono_g_hash_table_insert (D.37043, D.37044, tb);
      if (parent != 0B) goto <D.37045>; else goto <D.37046>;
      <D.37045>:
      mono_class_setup_parent (klass, parent);
      goto <D.37047>;
      <D.37046>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37051 = "Object";
          D.37052 = MEM[(const unsigned char *)D.37051];
          D.37053 = (int) D.37052;
          D.37054 = *__s2;
          D.37055 = (int) D.37054;
          __result = D.37053 - D.37055;
          {
            if (__s2_len != 0) goto <D.37056>; else goto <D.37057>;
            <D.37056>:
            if (__result == 0) goto <D.37058>; else goto <D.37059>;
            <D.37058>:
            D.37060 = &MEM[(void *)"Object" + 1B];
            D.37061 = *D.37060;
            D.37062 = (int) D.37061;
            D.37063 = __s2 + 1;
            D.37064 = *D.37063;
            D.37065 = (int) D.37064;
            __result = D.37062 - D.37065;
            if (__s2_len > 1) goto <D.37066>; else goto <D.37067>;
            <D.37066>:
            if (__result == 0) goto <D.37068>; else goto <D.37069>;
            <D.37068>:
            D.37070 = &MEM[(void *)"Object" + 2B];
            D.37071 = *D.37070;
            D.37072 = (int) D.37071;
            D.37073 = __s2 + 2;
            D.37074 = *D.37073;
            D.37075 = (int) D.37074;
            __result = D.37072 - D.37075;
            if (__s2_len > 2) goto <D.37076>; else goto <D.37077>;
            <D.37076>:
            if (__result == 0) goto <D.37078>; else goto <D.37079>;
            <D.37078>:
            D.37080 = &MEM[(void *)"Object" + 3B];
            D.37081 = *D.37080;
            D.37082 = (int) D.37081;
            D.37083 = __s2 + 3;
            D.37084 = *D.37083;
            D.37085 = (int) D.37084;
            __result = D.37082 - D.37085;
            <D.37079>:
            <D.37077>:
            <D.37069>:
            <D.37067>:
            <D.37059>:
            <D.37057>:
          }
          D.22716 = __result;
        }
        iftmp.720 = -D.22716;
        goto <D.37086>;
        <D.37050>:
        D.37035 = klass->name;
        iftmp.720 = __builtin_strcmp (D.37035, "Object");
        <D.37086>:
        D.22717 = iftmp.720;
      }
      if (D.22717 == 0) goto <D.37087>; else goto <D.37088>;
      <D.37087>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37092 = "System";
          D.37093 = MEM[(const unsigned char *)D.37092];
          D.37094 = (int) D.37093;
          D.37095 = *__s2;
          D.37096 = (int) D.37095;
          __result = D.37094 - D.37096;
          {
            if (__s2_len != 0) goto <D.37097>; else goto <D.37098>;
            <D.37097>:
            if (__result == 0) goto <D.37099>; else goto <D.37100>;
            <D.37099>:
            D.37101 = &MEM[(void *)"System" + 1B];
            D.37102 = *D.37101;
            D.37103 = (int) D.37102;
            D.37104 = __s2 + 1;
            D.37105 = *D.37104;
            D.37106 = (int) D.37105;
            __result = D.37103 - D.37106;
            if (__s2_len > 1) goto <D.37107>; else goto <D.37108>;
            <D.37107>:
            if (__result == 0) goto <D.37109>; else goto <D.37110>;
            <D.37109>:
            D.37111 = &MEM[(void *)"System" + 2B];
            D.37112 = *D.37111;
            D.37113 = (int) D.37112;
            D.37114 = __s2 + 2;
            D.37115 = *D.37114;
            D.37116 = (int) D.37115;
            __result = D.37113 - D.37116;
            if (__s2_len > 2) goto <D.37117>; else goto <D.37118>;
            <D.37117>:
            if (__result == 0) goto <D.37119>; else goto <D.37120>;
            <D.37119>:
            D.37121 = &MEM[(void *)"System" + 3B];
            D.37122 = *D.37121;
            D.37123 = (int) D.37122;
            D.37124 = __s2 + 3;
            D.37125 = *D.37124;
            D.37126 = (int) D.37125;
            __result = D.37123 - D.37126;
            <D.37120>:
            <D.37118>:
            <D.37110>:
            <D.37108>:
            <D.37100>:
            <D.37098>:
          }
          D.22725 = __result;
        }
        iftmp.721 = -D.22725;
        goto <D.37127>;
        <D.37091>:
        D.37034 = klass->name_space;
        iftmp.721 = __builtin_strcmp (D.37034, "System");
        <D.37127>:
        D.22726 = iftmp.721;
      }
      if (D.22726 == 0) goto <D.37128>; else goto <D.37129>;
      <D.37128>:
      {
        const char * old_n;

        old_n = klass->name;
        klass->name = "BuildingObject";
        D.37130 = mono_defaults.object_class;
        mono_class_setup_parent (klass, D.37130);
        klass->name = old_n;
      }
      <D.37129>:
      <D.37088>:
      <D.37047>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37138 = "ValueType";
          D.37139 = MEM[(const unsigned char *)D.37138];
          D.37140 = (int) D.37139;
          D.37141 = *__s2;
          D.37142 = (int) D.37141;
          __result = D.37140 - D.37142;
          {
            if (__s2_len != 0) goto <D.37143>; else goto <D.37144>;
            <D.37143>:
            if (__result == 0) goto <D.37145>; else goto <D.37146>;
            <D.37145>:
            D.37147 = &MEM[(void *)"ValueType" + 1B];
            D.37148 = *D.37147;
            D.37149 = (int) D.37148;
            D.37150 = __s2 + 1;
            D.37151 = *D.37150;
            D.37152 = (int) D.37151;
            __result = D.37149 - D.37152;
            if (__s2_len > 1) goto <D.37153>; else goto <D.37154>;
            <D.37153>:
            if (__result == 0) goto <D.37155>; else goto <D.37156>;
            <D.37155>:
            D.37157 = &MEM[(void *)"ValueType" + 2B];
            D.37158 = *D.37157;
            D.37159 = (int) D.37158;
            D.37160 = __s2 + 2;
            D.37161 = *D.37160;
            D.37162 = (int) D.37161;
            __result = D.37159 - D.37162;
            if (__s2_len > 2) goto <D.37163>; else goto <D.37164>;
            <D.37163>:
            if (__result == 0) goto <D.37165>; else goto <D.37166>;
            <D.37165>:
            D.37167 = &MEM[(void *)"ValueType" + 3B];
            D.37168 = *D.37167;
            D.37169 = (int) D.37168;
            D.37170 = __s2 + 3;
            D.37171 = *D.37170;
            D.37172 = (int) D.37171;
            __result = D.37169 - D.37172;
            <D.37166>:
            <D.37164>:
            <D.37156>:
            <D.37154>:
            <D.37146>:
            <D.37144>:
          }
          D.22735 = __result;
        }
        iftmp.722 = -D.22735;
        goto <D.37173>;
        <D.37137>:
        D.37035 = klass->name;
        iftmp.722 = __builtin_strcmp (D.37035, "ValueType");
        <D.37173>:
        D.22736 = iftmp.722;
      }
      if (D.22736 == 0) goto <D.37174>; else goto <D.37131>;
      <D.37174>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37092 = "System";
          D.37093 = MEM[(const unsigned char *)D.37092];
          D.37094 = (int) D.37093;
          D.37178 = *__s2;
          D.37179 = (int) D.37178;
          __result = D.37094 - D.37179;
          {
            if (__s2_len != 0) goto <D.37180>; else goto <D.37181>;
            <D.37180>:
            if (__result == 0) goto <D.37182>; else goto <D.37183>;
            <D.37182>:
            D.37101 = &MEM[(void *)"System" + 1B];
            D.37102 = *D.37101;
            D.37103 = (int) D.37102;
            D.37184 = __s2 + 1;
            D.37185 = *D.37184;
            D.37186 = (int) D.37185;
            __result = D.37103 - D.37186;
            if (__s2_len > 1) goto <D.37187>; else goto <D.37188>;
            <D.37187>:
            if (__result == 0) goto <D.37189>; else goto <D.37190>;
            <D.37189>:
            D.37111 = &MEM[(void *)"System" + 2B];
            D.37112 = *D.37111;
            D.37113 = (int) D.37112;
            D.37191 = __s2 + 2;
            D.37192 = *D.37191;
            D.37193 = (int) D.37192;
            __result = D.37113 - D.37193;
            if (__s2_len > 2) goto <D.37194>; else goto <D.37195>;
            <D.37194>:
            if (__result == 0) goto <D.37196>; else goto <D.37197>;
            <D.37196>:
            D.37121 = &MEM[(void *)"System" + 3B];
            D.37122 = *D.37121;
            D.37123 = (int) D.37122;
            D.37198 = __s2 + 3;
            D.37199 = *D.37198;
            D.37200 = (int) D.37199;
            __result = D.37123 - D.37200;
            <D.37197>:
            <D.37195>:
            <D.37190>:
            <D.37188>:
            <D.37183>:
            <D.37181>:
          }
          D.22744 = __result;
        }
        iftmp.723 = -D.22744;
        goto <D.37201>;
        <D.37177>:
        D.37034 = klass->name_space;
        iftmp.723 = __builtin_strcmp (D.37034, "System");
        <D.37201>:
        D.22745 = iftmp.723;
      }
      if (D.22745 == 0) goto <D.37132>; else goto <D.37131>;
      <D.37131>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37051 = "Object";
          D.37052 = MEM[(const unsigned char *)D.37051];
          D.37053 = (int) D.37052;
          D.37205 = *__s2;
          D.37206 = (int) D.37205;
          __result = D.37053 - D.37206;
          {
            if (__s2_len != 0) goto <D.37207>; else goto <D.37208>;
            <D.37207>:
            if (__result == 0) goto <D.37209>; else goto <D.37210>;
            <D.37209>:
            D.37060 = &MEM[(void *)"Object" + 1B];
            D.37061 = *D.37060;
            D.37062 = (int) D.37061;
            D.37211 = __s2 + 1;
            D.37212 = *D.37211;
            D.37213 = (int) D.37212;
            __result = D.37062 - D.37213;
            if (__s2_len > 1) goto <D.37214>; else goto <D.37215>;
            <D.37214>:
            if (__result == 0) goto <D.37216>; else goto <D.37217>;
            <D.37216>:
            D.37070 = &MEM[(void *)"Object" + 2B];
            D.37071 = *D.37070;
            D.37072 = (int) D.37071;
            D.37218 = __s2 + 2;
            D.37219 = *D.37218;
            D.37220 = (int) D.37219;
            __result = D.37072 - D.37220;
            if (__s2_len > 2) goto <D.37221>; else goto <D.37222>;
            <D.37221>:
            if (__result == 0) goto <D.37223>; else goto <D.37224>;
            <D.37223>:
            D.37080 = &MEM[(void *)"Object" + 3B];
            D.37081 = *D.37080;
            D.37082 = (int) D.37081;
            D.37225 = __s2 + 3;
            D.37226 = *D.37225;
            D.37227 = (int) D.37226;
            __result = D.37082 - D.37227;
            <D.37224>:
            <D.37222>:
            <D.37217>:
            <D.37215>:
            <D.37210>:
            <D.37208>:
          }
          D.22753 = __result;
        }
        iftmp.724 = -D.22753;
        goto <D.37228>;
        <D.37204>:
        D.37035 = klass->name;
        iftmp.724 = __builtin_strcmp (D.37035, "Object");
        <D.37228>:
        D.22754 = iftmp.724;
      }
      if (D.22754 == 0) goto <D.37229>; else goto <D.37133>;
      <D.37229>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37092 = "System";
          D.37093 = MEM[(const unsigned char *)D.37092];
          D.37094 = (int) D.37093;
          D.37233 = *__s2;
          D.37234 = (int) D.37233;
          __result = D.37094 - D.37234;
          {
            if (__s2_len != 0) goto <D.37235>; else goto <D.37236>;
            <D.37235>:
            if (__result == 0) goto <D.37237>; else goto <D.37238>;
            <D.37237>:
            D.37101 = &MEM[(void *)"System" + 1B];
            D.37102 = *D.37101;
            D.37103 = (int) D.37102;
            D.37239 = __s2 + 1;
            D.37240 = *D.37239;
            D.37241 = (int) D.37240;
            __result = D.37103 - D.37241;
            if (__s2_len > 1) goto <D.37242>; else goto <D.37243>;
            <D.37242>:
            if (__result == 0) goto <D.37244>; else goto <D.37245>;
            <D.37244>:
            D.37111 = &MEM[(void *)"System" + 2B];
            D.37112 = *D.37111;
            D.37113 = (int) D.37112;
            D.37246 = __s2 + 2;
            D.37247 = *D.37246;
            D.37248 = (int) D.37247;
            __result = D.37113 - D.37248;
            if (__s2_len > 2) goto <D.37249>; else goto <D.37250>;
            <D.37249>:
            if (__result == 0) goto <D.37251>; else goto <D.37252>;
            <D.37251>:
            D.37121 = &MEM[(void *)"System" + 3B];
            D.37122 = *D.37121;
            D.37123 = (int) D.37122;
            D.37253 = __s2 + 3;
            D.37254 = *D.37253;
            D.37255 = (int) D.37254;
            __result = D.37123 - D.37255;
            <D.37252>:
            <D.37250>:
            <D.37245>:
            <D.37243>:
            <D.37238>:
            <D.37236>:
          }
          D.22762 = __result;
        }
        iftmp.725 = -D.22762;
        goto <D.37256>;
        <D.37232>:
        D.37034 = klass->name_space;
        iftmp.725 = __builtin_strcmp (D.37034, "System");
        <D.37256>:
        D.22763 = iftmp.725;
      }
      if (D.22763 == 0) goto <D.37132>; else goto <D.37133>;
      <D.37133>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37260 = "Enum";
          D.37261 = MEM[(const unsigned char *)D.37260];
          D.37262 = (int) D.37261;
          D.37263 = *__s2;
          D.37264 = (int) D.37263;
          __result = D.37262 - D.37264;
          {
            if (__s2_len != 0) goto <D.37265>; else goto <D.37266>;
            <D.37265>:
            if (__result == 0) goto <D.37267>; else goto <D.37268>;
            <D.37267>:
            D.37269 = &MEM[(void *)"Enum" + 1B];
            D.37270 = *D.37269;
            D.37271 = (int) D.37270;
            D.37272 = __s2 + 1;
            D.37273 = *D.37272;
            D.37274 = (int) D.37273;
            __result = D.37271 - D.37274;
            if (__s2_len > 1) goto <D.37275>; else goto <D.37276>;
            <D.37275>:
            if (__result == 0) goto <D.37277>; else goto <D.37278>;
            <D.37277>:
            D.37279 = &MEM[(void *)"Enum" + 2B];
            D.37280 = *D.37279;
            D.37281 = (int) D.37280;
            D.37282 = __s2 + 2;
            D.37283 = *D.37282;
            D.37284 = (int) D.37283;
            __result = D.37281 - D.37284;
            if (__s2_len > 2) goto <D.37285>; else goto <D.37286>;
            <D.37285>:
            if (__result == 0) goto <D.37287>; else goto <D.37288>;
            <D.37287>:
            D.37289 = &MEM[(void *)"Enum" + 3B];
            D.37290 = *D.37289;
            D.37291 = (int) D.37290;
            D.37292 = __s2 + 3;
            D.37293 = *D.37292;
            D.37294 = (int) D.37293;
            __result = D.37291 - D.37294;
            <D.37288>:
            <D.37286>:
            <D.37278>:
            <D.37276>:
            <D.37268>:
            <D.37266>:
          }
          D.22771 = __result;
        }
        iftmp.726 = -D.22771;
        goto <D.37295>;
        <D.37259>:
        D.37035 = klass->name;
        iftmp.726 = __builtin_strcmp (D.37035, "Enum");
        <D.37295>:
        D.22772 = iftmp.726;
      }
      if (D.22772 == 0) goto <D.37296>; else goto <D.37134>;
      <D.37296>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37092 = "System";
          D.37093 = MEM[(const unsigned char *)D.37092];
          D.37094 = (int) D.37093;
          D.37300 = *__s2;
          D.37301 = (int) D.37300;
          __result = D.37094 - D.37301;
          {
            if (__s2_len != 0) goto <D.37302>; else goto <D.37303>;
            <D.37302>:
            if (__result == 0) goto <D.37304>; else goto <D.37305>;
            <D.37304>:
            D.37101 = &MEM[(void *)"System" + 1B];
            D.37102 = *D.37101;
            D.37103 = (int) D.37102;
            D.37306 = __s2 + 1;
            D.37307 = *D.37306;
            D.37308 = (int) D.37307;
            __result = D.37103 - D.37308;
            if (__s2_len > 1) goto <D.37309>; else goto <D.37310>;
            <D.37309>:
            if (__result == 0) goto <D.37311>; else goto <D.37312>;
            <D.37311>:
            D.37111 = &MEM[(void *)"System" + 2B];
            D.37112 = *D.37111;
            D.37113 = (int) D.37112;
            D.37313 = __s2 + 2;
            D.37314 = *D.37313;
            D.37315 = (int) D.37314;
            __result = D.37113 - D.37315;
            if (__s2_len > 2) goto <D.37316>; else goto <D.37317>;
            <D.37316>:
            if (__result == 0) goto <D.37318>; else goto <D.37319>;
            <D.37318>:
            D.37121 = &MEM[(void *)"System" + 3B];
            D.37122 = *D.37121;
            D.37123 = (int) D.37122;
            D.37320 = __s2 + 3;
            D.37321 = *D.37320;
            D.37322 = (int) D.37321;
            __result = D.37123 - D.37322;
            <D.37319>:
            <D.37317>:
            <D.37312>:
            <D.37310>:
            <D.37305>:
            <D.37303>:
          }
          D.22780 = __result;
        }
        iftmp.727 = -D.22780;
        goto <D.37323>;
        <D.37299>:
        D.37034 = klass->name_space;
        iftmp.727 = __builtin_strcmp (D.37034, "System");
        <D.37323>:
        D.22781 = iftmp.727;
      }
      if (D.22781 == 0) goto <D.37132>; else goto <D.37134>;
      <D.37132>:
      klass->instance_size = 8;
      klass->size_inited = 1;
      mono_class_setup_vtable_general (klass, 0B, 0, 0B);
      <D.37134>:
      mono_class_setup_mono_type (klass);
      mono_class_setup_supertypes (klass);
      D.37324 = &klass->byval_arg;
      tb->type.type = D.37324;
      D.37031 = tb->nesting_type;
      if (D.37031 != 0B) goto <D.37325>; else goto <D.37326>;
      <D.37325>:
      D.37031 = tb->nesting_type;
      D.37327 = D.37031->type;
      D.37328 = D.37327 == 0B;
      D.37329 = (long int) D.37328;
      D.37330 = __builtin_expect (D.37329, 0);
      if (D.37330 != 0) goto <D.37331>; else goto <D.37332>;
      <D.37331>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9889, "tb->nesting_type->type");
      <D.37332>:
      D.37031 = tb->nesting_type;
      D.37333 = mono_reflection_type_get_handle (D.37031);
      D.37334 = mono_class_from_mono_type (D.37333);
      klass->nested_in = D.37334;
      <D.37326>:
      mono_profiler_class_loaded (klass, 0);
      mono_loader_unlock ();
      return;
      failure:
      mono_loader_unlock ();
      mono_error_raise_exception (&error);
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_setup_generic_class (struct MonoReflectionTypeBuilder * tb)
{

}


mono_reflection_create_generic_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoType * D.37338;
  int iftmp.728;
  struct MonoArray * D.37340;
  unsigned int D.37343;
  struct MonoGenericContainer * D.37347;
  int iftmp.729;
  struct MonoGenericContainer * D.37353;
  struct MonoClass * D.37355;
  _Bool D.37356;
  long int D.37357;
  long int D.37358;
  struct MonoImage * D.37361;
  void * D.37362;
  <unnamed-signed:31> D.37363;
  unsigned int count.730;
  unsigned int D.37365;
  void * D.37366;
  unsigned int i.731;
  char * D.37368;
  struct MonoType * D.37369;
  struct MonoGenericParamFull * D.37370;
  unsigned int i.732;
  unsigned int D.37372;
  struct MonoGenericParamFull * D.37373;
  unsigned int D.37374;
  short unsigned int D.37375;
  struct MonoGenericContainer * D.37376;
  _Bool D.37377;
  long int D.37378;
  long int D.37379;
  struct MonoGenericInst * D.37382;
  struct MonoClass * klass;
  int count;
  int i;

  D.37338 = tb->type.type;
  klass = mono_class_from_mono_type (D.37338);
  D.37340 = tb->generic_params;
  if (D.37340 != 0B) goto <D.37341>; else goto <D.37342>;
  <D.37341>:
  D.37340 = tb->generic_params;
  D.37343 = mono_array_length (D.37340);
  iftmp.728 = (int) D.37343;
  goto <D.37344>;
  <D.37342>:
  iftmp.728 = 0;
  <D.37344>:
  count = iftmp.728;
  D.37347 = klass->generic_container;
  if (D.37347 != 0B) goto <D.37345>; else goto <D.37348>;
  <D.37348>:
  if (count == 0) goto <D.37345>; else goto <D.37346>;
  <D.37345>:
  return;
  <D.37346>:
  D.37353 = tb->generic_container;
  if (D.37353 == 0B) goto <D.37350>; else goto <D.37354>;
  <D.37354>:
  D.37353 = tb->generic_container;
  D.37355 = D.37353->owner.klass;
  if (D.37355 != klass) goto <D.37350>; else goto <D.37351>;
  <D.37350>:
  iftmp.729 = 1;
  goto <D.37352>;
  <D.37351>:
  iftmp.729 = 0;
  <D.37352>:
  D.37356 = iftmp.729 != 0;
  D.37357 = (long int) D.37356;
  D.37358 = __builtin_expect (D.37357, 0);
  if (D.37358 != 0) goto <D.37359>; else goto <D.37360>;
  <D.37359>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9937, "tb->generic_container && (tb->generic_container->owner.klass == klass)");
  <D.37360>:
  D.37361 = klass->image;
  D.37362 = mono_image_alloc0 (D.37361, 28);
  klass->generic_container = D.37362;
  D.37347 = klass->generic_container;
  D.37347->owner.klass = klass;
  D.37347 = klass->generic_container;
  D.37363 = (<unnamed-signed:31>) count;
  D.37347->type_argc = D.37363;
  D.37347 = klass->generic_container;
  D.37361 = klass->image;
  count.730 = (unsigned int) count;
  D.37365 = count.730 * 32;
  D.37366 = mono_image_alloc0 (D.37361, D.37365);
  D.37347->type_params = D.37366;
  klass->is_generic = 1;
  i = 0;
  goto <D.22794>;
  <D.22793>:
  {
    struct MonoReflectionGenericParam * gparam;
    struct MonoGenericParamFull * param;

    D.37340 = tb->generic_params;
    i.731 = (unsigned int) i;
    D.37368 = mono_array_addr_with_size (D.37340, 4, i.731);
    gparam = MEM[(void * *)D.37368];
    D.37369 = mono_reflection_type_get_handle (gparam);
    param = D.37369->data.generic_param;
    D.37347 = klass->generic_container;
    D.37370 = D.37347->type_params;
    i.732 = (unsigned int) i;
    D.37372 = i.732 * 32;
    D.37373 = D.37370 + D.37372;
    *D.37373 = *param;
    D.37347 = klass->generic_container;
    D.37370 = D.37347->type_params;
    i.732 = (unsigned int) i;
    D.37372 = i.732 * 32;
    D.37373 = D.37370 + D.37372;
    D.37347 = klass->generic_container;
    D.37373->param.owner = D.37347;
    D.37347 = klass->generic_container;
    D.37370 = D.37347->type_params;
    i.732 = (unsigned int) i;
    D.37372 = i.732 * 32;
    D.37373 = D.37370 + D.37372;
    D.37373->info.pklass = 0B;
    D.37347 = klass->generic_container;
    D.37370 = D.37347->type_params;
    i.732 = (unsigned int) i;
    D.37372 = i.732 * 32;
    D.37373 = D.37370 + D.37372;
    D.37374 = gparam->attrs;
    D.37375 = (short unsigned int) D.37374;
    D.37373->info.flags = D.37375;
    D.37347 = klass->generic_container;
    D.37370 = D.37347->type_params;
    i.732 = (unsigned int) i;
    D.37372 = i.732 * 32;
    D.37373 = D.37370 + D.37372;
    D.37376 = D.37373->param.owner;
    D.37377 = D.37376 == 0B;
    D.37378 = (long int) D.37377;
    D.37379 = __builtin_expect (D.37378, 0);
    if (D.37379 != 0) goto <D.37380>; else goto <D.37381>;
    <D.37380>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9956, "klass->generic_container->type_params [i].param.owner");
    <D.37381>:
  }
  i = i + 1;
  <D.22794>:
  if (i < count) goto <D.22793>; else goto <D.22795>;
  <D.22795>:
  D.37347 = klass->generic_container;
  D.37347 = klass->generic_container;
  D.37382 = mono_get_shared_generic_inst (D.37347);
  D.37347->context.class_inst = D.37382;
}


mono_reflection_create_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoType * D.37384;
  unsigned int D.37385;
  unsigned int D.37386;
  struct MonoType * D.37389;
  struct MonoArray * D.37392;
  _Bool D.37393;
  long int D.37394;
  long int D.37395;
  unsigned int D.37398;
  _Bool D.37399;
  long int D.37400;
  long int D.37401;
  char * D.37404;
  struct MonoObject * D.37405;
  struct MonoType * D.37406;
  int D.37407;
  struct MonoClass * D.37410;
  struct MonoClass * D.37411;
  struct MonoClass * D.37414;
  int D.37415;
  struct MonoClass * klass;

  D.37384 = tb->type.type;
  klass = mono_class_from_mono_type (D.37384);
  mono_loader_lock ();
  D.37385 = BIT_FIELD_REF <*klass, 32, 160>;
  D.37386 = D.37385 & 16;
  if (D.37386 != 0) goto <D.37387>; else goto <D.37388>;
  <D.37387>:
  D.37389 = mono_class_enum_basetype (klass);
  if (D.37389 == 0B) goto <D.37390>; else goto <D.37391>;
  <D.37390>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoClass * ec;
    struct MonoType * enum_basetype;

    D.37392 = tb->fields;
    D.37393 = D.37392 == 0B;
    D.37394 = (long int) D.37393;
    D.37395 = __builtin_expect (D.37394, 0);
    if (D.37395 != 0) goto <D.37396>; else goto <D.37397>;
    <D.37396>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9983, "tb->fields != NULL");
    <D.37397>:
    D.37392 = tb->fields;
    D.37398 = mono_array_length (D.37392);
    D.37399 = D.37398 == 0;
    D.37400 = (long int) D.37399;
    D.37401 = __builtin_expect (D.37400, 0);
    if (D.37401 != 0) goto <D.37402>; else goto <D.37403>;
    <D.37402>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9984, "mono_array_length (tb->fields) >= 1");
    <D.37403>:
    D.37392 = tb->fields;
    D.37404 = mono_array_addr_with_size (D.37392, 4, 0);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.37404];
    D.37405 = fb->type;
    D.37406 = mono_reflection_type_get_handle (D.37405);
    D.37407 = mono_type_is_valid_enum_basetype (D.37406);
    if (D.37407 == 0) goto <D.37408>; else goto <D.37409>;
    <D.37408>:
    mono_loader_unlock ();
    return;
    <D.37409>:
    D.37405 = fb->type;
    enum_basetype = mono_reflection_type_get_handle (D.37405);
    D.37410 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.37410;
    D.37411 = klass->element_class;
    if (D.37411 == 0B) goto <D.37412>; else goto <D.37413>;
    <D.37412>:
    D.37414 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.37414;
    <D.37413>:
    ec = default_class_from_mono_type (enum_basetype);
    D.37415 = ec->instance_size;
    klass->instance_size = D.37415;
    klass->size_inited = 1;
    mono_class_setup_vtable_general (klass, 0B, 0, 0B);
  }
  <D.37391>:
  <D.37388>:
  mono_loader_unlock ();
}


default_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.37417;
  int D.37418;
  struct MonoClass * D.37419;

  D.37417 = type->type;
  D.37418 = (int) D.37417;
  switch (D.37418) <default: <D.18421>, case 1: <D.18405>, case 2: <D.18406>, case 3: <D.18407>, case 4: <D.18408>, case 5: <D.18409>, case 6: <D.18410>, case 7: <D.18411>, case 8: <D.18412>, case 9: <D.18413>, case 10: <D.18416>, case 11: <D.18417>, case 12: <D.18418>, case 13: <D.18419>, case 14: <D.18420>, case 24: <D.18414>, case 25: <D.18415>, case 28: <D.18404>>
  <D.18404>:
  D.37419 = mono_defaults.object_class;
  return D.37419;
  <D.18405>:
  D.37419 = mono_defaults.void_class;
  return D.37419;
  <D.18406>:
  D.37419 = mono_defaults.boolean_class;
  return D.37419;
  <D.18407>:
  D.37419 = mono_defaults.char_class;
  return D.37419;
  <D.18408>:
  D.37419 = mono_defaults.sbyte_class;
  return D.37419;
  <D.18409>:
  D.37419 = mono_defaults.byte_class;
  return D.37419;
  <D.18410>:
  D.37419 = mono_defaults.int16_class;
  return D.37419;
  <D.18411>:
  D.37419 = mono_defaults.uint16_class;
  return D.37419;
  <D.18412>:
  D.37419 = mono_defaults.int32_class;
  return D.37419;
  <D.18413>:
  D.37419 = mono_defaults.uint32_class;
  return D.37419;
  <D.18414>:
  D.37419 = mono_defaults.int_class;
  return D.37419;
  <D.18415>:
  D.37419 = mono_defaults.uint_class;
  return D.37419;
  <D.18416>:
  D.37419 = mono_defaults.int64_class;
  return D.37419;
  <D.18417>:
  D.37419 = mono_defaults.uint64_class;
  return D.37419;
  <D.18418>:
  D.37419 = mono_defaults.single_class;
  return D.37419;
  <D.18419>:
  D.37419 = mono_defaults.double_class;
  return D.37419;
  <D.18420>:
  D.37419 = mono_defaults.string_class;
  return D.37419;
  <D.18421>:
  D.37417 = type->type;
  D.37418 = (int) D.37417;
  monoeg_g_log (0B, 16, "default_class_from_mono_type: implement me 0x%02x\n", D.37418);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 616);
  D.37419 = 0B;
  return D.37419;
}


mono_reflection_marshal_as_attribute_from_marshal_spec (struct MonoDomain * domain, struct MonoClass * klass, struct MonoMarshalSpec * spec)
{
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.733;
  struct MonoImage * D.37424;
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.734;
  _Bool D.37426;
  long int D.37427;
  long int D.37428;
  <unnamed type> D.37431;
  unsigned int D.37432;
  <unnamed type> D.37433;
  int D.37434;
  short int D.37435;
  char * D.37438;
  struct MonoImage * D.37441;
  struct MonoReflectionType * * D.37444;
  struct MonoReflectionType * D.37445;
  struct MonoString * * D.37446;
  struct MonoString * D.37447;
  char * D.37448;
  struct MonoString * * D.37451;
  struct MonoString * D.37452;
  struct MonoReflectionMarshalAsAttribute * D.37453;
  static struct MonoClass * System_Reflection_Emit_MarshalAsAttribute;
  struct MonoReflectionMarshalAsAttribute * minfo;
  struct MonoType * mtype;

  System_Reflection_Emit_MarshalAsAttribute.733 = System_Reflection_Emit_MarshalAsAttribute;
  if (System_Reflection_Emit_MarshalAsAttribute.733 == 0B) goto <D.37422>; else goto <D.37423>;
  <D.37422>:
  D.37424 = mono_defaults.corlib;
  System_Reflection_Emit_MarshalAsAttribute.734 = mono_class_from_name (D.37424, "System.Runtime.InteropServices", "MarshalAsAttribute");
  System_Reflection_Emit_MarshalAsAttribute = System_Reflection_Emit_MarshalAsAttribute.734;
  System_Reflection_Emit_MarshalAsAttribute.733 = System_Reflection_Emit_MarshalAsAttribute;
  D.37426 = System_Reflection_Emit_MarshalAsAttribute.733 == 0B;
  D.37427 = (long int) D.37426;
  D.37428 = __builtin_expect (D.37427, 0);
  if (D.37428 != 0) goto <D.37429>; else goto <D.37430>;
  <D.37429>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10070, "System_Reflection_Emit_MarshalAsAttribute");
  <D.37430>:
  <D.37423>:
  System_Reflection_Emit_MarshalAsAttribute.733 = System_Reflection_Emit_MarshalAsAttribute;
  minfo = mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute.733);
  D.37431 = spec->native;
  minfo->utype = D.37431;
  D.37432 = minfo->utype;
  switch (D.37432) <default: <D.22828>, case 23: <D.22825>, case 30: <D.22826>, case 42: <D.22823>, case 44: <D.22827>>
  <D.22823>:
  D.37433 = spec->data.array_data.elem_type;
  minfo->array_subtype = D.37433;
  D.37434 = spec->data.array_data.num_elem;
  minfo->size_const = D.37434;
  D.37435 = spec->data.array_data.param_num;
  if (D.37435 != -1) goto <D.37436>; else goto <D.37437>;
  <D.37436>:
  D.37435 = spec->data.array_data.param_num;
  minfo->size_param_index = D.37435;
  <D.37437>:
  goto <D.22824>;
  <D.22825>:
  <D.22826>:
  D.37434 = spec->data.array_data.num_elem;
  minfo->size_const = D.37434;
  goto <D.22824>;
  <D.22827>:
  D.37438 = spec->data.custom_data.custom_name;
  if (D.37438 != 0B) goto <D.37439>; else goto <D.37440>;
  <D.37439>:
  D.37438 = spec->data.custom_data.custom_name;
  D.37441 = klass->image;
  mtype = mono_reflection_type_from_name (D.37438, D.37441);
  if (mtype != 0B) goto <D.37442>; else goto <D.37443>;
  <D.37442>:
  D.37444 = &minfo->marshal_type_ref;
  D.37445 = mono_type_get_object (domain, mtype);
  mono_gc_wbarrier_set_field (minfo, D.37444, D.37445);
  <D.37443>:
  D.37446 = &minfo->marshal_type;
  D.37438 = spec->data.custom_data.custom_name;
  D.37447 = mono_string_new (domain, D.37438);
  mono_gc_wbarrier_set_field (minfo, D.37446, D.37447);
  <D.37440>:
  D.37448 = spec->data.custom_data.cookie;
  if (D.37448 != 0B) goto <D.37449>; else goto <D.37450>;
  <D.37449>:
  D.37451 = &minfo->marshal_cookie;
  D.37448 = spec->data.custom_data.cookie;
  D.37452 = mono_string_new (domain, D.37448);
  mono_gc_wbarrier_set_field (minfo, D.37451, D.37452);
  <D.37450>:
  goto <D.22824>;
  <D.22828>:
  goto <D.22824>;
  <D.22824>:
  D.37453 = minfo;
  return D.37453;
}


mono_reflection_bind_generic_parameters (struct MonoReflectionType * type, int type_argc, struct MonoType * * types)
{
  struct MonoVTable * D.37456;
  struct MonoClass * D.37457;
  int D.37458;
  int D.37462;
  struct MonoVTable * D.37465;
  struct MonoClass * D.37466;
  int D.37467;
  struct MonoGenericContainer * D.37472;
  struct MonoType * D.37475;
  struct MonoGenericContainer * D.37476;
  struct MonoType * D.37479;
  unsigned int D.37480;
  unsigned int D.37481;
  struct MonoClass * klass;
  struct MonoReflectionTypeBuilder * tb;
  gboolean is_dynamic;
  struct MonoDomain * domain;
  struct MonoClass * geninst;

  tb = 0B;
  is_dynamic = 0;
  mono_loader_lock ();
  D.37456 = MEM[(struct MonoObject *)type].vtable;
  domain = D.37456->domain;
  D.37456 = MEM[(struct MonoObject *)type].vtable;
  D.37457 = D.37456->klass;
  D.37458 = is_sre_type_builder (D.37457);
  if (D.37458 != 0) goto <D.37459>; else goto <D.37460>;
  <D.37459>:
  tb = type;
  is_dynamic = 1;
  goto <D.37461>;
  <D.37460>:
  D.37456 = MEM[(struct MonoObject *)type].vtable;
  D.37457 = D.37456->klass;
  D.37462 = is_sre_generic_instance (D.37457);
  if (D.37462 != 0) goto <D.37463>; else goto <D.37464>;
  <D.37463>:
  {
    struct MonoReflectionGenericClass * rgi;
    struct MonoReflectionType * gtd;

    rgi = type;
    gtd = rgi->generic_type;
    D.37465 = MEM[(struct MonoObject *)gtd].vtable;
    D.37466 = D.37465->klass;
    D.37467 = is_sre_type_builder (D.37466);
    if (D.37467 != 0) goto <D.37468>; else goto <D.37469>;
    <D.37468>:
    tb = gtd;
    is_dynamic = 1;
    <D.37469>:
  }
  <D.37464>:
  <D.37461>:
  if (tb != 0B) goto <D.37470>; else goto <D.37471>;
  <D.37470>:
  D.37472 = tb->generic_container;
  if (D.37472 != 0B) goto <D.37473>; else goto <D.37474>;
  <D.37473>:
  mono_reflection_create_generic_class (tb);
  <D.37474>:
  <D.37471>:
  D.37475 = mono_reflection_type_get_handle (type);
  klass = mono_class_from_mono_type (D.37475);
  D.37476 = klass->generic_container;
  if (D.37476 == 0B) goto <D.37477>; else goto <D.37478>;
  <D.37477>:
  mono_loader_unlock ();
  D.37479 = 0B;
  return D.37479;
  <D.37478>:
  D.37480 = BIT_FIELD_REF <*klass, 32, 160>;
  D.37481 = D.37480 & 128;
  if (D.37481 != 0) goto <D.37482>; else goto <D.37483>;
  <D.37482>:
  tb = mono_class_get_ref_info (klass);
  is_dynamic = 1;
  <D.37483>:
  mono_loader_unlock ();
  geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
  D.37479 = &geninst->byval_arg;
  return D.37479;
}


mono_class_bind_generic_parameters (struct MonoClass * klass, int type_argc, struct MonoType * * types, gboolean is_dynamic)
{
  struct MonoGenericContainer * D.37485;
  _Bool D.37486;
  long int D.37487;
  long int D.37488;
  struct MonoClass * D.37491;
  struct MonoGenericClass * gclass;
  struct MonoGenericInst * inst;

  D.37485 = klass->generic_container;
  D.37486 = D.37485 == 0B;
  D.37487 = (long int) D.37486;
  D.37488 = __builtin_expect (D.37487, 0);
  if (D.37488 != 0) goto <D.37489>; else goto <D.37490>;
  <D.37489>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10507, "klass->generic_container");
  <D.37490>:
  inst = mono_metadata_get_generic_inst (type_argc, types);
  gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
  D.37491 = mono_generic_class_get_class (gclass);
  return D.37491;
}


mono_reflection_bind_generic_method_parameters (struct MonoReflectionMethod * rmethod, struct MonoArray * types)
{
  int D.22954;
  int iftmp.735;
  int D.22953;
  struct MonoVTable * D.37496;
  struct MonoClass * D.37497;
  const char[14] * D.37498;
  unsigned char D.37499;
  int D.37500;
  unsigned char D.37501;
  int D.37502;
  const unsigned char * D.37507;
  unsigned char D.37508;
  int D.37509;
  const unsigned char * D.37510;
  unsigned char D.37511;
  int D.37512;
  const unsigned char * D.37517;
  unsigned char D.37518;
  int D.37519;
  const unsigned char * D.37520;
  unsigned char D.37521;
  int D.37522;
  const unsigned char * D.37527;
  unsigned char D.37528;
  int D.37529;
  const unsigned char * D.37530;
  unsigned char D.37531;
  int D.37532;
  const char * D.37534;
  struct MonoType * D.37537;
  unsigned int D.37539;
  unsigned int D.37540;
  struct MonoMethodSignature * D.37543;
  short unsigned int D.37544;
  unsigned int count.736;
  unsigned int D.37546;
  struct MonoReflectionMethod * D.37549;
  unsigned int count.737;
  unsigned int D.37551;
  unsigned int i.738;
  char * D.37553;
  unsigned int i.739;
  unsigned int D.37555;
  struct MonoType * * D.37556;
  struct MonoType * D.37557;
  struct MonoGenericInst * iftmp.740;
  struct MonoGenericClass * D.37559;
  struct MonoClass * D.37563;
  struct MonoImage * D.37564;
  unsigned int D.37565;
  unsigned int D.37566;
  struct MonoGHashTable * D.37569;
  int D.37570;
  struct MonoException * D.37573;
  struct MonoVTable * D.37574;
  struct MonoDomain * D.37575;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * inflated;
  struct MonoMethodInflated * imethod;
  struct MonoGenericContext tmp_context;
  struct MonoGenericInst * ginst;
  struct MonoType * * type_argv;
  int count;
  int i;

  try
    {
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.37496 = rmethod->object.vtable;
          D.37497 = D.37496->klass;
          __s2 = D.37497->name;
          D.37498 = "MethodBuilder";
          D.37499 = MEM[(const unsigned char *)D.37498];
          D.37500 = (int) D.37499;
          D.37501 = *__s2;
          D.37502 = (int) D.37501;
          __result = D.37500 - D.37502;
          {
            if (__s2_len != 0) goto <D.37503>; else goto <D.37504>;
            <D.37503>:
            if (__result == 0) goto <D.37505>; else goto <D.37506>;
            <D.37505>:
            D.37507 = &MEM[(void *)"MethodBuilder" + 1B];
            D.37508 = *D.37507;
            D.37509 = (int) D.37508;
            D.37510 = __s2 + 1;
            D.37511 = *D.37510;
            D.37512 = (int) D.37511;
            __result = D.37509 - D.37512;
            if (__s2_len > 1) goto <D.37513>; else goto <D.37514>;
            <D.37513>:
            if (__result == 0) goto <D.37515>; else goto <D.37516>;
            <D.37515>:
            D.37517 = &MEM[(void *)"MethodBuilder" + 2B];
            D.37518 = *D.37517;
            D.37519 = (int) D.37518;
            D.37520 = __s2 + 2;
            D.37521 = *D.37520;
            D.37522 = (int) D.37521;
            __result = D.37519 - D.37522;
            if (__s2_len > 2) goto <D.37523>; else goto <D.37524>;
            <D.37523>:
            if (__result == 0) goto <D.37525>; else goto <D.37526>;
            <D.37525>:
            D.37527 = &MEM[(void *)"MethodBuilder" + 3B];
            D.37528 = *D.37527;
            D.37529 = (int) D.37528;
            D.37530 = __s2 + 3;
            D.37531 = *D.37530;
            D.37532 = (int) D.37531;
            __result = D.37529 - D.37532;
            <D.37526>:
            <D.37524>:
            <D.37516>:
            <D.37514>:
            <D.37506>:
            <D.37504>:
          }
          D.22953 = __result;
        }
        iftmp.735 = -D.22953;
        goto <D.37533>;
        <D.37495>:
        D.37496 = rmethod->object.vtable;
        D.37497 = D.37496->klass;
        D.37534 = D.37497->name;
        iftmp.735 = __builtin_strcmp (D.37534, "MethodBuilder");
        <D.37533>:
        D.22954 = iftmp.735;
      }
      if (D.22954 == 0) goto <D.37535>; else goto <D.37536>;
      <D.37535>:
      {
        struct MonoReflectionMethodBuilder * mb;
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        mb = 0B;
        mb = rmethod;
        tb = mb->type;
        D.37537 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.37537);
        method = methodbuilder_to_mono_method (klass, mb);
      }
      goto <D.37538>;
      <D.37536>:
      method = rmethod->method;
      <D.37538>:
      klass = method->klass;
      D.37539 = BIT_FIELD_REF <*method, 32, 160>;
      D.37540 = D.37539 & 4096;
      if (D.37540 != 0) goto <D.37541>; else goto <D.37542>;
      <D.37541>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.37542>:
      D.37543 = mono_method_signature (method);
      D.37544 = D.37543->generic_param_count;
      count = (int) D.37544;
      count.736 = (unsigned int) count;
      D.37546 = mono_array_length (types);
      if (count.736 != D.37546) goto <D.37547>; else goto <D.37548>;
      <D.37547>:
      D.37549 = 0B;
      return D.37549;
      <D.37548>:
      count.737 = (unsigned int) count;
      D.37551 = count.737 * 4;
      type_argv = monoeg_malloc0 (D.37551);
      i = 0;
      goto <D.22960>;
      <D.22959>:
      {
        struct MonoReflectionType * garg;

        i.738 = (unsigned int) i;
        D.37553 = mono_array_addr_with_size (types, 4, i.738);
        garg = MEM[(void * *)D.37553];
        i.739 = (unsigned int) i;
        D.37555 = i.739 * 4;
        D.37556 = type_argv + D.37555;
        D.37557 = mono_reflection_type_get_handle (garg);
        *D.37556 = D.37557;
      }
      i = i + 1;
      <D.22960>:
      if (i < count) goto <D.22959>; else goto <D.22961>;
      <D.22961>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.37559 = klass->generic_class;
      if (D.37559 != 0B) goto <D.37560>; else goto <D.37561>;
      <D.37560>:
      D.37559 = klass->generic_class;
      iftmp.740 = D.37559->context.class_inst;
      goto <D.37562>;
      <D.37561>:
      iftmp.740 = 0B;
      <D.37562>:
      tmp_context.class_inst = iftmp.740;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      imethod = inflated;
      D.37563 = method->klass;
      D.37564 = D.37563->image;
      D.37565 = BIT_FIELD_REF <*D.37564, 32, 128>;
      D.37566 = D.37565 & 8;
      if (D.37566 != 0) goto <D.37567>; else goto <D.37568>;
      <D.37567>:
      {
        struct MonoDynamicImage * image;

        D.37563 = method->klass;
        image = D.37563->image;
        mono_image_lock (image);
        D.37569 = image->generic_def_objects;
        mono_g_hash_table_insert (D.37569, imethod, rmethod);
        mono_image_unlock (image);
      }
      <D.37568>:
      D.37570 = mono_verifier_is_method_valid_generic_instantiation (inflated);
      if (D.37570 == 0) goto <D.37571>; else goto <D.37572>;
      <D.37571>:
      D.37573 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
      mono_raise_exception (D.37573);
      <D.37572>:
      D.37574 = MEM[(struct MonoObject *)rmethod].vtable;
      D.37575 = D.37574->domain;
      D.37549 = mono_method_get_object (D.37575, inflated, 0B);
      return D.37549;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


mono_reflection_generic_class_initialize (struct MonoReflectionGenericClass * type, struct MonoArray * fields)
{
  unsigned char D.37578;
  _Bool D.37579;
  long int D.37580;
  long int D.37581;
  unsigned int D.37584;
  unsigned int D.37585;
  unsigned int D.37588;
  int iftmp.741;
  unsigned int D.37594;
  struct MonoImageSet * D.37596;
  int D.37597;
  unsigned int D.37598;
  unsigned int D.37599;
  void * D.37600;
  unsigned int D.37601;
  void * D.37602;
  void * D.37603;
  unsigned int i.742;
  char * D.37605;
  int D.23042;
  int iftmp.743;
  int D.23041;
  struct MonoVTable * D.37609;
  struct MonoClass * D.37610;
  const char[13] * D.37611;
  unsigned char D.37612;
  int D.37613;
  unsigned char D.37614;
  int D.37615;
  const unsigned char * D.37620;
  unsigned char D.37621;
  int D.37622;
  const unsigned char * D.37623;
  unsigned char D.37624;
  int D.37625;
  const unsigned char * D.37630;
  unsigned char D.37631;
  int D.37632;
  const unsigned char * D.37633;
  unsigned char D.37634;
  int D.37635;
  const unsigned char * D.37640;
  unsigned char D.37641;
  int D.37642;
  const unsigned char * D.37643;
  unsigned char D.37644;
  int D.37645;
  const char * D.37647;
  int D.23051;
  int iftmp.744;
  int D.23050;
  const char[10] * D.37654;
  unsigned char D.37655;
  int D.37656;
  unsigned char D.37657;
  int D.37658;
  const unsigned char * D.37663;
  unsigned char D.37664;
  int D.37665;
  const unsigned char * D.37666;
  unsigned char D.37667;
  int D.37668;
  const unsigned char * D.37673;
  unsigned char D.37674;
  int D.37675;
  const unsigned char * D.37676;
  unsigned char D.37677;
  int D.37678;
  const unsigned char * D.37683;
  unsigned char D.37684;
  int D.37685;
  const unsigned char * D.37686;
  unsigned char D.37687;
  int D.37688;
  struct MonoClassField * D.37693;
  unsigned int i.745;
  unsigned int D.37695;
  struct MonoClassField * D.37696;
  struct MonoType * D.37697;
  struct MonoGenericContext * D.37698;
  struct MonoType * D.37699;
  struct MonoType * * D.37700;
  unsigned int D.37701;
  struct MonoType * * D.37702;
  int D.37703;
  struct MonoObject * * D.37708;
  char * D.37709;
  void * D.37710;
  struct MonoObject * * D.37711;
  const char * D.37715;
  char * D.37716;
  struct MonoGenericClass * gclass;
  struct MonoDynamicGenericClass * dgclass;
  struct MonoClass * klass;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int i;

  gtype = mono_reflection_type_get_handle (type);
  klass = mono_class_from_mono_type (gtype);
  D.37578 = gtype->type;
  D.37579 = D.37578 != 21;
  D.37580 = (long int) D.37579;
  D.37581 = __builtin_expect (D.37580, 0);
  if (D.37581 != 0) goto <D.37582>; else goto <D.37583>;
  <D.37582>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10682, "gtype->type == MONO_TYPE_GENERICINST");
  <D.37583>:
  gclass = gtype->data.generic_class;
  D.37584 = BIT_FIELD_REF <*gclass, 32, 96>;
  D.37585 = D.37584 & 1;
  if (D.37585 == 0) goto <D.37586>; else goto <D.37587>;
  <D.37586>:
  return;
  <D.37587>:
  dgclass = gclass;
  D.37588 = dgclass->initialized;
  if (D.37588 != 0) goto <D.37589>; else goto <D.37590>;
  <D.37589>:
  return;
  <D.37590>:
  gklass = gclass->container_class;
  mono_class_init (gklass);
  if (fields != 0B) goto <D.37592>; else goto <D.37593>;
  <D.37592>:
  D.37594 = mono_array_length (fields);
  iftmp.741 = (int) D.37594;
  goto <D.37595>;
  <D.37593>:
  iftmp.741 = 0;
  <D.37595>:
  dgclass->count_fields = iftmp.741;
  D.37596 = gclass->owner;
  D.37597 = dgclass->count_fields;
  D.37598 = (unsigned int) D.37597;
  D.37599 = D.37598 * 16;
  D.37600 = mono_image_set_alloc0 (D.37596, D.37599);
  dgclass->fields = D.37600;
  D.37596 = gclass->owner;
  D.37597 = dgclass->count_fields;
  D.37598 = (unsigned int) D.37597;
  D.37601 = D.37598 * 4;
  D.37602 = mono_image_set_alloc0 (D.37596, D.37601);
  dgclass->field_objects = D.37602;
  D.37596 = gclass->owner;
  D.37597 = dgclass->count_fields;
  D.37598 = (unsigned int) D.37597;
  D.37601 = D.37598 * 4;
  D.37603 = mono_image_set_alloc0 (D.37596, D.37601);
  dgclass->field_generic_types = D.37603;
  i = 0;
  goto <D.23053>;
  <D.23052>:
  {
    struct MonoObject * obj;
    struct MonoClassField * field;
    struct MonoClassField * inflated_field;

    i.742 = (unsigned int) i;
    D.37605 = mono_array_addr_with_size (fields, 4, i.742);
    obj = MEM[(void * *)D.37605];
    inflated_field = 0B;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.37609 = obj->vtable;
        D.37610 = D.37609->klass;
        __s2 = D.37610->name;
        D.37611 = "FieldBuilder";
        D.37612 = MEM[(const unsigned char *)D.37611];
        D.37613 = (int) D.37612;
        D.37614 = *__s2;
        D.37615 = (int) D.37614;
        __result = D.37613 - D.37615;
        {
          if (__s2_len != 0) goto <D.37616>; else goto <D.37617>;
          <D.37616>:
          if (__result == 0) goto <D.37618>; else goto <D.37619>;
          <D.37618>:
          D.37620 = &MEM[(void *)"FieldBuilder" + 1B];
          D.37621 = *D.37620;
          D.37622 = (int) D.37621;
          D.37623 = __s2 + 1;
          D.37624 = *D.37623;
          D.37625 = (int) D.37624;
          __result = D.37622 - D.37625;
          if (__s2_len > 1) goto <D.37626>; else goto <D.37627>;
          <D.37626>:
          if (__result == 0) goto <D.37628>; else goto <D.37629>;
          <D.37628>:
          D.37630 = &MEM[(void *)"FieldBuilder" + 2B];
          D.37631 = *D.37630;
          D.37632 = (int) D.37631;
          D.37633 = __s2 + 2;
          D.37634 = *D.37633;
          D.37635 = (int) D.37634;
          __result = D.37632 - D.37635;
          if (__s2_len > 2) goto <D.37636>; else goto <D.37637>;
          <D.37636>:
          if (__result == 0) goto <D.37638>; else goto <D.37639>;
          <D.37638>:
          D.37640 = &MEM[(void *)"FieldBuilder" + 3B];
          D.37641 = *D.37640;
          D.37642 = (int) D.37641;
          D.37643 = __s2 + 3;
          D.37644 = *D.37643;
          D.37645 = (int) D.37644;
          __result = D.37642 - D.37645;
          <D.37639>:
          <D.37637>:
          <D.37629>:
          <D.37627>:
          <D.37619>:
          <D.37617>:
        }
        D.23041 = __result;
      }
      iftmp.743 = -D.23041;
      goto <D.37646>;
      <D.37608>:
      D.37609 = obj->vtable;
      D.37610 = D.37609->klass;
      D.37647 = D.37610->name;
      iftmp.743 = __builtin_strcmp (D.37647, "FieldBuilder");
      <D.37646>:
      D.23042 = iftmp.743;
    }
    if (D.23042 == 0) goto <D.37648>; else goto <D.37649>;
    <D.37648>:
    field = fieldbuilder_to_mono_class_field (klass, obj);
    inflated_field = field;
    goto <D.37650>;
    <D.37649>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.37609 = obj->vtable;
        D.37610 = D.37609->klass;
        __s2 = D.37610->name;
        D.37654 = "MonoField";
        D.37655 = MEM[(const unsigned char *)D.37654];
        D.37656 = (int) D.37655;
        D.37657 = *__s2;
        D.37658 = (int) D.37657;
        __result = D.37656 - D.37658;
        {
          if (__s2_len != 0) goto <D.37659>; else goto <D.37660>;
          <D.37659>:
          if (__result == 0) goto <D.37661>; else goto <D.37662>;
          <D.37661>:
          D.37663 = &MEM[(void *)"MonoField" + 1B];
          D.37664 = *D.37663;
          D.37665 = (int) D.37664;
          D.37666 = __s2 + 1;
          D.37667 = *D.37666;
          D.37668 = (int) D.37667;
          __result = D.37665 - D.37668;
          if (__s2_len > 1) goto <D.37669>; else goto <D.37670>;
          <D.37669>:
          if (__result == 0) goto <D.37671>; else goto <D.37672>;
          <D.37671>:
          D.37673 = &MEM[(void *)"MonoField" + 2B];
          D.37674 = *D.37673;
          D.37675 = (int) D.37674;
          D.37676 = __s2 + 2;
          D.37677 = *D.37676;
          D.37678 = (int) D.37677;
          __result = D.37675 - D.37678;
          if (__s2_len > 2) goto <D.37679>; else goto <D.37680>;
          <D.37679>:
          if (__result == 0) goto <D.37681>; else goto <D.37682>;
          <D.37681>:
          D.37683 = &MEM[(void *)"MonoField" + 3B];
          D.37684 = *D.37683;
          D.37685 = (int) D.37684;
          D.37686 = __s2 + 3;
          D.37687 = *D.37686;
          D.37688 = (int) D.37687;
          __result = D.37685 - D.37688;
          <D.37682>:
          <D.37680>:
          <D.37672>:
          <D.37670>:
          <D.37662>:
          <D.37660>:
        }
        D.23050 = __result;
      }
      iftmp.744 = -D.23050;
      goto <D.37689>;
      <D.37653>:
      D.37609 = obj->vtable;
      D.37610 = D.37609->klass;
      D.37647 = D.37610->name;
      iftmp.744 = __builtin_strcmp (D.37647, "MonoField");
      <D.37689>:
      D.23051 = iftmp.744;
    }
    if (D.23051 == 0) goto <D.37690>; else goto <D.37691>;
    <D.37690>:
    field = MEM[(struct MonoReflectionField *)obj].field;
    goto <D.37692>;
    <D.37691>:
    field = 0B;
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 10712);
    <D.37692>:
    <D.37650>:
    D.37693 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37695 = i.745 * 16;
    D.37696 = D.37693 + D.37695;
    *D.37696 = *field;
    D.37693 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37695 = i.745 * 16;
    D.37696 = D.37693 + D.37695;
    D.37696->parent = klass;
    D.37693 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37695 = i.745 * 16;
    D.37696 = D.37693 + D.37695;
    D.37697 = field->type;
    D.37698 = mono_generic_class_get_context (dgclass);
    D.37699 = mono_class_inflate_generic_type (D.37697, D.37698);
    D.37696->type = D.37699;
    D.37700 = dgclass->field_generic_types;
    i.745 = (unsigned int) i;
    D.37701 = i.745 * 4;
    D.37702 = D.37700 + D.37701;
    D.37697 = field->type;
    *D.37702 = D.37697;
    D.37703 = mono_gc_is_moving ();
    if (D.37703 != 0) goto <D.37704>; else goto <D.37705>;
    <D.37704>:
    if (0 != 0) goto <D.37706>; else goto <D.37707>;
    <D.37706>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10720, "sizeof (dgclass->field_objects [i]) == sizeof (MonoObject*)");
    <D.37707>:
    D.37708 = dgclass->field_objects;
    i.745 = (unsigned int) i;
    D.37701 = i.745 * 4;
    D.37709 = D.37708 + D.37701;
    D.37710 = mono_gc_make_root_descr_all_refs (1);
    mono_gc_register_root (D.37709, 4, D.37710);
    <D.37705>:
    D.37708 = dgclass->field_objects;
    i.745 = (unsigned int) i;
    D.37701 = i.745 * 4;
    D.37711 = D.37708 + D.37701;
    *D.37711 = obj;
    if (inflated_field != 0B) goto <D.37712>; else goto <D.37713>;
    <D.37712>:
    monoeg_g_free (inflated_field);
    goto <D.37714>;
    <D.37713>:
    D.37693 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37695 = i.745 * 16;
    D.37696 = D.37693 + D.37695;
    D.37596 = gclass->owner;
    D.37693 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37695 = i.745 * 16;
    D.37696 = D.37693 + D.37695;
    D.37715 = D.37696->name;
    D.37716 = mono_image_set_strdup (D.37596, D.37715);
    D.37696->name = D.37716;
    <D.37714>:
  }
  i = i + 1;
  <D.23053>:
  D.37597 = dgclass->count_fields;
  if (D.37597 > i) goto <D.23052>; else goto <D.23054>;
  <D.23054>:
  dgclass->initialized = 1;
}


fieldbuilder_to_mono_class_field (struct MonoClass * klass, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoImage * D.37718;
  struct MonoString * D.37719;
  char * D.37720;
  int D.37721;
  _Bool D.37722;
  long int D.37723;
  long int D.37724;
  unsigned int D.37730;
  struct MonoArray * D.37732;
  struct MonoArray * D.37734;
  struct MonoObject * D.37735;
  struct MonoType * D.37736;
  struct MonoType * D.37737;
  struct MonoType * D.37738;
  short unsigned int D.37739;
  unsigned int D.37740;
  unsigned int D.37741;
  _Bool D.37742;
  long int D.37743;
  long int D.37744;
  struct MonoType * D.37747;
  struct MonoType * D.37748;
  int D.37749;
  struct MonoArray * D.37752;
  struct MonoClassField * D.37753;
  struct MonoClassField * field;
  struct MonoType * custom;
  struct MonoError error;

  try
    {
      field = monoeg_malloc0 (16);
      D.37718 = klass->image;
      D.37719 = fb->name;
      D.37720 = mono_string_to_utf8_image (D.37718, D.37719, &error);
      field->name = D.37720;
      D.37721 = mono_error_ok (&error);
      D.37722 = D.37721 == 0;
      D.37723 = (long int) D.37722;
      D.37724 = __builtin_expect (D.37723, 0);
      if (D.37724 != 0) goto <D.37725>; else goto <D.37726>;
      <D.37725>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10427, "mono_error_ok (&error)");
      <D.37726>:
      D.37730 = fb->attrs;
      if (D.37730 != 0) goto <D.37727>; else goto <D.37731>;
      <D.37731>:
      D.37732 = fb->modreq;
      if (D.37732 != 0B) goto <D.37727>; else goto <D.37733>;
      <D.37733>:
      D.37734 = fb->modopt;
      if (D.37734 != 0B) goto <D.37727>; else goto <D.37728>;
      <D.37727>:
      D.37735 = fb->type;
      D.37736 = mono_reflection_type_get_handle (D.37735);
      D.37737 = mono_metadata_type_dup (0B, D.37736);
      field->type = D.37737;
      D.37738 = field->type;
      D.37730 = fb->attrs;
      D.37739 = (short unsigned int) D.37730;
      D.37738->attrs = D.37739;
      D.37718 = klass->image;
      D.37740 = BIT_FIELD_REF <*D.37718, 32, 128>;
      D.37741 = D.37740 & 8;
      D.37742 = D.37741 == 0;
      D.37743 = (long int) D.37742;
      D.37744 = __builtin_expect (D.37743, 0);
      if (D.37744 != 0) goto <D.37745>; else goto <D.37746>;
      <D.37745>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10432, "klass->image->dynamic");
      <D.37746>:
      D.37718 = klass->image;
      D.37738 = field->type;
      D.37732 = fb->modreq;
      D.37734 = fb->modopt;
      custom = add_custom_modifiers (D.37718, D.37738, D.37732, D.37734);
      D.37738 = field->type;
      monoeg_g_free (D.37738);
      D.37718 = klass->image;
      D.37747 = mono_metadata_type_dup (D.37718, custom);
      field->type = D.37747;
      monoeg_g_free (custom);
      goto <D.37729>;
      <D.37728>:
      D.37735 = fb->type;
      D.37748 = mono_reflection_type_get_handle (D.37735);
      field->type = D.37748;
      <D.37729>:
      D.37749 = fb->offset;
      if (D.37749 != -1) goto <D.37750>; else goto <D.37751>;
      <D.37750>:
      D.37749 = fb->offset;
      field->offset = D.37749;
      <D.37751>:
      field->parent = klass;
      D.37718 = klass->image;
      D.37752 = fb->cattrs;
      mono_save_custom_attrs (D.37718, field, D.37752);
      D.37753 = field;
      return D.37753;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_free_dynamic_generic_class (struct MonoGenericClass * gclass)
{
  unsigned int D.37756;
  unsigned int D.37757;
  _Bool D.37758;
  long int D.37759;
  long int D.37760;
  struct MonoClassField * D.37763;
  unsigned int i.746;
  unsigned int D.37765;
  struct MonoType * D.37766;
  int D.37767;
  struct MonoObject * * D.37770;
  unsigned int D.37771;
  char * D.37772;
  int D.37773;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.37756 = BIT_FIELD_REF <*gclass, 32, 96>;
  D.37757 = D.37756 & 1;
  D.37758 = D.37757 == 0;
  D.37759 = (long int) D.37758;
  D.37760 = __builtin_expect (D.37759, 0);
  if (D.37760 != 0) goto <D.37761>; else goto <D.37762>;
  <D.37761>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10739, "gclass->is_dynamic");
  <D.37762>:
  dgclass = gclass;
  i = 0;
  goto <D.23062>;
  <D.23061>:
  {
    struct MonoClassField * field;

    D.37763 = dgclass->fields;
    i.746 = (unsigned int) i;
    D.37765 = i.746 * 16;
    field = D.37763 + D.37765;
    D.37766 = field->type;
    mono_metadata_free_type (D.37766);
    D.37767 = mono_gc_is_moving ();
    if (D.37767 != 0) goto <D.37768>; else goto <D.37769>;
    <D.37768>:
    D.37770 = dgclass->field_objects;
    i.746 = (unsigned int) i;
    D.37771 = i.746 * 4;
    D.37772 = D.37770 + D.37771;
    mono_gc_deregister_root (D.37772);
    <D.37769>:
  }
  i = i + 1;
  <D.23062>:
  D.37773 = dgclass->count_fields;
  if (D.37773 > i) goto <D.23061>; else goto <D.23063>;
  <D.23063>:
}


mono_reflection_get_dynamic_overrides (struct MonoClass * klass, struct MonoMethod * * * overrides, int * num_overrides)
{
  struct MonoImage * D.37774;
  unsigned int D.37775;
  unsigned int D.37776;
  _Bool D.37777;
  long int D.37778;
  long int D.37779;
  void * D.37782;
  int D.23140;
  int iftmp.747;
  int D.23139;
  void * D.37788;
  struct MonoVTable * D.37789;
  struct MonoClass * D.37790;
  const char[12] * D.37791;
  unsigned char D.37792;
  int D.37793;
  unsigned char D.37794;
  int D.37795;
  const unsigned char * D.37800;
  unsigned char D.37801;
  int D.37802;
  const unsigned char * D.37803;
  unsigned char D.37804;
  int D.37805;
  const unsigned char * D.37810;
  unsigned char D.37811;
  int D.37812;
  const unsigned char * D.37813;
  unsigned char D.37814;
  int D.37815;
  const unsigned char * D.37820;
  unsigned char D.37821;
  int D.37822;
  const unsigned char * D.37823;
  unsigned char D.37824;
  int D.37825;
  void * D.37827;
  struct MonoVTable * D.37828;
  struct MonoClass * D.37829;
  const char * D.37830;
  _Bool D.37831;
  long int D.37832;
  long int D.37833;
  struct MonoArray * D.37836;
  unsigned int i.748;
  char * D.37840;
  struct MonoArray * D.37841;
  unsigned int D.37844;
  unsigned int onum.749;
  unsigned int D.37846;
  int D.37847;
  unsigned int onum.750;
  unsigned int D.37851;
  void * D.37852;
  char * D.37853;
  struct MonoArray * D.37854;
  unsigned int j.751;
  char * D.37858;
  struct MonoMethod * * D.37859;
  struct MonoMethod * * D.37860;
  struct MonoMethod * D.37861;
  sizetype onum.752;
  sizetype D.37863;
  sizetype D.37864;
  struct MonoMethod * * D.37865;
  struct MonoMethod * D.37866;
  _Bool D.37867;
  long int D.37868;
  long int D.37869;
  unsigned int D.37872;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int j;
  int onum;
  struct MonoReflectionMethod * m;

  *overrides = 0B;
  *num_overrides = 0;
  D.37774 = klass->image;
  D.37775 = BIT_FIELD_REF <*D.37774, 32, 128>;
  D.37776 = D.37775 & 8;
  D.37777 = D.37776 == 0;
  D.37778 = (long int) D.37777;
  D.37779 = __builtin_expect (D.37778, 0);
  if (D.37779 != 0) goto <D.37780>; else goto <D.37781>;
  <D.37780>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10948, "klass->image->dynamic");
  <D.37781>:
  D.37782 = mono_class_get_ref_info (klass);
  if (D.37782 == 0B) goto <D.37783>; else goto <D.37784>;
  <D.37783>:
  return;
  <D.37784>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.37788 = mono_class_get_ref_info (klass);
      D.37789 = MEM[(struct MonoObject *)D.37788].vtable;
      D.37790 = D.37789->klass;
      __s2 = D.37790->name;
      D.37791 = "TypeBuilder";
      D.37792 = MEM[(const unsigned char *)D.37791];
      D.37793 = (int) D.37792;
      D.37794 = *__s2;
      D.37795 = (int) D.37794;
      __result = D.37793 - D.37795;
      {
        if (__s2_len != 0) goto <D.37796>; else goto <D.37797>;
        <D.37796>:
        if (__result == 0) goto <D.37798>; else goto <D.37799>;
        <D.37798>:
        D.37800 = &MEM[(void *)"TypeBuilder" + 1B];
        D.37801 = *D.37800;
        D.37802 = (int) D.37801;
        D.37803 = __s2 + 1;
        D.37804 = *D.37803;
        D.37805 = (int) D.37804;
        __result = D.37802 - D.37805;
        if (__s2_len > 1) goto <D.37806>; else goto <D.37807>;
        <D.37806>:
        if (__result == 0) goto <D.37808>; else goto <D.37809>;
        <D.37808>:
        D.37810 = &MEM[(void *)"TypeBuilder" + 2B];
        D.37811 = *D.37810;
        D.37812 = (int) D.37811;
        D.37813 = __s2 + 2;
        D.37814 = *D.37813;
        D.37815 = (int) D.37814;
        __result = D.37812 - D.37815;
        if (__s2_len > 2) goto <D.37816>; else goto <D.37817>;
        <D.37816>:
        if (__result == 0) goto <D.37818>; else goto <D.37819>;
        <D.37818>:
        D.37820 = &MEM[(void *)"TypeBuilder" + 3B];
        D.37821 = *D.37820;
        D.37822 = (int) D.37821;
        D.37823 = __s2 + 3;
        D.37824 = *D.37823;
        D.37825 = (int) D.37824;
        __result = D.37822 - D.37825;
        <D.37819>:
        <D.37817>:
        <D.37809>:
        <D.37807>:
        <D.37799>:
        <D.37797>:
      }
      D.23139 = __result;
    }
    iftmp.747 = -D.23139;
    goto <D.37826>;
    <D.37787>:
    D.37827 = mono_class_get_ref_info (klass);
    D.37828 = MEM[(struct MonoObject *)D.37827].vtable;
    D.37829 = D.37828->klass;
    D.37830 = D.37829->name;
    iftmp.747 = __builtin_strcmp (D.37830, "TypeBuilder");
    <D.37826>:
    D.23140 = iftmp.747;
  }
  D.37831 = D.23140 != 0;
  D.37832 = (long int) D.37831;
  D.37833 = __builtin_expect (D.37832, 0);
  if (D.37833 != 0) goto <D.37834>; else goto <D.37835>;
  <D.37834>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10953, "strcmp (((MonoObject*)mono_class_get_ref_info (klass))->vtable->klass->name, \"TypeBuilder\") == 0");
  <D.37835>:
  tb = mono_class_get_ref_info (klass);
  onum = 0;
  D.37836 = tb->methods;
  if (D.37836 != 0B) goto <D.37837>; else goto <D.37838>;
  <D.37837>:
  i = 0;
  goto <D.23143>;
  <D.23142>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.37836 = tb->methods;
    i.748 = (unsigned int) i;
    D.37840 = mono_array_addr_with_size (D.37836, 4, i.748);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.37840];
    D.37841 = mb->override_methods;
    if (D.37841 != 0B) goto <D.37842>; else goto <D.37843>;
    <D.37842>:
    D.37841 = mb->override_methods;
    D.37844 = mono_array_length (D.37841);
    onum.749 = (unsigned int) onum;
    D.37846 = D.37844 + onum.749;
    onum = (int) D.37846;
    <D.37843>:
  }
  i = i + 1;
  <D.23143>:
  D.37847 = tb->num_methods;
  if (D.37847 > i) goto <D.23142>; else goto <D.23144>;
  <D.23144>:
  <D.37838>:
  if (onum != 0) goto <D.37848>; else goto <D.37849>;
  <D.37848>:
  onum.750 = (unsigned int) onum;
  D.37851 = onum.750 * 8;
  D.37852 = monoeg_malloc0 (D.37851);
  *overrides = D.37852;
  onum = 0;
  i = 0;
  goto <D.23150>;
  <D.23149>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.37836 = tb->methods;
    i.748 = (unsigned int) i;
    D.37853 = mono_array_addr_with_size (D.37836, 4, i.748);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.37853];
    D.37854 = mb->override_methods;
    if (D.37854 != 0B) goto <D.37855>; else goto <D.37856>;
    <D.37855>:
    j = 0;
    goto <D.23147>;
    <D.23146>:
    D.37854 = mb->override_methods;
    j.751 = (unsigned int) j;
    D.37858 = mono_array_addr_with_size (D.37854, 4, j.751);
    m = MEM[(struct MonoReflectionMethod * *)D.37858];
    D.37859 = *overrides;
    onum.750 = (unsigned int) onum;
    D.37851 = onum.750 * 8;
    D.37860 = D.37859 + D.37851;
    D.37861 = mono_reflection_method_get_handle (m);
    *D.37860 = D.37861;
    D.37859 = *overrides;
    onum.752 = (sizetype) onum;
    D.37863 = onum.752 * 8;
    D.37864 = D.37863 + 4;
    D.37865 = D.37859 + D.37864;
    D.37866 = mb->mhandle;
    *D.37865 = D.37866;
    D.37866 = mb->mhandle;
    D.37867 = D.37866 == 0B;
    D.37868 = (long int) D.37867;
    D.37869 = __builtin_expect (D.37868, 0);
    if (D.37869 != 0) goto <D.37870>; else goto <D.37871>;
    <D.37870>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10981, "mb->mhandle");
    <D.37871>:
    onum = onum + 1;
    j = j + 1;
    <D.23147>:
    j.751 = (unsigned int) j;
    D.37854 = mb->override_methods;
    D.37872 = mono_array_length (D.37854);
    if (j.751 < D.37872) goto <D.23146>; else goto <D.23148>;
    <D.23148>:
    <D.37856>:
  }
  i = i + 1;
  <D.23150>:
  D.37847 = tb->num_methods;
  if (D.37847 > i) goto <D.23149>; else goto <D.23151>;
  <D.23151>:
  <D.37849>:
  *num_overrides = onum;
}


mono_reflection_method_get_handle (struct MonoObject * method)
{
  struct MonoVTable * D.37874;
  int D.37877;
  int D.37879;
  struct MonoMethod * D.37880;
  int D.37881;
  int D.37884;
  struct MonoArray * D.37887;
  struct MonoReflectionType * D.37891;
  struct MonoObject * D.37892;
  struct MonoVTable * D.37893;
  struct MonoClass * D.37894;
  int D.37895;
  int D.37899;
  char * D.37903;
  const char * D.37904;
  const char * D.37905;
  struct MonoClass * class;

  D.37874 = method->vtable;
  class = D.37874->klass;
  D.37877 = is_sr_mono_method (class);
  if (D.37877 != 0) goto <D.37875>; else goto <D.37878>;
  <D.37878>:
  D.37879 = is_sr_mono_generic_method (class);
  if (D.37879 != 0) goto <D.37875>; else goto <D.37876>;
  <D.37875>:
  {
    struct MonoReflectionMethod * sr_method;

    sr_method = method;
    D.37880 = sr_method->method;
    return D.37880;
  }
  <D.37876>:
  D.37881 = is_sre_method_builder (class);
  if (D.37881 != 0) goto <D.37882>; else goto <D.37883>;
  <D.37882>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = method;
    D.37880 = mb->mhandle;
    return D.37880;
  }
  <D.37883>:
  D.37884 = is_sre_method_on_tb_inst (class);
  if (D.37884 != 0) goto <D.37885>; else goto <D.37886>;
  <D.37885>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;
    struct MonoMethod * result;

    m = method;
    D.37887 = m->method_args;
    if (D.37887 != 0B) goto <D.37888>; else goto <D.37889>;
    <D.37888>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    goto <D.37890>;
    <D.37889>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * mono_method;

      D.37891 = m->inst;
      type = mono_reflection_type_get_handle (D.37891);
      inflated_klass = mono_class_from_mono_type (type);
      D.37892 = m->mb;
      D.37893 = D.37892->vtable;
      D.37894 = D.37893->klass;
      D.37895 = is_sre_method_builder (D.37894);
      if (D.37895 != 0) goto <D.37896>; else goto <D.37897>;
      <D.37896>:
      D.37892 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethodBuilder *)D.37892].mhandle;
      goto <D.37898>;
      <D.37897>:
      D.37892 = m->mb;
      D.37893 = D.37892->vtable;
      D.37894 = D.37893->klass;
      D.37899 = is_sr_mono_method (D.37894);
      if (D.37899 != 0) goto <D.37900>; else goto <D.37901>;
      <D.37900>:
      D.37892 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethod *)D.37892].method;
      goto <D.37902>;
      <D.37901>:
      D.37892 = m->mb;
      D.37893 = D.37892->vtable;
      D.37894 = D.37893->klass;
      D.37903 = mono_type_get_full_name (D.37894);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.37903);
      <D.23120>:
      goto <D.23120>;
      <D.37902>:
      <D.37898>:
      D.37892 = m->mb;
      result = inflate_mono_method (inflated_klass, mono_method, D.37892);
    }
    <D.37890>:
    D.37880 = result;
    return D.37880;
  }
  <D.37886>:
  D.37904 = class->name_space;
  D.37905 = class->name;
  monoeg_g_log (0B, 4, "Can\'t handle methods of type %s:%s", D.37904, D.37905);
  <D.23121>:
  goto <D.23121>;
  D.37880 = 0B;
  return D.37880;
}


mono_reflection_event_builder_get_event_info (struct MonoReflectionTypeBuilder * tb, struct MonoReflectionEventBuilder * eb)
{
  struct MonoType * D.37907;
  unsigned int D.37908;
  struct MonoString * D.37909;
  char * D.37910;
  struct MonoReflectionMethodBuilder * D.37911;
  struct MonoMethod * D.37914;
  struct MonoReflectionMethodBuilder * D.37915;
  struct MonoMethod * D.37918;
  struct MonoReflectionMethodBuilder * D.37919;
  struct MonoMethod * D.37922;
  struct MonoArray * D.37923;
  unsigned int D.37926;
  unsigned int D.37927;
  unsigned int D.37928;
  void * D.37929;
  unsigned int j.753;
  char * D.37931;
  struct MonoMethod * * D.37932;
  unsigned int j.754;
  unsigned int D.37934;
  struct MonoMethod * * D.37935;
  struct MonoMethod * D.37936;
  unsigned int D.37937;
  struct MonoReflectionEvent * D.37938;
  struct MonoVTable * D.37939;
  struct MonoDomain * D.37940;
  struct MonoEvent * event;
  struct MonoClass * klass;

  event = monoeg_malloc0 (28);
  D.37907 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.37907);
  event->parent = klass;
  D.37908 = eb->attrs;
  event->attrs = D.37908;
  D.37909 = eb->name;
  D.37910 = mono_string_to_utf8 (D.37909);
  event->name = D.37910;
  D.37911 = eb->add_method;
  if (D.37911 != 0B) goto <D.37912>; else goto <D.37913>;
  <D.37912>:
  D.37911 = eb->add_method;
  D.37914 = D.37911->mhandle;
  event->add = D.37914;
  <D.37913>:
  D.37915 = eb->remove_method;
  if (D.37915 != 0B) goto <D.37916>; else goto <D.37917>;
  <D.37916>:
  D.37915 = eb->remove_method;
  D.37918 = D.37915->mhandle;
  event->remove = D.37918;
  <D.37917>:
  D.37919 = eb->raise_method;
  if (D.37919 != 0B) goto <D.37920>; else goto <D.37921>;
  <D.37920>:
  D.37919 = eb->raise_method;
  D.37922 = D.37919->mhandle;
  event->raise = D.37922;
  <D.37921>:
  D.37923 = eb->other_methods;
  if (D.37923 != 0B) goto <D.37924>; else goto <D.37925>;
  <D.37924>:
  {
    int j;

    D.37923 = eb->other_methods;
    D.37926 = mono_array_length (D.37923);
    D.37927 = D.37926 + 1;
    D.37928 = D.37927 * 4;
    D.37929 = monoeg_malloc0 (D.37928);
    event->other = D.37929;
    j = 0;
    goto <D.23201>;
    <D.23200>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.37923 = eb->other_methods;
      j.753 = (unsigned int) j;
      D.37931 = mono_array_addr_with_size (D.37923, 4, j.753);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.37931];
      D.37932 = event->other;
      j.754 = (unsigned int) j;
      D.37934 = j.754 * 4;
      D.37935 = D.37932 + D.37934;
      D.37936 = mb->mhandle;
      *D.37935 = D.37936;
    }
    j = j + 1;
    <D.23201>:
    j.753 = (unsigned int) j;
    D.37923 = eb->other_methods;
    D.37937 = mono_array_length (D.37923);
    if (j.753 < D.37937) goto <D.23200>; else goto <D.23202>;
    <D.23202>:
  }
  <D.37925>:
  D.37939 = MEM[(struct MonoObject *)tb].vtable;
  D.37940 = D.37939->domain;
  D.37938 = mono_event_get_object (D.37940, klass, event);
  return D.37938;
}


mono_reflection_create_runtime_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoVTable * D.37942;
  struct MonoType * D.37943;
  struct MonoObject * D.37944;
  struct MonoReflectionType * D.37945;
  struct MonoArray * D.37946;
  struct MonoArray * D.37947;
  unsigned int i.755;
  char * D.37951;
  struct MonoObject * D.37954;
  struct MonoReflectionType * D.37955;
  struct MonoArray * D.37956;
  struct MonoArray * D.37957;
  struct MonoReflectionMarshal * D.37958;
  struct MonoObject * D.37961;
  struct MonoReflectionType * D.37964;
  unsigned int D.37965;
  struct MonoArray * D.37966;
  char * D.37969;
  struct MonoObject * D.37972;
  struct MonoReflectionType * D.37973;
  struct MonoArray * D.37974;
  struct MonoArray * D.37975;
  struct MonoArray * D.37976;
  struct MonoArray * D.37977;
  unsigned int j.756;
  char * D.37981;
  struct MonoArray * D.37982;
  unsigned int D.37983;
  struct MonoArray * D.37984;
  char * D.37987;
  struct MonoArray * D.37988;
  unsigned int D.37989;
  unsigned int D.37990;
  struct MonoArray * D.37991;
  char * D.37994;
  struct MonoArray * D.37997;
  struct MonoArray * D.37998;
  char * D.38001;
  struct MonoArray * D.38002;
  unsigned int D.38003;
  struct MonoArray * D.38004;
  char * D.38007;
  struct MonoArray * D.38008;
  unsigned int D.38009;
  unsigned int D.38010;
  struct MonoImage * D.38011;
  struct MonoArray * D.38012;
  union mono_mutex_t * D.38013;
  _Bool D.38016;
  long int D.38017;
  long int D.38018;
  unsigned int D.38021;
  unsigned int D.38022;
  _Bool D.38027;
  long int D.38028;
  long int D.38029;
  struct MonoReflectionType * D.38032;
  struct MonoDomain * D.38033;
  struct MonoType * D.38034;
  unsigned int D.38035;
  struct MonoClass * D.38036;
  unsigned int D.38037;
  struct MonoArray * D.38040;
  char * D.38043;
  struct MonoClassExt * D.38044;
  struct GList * D.38045;
  struct MonoType * D.38046;
  struct MonoClass * D.38047;
  struct GList * D.38048;
  unsigned int D.38049;
  unsigned int D.38052;
  unsigned int D.38053;
  int D.38056;
  unsigned char D.38057;
  <unnamed-unsigned:1> D.38058;
  unsigned char D.38059;
  <unnamed-unsigned:1> D.38060;
  unsigned char D.38061;
  unsigned char D.38062;
  <unnamed-unsigned:1> D.38063;
  int D.38065;
  int D.38067;
  int D.38069;
  struct MonoGHashTable * D.38071;
  struct MonoGenericContainer * D.38074;
  _Bool D.38079;
  long int D.38080;
  long int D.38081;
  int D.38086;
  struct MonoString * D.38089;
  struct MonoException * D.38090;
  _Bool D.38091;
  long int D.38092;
  long int D.38093;
  _Bool D.38098;
  long int D.38099;
  long int D.38100;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoReflectionType * res;
  int i;
  int j;
  void failure = <<< error >>>;

  try
    {
      D.37942 = MEM[(struct MonoObject *)tb].vtable;
      domain = D.37942->domain;
      D.37943 = tb->type.type;
      klass = mono_class_from_mono_type (D.37943);
      D.37944 = tb->parent;
      D.37945 = mono_reflection_type_resolve_user_types (D.37944);
      tb->parent = D.37945;
      D.37946 = tb->interfaces;
      check_array_for_usertypes (D.37946);
      D.37947 = tb->fields;
      if (D.37947 != 0B) goto <D.37948>; else goto <D.37949>;
      <D.37948>:
      i = 0;
      goto <D.23247>;
      <D.23246>:
      {
        struct MonoReflectionFieldBuilder * fb;

        D.37947 = tb->fields;
        i.755 = (unsigned int) i;
        D.37951 = mono_array_addr_with_size (D.37947, 4, i.755);
        fb = MEM[(void * *)D.37951];
        if (fb != 0B) goto <D.37952>; else goto <D.37953>;
        <D.37952>:
        D.37954 = fb->type;
        D.37955 = mono_reflection_type_resolve_user_types (D.37954);
        fb->type = D.37955;
        D.37956 = fb->modreq;
        check_array_for_usertypes (D.37956);
        D.37957 = fb->modopt;
        check_array_for_usertypes (D.37957);
        D.37958 = fb->marshal_info;
        if (D.37958 != 0B) goto <D.37959>; else goto <D.37960>;
        <D.37959>:
        D.37958 = fb->marshal_info;
        D.37961 = D.37958->marshaltyperef;
        if (D.37961 != 0B) goto <D.37962>; else goto <D.37963>;
        <D.37962>:
        D.37958 = fb->marshal_info;
        D.37958 = fb->marshal_info;
        D.37961 = D.37958->marshaltyperef;
        D.37964 = mono_reflection_type_resolve_user_types (D.37961);
        D.37958->marshaltyperef = D.37964;
        <D.37963>:
        <D.37960>:
        <D.37953>:
      }
      i = i + 1;
      <D.23247>:
      i.755 = (unsigned int) i;
      D.37947 = tb->fields;
      D.37965 = mono_array_length (D.37947);
      if (i.755 < D.37965) goto <D.23246>; else goto <D.23248>;
      <D.23248>:
      <D.37949>:
      D.37966 = tb->methods;
      if (D.37966 != 0B) goto <D.37967>; else goto <D.37968>;
      <D.37967>:
      i = 0;
      goto <D.23257>;
      <D.23256>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.37966 = tb->methods;
        i.755 = (unsigned int) i;
        D.37969 = mono_array_addr_with_size (D.37966, 4, i.755);
        mb = MEM[(void * *)D.37969];
        if (mb != 0B) goto <D.37970>; else goto <D.37971>;
        <D.37970>:
        D.37972 = mb->rtype;
        D.37973 = mono_reflection_type_resolve_user_types (D.37972);
        mb->rtype = D.37973;
        D.37974 = mb->return_modreq;
        check_array_for_usertypes (D.37974);
        D.37975 = mb->return_modopt;
        check_array_for_usertypes (D.37975);
        D.37976 = mb->parameters;
        check_array_for_usertypes (D.37976);
        D.37977 = mb->param_modreq;
        if (D.37977 != 0B) goto <D.37978>; else goto <D.37979>;
        <D.37978>:
        j = 0;
        goto <D.23251>;
        <D.23250>:
        D.37977 = mb->param_modreq;
        j.756 = (unsigned int) j;
        D.37981 = mono_array_addr_with_size (D.37977, 4, j.756);
        D.37982 = MEM[(struct MonoArray * *)D.37981];
        check_array_for_usertypes (D.37982);
        j = j + 1;
        <D.23251>:
        j.756 = (unsigned int) j;
        D.37977 = mb->param_modreq;
        D.37983 = mono_array_length (D.37977);
        if (j.756 < D.37983) goto <D.23250>; else goto <D.23252>;
        <D.23252>:
        <D.37979>:
        D.37984 = mb->param_modopt;
        if (D.37984 != 0B) goto <D.37985>; else goto <D.37986>;
        <D.37985>:
        j = 0;
        goto <D.23254>;
        <D.23253>:
        D.37984 = mb->param_modopt;
        j.756 = (unsigned int) j;
        D.37987 = mono_array_addr_with_size (D.37984, 4, j.756);
        D.37988 = MEM[(struct MonoArray * *)D.37987];
        check_array_for_usertypes (D.37988);
        j = j + 1;
        <D.23254>:
        j.756 = (unsigned int) j;
        D.37984 = mb->param_modopt;
        D.37989 = mono_array_length (D.37984);
        if (j.756 < D.37989) goto <D.23253>; else goto <D.23255>;
        <D.23255>:
        <D.37986>:
        <D.37971>:
      }
      i = i + 1;
      <D.23257>:
      i.755 = (unsigned int) i;
      D.37966 = tb->methods;
      D.37990 = mono_array_length (D.37966);
      if (i.755 < D.37990) goto <D.23256>; else goto <D.23258>;
      <D.23258>:
      <D.37968>:
      D.37991 = tb->ctors;
      if (D.37991 != 0B) goto <D.37992>; else goto <D.37993>;
      <D.37992>:
      i = 0;
      goto <D.23267>;
      <D.23266>:
      {
        struct MonoReflectionCtorBuilder * mb;

        D.37991 = tb->ctors;
        i.755 = (unsigned int) i;
        D.37994 = mono_array_addr_with_size (D.37991, 4, i.755);
        mb = MEM[(void * *)D.37994];
        if (mb != 0B) goto <D.37995>; else goto <D.37996>;
        <D.37995>:
        D.37997 = mb->parameters;
        check_array_for_usertypes (D.37997);
        D.37998 = mb->param_modreq;
        if (D.37998 != 0B) goto <D.37999>; else goto <D.38000>;
        <D.37999>:
        j = 0;
        goto <D.23261>;
        <D.23260>:
        D.37998 = mb->param_modreq;
        j.756 = (unsigned int) j;
        D.38001 = mono_array_addr_with_size (D.37998, 4, j.756);
        D.38002 = MEM[(struct MonoArray * *)D.38001];
        check_array_for_usertypes (D.38002);
        j = j + 1;
        <D.23261>:
        j.756 = (unsigned int) j;
        D.37998 = mb->param_modreq;
        D.38003 = mono_array_length (D.37998);
        if (j.756 < D.38003) goto <D.23260>; else goto <D.23262>;
        <D.23262>:
        <D.38000>:
        D.38004 = mb->param_modopt;
        if (D.38004 != 0B) goto <D.38005>; else goto <D.38006>;
        <D.38005>:
        j = 0;
        goto <D.23264>;
        <D.23263>:
        D.38004 = mb->param_modopt;
        j.756 = (unsigned int) j;
        D.38007 = mono_array_addr_with_size (D.38004, 4, j.756);
        D.38008 = MEM[(struct MonoArray * *)D.38007];
        check_array_for_usertypes (D.38008);
        j = j + 1;
        <D.23264>:
        j.756 = (unsigned int) j;
        D.38004 = mb->param_modopt;
        D.38009 = mono_array_length (D.38004);
        if (j.756 < D.38009) goto <D.23263>; else goto <D.23265>;
        <D.23265>:
        <D.38006>:
        <D.37996>:
      }
      i = i + 1;
      <D.23267>:
      i.755 = (unsigned int) i;
      D.37991 = tb->ctors;
      D.38010 = mono_array_length (D.37991);
      if (i.755 < D.38010) goto <D.23266>; else goto <D.23268>;
      <D.23268>:
      <D.37993>:
      D.38011 = klass->image;
      D.38012 = tb->cattrs;
      mono_save_custom_attrs (D.38011, klass, D.38012);
      mono_loader_lock ();
      {
        int ret;

        D.38013 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.38013);
        if (ret != 0) goto <D.38014>; else goto <D.38015>;
        <D.38014>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.38015>:
        D.38016 = ret != 0;
        D.38017 = (long int) D.38016;
        D.38018 = __builtin_expect (D.38017, 0);
        if (D.38018 != 0) goto <D.38019>; else goto <D.38020>;
        <D.38019>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11312, "ret == 0");
        <D.38020>:
      }
      D.38021 = BIT_FIELD_REF <*klass, 32, 160>;
      D.38022 = D.38021 & 128;
      if (D.38022 != 0) goto <D.38023>; else goto <D.38024>;
      <D.38023>:
      {
        int ret;

        D.38013 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38013);
        if (ret != 0) goto <D.38025>; else goto <D.38026>;
        <D.38025>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38026>:
        D.38027 = ret != 0;
        D.38028 = (long int) D.38027;
        D.38029 = __builtin_expect (D.38028, 0);
        if (D.38029 != 0) goto <D.38030>; else goto <D.38031>;
        <D.38030>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11314, "ret == 0");
        <D.38031>:
      }
      mono_loader_unlock ();
      D.37942 = MEM[(struct MonoObject *)tb].vtable;
      D.38033 = D.37942->domain;
      D.38034 = &klass->byval_arg;
      D.38032 = mono_type_get_object (D.38033, D.38034);
      return D.38032;
      <D.38024>:
      D.38035 = tb->attrs;
      klass->flags = D.38035;
      klass->has_cctor = 1;
      klass->has_finalize = 1;
      klass->has_finalize_inited = 1;
      klass->supertypes = 0B;
      D.38036 = klass->parent;
      mono_class_setup_parent (klass, D.38036);
      mono_class_setup_mono_type (klass);
      D.38021 = BIT_FIELD_REF <*klass, 32, 160>;
      D.38037 = D.38021 & 16;
      if (D.38037 == 0) goto <D.38038>; else goto <D.38039>;
      <D.38038>:
      ensure_runtime_vtable (klass);
      <D.38039>:
      D.38040 = tb->subtypes;
      if (D.38040 != 0B) goto <D.38041>; else goto <D.38042>;
      <D.38041>:
      i = 0;
      goto <D.23273>;
      <D.23272>:
      {
        struct MonoReflectionTypeBuilder * subtb;

        D.38040 = tb->subtypes;
        i.755 = (unsigned int) i;
        D.38043 = mono_array_addr_with_size (D.38040, 4, i.755);
        subtb = MEM[(struct MonoReflectionTypeBuilder * *)D.38043];
        mono_class_alloc_ext (klass);
        D.38044 = klass->ext;
        D.38011 = klass->image;
        D.38044 = klass->ext;
        D.38045 = D.38044->nested_classes;
        D.38046 = mono_reflection_type_get_handle (subtb);
        D.38047 = mono_class_from_mono_type (D.38046);
        D.38048 = g_list_prepend_image (D.38011, D.38045, D.38047);
        D.38044->nested_classes = D.38048;
      }
      i = i + 1;
      <D.23273>:
      i.755 = (unsigned int) i;
      D.38040 = tb->subtypes;
      D.38049 = mono_array_length (D.38040);
      if (i.755 < D.38049) goto <D.23272>; else goto <D.23274>;
      <D.23274>:
      <D.38042>:
      klass->nested_classes_inited = 1;
      D.38036 = klass->parent;
      if (D.38036 != 0B) goto <D.38050>; else goto <D.38051>;
      <D.38050>:
      D.38036 = klass->parent;
      D.38052 = BIT_FIELD_REF <*D.38036, 32, 160>;
      D.38053 = D.38052 & 4;
      if (D.38053 == 0) goto <D.38054>; else goto <D.38055>;
      <D.38054>:
      D.38036 = klass->parent;
      mono_class_init (D.38036);
      <D.38055>:
      D.38036 = klass->parent;
      D.38056 = D.38036->instance_size;
      klass->instance_size = D.38056;
      klass->sizes.class_size = 0;
      D.38036 = klass->parent;
      D.38057 = D.38036->min_align;
      klass->min_align = D.38057;
      D.38058 = klass->has_references;
      D.38059 = (unsigned char) D.38058;
      D.38036 = klass->parent;
      D.38060 = D.38036->has_references;
      D.38061 = (unsigned char) D.38060;
      D.38062 = D.38059 | D.38061;
      D.38063 = (<unnamed-unsigned:1>) D.38062;
      klass->has_references = D.38063;
      goto <D.38064>;
      <D.38051>:
      klass->instance_size = 8;
      klass->min_align = 1;
      <D.38064>:
      typebuilder_setup_fields (klass, &error);
      D.38065 = mono_error_ok (&error);
      if (D.38065 == 0) goto failure; else goto <D.38066>;
      <D.38066>:
      typebuilder_setup_properties (klass, &error);
      D.38067 = mono_error_ok (&error);
      if (D.38067 == 0) goto failure; else goto <D.38068>;
      <D.38068>:
      typebuilder_setup_events (klass, &error);
      D.38069 = mono_error_ok (&error);
      if (D.38069 == 0) goto failure; else goto <D.38070>;
      <D.38070>:
      klass->wastypebuilder = 1;
      D.38071 = domain->type_hash;
      if (D.38071 != 0B) goto <D.38072>; else goto <D.38073>;
      <D.38072>:
      D.38074 = klass->generic_container;
      if (D.38074 != 0B) goto <D.38075>; else goto <D.38076>;
      <D.38075>:
      D.38071 = domain->type_hash;
      mono_g_hash_table_foreach_remove (D.38071, remove_instantiations_of_and_ensure_contents, klass);
      <D.38076>:
      <D.38073>:
      {
        int ret;

        D.38013 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38013);
        if (ret != 0) goto <D.38077>; else goto <D.38078>;
        <D.38077>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38078>:
        D.38079 = ret != 0;
        D.38080 = (long int) D.38079;
        D.38081 = __builtin_expect (D.38080, 0);
        if (D.38081 != 0) goto <D.38082>; else goto <D.38083>;
        <D.38082>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11398, "ret == 0");
        <D.38083>:
      }
      mono_loader_unlock ();
      D.38021 = BIT_FIELD_REF <*klass, 32, 160>;
      D.38037 = D.38021 & 16;
      if (D.38037 != 0) goto <D.38084>; else goto <D.38085>;
      <D.38084>:
      D.38086 = mono_class_is_valid_enum (klass);
      if (D.38086 == 0) goto <D.38087>; else goto <D.38088>;
      <D.38087>:
      mono_class_set_failure (klass, 7, 0B);
      D.38089 = tb->name;
      D.38090 = mono_get_exception_type_load (D.38089, 0B);
      mono_raise_exception (D.38090);
      <D.38088>:
      <D.38085>:
      D.37942 = MEM[(struct MonoObject *)tb].vtable;
      D.38033 = D.37942->domain;
      D.38034 = &klass->byval_arg;
      res = mono_type_get_object (D.38033, D.38034);
      D.38091 = res == tb;
      D.38092 = (long int) D.38091;
      D.38093 = __builtin_expect (D.38092, 0);
      if (D.38093 != 0) goto <D.38094>; else goto <D.38095>;
      <D.38094>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11407, "res != (MonoReflectionType*)tb");
      <D.38095>:
      D.38032 = res;
      return D.38032;
      failure:
      mono_class_set_failure (klass, 7, 0B);
      klass->wastypebuilder = 1;
      {
        int ret;

        D.38013 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38013);
        if (ret != 0) goto <D.38096>; else goto <D.38097>;
        <D.38096>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38097>:
        D.38098 = ret != 0;
        D.38099 = (long int) D.38098;
        D.38100 = __builtin_expect (D.38099, 0);
        if (D.38100 != 0) goto <D.38101>; else goto <D.38102>;
        <D.38101>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11414, "ret == 0");
        <D.38102>:
      }
      mono_loader_unlock ();
      mono_error_raise_exception (&error);
      D.38032 = 0B;
      return D.38032;
    }
  finally
    {
      error = {CLOBBER};
    }
}


remove_instantiations_of_and_ensure_contents (void * key, void * value, void * user_data)
{
  unsigned char D.38106;
  struct MonoGenericClass * D.38108;
  struct MonoClass * D.38109;
  struct MonoClass * D.38111;
  gboolean D.38112;
  struct MonoType * type;
  struct MonoClass * klass;

  type = key;
  klass = user_data;
  D.38106 = type->type;
  if (D.38106 == 21) goto <D.38107>; else goto <D.38105>;
  <D.38107>:
  D.38108 = type->data.generic_class;
  D.38109 = D.38108->container_class;
  if (D.38109 == klass) goto <D.38110>; else goto <D.38105>;
  <D.38110>:
  D.38111 = mono_class_from_mono_type (type);
  fix_partial_generic_class (D.38111);
  D.38112 = 1;
  return D.38112;
  <D.38105>:
  D.38112 = 0;
  return D.38112;
}


fix_partial_generic_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.38114;
  unsigned int D.38115;
  unsigned int D.38116;
  struct MonoClass * D.38119;
  struct MonoClass * D.38120;
  struct MonoType * D.38123;
  struct MonoGenericContext * D.38124;
  int D.38125;
  unsigned int D.38131;
  unsigned int D.38132;
  unsigned int D.38135;
  unsigned int D.38138;
  unsigned int D.38139;
  struct MonoImage * D.38142;
  unsigned int D.38143;
  unsigned int D.38144;
  void * D.38145;
  struct MonoMethod * * D.38146;
  unsigned int i.757;
  unsigned int D.38148;
  struct MonoMethod * * D.38149;
  struct MonoMethod * * D.38150;
  struct MonoMethod * * D.38151;
  struct MonoMethod * D.38152;
  struct MonoGenericContext * D.38153;
  struct MonoMethod * D.38154;
  unsigned int i.758;
  short unsigned int D.38156;
  short unsigned int D.38159;
  unsigned int D.38162;
  unsigned int D.38163;
  void * D.38164;
  struct MonoClass * * D.38165;
  struct MonoClass * * D.38166;
  struct MonoClass * D.38167;
  struct MonoType * D.38168;
  struct MonoGenericContext * D.38169;
  struct MonoClass * * D.38170;
  struct MonoClass * * D.38171;
  struct MonoClass * D.38172;
  struct MonoClass * D.38173;
  int D.38174;
  unsigned int D.38175;
  unsigned int D.38176;
  unsigned int D.38179;
  void * D.38180;
  struct MonoClassField * D.38181;
  unsigned int D.38182;
  struct MonoClassField * D.38183;
  struct MonoClassField * D.38184;
  struct MonoClassField * D.38185;
  struct MonoType * D.38186;
  struct MonoGenericContext * D.38187;
  struct MonoType * D.38188;
  struct MonoClass * gklass;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.38114 = klass->generic_class;
  gklass = D.38114->container_class;
  D.38115 = BIT_FIELD_REF <*klass, 32, 160>;
  D.38116 = D.38115 & 128;
  if (D.38116 != 0) goto <D.38117>; else goto <D.38118>;
  <D.38117>:
  return;
  <D.38118>:
  dgclass = klass->generic_class;
  D.38119 = klass->parent;
  D.38120 = gklass->parent;
  if (D.38119 != D.38120) goto <D.38121>; else goto <D.38122>;
  <D.38121>:
  {
    struct MonoError error;
    struct MonoType * parent_type;

    try
      {
        D.38120 = gklass->parent;
        D.38123 = &D.38120->byval_arg;
        D.38114 = klass->generic_class;
        D.38124 = &D.38114->context;
        parent_type = mono_class_inflate_generic_type_checked (D.38123, D.38124, &error);
        D.38125 = mono_error_ok (&error);
        if (D.38125 != 0) goto <D.38126>; else goto <D.38127>;
        <D.38126>:
        {
          struct MonoClass * parent;

          parent = mono_class_from_mono_type (parent_type);
          mono_metadata_free_type (parent_type);
          D.38119 = klass->parent;
          if (D.38119 != parent) goto <D.38128>; else goto <D.38129>;
          <D.38128>:
          klass->supertypes = 0B;
          mono_class_setup_parent (klass, parent);
          <D.38129>:
        }
        goto <D.38130>;
        <D.38127>:
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        D.38131 = BIT_FIELD_REF <*gklass, 32, 160>;
        D.38132 = D.38131 & 128;
        if (D.38132 != 0) goto <D.38133>; else goto <D.38134>;
        <D.38133>:
        klass->wastypebuilder = 1;
        <D.38134>:
        return;
        <D.38130>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.38122>:
  D.38135 = dgclass->initialized;
  if (D.38135 == 0) goto <D.38136>; else goto <D.38137>;
  <D.38136>:
  return;
  <D.38137>:
  D.38138 = klass->method.count;
  D.38139 = gklass->method.count;
  if (D.38138 != D.38139) goto <D.38140>; else goto <D.38141>;
  <D.38140>:
  D.38139 = gklass->method.count;
  klass->method.count = D.38139;
  D.38142 = klass->image;
  D.38138 = klass->method.count;
  D.38143 = D.38138 + 1;
  D.38144 = D.38143 * 4;
  D.38145 = mono_image_alloc (D.38142, D.38144);
  klass->methods = D.38145;
  i = 0;
  goto <D.23074>;
  <D.23073>:
  D.38146 = klass->methods;
  i.757 = (unsigned int) i;
  D.38148 = i.757 * 4;
  D.38149 = D.38146 + D.38148;
  D.38150 = gklass->methods;
  i.757 = (unsigned int) i;
  D.38148 = i.757 * 4;
  D.38151 = D.38150 + D.38148;
  D.38152 = *D.38151;
  D.38153 = mono_class_get_context (klass);
  D.38154 = mono_class_inflate_generic_method_full (D.38152, klass, D.38153);
  *D.38149 = D.38154;
  i = i + 1;
  <D.23074>:
  i.758 = (unsigned int) i;
  D.38138 = klass->method.count;
  if (i.758 < D.38138) goto <D.23073>; else goto <D.23075>;
  <D.23075>:
  <D.38141>:
  D.38156 = klass->interface_count;
  if (D.38156 != 0) goto <D.38157>; else goto <D.38158>;
  <D.38157>:
  D.38156 = klass->interface_count;
  D.38159 = gklass->interface_count;
  if (D.38156 != D.38159) goto <D.38160>; else goto <D.38161>;
  <D.38160>:
  D.38159 = gklass->interface_count;
  klass->interface_count = D.38159;
  D.38142 = klass->image;
  D.38159 = gklass->interface_count;
  D.38162 = (unsigned int) D.38159;
  D.38163 = D.38162 * 4;
  D.38164 = mono_image_alloc (D.38142, D.38163);
  klass->interfaces = D.38164;
  klass->interfaces_packed = 0B;
  i = 0;
  goto <D.23078>;
  <D.23077>:
  {
    struct MonoType * iface_type;

    D.38165 = gklass->interfaces;
    i.757 = (unsigned int) i;
    D.38148 = i.757 * 4;
    D.38166 = D.38165 + D.38148;
    D.38167 = *D.38166;
    D.38168 = &D.38167->byval_arg;
    D.38169 = mono_class_get_context (klass);
    iface_type = mono_class_inflate_generic_type (D.38168, D.38169);
    D.38170 = klass->interfaces;
    i.757 = (unsigned int) i;
    D.38148 = i.757 * 4;
    D.38171 = D.38170 + D.38148;
    D.38172 = mono_class_from_mono_type (iface_type);
    *D.38171 = D.38172;
    mono_metadata_free_type (iface_type);
    D.38170 = klass->interfaces;
    i.757 = (unsigned int) i;
    D.38148 = i.757 * 4;
    D.38171 = D.38170 + D.38148;
    D.38173 = *D.38171;
    ensure_runtime_vtable (D.38173);
  }
  i = i + 1;
  <D.23078>:
  D.38159 = gklass->interface_count;
  D.38174 = (int) D.38159;
  if (D.38174 > i) goto <D.23077>; else goto <D.23079>;
  <D.23079>:
  klass->interfaces_inited = 1;
  <D.38161>:
  <D.38158>:
  D.38175 = klass->field.count;
  D.38176 = gklass->field.count;
  if (D.38175 != D.38176) goto <D.38177>; else goto <D.38178>;
  <D.38177>:
  D.38176 = gklass->field.count;
  klass->field.count = D.38176;
  D.38142 = klass->image;
  D.38175 = klass->field.count;
  D.38179 = D.38175 * 16;
  D.38180 = image_g_malloc0 (D.38142, D.38179);
  klass->fields = D.38180;
  i = 0;
  goto <D.23081>;
  <D.23080>:
  D.38181 = klass->fields;
  i.757 = (unsigned int) i;
  D.38182 = i.757 * 16;
  D.38183 = D.38181 + D.38182;
  D.38184 = gklass->fields;
  i.757 = (unsigned int) i;
  D.38182 = i.757 * 16;
  D.38185 = D.38184 + D.38182;
  *D.38183 = *D.38185;
  D.38181 = klass->fields;
  i.757 = (unsigned int) i;
  D.38182 = i.757 * 16;
  D.38183 = D.38181 + D.38182;
  D.38183->parent = klass;
  D.38181 = klass->fields;
  i.757 = (unsigned int) i;
  D.38182 = i.757 * 16;
  D.38183 = D.38181 + D.38182;
  D.38184 = gklass->fields;
  i.757 = (unsigned int) i;
  D.38182 = i.757 * 16;
  D.38185 = D.38184 + D.38182;
  D.38186 = D.38185->type;
  D.38187 = mono_class_get_context (klass);
  D.38188 = mono_class_inflate_generic_type (D.38186, D.38187);
  D.38183->type = D.38188;
  i = i + 1;
  <D.23081>:
  i.758 = (unsigned int) i;
  D.38175 = klass->field.count;
  if (i.758 < D.38175) goto <D.23080>; else goto <D.23082>;
  <D.23082>:
  <D.38178>:
  D.38131 = BIT_FIELD_REF <*gklass, 32, 160>;
  D.38132 = D.38131 & 128;
  if (D.38132 != 0) goto <D.38189>; else goto <D.38190>;
  <D.38189>:
  klass->wastypebuilder = 1;
  <D.38190>:
  return;
}


check_array_for_usertypes (struct MonoArray * arr)
{
  unsigned int i.759;
  char * D.38197;
  unsigned int D.38198;
  int i;

  if (arr == 0B) goto <D.38194>; else goto <D.38195>;
  <D.38194>:
  return;
  <D.38195>:
  i = 0;
  goto <D.23234>;
  <D.23233>:
  {
    struct MonoReflectionType * __type;

    i.759 = (unsigned int) i;
    D.38197 = mono_array_addr_with_size (arr, 4, i.759);
    __type = MEM[(struct MonoReflectionType * *)D.38197];
    __type = mono_reflection_type_resolve_user_types (__type);
    {
      struct MonoReflectionType * * __p;

      i.759 = (unsigned int) i;
      __p = mono_array_addr_with_size (arr, 4, i.759);
      *__p = __type;
    }
  }
  i = i + 1;
  <D.23234>:
  i.759 = (unsigned int) i;
  D.38198 = mono_array_length (arr);
  if (i.759 < D.38198) goto <D.23233>; else goto <D.23235>;
  <D.23235>:
}


ensure_runtime_vtable (struct MonoClass * klass)
{
  struct MonoImage * D.38203;
  unsigned int D.38204;
  unsigned int D.38205;
  struct MonoGenericClass * D.38208;
  unsigned int D.38209;
  unsigned int D.38210;
  struct MonoClass * D.38211;
  int iftmp.760;
  struct MonoArray * D.38217;
  unsigned int D.38220;
  int D.38222;
  unsigned int num.761;
  unsigned int num.762;
  unsigned int D.38225;
  void * D.38226;
  int iftmp.763;
  unsigned int D.38230;
  struct MonoMethod * * D.38232;
  unsigned int i.764;
  unsigned int D.38234;
  struct MonoMethod * * D.38235;
  unsigned int i.765;
  char * D.38237;
  struct MonoReflectionCtorBuilder * D.38238;
  struct MonoMethod * D.38239;
  int j.766;
  unsigned int j.767;
  unsigned int D.38242;
  struct MonoMethod * * D.38243;
  struct MonoArray * D.38244;
  char * D.38245;
  struct MonoReflectionMethodBuilder * D.38246;
  struct MonoMethod * D.38247;
  struct MonoArray * D.38248;
  unsigned int D.38251;
  short unsigned int D.38252;
  short unsigned int D.38253;
  unsigned int D.38254;
  unsigned int D.38255;
  void * D.38256;
  char * D.38257;
  void * D.38258;
  struct MonoClass * * D.38259;
  struct MonoClass * * D.38260;
  struct MonoClass * D.38261;
  struct MonoClass * D.38262;
  int D.38263;
  unsigned int D.38267;
  unsigned int D.38268;
  short unsigned int D.38271;
  int D.38272;
  int D.38273;
  int slot_num.768;
  short int D.38277;
  unsigned int i.769;
  unsigned int D.38279;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int num;
  int j;

  tb = mono_class_get_ref_info (klass);
  D.38203 = klass->image;
  D.38204 = BIT_FIELD_REF <*D.38203, 32, 128>;
  D.38205 = D.38204 & 8;
  if (D.38205 == 0) goto <D.38200>; else goto <D.38206>;
  <D.38206>:
  if (tb == 0B) goto <D.38207>; else goto <D.38201>;
  <D.38207>:
  D.38208 = klass->generic_class;
  if (D.38208 == 0B) goto <D.38200>; else goto <D.38201>;
  <D.38201>:
  D.38209 = BIT_FIELD_REF <*klass, 32, 160>;
  D.38210 = D.38209 & 128;
  if (D.38210 != 0) goto <D.38200>; else goto <D.38202>;
  <D.38200>:
  return;
  <D.38202>:
  D.38211 = klass->parent;
  if (D.38211 != 0B) goto <D.38212>; else goto <D.38213>;
  <D.38212>:
  D.38211 = klass->parent;
  ensure_runtime_vtable (D.38211);
  <D.38213>:
  if (tb != 0B) goto <D.38214>; else goto <D.38215>;
  <D.38214>:
  D.38217 = tb->ctors;
  if (D.38217 != 0B) goto <D.38218>; else goto <D.38219>;
  <D.38218>:
  D.38217 = tb->ctors;
  D.38220 = mono_array_length (D.38217);
  iftmp.760 = (int) D.38220;
  goto <D.38221>;
  <D.38219>:
  iftmp.760 = 0;
  <D.38221>:
  num = iftmp.760;
  D.38222 = tb->num_methods;
  num = D.38222 + num;
  num.761 = (unsigned int) num;
  klass->method.count = num.761;
  D.38203 = klass->image;
  num.762 = (unsigned int) num;
  D.38225 = num.762 * 4;
  D.38226 = mono_image_alloc (D.38203, D.38225);
  klass->methods = D.38226;
  D.38217 = tb->ctors;
  if (D.38217 != 0B) goto <D.38228>; else goto <D.38229>;
  <D.38228>:
  D.38217 = tb->ctors;
  D.38230 = mono_array_length (D.38217);
  iftmp.763 = (int) D.38230;
  goto <D.38231>;
  <D.38229>:
  iftmp.763 = 0;
  <D.38231>:
  num = iftmp.763;
  i = 0;
  goto <D.23095>;
  <D.23094>:
  D.38232 = klass->methods;
  i.764 = (unsigned int) i;
  D.38234 = i.764 * 4;
  D.38235 = D.38232 + D.38234;
  D.38217 = tb->ctors;
  i.765 = (unsigned int) i;
  D.38237 = mono_array_addr_with_size (D.38217, 4, i.765);
  D.38238 = MEM[(struct MonoReflectionCtorBuilder * *)D.38237];
  D.38239 = ctorbuilder_to_mono_method (klass, D.38238);
  *D.38235 = D.38239;
  i = i + 1;
  <D.23095>:
  if (i < num) goto <D.23094>; else goto <D.23096>;
  <D.23096>:
  num = tb->num_methods;
  j = i;
  i = 0;
  goto <D.23098>;
  <D.23097>:
  D.38232 = klass->methods;
  j.766 = j;
  j = j.766 + 1;
  j.767 = (unsigned int) j.766;
  D.38242 = j.767 * 4;
  D.38243 = D.38232 + D.38242;
  D.38244 = tb->methods;
  i.765 = (unsigned int) i;
  D.38245 = mono_array_addr_with_size (D.38244, 4, i.765);
  D.38246 = MEM[(struct MonoReflectionMethodBuilder * *)D.38245];
  D.38247 = methodbuilder_to_mono_method (klass, D.38246);
  *D.38243 = D.38247;
  i = i + 1;
  <D.23098>:
  if (i < num) goto <D.23097>; else goto <D.23099>;
  <D.23099>:
  D.38248 = tb->interfaces;
  if (D.38248 != 0B) goto <D.38249>; else goto <D.38250>;
  <D.38249>:
  D.38248 = tb->interfaces;
  D.38251 = mono_array_length (D.38248);
  D.38252 = (short unsigned int) D.38251;
  klass->interface_count = D.38252;
  D.38203 = klass->image;
  D.38253 = klass->interface_count;
  D.38254 = (unsigned int) D.38253;
  D.38255 = D.38254 * 4;
  D.38256 = mono_image_alloc (D.38203, D.38255);
  klass->interfaces = D.38256;
  i = 0;
  goto <D.23102>;
  <D.23101>:
  {
    struct MonoType * iface;

    D.38248 = tb->interfaces;
    i.765 = (unsigned int) i;
    D.38257 = mono_array_addr_with_size (D.38248, 4, i.765);
    D.38258 = MEM[(void * *)D.38257];
    iface = mono_reflection_type_get_handle (D.38258);
    D.38259 = klass->interfaces;
    i.764 = (unsigned int) i;
    D.38234 = i.764 * 4;
    D.38260 = D.38259 + D.38234;
    D.38261 = mono_class_from_mono_type (iface);
    *D.38260 = D.38261;
    D.38259 = klass->interfaces;
    i.764 = (unsigned int) i;
    D.38234 = i.764 * 4;
    D.38260 = D.38259 + D.38234;
    D.38262 = *D.38260;
    ensure_runtime_vtable (D.38262);
  }
  i = i + 1;
  <D.23102>:
  D.38253 = klass->interface_count;
  D.38263 = (int) D.38253;
  if (D.38263 > i) goto <D.23101>; else goto <D.23103>;
  <D.23103>:
  klass->interfaces_inited = 1;
  <D.38250>:
  goto <D.38264>;
  <D.38215>:
  D.38208 = klass->generic_class;
  if (D.38208 != 0B) goto <D.38265>; else goto <D.38266>;
  <D.38265>:
  ensure_generic_class_runtime_vtable (klass);
  <D.38266>:
  <D.38264>:
  D.38267 = klass->flags;
  D.38268 = D.38267 & 32;
  if (D.38268 != 0) goto <D.38269>; else goto <D.38270>;
  <D.38269>:
  {
    int slot_num;

    slot_num = 0;
    i = 0;
    goto <D.23107>;
    <D.23106>:
    {
      struct MonoMethod * im;

      D.38232 = klass->methods;
      i.764 = (unsigned int) i;
      D.38234 = i.764 * 4;
      D.38235 = D.38232 + D.38234;
      im = *D.38235;
      D.38271 = im->flags;
      D.38272 = (int) D.38271;
      D.38273 = D.38272 & 16;
      if (D.38273 == 0) goto <D.38274>; else goto <D.38275>;
      <D.38274>:
      slot_num.768 = slot_num;
      slot_num = slot_num.768 + 1;
      D.38277 = (short int) slot_num.768;
      im->slot = D.38277;
      <D.38275>:
    }
    i = i + 1;
    <D.23107>:
    i.769 = (unsigned int) i;
    D.38279 = klass->method.count;
    if (i.769 < D.38279) goto <D.23106>; else goto <D.23108>;
    <D.23108>:
    klass->interfaces_packed = 0B;
    mono_class_setup_interface_offsets (klass);
    mono_class_setup_interface_id (klass);
  }
  <D.38270>:
}


ensure_generic_class_runtime_vtable (struct MonoClass * klass)
{
  struct MonoGenericClass * D.38281;
  struct MonoClass * gklass;

  D.38281 = klass->generic_class;
  gklass = D.38281->container_class;
  ensure_runtime_vtable (gklass);
  fix_partial_generic_class (klass);
}


typebuilder_setup_fields (struct MonoClass * klass, struct MonoError * error)
{
  int D.38282;
  unsigned int D.38283;
  int D.38284;
  int D.38287;
  unsigned int D.38288;
  unsigned int D.38289;
  const char * D.38292;
  unsigned char D.38293;
  <unnamed-unsigned:4> D.38294;
  int D.38295;
  int D.38296;
  unsigned int D.38297;
  unsigned int D.38300;
  unsigned int D.38301;
  int D.38302;
  unsigned int D.38303;
  void * D.38304;
  struct MonoClassExt * D.38305;
  unsigned int D.38306;
  void * D.38307;
  struct MonoArray * D.38308;
  unsigned int i.770;
  char * D.38310;
  struct MonoClassField * D.38311;
  unsigned int i.771;
  unsigned int D.38313;
  struct MonoString * D.38314;
  char * D.38315;
  int D.38316;
  unsigned int D.38319;
  struct MonoImage * D.38322;
  struct MonoObject * D.38323;
  struct MonoType * D.38324;
  struct MonoType * D.38325;
  struct MonoType * D.38326;
  short unsigned int D.38327;
  struct MonoType * D.38329;
  unsigned int D.38330;
  struct MonoFieldDefaultValue * D.38335;
  unsigned int D.38336;
  struct MonoFieldDefaultValue * D.38337;
  int D.38338;
  struct MonoArray * D.38341;
  unsigned int D.38342;
  unsigned int D.38343;
  short unsigned int D.38346;
  int D.38347;
  int D.38348;
  struct MonoClass * D.38351;
  struct MonoClass * D.38352;
  struct MonoObject * D.38353;
  short unsigned int D.38356;
  MonoTypeEnum * D.38357;
  char * D.38358;
  const char * p2.772;
  int p2.773;
  int p.774;
  int D.38362;
  unsigned int D.38363;
  void * D.38364;
  const char * D.38365;
  unsigned int i.775;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoReflectionFieldBuilder * fb;
  struct MonoClassField * field;
  struct MonoImage * image;
  const char * p;
  const char * p2;
  int i;
  guint32 len;
  guint32 idx;
  guint32 real_size;

  try
    {
      tb = mono_class_get_ref_info (klass);
      image = klass->image;
      real_size = 0;
      D.38282 = tb->num_fields;
      D.38283 = (unsigned int) D.38282;
      klass->field.count = D.38283;
      klass->field.first = 0;
      mono_error_init (error);
      D.38284 = tb->class_size;
      if (D.38284 != 0) goto <D.38285>; else goto <D.38286>;
      <D.38285>:
      D.38287 = tb->packing_size;
      D.38288 = (unsigned int) D.38287;
      D.38289 = D.38288 & 4294967280;
      if (D.38289 != 0) goto <D.38290>; else goto <D.38291>;
      <D.38290>:
      {
        char * err_msg;

        D.38292 = klass->name;
        D.38287 = tb->packing_size;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.38292, D.38287);
        mono_class_set_failure (klass, 7, err_msg);
        return;
      }
      <D.38291>:
      D.38287 = tb->packing_size;
      D.38293 = (unsigned char) D.38287;
      D.38294 = (<unnamed-unsigned:4>) D.38293;
      klass->packing_size = D.38294;
      D.38295 = klass->instance_size;
      D.38284 = tb->class_size;
      D.38296 = D.38295 + D.38284;
      real_size = (guint32) D.38296;
      <D.38286>:
      D.38297 = klass->field.count;
      if (D.38297 == 0) goto <D.38298>; else goto <D.38299>;
      <D.38298>:
      D.38295 = klass->instance_size;
      D.38300 = (unsigned int) D.38295;
      D.38301 = MAX_EXPR <D.38300, real_size>;
      D.38302 = (int) D.38301;
      klass->instance_size = D.38302;
      return;
      <D.38299>:
      D.38297 = klass->field.count;
      D.38303 = D.38297 * 16;
      D.38304 = image_g_malloc0 (image, D.38303);
      klass->fields = D.38304;
      mono_class_alloc_ext (klass);
      D.38305 = klass->ext;
      D.38297 = klass->field.count;
      D.38306 = D.38297 * 8;
      D.38307 = image_g_malloc0 (image, D.38306);
      D.38305->field_def_values = D.38307;
      klass->size_inited = 1;
      i = 0;
      goto <D.23173>;
      <D.23172>:
      {
        struct MonoArray * rva_data;

        D.38308 = tb->fields;
        i.770 = (unsigned int) i;
        D.38310 = mono_array_addr_with_size (D.38308, 4, i.770);
        fb = MEM[(void * *)D.38310];
        D.38311 = klass->fields;
        i.771 = (unsigned int) i;
        D.38313 = i.771 * 16;
        field = D.38311 + D.38313;
        D.38314 = fb->name;
        D.38315 = mono_string_to_utf8_image (image, D.38314, error);
        field->name = D.38315;
        D.38316 = mono_error_ok (error);
        if (D.38316 == 0) goto <D.38317>; else goto <D.38318>;
        <D.38317>:
        return;
        <D.38318>:
        D.38319 = fb->attrs;
        if (D.38319 != 0) goto <D.38320>; else goto <D.38321>;
        <D.38320>:
        D.38322 = klass->image;
        D.38323 = fb->type;
        D.38324 = mono_reflection_type_get_handle (D.38323);
        D.38325 = mono_metadata_type_dup (D.38322, D.38324);
        field->type = D.38325;
        D.38326 = field->type;
        D.38319 = fb->attrs;
        D.38327 = (short unsigned int) D.38319;
        D.38326->attrs = D.38327;
        goto <D.38328>;
        <D.38321>:
        D.38323 = fb->type;
        D.38329 = mono_reflection_type_get_handle (D.38323);
        field->type = D.38329;
        <D.38328>:
        D.38319 = fb->attrs;
        D.38330 = D.38319 & 256;
        if (D.38330 != 0) goto <D.38331>; else goto <D.38332>;
        <D.38331>:
        rva_data = fb->rva_data;
        if (rva_data != 0B) goto <D.38333>; else goto <D.38334>;
        <D.38333>:
        {
          char * base;
          size_t size;
          char * data;

          base = mono_array_addr_with_size (rva_data, 1, 0);
          size = mono_array_length (rva_data);
          D.38322 = klass->image;
          data = mono_image_alloc (D.38322, size);
          memcpy (data, base, size);
          D.38305 = klass->ext;
          D.38335 = D.38305->field_def_values;
          i.771 = (unsigned int) i;
          D.38336 = i.771 * 8;
          D.38337 = D.38335 + D.38336;
          D.38337->data = data;
        }
        <D.38334>:
        <D.38332>:
        D.38338 = fb->offset;
        if (D.38338 != -1) goto <D.38339>; else goto <D.38340>;
        <D.38339>:
        D.38338 = fb->offset;
        field->offset = D.38338;
        <D.38340>:
        field->parent = klass;
        fb->handle = field;
        D.38322 = klass->image;
        D.38341 = fb->cattrs;
        mono_save_custom_attrs (D.38322, field, D.38341);
        D.38342 = BIT_FIELD_REF <*klass, 32, 160>;
        D.38343 = D.38342 & 16;
        if (D.38343 != 0) goto <D.38344>; else goto <D.38345>;
        <D.38344>:
        D.38326 = field->type;
        D.38346 = D.38326->attrs;
        D.38347 = (int) D.38346;
        D.38348 = D.38347 & 16;
        if (D.38348 == 0) goto <D.38349>; else goto <D.38350>;
        <D.38349>:
        D.38326 = field->type;
        D.38351 = mono_class_from_mono_type (D.38326);
        klass->element_class = D.38351;
        D.38352 = klass->element_class;
        klass->cast_class = D.38352;
        <D.38350>:
        <D.38345>:
        D.38353 = fb->def_value;
        if (D.38353 != 0B) goto <D.38354>; else goto <D.38355>;
        <D.38354>:
        {
          struct MonoDynamicImage * assembly;

          assembly = klass->image;
          D.38326 = field->type;
          D.38326 = field->type;
          D.38346 = D.38326->attrs;
          D.38356 = D.38346 | 32768;
          D.38326->attrs = D.38356;
          D.38353 = fb->def_value;
          D.38305 = klass->ext;
          D.38335 = D.38305->field_def_values;
          i.771 = (unsigned int) i;
          D.38336 = i.771 * 8;
          D.38337 = D.38335 + D.38336;
          D.38357 = &D.38337->def_type;
          idx = encode_constant (assembly, D.38353, D.38357);
          D.38358 = assembly->blob.data;
          p = D.38358 + idx;
          len = mono_metadata_decode_blob_size (p, &p2);
          p2.772 = p2;
          p2.773 = (int) p2.772;
          p.774 = (int) p;
          D.38362 = p2.773 - p.774;
          D.38363 = (unsigned int) D.38362;
          len = D.38363 + len;
          D.38305 = klass->ext;
          D.38335 = D.38305->field_def_values;
          i.771 = (unsigned int) i;
          D.38336 = i.771 * 8;
          D.38337 = D.38335 + D.38336;
          D.38364 = mono_image_alloc (image, len);
          D.38337->data = D.38364;
          D.38305 = klass->ext;
          D.38335 = D.38305->field_def_values;
          i.771 = (unsigned int) i;
          D.38336 = i.771 * 8;
          D.38337 = D.38335 + D.38336;
          D.38365 = D.38337->data;
          memcpy (D.38365, p, len);
        }
        <D.38355>:
      }
      i = i + 1;
      <D.23173>:
      i.775 = (unsigned int) i;
      D.38297 = klass->field.count;
      if (i.775 < D.38297) goto <D.23172>; else goto <D.23174>;
      <D.23174>:
      D.38295 = klass->instance_size;
      D.38300 = (unsigned int) D.38295;
      D.38301 = MAX_EXPR <D.38300, real_size>;
      D.38302 = (int) D.38301;
      klass->instance_size = D.38302;
      mono_class_layout_fields (klass);
    }
  finally
    {
      p2 = {CLOBBER};
    }
}


typebuilder_setup_properties (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.38370;
  void * D.38373;
  uintptr_t iftmp.776;
  struct MonoArray * D.38375;
  unsigned int D.38379;
  unsigned int D.38380;
  unsigned int i.777;
  char * D.38382;
  unsigned int i.778;
  unsigned int D.38384;
  struct MonoProperty * D.38385;
  unsigned int D.38386;
  struct MonoString * D.38387;
  char * D.38388;
  int D.38389;
  struct MonoReflectionMethodBuilder * D.38392;
  struct MonoMethod * D.38395;
  struct MonoReflectionMethodBuilder * D.38396;
  struct MonoMethod * D.38399;
  struct MonoImage * D.38400;
  void * D.38401;
  struct MonoArray * D.38402;
  struct MonoObject * D.38403;
  struct MonoFieldDefaultValue * D.38406;
  unsigned int D.38409;
  void * D.38410;
  unsigned int D.38411;
  unsigned int D.38412;
  unsigned int D.38413;
  struct MonoFieldDefaultValue * D.38414;
  MonoTypeEnum * D.38415;
  char * D.38416;
  const char * p2.779;
  int p2.780;
  int p.781;
  int D.38420;
  unsigned int D.38421;
  void * D.38422;
  const char * D.38423;
  unsigned int i.782;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoReflectionPropertyBuilder * pb;
  struct MonoImage * image;
  struct MonoProperty * properties;
  int i;

  tb = mono_class_get_ref_info (klass);
  image = klass->image;
  mono_error_init (error);
  D.38370 = klass->ext;
  if (D.38370 == 0B) goto <D.38371>; else goto <D.38372>;
  <D.38371>:
  D.38373 = image_g_malloc0 (image, 40);
  klass->ext = D.38373;
  <D.38372>:
  D.38370 = klass->ext;
  D.38375 = tb->properties;
  if (D.38375 != 0B) goto <D.38376>; else goto <D.38377>;
  <D.38376>:
  D.38375 = tb->properties;
  iftmp.776 = mono_array_length (D.38375);
  goto <D.38378>;
  <D.38377>:
  iftmp.776 = 0;
  <D.38378>:
  D.38370->property.count = iftmp.776;
  D.38370 = klass->ext;
  D.38370->property.first = 0;
  D.38370 = klass->ext;
  D.38379 = D.38370->property.count;
  D.38380 = D.38379 * 20;
  properties = image_g_malloc0 (image, D.38380);
  D.38370 = klass->ext;
  D.38370->properties = properties;
  i = 0;
  goto <D.23190>;
  <D.23189>:
  D.38375 = tb->properties;
  i.777 = (unsigned int) i;
  D.38382 = mono_array_addr_with_size (D.38375, 4, i.777);
  pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.38382];
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38385 = properties + D.38384;
  D.38385->parent = klass;
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38385 = properties + D.38384;
  D.38386 = pb->attrs;
  D.38385->attrs = D.38386;
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38385 = properties + D.38384;
  D.38387 = pb->name;
  D.38388 = mono_string_to_utf8_image (image, D.38387, error);
  D.38385->name = D.38388;
  D.38389 = mono_error_ok (error);
  if (D.38389 == 0) goto <D.38390>; else goto <D.38391>;
  <D.38390>:
  return;
  <D.38391>:
  D.38392 = pb->get_method;
  if (D.38392 != 0B) goto <D.38393>; else goto <D.38394>;
  <D.38393>:
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38385 = properties + D.38384;
  D.38392 = pb->get_method;
  D.38395 = D.38392->mhandle;
  D.38385->get = D.38395;
  <D.38394>:
  D.38396 = pb->set_method;
  if (D.38396 != 0B) goto <D.38397>; else goto <D.38398>;
  <D.38397>:
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38385 = properties + D.38384;
  D.38396 = pb->set_method;
  D.38399 = D.38396->mhandle;
  D.38385->set = D.38399;
  <D.38398>:
  D.38400 = klass->image;
  i.778 = (unsigned int) i;
  D.38384 = i.778 * 20;
  D.38401 = properties + D.38384;
  D.38402 = pb->cattrs;
  mono_save_custom_attrs (D.38400, D.38401, D.38402);
  D.38403 = pb->def_value;
  if (D.38403 != 0B) goto <D.38404>; else goto <D.38405>;
  <D.38404>:
  {
    guint32 len;
    guint32 idx;
    const char * p;
    const char * p2;
    struct MonoDynamicImage * assembly;

    try
      {
        assembly = klass->image;
        D.38370 = klass->ext;
        D.38406 = D.38370->prop_def_values;
        if (D.38406 == 0B) goto <D.38407>; else goto <D.38408>;
        <D.38407>:
        D.38370 = klass->ext;
        D.38370 = klass->ext;
        D.38379 = D.38370->property.count;
        D.38409 = D.38379 * 8;
        D.38410 = image_g_malloc0 (image, D.38409);
        D.38370->prop_def_values = D.38410;
        <D.38408>:
        i.778 = (unsigned int) i;
        D.38384 = i.778 * 20;
        D.38385 = properties + D.38384;
        i.778 = (unsigned int) i;
        D.38384 = i.778 * 20;
        D.38385 = properties + D.38384;
        D.38411 = D.38385->attrs;
        D.38412 = D.38411 | 4096;
        D.38385->attrs = D.38412;
        D.38403 = pb->def_value;
        D.38370 = klass->ext;
        D.38406 = D.38370->prop_def_values;
        i.778 = (unsigned int) i;
        D.38413 = i.778 * 8;
        D.38414 = D.38406 + D.38413;
        D.38415 = &D.38414->def_type;
        idx = encode_constant (assembly, D.38403, D.38415);
        D.38416 = assembly->blob.data;
        p = D.38416 + idx;
        len = mono_metadata_decode_blob_size (p, &p2);
        p2.779 = p2;
        p2.780 = (int) p2.779;
        p.781 = (int) p;
        D.38420 = p2.780 - p.781;
        D.38421 = (unsigned int) D.38420;
        len = D.38421 + len;
        D.38370 = klass->ext;
        D.38406 = D.38370->prop_def_values;
        i.778 = (unsigned int) i;
        D.38413 = i.778 * 8;
        D.38414 = D.38406 + D.38413;
        D.38422 = mono_image_alloc (image, len);
        D.38414->data = D.38422;
        D.38370 = klass->ext;
        D.38406 = D.38370->prop_def_values;
        i.778 = (unsigned int) i;
        D.38413 = i.778 * 8;
        D.38414 = D.38406 + D.38413;
        D.38423 = D.38414->data;
        memcpy (D.38423, p, len);
      }
    finally
      {
        p2 = {CLOBBER};
      }
  }
  <D.38405>:
  i = i + 1;
  <D.23190>:
  i.782 = (unsigned int) i;
  D.38370 = klass->ext;
  D.38379 = D.38370->property.count;
  if (i.782 < D.38379) goto <D.23189>; else goto <D.23191>;
  <D.23191>:
}


typebuilder_setup_events (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.38426;
  void * D.38429;
  uintptr_t iftmp.783;
  struct MonoArray * D.38431;
  unsigned int D.38435;
  unsigned int D.38436;
  unsigned int i.784;
  char * D.38438;
  unsigned int i.785;
  unsigned int D.38440;
  struct MonoEvent * D.38441;
  unsigned int D.38442;
  struct MonoString * D.38443;
  char * D.38444;
  int D.38445;
  struct MonoReflectionMethodBuilder * D.38448;
  struct MonoMethod * D.38451;
  struct MonoReflectionMethodBuilder * D.38452;
  struct MonoMethod * D.38455;
  struct MonoReflectionMethodBuilder * D.38456;
  struct MonoMethod * D.38459;
  struct MonoArray * D.38460;
  unsigned int D.38463;
  unsigned int D.38464;
  unsigned int D.38465;
  void * D.38466;
  unsigned int j.786;
  char * D.38468;
  struct MonoMethod * * D.38469;
  unsigned int j.787;
  unsigned int D.38471;
  struct MonoMethod * * D.38472;
  struct MonoMethod * D.38473;
  unsigned int D.38474;
  struct MonoImage * D.38475;
  void * D.38476;
  struct MonoArray * D.38477;
  unsigned int i.788;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoReflectionEventBuilder * eb;
  struct MonoImage * image;
  struct MonoEvent * events;
  int i;

  tb = mono_class_get_ref_info (klass);
  image = klass->image;
  mono_error_init (error);
  D.38426 = klass->ext;
  if (D.38426 == 0B) goto <D.38427>; else goto <D.38428>;
  <D.38427>:
  D.38429 = image_g_malloc0 (image, 40);
  klass->ext = D.38429;
  <D.38428>:
  D.38426 = klass->ext;
  D.38431 = tb->events;
  if (D.38431 != 0B) goto <D.38432>; else goto <D.38433>;
  <D.38432>:
  D.38431 = tb->events;
  iftmp.783 = mono_array_length (D.38431);
  goto <D.38434>;
  <D.38433>:
  iftmp.783 = 0;
  <D.38434>:
  D.38426->event.count = iftmp.783;
  D.38426 = klass->ext;
  D.38426->event.first = 0;
  D.38426 = klass->ext;
  D.38435 = D.38426->event.count;
  D.38436 = D.38435 * 28;
  events = image_g_malloc0 (image, D.38436);
  D.38426 = klass->ext;
  D.38426->events = events;
  i = 0;
  goto <D.23218>;
  <D.23217>:
  D.38431 = tb->events;
  i.784 = (unsigned int) i;
  D.38438 = mono_array_addr_with_size (D.38431, 4, i.784);
  eb = MEM[(struct MonoReflectionEventBuilder * *)D.38438];
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38441->parent = klass;
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38442 = eb->attrs;
  D.38441->attrs = D.38442;
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38443 = eb->name;
  D.38444 = mono_string_to_utf8_image (image, D.38443, error);
  D.38441->name = D.38444;
  D.38445 = mono_error_ok (error);
  if (D.38445 == 0) goto <D.38446>; else goto <D.38447>;
  <D.38446>:
  return;
  <D.38447>:
  D.38448 = eb->add_method;
  if (D.38448 != 0B) goto <D.38449>; else goto <D.38450>;
  <D.38449>:
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38448 = eb->add_method;
  D.38451 = D.38448->mhandle;
  D.38441->add = D.38451;
  <D.38450>:
  D.38452 = eb->remove_method;
  if (D.38452 != 0B) goto <D.38453>; else goto <D.38454>;
  <D.38453>:
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38452 = eb->remove_method;
  D.38455 = D.38452->mhandle;
  D.38441->remove = D.38455;
  <D.38454>:
  D.38456 = eb->raise_method;
  if (D.38456 != 0B) goto <D.38457>; else goto <D.38458>;
  <D.38457>:
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38441 = events + D.38440;
  D.38456 = eb->raise_method;
  D.38459 = D.38456->mhandle;
  D.38441->raise = D.38459;
  <D.38458>:
  D.38460 = eb->other_methods;
  if (D.38460 != 0B) goto <D.38461>; else goto <D.38462>;
  <D.38461>:
  {
    int j;

    i.785 = (unsigned int) i;
    D.38440 = i.785 * 28;
    D.38441 = events + D.38440;
    D.38460 = eb->other_methods;
    D.38463 = mono_array_length (D.38460);
    D.38464 = D.38463 + 1;
    D.38465 = D.38464 * 4;
    D.38466 = image_g_malloc0 (image, D.38465);
    D.38441->other = D.38466;
    j = 0;
    goto <D.23215>;
    <D.23214>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.38460 = eb->other_methods;
      j.786 = (unsigned int) j;
      D.38468 = mono_array_addr_with_size (D.38460, 4, j.786);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38468];
      i.785 = (unsigned int) i;
      D.38440 = i.785 * 28;
      D.38441 = events + D.38440;
      D.38469 = D.38441->other;
      j.787 = (unsigned int) j;
      D.38471 = j.787 * 4;
      D.38472 = D.38469 + D.38471;
      D.38473 = mb->mhandle;
      *D.38472 = D.38473;
    }
    j = j + 1;
    <D.23215>:
    j.786 = (unsigned int) j;
    D.38460 = eb->other_methods;
    D.38474 = mono_array_length (D.38460);
    if (j.786 < D.38474) goto <D.23214>; else goto <D.23216>;
    <D.23216>:
  }
  <D.38462>:
  D.38475 = klass->image;
  i.785 = (unsigned int) i;
  D.38440 = i.785 * 28;
  D.38476 = events + D.38440;
  D.38477 = eb->cattrs;
  mono_save_custom_attrs (D.38475, D.38476, D.38477);
  i = i + 1;
  <D.23218>:
  i.788 = (unsigned int) i;
  D.38426 = klass->ext;
  D.38435 = D.38426->event.count;
  if (i.788 < D.38435) goto <D.23217>; else goto <D.23219>;
  <D.23219>:
}


mono_reflection_initialize_generic_parameter (struct MonoReflectionGenericParam * gparam)
{
  struct MonoReflectionTypeBuilder * D.38480;
  struct MonoReflectionModuleBuilder * D.38481;
  struct MonoDynamicImage * D.38482;
  struct MonoString * D.38483;
  char * D.38484;
  int D.38485;
  _Bool D.38486;
  long int D.38487;
  long int D.38488;
  unsigned int D.38491;
  short unsigned int D.38492;
  struct MonoReflectionMethodBuilder * D.38493;
  struct MonoGenericContainer * D.38496;
  struct MonoType * D.38499;
  struct MonoImage * D.38500;
  void * D.38501;
  struct MonoGenericContainer * D.38505;
  struct MonoType * D.38508;
  struct MonoImage * D.38509;
  void * D.38510;
  _Bool D.38511;
  int D.38512;
  struct MonoType * D.38513;
  struct MonoGenericParamFull * param;
  struct MonoImage * image;
  struct MonoClass * pklass;
  struct MonoError error;

  try
    {
      D.38480 = gparam->tbuilder;
      D.38481 = D.38480->module;
      D.38482 = D.38481->dynamic_image;
      image = &D.38482->image;
      param = mono_image_alloc0 (image, 32);
      D.38483 = gparam->name;
      D.38484 = mono_string_to_utf8_image (image, D.38483, &error);
      param->info.name = D.38484;
      D.38485 = mono_error_ok (&error);
      D.38486 = D.38485 == 0;
      D.38487 = (long int) D.38486;
      D.38488 = __builtin_expect (D.38487, 0);
      if (D.38488 != 0) goto <D.38489>; else goto <D.38490>;
      <D.38489>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11435, "mono_error_ok (&error)");
      <D.38490>:
      D.38491 = gparam->index;
      D.38492 = (short unsigned int) D.38491;
      param->param.num = D.38492;
      D.38493 = gparam->mbuilder;
      if (D.38493 != 0B) goto <D.38494>; else goto <D.38495>;
      <D.38494>:
      D.38493 = gparam->mbuilder;
      D.38496 = D.38493->generic_container;
      if (D.38496 == 0B) goto <D.38497>; else goto <D.38498>;
      <D.38497>:
      {
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        D.38493 = gparam->mbuilder;
        tb = D.38493->type;
        D.38499 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.38499);
        D.38493 = gparam->mbuilder;
        D.38500 = klass->image;
        D.38501 = mono_image_alloc0 (D.38500, 28);
        D.38493->generic_container = D.38501;
        D.38493 = gparam->mbuilder;
        D.38496 = D.38493->generic_container;
        D.38496->is_method = -1;
        D.38493 = gparam->mbuilder;
        D.38496 = D.38493->generic_container;
        D.38500 = klass->image;
        D.38496->image = D.38500;
      }
      <D.38498>:
      D.38493 = gparam->mbuilder;
      D.38496 = D.38493->generic_container;
      param->param.owner = D.38496;
      goto <D.38502>;
      <D.38495>:
      D.38480 = gparam->tbuilder;
      if (D.38480 != 0B) goto <D.38503>; else goto <D.38504>;
      <D.38503>:
      D.38480 = gparam->tbuilder;
      D.38505 = D.38480->generic_container;
      if (D.38505 == 0B) goto <D.38506>; else goto <D.38507>;
      <D.38506>:
      {
        struct MonoClass * klass;

        D.38480 = gparam->tbuilder;
        D.38508 = mono_reflection_type_get_handle (D.38480);
        klass = mono_class_from_mono_type (D.38508);
        D.38480 = gparam->tbuilder;
        D.38509 = klass->image;
        D.38510 = mono_image_alloc0 (D.38509, 28);
        D.38480->generic_container = D.38510;
        D.38480 = gparam->tbuilder;
        D.38505 = D.38480->generic_container;
        D.38505->owner.klass = klass;
      }
      <D.38507>:
      D.38480 = gparam->tbuilder;
      D.38505 = D.38480->generic_container;
      param->param.owner = D.38505;
      <D.38504>:
      <D.38502>:
      D.38493 = gparam->mbuilder;
      D.38511 = D.38493 != 0B;
      D.38512 = (int) D.38511;
      pklass = mono_class_from_generic_parameter (param, image, D.38512);
      D.38513 = &pklass->byval_arg;
      gparam->type.type = D.38513;
      mono_class_set_ref_info (pklass, gparam);
      mono_image_append_class_to_reflection_info_set (pklass);
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_sighelper_get_signature_local (struct MonoReflectionSigHelper * sig)
{
  struct MonoDynamicImage * iftmp.789;
  uintptr_t iftmp.790;
  struct MonoArray * D.38519;
  char * D.38525;
  char * D.38526;
  int D.38527;
  char * D.38528;
  int D.38529;
  int D.38530;
  struct MonoDomain * D.38531;
  struct MonoClass * D.38532;
  char * D.38533;
  struct MonoArray * D.38534;
  struct MonoReflectionModuleBuilder * module;
  struct MonoDynamicImage * assembly;
  guint32 na;
  guint32 buflen;
  guint32 i;
  struct MonoArray * result;
  struct SigBuffer buf;

  try
    {
      module = sig->module;
      if (module != 0B) goto <D.38515>; else goto <D.38516>;
      <D.38515>:
      iftmp.789 = module->dynamic_image;
      goto <D.38517>;
      <D.38516>:
      iftmp.789 = 0B;
      <D.38517>:
      assembly = iftmp.789;
      D.38519 = sig->arguments;
      if (D.38519 != 0B) goto <D.38520>; else goto <D.38521>;
      <D.38520>:
      D.38519 = sig->arguments;
      iftmp.790 = mono_array_length (D.38519);
      goto <D.38522>;
      <D.38521>:
      iftmp.790 = 0;
      <D.38522>:
      na = iftmp.790;
      D.38519 = sig->arguments;
      check_array_for_usertypes (D.38519);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, na);
      if (assembly != 0B) goto <D.38523>; else goto <D.38524>;
      <D.38523>:
      i = 0;
      goto <D.23300>;
      <D.23299>:
      {
        struct MonoReflectionType * type;

        D.38519 = sig->arguments;
        D.38525 = mono_array_addr_with_size (D.38519, 4, i);
        type = MEM[(struct MonoReflectionType * *)D.38525];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23300>:
      if (i < na) goto <D.23299>; else goto <D.23301>;
      <D.23301>:
      <D.38524>:
      D.38526 = buf.p;
      D.38527 = (int) D.38526;
      D.38528 = buf.buf;
      D.38529 = (int) D.38528;
      D.38530 = D.38527 - D.38529;
      buflen = (guint32) D.38530;
      D.38531 = mono_domain_get ();
      D.38532 = mono_defaults.byte_class;
      result = mono_array_new (D.38531, D.38532, buflen);
      D.38533 = mono_array_addr_with_size (result, 1, 0);
      D.38528 = buf.buf;
      memcpy (D.38533, D.38528, buflen);
      sigbuffer_free (&buf);
      D.38534 = result;
      return D.38534;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_sighelper_get_signature_field (struct MonoReflectionSigHelper * sig)
{
  struct MonoReflectionModuleBuilder * D.38537;
  uintptr_t iftmp.791;
  struct MonoArray * D.38539;
  char * D.38543;
  char * D.38544;
  int D.38545;
  char * D.38546;
  int D.38547;
  int D.38548;
  struct MonoDomain * D.38549;
  struct MonoClass * D.38550;
  char * D.38551;
  struct MonoArray * D.38552;
  struct MonoDynamicImage * assembly;
  guint32 na;
  guint32 buflen;
  guint32 i;
  struct MonoArray * result;
  struct SigBuffer buf;

  try
    {
      D.38537 = sig->module;
      assembly = D.38537->dynamic_image;
      D.38539 = sig->arguments;
      if (D.38539 != 0B) goto <D.38540>; else goto <D.38541>;
      <D.38540>:
      D.38539 = sig->arguments;
      iftmp.791 = mono_array_length (D.38539);
      goto <D.38542>;
      <D.38541>:
      iftmp.791 = 0;
      <D.38542>:
      na = iftmp.791;
      D.38539 = sig->arguments;
      check_array_for_usertypes (D.38539);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      i = 0;
      goto <D.23313>;
      <D.23312>:
      {
        struct MonoReflectionType * type;

        D.38539 = sig->arguments;
        D.38543 = mono_array_addr_with_size (D.38539, 4, i);
        type = MEM[(struct MonoReflectionType * *)D.38543];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23313>:
      if (i < na) goto <D.23312>; else goto <D.23314>;
      <D.23314>:
      D.38544 = buf.p;
      D.38545 = (int) D.38544;
      D.38546 = buf.buf;
      D.38547 = (int) D.38546;
      D.38548 = D.38545 - D.38547;
      buflen = (guint32) D.38548;
      D.38549 = mono_domain_get ();
      D.38550 = mono_defaults.byte_class;
      result = mono_array_new (D.38549, D.38550, buflen);
      D.38551 = mono_array_addr_with_size (result, 1, 0);
      D.38546 = buf.buf;
      memcpy (D.38551, D.38546, buflen);
      sigbuffer_free (&buf);
      D.38552 = result;
      return D.38552;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_create_dynamic_method (struct MonoReflectionDynamicMethod * mb)
{
  int D.38555;
  struct MonoException * D.38558;
  struct MonoReferenceQueue * dynamic_method_queue.792;
  int D.38564;
  unsigned int D.38565;
  int D.38566;
  unsigned int D.38567;
  unsigned int D.38568;
  void * D.38569;
  struct MonoArray * D.38570;
  unsigned int i.793;
  char * D.38572;
  int D.23346;
  int iftmp.794;
  int D.23345;
  struct MonoVTable * D.38576;
  struct MonoClass * D.38577;
  const char[14] * D.38578;
  unsigned char D.38579;
  int D.38580;
  unsigned char D.38581;
  int D.38582;
  const unsigned char * D.38587;
  unsigned char D.38588;
  int D.38589;
  const unsigned char * D.38590;
  unsigned char D.38591;
  int D.38592;
  const unsigned char * D.38597;
  unsigned char D.38598;
  int D.38599;
  const unsigned char * D.38600;
  unsigned char D.38601;
  int D.38602;
  const unsigned char * D.38607;
  unsigned char D.38608;
  int D.38609;
  const unsigned char * D.38610;
  unsigned char D.38611;
  int D.38612;
  const char * D.38614;
  struct MonoMethod * D.38617;
  struct GSList * D.38621;
  struct GSList * D.38622;
  struct MonoClass * handle_class.795;
  struct MonoReflectionModule * D.38625;
  struct MonoImage * D.38626;
  <unnamed type> D.38630;
  struct MonoClass * handle_class.796;
  void * * D.38636;
  unsigned int i.797;
  unsigned int D.38638;
  void * * D.38639;
  sizetype i.798;
  sizetype D.38641;
  sizetype D.38642;
  void * * D.38643;
  struct MonoClass * iftmp.799;
  struct MonoReflectionType * D.38645;
  struct MonoType * D.38648;
  struct MonoDomain * D.38650;
  int D.38651;
  struct MonoMethod * D.38654;
  _Bool D.38655;
  long int D.38656;
  long int D.38657;
  void * * D.38660;
  void * D.38661;
  sizetype D.38664;
  sizetype D.38665;
  void * * D.38666;
  void * D.38667;
  struct MonoMethod * D.38670;
  void * D.38671;
  unsigned int D.38672;
  struct GSList * D.38673;
  struct MonoReferenceQueue * queue;
  struct MonoMethod * handle;
  struct DynamicMethodReleaseData * release_data;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;
  struct MonoClass * klass;
  struct GSList * l;
  int i;

  try
    {
      D.38555 = mono_runtime_is_shutting_down ();
      if (D.38555 != 0) goto <D.38556>; else goto <D.38557>;
      <D.38556>:
      D.38558 = mono_get_exception_invalid_operation ("");
      mono_raise_exception (D.38558);
      <D.38557>:
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.38559>; else goto <D.38560>;
      <D.38559>:
      mono_loader_lock ();
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.38561>; else goto <D.38562>;
      <D.38561>:
      dynamic_method_queue.792 = mono_gc_reference_queue_new (free_dynamic_method);
      dynamic_method_queue = dynamic_method_queue.792;
      queue = dynamic_method_queue;
      <D.38562>:
      mono_loader_unlock ();
      <D.38560>:
      sig = dynamic_method_to_signature (mb);
      reflection_methodbuilder_from_dynamic_method (&rmb, mb);
      D.38564 = mb->nrefs;
      D.38565 = (unsigned int) D.38564;
      rmb.nrefs = D.38565;
      D.38564 = mb->nrefs;
      D.38566 = D.38564 + 1;
      D.38567 = (unsigned int) D.38566;
      D.38568 = D.38567 * 4;
      D.38569 = monoeg_malloc0 (D.38568);
      rmb.refs = D.38569;
      i = 0;
      goto <D.23350>;
      <D.23349>:
      {
        struct MonoClass * handle_class;
        void * ref;
        struct MonoObject * obj;

        try
          {
            D.38570 = mb->refs;
            i.793 = (unsigned int) i;
            D.38572 = mono_array_addr_with_size (D.38570, 4, i.793);
            obj = MEM[(struct MonoObject * *)D.38572];
            {
              size_t __s1_len;
              size_t __s2_len;

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

                D.38576 = obj->vtable;
                D.38577 = D.38576->klass;
                __s2 = D.38577->name;
                D.38578 = "DynamicMethod";
                D.38579 = MEM[(const unsigned char *)D.38578];
                D.38580 = (int) D.38579;
                D.38581 = *__s2;
                D.38582 = (int) D.38581;
                __result = D.38580 - D.38582;
                {
                  if (__s2_len != 0) goto <D.38583>; else goto <D.38584>;
                  <D.38583>:
                  if (__result == 0) goto <D.38585>; else goto <D.38586>;
                  <D.38585>:
                  D.38587 = &MEM[(void *)"DynamicMethod" + 1B];
                  D.38588 = *D.38587;
                  D.38589 = (int) D.38588;
                  D.38590 = __s2 + 1;
                  D.38591 = *D.38590;
                  D.38592 = (int) D.38591;
                  __result = D.38589 - D.38592;
                  if (__s2_len > 1) goto <D.38593>; else goto <D.38594>;
                  <D.38593>:
                  if (__result == 0) goto <D.38595>; else goto <D.38596>;
                  <D.38595>:
                  D.38597 = &MEM[(void *)"DynamicMethod" + 2B];
                  D.38598 = *D.38597;
                  D.38599 = (int) D.38598;
                  D.38600 = __s2 + 2;
                  D.38601 = *D.38600;
                  D.38602 = (int) D.38601;
                  __result = D.38599 - D.38602;
                  if (__s2_len > 2) goto <D.38603>; else goto <D.38604>;
                  <D.38603>:
                  if (__result == 0) goto <D.38605>; else goto <D.38606>;
                  <D.38605>:
                  D.38607 = &MEM[(void *)"DynamicMethod" + 3B];
                  D.38608 = *D.38607;
                  D.38609 = (int) D.38608;
                  D.38610 = __s2 + 3;
                  D.38611 = *D.38610;
                  D.38612 = (int) D.38611;
                  __result = D.38609 - D.38612;
                  <D.38606>:
                  <D.38604>:
                  <D.38596>:
                  <D.38594>:
                  <D.38586>:
                  <D.38584>:
                }
                D.23345 = __result;
              }
              iftmp.794 = -D.23345;
              goto <D.38613>;
              <D.38575>:
              D.38576 = obj->vtable;
              D.38577 = D.38576->klass;
              D.38614 = D.38577->name;
              iftmp.794 = __builtin_strcmp (D.38614, "DynamicMethod");
              <D.38613>:
              D.23346 = iftmp.794;
            }
            if (D.23346 == 0) goto <D.38615>; else goto <D.38616>;
            <D.38615>:
            {
              struct MonoReflectionDynamicMethod * method;

              method = obj;
              D.38617 = method->mhandle;
              if (D.38617 != 0B) goto <D.38618>; else goto <D.38619>;
              <D.38618>:
              ref = method->mhandle;
              goto <D.38620>;
              <D.38619>:
              ref = method;
              D.38621 = method->referenced_by;
              D.38622 = monoeg_g_slist_append (D.38621, mb);
              method->referenced_by = D.38622;
              <D.38620>:
              handle_class.795 = mono_defaults.methodhandle_class;
              handle_class = handle_class.795;
            }
            goto <D.38624>;
            <D.38616>:
            {
              struct MonoException * ex;

              ex = 0B;
              D.38625 = mb->module;
              D.38626 = D.38625->image;
              ref = resolve_object (D.38626, obj, &handle_class, 0B);
              if (ref == 0B) goto <D.38627>; else goto <D.38628>;
              <D.38627>:
              ex = mono_get_exception_type_load (0B, 0B);
              goto <D.38629>;
              <D.38628>:
              D.38630 = mono_security_get_mode ();
              if (D.38630 == 1) goto <D.38631>; else goto <D.38632>;
              <D.38631>:
              handle_class.796 = handle_class;
              ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class.796);
              <D.38632>:
              <D.38629>:
              if (ex != 0B) goto <D.38634>; else goto <D.38635>;
              <D.38634>:
              D.38636 = rmb.refs;
              monoeg_g_free (D.38636);
              mono_raise_exception (ex);
              return;
              <D.38635>:
            }
            <D.38624>:
            D.38636 = rmb.refs;
            i.797 = (unsigned int) i;
            D.38638 = i.797 * 4;
            D.38639 = D.38636 + D.38638;
            *D.38639 = ref;
            D.38636 = rmb.refs;
            i.798 = (sizetype) i;
            D.38641 = i.798 + 1;
            D.38642 = D.38641 * 4;
            D.38643 = D.38636 + D.38642;
            handle_class.796 = handle_class;
            *D.38643 = handle_class.796;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      i = i + 2;
      <D.23350>:
      D.38564 = mb->nrefs;
      if (D.38564 > i) goto <D.23349>; else goto <D.23351>;
      <D.23351>:
      D.38645 = mb->owner;
      if (D.38645 != 0B) goto <D.38646>; else goto <D.38647>;
      <D.38646>:
      D.38645 = mb->owner;
      D.38648 = mono_reflection_type_get_handle (D.38645);
      iftmp.799 = mono_class_from_mono_type (D.38648);
      goto <D.38649>;
      <D.38647>:
      iftmp.799 = mono_defaults.object_class;
      <D.38649>:
      klass = iftmp.799;
      handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = handle;
      release_data = monoeg_malloc (8);
      release_data->handle = handle;
      D.38650 = mono_object_get_domain (mb);
      release_data->domain = D.38650;
      D.38651 = mono_gc_reference_queue_add (queue, mb, release_data);
      if (D.38651 == 0) goto <D.38652>; else goto <D.38653>;
      <D.38652>:
      monoeg_g_free (release_data);
      <D.38653>:
      l = mb->referenced_by;
      goto <D.23359>;
      <D.23358>:
      {
        struct MonoReflectionDynamicMethod * method;
        struct MonoMethodWrapper * wrapper;
        void * * data;

        method = l->data;
        wrapper = method->mhandle;
        D.38654 = method->mhandle;
        D.38655 = D.38654 == 0B;
        D.38656 = (long int) D.38655;
        D.38657 = __builtin_expect (D.38656, 0);
        if (D.38657 != 0) goto <D.38658>; else goto <D.38659>;
        <D.38658>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11637, "method->mhandle");
        <D.38659>:
        data = wrapper->method_data;
        i = 0;
        goto <D.23356>;
        <D.23355>:
        i.798 = (sizetype) i;
        D.38641 = i.798 + 1;
        D.38642 = D.38641 * 4;
        D.38660 = data + D.38642;
        D.38661 = *D.38660;
        if (D.38661 == mb) goto <D.38662>; else goto <D.38663>;
        <D.38662>:
        i.798 = (sizetype) i;
        D.38664 = i.798 + 2;
        D.38665 = D.38664 * 4;
        D.38666 = data + D.38665;
        D.38667 = *D.38666;
        handle_class.795 = mono_defaults.methodhandle_class;
        if (D.38667 == handle_class.795) goto <D.38668>; else goto <D.38669>;
        <D.38668>:
        i.798 = (sizetype) i;
        D.38641 = i.798 + 1;
        D.38642 = D.38641 * 4;
        D.38660 = data + D.38642;
        D.38670 = mb->mhandle;
        *D.38660 = D.38670;
        <D.38669>:
        <D.38663>:
        i = i + 2;
        <D.23356>:
        i.797 = (unsigned int) i;
        D.38671 = *data;
        D.38672 = (unsigned int) D.38671;
        if (i.797 < D.38672) goto <D.23355>; else goto <D.23357>;
        <D.23357>:
      }
      l = l->next;
      <D.23359>:
      if (l != 0B) goto <D.23358>; else goto <D.23360>;
      <D.23360>:
      D.38673 = mb->referenced_by;
      monoeg_g_slist_free (D.38673);
      D.38636 = rmb.refs;
      monoeg_g_free (D.38636);
      mb->ilgen = 0B;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


free_dynamic_method (void * dynamic_method)
{
  struct MonoDomain * D.38679;
  struct MonoMethod * D.38680;
  struct DynamicMethodReleaseData * data;

  data = dynamic_method;
  D.38679 = data->domain;
  D.38680 = data->handle;
  mono_runtime_free_method (D.38679, D.38680);
  monoeg_g_free (data);
}


dynamic_method_to_signature (struct MonoReflectionDynamicMethod * method)
{
  struct MonoArray * D.38681;
  unsigned int D.38682;
  unsigned int D.38683;
  _Bool D.38684;
  struct MonoType * iftmp.800;
  struct MonoReflectionType * D.38686;
  struct MonoClass * D.38690;
  struct MonoMethodSignature * D.38691;
  struct MonoMethodSignature * sig;

  D.38681 = method->parameters;
  sig = parameters_to_signature (0B, D.38681);
  D.38682 = method->attrs;
  D.38683 = D.38682 & 16;
  D.38684 = D.38683 == 0;
  sig->hasthis = D.38684;
  D.38686 = method->rtype;
  if (D.38686 != 0B) goto <D.38687>; else goto <D.38688>;
  <D.38687>:
  D.38686 = method->rtype;
  iftmp.800 = mono_reflection_type_get_handle (D.38686);
  goto <D.38689>;
  <D.38688>:
  D.38690 = mono_defaults.void_class;
  iftmp.800 = &D.38690->byval_arg;
  <D.38689>:
  sig->ret = iftmp.800;
  sig->generic_param_count = 0;
  D.38691 = sig;
  return D.38691;
}


reflection_methodbuilder_from_dynamic_method (struct ReflectionMethodBuilder * rmb, struct MonoReflectionDynamicMethod * mb)
{
  struct MonoReflectionILGen * D.38693;
  struct MonoReflectionType * D.38694;
  struct MonoArray * D.38695;
  unsigned int D.38696;
  unsigned int D.38697;
  struct MonoReflectionType * D.38698;
  struct MonoString * D.38699;
  unsigned char D.38700;
  unsigned char D.38701;
  struct MonoMethod * D.38702;

  memset (rmb, 0, 112);
  D.38693 = mb->ilgen;
  rmb->ilgen = D.38693;
  D.38694 = mb->rtype;
  rmb->rtype = D.38694;
  D.38695 = mb->parameters;
  rmb->parameters = D.38695;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  rmb->pinfo = 0B;
  D.38696 = mb->attrs;
  rmb->attrs = D.38696;
  rmb->iattrs = 0;
  D.38697 = mb->call_conv;
  rmb->call_conv = D.38697;
  rmb->code = 0B;
  D.38698 = mb->owner;
  rmb->type = D.38698;
  D.38699 = mb->name;
  rmb->name = D.38699;
  rmb->table_idx = 0B;
  D.38700 = mb->init_locals;
  rmb->init_locals = D.38700;
  D.38701 = mb->skip_visibility;
  rmb->skip_visibility = D.38701;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  rmb->param_modreq = 0B;
  rmb->param_modopt = 0B;
  rmb->permissions = 0B;
  D.38702 = mb->mhandle;
  rmb->mhandle = D.38702;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


resolve_object (struct MonoImage * image, struct MonoObject * obj, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  int D.23406;
  int iftmp.801;
  int D.23405;
  struct MonoVTable * D.38706;
  struct MonoClass * D.38707;
  const char[7] * D.38708;
  unsigned char D.38709;
  int D.38710;
  unsigned char D.38711;
  int D.38712;
  const unsigned char * D.38717;
  unsigned char D.38718;
  int D.38719;
  const unsigned char * D.38720;
  unsigned char D.38721;
  int D.38722;
  const unsigned char * D.38727;
  unsigned char D.38728;
  int D.38729;
  const unsigned char * D.38730;
  unsigned char D.38731;
  int D.38732;
  const unsigned char * D.38737;
  unsigned char D.38738;
  int D.38739;
  const unsigned char * D.38740;
  unsigned char D.38741;
  int D.38742;
  const char * D.38744;
  struct MonoClass * D.38747;
  _Bool D.38748;
  long int D.38749;
  long int D.38750;
  int D.23415;
  int iftmp.802;
  int D.23414;
  const char[9] * D.38757;
  unsigned char D.38758;
  int D.38759;
  unsigned char D.38760;
  int D.38761;
  const unsigned char * D.38766;
  unsigned char D.38767;
  int D.38768;
  const unsigned char * D.38769;
  unsigned char D.38770;
  int D.38771;
  const unsigned char * D.38776;
  unsigned char D.38777;
  int D.38778;
  const unsigned char * D.38779;
  unsigned char D.38780;
  int D.38781;
  const unsigned char * D.38786;
  unsigned char D.38787;
  int D.38788;
  const unsigned char * D.38789;
  unsigned char D.38790;
  int D.38791;
  int D.38795;
  struct MonoException * D.38798;
  struct MonoClass * D.38802;
  int D.23427;
  int iftmp.803;
  int D.23426;
  const char[11] * D.38812;
  unsigned char D.38813;
  int D.38814;
  unsigned char D.38815;
  int D.38816;
  const unsigned char * D.38821;
  unsigned char D.38822;
  int D.38823;
  const unsigned char * D.38824;
  unsigned char D.38825;
  int D.38826;
  const unsigned char * D.38831;
  unsigned char D.38832;
  int D.38833;
  const unsigned char * D.38834;
  unsigned char D.38835;
  int D.38836;
  const unsigned char * D.38841;
  unsigned char D.38842;
  int D.38843;
  const unsigned char * D.38844;
  unsigned char D.38845;
  int D.38846;
  int D.23436;
  int iftmp.804;
  int D.23435;
  const char[12] * D.38852;
  unsigned char D.38853;
  int D.38854;
  unsigned char D.38855;
  int D.38856;
  const unsigned char * D.38861;
  unsigned char D.38862;
  int D.38863;
  const unsigned char * D.38864;
  unsigned char D.38865;
  int D.38866;
  const unsigned char * D.38871;
  unsigned char D.38872;
  int D.38873;
  const unsigned char * D.38874;
  unsigned char D.38875;
  int D.38876;
  const unsigned char * D.38881;
  unsigned char D.38882;
  int D.38883;
  const unsigned char * D.38884;
  unsigned char D.38885;
  int D.38886;
  int D.23445;
  int iftmp.805;
  int D.23444;
  const char[19] * D.38892;
  unsigned char D.38893;
  int D.38894;
  unsigned char D.38895;
  int D.38896;
  const unsigned char * D.38901;
  unsigned char D.38902;
  int D.38903;
  const unsigned char * D.38904;
  unsigned char D.38905;
  int D.38906;
  const unsigned char * D.38911;
  unsigned char D.38912;
  int D.38913;
  const unsigned char * D.38914;
  unsigned char D.38915;
  int D.38916;
  const unsigned char * D.38921;
  unsigned char D.38922;
  int D.38923;
  const unsigned char * D.38924;
  unsigned char D.38925;
  int D.38926;
  int D.23454;
  int iftmp.806;
  int D.23453;
  const char[18] * D.38932;
  unsigned char D.38933;
  int D.38934;
  unsigned char D.38935;
  int D.38936;
  const unsigned char * D.38941;
  unsigned char D.38942;
  int D.38943;
  const unsigned char * D.38944;
  unsigned char D.38945;
  int D.38946;
  const unsigned char * D.38951;
  unsigned char D.38952;
  int D.38953;
  const unsigned char * D.38954;
  unsigned char D.38955;
  int D.38956;
  const unsigned char * D.38961;
  unsigned char D.38962;
  int D.38963;
  const unsigned char * D.38964;
  unsigned char D.38965;
  int D.38966;
  struct MonoClass * D.38970;
  int D.23463;
  int iftmp.807;
  int D.23462;
  const char[14] * D.38976;
  unsigned char D.38977;
  int D.38978;
  unsigned char D.38979;
  int D.38980;
  const unsigned char * D.38985;
  unsigned char D.38986;
  int D.38987;
  const unsigned char * D.38988;
  unsigned char D.38989;
  int D.38990;
  const unsigned char * D.38995;
  unsigned char D.38996;
  int D.38997;
  const unsigned char * D.38998;
  unsigned char D.38999;
  int D.39000;
  const unsigned char * D.39005;
  unsigned char D.39006;
  int D.39007;
  const unsigned char * D.39008;
  unsigned char D.39009;
  int D.39010;
  struct MonoDomain * D.39016;
  int D.23474;
  int iftmp.808;
  int D.23473;
  const char[19] * D.39023;
  unsigned char D.39024;
  int D.39025;
  unsigned char D.39026;
  int D.39027;
  const unsigned char * D.39032;
  unsigned char D.39033;
  int D.39034;
  const unsigned char * D.39035;
  unsigned char D.39036;
  int D.39037;
  const unsigned char * D.39042;
  unsigned char D.39043;
  int D.39044;
  const unsigned char * D.39045;
  unsigned char D.39046;
  int D.39047;
  const unsigned char * D.39052;
  unsigned char D.39053;
  int D.39054;
  const unsigned char * D.39055;
  unsigned char D.39056;
  int D.39057;
  struct MonoDomain * D.39063;
  int D.23485;
  int iftmp.809;
  int D.23484;
  const char[10] * D.39070;
  unsigned char D.39071;
  int D.39072;
  unsigned char D.39073;
  int D.39074;
  const unsigned char * D.39079;
  unsigned char D.39080;
  int D.39081;
  const unsigned char * D.39082;
  unsigned char D.39083;
  int D.39084;
  const unsigned char * D.39089;
  unsigned char D.39090;
  int D.39091;
  const unsigned char * D.39092;
  unsigned char D.39093;
  int D.39094;
  const unsigned char * D.39099;
  unsigned char D.39100;
  int D.39101;
  const unsigned char * D.39102;
  unsigned char D.39103;
  int D.39104;
  struct MonoClass * D.39108;
  struct MonoType * D.39111;
  int D.23499;
  const char * D.39112;
  const char * D.39113;
  int iftmp.810;
  int D.23511;
  _Bool D.39120;
  long int D.39121;
  long int D.39122;
  struct MonoClass * D.39126;
  int D.23520;
  int iftmp.811;
  int D.23519;
  const char[13] * D.39133;
  unsigned char D.39134;
  int D.39135;
  unsigned char D.39136;
  int D.39137;
  const unsigned char * D.39142;
  unsigned char D.39143;
  int D.39144;
  const unsigned char * D.39145;
  unsigned char D.39146;
  int D.39147;
  const unsigned char * D.39152;
  unsigned char D.39153;
  int D.39154;
  const unsigned char * D.39155;
  unsigned char D.39156;
  int D.39157;
  const unsigned char * D.39162;
  unsigned char D.39163;
  int D.39164;
  const unsigned char * D.39165;
  unsigned char D.39166;
  int D.39167;
  struct MonoDomain * D.39173;
  struct MonoClassField * D.39174;
  struct MonoClass * D.39177;
  struct MonoGenericContainer * D.39178;
  struct MonoType * D.39181;
  const char * D.39182;
  int D.23534;
  int iftmp.812;
  int D.23533;
  const char[12] * D.39189;
  unsigned char D.39190;
  int D.39191;
  unsigned char D.39192;
  int D.39193;
  const unsigned char * D.39198;
  unsigned char D.39199;
  int D.39200;
  const unsigned char * D.39201;
  unsigned char D.39202;
  int D.39203;
  const unsigned char * D.39208;
  unsigned char D.39209;
  int D.39210;
  const unsigned char * D.39211;
  unsigned char D.39212;
  int D.39213;
  const unsigned char * D.39218;
  unsigned char D.39219;
  int D.39220;
  const unsigned char * D.39221;
  unsigned char D.39222;
  int D.39223;
  unsigned int D.39227;
  unsigned int D.39228;
  struct MonoDomain * D.39232;
  int D.23546;
  int iftmp.813;
  int D.23545;
  const char[16] * D.39239;
  unsigned char D.39240;
  int D.39241;
  unsigned char D.39242;
  int D.39243;
  const unsigned char * D.39248;
  unsigned char D.39249;
  int D.39250;
  const unsigned char * D.39251;
  unsigned char D.39252;
  int D.39253;
  const unsigned char * D.39258;
  unsigned char D.39259;
  int D.39260;
  const unsigned char * D.39261;
  unsigned char D.39262;
  int D.39263;
  const unsigned char * D.39268;
  unsigned char D.39269;
  int D.39270;
  const unsigned char * D.39271;
  unsigned char D.39272;
  int D.39273;
  struct MonoArray * D.39277;
  unsigned int D.39280;
  unsigned int nargs.814;
  unsigned int D.39283;
  unsigned int D.39284;
  _Bool D.39285;
  unsigned int D.39286;
  _Bool D.39287;
  unsigned int D.39288;
  unsigned char D.39291;
  unsigned char D.39292;
  <unnamed-unsigned:6> D.39293;
  unsigned int D.39295;
  short unsigned int D.39299;
  struct MonoReflectionType * D.39300;
  struct MonoType * D.39301;
  unsigned int i.815;
  char * D.39303;
  void * D.39304;
  struct MonoType * D.39305;
  int D.23562;
  int iftmp.816;
  int D.23561;
  const char[14] * D.39310;
  unsigned char D.39311;
  int D.39312;
  unsigned char D.39313;
  int D.39314;
  const unsigned char * D.39319;
  unsigned char D.39320;
  int D.39321;
  const unsigned char * D.39322;
  unsigned char D.39323;
  int D.39324;
  const unsigned char * D.39329;
  unsigned char D.39330;
  int D.39331;
  const unsigned char * D.39332;
  unsigned char D.39333;
  int D.39334;
  const unsigned char * D.39339;
  unsigned char D.39340;
  int D.39341;
  const unsigned char * D.39342;
  unsigned char D.39343;
  int D.39344;
  struct MonoMethod * D.39348;
  _Bool D.39349;
  long int D.39350;
  long int D.39351;
  int D.23572;
  int iftmp.817;
  int D.23571;
  const char[28] * D.39358;
  unsigned char D.39359;
  int D.39360;
  unsigned char D.39361;
  int D.39362;
  const unsigned char * D.39367;
  unsigned char D.39368;
  int D.39369;
  const unsigned char * D.39370;
  unsigned char D.39371;
  int D.39372;
  const unsigned char * D.39377;
  unsigned char D.39378;
  int D.39379;
  const unsigned char * D.39380;
  unsigned char D.39381;
  int D.39382;
  const unsigned char * D.39387;
  unsigned char D.39388;
  int D.39389;
  const unsigned char * D.39390;
  unsigned char D.39391;
  int D.39392;
  int D.23582;
  int iftmp.818;
  int D.23581;
  const char[17] * D.39402;
  unsigned char D.39403;
  int D.39404;
  unsigned char D.39405;
  int D.39406;
  const unsigned char * D.39411;
  unsigned char D.39412;
  int D.39413;
  const unsigned char * D.39414;
  unsigned char D.39415;
  int D.39416;
  const unsigned char * D.39421;
  unsigned char D.39422;
  int D.39423;
  const unsigned char * D.39424;
  unsigned char D.39425;
  int D.39426;
  const unsigned char * D.39431;
  unsigned char D.39432;
  int D.39433;
  const unsigned char * D.39434;
  unsigned char D.39435;
  int D.39436;
  int D.23592;
  int iftmp.819;
  int D.23591;
  const char[23] * D.39446;
  unsigned char D.39447;
  int D.39448;
  unsigned char D.39449;
  int D.39450;
  const unsigned char * D.39455;
  unsigned char D.39456;
  int D.39457;
  const unsigned char * D.39458;
  unsigned char D.39459;
  int D.39460;
  const unsigned char * D.39465;
  unsigned char D.39466;
  int D.39467;
  const unsigned char * D.39468;
  unsigned char D.39469;
  int D.39470;
  const unsigned char * D.39475;
  unsigned char D.39476;
  int D.39477;
  const unsigned char * D.39478;
  unsigned char D.39479;
  int D.39480;
  struct MonoObject * D.39484;
  struct MonoVTable * D.39485;
  struct MonoClass * D.39486;
  int D.39487;
  int D.39491;
  char * D.39495;
  struct MonoReflectionGenericClass * D.39496;
  struct MonoType * D.39497;
  const char * D.39498;
  struct MonoClass * D.39499;
  int D.23606;
  int iftmp.820;
  int D.23605;
  const char[29] * D.39506;
  unsigned char D.39507;
  int D.39508;
  unsigned char D.39509;
  int D.39510;
  const unsigned char * D.39515;
  unsigned char D.39516;
  int D.39517;
  const unsigned char * D.39518;
  unsigned char D.39519;
  int D.39520;
  const unsigned char * D.39525;
  unsigned char D.39526;
  int D.39527;
  const unsigned char * D.39528;
  unsigned char D.39529;
  int D.39530;
  const unsigned char * D.39535;
  unsigned char D.39536;
  int D.39537;
  const unsigned char * D.39538;
  unsigned char D.39539;
  int D.39540;
  struct MonoReflectionGenericClass * D.39544;
  struct MonoType * D.39545;
  struct MonoObject * D.39546;
  struct MonoVTable * D.39547;
  struct MonoClass * D.39548;
  int D.39549;
  int D.39553;
  char * D.39557;
  int D.23620;
  int iftmp.821;
  int D.23619;
  const char[24] * D.39562;
  unsigned char D.39563;
  int D.39564;
  unsigned char D.39565;
  int D.39566;
  const unsigned char * D.39571;
  unsigned char D.39572;
  int D.39573;
  const unsigned char * D.39574;
  unsigned char D.39575;
  int D.39576;
  const unsigned char * D.39581;
  unsigned char D.39582;
  int D.39583;
  const unsigned char * D.39584;
  unsigned char D.39585;
  int D.39586;
  const unsigned char * D.39591;
  unsigned char D.39592;
  int D.39593;
  const unsigned char * D.39594;
  unsigned char D.39595;
  int D.39596;
  struct MonoArray * D.39600;
  struct MonoReflectionType * D.39606;
  struct MonoType * D.39607;
  struct MonoObject * D.39608;
  struct MonoVTable * D.39609;
  struct MonoClass * D.39610;
  int D.39611;
  int D.39615;
  char * D.39619;
  int D.23634;
  int iftmp.822;
  int D.23633;
  const char[16] * D.39624;
  unsigned char D.39625;
  int D.39626;
  unsigned char D.39627;
  int D.39628;
  const unsigned char * D.39633;
  unsigned char D.39634;
  int D.39635;
  const unsigned char * D.39636;
  unsigned char D.39637;
  int D.39638;
  const unsigned char * D.39643;
  unsigned char D.39644;
  int D.39645;
  const unsigned char * D.39646;
  unsigned char D.39647;
  int D.39648;
  const unsigned char * D.39653;
  unsigned char D.39654;
  int D.39655;
  const unsigned char * D.39656;
  unsigned char D.39657;
  int D.39658;
  struct MonoReflectionType * D.39662;
  struct MonoString * D.39663;
  int D.23649;
  const char * D.39664;
  _Bool D.39666;
  long int D.39667;
  long int D.39668;
  struct MonoClass * D.39675;
  int D.39676;
  struct MonoClass * D.39678;
  int D.39679;
  struct MonoClass * D.39681;
  int D.39682;
  void * D.39686;
  void * result;

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

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38708 = "String";
      D.38709 = MEM[(const unsigned char *)D.38708];
      D.38710 = (int) D.38709;
      D.38711 = *__s2;
      D.38712 = (int) D.38711;
      __result = D.38710 - D.38712;
      {
        if (__s2_len != 0) goto <D.38713>; else goto <D.38714>;
        <D.38713>:
        if (__result == 0) goto <D.38715>; else goto <D.38716>;
        <D.38715>:
        D.38717 = &MEM[(void *)"String" + 1B];
        D.38718 = *D.38717;
        D.38719 = (int) D.38718;
        D.38720 = __s2 + 1;
        D.38721 = *D.38720;
        D.38722 = (int) D.38721;
        __result = D.38719 - D.38722;
        if (__s2_len > 1) goto <D.38723>; else goto <D.38724>;
        <D.38723>:
        if (__result == 0) goto <D.38725>; else goto <D.38726>;
        <D.38725>:
        D.38727 = &MEM[(void *)"String" + 2B];
        D.38728 = *D.38727;
        D.38729 = (int) D.38728;
        D.38730 = __s2 + 2;
        D.38731 = *D.38730;
        D.38732 = (int) D.38731;
        __result = D.38729 - D.38732;
        if (__s2_len > 2) goto <D.38733>; else goto <D.38734>;
        <D.38733>:
        if (__result == 0) goto <D.38735>; else goto <D.38736>;
        <D.38735>:
        D.38737 = &MEM[(void *)"String" + 3B];
        D.38738 = *D.38737;
        D.38739 = (int) D.38738;
        D.38740 = __s2 + 3;
        D.38741 = *D.38740;
        D.38742 = (int) D.38741;
        __result = D.38739 - D.38742;
        <D.38736>:
        <D.38734>:
        <D.38726>:
        <D.38724>:
        <D.38716>:
        <D.38714>:
      }
      D.23405 = __result;
    }
    iftmp.801 = -D.23405;
    goto <D.38743>;
    <D.38705>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.801 = __builtin_strcmp (D.38744, "String");
    <D.38743>:
    D.23406 = iftmp.801;
  }
  if (D.23406 == 0) goto <D.38745>; else goto <D.38746>;
  <D.38745>:
  result = mono_string_intern (obj);
  D.38747 = mono_defaults.string_class;
  *handle_class = D.38747;
  D.38748 = result == 0B;
  D.38749 = (long int) D.38748;
  D.38750 = __builtin_expect (D.38749, 0);
  if (D.38750 != 0) goto <D.38751>; else goto <D.38752>;
  <D.38751>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11751, "result");
  <D.38752>:
  goto <D.38753>;
  <D.38746>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38757 = "MonoType";
      D.38758 = MEM[(const unsigned char *)D.38757];
      D.38759 = (int) D.38758;
      D.38760 = *__s2;
      D.38761 = (int) D.38760;
      __result = D.38759 - D.38761;
      {
        if (__s2_len != 0) goto <D.38762>; else goto <D.38763>;
        <D.38762>:
        if (__result == 0) goto <D.38764>; else goto <D.38765>;
        <D.38764>:
        D.38766 = &MEM[(void *)"MonoType" + 1B];
        D.38767 = *D.38766;
        D.38768 = (int) D.38767;
        D.38769 = __s2 + 1;
        D.38770 = *D.38769;
        D.38771 = (int) D.38770;
        __result = D.38768 - D.38771;
        if (__s2_len > 1) goto <D.38772>; else goto <D.38773>;
        <D.38772>:
        if (__result == 0) goto <D.38774>; else goto <D.38775>;
        <D.38774>:
        D.38776 = &MEM[(void *)"MonoType" + 2B];
        D.38777 = *D.38776;
        D.38778 = (int) D.38777;
        D.38779 = __s2 + 2;
        D.38780 = *D.38779;
        D.38781 = (int) D.38780;
        __result = D.38778 - D.38781;
        if (__s2_len > 2) goto <D.38782>; else goto <D.38783>;
        <D.38782>:
        if (__result == 0) goto <D.38784>; else goto <D.38785>;
        <D.38784>:
        D.38786 = &MEM[(void *)"MonoType" + 3B];
        D.38787 = *D.38786;
        D.38788 = (int) D.38787;
        D.38789 = __s2 + 3;
        D.38790 = *D.38789;
        D.38791 = (int) D.38790;
        __result = D.38788 - D.38791;
        <D.38785>:
        <D.38783>:
        <D.38775>:
        <D.38773>:
        <D.38765>:
        <D.38763>:
      }
      D.23414 = __result;
    }
    iftmp.802 = -D.23414;
    goto <D.38792>;
    <D.38756>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.802 = __builtin_strcmp (D.38744, "MonoType");
    <D.38792>:
    D.23415 = iftmp.802;
  }
  if (D.23415 == 0) goto <D.38793>; else goto <D.38794>;
  <D.38793>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.38795 = mono_class_init (mc);
    if (D.38795 == 0) goto <D.38796>; else goto <D.38797>;
    <D.38796>:
    D.38798 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.38798);
    <D.38797>:
    if (context != 0B) goto <D.38799>; else goto <D.38800>;
    <D.38799>:
    {
      struct MonoType * inflated;

      inflated = mono_class_inflate_generic_type (type, context);
      result = mono_class_from_mono_type (inflated);
      mono_metadata_free_type (inflated);
    }
    goto <D.38801>;
    <D.38800>:
    result = mono_class_from_mono_type (type);
    <D.38801>:
    D.38802 = mono_defaults.typehandle_class;
    *handle_class = D.38802;
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.38803>; else goto <D.38804>;
    <D.38803>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11766, "result");
    <D.38804>:
  }
  goto <D.38805>;
  <D.38794>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38812 = "MonoMethod";
      D.38813 = MEM[(const unsigned char *)D.38812];
      D.38814 = (int) D.38813;
      D.38815 = *__s2;
      D.38816 = (int) D.38815;
      __result = D.38814 - D.38816;
      {
        if (__s2_len != 0) goto <D.38817>; else goto <D.38818>;
        <D.38817>:
        if (__result == 0) goto <D.38819>; else goto <D.38820>;
        <D.38819>:
        D.38821 = &MEM[(void *)"MonoMethod" + 1B];
        D.38822 = *D.38821;
        D.38823 = (int) D.38822;
        D.38824 = __s2 + 1;
        D.38825 = *D.38824;
        D.38826 = (int) D.38825;
        __result = D.38823 - D.38826;
        if (__s2_len > 1) goto <D.38827>; else goto <D.38828>;
        <D.38827>:
        if (__result == 0) goto <D.38829>; else goto <D.38830>;
        <D.38829>:
        D.38831 = &MEM[(void *)"MonoMethod" + 2B];
        D.38832 = *D.38831;
        D.38833 = (int) D.38832;
        D.38834 = __s2 + 2;
        D.38835 = *D.38834;
        D.38836 = (int) D.38835;
        __result = D.38833 - D.38836;
        if (__s2_len > 2) goto <D.38837>; else goto <D.38838>;
        <D.38837>:
        if (__result == 0) goto <D.38839>; else goto <D.38840>;
        <D.38839>:
        D.38841 = &MEM[(void *)"MonoMethod" + 3B];
        D.38842 = *D.38841;
        D.38843 = (int) D.38842;
        D.38844 = __s2 + 3;
        D.38845 = *D.38844;
        D.38846 = (int) D.38845;
        __result = D.38843 - D.38846;
        <D.38840>:
        <D.38838>:
        <D.38830>:
        <D.38828>:
        <D.38820>:
        <D.38818>:
      }
      D.23426 = __result;
    }
    iftmp.803 = -D.23426;
    goto <D.38847>;
    <D.38811>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.803 = __builtin_strcmp (D.38744, "MonoMethod");
    <D.38847>:
    D.23427 = iftmp.803;
  }
  if (D.23427 == 0) goto <D.38806>; else goto <D.38848>;
  <D.38848>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38852 = "MonoCMethod";
      D.38853 = MEM[(const unsigned char *)D.38852];
      D.38854 = (int) D.38853;
      D.38855 = *__s2;
      D.38856 = (int) D.38855;
      __result = D.38854 - D.38856;
      {
        if (__s2_len != 0) goto <D.38857>; else goto <D.38858>;
        <D.38857>:
        if (__result == 0) goto <D.38859>; else goto <D.38860>;
        <D.38859>:
        D.38861 = &MEM[(void *)"MonoCMethod" + 1B];
        D.38862 = *D.38861;
        D.38863 = (int) D.38862;
        D.38864 = __s2 + 1;
        D.38865 = *D.38864;
        D.38866 = (int) D.38865;
        __result = D.38863 - D.38866;
        if (__s2_len > 1) goto <D.38867>; else goto <D.38868>;
        <D.38867>:
        if (__result == 0) goto <D.38869>; else goto <D.38870>;
        <D.38869>:
        D.38871 = &MEM[(void *)"MonoCMethod" + 2B];
        D.38872 = *D.38871;
        D.38873 = (int) D.38872;
        D.38874 = __s2 + 2;
        D.38875 = *D.38874;
        D.38876 = (int) D.38875;
        __result = D.38873 - D.38876;
        if (__s2_len > 2) goto <D.38877>; else goto <D.38878>;
        <D.38877>:
        if (__result == 0) goto <D.38879>; else goto <D.38880>;
        <D.38879>:
        D.38881 = &MEM[(void *)"MonoCMethod" + 3B];
        D.38882 = *D.38881;
        D.38883 = (int) D.38882;
        D.38884 = __s2 + 3;
        D.38885 = *D.38884;
        D.38886 = (int) D.38885;
        __result = D.38883 - D.38886;
        <D.38880>:
        <D.38878>:
        <D.38870>:
        <D.38868>:
        <D.38860>:
        <D.38858>:
      }
      D.23435 = __result;
    }
    iftmp.804 = -D.23435;
    goto <D.38887>;
    <D.38851>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.804 = __builtin_strcmp (D.38744, "MonoCMethod");
    <D.38887>:
    D.23436 = iftmp.804;
  }
  if (D.23436 == 0) goto <D.38806>; else goto <D.38888>;
  <D.38888>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38892 = "MonoGenericCMethod";
      D.38893 = MEM[(const unsigned char *)D.38892];
      D.38894 = (int) D.38893;
      D.38895 = *__s2;
      D.38896 = (int) D.38895;
      __result = D.38894 - D.38896;
      {
        if (__s2_len != 0) goto <D.38897>; else goto <D.38898>;
        <D.38897>:
        if (__result == 0) goto <D.38899>; else goto <D.38900>;
        <D.38899>:
        D.38901 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.38902 = *D.38901;
        D.38903 = (int) D.38902;
        D.38904 = __s2 + 1;
        D.38905 = *D.38904;
        D.38906 = (int) D.38905;
        __result = D.38903 - D.38906;
        if (__s2_len > 1) goto <D.38907>; else goto <D.38908>;
        <D.38907>:
        if (__result == 0) goto <D.38909>; else goto <D.38910>;
        <D.38909>:
        D.38911 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.38912 = *D.38911;
        D.38913 = (int) D.38912;
        D.38914 = __s2 + 2;
        D.38915 = *D.38914;
        D.38916 = (int) D.38915;
        __result = D.38913 - D.38916;
        if (__s2_len > 2) goto <D.38917>; else goto <D.38918>;
        <D.38917>:
        if (__result == 0) goto <D.38919>; else goto <D.38920>;
        <D.38919>:
        D.38921 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.38922 = *D.38921;
        D.38923 = (int) D.38922;
        D.38924 = __s2 + 3;
        D.38925 = *D.38924;
        D.38926 = (int) D.38925;
        __result = D.38923 - D.38926;
        <D.38920>:
        <D.38918>:
        <D.38910>:
        <D.38908>:
        <D.38900>:
        <D.38898>:
      }
      D.23444 = __result;
    }
    iftmp.805 = -D.23444;
    goto <D.38927>;
    <D.38891>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.805 = __builtin_strcmp (D.38744, "MonoGenericCMethod");
    <D.38927>:
    D.23445 = iftmp.805;
  }
  if (D.23445 == 0) goto <D.38806>; else goto <D.38928>;
  <D.38928>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38932 = "MonoGenericMethod";
      D.38933 = MEM[(const unsigned char *)D.38932];
      D.38934 = (int) D.38933;
      D.38935 = *__s2;
      D.38936 = (int) D.38935;
      __result = D.38934 - D.38936;
      {
        if (__s2_len != 0) goto <D.38937>; else goto <D.38938>;
        <D.38937>:
        if (__result == 0) goto <D.38939>; else goto <D.38940>;
        <D.38939>:
        D.38941 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.38942 = *D.38941;
        D.38943 = (int) D.38942;
        D.38944 = __s2 + 1;
        D.38945 = *D.38944;
        D.38946 = (int) D.38945;
        __result = D.38943 - D.38946;
        if (__s2_len > 1) goto <D.38947>; else goto <D.38948>;
        <D.38947>:
        if (__result == 0) goto <D.38949>; else goto <D.38950>;
        <D.38949>:
        D.38951 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.38952 = *D.38951;
        D.38953 = (int) D.38952;
        D.38954 = __s2 + 2;
        D.38955 = *D.38954;
        D.38956 = (int) D.38955;
        __result = D.38953 - D.38956;
        if (__s2_len > 2) goto <D.38957>; else goto <D.38958>;
        <D.38957>:
        if (__result == 0) goto <D.38959>; else goto <D.38960>;
        <D.38959>:
        D.38961 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.38962 = *D.38961;
        D.38963 = (int) D.38962;
        D.38964 = __s2 + 3;
        D.38965 = *D.38964;
        D.38966 = (int) D.38965;
        __result = D.38963 - D.38966;
        <D.38960>:
        <D.38958>:
        <D.38950>:
        <D.38948>:
        <D.38940>:
        <D.38938>:
      }
      D.23453 = __result;
    }
    iftmp.806 = -D.23453;
    goto <D.38967>;
    <D.38931>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.806 = __builtin_strcmp (D.38744, "MonoGenericMethod");
    <D.38967>:
    D.23454 = iftmp.806;
  }
  if (D.23454 == 0) goto <D.38806>; else goto <D.38807>;
  <D.38806>:
  result = MEM[(struct MonoReflectionMethod *)obj].method;
  if (context != 0B) goto <D.38968>; else goto <D.38969>;
  <D.38968>:
  result = mono_class_inflate_generic_method (result, context);
  <D.38969>:
  D.38970 = mono_defaults.methodhandle_class;
  *handle_class = D.38970;
  D.38748 = result == 0B;
  D.38749 = (long int) D.38748;
  D.38750 = __builtin_expect (D.38749, 0);
  if (D.38750 != 0) goto <D.38971>; else goto <D.38972>;
  <D.38971>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11775, "result");
  <D.38972>:
  goto <D.38808>;
  <D.38807>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.38976 = "MethodBuilder";
      D.38977 = MEM[(const unsigned char *)D.38976];
      D.38978 = (int) D.38977;
      D.38979 = *__s2;
      D.38980 = (int) D.38979;
      __result = D.38978 - D.38980;
      {
        if (__s2_len != 0) goto <D.38981>; else goto <D.38982>;
        <D.38981>:
        if (__result == 0) goto <D.38983>; else goto <D.38984>;
        <D.38983>:
        D.38985 = &MEM[(void *)"MethodBuilder" + 1B];
        D.38986 = *D.38985;
        D.38987 = (int) D.38986;
        D.38988 = __s2 + 1;
        D.38989 = *D.38988;
        D.38990 = (int) D.38989;
        __result = D.38987 - D.38990;
        if (__s2_len > 1) goto <D.38991>; else goto <D.38992>;
        <D.38991>:
        if (__result == 0) goto <D.38993>; else goto <D.38994>;
        <D.38993>:
        D.38995 = &MEM[(void *)"MethodBuilder" + 2B];
        D.38996 = *D.38995;
        D.38997 = (int) D.38996;
        D.38998 = __s2 + 2;
        D.38999 = *D.38998;
        D.39000 = (int) D.38999;
        __result = D.38997 - D.39000;
        if (__s2_len > 2) goto <D.39001>; else goto <D.39002>;
        <D.39001>:
        if (__result == 0) goto <D.39003>; else goto <D.39004>;
        <D.39003>:
        D.39005 = &MEM[(void *)"MethodBuilder" + 3B];
        D.39006 = *D.39005;
        D.39007 = (int) D.39006;
        D.39008 = __s2 + 3;
        D.39009 = *D.39008;
        D.39010 = (int) D.39009;
        __result = D.39007 - D.39010;
        <D.39004>:
        <D.39002>:
        <D.38994>:
        <D.38992>:
        <D.38984>:
        <D.38982>:
      }
      D.23462 = __result;
    }
    iftmp.807 = -D.23462;
    goto <D.39011>;
    <D.38975>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.807 = __builtin_strcmp (D.38744, "MethodBuilder");
    <D.39011>:
    D.23463 = iftmp.807;
  }
  if (D.23463 == 0) goto <D.39012>; else goto <D.39013>;
  <D.39012>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    result = mb->mhandle;
    if (result == 0B) goto <D.39014>; else goto <D.39015>;
    <D.39014>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = mb->type;
      D.39016 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39016, 0B, tb);
      result = mb->mhandle;
    }
    <D.39015>:
    if (context != 0B) goto <D.39017>; else goto <D.39018>;
    <D.39017>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39018>:
    D.38970 = mono_defaults.methodhandle_class;
    *handle_class = D.38970;
  }
  goto <D.39019>;
  <D.39013>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39023 = "ConstructorBuilder";
      D.39024 = MEM[(const unsigned char *)D.39023];
      D.39025 = (int) D.39024;
      D.39026 = *__s2;
      D.39027 = (int) D.39026;
      __result = D.39025 - D.39027;
      {
        if (__s2_len != 0) goto <D.39028>; else goto <D.39029>;
        <D.39028>:
        if (__result == 0) goto <D.39030>; else goto <D.39031>;
        <D.39030>:
        D.39032 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.39033 = *D.39032;
        D.39034 = (int) D.39033;
        D.39035 = __s2 + 1;
        D.39036 = *D.39035;
        D.39037 = (int) D.39036;
        __result = D.39034 - D.39037;
        if (__s2_len > 1) goto <D.39038>; else goto <D.39039>;
        <D.39038>:
        if (__result == 0) goto <D.39040>; else goto <D.39041>;
        <D.39040>:
        D.39042 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.39043 = *D.39042;
        D.39044 = (int) D.39043;
        D.39045 = __s2 + 2;
        D.39046 = *D.39045;
        D.39047 = (int) D.39046;
        __result = D.39044 - D.39047;
        if (__s2_len > 2) goto <D.39048>; else goto <D.39049>;
        <D.39048>:
        if (__result == 0) goto <D.39050>; else goto <D.39051>;
        <D.39050>:
        D.39052 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.39053 = *D.39052;
        D.39054 = (int) D.39053;
        D.39055 = __s2 + 3;
        D.39056 = *D.39055;
        D.39057 = (int) D.39056;
        __result = D.39054 - D.39057;
        <D.39051>:
        <D.39049>:
        <D.39041>:
        <D.39039>:
        <D.39031>:
        <D.39029>:
      }
      D.23473 = __result;
    }
    iftmp.808 = -D.23473;
    goto <D.39058>;
    <D.39022>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.808 = __builtin_strcmp (D.38744, "ConstructorBuilder");
    <D.39058>:
    D.23474 = iftmp.808;
  }
  if (D.23474 == 0) goto <D.39059>; else goto <D.39060>;
  <D.39059>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    result = cb->mhandle;
    if (result == 0B) goto <D.39061>; else goto <D.39062>;
    <D.39061>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = cb->type;
      D.39063 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39063, 0B, tb);
      result = cb->mhandle;
    }
    <D.39062>:
    if (context != 0B) goto <D.39064>; else goto <D.39065>;
    <D.39064>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39065>:
    D.38970 = mono_defaults.methodhandle_class;
    *handle_class = D.38970;
  }
  goto <D.39066>;
  <D.39060>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39070 = "MonoField";
      D.39071 = MEM[(const unsigned char *)D.39070];
      D.39072 = (int) D.39071;
      D.39073 = *__s2;
      D.39074 = (int) D.39073;
      __result = D.39072 - D.39074;
      {
        if (__s2_len != 0) goto <D.39075>; else goto <D.39076>;
        <D.39075>:
        if (__result == 0) goto <D.39077>; else goto <D.39078>;
        <D.39077>:
        D.39079 = &MEM[(void *)"MonoField" + 1B];
        D.39080 = *D.39079;
        D.39081 = (int) D.39080;
        D.39082 = __s2 + 1;
        D.39083 = *D.39082;
        D.39084 = (int) D.39083;
        __result = D.39081 - D.39084;
        if (__s2_len > 1) goto <D.39085>; else goto <D.39086>;
        <D.39085>:
        if (__result == 0) goto <D.39087>; else goto <D.39088>;
        <D.39087>:
        D.39089 = &MEM[(void *)"MonoField" + 2B];
        D.39090 = *D.39089;
        D.39091 = (int) D.39090;
        D.39092 = __s2 + 2;
        D.39093 = *D.39092;
        D.39094 = (int) D.39093;
        __result = D.39091 - D.39094;
        if (__s2_len > 2) goto <D.39095>; else goto <D.39096>;
        <D.39095>:
        if (__result == 0) goto <D.39097>; else goto <D.39098>;
        <D.39097>:
        D.39099 = &MEM[(void *)"MonoField" + 3B];
        D.39100 = *D.39099;
        D.39101 = (int) D.39100;
        D.39102 = __s2 + 3;
        D.39103 = *D.39102;
        D.39104 = (int) D.39103;
        __result = D.39101 - D.39104;
        <D.39098>:
        <D.39096>:
        <D.39088>:
        <D.39086>:
        <D.39078>:
        <D.39076>:
      }
      D.23484 = __result;
    }
    iftmp.809 = -D.23484;
    goto <D.39105>;
    <D.39069>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.809 = __builtin_strcmp (D.38744, "MonoField");
    <D.39105>:
    D.23485 = iftmp.809;
  }
  if (D.23485 == 0) goto <D.39106>; else goto <D.39107>;
  <D.39106>:
  {
    struct MonoClassField * field;

    field = MEM[(struct MonoReflectionField *)obj].field;
    D.39108 = field->parent;
    ensure_complete_type (D.39108);
    if (context != 0B) goto <D.39109>; else goto <D.39110>;
    <D.39109>:
    {
      struct MonoType * inflated;
      struct MonoClass * class;
      struct MonoClassField * inflated_field;
      void * iter;

      try
        {
          D.39108 = field->parent;
          D.39111 = &D.39108->byval_arg;
          inflated = mono_class_inflate_generic_type (D.39111, context);
          class = mono_class_from_mono_type (inflated);
          iter = 0B;
          mono_metadata_free_type (inflated);
          goto <D.23502>;
          <D.23501>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.39112 = field->name;
            D.39113 = inflated_field->name;
            D.23499 = __builtin_strcmp (D.39112, D.39113);
          }
          if (D.23499 == 0) goto <D.23500>; else goto <D.39114>;
          <D.39114>:
          <D.23502>:
          inflated_field = mono_class_get_fields (class, &iter);
          if (inflated_field != 0B) goto <D.23501>; else goto <D.23500>;
          <D.23500>:
          if (inflated_field == 0B) goto <D.39116>; else goto <D.39119>;
          <D.39119>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.39112 = field->name;
            D.39113 = inflated_field->name;
            D.23511 = __builtin_strcmp (D.39112, D.39113);
          }
          if (D.23511 != 0) goto <D.39116>; else goto <D.39117>;
          <D.39116>:
          iftmp.810 = 1;
          goto <D.39118>;
          <D.39117>:
          iftmp.810 = 0;
          <D.39118>:
          D.39120 = iftmp.810 != 0;
          D.39121 = (long int) D.39120;
          D.39122 = __builtin_expect (D.39121, 0);
          if (D.39122 != 0) goto <D.39123>; else goto <D.39124>;
          <D.39123>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11825, "inflated_field && !strcmp (field->name, inflated_field->name)");
          <D.39124>:
          result = inflated_field;
        }
      finally
        {
          iter = {CLOBBER};
        }
    }
    goto <D.39125>;
    <D.39110>:
    result = field;
    <D.39125>:
    D.39126 = mono_defaults.fieldhandle_class;
    *handle_class = D.39126;
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.39127>; else goto <D.39128>;
    <D.39127>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11831, "result");
    <D.39128>:
  }
  goto <D.39129>;
  <D.39107>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39133 = "FieldBuilder";
      D.39134 = MEM[(const unsigned char *)D.39133];
      D.39135 = (int) D.39134;
      D.39136 = *__s2;
      D.39137 = (int) D.39136;
      __result = D.39135 - D.39137;
      {
        if (__s2_len != 0) goto <D.39138>; else goto <D.39139>;
        <D.39138>:
        if (__result == 0) goto <D.39140>; else goto <D.39141>;
        <D.39140>:
        D.39142 = &MEM[(void *)"FieldBuilder" + 1B];
        D.39143 = *D.39142;
        D.39144 = (int) D.39143;
        D.39145 = __s2 + 1;
        D.39146 = *D.39145;
        D.39147 = (int) D.39146;
        __result = D.39144 - D.39147;
        if (__s2_len > 1) goto <D.39148>; else goto <D.39149>;
        <D.39148>:
        if (__result == 0) goto <D.39150>; else goto <D.39151>;
        <D.39150>:
        D.39152 = &MEM[(void *)"FieldBuilder" + 2B];
        D.39153 = *D.39152;
        D.39154 = (int) D.39153;
        D.39155 = __s2 + 2;
        D.39156 = *D.39155;
        D.39157 = (int) D.39156;
        __result = D.39154 - D.39157;
        if (__s2_len > 2) goto <D.39158>; else goto <D.39159>;
        <D.39158>:
        if (__result == 0) goto <D.39160>; else goto <D.39161>;
        <D.39160>:
        D.39162 = &MEM[(void *)"FieldBuilder" + 3B];
        D.39163 = *D.39162;
        D.39164 = (int) D.39163;
        D.39165 = __s2 + 3;
        D.39166 = *D.39165;
        D.39167 = (int) D.39166;
        __result = D.39164 - D.39167;
        <D.39161>:
        <D.39159>:
        <D.39151>:
        <D.39149>:
        <D.39141>:
        <D.39139>:
      }
      D.23519 = __result;
    }
    iftmp.811 = -D.23519;
    goto <D.39168>;
    <D.39132>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.811 = __builtin_strcmp (D.38744, "FieldBuilder");
    <D.39168>:
    D.23520 = iftmp.811;
  }
  if (D.23520 == 0) goto <D.39169>; else goto <D.39170>;
  <D.39169>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    result = fb->handle;
    if (result == 0B) goto <D.39171>; else goto <D.39172>;
    <D.39171>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = fb->typeb;
      D.39173 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39173, 0B, tb);
      result = fb->handle;
    }
    <D.39172>:
    D.39174 = fb->handle;
    if (D.39174 != 0B) goto <D.39175>; else goto <D.39176>;
    <D.39175>:
    D.39174 = fb->handle;
    D.39177 = D.39174->parent;
    D.39178 = D.39177->generic_container;
    if (D.39178 != 0B) goto <D.39179>; else goto <D.39180>;
    <D.39179>:
    {
      struct MonoClass * klass;
      struct MonoType * type;
      struct MonoClass * inflated;

      D.39174 = fb->handle;
      klass = D.39174->parent;
      D.39181 = &klass->byval_arg;
      type = mono_class_inflate_generic_type (D.39181, context);
      inflated = mono_class_from_mono_type (type);
      D.39174 = fb->handle;
      D.39182 = mono_field_get_name (D.39174);
      result = mono_class_get_field_from_name (inflated, D.39182);
      D.38748 = result == 0B;
      D.38749 = (long int) D.38748;
      D.38750 = __builtin_expect (D.38749, 0);
      if (D.38750 != 0) goto <D.39183>; else goto <D.39184>;
      <D.39183>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11849, "result");
      <D.39184>:
      mono_metadata_free_type (type);
    }
    <D.39180>:
    <D.39176>:
    D.39126 = mono_defaults.fieldhandle_class;
    *handle_class = D.39126;
  }
  goto <D.39185>;
  <D.39170>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39189 = "TypeBuilder";
      D.39190 = MEM[(const unsigned char *)D.39189];
      D.39191 = (int) D.39190;
      D.39192 = *__s2;
      D.39193 = (int) D.39192;
      __result = D.39191 - D.39193;
      {
        if (__s2_len != 0) goto <D.39194>; else goto <D.39195>;
        <D.39194>:
        if (__result == 0) goto <D.39196>; else goto <D.39197>;
        <D.39196>:
        D.39198 = &MEM[(void *)"TypeBuilder" + 1B];
        D.39199 = *D.39198;
        D.39200 = (int) D.39199;
        D.39201 = __s2 + 1;
        D.39202 = *D.39201;
        D.39203 = (int) D.39202;
        __result = D.39200 - D.39203;
        if (__s2_len > 1) goto <D.39204>; else goto <D.39205>;
        <D.39204>:
        if (__result == 0) goto <D.39206>; else goto <D.39207>;
        <D.39206>:
        D.39208 = &MEM[(void *)"TypeBuilder" + 2B];
        D.39209 = *D.39208;
        D.39210 = (int) D.39209;
        D.39211 = __s2 + 2;
        D.39212 = *D.39211;
        D.39213 = (int) D.39212;
        __result = D.39210 - D.39213;
        if (__s2_len > 2) goto <D.39214>; else goto <D.39215>;
        <D.39214>:
        if (__result == 0) goto <D.39216>; else goto <D.39217>;
        <D.39216>:
        D.39218 = &MEM[(void *)"TypeBuilder" + 3B];
        D.39219 = *D.39218;
        D.39220 = (int) D.39219;
        D.39221 = __s2 + 3;
        D.39222 = *D.39221;
        D.39223 = (int) D.39222;
        __result = D.39220 - D.39223;
        <D.39217>:
        <D.39215>:
        <D.39207>:
        <D.39205>:
        <D.39197>:
        <D.39195>:
      }
      D.23533 = __result;
    }
    iftmp.812 = -D.23533;
    goto <D.39224>;
    <D.39188>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.812 = __builtin_strcmp (D.38744, "TypeBuilder");
    <D.39224>:
    D.23534 = iftmp.812;
  }
  if (D.23534 == 0) goto <D.39225>; else goto <D.39226>;
  <D.39225>:
  {
    struct MonoReflectionTypeBuilder * tb;
    struct MonoType * type;
    struct MonoClass * klass;

    tb = obj;
    type = mono_reflection_type_get_handle (tb);
    klass = type->data.klass;
    D.39227 = BIT_FIELD_REF <*klass, 32, 160>;
    D.39228 = D.39227 & 128;
    if (D.39228 != 0) goto <D.39229>; else goto <D.39230>;
    <D.39229>:
    result = klass;
    goto <D.39231>;
    <D.39230>:
    D.39232 = mono_domain_get ();
    mono_domain_try_type_resolve (D.39232, 0B, tb);
    result = type->data.klass;
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.39233>; else goto <D.39234>;
    <D.39233>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11866, "result");
    <D.39234>:
    <D.39231>:
    D.38802 = mono_defaults.typehandle_class;
    *handle_class = D.38802;
  }
  goto <D.39235>;
  <D.39226>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39239 = "SignatureHelper";
      D.39240 = MEM[(const unsigned char *)D.39239];
      D.39241 = (int) D.39240;
      D.39242 = *__s2;
      D.39243 = (int) D.39242;
      __result = D.39241 - D.39243;
      {
        if (__s2_len != 0) goto <D.39244>; else goto <D.39245>;
        <D.39244>:
        if (__result == 0) goto <D.39246>; else goto <D.39247>;
        <D.39246>:
        D.39248 = &MEM[(void *)"SignatureHelper" + 1B];
        D.39249 = *D.39248;
        D.39250 = (int) D.39249;
        D.39251 = __s2 + 1;
        D.39252 = *D.39251;
        D.39253 = (int) D.39252;
        __result = D.39250 - D.39253;
        if (__s2_len > 1) goto <D.39254>; else goto <D.39255>;
        <D.39254>:
        if (__result == 0) goto <D.39256>; else goto <D.39257>;
        <D.39256>:
        D.39258 = &MEM[(void *)"SignatureHelper" + 2B];
        D.39259 = *D.39258;
        D.39260 = (int) D.39259;
        D.39261 = __s2 + 2;
        D.39262 = *D.39261;
        D.39263 = (int) D.39262;
        __result = D.39260 - D.39263;
        if (__s2_len > 2) goto <D.39264>; else goto <D.39265>;
        <D.39264>:
        if (__result == 0) goto <D.39266>; else goto <D.39267>;
        <D.39266>:
        D.39268 = &MEM[(void *)"SignatureHelper" + 3B];
        D.39269 = *D.39268;
        D.39270 = (int) D.39269;
        D.39271 = __s2 + 3;
        D.39272 = *D.39271;
        D.39273 = (int) D.39272;
        __result = D.39270 - D.39273;
        <D.39267>:
        <D.39265>:
        <D.39257>:
        <D.39255>:
        <D.39247>:
        <D.39245>:
      }
      D.23545 = __result;
    }
    iftmp.813 = -D.23545;
    goto <D.39274>;
    <D.39238>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.813 = __builtin_strcmp (D.38744, "SignatureHelper");
    <D.39274>:
    D.23546 = iftmp.813;
  }
  if (D.23546 == 0) goto <D.39275>; else goto <D.39276>;
  <D.39275>:
  {
    struct MonoReflectionSigHelper * helper;
    struct MonoMethodSignature * sig;
    int nargs;
    int i;

    helper = obj;
    D.39277 = helper->arguments;
    if (D.39277 != 0B) goto <D.39278>; else goto <D.39279>;
    <D.39278>:
    D.39277 = helper->arguments;
    D.39280 = mono_array_length (D.39277);
    nargs = (int) D.39280;
    goto <D.39281>;
    <D.39279>:
    nargs = 0;
    <D.39281>:
    nargs.814 = (unsigned int) nargs;
    sig = mono_metadata_signature_alloc (image, nargs.814);
    D.39283 = helper->call_conv;
    D.39284 = D.39283 & 64;
    D.39285 = D.39284 != 0;
    sig->explicit_this = D.39285;
    D.39283 = helper->call_conv;
    D.39286 = D.39283 & 32;
    D.39287 = D.39286 != 0;
    sig->hasthis = D.39287;
    D.39288 = helper->unmanaged_call_conv;
    if (D.39288 != 0) goto <D.39289>; else goto <D.39290>;
    <D.39289>:
    D.39288 = helper->unmanaged_call_conv;
    D.39291 = (unsigned char) D.39288;
    D.39292 = D.39291 + 255;
    D.39293 = (<unnamed-unsigned:6>) D.39292;
    sig->call_convention = D.39293;
    sig->pinvoke = 1;
    goto <D.39294>;
    <D.39290>:
    D.39283 = helper->call_conv;
    D.39295 = D.39283 & 2;
    if (D.39295 != 0) goto <D.39296>; else goto <D.39297>;
    <D.39296>:
    sig->call_convention = 5;
    goto <D.39298>;
    <D.39297>:
    sig->call_convention = 0;
    <D.39298>:
    <D.39294>:
    D.39299 = (short unsigned int) nargs;
    sig->param_count = D.39299;
    D.39300 = helper->return_type;
    D.39301 = D.39300->type;
    sig->ret = D.39301;
    i = 0;
    goto <D.23552>;
    <D.23551>:
    D.39277 = helper->arguments;
    i.815 = (unsigned int) i;
    D.39303 = mono_array_addr_with_size (D.39277, 4, i.815);
    D.39304 = MEM[(void * *)D.39303];
    D.39305 = mono_reflection_type_get_handle (D.39304);
    sig->params[i] = D.39305;
    i = i + 1;
    <D.23552>:
    if (i < nargs) goto <D.23551>; else goto <D.23553>;
    <D.23553>:
    result = sig;
    *handle_class = 0B;
  }
  goto <D.39306>;
  <D.39276>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39310 = "DynamicMethod";
      D.39311 = MEM[(const unsigned char *)D.39310];
      D.39312 = (int) D.39311;
      D.39313 = *__s2;
      D.39314 = (int) D.39313;
      __result = D.39312 - D.39314;
      {
        if (__s2_len != 0) goto <D.39315>; else goto <D.39316>;
        <D.39315>:
        if (__result == 0) goto <D.39317>; else goto <D.39318>;
        <D.39317>:
        D.39319 = &MEM[(void *)"DynamicMethod" + 1B];
        D.39320 = *D.39319;
        D.39321 = (int) D.39320;
        D.39322 = __s2 + 1;
        D.39323 = *D.39322;
        D.39324 = (int) D.39323;
        __result = D.39321 - D.39324;
        if (__s2_len > 1) goto <D.39325>; else goto <D.39326>;
        <D.39325>:
        if (__result == 0) goto <D.39327>; else goto <D.39328>;
        <D.39327>:
        D.39329 = &MEM[(void *)"DynamicMethod" + 2B];
        D.39330 = *D.39329;
        D.39331 = (int) D.39330;
        D.39332 = __s2 + 2;
        D.39333 = *D.39332;
        D.39334 = (int) D.39333;
        __result = D.39331 - D.39334;
        if (__s2_len > 2) goto <D.39335>; else goto <D.39336>;
        <D.39335>:
        if (__result == 0) goto <D.39337>; else goto <D.39338>;
        <D.39337>:
        D.39339 = &MEM[(void *)"DynamicMethod" + 3B];
        D.39340 = *D.39339;
        D.39341 = (int) D.39340;
        D.39342 = __s2 + 3;
        D.39343 = *D.39342;
        D.39344 = (int) D.39343;
        __result = D.39341 - D.39344;
        <D.39338>:
        <D.39336>:
        <D.39328>:
        <D.39326>:
        <D.39318>:
        <D.39316>:
      }
      D.23561 = __result;
    }
    iftmp.816 = -D.23561;
    goto <D.39345>;
    <D.39309>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.816 = __builtin_strcmp (D.38744, "DynamicMethod");
    <D.39345>:
    D.23562 = iftmp.816;
  }
  if (D.23562 == 0) goto <D.39346>; else goto <D.39347>;
  <D.39346>:
  {
    struct MonoReflectionDynamicMethod * method;

    method = obj;
    D.39348 = method->mhandle;
    D.39349 = D.39348 == 0B;
    D.39350 = (long int) D.39349;
    D.39351 = __builtin_expect (D.39350, 0);
    if (D.39351 != 0) goto <D.39352>; else goto <D.39353>;
    <D.39352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11903, "method->mhandle");
    <D.39353>:
    result = method->mhandle;
    D.38970 = mono_defaults.methodhandle_class;
    *handle_class = D.38970;
  }
  goto <D.39354>;
  <D.39347>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39358 = "GenericTypeParameterBuilder";
      D.39359 = MEM[(const unsigned char *)D.39358];
      D.39360 = (int) D.39359;
      D.39361 = *__s2;
      D.39362 = (int) D.39361;
      __result = D.39360 - D.39362;
      {
        if (__s2_len != 0) goto <D.39363>; else goto <D.39364>;
        <D.39363>:
        if (__result == 0) goto <D.39365>; else goto <D.39366>;
        <D.39365>:
        D.39367 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.39368 = *D.39367;
        D.39369 = (int) D.39368;
        D.39370 = __s2 + 1;
        D.39371 = *D.39370;
        D.39372 = (int) D.39371;
        __result = D.39369 - D.39372;
        if (__s2_len > 1) goto <D.39373>; else goto <D.39374>;
        <D.39373>:
        if (__result == 0) goto <D.39375>; else goto <D.39376>;
        <D.39375>:
        D.39377 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.39378 = *D.39377;
        D.39379 = (int) D.39378;
        D.39380 = __s2 + 2;
        D.39381 = *D.39380;
        D.39382 = (int) D.39381;
        __result = D.39379 - D.39382;
        if (__s2_len > 2) goto <D.39383>; else goto <D.39384>;
        <D.39383>:
        if (__result == 0) goto <D.39385>; else goto <D.39386>;
        <D.39385>:
        D.39387 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.39388 = *D.39387;
        D.39389 = (int) D.39388;
        D.39390 = __s2 + 3;
        D.39391 = *D.39390;
        D.39392 = (int) D.39391;
        __result = D.39389 - D.39392;
        <D.39386>:
        <D.39384>:
        <D.39376>:
        <D.39374>:
        <D.39366>:
        <D.39364>:
      }
      D.23571 = __result;
    }
    iftmp.817 = -D.23571;
    goto <D.39393>;
    <D.39357>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.817 = __builtin_strcmp (D.38744, "GenericTypeParameterBuilder");
    <D.39393>:
    D.23572 = iftmp.817;
  }
  if (D.23572 == 0) goto <D.39394>; else goto <D.39395>;
  <D.39394>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    type = mono_class_inflate_generic_type (type, context);
    result = mono_class_from_mono_type (type);
    D.38802 = mono_defaults.typehandle_class;
    *handle_class = D.38802;
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.39396>; else goto <D.39397>;
    <D.39396>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11911, "result");
    <D.39397>:
    mono_metadata_free_type (type);
  }
  goto <D.39398>;
  <D.39395>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39402 = "MonoGenericClass";
      D.39403 = MEM[(const unsigned char *)D.39402];
      D.39404 = (int) D.39403;
      D.39405 = *__s2;
      D.39406 = (int) D.39405;
      __result = D.39404 - D.39406;
      {
        if (__s2_len != 0) goto <D.39407>; else goto <D.39408>;
        <D.39407>:
        if (__result == 0) goto <D.39409>; else goto <D.39410>;
        <D.39409>:
        D.39411 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.39412 = *D.39411;
        D.39413 = (int) D.39412;
        D.39414 = __s2 + 1;
        D.39415 = *D.39414;
        D.39416 = (int) D.39415;
        __result = D.39413 - D.39416;
        if (__s2_len > 1) goto <D.39417>; else goto <D.39418>;
        <D.39417>:
        if (__result == 0) goto <D.39419>; else goto <D.39420>;
        <D.39419>:
        D.39421 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.39422 = *D.39421;
        D.39423 = (int) D.39422;
        D.39424 = __s2 + 2;
        D.39425 = *D.39424;
        D.39426 = (int) D.39425;
        __result = D.39423 - D.39426;
        if (__s2_len > 2) goto <D.39427>; else goto <D.39428>;
        <D.39427>:
        if (__result == 0) goto <D.39429>; else goto <D.39430>;
        <D.39429>:
        D.39431 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.39432 = *D.39431;
        D.39433 = (int) D.39432;
        D.39434 = __s2 + 3;
        D.39435 = *D.39434;
        D.39436 = (int) D.39435;
        __result = D.39433 - D.39436;
        <D.39430>:
        <D.39428>:
        <D.39420>:
        <D.39418>:
        <D.39410>:
        <D.39408>:
      }
      D.23581 = __result;
    }
    iftmp.818 = -D.23581;
    goto <D.39437>;
    <D.39401>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.818 = __builtin_strcmp (D.38744, "MonoGenericClass");
    <D.39437>:
    D.23582 = iftmp.818;
  }
  if (D.23582 == 0) goto <D.39438>; else goto <D.39439>;
  <D.39438>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    type = mono_class_inflate_generic_type (type, context);
    result = mono_class_from_mono_type (type);
    D.38802 = mono_defaults.typehandle_class;
    *handle_class = D.38802;
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.39440>; else goto <D.39441>;
    <D.39440>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11918, "result");
    <D.39441>:
    mono_metadata_free_type (type);
  }
  goto <D.39442>;
  <D.39439>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39446 = "FieldOnTypeBuilderInst";
      D.39447 = MEM[(const unsigned char *)D.39446];
      D.39448 = (int) D.39447;
      D.39449 = *__s2;
      D.39450 = (int) D.39449;
      __result = D.39448 - D.39450;
      {
        if (__s2_len != 0) goto <D.39451>; else goto <D.39452>;
        <D.39451>:
        if (__result == 0) goto <D.39453>; else goto <D.39454>;
        <D.39453>:
        D.39455 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.39456 = *D.39455;
        D.39457 = (int) D.39456;
        D.39458 = __s2 + 1;
        D.39459 = *D.39458;
        D.39460 = (int) D.39459;
        __result = D.39457 - D.39460;
        if (__s2_len > 1) goto <D.39461>; else goto <D.39462>;
        <D.39461>:
        if (__result == 0) goto <D.39463>; else goto <D.39464>;
        <D.39463>:
        D.39465 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.39466 = *D.39465;
        D.39467 = (int) D.39466;
        D.39468 = __s2 + 2;
        D.39469 = *D.39468;
        D.39470 = (int) D.39469;
        __result = D.39467 - D.39470;
        if (__s2_len > 2) goto <D.39471>; else goto <D.39472>;
        <D.39471>:
        if (__result == 0) goto <D.39473>; else goto <D.39474>;
        <D.39473>:
        D.39475 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.39476 = *D.39475;
        D.39477 = (int) D.39476;
        D.39478 = __s2 + 3;
        D.39479 = *D.39478;
        D.39480 = (int) D.39479;
        __result = D.39477 - D.39480;
        <D.39474>:
        <D.39472>:
        <D.39464>:
        <D.39462>:
        <D.39454>:
        <D.39452>:
      }
      D.23591 = __result;
    }
    iftmp.819 = -D.23591;
    goto <D.39481>;
    <D.39445>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.819 = __builtin_strcmp (D.38744, "FieldOnTypeBuilderInst");
    <D.39481>:
    D.23592 = iftmp.819;
  }
  if (D.23592 == 0) goto <D.39482>; else goto <D.39483>;
  <D.39482>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;
    struct MonoClass * inflated;
    struct MonoType * type;
    struct MonoClassField * field;

    f = obj;
    D.39484 = f->fb;
    D.39485 = D.39484->vtable;
    D.39486 = D.39485->klass;
    D.39487 = is_sre_field_builder (D.39486);
    if (D.39487 != 0) goto <D.39488>; else goto <D.39489>;
    <D.39488>:
    D.39484 = f->fb;
    field = MEM[(struct MonoReflectionFieldBuilder *)D.39484].handle;
    goto <D.39490>;
    <D.39489>:
    D.39484 = f->fb;
    D.39485 = D.39484->vtable;
    D.39486 = D.39485->klass;
    D.39491 = is_sr_mono_field (D.39486);
    if (D.39491 != 0) goto <D.39492>; else goto <D.39493>;
    <D.39492>:
    D.39484 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.39484].field;
    goto <D.39494>;
    <D.39493>:
    D.39484 = f->fb;
    D.39485 = D.39484->vtable;
    D.39486 = D.39485->klass;
    D.39495 = mono_type_get_full_name (D.39486);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a FTBI with base_method of type %s", D.39495);
    <D.23597>:
    goto <D.23597>;
    <D.39494>:
    <D.39490>:
    D.39496 = f->inst;
    D.39497 = mono_reflection_type_get_handle (D.39496);
    type = mono_class_inflate_generic_type (D.39497, context);
    inflated = mono_class_from_mono_type (type);
    D.39498 = mono_field_get_name (field);
    field = mono_class_get_field_from_name (inflated, D.39498);
    result = field;
    D.39499 = field->parent;
    ensure_complete_type (D.39499);
    D.38748 = result == 0B;
    D.38749 = (long int) D.38748;
    D.38750 = __builtin_expect (D.38749, 0);
    if (D.38750 != 0) goto <D.39500>; else goto <D.39501>;
    <D.39500>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11938, "result");
    <D.39501>:
    mono_metadata_free_type (type);
    D.39126 = mono_defaults.fieldhandle_class;
    *handle_class = D.39126;
  }
  goto <D.39502>;
  <D.39483>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39506 = "ConstructorOnTypeBuilderInst";
      D.39507 = MEM[(const unsigned char *)D.39506];
      D.39508 = (int) D.39507;
      D.39509 = *__s2;
      D.39510 = (int) D.39509;
      __result = D.39508 - D.39510;
      {
        if (__s2_len != 0) goto <D.39511>; else goto <D.39512>;
        <D.39511>:
        if (__result == 0) goto <D.39513>; else goto <D.39514>;
        <D.39513>:
        D.39515 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.39516 = *D.39515;
        D.39517 = (int) D.39516;
        D.39518 = __s2 + 1;
        D.39519 = *D.39518;
        D.39520 = (int) D.39519;
        __result = D.39517 - D.39520;
        if (__s2_len > 1) goto <D.39521>; else goto <D.39522>;
        <D.39521>:
        if (__result == 0) goto <D.39523>; else goto <D.39524>;
        <D.39523>:
        D.39525 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.39526 = *D.39525;
        D.39527 = (int) D.39526;
        D.39528 = __s2 + 2;
        D.39529 = *D.39528;
        D.39530 = (int) D.39529;
        __result = D.39527 - D.39530;
        if (__s2_len > 2) goto <D.39531>; else goto <D.39532>;
        <D.39531>:
        if (__result == 0) goto <D.39533>; else goto <D.39534>;
        <D.39533>:
        D.39535 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.39536 = *D.39535;
        D.39537 = (int) D.39536;
        D.39538 = __s2 + 3;
        D.39539 = *D.39538;
        D.39540 = (int) D.39539;
        __result = D.39537 - D.39540;
        <D.39534>:
        <D.39532>:
        <D.39524>:
        <D.39522>:
        <D.39514>:
        <D.39512>:
      }
      D.23605 = __result;
    }
    iftmp.820 = -D.23605;
    goto <D.39541>;
    <D.39505>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.820 = __builtin_strcmp (D.38744, "ConstructorOnTypeBuilderInst");
    <D.39541>:
    D.23606 = iftmp.820;
  }
  if (D.23606 == 0) goto <D.39542>; else goto <D.39543>;
  <D.39542>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;
    struct MonoType * type;
    struct MonoClass * inflated_klass;
    struct MonoMethod * method;

    c = obj;
    D.39544 = c->inst;
    D.39545 = mono_reflection_type_get_handle (D.39544);
    type = mono_class_inflate_generic_type (D.39545, context);
    inflated_klass = mono_class_from_mono_type (type);
    D.39546 = c->cb;
    D.39547 = D.39546->vtable;
    D.39548 = D.39547->klass;
    D.39549 = is_sre_ctor_builder (D.39548);
    if (D.39549 != 0) goto <D.39550>; else goto <D.39551>;
    <D.39550>:
    D.39546 = c->cb;
    method = MEM[(struct MonoReflectionCtorBuilder *)D.39546].mhandle;
    goto <D.39552>;
    <D.39551>:
    D.39546 = c->cb;
    D.39547 = D.39546->vtable;
    D.39548 = D.39547->klass;
    D.39553 = is_sr_mono_cmethod (D.39548);
    if (D.39553 != 0) goto <D.39554>; else goto <D.39555>;
    <D.39554>:
    D.39546 = c->cb;
    method = MEM[(struct MonoReflectionMethod *)D.39546].method;
    goto <D.39556>;
    <D.39555>:
    D.39546 = c->cb;
    D.39547 = D.39546->vtable;
    D.39548 = D.39547->klass;
    D.39557 = mono_type_get_full_name (D.39548);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a CTBI with base_method of type %s", D.39557);
    <D.23611>:
    goto <D.23611>;
    <D.39556>:
    <D.39552>:
    D.39546 = c->cb;
    result = inflate_mono_method (inflated_klass, method, D.39546);
    D.38970 = mono_defaults.methodhandle_class;
    *handle_class = D.38970;
    mono_metadata_free_type (type);
  }
  goto <D.39558>;
  <D.39543>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39562 = "MethodOnTypeBuilderInst";
      D.39563 = MEM[(const unsigned char *)D.39562];
      D.39564 = (int) D.39563;
      D.39565 = *__s2;
      D.39566 = (int) D.39565;
      __result = D.39564 - D.39566;
      {
        if (__s2_len != 0) goto <D.39567>; else goto <D.39568>;
        <D.39567>:
        if (__result == 0) goto <D.39569>; else goto <D.39570>;
        <D.39569>:
        D.39571 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.39572 = *D.39571;
        D.39573 = (int) D.39572;
        D.39574 = __s2 + 1;
        D.39575 = *D.39574;
        D.39576 = (int) D.39575;
        __result = D.39573 - D.39576;
        if (__s2_len > 1) goto <D.39577>; else goto <D.39578>;
        <D.39577>:
        if (__result == 0) goto <D.39579>; else goto <D.39580>;
        <D.39579>:
        D.39581 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.39582 = *D.39581;
        D.39583 = (int) D.39582;
        D.39584 = __s2 + 2;
        D.39585 = *D.39584;
        D.39586 = (int) D.39585;
        __result = D.39583 - D.39586;
        if (__s2_len > 2) goto <D.39587>; else goto <D.39588>;
        <D.39587>:
        if (__result == 0) goto <D.39589>; else goto <D.39590>;
        <D.39589>:
        D.39591 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.39592 = *D.39591;
        D.39593 = (int) D.39592;
        D.39594 = __s2 + 3;
        D.39595 = *D.39594;
        D.39596 = (int) D.39595;
        __result = D.39593 - D.39596;
        <D.39590>:
        <D.39588>:
        <D.39580>:
        <D.39578>:
        <D.39570>:
        <D.39568>:
      }
      D.23619 = __result;
    }
    iftmp.821 = -D.23619;
    goto <D.39597>;
    <D.39561>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.821 = __builtin_strcmp (D.38744, "MethodOnTypeBuilderInst");
    <D.39597>:
    D.23620 = iftmp.821;
  }
  if (D.23620 == 0) goto <D.39598>; else goto <D.39599>;
  <D.39598>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    D.39600 = m->method_args;
    if (D.39600 != 0B) goto <D.39601>; else goto <D.39602>;
    <D.39601>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    if (context != 0B) goto <D.39603>; else goto <D.39604>;
    <D.39603>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39604>:
    goto <D.39605>;
    <D.39602>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * method;

      D.39606 = m->inst;
      D.39607 = mono_reflection_type_get_handle (D.39606);
      type = mono_class_inflate_generic_type (D.39607, context);
      inflated_klass = mono_class_from_mono_type (type);
      D.39608 = m->mb;
      D.39609 = D.39608->vtable;
      D.39610 = D.39609->klass;
      D.39611 = is_sre_method_builder (D.39610);
      if (D.39611 != 0) goto <D.39612>; else goto <D.39613>;
      <D.39612>:
      D.39608 = m->mb;
      method = MEM[(struct MonoReflectionMethodBuilder *)D.39608].mhandle;
      goto <D.39614>;
      <D.39613>:
      D.39608 = m->mb;
      D.39609 = D.39608->vtable;
      D.39610 = D.39609->klass;
      D.39615 = is_sr_mono_method (D.39610);
      if (D.39615 != 0) goto <D.39616>; else goto <D.39617>;
      <D.39616>:
      D.39608 = m->mb;
      method = MEM[(struct MonoReflectionMethod *)D.39608].method;
      goto <D.39618>;
      <D.39617>:
      D.39608 = m->mb;
      D.39609 = D.39608->vtable;
      D.39610 = D.39609->klass;
      D.39619 = mono_type_get_full_name (D.39610);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.39619);
      <D.23625>:
      goto <D.23625>;
      <D.39618>:
      <D.39614>:
      D.39608 = m->mb;
      result = inflate_mono_method (inflated_klass, method, D.39608);
      mono_metadata_free_type (type);
    }
    <D.39605>:
    D.38970 = mono_defaults.methodhandle_class;
    *handle_class = D.38970;
  }
  goto <D.39620>;
  <D.39599>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38706 = obj->vtable;
      D.38707 = D.38706->klass;
      __s2 = D.38707->name;
      D.39624 = "MonoArrayMethod";
      D.39625 = MEM[(const unsigned char *)D.39624];
      D.39626 = (int) D.39625;
      D.39627 = *__s2;
      D.39628 = (int) D.39627;
      __result = D.39626 - D.39628;
      {
        if (__s2_len != 0) goto <D.39629>; else goto <D.39630>;
        <D.39629>:
        if (__result == 0) goto <D.39631>; else goto <D.39632>;
        <D.39631>:
        D.39633 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.39634 = *D.39633;
        D.39635 = (int) D.39634;
        D.39636 = __s2 + 1;
        D.39637 = *D.39636;
        D.39638 = (int) D.39637;
        __result = D.39635 - D.39638;
        if (__s2_len > 1) goto <D.39639>; else goto <D.39640>;
        <D.39639>:
        if (__result == 0) goto <D.39641>; else goto <D.39642>;
        <D.39641>:
        D.39643 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.39644 = *D.39643;
        D.39645 = (int) D.39644;
        D.39646 = __s2 + 2;
        D.39647 = *D.39646;
        D.39648 = (int) D.39647;
        __result = D.39645 - D.39648;
        if (__s2_len > 2) goto <D.39649>; else goto <D.39650>;
        <D.39649>:
        if (__result == 0) goto <D.39651>; else goto <D.39652>;
        <D.39651>:
        D.39653 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.39654 = *D.39653;
        D.39655 = (int) D.39654;
        D.39656 = __s2 + 3;
        D.39657 = *D.39656;
        D.39658 = (int) D.39657;
        __result = D.39655 - D.39658;
        <D.39652>:
        <D.39650>:
        <D.39642>:
        <D.39640>:
        <D.39632>:
        <D.39630>:
      }
      D.23633 = __result;
    }
    iftmp.822 = -D.23633;
    goto <D.39659>;
    <D.39623>:
    D.38706 = obj->vtable;
    D.38707 = D.38706->klass;
    D.38744 = D.38707->name;
    iftmp.822 = __builtin_strcmp (D.38744, "MonoArrayMethod");
    <D.39659>:
    D.23634 = iftmp.822;
  }
  if (D.23634 == 0) goto <D.39660>; else goto <D.39661>;
  <D.39660>:
  {
    struct MonoReflectionArrayMethod * m;
    struct MonoType * mtype;
    struct MonoClass * klass;
    struct MonoMethod * method;
    void * iter;
    char * name;

    try
      {
        m = obj;
        D.39662 = m->parent;
        mtype = mono_reflection_type_get_handle (D.39662);
        klass = mono_class_from_mono_type (mtype);
        D.39663 = m->name;
        name = mono_string_to_utf8 (D.39663);
        iter = 0B;
        goto <D.23652>;
        <D.23651>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.39664 = method->name;
          D.23649 = __builtin_strcmp (D.39664, name);
        }
        if (D.23649 == 0) goto <D.23650>; else goto <D.39665>;
        <D.39665>:
        <D.23652>:
        method = mono_class_get_methods (klass, &iter);
        if (method != 0B) goto <D.23651>; else goto <D.23650>;
        <D.23650>:
        monoeg_g_free (name);
        D.39666 = method == 0B;
        D.39667 = (long int) D.39666;
        D.39668 = __builtin_expect (D.39667, 0);
        if (D.39668 != 0) goto <D.39669>; else goto <D.39670>;
        <D.39669>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12001, "method");
        <D.39670>:
        result = method;
        D.38970 = mono_defaults.methodhandle_class;
        *handle_class = D.38970;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  goto <D.39671>;
  <D.39661>:
  D.39675 = mono_object_get_class (obj);
  D.39676 = is_sre_array (D.39675);
  if (D.39676 != 0) goto <D.39672>; else goto <D.39677>;
  <D.39677>:
  D.39678 = mono_object_get_class (obj);
  D.39679 = is_sre_byref (D.39678);
  if (D.39679 != 0) goto <D.39672>; else goto <D.39680>;
  <D.39680>:
  D.39681 = mono_object_get_class (obj);
  D.39682 = is_sre_pointer (D.39681);
  if (D.39682 != 0) goto <D.39672>; else goto <D.39673>;
  <D.39672>:
  {
    struct MonoReflectionType * ref_type;
    struct MonoType * type;

    ref_type = obj;
    type = mono_reflection_type_get_handle (ref_type);
    if (context != 0B) goto <D.39683>; else goto <D.39684>;
    <D.39683>:
    {
      struct MonoType * inflated;

      inflated = mono_class_inflate_generic_type (type, context);
      result = mono_class_from_mono_type (inflated);
      mono_metadata_free_type (inflated);
    }
    goto <D.39685>;
    <D.39684>:
    result = mono_class_from_mono_type (type);
    <D.39685>:
    D.38802 = mono_defaults.typehandle_class;
    *handle_class = D.38802;
  }
  goto <D.39674>;
  <D.39673>:
  D.38706 = obj->vtable;
  D.38707 = D.38706->klass;
  D.38744 = D.38707->name;
  monoeg_g_print ("%s\n", D.38744);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12022);
  <D.39674>:
  <D.39671>:
  <D.39620>:
  <D.39558>:
  <D.39502>:
  <D.39442>:
  <D.39398>:
  <D.39354>:
  <D.39306>:
  <D.39235>:
  <D.39185>:
  <D.39129>:
  <D.39066>:
  <D.39019>:
  <D.38808>:
  <D.38805>:
  <D.38753>:
  D.39686 = result;
  return D.39686;
}


ensure_complete_type (struct MonoClass * klass)
{
  struct MonoImage * D.39688;
  unsigned int D.39689;
  unsigned int D.39690;
  unsigned int D.39693;
  unsigned int D.39694;
  void * D.39697;
  struct MonoDomain * D.39700;
  struct MonoGenericClass * D.39701;
  struct MonoType * D.39704;
  struct MonoClass * D.39705;
  <unnamed-unsigned:22> D.39706;
  int D.39707;

  D.39688 = klass->image;
  D.39689 = BIT_FIELD_REF <*D.39688, 32, 128>;
  D.39690 = D.39689 & 8;
  if (D.39690 != 0) goto <D.39691>; else goto <D.39692>;
  <D.39691>:
  D.39693 = BIT_FIELD_REF <*klass, 32, 160>;
  D.39694 = D.39693 & 128;
  if (D.39694 == 0) goto <D.39695>; else goto <D.39696>;
  <D.39695>:
  D.39697 = mono_class_get_ref_info (klass);
  if (D.39697 != 0B) goto <D.39698>; else goto <D.39699>;
  <D.39698>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.39700 = mono_domain_get ();
    mono_domain_try_type_resolve (D.39700, 0B, tb);
  }
  <D.39699>:
  <D.39696>:
  <D.39692>:
  D.39701 = klass->generic_class;
  if (D.39701 != 0B) goto <D.39702>; else goto <D.39703>;
  <D.39702>:
  {
    struct MonoGenericInst * inst;
    int i;

    D.39701 = klass->generic_class;
    inst = D.39701->context.class_inst;
    i = 0;
    goto <D.23389>;
    <D.23388>:
    D.39704 = inst->type_argv[i];
    D.39705 = mono_class_from_mono_type (D.39704);
    ensure_complete_type (D.39705);
    i = i + 1;
    <D.23389>:
    D.39706 = inst->type_argc;
    D.39707 = (int) D.39706;
    if (D.39707 > i) goto <D.23388>; else goto <D.23390>;
    <D.23390>:
  }
  <D.39703>:
}


mono_reflection_is_valid_dynamic_token (struct MonoDynamicImage * image, guint32 token)
{
  gboolean D.39708;
  struct MonoGHashTable * D.39709;
  const void * token.823;
  void * D.39711;
  _Bool D.39712;

  D.39709 = image->tokens;
  token.823 = (const void *) token;
  D.39711 = mono_g_hash_table_lookup (D.39709, token.823);
  D.39712 = D.39711 != 0B;
  D.39708 = (gboolean) D.39712;
  return D.39708;
}


mono_reflection_lookup_signature (struct MonoImage * image, struct MonoMethod * method, guint32 token)
{
  unsigned int D.39714;
  unsigned int D.39715;
  _Bool D.39716;
  long int D.39717;
  long int D.39718;
  struct GHashTable * D.39721;
  const void * token.824;
  struct MonoMethodSignature * D.39725;
  struct MonoMethodSignature * sig;

  D.39714 = BIT_FIELD_REF <*image, 32, 128>;
  D.39715 = D.39714 & 8;
  D.39716 = D.39715 == 0;
  D.39717 = (long int) D.39716;
  D.39718 = __builtin_expect (D.39717, 0);
  if (D.39718 != 0) goto <D.39719>; else goto <D.39720>;
  <D.39719>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11672, "image->dynamic");
  <D.39720>:
  D.39721 = MEM[(struct MonoDynamicImage *)image].vararg_aux_hash;
  token.824 = (const void *) token;
  sig = monoeg_g_hash_table_lookup (D.39721, token.824);
  if (sig != 0B) goto <D.39723>; else goto <D.39724>;
  <D.39723>:
  D.39725 = sig;
  return D.39725;
  <D.39724>:
  D.39725 = mono_method_signature (method);
  return D.39725;
}


mono_reflection_lookup_dynamic_token (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  struct MonoGHashTable * D.39727;
  const void * token.825;
  void * D.39733;
  struct MonoDynamicImage * assembly;
  struct MonoObject * obj;
  struct MonoClass * klass;

  try
    {
      assembly = image;
      mono_loader_lock ();
      D.39727 = assembly->tokens;
      token.825 = (const void *) token;
      obj = mono_g_hash_table_lookup (D.39727, token.825);
      mono_loader_unlock ();
      if (obj == 0B) goto <D.39729>; else goto <D.39730>;
      <D.39729>:
      if (valid_token != 0) goto <D.39731>; else goto <D.39732>;
      <D.39731>:
      monoeg_g_log (0B, 4, "Could not find required dynamic token 0x%08x", token);
      <D.23381>:
      goto <D.23381>;
      <D.39732>:
      D.39733 = 0B;
      return D.39733;
      <D.39730>:
      if (handle_class == 0B) goto <D.39734>; else goto <D.39735>;
      <D.39734>:
      handle_class = &klass;
      <D.39735>:
      D.39733 = resolve_object (image, obj, handle_class, context);
      return D.39733;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


mono_declsec_flags_from_method (struct MonoMethod * method)
{
  short unsigned int D.39738;
  int D.39739;
  int D.39740;
  uint32_t D.39743;
  struct MonoClass * D.39744;
  struct MonoImage * D.39745;

  D.39738 = method->flags;
  D.39739 = (int) D.39738;
  D.39740 = D.39739 & 16384;
  if (D.39740 != 0) goto <D.39741>; else goto <D.39742>;
  <D.39741>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.39744 = method->klass;
    D.39745 = D.39744->image;
    D.39743 = mono_declsec_get_flags (D.39745, idx);
    return D.39743;
  }
  <D.39742>:
  D.39743 = 0;
  return D.39743;
}


mono_declsec_get_flags (struct MonoImage * image, guint32 token)
{
  unsigned int D.39747;
  guint32 D.39750;
  unsigned int D.39751;
  unsigned int D.39753;
  unsigned int D.39756;
  <unnamed-unsigned:24> D.39758;
  int D.39759;
  int index;
  struct MonoTableInfo * t;
  guint32 result;
  guint32 action;
  int i;

  D.39747 = mono_metadata_declsec_from_index (image, token);
  index = (int) D.39747;
  t = &image->tables[14];
  result = 0;
  if (index < 0) goto <D.39748>; else goto <D.39749>;
  <D.39748>:
  D.39750 = 0;
  return D.39750;
  <D.39749>:
  i = index;
  goto <D.23669>;
  <D.23668>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.39751 = cols[1];
        if (D.39751 != token) goto <D.23667>; else goto <D.39752>;
        <D.39752>:
        action = cols[0];
        D.39753 = action + 4294967295;
        if (D.39753 <= 17) goto <D.39754>; else goto <D.39755>;
        <D.39754>:
        D.39756 = declsec_flags_map[action];
        result = D.39756 | result;
        goto <D.39757>;
        <D.39755>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12239);
        <D.39757>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.23669>:
  D.39758 = t->rows;
  D.39759 = (int) D.39758;
  if (D.39759 > i) goto <D.23668>; else goto <D.23667>;
  <D.23667>:
  D.39750 = result;
  return D.39750;
}


mono_declsec_flags_from_class (struct MonoClass * klass)
{
  unsigned int D.39763;
  unsigned int D.39764;
  struct MonoClassExt * D.39769;
  unsigned int D.39771;
  unsigned int D.39772;
  struct MonoImage * D.39773;
  unsigned int D.39774;
  uint32_t D.39775;

  D.39763 = klass->flags;
  D.39764 = D.39763 & 262144;
  if (D.39764 != 0) goto <D.39765>; else goto <D.39766>;
  <D.39765>:
  D.39769 = klass->ext;
  if (D.39769 == 0B) goto <D.39767>; else goto <D.39770>;
  <D.39770>:
  D.39769 = klass->ext;
  D.39771 = D.39769->declsec_flags;
  if (D.39771 == 0) goto <D.39767>; else goto <D.39768>;
  <D.39767>:
  {
    guint32 idx;

    D.39772 = klass->type_token;
    idx = D.39772 & 16777215;
    idx = idx << 2;
    idx = idx;
    mono_loader_lock ();
    mono_class_alloc_ext (klass);
    mono_loader_unlock ();
    D.39769 = klass->ext;
    D.39773 = klass->image;
    D.39774 = mono_declsec_get_flags (D.39773, idx);
    D.39769->declsec_flags = D.39774;
  }
  <D.39768>:
  D.39769 = klass->ext;
  D.39775 = D.39769->declsec_flags;
  return D.39775;
  <D.39766>:
  D.39775 = 0;
  return D.39775;
}


mono_declsec_flags_from_assembly (struct MonoAssembly * assembly)
{
  uint32_t D.39777;
  struct MonoImage * D.39778;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.39778 = assembly->image;
  D.39777 = mono_declsec_get_flags (D.39778, idx);
  return D.39777;
}


mono_declsec_get_demands (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.39780;
  struct MonoImage * D.39781;
  unsigned int D.39782;
  unsigned int D.39783;
  MonoBoolean D.39786;
  unsigned int D.39789;
  unsigned int D.39790;
  short unsigned int D.39794;
  int D.39795;
  int D.39796;
  unsigned int D.39799;
  unsigned char D.39804;
  guint32 mask;
  MonoBoolean result;
  guint32 flags;

  mask = 135170;
  result = 0;
  D.39780 = method->klass;
  D.39781 = D.39780->image;
  D.39782 = BIT_FIELD_REF <*D.39781, 32, 2176>;
  D.39783 = D.39782 & 16777215;
  if (D.39783 == 0) goto <D.39784>; else goto <D.39785>;
  <D.39784>:
  D.39786 = 0;
  return D.39786;
  <D.39785>:
  D.39789 = BIT_FIELD_REF <*method, 32, 160>;
  D.39790 = D.39789 & 124;
  if (D.39790 == 24) goto <D.39787>; else goto <D.39791>;
  <D.39791>:
  D.39789 = BIT_FIELD_REF <*method, 32, 160>;
  D.39790 = D.39789 & 124;
  if (D.39790 == 28) goto <D.39787>; else goto <D.39788>;
  <D.39787>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.39792>; else goto <D.39793>;
  <D.39792>:
  D.39786 = 0;
  return D.39786;
  <D.39793>:
  <D.39788>:
  D.39794 = method->flags;
  D.39795 = (int) D.39794;
  D.39796 = D.39795 & 16384;
  if (D.39796 != 0) goto <D.39797>; else goto <D.39798>;
  <D.39797>:
  D.39780 = method->klass;
  mono_class_init (D.39780);
  memset (demands, 0, 36);
  result = mono_declsec_get_method_demands_params (method, demands, 2, 13, 18);
  <D.39798>:
  D.39780 = method->klass;
  flags = mono_declsec_flags_from_class (D.39780);
  D.39799 = flags & mask;
  if (D.39799 != 0) goto <D.39800>; else goto <D.39801>;
  <D.39800>:
  if (result == 0) goto <D.39802>; else goto <D.39803>;
  <D.39802>:
  D.39780 = method->klass;
  mono_class_init (D.39780);
  memset (demands, 0, 36);
  <D.39803>:
  D.39780 = method->klass;
  D.39804 = mono_declsec_get_class_demands_params (D.39780, demands, 2, 13, 18);
  result = D.39804 | result;
  <D.39801>:
  D.39786 = result;
  return D.39786;
}


mono_declsec_get_method_demands_params (struct MonoMethod * method, struct MonoDeclSecurityActions * demands, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  MonoBoolean D.39806;
  struct MonoClass * D.39807;
  struct MonoImage * D.39808;
  guint32 idx;

  idx = mono_method_get_index (method);
  idx = idx << 2;
  idx = idx | 1;
  D.39807 = method->klass;
  D.39808 = D.39807->image;
  D.39806 = fill_actions_from_index (D.39808, idx, demands, id_std, id_noncas, id_choice);
  return D.39806;
}


fill_actions_from_index (struct MonoImage * image, guint32 token, struct MonoDeclSecurityActions * actions, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  unsigned int D.39810;
  unsigned int D.39811;
  MonoBoolean D.39814;
  unsigned int D.39815;
  char * D.39818;
  unsigned int D.39821;
  const char * blob.826;
  const char * blob.827;
  char * D.39824;
  unsigned int D.39825;
  char * D.39829;
  const char * blob.828;
  const char * blob.829;
  char * D.39834;
  unsigned int D.39835;
  char * D.39839;
  const char * blob.830;
  const char * blob.831;
  char * D.39844;
  unsigned int D.39845;
  <unnamed-unsigned:24> D.39846;
  int D.39847;
  MonoBoolean result;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int index;
  int i;

  try
    {
      result = 0;
      D.39810 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.39810;
      t = &image->tables[14];
      i = index;
      goto <D.23699>;
      <D.23698>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.39811 = cols[1];
      if (D.39811 != token) goto <D.39812>; else goto <D.39813>;
      <D.39812>:
      D.39814 = result;
      return D.39814;
      <D.39813>:
      D.39815 = cols[0];
      if (D.39815 == id_std) goto <D.39816>; else goto <D.39817>;
      <D.39816>:
      D.39818 = actions->demand.blob;
      if (D.39818 == 0B) goto <D.39819>; else goto <D.39820>;
      <D.39819>:
      {
        const char * blob;

        try
          {
            D.39821 = cols[2];
            blob.826 = mono_metadata_blob_heap (image, D.39821);
            blob = blob.826;
            D.39821 = cols[2];
            actions->demand.index = D.39821;
            blob.827 = blob;
            D.39824 = blob.827 + 2;
            actions->demand.blob = D.39824;
            blob.827 = blob;
            D.39825 = mono_metadata_decode_blob_size (blob.827, &blob);
            actions->demand.size = D.39825;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.39820>:
      goto <D.39826>;
      <D.39817>:
      D.39815 = cols[0];
      if (D.39815 == id_noncas) goto <D.39827>; else goto <D.39828>;
      <D.39827>:
      D.39829 = actions->noncasdemand.blob;
      if (D.39829 == 0B) goto <D.39830>; else goto <D.39831>;
      <D.39830>:
      {
        const char * blob;

        try
          {
            D.39821 = cols[2];
            blob.828 = mono_metadata_blob_heap (image, D.39821);
            blob = blob.828;
            D.39821 = cols[2];
            actions->noncasdemand.index = D.39821;
            blob.829 = blob;
            D.39834 = blob.829 + 2;
            actions->noncasdemand.blob = D.39834;
            blob.829 = blob;
            D.39835 = mono_metadata_decode_blob_size (blob.829, &blob);
            actions->noncasdemand.size = D.39835;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.39831>:
      goto <D.39836>;
      <D.39828>:
      D.39815 = cols[0];
      if (D.39815 == id_choice) goto <D.39837>; else goto <D.39838>;
      <D.39837>:
      D.39839 = actions->demandchoice.blob;
      if (D.39839 == 0B) goto <D.39840>; else goto <D.39841>;
      <D.39840>:
      {
        const char * blob;

        try
          {
            D.39821 = cols[2];
            blob.830 = mono_metadata_blob_heap (image, D.39821);
            blob = blob.830;
            D.39821 = cols[2];
            actions->demandchoice.index = D.39821;
            blob.831 = blob;
            D.39844 = blob.831 + 2;
            actions->demandchoice.blob = D.39844;
            blob.831 = blob;
            D.39845 = mono_metadata_decode_blob_size (blob.831, &blob);
            actions->demandchoice.size = D.39845;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.39841>:
      <D.39838>:
      <D.39836>:
      <D.39826>:
      i = i + 1;
      <D.23699>:
      D.39846 = t->rows;
      D.39847 = (int) D.39846;
      if (D.39847 > i) goto <D.23698>; else goto <D.23700>;
      <D.23700>:
      D.39814 = result;
      return D.39814;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_declsec_get_class_demands_params (struct MonoClass * klass, struct MonoDeclSecurityActions * demands, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  unsigned int D.39850;
  MonoBoolean D.39851;
  struct MonoImage * D.39852;
  guint32 idx;

  D.39850 = klass->type_token;
  idx = D.39850 & 16777215;
  idx = idx << 2;
  idx = idx;
  D.39852 = klass->image;
  D.39851 = fill_actions_from_index (D.39852, idx, demands, id_std, id_noncas, id_choice);
  return D.39851;
}


mono_declsec_get_linkdemands (struct MonoMethod * method, struct MonoDeclSecurityActions * klass, struct MonoDeclSecurityActions * cmethod)
{
  struct MonoClass * D.39854;
  struct MonoImage * D.39855;
  unsigned int D.39856;
  unsigned int D.39857;
  MonoBoolean D.39860;
  unsigned int D.39863;
  unsigned int D.39864;
  short unsigned int D.39868;
  int D.39869;
  int D.39870;
  unsigned int D.39873;
  unsigned char D.39876;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.39854 = method->klass;
  D.39855 = D.39854->image;
  D.39856 = BIT_FIELD_REF <*D.39855, 32, 2176>;
  D.39857 = D.39856 & 16777215;
  if (D.39857 == 0) goto <D.39858>; else goto <D.39859>;
  <D.39858>:
  D.39860 = 0;
  return D.39860;
  <D.39859>:
  D.39863 = BIT_FIELD_REF <*method, 32, 160>;
  D.39864 = D.39863 & 124;
  if (D.39864 == 24) goto <D.39861>; else goto <D.39865>;
  <D.39865>:
  D.39863 = BIT_FIELD_REF <*method, 32, 160>;
  D.39864 = D.39863 & 124;
  if (D.39864 == 28) goto <D.39861>; else goto <D.39862>;
  <D.39861>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.39866>; else goto <D.39867>;
  <D.39866>:
  D.39860 = 0;
  return D.39860;
  <D.39867>:
  <D.39862>:
  memset (cmethod, 0, 36);
  memset (klass, 0, 36);
  D.39868 = method->flags;
  D.39869 = (int) D.39868;
  D.39870 = D.39869 & 16384;
  if (D.39870 != 0) goto <D.39871>; else goto <D.39872>;
  <D.39871>:
  D.39854 = method->klass;
  mono_class_init (D.39854);
  result = mono_declsec_get_method_demands_params (method, cmethod, 6, 14, 16);
  <D.39872>:
  D.39854 = method->klass;
  flags = mono_declsec_flags_from_class (D.39854);
  D.39873 = flags & 40992;
  if (D.39873 != 0) goto <D.39874>; else goto <D.39875>;
  <D.39874>:
  D.39854 = method->klass;
  mono_class_init (D.39854);
  D.39854 = method->klass;
  D.39876 = mono_declsec_get_class_demands_params (D.39854, klass, 6, 14, 16);
  result = D.39876 | result;
  <D.39875>:
  D.39860 = result;
  return D.39860;
}


mono_declsec_get_inheritdemands_class (struct MonoClass * klass, struct MonoDeclSecurityActions * demands)
{
  struct MonoImage * D.39878;
  unsigned int D.39879;
  unsigned int D.39880;
  MonoBoolean D.39883;
  unsigned int D.39884;
  unsigned char D.39887;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.39878 = klass->image;
  D.39879 = BIT_FIELD_REF <*D.39878, 32, 2176>;
  D.39880 = D.39879 & 16777215;
  if (D.39880 == 0) goto <D.39881>; else goto <D.39882>;
  <D.39881>:
  D.39883 = 0;
  return D.39883;
  <D.39882>:
  flags = mono_declsec_flags_from_class (klass);
  D.39884 = flags & 81984;
  if (D.39884 != 0) goto <D.39885>; else goto <D.39886>;
  <D.39885>:
  mono_class_init (klass);
  memset (demands, 0, 36);
  D.39887 = mono_declsec_get_class_demands_params (klass, demands, 7, 15, 17);
  result = D.39887 | result;
  <D.39886>:
  D.39883 = result;
  return D.39883;
}


mono_declsec_get_inheritdemands_method (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.39889;
  struct MonoImage * D.39890;
  unsigned int D.39891;
  unsigned int D.39892;
  MonoBoolean D.39895;
  unsigned int D.39898;
  unsigned int D.39899;
  short unsigned int D.39903;
  int D.39904;
  int D.39905;

  D.39889 = method->klass;
  D.39890 = D.39889->image;
  D.39891 = BIT_FIELD_REF <*D.39890, 32, 2176>;
  D.39892 = D.39891 & 16777215;
  if (D.39892 == 0) goto <D.39893>; else goto <D.39894>;
  <D.39893>:
  D.39895 = 0;
  return D.39895;
  <D.39894>:
  D.39898 = BIT_FIELD_REF <*method, 32, 160>;
  D.39899 = D.39898 & 124;
  if (D.39899 == 24) goto <D.39896>; else goto <D.39900>;
  <D.39900>:
  D.39898 = BIT_FIELD_REF <*method, 32, 160>;
  D.39899 = D.39898 & 124;
  if (D.39899 == 28) goto <D.39896>; else goto <D.39897>;
  <D.39896>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.39901>; else goto <D.39902>;
  <D.39901>:
  D.39895 = 0;
  return D.39895;
  <D.39902>:
  <D.39897>:
  D.39903 = method->flags;
  D.39904 = (int) D.39903;
  D.39905 = D.39904 & 16384;
  if (D.39905 != 0) goto <D.39906>; else goto <D.39907>;
  <D.39906>:
  D.39889 = method->klass;
  mono_class_init (D.39889);
  memset (demands, 0, 36);
  D.39895 = mono_declsec_get_method_demands_params (method, demands, 7, 15, 17);
  return D.39895;
  <D.39907>:
  D.39895 = 0;
  return D.39895;
}


mono_declsec_get_method_action (struct MonoMethod * method, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  short unsigned int D.39909;
  int D.39910;
  int D.39911;
  MonoBoolean D.39914;
  struct MonoClass * D.39915;
  struct MonoImage * D.39916;

  D.39909 = method->flags;
  D.39910 = (int) D.39909;
  D.39911 = D.39910 & 16384;
  if (D.39911 != 0) goto <D.39912>; else goto <D.39913>;
  <D.39912>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.39915 = method->klass;
    D.39916 = D.39915->image;
    D.39914 = get_declsec_action (D.39916, idx, action, entry);
    return D.39914;
  }
  <D.39913>:
  D.39914 = 0;
  return D.39914;
}


get_declsec_action (struct MonoImage * image, guint32 token, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.39918;
  MonoBoolean D.39921;
  unsigned int D.39922;
  unsigned int D.39925;
  unsigned int D.39928;
  const char * metadata.832;
  const char * metadata.833;
  char * D.39931;
  unsigned int D.39932;
  <unnamed-unsigned:24> D.39933;
  int D.39934;
  guint32 cols[3];
  struct MonoTableInfo * t;
  int i;
  int index;

  try
    {
      D.39918 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.39918;
      if (index == -1) goto <D.39919>; else goto <D.39920>;
      <D.39919>:
      D.39921 = 0;
      return D.39921;
      <D.39920>:
      t = &image->tables[14];
      i = index;
      goto <D.23753>;
      <D.23752>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.39922 = cols[1];
      if (D.39922 != token) goto <D.39923>; else goto <D.39924>;
      <D.39923>:
      D.39921 = 0;
      return D.39921;
      <D.39924>:
      D.39925 = cols[0];
      if (D.39925 == action) goto <D.39926>; else goto <D.39927>;
      <D.39926>:
      {
        const char * metadata;

        try
          {
            D.39928 = cols[2];
            metadata.832 = mono_metadata_blob_heap (image, D.39928);
            metadata = metadata.832;
            metadata.833 = metadata;
            D.39931 = metadata.833 + 2;
            entry->blob = D.39931;
            metadata.833 = metadata;
            D.39932 = mono_metadata_decode_blob_size (metadata.833, &metadata);
            entry->size = D.39932;
            D.39921 = 1;
            return D.39921;
          }
        finally
          {
            metadata = {CLOBBER};
          }
      }
      <D.39927>:
      i = i + 1;
      <D.23753>:
      D.39933 = t->rows;
      D.39934 = (int) D.39933;
      if (D.39934 > i) goto <D.23752>; else goto <D.23754>;
      <D.23754>:
      D.39921 = 0;
      return D.39921;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_declsec_get_class_action (struct MonoClass * klass, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.39938;
  unsigned int D.39939;
  unsigned int D.39942;
  MonoBoolean D.39943;
  struct MonoImage * D.39944;
  guint32 flags;

  flags = mono_declsec_flags_from_class (klass);
  D.39938 = declsec_flags_map[action];
  D.39939 = D.39938 & flags;
  if (D.39939 != 0) goto <D.39940>; else goto <D.39941>;
  <D.39940>:
  {
    guint32 idx;

    D.39942 = klass->type_token;
    idx = D.39942 & 16777215;
    idx = idx << 2;
    idx = idx;
    D.39944 = klass->image;
    D.39943 = get_declsec_action (D.39944, idx, action, entry);
    return D.39943;
  }
  <D.39941>:
  D.39943 = 0;
  return D.39943;
}


mono_declsec_get_assembly_action (struct MonoAssembly * assembly, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  MonoBoolean D.39946;
  struct MonoImage * D.39947;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.39947 = assembly->image;
  D.39946 = get_declsec_action (D.39947, idx, action, entry);
  return D.39946;
}


mono_reflection_call_is_assignable_to (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * System_Reflection_Emit_TypeBuilder.834;
  struct MonoImage * D.39952;
  struct MonoClass * System_Reflection_Emit_TypeBuilder.835;
  _Bool D.39954;
  long int D.39955;
  long int D.39956;
  struct MonoMethod * method.836;
  struct MonoMethod * method.837;
  _Bool D.39963;
  long int D.39964;
  long int D.39965;
  void * D.39968;
  _Bool D.39969;
  long int D.39970;
  long int D.39971;
  int D.23791;
  int iftmp.838;
  int D.23790;
  void * D.39977;
  struct MonoVTable * D.39978;
  struct MonoClass * D.39979;
  const char[12] * D.39980;
  unsigned char D.39981;
  int D.39982;
  unsigned char D.39983;
  int D.39984;
  const unsigned char * D.39989;
  unsigned char D.39990;
  int D.39991;
  const unsigned char * D.39992;
  unsigned char D.39993;
  int D.39994;
  const unsigned char * D.39999;
  unsigned char D.40000;
  int D.40001;
  const unsigned char * D.40002;
  unsigned char D.40003;
  int D.40004;
  const unsigned char * D.40009;
  unsigned char D.40010;
  int D.40011;
  const unsigned char * D.40012;
  unsigned char D.40013;
  int D.40014;
  void * D.40016;
  struct MonoVTable * D.40017;
  struct MonoClass * D.40018;
  const char * D.40019;
  _Bool D.40020;
  long int D.40021;
  long int D.40022;
  struct MonoDomain * D.40025;
  struct MonoType * D.40026;
  struct MonoReflectionType * D.40027;
  void * D.40028;
  struct MonoObject * exc.839;
  gboolean D.40032;
  void * D.40033;
  unsigned char D.40034;
  struct MonoObject * res;
  struct MonoObject * exc;
  void * params[1];
  static struct MonoClass * System_Reflection_Emit_TypeBuilder = 0B;
  static struct MonoMethod * method = 0B;

  try
    {
      System_Reflection_Emit_TypeBuilder.834 = System_Reflection_Emit_TypeBuilder;
      if (System_Reflection_Emit_TypeBuilder.834 == 0B) goto <D.39950>; else goto <D.39951>;
      <D.39950>:
      D.39952 = mono_defaults.corlib;
      System_Reflection_Emit_TypeBuilder.835 = mono_class_from_name (D.39952, "System.Reflection.Emit", "TypeBuilder");
      System_Reflection_Emit_TypeBuilder = System_Reflection_Emit_TypeBuilder.835;
      System_Reflection_Emit_TypeBuilder.834 = System_Reflection_Emit_TypeBuilder;
      D.39954 = System_Reflection_Emit_TypeBuilder.834 == 0B;
      D.39955 = (long int) D.39954;
      D.39956 = __builtin_expect (D.39955, 0);
      if (D.39956 != 0) goto <D.39957>; else goto <D.39958>;
      <D.39957>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12621, "System_Reflection_Emit_TypeBuilder");
      <D.39958>:
      <D.39951>:
      method.836 = method;
      if (method.836 == 0B) goto <D.39960>; else goto <D.39961>;
      <D.39960>:
      System_Reflection_Emit_TypeBuilder.834 = System_Reflection_Emit_TypeBuilder;
      method.837 = mono_class_get_method_from_name (System_Reflection_Emit_TypeBuilder.834, "IsAssignableTo", 1);
      method = method.837;
      method.836 = method;
      D.39963 = method.836 == 0B;
      D.39964 = (long int) D.39963;
      D.39965 = __builtin_expect (D.39964, 0);
      if (D.39965 != 0) goto <D.39966>; else goto <D.39967>;
      <D.39966>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12625, "method");
      <D.39967>:
      <D.39961>:
      D.39968 = mono_class_get_ref_info (klass);
      D.39969 = D.39968 == 0B;
      D.39970 = (long int) D.39969;
      D.39971 = __builtin_expect (D.39970, 0);
      if (D.39971 != 0) goto <D.39972>; else goto <D.39973>;
      <D.39972>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12632, "mono_class_get_ref_info (klass)");
      <D.39973>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.39977 = mono_class_get_ref_info (klass);
          D.39978 = MEM[(struct MonoObject *)D.39977].vtable;
          D.39979 = D.39978->klass;
          __s2 = D.39979->name;
          D.39980 = "TypeBuilder";
          D.39981 = MEM[(const unsigned char *)D.39980];
          D.39982 = (int) D.39981;
          D.39983 = *__s2;
          D.39984 = (int) D.39983;
          __result = D.39982 - D.39984;
          {
            if (__s2_len != 0) goto <D.39985>; else goto <D.39986>;
            <D.39985>:
            if (__result == 0) goto <D.39987>; else goto <D.39988>;
            <D.39987>:
            D.39989 = &MEM[(void *)"TypeBuilder" + 1B];
            D.39990 = *D.39989;
            D.39991 = (int) D.39990;
            D.39992 = __s2 + 1;
            D.39993 = *D.39992;
            D.39994 = (int) D.39993;
            __result = D.39991 - D.39994;
            if (__s2_len > 1) goto <D.39995>; else goto <D.39996>;
            <D.39995>:
            if (__result == 0) goto <D.39997>; else goto <D.39998>;
            <D.39997>:
            D.39999 = &MEM[(void *)"TypeBuilder" + 2B];
            D.40000 = *D.39999;
            D.40001 = (int) D.40000;
            D.40002 = __s2 + 2;
            D.40003 = *D.40002;
            D.40004 = (int) D.40003;
            __result = D.40001 - D.40004;
            if (__s2_len > 2) goto <D.40005>; else goto <D.40006>;
            <D.40005>:
            if (__result == 0) goto <D.40007>; else goto <D.40008>;
            <D.40007>:
            D.40009 = &MEM[(void *)"TypeBuilder" + 3B];
            D.40010 = *D.40009;
            D.40011 = (int) D.40010;
            D.40012 = __s2 + 3;
            D.40013 = *D.40012;
            D.40014 = (int) D.40013;
            __result = D.40011 - D.40014;
            <D.40008>:
            <D.40006>:
            <D.39998>:
            <D.39996>:
            <D.39988>:
            <D.39986>:
          }
          D.23790 = __result;
        }
        iftmp.838 = -D.23790;
        goto <D.40015>;
        <D.39976>:
        D.40016 = mono_class_get_ref_info (klass);
        D.40017 = MEM[(struct MonoObject *)D.40016].vtable;
        D.40018 = D.40017->klass;
        D.40019 = D.40018->name;
        iftmp.838 = __builtin_strcmp (D.40019, "TypeBuilder");
        <D.40015>:
        D.23791 = iftmp.838;
      }
      D.40020 = D.23791 != 0;
      D.40021 = (long int) D.40020;
      D.40022 = __builtin_expect (D.40021, 0);
      if (D.40022 != 0) goto <D.40023>; else goto <D.40024>;
      <D.40023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12633, "!strcmp (((MonoObject*)(mono_class_get_ref_info (klass)))->vtable->klass->name, \"TypeBuilder\")");
      <D.40024>:
      D.40025 = mono_domain_get ();
      D.40026 = &oklass->byval_arg;
      D.40027 = mono_type_get_object (D.40025, D.40026);
      params[0] = D.40027;
      method.836 = method;
      D.40028 = mono_class_get_ref_info (klass);
      res = mono_runtime_invoke (method.836, D.40028, &params, &exc);
      exc.839 = exc;
      if (exc.839 != 0B) goto <D.40030>; else goto <D.40031>;
      <D.40030>:
      D.40032 = 0;
      return D.40032;
      <D.40031>:
      D.40033 = mono_object_unbox (res);
      D.40034 = MEM[(MonoBoolean *)D.40033];
      D.40032 = (gboolean) D.40034;
      return D.40032;
    }
  finally
    {
      exc = {CLOBBER};
      params = {CLOBBER};
    }
}


mono_reflection_type_get_type (struct MonoReflectionType * reftype)
{
  _Bool D.40037;
  long int D.40038;
  long int D.40039;
  struct MonoType * D.40042;

  D.40037 = reftype == 0B;
  D.40038 = (long int) D.40037;
  D.40039 = __builtin_expect (D.40038, 0);
  if (D.40039 != 0) goto <D.40040>; else goto <D.40041>;
  <D.40040>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12653, "reftype");
  <D.40041>:
  D.40042 = mono_reflection_type_get_handle (reftype);
  return D.40042;
}


