mono_reflection_init ()
{

}


mono_class_get_ref_info (struct MonoClass * klass)
{
  unsigned int D.23824;
  void * D.23827;

  D.23824 = klass->ref_info_handle;
  if (D.23824 == 0) goto <D.23825>; else goto <D.23826>;
  <D.23825>:
  D.23827 = 0B;
  return D.23827;
  <D.23826>:
  D.23824 = klass->ref_info_handle;
  D.23827 = mono_gchandle_get_target (D.23824);
  return D.23827;
}


mono_class_set_ref_info (struct MonoClass * klass, void * obj)
{
  unsigned int D.23829;
  unsigned int D.23830;
  _Bool D.23831;
  long int D.23832;
  long int D.23833;

  D.23829 = mono_gchandle_new (obj, 0);
  klass->ref_info_handle = D.23829;
  D.23830 = klass->ref_info_handle;
  D.23831 = D.23830 == 0;
  D.23832 = (long int) D.23831;
  D.23833 = __builtin_expect (D.23832, 0);
  if (D.23833 != 0) goto <D.23834>; else goto <D.23835>;
  <D.23834>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 641, "klass->ref_info_handle != 0");
  <D.23835>:
}


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

  D.23836 = klass->ref_info_handle;
  if (D.23836 != 0) goto <D.23837>; else goto <D.23838>;
  <D.23837>:
  D.23836 = klass->ref_info_handle;
  mono_gchandle_free (D.23836);
  klass->ref_info_handle = 0;
  <D.23838>:
}


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

  D.23839 = ainfo->cached;
  if (D.23839 == 0) goto <D.23840>; else goto <D.23841>;
  <D.23840>:
  monoeg_g_free (ainfo);
  <D.23841>:
}


mono_image_build_metadata (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.23842;
  unsigned int D.23843;
  int D.23846;
  unsigned int D.23849;
  unsigned int D.23850;
  unsigned int D.23851;
  guint32 * D.23852;
  unsigned char D.23853;
  unsigned int D.23854;
  unsigned int D.23855;
  guint32 * D.23856;
  struct MonoDynamicStream * D.23857;
  unsigned int D.23858;
  guint32 * D.23859;
  unsigned int D.23860;
  guint32 * D.23861;
  guint32 * D.23862;
  guint32 * D.23863;
  struct MonoArray * D.23864;
  unsigned int D.23867;
  unsigned int D.23868;
  unsigned int i.0;
  char * D.23870;
  struct MonoReflectionMethodBuilder * D.23871;
  unsigned int D.23872;
  struct MonoArray * D.23873;
  unsigned int D.23876;
  unsigned int D.23877;
  char * D.23878;
  struct MonoReflectionFieldBuilder * D.23879;
  unsigned int D.23880;
  int D.23881;
  int D.23882;
  void * iftmp.1;
  void * D.23886;
  unsigned int D.23887;
  unsigned int D.23888;
  struct MonoArray * D.23890;
  char * D.23893;
  int D.23894;
  unsigned int D.23895;
  void * * D.23896;
  unsigned int D.23897;
  unsigned int D.23898;
  unsigned int i.2;
  unsigned int D.23900;
  void * * D.23901;
  struct MonoString * D.23902;
  struct MonoString * D.23903;
  struct MonoArray * D.23904;
  struct MonoArray * D.23905;
  struct MonoArray * D.23908;
  struct MonoArray * D.23911;
  struct MonoGHashTable * D.23914;
  char * D.23917;
  unsigned int D.23918;
  struct MonoArray * D.23919;
  unsigned int j.3;
  char * D.23923;
  int D.23924;
  int D.23925;
  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.23842 = MEM[(struct MonoObject *)assemblyb].vtable;
      domain = D.23842->domain;
      D.23843 = assembly->text_rva;
      if (D.23843 != 0) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      return;
      <D.23845>:
      assembly->text_rva = 8192;
      D.23846 = moduleb->is_main;
      if (D.23846 != 0) goto <D.23847>; else goto <D.23848>;
      <D.23847>:
      mono_image_emit_manifest (moduleb);
      <D.23848>:
      table = &assembly->tables[2];
      table->rows = 1;
      D.23849 = table->next_idx;
      D.23850 = D.23849 + 1;
      table->next_idx = D.23850;
      D.23851 = table->rows;
      alloc_table (table, D.23851);
      D.23852 = table->values;
      D.23853 = table->columns;
      D.23854 = (unsigned int) D.23853;
      D.23855 = D.23854 * 4;
      values = D.23852 + D.23855;
      *values = 0;
      D.23856 = values + 4;
      D.23857 = &assembly->sheap;
      D.23858 = string_heap_insert (D.23857, "<Module>");
      *D.23856 = D.23858;
      D.23859 = values + 8;
      D.23857 = &assembly->sheap;
      D.23860 = string_heap_insert (D.23857, "");
      *D.23859 = D.23860;
      D.23861 = values + 12;
      *D.23861 = 0;
      D.23862 = values + 16;
      *D.23862 = 1;
      D.23863 = values + 20;
      *D.23863 = 1;
      D.23864 = moduleb->global_methods;
      if (D.23864 != 0B) goto <D.23865>; else goto <D.23866>;
      <D.23865>:
      table = &assembly->tables[6];
      D.23864 = moduleb->global_methods;
      D.23867 = mono_array_length (D.23864);
      D.23851 = table->rows;
      D.23868 = D.23851 + D.23867;
      table->rows = D.23868;
      D.23851 = table->rows;
      alloc_table (table, D.23851);
      i = 0;
      goto <D.20036>;
      <D.20035>:
      i.0 = (unsigned int) i;
      D.23864 = moduleb->global_methods;
      D.23870 = mono_array_addr_with_size (D.23864, 4, i.0);
      D.23871 = MEM[(struct MonoReflectionMethodBuilder * *)D.23870];
      mono_image_get_method_info (D.23871, assembly);
      i = i + 1;
      <D.20036>:
      i.0 = (unsigned int) i;
      D.23864 = moduleb->global_methods;
      D.23872 = mono_array_length (D.23864);
      if (i.0 < D.23872) goto <D.20035>; else goto <D.20037>;
      <D.20037>:
      <D.23866>:
      D.23873 = moduleb->global_fields;
      if (D.23873 != 0B) goto <D.23874>; else goto <D.23875>;
      <D.23874>:
      table = &assembly->tables[4];
      D.23873 = moduleb->global_fields;
      D.23876 = mono_array_length (D.23873);
      D.23851 = table->rows;
      D.23877 = D.23851 + D.23876;
      table->rows = D.23877;
      D.23851 = table->rows;
      alloc_table (table, D.23851);
      i = 0;
      goto <D.20039>;
      <D.20038>:
      i.0 = (unsigned int) i;
      D.23873 = moduleb->global_fields;
      D.23878 = mono_array_addr_with_size (D.23873, 4, i.0);
      D.23879 = MEM[(struct MonoReflectionFieldBuilder * *)D.23878];
      mono_image_get_field_info (D.23879, assembly);
      i = i + 1;
      <D.20039>:
      i.0 = (unsigned int) i;
      D.23873 = moduleb->global_fields;
      D.23880 = mono_array_length (D.23873);
      if (i.0 < D.23880) goto <D.20038>; else goto <D.20040>;
      <D.20040>:
      <D.23875>:
      table = &assembly->tables[0];
      alloc_table (table, 1);
      mono_image_fill_module_table (domain, moduleb, assembly);
      types.size = 0;
      D.23881 = moduleb->num_types;
      D.23882 = MAX_EXPR <D.23881, 16>;
      types.capacity = D.23882;
      D.23881 = moduleb->num_types;
      if (D.23881 > 16) goto <D.23884>; else goto <D.23885>;
      <D.23884>:
      D.23881 = moduleb->num_types;
      D.23886 = mono_gc_make_root_descr_all_refs (D.23881);
      D.23881 = moduleb->num_types;
      D.23887 = (unsigned int) D.23881;
      D.23888 = D.23887 * 4;
      iftmp.1 = mono_gc_alloc_fixed (D.23888, D.23886);
      goto <D.23889>;
      <D.23885>:
      iftmp.1 = __builtin_alloca (64);
      <D.23889>:
      types.data = iftmp.1;
      D.23890 = moduleb->types;
      if (D.23890 != 0B) goto <D.23891>; else goto <D.23892>;
      <D.23891>:
      i = 0;
      goto <D.20043>;
      <D.20042>:
      {
        struct MonoReflectionTypeBuilder * type;

        i.0 = (unsigned int) i;
        D.23890 = moduleb->types;
        D.23893 = mono_array_addr_with_size (D.23890, 4, i.0);
        type = MEM[(struct MonoReflectionTypeBuilder * *)D.23893];
        collect_types (&types, type);
      }
      i = i + 1;
      <D.20043>:
      D.23881 = moduleb->num_types;
      if (D.23881 > i) goto <D.20042>; else goto <D.20044>;
      <D.20044>:
      <D.23892>:
      D.23894 = types.size;
      D.23895 = (unsigned int) D.23894;
      D.23896 = types.data;
      qsort (D.23896, D.23895, 4, compare_types_by_table_idx);
      table = &assembly->tables[2];
      D.23851 = table->rows;
      D.23894 = types.size;
      D.23897 = (unsigned int) D.23894;
      D.23898 = D.23851 + D.23897;
      table->rows = D.23898;
      D.23851 = table->rows;
      alloc_table (table, D.23851);
      i = 0;
      goto <D.20047>;
      <D.20046>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.23896 = types.data;
        i.2 = (unsigned int) i;
        D.23900 = i.2 * 4;
        D.23901 = D.23896 + D.23900;
        tb = *D.23901;
        D.23902 = tb->nspace;
        D.23857 = &assembly->sheap;
        string_heap_insert_mstring (D.23857, D.23902);
      }
      i = i + 1;
      <D.20047>:
      D.23894 = types.size;
      if (D.23894 > i) goto <D.20046>; else goto <D.20048>;
      <D.20048>:
      i = 0;
      goto <D.20051>;
      <D.20050>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.23896 = types.data;
        i.2 = (unsigned int) i;
        D.23900 = i.2 * 4;
        D.23901 = D.23896 + D.23900;
        tb = *D.23901;
        D.23903 = tb->name;
        D.23857 = &assembly->sheap;
        string_heap_insert_mstring (D.23857, D.23903);
      }
      i = i + 1;
      <D.20051>:
      D.23894 = types.size;
      if (D.23894 > i) goto <D.20050>; else goto <D.20052>;
      <D.20052>:
      i = 0;
      goto <D.20055>;
      <D.20054>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.23896 = types.data;
        i.2 = (unsigned int) i;
        D.23900 = i.2 * 4;
        D.23901 = D.23896 + D.23900;
        type = *D.23901;
        mono_image_get_type_info (domain, type, assembly);
      }
      i = i + 1;
      <D.20055>:
      D.23894 = types.size;
      if (D.23894 > i) goto <D.20054>; else goto <D.20056>;
      <D.20056>:
      D.23904 = assemblyb->cattrs;
      mono_image_add_cattrs (assembly, 1, 14, D.23904);
      D.23905 = assemblyb->permissions_minimum;
      if (D.23905 != 0B) goto <D.23906>; else goto <D.23907>;
      <D.23906>:
      D.23905 = assemblyb->permissions_minimum;
      mono_image_add_decl_security (assembly, 536870913, D.23905);
      <D.23907>:
      D.23908 = assemblyb->permissions_optional;
      if (D.23908 != 0B) goto <D.23909>; else goto <D.23910>;
      <D.23909>:
      D.23908 = assemblyb->permissions_optional;
      mono_image_add_decl_security (assembly, 536870913, D.23908);
      <D.23910>:
      D.23911 = assemblyb->permissions_refused;
      if (D.23911 != 0B) goto <D.23912>; else goto <D.23913>;
      <D.23912>:
      D.23911 = assemblyb->permissions_refused;
      mono_image_add_decl_security (assembly, 536870913, D.23911);
      <D.23913>:
      module_add_cattrs (assembly, moduleb);
      D.23914 = assembly->token_fixups;
      mono_g_hash_table_foreach (D.23914, fixup_method, assembly);
      D.23864 = moduleb->global_methods;
      if (D.23864 != 0B) goto <D.23915>; else goto <D.23916>;
      <D.23915>:
      i = 0;
      goto <D.20059>;
      <D.20058>:
      {
        struct MonoReflectionMethodBuilder * mb;

        i.0 = (unsigned int) i;
        D.23864 = moduleb->global_methods;
        D.23917 = mono_array_addr_with_size (D.23864, 4, i.0);
        mb = MEM[(struct MonoReflectionMethodBuilder * *)D.23917];
        mono_image_add_methodimpl (assembly, mb);
      }
      i = i + 1;
      <D.20059>:
      i.0 = (unsigned int) i;
      D.23864 = moduleb->global_methods;
      D.23918 = mono_array_length (D.23864);
      if (i.0 < D.23918) goto <D.20058>; else goto <D.20060>;
      <D.20060>:
      <D.23916>:
      i = 0;
      goto <D.20067>;
      <D.20066>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.23896 = types.data;
        i.2 = (unsigned int) i;
        D.23900 = i.2 * 4;
        D.23901 = D.23896 + D.23900;
        type = *D.23901;
        D.23919 = type->methods;
        if (D.23919 != 0B) goto <D.23920>; else goto <D.23921>;
        <D.23920>:
        j = 0;
        goto <D.20064>;
        <D.20063>:
        {
          struct MonoReflectionMethodBuilder * mb;

          j.3 = (unsigned int) j;
          D.23919 = type->methods;
          D.23923 = mono_array_addr_with_size (D.23919, 4, j.3);
          mb = MEM[(struct MonoReflectionMethodBuilder * *)D.23923];
          mono_image_add_methodimpl (assembly, mb);
        }
        j = j + 1;
        <D.20064>:
        D.23924 = type->num_methods;
        if (D.23924 > j) goto <D.20063>; else goto <D.20065>;
        <D.20065>:
        <D.23921>:
      }
      i = i + 1;
      <D.20067>:
      D.23894 = types.size;
      if (D.23894 > i) goto <D.20066>; else goto <D.20068>;
      <D.20068>:
      D.23925 = types.capacity;
      if (D.23925 > 16) goto <D.23926>; else goto <D.23927>;
      <D.23926>:
      D.23896 = types.data;
      mono_gc_free_fixed (D.23896);
      <D.23927>:
      fixup_cattrs (assembly);
    }
  finally
    {
      types = {CLOBBER};
    }
}


fixup_method (struct MonoReflectionILGen * ilgen, void * value, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.23931;
  char * D.23932;
  int D.23933;
  sizetype D.23934;
  sizetype D.23935;
  unsigned char * D.23936;
  unsigned char D.23937;
  int D.23938;
  int D.19705;
  int iftmp.4;
  int D.19704;
  struct MonoObject * D.23942;
  struct MonoVTable * D.23943;
  struct MonoClass * D.23944;
  const char[13] * D.23945;
  unsigned char D.23946;
  int D.23947;
  unsigned char D.23948;
  int D.23949;
  _Bool D.23950;
  _Bool D.23951;
  _Bool D.23952;
  const unsigned char * D.23955;
  unsigned char D.23956;
  int D.23957;
  const unsigned char * D.23958;
  unsigned char D.23959;
  int D.23960;
  _Bool D.23961;
  _Bool D.23962;
  const unsigned char * D.23965;
  unsigned char D.23966;
  int D.23967;
  const unsigned char * D.23968;
  unsigned char D.23969;
  int D.23970;
  _Bool D.23971;
  _Bool D.23972;
  const unsigned char * D.23975;
  unsigned char D.23976;
  int D.23977;
  const unsigned char * D.23978;
  unsigned char D.23979;
  int D.23980;
  const char * D.23982;
  int D.23985;
  int D.19714;
  int iftmp.5;
  int D.19713;
  const char[10] * D.23990;
  unsigned char D.23991;
  int D.23992;
  unsigned char D.23993;
  int D.23994;
  _Bool D.23995;
  _Bool D.23996;
  _Bool D.23997;
  const unsigned char * D.24000;
  unsigned char D.24001;
  int D.24002;
  const unsigned char * D.24003;
  unsigned char D.24004;
  int D.24005;
  _Bool D.24006;
  _Bool D.24007;
  const unsigned char * D.24010;
  unsigned char D.24011;
  int D.24012;
  const unsigned char * D.24013;
  unsigned char D.24014;
  int D.24015;
  _Bool D.24016;
  _Bool D.24017;
  const unsigned char * D.24020;
  unsigned char D.24021;
  int D.24022;
  const unsigned char * D.24023;
  unsigned char D.24024;
  int D.24025;
  struct GHashTable * D.24029;
  void * D.24030;
  int D.19726;
  int iftmp.6;
  int D.19725;
  const char[14] * D.24035;
  unsigned char D.24036;
  int D.24037;
  unsigned char D.24038;
  int D.24039;
  _Bool D.24040;
  _Bool D.24041;
  _Bool D.24042;
  const unsigned char * D.24045;
  unsigned char D.24046;
  int D.24047;
  const unsigned char * D.24048;
  unsigned char D.24049;
  int D.24050;
  _Bool D.24051;
  _Bool D.24052;
  const unsigned char * D.24055;
  unsigned char D.24056;
  int D.24057;
  const unsigned char * D.24058;
  unsigned char D.24059;
  int D.24060;
  _Bool D.24061;
  _Bool D.24062;
  const unsigned char * D.24065;
  unsigned char D.24066;
  int D.24067;
  const unsigned char * D.24068;
  unsigned char D.24069;
  int D.24070;
  int D.19735;
  int iftmp.7;
  int D.19734;
  const char[19] * D.24078;
  unsigned char D.24079;
  int D.24080;
  unsigned char D.24081;
  int D.24082;
  _Bool D.24083;
  _Bool D.24084;
  _Bool D.24085;
  const unsigned char * D.24088;
  unsigned char D.24089;
  int D.24090;
  const unsigned char * D.24091;
  unsigned char D.24092;
  int D.24093;
  _Bool D.24094;
  _Bool D.24095;
  const unsigned char * D.24098;
  unsigned char D.24099;
  int D.24100;
  const unsigned char * D.24101;
  unsigned char D.24102;
  int D.24103;
  _Bool D.24104;
  _Bool D.24105;
  const unsigned char * D.24108;
  unsigned char D.24109;
  int D.24110;
  const unsigned char * D.24111;
  unsigned char D.24112;
  int D.24113;
  int D.19744;
  int iftmp.8;
  int D.19743;
  const char[11] * D.24124;
  unsigned char D.24125;
  int D.24126;
  unsigned char D.24127;
  int D.24128;
  _Bool D.24129;
  _Bool D.24130;
  _Bool D.24131;
  const unsigned char * D.24134;
  unsigned char D.24135;
  int D.24136;
  const unsigned char * D.24137;
  unsigned char D.24138;
  int D.24139;
  _Bool D.24140;
  _Bool D.24141;
  const unsigned char * D.24144;
  unsigned char D.24145;
  int D.24146;
  const unsigned char * D.24147;
  unsigned char D.24148;
  int D.24149;
  _Bool D.24150;
  _Bool D.24151;
  const unsigned char * D.24154;
  unsigned char D.24155;
  int D.24156;
  const unsigned char * D.24157;
  unsigned char D.24158;
  int D.24159;
  int D.19753;
  int iftmp.9;
  int D.19752;
  const char[12] * D.24165;
  unsigned char D.24166;
  int D.24167;
  unsigned char D.24168;
  int D.24169;
  _Bool D.24170;
  _Bool D.24171;
  _Bool D.24172;
  const unsigned char * D.24175;
  unsigned char D.24176;
  int D.24177;
  const unsigned char * D.24178;
  unsigned char D.24179;
  int D.24180;
  _Bool D.24181;
  _Bool D.24182;
  const unsigned char * D.24185;
  unsigned char D.24186;
  int D.24187;
  const unsigned char * D.24188;
  unsigned char D.24189;
  int D.24190;
  _Bool D.24191;
  _Bool D.24192;
  const unsigned char * D.24195;
  unsigned char D.24196;
  int D.24197;
  const unsigned char * D.24198;
  unsigned char D.24199;
  int D.24200;
  struct GHashTable * D.24202;
  void * D.24203;
  int D.19764;
  int iftmp.10;
  int D.19763;
  const char[12] * D.24207;
  unsigned char D.24208;
  int D.24209;
  unsigned char D.24210;
  int D.24211;
  _Bool D.24212;
  _Bool D.24213;
  _Bool D.24214;
  const unsigned char * D.24217;
  unsigned char D.24218;
  int D.24219;
  const unsigned char * D.24220;
  unsigned char D.24221;
  int D.24222;
  _Bool D.24223;
  _Bool D.24224;
  const unsigned char * D.24227;
  unsigned char D.24228;
  int D.24229;
  const unsigned char * D.24230;
  unsigned char D.24231;
  int D.24232;
  _Bool D.24233;
  _Bool D.24234;
  const unsigned char * D.24237;
  unsigned char D.24238;
  int D.24239;
  const unsigned char * D.24240;
  unsigned char D.24241;
  int D.24242;
  int D.19774;
  int iftmp.11;
  int D.19773;
  const char[16] * D.24249;
  unsigned char D.24250;
  int D.24251;
  unsigned char D.24252;
  int D.24253;
  _Bool D.24254;
  _Bool D.24255;
  _Bool D.24256;
  const unsigned char * D.24259;
  unsigned char D.24260;
  int D.24261;
  const unsigned char * D.24262;
  unsigned char D.24263;
  int D.24264;
  _Bool D.24265;
  _Bool D.24266;
  const unsigned char * D.24269;
  unsigned char D.24270;
  int D.24271;
  const unsigned char * D.24272;
  unsigned char D.24273;
  int D.24274;
  _Bool D.24275;
  _Bool D.24276;
  const unsigned char * D.24279;
  unsigned char D.24280;
  int D.24281;
  const unsigned char * D.24282;
  unsigned char D.24283;
  int D.24284;
  int D.19783;
  int iftmp.12;
  int D.19782;
  unsigned char D.24294;
  int D.24295;
  _Bool D.24296;
  _Bool D.24297;
  _Bool D.24298;
  const unsigned char * D.24301;
  unsigned char D.24302;
  int D.24303;
  _Bool D.24304;
  _Bool D.24305;
  const unsigned char * D.24308;
  unsigned char D.24309;
  int D.24310;
  _Bool D.24311;
  _Bool D.24312;
  const unsigned char * D.24315;
  unsigned char D.24316;
  int D.24317;
  int D.19792;
  int iftmp.13;
  int D.19791;
  unsigned char D.24323;
  int D.24324;
  _Bool D.24325;
  _Bool D.24326;
  _Bool D.24327;
  const unsigned char * D.24330;
  unsigned char D.24331;
  int D.24332;
  _Bool D.24333;
  _Bool D.24334;
  const unsigned char * D.24337;
  unsigned char D.24338;
  int D.24339;
  _Bool D.24340;
  _Bool D.24341;
  const unsigned char * D.24344;
  unsigned char D.24345;
  int D.24346;
  int D.19801;
  int iftmp.14;
  int D.19800;
  const char[18] * D.24352;
  unsigned char D.24353;
  int D.24354;
  unsigned char D.24355;
  int D.24356;
  _Bool D.24357;
  _Bool D.24358;
  _Bool D.24359;
  const unsigned char * D.24362;
  unsigned char D.24363;
  int D.24364;
  const unsigned char * D.24365;
  unsigned char D.24366;
  int D.24367;
  _Bool D.24368;
  _Bool D.24369;
  const unsigned char * D.24372;
  unsigned char D.24373;
  int D.24374;
  const unsigned char * D.24375;
  unsigned char D.24376;
  int D.24377;
  _Bool D.24378;
  _Bool D.24379;
  const unsigned char * D.24382;
  unsigned char D.24383;
  int D.24384;
  const unsigned char * D.24385;
  unsigned char D.24386;
  int D.24387;
  int D.19810;
  int iftmp.15;
  int D.19809;
  const char[19] * D.24393;
  unsigned char D.24394;
  int D.24395;
  unsigned char D.24396;
  int D.24397;
  _Bool D.24398;
  _Bool D.24399;
  _Bool D.24400;
  const unsigned char * D.24403;
  unsigned char D.24404;
  int D.24405;
  const unsigned char * D.24406;
  unsigned char D.24407;
  int D.24408;
  _Bool D.24409;
  _Bool D.24410;
  const unsigned char * D.24413;
  unsigned char D.24414;
  int D.24415;
  const unsigned char * D.24416;
  unsigned char D.24417;
  int D.24418;
  _Bool D.24419;
  _Bool D.24420;
  const unsigned char * D.24423;
  unsigned char D.24424;
  int D.24425;
  const unsigned char * D.24426;
  unsigned char D.24427;
  int D.24428;
  int iftmp.16;
  struct MonoClass * D.24433;
  struct MonoGenericClass * D.24434;
  struct MonoGenericContainer * D.24436;
  _Bool D.24438;
  long int D.24439;
  long int D.24440;
  int D.19821;
  int iftmp.17;
  int D.19820;
  unsigned char D.24446;
  int D.24447;
  _Bool D.24448;
  _Bool D.24449;
  _Bool D.24450;
  const unsigned char * D.24453;
  unsigned char D.24454;
  int D.24455;
  _Bool D.24456;
  _Bool D.24457;
  const unsigned char * D.24460;
  unsigned char D.24461;
  int D.24462;
  _Bool D.24463;
  _Bool D.24464;
  const unsigned char * D.24467;
  unsigned char D.24468;
  int D.24469;
  int D.19830;
  int iftmp.18;
  int D.19829;
  unsigned char D.24476;
  int D.24477;
  _Bool D.24478;
  _Bool D.24479;
  _Bool D.24480;
  const unsigned char * D.24483;
  unsigned char D.24484;
  int D.24485;
  _Bool D.24486;
  _Bool D.24487;
  const unsigned char * D.24490;
  unsigned char D.24491;
  int D.24492;
  _Bool D.24493;
  _Bool D.24494;
  const unsigned char * D.24497;
  unsigned char D.24498;
  int D.24499;
  int D.24503;
  _Bool D.24504;
  long int D.24505;
  long int D.24506;
  int D.19840;
  int iftmp.19;
  int D.19839;
  unsigned char D.24514;
  int D.24515;
  _Bool D.24516;
  _Bool D.24517;
  _Bool D.24518;
  const unsigned char * D.24521;
  unsigned char D.24522;
  int D.24523;
  _Bool D.24524;
  _Bool D.24525;
  const unsigned char * D.24528;
  unsigned char D.24529;
  int D.24530;
  _Bool D.24531;
  _Bool D.24532;
  const unsigned char * D.24535;
  unsigned char D.24536;
  int D.24537;
  int D.19849;
  int iftmp.20;
  int D.19848;
  unsigned char D.24543;
  int D.24544;
  _Bool D.24545;
  _Bool D.24546;
  _Bool D.24547;
  const unsigned char * D.24550;
  unsigned char D.24551;
  int D.24552;
  _Bool D.24553;
  _Bool D.24554;
  const unsigned char * D.24557;
  unsigned char D.24558;
  int D.24559;
  _Bool D.24560;
  _Bool D.24561;
  const unsigned char * D.24564;
  unsigned char D.24565;
  int D.24566;
  int D.19858;
  int iftmp.21;
  int D.19857;
  const char[23] * D.24571;
  unsigned char D.24572;
  int D.24573;
  unsigned char D.24574;
  int D.24575;
  _Bool D.24576;
  _Bool D.24577;
  _Bool D.24578;
  const unsigned char * D.24581;
  unsigned char D.24582;
  int D.24583;
  const unsigned char * D.24584;
  unsigned char D.24585;
  int D.24586;
  _Bool D.24587;
  _Bool D.24588;
  const unsigned char * D.24591;
  unsigned char D.24592;
  int D.24593;
  const unsigned char * D.24594;
  unsigned char D.24595;
  int D.24596;
  _Bool D.24597;
  _Bool D.24598;
  const unsigned char * D.24601;
  unsigned char D.24602;
  int D.24603;
  const unsigned char * D.24604;
  unsigned char D.24605;
  int D.24606;
  int D.19867;
  int iftmp.22;
  int D.19866;
  const char[24] * D.24613;
  unsigned char D.24614;
  int D.24615;
  unsigned char D.24616;
  int D.24617;
  _Bool D.24618;
  _Bool D.24619;
  _Bool D.24620;
  const unsigned char * D.24623;
  unsigned char D.24624;
  int D.24625;
  const unsigned char * D.24626;
  unsigned char D.24627;
  int D.24628;
  _Bool D.24629;
  _Bool D.24630;
  const unsigned char * D.24633;
  unsigned char D.24634;
  int D.24635;
  const unsigned char * D.24636;
  unsigned char D.24637;
  int D.24638;
  _Bool D.24639;
  _Bool D.24640;
  const unsigned char * D.24643;
  unsigned char D.24644;
  int D.24645;
  const unsigned char * D.24646;
  unsigned char D.24647;
  int D.24648;
  int D.19876;
  int iftmp.23;
  int D.19875;
  const char[29] * D.24655;
  unsigned char D.24656;
  int D.24657;
  unsigned char D.24658;
  int D.24659;
  _Bool D.24660;
  _Bool D.24661;
  _Bool D.24662;
  const unsigned char * D.24665;
  unsigned char D.24666;
  int D.24667;
  const unsigned char * D.24668;
  unsigned char D.24669;
  int D.24670;
  _Bool D.24671;
  _Bool D.24672;
  const unsigned char * D.24675;
  unsigned char D.24676;
  int D.24677;
  const unsigned char * D.24678;
  unsigned char D.24679;
  int D.24680;
  _Bool D.24681;
  _Bool D.24682;
  const unsigned char * D.24685;
  unsigned char D.24686;
  int D.24687;
  const unsigned char * D.24688;
  unsigned char D.24689;
  int D.24690;
  int D.19886;
  int iftmp.24;
  int D.19885;
  unsigned char D.24697;
  int D.24698;
  _Bool D.24699;
  _Bool D.24700;
  _Bool D.24701;
  const unsigned char * D.24704;
  unsigned char D.24705;
  int D.24706;
  _Bool D.24707;
  _Bool D.24708;
  const unsigned char * D.24711;
  unsigned char D.24712;
  int D.24713;
  _Bool D.24714;
  _Bool D.24715;
  const unsigned char * D.24718;
  unsigned char D.24719;
  int D.24720;
  struct MonoMethodSignature * D.24724;
  short unsigned int D.24725;
  _Bool D.24726;
  long int D.24727;
  long int D.24728;
  int D.19896;
  int iftmp.25;
  int D.19895;
  unsigned char D.24734;
  int D.24735;
  _Bool D.24736;
  _Bool D.24737;
  _Bool D.24738;
  const unsigned char * D.24741;
  unsigned char D.24742;
  int D.24743;
  _Bool D.24744;
  _Bool D.24745;
  const unsigned char * D.24748;
  unsigned char D.24749;
  int D.24750;
  _Bool D.24751;
  _Bool D.24752;
  const unsigned char * D.24755;
  unsigned char D.24756;
  int D.24757;
  int D.19905;
  int iftmp.26;
  int D.19904;
  unsigned char D.24764;
  int D.24765;
  _Bool D.24766;
  _Bool D.24767;
  _Bool D.24768;
  const unsigned char * D.24771;
  unsigned char D.24772;
  int D.24773;
  _Bool D.24774;
  _Bool D.24775;
  const unsigned char * D.24778;
  unsigned char D.24779;
  int D.24780;
  _Bool D.24781;
  _Bool D.24782;
  const unsigned char * D.24785;
  unsigned char D.24786;
  int D.24787;
  unsigned char D.24791;
  unsigned char * D.24792;
  unsigned int D.24793;
  unsigned char D.24794;
  unsigned char * D.24795;
  unsigned int D.24796;
  unsigned char D.24797;
  int D.24798;
  unsigned int D.24799;
  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.19909>;
  <D.19908>:
  D.23931 = ilgen->token_fixups;
  iltoken = mono_array_addr_with_size (D.23931, 8, i);
  D.23932 = assembly->code.data;
  D.23933 = iltoken->code_pos;
  D.23934 = (sizetype) D.23933;
  D.23935 = D.23934 + code_idx;
  target = D.23932 + D.23935;
  D.23936 = target + 3;
  D.23937 = *D.23936;
  D.23938 = (int) D.23937;
  switch (D.23938) <default: <D.19906>, case 2: <D.19755>, case 4: <D.19696>, case 6: <D.19717>, case 10: <D.19765>, case 43: <D.19877>>
  <D.19696>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.23945 = "FieldBuilder";
      D.23946 = MEM[(const unsigned char *)D.23945];
      D.23947 = (int) D.23946;
      D.23948 = *__s2;
      D.23949 = (int) D.23948;
      __result = D.23947 - D.23949;
      {
        D.23950 = __s2_len != 0;
        D.23951 = __result == 0;
        D.23952 = D.23950 & D.23951;
        if (D.23952 != 0) goto <D.23953>; else goto <D.23954>;
        <D.23953>:
        D.23955 = &MEM[(void *)"FieldBuilder" + 1B];
        D.23956 = *D.23955;
        D.23957 = (int) D.23956;
        D.23958 = __s2 + 1;
        D.23959 = *D.23958;
        D.23960 = (int) D.23959;
        __result = D.23957 - D.23960;
        D.23961 = __s2_len > 1;
        D.23951 = __result == 0;
        D.23962 = D.23961 & D.23951;
        if (D.23962 != 0) goto <D.23963>; else goto <D.23964>;
        <D.23963>:
        D.23965 = &MEM[(void *)"FieldBuilder" + 2B];
        D.23966 = *D.23965;
        D.23967 = (int) D.23966;
        D.23968 = __s2 + 2;
        D.23969 = *D.23968;
        D.23970 = (int) D.23969;
        __result = D.23967 - D.23970;
        D.23971 = __s2_len > 2;
        D.23951 = __result == 0;
        D.23972 = D.23971 & D.23951;
        if (D.23972 != 0) goto <D.23973>; else goto <D.23974>;
        <D.23973>:
        D.23975 = &MEM[(void *)"FieldBuilder" + 3B];
        D.23976 = *D.23975;
        D.23977 = (int) D.23976;
        D.23978 = __s2 + 3;
        D.23979 = *D.23978;
        D.23980 = (int) D.23979;
        __result = D.23977 - D.23980;
        <D.23974>:
        <D.23964>:
        <D.23954>:
      }
      D.19704 = __result;
    }
    iftmp.4 = -D.19704;
    goto <D.23981>;
    <D.23941>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.4 = __builtin_strcmp (D.23982, "FieldBuilder");
    <D.23981>:
    D.19705 = iftmp.4;
  }
  if (D.19705 == 0) goto <D.23983>; else goto <D.23984>;
  <D.23983>:
  field = iltoken->member;
  D.23985 = field->table_idx;
  idx = (guint32) D.23985;
  goto <D.23986>;
  <D.23984>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.23990 = "MonoField";
      D.23991 = MEM[(const unsigned char *)D.23990];
      D.23992 = (int) D.23991;
      D.23993 = *__s2;
      D.23994 = (int) D.23993;
      __result = D.23992 - D.23994;
      {
        D.23995 = __s2_len != 0;
        D.23996 = __result == 0;
        D.23997 = D.23995 & D.23996;
        if (D.23997 != 0) goto <D.23998>; else goto <D.23999>;
        <D.23998>:
        D.24000 = &MEM[(void *)"MonoField" + 1B];
        D.24001 = *D.24000;
        D.24002 = (int) D.24001;
        D.24003 = __s2 + 1;
        D.24004 = *D.24003;
        D.24005 = (int) D.24004;
        __result = D.24002 - D.24005;
        D.24006 = __s2_len > 1;
        D.23996 = __result == 0;
        D.24007 = D.24006 & D.23996;
        if (D.24007 != 0) goto <D.24008>; else goto <D.24009>;
        <D.24008>:
        D.24010 = &MEM[(void *)"MonoField" + 2B];
        D.24011 = *D.24010;
        D.24012 = (int) D.24011;
        D.24013 = __s2 + 2;
        D.24014 = *D.24013;
        D.24015 = (int) D.24014;
        __result = D.24012 - D.24015;
        D.24016 = __s2_len > 2;
        D.23996 = __result == 0;
        D.24017 = D.24016 & D.23996;
        if (D.24017 != 0) goto <D.24018>; else goto <D.24019>;
        <D.24018>:
        D.24020 = &MEM[(void *)"MonoField" + 3B];
        D.24021 = *D.24020;
        D.24022 = (int) D.24021;
        D.24023 = __s2 + 3;
        D.24024 = *D.24023;
        D.24025 = (int) D.24024;
        __result = D.24022 - D.24025;
        <D.24019>:
        <D.24009>:
        <D.23999>:
      }
      D.19713 = __result;
    }
    iftmp.5 = -D.19713;
    goto <D.24026>;
    <D.23989>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.5 = __builtin_strcmp (D.23982, "MonoField");
    <D.24026>:
    D.19714 = iftmp.5;
  }
  if (D.19714 == 0) goto <D.24027>; else goto <D.24028>;
  <D.24027>:
  {
    struct MonoClassField * f;

    D.23942 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.23942].field;
    D.24029 = assembly->field_to_table_idx;
    D.24030 = monoeg_g_hash_table_lookup (D.24029, f);
    idx = (guint32) D.24030;
  }
  goto <D.24031>;
  <D.24028>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4237);
  <D.24031>:
  <D.23986>:
  goto <D.19716>;
  <D.19717>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24035 = "MethodBuilder";
      D.24036 = MEM[(const unsigned char *)D.24035];
      D.24037 = (int) D.24036;
      D.24038 = *__s2;
      D.24039 = (int) D.24038;
      __result = D.24037 - D.24039;
      {
        D.24040 = __s2_len != 0;
        D.24041 = __result == 0;
        D.24042 = D.24040 & D.24041;
        if (D.24042 != 0) goto <D.24043>; else goto <D.24044>;
        <D.24043>:
        D.24045 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24046 = *D.24045;
        D.24047 = (int) D.24046;
        D.24048 = __s2 + 1;
        D.24049 = *D.24048;
        D.24050 = (int) D.24049;
        __result = D.24047 - D.24050;
        D.24051 = __s2_len > 1;
        D.24041 = __result == 0;
        D.24052 = D.24051 & D.24041;
        if (D.24052 != 0) goto <D.24053>; else goto <D.24054>;
        <D.24053>:
        D.24055 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24056 = *D.24055;
        D.24057 = (int) D.24056;
        D.24058 = __s2 + 2;
        D.24059 = *D.24058;
        D.24060 = (int) D.24059;
        __result = D.24057 - D.24060;
        D.24061 = __s2_len > 2;
        D.24041 = __result == 0;
        D.24062 = D.24061 & D.24041;
        if (D.24062 != 0) goto <D.24063>; else goto <D.24064>;
        <D.24063>:
        D.24065 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24066 = *D.24065;
        D.24067 = (int) D.24066;
        D.24068 = __s2 + 3;
        D.24069 = *D.24068;
        D.24070 = (int) D.24069;
        __result = D.24067 - D.24070;
        <D.24064>:
        <D.24054>:
        <D.24044>:
      }
      D.19725 = __result;
    }
    iftmp.6 = -D.19725;
    goto <D.24071>;
    <D.24034>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.6 = __builtin_strcmp (D.23982, "MethodBuilder");
    <D.24071>:
    D.19726 = iftmp.6;
  }
  if (D.19726 == 0) goto <D.24072>; else goto <D.24073>;
  <D.24072>:
  method = iltoken->member;
  idx = method->table_idx;
  goto <D.24074>;
  <D.24073>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24078 = "ConstructorBuilder";
      D.24079 = MEM[(const unsigned char *)D.24078];
      D.24080 = (int) D.24079;
      D.24081 = *__s2;
      D.24082 = (int) D.24081;
      __result = D.24080 - D.24082;
      {
        D.24083 = __s2_len != 0;
        D.24084 = __result == 0;
        D.24085 = D.24083 & D.24084;
        if (D.24085 != 0) goto <D.24086>; else goto <D.24087>;
        <D.24086>:
        D.24088 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24089 = *D.24088;
        D.24090 = (int) D.24089;
        D.24091 = __s2 + 1;
        D.24092 = *D.24091;
        D.24093 = (int) D.24092;
        __result = D.24090 - D.24093;
        D.24094 = __s2_len > 1;
        D.24084 = __result == 0;
        D.24095 = D.24094 & D.24084;
        if (D.24095 != 0) goto <D.24096>; else goto <D.24097>;
        <D.24096>:
        D.24098 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24099 = *D.24098;
        D.24100 = (int) D.24099;
        D.24101 = __s2 + 2;
        D.24102 = *D.24101;
        D.24103 = (int) D.24102;
        __result = D.24100 - D.24103;
        D.24104 = __s2_len > 2;
        D.24084 = __result == 0;
        D.24105 = D.24104 & D.24084;
        if (D.24105 != 0) goto <D.24106>; else goto <D.24107>;
        <D.24106>:
        D.24108 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24109 = *D.24108;
        D.24110 = (int) D.24109;
        D.24111 = __s2 + 3;
        D.24112 = *D.24111;
        D.24113 = (int) D.24112;
        __result = D.24110 - D.24113;
        <D.24107>:
        <D.24097>:
        <D.24087>:
      }
      D.19734 = __result;
    }
    iftmp.7 = -D.19734;
    goto <D.24114>;
    <D.24077>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.7 = __builtin_strcmp (D.23982, "ConstructorBuilder");
    <D.24114>:
    D.19735 = iftmp.7;
  }
  if (D.19735 == 0) goto <D.24115>; else goto <D.24116>;
  <D.24115>:
  ctor = iltoken->member;
  idx = ctor->table_idx;
  goto <D.24117>;
  <D.24116>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24124 = "MonoMethod";
      D.24125 = MEM[(const unsigned char *)D.24124];
      D.24126 = (int) D.24125;
      D.24127 = *__s2;
      D.24128 = (int) D.24127;
      __result = D.24126 - D.24128;
      {
        D.24129 = __s2_len != 0;
        D.24130 = __result == 0;
        D.24131 = D.24129 & D.24130;
        if (D.24131 != 0) goto <D.24132>; else goto <D.24133>;
        <D.24132>:
        D.24134 = &MEM[(void *)"MonoMethod" + 1B];
        D.24135 = *D.24134;
        D.24136 = (int) D.24135;
        D.24137 = __s2 + 1;
        D.24138 = *D.24137;
        D.24139 = (int) D.24138;
        __result = D.24136 - D.24139;
        D.24140 = __s2_len > 1;
        D.24130 = __result == 0;
        D.24141 = D.24140 & D.24130;
        if (D.24141 != 0) goto <D.24142>; else goto <D.24143>;
        <D.24142>:
        D.24144 = &MEM[(void *)"MonoMethod" + 2B];
        D.24145 = *D.24144;
        D.24146 = (int) D.24145;
        D.24147 = __s2 + 2;
        D.24148 = *D.24147;
        D.24149 = (int) D.24148;
        __result = D.24146 - D.24149;
        D.24150 = __s2_len > 2;
        D.24130 = __result == 0;
        D.24151 = D.24150 & D.24130;
        if (D.24151 != 0) goto <D.24152>; else goto <D.24153>;
        <D.24152>:
        D.24154 = &MEM[(void *)"MonoMethod" + 3B];
        D.24155 = *D.24154;
        D.24156 = (int) D.24155;
        D.24157 = __s2 + 3;
        D.24158 = *D.24157;
        D.24159 = (int) D.24158;
        __result = D.24156 - D.24159;
        <D.24153>:
        <D.24143>:
        <D.24133>:
      }
      D.19743 = __result;
    }
    iftmp.8 = -D.19743;
    goto <D.24160>;
    <D.24123>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.8 = __builtin_strcmp (D.23982, "MonoMethod");
    <D.24160>:
    D.19744 = iftmp.8;
  }
  if (D.19744 == 0) goto <D.24118>; else goto <D.24161>;
  <D.24161>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24165 = "MonoCMethod";
      D.24166 = MEM[(const unsigned char *)D.24165];
      D.24167 = (int) D.24166;
      D.24168 = *__s2;
      D.24169 = (int) D.24168;
      __result = D.24167 - D.24169;
      {
        D.24170 = __s2_len != 0;
        D.24171 = __result == 0;
        D.24172 = D.24170 & D.24171;
        if (D.24172 != 0) goto <D.24173>; else goto <D.24174>;
        <D.24173>:
        D.24175 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24176 = *D.24175;
        D.24177 = (int) D.24176;
        D.24178 = __s2 + 1;
        D.24179 = *D.24178;
        D.24180 = (int) D.24179;
        __result = D.24177 - D.24180;
        D.24181 = __s2_len > 1;
        D.24171 = __result == 0;
        D.24182 = D.24181 & D.24171;
        if (D.24182 != 0) goto <D.24183>; else goto <D.24184>;
        <D.24183>:
        D.24185 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24186 = *D.24185;
        D.24187 = (int) D.24186;
        D.24188 = __s2 + 2;
        D.24189 = *D.24188;
        D.24190 = (int) D.24189;
        __result = D.24187 - D.24190;
        D.24191 = __s2_len > 2;
        D.24171 = __result == 0;
        D.24192 = D.24191 & D.24171;
        if (D.24192 != 0) goto <D.24193>; else goto <D.24194>;
        <D.24193>:
        D.24195 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24196 = *D.24195;
        D.24197 = (int) D.24196;
        D.24198 = __s2 + 3;
        D.24199 = *D.24198;
        D.24200 = (int) D.24199;
        __result = D.24197 - D.24200;
        <D.24194>:
        <D.24184>:
        <D.24174>:
      }
      D.19752 = __result;
    }
    iftmp.9 = -D.19752;
    goto <D.24201>;
    <D.24164>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.9 = __builtin_strcmp (D.23982, "MonoCMethod");
    <D.24201>:
    D.19753 = iftmp.9;
  }
  if (D.19753 == 0) goto <D.24118>; else goto <D.24119>;
  <D.24118>:
  {
    struct MonoMethod * m;

    D.23942 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23942].method;
    D.24202 = assembly->method_to_table_idx;
    D.24203 = monoeg_g_hash_table_lookup (D.24202, m);
    idx = (guint32) D.24203;
  }
  goto <D.24120>;
  <D.24119>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4252);
  <D.24120>:
  <D.24117>:
  <D.24074>:
  goto <D.19716>;
  <D.19755>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24207 = "TypeBuilder";
      D.24208 = MEM[(const unsigned char *)D.24207];
      D.24209 = (int) D.24208;
      D.24210 = *__s2;
      D.24211 = (int) D.24210;
      __result = D.24209 - D.24211;
      {
        D.24212 = __s2_len != 0;
        D.24213 = __result == 0;
        D.24214 = D.24212 & D.24213;
        if (D.24214 != 0) goto <D.24215>; else goto <D.24216>;
        <D.24215>:
        D.24217 = &MEM[(void *)"TypeBuilder" + 1B];
        D.24218 = *D.24217;
        D.24219 = (int) D.24218;
        D.24220 = __s2 + 1;
        D.24221 = *D.24220;
        D.24222 = (int) D.24221;
        __result = D.24219 - D.24222;
        D.24223 = __s2_len > 1;
        D.24213 = __result == 0;
        D.24224 = D.24223 & D.24213;
        if (D.24224 != 0) goto <D.24225>; else goto <D.24226>;
        <D.24225>:
        D.24227 = &MEM[(void *)"TypeBuilder" + 2B];
        D.24228 = *D.24227;
        D.24229 = (int) D.24228;
        D.24230 = __s2 + 2;
        D.24231 = *D.24230;
        D.24232 = (int) D.24231;
        __result = D.24229 - D.24232;
        D.24233 = __s2_len > 2;
        D.24213 = __result == 0;
        D.24234 = D.24233 & D.24213;
        if (D.24234 != 0) goto <D.24235>; else goto <D.24236>;
        <D.24235>:
        D.24237 = &MEM[(void *)"TypeBuilder" + 3B];
        D.24238 = *D.24237;
        D.24239 = (int) D.24238;
        D.24240 = __s2 + 3;
        D.24241 = *D.24240;
        D.24242 = (int) D.24241;
        __result = D.24239 - D.24242;
        <D.24236>:
        <D.24226>:
        <D.24216>:
      }
      D.19763 = __result;
    }
    iftmp.10 = -D.19763;
    goto <D.24243>;
    <D.24206>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.10 = __builtin_strcmp (D.23982, "TypeBuilder");
    <D.24243>:
    D.19764 = iftmp.10;
  }
  if (D.19764 != 0) goto <D.24244>; else goto <D.24245>;
  <D.24244>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4257);
  <D.24245>:
  tb = iltoken->member;
  idx = tb->table_idx;
  goto <D.19716>;
  <D.19765>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24249 = "MonoArrayMethod";
      D.24250 = MEM[(const unsigned char *)D.24249];
      D.24251 = (int) D.24250;
      D.24252 = *__s2;
      D.24253 = (int) D.24252;
      __result = D.24251 - D.24253;
      {
        D.24254 = __s2_len != 0;
        D.24255 = __result == 0;
        D.24256 = D.24254 & D.24255;
        if (D.24256 != 0) goto <D.24257>; else goto <D.24258>;
        <D.24257>:
        D.24259 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.24260 = *D.24259;
        D.24261 = (int) D.24260;
        D.24262 = __s2 + 1;
        D.24263 = *D.24262;
        D.24264 = (int) D.24263;
        __result = D.24261 - D.24264;
        D.24265 = __s2_len > 1;
        D.24255 = __result == 0;
        D.24266 = D.24265 & D.24255;
        if (D.24266 != 0) goto <D.24267>; else goto <D.24268>;
        <D.24267>:
        D.24269 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.24270 = *D.24269;
        D.24271 = (int) D.24270;
        D.24272 = __s2 + 2;
        D.24273 = *D.24272;
        D.24274 = (int) D.24273;
        __result = D.24271 - D.24274;
        D.24275 = __s2_len > 2;
        D.24255 = __result == 0;
        D.24276 = D.24275 & D.24255;
        if (D.24276 != 0) goto <D.24277>; else goto <D.24278>;
        <D.24277>:
        D.24279 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.24280 = *D.24279;
        D.24281 = (int) D.24280;
        D.24282 = __s2 + 3;
        D.24283 = *D.24282;
        D.24284 = (int) D.24283;
        __result = D.24281 - D.24284;
        <D.24278>:
        <D.24268>:
        <D.24258>:
      }
      D.19773 = __result;
    }
    iftmp.11 = -D.19773;
    goto <D.24285>;
    <D.24248>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.11 = __builtin_strcmp (D.23982, "MonoArrayMethod");
    <D.24285>:
    D.19774 = iftmp.11;
  }
  if (D.19774 == 0) goto <D.24286>; else goto <D.24287>;
  <D.24286>:
  am = iltoken->member;
  idx = am->table_idx;
  goto <D.24288>;
  <D.24287>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24124 = "MonoMethod";
      D.24125 = MEM[(const unsigned char *)D.24124];
      D.24126 = (int) D.24125;
      D.24294 = *__s2;
      D.24295 = (int) D.24294;
      __result = D.24126 - D.24295;
      {
        D.24296 = __s2_len != 0;
        D.24297 = __result == 0;
        D.24298 = D.24296 & D.24297;
        if (D.24298 != 0) goto <D.24299>; else goto <D.24300>;
        <D.24299>:
        D.24134 = &MEM[(void *)"MonoMethod" + 1B];
        D.24135 = *D.24134;
        D.24136 = (int) D.24135;
        D.24301 = __s2 + 1;
        D.24302 = *D.24301;
        D.24303 = (int) D.24302;
        __result = D.24136 - D.24303;
        D.24304 = __s2_len > 1;
        D.24297 = __result == 0;
        D.24305 = D.24304 & D.24297;
        if (D.24305 != 0) goto <D.24306>; else goto <D.24307>;
        <D.24306>:
        D.24144 = &MEM[(void *)"MonoMethod" + 2B];
        D.24145 = *D.24144;
        D.24146 = (int) D.24145;
        D.24308 = __s2 + 2;
        D.24309 = *D.24308;
        D.24310 = (int) D.24309;
        __result = D.24146 - D.24310;
        D.24311 = __s2_len > 2;
        D.24297 = __result == 0;
        D.24312 = D.24311 & D.24297;
        if (D.24312 != 0) goto <D.24313>; else goto <D.24314>;
        <D.24313>:
        D.24154 = &MEM[(void *)"MonoMethod" + 3B];
        D.24155 = *D.24154;
        D.24156 = (int) D.24155;
        D.24315 = __s2 + 3;
        D.24316 = *D.24315;
        D.24317 = (int) D.24316;
        __result = D.24156 - D.24317;
        <D.24314>:
        <D.24307>:
        <D.24300>:
      }
      D.19782 = __result;
    }
    iftmp.12 = -D.19782;
    goto <D.24318>;
    <D.24293>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.12 = __builtin_strcmp (D.23982, "MonoMethod");
    <D.24318>:
    D.19783 = iftmp.12;
  }
  if (D.19783 == 0) goto <D.24289>; else goto <D.24319>;
  <D.24319>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24165 = "MonoCMethod";
      D.24166 = MEM[(const unsigned char *)D.24165];
      D.24167 = (int) D.24166;
      D.24323 = *__s2;
      D.24324 = (int) D.24323;
      __result = D.24167 - D.24324;
      {
        D.24325 = __s2_len != 0;
        D.24326 = __result == 0;
        D.24327 = D.24325 & D.24326;
        if (D.24327 != 0) goto <D.24328>; else goto <D.24329>;
        <D.24328>:
        D.24175 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24176 = *D.24175;
        D.24177 = (int) D.24176;
        D.24330 = __s2 + 1;
        D.24331 = *D.24330;
        D.24332 = (int) D.24331;
        __result = D.24177 - D.24332;
        D.24333 = __s2_len > 1;
        D.24326 = __result == 0;
        D.24334 = D.24333 & D.24326;
        if (D.24334 != 0) goto <D.24335>; else goto <D.24336>;
        <D.24335>:
        D.24185 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24186 = *D.24185;
        D.24187 = (int) D.24186;
        D.24337 = __s2 + 2;
        D.24338 = *D.24337;
        D.24339 = (int) D.24338;
        __result = D.24187 - D.24339;
        D.24340 = __s2_len > 2;
        D.24326 = __result == 0;
        D.24341 = D.24340 & D.24326;
        if (D.24341 != 0) goto <D.24342>; else goto <D.24343>;
        <D.24342>:
        D.24195 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24196 = *D.24195;
        D.24197 = (int) D.24196;
        D.24344 = __s2 + 3;
        D.24345 = *D.24344;
        D.24346 = (int) D.24345;
        __result = D.24197 - D.24346;
        <D.24343>:
        <D.24336>:
        <D.24329>:
      }
      D.19791 = __result;
    }
    iftmp.13 = -D.19791;
    goto <D.24347>;
    <D.24322>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.13 = __builtin_strcmp (D.23982, "MonoCMethod");
    <D.24347>:
    D.19792 = iftmp.13;
  }
  if (D.19792 == 0) goto <D.24289>; else goto <D.24348>;
  <D.24348>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24352 = "MonoGenericMethod";
      D.24353 = MEM[(const unsigned char *)D.24352];
      D.24354 = (int) D.24353;
      D.24355 = *__s2;
      D.24356 = (int) D.24355;
      __result = D.24354 - D.24356;
      {
        D.24357 = __s2_len != 0;
        D.24358 = __result == 0;
        D.24359 = D.24357 & D.24358;
        if (D.24359 != 0) goto <D.24360>; else goto <D.24361>;
        <D.24360>:
        D.24362 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24363 = *D.24362;
        D.24364 = (int) D.24363;
        D.24365 = __s2 + 1;
        D.24366 = *D.24365;
        D.24367 = (int) D.24366;
        __result = D.24364 - D.24367;
        D.24368 = __s2_len > 1;
        D.24358 = __result == 0;
        D.24369 = D.24368 & D.24358;
        if (D.24369 != 0) goto <D.24370>; else goto <D.24371>;
        <D.24370>:
        D.24372 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24373 = *D.24372;
        D.24374 = (int) D.24373;
        D.24375 = __s2 + 2;
        D.24376 = *D.24375;
        D.24377 = (int) D.24376;
        __result = D.24374 - D.24377;
        D.24378 = __s2_len > 2;
        D.24358 = __result == 0;
        D.24379 = D.24378 & D.24358;
        if (D.24379 != 0) goto <D.24380>; else goto <D.24381>;
        <D.24380>:
        D.24382 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24383 = *D.24382;
        D.24384 = (int) D.24383;
        D.24385 = __s2 + 3;
        D.24386 = *D.24385;
        D.24387 = (int) D.24386;
        __result = D.24384 - D.24387;
        <D.24381>:
        <D.24371>:
        <D.24361>:
      }
      D.19800 = __result;
    }
    iftmp.14 = -D.19800;
    goto <D.24388>;
    <D.24351>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.14 = __builtin_strcmp (D.23982, "MonoGenericMethod");
    <D.24388>:
    D.19801 = iftmp.14;
  }
  if (D.19801 == 0) goto <D.24289>; else goto <D.24389>;
  <D.24389>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24393 = "MonoGenericCMethod";
      D.24394 = MEM[(const unsigned char *)D.24393];
      D.24395 = (int) D.24394;
      D.24396 = *__s2;
      D.24397 = (int) D.24396;
      __result = D.24395 - D.24397;
      {
        D.24398 = __s2_len != 0;
        D.24399 = __result == 0;
        D.24400 = D.24398 & D.24399;
        if (D.24400 != 0) goto <D.24401>; else goto <D.24402>;
        <D.24401>:
        D.24403 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.24404 = *D.24403;
        D.24405 = (int) D.24404;
        D.24406 = __s2 + 1;
        D.24407 = *D.24406;
        D.24408 = (int) D.24407;
        __result = D.24405 - D.24408;
        D.24409 = __s2_len > 1;
        D.24399 = __result == 0;
        D.24410 = D.24409 & D.24399;
        if (D.24410 != 0) goto <D.24411>; else goto <D.24412>;
        <D.24411>:
        D.24413 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.24414 = *D.24413;
        D.24415 = (int) D.24414;
        D.24416 = __s2 + 2;
        D.24417 = *D.24416;
        D.24418 = (int) D.24417;
        __result = D.24415 - D.24418;
        D.24419 = __s2_len > 2;
        D.24399 = __result == 0;
        D.24420 = D.24419 & D.24399;
        if (D.24420 != 0) goto <D.24421>; else goto <D.24422>;
        <D.24421>:
        D.24423 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.24424 = *D.24423;
        D.24425 = (int) D.24424;
        D.24426 = __s2 + 3;
        D.24427 = *D.24426;
        D.24428 = (int) D.24427;
        __result = D.24425 - D.24428;
        <D.24422>:
        <D.24412>:
        <D.24402>:
      }
      D.19809 = __result;
    }
    iftmp.15 = -D.19809;
    goto <D.24429>;
    <D.24392>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.15 = __builtin_strcmp (D.23982, "MonoGenericCMethod");
    <D.24429>:
    D.19810 = iftmp.15;
  }
  if (D.19810 == 0) goto <D.24289>; else goto <D.24290>;
  <D.24289>:
  {
    struct MonoMethod * m;

    D.23942 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23942].method;
    D.24433 = m->klass;
    D.24434 = D.24433->generic_class;
    if (D.24434 == 0B) goto <D.24435>; else goto <D.24431>;
    <D.24435>:
    D.24433 = m->klass;
    D.24436 = D.24433->generic_container;
    if (D.24436 == 0B) goto <D.24437>; else goto <D.24431>;
    <D.24437>:
    iftmp.16 = 1;
    goto <D.24432>;
    <D.24431>:
    iftmp.16 = 0;
    <D.24432>:
    D.24438 = iftmp.16 != 0;
    D.24439 = (long int) D.24438;
    D.24440 = __builtin_expect (D.24439, 0);
    if (D.24440 != 0) goto <D.24441>; else goto <D.24442>;
    <D.24441>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4270, "m->klass->generic_class || m->klass->generic_container");
    <D.24442>:
    // predicted unlikely by continue predictor.
    goto <D.19812>;
  }
  <D.24290>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.23945 = "FieldBuilder";
      D.23946 = MEM[(const unsigned char *)D.23945];
      D.23947 = (int) D.23946;
      D.24446 = *__s2;
      D.24447 = (int) D.24446;
      __result = D.23947 - D.24447;
      {
        D.24448 = __s2_len != 0;
        D.24449 = __result == 0;
        D.24450 = D.24448 & D.24449;
        if (D.24450 != 0) goto <D.24451>; else goto <D.24452>;
        <D.24451>:
        D.23955 = &MEM[(void *)"FieldBuilder" + 1B];
        D.23956 = *D.23955;
        D.23957 = (int) D.23956;
        D.24453 = __s2 + 1;
        D.24454 = *D.24453;
        D.24455 = (int) D.24454;
        __result = D.23957 - D.24455;
        D.24456 = __s2_len > 1;
        D.24449 = __result == 0;
        D.24457 = D.24456 & D.24449;
        if (D.24457 != 0) goto <D.24458>; else goto <D.24459>;
        <D.24458>:
        D.23965 = &MEM[(void *)"FieldBuilder" + 2B];
        D.23966 = *D.23965;
        D.23967 = (int) D.23966;
        D.24460 = __s2 + 2;
        D.24461 = *D.24460;
        D.24462 = (int) D.24461;
        __result = D.23967 - D.24462;
        D.24463 = __s2_len > 2;
        D.24449 = __result == 0;
        D.24464 = D.24463 & D.24449;
        if (D.24464 != 0) goto <D.24465>; else goto <D.24466>;
        <D.24465>:
        D.23975 = &MEM[(void *)"FieldBuilder" + 3B];
        D.23976 = *D.23975;
        D.23977 = (int) D.23976;
        D.24467 = __s2 + 3;
        D.24468 = *D.24467;
        D.24469 = (int) D.24468;
        __result = D.23977 - D.24469;
        <D.24466>:
        <D.24459>:
        <D.24452>:
      }
      D.19820 = __result;
    }
    iftmp.17 = -D.19820;
    goto <D.24470>;
    <D.24445>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.17 = __builtin_strcmp (D.23982, "FieldBuilder");
    <D.24470>:
    D.19821 = iftmp.17;
  }
  if (D.19821 == 0) goto <D.24471>; else goto <D.24472>;
  <D.24471>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24472>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.23990 = "MonoField";
      D.23991 = MEM[(const unsigned char *)D.23990];
      D.23992 = (int) D.23991;
      D.24476 = *__s2;
      D.24477 = (int) D.24476;
      __result = D.23992 - D.24477;
      {
        D.24478 = __s2_len != 0;
        D.24479 = __result == 0;
        D.24480 = D.24478 & D.24479;
        if (D.24480 != 0) goto <D.24481>; else goto <D.24482>;
        <D.24481>:
        D.24000 = &MEM[(void *)"MonoField" + 1B];
        D.24001 = *D.24000;
        D.24002 = (int) D.24001;
        D.24483 = __s2 + 1;
        D.24484 = *D.24483;
        D.24485 = (int) D.24484;
        __result = D.24002 - D.24485;
        D.24486 = __s2_len > 1;
        D.24479 = __result == 0;
        D.24487 = D.24486 & D.24479;
        if (D.24487 != 0) goto <D.24488>; else goto <D.24489>;
        <D.24488>:
        D.24010 = &MEM[(void *)"MonoField" + 2B];
        D.24011 = *D.24010;
        D.24012 = (int) D.24011;
        D.24490 = __s2 + 2;
        D.24491 = *D.24490;
        D.24492 = (int) D.24491;
        __result = D.24012 - D.24492;
        D.24493 = __s2_len > 2;
        D.24479 = __result == 0;
        D.24494 = D.24493 & D.24479;
        if (D.24494 != 0) goto <D.24495>; else goto <D.24496>;
        <D.24495>:
        D.24020 = &MEM[(void *)"MonoField" + 3B];
        D.24021 = *D.24020;
        D.24022 = (int) D.24021;
        D.24497 = __s2 + 3;
        D.24498 = *D.24497;
        D.24499 = (int) D.24498;
        __result = D.24022 - D.24499;
        <D.24496>:
        <D.24489>:
        <D.24482>:
      }
      D.19829 = __result;
    }
    iftmp.18 = -D.19829;
    goto <D.24500>;
    <D.24475>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.18 = __builtin_strcmp (D.23982, "MonoField");
    <D.24500>:
    D.19830 = iftmp.18;
  }
  if (D.19830 == 0) goto <D.24501>; else goto <D.24502>;
  <D.24501>:
  {
    struct MonoClassField * f;

    D.23942 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.23942].field;
    D.24503 = is_field_on_inst (f);
    D.24504 = D.24503 == 0;
    D.24505 = (long int) D.24504;
    D.24506 = __builtin_expect (D.24505, 0);
    if (D.24506 != 0) goto <D.24507>; else goto <D.24508>;
    <D.24507>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4276, "is_field_on_inst (f)");
    <D.24508>:
    // predicted unlikely by continue predictor.
    goto <D.19812>;
  }
  <D.24502>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24035 = "MethodBuilder";
      D.24036 = MEM[(const unsigned char *)D.24035];
      D.24037 = (int) D.24036;
      D.24514 = *__s2;
      D.24515 = (int) D.24514;
      __result = D.24037 - D.24515;
      {
        D.24516 = __s2_len != 0;
        D.24517 = __result == 0;
        D.24518 = D.24516 & D.24517;
        if (D.24518 != 0) goto <D.24519>; else goto <D.24520>;
        <D.24519>:
        D.24045 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24046 = *D.24045;
        D.24047 = (int) D.24046;
        D.24521 = __s2 + 1;
        D.24522 = *D.24521;
        D.24523 = (int) D.24522;
        __result = D.24047 - D.24523;
        D.24524 = __s2_len > 1;
        D.24517 = __result == 0;
        D.24525 = D.24524 & D.24517;
        if (D.24525 != 0) goto <D.24526>; else goto <D.24527>;
        <D.24526>:
        D.24055 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24056 = *D.24055;
        D.24057 = (int) D.24056;
        D.24528 = __s2 + 2;
        D.24529 = *D.24528;
        D.24530 = (int) D.24529;
        __result = D.24057 - D.24530;
        D.24531 = __s2_len > 2;
        D.24517 = __result == 0;
        D.24532 = D.24531 & D.24517;
        if (D.24532 != 0) goto <D.24533>; else goto <D.24534>;
        <D.24533>:
        D.24065 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24066 = *D.24065;
        D.24067 = (int) D.24066;
        D.24535 = __s2 + 3;
        D.24536 = *D.24535;
        D.24537 = (int) D.24536;
        __result = D.24067 - D.24537;
        <D.24534>:
        <D.24527>:
        <D.24520>:
      }
      D.19839 = __result;
    }
    iftmp.19 = -D.19839;
    goto <D.24538>;
    <D.24513>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.19 = __builtin_strcmp (D.23982, "MethodBuilder");
    <D.24538>:
    D.19840 = iftmp.19;
  }
  if (D.19840 == 0) goto <D.24509>; else goto <D.24539>;
  <D.24539>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24078 = "ConstructorBuilder";
      D.24079 = MEM[(const unsigned char *)D.24078];
      D.24080 = (int) D.24079;
      D.24543 = *__s2;
      D.24544 = (int) D.24543;
      __result = D.24080 - D.24544;
      {
        D.24545 = __s2_len != 0;
        D.24546 = __result == 0;
        D.24547 = D.24545 & D.24546;
        if (D.24547 != 0) goto <D.24548>; else goto <D.24549>;
        <D.24548>:
        D.24088 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24089 = *D.24088;
        D.24090 = (int) D.24089;
        D.24550 = __s2 + 1;
        D.24551 = *D.24550;
        D.24552 = (int) D.24551;
        __result = D.24090 - D.24552;
        D.24553 = __s2_len > 1;
        D.24546 = __result == 0;
        D.24554 = D.24553 & D.24546;
        if (D.24554 != 0) goto <D.24555>; else goto <D.24556>;
        <D.24555>:
        D.24098 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24099 = *D.24098;
        D.24100 = (int) D.24099;
        D.24557 = __s2 + 2;
        D.24558 = *D.24557;
        D.24559 = (int) D.24558;
        __result = D.24100 - D.24559;
        D.24560 = __s2_len > 2;
        D.24546 = __result == 0;
        D.24561 = D.24560 & D.24546;
        if (D.24561 != 0) goto <D.24562>; else goto <D.24563>;
        <D.24562>:
        D.24108 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24109 = *D.24108;
        D.24110 = (int) D.24109;
        D.24564 = __s2 + 3;
        D.24565 = *D.24564;
        D.24566 = (int) D.24565;
        __result = D.24110 - D.24566;
        <D.24563>:
        <D.24556>:
        <D.24549>:
      }
      D.19848 = __result;
    }
    iftmp.20 = -D.19848;
    goto <D.24567>;
    <D.24542>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.20 = __builtin_strcmp (D.23982, "ConstructorBuilder");
    <D.24567>:
    D.19849 = iftmp.20;
  }
  if (D.19849 == 0) goto <D.24509>; else goto <D.24510>;
  <D.24509>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24510>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24571 = "FieldOnTypeBuilderInst";
      D.24572 = MEM[(const unsigned char *)D.24571];
      D.24573 = (int) D.24572;
      D.24574 = *__s2;
      D.24575 = (int) D.24574;
      __result = D.24573 - D.24575;
      {
        D.24576 = __s2_len != 0;
        D.24577 = __result == 0;
        D.24578 = D.24576 & D.24577;
        if (D.24578 != 0) goto <D.24579>; else goto <D.24580>;
        <D.24579>:
        D.24581 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.24582 = *D.24581;
        D.24583 = (int) D.24582;
        D.24584 = __s2 + 1;
        D.24585 = *D.24584;
        D.24586 = (int) D.24585;
        __result = D.24583 - D.24586;
        D.24587 = __s2_len > 1;
        D.24577 = __result == 0;
        D.24588 = D.24587 & D.24577;
        if (D.24588 != 0) goto <D.24589>; else goto <D.24590>;
        <D.24589>:
        D.24591 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.24592 = *D.24591;
        D.24593 = (int) D.24592;
        D.24594 = __s2 + 2;
        D.24595 = *D.24594;
        D.24596 = (int) D.24595;
        __result = D.24593 - D.24596;
        D.24597 = __s2_len > 2;
        D.24577 = __result == 0;
        D.24598 = D.24597 & D.24577;
        if (D.24598 != 0) goto <D.24599>; else goto <D.24600>;
        <D.24599>:
        D.24601 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.24602 = *D.24601;
        D.24603 = (int) D.24602;
        D.24604 = __s2 + 3;
        D.24605 = *D.24604;
        D.24606 = (int) D.24605;
        __result = D.24603 - D.24606;
        <D.24600>:
        <D.24590>:
        <D.24580>:
      }
      D.19857 = __result;
    }
    iftmp.21 = -D.19857;
    goto <D.24607>;
    <D.24570>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.21 = __builtin_strcmp (D.23982, "FieldOnTypeBuilderInst");
    <D.24607>:
    D.19858 = iftmp.21;
  }
  if (D.19858 == 0) goto <D.24608>; else goto <D.24609>;
  <D.24608>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24609>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24613 = "MethodOnTypeBuilderInst";
      D.24614 = MEM[(const unsigned char *)D.24613];
      D.24615 = (int) D.24614;
      D.24616 = *__s2;
      D.24617 = (int) D.24616;
      __result = D.24615 - D.24617;
      {
        D.24618 = __s2_len != 0;
        D.24619 = __result == 0;
        D.24620 = D.24618 & D.24619;
        if (D.24620 != 0) goto <D.24621>; else goto <D.24622>;
        <D.24621>:
        D.24623 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24624 = *D.24623;
        D.24625 = (int) D.24624;
        D.24626 = __s2 + 1;
        D.24627 = *D.24626;
        D.24628 = (int) D.24627;
        __result = D.24625 - D.24628;
        D.24629 = __s2_len > 1;
        D.24619 = __result == 0;
        D.24630 = D.24629 & D.24619;
        if (D.24630 != 0) goto <D.24631>; else goto <D.24632>;
        <D.24631>:
        D.24633 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.24634 = *D.24633;
        D.24635 = (int) D.24634;
        D.24636 = __s2 + 2;
        D.24637 = *D.24636;
        D.24638 = (int) D.24637;
        __result = D.24635 - D.24638;
        D.24639 = __s2_len > 2;
        D.24619 = __result == 0;
        D.24640 = D.24639 & D.24619;
        if (D.24640 != 0) goto <D.24641>; else goto <D.24642>;
        <D.24641>:
        D.24643 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.24644 = *D.24643;
        D.24645 = (int) D.24644;
        D.24646 = __s2 + 3;
        D.24647 = *D.24646;
        D.24648 = (int) D.24647;
        __result = D.24645 - D.24648;
        <D.24642>:
        <D.24632>:
        <D.24622>:
      }
      D.19866 = __result;
    }
    iftmp.22 = -D.19866;
    goto <D.24649>;
    <D.24612>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.22 = __builtin_strcmp (D.23982, "MethodOnTypeBuilderInst");
    <D.24649>:
    D.19867 = iftmp.22;
  }
  if (D.19867 == 0) goto <D.24650>; else goto <D.24651>;
  <D.24650>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24651>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24655 = "ConstructorOnTypeBuilderInst";
      D.24656 = MEM[(const unsigned char *)D.24655];
      D.24657 = (int) D.24656;
      D.24658 = *__s2;
      D.24659 = (int) D.24658;
      __result = D.24657 - D.24659;
      {
        D.24660 = __s2_len != 0;
        D.24661 = __result == 0;
        D.24662 = D.24660 & D.24661;
        if (D.24662 != 0) goto <D.24663>; else goto <D.24664>;
        <D.24663>:
        D.24665 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.24666 = *D.24665;
        D.24667 = (int) D.24666;
        D.24668 = __s2 + 1;
        D.24669 = *D.24668;
        D.24670 = (int) D.24669;
        __result = D.24667 - D.24670;
        D.24671 = __s2_len > 1;
        D.24661 = __result == 0;
        D.24672 = D.24671 & D.24661;
        if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
        <D.24673>:
        D.24675 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.24676 = *D.24675;
        D.24677 = (int) D.24676;
        D.24678 = __s2 + 2;
        D.24679 = *D.24678;
        D.24680 = (int) D.24679;
        __result = D.24677 - D.24680;
        D.24681 = __s2_len > 2;
        D.24661 = __result == 0;
        D.24682 = D.24681 & D.24661;
        if (D.24682 != 0) goto <D.24683>; else goto <D.24684>;
        <D.24683>:
        D.24685 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.24686 = *D.24685;
        D.24687 = (int) D.24686;
        D.24688 = __s2 + 3;
        D.24689 = *D.24688;
        D.24690 = (int) D.24689;
        __result = D.24687 - D.24690;
        <D.24684>:
        <D.24674>:
        <D.24664>:
      }
      D.19875 = __result;
    }
    iftmp.23 = -D.19875;
    goto <D.24691>;
    <D.24654>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.23 = __builtin_strcmp (D.23982, "ConstructorOnTypeBuilderInst");
    <D.24691>:
    D.19876 = iftmp.23;
  }
  if (D.19876 == 0) goto <D.24692>; else goto <D.24693>;
  <D.24692>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24693>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4288);
  <D.24288>:
  goto <D.19716>;
  <D.19877>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24352 = "MonoGenericMethod";
      D.24353 = MEM[(const unsigned char *)D.24352];
      D.24354 = (int) D.24353;
      D.24697 = *__s2;
      D.24698 = (int) D.24697;
      __result = D.24354 - D.24698;
      {
        D.24699 = __s2_len != 0;
        D.24700 = __result == 0;
        D.24701 = D.24699 & D.24700;
        if (D.24701 != 0) goto <D.24702>; else goto <D.24703>;
        <D.24702>:
        D.24362 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24363 = *D.24362;
        D.24364 = (int) D.24363;
        D.24704 = __s2 + 1;
        D.24705 = *D.24704;
        D.24706 = (int) D.24705;
        __result = D.24364 - D.24706;
        D.24707 = __s2_len > 1;
        D.24700 = __result == 0;
        D.24708 = D.24707 & D.24700;
        if (D.24708 != 0) goto <D.24709>; else goto <D.24710>;
        <D.24709>:
        D.24372 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24373 = *D.24372;
        D.24374 = (int) D.24373;
        D.24711 = __s2 + 2;
        D.24712 = *D.24711;
        D.24713 = (int) D.24712;
        __result = D.24374 - D.24713;
        D.24714 = __s2_len > 2;
        D.24700 = __result == 0;
        D.24715 = D.24714 & D.24700;
        if (D.24715 != 0) goto <D.24716>; else goto <D.24717>;
        <D.24716>:
        D.24382 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24383 = *D.24382;
        D.24384 = (int) D.24383;
        D.24718 = __s2 + 3;
        D.24719 = *D.24718;
        D.24720 = (int) D.24719;
        __result = D.24384 - D.24720;
        <D.24717>:
        <D.24710>:
        <D.24703>:
      }
      D.19885 = __result;
    }
    iftmp.24 = -D.19885;
    goto <D.24721>;
    <D.24696>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.24 = __builtin_strcmp (D.23982, "MonoGenericMethod");
    <D.24721>:
    D.19886 = iftmp.24;
  }
  if (D.19886 == 0) goto <D.24722>; else goto <D.24723>;
  <D.24722>:
  {
    struct MonoMethod * m;

    D.23942 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.23942].method;
    D.24724 = mono_method_signature (m);
    D.24725 = D.24724->generic_param_count;
    D.24726 = D.24725 == 0;
    D.24727 = (long int) D.24726;
    D.24728 = __builtin_expect (D.24727, 0);
    if (D.24728 != 0) goto <D.24729>; else goto <D.24730>;
    <D.24729>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4294, "mono_method_signature (m)->generic_param_count");
    <D.24730>:
    // predicted unlikely by continue predictor.
    goto <D.19812>;
  }
  <D.24723>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24035 = "MethodBuilder";
      D.24036 = MEM[(const unsigned char *)D.24035];
      D.24037 = (int) D.24036;
      D.24734 = *__s2;
      D.24735 = (int) D.24734;
      __result = D.24037 - D.24735;
      {
        D.24736 = __s2_len != 0;
        D.24737 = __result == 0;
        D.24738 = D.24736 & D.24737;
        if (D.24738 != 0) goto <D.24739>; else goto <D.24740>;
        <D.24739>:
        D.24045 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24046 = *D.24045;
        D.24047 = (int) D.24046;
        D.24741 = __s2 + 1;
        D.24742 = *D.24741;
        D.24743 = (int) D.24742;
        __result = D.24047 - D.24743;
        D.24744 = __s2_len > 1;
        D.24737 = __result == 0;
        D.24745 = D.24744 & D.24737;
        if (D.24745 != 0) goto <D.24746>; else goto <D.24747>;
        <D.24746>:
        D.24055 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24056 = *D.24055;
        D.24057 = (int) D.24056;
        D.24748 = __s2 + 2;
        D.24749 = *D.24748;
        D.24750 = (int) D.24749;
        __result = D.24057 - D.24750;
        D.24751 = __s2_len > 2;
        D.24737 = __result == 0;
        D.24752 = D.24751 & D.24737;
        if (D.24752 != 0) goto <D.24753>; else goto <D.24754>;
        <D.24753>:
        D.24065 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24066 = *D.24065;
        D.24067 = (int) D.24066;
        D.24755 = __s2 + 3;
        D.24756 = *D.24755;
        D.24757 = (int) D.24756;
        __result = D.24067 - D.24757;
        <D.24754>:
        <D.24747>:
        <D.24740>:
      }
      D.19895 = __result;
    }
    iftmp.25 = -D.19895;
    goto <D.24758>;
    <D.24733>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.25 = __builtin_strcmp (D.23982, "MethodBuilder");
    <D.24758>:
    D.19896 = iftmp.25;
  }
  if (D.19896 == 0) goto <D.24759>; else goto <D.24760>;
  <D.24759>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24760>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.23942 = iltoken->member;
      D.23943 = D.23942->vtable;
      D.23944 = D.23943->klass;
      __s2 = D.23944->name;
      D.24613 = "MethodOnTypeBuilderInst";
      D.24614 = MEM[(const unsigned char *)D.24613];
      D.24615 = (int) D.24614;
      D.24764 = *__s2;
      D.24765 = (int) D.24764;
      __result = D.24615 - D.24765;
      {
        D.24766 = __s2_len != 0;
        D.24767 = __result == 0;
        D.24768 = D.24766 & D.24767;
        if (D.24768 != 0) goto <D.24769>; else goto <D.24770>;
        <D.24769>:
        D.24623 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24624 = *D.24623;
        D.24625 = (int) D.24624;
        D.24771 = __s2 + 1;
        D.24772 = *D.24771;
        D.24773 = (int) D.24772;
        __result = D.24625 - D.24773;
        D.24774 = __s2_len > 1;
        D.24767 = __result == 0;
        D.24775 = D.24774 & D.24767;
        if (D.24775 != 0) goto <D.24776>; else goto <D.24777>;
        <D.24776>:
        D.24633 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.24634 = *D.24633;
        D.24635 = (int) D.24634;
        D.24778 = __s2 + 2;
        D.24779 = *D.24778;
        D.24780 = (int) D.24779;
        __result = D.24635 - D.24780;
        D.24781 = __s2_len > 2;
        D.24767 = __result == 0;
        D.24782 = D.24781 & D.24767;
        if (D.24782 != 0) goto <D.24783>; else goto <D.24784>;
        <D.24783>:
        D.24643 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.24644 = *D.24643;
        D.24645 = (int) D.24644;
        D.24785 = __s2 + 3;
        D.24786 = *D.24785;
        D.24787 = (int) D.24786;
        __result = D.24645 - D.24787;
        <D.24784>:
        <D.24777>:
        <D.24770>:
      }
      D.19904 = __result;
    }
    iftmp.26 = -D.19904;
    goto <D.24788>;
    <D.24763>:
    D.23942 = iltoken->member;
    D.23943 = D.23942->vtable;
    D.23944 = D.23943->klass;
    D.23982 = D.23944->name;
    iftmp.26 = __builtin_strcmp (D.23982, "MethodOnTypeBuilderInst");
    <D.24788>:
    D.19905 = iftmp.26;
  }
  if (D.19905 == 0) goto <D.24789>; else goto <D.24790>;
  <D.24789>:
  // predicted unlikely by continue predictor.
  goto <D.19812>;
  <D.24790>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4301);
  <D.19906>:
  D.23936 = target + 3;
  D.23937 = *D.23936;
  D.23938 = (int) D.23937;
  monoeg_g_log (0B, 4, "got unexpected table 0x%02x in fixup", D.23938);
  <D.19907>:
  goto <D.19907>;
  <D.19716>:
  D.24791 = (unsigned char) idx;
  *target = D.24791;
  D.24792 = target + 1;
  D.24793 = idx >> 8;
  D.24794 = (unsigned char) D.24793;
  *D.24792 = D.24794;
  D.24795 = target + 2;
  D.24796 = idx >> 16;
  D.24797 = (unsigned char) D.24796;
  *D.24795 = D.24797;
  <D.19812>:
  i = i + 1;
  <D.19909>:
  D.24798 = ilgen->num_token_fixups;
  D.24799 = (unsigned int) D.24798;
  if (D.24799 > i) goto <D.19908>; else goto <D.19910>;
  <D.19910>:
}


is_field_on_inst (struct MonoClassField * field)
{
  gboolean D.24800;
  int iftmp.27;
  struct MonoClass * D.24804;
  struct MonoGenericClass * D.24805;
  unsigned char D.24807;
  unsigned char D.24808;
  struct MonoClassField * D.24810;

  D.24804 = field->parent;
  D.24805 = D.24804->generic_class;
  if (D.24805 != 0B) goto <D.24806>; else goto <D.24802>;
  <D.24806>:
  D.24804 = field->parent;
  D.24805 = D.24804->generic_class;
  D.24807 = BIT_FIELD_REF <*D.24805, 8, 96>;
  D.24808 = D.24807 & 1;
  if (D.24808 != 0) goto <D.24809>; else goto <D.24802>;
  <D.24809>:
  D.24804 = field->parent;
  D.24805 = D.24804->generic_class;
  D.24810 = MEM[(struct MonoDynamicGenericClass *)D.24805].fields;
  if (D.24810 != 0B) goto <D.24811>; else goto <D.24802>;
  <D.24811>:
  iftmp.27 = 1;
  goto <D.24803>;
  <D.24802>:
  iftmp.27 = 0;
  <D.24803>:
  D.24800 = iftmp.27;
  return D.24800;
}


compare_types_by_table_idx (struct MonoReflectionTypeBuilder * * type1, struct MonoReflectionTypeBuilder * * type2)
{
  struct MonoReflectionTypeBuilder * D.24813;
  unsigned int D.24814;
  struct MonoReflectionTypeBuilder * D.24815;
  unsigned int D.24816;
  gint D.24819;

  D.24813 = *type1;
  D.24814 = D.24813->table_idx;
  D.24815 = *type2;
  D.24816 = D.24815->table_idx;
  if (D.24814 < D.24816) goto <D.24817>; else goto <D.24818>;
  <D.24817>:
  D.24819 = -1;
  return D.24819;
  <D.24818>:
  D.24813 = *type1;
  D.24814 = D.24813->table_idx;
  D.24815 = *type2;
  D.24816 = D.24815->table_idx;
  if (D.24814 > D.24816) goto <D.24820>; else goto <D.24821>;
  <D.24820>:
  D.24819 = 1;
  return D.24819;
  <D.24821>:
  D.24819 = 0;
  return D.24819;
}


mono_image_emit_manifest (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.24823;
  guint32 * D.24824;
  guint32 iftmp.28;
  unsigned int D.24826;
  guint32 * D.24830;
  struct MonoString * D.24831;
  struct MonoDynamicStream * D.24832;
  unsigned int D.24833;
  struct MonoString * D.24834;
  guint32 * D.24837;
  unsigned int D.24838;
  unsigned int D.24840;
  guint32 * D.24841;
  struct MonoArray * D.24842;
  unsigned int D.24843;
  guint32 * D.24844;
  unsigned int D.24845;
  struct MonoString * D.24846;
  unsigned int i.29;
  struct MonoArray * D.24848;
  char * D.24849;
  struct MonoArray * D.24852;
  unsigned int j.30;
  char * D.24856;
  int D.24857;
  unsigned int D.24858;
  struct MonoArray * D.24859;
  char * D.24862;
  unsigned int D.24863;
  struct MonoArray * D.24864;
  char * D.24867;
  struct MonoArray * D.24870;
  unsigned int D.24873;
  unsigned int j.31;
  unsigned int D.24875;
  unsigned int D.24876;
  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.24823 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.24823->domain;
  table = &assembly->tables[32];
  alloc_table (table, 1);
  D.24824 = table->values;
  values = D.24824 + 36;
  D.24826 = assemblyb->algid;
  if (D.24826 != 0) goto <D.24827>; else goto <D.24828>;
  <D.24827>:
  iftmp.28 = assemblyb->algid;
  goto <D.24829>;
  <D.24828>:
  iftmp.28 = 32772;
  <D.24829>:
  *values = iftmp.28;
  D.24830 = values + 28;
  D.24831 = assemblyb->name;
  D.24832 = &assembly->sheap;
  D.24833 = string_heap_insert_mstring (D.24832, D.24831);
  *D.24830 = D.24833;
  D.24834 = assemblyb->culture;
  if (D.24834 != 0B) goto <D.24835>; else goto <D.24836>;
  <D.24835>:
  D.24837 = values + 32;
  D.24834 = assemblyb->culture;
  D.24832 = &assembly->sheap;
  D.24838 = string_heap_insert_mstring (D.24832, D.24834);
  *D.24837 = D.24838;
  goto <D.24839>;
  <D.24836>:
  D.24837 = values + 32;
  D.24832 = &assembly->sheap;
  D.24840 = string_heap_insert (D.24832, "");
  *D.24837 = D.24840;
  <D.24839>:
  D.24841 = values + 24;
  D.24842 = assemblyb->public_key;
  D.24843 = load_public_key (D.24842, assembly);
  *D.24841 = D.24843;
  D.24844 = values + 20;
  D.24845 = assemblyb->flags;
  *D.24844 = D.24845;
  D.24846 = assemblyb->version;
  set_version_from_string (D.24846, values);
  module_index = 0;
  i = 0;
  goto <D.20008>;
  <D.20007>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    i.29 = (unsigned int) i;
    D.24848 = assemblyb->modules;
    D.24849 = mono_array_addr_with_size (D.24848, 4, i.29);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.24849];
    if (file_module != moduleb) goto <D.24850>; else goto <D.24851>;
    <D.24850>:
    mono_image_fill_file_table (domain, file_module, assembly);
    module_index = module_index + 1;
    D.24852 = file_module->types;
    if (D.24852 != 0B) goto <D.24853>; else goto <D.24854>;
    <D.24853>:
    j = 0;
    goto <D.20005>;
    <D.20004>:
    {
      struct MonoReflectionTypeBuilder * tb;

      j.30 = (unsigned int) j;
      D.24852 = file_module->types;
      D.24856 = mono_array_addr_with_size (D.24852, 4, j.30);
      tb = MEM[(struct MonoReflectionTypeBuilder * *)D.24856];
      mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
    }
    j = j + 1;
    <D.20005>:
    D.24857 = file_module->num_types;
    if (D.24857 > j) goto <D.20004>; else goto <D.20006>;
    <D.20006>:
    <D.24854>:
    <D.24851>:
  }
  i = i + 1;
  <D.20008>:
  i.29 = (unsigned int) i;
  D.24848 = assemblyb->modules;
  D.24858 = mono_array_length (D.24848);
  if (i.29 < D.24858) goto <D.20007>; else goto <D.20009>;
  <D.20009>:
  D.24859 = assemblyb->loaded_modules;
  if (D.24859 != 0B) goto <D.24860>; else goto <D.24861>;
  <D.24860>:
  i = 0;
  goto <D.20012>;
  <D.20011>:
  {
    struct MonoReflectionModule * file_module;

    i.29 = (unsigned int) i;
    D.24859 = assemblyb->loaded_modules;
    D.24862 = mono_array_addr_with_size (D.24859, 4, i.29);
    file_module = MEM[(struct MonoReflectionModule * *)D.24862];
    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.20012>:
  i.29 = (unsigned int) i;
  D.24859 = assemblyb->loaded_modules;
  D.24863 = mono_array_length (D.24859);
  if (i.29 < D.24863) goto <D.20011>; else goto <D.20013>;
  <D.20013>:
  <D.24861>:
  D.24864 = assemblyb->type_forwarders;
  if (D.24864 != 0B) goto <D.24865>; else goto <D.24866>;
  <D.24865>:
  mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
  <D.24866>:
  module_index = 0;
  i = 0;
  goto <D.20022>;
  <D.20021>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    i.29 = (unsigned int) i;
    D.24848 = assemblyb->modules;
    D.24867 = mono_array_addr_with_size (D.24848, 4, i.29);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.24867];
    if (file_module != moduleb) goto <D.24868>; else goto <D.24869>;
    <D.24868>:
    module_index = module_index + 1;
    D.24870 = file_module->resources;
    if (D.24870 != 0B) goto <D.24871>; else goto <D.24872>;
    <D.24871>:
    {
      int len;

      D.24870 = file_module->resources;
      D.24873 = mono_array_length (D.24870);
      len = (int) D.24873;
      j = 0;
      goto <D.20019>;
      <D.20018>:
      {
        struct MonoReflectionResource * res;

        j.31 = (unsigned int) j;
        D.24870 = file_module->resources;
        res = mono_array_addr_with_size (D.24870, 24, j.31);
        D.24875 = module_index << 2;
        assembly_add_resource_manifest (file_module, assembly, res, D.24875);
      }
      j = j + 1;
      <D.20019>:
      if (j < len) goto <D.20018>; else goto <D.20020>;
      <D.20020>:
    }
    <D.24872>:
    <D.24869>:
  }
  i = i + 1;
  <D.20022>:
  i.29 = (unsigned int) i;
  D.24848 = assemblyb->modules;
  D.24876 = mono_array_length (D.24848);
  if (i.29 < D.24876) goto <D.20021>; else goto <D.20023>;
  <D.20023>:
}


load_public_key (struct MonoArray * pkey, struct MonoDynamicImage * assembly)
{
  guint32 D.24879;
  char * b.32;
  int b.33;
  int blob_size.34;
  int D.24883;
  unsigned int D.24884;
  struct MonoDynamicStream * D.24885;
  char * D.24886;
  void * D.24887;
  char * D.24888;
  guint8 * D.24889;
  int len.35;
  char * D.24894;
  int D.24895;
  unsigned int D.24899;
  unsigned int D.24901;
  int D.24902;
  unsigned int D.24903;
  void * D.24904;
  gsize len;
  guint32 token;
  char blob_size[6];
  char * b;

  try
    {
      token = 0;
      b = &blob_size;
      if (pkey == 0B) goto <D.24877>; else goto <D.24878>;
      <D.24877>:
      D.24879 = token;
      return D.24879;
      <D.24878>:
      len = mono_array_length (pkey);
      b.32 = b;
      mono_metadata_encode_value (len, b.32, &b);
      b.32 = b;
      b.33 = (int) b.32;
      blob_size.34 = (int) &blob_size;
      D.24883 = b.33 - blob_size.34;
      D.24884 = (unsigned int) D.24883;
      D.24885 = &assembly->blob;
      token = mono_image_add_stream_data (D.24885, &blob_size, D.24884);
      D.24886 = mono_array_addr_with_size (pkey, 1, 0);
      D.24885 = &assembly->blob;
      mono_image_add_stream_data (D.24885, D.24886, len);
      D.24887 = monoeg_malloc (len);
      assembly->public_key = D.24887;
      D.24888 = mono_array_addr_with_size (pkey, 1, 0);
      D.24889 = assembly->public_key;
      memcpy (D.24889, D.24888, len);
      len.35 = (int) len;
      assembly->public_key_len = len.35;
      if (len == 16) goto <D.24893>; else goto <D.24891>;
      <D.24893>:
      len.35 = (int) len;
      D.24894 = mono_array_addr_with_size (pkey, 1, 0);
      D.24895 = mono_is_ecma_key (D.24894, len.35);
      if (D.24895 != 0) goto <D.24896>; else goto <D.24891>;
      <D.24896>:
      assembly->strong_name_size = 128;
      goto <D.24892>;
      <D.24891>:
      if (len > 79) goto <D.24897>; else goto <D.24898>;
      <D.24897>:
      D.24899 = len + 4294967264;
      assembly->strong_name_size = D.24899;
      goto <D.24900>;
      <D.24898>:
      len.35 = (int) len;
      D.24899 = len + 4294967264;
      D.24901 = D.24899 << 3;
      D.24902 = (int) D.24901;
      monoeg_g_log (0B, 16, "Invalid public key length: %d bits (total: %d)", D.24902, len.35);
      assembly->strong_name_size = 128;
      <D.24900>:
      <D.24892>:
      D.24903 = assembly->strong_name_size;
      D.24904 = monoeg_malloc0 (D.24903);
      assembly->strong_name = D.24904;
      D.24879 = token;
      return D.24879;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.24907;
  unsigned int D.24908;
  int D.24909;
  char * D.24910;
  char * D.24911;
  guint32 D.24912;
  guint32 idx;

  D.24907 = stream->index;
  D.24908 = D.24907 + len;
  D.24909 = (int) D.24908;
  make_room_in_stream (stream, D.24909);
  D.24910 = stream->data;
  D.24907 = stream->index;
  D.24911 = D.24910 + D.24907;
  memcpy (D.24911, data, len);
  idx = stream->index;
  D.24907 = stream->index;
  D.24908 = D.24907 + len;
  stream->index = D.24908;
  D.24912 = idx;
  return D.24912;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.36;
  unsigned int D.24915;
  unsigned int D.24921;
  char * D.24922;
  void * D.24923;

  size.36 = (unsigned int) size;
  D.24915 = stream->alloc_size;
  if (size.36 <= D.24915) goto <D.24916>; else goto <D.24917>;
  <D.24916>:
  return;
  <D.24917>:
  goto <D.18345>;
  <D.18344>:
  D.24915 = stream->alloc_size;
  if (D.24915 <= 4095) goto <D.24918>; else goto <D.24919>;
  <D.24918>:
  stream->alloc_size = 4096;
  goto <D.24920>;
  <D.24919>:
  D.24915 = stream->alloc_size;
  D.24921 = D.24915 * 2;
  stream->alloc_size = D.24921;
  <D.24920>:
  <D.18345>:
  D.24915 = stream->alloc_size;
  size.36 = (unsigned int) size;
  if (D.24915 <= size.36) goto <D.18344>; else goto <D.18346>;
  <D.18346>:
  D.24915 = stream->alloc_size;
  D.24922 = stream->data;
  D.24923 = monoeg_realloc (D.24922, D.24915);
  stream->data = D.24923;
}


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

  D.24926 = __builtin_object_size (__dest, 0);
  D.24925 = __builtin___memcpy_chk (__dest, __src, __len, D.24926);
  return D.24925;
}


set_version_from_string (struct MonoString * version, guint32 * values)
{
  guint32 * D.24928;
  guint32 * D.24929;
  guint32 * D.24930;
  guint32 * D.24931;
  unsigned int D.24934;
  unsigned int D.24935;
  guint32 * D.24936;
  long int D.24937;
  unsigned int D.24938;
  gchar * p.37;
  char D.24940;
  int D.24941;
  gchar * p.38;
  gchar * ver;
  gchar * p;
  gchar * str;
  guint32 i;

  try
    {
      D.24928 = values + 4;
      *D.24928 = 0;
      D.24929 = values + 8;
      *D.24929 = 0;
      D.24930 = values + 16;
      *D.24930 = 0;
      D.24931 = values + 12;
      *D.24931 = 0;
      if (version == 0B) goto <D.24932>; else goto <D.24933>;
      <D.24932>:
      return;
      <D.24933>:
      str = mono_string_to_utf8 (version);
      ver = str;
      i = 0;
      goto <D.19981>;
      <D.19980>:
      D.24934 = i + 1;
      D.24935 = D.24934 * 4;
      D.24936 = values + D.24935;
      D.24937 = strtol (ver, &p, 10);
      D.24938 = (unsigned int) D.24937;
      *D.24936 = D.24938;
      p.37 = p;
      D.24940 = *p.37;
      D.24941 = (int) D.24940;
      switch (D.24941) <default: <D.24943>, case 42: <D.19979>, case 46: <D.19977>>
      <D.19977>:
      p.37 = p;
      p.38 = p.37 + 1;
      p = p.38;
      goto <D.19978>;
      <D.19979>:
      p.37 = p;
      p.38 = p.37 + 1;
      p = p.38;
      goto <D.19978>;
      <D.24943>:
      <D.19978>:
      ver = p;
      i = i + 1;
      <D.19981>:
      if (i <= 3) goto <D.19980>; else goto <D.19982>;
      <D.19982>:
      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.24947;
  unsigned int D.24948;
  unsigned int D.24949;
  struct MonoArray * D.24950;
  char * D.24953;
  struct MonoReflectionTypeBuilder * D.24954;
  unsigned int D.24955;
  struct MonoClass * klass;
  guint32 idx;
  guint32 i;

  D.24947 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.24947);
  D.24948 = tb->table_idx;
  D.24949 = D.24948 | 33554432;
  klass->type_token = D.24949;
  idx = mono_image_fill_export_table_from_class (domain, klass, module_index, parent_index, assembly);
  D.24950 = tb->subtypes;
  if (D.24950 != 0B) goto <D.24951>; else goto <D.24952>;
  <D.24951>:
  i = 0;
  goto <D.19522>;
  <D.19521>:
  D.24950 = tb->subtypes;
  D.24953 = mono_array_addr_with_size (D.24950, 4, i);
  D.24954 = MEM[(struct MonoReflectionTypeBuilder * *)D.24953];
  mono_image_fill_export_table (domain, D.24954, module_index, idx, assembly);
  i = i + 1;
  <D.19522>:
  D.24950 = tb->subtypes;
  D.24955 = mono_array_length (D.24950);
  if (D.24955 > i) goto <D.19521>; else goto <D.19523>;
  <D.19523>:
  <D.24952>:
}


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.24956;
  unsigned int D.24957;
  guint32 D.24960;
  unsigned int D.24961;
  unsigned int D.24962;
  guint32 * D.24963;
  unsigned int D.24964;
  unsigned int D.24965;
  guint32 * D.24966;
  unsigned int D.24967;
  struct MonoClass * D.24968;
  guint32 * D.24971;
  unsigned int D.24972;
  unsigned int D.24973;
  unsigned int D.24975;
  guint32 * D.24976;
  const char * D.24977;
  struct MonoDynamicStream * D.24978;
  unsigned int D.24979;
  guint32 * D.24980;
  const char * D.24981;
  unsigned int D.24982;
  unsigned int D.24983;
  struct MonoClassExt * D.24984;
  struct GList * D.24987;
  unsigned int D.24990;
  void * D.24991;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 visib;
  guint32 res;

  D.24956 = klass->flags;
  visib = D.24956 & 7;
  D.24957 = visib & 3;
  if (D.24957 == 0) goto <D.24958>; else goto <D.24959>;
  <D.24958>:
  D.24960 = 0;
  return D.24960;
  <D.24959>:
  table = &assembly->tables[39];
  D.24961 = table->rows;
  D.24962 = D.24961 + 1;
  table->rows = D.24962;
  D.24961 = table->rows;
  alloc_table (table, D.24961);
  D.24963 = table->values;
  D.24964 = table->next_idx;
  D.24965 = D.24964 * 20;
  values = D.24963 + D.24965;
  D.24956 = klass->flags;
  *values = D.24956;
  D.24966 = values + 4;
  D.24967 = klass->type_token;
  *D.24966 = D.24967;
  D.24968 = klass->nested_in;
  if (D.24968 != 0B) goto <D.24969>; else goto <D.24970>;
  <D.24969>:
  D.24971 = values + 16;
  D.24972 = parent_index << 2;
  D.24973 = D.24972 + 2;
  *D.24971 = D.24973;
  goto <D.24974>;
  <D.24970>:
  D.24971 = values + 16;
  D.24975 = module_index << 2;
  *D.24971 = D.24975;
  <D.24974>:
  D.24976 = values + 8;
  D.24977 = klass->name;
  D.24978 = &assembly->sheap;
  D.24979 = string_heap_insert (D.24978, D.24977);
  *D.24976 = D.24979;
  D.24980 = values + 12;
  D.24981 = klass->name_space;
  D.24978 = &assembly->sheap;
  D.24982 = string_heap_insert (D.24978, D.24981);
  *D.24980 = D.24982;
  res = table->next_idx;
  D.24964 = table->next_idx;
  D.24983 = D.24964 + 1;
  table->next_idx = D.24983;
  D.24984 = klass->ext;
  if (D.24984 != 0B) goto <D.24985>; else goto <D.24986>;
  <D.24985>:
  D.24984 = klass->ext;
  D.24987 = D.24984->nested_classes;
  if (D.24987 != 0B) goto <D.24988>; else goto <D.24989>;
  <D.24988>:
  {
    struct GList * tmp;

    D.24984 = klass->ext;
    tmp = D.24984->nested_classes;
    goto <D.19509>;
    <D.19508>:
    D.24964 = table->next_idx;
    D.24990 = D.24964 + 4294967295;
    D.24991 = tmp->data;
    mono_image_fill_export_table_from_class (domain, D.24991, module_index, D.24990, assembly);
    tmp = tmp->next;
    <D.19509>:
    if (tmp != 0B) goto <D.19508>; else goto <D.19510>;
    <D.19510>:
  }
  <D.24989>:
  <D.24986>:
  D.24960 = res;
  return D.24960;
}


mono_image_fill_file_table (struct MonoDomain * domain, struct MonoReflectionModule * module, struct MonoDynamicImage * assembly)
{
  unsigned int D.24993;
  unsigned int D.24994;
  guint32 * D.24995;
  unsigned int D.24996;
  unsigned int D.24997;
  guint32 * D.24998;
  struct MonoImage * D.24999;
  const char * D.25000;
  struct MonoDynamicStream * D.25001;
  unsigned int D.25002;
  unsigned char D.25003;
  unsigned char D.25004;
  struct MonoReflectionAssemblyBuilder * D.25007;
  struct MonoString * D.25008;
  char * D.25010;
  char * b.39;
  guint32 * D.25012;
  int b.40;
  int blob_size.41;
  int D.25015;
  unsigned int D.25016;
  struct MonoDynamicStream * D.25017;
  unsigned int D.25018;
  unsigned int D.25019;
  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.24993 = table->rows;
      D.24994 = D.24993 + 1;
      table->rows = D.24994;
      D.24993 = table->rows;
      alloc_table (table, D.24993);
      D.24995 = table->values;
      D.24996 = table->next_idx;
      D.24997 = D.24996 * 12;
      values = D.24995 + D.24997;
      *values = 0;
      D.24998 = values + 4;
      D.24999 = module->image;
      D.25000 = D.24999->module_name;
      D.25001 = &assembly->sheap;
      D.25002 = string_heap_insert (D.25001, D.25000);
      *D.24998 = D.25002;
      D.24999 = module->image;
      D.25003 = BIT_FIELD_REF <*D.24999, 8, 128>;
      D.25004 = D.25003 & 8;
      if (D.25004 != 0) goto <D.25005>; else goto <D.25006>;
      <D.25005>:
      D.25007 = MEM[(struct MonoReflectionModuleBuilder *)module].assemblyb;
      D.25008 = D.25007->dir;
      dir = mono_string_to_utf8 (D.25008);
      D.24999 = module->image;
      D.25000 = D.24999->module_name;
      path = monoeg_g_strdup_printf ("%s%c%s", dir, 47, D.25000);
      goto <D.25009>;
      <D.25006>:
      dir = 0B;
      D.24999 = module->image;
      D.25010 = D.24999->name;
      path = monoeg_strdup (D.25010);
      <D.25009>:
      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.25012 = values + 8;
      b.39 = b;
      b.40 = (int) b.39;
      blob_size.41 = (int) &blob_size;
      D.25015 = b.40 - blob_size.41;
      D.25016 = (unsigned int) D.25015;
      D.25017 = &assembly->blob;
      D.25018 = mono_image_add_stream_data (D.25017, &blob_size, D.25016);
      *D.25012 = D.25018;
      D.25017 = &assembly->blob;
      mono_image_add_stream_data (D.25017, &hash, 20);
      D.24996 = table->next_idx;
      D.25019 = D.24996 + 1;
      table->next_idx = D.25019;
    }
  finally
    {
      blob_size = {CLOBBER};
      hash = {CLOBBER};
      b = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.25020>; else goto <D.25021>;
  <D.25020>:
  D.25022 = __strdup (str);
  return D.25022;
  <D.25021>:
  D.25022 = 0B;
  return D.25022;
}


mono_image_fill_export_table_from_module (struct MonoDomain * domain, struct MonoReflectionModule * module, guint32 module_index, struct MonoDynamicImage * assembly)
{
  unsigned int D.25024;
  unsigned int D.25025;
  unsigned int D.25026;
  unsigned int D.25027;
  <unnamed-unsigned:24> D.25030;
  unsigned int D.25031;
  struct MonoImage * image;
  struct MonoTableInfo * t;
  guint32 i;

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

    D.25024 = i + 1;
    D.25025 = D.25024 | 33554432;
    klass = mono_class_get (image, D.25025);
    D.25026 = klass->flags;
    D.25027 = D.25026 & 1;
    if (D.25027 != 0) goto <D.25028>; else goto <D.25029>;
    <D.25028>:
    mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
    <D.25029>:
  }
  i = i + 1;
  <D.19535>:
  D.25030 = t->rows;
  D.25031 = (unsigned int) D.25030;
  if (D.25031 > i) goto <D.19534>; else goto <D.19536>;
  <D.19536>:
}


mono_image_fill_export_table_from_type_forwarders (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.25032;
  unsigned int i.42;
  char * D.25036;
  _Bool D.25039;
  long int D.25040;
  long int D.25041;
  unsigned int D.25044;
  struct MonoClass * klass;
  int i;

  D.25032 = assemblyb->type_forwarders;
  if (D.25032 == 0B) goto <D.25033>; else goto <D.25034>;
  <D.25033>:
  return;
  <D.25034>:
  i = 0;
  goto <D.19565>;
  <D.19564>:
  {
    struct MonoReflectionType * t;
    struct MonoType * type;

    i.42 = (unsigned int) i;
    D.25032 = assemblyb->type_forwarders;
    D.25036 = mono_array_addr_with_size (D.25032, 4, i.42);
    t = MEM[(struct MonoReflectionType * *)D.25036];
    if (t == 0B) goto <D.25037>; else goto <D.25038>;
    <D.25037>:
    // predicted unlikely by continue predictor.
    goto <D.19563>;
    <D.25038>:
    type = mono_reflection_type_get_handle (t);
    D.25039 = type == 0B;
    D.25040 = (long int) D.25039;
    D.25041 = __builtin_expect (D.25040, 0);
    if (D.25041 != 0) goto <D.25042>; else goto <D.25043>;
    <D.25042>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3863, "type");
    <D.25043>:
    klass = mono_class_from_mono_type (type);
    add_exported_type (assemblyb, assembly, klass, 0);
  }
  <D.19563>:
  i = i + 1;
  <D.19565>:
  i.42 = (unsigned int) i;
  D.25032 = assemblyb->type_forwarders;
  D.25044 = mono_array_length (D.25032);
  if (i.42 < D.25044) goto <D.19564>; else goto <D.19566>;
  <D.19566>:
}


add_exported_type (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly, struct MonoClass * klass, guint32 parent_index)
{
  struct MonoClass * D.25046;
  unsigned int D.25049;
  struct MonoImage * D.25051;
  unsigned int D.25052;
  _Bool D.25053;
  long int D.25054;
  long int D.25055;
  unsigned int D.25058;
  unsigned int D.25059;
  unsigned int D.25060;
  guint32 * D.25061;
  unsigned int D.25062;
  guint32 iftmp.43;
  guint32 * D.25067;
  guint32 * D.25068;
  guint32 * D.25069;
  const char * D.25070;
  struct MonoDynamicStream * D.25071;
  unsigned int D.25072;
  guint32 * D.25073;
  const char * D.25074;
  unsigned int D.25075;
  unsigned int D.25076;
  unsigned int D.25077;
  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.25046 = klass->nested_in;
      if (D.25046 != 0B) goto <D.25047>; else goto <D.25048>;
      <D.25047>:
      D.25049 = parent_index << 2;
      impl = D.25049 + 2;
      forwarder = 0;
      goto <D.25050>;
      <D.25048>:
      D.25051 = klass->image;
      scope = resolution_scope_from_image (assembly, D.25051);
      D.25052 = scope & 3;
      D.25053 = D.25052 != 2;
      D.25054 = (long int) D.25053;
      D.25055 = __builtin_expect (D.25054, 0);
      if (D.25055 != 0) goto <D.25056>; else goto <D.25057>;
      <D.25056>:
      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.25057>:
      scope_idx = scope >> 2;
      D.25058 = scope_idx << 2;
      impl = D.25058 + 1;
      <D.25050>:
      table = &assembly->tables[39];
      D.25059 = table->rows;
      D.25060 = D.25059 + 1;
      table->rows = D.25060;
      D.25059 = table->rows;
      alloc_table (table, D.25059);
      current_idx = table->next_idx;
      D.25061 = table->values;
      D.25062 = current_idx * 20;
      values = D.25061 + D.25062;
      if (forwarder != 0) goto <D.25064>; else goto <D.25065>;
      <D.25064>:
      iftmp.43 = 2097152;
      goto <D.25066>;
      <D.25065>:
      iftmp.43 = 0;
      <D.25066>:
      *values = iftmp.43;
      D.25067 = values + 4;
      *D.25067 = 0;
      D.25068 = values + 16;
      *D.25068 = impl;
      D.25069 = values + 8;
      D.25070 = klass->name;
      D.25071 = &assembly->sheap;
      D.25072 = string_heap_insert (D.25071, D.25070);
      *D.25069 = D.25072;
      D.25073 = values + 12;
      D.25074 = klass->name_space;
      D.25071 = &assembly->sheap;
      D.25075 = string_heap_insert (D.25071, D.25074);
      *D.25073 = D.25075;
      D.25076 = table->next_idx;
      D.25077 = D.25076 + 1;
      table->next_idx = D.25077;
      goto <D.19553>;
      <D.19552>:
      add_exported_type (assemblyb, assembly, nested, current_idx);
      <D.19553>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.19552>; else goto <D.19554>;
      <D.19554>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


resolution_scope_from_image (struct MonoDynamicImage * assembly, struct MonoImage * image)
{
  struct GHashTable * D.25078;
  void * D.25079;
  guint32 D.25082;
  struct MonoAssembly * D.25083;
  unsigned char D.25084;
  struct MonoAssembly * D.25087;
  unsigned int D.25090;
  unsigned int token.44;
  unsigned int D.25092;
  unsigned int D.25093;
  unsigned int D.25094;
  guint32 * D.25095;
  unsigned int D.25096;
  const char * D.25097;
  struct MonoDynamicStream * D.25098;
  unsigned int D.25099;
  void * token.45;
  struct MonoTableInfo * D.25104;
  unsigned int token.46;
  unsigned int D.25106;
  unsigned int D.25107;
  guint32 * D.25108;
  const char * D.25109;
  unsigned int D.25110;
  unsigned int D.25111;
  guint32 * D.25112;
  unsigned int D.25113;
  guint32 * D.25114;
  unsigned int D.25115;
  guint32 * D.25116;
  unsigned int D.25117;
  guint32 * D.25118;
  guint32 * D.25119;
  guint32 * D.25120;
  int D.18989;
  int iftmp.47;
  int D.18985;
  const char[1] * D.25124;
  unsigned char D.25125;
  int D.25126;
  unsigned char D.25127;
  int D.25128;
  _Bool D.25129;
  _Bool D.25130;
  _Bool D.25131;
  const unsigned char * D.25134;
  unsigned char D.25135;
  int D.25136;
  const unsigned char * D.25137;
  unsigned char D.25138;
  int D.25139;
  _Bool D.25140;
  _Bool D.25141;
  const unsigned char * D.25144;
  unsigned char D.25145;
  int D.25146;
  const unsigned char * D.25147;
  unsigned char D.25148;
  int D.25149;
  _Bool D.25150;
  _Bool D.25151;
  const unsigned char * D.25154;
  unsigned char D.25155;
  int D.25156;
  const unsigned char * D.25157;
  unsigned char D.25158;
  int D.25159;
  const char * D.25161;
  unsigned char D.25162;
  int D.25163;
  unsigned int D.25166;
  unsigned int publen.48;
  guint32 * D.25170;
  struct MonoDynamicStream * D.25171;
  unsigned int D.25172;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;
  guint32 cols[9];
  const char * pubkey;
  guint32 publen;

  try
    {
      D.25078 = assembly->handleref;
      D.25079 = monoeg_g_hash_table_lookup (D.25078, image);
      token = (guint32) D.25079;
      if (token != 0) goto <D.25080>; else goto <D.25081>;
      <D.25080>:
      D.25082 = token;
      return D.25082;
      <D.25081>:
      D.25083 = image->assembly;
      D.25084 = D.25083->dynamic;
      if (D.25084 != 0) goto <D.25085>; else goto <D.25086>;
      <D.25085>:
      D.25083 = image->assembly;
      D.25087 = assembly->image.assembly;
      if (D.25083 == D.25087) goto <D.25088>; else goto <D.25089>;
      <D.25088>:
      table = &assembly->tables[26];
      D.25090 = table->next_idx;
      token.44 = D.25090;
      D.25092 = token.44 + 1;
      table->next_idx = D.25092;
      token = token.44;
      D.25093 = table->rows;
      D.25094 = D.25093 + 1;
      table->rows = D.25094;
      D.25093 = table->rows;
      alloc_table (table, D.25093);
      D.25095 = table->values;
      D.25096 = token * 4;
      values = D.25095 + D.25096;
      D.25097 = image->module_name;
      D.25098 = &assembly->sheap;
      D.25099 = string_heap_insert (D.25098, D.25097);
      *values = D.25099;
      token = token << 2;
      token = token | 1;
      token.45 = (void *) token;
      D.25078 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.25078, image, token.45, 0);
      D.25082 = token;
      return D.25082;
      <D.25089>:
      <D.25086>:
      D.25083 = image->assembly;
      D.25084 = D.25083->dynamic;
      if (D.25084 != 0) goto <D.25101>; else goto <D.25102>;
      <D.25101>:
      memset (&cols, 0, 36);
      goto <D.25103>;
      <D.25102>:
      D.25083 = image->assembly;
      image = D.25083->image;
      D.25104 = &image->tables[32];
      mono_metadata_decode_row (D.25104, 0, &cols, 9);
      <D.25103>:
      table = &assembly->tables[35];
      D.25090 = table->next_idx;
      token.46 = D.25090;
      D.25106 = token.46 + 1;
      table->next_idx = D.25106;
      token = token.46;
      D.25093 = table->rows;
      D.25094 = D.25093 + 1;
      table->rows = D.25094;
      D.25093 = table->rows;
      alloc_table (table, D.25093);
      D.25095 = table->values;
      D.25107 = token * 36;
      values = D.25095 + D.25107;
      D.25108 = values + 24;
      D.25109 = image->assembly_name;
      D.25098 = &assembly->sheap;
      D.25110 = string_heap_insert (D.25098, D.25109);
      *D.25108 = D.25110;
      D.25111 = cols[1];
      *values = D.25111;
      D.25112 = values + 4;
      D.25113 = cols[2];
      *D.25112 = D.25113;
      D.25114 = values + 8;
      D.25115 = cols[3];
      *D.25114 = D.25115;
      D.25116 = values + 12;
      D.25117 = cols[4];
      *D.25116 = D.25117;
      D.25118 = values + 16;
      *D.25118 = 0;
      D.25119 = values + 28;
      *D.25119 = 0;
      D.25120 = values + 32;
      *D.25120 = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.25083 = image->assembly;
          __s2 = D.25083->aname.culture;
          D.25124 = "";
          D.25125 = MEM[(const unsigned char *)D.25124];
          D.25126 = (int) D.25125;
          D.25127 = *__s2;
          D.25128 = (int) D.25127;
          __result = D.25126 - D.25128;
          {
            D.25129 = __s1_len != 0;
            D.25130 = __result == 0;
            D.25131 = D.25129 & D.25130;
            if (D.25131 != 0) goto <D.25132>; else goto <D.25133>;
            <D.25132>:
            D.25134 = &MEM[(void *)"" + 1B];
            D.25135 = *D.25134;
            D.25136 = (int) D.25135;
            D.25137 = __s2 + 1;
            D.25138 = *D.25137;
            D.25139 = (int) D.25138;
            __result = D.25136 - D.25139;
            D.25140 = __s1_len > 1;
            D.25130 = __result == 0;
            D.25141 = D.25140 & D.25130;
            if (D.25141 != 0) goto <D.25142>; else goto <D.25143>;
            <D.25142>:
            D.25144 = &MEM[(void *)"" + 2B];
            D.25145 = *D.25144;
            D.25146 = (int) D.25145;
            D.25147 = __s2 + 2;
            D.25148 = *D.25147;
            D.25149 = (int) D.25148;
            __result = D.25146 - D.25149;
            D.25150 = __s1_len > 2;
            D.25130 = __result == 0;
            D.25151 = D.25150 & D.25130;
            if (D.25151 != 0) goto <D.25152>; else goto <D.25153>;
            <D.25152>:
            D.25154 = &MEM[(void *)"" + 3B];
            D.25155 = *D.25154;
            D.25156 = (int) D.25155;
            D.25157 = __s2 + 3;
            D.25158 = *D.25157;
            D.25159 = (int) D.25158;
            __result = D.25156 - D.25159;
            <D.25153>:
            <D.25143>:
            <D.25133>:
          }
          D.18985 = __result;
        }
        iftmp.47 = D.18985;
        goto <D.25160>;
        <D.25123>:
        D.25083 = image->assembly;
        D.25161 = D.25083->aname.culture;
        D.25162 = MEM[(const unsigned char * {ref-all})D.25161];
        D.25163 = (int) D.25162;
        iftmp.47 = -D.25163;
        <D.25160>:
        D.18989 = iftmp.47;
      }
      if (D.18989 != 0) goto <D.25164>; else goto <D.25165>;
      <D.25164>:
      D.25119 = values + 28;
      D.25083 = image->assembly;
      D.25161 = D.25083->aname.culture;
      D.25098 = &assembly->sheap;
      D.25166 = string_heap_insert (D.25098, D.25161);
      *D.25119 = D.25166;
      <D.25165>:
      pubkey = mono_image_get_public_key (image, &publen);
      if (pubkey != 0B) goto <D.25167>; else goto <D.25168>;
      <D.25167>:
      {
        guchar pubtoken[9];

        try
          {
            pubtoken[0] = 8;
            publen.48 = publen;
            mono_digest_get_public_token (&MEM[(void *)&pubtoken + 1B], pubkey, publen.48);
            D.25170 = values + 20;
            D.25171 = &assembly->blob;
            D.25172 = mono_image_add_stream_data (D.25171, &pubtoken, 9);
            *D.25170 = D.25172;
          }
        finally
          {
            pubtoken = {CLOBBER};
          }
      }
      goto <D.25173>;
      <D.25168>:
      D.25170 = values + 20;
      *D.25170 = 0;
      <D.25173>:
      token = token << 2;
      token = token | 2;
      token.45 = (void *) token;
      D.25078 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.25078, image, token.45, 0);
      D.25082 = token;
      return D.25082;
    }
  finally
    {
      cols = {CLOBBER};
      publen = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25178;
  int D.25183;
  void * D.25185;
  unsigned int D.25186;

  D.25178 = __builtin_constant_p (__len);
  if (D.25178 != 0) goto <D.25179>; else goto <D.25180>;
  <D.25179>:
  if (__len == 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  D.25183 = __builtin_constant_p (__ch);
  if (D.25183 == 0) goto <D.25176>; else goto <D.25184>;
  <D.25184>:
  if (__ch != 0) goto <D.25176>; else goto <D.25177>;
  <D.25176>:
  __warn_memset_zero_len ();
  D.25185 = __dest;
  return D.25185;
  <D.25177>:
  <D.25182>:
  <D.25180>:
  D.25186 = __builtin_object_size (__dest, 0);
  D.25185 = __builtin___memset_chk (__dest, __ch, __len, D.25186);
  return D.25185;
}


assembly_add_resource_manifest (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc, guint32 implementation)
{
  unsigned int D.25188;
  unsigned int D.25189;
  guint32 * D.25190;
  unsigned int D.25191;
  unsigned int D.25192;
  unsigned int D.25193;
  guint32 * D.25194;
  unsigned int D.25195;
  guint32 * D.25196;
  struct MonoString * D.25197;
  struct MonoDynamicStream * D.25198;
  unsigned int D.25199;
  guint32 * D.25200;
  unsigned int D.25201;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[40];
  D.25188 = table->rows;
  D.25189 = D.25188 + 1;
  table->rows = D.25189;
  D.25188 = table->rows;
  alloc_table (table, D.25188);
  D.25190 = table->values;
  D.25191 = table->next_idx;
  D.25192 = D.25191 * 16;
  values = D.25190 + D.25192;
  D.25193 = rsrc->offset;
  *values = D.25193;
  D.25194 = values + 4;
  D.25195 = rsrc->attrs;
  *D.25194 = D.25195;
  D.25196 = values + 8;
  D.25197 = rsrc->name;
  D.25198 = &assembly->sheap;
  D.25199 = string_heap_insert_mstring (D.25198, D.25197);
  *D.25196 = D.25199;
  D.25200 = values + 12;
  *D.25200 = implementation;
  D.25191 = table->next_idx;
  D.25201 = D.25191 + 1;
  table->next_idx = D.25201;
}


string_heap_insert (struct MonoDynamicStream * sh, const char * str)
{
  struct GHashTable * D.25202;
  int D.25203;
  guint32 D.25206;
  void * oldval.49;
  unsigned int D.25208;
  unsigned int D.25209;
  int D.25210;
  void * idx.50;
  gchar * D.25212;
  char * D.25213;
  char * D.25214;
  unsigned int D.25215;
  unsigned int D.25216;
  guint32 idx;
  guint32 len;
  void * oldkey;
  void * oldval;

  try
    {
      D.25202 = sh->hash;
      D.25203 = monoeg_g_hash_table_lookup_extended (D.25202, str, &oldkey, &oldval);
      if (D.25203 != 0) goto <D.25204>; else goto <D.25205>;
      <D.25204>:
      oldval.49 = oldval;
      D.25206 = (guint32) oldval.49;
      return D.25206;
      <D.25205>:
      D.25208 = strlen (str);
      len = D.25208 + 1;
      idx = sh->index;
      D.25209 = idx + len;
      D.25210 = (int) D.25209;
      make_room_in_stream (sh, D.25210);
      idx.50 = (void *) idx;
      D.25212 = monoeg_strdup (str);
      D.25202 = sh->hash;
      monoeg_g_hash_table_insert_replace (D.25202, D.25212, idx.50, 0);
      D.25213 = sh->data;
      D.25214 = D.25213 + idx;
      memcpy (D.25214, str, len);
      D.25215 = sh->index;
      D.25216 = D.25215 + len;
      sh->index = D.25216;
      D.25206 = idx;
      return D.25206;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


mono_image_get_method_info (struct MonoReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25219;
  unsigned int D.25220;
  struct MonoString * D.25221;
  int iftmp.51;
  unsigned int D.25225;
  unsigned int D.25228;
  unsigned int D.25229;
  unsigned int D.25231;
  unsigned int D.25232;
  unsigned int D.25233;
  guint32 * D.25234;
  unsigned int D.25235;
  unsigned int D.25236;
  unsigned int D.25237;
  unsigned int ncharset.52;
  unsigned int D.25239;
  unsigned int extra_flags.53;
  unsigned int D.25241;
  guint32 * D.25242;
  unsigned int D.25243;
  unsigned int D.25244;
  unsigned int D.25245;
  struct MonoString * D.25246;
  guint32 * D.25249;
  struct MonoDynamicStream * D.25250;
  unsigned int D.25251;
  struct MonoString * D.25253;
  unsigned int D.25254;
  guint32 * D.25255;
  unsigned int D.25256;
  unsigned int D.25257;
  unsigned int D.25260;
  guint32 * D.25261;
  struct MonoArray * D.25262;
  unsigned int D.25265;
  unsigned int D.25266;
  unsigned int i.54;
  char * D.25268;
  void * D.25269;
  unsigned int D.25270;
  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.25219 = rmb.table_idx;
      D.25220 = *D.25219;
      mb->table_idx = D.25220;
      D.25221 = mb->dll;
      if (D.25221 != 0B) goto <D.25222>; else goto <D.25223>;
      <D.25222>:
      {
        guint32 moduleref;
        int ncharset;
        int extra_flags;

        D.25225 = mb->charset;
        if (D.25225 != 0) goto <D.25226>; else goto <D.25227>;
        <D.25226>:
        D.25225 = mb->charset;
        D.25228 = D.25225 + 2147483647;
        D.25229 = D.25228 * 2;
        iftmp.51 = (int) D.25229;
        goto <D.25230>;
        <D.25227>:
        iftmp.51 = 0;
        <D.25230>:
        ncharset = iftmp.51;
        D.25231 = mb->extra_flags;
        extra_flags = (int) D.25231;
        table = &assembly->tables[28];
        D.25232 = table->rows;
        D.25233 = D.25232 + 1;
        table->rows = D.25233;
        D.25232 = table->rows;
        alloc_table (table, D.25232);
        D.25234 = table->values;
        D.25232 = table->rows;
        D.25235 = D.25232 * 16;
        values = D.25234 + D.25235;
        D.25236 = mb->native_cc;
        D.25237 = D.25236 << 8;
        ncharset.52 = (unsigned int) ncharset;
        D.25239 = D.25237 | ncharset.52;
        extra_flags.53 = (unsigned int) extra_flags;
        D.25241 = D.25239 | extra_flags.53;
        *values = D.25241;
        D.25242 = values + 4;
        D.25243 = mb->table_idx;
        D.25244 = D.25243 << 1;
        D.25245 = D.25244 | 1;
        *D.25242 = D.25245;
        D.25246 = mb->dllentry;
        if (D.25246 != 0B) goto <D.25247>; else goto <D.25248>;
        <D.25247>:
        D.25249 = values + 8;
        D.25246 = mb->dllentry;
        D.25250 = &assembly->sheap;
        D.25251 = string_heap_insert_mstring (D.25250, D.25246);
        *D.25249 = D.25251;
        goto <D.25252>;
        <D.25248>:
        D.25249 = values + 8;
        D.25253 = mb->name;
        D.25250 = &assembly->sheap;
        D.25254 = string_heap_insert_mstring (D.25250, D.25253);
        *D.25249 = D.25254;
        <D.25252>:
        D.25221 = mb->dll;
        D.25250 = &assembly->sheap;
        moduleref = string_heap_insert_mstring (D.25250, D.25221);
        D.25255 = values + 12;
        D.25256 = find_index_in_table (assembly, 26, 0, moduleref);
        *D.25255 = D.25256;
        D.25257 = *D.25255;
        if (D.25257 == 0) goto <D.25258>; else goto <D.25259>;
        <D.25258>:
        table = &assembly->tables[26];
        D.25232 = table->rows;
        D.25233 = D.25232 + 1;
        table->rows = D.25233;
        D.25232 = table->rows;
        alloc_table (table, D.25232);
        D.25234 = table->values;
        D.25232 = table->rows;
        D.25260 = D.25232 * 4;
        D.25261 = D.25234 + D.25260;
        *D.25261 = moduleref;
        D.25255 = values + 12;
        D.25232 = table->rows;
        *D.25255 = D.25232;
        <D.25259>:
      }
      <D.25223>:
      D.25262 = mb->generic_params;
      if (D.25262 != 0B) goto <D.25263>; else goto <D.25264>;
      <D.25263>:
      table = &assembly->tables[42];
      D.25262 = mb->generic_params;
      D.25265 = mono_array_length (D.25262);
      D.25232 = table->rows;
      D.25266 = D.25232 + D.25265;
      table->rows = D.25266;
      D.25232 = table->rows;
      alloc_table (table, D.25232);
      i = 0;
      goto <D.18791>;
      <D.18790>:
      {
        guint32 owner;

        D.25243 = mb->table_idx;
        D.25244 = D.25243 << 1;
        owner = D.25244 | 1;
        i.54 = (unsigned int) i;
        D.25262 = mb->generic_params;
        D.25268 = mono_array_addr_with_size (D.25262, 4, i.54);
        D.25269 = MEM[(void * *)D.25268];
        mono_image_get_generic_param_info (D.25269, owner, assembly);
      }
      i = i + 1;
      <D.18791>:
      i.54 = (unsigned int) i;
      D.25262 = mb->generic_params;
      D.25270 = mono_array_length (D.25262);
      if (i.54 < D.25270) goto <D.18790>; else goto <D.18792>;
      <D.18792>:
      <D.25264>:
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


reflection_methodbuilder_from_method_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoReflectionILGen * D.25271;
  struct MonoObject * D.25272;
  struct MonoReflectionType * D.25273;
  struct MonoArray * D.25274;
  struct MonoArray * D.25275;
  struct MonoGenericContainer * D.25276;
  struct MonoArray * D.25277;
  unsigned int D.25278;
  unsigned int D.25279;
  unsigned int D.25280;
  struct MonoArray * D.25281;
  struct MonoObject * D.25282;
  struct MonoString * D.25283;
  guint32 * D.25284;
  unsigned char D.25285;
  struct MonoArray * D.25286;
  struct MonoArray * D.25287;
  struct MonoArray * D.25288;
  struct MonoArray * D.25289;
  struct MonoArray * D.25290;
  struct MonoMethod * D.25291;
  struct MonoString * D.25292;
  unsigned int D.25295;
  int D.25296;
  unsigned int D.25297;
  int D.25298;
  unsigned int D.25299;
  int D.25300;
  struct MonoString * D.25301;

  memset (rmb, 0, 112);
  D.25271 = mb->ilgen;
  rmb->ilgen = D.25271;
  D.25272 = mb->rtype;
  D.25273 = mono_reflection_type_resolve_user_types (D.25272);
  rmb->rtype = D.25273;
  D.25274 = mb->parameters;
  rmb->parameters = D.25274;
  D.25275 = mb->generic_params;
  rmb->generic_params = D.25275;
  D.25276 = mb->generic_container;
  rmb->generic_container = D.25276;
  rmb->opt_types = 0B;
  D.25277 = mb->pinfo;
  rmb->pinfo = D.25277;
  D.25278 = mb->attrs;
  rmb->attrs = D.25278;
  D.25279 = mb->iattrs;
  rmb->iattrs = D.25279;
  D.25280 = mb->call_conv;
  rmb->call_conv = D.25280;
  D.25281 = mb->code;
  rmb->code = D.25281;
  D.25282 = mb->type;
  rmb->type = D.25282;
  D.25283 = mb->name;
  rmb->name = D.25283;
  D.25284 = &mb->table_idx;
  rmb->table_idx = D.25284;
  D.25285 = mb->init_locals;
  rmb->init_locals = D.25285;
  rmb->skip_visibility = 0;
  D.25286 = mb->return_modreq;
  rmb->return_modreq = D.25286;
  D.25287 = mb->return_modopt;
  rmb->return_modopt = D.25287;
  D.25288 = mb->param_modreq;
  rmb->param_modreq = D.25288;
  D.25289 = mb->param_modopt;
  rmb->param_modopt = D.25289;
  D.25290 = mb->permissions;
  rmb->permissions = D.25290;
  D.25291 = mb->mhandle;
  rmb->mhandle = D.25291;
  rmb->nrefs = 0;
  rmb->refs = 0B;
  D.25292 = mb->dll;
  if (D.25292 != 0B) goto <D.25293>; else goto <D.25294>;
  <D.25293>:
  D.25295 = mb->charset;
  D.25296 = (int) D.25295;
  rmb->charset = D.25296;
  D.25297 = mb->extra_flags;
  D.25298 = (int) D.25297;
  rmb->extra_flags = D.25298;
  D.25299 = mb->native_cc;
  D.25300 = (int) D.25299;
  rmb->native_cc = D.25300;
  D.25301 = mb->dllentry;
  rmb->dllentry = D.25301;
  D.25292 = mb->dll;
  rmb->dll = D.25292;
  <D.25294>:
}


mono_reflection_type_resolve_user_types (struct MonoReflectionType * type)
{
  struct MonoType * D.25305;
  struct MonoReflectionType * D.25306;
  int D.25307;
  int D.25310;
  struct MonoException * D.25313;

  if (type == 0B) goto <D.25302>; else goto <D.25304>;
  <D.25304>:
  D.25305 = type->type;
  if (D.25305 != 0B) goto <D.25302>; else goto <D.25303>;
  <D.25302>:
  D.25306 = type;
  return D.25306;
  <D.25303>:
  D.25307 = is_usertype (type);
  if (D.25307 != 0) goto <D.25308>; else goto <D.25309>;
  <D.25308>:
  type = mono_reflection_type_get_underlying_system_type (type);
  D.25310 = is_usertype (type);
  if (D.25310 != 0) goto <D.25311>; else goto <D.25312>;
  <D.25311>:
  D.25313 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported22");
  mono_raise_exception (D.25313);
  <D.25312>:
  <D.25309>:
  D.25306 = type;
  return D.25306;
}


mono_reflection_type_get_underlying_system_type (struct MonoReflectionType * t)
{
  struct MonoMethod * method_get_underlying_system_type.55;
  struct MonoClass * D.25318;
  struct MonoMethod * method_get_underlying_system_type.56;
  struct MonoReflectionType * D.25320;
  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.25316>; else goto <D.25317>;
  <D.25316>:
  D.25318 = mono_defaults.systemtype_class;
  method_get_underlying_system_type.56 = mono_class_get_method_from_name (D.25318, "get_UnderlyingSystemType", 0);
  method_get_underlying_system_type = method_get_underlying_system_type.56;
  <D.25317>:
  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.25320 = mono_runtime_invoke (usertype_method, t, 0B, 0B);
  return D.25320;
}


is_usertype (struct MonoReflectionType * ref)
{
  struct MonoVTable * D.25322;
  gboolean D.25323;
  int iftmp.57;
  struct MonoImage * D.25328;
  struct MonoImage * D.25329;
  int D.22583;
  int iftmp.58;
  int D.22579;
  const char[14] * D.25334;
  unsigned char D.25335;
  int D.25336;
  unsigned char D.25337;
  int D.25338;
  _Bool D.25339;
  _Bool D.25340;
  _Bool D.25341;
  const unsigned char * D.25344;
  unsigned char D.25345;
  int D.25346;
  const unsigned char * D.25347;
  unsigned char D.25348;
  int D.25349;
  _Bool D.25350;
  _Bool D.25351;
  const unsigned char * D.25354;
  unsigned char D.25355;
  int D.25356;
  const unsigned char * D.25357;
  unsigned char D.25358;
  int D.25359;
  _Bool D.25360;
  _Bool D.25361;
  const unsigned char * D.25364;
  unsigned char D.25365;
  int D.25366;
  const unsigned char * D.25367;
  unsigned char D.25368;
  int D.25369;
  const char * D.25371;
  struct MonoClass * class;

  D.25322 = MEM[(struct MonoObject *)ref].vtable;
  class = D.25322->klass;
  D.25328 = class->image;
  D.25329 = mono_defaults.corlib;
  if (D.25328 != D.25329) goto <D.25325>; else goto <D.25330>;
  <D.25330>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.25334 = "TypeDelegator";
      D.25335 = MEM[(const unsigned char *)D.25334];
      D.25336 = (int) D.25335;
      D.25337 = *__s2;
      D.25338 = (int) D.25337;
      __result = D.25336 - D.25338;
      {
        D.25339 = __s1_len != 0;
        D.25340 = __result == 0;
        D.25341 = D.25339 & D.25340;
        if (D.25341 != 0) goto <D.25342>; else goto <D.25343>;
        <D.25342>:
        D.25344 = &MEM[(void *)"TypeDelegator" + 1B];
        D.25345 = *D.25344;
        D.25346 = (int) D.25345;
        D.25347 = __s2 + 1;
        D.25348 = *D.25347;
        D.25349 = (int) D.25348;
        __result = D.25346 - D.25349;
        D.25350 = __s1_len > 1;
        D.25340 = __result == 0;
        D.25351 = D.25350 & D.25340;
        if (D.25351 != 0) goto <D.25352>; else goto <D.25353>;
        <D.25352>:
        D.25354 = &MEM[(void *)"TypeDelegator" + 2B];
        D.25355 = *D.25354;
        D.25356 = (int) D.25355;
        D.25357 = __s2 + 2;
        D.25358 = *D.25357;
        D.25359 = (int) D.25358;
        __result = D.25356 - D.25359;
        D.25360 = __s1_len > 2;
        D.25340 = __result == 0;
        D.25361 = D.25360 & D.25340;
        if (D.25361 != 0) goto <D.25362>; else goto <D.25363>;
        <D.25362>:
        D.25364 = &MEM[(void *)"TypeDelegator" + 3B];
        D.25365 = *D.25364;
        D.25366 = (int) D.25365;
        D.25367 = __s2 + 3;
        D.25368 = *D.25367;
        D.25369 = (int) D.25368;
        __result = D.25366 - D.25369;
        <D.25363>:
        <D.25353>:
        <D.25343>:
      }
      D.22579 = __result;
    }
    iftmp.58 = D.22579;
    goto <D.25370>;
    <D.25333>:
    D.25371 = class->name;
    iftmp.58 = __builtin_strcmp ("TypeDelegator", D.25371);
    <D.25370>:
    D.22583 = iftmp.58;
  }
  if (D.22583 == 0) goto <D.25325>; else goto <D.25326>;
  <D.25325>:
  iftmp.57 = 1;
  goto <D.25327>;
  <D.25326>:
  iftmp.57 = 0;
  <D.25327>:
  D.25323 = iftmp.57;
  return D.25323;
}


mono_image_basic_method (struct ReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25373;
  unsigned int D.25374;
  unsigned int D.25375;
  unsigned int D.25376;
  unsigned int D.25377;
  void * D.25378;
  struct MonoMethod * D.25379;
  struct GHashTable * D.25380;
  guint32 * D.25381;
  unsigned int D.25382;
  guint32 * D.25383;
  struct MonoString * D.25384;
  struct MonoDynamicStream * D.25385;
  unsigned int D.25386;
  guint32 * D.25387;
  unsigned int D.25388;
  guint32 * D.25389;
  unsigned int D.25390;
  guint32 * D.25391;
  unsigned int D.25392;
  unsigned int D.25393;
  guint32 * D.25394;
  struct MonoArray * D.25395;
  unsigned int D.25396;
  struct MonoArray * D.25397;
  guint32 * D.25400;
  unsigned int D.25401;
  unsigned int D.25402;
  char * D.25403;
  void * D.25404;
  unsigned int D.25407;
  unsigned int D.25408;
  unsigned int D.25409;
  unsigned int D.25410;
  char * D.25411;
  unsigned int D.25414;
  struct MonoString * D.25415;
  unsigned int D.25418;
  struct MonoReflectionMarshal * D.25420;
  unsigned int D.25423;
  unsigned int D.25424;
  unsigned int D.25425;
  unsigned int D.25426;
  unsigned int D.25427;
  guint32 * D.25428;
  unsigned int D.25429;
  unsigned int D.25430;
  unsigned int D.25431;
  unsigned int D.25432;
  unsigned int D.25435;
  guint32 * D.25436;
  unsigned int D.25437;
  unsigned int D.25438;
  unsigned int D.25439;
  guint32 * D.25440;
  struct MonoObject * D.25441;
  unsigned int D.25442;
  unsigned int field_type.59;
  unsigned int D.25444;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint i;
  guint count;

  table = &assembly->tables[6];
  D.25373 = mb->table_idx;
  D.25374 = table->next_idx;
  D.25375 = D.25374;
  D.25376 = D.25375 + 1;
  table->next_idx = D.25376;
  *D.25373 = D.25375;
  D.25373 = mb->table_idx;
  D.25377 = *D.25373;
  D.25378 = (void *) D.25377;
  D.25379 = mb->mhandle;
  D.25380 = assembly->method_to_table_idx;
  monoeg_g_hash_table_insert_replace (D.25380, D.25379, D.25378, 0);
  D.25381 = table->values;
  D.25373 = mb->table_idx;
  D.25377 = *D.25373;
  D.25382 = D.25377 * 24;
  values = D.25381 + D.25382;
  D.25383 = values + 12;
  D.25384 = mb->name;
  D.25385 = &assembly->sheap;
  D.25386 = string_heap_insert_mstring (D.25385, D.25384);
  *D.25383 = D.25386;
  D.25387 = values + 8;
  D.25388 = mb->attrs;
  *D.25387 = D.25388;
  D.25389 = values + 4;
  D.25390 = mb->iattrs;
  *D.25389 = D.25390;
  D.25391 = values + 16;
  D.25392 = method_builder_encode_signature (assembly, mb);
  *D.25391 = D.25392;
  D.25393 = method_encode_code (assembly, mb);
  *values = D.25393;
  table = &assembly->tables[8];
  D.25394 = values + 20;
  D.25374 = table->next_idx;
  *D.25394 = D.25374;
  D.25395 = mb->permissions;
  D.25373 = mb->table_idx;
  D.25377 = *D.25373;
  D.25396 = D.25377 | 100663296;
  mono_image_add_decl_security (assembly, D.25396, D.25395);
  D.25397 = mb->pinfo;
  if (D.25397 != 0B) goto <D.25398>; else goto <D.25399>;
  <D.25398>:
  {
    struct MonoDynamicTable * mtable;
    guint32 * mvalues;

    mtable = &assembly->tables[13];
    D.25400 = mtable->values;
    D.25401 = mtable->next_idx;
    D.25402 = D.25401 * 8;
    mvalues = D.25400 + D.25402;
    count = 0;
    i = 0;
    goto <D.18741>;
    <D.18740>:
    D.25397 = mb->pinfo;
    D.25403 = mono_array_addr_with_size (D.25397, 4, i);
    D.25404 = MEM[(void * *)D.25403];
    if (D.25404 != 0B) goto <D.25405>; else goto <D.25406>;
    <D.25405>:
    count = count + 1;
    <D.25406>:
    i = i + 1;
    <D.18741>:
    D.25397 = mb->pinfo;
    D.25407 = mono_array_length (D.25397);
    if (D.25407 > i) goto <D.18740>; else goto <D.18742>;
    <D.18742>:
    D.25408 = table->rows;
    D.25409 = D.25408 + count;
    table->rows = D.25409;
    D.25408 = table->rows;
    alloc_table (table, D.25408);
    D.25381 = table->values;
    D.25374 = table->next_idx;
    D.25410 = D.25374 * 12;
    values = D.25381 + D.25410;
    i = 0;
    goto <D.18746>;
    <D.18745>:
    {
      struct MonoReflectionParamBuilder * pb;

      D.25397 = mb->pinfo;
      D.25411 = mono_array_addr_with_size (D.25397, 4, i);
      pb = MEM[(struct MonoReflectionParamBuilder * *)D.25411];
      if (pb != 0B) goto <D.25412>; else goto <D.25413>;
      <D.25412>:
      D.25414 = pb->attrs;
      *values = D.25414;
      D.25389 = values + 4;
      *D.25389 = i;
      D.25415 = pb->name;
      if (D.25415 != 0B) goto <D.25416>; else goto <D.25417>;
      <D.25416>:
      D.25387 = values + 8;
      D.25415 = pb->name;
      D.25385 = &assembly->sheap;
      D.25418 = string_heap_insert_mstring (D.25385, D.25415);
      *D.25387 = D.25418;
      goto <D.25419>;
      <D.25417>:
      D.25387 = values + 8;
      *D.25387 = 0;
      <D.25419>:
      values = values + 12;
      D.25420 = pb->marshal_info;
      if (D.25420 != 0B) goto <D.25421>; else goto <D.25422>;
      <D.25421>:
      D.25423 = mtable->rows;
      D.25424 = D.25423 + 1;
      mtable->rows = D.25424;
      D.25423 = mtable->rows;
      alloc_table (mtable, D.25423);
      D.25400 = mtable->values;
      D.25423 = mtable->rows;
      D.25425 = D.25423 * 8;
      mvalues = D.25400 + D.25425;
      D.25374 = table->next_idx;
      D.25426 = D.25374 << 1;
      D.25427 = D.25426 | 1;
      *mvalues = D.25427;
      D.25428 = mvalues + 4;
      D.25420 = pb->marshal_info;
      D.25429 = encode_marshal_blob (assembly, D.25420);
      *D.25428 = D.25429;
      <D.25422>:
      D.25374 = table->next_idx;
      D.25430 = D.25374;
      D.25431 = D.25430 + 1;
      table->next_idx = D.25431;
      pb->table_idx = D.25430;
      D.25414 = pb->attrs;
      D.25432 = D.25414 & 4096;
      if (D.25432 != 0) goto <D.25433>; else goto <D.25434>;
      <D.25433>:
      {
        guint32 field_type;

        try
          {
            field_type = 0;
            mtable = &assembly->tables[11];
            D.25423 = mtable->rows;
            D.25424 = D.25423 + 1;
            mtable->rows = D.25424;
            D.25423 = mtable->rows;
            alloc_table (mtable, D.25423);
            D.25400 = mtable->values;
            D.25423 = mtable->rows;
            D.25435 = D.25423 * 16;
            mvalues = D.25400 + D.25435;
            D.25436 = mvalues + 8;
            D.25437 = pb->table_idx;
            D.25438 = D.25437 << 2;
            D.25439 = D.25438 | 1;
            *D.25436 = D.25439;
            D.25440 = mvalues + 12;
            D.25441 = pb->def_value;
            D.25442 = encode_constant (assembly, D.25441, &field_type);
            *D.25440 = D.25442;
            field_type.59 = field_type;
            *mvalues = field_type.59;
            D.25428 = mvalues + 4;
            *D.25428 = 0;
          }
        finally
          {
            field_type = {CLOBBER};
          }
      }
      <D.25434>:
      <D.25413>:
    }
    i = i + 1;
    <D.18746>:
    D.25397 = mb->pinfo;
    D.25444 = mono_array_length (D.25397);
    if (D.25444 > i) goto <D.18745>; else goto <D.18747>;
    <D.18747>:
  }
  <D.25399>:
}


method_builder_encode_signature (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  uintptr_t iftmp.60;
  struct MonoArray * D.25446;
  uintptr_t iftmp.61;
  struct MonoArray * D.25451;
  uintptr_t iftmp.62;
  struct MonoArray * D.25456;
  unsigned int D.25460;
  unsigned int D.25461;
  unsigned int D.25464;
  unsigned int D.25465;
  unsigned char D.25470;
  int D.25471;
  unsigned int D.25474;
  struct MonoArray * D.25475;
  struct MonoArray * D.25476;
  struct MonoReflectionType * D.25477;
  struct MonoArray * D.25478;
  unsigned int i.63;
  unsigned int D.25482;
  char * D.25485;
  struct MonoArray * D.25486;
  unsigned int D.25489;
  char * D.25492;
  char * D.25493;
  unsigned int i.64;
  char * D.25497;
  guint32 D.25498;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 ngparams;
  guint32 notypes;
  guint32 idx;

  try
    {
      D.25446 = mb->parameters;
      if (D.25446 != 0B) goto <D.25447>; else goto <D.25448>;
      <D.25447>:
      D.25446 = mb->parameters;
      iftmp.60 = mono_array_length (D.25446);
      goto <D.25449>;
      <D.25448>:
      iftmp.60 = 0;
      <D.25449>:
      nparams = iftmp.60;
      D.25451 = mb->generic_params;
      if (D.25451 != 0B) goto <D.25452>; else goto <D.25453>;
      <D.25452>:
      D.25451 = mb->generic_params;
      iftmp.61 = mono_array_length (D.25451);
      goto <D.25454>;
      <D.25453>:
      iftmp.61 = 0;
      <D.25454>:
      ngparams = iftmp.61;
      D.25456 = mb->opt_types;
      if (D.25456 != 0B) goto <D.25457>; else goto <D.25458>;
      <D.25457>:
      D.25456 = mb->opt_types;
      iftmp.62 = mono_array_length (D.25456);
      goto <D.25459>;
      <D.25458>:
      iftmp.62 = 0;
      <D.25459>:
      notypes = iftmp.62;
      sigbuffer_init (&buf, 32);
      D.25460 = mb->call_conv;
      idx = D.25460 & 96;
      D.25460 = mb->call_conv;
      D.25461 = D.25460 & 2;
      if (D.25461 != 0) goto <D.25462>; else goto <D.25463>;
      <D.25462>:
      idx = idx | 5;
      <D.25463>:
      D.25464 = mb->attrs;
      D.25465 = D.25464 & 16;
      if (D.25465 == 0) goto <D.25466>; else goto <D.25467>;
      <D.25466>:
      idx = idx | 32;
      <D.25467>:
      if (ngparams != 0) goto <D.25468>; else goto <D.25469>;
      <D.25468>:
      idx = idx | 16;
      <D.25469>:
      D.25470 = (unsigned char) idx;
      D.25471 = (int) D.25470;
      sigbuffer_add_byte (&buf, D.25471);
      if (ngparams != 0) goto <D.25472>; else goto <D.25473>;
      <D.25472>:
      sigbuffer_add_value (&buf, ngparams);
      <D.25473>:
      D.25474 = nparams + notypes;
      sigbuffer_add_value (&buf, D.25474);
      D.25475 = mb->return_modopt;
      D.25476 = mb->return_modreq;
      encode_custom_modifiers (assembly, D.25476, D.25475, &buf);
      D.25477 = mb->rtype;
      encode_reflection_type (assembly, D.25477, &buf);
      i = 0;
      goto <D.18552>;
      <D.18551>:
      {
        struct MonoArray * modreq;
        struct MonoArray * modopt;
        struct MonoReflectionType * pt;

        modreq = 0B;
        modopt = 0B;
        D.25478 = mb->param_modreq;
        if (D.25478 != 0B) goto <D.25479>; else goto <D.25480>;
        <D.25479>:
        i.63 = (unsigned int) i;
        D.25478 = mb->param_modreq;
        D.25482 = mono_array_length (D.25478);
        if (i.63 < D.25482) goto <D.25483>; else goto <D.25484>;
        <D.25483>:
        i.63 = (unsigned int) i;
        D.25478 = mb->param_modreq;
        D.25485 = mono_array_addr_with_size (D.25478, 4, i.63);
        modreq = MEM[(struct MonoArray * *)D.25485];
        <D.25484>:
        <D.25480>:
        D.25486 = mb->param_modopt;
        if (D.25486 != 0B) goto <D.25487>; else goto <D.25488>;
        <D.25487>:
        i.63 = (unsigned int) i;
        D.25486 = mb->param_modopt;
        D.25489 = mono_array_length (D.25486);
        if (i.63 < D.25489) goto <D.25490>; else goto <D.25491>;
        <D.25490>:
        i.63 = (unsigned int) i;
        D.25486 = mb->param_modopt;
        D.25492 = mono_array_addr_with_size (D.25486, 4, i.63);
        modopt = MEM[(struct MonoArray * *)D.25492];
        <D.25491>:
        <D.25488>:
        encode_custom_modifiers (assembly, modreq, modopt, &buf);
        i.63 = (unsigned int) i;
        D.25446 = mb->parameters;
        D.25493 = mono_array_addr_with_size (D.25446, 4, i.63);
        pt = MEM[(struct MonoReflectionType * *)D.25493];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18552>:
      i.64 = (unsigned int) i;
      if (i.64 < nparams) goto <D.18551>; else goto <D.18553>;
      <D.18553>:
      if (notypes != 0) goto <D.25495>; else goto <D.25496>;
      <D.25495>:
      sigbuffer_add_byte (&buf, 65);
      <D.25496>:
      i = 0;
      goto <D.18556>;
      <D.18555>:
      {
        struct MonoReflectionType * pt;

        i.63 = (unsigned int) i;
        D.25456 = mb->opt_types;
        D.25497 = mono_array_addr_with_size (D.25456, 4, i.63);
        pt = MEM[(struct MonoReflectionType * *)D.25497];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18556>:
      i.64 = (unsigned int) i;
      if (i.64 < notypes) goto <D.18555>; else goto <D.18557>;
      <D.18557>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25498 = idx;
      return D.25498;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sigbuffer_init (struct SigBuffer * buf, int size)
{
  unsigned int size.65;
  void * D.25502;
  char * D.25503;
  sizetype size.66;
  char * D.25505;

  size.65 = (unsigned int) size;
  D.25502 = monoeg_malloc (size.65);
  buf->buf = D.25502;
  D.25503 = buf->buf;
  buf->p = D.25503;
  D.25503 = buf->buf;
  size.66 = (sizetype) size;
  D.25505 = D.25503 + size.66;
  buf->end = D.25505;
}


sigbuffer_add_value (struct SigBuffer * buf, guint32 val)
{
  char * * D.25506;
  char * D.25507;

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


sigbuffer_make_room (struct SigBuffer * buf, int size)
{
  char * D.25508;
  int D.25509;
  char * D.25510;
  int D.25511;
  int D.25512;
  char * D.25515;
  int D.25516;
  int D.25517;
  int D.25518;
  unsigned int new_size.67;
  sizetype size.68;
  char * D.25521;
  sizetype new_size.69;
  char * D.25523;

  D.25508 = buf->end;
  D.25509 = (int) D.25508;
  D.25510 = buf->p;
  D.25511 = (int) D.25510;
  D.25512 = D.25509 - D.25511;
  if (D.25512 < size) goto <D.25513>; else goto <D.25514>;
  <D.25513>:
  {
    int new_size;
    char * p;

    D.25508 = buf->end;
    D.25509 = (int) D.25508;
    D.25515 = buf->buf;
    D.25516 = (int) D.25515;
    D.25517 = D.25509 - D.25516;
    D.25518 = D.25517 + size;
    new_size = D.25518 + 32;
    new_size.67 = (unsigned int) new_size;
    D.25515 = buf->buf;
    p = monoeg_realloc (D.25515, new_size.67);
    D.25510 = buf->p;
    D.25511 = (int) D.25510;
    D.25515 = buf->buf;
    D.25516 = (int) D.25515;
    size = D.25511 - D.25516;
    buf->buf = p;
    size.68 = (sizetype) size;
    D.25521 = p + size.68;
    buf->p = D.25521;
    D.25515 = buf->buf;
    new_size.69 = (sizetype) new_size;
    D.25523 = D.25515 + new_size.69;
    buf->end = D.25523;
  }
  <D.25514>:
}


encode_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoArray * modreq, struct MonoArray * modopt, struct SigBuffer * buf)
{
  unsigned int i.70;
  char * D.25527;
  void * D.25528;
  unsigned int D.25529;
  unsigned int D.25530;
  char * D.25533;
  void * D.25534;
  unsigned int D.25535;
  unsigned int D.25536;
  int i;

  if (modreq != 0B) goto <D.25524>; else goto <D.25525>;
  <D.25524>:
  i = 0;
  goto <D.18521>;
  <D.18520>:
  {
    struct MonoType * mod;

    i.70 = (unsigned int) i;
    D.25527 = mono_array_addr_with_size (modreq, 4, i.70);
    D.25528 = MEM[(void * *)D.25527];
    mod = mono_reflection_type_get_handle (D.25528);
    sigbuffer_add_byte (buf, 31);
    D.25529 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25529);
  }
  i = i + 1;
  <D.18521>:
  i.70 = (unsigned int) i;
  D.25530 = mono_array_length (modreq);
  if (i.70 < D.25530) goto <D.18520>; else goto <D.18522>;
  <D.18522>:
  <D.25525>:
  if (modopt != 0B) goto <D.25531>; else goto <D.25532>;
  <D.25531>:
  i = 0;
  goto <D.18525>;
  <D.18524>:
  {
    struct MonoType * mod;

    i.70 = (unsigned int) i;
    D.25533 = mono_array_addr_with_size (modopt, 4, i.70);
    D.25534 = MEM[(void * *)D.25533];
    mod = mono_reflection_type_get_handle (D.25534);
    sigbuffer_add_byte (buf, 32);
    D.25535 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25535);
  }
  i = i + 1;
  <D.18525>:
  i.70 = (unsigned int) i;
  D.25536 = mono_array_length (modopt);
  if (i.70 < D.25536) goto <D.18524>; else goto <D.18526>;
  <D.18526>:
  <D.25532>:
}


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

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


mono_image_typedef_or_ref_full (struct MonoDynamicImage * assembly, struct MonoType * type, gboolean try_typespec)
{
  guint32 D.25543;
  struct GHashTable * D.25544;
  void * D.25545;
  struct MonoImage * D.25550;
  struct MonoImage * D.25551;
  unsigned char D.25554;
  unsigned int D.25559;
  void * D.25560;
  void * token.71;
  struct MonoGHashTable * D.25562;
  struct MonoClass * D.25563;
  struct MonoType * D.25566;
  unsigned int D.25567;
  int D.25569;
  unsigned int D.25572;
  unsigned int D.25573;
  guint32 * D.25574;
  unsigned int D.25575;
  unsigned int D.25576;
  guint32 * D.25577;
  const char * D.25578;
  struct MonoDynamicStream * D.25579;
  unsigned int D.25580;
  guint32 * D.25581;
  const char * D.25582;
  unsigned int D.25583;
  unsigned int D.25584;
  unsigned int D.25585;
  void * D.25586;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 scope;
  guint32 enclosing;
  struct MonoClass * klass;

  if (try_typespec != 0) goto <D.25539>; else goto <D.25540>;
  <D.25539>:
  token = create_typespec (assembly, type);
  if (token != 0) goto <D.25541>; else goto <D.25542>;
  <D.25541>:
  D.25543 = token;
  return D.25543;
  <D.25542>:
  <D.25540>:
  D.25544 = assembly->typeref;
  D.25545 = monoeg_g_hash_table_lookup (D.25544, type);
  token = (guint32) D.25545;
  if (token != 0) goto <D.25546>; else goto <D.25547>;
  <D.25546>:
  D.25543 = token;
  return D.25543;
  <D.25547>:
  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.25548>; else goto <D.25549>;
  <D.25548>:
  klass = mono_class_from_mono_type (type);
  <D.25549>:
  D.25550 = klass->image;
  D.25551 = &assembly->image;
  if (D.25550 == D.25551) goto <D.25552>; else goto <D.25553>;
  <D.25552>:
  D.25554 = type->type;
  if (D.25554 != 19) goto <D.25555>; else goto <D.25556>;
  <D.25555>:
  D.25554 = type->type;
  if (D.25554 != 30) goto <D.25557>; else goto <D.25558>;
  <D.25557>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.25559 = tb->table_idx;
    token = D.25559 << 2;
    D.25560 = mono_class_get_ref_info (klass);
    token.71 = (void *) token;
    D.25562 = assembly->tokens;
    mono_g_hash_table_insert (D.25562, token.71, D.25560);
    D.25543 = token;
    return D.25543;
  }
  <D.25558>:
  <D.25556>:
  <D.25553>:
  D.25563 = klass->nested_in;
  if (D.25563 != 0B) goto <D.25564>; else goto <D.25565>;
  <D.25564>:
  D.25563 = klass->nested_in;
  D.25566 = &D.25563->byval_arg;
  enclosing = mono_image_typedef_or_ref_full (assembly, D.25566, 0);
  enclosing = enclosing >> 2;
  D.25567 = enclosing << 2;
  scope = D.25567 | 3;
  goto <D.25568>;
  <D.25565>:
  D.25550 = klass->image;
  scope = resolution_scope_from_image (assembly, D.25550);
  <D.25568>:
  table = &assembly->tables[1];
  D.25569 = assembly->save;
  if (D.25569 != 0) goto <D.25570>; else goto <D.25571>;
  <D.25570>:
  D.25572 = table->rows;
  D.25573 = D.25572 + 1;
  alloc_table (table, D.25573);
  D.25574 = table->values;
  D.25575 = table->next_idx;
  D.25576 = D.25575 * 12;
  values = D.25574 + D.25576;
  *values = scope;
  D.25577 = values + 4;
  D.25578 = klass->name;
  D.25579 = &assembly->sheap;
  D.25580 = string_heap_insert (D.25579, D.25578);
  *D.25577 = D.25580;
  D.25581 = values + 8;
  D.25582 = klass->name_space;
  D.25579 = &assembly->sheap;
  D.25583 = string_heap_insert (D.25579, D.25582);
  *D.25581 = D.25583;
  <D.25571>:
  D.25575 = table->next_idx;
  D.25584 = D.25575 << 2;
  token = D.25584 | 1;
  token.71 = (void *) token;
  D.25544 = assembly->typeref;
  monoeg_g_hash_table_insert_replace (D.25544, type, token.71, 0);
  D.25575 = table->next_idx;
  D.25585 = D.25575 + 1;
  table->next_idx = D.25585;
  D.25586 = mono_class_get_ref_info (klass);
  token.71 = (void *) token;
  D.25562 = assembly->tokens;
  mono_g_hash_table_insert (D.25562, token.71, D.25586);
  D.25543 = token;
  return D.25543;
}


create_typespec (struct MonoDynamicImage * assembly, struct MonoType * type)
{
  struct GHashTable * D.25588;
  void * D.25589;
  guint32 D.25592;
  unsigned char D.25593;
  int D.25594;
  struct MonoGenericContainer * D.25598;
  int D.25599;
  unsigned int D.25602;
  unsigned int D.25603;
  guint32 * D.25604;
  unsigned int D.25605;
  unsigned int D.25606;
  unsigned int D.25607;
  void * token.72;
  unsigned int D.25609;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  struct SigBuffer buf;

  try
    {
      D.25588 = assembly->typespec;
      D.25589 = monoeg_g_hash_table_lookup (D.25588, type);
      token = (guint32) D.25589;
      if (token != 0) goto <D.25590>; else goto <D.25591>;
      <D.25590>:
      D.25592 = token;
      return D.25592;
      <D.25591>:
      sigbuffer_init (&buf, 32);
      D.25593 = type->type;
      D.25594 = (int) D.25593;
      switch (D.25594) <default: <D.19010>, case 15: <D.19000>, case 17: <D.19008>, case 18: <D.19007>, case 19: <D.19003>, case 20: <D.19002>, case 21: <D.19005>, case 27: <D.18999>, case 29: <D.19001>, case 30: <D.19004>>
      <D.18999>:
      <D.19000>:
      <D.19001>:
      <D.19002>:
      <D.19003>:
      <D.19004>:
      <D.19005>:
      encode_type (assembly, type, &buf);
      goto <D.19006>;
      <D.19007>:
      <D.19008>:
      {
        struct MonoClass * k;

        k = mono_class_from_mono_type (type);
        if (k == 0B) goto <D.25595>; else goto <D.25597>;
        <D.25597>:
        D.25598 = k->generic_container;
        if (D.25598 == 0B) goto <D.25595>; else goto <D.25596>;
        <D.25595>:
        sigbuffer_free (&buf);
        D.25592 = 0;
        return D.25592;
        <D.25596>:
        encode_type (assembly, type, &buf);
        goto <D.19006>;
      }
      <D.19010>:
      sigbuffer_free (&buf);
      D.25592 = 0;
      return D.25592;
      <D.19006>:
      table = &assembly->tables[27];
      D.25599 = assembly->save;
      if (D.25599 != 0) goto <D.25600>; else goto <D.25601>;
      <D.25600>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.25602 = table->rows;
      D.25603 = D.25602 + 1;
      alloc_table (table, D.25603);
      D.25604 = table->values;
      D.25605 = table->next_idx;
      D.25606 = D.25605 * 4;
      values = D.25604 + D.25606;
      *values = token;
      <D.25601>:
      sigbuffer_free (&buf);
      D.25605 = table->next_idx;
      D.25607 = D.25605 << 2;
      token = D.25607 | 2;
      token.72 = (void *) token;
      D.25588 = assembly->typespec;
      monoeg_g_hash_table_insert_replace (D.25588, type, token.72, 0);
      D.25605 = table->next_idx;
      D.25609 = D.25605 + 1;
      table->next_idx = D.25609;
      D.25592 = token;
      return D.25592;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_type (struct MonoDynamicImage * assembly, struct MonoType * type, struct SigBuffer * buf)
{
  unsigned char D.25614;
  unsigned char D.25615;
  unsigned char D.25618;
  int D.25619;
  unsigned int D.25620;
  struct MonoType * D.25621;
  struct MonoClass * D.25622;
  struct MonoType * D.25623;
  struct MonoGenericContainer * D.25624;
  struct MonoGenericInst * D.25627;
  unsigned char D.25629;
  unsigned int D.25630;
  struct MonoType * D.25631;
  unsigned int D.25632;
  struct MonoArrayType * D.25633;
  struct MonoClass * D.25634;
  struct MonoType * D.25635;
  unsigned char D.25636;
  unsigned int D.25637;
  struct MonoGenericClass * D.25638;
  struct MonoGenericParam * D.25639;
  short unsigned int D.25640;
  unsigned int D.25641;

  if (type == 0B) goto <D.25612>; else goto <D.25613>;
  <D.25612>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 679);
  return;
  <D.25613>:
  D.25614 = BIT_FIELD_REF <*type, 8, 56>;
  D.25615 = D.25614 & 64;
  if (D.25615 != 0) goto <D.25616>; else goto <D.25617>;
  <D.25616>:
  sigbuffer_add_value (buf, 16);
  <D.25617>:
  D.25618 = type->type;
  D.25619 = (int) D.25618;
  switch (D.25619) <default: <D.18505>, case 1: <D.18476>, case 2: <D.18477>, case 3: <D.18478>, case 4: <D.18479>, case 5: <D.18480>, case 6: <D.18481>, case 7: <D.18482>, case 8: <D.18483>, case 9: <D.18484>, case 10: <D.18485>, case 11: <D.18486>, case 12: <D.18487>, case 13: <D.18488>, case 14: <D.18491>, case 15: <D.18495>, case 17: <D.18497>, case 18: <D.18498>, case 19: <D.18503>, case 20: <D.18501>, case 21: <D.18502>, case 22: <D.18493>, case 24: <D.18489>, case 25: <D.18490>, case 28: <D.18492>, case 29: <D.18496>, case 30: <D.18504>>
  <D.18476>:
  <D.18477>:
  <D.18478>:
  <D.18479>:
  <D.18480>:
  <D.18481>:
  <D.18482>:
  <D.18483>:
  <D.18484>:
  <D.18485>:
  <D.18486>:
  <D.18487>:
  <D.18488>:
  <D.18489>:
  <D.18490>:
  <D.18491>:
  <D.18492>:
  <D.18493>:
  D.25618 = type->type;
  D.25620 = (unsigned int) D.25618;
  sigbuffer_add_value (buf, D.25620);
  goto <D.18494>;
  <D.18495>:
  D.25618 = type->type;
  D.25620 = (unsigned int) D.25618;
  sigbuffer_add_value (buf, D.25620);
  D.25621 = type->data.type;
  encode_type (assembly, D.25621, buf);
  goto <D.18494>;
  <D.18496>:
  D.25618 = type->type;
  D.25620 = (unsigned int) D.25618;
  sigbuffer_add_value (buf, D.25620);
  D.25622 = type->data.klass;
  D.25623 = &D.25622->byval_arg;
  encode_type (assembly, D.25623, buf);
  goto <D.18494>;
  <D.18497>:
  <D.18498>:
  {
    struct MonoClass * k;

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

      D.25624 = k->generic_container;
      D.25627 = D.25624->context.class_inst;
      gclass = mono_metadata_lookup_generic_class (k, D.25627, 1);
      encode_generic_class (assembly, gclass, buf);
    }
    goto <D.25628>;
    <D.25626>:
    D.25629 = k->byval_arg.type;
    D.25630 = (unsigned int) D.25629;
    sigbuffer_add_value (buf, D.25630);
    D.25631 = &k->byval_arg;
    D.25632 = mono_image_typedef_or_ref (assembly, D.25631);
    sigbuffer_add_value (buf, D.25632);
    <D.25628>:
    goto <D.18494>;
  }
  <D.18501>:
  D.25618 = type->type;
  D.25620 = (unsigned int) D.25618;
  sigbuffer_add_value (buf, D.25620);
  D.25633 = type->data.array;
  D.25634 = D.25633->eklass;
  D.25635 = &D.25634->byval_arg;
  encode_type (assembly, D.25635, buf);
  D.25633 = type->data.array;
  D.25636 = D.25633->rank;
  D.25637 = (unsigned int) D.25636;
  sigbuffer_add_value (buf, D.25637);
  sigbuffer_add_value (buf, 0);
  sigbuffer_add_value (buf, 0);
  goto <D.18494>;
  <D.18502>:
  D.25638 = type->data.generic_class;
  encode_generic_class (assembly, D.25638, buf);
  goto <D.18494>;
  <D.18503>:
  <D.18504>:
  D.25618 = type->type;
  D.25620 = (unsigned int) D.25618;
  sigbuffer_add_value (buf, D.25620);
  D.25639 = type->data.generic_param;
  D.25640 = D.25639->num;
  D.25641 = (unsigned int) D.25640;
  sigbuffer_add_value (buf, D.25641);
  goto <D.18494>;
  <D.18505>:
  D.25618 = type->type;
  D.25619 = (int) D.25618;
  monoeg_g_log (0B, 4, "need to encode type %x", D.25619);
  <D.18506>:
  goto <D.18506>;
  <D.18494>:
}


encode_generic_class (struct MonoDynamicImage * assembly, struct MonoGenericClass * gclass, struct SigBuffer * buf)
{
  _Bool D.25642;
  long int D.25643;
  long int D.25644;
  unsigned char D.25647;
  unsigned int D.25648;
  struct MonoType * D.25649;
  unsigned int D.25650;
  <unnamed-unsigned:22> D.25651;
  unsigned int D.25652;
  struct MonoType * D.25653;
  int D.25654;
  int i;
  struct MonoGenericInst * class_inst;
  struct MonoClass * klass;

  D.25642 = gclass == 0B;
  D.25643 = (long int) D.25642;
  D.25644 = __builtin_expect (D.25643, 0);
  if (D.25644 != 0) goto <D.25645>; else goto <D.25646>;
  <D.25645>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 660, "gclass");
  <D.25646>:
  class_inst = gclass->context.class_inst;
  sigbuffer_add_value (buf, 21);
  klass = gclass->container_class;
  D.25647 = klass->byval_arg.type;
  D.25648 = (unsigned int) D.25647;
  sigbuffer_add_value (buf, D.25648);
  D.25649 = &klass->byval_arg;
  D.25650 = mono_image_typedef_or_ref_full (assembly, D.25649, 0);
  sigbuffer_add_value (buf, D.25650);
  D.25651 = class_inst->type_argc;
  D.25652 = (unsigned int) D.25651;
  sigbuffer_add_value (buf, D.25652);
  i = 0;
  goto <D.18469>;
  <D.18468>:
  D.25653 = class_inst->type_argv[i];
  encode_type (assembly, D.25653, buf);
  i = i + 1;
  <D.18469>:
  D.25651 = class_inst->type_argc;
  D.25654 = (int) D.25651;
  if (D.25654 > i) goto <D.18468>; else goto <D.18470>;
  <D.18470>:
}


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

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


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

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


sigbuffer_add_to_blob_cached (struct MonoDynamicImage * assembly, struct SigBuffer * buf)
{
  char * D.25662;
  int D.25663;
  char * D.25664;
  int D.25665;
  int D.25666;
  char * D.25667;
  int D.25668;
  int D.25669;
  unsigned int D.25670;
  _Bool D.25671;
  long int D.25672;
  long int D.25673;
  char * b.74;
  guint32 D.25677;
  int size.75;
  int b.76;
  int blob_size.77;
  int D.25681;
  char blob_size[8];
  char * b;
  guint32 size;

  try
    {
      b = &blob_size;
      D.25662 = buf->p;
      D.25663 = (int) D.25662;
      D.25664 = buf->buf;
      D.25665 = (int) D.25664;
      D.25666 = D.25663 - D.25665;
      size = (guint32) D.25666;
      D.25667 = buf->end;
      D.25668 = (int) D.25667;
      D.25664 = buf->buf;
      D.25665 = (int) D.25664;
      D.25669 = D.25668 - D.25665;
      D.25670 = (unsigned int) D.25669;
      D.25671 = D.25670 < size;
      D.25672 = (long int) D.25671;
      D.25673 = __builtin_expect (D.25672, 0);
      if (D.25673 != 0) goto <D.25674>; else goto <D.25675>;
      <D.25674>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 501, "size <= (buf->end - buf->buf)");
      <D.25675>:
      b.74 = b;
      mono_metadata_encode_value (size, b.74, &b);
      size.75 = (int) size;
      D.25664 = buf->buf;
      b.74 = b;
      b.76 = (int) b.74;
      blob_size.77 = (int) &blob_size;
      D.25681 = b.76 - blob_size.77;
      D.25677 = add_to_blob_cached (assembly, &blob_size, D.25681, D.25664, size.75);
      return D.25677;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


add_to_blob_cached (struct MonoDynamicImage * assembly, char * b1, int s1, char * b2, int s2)
{
  int D.25684;
  unsigned int D.25685;
  unsigned int s1.78;
  unsigned int s2.79;
  sizetype s1.80;
  char * D.25689;
  struct GHashTable * D.25690;
  int D.25691;
  void * oldval.81;
  unsigned int s1.82;
  struct MonoDynamicStream * D.25697;
  unsigned int s2.83;
  void * idx.84;
  guint32 D.25700;
  guint32 idx;
  char * copy;
  void * oldkey;
  void * oldval;

  try
    {
      D.25684 = s1 + s2;
      D.25685 = (unsigned int) D.25684;
      copy = monoeg_malloc (D.25685);
      s1.78 = (unsigned int) s1;
      memcpy (copy, b1, s1.78);
      s2.79 = (unsigned int) s2;
      s1.80 = (sizetype) s1;
      D.25689 = copy + s1.80;
      memcpy (D.25689, b2, s2.79);
      D.25690 = assembly->blob_cache;
      D.25691 = monoeg_g_hash_table_lookup_extended (D.25690, copy, &oldkey, &oldval);
      if (D.25691 != 0) goto <D.25692>; else goto <D.25693>;
      <D.25692>:
      monoeg_g_free (copy);
      oldval.81 = oldval;
      idx = (guint32) oldval.81;
      goto <D.25695>;
      <D.25693>:
      s1.82 = (unsigned int) s1;
      D.25697 = &assembly->blob;
      idx = mono_image_add_stream_data (D.25697, b1, s1.82);
      s2.83 = (unsigned int) s2;
      D.25697 = &assembly->blob;
      mono_image_add_stream_data (D.25697, b2, s2.83);
      idx.84 = (void *) idx;
      D.25690 = assembly->blob_cache;
      monoeg_g_hash_table_insert_replace (D.25690, copy, idx.84, 0);
      <D.25695>:
      D.25700 = idx;
      return D.25700;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


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

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


method_encode_code (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  unsigned int D.25706;
  unsigned int D.25707;
  unsigned int D.25709;
  unsigned int D.25710;
  guint32 D.25711;
  struct MonoReflectionILGen * D.25712;
  int D.25715;
  gint32 iftmp.85;
  struct MonoArray * D.25717;
  unsigned int D.25720;
  struct MonoArray * D.25722;
  unsigned int D.25725;
  struct MonoString * D.25729;
  struct MonoDynamicStream * D.25730;
  int iftmp.86;
  _Bool D.25734;
  _Bool D.25735;
  _Bool D.25736;
  unsigned int D.25744;
  unsigned char D.25746;
  unsigned char D.25747;
  unsigned char D.25748;
  char flags.87;
  unsigned char D.25752;
  char flags.88;
  int D.25756;
  unsigned int D.25759;
  void * D.25760;
  struct MonoGHashTable * D.25761;
  char * D.25762;
  unsigned int D.25763;
  unsigned int D.25766;
  unsigned char D.25769;
  char D.25772;
  unsigned int D.25773;
  unsigned int D.25774;
  char D.25775;
  short unsigned int short_value.89;
  unsigned int D.25781;
  void * D.25782;
  char * D.25783;
  unsigned int num_exception.90;
  unsigned int D.25787;
  unsigned char D.25788;
  int D.25789;
  unsigned char D.25790;
  int D.25791;
  unsigned char D.25792;
  unsigned int D.25793;
  unsigned int D.25794;
  unsigned int i.91;
  struct MonoArray * D.25796;
  int D.25799;
  int D.25800;
  unsigned int j.92;
  int D.25802;
  unsigned int val.93;
  unsigned int val.94;
  int D.25807;
  unsigned int val.95;
  unsigned int val.96;
  int D.25811;
  unsigned int val.97;
  int D.25813;
  unsigned int val.98;
  struct MonoObject * D.25815;
  struct MonoType * D.25818;
  unsigned int D.25819;
  unsigned int val.99;
  int D.25824;
  unsigned int val.100;
  unsigned int val.101;
  unsigned int D.25828;
  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.25706 = mb->attrs;
      D.25707 = D.25706 & 9216;
      if (D.25707 != 0) goto <D.25704>; else goto <D.25708>;
      <D.25708>:
      D.25709 = mb->iattrs;
      D.25710 = D.25709 & 4099;
      if (D.25710 != 0) goto <D.25704>; else goto <D.25705>;
      <D.25704>:
      D.25711 = 0;
      return D.25711;
      <D.25705>:
      D.25712 = mb->ilgen;
      if (D.25712 != 0B) goto <D.25713>; else goto <D.25714>;
      <D.25713>:
      D.25712 = mb->ilgen;
      code = D.25712->code;
      D.25712 = mb->ilgen;
      D.25715 = D.25712->code_len;
      code_size = (guint32) D.25715;
      D.25712 = mb->ilgen;
      max_stack = D.25712->max_stack;
      D.25712 = mb->ilgen;
      D.25717 = D.25712->locals;
      if (D.25717 != 0B) goto <D.25718>; else goto <D.25719>;
      <D.25718>:
      D.25712 = mb->ilgen;
      D.25717 = D.25712->locals;
      D.25720 = mono_array_length (D.25717);
      iftmp.85 = (gint32) D.25720;
      goto <D.25721>;
      <D.25719>:
      iftmp.85 = 0;
      <D.25721>:
      num_locals = iftmp.85;
      D.25712 = mb->ilgen;
      D.25722 = D.25712->ex_handlers;
      if (D.25722 != 0B) goto <D.25723>; else goto <D.25724>;
      <D.25723>:
      D.25712 = mb->ilgen;
      D.25725 = method_count_clauses (D.25712);
      num_exception = (gint32) D.25725;
      <D.25724>:
      goto <D.25726>;
      <D.25714>:
      code = mb->code;
      if (code == 0B) goto <D.25727>; else goto <D.25728>;
      <D.25727>:
      {
        char * name;
        char * str;
        struct MonoException * exception;

        D.25729 = mb->name;
        name = mono_string_to_utf8 (D.25729);
        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.25728>:
      code_size = mono_array_length (code);
      max_stack = 8;
      <D.25726>:
      D.25730 = &assembly->code;
      stream_data_align (D.25730);
      D.25734 = max_stack <= 8;
      D.25735 = num_locals == 0;
      D.25736 = D.25734 & D.25735;
      if (D.25736 != 0) goto <D.25737>; else goto <D.25732>;
      <D.25737>:
      if (num_exception == 0) goto <D.25738>; else goto <D.25732>;
      <D.25738>:
      iftmp.86 = 1;
      goto <D.25733>;
      <D.25732>:
      iftmp.86 = 0;
      <D.25733>:
      maybe_small = iftmp.86;
      if (maybe_small != 0) goto <D.25739>; else goto <D.25740>;
      <D.25739>:
      if (code_size <= 63) goto <D.25743>; else goto <D.25741>;
      <D.25743>:
      D.25744 = code_size & 1;
      if (D.25744 == 0) goto <D.25745>; else goto <D.25741>;
      <D.25745>:
      D.25746 = (unsigned char) code_size;
      D.25747 = D.25746 << 2;
      D.25748 = D.25747 | 2;
      flags.87 = (char) D.25748;
      flags = flags.87;
      goto <D.25742>;
      <D.25741>:
      if (code_size <= 31) goto <D.25750>; else goto fat_header;
      <D.25750>:
      D.25744 = code_size & 1;
      if (D.25744 != 0) goto <D.25751>; else goto fat_header;
      <D.25751>:
      D.25746 = (unsigned char) code_size;
      D.25747 = D.25746 << 2;
      D.25752 = D.25747 | 6;
      flags.88 = (char) D.25752;
      flags = flags.88;
      <D.25742>:
      D.25730 = &assembly->code;
      idx = mono_image_add_stream_data (D.25730, &flags, 1);
      D.25712 = mb->ilgen;
      if (D.25712 != 0B) goto <D.25754>; else goto <D.25755>;
      <D.25754>:
      D.25712 = mb->ilgen;
      D.25756 = D.25712->num_token_fixups;
      if (D.25756 != 0) goto <D.25757>; else goto <D.25758>;
      <D.25757>:
      D.25759 = idx + 1;
      D.25760 = (void *) D.25759;
      D.25712 = mb->ilgen;
      D.25761 = assembly->token_fixups;
      mono_g_hash_table_insert (D.25761, D.25712, D.25760);
      <D.25758>:
      <D.25755>:
      D.25762 = mono_array_addr_with_size (code, 1, 0);
      D.25730 = &assembly->code;
      mono_image_add_stream_data (D.25730, D.25762, code_size);
      D.25763 = assembly->text_rva;
      D.25711 = D.25763 + idx;
      return D.25711;
      <D.25740>:
      fat_header:
      if (num_locals != 0) goto <D.25764>; else goto <D.25765>;
      <D.25764>:
      D.25712 = mb->ilgen;
      D.25766 = encode_locals (assembly, D.25712);
      local_sig = D.25766 | 285212672;
      <D.25765>:
      fat_flags = 3;
      if (num_exception != 0) goto <D.25767>; else goto <D.25768>;
      <D.25767>:
      fat_flags = fat_flags | 8;
      <D.25768>:
      D.25769 = mb->init_locals;
      if (D.25769 != 0) goto <D.25770>; else goto <D.25771>;
      <D.25770>:
      fat_flags = fat_flags | 16;
      <D.25771>:
      D.25772 = (char) fat_flags;
      fat_header[0] = D.25772;
      D.25773 = header_size / 4;
      D.25774 = D.25773 << 4;
      D.25775 = (char) D.25774;
      fat_header[1] = D.25775;
      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.25730 = &assembly->code;
      idx = mono_image_add_stream_data (D.25730, &fat_header, 12);
      D.25712 = mb->ilgen;
      if (D.25712 != 0B) goto <D.25777>; else goto <D.25778>;
      <D.25777>:
      D.25712 = mb->ilgen;
      D.25756 = D.25712->num_token_fixups;
      if (D.25756 != 0) goto <D.25779>; else goto <D.25780>;
      <D.25779>:
      D.25781 = idx + 12;
      D.25782 = (void *) D.25781;
      D.25712 = mb->ilgen;
      D.25761 = assembly->token_fixups;
      mono_g_hash_table_insert (D.25761, D.25712, D.25782);
      <D.25780>:
      <D.25778>:
      D.25783 = mono_array_addr_with_size (code, 1, 0);
      D.25730 = &assembly->code;
      mono_image_add_stream_data (D.25730, D.25783, code_size);
      if (num_exception != 0) goto <D.25784>; else goto <D.25785>;
      <D.25784>:
      {
        unsigned char sheader[4];
        struct MonoILExceptionInfo * ex_info;
        struct MonoILExceptionBlock * ex_block;
        int j;

        try
          {
            D.25730 = &assembly->code;
            stream_data_align (D.25730);
            sheader[0] = 65;
            num_exception.90 = (unsigned int) num_exception;
            D.25787 = num_exception.90 * 24;
            num_exception = (gint32) D.25787;
            num_exception = num_exception + 4;
            D.25788 = (unsigned char) num_exception;
            sheader[1] = D.25788;
            D.25789 = num_exception >> 8;
            D.25790 = (unsigned char) D.25789;
            sheader[2] = D.25790;
            D.25791 = num_exception >> 16;
            D.25792 = (unsigned char) D.25791;
            sheader[3] = D.25792;
            D.25730 = &assembly->code;
            mono_image_add_stream_data (D.25730, &sheader, 4);
            D.25712 = mb->ilgen;
            D.25722 = D.25712->ex_handlers;
            D.25793 = mono_array_length (D.25722);
            D.25794 = D.25793 + 4294967295;
            i = (gint32) D.25794;
            goto <D.18637>;
            <D.18636>:
            i.91 = (unsigned int) i;
            D.25712 = mb->ilgen;
            D.25722 = D.25712->ex_handlers;
            ex_info = mono_array_addr_with_size (D.25722, 16, i.91);
            D.25796 = ex_info->handlers;
            if (D.25796 != 0B) goto <D.25797>; else goto <D.25798>;
            <D.25797>:
            {
              int finally_start;

              D.25799 = ex_info->start;
              D.25800 = ex_info->len;
              finally_start = D.25799 + D.25800;
              j = 0;
              goto <D.18633>;
              <D.18632>:
              {
                guint32 val;

                try
                  {
                    j.92 = (unsigned int) j;
                    D.25796 = ex_info->handlers;
                    ex_block = mono_array_addr_with_size (D.25796, 20, j.92);
                    D.25802 = ex_block->type;
                    val.93 = (unsigned int) D.25802;
                    val = val.93;
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                    D.25799 = ex_info->start;
                    val.94 = (unsigned int) D.25799;
                    val = val.94;
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                    D.25802 = ex_block->type;
                    if (D.25802 == 2) goto <D.25805>; else goto <D.25806>;
                    <D.25805>:
                    D.25799 = ex_info->start;
                    D.25807 = finally_start - D.25799;
                    val.95 = (unsigned int) D.25807;
                    val = val.95;
                    goto <D.25809>;
                    <D.25806>:
                    D.25800 = ex_info->len;
                    val.96 = (unsigned int) D.25800;
                    val = val.96;
                    <D.25809>:
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                    D.25811 = ex_block->start;
                    val.97 = (unsigned int) D.25811;
                    val = val.97;
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                    D.25813 = ex_block->len;
                    val.98 = (unsigned int) D.25813;
                    val = val.98;
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                    D.25811 = ex_block->start;
                    D.25813 = ex_block->len;
                    finally_start = D.25811 + D.25813;
                    D.25815 = ex_block->extype;
                    if (D.25815 != 0B) goto <D.25816>; else goto <D.25817>;
                    <D.25816>:
                    D.25815 = ex_block->extype;
                    D.25818 = mono_reflection_type_get_handle (D.25815);
                    D.25819 = mono_image_typedef_or_ref (assembly, D.25818);
                    val.99 = mono_metadata_token_from_dor (D.25819);
                    val = val.99;
                    goto <D.25821>;
                    <D.25817>:
                    D.25802 = ex_block->type;
                    if (D.25802 == 1) goto <D.25822>; else goto <D.25823>;
                    <D.25822>:
                    D.25824 = ex_block->filter_offset;
                    val.100 = (unsigned int) D.25824;
                    val = val.100;
                    goto <D.25826>;
                    <D.25823>:
                    val = 0;
                    <D.25826>:
                    <D.25821>:
                    val.101 = val;
                    val = val.101;
                    D.25730 = &assembly->code;
                    mono_image_add_stream_data (D.25730, &val, 4);
                  }
                finally
                  {
                    val = {CLOBBER};
                  }
              }
              j = j + 1;
              <D.18633>:
              j.92 = (unsigned int) j;
              D.25796 = ex_info->handlers;
              D.25828 = mono_array_length (D.25796);
              if (j.92 < D.25828) goto <D.18632>; else goto <D.18634>;
              <D.18634>:
            }
            goto <D.25829>;
            <D.25798>:
            monoeg_g_log (0B, 4, "No clauses for ex info block %d", i);
            <D.18635>:
            goto <D.18635>;
            <D.25829>:
            i = i + -1;
            <D.18637>:
            if (i >= 0) goto <D.18636>; else goto <D.18638>;
            <D.18638>:
          }
        finally
          {
            sheader = {CLOBBER};
          }
      }
      <D.25785>:
      D.25763 = assembly->text_rva;
      D.25711 = D.25763 + idx;
      return D.25711;
    }
  finally
    {
      flags = {CLOBBER};
      fat_header = {CLOBBER};
      int_value = {CLOBBER};
      short_value = {CLOBBER};
    }
}


method_count_clauses (struct MonoReflectionILGen * ilgen)
{
  unsigned int i.102;
  struct MonoArray * D.25833;
  struct MonoArray * D.25834;
  unsigned int D.25837;
  unsigned int D.25839;
  guint32 D.25840;
  guint32 num_clauses;
  int i;
  struct MonoILExceptionInfo * ex_info;

  num_clauses = 0;
  i = 0;
  goto <D.18580>;
  <D.18579>:
  i.102 = (unsigned int) i;
  D.25833 = ilgen->ex_handlers;
  ex_info = mono_array_addr_with_size (D.25833, 16, i.102);
  D.25834 = ex_info->handlers;
  if (D.25834 != 0B) goto <D.25835>; else goto <D.25836>;
  <D.25835>:
  D.25834 = ex_info->handlers;
  D.25837 = mono_array_length (D.25834);
  num_clauses = D.25837 + num_clauses;
  goto <D.25838>;
  <D.25836>:
  num_clauses = num_clauses + 1;
  <D.25838>:
  i = i + 1;
  <D.18580>:
  i.102 = (unsigned int) i;
  D.25833 = ilgen->ex_handlers;
  D.25839 = mono_array_length (D.25833);
  if (i.102 < D.25839) goto <D.18579>; else goto <D.18581>;
  <D.18581>:
  D.25840 = num_clauses;
  return D.25840;
}


encode_locals (struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.25842;
  unsigned int i.103;
  char * D.25844;
  unsigned char D.25845;
  struct MonoObject * D.25848;
  unsigned int i.104;
  struct GHashTable * D.25850;
  struct GHashTable * D.25853;
  const void * sig_idx.105;
  void * D.25855;
  guint32 D.25858;
  unsigned int D.25859;
  unsigned int idx.106;
  unsigned int D.25861;
  unsigned int D.25862;
  unsigned int D.25863;
  guint32 * D.25864;
  unsigned int D.25865;
  void * idx.107;
  void * sig_idx.108;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 idx;
  guint32 sig_idx;
  guint nl;
  struct SigBuffer buf;
  int i;

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

        i.103 = (unsigned int) i;
        D.25842 = ilgen->locals;
        D.25844 = mono_array_addr_with_size (D.25842, 4, i.103);
        lb = MEM[(struct MonoReflectionLocalBuilder * *)D.25844];
        D.25845 = lb->is_pinned;
        if (D.25845 != 0) goto <D.25846>; else goto <D.25847>;
        <D.25846>:
        sigbuffer_add_value (&buf, 69);
        <D.25847>:
        D.25848 = lb->type;
        encode_reflection_type (assembly, D.25848, &buf);
      }
      i = i + 1;
      <D.18571>:
      i.104 = (unsigned int) i;
      if (i.104 < nl) goto <D.18570>; else goto <D.18572>;
      <D.18572>:
      sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25850 = assembly->standalonesig_cache;
      if (D.25850 == 0B) goto <D.25851>; else goto <D.25852>;
      <D.25851>:
      D.25853 = monoeg_g_hash_table_new (0B, 0B);
      assembly->standalonesig_cache = D.25853;
      <D.25852>:
      sig_idx.105 = (const void *) sig_idx;
      D.25850 = assembly->standalonesig_cache;
      D.25855 = monoeg_g_hash_table_lookup (D.25850, sig_idx.105);
      idx = (guint32) D.25855;
      if (idx != 0) goto <D.25856>; else goto <D.25857>;
      <D.25856>:
      D.25858 = idx;
      return D.25858;
      <D.25857>:
      table = &assembly->tables[17];
      D.25859 = table->next_idx;
      idx.106 = D.25859;
      D.25861 = idx.106 + 1;
      table->next_idx = D.25861;
      idx = idx.106;
      D.25862 = table->rows;
      D.25863 = D.25862 + 1;
      table->rows = D.25863;
      D.25862 = table->rows;
      alloc_table (table, D.25862);
      D.25864 = table->values;
      D.25865 = idx * 4;
      values = D.25864 + D.25865;
      *values = sig_idx;
      idx.107 = (void *) idx;
      sig_idx.108 = (void *) sig_idx;
      D.25850 = assembly->standalonesig_cache;
      monoeg_g_hash_table_insert_replace (D.25850, sig_idx.108, idx.107, 0);
      D.25858 = idx;
      return D.25858;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  try
    {
      buf = {};
      D.25870 = stream->index;
      count = D.25870 & 3;
      if (count != 0) goto <D.25871>; else goto <D.25872>;
      <D.25871>:
      D.25873 = 4 - count;
      mono_image_add_stream_data (stream, &buf, D.25873);
      <D.25872>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_marshal_blob (struct MonoDynamicImage * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.25874;
  unsigned int D.25875;
  int D.25876;
  unsigned int D.25877;
  int D.25880;
  unsigned char D.25882;
  unsigned int D.25883;
  guint32 iftmp.109;
  int D.25887;
  guint32 iftmp.110;
  _Bool D.25895;
  unsigned int D.25896;
  struct MonoString * D.25899;
  struct MonoString * D.25906;
  struct MonoObject * D.25908;
  struct MonoType * D.25911;
  struct MonoString * D.25913;
  guint32 D.25917;
  char * str;
  struct SigBuffer buf;
  guint32 idx;
  guint32 len;

  try
    {
      sigbuffer_init (&buf, 32);
      D.25874 = minfo->type;
      D.25875 = (unsigned int) D.25874;
      sigbuffer_add_value (&buf, D.25875);
      D.25874 = minfo->type;
      switch (D.25874) <default: <D.18899>, case 23: <D.18893>, case 29: <D.18897>, case 30: <D.18894>, case 42: <D.18896>, case 44: <D.18898>>
      <D.18893>:
      <D.18894>:
      D.25876 = minfo->count;
      D.25877 = (unsigned int) D.25876;
      sigbuffer_add_value (&buf, D.25877);
      goto <D.18895>;
      <D.18896>:
      D.25880 = minfo->eltype;
      if (D.25880 != 0) goto <D.25878>; else goto <D.25881>;
      <D.25881>:
      D.25882 = minfo->has_size;
      if (D.25882 != 0) goto <D.25878>; else goto <D.25879>;
      <D.25878>:
      D.25880 = minfo->eltype;
      D.25883 = (unsigned int) D.25880;
      sigbuffer_add_value (&buf, D.25883);
      D.25882 = minfo->has_size;
      if (D.25882 != 0) goto <D.25884>; else goto <D.25885>;
      <D.25884>:
      D.25887 = minfo->param_num;
      if (D.25887 != -1) goto <D.25888>; else goto <D.25889>;
      <D.25888>:
      D.25887 = minfo->param_num;
      iftmp.109 = (guint32) D.25887;
      goto <D.25890>;
      <D.25889>:
      iftmp.109 = 0;
      <D.25890>:
      sigbuffer_add_value (&buf, iftmp.109);
      D.25876 = minfo->count;
      if (D.25876 != -1) goto <D.25892>; else goto <D.25893>;
      <D.25892>:
      D.25876 = minfo->count;
      iftmp.110 = (guint32) D.25876;
      goto <D.25894>;
      <D.25893>:
      iftmp.110 = 0;
      <D.25894>:
      sigbuffer_add_value (&buf, iftmp.110);
      D.25887 = minfo->param_num;
      D.25895 = D.25887 != -1;
      D.25896 = (unsigned int) D.25895;
      sigbuffer_add_value (&buf, D.25896);
      <D.25885>:
      <D.25879>:
      goto <D.18895>;
      <D.18897>:
      D.25880 = minfo->eltype;
      if (D.25880 != 0) goto <D.25897>; else goto <D.25898>;
      <D.25897>:
      D.25880 = minfo->eltype;
      D.25883 = (unsigned int) D.25880;
      sigbuffer_add_value (&buf, D.25883);
      <D.25898>:
      goto <D.18895>;
      <D.18898>:
      D.25899 = minfo->guid;
      if (D.25899 != 0B) goto <D.25900>; else goto <D.25901>;
      <D.25900>:
      D.25899 = minfo->guid;
      str = mono_string_to_utf8 (D.25899);
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25902>;
      <D.25901>:
      sigbuffer_add_value (&buf, 0);
      <D.25902>:
      sigbuffer_add_value (&buf, 0);
      D.25906 = minfo->marshaltype;
      if (D.25906 != 0B) goto <D.25903>; else goto <D.25907>;
      <D.25907>:
      D.25908 = minfo->marshaltyperef;
      if (D.25908 != 0B) goto <D.25903>; else goto <D.25904>;
      <D.25903>:
      D.25908 = minfo->marshaltyperef;
      if (D.25908 != 0B) goto <D.25909>; else goto <D.25910>;
      <D.25909>:
      D.25908 = minfo->marshaltyperef;
      D.25911 = mono_reflection_type_get_handle (D.25908);
      str = type_get_fully_qualified_name (D.25911);
      goto <D.25912>;
      <D.25910>:
      D.25906 = minfo->marshaltype;
      str = mono_string_to_utf8 (D.25906);
      <D.25912>:
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25905>;
      <D.25904>:
      sigbuffer_add_value (&buf, 0);
      <D.25905>:
      D.25913 = minfo->mcookie;
      if (D.25913 != 0B) goto <D.25914>; else goto <D.25915>;
      <D.25914>:
      D.25913 = minfo->mcookie;
      str = mono_string_to_utf8 (D.25913);
      len = strlen (str);
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.25916>;
      <D.25915>:
      sigbuffer_add_value (&buf, 0);
      <D.25916>:
      goto <D.18895>;
      <D.18899>:
      goto <D.18895>;
      <D.18895>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25917 = idx;
      return D.25917;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


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

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


encode_constant (struct MonoDynamicImage * assembly, struct MonoObject * val, guint32 * ret_type)
{
  struct MonoVTable * D.25929;
  struct MonoClass * D.25930;
  unsigned char D.25931;
  unsigned int D.25932;
  unsigned int D.25933;
  unsigned char D.25934;
  unsigned char D.25935;
  struct MonoType * D.25938;
  unsigned char D.25939;
  unsigned int D.25940;
  struct MonoImage * D.25943;
  int D.25944;
  int D.18868;
  int iftmp.112;
  int D.18867;
  const char[7] * D.25949;
  unsigned char D.25950;
  int D.25951;
  unsigned char D.25952;
  int D.25953;
  _Bool D.25954;
  _Bool D.25955;
  _Bool D.25956;
  const unsigned char * D.25959;
  unsigned char D.25960;
  int D.25961;
  const unsigned char * D.25962;
  unsigned char D.25963;
  int D.25964;
  _Bool D.25965;
  _Bool D.25966;
  const unsigned char * D.25969;
  unsigned char D.25970;
  int D.25971;
  const unsigned char * D.25972;
  unsigned char D.25973;
  int D.25974;
  _Bool D.25975;
  _Bool D.25976;
  const unsigned char * D.25979;
  unsigned char D.25980;
  int D.25981;
  const unsigned char * D.25982;
  unsigned char D.25983;
  int D.25984;
  const char * D.25986;
  int D.18877;
  int iftmp.113;
  int D.18876;
  const char[9] * D.25991;
  unsigned char D.25992;
  int D.25993;
  unsigned char D.25994;
  int D.25995;
  _Bool D.25996;
  _Bool D.25997;
  _Bool D.25998;
  const unsigned char * D.26001;
  unsigned char D.26002;
  int D.26003;
  const unsigned char * D.26004;
  unsigned char D.26005;
  int D.26006;
  _Bool D.26007;
  _Bool D.26008;
  const unsigned char * D.26011;
  unsigned char D.26012;
  int D.26013;
  const unsigned char * D.26014;
  unsigned char D.26015;
  int D.26016;
  _Bool D.26017;
  _Bool D.26018;
  const unsigned char * D.26021;
  unsigned char D.26022;
  int D.26023;
  const unsigned char * D.26024;
  unsigned char D.26025;
  int D.26026;
  const char * D.26028;
  int D.26030;
  int D.26031;
  char * b.114;
  int len.115;
  mono_unichar2 * D.26034;
  int b.116;
  int blob_size.117;
  int D.26037;
  guint32 D.26038;
  struct MonoGenericClass * D.26039;
  struct MonoClass * D.26040;
  unsigned char D.26041;
  unsigned int D.26042;
  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.25926>; else goto <D.25927>;
      <D.25926>:
      *ret_type = 18;
      len = 4;
      box_val = &dummy;
      goto <D.25928>;
      <D.25927>:
      box_val = val + 8;
      D.25929 = val->vtable;
      D.25930 = D.25929->klass;
      D.25931 = D.25930->byval_arg.type;
      D.25932 = (unsigned int) D.25931;
      *ret_type = D.25932;
      <D.25928>:
      handle_enum:
      D.25933 = *ret_type;
      switch (D.25933) <default: <D.18883>, case 2: <D.18845>, case 3: <D.18849>, case 4: <D.18847>, case 5: <D.18846>, case 6: <D.18851>, case 7: <D.18850>, case 8: <D.18853>, case 9: <D.18852>, case 10: <D.18856>, case 11: <D.18855>, case 12: <D.18854>, case 13: <D.18857>, case 14: <D.18880>, case 17: <D.18858>, case 18: <D.18879>, case 21: <D.18882>>
      <D.18845>:
      <D.18846>:
      <D.18847>:
      len = 1;
      goto <D.18848>;
      <D.18849>:
      <D.18850>:
      <D.18851>:
      len = 2;
      goto <D.18848>;
      <D.18852>:
      <D.18853>:
      <D.18854>:
      len = 4;
      goto <D.18848>;
      <D.18855>:
      <D.18856>:
      len = 8;
      goto <D.18848>;
      <D.18857>:
      len = 8;
      goto <D.18848>;
      <D.18858>:
      {
        struct MonoClass * klass;

        D.25929 = val->vtable;
        klass = D.25929->klass;
        D.25934 = BIT_FIELD_REF <*klass, 8, 160>;
        D.25935 = D.25934 & 16;
        if (D.25935 != 0) goto <D.25936>; else goto <D.25937>;
        <D.25936>:
        D.25938 = mono_class_enum_basetype (klass);
        D.25939 = D.25938->type;
        D.25940 = (unsigned int) D.25939;
        *ret_type = D.25940;
        goto handle_enum;
        <D.25937>:
        D.25943 = klass->image;
        D.25944 = mono_is_corlib_image (D.25943);
        if (D.25944 != 0) goto <D.25945>; else goto <D.25941>;
        <D.25945>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.25949 = "System";
            D.25950 = MEM[(const unsigned char *)D.25949];
            D.25951 = (int) D.25950;
            D.25952 = *__s2;
            D.25953 = (int) D.25952;
            __result = D.25951 - D.25953;
            {
              D.25954 = __s2_len != 0;
              D.25955 = __result == 0;
              D.25956 = D.25954 & D.25955;
              if (D.25956 != 0) goto <D.25957>; else goto <D.25958>;
              <D.25957>:
              D.25959 = &MEM[(void *)"System" + 1B];
              D.25960 = *D.25959;
              D.25961 = (int) D.25960;
              D.25962 = __s2 + 1;
              D.25963 = *D.25962;
              D.25964 = (int) D.25963;
              __result = D.25961 - D.25964;
              D.25965 = __s2_len > 1;
              D.25955 = __result == 0;
              D.25966 = D.25965 & D.25955;
              if (D.25966 != 0) goto <D.25967>; else goto <D.25968>;
              <D.25967>:
              D.25969 = &MEM[(void *)"System" + 2B];
              D.25970 = *D.25969;
              D.25971 = (int) D.25970;
              D.25972 = __s2 + 2;
              D.25973 = *D.25972;
              D.25974 = (int) D.25973;
              __result = D.25971 - D.25974;
              D.25975 = __s2_len > 2;
              D.25955 = __result == 0;
              D.25976 = D.25975 & D.25955;
              if (D.25976 != 0) goto <D.25977>; else goto <D.25978>;
              <D.25977>:
              D.25979 = &MEM[(void *)"System" + 3B];
              D.25980 = *D.25979;
              D.25981 = (int) D.25980;
              D.25982 = __s2 + 3;
              D.25983 = *D.25982;
              D.25984 = (int) D.25983;
              __result = D.25981 - D.25984;
              <D.25978>:
              <D.25968>:
              <D.25958>:
            }
            D.18867 = __result;
          }
          iftmp.112 = -D.18867;
          goto <D.25985>;
          <D.25948>:
          D.25986 = klass->name_space;
          iftmp.112 = __builtin_strcmp (D.25986, "System");
          <D.25985>:
          D.18868 = iftmp.112;
        }
        if (D.18868 == 0) goto <D.25987>; else goto <D.25941>;
        <D.25987>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.25991 = "DateTime";
            D.25992 = MEM[(const unsigned char *)D.25991];
            D.25993 = (int) D.25992;
            D.25994 = *__s2;
            D.25995 = (int) D.25994;
            __result = D.25993 - D.25995;
            {
              D.25996 = __s2_len != 0;
              D.25997 = __result == 0;
              D.25998 = D.25996 & D.25997;
              if (D.25998 != 0) goto <D.25999>; else goto <D.26000>;
              <D.25999>:
              D.26001 = &MEM[(void *)"DateTime" + 1B];
              D.26002 = *D.26001;
              D.26003 = (int) D.26002;
              D.26004 = __s2 + 1;
              D.26005 = *D.26004;
              D.26006 = (int) D.26005;
              __result = D.26003 - D.26006;
              D.26007 = __s2_len > 1;
              D.25997 = __result == 0;
              D.26008 = D.26007 & D.25997;
              if (D.26008 != 0) goto <D.26009>; else goto <D.26010>;
              <D.26009>:
              D.26011 = &MEM[(void *)"DateTime" + 2B];
              D.26012 = *D.26011;
              D.26013 = (int) D.26012;
              D.26014 = __s2 + 2;
              D.26015 = *D.26014;
              D.26016 = (int) D.26015;
              __result = D.26013 - D.26016;
              D.26017 = __s2_len > 2;
              D.25997 = __result == 0;
              D.26018 = D.26017 & D.25997;
              if (D.26018 != 0) goto <D.26019>; else goto <D.26020>;
              <D.26019>:
              D.26021 = &MEM[(void *)"DateTime" + 3B];
              D.26022 = *D.26021;
              D.26023 = (int) D.26022;
              D.26024 = __s2 + 3;
              D.26025 = *D.26024;
              D.26026 = (int) D.26025;
              __result = D.26023 - D.26026;
              <D.26020>:
              <D.26010>:
              <D.26000>:
            }
            D.18876 = __result;
          }
          iftmp.113 = -D.18876;
          goto <D.26027>;
          <D.25990>:
          D.26028 = klass->name;
          iftmp.113 = __builtin_strcmp (D.26028, "DateTime");
          <D.26027>:
          D.18877 = iftmp.113;
        }
        if (D.18877 == 0) goto <D.26029>; else goto <D.25941>;
        <D.26029>:
        len = 8;
        goto <D.25942>;
        <D.25941>:
        monoeg_g_log (0B, 4, "we can\'t encode valuetypes, we should have never reached this line");
        <D.18878>:
        goto <D.18878>;
        <D.25942>:
        goto <D.18848>;
      }
      <D.18879>:
      goto <D.18848>;
      <D.18880>:
      {
        struct MonoString * str;

        str = val;
        D.26030 = str->length;
        D.26031 = D.26030 * 2;
        len = (guint32) D.26031;
        b.114 = b;
        mono_metadata_encode_value (len, b.114, &b);
        len.115 = (int) len;
        D.26034 = mono_string_chars (str);
        b.114 = b;
        b.116 = (int) b.114;
        blob_size.117 = (int) &blob_size;
        D.26037 = b.116 - blob_size.117;
        idx = add_to_blob_cached (assembly, &blob_size, D.26037, D.26034, len.115);
        monoeg_g_free (buf);
        D.26038 = idx;
        return D.26038;
      }
      <D.18882>:
      D.25929 = val->vtable;
      D.25930 = D.25929->klass;
      D.26039 = D.25930->generic_class;
      D.26040 = D.26039->container_class;
      D.26041 = D.26040->byval_arg.type;
      D.26042 = (unsigned int) D.26041;
      *ret_type = D.26042;
      goto handle_enum;
      <D.18883>:
      D.25933 = *ret_type;
      monoeg_g_log (0B, 4, "we don\'t encode constant type 0x%02x yet", D.25933);
      <D.18884>:
      goto <D.18884>;
      <D.18848>:
      b.114 = b;
      mono_metadata_encode_value (len, b.114, &b);
      len.115 = (int) len;
      b.114 = b;
      b.116 = (int) b.114;
      blob_size.117 = (int) &blob_size;
      D.26037 = b.116 - blob_size.117;
      idx = add_to_blob_cached (assembly, &blob_size, D.26037, box_val, len.115);
      monoeg_g_free (buf);
      D.26038 = idx;
      return D.26038;
    }
  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.26046;
  int D.26047;
  _Bool D.26048;
  long int D.26049;
  long int D.26050;
  guint32 * D.26053;
  unsigned int D.26054;
  unsigned int D.26055;
  unsigned int col.118;
  unsigned int D.26057;
  guint32 * D.26058;
  unsigned int D.26059;
  guint32 D.26062;
  unsigned int i.119;
  unsigned int D.26064;
  int i;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[table_idx];
  D.26046 = table->columns;
  D.26047 = (int) D.26046;
  D.26048 = D.26047 <= col;
  D.26049 = (long int) D.26048;
  D.26050 = __builtin_expect (D.26049, 0);
  if (D.26050 != 0) goto <D.26051>; else goto <D.26052>;
  <D.26051>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1155, "col < table->columns");
  <D.26052>:
  D.26053 = table->values;
  D.26046 = table->columns;
  D.26054 = (unsigned int) D.26046;
  D.26055 = D.26054 * 4;
  values = D.26053 + D.26055;
  i = 1;
  goto <D.18649>;
  <D.18648>:
  col.118 = (unsigned int) col;
  D.26057 = col.118 * 4;
  D.26058 = values + D.26057;
  D.26059 = *D.26058;
  if (D.26059 == token) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  D.26062 = (guint32) i;
  return D.26062;
  <D.26061>:
  D.26046 = table->columns;
  D.26054 = (unsigned int) D.26046;
  D.26055 = D.26054 * 4;
  values = values + D.26055;
  i = i + 1;
  <D.18649>:
  i.119 = (unsigned int) i;
  D.26064 = table->rows;
  if (i.119 <= D.26064) goto <D.18648>; else goto <D.18650>;
  <D.18650>:
  D.26062 = 0;
  return D.26062;
}


mono_image_get_generic_param_info (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  int D.26066;
  void * D.26071;
  struct MonoReflectionGenericParam * * D.26072;
  struct GPtrArray * D.26073;
  struct GenericParamTableEntry * entry;

  entry = monoeg_malloc0 (8);
  entry->owner = owner;
  D.26066 = mono_gc_is_moving ();
  if (D.26066 != 0) goto <D.26067>; else goto <D.26068>;
  <D.26067>:
  if (0 != 0) goto <D.26069>; else goto <D.26070>;
  <D.26069>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2206, "sizeof (entry->gparam) == sizeof (MonoObject*)");
  <D.26070>:
  D.26071 = mono_gc_make_root_descr_all_refs (1);
  D.26072 = &entry->gparam;
  mono_gc_register_root (D.26072, 4, D.26071);
  <D.26068>:
  entry->gparam = gparam;
  D.26073 = assembly->gen_params;
  monoeg_g_ptr_array_add (D.26073, entry);
}


mono_image_get_field_info (struct MonoReflectionFieldBuilder * fb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26074;
  unsigned int D.26075;
  unsigned int D.26078;
  unsigned int D.26079;
  unsigned int D.26080;
  unsigned int D.26081;
  int D.26082;
  int D.26083;
  void * D.26084;
  struct MonoClassField * D.26085;
  struct GHashTable * D.26086;
  guint32 * D.26087;
  unsigned int D.26088;
  unsigned int D.26089;
  guint32 * D.26090;
  struct MonoString * D.26091;
  struct MonoDynamicStream * D.26092;
  unsigned int D.26093;
  guint32 * D.26094;
  unsigned int D.26095;
  int D.26096;
  unsigned int D.26099;
  unsigned int D.26100;
  unsigned int D.26101;
  unsigned int D.26102;
  unsigned int D.26103;
  unsigned int D.26106;
  int D.26107;
  unsigned int D.26108;
  guint32 * D.26109;
  struct MonoObject * D.26110;
  unsigned int D.26111;
  unsigned int field_type.120;
  unsigned int D.26113;
  struct MonoArray * D.26116;
  unsigned int D.26119;
  struct MonoDynamicStream * D.26122;
  unsigned int D.26123;
  char * D.26124;
  struct MonoClass * D.26126;
  int D.26127;
  unsigned int D.26128;
  unsigned int D.26129;
  unsigned int D.26130;
  struct MonoReflectionMarshal * D.26131;
  int D.26134;
  unsigned int D.26135;
  unsigned int D.26136;
  struct MonoDynamicTable * table;
  guint32 * values;

  D.26074 = fb->attrs;
  D.26075 = D.26074 & 64;
  if (D.26075 != 0) goto <D.26076>; else goto <D.26077>;
  <D.26076>:
  D.26074 = fb->attrs;
  D.26078 = D.26074 | 32768;
  fb->attrs = D.26078;
  <D.26077>:
  table = &assembly->tables[4];
  D.26079 = table->next_idx;
  D.26080 = D.26079;
  D.26081 = D.26080 + 1;
  table->next_idx = D.26081;
  D.26082 = (int) D.26080;
  fb->table_idx = D.26082;
  D.26083 = fb->table_idx;
  D.26084 = (void *) D.26083;
  D.26085 = fb->handle;
  D.26086 = assembly->field_to_table_idx;
  monoeg_g_hash_table_insert_replace (D.26086, D.26085, D.26084, 0);
  D.26087 = table->values;
  D.26083 = fb->table_idx;
  D.26088 = (unsigned int) D.26083;
  D.26089 = D.26088 * 12;
  values = D.26087 + D.26089;
  D.26090 = values + 4;
  D.26091 = fb->name;
  D.26092 = &assembly->sheap;
  D.26093 = string_heap_insert_mstring (D.26092, D.26091);
  *D.26090 = D.26093;
  D.26074 = fb->attrs;
  *values = D.26074;
  D.26094 = values + 8;
  D.26095 = field_encode_signature (assembly, fb);
  *D.26094 = D.26095;
  D.26096 = fb->offset;
  if (D.26096 != -1) goto <D.26097>; else goto <D.26098>;
  <D.26097>:
  table = &assembly->tables[16];
  D.26099 = table->rows;
  D.26100 = D.26099 + 1;
  table->rows = D.26100;
  D.26099 = table->rows;
  alloc_table (table, D.26099);
  D.26087 = table->values;
  D.26099 = table->rows;
  D.26101 = D.26099 * 8;
  values = D.26087 + D.26101;
  D.26090 = values + 4;
  D.26083 = fb->table_idx;
  D.26102 = (unsigned int) D.26083;
  *D.26090 = D.26102;
  D.26096 = fb->offset;
  D.26103 = (unsigned int) D.26096;
  *values = D.26103;
  <D.26098>:
  D.26074 = fb->attrs;
  D.26075 = D.26074 & 64;
  if (D.26075 != 0) goto <D.26104>; else goto <D.26105>;
  <D.26104>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.26099 = table->rows;
        D.26100 = D.26099 + 1;
        table->rows = D.26100;
        D.26099 = table->rows;
        alloc_table (table, D.26099);
        D.26087 = table->values;
        D.26099 = table->rows;
        D.26106 = D.26099 * 16;
        values = D.26087 + D.26106;
        D.26094 = values + 8;
        D.26083 = fb->table_idx;
        D.26107 = D.26083 << 2;
        D.26108 = (unsigned int) D.26107;
        *D.26094 = D.26108;
        D.26109 = values + 12;
        D.26110 = fb->def_value;
        D.26111 = encode_constant (assembly, D.26110, &field_type);
        *D.26109 = D.26111;
        field_type.120 = field_type;
        *values = field_type.120;
        D.26090 = values + 4;
        *D.26090 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.26105>:
  D.26074 = fb->attrs;
  D.26113 = D.26074 & 256;
  if (D.26113 != 0) goto <D.26114>; else goto <D.26115>;
  <D.26114>:
  {
    guint32 rva_idx;

    table = &assembly->tables[29];
    D.26099 = table->rows;
    D.26100 = D.26099 + 1;
    table->rows = D.26100;
    D.26099 = table->rows;
    alloc_table (table, D.26099);
    D.26087 = table->values;
    D.26099 = table->rows;
    D.26101 = D.26099 * 8;
    values = D.26087 + D.26101;
    D.26090 = values + 4;
    D.26083 = fb->table_idx;
    D.26102 = (unsigned int) D.26083;
    *D.26090 = D.26102;
    D.26116 = fb->rva_data;
    if (D.26116 != 0B) goto <D.26117>; else goto <D.26118>;
    <D.26117>:
    D.26116 = fb->rva_data;
    D.26119 = mono_array_length (D.26116);
    if (D.26119 > 9) goto <D.26120>; else goto <D.26121>;
    <D.26120>:
    D.26122 = &assembly->code;
    stream_data_align (D.26122);
    <D.26121>:
    D.26116 = fb->rva_data;
    D.26123 = mono_array_length (D.26116);
    D.26116 = fb->rva_data;
    D.26124 = mono_array_addr_with_size (D.26116, 1, 0);
    D.26122 = &assembly->code;
    rva_idx = mono_image_add_stream_data (D.26122, D.26124, D.26123);
    goto <D.26125>;
    <D.26118>:
    D.26085 = fb->handle;
    D.26126 = D.26085->parent;
    D.26127 = mono_class_value_size (D.26126, 0B);
    D.26128 = (unsigned int) D.26127;
    D.26122 = &assembly->code;
    rva_idx = mono_image_add_stream_zero (D.26122, D.26128);
    <D.26125>:
    D.26129 = assembly->text_rva;
    D.26130 = D.26129 + rva_idx;
    *values = D.26130;
  }
  <D.26115>:
  D.26131 = fb->marshal_info;
  if (D.26131 != 0B) goto <D.26132>; else goto <D.26133>;
  <D.26132>:
  table = &assembly->tables[13];
  D.26099 = table->rows;
  D.26100 = D.26099 + 1;
  table->rows = D.26100;
  D.26099 = table->rows;
  alloc_table (table, D.26099);
  D.26087 = table->values;
  D.26099 = table->rows;
  D.26101 = D.26099 * 8;
  values = D.26087 + D.26101;
  D.26083 = fb->table_idx;
  D.26134 = D.26083 << 1;
  D.26135 = (unsigned int) D.26134;
  *values = D.26135;
  D.26090 = values + 4;
  D.26131 = fb->marshal_info;
  D.26136 = encode_marshal_blob (assembly, D.26131);
  *D.26090 = D.26136;
  <D.26133>:
}


field_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoObject * D.26137;
  struct MonoArray * D.26138;
  struct MonoArray * D.26139;
  struct MonoGenericContainer * D.26140;
  struct MonoGenericInst * D.26145;
  guint32 D.26147;
  struct SigBuffer buf;
  guint32 idx;
  guint32 typespec;
  struct MonoType * type;
  struct MonoClass * class;

  try
    {
      typespec = 0;
      D.26137 = fb->type;
      init_type_builder_generics (D.26137);
      D.26137 = fb->type;
      type = mono_reflection_type_get_handle (D.26137);
      class = mono_class_from_mono_type (type);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.26138 = fb->modopt;
      D.26139 = fb->modreq;
      encode_custom_modifiers (assembly, D.26139, D.26138, &buf);
      D.26140 = class->generic_container;
      if (D.26140 != 0B) goto <D.26141>; else goto <D.26142>;
      <D.26141>:
      typespec = create_typespec (assembly, type);
      <D.26142>:
      if (typespec != 0) goto <D.26143>; else goto <D.26144>;
      <D.26143>:
      {
        struct MonoGenericClass * gclass;

        D.26140 = class->generic_container;
        D.26145 = D.26140->context.class_inst;
        gclass = mono_metadata_lookup_generic_class (class, D.26145, 1);
        encode_generic_class (assembly, gclass, &buf);
      }
      goto <D.26146>;
      <D.26144>:
      encode_type (assembly, type, &buf);
      <D.26146>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26147 = idx;
      return D.26147;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


init_type_builder_generics (struct MonoObject * type)
{
  struct MonoVTable * D.26150;
  struct MonoClass * D.26151;
  int D.26152;
  struct MonoGenericContainer * D.26157;
  struct MonoReflectionTypeBuilder * tb;

  D.26150 = type->vtable;
  D.26151 = D.26150->klass;
  D.26152 = is_sre_type_builder (D.26151);
  if (D.26152 == 0) goto <D.26153>; else goto <D.26154>;
  <D.26153>:
  return;
  <D.26154>:
  tb = type;
  if (tb != 0B) goto <D.26155>; else goto <D.26156>;
  <D.26155>:
  D.26157 = tb->generic_container;
  if (D.26157 != 0B) goto <D.26158>; else goto <D.26159>;
  <D.26158>:
  mono_reflection_create_generic_class (tb);
  <D.26159>:
  <D.26156>:
}


is_sre_type_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.121;
  gboolean D.26164;
  _Bool D.26165;
  int D.26166;
  int D.22224;
  int iftmp.122;
  int D.22220;
  const char[12] * D.26172;
  unsigned char D.26173;
  int D.26174;
  unsigned char D.26175;
  int D.26176;
  _Bool D.26177;
  _Bool D.26178;
  _Bool D.26179;
  const unsigned char * D.26182;
  unsigned char D.26183;
  int D.26184;
  const unsigned char * D.26185;
  unsigned char D.26186;
  int D.26187;
  _Bool D.26188;
  _Bool D.26189;
  const unsigned char * D.26192;
  unsigned char D.26193;
  int D.26194;
  const unsigned char * D.26195;
  unsigned char D.26196;
  int D.26197;
  _Bool D.26198;
  _Bool D.26199;
  const unsigned char * D.26202;
  unsigned char D.26203;
  int D.26204;
  const unsigned char * D.26205;
  unsigned char D.26206;
  int D.26207;
  const char * D.26209;
  int D.22233;
  int iftmp.123;
  int D.22229;
  const char[23] * D.26215;
  unsigned char D.26216;
  int D.26217;
  unsigned char D.26218;
  int D.26219;
  _Bool D.26220;
  _Bool D.26221;
  _Bool D.26222;
  const unsigned char * D.26225;
  unsigned char D.26226;
  int D.26227;
  const unsigned char * D.26228;
  unsigned char D.26229;
  int D.26230;
  _Bool D.26231;
  _Bool D.26232;
  const unsigned char * D.26235;
  unsigned char D.26236;
  int D.26237;
  const unsigned char * D.26238;
  unsigned char D.26239;
  int D.26240;
  _Bool D.26241;
  _Bool D.26242;
  const unsigned char * D.26245;
  unsigned char D.26246;
  int D.26247;
  const unsigned char * D.26248;
  unsigned char D.26249;
  int D.26250;
  const char * D.26252;

  {
    static struct MonoClass * cached_class;

    cached_class.121 = cached_class;
    if (cached_class.121 != 0B) goto <D.26162>; else goto <D.26163>;
    <D.26162>:
    cached_class.121 = cached_class;
    D.26165 = cached_class.121 == class;
    D.26164 = (gboolean) D.26165;
    return D.26164;
    <D.26163>:
    D.26166 = is_corlib_type (class);
    if (D.26166 != 0) goto <D.26167>; else goto <D.26168>;
    <D.26167>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.26172 = "TypeBuilder";
        D.26173 = MEM[(const unsigned char *)D.26172];
        D.26174 = (int) D.26173;
        D.26175 = *__s2;
        D.26176 = (int) D.26175;
        __result = D.26174 - D.26176;
        {
          D.26177 = __s1_len != 0;
          D.26178 = __result == 0;
          D.26179 = D.26177 & D.26178;
          if (D.26179 != 0) goto <D.26180>; else goto <D.26181>;
          <D.26180>:
          D.26182 = &MEM[(void *)"TypeBuilder" + 1B];
          D.26183 = *D.26182;
          D.26184 = (int) D.26183;
          D.26185 = __s2 + 1;
          D.26186 = *D.26185;
          D.26187 = (int) D.26186;
          __result = D.26184 - D.26187;
          D.26188 = __s1_len > 1;
          D.26178 = __result == 0;
          D.26189 = D.26188 & D.26178;
          if (D.26189 != 0) goto <D.26190>; else goto <D.26191>;
          <D.26190>:
          D.26192 = &MEM[(void *)"TypeBuilder" + 2B];
          D.26193 = *D.26192;
          D.26194 = (int) D.26193;
          D.26195 = __s2 + 2;
          D.26196 = *D.26195;
          D.26197 = (int) D.26196;
          __result = D.26194 - D.26197;
          D.26198 = __s1_len > 2;
          D.26178 = __result == 0;
          D.26199 = D.26198 & D.26178;
          if (D.26199 != 0) goto <D.26200>; else goto <D.26201>;
          <D.26200>:
          D.26202 = &MEM[(void *)"TypeBuilder" + 3B];
          D.26203 = *D.26202;
          D.26204 = (int) D.26203;
          D.26205 = __s2 + 3;
          D.26206 = *D.26205;
          D.26207 = (int) D.26206;
          __result = D.26204 - D.26207;
          <D.26201>:
          <D.26191>:
          <D.26181>:
        }
        D.22220 = __result;
      }
      iftmp.122 = D.22220;
      goto <D.26208>;
      <D.26171>:
      D.26209 = class->name;
      iftmp.122 = __builtin_strcmp ("TypeBuilder", D.26209);
      <D.26208>:
      D.22224 = iftmp.122;
    }
    if (D.22224 == 0) goto <D.26210>; else goto <D.26211>;
    <D.26210>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.26215 = "System.Reflection.Emit";
        D.26216 = MEM[(const unsigned char *)D.26215];
        D.26217 = (int) D.26216;
        D.26218 = *__s2;
        D.26219 = (int) D.26218;
        __result = D.26217 - D.26219;
        {
          D.26220 = __s1_len != 0;
          D.26221 = __result == 0;
          D.26222 = D.26220 & D.26221;
          if (D.26222 != 0) goto <D.26223>; else goto <D.26224>;
          <D.26223>:
          D.26225 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.26226 = *D.26225;
          D.26227 = (int) D.26226;
          D.26228 = __s2 + 1;
          D.26229 = *D.26228;
          D.26230 = (int) D.26229;
          __result = D.26227 - D.26230;
          D.26231 = __s1_len > 1;
          D.26221 = __result == 0;
          D.26232 = D.26231 & D.26221;
          if (D.26232 != 0) goto <D.26233>; else goto <D.26234>;
          <D.26233>:
          D.26235 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.26236 = *D.26235;
          D.26237 = (int) D.26236;
          D.26238 = __s2 + 2;
          D.26239 = *D.26238;
          D.26240 = (int) D.26239;
          __result = D.26237 - D.26240;
          D.26241 = __s1_len > 2;
          D.26221 = __result == 0;
          D.26242 = D.26241 & D.26221;
          if (D.26242 != 0) goto <D.26243>; else goto <D.26244>;
          <D.26243>:
          D.26245 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.26246 = *D.26245;
          D.26247 = (int) D.26246;
          D.26248 = __s2 + 3;
          D.26249 = *D.26248;
          D.26250 = (int) D.26249;
          __result = D.26247 - D.26250;
          <D.26244>:
          <D.26234>:
          <D.26224>:
        }
        D.22229 = __result;
      }
      iftmp.123 = D.22229;
      goto <D.26251>;
      <D.26214>:
      D.26252 = class->name_space;
      iftmp.123 = __builtin_strcmp ("System.Reflection.Emit", D.26252);
      <D.26251>:
      D.22233 = iftmp.123;
    }
    if (D.22233 == 0) goto <D.26253>; else goto <D.26254>;
    <D.26253>:
    cached_class = class;
    D.26164 = 1;
    return D.26164;
    <D.26254>:
    <D.26211>:
    <D.26168>:
    D.26164 = 0;
    return D.26164;
  }
}


is_corlib_type (struct MonoClass * class)
{
  gboolean D.26256;
  struct MonoImage * D.26257;
  struct MonoImage * D.26258;
  _Bool D.26259;

  D.26257 = class->image;
  D.26258 = mono_defaults.corlib;
  D.26259 = D.26257 == D.26258;
  D.26256 = (gboolean) D.26259;
  return D.26256;
}


mono_image_add_stream_zero (struct MonoDynamicStream * stream, guint32 len)
{
  unsigned int D.26261;
  unsigned int D.26262;
  int D.26263;
  char * D.26264;
  void * D.26265;
  guint32 D.26266;
  guint32 idx;

  D.26261 = stream->index;
  D.26262 = D.26261 + len;
  D.26263 = (int) D.26262;
  make_room_in_stream (stream, D.26263);
  D.26264 = stream->data;
  D.26261 = stream->index;
  D.26265 = D.26264 + D.26261;
  memset (D.26265, 0, len);
  idx = stream->index;
  D.26261 = stream->index;
  D.26262 = D.26261 + len;
  stream->index = D.26262;
  D.26266 = idx;
  return D.26266;
}


mono_image_fill_module_table (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26268;
  unsigned int D.26269;
  unsigned int D.26270;
  guint32 * D.26271;
  unsigned int D.26272;
  unsigned int D.26273;
  sizetype D.26274;
  guint32 * D.26275;
  struct MonoString * D.26276;
  struct MonoDynamicStream * D.26277;
  unsigned int D.26278;
  struct MonoArray * D.26279;
  char * D.26280;
  struct MonoDynamicStream * D.26281;
  unsigned int D.26282;
  guint32 * D.26283;
  sizetype D.26284;
  guint32 * D.26285;
  unsigned int i.124;
  sizetype D.26287;
  guint32 * D.26288;
  sizetype D.26289;
  guint32 * D.26290;
  struct MonoDynamicTable * table;
  int i;

  table = &assembly->tables[0];
  D.26268 = table->next_idx;
  D.26269 = D.26268;
  D.26270 = D.26269 + 1;
  table->next_idx = D.26270;
  mb->table_idx = D.26269;
  D.26271 = table->values;
  D.26272 = mb->table_idx;
  D.26273 = D.26272 * 20;
  D.26274 = D.26273 + 4;
  D.26275 = D.26271 + D.26274;
  D.26276 = mb->module.name;
  D.26277 = &assembly->sheap;
  D.26278 = string_heap_insert_mstring (D.26277, D.26276);
  *D.26275 = D.26278;
  D.26279 = mb->guid;
  D.26280 = mono_array_addr_with_size (D.26279, 1, 0);
  D.26281 = &assembly->guid;
  D.26282 = mono_image_add_stream_data (D.26281, D.26280, 16);
  i = (int) D.26282;
  i = i / 16;
  i = i + 1;
  D.26271 = table->values;
  D.26272 = mb->table_idx;
  D.26273 = D.26272 * 20;
  D.26283 = D.26271 + D.26273;
  *D.26283 = 0;
  D.26271 = table->values;
  D.26272 = mb->table_idx;
  D.26273 = D.26272 * 20;
  D.26284 = D.26273 + 8;
  D.26285 = D.26271 + D.26284;
  i.124 = (unsigned int) i;
  *D.26285 = i.124;
  D.26271 = table->values;
  D.26272 = mb->table_idx;
  D.26273 = D.26272 * 20;
  D.26287 = D.26273 + 12;
  D.26288 = D.26271 + D.26287;
  *D.26288 = 0;
  D.26271 = table->values;
  D.26272 = mb->table_idx;
  D.26273 = D.26272 * 20;
  D.26289 = D.26273 + 16;
  D.26290 = D.26271 + D.26289;
  *D.26290 = 0;
}


collect_types (struct MonoPtrArray * types, struct MonoReflectionTypeBuilder * type)
{
  int D.26291;
  int D.26292;
  int D.26295;
  void * D.26296;
  unsigned int D.26297;
  unsigned int D.26298;
  unsigned int D.26299;
  void * * D.26300;
  int D.26303;
  int D.26304;
  unsigned int D.26305;
  unsigned int D.26306;
  void * * D.26307;
  struct MonoArray * D.26308;
  unsigned int i.125;
  char * D.26312;
  unsigned int D.26313;
  int i;

  D.26291 = types->size;
  D.26292 = types->capacity;
  if (D.26291 >= D.26292) goto <D.26293>; else goto <D.26294>;
  <D.26293>:
  {
    void * __tmp;

    D.26292 = types->capacity;
    D.26295 = D.26292 * 2;
    D.26296 = mono_gc_make_root_descr_all_refs (D.26295);
    D.26292 = types->capacity;
    D.26297 = (unsigned int) D.26292;
    D.26298 = D.26297 * 8;
    __tmp = mono_gc_alloc_fixed (D.26298, D.26296);
    D.26292 = types->capacity;
    D.26297 = (unsigned int) D.26292;
    D.26299 = D.26297 * 4;
    D.26300 = types->data;
    mono_gc_memmove_aligned (__tmp, D.26300, D.26299);
    D.26292 = types->capacity;
    if (D.26292 > 16) goto <D.26301>; else goto <D.26302>;
    <D.26301>:
    D.26300 = types->data;
    mono_gc_free_fixed (D.26300);
    <D.26302>:
    types->data = __tmp;
    D.26292 = types->capacity;
    D.26295 = D.26292 * 2;
    types->capacity = D.26295;
  }
  <D.26294>:
  D.26300 = types->data;
  D.26291 = types->size;
  D.26303 = D.26291;
  D.26304 = D.26303 + 1;
  types->size = D.26304;
  D.26305 = (unsigned int) D.26303;
  D.26306 = D.26305 * 4;
  D.26307 = D.26300 + D.26306;
  *D.26307 = type;
  D.26308 = type->subtypes;
  if (D.26308 == 0B) goto <D.26309>; else goto <D.26310>;
  <D.26309>:
  return;
  <D.26310>:
  i = 0;
  goto <D.19417>;
  <D.19416>:
  {
    struct MonoReflectionTypeBuilder * subtype;

    i.125 = (unsigned int) i;
    D.26308 = type->subtypes;
    D.26312 = mono_array_addr_with_size (D.26308, 4, i.125);
    subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.26312];
    collect_types (types, subtype);
  }
  i = i + 1;
  <D.19417>:
  i.125 = (unsigned int) i;
  D.26308 = type->subtypes;
  D.26313 = mono_array_length (D.26308);
  if (i.125 < D.26313) goto <D.19416>; else goto <D.19418>;
  <D.19418>:
}


alloc_table (struct MonoDynamicTable * table, guint nrows)
{
  unsigned char D.26315;
  _Bool D.26316;
  long int D.26317;
  long int D.26318;
  unsigned int D.26321;
  unsigned int D.26322;
  unsigned int D.26328;
  unsigned int D.26329;
  unsigned int D.26330;
  unsigned int D.26331;
  guint32 * D.26332;
  void * D.26333;

  table->rows = nrows;
  D.26315 = table->columns;
  D.26316 = D.26315 == 0;
  D.26317 = (long int) D.26316;
  D.26318 = __builtin_expect (D.26317, 0);
  if (D.26318 != 0) goto <D.26319>; else goto <D.26320>;
  <D.26319>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 327, "table->columns");
  <D.26320>:
  D.26321 = nrows + 1;
  D.26322 = table->alloc_rows;
  if (D.26321 >= D.26322) goto <D.26323>; else goto <D.26324>;
  <D.26323>:
  goto <D.18338>;
  <D.18337>:
  D.26322 = table->alloc_rows;
  if (D.26322 == 0) goto <D.26325>; else goto <D.26326>;
  <D.26325>:
  table->alloc_rows = 16;
  goto <D.26327>;
  <D.26326>:
  D.26322 = table->alloc_rows;
  D.26328 = D.26322 * 2;
  table->alloc_rows = D.26328;
  <D.26327>:
  <D.18338>:
  D.26321 = nrows + 1;
  D.26322 = table->alloc_rows;
  if (D.26321 >= D.26322) goto <D.18337>; else goto <D.18339>;
  <D.18339>:
  D.26322 = table->alloc_rows;
  D.26315 = table->columns;
  D.26329 = (unsigned int) D.26315;
  D.26330 = D.26322 * D.26329;
  D.26331 = D.26330 * 4;
  D.26332 = table->values;
  D.26333 = monoeg_realloc (D.26332, D.26331);
  table->values = D.26333;
  <D.26324>:
}


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

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


mono_image_get_type_info (struct MonoDomain * domain, struct MonoReflectionTypeBuilder * tb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26336;
  unsigned int D.26337;
  unsigned int D.26338;
  unsigned int D.26339;
  struct MonoString * D.26340;
  int D.19371;
  int iftmp.126;
  int D.19370;
  const char[7] * D.26344;
  unsigned char D.26345;
  int D.26346;
  unsigned char D.26347;
  int D.26348;
  _Bool D.26349;
  _Bool D.26350;
  _Bool D.26351;
  const unsigned char * D.26354;
  unsigned char D.26355;
  int D.26356;
  const unsigned char * D.26357;
  unsigned char D.26358;
  int D.26359;
  _Bool D.26360;
  _Bool D.26361;
  const unsigned char * D.26364;
  unsigned char D.26365;
  int D.26366;
  const unsigned char * D.26367;
  unsigned char D.26368;
  int D.26369;
  _Bool D.26370;
  _Bool D.26371;
  const unsigned char * D.26374;
  unsigned char D.26375;
  int D.26376;
  const unsigned char * D.26377;
  unsigned char D.26378;
  int D.26379;
  guint * D.26383;
  struct MonoDynamicStream * D.26384;
  unsigned int D.26385;
  struct MonoString * D.26386;
  int D.19380;
  int iftmp.127;
  int D.19379;
  const char[7] * D.26390;
  unsigned char D.26391;
  int D.26392;
  unsigned char D.26393;
  int D.26394;
  _Bool D.26395;
  _Bool D.26396;
  _Bool D.26397;
  const unsigned char * D.26400;
  unsigned char D.26401;
  int D.26402;
  const unsigned char * D.26403;
  unsigned char D.26404;
  int D.26405;
  _Bool D.26406;
  _Bool D.26407;
  const unsigned char * D.26410;
  unsigned char D.26411;
  int D.26412;
  const unsigned char * D.26413;
  unsigned char D.26414;
  int D.26415;
  _Bool D.26416;
  _Bool D.26417;
  const unsigned char * D.26420;
  unsigned char D.26421;
  int D.26422;
  const unsigned char * D.26423;
  unsigned char D.26424;
  int D.26425;
  guint * D.26429;
  unsigned int D.26430;
  struct MonoObject * D.26433;
  _Bool D.26435;
  _Bool D.26436;
  _Bool D.26437;
  unsigned int D.26439;
  guint * D.26441;
  struct MonoType * D.26442;
  unsigned int D.26443;
  guint * D.26444;
  unsigned int D.26445;
  guint * D.26446;
  unsigned int D.26447;
  unsigned int D.26450;
  int D.26453;
  int D.26455;
  unsigned int D.26456;
  unsigned int D.26457;
  unsigned int D.26458;
  unsigned int D.26459;
  unsigned int D.26460;
  struct MonoArray * D.26461;
  unsigned int D.26464;
  unsigned int D.26465;
  int D.26466;
  unsigned int D.26467;
  unsigned int D.26468;
  unsigned int i.128;
  char * D.26470;
  struct MonoType * D.26471;
  unsigned int D.26472;
  unsigned int D.26473;
  struct MonoArray * D.26474;
  int D.26477;
  unsigned int D.26478;
  unsigned int D.26479;
  char * D.26480;
  struct MonoReflectionFieldBuilder * D.26481;
  struct MonoArray * D.26482;
  unsigned int D.26485;
  unsigned int D.26486;
  char * D.26487;
  struct MonoReflectionCtorBuilder * D.26488;
  unsigned int D.26489;
  struct MonoArray * D.26490;
  int D.26493;
  unsigned int D.26494;
  unsigned int D.26495;
  char * D.26496;
  struct MonoReflectionMethodBuilder * D.26497;
  struct MonoArray * D.26498;
  unsigned int D.26501;
  unsigned int D.26504;
  unsigned int D.26505;
  unsigned int D.26506;
  unsigned int D.26507;
  char * D.26508;
  struct MonoReflectionEventBuilder * D.26509;
  unsigned int D.26510;
  struct MonoArray * D.26511;
  unsigned int D.26514;
  unsigned int D.26517;
  unsigned int D.26518;
  unsigned int D.26519;
  char * D.26520;
  struct MonoReflectionPropertyBuilder * D.26521;
  unsigned int D.26522;
  struct MonoArray * D.26523;
  unsigned int D.26526;
  unsigned int D.26527;
  char * D.26528;
  struct MonoReflectionGenericParam * D.26529;
  unsigned int D.26530;
  struct MonoArray * D.26531;
  unsigned int D.26532;
  struct MonoArray * D.26533;
  unsigned int D.26536;
  unsigned int D.26537;
  unsigned int D.26538;
  guint32 * D.26539;
  unsigned int D.26540;
  unsigned int D.26541;
  char * D.26542;
  unsigned int D.26543;
  unsigned int D.26544;
  unsigned int D.26545;
  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.26336 = table->values;
  D.26337 = tb->table_idx;
  D.26338 = D.26337 * 24;
  values = D.26336 + D.26338;
  D.26339 = tb->attrs;
  *values = D.26339;
  D.26340 = tb->name;
  n = mono_string_to_utf8 (D.26340);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26344 = "Object";
      D.26345 = MEM[(const unsigned char *)D.26344];
      D.26346 = (int) D.26345;
      D.26347 = *__s2;
      D.26348 = (int) D.26347;
      __result = D.26346 - D.26348;
      {
        D.26349 = __s2_len != 0;
        D.26350 = __result == 0;
        D.26351 = D.26349 & D.26350;
        if (D.26351 != 0) goto <D.26352>; else goto <D.26353>;
        <D.26352>:
        D.26354 = &MEM[(void *)"Object" + 1B];
        D.26355 = *D.26354;
        D.26356 = (int) D.26355;
        D.26357 = __s2 + 1;
        D.26358 = *D.26357;
        D.26359 = (int) D.26358;
        __result = D.26356 - D.26359;
        D.26360 = __s2_len > 1;
        D.26350 = __result == 0;
        D.26361 = D.26360 & D.26350;
        if (D.26361 != 0) goto <D.26362>; else goto <D.26363>;
        <D.26362>:
        D.26364 = &MEM[(void *)"Object" + 2B];
        D.26365 = *D.26364;
        D.26366 = (int) D.26365;
        D.26367 = __s2 + 2;
        D.26368 = *D.26367;
        D.26369 = (int) D.26368;
        __result = D.26366 - D.26369;
        D.26370 = __s2_len > 2;
        D.26350 = __result == 0;
        D.26371 = D.26370 & D.26350;
        if (D.26371 != 0) goto <D.26372>; else goto <D.26373>;
        <D.26372>:
        D.26374 = &MEM[(void *)"Object" + 3B];
        D.26375 = *D.26374;
        D.26376 = (int) D.26375;
        D.26377 = __s2 + 3;
        D.26378 = *D.26377;
        D.26379 = (int) D.26378;
        __result = D.26376 - D.26379;
        <D.26373>:
        <D.26363>:
        <D.26353>:
      }
      D.19370 = __result;
    }
    iftmp.126 = -D.19370;
    goto <D.26380>;
    <D.26343>:
    iftmp.126 = __builtin_strcmp (n, "Object");
    <D.26380>:
    D.19371 = iftmp.126;
  }
  if (D.19371 == 0) goto <D.26381>; else goto <D.26382>;
  <D.26381>:
  is_object = is_object + 1;
  <D.26382>:
  D.26383 = values + 4;
  D.26384 = &assembly->sheap;
  D.26385 = string_heap_insert (D.26384, n);
  *D.26383 = D.26385;
  monoeg_g_free (n);
  D.26386 = tb->nspace;
  n = mono_string_to_utf8 (D.26386);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26390 = "System";
      D.26391 = MEM[(const unsigned char *)D.26390];
      D.26392 = (int) D.26391;
      D.26393 = *__s2;
      D.26394 = (int) D.26393;
      __result = D.26392 - D.26394;
      {
        D.26395 = __s2_len != 0;
        D.26396 = __result == 0;
        D.26397 = D.26395 & D.26396;
        if (D.26397 != 0) goto <D.26398>; else goto <D.26399>;
        <D.26398>:
        D.26400 = &MEM[(void *)"System" + 1B];
        D.26401 = *D.26400;
        D.26402 = (int) D.26401;
        D.26403 = __s2 + 1;
        D.26404 = *D.26403;
        D.26405 = (int) D.26404;
        __result = D.26402 - D.26405;
        D.26406 = __s2_len > 1;
        D.26396 = __result == 0;
        D.26407 = D.26406 & D.26396;
        if (D.26407 != 0) goto <D.26408>; else goto <D.26409>;
        <D.26408>:
        D.26410 = &MEM[(void *)"System" + 2B];
        D.26411 = *D.26410;
        D.26412 = (int) D.26411;
        D.26413 = __s2 + 2;
        D.26414 = *D.26413;
        D.26415 = (int) D.26414;
        __result = D.26412 - D.26415;
        D.26416 = __s2_len > 2;
        D.26396 = __result == 0;
        D.26417 = D.26416 & D.26396;
        if (D.26417 != 0) goto <D.26418>; else goto <D.26419>;
        <D.26418>:
        D.26420 = &MEM[(void *)"System" + 3B];
        D.26421 = *D.26420;
        D.26422 = (int) D.26421;
        D.26423 = __s2 + 3;
        D.26424 = *D.26423;
        D.26425 = (int) D.26424;
        __result = D.26422 - D.26425;
        <D.26419>:
        <D.26409>:
        <D.26399>:
      }
      D.19379 = __result;
    }
    iftmp.127 = -D.19379;
    goto <D.26426>;
    <D.26389>:
    iftmp.127 = __builtin_strcmp (n, "System");
    <D.26426>:
    D.19380 = iftmp.127;
  }
  if (D.19380 == 0) goto <D.26427>; else goto <D.26428>;
  <D.26427>:
  is_system = is_system + 1;
  <D.26428>:
  D.26429 = values + 8;
  D.26384 = &assembly->sheap;
  D.26430 = string_heap_insert (D.26384, n);
  *D.26429 = D.26430;
  monoeg_g_free (n);
  D.26433 = tb->parent;
  if (D.26433 != 0B) goto <D.26434>; else goto <D.26431>;
  <D.26434>:
  D.26435 = is_system == 0;
  D.26436 = is_object == 0;
  D.26437 = D.26435 | D.26436;
  if (D.26437 != 0) goto <D.26438>; else goto <D.26431>;
  <D.26438>:
  D.26339 = tb->attrs;
  D.26439 = D.26339 & 32;
  if (D.26439 == 0) goto <D.26440>; else goto <D.26431>;
  <D.26440>:
  D.26441 = values + 12;
  D.26433 = tb->parent;
  D.26442 = mono_reflection_type_get_handle (D.26433);
  D.26443 = mono_image_typedef_or_ref (assembly, D.26442);
  *D.26441 = D.26443;
  goto <D.26432>;
  <D.26431>:
  D.26441 = values + 12;
  *D.26441 = 0;
  <D.26432>:
  D.26444 = values + 16;
  D.26445 = assembly->tables[4].next_idx;
  *D.26444 = D.26445;
  D.26446 = values + 20;
  D.26447 = assembly->tables[6].next_idx;
  *D.26446 = D.26447;
  D.26339 = tb->attrs;
  D.26450 = D.26339 & 24;
  if (D.26450 != 0) goto <D.26451>; else goto <D.26452>;
  <D.26451>:
  D.26453 = tb->class_size;
  if (D.26453 > 0) goto <D.26448>; else goto <D.26454>;
  <D.26454>:
  D.26455 = tb->packing_size;
  if (D.26455 > 0) goto <D.26448>; else goto <D.26449>;
  <D.26448>:
  table = &assembly->tables[15];
  D.26456 = table->rows;
  D.26457 = D.26456 + 1;
  table->rows = D.26457;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  D.26336 = table->values;
  D.26456 = table->rows;
  D.26458 = D.26456 * 12;
  values = D.26336 + D.26458;
  D.26429 = values + 8;
  D.26337 = tb->table_idx;
  *D.26429 = D.26337;
  D.26383 = values + 4;
  D.26453 = tb->class_size;
  D.26459 = (unsigned int) D.26453;
  *D.26383 = D.26459;
  D.26455 = tb->packing_size;
  D.26460 = (unsigned int) D.26455;
  *values = D.26460;
  <D.26449>:
  <D.26452>:
  D.26461 = tb->interfaces;
  if (D.26461 != 0B) goto <D.26462>; else goto <D.26463>;
  <D.26462>:
  table = &assembly->tables[9];
  D.26456 = table->rows;
  i = (int) D.26456;
  D.26461 = tb->interfaces;
  D.26464 = mono_array_length (D.26461);
  D.26456 = table->rows;
  D.26465 = D.26456 + D.26464;
  table->rows = D.26465;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  D.26336 = table->values;
  D.26466 = i + 1;
  D.26467 = (unsigned int) D.26466;
  D.26468 = D.26467 * 8;
  values = D.26336 + D.26468;
  i = 0;
  goto <D.19383>;
  <D.19382>:
  {
    struct MonoReflectionType * iface;

    i.128 = (unsigned int) i;
    D.26461 = tb->interfaces;
    D.26470 = mono_array_addr_with_size (D.26461, 4, i.128);
    iface = MEM[(void * *)D.26470];
    D.26337 = tb->table_idx;
    *values = D.26337;
    D.26383 = values + 4;
    D.26471 = mono_reflection_type_get_handle (iface);
    D.26472 = mono_image_typedef_or_ref (assembly, D.26471);
    *D.26383 = D.26472;
    values = values + 8;
  }
  i = i + 1;
  <D.19383>:
  i.128 = (unsigned int) i;
  D.26461 = tb->interfaces;
  D.26473 = mono_array_length (D.26461);
  if (i.128 < D.26473) goto <D.19382>; else goto <D.19384>;
  <D.19384>:
  <D.26463>:
  D.26474 = tb->fields;
  if (D.26474 != 0B) goto <D.26475>; else goto <D.26476>;
  <D.26475>:
  table = &assembly->tables[4];
  D.26456 = table->rows;
  D.26477 = tb->num_fields;
  D.26478 = (unsigned int) D.26477;
  D.26479 = D.26456 + D.26478;
  table->rows = D.26479;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  i = 0;
  goto <D.19386>;
  <D.19385>:
  i.128 = (unsigned int) i;
  D.26474 = tb->fields;
  D.26480 = mono_array_addr_with_size (D.26474, 4, i.128);
  D.26481 = MEM[(struct MonoReflectionFieldBuilder * *)D.26480];
  mono_image_get_field_info (D.26481, assembly);
  i = i + 1;
  <D.19386>:
  D.26477 = tb->num_fields;
  if (D.26477 > i) goto <D.19385>; else goto <D.19387>;
  <D.19387>:
  <D.26476>:
  D.26482 = tb->ctors;
  if (D.26482 != 0B) goto <D.26483>; else goto <D.26484>;
  <D.26483>:
  table = &assembly->tables[6];
  D.26482 = tb->ctors;
  D.26485 = mono_array_length (D.26482);
  D.26456 = table->rows;
  D.26486 = D.26456 + D.26485;
  table->rows = D.26486;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  i = 0;
  goto <D.19389>;
  <D.19388>:
  i.128 = (unsigned int) i;
  D.26482 = tb->ctors;
  D.26487 = mono_array_addr_with_size (D.26482, 4, i.128);
  D.26488 = MEM[(struct MonoReflectionCtorBuilder * *)D.26487];
  mono_image_get_ctor_info (domain, D.26488, assembly);
  i = i + 1;
  <D.19389>:
  i.128 = (unsigned int) i;
  D.26482 = tb->ctors;
  D.26489 = mono_array_length (D.26482);
  if (i.128 < D.26489) goto <D.19388>; else goto <D.19390>;
  <D.19390>:
  <D.26484>:
  D.26490 = tb->methods;
  if (D.26490 != 0B) goto <D.26491>; else goto <D.26492>;
  <D.26491>:
  table = &assembly->tables[6];
  D.26456 = table->rows;
  D.26493 = tb->num_methods;
  D.26494 = (unsigned int) D.26493;
  D.26495 = D.26456 + D.26494;
  table->rows = D.26495;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  i = 0;
  goto <D.19392>;
  <D.19391>:
  i.128 = (unsigned int) i;
  D.26490 = tb->methods;
  D.26496 = mono_array_addr_with_size (D.26490, 4, i.128);
  D.26497 = MEM[(struct MonoReflectionMethodBuilder * *)D.26496];
  mono_image_get_method_info (D.26497, assembly);
  i = i + 1;
  <D.19392>:
  D.26493 = tb->num_methods;
  if (D.26493 > i) goto <D.19391>; else goto <D.19393>;
  <D.19393>:
  <D.26492>:
  D.26498 = tb->events;
  if (D.26498 != 0B) goto <D.26499>; else goto <D.26500>;
  <D.26499>:
  D.26498 = tb->events;
  D.26501 = mono_array_length (D.26498);
  if (D.26501 != 0) goto <D.26502>; else goto <D.26503>;
  <D.26502>:
  table = &assembly->tables[20];
  D.26498 = tb->events;
  D.26504 = mono_array_length (D.26498);
  D.26456 = table->rows;
  D.26505 = D.26456 + D.26504;
  table->rows = D.26505;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  table = &assembly->tables[18];
  D.26456 = table->rows;
  D.26457 = D.26456 + 1;
  table->rows = D.26457;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  D.26336 = table->values;
  D.26456 = table->rows;
  D.26506 = D.26456 * 8;
  values = D.26336 + D.26506;
  D.26337 = tb->table_idx;
  *values = D.26337;
  D.26383 = values + 4;
  D.26507 = assembly->tables[20].next_idx;
  *D.26383 = D.26507;
  i = 0;
  goto <D.19395>;
  <D.19394>:
  i.128 = (unsigned int) i;
  D.26498 = tb->events;
  D.26508 = mono_array_addr_with_size (D.26498, 4, i.128);
  D.26509 = MEM[(struct MonoReflectionEventBuilder * *)D.26508];
  mono_image_get_event_info (D.26509, assembly);
  i = i + 1;
  <D.19395>:
  i.128 = (unsigned int) i;
  D.26498 = tb->events;
  D.26510 = mono_array_length (D.26498);
  if (i.128 < D.26510) goto <D.19394>; else goto <D.19396>;
  <D.19396>:
  <D.26503>:
  <D.26500>:
  D.26511 = tb->properties;
  if (D.26511 != 0B) goto <D.26512>; else goto <D.26513>;
  <D.26512>:
  D.26511 = tb->properties;
  D.26514 = mono_array_length (D.26511);
  if (D.26514 != 0) goto <D.26515>; else goto <D.26516>;
  <D.26515>:
  table = &assembly->tables[23];
  D.26511 = tb->properties;
  D.26517 = mono_array_length (D.26511);
  D.26456 = table->rows;
  D.26518 = D.26456 + D.26517;
  table->rows = D.26518;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  table = &assembly->tables[21];
  D.26456 = table->rows;
  D.26457 = D.26456 + 1;
  table->rows = D.26457;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  D.26336 = table->values;
  D.26456 = table->rows;
  D.26506 = D.26456 * 8;
  values = D.26336 + D.26506;
  D.26337 = tb->table_idx;
  *values = D.26337;
  D.26383 = values + 4;
  D.26519 = assembly->tables[23].next_idx;
  *D.26383 = D.26519;
  i = 0;
  goto <D.19398>;
  <D.19397>:
  i.128 = (unsigned int) i;
  D.26511 = tb->properties;
  D.26520 = mono_array_addr_with_size (D.26511, 4, i.128);
  D.26521 = MEM[(struct MonoReflectionPropertyBuilder * *)D.26520];
  mono_image_get_property_info (D.26521, assembly);
  i = i + 1;
  <D.19398>:
  i.128 = (unsigned int) i;
  D.26511 = tb->properties;
  D.26522 = mono_array_length (D.26511);
  if (i.128 < D.26522) goto <D.19397>; else goto <D.19399>;
  <D.19399>:
  <D.26516>:
  <D.26513>:
  D.26523 = tb->generic_params;
  if (D.26523 != 0B) goto <D.26524>; else goto <D.26525>;
  <D.26524>:
  table = &assembly->tables[42];
  D.26523 = tb->generic_params;
  D.26526 = mono_array_length (D.26523);
  D.26456 = table->rows;
  D.26527 = D.26456 + D.26526;
  table->rows = D.26527;
  D.26456 = table->rows;
  alloc_table (table, D.26456);
  i = 0;
  goto <D.19402>;
  <D.19401>:
  {
    guint32 owner;

    D.26337 = tb->table_idx;
    owner = D.26337 << 1;
    i.128 = (unsigned int) i;
    D.26523 = tb->generic_params;
    D.26528 = mono_array_addr_with_size (D.26523, 4, i.128);
    D.26529 = MEM[(struct MonoReflectionGenericParam * *)D.26528];
    mono_image_get_generic_param_info (D.26529, owner, assembly);
  }
  i = i + 1;
  <D.19402>:
  i.128 = (unsigned int) i;
  D.26523 = tb->generic_params;
  D.26530 = mono_array_length (D.26523);
  if (i.128 < D.26530) goto <D.19401>; else goto <D.19403>;
  <D.19403>:
  <D.26525>:
  D.26531 = tb->permissions;
  D.26337 = tb->table_idx;
  D.26532 = D.26337 | 33554432;
  mono_image_add_decl_security (assembly, D.26532, D.26531);
  D.26533 = tb->subtypes;
  if (D.26533 != 0B) goto <D.26534>; else goto <D.26535>;
  <D.26534>:
  {
    struct MonoDynamicTable * ntable;

    ntable = &assembly->tables[41];
    D.26533 = tb->subtypes;
    D.26536 = mono_array_length (D.26533);
    D.26537 = ntable->rows;
    D.26538 = D.26537 + D.26536;
    ntable->rows = D.26538;
    D.26537 = ntable->rows;
    alloc_table (ntable, D.26537);
    D.26539 = ntable->values;
    D.26540 = ntable->next_idx;
    D.26541 = D.26540 * 8;
    values = D.26539 + D.26541;
    i = 0;
    goto <D.19407>;
    <D.19406>:
    {
      struct MonoReflectionTypeBuilder * subtype;

      i.128 = (unsigned int) i;
      D.26533 = tb->subtypes;
      D.26542 = mono_array_addr_with_size (D.26533, 4, i.128);
      subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.26542];
      D.26543 = subtype->table_idx;
      *values = D.26543;
      D.26383 = values + 4;
      D.26337 = tb->table_idx;
      *D.26383 = D.26337;
      values = values + 8;
      D.26540 = ntable->next_idx;
      D.26544 = D.26540 + 1;
      ntable->next_idx = D.26544;
    }
    i = i + 1;
    <D.19407>:
    i.128 = (unsigned int) i;
    D.26533 = tb->subtypes;
    D.26545 = mono_array_length (D.26533);
    if (i.128 < D.26545) goto <D.19406>; else goto <D.19408>;
    <D.19408>:
  }
  <D.26535>:
}


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

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


reflection_methodbuilder_from_ctor_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionCtorBuilder * mb)
{
  const char * iftmp.129;
  unsigned int D.26549;
  unsigned int D.26550;
  struct MonoReflectionILGen * D.26554;
  struct MonoClass * D.26555;
  struct MonoType * D.26556;
  struct MonoDomain * D.26557;
  struct MonoReflectionType * D.26558;
  struct MonoArray * D.26559;
  struct MonoArray * D.26560;
  unsigned int D.26561;
  unsigned int D.26562;
  struct MonoObject * D.26563;
  struct MonoDomain * D.26564;
  struct MonoString * D.26565;
  guint32 * D.26566;
  unsigned char D.26567;
  struct MonoArray * D.26568;
  struct MonoArray * D.26569;
  struct MonoArray * D.26570;
  struct MonoMethod * D.26571;
  const char * name;

  D.26549 = mb->attrs;
  D.26550 = D.26549 & 16;
  if (D.26550 != 0) goto <D.26551>; else goto <D.26552>;
  <D.26551>:
  iftmp.129 = ".cctor";
  goto <D.26553>;
  <D.26552>:
  iftmp.129 = ".ctor";
  <D.26553>:
  name = iftmp.129;
  memset (rmb, 0, 112);
  D.26554 = mb->ilgen;
  rmb->ilgen = D.26554;
  D.26555 = mono_defaults.void_class;
  D.26556 = &D.26555->byval_arg;
  D.26557 = mono_domain_get ();
  D.26558 = mono_type_get_object (D.26557, D.26556);
  rmb->rtype = D.26558;
  D.26559 = mb->parameters;
  rmb->parameters = D.26559;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  D.26560 = mb->pinfo;
  rmb->pinfo = D.26560;
  D.26549 = mb->attrs;
  rmb->attrs = D.26549;
  D.26561 = mb->iattrs;
  rmb->iattrs = D.26561;
  D.26562 = mb->call_conv;
  rmb->call_conv = D.26562;
  rmb->code = 0B;
  D.26563 = mb->type;
  rmb->type = D.26563;
  D.26564 = mono_domain_get ();
  D.26565 = mono_string_new (D.26564, name);
  rmb->name = D.26565;
  D.26566 = &mb->table_idx;
  rmb->table_idx = D.26566;
  D.26567 = mb->init_locals;
  rmb->init_locals = D.26567;
  rmb->skip_visibility = 0;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  D.26568 = mb->param_modreq;
  rmb->param_modreq = D.26568;
  D.26569 = mb->param_modopt;
  rmb->param_modopt = D.26569;
  D.26570 = mb->permissions;
  rmb->permissions = D.26570;
  D.26571 = mb->mhandle;
  rmb->mhandle = D.26571;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


mono_image_get_event_info (struct MonoReflectionEventBuilder * eb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26572;
  unsigned int D.26573;
  unsigned int D.26574;
  guint32 * D.26575;
  unsigned int D.26576;
  unsigned int D.26577;
  guint32 * D.26578;
  struct MonoString * D.26579;
  struct MonoDynamicStream * D.26580;
  unsigned int D.26581;
  unsigned int D.26582;
  guint32 * D.26583;
  struct MonoReflectionType * D.26584;
  struct MonoType * D.26585;
  unsigned int D.26586;
  struct MonoReflectionMethodBuilder * D.26587;
  struct MonoReflectionMethodBuilder * D.26590;
  struct MonoReflectionMethodBuilder * D.26593;
  unsigned int D.26596;
  unsigned int D.26597;
  unsigned int semaidx.130;
  unsigned int D.26601;
  unsigned int D.26602;
  unsigned int D.26603;
  unsigned int D.26604;
  unsigned int semaidx.131;
  unsigned int D.26608;
  unsigned int D.26609;
  unsigned int semaidx.132;
  unsigned int D.26613;
  unsigned int D.26614;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[20];
  D.26572 = table->next_idx;
  D.26573 = D.26572;
  D.26574 = D.26573 + 1;
  table->next_idx = D.26574;
  eb->table_idx = D.26573;
  D.26575 = table->values;
  D.26576 = eb->table_idx;
  D.26577 = D.26576 * 12;
  values = D.26575 + D.26577;
  D.26578 = values + 4;
  D.26579 = eb->name;
  D.26580 = &assembly->sheap;
  D.26581 = string_heap_insert_mstring (D.26580, D.26579);
  *D.26578 = D.26581;
  D.26582 = eb->attrs;
  *values = D.26582;
  D.26583 = values + 8;
  D.26584 = eb->type;
  D.26585 = mono_reflection_type_get_handle (D.26584);
  D.26586 = mono_image_typedef_or_ref (assembly, D.26585);
  *D.26583 = D.26586;
  D.26587 = eb->add_method;
  if (D.26587 != 0B) goto <D.26588>; else goto <D.26589>;
  <D.26588>:
  num_methods = num_methods + 1;
  <D.26589>:
  D.26590 = eb->remove_method;
  if (D.26590 != 0B) goto <D.26591>; else goto <D.26592>;
  <D.26591>:
  num_methods = num_methods + 1;
  <D.26592>:
  D.26593 = eb->raise_method;
  if (D.26593 != 0B) goto <D.26594>; else goto <D.26595>;
  <D.26594>:
  num_methods = num_methods + 1;
  <D.26595>:
  table = &assembly->tables[24];
  D.26596 = table->rows;
  D.26597 = D.26596 + num_methods;
  table->rows = D.26597;
  D.26596 = table->rows;
  alloc_table (table, D.26596);
  D.26587 = eb->add_method;
  if (D.26587 != 0B) goto <D.26598>; else goto <D.26599>;
  <D.26598>:
  D.26572 = table->next_idx;
  semaidx.130 = D.26572;
  D.26601 = semaidx.130 + 1;
  table->next_idx = D.26601;
  semaidx = semaidx.130;
  D.26575 = table->values;
  D.26602 = semaidx * 12;
  values = D.26575 + D.26602;
  *values = 8;
  D.26578 = values + 4;
  D.26587 = eb->add_method;
  D.26603 = D.26587->table_idx;
  *D.26578 = D.26603;
  D.26583 = values + 8;
  D.26576 = eb->table_idx;
  D.26604 = D.26576 << 1;
  *D.26583 = D.26604;
  <D.26599>:
  D.26590 = eb->remove_method;
  if (D.26590 != 0B) goto <D.26605>; else goto <D.26606>;
  <D.26605>:
  D.26572 = table->next_idx;
  semaidx.131 = D.26572;
  D.26608 = semaidx.131 + 1;
  table->next_idx = D.26608;
  semaidx = semaidx.131;
  D.26575 = table->values;
  D.26602 = semaidx * 12;
  values = D.26575 + D.26602;
  *values = 16;
  D.26578 = values + 4;
  D.26590 = eb->remove_method;
  D.26609 = D.26590->table_idx;
  *D.26578 = D.26609;
  D.26583 = values + 8;
  D.26576 = eb->table_idx;
  D.26604 = D.26576 << 1;
  *D.26583 = D.26604;
  <D.26606>:
  D.26593 = eb->raise_method;
  if (D.26593 != 0B) goto <D.26610>; else goto <D.26611>;
  <D.26610>:
  D.26572 = table->next_idx;
  semaidx.132 = D.26572;
  D.26613 = semaidx.132 + 1;
  table->next_idx = D.26613;
  semaidx = semaidx.132;
  D.26575 = table->values;
  D.26602 = semaidx * 12;
  values = D.26575 + D.26602;
  *values = 32;
  D.26578 = values + 4;
  D.26593 = eb->raise_method;
  D.26614 = D.26593->table_idx;
  *D.26578 = D.26614;
  D.26583 = values + 8;
  D.26576 = eb->table_idx;
  D.26604 = D.26576 << 1;
  *D.26583 = D.26604;
  <D.26611>:
}


mono_image_get_property_info (struct MonoReflectionPropertyBuilder * pb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26615;
  unsigned int D.26616;
  unsigned int D.26617;
  int D.26618;
  guint32 * D.26619;
  int D.26620;
  unsigned int D.26621;
  unsigned int D.26622;
  guint32 * D.26623;
  struct MonoString * D.26624;
  struct MonoDynamicStream * D.26625;
  unsigned int D.26626;
  unsigned int D.26627;
  guint32 * D.26628;
  unsigned int D.26629;
  struct MonoReflectionMethodBuilder * D.26630;
  struct MonoReflectionMethodBuilder * D.26633;
  unsigned int D.26636;
  unsigned int D.26637;
  unsigned int semaidx.133;
  unsigned int D.26641;
  unsigned int D.26642;
  unsigned int D.26643;
  int D.26644;
  int D.26645;
  unsigned int D.26646;
  unsigned int semaidx.134;
  unsigned int D.26650;
  unsigned int D.26651;
  unsigned int D.26652;
  unsigned int D.26655;
  unsigned int D.26656;
  int D.26657;
  int D.26658;
  unsigned int D.26659;
  guint32 * D.26660;
  struct MonoObject * D.26661;
  unsigned int D.26662;
  unsigned int field_type.135;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[23];
  D.26615 = table->next_idx;
  D.26616 = D.26615;
  D.26617 = D.26616 + 1;
  table->next_idx = D.26617;
  D.26618 = (int) D.26616;
  pb->table_idx = D.26618;
  D.26619 = table->values;
  D.26620 = pb->table_idx;
  D.26621 = (unsigned int) D.26620;
  D.26622 = D.26621 * 12;
  values = D.26619 + D.26622;
  D.26623 = values + 4;
  D.26624 = pb->name;
  D.26625 = &assembly->sheap;
  D.26626 = string_heap_insert_mstring (D.26625, D.26624);
  *D.26623 = D.26626;
  D.26627 = pb->attrs;
  *values = D.26627;
  D.26628 = values + 8;
  D.26629 = property_encode_signature (assembly, pb);
  *D.26628 = D.26629;
  D.26630 = pb->get_method;
  if (D.26630 != 0B) goto <D.26631>; else goto <D.26632>;
  <D.26631>:
  num_methods = num_methods + 1;
  <D.26632>:
  D.26633 = pb->set_method;
  if (D.26633 != 0B) goto <D.26634>; else goto <D.26635>;
  <D.26634>:
  num_methods = num_methods + 1;
  <D.26635>:
  table = &assembly->tables[24];
  D.26636 = table->rows;
  D.26637 = D.26636 + num_methods;
  table->rows = D.26637;
  D.26636 = table->rows;
  alloc_table (table, D.26636);
  D.26630 = pb->get_method;
  if (D.26630 != 0B) goto <D.26638>; else goto <D.26639>;
  <D.26638>:
  D.26615 = table->next_idx;
  semaidx.133 = D.26615;
  D.26641 = semaidx.133 + 1;
  table->next_idx = D.26641;
  semaidx = semaidx.133;
  D.26619 = table->values;
  D.26642 = semaidx * 12;
  values = D.26619 + D.26642;
  *values = 2;
  D.26623 = values + 4;
  D.26630 = pb->get_method;
  D.26643 = D.26630->table_idx;
  *D.26623 = D.26643;
  D.26628 = values + 8;
  D.26620 = pb->table_idx;
  D.26644 = D.26620 << 1;
  D.26645 = D.26644 | 1;
  D.26646 = (unsigned int) D.26645;
  *D.26628 = D.26646;
  <D.26639>:
  D.26633 = pb->set_method;
  if (D.26633 != 0B) goto <D.26647>; else goto <D.26648>;
  <D.26647>:
  D.26615 = table->next_idx;
  semaidx.134 = D.26615;
  D.26650 = semaidx.134 + 1;
  table->next_idx = D.26650;
  semaidx = semaidx.134;
  D.26619 = table->values;
  D.26642 = semaidx * 12;
  values = D.26619 + D.26642;
  *values = 1;
  D.26623 = values + 4;
  D.26633 = pb->set_method;
  D.26651 = D.26633->table_idx;
  *D.26623 = D.26651;
  D.26628 = values + 8;
  D.26620 = pb->table_idx;
  D.26644 = D.26620 << 1;
  D.26645 = D.26644 | 1;
  D.26646 = (unsigned int) D.26645;
  *D.26628 = D.26646;
  <D.26648>:
  D.26627 = pb->attrs;
  D.26652 = D.26627 & 4096;
  if (D.26652 != 0) goto <D.26653>; else goto <D.26654>;
  <D.26653>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.26636 = table->rows;
        D.26655 = D.26636 + 1;
        table->rows = D.26655;
        D.26636 = table->rows;
        alloc_table (table, D.26636);
        D.26619 = table->values;
        D.26636 = table->rows;
        D.26656 = D.26636 * 16;
        values = D.26619 + D.26656;
        D.26628 = values + 8;
        D.26620 = pb->table_idx;
        D.26657 = D.26620 << 2;
        D.26658 = D.26657 | 2;
        D.26659 = (unsigned int) D.26658;
        *D.26628 = D.26659;
        D.26660 = values + 12;
        D.26661 = pb->def_value;
        D.26662 = encode_constant (assembly, D.26661, &field_type);
        *D.26660 = D.26662;
        field_type.135 = field_type;
        *values = field_type.135;
        D.26623 = values + 4;
        *D.26623 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.26654>:
}


property_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionPropertyBuilder * fb)
{
  struct MonoArray * D.26666;
  _Bool D.26669;
  _Bool D.26670;
  _Bool D.26671;
  struct MonoArray * D.26674;
  unsigned int D.26677;
  unsigned int D.26678;
  unsigned int D.26679;
  struct MonoObject * D.26685;
  char * D.26686;
  char * D.26692;
  struct MonoReflectionType * D.26693;
  char * D.26694;
  struct MonoObject * D.26695;
  guint32 D.26696;
  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.26664>; else goto <D.26665>;
      <D.26664>:
      D.26666 = mb->parameters;
      if (D.26666 != 0B) goto <D.26667>; else goto <D.26668>;
      <D.26667>:
      D.26666 = mb->parameters;
      nparams = mono_array_length (D.26666);
      <D.26668>:
      <D.26665>:
      D.26669 = mb == 0B;
      D.26670 = smb != 0B;
      D.26671 = D.26669 & D.26670;
      if (D.26671 != 0) goto <D.26672>; else goto <D.26673>;
      <D.26672>:
      D.26674 = smb->parameters;
      if (D.26674 != 0B) goto <D.26675>; else goto <D.26676>;
      <D.26675>:
      D.26674 = smb->parameters;
      D.26677 = mono_array_length (D.26674);
      nparams = D.26677 + 4294967295;
      <D.26676>:
      <D.26673>:
      sigbuffer_init (&buf, 32);
      D.26678 = fb->call_conv;
      D.26679 = D.26678 & 32;
      if (D.26679 != 0) goto <D.26680>; else goto <D.26681>;
      <D.26680>:
      sigbuffer_add_byte (&buf, 40);
      goto <D.26682>;
      <D.26681>:
      sigbuffer_add_byte (&buf, 8);
      <D.26682>:
      sigbuffer_add_value (&buf, nparams);
      if (mb != 0B) goto <D.26683>; else goto <D.26684>;
      <D.26683>:
      D.26685 = mb->rtype;
      encode_reflection_type (assembly, D.26685, &buf);
      i = 0;
      goto <D.18920>;
      <D.18919>:
      {
        struct MonoReflectionType * pt;

        D.26666 = mb->parameters;
        D.26686 = mono_array_addr_with_size (D.26666, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.26686];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18920>:
      if (i < nparams) goto <D.18919>; else goto <D.18921>;
      <D.18921>:
      goto <D.26687>;
      <D.26684>:
      if (smb != 0B) goto <D.26690>; else goto <D.26688>;
      <D.26690>:
      D.26674 = smb->parameters;
      if (D.26674 != 0B) goto <D.26691>; else goto <D.26688>;
      <D.26691>:
      D.26674 = smb->parameters;
      D.26692 = mono_array_addr_with_size (D.26674, 4, nparams);
      D.26693 = MEM[(struct MonoReflectionType * *)D.26692];
      encode_reflection_type (assembly, D.26693, &buf);
      i = 0;
      goto <D.18924>;
      <D.18923>:
      {
        struct MonoReflectionType * pt;

        D.26674 = smb->parameters;
        D.26694 = mono_array_addr_with_size (D.26674, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.26694];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18924>:
      if (i < nparams) goto <D.18923>; else goto <D.18925>;
      <D.18925>:
      goto <D.26689>;
      <D.26688>:
      D.26695 = fb->type;
      encode_reflection_type (assembly, D.26695, &buf);
      <D.26689>:
      <D.26687>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26696 = idx;
      return D.26696;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_cattrs (struct MonoDynamicImage * assembly, guint32 idx, guint32 type, struct MonoArray * cattrs)
{
  unsigned int D.26701;
  unsigned int D.26702;
  guint32 * D.26703;
  unsigned int D.26704;
  unsigned int D.26705;
  char * D.26706;
  struct MonoReflectionMethod * D.26707;
  unsigned int D.26708;
  void * token.136;
  struct MonoGHashTable * D.26710;
  guint32 * D.26711;
  char * p.137;
  struct MonoArray * D.26713;
  unsigned int D.26714;
  guint32 * D.26715;
  unsigned int D.26716;
  int D.26717;
  char * D.26718;
  int p.138;
  int blob_size.139;
  int D.26721;
  unsigned int D.26722;
  unsigned int D.26723;
  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.26699>; else goto <D.26700>;
      <D.26699>:
      return;
      <D.26700>:
      count = mono_array_length (cattrs);
      table = &assembly->tables[12];
      D.26701 = table->rows;
      D.26702 = D.26701 + count;
      table->rows = D.26702;
      D.26701 = table->rows;
      alloc_table (table, D.26701);
      D.26703 = table->values;
      D.26704 = table->next_idx;
      D.26705 = D.26704 * 12;
      values = D.26703 + D.26705;
      idx = idx << 5;
      idx = idx | type;
      i = 0;
      goto <D.18709>;
      <D.18708>:
      D.26706 = mono_array_addr_with_size (cattrs, 4, i);
      cattr = MEM[(void * *)D.26706];
      *values = idx;
      D.26707 = cattr->ctor;
      token = mono_image_create_token (assembly, D.26707, 0, 0);
      type = token & 16777215;
      type = type << 3;
      D.26708 = token >> 24;
      switch (D.26708) <default: <D.18706>, case 6: <D.18703>, case 10: <D.18705>>
      <D.18703>:
      type = type | 2;
      D.26707 = cattr->ctor;
      token.136 = (void *) token;
      D.26710 = assembly->remapped_tokens;
      mono_g_hash_table_insert (D.26710, token.136, D.26707);
      goto <D.18704>;
      <D.18705>:
      type = type | 3;
      goto <D.18704>;
      <D.18706>:
      monoeg_g_log (0B, 16, "got wrong token in custom attr");
      // predicted unlikely by continue predictor.
      goto <D.18707>;
      <D.18704>:
      D.26711 = values + 4;
      *D.26711 = type;
      p = &blob_size;
      p.137 = p;
      D.26713 = cattr->data;
      D.26714 = mono_array_length (D.26713);
      mono_metadata_encode_value (D.26714, p.137, &p);
      D.26715 = values + 8;
      D.26713 = cattr->data;
      D.26716 = mono_array_length (D.26713);
      D.26717 = (int) D.26716;
      D.26713 = cattr->data;
      D.26718 = mono_array_addr_with_size (D.26713, 1, 0);
      p.137 = p;
      p.138 = (int) p.137;
      blob_size.139 = (int) &blob_size;
      D.26721 = p.138 - blob_size.139;
      D.26722 = add_to_blob_cached (assembly, &blob_size, D.26721, D.26718, D.26717);
      *D.26715 = D.26722;
      values = values + 12;
      D.26704 = table->next_idx;
      D.26723 = D.26704 + 1;
      table->next_idx = D.26723;
      <D.18707>:
      i = i + 1;
      <D.18709>:
      if (i < count) goto <D.18708>; else goto <D.18710>;
      <D.18710>:
    }
  finally
    {
      blob_size = {CLOBBER};
      p = {CLOBBER};
    }
}


mono_image_add_decl_security (struct MonoDynamicImage * assembly, guint32 parent_token, struct MonoArray * permissions)
{
  unsigned int D.26729;
  unsigned int D.26730;
  guint32 * D.26731;
  unsigned int D.26732;
  unsigned int D.26733;
  unsigned int D.26734;
  unsigned int D.26735;
  guint32 * D.26736;
  guint32 * D.26737;
  struct MonoString * D.26738;
  unsigned int D.26739;
  unsigned int D.26740;
  unsigned int D.26741;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 count;
  guint32 i;
  guint32 idx;
  struct MonoReflectionPermissionSet * perm;

  if (permissions == 0B) goto <D.26727>; else goto <D.26728>;
  <D.26727>:
  return;
  <D.26728>:
  count = mono_array_length (permissions);
  table = &assembly->tables[14];
  D.26729 = table->rows;
  D.26730 = D.26729 + count;
  table->rows = D.26730;
  D.26729 = table->rows;
  alloc_table (table, D.26729);
  i = 0;
  goto <D.18728>;
  <D.18727>:
  perm = mono_array_addr_with_size (permissions, 8, i);
  D.26731 = table->values;
  D.26732 = table->next_idx;
  D.26733 = D.26732 * 12;
  values = D.26731 + D.26733;
  idx = parent_token & 16777215;
  idx = idx << 2;
  D.26734 = parent_token >> 24;
  switch (D.26734) <default: <D.18726>, case 2: <D.18722>, case 6: <D.18724>, case 32: <D.18725>>
  <D.18722>:
  idx = idx;
  goto <D.18723>;
  <D.18724>:
  idx = idx | 1;
  goto <D.18723>;
  <D.18725>:
  idx = idx | 2;
  goto <D.18723>;
  <D.18726>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1363);
  <D.18723>:
  D.26735 = perm->action;
  *values = D.26735;
  D.26736 = values + 4;
  *D.26736 = idx;
  D.26737 = values + 8;
  D.26738 = perm->pset;
  D.26739 = add_mono_string_to_blob_cached (assembly, D.26738);
  *D.26737 = D.26739;
  D.26732 = table->next_idx;
  D.26740 = D.26732 + 1;
  table->next_idx = D.26740;
  i = i + 1;
  <D.18728>:
  D.26741 = mono_array_length (permissions);
  if (D.26741 > i) goto <D.18727>; else goto <D.18729>;
  <D.18729>:
}


add_mono_string_to_blob_cached (struct MonoDynamicImage * assembly, struct MonoString * str)
{
  int D.26743;
  int D.26744;
  char * b.140;
  int len.141;
  mono_unichar2 * D.26747;
  int b.142;
  int blob_size.143;
  int D.26750;
  guint32 D.26751;
  char blob_size[64];
  char * b;
  guint32 idx;
  guint32 len;

  try
    {
      b = &blob_size;
      idx = 0;
      D.26743 = str->length;
      D.26744 = D.26743 * 2;
      len = (guint32) D.26744;
      b.140 = b;
      mono_metadata_encode_value (len, b.140, &b);
      len.141 = (int) len;
      D.26747 = mono_string_chars (str);
      b.140 = b;
      b.142 = (int) b.140;
      blob_size.143 = (int) &blob_size;
      D.26750 = b.142 - blob_size.143;
      idx = add_to_blob_cached (assembly, &blob_size, D.26750, D.26747, len.141);
      D.26751 = idx;
      return D.26751;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


module_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoArray * D.26754;
  unsigned int D.26755;
  struct MonoArray * D.26756;
  unsigned int i.144;
  char * D.26760;
  struct MonoArray * D.26761;
  unsigned int D.26762;
  struct MonoArray * D.26763;
  unsigned int D.26764;
  struct MonoArray * D.26765;
  char * D.26768;
  struct MonoArray * D.26769;
  int D.26770;
  unsigned int D.26771;
  unsigned int D.26772;
  struct MonoArray * D.26773;
  char * D.26776;
  struct MonoReflectionTypeBuilder * D.26777;
  int D.26778;
  int i;

  D.26754 = moduleb->cattrs;
  D.26755 = moduleb->table_idx;
  mono_image_add_cattrs (assembly, D.26755, 7, D.26754);
  D.26756 = moduleb->global_methods;
  if (D.26756 != 0B) goto <D.26757>; else goto <D.26758>;
  <D.26757>:
  i = 0;
  goto <D.19468>;
  <D.19467>:
  {
    struct MonoReflectionMethodBuilder * mb;

    i.144 = (unsigned int) i;
    D.26756 = moduleb->global_methods;
    D.26760 = mono_array_addr_with_size (D.26756, 4, i.144);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.26760];
    D.26761 = mb->cattrs;
    D.26762 = mb->table_idx;
    mono_image_add_cattrs (assembly, D.26762, 0, D.26761);
    D.26763 = mb->pinfo;
    params_add_cattrs (assembly, D.26763);
  }
  i = i + 1;
  <D.19468>:
  i.144 = (unsigned int) i;
  D.26756 = moduleb->global_methods;
  D.26764 = mono_array_length (D.26756);
  if (i.144 < D.26764) goto <D.19467>; else goto <D.19469>;
  <D.19469>:
  <D.26758>:
  D.26765 = moduleb->global_fields;
  if (D.26765 != 0B) goto <D.26766>; else goto <D.26767>;
  <D.26766>:
  i = 0;
  goto <D.19472>;
  <D.19471>:
  {
    struct MonoReflectionFieldBuilder * fb;

    i.144 = (unsigned int) i;
    D.26765 = moduleb->global_fields;
    D.26768 = mono_array_addr_with_size (D.26765, 4, i.144);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.26768];
    D.26769 = fb->cattrs;
    D.26770 = fb->table_idx;
    D.26771 = (unsigned int) D.26770;
    mono_image_add_cattrs (assembly, D.26771, 1, D.26769);
  }
  i = i + 1;
  <D.19472>:
  i.144 = (unsigned int) i;
  D.26765 = moduleb->global_fields;
  D.26772 = mono_array_length (D.26765);
  if (i.144 < D.26772) goto <D.19471>; else goto <D.19473>;
  <D.19473>:
  <D.26767>:
  D.26773 = moduleb->types;
  if (D.26773 != 0B) goto <D.26774>; else goto <D.26775>;
  <D.26774>:
  i = 0;
  goto <D.19475>;
  <D.19474>:
  i.144 = (unsigned int) i;
  D.26773 = moduleb->types;
  D.26776 = mono_array_addr_with_size (D.26773, 4, i.144);
  D.26777 = MEM[(struct MonoReflectionTypeBuilder * *)D.26776];
  type_add_cattrs (assembly, D.26777);
  i = i + 1;
  <D.19475>:
  D.26778 = moduleb->num_types;
  if (D.26778 > i) goto <D.19474>; else goto <D.19476>;
  <D.19476>:
  <D.26775>:
}


params_add_cattrs (struct MonoDynamicImage * assembly, struct MonoArray * pinfo)
{
  unsigned int i.145;
  char * D.26782;
  struct MonoArray * D.26785;
  unsigned int D.26786;
  unsigned int D.26787;
  int i;

  if (pinfo == 0B) goto <D.26779>; else goto <D.26780>;
  <D.26779>:
  return;
  <D.26780>:
  i = 0;
  goto <D.19431>;
  <D.19430>:
  {
    struct MonoReflectionParamBuilder * pb;

    i.145 = (unsigned int) i;
    D.26782 = mono_array_addr_with_size (pinfo, 4, i.145);
    pb = MEM[(struct MonoReflectionParamBuilder * *)D.26782];
    if (pb == 0B) goto <D.26783>; else goto <D.26784>;
    <D.26783>:
    // predicted unlikely by continue predictor.
    goto <D.19429>;
    <D.26784>:
    D.26785 = pb->cattrs;
    D.26786 = pb->table_idx;
    mono_image_add_cattrs (assembly, D.26786, 4, D.26785);
  }
  <D.19429>:
  i = i + 1;
  <D.19431>:
  i.145 = (unsigned int) i;
  D.26787 = mono_array_length (pinfo);
  if (i.145 < D.26787) goto <D.19430>; else goto <D.19432>;
  <D.19432>:
}


type_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct MonoArray * D.26789;
  unsigned int D.26790;
  struct MonoArray * D.26791;
  unsigned int i.146;
  char * D.26795;
  struct MonoArray * D.26796;
  int D.26797;
  unsigned int D.26798;
  int D.26799;
  struct MonoArray * D.26800;
  char * D.26803;
  struct MonoArray * D.26804;
  unsigned int D.26805;
  unsigned int D.26806;
  struct MonoArray * D.26807;
  char * D.26810;
  struct MonoArray * D.26811;
  int D.26812;
  unsigned int D.26813;
  unsigned int D.26814;
  struct MonoArray * D.26815;
  char * D.26818;
  struct MonoArray * D.26819;
  unsigned int D.26820;
  struct MonoArray * D.26821;
  unsigned int D.26822;
  struct MonoArray * D.26823;
  char * D.26826;
  struct MonoArray * D.26827;
  unsigned int D.26828;
  struct MonoArray * D.26829;
  int D.26830;
  struct MonoArray * D.26831;
  char * D.26834;
  struct MonoReflectionTypeBuilder * D.26835;
  unsigned int D.26836;
  int i;

  D.26789 = tb->cattrs;
  D.26790 = tb->table_idx;
  mono_image_add_cattrs (assembly, D.26790, 3, D.26789);
  D.26791 = tb->fields;
  if (D.26791 != 0B) goto <D.26792>; else goto <D.26793>;
  <D.26792>:
  i = 0;
  goto <D.19440>;
  <D.19439>:
  {
    struct MonoReflectionFieldBuilder * fb;

    i.146 = (unsigned int) i;
    D.26791 = tb->fields;
    D.26795 = mono_array_addr_with_size (D.26791, 4, i.146);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.26795];
    D.26796 = fb->cattrs;
    D.26797 = fb->table_idx;
    D.26798 = (unsigned int) D.26797;
    mono_image_add_cattrs (assembly, D.26798, 1, D.26796);
  }
  i = i + 1;
  <D.19440>:
  D.26799 = tb->num_fields;
  if (D.26799 > i) goto <D.19439>; else goto <D.19441>;
  <D.19441>:
  <D.26793>:
  D.26800 = tb->events;
  if (D.26800 != 0B) goto <D.26801>; else goto <D.26802>;
  <D.26801>:
  i = 0;
  goto <D.19444>;
  <D.19443>:
  {
    struct MonoReflectionEventBuilder * eb;

    i.146 = (unsigned int) i;
    D.26800 = tb->events;
    D.26803 = mono_array_addr_with_size (D.26800, 4, i.146);
    eb = MEM[(struct MonoReflectionEventBuilder * *)D.26803];
    D.26804 = eb->cattrs;
    D.26805 = eb->table_idx;
    mono_image_add_cattrs (assembly, D.26805, 10, D.26804);
  }
  i = i + 1;
  <D.19444>:
  i.146 = (unsigned int) i;
  D.26800 = tb->events;
  D.26806 = mono_array_length (D.26800);
  if (i.146 < D.26806) goto <D.19443>; else goto <D.19445>;
  <D.19445>:
  <D.26802>:
  D.26807 = tb->properties;
  if (D.26807 != 0B) goto <D.26808>; else goto <D.26809>;
  <D.26808>:
  i = 0;
  goto <D.19448>;
  <D.19447>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    i.146 = (unsigned int) i;
    D.26807 = tb->properties;
    D.26810 = mono_array_addr_with_size (D.26807, 4, i.146);
    pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.26810];
    D.26811 = pb->cattrs;
    D.26812 = pb->table_idx;
    D.26813 = (unsigned int) D.26812;
    mono_image_add_cattrs (assembly, D.26813, 9, D.26811);
  }
  i = i + 1;
  <D.19448>:
  i.146 = (unsigned int) i;
  D.26807 = tb->properties;
  D.26814 = mono_array_length (D.26807);
  if (i.146 < D.26814) goto <D.19447>; else goto <D.19449>;
  <D.19449>:
  <D.26809>:
  D.26815 = tb->ctors;
  if (D.26815 != 0B) goto <D.26816>; else goto <D.26817>;
  <D.26816>:
  i = 0;
  goto <D.19452>;
  <D.19451>:
  {
    struct MonoReflectionCtorBuilder * cb;

    i.146 = (unsigned int) i;
    D.26815 = tb->ctors;
    D.26818 = mono_array_addr_with_size (D.26815, 4, i.146);
    cb = MEM[(struct MonoReflectionCtorBuilder * *)D.26818];
    D.26819 = cb->cattrs;
    D.26820 = cb->table_idx;
    mono_image_add_cattrs (assembly, D.26820, 0, D.26819);
    D.26821 = cb->pinfo;
    params_add_cattrs (assembly, D.26821);
  }
  i = i + 1;
  <D.19452>:
  i.146 = (unsigned int) i;
  D.26815 = tb->ctors;
  D.26822 = mono_array_length (D.26815);
  if (i.146 < D.26822) goto <D.19451>; else goto <D.19453>;
  <D.19453>:
  <D.26817>:
  D.26823 = tb->methods;
  if (D.26823 != 0B) goto <D.26824>; else goto <D.26825>;
  <D.26824>:
  i = 0;
  goto <D.19456>;
  <D.19455>:
  {
    struct MonoReflectionMethodBuilder * mb;

    i.146 = (unsigned int) i;
    D.26823 = tb->methods;
    D.26826 = mono_array_addr_with_size (D.26823, 4, i.146);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.26826];
    D.26827 = mb->cattrs;
    D.26828 = mb->table_idx;
    mono_image_add_cattrs (assembly, D.26828, 0, D.26827);
    D.26829 = mb->pinfo;
    params_add_cattrs (assembly, D.26829);
  }
  i = i + 1;
  <D.19456>:
  D.26830 = tb->num_methods;
  if (D.26830 > i) goto <D.19455>; else goto <D.19457>;
  <D.19457>:
  <D.26825>:
  D.26831 = tb->subtypes;
  if (D.26831 != 0B) goto <D.26832>; else goto <D.26833>;
  <D.26832>:
  i = 0;
  goto <D.19459>;
  <D.19458>:
  i.146 = (unsigned int) i;
  D.26831 = tb->subtypes;
  D.26834 = mono_array_addr_with_size (D.26831, 4, i.146);
  D.26835 = MEM[(struct MonoReflectionTypeBuilder * *)D.26834];
  type_add_cattrs (assembly, D.26835);
  i = i + 1;
  <D.19459>:
  i.146 = (unsigned int) i;
  D.26831 = tb->subtypes;
  D.26836 = mono_array_length (D.26831);
  if (i.146 < D.26836) goto <D.19458>; else goto <D.19460>;
  <D.19460>:
  <D.26833>:
}


mono_image_add_methodimpl (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.26837;
  unsigned int i.147;
  char * D.26841;
  unsigned int D.26842;
  unsigned int D.26843;
  guint32 * D.26844;
  unsigned int D.26845;
  unsigned int D.26846;
  guint32 * D.26847;
  unsigned int D.26848;
  unsigned int D.26849;
  unsigned int D.26850;
  unsigned int D.26851;
  unsigned int D.26852;
  guint32 * D.26853;
  unsigned int D.26854;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 tok;
  struct MonoReflectionMethod * m;
  int i;

  tb = mb->type;
  D.26837 = mb->override_methods;
  if (D.26837 == 0B) goto <D.26838>; else goto <D.26839>;
  <D.26838>:
  return;
  <D.26839>:
  i = 0;
  goto <D.18776>;
  <D.18775>:
  i.147 = (unsigned int) i;
  D.26837 = mb->override_methods;
  D.26841 = mono_array_addr_with_size (D.26837, 4, i.147);
  m = MEM[(struct MonoReflectionMethod * *)D.26841];
  table = &assembly->tables[25];
  D.26842 = table->rows;
  D.26843 = D.26842 + 1;
  table->rows = D.26843;
  D.26842 = table->rows;
  alloc_table (table, D.26842);
  D.26844 = table->values;
  D.26842 = table->rows;
  D.26845 = D.26842 * 12;
  values = D.26844 + D.26845;
  D.26846 = tb->table_idx;
  *values = D.26846;
  D.26847 = values + 4;
  D.26848 = mb->table_idx;
  D.26849 = D.26848 << 1;
  *D.26847 = D.26849;
  tok = mono_image_create_token (assembly, m, 0, 0);
  D.26850 = tok >> 24;
  switch (D.26850) <default: <D.18774>, case 6: <D.18773>, case 10: <D.18771>>
  <D.18771>:
  D.26851 = tok & 16777215;
  D.26852 = D.26851 << 1;
  tok = D.26852 | 1;
  goto <D.18772>;
  <D.18773>:
  D.26851 = tok & 16777215;
  tok = D.26851 << 1;
  goto <D.18772>;
  <D.18774>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1589);
  <D.18772>:
  D.26853 = values + 8;
  *D.26853 = tok;
  i = i + 1;
  <D.18776>:
  i.147 = (unsigned int) i;
  D.26837 = mb->override_methods;
  D.26854 = mono_array_length (D.26837);
  if (i.147 < D.26854) goto <D.18775>; else goto <D.18777>;
  <D.18777>:
}


fixup_cattrs (struct MonoDynamicImage * assembly)
{
  guint32 * D.26856;
  unsigned int D.26857;
  unsigned int D.26858;
  unsigned int D.26859;
  const void * token.148;
  struct MonoGHashTable * D.26863;
  _Bool D.26864;
  long int D.26865;
  long int D.26866;
  int D.19929;
  int iftmp.149;
  int D.19928;
  struct MonoVTable * D.26872;
  struct MonoClass * D.26873;
  const char[12] * D.26874;
  unsigned char D.26875;
  int D.26876;
  unsigned char D.26877;
  int D.26878;
  _Bool D.26879;
  _Bool D.26880;
  _Bool D.26881;
  const unsigned char * D.26884;
  unsigned char D.26885;
  int D.26886;
  const unsigned char * D.26887;
  unsigned char D.26888;
  int D.26889;
  _Bool D.26890;
  _Bool D.26891;
  const unsigned char * D.26894;
  unsigned char D.26895;
  int D.26896;
  const unsigned char * D.26897;
  unsigned char D.26898;
  int D.26899;
  _Bool D.26900;
  _Bool D.26901;
  const unsigned char * D.26904;
  unsigned char D.26905;
  int D.26906;
  const unsigned char * D.26907;
  unsigned char D.26908;
  int D.26909;
  const char * D.26911;
  struct GHashTable * D.26914;
  void * D.26915;
  guint32 * D.26916;
  unsigned int D.26917;
  unsigned int D.26918;
  int D.19939;
  int iftmp.150;
  int D.19938;
  const char[19] * D.26923;
  unsigned char D.26924;
  int D.26925;
  unsigned char D.26926;
  int D.26927;
  _Bool D.26928;
  _Bool D.26929;
  _Bool D.26930;
  const unsigned char * D.26933;
  unsigned char D.26934;
  int D.26935;
  const unsigned char * D.26936;
  unsigned char D.26937;
  int D.26938;
  _Bool D.26939;
  _Bool D.26940;
  const unsigned char * D.26943;
  unsigned char D.26944;
  int D.26945;
  const unsigned char * D.26946;
  unsigned char D.26947;
  int D.26948;
  _Bool D.26949;
  _Bool D.26950;
  const unsigned char * D.26953;
  unsigned char D.26954;
  int D.26955;
  const unsigned char * D.26956;
  unsigned char D.26957;
  int D.26958;
  void * D.26962;
  unsigned int D.26963;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 type;
  guint32 i;
  guint32 idx;
  guint32 token;
  struct MonoObject * ctor;

  table = &assembly->tables[12];
  i = 0;
  goto <D.19942>;
  <D.19941>:
  D.26856 = table->values;
  D.26857 = i + 1;
  D.26858 = D.26857 * 12;
  values = D.26856 + D.26858;
  type = MEM[(guint32 *)values + 4B];
  D.26859 = type & 7;
  if (D.26859 == 2) goto <D.26860>; else goto <D.26861>;
  <D.26860>:
  idx = type >> 3;
  token = idx | 100663296;
  token.148 = (const void *) token;
  D.26863 = assembly->remapped_tokens;
  ctor = mono_g_hash_table_lookup (D.26863, token.148);
  D.26864 = ctor == 0B;
  D.26865 = (long int) D.26864;
  D.26866 = __builtin_expect (D.26865, 0);
  if (D.26866 != 0) goto <D.26867>; else goto <D.26868>;
  <D.26867>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4337, "ctor");
  <D.26868>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26872 = ctor->vtable;
      D.26873 = D.26872->klass;
      __s2 = D.26873->name;
      D.26874 = "MonoCMethod";
      D.26875 = MEM[(const unsigned char *)D.26874];
      D.26876 = (int) D.26875;
      D.26877 = *__s2;
      D.26878 = (int) D.26877;
      __result = D.26876 - D.26878;
      {
        D.26879 = __s2_len != 0;
        D.26880 = __result == 0;
        D.26881 = D.26879 & D.26880;
        if (D.26881 != 0) goto <D.26882>; else goto <D.26883>;
        <D.26882>:
        D.26884 = &MEM[(void *)"MonoCMethod" + 1B];
        D.26885 = *D.26884;
        D.26886 = (int) D.26885;
        D.26887 = __s2 + 1;
        D.26888 = *D.26887;
        D.26889 = (int) D.26888;
        __result = D.26886 - D.26889;
        D.26890 = __s2_len > 1;
        D.26880 = __result == 0;
        D.26891 = D.26890 & D.26880;
        if (D.26891 != 0) goto <D.26892>; else goto <D.26893>;
        <D.26892>:
        D.26894 = &MEM[(void *)"MonoCMethod" + 2B];
        D.26895 = *D.26894;
        D.26896 = (int) D.26895;
        D.26897 = __s2 + 2;
        D.26898 = *D.26897;
        D.26899 = (int) D.26898;
        __result = D.26896 - D.26899;
        D.26900 = __s2_len > 2;
        D.26880 = __result == 0;
        D.26901 = D.26900 & D.26880;
        if (D.26901 != 0) goto <D.26902>; else goto <D.26903>;
        <D.26902>:
        D.26904 = &MEM[(void *)"MonoCMethod" + 3B];
        D.26905 = *D.26904;
        D.26906 = (int) D.26905;
        D.26907 = __s2 + 3;
        D.26908 = *D.26907;
        D.26909 = (int) D.26908;
        __result = D.26906 - D.26909;
        <D.26903>:
        <D.26893>:
        <D.26883>:
      }
      D.19928 = __result;
    }
    iftmp.149 = -D.19928;
    goto <D.26910>;
    <D.26871>:
    D.26872 = ctor->vtable;
    D.26873 = D.26872->klass;
    D.26911 = D.26873->name;
    iftmp.149 = __builtin_strcmp (D.26911, "MonoCMethod");
    <D.26910>:
    D.19929 = iftmp.149;
  }
  if (D.19929 == 0) goto <D.26912>; else goto <D.26913>;
  <D.26912>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionMethod *)ctor].method;
    D.26914 = assembly->method_to_table_idx;
    D.26915 = monoeg_g_hash_table_lookup (D.26914, m);
    idx = (guint32) D.26915;
    D.26916 = values + 4;
    D.26917 = idx << 3;
    D.26918 = D.26917 | 2;
    *D.26916 = D.26918;
  }
  goto <D.26919>;
  <D.26913>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26872 = ctor->vtable;
      D.26873 = D.26872->klass;
      __s2 = D.26873->name;
      D.26923 = "ConstructorBuilder";
      D.26924 = MEM[(const unsigned char *)D.26923];
      D.26925 = (int) D.26924;
      D.26926 = *__s2;
      D.26927 = (int) D.26926;
      __result = D.26925 - D.26927;
      {
        D.26928 = __s2_len != 0;
        D.26929 = __result == 0;
        D.26930 = D.26928 & D.26929;
        if (D.26930 != 0) goto <D.26931>; else goto <D.26932>;
        <D.26931>:
        D.26933 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.26934 = *D.26933;
        D.26935 = (int) D.26934;
        D.26936 = __s2 + 1;
        D.26937 = *D.26936;
        D.26938 = (int) D.26937;
        __result = D.26935 - D.26938;
        D.26939 = __s2_len > 1;
        D.26929 = __result == 0;
        D.26940 = D.26939 & D.26929;
        if (D.26940 != 0) goto <D.26941>; else goto <D.26942>;
        <D.26941>:
        D.26943 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.26944 = *D.26943;
        D.26945 = (int) D.26944;
        D.26946 = __s2 + 2;
        D.26947 = *D.26946;
        D.26948 = (int) D.26947;
        __result = D.26945 - D.26948;
        D.26949 = __s2_len > 2;
        D.26929 = __result == 0;
        D.26950 = D.26949 & D.26929;
        if (D.26950 != 0) goto <D.26951>; else goto <D.26952>;
        <D.26951>:
        D.26953 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.26954 = *D.26953;
        D.26955 = (int) D.26954;
        D.26956 = __s2 + 3;
        D.26957 = *D.26956;
        D.26958 = (int) D.26957;
        __result = D.26955 - D.26958;
        <D.26952>:
        <D.26942>:
        <D.26932>:
      }
      D.19938 = __result;
    }
    iftmp.150 = -D.19938;
    goto <D.26959>;
    <D.26922>:
    D.26872 = ctor->vtable;
    D.26873 = D.26872->klass;
    D.26911 = D.26873->name;
    iftmp.150 = __builtin_strcmp (D.26911, "ConstructorBuilder");
    <D.26959>:
    D.19939 = iftmp.150;
  }
  if (D.19939 == 0) goto <D.26960>; else goto <D.26961>;
  <D.26960>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionCtorBuilder *)ctor].mhandle;
    D.26914 = assembly->method_to_table_idx;
    D.26962 = monoeg_g_hash_table_lookup (D.26914, m);
    idx = (guint32) D.26962;
    D.26916 = values + 4;
    D.26917 = idx << 3;
    D.26918 = D.26917 | 2;
    *D.26916 = D.26918;
  }
  <D.26961>:
  <D.26919>:
  <D.26861>:
  i = i + 1;
  <D.19942>:
  D.26963 = table->rows;
  if (D.26963 > i) goto <D.19941>; else goto <D.19943>;
  <D.19943>:
}


mono_image_insert_string (struct MonoReflectionModuleBuilder * module, struct MonoString * str)
{
  struct MonoDynamicImage * D.26964;
  int D.26967;
  char * b.151;
  int D.26971;
  int D.26972;
  int D.26973;
  unsigned int D.26974;
  int b.152;
  int buf.153;
  int D.26977;
  unsigned int D.26978;
  struct MonoDynamicStream * D.26979;
  unsigned int D.26980;
  mono_unichar2 * D.26981;
  unsigned int D.26983;
  unsigned int idx.154;
  unsigned int D.26985;
  unsigned int D.26986;
  void * D.26987;
  struct MonoGHashTable * D.26988;
  guint32 D.26989;
  struct MonoDynamicImage * assembly;
  guint32 idx;
  char buf[16];
  char * b;

  try
    {
      b = &buf;
      D.26964 = module->dynamic_image;
      if (D.26964 == 0B) goto <D.26965>; else goto <D.26966>;
      <D.26965>:
      mono_image_module_basic_init (module);
      <D.26966>:
      assembly = module->dynamic_image;
      D.26967 = assembly->save;
      if (D.26967 != 0) goto <D.26968>; else goto <D.26969>;
      <D.26968>:
      b.151 = b;
      D.26971 = str->length;
      D.26972 = D.26971 * 2;
      D.26973 = D.26972 | 1;
      D.26974 = (unsigned int) D.26973;
      mono_metadata_encode_value (D.26974, b.151, &b);
      b.151 = b;
      b.152 = (int) b.151;
      buf.153 = (int) &buf;
      D.26977 = b.152 - buf.153;
      D.26978 = (unsigned int) D.26977;
      D.26979 = &assembly->us;
      idx = mono_image_add_stream_data (D.26979, &buf, D.26978);
      D.26971 = str->length;
      D.26972 = D.26971 * 2;
      D.26980 = (unsigned int) D.26972;
      D.26981 = mono_string_chars (str);
      D.26979 = &assembly->us;
      mono_image_add_stream_data (D.26979, D.26981, D.26980);
      D.26979 = &assembly->us;
      mono_image_add_stream_data (D.26979, "", 1);
      goto <D.26982>;
      <D.26969>:
      D.26983 = assembly->us.index;
      idx.154 = D.26983;
      D.26985 = idx.154 + 1;
      assembly->us.index = D.26985;
      idx = idx.154;
      <D.26982>:
      D.26986 = idx | 1879048192;
      D.26987 = (void *) D.26986;
      D.26988 = assembly->tokens;
      mono_g_hash_table_insert (D.26988, D.26987, str);
      D.26989 = idx | 1879048192;
      return D.26989;
    }
  finally
    {
      buf = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_create_method_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, struct MonoArray * opt_param_types)
{
  struct MonoVTable * D.26992;
  int D.20104;
  int iftmp.155;
  int D.20103;
  const char[11] * D.26999;
  unsigned char D.27000;
  int D.27001;
  unsigned char D.27002;
  int D.27003;
  _Bool D.27004;
  _Bool D.27005;
  _Bool D.27006;
  const unsigned char * D.27009;
  unsigned char D.27010;
  int D.27011;
  const unsigned char * D.27012;
  unsigned char D.27013;
  int D.27014;
  _Bool D.27015;
  _Bool D.27016;
  const unsigned char * D.27019;
  unsigned char D.27020;
  int D.27021;
  const unsigned char * D.27022;
  unsigned char D.27023;
  int D.27024;
  _Bool D.27025;
  _Bool D.27026;
  const unsigned char * D.27029;
  unsigned char D.27030;
  int D.27031;
  const unsigned char * D.27032;
  unsigned char D.27033;
  int D.27034;
  const char * D.27036;
  int D.20113;
  int iftmp.156;
  int D.20112;
  const char[12] * D.27041;
  unsigned char D.27042;
  int D.27043;
  unsigned char D.27044;
  int D.27045;
  _Bool D.27046;
  _Bool D.27047;
  _Bool D.27048;
  const unsigned char * D.27051;
  unsigned char D.27052;
  int D.27053;
  const unsigned char * D.27054;
  unsigned char D.27055;
  int D.27056;
  _Bool D.27057;
  _Bool D.27058;
  const unsigned char * D.27061;
  unsigned char D.27062;
  int D.27063;
  const unsigned char * D.27064;
  unsigned char D.27065;
  int D.27066;
  _Bool D.27067;
  _Bool D.27068;
  const unsigned char * D.27071;
  unsigned char D.27072;
  int D.27073;
  const unsigned char * D.27074;
  unsigned char D.27075;
  int D.27076;
  int iftmp.157;
  struct MonoMethodSignature * D.27083;
  short int D.27084;
  _Bool D.27085;
  long int D.27086;
  long int D.27087;
  unsigned int D.27090;
  short unsigned int D.27091;
  int D.27092;
  int D.27093;
  unsigned int D.27094;
  struct MonoImage * D.27095;
  <unnamed-unsigned:1> D.27096;
  <unnamed-unsigned:1> D.27097;
  <unnamed-unsigned:6> D.27098;
  short unsigned int D.27099;
  short unsigned int D.27100;
  short unsigned int D.27101;
  short int D.27102;
  struct MonoType * D.27103;
  struct MonoType * D.27104;
  unsigned int i.158;
  char * D.27106;
  int D.27107;
  struct MonoType * D.27108;
  struct MonoClass * D.27109;
  struct MonoType * D.27110;
  unsigned int D.27111;
  _Bool D.27112;
  long int D.27113;
  long int D.27114;
  const char * D.27117;
  int D.20135;
  int iftmp.159;
  int D.20134;
  const char[14] * D.27121;
  unsigned char D.27122;
  int D.27123;
  unsigned char D.27124;
  int D.27125;
  _Bool D.27126;
  _Bool D.27127;
  _Bool D.27128;
  const unsigned char * D.27131;
  unsigned char D.27132;
  int D.27133;
  const unsigned char * D.27134;
  unsigned char D.27135;
  int D.27136;
  _Bool D.27137;
  _Bool D.27138;
  const unsigned char * D.27141;
  unsigned char D.27142;
  int D.27143;
  const unsigned char * D.27144;
  unsigned char D.27145;
  int D.27146;
  _Bool D.27147;
  _Bool D.27148;
  const unsigned char * D.27151;
  unsigned char D.27152;
  int D.27153;
  const unsigned char * D.27154;
  unsigned char D.27155;
  int D.27156;
  unsigned int D.27160;
  int iftmp.160;
  struct MonoArray * D.27162;
  unsigned int D.27165;
  int iftmp.161;
  struct MonoArray * D.27168;
  unsigned int D.27171;
  int D.27173;
  unsigned int D.27174;
  unsigned int D.27175;
  unsigned int D.27176;
  _Bool D.27177;
  unsigned int D.27178;
  unsigned int D.27179;
  _Bool D.27180;
  unsigned char D.27181;
  <unnamed-unsigned:6> D.27182;
  short unsigned int D.27183;
  short unsigned int D.27184;
  short unsigned int D.27185;
  short unsigned int D.27186;
  short int D.27187;
  struct MonoReflectionType * D.27188;
  struct MonoType * D.27189;
  unsigned int i.162;
  char * D.27191;
  struct MonoType * D.27192;
  char * D.27193;
  int D.27194;
  struct MonoType * D.27195;
  unsigned int D.27196;
  _Bool D.27197;
  long int D.27198;
  long int D.27199;
  unsigned int D.27202;
  struct MonoString * D.27203;
  void * token.163;
  struct GHashTable * D.27206;
  struct MonoGHashTable * D.27207;
  guint32 D.27208;
  struct MonoClass * klass;
  guint32 token;
  struct MonoMethodSignature * sig;

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

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

      __s2 = klass->name;
      D.26999 = "MonoMethod";
      D.27000 = MEM[(const unsigned char *)D.26999];
      D.27001 = (int) D.27000;
      D.27002 = *__s2;
      D.27003 = (int) D.27002;
      __result = D.27001 - D.27003;
      {
        D.27004 = __s2_len != 0;
        D.27005 = __result == 0;
        D.27006 = D.27004 & D.27005;
        if (D.27006 != 0) goto <D.27007>; else goto <D.27008>;
        <D.27007>:
        D.27009 = &MEM[(void *)"MonoMethod" + 1B];
        D.27010 = *D.27009;
        D.27011 = (int) D.27010;
        D.27012 = __s2 + 1;
        D.27013 = *D.27012;
        D.27014 = (int) D.27013;
        __result = D.27011 - D.27014;
        D.27015 = __s2_len > 1;
        D.27005 = __result == 0;
        D.27016 = D.27015 & D.27005;
        if (D.27016 != 0) goto <D.27017>; else goto <D.27018>;
        <D.27017>:
        D.27019 = &MEM[(void *)"MonoMethod" + 2B];
        D.27020 = *D.27019;
        D.27021 = (int) D.27020;
        D.27022 = __s2 + 2;
        D.27023 = *D.27022;
        D.27024 = (int) D.27023;
        __result = D.27021 - D.27024;
        D.27025 = __s2_len > 2;
        D.27005 = __result == 0;
        D.27026 = D.27025 & D.27005;
        if (D.27026 != 0) goto <D.27027>; else goto <D.27028>;
        <D.27027>:
        D.27029 = &MEM[(void *)"MonoMethod" + 3B];
        D.27030 = *D.27029;
        D.27031 = (int) D.27030;
        D.27032 = __s2 + 3;
        D.27033 = *D.27032;
        D.27034 = (int) D.27033;
        __result = D.27031 - D.27034;
        <D.27028>:
        <D.27018>:
        <D.27008>:
      }
      D.20103 = __result;
    }
    iftmp.155 = -D.20103;
    goto <D.27035>;
    <D.26998>:
    D.27036 = klass->name;
    iftmp.155 = __builtin_strcmp (D.27036, "MonoMethod");
    <D.27035>:
    D.20104 = iftmp.155;
  }
  if (D.20104 == 0) goto <D.26993>; else goto <D.27037>;
  <D.27037>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27041 = "MonoCMethod";
      D.27042 = MEM[(const unsigned char *)D.27041];
      D.27043 = (int) D.27042;
      D.27044 = *__s2;
      D.27045 = (int) D.27044;
      __result = D.27043 - D.27045;
      {
        D.27046 = __s2_len != 0;
        D.27047 = __result == 0;
        D.27048 = D.27046 & D.27047;
        if (D.27048 != 0) goto <D.27049>; else goto <D.27050>;
        <D.27049>:
        D.27051 = &MEM[(void *)"MonoCMethod" + 1B];
        D.27052 = *D.27051;
        D.27053 = (int) D.27052;
        D.27054 = __s2 + 1;
        D.27055 = *D.27054;
        D.27056 = (int) D.27055;
        __result = D.27053 - D.27056;
        D.27057 = __s2_len > 1;
        D.27047 = __result == 0;
        D.27058 = D.27057 & D.27047;
        if (D.27058 != 0) goto <D.27059>; else goto <D.27060>;
        <D.27059>:
        D.27061 = &MEM[(void *)"MonoCMethod" + 2B];
        D.27062 = *D.27061;
        D.27063 = (int) D.27062;
        D.27064 = __s2 + 2;
        D.27065 = *D.27064;
        D.27066 = (int) D.27065;
        __result = D.27063 - D.27066;
        D.27067 = __s2_len > 2;
        D.27047 = __result == 0;
        D.27068 = D.27067 & D.27047;
        if (D.27068 != 0) goto <D.27069>; else goto <D.27070>;
        <D.27069>:
        D.27071 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27072 = *D.27071;
        D.27073 = (int) D.27072;
        D.27074 = __s2 + 3;
        D.27075 = *D.27074;
        D.27076 = (int) D.27075;
        __result = D.27073 - D.27076;
        <D.27070>:
        <D.27060>:
        <D.27050>:
      }
      D.20112 = __result;
    }
    iftmp.156 = -D.20112;
    goto <D.27077>;
    <D.27040>:
    D.27036 = klass->name;
    iftmp.156 = __builtin_strcmp (D.27036, "MonoCMethod");
    <D.27077>:
    D.20113 = iftmp.156;
  }
  if (D.20113 == 0) goto <D.26993>; else goto <D.26994>;
  <D.26993>:
  {
    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.27079>; else goto <D.27082>;
    <D.27082>:
    D.27083 = mono_method_signature (method);
    D.27084 = D.27083->sentinelpos;
    if (D.27084 < 0) goto <D.27079>; else goto <D.27080>;
    <D.27079>:
    iftmp.157 = 1;
    goto <D.27081>;
    <D.27080>:
    iftmp.157 = 0;
    <D.27081>:
    D.27085 = iftmp.157 != 0;
    D.27086 = (long int) D.27085;
    D.27087 = __builtin_expect (D.27086, 0);
    if (D.27087 != 0) goto <D.27088>; else goto <D.27089>;
    <D.27088>:
    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.27089>:
    D.27090 = mono_array_length (opt_param_types);
    nargs = (int) D.27090;
    old = mono_method_signature (method);
    D.27091 = old->param_count;
    D.27092 = (int) D.27091;
    D.27093 = D.27092 + nargs;
    D.27094 = (unsigned int) D.27093;
    D.27095 = &assembly->image;
    sig = mono_metadata_signature_alloc (D.27095, D.27094);
    D.27096 = old->hasthis;
    sig->hasthis = D.27096;
    D.27097 = old->explicit_this;
    sig->explicit_this = D.27097;
    D.27098 = old->call_convention;
    sig->call_convention = D.27098;
    D.27099 = old->generic_param_count;
    sig->generic_param_count = D.27099;
    D.27091 = old->param_count;
    D.27100 = (short unsigned int) nargs;
    D.27101 = D.27091 + D.27100;
    sig->param_count = D.27101;
    D.27091 = old->param_count;
    D.27102 = (short int) D.27091;
    sig->sentinelpos = D.27102;
    D.27103 = old->ret;
    sig->ret = D.27103;
    i = 0;
    goto <D.20121>;
    <D.20120>:
    D.27104 = old->params[i];
    sig->params[i] = D.27104;
    i = i + 1;
    <D.20121>:
    D.27091 = old->param_count;
    D.27092 = (int) D.27091;
    if (D.27092 > i) goto <D.20120>; else goto <D.20122>;
    <D.20122>:
    i = 0;
    goto <D.20125>;
    <D.20124>:
    {
      struct MonoReflectionType * rt;

      i.158 = (unsigned int) i;
      D.27106 = mono_array_addr_with_size (opt_param_types, 4, i.158);
      rt = MEM[(struct MonoReflectionType * *)D.27106];
      D.27091 = old->param_count;
      D.27092 = (int) D.27091;
      D.27107 = D.27092 + i;
      D.27108 = mono_reflection_type_get_handle (rt);
      sig->params[D.27107] = D.27108;
    }
    i = i + 1;
    <D.20125>:
    if (i < nargs) goto <D.20124>; else goto <D.20126>;
    <D.20126>:
    D.27109 = method->klass;
    D.27110 = &D.27109->byval_arg;
    parent = mono_image_typedef_or_ref (assembly, D.27110);
    D.27111 = parent & 3;
    D.27112 = D.27111 != 1;
    D.27113 = (long int) D.27112;
    D.27114 = __builtin_expect (D.27113, 0);
    if (D.27114 != 0) goto <D.27115>; else goto <D.27116>;
    <D.27115>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4836, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF");
    <D.27116>:
    parent = parent >> 2;
    parent = parent << 3;
    parent = parent | 1;
    sig_token = method_encode_signature (assembly, sig);
    D.27117 = method->name;
    token = mono_image_get_varargs_method_token (assembly, parent, D.27117, sig_token);
  }
  goto <D.26995>;
  <D.26994>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27121 = "MethodBuilder";
      D.27122 = MEM[(const unsigned char *)D.27121];
      D.27123 = (int) D.27122;
      D.27124 = *__s2;
      D.27125 = (int) D.27124;
      __result = D.27123 - D.27125;
      {
        D.27126 = __s2_len != 0;
        D.27127 = __result == 0;
        D.27128 = D.27126 & D.27127;
        if (D.27128 != 0) goto <D.27129>; else goto <D.27130>;
        <D.27129>:
        D.27131 = &MEM[(void *)"MethodBuilder" + 1B];
        D.27132 = *D.27131;
        D.27133 = (int) D.27132;
        D.27134 = __s2 + 1;
        D.27135 = *D.27134;
        D.27136 = (int) D.27135;
        __result = D.27133 - D.27136;
        D.27137 = __s2_len > 1;
        D.27127 = __result == 0;
        D.27138 = D.27137 & D.27127;
        if (D.27138 != 0) goto <D.27139>; else goto <D.27140>;
        <D.27139>:
        D.27141 = &MEM[(void *)"MethodBuilder" + 2B];
        D.27142 = *D.27141;
        D.27143 = (int) D.27142;
        D.27144 = __s2 + 2;
        D.27145 = *D.27144;
        D.27146 = (int) D.27145;
        __result = D.27143 - D.27146;
        D.27147 = __s2_len > 2;
        D.27127 = __result == 0;
        D.27148 = D.27147 & D.27127;
        if (D.27148 != 0) goto <D.27149>; else goto <D.27150>;
        <D.27149>:
        D.27151 = &MEM[(void *)"MethodBuilder" + 3B];
        D.27152 = *D.27151;
        D.27153 = (int) D.27152;
        D.27154 = __s2 + 3;
        D.27155 = *D.27154;
        D.27156 = (int) D.27155;
        __result = D.27153 - D.27156;
        <D.27150>:
        <D.27140>:
        <D.27130>:
      }
      D.20134 = __result;
    }
    iftmp.159 = -D.20134;
    goto <D.27157>;
    <D.27120>:
    D.27036 = klass->name;
    iftmp.159 = __builtin_strcmp (D.27036, "MethodBuilder");
    <D.27157>:
    D.20135 = iftmp.159;
  }
  if (D.20135 == 0) goto <D.27158>; else goto <D.27159>;
  <D.27158>:
  {
    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.27160 = mono_array_length (opt_param_types);
        nopt_args = (int) D.27160;
        D.27162 = rmb.parameters;
        if (D.27162 != 0B) goto <D.27163>; else goto <D.27164>;
        <D.27163>:
        D.27162 = rmb.parameters;
        D.27165 = mono_array_length (D.27162);
        iftmp.160 = (int) D.27165;
        goto <D.27166>;
        <D.27164>:
        iftmp.160 = 0;
        <D.27166>:
        nparams = iftmp.160;
        D.27168 = rmb.generic_params;
        if (D.27168 != 0B) goto <D.27169>; else goto <D.27170>;
        <D.27169>:
        D.27168 = rmb.generic_params;
        D.27171 = mono_array_length (D.27168);
        iftmp.161 = (int) D.27171;
        goto <D.27172>;
        <D.27170>:
        iftmp.161 = 0;
        <D.27172>:
        ngparams = iftmp.161;
        D.27173 = nparams + nopt_args;
        D.27174 = (unsigned int) D.27173;
        D.27095 = &assembly->image;
        sig = mono_metadata_signature_alloc (D.27095, D.27174);
        D.27175 = rmb.attrs;
        D.27176 = D.27175 & 16;
        D.27177 = D.27176 == 0;
        sig->hasthis = D.27177;
        D.27178 = rmb.call_conv;
        D.27179 = D.27178 & 64;
        D.27180 = D.27179 != 0;
        sig->explicit_this = D.27180;
        D.27178 = rmb.call_conv;
        D.27181 = (unsigned char) D.27178;
        D.27182 = (<unnamed-unsigned:6>) D.27181;
        sig->call_convention = D.27182;
        D.27183 = (short unsigned int) ngparams;
        sig->generic_param_count = D.27183;
        D.27184 = (short unsigned int) nparams;
        D.27185 = (short unsigned int) nopt_args;
        D.27186 = D.27184 + D.27185;
        sig->param_count = D.27186;
        D.27187 = (short int) nparams;
        sig->sentinelpos = D.27187;
        D.27188 = rmb.rtype;
        D.27189 = mono_reflection_type_get_handle (D.27188);
        sig->ret = D.27189;
        i = 0;
        goto <D.20147>;
        <D.20146>:
        {
          struct MonoReflectionType * rt;

          i.162 = (unsigned int) i;
          D.27162 = rmb.parameters;
          D.27191 = mono_array_addr_with_size (D.27162, 4, i.162);
          rt = MEM[(struct MonoReflectionType * *)D.27191];
          D.27192 = mono_reflection_type_get_handle (rt);
          sig->params[i] = D.27192;
        }
        i = i + 1;
        <D.20147>:
        if (i < nparams) goto <D.20146>; else goto <D.20148>;
        <D.20148>:
        i = 0;
        goto <D.20151>;
        <D.20150>:
        {
          struct MonoReflectionType * rt;

          i.162 = (unsigned int) i;
          D.27193 = mono_array_addr_with_size (opt_param_types, 4, i.162);
          rt = MEM[(struct MonoReflectionType * *)D.27193];
          D.27194 = nparams + i;
          D.27195 = mono_reflection_type_get_handle (rt);
          sig->params[D.27194] = D.27195;
        }
        i = i + 1;
        <D.20151>:
        if (i < nopt_args) goto <D.20150>; else goto <D.20152>;
        <D.20152>:
        sig_token = method_builder_encode_signature (assembly, &rmb);
        parent = mono_image_create_token (assembly, obj, 1, 1);
        D.27196 = parent >> 24;
        D.27197 = D.27196 != 6;
        D.27198 = (long int) D.27197;
        D.27199 = __builtin_expect (D.27198, 0);
        if (D.27199 != 0) goto <D.27200>; else goto <D.27201>;
        <D.27200>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4880, "mono_metadata_token_table (parent) == MONO_TABLE_METHOD");
        <D.27201>:
        D.27202 = parent & 16777215;
        parent = D.27202 << 3;
        parent = parent | 3;
        D.27203 = rmb.name;
        name = mono_string_to_utf8 (D.27203);
        token = mono_image_get_varargs_method_token (assembly, parent, name, sig_token);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.27204>;
  <D.27159>:
  D.27036 = klass->name;
  monoeg_g_log (0B, 4, "requested method token for %s\n", D.27036);
  <D.20153>:
  goto <D.20153>;
  <D.27204>:
  <D.26995>:
  token.163 = (void *) token;
  D.27206 = assembly->vararg_aux_hash;
  monoeg_g_hash_table_insert_replace (D.27206, token.163, sig, 0);
  token.163 = (void *) token;
  D.27207 = assembly->tokens;
  mono_g_hash_table_insert (D.27207, token.163, obj);
  D.27208 = token;
  return D.27208;
}


method_encode_signature (struct MonoDynamicImage * assembly, struct MonoMethodSignature * sig)
{
  short unsigned int D.27210;
  int D.27211;
  guint32 D.27214;
  <unnamed-unsigned:6> D.27215;
  unsigned char D.27216;
  unsigned char D.27217;
  short unsigned int D.27220;
  unsigned char D.27223;
  int D.27224;
  unsigned int D.27227;
  struct MonoType * D.27228;
  short int D.27229;
  int D.27230;
  struct MonoType * D.27233;
  unsigned int i.164;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.27210 = sig->param_count;
      nparams = (guint32) D.27210;
      D.27211 = assembly->save;
      if (D.27211 == 0) goto <D.27212>; else goto <D.27213>;
      <D.27212>:
      D.27214 = 0;
      return D.27214;
      <D.27213>:
      sigbuffer_init (&buf, 32);
      D.27215 = sig->call_convention;
      idx = (guint32) D.27215;
      D.27216 = BIT_FIELD_REF <*sig, 8, 80>;
      D.27217 = D.27216 & 64;
      if (D.27217 != 0) goto <D.27218>; else goto <D.27219>;
      <D.27218>:
      idx = idx | 32;
      <D.27219>:
      D.27220 = sig->generic_param_count;
      if (D.27220 != 0) goto <D.27221>; else goto <D.27222>;
      <D.27221>:
      idx = idx | 16;
      <D.27222>:
      D.27223 = (unsigned char) idx;
      D.27224 = (int) D.27223;
      sigbuffer_add_byte (&buf, D.27224);
      D.27220 = sig->generic_param_count;
      if (D.27220 != 0) goto <D.27225>; else goto <D.27226>;
      <D.27225>:
      D.27220 = sig->generic_param_count;
      D.27227 = (unsigned int) D.27220;
      sigbuffer_add_value (&buf, D.27227);
      <D.27226>:
      sigbuffer_add_value (&buf, nparams);
      D.27228 = sig->ret;
      encode_type (assembly, D.27228, &buf);
      i = 0;
      goto <D.18536>;
      <D.18535>:
      D.27229 = sig->sentinelpos;
      D.27230 = (int) D.27229;
      if (D.27230 == i) goto <D.27231>; else goto <D.27232>;
      <D.27231>:
      sigbuffer_add_byte (&buf, 65);
      <D.27232>:
      D.27233 = sig->params[i];
      encode_type (assembly, D.27233, &buf);
      i = i + 1;
      <D.18536>:
      i.164 = (unsigned int) i;
      if (i.164 < nparams) goto <D.18535>; else goto <D.18537>;
      <D.18537>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27214 = idx;
      return D.27214;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_varargs_method_token (struct MonoDynamicImage * assembly, guint32 original, const gchar * name, guint32 sig)
{
  int D.27237;
  unsigned int D.27240;
  unsigned int D.27241;
  guint32 * D.27242;
  unsigned int D.27243;
  unsigned int D.27244;
  guint32 * D.27245;
  struct MonoDynamicStream * D.27246;
  unsigned int D.27247;
  guint32 * D.27248;
  unsigned int D.27249;
  guint32 D.27250;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;

  table = &assembly->tables[10];
  D.27237 = assembly->save;
  if (D.27237 != 0) goto <D.27238>; else goto <D.27239>;
  <D.27238>:
  D.27240 = table->rows;
  D.27241 = D.27240 + 1;
  alloc_table (table, D.27241);
  D.27242 = table->values;
  D.27243 = table->next_idx;
  D.27244 = D.27243 * 12;
  values = D.27242 + D.27244;
  *values = original;
  D.27245 = values + 4;
  D.27246 = &assembly->sheap;
  D.27247 = string_heap_insert (D.27246, name);
  *D.27245 = D.27247;
  D.27248 = values + 8;
  *D.27248 = sig;
  <D.27239>:
  D.27243 = table->next_idx;
  token = D.27243 | 167772160;
  D.27243 = table->next_idx;
  D.27249 = D.27243 + 1;
  table->next_idx = D.27249;
  D.27250 = token;
  return D.27250;
}


mono_image_create_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, gboolean create_open_instance, gboolean register_token)
{
  struct MonoVTable * D.27252;
  struct MonoImage * D.27255;
  struct MonoImage * D.27256;
  int D.20170;
  int iftmp.165;
  int D.20169;
  const char[14] * D.27261;
  unsigned char D.27262;
  int D.27263;
  unsigned char D.27264;
  int D.27265;
  _Bool D.27266;
  _Bool D.27267;
  _Bool D.27268;
  const unsigned char * D.27271;
  unsigned char D.27272;
  int D.27273;
  const unsigned char * D.27274;
  unsigned char D.27275;
  int D.27276;
  _Bool D.27277;
  _Bool D.27278;
  const unsigned char * D.27281;
  unsigned char D.27282;
  int D.27283;
  const unsigned char * D.27284;
  unsigned char D.27285;
  int D.27286;
  _Bool D.27287;
  _Bool D.27288;
  const unsigned char * D.27291;
  unsigned char D.27292;
  int D.27293;
  const unsigned char * D.27294;
  unsigned char D.27295;
  int D.27296;
  const char * D.27298;
  struct MonoException * D.27299;
  int D.20179;
  int iftmp.166;
  int D.20178;
  const char[14] * D.27303;
  unsigned char D.27304;
  int D.27305;
  unsigned char D.27306;
  int D.27307;
  _Bool D.27308;
  _Bool D.27309;
  _Bool D.27310;
  const unsigned char * D.27313;
  unsigned char D.27314;
  int D.27315;
  const unsigned char * D.27316;
  unsigned char D.27317;
  int D.27318;
  _Bool D.27319;
  _Bool D.27320;
  const unsigned char * D.27323;
  unsigned char D.27324;
  int D.27325;
  const unsigned char * D.27326;
  unsigned char D.27327;
  int D.27328;
  _Bool D.27329;
  _Bool D.27330;
  const unsigned char * D.27333;
  unsigned char D.27334;
  int D.27335;
  const unsigned char * D.27336;
  unsigned char D.27337;
  int D.27338;
  struct MonoReflectionModuleBuilder * D.27344;
  struct MonoDynamicImage * D.27345;
  struct MonoArray * D.27347;
  struct MonoArray * D.27349;
  unsigned int D.27351;
  int D.20190;
  int iftmp.167;
  int D.20189;
  const char[19] * D.27356;
  unsigned char D.27357;
  int D.27358;
  unsigned char D.27359;
  int D.27360;
  _Bool D.27361;
  _Bool D.27362;
  _Bool D.27363;
  const unsigned char * D.27366;
  unsigned char D.27367;
  int D.27368;
  const unsigned char * D.27369;
  unsigned char D.27370;
  int D.27371;
  _Bool D.27372;
  _Bool D.27373;
  const unsigned char * D.27376;
  unsigned char D.27377;
  int D.27378;
  const unsigned char * D.27379;
  unsigned char D.27380;
  int D.27381;
  _Bool D.27382;
  _Bool D.27383;
  const unsigned char * D.27386;
  unsigned char D.27387;
  int D.27388;
  const unsigned char * D.27389;
  unsigned char D.27390;
  int D.27391;
  struct MonoReflectionModuleBuilder * D.27397;
  struct MonoDynamicImage * D.27398;
  struct MonoArray * D.27400;
  unsigned int D.27402;
  int D.20201;
  int iftmp.168;
  int D.20200;
  const char[13] * D.27407;
  unsigned char D.27408;
  int D.27409;
  unsigned char D.27410;
  int D.27411;
  _Bool D.27412;
  _Bool D.27413;
  _Bool D.27414;
  const unsigned char * D.27417;
  unsigned char D.27418;
  int D.27419;
  const unsigned char * D.27420;
  unsigned char D.27421;
  int D.27422;
  _Bool D.27423;
  _Bool D.27424;
  const unsigned char * D.27427;
  unsigned char D.27428;
  int D.27429;
  const unsigned char * D.27430;
  unsigned char D.27431;
  int D.27432;
  _Bool D.27433;
  _Bool D.27434;
  const unsigned char * D.27437;
  unsigned char D.27438;
  int D.27439;
  const unsigned char * D.27440;
  unsigned char D.27441;
  int D.27442;
  struct MonoArray * D.27446;
  struct MonoReflectionModuleBuilder * D.27450;
  struct MonoDynamicImage * D.27451;
  int D.27454;
  int D.27455;
  struct MonoClassField * D.27457;
  int D.20212;
  int iftmp.169;
  int D.20211;
  const char[12] * D.27462;
  unsigned char D.27463;
  int D.27464;
  unsigned char D.27465;
  int D.27466;
  _Bool D.27467;
  _Bool D.27468;
  _Bool D.27469;
  const unsigned char * D.27472;
  unsigned char D.27473;
  int D.27474;
  const unsigned char * D.27475;
  unsigned char D.27476;
  int D.27477;
  _Bool D.27478;
  _Bool D.27479;
  const unsigned char * D.27482;
  unsigned char D.27483;
  int D.27484;
  const unsigned char * D.27485;
  unsigned char D.27486;
  int D.27487;
  _Bool D.27488;
  _Bool D.27489;
  const unsigned char * D.27492;
  unsigned char D.27493;
  int D.27494;
  const unsigned char * D.27495;
  unsigned char D.27496;
  int D.27497;
  struct MonoArray * D.27504;
  struct MonoReflectionModuleBuilder * D.27506;
  struct MonoDynamicImage * D.27507;
  unsigned int D.27510;
  unsigned int D.27512;
  int D.20224;
  int iftmp.170;
  int D.20223;
  const char[9] * D.27517;
  unsigned char D.27518;
  int D.27519;
  unsigned char D.27520;
  int D.27521;
  _Bool D.27522;
  _Bool D.27523;
  _Bool D.27524;
  const unsigned char * D.27527;
  unsigned char D.27528;
  int D.27529;
  const unsigned char * D.27530;
  unsigned char D.27531;
  int D.27532;
  _Bool D.27533;
  _Bool D.27534;
  const unsigned char * D.27537;
  unsigned char D.27538;
  int D.27539;
  const unsigned char * D.27540;
  unsigned char D.27541;
  int D.27542;
  _Bool D.27543;
  _Bool D.27544;
  const unsigned char * D.27547;
  unsigned char D.27548;
  int D.27549;
  const unsigned char * D.27550;
  unsigned char D.27551;
  int D.27552;
  int iftmp.171;
  struct MonoGenericContainer * D.27560;
  unsigned int D.27562;
  int D.20235;
  int iftmp.172;
  int D.20234;
  const char[28] * D.27567;
  unsigned char D.27568;
  int D.27569;
  unsigned char D.27570;
  int D.27571;
  _Bool D.27572;
  _Bool D.27573;
  _Bool D.27574;
  const unsigned char * D.27577;
  unsigned char D.27578;
  int D.27579;
  const unsigned char * D.27580;
  unsigned char D.27581;
  int D.27582;
  _Bool D.27583;
  _Bool D.27584;
  const unsigned char * D.27587;
  unsigned char D.27588;
  int D.27589;
  const unsigned char * D.27590;
  unsigned char D.27591;
  int D.27592;
  _Bool D.27593;
  _Bool D.27594;
  const unsigned char * D.27597;
  unsigned char D.27598;
  int D.27599;
  const unsigned char * D.27600;
  unsigned char D.27601;
  int D.27602;
  unsigned int D.27606;
  int D.20245;
  int iftmp.173;
  int D.20244;
  const char[17] * D.27611;
  unsigned char D.27612;
  int D.27613;
  unsigned char D.27614;
  int D.27615;
  _Bool D.27616;
  _Bool D.27617;
  _Bool D.27618;
  const unsigned char * D.27621;
  unsigned char D.27622;
  int D.27623;
  const unsigned char * D.27624;
  unsigned char D.27625;
  int D.27626;
  _Bool D.27627;
  _Bool D.27628;
  const unsigned char * D.27631;
  unsigned char D.27632;
  int D.27633;
  const unsigned char * D.27634;
  unsigned char D.27635;
  int D.27636;
  _Bool D.27637;
  _Bool D.27638;
  const unsigned char * D.27641;
  unsigned char D.27642;
  int D.27643;
  const unsigned char * D.27644;
  unsigned char D.27645;
  int D.27646;
  unsigned int D.27650;
  int D.20255;
  int iftmp.174;
  int D.20254;
  const char[12] * D.27658;
  unsigned char D.27659;
  int D.27660;
  unsigned char D.27661;
  int D.27662;
  _Bool D.27663;
  _Bool D.27664;
  _Bool D.27665;
  const unsigned char * D.27668;
  unsigned char D.27669;
  int D.27670;
  const unsigned char * D.27671;
  unsigned char D.27672;
  int D.27673;
  _Bool D.27674;
  _Bool D.27675;
  const unsigned char * D.27678;
  unsigned char D.27679;
  int D.27680;
  const unsigned char * D.27681;
  unsigned char D.27682;
  int D.27683;
  _Bool D.27684;
  _Bool D.27685;
  const unsigned char * D.27688;
  unsigned char D.27689;
  int D.27690;
  const unsigned char * D.27691;
  unsigned char D.27692;
  int D.27693;
  int D.20264;
  int iftmp.175;
  int D.20263;
  const char[11] * D.27699;
  unsigned char D.27700;
  int D.27701;
  unsigned char D.27702;
  int D.27703;
  _Bool D.27704;
  _Bool D.27705;
  _Bool D.27706;
  const unsigned char * D.27709;
  unsigned char D.27710;
  int D.27711;
  const unsigned char * D.27712;
  unsigned char D.27713;
  int D.27714;
  _Bool D.27715;
  _Bool D.27716;
  const unsigned char * D.27719;
  unsigned char D.27720;
  int D.27721;
  const unsigned char * D.27722;
  unsigned char D.27723;
  int D.27724;
  _Bool D.27725;
  _Bool D.27726;
  const unsigned char * D.27729;
  unsigned char D.27730;
  int D.27731;
  const unsigned char * D.27732;
  unsigned char D.27733;
  int D.27734;
  int D.20273;
  int iftmp.176;
  int D.20272;
  const char[18] * D.27740;
  unsigned char D.27741;
  int D.27742;
  unsigned char D.27743;
  int D.27744;
  _Bool D.27745;
  _Bool D.27746;
  _Bool D.27747;
  const unsigned char * D.27750;
  unsigned char D.27751;
  int D.27752;
  const unsigned char * D.27753;
  unsigned char D.27754;
  int D.27755;
  _Bool D.27756;
  _Bool D.27757;
  const unsigned char * D.27760;
  unsigned char D.27761;
  int D.27762;
  const unsigned char * D.27763;
  unsigned char D.27764;
  int D.27765;
  _Bool D.27766;
  _Bool D.27767;
  const unsigned char * D.27770;
  unsigned char D.27771;
  int D.27772;
  const unsigned char * D.27773;
  unsigned char D.27774;
  int D.27775;
  int D.20282;
  int iftmp.177;
  int D.20281;
  const char[19] * D.27781;
  unsigned char D.27782;
  int D.27783;
  unsigned char D.27784;
  int D.27785;
  _Bool D.27786;
  _Bool D.27787;
  _Bool D.27788;
  const unsigned char * D.27791;
  unsigned char D.27792;
  int D.27793;
  const unsigned char * D.27794;
  unsigned char D.27795;
  int D.27796;
  _Bool D.27797;
  _Bool D.27798;
  const unsigned char * D.27801;
  unsigned char D.27802;
  int D.27803;
  const unsigned char * D.27804;
  unsigned char D.27805;
  int D.27806;
  _Bool D.27807;
  _Bool D.27808;
  const unsigned char * D.27811;
  unsigned char D.27812;
  int D.27813;
  const unsigned char * D.27814;
  unsigned char D.27815;
  int D.27816;
  struct MonoMethod * D.27818;
  unsigned char D.27819;
  unsigned char D.27820;
  struct MonoClass * D.27829;
  struct MonoImage * D.27830;
  struct MonoImage * D.27831;
  struct MonoGenericClass * D.27833;
  unsigned char D.27835;
  unsigned char D.27836;
  unsigned int method_table_idx.178;
  unsigned int method_table_idx.179;
  int D.20293;
  int iftmp.180;
  int D.20292;
  const char[10] * D.27845;
  unsigned char D.27846;
  int D.27847;
  unsigned char D.27848;
  int D.27849;
  _Bool D.27850;
  _Bool D.27851;
  _Bool D.27852;
  const unsigned char * D.27855;
  unsigned char D.27856;
  int D.27857;
  const unsigned char * D.27858;
  unsigned char D.27859;
  int D.27860;
  _Bool D.27861;
  _Bool D.27862;
  const unsigned char * D.27865;
  unsigned char D.27866;
  int D.27867;
  const unsigned char * D.27868;
  unsigned char D.27869;
  int D.27870;
  _Bool D.27871;
  _Bool D.27872;
  const unsigned char * D.27875;
  unsigned char D.27876;
  int D.27877;
  const unsigned char * D.27878;
  unsigned char D.27879;
  int D.27880;
  struct MonoClassField * D.27886;
  struct MonoClass * D.27887;
  struct MonoImage * D.27888;
  int D.27890;
  unsigned int field_table_idx.181;
  unsigned int field_table_idx.182;
  int D.20304;
  int iftmp.183;
  int D.20303;
  const char[16] * D.27898;
  unsigned char D.27899;
  int D.27900;
  unsigned char D.27901;
  int D.27902;
  _Bool D.27903;
  _Bool D.27904;
  _Bool D.27905;
  const unsigned char * D.27908;
  unsigned char D.27909;
  int D.27910;
  const unsigned char * D.27911;
  unsigned char D.27912;
  int D.27913;
  _Bool D.27914;
  _Bool D.27915;
  const unsigned char * D.27918;
  unsigned char D.27919;
  int D.27920;
  const unsigned char * D.27921;
  unsigned char D.27922;
  int D.27923;
  _Bool D.27924;
  _Bool D.27925;
  const unsigned char * D.27928;
  unsigned char D.27929;
  int D.27930;
  const unsigned char * D.27931;
  unsigned char D.27932;
  int D.27933;
  int D.20314;
  int iftmp.184;
  int D.20313;
  const char[16] * D.27941;
  unsigned char D.27942;
  int D.27943;
  unsigned char D.27944;
  int D.27945;
  _Bool D.27946;
  _Bool D.27947;
  _Bool D.27948;
  const unsigned char * D.27951;
  unsigned char D.27952;
  int D.27953;
  const unsigned char * D.27954;
  unsigned char D.27955;
  int D.27956;
  _Bool D.27957;
  _Bool D.27958;
  const unsigned char * D.27961;
  unsigned char D.27962;
  int D.27963;
  const unsigned char * D.27964;
  unsigned char D.27965;
  int D.27966;
  _Bool D.27967;
  _Bool D.27968;
  const unsigned char * D.27971;
  unsigned char D.27972;
  int D.27973;
  const unsigned char * D.27974;
  unsigned char D.27975;
  int D.27976;
  unsigned int D.27980;
  int D.20324;
  int iftmp.185;
  int D.20323;
  const char[12] * D.27985;
  unsigned char D.27986;
  int D.27987;
  unsigned char D.27988;
  int D.27989;
  _Bool D.27990;
  _Bool D.27991;
  _Bool D.27992;
  const unsigned char * D.27995;
  unsigned char D.27996;
  int D.27997;
  const unsigned char * D.27998;
  unsigned char D.27999;
  int D.28000;
  _Bool D.28001;
  _Bool D.28002;
  const unsigned char * D.28005;
  unsigned char D.28006;
  int D.28007;
  const unsigned char * D.28008;
  unsigned char D.28009;
  int D.28010;
  _Bool D.28011;
  _Bool D.28012;
  const unsigned char * D.28015;
  unsigned char D.28016;
  int D.28017;
  const unsigned char * D.28018;
  unsigned char D.28019;
  int D.28020;
  unsigned int D.28024;
  int D.20334;
  int iftmp.186;
  int D.20333;
  const char[23] * D.28029;
  unsigned char D.28030;
  int D.28031;
  unsigned char D.28032;
  int D.28033;
  _Bool D.28034;
  _Bool D.28035;
  _Bool D.28036;
  const unsigned char * D.28039;
  unsigned char D.28040;
  int D.28041;
  const unsigned char * D.28042;
  unsigned char D.28043;
  int D.28044;
  _Bool D.28045;
  _Bool D.28046;
  const unsigned char * D.28049;
  unsigned char D.28050;
  int D.28051;
  const unsigned char * D.28052;
  unsigned char D.28053;
  int D.28054;
  _Bool D.28055;
  _Bool D.28056;
  const unsigned char * D.28059;
  unsigned char D.28060;
  int D.28061;
  const unsigned char * D.28062;
  unsigned char D.28063;
  int D.28064;
  int D.20344;
  int iftmp.187;
  int D.20343;
  const char[29] * D.28072;
  unsigned char D.28073;
  int D.28074;
  unsigned char D.28075;
  int D.28076;
  _Bool D.28077;
  _Bool D.28078;
  _Bool D.28079;
  const unsigned char * D.28082;
  unsigned char D.28083;
  int D.28084;
  const unsigned char * D.28085;
  unsigned char D.28086;
  int D.28087;
  _Bool D.28088;
  _Bool D.28089;
  const unsigned char * D.28092;
  unsigned char D.28093;
  int D.28094;
  const unsigned char * D.28095;
  unsigned char D.28096;
  int D.28097;
  _Bool D.28098;
  _Bool D.28099;
  const unsigned char * D.28102;
  unsigned char D.28103;
  int D.28104;
  const unsigned char * D.28105;
  unsigned char D.28106;
  int D.28107;
  int D.20354;
  int iftmp.188;
  int D.20353;
  const char[24] * D.28115;
  unsigned char D.28116;
  int D.28117;
  unsigned char D.28118;
  int D.28119;
  _Bool D.28120;
  _Bool D.28121;
  _Bool D.28122;
  const unsigned char * D.28125;
  unsigned char D.28126;
  int D.28127;
  const unsigned char * D.28128;
  unsigned char D.28129;
  int D.28130;
  _Bool D.28131;
  _Bool D.28132;
  const unsigned char * D.28135;
  unsigned char D.28136;
  int D.28137;
  const unsigned char * D.28138;
  unsigned char D.28139;
  int D.28140;
  _Bool D.28141;
  _Bool D.28142;
  const unsigned char * D.28145;
  unsigned char D.28146;
  int D.28147;
  const unsigned char * D.28148;
  unsigned char D.28149;
  int D.28150;
  int D.28158;
  int D.28160;
  int D.28162;
  struct MonoType * D.28163;
  unsigned int D.28164;
  guint32 D.28167;
  struct MonoClass * klass;
  guint32 token;

  token = 0;
  D.27252 = obj->vtable;
  klass = D.27252->klass;
  D.27255 = klass->image;
  D.27256 = mono_defaults.corlib;
  if (D.27255 != D.27256) goto <D.27253>; else goto <D.27257>;
  <D.27257>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27261 = "TypeDelegator";
      D.27262 = MEM[(const unsigned char *)D.27261];
      D.27263 = (int) D.27262;
      D.27264 = *__s2;
      D.27265 = (int) D.27264;
      __result = D.27263 - D.27265;
      {
        D.27266 = __s2_len != 0;
        D.27267 = __result == 0;
        D.27268 = D.27266 & D.27267;
        if (D.27268 != 0) goto <D.27269>; else goto <D.27270>;
        <D.27269>:
        D.27271 = &MEM[(void *)"TypeDelegator" + 1B];
        D.27272 = *D.27271;
        D.27273 = (int) D.27272;
        D.27274 = __s2 + 1;
        D.27275 = *D.27274;
        D.27276 = (int) D.27275;
        __result = D.27273 - D.27276;
        D.27277 = __s2_len > 1;
        D.27267 = __result == 0;
        D.27278 = D.27277 & D.27267;
        if (D.27278 != 0) goto <D.27279>; else goto <D.27280>;
        <D.27279>:
        D.27281 = &MEM[(void *)"TypeDelegator" + 2B];
        D.27282 = *D.27281;
        D.27283 = (int) D.27282;
        D.27284 = __s2 + 2;
        D.27285 = *D.27284;
        D.27286 = (int) D.27285;
        __result = D.27283 - D.27286;
        D.27287 = __s2_len > 2;
        D.27267 = __result == 0;
        D.27288 = D.27287 & D.27267;
        if (D.27288 != 0) goto <D.27289>; else goto <D.27290>;
        <D.27289>:
        D.27291 = &MEM[(void *)"TypeDelegator" + 3B];
        D.27292 = *D.27291;
        D.27293 = (int) D.27292;
        D.27294 = __s2 + 3;
        D.27295 = *D.27294;
        D.27296 = (int) D.27295;
        __result = D.27293 - D.27296;
        <D.27290>:
        <D.27280>:
        <D.27270>:
      }
      D.20169 = __result;
    }
    iftmp.165 = -D.20169;
    goto <D.27297>;
    <D.27260>:
    D.27298 = klass->name;
    iftmp.165 = __builtin_strcmp (D.27298, "TypeDelegator");
    <D.27297>:
    D.20170 = iftmp.165;
  }
  if (D.20170 == 0) goto <D.27253>; else goto <D.27254>;
  <D.27253>:
  D.27299 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported");
  mono_raise_exception (D.27299);
  <D.27254>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27303 = "MethodBuilder";
      D.27304 = MEM[(const unsigned char *)D.27303];
      D.27305 = (int) D.27304;
      D.27306 = *__s2;
      D.27307 = (int) D.27306;
      __result = D.27305 - D.27307;
      {
        D.27308 = __s2_len != 0;
        D.27309 = __result == 0;
        D.27310 = D.27308 & D.27309;
        if (D.27310 != 0) goto <D.27311>; else goto <D.27312>;
        <D.27311>:
        D.27313 = &MEM[(void *)"MethodBuilder" + 1B];
        D.27314 = *D.27313;
        D.27315 = (int) D.27314;
        D.27316 = __s2 + 1;
        D.27317 = *D.27316;
        D.27318 = (int) D.27317;
        __result = D.27315 - D.27318;
        D.27319 = __s2_len > 1;
        D.27309 = __result == 0;
        D.27320 = D.27319 & D.27309;
        if (D.27320 != 0) goto <D.27321>; else goto <D.27322>;
        <D.27321>:
        D.27323 = &MEM[(void *)"MethodBuilder" + 2B];
        D.27324 = *D.27323;
        D.27325 = (int) D.27324;
        D.27326 = __s2 + 2;
        D.27327 = *D.27326;
        D.27328 = (int) D.27327;
        __result = D.27325 - D.27328;
        D.27329 = __s2_len > 2;
        D.27309 = __result == 0;
        D.27330 = D.27329 & D.27309;
        if (D.27330 != 0) goto <D.27331>; else goto <D.27332>;
        <D.27331>:
        D.27333 = &MEM[(void *)"MethodBuilder" + 3B];
        D.27334 = *D.27333;
        D.27335 = (int) D.27334;
        D.27336 = __s2 + 3;
        D.27337 = *D.27336;
        D.27338 = (int) D.27337;
        __result = D.27335 - D.27338;
        <D.27332>:
        <D.27322>:
        <D.27312>:
      }
      D.20178 = __result;
    }
    iftmp.166 = -D.20178;
    goto <D.27339>;
    <D.27302>:
    D.27298 = klass->name;
    iftmp.166 = __builtin_strcmp (D.27298, "MethodBuilder");
    <D.27339>:
    D.20179 = iftmp.166;
  }
  if (D.20179 == 0) goto <D.27340>; else goto <D.27341>;
  <D.27340>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.27344 = tb->module;
    D.27345 = D.27344->dynamic_image;
    if (D.27345 == assembly) goto <D.27346>; else goto <D.27342>;
    <D.27346>:
    D.27347 = tb->generic_params;
    if (D.27347 == 0B) goto <D.27348>; else goto <D.27342>;
    <D.27348>:
    D.27349 = mb->generic_params;
    if (D.27349 == 0B) goto <D.27350>; else goto <D.27342>;
    <D.27350>:
    D.27351 = mb->table_idx;
    token = D.27351 | 100663296;
    goto <D.27343>;
    <D.27342>:
    token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
    <D.27343>:
  }
  goto <D.27352>;
  <D.27341>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27356 = "ConstructorBuilder";
      D.27357 = MEM[(const unsigned char *)D.27356];
      D.27358 = (int) D.27357;
      D.27359 = *__s2;
      D.27360 = (int) D.27359;
      __result = D.27358 - D.27360;
      {
        D.27361 = __s2_len != 0;
        D.27362 = __result == 0;
        D.27363 = D.27361 & D.27362;
        if (D.27363 != 0) goto <D.27364>; else goto <D.27365>;
        <D.27364>:
        D.27366 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.27367 = *D.27366;
        D.27368 = (int) D.27367;
        D.27369 = __s2 + 1;
        D.27370 = *D.27369;
        D.27371 = (int) D.27370;
        __result = D.27368 - D.27371;
        D.27372 = __s2_len > 1;
        D.27362 = __result == 0;
        D.27373 = D.27372 & D.27362;
        if (D.27373 != 0) goto <D.27374>; else goto <D.27375>;
        <D.27374>:
        D.27376 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.27377 = *D.27376;
        D.27378 = (int) D.27377;
        D.27379 = __s2 + 2;
        D.27380 = *D.27379;
        D.27381 = (int) D.27380;
        __result = D.27378 - D.27381;
        D.27382 = __s2_len > 2;
        D.27362 = __result == 0;
        D.27383 = D.27382 & D.27362;
        if (D.27383 != 0) goto <D.27384>; else goto <D.27385>;
        <D.27384>:
        D.27386 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.27387 = *D.27386;
        D.27388 = (int) D.27387;
        D.27389 = __s2 + 3;
        D.27390 = *D.27389;
        D.27391 = (int) D.27390;
        __result = D.27388 - D.27391;
        <D.27385>:
        <D.27375>:
        <D.27365>:
      }
      D.20189 = __result;
    }
    iftmp.167 = -D.20189;
    goto <D.27392>;
    <D.27355>:
    D.27298 = klass->name;
    iftmp.167 = __builtin_strcmp (D.27298, "ConstructorBuilder");
    <D.27392>:
    D.20190 = iftmp.167;
  }
  if (D.20190 == 0) goto <D.27393>; else goto <D.27394>;
  <D.27393>:
  {
    struct MonoReflectionCtorBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.27397 = tb->module;
    D.27398 = D.27397->dynamic_image;
    if (D.27398 == assembly) goto <D.27399>; else goto <D.27395>;
    <D.27399>:
    D.27400 = tb->generic_params;
    if (D.27400 == 0B) goto <D.27401>; else goto <D.27395>;
    <D.27401>:
    D.27402 = mb->table_idx;
    token = D.27402 | 100663296;
    goto <D.27396>;
    <D.27395>:
    token = mono_image_get_ctorbuilder_token (assembly, mb);
    <D.27396>:
  }
  goto <D.27403>;
  <D.27394>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27407 = "FieldBuilder";
      D.27408 = MEM[(const unsigned char *)D.27407];
      D.27409 = (int) D.27408;
      D.27410 = *__s2;
      D.27411 = (int) D.27410;
      __result = D.27409 - D.27411;
      {
        D.27412 = __s2_len != 0;
        D.27413 = __result == 0;
        D.27414 = D.27412 & D.27413;
        if (D.27414 != 0) goto <D.27415>; else goto <D.27416>;
        <D.27415>:
        D.27417 = &MEM[(void *)"FieldBuilder" + 1B];
        D.27418 = *D.27417;
        D.27419 = (int) D.27418;
        D.27420 = __s2 + 1;
        D.27421 = *D.27420;
        D.27422 = (int) D.27421;
        __result = D.27419 - D.27422;
        D.27423 = __s2_len > 1;
        D.27413 = __result == 0;
        D.27424 = D.27423 & D.27413;
        if (D.27424 != 0) goto <D.27425>; else goto <D.27426>;
        <D.27425>:
        D.27427 = &MEM[(void *)"FieldBuilder" + 2B];
        D.27428 = *D.27427;
        D.27429 = (int) D.27428;
        D.27430 = __s2 + 2;
        D.27431 = *D.27430;
        D.27432 = (int) D.27431;
        __result = D.27429 - D.27432;
        D.27433 = __s2_len > 2;
        D.27413 = __result == 0;
        D.27434 = D.27433 & D.27413;
        if (D.27434 != 0) goto <D.27435>; else goto <D.27436>;
        <D.27435>:
        D.27437 = &MEM[(void *)"FieldBuilder" + 3B];
        D.27438 = *D.27437;
        D.27439 = (int) D.27438;
        D.27440 = __s2 + 3;
        D.27441 = *D.27440;
        D.27442 = (int) D.27441;
        __result = D.27439 - D.27442;
        <D.27436>:
        <D.27426>:
        <D.27416>:
      }
      D.20200 = __result;
    }
    iftmp.168 = -D.20200;
    goto <D.27443>;
    <D.27406>:
    D.27298 = klass->name;
    iftmp.168 = __builtin_strcmp (D.27298, "FieldBuilder");
    <D.27443>:
    D.20201 = iftmp.168;
  }
  if (D.20201 == 0) goto <D.27444>; else goto <D.27445>;
  <D.27444>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoReflectionTypeBuilder * tb;

    fb = obj;
    tb = fb->typeb;
    D.27446 = tb->generic_params;
    if (D.27446 != 0B) goto <D.27447>; else goto <D.27448>;
    <D.27447>:
    token = mono_image_get_generic_field_token (assembly, fb);
    goto <D.27449>;
    <D.27448>:
    D.27450 = tb->module;
    D.27451 = D.27450->dynamic_image;
    if (D.27451 == assembly) goto <D.27452>; else goto <D.27453>;
    <D.27452>:
    D.27454 = fb->table_idx;
    D.27455 = D.27454 | 67108864;
    token = (guint32) D.27455;
    goto <D.27456>;
    <D.27453>:
    D.27457 = fb->handle;
    token = mono_image_get_fieldref_token (assembly, fb, D.27457);
    <D.27456>:
    <D.27449>:
  }
  goto <D.27458>;
  <D.27445>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27462 = "TypeBuilder";
      D.27463 = MEM[(const unsigned char *)D.27462];
      D.27464 = (int) D.27463;
      D.27465 = *__s2;
      D.27466 = (int) D.27465;
      __result = D.27464 - D.27466;
      {
        D.27467 = __s2_len != 0;
        D.27468 = __result == 0;
        D.27469 = D.27467 & D.27468;
        if (D.27469 != 0) goto <D.27470>; else goto <D.27471>;
        <D.27470>:
        D.27472 = &MEM[(void *)"TypeBuilder" + 1B];
        D.27473 = *D.27472;
        D.27474 = (int) D.27473;
        D.27475 = __s2 + 1;
        D.27476 = *D.27475;
        D.27477 = (int) D.27476;
        __result = D.27474 - D.27477;
        D.27478 = __s2_len > 1;
        D.27468 = __result == 0;
        D.27479 = D.27478 & D.27468;
        if (D.27479 != 0) goto <D.27480>; else goto <D.27481>;
        <D.27480>:
        D.27482 = &MEM[(void *)"TypeBuilder" + 2B];
        D.27483 = *D.27482;
        D.27484 = (int) D.27483;
        D.27485 = __s2 + 2;
        D.27486 = *D.27485;
        D.27487 = (int) D.27486;
        __result = D.27484 - D.27487;
        D.27488 = __s2_len > 2;
        D.27468 = __result == 0;
        D.27489 = D.27488 & D.27468;
        if (D.27489 != 0) goto <D.27490>; else goto <D.27491>;
        <D.27490>:
        D.27492 = &MEM[(void *)"TypeBuilder" + 3B];
        D.27493 = *D.27492;
        D.27494 = (int) D.27493;
        D.27495 = __s2 + 3;
        D.27496 = *D.27495;
        D.27497 = (int) D.27496;
        __result = D.27494 - D.27497;
        <D.27491>:
        <D.27481>:
        <D.27471>:
      }
      D.20211 = __result;
    }
    iftmp.169 = -D.20211;
    goto <D.27498>;
    <D.27461>:
    D.27298 = klass->name;
    iftmp.169 = __builtin_strcmp (D.27298, "TypeBuilder");
    <D.27498>:
    D.20212 = iftmp.169;
  }
  if (D.20212 == 0) goto <D.27499>; else goto <D.27500>;
  <D.27499>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    if (create_open_instance != 0) goto <D.27503>; else goto <D.27501>;
    <D.27503>:
    D.27504 = tb->generic_params;
    if (D.27504 != 0B) goto <D.27505>; else goto <D.27501>;
    <D.27505>:
    {
      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.27502>;
    <D.27501>:
    D.27506 = tb->module;
    D.27507 = D.27506->dynamic_image;
    if (D.27507 == assembly) goto <D.27508>; else goto <D.27509>;
    <D.27508>:
    D.27510 = tb->table_idx;
    token = D.27510 | 33554432;
    goto <D.27511>;
    <D.27509>:
    {
      struct MonoType * type;

      type = mono_reflection_type_get_handle (obj);
      D.27512 = mono_image_typedef_or_ref (assembly, type);
      token = mono_metadata_token_from_dor (D.27512);
    }
    <D.27511>:
    <D.27502>:
  }
  goto <D.27513>;
  <D.27500>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27517 = "MonoType";
      D.27518 = MEM[(const unsigned char *)D.27517];
      D.27519 = (int) D.27518;
      D.27520 = *__s2;
      D.27521 = (int) D.27520;
      __result = D.27519 - D.27521;
      {
        D.27522 = __s2_len != 0;
        D.27523 = __result == 0;
        D.27524 = D.27522 & D.27523;
        if (D.27524 != 0) goto <D.27525>; else goto <D.27526>;
        <D.27525>:
        D.27527 = &MEM[(void *)"MonoType" + 1B];
        D.27528 = *D.27527;
        D.27529 = (int) D.27528;
        D.27530 = __s2 + 1;
        D.27531 = *D.27530;
        D.27532 = (int) D.27531;
        __result = D.27529 - D.27532;
        D.27533 = __s2_len > 1;
        D.27523 = __result == 0;
        D.27534 = D.27533 & D.27523;
        if (D.27534 != 0) goto <D.27535>; else goto <D.27536>;
        <D.27535>:
        D.27537 = &MEM[(void *)"MonoType" + 2B];
        D.27538 = *D.27537;
        D.27539 = (int) D.27538;
        D.27540 = __s2 + 2;
        D.27541 = *D.27540;
        D.27542 = (int) D.27541;
        __result = D.27539 - D.27542;
        D.27543 = __s2_len > 2;
        D.27523 = __result == 0;
        D.27544 = D.27543 & D.27523;
        if (D.27544 != 0) goto <D.27545>; else goto <D.27546>;
        <D.27545>:
        D.27547 = &MEM[(void *)"MonoType" + 3B];
        D.27548 = *D.27547;
        D.27549 = (int) D.27548;
        D.27550 = __s2 + 3;
        D.27551 = *D.27550;
        D.27552 = (int) D.27551;
        __result = D.27549 - D.27552;
        <D.27546>:
        <D.27536>:
        <D.27526>:
      }
      D.20223 = __result;
    }
    iftmp.170 = -D.20223;
    goto <D.27553>;
    <D.27516>:
    D.27298 = klass->name;
    iftmp.170 = __builtin_strcmp (D.27298, "MonoType");
    <D.27553>:
    D.20224 = iftmp.170;
  }
  if (D.20224 == 0) goto <D.27554>; else goto <D.27555>;
  <D.27554>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.27560 = mc->generic_container;
    if (D.27560 == 0B) goto <D.27557>; else goto <D.27561>;
    <D.27561>:
    if (create_open_instance != 0) goto <D.27557>; else goto <D.27558>;
    <D.27557>:
    iftmp.171 = 1;
    goto <D.27559>;
    <D.27558>:
    iftmp.171 = 0;
    <D.27559>:
    D.27562 = mono_image_typedef_or_ref_full (assembly, type, iftmp.171);
    token = mono_metadata_token_from_dor (D.27562);
  }
  goto <D.27563>;
  <D.27555>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27567 = "GenericTypeParameterBuilder";
      D.27568 = MEM[(const unsigned char *)D.27567];
      D.27569 = (int) D.27568;
      D.27570 = *__s2;
      D.27571 = (int) D.27570;
      __result = D.27569 - D.27571;
      {
        D.27572 = __s2_len != 0;
        D.27573 = __result == 0;
        D.27574 = D.27572 & D.27573;
        if (D.27574 != 0) goto <D.27575>; else goto <D.27576>;
        <D.27575>:
        D.27577 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.27578 = *D.27577;
        D.27579 = (int) D.27578;
        D.27580 = __s2 + 1;
        D.27581 = *D.27580;
        D.27582 = (int) D.27581;
        __result = D.27579 - D.27582;
        D.27583 = __s2_len > 1;
        D.27573 = __result == 0;
        D.27584 = D.27583 & D.27573;
        if (D.27584 != 0) goto <D.27585>; else goto <D.27586>;
        <D.27585>:
        D.27587 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.27588 = *D.27587;
        D.27589 = (int) D.27588;
        D.27590 = __s2 + 2;
        D.27591 = *D.27590;
        D.27592 = (int) D.27591;
        __result = D.27589 - D.27592;
        D.27593 = __s2_len > 2;
        D.27573 = __result == 0;
        D.27594 = D.27593 & D.27573;
        if (D.27594 != 0) goto <D.27595>; else goto <D.27596>;
        <D.27595>:
        D.27597 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.27598 = *D.27597;
        D.27599 = (int) D.27598;
        D.27600 = __s2 + 3;
        D.27601 = *D.27600;
        D.27602 = (int) D.27601;
        __result = D.27599 - D.27602;
        <D.27596>:
        <D.27586>:
        <D.27576>:
      }
      D.20234 = __result;
    }
    iftmp.172 = -D.20234;
    goto <D.27603>;
    <D.27566>:
    D.27298 = klass->name;
    iftmp.172 = __builtin_strcmp (D.27298, "GenericTypeParameterBuilder");
    <D.27603>:
    D.20235 = iftmp.172;
  }
  if (D.20235 == 0) goto <D.27604>; else goto <D.27605>;
  <D.27604>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.27606 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.27606);
  }
  goto <D.27607>;
  <D.27605>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27611 = "MonoGenericClass";
      D.27612 = MEM[(const unsigned char *)D.27611];
      D.27613 = (int) D.27612;
      D.27614 = *__s2;
      D.27615 = (int) D.27614;
      __result = D.27613 - D.27615;
      {
        D.27616 = __s2_len != 0;
        D.27617 = __result == 0;
        D.27618 = D.27616 & D.27617;
        if (D.27618 != 0) goto <D.27619>; else goto <D.27620>;
        <D.27619>:
        D.27621 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.27622 = *D.27621;
        D.27623 = (int) D.27622;
        D.27624 = __s2 + 1;
        D.27625 = *D.27624;
        D.27626 = (int) D.27625;
        __result = D.27623 - D.27626;
        D.27627 = __s2_len > 1;
        D.27617 = __result == 0;
        D.27628 = D.27627 & D.27617;
        if (D.27628 != 0) goto <D.27629>; else goto <D.27630>;
        <D.27629>:
        D.27631 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.27632 = *D.27631;
        D.27633 = (int) D.27632;
        D.27634 = __s2 + 2;
        D.27635 = *D.27634;
        D.27636 = (int) D.27635;
        __result = D.27633 - D.27636;
        D.27637 = __s2_len > 2;
        D.27617 = __result == 0;
        D.27638 = D.27637 & D.27617;
        if (D.27638 != 0) goto <D.27639>; else goto <D.27640>;
        <D.27639>:
        D.27641 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.27642 = *D.27641;
        D.27643 = (int) D.27642;
        D.27644 = __s2 + 3;
        D.27645 = *D.27644;
        D.27646 = (int) D.27645;
        __result = D.27643 - D.27646;
        <D.27640>:
        <D.27630>:
        <D.27620>:
      }
      D.20244 = __result;
    }
    iftmp.173 = -D.20244;
    goto <D.27647>;
    <D.27610>:
    D.27298 = klass->name;
    iftmp.173 = __builtin_strcmp (D.27298, "MonoGenericClass");
    <D.27647>:
    D.20245 = iftmp.173;
  }
  if (D.20245 == 0) goto <D.27648>; else goto <D.27649>;
  <D.27648>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.27650 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.27650);
  }
  goto <D.27651>;
  <D.27649>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

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

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

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

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

      __s2 = klass->name;
      D.27781 = "MonoGenericCMethod";
      D.27782 = MEM[(const unsigned char *)D.27781];
      D.27783 = (int) D.27782;
      D.27784 = *__s2;
      D.27785 = (int) D.27784;
      __result = D.27783 - D.27785;
      {
        D.27786 = __s2_len != 0;
        D.27787 = __result == 0;
        D.27788 = D.27786 & D.27787;
        if (D.27788 != 0) goto <D.27789>; else goto <D.27790>;
        <D.27789>:
        D.27791 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.27792 = *D.27791;
        D.27793 = (int) D.27792;
        D.27794 = __s2 + 1;
        D.27795 = *D.27794;
        D.27796 = (int) D.27795;
        __result = D.27793 - D.27796;
        D.27797 = __s2_len > 1;
        D.27787 = __result == 0;
        D.27798 = D.27797 & D.27787;
        if (D.27798 != 0) goto <D.27799>; else goto <D.27800>;
        <D.27799>:
        D.27801 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.27802 = *D.27801;
        D.27803 = (int) D.27802;
        D.27804 = __s2 + 2;
        D.27805 = *D.27804;
        D.27806 = (int) D.27805;
        __result = D.27803 - D.27806;
        D.27807 = __s2_len > 2;
        D.27787 = __result == 0;
        D.27808 = D.27807 & D.27787;
        if (D.27808 != 0) goto <D.27809>; else goto <D.27810>;
        <D.27809>:
        D.27811 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.27812 = *D.27811;
        D.27813 = (int) D.27812;
        D.27814 = __s2 + 3;
        D.27815 = *D.27814;
        D.27816 = (int) D.27815;
        __result = D.27813 - D.27816;
        <D.27810>:
        <D.27800>:
        <D.27790>:
      }
      D.20281 = __result;
    }
    iftmp.177 = -D.20281;
    goto <D.27817>;
    <D.27780>:
    D.27298 = klass->name;
    iftmp.177 = __builtin_strcmp (D.27298, "MonoGenericCMethod");
    <D.27817>:
    D.20282 = iftmp.177;
  }
  if (D.20282 == 0) goto <D.27652>; else goto <D.27653>;
  <D.27652>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.27818 = m->method;
    D.27819 = BIT_FIELD_REF <*D.27818, 8, 168>;
    D.27820 = D.27819 & 16;
    if (D.27820 != 0) goto <D.27821>; else goto <D.27822>;
    <D.27821>:
    if (create_open_instance != 0) goto <D.27823>; else goto <D.27824>;
    <D.27823>:
    D.27818 = m->method;
    token = mono_image_get_methodspec_token (assembly, D.27818);
    goto <D.27825>;
    <D.27824>:
    D.27818 = m->method;
    token = mono_image_get_inflated_method_token (assembly, D.27818);
    <D.27825>:
    goto <D.27826>;
    <D.27822>:
    D.27818 = m->method;
    D.27829 = D.27818->klass;
    D.27830 = D.27829->image;
    D.27831 = &assembly->image;
    if (D.27830 == D.27831) goto <D.27832>; else goto <D.27827>;
    <D.27832>:
    D.27818 = m->method;
    D.27829 = D.27818->klass;
    D.27833 = D.27829->generic_class;
    if (D.27833 == 0B) goto <D.27834>; else goto <D.27827>;
    <D.27834>:
    {
      static guint32 method_table_idx = 16777215;

      D.27818 = m->method;
      D.27829 = D.27818->klass;
      D.27835 = BIT_FIELD_REF <*D.27829, 8, 160>;
      D.27836 = D.27835 & 128;
      if (D.27836 != 0) goto <D.27837>; else goto <D.27838>;
      <D.27837>:
      D.27818 = m->method;
      token = D.27818->token;
      goto <D.27839>;
      <D.27838>:
      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.27839>:
    }
    goto <D.27828>;
    <D.27827>:
    D.27818 = m->method;
    token = mono_image_get_methodref_token (assembly, D.27818, create_open_instance);
    <D.27828>:
    <D.27826>:
  }
  goto <D.27654>;
  <D.27653>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27845 = "MonoField";
      D.27846 = MEM[(const unsigned char *)D.27845];
      D.27847 = (int) D.27846;
      D.27848 = *__s2;
      D.27849 = (int) D.27848;
      __result = D.27847 - D.27849;
      {
        D.27850 = __s2_len != 0;
        D.27851 = __result == 0;
        D.27852 = D.27850 & D.27851;
        if (D.27852 != 0) goto <D.27853>; else goto <D.27854>;
        <D.27853>:
        D.27855 = &MEM[(void *)"MonoField" + 1B];
        D.27856 = *D.27855;
        D.27857 = (int) D.27856;
        D.27858 = __s2 + 1;
        D.27859 = *D.27858;
        D.27860 = (int) D.27859;
        __result = D.27857 - D.27860;
        D.27861 = __s2_len > 1;
        D.27851 = __result == 0;
        D.27862 = D.27861 & D.27851;
        if (D.27862 != 0) goto <D.27863>; else goto <D.27864>;
        <D.27863>:
        D.27865 = &MEM[(void *)"MonoField" + 2B];
        D.27866 = *D.27865;
        D.27867 = (int) D.27866;
        D.27868 = __s2 + 2;
        D.27869 = *D.27868;
        D.27870 = (int) D.27869;
        __result = D.27867 - D.27870;
        D.27871 = __s2_len > 2;
        D.27851 = __result == 0;
        D.27872 = D.27871 & D.27851;
        if (D.27872 != 0) goto <D.27873>; else goto <D.27874>;
        <D.27873>:
        D.27875 = &MEM[(void *)"MonoField" + 3B];
        D.27876 = *D.27875;
        D.27877 = (int) D.27876;
        D.27878 = __s2 + 3;
        D.27879 = *D.27878;
        D.27880 = (int) D.27879;
        __result = D.27877 - D.27880;
        <D.27874>:
        <D.27864>:
        <D.27854>:
      }
      D.20292 = __result;
    }
    iftmp.180 = -D.20292;
    goto <D.27881>;
    <D.27844>:
    D.27298 = klass->name;
    iftmp.180 = __builtin_strcmp (D.27298, "MonoField");
    <D.27881>:
    D.20293 = iftmp.180;
  }
  if (D.20293 == 0) goto <D.27882>; else goto <D.27883>;
  <D.27882>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.27886 = f->field;
    D.27887 = D.27886->parent;
    D.27888 = D.27887->image;
    D.27831 = &assembly->image;
    if (D.27888 == D.27831) goto <D.27889>; else goto <D.27884>;
    <D.27889>:
    D.27886 = f->field;
    D.27890 = is_field_on_inst (D.27886);
    if (D.27890 == 0) goto <D.27891>; else goto <D.27884>;
    <D.27891>:
    {
      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.27885>;
    <D.27884>:
    D.27886 = f->field;
    token = mono_image_get_fieldref_token (assembly, f, D.27886);
    <D.27885>:
  }
  goto <D.27894>;
  <D.27883>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27898 = "MonoArrayMethod";
      D.27899 = MEM[(const unsigned char *)D.27898];
      D.27900 = (int) D.27899;
      D.27901 = *__s2;
      D.27902 = (int) D.27901;
      __result = D.27900 - D.27902;
      {
        D.27903 = __s2_len != 0;
        D.27904 = __result == 0;
        D.27905 = D.27903 & D.27904;
        if (D.27905 != 0) goto <D.27906>; else goto <D.27907>;
        <D.27906>:
        D.27908 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.27909 = *D.27908;
        D.27910 = (int) D.27909;
        D.27911 = __s2 + 1;
        D.27912 = *D.27911;
        D.27913 = (int) D.27912;
        __result = D.27910 - D.27913;
        D.27914 = __s2_len > 1;
        D.27904 = __result == 0;
        D.27915 = D.27914 & D.27904;
        if (D.27915 != 0) goto <D.27916>; else goto <D.27917>;
        <D.27916>:
        D.27918 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.27919 = *D.27918;
        D.27920 = (int) D.27919;
        D.27921 = __s2 + 2;
        D.27922 = *D.27921;
        D.27923 = (int) D.27922;
        __result = D.27920 - D.27923;
        D.27924 = __s2_len > 2;
        D.27904 = __result == 0;
        D.27925 = D.27924 & D.27904;
        if (D.27925 != 0) goto <D.27926>; else goto <D.27927>;
        <D.27926>:
        D.27928 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.27929 = *D.27928;
        D.27930 = (int) D.27929;
        D.27931 = __s2 + 3;
        D.27932 = *D.27931;
        D.27933 = (int) D.27932;
        __result = D.27930 - D.27933;
        <D.27927>:
        <D.27917>:
        <D.27907>:
      }
      D.20303 = __result;
    }
    iftmp.183 = -D.20303;
    goto <D.27934>;
    <D.27897>:
    D.27298 = klass->name;
    iftmp.183 = __builtin_strcmp (D.27298, "MonoArrayMethod");
    <D.27934>:
    D.20304 = iftmp.183;
  }
  if (D.20304 == 0) goto <D.27935>; else goto <D.27936>;
  <D.27935>:
  {
    struct MonoReflectionArrayMethod * m;

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

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

      __s2 = klass->name;
      D.27941 = "SignatureHelper";
      D.27942 = MEM[(const unsigned char *)D.27941];
      D.27943 = (int) D.27942;
      D.27944 = *__s2;
      D.27945 = (int) D.27944;
      __result = D.27943 - D.27945;
      {
        D.27946 = __s2_len != 0;
        D.27947 = __result == 0;
        D.27948 = D.27946 & D.27947;
        if (D.27948 != 0) goto <D.27949>; else goto <D.27950>;
        <D.27949>:
        D.27951 = &MEM[(void *)"SignatureHelper" + 1B];
        D.27952 = *D.27951;
        D.27953 = (int) D.27952;
        D.27954 = __s2 + 1;
        D.27955 = *D.27954;
        D.27956 = (int) D.27955;
        __result = D.27953 - D.27956;
        D.27957 = __s2_len > 1;
        D.27947 = __result == 0;
        D.27958 = D.27957 & D.27947;
        if (D.27958 != 0) goto <D.27959>; else goto <D.27960>;
        <D.27959>:
        D.27961 = &MEM[(void *)"SignatureHelper" + 2B];
        D.27962 = *D.27961;
        D.27963 = (int) D.27962;
        D.27964 = __s2 + 2;
        D.27965 = *D.27964;
        D.27966 = (int) D.27965;
        __result = D.27963 - D.27966;
        D.27967 = __s2_len > 2;
        D.27947 = __result == 0;
        D.27968 = D.27967 & D.27947;
        if (D.27968 != 0) goto <D.27969>; else goto <D.27970>;
        <D.27969>:
        D.27971 = &MEM[(void *)"SignatureHelper" + 3B];
        D.27972 = *D.27971;
        D.27973 = (int) D.27972;
        D.27974 = __s2 + 3;
        D.27975 = *D.27974;
        D.27976 = (int) D.27975;
        __result = D.27973 - D.27976;
        <D.27970>:
        <D.27960>:
        <D.27950>:
      }
      D.20313 = __result;
    }
    iftmp.184 = -D.20313;
    goto <D.27977>;
    <D.27940>:
    D.27298 = klass->name;
    iftmp.184 = __builtin_strcmp (D.27298, "SignatureHelper");
    <D.27977>:
    D.20314 = iftmp.184;
  }
  if (D.20314 == 0) goto <D.27978>; else goto <D.27979>;
  <D.27978>:
  {
    struct MonoReflectionSigHelper * s;

    s = obj;
    D.27980 = mono_image_get_sighelper_token (assembly, s);
    token = D.27980 | 285212672;
  }
  goto <D.27981>;
  <D.27979>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

    type = mono_reflection_type_get_handle (obj);
    D.28024 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28024);
  }
  goto <D.28025>;
  <D.28023>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28029 = "FieldOnTypeBuilderInst";
      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;
      {
        D.28034 = __s2_len != 0;
        D.28035 = __result == 0;
        D.28036 = D.28034 & D.28035;
        if (D.28036 != 0) goto <D.28037>; else goto <D.28038>;
        <D.28037>:
        D.28039 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.28040 = *D.28039;
        D.28041 = (int) D.28040;
        D.28042 = __s2 + 1;
        D.28043 = *D.28042;
        D.28044 = (int) D.28043;
        __result = D.28041 - D.28044;
        D.28045 = __s2_len > 1;
        D.28035 = __result == 0;
        D.28046 = D.28045 & D.28035;
        if (D.28046 != 0) goto <D.28047>; else goto <D.28048>;
        <D.28047>:
        D.28049 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.28050 = *D.28049;
        D.28051 = (int) D.28050;
        D.28052 = __s2 + 2;
        D.28053 = *D.28052;
        D.28054 = (int) D.28053;
        __result = D.28051 - D.28054;
        D.28055 = __s2_len > 2;
        D.28035 = __result == 0;
        D.28056 = D.28055 & D.28035;
        if (D.28056 != 0) goto <D.28057>; else goto <D.28058>;
        <D.28057>:
        D.28059 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.28060 = *D.28059;
        D.28061 = (int) D.28060;
        D.28062 = __s2 + 3;
        D.28063 = *D.28062;
        D.28064 = (int) D.28063;
        __result = D.28061 - D.28064;
        <D.28058>:
        <D.28048>:
        <D.28038>:
      }
      D.20333 = __result;
    }
    iftmp.186 = -D.20333;
    goto <D.28065>;
    <D.28028>:
    D.27298 = klass->name;
    iftmp.186 = __builtin_strcmp (D.27298, "FieldOnTypeBuilderInst");
    <D.28065>:
    D.20334 = iftmp.186;
  }
  if (D.20334 == 0) goto <D.28066>; else goto <D.28067>;
  <D.28066>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;

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

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

      __s2 = klass->name;
      D.28072 = "ConstructorOnTypeBuilderInst";
      D.28073 = MEM[(const unsigned char *)D.28072];
      D.28074 = (int) D.28073;
      D.28075 = *__s2;
      D.28076 = (int) D.28075;
      __result = D.28074 - D.28076;
      {
        D.28077 = __s2_len != 0;
        D.28078 = __result == 0;
        D.28079 = D.28077 & D.28078;
        if (D.28079 != 0) goto <D.28080>; else goto <D.28081>;
        <D.28080>:
        D.28082 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.28083 = *D.28082;
        D.28084 = (int) D.28083;
        D.28085 = __s2 + 1;
        D.28086 = *D.28085;
        D.28087 = (int) D.28086;
        __result = D.28084 - D.28087;
        D.28088 = __s2_len > 1;
        D.28078 = __result == 0;
        D.28089 = D.28088 & D.28078;
        if (D.28089 != 0) goto <D.28090>; else goto <D.28091>;
        <D.28090>:
        D.28092 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.28093 = *D.28092;
        D.28094 = (int) D.28093;
        D.28095 = __s2 + 2;
        D.28096 = *D.28095;
        D.28097 = (int) D.28096;
        __result = D.28094 - D.28097;
        D.28098 = __s2_len > 2;
        D.28078 = __result == 0;
        D.28099 = D.28098 & D.28078;
        if (D.28099 != 0) goto <D.28100>; else goto <D.28101>;
        <D.28100>:
        D.28102 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.28103 = *D.28102;
        D.28104 = (int) D.28103;
        D.28105 = __s2 + 3;
        D.28106 = *D.28105;
        D.28107 = (int) D.28106;
        __result = D.28104 - D.28107;
        <D.28101>:
        <D.28091>:
        <D.28081>:
      }
      D.20343 = __result;
    }
    iftmp.187 = -D.20343;
    goto <D.28108>;
    <D.28071>:
    D.27298 = klass->name;
    iftmp.187 = __builtin_strcmp (D.27298, "ConstructorOnTypeBuilderInst");
    <D.28108>:
    D.20344 = iftmp.187;
  }
  if (D.20344 == 0) goto <D.28109>; else goto <D.28110>;
  <D.28109>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;

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

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

      __s2 = klass->name;
      D.28115 = "MethodOnTypeBuilderInst";
      D.28116 = MEM[(const unsigned char *)D.28115];
      D.28117 = (int) D.28116;
      D.28118 = *__s2;
      D.28119 = (int) D.28118;
      __result = D.28117 - D.28119;
      {
        D.28120 = __s2_len != 0;
        D.28121 = __result == 0;
        D.28122 = D.28120 & D.28121;
        if (D.28122 != 0) goto <D.28123>; else goto <D.28124>;
        <D.28123>:
        D.28125 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.28126 = *D.28125;
        D.28127 = (int) D.28126;
        D.28128 = __s2 + 1;
        D.28129 = *D.28128;
        D.28130 = (int) D.28129;
        __result = D.28127 - D.28130;
        D.28131 = __s2_len > 1;
        D.28121 = __result == 0;
        D.28132 = D.28131 & D.28121;
        if (D.28132 != 0) goto <D.28133>; else goto <D.28134>;
        <D.28133>:
        D.28135 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.28136 = *D.28135;
        D.28137 = (int) D.28136;
        D.28138 = __s2 + 2;
        D.28139 = *D.28138;
        D.28140 = (int) D.28139;
        __result = D.28137 - D.28140;
        D.28141 = __s2_len > 2;
        D.28121 = __result == 0;
        D.28142 = D.28141 & D.28121;
        if (D.28142 != 0) goto <D.28143>; else goto <D.28144>;
        <D.28143>:
        D.28145 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.28146 = *D.28145;
        D.28147 = (int) D.28146;
        D.28148 = __s2 + 3;
        D.28149 = *D.28148;
        D.28150 = (int) D.28149;
        __result = D.28147 - D.28150;
        <D.28144>:
        <D.28134>:
        <D.28124>:
      }
      D.20353 = __result;
    }
    iftmp.188 = -D.20353;
    goto <D.28151>;
    <D.28114>:
    D.27298 = klass->name;
    iftmp.188 = __builtin_strcmp (D.27298, "MethodOnTypeBuilderInst");
    <D.28151>:
    D.20354 = iftmp.188;
  }
  if (D.20354 == 0) goto <D.28152>; else goto <D.28153>;
  <D.28152>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
  }
  goto <D.28154>;
  <D.28153>:
  D.28158 = is_sre_array (klass);
  if (D.28158 != 0) goto <D.28155>; else goto <D.28159>;
  <D.28159>:
  D.28160 = is_sre_byref (klass);
  if (D.28160 != 0) goto <D.28155>; else goto <D.28161>;
  <D.28161>:
  D.28162 = is_sre_pointer (klass);
  if (D.28162 != 0) goto <D.28155>; else goto <D.28156>;
  <D.28155>:
  {
    struct MonoReflectionType * type;

    type = obj;
    D.28163 = mono_reflection_type_get_handle (type);
    D.28164 = mono_image_typedef_or_ref (assembly, D.28163);
    token = mono_metadata_token_from_dor (D.28164);
  }
  goto <D.28157>;
  <D.28156>:
  D.27298 = klass->name;
  monoeg_g_log (0B, 4, "requested token for %s\n", D.27298);
  <D.20357>:
  goto <D.20357>;
  <D.28157>:
  <D.28154>:
  <D.28111>:
  <D.28068>:
  <D.28025>:
  <D.27981>:
  <D.27937>:
  <D.27894>:
  <D.27654>:
  <D.27651>:
  <D.27607>:
  <D.27563>:
  <D.27513>:
  <D.27458>:
  <D.27403>:
  <D.27352>:
  if (register_token != 0) goto <D.28165>; else goto <D.28166>;
  <D.28165>:
  mono_image_register_token (assembly, token, obj);
  <D.28166>:
  D.28167 = token;
  return D.28167;
}


mono_image_get_methodbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb, gboolean create_methodspec)
{
  struct MonoArray * D.28169;
  guint32 D.28174;
  struct MonoGHashTable * D.28175;
  void * D.28176;
  void * token.189;
  guint32 token;

  D.28169 = mb->generic_params;
  if (D.28169 != 0B) goto <D.28170>; else goto <D.28171>;
  <D.28170>:
  if (create_methodspec != 0) goto <D.28172>; else goto <D.28173>;
  <D.28172>:
  D.28174 = mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
  return D.28174;
  <D.28173>:
  <D.28171>:
  D.28175 = assembly->handleref_managed;
  D.28176 = mono_g_hash_table_lookup (D.28175, mb);
  token = (guint32) D.28176;
  if (token != 0) goto <D.28177>; else goto <D.28178>;
  <D.28177>:
  D.28174 = token;
  return D.28174;
  <D.28178>:
  token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  token.189 = (void *) token;
  D.28175 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28175, mb, token.189);
  D.28174 = token;
  return D.28174;
}


mono_image_get_methodspec_token_for_generic_method_definition (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoGHashTable * D.28181;
  void * D.28182;
  guint32 D.28185;
  unsigned int D.28186;
  unsigned int D.28187;
  unsigned int D.28188;
  int D.28189;
  unsigned int D.28192;
  unsigned int D.28193;
  guint32 * D.28194;
  unsigned int D.28195;
  unsigned int D.28196;
  guint32 * D.28197;
  unsigned int D.28198;
  unsigned int D.28199;
  void * token.190;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;

  mtoken = 0;
  D.28181 = assembly->methodspec;
  D.28182 = mono_g_hash_table_lookup (D.28181, mb);
  token = (guint32) D.28182;
  if (token != 0) goto <D.28183>; else goto <D.28184>;
  <D.28183>:
  D.28185 = token;
  return D.28185;
  <D.28184>:
  table = &assembly->tables[43];
  mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.28186 = mtoken >> 24;
  switch (D.28186) <default: <D.19099>, case 6: <D.19098>, case 10: <D.19096>>
  <D.19096>:
  D.28187 = mtoken & 16777215;
  D.28188 = D.28187 << 1;
  mtoken = D.28188 | 1;
  goto <D.19097>;
  <D.19098>:
  D.28187 = mtoken & 16777215;
  mtoken = D.28187 << 1;
  goto <D.19097>;
  <D.19099>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2637);
  <D.19097>:
  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 * 8;
  values = D.28194 + D.28196;
  *values = mtoken;
  D.28197 = values + 4;
  D.28198 = encode_generic_method_definition_sig (assembly, mb);
  *D.28197 = D.28198;
  <D.28191>:
  D.28195 = table->next_idx;
  token = D.28195 | 721420288;
  D.28195 = table->next_idx;
  D.28199 = D.28195 + 1;
  table->next_idx = D.28199;
  token.190 = (void *) token;
  D.28181 = assembly->methodspec;
  mono_g_hash_table_insert (D.28181, mb, token.190);
  D.28185 = token;
  return D.28185;
}


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

  try
    {
      D.28202 = mb->generic_params;
      nparams = mono_array_length (D.28202);
      D.28203 = assembly->save;
      if (D.28203 == 0) goto <D.28204>; else goto <D.28205>;
      <D.28204>:
      D.28206 = 0;
      return D.28206;
      <D.28205>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19086>;
      <D.19085>:
      sigbuffer_add_value (&buf, 30);
      i.191 = (unsigned int) i;
      sigbuffer_add_value (&buf, i.191);
      i = i + 1;
      <D.19086>:
      i.191 = (unsigned int) i;
      if (i.191 < nparams) goto <D.19085>; else goto <D.19087>;
      <D.19087>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28206 = idx;
      return D.28206;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodref_token_for_methodbuilder (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * method)
{
  struct GHashTable * D.28210;
  void * D.28211;
  guint32 D.28214;
  struct MonoString * D.28215;
  unsigned int D.28216;
  unsigned int D.28217;
  _Bool D.28218;
  _Bool D.28219;
  _Bool D.28220;
  unsigned int D.28223;
  struct MonoArray * D.28224;
  struct MonoObject * D.28228;
  struct MonoType * D.28229;
  void * token.192;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = method->type;
      D.28210 = assembly->handleref;
      D.28211 = monoeg_g_hash_table_lookup (D.28210, method);
      token = (guint32) D.28211;
      if (token != 0) goto <D.28212>; else goto <D.28213>;
      <D.28212>:
      D.28214 = token;
      return D.28214;
      <D.28213>:
      D.28215 = method->name;
      name = mono_string_to_utf8 (D.28215);
      reflection_methodbuilder_from_method_builder (&rmb, method);
      D.28216 = rmb.call_conv;
      D.28217 = D.28216 & 4294967199;
      D.28218 = D.28217 != 0;
      D.28219 = D.28217 != 5;
      D.28220 = D.28218 & D.28219;
      if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
      <D.28221>:
      D.28216 = rmb.call_conv;
      D.28223 = D.28216 & 96;
      rmb.call_conv = D.28223;
      <D.28222>:
      sig = method_builder_encode_signature (assembly, &rmb);
      D.28224 = tb->generic_params;
      if (D.28224 != 0B) goto <D.28225>; else goto <D.28226>;
      <D.28225>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28227>;
      <D.28226>:
      D.28228 = rmb.type;
      D.28229 = mono_reflection_type_get_handle (D.28228);
      parent = mono_image_typedef_or_ref (assembly, D.28229);
      <D.28227>:
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      token.192 = (void *) token;
      D.28210 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.28210, method, token.192, 0);
      D.28214 = token;
      return D.28214;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


create_generic_typespec (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct GHashTable * D.28233;
  void * D.28234;
  guint32 D.28237;
  struct MonoArray * D.28238;
  _Bool D.28239;
  long int D.28240;
  long int D.28241;
  struct MonoGenericContainer * D.28244;
  struct MonoGenericContainer * D.28247;
  _Bool D.28248;
  long int D.28249;
  long int D.28250;
  unsigned char D.28253;
  unsigned int D.28254;
  struct MonoType * D.28255;
  unsigned int D.28256;
  unsigned int D.28257;
  unsigned int count.193;
  unsigned int i.194;
  char * D.28260;
  struct MonoType * D.28261;
  int D.28262;
  unsigned int D.28265;
  unsigned int D.28266;
  guint32 * D.28267;
  unsigned int D.28268;
  unsigned int D.28269;
  unsigned int D.28270;
  void * token.195;
  unsigned int D.28272;
  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.28233 = assembly->typespec;
      D.28234 = monoeg_g_hash_table_lookup (D.28233, type);
      token = (guint32) D.28234;
      if (token != 0) goto <D.28235>; else goto <D.28236>;
      <D.28235>:
      D.28237 = token;
      return D.28237;
      <D.28236>:
      sigbuffer_init (&buf, 32);
      D.28238 = tb->generic_params;
      D.28239 = D.28238 == 0B;
      D.28240 = (long int) D.28239;
      D.28241 = __builtin_expect (D.28240, 0);
      if (D.28241 != 0) goto <D.28242>; else goto <D.28243>;
      <D.28242>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3096, "tb->generic_params");
      <D.28243>:
      klass = mono_class_from_mono_type (type);
      D.28244 = tb->generic_container;
      if (D.28244 != 0B) goto <D.28245>; else goto <D.28246>;
      <D.28245>:
      mono_reflection_create_generic_class (tb);
      <D.28246>:
      sigbuffer_add_value (&buf, 21);
      D.28247 = klass->generic_container;
      D.28248 = D.28247 == 0B;
      D.28249 = (long int) D.28248;
      D.28250 = __builtin_expect (D.28249, 0);
      if (D.28250 != 0) goto <D.28251>; else goto <D.28252>;
      <D.28251>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3103, "klass->generic_container");
      <D.28252>:
      D.28253 = klass->byval_arg.type;
      D.28254 = (unsigned int) D.28253;
      sigbuffer_add_value (&buf, D.28254);
      D.28255 = &klass->byval_arg;
      D.28256 = mono_image_typedef_or_ref_full (assembly, D.28255, 0);
      sigbuffer_add_value (&buf, D.28256);
      D.28238 = tb->generic_params;
      D.28257 = mono_array_length (D.28238);
      count = (int) D.28257;
      count.193 = (unsigned int) count;
      sigbuffer_add_value (&buf, count.193);
      i = 0;
      goto <D.19252>;
      <D.19251>:
      {
        struct MonoReflectionGenericParam * gparam;

        i.194 = (unsigned int) i;
        D.28238 = tb->generic_params;
        D.28260 = mono_array_addr_with_size (D.28238, 4, i.194);
        gparam = MEM[(struct MonoReflectionGenericParam * *)D.28260];
        D.28261 = mono_reflection_type_get_handle (gparam);
        encode_type (assembly, D.28261, &buf);
      }
      i = i + 1;
      <D.19252>:
      if (i < count) goto <D.19251>; else goto <D.19253>;
      <D.19253>:
      table = &assembly->tables[27];
      D.28262 = assembly->save;
      if (D.28262 != 0) goto <D.28263>; else goto <D.28264>;
      <D.28263>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.28265 = table->rows;
      D.28266 = D.28265 + 1;
      alloc_table (table, D.28266);
      D.28267 = table->values;
      D.28268 = table->next_idx;
      D.28269 = D.28268 * 4;
      values = D.28267 + D.28269;
      *values = token;
      <D.28264>:
      sigbuffer_free (&buf);
      D.28268 = table->next_idx;
      D.28270 = D.28268 << 2;
      token = D.28270 | 2;
      token.195 = (void *) token;
      D.28233 = assembly->typespec;
      monoeg_g_hash_table_insert_replace (D.28233, type, token.195, 0);
      D.28268 = table->next_idx;
      D.28272 = D.28268 + 1;
      table->next_idx = D.28272;
      D.28237 = token;
      return D.28237;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_memberef_row (struct MonoDynamicImage * assembly, guint32 parent, const char * name, guint32 sig)
{
  unsigned int D.28275;
  guint32 D.28276;
  int D.28277;
  unsigned int D.28280;
  unsigned int D.28281;
  guint32 * D.28282;
  unsigned int D.28283;
  unsigned int D.28284;
  unsigned int D.28285;
  unsigned int D.28286;
  guint32 * D.28287;
  struct MonoDynamicStream * D.28288;
  unsigned int D.28289;
  guint32 * D.28290;
  unsigned int D.28291;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 pclass;

  D.28275 = parent & 3;
  switch (D.28275) <default: <D.19041>, case 0: <D.19040>, case 1: <D.19037>, case 2: <D.19039>>
  <D.19037>:
  pclass = 1;
  goto <D.19038>;
  <D.19039>:
  pclass = 4;
  goto <D.19038>;
  <D.19040>:
  pclass = 0;
  goto <D.19038>;
  <D.19041>:
  monoeg_g_log (0B, 16, "unknown typeref or def token 0x%08x for %s", parent, name);
  D.28276 = 0;
  return D.28276;
  <D.19038>:
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28277 = assembly->save;
  if (D.28277 != 0) goto <D.28278>; else goto <D.28279>;
  <D.28278>:
  D.28280 = table->rows;
  D.28281 = D.28280 + 1;
  alloc_table (table, D.28281);
  D.28282 = table->values;
  D.28283 = table->next_idx;
  D.28284 = D.28283 * 12;
  values = D.28282 + D.28284;
  D.28285 = parent << 3;
  D.28286 = D.28285 | pclass;
  *values = D.28286;
  D.28287 = values + 4;
  D.28288 = &assembly->sheap;
  D.28289 = string_heap_insert (D.28288, name);
  *D.28287 = D.28289;
  D.28290 = values + 8;
  *D.28290 = sig;
  <D.28279>:
  D.28283 = table->next_idx;
  token = D.28283 | 167772160;
  D.28283 = table->next_idx;
  D.28291 = D.28283 + 1;
  table->next_idx = D.28291;
  D.28276 = token;
  return D.28276;
}


mono_image_get_ctorbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoGHashTable * D.28293;
  void * D.28294;
  guint32 D.28297;
  struct MonoArray * D.28298;
  struct MonoType * D.28302;
  struct MonoString * D.28303;
  void * token.196;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = mb->type;
      D.28293 = assembly->handleref_managed;
      D.28294 = mono_g_hash_table_lookup (D.28293, mb);
      token = (guint32) D.28294;
      if (token != 0) goto <D.28295>; else goto <D.28296>;
      <D.28295>:
      D.28297 = token;
      return D.28297;
      <D.28296>:
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.28298 = tb->generic_params;
      if (D.28298 != 0B) goto <D.28299>; else goto <D.28300>;
      <D.28299>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28301>;
      <D.28300>:
      D.28302 = mono_reflection_type_get_handle (tb);
      parent = mono_image_typedef_or_ref (assembly, D.28302);
      <D.28301>:
      D.28303 = rmb.name;
      name = mono_string_to_utf8 (D.28303);
      sig = method_builder_encode_signature (assembly, &rmb);
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      token.196 = (void *) token;
      D.28293 = assembly->handleref_managed;
      mono_g_hash_table_insert (D.28293, mb, token.196);
      D.28297 = token;
      return D.28297;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


mono_image_get_generic_field_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoGHashTable * D.28307;
  void * D.28308;
  guint32 D.28311;
  struct MonoReflectionType * D.28312;
  struct MonoType * D.28313;
  struct MonoString * D.28314;
  struct MonoObject * D.28315;
  struct MonoArray * D.28318;
  struct MonoArray * D.28320;
  unsigned int D.28321;
  _Bool D.28322;
  long int D.28323;
  long int D.28324;
  int D.28327;
  unsigned int D.28330;
  unsigned int D.28331;
  guint32 * D.28332;
  unsigned int D.28333;
  unsigned int D.28334;
  unsigned int D.28335;
  unsigned int D.28336;
  guint32 * D.28337;
  struct MonoDynamicStream * D.28338;
  unsigned int D.28339;
  guint32 * D.28340;
  unsigned int D.28341;
  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.28307 = assembly->handleref_managed;
  D.28308 = mono_g_hash_table_lookup (D.28307, fb);
  token = (guint32) D.28308;
  if (token != 0) goto <D.28309>; else goto <D.28310>;
  <D.28309>:
  D.28311 = token;
  return D.28311;
  <D.28310>:
  D.28312 = fb->typeb;
  D.28313 = mono_reflection_type_get_handle (D.28312);
  klass = mono_class_from_mono_type (D.28313);
  D.28314 = fb->name;
  name = mono_string_to_utf8 (D.28314);
  D.28315 = fb->type;
  init_type_builder_generics (D.28315);
  D.28315 = fb->type;
  type = mono_reflection_type_get_handle (D.28315);
  D.28318 = fb->modreq;
  if (D.28318 != 0B) goto <D.28316>; else goto <D.28319>;
  <D.28319>:
  D.28320 = fb->modopt;
  if (D.28320 != 0B) goto <D.28316>; else goto <D.28317>;
  <D.28316>:
  D.28320 = fb->modopt;
  D.28318 = fb->modreq;
  custom = add_custom_modifiers (assembly, type, D.28318, D.28320);
  type = custom;
  <D.28317>:
  sig = fieldref_encode_signature (assembly, 0B, type);
  monoeg_g_free (custom);
  D.28312 = fb->typeb;
  parent = create_generic_typespec (assembly, D.28312);
  D.28321 = parent & 3;
  D.28322 = D.28321 != 2;
  D.28323 = (long int) D.28322;
  D.28324 = __builtin_expect (D.28323, 0);
  if (D.28324 != 0) goto <D.28325>; else goto <D.28326>;
  <D.28325>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3220, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC");
  <D.28326>:
  pclass = 4;
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28327 = assembly->save;
  if (D.28327 != 0) goto <D.28328>; else goto <D.28329>;
  <D.28328>:
  D.28330 = table->rows;
  D.28331 = D.28330 + 1;
  alloc_table (table, D.28331);
  D.28332 = table->values;
  D.28333 = table->next_idx;
  D.28334 = D.28333 * 12;
  values = D.28332 + D.28334;
  D.28335 = parent << 3;
  D.28336 = D.28335 | pclass;
  *values = D.28336;
  D.28337 = values + 4;
  D.28338 = &assembly->sheap;
  D.28339 = string_heap_insert (D.28338, name);
  *D.28337 = D.28339;
  D.28340 = values + 8;
  *D.28340 = sig;
  <D.28329>:
  D.28333 = table->next_idx;
  token = D.28333 | 167772160;
  D.28333 = table->next_idx;
  D.28341 = D.28333 + 1;
  table->next_idx = D.28341;
  token.197 = (void *) token;
  D.28307 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28307, fb, token.197);
  monoeg_g_free (name);
  D.28311 = token;
  return D.28311;
}


add_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoType * type, struct MonoArray * modreq, struct MonoArray * modopt)
{
  unsigned int D.28346;
  unsigned int count.198;
  unsigned int D.28348;
  unsigned int D.28351;
  unsigned int D.28352;
  struct MonoType * D.28355;
  unsigned int count.199;
  unsigned int D.28357;
  unsigned int D.28358;
  unsigned int len.200;
  unsigned char D.28360;
  <unnamed-unsigned:6> D.28361;
  unsigned int i.201;
  char * D.28365;
  void * D.28366;
  unsigned int D.28367;
  <unnamed-unsigned:31> D.28368;
  unsigned int D.28369;
  char * D.28372;
  void * D.28373;
  unsigned int D.28374;
  <unnamed-unsigned:31> D.28375;
  unsigned int D.28376;
  int i;
  int count;
  int len;
  int pos;
  struct MonoType * t;

  count = 0;
  if (modreq != 0B) goto <D.28344>; else goto <D.28345>;
  <D.28344>:
  D.28346 = mono_array_length (modreq);
  count.198 = (unsigned int) count;
  D.28348 = D.28346 + count.198;
  count = (int) D.28348;
  <D.28345>:
  if (modopt != 0B) goto <D.28349>; else goto <D.28350>;
  <D.28349>:
  D.28351 = mono_array_length (modopt);
  count.198 = (unsigned int) count;
  D.28352 = D.28351 + count.198;
  count = (int) D.28352;
  <D.28350>:
  if (count == 0) goto <D.28353>; else goto <D.28354>;
  <D.28353>:
  D.28355 = mono_metadata_type_dup (0B, type);
  return D.28355;
  <D.28354>:
  count.199 = (unsigned int) count;
  D.28357 = count.199 + 2;
  D.28358 = D.28357 * 4;
  len = (int) D.28358;
  len.200 = (unsigned int) len;
  t = monoeg_malloc (len.200);
  memcpy (t, type, 8);
  D.28360 = (unsigned char) count;
  D.28361 = (<unnamed-unsigned:6>) D.28360;
  t->num_mods = D.28361;
  pos = 0;
  if (modreq != 0B) goto <D.28362>; else goto <D.28363>;
  <D.28362>:
  i = 0;
  goto <D.19267>;
  <D.19266>:
  {
    struct MonoType * mod;

    i.201 = (unsigned int) i;
    D.28365 = mono_array_addr_with_size (modreq, 4, i.201);
    D.28366 = MEM[(void * *)D.28365];
    mod = mono_reflection_type_get_handle (D.28366);
    t->modifiers[pos].required = 1;
    D.28367 = mono_image_typedef_or_ref (assembly, mod);
    D.28368 = (<unnamed-unsigned:31>) D.28367;
    t->modifiers[pos].token = D.28368;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19267>:
  i.201 = (unsigned int) i;
  D.28369 = mono_array_length (modreq);
  if (i.201 < D.28369) goto <D.19266>; else goto <D.19268>;
  <D.19268>:
  <D.28363>:
  if (modopt != 0B) goto <D.28370>; else goto <D.28371>;
  <D.28370>:
  i = 0;
  goto <D.19271>;
  <D.19270>:
  {
    struct MonoType * mod;

    i.201 = (unsigned int) i;
    D.28372 = mono_array_addr_with_size (modopt, 4, i.201);
    D.28373 = MEM[(void * *)D.28372];
    mod = mono_reflection_type_get_handle (D.28373);
    t->modifiers[pos].required = 0;
    D.28374 = mono_image_typedef_or_ref (assembly, mod);
    D.28375 = (<unnamed-unsigned:31>) D.28374;
    t->modifiers[pos].token = D.28375;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19271>:
  i.201 = (unsigned int) i;
  D.28376 = mono_array_length (modopt);
  if (i.201 < D.28376) goto <D.19270>; else goto <D.19272>;
  <D.19272>:
  <D.28371>:
  D.28355 = t;
  return D.28355;
}


fieldref_encode_signature (struct MonoDynamicImage * assembly, struct MonoImage * field_image, struct MonoType * type)
{
  int D.28378;
  guint32 D.28381;
  unsigned char D.28382;
  unsigned char D.28383;
  <unnamed-unsigned:31> D.28388;
  unsigned int D.28389;
  _Bool D.28390;
  long int D.28391;
  long int D.28392;
  struct MonoType * D.28395;
  <unnamed-unsigned:1> D.28397;
  <unnamed-unsigned:6> D.28401;
  unsigned int D.28402;
  struct SigBuffer buf;
  guint32 idx;
  guint32 i;
  guint32 token;

  try
    {
      D.28378 = assembly->save;
      if (D.28378 == 0) goto <D.28379>; else goto <D.28380>;
      <D.28379>:
      D.28381 = 0;
      return D.28381;
      <D.28380>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.28382 = BIT_FIELD_REF <*type, 8, 56>;
      D.28383 = D.28382 & 63;
      if (D.28383 != 0) goto <D.28384>; else goto <D.28385>;
      <D.28384>:
      i = 0;
      goto <D.18819>;
      <D.18818>:
      if (field_image != 0B) goto <D.28386>; else goto <D.28387>;
      <D.28386>:
      {
        struct MonoClass * class;

        D.28388 = type->modifiers[i].token;
        D.28389 = (unsigned int) D.28388;
        class = mono_class_get (field_image, D.28389);
        D.28390 = class == 0B;
        D.28391 = (long int) D.28390;
        D.28392 = __builtin_expect (D.28391, 0);
        if (D.28392 != 0) goto <D.28393>; else goto <D.28394>;
        <D.28393>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1706, "class");
        <D.28394>:
        D.28395 = &class->byval_arg;
        token = mono_image_typedef_or_ref (assembly, D.28395);
      }
      goto <D.28396>;
      <D.28387>:
      D.28388 = type->modifiers[i].token;
      token = (guint32) D.28388;
      <D.28396>:
      D.28397 = type->modifiers[i].required;
      if (D.28397 != 0) goto <D.28398>; else goto <D.28399>;
      <D.28398>:
      sigbuffer_add_byte (&buf, 31);
      goto <D.28400>;
      <D.28399>:
      sigbuffer_add_byte (&buf, 32);
      <D.28400>:
      sigbuffer_add_value (&buf, token);
      i = i + 1;
      <D.18819>:
      D.28401 = type->num_mods;
      D.28402 = (unsigned int) D.28401;
      if (D.28402 > i) goto <D.18818>; else goto <D.18820>;
      <D.18820>:
      <D.28385>:
      encode_type (assembly, type, &buf);
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28381 = idx;
      return D.28381;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodspec_token (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  struct GHashTable * D.28405;
  void * D.28406;
  guint32 D.28409;
  unsigned char D.28410;
  unsigned char D.28411;
  _Bool D.28412;
  long int D.28413;
  long int D.28414;
  struct MonoMethod * D.28417;
  struct MonoMethodSignature * D.28418;
  short unsigned int D.28419;
  struct MonoMethodSignature * D.28423;
  const char * D.28424;
  struct MonoClass * D.28425;
  struct MonoType * D.28426;
  void * token.202;
  struct MonoMethodInflated * imethod;
  guint32 token;

  D.28405 = assembly->handleref;
  D.28406 = monoeg_g_hash_table_lookup (D.28405, method);
  token = (guint32) D.28406;
  if (token != 0) goto <D.28407>; else goto <D.28408>;
  <D.28407>:
  D.28409 = token;
  return D.28409;
  <D.28408>:
  D.28410 = BIT_FIELD_REF <*method, 8, 168>;
  D.28411 = D.28410 & 16;
  D.28412 = D.28411 == 0;
  D.28413 = (long int) D.28412;
  D.28414 = __builtin_expect (D.28413, 0);
  if (D.28414 != 0) goto <D.28415>; else goto <D.28416>;
  <D.28415>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3044, "method->is_inflated");
  <D.28416>:
  imethod = method;
  D.28417 = imethod->declaring;
  D.28418 = mono_method_signature (D.28417);
  D.28419 = D.28418->generic_param_count;
  if (D.28419 != 0) goto <D.28420>; else goto <D.28421>;
  <D.28420>:
  token = method_encode_methodspec (assembly, method);
  goto <D.28422>;
  <D.28421>:
  {
    guint32 sig;

    D.28417 = imethod->declaring;
    D.28423 = mono_method_signature (D.28417);
    sig = method_encode_signature (assembly, D.28423);
    D.28424 = method->name;
    D.28425 = method->klass;
    D.28426 = &D.28425->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.28426, D.28424, sig);
  }
  <D.28422>:
  token.202 = (void *) token;
  D.28405 = assembly->handleref;
  monoeg_g_hash_table_insert_replace (D.28405, method, token.202, 0);
  D.28409 = token;
  return D.28409;
}


method_encode_methodspec (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  unsigned char D.28429;
  unsigned char D.28430;
  _Bool D.28431;
  long int D.28432;
  long int D.28433;
  struct MonoMethodSignature * D.28436;
  const char * D.28437;
  struct MonoClass * D.28438;
  struct MonoType * D.28439;
  struct MonoMethodSignature * D.28440;
  short unsigned int D.28441;
  guint32 D.28444;
  unsigned int D.28445;
  unsigned int D.28446;
  unsigned int D.28447;
  struct MonoGenericContext * D.28448;
  int D.28449;
  unsigned int D.28452;
  unsigned int D.28453;
  guint32 * D.28454;
  unsigned int D.28455;
  unsigned int D.28456;
  guint32 * D.28457;
  unsigned int D.28458;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;
  guint32 sig;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * declaring;

  mtoken = 0;
  table = &assembly->tables[43];
  D.28429 = BIT_FIELD_REF <*method, 8, 168>;
  D.28430 = D.28429 & 16;
  D.28431 = D.28430 == 0;
  D.28432 = (long int) D.28431;
  D.28433 = __builtin_expect (D.28432, 0);
  if (D.28433 != 0) goto <D.28434>; else goto <D.28435>;
  <D.28434>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2998, "method->is_inflated");
  <D.28435>:
  imethod = method;
  declaring = imethod->declaring;
  D.28436 = mono_method_signature (declaring);
  sig = method_encode_signature (assembly, D.28436);
  D.28437 = declaring->name;
  D.28438 = method->klass;
  D.28439 = &D.28438->byval_arg;
  mtoken = mono_image_get_memberref_token (assembly, D.28439, D.28437, sig);
  D.28440 = mono_method_signature (declaring);
  D.28441 = D.28440->generic_param_count;
  if (D.28441 == 0) goto <D.28442>; else goto <D.28443>;
  <D.28442>:
  D.28444 = mtoken;
  return D.28444;
  <D.28443>:
  D.28445 = mtoken >> 24;
  switch (D.28445) <default: <D.19223>, case 6: <D.19222>, case 10: <D.19220>>
  <D.19220>:
  D.28446 = mtoken & 16777215;
  D.28447 = D.28446 << 1;
  mtoken = D.28447 | 1;
  goto <D.19221>;
  <D.19222>:
  D.28446 = mtoken & 16777215;
  mtoken = D.28446 << 1;
  goto <D.19221>;
  <D.19223>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3016);
  <D.19221>:
  D.28448 = mono_method_get_context (method);
  sig = encode_generic_method_sig (assembly, D.28448);
  D.28449 = assembly->save;
  if (D.28449 != 0) goto <D.28450>; else goto <D.28451>;
  <D.28450>:
  D.28452 = table->rows;
  D.28453 = D.28452 + 1;
  alloc_table (table, D.28453);
  D.28454 = table->values;
  D.28455 = table->next_idx;
  D.28456 = D.28455 * 8;
  values = D.28454 + D.28456;
  *values = mtoken;
  D.28457 = values + 4;
  *D.28457 = sig;
  <D.28451>:
  D.28455 = table->next_idx;
  token = D.28455 | 721420288;
  D.28455 = table->next_idx;
  D.28458 = D.28455 + 1;
  table->next_idx = D.28458;
  D.28444 = token;
  return D.28444;
}


encode_generic_method_sig (struct MonoDynamicImage * assembly, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.28460;
  <unnamed-unsigned:22> D.28461;
  int D.28462;
  guint32 D.28465;
  struct MonoType * D.28466;
  unsigned int i.203;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.28460 = context->method_inst;
      D.28461 = D.28460->type_argc;
      nparams = (guint32) D.28461;
      D.28462 = assembly->save;
      if (D.28462 == 0) goto <D.28463>; else goto <D.28464>;
      <D.28463>:
      D.28465 = 0;
      return D.28465;
      <D.28464>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19207>;
      <D.19206>:
      D.28460 = context->method_inst;
      D.28466 = D.28460->type_argv[i];
      encode_type (assembly, D.28466, &buf);
      i = i + 1;
      <D.19207>:
      i.203 = (unsigned int) i;
      if (i.203 < nparams) goto <D.19206>; else goto <D.19208>;
      <D.19208>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28465 = idx;
      return D.28465;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


mono_image_get_inflated_method_token (struct MonoDynamicImage * assembly, struct MonoMethod * m)
{
  struct MonoMethod * D.28472;
  struct MonoMethodSignature * D.28473;
  const char * D.28474;
  struct MonoClass * D.28475;
  struct MonoType * D.28476;
  guint32 D.28477;
  struct MonoMethodInflated * imethod;
  guint32 sig;
  guint32 token;

  imethod = m;
  D.28472 = imethod->declaring;
  D.28473 = mono_method_signature (D.28472);
  sig = method_encode_signature (assembly, D.28473);
  D.28474 = m->name;
  D.28475 = m->klass;
  D.28476 = &D.28475->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.28476, D.28474, sig);
  D.28477 = token;
  return D.28477;
}


mono_image_get_methodref_token (struct MonoDynamicImage * assembly, struct MonoMethod * method, gboolean create_typespec)
{
  int iftmp.204;
  unsigned char D.28483;
  unsigned char D.28484;
  struct MonoClass * D.28486;
  struct MonoImage * D.28487;
  struct MonoImage * D.28488;
  unsigned int method.205;
  unsigned int D.28493;
  const void * D.28494;
  struct GHashTable * D.28495;
  void * D.28496;
  guint32 D.28499;
  void * D.28500;
  _Bool D.28501;
  _Bool D.28502;
  _Bool D.28503;
  unsigned char D.28506;
  _Bool D.28507;
  long int D.28508;
  long int D.28509;
  struct MonoMethodSignature * D.28514;
  unsigned char D.28515;
  unsigned char D.28516;
  _Bool D.28517;
  _Bool D.28518;
  _Bool D.28519;
  unsigned int D.28522;
  const char * D.28523;
  struct MonoType * D.28524;
  void * token.206;
  unsigned int D.28528;
  _Bool D.28529;
  long int D.28530;
  long int D.28531;
  unsigned int D.28534;
  unsigned int D.28535;
  int D.28536;
  unsigned int D.28539;
  unsigned int D.28540;
  guint32 * D.28541;
  unsigned int D.28542;
  unsigned int D.28543;
  guint32 * D.28544;
  struct MonoGenericContainer * D.28545;
  struct MonoGenericContext * D.28546;
  unsigned int D.28547;
  unsigned int D.28548;
  void * D.28549;
  guint32 token;
  struct MonoMethodSignature * sig;

  if (create_typespec != 0) goto <D.28482>; else goto <D.28480>;
  <D.28482>:
  D.28483 = BIT_FIELD_REF <*method, 8, 168>;
  D.28484 = D.28483 & 8;
  if (D.28484 != 0) goto <D.28485>; else goto <D.28480>;
  <D.28485>:
  D.28486 = method->klass;
  D.28487 = D.28486->image;
  D.28488 = &assembly->image;
  if (D.28487 != D.28488) goto <D.28489>; else goto <D.28480>;
  <D.28489>:
  iftmp.204 = 1;
  goto <D.28481>;
  <D.28480>:
  iftmp.204 = 0;
  <D.28481>:
  create_typespec = iftmp.204;
  if (create_typespec != 0) goto <D.28490>; else goto <D.28491>;
  <D.28490>:
  method.205 = (unsigned int) method;
  D.28493 = method.205 + 1;
  D.28494 = (const void *) D.28493;
  D.28495 = assembly->handleref;
  D.28496 = monoeg_g_hash_table_lookup (D.28495, D.28494);
  token = (guint32) D.28496;
  if (token != 0) goto <D.28497>; else goto <D.28498>;
  <D.28497>:
  D.28499 = token;
  return D.28499;
  <D.28498>:
  <D.28491>:
  D.28495 = assembly->handleref;
  D.28500 = monoeg_g_hash_table_lookup (D.28495, method);
  token = (guint32) D.28500;
  D.28501 = token != 0;
  D.28502 = create_typespec == 0;
  D.28503 = D.28501 & D.28502;
  if (D.28503 != 0) goto <D.28504>; else goto <D.28505>;
  <D.28504>:
  D.28499 = token;
  return D.28499;
  <D.28505>:
  D.28483 = BIT_FIELD_REF <*method, 8, 168>;
  D.28506 = D.28483 & 16;
  D.28507 = D.28506 != 0;
  D.28508 = (long int) D.28507;
  D.28509 = __builtin_expect (D.28508, 0);
  if (D.28509 != 0) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2492, "!method->is_inflated");
  <D.28511>:
  if (token == 0) goto <D.28512>; else goto <D.28513>;
  <D.28512>:
  D.28514 = mono_method_signature (method);
  sig = mono_metadata_signature_dup (D.28514);
  D.28515 = BIT_FIELD_REF <*sig, 8, 80>;
  D.28516 = D.28515 & 63;
  D.28517 = D.28516 != 0;
  D.28518 = D.28516 != 5;
  D.28519 = D.28517 & D.28518;
  if (D.28519 != 0) goto <D.28520>; else goto <D.28521>;
  <D.28520>:
  sig->call_convention = 0;
  <D.28521>:
  D.28522 = method_encode_signature (assembly, sig);
  D.28523 = method->name;
  D.28486 = method->klass;
  D.28524 = &D.28486->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.28524, D.28523, D.28522);
  monoeg_g_free (sig);
  token.206 = (void *) token;
  D.28495 = assembly->handleref;
  monoeg_g_hash_table_insert_replace (D.28495, method, token.206, 0);
  <D.28513>:
  if (create_typespec != 0) goto <D.28526>; else goto <D.28527>;
  <D.28526>:
  {
    struct MonoDynamicTable * table;

    table = &assembly->tables[43];
    D.28528 = token >> 24;
    D.28529 = D.28528 != 10;
    D.28530 = (long int) D.28529;
    D.28531 = __builtin_expect (D.28530, 0);
    if (D.28531 != 0) goto <D.28532>; else goto <D.28533>;
    <D.28532>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2508, "mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF");
    <D.28533>:
    D.28534 = token & 16777215;
    D.28535 = D.28534 << 1;
    token = D.28535 | 1;
    D.28536 = assembly->save;
    if (D.28536 != 0) goto <D.28537>; else goto <D.28538>;
    <D.28537>:
    {
      guint32 * values;

      D.28539 = table->rows;
      D.28540 = D.28539 + 1;
      alloc_table (table, D.28540);
      D.28541 = table->values;
      D.28542 = table->next_idx;
      D.28543 = D.28542 * 8;
      values = D.28541 + D.28543;
      *values = token;
      D.28544 = values + 4;
      D.28545 = mono_method_get_generic_container (method);
      D.28546 = &D.28545->context;
      D.28547 = encode_generic_method_sig (assembly, D.28546);
      *D.28544 = D.28547;
    }
    <D.28538>:
    D.28542 = table->next_idx;
    token = D.28542 | 721420288;
    D.28542 = table->next_idx;
    D.28548 = D.28542 + 1;
    table->next_idx = D.28548;
    token.206 = (void *) token;
    method.205 = (unsigned int) method;
    D.28493 = method.205 + 1;
    D.28549 = (void *) D.28493;
    D.28495 = assembly->handleref;
    monoeg_g_hash_table_insert_replace (D.28495, D.28549, token.206, 0);
    D.28499 = token;
    return D.28499;
  }
  <D.28527>:
  D.28499 = token;
  return D.28499;
}


mono_image_get_fieldref_token (struct MonoDynamicImage * assembly, struct MonoObject * f, struct MonoClassField * field)
{
  _Bool D.28551;
  long int D.28552;
  long int D.28553;
  struct MonoClass * D.28556;
  _Bool D.28557;
  long int D.28558;
  long int D.28559;
  struct MonoGHashTable * D.28562;
  void * D.28563;
  guint32 D.28566;
  struct MonoGenericClass * D.28569;
  struct MonoClass * D.28571;
  struct MonoClassField * D.28573;
  int field.207;
  struct MonoClassField * D.28576;
  int D.28577;
  int D.28578;
  unsigned int index.208;
  unsigned int D.28580;
  struct MonoClassField * D.28581;
  int D.28582;
  struct MonoImage * D.28586;
  unsigned int D.28587;
  const char * D.28588;
  struct MonoType * D.28589;
  void * token.209;
  struct MonoType * type;
  guint32 token;

  D.28551 = field == 0B;
  D.28552 = (long int) D.28551;
  D.28553 = __builtin_expect (D.28552, 0);
  if (D.28553 != 0) goto <D.28554>; else goto <D.28555>;
  <D.28554>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2745, "field");
  <D.28555>:
  D.28556 = field->parent;
  D.28557 = D.28556 == 0B;
  D.28558 = (long int) D.28557;
  D.28559 = __builtin_expect (D.28558, 0);
  if (D.28559 != 0) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2746, "field->parent");
  <D.28561>:
  D.28562 = assembly->handleref_managed;
  D.28563 = mono_g_hash_table_lookup (D.28562, f);
  token = (guint32) D.28563;
  if (token != 0) goto <D.28564>; else goto <D.28565>;
  <D.28564>:
  D.28566 = token;
  return D.28566;
  <D.28565>:
  D.28556 = field->parent;
  D.28569 = D.28556->generic_class;
  if (D.28569 != 0B) goto <D.28570>; else goto <D.28567>;
  <D.28570>:
  D.28556 = field->parent;
  D.28569 = D.28556->generic_class;
  D.28571 = D.28569->container_class;
  if (D.28571 != 0B) goto <D.28572>; else goto <D.28567>;
  <D.28572>:
  D.28556 = field->parent;
  D.28569 = D.28556->generic_class;
  D.28571 = D.28569->container_class;
  D.28573 = D.28571->fields;
  if (D.28573 != 0B) goto <D.28574>; else goto <D.28567>;
  <D.28574>:
  {
    int index;

    field.207 = (int) field;
    D.28556 = field->parent;
    D.28576 = D.28556->fields;
    D.28577 = (int) D.28576;
    D.28578 = field.207 - D.28577;
    index = D.28578 /[ex] 16;
    D.28556 = field->parent;
    D.28569 = D.28556->generic_class;
    D.28571 = D.28569->container_class;
    D.28573 = D.28571->fields;
    index.208 = (unsigned int) index;
    D.28580 = index.208 * 16;
    D.28581 = D.28573 + D.28580;
    type = mono_field_get_type (D.28581);
  }
  goto <D.28568>;
  <D.28567>:
  D.28582 = is_field_on_inst (field);
  if (D.28582 != 0) goto <D.28583>; else goto <D.28584>;
  <D.28583>:
  type = get_field_on_inst_generic_type (field);
  goto <D.28585>;
  <D.28584>:
  type = mono_field_get_type (field);
  <D.28585>:
  <D.28568>:
  D.28556 = field->parent;
  D.28586 = D.28556->image;
  D.28587 = fieldref_encode_signature (assembly, D.28586, type);
  D.28588 = mono_field_get_name (field);
  D.28556 = field->parent;
  D.28589 = &D.28556->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.28589, D.28588, D.28587);
  token.209 = (void *) token;
  D.28562 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28562, f, token.209);
  D.28566 = token;
  return D.28566;
}


get_field_on_inst_generic_type (struct MonoClassField * field)
{
  int D.28592;
  _Bool D.28593;
  long int D.28594;
  long int D.28595;
  struct MonoClass * D.28598;
  struct MonoClassField * D.28599;
  int field.210;
  int D.28603;
  int D.28604;
  int D.28605;
  int D.28606;
  struct MonoType * D.28609;
  struct MonoType * * D.28610;
  unsigned int field_index.211;
  unsigned int D.28612;
  struct MonoType * * D.28613;
  struct MonoGenericClass * D.28614;
  struct MonoClassField * D.28615;
  int D.28618;
  int D.28619;
  int D.28620;
  unsigned int D.28621;
  unsigned int D.28622;
  struct MonoClassField * D.28625;
  unsigned int D.28626;
  struct MonoClassField * D.28627;
  struct MonoClass * class;
  struct MonoClass * gtd;
  struct MonoDynamicGenericClass * dgclass;
  int field_index;

  D.28592 = is_field_on_inst (field);
  D.28593 = D.28592 == 0;
  D.28594 = (long int) D.28593;
  D.28595 = __builtin_expect (D.28594, 0);
  if (D.28595 != 0) goto <D.28596>; else goto <D.28597>;
  <D.28596>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2717, "is_field_on_inst (field)");
  <D.28597>:
  D.28598 = field->parent;
  dgclass = D.28598->generic_class;
  D.28599 = dgclass->fields;
  if (D.28599 <= field) goto <D.28600>; else goto <D.28601>;
  <D.28600>:
  field.210 = (int) field;
  D.28599 = dgclass->fields;
  D.28603 = (int) D.28599;
  D.28604 = field.210 - D.28603;
  D.28605 = D.28604 /[ex] 16;
  D.28606 = dgclass->count_fields;
  if (D.28605 < D.28606) goto <D.28607>; else goto <D.28608>;
  <D.28607>:
  field.210 = (int) field;
  D.28599 = dgclass->fields;
  D.28603 = (int) D.28599;
  D.28604 = field.210 - D.28603;
  field_index = D.28604 /[ex] 16;
  D.28610 = dgclass->field_generic_types;
  field_index.211 = (unsigned int) field_index;
  D.28612 = field_index.211 * 4;
  D.28613 = D.28610 + D.28612;
  D.28609 = *D.28613;
  return D.28609;
  <D.28608>:
  <D.28601>:
  class = field->parent;
  D.28614 = class->generic_class;
  gtd = D.28614->container_class;
  D.28615 = class->fields;
  if (D.28615 <= field) goto <D.28616>; else goto <D.28617>;
  <D.28616>:
  field.210 = (int) field;
  D.28615 = class->fields;
  D.28618 = (int) D.28615;
  D.28619 = field.210 - D.28618;
  D.28620 = D.28619 /[ex] 16;
  D.28621 = (unsigned int) D.28620;
  D.28622 = class->field.count;
  if (D.28621 < D.28622) goto <D.28623>; else goto <D.28624>;
  <D.28623>:
  field.210 = (int) field;
  D.28615 = class->fields;
  D.28618 = (int) D.28615;
  D.28619 = field.210 - D.28618;
  field_index = D.28619 /[ex] 16;
  D.28625 = gtd->fields;
  field_index.211 = (unsigned int) field_index;
  D.28626 = field_index.211 * 16;
  D.28627 = D.28625 + D.28626;
  D.28609 = D.28627->type;
  return D.28609;
  <D.28624>:
  <D.28617>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2734);
  D.28609 = 0B;
  return D.28609;
}


mono_image_get_array_token (struct MonoDynamicImage * assembly, struct MonoReflectionArrayMethod * m)
{
  struct MonoString * D.28629;
  struct MonoArray * D.28630;
  unsigned int D.28631;
  unsigned int D.28632;
  unsigned int D.28633;
  int D.28634;
  int D.28635;
  unsigned char D.28636;
  <unnamed-unsigned:6> D.28637;
  short unsigned int D.28638;
  struct MonoType * iftmp.212;
  struct MonoReflectionType * D.28640;
  struct MonoClass * D.28644;
  struct MonoReflectionType * D.28645;
  char * D.28646;
  void * D.28647;
  struct MonoType * D.28648;
  int D.19348;
  char * D.28649;
  struct MonoType * D.28652;
  int D.28653;
  struct MonoMethodSignature * D.28656;
  int D.28657;
  unsigned int D.28660;
  unsigned int D.28661;
  guint32 D.28662;
  unsigned int D.28663;
  unsigned int D.28664;
  struct GList * D.28665;
  struct GList * D.28666;
  guint32 nparams;
  guint32 i;
  struct GList * tmp;
  char * name;
  struct MonoMethodSignature * sig;
  struct ArrayMethod * am;
  struct MonoType * mtype;

  D.28629 = m->name;
  name = mono_string_to_utf8 (D.28629);
  D.28630 = m->parameters;
  nparams = mono_array_length (D.28630);
  D.28631 = nparams + 3;
  D.28632 = D.28631 * 4;
  sig = monoeg_malloc0 (D.28632);
  sig->hasthis = 1;
  sig->sentinelpos = -1;
  D.28633 = m->call_conv;
  D.28634 = (int) D.28633;
  D.28635 = reflection_cc_to_file (D.28634);
  D.28636 = (unsigned char) D.28635;
  D.28637 = (<unnamed-unsigned:6>) D.28636;
  sig->call_convention = D.28637;
  D.28638 = (short unsigned int) nparams;
  sig->param_count = D.28638;
  D.28640 = m->ret;
  if (D.28640 != 0B) goto <D.28641>; else goto <D.28642>;
  <D.28641>:
  D.28640 = m->ret;
  iftmp.212 = mono_reflection_type_get_handle (D.28640);
  goto <D.28643>;
  <D.28642>:
  D.28644 = mono_defaults.void_class;
  iftmp.212 = &D.28644->byval_arg;
  <D.28643>:
  sig->ret = iftmp.212;
  D.28645 = m->parent;
  mtype = mono_reflection_type_get_handle (D.28645);
  i = 0;
  goto <D.19338>;
  <D.19337>:
  D.28630 = m->parameters;
  D.28646 = mono_array_addr_with_size (D.28630, 4, i);
  D.28647 = MEM[(void * *)D.28646];
  D.28648 = mono_reflection_type_get_handle (D.28647);
  sig->params[i] = D.28648;
  i = i + 1;
  <D.19338>:
  if (i < nparams) goto <D.19337>; else goto <D.19339>;
  <D.19339>:
  tmp = assembly->array_methods;
  goto <D.19350>;
  <D.19349>:
  am = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.28649 = am->name;
    D.19348 = __builtin_strcmp (name, D.28649);
  }
  if (D.19348 == 0) goto <D.28650>; else goto <D.28651>;
  <D.28650>:
  D.28652 = am->parent;
  D.28653 = mono_metadata_type_equal (D.28652, mtype);
  if (D.28653 != 0) goto <D.28654>; else goto <D.28655>;
  <D.28654>:
  D.28656 = am->sig;
  D.28657 = mono_metadata_signature_equal (D.28656, sig);
  if (D.28657 != 0) goto <D.28658>; else goto <D.28659>;
  <D.28658>:
  monoeg_g_free (name);
  monoeg_g_free (sig);
  D.28660 = am->token;
  D.28661 = D.28660 & 16777215;
  m->table_idx = D.28661;
  D.28662 = am->token;
  return D.28662;
  <D.28659>:
  <D.28655>:
  <D.28651>:
  tmp = tmp->next;
  <D.19350>:
  if (tmp != 0B) goto <D.19349>; else goto <D.19351>;
  <D.19351>:
  am = monoeg_malloc0 (16);
  am->name = name;
  am->sig = sig;
  am->parent = mtype;
  D.28663 = method_encode_signature (assembly, sig);
  D.28652 = am->parent;
  D.28664 = mono_image_get_memberref_token (assembly, D.28652, name, D.28663);
  am->token = D.28664;
  D.28665 = assembly->array_methods;
  D.28666 = monoeg_g_list_prepend (D.28665, am);
  assembly->array_methods = D.28666;
  D.28660 = am->token;
  D.28661 = D.28660 & 16777215;
  m->table_idx = D.28661;
  D.28662 = am->token;
  return D.28662;
}


reflection_cc_to_file (int call_conv)
{
  int D.28668;
  int D.28669;

  D.28668 = call_conv & 3;
  switch (D.28668) <default: <D.19319>, case 0: <D.19316>, case 1: <D.19317>, case 2: <D.19318>>
  <D.19316>:
  <D.19317>:
  D.28669 = 0;
  return D.28669;
  <D.19318>:
  D.28669 = 5;
  return D.28669;
  <D.19319>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3331);
  D.28669 = 0;
  return D.28669;
}


mono_image_get_sighelper_token (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  unsigned int D.28671;
  unsigned int idx.213;
  unsigned int D.28673;
  unsigned int D.28674;
  unsigned int D.28675;
  guint32 * D.28676;
  unsigned int D.28677;
  unsigned int D.28678;
  guint32 D.28679;
  guint32 idx;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[17];
  D.28671 = table->next_idx;
  idx.213 = D.28671;
  D.28673 = idx.213 + 1;
  table->next_idx = D.28673;
  idx = idx.213;
  D.28674 = table->rows;
  D.28675 = D.28674 + 1;
  table->rows = D.28675;
  D.28674 = table->rows;
  alloc_table (table, D.28674);
  D.28676 = table->values;
  D.28677 = idx * 4;
  values = D.28676 + D.28677;
  D.28678 = mono_reflection_encode_sighelper (assembly, helper);
  *values = D.28678;
  D.28679 = idx;
  return D.28679;
}


mono_reflection_encode_sighelper (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  int D.28681;
  guint32 D.28684;
  unsigned int D.28685;
  _Bool D.28686;
  long int D.28687;
  long int D.28688;
  struct MonoArray * D.28691;
  unsigned int D.28695;
  unsigned int D.28696;
  unsigned int D.28697;
  unsigned int D.28700;
  unsigned int D.28703;
  unsigned int D.28706;
  unsigned int D.28708;
  unsigned char D.28711;
  int D.28712;
  struct MonoReflectionType * D.28713;
  struct MonoArray * D.28714;
  unsigned int D.28717;
  char * D.28720;
  struct MonoArray * D.28721;
  unsigned int D.28724;
  char * D.28727;
  char * D.28728;
  struct SigBuffer buf;
  guint32 nargs;
  guint32 size;
  guint32 i;
  guint32 idx;

  try
    {
      D.28681 = assembly->save;
      if (D.28681 == 0) goto <D.28682>; else goto <D.28683>;
      <D.28682>:
      D.28684 = 0;
      return D.28684;
      <D.28683>:
      D.28685 = helper->type;
      D.28686 = D.28685 != 2;
      D.28687 = (long int) D.28686;
      D.28688 = __builtin_expect (D.28687, 0);
      if (D.28688 != 0) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3254, "helper->type == 2");
      <D.28690>:
      D.28691 = helper->arguments;
      if (D.28691 != 0B) goto <D.28692>; else goto <D.28693>;
      <D.28692>:
      D.28691 = helper->arguments;
      nargs = mono_array_length (D.28691);
      goto <D.28694>;
      <D.28693>:
      nargs = 0;
      <D.28694>:
      D.28695 = nargs + 1;
      size = D.28695 * 10;
      sigbuffer_init (&buf, 32);
      D.28696 = helper->call_conv;
      D.28697 = D.28696 & 3;
      if (D.28697 == 3) goto <D.28698>; else goto <D.28699>;
      <D.28698>:
      helper->call_conv = 1;
      <D.28699>:
      D.28696 = helper->call_conv;
      D.28700 = D.28696 & 64;
      if (D.28700 != 0) goto <D.28701>; else goto <D.28702>;
      <D.28701>:
      D.28696 = helper->call_conv;
      D.28703 = D.28696 & 32;
      helper->call_conv = D.28703;
      <D.28702>:
      D.28696 = helper->call_conv;
      if (D.28696 == 0) goto <D.28704>; else goto <D.28705>;
      <D.28704>:
      D.28706 = helper->unmanaged_call_conv;
      idx = D.28706 + 4294967295;
      goto <D.28707>;
      <D.28705>:
      D.28696 = helper->call_conv;
      idx = D.28696 & 96;
      D.28696 = helper->call_conv;
      D.28708 = D.28696 & 2;
      if (D.28708 != 0) goto <D.28709>; else goto <D.28710>;
      <D.28709>:
      idx = idx + 5;
      <D.28710>:
      <D.28707>:
      D.28711 = (unsigned char) idx;
      D.28712 = (int) D.28711;
      sigbuffer_add_byte (&buf, D.28712);
      sigbuffer_add_value (&buf, nargs);
      D.28713 = helper->return_type;
      encode_reflection_type (assembly, D.28713, &buf);
      i = 0;
      goto <D.19304>;
      <D.19303>:
      {
        struct MonoArray * modreqs;
        struct MonoArray * modopts;
        struct MonoReflectionType * pt;

        modreqs = 0B;
        modopts = 0B;
        D.28714 = helper->modreqs;
        if (D.28714 != 0B) goto <D.28715>; else goto <D.28716>;
        <D.28715>:
        D.28714 = helper->modreqs;
        D.28717 = mono_array_length (D.28714);
        if (D.28717 > i) goto <D.28718>; else goto <D.28719>;
        <D.28718>:
        D.28714 = helper->modreqs;
        D.28720 = mono_array_addr_with_size (D.28714, 4, i);
        modreqs = MEM[(struct MonoArray * *)D.28720];
        <D.28719>:
        <D.28716>:
        D.28721 = helper->modopts;
        if (D.28721 != 0B) goto <D.28722>; else goto <D.28723>;
        <D.28722>:
        D.28721 = helper->modopts;
        D.28724 = mono_array_length (D.28721);
        if (D.28724 > i) goto <D.28725>; else goto <D.28726>;
        <D.28725>:
        D.28721 = helper->modopts;
        D.28727 = mono_array_addr_with_size (D.28721, 4, i);
        modopts = MEM[(struct MonoArray * *)D.28727];
        <D.28726>:
        <D.28723>:
        encode_custom_modifiers (assembly, modreqs, modopts, &buf);
        D.28691 = helper->arguments;
        D.28728 = mono_array_addr_with_size (D.28691, 4, i);
        pt = MEM[(struct MonoReflectionType * *)D.28728];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19304>:
      if (i < nargs) goto <D.19303>; else goto <D.19305>;
      <D.19305>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28684 = idx;
      return D.28684;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_field_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldOnTypeBuilderInst * f)
{
  struct MonoGHashTable * D.28731;
  void * D.28732;
  guint32 D.28735;
  struct MonoObject * D.28736;
  struct MonoVTable * D.28737;
  struct MonoClass * D.28738;
  int D.28739;
  struct MonoReflectionGenericClass * D.28742;
  unsigned char D.28743;
  unsigned char D.28744;
  _Bool D.28745;
  long int D.28746;
  long int D.28747;
  struct MonoString * D.28750;
  unsigned int D.28751;
  struct MonoType * D.28752;
  int D.28754;
  struct MonoType * D.28757;
  struct MonoClass * D.28758;
  struct MonoImage * D.28759;
  const char * D.28760;
  void * token.214;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoDynamicGenericClass * dgclass;
  struct MonoType * type;
  char * name;

  D.28731 = assembly->handleref_managed;
  D.28732 = mono_g_hash_table_lookup (D.28731, f);
  token = (guint32) D.28732;
  if (token != 0) goto <D.28733>; else goto <D.28734>;
  <D.28733>:
  D.28735 = token;
  return D.28735;
  <D.28734>:
  D.28736 = f->fb;
  D.28737 = D.28736->vtable;
  D.28738 = D.28737->klass;
  D.28739 = is_sre_field_builder (D.28738);
  if (D.28739 != 0) goto <D.28740>; else goto <D.28741>;
  <D.28740>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = f->fb;
    D.28742 = f->inst;
    type = mono_reflection_type_get_handle (D.28742);
    klass = mono_class_from_mono_type (type);
    gclass = type->data.generic_class;
    D.28743 = BIT_FIELD_REF <*gclass, 8, 96>;
    D.28744 = D.28743 & 1;
    D.28745 = D.28744 == 0;
    D.28746 = (long int) D.28745;
    D.28747 = __builtin_expect (D.28746, 0);
    if (D.28747 != 0) goto <D.28748>; else goto <D.28749>;
    <D.28748>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2786, "gclass->is_dynamic");
    <D.28749>:
    dgclass = gclass;
    D.28750 = fb->name;
    name = mono_string_to_utf8 (D.28750);
    D.28751 = field_encode_signature (assembly, fb);
    D.28752 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.28752, name, D.28751);
    monoeg_g_free (name);
  }
  goto <D.28753>;
  <D.28741>:
  D.28736 = f->fb;
  D.28737 = D.28736->vtable;
  D.28738 = D.28737->klass;
  D.28754 = is_sr_mono_field (D.28738);
  if (D.28754 != 0) goto <D.28755>; else goto <D.28756>;
  <D.28755>:
  {
    guint32 sig;
    struct MonoClassField * field;

    D.28736 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.28736].field;
    D.28742 = f->inst;
    type = mono_reflection_type_get_handle (D.28742);
    klass = mono_class_from_mono_type (type);
    D.28757 = field->type;
    D.28758 = field->parent;
    D.28759 = D.28758->image;
    sig = fieldref_encode_signature (assembly, D.28759, D.28757);
    D.28760 = field->name;
    D.28752 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.28752, D.28760, sig);
  }
  goto <D.28761>;
  <D.28756>:
  {
    char * name;

    D.28736 = f->fb;
    D.28737 = D.28736->vtable;
    D.28738 = D.28737->klass;
    name = mono_type_get_full_name (D.28738);
    monoeg_g_log (0B, 4, "mono_image_get_field_on_inst_token: don\'t know how to handle %s", name);
    <D.19148>:
    goto <D.19148>;
  }
  <D.28761>:
  <D.28753>:
  token.214 = (void *) token;
  D.28731 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28731, f, token.214);
  D.28735 = token;
  return D.28735;
}


is_sre_field_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.215;
  gboolean D.28767;
  _Bool D.28768;
  int D.28769;
  int D.22290;
  int iftmp.216;
  int D.22286;
  const char[13] * D.28775;
  unsigned char D.28776;
  int D.28777;
  unsigned char D.28778;
  int D.28779;
  _Bool D.28780;
  _Bool D.28781;
  _Bool D.28782;
  const unsigned char * D.28785;
  unsigned char D.28786;
  int D.28787;
  const unsigned char * D.28788;
  unsigned char D.28789;
  int D.28790;
  _Bool D.28791;
  _Bool D.28792;
  const unsigned char * D.28795;
  unsigned char D.28796;
  int D.28797;
  const unsigned char * D.28798;
  unsigned char D.28799;
  int D.28800;
  _Bool D.28801;
  _Bool D.28802;
  const unsigned char * D.28805;
  unsigned char D.28806;
  int D.28807;
  const unsigned char * D.28808;
  unsigned char D.28809;
  int D.28810;
  const char * D.28812;
  int D.22299;
  int iftmp.217;
  int D.22295;
  const char[23] * D.28818;
  unsigned char D.28819;
  int D.28820;
  unsigned char D.28821;
  int D.28822;
  _Bool D.28823;
  _Bool D.28824;
  _Bool D.28825;
  const unsigned char * D.28828;
  unsigned char D.28829;
  int D.28830;
  const unsigned char * D.28831;
  unsigned char D.28832;
  int D.28833;
  _Bool D.28834;
  _Bool D.28835;
  const unsigned char * D.28838;
  unsigned char D.28839;
  int D.28840;
  const unsigned char * D.28841;
  unsigned char D.28842;
  int D.28843;
  _Bool D.28844;
  _Bool D.28845;
  const unsigned char * D.28848;
  unsigned char D.28849;
  int D.28850;
  const unsigned char * D.28851;
  unsigned char D.28852;
  int D.28853;
  const char * D.28855;

  {
    static struct MonoClass * cached_class;

    cached_class.215 = cached_class;
    if (cached_class.215 != 0B) goto <D.28765>; else goto <D.28766>;
    <D.28765>:
    cached_class.215 = cached_class;
    D.28768 = cached_class.215 == class;
    D.28767 = (gboolean) D.28768;
    return D.28767;
    <D.28766>:
    D.28769 = is_corlib_type (class);
    if (D.28769 != 0) goto <D.28770>; else goto <D.28771>;
    <D.28770>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

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


is_sr_mono_field (struct MonoClass * class)
{
  struct MonoClass * cached_class.218;
  gboolean D.28862;
  _Bool D.28863;
  int D.28864;
  int D.22448;
  int iftmp.219;
  int D.22444;
  const char[10] * D.28870;
  unsigned char D.28871;
  int D.28872;
  unsigned char D.28873;
  int D.28874;
  _Bool D.28875;
  _Bool D.28876;
  _Bool D.28877;
  const unsigned char * D.28880;
  unsigned char D.28881;
  int D.28882;
  const unsigned char * D.28883;
  unsigned char D.28884;
  int D.28885;
  _Bool D.28886;
  _Bool D.28887;
  const unsigned char * D.28890;
  unsigned char D.28891;
  int D.28892;
  const unsigned char * D.28893;
  unsigned char D.28894;
  int D.28895;
  _Bool D.28896;
  _Bool D.28897;
  const unsigned char * D.28900;
  unsigned char D.28901;
  int D.28902;
  const unsigned char * D.28903;
  unsigned char D.28904;
  int D.28905;
  const char * D.28907;
  int D.22457;
  int iftmp.220;
  int D.22453;
  const char[18] * D.28913;
  unsigned char D.28914;
  int D.28915;
  unsigned char D.28916;
  int D.28917;
  _Bool D.28918;
  _Bool D.28919;
  _Bool D.28920;
  const unsigned char * D.28923;
  unsigned char D.28924;
  int D.28925;
  const unsigned char * D.28926;
  unsigned char D.28927;
  int D.28928;
  _Bool D.28929;
  _Bool D.28930;
  const unsigned char * D.28933;
  unsigned char D.28934;
  int D.28935;
  const unsigned char * D.28936;
  unsigned char D.28937;
  int D.28938;
  _Bool D.28939;
  _Bool D.28940;
  const unsigned char * D.28943;
  unsigned char D.28944;
  int D.28945;
  const unsigned char * D.28946;
  unsigned char D.28947;
  int D.28948;
  const char * D.28950;

  {
    static struct MonoClass * cached_class;

    cached_class.218 = cached_class;
    if (cached_class.218 != 0B) goto <D.28860>; else goto <D.28861>;
    <D.28860>:
    cached_class.218 = cached_class;
    D.28863 = cached_class.218 == class;
    D.28862 = (gboolean) D.28863;
    return D.28862;
    <D.28861>:
    D.28864 = is_corlib_type (class);
    if (D.28864 != 0) goto <D.28865>; else goto <D.28866>;
    <D.28865>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.28870 = "MonoField";
        D.28871 = MEM[(const unsigned char *)D.28870];
        D.28872 = (int) D.28871;
        D.28873 = *__s2;
        D.28874 = (int) D.28873;
        __result = D.28872 - D.28874;
        {
          D.28875 = __s1_len != 0;
          D.28876 = __result == 0;
          D.28877 = D.28875 & D.28876;
          if (D.28877 != 0) goto <D.28878>; else goto <D.28879>;
          <D.28878>:
          D.28880 = &MEM[(void *)"MonoField" + 1B];
          D.28881 = *D.28880;
          D.28882 = (int) D.28881;
          D.28883 = __s2 + 1;
          D.28884 = *D.28883;
          D.28885 = (int) D.28884;
          __result = D.28882 - D.28885;
          D.28886 = __s1_len > 1;
          D.28876 = __result == 0;
          D.28887 = D.28886 & D.28876;
          if (D.28887 != 0) goto <D.28888>; else goto <D.28889>;
          <D.28888>:
          D.28890 = &MEM[(void *)"MonoField" + 2B];
          D.28891 = *D.28890;
          D.28892 = (int) D.28891;
          D.28893 = __s2 + 2;
          D.28894 = *D.28893;
          D.28895 = (int) D.28894;
          __result = D.28892 - D.28895;
          D.28896 = __s1_len > 2;
          D.28876 = __result == 0;
          D.28897 = D.28896 & D.28876;
          if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
          <D.28898>:
          D.28900 = &MEM[(void *)"MonoField" + 3B];
          D.28901 = *D.28900;
          D.28902 = (int) D.28901;
          D.28903 = __s2 + 3;
          D.28904 = *D.28903;
          D.28905 = (int) D.28904;
          __result = D.28902 - D.28905;
          <D.28899>:
          <D.28889>:
          <D.28879>:
        }
        D.22444 = __result;
      }
      iftmp.219 = D.22444;
      goto <D.28906>;
      <D.28869>:
      D.28907 = class->name;
      iftmp.219 = __builtin_strcmp ("MonoField", D.28907);
      <D.28906>:
      D.22448 = iftmp.219;
    }
    if (D.22448 == 0) goto <D.28908>; else goto <D.28909>;
    <D.28908>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.28913 = "System.Reflection";
        D.28914 = MEM[(const unsigned char *)D.28913];
        D.28915 = (int) D.28914;
        D.28916 = *__s2;
        D.28917 = (int) D.28916;
        __result = D.28915 - D.28917;
        {
          D.28918 = __s1_len != 0;
          D.28919 = __result == 0;
          D.28920 = D.28918 & D.28919;
          if (D.28920 != 0) goto <D.28921>; else goto <D.28922>;
          <D.28921>:
          D.28923 = &MEM[(void *)"System.Reflection" + 1B];
          D.28924 = *D.28923;
          D.28925 = (int) D.28924;
          D.28926 = __s2 + 1;
          D.28927 = *D.28926;
          D.28928 = (int) D.28927;
          __result = D.28925 - D.28928;
          D.28929 = __s1_len > 1;
          D.28919 = __result == 0;
          D.28930 = D.28929 & D.28919;
          if (D.28930 != 0) goto <D.28931>; else goto <D.28932>;
          <D.28931>:
          D.28933 = &MEM[(void *)"System.Reflection" + 2B];
          D.28934 = *D.28933;
          D.28935 = (int) D.28934;
          D.28936 = __s2 + 2;
          D.28937 = *D.28936;
          D.28938 = (int) D.28937;
          __result = D.28935 - D.28938;
          D.28939 = __s1_len > 2;
          D.28919 = __result == 0;
          D.28940 = D.28939 & D.28919;
          if (D.28940 != 0) goto <D.28941>; else goto <D.28942>;
          <D.28941>:
          D.28943 = &MEM[(void *)"System.Reflection" + 3B];
          D.28944 = *D.28943;
          D.28945 = (int) D.28944;
          D.28946 = __s2 + 3;
          D.28947 = *D.28946;
          D.28948 = (int) D.28947;
          __result = D.28945 - D.28948;
          <D.28942>:
          <D.28932>:
          <D.28922>:
        }
        D.22453 = __result;
      }
      iftmp.220 = D.22453;
      goto <D.28949>;
      <D.28912>:
      D.28950 = class->name_space;
      iftmp.220 = __builtin_strcmp ("System.Reflection", D.28950);
      <D.28949>:
      D.22457 = iftmp.220;
    }
    if (D.22457 == 0) goto <D.28951>; else goto <D.28952>;
    <D.28951>:
    cached_class = class;
    D.28862 = 1;
    return D.28862;
    <D.28952>:
    <D.28909>:
    <D.28866>:
    D.28862 = 0;
    return D.28862;
  }
}


mono_image_get_ctor_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorOnTypeBuilderInst * c, gboolean create_methodspec)
{
  struct MonoGHashTable * D.28954;
  void * D.28955;
  guint32 D.28958;
  struct MonoObject * D.28959;
  struct MonoVTable * D.28960;
  struct MonoClass * D.28961;
  int D.28962;
  struct MonoReflectionGenericClass * D.28965;
  unsigned char D.28966;
  unsigned char D.28967;
  _Bool D.28968;
  long int D.28969;
  long int D.28970;
  struct MonoString * D.28973;
  struct MonoType * D.28974;
  int D.28976;
  struct MonoMethodSignature * D.28979;
  const char * D.28980;
  void * token.221;
  guint32 sig;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoType * type;

  D.28954 = assembly->handleref_managed;
  D.28955 = mono_g_hash_table_lookup (D.28954, c);
  token = (guint32) D.28955;
  if (token != 0) goto <D.28956>; else goto <D.28957>;
  <D.28956>:
  D.28958 = token;
  return D.28958;
  <D.28957>:
  D.28959 = c->cb;
  D.28960 = D.28959->vtable;
  D.28961 = D.28960->klass;
  D.28962 = is_sre_ctor_builder (D.28961);
  if (D.28962 != 0) goto <D.28963>; else goto <D.28964>;
  <D.28963>:
  {
    struct MonoReflectionCtorBuilder * cb;
    struct MonoDynamicGenericClass * dgclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        cb = c->cb;
        D.28965 = c->inst;
        type = mono_reflection_type_get_handle (D.28965);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.28966 = BIT_FIELD_REF <*gclass, 8, 96>;
        D.28967 = D.28966 & 1;
        D.28968 = D.28967 == 0;
        D.28969 = (long int) D.28968;
        D.28970 = __builtin_expect (D.28969, 0);
        if (D.28970 != 0) goto <D.28971>; else goto <D.28972>;
        <D.28971>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2835, "gclass->is_dynamic");
        <D.28972>:
        dgclass = gclass;
        reflection_methodbuilder_from_ctor_builder (&rmb, cb);
        D.28973 = rmb.name;
        name = mono_string_to_utf8 (D.28973);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.28974 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.28974, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.28975>;
  <D.28964>:
  D.28959 = c->cb;
  D.28960 = D.28959->vtable;
  D.28961 = D.28960->klass;
  D.28976 = is_sr_mono_cmethod (D.28961);
  if (D.28976 != 0) goto <D.28977>; else goto <D.28978>;
  <D.28977>:
  {
    struct MonoMethod * mm;

    D.28959 = c->cb;
    mm = MEM[(struct MonoReflectionMethod *)D.28959].method;
    D.28965 = c->inst;
    type = mono_reflection_type_get_handle (D.28965);
    klass = mono_class_from_mono_type (type);
    D.28979 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.28979);
    D.28980 = mm->name;
    D.28974 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.28974, D.28980, sig);
  }
  goto <D.28981>;
  <D.28978>:
  {
    char * name;

    D.28959 = c->cb;
    D.28960 = D.28959->vtable;
    D.28961 = D.28960->klass;
    name = mono_type_get_full_name (D.28961);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19165>:
    goto <D.19165>;
  }
  <D.28981>:
  <D.28975>:
  token.221 = (void *) token;
  D.28954 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28954, c, token.221);
  D.28958 = token;
  return D.28958;
}


is_sre_ctor_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.222;
  gboolean D.28987;
  _Bool D.28988;
  int D.28989;
  int D.22268;
  int iftmp.223;
  int D.22264;
  const char[19] * D.28995;
  unsigned char D.28996;
  int D.28997;
  unsigned char D.28998;
  int D.28999;
  _Bool D.29000;
  _Bool D.29001;
  _Bool D.29002;
  const unsigned char * D.29005;
  unsigned char D.29006;
  int D.29007;
  const unsigned char * D.29008;
  unsigned char D.29009;
  int D.29010;
  _Bool D.29011;
  _Bool D.29012;
  const unsigned char * D.29015;
  unsigned char D.29016;
  int D.29017;
  const unsigned char * D.29018;
  unsigned char D.29019;
  int D.29020;
  _Bool D.29021;
  _Bool D.29022;
  const unsigned char * D.29025;
  unsigned char D.29026;
  int D.29027;
  const unsigned char * D.29028;
  unsigned char D.29029;
  int D.29030;
  const char * D.29032;
  int D.22277;
  int iftmp.224;
  int D.22273;
  const char[23] * D.29038;
  unsigned char D.29039;
  int D.29040;
  unsigned char D.29041;
  int D.29042;
  _Bool D.29043;
  _Bool D.29044;
  _Bool D.29045;
  const unsigned char * D.29048;
  unsigned char D.29049;
  int D.29050;
  const unsigned char * D.29051;
  unsigned char D.29052;
  int D.29053;
  _Bool D.29054;
  _Bool D.29055;
  const unsigned char * D.29058;
  unsigned char D.29059;
  int D.29060;
  const unsigned char * D.29061;
  unsigned char D.29062;
  int D.29063;
  _Bool D.29064;
  _Bool D.29065;
  const unsigned char * D.29068;
  unsigned char D.29069;
  int D.29070;
  const unsigned char * D.29071;
  unsigned char D.29072;
  int D.29073;
  const char * D.29075;

  {
    static struct MonoClass * cached_class;

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

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

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

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

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


is_sr_mono_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.225;
  gboolean D.29082;
  _Bool D.29083;
  int D.29084;
  int D.22514;
  int iftmp.226;
  int D.22510;
  const char[12] * D.29090;
  unsigned char D.29091;
  int D.29092;
  unsigned char D.29093;
  int D.29094;
  _Bool D.29095;
  _Bool D.29096;
  _Bool D.29097;
  const unsigned char * D.29100;
  unsigned char D.29101;
  int D.29102;
  const unsigned char * D.29103;
  unsigned char D.29104;
  int D.29105;
  _Bool D.29106;
  _Bool D.29107;
  const unsigned char * D.29110;
  unsigned char D.29111;
  int D.29112;
  const unsigned char * D.29113;
  unsigned char D.29114;
  int D.29115;
  _Bool D.29116;
  _Bool D.29117;
  const unsigned char * D.29120;
  unsigned char D.29121;
  int D.29122;
  const unsigned char * D.29123;
  unsigned char D.29124;
  int D.29125;
  const char * D.29127;
  int D.22523;
  int iftmp.227;
  int D.22519;
  const char[18] * D.29133;
  unsigned char D.29134;
  int D.29135;
  unsigned char D.29136;
  int D.29137;
  _Bool D.29138;
  _Bool D.29139;
  _Bool D.29140;
  const unsigned char * D.29143;
  unsigned char D.29144;
  int D.29145;
  const unsigned char * D.29146;
  unsigned char D.29147;
  int D.29148;
  _Bool D.29149;
  _Bool D.29150;
  const unsigned char * D.29153;
  unsigned char D.29154;
  int D.29155;
  const unsigned char * D.29156;
  unsigned char D.29157;
  int D.29158;
  _Bool D.29159;
  _Bool D.29160;
  const unsigned char * D.29163;
  unsigned char D.29164;
  int D.29165;
  const unsigned char * D.29166;
  unsigned char D.29167;
  int D.29168;
  const char * D.29170;

  {
    static struct MonoClass * cached_class;

    cached_class.225 = cached_class;
    if (cached_class.225 != 0B) goto <D.29080>; else goto <D.29081>;
    <D.29080>:
    cached_class.225 = cached_class;
    D.29083 = cached_class.225 == class;
    D.29082 = (gboolean) D.29083;
    return D.29082;
    <D.29081>:
    D.29084 = is_corlib_type (class);
    if (D.29084 != 0) goto <D.29085>; else goto <D.29086>;
    <D.29085>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29090 = "MonoCMethod";
        D.29091 = MEM[(const unsigned char *)D.29090];
        D.29092 = (int) D.29091;
        D.29093 = *__s2;
        D.29094 = (int) D.29093;
        __result = D.29092 - D.29094;
        {
          D.29095 = __s1_len != 0;
          D.29096 = __result == 0;
          D.29097 = D.29095 & D.29096;
          if (D.29097 != 0) goto <D.29098>; else goto <D.29099>;
          <D.29098>:
          D.29100 = &MEM[(void *)"MonoCMethod" + 1B];
          D.29101 = *D.29100;
          D.29102 = (int) D.29101;
          D.29103 = __s2 + 1;
          D.29104 = *D.29103;
          D.29105 = (int) D.29104;
          __result = D.29102 - D.29105;
          D.29106 = __s1_len > 1;
          D.29096 = __result == 0;
          D.29107 = D.29106 & D.29096;
          if (D.29107 != 0) goto <D.29108>; else goto <D.29109>;
          <D.29108>:
          D.29110 = &MEM[(void *)"MonoCMethod" + 2B];
          D.29111 = *D.29110;
          D.29112 = (int) D.29111;
          D.29113 = __s2 + 2;
          D.29114 = *D.29113;
          D.29115 = (int) D.29114;
          __result = D.29112 - D.29115;
          D.29116 = __s1_len > 2;
          D.29096 = __result == 0;
          D.29117 = D.29116 & D.29096;
          if (D.29117 != 0) goto <D.29118>; else goto <D.29119>;
          <D.29118>:
          D.29120 = &MEM[(void *)"MonoCMethod" + 3B];
          D.29121 = *D.29120;
          D.29122 = (int) D.29121;
          D.29123 = __s2 + 3;
          D.29124 = *D.29123;
          D.29125 = (int) D.29124;
          __result = D.29122 - D.29125;
          <D.29119>:
          <D.29109>:
          <D.29099>:
        }
        D.22510 = __result;
      }
      iftmp.226 = D.22510;
      goto <D.29126>;
      <D.29089>:
      D.29127 = class->name;
      iftmp.226 = __builtin_strcmp ("MonoCMethod", D.29127);
      <D.29126>:
      D.22514 = iftmp.226;
    }
    if (D.22514 == 0) goto <D.29128>; else goto <D.29129>;
    <D.29128>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29133 = "System.Reflection";
        D.29134 = MEM[(const unsigned char *)D.29133];
        D.29135 = (int) D.29134;
        D.29136 = *__s2;
        D.29137 = (int) D.29136;
        __result = D.29135 - D.29137;
        {
          D.29138 = __s1_len != 0;
          D.29139 = __result == 0;
          D.29140 = D.29138 & D.29139;
          if (D.29140 != 0) goto <D.29141>; else goto <D.29142>;
          <D.29141>:
          D.29143 = &MEM[(void *)"System.Reflection" + 1B];
          D.29144 = *D.29143;
          D.29145 = (int) D.29144;
          D.29146 = __s2 + 1;
          D.29147 = *D.29146;
          D.29148 = (int) D.29147;
          __result = D.29145 - D.29148;
          D.29149 = __s1_len > 1;
          D.29139 = __result == 0;
          D.29150 = D.29149 & D.29139;
          if (D.29150 != 0) goto <D.29151>; else goto <D.29152>;
          <D.29151>:
          D.29153 = &MEM[(void *)"System.Reflection" + 2B];
          D.29154 = *D.29153;
          D.29155 = (int) D.29154;
          D.29156 = __s2 + 2;
          D.29157 = *D.29156;
          D.29158 = (int) D.29157;
          __result = D.29155 - D.29158;
          D.29159 = __s1_len > 2;
          D.29139 = __result == 0;
          D.29160 = D.29159 & D.29139;
          if (D.29160 != 0) goto <D.29161>; else goto <D.29162>;
          <D.29161>:
          D.29163 = &MEM[(void *)"System.Reflection" + 3B];
          D.29164 = *D.29163;
          D.29165 = (int) D.29164;
          D.29166 = __s2 + 3;
          D.29167 = *D.29166;
          D.29168 = (int) D.29167;
          __result = D.29165 - D.29168;
          <D.29162>:
          <D.29152>:
          <D.29142>:
        }
        D.22519 = __result;
      }
      iftmp.227 = D.22519;
      goto <D.29169>;
      <D.29132>:
      D.29170 = class->name_space;
      iftmp.227 = __builtin_strcmp ("System.Reflection", D.29170);
      <D.29169>:
      D.22523 = iftmp.227;
    }
    if (D.22523 == 0) goto <D.29171>; else goto <D.29172>;
    <D.29171>:
    cached_class = class;
    D.29082 = 1;
    return D.29082;
    <D.29172>:
    <D.29129>:
    <D.29086>:
    D.29082 = 0;
    return D.29082;
  }
}


mono_image_get_method_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodOnTypeBuilderInst * m, gboolean create_methodspec)
{
  struct MonoArray * D.29174;
  guint32 D.29180;
  struct MonoGHashTable * D.29181;
  void * D.29182;
  struct MonoObject * D.29185;
  struct MonoVTable * D.29186;
  struct MonoClass * D.29187;
  int D.29188;
  struct MonoReflectionType * D.29191;
  unsigned char D.29192;
  unsigned char D.29193;
  _Bool D.29194;
  long int D.29195;
  long int D.29196;
  struct MonoString * D.29199;
  struct MonoType * D.29200;
  int D.29202;
  struct MonoMethodSignature * D.29205;
  const char * D.29206;
  void * token.228;
  guint32 sig;
  guint32 token;
  struct MonoType * type;
  struct MonoClass * klass;

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

    inflated = mono_reflection_method_on_tb_inst_get_handle (m);
    if (create_methodspec != 0) goto <D.29177>; else goto <D.29178>;
    <D.29177>:
    token = mono_image_get_methodspec_token (assembly, inflated);
    goto <D.29179>;
    <D.29178>:
    token = mono_image_get_inflated_method_token (assembly, inflated);
    <D.29179>:
    D.29180 = token;
    return D.29180;
  }
  <D.29176>:
  D.29181 = assembly->handleref_managed;
  D.29182 = mono_g_hash_table_lookup (D.29181, m);
  token = (guint32) D.29182;
  if (token != 0) goto <D.29183>; else goto <D.29184>;
  <D.29183>:
  D.29180 = token;
  return D.29180;
  <D.29184>:
  D.29185 = m->mb;
  D.29186 = D.29185->vtable;
  D.29187 = D.29186->klass;
  D.29188 = is_sre_method_builder (D.29187);
  if (D.29188 != 0) goto <D.29189>; else goto <D.29190>;
  <D.29189>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoGenericClass * gclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        mb = m->mb;
        D.29191 = m->inst;
        type = mono_reflection_type_get_handle (D.29191);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.29192 = BIT_FIELD_REF <*gclass, 8, 96>;
        D.29193 = D.29192 & 1;
        D.29194 = D.29193 == 0;
        D.29195 = (long int) D.29194;
        D.29196 = __builtin_expect (D.29195, 0);
        if (D.29196 != 0) goto <D.29197>; else goto <D.29198>;
        <D.29197>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2934, "gclass->is_dynamic");
        <D.29198>:
        reflection_methodbuilder_from_method_builder (&rmb, mb);
        D.29199 = rmb.name;
        name = mono_string_to_utf8 (D.29199);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.29200 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.29200, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.29201>;
  <D.29190>:
  D.29185 = m->mb;
  D.29186 = D.29185->vtable;
  D.29187 = D.29186->klass;
  D.29202 = is_sr_mono_method (D.29187);
  if (D.29202 != 0) goto <D.29203>; else goto <D.29204>;
  <D.29203>:
  {
    struct MonoMethod * mm;

    D.29185 = m->mb;
    mm = MEM[(struct MonoReflectionMethod *)D.29185].method;
    D.29191 = m->inst;
    type = mono_reflection_type_get_handle (D.29191);
    klass = mono_class_from_mono_type (type);
    D.29205 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.29205);
    D.29206 = mm->name;
    D.29200 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.29200, D.29206, sig);
  }
  goto <D.29207>;
  <D.29204>:
  {
    char * name;

    D.29185 = m->mb;
    D.29186 = D.29185->vtable;
    D.29187 = D.29186->klass;
    name = mono_type_get_full_name (D.29187);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19197>:
    goto <D.19197>;
  }
  <D.29207>:
  <D.29201>:
  token.228 = (void *) token;
  D.29181 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.29181, m, token.228);
  D.29180 = token;
  return D.29180;
}


mono_reflection_method_on_tb_inst_get_handle (struct MonoReflectionMethodOnTypeBuilderInst * m)
{
  struct MonoReflectionType * D.29210;
  struct MonoObject * D.29211;
  struct MonoArray * D.29212;
  struct MonoMethod * D.29215;
  unsigned char D.29216;
  unsigned char D.29217;
  unsigned int D.29220;
  unsigned int count.229;
  unsigned int D.29222;
  unsigned int i.230;
  char * D.29224;
  unsigned int i.231;
  unsigned int D.29226;
  struct MonoType * * D.29227;
  struct MonoType * D.29228;
  struct MonoGenericInst * iftmp.232;
  struct MonoGenericClass * D.29230;
  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.29210 = m->inst;
      init_type_builder_generics (D.29210);
      D.29211 = m->mb;
      D.29210 = m->inst;
      method = inflate_method (D.29210, D.29211);
      klass = method->klass;
      D.29212 = m->method_args;
      if (D.29212 == 0B) goto <D.29213>; else goto <D.29214>;
      <D.29213>:
      D.29215 = method;
      return D.29215;
      <D.29214>:
      D.29216 = BIT_FIELD_REF <*method, 8, 168>;
      D.29217 = D.29216 & 16;
      if (D.29217 != 0) goto <D.29218>; else goto <D.29219>;
      <D.29218>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.29219>:
      D.29212 = m->method_args;
      D.29220 = mono_array_length (D.29212);
      count = (int) D.29220;
      count.229 = (unsigned int) count;
      D.29222 = count.229 * 4;
      type_argv = monoeg_malloc0 (D.29222);
      i = 0;
      goto <D.19179>;
      <D.19178>:
      {
        struct MonoReflectionType * garg;

        i.230 = (unsigned int) i;
        D.29212 = m->method_args;
        D.29224 = mono_array_addr_with_size (D.29212, 4, i.230);
        garg = MEM[(void * *)D.29224];
        i.231 = (unsigned int) i;
        D.29226 = i.231 * 4;
        D.29227 = type_argv + D.29226;
        D.29228 = mono_reflection_type_get_handle (garg);
        *D.29227 = D.29228;
      }
      i = i + 1;
      <D.19179>:
      if (i < count) goto <D.19178>; else goto <D.19180>;
      <D.19180>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.29230 = klass->generic_class;
      if (D.29230 != 0B) goto <D.29231>; else goto <D.29232>;
      <D.29231>:
      D.29230 = klass->generic_class;
      iftmp.232 = D.29230->context.class_inst;
      goto <D.29233>;
      <D.29232>:
      iftmp.232 = 0B;
      <D.29233>:
      tmp_context.class_inst = iftmp.232;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      D.29215 = inflated;
      return D.29215;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_method (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoVTable * D.29236;
  int D.29237;
  struct MonoReflectionType * D.29240;
  struct MonoType * D.29241;
  int D.29243;
  struct MonoType * D.29246;
  struct MonoType * D.29248;
  struct MonoClass * D.29252;
  char * D.29253;
  int D.23020;
  int iftmp.233;
  int D.23019;
  struct MonoVTable * D.29257;
  struct MonoClass * D.29258;
  const char[14] * D.29259;
  unsigned char D.29260;
  int D.29261;
  unsigned char D.29262;
  int D.29263;
  _Bool D.29264;
  _Bool D.29265;
  _Bool D.29266;
  const unsigned char * D.29269;
  unsigned char D.29270;
  int D.29271;
  const unsigned char * D.29272;
  unsigned char D.29273;
  int D.29274;
  _Bool D.29275;
  _Bool D.29276;
  const unsigned char * D.29279;
  unsigned char D.29280;
  int D.29281;
  const unsigned char * D.29282;
  unsigned char D.29283;
  int D.29284;
  _Bool D.29285;
  _Bool D.29286;
  const unsigned char * D.29289;
  unsigned char D.29290;
  int D.29291;
  const unsigned char * D.29292;
  unsigned char D.29293;
  int D.29294;
  const char * D.29296;
  struct MonoMethod * D.29299;
  int D.23029;
  int iftmp.234;
  int D.23028;
  const char[19] * D.29307;
  unsigned char D.29308;
  int D.29309;
  unsigned char D.29310;
  int D.29311;
  _Bool D.29312;
  _Bool D.29313;
  _Bool D.29314;
  const unsigned char * D.29317;
  unsigned char D.29318;
  int D.29319;
  const unsigned char * D.29320;
  unsigned char D.29321;
  int D.29322;
  _Bool D.29323;
  _Bool D.29324;
  const unsigned char * D.29327;
  unsigned char D.29328;
  int D.29329;
  const unsigned char * D.29330;
  unsigned char D.29331;
  int D.29332;
  _Bool D.29333;
  _Bool D.29334;
  const unsigned char * D.29337;
  unsigned char D.29338;
  int D.29339;
  const unsigned char * D.29340;
  unsigned char D.29341;
  int D.29342;
  int D.23038;
  int iftmp.235;
  int D.23037;
  const char[11] * D.29353;
  unsigned char D.29354;
  int D.29355;
  unsigned char D.29356;
  int D.29357;
  _Bool D.29358;
  _Bool D.29359;
  _Bool D.29360;
  const unsigned char * D.29363;
  unsigned char D.29364;
  int D.29365;
  const unsigned char * D.29366;
  unsigned char D.29367;
  int D.29368;
  _Bool D.29369;
  _Bool D.29370;
  const unsigned char * D.29373;
  unsigned char D.29374;
  int D.29375;
  const unsigned char * D.29376;
  unsigned char D.29377;
  int D.29378;
  _Bool D.29379;
  _Bool D.29380;
  const unsigned char * D.29383;
  unsigned char D.29384;
  int D.29385;
  const unsigned char * D.29386;
  unsigned char D.29387;
  int D.29388;
  int D.23047;
  int iftmp.236;
  int D.23046;
  const char[12] * D.29394;
  unsigned char D.29395;
  int D.29396;
  unsigned char D.29397;
  int D.29398;
  _Bool D.29399;
  _Bool D.29400;
  _Bool D.29401;
  const unsigned char * D.29404;
  unsigned char D.29405;
  int D.29406;
  const unsigned char * D.29407;
  unsigned char D.29408;
  int D.29409;
  _Bool D.29410;
  _Bool D.29411;
  const unsigned char * D.29414;
  unsigned char D.29415;
  int D.29416;
  const unsigned char * D.29417;
  unsigned char D.29418;
  int D.29419;
  _Bool D.29420;
  _Bool D.29421;
  const unsigned char * D.29424;
  unsigned char D.29425;
  int D.29426;
  const unsigned char * D.29427;
  unsigned char D.29428;
  int D.29429;
  struct MonoMethod * D.29431;
  struct MonoType * D.29432;
  struct MonoClass * D.29433;
  struct MonoMethod * method;
  struct MonoClass * gklass;
  struct MonoClass * type_class;

  D.29236 = MEM[(struct MonoObject *)type].vtable;
  type_class = D.29236->klass;
  D.29237 = is_sre_generic_instance (type_class);
  if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
  <D.29238>:
  {
    struct MonoReflectionGenericClass * mgc;

    mgc = type;
    D.29240 = mgc->generic_type;
    D.29241 = mono_reflection_type_get_handle (D.29240);
    gklass = mono_class_from_mono_type (D.29241);
  }
  goto <D.29242>;
  <D.29239>:
  D.29243 = is_sre_type_builder (type_class);
  if (D.29243 != 0) goto <D.29244>; else goto <D.29245>;
  <D.29244>:
  D.29246 = mono_reflection_type_get_handle (type);
  gklass = mono_class_from_mono_type (D.29246);
  goto <D.29247>;
  <D.29245>:
  D.29248 = type->type;
  if (D.29248 != 0B) goto <D.29249>; else goto <D.29250>;
  <D.29249>:
  D.29248 = type->type;
  gklass = mono_class_from_mono_type (D.29248);
  gklass = mono_class_get_generic_type_definition (gklass);
  goto <D.29251>;
  <D.29250>:
  D.29236 = MEM[(struct MonoObject *)type].vtable;
  D.29252 = D.29236->klass;
  D.29253 = mono_type_get_full_name (D.29252);
  monoeg_g_log (0B, 4, "Can\'t handle type %s", D.29253);
  <D.23011>:
  goto <D.23011>;
  <D.29251>:
  <D.29247>:
  <D.29242>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29257 = obj->vtable;
      D.29258 = D.29257->klass;
      __s2 = D.29258->name;
      D.29259 = "MethodBuilder";
      D.29260 = MEM[(const unsigned char *)D.29259];
      D.29261 = (int) D.29260;
      D.29262 = *__s2;
      D.29263 = (int) D.29262;
      __result = D.29261 - D.29263;
      {
        D.29264 = __s2_len != 0;
        D.29265 = __result == 0;
        D.29266 = D.29264 & D.29265;
        if (D.29266 != 0) goto <D.29267>; else goto <D.29268>;
        <D.29267>:
        D.29269 = &MEM[(void *)"MethodBuilder" + 1B];
        D.29270 = *D.29269;
        D.29271 = (int) D.29270;
        D.29272 = __s2 + 1;
        D.29273 = *D.29272;
        D.29274 = (int) D.29273;
        __result = D.29271 - D.29274;
        D.29275 = __s2_len > 1;
        D.29265 = __result == 0;
        D.29276 = D.29275 & D.29265;
        if (D.29276 != 0) goto <D.29277>; else goto <D.29278>;
        <D.29277>:
        D.29279 = &MEM[(void *)"MethodBuilder" + 2B];
        D.29280 = *D.29279;
        D.29281 = (int) D.29280;
        D.29282 = __s2 + 2;
        D.29283 = *D.29282;
        D.29284 = (int) D.29283;
        __result = D.29281 - D.29284;
        D.29285 = __s2_len > 2;
        D.29265 = __result == 0;
        D.29286 = D.29285 & D.29265;
        if (D.29286 != 0) goto <D.29287>; else goto <D.29288>;
        <D.29287>:
        D.29289 = &MEM[(void *)"MethodBuilder" + 3B];
        D.29290 = *D.29289;
        D.29291 = (int) D.29290;
        D.29292 = __s2 + 3;
        D.29293 = *D.29292;
        D.29294 = (int) D.29293;
        __result = D.29291 - D.29294;
        <D.29288>:
        <D.29278>:
        <D.29268>:
      }
      D.23019 = __result;
    }
    iftmp.233 = -D.23019;
    goto <D.29295>;
    <D.29256>:
    D.29257 = obj->vtable;
    D.29258 = D.29257->klass;
    D.29296 = D.29258->name;
    iftmp.233 = __builtin_strcmp (D.29296, "MethodBuilder");
    <D.29295>:
    D.23020 = iftmp.233;
  }
  if (D.23020 == 0) goto <D.29297>; else goto <D.29298>;
  <D.29297>:
  D.29299 = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  if (D.29299 != 0B) goto <D.29300>; else goto <D.29301>;
  <D.29300>:
  method = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  goto <D.29302>;
  <D.29301>:
  method = methodbuilder_to_mono_method (gklass, obj);
  <D.29302>:
  goto <D.29303>;
  <D.29298>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29257 = obj->vtable;
      D.29258 = D.29257->klass;
      __s2 = D.29258->name;
      D.29307 = "ConstructorBuilder";
      D.29308 = MEM[(const unsigned char *)D.29307];
      D.29309 = (int) D.29308;
      D.29310 = *__s2;
      D.29311 = (int) D.29310;
      __result = D.29309 - D.29311;
      {
        D.29312 = __s2_len != 0;
        D.29313 = __result == 0;
        D.29314 = D.29312 & D.29313;
        if (D.29314 != 0) goto <D.29315>; else goto <D.29316>;
        <D.29315>:
        D.29317 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.29318 = *D.29317;
        D.29319 = (int) D.29318;
        D.29320 = __s2 + 1;
        D.29321 = *D.29320;
        D.29322 = (int) D.29321;
        __result = D.29319 - D.29322;
        D.29323 = __s2_len > 1;
        D.29313 = __result == 0;
        D.29324 = D.29323 & D.29313;
        if (D.29324 != 0) goto <D.29325>; else goto <D.29326>;
        <D.29325>:
        D.29327 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.29328 = *D.29327;
        D.29329 = (int) D.29328;
        D.29330 = __s2 + 2;
        D.29331 = *D.29330;
        D.29332 = (int) D.29331;
        __result = D.29329 - D.29332;
        D.29333 = __s2_len > 2;
        D.29313 = __result == 0;
        D.29334 = D.29333 & D.29313;
        if (D.29334 != 0) goto <D.29335>; else goto <D.29336>;
        <D.29335>:
        D.29337 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.29338 = *D.29337;
        D.29339 = (int) D.29338;
        D.29340 = __s2 + 3;
        D.29341 = *D.29340;
        D.29342 = (int) D.29341;
        __result = D.29339 - D.29342;
        <D.29336>:
        <D.29326>:
        <D.29316>:
      }
      D.23028 = __result;
    }
    iftmp.234 = -D.23028;
    goto <D.29343>;
    <D.29306>:
    D.29257 = obj->vtable;
    D.29258 = D.29257->klass;
    D.29296 = D.29258->name;
    iftmp.234 = __builtin_strcmp (D.29296, "ConstructorBuilder");
    <D.29343>:
    D.23029 = iftmp.234;
  }
  if (D.23029 == 0) goto <D.29344>; else goto <D.29345>;
  <D.29344>:
  method = ctorbuilder_to_mono_method (gklass, obj);
  goto <D.29346>;
  <D.29345>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29257 = obj->vtable;
      D.29258 = D.29257->klass;
      __s2 = D.29258->name;
      D.29353 = "MonoMethod";
      D.29354 = MEM[(const unsigned char *)D.29353];
      D.29355 = (int) D.29354;
      D.29356 = *__s2;
      D.29357 = (int) D.29356;
      __result = D.29355 - D.29357;
      {
        D.29358 = __s2_len != 0;
        D.29359 = __result == 0;
        D.29360 = D.29358 & D.29359;
        if (D.29360 != 0) goto <D.29361>; else goto <D.29362>;
        <D.29361>:
        D.29363 = &MEM[(void *)"MonoMethod" + 1B];
        D.29364 = *D.29363;
        D.29365 = (int) D.29364;
        D.29366 = __s2 + 1;
        D.29367 = *D.29366;
        D.29368 = (int) D.29367;
        __result = D.29365 - D.29368;
        D.29369 = __s2_len > 1;
        D.29359 = __result == 0;
        D.29370 = D.29369 & D.29359;
        if (D.29370 != 0) goto <D.29371>; else goto <D.29372>;
        <D.29371>:
        D.29373 = &MEM[(void *)"MonoMethod" + 2B];
        D.29374 = *D.29373;
        D.29375 = (int) D.29374;
        D.29376 = __s2 + 2;
        D.29377 = *D.29376;
        D.29378 = (int) D.29377;
        __result = D.29375 - D.29378;
        D.29379 = __s2_len > 2;
        D.29359 = __result == 0;
        D.29380 = D.29379 & D.29359;
        if (D.29380 != 0) goto <D.29381>; else goto <D.29382>;
        <D.29381>:
        D.29383 = &MEM[(void *)"MonoMethod" + 3B];
        D.29384 = *D.29383;
        D.29385 = (int) D.29384;
        D.29386 = __s2 + 3;
        D.29387 = *D.29386;
        D.29388 = (int) D.29387;
        __result = D.29385 - D.29388;
        <D.29382>:
        <D.29372>:
        <D.29362>:
      }
      D.23037 = __result;
    }
    iftmp.235 = -D.23037;
    goto <D.29389>;
    <D.29352>:
    D.29257 = obj->vtable;
    D.29258 = D.29257->klass;
    D.29296 = D.29258->name;
    iftmp.235 = __builtin_strcmp (D.29296, "MonoMethod");
    <D.29389>:
    D.23038 = iftmp.235;
  }
  if (D.23038 == 0) goto <D.29347>; else goto <D.29390>;
  <D.29390>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29257 = obj->vtable;
      D.29258 = D.29257->klass;
      __s2 = D.29258->name;
      D.29394 = "MonoCMethod";
      D.29395 = MEM[(const unsigned char *)D.29394];
      D.29396 = (int) D.29395;
      D.29397 = *__s2;
      D.29398 = (int) D.29397;
      __result = D.29396 - D.29398;
      {
        D.29399 = __s2_len != 0;
        D.29400 = __result == 0;
        D.29401 = D.29399 & D.29400;
        if (D.29401 != 0) goto <D.29402>; else goto <D.29403>;
        <D.29402>:
        D.29404 = &MEM[(void *)"MonoCMethod" + 1B];
        D.29405 = *D.29404;
        D.29406 = (int) D.29405;
        D.29407 = __s2 + 1;
        D.29408 = *D.29407;
        D.29409 = (int) D.29408;
        __result = D.29406 - D.29409;
        D.29410 = __s2_len > 1;
        D.29400 = __result == 0;
        D.29411 = D.29410 & D.29400;
        if (D.29411 != 0) goto <D.29412>; else goto <D.29413>;
        <D.29412>:
        D.29414 = &MEM[(void *)"MonoCMethod" + 2B];
        D.29415 = *D.29414;
        D.29416 = (int) D.29415;
        D.29417 = __s2 + 2;
        D.29418 = *D.29417;
        D.29419 = (int) D.29418;
        __result = D.29416 - D.29419;
        D.29420 = __s2_len > 2;
        D.29400 = __result == 0;
        D.29421 = D.29420 & D.29400;
        if (D.29421 != 0) goto <D.29422>; else goto <D.29423>;
        <D.29422>:
        D.29424 = &MEM[(void *)"MonoCMethod" + 3B];
        D.29425 = *D.29424;
        D.29426 = (int) D.29425;
        D.29427 = __s2 + 3;
        D.29428 = *D.29427;
        D.29429 = (int) D.29428;
        __result = D.29426 - D.29429;
        <D.29423>:
        <D.29413>:
        <D.29403>:
      }
      D.23046 = __result;
    }
    iftmp.236 = -D.23046;
    goto <D.29430>;
    <D.29393>:
    D.29257 = obj->vtable;
    D.29258 = D.29257->klass;
    D.29296 = D.29258->name;
    iftmp.236 = __builtin_strcmp (D.29296, "MonoCMethod");
    <D.29430>:
    D.23047 = iftmp.236;
  }
  if (D.23047 == 0) goto <D.29347>; else goto <D.29348>;
  <D.29347>:
  method = MEM[(struct MonoReflectionMethod *)obj].method;
  goto <D.29349>;
  <D.29348>:
  method = 0B;
  D.29257 = obj->vtable;
  D.29258 = D.29257->klass;
  D.29296 = D.29258->name;
  monoeg_g_log (0B, 4, "can\'t handle type %s", D.29296);
  <D.23048>:
  goto <D.23048>;
  <D.29349>:
  <D.29346>:
  <D.29303>:
  D.29432 = mono_reflection_type_get_handle (type);
  D.29433 = mono_class_from_mono_type (D.29432);
  D.29431 = inflate_mono_method (D.29433, method, obj);
  return D.29431;
}


is_sre_generic_instance (struct MonoClass * class)
{
  struct MonoClass * cached_class.237;
  gboolean D.29438;
  _Bool D.29439;
  int D.29440;
  int D.22202;
  int iftmp.238;
  int D.22198;
  const char[17] * D.29446;
  unsigned char D.29447;
  int D.29448;
  unsigned char D.29449;
  int D.29450;
  _Bool D.29451;
  _Bool D.29452;
  _Bool D.29453;
  const unsigned char * D.29456;
  unsigned char D.29457;
  int D.29458;
  const unsigned char * D.29459;
  unsigned char D.29460;
  int D.29461;
  _Bool D.29462;
  _Bool D.29463;
  const unsigned char * D.29466;
  unsigned char D.29467;
  int D.29468;
  const unsigned char * D.29469;
  unsigned char D.29470;
  int D.29471;
  _Bool D.29472;
  _Bool D.29473;
  const unsigned char * D.29476;
  unsigned char D.29477;
  int D.29478;
  const unsigned char * D.29479;
  unsigned char D.29480;
  int D.29481;
  const char * D.29483;
  int D.22211;
  int iftmp.239;
  int D.22207;
  const char[18] * D.29489;
  unsigned char D.29490;
  int D.29491;
  unsigned char D.29492;
  int D.29493;
  _Bool D.29494;
  _Bool D.29495;
  _Bool D.29496;
  const unsigned char * D.29499;
  unsigned char D.29500;
  int D.29501;
  const unsigned char * D.29502;
  unsigned char D.29503;
  int D.29504;
  _Bool D.29505;
  _Bool D.29506;
  const unsigned char * D.29509;
  unsigned char D.29510;
  int D.29511;
  const unsigned char * D.29512;
  unsigned char D.29513;
  int D.29514;
  _Bool D.29515;
  _Bool D.29516;
  const unsigned char * D.29519;
  unsigned char D.29520;
  int D.29521;
  const unsigned char * D.29522;
  unsigned char D.29523;
  int D.29524;
  const char * D.29526;

  {
    static struct MonoClass * cached_class;

    cached_class.237 = cached_class;
    if (cached_class.237 != 0B) goto <D.29436>; else goto <D.29437>;
    <D.29436>:
    cached_class.237 = cached_class;
    D.29439 = cached_class.237 == class;
    D.29438 = (gboolean) D.29439;
    return D.29438;
    <D.29437>:
    D.29440 = is_corlib_type (class);
    if (D.29440 != 0) goto <D.29441>; else goto <D.29442>;
    <D.29441>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29446 = "MonoGenericClass";
        D.29447 = MEM[(const unsigned char *)D.29446];
        D.29448 = (int) D.29447;
        D.29449 = *__s2;
        D.29450 = (int) D.29449;
        __result = D.29448 - D.29450;
        {
          D.29451 = __s1_len != 0;
          D.29452 = __result == 0;
          D.29453 = D.29451 & D.29452;
          if (D.29453 != 0) goto <D.29454>; else goto <D.29455>;
          <D.29454>:
          D.29456 = &MEM[(void *)"MonoGenericClass" + 1B];
          D.29457 = *D.29456;
          D.29458 = (int) D.29457;
          D.29459 = __s2 + 1;
          D.29460 = *D.29459;
          D.29461 = (int) D.29460;
          __result = D.29458 - D.29461;
          D.29462 = __s1_len > 1;
          D.29452 = __result == 0;
          D.29463 = D.29462 & D.29452;
          if (D.29463 != 0) goto <D.29464>; else goto <D.29465>;
          <D.29464>:
          D.29466 = &MEM[(void *)"MonoGenericClass" + 2B];
          D.29467 = *D.29466;
          D.29468 = (int) D.29467;
          D.29469 = __s2 + 2;
          D.29470 = *D.29469;
          D.29471 = (int) D.29470;
          __result = D.29468 - D.29471;
          D.29472 = __s1_len > 2;
          D.29452 = __result == 0;
          D.29473 = D.29472 & D.29452;
          if (D.29473 != 0) goto <D.29474>; else goto <D.29475>;
          <D.29474>:
          D.29476 = &MEM[(void *)"MonoGenericClass" + 3B];
          D.29477 = *D.29476;
          D.29478 = (int) D.29477;
          D.29479 = __s2 + 3;
          D.29480 = *D.29479;
          D.29481 = (int) D.29480;
          __result = D.29478 - D.29481;
          <D.29475>:
          <D.29465>:
          <D.29455>:
        }
        D.22198 = __result;
      }
      iftmp.238 = D.22198;
      goto <D.29482>;
      <D.29445>:
      D.29483 = class->name;
      iftmp.238 = __builtin_strcmp ("MonoGenericClass", D.29483);
      <D.29482>:
      D.22202 = iftmp.238;
    }
    if (D.22202 == 0) goto <D.29484>; else goto <D.29485>;
    <D.29484>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29489 = "System.Reflection";
        D.29490 = MEM[(const unsigned char *)D.29489];
        D.29491 = (int) D.29490;
        D.29492 = *__s2;
        D.29493 = (int) D.29492;
        __result = D.29491 - D.29493;
        {
          D.29494 = __s1_len != 0;
          D.29495 = __result == 0;
          D.29496 = D.29494 & D.29495;
          if (D.29496 != 0) goto <D.29497>; else goto <D.29498>;
          <D.29497>:
          D.29499 = &MEM[(void *)"System.Reflection" + 1B];
          D.29500 = *D.29499;
          D.29501 = (int) D.29500;
          D.29502 = __s2 + 1;
          D.29503 = *D.29502;
          D.29504 = (int) D.29503;
          __result = D.29501 - D.29504;
          D.29505 = __s1_len > 1;
          D.29495 = __result == 0;
          D.29506 = D.29505 & D.29495;
          if (D.29506 != 0) goto <D.29507>; else goto <D.29508>;
          <D.29507>:
          D.29509 = &MEM[(void *)"System.Reflection" + 2B];
          D.29510 = *D.29509;
          D.29511 = (int) D.29510;
          D.29512 = __s2 + 2;
          D.29513 = *D.29512;
          D.29514 = (int) D.29513;
          __result = D.29511 - D.29514;
          D.29515 = __s1_len > 2;
          D.29495 = __result == 0;
          D.29516 = D.29515 & D.29495;
          if (D.29516 != 0) goto <D.29517>; else goto <D.29518>;
          <D.29517>:
          D.29519 = &MEM[(void *)"System.Reflection" + 3B];
          D.29520 = *D.29519;
          D.29521 = (int) D.29520;
          D.29522 = __s2 + 3;
          D.29523 = *D.29522;
          D.29524 = (int) D.29523;
          __result = D.29521 - D.29524;
          <D.29518>:
          <D.29508>:
          <D.29498>:
        }
        D.22207 = __result;
      }
      iftmp.239 = D.22207;
      goto <D.29525>;
      <D.29488>:
      D.29526 = class->name_space;
      iftmp.239 = __builtin_strcmp ("System.Reflection", D.29526);
      <D.29525>:
      D.22211 = iftmp.239;
    }
    if (D.22211 == 0) goto <D.29527>; else goto <D.29528>;
    <D.29527>:
    cached_class = class;
    D.29438 = 1;
    return D.29438;
    <D.29528>:
    <D.29485>:
    <D.29442>:
    D.29438 = 0;
    return D.29438;
  }
}


methodbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoImage * D.29530;
  struct MonoMethod * D.29531;
  struct MonoArray * D.29532;
  struct MonoMethod * D.29533;
  int D.29534;
  struct MonoGenericContainer * D.29537;
  struct MonoMethod * D.29540;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.29530 = klass->image;
      sig = method_builder_to_signature (D.29530, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_method_builder (&rmb, mb);
      D.29531 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.29531;
      D.29532 = mb->cattrs;
      D.29533 = mb->mhandle;
      D.29530 = klass->image;
      mono_save_custom_attrs (D.29530, D.29533, D.29532);
      D.29530 = klass->image;
      D.29534 = MEM[(struct MonoDynamicImage *)D.29530].save;
      if (D.29534 == 0) goto <D.29535>; else goto <D.29536>;
      <D.29535>:
      D.29537 = klass->generic_container;
      if (D.29537 == 0B) goto <D.29538>; else goto <D.29539>;
      <D.29538>:
      mb->ilgen = 0B;
      <D.29539>:
      <D.29536>:
      D.29540 = mb->mhandle;
      return D.29540;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


method_builder_to_signature (struct MonoImage * image, struct MonoReflectionMethodBuilder * method)
{
  struct MonoArray * D.29543;
  unsigned int D.29544;
  unsigned int D.29545;
  _Bool D.29546;
  struct MonoType * iftmp.240;
  struct MonoObject * D.29548;
  struct MonoClass * D.29552;
  short unsigned int iftmp.241;
  struct MonoArray * D.29554;
  unsigned int D.29557;
  struct MonoMethodSignature * D.29559;
  struct MonoMethodSignature * sig;

  D.29543 = method->parameters;
  sig = parameters_to_signature (image, D.29543);
  D.29544 = method->attrs;
  D.29545 = D.29544 & 16;
  D.29546 = D.29545 == 0;
  sig->hasthis = D.29546;
  D.29548 = method->rtype;
  if (D.29548 != 0B) goto <D.29549>; else goto <D.29550>;
  <D.29549>:
  D.29548 = method->rtype;
  iftmp.240 = mono_reflection_type_get_handle (D.29548);
  goto <D.29551>;
  <D.29550>:
  D.29552 = mono_defaults.void_class;
  iftmp.240 = &D.29552->byval_arg;
  <D.29551>:
  sig->ret = iftmp.240;
  D.29554 = method->generic_params;
  if (D.29554 != 0B) goto <D.29555>; else goto <D.29556>;
  <D.29555>:
  D.29554 = method->generic_params;
  D.29557 = mono_array_length (D.29554);
  iftmp.241 = (short unsigned int) D.29557;
  goto <D.29558>;
  <D.29556>:
  iftmp.241 = 0;
  <D.29558>:
  sig->generic_param_count = iftmp.241;
  D.29559 = sig;
  return D.29559;
}


parameters_to_signature (struct MonoImage * image, struct MonoArray * parameters)
{
  int iftmp.242;
  unsigned int D.29564;
  unsigned int count.243;
  unsigned int D.29567;
  unsigned int D.29568;
  short unsigned int D.29569;
  unsigned int i.244;
  char * D.29571;
  void * D.29572;
  struct MonoType * D.29573;
  struct MonoMethodSignature * D.29574;
  struct MonoMethodSignature * sig;
  int count;
  int i;

  if (parameters != 0B) goto <D.29562>; else goto <D.29563>;
  <D.29562>:
  D.29564 = mono_array_length (parameters);
  iftmp.242 = (int) D.29564;
  goto <D.29565>;
  <D.29563>:
  iftmp.242 = 0;
  <D.29565>:
  count = iftmp.242;
  count.243 = (unsigned int) count;
  D.29567 = count.243 + 3;
  D.29568 = D.29567 * 4;
  sig = image_g_malloc0 (image, D.29568);
  D.29569 = (short unsigned int) count;
  sig->param_count = D.29569;
  sig->sentinelpos = -1;
  i = 0;
  goto <D.22386>;
  <D.22385>:
  i.244 = (unsigned int) i;
  D.29571 = mono_array_addr_with_size (parameters, 4, i.244);
  D.29572 = MEM[(void * *)D.29571];
  D.29573 = mono_reflection_type_get_handle (D.29572);
  sig->params[i] = D.29573;
  i = i + 1;
  <D.22386>:
  if (i < count) goto <D.22385>; else goto <D.22387>;
  <D.22387>:
  D.29574 = sig;
  return D.29574;
}


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

  if (image != 0B) goto <D.29576>; else goto <D.29577>;
  <D.29576>:
  D.29578 = mono_image_alloc0 (image, size);
  return D.29578;
  <D.29577>:
  D.29578 = monoeg_malloc0 (size);
  return D.29578;
}


reflection_methodbuilder_to_mono_method (struct MonoClass * klass, struct ReflectionMethodBuilder * rmb, struct MonoMethodSignature * sig)
{
  void * * D.29580;
  _Bool D.29581;
  struct MonoImage * iftmp.245;
  struct MonoGenericClass * D.29588;
  _Bool D.29589;
  long int D.29590;
  long int D.29591;
  unsigned int D.29597;
  unsigned int D.29598;
  unsigned int D.29600;
  unsigned int D.29601;
  unsigned char D.29602;
  <unnamed-unsigned:1> D.29603;
  short unsigned int D.29604;
  short unsigned int D.29605;
  struct MonoString * D.29606;
  char * D.29607;
  unsigned char D.29608;
  <unnamed-unsigned:1> D.29609;
  guint32 * D.29610;
  unsigned int D.29613;
  unsigned int D.29614;
  short unsigned int D.29615;
  int D.29616;
  int D.29617;
  struct MonoClass * D.29620;
  int D.22878;
  int iftmp.246;
  int D.22877;
  const char[6] * D.29626;
  unsigned char D.29627;
  int D.29628;
  unsigned char D.29629;
  int D.29630;
  _Bool D.29631;
  _Bool D.29632;
  _Bool D.29633;
  const unsigned char * D.29636;
  unsigned char D.29637;
  int D.29638;
  const unsigned char * D.29639;
  unsigned char D.29640;
  int D.29641;
  _Bool D.29642;
  _Bool D.29643;
  const unsigned char * D.29646;
  unsigned char D.29647;
  int D.29648;
  const unsigned char * D.29649;
  unsigned char D.29650;
  int D.29651;
  _Bool D.29652;
  _Bool D.29653;
  const unsigned char * D.29656;
  unsigned char D.29657;
  int D.29658;
  const unsigned char * D.29659;
  unsigned char D.29660;
  int D.29661;
  const char * D.29663;
  struct MonoMethodSignature * D.29666;
  short unsigned int D.29668;
  int D.29669;
  int D.29670;
  char * iftmp.247;
  struct MonoString * D.29674;
  int D.29678;
  _Bool D.29679;
  long int D.29680;
  long int D.29681;
  struct MonoString * D.29684;
  char * D.29685;
  int D.29686;
  _Bool D.29687;
  long int D.29688;
  long int D.29689;
  int D.29692;
  int D.29693;
  signed short D.29694;
  signed short iftmp.248;
  int D.29696;
  int D.29699;
  unsigned short D.29700;
  unsigned short D.29701;
  signed short D.29703;
  int D.29704;
  signed short D.29705;
  signed short D.29706;
  short unsigned int D.29707;
  struct MonoImage * D.29708;
  unsigned char D.29709;
  unsigned char D.29710;
  struct GHashTable * D.29713;
  struct MonoMethod * D.29714;
  int D.29715;
  int D.29718;
  struct MonoReflectionILGen * D.29721;
  struct MonoArray * D.29724;
  int D.29725;
  gint32 iftmp.249;
  struct MonoArray * D.29727;
  unsigned int D.29730;
  struct MonoArray * D.29732;
  unsigned int D.29735;
  struct MonoArray * D.29737;
  unsigned int num_locals.250;
  unsigned int D.29742;
  unsigned int D.29743;
  void * D.29744;
  const unsigned char * D.29745;
  short unsigned int D.29746;
  <unnamed-unsigned:15> D.29747;
  unsigned char D.29748;
  <unnamed-unsigned:1> D.29749;
  short unsigned int D.29750;
  unsigned int i.251;
  char * D.29752;
  void * D.29753;
  struct MonoObject * D.29754;
  struct MonoType * D.29755;
  struct MonoType * D.29756;
  short unsigned int D.29757;
  <unnamed-unsigned:15> D.29758;
  unsigned int num_clauses.252;
  struct MonoExceptionClause * D.29762;
  struct MonoArray * D.29763;
  unsigned int D.29766;
  _Bool D.29767;
  long int D.29768;
  long int D.29769;
  <unnamed-signed:31> D.29772;
  unsigned int count.253;
  unsigned int D.29774;
  void * D.29775;
  unsigned int i.254;
  char * D.29777;
  struct MonoType * D.29778;
  struct MonoGenericParamFull * D.29779;
  unsigned int i.255;
  unsigned int D.29781;
  struct MonoGenericParamFull * D.29782;
  unsigned char D.29783;
  short unsigned int D.29786;
  int D.29787;
  struct MonoType * D.29790;
  struct MonoType * D.29791;
  unsigned int D.29792;
  unsigned int D.29793;
  struct MonoGenericParam * D.29794;
  short unsigned int D.29795;
  int D.29796;
  struct MonoGenericContainer * D.29797;
  struct MonoGenericInst * D.29800;
  struct MonoGenericInst * D.29801;
  unsigned int D.29804;
  unsigned int D.29805;
  unsigned int D.29806;
  void * D.29807;
  sizetype i.256;
  sizetype D.29809;
  sizetype D.29810;
  void * * D.29811;
  unsigned int i.257;
  unsigned int D.29813;
  void * * D.29814;
  void * D.29815;
  unsigned int i.258;
  struct MonoArray * D.29817;
  struct MonoMethodSignature * D.29822;
  short unsigned int D.29823;
  int D.29824;
  int D.29825;
  unsigned int D.29826;
  unsigned int D.29827;
  void * D.29828;
  char * D.29829;
  unsigned int D.29834;
  int D.29837;
  struct MonoType * D.29838;
  struct MonoType * D.29839;
  short unsigned int D.29840;
  unsigned int D.29841;
  uint8_t * * D.29844;
  int D.29847;
  unsigned int D.29848;
  unsigned int D.29849;
  void * D.29850;
  void * D.29851;
  struct MonoObject * D.29852;
  char * D.29853;
  const char * p2.259;
  int p2.260;
  int p.261;
  int D.29857;
  unsigned int D.29858;
  unsigned int D.29859;
  uint8_t * * D.29860;
  void * D.29861;
  uint32_t * D.29862;
  uint32_t * D.29863;
  unsigned int def_type.262;
  uint8_t * D.29865;
  struct MonoString * D.29866;
  char * * D.29869;
  char * * D.29870;
  char * D.29871;
  int D.29872;
  _Bool D.29873;
  long int D.29874;
  long int D.29875;
  struct MonoArray * D.29878;
  struct MonoCustomAttrInfo * * D.29881;
  void * D.29884;
  struct MonoCustomAttrInfo * * D.29885;
  struct MonoCustomAttrInfo * D.29886;
  char * D.29889;
  struct MonoReflectionMarshal * D.29892;
  short unsigned int D.29897;
  int D.29898;
  int D.29899;
  unsigned int D.29900;
  unsigned int D.29901;
  int D.29902;
  unsigned int D.29903;
  unsigned int D.29904;
  struct MonoMarshalSpec * * D.29905;
  struct MonoAssembly * D.29906;
  struct MonoMarshalSpec * D.29907;
  unsigned int D.29908;
  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.29580 = rmb->refs;
      D.29581 = D.29580 != 0B;
      dynamic = (gboolean) D.29581;
      if (dynamic == 0) goto <D.29583>; else goto <D.29584>;
      <D.29583>:
      iftmp.245 = klass->image;
      goto <D.29585>;
      <D.29584>:
      iftmp.245 = 0B;
      <D.29585>:
      image = iftmp.245;
      if (dynamic == 0) goto <D.29586>; else goto <D.29587>;
      <D.29586>:
      D.29588 = klass->generic_class;
      D.29589 = D.29588 != 0B;
      D.29590 = (long int) D.29589;
      D.29591 = __builtin_expect (D.29590, 0);
      if (D.29591 != 0) goto <D.29592>; else goto <D.29593>;
      <D.29592>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10133, "!klass->generic_class");
      <D.29593>:
      <D.29587>:
      mono_loader_lock ();
      D.29597 = rmb->attrs;
      D.29598 = D.29597 & 8192;
      if (D.29598 != 0) goto <D.29594>; else goto <D.29599>;
      <D.29599>:
      D.29600 = rmb->iattrs;
      D.29601 = D.29600 & 4096;
      if (D.29601 != 0) goto <D.29594>; else goto <D.29595>;
      <D.29594>:
      m = image_g_malloc0 (image, 32);
      goto <D.29596>;
      <D.29595>:
      m = image_g_malloc0 (image, 32);
      <D.29596>:
      wrapperm = m;
      D.29602 = (unsigned char) dynamic;
      D.29603 = (<unnamed-unsigned:1>) D.29602;
      m->dynamic = D.29603;
      m->slot = -1;
      D.29597 = rmb->attrs;
      D.29604 = (short unsigned int) D.29597;
      m->flags = D.29604;
      D.29600 = rmb->iattrs;
      D.29605 = (short unsigned int) D.29600;
      m->iflags = D.29605;
      D.29606 = rmb->name;
      D.29607 = mono_string_to_utf8_image_ignore (image, D.29606);
      m->name = D.29607;
      m->klass = klass;
      m->signature = sig;
      m->sre_method = 1;
      D.29608 = rmb->skip_visibility;
      D.29609 = (<unnamed-unsigned:1>) D.29608;
      m->skip_visibility = D.29609;
      D.29610 = rmb->table_idx;
      if (D.29610 != 0B) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      D.29610 = rmb->table_idx;
      D.29613 = *D.29610;
      D.29614 = D.29613 | 100663296;
      m->token = D.29614;
      <D.29612>:
      D.29615 = m->iflags;
      D.29616 = (int) D.29615;
      D.29617 = D.29616 & 4096;
      if (D.29617 != 0) goto <D.29618>; else goto <D.29619>;
      <D.29618>:
      D.29620 = mono_defaults.string_class;
      if (D.29620 == klass) goto <D.29621>; else goto <D.29622>;
      <D.29621>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.29626 = ".ctor";
          D.29627 = MEM[(const unsigned char *)D.29626];
          D.29628 = (int) D.29627;
          D.29629 = *__s2;
          D.29630 = (int) D.29629;
          __result = D.29628 - D.29630;
          {
            D.29631 = __s2_len != 0;
            D.29632 = __result == 0;
            D.29633 = D.29631 & D.29632;
            if (D.29633 != 0) goto <D.29634>; else goto <D.29635>;
            <D.29634>:
            D.29636 = &MEM[(void *)".ctor" + 1B];
            D.29637 = *D.29636;
            D.29638 = (int) D.29637;
            D.29639 = __s2 + 1;
            D.29640 = *D.29639;
            D.29641 = (int) D.29640;
            __result = D.29638 - D.29641;
            D.29642 = __s2_len > 1;
            D.29632 = __result == 0;
            D.29643 = D.29642 & D.29632;
            if (D.29643 != 0) goto <D.29644>; else goto <D.29645>;
            <D.29644>:
            D.29646 = &MEM[(void *)".ctor" + 2B];
            D.29647 = *D.29646;
            D.29648 = (int) D.29647;
            D.29649 = __s2 + 2;
            D.29650 = *D.29649;
            D.29651 = (int) D.29650;
            __result = D.29648 - D.29651;
            D.29652 = __s2_len > 2;
            D.29632 = __result == 0;
            D.29653 = D.29652 & D.29632;
            if (D.29653 != 0) goto <D.29654>; else goto <D.29655>;
            <D.29654>:
            D.29656 = &MEM[(void *)".ctor" + 3B];
            D.29657 = *D.29656;
            D.29658 = (int) D.29657;
            D.29659 = __s2 + 3;
            D.29660 = *D.29659;
            D.29661 = (int) D.29660;
            __result = D.29658 - D.29661;
            <D.29655>:
            <D.29645>:
            <D.29635>:
          }
          D.22877 = __result;
        }
        iftmp.246 = -D.22877;
        goto <D.29662>;
        <D.29625>:
        D.29663 = m->name;
        iftmp.246 = __builtin_strcmp (D.29663, ".ctor");
        <D.29662>:
        D.22878 = iftmp.246;
      }
      if (D.22878 == 0) goto <D.29664>; else goto <D.29665>;
      <D.29664>:
      m->string_ctor = 1;
      <D.29665>:
      <D.29622>:
      D.29666 = m->signature;
      D.29666->pinvoke = 1;
      goto <D.29667>;
      <D.29619>:
      D.29668 = m->flags;
      D.29669 = (int) D.29668;
      D.29670 = D.29669 & 8192;
      if (D.29670 != 0) goto <D.29671>; else goto <D.29672>;
      <D.29671>:
      D.29666 = m->signature;
      D.29666->pinvoke = 1;
      method_aux = image_g_malloc0 (image, 28);
      D.29674 = rmb->dllentry;
      if (D.29674 != 0B) goto <D.29675>; else goto <D.29676>;
      <D.29675>:
      D.29674 = rmb->dllentry;
      iftmp.247 = mono_string_to_utf8_image (image, D.29674, &error);
      goto <D.29677>;
      <D.29676>:
      D.29663 = m->name;
      iftmp.247 = image_strdup (image, D.29663);
      <D.29677>:
      method_aux->dllentry = iftmp.247;
      D.29678 = mono_error_ok (&error);
      D.29679 = D.29678 == 0;
      D.29680 = (long int) D.29679;
      D.29681 = __builtin_expect (D.29680, 0);
      if (D.29681 != 0) goto <D.29682>; else goto <D.29683>;
      <D.29682>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10168, "mono_error_ok (&error)");
      <D.29683>:
      D.29684 = rmb->dll;
      D.29685 = mono_string_to_utf8_image (image, D.29684, &error);
      method_aux->dll = D.29685;
      D.29686 = mono_error_ok (&error);
      D.29687 = D.29686 == 0;
      D.29688 = (long int) D.29687;
      D.29689 = __builtin_expect (D.29688, 0);
      if (D.29689 != 0) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10170, "mono_error_ok (&error)");
      <D.29691>:
      D.29692 = rmb->native_cc;
      D.29693 = D.29692 << 8;
      D.29694 = (signed short) D.29693;
      D.29696 = rmb->charset;
      if (D.29696 != 0) goto <D.29697>; else goto <D.29698>;
      <D.29697>:
      D.29696 = rmb->charset;
      D.29699 = D.29696 + -1;
      D.29700 = (unsigned short) D.29699;
      D.29701 = D.29700 * 2;
      iftmp.248 = (signed short) D.29701;
      goto <D.29702>;
      <D.29698>:
      iftmp.248 = 0;
      <D.29702>:
      D.29703 = D.29694 | iftmp.248;
      D.29704 = rmb->extra_flags;
      D.29705 = (signed short) D.29704;
      D.29706 = D.29703 | D.29705;
      D.29707 = (short unsigned int) D.29706;
      MEM[(struct MonoMethodPInvoke *)m].piflags = D.29707;
      D.29708 = klass->image;
      D.29709 = BIT_FIELD_REF <*D.29708, 8, 128>;
      D.29710 = D.29709 & 8;
      if (D.29710 != 0) goto <D.29711>; else goto <D.29712>;
      <D.29711>:
      D.29708 = klass->image;
      D.29713 = MEM[(struct MonoDynamicImage *)D.29708].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.29713, m, method_aux, 0);
      <D.29712>:
      mono_loader_unlock ();
      D.29714 = m;
      return D.29714;
      <D.29672>:
      D.29668 = m->flags;
      D.29669 = (int) D.29668;
      D.29715 = D.29669 & 1024;
      if (D.29715 == 0) goto <D.29716>; else goto <D.29717>;
      <D.29716>:
      D.29615 = m->iflags;
      D.29616 = (int) D.29615;
      D.29718 = D.29616 & 3;
      if (D.29718 == 0) goto <D.29719>; else goto <D.29720>;
      <D.29719>:
      {
        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.29721 = rmb->ilgen;
        if (D.29721 != 0B) goto <D.29722>; else goto <D.29723>;
        <D.29722>:
        D.29721 = rmb->ilgen;
        D.29724 = D.29721->code;
        code = mono_array_addr_with_size (D.29724, 1, 0);
        D.29721 = rmb->ilgen;
        D.29725 = D.29721->code_len;
        code_size = (guint32) D.29725;
        D.29721 = rmb->ilgen;
        max_stack = D.29721->max_stack;
        D.29721 = rmb->ilgen;
        D.29727 = D.29721->locals;
        if (D.29727 != 0B) goto <D.29728>; else goto <D.29729>;
        <D.29728>:
        D.29721 = rmb->ilgen;
        D.29727 = D.29721->locals;
        D.29730 = mono_array_length (D.29727);
        iftmp.249 = (gint32) D.29730;
        goto <D.29731>;
        <D.29729>:
        iftmp.249 = 0;
        <D.29731>:
        num_locals = iftmp.249;
        D.29721 = rmb->ilgen;
        D.29732 = D.29721->ex_handlers;
        if (D.29732 != 0B) goto <D.29733>; else goto <D.29734>;
        <D.29733>:
        D.29721 = rmb->ilgen;
        D.29735 = method_count_clauses (D.29721);
        num_clauses = (gint32) D.29735;
        <D.29734>:
        goto <D.29736>;
        <D.29723>:
        D.29737 = rmb->code;
        if (D.29737 != 0B) goto <D.29738>; else goto <D.29739>;
        <D.29738>:
        D.29737 = rmb->code;
        code = mono_array_addr_with_size (D.29737, 1, 0);
        D.29737 = rmb->code;
        code_size = mono_array_length (D.29737);
        max_stack = 8;
        goto <D.29740>;
        <D.29739>:
        code = 0B;
        code_size = 0;
        max_stack = 8;
        <D.29740>:
        <D.29736>:
        num_locals.250 = (unsigned int) num_locals;
        D.29742 = num_locals.250 + 5;
        D.29743 = D.29742 * 4;
        header = image_g_malloc0 (image, D.29743);
        header->code_size = code_size;
        D.29744 = image_g_malloc (image, code_size);
        header->code = D.29744;
        D.29745 = header->code;
        memcpy (D.29745, code, code_size);
        D.29746 = (short unsigned int) max_stack;
        D.29747 = (<unnamed-unsigned:15>) D.29746;
        header->max_stack = D.29747;
        D.29748 = rmb->init_locals;
        D.29749 = (<unnamed-unsigned:1>) D.29748;
        header->init_locals = D.29749;
        D.29750 = (short unsigned int) num_locals;
        header->num_locals = D.29750;
        i = 0;
        goto <D.22888>;
        <D.22887>:
        {
          struct MonoReflectionLocalBuilder * lb;

          i.251 = (unsigned int) i;
          D.29721 = rmb->ilgen;
          D.29727 = D.29721->locals;
          D.29752 = mono_array_addr_with_size (D.29727, 4, i.251);
          lb = MEM[(struct MonoReflectionLocalBuilder * *)D.29752];
          D.29753 = image_g_malloc0 (image, 8);
          header->locals[i] = D.29753;
          D.29754 = lb->type;
          D.29755 = mono_reflection_type_get_handle (D.29754);
          D.29756 = header->locals[i];
          memcpy (D.29756, D.29755, 8);
        }
        i = i + 1;
        <D.22888>:
        if (i < num_locals) goto <D.22887>; else goto <D.22889>;
        <D.22889>:
        D.29757 = (short unsigned int) num_clauses;
        D.29758 = (<unnamed-unsigned:15>) D.29757;
        header->num_clauses = D.29758;
        if (num_clauses != 0) goto <D.29759>; else goto <D.29760>;
        <D.29759>:
        num_clauses.252 = (unsigned int) num_clauses;
        D.29721 = rmb->ilgen;
        D.29708 = klass->image;
        D.29762 = method_encode_clauses (image, D.29708, D.29721, num_clauses.252);
        header->clauses = D.29762;
        <D.29760>:
        wrapperm->header = header;
      }
      <D.29720>:
      <D.29717>:
      <D.29667>:
      D.29763 = rmb->generic_params;
      if (D.29763 != 0B) goto <D.29764>; else goto <D.29765>;
      <D.29764>:
      {
        int count;
        struct MonoGenericContainer * container;

        D.29763 = rmb->generic_params;
        D.29766 = mono_array_length (D.29763);
        count = (int) D.29766;
        container = rmb->generic_container;
        D.29767 = container == 0B;
        D.29768 = (long int) D.29767;
        D.29769 = __builtin_expect (D.29768, 0);
        if (D.29769 != 0) goto <D.29770>; else goto <D.29771>;
        <D.29770>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10239, "container");
        <D.29771>:
        D.29772 = (<unnamed-signed:31>) count;
        container->type_argc = D.29772;
        count.253 = (unsigned int) count;
        D.29774 = count.253 * 32;
        D.29775 = image_g_malloc0 (image, D.29774);
        container->type_params = D.29775;
        container->owner.method = m;
        m->is_generic = 1;
        mono_method_set_generic_container (m, container);
        i = 0;
        goto <D.22895>;
        <D.22894>:
        {
          struct MonoReflectionGenericParam * gp;
          struct MonoGenericParamFull * param;

          i.254 = (unsigned int) i;
          D.29763 = rmb->generic_params;
          D.29777 = mono_array_addr_with_size (D.29763, 4, i.254);
          gp = MEM[(struct MonoReflectionGenericParam * *)D.29777];
          D.29778 = mono_reflection_type_get_handle (gp);
          param = D.29778->data.generic_param;
          D.29779 = container->type_params;
          i.255 = (unsigned int) i;
          D.29781 = i.255 * 32;
          D.29782 = D.29779 + D.29781;
          *D.29782 = *param;
        }
        i = i + 1;
        <D.22895>:
        if (i < count) goto <D.22894>; else goto <D.22896>;
        <D.22896>:
        i = 0;
        goto <D.22900>;
        <D.22899>:
        {
          struct MonoType * t;

          D.29666 = m->signature;
          t = D.29666->params[i];
          D.29783 = t->type;
          if (D.29783 == 30) goto <D.29784>; else goto <D.29785>;
          <D.29784>:
          {
            struct MonoGenericParam * gparam;

            gparam = t->data.generic_param;
            D.29786 = gparam->num;
            D.29787 = (int) D.29786;
            if (D.29787 < count) goto <D.29788>; else goto <D.29789>;
            <D.29788>:
            D.29666 = m->signature;
            D.29666 = m->signature;
            D.29790 = D.29666->params[i];
            D.29791 = mono_metadata_type_dup (image, D.29790);
            D.29666->params[i] = D.29791;
            D.29666 = m->signature;
            D.29790 = D.29666->params[i];
            D.29779 = container->type_params;
            D.29786 = gparam->num;
            D.29792 = (unsigned int) D.29786;
            D.29793 = D.29792 * 32;
            D.29794 = D.29779 + D.29793;
            D.29790->data.generic_param = D.29794;
            <D.29789>:
          }
          <D.29785>:
        }
        i = i + 1;
        <D.22900>:
        D.29666 = m->signature;
        D.29795 = D.29666->param_count;
        D.29796 = (int) D.29795;
        if (D.29796 > i) goto <D.22899>; else goto <D.22901>;
        <D.22901>:
        D.29797 = klass->generic_container;
        if (D.29797 != 0B) goto <D.29798>; else goto <D.29799>;
        <D.29798>:
        D.29797 = klass->generic_container;
        container->parent = D.29797;
        D.29797 = klass->generic_container;
        D.29800 = D.29797->context.class_inst;
        container->context.class_inst = D.29800;
        <D.29799>:
        D.29801 = mono_get_shared_generic_inst (container);
        container->context.method_inst = D.29801;
      }
      <D.29765>:
      D.29580 = rmb->refs;
      if (D.29580 != 0B) goto <D.29802>; else goto <D.29803>;
      <D.29802>:
      {
        struct MonoMethodWrapper * mw;
        int i;
        void * * data;

        mw = m;
        m->wrapper_type = 17;
        D.29804 = rmb->nrefs;
        D.29805 = D.29804 + 1;
        D.29806 = D.29805 * 4;
        data = image_g_malloc (image, D.29806);
        mw->method_data = data;
        D.29804 = rmb->nrefs;
        D.29807 = (void *) D.29804;
        *data = D.29807;
        i = 0;
        goto <D.22906>;
        <D.22905>:
        i.256 = (sizetype) i;
        D.29809 = i.256 + 1;
        D.29810 = D.29809 * 4;
        D.29811 = data + D.29810;
        D.29580 = rmb->refs;
        i.257 = (unsigned int) i;
        D.29813 = i.257 * 4;
        D.29814 = D.29580 + D.29813;
        D.29815 = *D.29814;
        *D.29811 = D.29815;
        i = i + 1;
        <D.22906>:
        i.258 = (unsigned int) i;
        D.29804 = rmb->nrefs;
        if (i.258 < D.29804) goto <D.22905>; else goto <D.22907>;
        <D.22907>:
      }
      <D.29803>:
      method_aux = 0B;
      D.29817 = rmb->pinfo;
      if (D.29817 != 0B) goto <D.29818>; else goto <D.29819>;
      <D.29818>:
      if (method_aux == 0B) goto <D.29820>; else goto <D.29821>;
      <D.29820>:
      method_aux = image_g_malloc0 (image, 28);
      <D.29821>:
      D.29822 = mono_method_signature (m);
      D.29823 = D.29822->param_count;
      D.29824 = (int) D.29823;
      D.29825 = D.29824 + 1;
      D.29826 = (unsigned int) D.29825;
      D.29827 = D.29826 * 4;
      D.29828 = image_g_malloc0 (image, D.29827);
      method_aux->param_names = D.29828;
      i = 0;
      goto <D.22916>;
      <D.22915>:
      {
        struct MonoReflectionParamBuilder * pb;

        i.254 = (unsigned int) i;
        D.29817 = rmb->pinfo;
        D.29829 = mono_array_addr_with_size (D.29817, 4, i.254);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.29829];
        if (pb != 0B) goto <D.29830>; else goto <D.29831>;
        <D.29830>:
        if (i > 0) goto <D.29832>; else goto <D.29833>;
        <D.29832>:
        D.29834 = pb->attrs;
        if (D.29834 != 0) goto <D.29835>; else goto <D.29836>;
        <D.29835>:
        D.29666 = m->signature;
        D.29837 = i + -1;
        D.29666 = m->signature;
        D.29837 = i + -1;
        D.29838 = D.29666->params[D.29837];
        D.29708 = klass->image;
        D.29839 = mono_metadata_type_dup (D.29708, D.29838);
        D.29666->params[D.29837] = D.29839;
        D.29666 = m->signature;
        D.29837 = i + -1;
        D.29838 = D.29666->params[D.29837];
        D.29834 = pb->attrs;
        D.29840 = (short unsigned int) D.29834;
        D.29838->attrs = D.29840;
        <D.29836>:
        <D.29833>:
        D.29834 = pb->attrs;
        D.29841 = D.29834 & 4096;
        if (D.29841 != 0) goto <D.29842>; else goto <D.29843>;
        <D.29842>:
        {
          struct MonoDynamicImage * assembly;
          guint32 idx;
          guint32 def_type;
          guint32 len;
          char * p;
          const char * p2;

          try
            {
              D.29844 = method_aux->param_defaults;
              if (D.29844 == 0B) goto <D.29845>; else goto <D.29846>;
              <D.29845>:
              D.29666 = m->signature;
              D.29795 = D.29666->param_count;
              D.29796 = (int) D.29795;
              D.29847 = D.29796 + 1;
              D.29848 = (unsigned int) D.29847;
              D.29849 = D.29848 * 4;
              D.29850 = image_g_malloc0 (image, D.29849);
              method_aux->param_defaults = D.29850;
              D.29666 = m->signature;
              D.29795 = D.29666->param_count;
              D.29796 = (int) D.29795;
              D.29847 = D.29796 + 1;
              D.29848 = (unsigned int) D.29847;
              D.29849 = D.29848 * 4;
              D.29851 = image_g_malloc0 (image, D.29849);
              method_aux->param_default_types = D.29851;
              <D.29846>:
              assembly = klass->image;
              D.29852 = pb->def_value;
              idx = encode_constant (assembly, D.29852, &def_type);
              D.29853 = assembly->blob.data;
              p = D.29853 + idx;
              len = mono_metadata_decode_blob_size (p, &p2);
              p2.259 = p2;
              p2.260 = (int) p2.259;
              p.261 = (int) p;
              D.29857 = p2.260 - p.261;
              D.29858 = (unsigned int) D.29857;
              len = D.29858 + len;
              D.29844 = method_aux->param_defaults;
              i.255 = (unsigned int) i;
              D.29859 = i.255 * 4;
              D.29860 = D.29844 + D.29859;
              D.29861 = image_g_malloc (image, len);
              *D.29860 = D.29861;
              D.29862 = method_aux->param_default_types;
              i.255 = (unsigned int) i;
              D.29859 = i.255 * 4;
              D.29863 = D.29862 + D.29859;
              def_type.262 = def_type;
              *D.29863 = def_type.262;
              D.29844 = method_aux->param_defaults;
              i.255 = (unsigned int) i;
              D.29859 = i.255 * 4;
              D.29860 = D.29844 + D.29859;
              D.29865 = *D.29860;
              memcpy (D.29865, p, len);
            }
          finally
            {
              def_type = {CLOBBER};
              p2 = {CLOBBER};
            }
        }
        <D.29843>:
        D.29866 = pb->name;
        if (D.29866 != 0B) goto <D.29867>; else goto <D.29868>;
        <D.29867>:
        D.29869 = method_aux->param_names;
        i.255 = (unsigned int) i;
        D.29859 = i.255 * 4;
        D.29870 = D.29869 + D.29859;
        D.29866 = pb->name;
        D.29871 = mono_string_to_utf8_image (image, D.29866, &error);
        *D.29870 = D.29871;
        D.29872 = mono_error_ok (&error);
        D.29873 = D.29872 == 0;
        D.29874 = (long int) D.29873;
        D.29875 = __builtin_expect (D.29874, 0);
        if (D.29875 != 0) goto <D.29876>; else goto <D.29877>;
        <D.29876>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10331, "mono_error_ok (&error)");
        <D.29877>:
        <D.29868>:
        D.29878 = pb->cattrs;
        if (D.29878 != 0B) goto <D.29879>; else goto <D.29880>;
        <D.29879>:
        D.29881 = method_aux->param_cattr;
        if (D.29881 == 0B) goto <D.29882>; else goto <D.29883>;
        <D.29882>:
        D.29666 = m->signature;
        D.29795 = D.29666->param_count;
        D.29796 = (int) D.29795;
        D.29847 = D.29796 + 1;
        D.29848 = (unsigned int) D.29847;
        D.29849 = D.29848 * 4;
        D.29884 = image_g_malloc0 (image, D.29849);
        method_aux->param_cattr = D.29884;
        <D.29883>:
        D.29881 = method_aux->param_cattr;
        i.255 = (unsigned int) i;
        D.29859 = i.255 * 4;
        D.29885 = D.29881 + D.29859;
        D.29878 = pb->cattrs;
        D.29708 = klass->image;
        D.29886 = mono_custom_attrs_from_builders (image, D.29708, D.29878);
        *D.29885 = D.29886;
        <D.29880>:
        <D.29831>:
      }
      i = i + 1;
      <D.22916>:
      D.29666 = m->signature;
      D.29795 = D.29666->param_count;
      D.29796 = (int) D.29795;
      if (D.29796 >= i) goto <D.22915>; else goto <D.22917>;
      <D.22917>:
      <D.29819>:
      specs = 0B;
      D.29817 = rmb->pinfo;
      if (D.29817 != 0B) goto <D.29887>; else goto <D.29888>;
      <D.29887>:
      i = 0;
      goto <D.22920>;
      <D.22919>:
      {
        struct MonoReflectionParamBuilder * pb;

        i.254 = (unsigned int) i;
        D.29817 = rmb->pinfo;
        D.29889 = mono_array_addr_with_size (D.29817, 4, i.254);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.29889];
        if (pb != 0B) goto <D.29890>; else goto <D.29891>;
        <D.29890>:
        D.29892 = pb->marshal_info;
        if (D.29892 != 0B) goto <D.29893>; else goto <D.29894>;
        <D.29893>:
        if (specs == 0B) goto <D.29895>; else goto <D.29896>;
        <D.29895>:
        D.29897 = sig->param_count;
        D.29898 = (int) D.29897;
        D.29899 = D.29898 + 1;
        D.29900 = (unsigned int) D.29899;
        D.29901 = D.29900 * 4;
        specs = image_g_malloc0 (image, D.29901);
        <D.29896>:
        D.29902 = pb->position;
        D.29903 = (unsigned int) D.29902;
        D.29904 = D.29903 * 4;
        D.29905 = specs + D.29904;
        D.29892 = pb->marshal_info;
        D.29708 = klass->image;
        D.29906 = D.29708->assembly;
        D.29907 = mono_marshal_spec_from_builder (image, D.29906, D.29892);
        *D.29905 = D.29907;
        <D.29894>:
        <D.29891>:
      }
      i = i + 1;
      <D.22920>:
      i.254 = (unsigned int) i;
      D.29817 = rmb->pinfo;
      D.29908 = mono_array_length (D.29817);
      if (i.254 < D.29908) goto <D.22919>; else goto <D.22921>;
      <D.22921>:
      <D.29888>:
      if (specs != 0B) goto <D.29909>; else goto <D.29910>;
      <D.29909>:
      if (method_aux == 0B) goto <D.29911>; else goto <D.29912>;
      <D.29911>:
      method_aux = image_g_malloc0 (image, 28);
      <D.29912>:
      method_aux->param_marshall = specs;
      <D.29910>:
      D.29708 = klass->image;
      D.29709 = BIT_FIELD_REF <*D.29708, 8, 128>;
      D.29710 = D.29709 & 8;
      if (D.29710 != 0) goto <D.29913>; else goto <D.29914>;
      <D.29913>:
      if (method_aux != 0B) goto <D.29915>; else goto <D.29916>;
      <D.29915>:
      D.29708 = klass->image;
      D.29713 = MEM[(struct MonoDynamicImage *)D.29708].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.29713, m, method_aux, 0);
      <D.29916>:
      <D.29914>:
      mono_loader_unlock ();
      D.29714 = m;
      return D.29714;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

  if (image != 0B) goto <D.29919>; else goto <D.29920>;
  <D.29919>:
  D.29921 = mono_image_strdup (image, s);
  return D.29921;
  <D.29920>:
  D.29921 = monoeg_strdup (s);
  return D.29921;
}


method_encode_clauses (struct MonoImage * image, struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen, guint32 num_clauses)
{
  unsigned int D.29923;
  struct MonoArray * D.29924;
  unsigned int D.29925;
  unsigned int D.29926;
  unsigned int i.263;
  int D.29928;
  int D.29929;
  int D.29930;
  struct MonoArray * D.29931;
  unsigned int j.264;
  unsigned int clause_index.265;
  unsigned int D.29936;
  int D.29937;
  unsigned int D.29938;
  unsigned int D.29939;
  unsigned int D.29942;
  unsigned int D.29943;
  unsigned int D.29945;
  int D.29946;
  unsigned int D.29947;
  int D.29948;
  unsigned int D.29949;
  struct MonoObject * D.29950;
  struct MonoType * D.29953;
  struct MonoClass * D.29954;
  int D.29958;
  unsigned int D.29959;
  int D.29961;
  unsigned int D.29962;
  struct MonoExceptionClause * D.29963;
  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.29923 = num_clauses * 24;
  clauses = image_g_malloc0 (image, D.29923);
  clause_index = 0;
  D.29924 = ilgen->ex_handlers;
  D.29925 = mono_array_length (D.29924);
  D.29926 = D.29925 + 4294967295;
  i = (int) D.29926;
  goto <D.18601>;
  <D.18600>:
  i.263 = (unsigned int) i;
  D.29924 = ilgen->ex_handlers;
  ex_info = mono_array_addr_with_size (D.29924, 16, i.263);
  D.29928 = ex_info->start;
  D.29929 = ex_info->len;
  D.29930 = D.29928 + D.29929;
  finally_start = (guint32) D.29930;
  D.29931 = ex_info->handlers;
  if (D.29931 == 0B) goto <D.29932>; else goto <D.29933>;
  <D.29932>:
  // predicted unlikely by continue predictor.
  goto <D.18596>;
  <D.29933>:
  j = 0;
  goto <D.18598>;
  <D.18597>:
  j.264 = (unsigned int) j;
  D.29931 = ex_info->handlers;
  ex_block = mono_array_addr_with_size (D.29931, 20, j.264);
  clause_index.265 = (unsigned int) clause_index;
  D.29936 = clause_index.265 * 24;
  clause = clauses + D.29936;
  D.29937 = ex_block->type;
  D.29938 = (unsigned int) D.29937;
  clause->flags = D.29938;
  D.29928 = ex_info->start;
  D.29939 = (unsigned int) D.29928;
  clause->try_offset = D.29939;
  D.29937 = ex_block->type;
  if (D.29937 == 2) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  D.29928 = ex_info->start;
  D.29942 = (unsigned int) D.29928;
  D.29943 = finally_start - D.29942;
  clause->try_len = D.29943;
  goto <D.29944>;
  <D.29941>:
  D.29929 = ex_info->len;
  D.29945 = (unsigned int) D.29929;
  clause->try_len = D.29945;
  <D.29944>:
  D.29946 = ex_block->start;
  D.29947 = (unsigned int) D.29946;
  clause->handler_offset = D.29947;
  D.29948 = ex_block->len;
  D.29949 = (unsigned int) D.29948;
  clause->handler_len = D.29949;
  D.29950 = ex_block->extype;
  if (D.29950 != 0B) goto <D.29951>; else goto <D.29952>;
  <D.29951>:
  D.29950 = ex_block->extype;
  D.29953 = mono_reflection_type_get_handle (D.29950);
  D.29954 = mono_class_from_mono_type (D.29953);
  clause->data.catch_class = D.29954;
  goto <D.29955>;
  <D.29952>:
  D.29937 = ex_block->type;
  if (D.29937 == 1) goto <D.29956>; else goto <D.29957>;
  <D.29956>:
  D.29958 = ex_block->filter_offset;
  D.29959 = (unsigned int) D.29958;
  clause->data.filter_offset = D.29959;
  goto <D.29960>;
  <D.29957>:
  clause->data.filter_offset = 0;
  <D.29960>:
  <D.29955>:
  D.29946 = ex_block->start;
  D.29948 = ex_block->len;
  D.29961 = D.29946 + D.29948;
  finally_start = (guint32) D.29961;
  clause_index = clause_index + 1;
  j = j + 1;
  <D.18598>:
  j.264 = (unsigned int) j;
  D.29931 = ex_info->handlers;
  D.29962 = mono_array_length (D.29931);
  if (j.264 < D.29962) goto <D.18597>; else goto <D.18599>;
  <D.18599>:
  <D.18596>:
  i = i + -1;
  <D.18601>:
  if (i >= 0) goto <D.18600>; else goto <D.18602>;
  <D.18602>:
  D.29963 = clauses;
  return D.29963;
}


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

  if (image != 0B) goto <D.29965>; else goto <D.29966>;
  <D.29965>:
  D.29967 = mono_image_alloc (image, size);
  return D.29967;
  <D.29966>:
  D.29967 = monoeg_malloc (size);
  return D.29967;
}


mono_custom_attrs_from_builders (struct MonoImage * alloc_img, struct MonoImage * image, struct MonoArray * cattrs)
{
  struct MonoCustomAttrInfo * D.29971;
  unsigned int D.29972;
  unsigned int i.266;
  char * D.29974;
  int D.29975;
  unsigned int count.267;
  unsigned int D.29979;
  unsigned int D.29980;
  _Bool D.29981;
  int D.29982;
  char * D.29983;
  int D.29984;
  struct MonoArray * D.29987;
  unsigned int D.29988;
  unsigned int D.29989;
  char * D.29990;
  struct MonoReflectionMethod * D.29991;
  struct MonoMethod * D.29992;
  unsigned int D.29993;
  int i;
  int index;
  int count;
  int not_visible;
  struct MonoCustomAttrInfo * ainfo;
  struct MonoReflectionCustomAttr * cattr;

  if (cattrs == 0B) goto <D.29969>; else goto <D.29970>;
  <D.29969>:
  D.29971 = 0B;
  return D.29971;
  <D.29970>:
  D.29972 = mono_array_length (cattrs);
  count = (int) D.29972;
  not_visible = 0;
  i = 0;
  goto <D.18673>;
  <D.18672>:
  i.266 = (unsigned int) i;
  D.29974 = mono_array_addr_with_size (cattrs, 4, i.266);
  cattr = MEM[(void * *)D.29974];
  D.29975 = custom_attr_visible (image, cattr);
  if (D.29975 == 0) goto <D.29976>; else goto <D.29977>;
  <D.29976>:
  not_visible = not_visible + 1;
  <D.29977>:
  i = i + 1;
  <D.18673>:
  if (i < count) goto <D.18672>; else goto <D.18674>;
  <D.18674>:
  count = count - not_visible;
  count.267 = (unsigned int) count;
  D.29979 = count.267 + 1;
  D.29980 = D.29979 * 12;
  ainfo = image_g_malloc0 (alloc_img, D.29980);
  ainfo->image = image;
  ainfo->num_attrs = count;
  D.29981 = alloc_img != 0B;
  D.29982 = (int) D.29981;
  ainfo->cached = D.29982;
  index = 0;
  i = 0;
  goto <D.18677>;
  <D.18676>:
  i.266 = (unsigned int) i;
  D.29983 = mono_array_addr_with_size (cattrs, 4, i.266);
  cattr = MEM[(void * *)D.29983];
  D.29984 = custom_attr_visible (image, cattr);
  if (D.29984 != 0) goto <D.29985>; else goto <D.29986>;
  <D.29985>:
  {
    unsigned char * saved;

    D.29987 = cattr->data;
    D.29988 = mono_array_length (D.29987);
    saved = mono_image_alloc (image, D.29988);
    D.29987 = cattr->data;
    D.29989 = mono_array_length (D.29987);
    D.29987 = cattr->data;
    D.29990 = mono_array_addr_with_size (D.29987, 1, 0);
    memcpy (saved, D.29990, D.29989);
    D.29991 = cattr->ctor;
    D.29992 = D.29991->method;
    ainfo->attrs[index].ctor = D.29992;
    ainfo->attrs[index].data = saved;
    D.29987 = cattr->data;
    D.29993 = mono_array_length (D.29987);
    ainfo->attrs[index].data_size = D.29993;
    index = index + 1;
  }
  <D.29986>:
  i = i + 1;
  <D.18677>:
  if (i < count) goto <D.18676>; else goto <D.18678>;
  <D.18678>:
  D.29971 = ainfo;
  return D.29971;
}


custom_attr_visible (struct MonoImage * image, struct MonoReflectionCustomAttr * cattr)
{
  struct MonoReflectionMethod * D.29995;
  struct MonoMethod * D.29996;
  struct MonoClass * D.29999;
  struct MonoImage * D.30000;
  unsigned int D.30003;
  int D.30004;
  unsigned int visibility.268;
  unsigned int D.30006;
  gboolean D.30009;

  D.29995 = cattr->ctor;
  D.29996 = D.29995->method;
  if (D.29996 != 0B) goto <D.29997>; else goto <D.29998>;
  <D.29997>:
  D.29995 = cattr->ctor;
  D.29996 = D.29995->method;
  D.29999 = D.29996->klass;
  D.30000 = D.29999->image;
  if (D.30000 != image) goto <D.30001>; else goto <D.30002>;
  <D.30001>:
  {
    int visibility;

    D.29995 = cattr->ctor;
    D.29996 = D.29995->method;
    D.29999 = D.29996->klass;
    D.30003 = D.29999->flags;
    D.30004 = (int) D.30003;
    visibility = D.30004 & 7;
    visibility.268 = (unsigned int) visibility;
    D.30006 = visibility.268 + 4294967295;
    if (D.30006 > 1) goto <D.30007>; else goto <D.30008>;
    <D.30007>:
    D.30009 = 0;
    return D.30009;
    <D.30008>:
  }
  <D.30002>:
  <D.29998>:
  D.30009 = 1;
  return D.30009;
}


mono_marshal_spec_from_builder (struct MonoImage * image, struct MonoAssembly * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.30011;
  <unnamed type> D.30012;
  int D.30013;
  <unnamed type> D.30014;
  unsigned char D.30015;
  int D.30018;
  short int D.30019;
  int D.30020;
  _Bool D.30021;
  short int D.30022;
  struct MonoObject * D.30024;
  struct MonoType * D.30027;
  char * D.30028;
  struct MonoString * D.30029;
  char * D.30032;
  struct MonoMarshalSpec * D.30033;
  struct MonoMarshalSpec * res;

  res = image_g_malloc0 (image, 16);
  D.30011 = minfo->type;
  D.30012 = (<unnamed type>) D.30011;
  res->native = D.30012;
  D.30011 = minfo->type;
  switch (D.30011) <default: <D.22842>, case 23: <D.22839>, case 30: <D.22840>, case 42: <D.22837>, case 44: <D.22841>>
  <D.22837>:
  D.30013 = minfo->eltype;
  D.30014 = (<unnamed type>) D.30013;
  res->data.array_data.elem_type = D.30014;
  D.30015 = minfo->has_size;
  if (D.30015 != 0) goto <D.30016>; else goto <D.30017>;
  <D.30016>:
  D.30018 = minfo->param_num;
  D.30019 = (short int) D.30018;
  res->data.array_data.param_num = D.30019;
  D.30020 = minfo->count;
  res->data.array_data.num_elem = D.30020;
  D.30018 = minfo->param_num;
  D.30021 = D.30018 != -1;
  D.30022 = (short int) D.30021;
  res->data.array_data.elem_mult = D.30022;
  goto <D.30023>;
  <D.30017>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  <D.30023>:
  goto <D.22838>;
  <D.22839>:
  <D.22840>:
  D.30020 = minfo->count;
  res->data.array_data.num_elem = D.30020;
  goto <D.22838>;
  <D.22841>:
  D.30024 = minfo->marshaltyperef;
  if (D.30024 != 0B) goto <D.30025>; else goto <D.30026>;
  <D.30025>:
  D.30024 = minfo->marshaltyperef;
  D.30027 = mono_reflection_type_get_handle (D.30024);
  D.30028 = type_get_fully_qualified_name (D.30027);
  res->data.custom_data.custom_name = D.30028;
  <D.30026>:
  D.30029 = minfo->mcookie;
  if (D.30029 != 0B) goto <D.30030>; else goto <D.30031>;
  <D.30030>:
  D.30029 = minfo->mcookie;
  D.30032 = mono_string_to_utf8 (D.30029);
  res->data.custom_data.cookie = D.30032;
  <D.30031>:
  goto <D.22838>;
  <D.22842>:
  goto <D.22838>;
  <D.22838>:
  D.30033 = res;
  return D.30033;
}


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

  if (cattrs == 0B) goto <D.30036>; else goto <D.30038>;
  <D.30038>:
  D.30039 = mono_array_length (cattrs);
  if (D.30039 == 0) goto <D.30036>; else goto <D.30037>;
  <D.30036>:
  return;
  <D.30037>:
  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.30040>; else goto <D.30041>;
  <D.30040>:
  mono_custom_attrs_free (tmp);
  <D.30041>:
  mono_image_property_insert (image, obj, 4096, ainfo);
  mono_loader_unlock ();
}


ctorbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoImage * D.30043;
  struct MonoMethod * D.30044;
  struct MonoArray * D.30045;
  struct MonoMethod * D.30046;
  int D.30047;
  struct MonoGenericContainer * D.30050;
  struct MonoMethod * D.30053;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.30043 = klass->image;
      sig = ctor_builder_to_signature (D.30043, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.30044 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.30044;
      D.30045 = mb->cattrs;
      D.30046 = mb->mhandle;
      D.30043 = klass->image;
      mono_save_custom_attrs (D.30043, D.30046, D.30045);
      D.30043 = klass->image;
      D.30047 = MEM[(struct MonoDynamicImage *)D.30043].save;
      if (D.30047 == 0) goto <D.30048>; else goto <D.30049>;
      <D.30048>:
      D.30050 = klass->generic_container;
      if (D.30050 == 0B) goto <D.30051>; else goto <D.30052>;
      <D.30051>:
      mb->ilgen = 0B;
      <D.30052>:
      <D.30049>:
      D.30053 = mb->mhandle;
      return D.30053;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


ctor_builder_to_signature (struct MonoImage * image, struct MonoReflectionCtorBuilder * ctor)
{
  struct MonoArray * D.30056;
  unsigned int D.30057;
  unsigned int D.30058;
  _Bool D.30059;
  struct MonoClass * D.30060;
  struct MonoType * D.30061;
  struct MonoMethodSignature * D.30062;
  struct MonoMethodSignature * sig;

  D.30056 = ctor->parameters;
  sig = parameters_to_signature (image, D.30056);
  D.30057 = ctor->attrs;
  D.30058 = D.30057 & 16;
  D.30059 = D.30058 == 0;
  sig->hasthis = D.30059;
  D.30060 = mono_defaults.void_class;
  D.30061 = &D.30060->byval_arg;
  sig->ret = D.30061;
  D.30062 = sig;
  return D.30062;
}


inflate_mono_method (struct MonoClass * klass, struct MonoMethod * method, struct MonoObject * obj)
{
  struct MonoGenericClass * D.30064;
  struct MonoMethod * D.30067;
  unsigned int D.30070;
  struct MonoMethod * * D.30072;
  unsigned int i.269;
  unsigned int D.30075;
  struct MonoMethod * * D.30076;
  struct MonoMethod * D.30077;
  unsigned char D.30078;
  unsigned char D.30079;
  _Bool D.30080;
  long int D.30081;
  long int D.30082;
  struct MonoMethod * D.30085;
  unsigned int i.270;
  _Bool D.30088;
  long int D.30089;
  long int D.30090;
  unsigned char D.30093;
  unsigned char D.30094;
  struct MonoClass * D.30097;
  struct MonoImage * D.30098;
  unsigned char D.30099;
  unsigned char D.30100;
  struct MonoGHashTable * D.30103;
  struct MonoMethodInflated * imethod;
  struct MonoGenericContext * context;
  int i;

  D.30064 = klass->generic_class;
  if (D.30064 == 0B) goto <D.30065>; else goto <D.30066>;
  <D.30065>:
  D.30067 = method;
  return D.30067;
  <D.30066>:
  context = mono_class_get_context (klass);
  D.30070 = klass->method.count;
  if (D.30070 != 0) goto <D.30071>; else goto <D.30068>;
  <D.30071>:
  D.30072 = klass->methods;
  if (D.30072 != 0B) goto <D.30073>; else goto <D.30068>;
  <D.30073>:
  i = 0;
  goto <D.23001>;
  <D.23000>:
  D.30072 = klass->methods;
  i.269 = (unsigned int) i;
  D.30075 = i.269 * 4;
  D.30076 = D.30072 + D.30075;
  D.30077 = *D.30076;
  D.30078 = BIT_FIELD_REF <*D.30077, 8, 168>;
  D.30079 = D.30078 & 16;
  D.30080 = D.30079 == 0;
  D.30081 = (long int) D.30080;
  D.30082 = __builtin_expect (D.30081, 0);
  if (D.30082 != 0) goto <D.30083>; else goto <D.30084>;
  <D.30083>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10611, "klass->methods [i]->is_inflated");
  <D.30084>:
  D.30072 = klass->methods;
  i.269 = (unsigned int) i;
  D.30075 = i.269 * 4;
  D.30076 = D.30072 + D.30075;
  D.30077 = *D.30076;
  D.30085 = MEM[(struct MonoMethodInflated *)D.30077].declaring;
  if (D.30085 == method) goto <D.22999>; else goto <D.30086>;
  <D.30086>:
  i = i + 1;
  <D.23001>:
  i.270 = (unsigned int) i;
  D.30070 = klass->method.count;
  if (i.270 < D.30070) goto <D.23000>; else goto <D.22999>;
  <D.22999>:
  i.270 = (unsigned int) i;
  D.30070 = klass->method.count;
  D.30088 = i.270 >= D.30070;
  D.30089 = (long int) D.30088;
  D.30090 = __builtin_expect (D.30089, 0);
  if (D.30090 != 0) goto <D.30091>; else goto <D.30092>;
  <D.30091>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10615, "i < klass->method.count");
  <D.30092>:
  D.30072 = klass->methods;
  i.269 = (unsigned int) i;
  D.30075 = i.269 * 4;
  D.30076 = D.30072 + D.30075;
  imethod = *D.30076;
  goto <D.30069>;
  <D.30068>:
  imethod = mono_class_inflate_generic_method_full (method, klass, context);
  <D.30069>:
  D.30093 = BIT_FIELD_REF <*method, 8, 168>;
  D.30094 = D.30093 & 8;
  if (D.30094 != 0) goto <D.30095>; else goto <D.30096>;
  <D.30095>:
  D.30097 = method->klass;
  D.30098 = D.30097->image;
  D.30099 = BIT_FIELD_REF <*D.30098, 8, 128>;
  D.30100 = D.30099 & 8;
  if (D.30100 != 0) goto <D.30101>; else goto <D.30102>;
  <D.30101>:
  {
    struct MonoDynamicImage * image;

    D.30097 = method->klass;
    image = D.30097->image;
    mono_image_lock (image);
    D.30103 = image->generic_def_objects;
    mono_g_hash_table_insert (D.30103, imethod, obj);
    mono_image_unlock (image);
  }
  <D.30102>:
  <D.30096>:
  D.30067 = imethod;
  return D.30067;
}


is_sre_method_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.271;
  gboolean D.30108;
  _Bool D.30109;
  int D.30110;
  int D.22246;
  int iftmp.272;
  int D.22242;
  const char[14] * D.30116;
  unsigned char D.30117;
  int D.30118;
  unsigned char D.30119;
  int D.30120;
  _Bool D.30121;
  _Bool D.30122;
  _Bool D.30123;
  const unsigned char * D.30126;
  unsigned char D.30127;
  int D.30128;
  const unsigned char * D.30129;
  unsigned char D.30130;
  int D.30131;
  _Bool D.30132;
  _Bool D.30133;
  const unsigned char * D.30136;
  unsigned char D.30137;
  int D.30138;
  const unsigned char * D.30139;
  unsigned char D.30140;
  int D.30141;
  _Bool D.30142;
  _Bool D.30143;
  const unsigned char * D.30146;
  unsigned char D.30147;
  int D.30148;
  const unsigned char * D.30149;
  unsigned char D.30150;
  int D.30151;
  const char * D.30153;
  int D.22255;
  int iftmp.273;
  int D.22251;
  const char[23] * D.30159;
  unsigned char D.30160;
  int D.30161;
  unsigned char D.30162;
  int D.30163;
  _Bool D.30164;
  _Bool D.30165;
  _Bool D.30166;
  const unsigned char * D.30169;
  unsigned char D.30170;
  int D.30171;
  const unsigned char * D.30172;
  unsigned char D.30173;
  int D.30174;
  _Bool D.30175;
  _Bool D.30176;
  const unsigned char * D.30179;
  unsigned char D.30180;
  int D.30181;
  const unsigned char * D.30182;
  unsigned char D.30183;
  int D.30184;
  _Bool D.30185;
  _Bool D.30186;
  const unsigned char * D.30189;
  unsigned char D.30190;
  int D.30191;
  const unsigned char * D.30192;
  unsigned char D.30193;
  int D.30194;
  const char * D.30196;

  {
    static struct MonoClass * cached_class;

    cached_class.271 = cached_class;
    if (cached_class.271 != 0B) goto <D.30106>; else goto <D.30107>;
    <D.30106>:
    cached_class.271 = cached_class;
    D.30109 = cached_class.271 == class;
    D.30108 = (gboolean) D.30109;
    return D.30108;
    <D.30107>:
    D.30110 = is_corlib_type (class);
    if (D.30110 != 0) goto <D.30111>; else goto <D.30112>;
    <D.30111>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30116 = "MethodBuilder";
        D.30117 = MEM[(const unsigned char *)D.30116];
        D.30118 = (int) D.30117;
        D.30119 = *__s2;
        D.30120 = (int) D.30119;
        __result = D.30118 - D.30120;
        {
          D.30121 = __s1_len != 0;
          D.30122 = __result == 0;
          D.30123 = D.30121 & D.30122;
          if (D.30123 != 0) goto <D.30124>; else goto <D.30125>;
          <D.30124>:
          D.30126 = &MEM[(void *)"MethodBuilder" + 1B];
          D.30127 = *D.30126;
          D.30128 = (int) D.30127;
          D.30129 = __s2 + 1;
          D.30130 = *D.30129;
          D.30131 = (int) D.30130;
          __result = D.30128 - D.30131;
          D.30132 = __s1_len > 1;
          D.30122 = __result == 0;
          D.30133 = D.30132 & D.30122;
          if (D.30133 != 0) goto <D.30134>; else goto <D.30135>;
          <D.30134>:
          D.30136 = &MEM[(void *)"MethodBuilder" + 2B];
          D.30137 = *D.30136;
          D.30138 = (int) D.30137;
          D.30139 = __s2 + 2;
          D.30140 = *D.30139;
          D.30141 = (int) D.30140;
          __result = D.30138 - D.30141;
          D.30142 = __s1_len > 2;
          D.30122 = __result == 0;
          D.30143 = D.30142 & D.30122;
          if (D.30143 != 0) goto <D.30144>; else goto <D.30145>;
          <D.30144>:
          D.30146 = &MEM[(void *)"MethodBuilder" + 3B];
          D.30147 = *D.30146;
          D.30148 = (int) D.30147;
          D.30149 = __s2 + 3;
          D.30150 = *D.30149;
          D.30151 = (int) D.30150;
          __result = D.30148 - D.30151;
          <D.30145>:
          <D.30135>:
          <D.30125>:
        }
        D.22242 = __result;
      }
      iftmp.272 = D.22242;
      goto <D.30152>;
      <D.30115>:
      D.30153 = class->name;
      iftmp.272 = __builtin_strcmp ("MethodBuilder", D.30153);
      <D.30152>:
      D.22246 = iftmp.272;
    }
    if (D.22246 == 0) goto <D.30154>; else goto <D.30155>;
    <D.30154>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30159 = "System.Reflection.Emit";
        D.30160 = MEM[(const unsigned char *)D.30159];
        D.30161 = (int) D.30160;
        D.30162 = *__s2;
        D.30163 = (int) D.30162;
        __result = D.30161 - D.30163;
        {
          D.30164 = __s1_len != 0;
          D.30165 = __result == 0;
          D.30166 = D.30164 & D.30165;
          if (D.30166 != 0) goto <D.30167>; else goto <D.30168>;
          <D.30167>:
          D.30169 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30170 = *D.30169;
          D.30171 = (int) D.30170;
          D.30172 = __s2 + 1;
          D.30173 = *D.30172;
          D.30174 = (int) D.30173;
          __result = D.30171 - D.30174;
          D.30175 = __s1_len > 1;
          D.30165 = __result == 0;
          D.30176 = D.30175 & D.30165;
          if (D.30176 != 0) goto <D.30177>; else goto <D.30178>;
          <D.30177>:
          D.30179 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30180 = *D.30179;
          D.30181 = (int) D.30180;
          D.30182 = __s2 + 2;
          D.30183 = *D.30182;
          D.30184 = (int) D.30183;
          __result = D.30181 - D.30184;
          D.30185 = __s1_len > 2;
          D.30165 = __result == 0;
          D.30186 = D.30185 & D.30165;
          if (D.30186 != 0) goto <D.30187>; else goto <D.30188>;
          <D.30187>:
          D.30189 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30190 = *D.30189;
          D.30191 = (int) D.30190;
          D.30192 = __s2 + 3;
          D.30193 = *D.30192;
          D.30194 = (int) D.30193;
          __result = D.30191 - D.30194;
          <D.30188>:
          <D.30178>:
          <D.30168>:
        }
        D.22251 = __result;
      }
      iftmp.273 = D.22251;
      goto <D.30195>;
      <D.30158>:
      D.30196 = class->name_space;
      iftmp.273 = __builtin_strcmp ("System.Reflection.Emit", D.30196);
      <D.30195>:
      D.22255 = iftmp.273;
    }
    if (D.22255 == 0) goto <D.30197>; else goto <D.30198>;
    <D.30197>:
    cached_class = class;
    D.30108 = 1;
    return D.30108;
    <D.30198>:
    <D.30155>:
    <D.30112>:
    D.30108 = 0;
    return D.30108;
  }
}


is_sr_mono_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.274;
  gboolean D.30203;
  _Bool D.30204;
  int D.30205;
  int D.22492;
  int iftmp.275;
  int D.22488;
  const char[11] * D.30211;
  unsigned char D.30212;
  int D.30213;
  unsigned char D.30214;
  int D.30215;
  _Bool D.30216;
  _Bool D.30217;
  _Bool D.30218;
  const unsigned char * D.30221;
  unsigned char D.30222;
  int D.30223;
  const unsigned char * D.30224;
  unsigned char D.30225;
  int D.30226;
  _Bool D.30227;
  _Bool D.30228;
  const unsigned char * D.30231;
  unsigned char D.30232;
  int D.30233;
  const unsigned char * D.30234;
  unsigned char D.30235;
  int D.30236;
  _Bool D.30237;
  _Bool D.30238;
  const unsigned char * D.30241;
  unsigned char D.30242;
  int D.30243;
  const unsigned char * D.30244;
  unsigned char D.30245;
  int D.30246;
  const char * D.30248;
  int D.22501;
  int iftmp.276;
  int D.22497;
  const char[18] * D.30254;
  unsigned char D.30255;
  int D.30256;
  unsigned char D.30257;
  int D.30258;
  _Bool D.30259;
  _Bool D.30260;
  _Bool D.30261;
  const unsigned char * D.30264;
  unsigned char D.30265;
  int D.30266;
  const unsigned char * D.30267;
  unsigned char D.30268;
  int D.30269;
  _Bool D.30270;
  _Bool D.30271;
  const unsigned char * D.30274;
  unsigned char D.30275;
  int D.30276;
  const unsigned char * D.30277;
  unsigned char D.30278;
  int D.30279;
  _Bool D.30280;
  _Bool D.30281;
  const unsigned char * D.30284;
  unsigned char D.30285;
  int D.30286;
  const unsigned char * D.30287;
  unsigned char D.30288;
  int D.30289;
  const char * D.30291;

  {
    static struct MonoClass * cached_class;

    cached_class.274 = cached_class;
    if (cached_class.274 != 0B) goto <D.30201>; else goto <D.30202>;
    <D.30201>:
    cached_class.274 = cached_class;
    D.30204 = cached_class.274 == class;
    D.30203 = (gboolean) D.30204;
    return D.30203;
    <D.30202>:
    D.30205 = is_corlib_type (class);
    if (D.30205 != 0) goto <D.30206>; else goto <D.30207>;
    <D.30206>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30211 = "MonoMethod";
        D.30212 = MEM[(const unsigned char *)D.30211];
        D.30213 = (int) D.30212;
        D.30214 = *__s2;
        D.30215 = (int) D.30214;
        __result = D.30213 - D.30215;
        {
          D.30216 = __s1_len != 0;
          D.30217 = __result == 0;
          D.30218 = D.30216 & D.30217;
          if (D.30218 != 0) goto <D.30219>; else goto <D.30220>;
          <D.30219>:
          D.30221 = &MEM[(void *)"MonoMethod" + 1B];
          D.30222 = *D.30221;
          D.30223 = (int) D.30222;
          D.30224 = __s2 + 1;
          D.30225 = *D.30224;
          D.30226 = (int) D.30225;
          __result = D.30223 - D.30226;
          D.30227 = __s1_len > 1;
          D.30217 = __result == 0;
          D.30228 = D.30227 & D.30217;
          if (D.30228 != 0) goto <D.30229>; else goto <D.30230>;
          <D.30229>:
          D.30231 = &MEM[(void *)"MonoMethod" + 2B];
          D.30232 = *D.30231;
          D.30233 = (int) D.30232;
          D.30234 = __s2 + 2;
          D.30235 = *D.30234;
          D.30236 = (int) D.30235;
          __result = D.30233 - D.30236;
          D.30237 = __s1_len > 2;
          D.30217 = __result == 0;
          D.30238 = D.30237 & D.30217;
          if (D.30238 != 0) goto <D.30239>; else goto <D.30240>;
          <D.30239>:
          D.30241 = &MEM[(void *)"MonoMethod" + 3B];
          D.30242 = *D.30241;
          D.30243 = (int) D.30242;
          D.30244 = __s2 + 3;
          D.30245 = *D.30244;
          D.30246 = (int) D.30245;
          __result = D.30243 - D.30246;
          <D.30240>:
          <D.30230>:
          <D.30220>:
        }
        D.22488 = __result;
      }
      iftmp.275 = D.22488;
      goto <D.30247>;
      <D.30210>:
      D.30248 = class->name;
      iftmp.275 = __builtin_strcmp ("MonoMethod", D.30248);
      <D.30247>:
      D.22492 = iftmp.275;
    }
    if (D.22492 == 0) goto <D.30249>; else goto <D.30250>;
    <D.30249>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30254 = "System.Reflection";
        D.30255 = MEM[(const unsigned char *)D.30254];
        D.30256 = (int) D.30255;
        D.30257 = *__s2;
        D.30258 = (int) D.30257;
        __result = D.30256 - D.30258;
        {
          D.30259 = __s1_len != 0;
          D.30260 = __result == 0;
          D.30261 = D.30259 & D.30260;
          if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
          <D.30262>:
          D.30264 = &MEM[(void *)"System.Reflection" + 1B];
          D.30265 = *D.30264;
          D.30266 = (int) D.30265;
          D.30267 = __s2 + 1;
          D.30268 = *D.30267;
          D.30269 = (int) D.30268;
          __result = D.30266 - D.30269;
          D.30270 = __s1_len > 1;
          D.30260 = __result == 0;
          D.30271 = D.30270 & D.30260;
          if (D.30271 != 0) goto <D.30272>; else goto <D.30273>;
          <D.30272>:
          D.30274 = &MEM[(void *)"System.Reflection" + 2B];
          D.30275 = *D.30274;
          D.30276 = (int) D.30275;
          D.30277 = __s2 + 2;
          D.30278 = *D.30277;
          D.30279 = (int) D.30278;
          __result = D.30276 - D.30279;
          D.30280 = __s1_len > 2;
          D.30260 = __result == 0;
          D.30281 = D.30280 & D.30260;
          if (D.30281 != 0) goto <D.30282>; else goto <D.30283>;
          <D.30282>:
          D.30284 = &MEM[(void *)"System.Reflection" + 3B];
          D.30285 = *D.30284;
          D.30286 = (int) D.30285;
          D.30287 = __s2 + 3;
          D.30288 = *D.30287;
          D.30289 = (int) D.30288;
          __result = D.30286 - D.30289;
          <D.30283>:
          <D.30273>:
          <D.30263>:
        }
        D.22497 = __result;
      }
      iftmp.276 = D.22497;
      goto <D.30290>;
      <D.30253>:
      D.30291 = class->name_space;
      iftmp.276 = __builtin_strcmp ("System.Reflection", D.30291);
      <D.30290>:
      D.22501 = iftmp.276;
    }
    if (D.22501 == 0) goto <D.30292>; else goto <D.30293>;
    <D.30292>:
    cached_class = class;
    D.30203 = 1;
    return D.30203;
    <D.30293>:
    <D.30250>:
    <D.30207>:
    D.30203 = 0;
    return D.30203;
  }
}


is_sre_array (struct MonoClass * class)
{
  struct MonoClass * cached_class.277;
  gboolean D.30298;
  _Bool D.30299;
  int D.30300;
  int D.22136;
  int iftmp.278;
  int D.22132;
  const char[10] * D.30306;
  unsigned char D.30307;
  int D.30308;
  unsigned char D.30309;
  int D.30310;
  _Bool D.30311;
  _Bool D.30312;
  _Bool D.30313;
  const unsigned char * D.30316;
  unsigned char D.30317;
  int D.30318;
  const unsigned char * D.30319;
  unsigned char D.30320;
  int D.30321;
  _Bool D.30322;
  _Bool D.30323;
  const unsigned char * D.30326;
  unsigned char D.30327;
  int D.30328;
  const unsigned char * D.30329;
  unsigned char D.30330;
  int D.30331;
  _Bool D.30332;
  _Bool D.30333;
  const unsigned char * D.30336;
  unsigned char D.30337;
  int D.30338;
  const unsigned char * D.30339;
  unsigned char D.30340;
  int D.30341;
  const char * D.30343;
  int D.22145;
  int iftmp.279;
  int D.22141;
  const char[23] * D.30349;
  unsigned char D.30350;
  int D.30351;
  unsigned char D.30352;
  int D.30353;
  _Bool D.30354;
  _Bool D.30355;
  _Bool D.30356;
  const unsigned char * D.30359;
  unsigned char D.30360;
  int D.30361;
  const unsigned char * D.30362;
  unsigned char D.30363;
  int D.30364;
  _Bool D.30365;
  _Bool D.30366;
  const unsigned char * D.30369;
  unsigned char D.30370;
  int D.30371;
  const unsigned char * D.30372;
  unsigned char D.30373;
  int D.30374;
  _Bool D.30375;
  _Bool D.30376;
  const unsigned char * D.30379;
  unsigned char D.30380;
  int D.30381;
  const unsigned char * D.30382;
  unsigned char D.30383;
  int D.30384;
  const char * D.30386;

  {
    static struct MonoClass * cached_class;

    cached_class.277 = cached_class;
    if (cached_class.277 != 0B) goto <D.30296>; else goto <D.30297>;
    <D.30296>:
    cached_class.277 = cached_class;
    D.30299 = cached_class.277 == class;
    D.30298 = (gboolean) D.30299;
    return D.30298;
    <D.30297>:
    D.30300 = is_corlib_type (class);
    if (D.30300 != 0) goto <D.30301>; else goto <D.30302>;
    <D.30301>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30306 = "ArrayType";
        D.30307 = MEM[(const unsigned char *)D.30306];
        D.30308 = (int) D.30307;
        D.30309 = *__s2;
        D.30310 = (int) D.30309;
        __result = D.30308 - D.30310;
        {
          D.30311 = __s1_len != 0;
          D.30312 = __result == 0;
          D.30313 = D.30311 & D.30312;
          if (D.30313 != 0) goto <D.30314>; else goto <D.30315>;
          <D.30314>:
          D.30316 = &MEM[(void *)"ArrayType" + 1B];
          D.30317 = *D.30316;
          D.30318 = (int) D.30317;
          D.30319 = __s2 + 1;
          D.30320 = *D.30319;
          D.30321 = (int) D.30320;
          __result = D.30318 - D.30321;
          D.30322 = __s1_len > 1;
          D.30312 = __result == 0;
          D.30323 = D.30322 & D.30312;
          if (D.30323 != 0) goto <D.30324>; else goto <D.30325>;
          <D.30324>:
          D.30326 = &MEM[(void *)"ArrayType" + 2B];
          D.30327 = *D.30326;
          D.30328 = (int) D.30327;
          D.30329 = __s2 + 2;
          D.30330 = *D.30329;
          D.30331 = (int) D.30330;
          __result = D.30328 - D.30331;
          D.30332 = __s1_len > 2;
          D.30312 = __result == 0;
          D.30333 = D.30332 & D.30312;
          if (D.30333 != 0) goto <D.30334>; else goto <D.30335>;
          <D.30334>:
          D.30336 = &MEM[(void *)"ArrayType" + 3B];
          D.30337 = *D.30336;
          D.30338 = (int) D.30337;
          D.30339 = __s2 + 3;
          D.30340 = *D.30339;
          D.30341 = (int) D.30340;
          __result = D.30338 - D.30341;
          <D.30335>:
          <D.30325>:
          <D.30315>:
        }
        D.22132 = __result;
      }
      iftmp.278 = D.22132;
      goto <D.30342>;
      <D.30305>:
      D.30343 = class->name;
      iftmp.278 = __builtin_strcmp ("ArrayType", D.30343);
      <D.30342>:
      D.22136 = iftmp.278;
    }
    if (D.22136 == 0) goto <D.30344>; else goto <D.30345>;
    <D.30344>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30349 = "System.Reflection.Emit";
        D.30350 = MEM[(const unsigned char *)D.30349];
        D.30351 = (int) D.30350;
        D.30352 = *__s2;
        D.30353 = (int) D.30352;
        __result = D.30351 - D.30353;
        {
          D.30354 = __s1_len != 0;
          D.30355 = __result == 0;
          D.30356 = D.30354 & D.30355;
          if (D.30356 != 0) goto <D.30357>; else goto <D.30358>;
          <D.30357>:
          D.30359 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30360 = *D.30359;
          D.30361 = (int) D.30360;
          D.30362 = __s2 + 1;
          D.30363 = *D.30362;
          D.30364 = (int) D.30363;
          __result = D.30361 - D.30364;
          D.30365 = __s1_len > 1;
          D.30355 = __result == 0;
          D.30366 = D.30365 & D.30355;
          if (D.30366 != 0) goto <D.30367>; else goto <D.30368>;
          <D.30367>:
          D.30369 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30370 = *D.30369;
          D.30371 = (int) D.30370;
          D.30372 = __s2 + 2;
          D.30373 = *D.30372;
          D.30374 = (int) D.30373;
          __result = D.30371 - D.30374;
          D.30375 = __s1_len > 2;
          D.30355 = __result == 0;
          D.30376 = D.30375 & D.30355;
          if (D.30376 != 0) goto <D.30377>; else goto <D.30378>;
          <D.30377>:
          D.30379 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30380 = *D.30379;
          D.30381 = (int) D.30380;
          D.30382 = __s2 + 3;
          D.30383 = *D.30382;
          D.30384 = (int) D.30383;
          __result = D.30381 - D.30384;
          <D.30378>:
          <D.30368>:
          <D.30358>:
        }
        D.22141 = __result;
      }
      iftmp.279 = D.22141;
      goto <D.30385>;
      <D.30348>:
      D.30386 = class->name_space;
      iftmp.279 = __builtin_strcmp ("System.Reflection.Emit", D.30386);
      <D.30385>:
      D.22145 = iftmp.279;
    }
    if (D.22145 == 0) goto <D.30387>; else goto <D.30388>;
    <D.30387>:
    cached_class = class;
    D.30298 = 1;
    return D.30298;
    <D.30388>:
    <D.30345>:
    <D.30302>:
    D.30298 = 0;
    return D.30298;
  }
}


is_sre_byref (struct MonoClass * class)
{
  struct MonoClass * cached_class.280;
  gboolean D.30393;
  _Bool D.30394;
  int D.30395;
  int D.22158;
  int iftmp.281;
  int D.22154;
  const char[10] * D.30401;
  unsigned char D.30402;
  int D.30403;
  unsigned char D.30404;
  int D.30405;
  _Bool D.30406;
  _Bool D.30407;
  _Bool D.30408;
  const unsigned char * D.30411;
  unsigned char D.30412;
  int D.30413;
  const unsigned char * D.30414;
  unsigned char D.30415;
  int D.30416;
  _Bool D.30417;
  _Bool D.30418;
  const unsigned char * D.30421;
  unsigned char D.30422;
  int D.30423;
  const unsigned char * D.30424;
  unsigned char D.30425;
  int D.30426;
  _Bool D.30427;
  _Bool D.30428;
  const unsigned char * D.30431;
  unsigned char D.30432;
  int D.30433;
  const unsigned char * D.30434;
  unsigned char D.30435;
  int D.30436;
  const char * D.30438;
  int D.22167;
  int iftmp.282;
  int D.22163;
  const char[23] * D.30444;
  unsigned char D.30445;
  int D.30446;
  unsigned char D.30447;
  int D.30448;
  _Bool D.30449;
  _Bool D.30450;
  _Bool D.30451;
  const unsigned char * D.30454;
  unsigned char D.30455;
  int D.30456;
  const unsigned char * D.30457;
  unsigned char D.30458;
  int D.30459;
  _Bool D.30460;
  _Bool D.30461;
  const unsigned char * D.30464;
  unsigned char D.30465;
  int D.30466;
  const unsigned char * D.30467;
  unsigned char D.30468;
  int D.30469;
  _Bool D.30470;
  _Bool D.30471;
  const unsigned char * D.30474;
  unsigned char D.30475;
  int D.30476;
  const unsigned char * D.30477;
  unsigned char D.30478;
  int D.30479;
  const char * D.30481;

  {
    static struct MonoClass * cached_class;

    cached_class.280 = cached_class;
    if (cached_class.280 != 0B) goto <D.30391>; else goto <D.30392>;
    <D.30391>:
    cached_class.280 = cached_class;
    D.30394 = cached_class.280 == class;
    D.30393 = (gboolean) D.30394;
    return D.30393;
    <D.30392>:
    D.30395 = is_corlib_type (class);
    if (D.30395 != 0) goto <D.30396>; else goto <D.30397>;
    <D.30396>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30401 = "ByRefType";
        D.30402 = MEM[(const unsigned char *)D.30401];
        D.30403 = (int) D.30402;
        D.30404 = *__s2;
        D.30405 = (int) D.30404;
        __result = D.30403 - D.30405;
        {
          D.30406 = __s1_len != 0;
          D.30407 = __result == 0;
          D.30408 = D.30406 & D.30407;
          if (D.30408 != 0) goto <D.30409>; else goto <D.30410>;
          <D.30409>:
          D.30411 = &MEM[(void *)"ByRefType" + 1B];
          D.30412 = *D.30411;
          D.30413 = (int) D.30412;
          D.30414 = __s2 + 1;
          D.30415 = *D.30414;
          D.30416 = (int) D.30415;
          __result = D.30413 - D.30416;
          D.30417 = __s1_len > 1;
          D.30407 = __result == 0;
          D.30418 = D.30417 & D.30407;
          if (D.30418 != 0) goto <D.30419>; else goto <D.30420>;
          <D.30419>:
          D.30421 = &MEM[(void *)"ByRefType" + 2B];
          D.30422 = *D.30421;
          D.30423 = (int) D.30422;
          D.30424 = __s2 + 2;
          D.30425 = *D.30424;
          D.30426 = (int) D.30425;
          __result = D.30423 - D.30426;
          D.30427 = __s1_len > 2;
          D.30407 = __result == 0;
          D.30428 = D.30427 & D.30407;
          if (D.30428 != 0) goto <D.30429>; else goto <D.30430>;
          <D.30429>:
          D.30431 = &MEM[(void *)"ByRefType" + 3B];
          D.30432 = *D.30431;
          D.30433 = (int) D.30432;
          D.30434 = __s2 + 3;
          D.30435 = *D.30434;
          D.30436 = (int) D.30435;
          __result = D.30433 - D.30436;
          <D.30430>:
          <D.30420>:
          <D.30410>:
        }
        D.22154 = __result;
      }
      iftmp.281 = D.22154;
      goto <D.30437>;
      <D.30400>:
      D.30438 = class->name;
      iftmp.281 = __builtin_strcmp ("ByRefType", D.30438);
      <D.30437>:
      D.22158 = iftmp.281;
    }
    if (D.22158 == 0) goto <D.30439>; else goto <D.30440>;
    <D.30439>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30444 = "System.Reflection.Emit";
        D.30445 = MEM[(const unsigned char *)D.30444];
        D.30446 = (int) D.30445;
        D.30447 = *__s2;
        D.30448 = (int) D.30447;
        __result = D.30446 - D.30448;
        {
          D.30449 = __s1_len != 0;
          D.30450 = __result == 0;
          D.30451 = D.30449 & D.30450;
          if (D.30451 != 0) goto <D.30452>; else goto <D.30453>;
          <D.30452>:
          D.30454 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30455 = *D.30454;
          D.30456 = (int) D.30455;
          D.30457 = __s2 + 1;
          D.30458 = *D.30457;
          D.30459 = (int) D.30458;
          __result = D.30456 - D.30459;
          D.30460 = __s1_len > 1;
          D.30450 = __result == 0;
          D.30461 = D.30460 & D.30450;
          if (D.30461 != 0) goto <D.30462>; else goto <D.30463>;
          <D.30462>:
          D.30464 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30465 = *D.30464;
          D.30466 = (int) D.30465;
          D.30467 = __s2 + 2;
          D.30468 = *D.30467;
          D.30469 = (int) D.30468;
          __result = D.30466 - D.30469;
          D.30470 = __s1_len > 2;
          D.30450 = __result == 0;
          D.30471 = D.30470 & D.30450;
          if (D.30471 != 0) goto <D.30472>; else goto <D.30473>;
          <D.30472>:
          D.30474 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30475 = *D.30474;
          D.30476 = (int) D.30475;
          D.30477 = __s2 + 3;
          D.30478 = *D.30477;
          D.30479 = (int) D.30478;
          __result = D.30476 - D.30479;
          <D.30473>:
          <D.30463>:
          <D.30453>:
        }
        D.22163 = __result;
      }
      iftmp.282 = D.22163;
      goto <D.30480>;
      <D.30443>:
      D.30481 = class->name_space;
      iftmp.282 = __builtin_strcmp ("System.Reflection.Emit", D.30481);
      <D.30480>:
      D.22167 = iftmp.282;
    }
    if (D.22167 == 0) goto <D.30482>; else goto <D.30483>;
    <D.30482>:
    cached_class = class;
    D.30393 = 1;
    return D.30393;
    <D.30483>:
    <D.30440>:
    <D.30397>:
    D.30393 = 0;
    return D.30393;
  }
}


is_sre_pointer (struct MonoClass * class)
{
  struct MonoClass * cached_class.283;
  gboolean D.30488;
  _Bool D.30489;
  int D.30490;
  int D.22180;
  int iftmp.284;
  int D.22176;
  const char[12] * D.30496;
  unsigned char D.30497;
  int D.30498;
  unsigned char D.30499;
  int D.30500;
  _Bool D.30501;
  _Bool D.30502;
  _Bool D.30503;
  const unsigned char * D.30506;
  unsigned char D.30507;
  int D.30508;
  const unsigned char * D.30509;
  unsigned char D.30510;
  int D.30511;
  _Bool D.30512;
  _Bool D.30513;
  const unsigned char * D.30516;
  unsigned char D.30517;
  int D.30518;
  const unsigned char * D.30519;
  unsigned char D.30520;
  int D.30521;
  _Bool D.30522;
  _Bool D.30523;
  const unsigned char * D.30526;
  unsigned char D.30527;
  int D.30528;
  const unsigned char * D.30529;
  unsigned char D.30530;
  int D.30531;
  const char * D.30533;
  int D.22189;
  int iftmp.285;
  int D.22185;
  const char[23] * D.30539;
  unsigned char D.30540;
  int D.30541;
  unsigned char D.30542;
  int D.30543;
  _Bool D.30544;
  _Bool D.30545;
  _Bool D.30546;
  const unsigned char * D.30549;
  unsigned char D.30550;
  int D.30551;
  const unsigned char * D.30552;
  unsigned char D.30553;
  int D.30554;
  _Bool D.30555;
  _Bool D.30556;
  const unsigned char * D.30559;
  unsigned char D.30560;
  int D.30561;
  const unsigned char * D.30562;
  unsigned char D.30563;
  int D.30564;
  _Bool D.30565;
  _Bool D.30566;
  const unsigned char * D.30569;
  unsigned char D.30570;
  int D.30571;
  const unsigned char * D.30572;
  unsigned char D.30573;
  int D.30574;
  const char * D.30576;

  {
    static struct MonoClass * cached_class;

    cached_class.283 = cached_class;
    if (cached_class.283 != 0B) goto <D.30486>; else goto <D.30487>;
    <D.30486>:
    cached_class.283 = cached_class;
    D.30489 = cached_class.283 == class;
    D.30488 = (gboolean) D.30489;
    return D.30488;
    <D.30487>:
    D.30490 = is_corlib_type (class);
    if (D.30490 != 0) goto <D.30491>; else goto <D.30492>;
    <D.30491>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30496 = "PointerType";
        D.30497 = MEM[(const unsigned char *)D.30496];
        D.30498 = (int) D.30497;
        D.30499 = *__s2;
        D.30500 = (int) D.30499;
        __result = D.30498 - D.30500;
        {
          D.30501 = __s1_len != 0;
          D.30502 = __result == 0;
          D.30503 = D.30501 & D.30502;
          if (D.30503 != 0) goto <D.30504>; else goto <D.30505>;
          <D.30504>:
          D.30506 = &MEM[(void *)"PointerType" + 1B];
          D.30507 = *D.30506;
          D.30508 = (int) D.30507;
          D.30509 = __s2 + 1;
          D.30510 = *D.30509;
          D.30511 = (int) D.30510;
          __result = D.30508 - D.30511;
          D.30512 = __s1_len > 1;
          D.30502 = __result == 0;
          D.30513 = D.30512 & D.30502;
          if (D.30513 != 0) goto <D.30514>; else goto <D.30515>;
          <D.30514>:
          D.30516 = &MEM[(void *)"PointerType" + 2B];
          D.30517 = *D.30516;
          D.30518 = (int) D.30517;
          D.30519 = __s2 + 2;
          D.30520 = *D.30519;
          D.30521 = (int) D.30520;
          __result = D.30518 - D.30521;
          D.30522 = __s1_len > 2;
          D.30502 = __result == 0;
          D.30523 = D.30522 & D.30502;
          if (D.30523 != 0) goto <D.30524>; else goto <D.30525>;
          <D.30524>:
          D.30526 = &MEM[(void *)"PointerType" + 3B];
          D.30527 = *D.30526;
          D.30528 = (int) D.30527;
          D.30529 = __s2 + 3;
          D.30530 = *D.30529;
          D.30531 = (int) D.30530;
          __result = D.30528 - D.30531;
          <D.30525>:
          <D.30515>:
          <D.30505>:
        }
        D.22176 = __result;
      }
      iftmp.284 = D.22176;
      goto <D.30532>;
      <D.30495>:
      D.30533 = class->name;
      iftmp.284 = __builtin_strcmp ("PointerType", D.30533);
      <D.30532>:
      D.22180 = iftmp.284;
    }
    if (D.22180 == 0) goto <D.30534>; else goto <D.30535>;
    <D.30534>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30539 = "System.Reflection.Emit";
        D.30540 = MEM[(const unsigned char *)D.30539];
        D.30541 = (int) D.30540;
        D.30542 = *__s2;
        D.30543 = (int) D.30542;
        __result = D.30541 - D.30543;
        {
          D.30544 = __s1_len != 0;
          D.30545 = __result == 0;
          D.30546 = D.30544 & D.30545;
          if (D.30546 != 0) goto <D.30547>; else goto <D.30548>;
          <D.30547>:
          D.30549 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30550 = *D.30549;
          D.30551 = (int) D.30550;
          D.30552 = __s2 + 1;
          D.30553 = *D.30552;
          D.30554 = (int) D.30553;
          __result = D.30551 - D.30554;
          D.30555 = __s1_len > 1;
          D.30545 = __result == 0;
          D.30556 = D.30555 & D.30545;
          if (D.30556 != 0) goto <D.30557>; else goto <D.30558>;
          <D.30557>:
          D.30559 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30560 = *D.30559;
          D.30561 = (int) D.30560;
          D.30562 = __s2 + 2;
          D.30563 = *D.30562;
          D.30564 = (int) D.30563;
          __result = D.30561 - D.30564;
          D.30565 = __s1_len > 2;
          D.30545 = __result == 0;
          D.30566 = D.30565 & D.30545;
          if (D.30566 != 0) goto <D.30567>; else goto <D.30568>;
          <D.30567>:
          D.30569 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30570 = *D.30569;
          D.30571 = (int) D.30570;
          D.30572 = __s2 + 3;
          D.30573 = *D.30572;
          D.30574 = (int) D.30573;
          __result = D.30571 - D.30574;
          <D.30568>:
          <D.30558>:
          <D.30548>:
        }
        D.22185 = __result;
      }
      iftmp.285 = D.22185;
      goto <D.30575>;
      <D.30538>:
      D.30576 = class->name_space;
      iftmp.285 = __builtin_strcmp ("System.Reflection.Emit", D.30576);
      <D.30575>:
      D.22189 = iftmp.285;
    }
    if (D.22189 == 0) goto <D.30577>; else goto <D.30578>;
    <D.30577>:
    cached_class = class;
    D.30488 = 1;
    return D.30488;
    <D.30578>:
    <D.30535>:
    <D.30492>:
    D.30488 = 0;
    return D.30488;
  }
}


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

  token.286 = (const void *) token;
  D.30581 = assembly->tokens;
  prev = mono_g_hash_table_lookup (D.30581, token.286);
  if (prev != 0B) goto <D.30582>; else goto <D.30583>;
  <D.30582>:
  goto <D.30584>;
  <D.30583>:
  token.287 = (void *) token;
  D.30581 = assembly->tokens;
  mono_g_hash_table_insert (D.30581, token.287, obj);
  <D.30584>:
}


mono_dynamic_image_release_gc_roots (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * * D.30586;
  struct MonoGHashTable * * D.30587;
  struct MonoGHashTable * * D.30588;
  struct MonoGHashTable * * D.30589;
  struct MonoGHashTable * * D.30590;
  struct MonoGHashTable * * D.30591;

  D.30586 = &image->token_fixups;
  release_hashtable (D.30586);
  D.30587 = &image->handleref_managed;
  release_hashtable (D.30587);
  D.30588 = &image->tokens;
  release_hashtable (D.30588);
  D.30589 = &image->remapped_tokens;
  release_hashtable (D.30589);
  D.30590 = &image->generic_def_objects;
  release_hashtable (D.30590);
  D.30591 = &image->methodspec;
  release_hashtable (D.30591);
}


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

  D.30592 = *hash;
  if (D.30592 != 0B) goto <D.30593>; else goto <D.30594>;
  <D.30593>:
  D.30592 = *hash;
  mono_g_hash_table_destroy (D.30592);
  *hash = 0B;
  <D.30594>:
}


mono_dynamic_image_free (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * D.30595;
  struct GHashTable * D.30598;
  struct GHashTable * D.30601;
  struct GHashTable * D.30604;
  struct MonoGHashTable * D.30607;
  struct MonoGHashTable * D.30610;
  struct MonoGHashTable * D.30613;
  struct MonoGHashTable * D.30616;
  struct GHashTable * D.30619;
  struct GHashTable * D.30622;
  struct MonoMethodSignature * D.30625;
  char * D.30626;
  struct GList * D.30627;
  struct GPtrArray * D.30628;
  void * * D.30631;
  unsigned int i.288;
  unsigned int D.30633;
  void * * D.30634;
  struct MonoReflectionGenericParam * * D.30635;
  unsigned int i.289;
  unsigned int D.30637;
  struct MonoGHashTable * D.30638;
  struct GHashTable * D.30641;
  struct GHashTable * D.30644;
  struct GHashTable * D.30647;
  struct GHashTable * D.30650;
  char * D.30653;
  char * D.30654;
  guint8 * D.30655;
  struct MonoDynamicStream * D.30658;
  struct MonoDynamicStream * D.30659;
  struct MonoDynamicStream * D.30660;
  struct MonoDynamicStream * D.30661;
  struct MonoDynamicStream * D.30662;
  struct MonoDynamicStream * D.30663;
  struct MonoDynamicStream * D.30664;
  guint32 * D.30665;
  struct MonoDynamicImage * di;
  struct GList * list;
  int i;

  di = image;
  D.30595 = di->methodspec;
  if (D.30595 != 0B) goto <D.30596>; else goto <D.30597>;
  <D.30596>:
  D.30595 = di->methodspec;
  mono_g_hash_table_destroy (D.30595);
  <D.30597>:
  D.30598 = di->typespec;
  if (D.30598 != 0B) goto <D.30599>; else goto <D.30600>;
  <D.30599>:
  D.30598 = di->typespec;
  monoeg_g_hash_table_destroy (D.30598);
  <D.30600>:
  D.30601 = di->typeref;
  if (D.30601 != 0B) goto <D.30602>; else goto <D.30603>;
  <D.30602>:
  D.30601 = di->typeref;
  monoeg_g_hash_table_destroy (D.30601);
  <D.30603>:
  D.30604 = di->handleref;
  if (D.30604 != 0B) goto <D.30605>; else goto <D.30606>;
  <D.30605>:
  D.30604 = di->handleref;
  monoeg_g_hash_table_destroy (D.30604);
  <D.30606>:
  D.30607 = di->handleref_managed;
  if (D.30607 != 0B) goto <D.30608>; else goto <D.30609>;
  <D.30608>:
  D.30607 = di->handleref_managed;
  mono_g_hash_table_destroy (D.30607);
  <D.30609>:
  D.30610 = di->tokens;
  if (D.30610 != 0B) goto <D.30611>; else goto <D.30612>;
  <D.30611>:
  D.30610 = di->tokens;
  mono_g_hash_table_destroy (D.30610);
  <D.30612>:
  D.30613 = di->remapped_tokens;
  if (D.30613 != 0B) goto <D.30614>; else goto <D.30615>;
  <D.30614>:
  D.30613 = di->remapped_tokens;
  mono_g_hash_table_destroy (D.30613);
  <D.30615>:
  D.30616 = di->generic_def_objects;
  if (D.30616 != 0B) goto <D.30617>; else goto <D.30618>;
  <D.30617>:
  D.30616 = di->generic_def_objects;
  mono_g_hash_table_destroy (D.30616);
  <D.30618>:
  D.30619 = di->blob_cache;
  if (D.30619 != 0B) goto <D.30620>; else goto <D.30621>;
  <D.30620>:
  D.30619 = di->blob_cache;
  monoeg_g_hash_table_foreach (D.30619, free_blob_cache_entry, 0B);
  D.30619 = di->blob_cache;
  monoeg_g_hash_table_destroy (D.30619);
  <D.30621>:
  D.30622 = di->standalonesig_cache;
  if (D.30622 != 0B) goto <D.30623>; else goto <D.30624>;
  <D.30623>:
  D.30622 = di->standalonesig_cache;
  monoeg_g_hash_table_destroy (D.30622);
  <D.30624>:
  list = di->array_methods;
  goto <D.20404>;
  <D.20403>:
  {
    struct ArrayMethod * am;

    am = list->data;
    D.30625 = am->sig;
    monoeg_g_free (D.30625);
    D.30626 = am->name;
    monoeg_g_free (D.30626);
    monoeg_g_free (am);
  }
  list = list->next;
  <D.20404>:
  if (list != 0B) goto <D.20403>; else goto <D.20405>;
  <D.20405>:
  D.30627 = di->array_methods;
  monoeg_g_list_free (D.30627);
  D.30628 = di->gen_params;
  if (D.30628 != 0B) goto <D.30629>; else goto <D.30630>;
  <D.30629>:
  i = 0;
  goto <D.20408>;
  <D.20407>:
  {
    struct GenericParamTableEntry * entry;

    D.30628 = di->gen_params;
    D.30631 = D.30628->pdata;
    i.288 = (unsigned int) i;
    D.30633 = i.288 * 4;
    D.30634 = D.30631 + D.30633;
    entry = *D.30634;
    D.30635 = &entry->gparam;
    mono_gc_deregister_root (D.30635);
    monoeg_g_free (entry);
  }
  i = i + 1;
  <D.20408>:
  i.289 = (unsigned int) i;
  D.30628 = di->gen_params;
  D.30637 = D.30628->len;
  if (i.289 < D.30637) goto <D.20407>; else goto <D.20409>;
  <D.20409>:
  D.30628 = di->gen_params;
  monoeg_g_ptr_array_free (D.30628, 1);
  <D.30630>:
  D.30638 = di->token_fixups;
  if (D.30638 != 0B) goto <D.30639>; else goto <D.30640>;
  <D.30639>:
  D.30638 = di->token_fixups;
  mono_g_hash_table_destroy (D.30638);
  <D.30640>:
  D.30641 = di->method_to_table_idx;
  if (D.30641 != 0B) goto <D.30642>; else goto <D.30643>;
  <D.30642>:
  D.30641 = di->method_to_table_idx;
  monoeg_g_hash_table_destroy (D.30641);
  <D.30643>:
  D.30644 = di->field_to_table_idx;
  if (D.30644 != 0B) goto <D.30645>; else goto <D.30646>;
  <D.30645>:
  D.30644 = di->field_to_table_idx;
  monoeg_g_hash_table_destroy (D.30644);
  <D.30646>:
  D.30647 = di->method_aux_hash;
  if (D.30647 != 0B) goto <D.30648>; else goto <D.30649>;
  <D.30648>:
  D.30647 = di->method_aux_hash;
  monoeg_g_hash_table_destroy (D.30647);
  <D.30649>:
  D.30650 = di->vararg_aux_hash;
  if (D.30650 != 0B) goto <D.30651>; else goto <D.30652>;
  <D.30651>:
  D.30650 = di->vararg_aux_hash;
  monoeg_g_hash_table_destroy (D.30650);
  <D.30652>:
  D.30653 = di->strong_name;
  monoeg_g_free (D.30653);
  D.30654 = di->win32_res;
  monoeg_g_free (D.30654);
  D.30655 = di->public_key;
  if (D.30655 != 0B) goto <D.30656>; else goto <D.30657>;
  <D.30656>:
  D.30655 = di->public_key;
  monoeg_g_free (D.30655);
  <D.30657>:
  D.30658 = &di->sheap;
  mono_dynamic_stream_reset (D.30658);
  D.30659 = &di->code;
  mono_dynamic_stream_reset (D.30659);
  D.30660 = &di->resources;
  mono_dynamic_stream_reset (D.30660);
  D.30661 = &di->us;
  mono_dynamic_stream_reset (D.30661);
  D.30662 = &di->blob;
  mono_dynamic_stream_reset (D.30662);
  D.30663 = &di->tstream;
  mono_dynamic_stream_reset (D.30663);
  D.30664 = &di->guid;
  mono_dynamic_stream_reset (D.30664);
  i = 0;
  goto <D.20411>;
  <D.20410>:
  D.30665 = di->tables[i].values;
  monoeg_g_free (D.30665);
  i = i + 1;
  <D.20411>:
  if (i <= 44) goto <D.20410>; else goto <D.20412>;
  <D.20412>:
}


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.30666;
  struct MonoDynamicAssembly * D.30667;
  void * D.30670;
  struct MonoAssembly * D.30671;
  unsigned char D.30672;
  struct MonoString * D.30673;
  char * D.30674;
  struct MonoString * D.30675;
  char * D.30678;
  gchar * D.30680;
  struct MonoString * D.30681;
  char * * parts.290;
  char * D.30685;
  int D.30686;
  short unsigned int D.30687;
  char * * parts.291;
  char * D.30689;
  int D.30690;
  short unsigned int D.30691;
  uint16_t iftmp.292;
  char * D.30693;
  char * * parts.293;
  char * D.30697;
  int D.30698;
  uint16_t iftmp.294;
  int D.30703;
  unsigned int D.30706;
  _Bool D.30707;
  unsigned char D.30708;
  _Bool D.30709;
  unsigned char D.30710;
  gchar * D.30711;
  struct MonoString * D.30712;
  char * D.30713;
  char * D.30714;
  struct MonoImage * D.30715;
  struct MonoArray * D.30716;
  unsigned int D.30719;
  const char * D.30724;
  char * D.30725;
  mono_byte[17] * D.30726;
  union mono_mutex_t * D.30727;
  _Bool D.30730;
  long int D.30731;
  long int D.30732;
  struct GSList * D.30735;
  struct GSList * D.30736;
  _Bool D.30739;
  long int D.30740;
  long int D.30741;
  struct MonoReflectionAssembly * D.30744;
  struct MonoDomain * D.30745;
  struct MonoDynamicAssembly * assembly;
  struct MonoDynamicImage * image;
  struct MonoDomain * domain;

  D.30666 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.30666->domain;
  D.30667 = assemblyb->dynamic_assembly;
  if (D.30667 != 0B) goto <D.30668>; else goto <D.30669>;
  <D.30668>:
  return;
  <D.30669>:
  D.30670 = monoeg_malloc0 (108);
  assemblyb->dynamic_assembly = D.30670;
  assembly = assemblyb->dynamic_assembly;
  D.30671 = &assembly->assembly;
  mono_profiler_assembly_event (D.30671, 0);
  assembly->assembly.ref_count = 1;
  assembly->assembly.dynamic = 1;
  D.30672 = assemblyb->corlib_internal;
  assembly->assembly.corlib_internal = D.30672;
  assemblyb->assembly.assembly = assembly;
  D.30673 = assemblyb->dir;
  D.30674 = mono_string_to_utf8 (D.30673);
  assembly->assembly.basedir = D.30674;
  D.30675 = assemblyb->culture;
  if (D.30675 != 0B) goto <D.30676>; else goto <D.30677>;
  <D.30676>:
  D.30675 = assemblyb->culture;
  D.30678 = mono_string_to_utf8 (D.30675);
  assembly->assembly.aname.culture = D.30678;
  goto <D.30679>;
  <D.30677>:
  D.30680 = monoeg_strdup ("");
  assembly->assembly.aname.culture = D.30680;
  <D.30679>:
  D.30681 = assemblyb->version;
  if (D.30681 != 0B) goto <D.30682>; else goto <D.30683>;
  <D.30682>:
  {
    char * vstr;
    char * * version;
    char * * parts;

    D.30681 = assemblyb->version;
    vstr = mono_string_to_utf8 (D.30681);
    version = monoeg_g_strsplit (vstr, ".", 4);
    parts = version;
    parts.290 = parts;
    parts = parts.290 + 4;
    D.30685 = *parts.290;
    D.30686 = atoi (D.30685);
    D.30687 = (short unsigned int) D.30686;
    assembly->assembly.aname.major = D.30687;
    parts.291 = parts;
    parts = parts.291 + 4;
    D.30689 = *parts.291;
    D.30690 = atoi (D.30689);
    D.30691 = (short unsigned int) D.30690;
    assembly->assembly.aname.minor = D.30691;
    D.30693 = *parts;
    if (D.30693 != 0B) goto <D.30694>; else goto <D.30695>;
    <D.30694>:
    parts.293 = parts;
    parts = parts.293 + 4;
    D.30697 = *parts.293;
    D.30698 = atoi (D.30697);
    iftmp.292 = (uint16_t) D.30698;
    goto <D.30699>;
    <D.30695>:
    iftmp.292 = 0;
    <D.30699>:
    assembly->assembly.aname.build = iftmp.292;
    D.30693 = *parts;
    if (D.30693 != 0B) goto <D.30701>; else goto <D.30702>;
    <D.30701>:
    D.30693 = *parts;
    D.30703 = atoi (D.30693);
    iftmp.294 = (uint16_t) D.30703;
    goto <D.30704>;
    <D.30702>:
    iftmp.294 = 0;
    <D.30704>:
    assembly->assembly.aname.revision = iftmp.294;
    monoeg_g_strfreev (version);
    monoeg_g_free (vstr);
  }
  goto <D.30705>;
  <D.30683>:
  assembly->assembly.aname.major = 0;
  assembly->assembly.aname.minor = 0;
  assembly->assembly.aname.build = 0;
  assembly->assembly.aname.revision = 0;
  <D.30705>:
  D.30706 = assemblyb->access;
  D.30707 = D.30706 != 2;
  D.30708 = (unsigned char) D.30707;
  assembly->run = D.30708;
  D.30706 = assemblyb->access;
  D.30709 = D.30706 != 1;
  D.30710 = (unsigned char) D.30709;
  assembly->save = D.30710;
  assembly->domain = domain;
  D.30711 = monoeg_strdup ("RefEmit_YouForgotToDefineAModule");
  D.30712 = assemblyb->name;
  D.30713 = mono_string_to_utf8 (D.30712);
  image = create_dynamic_mono_image (assembly, D.30713, D.30711);
  image->initial_image = 1;
  D.30714 = image->image.name;
  assembly->assembly.aname.name = D.30714;
  D.30715 = &image->image;
  assembly->assembly.image = D.30715;
  D.30716 = assemblyb->pktoken;
  if (D.30716 != 0B) goto <D.30717>; else goto <D.30718>;
  <D.30717>:
  D.30716 = assemblyb->pktoken;
  D.30719 = D.30716->max_length;
  if (D.30719 != 0) goto <D.30720>; else goto <D.30721>;
  <D.30720>:
  D.30716 = assemblyb->pktoken;
  D.30719 = D.30716->max_length;
  if (D.30719 != 16) goto <D.30722>; else goto <D.30723>;
  <D.30722>:
  D.30716 = assemblyb->pktoken;
  D.30719 = D.30716->max_length;
  D.30724 = assembly->assembly.aname.name;
  monoeg_g_log (0B, 4, "Public key token length invalid for assembly %s: %i", D.30724, D.30719);
  <D.20422>:
  goto <D.20422>;
  <D.30723>:
  D.30716 = assemblyb->pktoken;
  D.30719 = D.30716->max_length;
  D.30716 = assemblyb->pktoken;
  D.30725 = mono_array_addr_with_size (D.30716, 1, 0);
  D.30726 = &assembly->assembly.aname.public_key_token;
  memcpy (D.30726, D.30725, D.30719);
  <D.30721>:
  <D.30718>:
  {
    int ret;

    D.30727 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.30727);
    if (ret != 0) goto <D.30728>; else goto <D.30729>;
    <D.30728>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.30729>:
    D.30730 = ret != 0;
    D.30731 = (long int) D.30730;
    D.30732 = __builtin_expect (D.30731, 0);
    if (D.30732 != 0) goto <D.30733>; else goto <D.30734>;
    <D.30733>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5333, "ret == 0");
    <D.30734>:
  }
  D.30735 = domain->domain_assemblies;
  D.30736 = monoeg_g_slist_append (D.30735, assembly);
  domain->domain_assemblies = D.30736;
  {
    int ret;

    D.30727 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.30727);
    if (ret != 0) goto <D.30737>; else goto <D.30738>;
    <D.30737>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.30738>:
    D.30739 = ret != 0;
    D.30740 = (long int) D.30739;
    D.30741 = __builtin_expect (D.30740, 0);
    if (D.30741 != 0) goto <D.30742>; else goto <D.30743>;
    <D.30742>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5335, "ret == 0");
    <D.30743>:
  }
  D.30671 = &assembly->assembly;
  D.30744 = &assemblyb->assembly;
  D.30666 = MEM[(struct MonoObject *)assemblyb].vtable;
  D.30745 = D.30666->domain;
  register_assembly (D.30745, D.30744, D.30671);
  D.30671 = &assembly->assembly;
  mono_profiler_assembly_loaded (D.30671, 0);
  mono_assembly_invoke_load_hook (assembly);
}


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

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


create_dynamic_mono_image (struct MonoDynamicAssembly * assembly, char * assembly_name, char * module_name)
{
  int D.20381;
  int iftmp.295;
  int D.20380;
  const struct MonoRuntimeInfo * D.30752;
  const char[4] * D.30753;
  unsigned char D.30754;
  int D.30755;
  unsigned char D.30756;
  int D.30757;
  _Bool D.30758;
  _Bool D.30759;
  _Bool D.30760;
  const unsigned char * D.30763;
  unsigned char D.30764;
  int D.30765;
  const unsigned char * D.30766;
  unsigned char D.30767;
  int D.30768;
  _Bool D.30769;
  _Bool D.30770;
  const unsigned char * D.30773;
  unsigned char D.30774;
  int D.30775;
  const unsigned char * D.30776;
  unsigned char D.30777;
  int D.30778;
  _Bool D.30779;
  _Bool D.30780;
  const unsigned char * D.30783;
  unsigned char D.30784;
  int D.30785;
  const unsigned char * D.30786;
  unsigned char D.30787;
  int D.30788;
  const struct MonoRuntimeInfo * D.30790;
  const char[4] * D.30791;
  const struct MonoRuntimeInfo * D.30795;
  struct MonoImage * D.30796;
  char * D.30797;
  gchar * D.30798;
  void * D.30799;
  struct MonoAssembly * * D.30800;
  struct MonoGHashTable * D.30801;
  struct GHashTable * D.30802;
  struct GHashTable * D.30803;
  struct GHashTable * D.30804;
  struct GHashTable * D.30805;
  struct GHashTable * D.30806;
  struct MonoGHashTable * D.30807;
  struct MonoGHashTable * D.30808;
  struct MonoGHashTable * D.30809;
  struct MonoGHashTable * D.30810;
  struct GHashTable * D.30811;
  struct GHashTable * D.30812;
  struct GHashTable * D.30813;
  struct GPtrArray * D.30814;
  struct MonoGHashTable * D.30815;
  struct MonoDynamicStream * D.30816;
  struct MonoDynamicStream * D.30817;
  struct MonoDynamicStream * D.30818;
  unsigned int D.30819;
  unsigned int D.30820;
  unsigned int D.30821;
  unsigned int D.30822;
  unsigned int D.30823;
  unsigned char D.30824;
  unsigned char D.30825;
  int D.30826;
  unsigned char D.30827;
  int D.30828;
  struct MonoDynamicImage * D.30829;
  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.30750>; else goto <D.30751>;
    <D.30750>:
    {
      const unsigned char * __s2;
      int __result;

      D.30752 = mono_get_runtime_info ();
      __s2 = &D.30752->framework_version;
      D.30753 = "2.1";
      D.30754 = MEM[(const unsigned char *)D.30753];
      D.30755 = (int) D.30754;
      D.30756 = *__s2;
      D.30757 = (int) D.30756;
      __result = D.30755 - D.30757;
      {
        D.30758 = __s2_len != 0;
        D.30759 = __result == 0;
        D.30760 = D.30758 & D.30759;
        if (D.30760 != 0) goto <D.30761>; else goto <D.30762>;
        <D.30761>:
        D.30763 = &MEM[(void *)"2.1" + 1B];
        D.30764 = *D.30763;
        D.30765 = (int) D.30764;
        D.30766 = __s2 + 1;
        D.30767 = *D.30766;
        D.30768 = (int) D.30767;
        __result = D.30765 - D.30768;
        D.30769 = __s2_len > 1;
        D.30759 = __result == 0;
        D.30770 = D.30769 & D.30759;
        if (D.30770 != 0) goto <D.30771>; else goto <D.30772>;
        <D.30771>:
        D.30773 = &MEM[(void *)"2.1" + 2B];
        D.30774 = *D.30773;
        D.30775 = (int) D.30774;
        D.30776 = __s2 + 2;
        D.30777 = *D.30776;
        D.30778 = (int) D.30777;
        __result = D.30775 - D.30778;
        D.30779 = __s2_len > 2;
        D.30759 = __result == 0;
        D.30780 = D.30779 & D.30759;
        if (D.30780 != 0) goto <D.30781>; else goto <D.30782>;
        <D.30781>:
        D.30783 = &MEM[(void *)"2.1" + 3B];
        D.30784 = *D.30783;
        D.30785 = (int) D.30784;
        D.30786 = __s2 + 3;
        D.30787 = *D.30786;
        D.30788 = (int) D.30787;
        __result = D.30785 - D.30788;
        <D.30782>:
        <D.30772>:
        <D.30762>:
      }
      D.20380 = __result;
    }
    iftmp.295 = -D.20380;
    goto <D.30789>;
    <D.30751>:
    D.30790 = mono_get_runtime_info ();
    D.30791 = &D.30790->framework_version;
    iftmp.295 = __builtin_strcmp (D.30791, "2.1");
    <D.30789>:
    D.20381 = iftmp.295;
  }
  if (D.20381 == 0) goto <D.30792>; else goto <D.30793>;
  <D.30792>:
  version = "v2.0.50727";
  goto <D.30794>;
  <D.30793>:
  D.30795 = mono_get_runtime_info ();
  version = &D.30795->runtime_version;
  <D.30794>:
  image = monoeg_malloc0 (2220);
  D.30796 = &image->image;
  mono_profiler_module_event (D.30796, 0);
  image->image.name = assembly_name;
  D.30797 = image->image.name;
  image->image.assembly_name = D.30797;
  image->image.module_name = module_name;
  D.30798 = monoeg_strdup (version);
  image->image.version = D.30798;
  image->image.md_version_major = 1;
  image->image.md_version_minor = 1;
  image->image.dynamic = 1;
  D.30799 = monoeg_malloc0 (4);
  image->image.references = D.30799;
  D.30800 = image->image.references;
  *D.30800 = 0B;
  D.30796 = &image->image;
  mono_image_init (D.30796);
  D.30801 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->token_fixups = D.30801;
  D.30802 = monoeg_g_hash_table_new (0B, 0B);
  image->method_to_table_idx = D.30802;
  D.30803 = monoeg_g_hash_table_new (0B, 0B);
  image->field_to_table_idx = D.30803;
  D.30804 = monoeg_g_hash_table_new (0B, 0B);
  image->method_aux_hash = D.30804;
  D.30805 = monoeg_g_hash_table_new (0B, 0B);
  image->vararg_aux_hash = D.30805;
  D.30806 = monoeg_g_hash_table_new (0B, 0B);
  image->handleref = D.30806;
  D.30807 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->handleref_managed = D.30807;
  D.30808 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->tokens = D.30808;
  D.30809 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->generic_def_objects = D.30809;
  D.30810 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->methodspec = D.30810;
  D.30811 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typespec = D.30811;
  D.30812 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typeref = D.30812;
  D.30813 = monoeg_g_hash_table_new (mono_blob_entry_hash, mono_blob_entry_equal);
  image->blob_cache = D.30813;
  D.30814 = monoeg_g_ptr_array_new ();
  image->gen_params = D.30814;
  D.30815 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->remapped_tokens = D.30815;
  D.30816 = &image->sheap;
  string_heap_init (D.30816);
  D.30817 = &image->us;
  mono_image_add_stream_data (D.30817, "", 1);
  add_to_blob_cached (image, "", 1, 0B, 0);
  D.30818 = &image->code;
  mono_image_add_stream_data (D.30818, &entrycode, 16);
  D.30818 = &image->code;
  D.30819 = mono_image_add_stream_zero (D.30818, 8);
  image->iat_offset = D.30819;
  D.30818 = &image->code;
  D.30820 = mono_image_add_stream_zero (D.30818, 40);
  image->idt_offset = D.30820;
  D.30818 = &image->code;
  D.30821 = mono_image_add_stream_zero (D.30818, 2);
  image->imp_names_offset = D.30821;
  D.30818 = &image->code;
  mono_image_add_stream_data (D.30818, "_CorExeMain", 12);
  D.30818 = &image->code;
  mono_image_add_stream_data (D.30818, "mscoree.dll", 12);
  D.30818 = &image->code;
  D.30822 = mono_image_add_stream_zero (D.30818, 8);
  image->ilt_offset = D.30822;
  D.30818 = &image->code;
  stream_data_align (D.30818);
  D.30818 = &image->code;
  D.30823 = mono_image_add_stream_zero (D.30818, 136);
  image->cli_header_offset = D.30823;
  i = 0;
  goto <D.20383>;
  <D.20382>:
  image->tables[i].next_idx = 1;
  D.30824 = table_sizes[i];
  image->tables[i].columns = D.30824;
  i = i + 1;
  <D.20383>:
  if (i <= 44) goto <D.20382>; else goto <D.20384>;
  <D.20384>:
  image->image.assembly = assembly;
  D.30825 = assembly->run;
  D.30826 = (int) D.30825;
  image->run = D.30826;
  D.30827 = assembly->save;
  D.30828 = (int) D.30827;
  image->save = D.30828;
  image->pe_kind = 1;
  image->machine = 332;
  D.30796 = &image->image;
  mono_profiler_module_loaded (D.30796, 0);
  D.30829 = image;
  return D.30829;
}


mono_blob_entry_equal (const char * str1, const char * str2)
{
  unsigned int D.30831;
  unsigned int D.30832;
  gboolean D.30835;
  unsigned int len.296;
  const char * end2.297;
  const char * end1.298;
  int D.30839;
  _Bool D.30840;
  int len;
  int len2;
  const char * end1;
  const char * end2;

  try
    {
      D.30831 = mono_metadata_decode_blob_size (str1, &end1);
      len = (int) D.30831;
      D.30832 = mono_metadata_decode_blob_size (str2, &end2);
      len2 = (int) D.30832;
      if (len != len2) goto <D.30833>; else goto <D.30834>;
      <D.30833>:
      D.30835 = 0;
      return D.30835;
      <D.30834>:
      len.296 = (unsigned int) len;
      end2.297 = end2;
      end1.298 = end1;
      D.30839 = memcmp (end1.298, end2.297, len.296);
      D.30840 = D.30839 == 0;
      D.30835 = (gboolean) D.30840;
      return D.30835;
    }
  finally
    {
      end1 = {CLOBBER};
      end2 = {CLOBBER};
    }
}


mono_blob_entry_hash (const char * str)
{
  const char * str.299;
  char D.30846;
  const char * str.300;
  unsigned int D.30848;
  unsigned int D.30849;
  unsigned int D.30850;
  int D.30851;
  guint len;
  guint h;
  const char * end;

  str.299 = str;
  len = mono_metadata_decode_blob_size (str.299, &str);
  if (len != 0) goto <D.30844>; else goto <D.30845>;
  <D.30844>:
  str.299 = str;
  end = str.299 + len;
  str.299 = str;
  D.30846 = *str.299;
  h = (guint) D.30846;
  str.299 = str;
  str.300 = str.299 + 1;
  str = str.300;
  goto <D.18387>;
  <D.18386>:
  D.30848 = h << 5;
  D.30849 = D.30848 - h;
  str.299 = str;
  D.30846 = *str.299;
  D.30850 = (unsigned int) D.30846;
  h = D.30849 + D.30850;
  str.299 = str;
  str.300 = str.299 + 1;
  str = str.300;
  <D.18387>:
  str.299 = str;
  if (str.299 < end) goto <D.18386>; else goto <D.18388>;
  <D.18388>:
  D.30851 = (int) h;
  return D.30851;
  <D.30845>:
  D.30851 = 0;
  return D.30851;
}


string_heap_init (struct MonoDynamicStream * sh)
{
  void * D.30853;
  struct GHashTable * D.30854;

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


register_assembly (struct MonoDomain * domain, struct MonoReflectionAssembly * res, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.30855;
  _Bool D.30858;
  long int D.30859;
  long int D.30860;
  struct MonoGHashTable * D.30863;
  struct MonoGHashTable * D.30866;
  struct MonoMemPool * D.30869;
  _Bool D.30872;
  long int D.30873;
  long int D.30874;
  void * D.30877;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

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

          D.30855 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.30855);
          if (ret != 0) goto <D.30856>; else goto <D.30857>;
          <D.30856>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.30857>:
          D.30858 = ret != 0;
          D.30859 = (long int) D.30858;
          D.30860 = __builtin_expect (D.30859, 0);
          if (D.30860 != 0) goto <D.30861>; else goto <D.30862>;
          <D.30861>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.30862>:
        }
        D.30863 = domain->refobject_hash;
        if (D.30863 == 0B) goto <D.30864>; else goto <D.30865>;
        <D.30864>:
        D.30866 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.30866;
        <D.30865>:
        D.30863 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.30863, &pe);
        if (_obj == 0B) goto <D.30867>; else goto <D.30868>;
        <D.30867>:
        {
          struct ReflectedEntry * e;

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

          D.30855 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.30855);
          if (ret != 0) goto <D.30870>; else goto <D.30871>;
          <D.30870>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.30871>:
          D.30872 = ret != 0;
          D.30873 = (long int) D.30872;
          D.30874 = __builtin_expect (D.30873, 0);
          if (D.30874 != 0) goto <D.30875>; else goto <D.30876>;
          <D.30875>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.30876>:
        }
        D.30877 = _obj;
        return D.30877;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


reflected_equal (const void * a, const void * b)
{
  gboolean D.30880;
  int iftmp.301;
  void * D.30884;
  void * D.30885;
  struct MonoClass * D.30887;
  struct MonoClass * D.30888;
  const struct ReflectedEntry * ea;
  const struct ReflectedEntry * eb;

  ea = a;
  eb = b;
  D.30884 = ea->item;
  D.30885 = eb->item;
  if (D.30884 == D.30885) goto <D.30886>; else goto <D.30882>;
  <D.30886>:
  D.30887 = ea->refclass;
  D.30888 = eb->refclass;
  if (D.30887 == D.30888) goto <D.30889>; else goto <D.30882>;
  <D.30889>:
  iftmp.301 = 1;
  goto <D.30883>;
  <D.30882>:
  iftmp.301 = 0;
  <D.30883>:
  D.30880 = iftmp.301;
  return D.30880;
}


reflected_hash (const void * a)
{
  guint D.30891;
  void * D.30892;
  const struct ReflectedEntry * ea;

  ea = a;
  D.30892 = ea->item;
  D.30891 = mono_aligned_addr_hash (D.30892);
  return D.30891;
}


mono_image_create_pefile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  int D.30894;
  unsigned int D.30895;
  int D.30896;
  unsigned int D.30897;
  struct MonoDynamicAssembly * D.30898;
  struct MonoImage * D.30899;
  int D.30900;
  struct MonoArray * D.30903;
  unsigned int D.30906;
  unsigned int i.302;
  char * D.30908;
  struct MonoArray * D.30909;
  unsigned int D.30912;
  char * D.30913;
  unsigned int nsections.303;
  unsigned int D.30919;
  unsigned int D.30920;
  unsigned int D.30923;
  unsigned int D.30924;
  unsigned int D.30925;
  char * D.30926;
  short unsigned int D.30927;
  short unsigned int D.30928;
  long int D.30929;
  unsigned int D.30930;
  unsigned int D.30931;
  unsigned int D.30935;
  _Bool D.30936;
  long int D.30937;
  long int D.30938;
  unsigned int D.30941;
  short unsigned int kind.304;
  unsigned int D.30946;
  unsigned int D.30947;
  unsigned int D.30948;
  unsigned int D.30949;
  unsigned int D.30950;
  unsigned int D.30951;
  unsigned int D.30952;
  unsigned int D.30953;
  char * D.30956;
  unsigned int D.30957;
  sizetype D.30958;
  char * D.30959;
  unsigned int D.30961;
  unsigned int D.30962;
  unsigned int D.30963;
  sizetype D.30964;
  unsigned int D.30965;
  sizetype D.30966;
  unsigned int D.30967;
  unsigned int D.30968;
  guchar * p.305;
  unsigned char D.30970;
  guchar * p.306;
  unsigned int D.30972;
  unsigned char D.30973;
  guchar * p.307;
  unsigned int D.30975;
  unsigned char D.30976;
  guchar * p.308;
  unsigned int D.30978;
  unsigned char D.30979;
  struct MonoReflectionMethod * D.30980;
  int D.20570;
  int iftmp.309;
  int D.20569;
  struct MonoVTable * D.30986;
  struct MonoClass * D.30987;
  const char[14] * D.30988;
  unsigned char D.30989;
  int D.30990;
  unsigned char D.30991;
  int D.30992;
  _Bool D.30993;
  _Bool D.30994;
  _Bool D.30995;
  const unsigned char * D.30998;
  unsigned char D.30999;
  int D.31000;
  const unsigned char * D.31001;
  unsigned char D.31002;
  int D.31003;
  _Bool D.31004;
  _Bool D.31005;
  const unsigned char * D.31008;
  unsigned char D.31009;
  int D.31010;
  const unsigned char * D.31011;
  unsigned char D.31012;
  int D.31013;
  _Bool D.31014;
  _Bool D.31015;
  const unsigned char * D.31018;
  unsigned char D.31019;
  int D.31020;
  const unsigned char * D.31021;
  unsigned char D.31022;
  int D.31023;
  const char * D.31025;
  struct MonoMethod * D.31029;
  struct GHashTable * D.31030;
  void * D.31031;
  unsigned int D.31032;
  unsigned int D.31034;
  unsigned int D.31035;
  unsigned int D.31036;
  unsigned int D.31037;
  const char[7] * D.31042;
  char[8] * D.31043;
  unsigned int D.31044;
  unsigned int D.31045;
  unsigned int D.31046;
  unsigned int D.31047;
  unsigned int D.31048;
  unsigned int D.31049;
  unsigned int D.31050;
  unsigned int D.31051;
  int D.31054;
  unsigned int D.31055;
  unsigned int D.31058;
  unsigned int D.31059;
  guchar * p.310;
  guchar * p.311;
  guchar * p.312;
  guchar * p.313;
  char * D.31064;
  char * D.31065;
  char * D.31066;
  char * D.31069;
  unsigned int D.31072;
  int file_offset.314;
  unsigned int D.31074;
  unsigned int D.31077;
  int D.31078;
  unsigned int D.31081;
  struct MonoDynamicStream * D.31082;
  struct MonoDynamicStream * D.31083;
  struct MonoDynamicStream * D.31084;
  struct MonoDynamicStream * D.31085;
  struct MonoDynamicStream * D.31086;
  struct GHashTable * D.31087;
  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.30894 = assemblyb->pe_kind;
      D.30895 = (unsigned int) D.30894;
      assembly->pe_kind = D.30895;
      D.30896 = assemblyb->machine;
      D.30897 = (unsigned int) D.30896;
      assembly->machine = D.30897;
      D.30898 = assemblyb->dynamic_assembly;
      D.30899 = D.30898->assembly.image;
      D.30894 = assemblyb->pe_kind;
      D.30895 = (unsigned int) D.30894;
      MEM[(struct MonoDynamicImage *)D.30899].pe_kind = D.30895;
      D.30898 = assemblyb->dynamic_assembly;
      D.30899 = D.30898->assembly.image;
      D.30896 = assemblyb->machine;
      D.30897 = (unsigned int) D.30896;
      MEM[(struct MonoDynamicImage *)D.30899].machine = D.30897;
      mono_image_build_metadata (mb);
      D.30900 = mb->is_main;
      if (D.30900 != 0) goto <D.30901>; else goto <D.30902>;
      <D.30901>:
      D.30903 = assemblyb->resources;
      if (D.30903 != 0B) goto <D.30904>; else goto <D.30905>;
      <D.30904>:
      {
        int len;

        D.30903 = assemblyb->resources;
        D.30906 = mono_array_length (D.30903);
        len = (int) D.30906;
        i = 0;
        goto <D.20550>;
        <D.20549>:
        i.302 = (unsigned int) i;
        D.30903 = assemblyb->resources;
        D.30908 = mono_array_addr_with_size (D.30903, 24, i.302);
        assembly_add_resource (mb, assembly, D.30908);
        i = i + 1;
        <D.20550>:
        if (i < len) goto <D.20549>; else goto <D.20551>;
        <D.20551>:
      }
      <D.30905>:
      <D.30902>:
      D.30909 = mb->resources;
      if (D.30909 != 0B) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      {
        int len;

        D.30909 = mb->resources;
        D.30912 = mono_array_length (D.30909);
        len = (int) D.30912;
        i = 0;
        goto <D.20554>;
        <D.20553>:
        i.302 = (unsigned int) i;
        D.30909 = mb->resources;
        D.30913 = mono_array_addr_with_size (D.30909, 24, i.302);
        assembly_add_resource (mb, assembly, D.30913);
        i = i + 1;
        <D.20554>:
        if (i < len) goto <D.20553>; else goto <D.20555>;
        <D.20555>:
      }
      <D.30911>:
      build_compressed_metadata (assembly);
      D.30900 = mb->is_main;
      if (D.30900 != 0) goto <D.30914>; else goto <D.30915>;
      <D.30914>:
      assembly_add_win32_resources (assembly, assemblyb);
      <D.30915>:
      nsections = calc_section_size (assembly);
      if (0 != 0) goto <D.30916>; else goto <D.30917>;
      <D.30916>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5690, "sizeof (MonoMSDOSHeader) == sizeof (msheader)");
      <D.30917>:
      mono_image_add_stream_data (pefile, &msheader, 128);
      header_start = mono_image_add_stream_zero (pefile, 248);
      nsections.303 = (unsigned int) nsections;
      D.30919 = nsections.303 * 40;
      section_start = mono_image_add_stream_zero (pefile, D.30919);
      nsections.303 = (unsigned int) nsections;
      D.30919 = nsections.303 * 40;
      file_offset = D.30919 + section_start;
      virtual_offset = 8192;
      image_size = 0;
      i = 0;
      goto <D.20558>;
      <D.20557>:
      D.30920 = assembly->sections[i].size;
      if (D.30920 == 0) goto <D.30921>; else goto <D.30922>;
      <D.30921>:
      // predicted unlikely by continue predictor.
      goto <D.20556>;
      <D.30922>:
      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.30920 = assembly->sections[i].size;
      file_offset = D.30920 + file_offset;
      D.30920 = assembly->sections[i].size;
      virtual_offset = D.30920 + virtual_offset;
      D.30920 = assembly->sections[i].size;
      D.30923 = D.30920 + 8191;
      D.30924 = D.30923 & 4294959104;
      image_size = D.30924 + image_size;
      <D.20556>:
      i = i + 1;
      <D.20558>:
      if (i <= 2) goto <D.20557>; else goto <D.20559>;
      <D.20559>:
      file_offset = file_offset + 511;
      file_offset = file_offset & 4294966784;
      nsections.303 = (unsigned int) nsections;
      D.30919 = nsections.303 * 40;
      D.30925 = D.30919 + section_start;
      image_size = D.30925 + image_size;
      msdos = pefile->data;
      msdos->pe_offset = 128;
      D.30926 = pefile->data;
      header = D.30926 + header_start;
      header->pesig[0] = 80;
      header->pesig[1] = 69;
      D.30896 = assemblyb->machine;
      D.30927 = (short unsigned int) D.30896;
      header->coff.coff_machine = D.30927;
      D.30928 = (short unsigned int) nsections;
      header->coff.coff_sections = D.30928;
      D.30929 = time (0B);
      D.30930 = (unsigned int) D.30929;
      header->coff.coff_time = D.30930;
      header->coff.coff_opt_header_size = 224;
      D.30931 = assemblyb->pekind;
      if (D.30931 == 1) goto <D.30932>; else goto <D.30933>;
      <D.30932>:
      header->coff.coff_attributes = 8462;
      goto <D.30934>;
      <D.30933>:
      header->coff.coff_attributes = 270;
      <D.30934>:
      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.30935 = assembly->sections[0].rva;
      D.30936 = D.30935 != 8192;
      D.30937 = (long int) D.30936;
      D.30938 = __builtin_expect (D.30937, 0);
      if (D.30938 != 0) goto <D.30939>; else goto <D.30940>;
      <D.30939>:
      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.30940>:
      D.30935 = assembly->sections[0].rva;
      header->pe.pe_rva_code_base = D.30935;
      D.30941 = assembly->sections[1].rva;
      header->pe.pe_rva_data_base = D.30941;
      D.30935 = assembly->sections[0].rva;
      header->pe.pe_rva_entry_point = D.30935;
      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.30931 = assemblyb->pekind;
        if (D.30931 == 3) goto <D.30942>; else goto <D.30943>;
        <D.30942>:
        kind = 2;
        goto <D.30944>;
        <D.30943>:
        kind = 3;
        <D.30944>:
        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.30946 = assembly->sections[1].size;
      header->datadir.pe_resource_table.size = D.30946;
      D.30941 = assembly->sections[1].rva;
      header->datadir.pe_resource_table.rva = D.30941;
      D.30947 = assembly->sections[2].size;
      header->datadir.pe_reloc_table.size = D.30947;
      D.30948 = assembly->sections[2].rva;
      header->datadir.pe_reloc_table.rva = D.30948;
      header->datadir.pe_cli_header.size = 72;
      D.30949 = assembly->text_rva;
      D.30950 = assembly->cli_header_offset;
      D.30951 = D.30949 + D.30950;
      header->datadir.pe_cli_header.rva = D.30951;
      header->datadir.pe_iat.size = 8;
      D.30949 = assembly->text_rva;
      D.30952 = assembly->iat_offset;
      D.30953 = D.30949 + D.30952;
      header->datadir.pe_iat.rva = D.30953;
      D.30931 = assemblyb->pekind;
      if (D.30931 == 1) goto <D.30954>; else goto <D.30955>;
      <D.30954>:
      D.30956 = assembly->code.data;
      D.30957 = assembly->imp_names_offset;
      D.30958 = D.30957 + 2;
      D.30959 = D.30956 + D.30958;
      memcpy (D.30959, "_CorDllMain", 12);
      goto <D.30960>;
      <D.30955>:
      D.30956 = assembly->code.data;
      D.30957 = assembly->imp_names_offset;
      D.30958 = D.30957 + 2;
      D.30959 = D.30956 + D.30958;
      memcpy (D.30959, "_CorExeMain", 12);
      <D.30960>:
      D.30956 = assembly->code.data;
      D.30952 = assembly->iat_offset;
      rva = D.30956 + D.30952;
      D.30949 = assembly->text_rva;
      D.30957 = assembly->imp_names_offset;
      D.30961 = D.30949 + D.30957;
      *rva = D.30961;
      header->datadir.pe_import_table.size = 79;
      D.30949 = assembly->text_rva;
      D.30962 = assembly->idt_offset;
      D.30963 = D.30949 + D.30962;
      header->datadir.pe_import_table.rva = D.30963;
      D.30956 = assembly->code.data;
      D.30962 = assembly->idt_offset;
      D.30964 = D.30962 + 12;
      rva = D.30956 + D.30964;
      D.30949 = assembly->text_rva;
      D.30957 = assembly->imp_names_offset;
      D.30961 = D.30949 + D.30957;
      D.30965 = D.30961 + 14;
      *rva = D.30965;
      D.30956 = assembly->code.data;
      D.30962 = assembly->idt_offset;
      D.30966 = D.30962 + 16;
      rva = D.30956 + D.30966;
      D.30949 = assembly->text_rva;
      D.30952 = assembly->iat_offset;
      D.30953 = D.30949 + D.30952;
      *rva = D.30953;
      D.30956 = assembly->code.data;
      D.30962 = assembly->idt_offset;
      rva = D.30956 + D.30962;
      D.30949 = assembly->text_rva;
      D.30967 = assembly->ilt_offset;
      D.30968 = D.30949 + D.30967;
      *rva = D.30968;
      D.30956 = assembly->code.data;
      D.30967 = assembly->ilt_offset;
      p = D.30956 + D.30967;
      D.30949 = assembly->text_rva;
      D.30957 = assembly->imp_names_offset;
      value = D.30949 + D.30957;
      p.305 = p;
      p = p.305 + 1;
      D.30970 = (unsigned char) value;
      *p.305 = D.30970;
      p.306 = p;
      p = p.306 + 1;
      D.30972 = value >> 8;
      D.30973 = (unsigned char) D.30972;
      *p.306 = D.30973;
      p.307 = p;
      p = p.307 + 1;
      D.30975 = value >> 16;
      D.30976 = (unsigned char) D.30975;
      *p.307 = D.30976;
      p.308 = p;
      p = p.308 + 1;
      D.30978 = value >> 24;
      D.30979 = (unsigned char) D.30978;
      *p.308 = D.30979;
      D.30956 = assembly->code.data;
      D.30950 = assembly->cli_header_offset;
      cli_header = D.30956 + D.30950;
      cli_header->ch_size = 72;
      cli_header->ch_runtime_major = 2;
      cli_header->ch_runtime_minor = 5;
      D.30894 = assemblyb->pe_kind;
      D.30895 = (unsigned int) D.30894;
      cli_header->ch_flags = D.30895;
      D.30980 = assemblyb->entry_point;
      if (D.30980 != 0B) goto <D.30981>; else goto <D.30982>;
      <D.30981>:
      {
        guint32 table_idx;

        table_idx = 0;
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.30980 = assemblyb->entry_point;
            D.30986 = D.30980->object.vtable;
            D.30987 = D.30986->klass;
            __s2 = D.30987->name;
            D.30988 = "MethodBuilder";
            D.30989 = MEM[(const unsigned char *)D.30988];
            D.30990 = (int) D.30989;
            D.30991 = *__s2;
            D.30992 = (int) D.30991;
            __result = D.30990 - D.30992;
            {
              D.30993 = __s2_len != 0;
              D.30994 = __result == 0;
              D.30995 = D.30993 & D.30994;
              if (D.30995 != 0) goto <D.30996>; else goto <D.30997>;
              <D.30996>:
              D.30998 = &MEM[(void *)"MethodBuilder" + 1B];
              D.30999 = *D.30998;
              D.31000 = (int) D.30999;
              D.31001 = __s2 + 1;
              D.31002 = *D.31001;
              D.31003 = (int) D.31002;
              __result = D.31000 - D.31003;
              D.31004 = __s2_len > 1;
              D.30994 = __result == 0;
              D.31005 = D.31004 & D.30994;
              if (D.31005 != 0) goto <D.31006>; else goto <D.31007>;
              <D.31006>:
              D.31008 = &MEM[(void *)"MethodBuilder" + 2B];
              D.31009 = *D.31008;
              D.31010 = (int) D.31009;
              D.31011 = __s2 + 2;
              D.31012 = *D.31011;
              D.31013 = (int) D.31012;
              __result = D.31010 - D.31013;
              D.31014 = __s2_len > 2;
              D.30994 = __result == 0;
              D.31015 = D.31014 & D.30994;
              if (D.31015 != 0) goto <D.31016>; else goto <D.31017>;
              <D.31016>:
              D.31018 = &MEM[(void *)"MethodBuilder" + 3B];
              D.31019 = *D.31018;
              D.31020 = (int) D.31019;
              D.31021 = __s2 + 3;
              D.31022 = *D.31021;
              D.31023 = (int) D.31022;
              __result = D.31020 - D.31023;
              <D.31017>:
              <D.31007>:
              <D.30997>:
            }
            D.20569 = __result;
          }
          iftmp.309 = -D.20569;
          goto <D.31024>;
          <D.30985>:
          D.30980 = assemblyb->entry_point;
          D.30986 = D.30980->object.vtable;
          D.30987 = D.30986->klass;
          D.31025 = D.30987->name;
          iftmp.309 = __builtin_strcmp (D.31025, "MethodBuilder");
          <D.31024>:
          D.20570 = iftmp.309;
        }
        if (D.20570 == 0) goto <D.31026>; else goto <D.31027>;
        <D.31026>:
        {
          struct MonoReflectionMethodBuilder * methodb;

          methodb = assemblyb->entry_point;
          table_idx = methodb->table_idx;
        }
        goto <D.31028>;
        <D.31027>:
        D.30980 = assemblyb->entry_point;
        D.31029 = D.30980->method;
        D.31030 = assembly->method_to_table_idx;
        D.31031 = monoeg_g_hash_table_lookup (D.31030, D.31029);
        table_idx = (guint32) D.31031;
        <D.31028>:
        D.31032 = table_idx | 100663296;
        cli_header->ch_entry_point = D.31032;
      }
      goto <D.31033>;
      <D.30982>:
      cli_header->ch_entry_point = 0;
      <D.31033>:
      D.30949 = assembly->text_rva;
      D.31034 = assembly->code.index;
      text_offset = D.30949 + D.31034;
      cli_header->ch_resources.rva = text_offset;
      D.31035 = assembly->resources.index;
      cli_header->ch_resources.size = D.31035;
      D.31035 = assembly->resources.index;
      text_offset = D.31035 + text_offset;
      cli_header->ch_metadata.rva = text_offset;
      D.31036 = assembly->meta_size;
      cli_header->ch_metadata.size = D.31036;
      D.31036 = assembly->meta_size;
      text_offset = D.31036 + text_offset;
      D.31037 = assembly->strong_name_size;
      if (D.31037 != 0) goto <D.31038>; else goto <D.31039>;
      <D.31038>:
      cli_header->ch_strong_name.rva = text_offset;
      D.31037 = assembly->strong_name_size;
      cli_header->ch_strong_name.size = D.31037;
      D.31037 = assembly->strong_name_size;
      text_offset = D.31037 + text_offset;
      <D.31039>:
      D.30926 = pefile->data;
      section = D.30926 + section_start;
      i = 0;
      goto <D.20575>;
      <D.20574>:
      {
        static const char section_names[3][7] = {".text", ".rsrc", ".reloc"};

        D.30920 = assembly->sections[i].size;
        if (D.30920 == 0) goto <D.31040>; else goto <D.31041>;
        <D.31040>:
        // predicted unlikely by continue predictor.
        goto <D.20573>;
        <D.31041>:
        D.31042 = &section_names[i];
        D.31043 = &section->st_name;
        strcpy (D.31043, D.31042);
        D.31044 = assembly->sections[i].rva;
        section->st_virtual_address = D.31044;
        D.30920 = assembly->sections[i].size;
        section->st_virtual_size = D.30920;
        D.31045 = section->st_virtual_size;
        D.31046 = D.31045 + 511;
        section->st_raw_data_size = D.31046;
        D.31047 = section->st_raw_data_size;
        D.31048 = D.31047 & 4294966784;
        section->st_raw_data_size = D.31048;
        D.31049 = assembly->sections[i].offset;
        section->st_raw_data_ptr = D.31049;
        D.31050 = assembly->sections[i].attrs;
        section->st_flags = D.31050;
        section = section + 40;
      }
      <D.20573>:
      i = i + 1;
      <D.20575>:
      if (i <= 2) goto <D.20574>; else goto <D.20576>;
      <D.20576>:
      D.31051 = pefile->index;
      D.30926 = pefile->data;
      checked_write_file (file, D.30926, D.31051);
      mono_dynamic_stream_reset (pefile);
      i = 0;
      goto <D.20591>;
      <D.20590>:
      D.30920 = assembly->sections[i].size;
      if (D.30920 == 0) goto <D.31052>; else goto <D.31053>;
      <D.31052>:
      // predicted unlikely by continue predictor.
      goto <D.20577>;
      <D.31053>:
      D.31049 = assembly->sections[i].offset;
      D.31054 = (int) D.31049;
      D.31055 = SetFilePointer (file, D.31054, 0B, 0);
      if (D.31055 == 4294967295) goto <D.31056>; else goto <D.31057>;
      <D.31056>:
      D.31058 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.31058);
      <D.20578>:
      goto <D.20578>;
      <D.31057>:
      switch (i) <default: <D.20589>, case 0: <D.20579>, case 1: <D.20588>, case 2: <D.20581>>
      <D.20579>:
      D.30956 = assembly->code.data;
      p = D.30956 + 2;
      D.30949 = assembly->text_rva;
      D.31059 = D.30949 + virtual_base;
      D.30952 = assembly->iat_offset;
      value = D.31059 + D.30952;
      p.310 = p;
      p = p.310 + 1;
      D.30970 = (unsigned char) value;
      *p.310 = D.30970;
      p.311 = p;
      p = p.311 + 1;
      D.30972 = value >> 8;
      D.30973 = (unsigned char) D.30972;
      *p.311 = D.30973;
      p.312 = p;
      p = p.312 + 1;
      D.30975 = value >> 16;
      D.30976 = (unsigned char) D.30975;
      *p.312 = D.30976;
      p.313 = p;
      p = p.313 + 1;
      D.30978 = value >> 24;
      D.30979 = (unsigned char) D.30978;
      *p.313 = D.30979;
      D.31034 = assembly->code.index;
      D.30956 = assembly->code.data;
      checked_write_file (file, D.30956, D.31034);
      D.31035 = assembly->resources.index;
      D.31064 = assembly->resources.data;
      checked_write_file (file, D.31064, D.31035);
      D.31036 = assembly->meta_size;
      D.31065 = assembly->image.raw_metadata;
      checked_write_file (file, D.31065, D.31036);
      D.31037 = assembly->strong_name_size;
      D.31066 = assembly->strong_name;
      checked_write_file (file, D.31066, D.31037);
      D.31065 = assembly->image.raw_metadata;
      monoeg_g_free (D.31065);
      goto <D.20580>;
      <D.20581>:
      {
        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.31067>; else goto <D.31068>;
            <D.31067>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5935, "sizeof (reloc) == 12");
            <D.31068>:
            D.30949 = assembly->text_rva;
            reloc.page_rva = D.30949;
            reloc.block_size = 12;
            reloc.type_and_offset = 12290;
            reloc.term = 0;
            checked_write_file (file, &reloc, 12);
            goto <D.20580>;
          }
        finally
          {
            reloc = {CLOBBER};
          }
      }
      <D.20588>:
      D.31069 = assembly->win32_res;
      if (D.31069 != 0B) goto <D.31070>; else goto <D.31071>;
      <D.31070>:
      D.31044 = assembly->sections[i].rva;
      D.31069 = assembly->win32_res;
      D.31069 = assembly->win32_res;
      fixup_resource_directory (D.31069, D.31069, D.31044);
      D.31072 = assembly->win32_res_size;
      D.31069 = assembly->win32_res;
      checked_write_file (file, D.31069, D.31072);
      <D.31071>:
      goto <D.20580>;
      <D.20589>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 5961);
      <D.20580>:
      <D.20577>:
      i = i + 1;
      <D.20591>:
      if (i <= 2) goto <D.20590>; else goto <D.20592>;
      <D.20592>:
      file_offset.314 = (int) file_offset;
      D.31074 = SetFilePointer (file, file_offset.314, 0B, 0);
      if (D.31074 == 4294967295) goto <D.31075>; else goto <D.31076>;
      <D.31075>:
      D.31077 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.31077);
      <D.20593>:
      goto <D.20593>;
      <D.31076>:
      D.31078 = SetEndOfFile (file);
      if (D.31078 == 0) goto <D.31079>; else goto <D.31080>;
      <D.31079>:
      D.31081 = GetLastError ();
      monoeg_g_log (0B, 4, "SetEndOfFile returned %d\n", D.31081);
      <D.20594>:
      goto <D.20594>;
      <D.31080>:
      D.31082 = &assembly->code;
      mono_dynamic_stream_reset (D.31082);
      D.31083 = &assembly->us;
      mono_dynamic_stream_reset (D.31083);
      D.31084 = &assembly->blob;
      mono_dynamic_stream_reset (D.31084);
      D.31085 = &assembly->guid;
      mono_dynamic_stream_reset (D.31085);
      D.31086 = &assembly->sheap;
      mono_dynamic_stream_reset (D.31086);
      D.31087 = assembly->blob_cache;
      monoeg_g_hash_table_foreach (D.31087, monoeg_g_free, 0B);
      D.31087 = assembly->blob_cache;
      monoeg_g_hash_table_destroy (D.31087);
      assembly->blob_cache = 0B;
    }
  finally
    {
      pefile_stream = {CLOBBER};
    }
}


assembly_add_resource (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc)
{
  struct MonoString * D.31090;
  unsigned int D.31093;
  unsigned int D.31094;
  guint32 * D.31095;
  unsigned int D.31096;
  unsigned int D.31097;
  guint32 * D.31098;
  struct MonoDynamicStream * D.31099;
  unsigned int D.31100;
  char * b.315;
  guint32 * D.31102;
  int b.316;
  int blob_size.317;
  int D.31105;
  unsigned int D.31106;
  struct MonoDynamicStream * D.31107;
  unsigned int D.31108;
  unsigned int idx.318;
  unsigned int D.31110;
  struct MonoArray * D.31112;
  char D.31116;
  unsigned int D.31117;
  char D.31118;
  unsigned int D.31119;
  char D.31120;
  unsigned int D.31121;
  char D.31122;
  struct MonoDynamicStream * D.31123;
  unsigned int D.31124;
  int D.31125;
  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.31090 = rsrc->filename;
      if (D.31090 != 0B) goto <D.31091>; else goto <D.31092>;
      <D.31091>:
      D.31090 = rsrc->filename;
      name = mono_string_to_utf8 (D.31090);
      sname = monoeg_g_path_get_basename (name);
      table = &assembly->tables[38];
      D.31093 = table->rows;
      D.31094 = D.31093 + 1;
      table->rows = D.31094;
      D.31093 = table->rows;
      alloc_table (table, D.31093);
      D.31095 = table->values;
      D.31096 = table->next_idx;
      D.31097 = D.31096 * 12;
      values = D.31095 + D.31097;
      *values = 1;
      D.31098 = values + 4;
      D.31099 = &assembly->sheap;
      D.31100 = string_heap_insert (D.31099, sname);
      *D.31098 = D.31100;
      monoeg_g_free (sname);
      mono_sha1_get_digest_from_file (name, &hash);
      b.315 = b;
      mono_metadata_encode_value (20, b.315, &b);
      D.31102 = values + 8;
      b.315 = b;
      b.316 = (int) b.315;
      blob_size.317 = (int) &blob_size;
      D.31105 = b.316 - blob_size.317;
      D.31106 = (unsigned int) D.31105;
      D.31107 = &assembly->blob;
      D.31108 = mono_image_add_stream_data (D.31107, &blob_size, D.31106);
      *D.31102 = D.31108;
      D.31107 = &assembly->blob;
      mono_image_add_stream_data (D.31107, &hash, 20);
      monoeg_g_free (name);
      D.31096 = table->next_idx;
      idx.318 = D.31096;
      D.31110 = idx.318 + 1;
      table->next_idx = D.31110;
      idx = idx.318;
      rsrc->offset = 0;
      idx = idx << 2;
      goto <D.31111>;
      <D.31092>:
      {
        char sizebuf[4];
        char * data;
        guint len;

        try
          {
            D.31112 = rsrc->data;
            if (D.31112 != 0B) goto <D.31113>; else goto <D.31114>;
            <D.31113>:
            D.31112 = rsrc->data;
            data = mono_array_addr_with_size (D.31112, 1, 0);
            D.31112 = rsrc->data;
            len = mono_array_length (D.31112);
            goto <D.31115>;
            <D.31114>:
            data = 0B;
            len = 0;
            <D.31115>:
            offset = len;
            D.31116 = (char) offset;
            sizebuf[0] = D.31116;
            D.31117 = offset >> 8;
            D.31118 = (char) D.31117;
            sizebuf[1] = D.31118;
            D.31119 = offset >> 16;
            D.31120 = (char) D.31119;
            sizebuf[2] = D.31120;
            D.31121 = offset >> 24;
            D.31122 = (char) D.31121;
            sizebuf[3] = D.31122;
            D.31123 = &assembly->resources;
            D.31124 = mono_image_add_stream_data (D.31123, &sizebuf, 4);
            rsrc->offset = D.31124;
            D.31123 = &assembly->resources;
            mono_image_add_stream_data (D.31123, data, len);
            D.31125 = mb->is_main;
            if (D.31125 == 0) goto <D.31126>; else goto <D.31127>;
            <D.31126>:
            return;
            <D.31127>:
            idx = 0;
          }
        finally
          {
            sizebuf = {CLOBBER};
          }
      }
      <D.31111>:
      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.31133;
  unsigned int D.31134;
  void * * D.31135;
  unsigned int i.319;
  unsigned int D.31137;
  void * * D.31138;
  unsigned int i.320;
  struct MonoDynamicStream * D.31140;
  struct MonoDynamicStream * D.31141;
  struct MonoDynamicStream * D.31142;
  struct MonoDynamicStream * D.31143;
  struct MonoDynamicStream * D.31144;
  unsigned int D.31145;
  _Bool D.31146;
  unsigned int D.31147;
  _Bool D.31148;
  unsigned int D.31149;
  _Bool D.31150;
  unsigned int D.31151;
  unsigned int D.31152;
  <unnamed-unsigned:24> D.31153;
  <unnamed-unsigned:24> D.31154;
  long long unsigned int D.31157;
  guint32 * D.31158;
  int D.31159;
  unsigned char D.31160;
  unsigned char D.31161;
  int D.31162;
  int D.31163;
  int D.31164;
  unsigned int D.31165;
  unsigned int D.31166;
  void * D.31167;
  unsigned char * p.321;
  unsigned char * p.322;
  unsigned char * p.323;
  unsigned char * p.324;
  guint16 * int16val.325;
  short int D.31173;
  short unsigned int D.31174;
  short int D.31175;
  short unsigned int D.31176;
  char * D.31177;
  unsigned int D.31178;
  unsigned int D.31179;
  unsigned int D.31180;
  unsigned int D.31181;
  unsigned int D.31182;
  int p.326;
  char * D.31184;
  int D.31185;
  int D.31186;
  unsigned int D.31187;
  unsigned int D.31190;
  guint16 * int16val.327;
  int D.31192;
  struct MonoDynamicStream * D.31193;
  guint32 * int32val.328;
  unsigned int D.31195;
  const char * D.31196;
  unsigned int D.31197;
  sizetype D.31198;
  unsigned int D.31199;
  unsigned int D.31202;
  unsigned int D.31203;
  unsigned int D.31204;
  _Bool D.31205;
  long int D.31206;
  long int D.31207;
  unsigned char * p.329;
  unsigned char * p.330;
  unsigned char D.31212;
  unsigned char D.31213;
  unsigned char D.31216;
  unsigned char D.31217;
  unsigned char D.31218;
  unsigned char D.31221;
  unsigned char D.31222;
  unsigned char D.31225;
  unsigned char * p.331;
  guint64 * int64val.332;
  guint64 * int64val.333;
  long long unsigned int D.31229;
  guint32 * int32val.334;
  unsigned int D.31233;
  unsigned int D.31234;
  guint32 * D.31237;
  void * D.31238;
  void * D.31241;
  void * D.31246;
  unsigned char D.31255;
  unsigned int D.31256;
  unsigned int D.31257;
  int D.31260;
  guint32 * D.31261;
  int D.31262;
  unsigned int D.31263;
  unsigned int D.31264;
  int D.31265;
  unsigned int D.31266;
  unsigned int D.31267;
  unsigned int D.31268;
  unsigned char * p.335;
  unsigned int col.336;
  unsigned int D.31271;
  guint32 * D.31272;
  unsigned int D.31273;
  unsigned char D.31274;
  unsigned char * p.337;
  unsigned char * p.338;
  unsigned int D.31277;
  unsigned char D.31278;
  unsigned char * p.339;
  unsigned char * p.340;
  unsigned char * p.341;
  unsigned int D.31282;
  unsigned char D.31283;
  unsigned char * p.342;
  unsigned int D.31285;
  unsigned char D.31286;
  const char * D.31287;
  int D.31288;
  int D.31289;
  _Bool D.31290;
  long int D.31291;
  long int D.31292;
  unsigned int D.31295;
  unsigned int D.31296;
  _Bool D.31297;
  long int D.31298;
  long int D.31299;
  char * D.31302;
  unsigned int D.31303;
  char * D.31304;
  char * D.31305;
  unsigned int D.31306;
  char * D.31307;
  char * D.31308;
  unsigned int D.31309;
  char * D.31310;
  char * D.31311;
  char * D.31312;
  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.31133 = assembly->gen_params;
      D.31134 = D.31133->len;
      D.31133 = assembly->gen_params;
      D.31135 = D.31133->pdata;
      qsort (D.31135, D.31134, 4, compare_genericparam);
      i = 0;
      goto <D.19643>;
      <D.19642>:
      {
        struct GenericParamTableEntry * entry;

        D.31133 = assembly->gen_params;
        D.31135 = D.31133->pdata;
        i.319 = (unsigned int) i;
        D.31137 = i.319 * 4;
        D.31138 = D.31135 + D.31137;
        entry = *D.31138;
        write_generic_param_entry (assembly, entry);
      }
      i = i + 1;
      <D.19643>:
      i.320 = (unsigned int) i;
      D.31133 = assembly->gen_params;
      D.31134 = D.31133->len;
      if (i.320 < D.31134) goto <D.19642>; else goto <D.19644>;
      <D.19644>:
      stream_desc[0].name = "#~";
      D.31140 = &assembly->tstream;
      stream_desc[0].stream = D.31140;
      stream_desc[1].name = "#Strings";
      D.31141 = &assembly->sheap;
      stream_desc[1].stream = D.31141;
      stream_desc[2].name = "#US";
      D.31142 = &assembly->us;
      stream_desc[2].stream = D.31142;
      stream_desc[3].name = "#Blob";
      D.31143 = &assembly->blob;
      stream_desc[3].stream = D.31143;
      stream_desc[4].name = "#GUID";
      D.31144 = &assembly->guid;
      stream_desc[4].stream = D.31144;
      sorted_mask = 6597925534208;
      meta = &assembly->image;
      D.31143 = &assembly->blob;
      pad_heap (D.31143);
      D.31144 = &assembly->guid;
      pad_heap (D.31144);
      D.31141 = &assembly->sheap;
      pad_heap (D.31141);
      D.31142 = &assembly->us;
      pad_heap (D.31142);
      D.31145 = assembly->blob.index;
      D.31146 = D.31145 > 65535;
      meta->idx_blob_wide = D.31146;
      D.31147 = assembly->guid.index;
      D.31148 = D.31147 > 65535;
      meta->idx_guid_wide = D.31148;
      D.31149 = assembly->sheap.index;
      D.31150 = D.31149 > 65535;
      meta->idx_string_wide = D.31150;
      D.31145 = assembly->blob.index;
      meta_size = D.31145 + meta_size;
      D.31147 = assembly->guid.index;
      meta_size = D.31147 + meta_size;
      D.31149 = assembly->sheap.index;
      meta_size = D.31149 + meta_size;
      D.31151 = assembly->us.index;
      meta_size = D.31151 + meta_size;
      i = 0;
      goto <D.19646>;
      <D.19645>:
      D.31152 = assembly->tables[i].rows;
      D.31153 = (<unnamed-unsigned:24>) D.31152;
      meta->tables[i].rows = D.31153;
      i = i + 1;
      <D.19646>:
      if (i <= 44) goto <D.19645>; else goto <D.19647>;
      <D.19647>:
      i = 0;
      goto <D.19650>;
      <D.19649>:
      D.31154 = meta->tables[i].rows;
      if (D.31154 == 0) goto <D.31155>; else goto <D.31156>;
      <D.31155>:
      // predicted unlikely by continue predictor.
      goto <D.19648>;
      <D.31156>:
      D.31157 = 1 << i;
      valid_mask = D.31157 | valid_mask;
      ntables = ntables + 1;
      D.31158 = &meta->tables[i].size_bitfield;
      D.31159 = mono_metadata_compute_size (meta, i, D.31158);
      D.31160 = (unsigned char) D.31159;
      meta->tables[i].row_size = D.31160;
      D.31161 = meta->tables[i].row_size;
      D.31162 = (int) D.31161;
      D.31154 = meta->tables[i].rows;
      D.31163 = (int) D.31154;
      D.31164 = D.31162 * D.31163;
      D.31165 = (unsigned int) D.31164;
      heapt_size = D.31165 + heapt_size;
      <D.19648>:
      i = i + 1;
      <D.19650>:
      if (i <= 44) goto <D.19649>; else goto <D.19651>;
      <D.19651>:
      heapt_size = heapt_size + 24;
      D.31166 = ntables * 4;
      heapt_size = D.31166 + heapt_size;
      heapt_size = heapt_size + 3;
      heapt_size = heapt_size & 4294967292;
      meta_size = meta_size + heapt_size;
      D.31167 = monoeg_malloc0 (meta_size);
      meta->raw_metadata = D.31167;
      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.31173 = meta->md_version_major;
      D.31174 = (short unsigned int) D.31173;
      *int16val.325 = D.31174;
      D.31175 = meta->md_version_minor;
      D.31176 = (short unsigned int) D.31175;
      *int16val = D.31176;
      p = p + 8;
      int32val = p;
      D.31177 = meta->version;
      D.31178 = strlen (D.31177);
      D.31179 = D.31178 + 3;
      D.31180 = D.31179 & 4294967292;
      *int32val = D.31180;
      p = p + 4;
      D.31177 = meta->version;
      D.31181 = strlen (D.31177);
      D.31177 = meta->version;
      memcpy (p, D.31177, D.31181);
      D.31182 = *int32val;
      p = p + D.31182;
      {
        guint32 __diff;

        p.326 = (int) p;
        D.31184 = meta->raw_metadata;
        D.31185 = (int) D.31184;
        D.31186 = p.326 - D.31185;
        __diff = (guint32) D.31186;
        D.31187 = __diff & 3;
        if (D.31187 != 0) goto <D.31188>; else goto <D.31189>;
        <D.31188>:
        D.31187 = __diff & 3;
        D.31190 = 4 - D.31187;
        p = p + D.31190;
        <D.31189>:
      }
      int16val = p;
      int16val.327 = int16val;
      int16val = int16val.327 + 2;
      *int16val.327 = 0;
      *int16val = 5;
      p = p + 4;
      p.326 = (int) p;
      D.31184 = meta->raw_metadata;
      D.31185 = (int) D.31184;
      D.31186 = p.326 - D.31185;
      D.31192 = D.31186 + 80;
      table_offset = (guint32) D.31192;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      assembly->tstream.index = heapt_size;
      i = 0;
      goto <D.19655>;
      <D.19654>:
      int32val = p;
      D.31193 = stream_desc[i].stream;
      D.31193->offset = table_offset;
      int32val.328 = int32val;
      int32val = int32val.328 + 4;
      *int32val.328 = table_offset;
      D.31193 = stream_desc[i].stream;
      D.31195 = D.31193->index;
      *int32val = D.31195;
      D.31182 = *int32val;
      table_offset = D.31182 + table_offset;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      p = p + 8;
      D.31196 = stream_desc[i].name;
      strcpy (p, D.31196);
      D.31196 = stream_desc[i].name;
      D.31197 = strlen (D.31196);
      D.31198 = D.31197 + 1;
      p = p + D.31198;
      {
        guint32 __diff;

        p.326 = (int) p;
        D.31184 = meta->raw_metadata;
        D.31185 = (int) D.31184;
        D.31186 = p.326 - D.31185;
        __diff = (guint32) D.31186;
        D.31199 = __diff & 3;
        if (D.31199 != 0) goto <D.31200>; else goto <D.31201>;
        <D.31200>:
        D.31199 = __diff & 3;
        D.31202 = 4 - D.31199;
        p = p + D.31202;
        <D.31201>:
      }
      i = i + 1;
      <D.19655>:
      if (i <= 4) goto <D.19654>; else goto <D.19656>;
      <D.19656>:
      p.326 = (int) p;
      D.31184 = meta->raw_metadata;
      D.31185 = (int) D.31184;
      D.31186 = p.326 - D.31185;
      D.31203 = (unsigned int) D.31186;
      D.31204 = assembly->tstream.offset;
      D.31205 = D.31203 >= D.31204;
      D.31206 = (long int) D.31205;
      D.31207 = __builtin_expect (D.31206, 0);
      if (D.31207 != 0) goto <D.31208>; else goto <D.31209>;
      <D.31208>:
      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.31209>:
      D.31184 = meta->raw_metadata;
      D.31204 = assembly->tstream.offset;
      p = D.31184 + D.31204;
      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.31212 = BIT_FIELD_REF <*meta, 8, 136>;
      D.31213 = D.31212 & 1;
      if (D.31213 != 0) goto <D.31214>; else goto <D.31215>;
      <D.31214>:
      D.31216 = *p;
      D.31217 = D.31216 | 1;
      *p = D.31217;
      <D.31215>:
      D.31212 = BIT_FIELD_REF <*meta, 8, 136>;
      D.31218 = D.31212 & 2;
      if (D.31218 != 0) goto <D.31219>; else goto <D.31220>;
      <D.31219>:
      D.31216 = *p;
      D.31221 = D.31216 | 2;
      *p = D.31221;
      <D.31220>:
      D.31212 = BIT_FIELD_REF <*meta, 8, 136>;
      D.31222 = D.31212 & 4;
      if (D.31222 != 0) goto <D.31223>; else goto <D.31224>;
      <D.31223>:
      D.31216 = *p;
      D.31225 = D.31216 | 4;
      *p = D.31225;
      <D.31224>:
      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.31229 = valid_mask & sorted_mask;
      *int64val.333 = D.31229;
      p = p + 16;
      int32val = p;
      i = 0;
      goto <D.19659>;
      <D.19658>:
      D.31154 = meta->tables[i].rows;
      if (D.31154 == 0) goto <D.31230>; else goto <D.31231>;
      <D.31230>:
      // predicted unlikely by continue predictor.
      goto <D.19657>;
      <D.31231>:
      int32val.334 = int32val;
      int32val = int32val.334 + 4;
      D.31154 = meta->tables[i].rows;
      D.31233 = (unsigned int) D.31154;
      *int32val.334 = D.31233;
      <D.19657>:
      i = i + 1;
      <D.19659>:
      if (i <= 44) goto <D.19658>; else goto <D.19660>;
      <D.19660>:
      p = int32val;
      table = &assembly->tables[11];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31235>; else goto <D.31236>;
      <D.31235>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31238 = D.31237 + 16;
      qsort (D.31238, D.31234, 16, compare_constants);
      <D.31236>:
      table = &assembly->tables[24];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31239>; else goto <D.31240>;
      <D.31239>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31241 = D.31237 + 12;
      qsort (D.31241, D.31234, 12, compare_semantics);
      <D.31240>:
      table = &assembly->tables[12];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31242>; else goto <D.31243>;
      <D.31242>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31241 = D.31237 + 12;
      qsort (D.31241, D.31234, 12, compare_custom_attrs);
      <D.31243>:
      table = &assembly->tables[13];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31244>; else goto <D.31245>;
      <D.31244>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31246 = D.31237 + 8;
      qsort (D.31246, D.31234, 8, compare_field_marshal);
      <D.31245>:
      table = &assembly->tables[41];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31247>; else goto <D.31248>;
      <D.31247>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31246 = D.31237 + 8;
      qsort (D.31246, D.31234, 8, compare_nested);
      <D.31248>:
      table = &assembly->tables[14];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31249>; else goto <D.31250>;
      <D.31249>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31241 = D.31237 + 12;
      qsort (D.31241, D.31234, 12, compare_declsecurity_attrs);
      <D.31250>:
      table = &assembly->tables[9];
      D.31234 = table->rows;
      if (D.31234 != 0) goto <D.31251>; else goto <D.31252>;
      <D.31251>:
      D.31234 = table->rows;
      D.31237 = table->values;
      D.31246 = D.31237 + 8;
      qsort (D.31246, D.31234, 8, compare_interface_impl);
      <D.31252>:
      i = 0;
      goto <D.19679>;
      <D.19678>:
      {
        int row;
        int col;
        guint32 * values;
        guint32 bitfield;

        bitfield = meta->tables[i].size_bitfield;
        D.31154 = meta->tables[i].rows;
        if (D.31154 == 0) goto <D.31253>; else goto <D.31254>;
        <D.31253>:
        // predicted unlikely by continue predictor.
        goto <D.19665>;
        <D.31254>:
        D.31255 = assembly->tables[i].columns;
        D.31256 = (unsigned int) D.31255;
        D.31257 = bitfield >> 24;
        if (D.31256 != D.31257) goto <D.31258>; else goto <D.31259>;
        <D.31258>:
        D.31257 = bitfield >> 24;
        D.31255 = assembly->tables[i].columns;
        D.31260 = (int) D.31255;
        monoeg_g_log (0B, 4, "col count mismatch in %d: %d %d", i, D.31260, D.31257);
        <D.19666>:
        goto <D.19666>;
        <D.31259>:
        meta->tables[i].base = p;
        row = 1;
        goto <D.19676>;
        <D.19675>:
        D.31261 = assembly->tables[i].values;
        D.31255 = assembly->tables[i].columns;
        D.31260 = (int) D.31255;
        D.31262 = D.31260 * row;
        D.31263 = (unsigned int) D.31262;
        D.31264 = D.31263 * 4;
        values = D.31261 + D.31264;
        col = 0;
        goto <D.19673>;
        <D.19672>:
        D.31265 = col * 2;
        D.31266 = bitfield >> D.31265;
        D.31267 = D.31266 & 3;
        D.31268 = D.31267 + 1;
        switch (D.31268) <default: <D.19671>, case 1: <D.19667>, case 2: <D.19669>, case 4: <D.19670>>
        <D.19667>:
        p.335 = p;
        p = p.335 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31274 = (unsigned char) D.31273;
        *p.335 = D.31274;
        goto <D.19668>;
        <D.19669>:
        p.337 = p;
        p = p.337 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31274 = (unsigned char) D.31273;
        *p.337 = D.31274;
        p.338 = p;
        p = p.338 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31277 = D.31273 >> 8;
        D.31278 = (unsigned char) D.31277;
        *p.338 = D.31278;
        goto <D.19668>;
        <D.19670>:
        p.339 = p;
        p = p.339 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31274 = (unsigned char) D.31273;
        *p.339 = D.31274;
        p.340 = p;
        p = p.340 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31277 = D.31273 >> 8;
        D.31278 = (unsigned char) D.31277;
        *p.340 = D.31278;
        p.341 = p;
        p = p.341 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31282 = D.31273 >> 16;
        D.31283 = (unsigned char) D.31282;
        *p.341 = D.31283;
        p.342 = p;
        p = p.342 + 1;
        col.336 = (unsigned int) col;
        D.31271 = col.336 * 4;
        D.31272 = values + D.31271;
        D.31273 = *D.31272;
        D.31285 = D.31273 >> 24;
        D.31286 = (unsigned char) D.31285;
        *p.342 = D.31286;
        goto <D.19668>;
        <D.19671>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4187);
        <D.19668>:
        col = col + 1;
        <D.19673>:
        D.31255 = assembly->tables[i].columns;
        D.31260 = (int) D.31255;
        if (D.31260 > col) goto <D.19672>; else goto <D.19674>;
        <D.19674>:
        row = row + 1;
        <D.19676>:
        D.31154 = meta->tables[i].rows;
        D.31163 = (int) D.31154;
        if (D.31163 >= row) goto <D.19675>; else goto <D.19677>;
        <D.19677>:
        p.326 = (int) p;
        D.31287 = meta->tables[i].base;
        D.31288 = (int) D.31287;
        D.31289 = p.326 - D.31288;
        D.31154 = meta->tables[i].rows;
        D.31163 = (int) D.31154;
        D.31161 = meta->tables[i].row_size;
        D.31162 = (int) D.31161;
        D.31164 = D.31163 * D.31162;
        D.31290 = D.31289 != D.31164;
        D.31291 = (long int) D.31290;
        D.31292 = __builtin_expect (D.31291, 0);
        if (D.31292 != 0) goto <D.31293>; else goto <D.31294>;
        <D.31293>:
        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.31294>:
      }
      <D.19665>:
      i = i + 1;
      <D.19679>:
      if (i <= 44) goto <D.19678>; else goto <D.19680>;
      <D.19680>:
      D.31295 = assembly->guid.offset;
      D.31147 = assembly->guid.index;
      D.31296 = D.31295 + D.31147;
      D.31297 = D.31296 >= meta_size;
      D.31298 = (long int) D.31297;
      D.31299 = __builtin_expect (D.31298, 0);
      if (D.31299 != 0) goto <D.31300>; else goto <D.31301>;
      <D.31300>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4194, "assembly->guid.offset + assembly->guid.index < meta_size");
      <D.31301>:
      D.31149 = assembly->sheap.index;
      D.31302 = assembly->sheap.data;
      D.31184 = meta->raw_metadata;
      D.31303 = assembly->sheap.offset;
      D.31304 = D.31184 + D.31303;
      memcpy (D.31304, D.31302, D.31149);
      D.31151 = assembly->us.index;
      D.31305 = assembly->us.data;
      D.31184 = meta->raw_metadata;
      D.31306 = assembly->us.offset;
      D.31307 = D.31184 + D.31306;
      memcpy (D.31307, D.31305, D.31151);
      D.31145 = assembly->blob.index;
      D.31308 = assembly->blob.data;
      D.31184 = meta->raw_metadata;
      D.31309 = assembly->blob.offset;
      D.31310 = D.31184 + D.31309;
      memcpy (D.31310, D.31308, D.31145);
      D.31147 = assembly->guid.index;
      D.31311 = assembly->guid.data;
      D.31184 = meta->raw_metadata;
      D.31295 = assembly->guid.offset;
      D.31312 = D.31184 + D.31295;
      memcpy (D.31312, D.31311, D.31147);
      D.31295 = assembly->guid.offset;
      D.31147 = assembly->guid.index;
      D.31296 = D.31295 + D.31147;
      assembly->meta_size = D.31296;
    }
  finally
    {
      stream_desc = {CLOBBER};
    }
}


compare_interface_impl (const void * a, const void * b)
{
  unsigned int D.31313;
  unsigned int D.31314;
  unsigned int D.31315;
  int D.31318;
  const guint32 * D.31319;
  unsigned int D.31320;
  const guint32 * D.31321;
  unsigned int D.31322;
  unsigned int D.31323;
  const guint32 * a_values;
  const guint32 * b_values;
  int klass;

  a_values = a;
  b_values = b;
  D.31313 = *a_values;
  D.31314 = *b_values;
  D.31315 = D.31313 - D.31314;
  klass = (int) D.31315;
  if (klass != 0) goto <D.31316>; else goto <D.31317>;
  <D.31316>:
  D.31318 = klass;
  return D.31318;
  <D.31317>:
  D.31319 = a_values + 4;
  D.31320 = *D.31319;
  D.31321 = b_values + 4;
  D.31322 = *D.31321;
  D.31323 = D.31320 - D.31322;
  D.31318 = (int) D.31323;
  return D.31318;
}


compare_declsecurity_attrs (const void * a, const void * b)
{
  int D.31325;
  const guint32 * D.31326;
  unsigned int D.31327;
  const guint32 * D.31328;
  unsigned int D.31329;
  unsigned int D.31330;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31326 = a_values + 4;
  D.31327 = *D.31326;
  D.31328 = b_values + 4;
  D.31329 = *D.31328;
  D.31330 = D.31327 - D.31329;
  D.31325 = (int) D.31330;
  return D.31325;
}


compare_nested (const void * a, const void * b)
{
  int D.31332;
  unsigned int D.31333;
  unsigned int D.31334;
  unsigned int D.31335;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31333 = *a_values;
  D.31334 = *b_values;
  D.31335 = D.31333 - D.31334;
  D.31332 = (int) D.31335;
  return D.31332;
}


compare_field_marshal (const void * a, const void * b)
{
  int D.31337;
  unsigned int D.31338;
  unsigned int D.31339;
  unsigned int D.31340;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31338 = *a_values;
  D.31339 = *b_values;
  D.31340 = D.31338 - D.31339;
  D.31337 = (int) D.31340;
  return D.31337;
}


compare_custom_attrs (const void * a, const void * b)
{
  int D.31342;
  unsigned int D.31343;
  unsigned int D.31344;
  unsigned int D.31345;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31343 = *a_values;
  D.31344 = *b_values;
  D.31345 = D.31343 - D.31344;
  D.31342 = (int) D.31345;
  return D.31342;
}


compare_semantics (const void * a, const void * b)
{
  const guint32 * D.31347;
  unsigned int D.31348;
  const guint32 * D.31349;
  unsigned int D.31350;
  unsigned int D.31351;
  int D.31354;
  unsigned int D.31355;
  unsigned int D.31356;
  unsigned int D.31357;
  const guint32 * a_values;
  const guint32 * b_values;
  int assoc;

  a_values = a;
  b_values = b;
  D.31347 = a_values + 8;
  D.31348 = *D.31347;
  D.31349 = b_values + 8;
  D.31350 = *D.31349;
  D.31351 = D.31348 - D.31350;
  assoc = (int) D.31351;
  if (assoc != 0) goto <D.31352>; else goto <D.31353>;
  <D.31352>:
  D.31354 = assoc;
  return D.31354;
  <D.31353>:
  D.31355 = *a_values;
  D.31356 = *b_values;
  D.31357 = D.31355 - D.31356;
  D.31354 = (int) D.31357;
  return D.31354;
}


compare_constants (const void * a, const void * b)
{
  int D.31359;
  const guint32 * D.31360;
  unsigned int D.31361;
  const guint32 * D.31362;
  unsigned int D.31363;
  unsigned int D.31364;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31360 = a_values + 8;
  D.31361 = *D.31360;
  D.31362 = b_values + 8;
  D.31363 = *D.31362;
  D.31364 = D.31361 - D.31363;
  D.31359 = (int) D.31364;
  return D.31359;
}


compare_genericparam (const void * a, const void * b)
{
  const struct GenericParamTableEntry * D.31366;
  unsigned int D.31367;
  const struct GenericParamTableEntry * D.31368;
  unsigned int D.31369;
  int D.31372;
  struct MonoReflectionGenericParam * D.31373;
  struct MonoType * D.31374;
  struct MonoGenericParam * D.31375;
  short unsigned int D.31376;
  int D.31377;
  struct MonoReflectionGenericParam * D.31378;
  struct MonoType * D.31379;
  struct MonoGenericParam * D.31380;
  short unsigned int D.31381;
  int D.31382;
  unsigned int D.31383;
  const struct GenericParamTableEntry * * a_entry;
  const struct GenericParamTableEntry * * b_entry;

  a_entry = a;
  b_entry = b;
  D.31366 = *b_entry;
  D.31367 = D.31366->owner;
  D.31368 = *a_entry;
  D.31369 = D.31368->owner;
  if (D.31367 == D.31369) goto <D.31370>; else goto <D.31371>;
  <D.31370>:
  D.31368 = *a_entry;
  D.31373 = D.31368->gparam;
  D.31374 = mono_reflection_type_get_handle (D.31373);
  D.31375 = D.31374->data.generic_param;
  D.31376 = D.31375->num;
  D.31377 = (int) D.31376;
  D.31366 = *b_entry;
  D.31378 = D.31366->gparam;
  D.31379 = mono_reflection_type_get_handle (D.31378);
  D.31380 = D.31379->data.generic_param;
  D.31381 = D.31380->num;
  D.31382 = (int) D.31381;
  D.31372 = D.31377 - D.31382;
  return D.31372;
  <D.31371>:
  D.31368 = *a_entry;
  D.31369 = D.31368->owner;
  D.31366 = *b_entry;
  D.31367 = D.31366->owner;
  D.31383 = D.31369 - D.31367;
  D.31372 = (int) D.31383;
  return D.31372;
}


write_generic_param_entry (struct MonoDynamicImage * assembly, struct GenericParamTableEntry * entry)
{
  unsigned int D.31385;
  unsigned int table_idx.343;
  unsigned int D.31387;
  guint32 * D.31388;
  unsigned int D.31389;
  struct MonoReflectionGenericParam * D.31390;
  struct MonoType * D.31391;
  guint32 * D.31392;
  unsigned int D.31393;
  guint32 * D.31394;
  unsigned int D.31395;
  short unsigned int D.31396;
  unsigned int D.31397;
  guint32 * D.31398;
  struct MonoGenericParamInfo * iftmp.344;
  struct MonoGenericContainer * D.31400;
  const char * D.31404;
  struct MonoDynamicStream * D.31405;
  unsigned int D.31406;
  struct MonoArray * D.31407;
  struct MonoDynamicTable * table;
  struct MonoGenericParam * param;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[42];
  D.31385 = table->next_idx;
  table_idx.343 = D.31385;
  D.31387 = table_idx.343 + 1;
  table->next_idx = D.31387;
  table_idx = table_idx.343;
  D.31388 = table->values;
  D.31389 = table_idx * 16;
  values = D.31388 + D.31389;
  D.31390 = entry->gparam;
  D.31391 = mono_reflection_type_get_handle (D.31390);
  param = D.31391->data.generic_param;
  D.31392 = values + 8;
  D.31393 = entry->owner;
  *D.31392 = D.31393;
  D.31394 = values + 4;
  D.31390 = entry->gparam;
  D.31395 = D.31390->attrs;
  *D.31394 = D.31395;
  D.31396 = param->num;
  D.31397 = (unsigned int) D.31396;
  *values = D.31397;
  D.31398 = values + 12;
  D.31400 = param->owner;
  if (D.31400 != 0B) goto <D.31401>; else goto <D.31402>;
  <D.31401>:
  iftmp.344 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.31403>;
  <D.31402>:
  iftmp.344 = 0B;
  <D.31403>:
  D.31404 = iftmp.344->name;
  D.31405 = &assembly->sheap;
  D.31406 = string_heap_insert (D.31405, D.31404);
  *D.31398 = D.31406;
  D.31390 = entry->gparam;
  D.31407 = D.31390->cattrs;
  mono_image_add_cattrs (assembly, table_idx, 19, D.31407);
  D.31390 = entry->gparam;
  encode_constraints (D.31390, table_idx, assembly);
}


encode_constraints (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  uintptr_t iftmp.345;
  struct MonoArray * D.31409;
  unsigned int D.31413;
  unsigned int D.31414;
  struct MonoReflectionType * D.31415;
  unsigned int D.31418;
  unsigned int D.31421;
  unsigned int table_idx.346;
  unsigned int D.31423;
  guint32 * D.31424;
  unsigned int D.31425;
  guint32 * D.31426;
  struct MonoType * D.31427;
  unsigned int D.31428;
  char * D.31429;
  unsigned int table_idx.347;
  unsigned int D.31431;
  struct MonoType * D.31432;
  unsigned int D.31433;
  struct MonoDynamicTable * table;
  guint32 num_constraints;
  guint32 i;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[44];
  D.31409 = gparam->iface_constraints;
  if (D.31409 != 0B) goto <D.31410>; else goto <D.31411>;
  <D.31410>:
  D.31409 = gparam->iface_constraints;
  iftmp.345 = mono_array_length (D.31409);
  goto <D.31412>;
  <D.31411>:
  iftmp.345 = 0;
  <D.31412>:
  num_constraints = iftmp.345;
  D.31413 = table->rows;
  D.31414 = D.31413 + num_constraints;
  table->rows = D.31414;
  D.31415 = gparam->base_type;
  if (D.31415 != 0B) goto <D.31416>; else goto <D.31417>;
  <D.31416>:
  D.31413 = table->rows;
  D.31418 = D.31413 + 1;
  table->rows = D.31418;
  <D.31417>:
  D.31413 = table->rows;
  alloc_table (table, D.31413);
  D.31415 = gparam->base_type;
  if (D.31415 != 0B) goto <D.31419>; else goto <D.31420>;
  <D.31419>:
  D.31421 = table->next_idx;
  table_idx.346 = D.31421;
  D.31423 = table_idx.346 + 1;
  table->next_idx = D.31423;
  table_idx = table_idx.346;
  D.31424 = table->values;
  D.31425 = table_idx * 8;
  values = D.31424 + D.31425;
  *values = owner;
  D.31426 = values + 4;
  D.31415 = gparam->base_type;
  D.31427 = mono_reflection_type_get_handle (D.31415);
  D.31428 = mono_image_typedef_or_ref (assembly, D.31427);
  *D.31426 = D.31428;
  <D.31420>:
  i = 0;
  goto <D.18955>;
  <D.18954>:
  {
    struct MonoReflectionType * constraint;

    D.31409 = gparam->iface_constraints;
    D.31429 = mono_array_addr_with_size (D.31409, 4, i);
    constraint = MEM[(void * *)D.31429];
    D.31421 = table->next_idx;
    table_idx.347 = D.31421;
    D.31431 = table_idx.347 + 1;
    table->next_idx = D.31431;
    table_idx = table_idx.347;
    D.31424 = table->values;
    D.31425 = table_idx * 8;
    values = D.31424 + D.31425;
    *values = owner;
    D.31426 = values + 4;
    D.31432 = mono_reflection_type_get_handle (constraint);
    D.31433 = mono_image_typedef_or_ref (assembly, D.31432);
    *D.31426 = D.31433;
  }
  i = i + 1;
  <D.18955>:
  if (i < num_constraints) goto <D.18954>; else goto <D.18956>;
  <D.18956>:
}


pad_heap (struct MonoDynamicStream * sh)
{
  unsigned int D.31434;
  unsigned int D.31435;
  unsigned int D.31438;
  unsigned int sz.348;
  char * D.31440;
  void * D.31441;
  unsigned int sz.349;
  unsigned int D.31443;

  D.31434 = sh->index;
  D.31435 = D.31434 & 3;
  if (D.31435 != 0) goto <D.31436>; else goto <D.31437>;
  <D.31436>:
  {
    int sz;

    D.31434 = sh->index;
    D.31435 = D.31434 & 3;
    D.31438 = 4 - D.31435;
    sz = (int) D.31438;
    sz.348 = (unsigned int) sz;
    D.31440 = sh->data;
    D.31434 = sh->index;
    D.31441 = D.31440 + D.31434;
    memset (D.31441, 0, sz.348);
    D.31434 = sh->index;
    sz.349 = (unsigned int) sz;
    D.31443 = D.31434 + sz.349;
    sh->index = D.31443;
  }
  <D.31437>:
}


assembly_add_win32_resources (struct MonoDynamicImage * assembly, struct MonoReflectionAssemblyBuilder * assemblyb)
{
  struct MonoArray * D.31444;
  struct MonoArray * D.31447;
  unsigned int D.31448;
  unsigned int D.31449;
  unsigned int D.31450;
  unsigned int D.31451;
  char * p.350;
  int p.351;
  int buf.352;
  int D.31455;
  unsigned int D.31456;
  _Bool D.31457;
  long int D.31458;
  long int D.31459;
  unsigned int D.31462;
  void * D.31463;
  unsigned int D.31464;
  char * D.31465;
  char * buf;
  char * p;
  guint32 size;
  guint32 i;
  struct MonoReflectionWin32Resource * win32_res;
  struct ResTreeNode * tree;

  try
    {
      D.31444 = assemblyb->win32_resources;
      if (D.31444 == 0B) goto <D.31445>; else goto <D.31446>;
      <D.31445>:
      return;
      <D.31446>:
      D.31444 = assemblyb->win32_resources;
      tree = resource_tree_create (D.31444);
      size = 0;
      i = 0;
      goto <D.20500>;
      <D.20499>:
      D.31444 = assemblyb->win32_resources;
      win32_res = mono_array_addr_with_size (D.31444, 16, i);
      D.31447 = win32_res->res_data;
      D.31448 = mono_array_length (D.31447);
      size = D.31448 + size;
      i = i + 1;
      <D.20500>:
      D.31444 = assemblyb->win32_resources;
      D.31449 = mono_array_length (D.31444);
      if (D.31449 > i) goto <D.20499>; else goto <D.20501>;
      <D.20501>:
      D.31444 = assemblyb->win32_resources;
      D.31450 = mono_array_length (D.31444);
      D.31451 = D.31450 * 256;
      size = D.31451 + 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.31455 = p.351 - buf.352;
      D.31456 = (unsigned int) D.31455;
      D.31457 = D.31456 > size;
      D.31458 = (long int) D.31457;
      D.31459 = __builtin_expect (D.31458, 0);
      if (D.31459 != 0) goto <D.31460>; else goto <D.31461>;
      <D.31460>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5585, "p - buf <= size");
      <D.31461>:
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31455 = p.351 - buf.352;
      D.31462 = (unsigned int) D.31455;
      D.31463 = monoeg_malloc (D.31462);
      assembly->win32_res = D.31463;
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31455 = p.351 - buf.352;
      D.31456 = (unsigned int) D.31455;
      assembly->win32_res_size = D.31456;
      p.350 = p;
      p.351 = (int) p.350;
      buf.352 = (int) buf;
      D.31455 = p.351 - buf.352;
      D.31464 = (unsigned int) D.31455;
      D.31465 = assembly->win32_res;
      memcpy (D.31465, buf, D.31464);
      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.31470;
  void * D.31471;
  unsigned int D.31472;
  unsigned int D.31473;
  struct GSList * D.31478;
  struct GSList * D.31479;
  unsigned int D.31480;
  struct GSList * D.31485;
  struct GSList * D.31486;
  struct GSList * D.31487;
  struct GSList * D.31488;
  unsigned int D.31489;
  struct ResTreeNode * D.31490;
  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.20459>;
  <D.20458>:
  {
    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.31470 = win32_res->lang_id;
    lang_node->id = D.31470;
    lang_node->win32_res = win32_res;
    type_node = 0B;
    l = tree->children;
    goto <D.20454>;
    <D.20453>:
    D.31471 = l->data;
    D.31472 = MEM[(struct ResTreeNode *)D.31471].id;
    D.31473 = win32_res->res_type;
    if (D.31472 == D.31473) goto <D.31474>; else goto <D.31475>;
    <D.31474>:
    type_node = l->data;
    goto <D.20452>;
    <D.31475>:
    l = l->next;
    <D.20454>:
    if (l != 0B) goto <D.20453>; else goto <D.20452>;
    <D.20452>:
    if (type_node == 0B) goto <D.31476>; else goto <D.31477>;
    <D.31476>:
    type_node = monoeg_malloc0 (16);
    D.31473 = win32_res->res_type;
    type_node->id = D.31473;
    D.31478 = tree->children;
    D.31479 = monoeg_g_slist_insert_sorted (D.31478, type_node, resource_tree_compare_by_id);
    tree->children = D.31479;
    <D.31477>:
    res_node = 0B;
    l = type_node->children;
    goto <D.20457>;
    <D.20456>:
    D.31471 = l->data;
    D.31472 = MEM[(struct ResTreeNode *)D.31471].id;
    D.31480 = win32_res->res_id;
    if (D.31472 == D.31480) goto <D.31481>; else goto <D.31482>;
    <D.31481>:
    res_node = l->data;
    goto <D.20455>;
    <D.31482>:
    l = l->next;
    <D.20457>:
    if (l != 0B) goto <D.20456>; else goto <D.20455>;
    <D.20455>:
    if (res_node == 0B) goto <D.31483>; else goto <D.31484>;
    <D.31483>:
    res_node = monoeg_malloc0 (16);
    D.31480 = win32_res->res_id;
    res_node->id = D.31480;
    D.31485 = type_node->children;
    D.31486 = monoeg_g_slist_append (D.31485, res_node);
    type_node->children = D.31486;
    <D.31484>:
    D.31487 = res_node->children;
    D.31488 = monoeg_g_slist_append (D.31487, lang_node);
    res_node->children = D.31488;
  }
  i = i + 1;
  <D.20459>:
  i.353 = (unsigned int) i;
  D.31489 = mono_array_length (win32_resources);
  if (i.353 < D.31489) goto <D.20458>; else goto <D.20460>;
  <D.20460>:
  D.31490 = tree;
  return D.31490;
}


resource_tree_compare_by_id (const void * a, const void * b)
{
  int D.31492;
  unsigned int D.31493;
  unsigned int D.31494;
  unsigned int D.31495;
  struct ResTreeNode * t1;
  struct ResTreeNode * t2;

  t1 = a;
  t2 = b;
  D.31493 = t1->id;
  D.31494 = t2->id;
  D.31495 = D.31493 - D.31494;
  D.31492 = (int) D.31495;
  return D.31492;
}


resource_tree_encode (struct ResTreeNode * node, char * begin, char * p, char * * endbuf)
{
  char * p.354;
  int p.355;
  int begin.356;
  int D.31506;
  unsigned int D.31507;
  struct GSList * D.31508;
  short unsigned int D.31509;
  char * p.357;
  unsigned int D.31511;
  char * p.358;
  struct MonoReflectionWin32Resource * D.31513;
  unsigned int D.31516;
  unsigned int D.31517;
  struct MonoArray * D.31518;
  char * D.31519;
  char * p.359;
  unsigned int D.31522;
  unsigned int D.31523;
  unsigned int iftmp.360;
  struct MonoReflectionWin32Resource * D.31525;
  unsigned int D.31529;
  unsigned int D.31530;
  unsigned int D.31531;
  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.31497>; else goto <D.31498>;
      <D.31497>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5486, "sizeof (dir) == 16");
      <D.31498>:
      if (0 != 0) goto <D.31499>; else goto <D.31500>;
      <D.31499>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5487, "sizeof (dir_entry) == 8");
      <D.31500>:
      if (0 != 0) goto <D.31501>; else goto <D.31502>;
      <D.31501>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5488, "sizeof (data_entry) == 16");
      <D.31502>:
      p.354 = p;
      p.355 = (int) p.354;
      begin.356 = (int) begin;
      D.31506 = p.355 - begin.356;
      D.31507 = (unsigned int) D.31506;
      node->offset = D.31507;
      D.31508 = node->children;
      res_id_entries = monoeg_g_slist_length (D.31508);
      D.31509 = (short unsigned int) res_id_entries;
      dir.res_id_entries = D.31509;
      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.31511 = res_id_entries * 8;
      p.358 = p.354 + D.31511;
      p = p.358;
      l = node->children;
      goto <D.20476>;
      <D.20475>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.31513 = child->win32_res;
        if (D.31513 != 0B) goto <D.31514>; else goto <D.31515>;
        <D.31514>:
        {
          guint32 size;

          p.354 = p;
          p.355 = (int) p.354;
          begin.356 = (int) begin;
          D.31506 = p.355 - begin.356;
          D.31507 = (unsigned int) D.31506;
          child->offset = D.31507;
          p.354 = p;
          p.355 = (int) p.354;
          begin.356 = (int) begin;
          D.31506 = p.355 - begin.356;
          D.31516 = (unsigned int) D.31506;
          D.31517 = D.31516 + 16;
          data_entry.rde_data_offset = D.31517;
          D.31513 = child->win32_res;
          D.31518 = D.31513->res_data;
          size = mono_array_length (D.31518);
          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;
          D.31513 = child->win32_res;
          D.31518 = D.31513->res_data;
          D.31519 = mono_array_addr_with_size (D.31518, 1, 0);
          p.354 = p;
          memcpy (p.354, D.31519, size);
          p.354 = p;
          p.359 = p.354 + size;
          p = p.359;
        }
        goto <D.31521>;
        <D.31515>:
        p.354 = p;
        resource_tree_encode (child, begin, p.354, &p);
        <D.31521>:
      }
      l = l->next;
      <D.20476>:
      if (l != 0B) goto <D.20475>; else goto <D.20477>;
      <D.20477>:
      l = node->children;
      goto <D.20480>;
      <D.20479>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.31522 = child->id;
        D.31523 = D.31522 & 2147483647;
        dir_entry.name = D.31523;
        D.31525 = child->win32_res;
        if (D.31525 == 0B) goto <D.31526>; else goto <D.31527>;
        <D.31526>:
        iftmp.360 = 2147483648;
        goto <D.31528>;
        <D.31527>:
        iftmp.360 = 0;
        <D.31528>:
        D.31529 = child->offset;
        D.31530 = D.31529 & 2147483647;
        D.31531 = iftmp.360 | D.31530;
        dir_entry.dir = D.31531;
        memcpy (entries, &dir_entry, 8);
        entries = entries + 8;
      }
      l = l->next;
      <D.20480>:
      if (l != 0B) goto <D.20479>; else goto <D.20481>;
      <D.20481>:
      p.354 = p;
      *endbuf = p.354;
    }
  finally
    {
      dir = {CLOBBER};
      dir_entry = {CLOBBER};
      data_entry = {CLOBBER};
    }
}


resource_tree_free (struct ResTreeNode * node)
{
  void * D.31532;
  struct GSList * D.31533;
  struct GSList * list;

  list = node->children;
  goto <D.20487>;
  <D.20486>:
  D.31532 = list->data;
  resource_tree_free (D.31532);
  list = list->next;
  <D.20487>:
  if (list != 0B) goto <D.20486>; else goto <D.20488>;
  <D.20488>:
  D.31533 = node->children;
  monoeg_g_slist_free (D.31533);
  monoeg_g_free (node);
}


calc_section_size (struct MonoDynamicImage * assembly)
{
  unsigned int D.31534;
  unsigned int D.31535;
  unsigned int D.31536;
  struct MonoDynamicStream * D.31537;
  _Bool D.31538;
  long int D.31539;
  long int D.31540;
  unsigned int D.31543;
  unsigned int D.31544;
  unsigned int D.31545;
  unsigned int D.31546;
  unsigned int D.31547;
  unsigned int D.31548;
  struct MonoDynamicStream * D.31549;
  _Bool D.31550;
  long int D.31551;
  long int D.31552;
  unsigned int D.31555;
  unsigned int D.31556;
  unsigned int D.31557;
  unsigned int D.31558;
  char * D.31559;
  unsigned int D.31562;
  unsigned int D.31563;
  int D.31564;
  int nsections;

  nsections = 0;
  D.31534 = assembly->code.index;
  D.31535 = D.31534 & 3;
  D.31536 = 4 - D.31535;
  D.31537 = &assembly->code;
  mono_image_add_stream_zero (D.31537, D.31536);
  D.31534 = assembly->code.index;
  D.31535 = D.31534 & 3;
  D.31538 = D.31535 != 0;
  D.31539 = (long int) D.31538;
  D.31540 = __builtin_expect (D.31539, 0);
  if (D.31540 != 0) goto <D.31541>; else goto <D.31542>;
  <D.31541>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5355, "(assembly->code.index % 4) == 0");
  <D.31542>:
  D.31543 = assembly->meta_size;
  D.31544 = D.31543 + 3;
  assembly->meta_size = D.31544;
  D.31543 = assembly->meta_size;
  D.31545 = D.31543 & 4294967292;
  assembly->meta_size = D.31545;
  D.31546 = assembly->resources.index;
  D.31547 = D.31546 & 3;
  D.31548 = 4 - D.31547;
  D.31549 = &assembly->resources;
  mono_image_add_stream_zero (D.31549, D.31548);
  D.31546 = assembly->resources.index;
  D.31547 = D.31546 & 3;
  D.31550 = D.31547 != 0;
  D.31551 = (long int) D.31550;
  D.31552 = __builtin_expect (D.31551, 0);
  if (D.31552 != 0) goto <D.31553>; else goto <D.31554>;
  <D.31553>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5359, "(assembly->resources.index % 4) == 0");
  <D.31554>:
  D.31543 = assembly->meta_size;
  D.31534 = assembly->code.index;
  D.31555 = D.31543 + D.31534;
  D.31546 = assembly->resources.index;
  D.31556 = D.31555 + D.31546;
  D.31557 = assembly->strong_name_size;
  D.31558 = D.31556 + D.31557;
  assembly->sections[0].size = D.31558;
  assembly->sections[0].attrs = 1610612768;
  nsections = nsections + 1;
  D.31559 = assembly->win32_res;
  if (D.31559 != 0B) goto <D.31560>; else goto <D.31561>;
  <D.31560>:
  {
    guint32 res_size;

    D.31562 = assembly->win32_res_size;
    D.31563 = D.31562 + 3;
    res_size = D.31563 & 4294967292;
    assembly->sections[1].size = res_size;
    assembly->sections[1].attrs = 1073741888;
    nsections = nsections + 1;
  }
  <D.31561>:
  assembly->sections[2].size = 12;
  assembly->sections[2].attrs = 1107296320;
  nsections = nsections + 1;
  D.31564 = nsections;
  return D.31564;
}


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

  D.31567 = __builtin_object_size (__dest, 1);
  D.31566 = __builtin___strcpy_chk (__dest, __src, D.31567);
  return D.31566;
}


fixup_resource_directory (char * res_section, char * p, guint32 rva)
{
  unsigned int D.31569;
  sizetype D.31570;
  signed int D.31571;
  unsigned int D.31575;
  unsigned int D.31576;
  short unsigned int D.31577;
  int D.31578;
  short unsigned int D.31579;
  int D.31580;
  int D.31581;
  struct MonoPEResourceDir * dir;
  int i;

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

    dir_entry = p;
    D.31569 = dir_entry->dir;
    D.31570 = D.31569 & 2147483647;
    child = res_section + D.31570;
    D.31569 = dir_entry->dir;
    D.31571 = (signed int) D.31569;
    if (D.31571 < 0) goto <D.31572>; else goto <D.31573>;
    <D.31572>:
    fixup_resource_directory (res_section, child, rva);
    goto <D.31574>;
    <D.31573>:
    {
      struct MonoPEResourceDataEntry * data_entry;

      data_entry = child;
      D.31575 = data_entry->rde_data_offset;
      D.31576 = D.31575 + rva;
      data_entry->rde_data_offset = D.31576;
    }
    <D.31574>:
    p = p + 8;
  }
  i = i + 1;
  <D.20513>:
  D.31577 = dir->res_named_entries;
  D.31578 = (int) D.31577;
  D.31579 = dir->res_id_entries;
  D.31580 = (int) D.31579;
  D.31581 = D.31578 + D.31580;
  if (D.31581 > i) goto <D.20512>; else goto <D.20514>;
  <D.20514>:
}


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

  try
    {
      D.31582 = WriteFile (f, buffer, numbytes, &dummy, 0B);
      if (D.31582 == 0) goto <D.31583>; else goto <D.31584>;
      <D.31583>:
      D.31585 = GetLastError ();
      monoeg_g_log (0B, 4, "WriteFile returned %d\n", D.31585);
      <D.20521>:
      goto <D.20521>;
      <D.31584>:
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


mono_image_load_module_dynamic (struct MonoReflectionAssemblyBuilder * ab, struct MonoString * fileName)
{
  <unnamed type> status.361;
  struct MonoAssembly * D.31592;
  struct MonoImage * D.31593;
  unsigned int D.31594;
  unsigned int D.31595;
  struct MonoImage * * D.31596;
  unsigned int D.31599;
  gboolean * D.31600;
  struct MonoImage * * D.31603;
  gboolean * D.31604;
  unsigned int D.31605;
  unsigned int D.31606;
  struct MonoException * D.31609;
  struct MonoReflectionModule * D.31610;
  struct MonoDomain * D.31611;
  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.31586>; else goto <D.31587>;
      <D.31586>:
      {
        struct MonoException * exc;

        status.361 = status;
        if (status.361 == 1) goto <D.31589>; else goto <D.31590>;
        <D.31589>:
        exc = mono_get_exception_file_not_found (fileName);
        goto <D.31591>;
        <D.31590>:
        exc = mono_get_exception_bad_image_format (name);
        <D.31591>:
        monoeg_g_free (name);
        mono_raise_exception (exc);
      }
      <D.31587>:
      monoeg_g_free (name);
      assembly = ab->dynamic_assembly;
      image->assembly = assembly;
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      module_count = D.31593->module_count;
      D.31594 = module_count + 1;
      D.31595 = D.31594 * 4;
      new_modules = monoeg_malloc0 (D.31595);
      D.31594 = module_count + 1;
      D.31595 = D.31594 * 4;
      new_modules_loaded = monoeg_malloc0 (D.31595);
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31596 = D.31593->modules;
      if (D.31596 != 0B) goto <D.31597>; else goto <D.31598>;
      <D.31597>:
      D.31599 = module_count * 4;
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31596 = D.31593->modules;
      memcpy (new_modules, D.31596, D.31599);
      <D.31598>:
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31600 = D.31593->modules_loaded;
      if (D.31600 != 0B) goto <D.31601>; else goto <D.31602>;
      <D.31601>:
      D.31599 = module_count * 4;
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31600 = D.31593->modules_loaded;
      memcpy (new_modules_loaded, D.31600, D.31599);
      <D.31602>:
      D.31599 = module_count * 4;
      D.31603 = new_modules + D.31599;
      *D.31603 = image;
      D.31599 = module_count * 4;
      D.31604 = new_modules_loaded + D.31599;
      *D.31604 = 1;
      mono_image_addref (image);
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31596 = D.31593->modules;
      monoeg_g_free (D.31596);
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31593->modules = new_modules;
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31593->modules_loaded = new_modules_loaded;
      D.31592 = image->assembly;
      D.31593 = D.31592->image;
      D.31605 = D.31593->module_count;
      D.31606 = D.31605 + 1;
      D.31593->module_count = D.31606;
      mono_assembly_load_references (image, &status);
      status.361 = status;
      if (status.361 != 0) goto <D.31607>; else goto <D.31608>;
      <D.31607>:
      mono_image_close (image);
      D.31609 = mono_get_exception_file_not_found (fileName);
      mono_raise_exception (D.31609);
      <D.31608>:
      D.31611 = mono_domain_get ();
      D.31610 = mono_module_get_object (D.31611, image);
      return D.31610;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

  D.31614 = domain->refobject_hash;
  if (D.31614 != 0B) goto <D.31615>; else goto <D.31616>;
  <D.31615>:
  D.31614 = domain->refobject_hash;
  mono_g_hash_table_destroy (D.31614);
  domain->refobject_hash = 0B;
  <D.31616>:
}


mono_image_module_basic_init (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoString * D.31619;
  struct MonoString * D.31620;
  int D.31621;
  struct MonoDynamicAssembly * D.31624;
  struct MonoImage * D.31625;
  struct MonoVTable * D.31626;
  struct MonoDomain * D.31627;
  unsigned int D.31628;
  int D.31629;
  unsigned int D.31630;
  unsigned int D.31631;
  struct MonoImage * * D.31632;
  unsigned int module_count.362;
  unsigned int D.31636;
  struct MonoImage * * D.31637;
  unsigned int D.31638;
  struct MonoDynamicImage * image;
  struct MonoReflectionAssemblyBuilder * ab;

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

    try
      {
        D.31619 = ab->name;
        name = mono_string_to_utf8 (D.31619);
        D.31620 = moduleb->module.fqname;
        fqname = mono_string_to_utf8_checked (D.31620, &error);
        D.31621 = mono_error_ok (&error);
        if (D.31621 == 0) goto <D.31622>; else goto <D.31623>;
        <D.31622>:
        monoeg_g_free (name);
        mono_error_raise_exception (&error);
        <D.31623>:
        D.31624 = ab->dynamic_assembly;
        image = create_dynamic_mono_image (D.31624, name, fqname);
        D.31625 = &image->image;
        moduleb->module.image = D.31625;
        moduleb->dynamic_image = image;
        D.31626 = MEM[(struct MonoObject *)moduleb].vtable;
        D.31627 = D.31626->domain;
        register_module (D.31627, moduleb, image);
        D.31624 = ab->dynamic_assembly;
        ass = D.31624->assembly.image;
        D.31628 = ass->module_count;
        module_count = (int) D.31628;
        D.31629 = module_count + 1;
        D.31630 = (unsigned int) D.31629;
        D.31631 = D.31630 * 4;
        new_modules = monoeg_malloc0 (D.31631);
        D.31632 = ass->modules;
        if (D.31632 != 0B) goto <D.31633>; else goto <D.31634>;
        <D.31633>:
        module_count.362 = (unsigned int) module_count;
        D.31636 = module_count.362 * 4;
        D.31632 = ass->modules;
        memcpy (new_modules, D.31632, D.31636);
        <D.31634>:
        module_count.362 = (unsigned int) module_count;
        D.31636 = module_count.362 * 4;
        D.31637 = new_modules + D.31636;
        D.31625 = &image->image;
        *D.31637 = D.31625;
        D.31625 = &image->image;
        mono_image_addref (D.31625);
        D.31632 = ass->modules;
        monoeg_g_free (D.31632);
        ass->modules = new_modules;
        D.31628 = ass->module_count;
        D.31638 = D.31628 + 1;
        ass->module_count = D.31638;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.31618>:
}


register_module (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * res, struct MonoDynamicImage * module)
{
  union mono_mutex_t * D.31639;
  _Bool D.31642;
  long int D.31643;
  long int D.31644;
  struct MonoGHashTable * D.31647;
  struct MonoGHashTable * D.31650;
  struct MonoMemPool * D.31653;
  _Bool D.31656;
  long int D.31657;
  long int D.31658;
  void * D.31661;

  {
    struct MonoReflectionModuleBuilder * _obj;
    struct ReflectedEntry pe;

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

          D.31639 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31639);
          if (ret != 0) goto <D.31640>; else goto <D.31641>;
          <D.31640>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock 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", 6173, "ret == 0");
          <D.31646>:
        }
        D.31647 = domain->refobject_hash;
        if (D.31647 == 0B) goto <D.31648>; else goto <D.31649>;
        <D.31648>:
        D.31650 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31650;
        <D.31649>:
        D.31647 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31647, &pe);
        if (_obj == 0B) goto <D.31651>; else goto <D.31652>;
        <D.31651>:
        {
          struct ReflectedEntry * e;

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

          D.31639 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31639);
          if (ret != 0) goto <D.31654>; else goto <D.31655>;
          <D.31654>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31655>:
          D.31656 = ret != 0;
          D.31657 = (long int) D.31656;
          D.31658 = __builtin_expect (D.31657, 0);
          if (D.31658 != 0) goto <D.31659>; else goto <D.31660>;
          <D.31659>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.31660>:
        }
        D.31661 = _obj;
        return D.31661;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_image_set_wrappers_type (struct MonoReflectionModuleBuilder * moduleb, struct MonoReflectionType * type)
{
  struct MonoType * D.31664;
  _Bool D.31665;
  long int D.31666;
  long int D.31667;
  struct MonoClass * D.31670;
  struct MonoDynamicImage * image;

  image = moduleb->dynamic_image;
  D.31664 = type->type;
  D.31665 = D.31664 == 0B;
  D.31666 = (long int) D.31665;
  D.31667 = __builtin_expect (D.31666, 0);
  if (D.31667 != 0) goto <D.31668>; else goto <D.31669>;
  <D.31668>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6226, "type->type");
  <D.31669>:
  D.31664 = type->type;
  D.31670 = mono_class_from_mono_type (D.31664);
  image->wrappers_type = D.31670;
}


mono_assembly_get_object (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.31671;
  _Bool D.31674;
  long int D.31675;
  long int D.31676;
  struct MonoGHashTable * D.31679;
  struct MonoGHashTable * D.31682;
  _Bool D.31687;
  long int D.31688;
  long int D.31689;
  struct MonoReflectionAssembly * D.31692;
  _Bool D.31695;
  long int D.31696;
  long int D.31697;
  struct MonoClass * assembly_type.363;
  struct MonoImage * D.31703;
  _Bool D.31706;
  long int D.31707;
  long int D.31708;
  _Bool D.31713;
  long int D.31714;
  long int D.31715;
  struct MonoGHashTable * D.31720;
  struct MonoMemPool * D.31723;
  _Bool D.31726;
  long int D.31727;
  long int D.31728;
  static struct MonoClass * assembly_type;
  struct MonoReflectionAssembly * res;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry e;

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

          D.31671 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31671);
          if (ret != 0) goto <D.31672>; else goto <D.31673>;
          <D.31672>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31673>:
          D.31674 = ret != 0;
          D.31675 = (long int) D.31674;
          D.31676 = __builtin_expect (D.31675, 0);
          if (D.31676 != 0) goto <D.31677>; else goto <D.31678>;
          <D.31677>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.31678>:
        }
        D.31679 = domain->refobject_hash;
        if (D.31679 == 0B) goto <D.31680>; else goto <D.31681>;
        <D.31680>:
        D.31682 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31682;
        <D.31681>:
        D.31679 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31679, &e);
        if (_obj != 0B) goto <D.31683>; else goto <D.31684>;
        <D.31683>:
        {
          int ret;

          D.31671 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31671);
          if (ret != 0) goto <D.31685>; else goto <D.31686>;
          <D.31685>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31686>:
          D.31687 = ret != 0;
          D.31688 = (long int) D.31687;
          D.31689 = __builtin_expect (D.31688, 0);
          if (D.31689 != 0) goto <D.31690>; else goto <D.31691>;
          <D.31690>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.31691>:
        }
        D.31692 = _obj;
        return D.31692;
        <D.31684>:
        {
          int ret;

          D.31671 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31671);
          if (ret != 0) goto <D.31693>; else goto <D.31694>;
          <D.31693>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock 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", 6245, "ret == 0");
          <D.31699>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  assembly_type.363 = assembly_type;
  if (assembly_type.363 == 0B) goto <D.31701>; else goto <D.31702>;
  <D.31701>:
  {
    struct MonoClass * class;

    D.31703 = mono_defaults.corlib;
    class = mono_class_from_name (D.31703, "System.Reflection", "MonoAssembly");
    if (class == 0B) goto <D.31704>; else goto <D.31705>;
    <D.31704>:
    D.31703 = mono_defaults.corlib;
    class = mono_class_from_name (D.31703, "System.Reflection", "Assembly");
    <D.31705>:
    D.31706 = class == 0B;
    D.31707 = (long int) D.31706;
    D.31708 = __builtin_expect (D.31707, 0);
    if (D.31708 != 0) goto <D.31709>; else goto <D.31710>;
    <D.31709>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6250, "class");
    <D.31710>:
    assembly_type = class;
  }
  <D.31702>:
  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.31671 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31671);
          if (ret != 0) goto <D.31711>; else goto <D.31712>;
          <D.31711>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31712>:
          D.31713 = ret != 0;
          D.31714 = (long int) D.31713;
          D.31715 = __builtin_expect (D.31714, 0);
          if (D.31715 != 0) goto <D.31716>; else goto <D.31717>;
          <D.31716>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.31717>:
        }
        D.31679 = domain->refobject_hash;
        if (D.31679 == 0B) goto <D.31718>; else goto <D.31719>;
        <D.31718>:
        D.31720 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31720;
        <D.31719>:
        D.31679 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31679, &pe);
        if (_obj == 0B) goto <D.31721>; else goto <D.31722>;
        <D.31721>:
        {
          struct ReflectedEntry * e;

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

          D.31671 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31671);
          if (ret != 0) goto <D.31724>; else goto <D.31725>;
          <D.31724>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31725>:
          D.31726 = ret != 0;
          D.31727 = (long int) D.31726;
          D.31728 = __builtin_expect (D.31727, 0);
          if (D.31728 != 0) goto <D.31729>; else goto <D.31730>;
          <D.31729>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.31730>:
        }
        D.31692 = _obj;
        return D.31692;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_get_object (struct MonoDomain * domain, struct MonoImage * image)
{
  union mono_mutex_t * D.31735;
  _Bool D.31738;
  long int D.31739;
  long int D.31740;
  struct MonoGHashTable * D.31743;
  struct MonoGHashTable * D.31746;
  _Bool D.31751;
  long int D.31752;
  long int D.31753;
  struct MonoReflectionModule * D.31756;
  _Bool D.31759;
  long int D.31760;
  long int D.31761;
  struct MonoClass * module_type.364;
  struct MonoImage * D.31767;
  _Bool D.31770;
  long int D.31771;
  long int D.31772;
  struct MonoAssembly * D.31775;
  struct MonoReflectionAssembly * D.31776;
  struct MonoReflectionAssembly * * D.31777;
  char * D.31778;
  struct MonoString * D.31779;
  struct MonoString * * D.31780;
  struct MonoString * D.31781;
  struct MonoString * * D.31782;
  const char * D.31783;
  struct MonoString * D.31784;
  struct MonoString * * D.31785;
  struct MonoImage * D.31786;
  struct MonoImage * * D.31790;
  unsigned int i.365;
  unsigned int D.31794;
  struct MonoImage * * D.31795;
  struct MonoImage * D.31796;
  int D.31799;
  int D.31800;
  unsigned int D.31801;
  unsigned int i.366;
  unsigned int D.31803;
  unsigned int D.31804;
  _Bool D.31805;
  long int D.31806;
  long int D.31807;
  _Bool D.31812;
  long int D.31813;
  long int D.31814;
  struct MonoGHashTable * D.31819;
  struct MonoMemPool * D.31822;
  _Bool D.31825;
  long int D.31826;
  long int D.31827;
  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.31735 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31735);
          if (ret != 0) goto <D.31736>; else goto <D.31737>;
          <D.31736>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31737>:
          D.31738 = ret != 0;
          D.31739 = (long int) D.31738;
          D.31740 = __builtin_expect (D.31739, 0);
          if (D.31740 != 0) goto <D.31741>; else goto <D.31742>;
          <D.31741>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31742>:
        }
        D.31743 = domain->refobject_hash;
        if (D.31743 == 0B) goto <D.31744>; else goto <D.31745>;
        <D.31744>:
        D.31746 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31746;
        <D.31745>:
        D.31743 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31743, &e);
        if (_obj != 0B) goto <D.31747>; else goto <D.31748>;
        <D.31747>:
        {
          int ret;

          D.31735 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31735);
          if (ret != 0) goto <D.31749>; else goto <D.31750>;
          <D.31749>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31750>:
          D.31751 = ret != 0;
          D.31752 = (long int) D.31751;
          D.31753 = __builtin_expect (D.31752, 0);
          if (D.31753 != 0) goto <D.31754>; else goto <D.31755>;
          <D.31754>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31755>:
        }
        D.31756 = _obj;
        return D.31756;
        <D.31748>:
        {
          int ret;

          D.31735 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31735);
          if (ret != 0) goto <D.31757>; else goto <D.31758>;
          <D.31757>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31758>:
          D.31759 = ret != 0;
          D.31760 = (long int) D.31759;
          D.31761 = __builtin_expect (D.31760, 0);
          if (D.31761 != 0) goto <D.31762>; else goto <D.31763>;
          <D.31762>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.31763>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  module_type.364 = module_type;
  if (module_type.364 == 0B) goto <D.31765>; else goto <D.31766>;
  <D.31765>:
  {
    struct MonoClass * class;

    D.31767 = mono_defaults.corlib;
    class = mono_class_from_name (D.31767, "System.Reflection", "MonoModule");
    if (class == 0B) goto <D.31768>; else goto <D.31769>;
    <D.31768>:
    D.31767 = mono_defaults.corlib;
    class = mono_class_from_name (D.31767, "System.Reflection", "Module");
    <D.31769>:
    D.31770 = class == 0B;
    D.31771 = (long int) D.31770;
    D.31772 = __builtin_expect (D.31771, 0);
    if (D.31772 != 0) goto <D.31773>; else goto <D.31774>;
    <D.31773>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6273, "class");
    <D.31774>:
    module_type = class;
  }
  <D.31766>:
  module_type.364 = module_type;
  res = mono_object_new (domain, module_type.364);
  res->image = image;
  D.31775 = image->assembly;
  D.31776 = mono_assembly_get_object (domain, D.31775);
  D.31777 = &res->assembly;
  mono_gc_wbarrier_set_field (res, D.31777, D.31776);
  D.31778 = image->name;
  D.31779 = mono_string_new (domain, D.31778);
  D.31780 = &res->fqname;
  mono_gc_wbarrier_set_field (res, D.31780, D.31779);
  D.31778 = image->name;
  basename = monoeg_g_path_get_basename (D.31778);
  D.31781 = mono_string_new (domain, basename);
  D.31782 = &res->name;
  mono_gc_wbarrier_set_field (res, D.31782, D.31781);
  D.31783 = image->module_name;
  D.31784 = mono_string_new (domain, D.31783);
  D.31785 = &res->scopename;
  mono_gc_wbarrier_set_field (res, D.31785, D.31784);
  monoeg_g_free (basename);
  D.31775 = image->assembly;
  D.31786 = D.31775->image;
  if (D.31786 == image) goto <D.31787>; else goto <D.31788>;
  <D.31787>:
  res->token = 1;
  goto <D.31789>;
  <D.31788>:
  {
    int i;

    res->token = 0;
    D.31775 = image->assembly;
    D.31786 = D.31775->image;
    D.31790 = D.31786->modules;
    if (D.31790 != 0B) goto <D.31791>; else goto <D.31792>;
    <D.31791>:
    i = 0;
    goto <D.20702>;
    <D.20701>:
    D.31775 = image->assembly;
    D.31786 = D.31775->image;
    D.31790 = D.31786->modules;
    i.365 = (unsigned int) i;
    D.31794 = i.365 * 4;
    D.31795 = D.31790 + D.31794;
    D.31796 = *D.31795;
    if (D.31796 == image) goto <D.31797>; else goto <D.31798>;
    <D.31797>:
    D.31799 = i + 1;
    D.31800 = D.31799 | 436207616;
    D.31801 = (unsigned int) D.31800;
    res->token = D.31801;
    <D.31798>:
    i = i + 1;
    <D.20702>:
    i.366 = (unsigned int) i;
    D.31775 = image->assembly;
    D.31786 = D.31775->image;
    D.31803 = D.31786->module_count;
    if (i.366 < D.31803) goto <D.20701>; else goto <D.20703>;
    <D.20703>:
    D.31804 = res->token;
    D.31805 = D.31804 == 0;
    D.31806 = (long int) D.31805;
    D.31807 = __builtin_expect (D.31806, 0);
    if (D.31807 != 0) goto <D.31808>; else goto <D.31809>;
    <D.31808>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6298, "res->token");
    <D.31809>:
    <D.31792>:
  }
  <D.31789>:
  {
    struct MonoReflectionModule * _obj;
    struct ReflectedEntry pe;

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

          D.31735 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31735);
          if (ret != 0) goto <D.31810>; else goto <D.31811>;
          <D.31810>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31811>:
          D.31812 = ret != 0;
          D.31813 = (long int) D.31812;
          D.31814 = __builtin_expect (D.31813, 0);
          if (D.31814 != 0) goto <D.31815>; else goto <D.31816>;
          <D.31815>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.31816>:
        }
        D.31743 = domain->refobject_hash;
        if (D.31743 == 0B) goto <D.31817>; else goto <D.31818>;
        <D.31817>:
        D.31819 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31819;
        <D.31818>:
        D.31743 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31743, &pe);
        if (_obj == 0B) goto <D.31820>; else goto <D.31821>;
        <D.31820>:
        {
          struct ReflectedEntry * e;

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

          D.31735 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31735);
          if (ret != 0) goto <D.31823>; else goto <D.31824>;
          <D.31823>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31824>:
          D.31825 = ret != 0;
          D.31826 = (long int) D.31825;
          D.31827 = __builtin_expect (D.31826, 0);
          if (D.31827 != 0) goto <D.31828>; else goto <D.31829>;
          <D.31828>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.31829>:
        }
        D.31756 = _obj;
        return D.31756;
      }
    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.31837;
  _Bool D.31840;
  long int D.31841;
  long int D.31842;
  <unnamed-unsigned:24> D.31845;
  int D.31846;
  _Bool D.31847;
  long int D.31848;
  long int D.31849;
  struct MonoAssembly * D.31852;
  struct MonoReflectionAssembly * D.31853;
  struct MonoReflectionAssembly * * D.31854;
  unsigned int D.31855;
  int i.368;
  int D.20731;
  struct MonoImage * * D.31859;
  unsigned int D.31860;
  struct MonoImage * * D.31861;
  struct MonoImage * D.31862;
  unsigned int D.31863;
  struct MonoString * D.31864;
  struct MonoString * * D.31865;
  struct MonoString * D.31866;
  struct MonoString * * D.31867;
  struct MonoString * D.31868;
  struct MonoString * * D.31869;
  unsigned int D.31870;
  _Bool D.31871;
  unsigned char D.31872;
  int D.31873;
  int D.31874;
  unsigned int D.31875;
  struct MonoReflectionModule * D.31876;
  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.31835>; else goto <D.31836>;
      <D.31835>:
      {
        struct MonoClass * class;

        D.31837 = mono_defaults.corlib;
        class = mono_class_from_name (D.31837, "System.Reflection", "MonoModule");
        if (class == 0B) goto <D.31838>; else goto <D.31839>;
        <D.31838>:
        D.31837 = mono_defaults.corlib;
        class = mono_class_from_name (D.31837, "System.Reflection", "Module");
        <D.31839>:
        D.31840 = class == 0B;
        D.31841 = (long int) D.31840;
        D.31842 = __builtin_expect (D.31841, 0);
        if (D.31842 != 0) goto <D.31843>; else goto <D.31844>;
        <D.31843>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6320, "class");
        <D.31844>:
        module_type = class;
      }
      <D.31836>:
      module_type.367 = module_type;
      res = mono_object_new (domain, module_type.367);
      table = &image->tables[38];
      D.31845 = table->rows;
      D.31846 = (int) D.31845;
      D.31847 = D.31846 <= table_index;
      D.31848 = (long int) D.31847;
      D.31849 = __builtin_expect (D.31848, 0);
      if (D.31849 != 0) goto <D.31850>; else goto <D.31851>;
      <D.31850>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6326, "table_index < table->rows");
      <D.31851>:
      mono_metadata_decode_row (table, table_index, &cols, 3);
      res->image = 0B;
      D.31852 = image->assembly;
      D.31853 = mono_assembly_get_object (domain, D.31852);
      D.31854 = &res->assembly;
      mono_gc_wbarrier_set_field (res, D.31854, D.31853);
      D.31855 = cols[1];
      name = mono_metadata_string_heap (image, D.31855);
      table = &image->tables[26];
      i = 0;
      goto <D.20733>;
      <D.20732>:
      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.20731 = __builtin_strcmp (val, name);
      }
      if (D.20731 == 0) goto <D.31857>; else goto <D.31858>;
      <D.31857>:
      D.31859 = image->modules;
      D.31860 = i * 4;
      D.31861 = D.31859 + D.31860;
      D.31862 = *D.31861;
      res->image = D.31862;
      <D.31858>:
      i = i + 1;
      <D.20733>:
      D.31845 = table->rows;
      D.31863 = (unsigned int) D.31845;
      if (D.31863 > i) goto <D.20732>; else goto <D.20734>;
      <D.20734>:
      D.31864 = mono_string_new (domain, name);
      D.31865 = &res->fqname;
      mono_gc_wbarrier_set_field (res, D.31865, D.31864);
      D.31866 = mono_string_new (domain, name);
      D.31867 = &res->name;
      mono_gc_wbarrier_set_field (res, D.31867, D.31866);
      D.31868 = mono_string_new (domain, name);
      D.31869 = &res->scopename;
      mono_gc_wbarrier_set_field (res, D.31869, D.31868);
      D.31870 = cols[0];
      D.31871 = D.31870 != 0;
      D.31872 = (unsigned char) D.31871;
      res->is_resource = D.31872;
      D.31873 = table_index + 1;
      D.31874 = D.31873 | 637534208;
      D.31875 = (unsigned int) D.31874;
      res->token = D.31875;
      D.31876 = res;
      return D.31876;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_type_get_object (struct MonoDomain * domain, struct MonoType * type)
{
  struct MonoType * iftmp.369;
  <unnamed-unsigned:1> D.31880;
  <unnamed-unsigned:1> D.31881;
  unsigned char D.31885;
  struct MonoObject * D.31888;
  struct MonoReflectionType * D.31891;
  struct MonoType * D.31892;
  struct MonoImage * D.31895;
  unsigned char D.31896;
  unsigned char D.31897;
  void * D.31902;
  union mono_mutex_t * D.31905;
  _Bool D.31908;
  long int D.31909;
  long int D.31910;
  struct MonoGHashTable * D.31913;
  struct MonoGHashTable * D.31916;
  _Bool D.31921;
  long int D.31922;
  long int D.31923;
  _Bool D.31930;
  long int D.31931;
  long int D.31932;
  struct MonoGenericClass * D.31937;
  unsigned char D.31938;
  unsigned char D.31939;
  struct MonoClass * D.31942;
  unsigned char D.31943;
  unsigned char D.31944;
  int D.31949;
  _Bool D.31954;
  long int D.31955;
  long int D.31956;
  struct MonoException * D.31959;
  void * D.31960;
  unsigned char D.31963;
  unsigned char D.31964;
  unsigned char D.31967;
  _Bool D.31968;
  _Bool D.31969;
  _Bool D.31970;
  struct MonoGenericContainer * D.31975;
  unsigned char D.31977;
  unsigned char D.31978;
  struct MonoClass * D.31982;
  struct MonoClass * D.31983;
  unsigned char D.31984;
  unsigned char D.31985;
  struct MonoClass * D.31994;
  unsigned char D.31995;
  unsigned char D.31996;
  unsigned char D.32001;
  unsigned char D.32002;
  _Bool D.32007;
  long int D.32008;
  long int D.32009;
  struct MonoClass * D.32012;
  _Bool D.32017;
  long int D.32018;
  long int D.32019;
  struct MonoType * norm_type;
  struct MonoReflectionType * res;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (type);
  D.31880 = klass->byval_arg.byref;
  D.31881 = type->byref;
  if (D.31880 == D.31881) goto <D.31882>; else goto <D.31883>;
  <D.31882>:
  iftmp.369 = &klass->byval_arg;
  goto <D.31884>;
  <D.31883>:
  iftmp.369 = &klass->this_arg;
  <D.31884>:
  type = iftmp.369;
  D.31885 = type->type;
  if (D.31885 == 1) goto <D.31886>; else goto <D.31887>;
  <D.31886>:
  D.31888 = domain->typeof_void;
  if (D.31888 != 0B) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  D.31891 = domain->typeof_void;
  return D.31891;
  <D.31890>:
  <D.31887>:
  D.31892 = &klass->byval_arg;
  if (D.31892 == type) goto <D.31893>; else goto <D.31894>;
  <D.31893>:
  D.31895 = klass->image;
  D.31896 = BIT_FIELD_REF <*D.31895, 8, 128>;
  D.31897 = D.31896 & 8;
  if (D.31897 == 0) goto <D.31898>; else goto <D.31899>;
  <D.31898>:
  {
    struct MonoVTable * vtable;

    vtable = mono_class_try_get_vtable (domain, klass);
    if (vtable != 0B) goto <D.31900>; else goto <D.31901>;
    <D.31900>:
    D.31902 = vtable->type;
    if (D.31902 != 0B) goto <D.31903>; else goto <D.31904>;
    <D.31903>:
    D.31891 = vtable->type;
    return D.31891;
    <D.31904>:
    <D.31901>:
  }
  <D.31899>:
  <D.31894>:
  mono_loader_lock ();
  {
    int ret;

    D.31905 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.31905);
    if (ret != 0) goto <D.31906>; else goto <D.31907>;
    <D.31906>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31907>:
    D.31908 = ret != 0;
    D.31909 = (long int) D.31908;
    D.31910 = __builtin_expect (D.31909, 0);
    if (D.31910 != 0) goto <D.31911>; else goto <D.31912>;
    <D.31911>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6462, "ret == 0");
    <D.31912>:
  }
  D.31913 = domain->type_hash;
  if (D.31913 == 0B) goto <D.31914>; else goto <D.31915>;
  <D.31914>:
  D.31916 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.31916;
  <D.31915>:
  D.31913 = domain->type_hash;
  res = mono_g_hash_table_lookup (D.31913, type);
  if (res != 0B) goto <D.31917>; else goto <D.31918>;
  <D.31917>:
  {
    int ret;

    D.31905 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31905);
    if (ret != 0) goto <D.31919>; else goto <D.31920>;
    <D.31919>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31920>:
    D.31921 = ret != 0;
    D.31922 = (long int) D.31921;
    D.31923 = __builtin_expect (D.31922, 0);
    if (D.31923 != 0) goto <D.31924>; else goto <D.31925>;
    <D.31924>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6467, "ret == 0");
    <D.31925>:
  }
  mono_loader_unlock ();
  D.31891 = res;
  return D.31891;
  <D.31918>:
  norm_type = mono_type_normalize (type);
  if (norm_type != type) goto <D.31926>; else goto <D.31927>;
  <D.31926>:
  res = mono_type_get_object (domain, norm_type);
  D.31913 = domain->type_hash;
  mono_g_hash_table_insert (D.31913, type, res);
  {
    int ret;

    D.31905 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31905);
    if (ret != 0) goto <D.31928>; else goto <D.31929>;
    <D.31928>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31929>:
    D.31930 = ret != 0;
    D.31931 = (long int) D.31930;
    D.31932 = __builtin_expect (D.31931, 0);
    if (D.31932 != 0) goto <D.31933>; else goto <D.31934>;
    <D.31933>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6483, "ret == 0");
    <D.31934>:
  }
  mono_loader_unlock ();
  D.31891 = res;
  return D.31891;
  <D.31927>:
  D.31885 = type->type;
  if (D.31885 == 21) goto <D.31935>; else goto <D.31936>;
  <D.31935>:
  D.31937 = type->data.generic_class;
  D.31938 = BIT_FIELD_REF <*D.31937, 8, 96>;
  D.31939 = D.31938 & 1;
  if (D.31939 != 0) goto <D.31940>; else goto <D.31941>;
  <D.31940>:
  D.31937 = type->data.generic_class;
  D.31942 = D.31937->container_class;
  D.31943 = BIT_FIELD_REF <*D.31942, 8, 160>;
  D.31944 = D.31943 & 128;
  if (D.31944 == 0) goto <D.31945>; else goto <D.31946>;
  <D.31945>:
  if (1 != 0) goto <D.31947>; else goto <D.31948>;
  <D.31947>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6490, "0");
  <D.31948>:
  <D.31946>:
  <D.31941>:
  <D.31936>:
  D.31949 = verify_safe_for_managed_space (type);
  if (D.31949 == 0) goto <D.31950>; else goto <D.31951>;
  <D.31950>:
  {
    int ret;

    D.31905 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31905);
    if (ret != 0) goto <D.31952>; else goto <D.31953>;
    <D.31952>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31953>:
    D.31954 = ret != 0;
    D.31955 = (long int) D.31954;
    D.31956 = __builtin_expect (D.31955, 0);
    if (D.31956 != 0) goto <D.31957>; else goto <D.31958>;
    <D.31957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6493, "ret == 0");
    <D.31958>:
  }
  mono_loader_unlock ();
  D.31959 = mono_get_exception_invalid_operation ("This type cannot be propagated to managed space");
  mono_raise_exception (D.31959);
  <D.31951>:
  D.31960 = mono_class_get_ref_info (klass);
  if (D.31960 != 0B) goto <D.31961>; else goto <D.31962>;
  <D.31961>:
  D.31963 = BIT_FIELD_REF <*klass, 8, 160>;
  D.31964 = D.31963 & 128;
  if (D.31964 == 0) goto <D.31965>; else goto <D.31966>;
  <D.31965>:
  {
    gboolean is_type_done;

    is_type_done = 1;
    D.31967 = klass->byval_arg.type;
    D.31968 = D.31967 == 30;
    D.31969 = D.31967 == 19;
    D.31970 = D.31968 | D.31969;
    if (D.31970 != 0) goto <D.31971>; else goto <D.31972>;
    <D.31971>:
    {
      struct MonoGenericParam * gparam;

      gparam = klass->byval_arg.data.generic_param;
      D.31975 = gparam->owner;
      if (D.31975 != 0B) goto <D.31976>; else goto <D.31973>;
      <D.31976>:
      D.31975 = gparam->owner;
      D.31977 = BIT_FIELD_REF <*D.31975, 8, 152>;
      D.31978 = D.31977 & 128;
      if (D.31978 != 0) goto <D.31979>; else goto <D.31973>;
      <D.31979>:
      {
        struct MonoMethod * method;

        D.31975 = gparam->owner;
        method = D.31975->owner.method;
        if (method != 0B) goto <D.31980>; else goto <D.31981>;
        <D.31980>:
        D.31982 = method->klass;
        D.31983 = mono_class_get_generic_type_definition (D.31982);
        D.31984 = BIT_FIELD_REF <*D.31983, 8, 160>;
        D.31985 = D.31984 & 128;
        if (D.31985 != 0) goto <D.31986>; else goto <D.31987>;
        <D.31986>:
        is_type_done = 0;
        <D.31987>:
        <D.31981>:
      }
      goto <D.31974>;
      <D.31973>:
      D.31975 = gparam->owner;
      if (D.31975 != 0B) goto <D.31988>; else goto <D.31989>;
      <D.31988>:
      D.31975 = gparam->owner;
      D.31977 = BIT_FIELD_REF <*D.31975, 8, 152>;
      D.31978 = D.31977 & 128;
      if (D.31978 == 0) goto <D.31990>; else goto <D.31991>;
      <D.31990>:
      {
        struct MonoClass * klass;

        D.31975 = gparam->owner;
        klass = D.31975->owner.klass;
        if (klass != 0B) goto <D.31992>; else goto <D.31993>;
        <D.31992>:
        D.31994 = mono_class_get_generic_type_definition (klass);
        D.31995 = BIT_FIELD_REF <*D.31994, 8, 160>;
        D.31996 = D.31995 & 128;
        if (D.31996 != 0) goto <D.31997>; else goto <D.31998>;
        <D.31997>:
        is_type_done = 0;
        <D.31998>:
        <D.31993>:
      }
      <D.31991>:
      <D.31989>:
      <D.31974>:
    }
    <D.31972>:
    if (is_type_done != 0) goto <D.31999>; else goto <D.32000>;
    <D.31999>:
    D.32001 = BIT_FIELD_REF <*type, 8, 56>;
    D.32002 = D.32001 & 64;
    if (D.32002 == 0) goto <D.32003>; else goto <D.32004>;
    <D.32003>:
    {
      int ret;

      D.31905 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.31905);
      if (ret != 0) goto <D.32005>; else goto <D.32006>;
      <D.32005>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32006>:
      D.32007 = ret != 0;
      D.32008 = (long int) D.32007;
      D.32009 = __builtin_expect (D.32008, 0);
      if (D.32009 != 0) goto <D.32010>; else goto <D.32011>;
      <D.32010>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6521, "ret == 0");
      <D.32011>:
    }
    mono_loader_unlock ();
    D.31891 = mono_class_get_ref_info (klass);
    return D.31891;
    <D.32004>:
    <D.32000>:
  }
  <D.31966>:
  <D.31962>:
  D.32012 = mono_defaults.monotype_class;
  res = mono_object_new_pinned (domain, D.32012);
  res->type = type;
  D.31913 = domain->type_hash;
  mono_g_hash_table_insert (D.31913, type, res);
  D.31885 = type->type;
  if (D.31885 == 1) goto <D.32013>; else goto <D.32014>;
  <D.32013>:
  domain->typeof_void = res;
  <D.32014>:
  {
    int ret;

    D.31905 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.31905);
    if (ret != 0) goto <D.32015>; else goto <D.32016>;
    <D.32015>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32016>:
    D.32017 = ret != 0;
    D.32018 = (long int) D.32017;
    D.32019 = __builtin_expect (D.32018, 0);
    if (D.32019 != 0) goto <D.32020>; else goto <D.32021>;
    <D.32020>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6534, "ret == 0");
    <D.32021>:
  }
  mono_loader_unlock ();
  D.31891 = res;
  return D.31891;
}


mono_type_normalize (struct MonoType * type)
{
  unsigned char D.32023;
  struct MonoType * D.32026;
  unsigned char D.32027;
  unsigned char D.32028;
  <unnamed-unsigned:22> D.32031;
  unsigned int D.32032;
  unsigned int D.32033;
  unsigned char D.32036;
  struct MonoGenericParam * D.32038;
  short unsigned int D.32039;
  int D.32040;
  struct MonoGenericContainer * D.32042;
  unsigned int i.370;
  unsigned int D.32044;
  struct MonoType * * D.32045;
  int D.32048;
  struct MonoType * iftmp.371;
  <unnamed-unsigned:1> D.32052;
  <unnamed-unsigned:1> D.32053;
  <unnamed-unsigned:1> D.32059;
  int D.32060;
  struct MonoType * iftmp.372;
  <unnamed-unsigned:1> D.32062;
  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.32023 = type->type;
  if (D.32023 != 21) goto <D.32024>; else goto <D.32025>;
  <D.32024>:
  D.32026 = type;
  return D.32026;
  <D.32025>:
  gclass = type->data.generic_class;
  ginst = gclass->context.class_inst;
  D.32027 = BIT_FIELD_REF <*ginst, 8, 48>;
  D.32028 = D.32027 & 64;
  if (D.32028 == 0) goto <D.32029>; else goto <D.32030>;
  <D.32029>:
  D.32026 = type;
  return D.32026;
  <D.32030>:
  gtd = gclass->container_class;
  gcontainer = gtd->generic_container;
  D.32031 = ginst->type_argc;
  D.32032 = (unsigned int) D.32031;
  D.32033 = D.32032 * 4;
  argv = __builtin_alloca (D.32033);
  i = 0;
  goto <D.20754>;
  <D.20753>:
  {
    struct MonoType * t;
    struct MonoType * norm;

    t = ginst->type_argv[i];
    D.32036 = t->type;
    if (D.32036 != 19) goto <D.32034>; else goto <D.32037>;
    <D.32037>:
    D.32038 = t->data.generic_param;
    D.32039 = D.32038->num;
    D.32040 = (int) D.32039;
    if (D.32040 != i) goto <D.32034>; else goto <D.32041>;
    <D.32041>:
    D.32038 = t->data.generic_param;
    D.32042 = D.32038->owner;
    if (D.32042 != gcontainer) goto <D.32034>; else goto <D.32035>;
    <D.32034>:
    is_denorm_gtd = 0;
    <D.32035>:
    norm = mono_type_normalize (t);
    i.370 = (unsigned int) i;
    D.32044 = i.370 * 4;
    D.32045 = argv + D.32044;
    *D.32045 = norm;
    if (norm != t) goto <D.32046>; else goto <D.32047>;
    <D.32046>:
    requires_rebind = 1;
    <D.32047>:
  }
  i = i + 1;
  <D.20754>:
  D.32031 = ginst->type_argc;
  D.32048 = (int) D.32031;
  if (D.32048 > i) goto <D.20753>; else goto <D.20755>;
  <D.20755>:
  if (is_denorm_gtd != 0) goto <D.32049>; else goto <D.32050>;
  <D.32049>:
  D.32052 = type->byref;
  D.32053 = gtd->byval_arg.byref;
  if (D.32052 == D.32053) goto <D.32054>; else goto <D.32055>;
  <D.32054>:
  iftmp.371 = &gtd->byval_arg;
  goto <D.32056>;
  <D.32055>:
  iftmp.371 = &gtd->this_arg;
  <D.32056>:
  D.32026 = iftmp.371;
  return D.32026;
  <D.32050>:
  if (requires_rebind != 0) goto <D.32057>; else goto <D.32058>;
  <D.32057>:
  {
    struct MonoClass * klass;

    D.32059 = gclass->is_dynamic;
    D.32060 = (int) D.32059;
    D.32031 = ginst->type_argc;
    D.32048 = (int) D.32031;
    klass = mono_class_bind_generic_parameters (gtd, D.32048, argv, D.32060);
    D.32052 = type->byref;
    D.32062 = klass->byval_arg.byref;
    if (D.32052 == D.32062) goto <D.32063>; else goto <D.32064>;
    <D.32063>:
    iftmp.372 = &klass->byval_arg;
    goto <D.32065>;
    <D.32064>:
    iftmp.372 = &klass->this_arg;
    <D.32065>:
    D.32026 = iftmp.372;
    return D.32026;
  }
  <D.32058>:
  D.32026 = type;
  return D.32026;
}


verify_safe_for_managed_space (struct MonoType * type)
{
  unsigned char D.32067;
  int D.32068;
  gboolean D.32069;

  D.32067 = type->type;
  D.32068 = (int) D.32067;
  switch (D.32068) <default: <D.32070>, case 19: <D.20738>, case 30: <D.20739>>
  <D.20738>:
  <D.20739>:
  D.32069 = 1;
  return D.32069;
  <D.32070>:
  D.32069 = 1;
  return D.32069;
}


mono_method_get_object (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  unsigned char D.32072;
  unsigned char D.32073;
  union mono_mutex_t * D.32076;
  _Bool D.32079;
  long int D.32080;
  long int D.32081;
  struct MonoGHashTable * D.32084;
  struct MonoGHashTable * D.32087;
  _Bool D.32092;
  long int D.32093;
  long int D.32094;
  struct MonoReflectionMethod * D.32097;
  _Bool D.32100;
  long int D.32101;
  long int D.32102;
  const char * D.32108;
  char D.32109;
  int D.20800;
  int iftmp.373;
  int D.20799;
  const char[6] * D.32114;
  unsigned char D.32115;
  int D.32116;
  unsigned char D.32117;
  int D.32118;
  _Bool D.32119;
  _Bool D.32120;
  _Bool D.32121;
  const unsigned char * D.32124;
  unsigned char D.32125;
  int D.32126;
  const unsigned char * D.32127;
  unsigned char D.32128;
  int D.32129;
  _Bool D.32130;
  _Bool D.32131;
  const unsigned char * D.32134;
  unsigned char D.32135;
  int D.32136;
  const unsigned char * D.32137;
  unsigned char D.32138;
  int D.32139;
  _Bool D.32140;
  _Bool D.32141;
  const unsigned char * D.32144;
  unsigned char D.32145;
  int D.32146;
  const unsigned char * D.32147;
  unsigned char D.32148;
  int D.32149;
  int D.20809;
  int iftmp.374;
  int D.20808;
  const char[7] * D.32155;
  unsigned char D.32156;
  int D.32157;
  unsigned char D.32158;
  int D.32159;
  _Bool D.32160;
  _Bool D.32161;
  _Bool D.32162;
  const unsigned char * D.32165;
  unsigned char D.32166;
  int D.32167;
  const unsigned char * D.32168;
  unsigned char D.32169;
  int D.32170;
  _Bool D.32171;
  _Bool D.32172;
  const unsigned char * D.32175;
  unsigned char D.32176;
  int D.32177;
  const unsigned char * D.32178;
  unsigned char D.32179;
  int D.32180;
  _Bool D.32181;
  _Bool D.32182;
  const unsigned char * D.32185;
  unsigned char D.32186;
  int D.32187;
  const unsigned char * D.32188;
  unsigned char D.32189;
  int D.32190;
  struct MonoClass * System_Reflection_MonoGenericCMethod.375;
  struct MonoImage * D.32195;
  struct MonoClass * System_Reflection_MonoGenericCMethod.376;
  struct MonoClass * System_Reflection_MonoGenericMethod.377;
  struct MonoClass * System_Reflection_MonoGenericMethod.378;
  struct MonoString * D.32201;
  struct MonoString * * D.32202;
  struct MonoType * D.32203;
  struct MonoReflectionType * D.32204;
  struct MonoReflectionType * * D.32205;
  _Bool D.32208;
  long int D.32209;
  long int D.32210;
  struct MonoGHashTable * D.32215;
  struct MonoMemPool * D.32218;
  _Bool D.32221;
  long int D.32222;
  long int D.32223;
  _Bool D.32230;
  long int D.32231;
  long int D.32232;
  struct MonoGHashTable * D.32237;
  _Bool D.32242;
  long int D.32243;
  long int D.32244;
  _Bool D.32249;
  long int D.32250;
  long int D.32251;
  int D.20828;
  int iftmp.379;
  int D.20827;
  unsigned char D.32261;
  int D.32262;
  _Bool D.32263;
  _Bool D.32264;
  _Bool D.32265;
  const unsigned char * D.32268;
  unsigned char D.32269;
  int D.32270;
  _Bool D.32271;
  _Bool D.32272;
  const unsigned char * D.32275;
  unsigned char D.32276;
  int D.32277;
  _Bool D.32278;
  _Bool D.32279;
  const unsigned char * D.32282;
  unsigned char D.32283;
  int D.32284;
  int D.20837;
  int iftmp.380;
  int D.20836;
  unsigned char D.32290;
  int D.32291;
  _Bool D.32292;
  _Bool D.32293;
  _Bool D.32294;
  const unsigned char * D.32297;
  unsigned char D.32298;
  int D.32299;
  _Bool D.32300;
  _Bool D.32301;
  const unsigned char * D.32304;
  unsigned char D.32305;
  int D.32306;
  _Bool D.32307;
  _Bool D.32308;
  const unsigned char * D.32311;
  unsigned char D.32312;
  int D.32313;
  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.32323;
  struct MonoReflectionType * * D.32324;
  _Bool D.32327;
  long int D.32328;
  long int D.32329;
  struct MonoGHashTable * D.32334;
  _Bool D.32339;
  long int D.32340;
  long int D.32341;
  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.32072 = BIT_FIELD_REF <*method, 8, 168>;
  D.32073 = D.32072 & 16;
  if (D.32073 != 0) goto <D.32074>; else goto <D.32075>;
  <D.32074>:
  {
    struct MonoReflectionGenericMethod * gret;

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

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

            D.32076 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.32076);
            if (ret != 0) goto <D.32077>; else goto <D.32078>;
            <D.32077>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.32078>:
            D.32079 = ret != 0;
            D.32080 = (long int) D.32079;
            D.32081 = __builtin_expect (D.32080, 0);
            if (D.32081 != 0) goto <D.32082>; else goto <D.32083>;
            <D.32082>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.32083>:
          }
          D.32084 = domain->refobject_hash;
          if (D.32084 == 0B) goto <D.32085>; else goto <D.32086>;
          <D.32085>:
          D.32087 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.32087;
          <D.32086>:
          D.32084 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.32084, &e);
          if (_obj != 0B) goto <D.32088>; else goto <D.32089>;
          <D.32088>:
          {
            int ret;

            D.32076 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.32076);
            if (ret != 0) goto <D.32090>; else goto <D.32091>;
            <D.32090>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.32091>:
            D.32092 = ret != 0;
            D.32093 = (long int) D.32092;
            D.32094 = __builtin_expect (D.32093, 0);
            if (D.32094 != 0) goto <D.32095>; else goto <D.32096>;
            <D.32095>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.32096>:
          }
          D.32097 = _obj;
          return D.32097;
          <D.32089>:
          {
            int ret;

            D.32076 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.32076);
            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", 6565, "ret == 0");
            <D.32104>:
          }
        }
      finally
        {
          e = {CLOBBER};
        }
    }
    D.32108 = method->name;
    D.32109 = *D.32108;
    if (D.32109 == 46) goto <D.32110>; else goto <D.32105>;
    <D.32110>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.32114 = ".ctor";
        D.32115 = MEM[(const unsigned char *)D.32114];
        D.32116 = (int) D.32115;
        D.32117 = *__s2;
        D.32118 = (int) D.32117;
        __result = D.32116 - D.32118;
        {
          D.32119 = __s2_len != 0;
          D.32120 = __result == 0;
          D.32121 = D.32119 & D.32120;
          if (D.32121 != 0) goto <D.32122>; else goto <D.32123>;
          <D.32122>:
          D.32124 = &MEM[(void *)".ctor" + 1B];
          D.32125 = *D.32124;
          D.32126 = (int) D.32125;
          D.32127 = __s2 + 1;
          D.32128 = *D.32127;
          D.32129 = (int) D.32128;
          __result = D.32126 - D.32129;
          D.32130 = __s2_len > 1;
          D.32120 = __result == 0;
          D.32131 = D.32130 & D.32120;
          if (D.32131 != 0) goto <D.32132>; else goto <D.32133>;
          <D.32132>:
          D.32134 = &MEM[(void *)".ctor" + 2B];
          D.32135 = *D.32134;
          D.32136 = (int) D.32135;
          D.32137 = __s2 + 2;
          D.32138 = *D.32137;
          D.32139 = (int) D.32138;
          __result = D.32136 - D.32139;
          D.32140 = __s2_len > 2;
          D.32120 = __result == 0;
          D.32141 = D.32140 & D.32120;
          if (D.32141 != 0) goto <D.32142>; else goto <D.32143>;
          <D.32142>:
          D.32144 = &MEM[(void *)".ctor" + 3B];
          D.32145 = *D.32144;
          D.32146 = (int) D.32145;
          D.32147 = __s2 + 3;
          D.32148 = *D.32147;
          D.32149 = (int) D.32148;
          __result = D.32146 - D.32149;
          <D.32143>:
          <D.32133>:
          <D.32123>:
        }
        D.20799 = __result;
      }
      iftmp.373 = -D.20799;
      goto <D.32150>;
      <D.32113>:
      D.32108 = method->name;
      iftmp.373 = __builtin_strcmp (D.32108, ".ctor");
      <D.32150>:
      D.20800 = iftmp.373;
    }
    if (D.20800 == 0) goto <D.32106>; else goto <D.32151>;
    <D.32151>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.32155 = ".cctor";
        D.32156 = MEM[(const unsigned char *)D.32155];
        D.32157 = (int) D.32156;
        D.32158 = *__s2;
        D.32159 = (int) D.32158;
        __result = D.32157 - D.32159;
        {
          D.32160 = __s2_len != 0;
          D.32161 = __result == 0;
          D.32162 = D.32160 & D.32161;
          if (D.32162 != 0) goto <D.32163>; else goto <D.32164>;
          <D.32163>:
          D.32165 = &MEM[(void *)".cctor" + 1B];
          D.32166 = *D.32165;
          D.32167 = (int) D.32166;
          D.32168 = __s2 + 1;
          D.32169 = *D.32168;
          D.32170 = (int) D.32169;
          __result = D.32167 - D.32170;
          D.32171 = __s2_len > 1;
          D.32161 = __result == 0;
          D.32172 = D.32171 & D.32161;
          if (D.32172 != 0) goto <D.32173>; else goto <D.32174>;
          <D.32173>:
          D.32175 = &MEM[(void *)".cctor" + 2B];
          D.32176 = *D.32175;
          D.32177 = (int) D.32176;
          D.32178 = __s2 + 2;
          D.32179 = *D.32178;
          D.32180 = (int) D.32179;
          __result = D.32177 - D.32180;
          D.32181 = __s2_len > 2;
          D.32161 = __result == 0;
          D.32182 = D.32181 & D.32161;
          if (D.32182 != 0) goto <D.32183>; else goto <D.32184>;
          <D.32183>:
          D.32185 = &MEM[(void *)".cctor" + 3B];
          D.32186 = *D.32185;
          D.32187 = (int) D.32186;
          D.32188 = __s2 + 3;
          D.32189 = *D.32188;
          D.32190 = (int) D.32189;
          __result = D.32187 - D.32190;
          <D.32184>:
          <D.32174>:
          <D.32164>:
        }
        D.20808 = __result;
      }
      iftmp.374 = -D.20808;
      goto <D.32191>;
      <D.32154>:
      D.32108 = method->name;
      iftmp.374 = __builtin_strcmp (D.32108, ".cctor");
      <D.32191>:
      D.20809 = iftmp.374;
    }
    if (D.20809 == 0) goto <D.32106>; else goto <D.32105>;
    <D.32106>:
    System_Reflection_MonoGenericCMethod.375 = System_Reflection_MonoGenericCMethod;
    if (System_Reflection_MonoGenericCMethod.375 == 0B) goto <D.32193>; else goto <D.32194>;
    <D.32193>:
    D.32195 = mono_defaults.corlib;
    System_Reflection_MonoGenericCMethod.376 = mono_class_from_name (D.32195, "System.Reflection", "MonoGenericCMethod");
    System_Reflection_MonoGenericCMethod = System_Reflection_MonoGenericCMethod.376;
    <D.32194>:
    klass = System_Reflection_MonoGenericCMethod;
    goto <D.32107>;
    <D.32105>:
    System_Reflection_MonoGenericMethod.377 = System_Reflection_MonoGenericMethod;
    if (System_Reflection_MonoGenericMethod.377 == 0B) goto <D.32198>; else goto <D.32199>;
    <D.32198>:
    D.32195 = mono_defaults.corlib;
    System_Reflection_MonoGenericMethod.378 = mono_class_from_name (D.32195, "System.Reflection", "MonoGenericMethod");
    System_Reflection_MonoGenericMethod = System_Reflection_MonoGenericMethod.378;
    <D.32199>:
    klass = System_Reflection_MonoGenericMethod;
    <D.32107>:
    gret = mono_object_new (domain, klass);
    gret->method.method = method;
    D.32108 = method->name;
    D.32201 = mono_string_new (domain, D.32108);
    D.32202 = &gret->method.name;
    mono_gc_wbarrier_set_field (gret, D.32202, D.32201);
    D.32203 = &refclass->byval_arg;
    D.32204 = mono_type_get_object (domain, D.32203);
    D.32205 = &gret->method.reftype;
    mono_gc_wbarrier_set_field (gret, D.32205, D.32204);
    {
      struct MonoReflectionMethod * _obj;
      struct ReflectedEntry pe;

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

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

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

            D.32076 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.32076);
            if (ret != 0) goto <D.32219>; else goto <D.32220>;
            <D.32219>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.32220>:
            D.32221 = ret != 0;
            D.32222 = (long int) D.32221;
            D.32223 = __builtin_expect (D.32222, 0);
            if (D.32223 != 0) goto <D.32224>; else goto <D.32225>;
            <D.32224>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.32225>:
          }
          D.32097 = _obj;
          return D.32097;
        }
      finally
        {
          pe = {CLOBBER};
        }
    }
  }
  <D.32075>:
  if (refclass == 0B) goto <D.32226>; else goto <D.32227>;
  <D.32226>:
  refclass = method->klass;
  <D.32227>:
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry e;

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

          D.32076 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32076);
          if (ret != 0) goto <D.32228>; else goto <D.32229>;
          <D.32228>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32229>:
          D.32230 = ret != 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", 6585, "ret == 0");
          <D.32234>:
        }
        D.32084 = domain->refobject_hash;
        if (D.32084 == 0B) goto <D.32235>; else goto <D.32236>;
        <D.32235>:
        D.32237 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32237;
        <D.32236>:
        D.32084 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32084, &e);
        if (_obj != 0B) goto <D.32238>; else goto <D.32239>;
        <D.32238>:
        {
          int ret;

          D.32076 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32076);
          if (ret != 0) goto <D.32240>; else goto <D.32241>;
          <D.32240>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32241>:
          D.32242 = ret != 0;
          D.32243 = (long int) D.32242;
          D.32244 = __builtin_expect (D.32243, 0);
          if (D.32244 != 0) goto <D.32245>; else goto <D.32246>;
          <D.32245>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32246>:
        }
        D.32097 = _obj;
        return D.32097;
        <D.32239>:
        {
          int ret;

          D.32076 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32076);
          if (ret != 0) goto <D.32247>; else goto <D.32248>;
          <D.32247>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32248>:
          D.32249 = ret != 0;
          D.32250 = (long int) D.32249;
          D.32251 = __builtin_expect (D.32250, 0);
          if (D.32251 != 0) goto <D.32252>; else goto <D.32253>;
          <D.32252>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32253>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.32108 = method->name;
  D.32109 = *D.32108;
  if (D.32109 == 46) goto <D.32257>; else goto <D.32254>;
  <D.32257>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32114 = ".ctor";
      D.32115 = MEM[(const unsigned char *)D.32114];
      D.32116 = (int) D.32115;
      D.32261 = *__s2;
      D.32262 = (int) D.32261;
      __result = D.32116 - D.32262;
      {
        D.32263 = __s2_len != 0;
        D.32264 = __result == 0;
        D.32265 = D.32263 & D.32264;
        if (D.32265 != 0) goto <D.32266>; else goto <D.32267>;
        <D.32266>:
        D.32124 = &MEM[(void *)".ctor" + 1B];
        D.32125 = *D.32124;
        D.32126 = (int) D.32125;
        D.32268 = __s2 + 1;
        D.32269 = *D.32268;
        D.32270 = (int) D.32269;
        __result = D.32126 - D.32270;
        D.32271 = __s2_len > 1;
        D.32264 = __result == 0;
        D.32272 = D.32271 & D.32264;
        if (D.32272 != 0) goto <D.32273>; else goto <D.32274>;
        <D.32273>:
        D.32134 = &MEM[(void *)".ctor" + 2B];
        D.32135 = *D.32134;
        D.32136 = (int) D.32135;
        D.32275 = __s2 + 2;
        D.32276 = *D.32275;
        D.32277 = (int) D.32276;
        __result = D.32136 - D.32277;
        D.32278 = __s2_len > 2;
        D.32264 = __result == 0;
        D.32279 = D.32278 & D.32264;
        if (D.32279 != 0) goto <D.32280>; else goto <D.32281>;
        <D.32280>:
        D.32144 = &MEM[(void *)".ctor" + 3B];
        D.32145 = *D.32144;
        D.32146 = (int) D.32145;
        D.32282 = __s2 + 3;
        D.32283 = *D.32282;
        D.32284 = (int) D.32283;
        __result = D.32146 - D.32284;
        <D.32281>:
        <D.32274>:
        <D.32267>:
      }
      D.20827 = __result;
    }
    iftmp.379 = -D.20827;
    goto <D.32285>;
    <D.32260>:
    D.32108 = method->name;
    iftmp.379 = __builtin_strcmp (D.32108, ".ctor");
    <D.32285>:
    D.20828 = iftmp.379;
  }
  if (D.20828 == 0) goto <D.32255>; else goto <D.32286>;
  <D.32286>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32155 = ".cctor";
      D.32156 = MEM[(const unsigned char *)D.32155];
      D.32157 = (int) D.32156;
      D.32290 = *__s2;
      D.32291 = (int) D.32290;
      __result = D.32157 - D.32291;
      {
        D.32292 = __s2_len != 0;
        D.32293 = __result == 0;
        D.32294 = D.32292 & D.32293;
        if (D.32294 != 0) goto <D.32295>; else goto <D.32296>;
        <D.32295>:
        D.32165 = &MEM[(void *)".cctor" + 1B];
        D.32166 = *D.32165;
        D.32167 = (int) D.32166;
        D.32297 = __s2 + 1;
        D.32298 = *D.32297;
        D.32299 = (int) D.32298;
        __result = D.32167 - D.32299;
        D.32300 = __s2_len > 1;
        D.32293 = __result == 0;
        D.32301 = D.32300 & D.32293;
        if (D.32301 != 0) goto <D.32302>; else goto <D.32303>;
        <D.32302>:
        D.32175 = &MEM[(void *)".cctor" + 2B];
        D.32176 = *D.32175;
        D.32177 = (int) D.32176;
        D.32304 = __s2 + 2;
        D.32305 = *D.32304;
        D.32306 = (int) D.32305;
        __result = D.32177 - D.32306;
        D.32307 = __s2_len > 2;
        D.32293 = __result == 0;
        D.32308 = D.32307 & D.32293;
        if (D.32308 != 0) goto <D.32309>; else goto <D.32310>;
        <D.32309>:
        D.32185 = &MEM[(void *)".cctor" + 3B];
        D.32186 = *D.32185;
        D.32187 = (int) D.32186;
        D.32311 = __s2 + 3;
        D.32312 = *D.32311;
        D.32313 = (int) D.32312;
        __result = D.32187 - D.32313;
        <D.32310>:
        <D.32303>:
        <D.32296>:
      }
      D.20836 = __result;
    }
    iftmp.380 = -D.20836;
    goto <D.32314>;
    <D.32289>:
    D.32108 = method->name;
    iftmp.380 = __builtin_strcmp (D.32108, ".cctor");
    <D.32314>:
    D.20837 = iftmp.380;
  }
  if (D.20837 == 0) goto <D.32255>; else goto <D.32254>;
  <D.32255>:
  System_Reflection_MonoCMethod.381 = System_Reflection_MonoCMethod;
  if (System_Reflection_MonoCMethod.381 == 0B) goto <D.32316>; else goto <D.32317>;
  <D.32316>:
  D.32195 = mono_defaults.corlib;
  System_Reflection_MonoCMethod.382 = mono_class_from_name (D.32195, "System.Reflection", "MonoCMethod");
  System_Reflection_MonoCMethod = System_Reflection_MonoCMethod.382;
  <D.32317>:
  klass = System_Reflection_MonoCMethod;
  goto <D.32256>;
  <D.32254>:
  System_Reflection_MonoMethod.383 = System_Reflection_MonoMethod;
  if (System_Reflection_MonoMethod.383 == 0B) goto <D.32320>; else goto <D.32321>;
  <D.32320>:
  D.32195 = mono_defaults.corlib;
  System_Reflection_MonoMethod.384 = mono_class_from_name (D.32195, "System.Reflection", "MonoMethod");
  System_Reflection_MonoMethod = System_Reflection_MonoMethod.384;
  <D.32321>:
  klass = System_Reflection_MonoMethod;
  <D.32256>:
  ret = mono_object_new (domain, klass);
  ret->method = method;
  D.32203 = &refclass->byval_arg;
  D.32323 = mono_type_get_object (domain, D.32203);
  D.32324 = &ret->reftype;
  mono_gc_wbarrier_set_field (ret, D.32324, D.32323);
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry pe;

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

          D.32076 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32076);
          if (ret != 0) goto <D.32325>; else goto <D.32326>;
          <D.32325>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32326>:
          D.32327 = ret != 0;
          D.32328 = (long int) D.32327;
          D.32329 = __builtin_expect (D.32328, 0);
          if (D.32329 != 0) goto <D.32330>; else goto <D.32331>;
          <D.32330>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32331>:
        }
        D.32084 = domain->refobject_hash;
        if (D.32084 == 0B) goto <D.32332>; else goto <D.32333>;
        <D.32332>:
        D.32334 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32334;
        <D.32333>:
        D.32084 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32084, &pe);
        if (_obj == 0B) goto <D.32335>; else goto <D.32336>;
        <D.32335>:
        {
          struct ReflectedEntry * e;

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

          D.32076 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32076);
          if (ret != 0) goto <D.32337>; else goto <D.32338>;
          <D.32337>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32338>:
          D.32339 = ret != 0;
          D.32340 = (long int) D.32339;
          D.32341 = __builtin_expect (D.32340, 0);
          if (D.32341 != 0) goto <D.32342>; else goto <D.32343>;
          <D.32342>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32343>:
        }
        D.32097 = _obj;
        return D.32097;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_method_clear_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.32351;
  unsigned char D.32352;
  _Bool D.32353;
  long int D.32354;
  long int D.32355;
  struct MonoMethodSignature * * D.32358;
  struct MonoClass * klass;

  D.32351 = BIT_FIELD_REF <*method, 8, 168>;
  D.32352 = D.32351 & 2;
  D.32353 = D.32352 == 0;
  D.32354 = (long int) D.32353;
  D.32355 = __builtin_expect (D.32354, 0);
  if (D.32355 != 0) goto <D.32356>; else goto <D.32357>;
  <D.32356>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6611, "method->dynamic");
  <D.32357>:
  klass = method->klass;
  goto <D.20849>;
  <D.20848>:
  clear_cached_object (domain, method, klass);
  klass = klass->parent;
  <D.20849>:
  if (klass != 0B) goto <D.20848>; else goto <D.20850>;
  <D.20850>:
  D.32358 = &method->signature;
  clear_cached_object (domain, D.32358, 0B);
  klass = method->klass;
  goto <D.20852>;
  <D.20851>:
  D.32358 = &method->signature;
  clear_cached_object (domain, D.32358, klass);
  klass = klass->parent;
  <D.20852>:
  if (klass != 0B) goto <D.20851>; else goto <D.20853>;
  <D.20853>:
}


clear_cached_object (struct MonoDomain * domain, void * o, struct MonoClass * klass)
{
  union mono_mutex_t * D.32359;
  _Bool D.32362;
  long int D.32363;
  long int D.32364;
  struct MonoGHashTable * D.32367;
  int D.32370;
  _Bool D.32375;
  long int D.32376;
  long int D.32377;

  {
    int ret;

    D.32359 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32359);
    if (ret != 0) goto <D.32360>; else goto <D.32361>;
    <D.32360>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32361>:
    D.32362 = ret != 0;
    D.32363 = (long int) D.32362;
    D.32364 = __builtin_expect (D.32363, 0);
    if (D.32364 != 0) goto <D.32365>; else goto <D.32366>;
    <D.32365>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6127, "ret == 0");
    <D.32366>:
  }
  D.32367 = domain->refobject_hash;
  if (D.32367 != 0B) goto <D.32368>; else goto <D.32369>;
  <D.32368>:
  {
    struct ReflectedEntry pe;
    void * orig_pe;
    void * orig_value;

    try
      {
        pe.item = o;
        pe.refclass = klass;
        D.32367 = domain->refobject_hash;
        D.32370 = mono_g_hash_table_lookup_extended (D.32367, &pe, &orig_pe, &orig_value);
        if (D.32370 != 0) goto <D.32371>; else goto <D.32372>;
        <D.32371>:
        D.32367 = domain->refobject_hash;
        mono_g_hash_table_remove (D.32367, &pe);
        <D.32372>:
      }
    finally
      {
        pe = {CLOBBER};
        orig_pe = {CLOBBER};
        orig_value = {CLOBBER};
      }
  }
  <D.32369>:
  {
    int ret;

    D.32359 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32359);
    if (ret != 0) goto <D.32373>; else goto <D.32374>;
    <D.32373>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32374>:
    D.32375 = ret != 0;
    D.32376 = (long int) D.32375;
    D.32377 = __builtin_expect (D.32376, 0);
    if (D.32377 != 0) goto <D.32378>; else goto <D.32379>;
    <D.32378>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6139, "ret == 0");
    <D.32379>:
  }
}


mono_field_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoClassField * field)
{
  union mono_mutex_t * D.32380;
  _Bool D.32383;
  long int D.32384;
  long int D.32385;
  struct MonoGHashTable * D.32388;
  struct MonoGHashTable * D.32391;
  _Bool D.32396;
  long int D.32397;
  long int D.32398;
  struct MonoReflectionField * D.32401;
  _Bool D.32404;
  long int D.32405;
  long int D.32406;
  struct MonoClass * monofield_klass.385;
  struct MonoImage * D.32412;
  struct MonoClass * monofield_klass.386;
  const char * D.32414;
  struct MonoString * D.32415;
  struct MonoString * * D.32416;
  int D.32417;
  struct MonoType * D.32420;
  short unsigned int D.32421;
  unsigned int D.32422;
  struct MonoType * D.32423;
  struct MonoReflectionType * D.32424;
  struct MonoReflectionType * * D.32425;
  struct MonoReflectionType * D.32429;
  unsigned int D.32430;
  _Bool D.32433;
  long int D.32434;
  long int D.32435;
  struct MonoGHashTable * D.32440;
  struct MonoMemPool * D.32443;
  _Bool D.32446;
  long int D.32447;
  long int D.32448;
  struct MonoReflectionField * res;
  static struct MonoClass * monofield_klass;

  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry e;

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

          D.32380 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32380);
          if (ret != 0) goto <D.32381>; else goto <D.32382>;
          <D.32381>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32382>:
          D.32383 = ret != 0;
          D.32384 = (long int) D.32383;
          D.32385 = __builtin_expect (D.32384, 0);
          if (D.32385 != 0) goto <D.32386>; else goto <D.32387>;
          <D.32386>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32387>:
        }
        D.32388 = domain->refobject_hash;
        if (D.32388 == 0B) goto <D.32389>; else goto <D.32390>;
        <D.32389>:
        D.32391 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32391;
        <D.32390>:
        D.32388 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32388, &e);
        if (_obj != 0B) goto <D.32392>; else goto <D.32393>;
        <D.32392>:
        {
          int ret;

          D.32380 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32380);
          if (ret != 0) goto <D.32394>; else goto <D.32395>;
          <D.32394>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32395>:
          D.32396 = ret != 0;
          D.32397 = (long int) D.32396;
          D.32398 = __builtin_expect (D.32397, 0);
          if (D.32398 != 0) goto <D.32399>; else goto <D.32400>;
          <D.32399>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32400>:
        }
        D.32401 = _obj;
        return D.32401;
        <D.32393>:
        {
          int ret;

          D.32380 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32380);
          if (ret != 0) goto <D.32402>; else goto <D.32403>;
          <D.32402>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32403>:
          D.32404 = ret != 0;
          D.32405 = (long int) D.32404;
          D.32406 = __builtin_expect (D.32405, 0);
          if (D.32406 != 0) goto <D.32407>; else goto <D.32408>;
          <D.32407>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.32408>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monofield_klass.385 = monofield_klass;
  if (monofield_klass.385 == 0B) goto <D.32410>; else goto <D.32411>;
  <D.32410>:
  D.32412 = mono_defaults.corlib;
  monofield_klass.386 = mono_class_from_name (D.32412, "System.Reflection", "MonoField");
  monofield_klass = monofield_klass.386;
  <D.32411>:
  monofield_klass.385 = monofield_klass;
  res = mono_object_new (domain, monofield_klass.385);
  res->klass = klass;
  res->field = field;
  D.32414 = mono_field_get_name (field);
  D.32415 = mono_string_new (domain, D.32414);
  D.32416 = &res->name;
  mono_gc_wbarrier_set_field (res, D.32416, D.32415);
  D.32417 = is_field_on_inst (field);
  if (D.32417 != 0) goto <D.32418>; else goto <D.32419>;
  <D.32418>:
  D.32420 = get_field_on_inst_generic_type (field);
  D.32421 = D.32420->attrs;
  D.32422 = (unsigned int) D.32421;
  res->attrs = D.32422;
  D.32423 = field->type;
  D.32424 = mono_type_get_object (domain, D.32423);
  D.32425 = &res->type;
  mono_gc_wbarrier_set_field (res, D.32425, D.32424);
  goto <D.32426>;
  <D.32419>:
  D.32423 = field->type;
  if (D.32423 != 0B) goto <D.32427>; else goto <D.32428>;
  <D.32427>:
  D.32423 = field->type;
  D.32429 = mono_type_get_object (domain, D.32423);
  D.32425 = &res->type;
  mono_gc_wbarrier_set_field (res, D.32425, D.32429);
  <D.32428>:
  D.32430 = mono_field_get_flags (field);
  res->attrs = D.32430;
  <D.32426>:
  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry pe;

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

          D.32380 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32380);
          if (ret != 0) goto <D.32431>; else goto <D.32432>;
          <D.32431>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32432>:
          D.32433 = ret != 0;
          D.32434 = (long int) D.32433;
          D.32435 = __builtin_expect (D.32434, 0);
          if (D.32435 != 0) goto <D.32436>; else goto <D.32437>;
          <D.32436>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.32437>:
        }
        D.32388 = domain->refobject_hash;
        if (D.32388 == 0B) goto <D.32438>; else goto <D.32439>;
        <D.32438>:
        D.32440 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32440;
        <D.32439>:
        D.32388 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32388, &pe);
        if (_obj == 0B) goto <D.32441>; else goto <D.32442>;
        <D.32441>:
        {
          struct ReflectedEntry * e;

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

          D.32380 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32380);
          if (ret != 0) goto <D.32444>; else goto <D.32445>;
          <D.32444>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32445>:
          D.32446 = ret != 0;
          D.32447 = (long int) D.32446;
          D.32448 = __builtin_expect (D.32447, 0);
          if (D.32448 != 0) goto <D.32449>; else goto <D.32450>;
          <D.32449>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.32450>:
        }
        D.32401 = _obj;
        return D.32401;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_property_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoProperty * property)
{
  union mono_mutex_t * D.32455;
  _Bool D.32458;
  long int D.32459;
  long int D.32460;
  struct MonoGHashTable * D.32463;
  struct MonoGHashTable * D.32466;
  _Bool D.32471;
  long int D.32472;
  long int D.32473;
  struct MonoReflectionProperty * D.32476;
  _Bool D.32479;
  long int D.32480;
  long int D.32481;
  struct MonoClass * monoproperty_klass.387;
  struct MonoImage * D.32487;
  struct MonoClass * monoproperty_klass.388;
  _Bool D.32491;
  long int D.32492;
  long int D.32493;
  struct MonoGHashTable * D.32498;
  struct MonoMemPool * D.32501;
  _Bool D.32504;
  long int D.32505;
  long int D.32506;
  struct MonoReflectionProperty * res;
  static struct MonoClass * monoproperty_klass;

  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry e;

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

          D.32455 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32455);
          if (ret != 0) goto <D.32456>; else goto <D.32457>;
          <D.32456>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32457>:
          D.32458 = ret != 0;
          D.32459 = (long int) D.32458;
          D.32460 = __builtin_expect (D.32459, 0);
          if (D.32460 != 0) goto <D.32461>; else goto <D.32462>;
          <D.32461>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.32462>:
        }
        D.32463 = domain->refobject_hash;
        if (D.32463 == 0B) goto <D.32464>; else goto <D.32465>;
        <D.32464>:
        D.32466 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32466;
        <D.32465>:
        D.32463 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32463, &e);
        if (_obj != 0B) goto <D.32467>; else goto <D.32468>;
        <D.32467>:
        {
          int ret;

          D.32455 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32455);
          if (ret != 0) goto <D.32469>; else goto <D.32470>;
          <D.32469>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32470>:
          D.32471 = ret != 0;
          D.32472 = (long int) D.32471;
          D.32473 = __builtin_expect (D.32472, 0);
          if (D.32473 != 0) goto <D.32474>; else goto <D.32475>;
          <D.32474>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.32475>:
        }
        D.32476 = _obj;
        return D.32476;
        <D.32468>:
        {
          int ret;

          D.32455 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32455);
          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", 6676, "ret == 0");
          <D.32483>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoproperty_klass.387 = monoproperty_klass;
  if (monoproperty_klass.387 == 0B) goto <D.32485>; else goto <D.32486>;
  <D.32485>:
  D.32487 = mono_defaults.corlib;
  monoproperty_klass.388 = mono_class_from_name (D.32487, "System.Reflection", "MonoProperty");
  monoproperty_klass = monoproperty_klass.388;
  <D.32486>:
  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.32455 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32455);
          if (ret != 0) goto <D.32489>; else goto <D.32490>;
          <D.32489>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32490>:
          D.32491 = ret != 0;
          D.32492 = (long int) D.32491;
          D.32493 = __builtin_expect (D.32492, 0);
          if (D.32493 != 0) goto <D.32494>; else goto <D.32495>;
          <D.32494>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.32495>:
        }
        D.32463 = domain->refobject_hash;
        if (D.32463 == 0B) goto <D.32496>; else goto <D.32497>;
        <D.32496>:
        D.32498 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32498;
        <D.32497>:
        D.32463 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32463, &pe);
        if (_obj == 0B) goto <D.32499>; else goto <D.32500>;
        <D.32499>:
        {
          struct ReflectedEntry * e;

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

          D.32455 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32455);
          if (ret != 0) goto <D.32502>; else goto <D.32503>;
          <D.32502>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32503>:
          D.32504 = ret != 0;
          D.32505 = (long int) D.32504;
          D.32506 = __builtin_expect (D.32505, 0);
          if (D.32506 != 0) goto <D.32507>; else goto <D.32508>;
          <D.32507>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.32508>:
        }
        D.32476 = _obj;
        return D.32476;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_event_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoEvent * event)
{
  union mono_mutex_t * D.32513;
  _Bool D.32516;
  long int D.32517;
  long int D.32518;
  struct MonoGHashTable * D.32521;
  struct MonoGHashTable * D.32524;
  _Bool D.32529;
  long int D.32530;
  long int D.32531;
  struct MonoReflectionEvent * D.32534;
  _Bool D.32537;
  long int D.32538;
  long int D.32539;
  struct MonoClass * monoevent_klass.389;
  struct MonoImage * D.32545;
  struct MonoClass * monoevent_klass.390;
  _Bool D.32549;
  long int D.32550;
  long int D.32551;
  struct MonoGHashTable * D.32556;
  struct MonoMemPool * D.32559;
  _Bool D.32562;
  long int D.32563;
  long int D.32564;
  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.32513 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32513);
          if (ret != 0) goto <D.32514>; else goto <D.32515>;
          <D.32514>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32515>:
          D.32516 = ret != 0;
          D.32517 = (long int) D.32516;
          D.32518 = __builtin_expect (D.32517, 0);
          if (D.32518 != 0) goto <D.32519>; else goto <D.32520>;
          <D.32519>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32520>:
        }
        D.32521 = domain->refobject_hash;
        if (D.32521 == 0B) goto <D.32522>; else goto <D.32523>;
        <D.32522>:
        D.32524 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32524;
        <D.32523>:
        D.32521 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32521, &e);
        if (_obj != 0B) goto <D.32525>; else goto <D.32526>;
        <D.32525>:
        {
          int ret;

          D.32513 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32513);
          if (ret != 0) goto <D.32527>; else goto <D.32528>;
          <D.32527>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32528>:
          D.32529 = ret != 0;
          D.32530 = (long int) D.32529;
          D.32531 = __builtin_expect (D.32530, 0);
          if (D.32531 != 0) goto <D.32532>; else goto <D.32533>;
          <D.32532>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32533>:
        }
        D.32534 = _obj;
        return D.32534;
        <D.32526>:
        {
          int ret;

          D.32513 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32513);
          if (ret != 0) goto <D.32535>; else goto <D.32536>;
          <D.32535>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32536>:
          D.32537 = ret != 0;
          D.32538 = (long int) D.32537;
          D.32539 = __builtin_expect (D.32538, 0);
          if (D.32539 != 0) goto <D.32540>; else goto <D.32541>;
          <D.32540>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.32541>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoevent_klass.389 = monoevent_klass;
  if (monoevent_klass.389 == 0B) goto <D.32543>; else goto <D.32544>;
  <D.32543>:
  D.32545 = mono_defaults.corlib;
  monoevent_klass.390 = mono_class_from_name (D.32545, "System.Reflection", "MonoEvent");
  monoevent_klass = monoevent_klass.390;
  <D.32544>:
  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.32513 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32513);
          if (ret != 0) goto <D.32547>; else goto <D.32548>;
          <D.32547>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32548>:
          D.32549 = ret != 0;
          D.32550 = (long int) D.32549;
          D.32551 = __builtin_expect (D.32550, 0);
          if (D.32551 != 0) goto <D.32552>; else goto <D.32553>;
          <D.32552>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.32553>:
        }
        D.32521 = domain->refobject_hash;
        if (D.32521 == 0B) goto <D.32554>; else goto <D.32555>;
        <D.32554>:
        D.32556 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32556;
        <D.32555>:
        D.32521 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32521, &pe);
        if (_obj == 0B) goto <D.32557>; else goto <D.32558>;
        <D.32557>:
        {
          struct ReflectedEntry * e;

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

          D.32513 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32513);
          if (ret != 0) goto <D.32560>; else goto <D.32561>;
          <D.32560>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32561>:
          D.32562 = ret != 0;
          D.32563 = (long int) D.32562;
          D.32564 = __builtin_expect (D.32563, 0);
          if (D.32564 != 0) goto <D.32565>; else goto <D.32566>;
          <D.32565>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.32566>:
        }
        D.32534 = _obj;
        return D.32534;
      }
    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.32574;
  int D.32577;
  short unsigned int D.32580;
  struct MonoArray * D.32583;
  struct MonoVTable * D.32584;
  struct MonoMethodSignature * * D.32585;
  union mono_mutex_t * D.32586;
  _Bool D.32589;
  long int D.32590;
  long int D.32591;
  struct MonoGHashTable * D.32594;
  struct MonoGHashTable * D.32597;
  _Bool D.32602;
  long int D.32603;
  long int D.32604;
  _Bool D.32609;
  long int D.32610;
  long int D.32611;
  unsigned int D.32614;
  unsigned int D.32615;
  int D.32616;
  int D.32617;
  unsigned int D.32618;
  unsigned int D.32619;
  unsigned int D.32620;
  struct MonoVTable * D.32621;
  struct MonoClass * System_Reflection_ParameterInfo.392;
  struct MonoType * D.32623;
  struct MonoReflectionType * D.32624;
  struct MonoReflectionType * * D.32625;
  struct MonoObject * * D.32626;
  unsigned int i.393;
  unsigned int D.32628;
  char * * D.32629;
  char * D.32630;
  struct MonoString * D.32631;
  struct MonoString * * D.32632;
  short unsigned int D.32633;
  unsigned int D.32634;
  unsigned int D.32635;
  unsigned int D.32636;
  unsigned int D.32639;
  struct MonoObject * D.32642;
  struct MonoObject * * D.32643;
  struct MonoObject * D.32645;
  guint32 * D.32651;
  unsigned int D.32652;
  unsigned char D.32653;
  struct MonoClass * D.32656;
  unsigned char D.32660;
  struct MonoClass * D.32662;
  unsigned char D.32663;
  unsigned char D.32664;
  struct MonoClass * D.32666;
  struct MonoClass * D.32667;
  char * * D.32668;
  char * D.32669;
  struct MonoObject * D.32670;
  struct MonoObject * D.32673;
  struct MonoObject * D.32678;
  struct MonoObject * D.32680;
  sizetype i.394;
  sizetype D.32682;
  sizetype D.32683;
  struct MonoMarshalSpec * * D.32684;
  struct MonoMarshalSpec * D.32685;
  struct MonoClass * D.32688;
  struct MonoReflectionMarshalAsAttribute * D.32689;
  struct MonoObject * * D.32690;
  unsigned int i.395;
  struct MonoMethodSignature * D.32692;
  short unsigned int D.32693;
  struct MonoMarshalSpec * * D.32694;
  struct MonoMarshalSpec * D.32695;
  _Bool D.32700;
  long int D.32701;
  long int D.32702;
  struct MonoGHashTable * D.32707;
  struct MonoMemPool * D.32710;
  _Bool D.32713;
  long int D.32714;
  long int D.32715;
  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.32572>; else goto <D.32573>;
      <D.32572>:
      {
        struct MonoClass * klass;

        D.32574 = mono_defaults.corlib;
        klass = mono_class_from_name (D.32574, "System.Reflection", "MonoParameterInfo");
        if (klass == 0B) goto <D.32575>; else goto <D.32576>;
        <D.32575>:
        D.32574 = mono_defaults.corlib;
        klass = mono_class_from_name (D.32574, "System.Reflection", "ParameterInfo");
        <D.32576>:
        mono_memory_barrier ();
        System_Reflection_ParameterInfo = klass;
        klass = mono_array_class_get (klass, 1);
        mono_memory_barrier ();
        System_Reflection_ParameterInfo_array = klass;
      }
      <D.32573>:
      sig = mono_method_signature_checked (method, &error);
      D.32577 = mono_error_ok (&error);
      if (D.32577 == 0) goto <D.32578>; else goto <D.32579>;
      <D.32578>:
      mono_error_raise_exception (&error);
      <D.32579>:
      D.32580 = sig->param_count;
      if (D.32580 == 0) goto <D.32581>; else goto <D.32582>;
      <D.32581>:
      System_Reflection_ParameterInfo_array.391 = System_Reflection_ParameterInfo_array;
      D.32584 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.391);
      D.32583 = mono_array_new_specific (D.32584, 0);
      return D.32583;
      <D.32582>:
      {
        struct MonoArray * _obj;
        struct ReflectedEntry e;

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

              D.32586 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.32586);
              if (ret != 0) goto <D.32587>; else goto <D.32588>;
              <D.32587>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.32588>:
              D.32589 = ret != 0;
              D.32590 = (long int) D.32589;
              D.32591 = __builtin_expect (D.32590, 0);
              if (D.32591 != 0) goto <D.32592>; else goto <D.32593>;
              <D.32592>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32593>:
            }
            D.32594 = domain->refobject_hash;
            if (D.32594 == 0B) goto <D.32595>; else goto <D.32596>;
            <D.32595>:
            D.32597 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.32597;
            <D.32596>:
            D.32594 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.32594, &e);
            if (_obj != 0B) goto <D.32598>; else goto <D.32599>;
            <D.32598>:
            {
              int ret;

              D.32586 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32586);
              if (ret != 0) goto <D.32600>; else goto <D.32601>;
              <D.32600>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32601>:
              D.32602 = ret != 0;
              D.32603 = (long int) D.32602;
              D.32604 = __builtin_expect (D.32603, 0);
              if (D.32604 != 0) goto <D.32605>; else goto <D.32606>;
              <D.32605>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32606>:
            }
            D.32583 = _obj;
            return D.32583;
            <D.32599>:
            {
              int ret;

              D.32586 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32586);
              if (ret != 0) goto <D.32607>; else goto <D.32608>;
              <D.32607>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32608>:
              D.32609 = ret != 0;
              D.32610 = (long int) D.32609;
              D.32611 = __builtin_expect (D.32610, 0);
              if (D.32611 != 0) goto <D.32612>; else goto <D.32613>;
              <D.32612>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.32613>:
            }
          }
        finally
          {
            e = {CLOBBER};
          }
      }
      member = mono_method_get_object (domain, method, refclass);
      D.32580 = sig->param_count;
      D.32614 = (unsigned int) D.32580;
      D.32615 = D.32614 * 4;
      names = monoeg_malloc (D.32615);
      mono_method_get_param_names (method, names);
      D.32580 = sig->param_count;
      D.32616 = (int) D.32580;
      D.32617 = D.32616 + 1;
      D.32618 = (unsigned int) D.32617;
      D.32619 = D.32618 * 4;
      mspecs = monoeg_malloc (D.32619);
      mono_method_get_marshal_info (method, mspecs);
      D.32580 = sig->param_count;
      D.32620 = (unsigned int) D.32580;
      System_Reflection_ParameterInfo_array.391 = System_Reflection_ParameterInfo_array;
      D.32621 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.391);
      res = mono_array_new_specific (D.32621, D.32620);
      System_Reflection_ParameterInfo.392 = System_Reflection_ParameterInfo;
      pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo.392);
      i = 0;
      goto <D.20949>;
      <D.20948>:
      param = mono_object_new_specific (pinfo_vtable);
      D.32623 = sig->params[i];
      D.32624 = mono_type_get_object (domain, D.32623);
      D.32625 = &param->ClassImpl;
      mono_gc_wbarrier_set_field (param, D.32625, D.32624);
      D.32626 = &param->MemberImpl;
      mono_gc_wbarrier_set_field (param, D.32626, member);
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32629 = names + D.32628;
      D.32630 = *D.32629;
      D.32631 = mono_string_new (domain, D.32630);
      D.32632 = &param->NameImpl;
      mono_gc_wbarrier_set_field (param, D.32632, D.32631);
      param->PositionImpl = i;
      D.32623 = sig->params[i];
      D.32633 = D.32623->attrs;
      D.32634 = (unsigned int) D.32633;
      param->AttrsImpl = D.32634;
      D.32635 = param->AttrsImpl;
      D.32636 = D.32635 & 4096;
      if (D.32636 == 0) goto <D.32637>; else goto <D.32638>;
      <D.32637>:
      D.32635 = param->AttrsImpl;
      D.32639 = D.32635 & 16;
      if (D.32639 != 0) goto <D.32640>; else goto <D.32641>;
      <D.32640>:
      D.32642 = get_reflection_missing (domain, &missing);
      D.32643 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.32643, D.32642);
      goto <D.32644>;
      <D.32641>:
      D.32645 = get_dbnull (domain, &dbnull);
      D.32643 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.32643, D.32645);
      <D.32644>:
      goto <D.32646>;
      <D.32638>:
      if (blobs == 0B) goto <D.32647>; else goto <D.32648>;
      <D.32647>:
      D.32580 = sig->param_count;
      D.32614 = (unsigned int) D.32580;
      D.32615 = D.32614 * 4;
      blobs = monoeg_malloc0 (D.32615);
      D.32580 = sig->param_count;
      D.32614 = (unsigned int) D.32580;
      D.32615 = D.32614 * 4;
      types = monoeg_malloc0 (D.32615);
      get_default_param_value_blobs (method, blobs, types);
      <D.32648>:
      if (type == 0B) goto <D.32649>; else goto <D.32650>;
      <D.32649>:
      type = monoeg_malloc0 (8);
      <D.32650>:
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32651 = types + D.32628;
      D.32652 = *D.32651;
      D.32653 = (unsigned char) D.32652;
      type->type = D.32653;
      type->data.klass = 0B;
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32651 = types + D.32628;
      D.32652 = *D.32651;
      if (D.32652 == 18) goto <D.32654>; else goto <D.32655>;
      <D.32654>:
      D.32656 = mono_defaults.object_class;
      type->data.klass = D.32656;
      goto <D.32657>;
      <D.32655>:
      D.32623 = sig->params[i];
      D.32660 = D.32623->type;
      if (D.32660 == 17) goto <D.32661>; else goto <D.32658>;
      <D.32661>:
      D.32623 = sig->params[i];
      D.32662 = D.32623->data.klass;
      D.32663 = BIT_FIELD_REF <*D.32662, 8, 160>;
      D.32664 = D.32663 & 16;
      if (D.32664 != 0) goto <D.32665>; else goto <D.32658>;
      <D.32665>:
      type->type = 17;
      D.32623 = sig->params[i];
      D.32666 = mono_class_from_mono_type (D.32623);
      type->data.klass = D.32666;
      goto <D.32659>;
      <D.32658>:
      D.32667 = mono_class_from_mono_type (type);
      type->data.klass = D.32667;
      <D.32659>:
      <D.32657>:
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32668 = blobs + D.32628;
      D.32669 = *D.32668;
      D.32670 = mono_get_object_from_blob (domain, type, D.32669);
      D.32643 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.32643, D.32670);
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32651 = types + D.32628;
      D.32652 = *D.32651;
      if (D.32652 != 18) goto <D.32671>; else goto <D.32672>;
      <D.32671>:
      D.32673 = param->DefaultValueImpl;
      if (D.32673 == 0B) goto <D.32674>; else goto <D.32675>;
      <D.32674>:
      D.32635 = param->AttrsImpl;
      D.32639 = D.32635 & 16;
      if (D.32639 != 0) goto <D.32676>; else goto <D.32677>;
      <D.32676>:
      D.32678 = get_reflection_missing (domain, &missing);
      D.32643 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.32643, D.32678);
      goto <D.32679>;
      <D.32677>:
      D.32680 = get_dbnull (domain, &dbnull);
      D.32643 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.32643, D.32680);
      <D.32679>:
      <D.32675>:
      <D.32672>:
      <D.32646>:
      i.394 = (sizetype) i;
      D.32682 = i.394 + 1;
      D.32683 = D.32682 * 4;
      D.32684 = mspecs + D.32683;
      D.32685 = *D.32684;
      if (D.32685 != 0B) goto <D.32686>; else goto <D.32687>;
      <D.32686>:
      i.394 = (sizetype) i;
      D.32682 = i.394 + 1;
      D.32683 = D.32682 * 4;
      D.32684 = mspecs + D.32683;
      D.32685 = *D.32684;
      D.32688 = method->klass;
      D.32689 = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.32688, D.32685);
      D.32690 = &param->MarshalAsImpl;
      mono_gc_wbarrier_set_field (param, D.32690, D.32689);
      <D.32687>:
      {
        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.20949>:
      D.32580 = sig->param_count;
      D.32616 = (int) D.32580;
      if (D.32616 > i) goto <D.20948>; else goto <D.20950>;
      <D.20950>:
      monoeg_g_free (names);
      monoeg_g_free (blobs);
      monoeg_g_free (types);
      monoeg_g_free (type);
      D.32692 = mono_method_signature (method);
      D.32693 = D.32692->param_count;
      i = (int) D.32693;
      goto <D.20952>;
      <D.20951>:
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32694 = mspecs + D.32628;
      D.32695 = *D.32694;
      if (D.32695 != 0B) goto <D.32696>; else goto <D.32697>;
      <D.32696>:
      i.393 = (unsigned int) i;
      D.32628 = i.393 * 4;
      D.32694 = mspecs + D.32628;
      D.32695 = *D.32694;
      mono_metadata_free_marshal_spec (D.32695);
      <D.32697>:
      i = i + -1;
      <D.20952>:
      if (i >= 0) goto <D.20951>; else goto <D.20953>;
      <D.20953>:
      monoeg_g_free (mspecs);
      {
        struct MonoArray * _obj;
        struct ReflectedEntry pe;

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

              D.32586 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.32586);
              if (ret != 0) goto <D.32698>; else goto <D.32699>;
              <D.32698>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.32699>:
              D.32700 = ret != 0;
              D.32701 = (long int) D.32700;
              D.32702 = __builtin_expect (D.32701, 0);
              if (D.32702 != 0) goto <D.32703>; else goto <D.32704>;
              <D.32703>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.32704>:
            }
            D.32594 = domain->refobject_hash;
            if (D.32594 == 0B) goto <D.32705>; else goto <D.32706>;
            <D.32705>:
            D.32707 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.32707;
            <D.32706>:
            D.32594 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.32594, &pe);
            if (_obj == 0B) goto <D.32708>; else goto <D.32709>;
            <D.32708>:
            {
              struct ReflectedEntry * e;

              D.32710 = domain->mp;
              e = mono_mempool_alloc (D.32710, 8);
              D.32585 = &method->signature;
              e->item = D.32585;
              e->refclass = refclass;
              D.32594 = domain->refobject_hash;
              mono_g_hash_table_insert (D.32594, e, res);
              _obj = res;
            }
            <D.32709>:
            {
              int ret;

              D.32586 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.32586);
              if (ret != 0) goto <D.32711>; else goto <D.32712>;
              <D.32711>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.32712>:
              D.32713 = ret != 0;
              D.32714 = (long int) D.32713;
              D.32715 = __builtin_expect (D.32714, 0);
              if (D.32715 != 0) goto <D.32716>; else goto <D.32717>;
              <D.32716>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.32717>:
            }
            D.32583 = _obj;
            return D.32583;
          }
        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.32723;
  struct MonoImage * D.32726;
  unsigned char D.32727;
  unsigned char D.32728;
  unsigned char D.32731;
  unsigned char D.32732;
  struct MonoClass * D.32735;
  struct MonoImage * D.32736;
  struct GHashTable * D.32737;
  uint8_t * * D.32740;
  unsigned int D.32743;
  unsigned int D.32744;
  uint8_t * * D.32745;
  uint32_t * D.32746;
  uint32_t * D.32747;
  unsigned int D.32748;
  unsigned int D.32749;
  _Bool D.32750;
  long int D.32751;
  long int D.32752;
  int D.32755;
  <unnamed-unsigned:24> D.32756;
  int D.32757;
  <unnamed-unsigned:24> D.32761;
  int D.32762;
  int D.32763;
  unsigned int D.32764;
  int D.32765;
  unsigned int D.32766;
  unsigned int D.32767;
  unsigned int D.32770;
  unsigned int D.32771;
  unsigned int D.32774;
  int D.32775;
  sizetype D.32776;
  sizetype D.32777;
  char * * D.32778;
  unsigned int D.32779;
  const char * D.32780;
  guint32 * D.32781;
  unsigned int D.32782;
  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.32723 = methodsig->param_count;
      if (D.32723 == 0) goto <D.32724>; else goto <D.32725>;
      <D.32724>:
      return;
      <D.32725>:
      mono_class_init (klass);
      D.32726 = klass->image;
      D.32727 = BIT_FIELD_REF <*D.32726, 8, 128>;
      D.32728 = D.32727 & 8;
      if (D.32728 != 0) goto <D.32729>; else goto <D.32730>;
      <D.32729>:
      {
        struct MonoReflectionMethodAux * aux;

        D.32731 = BIT_FIELD_REF <*method, 8, 168>;
        D.32732 = D.32731 & 16;
        if (D.32732 != 0) goto <D.32733>; else goto <D.32734>;
        <D.32733>:
        method = MEM[(struct MonoMethodInflated *)method].declaring;
        <D.32734>:
        D.32735 = method->klass;
        D.32736 = D.32735->image;
        D.32737 = MEM[(struct MonoDynamicImage *)D.32736].method_aux_hash;
        aux = monoeg_g_hash_table_lookup (D.32737, method);
        if (aux != 0B) goto <D.32738>; else goto <D.32739>;
        <D.32738>:
        D.32740 = aux->param_defaults;
        if (D.32740 != 0B) goto <D.32741>; else goto <D.32742>;
        <D.32741>:
        D.32723 = methodsig->param_count;
        D.32743 = (unsigned int) D.32723;
        D.32744 = D.32743 * 4;
        D.32740 = aux->param_defaults;
        D.32745 = D.32740 + 4;
        memcpy (blobs, D.32745, D.32744);
        D.32723 = methodsig->param_count;
        D.32743 = (unsigned int) D.32723;
        D.32744 = D.32743 * 4;
        D.32746 = aux->param_default_types;
        D.32747 = D.32746 + 4;
        memcpy (types, D.32747, D.32744);
        <D.32742>:
        <D.32739>:
        return;
      }
      <D.32730>:
      D.32726 = klass->image;
      methodt = &D.32726->tables[6];
      D.32726 = klass->image;
      paramt = &D.32726->tables[8];
      constt = &image->tables[11];
      D.32748 = mono_method_get_index (method);
      D.32749 = D.32748 + 4294967295;
      idx = (gint32) D.32749;
      D.32750 = idx == -1;
      D.32751 = (long int) D.32750;
      D.32752 = __builtin_expect (D.32751, 0);
      if (D.32752 != 0) goto <D.32753>; else goto <D.32754>;
      <D.32753>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7061, "idx != -1");
      <D.32754>:
      param_index = mono_metadata_decode_row_col (methodt, idx, 5);
      D.32755 = idx + 1;
      D.32756 = methodt->rows;
      D.32757 = (int) D.32756;
      if (D.32755 < D.32757) goto <D.32758>; else goto <D.32759>;
      <D.32758>:
      D.32755 = idx + 1;
      lastp = mono_metadata_decode_row_col (methodt, D.32755, 5);
      goto <D.32760>;
      <D.32759>:
      D.32761 = paramt->rows;
      D.32762 = (int) D.32761;
      D.32763 = D.32762 + 1;
      lastp = (guint32) D.32763;
      <D.32760>:
      i = param_index;
      goto <D.21038>;
      <D.21037>:
      {
        guint32 paramseq;

        D.32764 = i + 4294967295;
        D.32765 = (int) D.32764;
        mono_metadata_decode_row (paramt, D.32765, &param_cols, 3);
        paramseq = param_cols[1];
        D.32766 = param_cols[0];
        D.32767 = D.32766 & 4096;
        if (D.32767 == 0) goto <D.32768>; else goto <D.32769>;
        <D.32768>:
        // predicted unlikely by continue predictor.
        goto <D.21036>;
        <D.32769>:
        D.32770 = crow + 1;
        D.32771 = i | 134217728;
        crow = mono_metadata_get_constant_index (image, D.32771, D.32770);
        if (crow == 0) goto <D.32772>; else goto <D.32773>;
        <D.32772>:
        // predicted unlikely by continue predictor.
        goto <D.21036>;
        <D.32773>:
        D.32774 = crow + 4294967295;
        D.32775 = (int) D.32774;
        mono_metadata_decode_row (constt, D.32775, &const_cols, 4);
        D.32776 = paramseq + 1073741823;
        D.32777 = D.32776 * 4;
        D.32778 = blobs + D.32777;
        D.32779 = const_cols[3];
        D.32780 = mono_metadata_blob_heap (image, D.32779);
        *D.32778 = D.32780;
        D.32776 = paramseq + 1073741823;
        D.32777 = D.32776 * 4;
        D.32781 = types + D.32777;
        D.32782 = const_cols[0];
        *D.32781 = D.32782;
      }
      <D.21036>:
      i = i + 1;
      <D.21038>:
      if (i < lastp) goto <D.21037>; else goto <D.21039>;
      <D.21039>:
      return;
    }
  finally
    {
      param_cols = {CLOBBER};
      const_cols = {CLOBBER};
    }
}


get_reflection_missing (struct MonoDomain * domain, struct MonoObject * * reflection_missing)
{
  struct MonoObject * D.32785;
  struct MonoObject * D.32788;
  struct MonoObject * D.32789;

  D.32785 = *reflection_missing;
  if (D.32785 == 0B) goto <D.32786>; else goto <D.32787>;
  <D.32786>:
  D.32788 = mono_get_reflection_missing_object (domain);
  *reflection_missing = D.32788;
  <D.32787>:
  D.32789 = *reflection_missing;
  return D.32789;
}


mono_get_reflection_missing_object (struct MonoDomain * domain)
{
  struct MonoClassField * missing_value_field.396;
  struct MonoImage * D.32794;
  struct MonoClassField * missing_value_field.397;
  _Bool D.32796;
  long int D.32797;
  long int D.32798;
  _Bool D.32801;
  long int D.32802;
  long int D.32803;
  struct MonoObject * D.32806;
  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.32792>; else goto <D.32793>;
  <D.32792>:
  {
    struct MonoClass * missing_klass;

    D.32794 = mono_defaults.corlib;
    missing_klass = mono_class_from_name (D.32794, "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.32796 = missing_value_field.396 == 0B;
    D.32797 = (long int) D.32796;
    D.32798 = __builtin_expect (D.32797, 0);
    if (D.32798 != 0) goto <D.32799>; else goto <D.32800>;
    <D.32799>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6732, "missing_value_field");
    <D.32800>:
  }
  <D.32793>:
  missing_value_field.396 = missing_value_field;
  obj = mono_field_get_value_object (domain, missing_value_field.396, 0B);
  D.32801 = obj == 0B;
  D.32802 = (long int) D.32801;
  D.32803 = __builtin_expect (D.32802, 0);
  if (D.32803 != 0) goto <D.32804>; else goto <D.32805>;
  <D.32804>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6735, "obj");
  <D.32805>:
  D.32806 = obj;
  return D.32806;
}


get_dbnull (struct MonoDomain * domain, struct MonoObject * * dbnull)
{
  struct MonoObject * D.32808;
  struct MonoObject * D.32811;
  struct MonoObject * D.32812;

  D.32808 = *dbnull;
  if (D.32808 == 0B) goto <D.32809>; else goto <D.32810>;
  <D.32809>:
  D.32811 = mono_get_dbnull_object (domain);
  *dbnull = D.32811;
  <D.32810>:
  D.32812 = *dbnull;
  return D.32812;
}


mono_param_get_objects (struct MonoDomain * domain, struct MonoMethod * method)
{
  struct MonoArray * D.32814;

  D.32814 = mono_param_get_objects_internal (domain, method, 0B);
  return D.32814;
}


mono_method_body_get_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.32816;
  unsigned char D.32817;
  struct MonoException * D.32820;
  struct MonoClass * System_Reflection_MethodBody.398;
  struct MonoImage * D.32824;
  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.32834;
  _Bool D.32837;
  long int D.32838;
  long int D.32839;
  struct MonoGHashTable * D.32842;
  struct MonoGHashTable * D.32845;
  _Bool D.32850;
  long int D.32851;
  long int D.32852;
  struct MonoReflectionMethodBody * D.32855;
  _Bool D.32858;
  long int D.32859;
  long int D.32860;
  short unsigned int D.32865;
  unsigned int D.32866;
  unsigned int D.32867;
  short unsigned int D.32869;
  unsigned int D.32870;
  unsigned int D.32871;
  struct MonoClass * D.32872;
  unsigned char D.32873;
  unsigned char D.32874;
  unsigned int D.32877;
  unsigned int D.32878;
  unsigned int D.32879;
  int D.32880;
  struct MonoTableInfo * D.32881;
  int D.32882;
  <unnamed-unsigned:1> D.32884;
  unsigned char D.32885;
  <unnamed-unsigned:15> D.32886;
  unsigned int D.32887;
  unsigned int D.32888;
  struct MonoClass * D.20989;
  struct MonoClass * tmp_klass.404;
  struct MonoClass * D.32892;
  struct MonoClass * tmp_klass.405;
  _Bool D.32894;
  long int D.32895;
  long int D.32896;
  struct MonoVTable * D.32899;
  struct MonoArray * D.32900;
  struct MonoArray * * D.32901;
  const unsigned char * D.32902;
  struct MonoArray * D.32903;
  char * D.32904;
  short unsigned int D.32905;
  unsigned int D.32906;
  struct MonoClass * D.20991;
  struct MonoClass * tmp_klass.406;
  struct MonoClass * tmp_klass.407;
  _Bool D.32911;
  long int D.32912;
  long int D.32913;
  struct MonoVTable * D.32916;
  struct MonoArray * D.32917;
  struct MonoArray * * D.32918;
  struct MonoType * D.32919;
  struct MonoReflectionType * D.32920;
  struct MonoReflectionType * * D.32921;
  <unnamed-unsigned:1> D.32922;
  unsigned char D.32923;
  short unsigned int D.32924;
  unsigned int i.408;
  struct MonoArray * D.32926;
  int D.32927;
  <unnamed-unsigned:15> D.32928;
  unsigned int D.32929;
  struct MonoClass * D.20998;
  struct MonoClass * tmp_klass.409;
  struct MonoClass * tmp_klass.410;
  _Bool D.32934;
  long int D.32935;
  long int D.32936;
  struct MonoVTable * D.32939;
  struct MonoArray * D.32940;
  struct MonoArray * * D.32941;
  struct MonoExceptionClause * D.32942;
  unsigned int i.411;
  unsigned int D.32944;
  unsigned int D.32945;
  int D.32946;
  unsigned int D.32947;
  int D.32948;
  unsigned int D.32949;
  int D.32950;
  unsigned int D.32951;
  int D.32952;
  unsigned int D.32953;
  int D.32954;
  unsigned int D.32957;
  int D.32958;
  struct MonoClass * D.32960;
  struct MonoType * D.32963;
  struct MonoDomain * D.32964;
  struct MonoReflectionType * D.32965;
  struct MonoObject * * D.32966;
  struct MonoArray * D.32967;
  int D.32968;
  _Bool D.32971;
  long int D.32972;
  long int D.32973;
  struct MonoGHashTable * D.32978;
  struct MonoMemPool * D.32981;
  _Bool D.32984;
  long int D.32985;
  long int D.32986;
  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.32816 = BIT_FIELD_REF <*method, 8, 168>;
  D.32817 = D.32816 & 2;
  if (D.32817 != 0) goto <D.32818>; else goto <D.32819>;
  <D.32818>:
  D.32820 = mono_get_exception_invalid_operation (0B);
  mono_raise_exception (D.32820);
  <D.32819>:
  System_Reflection_MethodBody.398 = System_Reflection_MethodBody;
  if (System_Reflection_MethodBody.398 == 0B) goto <D.32822>; else goto <D.32823>;
  <D.32822>:
  D.32824 = mono_defaults.corlib;
  System_Reflection_MethodBody.399 = mono_class_from_name (D.32824, "System.Reflection", "MethodBody");
  System_Reflection_MethodBody = System_Reflection_MethodBody.399;
  <D.32823>:
  System_Reflection_LocalVariableInfo.400 = System_Reflection_LocalVariableInfo;
  if (System_Reflection_LocalVariableInfo.400 == 0B) goto <D.32827>; else goto <D.32828>;
  <D.32827>:
  D.32824 = mono_defaults.corlib;
  System_Reflection_LocalVariableInfo.401 = mono_class_from_name (D.32824, "System.Reflection", "LocalVariableInfo");
  System_Reflection_LocalVariableInfo = System_Reflection_LocalVariableInfo.401;
  <D.32828>:
  System_Reflection_ExceptionHandlingClause.402 = System_Reflection_ExceptionHandlingClause;
  if (System_Reflection_ExceptionHandlingClause.402 == 0B) goto <D.32831>; else goto <D.32832>;
  <D.32831>:
  D.32824 = mono_defaults.corlib;
  System_Reflection_ExceptionHandlingClause.403 = mono_class_from_name (D.32824, "System.Reflection", "ExceptionHandlingClause");
  System_Reflection_ExceptionHandlingClause = System_Reflection_ExceptionHandlingClause.403;
  <D.32832>:
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry e;

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

          D.32834 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32834);
          if (ret != 0) goto <D.32835>; else goto <D.32836>;
          <D.32835>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32836>:
          D.32837 = ret != 0;
          D.32838 = (long int) D.32837;
          D.32839 = __builtin_expect (D.32838, 0);
          if (D.32839 != 0) goto <D.32840>; else goto <D.32841>;
          <D.32840>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32841>:
        }
        D.32842 = domain->refobject_hash;
        if (D.32842 == 0B) goto <D.32843>; else goto <D.32844>;
        <D.32843>:
        D.32845 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32845;
        <D.32844>:
        D.32842 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32842, &e);
        if (_obj != 0B) goto <D.32846>; else goto <D.32847>;
        <D.32846>:
        {
          int ret;

          D.32834 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32834);
          if (ret != 0) goto <D.32848>; else goto <D.32849>;
          <D.32848>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32849>:
          D.32850 = ret != 0;
          D.32851 = (long int) D.32850;
          D.32852 = __builtin_expect (D.32851, 0);
          if (D.32852 != 0) goto <D.32853>; else goto <D.32854>;
          <D.32853>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32854>:
        }
        D.32855 = _obj;
        return D.32855;
        <D.32847>:
        {
          int ret;

          D.32834 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32834);
          if (ret != 0) goto <D.32856>; else goto <D.32857>;
          <D.32856>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32857>:
          D.32858 = ret != 0;
          D.32859 = (long int) D.32858;
          D.32860 = __builtin_expect (D.32859, 0);
          if (D.32860 != 0) goto <D.32861>; else goto <D.32862>;
          <D.32861>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.32862>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.32865 = method->flags;
  D.32866 = (unsigned int) D.32865;
  D.32867 = D.32866 & 9216;
  if (D.32867 != 0) goto <D.32863>; else goto <D.32868>;
  <D.32868>:
  D.32869 = method->iflags;
  D.32870 = (unsigned int) D.32869;
  D.32871 = D.32870 & 4099;
  if (D.32871 != 0) goto <D.32863>; else goto <D.32864>;
  <D.32863>:
  D.32855 = 0B;
  return D.32855;
  <D.32864>:
  D.32872 = method->klass;
  image = D.32872->image;
  header = mono_method_get_header (method);
  D.32873 = BIT_FIELD_REF <*image, 8, 128>;
  D.32874 = D.32873 & 8;
  if (D.32874 == 0) goto <D.32875>; else goto <D.32876>;
  <D.32875>:
  D.32877 = method->token;
  D.32878 = D.32877 & 16777215;
  D.32879 = D.32878 + 4294967295;
  D.32880 = (int) D.32879;
  D.32881 = &image->tables[6];
  method_rva = mono_metadata_decode_row_col (D.32881, D.32880, 0);
  ptr = mono_image_rva_map (image, method_rva);
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.32882 = (int) format;
  switch (D.32882) <default: <D.20987>, case 2: <D.20984>, case 3: <D.20986>>
  <D.20984>:
  local_var_sig_token = 0;
  goto <D.20985>;
  <D.20986>:
  ptr = ptr + 2;
  ptr = ptr + 2;
  ptr = ptr + 4;
  local_var_sig_token = MEM[(const guint32 *)ptr];
  goto <D.20985>;
  <D.20987>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 6951);
  <D.20985>:
  goto <D.32883>;
  <D.32876>:
  local_var_sig_token = 0;
  <D.32883>:
  System_Reflection_MethodBody.398 = System_Reflection_MethodBody;
  ret = mono_object_new (domain, System_Reflection_MethodBody.398);
  D.32884 = header->init_locals;
  D.32885 = (unsigned char) D.32884;
  ret->init_locals = D.32885;
  D.32886 = header->max_stack;
  D.32887 = (unsigned int) D.32886;
  ret->max_stack = D.32887;
  ret->local_var_sig_token = local_var_sig_token;
  D.32888 = header->code_size;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.404 = tmp_klass;
      if (tmp_klass.404 == 0B) goto <D.32890>; else goto <D.32891>;
      <D.32890>:
      D.32892 = mono_defaults.byte_class;
      tmp_klass.405 = mono_array_class_get (D.32892, 1);
      tmp_klass = tmp_klass.405;
      tmp_klass.404 = tmp_klass;
      D.32894 = tmp_klass.404 == 0B;
      D.32895 = (long int) D.32894;
      D.32896 = __builtin_expect (D.32895, 0);
      if (D.32896 != 0) goto <D.32897>; else goto <D.32898>;
      <D.32897>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6961, "tmp_klass");
      <D.32898>:
      <D.32891>:
    }
    D.20989 = tmp_klass;
  }
  D.32899 = mono_class_vtable (domain, D.20989);
  D.32900 = mono_array_new_specific (D.32899, D.32888);
  D.32901 = &ret->il;
  mono_gc_wbarrier_set_field (ret, D.32901, D.32900);
  D.32888 = header->code_size;
  D.32902 = header->code;
  D.32903 = ret->il;
  D.32904 = mono_array_addr_with_size (D.32903, 1, 0);
  memcpy (D.32904, D.32902, D.32888);
  D.32905 = header->num_locals;
  D.32906 = (unsigned int) D.32905;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.406 = tmp_klass;
      if (tmp_klass.406 == 0B) goto <D.32908>; else goto <D.32909>;
      <D.32908>:
      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.32911 = tmp_klass.406 == 0B;
      D.32912 = (long int) D.32911;
      D.32913 = __builtin_expect (D.32912, 0);
      if (D.32913 != 0) goto <D.32914>; else goto <D.32915>;
      <D.32914>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6965, "tmp_klass");
      <D.32915>:
      <D.32909>:
    }
    D.20991 = tmp_klass;
  }
  D.32916 = mono_class_vtable (domain, D.20991);
  D.32917 = mono_array_new_specific (D.32916, D.32906);
  D.32918 = &ret->locals;
  mono_gc_wbarrier_set_field (ret, D.32918, D.32917);
  i = 0;
  goto <D.20995>;
  <D.20994>:
  {
    struct MonoReflectionLocalVariableInfo * info;

    System_Reflection_LocalVariableInfo.400 = System_Reflection_LocalVariableInfo;
    info = mono_object_new (domain, System_Reflection_LocalVariableInfo.400);
    D.32919 = header->locals[i];
    D.32920 = mono_type_get_object (domain, D.32919);
    D.32921 = &info->local_type;
    mono_gc_wbarrier_set_field (info, D.32921, D.32920);
    D.32919 = header->locals[i];
    D.32922 = D.32919->pinned;
    D.32923 = (unsigned char) D.32922;
    info->is_pinned = D.32923;
    D.32924 = (short unsigned int) i;
    info->local_index = D.32924;
    {
      void * * __p;

      i.408 = (unsigned int) i;
      D.32926 = ret->locals;
      __p = mono_array_addr_with_size (D.32926, 4, i.408);
      D.32926 = ret->locals;
      mono_gc_wbarrier_set_arrayref (D.32926, __p, info);
    }
  }
  i = i + 1;
  <D.20995>:
  D.32905 = header->num_locals;
  D.32927 = (int) D.32905;
  if (D.32927 > i) goto <D.20994>; else goto <D.20996>;
  <D.20996>:
  D.32928 = header->num_clauses;
  D.32929 = (unsigned int) D.32928;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.409 = tmp_klass;
      if (tmp_klass.409 == 0B) goto <D.32931>; else goto <D.32932>;
      <D.32931>:
      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.32934 = tmp_klass.409 == 0B;
      D.32935 = (long int) D.32934;
      D.32936 = __builtin_expect (D.32935, 0);
      if (D.32936 != 0) goto <D.32937>; else goto <D.32938>;
      <D.32937>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6975, "tmp_klass");
      <D.32938>:
      <D.32932>:
    }
    D.20998 = tmp_klass;
  }
  D.32939 = mono_class_vtable (domain, D.20998);
  D.32940 = mono_array_new_specific (D.32939, D.32929);
  D.32941 = &ret->clauses;
  mono_gc_wbarrier_set_field (ret, D.32941, D.32940);
  i = 0;
  goto <D.21003>;
  <D.21002>:
  {
    struct MonoReflectionExceptionHandlingClause * info;
    struct MonoExceptionClause * clause;

    System_Reflection_ExceptionHandlingClause.402 = System_Reflection_ExceptionHandlingClause;
    info = mono_object_new (domain, System_Reflection_ExceptionHandlingClause.402);
    D.32942 = header->clauses;
    i.411 = (unsigned int) i;
    D.32944 = i.411 * 24;
    clause = D.32942 + D.32944;
    D.32945 = clause->flags;
    D.32946 = (int) D.32945;
    info->flags = D.32946;
    D.32947 = clause->try_offset;
    D.32948 = (int) D.32947;
    info->try_offset = D.32948;
    D.32949 = clause->try_len;
    D.32950 = (int) D.32949;
    info->try_length = D.32950;
    D.32951 = clause->handler_offset;
    D.32952 = (int) D.32951;
    info->handler_offset = D.32952;
    D.32953 = clause->handler_len;
    D.32954 = (int) D.32953;
    info->handler_length = D.32954;
    D.32945 = clause->flags;
    if (D.32945 == 1) goto <D.32955>; else goto <D.32956>;
    <D.32955>:
    D.32957 = clause->data.filter_offset;
    D.32958 = (int) D.32957;
    info->filter_offset = D.32958;
    goto <D.32959>;
    <D.32956>:
    D.32960 = clause->data.catch_class;
    if (D.32960 != 0B) goto <D.32961>; else goto <D.32962>;
    <D.32961>:
    D.32960 = clause->data.catch_class;
    D.32963 = &D.32960->byval_arg;
    D.32964 = mono_domain_get ();
    D.32965 = mono_type_get_object (D.32964, D.32963);
    D.32966 = &info->catch_type;
    mono_gc_wbarrier_set_field (info, D.32966, D.32965);
    <D.32962>:
    <D.32959>:
    {
      void * * __p;

      i.408 = (unsigned int) i;
      D.32967 = ret->clauses;
      __p = mono_array_addr_with_size (D.32967, 4, i.408);
      D.32967 = ret->clauses;
      mono_gc_wbarrier_set_arrayref (D.32967, __p, info);
    }
  }
  i = i + 1;
  <D.21003>:
  D.32928 = header->num_clauses;
  D.32968 = (int) D.32928;
  if (D.32968 > i) goto <D.21002>; else goto <D.21004>;
  <D.21004>:
  mono_metadata_free_mh (header);
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry pe;

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

          D.32834 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32834);
          if (ret != 0) goto <D.32969>; else goto <D.32970>;
          <D.32969>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32970>:
          D.32971 = ret != 0;
          D.32972 = (long int) D.32971;
          D.32973 = __builtin_expect (D.32972, 0);
          if (D.32973 != 0) goto <D.32974>; else goto <D.32975>;
          <D.32974>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.32975>:
        }
        D.32842 = domain->refobject_hash;
        if (D.32842 == 0B) goto <D.32976>; else goto <D.32977>;
        <D.32976>:
        D.32978 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32978;
        <D.32977>:
        D.32842 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32842, &pe);
        if (_obj == 0B) goto <D.32979>; else goto <D.32980>;
        <D.32979>:
        {
          struct ReflectedEntry * e;

          D.32981 = domain->mp;
          e = mono_mempool_alloc (D.32981, 8);
          e->item = method;
          e->refclass = 0B;
          D.32842 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32842, e, ret);
          _obj = ret;
        }
        <D.32980>:
        {
          int ret;

          D.32834 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32834);
          if (ret != 0) goto <D.32982>; else goto <D.32983>;
          <D.32982>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32983>:
          D.32984 = ret != 0;
          D.32985 = (long int) D.32984;
          D.32986 = __builtin_expect (D.32985, 0);
          if (D.32986 != 0) goto <D.32987>; else goto <D.32988>;
          <D.32987>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.32988>:
        }
        D.32855 = _obj;
        return D.32855;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
  D.32855 = ret;
  return D.32855;
}


mono_get_dbnull_object (struct MonoDomain * domain)
{
  struct MonoClassField * dbnull_value_field.412;
  struct MonoImage * D.32996;
  struct MonoClassField * dbnull_value_field.413;
  _Bool D.32998;
  long int D.32999;
  long int D.33000;
  _Bool D.33003;
  long int D.33004;
  long int D.33005;
  struct MonoObject * D.33008;
  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.32994>; else goto <D.32995>;
  <D.32994>:
  {
    struct MonoClass * dbnull_klass;

    D.32996 = mono_defaults.corlib;
    dbnull_klass = mono_class_from_name (D.32996, "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.32998 = dbnull_value_field.412 == 0B;
    D.32999 = (long int) D.32998;
    D.33000 = __builtin_expect (D.32999, 0);
    if (D.33000 != 0) goto <D.33001>; else goto <D.33002>;
    <D.33001>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7017, "dbnull_value_field");
    <D.33002>:
  }
  <D.32995>:
  dbnull_value_field.412 = dbnull_value_field;
  obj = mono_field_get_value_object (domain, dbnull_value_field.412, 0B);
  D.33003 = obj == 0B;
  D.33004 = (long int) D.33003;
  D.33005 = __builtin_expect (D.33004, 0);
  if (D.33005 != 0) goto <D.33006>; else goto <D.33007>;
  <D.33006>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7020, "obj");
  <D.33007>:
  D.33008 = obj;
  return D.33008;
}


mono_get_object_from_blob (struct MonoDomain * domain, struct MonoType * type, const char * blob)
{
  struct MonoObject * D.33012;
  unsigned char D.33013;
  unsigned char D.33014;
  struct MonoObject * object.414;
  struct MonoObject * object.415;
  unsigned char D.33019;
  unsigned char D.33023;
  <unnamed type> D.33024;
  int D.33025;
  void * retval;
  struct MonoClass * klass;
  struct MonoObject * object;
  struct MonoType * basetype;

  try
    {
      basetype = type;
      if (blob == 0B) goto <D.33010>; else goto <D.33011>;
      <D.33010>:
      D.33012 = 0B;
      return D.33012;
      <D.33011>:
      klass = mono_class_from_mono_type (type);
      D.33013 = BIT_FIELD_REF <*klass, 8, 160>;
      D.33014 = D.33013 & 8;
      if (D.33014 != 0) goto <D.33015>; else goto <D.33016>;
      <D.33015>:
      object.414 = mono_object_new (domain, klass);
      object = object.414;
      object.415 = object;
      retval = object.415 + 8;
      D.33013 = BIT_FIELD_REF <*klass, 8, 160>;
      D.33019 = D.33013 & 16;
      if (D.33019 != 0) goto <D.33020>; else goto <D.33021>;
      <D.33020>:
      basetype = mono_class_enum_basetype (klass);
      <D.33021>:
      goto <D.33022>;
      <D.33016>:
      retval = &object;
      <D.33022>:
      D.33023 = basetype->type;
      D.33024 = (<unnamed type>) D.33023;
      D.33025 = mono_get_constant_value_from_blob (domain, D.33024, blob, retval);
      if (D.33025 == 0) goto <D.33026>; else goto <D.33027>;
      <D.33026>:
      D.33012 = object;
      return D.33012;
      <D.33027>:
      D.33012 = 0B;
      return D.33012;
    }
  finally
    {
      object = {CLOBBER};
    }
}


mono_reflection_parse_type (char * name, struct MonoTypeNameParse * info)
{
  int D.33030;

  D.33030 = _mono_reflection_parse_type (name, 0B, 0, info);
  return D.33030;
}


_mono_reflection_parse_type (char * name, char * * endptr, gboolean is_recursed, struct MonoTypeNameParse * info)
{
  struct MonoAssemblyName * D.33032;
  char * D.33033;
  char * p.416;
  char * p.417;
  char D.33036;
  int D.33037;
  struct GList * D.33038;
  struct GList * D.33039;
  char * D.33040;
  char * D.33044;
  int D.33054;
  struct GList * D.33055;
  struct GList * D.33056;
  char * p.418;
  char * p.419;
  struct GList * D.33059;
  char * p.420;
  char * p.421;
  char * p.422;
  char * p.423;
  char D.33068;
  _Bool D.33069;
  _Bool D.33070;
  _Bool D.33071;
  struct GList * D.33079;
  char * p.424;
  char * p.425;
  char D.33083;
  void * rank.426;
  struct GList * D.33087;
  struct GPtrArray * D.33090;
  struct GPtrArray * D.33091;
  int D.33094;
  char * p.427;
  char * p.428;
  char D.33105;
  _Bool D.33106;
  _Bool D.33107;
  _Bool D.33108;
  char * p.429;
  char * p.430;
  const short unsigned int * * D.33113;
  const short unsigned int * D.33114;
  char D.33115;
  unsigned int D.33116;
  unsigned int D.33117;
  const short unsigned int * D.33118;
  short unsigned int D.33119;
  int D.33120;
  int D.33121;
  struct MonoAssemblyName * D.33127;
  int D.33128;
  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.33147;
  unsigned int D.33148;
  const short unsigned int * D.33149;
  short unsigned int D.33150;
  int D.33151;
  int D.33152;
  int D.33157;
  const char * D.33160;
  char D.33165;
  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.33032 = &info->assembly;
      memset (D.33032, 0, 60);
      info->name_space = 0B;
      D.33033 = info->name_space;
      info->name = D.33033;
      info->nested = 0B;
      info->modifiers = 0B;
      info->type_arguments = 0B;
      last_point = 0B;
      goto <D.21106>;
      <D.21105>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      start = start + 1;
      w = w + 1;
      name = name + 1;
      <D.21106>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 32) goto <D.21105>; else goto <D.21107>;
      <D.21107>:
      goto <D.21120>;
      <D.21119>:
      p.416 = p;
      D.33036 = *p.416;
      D.33037 = (int) D.33036;
      switch (D.33037) <default: <D.21117>, case 38: <D.21112>, case 42: <D.21113>, case 43: <D.21108>, case 44: <D.21115>, case 46: <D.21110>, case 91: <D.21114>, case 92: <D.21111>, case 93: <D.21116>>
      <D.21108>:
      p.416 = p;
      *p.416 = 0;
      p.416 = p;
      startn = p.416 + 1;
      D.33038 = info->nested;
      D.33039 = monoeg_g_list_append (D.33038, startn);
      info->nested = D.33039;
      D.33040 = info->name;
      if (D.33040 != 0B) goto <D.21109>; else goto <D.33041>;
      <D.33041>:
      if (last_point != 0B) goto <D.33042>; else goto <D.33043>;
      <D.33042>:
      info->name_space = start;
      *last_point = 0;
      D.33044 = last_point + 1;
      info->name = D.33044;
      goto <D.33045>;
      <D.33043>:
      info->name_space = "";
      info->name = start;
      <D.33045>:
      goto <D.21109>;
      <D.21110>:
      last_point = p;
      goto <D.21109>;
      <D.21111>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      goto <D.21109>;
      <D.21112>:
      <D.21113>:
      <D.21114>:
      <D.21115>:
      <D.21116>:
      in_modifiers = 1;
      goto <D.21109>;
      <D.21117>:
      goto <D.21109>;
      <D.21109>:
      if (in_modifiers != 0) goto <D.21118>; else goto <D.33046>;
      <D.33046>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      <D.21120>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 != 0) goto <D.21119>; else goto <D.21118>;
      <D.21118>:
      D.33040 = info->name;
      if (D.33040 == 0B) goto <D.33047>; else goto <D.33048>;
      <D.33047>:
      if (last_point != 0B) goto <D.33049>; else goto <D.33050>;
      <D.33049>:
      info->name_space = start;
      *last_point = 0;
      D.33044 = last_point + 1;
      info->name = D.33044;
      goto <D.33051>;
      <D.33050>:
      info->name_space = "";
      info->name = start;
      <D.33051>:
      <D.33048>:
      goto <D.21149>;
      <D.21148>:
      p.416 = p;
      D.33036 = *p.416;
      D.33037 = (int) D.33036;
      switch (D.33037) <default: <D.21146>, case 38: <D.21121>, case 42: <D.21123>, case 44: <D.21142>, case 91: <D.21124>, case 93: <D.21140>>
      <D.21121>:
      if (isbyref != 0) goto <D.33052>; else goto <D.33053>;
      <D.33052>:
      D.33054 = 0;
      return D.33054;
      <D.33053>:
      isbyref = 1;
      D.33055 = info->modifiers;
      D.33056 = monoeg_g_list_append (D.33055, 0B);
      info->modifiers = D.33056;
      p.416 = p;
      p.418 = p.416;
      p.419 = p.418 + 1;
      p = p.419;
      *p.418 = 0;
      goto <D.21122>;
      <D.21123>:
      D.33055 = info->modifiers;
      D.33059 = monoeg_g_list_append (D.33055, 4294967295B);
      info->modifiers = D.33059;
      p.416 = p;
      p.420 = p.416;
      p.421 = p.420 + 1;
      p = p.421;
      *p.420 = 0;
      goto <D.21122>;
      <D.21124>:
      p.416 = p;
      p.422 = p.416;
      p.423 = p.422 + 1;
      p = p.423;
      *p.422 = 0;
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 0) goto <D.33064>; else goto <D.33065>;
      <D.33064>:
      D.33054 = 0;
      return D.33054;
      <D.33065>:
      p.416 = p;
      D.33068 = *p.416;
      D.33069 = D.33068 == 44;
      D.33070 = D.33068 == 42;
      D.33071 = D.33069 | D.33070;
      if (D.33071 != 0) goto <D.33066>; else goto <D.33072>;
      <D.33072>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 93) goto <D.33066>; else goto <D.33067>;
      <D.33066>:
      rank = 1;
      goto <D.21127>;
      <D.21126>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 93) goto <D.21125>; else goto <D.33073>;
      <D.33073>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 44) goto <D.33074>; else goto <D.33075>;
      <D.33074>:
      rank = rank + 1;
      goto <D.33076>;
      <D.33075>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 42) goto <D.33077>; else goto <D.33078>;
      <D.33077>:
      D.33055 = info->modifiers;
      D.33079 = monoeg_g_list_append (D.33055, 4294967294B);
      info->modifiers = D.33079;
      goto <D.33080>;
      <D.33078>:
      D.33054 = 0;
      return D.33054;
      <D.33080>:
      <D.33076>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      <D.21127>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 != 0) goto <D.21126>; else goto <D.21125>;
      <D.21125>:
      p.416 = p;
      p.424 = p.416;
      p.425 = p.424 + 1;
      p = p.425;
      D.33083 = *p.424;
      if (D.33083 != 93) goto <D.33084>; else goto <D.33085>;
      <D.33084>:
      D.33054 = 0;
      return D.33054;
      <D.33085>:
      rank.426 = (void *) rank;
      D.33055 = info->modifiers;
      D.33087 = monoeg_g_list_append (D.33055, rank.426);
      info->modifiers = D.33087;
      goto <D.21137>;
      <D.33067>:
      if (rank != 0) goto <D.33088>; else goto <D.33089>;
      <D.33088>:
      D.33054 = 0;
      return D.33054;
      <D.33089>:
      D.33090 = monoeg_g_ptr_array_new ();
      info->type_arguments = D.33090;
      goto <D.21139>;
      <D.21138>:
      {
        struct MonoTypeNameParse * subinfo;
        gboolean fqname;

        subinfo = monoeg_malloc0 (80);
        fqname = 0;
        D.33091 = info->type_arguments;
        monoeg_g_ptr_array_add (D.33091, subinfo);
        p.416 = p;
        D.33036 = *p.416;
        if (D.33036 == 91) goto <D.33092>; else goto <D.33093>;
        <D.33092>:
        p.416 = p;
        p.417 = p.416 + 1;
        p = p.417;
        fqname = 1;
        <D.33093>:
        p.416 = p;
        D.33094 = _mono_reflection_parse_type (p.416, &p, 1, subinfo);
        if (D.33094 == 0) goto <D.33095>; else goto <D.33096>;
        <D.33095>:
        D.33054 = 0;
        return D.33054;
        <D.33096>:
        if (fqname != 0) goto <D.33099>; else goto <D.33097>;
        <D.33099>:
        p.416 = p;
        D.33036 = *p.416;
        if (D.33036 != 93) goto <D.33100>; else goto <D.33097>;
        <D.33100>:
        {
          char * aname;

          p.416 = p;
          D.33036 = *p.416;
          if (D.33036 != 44) goto <D.33101>; else goto <D.33102>;
          <D.33101>:
          D.33054 = 0;
          return D.33054;
          <D.33102>:
          p.416 = p;
          p.427 = p.416;
          p.428 = p.427 + 1;
          p = p.428;
          *p.427 = 0;
          aname = p;
          goto <D.21132>;
          <D.21131>:
          p.416 = p;
          p.417 = p.416 + 1;
          p = p.417;
          <D.21132>:
          p.416 = p;
          D.33105 = *p.416;
          D.33106 = D.33105 != 0;
          D.33107 = D.33105 != 93;
          D.33108 = D.33106 & D.33107;
          if (D.33108 != 0) goto <D.21131>; else goto <D.21133>;
          <D.21133>:
          p.416 = p;
          D.33036 = *p.416;
          if (D.33036 != 93) goto <D.33109>; else goto <D.33110>;
          <D.33109>:
          D.33054 = 0;
          return D.33054;
          <D.33110>:
          p.416 = p;
          p.429 = p.416;
          p.430 = p.429 + 1;
          p = p.430;
          *p.429 = 0;
          goto <D.21134>;
          <D.21136>:
          D.33113 = __ctype_b_loc ();
          D.33114 = *D.33113;
          D.33115 = *aname;
          D.33116 = (unsigned int) D.33115;
          D.33117 = D.33116 * 2;
          D.33118 = D.33114 + D.33117;
          D.33119 = *D.33118;
          D.33120 = (int) D.33119;
          D.33121 = D.33120 & 8192;
          if (D.33121 != 0) goto <D.33122>; else goto <D.33123>;
          <D.33122>:
          aname = aname + 1;
          // predicted unlikely by continue predictor.
          goto <D.21134>;
          <D.33123>:
          goto <D.21135>;
          <D.21134>:
          D.33115 = *aname;
          if (D.33115 != 0) goto <D.21136>; else goto <D.21135>;
          <D.21135>:
          D.33115 = *aname;
          if (D.33115 == 0) goto <D.33124>; else goto <D.33126>;
          <D.33126>:
          D.33127 = &subinfo->assembly;
          D.33128 = assembly_name_to_aname (D.33127, aname);
          if (D.33128 == 0) goto <D.33124>; else goto <D.33125>;
          <D.33124>:
          D.33054 = 0;
          return D.33054;
          <D.33125>:
        }
        goto <D.33098>;
        <D.33097>:
        if (fqname != 0) goto <D.33129>; else goto <D.33130>;
        <D.33129>:
        p.416 = p;
        D.33036 = *p.416;
        if (D.33036 == 93) goto <D.33131>; else goto <D.33132>;
        <D.33131>:
        p.416 = p;
        p.431 = p.416;
        p.432 = p.431 + 1;
        p = p.432;
        *p.431 = 0;
        <D.33132>:
        <D.33130>:
        <D.33098>:
        p.416 = p;
        D.33036 = *p.416;
        if (D.33036 == 93) goto <D.33135>; else goto <D.33136>;
        <D.33135>:
        p.416 = p;
        p.433 = p.416;
        p.434 = p.433 + 1;
        p = p.434;
        *p.433 = 0;
        goto <D.21137>;
        <D.33136>:
        p.416 = p;
        D.33036 = *p.416;
        if (D.33036 == 0) goto <D.33139>; else goto <D.33140>;
        <D.33139>:
        D.33054 = 0;
        return D.33054;
        <D.33140>:
        p.416 = p;
        p.435 = p.416;
        p.436 = p.435 + 1;
        p = p.436;
        *p.435 = 0;
      }
      <D.21139>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 != 0) goto <D.21138>; else goto <D.21137>;
      <D.21137>:
      goto <D.21122>;
      <D.21140>:
      if (is_recursed != 0) goto end; else goto <D.33143>;
      <D.33143>:
      D.33054 = 0;
      return D.33054;
      <D.21142>:
      if (is_recursed != 0) goto end; else goto <D.33144>;
      <D.33144>:
      p.416 = p;
      p.437 = p.416;
      p.438 = p.437 + 1;
      p = p.438;
      *p.437 = 0;
      goto <D.21143>;
      <D.21145>:
      D.33113 = __ctype_b_loc ();
      D.33114 = *D.33113;
      p.416 = p;
      D.33036 = *p.416;
      D.33147 = (unsigned int) D.33036;
      D.33148 = D.33147 * 2;
      D.33149 = D.33114 + D.33148;
      D.33150 = *D.33149;
      D.33151 = (int) D.33150;
      D.33152 = D.33151 & 8192;
      if (D.33152 != 0) goto <D.33153>; else goto <D.33154>;
      <D.33153>:
      p.416 = p;
      p.417 = p.416 + 1;
      p = p.417;
      // predicted unlikely by continue predictor.
      goto <D.21143>;
      <D.33154>:
      goto <D.21144>;
      <D.21143>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 != 0) goto <D.21145>; else goto <D.21144>;
      <D.21144>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 == 0) goto <D.33155>; else goto <D.33156>;
      <D.33155>:
      D.33054 = 0;
      return D.33054;
      <D.33156>:
      p.416 = p;
      D.33032 = &info->assembly;
      D.33157 = assembly_name_to_aname (D.33032, p.416);
      if (D.33157 == 0) goto <D.33158>; else goto <D.33159>;
      <D.33158>:
      D.33054 = 0;
      return D.33054;
      <D.33159>:
      goto <D.21122>;
      <D.21146>:
      D.33054 = 0;
      return D.33054;
      <D.21122>:
      D.33160 = info->assembly.name;
      if (D.33160 != 0B) goto <D.21147>; else goto <D.33161>;
      <D.33161>:
      <D.21149>:
      p.416 = p;
      D.33036 = *p.416;
      if (D.33036 != 0) goto <D.21148>; else goto <D.21147>;
      <D.21147>:
      end:
      D.33040 = info->name;
      if (D.33040 == 0B) goto <D.33162>; else goto <D.33164>;
      <D.33164>:
      D.33040 = info->name;
      D.33165 = *D.33040;
      if (D.33165 == 0) goto <D.33162>; else goto <D.33163>;
      <D.33162>:
      D.33054 = 0;
      return D.33054;
      <D.33163>:
      if (endptr != 0B) goto <D.33166>; else goto <D.33167>;
      <D.33166>:
      p.416 = p;
      *endptr = p.416;
      <D.33167>:
      D.33054 = 1;
      return D.33054;
    }
  finally
    {
      p = {CLOBBER};
    }
}


assembly_name_to_aname (struct MonoAssemblyName * assembly, char * p)
{
  mono_byte[17] * D.33171;
  char D.33172;
  const short unsigned int * * D.33176;
  const short unsigned int * D.33177;
  unsigned int D.33178;
  unsigned int D.33179;
  const short unsigned int * D.33180;
  short unsigned int D.33181;
  int D.33182;
  int D.33183;
  int D.33190;
  int D.33195;
  char * s.439;
  char * s.440;
  char * s.441;
  char * s.442;
  char D.33202;
  unsigned int D.33204;
  unsigned int D.33205;
  const short unsigned int * D.33206;
  short unsigned int D.33207;
  int D.33208;
  int D.33209;
  int D.33213;
  long unsigned int D.33215;
  short unsigned int D.33216;
  char * s.443;
  long unsigned int D.33221;
  short unsigned int D.33222;
  long unsigned int D.33226;
  short unsigned int D.33227;
  long unsigned int D.33231;
  short unsigned int D.33232;
  int D.33238;
  int D.33240;
  char D.33244;
  _Bool D.33245;
  _Bool D.33246;
  _Bool D.33247;
  int D.33250;
  int D.33252;
  char D.33256;
  _Bool D.33257;
  _Bool D.33258;
  _Bool D.33259;
  int p.444;
  int start.445;
  int D.33262;
  unsigned int len.446;
  char D.33266;
  _Bool D.33267;
  _Bool D.33268;
  _Bool D.33269;
  char * p.447;
  int found_sep;
  char * s;
  gboolean quoted;

  try
    {
      quoted = 0;
      memset (assembly, 0, 60);
      assembly->culture = "";
      D.33171 = &assembly->public_key_token;
      memset (D.33171, 0, 17);
      D.33172 = *p;
      if (D.33172 == 34) goto <D.33173>; else goto <D.33174>;
      <D.33173>:
      quoted = 1;
      p = p + 1;
      <D.33174>:
      assembly->name = p;
      goto <D.21057>;
      <D.21056>:
      p = p + 1;
      <D.21057>:
      D.33172 = *p;
      if (D.33172 != 0) goto <D.33175>; else goto <D.21058>;
      <D.33175>:
      D.33176 = __ctype_b_loc ();
      D.33177 = *D.33176;
      D.33172 = *p;
      D.33178 = (unsigned int) D.33172;
      D.33179 = D.33178 * 2;
      D.33180 = D.33177 + D.33179;
      D.33181 = *D.33180;
      D.33182 = (int) D.33181;
      D.33183 = D.33182 & 8;
      if (D.33183 != 0) goto <D.21056>; else goto <D.33184>;
      <D.33184>:
      D.33172 = *p;
      if (D.33172 == 46) goto <D.21056>; else goto <D.33185>;
      <D.33185>:
      D.33172 = *p;
      if (D.33172 == 45) goto <D.21056>; else goto <D.33186>;
      <D.33186>:
      D.33172 = *p;
      if (D.33172 == 95) goto <D.21056>; else goto <D.33187>;
      <D.33187>:
      D.33172 = *p;
      if (D.33172 == 36) goto <D.21056>; else goto <D.33188>;
      <D.33188>:
      D.33172 = *p;
      if (D.33172 == 64) goto <D.21056>; else goto <D.33189>;
      <D.33189>:
      D.33176 = __ctype_b_loc ();
      D.33177 = *D.33176;
      D.33172 = *p;
      D.33178 = (unsigned int) D.33172;
      D.33179 = D.33178 * 2;
      D.33180 = D.33177 + D.33179;
      D.33181 = *D.33180;
      D.33182 = (int) D.33181;
      D.33190 = D.33182 & 8192;
      if (D.33190 != 0) goto <D.21056>; else goto <D.21058>;
      <D.21058>:
      if (quoted != 0) goto <D.33191>; else goto <D.33192>;
      <D.33191>:
      D.33172 = *p;
      if (D.33172 != 34) goto <D.33193>; else goto <D.33194>;
      <D.33193>:
      D.33195 = 1;
      return D.33195;
      <D.33194>:
      *p = 0;
      p = p + 1;
      <D.33192>:
      D.33172 = *p;
      if (D.33172 != 44) goto <D.33196>; else goto <D.33197>;
      <D.33196>:
      D.33195 = 1;
      return D.33195;
      <D.33197>:
      *p = 0;
      s.439 = p + 4294967295;
      s = s.439;
      goto <D.21060>;
      <D.21059>:
      s.440 = s;
      s.441 = s.440;
      s.442 = s.441 + 4294967295;
      s = s.442;
      *s.441 = 0;
      <D.21060>:
      s.440 = s;
      D.33202 = *s.440;
      if (D.33202 != 0) goto <D.33203>; else goto <D.21061>;
      <D.33203>:
      D.33176 = __ctype_b_loc ();
      D.33177 = *D.33176;
      s.440 = s;
      D.33202 = *s.440;
      D.33204 = (unsigned int) D.33202;
      D.33205 = D.33204 * 2;
      D.33206 = D.33177 + D.33205;
      D.33207 = *D.33206;
      D.33208 = (int) D.33207;
      D.33209 = D.33208 & 8192;
      if (D.33209 != 0) goto <D.21059>; else goto <D.21061>;
      <D.21061>:
      p = p + 1;
      goto <D.21063>;
      <D.21062>:
      p = p + 1;
      <D.21063>:
      D.33176 = __ctype_b_loc ();
      D.33177 = *D.33176;
      D.33172 = *p;
      D.33178 = (unsigned int) D.33172;
      D.33179 = D.33178 * 2;
      D.33180 = D.33177 + D.33179;
      D.33181 = *D.33180;
      D.33182 = (int) D.33181;
      D.33190 = D.33182 & 8192;
      if (D.33190 != 0) goto <D.21062>; else goto <D.21064>;
      <D.21064>:
      goto <D.21089>;
      <D.21088>:
      D.33172 = *p;
      if (D.33172 == 86) goto <D.33212>; else goto <D.33210>;
      <D.33212>:
      D.33213 = monoeg_g_ascii_strncasecmp (p, "Version=", 8);
      if (D.33213 == 0) goto <D.33214>; else goto <D.33210>;
      <D.33214>:
      p = p + 8;
      D.33215 = strtoul (p, &s, 10);
      D.33216 = (short unsigned int) D.33215;
      assembly->major = D.33216;
      s.440 = s;
      if (s.440 == p) goto <D.33217>; else goto <D.33219>;
      <D.33219>:
      s.440 = s;
      D.33202 = *s.440;
      if (D.33202 != 46) goto <D.33217>; else goto <D.33218>;
      <D.33217>:
      D.33195 = 1;
      return D.33195;
      <D.33218>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33221 = strtoul (p, &s, 10);
      D.33222 = (short unsigned int) D.33221;
      assembly->minor = D.33222;
      s.440 = s;
      if (s.440 == p) goto <D.33223>; else goto <D.33225>;
      <D.33225>:
      s.440 = s;
      D.33202 = *s.440;
      if (D.33202 != 46) goto <D.33223>; else goto <D.33224>;
      <D.33223>:
      D.33195 = 1;
      return D.33195;
      <D.33224>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33226 = strtoul (p, &s, 10);
      D.33227 = (short unsigned int) D.33226;
      assembly->build = D.33227;
      s.440 = s;
      if (s.440 == p) goto <D.33228>; else goto <D.33230>;
      <D.33230>:
      s.440 = s;
      D.33202 = *s.440;
      if (D.33202 != 46) goto <D.33228>; else goto <D.33229>;
      <D.33228>:
      D.33195 = 1;
      return D.33195;
      <D.33229>:
      s.440 = s;
      s.443 = s.440 + 1;
      s = s.443;
      p = s;
      D.33231 = strtoul (p, &s, 10);
      D.33232 = (short unsigned int) D.33231;
      assembly->revision = D.33232;
      s.440 = s;
      if (s.440 == p) goto <D.33233>; else goto <D.33234>;
      <D.33233>:
      D.33195 = 1;
      return D.33195;
      <D.33234>:
      p = s;
      goto <D.33211>;
      <D.33210>:
      D.33172 = *p;
      if (D.33172 == 67) goto <D.33237>; else goto <D.33235>;
      <D.33237>:
      D.33238 = monoeg_g_ascii_strncasecmp (p, "Culture=", 8);
      if (D.33238 == 0) goto <D.33239>; else goto <D.33235>;
      <D.33239>:
      p = p + 8;
      D.33240 = monoeg_g_ascii_strncasecmp (p, "neutral", 7);
      if (D.33240 == 0) goto <D.33241>; else goto <D.33242>;
      <D.33241>:
      assembly->culture = "";
      p = p + 7;
      goto <D.33243>;
      <D.33242>:
      assembly->culture = p;
      goto <D.21066>;
      <D.21065>:
      p = p + 1;
      <D.21066>:
      D.33244 = *p;
      D.33245 = D.33244 != 0;
      D.33246 = D.33244 != 44;
      D.33247 = D.33245 & D.33246;
      if (D.33247 != 0) goto <D.21065>; else goto <D.21067>;
      <D.21067>:
      <D.33243>:
      goto <D.33236>;
      <D.33235>:
      D.33172 = *p;
      if (D.33172 == 80) goto <D.33249>; else goto <D.33248>;
      <D.33249>:
      D.33250 = monoeg_g_ascii_strncasecmp (p, "PublicKeyToken=", 15);
      if (D.33250 == 0) goto <D.33251>; else goto <D.33248>;
      <D.33251>:
      p = p + 15;
      D.33252 = strncmp (p, "null", 4);
      if (D.33252 == 0) goto <D.33253>; else goto <D.33254>;
      <D.33253>:
      p = p + 4;
      goto <D.33255>;
      <D.33254>:
      {
        int len;
        gchar * start;

        start = p;
        goto <D.21080>;
        <D.21079>:
        p = p + 1;
        <D.21080>:
        D.33256 = *p;
        D.33257 = D.33256 != 0;
        D.33258 = D.33256 != 44;
        D.33259 = D.33257 & D.33258;
        if (D.33259 != 0) goto <D.21079>; else goto <D.21081>;
        <D.21081>:
        p.444 = (int) p;
        start.445 = (int) start;
        D.33262 = p.444 - start.445;
        len = D.33262 + 1;
        if (len > 17) goto <D.33263>; else goto <D.33264>;
        <D.33263>:
        len = 17;
        <D.33264>:
        len.446 = (unsigned int) len;
        D.33171 = &assembly->public_key_token;
        monoeg_g_strlcpy (D.33171, start, len.446);
      }
      <D.33255>:
      goto <D.21084>;
      <D.33248>:
      goto <D.21083>;
      <D.21082>:
      p = p + 1;
      <D.21083>:
      D.33266 = *p;
      D.33267 = D.33266 != 0;
      D.33268 = D.33266 != 44;
      D.33269 = D.33267 & D.33268;
      if (D.33269 != 0) goto <D.21082>; else goto <D.21084>;
      <D.21084>:
      <D.33236>:
      <D.33211>:
      found_sep = 0;
      goto <D.21085>;
      <D.21086>:
      p.447 = p;
      p = p.447 + 1;
      *p.447 = 0;
      found_sep = 1;
      // predicted unlikely by continue predictor.
      goto <D.21085>;
      <D.21085>:
      D.33176 = __ctype_b_loc ();
      D.33177 = *D.33176;
      D.33172 = *p;
      D.33178 = (unsigned int) D.33172;
      D.33179 = D.33178 * 2;
      D.33180 = D.33177 + D.33179;
      D.33181 = *D.33180;
      D.33182 = (int) D.33181;
      D.33190 = D.33182 & 8192;
      if (D.33190 != 0) goto <D.21086>; else goto <D.33271>;
      <D.33271>:
      D.33172 = *p;
      if (D.33172 == 44) goto <D.21086>; else goto <D.21087>;
      <D.21087>:
      if (found_sep == 0) goto <D.33272>; else goto <D.33273>;
      <D.33272>:
      D.33195 = 1;
      return D.33195;
      <D.33273>:
      <D.21089>:
      D.33172 = *p;
      if (D.33172 != 0) goto <D.21088>; else goto <D.21090>;
      <D.21090>:
      D.33195 = 0;
      return D.33195;
    }
  finally
    {
      s = {CLOBBER};
    }
}


mono_reflection_get_type (struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  struct MonoType * D.33276;

  D.33276 = mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve);
  return D.33276;
}


mono_reflection_get_type_with_rootimage (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  unsigned char D.33281;
  unsigned char D.33282;
  struct MonoAssembly * D.33284;
  struct MonoType * D.33287;
  struct MonoDomain * D.33288;
  int D.33289;
  int D.33294;
  char * D.33299;
  char D.33301;
  char * D.33303;
  void * D.33304;
  char * D.33305;
  struct MonoDomain * D.33306;
  struct MonoAssembly * D.33309;
  unsigned char D.33310;
  struct MonoImage * D.33314;
  struct MonoType * type;
  struct MonoReflectionAssembly * assembly;
  struct GString * fullName;
  struct GList * mod;

  if (image != 0B) goto <D.33280>; else goto <D.33278>;
  <D.33280>:
  D.33281 = BIT_FIELD_REF <*image, 8, 128>;
  D.33282 = D.33281 & 8;
  if (D.33282 != 0) goto <D.33283>; else goto <D.33278>;
  <D.33283>:
  D.33284 = image->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33284, info, ignorecase);
  goto <D.33279>;
  <D.33278>:
  type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
  <D.33279>:
  if (type != 0B) goto <D.33285>; else goto <D.33286>;
  <D.33285>:
  D.33287 = type;
  return D.33287;
  <D.33286>:
  D.33288 = mono_domain_get ();
  D.33289 = mono_domain_has_type_resolve (D.33288);
  if (D.33289 == 0) goto <D.33290>; else goto <D.33291>;
  <D.33290>:
  D.33287 = 0B;
  return D.33287;
  <D.33291>:
  if (type_resolve != 0B) goto <D.33292>; else goto <D.33293>;
  <D.33292>:
  D.33294 = *type_resolve;
  if (D.33294 != 0) goto <D.33295>; else goto <D.33296>;
  <D.33295>:
  D.33287 = 0B;
  return D.33287;
  <D.33296>:
  *type_resolve = 1;
  <D.33293>:
  fullName = monoeg_g_string_new ("");
  D.33299 = info->name_space;
  if (D.33299 != 0B) goto <D.33300>; else goto <D.33297>;
  <D.33300>:
  D.33299 = info->name_space;
  D.33301 = *D.33299;
  if (D.33301 != 0) goto <D.33302>; else goto <D.33297>;
  <D.33302>:
  D.33303 = info->name;
  D.33299 = info->name_space;
  monoeg_g_string_printf (fullName, "%s.%s", D.33299, D.33303);
  goto <D.33298>;
  <D.33297>:
  D.33303 = info->name;
  monoeg_g_string_printf (fullName, "%s", D.33303);
  <D.33298>:
  mod = info->nested;
  goto <D.21236>;
  <D.21235>:
  D.33304 = mod->data;
  monoeg_g_string_append_printf (fullName, "+%s", D.33304);
  mod = mod->next;
  <D.21236>:
  if (mod != 0B) goto <D.21235>; else goto <D.21237>;
  <D.21237>:
  D.33305 = fullName->str;
  D.33306 = mono_domain_get ();
  assembly = mono_domain_try_type_resolve (D.33306, D.33305, 0B);
  if (assembly != 0B) goto <D.33307>; else goto <D.33308>;
  <D.33307>:
  D.33309 = assembly->assembly;
  D.33310 = D.33309->dynamic;
  if (D.33310 != 0) goto <D.33311>; else goto <D.33312>;
  <D.33311>:
  D.33309 = assembly->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33309, info, ignorecase);
  goto <D.33313>;
  <D.33312>:
  D.33309 = assembly->assembly;
  D.33314 = D.33309->image;
  type = mono_reflection_get_type_internal (rootimage, D.33314, info, ignorecase);
  <D.33313>:
  <D.33308>:
  monoeg_g_string_free (fullName, 1);
  D.33287 = type;
  return D.33287;
}


mono_reflection_get_type_internal_dynamic (struct MonoImage * rootimage, struct MonoAssembly * assembly, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  unsigned char D.33316;
  _Bool D.33317;
  long int D.33318;
  long int D.33319;
  struct MonoDomain * D.33322;
  struct MonoArray * D.33323;
  unsigned int i.448;
  char * D.33327;
  struct MonoDynamicImage * D.33328;
  struct MonoImage * D.33329;
  unsigned int D.33331;
  struct MonoArray * D.33334;
  char * D.33337;
  struct MonoImage * D.33338;
  unsigned int D.33340;
  struct MonoType * D.33341;
  struct MonoReflectionAssemblyBuilder * abuilder;
  struct MonoType * type;
  int i;

  D.33316 = assembly->dynamic;
  D.33317 = D.33316 == 0;
  D.33318 = (long int) D.33317;
  D.33319 = __builtin_expect (D.33318, 0);
  if (D.33319 != 0) goto <D.33320>; else goto <D.33321>;
  <D.33320>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7574, "assembly->dynamic");
  <D.33321>:
  D.33322 = MEM[(struct MonoDynamicAssembly *)assembly].domain;
  abuilder = mono_assembly_get_object (D.33322, assembly);
  type = 0B;
  D.33323 = abuilder->modules;
  if (D.33323 != 0B) goto <D.33324>; else goto <D.33325>;
  <D.33324>:
  i = 0;
  goto <D.21219>;
  <D.21218>:
  {
    struct MonoReflectionModuleBuilder * mb;

    i.448 = (unsigned int) i;
    D.33323 = abuilder->modules;
    D.33327 = mono_array_addr_with_size (D.33323, 4, i.448);
    mb = MEM[(struct MonoReflectionModuleBuilder * *)D.33327];
    D.33328 = mb->dynamic_image;
    D.33329 = &D.33328->image;
    type = mono_reflection_get_type_internal (rootimage, D.33329, info, ignorecase);
    if (type != 0B) goto <D.21217>; else goto <D.33330>;
    <D.33330>:
  }
  i = i + 1;
  <D.21219>:
  i.448 = (unsigned int) i;
  D.33323 = abuilder->modules;
  D.33331 = mono_array_length (D.33323);
  if (i.448 < D.33331) goto <D.21218>; else goto <D.21217>;
  <D.21217>:
  <D.33325>:
  if (type == 0B) goto <D.33332>; else goto <D.33333>;
  <D.33332>:
  D.33334 = abuilder->loaded_modules;
  if (D.33334 != 0B) goto <D.33335>; else goto <D.33336>;
  <D.33335>:
  i = 0;
  goto <D.21223>;
  <D.21222>:
  {
    struct MonoReflectionModule * mod;

    i.448 = (unsigned int) i;
    D.33334 = abuilder->loaded_modules;
    D.33337 = mono_array_addr_with_size (D.33334, 4, i.448);
    mod = MEM[(struct MonoReflectionModule * *)D.33337];
    D.33338 = mod->image;
    type = mono_reflection_get_type_internal (rootimage, D.33338, info, ignorecase);
    if (type != 0B) goto <D.21221>; else goto <D.33339>;
    <D.33339>:
  }
  i = i + 1;
  <D.21223>:
  i.448 = (unsigned int) i;
  D.33334 = abuilder->loaded_modules;
  D.33340 = mono_array_length (D.33334);
  if (i.448 < D.33340) goto <D.21222>; else goto <D.21221>;
  <D.21221>:
  <D.33336>:
  <D.33333>:
  D.33341 = type;
  return D.33341;
}


mono_reflection_get_type_internal (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  char * D.33347;
  char * D.33348;
  struct MonoType * D.33352;
  void * D.33355;
  const char * D.33356;
  int D.33357;
  int D.21184;
  struct GPtrArray * D.33364;
  unsigned int D.33367;
  unsigned int D.33368;
  void * * D.33369;
  unsigned int i.449;
  unsigned int D.33371;
  void * * D.33372;
  struct MonoType * * D.33373;
  struct MonoType * D.33374;
  struct MonoType * D.33375;
  unsigned int i.450;
  struct MonoType * D.33379;
  struct MonoDomain * D.33380;
  int D.33381;
  unsigned int modval.451;
  struct MonoClass * klass;
  struct GList * mod;
  int modval;
  gboolean bounded;

  bounded = 0;
  if (image == 0B) goto <D.33343>; else goto <D.33344>;
  <D.33343>:
  image = mono_defaults.corlib;
  <D.33344>:
  if (ignorecase != 0) goto <D.33345>; else goto <D.33346>;
  <D.33345>:
  D.33347 = info->name;
  D.33348 = info->name_space;
  klass = mono_class_from_name_case (image, D.33348, D.33347);
  goto <D.33349>;
  <D.33346>:
  D.33347 = info->name;
  D.33348 = info->name_space;
  klass = mono_class_from_name (image, D.33348, D.33347);
  <D.33349>:
  if (klass == 0B) goto <D.33350>; else goto <D.33351>;
  <D.33350>:
  D.33352 = 0B;
  return D.33352;
  <D.33351>:
  mod = info->nested;
  goto <D.21189>;
  <D.21188>:
  {
    void * iter;
    struct MonoClass * parent;

    try
      {
        iter = 0B;
        parent = klass;
        mono_class_init (parent);
        goto <D.21186>;
        <D.21185>:
        if (ignorecase != 0) goto <D.33353>; else goto <D.33354>;
        <D.33353>:
        D.33355 = mod->data;
        D.33356 = klass->name;
        D.33357 = monoeg_ascii_strcasecmp (D.33356, D.33355);
        if (D.33357 == 0) goto <D.21175>; else goto <D.33358>;
        <D.33358>:
        goto <D.33359>;
        <D.33354>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.33355 = mod->data;
          D.33356 = klass->name;
          D.21184 = __builtin_strcmp (D.33356, D.33355);
        }
        if (D.21184 == 0) goto <D.21175>; else goto <D.33360>;
        <D.33360>:
        <D.33359>:
        <D.21186>:
        klass = mono_class_get_nested_types (parent, &iter);
        if (klass != 0B) goto <D.21185>; else goto <D.21175>;
        <D.21175>:
        if (klass == 0B) goto <D.21187>; else goto <D.33361>;
        <D.33361>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  mod = mod->next;
  <D.21189>:
  if (mod != 0B) goto <D.21188>; else goto <D.21187>;
  <D.21187>:
  if (klass == 0B) goto <D.33362>; else goto <D.33363>;
  <D.33362>:
  D.33352 = 0B;
  return D.33352;
  <D.33363>:
  D.33364 = info->type_arguments;
  if (D.33364 != 0B) goto <D.33365>; else goto <D.33366>;
  <D.33365>:
  {
    struct MonoType * * type_args;
    struct MonoReflectionType * the_type;
    struct MonoType * instance;
    int i;

    D.33364 = info->type_arguments;
    D.33367 = D.33364->len;
    D.33368 = D.33367 * 4;
    type_args = monoeg_malloc0 (D.33368);
    i = 0;
    goto <D.21196>;
    <D.21195>:
    {
      struct MonoTypeNameParse * subinfo;

      D.33364 = info->type_arguments;
      D.33369 = D.33364->pdata;
      i.449 = (unsigned int) i;
      D.33371 = i.449 * 4;
      D.33372 = D.33369 + D.33371;
      subinfo = *D.33372;
      i.449 = (unsigned int) i;
      D.33371 = i.449 * 4;
      D.33373 = type_args + D.33371;
      D.33374 = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
      *D.33373 = D.33374;
      i.449 = (unsigned int) i;
      D.33371 = i.449 * 4;
      D.33373 = type_args + D.33371;
      D.33375 = *D.33373;
      if (D.33375 == 0B) goto <D.33376>; else goto <D.33377>;
      <D.33376>:
      monoeg_g_free (type_args);
      D.33352 = 0B;
      return D.33352;
      <D.33377>:
    }
    i = i + 1;
    <D.21196>:
    i.450 = (unsigned int) i;
    D.33364 = info->type_arguments;
    D.33367 = D.33364->len;
    if (i.450 < D.33367) goto <D.21195>; else goto <D.21197>;
    <D.21197>:
    D.33379 = &klass->byval_arg;
    D.33380 = mono_domain_get ();
    the_type = mono_type_get_object (D.33380, D.33379);
    D.33364 = info->type_arguments;
    D.33367 = D.33364->len;
    D.33381 = (int) D.33367;
    instance = mono_reflection_bind_generic_parameters (the_type, D.33381, type_args);
    monoeg_g_free (type_args);
    if (instance == 0B) goto <D.33382>; else goto <D.33383>;
    <D.33382>:
    D.33352 = 0B;
    return D.33352;
    <D.33383>:
    klass = mono_class_from_mono_type (instance);
  }
  <D.33366>:
  mod = info->modifiers;
  goto <D.21199>;
  <D.21198>:
  D.33355 = mod->data;
  modval = (int) D.33355;
  if (modval == 0) goto <D.33384>; else goto <D.33385>;
  <D.33384>:
  D.33352 = &klass->this_arg;
  return D.33352;
  <D.33385>:
  if (modval == -1) goto <D.33386>; else goto <D.33387>;
  <D.33386>:
  D.33379 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.33379);
  goto <D.33388>;
  <D.33387>:
  if (modval == -2) goto <D.33389>; else goto <D.33390>;
  <D.33389>:
  bounded = 1;
  goto <D.33391>;
  <D.33390>:
  modval.451 = (unsigned int) modval;
  klass = mono_bounded_array_class_get (klass, modval.451, bounded);
  <D.33391>:
  <D.33388>:
  mod = mod->next;
  <D.21199>:
  if (mod != 0B) goto <D.21198>; else goto <D.21200>;
  <D.21200>:
  D.33352 = &klass->byval_arg;
  return D.33352;
}


_mono_reflection_get_type_from_info (struct MonoTypeNameParse * info, struct MonoImage * image, gboolean ignorecase)
{
  const char * D.33396;
  struct MonoAssemblyName * D.33399;
  _Bool D.33400;
  _Bool D.33401;
  _Bool D.33402;
  struct MonoAssembly * D.33405;
  struct MonoAssemblyName * D.33408;
  int D.33409;
  struct MonoType * D.33416;
  struct MonoImage * D.33424;
  gboolean type_resolve;
  struct MonoType * type;
  struct MonoImage * rootimage;

  try
    {
      type_resolve = 0;
      rootimage = image;
      D.33396 = info->assembly.name;
      if (D.33396 != 0B) goto <D.33397>; else goto <D.33398>;
      <D.33397>:
      {
        struct MonoAssembly * assembly;

        D.33399 = &info->assembly;
        assembly = mono_assembly_loaded (D.33399);
        D.33400 = assembly == 0B;
        D.33401 = image != 0B;
        D.33402 = D.33400 & D.33401;
        if (D.33402 != 0) goto <D.33403>; else goto <D.33404>;
        <D.33403>:
        D.33405 = image->assembly;
        if (D.33405 != 0B) goto <D.33406>; else goto <D.33407>;
        <D.33406>:
        D.33405 = image->assembly;
        D.33408 = &D.33405->aname;
        D.33399 = &info->assembly;
        D.33409 = mono_assembly_names_equal (D.33399, D.33408);
        if (D.33409 != 0) goto <D.33410>; else goto <D.33411>;
        <D.33410>:
        assembly = image->assembly;
        <D.33411>:
        <D.33407>:
        <D.33404>:
        if (assembly == 0B) goto <D.33412>; else goto <D.33413>;
        <D.33412>:
        D.33399 = &info->assembly;
        assembly = mono_assembly_load (D.33399, 0B, 0B);
        if (assembly == 0B) goto <D.33414>; else goto <D.33415>;
        <D.33414>:
        D.33416 = 0B;
        return D.33416;
        <D.33415>:
        <D.33413>:
        image = assembly->image;
      }
      goto <D.33417>;
      <D.33398>:
      if (image == 0B) goto <D.33418>; else goto <D.33419>;
      <D.33418>:
      image = mono_defaults.corlib;
      <D.33419>:
      <D.33417>:
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      if (type == 0B) goto <D.33420>; else goto <D.33421>;
      <D.33420>:
      D.33396 = info->assembly.name;
      if (D.33396 == 0B) goto <D.33422>; else goto <D.33423>;
      <D.33422>:
      D.33424 = mono_defaults.corlib;
      if (D.33424 != image) goto <D.33425>; else goto <D.33426>;
      <D.33425>:
      image = mono_defaults.corlib;
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      <D.33426>:
      <D.33423>:
      <D.33421>:
      D.33416 = type;
      return D.33416;
    }
  finally
    {
      type_resolve = {CLOBBER};
    }
}


mono_reflection_free_type_info (struct MonoTypeNameParse * info)
{
  struct GList * D.33429;
  struct GList * D.33430;
  struct GPtrArray * D.33431;
  void * * D.33434;
  unsigned int i.452;
  unsigned int D.33436;
  void * * D.33437;
  unsigned int i.453;
  unsigned int D.33439;

  D.33429 = info->modifiers;
  monoeg_g_list_free (D.33429);
  D.33430 = info->nested;
  monoeg_g_list_free (D.33430);
  D.33431 = info->type_arguments;
  if (D.33431 != 0B) goto <D.33432>; else goto <D.33433>;
  <D.33432>:
  {
    int i;

    i = 0;
    goto <D.21244>;
    <D.21243>:
    {
      struct MonoTypeNameParse * subinfo;

      D.33431 = info->type_arguments;
      D.33434 = D.33431->pdata;
      i.452 = (unsigned int) i;
      D.33436 = i.452 * 4;
      D.33437 = D.33434 + D.33436;
      subinfo = *D.33437;
      mono_reflection_free_type_info (subinfo);
      monoeg_g_free (subinfo);
    }
    i = i + 1;
    <D.21244>:
    i.453 = (unsigned int) i;
    D.33431 = info->type_arguments;
    D.33439 = D.33431->len;
    if (i.453 < D.33439) goto <D.21243>; else goto <D.21245>;
    <D.21245>:
    D.33431 = info->type_arguments;
    monoeg_g_ptr_array_free (D.33431, 1);
  }
  <D.33433>:
}


mono_reflection_type_from_name (char * name, struct MonoImage * image)
{
  int D.33440;
  struct MonoType * D.33443;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  char * tmp;

  try
    {
      type = 0B;
      tmp = monoeg_strdup (name);
      D.33440 = mono_reflection_parse_type (tmp, &info);
      if (D.33440 != 0) goto <D.33441>; else goto <D.33442>;
      <D.33441>:
      type = _mono_reflection_get_type_from_info (&info, image, 0);
      <D.33442>:
      monoeg_g_free (tmp);
      mono_reflection_free_type_info (&info);
      D.33443 = type;
      return D.33443;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_reflection_get_token (struct MonoObject * obj)
{
  struct MonoVTable * D.33446;
  int D.21266;
  int iftmp.454;
  int D.21265;
  const char[14] * D.33450;
  unsigned char D.33451;
  int D.33452;
  unsigned char D.33453;
  int D.33454;
  _Bool D.33455;
  _Bool D.33456;
  _Bool D.33457;
  const unsigned char * D.33460;
  unsigned char D.33461;
  int D.33462;
  const unsigned char * D.33463;
  unsigned char D.33464;
  int D.33465;
  _Bool D.33466;
  _Bool D.33467;
  const unsigned char * D.33470;
  unsigned char D.33471;
  int D.33472;
  const unsigned char * D.33473;
  unsigned char D.33474;
  int D.33475;
  _Bool D.33476;
  _Bool D.33477;
  const unsigned char * D.33480;
  unsigned char D.33481;
  int D.33482;
  const unsigned char * D.33483;
  unsigned char D.33484;
  int D.33485;
  const char * D.33487;
  unsigned int D.33490;
  int D.21276;
  int iftmp.455;
  int D.21275;
  const char[19] * D.33495;
  unsigned char D.33496;
  int D.33497;
  unsigned char D.33498;
  int D.33499;
  _Bool D.33500;
  _Bool D.33501;
  _Bool D.33502;
  const unsigned char * D.33505;
  unsigned char D.33506;
  int D.33507;
  const unsigned char * D.33508;
  unsigned char D.33509;
  int D.33510;
  _Bool D.33511;
  _Bool D.33512;
  const unsigned char * D.33515;
  unsigned char D.33516;
  int D.33517;
  const unsigned char * D.33518;
  unsigned char D.33519;
  int D.33520;
  _Bool D.33521;
  _Bool D.33522;
  const unsigned char * D.33525;
  unsigned char D.33526;
  int D.33527;
  const unsigned char * D.33528;
  unsigned char D.33529;
  int D.33530;
  unsigned int D.33534;
  int D.21286;
  int iftmp.456;
  int D.21285;
  const char[13] * D.33539;
  unsigned char D.33540;
  int D.33541;
  unsigned char D.33542;
  int D.33543;
  _Bool D.33544;
  _Bool D.33545;
  _Bool D.33546;
  const unsigned char * D.33549;
  unsigned char D.33550;
  int D.33551;
  const unsigned char * D.33552;
  unsigned char D.33553;
  int D.33554;
  _Bool D.33555;
  _Bool D.33556;
  const unsigned char * D.33559;
  unsigned char D.33560;
  int D.33561;
  const unsigned char * D.33562;
  unsigned char D.33563;
  int D.33564;
  _Bool D.33565;
  _Bool D.33566;
  const unsigned char * D.33569;
  unsigned char D.33570;
  int D.33571;
  const unsigned char * D.33572;
  unsigned char D.33573;
  int D.33574;
  int D.33578;
  int D.33579;
  int D.21296;
  int iftmp.457;
  int D.21295;
  const char[12] * D.33584;
  unsigned char D.33585;
  int D.33586;
  unsigned char D.33587;
  int D.33588;
  _Bool D.33589;
  _Bool D.33590;
  _Bool D.33591;
  const unsigned char * D.33594;
  unsigned char D.33595;
  int D.33596;
  const unsigned char * D.33597;
  unsigned char D.33598;
  int D.33599;
  _Bool D.33600;
  _Bool D.33601;
  const unsigned char * D.33604;
  unsigned char D.33605;
  int D.33606;
  const unsigned char * D.33607;
  unsigned char D.33608;
  int D.33609;
  _Bool D.33610;
  _Bool D.33611;
  const unsigned char * D.33614;
  unsigned char D.33615;
  int D.33616;
  const unsigned char * D.33617;
  unsigned char D.33618;
  int D.33619;
  unsigned int D.33623;
  int D.21306;
  int iftmp.458;
  int D.21305;
  const char[9] * D.33628;
  unsigned char D.33629;
  int D.33630;
  unsigned char D.33631;
  int D.33632;
  _Bool D.33633;
  _Bool D.33634;
  _Bool D.33635;
  const unsigned char * D.33638;
  unsigned char D.33639;
  int D.33640;
  const unsigned char * D.33641;
  unsigned char D.33642;
  int D.33643;
  _Bool D.33644;
  _Bool D.33645;
  const unsigned char * D.33648;
  unsigned char D.33649;
  int D.33650;
  const unsigned char * D.33651;
  unsigned char D.33652;
  int D.33653;
  _Bool D.33654;
  _Bool D.33655;
  const unsigned char * D.33658;
  unsigned char D.33659;
  int D.33660;
  const unsigned char * D.33661;
  unsigned char D.33662;
  int D.33663;
  int D.33667;
  struct MonoException * D.33670;
  int D.21317;
  int iftmp.459;
  int D.21316;
  const char[12] * D.33678;
  unsigned char D.33679;
  int D.33680;
  unsigned char D.33681;
  int D.33682;
  _Bool D.33683;
  _Bool D.33684;
  _Bool D.33685;
  const unsigned char * D.33688;
  unsigned char D.33689;
  int D.33690;
  const unsigned char * D.33691;
  unsigned char D.33692;
  int D.33693;
  _Bool D.33694;
  _Bool D.33695;
  const unsigned char * D.33698;
  unsigned char D.33699;
  int D.33700;
  const unsigned char * D.33701;
  unsigned char D.33702;
  int D.33703;
  _Bool D.33704;
  _Bool D.33705;
  const unsigned char * D.33708;
  unsigned char D.33709;
  int D.33710;
  const unsigned char * D.33711;
  unsigned char D.33712;
  int D.33713;
  int D.21326;
  int iftmp.460;
  int D.21325;
  const char[11] * D.33719;
  unsigned char D.33720;
  int D.33721;
  unsigned char D.33722;
  int D.33723;
  _Bool D.33724;
  _Bool D.33725;
  _Bool D.33726;
  const unsigned char * D.33729;
  unsigned char D.33730;
  int D.33731;
  const unsigned char * D.33732;
  unsigned char D.33733;
  int D.33734;
  _Bool D.33735;
  _Bool D.33736;
  const unsigned char * D.33739;
  unsigned char D.33740;
  int D.33741;
  const unsigned char * D.33742;
  unsigned char D.33743;
  int D.33744;
  _Bool D.33745;
  _Bool D.33746;
  const unsigned char * D.33749;
  unsigned char D.33750;
  int D.33751;
  const unsigned char * D.33752;
  unsigned char D.33753;
  int D.33754;
  int D.21335;
  int iftmp.461;
  int D.21334;
  const char[18] * D.33760;
  unsigned char D.33761;
  int D.33762;
  unsigned char D.33763;
  int D.33764;
  _Bool D.33765;
  _Bool D.33766;
  _Bool D.33767;
  const unsigned char * D.33770;
  unsigned char D.33771;
  int D.33772;
  const unsigned char * D.33773;
  unsigned char D.33774;
  int D.33775;
  _Bool D.33776;
  _Bool D.33777;
  const unsigned char * D.33780;
  unsigned char D.33781;
  int D.33782;
  const unsigned char * D.33783;
  unsigned char D.33784;
  int D.33785;
  _Bool D.33786;
  _Bool D.33787;
  const unsigned char * D.33790;
  unsigned char D.33791;
  int D.33792;
  const unsigned char * D.33793;
  unsigned char D.33794;
  int D.33795;
  int D.21344;
  int iftmp.462;
  int D.21343;
  const char[19] * D.33801;
  unsigned char D.33802;
  int D.33803;
  unsigned char D.33804;
  int D.33805;
  _Bool D.33806;
  _Bool D.33807;
  _Bool D.33808;
  const unsigned char * D.33811;
  unsigned char D.33812;
  int D.33813;
  const unsigned char * D.33814;
  unsigned char D.33815;
  int D.33816;
  _Bool D.33817;
  _Bool D.33818;
  const unsigned char * D.33821;
  unsigned char D.33822;
  int D.33823;
  const unsigned char * D.33824;
  unsigned char D.33825;
  int D.33826;
  _Bool D.33827;
  _Bool D.33828;
  const unsigned char * D.33831;
  unsigned char D.33832;
  int D.33833;
  const unsigned char * D.33834;
  unsigned char D.33835;
  int D.33836;
  struct MonoMethod * D.33838;
  unsigned char D.33839;
  unsigned char D.33840;
  uint32_t D.33843;
  struct MonoMethod * D.33844;
  int D.21355;
  int iftmp.463;
  int D.21354;
  const char[10] * D.33848;
  unsigned char D.33849;
  int D.33850;
  unsigned char D.33851;
  int D.33852;
  _Bool D.33853;
  _Bool D.33854;
  _Bool D.33855;
  const unsigned char * D.33858;
  unsigned char D.33859;
  int D.33860;
  const unsigned char * D.33861;
  unsigned char D.33862;
  int D.33863;
  _Bool D.33864;
  _Bool D.33865;
  const unsigned char * D.33868;
  unsigned char D.33869;
  int D.33870;
  const unsigned char * D.33871;
  unsigned char D.33872;
  int D.33873;
  _Bool D.33874;
  _Bool D.33875;
  const unsigned char * D.33878;
  unsigned char D.33879;
  int D.33880;
  const unsigned char * D.33881;
  unsigned char D.33882;
  int D.33883;
  struct MonoClassField * D.33887;
  int D.33888;
  struct MonoClass * D.33891;
  int D.33892;
  struct MonoClassField * D.33893;
  int D.33894;
  int D.33895;
  int iftmp.464;
  int D.33901;
  _Bool D.33902;
  long int D.33903;
  long int D.33904;
  struct MonoObject * * D.33907;
  unsigned int field_index.465;
  unsigned int D.33909;
  struct MonoObject * * D.33910;
  int D.21368;
  int iftmp.466;
  int D.21367;
  const char[13] * D.33915;
  unsigned char D.33916;
  int D.33917;
  unsigned char D.33918;
  int D.33919;
  _Bool D.33920;
  _Bool D.33921;
  _Bool D.33922;
  const unsigned char * D.33925;
  unsigned char D.33926;
  int D.33927;
  const unsigned char * D.33928;
  unsigned char D.33929;
  int D.33930;
  _Bool D.33931;
  _Bool D.33932;
  const unsigned char * D.33935;
  unsigned char D.33936;
  int D.33937;
  const unsigned char * D.33938;
  unsigned char D.33939;
  int D.33940;
  _Bool D.33941;
  _Bool D.33942;
  const unsigned char * D.33945;
  unsigned char D.33946;
  int D.33947;
  const unsigned char * D.33948;
  unsigned char D.33949;
  int D.33950;
  struct MonoProperty * D.33954;
  int D.21378;
  int iftmp.467;
  int D.21377;
  const char[10] * D.33959;
  unsigned char D.33960;
  int D.33961;
  unsigned char D.33962;
  int D.33963;
  _Bool D.33964;
  _Bool D.33965;
  _Bool D.33966;
  const unsigned char * D.33969;
  unsigned char D.33970;
  int D.33971;
  const unsigned char * D.33972;
  unsigned char D.33973;
  int D.33974;
  _Bool D.33975;
  _Bool D.33976;
  const unsigned char * D.33979;
  unsigned char D.33980;
  int D.33981;
  const unsigned char * D.33982;
  unsigned char D.33983;
  int D.33984;
  _Bool D.33985;
  _Bool D.33986;
  const unsigned char * D.33989;
  unsigned char D.33990;
  int D.33991;
  const unsigned char * D.33992;
  unsigned char D.33993;
  int D.33994;
  struct MonoEvent * D.33998;
  int D.21388;
  int iftmp.468;
  int D.21387;
  const char[14] * D.34006;
  unsigned char D.34007;
  int D.34008;
  unsigned char D.34009;
  int D.34010;
  _Bool D.34011;
  _Bool D.34012;
  _Bool D.34013;
  const unsigned char * D.34016;
  unsigned char D.34017;
  int D.34018;
  const unsigned char * D.34019;
  unsigned char D.34020;
  int D.34021;
  _Bool D.34022;
  _Bool D.34023;
  const unsigned char * D.34026;
  unsigned char D.34027;
  int D.34028;
  const unsigned char * D.34029;
  unsigned char D.34030;
  int D.34031;
  _Bool D.34032;
  _Bool D.34033;
  const unsigned char * D.34036;
  unsigned char D.34037;
  int D.34038;
  const unsigned char * D.34039;
  unsigned char D.34040;
  int D.34041;
  int D.21397;
  int iftmp.469;
  int D.21396;
  const char[18] * D.34047;
  unsigned char D.34048;
  int D.34049;
  unsigned char D.34050;
  int D.34051;
  _Bool D.34052;
  _Bool D.34053;
  _Bool D.34054;
  const unsigned char * D.34057;
  unsigned char D.34058;
  int D.34059;
  const unsigned char * D.34060;
  unsigned char D.34061;
  int D.34062;
  _Bool D.34063;
  _Bool D.34064;
  const unsigned char * D.34067;
  unsigned char D.34068;
  int D.34069;
  const unsigned char * D.34070;
  unsigned char D.34071;
  int D.34072;
  _Bool D.34073;
  _Bool D.34074;
  const unsigned char * D.34077;
  unsigned char D.34078;
  int D.34079;
  const unsigned char * D.34080;
  unsigned char D.34081;
  int D.34082;
  struct MonoObject * D.34084;
  struct MonoVTable * D.34085;
  int D.34086;
  _Bool D.34087;
  long int D.34088;
  long int D.34089;
  int D.34092;
  struct MonoMethod * D.34093;
  int D.21408;
  int iftmp.470;
  int D.21407;
  const char[7] * D.34100;
  unsigned char D.34101;
  int D.34102;
  unsigned char D.34103;
  int D.34104;
  _Bool D.34105;
  _Bool D.34106;
  _Bool D.34107;
  const unsigned char * D.34110;
  unsigned char D.34111;
  int D.34112;
  const unsigned char * D.34113;
  unsigned char D.34114;
  int D.34115;
  _Bool D.34116;
  _Bool D.34117;
  const unsigned char * D.34120;
  unsigned char D.34121;
  int D.34122;
  const unsigned char * D.34123;
  unsigned char D.34124;
  int D.34125;
  _Bool D.34126;
  _Bool D.34127;
  const unsigned char * D.34130;
  unsigned char D.34131;
  int D.34132;
  const unsigned char * D.34133;
  unsigned char D.34134;
  int D.34135;
  int D.21417;
  int iftmp.471;
  int D.21416;
  const char[11] * D.34141;
  unsigned char D.34142;
  int D.34143;
  unsigned char D.34144;
  int D.34145;
  _Bool D.34146;
  _Bool D.34147;
  _Bool D.34148;
  const unsigned char * D.34151;
  unsigned char D.34152;
  int D.34153;
  const unsigned char * D.34154;
  unsigned char D.34155;
  int D.34156;
  _Bool D.34157;
  _Bool D.34158;
  const unsigned char * D.34161;
  unsigned char D.34162;
  int D.34163;
  const unsigned char * D.34164;
  unsigned char D.34165;
  int D.34166;
  _Bool D.34167;
  _Bool D.34168;
  const unsigned char * D.34171;
  unsigned char D.34172;
  int D.34173;
  const unsigned char * D.34174;
  unsigned char D.34175;
  int D.34176;
  int D.21427;
  int iftmp.472;
  int D.21426;
  const char[9] * D.34184;
  unsigned char D.34185;
  int D.34186;
  unsigned char D.34187;
  int D.34188;
  _Bool D.34189;
  _Bool D.34190;
  _Bool D.34191;
  const unsigned char * D.34194;
  unsigned char D.34195;
  int D.34196;
  const unsigned char * D.34197;
  unsigned char D.34198;
  int D.34199;
  _Bool D.34200;
  _Bool D.34201;
  const unsigned char * D.34204;
  unsigned char D.34205;
  int D.34206;
  const unsigned char * D.34207;
  unsigned char D.34208;
  int D.34209;
  _Bool D.34210;
  _Bool D.34211;
  const unsigned char * D.34214;
  unsigned char D.34215;
  int D.34216;
  const unsigned char * D.34217;
  unsigned char D.34218;
  int D.34219;
  int D.21436;
  int iftmp.473;
  int D.21435;
  const char[13] * D.34225;
  unsigned char D.34226;
  int D.34227;
  unsigned char D.34228;
  int D.34229;
  _Bool D.34230;
  _Bool D.34231;
  _Bool D.34232;
  const unsigned char * D.34235;
  unsigned char D.34236;
  int D.34237;
  const unsigned char * D.34238;
  unsigned char D.34239;
  int D.34240;
  _Bool D.34241;
  _Bool D.34242;
  const unsigned char * D.34245;
  unsigned char D.34246;
  int D.34247;
  const unsigned char * D.34248;
  unsigned char D.34249;
  int D.34250;
  _Bool D.34251;
  _Bool D.34252;
  const unsigned char * D.34255;
  unsigned char D.34256;
  int D.34257;
  const unsigned char * D.34258;
  unsigned char D.34259;
  int D.34260;
  const char * D.34262;
  struct MonoClass * klass;
  guint32 token;

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

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

      __s2 = klass->name;
      D.33450 = "MethodBuilder";
      D.33451 = MEM[(const unsigned char *)D.33450];
      D.33452 = (int) D.33451;
      D.33453 = *__s2;
      D.33454 = (int) D.33453;
      __result = D.33452 - D.33454;
      {
        D.33455 = __s2_len != 0;
        D.33456 = __result == 0;
        D.33457 = D.33455 & D.33456;
        if (D.33457 != 0) goto <D.33458>; else goto <D.33459>;
        <D.33458>:
        D.33460 = &MEM[(void *)"MethodBuilder" + 1B];
        D.33461 = *D.33460;
        D.33462 = (int) D.33461;
        D.33463 = __s2 + 1;
        D.33464 = *D.33463;
        D.33465 = (int) D.33464;
        __result = D.33462 - D.33465;
        D.33466 = __s2_len > 1;
        D.33456 = __result == 0;
        D.33467 = D.33466 & D.33456;
        if (D.33467 != 0) goto <D.33468>; else goto <D.33469>;
        <D.33468>:
        D.33470 = &MEM[(void *)"MethodBuilder" + 2B];
        D.33471 = *D.33470;
        D.33472 = (int) D.33471;
        D.33473 = __s2 + 2;
        D.33474 = *D.33473;
        D.33475 = (int) D.33474;
        __result = D.33472 - D.33475;
        D.33476 = __s2_len > 2;
        D.33456 = __result == 0;
        D.33477 = D.33476 & D.33456;
        if (D.33477 != 0) goto <D.33478>; else goto <D.33479>;
        <D.33478>:
        D.33480 = &MEM[(void *)"MethodBuilder" + 3B];
        D.33481 = *D.33480;
        D.33482 = (int) D.33481;
        D.33483 = __s2 + 3;
        D.33484 = *D.33483;
        D.33485 = (int) D.33484;
        __result = D.33482 - D.33485;
        <D.33479>:
        <D.33469>:
        <D.33459>:
      }
      D.21265 = __result;
    }
    iftmp.454 = -D.21265;
    goto <D.33486>;
    <D.33449>:
    D.33487 = klass->name;
    iftmp.454 = __builtin_strcmp (D.33487, "MethodBuilder");
    <D.33486>:
    D.21266 = iftmp.454;
  }
  if (D.21266 == 0) goto <D.33488>; else goto <D.33489>;
  <D.33488>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.33490 = mb->table_idx;
    token = D.33490 | 100663296;
  }
  goto <D.33491>;
  <D.33489>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33495 = "ConstructorBuilder";
      D.33496 = MEM[(const unsigned char *)D.33495];
      D.33497 = (int) D.33496;
      D.33498 = *__s2;
      D.33499 = (int) D.33498;
      __result = D.33497 - D.33499;
      {
        D.33500 = __s2_len != 0;
        D.33501 = __result == 0;
        D.33502 = D.33500 & D.33501;
        if (D.33502 != 0) goto <D.33503>; else goto <D.33504>;
        <D.33503>:
        D.33505 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.33506 = *D.33505;
        D.33507 = (int) D.33506;
        D.33508 = __s2 + 1;
        D.33509 = *D.33508;
        D.33510 = (int) D.33509;
        __result = D.33507 - D.33510;
        D.33511 = __s2_len > 1;
        D.33501 = __result == 0;
        D.33512 = D.33511 & D.33501;
        if (D.33512 != 0) goto <D.33513>; else goto <D.33514>;
        <D.33513>:
        D.33515 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.33516 = *D.33515;
        D.33517 = (int) D.33516;
        D.33518 = __s2 + 2;
        D.33519 = *D.33518;
        D.33520 = (int) D.33519;
        __result = D.33517 - D.33520;
        D.33521 = __s2_len > 2;
        D.33501 = __result == 0;
        D.33522 = D.33521 & D.33501;
        if (D.33522 != 0) goto <D.33523>; else goto <D.33524>;
        <D.33523>:
        D.33525 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.33526 = *D.33525;
        D.33527 = (int) D.33526;
        D.33528 = __s2 + 3;
        D.33529 = *D.33528;
        D.33530 = (int) D.33529;
        __result = D.33527 - D.33530;
        <D.33524>:
        <D.33514>:
        <D.33504>:
      }
      D.21275 = __result;
    }
    iftmp.455 = -D.21275;
    goto <D.33531>;
    <D.33494>:
    D.33487 = klass->name;
    iftmp.455 = __builtin_strcmp (D.33487, "ConstructorBuilder");
    <D.33531>:
    D.21276 = iftmp.455;
  }
  if (D.21276 == 0) goto <D.33532>; else goto <D.33533>;
  <D.33532>:
  {
    struct MonoReflectionCtorBuilder * mb;

    mb = obj;
    D.33534 = mb->table_idx;
    token = D.33534 | 100663296;
  }
  goto <D.33535>;
  <D.33533>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33539 = "FieldBuilder";
      D.33540 = MEM[(const unsigned char *)D.33539];
      D.33541 = (int) D.33540;
      D.33542 = *__s2;
      D.33543 = (int) D.33542;
      __result = D.33541 - D.33543;
      {
        D.33544 = __s2_len != 0;
        D.33545 = __result == 0;
        D.33546 = D.33544 & D.33545;
        if (D.33546 != 0) goto <D.33547>; else goto <D.33548>;
        <D.33547>:
        D.33549 = &MEM[(void *)"FieldBuilder" + 1B];
        D.33550 = *D.33549;
        D.33551 = (int) D.33550;
        D.33552 = __s2 + 1;
        D.33553 = *D.33552;
        D.33554 = (int) D.33553;
        __result = D.33551 - D.33554;
        D.33555 = __s2_len > 1;
        D.33545 = __result == 0;
        D.33556 = D.33555 & D.33545;
        if (D.33556 != 0) goto <D.33557>; else goto <D.33558>;
        <D.33557>:
        D.33559 = &MEM[(void *)"FieldBuilder" + 2B];
        D.33560 = *D.33559;
        D.33561 = (int) D.33560;
        D.33562 = __s2 + 2;
        D.33563 = *D.33562;
        D.33564 = (int) D.33563;
        __result = D.33561 - D.33564;
        D.33565 = __s2_len > 2;
        D.33545 = __result == 0;
        D.33566 = D.33565 & D.33545;
        if (D.33566 != 0) goto <D.33567>; else goto <D.33568>;
        <D.33567>:
        D.33569 = &MEM[(void *)"FieldBuilder" + 3B];
        D.33570 = *D.33569;
        D.33571 = (int) D.33570;
        D.33572 = __s2 + 3;
        D.33573 = *D.33572;
        D.33574 = (int) D.33573;
        __result = D.33571 - D.33574;
        <D.33568>:
        <D.33558>:
        <D.33548>:
      }
      D.21285 = __result;
    }
    iftmp.456 = -D.21285;
    goto <D.33575>;
    <D.33538>:
    D.33487 = klass->name;
    iftmp.456 = __builtin_strcmp (D.33487, "FieldBuilder");
    <D.33575>:
    D.21286 = iftmp.456;
  }
  if (D.21286 == 0) goto <D.33576>; else goto <D.33577>;
  <D.33576>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.33578 = fb->table_idx;
    D.33579 = D.33578 | 67108864;
    token = (guint32) D.33579;
  }
  goto <D.33580>;
  <D.33577>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33584 = "TypeBuilder";
      D.33585 = MEM[(const unsigned char *)D.33584];
      D.33586 = (int) D.33585;
      D.33587 = *__s2;
      D.33588 = (int) D.33587;
      __result = D.33586 - D.33588;
      {
        D.33589 = __s2_len != 0;
        D.33590 = __result == 0;
        D.33591 = D.33589 & D.33590;
        if (D.33591 != 0) goto <D.33592>; else goto <D.33593>;
        <D.33592>:
        D.33594 = &MEM[(void *)"TypeBuilder" + 1B];
        D.33595 = *D.33594;
        D.33596 = (int) D.33595;
        D.33597 = __s2 + 1;
        D.33598 = *D.33597;
        D.33599 = (int) D.33598;
        __result = D.33596 - D.33599;
        D.33600 = __s2_len > 1;
        D.33590 = __result == 0;
        D.33601 = D.33600 & D.33590;
        if (D.33601 != 0) goto <D.33602>; else goto <D.33603>;
        <D.33602>:
        D.33604 = &MEM[(void *)"TypeBuilder" + 2B];
        D.33605 = *D.33604;
        D.33606 = (int) D.33605;
        D.33607 = __s2 + 2;
        D.33608 = *D.33607;
        D.33609 = (int) D.33608;
        __result = D.33606 - D.33609;
        D.33610 = __s2_len > 2;
        D.33590 = __result == 0;
        D.33611 = D.33610 & D.33590;
        if (D.33611 != 0) goto <D.33612>; else goto <D.33613>;
        <D.33612>:
        D.33614 = &MEM[(void *)"TypeBuilder" + 3B];
        D.33615 = *D.33614;
        D.33616 = (int) D.33615;
        D.33617 = __s2 + 3;
        D.33618 = *D.33617;
        D.33619 = (int) D.33618;
        __result = D.33616 - D.33619;
        <D.33613>:
        <D.33603>:
        <D.33593>:
      }
      D.21295 = __result;
    }
    iftmp.457 = -D.21295;
    goto <D.33620>;
    <D.33583>:
    D.33487 = klass->name;
    iftmp.457 = __builtin_strcmp (D.33487, "TypeBuilder");
    <D.33620>:
    D.21296 = iftmp.457;
  }
  if (D.21296 == 0) goto <D.33621>; else goto <D.33622>;
  <D.33621>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.33623 = tb->table_idx;
    token = D.33623 | 33554432;
  }
  goto <D.33624>;
  <D.33622>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33628 = "MonoType";
      D.33629 = MEM[(const unsigned char *)D.33628];
      D.33630 = (int) D.33629;
      D.33631 = *__s2;
      D.33632 = (int) D.33631;
      __result = D.33630 - D.33632;
      {
        D.33633 = __s2_len != 0;
        D.33634 = __result == 0;
        D.33635 = D.33633 & D.33634;
        if (D.33635 != 0) goto <D.33636>; else goto <D.33637>;
        <D.33636>:
        D.33638 = &MEM[(void *)"MonoType" + 1B];
        D.33639 = *D.33638;
        D.33640 = (int) D.33639;
        D.33641 = __s2 + 1;
        D.33642 = *D.33641;
        D.33643 = (int) D.33642;
        __result = D.33640 - D.33643;
        D.33644 = __s2_len > 1;
        D.33634 = __result == 0;
        D.33645 = D.33644 & D.33634;
        if (D.33645 != 0) goto <D.33646>; else goto <D.33647>;
        <D.33646>:
        D.33648 = &MEM[(void *)"MonoType" + 2B];
        D.33649 = *D.33648;
        D.33650 = (int) D.33649;
        D.33651 = __s2 + 2;
        D.33652 = *D.33651;
        D.33653 = (int) D.33652;
        __result = D.33650 - D.33653;
        D.33654 = __s2_len > 2;
        D.33634 = __result == 0;
        D.33655 = D.33654 & D.33634;
        if (D.33655 != 0) goto <D.33656>; else goto <D.33657>;
        <D.33656>:
        D.33658 = &MEM[(void *)"MonoType" + 3B];
        D.33659 = *D.33658;
        D.33660 = (int) D.33659;
        D.33661 = __s2 + 3;
        D.33662 = *D.33661;
        D.33663 = (int) D.33662;
        __result = D.33660 - D.33663;
        <D.33657>:
        <D.33647>:
        <D.33637>:
      }
      D.21305 = __result;
    }
    iftmp.458 = -D.21305;
    goto <D.33664>;
    <D.33627>:
    D.33487 = klass->name;
    iftmp.458 = __builtin_strcmp (D.33487, "MonoType");
    <D.33664>:
    D.21306 = iftmp.458;
  }
  if (D.21306 == 0) goto <D.33665>; else goto <D.33666>;
  <D.33665>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.33667 = mono_class_init (mc);
    if (D.33667 == 0) goto <D.33668>; else goto <D.33669>;
    <D.33668>:
    D.33670 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.33670);
    <D.33669>:
    token = mc->type_token;
  }
  goto <D.33671>;
  <D.33666>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33678 = "MonoCMethod";
      D.33679 = MEM[(const unsigned char *)D.33678];
      D.33680 = (int) D.33679;
      D.33681 = *__s2;
      D.33682 = (int) D.33681;
      __result = D.33680 - D.33682;
      {
        D.33683 = __s2_len != 0;
        D.33684 = __result == 0;
        D.33685 = D.33683 & D.33684;
        if (D.33685 != 0) goto <D.33686>; else goto <D.33687>;
        <D.33686>:
        D.33688 = &MEM[(void *)"MonoCMethod" + 1B];
        D.33689 = *D.33688;
        D.33690 = (int) D.33689;
        D.33691 = __s2 + 1;
        D.33692 = *D.33691;
        D.33693 = (int) D.33692;
        __result = D.33690 - D.33693;
        D.33694 = __s2_len > 1;
        D.33684 = __result == 0;
        D.33695 = D.33694 & D.33684;
        if (D.33695 != 0) goto <D.33696>; else goto <D.33697>;
        <D.33696>:
        D.33698 = &MEM[(void *)"MonoCMethod" + 2B];
        D.33699 = *D.33698;
        D.33700 = (int) D.33699;
        D.33701 = __s2 + 2;
        D.33702 = *D.33701;
        D.33703 = (int) D.33702;
        __result = D.33700 - D.33703;
        D.33704 = __s2_len > 2;
        D.33684 = __result == 0;
        D.33705 = D.33704 & D.33684;
        if (D.33705 != 0) goto <D.33706>; else goto <D.33707>;
        <D.33706>:
        D.33708 = &MEM[(void *)"MonoCMethod" + 3B];
        D.33709 = *D.33708;
        D.33710 = (int) D.33709;
        D.33711 = __s2 + 3;
        D.33712 = *D.33711;
        D.33713 = (int) D.33712;
        __result = D.33710 - D.33713;
        <D.33707>:
        <D.33697>:
        <D.33687>:
      }
      D.21316 = __result;
    }
    iftmp.459 = -D.21316;
    goto <D.33714>;
    <D.33677>:
    D.33487 = klass->name;
    iftmp.459 = __builtin_strcmp (D.33487, "MonoCMethod");
    <D.33714>:
    D.21317 = iftmp.459;
  }
  if (D.21317 == 0) goto <D.33672>; else goto <D.33715>;
  <D.33715>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33719 = "MonoMethod";
      D.33720 = MEM[(const unsigned char *)D.33719];
      D.33721 = (int) D.33720;
      D.33722 = *__s2;
      D.33723 = (int) D.33722;
      __result = D.33721 - D.33723;
      {
        D.33724 = __s2_len != 0;
        D.33725 = __result == 0;
        D.33726 = D.33724 & D.33725;
        if (D.33726 != 0) goto <D.33727>; else goto <D.33728>;
        <D.33727>:
        D.33729 = &MEM[(void *)"MonoMethod" + 1B];
        D.33730 = *D.33729;
        D.33731 = (int) D.33730;
        D.33732 = __s2 + 1;
        D.33733 = *D.33732;
        D.33734 = (int) D.33733;
        __result = D.33731 - D.33734;
        D.33735 = __s2_len > 1;
        D.33725 = __result == 0;
        D.33736 = D.33735 & D.33725;
        if (D.33736 != 0) goto <D.33737>; else goto <D.33738>;
        <D.33737>:
        D.33739 = &MEM[(void *)"MonoMethod" + 2B];
        D.33740 = *D.33739;
        D.33741 = (int) D.33740;
        D.33742 = __s2 + 2;
        D.33743 = *D.33742;
        D.33744 = (int) D.33743;
        __result = D.33741 - D.33744;
        D.33745 = __s2_len > 2;
        D.33725 = __result == 0;
        D.33746 = D.33745 & D.33725;
        if (D.33746 != 0) goto <D.33747>; else goto <D.33748>;
        <D.33747>:
        D.33749 = &MEM[(void *)"MonoMethod" + 3B];
        D.33750 = *D.33749;
        D.33751 = (int) D.33750;
        D.33752 = __s2 + 3;
        D.33753 = *D.33752;
        D.33754 = (int) D.33753;
        __result = D.33751 - D.33754;
        <D.33748>:
        <D.33738>:
        <D.33728>:
      }
      D.21325 = __result;
    }
    iftmp.460 = -D.21325;
    goto <D.33755>;
    <D.33718>:
    D.33487 = klass->name;
    iftmp.460 = __builtin_strcmp (D.33487, "MonoMethod");
    <D.33755>:
    D.21326 = iftmp.460;
  }
  if (D.21326 == 0) goto <D.33672>; else goto <D.33756>;
  <D.33756>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33760 = "MonoGenericMethod";
      D.33761 = MEM[(const unsigned char *)D.33760];
      D.33762 = (int) D.33761;
      D.33763 = *__s2;
      D.33764 = (int) D.33763;
      __result = D.33762 - D.33764;
      {
        D.33765 = __s2_len != 0;
        D.33766 = __result == 0;
        D.33767 = D.33765 & D.33766;
        if (D.33767 != 0) goto <D.33768>; else goto <D.33769>;
        <D.33768>:
        D.33770 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.33771 = *D.33770;
        D.33772 = (int) D.33771;
        D.33773 = __s2 + 1;
        D.33774 = *D.33773;
        D.33775 = (int) D.33774;
        __result = D.33772 - D.33775;
        D.33776 = __s2_len > 1;
        D.33766 = __result == 0;
        D.33777 = D.33776 & D.33766;
        if (D.33777 != 0) goto <D.33778>; else goto <D.33779>;
        <D.33778>:
        D.33780 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.33781 = *D.33780;
        D.33782 = (int) D.33781;
        D.33783 = __s2 + 2;
        D.33784 = *D.33783;
        D.33785 = (int) D.33784;
        __result = D.33782 - D.33785;
        D.33786 = __s2_len > 2;
        D.33766 = __result == 0;
        D.33787 = D.33786 & D.33766;
        if (D.33787 != 0) goto <D.33788>; else goto <D.33789>;
        <D.33788>:
        D.33790 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.33791 = *D.33790;
        D.33792 = (int) D.33791;
        D.33793 = __s2 + 3;
        D.33794 = *D.33793;
        D.33795 = (int) D.33794;
        __result = D.33792 - D.33795;
        <D.33789>:
        <D.33779>:
        <D.33769>:
      }
      D.21334 = __result;
    }
    iftmp.461 = -D.21334;
    goto <D.33796>;
    <D.33759>:
    D.33487 = klass->name;
    iftmp.461 = __builtin_strcmp (D.33487, "MonoGenericMethod");
    <D.33796>:
    D.21335 = iftmp.461;
  }
  if (D.21335 == 0) goto <D.33672>; else goto <D.33797>;
  <D.33797>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33801 = "MonoGenericCMethod";
      D.33802 = MEM[(const unsigned char *)D.33801];
      D.33803 = (int) D.33802;
      D.33804 = *__s2;
      D.33805 = (int) D.33804;
      __result = D.33803 - D.33805;
      {
        D.33806 = __s2_len != 0;
        D.33807 = __result == 0;
        D.33808 = D.33806 & D.33807;
        if (D.33808 != 0) goto <D.33809>; else goto <D.33810>;
        <D.33809>:
        D.33811 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.33812 = *D.33811;
        D.33813 = (int) D.33812;
        D.33814 = __s2 + 1;
        D.33815 = *D.33814;
        D.33816 = (int) D.33815;
        __result = D.33813 - D.33816;
        D.33817 = __s2_len > 1;
        D.33807 = __result == 0;
        D.33818 = D.33817 & D.33807;
        if (D.33818 != 0) goto <D.33819>; else goto <D.33820>;
        <D.33819>:
        D.33821 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.33822 = *D.33821;
        D.33823 = (int) D.33822;
        D.33824 = __s2 + 2;
        D.33825 = *D.33824;
        D.33826 = (int) D.33825;
        __result = D.33823 - D.33826;
        D.33827 = __s2_len > 2;
        D.33807 = __result == 0;
        D.33828 = D.33827 & D.33807;
        if (D.33828 != 0) goto <D.33829>; else goto <D.33830>;
        <D.33829>:
        D.33831 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.33832 = *D.33831;
        D.33833 = (int) D.33832;
        D.33834 = __s2 + 3;
        D.33835 = *D.33834;
        D.33836 = (int) D.33835;
        __result = D.33833 - D.33836;
        <D.33830>:
        <D.33820>:
        <D.33810>:
      }
      D.21343 = __result;
    }
    iftmp.462 = -D.21343;
    goto <D.33837>;
    <D.33800>:
    D.33487 = klass->name;
    iftmp.462 = __builtin_strcmp (D.33487, "MonoGenericCMethod");
    <D.33837>:
    D.21344 = iftmp.462;
  }
  if (D.21344 == 0) goto <D.33672>; else goto <D.33673>;
  <D.33672>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.33838 = m->method;
    D.33839 = BIT_FIELD_REF <*D.33838, 8, 168>;
    D.33840 = D.33839 & 16;
    if (D.33840 != 0) goto <D.33841>; else goto <D.33842>;
    <D.33841>:
    {
      struct MonoMethodInflated * inflated;

      inflated = m->method;
      D.33844 = inflated->declaring;
      D.33843 = D.33844->token;
      return D.33843;
    }
    <D.33842>:
    D.33838 = m->method;
    token = D.33838->token;
  }
  goto <D.33674>;
  <D.33673>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33848 = "MonoField";
      D.33849 = MEM[(const unsigned char *)D.33848];
      D.33850 = (int) D.33849;
      D.33851 = *__s2;
      D.33852 = (int) D.33851;
      __result = D.33850 - D.33852;
      {
        D.33853 = __s2_len != 0;
        D.33854 = __result == 0;
        D.33855 = D.33853 & D.33854;
        if (D.33855 != 0) goto <D.33856>; else goto <D.33857>;
        <D.33856>:
        D.33858 = &MEM[(void *)"MonoField" + 1B];
        D.33859 = *D.33858;
        D.33860 = (int) D.33859;
        D.33861 = __s2 + 1;
        D.33862 = *D.33861;
        D.33863 = (int) D.33862;
        __result = D.33860 - D.33863;
        D.33864 = __s2_len > 1;
        D.33854 = __result == 0;
        D.33865 = D.33864 & D.33854;
        if (D.33865 != 0) goto <D.33866>; else goto <D.33867>;
        <D.33866>:
        D.33868 = &MEM[(void *)"MonoField" + 2B];
        D.33869 = *D.33868;
        D.33870 = (int) D.33869;
        D.33871 = __s2 + 2;
        D.33872 = *D.33871;
        D.33873 = (int) D.33872;
        __result = D.33870 - D.33873;
        D.33874 = __s2_len > 2;
        D.33854 = __result == 0;
        D.33875 = D.33874 & D.33854;
        if (D.33875 != 0) goto <D.33876>; else goto <D.33877>;
        <D.33876>:
        D.33878 = &MEM[(void *)"MonoField" + 3B];
        D.33879 = *D.33878;
        D.33880 = (int) D.33879;
        D.33881 = __s2 + 3;
        D.33882 = *D.33881;
        D.33883 = (int) D.33882;
        __result = D.33880 - D.33883;
        <D.33877>:
        <D.33867>:
        <D.33857>:
      }
      D.21354 = __result;
    }
    iftmp.463 = -D.21354;
    goto <D.33884>;
    <D.33847>:
    D.33487 = klass->name;
    iftmp.463 = __builtin_strcmp (D.33487, "MonoField");
    <D.33884>:
    D.21355 = iftmp.463;
  }
  if (D.21355 == 0) goto <D.33885>; else goto <D.33886>;
  <D.33885>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.33887 = f->field;
    D.33888 = is_field_on_inst (D.33887);
    if (D.33888 != 0) goto <D.33889>; else goto <D.33890>;
    <D.33889>:
    {
      struct MonoDynamicGenericClass * dgclass;
      int field_index;
      struct MonoObject * obj;

      D.33887 = f->field;
      D.33891 = D.33887->parent;
      dgclass = D.33891->generic_class;
      D.33887 = f->field;
      D.33892 = (int) D.33887;
      D.33893 = dgclass->fields;
      D.33894 = (int) D.33893;
      D.33895 = D.33892 - D.33894;
      field_index = D.33895 /[ex] 16;
      if (field_index < 0) goto <D.33897>; else goto <D.33900>;
      <D.33900>:
      D.33901 = dgclass->count_fields;
      if (D.33901 <= field_index) goto <D.33897>; else goto <D.33898>;
      <D.33897>:
      iftmp.464 = 1;
      goto <D.33899>;
      <D.33898>:
      iftmp.464 = 0;
      <D.33899>:
      D.33902 = iftmp.464 != 0;
      D.33903 = (long int) D.33902;
      D.33904 = __builtin_expect (D.33903, 0);
      if (D.33904 != 0) goto <D.33905>; else goto <D.33906>;
      <D.33905>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7752, "field_index >= 0 && field_index < dgclass->count_fields");
      <D.33906>:
      D.33907 = dgclass->field_objects;
      field_index.465 = (unsigned int) field_index;
      D.33909 = field_index.465 * 4;
      D.33910 = D.33907 + D.33909;
      obj = *D.33910;
      D.33843 = mono_reflection_get_token (obj);
      return D.33843;
    }
    <D.33890>:
    D.33887 = f->field;
    token = mono_class_get_field_token (D.33887);
  }
  goto <D.33911>;
  <D.33886>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33915 = "MonoProperty";
      D.33916 = MEM[(const unsigned char *)D.33915];
      D.33917 = (int) D.33916;
      D.33918 = *__s2;
      D.33919 = (int) D.33918;
      __result = D.33917 - D.33919;
      {
        D.33920 = __s2_len != 0;
        D.33921 = __result == 0;
        D.33922 = D.33920 & D.33921;
        if (D.33922 != 0) goto <D.33923>; else goto <D.33924>;
        <D.33923>:
        D.33925 = &MEM[(void *)"MonoProperty" + 1B];
        D.33926 = *D.33925;
        D.33927 = (int) D.33926;
        D.33928 = __s2 + 1;
        D.33929 = *D.33928;
        D.33930 = (int) D.33929;
        __result = D.33927 - D.33930;
        D.33931 = __s2_len > 1;
        D.33921 = __result == 0;
        D.33932 = D.33931 & D.33921;
        if (D.33932 != 0) goto <D.33933>; else goto <D.33934>;
        <D.33933>:
        D.33935 = &MEM[(void *)"MonoProperty" + 2B];
        D.33936 = *D.33935;
        D.33937 = (int) D.33936;
        D.33938 = __s2 + 2;
        D.33939 = *D.33938;
        D.33940 = (int) D.33939;
        __result = D.33937 - D.33940;
        D.33941 = __s2_len > 2;
        D.33921 = __result == 0;
        D.33942 = D.33941 & D.33921;
        if (D.33942 != 0) goto <D.33943>; else goto <D.33944>;
        <D.33943>:
        D.33945 = &MEM[(void *)"MonoProperty" + 3B];
        D.33946 = *D.33945;
        D.33947 = (int) D.33946;
        D.33948 = __s2 + 3;
        D.33949 = *D.33948;
        D.33950 = (int) D.33949;
        __result = D.33947 - D.33950;
        <D.33944>:
        <D.33934>:
        <D.33924>:
      }
      D.21367 = __result;
    }
    iftmp.466 = -D.21367;
    goto <D.33951>;
    <D.33914>:
    D.33487 = klass->name;
    iftmp.466 = __builtin_strcmp (D.33487, "MonoProperty");
    <D.33951>:
    D.21368 = iftmp.466;
  }
  if (D.21368 == 0) goto <D.33952>; else goto <D.33953>;
  <D.33952>:
  {
    struct MonoReflectionProperty * p;

    p = obj;
    D.33954 = p->property;
    token = mono_class_get_property_token (D.33954);
  }
  goto <D.33955>;
  <D.33953>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.33959 = "MonoEvent";
      D.33960 = MEM[(const unsigned char *)D.33959];
      D.33961 = (int) D.33960;
      D.33962 = *__s2;
      D.33963 = (int) D.33962;
      __result = D.33961 - D.33963;
      {
        D.33964 = __s2_len != 0;
        D.33965 = __result == 0;
        D.33966 = D.33964 & D.33965;
        if (D.33966 != 0) goto <D.33967>; else goto <D.33968>;
        <D.33967>:
        D.33969 = &MEM[(void *)"MonoEvent" + 1B];
        D.33970 = *D.33969;
        D.33971 = (int) D.33970;
        D.33972 = __s2 + 1;
        D.33973 = *D.33972;
        D.33974 = (int) D.33973;
        __result = D.33971 - D.33974;
        D.33975 = __s2_len > 1;
        D.33965 = __result == 0;
        D.33976 = D.33975 & D.33965;
        if (D.33976 != 0) goto <D.33977>; else goto <D.33978>;
        <D.33977>:
        D.33979 = &MEM[(void *)"MonoEvent" + 2B];
        D.33980 = *D.33979;
        D.33981 = (int) D.33980;
        D.33982 = __s2 + 2;
        D.33983 = *D.33982;
        D.33984 = (int) D.33983;
        __result = D.33981 - D.33984;
        D.33985 = __s2_len > 2;
        D.33965 = __result == 0;
        D.33986 = D.33985 & D.33965;
        if (D.33986 != 0) goto <D.33987>; else goto <D.33988>;
        <D.33987>:
        D.33989 = &MEM[(void *)"MonoEvent" + 3B];
        D.33990 = *D.33989;
        D.33991 = (int) D.33990;
        D.33992 = __s2 + 3;
        D.33993 = *D.33992;
        D.33994 = (int) D.33993;
        __result = D.33991 - D.33994;
        <D.33988>:
        <D.33978>:
        <D.33968>:
      }
      D.21377 = __result;
    }
    iftmp.467 = -D.21377;
    goto <D.33995>;
    <D.33958>:
    D.33487 = klass->name;
    iftmp.467 = __builtin_strcmp (D.33487, "MonoEvent");
    <D.33995>:
    D.21378 = iftmp.467;
  }
  if (D.21378 == 0) goto <D.33996>; else goto <D.33997>;
  <D.33996>:
  {
    struct MonoReflectionMonoEvent * p;

    p = obj;
    D.33998 = p->event;
    token = mono_class_get_event_token (D.33998);
  }
  goto <D.33999>;
  <D.33997>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34006 = "ParameterInfo";
      D.34007 = MEM[(const unsigned char *)D.34006];
      D.34008 = (int) D.34007;
      D.34009 = *__s2;
      D.34010 = (int) D.34009;
      __result = D.34008 - D.34010;
      {
        D.34011 = __s2_len != 0;
        D.34012 = __result == 0;
        D.34013 = D.34011 & D.34012;
        if (D.34013 != 0) goto <D.34014>; else goto <D.34015>;
        <D.34014>:
        D.34016 = &MEM[(void *)"ParameterInfo" + 1B];
        D.34017 = *D.34016;
        D.34018 = (int) D.34017;
        D.34019 = __s2 + 1;
        D.34020 = *D.34019;
        D.34021 = (int) D.34020;
        __result = D.34018 - D.34021;
        D.34022 = __s2_len > 1;
        D.34012 = __result == 0;
        D.34023 = D.34022 & D.34012;
        if (D.34023 != 0) goto <D.34024>; else goto <D.34025>;
        <D.34024>:
        D.34026 = &MEM[(void *)"ParameterInfo" + 2B];
        D.34027 = *D.34026;
        D.34028 = (int) D.34027;
        D.34029 = __s2 + 2;
        D.34030 = *D.34029;
        D.34031 = (int) D.34030;
        __result = D.34028 - D.34031;
        D.34032 = __s2_len > 2;
        D.34012 = __result == 0;
        D.34033 = D.34032 & D.34012;
        if (D.34033 != 0) goto <D.34034>; else goto <D.34035>;
        <D.34034>:
        D.34036 = &MEM[(void *)"ParameterInfo" + 3B];
        D.34037 = *D.34036;
        D.34038 = (int) D.34037;
        D.34039 = __s2 + 3;
        D.34040 = *D.34039;
        D.34041 = (int) D.34040;
        __result = D.34038 - D.34041;
        <D.34035>:
        <D.34025>:
        <D.34015>:
      }
      D.21387 = __result;
    }
    iftmp.468 = -D.21387;
    goto <D.34042>;
    <D.34005>:
    D.33487 = klass->name;
    iftmp.468 = __builtin_strcmp (D.33487, "ParameterInfo");
    <D.34042>:
    D.21388 = iftmp.468;
  }
  if (D.21388 == 0) goto <D.34000>; else goto <D.34043>;
  <D.34043>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34047 = "MonoParameterInfo";
      D.34048 = MEM[(const unsigned char *)D.34047];
      D.34049 = (int) D.34048;
      D.34050 = *__s2;
      D.34051 = (int) D.34050;
      __result = D.34049 - D.34051;
      {
        D.34052 = __s2_len != 0;
        D.34053 = __result == 0;
        D.34054 = D.34052 & D.34053;
        if (D.34054 != 0) goto <D.34055>; else goto <D.34056>;
        <D.34055>:
        D.34057 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.34058 = *D.34057;
        D.34059 = (int) D.34058;
        D.34060 = __s2 + 1;
        D.34061 = *D.34060;
        D.34062 = (int) D.34061;
        __result = D.34059 - D.34062;
        D.34063 = __s2_len > 1;
        D.34053 = __result == 0;
        D.34064 = D.34063 & D.34053;
        if (D.34064 != 0) goto <D.34065>; else goto <D.34066>;
        <D.34065>:
        D.34067 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.34068 = *D.34067;
        D.34069 = (int) D.34068;
        D.34070 = __s2 + 2;
        D.34071 = *D.34070;
        D.34072 = (int) D.34071;
        __result = D.34069 - D.34072;
        D.34073 = __s2_len > 2;
        D.34053 = __result == 0;
        D.34074 = D.34073 & D.34053;
        if (D.34074 != 0) goto <D.34075>; else goto <D.34076>;
        <D.34075>:
        D.34077 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.34078 = *D.34077;
        D.34079 = (int) D.34078;
        D.34080 = __s2 + 3;
        D.34081 = *D.34080;
        D.34082 = (int) D.34081;
        __result = D.34079 - D.34082;
        <D.34076>:
        <D.34066>:
        <D.34056>:
      }
      D.21396 = __result;
    }
    iftmp.469 = -D.21396;
    goto <D.34083>;
    <D.34046>:
    D.33487 = klass->name;
    iftmp.469 = __builtin_strcmp (D.33487, "MonoParameterInfo");
    <D.34083>:
    D.21397 = iftmp.469;
  }
  if (D.21397 == 0) goto <D.34000>; else goto <D.34001>;
  <D.34000>:
  {
    struct MonoReflectionParameter * p;
    struct MonoClass * member_class;

    p = obj;
    D.34084 = p->MemberImpl;
    D.34085 = D.34084->vtable;
    member_class = D.34085->klass;
    D.34086 = mono_class_is_reflection_method_or_constructor (member_class);
    D.34087 = D.34086 == 0;
    D.34088 = (long int) D.34087;
    D.34089 = __builtin_expect (D.34088, 0);
    if (D.34089 != 0) goto <D.34090>; else goto <D.34091>;
    <D.34090>:
    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.34091>:
    D.34092 = p->PositionImpl;
    D.34084 = p->MemberImpl;
    D.34093 = MEM[(struct MonoReflectionMethod *)D.34084].method;
    token = mono_method_get_param_token (D.34093, D.34092);
  }
  goto <D.34002>;
  <D.34001>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34100 = "Module";
      D.34101 = MEM[(const unsigned char *)D.34100];
      D.34102 = (int) D.34101;
      D.34103 = *__s2;
      D.34104 = (int) D.34103;
      __result = D.34102 - D.34104;
      {
        D.34105 = __s2_len != 0;
        D.34106 = __result == 0;
        D.34107 = D.34105 & D.34106;
        if (D.34107 != 0) goto <D.34108>; else goto <D.34109>;
        <D.34108>:
        D.34110 = &MEM[(void *)"Module" + 1B];
        D.34111 = *D.34110;
        D.34112 = (int) D.34111;
        D.34113 = __s2 + 1;
        D.34114 = *D.34113;
        D.34115 = (int) D.34114;
        __result = D.34112 - D.34115;
        D.34116 = __s2_len > 1;
        D.34106 = __result == 0;
        D.34117 = D.34116 & D.34106;
        if (D.34117 != 0) goto <D.34118>; else goto <D.34119>;
        <D.34118>:
        D.34120 = &MEM[(void *)"Module" + 2B];
        D.34121 = *D.34120;
        D.34122 = (int) D.34121;
        D.34123 = __s2 + 2;
        D.34124 = *D.34123;
        D.34125 = (int) D.34124;
        __result = D.34122 - D.34125;
        D.34126 = __s2_len > 2;
        D.34106 = __result == 0;
        D.34127 = D.34126 & D.34106;
        if (D.34127 != 0) goto <D.34128>; else goto <D.34129>;
        <D.34128>:
        D.34130 = &MEM[(void *)"Module" + 3B];
        D.34131 = *D.34130;
        D.34132 = (int) D.34131;
        D.34133 = __s2 + 3;
        D.34134 = *D.34133;
        D.34135 = (int) D.34134;
        __result = D.34132 - D.34135;
        <D.34129>:
        <D.34119>:
        <D.34109>:
      }
      D.21407 = __result;
    }
    iftmp.470 = -D.21407;
    goto <D.34136>;
    <D.34099>:
    D.33487 = klass->name;
    iftmp.470 = __builtin_strcmp (D.33487, "Module");
    <D.34136>:
    D.21408 = iftmp.470;
  }
  if (D.21408 == 0) goto <D.34094>; else goto <D.34137>;
  <D.34137>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34141 = "MonoModule";
      D.34142 = MEM[(const unsigned char *)D.34141];
      D.34143 = (int) D.34142;
      D.34144 = *__s2;
      D.34145 = (int) D.34144;
      __result = D.34143 - D.34145;
      {
        D.34146 = __s2_len != 0;
        D.34147 = __result == 0;
        D.34148 = D.34146 & D.34147;
        if (D.34148 != 0) goto <D.34149>; else goto <D.34150>;
        <D.34149>:
        D.34151 = &MEM[(void *)"MonoModule" + 1B];
        D.34152 = *D.34151;
        D.34153 = (int) D.34152;
        D.34154 = __s2 + 1;
        D.34155 = *D.34154;
        D.34156 = (int) D.34155;
        __result = D.34153 - D.34156;
        D.34157 = __s2_len > 1;
        D.34147 = __result == 0;
        D.34158 = D.34157 & D.34147;
        if (D.34158 != 0) goto <D.34159>; else goto <D.34160>;
        <D.34159>:
        D.34161 = &MEM[(void *)"MonoModule" + 2B];
        D.34162 = *D.34161;
        D.34163 = (int) D.34162;
        D.34164 = __s2 + 2;
        D.34165 = *D.34164;
        D.34166 = (int) D.34165;
        __result = D.34163 - D.34166;
        D.34167 = __s2_len > 2;
        D.34147 = __result == 0;
        D.34168 = D.34167 & D.34147;
        if (D.34168 != 0) goto <D.34169>; else goto <D.34170>;
        <D.34169>:
        D.34171 = &MEM[(void *)"MonoModule" + 3B];
        D.34172 = *D.34171;
        D.34173 = (int) D.34172;
        D.34174 = __s2 + 3;
        D.34175 = *D.34174;
        D.34176 = (int) D.34175;
        __result = D.34173 - D.34176;
        <D.34170>:
        <D.34160>:
        <D.34150>:
      }
      D.21416 = __result;
    }
    iftmp.471 = -D.21416;
    goto <D.34177>;
    <D.34140>:
    D.33487 = klass->name;
    iftmp.471 = __builtin_strcmp (D.33487, "MonoModule");
    <D.34177>:
    D.21417 = iftmp.471;
  }
  if (D.21417 == 0) goto <D.34094>; else goto <D.34095>;
  <D.34094>:
  {
    struct MonoReflectionModule * m;

    m = obj;
    token = m->token;
  }
  goto <D.34096>;
  <D.34095>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34184 = "Assembly";
      D.34185 = MEM[(const unsigned char *)D.34184];
      D.34186 = (int) D.34185;
      D.34187 = *__s2;
      D.34188 = (int) D.34187;
      __result = D.34186 - D.34188;
      {
        D.34189 = __s2_len != 0;
        D.34190 = __result == 0;
        D.34191 = D.34189 & D.34190;
        if (D.34191 != 0) goto <D.34192>; else goto <D.34193>;
        <D.34192>:
        D.34194 = &MEM[(void *)"Assembly" + 1B];
        D.34195 = *D.34194;
        D.34196 = (int) D.34195;
        D.34197 = __s2 + 1;
        D.34198 = *D.34197;
        D.34199 = (int) D.34198;
        __result = D.34196 - D.34199;
        D.34200 = __s2_len > 1;
        D.34190 = __result == 0;
        D.34201 = D.34200 & D.34190;
        if (D.34201 != 0) goto <D.34202>; else goto <D.34203>;
        <D.34202>:
        D.34204 = &MEM[(void *)"Assembly" + 2B];
        D.34205 = *D.34204;
        D.34206 = (int) D.34205;
        D.34207 = __s2 + 2;
        D.34208 = *D.34207;
        D.34209 = (int) D.34208;
        __result = D.34206 - D.34209;
        D.34210 = __s2_len > 2;
        D.34190 = __result == 0;
        D.34211 = D.34210 & D.34190;
        if (D.34211 != 0) goto <D.34212>; else goto <D.34213>;
        <D.34212>:
        D.34214 = &MEM[(void *)"Assembly" + 3B];
        D.34215 = *D.34214;
        D.34216 = (int) D.34215;
        D.34217 = __s2 + 3;
        D.34218 = *D.34217;
        D.34219 = (int) D.34218;
        __result = D.34216 - D.34219;
        <D.34213>:
        <D.34203>:
        <D.34193>:
      }
      D.21426 = __result;
    }
    iftmp.472 = -D.21426;
    goto <D.34220>;
    <D.34183>:
    D.33487 = klass->name;
    iftmp.472 = __builtin_strcmp (D.33487, "Assembly");
    <D.34220>:
    D.21427 = iftmp.472;
  }
  if (D.21427 == 0) goto <D.34178>; else goto <D.34221>;
  <D.34221>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34225 = "MonoAssembly";
      D.34226 = MEM[(const unsigned char *)D.34225];
      D.34227 = (int) D.34226;
      D.34228 = *__s2;
      D.34229 = (int) D.34228;
      __result = D.34227 - D.34229;
      {
        D.34230 = __s2_len != 0;
        D.34231 = __result == 0;
        D.34232 = D.34230 & D.34231;
        if (D.34232 != 0) goto <D.34233>; else goto <D.34234>;
        <D.34233>:
        D.34235 = &MEM[(void *)"MonoAssembly" + 1B];
        D.34236 = *D.34235;
        D.34237 = (int) D.34236;
        D.34238 = __s2 + 1;
        D.34239 = *D.34238;
        D.34240 = (int) D.34239;
        __result = D.34237 - D.34240;
        D.34241 = __s2_len > 1;
        D.34231 = __result == 0;
        D.34242 = D.34241 & D.34231;
        if (D.34242 != 0) goto <D.34243>; else goto <D.34244>;
        <D.34243>:
        D.34245 = &MEM[(void *)"MonoAssembly" + 2B];
        D.34246 = *D.34245;
        D.34247 = (int) D.34246;
        D.34248 = __s2 + 2;
        D.34249 = *D.34248;
        D.34250 = (int) D.34249;
        __result = D.34247 - D.34250;
        D.34251 = __s2_len > 2;
        D.34231 = __result == 0;
        D.34252 = D.34251 & D.34231;
        if (D.34252 != 0) goto <D.34253>; else goto <D.34254>;
        <D.34253>:
        D.34255 = &MEM[(void *)"MonoAssembly" + 3B];
        D.34256 = *D.34255;
        D.34257 = (int) D.34256;
        D.34258 = __s2 + 3;
        D.34259 = *D.34258;
        D.34260 = (int) D.34259;
        __result = D.34257 - D.34260;
        <D.34254>:
        <D.34244>:
        <D.34234>:
      }
      D.21435 = __result;
    }
    iftmp.473 = -D.21435;
    goto <D.34261>;
    <D.34224>:
    D.33487 = klass->name;
    iftmp.473 = __builtin_strcmp (D.33487, "MonoAssembly");
    <D.34261>:
    D.21436 = iftmp.473;
  }
  if (D.21436 == 0) goto <D.34178>; else goto <D.34179>;
  <D.34178>:
  token = 536870913;
  goto <D.34180>;
  <D.34179>:
  {
    gchar * msg;
    struct MonoException * ex;

    D.33487 = klass->name;
    D.34262 = klass->name_space;
    msg = monoeg_g_strdup_printf ("MetadataToken is not supported for type \'%s.%s\'", D.34262, D.33487);
    ex = mono_get_exception_not_implemented (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34180>:
  <D.34096>:
  <D.34002>:
  <D.33999>:
  <D.33955>:
  <D.33911>:
  <D.33674>:
  <D.33671>:
  <D.33624>:
  <D.33580>:
  <D.33535>:
  <D.33491>:
  D.33843 = token;
  return D.33843;
}


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.34264;
  struct MonoClass * D.34267;
  const char * p.474;
  short unsigned int D.34272;
  struct MonoMethodSignature * D.34273;
  short unsigned int D.34274;
  unsigned int D.34275;
  struct MonoClass * D.34276;
  const char * p.475;
  struct MonoMethodSignature * D.34278;
  struct MonoType * D.34279;
  struct MonoObject * iftmp.476;
  struct MonoMethodSignature * D.34281;
  struct MonoType * D.34282;
  int D.34283;
  struct MonoMethodSignature * D.34286;
  struct MonoType * D.34287;
  struct MonoClass * D.34288;
  struct MonoMethodSignature * D.34290;
  struct MonoType * D.34291;
  int D.34292;
  struct MonoMethodSignature * D.34295;
  short unsigned int D.34296;
  unsigned int D.34297;
  const char * named.477;
  short unsigned int D.34299;
  struct MonoClass * D.34300;
  const char * named.478;
  unsigned int D.34302;
  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.34313;
  sizetype type_len.485;
  const guchar * D.34315;
  const guchar * D.34316;
  unsigned int type_len.486;
  unsigned int D.34319;
  unsigned int named.487;
  int D.34322;
  unsigned int D.34323;
  unsigned int type_len.488;
  char * D.34325;
  const char * named.489;
  unsigned int D.34327;
  sizetype name_len.490;
  const guchar * D.34329;
  unsigned int name_len.491;
  unsigned int D.34332;
  int D.34334;
  unsigned int D.34335;
  unsigned int name_len.492;
  char * D.34337;
  const char * named.493;
  unsigned int D.34341;
  struct CattrNamedArg * D.34342;
  struct MonoType * D.34343;
  struct MonoObject * iftmp.494;
  int D.34345;
  struct MonoClass * D.34348;
  int D.34350;
  struct MonoType * iftmp.495;
  struct MonoMethod * D.34357;
  struct MonoMethodSignature * D.34360;
  struct MonoMethod * D.34362;
  struct MonoMethodSignature * D.34363;
  struct MonoMethodSignature * D.34364;
  short unsigned int D.34365;
  int D.34366;
  int D.34367;
  struct MonoObject * iftmp.496;
  int D.34369;
  struct MonoClass * D.34372;
  int D.34374;
  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.34264 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.34264 == 0) goto <D.34265>; else goto <D.34266>;
      <D.34265>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      return;
      <D.34266>:
      D.34267 = method->klass;
      mono_class_init (D.34267);
      domain = mono_domain_get ();
      if (len <= 1) goto <D.34268>; else goto <D.34270>;
      <D.34270>:
      p.474 = p;
      D.34272 = MEM[(const guint16 *)p.474];
      if (D.34272 != 1) goto <D.34268>; else goto <D.34269>;
      <D.34268>:
      return;
      <D.34269>:
      D.34273 = mono_method_signature (method);
      D.34274 = D.34273->param_count;
      D.34275 = (unsigned int) D.34274;
      D.34276 = mono_get_object_class ();
      typedargs = mono_array_new (domain, D.34276, D.34275);
      p.474 = p;
      p.475 = p.474 + 2;
      p = p.475;
      i = 0;
      goto <D.21699>;
      <D.21698>:
      {
        struct MonoObject * obj;
        void * val;

        p.474 = p;
        D.34278 = mono_method_signature (method);
        D.34279 = D.34278->params[i];
        val = load_cattr_value (image, D.34279, p.474, &p);
        D.34281 = mono_method_signature (method);
        D.34282 = D.34281->params[i];
        D.34283 = type_is_reference (D.34282);
        if (D.34283 == 0) goto <D.34284>; else goto <D.34285>;
        <D.34284>:
        D.34286 = mono_method_signature (method);
        D.34287 = D.34286->params[i];
        D.34288 = mono_class_from_mono_type (D.34287);
        iftmp.476 = mono_value_box (domain, D.34288, val);
        goto <D.34289>;
        <D.34285>:
        iftmp.476 = val;
        <D.34289>:
        obj = iftmp.476;
        {
          void * * __p;

          __p = mono_array_addr_with_size (typedargs, 4, i);
          mono_gc_wbarrier_set_arrayref (typedargs, __p, obj);
        }
        D.34290 = mono_method_signature (method);
        D.34291 = D.34290->params[i];
        D.34292 = type_is_reference (D.34291);
        if (D.34292 == 0) goto <D.34293>; else goto <D.34294>;
        <D.34293>:
        monoeg_g_free (val);
        <D.34294>:
      }
      i = i + 1;
      <D.21699>:
      D.34295 = mono_method_signature (method);
      D.34296 = D.34295->param_count;
      D.34297 = (unsigned int) D.34296;
      if (D.34297 > i) goto <D.21698>; else goto <D.21700>;
      <D.21700>:
      p.474 = p;
      named = p.474;
      named.477 = named;
      D.34299 = MEM[(const guint16 *)named.477];
      num_named = (guint32) D.34299;
      D.34300 = mono_get_object_class ();
      namedargs = mono_array_new (domain, D.34300, num_named);
      named.477 = named;
      named.478 = named.477 + 2;
      named = named.478;
      attrklass = method->klass;
      D.34302 = num_named * 12;
      arginfo = monoeg_malloc0 (D.34302);
      *named_arg_info = arginfo;
      j = 0;
      goto <D.21718>;
      <D.21717>:
      {
        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.34307>; else goto <D.34308>;
        <D.34307>:
        named.477 = named;
        named.483 = named.477;
        named.484 = named.483 + 1;
        named = named.484;
        data_type = *named.483;
        <D.34308>:
        if (data_type == 85) goto <D.34311>; else goto <D.34312>;
        <D.34311>:
        {
          gint type_len;
          char * type_name;

          named.477 = named;
          D.34313 = mono_metadata_decode_blob_size (named.477, &named);
          type_len = (gint) D.34313;
          named.477 = named;
          type_len.485 = (sizetype) type_len;
          D.34315 = named.477 + type_len.485;
          D.34316 = data + len;
          if (D.34315 > D.34316) goto fail; else goto <D.34317>;
          <D.34317>:
          type_len.486 = (unsigned int) type_len;
          D.34319 = ~type_len.486;
          named.477 = named;
          named.487 = (unsigned int) named.477;
          if (D.34319 < named.487) goto fail; else goto <D.34321>;
          <D.34321>:
          D.34322 = type_len + 1;
          D.34323 = (unsigned int) D.34322;
          type_name = monoeg_malloc (D.34323);
          type_len.488 = (unsigned int) type_len;
          named.477 = named;
          memcpy (type_name, named.477, type_len.488);
          type_len.485 = (sizetype) type_len;
          D.34325 = type_name + type_len.485;
          *D.34325 = 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.34312>:
        named.477 = named;
        D.34327 = mono_metadata_decode_blob_size (named.477, &named);
        name_len = (gint) D.34327;
        named.477 = named;
        name_len.490 = (sizetype) name_len;
        D.34329 = named.477 + name_len.490;
        D.34316 = data + len;
        if (D.34329 > D.34316) goto fail; else goto <D.34330>;
        <D.34330>:
        name_len.491 = (unsigned int) name_len;
        D.34332 = ~name_len.491;
        named.477 = named;
        named.487 = (unsigned int) named.477;
        if (D.34332 < named.487) goto fail; else goto <D.34333>;
        <D.34333>:
        D.34334 = name_len + 1;
        D.34335 = (unsigned int) D.34334;
        name = monoeg_malloc (D.34335);
        name_len.492 = (unsigned int) name_len;
        named.477 = named;
        memcpy (name, named.477, name_len.492);
        name_len.490 = (sizetype) name_len;
        D.34337 = name + name_len.490;
        *D.34337 = 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.34339>; else goto <D.34340>;
        <D.34339>:
        {
          struct MonoObject * obj;
          struct MonoClassField * field;
          void * val;

          field = mono_class_get_field_from_name (attrklass, name);
          D.34341 = j * 12;
          D.34342 = arginfo + D.34341;
          D.34343 = field->type;
          D.34342->type = D.34343;
          D.34341 = j * 12;
          D.34342 = arginfo + D.34341;
          D.34342->field = field;
          named.477 = named;
          D.34343 = field->type;
          val = load_cattr_value (image, D.34343, named.477, &named);
          D.34343 = field->type;
          D.34345 = type_is_reference (D.34343);
          if (D.34345 == 0) goto <D.34346>; else goto <D.34347>;
          <D.34346>:
          D.34343 = field->type;
          D.34348 = mono_class_from_mono_type (D.34343);
          iftmp.494 = mono_value_box (domain, D.34348, val);
          goto <D.34349>;
          <D.34347>:
          iftmp.494 = val;
          <D.34349>:
          obj = iftmp.494;
          {
            void * * __p;

            __p = mono_array_addr_with_size (namedargs, 4, j);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.34343 = field->type;
          D.34350 = type_is_reference (D.34343);
          if (D.34350 == 0) goto <D.34351>; else goto <D.34352>;
          <D.34351>:
          monoeg_g_free (val);
          <D.34352>:
        }
        goto <D.34353>;
        <D.34340>:
        if (named_type == 84) goto <D.34354>; else goto <D.34355>;
        <D.34354>:
        {
          struct MonoObject * obj;
          struct MonoType * prop_type;
          struct MonoProperty * prop;
          void * val;

          prop = mono_class_get_property_from_name (attrklass, name);
          D.34357 = prop->get;
          if (D.34357 != 0B) goto <D.34358>; else goto <D.34359>;
          <D.34358>:
          D.34357 = prop->get;
          D.34360 = mono_method_signature (D.34357);
          iftmp.495 = D.34360->ret;
          goto <D.34361>;
          <D.34359>:
          D.34362 = prop->set;
          D.34363 = mono_method_signature (D.34362);
          D.34362 = prop->set;
          D.34364 = mono_method_signature (D.34362);
          D.34365 = D.34364->param_count;
          D.34366 = (int) D.34365;
          D.34367 = D.34366 + -1;
          iftmp.495 = D.34363->params[D.34367];
          <D.34361>:
          prop_type = iftmp.495;
          D.34341 = j * 12;
          D.34342 = arginfo + D.34341;
          D.34342->type = prop_type;
          D.34341 = j * 12;
          D.34342 = arginfo + D.34341;
          D.34342->prop = prop;
          named.477 = named;
          val = load_cattr_value (image, prop_type, named.477, &named);
          D.34369 = type_is_reference (prop_type);
          if (D.34369 == 0) goto <D.34370>; else goto <D.34371>;
          <D.34370>:
          D.34372 = mono_class_from_mono_type (prop_type);
          iftmp.496 = mono_value_box (domain, D.34372, val);
          goto <D.34373>;
          <D.34371>:
          iftmp.496 = val;
          <D.34373>:
          obj = iftmp.496;
          {
            void * * __p;

            __p = mono_array_addr_with_size (namedargs, 4, j);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.34374 = type_is_reference (prop_type);
          if (D.34374 == 0) goto <D.34375>; else goto <D.34376>;
          <D.34375>:
          monoeg_g_free (val);
          <D.34376>:
        }
        <D.34355>:
        <D.34353>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.21718>:
      if (j < num_named) goto <D.21717>; else goto <D.21719>;
      <D.21719>:
      *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.34380;
  const char * p.497;
  char D.34382;
  unsigned char D.34383;
  const char * p.504;
  void * D.34385;
  short unsigned int D.34386;
  const char * p.511;
  unsigned int D.34388;
  const char * p.508;
  long long unsigned int D.34390;
  const char * p.514;
  double D.34392;
  struct MonoClass * D.34393;
  unsigned char D.34394;
  unsigned char D.34395;
  struct MonoType * D.34398;
  unsigned char D.34399;
  struct MonoImage * D.34400;
  int D.34401;
  int D.21488;
  int iftmp.498;
  int D.21487;
  const char[7] * D.34407;
  unsigned char D.34408;
  int D.34409;
  unsigned char D.34410;
  int D.34411;
  _Bool D.34412;
  _Bool D.34413;
  _Bool D.34414;
  const unsigned char * D.34417;
  unsigned char D.34418;
  int D.34419;
  const unsigned char * D.34420;
  unsigned char D.34421;
  int D.34422;
  _Bool D.34423;
  _Bool D.34424;
  const unsigned char * D.34427;
  unsigned char D.34428;
  int D.34429;
  const unsigned char * D.34430;
  unsigned char D.34431;
  int D.34432;
  _Bool D.34433;
  _Bool D.34434;
  const unsigned char * D.34437;
  unsigned char D.34438;
  int D.34439;
  const unsigned char * D.34440;
  unsigned char D.34441;
  int D.34442;
  const char * D.34444;
  int D.21497;
  int iftmp.499;
  int D.21496;
  const char[9] * D.34450;
  unsigned char D.34451;
  int D.34452;
  unsigned char D.34453;
  int D.34454;
  _Bool D.34455;
  _Bool D.34456;
  _Bool D.34457;
  const unsigned char * D.34460;
  unsigned char D.34461;
  int D.34462;
  const unsigned char * D.34463;
  unsigned char D.34464;
  int D.34465;
  _Bool D.34466;
  _Bool D.34467;
  const unsigned char * D.34470;
  unsigned char D.34471;
  int D.34472;
  const unsigned char * D.34473;
  unsigned char D.34474;
  int D.34475;
  _Bool D.34476;
  _Bool D.34477;
  const unsigned char * D.34480;
  unsigned char D.34481;
  int D.34482;
  const unsigned char * D.34483;
  unsigned char D.34484;
  int D.34485;
  const char * D.34487;
  const char * D.34490;
  unsigned int D.34493;
  sizetype slen.500;
  const char * p.505;
  unsigned int slen.501;
  struct MonoDomain * D.34497;
  unsigned int D.34500;
  int D.34501;
  unsigned int D.34502;
  char * D.34503;
  struct MonoDomain * D.34508;
  const char * p.502;
  const char * p.503;
  unsigned char D.34524;
  unsigned int D.34527;
  char * D.34528;
  unsigned char subt.506;
  unsigned char D.34533;
  unsigned char subt.507;
  int D.34538;
  struct MonoType * D.34539;
  struct MonoDomain * D.34540;
  unsigned char D.34541;
  unsigned char D.34542;
  _Bool D.34543;
  long int D.34544;
  long int D.34545;
  int D.34548;
  unsigned int D.34549;
  void * D.34550;
  struct MonoDomain * D.34553;
  unsigned char D.34554;
  unsigned char D.34557;
  unsigned char D.34558;
  struct MonoType * D.34561;
  unsigned char D.34562;
  const char * p.509;
  const char * p.510;
  char D.34565;
  double val.512;
  double val.513;
  struct MonoType * D.34568;
  int slen;
  int type;
  struct MonoClass * tklass;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  D.34380 = t->type;
  type = (int) D.34380;
  tklass = t->data.klass;
  handle_enum:
  switch (type) <default: <D.21571>, case 2: <D.21460>, case 3: <D.21462>, case 4: <D.21459>, case 5: <D.21458>, case 6: <D.21464>, case 7: <D.21463>, case 8: <D.21470>, case 9: <D.21469>, case 10: <D.21473>, case 11: <D.21472>, case 12: <D.21468>, case 13: <D.21475>, case 14: <D.21500>, case 17: <D.21478>, case 18: <D.21501>, case 24: <D.21467>, case 25: <D.21466>, case 28: <D.21505>, case 29: <D.21517>>
  <D.21458>:
  <D.21459>:
  <D.21460>:
  {
    MonoBoolean * bval;

    bval = monoeg_malloc (1);
    p.497 = p;
    D.34382 = *p.497;
    D.34383 = (unsigned char) D.34382;
    *bval = D.34383;
    p.497 = p;
    p.504 = p.497 + 1;
    *end = p.504;
    D.34385 = bval;
    return D.34385;
  }
  <D.21462>:
  <D.21463>:
  <D.21464>:
  {
    guint16 * val;

    val = monoeg_malloc (2);
    p.497 = p;
    D.34386 = MEM[(const guint16 *)p.497];
    *val = D.34386;
    p.497 = p;
    p.511 = p.497 + 2;
    *end = p.511;
    D.34385 = val;
    return D.34385;
  }
  <D.21466>:
  <D.21467>:
  <D.21468>:
  <D.21469>:
  <D.21470>:
  {
    guint32 * val;

    val = monoeg_malloc (4);
    p.497 = p;
    D.34388 = MEM[(const guint32 *)p.497];
    *val = D.34388;
    p.497 = p;
    p.508 = p.497 + 4;
    *end = p.508;
    D.34385 = val;
    return D.34385;
  }
  <D.21472>:
  <D.21473>:
  {
    guint64 * val;

    val = monoeg_malloc (8);
    p.497 = p;
    D.34390 = MEM[(const guint64 *)p.497];
    *val = D.34390;
    p.497 = p;
    p.514 = p.497 + 8;
    *end = p.514;
    D.34385 = val;
    return D.34385;
  }
  <D.21475>:
  {
    double * val;

    val = monoeg_malloc (8);
    {
      union mono_rdouble mf;

      try
        {
          p.497 = p;
          D.34390 = MEM[(const guint64 *)p.497];
          mf.ival = D.34390;
          D.34392 = mf.fval;
          *val = D.34392;
        }
      finally
        {
          mf = {CLOBBER};
        }
    }
    p.497 = p;
    p.514 = p.497 + 8;
    *end = p.514;
    D.34385 = val;
    return D.34385;
  }
  <D.21478>:
  D.34393 = t->data.klass;
  D.34394 = BIT_FIELD_REF <*D.34393, 8, 160>;
  D.34395 = D.34394 & 16;
  if (D.34395 != 0) goto <D.34396>; else goto <D.34397>;
  <D.34396>:
  D.34393 = t->data.klass;
  D.34398 = mono_class_enum_basetype (D.34393);
  D.34399 = D.34398->type;
  type = (int) D.34399;
  goto handle_enum;
  <D.34397>:
  {
    struct MonoClass * k;

    k = t->data.klass;
    D.34400 = k->image;
    D.34401 = mono_is_corlib_image (D.34400);
    if (D.34401 != 0) goto <D.34402>; else goto <D.34403>;
    <D.34402>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name_space;
        D.34407 = "System";
        D.34408 = MEM[(const unsigned char *)D.34407];
        D.34409 = (int) D.34408;
        D.34410 = *__s2;
        D.34411 = (int) D.34410;
        __result = D.34409 - D.34411;
        {
          D.34412 = __s2_len != 0;
          D.34413 = __result == 0;
          D.34414 = D.34412 & D.34413;
          if (D.34414 != 0) goto <D.34415>; else goto <D.34416>;
          <D.34415>:
          D.34417 = &MEM[(void *)"System" + 1B];
          D.34418 = *D.34417;
          D.34419 = (int) D.34418;
          D.34420 = __s2 + 1;
          D.34421 = *D.34420;
          D.34422 = (int) D.34421;
          __result = D.34419 - D.34422;
          D.34423 = __s2_len > 1;
          D.34413 = __result == 0;
          D.34424 = D.34423 & D.34413;
          if (D.34424 != 0) goto <D.34425>; else goto <D.34426>;
          <D.34425>:
          D.34427 = &MEM[(void *)"System" + 2B];
          D.34428 = *D.34427;
          D.34429 = (int) D.34428;
          D.34430 = __s2 + 2;
          D.34431 = *D.34430;
          D.34432 = (int) D.34431;
          __result = D.34429 - D.34432;
          D.34433 = __s2_len > 2;
          D.34413 = __result == 0;
          D.34434 = D.34433 & D.34413;
          if (D.34434 != 0) goto <D.34435>; else goto <D.34436>;
          <D.34435>:
          D.34437 = &MEM[(void *)"System" + 3B];
          D.34438 = *D.34437;
          D.34439 = (int) D.34438;
          D.34440 = __s2 + 3;
          D.34441 = *D.34440;
          D.34442 = (int) D.34441;
          __result = D.34439 - D.34442;
          <D.34436>:
          <D.34426>:
          <D.34416>:
        }
        D.21487 = __result;
      }
      iftmp.498 = -D.21487;
      goto <D.34443>;
      <D.34406>:
      D.34444 = k->name_space;
      iftmp.498 = __builtin_strcmp (D.34444, "System");
      <D.34443>:
      D.21488 = iftmp.498;
    }
    if (D.21488 == 0) goto <D.34445>; else goto <D.34446>;
    <D.34445>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name;
        D.34450 = "DateTime";
        D.34451 = MEM[(const unsigned char *)D.34450];
        D.34452 = (int) D.34451;
        D.34453 = *__s2;
        D.34454 = (int) D.34453;
        __result = D.34452 - D.34454;
        {
          D.34455 = __s2_len != 0;
          D.34456 = __result == 0;
          D.34457 = D.34455 & D.34456;
          if (D.34457 != 0) goto <D.34458>; else goto <D.34459>;
          <D.34458>:
          D.34460 = &MEM[(void *)"DateTime" + 1B];
          D.34461 = *D.34460;
          D.34462 = (int) D.34461;
          D.34463 = __s2 + 1;
          D.34464 = *D.34463;
          D.34465 = (int) D.34464;
          __result = D.34462 - D.34465;
          D.34466 = __s2_len > 1;
          D.34456 = __result == 0;
          D.34467 = D.34466 & D.34456;
          if (D.34467 != 0) goto <D.34468>; else goto <D.34469>;
          <D.34468>:
          D.34470 = &MEM[(void *)"DateTime" + 2B];
          D.34471 = *D.34470;
          D.34472 = (int) D.34471;
          D.34473 = __s2 + 2;
          D.34474 = *D.34473;
          D.34475 = (int) D.34474;
          __result = D.34472 - D.34475;
          D.34476 = __s2_len > 2;
          D.34456 = __result == 0;
          D.34477 = D.34476 & D.34456;
          if (D.34477 != 0) goto <D.34478>; else goto <D.34479>;
          <D.34478>:
          D.34480 = &MEM[(void *)"DateTime" + 3B];
          D.34481 = *D.34480;
          D.34482 = (int) D.34481;
          D.34483 = __s2 + 3;
          D.34484 = *D.34483;
          D.34485 = (int) D.34484;
          __result = D.34482 - D.34485;
          <D.34479>:
          <D.34469>:
          <D.34459>:
        }
        D.21496 = __result;
      }
      iftmp.499 = -D.21496;
      goto <D.34486>;
      <D.34449>:
      D.34487 = k->name;
      iftmp.499 = __builtin_strcmp (D.34487, "DateTime");
      <D.34486>:
      D.21497 = iftmp.499;
    }
    if (D.21497 == 0) goto <D.34488>; else goto <D.34489>;
    <D.34488>:
    {
      guint64 * val;

      val = monoeg_malloc (8);
      p.497 = p;
      D.34390 = MEM[(const guint64 *)p.497];
      *val = D.34390;
      p.497 = p;
      p.514 = p.497 + 8;
      *end = p.514;
      D.34385 = val;
      return D.34385;
    }
    <D.34489>:
    <D.34446>:
    <D.34403>:
  }
  D.34393 = t->data.klass;
  D.34490 = D.34393->name;
  monoeg_g_log (0B, 4, "generic valutype %s not handled in custom attr value decoding", D.34490);
  <D.21499>:
  goto <D.21499>;
  <D.21500>:
  p.497 = p;
  D.34382 = *p.497;
  if (D.34382 == -1) goto <D.34491>; else goto <D.34492>;
  <D.34491>:
  p.497 = p;
  p.504 = p.497 + 1;
  *end = p.504;
  D.34385 = 0B;
  return D.34385;
  <D.34492>:
  p.497 = p;
  D.34493 = mono_metadata_decode_value (p.497, &p);
  slen = (int) D.34493;
  p.497 = p;
  slen.500 = (sizetype) slen;
  p.505 = p.497 + slen.500;
  *end = p.505;
  slen.501 = (unsigned int) slen;
  p.497 = p;
  D.34497 = mono_domain_get ();
  D.34385 = mono_string_new_len (D.34497, p.497, slen.501);
  return D.34385;
  <D.21501>:
  {
    char * n;
    struct MonoType * t;

    p.497 = p;
    D.34382 = *p.497;
    if (D.34382 == -1) goto <D.34498>; else goto <D.34499>;
    <D.34498>:
    p.497 = p;
    p.504 = p.497 + 1;
    *end = p.504;
    D.34385 = 0B;
    return D.34385;
    <D.34499>:
    handle_type:
    p.497 = p;
    D.34500 = mono_metadata_decode_value (p.497, &p);
    slen = (int) D.34500;
    D.34501 = slen + 1;
    D.34502 = (unsigned int) D.34501;
    p.497 = p;
    n = monoeg_g_memdup (p.497, D.34502);
    slen.500 = (sizetype) slen;
    D.34503 = n + slen.500;
    *D.34503 = 0;
    t = mono_reflection_type_from_name (n, image);
    if (t == 0B) goto <D.34504>; else goto <D.34505>;
    <D.34504>:
    monoeg_g_log (0B, 16, "Cannot load type \'%s\'", n);
    <D.34505>:
    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.34506>; else goto <D.34507>;
    <D.34506>:
    D.34508 = mono_domain_get ();
    D.34385 = mono_type_get_object (D.34508, t);
    return D.34385;
    <D.34507>:
    D.34385 = 0B;
    return D.34385;
  }
  <D.21505>:
  {
    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.34511>;
    <D.34511>:
    if (subt == 14) goto <D.34512>; else goto <D.34513>;
    <D.34512>:
    type = 14;
    goto handle_enum;
    <D.34513>:
    if (subt == 29) goto <D.34514>; else goto <D.34515>;
    <D.34514>:
    {
      struct MonoType simple_type;
      int etype;

      try
        {
          simple_type = {};
          p.497 = p;
          D.34382 = *p.497;
          etype = (int) D.34382;
          p.497 = p;
          p.504 = p.497 + 1;
          p = p.504;
          type = 29;
          if (etype == 80) goto <D.34516>; else goto <D.34517>;
          <D.34516>:
          tklass = mono_defaults.systemtype_class;
          goto <D.34518>;
          <D.34517>:
          if (etype == 85) goto <D.34519>; else goto <D.34520>;
          <D.34519>:
          p.497 = p;
          tklass = load_cattr_enum_type (image, p.497, &p);
          goto <D.34521>;
          <D.34520>:
          if (etype == 81) goto <D.34522>; else goto <D.34523>;
          <D.34522>:
          etype = 28;
          <D.34523>:
          D.34524 = (unsigned char) etype;
          simple_type.type = D.34524;
          tklass = mono_class_from_mono_type (&simple_type);
          <D.34521>:
          <D.34518>:
          goto handle_enum;
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    <D.34515>:
    if (subt == 85) goto <D.34525>; else goto <D.34526>;
    <D.34525>:
    {
      char * n;
      struct MonoType * t;

      p.497 = p;
      D.34527 = mono_metadata_decode_value (p.497, &p);
      slen = (int) D.34527;
      D.34501 = slen + 1;
      D.34502 = (unsigned int) D.34501;
      p.497 = p;
      n = monoeg_g_memdup (p.497, D.34502);
      slen.500 = (sizetype) slen;
      D.34528 = n + slen.500;
      *D.34528 = 0;
      t = mono_reflection_type_from_name (n, image);
      if (t == 0B) goto <D.34529>; else goto <D.34530>;
      <D.34529>:
      monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
      <D.21514>:
      goto <D.21514>;
      <D.34530>:
      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.34531>;
    <D.34526>:
    subt.506 = (unsigned char) subt;
    D.34533 = subt.506 + 254;
    if (D.34533 <= 11) goto <D.34534>; else goto <D.34535>;
    <D.34534>:
    {
      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.34537>;
    <D.34535>:
    D.34538 = (int) subt;
    monoeg_g_log (0B, 4, "Unknown type 0x%02x for object type encoding in custom attr", D.34538);
    <D.21516>:
    goto <D.21516>;
    <D.34537>:
    <D.34531>:
    p.497 = p;
    D.34539 = &subc->byval_arg;
    val = load_cattr_value (image, D.34539, p.497, end);
    D.34540 = mono_domain_get ();
    obj = mono_object_new (D.34540, subc);
    D.34541 = BIT_FIELD_REF <*subc, 8, 184>;
    D.34542 = D.34541 & 8;
    D.34543 = D.34542 != 0;
    D.34544 = (long int) D.34543;
    D.34545 = __builtin_expect (D.34544, 0);
    if (D.34545 != 0) goto <D.34546>; else goto <D.34547>;
    <D.34546>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7953, "!subc->has_references");
    <D.34547>:
    D.34548 = mono_class_value_size (subc, 0B);
    D.34549 = (unsigned int) D.34548;
    D.34550 = obj + 8;
    mono_gc_memmove_atomic (D.34550, val, D.34549);
    monoeg_g_free (val);
    D.34385 = obj;
    return D.34385;
  }
  <D.21517>:
  {
    struct MonoArray * arr;
    guint32 i;
    guint32 alen;
    guint32 basetype;

    p.497 = p;
    alen = MEM[(const guint32 *)p.497];
    p.497 = p;
    p.508 = p.497 + 4;
    p = p.508;
    if (alen == 4294967295) goto <D.34551>; else goto <D.34552>;
    <D.34551>:
    p.497 = p;
    *end = p.497;
    D.34385 = 0B;
    return D.34385;
    <D.34552>:
    D.34553 = mono_domain_get ();
    arr = mono_array_new (D.34553, tklass, alen);
    D.34554 = tklass->byval_arg.type;
    basetype = (guint32) D.34554;
    if (basetype == 17) goto <D.34555>; else goto <D.34556>;
    <D.34555>:
    D.34557 = BIT_FIELD_REF <*tklass, 8, 160>;
    D.34558 = D.34557 & 16;
    if (D.34558 != 0) goto <D.34559>; else goto <D.34560>;
    <D.34559>:
    D.34561 = mono_class_enum_basetype (tklass);
    D.34562 = D.34561->type;
    basetype = (guint32) D.34562;
    <D.34560>:
    <D.34556>:
    switch (basetype) <default: <D.21569>, case 2: <D.21524>, case 3: <D.21531>, case 4: <D.21523>, case 5: <D.21522>, case 6: <D.21533>, case 7: <D.21532>, case 8: <D.21541>, case 9: <D.21540>, case 10: <D.21555>, case 11: <D.21554>, case 12: <D.21539>, case 13: <D.21547>, case 14: <D.21563>, case 18: <D.21561>, case 28: <D.21562>>
    <D.21522>:
    <D.21523>:
    <D.21524>:
    i = 0;
    goto <D.21528>;
    <D.21527>:
    {
      MonoBoolean val;

      p.497 = p;
      p.509 = p.497;
      p.510 = p.509 + 1;
      p = p.510;
      D.34565 = *p.509;
      val = (MonoBoolean) D.34565;
      {
        MonoBoolean * __p;

        __p = mono_array_addr_with_size (arr, 1, i);
        *__p = val;
      }
    }
    i = i + 1;
    <D.21528>:
    if (i < alen) goto <D.21527>; else goto <D.21529>;
    <D.21529>:
    goto <D.21530>;
    <D.21531>:
    <D.21532>:
    <D.21533>:
    i = 0;
    goto <D.21537>;
    <D.21536>:
    {
      guint16 val;

      p.497 = p;
      val = MEM[(const guint16 *)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.21537>:
    if (i < alen) goto <D.21536>; else goto <D.21538>;
    <D.21538>:
    goto <D.21530>;
    <D.21539>:
    <D.21540>:
    <D.21541>:
    i = 0;
    goto <D.21545>;
    <D.21544>:
    {
      guint32 val;

      p.497 = p;
      val = MEM[(const guint32 *)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.21545>:
    if (i < alen) goto <D.21544>; else goto <D.21546>;
    <D.21546>:
    goto <D.21530>;
    <D.21547>:
    i = 0;
    goto <D.21552>;
    <D.21551>:
    {
      double val;

      try
        {
          {
            union mono_rdouble mf;

            try
              {
                p.497 = p;
                D.34390 = MEM[(const guint64 *)p.497];
                mf.ival = D.34390;
                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.21552>:
    if (i < alen) goto <D.21551>; else goto <D.21553>;
    <D.21553>:
    goto <D.21530>;
    <D.21554>:
    <D.21555>:
    i = 0;
    goto <D.21559>;
    <D.21558>:
    {
      guint64 val;

      p.497 = p;
      val = MEM[(const guint64 *)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.21559>:
    if (i < alen) goto <D.21558>; else goto <D.21560>;
    <D.21560>:
    goto <D.21530>;
    <D.21561>:
    <D.21562>:
    <D.21563>:
    i = 0;
    goto <D.21567>;
    <D.21566>:
    {
      struct MonoObject * item;

      p.497 = p;
      D.34568 = &tklass->byval_arg;
      item = load_cattr_value (image, D.34568, 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.21567>:
    if (i < alen) goto <D.21566>; else goto <D.21568>;
    <D.21568>:
    goto <D.21530>;
    <D.21569>:
    monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr array decoding", basetype);
    <D.21570>:
    goto <D.21570>;
    <D.21530>:
    p.497 = p;
    *end = p.497;
    D.34385 = arr;
    return D.34385;
  }
  <D.21571>:
  monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr value decoding", type);
  <D.21572>:
  goto <D.21572>;
  D.34385 = 0B;
  return D.34385;
}


load_cattr_enum_type (struct MonoImage * image, const char * p, const char * * end)
{
  const char * p.515;
  unsigned int D.34572;
  int D.34573;
  unsigned int D.34574;
  sizetype slen.516;
  char * D.34576;
  const char * p.517;
  struct MonoClass * D.34580;
  char * n;
  struct MonoType * t;
  int slen;

  p.515 = p;
  D.34572 = mono_metadata_decode_value (p.515, &p);
  slen = (int) D.34572;
  D.34573 = slen + 1;
  D.34574 = (unsigned int) D.34573;
  p.515 = p;
  n = monoeg_g_memdup (p.515, D.34574);
  slen.516 = (sizetype) slen;
  D.34576 = n + slen.516;
  *D.34576 = 0;
  t = mono_reflection_type_from_name (n, image);
  if (t == 0B) goto <D.34577>; else goto <D.34578>;
  <D.34577>:
  monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
  <D.21447>:
  goto <D.21447>;
  <D.34578>:
  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.34580 = mono_class_from_mono_type (t);
  return D.34580;
}


type_is_reference (struct MonoType * type)
{
  unsigned char D.34582;
  int D.34583;
  gboolean D.34584;

  D.34582 = type->type;
  D.34583 = (int) D.34582;
  switch (D.34583) <default: <D.21609>, case 2: <D.21594>, case 3: <D.21595>, case 4: <D.21599>, case 5: <D.21598>, case 6: <D.21601>, case 7: <D.21600>, case 8: <D.21603>, case 9: <D.21602>, case 10: <D.21605>, case 11: <D.21604>, case 12: <D.21607>, case 13: <D.21606>, case 17: <D.21608>, case 24: <D.21597>, case 25: <D.21596>>
  <D.21594>:
  <D.21595>:
  <D.21596>:
  <D.21597>:
  <D.21598>:
  <D.21599>:
  <D.21600>:
  <D.21601>:
  <D.21602>:
  <D.21603>:
  <D.21604>:
  <D.21605>:
  <D.21606>:
  <D.21607>:
  <D.21608>:
  D.34584 = 0;
  return D.34584;
  <D.21609>:
  D.34584 = 1;
  return D.34584;
}


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.34588;
  struct MonoVTable * D.34589;
  struct MonoClass * D.34590;
  int D.34591;
  struct MonoException * D.34594;
  int D.34595;
  struct MonoLoaderError * D.34598;
  struct MonoLoaderError * D.34601;
  struct MonoException * D.34602;
  struct MonoArray * typedargs.518;
  struct MonoArray * namedargs.519;
  struct CattrNamedArg * arginfo.520;
  unsigned int i.521;
  char * D.34610;
  struct MonoMethodSignature * D.34611;
  struct MonoType * D.34612;
  struct MonoMethodSignature * D.34613;
  short unsigned int D.34614;
  int D.34615;
  char * D.34616;
  unsigned int i.522;
  unsigned int D.34618;
  struct CattrNamedArg * D.34619;
  struct MonoProperty * D.34620;
  struct MonoClassField * D.34624;
  struct MonoType * D.34625;
  unsigned int D.34626;
  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.34586>; else goto <D.34587>;
      <D.34586>:
      return;
      <D.34587>:
      D.34588 = assembly->assembly;
      image = D.34588->image;
      method = ref_method->method;
      D.34589 = MEM[(struct MonoObject *)ref_method].vtable;
      domain = D.34589->domain;
      D.34590 = method->klass;
      D.34591 = mono_class_init (D.34590);
      if (D.34591 == 0) goto <D.34592>; else goto <D.34593>;
      <D.34592>:
      D.34590 = method->klass;
      D.34594 = mono_class_get_exception_for_failure (D.34590);
      mono_raise_exception (D.34594);
      <D.34593>:
      mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
      D.34595 = mono_error_ok (&error);
      if (D.34595 == 0) goto <D.34596>; else goto <D.34597>;
      <D.34596>:
      mono_error_raise_exception (&error);
      <D.34597>:
      D.34598 = mono_loader_get_last_error ();
      if (D.34598 != 0B) goto <D.34599>; else goto <D.34600>;
      <D.34599>:
      D.34601 = mono_loader_get_last_error ();
      D.34602 = mono_loader_error_prepare_exception (D.34601);
      mono_raise_exception (D.34602);
      <D.34600>:
      typedargs.518 = typedargs;
      if (typedargs.518 == 0B) goto <D.34603>; else goto <D.34606>;
      <D.34606>:
      namedargs.519 = namedargs;
      if (namedargs.519 == 0B) goto <D.34603>; else goto <D.34604>;
      <D.34603>:
      arginfo.520 = arginfo;
      monoeg_g_free (arginfo.520);
      return;
      <D.34604>:
      i = 0;
      goto <D.21740>;
      <D.21739>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;

        i.521 = (unsigned int) i;
        typedargs.518 = typedargs;
        D.34610 = mono_array_addr_with_size (typedargs.518, 4, i.521);
        obj = MEM[(struct MonoObject * *)D.34610];
        D.34611 = mono_method_signature (method);
        D.34612 = D.34611->params[i];
        typedarg = create_cattr_typed_arg (D.34612, obj);
        {
          void * * __p;

          i.521 = (unsigned int) i;
          typedargs.518 = typedargs;
          __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.21740>:
      D.34613 = mono_method_signature (method);
      D.34614 = D.34613->param_count;
      D.34615 = (int) D.34614;
      if (D.34615 > i) goto <D.21739>; else goto <D.21741>;
      <D.21741>:
      i = 0;
      goto <D.21748>;
      <D.21747>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;
        struct MonoObject * namedarg;
        struct MonoObject * minfo;

        i.521 = (unsigned int) i;
        namedargs.519 = namedargs;
        D.34616 = mono_array_addr_with_size (namedargs.519, 4, i.521);
        obj = MEM[(struct MonoObject * *)D.34616];
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34618 = i.522 * 12;
        D.34619 = arginfo.520 + D.34618;
        D.34620 = D.34619->prop;
        if (D.34620 != 0B) goto <D.34621>; else goto <D.34622>;
        <D.34621>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34618 = i.522 * 12;
        D.34619 = arginfo.520 + D.34618;
        D.34620 = D.34619->prop;
        minfo = mono_property_get_object (domain, 0B, D.34620);
        goto <D.34623>;
        <D.34622>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34618 = i.522 * 12;
        D.34619 = arginfo.520 + D.34618;
        D.34624 = D.34619->field;
        minfo = mono_field_get_object (domain, 0B, D.34624);
        <D.34623>:
        arginfo.520 = arginfo;
        i.522 = (unsigned int) i;
        D.34618 = i.522 * 12;
        D.34619 = arginfo.520 + D.34618;
        D.34625 = D.34619->type;
        typedarg = create_cattr_typed_arg (D.34625, obj);
        namedarg = create_cattr_named_arg (minfo, typedarg);
        {
          void * * __p;

          i.521 = (unsigned int) i;
          namedargs.519 = namedargs;
          __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.21748>:
      i.521 = (unsigned int) i;
      namedargs.519 = namedargs;
      D.34626 = mono_array_length (namedargs.519);
      if (i.521 < D.34626) goto <D.21747>; else goto <D.21749>;
      <D.21749>:
      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.34633;
  struct MonoClass * klass.524;
  struct MonoMethod * ctor.525;
  struct MonoMethod * ctor.526;
  struct MonoDomain * D.34639;
  struct MonoReflectionType * D.34640;
  struct MonoDomain * D.34641;
  struct MonoObject * D.34642;
  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.34631>; else goto <D.34632>;
      <D.34631>:
      D.34633 = mono_defaults.corlib;
      klass.524 = mono_class_from_name (D.34633, "System.Reflection", "CustomAttributeTypedArgument");
      klass = klass.524;
      <D.34632>:
      ctor.525 = ctor;
      if (ctor.525 == 0B) goto <D.34636>; else goto <D.34637>;
      <D.34636>:
      klass.523 = klass;
      ctor.526 = mono_class_get_method_from_name (klass.523, ".ctor", 2);
      ctor = ctor.526;
      <D.34637>:
      D.34639 = mono_domain_get ();
      D.34640 = mono_type_get_object (D.34639, t);
      params[0] = D.34640;
      params[1] = val;
      klass.523 = klass;
      D.34641 = mono_domain_get ();
      retval = mono_object_new (D.34641, klass.523);
      unboxed = mono_object_unbox (retval);
      ctor.525 = ctor;
      mono_runtime_invoke (ctor.525, unboxed, &params, 0B);
      D.34642 = retval;
      return D.34642;
    }
  finally
    {
      params = {CLOBBER};
    }
}


create_cattr_named_arg (void * minfo, struct MonoObject * typedarg)
{
  struct MonoClass * klass.527;
  struct MonoImage * D.34648;
  struct MonoClass * klass.528;
  struct MonoMethod * ctor.529;
  struct MonoMethod * ctor.530;
  struct MonoDomain * D.34654;
  struct MonoObject * D.34655;
  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.34646>; else goto <D.34647>;
      <D.34646>:
      D.34648 = mono_defaults.corlib;
      klass.528 = mono_class_from_name (D.34648, "System.Reflection", "CustomAttributeNamedArgument");
      klass = klass.528;
      <D.34647>:
      ctor.529 = ctor;
      if (ctor.529 == 0B) goto <D.34651>; else goto <D.34652>;
      <D.34651>:
      klass.527 = klass;
      ctor.530 = mono_class_get_method_from_name (klass.527, ".ctor", 2);
      ctor = ctor.530;
      <D.34652>:
      params[0] = minfo;
      params[1] = typedarg;
      klass.527 = klass;
      D.34654 = mono_domain_get ();
      retval = mono_object_new (D.34654, klass.527);
      unboxed = mono_object_unbox (retval);
      ctor.529 = ctor;
      mono_runtime_invoke (ctor.529, unboxed, &params, 0B);
      D.34655 = retval;
      return D.34655;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_custom_attrs_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoArray * D.34658;
  struct MonoError error;

  try
    {
      D.34658 = mono_custom_attrs_construct_by_type (cinfo, 0B, &error);
      return D.34658;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_custom_attrs_construct_by_type (struct MonoCustomAttrInfo * cinfo, struct MonoClass * attr_klass, struct MonoError * error)
{
  struct MonoMethod * D.34664;
  struct MonoClass * D.34665;
  int D.34666;
  int D.34667;
  unsigned int n.531;
  struct MonoClass * D.21771;
  struct MonoClass * tmp_klass.532;
  struct MonoClass * D.34672;
  struct MonoClass * tmp_klass.533;
  _Bool D.34674;
  long int D.34675;
  long int D.34676;
  struct MonoDomain * D.34679;
  struct MonoVTable * D.34680;
  struct MonoException * D.34683;
  int D.34687;
  unsigned int D.34688;
  const mono_byte * D.34689;
  struct MonoImage * D.34690;
  int D.34691;
  struct MonoArray * D.34694;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;
  int n;

  mono_error_init (error);
  n = 0;
  i = 0;
  goto <D.21768>;
  <D.21767>:
  if (attr_klass == 0B) goto <D.34661>; else goto <D.34663>;
  <D.34663>:
  D.34664 = cinfo->attrs[i].ctor;
  D.34665 = D.34664->klass;
  D.34666 = mono_class_is_assignable_from (attr_klass, D.34665);
  if (D.34666 != 0) goto <D.34661>; else goto <D.34662>;
  <D.34661>:
  n = n + 1;
  <D.34662>:
  i = i + 1;
  <D.21768>:
  D.34667 = cinfo->num_attrs;
  if (D.34667 > i) goto <D.21767>; else goto <D.21769>;
  <D.21769>:
  n.531 = (unsigned int) n;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.532 = tmp_klass;
      if (tmp_klass.532 == 0B) goto <D.34670>; else goto <D.34671>;
      <D.34670>:
      D.34672 = mono_defaults.attribute_class;
      tmp_klass.533 = mono_array_class_get (D.34672, 1);
      tmp_klass = tmp_klass.533;
      tmp_klass.532 = tmp_klass;
      D.34674 = tmp_klass.532 == 0B;
      D.34675 = (long int) D.34674;
      D.34676 = __builtin_expect (D.34675, 0);
      if (D.34676 != 0) goto <D.34677>; else goto <D.34678>;
      <D.34677>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8491, "tmp_klass");
      <D.34678>:
      <D.34671>:
    }
    D.21771 = tmp_klass;
  }
  D.34679 = mono_domain_get ();
  D.34680 = mono_class_vtable (D.34679, D.21771);
  result = mono_array_new_specific (D.34680, n.531);
  n = 0;
  i = 0;
  goto <D.21774>;
  <D.21773>:
  D.34664 = cinfo->attrs[i].ctor;
  if (D.34664 == 0B) goto <D.34681>; else goto <D.34682>;
  <D.34681>:
  D.34683 = mono_get_exception_type_load (0B, 0B);
  mono_raise_exception (D.34683);
  <D.34682>:
  if (attr_klass == 0B) goto <D.34684>; else goto <D.34686>;
  <D.34686>:
  D.34664 = cinfo->attrs[i].ctor;
  D.34665 = D.34664->klass;
  D.34687 = mono_class_is_assignable_from (attr_klass, D.34665);
  if (D.34687 != 0) goto <D.34684>; else goto <D.34685>;
  <D.34684>:
  D.34688 = cinfo->attrs[i].data_size;
  D.34689 = cinfo->attrs[i].data;
  D.34664 = cinfo->attrs[i].ctor;
  D.34690 = cinfo->image;
  attr = create_custom_attr (D.34690, D.34664, D.34689, D.34688, error);
  D.34691 = mono_error_ok (error);
  if (D.34691 == 0) goto <D.34692>; else goto <D.34693>;
  <D.34692>:
  D.34694 = result;
  return D.34694;
  <D.34693>:
  {
    void * * __p;

    n.531 = (unsigned int) n;
    __p = mono_array_addr_with_size (result, 4, n.531);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  n = n + 1;
  <D.34685>:
  i = i + 1;
  <D.21774>:
  D.34667 = cinfo->num_attrs;
  if (D.34667 > i) goto <D.21773>; else goto <D.21775>;
  <D.21775>:
  D.34694 = result;
  return D.34694;
}


create_custom_attr (struct MonoImage * image, struct MonoMethod * method, const guchar * data, guint32 len, struct MonoError * error)
{
  struct MonoClass * D.34696;
  int D.34697;
  struct MonoObject * D.34700;
  struct MonoDomain * D.34703;
  const char * p.534;
  short unsigned int D.34708;
  short unsigned int D.34709;
  unsigned int D.34713;
  unsigned int D.34714;
  const char * p.535;
  unsigned int D.34716;
  void * * D.34717;
  struct MonoMethodSignature * D.34718;
  struct MonoType * D.34719;
  void * D.34720;
  struct MonoMethodSignature * D.34721;
  short unsigned int D.34722;
  unsigned int D.34723;
  struct MonoDomain * D.34724;
  struct MonoMethodSignature * D.34725;
  const char * named.536;
  short unsigned int D.34727;
  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.34739;
  int D.34740;
  unsigned int D.34741;
  unsigned int type_len.544;
  sizetype type_len.545;
  char * D.34744;
  const char * named.546;
  unsigned int D.34746;
  int D.34747;
  unsigned int D.34748;
  unsigned int name_len.547;
  sizetype name_len.548;
  char * D.34751;
  const char * named.549;
  struct MonoVTable * D.34755;
  struct MonoClass * D.34756;
  struct MonoType * D.34757;
  int D.34758;
  struct MonoType * iftmp.550;
  struct MonoMethod * D.34765;
  struct MonoMethodSignature * D.34768;
  struct MonoMethod * D.34770;
  struct MonoMethodSignature * D.34771;
  struct MonoMethodSignature * D.34772;
  short unsigned int D.34773;
  int D.34774;
  int D.34775;
  void * D.34776;
  int D.34777;
  void * D.34780;
  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.34696 = method->klass;
      mono_class_init (D.34696);
      D.34697 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.34697 == 0) goto <D.34698>; else goto <D.34699>;
      <D.34698>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      D.34700 = 0B;
      return D.34700;
      <D.34699>:
      if (len == 0) goto <D.34701>; else goto <D.34702>;
      <D.34701>:
      D.34696 = method->klass;
      D.34703 = mono_domain_get ();
      attr = mono_object_new (D.34703, D.34696);
      mono_runtime_invoke (method, attr, 0B, 0B);
      D.34700 = attr;
      return D.34700;
      <D.34702>:
      if (len <= 1) goto <D.34704>; else goto <D.34706>;
      <D.34706>:
      p.534 = p;
      D.34708 = MEM[(const guint16 *)p.534];
      if (D.34708 != 1) goto <D.34704>; else goto <D.34705>;
      <D.34704>:
      D.34700 = 0B;
      return D.34700;
      <D.34705>:
      sig = mono_method_signature (method);
      D.34709 = sig->param_count;
      if (D.34709 <= 31) goto <D.34710>; else goto <D.34711>;
      <D.34710>:
      params = &params_buf;
      goto <D.34712>;
      <D.34711>:
      D.34709 = sig->param_count;
      D.34713 = (unsigned int) D.34709;
      D.34714 = D.34713 * 4;
      params = mono_gc_alloc_fixed (D.34714, 0B);
      <D.34712>:
      p.534 = p;
      p.535 = p.534 + 2;
      p = p.535;
      i = 0;
      goto <D.21659>;
      <D.21658>:
      D.34716 = i * 4;
      D.34717 = params + D.34716;
      p.534 = p;
      D.34718 = mono_method_signature (method);
      D.34719 = D.34718->params[i];
      D.34720 = load_cattr_value (image, D.34719, p.534, &p);
      *D.34717 = D.34720;
      i = i + 1;
      <D.21659>:
      D.34721 = mono_method_signature (method);
      D.34722 = D.34721->param_count;
      D.34723 = (unsigned int) D.34722;
      if (D.34723 > i) goto <D.21658>; else goto <D.21660>;
      <D.21660>:
      p.534 = p;
      named = p.534;
      D.34696 = method->klass;
      D.34724 = mono_domain_get ();
      attr = mono_object_new (D.34724, D.34696);
      mono_runtime_invoke (method, attr, params, 0B);
      D.34725 = method->signature;
      free_param_data (D.34725, params);
      named.536 = named;
      D.34727 = MEM[(const guint16 *)named.536];
      num_named = (guint32) D.34727;
      named.536 = named;
      named.537 = named.536 + 2;
      named = named.537;
      j = 0;
      goto <D.21673>;
      <D.21672>:
      {
        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.34733>; else goto <D.34734>;
        <D.34733>:
        named.536 = named;
        named.542 = named.536;
        named.543 = named.542 + 1;
        named = named.543;
        data_type = *named.542;
        <D.34734>:
        if (data_type == 85) goto <D.34737>; else goto <D.34738>;
        <D.34737>:
        {
          gint type_len;
          char * type_name;

          named.536 = named;
          D.34739 = mono_metadata_decode_blob_size (named.536, &named);
          type_len = (gint) D.34739;
          D.34740 = type_len + 1;
          D.34741 = (unsigned int) D.34740;
          type_name = monoeg_malloc (D.34741);
          type_len.544 = (unsigned int) type_len;
          named.536 = named;
          memcpy (type_name, named.536, type_len.544);
          type_len.545 = (sizetype) type_len;
          D.34744 = type_name + type_len.545;
          *D.34744 = 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.34738>:
        named.536 = named;
        D.34746 = mono_metadata_decode_blob_size (named.536, &named);
        name_len = (gint) D.34746;
        D.34747 = name_len + 1;
        D.34748 = (unsigned int) D.34747;
        name = monoeg_malloc (D.34748);
        name_len.547 = (unsigned int) name_len;
        named.536 = named;
        memcpy (name, named.536, name_len.547);
        name_len.548 = (sizetype) name_len;
        D.34751 = name + name_len.548;
        *D.34751 = 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.34753>; else goto <D.34754>;
        <D.34753>:
        {
          struct MonoClassField * field;
          void * val;

          D.34755 = attr->vtable;
          D.34756 = D.34755->klass;
          field = mono_class_get_field_from_name (D.34756, name);
          named.536 = named;
          D.34757 = field->type;
          val = load_cattr_value (image, D.34757, named.536, &named);
          mono_field_set_value (attr, field, val);
          D.34757 = field->type;
          D.34758 = type_is_reference (D.34757);
          if (D.34758 == 0) goto <D.34759>; else goto <D.34760>;
          <D.34759>:
          monoeg_g_free (val);
          <D.34760>:
        }
        goto <D.34761>;
        <D.34754>:
        if (named_type == 84) goto <D.34762>; else goto <D.34763>;
        <D.34762>:
        {
          struct MonoProperty * prop;
          void * pparams[1];
          struct MonoType * prop_type;

          try
            {
              D.34755 = attr->vtable;
              D.34756 = D.34755->klass;
              prop = mono_class_get_property_from_name (D.34756, name);
              D.34765 = prop->get;
              if (D.34765 != 0B) goto <D.34766>; else goto <D.34767>;
              <D.34766>:
              D.34765 = prop->get;
              D.34768 = mono_method_signature (D.34765);
              iftmp.550 = D.34768->ret;
              goto <D.34769>;
              <D.34767>:
              D.34770 = prop->set;
              D.34771 = mono_method_signature (D.34770);
              D.34770 = prop->set;
              D.34772 = mono_method_signature (D.34770);
              D.34773 = D.34772->param_count;
              D.34774 = (int) D.34773;
              D.34775 = D.34774 + -1;
              iftmp.550 = D.34771->params[D.34775];
              <D.34769>:
              prop_type = iftmp.550;
              named.536 = named;
              D.34776 = load_cattr_value (image, prop_type, named.536, &named);
              pparams[0] = D.34776;
              mono_property_set_value (prop, attr, &pparams, 0B);
              D.34777 = type_is_reference (prop_type);
              if (D.34777 == 0) goto <D.34778>; else goto <D.34779>;
              <D.34778>:
              D.34780 = pparams[0];
              monoeg_g_free (D.34780);
              <D.34779>:
            }
          finally
            {
              pparams = {CLOBBER};
            }
        }
        <D.34763>:
        <D.34761>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.21673>:
      if (j < num_named) goto <D.21672>; else goto <D.21674>;
      <D.21674>:
      if (&params_buf != params) goto <D.34781>; else goto <D.34782>;
      <D.34781>:
      mono_gc_free_fixed (params);
      <D.34782>:
      D.34700 = attr;
      return D.34700;
    }
  finally
    {
      p = {CLOBBER};
      named = {CLOBBER};
      params_buf = {CLOBBER};
    }
}


free_param_data (struct MonoMethodSignature * sig, void * * params)
{
  struct MonoType * D.34785;
  int D.34786;
  unsigned int i.551;
  unsigned int D.34790;
  void * * D.34791;
  void * D.34792;
  short unsigned int D.34793;
  int D.34794;
  int i;

  i = 0;
  goto <D.21616>;
  <D.21615>:
  D.34785 = sig->params[i];
  D.34786 = type_is_reference (D.34785);
  if (D.34786 == 0) goto <D.34787>; else goto <D.34788>;
  <D.34787>:
  i.551 = (unsigned int) i;
  D.34790 = i.551 * 4;
  D.34791 = params + D.34790;
  D.34792 = *D.34791;
  monoeg_g_free (D.34792);
  <D.34788>:
  i = i + 1;
  <D.21616>:
  D.34793 = sig->param_count;
  D.34794 = (int) D.34793;
  if (D.34794 > i) goto <D.21615>; else goto <D.21617>;
  <D.21617>:
}


mono_custom_attrs_from_index (struct MonoImage * image, guint32 idx)
{
  struct MonoCustomAttrInfo * D.34797;
  int i.552;
  unsigned int D.34799;
  void * i.553;
  <unnamed-unsigned:24> D.34802;
  unsigned int D.34803;
  unsigned int D.34806;
  unsigned int D.34807;
  int len.554;
  void * D.34809;
  int D.34810;
  unsigned int D.34811;
  unsigned int D.34812;
  struct MonoMethod * D.34813;
  struct MonoMethod * D.34814;
  char * D.34817;
  unsigned int D.34818;
  int D.34819;
  const char * data.555;
  const char * data.556;
  unsigned int D.34824;
  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.34795>; else goto <D.34796>;
      <D.34795>:
      D.34797 = 0B;
      return D.34797;
      <D.34796>:
      i = i + 4294967295;
      goto <D.21805>;
      <D.21804>:
      i.552 = (int) i;
      D.34799 = mono_metadata_decode_row_col (ca, i.552, 0);
      if (D.34799 != idx) goto <D.21803>; else goto <D.34800>;
      <D.34800>:
      i.553 = (void *) i;
      list = monoeg_g_list_prepend (list, i.553);
      i = i + 1;
      <D.21805>:
      D.34802 = ca->rows;
      D.34803 = (unsigned int) D.34802;
      if (D.34803 > i) goto <D.21804>; else goto <D.21803>;
      <D.21803>:
      len = monoeg_g_list_length (list);
      if (len == 0) goto <D.34804>; else goto <D.34805>;
      <D.34804>:
      D.34797 = 0B;
      return D.34797;
      <D.34805>:
      D.34806 = len + 1;
      D.34807 = D.34806 * 12;
      ainfo = monoeg_malloc0 (D.34807);
      len.554 = (int) len;
      ainfo->num_attrs = len.554;
      ainfo->image = image;
      i = 0;
      tmp = list;
      goto <D.21812>;
      <D.21811>:
      D.34809 = tmp->data;
      D.34810 = (int) D.34809;
      mono_metadata_decode_row (ca, D.34810, &cols, 3);
      D.34811 = cols[1];
      mtoken = D.34811 >> 3;
      D.34811 = cols[1];
      D.34812 = D.34811 & 7;
      switch (D.34812) <default: <D.21809>, case 2: <D.21806>, case 3: <D.21808>>
      <D.21806>:
      mtoken = mtoken | 100663296;
      goto <D.21807>;
      <D.21808>:
      mtoken = mtoken | 167772160;
      goto <D.21807>;
      <D.21809>:
      D.34811 = cols[1];
      monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.34811);
      <D.21810>:
      goto <D.21810>;
      <D.21807>:
      D.34813 = mono_get_method (image, mtoken, 0B);
      ainfo->attrs[i].ctor = D.34813;
      D.34814 = ainfo->attrs[i].ctor;
      if (D.34814 == 0B) goto <D.34815>; else goto <D.34816>;
      <D.34815>:
      D.34817 = image->name;
      monoeg_g_log (0B, 16, "Can\'t find custom attr constructor image: %s mtoken: 0x%08x", D.34817, mtoken);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.34797 = 0B;
      return D.34797;
      <D.34816>:
      D.34818 = cols[2];
      D.34819 = mono_verifier_verify_cattr_blob (image, D.34818, 0B);
      if (D.34819 == 0) goto <D.34820>; else goto <D.34821>;
      <D.34820>:
      D.34817 = image->name;
      monoeg_g_log (0B, 16, "Invalid custom attribute blob on image %s for index %x", D.34817, idx);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.34797 = 0B;
      return D.34797;
      <D.34821>:
      D.34818 = cols[2];
      data.555 = mono_metadata_blob_heap (image, D.34818);
      data = data.555;
      data.556 = data;
      D.34824 = mono_metadata_decode_value (data.556, &data);
      ainfo->attrs[i].data_size = D.34824;
      data.556 = data;
      ainfo->attrs[i].data = data.556;
      i = i + 1;
      tmp = tmp->next;
      <D.21812>:
      if (i < len) goto <D.21811>; else goto <D.21813>;
      <D.21813>:
      monoeg_g_list_free (list);
      D.34797 = ainfo;
      return D.34797;
    }
  finally
    {
      cols = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_custom_attrs_from_method (struct MonoMethod * method)
{
  unsigned char D.34827;
  unsigned char D.34828;
  unsigned char D.34833;
  struct MonoClass * D.34835;
  struct MonoImage * D.34836;
  unsigned char D.34837;
  unsigned char D.34838;
  struct MonoCustomAttrInfo * D.34839;
  unsigned int D.34840;
  guint32 idx;

  D.34827 = BIT_FIELD_REF <*method, 8, 168>;
  D.34828 = D.34827 & 16;
  if (D.34828 != 0) goto <D.34829>; else goto <D.34830>;
  <D.34829>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.34830>:
  D.34827 = BIT_FIELD_REF <*method, 8, 168>;
  D.34833 = D.34827 & 2;
  if (D.34833 != 0) goto <D.34831>; else goto <D.34834>;
  <D.34834>:
  D.34835 = method->klass;
  D.34836 = D.34835->image;
  D.34837 = BIT_FIELD_REF <*D.34836, 8, 128>;
  D.34838 = D.34837 & 8;
  if (D.34838 != 0) goto <D.34831>; else goto <D.34832>;
  <D.34831>:
  D.34835 = method->klass;
  D.34836 = D.34835->image;
  D.34839 = lookup_custom_attr (D.34836, method);
  return D.34839;
  <D.34832>:
  D.34840 = method->token;
  if (D.34840 == 0) goto <D.34841>; else goto <D.34842>;
  <D.34841>:
  D.34839 = 0B;
  return D.34839;
  <D.34842>:
  idx = mono_method_get_index (method);
  idx = idx << 5;
  idx = idx;
  D.34835 = method->klass;
  D.34836 = D.34835->image;
  D.34839 = mono_custom_attrs_from_index (D.34836, idx);
  return D.34839;
}


lookup_custom_attr (struct MonoImage * image, void * member)
{
  struct MonoCustomAttrInfo * D.34846;
  int D.34847;
  unsigned int D.34848;
  unsigned int D.34849;
  unsigned int D.34850;
  struct MonoCustomAttrInfo * res;

  res = mono_image_property_lookup (image, member, 4096);
  if (res == 0B) goto <D.34844>; else goto <D.34845>;
  <D.34844>:
  D.34846 = 0B;
  return D.34846;
  <D.34845>:
  D.34847 = res->num_attrs;
  D.34848 = (unsigned int) D.34847;
  D.34849 = D.34848 + 1;
  D.34850 = D.34849 * 12;
  res = monoeg_g_memdup (res, D.34850);
  res->cached = 0;
  D.34846 = res;
  return D.34846;
}


mono_custom_attrs_from_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.34852;
  struct MonoImage * D.34855;
  unsigned char D.34856;
  unsigned char D.34857;
  struct MonoCustomAttrInfo * D.34860;
  unsigned char D.34861;
  _Bool D.34862;
  _Bool D.34863;
  _Bool D.34864;
  int D.34867;
  unsigned int D.34868;
  unsigned int D.34870;
  guint32 idx;

  D.34852 = klass->generic_class;
  if (D.34852 != 0B) goto <D.34853>; else goto <D.34854>;
  <D.34853>:
  D.34852 = klass->generic_class;
  klass = D.34852->container_class;
  <D.34854>:
  D.34855 = klass->image;
  D.34856 = BIT_FIELD_REF <*D.34855, 8, 128>;
  D.34857 = D.34856 & 8;
  if (D.34857 != 0) goto <D.34858>; else goto <D.34859>;
  <D.34858>:
  D.34855 = klass->image;
  D.34860 = lookup_custom_attr (D.34855, klass);
  return D.34860;
  <D.34859>:
  D.34861 = klass->byval_arg.type;
  D.34862 = D.34861 == 19;
  D.34863 = D.34861 == 30;
  D.34864 = D.34862 | D.34863;
  if (D.34864 != 0) goto <D.34865>; else goto <D.34866>;
  <D.34865>:
  D.34867 = klass->sizes.generic_param_token;
  D.34868 = (unsigned int) D.34867;
  idx = D.34868 & 16777215;
  idx = idx << 5;
  idx = idx | 19;
  goto <D.34869>;
  <D.34866>:
  D.34870 = klass->type_token;
  idx = D.34870 & 16777215;
  idx = idx << 5;
  idx = idx | 3;
  <D.34869>:
  D.34855 = klass->image;
  D.34860 = mono_custom_attrs_from_index (D.34855, idx);
  return D.34860;
}


mono_custom_attrs_from_assembly (struct MonoAssembly * assembly)
{
  struct MonoImage * D.34872;
  unsigned char D.34873;
  unsigned char D.34874;
  struct MonoCustomAttrInfo * D.34877;
  guint32 idx;

  D.34872 = assembly->image;
  D.34873 = BIT_FIELD_REF <*D.34872, 8, 128>;
  D.34874 = D.34873 & 8;
  if (D.34874 != 0) goto <D.34875>; else goto <D.34876>;
  <D.34875>:
  D.34872 = assembly->image;
  D.34877 = lookup_custom_attr (D.34872, assembly);
  return D.34877;
  <D.34876>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 14;
  D.34872 = assembly->image;
  D.34877 = mono_custom_attrs_from_index (D.34872, idx);
  return D.34877;
}


mono_custom_attrs_from_property (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoImage * D.34879;
  unsigned char D.34880;
  unsigned char D.34881;
  struct MonoCustomAttrInfo * D.34884;
  guint32 idx;

  D.34879 = klass->image;
  D.34880 = BIT_FIELD_REF <*D.34879, 8, 128>;
  D.34881 = D.34880 & 8;
  if (D.34881 != 0) goto <D.34882>; else goto <D.34883>;
  <D.34882>:
  property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
  D.34879 = klass->image;
  D.34884 = lookup_custom_attr (D.34879, property);
  return D.34884;
  <D.34883>:
  idx = find_property_index (klass, property);
  idx = idx << 5;
  idx = idx | 9;
  D.34879 = klass->image;
  D.34884 = mono_custom_attrs_from_index (D.34879, idx);
  return D.34884;
}


find_property_index (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoClassExt * D.34886;
  struct MonoProperty * D.34887;
  unsigned int i.557;
  unsigned int D.34889;
  struct MonoProperty * D.34890;
  guint32 D.34893;
  unsigned int D.34894;
  unsigned int i.558;
  unsigned int D.34896;
  unsigned int D.34897;
  int i;

  i = 0;
  goto <D.21632>;
  <D.21631>:
  D.34886 = klass->ext;
  D.34887 = D.34886->properties;
  i.557 = (unsigned int) i;
  D.34889 = i.557 * 20;
  D.34890 = D.34887 + D.34889;
  if (D.34890 == property) goto <D.34891>; else goto <D.34892>;
  <D.34891>:
  D.34886 = klass->ext;
  D.34894 = D.34886->property.first;
  i.558 = (unsigned int) i;
  D.34896 = D.34894 + i.558;
  D.34893 = D.34896 + 1;
  return D.34893;
  <D.34892>:
  i = i + 1;
  <D.21632>:
  i.558 = (unsigned int) i;
  D.34886 = klass->ext;
  D.34897 = D.34886->property.count;
  if (i.558 < D.34897) goto <D.21631>; else goto <D.21633>;
  <D.21633>:
  D.34893 = 0;
  return D.34893;
}


mono_custom_attrs_from_event (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoImage * D.34899;
  unsigned char D.34900;
  unsigned char D.34901;
  struct MonoCustomAttrInfo * D.34904;
  guint32 idx;

  D.34899 = klass->image;
  D.34900 = BIT_FIELD_REF <*D.34899, 8, 128>;
  D.34901 = D.34900 & 8;
  if (D.34901 != 0) goto <D.34902>; else goto <D.34903>;
  <D.34902>:
  event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
  D.34899 = klass->image;
  D.34904 = lookup_custom_attr (D.34899, event);
  return D.34904;
  <D.34903>:
  idx = find_event_index (klass, event);
  idx = idx << 5;
  idx = idx | 10;
  D.34899 = klass->image;
  D.34904 = mono_custom_attrs_from_index (D.34899, idx);
  return D.34904;
}


find_event_index (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoClassExt * D.34906;
  struct MonoEvent * D.34907;
  unsigned int i.559;
  unsigned int D.34909;
  struct MonoEvent * D.34910;
  guint32 D.34913;
  unsigned int D.34914;
  unsigned int i.560;
  unsigned int D.34916;
  unsigned int D.34917;
  int i;

  i = 0;
  goto <D.21640>;
  <D.21639>:
  D.34906 = klass->ext;
  D.34907 = D.34906->events;
  i.559 = (unsigned int) i;
  D.34909 = i.559 * 28;
  D.34910 = D.34907 + D.34909;
  if (D.34910 == event) goto <D.34911>; else goto <D.34912>;
  <D.34911>:
  D.34906 = klass->ext;
  D.34914 = D.34906->event.first;
  i.560 = (unsigned int) i;
  D.34916 = D.34914 + i.560;
  D.34913 = D.34916 + 1;
  return D.34913;
  <D.34912>:
  i = i + 1;
  <D.21640>:
  i.560 = (unsigned int) i;
  D.34906 = klass->ext;
  D.34917 = D.34906->event.count;
  if (i.560 < D.34917) goto <D.21639>; else goto <D.21641>;
  <D.21641>:
  D.34913 = 0;
  return D.34913;
}


mono_custom_attrs_from_field (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoImage * D.34919;
  unsigned char D.34920;
  unsigned char D.34921;
  struct MonoCustomAttrInfo * D.34924;
  guint32 idx;

  D.34919 = klass->image;
  D.34920 = BIT_FIELD_REF <*D.34919, 8, 128>;
  D.34921 = D.34920 & 8;
  if (D.34921 != 0) goto <D.34922>; else goto <D.34923>;
  <D.34922>:
  field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
  D.34919 = klass->image;
  D.34924 = lookup_custom_attr (D.34919, field);
  return D.34924;
  <D.34923>:
  idx = find_field_index (klass, field);
  idx = idx << 5;
  idx = idx | 1;
  D.34919 = klass->image;
  D.34924 = mono_custom_attrs_from_index (D.34919, idx);
  return D.34924;
}


find_field_index (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoClassField * D.34926;
  unsigned int i.561;
  unsigned int D.34928;
  struct MonoClassField * D.34929;
  guint32 D.34932;
  unsigned int D.34933;
  unsigned int i.562;
  unsigned int D.34935;
  unsigned int D.34936;
  int i;

  i = 0;
  goto <D.21624>;
  <D.21623>:
  D.34926 = klass->fields;
  i.561 = (unsigned int) i;
  D.34928 = i.561 * 16;
  D.34929 = D.34926 + D.34928;
  if (D.34929 == field) goto <D.34930>; else goto <D.34931>;
  <D.34930>:
  D.34933 = klass->field.first;
  i.562 = (unsigned int) i;
  D.34935 = D.34933 + i.562;
  D.34932 = D.34935 + 1;
  return D.34932;
  <D.34931>:
  i = i + 1;
  <D.21624>:
  i.562 = (unsigned int) i;
  D.34936 = klass->field.count;
  if (i.562 < D.34936) goto <D.21623>; else goto <D.21625>;
  <D.21625>:
  D.34932 = 0;
  return D.34932;
}


mono_custom_attrs_from_param (struct MonoMethod * method, guint32 param)
{
  unsigned char D.34938;
  unsigned char D.34939;
  struct MonoClass * D.34942;
  struct MonoImage * D.34943;
  unsigned char D.34944;
  unsigned char D.34945;
  struct GHashTable * D.34948;
  struct MonoCustomAttrInfo * * D.34952;
  struct MonoCustomAttrInfo * D.34953;
  unsigned int D.34954;
  struct MonoCustomAttrInfo * * D.34955;
  int D.34958;
  unsigned int D.34959;
  unsigned int D.34960;
  unsigned int D.34961;
  unsigned int size.563;
  unsigned int size.564;
  unsigned int D.34966;
  int D.34967;
  <unnamed-unsigned:24> D.34968;
  unsigned int D.34969;
  int D.34972;
  int D.34973;
  int method_index.565;
  unsigned int D.34976;
  int D.34977;
  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.34938 = BIT_FIELD_REF <*method, 8, 168>;
  D.34939 = D.34938 & 16;
  if (D.34939 != 0) goto <D.34940>; else goto <D.34941>;
  <D.34940>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.34941>:
  D.34942 = method->klass;
  D.34943 = D.34942->image;
  D.34944 = BIT_FIELD_REF <*D.34943, 8, 128>;
  D.34945 = D.34944 & 8;
  if (D.34945 != 0) goto <D.34946>; else goto <D.34947>;
  <D.34946>:
  {
    struct MonoCustomAttrInfo * res;
    struct MonoCustomAttrInfo * ainfo;
    int size;

    D.34942 = method->klass;
    D.34943 = D.34942->image;
    D.34948 = MEM[(struct MonoDynamicImage *)D.34943].method_aux_hash;
    aux = monoeg_g_hash_table_lookup (D.34948, method);
    if (aux == 0B) goto <D.34949>; else goto <D.34951>;
    <D.34951>:
    D.34952 = aux->param_cattr;
    if (D.34952 == 0B) goto <D.34949>; else goto <D.34950>;
    <D.34949>:
    D.34953 = 0B;
    return D.34953;
    <D.34950>:
    D.34952 = aux->param_cattr;
    D.34954 = param * 4;
    D.34955 = D.34952 + D.34954;
    ainfo = *D.34955;
    if (ainfo == 0B) goto <D.34956>; else goto <D.34957>;
    <D.34956>:
    D.34953 = 0B;
    return D.34953;
    <D.34957>:
    D.34958 = ainfo->num_attrs;
    D.34959 = (unsigned int) D.34958;
    D.34960 = D.34959 + 1;
    D.34961 = D.34960 * 12;
    size = (int) D.34961;
    size.563 = (unsigned int) size;
    res = monoeg_malloc0 (size.563);
    size.564 = (unsigned int) size;
    memcpy (res, ainfo, size.564);
    D.34953 = res;
    return D.34953;
  }
  <D.34947>:
  D.34942 = method->klass;
  image = D.34942->image;
  method_index = mono_method_get_index (method);
  if (method_index == 0) goto <D.34964>; else goto <D.34965>;
  <D.34964>:
  D.34953 = 0B;
  return D.34953;
  <D.34965>:
  ca = &image->tables[6];
  D.34966 = method_index + 4294967295;
  D.34967 = (int) D.34966;
  param_list = mono_metadata_decode_row_col (ca, D.34967, 5);
  D.34968 = ca->rows;
  D.34969 = (unsigned int) D.34968;
  if (D.34969 == method_index) goto <D.34970>; else goto <D.34971>;
  <D.34970>:
  ca = &image->tables[8];
  D.34968 = ca->rows;
  D.34972 = (int) D.34968;
  D.34973 = D.34972 + 1;
  param_last = (guint32) D.34973;
  goto <D.34974>;
  <D.34971>:
  method_index.565 = (int) method_index;
  param_last = mono_metadata_decode_row_col (ca, method_index.565, 5);
  ca = &image->tables[8];
  <D.34974>:
  found = 0;
  i = param_list;
  goto <D.21864>;
  <D.21863>:
  D.34976 = i + 4294967295;
  D.34977 = (int) D.34976;
  param_pos = mono_metadata_decode_row_col (ca, D.34977, 1);
  if (param_pos == param) goto <D.34978>; else goto <D.34979>;
  <D.34978>:
  found = 1;
  goto <D.21862>;
  <D.34979>:
  i = i + 1;
  <D.21864>:
  if (i < param_last) goto <D.21863>; else goto <D.21862>;
  <D.21862>:
  if (found == 0) goto <D.34980>; else goto <D.34981>;
  <D.34980>:
  D.34953 = 0B;
  return D.34953;
  <D.34981>:
  idx = i;
  idx = idx << 5;
  idx = idx | 4;
  D.34953 = mono_custom_attrs_from_index (image, idx);
  return D.34953;
}


mono_custom_attrs_has_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.34983;
  int D.34987;
  unsigned int D.34989;
  unsigned int D.34990;
  unsigned char D.34992;
  int D.34994;
  mono_bool D.34995;
  int D.34996;
  int i;
  struct MonoClass * klass;

  i = 0;
  goto <D.21872>;
  <D.21871>:
  D.34983 = ainfo->attrs[i].ctor;
  klass = D.34983->klass;
  D.34987 = mono_class_has_parent (klass, attr_klass);
  if (D.34987 != 0) goto <D.34984>; else goto <D.34988>;
  <D.34988>:
  D.34989 = attr_klass->flags;
  D.34990 = D.34989 & 32;
  if (D.34990 != 0) goto <D.34985>; else goto <D.34991>;
  <D.34991>:
  D.34992 = attr_klass->byval_arg.type;
  if (D.34992 == 19) goto <D.34985>; else goto <D.34993>;
  <D.34993>:
  D.34992 = attr_klass->byval_arg.type;
  if (D.34992 == 30) goto <D.34985>; else goto <D.34986>;
  <D.34985>:
  D.34994 = mono_class_is_assignable_from (attr_klass, klass);
  if (D.34994 != 0) goto <D.34984>; else goto <D.34986>;
  <D.34984>:
  D.34995 = 1;
  return D.34995;
  <D.34986>:
  i = i + 1;
  <D.21872>:
  D.34996 = ainfo->num_attrs;
  if (D.34996 > i) goto <D.21871>; else goto <D.21873>;
  <D.21873>:
  D.34995 = 0;
  return D.34995;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.34998;
  _Bool D.34999;
  long int D.35000;
  long int D.35001;
  struct MonoClass * * D.35004;
  _Bool D.35005;
  long int D.35006;
  long int D.35007;
  gboolean D.35010;

  D.34998 = klass->supertypes;
  D.34999 = D.34998 == 0B;
  D.35000 = (long int) D.34999;
  D.35001 = __builtin_expect (D.35000, 0);
  if (D.35001 != 0) goto <D.35002>; else goto <D.35003>;
  <D.35002>:
  mono_class_setup_supertypes (klass);
  <D.35003>:
  D.35004 = parent->supertypes;
  D.35005 = D.35004 == 0B;
  D.35006 = (long int) D.35005;
  D.35007 = __builtin_expect (D.35006, 0);
  if (D.35007 != 0) goto <D.35008>; else goto <D.35009>;
  <D.35008>:
  mono_class_setup_supertypes (parent);
  <D.35009>:
  D.35010 = mono_class_has_parent_fast (klass, parent);
  return D.35010;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.35012;
  int iftmp.566;
  short unsigned int D.35016;
  short unsigned int D.35017;
  struct MonoClass * * D.35019;
  sizetype D.35020;
  sizetype D.35021;
  sizetype D.35022;
  struct MonoClass * * D.35023;
  struct MonoClass * D.35024;

  D.35016 = klass->idepth;
  D.35017 = parent->idepth;
  if (D.35016 >= D.35017) goto <D.35018>; else goto <D.35014>;
  <D.35018>:
  D.35019 = klass->supertypes;
  D.35017 = parent->idepth;
  D.35020 = (sizetype) D.35017;
  D.35021 = D.35020 + 1073741823;
  D.35022 = D.35021 * 4;
  D.35023 = D.35019 + D.35022;
  D.35024 = *D.35023;
  if (D.35024 == parent) goto <D.35025>; else goto <D.35014>;
  <D.35025>:
  iftmp.566 = 1;
  goto <D.35015>;
  <D.35014>:
  iftmp.566 = 0;
  <D.35015>:
  D.35012 = iftmp.566;
  return D.35012;
}


mono_custom_attrs_get_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.35027;
  int D.35028;
  int D.35031;
  struct MonoObject * D.35034;
  unsigned int attr_index.567;
  char * D.35038;
  int i;
  int attr_index;
  struct MonoClass * klass;
  struct MonoArray * attrs;

  attr_index = -1;
  i = 0;
  goto <D.21884>;
  <D.21883>:
  D.35027 = ainfo->attrs[i].ctor;
  klass = D.35027->klass;
  D.35028 = mono_class_has_parent (klass, attr_klass);
  if (D.35028 != 0) goto <D.35029>; else goto <D.35030>;
  <D.35029>:
  attr_index = i;
  goto <D.21882>;
  <D.35030>:
  i = i + 1;
  <D.21884>:
  D.35031 = ainfo->num_attrs;
  if (D.35031 > i) goto <D.21883>; else goto <D.21882>;
  <D.21882>:
  if (attr_index == -1) goto <D.35032>; else goto <D.35033>;
  <D.35032>:
  D.35034 = 0B;
  return D.35034;
  <D.35033>:
  attrs = mono_custom_attrs_construct (ainfo);
  if (attrs != 0B) goto <D.35035>; else goto <D.35036>;
  <D.35035>:
  attr_index.567 = (unsigned int) attr_index;
  D.35038 = mono_array_addr_with_size (attrs, 4, attr_index.567);
  D.35034 = MEM[(struct MonoObject * *)D.35038];
  return D.35034;
  <D.35036>:
  D.35034 = 0B;
  return D.35034;
}


mono_reflection_get_custom_attrs_info (struct MonoObject * obj)
{
  struct MonoVTable * D.35040;
  struct MonoClass * D.35041;
  int D.21899;
  int iftmp.568;
  int D.21895;
  const char[9] * D.35051;
  unsigned char D.35052;
  int D.35053;
  unsigned char D.35054;
  int D.35055;
  _Bool D.35056;
  _Bool D.35057;
  _Bool D.35058;
  const unsigned char * D.35061;
  unsigned char D.35062;
  int D.35063;
  const unsigned char * D.35064;
  unsigned char D.35065;
  int D.35066;
  _Bool D.35067;
  _Bool D.35068;
  const unsigned char * D.35071;
  unsigned char D.35072;
  int D.35073;
  const unsigned char * D.35074;
  unsigned char D.35075;
  int D.35076;
  _Bool D.35077;
  _Bool D.35078;
  const unsigned char * D.35081;
  unsigned char D.35082;
  int D.35083;
  const unsigned char * D.35084;
  unsigned char D.35085;
  int D.35086;
  const char * D.35088;
  int D.21908;
  int iftmp.569;
  int D.21904;
  const char[13] * D.35093;
  unsigned char D.35094;
  int D.35095;
  unsigned char D.35096;
  int D.35097;
  _Bool D.35098;
  _Bool D.35099;
  _Bool D.35100;
  const unsigned char * D.35103;
  unsigned char D.35104;
  int D.35105;
  const unsigned char * D.35106;
  unsigned char D.35107;
  int D.35108;
  _Bool D.35109;
  _Bool D.35110;
  const unsigned char * D.35113;
  unsigned char D.35114;
  int D.35115;
  const unsigned char * D.35116;
  unsigned char D.35117;
  int D.35118;
  _Bool D.35119;
  _Bool D.35120;
  const unsigned char * D.35123;
  unsigned char D.35124;
  int D.35125;
  const unsigned char * D.35126;
  unsigned char D.35127;
  int D.35128;
  struct MonoAssembly * D.35130;
  int D.21918;
  int iftmp.570;
  int D.21914;
  const char[7] * D.35137;
  unsigned char D.35138;
  int D.35139;
  unsigned char D.35140;
  int D.35141;
  _Bool D.35142;
  _Bool D.35143;
  _Bool D.35144;
  const unsigned char * D.35147;
  unsigned char D.35148;
  int D.35149;
  const unsigned char * D.35150;
  unsigned char D.35151;
  int D.35152;
  _Bool D.35153;
  _Bool D.35154;
  const unsigned char * D.35157;
  unsigned char D.35158;
  int D.35159;
  const unsigned char * D.35160;
  unsigned char D.35161;
  int D.35162;
  _Bool D.35163;
  _Bool D.35164;
  const unsigned char * D.35167;
  unsigned char D.35168;
  int D.35169;
  const unsigned char * D.35170;
  unsigned char D.35171;
  int D.35172;
  int D.21927;
  int iftmp.571;
  int D.21923;
  const char[11] * D.35178;
  unsigned char D.35179;
  int D.35180;
  unsigned char D.35181;
  int D.35182;
  _Bool D.35183;
  _Bool D.35184;
  _Bool D.35185;
  const unsigned char * D.35188;
  unsigned char D.35189;
  int D.35190;
  const unsigned char * D.35191;
  unsigned char D.35192;
  int D.35193;
  _Bool D.35194;
  _Bool D.35195;
  const unsigned char * D.35198;
  unsigned char D.35199;
  int D.35200;
  const unsigned char * D.35201;
  unsigned char D.35202;
  int D.35203;
  _Bool D.35204;
  _Bool D.35205;
  const unsigned char * D.35208;
  unsigned char D.35209;
  int D.35210;
  const unsigned char * D.35211;
  unsigned char D.35212;
  int D.35213;
  struct MonoImage * D.35215;
  int D.21937;
  int iftmp.572;
  int D.21933;
  const char[13] * D.35219;
  unsigned char D.35220;
  int D.35221;
  unsigned char D.35222;
  int D.35223;
  _Bool D.35224;
  _Bool D.35225;
  _Bool D.35226;
  const unsigned char * D.35229;
  unsigned char D.35230;
  int D.35231;
  const unsigned char * D.35232;
  unsigned char D.35233;
  int D.35234;
  _Bool D.35235;
  _Bool D.35236;
  const unsigned char * D.35239;
  unsigned char D.35240;
  int D.35241;
  const unsigned char * D.35242;
  unsigned char D.35243;
  int D.35244;
  _Bool D.35245;
  _Bool D.35246;
  const unsigned char * D.35249;
  unsigned char D.35250;
  int D.35251;
  const unsigned char * D.35252;
  unsigned char D.35253;
  int D.35254;
  struct MonoProperty * D.35258;
  struct MonoClass * D.35259;
  int D.21947;
  int iftmp.573;
  int D.21943;
  const char[10] * D.35264;
  unsigned char D.35265;
  int D.35266;
  unsigned char D.35267;
  int D.35268;
  _Bool D.35269;
  _Bool D.35270;
  _Bool D.35271;
  const unsigned char * D.35274;
  unsigned char D.35275;
  int D.35276;
  const unsigned char * D.35277;
  unsigned char D.35278;
  int D.35279;
  _Bool D.35280;
  _Bool D.35281;
  const unsigned char * D.35284;
  unsigned char D.35285;
  int D.35286;
  const unsigned char * D.35287;
  unsigned char D.35288;
  int D.35289;
  _Bool D.35290;
  _Bool D.35291;
  const unsigned char * D.35294;
  unsigned char D.35295;
  int D.35296;
  const unsigned char * D.35297;
  unsigned char D.35298;
  int D.35299;
  struct MonoEvent * D.35303;
  struct MonoClass * D.35304;
  int D.21957;
  int iftmp.574;
  int D.21953;
  const char[10] * D.35309;
  unsigned char D.35310;
  int D.35311;
  unsigned char D.35312;
  int D.35313;
  _Bool D.35314;
  _Bool D.35315;
  _Bool D.35316;
  const unsigned char * D.35319;
  unsigned char D.35320;
  int D.35321;
  const unsigned char * D.35322;
  unsigned char D.35323;
  int D.35324;
  _Bool D.35325;
  _Bool D.35326;
  const unsigned char * D.35329;
  unsigned char D.35330;
  int D.35331;
  const unsigned char * D.35332;
  unsigned char D.35333;
  int D.35334;
  _Bool D.35335;
  _Bool D.35336;
  const unsigned char * D.35339;
  unsigned char D.35340;
  int D.35341;
  const unsigned char * D.35342;
  unsigned char D.35343;
  int D.35344;
  struct MonoClassField * D.35348;
  struct MonoClass * D.35349;
  int D.21967;
  int iftmp.575;
  int D.21963;
  const char[11] * D.35357;
  unsigned char D.35358;
  int D.35359;
  unsigned char D.35360;
  int D.35361;
  _Bool D.35362;
  _Bool D.35363;
  _Bool D.35364;
  const unsigned char * D.35367;
  unsigned char D.35368;
  int D.35369;
  const unsigned char * D.35370;
  unsigned char D.35371;
  int D.35372;
  _Bool D.35373;
  _Bool D.35374;
  const unsigned char * D.35377;
  unsigned char D.35378;
  int D.35379;
  const unsigned char * D.35380;
  unsigned char D.35381;
  int D.35382;
  _Bool D.35383;
  _Bool D.35384;
  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.21976;
  int iftmp.576;
  int D.21972;
  const char[12] * D.35398;
  unsigned char D.35399;
  int D.35400;
  unsigned char D.35401;
  int D.35402;
  _Bool D.35403;
  _Bool D.35404;
  _Bool D.35405;
  const unsigned char * D.35408;
  unsigned char D.35409;
  int D.35410;
  const unsigned char * D.35411;
  unsigned char D.35412;
  int D.35413;
  _Bool D.35414;
  _Bool D.35415;
  const unsigned char * D.35418;
  unsigned char D.35419;
  int D.35420;
  const unsigned char * D.35421;
  unsigned char D.35422;
  int D.35423;
  _Bool D.35424;
  _Bool D.35425;
  const unsigned char * D.35428;
  unsigned char D.35429;
  int D.35430;
  const unsigned char * D.35431;
  unsigned char D.35432;
  int D.35433;
  struct MonoMethod * D.35435;
  int D.21986;
  int iftmp.577;
  int D.21982;
  const char[18] * D.35442;
  unsigned char D.35443;
  int D.35444;
  unsigned char D.35445;
  int D.35446;
  _Bool D.35447;
  _Bool D.35448;
  _Bool D.35449;
  const unsigned char * D.35452;
  unsigned char D.35453;
  int D.35454;
  const unsigned char * D.35455;
  unsigned char D.35456;
  int D.35457;
  _Bool D.35458;
  _Bool D.35459;
  const unsigned char * D.35462;
  unsigned char D.35463;
  int D.35464;
  const unsigned char * D.35465;
  unsigned char D.35466;
  int D.35467;
  _Bool D.35468;
  _Bool D.35469;
  const unsigned char * D.35472;
  unsigned char D.35473;
  int D.35474;
  const unsigned char * D.35475;
  unsigned char D.35476;
  int D.35477;
  int D.21995;
  int iftmp.578;
  int D.21991;
  const char[19] * D.35483;
  unsigned char D.35484;
  int D.35485;
  unsigned char D.35486;
  int D.35487;
  _Bool D.35488;
  _Bool D.35489;
  _Bool D.35490;
  const unsigned char * D.35493;
  unsigned char D.35494;
  int D.35495;
  const unsigned char * D.35496;
  unsigned char D.35497;
  int D.35498;
  _Bool D.35499;
  _Bool D.35500;
  const unsigned char * D.35503;
  unsigned char D.35504;
  int D.35505;
  const unsigned char * D.35506;
  unsigned char D.35507;
  int D.35508;
  _Bool D.35509;
  _Bool D.35510;
  const unsigned char * D.35513;
  unsigned char D.35514;
  int D.35515;
  const unsigned char * D.35516;
  unsigned char D.35517;
  int D.35518;
  struct MonoMethod * D.35520;
  int D.22005;
  int iftmp.579;
  int D.22001;
  const char[14] * D.35527;
  unsigned char D.35528;
  int D.35529;
  unsigned char D.35530;
  int D.35531;
  _Bool D.35532;
  _Bool D.35533;
  _Bool D.35534;
  const unsigned char * D.35537;
  unsigned char D.35538;
  int D.35539;
  const unsigned char * D.35540;
  unsigned char D.35541;
  int D.35542;
  _Bool D.35543;
  _Bool D.35544;
  const unsigned char * D.35547;
  unsigned char D.35548;
  int D.35549;
  const unsigned char * D.35550;
  unsigned char D.35551;
  int D.35552;
  _Bool D.35553;
  _Bool D.35554;
  const unsigned char * D.35557;
  unsigned char D.35558;
  int D.35559;
  const unsigned char * D.35560;
  unsigned char D.35561;
  int D.35562;
  int D.22014;
  int iftmp.580;
  int D.22010;
  const char[18] * D.35568;
  unsigned char D.35569;
  int D.35570;
  unsigned char D.35571;
  int D.35572;
  _Bool D.35573;
  _Bool D.35574;
  _Bool D.35575;
  const unsigned char * D.35578;
  unsigned char D.35579;
  int D.35580;
  const unsigned char * D.35581;
  unsigned char D.35582;
  int D.35583;
  _Bool D.35584;
  _Bool D.35585;
  const unsigned char * D.35588;
  unsigned char D.35589;
  int D.35590;
  const unsigned char * D.35591;
  unsigned char D.35592;
  int D.35593;
  _Bool D.35594;
  _Bool D.35595;
  const unsigned char * D.35598;
  unsigned char D.35599;
  int D.35600;
  const unsigned char * D.35601;
  unsigned char D.35602;
  int D.35603;
  struct MonoObject * D.35605;
  struct MonoVTable * D.35606;
  int D.35607;
  int D.35610;
  int D.35611;
  unsigned int D.35612;
  struct MonoMethod * D.35613;
  int D.35615;
  struct MonoProperty * D.35618;
  _Bool D.35621;
  long int D.35622;
  long int D.35623;
  int D.35627;
  int D.35631;
  struct MonoObject * D.35634;
  struct MonoVTable * D.35635;
  struct MonoClass * D.35636;
  int D.35637;
  int D.35641;
  char * D.35645;
  int D.22035;
  int iftmp.581;
  int D.22031;
  const char[16] * D.35650;
  unsigned char D.35651;
  int D.35652;
  unsigned char D.35653;
  int D.35654;
  _Bool D.35655;
  _Bool D.35656;
  _Bool D.35657;
  const unsigned char * D.35660;
  unsigned char D.35661;
  int D.35662;
  const unsigned char * D.35663;
  unsigned char D.35664;
  int D.35665;
  _Bool D.35666;
  _Bool D.35667;
  const unsigned char * D.35670;
  unsigned char D.35671;
  int D.35672;
  const unsigned char * D.35673;
  unsigned char D.35674;
  int D.35675;
  _Bool D.35676;
  _Bool D.35677;
  const unsigned char * D.35680;
  unsigned char D.35681;
  int D.35682;
  const unsigned char * D.35683;
  unsigned char D.35684;
  int D.35685;
  struct MonoArray * D.35689;
  struct MonoAssembly * D.35690;
  struct MonoImage * D.35691;
  int D.22045;
  int iftmp.582;
  int D.22041;
  const char[12] * D.35696;
  unsigned char D.35697;
  int D.35698;
  unsigned char D.35699;
  int D.35700;
  _Bool D.35701;
  _Bool D.35702;
  _Bool D.35703;
  const unsigned char * D.35706;
  unsigned char D.35707;
  int D.35708;
  const unsigned char * D.35709;
  unsigned char D.35710;
  int D.35711;
  _Bool D.35712;
  _Bool D.35713;
  const unsigned char * D.35716;
  unsigned char D.35717;
  int D.35718;
  const unsigned char * D.35719;
  unsigned char D.35720;
  int D.35721;
  _Bool D.35722;
  _Bool D.35723;
  const unsigned char * D.35726;
  unsigned char D.35727;
  int D.35728;
  const unsigned char * D.35729;
  unsigned char D.35730;
  int D.35731;
  struct MonoArray * D.35735;
  struct MonoReflectionModuleBuilder * D.35736;
  struct MonoDynamicImage * D.35737;
  struct MonoImage * D.35738;
  int D.22055;
  int iftmp.583;
  int D.22051;
  const char[14] * D.35743;
  unsigned char D.35744;
  int D.35745;
  unsigned char D.35746;
  int D.35747;
  _Bool D.35748;
  _Bool D.35749;
  _Bool D.35750;
  const unsigned char * D.35753;
  unsigned char D.35754;
  int D.35755;
  const unsigned char * D.35756;
  unsigned char D.35757;
  int D.35758;
  _Bool D.35759;
  _Bool D.35760;
  const unsigned char * D.35763;
  unsigned char D.35764;
  int D.35765;
  const unsigned char * D.35766;
  unsigned char D.35767;
  int D.35768;
  _Bool D.35769;
  _Bool D.35770;
  const unsigned char * D.35773;
  unsigned char D.35774;
  int D.35775;
  const unsigned char * D.35776;
  unsigned char D.35777;
  int D.35778;
  struct MonoArray * D.35782;
  struct MonoDynamicImage * D.35783;
  struct MonoImage * D.35784;
  int D.22065;
  int iftmp.584;
  int D.22061;
  const char[19] * D.35789;
  unsigned char D.35790;
  int D.35791;
  unsigned char D.35792;
  int D.35793;
  _Bool D.35794;
  _Bool D.35795;
  _Bool D.35796;
  const unsigned char * D.35799;
  unsigned char D.35800;
  int D.35801;
  const unsigned char * D.35802;
  unsigned char D.35803;
  int D.35804;
  _Bool D.35805;
  _Bool D.35806;
  const unsigned char * D.35809;
  unsigned char D.35810;
  int D.35811;
  const unsigned char * D.35812;
  unsigned char D.35813;
  int D.35814;
  _Bool D.35815;
  _Bool D.35816;
  const unsigned char * D.35819;
  unsigned char D.35820;
  int D.35821;
  const unsigned char * D.35822;
  unsigned char D.35823;
  int D.35824;
  struct MonoArray * D.35828;
  struct MonoMethod * D.35829;
  struct MonoClass * D.35830;
  struct MonoImage * D.35831;
  int D.22075;
  int iftmp.585;
  int D.22071;
  const char[14] * D.35836;
  unsigned char D.35837;
  int D.35838;
  unsigned char D.35839;
  int D.35840;
  _Bool D.35841;
  _Bool D.35842;
  _Bool D.35843;
  const unsigned char * D.35846;
  unsigned char D.35847;
  int D.35848;
  const unsigned char * D.35849;
  unsigned char D.35850;
  int D.35851;
  _Bool D.35852;
  _Bool D.35853;
  const unsigned char * D.35856;
  unsigned char D.35857;
  int D.35858;
  const unsigned char * D.35859;
  unsigned char D.35860;
  int D.35861;
  _Bool D.35862;
  _Bool D.35863;
  const unsigned char * D.35866;
  unsigned char D.35867;
  int D.35868;
  const unsigned char * D.35869;
  unsigned char D.35870;
  int D.35871;
  struct MonoArray * D.35875;
  struct MonoMethod * D.35876;
  struct MonoClass * D.35877;
  struct MonoImage * D.35878;
  int D.22085;
  int iftmp.586;
  int D.22081;
  const char[13] * D.35883;
  unsigned char D.35884;
  int D.35885;
  unsigned char D.35886;
  int D.35887;
  _Bool D.35888;
  _Bool D.35889;
  _Bool D.35890;
  const unsigned char * D.35893;
  unsigned char D.35894;
  int D.35895;
  const unsigned char * D.35896;
  unsigned char D.35897;
  int D.35898;
  _Bool D.35899;
  _Bool D.35900;
  const unsigned char * D.35903;
  unsigned char D.35904;
  int D.35905;
  const unsigned char * D.35906;
  unsigned char D.35907;
  int D.35908;
  _Bool D.35909;
  _Bool D.35910;
  const unsigned char * D.35913;
  unsigned char D.35914;
  int D.35915;
  const unsigned char * D.35916;
  unsigned char D.35917;
  int D.35918;
  struct MonoArray * D.35922;
  struct MonoReflectionType * D.35923;
  struct MonoReflectionModuleBuilder * D.35924;
  struct MonoDynamicImage * D.35925;
  struct MonoImage * D.35926;
  int D.22095;
  int iftmp.587;
  int D.22091;
  const char[17] * D.35931;
  unsigned char D.35932;
  int D.35933;
  unsigned char D.35934;
  int D.35935;
  _Bool D.35936;
  _Bool D.35937;
  _Bool D.35938;
  const unsigned char * D.35941;
  unsigned char D.35942;
  int D.35943;
  const unsigned char * D.35944;
  unsigned char D.35945;
  int D.35946;
  _Bool D.35947;
  _Bool D.35948;
  const unsigned char * D.35951;
  unsigned char D.35952;
  int D.35953;
  const unsigned char * D.35954;
  unsigned char D.35955;
  int D.35956;
  _Bool D.35957;
  _Bool D.35958;
  const unsigned char * D.35961;
  unsigned char D.35962;
  int D.35963;
  const unsigned char * D.35964;
  unsigned char D.35965;
  int D.35966;
  struct MonoReflectionType * D.35970;
  struct MonoCustomAttrInfo * D.35972;
  struct MonoClass * klass;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = 0B;
  D.35040 = obj->vtable;
  klass = D.35040->klass;
  D.35041 = mono_defaults.monotype_class;
  if (D.35041 == klass) goto <D.35042>; else goto <D.35043>;
  <D.35042>:
  {
    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.35044>;
  <D.35043>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.35049>; else goto <D.35050>;
    <D.35049>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35051 = "Assembly";
      D.35052 = MEM[(const unsigned char *)D.35051];
      D.35053 = (int) D.35052;
      D.35054 = *__s2;
      D.35055 = (int) D.35054;
      __result = D.35053 - D.35055;
      {
        D.35056 = __s1_len != 0;
        D.35057 = __result == 0;
        D.35058 = D.35056 & D.35057;
        if (D.35058 != 0) goto <D.35059>; else goto <D.35060>;
        <D.35059>:
        D.35061 = &MEM[(void *)"Assembly" + 1B];
        D.35062 = *D.35061;
        D.35063 = (int) D.35062;
        D.35064 = __s2 + 1;
        D.35065 = *D.35064;
        D.35066 = (int) D.35065;
        __result = D.35063 - D.35066;
        D.35067 = __s1_len > 1;
        D.35057 = __result == 0;
        D.35068 = D.35067 & D.35057;
        if (D.35068 != 0) goto <D.35069>; else goto <D.35070>;
        <D.35069>:
        D.35071 = &MEM[(void *)"Assembly" + 2B];
        D.35072 = *D.35071;
        D.35073 = (int) D.35072;
        D.35074 = __s2 + 2;
        D.35075 = *D.35074;
        D.35076 = (int) D.35075;
        __result = D.35073 - D.35076;
        D.35077 = __s1_len > 2;
        D.35057 = __result == 0;
        D.35078 = D.35077 & D.35057;
        if (D.35078 != 0) goto <D.35079>; else goto <D.35080>;
        <D.35079>:
        D.35081 = &MEM[(void *)"Assembly" + 3B];
        D.35082 = *D.35081;
        D.35083 = (int) D.35082;
        D.35084 = __s2 + 3;
        D.35085 = *D.35084;
        D.35086 = (int) D.35085;
        __result = D.35083 - D.35086;
        <D.35080>:
        <D.35070>:
        <D.35060>:
      }
      D.21895 = __result;
    }
    iftmp.568 = D.21895;
    goto <D.35087>;
    <D.35050>:
    D.35088 = klass->name;
    iftmp.568 = __builtin_strcmp ("Assembly", D.35088);
    <D.35087>:
    D.21899 = iftmp.568;
  }
  if (D.21899 == 0) goto <D.35045>; else goto <D.35089>;
  <D.35089>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35093 = "MonoAssembly";
      D.35094 = MEM[(const unsigned char *)D.35093];
      D.35095 = (int) D.35094;
      D.35096 = *__s2;
      D.35097 = (int) D.35096;
      __result = D.35095 - D.35097;
      {
        D.35098 = __s1_len != 0;
        D.35099 = __result == 0;
        D.35100 = D.35098 & D.35099;
        if (D.35100 != 0) goto <D.35101>; else goto <D.35102>;
        <D.35101>:
        D.35103 = &MEM[(void *)"MonoAssembly" + 1B];
        D.35104 = *D.35103;
        D.35105 = (int) D.35104;
        D.35106 = __s2 + 1;
        D.35107 = *D.35106;
        D.35108 = (int) D.35107;
        __result = D.35105 - D.35108;
        D.35109 = __s1_len > 1;
        D.35099 = __result == 0;
        D.35110 = D.35109 & D.35099;
        if (D.35110 != 0) goto <D.35111>; else goto <D.35112>;
        <D.35111>:
        D.35113 = &MEM[(void *)"MonoAssembly" + 2B];
        D.35114 = *D.35113;
        D.35115 = (int) D.35114;
        D.35116 = __s2 + 2;
        D.35117 = *D.35116;
        D.35118 = (int) D.35117;
        __result = D.35115 - D.35118;
        D.35119 = __s1_len > 2;
        D.35099 = __result == 0;
        D.35120 = D.35119 & D.35099;
        if (D.35120 != 0) goto <D.35121>; else goto <D.35122>;
        <D.35121>:
        D.35123 = &MEM[(void *)"MonoAssembly" + 3B];
        D.35124 = *D.35123;
        D.35125 = (int) D.35124;
        D.35126 = __s2 + 3;
        D.35127 = *D.35126;
        D.35128 = (int) D.35127;
        __result = D.35125 - D.35128;
        <D.35122>:
        <D.35112>:
        <D.35102>:
      }
      D.21904 = __result;
    }
    iftmp.569 = D.21904;
    goto <D.35129>;
    <D.35092>:
    D.35088 = klass->name;
    iftmp.569 = __builtin_strcmp ("MonoAssembly", D.35088);
    <D.35129>:
    D.21908 = iftmp.569;
  }
  if (D.21908 == 0) goto <D.35045>; else goto <D.35046>;
  <D.35045>:
  {
    struct MonoReflectionAssembly * rassembly;

    rassembly = obj;
    D.35130 = rassembly->assembly;
    cinfo = mono_custom_attrs_from_assembly (D.35130);
  }
  goto <D.35047>;
  <D.35046>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35137 = "Module";
      D.35138 = MEM[(const unsigned char *)D.35137];
      D.35139 = (int) D.35138;
      D.35140 = *__s2;
      D.35141 = (int) D.35140;
      __result = D.35139 - D.35141;
      {
        D.35142 = __s1_len != 0;
        D.35143 = __result == 0;
        D.35144 = D.35142 & D.35143;
        if (D.35144 != 0) goto <D.35145>; else goto <D.35146>;
        <D.35145>:
        D.35147 = &MEM[(void *)"Module" + 1B];
        D.35148 = *D.35147;
        D.35149 = (int) D.35148;
        D.35150 = __s2 + 1;
        D.35151 = *D.35150;
        D.35152 = (int) D.35151;
        __result = D.35149 - D.35152;
        D.35153 = __s1_len > 1;
        D.35143 = __result == 0;
        D.35154 = D.35153 & D.35143;
        if (D.35154 != 0) goto <D.35155>; else goto <D.35156>;
        <D.35155>:
        D.35157 = &MEM[(void *)"Module" + 2B];
        D.35158 = *D.35157;
        D.35159 = (int) D.35158;
        D.35160 = __s2 + 2;
        D.35161 = *D.35160;
        D.35162 = (int) D.35161;
        __result = D.35159 - D.35162;
        D.35163 = __s1_len > 2;
        D.35143 = __result == 0;
        D.35164 = D.35163 & D.35143;
        if (D.35164 != 0) goto <D.35165>; else goto <D.35166>;
        <D.35165>:
        D.35167 = &MEM[(void *)"Module" + 3B];
        D.35168 = *D.35167;
        D.35169 = (int) D.35168;
        D.35170 = __s2 + 3;
        D.35171 = *D.35170;
        D.35172 = (int) D.35171;
        __result = D.35169 - D.35172;
        <D.35166>:
        <D.35156>:
        <D.35146>:
      }
      D.21914 = __result;
    }
    iftmp.570 = D.21914;
    goto <D.35173>;
    <D.35136>:
    D.35088 = klass->name;
    iftmp.570 = __builtin_strcmp ("Module", D.35088);
    <D.35173>:
    D.21918 = iftmp.570;
  }
  if (D.21918 == 0) goto <D.35131>; else goto <D.35174>;
  <D.35174>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35178 = "MonoModule";
      D.35179 = MEM[(const unsigned char *)D.35178];
      D.35180 = (int) D.35179;
      D.35181 = *__s2;
      D.35182 = (int) D.35181;
      __result = D.35180 - D.35182;
      {
        D.35183 = __s1_len != 0;
        D.35184 = __result == 0;
        D.35185 = D.35183 & D.35184;
        if (D.35185 != 0) goto <D.35186>; else goto <D.35187>;
        <D.35186>:
        D.35188 = &MEM[(void *)"MonoModule" + 1B];
        D.35189 = *D.35188;
        D.35190 = (int) D.35189;
        D.35191 = __s2 + 1;
        D.35192 = *D.35191;
        D.35193 = (int) D.35192;
        __result = D.35190 - D.35193;
        D.35194 = __s1_len > 1;
        D.35184 = __result == 0;
        D.35195 = D.35194 & D.35184;
        if (D.35195 != 0) goto <D.35196>; else goto <D.35197>;
        <D.35196>:
        D.35198 = &MEM[(void *)"MonoModule" + 2B];
        D.35199 = *D.35198;
        D.35200 = (int) D.35199;
        D.35201 = __s2 + 2;
        D.35202 = *D.35201;
        D.35203 = (int) D.35202;
        __result = D.35200 - D.35203;
        D.35204 = __s1_len > 2;
        D.35184 = __result == 0;
        D.35205 = D.35204 & D.35184;
        if (D.35205 != 0) goto <D.35206>; else goto <D.35207>;
        <D.35206>:
        D.35208 = &MEM[(void *)"MonoModule" + 3B];
        D.35209 = *D.35208;
        D.35210 = (int) D.35209;
        D.35211 = __s2 + 3;
        D.35212 = *D.35211;
        D.35213 = (int) D.35212;
        __result = D.35210 - D.35213;
        <D.35207>:
        <D.35197>:
        <D.35187>:
      }
      D.21923 = __result;
    }
    iftmp.571 = D.21923;
    goto <D.35214>;
    <D.35177>:
    D.35088 = klass->name;
    iftmp.571 = __builtin_strcmp ("MonoModule", D.35088);
    <D.35214>:
    D.21927 = iftmp.571;
  }
  if (D.21927 == 0) goto <D.35131>; else goto <D.35132>;
  <D.35131>:
  {
    struct MonoReflectionModule * module;

    module = obj;
    D.35215 = module->image;
    cinfo = mono_custom_attrs_from_module (D.35215);
  }
  goto <D.35133>;
  <D.35132>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35219 = "MonoProperty";
      D.35220 = MEM[(const unsigned char *)D.35219];
      D.35221 = (int) D.35220;
      D.35222 = *__s2;
      D.35223 = (int) D.35222;
      __result = D.35221 - D.35223;
      {
        D.35224 = __s1_len != 0;
        D.35225 = __result == 0;
        D.35226 = D.35224 & D.35225;
        if (D.35226 != 0) goto <D.35227>; else goto <D.35228>;
        <D.35227>:
        D.35229 = &MEM[(void *)"MonoProperty" + 1B];
        D.35230 = *D.35229;
        D.35231 = (int) D.35230;
        D.35232 = __s2 + 1;
        D.35233 = *D.35232;
        D.35234 = (int) D.35233;
        __result = D.35231 - D.35234;
        D.35235 = __s1_len > 1;
        D.35225 = __result == 0;
        D.35236 = D.35235 & D.35225;
        if (D.35236 != 0) goto <D.35237>; else goto <D.35238>;
        <D.35237>:
        D.35239 = &MEM[(void *)"MonoProperty" + 2B];
        D.35240 = *D.35239;
        D.35241 = (int) D.35240;
        D.35242 = __s2 + 2;
        D.35243 = *D.35242;
        D.35244 = (int) D.35243;
        __result = D.35241 - D.35244;
        D.35245 = __s1_len > 2;
        D.35225 = __result == 0;
        D.35246 = D.35245 & D.35225;
        if (D.35246 != 0) goto <D.35247>; else goto <D.35248>;
        <D.35247>:
        D.35249 = &MEM[(void *)"MonoProperty" + 3B];
        D.35250 = *D.35249;
        D.35251 = (int) D.35250;
        D.35252 = __s2 + 3;
        D.35253 = *D.35252;
        D.35254 = (int) D.35253;
        __result = D.35251 - D.35254;
        <D.35248>:
        <D.35238>:
        <D.35228>:
      }
      D.21933 = __result;
    }
    iftmp.572 = D.21933;
    goto <D.35255>;
    <D.35218>:
    D.35088 = klass->name;
    iftmp.572 = __builtin_strcmp ("MonoProperty", D.35088);
    <D.35255>:
    D.21937 = iftmp.572;
  }
  if (D.21937 == 0) goto <D.35256>; else goto <D.35257>;
  <D.35256>:
  {
    struct MonoReflectionProperty * rprop;

    rprop = obj;
    D.35258 = rprop->property;
    D.35258 = rprop->property;
    D.35259 = D.35258->parent;
    cinfo = mono_custom_attrs_from_property (D.35259, D.35258);
  }
  goto <D.35260>;
  <D.35257>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35264 = "MonoEvent";
      D.35265 = MEM[(const unsigned char *)D.35264];
      D.35266 = (int) D.35265;
      D.35267 = *__s2;
      D.35268 = (int) D.35267;
      __result = D.35266 - D.35268;
      {
        D.35269 = __s1_len != 0;
        D.35270 = __result == 0;
        D.35271 = D.35269 & D.35270;
        if (D.35271 != 0) goto <D.35272>; else goto <D.35273>;
        <D.35272>:
        D.35274 = &MEM[(void *)"MonoEvent" + 1B];
        D.35275 = *D.35274;
        D.35276 = (int) D.35275;
        D.35277 = __s2 + 1;
        D.35278 = *D.35277;
        D.35279 = (int) D.35278;
        __result = D.35276 - D.35279;
        D.35280 = __s1_len > 1;
        D.35270 = __result == 0;
        D.35281 = D.35280 & D.35270;
        if (D.35281 != 0) goto <D.35282>; else goto <D.35283>;
        <D.35282>:
        D.35284 = &MEM[(void *)"MonoEvent" + 2B];
        D.35285 = *D.35284;
        D.35286 = (int) D.35285;
        D.35287 = __s2 + 2;
        D.35288 = *D.35287;
        D.35289 = (int) D.35288;
        __result = D.35286 - D.35289;
        D.35290 = __s1_len > 2;
        D.35270 = __result == 0;
        D.35291 = D.35290 & D.35270;
        if (D.35291 != 0) goto <D.35292>; else goto <D.35293>;
        <D.35292>:
        D.35294 = &MEM[(void *)"MonoEvent" + 3B];
        D.35295 = *D.35294;
        D.35296 = (int) D.35295;
        D.35297 = __s2 + 3;
        D.35298 = *D.35297;
        D.35299 = (int) D.35298;
        __result = D.35296 - D.35299;
        <D.35293>:
        <D.35283>:
        <D.35273>:
      }
      D.21943 = __result;
    }
    iftmp.573 = D.21943;
    goto <D.35300>;
    <D.35263>:
    D.35088 = klass->name;
    iftmp.573 = __builtin_strcmp ("MonoEvent", D.35088);
    <D.35300>:
    D.21947 = iftmp.573;
  }
  if (D.21947 == 0) goto <D.35301>; else goto <D.35302>;
  <D.35301>:
  {
    struct MonoReflectionMonoEvent * revent;

    revent = obj;
    D.35303 = revent->event;
    D.35303 = revent->event;
    D.35304 = D.35303->parent;
    cinfo = mono_custom_attrs_from_event (D.35304, D.35303);
  }
  goto <D.35305>;
  <D.35302>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35309 = "MonoField";
      D.35310 = MEM[(const unsigned char *)D.35309];
      D.35311 = (int) D.35310;
      D.35312 = *__s2;
      D.35313 = (int) D.35312;
      __result = D.35311 - D.35313;
      {
        D.35314 = __s1_len != 0;
        D.35315 = __result == 0;
        D.35316 = D.35314 & D.35315;
        if (D.35316 != 0) goto <D.35317>; else goto <D.35318>;
        <D.35317>:
        D.35319 = &MEM[(void *)"MonoField" + 1B];
        D.35320 = *D.35319;
        D.35321 = (int) D.35320;
        D.35322 = __s2 + 1;
        D.35323 = *D.35322;
        D.35324 = (int) D.35323;
        __result = D.35321 - D.35324;
        D.35325 = __s1_len > 1;
        D.35315 = __result == 0;
        D.35326 = D.35325 & D.35315;
        if (D.35326 != 0) goto <D.35327>; else goto <D.35328>;
        <D.35327>:
        D.35329 = &MEM[(void *)"MonoField" + 2B];
        D.35330 = *D.35329;
        D.35331 = (int) D.35330;
        D.35332 = __s2 + 2;
        D.35333 = *D.35332;
        D.35334 = (int) D.35333;
        __result = D.35331 - D.35334;
        D.35335 = __s1_len > 2;
        D.35315 = __result == 0;
        D.35336 = D.35335 & D.35315;
        if (D.35336 != 0) goto <D.35337>; else goto <D.35338>;
        <D.35337>:
        D.35339 = &MEM[(void *)"MonoField" + 3B];
        D.35340 = *D.35339;
        D.35341 = (int) D.35340;
        D.35342 = __s2 + 3;
        D.35343 = *D.35342;
        D.35344 = (int) D.35343;
        __result = D.35341 - D.35344;
        <D.35338>:
        <D.35328>:
        <D.35318>:
      }
      D.21953 = __result;
    }
    iftmp.574 = D.21953;
    goto <D.35345>;
    <D.35308>:
    D.35088 = klass->name;
    iftmp.574 = __builtin_strcmp ("MonoField", D.35088);
    <D.35345>:
    D.21957 = iftmp.574;
  }
  if (D.21957 == 0) goto <D.35346>; else goto <D.35347>;
  <D.35346>:
  {
    struct MonoReflectionField * rfield;

    rfield = obj;
    D.35348 = rfield->field;
    D.35348 = rfield->field;
    D.35349 = D.35348->parent;
    cinfo = mono_custom_attrs_from_field (D.35349, D.35348);
  }
  goto <D.35350>;
  <D.35347>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35357 = "MonoMethod";
      D.35358 = MEM[(const unsigned char *)D.35357];
      D.35359 = (int) D.35358;
      D.35360 = *__s2;
      D.35361 = (int) D.35360;
      __result = D.35359 - D.35361;
      {
        D.35362 = __s1_len != 0;
        D.35363 = __result == 0;
        D.35364 = D.35362 & D.35363;
        if (D.35364 != 0) goto <D.35365>; else goto <D.35366>;
        <D.35365>:
        D.35367 = &MEM[(void *)"MonoMethod" + 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;
        D.35373 = __s1_len > 1;
        D.35363 = __result == 0;
        D.35374 = D.35373 & D.35363;
        if (D.35374 != 0) goto <D.35375>; else goto <D.35376>;
        <D.35375>:
        D.35377 = &MEM[(void *)"MonoMethod" + 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;
        D.35383 = __s1_len > 2;
        D.35363 = __result == 0;
        D.35384 = D.35383 & D.35363;
        if (D.35384 != 0) goto <D.35385>; else goto <D.35386>;
        <D.35385>:
        D.35387 = &MEM[(void *)"MonoMethod" + 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.35376>:
        <D.35366>:
      }
      D.21963 = __result;
    }
    iftmp.575 = D.21963;
    goto <D.35393>;
    <D.35356>:
    D.35088 = klass->name;
    iftmp.575 = __builtin_strcmp ("MonoMethod", D.35088);
    <D.35393>:
    D.21967 = iftmp.575;
  }
  if (D.21967 == 0) goto <D.35351>; else goto <D.35394>;
  <D.35394>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35398 = "MonoCMethod";
      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;
      {
        D.35403 = __s1_len != 0;
        D.35404 = __result == 0;
        D.35405 = D.35403 & D.35404;
        if (D.35405 != 0) goto <D.35406>; else goto <D.35407>;
        <D.35406>:
        D.35408 = &MEM[(void *)"MonoCMethod" + 1B];
        D.35409 = *D.35408;
        D.35410 = (int) D.35409;
        D.35411 = __s2 + 1;
        D.35412 = *D.35411;
        D.35413 = (int) D.35412;
        __result = D.35410 - D.35413;
        D.35414 = __s1_len > 1;
        D.35404 = __result == 0;
        D.35415 = D.35414 & D.35404;
        if (D.35415 != 0) goto <D.35416>; else goto <D.35417>;
        <D.35416>:
        D.35418 = &MEM[(void *)"MonoCMethod" + 2B];
        D.35419 = *D.35418;
        D.35420 = (int) D.35419;
        D.35421 = __s2 + 2;
        D.35422 = *D.35421;
        D.35423 = (int) D.35422;
        __result = D.35420 - D.35423;
        D.35424 = __s1_len > 2;
        D.35404 = __result == 0;
        D.35425 = D.35424 & D.35404;
        if (D.35425 != 0) goto <D.35426>; else goto <D.35427>;
        <D.35426>:
        D.35428 = &MEM[(void *)"MonoCMethod" + 3B];
        D.35429 = *D.35428;
        D.35430 = (int) D.35429;
        D.35431 = __s2 + 3;
        D.35432 = *D.35431;
        D.35433 = (int) D.35432;
        __result = D.35430 - D.35433;
        <D.35427>:
        <D.35417>:
        <D.35407>:
      }
      D.21972 = __result;
    }
    iftmp.576 = D.21972;
    goto <D.35434>;
    <D.35397>:
    D.35088 = klass->name;
    iftmp.576 = __builtin_strcmp ("MonoCMethod", D.35088);
    <D.35434>:
    D.21976 = iftmp.576;
  }
  if (D.21976 == 0) goto <D.35351>; else goto <D.35352>;
  <D.35351>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.35435 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.35435);
  }
  goto <D.35353>;
  <D.35352>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35442 = "MonoGenericMethod";
      D.35443 = MEM[(const unsigned char *)D.35442];
      D.35444 = (int) D.35443;
      D.35445 = *__s2;
      D.35446 = (int) D.35445;
      __result = D.35444 - D.35446;
      {
        D.35447 = __s1_len != 0;
        D.35448 = __result == 0;
        D.35449 = D.35447 & D.35448;
        if (D.35449 != 0) goto <D.35450>; else goto <D.35451>;
        <D.35450>:
        D.35452 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.35453 = *D.35452;
        D.35454 = (int) D.35453;
        D.35455 = __s2 + 1;
        D.35456 = *D.35455;
        D.35457 = (int) D.35456;
        __result = D.35454 - D.35457;
        D.35458 = __s1_len > 1;
        D.35448 = __result == 0;
        D.35459 = D.35458 & D.35448;
        if (D.35459 != 0) goto <D.35460>; else goto <D.35461>;
        <D.35460>:
        D.35462 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.35463 = *D.35462;
        D.35464 = (int) D.35463;
        D.35465 = __s2 + 2;
        D.35466 = *D.35465;
        D.35467 = (int) D.35466;
        __result = D.35464 - D.35467;
        D.35468 = __s1_len > 2;
        D.35448 = __result == 0;
        D.35469 = D.35468 & D.35448;
        if (D.35469 != 0) goto <D.35470>; else goto <D.35471>;
        <D.35470>:
        D.35472 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.35473 = *D.35472;
        D.35474 = (int) D.35473;
        D.35475 = __s2 + 3;
        D.35476 = *D.35475;
        D.35477 = (int) D.35476;
        __result = D.35474 - D.35477;
        <D.35471>:
        <D.35461>:
        <D.35451>:
      }
      D.21982 = __result;
    }
    iftmp.577 = D.21982;
    goto <D.35478>;
    <D.35441>:
    D.35088 = klass->name;
    iftmp.577 = __builtin_strcmp ("MonoGenericMethod", D.35088);
    <D.35478>:
    D.21986 = iftmp.577;
  }
  if (D.21986 == 0) goto <D.35436>; else goto <D.35479>;
  <D.35479>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35483 = "MonoGenericCMethod";
      D.35484 = MEM[(const unsigned char *)D.35483];
      D.35485 = (int) D.35484;
      D.35486 = *__s2;
      D.35487 = (int) D.35486;
      __result = D.35485 - D.35487;
      {
        D.35488 = __s1_len != 0;
        D.35489 = __result == 0;
        D.35490 = D.35488 & D.35489;
        if (D.35490 != 0) goto <D.35491>; else goto <D.35492>;
        <D.35491>:
        D.35493 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.35494 = *D.35493;
        D.35495 = (int) D.35494;
        D.35496 = __s2 + 1;
        D.35497 = *D.35496;
        D.35498 = (int) D.35497;
        __result = D.35495 - D.35498;
        D.35499 = __s1_len > 1;
        D.35489 = __result == 0;
        D.35500 = D.35499 & D.35489;
        if (D.35500 != 0) goto <D.35501>; else goto <D.35502>;
        <D.35501>:
        D.35503 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.35504 = *D.35503;
        D.35505 = (int) D.35504;
        D.35506 = __s2 + 2;
        D.35507 = *D.35506;
        D.35508 = (int) D.35507;
        __result = D.35505 - D.35508;
        D.35509 = __s1_len > 2;
        D.35489 = __result == 0;
        D.35510 = D.35509 & D.35489;
        if (D.35510 != 0) goto <D.35511>; else goto <D.35512>;
        <D.35511>:
        D.35513 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.35514 = *D.35513;
        D.35515 = (int) D.35514;
        D.35516 = __s2 + 3;
        D.35517 = *D.35516;
        D.35518 = (int) D.35517;
        __result = D.35515 - D.35518;
        <D.35512>:
        <D.35502>:
        <D.35492>:
      }
      D.21991 = __result;
    }
    iftmp.578 = D.21991;
    goto <D.35519>;
    <D.35482>:
    D.35088 = klass->name;
    iftmp.578 = __builtin_strcmp ("MonoGenericCMethod", D.35088);
    <D.35519>:
    D.21995 = iftmp.578;
  }
  if (D.21995 == 0) goto <D.35436>; else goto <D.35437>;
  <D.35436>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.35520 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.35520);
  }
  goto <D.35438>;
  <D.35437>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35527 = "ParameterInfo";
      D.35528 = MEM[(const unsigned char *)D.35527];
      D.35529 = (int) D.35528;
      D.35530 = *__s2;
      D.35531 = (int) D.35530;
      __result = D.35529 - D.35531;
      {
        D.35532 = __s1_len != 0;
        D.35533 = __result == 0;
        D.35534 = D.35532 & D.35533;
        if (D.35534 != 0) goto <D.35535>; else goto <D.35536>;
        <D.35535>:
        D.35537 = &MEM[(void *)"ParameterInfo" + 1B];
        D.35538 = *D.35537;
        D.35539 = (int) D.35538;
        D.35540 = __s2 + 1;
        D.35541 = *D.35540;
        D.35542 = (int) D.35541;
        __result = D.35539 - D.35542;
        D.35543 = __s1_len > 1;
        D.35533 = __result == 0;
        D.35544 = D.35543 & D.35533;
        if (D.35544 != 0) goto <D.35545>; else goto <D.35546>;
        <D.35545>:
        D.35547 = &MEM[(void *)"ParameterInfo" + 2B];
        D.35548 = *D.35547;
        D.35549 = (int) D.35548;
        D.35550 = __s2 + 2;
        D.35551 = *D.35550;
        D.35552 = (int) D.35551;
        __result = D.35549 - D.35552;
        D.35553 = __s1_len > 2;
        D.35533 = __result == 0;
        D.35554 = D.35553 & D.35533;
        if (D.35554 != 0) goto <D.35555>; else goto <D.35556>;
        <D.35555>:
        D.35557 = &MEM[(void *)"ParameterInfo" + 3B];
        D.35558 = *D.35557;
        D.35559 = (int) D.35558;
        D.35560 = __s2 + 3;
        D.35561 = *D.35560;
        D.35562 = (int) D.35561;
        __result = D.35559 - D.35562;
        <D.35556>:
        <D.35546>:
        <D.35536>:
      }
      D.22001 = __result;
    }
    iftmp.579 = D.22001;
    goto <D.35563>;
    <D.35526>:
    D.35088 = klass->name;
    iftmp.579 = __builtin_strcmp ("ParameterInfo", D.35088);
    <D.35563>:
    D.22005 = iftmp.579;
  }
  if (D.22005 == 0) goto <D.35521>; else goto <D.35564>;
  <D.35564>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35568 = "MonoParameterInfo";
      D.35569 = MEM[(const unsigned char *)D.35568];
      D.35570 = (int) D.35569;
      D.35571 = *__s2;
      D.35572 = (int) D.35571;
      __result = D.35570 - D.35572;
      {
        D.35573 = __s1_len != 0;
        D.35574 = __result == 0;
        D.35575 = D.35573 & D.35574;
        if (D.35575 != 0) goto <D.35576>; else goto <D.35577>;
        <D.35576>:
        D.35578 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.35579 = *D.35578;
        D.35580 = (int) D.35579;
        D.35581 = __s2 + 1;
        D.35582 = *D.35581;
        D.35583 = (int) D.35582;
        __result = D.35580 - D.35583;
        D.35584 = __s1_len > 1;
        D.35574 = __result == 0;
        D.35585 = D.35584 & D.35574;
        if (D.35585 != 0) goto <D.35586>; else goto <D.35587>;
        <D.35586>:
        D.35588 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.35589 = *D.35588;
        D.35590 = (int) D.35589;
        D.35591 = __s2 + 2;
        D.35592 = *D.35591;
        D.35593 = (int) D.35592;
        __result = D.35590 - D.35593;
        D.35594 = __s1_len > 2;
        D.35574 = __result == 0;
        D.35595 = D.35594 & D.35574;
        if (D.35595 != 0) goto <D.35596>; else goto <D.35597>;
        <D.35596>:
        D.35598 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.35599 = *D.35598;
        D.35600 = (int) D.35599;
        D.35601 = __s2 + 3;
        D.35602 = *D.35601;
        D.35603 = (int) D.35602;
        __result = D.35600 - D.35603;
        <D.35597>:
        <D.35587>:
        <D.35577>:
      }
      D.22010 = __result;
    }
    iftmp.580 = D.22010;
    goto <D.35604>;
    <D.35567>:
    D.35088 = klass->name;
    iftmp.580 = __builtin_strcmp ("MonoParameterInfo", D.35088);
    <D.35604>:
    D.22014 = iftmp.580;
  }
  if (D.22014 == 0) goto <D.35521>; else goto <D.35522>;
  <D.35521>:
  {
    struct MonoReflectionParameter * param;
    struct MonoClass * member_class;

    param = obj;
    D.35605 = param->MemberImpl;
    D.35606 = D.35605->vtable;
    member_class = D.35606->klass;
    D.35607 = mono_class_is_reflection_method_or_constructor (member_class);
    if (D.35607 != 0) goto <D.35608>; else goto <D.35609>;
    <D.35608>:
    {
      struct MonoReflectionMethod * rmethod;

      rmethod = param->MemberImpl;
      D.35610 = param->PositionImpl;
      D.35611 = D.35610 + 1;
      D.35612 = (unsigned int) D.35611;
      D.35613 = rmethod->method;
      cinfo = mono_custom_attrs_from_param (D.35613, D.35612);
    }
    goto <D.35614>;
    <D.35609>:
    D.35615 = is_sr_mono_property (member_class);
    if (D.35615 != 0) goto <D.35616>; else goto <D.35617>;
    <D.35616>:
    {
      struct MonoReflectionProperty * prop;
      struct MonoMethod * method;

      prop = param->MemberImpl;
      D.35618 = prop->property;
      method = D.35618->get;
      if (method == 0B) goto <D.35619>; else goto <D.35620>;
      <D.35619>:
      D.35618 = prop->property;
      method = D.35618->set;
      <D.35620>:
      D.35621 = method == 0B;
      D.35622 = (long int) D.35621;
      D.35623 = __builtin_expect (D.35622, 0);
      if (D.35623 != 0) goto <D.35624>; else goto <D.35625>;
      <D.35624>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8889, "method");
      <D.35625>:
      D.35610 = param->PositionImpl;
      D.35611 = D.35610 + 1;
      D.35612 = (unsigned int) D.35611;
      cinfo = mono_custom_attrs_from_param (method, D.35612);
    }
    goto <D.35626>;
    <D.35617>:
    D.35627 = is_sre_method_on_tb_inst (member_class);
    if (D.35627 != 0) goto <D.35628>; else goto <D.35629>;
    <D.35628>:
    {
      struct MonoMethod * method;

      D.35605 = param->MemberImpl;
      method = mono_reflection_method_on_tb_inst_get_handle (D.35605);
      D.35610 = param->PositionImpl;
      D.35611 = D.35610 + 1;
      D.35612 = (unsigned int) D.35611;
      cinfo = mono_custom_attrs_from_param (method, D.35612);
    }
    goto <D.35630>;
    <D.35629>:
    D.35631 = is_sre_ctor_on_tb_inst (member_class);
    if (D.35631 != 0) goto <D.35632>; else goto <D.35633>;
    <D.35632>:
    {
      struct MonoReflectionCtorOnTypeBuilderInst * c;
      struct MonoMethod * method;

      c = param->MemberImpl;
      method = 0B;
      D.35634 = c->cb;
      D.35635 = D.35634->vtable;
      D.35636 = D.35635->klass;
      D.35637 = is_sre_ctor_builder (D.35636);
      if (D.35637 != 0) goto <D.35638>; else goto <D.35639>;
      <D.35638>:
      D.35634 = c->cb;
      method = MEM[(struct MonoReflectionCtorBuilder *)D.35634].mhandle;
      goto <D.35640>;
      <D.35639>:
      D.35634 = c->cb;
      D.35635 = D.35634->vtable;
      D.35636 = D.35635->klass;
      D.35641 = is_sr_mono_cmethod (D.35636);
      if (D.35641 != 0) goto <D.35642>; else goto <D.35643>;
      <D.35642>:
      D.35634 = c->cb;
      method = MEM[(struct MonoReflectionMethod *)D.35634].method;
      goto <D.35644>;
      <D.35643>:
      D.35645 = 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.35645);
      <D.22023>:
      goto <D.22023>;
      <D.35644>:
      <D.35640>:
      D.35610 = param->PositionImpl;
      D.35611 = D.35610 + 1;
      D.35612 = (unsigned int) D.35611;
      cinfo = mono_custom_attrs_from_param (method, D.35612);
    }
    goto <D.35646>;
    <D.35633>:
    {
      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.35646>:
    <D.35630>:
    <D.35626>:
    <D.35614>:
  }
  goto <D.35523>;
  <D.35522>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 15;
    if (__s1_len <= 3) goto <D.35648>; else goto <D.35649>;
    <D.35648>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35650 = "AssemblyBuilder";
      D.35651 = MEM[(const unsigned char *)D.35650];
      D.35652 = (int) D.35651;
      D.35653 = *__s2;
      D.35654 = (int) D.35653;
      __result = D.35652 - D.35654;
      {
        D.35655 = __s1_len != 0;
        D.35656 = __result == 0;
        D.35657 = D.35655 & D.35656;
        if (D.35657 != 0) goto <D.35658>; else goto <D.35659>;
        <D.35658>:
        D.35660 = &MEM[(void *)"AssemblyBuilder" + 1B];
        D.35661 = *D.35660;
        D.35662 = (int) D.35661;
        D.35663 = __s2 + 1;
        D.35664 = *D.35663;
        D.35665 = (int) D.35664;
        __result = D.35662 - D.35665;
        D.35666 = __s1_len > 1;
        D.35656 = __result == 0;
        D.35667 = D.35666 & D.35656;
        if (D.35667 != 0) goto <D.35668>; else goto <D.35669>;
        <D.35668>:
        D.35670 = &MEM[(void *)"AssemblyBuilder" + 2B];
        D.35671 = *D.35670;
        D.35672 = (int) D.35671;
        D.35673 = __s2 + 2;
        D.35674 = *D.35673;
        D.35675 = (int) D.35674;
        __result = D.35672 - D.35675;
        D.35676 = __s1_len > 2;
        D.35656 = __result == 0;
        D.35677 = D.35676 & D.35656;
        if (D.35677 != 0) goto <D.35678>; else goto <D.35679>;
        <D.35678>:
        D.35680 = &MEM[(void *)"AssemblyBuilder" + 3B];
        D.35681 = *D.35680;
        D.35682 = (int) D.35681;
        D.35683 = __s2 + 3;
        D.35684 = *D.35683;
        D.35685 = (int) D.35684;
        __result = D.35682 - D.35685;
        <D.35679>:
        <D.35669>:
        <D.35659>:
      }
      D.22031 = __result;
    }
    iftmp.581 = D.22031;
    goto <D.35686>;
    <D.35649>:
    D.35088 = klass->name;
    iftmp.581 = __builtin_strcmp ("AssemblyBuilder", D.35088);
    <D.35686>:
    D.22035 = iftmp.581;
  }
  if (D.22035 == 0) goto <D.35687>; else goto <D.35688>;
  <D.35687>:
  {
    struct MonoReflectionAssemblyBuilder * assemblyb;

    assemblyb = obj;
    D.35689 = assemblyb->cattrs;
    D.35690 = assemblyb->assembly.assembly;
    D.35691 = D.35690->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35691, D.35689);
  }
  goto <D.35692>;
  <D.35688>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35696 = "TypeBuilder";
      D.35697 = MEM[(const unsigned char *)D.35696];
      D.35698 = (int) D.35697;
      D.35699 = *__s2;
      D.35700 = (int) D.35699;
      __result = D.35698 - D.35700;
      {
        D.35701 = __s1_len != 0;
        D.35702 = __result == 0;
        D.35703 = D.35701 & D.35702;
        if (D.35703 != 0) goto <D.35704>; else goto <D.35705>;
        <D.35704>:
        D.35706 = &MEM[(void *)"TypeBuilder" + 1B];
        D.35707 = *D.35706;
        D.35708 = (int) D.35707;
        D.35709 = __s2 + 1;
        D.35710 = *D.35709;
        D.35711 = (int) D.35710;
        __result = D.35708 - D.35711;
        D.35712 = __s1_len > 1;
        D.35702 = __result == 0;
        D.35713 = D.35712 & D.35702;
        if (D.35713 != 0) goto <D.35714>; else goto <D.35715>;
        <D.35714>:
        D.35716 = &MEM[(void *)"TypeBuilder" + 2B];
        D.35717 = *D.35716;
        D.35718 = (int) D.35717;
        D.35719 = __s2 + 2;
        D.35720 = *D.35719;
        D.35721 = (int) D.35720;
        __result = D.35718 - D.35721;
        D.35722 = __s1_len > 2;
        D.35702 = __result == 0;
        D.35723 = D.35722 & D.35702;
        if (D.35723 != 0) goto <D.35724>; else goto <D.35725>;
        <D.35724>:
        D.35726 = &MEM[(void *)"TypeBuilder" + 3B];
        D.35727 = *D.35726;
        D.35728 = (int) D.35727;
        D.35729 = __s2 + 3;
        D.35730 = *D.35729;
        D.35731 = (int) D.35730;
        __result = D.35728 - D.35731;
        <D.35725>:
        <D.35715>:
        <D.35705>:
      }
      D.22041 = __result;
    }
    iftmp.582 = D.22041;
    goto <D.35732>;
    <D.35695>:
    D.35088 = klass->name;
    iftmp.582 = __builtin_strcmp ("TypeBuilder", D.35088);
    <D.35732>:
    D.22045 = iftmp.582;
  }
  if (D.22045 == 0) goto <D.35733>; else goto <D.35734>;
  <D.35733>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.35735 = tb->cattrs;
    D.35736 = tb->module;
    D.35737 = D.35736->dynamic_image;
    D.35738 = &D.35737->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35738, D.35735);
  }
  goto <D.35739>;
  <D.35734>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35743 = "ModuleBuilder";
      D.35744 = MEM[(const unsigned char *)D.35743];
      D.35745 = (int) D.35744;
      D.35746 = *__s2;
      D.35747 = (int) D.35746;
      __result = D.35745 - D.35747;
      {
        D.35748 = __s1_len != 0;
        D.35749 = __result == 0;
        D.35750 = D.35748 & D.35749;
        if (D.35750 != 0) goto <D.35751>; else goto <D.35752>;
        <D.35751>:
        D.35753 = &MEM[(void *)"ModuleBuilder" + 1B];
        D.35754 = *D.35753;
        D.35755 = (int) D.35754;
        D.35756 = __s2 + 1;
        D.35757 = *D.35756;
        D.35758 = (int) D.35757;
        __result = D.35755 - D.35758;
        D.35759 = __s1_len > 1;
        D.35749 = __result == 0;
        D.35760 = D.35759 & D.35749;
        if (D.35760 != 0) goto <D.35761>; else goto <D.35762>;
        <D.35761>:
        D.35763 = &MEM[(void *)"ModuleBuilder" + 2B];
        D.35764 = *D.35763;
        D.35765 = (int) D.35764;
        D.35766 = __s2 + 2;
        D.35767 = *D.35766;
        D.35768 = (int) D.35767;
        __result = D.35765 - D.35768;
        D.35769 = __s1_len > 2;
        D.35749 = __result == 0;
        D.35770 = D.35769 & D.35749;
        if (D.35770 != 0) goto <D.35771>; else goto <D.35772>;
        <D.35771>:
        D.35773 = &MEM[(void *)"ModuleBuilder" + 3B];
        D.35774 = *D.35773;
        D.35775 = (int) D.35774;
        D.35776 = __s2 + 3;
        D.35777 = *D.35776;
        D.35778 = (int) D.35777;
        __result = D.35775 - D.35778;
        <D.35772>:
        <D.35762>:
        <D.35752>:
      }
      D.22051 = __result;
    }
    iftmp.583 = D.22051;
    goto <D.35779>;
    <D.35742>:
    D.35088 = klass->name;
    iftmp.583 = __builtin_strcmp ("ModuleBuilder", D.35088);
    <D.35779>:
    D.22055 = iftmp.583;
  }
  if (D.22055 == 0) goto <D.35780>; else goto <D.35781>;
  <D.35780>:
  {
    struct MonoReflectionModuleBuilder * mb;

    mb = obj;
    D.35782 = mb->cattrs;
    D.35783 = mb->dynamic_image;
    D.35784 = &D.35783->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35784, D.35782);
  }
  goto <D.35785>;
  <D.35781>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35789 = "ConstructorBuilder";
      D.35790 = MEM[(const unsigned char *)D.35789];
      D.35791 = (int) D.35790;
      D.35792 = *__s2;
      D.35793 = (int) D.35792;
      __result = D.35791 - D.35793;
      {
        D.35794 = __s1_len != 0;
        D.35795 = __result == 0;
        D.35796 = D.35794 & D.35795;
        if (D.35796 != 0) goto <D.35797>; else goto <D.35798>;
        <D.35797>:
        D.35799 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.35800 = *D.35799;
        D.35801 = (int) D.35800;
        D.35802 = __s2 + 1;
        D.35803 = *D.35802;
        D.35804 = (int) D.35803;
        __result = D.35801 - D.35804;
        D.35805 = __s1_len > 1;
        D.35795 = __result == 0;
        D.35806 = D.35805 & D.35795;
        if (D.35806 != 0) goto <D.35807>; else goto <D.35808>;
        <D.35807>:
        D.35809 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.35810 = *D.35809;
        D.35811 = (int) D.35810;
        D.35812 = __s2 + 2;
        D.35813 = *D.35812;
        D.35814 = (int) D.35813;
        __result = D.35811 - D.35814;
        D.35815 = __s1_len > 2;
        D.35795 = __result == 0;
        D.35816 = D.35815 & D.35795;
        if (D.35816 != 0) goto <D.35817>; else goto <D.35818>;
        <D.35817>:
        D.35819 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.35820 = *D.35819;
        D.35821 = (int) D.35820;
        D.35822 = __s2 + 3;
        D.35823 = *D.35822;
        D.35824 = (int) D.35823;
        __result = D.35821 - D.35824;
        <D.35818>:
        <D.35808>:
        <D.35798>:
      }
      D.22061 = __result;
    }
    iftmp.584 = D.22061;
    goto <D.35825>;
    <D.35788>:
    D.35088 = klass->name;
    iftmp.584 = __builtin_strcmp ("ConstructorBuilder", D.35088);
    <D.35825>:
    D.22065 = iftmp.584;
  }
  if (D.22065 == 0) goto <D.35826>; else goto <D.35827>;
  <D.35826>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    D.35828 = cb->cattrs;
    D.35829 = cb->mhandle;
    D.35830 = D.35829->klass;
    D.35831 = D.35830->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35831, D.35828);
  }
  goto <D.35832>;
  <D.35827>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35836 = "MethodBuilder";
      D.35837 = MEM[(const unsigned char *)D.35836];
      D.35838 = (int) D.35837;
      D.35839 = *__s2;
      D.35840 = (int) D.35839;
      __result = D.35838 - D.35840;
      {
        D.35841 = __s1_len != 0;
        D.35842 = __result == 0;
        D.35843 = D.35841 & D.35842;
        if (D.35843 != 0) goto <D.35844>; else goto <D.35845>;
        <D.35844>:
        D.35846 = &MEM[(void *)"MethodBuilder" + 1B];
        D.35847 = *D.35846;
        D.35848 = (int) D.35847;
        D.35849 = __s2 + 1;
        D.35850 = *D.35849;
        D.35851 = (int) D.35850;
        __result = D.35848 - D.35851;
        D.35852 = __s1_len > 1;
        D.35842 = __result == 0;
        D.35853 = D.35852 & D.35842;
        if (D.35853 != 0) goto <D.35854>; else goto <D.35855>;
        <D.35854>:
        D.35856 = &MEM[(void *)"MethodBuilder" + 2B];
        D.35857 = *D.35856;
        D.35858 = (int) D.35857;
        D.35859 = __s2 + 2;
        D.35860 = *D.35859;
        D.35861 = (int) D.35860;
        __result = D.35858 - D.35861;
        D.35862 = __s1_len > 2;
        D.35842 = __result == 0;
        D.35863 = D.35862 & D.35842;
        if (D.35863 != 0) goto <D.35864>; else goto <D.35865>;
        <D.35864>:
        D.35866 = &MEM[(void *)"MethodBuilder" + 3B];
        D.35867 = *D.35866;
        D.35868 = (int) D.35867;
        D.35869 = __s2 + 3;
        D.35870 = *D.35869;
        D.35871 = (int) D.35870;
        __result = D.35868 - D.35871;
        <D.35865>:
        <D.35855>:
        <D.35845>:
      }
      D.22071 = __result;
    }
    iftmp.585 = D.22071;
    goto <D.35872>;
    <D.35835>:
    D.35088 = klass->name;
    iftmp.585 = __builtin_strcmp ("MethodBuilder", D.35088);
    <D.35872>:
    D.22075 = iftmp.585;
  }
  if (D.22075 == 0) goto <D.35873>; else goto <D.35874>;
  <D.35873>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.35875 = mb->cattrs;
    D.35876 = mb->mhandle;
    D.35877 = D.35876->klass;
    D.35878 = D.35877->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35878, D.35875);
  }
  goto <D.35879>;
  <D.35874>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35883 = "FieldBuilder";
      D.35884 = MEM[(const unsigned char *)D.35883];
      D.35885 = (int) D.35884;
      D.35886 = *__s2;
      D.35887 = (int) D.35886;
      __result = D.35885 - D.35887;
      {
        D.35888 = __s1_len != 0;
        D.35889 = __result == 0;
        D.35890 = D.35888 & D.35889;
        if (D.35890 != 0) goto <D.35891>; else goto <D.35892>;
        <D.35891>:
        D.35893 = &MEM[(void *)"FieldBuilder" + 1B];
        D.35894 = *D.35893;
        D.35895 = (int) D.35894;
        D.35896 = __s2 + 1;
        D.35897 = *D.35896;
        D.35898 = (int) D.35897;
        __result = D.35895 - D.35898;
        D.35899 = __s1_len > 1;
        D.35889 = __result == 0;
        D.35900 = D.35899 & D.35889;
        if (D.35900 != 0) goto <D.35901>; else goto <D.35902>;
        <D.35901>:
        D.35903 = &MEM[(void *)"FieldBuilder" + 2B];
        D.35904 = *D.35903;
        D.35905 = (int) D.35904;
        D.35906 = __s2 + 2;
        D.35907 = *D.35906;
        D.35908 = (int) D.35907;
        __result = D.35905 - D.35908;
        D.35909 = __s1_len > 2;
        D.35889 = __result == 0;
        D.35910 = D.35909 & D.35889;
        if (D.35910 != 0) goto <D.35911>; else goto <D.35912>;
        <D.35911>:
        D.35913 = &MEM[(void *)"FieldBuilder" + 3B];
        D.35914 = *D.35913;
        D.35915 = (int) D.35914;
        D.35916 = __s2 + 3;
        D.35917 = *D.35916;
        D.35918 = (int) D.35917;
        __result = D.35915 - D.35918;
        <D.35912>:
        <D.35902>:
        <D.35892>:
      }
      D.22081 = __result;
    }
    iftmp.586 = D.22081;
    goto <D.35919>;
    <D.35882>:
    D.35088 = klass->name;
    iftmp.586 = __builtin_strcmp ("FieldBuilder", D.35088);
    <D.35919>:
    D.22085 = iftmp.586;
  }
  if (D.22085 == 0) goto <D.35920>; else goto <D.35921>;
  <D.35920>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.35922 = fb->cattrs;
    D.35923 = fb->typeb;
    D.35924 = MEM[(struct MonoReflectionTypeBuilder *)D.35923].module;
    D.35925 = D.35924->dynamic_image;
    D.35926 = &D.35925->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.35926, D.35922);
  }
  goto <D.35927>;
  <D.35921>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35931 = "MonoGenericClass";
      D.35932 = MEM[(const unsigned char *)D.35931];
      D.35933 = (int) D.35932;
      D.35934 = *__s2;
      D.35935 = (int) D.35934;
      __result = D.35933 - D.35935;
      {
        D.35936 = __s1_len != 0;
        D.35937 = __result == 0;
        D.35938 = D.35936 & D.35937;
        if (D.35938 != 0) goto <D.35939>; else goto <D.35940>;
        <D.35939>:
        D.35941 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.35942 = *D.35941;
        D.35943 = (int) D.35942;
        D.35944 = __s2 + 1;
        D.35945 = *D.35944;
        D.35946 = (int) D.35945;
        __result = D.35943 - D.35946;
        D.35947 = __s1_len > 1;
        D.35937 = __result == 0;
        D.35948 = D.35947 & D.35937;
        if (D.35948 != 0) goto <D.35949>; else goto <D.35950>;
        <D.35949>:
        D.35951 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.35952 = *D.35951;
        D.35953 = (int) D.35952;
        D.35954 = __s2 + 2;
        D.35955 = *D.35954;
        D.35956 = (int) D.35955;
        __result = D.35953 - D.35956;
        D.35957 = __s1_len > 2;
        D.35937 = __result == 0;
        D.35958 = D.35957 & D.35937;
        if (D.35958 != 0) goto <D.35959>; else goto <D.35960>;
        <D.35959>:
        D.35961 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.35962 = *D.35961;
        D.35963 = (int) D.35962;
        D.35964 = __s2 + 3;
        D.35965 = *D.35964;
        D.35966 = (int) D.35965;
        __result = D.35963 - D.35966;
        <D.35960>:
        <D.35950>:
        <D.35940>:
      }
      D.22091 = __result;
    }
    iftmp.587 = D.22091;
    goto <D.35967>;
    <D.35930>:
    D.35088 = klass->name;
    iftmp.587 = __builtin_strcmp ("MonoGenericClass", D.35088);
    <D.35967>:
    D.22095 = iftmp.587;
  }
  if (D.22095 == 0) goto <D.35968>; else goto <D.35969>;
  <D.35968>:
  {
    struct MonoReflectionGenericClass * gclass;

    gclass = obj;
    D.35970 = gclass->generic_type;
    cinfo = mono_reflection_get_custom_attrs_info (D.35970);
  }
  goto <D.35971>;
  <D.35969>:
  D.35088 = klass->name;
  monoeg_g_log (0B, 4, "get custom attrs not yet supported for %s", D.35088);
  <D.22097>:
  goto <D.22097>;
  <D.35971>:
  <D.35927>:
  <D.35879>:
  <D.35832>:
  <D.35785>:
  <D.35739>:
  <D.35692>:
  <D.35523>:
  <D.35438>:
  <D.35353>:
  <D.35350>:
  <D.35305>:
  <D.35260>:
  <D.35133>:
  <D.35047>:
  <D.35044>:
  D.35972 = cinfo;
  return D.35972;
}


mono_custom_attrs_from_module (struct MonoImage * image)
{
  unsigned char D.35974;
  unsigned char D.35975;
  struct MonoCustomAttrInfo * D.35978;
  guint32 idx;

  D.35974 = BIT_FIELD_REF <*image, 8, 128>;
  D.35975 = D.35974 & 8;
  if (D.35975 != 0) goto <D.35976>; else goto <D.35977>;
  <D.35976>:
  D.35978 = lookup_custom_attr (image, image);
  return D.35978;
  <D.35977>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 7;
  D.35978 = mono_custom_attrs_from_index (image, idx);
  return D.35978;
}


is_sr_mono_property (struct MonoClass * class)
{
  struct MonoClass * cached_class.588;
  gboolean D.35983;
  _Bool D.35984;
  int D.35985;
  int D.22470;
  int iftmp.589;
  int D.22466;
  const char[13] * D.35991;
  unsigned char D.35992;
  int D.35993;
  unsigned char D.35994;
  int D.35995;
  _Bool D.35996;
  _Bool D.35997;
  _Bool D.35998;
  const unsigned char * D.36001;
  unsigned char D.36002;
  int D.36003;
  const unsigned char * D.36004;
  unsigned char D.36005;
  int D.36006;
  _Bool D.36007;
  _Bool D.36008;
  const unsigned char * D.36011;
  unsigned char D.36012;
  int D.36013;
  const unsigned char * D.36014;
  unsigned char D.36015;
  int D.36016;
  _Bool D.36017;
  _Bool D.36018;
  const unsigned char * D.36021;
  unsigned char D.36022;
  int D.36023;
  const unsigned char * D.36024;
  unsigned char D.36025;
  int D.36026;
  const char * D.36028;
  int D.22479;
  int iftmp.590;
  int D.22475;
  const char[18] * D.36034;
  unsigned char D.36035;
  int D.36036;
  unsigned char D.36037;
  int D.36038;
  _Bool D.36039;
  _Bool D.36040;
  _Bool D.36041;
  const unsigned char * D.36044;
  unsigned char D.36045;
  int D.36046;
  const unsigned char * D.36047;
  unsigned char D.36048;
  int D.36049;
  _Bool D.36050;
  _Bool D.36051;
  const unsigned char * D.36054;
  unsigned char D.36055;
  int D.36056;
  const unsigned char * D.36057;
  unsigned char D.36058;
  int D.36059;
  _Bool D.36060;
  _Bool D.36061;
  const unsigned char * D.36064;
  unsigned char D.36065;
  int D.36066;
  const unsigned char * D.36067;
  unsigned char D.36068;
  int D.36069;
  const char * D.36071;

  {
    static struct MonoClass * cached_class;

    cached_class.588 = cached_class;
    if (cached_class.588 != 0B) goto <D.35981>; else goto <D.35982>;
    <D.35981>:
    cached_class.588 = cached_class;
    D.35984 = cached_class.588 == class;
    D.35983 = (gboolean) D.35984;
    return D.35983;
    <D.35982>:
    D.35985 = is_corlib_type (class);
    if (D.35985 != 0) goto <D.35986>; else goto <D.35987>;
    <D.35986>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.35991 = "MonoProperty";
        D.35992 = MEM[(const unsigned char *)D.35991];
        D.35993 = (int) D.35992;
        D.35994 = *__s2;
        D.35995 = (int) D.35994;
        __result = D.35993 - D.35995;
        {
          D.35996 = __s1_len != 0;
          D.35997 = __result == 0;
          D.35998 = D.35996 & D.35997;
          if (D.35998 != 0) goto <D.35999>; else goto <D.36000>;
          <D.35999>:
          D.36001 = &MEM[(void *)"MonoProperty" + 1B];
          D.36002 = *D.36001;
          D.36003 = (int) D.36002;
          D.36004 = __s2 + 1;
          D.36005 = *D.36004;
          D.36006 = (int) D.36005;
          __result = D.36003 - D.36006;
          D.36007 = __s1_len > 1;
          D.35997 = __result == 0;
          D.36008 = D.36007 & D.35997;
          if (D.36008 != 0) goto <D.36009>; else goto <D.36010>;
          <D.36009>:
          D.36011 = &MEM[(void *)"MonoProperty" + 2B];
          D.36012 = *D.36011;
          D.36013 = (int) D.36012;
          D.36014 = __s2 + 2;
          D.36015 = *D.36014;
          D.36016 = (int) D.36015;
          __result = D.36013 - D.36016;
          D.36017 = __s1_len > 2;
          D.35997 = __result == 0;
          D.36018 = D.36017 & D.35997;
          if (D.36018 != 0) goto <D.36019>; else goto <D.36020>;
          <D.36019>:
          D.36021 = &MEM[(void *)"MonoProperty" + 3B];
          D.36022 = *D.36021;
          D.36023 = (int) D.36022;
          D.36024 = __s2 + 3;
          D.36025 = *D.36024;
          D.36026 = (int) D.36025;
          __result = D.36023 - D.36026;
          <D.36020>:
          <D.36010>:
          <D.36000>:
        }
        D.22466 = __result;
      }
      iftmp.589 = D.22466;
      goto <D.36027>;
      <D.35990>:
      D.36028 = class->name;
      iftmp.589 = __builtin_strcmp ("MonoProperty", D.36028);
      <D.36027>:
      D.22470 = iftmp.589;
    }
    if (D.22470 == 0) goto <D.36029>; else goto <D.36030>;
    <D.36029>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36034 = "System.Reflection";
        D.36035 = MEM[(const unsigned char *)D.36034];
        D.36036 = (int) D.36035;
        D.36037 = *__s2;
        D.36038 = (int) D.36037;
        __result = D.36036 - D.36038;
        {
          D.36039 = __s1_len != 0;
          D.36040 = __result == 0;
          D.36041 = D.36039 & D.36040;
          if (D.36041 != 0) goto <D.36042>; else goto <D.36043>;
          <D.36042>:
          D.36044 = &MEM[(void *)"System.Reflection" + 1B];
          D.36045 = *D.36044;
          D.36046 = (int) D.36045;
          D.36047 = __s2 + 1;
          D.36048 = *D.36047;
          D.36049 = (int) D.36048;
          __result = D.36046 - D.36049;
          D.36050 = __s1_len > 1;
          D.36040 = __result == 0;
          D.36051 = D.36050 & D.36040;
          if (D.36051 != 0) goto <D.36052>; else goto <D.36053>;
          <D.36052>:
          D.36054 = &MEM[(void *)"System.Reflection" + 2B];
          D.36055 = *D.36054;
          D.36056 = (int) D.36055;
          D.36057 = __s2 + 2;
          D.36058 = *D.36057;
          D.36059 = (int) D.36058;
          __result = D.36056 - D.36059;
          D.36060 = __s1_len > 2;
          D.36040 = __result == 0;
          D.36061 = D.36060 & D.36040;
          if (D.36061 != 0) goto <D.36062>; else goto <D.36063>;
          <D.36062>:
          D.36064 = &MEM[(void *)"System.Reflection" + 3B];
          D.36065 = *D.36064;
          D.36066 = (int) D.36065;
          D.36067 = __s2 + 3;
          D.36068 = *D.36067;
          D.36069 = (int) D.36068;
          __result = D.36066 - D.36069;
          <D.36063>:
          <D.36053>:
          <D.36043>:
        }
        D.22475 = __result;
      }
      iftmp.590 = D.22475;
      goto <D.36070>;
      <D.36033>:
      D.36071 = class->name_space;
      iftmp.590 = __builtin_strcmp ("System.Reflection", D.36071);
      <D.36070>:
      D.22479 = iftmp.590;
    }
    if (D.22479 == 0) goto <D.36072>; else goto <D.36073>;
    <D.36072>:
    cached_class = class;
    D.35983 = 1;
    return D.35983;
    <D.36073>:
    <D.36030>:
    <D.35987>:
    D.35983 = 0;
    return D.35983;
  }
}


is_sre_method_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.591;
  gboolean D.36078;
  _Bool D.36079;
  int D.36080;
  int D.22312;
  int iftmp.592;
  int D.22308;
  const char[24] * D.36086;
  unsigned char D.36087;
  int D.36088;
  unsigned char D.36089;
  int D.36090;
  _Bool D.36091;
  _Bool D.36092;
  _Bool D.36093;
  const unsigned char * D.36096;
  unsigned char D.36097;
  int D.36098;
  const unsigned char * D.36099;
  unsigned char D.36100;
  int D.36101;
  _Bool D.36102;
  _Bool D.36103;
  const unsigned char * D.36106;
  unsigned char D.36107;
  int D.36108;
  const unsigned char * D.36109;
  unsigned char D.36110;
  int D.36111;
  _Bool D.36112;
  _Bool D.36113;
  const unsigned char * D.36116;
  unsigned char D.36117;
  int D.36118;
  const unsigned char * D.36119;
  unsigned char D.36120;
  int D.36121;
  const char * D.36123;
  int D.22321;
  int iftmp.593;
  int D.22317;
  const char[23] * D.36129;
  unsigned char D.36130;
  int D.36131;
  unsigned char D.36132;
  int D.36133;
  _Bool D.36134;
  _Bool D.36135;
  _Bool D.36136;
  const unsigned char * D.36139;
  unsigned char D.36140;
  int D.36141;
  const unsigned char * D.36142;
  unsigned char D.36143;
  int D.36144;
  _Bool D.36145;
  _Bool D.36146;
  const unsigned char * D.36149;
  unsigned char D.36150;
  int D.36151;
  const unsigned char * D.36152;
  unsigned char D.36153;
  int D.36154;
  _Bool D.36155;
  _Bool D.36156;
  const unsigned char * D.36159;
  unsigned char D.36160;
  int D.36161;
  const unsigned char * D.36162;
  unsigned char D.36163;
  int D.36164;
  const char * D.36166;

  {
    static struct MonoClass * cached_class;

    cached_class.591 = cached_class;
    if (cached_class.591 != 0B) goto <D.36076>; else goto <D.36077>;
    <D.36076>:
    cached_class.591 = cached_class;
    D.36079 = cached_class.591 == class;
    D.36078 = (gboolean) D.36079;
    return D.36078;
    <D.36077>:
    D.36080 = is_corlib_type (class);
    if (D.36080 != 0) goto <D.36081>; else goto <D.36082>;
    <D.36081>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 23;
      if (__s1_len <= 3) goto <D.36084>; else goto <D.36085>;
      <D.36084>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36086 = "MethodOnTypeBuilderInst";
        D.36087 = MEM[(const unsigned char *)D.36086];
        D.36088 = (int) D.36087;
        D.36089 = *__s2;
        D.36090 = (int) D.36089;
        __result = D.36088 - D.36090;
        {
          D.36091 = __s1_len != 0;
          D.36092 = __result == 0;
          D.36093 = D.36091 & D.36092;
          if (D.36093 != 0) goto <D.36094>; else goto <D.36095>;
          <D.36094>:
          D.36096 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
          D.36097 = *D.36096;
          D.36098 = (int) D.36097;
          D.36099 = __s2 + 1;
          D.36100 = *D.36099;
          D.36101 = (int) D.36100;
          __result = D.36098 - D.36101;
          D.36102 = __s1_len > 1;
          D.36092 = __result == 0;
          D.36103 = D.36102 & D.36092;
          if (D.36103 != 0) goto <D.36104>; else goto <D.36105>;
          <D.36104>:
          D.36106 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
          D.36107 = *D.36106;
          D.36108 = (int) D.36107;
          D.36109 = __s2 + 2;
          D.36110 = *D.36109;
          D.36111 = (int) D.36110;
          __result = D.36108 - D.36111;
          D.36112 = __s1_len > 2;
          D.36092 = __result == 0;
          D.36113 = D.36112 & D.36092;
          if (D.36113 != 0) goto <D.36114>; else goto <D.36115>;
          <D.36114>:
          D.36116 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
          D.36117 = *D.36116;
          D.36118 = (int) D.36117;
          D.36119 = __s2 + 3;
          D.36120 = *D.36119;
          D.36121 = (int) D.36120;
          __result = D.36118 - D.36121;
          <D.36115>:
          <D.36105>:
          <D.36095>:
        }
        D.22308 = __result;
      }
      iftmp.592 = D.22308;
      goto <D.36122>;
      <D.36085>:
      D.36123 = class->name;
      iftmp.592 = __builtin_strcmp ("MethodOnTypeBuilderInst", D.36123);
      <D.36122>:
      D.22312 = iftmp.592;
    }
    if (D.22312 == 0) goto <D.36124>; else goto <D.36125>;
    <D.36124>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36129 = "System.Reflection.Emit";
        D.36130 = MEM[(const unsigned char *)D.36129];
        D.36131 = (int) D.36130;
        D.36132 = *__s2;
        D.36133 = (int) D.36132;
        __result = D.36131 - D.36133;
        {
          D.36134 = __s1_len != 0;
          D.36135 = __result == 0;
          D.36136 = D.36134 & D.36135;
          if (D.36136 != 0) goto <D.36137>; else goto <D.36138>;
          <D.36137>:
          D.36139 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.36140 = *D.36139;
          D.36141 = (int) D.36140;
          D.36142 = __s2 + 1;
          D.36143 = *D.36142;
          D.36144 = (int) D.36143;
          __result = D.36141 - D.36144;
          D.36145 = __s1_len > 1;
          D.36135 = __result == 0;
          D.36146 = D.36145 & D.36135;
          if (D.36146 != 0) goto <D.36147>; else goto <D.36148>;
          <D.36147>:
          D.36149 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.36150 = *D.36149;
          D.36151 = (int) D.36150;
          D.36152 = __s2 + 2;
          D.36153 = *D.36152;
          D.36154 = (int) D.36153;
          __result = D.36151 - D.36154;
          D.36155 = __s1_len > 2;
          D.36135 = __result == 0;
          D.36156 = D.36155 & D.36135;
          if (D.36156 != 0) goto <D.36157>; else goto <D.36158>;
          <D.36157>:
          D.36159 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.36160 = *D.36159;
          D.36161 = (int) D.36160;
          D.36162 = __s2 + 3;
          D.36163 = *D.36162;
          D.36164 = (int) D.36163;
          __result = D.36161 - D.36164;
          <D.36158>:
          <D.36148>:
          <D.36138>:
        }
        D.22317 = __result;
      }
      iftmp.593 = D.22317;
      goto <D.36165>;
      <D.36128>:
      D.36166 = class->name_space;
      iftmp.593 = __builtin_strcmp ("System.Reflection.Emit", D.36166);
      <D.36165>:
      D.22321 = iftmp.593;
    }
    if (D.22321 == 0) goto <D.36167>; else goto <D.36168>;
    <D.36167>:
    cached_class = class;
    D.36078 = 1;
    return D.36078;
    <D.36168>:
    <D.36125>:
    <D.36082>:
    D.36078 = 0;
    return D.36078;
  }
}


is_sre_ctor_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.594;
  gboolean D.36173;
  _Bool D.36174;
  int D.36175;
  int D.22334;
  int iftmp.595;
  int D.22330;
  const char[29] * D.36181;
  unsigned char D.36182;
  int D.36183;
  unsigned char D.36184;
  int D.36185;
  _Bool D.36186;
  _Bool D.36187;
  _Bool D.36188;
  const unsigned char * D.36191;
  unsigned char D.36192;
  int D.36193;
  const unsigned char * D.36194;
  unsigned char D.36195;
  int D.36196;
  _Bool D.36197;
  _Bool D.36198;
  const unsigned char * D.36201;
  unsigned char D.36202;
  int D.36203;
  const unsigned char * D.36204;
  unsigned char D.36205;
  int D.36206;
  _Bool D.36207;
  _Bool D.36208;
  const unsigned char * D.36211;
  unsigned char D.36212;
  int D.36213;
  const unsigned char * D.36214;
  unsigned char D.36215;
  int D.36216;
  const char * D.36218;
  int D.22343;
  int iftmp.596;
  int D.22339;
  const char[23] * D.36224;
  unsigned char D.36225;
  int D.36226;
  unsigned char D.36227;
  int D.36228;
  _Bool D.36229;
  _Bool D.36230;
  _Bool D.36231;
  const unsigned char * D.36234;
  unsigned char D.36235;
  int D.36236;
  const unsigned char * D.36237;
  unsigned char D.36238;
  int D.36239;
  _Bool D.36240;
  _Bool D.36241;
  const unsigned char * D.36244;
  unsigned char D.36245;
  int D.36246;
  const unsigned char * D.36247;
  unsigned char D.36248;
  int D.36249;
  _Bool D.36250;
  _Bool D.36251;
  const unsigned char * D.36254;
  unsigned char D.36255;
  int D.36256;
  const unsigned char * D.36257;
  unsigned char D.36258;
  int D.36259;
  const char * D.36261;

  {
    static struct MonoClass * cached_class;

    cached_class.594 = cached_class;
    if (cached_class.594 != 0B) goto <D.36171>; else goto <D.36172>;
    <D.36171>:
    cached_class.594 = cached_class;
    D.36174 = cached_class.594 == class;
    D.36173 = (gboolean) D.36174;
    return D.36173;
    <D.36172>:
    D.36175 = is_corlib_type (class);
    if (D.36175 != 0) goto <D.36176>; else goto <D.36177>;
    <D.36176>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 28;
      if (__s1_len <= 3) goto <D.36179>; else goto <D.36180>;
      <D.36179>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36181 = "ConstructorOnTypeBuilderInst";
        D.36182 = MEM[(const unsigned char *)D.36181];
        D.36183 = (int) D.36182;
        D.36184 = *__s2;
        D.36185 = (int) D.36184;
        __result = D.36183 - D.36185;
        {
          D.36186 = __s1_len != 0;
          D.36187 = __result == 0;
          D.36188 = D.36186 & D.36187;
          if (D.36188 != 0) goto <D.36189>; else goto <D.36190>;
          <D.36189>:
          D.36191 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
          D.36192 = *D.36191;
          D.36193 = (int) D.36192;
          D.36194 = __s2 + 1;
          D.36195 = *D.36194;
          D.36196 = (int) D.36195;
          __result = D.36193 - D.36196;
          D.36197 = __s1_len > 1;
          D.36187 = __result == 0;
          D.36198 = D.36197 & D.36187;
          if (D.36198 != 0) goto <D.36199>; else goto <D.36200>;
          <D.36199>:
          D.36201 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
          D.36202 = *D.36201;
          D.36203 = (int) D.36202;
          D.36204 = __s2 + 2;
          D.36205 = *D.36204;
          D.36206 = (int) D.36205;
          __result = D.36203 - D.36206;
          D.36207 = __s1_len > 2;
          D.36187 = __result == 0;
          D.36208 = D.36207 & D.36187;
          if (D.36208 != 0) goto <D.36209>; else goto <D.36210>;
          <D.36209>:
          D.36211 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
          D.36212 = *D.36211;
          D.36213 = (int) D.36212;
          D.36214 = __s2 + 3;
          D.36215 = *D.36214;
          D.36216 = (int) D.36215;
          __result = D.36213 - D.36216;
          <D.36210>:
          <D.36200>:
          <D.36190>:
        }
        D.22330 = __result;
      }
      iftmp.595 = D.22330;
      goto <D.36217>;
      <D.36180>:
      D.36218 = class->name;
      iftmp.595 = __builtin_strcmp ("ConstructorOnTypeBuilderInst", D.36218);
      <D.36217>:
      D.22334 = iftmp.595;
    }
    if (D.22334 == 0) goto <D.36219>; else goto <D.36220>;
    <D.36219>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36224 = "System.Reflection.Emit";
        D.36225 = MEM[(const unsigned char *)D.36224];
        D.36226 = (int) D.36225;
        D.36227 = *__s2;
        D.36228 = (int) D.36227;
        __result = D.36226 - D.36228;
        {
          D.36229 = __s1_len != 0;
          D.36230 = __result == 0;
          D.36231 = D.36229 & D.36230;
          if (D.36231 != 0) goto <D.36232>; else goto <D.36233>;
          <D.36232>:
          D.36234 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.36235 = *D.36234;
          D.36236 = (int) D.36235;
          D.36237 = __s2 + 1;
          D.36238 = *D.36237;
          D.36239 = (int) D.36238;
          __result = D.36236 - D.36239;
          D.36240 = __s1_len > 1;
          D.36230 = __result == 0;
          D.36241 = D.36240 & D.36230;
          if (D.36241 != 0) goto <D.36242>; else goto <D.36243>;
          <D.36242>:
          D.36244 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.36245 = *D.36244;
          D.36246 = (int) D.36245;
          D.36247 = __s2 + 2;
          D.36248 = *D.36247;
          D.36249 = (int) D.36248;
          __result = D.36246 - D.36249;
          D.36250 = __s1_len > 2;
          D.36230 = __result == 0;
          D.36251 = D.36250 & D.36230;
          if (D.36251 != 0) goto <D.36252>; else goto <D.36253>;
          <D.36252>:
          D.36254 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.36255 = *D.36254;
          D.36256 = (int) D.36255;
          D.36257 = __s2 + 3;
          D.36258 = *D.36257;
          D.36259 = (int) D.36258;
          __result = D.36256 - D.36259;
          <D.36253>:
          <D.36243>:
          <D.36233>:
        }
        D.22339 = __result;
      }
      iftmp.596 = D.22339;
      goto <D.36260>;
      <D.36223>:
      D.36261 = class->name_space;
      iftmp.596 = __builtin_strcmp ("System.Reflection.Emit", D.36261);
      <D.36260>:
      D.22343 = iftmp.596;
    }
    if (D.22343 == 0) goto <D.36262>; else goto <D.36263>;
    <D.36262>:
    cached_class = class;
    D.36173 = 1;
    return D.36173;
    <D.36263>:
    <D.36220>:
    <D.36177>:
    D.36173 = 0;
    return D.36173;
  }
}


mono_reflection_get_custom_attrs_by_type (struct MonoObject * obj, struct MonoClass * attr_klass, struct MonoError * error)
{
  int D.36267;
  struct MonoLoaderError * D.36271;
  struct MonoArray * D.36274;
  struct MonoClass * D.22106;
  struct MonoClass * tmp_klass.597;
  struct MonoClass * D.36278;
  struct MonoClass * tmp_klass.598;
  _Bool D.36280;
  long int D.36281;
  long int D.36282;
  struct MonoDomain * D.36285;
  struct MonoVTable * D.36286;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  mono_error_init (error);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36265>; else goto <D.36266>;
  <D.36265>:
  result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
  D.36267 = cinfo->cached;
  if (D.36267 == 0) goto <D.36268>; else goto <D.36269>;
  <D.36268>:
  mono_custom_attrs_free (cinfo);
  <D.36269>:
  goto <D.36270>;
  <D.36266>:
  D.36271 = mono_loader_get_last_error ();
  if (D.36271 != 0B) goto <D.36272>; else goto <D.36273>;
  <D.36272>:
  D.36274 = 0B;
  return D.36274;
  <D.36273>:
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.597 = tmp_klass;
      if (tmp_klass.597 == 0B) goto <D.36276>; else goto <D.36277>;
      <D.36276>:
      D.36278 = mono_defaults.attribute_class;
      tmp_klass.598 = mono_array_class_get (D.36278, 1);
      tmp_klass = tmp_klass.598;
      tmp_klass.597 = tmp_klass;
      D.36280 = tmp_klass.597 == 0B;
      D.36281 = (long int) D.36280;
      D.36282 = __builtin_expect (D.36281, 0);
      if (D.36282 != 0) goto <D.36283>; else goto <D.36284>;
      <D.36283>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8971, "tmp_klass");
      <D.36284>:
      <D.36277>:
    }
    D.22106 = tmp_klass;
  }
  D.36285 = mono_domain_get ();
  D.36286 = mono_class_vtable (D.36285, D.22106);
  result = mono_array_new_specific (D.36286, 0);
  <D.36270>:
  D.36274 = result;
  return D.36274;
}


mono_reflection_get_custom_attrs (struct MonoObject * obj)
{
  struct MonoArray * D.36288;
  struct MonoError error;

  try
    {
      D.36288 = mono_reflection_get_custom_attrs_by_type (obj, 0B, &error);
      return D.36288;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_get_custom_attrs_data (struct MonoObject * obj)
{
  int D.36293;
  struct MonoClass * D.36297;
  struct MonoDomain * D.36298;
  struct MonoArray * D.36299;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36291>; else goto <D.36292>;
  <D.36291>:
  result = mono_custom_attrs_data_construct (cinfo);
  D.36293 = cinfo->cached;
  if (D.36293 == 0) goto <D.36294>; else goto <D.36295>;
  <D.36294>:
  mono_custom_attrs_free (cinfo);
  <D.36295>:
  goto <D.36296>;
  <D.36292>:
  D.36297 = mono_defaults.customattribute_data_class;
  D.36298 = mono_domain_get ();
  result = mono_array_new (D.36298, D.36297, 0);
  <D.36296>:
  D.36299 = result;
  return D.36299;
}


mono_custom_attrs_data_construct (struct MonoCustomAttrInfo * cinfo)
{
  int D.36301;
  unsigned int D.36302;
  struct MonoClass * D.36303;
  struct MonoDomain * D.36304;
  struct MonoCustomAttrEntry * D.36305;
  struct MonoImage * D.36306;
  unsigned int i.599;
  struct MonoArray * D.36308;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;

  D.36301 = cinfo->num_attrs;
  D.36302 = (unsigned int) D.36301;
  D.36303 = mono_defaults.customattribute_data_class;
  D.36304 = mono_domain_get ();
  result = mono_array_new (D.36304, D.36303, D.36302);
  i = 0;
  goto <D.21788>;
  <D.21787>:
  D.36305 = &cinfo->attrs[i];
  D.36306 = cinfo->image;
  attr = create_custom_attr_data (D.36306, D.36305);
  {
    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.21788>:
  D.36301 = cinfo->num_attrs;
  if (D.36301 > i) goto <D.21787>; else goto <D.21789>;
  <D.21789>:
  D.36308 = result;
  return D.36308;
}


create_custom_attr_data (struct MonoImage * image, struct MonoCustomAttrEntry * cattr)
{
  struct MonoAssembly * D.36310;
  _Bool D.36311;
  long int D.36312;
  long int D.36313;
  struct MonoMethod * ctor.600;
  struct MonoClass * D.36319;
  struct MonoMethod * ctor.601;
  struct MonoMethod * D.36321;
  struct MonoReflectionMethod * D.36322;
  struct MonoReflectionAssembly * D.36323;
  const mono_byte * * D.36324;
  uint32_t * D.36325;
  struct MonoObject * D.36326;
  static struct MonoMethod * ctor;
  struct MonoDomain * domain;
  struct MonoObject * attr;
  void * params[4];

  try
    {
      D.36310 = image->assembly;
      D.36311 = D.36310 == 0B;
      D.36312 = (long int) D.36311;
      D.36313 = __builtin_expect (D.36312, 0);
      if (D.36313 != 0) goto <D.36314>; else goto <D.36315>;
      <D.36314>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8461, "image->assembly");
      <D.36315>:
      ctor.600 = ctor;
      if (ctor.600 == 0B) goto <D.36317>; else goto <D.36318>;
      <D.36317>:
      D.36319 = mono_defaults.customattribute_data_class;
      ctor.601 = mono_class_get_method_from_name (D.36319, ".ctor", 4);
      ctor = ctor.601;
      <D.36318>:
      domain = mono_domain_get ();
      D.36319 = mono_defaults.customattribute_data_class;
      attr = mono_object_new (domain, D.36319);
      D.36321 = cattr->ctor;
      D.36322 = mono_method_get_object (domain, D.36321, 0B);
      params[0] = D.36322;
      D.36310 = image->assembly;
      D.36323 = mono_assembly_get_object (domain, D.36310);
      params[1] = D.36323;
      D.36324 = &cattr->data;
      params[2] = D.36324;
      D.36325 = &cattr->data_size;
      params[3] = D.36325;
      ctor.600 = ctor;
      mono_runtime_invoke (ctor.600, attr, &params, 0B);
      D.36326 = attr;
      return D.36326;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_reflection_type_get_handle (struct MonoReflectionType * ref)
{
  struct MonoType * D.36331;
  struct MonoType * D.36332;
  int D.36335;
  int D.36341;
  struct MonoVTable * D.36344;
  int D.36345;
  struct MonoReflectionType * D.36348;
  _Bool D.36349;
  long int D.36350;
  long int D.36351;
  int D.36354;
  struct MonoClass * D.36357;
  struct MonoClass * D.36358;
  unsigned int D.36360;
  struct MonoClass * D.36361;
  struct MonoClass * D.36362;
  int D.36363;
  struct MonoReflectionType * D.36366;
  _Bool D.36367;
  long int D.36368;
  long int D.36369;
  struct MonoClass * D.36372;
  int D.36373;
  struct MonoReflectionType * D.36376;
  _Bool D.36377;
  long int D.36378;
  long int D.36379;
  struct MonoClass * D.36382;
  int D.36383;
  struct MonoArray * D.36386;
  unsigned int D.36387;
  unsigned int count.602;
  unsigned int D.36389;
  unsigned int i.603;
  char * D.36391;
  unsigned int i.604;
  unsigned int D.36393;
  struct MonoType * * D.36394;
  struct MonoType * D.36395;
  struct MonoType * D.36396;
  struct MonoReflectionType * D.36399;
  _Bool D.36400;
  long int D.36401;
  long int D.36402;
  struct MonoClass * D.36405;
  struct MonoType * D.36406;
  char * D.36407;
  struct MonoClass * class;

  if (ref == 0B) goto <D.36329>; else goto <D.36330>;
  <D.36329>:
  D.36331 = 0B;
  return D.36331;
  <D.36330>:
  D.36332 = ref->type;
  if (D.36332 != 0B) goto <D.36333>; else goto <D.36334>;
  <D.36333>:
  D.36331 = ref->type;
  return D.36331;
  <D.36334>:
  D.36335 = is_usertype (ref);
  if (D.36335 != 0) goto <D.36336>; else goto <D.36337>;
  <D.36336>:
  ref = mono_reflection_type_get_underlying_system_type (ref);
  if (ref == 0B) goto <D.36338>; else goto <D.36340>;
  <D.36340>:
  D.36341 = is_usertype (ref);
  if (D.36341 != 0) goto <D.36338>; else goto <D.36339>;
  <D.36338>:
  D.36331 = 0B;
  return D.36331;
  <D.36339>:
  D.36332 = ref->type;
  if (D.36332 != 0B) goto <D.36342>; else goto <D.36343>;
  <D.36342>:
  D.36331 = ref->type;
  return D.36331;
  <D.36343>:
  <D.36337>:
  D.36344 = MEM[(struct MonoObject *)ref].vtable;
  class = D.36344->klass;
  D.36345 = is_sre_array (class);
  if (D.36345 != 0) goto <D.36346>; else goto <D.36347>;
  <D.36346>:
  {
    struct MonoType * res;
    struct MonoReflectionArrayType * sre_array;
    struct MonoType * base;

    sre_array = ref;
    D.36348 = sre_array->element_type;
    base = mono_reflection_type_get_handle (D.36348);
    D.36349 = base == 0B;
    D.36350 = (long int) D.36349;
    D.36351 = __builtin_expect (D.36350, 0);
    if (D.36351 != 0) goto <D.36352>; else goto <D.36353>;
    <D.36352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9133, "base");
    <D.36353>:
    D.36354 = sre_array->rank;
    if (D.36354 == 0) goto <D.36355>; else goto <D.36356>;
    <D.36355>:
    D.36357 = mono_class_from_mono_type (base);
    D.36358 = mono_array_class_get (D.36357, 1);
    res = &D.36358->byval_arg;
    goto <D.36359>;
    <D.36356>:
    D.36354 = sre_array->rank;
    D.36360 = (unsigned int) D.36354;
    D.36361 = mono_class_from_mono_type (base);
    D.36362 = mono_bounded_array_class_get (D.36361, D.36360, 1);
    res = &D.36362->byval_arg;
    <D.36359>:
    sre_array->type.type = res;
    D.36331 = res;
    return D.36331;
  }
  <D.36347>:
  D.36363 = is_sre_byref (class);
  if (D.36363 != 0) goto <D.36364>; else goto <D.36365>;
  <D.36364>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_byref;
    struct MonoType * base;

    sre_byref = ref;
    D.36366 = sre_byref->element_type;
    base = mono_reflection_type_get_handle (D.36366);
    D.36367 = base == 0B;
    D.36368 = (long int) D.36367;
    D.36369 = __builtin_expect (D.36368, 0);
    if (D.36369 != 0) goto <D.36370>; else goto <D.36371>;
    <D.36370>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9144, "base");
    <D.36371>:
    D.36372 = mono_class_from_mono_type (base);
    res = &D.36372->this_arg;
    sre_byref->type.type = res;
    D.36331 = res;
    return D.36331;
  }
  <D.36365>:
  D.36373 = is_sre_pointer (class);
  if (D.36373 != 0) goto <D.36374>; else goto <D.36375>;
  <D.36374>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_pointer;
    struct MonoType * base;

    sre_pointer = ref;
    D.36376 = sre_pointer->element_type;
    base = mono_reflection_type_get_handle (D.36376);
    D.36377 = base == 0B;
    D.36378 = (long int) D.36377;
    D.36379 = __builtin_expect (D.36378, 0);
    if (D.36379 != 0) goto <D.36380>; else goto <D.36381>;
    <D.36380>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9152, "base");
    <D.36381>:
    D.36382 = mono_ptr_class_get (base);
    res = &D.36382->byval_arg;
    sre_pointer->type.type = res;
    D.36331 = res;
    return D.36331;
  }
  <D.36375>:
  D.36383 = is_sre_generic_instance (class);
  if (D.36383 != 0) goto <D.36384>; else goto <D.36385>;
  <D.36384>:
  {
    struct MonoType * res;
    struct MonoType * * types;
    struct MonoReflectionGenericClass * gclass;
    int i;
    int count;

    gclass = ref;
    D.36386 = gclass->type_arguments;
    D.36387 = mono_array_length (D.36386);
    count = (int) D.36387;
    count.602 = (unsigned int) count;
    D.36389 = count.602 * 4;
    types = monoeg_malloc0 (D.36389);
    i = 0;
    goto <D.22364>;
    <D.22363>:
    {
      struct MonoReflectionType * t;

      i.603 = (unsigned int) i;
      D.36386 = gclass->type_arguments;
      D.36391 = mono_array_addr_with_size (D.36386, 4, i.603);
      t = MEM[(void * *)D.36391];
      i.604 = (unsigned int) i;
      D.36393 = i.604 * 4;
      D.36394 = types + D.36393;
      D.36395 = mono_reflection_type_get_handle (t);
      *D.36394 = D.36395;
      i.604 = (unsigned int) i;
      D.36393 = i.604 * 4;
      D.36394 = types + D.36393;
      D.36396 = *D.36394;
      if (D.36396 == 0B) goto <D.36397>; else goto <D.36398>;
      <D.36397>:
      monoeg_g_free (types);
      D.36331 = 0B;
      return D.36331;
      <D.36398>:
    }
    i = i + 1;
    <D.22364>:
    if (i < count) goto <D.22363>; else goto <D.22365>;
    <D.22365>:
    D.36399 = gclass->generic_type;
    res = mono_reflection_bind_generic_parameters (D.36399, count, types);
    monoeg_g_free (types);
    D.36400 = res == 0B;
    D.36401 = (long int) D.36400;
    D.36402 = __builtin_expect (D.36401, 0);
    if (D.36402 != 0) goto <D.36403>; else goto <D.36404>;
    <D.36403>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9174, "res");
    <D.36404>:
    gclass->type.type = res;
    D.36331 = res;
    return D.36331;
  }
  <D.36385>:
  D.36344 = MEM[(struct MonoObject *)ref].vtable;
  D.36405 = D.36344->klass;
  D.36406 = &D.36405->byval_arg;
  D.36407 = mono_type_full_name (D.36406);
  monoeg_g_log (0B, 4, "Cannot handle corlib user type %s", D.36407);
  <D.22366>:
  goto <D.22366>;
  D.36331 = 0B;
  return D.36331;
}


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.36409;
  struct MonoException * D.36412;
  union mono_mutex_t * D.36413;
  _Bool D.36416;
  long int D.36417;
  long int D.36418;
  struct MonoImage * D.36421;
  unsigned char D.36422;
  unsigned char D.36423;
  struct MonoGHashTable * D.36427;
  struct MonoGHashTable * D.36430;
  _Bool D.36433;
  long int D.36434;
  long int D.36435;
  struct MonoType * res;
  struct MonoDomain * domain;
  struct MonoClass * class;

  res = mono_reflection_type_get_handle (type);
  D.36409 = MEM[(struct MonoObject *)type].vtable;
  domain = D.36409->domain;
  if (res == 0B) goto <D.36410>; else goto <D.36411>;
  <D.36410>:
  D.36412 = mono_get_exception_argument (0B, "Invalid generic instantiation, one or more arguments are not proper user types");
  mono_raise_exception (D.36412);
  <D.36411>:
  class = mono_class_from_mono_type (res);
  mono_loader_lock ();
  {
    int ret;

    D.36413 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.36413);
    if (ret != 0) goto <D.36414>; else goto <D.36415>;
    <D.36414>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.36415>:
    D.36416 = ret != 0;
    D.36417 = (long int) D.36416;
    D.36418 = __builtin_expect (D.36417, 0);
    if (D.36418 != 0) goto <D.36419>; else goto <D.36420>;
    <D.36419>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9204, "ret == 0");
    <D.36420>:
  }
  D.36421 = class->image;
  D.36422 = BIT_FIELD_REF <*D.36421, 8, 128>;
  D.36423 = D.36422 & 8;
  if (D.36423 == 0) goto <D.36424>; else goto <D.36425>;
  <D.36424>:
  mono_class_setup_supertypes (class);
  goto <D.36426>;
  <D.36425>:
  D.36427 = domain->type_hash;
  if (D.36427 == 0B) goto <D.36428>; else goto <D.36429>;
  <D.36428>:
  D.36430 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.36430;
  <D.36429>:
  D.36427 = domain->type_hash;
  mono_g_hash_table_insert (D.36427, res, type);
  <D.36426>:
  {
    int ret;

    D.36413 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.36413);
    if (ret != 0) goto <D.36431>; else goto <D.36432>;
    <D.36431>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.36432>:
    D.36433 = ret != 0;
    D.36434 = (long int) D.36433;
    D.36435 = __builtin_expect (D.36434, 0);
    if (D.36435 != 0) goto <D.36436>; else goto <D.36437>;
    <D.36436>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9214, "ret == 0");
    <D.36437>:
  }
  mono_loader_unlock ();
}


mono_class_is_reflection_method_or_constructor (struct MonoClass * class)
{
  gboolean D.36438;
  int iftmp.605;
  int D.36443;
  int D.36445;
  int D.36447;
  int D.36449;

  D.36443 = is_sr_mono_method (class);
  if (D.36443 != 0) goto <D.36440>; else goto <D.36444>;
  <D.36444>:
  D.36445 = is_sr_mono_cmethod (class);
  if (D.36445 != 0) goto <D.36440>; else goto <D.36446>;
  <D.36446>:
  D.36447 = is_sr_mono_generic_method (class);
  if (D.36447 != 0) goto <D.36440>; else goto <D.36448>;
  <D.36448>:
  D.36449 = is_sr_mono_generic_cmethod (class);
  if (D.36449 != 0) goto <D.36440>; else goto <D.36441>;
  <D.36440>:
  iftmp.605 = 1;
  goto <D.36442>;
  <D.36441>:
  iftmp.605 = 0;
  <D.36442>:
  D.36438 = iftmp.605;
  return D.36438;
}


is_sr_mono_generic_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.606;
  gboolean D.36454;
  _Bool D.36455;
  int D.36456;
  int D.22536;
  int iftmp.607;
  int D.22532;
  const char[18] * D.36462;
  unsigned char D.36463;
  int D.36464;
  unsigned char D.36465;
  int D.36466;
  _Bool D.36467;
  _Bool D.36468;
  _Bool D.36469;
  const unsigned char * D.36472;
  unsigned char D.36473;
  int D.36474;
  const unsigned char * D.36475;
  unsigned char D.36476;
  int D.36477;
  _Bool D.36478;
  _Bool D.36479;
  const unsigned char * D.36482;
  unsigned char D.36483;
  int D.36484;
  const unsigned char * D.36485;
  unsigned char D.36486;
  int D.36487;
  _Bool D.36488;
  _Bool D.36489;
  const unsigned char * D.36492;
  unsigned char D.36493;
  int D.36494;
  const unsigned char * D.36495;
  unsigned char D.36496;
  int D.36497;
  const char * D.36499;
  int D.22545;
  int iftmp.608;
  int D.22541;
  const char[18] * D.36505;
  unsigned char D.36506;
  int D.36507;
  unsigned char D.36508;
  int D.36509;
  _Bool D.36510;
  _Bool D.36511;
  _Bool D.36512;
  const unsigned char * D.36515;
  unsigned char D.36516;
  int D.36517;
  const unsigned char * D.36518;
  unsigned char D.36519;
  int D.36520;
  _Bool D.36521;
  _Bool D.36522;
  const unsigned char * D.36525;
  unsigned char D.36526;
  int D.36527;
  const unsigned char * D.36528;
  unsigned char D.36529;
  int D.36530;
  _Bool D.36531;
  _Bool D.36532;
  const unsigned char * D.36535;
  unsigned char D.36536;
  int D.36537;
  const unsigned char * D.36538;
  unsigned char D.36539;
  int D.36540;
  const char * D.36542;

  {
    static struct MonoClass * cached_class;

    cached_class.606 = cached_class;
    if (cached_class.606 != 0B) goto <D.36452>; else goto <D.36453>;
    <D.36452>:
    cached_class.606 = cached_class;
    D.36455 = cached_class.606 == class;
    D.36454 = (gboolean) D.36455;
    return D.36454;
    <D.36453>:
    D.36456 = is_corlib_type (class);
    if (D.36456 != 0) goto <D.36457>; else goto <D.36458>;
    <D.36457>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.36462 = "MonoGenericMethod";
        D.36463 = MEM[(const unsigned char *)D.36462];
        D.36464 = (int) D.36463;
        D.36465 = *__s2;
        D.36466 = (int) D.36465;
        __result = D.36464 - D.36466;
        {
          D.36467 = __s1_len != 0;
          D.36468 = __result == 0;
          D.36469 = D.36467 & D.36468;
          if (D.36469 != 0) goto <D.36470>; else goto <D.36471>;
          <D.36470>:
          D.36472 = &MEM[(void *)"MonoGenericMethod" + 1B];
          D.36473 = *D.36472;
          D.36474 = (int) D.36473;
          D.36475 = __s2 + 1;
          D.36476 = *D.36475;
          D.36477 = (int) D.36476;
          __result = D.36474 - D.36477;
          D.36478 = __s1_len > 1;
          D.36468 = __result == 0;
          D.36479 = D.36478 & D.36468;
          if (D.36479 != 0) goto <D.36480>; else goto <D.36481>;
          <D.36480>:
          D.36482 = &MEM[(void *)"MonoGenericMethod" + 2B];
          D.36483 = *D.36482;
          D.36484 = (int) D.36483;
          D.36485 = __s2 + 2;
          D.36486 = *D.36485;
          D.36487 = (int) D.36486;
          __result = D.36484 - D.36487;
          D.36488 = __s1_len > 2;
          D.36468 = __result == 0;
          D.36489 = D.36488 & D.36468;
          if (D.36489 != 0) goto <D.36490>; else goto <D.36491>;
          <D.36490>:
          D.36492 = &MEM[(void *)"MonoGenericMethod" + 3B];
          D.36493 = *D.36492;
          D.36494 = (int) D.36493;
          D.36495 = __s2 + 3;
          D.36496 = *D.36495;
          D.36497 = (int) D.36496;
          __result = D.36494 - D.36497;
          <D.36491>:
          <D.36481>:
          <D.36471>:
        }
        D.22532 = __result;
      }
      iftmp.607 = D.22532;
      goto <D.36498>;
      <D.36461>:
      D.36499 = class->name;
      iftmp.607 = __builtin_strcmp ("MonoGenericMethod", D.36499);
      <D.36498>:
      D.22536 = iftmp.607;
    }
    if (D.22536 == 0) goto <D.36500>; else goto <D.36501>;
    <D.36500>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36505 = "System.Reflection";
        D.36506 = MEM[(const unsigned char *)D.36505];
        D.36507 = (int) D.36506;
        D.36508 = *__s2;
        D.36509 = (int) D.36508;
        __result = D.36507 - D.36509;
        {
          D.36510 = __s1_len != 0;
          D.36511 = __result == 0;
          D.36512 = D.36510 & D.36511;
          if (D.36512 != 0) goto <D.36513>; else goto <D.36514>;
          <D.36513>:
          D.36515 = &MEM[(void *)"System.Reflection" + 1B];
          D.36516 = *D.36515;
          D.36517 = (int) D.36516;
          D.36518 = __s2 + 1;
          D.36519 = *D.36518;
          D.36520 = (int) D.36519;
          __result = D.36517 - D.36520;
          D.36521 = __s1_len > 1;
          D.36511 = __result == 0;
          D.36522 = D.36521 & D.36511;
          if (D.36522 != 0) goto <D.36523>; else goto <D.36524>;
          <D.36523>:
          D.36525 = &MEM[(void *)"System.Reflection" + 2B];
          D.36526 = *D.36525;
          D.36527 = (int) D.36526;
          D.36528 = __s2 + 2;
          D.36529 = *D.36528;
          D.36530 = (int) D.36529;
          __result = D.36527 - D.36530;
          D.36531 = __s1_len > 2;
          D.36511 = __result == 0;
          D.36532 = D.36531 & D.36511;
          if (D.36532 != 0) goto <D.36533>; else goto <D.36534>;
          <D.36533>:
          D.36535 = &MEM[(void *)"System.Reflection" + 3B];
          D.36536 = *D.36535;
          D.36537 = (int) D.36536;
          D.36538 = __s2 + 3;
          D.36539 = *D.36538;
          D.36540 = (int) D.36539;
          __result = D.36537 - D.36540;
          <D.36534>:
          <D.36524>:
          <D.36514>:
        }
        D.22541 = __result;
      }
      iftmp.608 = D.22541;
      goto <D.36541>;
      <D.36504>:
      D.36542 = class->name_space;
      iftmp.608 = __builtin_strcmp ("System.Reflection", D.36542);
      <D.36541>:
      D.22545 = iftmp.608;
    }
    if (D.22545 == 0) goto <D.36543>; else goto <D.36544>;
    <D.36543>:
    cached_class = class;
    D.36454 = 1;
    return D.36454;
    <D.36544>:
    <D.36501>:
    <D.36458>:
    D.36454 = 0;
    return D.36454;
  }
}


is_sr_mono_generic_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.609;
  gboolean D.36549;
  _Bool D.36550;
  int D.36551;
  int D.22558;
  int iftmp.610;
  int D.22554;
  const char[19] * D.36557;
  unsigned char D.36558;
  int D.36559;
  unsigned char D.36560;
  int D.36561;
  _Bool D.36562;
  _Bool D.36563;
  _Bool D.36564;
  const unsigned char * D.36567;
  unsigned char D.36568;
  int D.36569;
  const unsigned char * D.36570;
  unsigned char D.36571;
  int D.36572;
  _Bool D.36573;
  _Bool D.36574;
  const unsigned char * D.36577;
  unsigned char D.36578;
  int D.36579;
  const unsigned char * D.36580;
  unsigned char D.36581;
  int D.36582;
  _Bool D.36583;
  _Bool D.36584;
  const unsigned char * D.36587;
  unsigned char D.36588;
  int D.36589;
  const unsigned char * D.36590;
  unsigned char D.36591;
  int D.36592;
  const char * D.36594;
  int D.22567;
  int iftmp.611;
  int D.22563;
  const char[18] * D.36600;
  unsigned char D.36601;
  int D.36602;
  unsigned char D.36603;
  int D.36604;
  _Bool D.36605;
  _Bool D.36606;
  _Bool D.36607;
  const unsigned char * D.36610;
  unsigned char D.36611;
  int D.36612;
  const unsigned char * D.36613;
  unsigned char D.36614;
  int D.36615;
  _Bool D.36616;
  _Bool D.36617;
  const unsigned char * D.36620;
  unsigned char D.36621;
  int D.36622;
  const unsigned char * D.36623;
  unsigned char D.36624;
  int D.36625;
  _Bool D.36626;
  _Bool D.36627;
  const unsigned char * D.36630;
  unsigned char D.36631;
  int D.36632;
  const unsigned char * D.36633;
  unsigned char D.36634;
  int D.36635;
  const char * D.36637;

  {
    static struct MonoClass * cached_class;

    cached_class.609 = cached_class;
    if (cached_class.609 != 0B) goto <D.36547>; else goto <D.36548>;
    <D.36547>:
    cached_class.609 = cached_class;
    D.36550 = cached_class.609 == class;
    D.36549 = (gboolean) D.36550;
    return D.36549;
    <D.36548>:
    D.36551 = is_corlib_type (class);
    if (D.36551 != 0) goto <D.36552>; else goto <D.36553>;
    <D.36552>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.36557 = "MonoGenericCMethod";
        D.36558 = MEM[(const unsigned char *)D.36557];
        D.36559 = (int) D.36558;
        D.36560 = *__s2;
        D.36561 = (int) D.36560;
        __result = D.36559 - D.36561;
        {
          D.36562 = __s1_len != 0;
          D.36563 = __result == 0;
          D.36564 = D.36562 & D.36563;
          if (D.36564 != 0) goto <D.36565>; else goto <D.36566>;
          <D.36565>:
          D.36567 = &MEM[(void *)"MonoGenericCMethod" + 1B];
          D.36568 = *D.36567;
          D.36569 = (int) D.36568;
          D.36570 = __s2 + 1;
          D.36571 = *D.36570;
          D.36572 = (int) D.36571;
          __result = D.36569 - D.36572;
          D.36573 = __s1_len > 1;
          D.36563 = __result == 0;
          D.36574 = D.36573 & D.36563;
          if (D.36574 != 0) goto <D.36575>; else goto <D.36576>;
          <D.36575>:
          D.36577 = &MEM[(void *)"MonoGenericCMethod" + 2B];
          D.36578 = *D.36577;
          D.36579 = (int) D.36578;
          D.36580 = __s2 + 2;
          D.36581 = *D.36580;
          D.36582 = (int) D.36581;
          __result = D.36579 - D.36582;
          D.36583 = __s1_len > 2;
          D.36563 = __result == 0;
          D.36584 = D.36583 & D.36563;
          if (D.36584 != 0) goto <D.36585>; else goto <D.36586>;
          <D.36585>:
          D.36587 = &MEM[(void *)"MonoGenericCMethod" + 3B];
          D.36588 = *D.36587;
          D.36589 = (int) D.36588;
          D.36590 = __s2 + 3;
          D.36591 = *D.36590;
          D.36592 = (int) D.36591;
          __result = D.36589 - D.36592;
          <D.36586>:
          <D.36576>:
          <D.36566>:
        }
        D.22554 = __result;
      }
      iftmp.610 = D.22554;
      goto <D.36593>;
      <D.36556>:
      D.36594 = class->name;
      iftmp.610 = __builtin_strcmp ("MonoGenericCMethod", D.36594);
      <D.36593>:
      D.22558 = iftmp.610;
    }
    if (D.22558 == 0) goto <D.36595>; else goto <D.36596>;
    <D.36595>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36600 = "System.Reflection";
        D.36601 = MEM[(const unsigned char *)D.36600];
        D.36602 = (int) D.36601;
        D.36603 = *__s2;
        D.36604 = (int) D.36603;
        __result = D.36602 - D.36604;
        {
          D.36605 = __s1_len != 0;
          D.36606 = __result == 0;
          D.36607 = D.36605 & D.36606;
          if (D.36607 != 0) goto <D.36608>; else goto <D.36609>;
          <D.36608>:
          D.36610 = &MEM[(void *)"System.Reflection" + 1B];
          D.36611 = *D.36610;
          D.36612 = (int) D.36611;
          D.36613 = __s2 + 1;
          D.36614 = *D.36613;
          D.36615 = (int) D.36614;
          __result = D.36612 - D.36615;
          D.36616 = __s1_len > 1;
          D.36606 = __result == 0;
          D.36617 = D.36616 & D.36606;
          if (D.36617 != 0) goto <D.36618>; else goto <D.36619>;
          <D.36618>:
          D.36620 = &MEM[(void *)"System.Reflection" + 2B];
          D.36621 = *D.36620;
          D.36622 = (int) D.36621;
          D.36623 = __s2 + 2;
          D.36624 = *D.36623;
          D.36625 = (int) D.36624;
          __result = D.36622 - D.36625;
          D.36626 = __s1_len > 2;
          D.36606 = __result == 0;
          D.36627 = D.36626 & D.36606;
          if (D.36627 != 0) goto <D.36628>; else goto <D.36629>;
          <D.36628>:
          D.36630 = &MEM[(void *)"System.Reflection" + 3B];
          D.36631 = *D.36630;
          D.36632 = (int) D.36631;
          D.36633 = __s2 + 3;
          D.36634 = *D.36633;
          D.36635 = (int) D.36634;
          __result = D.36632 - D.36635;
          <D.36629>:
          <D.36619>:
          <D.36609>:
        }
        D.22563 = __result;
      }
      iftmp.611 = D.22563;
      goto <D.36636>;
      <D.36599>:
      D.36637 = class->name_space;
      iftmp.611 = __builtin_strcmp ("System.Reflection", D.36637);
      <D.36636>:
      D.22567 = iftmp.611;
    }
    if (D.22567 == 0) goto <D.36638>; else goto <D.36639>;
    <D.36638>:
    cached_class = class;
    D.36549 = 1;
    return D.36549;
    <D.36639>:
    <D.36596>:
    <D.36553>:
    D.36549 = 0;
    return D.36549;
  }
}


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.22696;
  int iftmp.612;
  int D.22695;
  struct MonoVTable * D.36644;
  struct MonoClass * D.36645;
  const char[12] * D.36646;
  unsigned char D.36647;
  int D.36648;
  unsigned char D.36649;
  int D.36650;
  _Bool D.36651;
  _Bool D.36652;
  _Bool D.36653;
  const unsigned char * D.36656;
  unsigned char D.36657;
  int D.36658;
  const unsigned char * D.36659;
  unsigned char D.36660;
  int D.36661;
  _Bool D.36662;
  _Bool D.36663;
  const unsigned char * D.36666;
  unsigned char D.36667;
  int D.36668;
  const unsigned char * D.36669;
  unsigned char D.36670;
  int D.36671;
  _Bool D.36672;
  _Bool D.36673;
  const unsigned char * D.36676;
  unsigned char D.36677;
  int D.36678;
  const unsigned char * D.36679;
  unsigned char D.36680;
  int D.36681;
  const char * D.36683;
  struct MonoMethod * D.36687;
  unsigned int D.36688;
  short unsigned int D.36689;
  unsigned int D.36690;
  _Bool D.36691;
  long int D.36692;
  long int D.36693;
  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.36704;
  struct MonoType * D.36705;
  struct MonoAssembly * D.36706;
  unsigned int D.36707;
  unsigned int D.36710;
  unsigned int D.36713;
  char * p.621;
  char * p.622;
  char D.36716;
  char * p.623;
  char * p.624;
  unsigned int D.36719;
  char D.36720;
  char * D.36723;
  char * p.625;
  char * p.626;
  char * D.36726;
  void * D.36727;
  char * pname.627;
  struct MonoType * ptype.628;
  unsigned int D.36730;
  char * D.36733;
  char * p.629;
  char * p.630;
  char * D.36736;
  void * D.36737;
  char * fname.631;
  struct MonoType * ftype.632;
  unsigned int D.36740;
  int p.633;
  int buffer.634;
  int D.36743;
  unsigned int buflen.635;
  _Bool D.36745;
  long int D.36746;
  long int D.36747;
  struct MonoClass * D.36750;
  struct MonoDomain * D.36751;
  char * p.636;
  int D.22720;
  int iftmp.637;
  int D.22719;
  unsigned char D.36756;
  int D.36757;
  _Bool D.36758;
  _Bool D.36759;
  _Bool D.36760;
  const unsigned char * D.36763;
  unsigned char D.36764;
  int D.36765;
  _Bool D.36766;
  _Bool D.36767;
  const unsigned char * D.36770;
  unsigned char D.36771;
  int D.36772;
  _Bool D.36773;
  _Bool D.36774;
  const unsigned char * D.36777;
  unsigned char D.36778;
  int D.36779;
  struct MonoArray * D.36783;
  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.36642>; else goto <D.36643>;
        <D.36642>:
        {
          const unsigned char * __s2;
          int __result;

          D.36644 = ctor->vtable;
          D.36645 = D.36644->klass;
          __s2 = D.36645->name;
          D.36646 = "MonoCMethod";
          D.36647 = MEM[(const unsigned char *)D.36646];
          D.36648 = (int) D.36647;
          D.36649 = *__s2;
          D.36650 = (int) D.36649;
          __result = D.36648 - D.36650;
          {
            D.36651 = __s2_len != 0;
            D.36652 = __result == 0;
            D.36653 = D.36651 & D.36652;
            if (D.36653 != 0) goto <D.36654>; else goto <D.36655>;
            <D.36654>:
            D.36656 = &MEM[(void *)"MonoCMethod" + 1B];
            D.36657 = *D.36656;
            D.36658 = (int) D.36657;
            D.36659 = __s2 + 1;
            D.36660 = *D.36659;
            D.36661 = (int) D.36660;
            __result = D.36658 - D.36661;
            D.36662 = __s2_len > 1;
            D.36652 = __result == 0;
            D.36663 = D.36662 & D.36652;
            if (D.36663 != 0) goto <D.36664>; else goto <D.36665>;
            <D.36664>:
            D.36666 = &MEM[(void *)"MonoCMethod" + 2B];
            D.36667 = *D.36666;
            D.36668 = (int) D.36667;
            D.36669 = __s2 + 2;
            D.36670 = *D.36669;
            D.36671 = (int) D.36670;
            __result = D.36668 - D.36671;
            D.36672 = __s2_len > 2;
            D.36652 = __result == 0;
            D.36673 = D.36672 & D.36652;
            if (D.36673 != 0) goto <D.36674>; else goto <D.36675>;
            <D.36674>:
            D.36676 = &MEM[(void *)"MonoCMethod" + 3B];
            D.36677 = *D.36676;
            D.36678 = (int) D.36677;
            D.36679 = __s2 + 3;
            D.36680 = *D.36679;
            D.36681 = (int) D.36680;
            __result = D.36678 - D.36681;
            <D.36675>:
            <D.36665>:
            <D.36655>:
          }
          D.22695 = __result;
        }
        iftmp.612 = -D.22695;
        goto <D.36682>;
        <D.36643>:
        D.36644 = ctor->vtable;
        D.36645 = D.36644->klass;
        D.36683 = D.36645->name;
        iftmp.612 = __builtin_strcmp (D.36683, "MonoCMethod");
        <D.36682>:
        D.22696 = iftmp.612;
      }
      if (D.22696 != 0) goto <D.36684>; else goto <D.36685>;
      <D.36684>:
      sig = ctor_builder_to_signature (0B, ctor);
      goto <D.36686>;
      <D.36685>:
      D.36687 = MEM[(struct MonoReflectionMethod *)ctor].method;
      sig = mono_method_signature (D.36687);
      <D.36686>:
      D.36688 = mono_array_length (ctorArgs);
      D.36689 = sig->param_count;
      D.36690 = (unsigned int) D.36689;
      D.36691 = D.36688 != D.36690;
      D.36692 = (long int) D.36691;
      D.36693 = __builtin_expect (D.36692, 0);
      if (D.36693 != 0) goto <D.36694>; else goto <D.36695>;
      <D.36694>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9719, "mono_array_length (ctorArgs) == sig->param_count");
      <D.36695>:
      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.22698>;
      <D.22697>:
      D.36704 = mono_array_addr_with_size (ctorArgs, 4, i);
      arg = MEM[(struct MonoObject * *)D.36704];
      D.36705 = sig->params[i];
      p.616 = p;
      buffer.615 = buffer;
      D.36706 = assembly->assembly;
      encode_cattr_value (D.36706, buffer.615, p.616, &buffer, &p, &buflen, D.36705, arg, 0B);
      i = i + 1;
      <D.22698>:
      D.36689 = sig->param_count;
      D.36707 = (unsigned int) D.36689;
      if (D.36707 > i) goto <D.22697>; else goto <D.22699>;
      <D.22699>:
      i = 0;
      if (properties != 0B) goto <D.36708>; else goto <D.36709>;
      <D.36708>:
      D.36710 = mono_array_length (properties);
      i = D.36710 + i;
      <D.36709>:
      if (fields != 0B) goto <D.36711>; else goto <D.36712>;
      <D.36711>:
      D.36713 = mono_array_length (fields);
      i = D.36713 + i;
      <D.36712>:
      p.616 = p;
      p.621 = p.616;
      p.622 = p.621 + 1;
      p = p.622;
      D.36716 = (char) i;
      *p.621 = D.36716;
      p.616 = p;
      p.623 = p.616;
      p.624 = p.623 + 1;
      p = p.624;
      D.36719 = i >> 8;
      D.36720 = (char) D.36719;
      *p.623 = D.36720;
      if (properties != 0B) goto <D.36721>; else goto <D.36722>;
      <D.36721>:
      {
        struct MonoObject * prop;

        i = 0;
        goto <D.22704>;
        <D.22703>:
        {
          struct MonoType * ptype;
          char * pname;

          try
            {
              D.36723 = mono_array_addr_with_size (properties, 4, i);
              prop = MEM[(void * *)D.36723];
              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;
              D.36726 = mono_array_addr_with_size (propValues, 4, i);
              D.36727 = MEM[(void * *)D.36726];
              pname.627 = pname;
              ptype.628 = ptype;
              p.616 = p;
              buffer.615 = buffer;
              encode_named_val (assembly, buffer.615, p.616, &buffer, &p, &buflen, ptype.628, pname.627, D.36727);
              pname.627 = pname;
              monoeg_g_free (pname.627);
            }
          finally
            {
              ptype = {CLOBBER};
              pname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.22704>:
        D.36730 = mono_array_length (properties);
        if (D.36730 > i) goto <D.22703>; else goto <D.22705>;
        <D.22705>:
      }
      <D.36722>:
      if (fields != 0B) goto <D.36731>; else goto <D.36732>;
      <D.36731>:
      {
        struct MonoObject * field;

        i = 0;
        goto <D.22710>;
        <D.22709>:
        {
          struct MonoType * ftype;
          char * fname;

          try
            {
              D.36733 = mono_array_addr_with_size (fields, 4, i);
              field = MEM[(void * *)D.36733];
              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;
              D.36736 = mono_array_addr_with_size (fieldValues, 4, i);
              D.36737 = MEM[(void * *)D.36736];
              fname.631 = fname;
              ftype.632 = ftype;
              p.616 = p;
              buffer.615 = buffer;
              encode_named_val (assembly, buffer.615, p.616, &buffer, &p, &buflen, ftype.632, fname.631, D.36737);
              fname.631 = fname;
              monoeg_g_free (fname.631);
            }
          finally
            {
              ftype = {CLOBBER};
              fname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.22710>:
        D.36740 = mono_array_length (fields);
        if (D.36740 > i) goto <D.22709>; else goto <D.22711>;
        <D.22711>:
      }
      <D.36732>:
      p.616 = p;
      p.633 = (int) p.616;
      buffer.615 = buffer;
      buffer.634 = (int) buffer.615;
      D.36743 = p.633 - buffer.634;
      buflen.635 = (unsigned int) D.36743;
      buflen.613 = buflen;
      D.36745 = buflen.635 > buflen.613;
      D.36746 = (long int) D.36745;
      D.36747 = __builtin_expect (D.36746, 0);
      if (D.36747 != 0) goto <D.36748>; else goto <D.36749>;
      <D.36748>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9764, "p - buffer <= buflen");
      <D.36749>:
      p.616 = p;
      p.633 = (int) p.616;
      buffer.615 = buffer;
      buffer.634 = (int) buffer.615;
      D.36743 = p.633 - buffer.634;
      buflen.635 = (unsigned int) D.36743;
      buflen = buflen.635;
      buflen.613 = buflen;
      D.36750 = mono_defaults.byte_class;
      D.36751 = mono_domain_get ();
      result = mono_array_new (D.36751, D.36750, buflen.613);
      p.636 = mono_array_addr_with_size (result, 1, 0);
      p = p.636;
      buflen.613 = buflen;
      buffer.615 = buffer;
      p.616 = p;
      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.36754>; else goto <D.36755>;
        <D.36754>:
        {
          const unsigned char * __s2;
          int __result;

          D.36644 = ctor->vtable;
          D.36645 = D.36644->klass;
          __s2 = D.36645->name;
          D.36646 = "MonoCMethod";
          D.36647 = MEM[(const unsigned char *)D.36646];
          D.36648 = (int) D.36647;
          D.36756 = *__s2;
          D.36757 = (int) D.36756;
          __result = D.36648 - D.36757;
          {
            D.36758 = __s2_len != 0;
            D.36759 = __result == 0;
            D.36760 = D.36758 & D.36759;
            if (D.36760 != 0) goto <D.36761>; else goto <D.36762>;
            <D.36761>:
            D.36656 = &MEM[(void *)"MonoCMethod" + 1B];
            D.36657 = *D.36656;
            D.36658 = (int) D.36657;
            D.36763 = __s2 + 1;
            D.36764 = *D.36763;
            D.36765 = (int) D.36764;
            __result = D.36658 - D.36765;
            D.36766 = __s2_len > 1;
            D.36759 = __result == 0;
            D.36767 = D.36766 & D.36759;
            if (D.36767 != 0) goto <D.36768>; else goto <D.36769>;
            <D.36768>:
            D.36666 = &MEM[(void *)"MonoCMethod" + 2B];
            D.36667 = *D.36666;
            D.36668 = (int) D.36667;
            D.36770 = __s2 + 2;
            D.36771 = *D.36770;
            D.36772 = (int) D.36771;
            __result = D.36668 - D.36772;
            D.36773 = __s2_len > 2;
            D.36759 = __result == 0;
            D.36774 = D.36773 & D.36759;
            if (D.36774 != 0) goto <D.36775>; else goto <D.36776>;
            <D.36775>:
            D.36676 = &MEM[(void *)"MonoCMethod" + 3B];
            D.36677 = *D.36676;
            D.36678 = (int) D.36677;
            D.36777 = __s2 + 3;
            D.36778 = *D.36777;
            D.36779 = (int) D.36778;
            __result = D.36678 - D.36779;
            <D.36776>:
            <D.36769>:
            <D.36762>:
          }
          D.22719 = __result;
        }
        iftmp.637 = -D.22719;
        goto <D.36780>;
        <D.36755>:
        D.36644 = ctor->vtable;
        D.36645 = D.36644->klass;
        D.36683 = D.36645->name;
        iftmp.637 = __builtin_strcmp (D.36683, "MonoCMethod");
        <D.36780>:
        D.22720 = iftmp.637;
      }
      if (D.22720 != 0) goto <D.36781>; else goto <D.36782>;
      <D.36781>:
      monoeg_g_free (sig);
      <D.36782>:
      D.36783 = result;
      return D.36783;
    }
  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.36790;
  int D.36791;
  unsigned int D.36792;
  unsigned int D.36793;
  unsigned int D.36796;
  sizetype D.36797;
  char * p.642;
  unsigned char D.36801;
  char * p.643;
  char * p.644;
  char D.36804;
  char * p.645;
  char * p.646;
  char * p.647;
  struct MonoClass * D.36808;
  unsigned char D.36809;
  unsigned char D.36810;
  struct MonoType * D.36813;
  unsigned char D.36814;
  const char * D.36815;
  char * p.648;
  char * p.649;
  unsigned int D.36820;
  unsigned int D.36821;
  unsigned int D.36822;
  unsigned int D.36825;
  char * p.650;
  char * p.651;
  char * p.652;
  char * p.653;
  struct MonoType * D.36832;
  unsigned int D.36833;
  unsigned int D.36834;
  unsigned int D.36837;
  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.36850;
  char * p.664;
  char * p.665;
  char D.36853;
  char * p.666;
  char * p.667;
  int D.36856;
  char D.36857;
  char * p.668;
  char * p.669;
  int D.36860;
  char D.36861;
  char * p.670;
  char * p.671;
  unsigned int len.672;
  unsigned int D.36865;
  char D.36866;
  struct MonoVTable * D.36867;
  struct MonoClass * D.36868;
  struct MonoClass * D.36873;
  unsigned char D.36875;
  unsigned char D.36876;
  struct MonoType * D.36878;
  sizetype elsize.673;
  unsigned char D.36881;
  unsigned char D.36882;
  struct MonoType * D.36885;
  sizetype elsize.674;
  unsigned int i.675;
  char * D.36888;
  struct MonoObject * D.36889;
  char * p.676;
  char * p.677;
  char * p.678;
  char * p.679;
  struct MonoClass * D.36896;
  struct MonoObject * D.36897;
  char * p.680;
  char * p.681;
  unsigned char D.36902;
  unsigned char D.36903;
  char * p.682;
  char * p.683;
  struct MonoClass * D.36909;
  char * p.684;
  char * p.685;
  unsigned char D.36914;
  char * p.686;
  char * p.687;
  struct MonoClass * D.36919;
  unsigned char D.36920;
  char * p.688;
  char * p.689;
  char * p.690;
  char * p.691;
  char D.36928;
  struct MonoType * D.36929;
  unsigned char D.36930;
  unsigned char D.36931;
  char * p.692;
  char * p.693;
  char D.36936;
  struct MonoType * D.36937;
  unsigned int D.36938;
  unsigned int D.36939;
  unsigned int D.36942;
  char * p.694;
  char * p.695;
  struct MonoType * D.36945;
  unsigned char D.36946;
  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.36790 = p.639 - buffer.641;
  D.36791 = D.36790 + 10;
  D.36792 = (unsigned int) D.36791;
  D.36793 = *buflen;
  if (D.36792 >= D.36793) goto <D.36794>; else goto <D.36795>;
  <D.36794>:
  {
    char * newbuf;

    D.36793 = *buflen;
    D.36796 = D.36793 * 2;
    *buflen = D.36796;
    D.36793 = *buflen;
    buffer.640 = buffer;
    newbuf = monoeg_realloc (buffer.640, D.36793);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36790 = p.639 - buffer.641;
    D.36797 = (sizetype) D.36790;
    p.642 = newbuf + D.36797;
    p = p.642;
    buffer = newbuf;
  }
  <D.36795>:
  if (argval == 0B) goto <D.36799>; else goto <D.36800>;
  <D.36799>:
  argval = arg + 8;
  <D.36800>:
  D.36801 = type->type;
  simple_type = (MonoTypeEnum) D.36801;
  handle_enum:
  switch (simple_type) <default: <D.22648>, case 2: <D.22601>, case 3: <D.22605>, case 4: <D.22603>, case 5: <D.22602>, case 6: <D.22607>, case 7: <D.22606>, case 8: <D.22609>, case 9: <D.22608>, case 10: <D.22613>, case 11: <D.22612>, case 12: <D.22610>, case 13: <D.22611>, case 14: <D.22615>, case 17: <D.22614>, case 18: <D.22619>, case 28: <D.22642>, case 29: <D.22624>>
  <D.22601>:
  <D.22602>:
  <D.22603>:
  p.638 = p;
  p.643 = p.638;
  p.644 = p.643 + 1;
  p = p.644;
  D.36804 = *argval;
  *p.643 = D.36804;
  goto <D.22604>;
  <D.22605>:
  <D.22606>:
  <D.22607>:
  p.638 = p;
  swap_with_size (p.638, argval, 2, 1);
  p.638 = p;
  p.645 = p.638 + 2;
  p = p.645;
  goto <D.22604>;
  <D.22608>:
  <D.22609>:
  <D.22610>:
  p.638 = p;
  swap_with_size (p.638, argval, 4, 1);
  p.638 = p;
  p.646 = p.638 + 4;
  p = p.646;
  goto <D.22604>;
  <D.22611>:
  p.638 = p;
  swap_with_size (p.638, argval, 8, 1);
  p.638 = p;
  p.647 = p.638 + 8;
  p = p.647;
  goto <D.22604>;
  <D.22612>:
  <D.22613>:
  p.638 = p;
  swap_with_size (p.638, argval, 8, 1);
  p.638 = p;
  p.647 = p.638 + 8;
  p = p.647;
  goto <D.22604>;
  <D.22614>:
  D.36808 = type->data.klass;
  D.36809 = BIT_FIELD_REF <*D.36808, 8, 160>;
  D.36810 = D.36809 & 16;
  if (D.36810 != 0) goto <D.36811>; else goto <D.36812>;
  <D.36811>:
  D.36808 = type->data.klass;
  D.36813 = mono_class_enum_basetype (D.36808);
  D.36814 = D.36813->type;
  simple_type = (MonoTypeEnum) D.36814;
  goto handle_enum;
  <D.36812>:
  D.36808 = type->data.klass;
  D.36815 = D.36808->name;
  monoeg_g_log (0B, 16, "generic valutype %s not handled in custom attr value decoding", D.36815);
  goto <D.22604>;
  <D.22615>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36816>; else goto <D.36817>;
    <D.36816>:
    p.638 = p;
    p.648 = p.638;
    p.649 = p.648 + 1;
    p = p.649;
    *p.648 = -1;
    goto <D.22604>;
    <D.36817>:
    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.36790 = p.639 - buffer.641;
    D.36820 = (unsigned int) D.36790;
    D.36821 = D.36820 + slen;
    D.36822 = D.36821 + 10;
    D.36793 = *buflen;
    if (D.36822 >= D.36793) goto <D.36823>; else goto <D.36824>;
    <D.36823>:
    {
      char * newbuf;

      D.36793 = *buflen;
      D.36796 = D.36793 * 2;
      *buflen = D.36796;
      D.36793 = *buflen;
      D.36825 = D.36793 + slen;
      *buflen = D.36825;
      D.36793 = *buflen;
      buffer.640 = buffer;
      newbuf = monoeg_realloc (buffer.640, D.36793);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36790 = p.639 - buffer.641;
      D.36797 = (sizetype) D.36790;
      p.650 = newbuf + D.36797;
      p = p.650;
      buffer = newbuf;
    }
    <D.36824>:
    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.22604>;
  }
  <D.22619>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36828>; else goto <D.36829>;
    <D.36828>:
    p.638 = p;
    p.652 = p.638;
    p.653 = p.652 + 1;
    p = p.653;
    *p.652 = -1;
    goto <D.22604>;
    <D.36829>:
    handle_type:
    D.36832 = mono_reflection_type_get_handle (arg);
    str = type_get_qualified_name (D.36832, 0B);
    slen = strlen (str);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36790 = p.639 - buffer.641;
    D.36820 = (unsigned int) D.36790;
    D.36833 = D.36820 + slen;
    D.36834 = D.36833 + 10;
    D.36793 = *buflen;
    if (D.36834 >= D.36793) goto <D.36835>; else goto <D.36836>;
    <D.36835>:
    {
      char * newbuf;

      D.36793 = *buflen;
      D.36796 = D.36793 * 2;
      *buflen = D.36796;
      D.36793 = *buflen;
      D.36837 = D.36793 + slen;
      *buflen = D.36837;
      D.36793 = *buflen;
      buffer.640 = buffer;
      newbuf = monoeg_realloc (buffer.640, D.36793);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36790 = p.639 - buffer.641;
      D.36797 = (sizetype) D.36790;
      p.654 = newbuf + D.36797;
      p = p.654;
      buffer = newbuf;
    }
    <D.36836>:
    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.22604>;
  }
  <D.22624>:
  {
    int len;
    int i;
    struct MonoClass * eclass;
    struct MonoClass * arg_eclass;

    if (arg == 0B) goto <D.36840>; else goto <D.36841>;
    <D.36840>:
    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.22604>;
    <D.36841>:
    D.36850 = mono_array_length (arg);
    len = (int) D.36850;
    p.638 = p;
    p.664 = p.638;
    p.665 = p.664 + 1;
    p = p.665;
    D.36853 = (char) len;
    *p.664 = D.36853;
    p.638 = p;
    p.666 = p.638;
    p.667 = p.666 + 1;
    p = p.667;
    D.36856 = len >> 8;
    D.36857 = (char) D.36856;
    *p.666 = D.36857;
    p.638 = p;
    p.668 = p.638;
    p.669 = p.668 + 1;
    p = p.669;
    D.36860 = len >> 16;
    D.36861 = (char) D.36860;
    *p.668 = D.36861;
    p.638 = p;
    p.670 = p.638;
    p.671 = p.670 + 1;
    p = p.671;
    len.672 = (unsigned int) len;
    D.36865 = len.672 >> 24;
    D.36866 = (char) D.36865;
    *p.670 = D.36866;
    p.638 = p;
    *retp = p.638;
    buffer.640 = buffer;
    *retbuffer = buffer.640;
    eclass = type->data.klass;
    D.36867 = arg->vtable;
    D.36868 = D.36867->klass;
    arg_eclass = D.36868->element_class;
    if (eclass == 0B) goto <D.36869>; else goto <D.36870>;
    <D.36869>:
    eclass = mono_defaults.object_class;
    <D.36870>:
    D.36873 = mono_defaults.object_class;
    if (D.36873 == eclass) goto <D.36874>; else goto <D.36871>;
    <D.36874>:
    D.36875 = BIT_FIELD_REF <*arg_eclass, 8, 160>;
    D.36876 = D.36875 & 8;
    if (D.36876 != 0) goto <D.36877>; else goto <D.36871>;
    <D.36877>:
    {
      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.22632>;
      <D.22631>:
      D.36878 = &arg_eclass->byval_arg;
      p.638 = p;
      buffer.640 = buffer;
      encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36878, 0B, elptr);
      elsize.673 = (sizetype) elsize;
      elptr = elptr + elsize.673;
      i = i + 1;
      <D.22632>:
      if (i < len) goto <D.22631>; else goto <D.22633>;
      <D.22633>:
    }
    goto <D.36872>;
    <D.36871>:
    D.36881 = BIT_FIELD_REF <*eclass, 8, 160>;
    D.36882 = D.36881 & 8;
    if (D.36882 != 0) goto <D.36883>; else goto <D.36880>;
    <D.36883>:
    D.36875 = BIT_FIELD_REF <*arg_eclass, 8, 160>;
    D.36876 = D.36875 & 8;
    if (D.36876 != 0) goto <D.36884>; else goto <D.36880>;
    <D.36884>:
    {
      char * elptr;
      int elsize;

      elptr = mono_array_addr_with_size (arg, 1, 0);
      elsize = mono_class_array_element_size (eclass);
      i = 0;
      goto <D.22637>;
      <D.22636>:
      D.36885 = &eclass->byval_arg;
      p.638 = p;
      buffer.640 = buffer;
      encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36885, 0B, elptr);
      elsize.674 = (sizetype) elsize;
      elptr = elptr + elsize.674;
      i = i + 1;
      <D.22637>:
      if (i < len) goto <D.22636>; else goto <D.22638>;
      <D.22638>:
    }
    goto <D.22641>;
    <D.36880>:
    i = 0;
    goto <D.22640>;
    <D.22639>:
    i.675 = (unsigned int) i;
    D.36888 = mono_array_addr_with_size (arg, 4, i.675);
    D.36889 = MEM[(struct MonoObject * *)D.36888];
    D.36885 = &eclass->byval_arg;
    p.638 = p;
    buffer.640 = buffer;
    encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36885, D.36889, 0B);
    i = i + 1;
    <D.22640>:
    if (i < len) goto <D.22639>; else goto <D.22641>;
    <D.22641>:
    <D.36872>:
    goto <D.22604>;
  }
  <D.22642>:
  {
    struct MonoClass * klass;
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.36890>; else goto <D.36891>;
    <D.36890>:
    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.22604>;
    <D.36891>:
    D.36867 = arg->vtable;
    klass = D.36867->klass;
    D.36896 = mono_defaults.systemtype_class;
    D.36897 = mono_object_isinst (arg, D.36896);
    if (D.36897 != 0B) goto <D.36898>; else goto <D.36899>;
    <D.36898>:
    p.638 = p;
    p.680 = p.638;
    p.681 = p.680 + 1;
    p = p.681;
    *p.680 = 80;
    goto handle_type;
    <D.36899>:
    D.36902 = BIT_FIELD_REF <*klass, 8, 160>;
    D.36903 = D.36902 & 16;
    if (D.36903 != 0) goto <D.36904>; else goto <D.36905>;
    <D.36904>:
    p.638 = p;
    p.682 = p.638;
    p.683 = p.682 + 1;
    p = p.683;
    *p.682 = 85;
    goto <D.36908>;
    <D.36905>:
    D.36909 = mono_defaults.string_class;
    if (D.36909 == klass) goto <D.36910>; else goto <D.36911>;
    <D.36910>:
    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.36911>:
    D.36914 = klass->rank;
    if (D.36914 == 1) goto <D.36915>; else goto <D.36916>;
    <D.36915>:
    p.638 = p;
    p.686 = p.638;
    p.687 = p.686 + 1;
    p = p.687;
    *p.686 = 29;
    D.36919 = klass->element_class;
    D.36920 = D.36919->byval_arg.type;
    if (D.36920 == 28) goto <D.36921>; else goto <D.36922>;
    <D.36921>:
    p.638 = p;
    p.688 = p.638;
    p.689 = p.688 + 1;
    p = p.689;
    *p.688 = 81;
    goto <D.36925>;
    <D.36922>:
    p.638 = p;
    p.690 = p.638;
    p.691 = p.690 + 1;
    p = p.691;
    D.36919 = klass->element_class;
    D.36920 = D.36919->byval_arg.type;
    D.36928 = (char) D.36920;
    *p.690 = D.36928;
    <D.36925>:
    D.36929 = &klass->byval_arg;
    p.638 = p;
    buffer.640 = buffer;
    encode_cattr_value (assembly, buffer.640, p.638, &buffer, &p, buflen, D.36929, arg, 0B);
    goto <D.22604>;
    <D.36916>:
    D.36930 = klass->byval_arg.type;
    D.36931 = D.36930 + 254;
    if (D.36931 <= 11) goto <D.36932>; else goto <D.36933>;
    <D.36932>:
    p.638 = p;
    p.692 = p.638;
    p.693 = p.692 + 1;
    p = p.693;
    D.36930 = klass->byval_arg.type;
    simple_type = (MonoTypeEnum) D.36930;
    D.36936 = (char) simple_type;
    *p.692 = D.36936;
    goto handle_enum;
    <D.36933>:
    monoeg_g_log (0B, 4, "unhandled type in custom attr");
    <D.22646>:
    goto <D.22646>;
    <D.36908>:
    D.36937 = mono_class_get_type (klass);
    str = type_get_qualified_name (D.36937, 0B);
    slen = strlen (str);
    p.638 = p;
    p.639 = (int) p.638;
    buffer.640 = buffer;
    buffer.641 = (int) buffer.640;
    D.36790 = p.639 - buffer.641;
    D.36820 = (unsigned int) D.36790;
    D.36938 = D.36820 + slen;
    D.36939 = D.36938 + 10;
    D.36793 = *buflen;
    if (D.36939 >= D.36793) goto <D.36940>; else goto <D.36941>;
    <D.36940>:
    {
      char * newbuf;

      D.36793 = *buflen;
      D.36796 = D.36793 * 2;
      *buflen = D.36796;
      D.36793 = *buflen;
      D.36942 = D.36793 + slen;
      *buflen = D.36942;
      D.36793 = *buflen;
      buffer.640 = buffer;
      newbuf = monoeg_realloc (buffer.640, D.36793);
      p.638 = p;
      p.639 = (int) p.638;
      buffer.640 = buffer;
      buffer.641 = (int) buffer.640;
      D.36790 = p.639 - buffer.641;
      D.36797 = (sizetype) D.36790;
      p.694 = newbuf + D.36797;
      p = p.694;
      buffer = newbuf;
    }
    <D.36941>:
    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.36945 = mono_class_enum_basetype (klass);
    D.36946 = D.36945->type;
    simple_type = (MonoTypeEnum) D.36946;
    goto handle_enum;
  }
  <D.22648>:
  monoeg_g_log (0B, 4, "type 0x%02x not yet supported in custom attr encoder", simple_type);
  <D.22649>:
  goto <D.22649>;
  <D.22604>:
  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.36947;
  unsigned int D.36948;

  D.36947 = len * nelem;
  D.36948 = (unsigned int) D.36947;
  memcpy (dest, val, D.36948);
}


type_get_qualified_name (struct MonoType * type, struct MonoAssembly * ass)
{
  char * D.36951;
  struct MonoImage * D.36952;
  unsigned char D.36955;
  struct MonoGenericClass * D.36959;
  struct MonoGenericContainer * D.36961;
  struct MonoClass * klass;
  struct MonoAssembly * ta;

  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.36949>; else goto <D.36950>;
  <D.36949>:
  D.36951 = mono_type_get_name_full (type, 1);
  return D.36951;
  <D.36950>:
  D.36952 = klass->image;
  ta = D.36952->assembly;
  D.36955 = ta->dynamic;
  if (D.36955 != 0) goto <D.36953>; else goto <D.36956>;
  <D.36956>:
  if (ta == ass) goto <D.36953>; else goto <D.36954>;
  <D.36953>:
  D.36959 = klass->generic_class;
  if (D.36959 != 0B) goto <D.36957>; else goto <D.36960>;
  <D.36960>:
  D.36961 = klass->generic_container;
  if (D.36961 != 0B) goto <D.36957>; else goto <D.36958>;
  <D.36957>:
  D.36951 = mono_type_get_name_full (type, 2);
  return D.36951;
  <D.36958>:
  D.36951 = mono_type_get_name_full (type, 1);
  return D.36951;
  <D.36954>:
  D.36951 = mono_type_get_name_full (type, 3);
  return D.36951;
}


get_prop_name_and_type (struct MonoObject * prop, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.36963;
  int D.22416;
  int iftmp.696;
  int D.22415;
  const char[16] * D.36967;
  unsigned char D.36968;
  int D.36969;
  unsigned char D.36970;
  int D.36971;
  _Bool D.36972;
  _Bool D.36973;
  _Bool D.36974;
  const unsigned char * D.36977;
  unsigned char D.36978;
  int D.36979;
  const unsigned char * D.36980;
  unsigned char D.36981;
  int D.36982;
  _Bool D.36983;
  _Bool D.36984;
  const unsigned char * D.36987;
  unsigned char D.36988;
  int D.36989;
  const unsigned char * D.36990;
  unsigned char D.36991;
  int D.36992;
  _Bool D.36993;
  _Bool D.36994;
  const unsigned char * D.36997;
  unsigned char D.36998;
  int D.36999;
  const unsigned char * D.37000;
  unsigned char D.37001;
  int D.37002;
  const char * D.37004;
  struct MonoString * D.37007;
  char * D.37008;
  struct MonoObject * D.37009;
  struct MonoType * D.37010;
  struct MonoProperty * D.37012;
  const char * D.37013;
  gchar * D.37014;
  struct MonoMethod * D.37015;
  struct MonoMethodSignature * D.37018;
  struct MonoType * D.37019;
  struct MonoMethod * D.37021;
  struct MonoMethodSignature * D.37022;
  struct MonoMethodSignature * D.37023;
  short unsigned int D.37024;
  int D.37025;
  int D.37026;
  struct MonoType * D.37027;
  struct MonoClass * klass;

  D.36963 = prop->vtable;
  klass = D.36963->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36967 = "PropertyBuilder";
      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;
      {
        D.36972 = __s2_len != 0;
        D.36973 = __result == 0;
        D.36974 = D.36972 & D.36973;
        if (D.36974 != 0) goto <D.36975>; else goto <D.36976>;
        <D.36975>:
        D.36977 = &MEM[(void *)"PropertyBuilder" + 1B];
        D.36978 = *D.36977;
        D.36979 = (int) D.36978;
        D.36980 = __s2 + 1;
        D.36981 = *D.36980;
        D.36982 = (int) D.36981;
        __result = D.36979 - D.36982;
        D.36983 = __s2_len > 1;
        D.36973 = __result == 0;
        D.36984 = D.36983 & D.36973;
        if (D.36984 != 0) goto <D.36985>; else goto <D.36986>;
        <D.36985>:
        D.36987 = &MEM[(void *)"PropertyBuilder" + 2B];
        D.36988 = *D.36987;
        D.36989 = (int) D.36988;
        D.36990 = __s2 + 2;
        D.36991 = *D.36990;
        D.36992 = (int) D.36991;
        __result = D.36989 - D.36992;
        D.36993 = __s2_len > 2;
        D.36973 = __result == 0;
        D.36994 = D.36993 & D.36973;
        if (D.36994 != 0) goto <D.36995>; else goto <D.36996>;
        <D.36995>:
        D.36997 = &MEM[(void *)"PropertyBuilder" + 3B];
        D.36998 = *D.36997;
        D.36999 = (int) D.36998;
        D.37000 = __s2 + 3;
        D.37001 = *D.37000;
        D.37002 = (int) D.37001;
        __result = D.36999 - D.37002;
        <D.36996>:
        <D.36986>:
        <D.36976>:
      }
      D.22415 = __result;
    }
    iftmp.696 = -D.22415;
    goto <D.37003>;
    <D.36966>:
    D.37004 = klass->name;
    iftmp.696 = __builtin_strcmp (D.37004, "PropertyBuilder");
    <D.37003>:
    D.22416 = iftmp.696;
  }
  if (D.22416 == 0) goto <D.37005>; else goto <D.37006>;
  <D.37005>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    pb = prop;
    D.37007 = pb->name;
    D.37008 = mono_string_to_utf8 (D.37007);
    *name = D.37008;
    D.37009 = pb->type;
    D.37010 = mono_reflection_type_get_handle (D.37009);
    *type = D.37010;
  }
  goto <D.37011>;
  <D.37006>:
  {
    struct MonoReflectionProperty * p;

    p = prop;
    D.37012 = p->property;
    D.37013 = D.37012->name;
    D.37014 = monoeg_strdup (D.37013);
    *name = D.37014;
    D.37012 = p->property;
    D.37015 = D.37012->get;
    if (D.37015 != 0B) goto <D.37016>; else goto <D.37017>;
    <D.37016>:
    D.37012 = p->property;
    D.37015 = D.37012->get;
    D.37018 = mono_method_signature (D.37015);
    D.37019 = D.37018->ret;
    *type = D.37019;
    goto <D.37020>;
    <D.37017>:
    D.37012 = p->property;
    D.37021 = D.37012->set;
    D.37022 = mono_method_signature (D.37021);
    D.37012 = p->property;
    D.37021 = D.37012->set;
    D.37023 = mono_method_signature (D.37021);
    D.37024 = D.37023->param_count;
    D.37025 = (int) D.37024;
    D.37026 = D.37025 + -1;
    D.37027 = D.37022->params[D.37026];
    *type = D.37027;
    <D.37020>:
  }
  <D.37011>:
}


get_field_name_and_type (struct MonoObject * field, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.37028;
  int D.22433;
  int iftmp.697;
  int D.22432;
  const char[13] * D.37032;
  unsigned char D.37033;
  int D.37034;
  unsigned char D.37035;
  int D.37036;
  _Bool D.37037;
  _Bool D.37038;
  _Bool D.37039;
  const unsigned char * D.37042;
  unsigned char D.37043;
  int D.37044;
  const unsigned char * D.37045;
  unsigned char D.37046;
  int D.37047;
  _Bool D.37048;
  _Bool D.37049;
  const unsigned char * D.37052;
  unsigned char D.37053;
  int D.37054;
  const unsigned char * D.37055;
  unsigned char D.37056;
  int D.37057;
  _Bool D.37058;
  _Bool D.37059;
  const unsigned char * D.37062;
  unsigned char D.37063;
  int D.37064;
  const unsigned char * D.37065;
  unsigned char D.37066;
  int D.37067;
  const char * D.37069;
  struct MonoString * D.37072;
  char * D.37073;
  struct MonoObject * D.37074;
  struct MonoType * D.37075;
  struct MonoClassField * D.37077;
  const char * D.37078;
  gchar * D.37079;
  struct MonoType * D.37080;
  struct MonoClass * klass;

  D.37028 = field->vtable;
  klass = D.37028->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.37032 = "FieldBuilder";
      D.37033 = MEM[(const unsigned char *)D.37032];
      D.37034 = (int) D.37033;
      D.37035 = *__s2;
      D.37036 = (int) D.37035;
      __result = D.37034 - D.37036;
      {
        D.37037 = __s2_len != 0;
        D.37038 = __result == 0;
        D.37039 = D.37037 & D.37038;
        if (D.37039 != 0) goto <D.37040>; else goto <D.37041>;
        <D.37040>:
        D.37042 = &MEM[(void *)"FieldBuilder" + 1B];
        D.37043 = *D.37042;
        D.37044 = (int) D.37043;
        D.37045 = __s2 + 1;
        D.37046 = *D.37045;
        D.37047 = (int) D.37046;
        __result = D.37044 - D.37047;
        D.37048 = __s2_len > 1;
        D.37038 = __result == 0;
        D.37049 = D.37048 & D.37038;
        if (D.37049 != 0) goto <D.37050>; else goto <D.37051>;
        <D.37050>:
        D.37052 = &MEM[(void *)"FieldBuilder" + 2B];
        D.37053 = *D.37052;
        D.37054 = (int) D.37053;
        D.37055 = __s2 + 2;
        D.37056 = *D.37055;
        D.37057 = (int) D.37056;
        __result = D.37054 - D.37057;
        D.37058 = __s2_len > 2;
        D.37038 = __result == 0;
        D.37059 = D.37058 & D.37038;
        if (D.37059 != 0) goto <D.37060>; else goto <D.37061>;
        <D.37060>:
        D.37062 = &MEM[(void *)"FieldBuilder" + 3B];
        D.37063 = *D.37062;
        D.37064 = (int) D.37063;
        D.37065 = __s2 + 3;
        D.37066 = *D.37065;
        D.37067 = (int) D.37066;
        __result = D.37064 - D.37067;
        <D.37061>:
        <D.37051>:
        <D.37041>:
      }
      D.22432 = __result;
    }
    iftmp.697 = -D.22432;
    goto <D.37068>;
    <D.37031>:
    D.37069 = klass->name;
    iftmp.697 = __builtin_strcmp (D.37069, "FieldBuilder");
    <D.37068>:
    D.22433 = iftmp.697;
  }
  if (D.22433 == 0) goto <D.37070>; else goto <D.37071>;
  <D.37070>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = field;
    D.37072 = fb->name;
    D.37073 = mono_string_to_utf8 (D.37072);
    *name = D.37073;
    D.37074 = fb->type;
    D.37075 = mono_reflection_type_get_handle (D.37074);
    *type = D.37075;
  }
  goto <D.37076>;
  <D.37071>:
  {
    struct MonoReflectionField * f;

    f = field;
    D.37077 = f->field;
    D.37078 = mono_field_get_name (D.37077);
    D.37079 = monoeg_strdup (D.37078);
    *name = D.37079;
    D.37077 = f->field;
    D.37080 = D.37077->type;
    *type = D.37080;
  }
  <D.37076>:
}


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.37083;
  struct MonoClass * D.37085;
  unsigned char D.37086;
  unsigned char D.37087;
  unsigned int D.37089;
  struct MonoType * D.37094;
  unsigned int D.37095;
  unsigned int D.37096;
  unsigned int len.698;
  unsigned int D.37098;
  char * p.699;
  int p.700;
  char * buffer.701;
  int buffer.702;
  int D.37103;
  int D.37104;
  int D.37105;
  unsigned int D.37106;
  unsigned int D.37107;
  unsigned int D.37110;
  unsigned int len.703;
  unsigned int D.37112;
  sizetype D.37113;
  char * p.704;
  unsigned int D.37115;
  unsigned int len.705;
  sizetype len.706;
  char * p.707;
  struct MonoAssembly * D.37119;
  int len;

  D.37083 = type->type;
  if (D.37083 == 17) goto <D.37084>; else goto <D.37081>;
  <D.37084>:
  D.37085 = type->data.klass;
  D.37086 = BIT_FIELD_REF <*D.37085, 8, 160>;
  D.37087 = D.37086 & 16;
  if (D.37087 != 0) goto <D.37088>; else goto <D.37081>;
  <D.37088>:
  {
    char * str;

    str = type_get_qualified_name (type, 0B);
    D.37089 = strlen (str);
    len = (int) D.37089;
    monoeg_g_free (str);
  }
  goto <D.37082>;
  <D.37081>:
  D.37083 = type->type;
  if (D.37083 == 29) goto <D.37092>; else goto <D.37090>;
  <D.37092>:
  D.37085 = type->data.klass;
  D.37086 = BIT_FIELD_REF <*D.37085, 8, 160>;
  D.37087 = D.37086 & 16;
  if (D.37087 != 0) goto <D.37093>; else goto <D.37090>;
  <D.37093>:
  {
    char * str;

    D.37085 = type->data.klass;
    D.37094 = &D.37085->byval_arg;
    str = type_get_qualified_name (D.37094, 0B);
    D.37095 = strlen (str);
    len = (int) D.37095;
    monoeg_g_free (str);
  }
  goto <D.37091>;
  <D.37090>:
  len = 0;
  <D.37091>:
  <D.37082>:
  D.37096 = strlen (name);
  len.698 = (unsigned int) len;
  D.37098 = D.37096 + len.698;
  len = (int) D.37098;
  p.699 = p;
  p.700 = (int) p.699;
  buffer.701 = buffer;
  buffer.702 = (int) buffer.701;
  D.37103 = p.700 - buffer.702;
  D.37104 = D.37103 + 20;
  D.37105 = D.37104 + len;
  D.37106 = (unsigned int) D.37105;
  D.37107 = *buflen;
  if (D.37106 >= D.37107) goto <D.37108>; else goto <D.37109>;
  <D.37108>:
  {
    char * newbuf;

    D.37107 = *buflen;
    D.37110 = D.37107 * 2;
    *buflen = D.37110;
    D.37107 = *buflen;
    len.703 = (unsigned int) len;
    D.37112 = D.37107 + len.703;
    *buflen = D.37112;
    D.37107 = *buflen;
    buffer.701 = buffer;
    newbuf = monoeg_realloc (buffer.701, D.37107);
    p.699 = p;
    p.700 = (int) p.699;
    buffer.701 = buffer;
    buffer.702 = (int) buffer.701;
    D.37103 = p.700 - buffer.702;
    D.37113 = (sizetype) D.37103;
    p.704 = newbuf + D.37113;
    p = p.704;
    buffer = newbuf;
  }
  <D.37109>:
  p.699 = p;
  encode_field_or_prop_type (type, p.699, &p);
  D.37115 = strlen (name);
  len = (int) D.37115;
  p.699 = p;
  len.705 = (unsigned int) len;
  mono_metadata_encode_value (len.705, p.699, &p);
  len.698 = (unsigned int) len;
  p.699 = p;
  memcpy (p.699, name, len.698);
  p.699 = p;
  len.706 = (sizetype) len;
  p.707 = p.699 + len.706;
  p = p.707;
  p.699 = p;
  buffer.701 = buffer;
  D.37119 = assembly->assembly;
  encode_cattr_value (D.37119, 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.37122;
  struct MonoClass * D.37124;
  unsigned char D.37125;
  unsigned char D.37126;
  unsigned int D.37128;
  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.37146;
  struct MonoType * D.37149;

  D.37122 = type->type;
  if (D.37122 == 17) goto <D.37123>; else goto <D.37120>;
  <D.37123>:
  D.37124 = type->data.klass;
  D.37125 = BIT_FIELD_REF <*D.37124, 8, 160>;
  D.37126 = D.37125 & 16;
  if (D.37126 != 0) goto <D.37127>; else goto <D.37120>;
  <D.37127>:
  {
    char * str;
    int slen;

    str = type_get_qualified_name (type, 0B);
    D.37128 = strlen (str);
    slen = (int) D.37128;
    p.708 = p;
    p.709 = p.708;
    p.710 = p.709 + 1;
    p = p.710;
    *p.709 = 85;
    p.708 = p;
    slen.711 = (unsigned int) slen;
    mono_metadata_encode_value (slen.711, p.708, &p);
    slen.712 = (unsigned int) slen;
    p.708 = p;
    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.37121>;
  <D.37120>:
  D.37122 = type->type;
  if (D.37122 == 28) goto <D.37136>; else goto <D.37137>;
  <D.37136>:
  p.708 = p;
  p.715 = p.708;
  p.716 = p.715 + 1;
  p = p.716;
  *p.715 = 81;
  goto <D.37140>;
  <D.37137>:
  D.37122 = type->type;
  if (D.37122 == 18) goto <D.37141>; else goto <D.37142>;
  <D.37141>:
  p.708 = p;
  p.717 = p.708;
  p.718 = p.717 + 1;
  p = p.718;
  *p.717 = 80;
  goto <D.37145>;
  <D.37142>:
  p.708 = p;
  D.37122 = type->type;
  D.37146 = (unsigned int) D.37122;
  mono_metadata_encode_value (D.37146, p.708, &p);
  D.37122 = type->type;
  if (D.37122 == 29) goto <D.37147>; else goto <D.37148>;
  <D.37147>:
  p.708 = p;
  D.37124 = type->data.klass;
  D.37149 = &D.37124->byval_arg;
  encode_field_or_prop_type (D.37149, p.708, &p);
  <D.37148>:
  <D.37145>:
  <D.37140>:
  <D.37121>:
  p.708 = p;
  *retp = p.708;
}


mono_reflection_setup_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoObject * D.37150;
  struct MonoReflectionType * D.37151;
  int D.22735;
  int iftmp.719;
  int D.22734;
  struct MonoVTable * D.37157;
  struct MonoClass * D.37158;
  const char[12] * D.37159;
  unsigned char D.37160;
  int D.37161;
  unsigned char D.37162;
  int D.37163;
  _Bool D.37164;
  _Bool D.37165;
  _Bool D.37166;
  const unsigned char * D.37169;
  unsigned char D.37170;
  int D.37171;
  const unsigned char * D.37172;
  unsigned char D.37173;
  int D.37174;
  _Bool D.37175;
  _Bool D.37176;
  const unsigned char * D.37179;
  unsigned char D.37180;
  int D.37181;
  const unsigned char * D.37182;
  unsigned char D.37183;
  int D.37184;
  _Bool D.37185;
  _Bool D.37186;
  const unsigned char * D.37189;
  unsigned char D.37190;
  int D.37191;
  const unsigned char * D.37192;
  unsigned char D.37193;
  int D.37194;
  const char * D.37196;
  struct MonoType * D.37199;
  struct MonoType * D.37201;
  struct MonoType * D.37203;
  struct MonoReflectionModuleBuilder * D.37206;
  struct MonoDynamicImage * D.37207;
  struct MonoImage * D.37208;
  struct MonoString * D.37209;
  struct MonoImage * D.37210;
  char * D.37211;
  int D.37212;
  struct MonoString * D.37214;
  char * D.37215;
  int D.37216;
  unsigned int D.37218;
  unsigned int D.37219;
  unsigned int D.37220;
  void * D.37221;
  struct MonoReflectionType * D.37224;
  const char * D.37227;
  const char * D.37228;
  void * D.37230;
  _Bool D.37231;
  long int D.37232;
  long int D.37233;
  void * D.37236;
  struct MonoGHashTable * D.37237;
  int D.22745;
  int iftmp.720;
  int D.22744;
  const char[7] * D.37244;
  unsigned char D.37245;
  int D.37246;
  unsigned char D.37247;
  int D.37248;
  _Bool D.37249;
  _Bool D.37250;
  _Bool D.37251;
  const unsigned char * D.37254;
  unsigned char D.37255;
  int D.37256;
  const unsigned char * D.37257;
  unsigned char D.37258;
  int D.37259;
  _Bool D.37260;
  _Bool D.37261;
  const unsigned char * D.37264;
  unsigned char D.37265;
  int D.37266;
  const unsigned char * D.37267;
  unsigned char D.37268;
  int D.37269;
  _Bool D.37270;
  _Bool D.37271;
  const unsigned char * D.37274;
  unsigned char D.37275;
  int D.37276;
  const unsigned char * D.37277;
  unsigned char D.37278;
  int D.37279;
  int D.22754;
  int iftmp.721;
  int D.22753;
  const char[7] * D.37286;
  unsigned char D.37287;
  int D.37288;
  unsigned char D.37289;
  int D.37290;
  _Bool D.37291;
  _Bool D.37292;
  _Bool D.37293;
  const unsigned char * D.37296;
  unsigned char D.37297;
  int D.37298;
  const unsigned char * D.37299;
  unsigned char D.37300;
  int D.37301;
  _Bool D.37302;
  _Bool D.37303;
  const unsigned char * D.37306;
  unsigned char D.37307;
  int D.37308;
  const unsigned char * D.37309;
  unsigned char D.37310;
  int D.37311;
  _Bool D.37312;
  _Bool D.37313;
  const unsigned char * D.37316;
  unsigned char D.37317;
  int D.37318;
  const unsigned char * D.37319;
  unsigned char D.37320;
  int D.37321;
  struct MonoClass * D.37325;
  int D.22764;
  int iftmp.722;
  int D.22763;
  const char[10] * D.37333;
  unsigned char D.37334;
  int D.37335;
  unsigned char D.37336;
  int D.37337;
  _Bool D.37338;
  _Bool D.37339;
  _Bool D.37340;
  const unsigned char * D.37343;
  unsigned char D.37344;
  int D.37345;
  const unsigned char * D.37346;
  unsigned char D.37347;
  int D.37348;
  _Bool D.37349;
  _Bool D.37350;
  const unsigned char * D.37353;
  unsigned char D.37354;
  int D.37355;
  const unsigned char * D.37356;
  unsigned char D.37357;
  int D.37358;
  _Bool D.37359;
  _Bool D.37360;
  const unsigned char * D.37363;
  unsigned char D.37364;
  int D.37365;
  const unsigned char * D.37366;
  unsigned char D.37367;
  int D.37368;
  int D.22773;
  int iftmp.723;
  int D.22772;
  unsigned char D.37374;
  int D.37375;
  _Bool D.37376;
  _Bool D.37377;
  _Bool D.37378;
  const unsigned char * D.37381;
  unsigned char D.37382;
  int D.37383;
  _Bool D.37384;
  _Bool D.37385;
  const unsigned char * D.37388;
  unsigned char D.37389;
  int D.37390;
  _Bool D.37391;
  _Bool D.37392;
  const unsigned char * D.37395;
  unsigned char D.37396;
  int D.37397;
  int D.22782;
  int iftmp.724;
  int D.22781;
  unsigned char D.37402;
  int D.37403;
  _Bool D.37404;
  _Bool D.37405;
  _Bool D.37406;
  const unsigned char * D.37409;
  unsigned char D.37410;
  int D.37411;
  _Bool D.37412;
  _Bool D.37413;
  const unsigned char * D.37416;
  unsigned char D.37417;
  int D.37418;
  _Bool D.37419;
  _Bool D.37420;
  const unsigned char * D.37423;
  unsigned char D.37424;
  int D.37425;
  int D.22791;
  int iftmp.725;
  int D.22790;
  unsigned char D.37431;
  int D.37432;
  _Bool D.37433;
  _Bool D.37434;
  _Bool D.37435;
  const unsigned char * D.37438;
  unsigned char D.37439;
  int D.37440;
  _Bool D.37441;
  _Bool D.37442;
  const unsigned char * D.37445;
  unsigned char D.37446;
  int D.37447;
  _Bool D.37448;
  _Bool D.37449;
  const unsigned char * D.37452;
  unsigned char D.37453;
  int D.37454;
  int D.22800;
  int iftmp.726;
  int D.22799;
  const char[5] * D.37459;
  unsigned char D.37460;
  int D.37461;
  unsigned char D.37462;
  int D.37463;
  _Bool D.37464;
  _Bool D.37465;
  _Bool D.37466;
  const unsigned char * D.37469;
  unsigned char D.37470;
  int D.37471;
  const unsigned char * D.37472;
  unsigned char D.37473;
  int D.37474;
  _Bool D.37475;
  _Bool D.37476;
  const unsigned char * D.37479;
  unsigned char D.37480;
  int D.37481;
  const unsigned char * D.37482;
  unsigned char D.37483;
  int D.37484;
  _Bool D.37485;
  _Bool D.37486;
  const unsigned char * D.37489;
  unsigned char D.37490;
  int D.37491;
  const unsigned char * D.37492;
  unsigned char D.37493;
  int D.37494;
  int D.22809;
  int iftmp.727;
  int D.22808;
  unsigned char D.37500;
  int D.37501;
  _Bool D.37502;
  _Bool D.37503;
  _Bool D.37504;
  const unsigned char * D.37507;
  unsigned char D.37508;
  int D.37509;
  _Bool D.37510;
  _Bool D.37511;
  const unsigned char * D.37514;
  unsigned char D.37515;
  int D.37516;
  _Bool D.37517;
  _Bool D.37518;
  const unsigned char * D.37521;
  unsigned char D.37522;
  int D.37523;
  struct MonoType * D.37525;
  struct MonoType * D.37528;
  _Bool D.37529;
  long int D.37530;
  long int D.37531;
  struct MonoType * D.37534;
  struct MonoClass * D.37535;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoClass * parent;
  void failure = <<< error >>>;

  try
    {
      D.37150 = tb->parent;
      D.37151 = mono_reflection_type_resolve_user_types (D.37150);
      tb->parent = D.37151;
      mono_loader_lock ();
      D.37150 = tb->parent;
      if (D.37150 != 0B) goto <D.37152>; else goto <D.37153>;
      <D.37152>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.37150 = tb->parent;
          D.37157 = D.37150->vtable;
          D.37158 = D.37157->klass;
          __s2 = D.37158->name;
          D.37159 = "TypeBuilder";
          D.37160 = MEM[(const unsigned char *)D.37159];
          D.37161 = (int) D.37160;
          D.37162 = *__s2;
          D.37163 = (int) D.37162;
          __result = D.37161 - D.37163;
          {
            D.37164 = __s2_len != 0;
            D.37165 = __result == 0;
            D.37166 = D.37164 & D.37165;
            if (D.37166 != 0) goto <D.37167>; else goto <D.37168>;
            <D.37167>:
            D.37169 = &MEM[(void *)"TypeBuilder" + 1B];
            D.37170 = *D.37169;
            D.37171 = (int) D.37170;
            D.37172 = __s2 + 1;
            D.37173 = *D.37172;
            D.37174 = (int) D.37173;
            __result = D.37171 - D.37174;
            D.37175 = __s2_len > 1;
            D.37165 = __result == 0;
            D.37176 = D.37175 & D.37165;
            if (D.37176 != 0) goto <D.37177>; else goto <D.37178>;
            <D.37177>:
            D.37179 = &MEM[(void *)"TypeBuilder" + 2B];
            D.37180 = *D.37179;
            D.37181 = (int) D.37180;
            D.37182 = __s2 + 2;
            D.37183 = *D.37182;
            D.37184 = (int) D.37183;
            __result = D.37181 - D.37184;
            D.37185 = __s2_len > 2;
            D.37165 = __result == 0;
            D.37186 = D.37185 & D.37165;
            if (D.37186 != 0) goto <D.37187>; else goto <D.37188>;
            <D.37187>:
            D.37189 = &MEM[(void *)"TypeBuilder" + 3B];
            D.37190 = *D.37189;
            D.37191 = (int) D.37190;
            D.37192 = __s2 + 3;
            D.37193 = *D.37192;
            D.37194 = (int) D.37193;
            __result = D.37191 - D.37194;
            <D.37188>:
            <D.37178>:
            <D.37168>:
          }
          D.22734 = __result;
        }
        iftmp.719 = -D.22734;
        goto <D.37195>;
        <D.37156>:
        D.37150 = tb->parent;
        D.37157 = D.37150->vtable;
        D.37158 = D.37157->klass;
        D.37196 = D.37158->name;
        iftmp.719 = __builtin_strcmp (D.37196, "TypeBuilder");
        <D.37195>:
        D.22735 = iftmp.719;
      }
      if (D.22735 == 0) goto <D.37197>; else goto <D.37198>;
      <D.37197>:
      D.37150 = tb->parent;
      D.37199 = mono_reflection_type_get_handle (D.37150);
      parent = D.37199->data.klass;
      goto <D.37200>;
      <D.37198>:
      D.37150 = tb->parent;
      D.37201 = mono_reflection_type_get_handle (D.37150);
      parent = mono_class_from_mono_type (D.37201);
      <D.37200>:
      goto <D.37202>;
      <D.37153>:
      parent = 0B;
      <D.37202>:
      D.37203 = tb->type.type;
      if (D.37203 != 0B) goto <D.37204>; else goto <D.37205>;
      <D.37204>:
      D.37203 = tb->type.type;
      klass = mono_class_from_mono_type (D.37203);
      klass->parent = 0B;
      klass->supertypes = 0B;
      mono_class_setup_parent (klass, parent);
      mono_class_setup_mono_type (klass);
      mono_loader_unlock ();
      return;
      <D.37205>:
      D.37206 = tb->module;
      D.37207 = D.37206->dynamic_image;
      D.37208 = &D.37207->image;
      klass = mono_image_alloc0 (D.37208, 164);
      D.37206 = tb->module;
      D.37207 = D.37206->dynamic_image;
      D.37208 = &D.37207->image;
      klass->image = D.37208;
      klass->inited = 1;
      D.37209 = tb->name;
      D.37210 = klass->image;
      D.37211 = mono_string_to_utf8_image (D.37210, D.37209, &error);
      klass->name = D.37211;
      D.37212 = mono_error_ok (&error);
      if (D.37212 == 0) goto failure; else goto <D.37213>;
      <D.37213>:
      D.37214 = tb->nspace;
      D.37210 = klass->image;
      D.37215 = mono_string_to_utf8_image (D.37210, D.37214, &error);
      klass->name_space = D.37215;
      D.37216 = mono_error_ok (&error);
      if (D.37216 == 0) goto failure; else goto <D.37217>;
      <D.37217>:
      D.37218 = tb->table_idx;
      D.37219 = D.37218 | 33554432;
      klass->type_token = D.37219;
      D.37220 = tb->attrs;
      klass->flags = D.37220;
      mono_profiler_class_event (klass, 0);
      klass->element_class = klass;
      D.37221 = mono_class_get_ref_info (klass);
      if (D.37221 == 0B) goto <D.37222>; else goto <D.37223>;
      <D.37222>:
      mono_class_set_ref_info (klass, tb);
      D.37224 = tb->nesting_type;
      if (D.37224 == 0B) goto <D.37225>; else goto <D.37226>;
      <D.37225>:
      D.37218 = tb->table_idx;
      D.37227 = klass->name;
      D.37228 = klass->name_space;
      D.37210 = klass->image;
      mono_image_add_to_name_cache (D.37210, D.37228, D.37227, D.37218);
      <D.37226>:
      mono_image_append_class_to_reflection_info_set (klass);
      goto <D.37229>;
      <D.37223>:
      D.37230 = mono_class_get_ref_info (klass);
      D.37231 = D.37230 != tb;
      D.37232 = (long int) D.37231;
      D.37233 = __builtin_expect (D.37232, 0);
      if (D.37233 != 0) goto <D.37234>; else goto <D.37235>;
      <D.37234>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9854, "mono_class_get_ref_info (klass) == tb");
      <D.37235>:
      <D.37229>:
      D.37218 = tb->table_idx;
      D.37219 = D.37218 | 33554432;
      D.37236 = (void *) D.37219;
      D.37206 = tb->module;
      D.37207 = D.37206->dynamic_image;
      D.37237 = D.37207->tokens;
      mono_g_hash_table_insert (D.37237, D.37236, tb);
      if (parent != 0B) goto <D.37238>; else goto <D.37239>;
      <D.37238>:
      mono_class_setup_parent (klass, parent);
      goto <D.37240>;
      <D.37239>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37244 = "Object";
          D.37245 = MEM[(const unsigned char *)D.37244];
          D.37246 = (int) D.37245;
          D.37247 = *__s2;
          D.37248 = (int) D.37247;
          __result = D.37246 - D.37248;
          {
            D.37249 = __s2_len != 0;
            D.37250 = __result == 0;
            D.37251 = D.37249 & D.37250;
            if (D.37251 != 0) goto <D.37252>; else goto <D.37253>;
            <D.37252>:
            D.37254 = &MEM[(void *)"Object" + 1B];
            D.37255 = *D.37254;
            D.37256 = (int) D.37255;
            D.37257 = __s2 + 1;
            D.37258 = *D.37257;
            D.37259 = (int) D.37258;
            __result = D.37256 - D.37259;
            D.37260 = __s2_len > 1;
            D.37250 = __result == 0;
            D.37261 = D.37260 & D.37250;
            if (D.37261 != 0) goto <D.37262>; else goto <D.37263>;
            <D.37262>:
            D.37264 = &MEM[(void *)"Object" + 2B];
            D.37265 = *D.37264;
            D.37266 = (int) D.37265;
            D.37267 = __s2 + 2;
            D.37268 = *D.37267;
            D.37269 = (int) D.37268;
            __result = D.37266 - D.37269;
            D.37270 = __s2_len > 2;
            D.37250 = __result == 0;
            D.37271 = D.37270 & D.37250;
            if (D.37271 != 0) goto <D.37272>; else goto <D.37273>;
            <D.37272>:
            D.37274 = &MEM[(void *)"Object" + 3B];
            D.37275 = *D.37274;
            D.37276 = (int) D.37275;
            D.37277 = __s2 + 3;
            D.37278 = *D.37277;
            D.37279 = (int) D.37278;
            __result = D.37276 - D.37279;
            <D.37273>:
            <D.37263>:
            <D.37253>:
          }
          D.22744 = __result;
        }
        iftmp.720 = -D.22744;
        goto <D.37280>;
        <D.37243>:
        D.37227 = klass->name;
        iftmp.720 = __builtin_strcmp (D.37227, "Object");
        <D.37280>:
        D.22745 = iftmp.720;
      }
      if (D.22745 == 0) goto <D.37281>; else goto <D.37282>;
      <D.37281>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37286 = "System";
          D.37287 = MEM[(const unsigned char *)D.37286];
          D.37288 = (int) D.37287;
          D.37289 = *__s2;
          D.37290 = (int) D.37289;
          __result = D.37288 - D.37290;
          {
            D.37291 = __s2_len != 0;
            D.37292 = __result == 0;
            D.37293 = D.37291 & D.37292;
            if (D.37293 != 0) goto <D.37294>; else goto <D.37295>;
            <D.37294>:
            D.37296 = &MEM[(void *)"System" + 1B];
            D.37297 = *D.37296;
            D.37298 = (int) D.37297;
            D.37299 = __s2 + 1;
            D.37300 = *D.37299;
            D.37301 = (int) D.37300;
            __result = D.37298 - D.37301;
            D.37302 = __s2_len > 1;
            D.37292 = __result == 0;
            D.37303 = D.37302 & D.37292;
            if (D.37303 != 0) goto <D.37304>; else goto <D.37305>;
            <D.37304>:
            D.37306 = &MEM[(void *)"System" + 2B];
            D.37307 = *D.37306;
            D.37308 = (int) D.37307;
            D.37309 = __s2 + 2;
            D.37310 = *D.37309;
            D.37311 = (int) D.37310;
            __result = D.37308 - D.37311;
            D.37312 = __s2_len > 2;
            D.37292 = __result == 0;
            D.37313 = D.37312 & D.37292;
            if (D.37313 != 0) goto <D.37314>; else goto <D.37315>;
            <D.37314>:
            D.37316 = &MEM[(void *)"System" + 3B];
            D.37317 = *D.37316;
            D.37318 = (int) D.37317;
            D.37319 = __s2 + 3;
            D.37320 = *D.37319;
            D.37321 = (int) D.37320;
            __result = D.37318 - D.37321;
            <D.37315>:
            <D.37305>:
            <D.37295>:
          }
          D.22753 = __result;
        }
        iftmp.721 = -D.22753;
        goto <D.37322>;
        <D.37285>:
        D.37228 = klass->name_space;
        iftmp.721 = __builtin_strcmp (D.37228, "System");
        <D.37322>:
        D.22754 = iftmp.721;
      }
      if (D.22754 == 0) goto <D.37323>; else goto <D.37324>;
      <D.37323>:
      {
        const char * old_n;

        old_n = klass->name;
        klass->name = "BuildingObject";
        D.37325 = mono_defaults.object_class;
        mono_class_setup_parent (klass, D.37325);
        klass->name = old_n;
      }
      <D.37324>:
      <D.37282>:
      <D.37240>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37333 = "ValueType";
          D.37334 = MEM[(const unsigned char *)D.37333];
          D.37335 = (int) D.37334;
          D.37336 = *__s2;
          D.37337 = (int) D.37336;
          __result = D.37335 - D.37337;
          {
            D.37338 = __s2_len != 0;
            D.37339 = __result == 0;
            D.37340 = D.37338 & D.37339;
            if (D.37340 != 0) goto <D.37341>; else goto <D.37342>;
            <D.37341>:
            D.37343 = &MEM[(void *)"ValueType" + 1B];
            D.37344 = *D.37343;
            D.37345 = (int) D.37344;
            D.37346 = __s2 + 1;
            D.37347 = *D.37346;
            D.37348 = (int) D.37347;
            __result = D.37345 - D.37348;
            D.37349 = __s2_len > 1;
            D.37339 = __result == 0;
            D.37350 = D.37349 & D.37339;
            if (D.37350 != 0) goto <D.37351>; else goto <D.37352>;
            <D.37351>:
            D.37353 = &MEM[(void *)"ValueType" + 2B];
            D.37354 = *D.37353;
            D.37355 = (int) D.37354;
            D.37356 = __s2 + 2;
            D.37357 = *D.37356;
            D.37358 = (int) D.37357;
            __result = D.37355 - D.37358;
            D.37359 = __s2_len > 2;
            D.37339 = __result == 0;
            D.37360 = D.37359 & D.37339;
            if (D.37360 != 0) goto <D.37361>; else goto <D.37362>;
            <D.37361>:
            D.37363 = &MEM[(void *)"ValueType" + 3B];
            D.37364 = *D.37363;
            D.37365 = (int) D.37364;
            D.37366 = __s2 + 3;
            D.37367 = *D.37366;
            D.37368 = (int) D.37367;
            __result = D.37365 - D.37368;
            <D.37362>:
            <D.37352>:
            <D.37342>:
          }
          D.22763 = __result;
        }
        iftmp.722 = -D.22763;
        goto <D.37369>;
        <D.37332>:
        D.37227 = klass->name;
        iftmp.722 = __builtin_strcmp (D.37227, "ValueType");
        <D.37369>:
        D.22764 = iftmp.722;
      }
      if (D.22764 == 0) goto <D.37370>; else goto <D.37326>;
      <D.37370>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37286 = "System";
          D.37287 = MEM[(const unsigned char *)D.37286];
          D.37288 = (int) D.37287;
          D.37374 = *__s2;
          D.37375 = (int) D.37374;
          __result = D.37288 - D.37375;
          {
            D.37376 = __s2_len != 0;
            D.37377 = __result == 0;
            D.37378 = D.37376 & D.37377;
            if (D.37378 != 0) goto <D.37379>; else goto <D.37380>;
            <D.37379>:
            D.37296 = &MEM[(void *)"System" + 1B];
            D.37297 = *D.37296;
            D.37298 = (int) D.37297;
            D.37381 = __s2 + 1;
            D.37382 = *D.37381;
            D.37383 = (int) D.37382;
            __result = D.37298 - D.37383;
            D.37384 = __s2_len > 1;
            D.37377 = __result == 0;
            D.37385 = D.37384 & D.37377;
            if (D.37385 != 0) goto <D.37386>; else goto <D.37387>;
            <D.37386>:
            D.37306 = &MEM[(void *)"System" + 2B];
            D.37307 = *D.37306;
            D.37308 = (int) D.37307;
            D.37388 = __s2 + 2;
            D.37389 = *D.37388;
            D.37390 = (int) D.37389;
            __result = D.37308 - D.37390;
            D.37391 = __s2_len > 2;
            D.37377 = __result == 0;
            D.37392 = D.37391 & D.37377;
            if (D.37392 != 0) goto <D.37393>; else goto <D.37394>;
            <D.37393>:
            D.37316 = &MEM[(void *)"System" + 3B];
            D.37317 = *D.37316;
            D.37318 = (int) D.37317;
            D.37395 = __s2 + 3;
            D.37396 = *D.37395;
            D.37397 = (int) D.37396;
            __result = D.37318 - D.37397;
            <D.37394>:
            <D.37387>:
            <D.37380>:
          }
          D.22772 = __result;
        }
        iftmp.723 = -D.22772;
        goto <D.37398>;
        <D.37373>:
        D.37228 = klass->name_space;
        iftmp.723 = __builtin_strcmp (D.37228, "System");
        <D.37398>:
        D.22773 = iftmp.723;
      }
      if (D.22773 == 0) goto <D.37327>; else goto <D.37326>;
      <D.37326>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37244 = "Object";
          D.37245 = MEM[(const unsigned char *)D.37244];
          D.37246 = (int) D.37245;
          D.37402 = *__s2;
          D.37403 = (int) D.37402;
          __result = D.37246 - D.37403;
          {
            D.37404 = __s2_len != 0;
            D.37405 = __result == 0;
            D.37406 = D.37404 & D.37405;
            if (D.37406 != 0) goto <D.37407>; else goto <D.37408>;
            <D.37407>:
            D.37254 = &MEM[(void *)"Object" + 1B];
            D.37255 = *D.37254;
            D.37256 = (int) D.37255;
            D.37409 = __s2 + 1;
            D.37410 = *D.37409;
            D.37411 = (int) D.37410;
            __result = D.37256 - D.37411;
            D.37412 = __s2_len > 1;
            D.37405 = __result == 0;
            D.37413 = D.37412 & D.37405;
            if (D.37413 != 0) goto <D.37414>; else goto <D.37415>;
            <D.37414>:
            D.37264 = &MEM[(void *)"Object" + 2B];
            D.37265 = *D.37264;
            D.37266 = (int) D.37265;
            D.37416 = __s2 + 2;
            D.37417 = *D.37416;
            D.37418 = (int) D.37417;
            __result = D.37266 - D.37418;
            D.37419 = __s2_len > 2;
            D.37405 = __result == 0;
            D.37420 = D.37419 & D.37405;
            if (D.37420 != 0) goto <D.37421>; else goto <D.37422>;
            <D.37421>:
            D.37274 = &MEM[(void *)"Object" + 3B];
            D.37275 = *D.37274;
            D.37276 = (int) D.37275;
            D.37423 = __s2 + 3;
            D.37424 = *D.37423;
            D.37425 = (int) D.37424;
            __result = D.37276 - D.37425;
            <D.37422>:
            <D.37415>:
            <D.37408>:
          }
          D.22781 = __result;
        }
        iftmp.724 = -D.22781;
        goto <D.37426>;
        <D.37401>:
        D.37227 = klass->name;
        iftmp.724 = __builtin_strcmp (D.37227, "Object");
        <D.37426>:
        D.22782 = iftmp.724;
      }
      if (D.22782 == 0) goto <D.37427>; else goto <D.37328>;
      <D.37427>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37286 = "System";
          D.37287 = MEM[(const unsigned char *)D.37286];
          D.37288 = (int) D.37287;
          D.37431 = *__s2;
          D.37432 = (int) D.37431;
          __result = D.37288 - D.37432;
          {
            D.37433 = __s2_len != 0;
            D.37434 = __result == 0;
            D.37435 = D.37433 & D.37434;
            if (D.37435 != 0) goto <D.37436>; else goto <D.37437>;
            <D.37436>:
            D.37296 = &MEM[(void *)"System" + 1B];
            D.37297 = *D.37296;
            D.37298 = (int) D.37297;
            D.37438 = __s2 + 1;
            D.37439 = *D.37438;
            D.37440 = (int) D.37439;
            __result = D.37298 - D.37440;
            D.37441 = __s2_len > 1;
            D.37434 = __result == 0;
            D.37442 = D.37441 & D.37434;
            if (D.37442 != 0) goto <D.37443>; else goto <D.37444>;
            <D.37443>:
            D.37306 = &MEM[(void *)"System" + 2B];
            D.37307 = *D.37306;
            D.37308 = (int) D.37307;
            D.37445 = __s2 + 2;
            D.37446 = *D.37445;
            D.37447 = (int) D.37446;
            __result = D.37308 - D.37447;
            D.37448 = __s2_len > 2;
            D.37434 = __result == 0;
            D.37449 = D.37448 & D.37434;
            if (D.37449 != 0) goto <D.37450>; else goto <D.37451>;
            <D.37450>:
            D.37316 = &MEM[(void *)"System" + 3B];
            D.37317 = *D.37316;
            D.37318 = (int) D.37317;
            D.37452 = __s2 + 3;
            D.37453 = *D.37452;
            D.37454 = (int) D.37453;
            __result = D.37318 - D.37454;
            <D.37451>:
            <D.37444>:
            <D.37437>:
          }
          D.22790 = __result;
        }
        iftmp.725 = -D.22790;
        goto <D.37455>;
        <D.37430>:
        D.37228 = klass->name_space;
        iftmp.725 = __builtin_strcmp (D.37228, "System");
        <D.37455>:
        D.22791 = iftmp.725;
      }
      if (D.22791 == 0) goto <D.37327>; else goto <D.37328>;
      <D.37328>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37459 = "Enum";
          D.37460 = MEM[(const unsigned char *)D.37459];
          D.37461 = (int) D.37460;
          D.37462 = *__s2;
          D.37463 = (int) D.37462;
          __result = D.37461 - D.37463;
          {
            D.37464 = __s2_len != 0;
            D.37465 = __result == 0;
            D.37466 = D.37464 & D.37465;
            if (D.37466 != 0) goto <D.37467>; else goto <D.37468>;
            <D.37467>:
            D.37469 = &MEM[(void *)"Enum" + 1B];
            D.37470 = *D.37469;
            D.37471 = (int) D.37470;
            D.37472 = __s2 + 1;
            D.37473 = *D.37472;
            D.37474 = (int) D.37473;
            __result = D.37471 - D.37474;
            D.37475 = __s2_len > 1;
            D.37465 = __result == 0;
            D.37476 = D.37475 & D.37465;
            if (D.37476 != 0) goto <D.37477>; else goto <D.37478>;
            <D.37477>:
            D.37479 = &MEM[(void *)"Enum" + 2B];
            D.37480 = *D.37479;
            D.37481 = (int) D.37480;
            D.37482 = __s2 + 2;
            D.37483 = *D.37482;
            D.37484 = (int) D.37483;
            __result = D.37481 - D.37484;
            D.37485 = __s2_len > 2;
            D.37465 = __result == 0;
            D.37486 = D.37485 & D.37465;
            if (D.37486 != 0) goto <D.37487>; else goto <D.37488>;
            <D.37487>:
            D.37489 = &MEM[(void *)"Enum" + 3B];
            D.37490 = *D.37489;
            D.37491 = (int) D.37490;
            D.37492 = __s2 + 3;
            D.37493 = *D.37492;
            D.37494 = (int) D.37493;
            __result = D.37491 - D.37494;
            <D.37488>:
            <D.37478>:
            <D.37468>:
          }
          D.22799 = __result;
        }
        iftmp.726 = -D.22799;
        goto <D.37495>;
        <D.37458>:
        D.37227 = klass->name;
        iftmp.726 = __builtin_strcmp (D.37227, "Enum");
        <D.37495>:
        D.22800 = iftmp.726;
      }
      if (D.22800 == 0) goto <D.37496>; else goto <D.37329>;
      <D.37496>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37286 = "System";
          D.37287 = MEM[(const unsigned char *)D.37286];
          D.37288 = (int) D.37287;
          D.37500 = *__s2;
          D.37501 = (int) D.37500;
          __result = D.37288 - D.37501;
          {
            D.37502 = __s2_len != 0;
            D.37503 = __result == 0;
            D.37504 = D.37502 & D.37503;
            if (D.37504 != 0) goto <D.37505>; else goto <D.37506>;
            <D.37505>:
            D.37296 = &MEM[(void *)"System" + 1B];
            D.37297 = *D.37296;
            D.37298 = (int) D.37297;
            D.37507 = __s2 + 1;
            D.37508 = *D.37507;
            D.37509 = (int) D.37508;
            __result = D.37298 - D.37509;
            D.37510 = __s2_len > 1;
            D.37503 = __result == 0;
            D.37511 = D.37510 & D.37503;
            if (D.37511 != 0) goto <D.37512>; else goto <D.37513>;
            <D.37512>:
            D.37306 = &MEM[(void *)"System" + 2B];
            D.37307 = *D.37306;
            D.37308 = (int) D.37307;
            D.37514 = __s2 + 2;
            D.37515 = *D.37514;
            D.37516 = (int) D.37515;
            __result = D.37308 - D.37516;
            D.37517 = __s2_len > 2;
            D.37503 = __result == 0;
            D.37518 = D.37517 & D.37503;
            if (D.37518 != 0) goto <D.37519>; else goto <D.37520>;
            <D.37519>:
            D.37316 = &MEM[(void *)"System" + 3B];
            D.37317 = *D.37316;
            D.37318 = (int) D.37317;
            D.37521 = __s2 + 3;
            D.37522 = *D.37521;
            D.37523 = (int) D.37522;
            __result = D.37318 - D.37523;
            <D.37520>:
            <D.37513>:
            <D.37506>:
          }
          D.22808 = __result;
        }
        iftmp.727 = -D.22808;
        goto <D.37524>;
        <D.37499>:
        D.37228 = klass->name_space;
        iftmp.727 = __builtin_strcmp (D.37228, "System");
        <D.37524>:
        D.22809 = iftmp.727;
      }
      if (D.22809 == 0) goto <D.37327>; else goto <D.37329>;
      <D.37327>:
      klass->instance_size = 8;
      klass->size_inited = 1;
      mono_class_setup_vtable_general (klass, 0B, 0, 0B);
      <D.37329>:
      mono_class_setup_mono_type (klass);
      mono_class_setup_supertypes (klass);
      D.37525 = &klass->byval_arg;
      tb->type.type = D.37525;
      D.37224 = tb->nesting_type;
      if (D.37224 != 0B) goto <D.37526>; else goto <D.37527>;
      <D.37526>:
      D.37224 = tb->nesting_type;
      D.37528 = D.37224->type;
      D.37529 = D.37528 == 0B;
      D.37530 = (long int) D.37529;
      D.37531 = __builtin_expect (D.37530, 0);
      if (D.37531 != 0) goto <D.37532>; else goto <D.37533>;
      <D.37532>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9889, "tb->nesting_type->type");
      <D.37533>:
      D.37224 = tb->nesting_type;
      D.37534 = mono_reflection_type_get_handle (D.37224);
      D.37535 = mono_class_from_mono_type (D.37534);
      klass->nested_in = D.37535;
      <D.37527>:
      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.37539;
  int iftmp.728;
  struct MonoArray * D.37541;
  unsigned int D.37544;
  struct MonoGenericContainer * D.37548;
  int iftmp.729;
  struct MonoGenericContainer * D.37554;
  struct MonoClass * D.37556;
  _Bool D.37557;
  long int D.37558;
  long int D.37559;
  struct MonoImage * D.37562;
  void * D.37563;
  <unnamed-signed:31> D.37564;
  unsigned int count.730;
  unsigned int D.37566;
  void * D.37567;
  unsigned int i.731;
  char * D.37569;
  struct MonoType * D.37570;
  struct MonoGenericParamFull * D.37571;
  unsigned int i.732;
  unsigned int D.37573;
  struct MonoGenericParamFull * D.37574;
  unsigned int D.37575;
  short unsigned int D.37576;
  struct MonoGenericContainer * D.37577;
  _Bool D.37578;
  long int D.37579;
  long int D.37580;
  struct MonoGenericInst * D.37583;
  struct MonoClass * klass;
  int count;
  int i;

  D.37539 = tb->type.type;
  klass = mono_class_from_mono_type (D.37539);
  D.37541 = tb->generic_params;
  if (D.37541 != 0B) goto <D.37542>; else goto <D.37543>;
  <D.37542>:
  D.37541 = tb->generic_params;
  D.37544 = mono_array_length (D.37541);
  iftmp.728 = (int) D.37544;
  goto <D.37545>;
  <D.37543>:
  iftmp.728 = 0;
  <D.37545>:
  count = iftmp.728;
  D.37548 = klass->generic_container;
  if (D.37548 != 0B) goto <D.37546>; else goto <D.37549>;
  <D.37549>:
  if (count == 0) goto <D.37546>; else goto <D.37547>;
  <D.37546>:
  return;
  <D.37547>:
  D.37554 = tb->generic_container;
  if (D.37554 == 0B) goto <D.37551>; else goto <D.37555>;
  <D.37555>:
  D.37554 = tb->generic_container;
  D.37556 = D.37554->owner.klass;
  if (D.37556 != klass) goto <D.37551>; else goto <D.37552>;
  <D.37551>:
  iftmp.729 = 1;
  goto <D.37553>;
  <D.37552>:
  iftmp.729 = 0;
  <D.37553>:
  D.37557 = iftmp.729 != 0;
  D.37558 = (long int) D.37557;
  D.37559 = __builtin_expect (D.37558, 0);
  if (D.37559 != 0) goto <D.37560>; else goto <D.37561>;
  <D.37560>:
  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.37561>:
  D.37562 = klass->image;
  D.37563 = mono_image_alloc0 (D.37562, 28);
  klass->generic_container = D.37563;
  D.37548 = klass->generic_container;
  D.37548->owner.klass = klass;
  D.37548 = klass->generic_container;
  D.37564 = (<unnamed-signed:31>) count;
  D.37548->type_argc = D.37564;
  D.37548 = klass->generic_container;
  count.730 = (unsigned int) count;
  D.37566 = count.730 * 32;
  D.37562 = klass->image;
  D.37567 = mono_image_alloc0 (D.37562, D.37566);
  D.37548->type_params = D.37567;
  klass->is_generic = 1;
  i = 0;
  goto <D.22822>;
  <D.22821>:
  {
    struct MonoReflectionGenericParam * gparam;
    struct MonoGenericParamFull * param;

    i.731 = (unsigned int) i;
    D.37541 = tb->generic_params;
    D.37569 = mono_array_addr_with_size (D.37541, 4, i.731);
    gparam = MEM[(void * *)D.37569];
    D.37570 = mono_reflection_type_get_handle (gparam);
    param = D.37570->data.generic_param;
    D.37548 = klass->generic_container;
    D.37571 = D.37548->type_params;
    i.732 = (unsigned int) i;
    D.37573 = i.732 * 32;
    D.37574 = D.37571 + D.37573;
    *D.37574 = *param;
    D.37548 = klass->generic_container;
    D.37571 = D.37548->type_params;
    i.732 = (unsigned int) i;
    D.37573 = i.732 * 32;
    D.37574 = D.37571 + D.37573;
    D.37548 = klass->generic_container;
    D.37574->param.owner = D.37548;
    D.37548 = klass->generic_container;
    D.37571 = D.37548->type_params;
    i.732 = (unsigned int) i;
    D.37573 = i.732 * 32;
    D.37574 = D.37571 + D.37573;
    D.37574->info.pklass = 0B;
    D.37548 = klass->generic_container;
    D.37571 = D.37548->type_params;
    i.732 = (unsigned int) i;
    D.37573 = i.732 * 32;
    D.37574 = D.37571 + D.37573;
    D.37575 = gparam->attrs;
    D.37576 = (short unsigned int) D.37575;
    D.37574->info.flags = D.37576;
    D.37548 = klass->generic_container;
    D.37571 = D.37548->type_params;
    i.732 = (unsigned int) i;
    D.37573 = i.732 * 32;
    D.37574 = D.37571 + D.37573;
    D.37577 = D.37574->param.owner;
    D.37578 = D.37577 == 0B;
    D.37579 = (long int) D.37578;
    D.37580 = __builtin_expect (D.37579, 0);
    if (D.37580 != 0) goto <D.37581>; else goto <D.37582>;
    <D.37581>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9956, "klass->generic_container->type_params [i].param.owner");
    <D.37582>:
  }
  i = i + 1;
  <D.22822>:
  if (i < count) goto <D.22821>; else goto <D.22823>;
  <D.22823>:
  D.37548 = klass->generic_container;
  D.37548 = klass->generic_container;
  D.37583 = mono_get_shared_generic_inst (D.37548);
  D.37548->context.class_inst = D.37583;
}


mono_reflection_create_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoType * D.37585;
  unsigned char D.37586;
  unsigned char D.37587;
  struct MonoType * D.37590;
  struct MonoArray * D.37593;
  _Bool D.37594;
  long int D.37595;
  long int D.37596;
  unsigned int D.37599;
  _Bool D.37600;
  long int D.37601;
  long int D.37602;
  char * D.37605;
  struct MonoObject * D.37606;
  struct MonoType * D.37607;
  int D.37608;
  struct MonoClass * D.37611;
  struct MonoClass * D.37612;
  struct MonoClass * D.37615;
  int D.37616;
  struct MonoClass * klass;

  D.37585 = tb->type.type;
  klass = mono_class_from_mono_type (D.37585);
  mono_loader_lock ();
  D.37586 = BIT_FIELD_REF <*klass, 8, 160>;
  D.37587 = D.37586 & 16;
  if (D.37587 != 0) goto <D.37588>; else goto <D.37589>;
  <D.37588>:
  D.37590 = mono_class_enum_basetype (klass);
  if (D.37590 == 0B) goto <D.37591>; else goto <D.37592>;
  <D.37591>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoClass * ec;
    struct MonoType * enum_basetype;

    D.37593 = tb->fields;
    D.37594 = D.37593 == 0B;
    D.37595 = (long int) D.37594;
    D.37596 = __builtin_expect (D.37595, 0);
    if (D.37596 != 0) goto <D.37597>; else goto <D.37598>;
    <D.37597>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9983, "tb->fields != NULL");
    <D.37598>:
    D.37593 = tb->fields;
    D.37599 = mono_array_length (D.37593);
    D.37600 = D.37599 == 0;
    D.37601 = (long int) D.37600;
    D.37602 = __builtin_expect (D.37601, 0);
    if (D.37602 != 0) goto <D.37603>; else goto <D.37604>;
    <D.37603>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9984, "mono_array_length (tb->fields) >= 1");
    <D.37604>:
    D.37593 = tb->fields;
    D.37605 = mono_array_addr_with_size (D.37593, 4, 0);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.37605];
    D.37606 = fb->type;
    D.37607 = mono_reflection_type_get_handle (D.37606);
    D.37608 = mono_type_is_valid_enum_basetype (D.37607);
    if (D.37608 == 0) goto <D.37609>; else goto <D.37610>;
    <D.37609>:
    mono_loader_unlock ();
    return;
    <D.37610>:
    D.37606 = fb->type;
    enum_basetype = mono_reflection_type_get_handle (D.37606);
    D.37611 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.37611;
    D.37612 = klass->element_class;
    if (D.37612 == 0B) goto <D.37613>; else goto <D.37614>;
    <D.37613>:
    D.37615 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.37615;
    <D.37614>:
    ec = default_class_from_mono_type (enum_basetype);
    D.37616 = ec->instance_size;
    klass->instance_size = D.37616;
    klass->size_inited = 1;
    mono_class_setup_vtable_general (klass, 0B, 0, 0B);
  }
  <D.37592>:
  <D.37589>:
  mono_loader_unlock ();
}


default_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.37618;
  int D.37619;
  struct MonoClass * D.37620;

  D.37618 = type->type;
  D.37619 = (int) D.37618;
  switch (D.37619) <default: <D.18449>, case 1: <D.18433>, case 2: <D.18434>, case 3: <D.18435>, case 4: <D.18436>, case 5: <D.18437>, case 6: <D.18438>, case 7: <D.18439>, case 8: <D.18440>, case 9: <D.18441>, case 10: <D.18444>, case 11: <D.18445>, case 12: <D.18446>, case 13: <D.18447>, case 14: <D.18448>, case 24: <D.18442>, case 25: <D.18443>, case 28: <D.18432>>
  <D.18432>:
  D.37620 = mono_defaults.object_class;
  return D.37620;
  <D.18433>:
  D.37620 = mono_defaults.void_class;
  return D.37620;
  <D.18434>:
  D.37620 = mono_defaults.boolean_class;
  return D.37620;
  <D.18435>:
  D.37620 = mono_defaults.char_class;
  return D.37620;
  <D.18436>:
  D.37620 = mono_defaults.sbyte_class;
  return D.37620;
  <D.18437>:
  D.37620 = mono_defaults.byte_class;
  return D.37620;
  <D.18438>:
  D.37620 = mono_defaults.int16_class;
  return D.37620;
  <D.18439>:
  D.37620 = mono_defaults.uint16_class;
  return D.37620;
  <D.18440>:
  D.37620 = mono_defaults.int32_class;
  return D.37620;
  <D.18441>:
  D.37620 = mono_defaults.uint32_class;
  return D.37620;
  <D.18442>:
  D.37620 = mono_defaults.int_class;
  return D.37620;
  <D.18443>:
  D.37620 = mono_defaults.uint_class;
  return D.37620;
  <D.18444>:
  D.37620 = mono_defaults.int64_class;
  return D.37620;
  <D.18445>:
  D.37620 = mono_defaults.uint64_class;
  return D.37620;
  <D.18446>:
  D.37620 = mono_defaults.single_class;
  return D.37620;
  <D.18447>:
  D.37620 = mono_defaults.double_class;
  return D.37620;
  <D.18448>:
  D.37620 = mono_defaults.string_class;
  return D.37620;
  <D.18449>:
  D.37618 = type->type;
  D.37619 = (int) D.37618;
  monoeg_g_log (0B, 16, "default_class_from_mono_type: implement me 0x%02x\n", D.37619);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 616);
  D.37620 = 0B;
  return D.37620;
}


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.37625;
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.734;
  _Bool D.37627;
  long int D.37628;
  long int D.37629;
  <unnamed type> D.37632;
  unsigned int D.37633;
  <unnamed type> D.37634;
  int D.37635;
  short int D.37636;
  char * D.37639;
  struct MonoImage * D.37642;
  struct MonoReflectionType * D.37645;
  struct MonoReflectionType * * D.37646;
  struct MonoString * D.37647;
  struct MonoString * * D.37648;
  char * D.37649;
  struct MonoString * D.37652;
  struct MonoString * * D.37653;
  struct MonoReflectionMarshalAsAttribute * D.37654;
  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.37623>; else goto <D.37624>;
  <D.37623>:
  D.37625 = mono_defaults.corlib;
  System_Reflection_Emit_MarshalAsAttribute.734 = mono_class_from_name (D.37625, "System.Runtime.InteropServices", "MarshalAsAttribute");
  System_Reflection_Emit_MarshalAsAttribute = System_Reflection_Emit_MarshalAsAttribute.734;
  System_Reflection_Emit_MarshalAsAttribute.733 = System_Reflection_Emit_MarshalAsAttribute;
  D.37627 = System_Reflection_Emit_MarshalAsAttribute.733 == 0B;
  D.37628 = (long int) D.37627;
  D.37629 = __builtin_expect (D.37628, 0);
  if (D.37629 != 0) goto <D.37630>; else goto <D.37631>;
  <D.37630>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10070, "System_Reflection_Emit_MarshalAsAttribute");
  <D.37631>:
  <D.37624>:
  System_Reflection_Emit_MarshalAsAttribute.733 = System_Reflection_Emit_MarshalAsAttribute;
  minfo = mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute.733);
  D.37632 = spec->native;
  minfo->utype = D.37632;
  D.37633 = minfo->utype;
  switch (D.37633) <default: <D.22856>, case 23: <D.22853>, case 30: <D.22854>, case 42: <D.22851>, case 44: <D.22855>>
  <D.22851>:
  D.37634 = spec->data.array_data.elem_type;
  minfo->array_subtype = D.37634;
  D.37635 = spec->data.array_data.num_elem;
  minfo->size_const = D.37635;
  D.37636 = spec->data.array_data.param_num;
  if (D.37636 != -1) goto <D.37637>; else goto <D.37638>;
  <D.37637>:
  D.37636 = spec->data.array_data.param_num;
  minfo->size_param_index = D.37636;
  <D.37638>:
  goto <D.22852>;
  <D.22853>:
  <D.22854>:
  D.37635 = spec->data.array_data.num_elem;
  minfo->size_const = D.37635;
  goto <D.22852>;
  <D.22855>:
  D.37639 = spec->data.custom_data.custom_name;
  if (D.37639 != 0B) goto <D.37640>; else goto <D.37641>;
  <D.37640>:
  D.37642 = klass->image;
  D.37639 = spec->data.custom_data.custom_name;
  mtype = mono_reflection_type_from_name (D.37639, D.37642);
  if (mtype != 0B) goto <D.37643>; else goto <D.37644>;
  <D.37643>:
  D.37645 = mono_type_get_object (domain, mtype);
  D.37646 = &minfo->marshal_type_ref;
  mono_gc_wbarrier_set_field (minfo, D.37646, D.37645);
  <D.37644>:
  D.37639 = spec->data.custom_data.custom_name;
  D.37647 = mono_string_new (domain, D.37639);
  D.37648 = &minfo->marshal_type;
  mono_gc_wbarrier_set_field (minfo, D.37648, D.37647);
  <D.37641>:
  D.37649 = spec->data.custom_data.cookie;
  if (D.37649 != 0B) goto <D.37650>; else goto <D.37651>;
  <D.37650>:
  D.37649 = spec->data.custom_data.cookie;
  D.37652 = mono_string_new (domain, D.37649);
  D.37653 = &minfo->marshal_cookie;
  mono_gc_wbarrier_set_field (minfo, D.37653, D.37652);
  <D.37651>:
  goto <D.22852>;
  <D.22856>:
  goto <D.22852>;
  <D.22852>:
  D.37654 = minfo;
  return D.37654;
}


mono_reflection_bind_generic_parameters (struct MonoReflectionType * type, int type_argc, struct MonoType * * types)
{
  struct MonoVTable * D.37657;
  struct MonoClass * D.37658;
  int D.37659;
  int D.37663;
  struct MonoVTable * D.37666;
  struct MonoClass * D.37667;
  int D.37668;
  struct MonoGenericContainer * D.37673;
  struct MonoType * D.37676;
  struct MonoGenericContainer * D.37677;
  struct MonoType * D.37680;
  unsigned char D.37681;
  unsigned char D.37682;
  struct MonoClass * klass;
  struct MonoReflectionTypeBuilder * tb;
  gboolean is_dynamic;
  struct MonoDomain * domain;
  struct MonoClass * geninst;

  tb = 0B;
  is_dynamic = 0;
  mono_loader_lock ();
  D.37657 = MEM[(struct MonoObject *)type].vtable;
  domain = D.37657->domain;
  D.37657 = MEM[(struct MonoObject *)type].vtable;
  D.37658 = D.37657->klass;
  D.37659 = is_sre_type_builder (D.37658);
  if (D.37659 != 0) goto <D.37660>; else goto <D.37661>;
  <D.37660>:
  tb = type;
  is_dynamic = 1;
  goto <D.37662>;
  <D.37661>:
  D.37657 = MEM[(struct MonoObject *)type].vtable;
  D.37658 = D.37657->klass;
  D.37663 = is_sre_generic_instance (D.37658);
  if (D.37663 != 0) goto <D.37664>; else goto <D.37665>;
  <D.37664>:
  {
    struct MonoReflectionGenericClass * rgi;
    struct MonoReflectionType * gtd;

    rgi = type;
    gtd = rgi->generic_type;
    D.37666 = MEM[(struct MonoObject *)gtd].vtable;
    D.37667 = D.37666->klass;
    D.37668 = is_sre_type_builder (D.37667);
    if (D.37668 != 0) goto <D.37669>; else goto <D.37670>;
    <D.37669>:
    tb = gtd;
    is_dynamic = 1;
    <D.37670>:
  }
  <D.37665>:
  <D.37662>:
  if (tb != 0B) goto <D.37671>; else goto <D.37672>;
  <D.37671>:
  D.37673 = tb->generic_container;
  if (D.37673 != 0B) goto <D.37674>; else goto <D.37675>;
  <D.37674>:
  mono_reflection_create_generic_class (tb);
  <D.37675>:
  <D.37672>:
  D.37676 = mono_reflection_type_get_handle (type);
  klass = mono_class_from_mono_type (D.37676);
  D.37677 = klass->generic_container;
  if (D.37677 == 0B) goto <D.37678>; else goto <D.37679>;
  <D.37678>:
  mono_loader_unlock ();
  D.37680 = 0B;
  return D.37680;
  <D.37679>:
  D.37681 = BIT_FIELD_REF <*klass, 8, 160>;
  D.37682 = D.37681 & 128;
  if (D.37682 != 0) goto <D.37683>; else goto <D.37684>;
  <D.37683>:
  tb = mono_class_get_ref_info (klass);
  is_dynamic = 1;
  <D.37684>:
  mono_loader_unlock ();
  geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
  D.37680 = &geninst->byval_arg;
  return D.37680;
}


mono_class_bind_generic_parameters (struct MonoClass * klass, int type_argc, struct MonoType * * types, gboolean is_dynamic)
{
  struct MonoGenericContainer * D.37686;
  _Bool D.37687;
  long int D.37688;
  long int D.37689;
  struct MonoClass * D.37692;
  struct MonoGenericClass * gclass;
  struct MonoGenericInst * inst;

  D.37686 = klass->generic_container;
  D.37687 = D.37686 == 0B;
  D.37688 = (long int) D.37687;
  D.37689 = __builtin_expect (D.37688, 0);
  if (D.37689 != 0) goto <D.37690>; else goto <D.37691>;
  <D.37690>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10507, "klass->generic_container");
  <D.37691>:
  inst = mono_metadata_get_generic_inst (type_argc, types);
  gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
  D.37692 = mono_generic_class_get_class (gclass);
  return D.37692;
}


mono_reflection_bind_generic_method_parameters (struct MonoReflectionMethod * rmethod, struct MonoArray * types)
{
  int D.22982;
  int iftmp.735;
  int D.22981;
  struct MonoVTable * D.37697;
  struct MonoClass * D.37698;
  const char[14] * D.37699;
  unsigned char D.37700;
  int D.37701;
  unsigned char D.37702;
  int D.37703;
  _Bool D.37704;
  _Bool D.37705;
  _Bool D.37706;
  const unsigned char * D.37709;
  unsigned char D.37710;
  int D.37711;
  const unsigned char * D.37712;
  unsigned char D.37713;
  int D.37714;
  _Bool D.37715;
  _Bool D.37716;
  const unsigned char * D.37719;
  unsigned char D.37720;
  int D.37721;
  const unsigned char * D.37722;
  unsigned char D.37723;
  int D.37724;
  _Bool D.37725;
  _Bool D.37726;
  const unsigned char * D.37729;
  unsigned char D.37730;
  int D.37731;
  const unsigned char * D.37732;
  unsigned char D.37733;
  int D.37734;
  const char * D.37736;
  struct MonoType * D.37739;
  unsigned char D.37741;
  unsigned char D.37742;
  struct MonoMethodSignature * D.37745;
  short unsigned int D.37746;
  unsigned int count.736;
  unsigned int D.37748;
  struct MonoReflectionMethod * D.37751;
  unsigned int count.737;
  unsigned int D.37753;
  unsigned int i.738;
  char * D.37755;
  unsigned int i.739;
  unsigned int D.37757;
  struct MonoType * * D.37758;
  struct MonoType * D.37759;
  struct MonoGenericInst * iftmp.740;
  struct MonoGenericClass * D.37761;
  struct MonoClass * D.37765;
  struct MonoImage * D.37766;
  unsigned char D.37767;
  unsigned char D.37768;
  struct MonoGHashTable * D.37771;
  int D.37772;
  struct MonoException * D.37775;
  struct MonoVTable * D.37776;
  struct MonoDomain * D.37777;
  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.37695>; else goto <D.37696>;
        <D.37695>:
        {
          const unsigned char * __s2;
          int __result;

          D.37697 = rmethod->object.vtable;
          D.37698 = D.37697->klass;
          __s2 = D.37698->name;
          D.37699 = "MethodBuilder";
          D.37700 = MEM[(const unsigned char *)D.37699];
          D.37701 = (int) D.37700;
          D.37702 = *__s2;
          D.37703 = (int) D.37702;
          __result = D.37701 - D.37703;
          {
            D.37704 = __s2_len != 0;
            D.37705 = __result == 0;
            D.37706 = D.37704 & D.37705;
            if (D.37706 != 0) goto <D.37707>; else goto <D.37708>;
            <D.37707>:
            D.37709 = &MEM[(void *)"MethodBuilder" + 1B];
            D.37710 = *D.37709;
            D.37711 = (int) D.37710;
            D.37712 = __s2 + 1;
            D.37713 = *D.37712;
            D.37714 = (int) D.37713;
            __result = D.37711 - D.37714;
            D.37715 = __s2_len > 1;
            D.37705 = __result == 0;
            D.37716 = D.37715 & D.37705;
            if (D.37716 != 0) goto <D.37717>; else goto <D.37718>;
            <D.37717>:
            D.37719 = &MEM[(void *)"MethodBuilder" + 2B];
            D.37720 = *D.37719;
            D.37721 = (int) D.37720;
            D.37722 = __s2 + 2;
            D.37723 = *D.37722;
            D.37724 = (int) D.37723;
            __result = D.37721 - D.37724;
            D.37725 = __s2_len > 2;
            D.37705 = __result == 0;
            D.37726 = D.37725 & D.37705;
            if (D.37726 != 0) goto <D.37727>; else goto <D.37728>;
            <D.37727>:
            D.37729 = &MEM[(void *)"MethodBuilder" + 3B];
            D.37730 = *D.37729;
            D.37731 = (int) D.37730;
            D.37732 = __s2 + 3;
            D.37733 = *D.37732;
            D.37734 = (int) D.37733;
            __result = D.37731 - D.37734;
            <D.37728>:
            <D.37718>:
            <D.37708>:
          }
          D.22981 = __result;
        }
        iftmp.735 = -D.22981;
        goto <D.37735>;
        <D.37696>:
        D.37697 = rmethod->object.vtable;
        D.37698 = D.37697->klass;
        D.37736 = D.37698->name;
        iftmp.735 = __builtin_strcmp (D.37736, "MethodBuilder");
        <D.37735>:
        D.22982 = iftmp.735;
      }
      if (D.22982 == 0) goto <D.37737>; else goto <D.37738>;
      <D.37737>:
      {
        struct MonoReflectionMethodBuilder * mb;
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        mb = 0B;
        mb = rmethod;
        tb = mb->type;
        D.37739 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.37739);
        method = methodbuilder_to_mono_method (klass, mb);
      }
      goto <D.37740>;
      <D.37738>:
      method = rmethod->method;
      <D.37740>:
      klass = method->klass;
      D.37741 = BIT_FIELD_REF <*method, 8, 168>;
      D.37742 = D.37741 & 16;
      if (D.37742 != 0) goto <D.37743>; else goto <D.37744>;
      <D.37743>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.37744>:
      D.37745 = mono_method_signature (method);
      D.37746 = D.37745->generic_param_count;
      count = (int) D.37746;
      count.736 = (unsigned int) count;
      D.37748 = mono_array_length (types);
      if (count.736 != D.37748) goto <D.37749>; else goto <D.37750>;
      <D.37749>:
      D.37751 = 0B;
      return D.37751;
      <D.37750>:
      count.737 = (unsigned int) count;
      D.37753 = count.737 * 4;
      type_argv = monoeg_malloc0 (D.37753);
      i = 0;
      goto <D.22988>;
      <D.22987>:
      {
        struct MonoReflectionType * garg;

        i.738 = (unsigned int) i;
        D.37755 = mono_array_addr_with_size (types, 4, i.738);
        garg = MEM[(void * *)D.37755];
        i.739 = (unsigned int) i;
        D.37757 = i.739 * 4;
        D.37758 = type_argv + D.37757;
        D.37759 = mono_reflection_type_get_handle (garg);
        *D.37758 = D.37759;
      }
      i = i + 1;
      <D.22988>:
      if (i < count) goto <D.22987>; else goto <D.22989>;
      <D.22989>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.37761 = klass->generic_class;
      if (D.37761 != 0B) goto <D.37762>; else goto <D.37763>;
      <D.37762>:
      D.37761 = klass->generic_class;
      iftmp.740 = D.37761->context.class_inst;
      goto <D.37764>;
      <D.37763>:
      iftmp.740 = 0B;
      <D.37764>:
      tmp_context.class_inst = iftmp.740;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      imethod = inflated;
      D.37765 = method->klass;
      D.37766 = D.37765->image;
      D.37767 = BIT_FIELD_REF <*D.37766, 8, 128>;
      D.37768 = D.37767 & 8;
      if (D.37768 != 0) goto <D.37769>; else goto <D.37770>;
      <D.37769>:
      {
        struct MonoDynamicImage * image;

        D.37765 = method->klass;
        image = D.37765->image;
        mono_image_lock (image);
        D.37771 = image->generic_def_objects;
        mono_g_hash_table_insert (D.37771, imethod, rmethod);
        mono_image_unlock (image);
      }
      <D.37770>:
      D.37772 = mono_verifier_is_method_valid_generic_instantiation (inflated);
      if (D.37772 == 0) goto <D.37773>; else goto <D.37774>;
      <D.37773>:
      D.37775 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
      mono_raise_exception (D.37775);
      <D.37774>:
      D.37776 = MEM[(struct MonoObject *)rmethod].vtable;
      D.37777 = D.37776->domain;
      D.37751 = mono_method_get_object (D.37777, inflated, 0B);
      return D.37751;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


mono_reflection_generic_class_initialize (struct MonoReflectionGenericClass * type, struct MonoArray * fields)
{
  unsigned char D.37780;
  _Bool D.37781;
  long int D.37782;
  long int D.37783;
  unsigned char D.37786;
  unsigned char D.37787;
  unsigned int D.37790;
  int iftmp.741;
  unsigned int D.37796;
  int D.37798;
  unsigned int D.37799;
  unsigned int D.37800;
  struct MonoImageSet * D.37801;
  void * D.37802;
  unsigned int D.37803;
  void * D.37804;
  void * D.37805;
  unsigned int i.742;
  char * D.37807;
  int D.23070;
  int iftmp.743;
  int D.23069;
  struct MonoVTable * D.37811;
  struct MonoClass * D.37812;
  const char[13] * D.37813;
  unsigned char D.37814;
  int D.37815;
  unsigned char D.37816;
  int D.37817;
  _Bool D.37818;
  _Bool D.37819;
  _Bool D.37820;
  const unsigned char * D.37823;
  unsigned char D.37824;
  int D.37825;
  const unsigned char * D.37826;
  unsigned char D.37827;
  int D.37828;
  _Bool D.37829;
  _Bool D.37830;
  const unsigned char * D.37833;
  unsigned char D.37834;
  int D.37835;
  const unsigned char * D.37836;
  unsigned char D.37837;
  int D.37838;
  _Bool D.37839;
  _Bool D.37840;
  const unsigned char * D.37843;
  unsigned char D.37844;
  int D.37845;
  const unsigned char * D.37846;
  unsigned char D.37847;
  int D.37848;
  const char * D.37850;
  int D.23079;
  int iftmp.744;
  int D.23078;
  const char[10] * D.37857;
  unsigned char D.37858;
  int D.37859;
  unsigned char D.37860;
  int D.37861;
  _Bool D.37862;
  _Bool D.37863;
  _Bool D.37864;
  const unsigned char * D.37867;
  unsigned char D.37868;
  int D.37869;
  const unsigned char * D.37870;
  unsigned char D.37871;
  int D.37872;
  _Bool D.37873;
  _Bool D.37874;
  const unsigned char * D.37877;
  unsigned char D.37878;
  int D.37879;
  const unsigned char * D.37880;
  unsigned char D.37881;
  int D.37882;
  _Bool D.37883;
  _Bool D.37884;
  const unsigned char * D.37887;
  unsigned char D.37888;
  int D.37889;
  const unsigned char * D.37890;
  unsigned char D.37891;
  int D.37892;
  struct MonoClassField * D.37897;
  unsigned int i.745;
  unsigned int D.37899;
  struct MonoClassField * D.37900;
  struct MonoGenericContext * D.37901;
  struct MonoType * D.37902;
  struct MonoType * D.37903;
  struct MonoType * * D.37904;
  unsigned int D.37905;
  struct MonoType * * D.37906;
  int D.37907;
  void * D.37912;
  struct MonoObject * * D.37913;
  char * D.37914;
  struct MonoObject * * D.37915;
  const char * D.37919;
  char * D.37920;
  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.37780 = gtype->type;
  D.37781 = D.37780 != 21;
  D.37782 = (long int) D.37781;
  D.37783 = __builtin_expect (D.37782, 0);
  if (D.37783 != 0) goto <D.37784>; else goto <D.37785>;
  <D.37784>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10682, "gtype->type == MONO_TYPE_GENERICINST");
  <D.37785>:
  gclass = gtype->data.generic_class;
  D.37786 = BIT_FIELD_REF <*gclass, 8, 96>;
  D.37787 = D.37786 & 1;
  if (D.37787 == 0) goto <D.37788>; else goto <D.37789>;
  <D.37788>:
  return;
  <D.37789>:
  dgclass = gclass;
  D.37790 = dgclass->initialized;
  if (D.37790 != 0) goto <D.37791>; else goto <D.37792>;
  <D.37791>:
  return;
  <D.37792>:
  gklass = gclass->container_class;
  mono_class_init (gklass);
  if (fields != 0B) goto <D.37794>; else goto <D.37795>;
  <D.37794>:
  D.37796 = mono_array_length (fields);
  iftmp.741 = (int) D.37796;
  goto <D.37797>;
  <D.37795>:
  iftmp.741 = 0;
  <D.37797>:
  dgclass->count_fields = iftmp.741;
  D.37798 = dgclass->count_fields;
  D.37799 = (unsigned int) D.37798;
  D.37800 = D.37799 * 16;
  D.37801 = gclass->owner;
  D.37802 = mono_image_set_alloc0 (D.37801, D.37800);
  dgclass->fields = D.37802;
  D.37798 = dgclass->count_fields;
  D.37799 = (unsigned int) D.37798;
  D.37803 = D.37799 * 4;
  D.37801 = gclass->owner;
  D.37804 = mono_image_set_alloc0 (D.37801, D.37803);
  dgclass->field_objects = D.37804;
  D.37798 = dgclass->count_fields;
  D.37799 = (unsigned int) D.37798;
  D.37803 = D.37799 * 4;
  D.37801 = gclass->owner;
  D.37805 = mono_image_set_alloc0 (D.37801, D.37803);
  dgclass->field_generic_types = D.37805;
  i = 0;
  goto <D.23081>;
  <D.23080>:
  {
    struct MonoObject * obj;
    struct MonoClassField * field;
    struct MonoClassField * inflated_field;

    i.742 = (unsigned int) i;
    D.37807 = mono_array_addr_with_size (fields, 4, i.742);
    obj = MEM[(void * *)D.37807];
    inflated_field = 0B;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.37811 = obj->vtable;
        D.37812 = D.37811->klass;
        __s2 = D.37812->name;
        D.37813 = "FieldBuilder";
        D.37814 = MEM[(const unsigned char *)D.37813];
        D.37815 = (int) D.37814;
        D.37816 = *__s2;
        D.37817 = (int) D.37816;
        __result = D.37815 - D.37817;
        {
          D.37818 = __s2_len != 0;
          D.37819 = __result == 0;
          D.37820 = D.37818 & D.37819;
          if (D.37820 != 0) goto <D.37821>; else goto <D.37822>;
          <D.37821>:
          D.37823 = &MEM[(void *)"FieldBuilder" + 1B];
          D.37824 = *D.37823;
          D.37825 = (int) D.37824;
          D.37826 = __s2 + 1;
          D.37827 = *D.37826;
          D.37828 = (int) D.37827;
          __result = D.37825 - D.37828;
          D.37829 = __s2_len > 1;
          D.37819 = __result == 0;
          D.37830 = D.37829 & D.37819;
          if (D.37830 != 0) goto <D.37831>; else goto <D.37832>;
          <D.37831>:
          D.37833 = &MEM[(void *)"FieldBuilder" + 2B];
          D.37834 = *D.37833;
          D.37835 = (int) D.37834;
          D.37836 = __s2 + 2;
          D.37837 = *D.37836;
          D.37838 = (int) D.37837;
          __result = D.37835 - D.37838;
          D.37839 = __s2_len > 2;
          D.37819 = __result == 0;
          D.37840 = D.37839 & D.37819;
          if (D.37840 != 0) goto <D.37841>; else goto <D.37842>;
          <D.37841>:
          D.37843 = &MEM[(void *)"FieldBuilder" + 3B];
          D.37844 = *D.37843;
          D.37845 = (int) D.37844;
          D.37846 = __s2 + 3;
          D.37847 = *D.37846;
          D.37848 = (int) D.37847;
          __result = D.37845 - D.37848;
          <D.37842>:
          <D.37832>:
          <D.37822>:
        }
        D.23069 = __result;
      }
      iftmp.743 = -D.23069;
      goto <D.37849>;
      <D.37810>:
      D.37811 = obj->vtable;
      D.37812 = D.37811->klass;
      D.37850 = D.37812->name;
      iftmp.743 = __builtin_strcmp (D.37850, "FieldBuilder");
      <D.37849>:
      D.23070 = iftmp.743;
    }
    if (D.23070 == 0) goto <D.37851>; else goto <D.37852>;
    <D.37851>:
    field = fieldbuilder_to_mono_class_field (klass, obj);
    inflated_field = field;
    goto <D.37853>;
    <D.37852>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.37811 = obj->vtable;
        D.37812 = D.37811->klass;
        __s2 = D.37812->name;
        D.37857 = "MonoField";
        D.37858 = MEM[(const unsigned char *)D.37857];
        D.37859 = (int) D.37858;
        D.37860 = *__s2;
        D.37861 = (int) D.37860;
        __result = D.37859 - D.37861;
        {
          D.37862 = __s2_len != 0;
          D.37863 = __result == 0;
          D.37864 = D.37862 & D.37863;
          if (D.37864 != 0) goto <D.37865>; else goto <D.37866>;
          <D.37865>:
          D.37867 = &MEM[(void *)"MonoField" + 1B];
          D.37868 = *D.37867;
          D.37869 = (int) D.37868;
          D.37870 = __s2 + 1;
          D.37871 = *D.37870;
          D.37872 = (int) D.37871;
          __result = D.37869 - D.37872;
          D.37873 = __s2_len > 1;
          D.37863 = __result == 0;
          D.37874 = D.37873 & D.37863;
          if (D.37874 != 0) goto <D.37875>; else goto <D.37876>;
          <D.37875>:
          D.37877 = &MEM[(void *)"MonoField" + 2B];
          D.37878 = *D.37877;
          D.37879 = (int) D.37878;
          D.37880 = __s2 + 2;
          D.37881 = *D.37880;
          D.37882 = (int) D.37881;
          __result = D.37879 - D.37882;
          D.37883 = __s2_len > 2;
          D.37863 = __result == 0;
          D.37884 = D.37883 & D.37863;
          if (D.37884 != 0) goto <D.37885>; else goto <D.37886>;
          <D.37885>:
          D.37887 = &MEM[(void *)"MonoField" + 3B];
          D.37888 = *D.37887;
          D.37889 = (int) D.37888;
          D.37890 = __s2 + 3;
          D.37891 = *D.37890;
          D.37892 = (int) D.37891;
          __result = D.37889 - D.37892;
          <D.37886>:
          <D.37876>:
          <D.37866>:
        }
        D.23078 = __result;
      }
      iftmp.744 = -D.23078;
      goto <D.37893>;
      <D.37856>:
      D.37811 = obj->vtable;
      D.37812 = D.37811->klass;
      D.37850 = D.37812->name;
      iftmp.744 = __builtin_strcmp (D.37850, "MonoField");
      <D.37893>:
      D.23079 = iftmp.744;
    }
    if (D.23079 == 0) goto <D.37894>; else goto <D.37895>;
    <D.37894>:
    field = MEM[(struct MonoReflectionField *)obj].field;
    goto <D.37896>;
    <D.37895>:
    field = 0B;
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 10712);
    <D.37896>:
    <D.37853>:
    D.37897 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37899 = i.745 * 16;
    D.37900 = D.37897 + D.37899;
    *D.37900 = *field;
    D.37897 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37899 = i.745 * 16;
    D.37900 = D.37897 + D.37899;
    D.37900->parent = klass;
    D.37897 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37899 = i.745 * 16;
    D.37900 = D.37897 + D.37899;
    D.37901 = mono_generic_class_get_context (dgclass);
    D.37902 = field->type;
    D.37903 = mono_class_inflate_generic_type (D.37902, D.37901);
    D.37900->type = D.37903;
    D.37904 = dgclass->field_generic_types;
    i.745 = (unsigned int) i;
    D.37905 = i.745 * 4;
    D.37906 = D.37904 + D.37905;
    D.37902 = field->type;
    *D.37906 = D.37902;
    D.37907 = mono_gc_is_moving ();
    if (D.37907 != 0) goto <D.37908>; else goto <D.37909>;
    <D.37908>:
    if (0 != 0) goto <D.37910>; else goto <D.37911>;
    <D.37910>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10720, "sizeof (dgclass->field_objects [i]) == sizeof (MonoObject*)");
    <D.37911>:
    D.37912 = mono_gc_make_root_descr_all_refs (1);
    D.37913 = dgclass->field_objects;
    i.745 = (unsigned int) i;
    D.37905 = i.745 * 4;
    D.37914 = D.37913 + D.37905;
    mono_gc_register_root (D.37914, 4, D.37912);
    <D.37909>:
    D.37913 = dgclass->field_objects;
    i.745 = (unsigned int) i;
    D.37905 = i.745 * 4;
    D.37915 = D.37913 + D.37905;
    *D.37915 = obj;
    if (inflated_field != 0B) goto <D.37916>; else goto <D.37917>;
    <D.37916>:
    monoeg_g_free (inflated_field);
    goto <D.37918>;
    <D.37917>:
    D.37897 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37899 = i.745 * 16;
    D.37900 = D.37897 + D.37899;
    D.37897 = dgclass->fields;
    i.745 = (unsigned int) i;
    D.37899 = i.745 * 16;
    D.37900 = D.37897 + D.37899;
    D.37919 = D.37900->name;
    D.37801 = gclass->owner;
    D.37920 = mono_image_set_strdup (D.37801, D.37919);
    D.37900->name = D.37920;
    <D.37918>:
  }
  i = i + 1;
  <D.23081>:
  D.37798 = dgclass->count_fields;
  if (D.37798 > i) goto <D.23080>; else goto <D.23082>;
  <D.23082>:
  dgclass->initialized = 1;
}


fieldbuilder_to_mono_class_field (struct MonoClass * klass, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoString * D.37922;
  struct MonoImage * D.37923;
  char * D.37924;
  int D.37925;
  _Bool D.37926;
  long int D.37927;
  long int D.37928;
  unsigned int D.37934;
  struct MonoArray * D.37936;
  struct MonoArray * D.37938;
  struct MonoObject * D.37939;
  struct MonoType * D.37940;
  struct MonoType * D.37941;
  struct MonoType * D.37942;
  short unsigned int D.37943;
  unsigned char D.37944;
  unsigned char D.37945;
  _Bool D.37946;
  long int D.37947;
  long int D.37948;
  struct MonoType * D.37951;
  struct MonoType * D.37952;
  int D.37953;
  struct MonoArray * D.37956;
  struct MonoClassField * D.37957;
  struct MonoClassField * field;
  struct MonoType * custom;
  struct MonoError error;

  try
    {
      field = monoeg_malloc0 (16);
      D.37922 = fb->name;
      D.37923 = klass->image;
      D.37924 = mono_string_to_utf8_image (D.37923, D.37922, &error);
      field->name = D.37924;
      D.37925 = mono_error_ok (&error);
      D.37926 = D.37925 == 0;
      D.37927 = (long int) D.37926;
      D.37928 = __builtin_expect (D.37927, 0);
      if (D.37928 != 0) goto <D.37929>; else goto <D.37930>;
      <D.37929>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10427, "mono_error_ok (&error)");
      <D.37930>:
      D.37934 = fb->attrs;
      if (D.37934 != 0) goto <D.37931>; else goto <D.37935>;
      <D.37935>:
      D.37936 = fb->modreq;
      if (D.37936 != 0B) goto <D.37931>; else goto <D.37937>;
      <D.37937>:
      D.37938 = fb->modopt;
      if (D.37938 != 0B) goto <D.37931>; else goto <D.37932>;
      <D.37931>:
      D.37939 = fb->type;
      D.37940 = mono_reflection_type_get_handle (D.37939);
      D.37941 = mono_metadata_type_dup (0B, D.37940);
      field->type = D.37941;
      D.37942 = field->type;
      D.37934 = fb->attrs;
      D.37943 = (short unsigned int) D.37934;
      D.37942->attrs = D.37943;
      D.37923 = klass->image;
      D.37944 = BIT_FIELD_REF <*D.37923, 8, 128>;
      D.37945 = D.37944 & 8;
      D.37946 = D.37945 == 0;
      D.37947 = (long int) D.37946;
      D.37948 = __builtin_expect (D.37947, 0);
      if (D.37948 != 0) goto <D.37949>; else goto <D.37950>;
      <D.37949>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10432, "klass->image->dynamic");
      <D.37950>:
      D.37938 = fb->modopt;
      D.37936 = fb->modreq;
      D.37942 = field->type;
      D.37923 = klass->image;
      custom = add_custom_modifiers (D.37923, D.37942, D.37936, D.37938);
      D.37942 = field->type;
      monoeg_g_free (D.37942);
      D.37923 = klass->image;
      D.37951 = mono_metadata_type_dup (D.37923, custom);
      field->type = D.37951;
      monoeg_g_free (custom);
      goto <D.37933>;
      <D.37932>:
      D.37939 = fb->type;
      D.37952 = mono_reflection_type_get_handle (D.37939);
      field->type = D.37952;
      <D.37933>:
      D.37953 = fb->offset;
      if (D.37953 != -1) goto <D.37954>; else goto <D.37955>;
      <D.37954>:
      D.37953 = fb->offset;
      field->offset = D.37953;
      <D.37955>:
      field->parent = klass;
      D.37956 = fb->cattrs;
      D.37923 = klass->image;
      mono_save_custom_attrs (D.37923, field, D.37956);
      D.37957 = field;
      return D.37957;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_free_dynamic_generic_class (struct MonoGenericClass * gclass)
{
  unsigned char D.37960;
  unsigned char D.37961;
  _Bool D.37962;
  long int D.37963;
  long int D.37964;
  struct MonoClassField * D.37967;
  unsigned int i.746;
  unsigned int D.37969;
  struct MonoType * D.37970;
  int D.37971;
  struct MonoObject * * D.37974;
  unsigned int D.37975;
  char * D.37976;
  int D.37977;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.37960 = BIT_FIELD_REF <*gclass, 8, 96>;
  D.37961 = D.37960 & 1;
  D.37962 = D.37961 == 0;
  D.37963 = (long int) D.37962;
  D.37964 = __builtin_expect (D.37963, 0);
  if (D.37964 != 0) goto <D.37965>; else goto <D.37966>;
  <D.37965>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10739, "gclass->is_dynamic");
  <D.37966>:
  dgclass = gclass;
  i = 0;
  goto <D.23090>;
  <D.23089>:
  {
    struct MonoClassField * field;

    D.37967 = dgclass->fields;
    i.746 = (unsigned int) i;
    D.37969 = i.746 * 16;
    field = D.37967 + D.37969;
    D.37970 = field->type;
    mono_metadata_free_type (D.37970);
    D.37971 = mono_gc_is_moving ();
    if (D.37971 != 0) goto <D.37972>; else goto <D.37973>;
    <D.37972>:
    D.37974 = dgclass->field_objects;
    i.746 = (unsigned int) i;
    D.37975 = i.746 * 4;
    D.37976 = D.37974 + D.37975;
    mono_gc_deregister_root (D.37976);
    <D.37973>:
  }
  i = i + 1;
  <D.23090>:
  D.37977 = dgclass->count_fields;
  if (D.37977 > i) goto <D.23089>; else goto <D.23091>;
  <D.23091>:
}


mono_reflection_get_dynamic_overrides (struct MonoClass * klass, struct MonoMethod * * * overrides, int * num_overrides)
{
  struct MonoImage * D.37978;
  unsigned char D.37979;
  unsigned char D.37980;
  _Bool D.37981;
  long int D.37982;
  long int D.37983;
  void * D.37986;
  int D.23168;
  int iftmp.747;
  int D.23167;
  void * D.37992;
  struct MonoVTable * D.37993;
  struct MonoClass * D.37994;
  const char[12] * D.37995;
  unsigned char D.37996;
  int D.37997;
  unsigned char D.37998;
  int D.37999;
  _Bool D.38000;
  _Bool D.38001;
  _Bool D.38002;
  const unsigned char * D.38005;
  unsigned char D.38006;
  int D.38007;
  const unsigned char * D.38008;
  unsigned char D.38009;
  int D.38010;
  _Bool D.38011;
  _Bool D.38012;
  const unsigned char * D.38015;
  unsigned char D.38016;
  int D.38017;
  const unsigned char * D.38018;
  unsigned char D.38019;
  int D.38020;
  _Bool D.38021;
  _Bool D.38022;
  const unsigned char * D.38025;
  unsigned char D.38026;
  int D.38027;
  const unsigned char * D.38028;
  unsigned char D.38029;
  int D.38030;
  void * D.38032;
  struct MonoVTable * D.38033;
  struct MonoClass * D.38034;
  const char * D.38035;
  _Bool D.38036;
  long int D.38037;
  long int D.38038;
  struct MonoArray * D.38041;
  unsigned int i.748;
  char * D.38045;
  struct MonoArray * D.38046;
  unsigned int D.38049;
  unsigned int onum.749;
  unsigned int D.38051;
  int D.38052;
  unsigned int onum.750;
  unsigned int D.38056;
  void * D.38057;
  char * D.38058;
  struct MonoArray * D.38059;
  unsigned int j.751;
  char * D.38063;
  struct MonoMethod * * D.38064;
  struct MonoMethod * * D.38065;
  struct MonoMethod * D.38066;
  sizetype onum.752;
  sizetype D.38068;
  sizetype D.38069;
  struct MonoMethod * * D.38070;
  struct MonoMethod * D.38071;
  _Bool D.38072;
  long int D.38073;
  long int D.38074;
  unsigned int D.38077;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int j;
  int onum;
  struct MonoReflectionMethod * m;

  *overrides = 0B;
  *num_overrides = 0;
  D.37978 = klass->image;
  D.37979 = BIT_FIELD_REF <*D.37978, 8, 128>;
  D.37980 = D.37979 & 8;
  D.37981 = D.37980 == 0;
  D.37982 = (long int) D.37981;
  D.37983 = __builtin_expect (D.37982, 0);
  if (D.37983 != 0) goto <D.37984>; else goto <D.37985>;
  <D.37984>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10948, "klass->image->dynamic");
  <D.37985>:
  D.37986 = mono_class_get_ref_info (klass);
  if (D.37986 == 0B) goto <D.37987>; else goto <D.37988>;
  <D.37987>:
  return;
  <D.37988>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.37992 = mono_class_get_ref_info (klass);
      D.37993 = MEM[(struct MonoObject *)D.37992].vtable;
      D.37994 = D.37993->klass;
      __s2 = D.37994->name;
      D.37995 = "TypeBuilder";
      D.37996 = MEM[(const unsigned char *)D.37995];
      D.37997 = (int) D.37996;
      D.37998 = *__s2;
      D.37999 = (int) D.37998;
      __result = D.37997 - D.37999;
      {
        D.38000 = __s2_len != 0;
        D.38001 = __result == 0;
        D.38002 = D.38000 & D.38001;
        if (D.38002 != 0) goto <D.38003>; else goto <D.38004>;
        <D.38003>:
        D.38005 = &MEM[(void *)"TypeBuilder" + 1B];
        D.38006 = *D.38005;
        D.38007 = (int) D.38006;
        D.38008 = __s2 + 1;
        D.38009 = *D.38008;
        D.38010 = (int) D.38009;
        __result = D.38007 - D.38010;
        D.38011 = __s2_len > 1;
        D.38001 = __result == 0;
        D.38012 = D.38011 & D.38001;
        if (D.38012 != 0) goto <D.38013>; else goto <D.38014>;
        <D.38013>:
        D.38015 = &MEM[(void *)"TypeBuilder" + 2B];
        D.38016 = *D.38015;
        D.38017 = (int) D.38016;
        D.38018 = __s2 + 2;
        D.38019 = *D.38018;
        D.38020 = (int) D.38019;
        __result = D.38017 - D.38020;
        D.38021 = __s2_len > 2;
        D.38001 = __result == 0;
        D.38022 = D.38021 & D.38001;
        if (D.38022 != 0) goto <D.38023>; else goto <D.38024>;
        <D.38023>:
        D.38025 = &MEM[(void *)"TypeBuilder" + 3B];
        D.38026 = *D.38025;
        D.38027 = (int) D.38026;
        D.38028 = __s2 + 3;
        D.38029 = *D.38028;
        D.38030 = (int) D.38029;
        __result = D.38027 - D.38030;
        <D.38024>:
        <D.38014>:
        <D.38004>:
      }
      D.23167 = __result;
    }
    iftmp.747 = -D.23167;
    goto <D.38031>;
    <D.37991>:
    D.38032 = mono_class_get_ref_info (klass);
    D.38033 = MEM[(struct MonoObject *)D.38032].vtable;
    D.38034 = D.38033->klass;
    D.38035 = D.38034->name;
    iftmp.747 = __builtin_strcmp (D.38035, "TypeBuilder");
    <D.38031>:
    D.23168 = iftmp.747;
  }
  D.38036 = D.23168 != 0;
  D.38037 = (long int) D.38036;
  D.38038 = __builtin_expect (D.38037, 0);
  if (D.38038 != 0) goto <D.38039>; else goto <D.38040>;
  <D.38039>:
  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.38040>:
  tb = mono_class_get_ref_info (klass);
  onum = 0;
  D.38041 = tb->methods;
  if (D.38041 != 0B) goto <D.38042>; else goto <D.38043>;
  <D.38042>:
  i = 0;
  goto <D.23171>;
  <D.23170>:
  {
    struct MonoReflectionMethodBuilder * mb;

    i.748 = (unsigned int) i;
    D.38041 = tb->methods;
    D.38045 = mono_array_addr_with_size (D.38041, 4, i.748);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38045];
    D.38046 = mb->override_methods;
    if (D.38046 != 0B) goto <D.38047>; else goto <D.38048>;
    <D.38047>:
    D.38046 = mb->override_methods;
    D.38049 = mono_array_length (D.38046);
    onum.749 = (unsigned int) onum;
    D.38051 = D.38049 + onum.749;
    onum = (int) D.38051;
    <D.38048>:
  }
  i = i + 1;
  <D.23171>:
  D.38052 = tb->num_methods;
  if (D.38052 > i) goto <D.23170>; else goto <D.23172>;
  <D.23172>:
  <D.38043>:
  if (onum != 0) goto <D.38053>; else goto <D.38054>;
  <D.38053>:
  onum.750 = (unsigned int) onum;
  D.38056 = onum.750 * 8;
  D.38057 = monoeg_malloc0 (D.38056);
  *overrides = D.38057;
  onum = 0;
  i = 0;
  goto <D.23178>;
  <D.23177>:
  {
    struct MonoReflectionMethodBuilder * mb;

    i.748 = (unsigned int) i;
    D.38041 = tb->methods;
    D.38058 = mono_array_addr_with_size (D.38041, 4, i.748);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38058];
    D.38059 = mb->override_methods;
    if (D.38059 != 0B) goto <D.38060>; else goto <D.38061>;
    <D.38060>:
    j = 0;
    goto <D.23175>;
    <D.23174>:
    j.751 = (unsigned int) j;
    D.38059 = mb->override_methods;
    D.38063 = mono_array_addr_with_size (D.38059, 4, j.751);
    m = MEM[(struct MonoReflectionMethod * *)D.38063];
    D.38064 = *overrides;
    onum.750 = (unsigned int) onum;
    D.38056 = onum.750 * 8;
    D.38065 = D.38064 + D.38056;
    D.38066 = mono_reflection_method_get_handle (m);
    *D.38065 = D.38066;
    D.38064 = *overrides;
    onum.752 = (sizetype) onum;
    D.38068 = onum.752 * 8;
    D.38069 = D.38068 + 4;
    D.38070 = D.38064 + D.38069;
    D.38071 = mb->mhandle;
    *D.38070 = D.38071;
    D.38071 = mb->mhandle;
    D.38072 = D.38071 == 0B;
    D.38073 = (long int) D.38072;
    D.38074 = __builtin_expect (D.38073, 0);
    if (D.38074 != 0) goto <D.38075>; else goto <D.38076>;
    <D.38075>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10981, "mb->mhandle");
    <D.38076>:
    onum = onum + 1;
    j = j + 1;
    <D.23175>:
    j.751 = (unsigned int) j;
    D.38059 = mb->override_methods;
    D.38077 = mono_array_length (D.38059);
    if (j.751 < D.38077) goto <D.23174>; else goto <D.23176>;
    <D.23176>:
    <D.38061>:
  }
  i = i + 1;
  <D.23178>:
  D.38052 = tb->num_methods;
  if (D.38052 > i) goto <D.23177>; else goto <D.23179>;
  <D.23179>:
  <D.38054>:
  *num_overrides = onum;
}


mono_reflection_method_get_handle (struct MonoObject * method)
{
  struct MonoVTable * D.38079;
  int D.38082;
  int D.38084;
  struct MonoMethod * D.38085;
  int D.38086;
  int D.38089;
  struct MonoArray * D.38092;
  struct MonoReflectionType * D.38096;
  struct MonoObject * D.38097;
  struct MonoVTable * D.38098;
  struct MonoClass * D.38099;
  int D.38100;
  int D.38104;
  char * D.38108;
  const char * D.38109;
  const char * D.38110;
  struct MonoClass * class;

  D.38079 = method->vtable;
  class = D.38079->klass;
  D.38082 = is_sr_mono_method (class);
  if (D.38082 != 0) goto <D.38080>; else goto <D.38083>;
  <D.38083>:
  D.38084 = is_sr_mono_generic_method (class);
  if (D.38084 != 0) goto <D.38080>; else goto <D.38081>;
  <D.38080>:
  {
    struct MonoReflectionMethod * sr_method;

    sr_method = method;
    D.38085 = sr_method->method;
    return D.38085;
  }
  <D.38081>:
  D.38086 = is_sre_method_builder (class);
  if (D.38086 != 0) goto <D.38087>; else goto <D.38088>;
  <D.38087>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = method;
    D.38085 = mb->mhandle;
    return D.38085;
  }
  <D.38088>:
  D.38089 = is_sre_method_on_tb_inst (class);
  if (D.38089 != 0) goto <D.38090>; else goto <D.38091>;
  <D.38090>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;
    struct MonoMethod * result;

    m = method;
    D.38092 = m->method_args;
    if (D.38092 != 0B) goto <D.38093>; else goto <D.38094>;
    <D.38093>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    goto <D.38095>;
    <D.38094>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * mono_method;

      D.38096 = m->inst;
      type = mono_reflection_type_get_handle (D.38096);
      inflated_klass = mono_class_from_mono_type (type);
      D.38097 = m->mb;
      D.38098 = D.38097->vtable;
      D.38099 = D.38098->klass;
      D.38100 = is_sre_method_builder (D.38099);
      if (D.38100 != 0) goto <D.38101>; else goto <D.38102>;
      <D.38101>:
      D.38097 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethodBuilder *)D.38097].mhandle;
      goto <D.38103>;
      <D.38102>:
      D.38097 = m->mb;
      D.38098 = D.38097->vtable;
      D.38099 = D.38098->klass;
      D.38104 = is_sr_mono_method (D.38099);
      if (D.38104 != 0) goto <D.38105>; else goto <D.38106>;
      <D.38105>:
      D.38097 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethod *)D.38097].method;
      goto <D.38107>;
      <D.38106>:
      D.38097 = m->mb;
      D.38098 = D.38097->vtable;
      D.38099 = D.38098->klass;
      D.38108 = mono_type_get_full_name (D.38099);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.38108);
      <D.23148>:
      goto <D.23148>;
      <D.38107>:
      <D.38103>:
      D.38097 = m->mb;
      result = inflate_mono_method (inflated_klass, mono_method, D.38097);
    }
    <D.38095>:
    D.38085 = result;
    return D.38085;
  }
  <D.38091>:
  D.38109 = class->name;
  D.38110 = class->name_space;
  monoeg_g_log (0B, 4, "Can\'t handle methods of type %s:%s", D.38110, D.38109);
  <D.23149>:
  goto <D.23149>;
  D.38085 = 0B;
  return D.38085;
}


mono_reflection_event_builder_get_event_info (struct MonoReflectionTypeBuilder * tb, struct MonoReflectionEventBuilder * eb)
{
  struct MonoType * D.38112;
  unsigned int D.38113;
  struct MonoString * D.38114;
  char * D.38115;
  struct MonoReflectionMethodBuilder * D.38116;
  struct MonoMethod * D.38119;
  struct MonoReflectionMethodBuilder * D.38120;
  struct MonoMethod * D.38123;
  struct MonoReflectionMethodBuilder * D.38124;
  struct MonoMethod * D.38127;
  struct MonoArray * D.38128;
  unsigned int D.38131;
  unsigned int D.38132;
  unsigned int D.38133;
  void * D.38134;
  unsigned int j.753;
  char * D.38136;
  struct MonoMethod * * D.38137;
  unsigned int j.754;
  unsigned int D.38139;
  struct MonoMethod * * D.38140;
  struct MonoMethod * D.38141;
  unsigned int D.38142;
  struct MonoReflectionEvent * D.38143;
  struct MonoVTable * D.38144;
  struct MonoDomain * D.38145;
  struct MonoEvent * event;
  struct MonoClass * klass;

  event = monoeg_malloc0 (28);
  D.38112 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.38112);
  event->parent = klass;
  D.38113 = eb->attrs;
  event->attrs = D.38113;
  D.38114 = eb->name;
  D.38115 = mono_string_to_utf8 (D.38114);
  event->name = D.38115;
  D.38116 = eb->add_method;
  if (D.38116 != 0B) goto <D.38117>; else goto <D.38118>;
  <D.38117>:
  D.38116 = eb->add_method;
  D.38119 = D.38116->mhandle;
  event->add = D.38119;
  <D.38118>:
  D.38120 = eb->remove_method;
  if (D.38120 != 0B) goto <D.38121>; else goto <D.38122>;
  <D.38121>:
  D.38120 = eb->remove_method;
  D.38123 = D.38120->mhandle;
  event->remove = D.38123;
  <D.38122>:
  D.38124 = eb->raise_method;
  if (D.38124 != 0B) goto <D.38125>; else goto <D.38126>;
  <D.38125>:
  D.38124 = eb->raise_method;
  D.38127 = D.38124->mhandle;
  event->raise = D.38127;
  <D.38126>:
  D.38128 = eb->other_methods;
  if (D.38128 != 0B) goto <D.38129>; else goto <D.38130>;
  <D.38129>:
  {
    int j;

    D.38128 = eb->other_methods;
    D.38131 = mono_array_length (D.38128);
    D.38132 = D.38131 + 1;
    D.38133 = D.38132 * 4;
    D.38134 = monoeg_malloc0 (D.38133);
    event->other = D.38134;
    j = 0;
    goto <D.23229>;
    <D.23228>:
    {
      struct MonoReflectionMethodBuilder * mb;

      j.753 = (unsigned int) j;
      D.38128 = eb->other_methods;
      D.38136 = mono_array_addr_with_size (D.38128, 4, j.753);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38136];
      D.38137 = event->other;
      j.754 = (unsigned int) j;
      D.38139 = j.754 * 4;
      D.38140 = D.38137 + D.38139;
      D.38141 = mb->mhandle;
      *D.38140 = D.38141;
    }
    j = j + 1;
    <D.23229>:
    j.753 = (unsigned int) j;
    D.38128 = eb->other_methods;
    D.38142 = mono_array_length (D.38128);
    if (j.753 < D.38142) goto <D.23228>; else goto <D.23230>;
    <D.23230>:
  }
  <D.38130>:
  D.38144 = MEM[(struct MonoObject *)tb].vtable;
  D.38145 = D.38144->domain;
  D.38143 = mono_event_get_object (D.38145, klass, event);
  return D.38143;
}


mono_reflection_create_runtime_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoVTable * D.38147;
  struct MonoType * D.38148;
  struct MonoObject * D.38149;
  struct MonoReflectionType * D.38150;
  struct MonoArray * D.38151;
  struct MonoArray * D.38152;
  unsigned int i.755;
  char * D.38156;
  struct MonoObject * D.38159;
  struct MonoReflectionType * D.38160;
  struct MonoArray * D.38161;
  struct MonoArray * D.38162;
  struct MonoReflectionMarshal * D.38163;
  struct MonoObject * D.38166;
  struct MonoReflectionType * D.38169;
  unsigned int D.38170;
  struct MonoArray * D.38171;
  char * D.38174;
  struct MonoObject * D.38177;
  struct MonoReflectionType * D.38178;
  struct MonoArray * D.38179;
  struct MonoArray * D.38180;
  struct MonoArray * D.38181;
  struct MonoArray * D.38182;
  unsigned int j.756;
  char * D.38186;
  struct MonoArray * D.38187;
  unsigned int D.38188;
  struct MonoArray * D.38189;
  char * D.38192;
  struct MonoArray * D.38193;
  unsigned int D.38194;
  unsigned int D.38195;
  struct MonoArray * D.38196;
  char * D.38199;
  struct MonoArray * D.38202;
  struct MonoArray * D.38203;
  char * D.38206;
  struct MonoArray * D.38207;
  unsigned int D.38208;
  struct MonoArray * D.38209;
  char * D.38212;
  struct MonoArray * D.38213;
  unsigned int D.38214;
  unsigned int D.38215;
  struct MonoArray * D.38216;
  struct MonoImage * D.38217;
  union mono_mutex_t * D.38218;
  _Bool D.38221;
  long int D.38222;
  long int D.38223;
  unsigned char D.38226;
  unsigned char D.38227;
  _Bool D.38232;
  long int D.38233;
  long int D.38234;
  struct MonoReflectionType * D.38237;
  struct MonoType * D.38238;
  struct MonoDomain * D.38239;
  unsigned int D.38240;
  struct MonoClass * D.38241;
  unsigned char D.38242;
  struct MonoArray * D.38245;
  char * D.38248;
  struct MonoClassExt * D.38249;
  struct MonoType * D.38250;
  struct MonoClass * D.38251;
  struct GList * D.38252;
  struct GList * D.38253;
  unsigned int D.38254;
  unsigned char D.38257;
  unsigned char D.38258;
  int D.38261;
  unsigned char D.38262;
  <unnamed-unsigned:1> D.38263;
  unsigned char D.38264;
  <unnamed-unsigned:1> D.38265;
  unsigned char D.38266;
  unsigned char D.38267;
  <unnamed-unsigned:1> D.38268;
  int D.38270;
  int D.38272;
  int D.38274;
  struct MonoGHashTable * D.38276;
  struct MonoGenericContainer * D.38279;
  _Bool D.38284;
  long int D.38285;
  long int D.38286;
  int D.38291;
  struct MonoString * D.38294;
  struct MonoException * D.38295;
  _Bool D.38296;
  long int D.38297;
  long int D.38298;
  _Bool D.38303;
  long int D.38304;
  long int D.38305;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoReflectionType * res;
  int i;
  int j;
  void failure = <<< error >>>;

  try
    {
      D.38147 = MEM[(struct MonoObject *)tb].vtable;
      domain = D.38147->domain;
      D.38148 = tb->type.type;
      klass = mono_class_from_mono_type (D.38148);
      D.38149 = tb->parent;
      D.38150 = mono_reflection_type_resolve_user_types (D.38149);
      tb->parent = D.38150;
      D.38151 = tb->interfaces;
      check_array_for_usertypes (D.38151);
      D.38152 = tb->fields;
      if (D.38152 != 0B) goto <D.38153>; else goto <D.38154>;
      <D.38153>:
      i = 0;
      goto <D.23275>;
      <D.23274>:
      {
        struct MonoReflectionFieldBuilder * fb;

        i.755 = (unsigned int) i;
        D.38152 = tb->fields;
        D.38156 = mono_array_addr_with_size (D.38152, 4, i.755);
        fb = MEM[(void * *)D.38156];
        if (fb != 0B) goto <D.38157>; else goto <D.38158>;
        <D.38157>:
        D.38159 = fb->type;
        D.38160 = mono_reflection_type_resolve_user_types (D.38159);
        fb->type = D.38160;
        D.38161 = fb->modreq;
        check_array_for_usertypes (D.38161);
        D.38162 = fb->modopt;
        check_array_for_usertypes (D.38162);
        D.38163 = fb->marshal_info;
        if (D.38163 != 0B) goto <D.38164>; else goto <D.38165>;
        <D.38164>:
        D.38163 = fb->marshal_info;
        D.38166 = D.38163->marshaltyperef;
        if (D.38166 != 0B) goto <D.38167>; else goto <D.38168>;
        <D.38167>:
        D.38163 = fb->marshal_info;
        D.38163 = fb->marshal_info;
        D.38166 = D.38163->marshaltyperef;
        D.38169 = mono_reflection_type_resolve_user_types (D.38166);
        D.38163->marshaltyperef = D.38169;
        <D.38168>:
        <D.38165>:
        <D.38158>:
      }
      i = i + 1;
      <D.23275>:
      i.755 = (unsigned int) i;
      D.38152 = tb->fields;
      D.38170 = mono_array_length (D.38152);
      if (i.755 < D.38170) goto <D.23274>; else goto <D.23276>;
      <D.23276>:
      <D.38154>:
      D.38171 = tb->methods;
      if (D.38171 != 0B) goto <D.38172>; else goto <D.38173>;
      <D.38172>:
      i = 0;
      goto <D.23285>;
      <D.23284>:
      {
        struct MonoReflectionMethodBuilder * mb;

        i.755 = (unsigned int) i;
        D.38171 = tb->methods;
        D.38174 = mono_array_addr_with_size (D.38171, 4, i.755);
        mb = MEM[(void * *)D.38174];
        if (mb != 0B) goto <D.38175>; else goto <D.38176>;
        <D.38175>:
        D.38177 = mb->rtype;
        D.38178 = mono_reflection_type_resolve_user_types (D.38177);
        mb->rtype = D.38178;
        D.38179 = mb->return_modreq;
        check_array_for_usertypes (D.38179);
        D.38180 = mb->return_modopt;
        check_array_for_usertypes (D.38180);
        D.38181 = mb->parameters;
        check_array_for_usertypes (D.38181);
        D.38182 = mb->param_modreq;
        if (D.38182 != 0B) goto <D.38183>; else goto <D.38184>;
        <D.38183>:
        j = 0;
        goto <D.23279>;
        <D.23278>:
        j.756 = (unsigned int) j;
        D.38182 = mb->param_modreq;
        D.38186 = mono_array_addr_with_size (D.38182, 4, j.756);
        D.38187 = MEM[(struct MonoArray * *)D.38186];
        check_array_for_usertypes (D.38187);
        j = j + 1;
        <D.23279>:
        j.756 = (unsigned int) j;
        D.38182 = mb->param_modreq;
        D.38188 = mono_array_length (D.38182);
        if (j.756 < D.38188) goto <D.23278>; else goto <D.23280>;
        <D.23280>:
        <D.38184>:
        D.38189 = mb->param_modopt;
        if (D.38189 != 0B) goto <D.38190>; else goto <D.38191>;
        <D.38190>:
        j = 0;
        goto <D.23282>;
        <D.23281>:
        j.756 = (unsigned int) j;
        D.38189 = mb->param_modopt;
        D.38192 = mono_array_addr_with_size (D.38189, 4, j.756);
        D.38193 = MEM[(struct MonoArray * *)D.38192];
        check_array_for_usertypes (D.38193);
        j = j + 1;
        <D.23282>:
        j.756 = (unsigned int) j;
        D.38189 = mb->param_modopt;
        D.38194 = mono_array_length (D.38189);
        if (j.756 < D.38194) goto <D.23281>; else goto <D.23283>;
        <D.23283>:
        <D.38191>:
        <D.38176>:
      }
      i = i + 1;
      <D.23285>:
      i.755 = (unsigned int) i;
      D.38171 = tb->methods;
      D.38195 = mono_array_length (D.38171);
      if (i.755 < D.38195) goto <D.23284>; else goto <D.23286>;
      <D.23286>:
      <D.38173>:
      D.38196 = tb->ctors;
      if (D.38196 != 0B) goto <D.38197>; else goto <D.38198>;
      <D.38197>:
      i = 0;
      goto <D.23295>;
      <D.23294>:
      {
        struct MonoReflectionCtorBuilder * mb;

        i.755 = (unsigned int) i;
        D.38196 = tb->ctors;
        D.38199 = mono_array_addr_with_size (D.38196, 4, i.755);
        mb = MEM[(void * *)D.38199];
        if (mb != 0B) goto <D.38200>; else goto <D.38201>;
        <D.38200>:
        D.38202 = mb->parameters;
        check_array_for_usertypes (D.38202);
        D.38203 = mb->param_modreq;
        if (D.38203 != 0B) goto <D.38204>; else goto <D.38205>;
        <D.38204>:
        j = 0;
        goto <D.23289>;
        <D.23288>:
        j.756 = (unsigned int) j;
        D.38203 = mb->param_modreq;
        D.38206 = mono_array_addr_with_size (D.38203, 4, j.756);
        D.38207 = MEM[(struct MonoArray * *)D.38206];
        check_array_for_usertypes (D.38207);
        j = j + 1;
        <D.23289>:
        j.756 = (unsigned int) j;
        D.38203 = mb->param_modreq;
        D.38208 = mono_array_length (D.38203);
        if (j.756 < D.38208) goto <D.23288>; else goto <D.23290>;
        <D.23290>:
        <D.38205>:
        D.38209 = mb->param_modopt;
        if (D.38209 != 0B) goto <D.38210>; else goto <D.38211>;
        <D.38210>:
        j = 0;
        goto <D.23292>;
        <D.23291>:
        j.756 = (unsigned int) j;
        D.38209 = mb->param_modopt;
        D.38212 = mono_array_addr_with_size (D.38209, 4, j.756);
        D.38213 = MEM[(struct MonoArray * *)D.38212];
        check_array_for_usertypes (D.38213);
        j = j + 1;
        <D.23292>:
        j.756 = (unsigned int) j;
        D.38209 = mb->param_modopt;
        D.38214 = mono_array_length (D.38209);
        if (j.756 < D.38214) goto <D.23291>; else goto <D.23293>;
        <D.23293>:
        <D.38211>:
        <D.38201>:
      }
      i = i + 1;
      <D.23295>:
      i.755 = (unsigned int) i;
      D.38196 = tb->ctors;
      D.38215 = mono_array_length (D.38196);
      if (i.755 < D.38215) goto <D.23294>; else goto <D.23296>;
      <D.23296>:
      <D.38198>:
      D.38216 = tb->cattrs;
      D.38217 = klass->image;
      mono_save_custom_attrs (D.38217, klass, D.38216);
      mono_loader_lock ();
      {
        int ret;

        D.38218 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.38218);
        if (ret != 0) goto <D.38219>; else goto <D.38220>;
        <D.38219>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.38220>:
        D.38221 = ret != 0;
        D.38222 = (long int) D.38221;
        D.38223 = __builtin_expect (D.38222, 0);
        if (D.38223 != 0) goto <D.38224>; else goto <D.38225>;
        <D.38224>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11312, "ret == 0");
        <D.38225>:
      }
      D.38226 = BIT_FIELD_REF <*klass, 8, 160>;
      D.38227 = D.38226 & 128;
      if (D.38227 != 0) goto <D.38228>; else goto <D.38229>;
      <D.38228>:
      {
        int ret;

        D.38218 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38218);
        if (ret != 0) goto <D.38230>; else goto <D.38231>;
        <D.38230>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38231>:
        D.38232 = ret != 0;
        D.38233 = (long int) D.38232;
        D.38234 = __builtin_expect (D.38233, 0);
        if (D.38234 != 0) goto <D.38235>; else goto <D.38236>;
        <D.38235>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11314, "ret == 0");
        <D.38236>:
      }
      mono_loader_unlock ();
      D.38238 = &klass->byval_arg;
      D.38147 = MEM[(struct MonoObject *)tb].vtable;
      D.38239 = D.38147->domain;
      D.38237 = mono_type_get_object (D.38239, D.38238);
      return D.38237;
      <D.38229>:
      D.38240 = tb->attrs;
      klass->flags = D.38240;
      klass->has_cctor = 1;
      klass->has_finalize = 1;
      klass->has_finalize_inited = 1;
      klass->supertypes = 0B;
      D.38241 = klass->parent;
      mono_class_setup_parent (klass, D.38241);
      mono_class_setup_mono_type (klass);
      D.38226 = BIT_FIELD_REF <*klass, 8, 160>;
      D.38242 = D.38226 & 16;
      if (D.38242 == 0) goto <D.38243>; else goto <D.38244>;
      <D.38243>:
      ensure_runtime_vtable (klass);
      <D.38244>:
      D.38245 = tb->subtypes;
      if (D.38245 != 0B) goto <D.38246>; else goto <D.38247>;
      <D.38246>:
      i = 0;
      goto <D.23301>;
      <D.23300>:
      {
        struct MonoReflectionTypeBuilder * subtb;

        i.755 = (unsigned int) i;
        D.38245 = tb->subtypes;
        D.38248 = mono_array_addr_with_size (D.38245, 4, i.755);
        subtb = MEM[(struct MonoReflectionTypeBuilder * *)D.38248];
        mono_class_alloc_ext (klass);
        D.38249 = klass->ext;
        D.38250 = mono_reflection_type_get_handle (subtb);
        D.38251 = mono_class_from_mono_type (D.38250);
        D.38249 = klass->ext;
        D.38252 = D.38249->nested_classes;
        D.38217 = klass->image;
        D.38253 = g_list_prepend_image (D.38217, D.38252, D.38251);
        D.38249->nested_classes = D.38253;
      }
      i = i + 1;
      <D.23301>:
      i.755 = (unsigned int) i;
      D.38245 = tb->subtypes;
      D.38254 = mono_array_length (D.38245);
      if (i.755 < D.38254) goto <D.23300>; else goto <D.23302>;
      <D.23302>:
      <D.38247>:
      klass->nested_classes_inited = 1;
      D.38241 = klass->parent;
      if (D.38241 != 0B) goto <D.38255>; else goto <D.38256>;
      <D.38255>:
      D.38241 = klass->parent;
      D.38257 = BIT_FIELD_REF <*D.38241, 8, 160>;
      D.38258 = D.38257 & 4;
      if (D.38258 == 0) goto <D.38259>; else goto <D.38260>;
      <D.38259>:
      D.38241 = klass->parent;
      mono_class_init (D.38241);
      <D.38260>:
      D.38241 = klass->parent;
      D.38261 = D.38241->instance_size;
      klass->instance_size = D.38261;
      klass->sizes.class_size = 0;
      D.38241 = klass->parent;
      D.38262 = D.38241->min_align;
      klass->min_align = D.38262;
      D.38263 = klass->has_references;
      D.38264 = (unsigned char) D.38263;
      D.38241 = klass->parent;
      D.38265 = D.38241->has_references;
      D.38266 = (unsigned char) D.38265;
      D.38267 = D.38264 | D.38266;
      D.38268 = (<unnamed-unsigned:1>) D.38267;
      klass->has_references = D.38268;
      goto <D.38269>;
      <D.38256>:
      klass->instance_size = 8;
      klass->min_align = 1;
      <D.38269>:
      typebuilder_setup_fields (klass, &error);
      D.38270 = mono_error_ok (&error);
      if (D.38270 == 0) goto failure; else goto <D.38271>;
      <D.38271>:
      typebuilder_setup_properties (klass, &error);
      D.38272 = mono_error_ok (&error);
      if (D.38272 == 0) goto failure; else goto <D.38273>;
      <D.38273>:
      typebuilder_setup_events (klass, &error);
      D.38274 = mono_error_ok (&error);
      if (D.38274 == 0) goto failure; else goto <D.38275>;
      <D.38275>:
      klass->wastypebuilder = 1;
      D.38276 = domain->type_hash;
      if (D.38276 != 0B) goto <D.38277>; else goto <D.38278>;
      <D.38277>:
      D.38279 = klass->generic_container;
      if (D.38279 != 0B) goto <D.38280>; else goto <D.38281>;
      <D.38280>:
      D.38276 = domain->type_hash;
      mono_g_hash_table_foreach_remove (D.38276, remove_instantiations_of_and_ensure_contents, klass);
      <D.38281>:
      <D.38278>:
      {
        int ret;

        D.38218 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38218);
        if (ret != 0) goto <D.38282>; else goto <D.38283>;
        <D.38282>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38283>:
        D.38284 = ret != 0;
        D.38285 = (long int) D.38284;
        D.38286 = __builtin_expect (D.38285, 0);
        if (D.38286 != 0) goto <D.38287>; else goto <D.38288>;
        <D.38287>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11398, "ret == 0");
        <D.38288>:
      }
      mono_loader_unlock ();
      D.38226 = BIT_FIELD_REF <*klass, 8, 160>;
      D.38242 = D.38226 & 16;
      if (D.38242 != 0) goto <D.38289>; else goto <D.38290>;
      <D.38289>:
      D.38291 = mono_class_is_valid_enum (klass);
      if (D.38291 == 0) goto <D.38292>; else goto <D.38293>;
      <D.38292>:
      mono_class_set_failure (klass, 7, 0B);
      D.38294 = tb->name;
      D.38295 = mono_get_exception_type_load (D.38294, 0B);
      mono_raise_exception (D.38295);
      <D.38293>:
      <D.38290>:
      D.38238 = &klass->byval_arg;
      D.38147 = MEM[(struct MonoObject *)tb].vtable;
      D.38239 = D.38147->domain;
      res = mono_type_get_object (D.38239, D.38238);
      D.38296 = res == tb;
      D.38297 = (long int) D.38296;
      D.38298 = __builtin_expect (D.38297, 0);
      if (D.38298 != 0) goto <D.38299>; else goto <D.38300>;
      <D.38299>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11407, "res != (MonoReflectionType*)tb");
      <D.38300>:
      D.38237 = res;
      return D.38237;
      failure:
      mono_class_set_failure (klass, 7, 0B);
      klass->wastypebuilder = 1;
      {
        int ret;

        D.38218 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38218);
        if (ret != 0) goto <D.38301>; else goto <D.38302>;
        <D.38301>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38302>:
        D.38303 = ret != 0;
        D.38304 = (long int) D.38303;
        D.38305 = __builtin_expect (D.38304, 0);
        if (D.38305 != 0) goto <D.38306>; else goto <D.38307>;
        <D.38306>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11414, "ret == 0");
        <D.38307>:
      }
      mono_loader_unlock ();
      mono_error_raise_exception (&error);
      D.38237 = 0B;
      return D.38237;
    }
  finally
    {
      error = {CLOBBER};
    }
}


remove_instantiations_of_and_ensure_contents (void * key, void * value, void * user_data)
{
  unsigned char D.38311;
  struct MonoGenericClass * D.38313;
  struct MonoClass * D.38314;
  struct MonoClass * D.38316;
  gboolean D.38317;
  struct MonoType * type;
  struct MonoClass * klass;

  type = key;
  klass = user_data;
  D.38311 = type->type;
  if (D.38311 == 21) goto <D.38312>; else goto <D.38310>;
  <D.38312>:
  D.38313 = type->data.generic_class;
  D.38314 = D.38313->container_class;
  if (D.38314 == klass) goto <D.38315>; else goto <D.38310>;
  <D.38315>:
  D.38316 = mono_class_from_mono_type (type);
  fix_partial_generic_class (D.38316);
  D.38317 = 1;
  return D.38317;
  <D.38310>:
  D.38317 = 0;
  return D.38317;
}


fix_partial_generic_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.38319;
  unsigned char D.38320;
  unsigned char D.38321;
  struct MonoClass * D.38324;
  struct MonoClass * D.38325;
  struct MonoGenericContext * D.38328;
  struct MonoType * D.38329;
  int D.38330;
  unsigned char D.38336;
  unsigned char D.38337;
  unsigned int D.38340;
  unsigned int D.38343;
  unsigned int D.38344;
  unsigned int D.38347;
  unsigned int D.38348;
  struct MonoImage * D.38349;
  void * D.38350;
  struct MonoMethod * * D.38351;
  unsigned int i.757;
  unsigned int D.38353;
  struct MonoMethod * * D.38354;
  struct MonoGenericContext * D.38355;
  struct MonoMethod * * D.38356;
  struct MonoMethod * * D.38357;
  struct MonoMethod * D.38358;
  struct MonoMethod * D.38359;
  unsigned int i.758;
  short unsigned int D.38361;
  short unsigned int D.38364;
  unsigned int D.38367;
  unsigned int D.38368;
  void * D.38369;
  struct MonoGenericContext * D.38370;
  struct MonoClass * * D.38371;
  struct MonoClass * * D.38372;
  struct MonoClass * D.38373;
  struct MonoType * D.38374;
  struct MonoClass * * D.38375;
  struct MonoClass * * D.38376;
  struct MonoClass * D.38377;
  struct MonoClass * D.38378;
  int D.38379;
  unsigned int D.38380;
  unsigned int D.38381;
  unsigned int D.38384;
  void * D.38385;
  struct MonoClassField * D.38386;
  unsigned int D.38387;
  struct MonoClassField * D.38388;
  struct MonoClassField * D.38389;
  struct MonoClassField * D.38390;
  struct MonoGenericContext * D.38391;
  struct MonoType * D.38392;
  struct MonoType * D.38393;
  struct MonoClass * gklass;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.38319 = klass->generic_class;
  gklass = D.38319->container_class;
  D.38320 = BIT_FIELD_REF <*klass, 8, 160>;
  D.38321 = D.38320 & 128;
  if (D.38321 != 0) goto <D.38322>; else goto <D.38323>;
  <D.38322>:
  return;
  <D.38323>:
  dgclass = klass->generic_class;
  D.38324 = klass->parent;
  D.38325 = gklass->parent;
  if (D.38324 != D.38325) goto <D.38326>; else goto <D.38327>;
  <D.38326>:
  {
    struct MonoError error;
    struct MonoType * parent_type;

    try
      {
        D.38319 = klass->generic_class;
        D.38328 = &D.38319->context;
        D.38325 = gklass->parent;
        D.38329 = &D.38325->byval_arg;
        parent_type = mono_class_inflate_generic_type_checked (D.38329, D.38328, &error);
        D.38330 = mono_error_ok (&error);
        if (D.38330 != 0) goto <D.38331>; else goto <D.38332>;
        <D.38331>:
        {
          struct MonoClass * parent;

          parent = mono_class_from_mono_type (parent_type);
          mono_metadata_free_type (parent_type);
          D.38324 = klass->parent;
          if (D.38324 != parent) goto <D.38333>; else goto <D.38334>;
          <D.38333>:
          klass->supertypes = 0B;
          mono_class_setup_parent (klass, parent);
          <D.38334>:
        }
        goto <D.38335>;
        <D.38332>:
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        D.38336 = BIT_FIELD_REF <*gklass, 8, 160>;
        D.38337 = D.38336 & 128;
        if (D.38337 != 0) goto <D.38338>; else goto <D.38339>;
        <D.38338>:
        klass->wastypebuilder = 1;
        <D.38339>:
        return;
        <D.38335>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.38327>:
  D.38340 = dgclass->initialized;
  if (D.38340 == 0) goto <D.38341>; else goto <D.38342>;
  <D.38341>:
  return;
  <D.38342>:
  D.38343 = klass->method.count;
  D.38344 = gklass->method.count;
  if (D.38343 != D.38344) goto <D.38345>; else goto <D.38346>;
  <D.38345>:
  D.38344 = gklass->method.count;
  klass->method.count = D.38344;
  D.38343 = klass->method.count;
  D.38347 = D.38343 + 1;
  D.38348 = D.38347 * 4;
  D.38349 = klass->image;
  D.38350 = mono_image_alloc (D.38349, D.38348);
  klass->methods = D.38350;
  i = 0;
  goto <D.23102>;
  <D.23101>:
  D.38351 = klass->methods;
  i.757 = (unsigned int) i;
  D.38353 = i.757 * 4;
  D.38354 = D.38351 + D.38353;
  D.38355 = mono_class_get_context (klass);
  D.38356 = gklass->methods;
  i.757 = (unsigned int) i;
  D.38353 = i.757 * 4;
  D.38357 = D.38356 + D.38353;
  D.38358 = *D.38357;
  D.38359 = mono_class_inflate_generic_method_full (D.38358, klass, D.38355);
  *D.38354 = D.38359;
  i = i + 1;
  <D.23102>:
  i.758 = (unsigned int) i;
  D.38343 = klass->method.count;
  if (i.758 < D.38343) goto <D.23101>; else goto <D.23103>;
  <D.23103>:
  <D.38346>:
  D.38361 = klass->interface_count;
  if (D.38361 != 0) goto <D.38362>; else goto <D.38363>;
  <D.38362>:
  D.38361 = klass->interface_count;
  D.38364 = gklass->interface_count;
  if (D.38361 != D.38364) goto <D.38365>; else goto <D.38366>;
  <D.38365>:
  D.38364 = gklass->interface_count;
  klass->interface_count = D.38364;
  D.38364 = gklass->interface_count;
  D.38367 = (unsigned int) D.38364;
  D.38368 = D.38367 * 4;
  D.38349 = klass->image;
  D.38369 = mono_image_alloc (D.38349, D.38368);
  klass->interfaces = D.38369;
  klass->interfaces_packed = 0B;
  i = 0;
  goto <D.23106>;
  <D.23105>:
  {
    struct MonoType * iface_type;

    D.38370 = mono_class_get_context (klass);
    D.38371 = gklass->interfaces;
    i.757 = (unsigned int) i;
    D.38353 = i.757 * 4;
    D.38372 = D.38371 + D.38353;
    D.38373 = *D.38372;
    D.38374 = &D.38373->byval_arg;
    iface_type = mono_class_inflate_generic_type (D.38374, D.38370);
    D.38375 = klass->interfaces;
    i.757 = (unsigned int) i;
    D.38353 = i.757 * 4;
    D.38376 = D.38375 + D.38353;
    D.38377 = mono_class_from_mono_type (iface_type);
    *D.38376 = D.38377;
    mono_metadata_free_type (iface_type);
    D.38375 = klass->interfaces;
    i.757 = (unsigned int) i;
    D.38353 = i.757 * 4;
    D.38376 = D.38375 + D.38353;
    D.38378 = *D.38376;
    ensure_runtime_vtable (D.38378);
  }
  i = i + 1;
  <D.23106>:
  D.38364 = gklass->interface_count;
  D.38379 = (int) D.38364;
  if (D.38379 > i) goto <D.23105>; else goto <D.23107>;
  <D.23107>:
  klass->interfaces_inited = 1;
  <D.38366>:
  <D.38363>:
  D.38380 = klass->field.count;
  D.38381 = gklass->field.count;
  if (D.38380 != D.38381) goto <D.38382>; else goto <D.38383>;
  <D.38382>:
  D.38381 = gklass->field.count;
  klass->field.count = D.38381;
  D.38380 = klass->field.count;
  D.38384 = D.38380 * 16;
  D.38349 = klass->image;
  D.38385 = image_g_malloc0 (D.38349, D.38384);
  klass->fields = D.38385;
  i = 0;
  goto <D.23109>;
  <D.23108>:
  D.38386 = klass->fields;
  i.757 = (unsigned int) i;
  D.38387 = i.757 * 16;
  D.38388 = D.38386 + D.38387;
  D.38389 = gklass->fields;
  i.757 = (unsigned int) i;
  D.38387 = i.757 * 16;
  D.38390 = D.38389 + D.38387;
  *D.38388 = *D.38390;
  D.38386 = klass->fields;
  i.757 = (unsigned int) i;
  D.38387 = i.757 * 16;
  D.38388 = D.38386 + D.38387;
  D.38388->parent = klass;
  D.38386 = klass->fields;
  i.757 = (unsigned int) i;
  D.38387 = i.757 * 16;
  D.38388 = D.38386 + D.38387;
  D.38391 = mono_class_get_context (klass);
  D.38389 = gklass->fields;
  i.757 = (unsigned int) i;
  D.38387 = i.757 * 16;
  D.38390 = D.38389 + D.38387;
  D.38392 = D.38390->type;
  D.38393 = mono_class_inflate_generic_type (D.38392, D.38391);
  D.38388->type = D.38393;
  i = i + 1;
  <D.23109>:
  i.758 = (unsigned int) i;
  D.38380 = klass->field.count;
  if (i.758 < D.38380) goto <D.23108>; else goto <D.23110>;
  <D.23110>:
  <D.38383>:
  D.38336 = BIT_FIELD_REF <*gklass, 8, 160>;
  D.38337 = D.38336 & 128;
  if (D.38337 != 0) goto <D.38394>; else goto <D.38395>;
  <D.38394>:
  klass->wastypebuilder = 1;
  <D.38395>:
  return;
}


check_array_for_usertypes (struct MonoArray * arr)
{
  unsigned int i.759;
  char * D.38402;
  unsigned int D.38403;
  int i;

  if (arr == 0B) goto <D.38399>; else goto <D.38400>;
  <D.38399>:
  return;
  <D.38400>:
  i = 0;
  goto <D.23262>;
  <D.23261>:
  {
    struct MonoReflectionType * __type;

    i.759 = (unsigned int) i;
    D.38402 = mono_array_addr_with_size (arr, 4, i.759);
    __type = MEM[(struct MonoReflectionType * *)D.38402];
    __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.23262>:
  i.759 = (unsigned int) i;
  D.38403 = mono_array_length (arr);
  if (i.759 < D.38403) goto <D.23261>; else goto <D.23263>;
  <D.23263>:
}


ensure_runtime_vtable (struct MonoClass * klass)
{
  struct MonoImage * D.38408;
  unsigned char D.38409;
  unsigned char D.38410;
  struct MonoGenericClass * D.38413;
  unsigned char D.38414;
  unsigned char D.38415;
  struct MonoClass * D.38416;
  int iftmp.760;
  struct MonoArray * D.38422;
  unsigned int D.38425;
  int D.38427;
  unsigned int num.761;
  unsigned int num.762;
  unsigned int D.38430;
  void * D.38431;
  int iftmp.763;
  unsigned int D.38435;
  struct MonoMethod * * D.38437;
  unsigned int i.764;
  unsigned int D.38439;
  struct MonoMethod * * D.38440;
  unsigned int i.765;
  char * D.38442;
  struct MonoReflectionCtorBuilder * D.38443;
  struct MonoMethod * D.38444;
  int j.766;
  unsigned int j.767;
  unsigned int D.38447;
  struct MonoMethod * * D.38448;
  struct MonoArray * D.38449;
  char * D.38450;
  struct MonoReflectionMethodBuilder * D.38451;
  struct MonoMethod * D.38452;
  struct MonoArray * D.38453;
  unsigned int D.38456;
  short unsigned int D.38457;
  short unsigned int D.38458;
  unsigned int D.38459;
  unsigned int D.38460;
  void * D.38461;
  char * D.38462;
  void * D.38463;
  struct MonoClass * * D.38464;
  struct MonoClass * * D.38465;
  struct MonoClass * D.38466;
  struct MonoClass * D.38467;
  int D.38468;
  unsigned int D.38472;
  unsigned int D.38473;
  short unsigned int D.38476;
  int D.38477;
  int D.38478;
  int slot_num.768;
  short int D.38482;
  unsigned int i.769;
  unsigned int D.38484;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int num;
  int j;

  tb = mono_class_get_ref_info (klass);
  D.38408 = klass->image;
  D.38409 = BIT_FIELD_REF <*D.38408, 8, 128>;
  D.38410 = D.38409 & 8;
  if (D.38410 == 0) goto <D.38405>; else goto <D.38411>;
  <D.38411>:
  if (tb == 0B) goto <D.38412>; else goto <D.38406>;
  <D.38412>:
  D.38413 = klass->generic_class;
  if (D.38413 == 0B) goto <D.38405>; else goto <D.38406>;
  <D.38406>:
  D.38414 = BIT_FIELD_REF <*klass, 8, 160>;
  D.38415 = D.38414 & 128;
  if (D.38415 != 0) goto <D.38405>; else goto <D.38407>;
  <D.38405>:
  return;
  <D.38407>:
  D.38416 = klass->parent;
  if (D.38416 != 0B) goto <D.38417>; else goto <D.38418>;
  <D.38417>:
  D.38416 = klass->parent;
  ensure_runtime_vtable (D.38416);
  <D.38418>:
  if (tb != 0B) goto <D.38419>; else goto <D.38420>;
  <D.38419>:
  D.38422 = tb->ctors;
  if (D.38422 != 0B) goto <D.38423>; else goto <D.38424>;
  <D.38423>:
  D.38422 = tb->ctors;
  D.38425 = mono_array_length (D.38422);
  iftmp.760 = (int) D.38425;
  goto <D.38426>;
  <D.38424>:
  iftmp.760 = 0;
  <D.38426>:
  num = iftmp.760;
  D.38427 = tb->num_methods;
  num = D.38427 + num;
  num.761 = (unsigned int) num;
  klass->method.count = num.761;
  num.762 = (unsigned int) num;
  D.38430 = num.762 * 4;
  D.38408 = klass->image;
  D.38431 = mono_image_alloc (D.38408, D.38430);
  klass->methods = D.38431;
  D.38422 = tb->ctors;
  if (D.38422 != 0B) goto <D.38433>; else goto <D.38434>;
  <D.38433>:
  D.38422 = tb->ctors;
  D.38435 = mono_array_length (D.38422);
  iftmp.763 = (int) D.38435;
  goto <D.38436>;
  <D.38434>:
  iftmp.763 = 0;
  <D.38436>:
  num = iftmp.763;
  i = 0;
  goto <D.23123>;
  <D.23122>:
  D.38437 = klass->methods;
  i.764 = (unsigned int) i;
  D.38439 = i.764 * 4;
  D.38440 = D.38437 + D.38439;
  i.765 = (unsigned int) i;
  D.38422 = tb->ctors;
  D.38442 = mono_array_addr_with_size (D.38422, 4, i.765);
  D.38443 = MEM[(struct MonoReflectionCtorBuilder * *)D.38442];
  D.38444 = ctorbuilder_to_mono_method (klass, D.38443);
  *D.38440 = D.38444;
  i = i + 1;
  <D.23123>:
  if (i < num) goto <D.23122>; else goto <D.23124>;
  <D.23124>:
  num = tb->num_methods;
  j = i;
  i = 0;
  goto <D.23126>;
  <D.23125>:
  D.38437 = klass->methods;
  j.766 = j;
  j = j.766 + 1;
  j.767 = (unsigned int) j.766;
  D.38447 = j.767 * 4;
  D.38448 = D.38437 + D.38447;
  i.765 = (unsigned int) i;
  D.38449 = tb->methods;
  D.38450 = mono_array_addr_with_size (D.38449, 4, i.765);
  D.38451 = MEM[(struct MonoReflectionMethodBuilder * *)D.38450];
  D.38452 = methodbuilder_to_mono_method (klass, D.38451);
  *D.38448 = D.38452;
  i = i + 1;
  <D.23126>:
  if (i < num) goto <D.23125>; else goto <D.23127>;
  <D.23127>:
  D.38453 = tb->interfaces;
  if (D.38453 != 0B) goto <D.38454>; else goto <D.38455>;
  <D.38454>:
  D.38453 = tb->interfaces;
  D.38456 = mono_array_length (D.38453);
  D.38457 = (short unsigned int) D.38456;
  klass->interface_count = D.38457;
  D.38458 = klass->interface_count;
  D.38459 = (unsigned int) D.38458;
  D.38460 = D.38459 * 4;
  D.38408 = klass->image;
  D.38461 = mono_image_alloc (D.38408, D.38460);
  klass->interfaces = D.38461;
  i = 0;
  goto <D.23130>;
  <D.23129>:
  {
    struct MonoType * iface;

    i.765 = (unsigned int) i;
    D.38453 = tb->interfaces;
    D.38462 = mono_array_addr_with_size (D.38453, 4, i.765);
    D.38463 = MEM[(void * *)D.38462];
    iface = mono_reflection_type_get_handle (D.38463);
    D.38464 = klass->interfaces;
    i.764 = (unsigned int) i;
    D.38439 = i.764 * 4;
    D.38465 = D.38464 + D.38439;
    D.38466 = mono_class_from_mono_type (iface);
    *D.38465 = D.38466;
    D.38464 = klass->interfaces;
    i.764 = (unsigned int) i;
    D.38439 = i.764 * 4;
    D.38465 = D.38464 + D.38439;
    D.38467 = *D.38465;
    ensure_runtime_vtable (D.38467);
  }
  i = i + 1;
  <D.23130>:
  D.38458 = klass->interface_count;
  D.38468 = (int) D.38458;
  if (D.38468 > i) goto <D.23129>; else goto <D.23131>;
  <D.23131>:
  klass->interfaces_inited = 1;
  <D.38455>:
  goto <D.38469>;
  <D.38420>:
  D.38413 = klass->generic_class;
  if (D.38413 != 0B) goto <D.38470>; else goto <D.38471>;
  <D.38470>:
  ensure_generic_class_runtime_vtable (klass);
  <D.38471>:
  <D.38469>:
  D.38472 = klass->flags;
  D.38473 = D.38472 & 32;
  if (D.38473 != 0) goto <D.38474>; else goto <D.38475>;
  <D.38474>:
  {
    int slot_num;

    slot_num = 0;
    i = 0;
    goto <D.23135>;
    <D.23134>:
    {
      struct MonoMethod * im;

      D.38437 = klass->methods;
      i.764 = (unsigned int) i;
      D.38439 = i.764 * 4;
      D.38440 = D.38437 + D.38439;
      im = *D.38440;
      D.38476 = im->flags;
      D.38477 = (int) D.38476;
      D.38478 = D.38477 & 16;
      if (D.38478 == 0) goto <D.38479>; else goto <D.38480>;
      <D.38479>:
      slot_num.768 = slot_num;
      slot_num = slot_num.768 + 1;
      D.38482 = (short int) slot_num.768;
      im->slot = D.38482;
      <D.38480>:
    }
    i = i + 1;
    <D.23135>:
    i.769 = (unsigned int) i;
    D.38484 = klass->method.count;
    if (i.769 < D.38484) goto <D.23134>; else goto <D.23136>;
    <D.23136>:
    klass->interfaces_packed = 0B;
    mono_class_setup_interface_offsets (klass);
    mono_class_setup_interface_id (klass);
  }
  <D.38475>:
}


ensure_generic_class_runtime_vtable (struct MonoClass * klass)
{
  struct MonoGenericClass * D.38486;
  struct MonoClass * gklass;

  D.38486 = klass->generic_class;
  gklass = D.38486->container_class;
  ensure_runtime_vtable (gklass);
  fix_partial_generic_class (klass);
}


typebuilder_setup_fields (struct MonoClass * klass, struct MonoError * error)
{
  int D.38487;
  unsigned int D.38488;
  int D.38489;
  int D.38492;
  unsigned int D.38493;
  unsigned int D.38494;
  const char * D.38497;
  unsigned char D.38498;
  <unnamed-unsigned:4> D.38499;
  int D.38500;
  int D.38501;
  unsigned int D.38502;
  unsigned int D.38505;
  unsigned int D.38506;
  int D.38507;
  unsigned int D.38508;
  void * D.38509;
  struct MonoClassExt * D.38510;
  unsigned int D.38511;
  void * D.38512;
  unsigned int i.770;
  struct MonoArray * D.38514;
  char * D.38515;
  struct MonoClassField * D.38516;
  unsigned int i.771;
  unsigned int D.38518;
  struct MonoString * D.38519;
  char * D.38520;
  int D.38521;
  unsigned int D.38524;
  struct MonoObject * D.38527;
  struct MonoType * D.38528;
  struct MonoImage * D.38529;
  struct MonoType * D.38530;
  struct MonoType * D.38531;
  short unsigned int D.38532;
  struct MonoType * D.38534;
  unsigned int D.38535;
  struct MonoFieldDefaultValue * D.38540;
  unsigned int D.38541;
  struct MonoFieldDefaultValue * D.38542;
  int D.38543;
  struct MonoArray * D.38546;
  unsigned char D.38547;
  unsigned char D.38548;
  short unsigned int D.38551;
  int D.38552;
  int D.38553;
  struct MonoClass * D.38556;
  struct MonoClass * D.38557;
  struct MonoObject * D.38558;
  short unsigned int D.38561;
  MonoTypeEnum * D.38562;
  char * D.38563;
  const char * p2.772;
  int p2.773;
  int p.774;
  int D.38567;
  unsigned int D.38568;
  void * D.38569;
  const char * D.38570;
  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.38487 = tb->num_fields;
      D.38488 = (unsigned int) D.38487;
      klass->field.count = D.38488;
      klass->field.first = 0;
      mono_error_init (error);
      D.38489 = tb->class_size;
      if (D.38489 != 0) goto <D.38490>; else goto <D.38491>;
      <D.38490>:
      D.38492 = tb->packing_size;
      D.38493 = (unsigned int) D.38492;
      D.38494 = D.38493 & 4294967280;
      if (D.38494 != 0) goto <D.38495>; else goto <D.38496>;
      <D.38495>:
      {
        char * err_msg;

        D.38492 = tb->packing_size;
        D.38497 = klass->name;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.38497, D.38492);
        mono_class_set_failure (klass, 7, err_msg);
        return;
      }
      <D.38496>:
      D.38492 = tb->packing_size;
      D.38498 = (unsigned char) D.38492;
      D.38499 = (<unnamed-unsigned:4>) D.38498;
      klass->packing_size = D.38499;
      D.38500 = klass->instance_size;
      D.38489 = tb->class_size;
      D.38501 = D.38500 + D.38489;
      real_size = (guint32) D.38501;
      <D.38491>:
      D.38502 = klass->field.count;
      if (D.38502 == 0) goto <D.38503>; else goto <D.38504>;
      <D.38503>:
      D.38500 = klass->instance_size;
      D.38505 = (unsigned int) D.38500;
      D.38506 = MAX_EXPR <D.38505, real_size>;
      D.38507 = (int) D.38506;
      klass->instance_size = D.38507;
      return;
      <D.38504>:
      D.38502 = klass->field.count;
      D.38508 = D.38502 * 16;
      D.38509 = image_g_malloc0 (image, D.38508);
      klass->fields = D.38509;
      mono_class_alloc_ext (klass);
      D.38510 = klass->ext;
      D.38502 = klass->field.count;
      D.38511 = D.38502 * 8;
      D.38512 = image_g_malloc0 (image, D.38511);
      D.38510->field_def_values = D.38512;
      klass->size_inited = 1;
      i = 0;
      goto <D.23201>;
      <D.23200>:
      {
        struct MonoArray * rva_data;

        i.770 = (unsigned int) i;
        D.38514 = tb->fields;
        D.38515 = mono_array_addr_with_size (D.38514, 4, i.770);
        fb = MEM[(void * *)D.38515];
        D.38516 = klass->fields;
        i.771 = (unsigned int) i;
        D.38518 = i.771 * 16;
        field = D.38516 + D.38518;
        D.38519 = fb->name;
        D.38520 = mono_string_to_utf8_image (image, D.38519, error);
        field->name = D.38520;
        D.38521 = mono_error_ok (error);
        if (D.38521 == 0) goto <D.38522>; else goto <D.38523>;
        <D.38522>:
        return;
        <D.38523>:
        D.38524 = fb->attrs;
        if (D.38524 != 0) goto <D.38525>; else goto <D.38526>;
        <D.38525>:
        D.38527 = fb->type;
        D.38528 = mono_reflection_type_get_handle (D.38527);
        D.38529 = klass->image;
        D.38530 = mono_metadata_type_dup (D.38529, D.38528);
        field->type = D.38530;
        D.38531 = field->type;
        D.38524 = fb->attrs;
        D.38532 = (short unsigned int) D.38524;
        D.38531->attrs = D.38532;
        goto <D.38533>;
        <D.38526>:
        D.38527 = fb->type;
        D.38534 = mono_reflection_type_get_handle (D.38527);
        field->type = D.38534;
        <D.38533>:
        D.38524 = fb->attrs;
        D.38535 = D.38524 & 256;
        if (D.38535 != 0) goto <D.38536>; else goto <D.38537>;
        <D.38536>:
        rva_data = fb->rva_data;
        if (rva_data != 0B) goto <D.38538>; else goto <D.38539>;
        <D.38538>:
        {
          char * base;
          size_t size;
          char * data;

          base = mono_array_addr_with_size (rva_data, 1, 0);
          size = mono_array_length (rva_data);
          D.38529 = klass->image;
          data = mono_image_alloc (D.38529, size);
          memcpy (data, base, size);
          D.38510 = klass->ext;
          D.38540 = D.38510->field_def_values;
          i.771 = (unsigned int) i;
          D.38541 = i.771 * 8;
          D.38542 = D.38540 + D.38541;
          D.38542->data = data;
        }
        <D.38539>:
        <D.38537>:
        D.38543 = fb->offset;
        if (D.38543 != -1) goto <D.38544>; else goto <D.38545>;
        <D.38544>:
        D.38543 = fb->offset;
        field->offset = D.38543;
        <D.38545>:
        field->parent = klass;
        fb->handle = field;
        D.38546 = fb->cattrs;
        D.38529 = klass->image;
        mono_save_custom_attrs (D.38529, field, D.38546);
        D.38547 = BIT_FIELD_REF <*klass, 8, 160>;
        D.38548 = D.38547 & 16;
        if (D.38548 != 0) goto <D.38549>; else goto <D.38550>;
        <D.38549>:
        D.38531 = field->type;
        D.38551 = D.38531->attrs;
        D.38552 = (int) D.38551;
        D.38553 = D.38552 & 16;
        if (D.38553 == 0) goto <D.38554>; else goto <D.38555>;
        <D.38554>:
        D.38531 = field->type;
        D.38556 = mono_class_from_mono_type (D.38531);
        klass->element_class = D.38556;
        D.38557 = klass->element_class;
        klass->cast_class = D.38557;
        <D.38555>:
        <D.38550>:
        D.38558 = fb->def_value;
        if (D.38558 != 0B) goto <D.38559>; else goto <D.38560>;
        <D.38559>:
        {
          struct MonoDynamicImage * assembly;

          assembly = klass->image;
          D.38531 = field->type;
          D.38531 = field->type;
          D.38551 = D.38531->attrs;
          D.38561 = D.38551 | 32768;
          D.38531->attrs = D.38561;
          D.38510 = klass->ext;
          D.38540 = D.38510->field_def_values;
          i.771 = (unsigned int) i;
          D.38541 = i.771 * 8;
          D.38542 = D.38540 + D.38541;
          D.38562 = &D.38542->def_type;
          D.38558 = fb->def_value;
          idx = encode_constant (assembly, D.38558, D.38562);
          D.38563 = assembly->blob.data;
          p = D.38563 + idx;
          len = mono_metadata_decode_blob_size (p, &p2);
          p2.772 = p2;
          p2.773 = (int) p2.772;
          p.774 = (int) p;
          D.38567 = p2.773 - p.774;
          D.38568 = (unsigned int) D.38567;
          len = D.38568 + len;
          D.38510 = klass->ext;
          D.38540 = D.38510->field_def_values;
          i.771 = (unsigned int) i;
          D.38541 = i.771 * 8;
          D.38542 = D.38540 + D.38541;
          D.38569 = mono_image_alloc (image, len);
          D.38542->data = D.38569;
          D.38510 = klass->ext;
          D.38540 = D.38510->field_def_values;
          i.771 = (unsigned int) i;
          D.38541 = i.771 * 8;
          D.38542 = D.38540 + D.38541;
          D.38570 = D.38542->data;
          memcpy (D.38570, p, len);
        }
        <D.38560>:
      }
      i = i + 1;
      <D.23201>:
      i.775 = (unsigned int) i;
      D.38502 = klass->field.count;
      if (i.775 < D.38502) goto <D.23200>; else goto <D.23202>;
      <D.23202>:
      D.38500 = klass->instance_size;
      D.38505 = (unsigned int) D.38500;
      D.38506 = MAX_EXPR <D.38505, real_size>;
      D.38507 = (int) D.38506;
      klass->instance_size = D.38507;
      mono_class_layout_fields (klass);
    }
  finally
    {
      p2 = {CLOBBER};
    }
}


typebuilder_setup_properties (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.38575;
  void * D.38578;
  uintptr_t iftmp.776;
  struct MonoArray * D.38580;
  unsigned int D.38584;
  unsigned int D.38585;
  unsigned int i.777;
  char * D.38587;
  unsigned int i.778;
  unsigned int D.38589;
  struct MonoProperty * D.38590;
  unsigned int D.38591;
  struct MonoString * D.38592;
  char * D.38593;
  int D.38594;
  struct MonoReflectionMethodBuilder * D.38597;
  struct MonoMethod * D.38600;
  struct MonoReflectionMethodBuilder * D.38601;
  struct MonoMethod * D.38604;
  struct MonoArray * D.38605;
  void * D.38606;
  struct MonoImage * D.38607;
  struct MonoObject * D.38608;
  struct MonoFieldDefaultValue * D.38611;
  unsigned int D.38614;
  void * D.38615;
  unsigned int D.38616;
  unsigned int D.38617;
  unsigned int D.38618;
  struct MonoFieldDefaultValue * D.38619;
  MonoTypeEnum * D.38620;
  char * D.38621;
  const char * p2.779;
  int p2.780;
  int p.781;
  int D.38625;
  unsigned int D.38626;
  void * D.38627;
  const char * D.38628;
  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.38575 = klass->ext;
  if (D.38575 == 0B) goto <D.38576>; else goto <D.38577>;
  <D.38576>:
  D.38578 = image_g_malloc0 (image, 40);
  klass->ext = D.38578;
  <D.38577>:
  D.38575 = klass->ext;
  D.38580 = tb->properties;
  if (D.38580 != 0B) goto <D.38581>; else goto <D.38582>;
  <D.38581>:
  D.38580 = tb->properties;
  iftmp.776 = mono_array_length (D.38580);
  goto <D.38583>;
  <D.38582>:
  iftmp.776 = 0;
  <D.38583>:
  D.38575->property.count = iftmp.776;
  D.38575 = klass->ext;
  D.38575->property.first = 0;
  D.38575 = klass->ext;
  D.38584 = D.38575->property.count;
  D.38585 = D.38584 * 20;
  properties = image_g_malloc0 (image, D.38585);
  D.38575 = klass->ext;
  D.38575->properties = properties;
  i = 0;
  goto <D.23218>;
  <D.23217>:
  i.777 = (unsigned int) i;
  D.38580 = tb->properties;
  D.38587 = mono_array_addr_with_size (D.38580, 4, i.777);
  pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.38587];
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38590 = properties + D.38589;
  D.38590->parent = klass;
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38590 = properties + D.38589;
  D.38591 = pb->attrs;
  D.38590->attrs = D.38591;
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38590 = properties + D.38589;
  D.38592 = pb->name;
  D.38593 = mono_string_to_utf8_image (image, D.38592, error);
  D.38590->name = D.38593;
  D.38594 = mono_error_ok (error);
  if (D.38594 == 0) goto <D.38595>; else goto <D.38596>;
  <D.38595>:
  return;
  <D.38596>:
  D.38597 = pb->get_method;
  if (D.38597 != 0B) goto <D.38598>; else goto <D.38599>;
  <D.38598>:
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38590 = properties + D.38589;
  D.38597 = pb->get_method;
  D.38600 = D.38597->mhandle;
  D.38590->get = D.38600;
  <D.38599>:
  D.38601 = pb->set_method;
  if (D.38601 != 0B) goto <D.38602>; else goto <D.38603>;
  <D.38602>:
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38590 = properties + D.38589;
  D.38601 = pb->set_method;
  D.38604 = D.38601->mhandle;
  D.38590->set = D.38604;
  <D.38603>:
  D.38605 = pb->cattrs;
  i.778 = (unsigned int) i;
  D.38589 = i.778 * 20;
  D.38606 = properties + D.38589;
  D.38607 = klass->image;
  mono_save_custom_attrs (D.38607, D.38606, D.38605);
  D.38608 = pb->def_value;
  if (D.38608 != 0B) goto <D.38609>; else goto <D.38610>;
  <D.38609>:
  {
    guint32 len;
    guint32 idx;
    const char * p;
    const char * p2;
    struct MonoDynamicImage * assembly;

    try
      {
        assembly = klass->image;
        D.38575 = klass->ext;
        D.38611 = D.38575->prop_def_values;
        if (D.38611 == 0B) goto <D.38612>; else goto <D.38613>;
        <D.38612>:
        D.38575 = klass->ext;
        D.38575 = klass->ext;
        D.38584 = D.38575->property.count;
        D.38614 = D.38584 * 8;
        D.38615 = image_g_malloc0 (image, D.38614);
        D.38575->prop_def_values = D.38615;
        <D.38613>:
        i.778 = (unsigned int) i;
        D.38589 = i.778 * 20;
        D.38590 = properties + D.38589;
        i.778 = (unsigned int) i;
        D.38589 = i.778 * 20;
        D.38590 = properties + D.38589;
        D.38616 = D.38590->attrs;
        D.38617 = D.38616 | 4096;
        D.38590->attrs = D.38617;
        D.38575 = klass->ext;
        D.38611 = D.38575->prop_def_values;
        i.778 = (unsigned int) i;
        D.38618 = i.778 * 8;
        D.38619 = D.38611 + D.38618;
        D.38620 = &D.38619->def_type;
        D.38608 = pb->def_value;
        idx = encode_constant (assembly, D.38608, D.38620);
        D.38621 = assembly->blob.data;
        p = D.38621 + idx;
        len = mono_metadata_decode_blob_size (p, &p2);
        p2.779 = p2;
        p2.780 = (int) p2.779;
        p.781 = (int) p;
        D.38625 = p2.780 - p.781;
        D.38626 = (unsigned int) D.38625;
        len = D.38626 + len;
        D.38575 = klass->ext;
        D.38611 = D.38575->prop_def_values;
        i.778 = (unsigned int) i;
        D.38618 = i.778 * 8;
        D.38619 = D.38611 + D.38618;
        D.38627 = mono_image_alloc (image, len);
        D.38619->data = D.38627;
        D.38575 = klass->ext;
        D.38611 = D.38575->prop_def_values;
        i.778 = (unsigned int) i;
        D.38618 = i.778 * 8;
        D.38619 = D.38611 + D.38618;
        D.38628 = D.38619->data;
        memcpy (D.38628, p, len);
      }
    finally
      {
        p2 = {CLOBBER};
      }
  }
  <D.38610>:
  i = i + 1;
  <D.23218>:
  i.782 = (unsigned int) i;
  D.38575 = klass->ext;
  D.38584 = D.38575->property.count;
  if (i.782 < D.38584) goto <D.23217>; else goto <D.23219>;
  <D.23219>:
}


typebuilder_setup_events (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.38631;
  void * D.38634;
  uintptr_t iftmp.783;
  struct MonoArray * D.38636;
  unsigned int D.38640;
  unsigned int D.38641;
  unsigned int i.784;
  char * D.38643;
  unsigned int i.785;
  unsigned int D.38645;
  struct MonoEvent * D.38646;
  unsigned int D.38647;
  struct MonoString * D.38648;
  char * D.38649;
  int D.38650;
  struct MonoReflectionMethodBuilder * D.38653;
  struct MonoMethod * D.38656;
  struct MonoReflectionMethodBuilder * D.38657;
  struct MonoMethod * D.38660;
  struct MonoReflectionMethodBuilder * D.38661;
  struct MonoMethod * D.38664;
  struct MonoArray * D.38665;
  unsigned int D.38668;
  unsigned int D.38669;
  unsigned int D.38670;
  void * D.38671;
  unsigned int j.786;
  char * D.38673;
  struct MonoMethod * * D.38674;
  unsigned int j.787;
  unsigned int D.38676;
  struct MonoMethod * * D.38677;
  struct MonoMethod * D.38678;
  unsigned int D.38679;
  struct MonoArray * D.38680;
  void * D.38681;
  struct MonoImage * D.38682;
  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.38631 = klass->ext;
  if (D.38631 == 0B) goto <D.38632>; else goto <D.38633>;
  <D.38632>:
  D.38634 = image_g_malloc0 (image, 40);
  klass->ext = D.38634;
  <D.38633>:
  D.38631 = klass->ext;
  D.38636 = tb->events;
  if (D.38636 != 0B) goto <D.38637>; else goto <D.38638>;
  <D.38637>:
  D.38636 = tb->events;
  iftmp.783 = mono_array_length (D.38636);
  goto <D.38639>;
  <D.38638>:
  iftmp.783 = 0;
  <D.38639>:
  D.38631->event.count = iftmp.783;
  D.38631 = klass->ext;
  D.38631->event.first = 0;
  D.38631 = klass->ext;
  D.38640 = D.38631->event.count;
  D.38641 = D.38640 * 28;
  events = image_g_malloc0 (image, D.38641);
  D.38631 = klass->ext;
  D.38631->events = events;
  i = 0;
  goto <D.23246>;
  <D.23245>:
  i.784 = (unsigned int) i;
  D.38636 = tb->events;
  D.38643 = mono_array_addr_with_size (D.38636, 4, i.784);
  eb = MEM[(struct MonoReflectionEventBuilder * *)D.38643];
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38646->parent = klass;
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38647 = eb->attrs;
  D.38646->attrs = D.38647;
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38648 = eb->name;
  D.38649 = mono_string_to_utf8_image (image, D.38648, error);
  D.38646->name = D.38649;
  D.38650 = mono_error_ok (error);
  if (D.38650 == 0) goto <D.38651>; else goto <D.38652>;
  <D.38651>:
  return;
  <D.38652>:
  D.38653 = eb->add_method;
  if (D.38653 != 0B) goto <D.38654>; else goto <D.38655>;
  <D.38654>:
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38653 = eb->add_method;
  D.38656 = D.38653->mhandle;
  D.38646->add = D.38656;
  <D.38655>:
  D.38657 = eb->remove_method;
  if (D.38657 != 0B) goto <D.38658>; else goto <D.38659>;
  <D.38658>:
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38657 = eb->remove_method;
  D.38660 = D.38657->mhandle;
  D.38646->remove = D.38660;
  <D.38659>:
  D.38661 = eb->raise_method;
  if (D.38661 != 0B) goto <D.38662>; else goto <D.38663>;
  <D.38662>:
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38646 = events + D.38645;
  D.38661 = eb->raise_method;
  D.38664 = D.38661->mhandle;
  D.38646->raise = D.38664;
  <D.38663>:
  D.38665 = eb->other_methods;
  if (D.38665 != 0B) goto <D.38666>; else goto <D.38667>;
  <D.38666>:
  {
    int j;

    i.785 = (unsigned int) i;
    D.38645 = i.785 * 28;
    D.38646 = events + D.38645;
    D.38665 = eb->other_methods;
    D.38668 = mono_array_length (D.38665);
    D.38669 = D.38668 + 1;
    D.38670 = D.38669 * 4;
    D.38671 = image_g_malloc0 (image, D.38670);
    D.38646->other = D.38671;
    j = 0;
    goto <D.23243>;
    <D.23242>:
    {
      struct MonoReflectionMethodBuilder * mb;

      j.786 = (unsigned int) j;
      D.38665 = eb->other_methods;
      D.38673 = mono_array_addr_with_size (D.38665, 4, j.786);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38673];
      i.785 = (unsigned int) i;
      D.38645 = i.785 * 28;
      D.38646 = events + D.38645;
      D.38674 = D.38646->other;
      j.787 = (unsigned int) j;
      D.38676 = j.787 * 4;
      D.38677 = D.38674 + D.38676;
      D.38678 = mb->mhandle;
      *D.38677 = D.38678;
    }
    j = j + 1;
    <D.23243>:
    j.786 = (unsigned int) j;
    D.38665 = eb->other_methods;
    D.38679 = mono_array_length (D.38665);
    if (j.786 < D.38679) goto <D.23242>; else goto <D.23244>;
    <D.23244>:
  }
  <D.38667>:
  D.38680 = eb->cattrs;
  i.785 = (unsigned int) i;
  D.38645 = i.785 * 28;
  D.38681 = events + D.38645;
  D.38682 = klass->image;
  mono_save_custom_attrs (D.38682, D.38681, D.38680);
  i = i + 1;
  <D.23246>:
  i.788 = (unsigned int) i;
  D.38631 = klass->ext;
  D.38640 = D.38631->event.count;
  if (i.788 < D.38640) goto <D.23245>; else goto <D.23247>;
  <D.23247>:
}


mono_reflection_initialize_generic_parameter (struct MonoReflectionGenericParam * gparam)
{
  struct MonoReflectionTypeBuilder * D.38685;
  struct MonoReflectionModuleBuilder * D.38686;
  struct MonoDynamicImage * D.38687;
  struct MonoString * D.38688;
  char * D.38689;
  int D.38690;
  _Bool D.38691;
  long int D.38692;
  long int D.38693;
  unsigned int D.38696;
  short unsigned int D.38697;
  struct MonoReflectionMethodBuilder * D.38698;
  struct MonoGenericContainer * D.38701;
  struct MonoType * D.38704;
  struct MonoImage * D.38705;
  void * D.38706;
  struct MonoGenericContainer * D.38710;
  struct MonoType * D.38713;
  struct MonoImage * D.38714;
  void * D.38715;
  _Bool D.38716;
  int D.38717;
  struct MonoType * D.38718;
  struct MonoGenericParamFull * param;
  struct MonoImage * image;
  struct MonoClass * pklass;
  struct MonoError error;

  try
    {
      D.38685 = gparam->tbuilder;
      D.38686 = D.38685->module;
      D.38687 = D.38686->dynamic_image;
      image = &D.38687->image;
      param = mono_image_alloc0 (image, 32);
      D.38688 = gparam->name;
      D.38689 = mono_string_to_utf8_image (image, D.38688, &error);
      param->info.name = D.38689;
      D.38690 = mono_error_ok (&error);
      D.38691 = D.38690 == 0;
      D.38692 = (long int) D.38691;
      D.38693 = __builtin_expect (D.38692, 0);
      if (D.38693 != 0) goto <D.38694>; else goto <D.38695>;
      <D.38694>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11435, "mono_error_ok (&error)");
      <D.38695>:
      D.38696 = gparam->index;
      D.38697 = (short unsigned int) D.38696;
      param->param.num = D.38697;
      D.38698 = gparam->mbuilder;
      if (D.38698 != 0B) goto <D.38699>; else goto <D.38700>;
      <D.38699>:
      D.38698 = gparam->mbuilder;
      D.38701 = D.38698->generic_container;
      if (D.38701 == 0B) goto <D.38702>; else goto <D.38703>;
      <D.38702>:
      {
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        D.38698 = gparam->mbuilder;
        tb = D.38698->type;
        D.38704 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.38704);
        D.38698 = gparam->mbuilder;
        D.38705 = klass->image;
        D.38706 = mono_image_alloc0 (D.38705, 28);
        D.38698->generic_container = D.38706;
        D.38698 = gparam->mbuilder;
        D.38701 = D.38698->generic_container;
        D.38701->is_method = -1;
        D.38698 = gparam->mbuilder;
        D.38701 = D.38698->generic_container;
        D.38705 = klass->image;
        D.38701->image = D.38705;
      }
      <D.38703>:
      D.38698 = gparam->mbuilder;
      D.38701 = D.38698->generic_container;
      param->param.owner = D.38701;
      goto <D.38707>;
      <D.38700>:
      D.38685 = gparam->tbuilder;
      if (D.38685 != 0B) goto <D.38708>; else goto <D.38709>;
      <D.38708>:
      D.38685 = gparam->tbuilder;
      D.38710 = D.38685->generic_container;
      if (D.38710 == 0B) goto <D.38711>; else goto <D.38712>;
      <D.38711>:
      {
        struct MonoClass * klass;

        D.38685 = gparam->tbuilder;
        D.38713 = mono_reflection_type_get_handle (D.38685);
        klass = mono_class_from_mono_type (D.38713);
        D.38685 = gparam->tbuilder;
        D.38714 = klass->image;
        D.38715 = mono_image_alloc0 (D.38714, 28);
        D.38685->generic_container = D.38715;
        D.38685 = gparam->tbuilder;
        D.38710 = D.38685->generic_container;
        D.38710->owner.klass = klass;
      }
      <D.38712>:
      D.38685 = gparam->tbuilder;
      D.38710 = D.38685->generic_container;
      param->param.owner = D.38710;
      <D.38709>:
      <D.38707>:
      D.38698 = gparam->mbuilder;
      D.38716 = D.38698 != 0B;
      D.38717 = (int) D.38716;
      pklass = mono_class_from_generic_parameter (param, image, D.38717);
      D.38718 = &pklass->byval_arg;
      gparam->type.type = D.38718;
      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.38724;
  char * D.38730;
  char * D.38731;
  int D.38732;
  char * D.38733;
  int D.38734;
  int D.38735;
  struct MonoClass * D.38736;
  struct MonoDomain * D.38737;
  char * D.38738;
  struct MonoArray * D.38739;
  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.38720>; else goto <D.38721>;
      <D.38720>:
      iftmp.789 = module->dynamic_image;
      goto <D.38722>;
      <D.38721>:
      iftmp.789 = 0B;
      <D.38722>:
      assembly = iftmp.789;
      D.38724 = sig->arguments;
      if (D.38724 != 0B) goto <D.38725>; else goto <D.38726>;
      <D.38725>:
      D.38724 = sig->arguments;
      iftmp.790 = mono_array_length (D.38724);
      goto <D.38727>;
      <D.38726>:
      iftmp.790 = 0;
      <D.38727>:
      na = iftmp.790;
      D.38724 = sig->arguments;
      check_array_for_usertypes (D.38724);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, na);
      if (assembly != 0B) goto <D.38728>; else goto <D.38729>;
      <D.38728>:
      i = 0;
      goto <D.23328>;
      <D.23327>:
      {
        struct MonoReflectionType * type;

        D.38724 = sig->arguments;
        D.38730 = mono_array_addr_with_size (D.38724, 4, i);
        type = MEM[(struct MonoReflectionType * *)D.38730];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23328>:
      if (i < na) goto <D.23327>; else goto <D.23329>;
      <D.23329>:
      <D.38729>:
      D.38731 = buf.p;
      D.38732 = (int) D.38731;
      D.38733 = buf.buf;
      D.38734 = (int) D.38733;
      D.38735 = D.38732 - D.38734;
      buflen = (guint32) D.38735;
      D.38736 = mono_defaults.byte_class;
      D.38737 = mono_domain_get ();
      result = mono_array_new (D.38737, D.38736, buflen);
      D.38733 = buf.buf;
      D.38738 = mono_array_addr_with_size (result, 1, 0);
      memcpy (D.38738, D.38733, buflen);
      sigbuffer_free (&buf);
      D.38739 = result;
      return D.38739;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_sighelper_get_signature_field (struct MonoReflectionSigHelper * sig)
{
  struct MonoReflectionModuleBuilder * D.38742;
  uintptr_t iftmp.791;
  struct MonoArray * D.38744;
  char * D.38748;
  char * D.38749;
  int D.38750;
  char * D.38751;
  int D.38752;
  int D.38753;
  struct MonoClass * D.38754;
  struct MonoDomain * D.38755;
  char * D.38756;
  struct MonoArray * D.38757;
  struct MonoDynamicImage * assembly;
  guint32 na;
  guint32 buflen;
  guint32 i;
  struct MonoArray * result;
  struct SigBuffer buf;

  try
    {
      D.38742 = sig->module;
      assembly = D.38742->dynamic_image;
      D.38744 = sig->arguments;
      if (D.38744 != 0B) goto <D.38745>; else goto <D.38746>;
      <D.38745>:
      D.38744 = sig->arguments;
      iftmp.791 = mono_array_length (D.38744);
      goto <D.38747>;
      <D.38746>:
      iftmp.791 = 0;
      <D.38747>:
      na = iftmp.791;
      D.38744 = sig->arguments;
      check_array_for_usertypes (D.38744);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      i = 0;
      goto <D.23341>;
      <D.23340>:
      {
        struct MonoReflectionType * type;

        D.38744 = sig->arguments;
        D.38748 = mono_array_addr_with_size (D.38744, 4, i);
        type = MEM[(struct MonoReflectionType * *)D.38748];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23341>:
      if (i < na) goto <D.23340>; else goto <D.23342>;
      <D.23342>:
      D.38749 = buf.p;
      D.38750 = (int) D.38749;
      D.38751 = buf.buf;
      D.38752 = (int) D.38751;
      D.38753 = D.38750 - D.38752;
      buflen = (guint32) D.38753;
      D.38754 = mono_defaults.byte_class;
      D.38755 = mono_domain_get ();
      result = mono_array_new (D.38755, D.38754, buflen);
      D.38751 = buf.buf;
      D.38756 = mono_array_addr_with_size (result, 1, 0);
      memcpy (D.38756, D.38751, buflen);
      sigbuffer_free (&buf);
      D.38757 = result;
      return D.38757;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_create_dynamic_method (struct MonoReflectionDynamicMethod * mb)
{
  int D.38760;
  struct MonoException * D.38763;
  struct MonoReferenceQueue * dynamic_method_queue.792;
  int D.38769;
  unsigned int D.38770;
  int D.38771;
  unsigned int D.38772;
  unsigned int D.38773;
  void * D.38774;
  unsigned int i.793;
  struct MonoArray * D.38776;
  char * D.38777;
  int D.23374;
  int iftmp.794;
  int D.23373;
  struct MonoVTable * D.38781;
  struct MonoClass * D.38782;
  const char[14] * D.38783;
  unsigned char D.38784;
  int D.38785;
  unsigned char D.38786;
  int D.38787;
  _Bool D.38788;
  _Bool D.38789;
  _Bool D.38790;
  const unsigned char * D.38793;
  unsigned char D.38794;
  int D.38795;
  const unsigned char * D.38796;
  unsigned char D.38797;
  int D.38798;
  _Bool D.38799;
  _Bool D.38800;
  const unsigned char * D.38803;
  unsigned char D.38804;
  int D.38805;
  const unsigned char * D.38806;
  unsigned char D.38807;
  int D.38808;
  _Bool D.38809;
  _Bool D.38810;
  const unsigned char * D.38813;
  unsigned char D.38814;
  int D.38815;
  const unsigned char * D.38816;
  unsigned char D.38817;
  int D.38818;
  const char * D.38820;
  struct MonoMethod * D.38823;
  struct GSList * D.38827;
  struct GSList * D.38828;
  struct MonoClass * handle_class.795;
  struct MonoReflectionModule * D.38831;
  struct MonoImage * D.38832;
  <unnamed type> D.38836;
  struct MonoClass * handle_class.796;
  void * * D.38842;
  unsigned int i.797;
  unsigned int D.38844;
  void * * D.38845;
  sizetype i.798;
  sizetype D.38847;
  sizetype D.38848;
  void * * D.38849;
  struct MonoClass * iftmp.799;
  struct MonoReflectionType * D.38851;
  struct MonoType * D.38854;
  struct MonoDomain * D.38856;
  int D.38857;
  struct MonoMethod * D.38860;
  _Bool D.38861;
  long int D.38862;
  long int D.38863;
  void * * D.38866;
  void * D.38867;
  sizetype D.38870;
  sizetype D.38871;
  void * * D.38872;
  void * D.38873;
  struct MonoMethod * D.38876;
  void * D.38877;
  unsigned int D.38878;
  struct GSList * D.38879;
  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.38760 = mono_runtime_is_shutting_down ();
      if (D.38760 != 0) goto <D.38761>; else goto <D.38762>;
      <D.38761>:
      D.38763 = mono_get_exception_invalid_operation ("");
      mono_raise_exception (D.38763);
      <D.38762>:
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.38764>; else goto <D.38765>;
      <D.38764>:
      mono_loader_lock ();
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.38766>; else goto <D.38767>;
      <D.38766>:
      dynamic_method_queue.792 = mono_gc_reference_queue_new (free_dynamic_method);
      dynamic_method_queue = dynamic_method_queue.792;
      queue = dynamic_method_queue;
      <D.38767>:
      mono_loader_unlock ();
      <D.38765>:
      sig = dynamic_method_to_signature (mb);
      reflection_methodbuilder_from_dynamic_method (&rmb, mb);
      D.38769 = mb->nrefs;
      D.38770 = (unsigned int) D.38769;
      rmb.nrefs = D.38770;
      D.38769 = mb->nrefs;
      D.38771 = D.38769 + 1;
      D.38772 = (unsigned int) D.38771;
      D.38773 = D.38772 * 4;
      D.38774 = monoeg_malloc0 (D.38773);
      rmb.refs = D.38774;
      i = 0;
      goto <D.23378>;
      <D.23377>:
      {
        struct MonoClass * handle_class;
        void * ref;
        struct MonoObject * obj;

        try
          {
            i.793 = (unsigned int) i;
            D.38776 = mb->refs;
            D.38777 = mono_array_addr_with_size (D.38776, 4, i.793);
            obj = MEM[(struct MonoObject * *)D.38777];
            {
              size_t __s1_len;
              size_t __s2_len;

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

                D.38781 = obj->vtable;
                D.38782 = D.38781->klass;
                __s2 = D.38782->name;
                D.38783 = "DynamicMethod";
                D.38784 = MEM[(const unsigned char *)D.38783];
                D.38785 = (int) D.38784;
                D.38786 = *__s2;
                D.38787 = (int) D.38786;
                __result = D.38785 - D.38787;
                {
                  D.38788 = __s2_len != 0;
                  D.38789 = __result == 0;
                  D.38790 = D.38788 & D.38789;
                  if (D.38790 != 0) goto <D.38791>; else goto <D.38792>;
                  <D.38791>:
                  D.38793 = &MEM[(void *)"DynamicMethod" + 1B];
                  D.38794 = *D.38793;
                  D.38795 = (int) D.38794;
                  D.38796 = __s2 + 1;
                  D.38797 = *D.38796;
                  D.38798 = (int) D.38797;
                  __result = D.38795 - D.38798;
                  D.38799 = __s2_len > 1;
                  D.38789 = __result == 0;
                  D.38800 = D.38799 & D.38789;
                  if (D.38800 != 0) goto <D.38801>; else goto <D.38802>;
                  <D.38801>:
                  D.38803 = &MEM[(void *)"DynamicMethod" + 2B];
                  D.38804 = *D.38803;
                  D.38805 = (int) D.38804;
                  D.38806 = __s2 + 2;
                  D.38807 = *D.38806;
                  D.38808 = (int) D.38807;
                  __result = D.38805 - D.38808;
                  D.38809 = __s2_len > 2;
                  D.38789 = __result == 0;
                  D.38810 = D.38809 & D.38789;
                  if (D.38810 != 0) goto <D.38811>; else goto <D.38812>;
                  <D.38811>:
                  D.38813 = &MEM[(void *)"DynamicMethod" + 3B];
                  D.38814 = *D.38813;
                  D.38815 = (int) D.38814;
                  D.38816 = __s2 + 3;
                  D.38817 = *D.38816;
                  D.38818 = (int) D.38817;
                  __result = D.38815 - D.38818;
                  <D.38812>:
                  <D.38802>:
                  <D.38792>:
                }
                D.23373 = __result;
              }
              iftmp.794 = -D.23373;
              goto <D.38819>;
              <D.38780>:
              D.38781 = obj->vtable;
              D.38782 = D.38781->klass;
              D.38820 = D.38782->name;
              iftmp.794 = __builtin_strcmp (D.38820, "DynamicMethod");
              <D.38819>:
              D.23374 = iftmp.794;
            }
            if (D.23374 == 0) goto <D.38821>; else goto <D.38822>;
            <D.38821>:
            {
              struct MonoReflectionDynamicMethod * method;

              method = obj;
              D.38823 = method->mhandle;
              if (D.38823 != 0B) goto <D.38824>; else goto <D.38825>;
              <D.38824>:
              ref = method->mhandle;
              goto <D.38826>;
              <D.38825>:
              ref = method;
              D.38827 = method->referenced_by;
              D.38828 = monoeg_g_slist_append (D.38827, mb);
              method->referenced_by = D.38828;
              <D.38826>:
              handle_class.795 = mono_defaults.methodhandle_class;
              handle_class = handle_class.795;
            }
            goto <D.38830>;
            <D.38822>:
            {
              struct MonoException * ex;

              ex = 0B;
              D.38831 = mb->module;
              D.38832 = D.38831->image;
              ref = resolve_object (D.38832, obj, &handle_class, 0B);
              if (ref == 0B) goto <D.38833>; else goto <D.38834>;
              <D.38833>:
              ex = mono_get_exception_type_load (0B, 0B);
              goto <D.38835>;
              <D.38834>:
              D.38836 = mono_security_get_mode ();
              if (D.38836 == 1) goto <D.38837>; else goto <D.38838>;
              <D.38837>:
              handle_class.796 = handle_class;
              ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class.796);
              <D.38838>:
              <D.38835>:
              if (ex != 0B) goto <D.38840>; else goto <D.38841>;
              <D.38840>:
              D.38842 = rmb.refs;
              monoeg_g_free (D.38842);
              mono_raise_exception (ex);
              return;
              <D.38841>:
            }
            <D.38830>:
            D.38842 = rmb.refs;
            i.797 = (unsigned int) i;
            D.38844 = i.797 * 4;
            D.38845 = D.38842 + D.38844;
            *D.38845 = ref;
            D.38842 = rmb.refs;
            i.798 = (sizetype) i;
            D.38847 = i.798 + 1;
            D.38848 = D.38847 * 4;
            D.38849 = D.38842 + D.38848;
            handle_class.796 = handle_class;
            *D.38849 = handle_class.796;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      i = i + 2;
      <D.23378>:
      D.38769 = mb->nrefs;
      if (D.38769 > i) goto <D.23377>; else goto <D.23379>;
      <D.23379>:
      D.38851 = mb->owner;
      if (D.38851 != 0B) goto <D.38852>; else goto <D.38853>;
      <D.38852>:
      D.38851 = mb->owner;
      D.38854 = mono_reflection_type_get_handle (D.38851);
      iftmp.799 = mono_class_from_mono_type (D.38854);
      goto <D.38855>;
      <D.38853>:
      iftmp.799 = mono_defaults.object_class;
      <D.38855>:
      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.38856 = mono_object_get_domain (mb);
      release_data->domain = D.38856;
      D.38857 = mono_gc_reference_queue_add (queue, mb, release_data);
      if (D.38857 == 0) goto <D.38858>; else goto <D.38859>;
      <D.38858>:
      monoeg_g_free (release_data);
      <D.38859>:
      l = mb->referenced_by;
      goto <D.23387>;
      <D.23386>:
      {
        struct MonoReflectionDynamicMethod * method;
        struct MonoMethodWrapper * wrapper;
        void * * data;

        method = l->data;
        wrapper = method->mhandle;
        D.38860 = method->mhandle;
        D.38861 = D.38860 == 0B;
        D.38862 = (long int) D.38861;
        D.38863 = __builtin_expect (D.38862, 0);
        if (D.38863 != 0) goto <D.38864>; else goto <D.38865>;
        <D.38864>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11637, "method->mhandle");
        <D.38865>:
        data = wrapper->method_data;
        i = 0;
        goto <D.23384>;
        <D.23383>:
        i.798 = (sizetype) i;
        D.38847 = i.798 + 1;
        D.38848 = D.38847 * 4;
        D.38866 = data + D.38848;
        D.38867 = *D.38866;
        if (D.38867 == mb) goto <D.38868>; else goto <D.38869>;
        <D.38868>:
        i.798 = (sizetype) i;
        D.38870 = i.798 + 2;
        D.38871 = D.38870 * 4;
        D.38872 = data + D.38871;
        D.38873 = *D.38872;
        handle_class.795 = mono_defaults.methodhandle_class;
        if (D.38873 == handle_class.795) goto <D.38874>; else goto <D.38875>;
        <D.38874>:
        i.798 = (sizetype) i;
        D.38847 = i.798 + 1;
        D.38848 = D.38847 * 4;
        D.38866 = data + D.38848;
        D.38876 = mb->mhandle;
        *D.38866 = D.38876;
        <D.38875>:
        <D.38869>:
        i = i + 2;
        <D.23384>:
        i.797 = (unsigned int) i;
        D.38877 = *data;
        D.38878 = (unsigned int) D.38877;
        if (i.797 < D.38878) goto <D.23383>; else goto <D.23385>;
        <D.23385>:
      }
      l = l->next;
      <D.23387>:
      if (l != 0B) goto <D.23386>; else goto <D.23388>;
      <D.23388>:
      D.38879 = mb->referenced_by;
      monoeg_g_slist_free (D.38879);
      D.38842 = rmb.refs;
      monoeg_g_free (D.38842);
      mb->ilgen = 0B;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


free_dynamic_method (void * dynamic_method)
{
  struct MonoMethod * D.38885;
  struct MonoDomain * D.38886;
  struct DynamicMethodReleaseData * data;

  data = dynamic_method;
  D.38885 = data->handle;
  D.38886 = data->domain;
  mono_runtime_free_method (D.38886, D.38885);
  monoeg_g_free (data);
}


dynamic_method_to_signature (struct MonoReflectionDynamicMethod * method)
{
  struct MonoArray * D.38887;
  unsigned int D.38888;
  unsigned int D.38889;
  _Bool D.38890;
  struct MonoType * iftmp.800;
  struct MonoReflectionType * D.38892;
  struct MonoClass * D.38896;
  struct MonoMethodSignature * D.38897;
  struct MonoMethodSignature * sig;

  D.38887 = method->parameters;
  sig = parameters_to_signature (0B, D.38887);
  D.38888 = method->attrs;
  D.38889 = D.38888 & 16;
  D.38890 = D.38889 == 0;
  sig->hasthis = D.38890;
  D.38892 = method->rtype;
  if (D.38892 != 0B) goto <D.38893>; else goto <D.38894>;
  <D.38893>:
  D.38892 = method->rtype;
  iftmp.800 = mono_reflection_type_get_handle (D.38892);
  goto <D.38895>;
  <D.38894>:
  D.38896 = mono_defaults.void_class;
  iftmp.800 = &D.38896->byval_arg;
  <D.38895>:
  sig->ret = iftmp.800;
  sig->generic_param_count = 0;
  D.38897 = sig;
  return D.38897;
}


reflection_methodbuilder_from_dynamic_method (struct ReflectionMethodBuilder * rmb, struct MonoReflectionDynamicMethod * mb)
{
  struct MonoReflectionILGen * D.38899;
  struct MonoReflectionType * D.38900;
  struct MonoArray * D.38901;
  unsigned int D.38902;
  unsigned int D.38903;
  struct MonoReflectionType * D.38904;
  struct MonoString * D.38905;
  unsigned char D.38906;
  unsigned char D.38907;
  struct MonoMethod * D.38908;

  memset (rmb, 0, 112);
  D.38899 = mb->ilgen;
  rmb->ilgen = D.38899;
  D.38900 = mb->rtype;
  rmb->rtype = D.38900;
  D.38901 = mb->parameters;
  rmb->parameters = D.38901;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  rmb->pinfo = 0B;
  D.38902 = mb->attrs;
  rmb->attrs = D.38902;
  rmb->iattrs = 0;
  D.38903 = mb->call_conv;
  rmb->call_conv = D.38903;
  rmb->code = 0B;
  D.38904 = mb->owner;
  rmb->type = D.38904;
  D.38905 = mb->name;
  rmb->name = D.38905;
  rmb->table_idx = 0B;
  D.38906 = mb->init_locals;
  rmb->init_locals = D.38906;
  D.38907 = mb->skip_visibility;
  rmb->skip_visibility = D.38907;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  rmb->param_modreq = 0B;
  rmb->param_modopt = 0B;
  rmb->permissions = 0B;
  D.38908 = mb->mhandle;
  rmb->mhandle = D.38908;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


resolve_object (struct MonoImage * image, struct MonoObject * obj, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  int D.23434;
  int iftmp.801;
  int D.23433;
  struct MonoVTable * D.38912;
  struct MonoClass * D.38913;
  const char[7] * D.38914;
  unsigned char D.38915;
  int D.38916;
  unsigned char D.38917;
  int D.38918;
  _Bool D.38919;
  _Bool D.38920;
  _Bool D.38921;
  const unsigned char * D.38924;
  unsigned char D.38925;
  int D.38926;
  const unsigned char * D.38927;
  unsigned char D.38928;
  int D.38929;
  _Bool D.38930;
  _Bool D.38931;
  const unsigned char * D.38934;
  unsigned char D.38935;
  int D.38936;
  const unsigned char * D.38937;
  unsigned char D.38938;
  int D.38939;
  _Bool D.38940;
  _Bool D.38941;
  const unsigned char * D.38944;
  unsigned char D.38945;
  int D.38946;
  const unsigned char * D.38947;
  unsigned char D.38948;
  int D.38949;
  const char * D.38951;
  struct MonoClass * D.38954;
  _Bool D.38955;
  long int D.38956;
  long int D.38957;
  int D.23443;
  int iftmp.802;
  int D.23442;
  const char[9] * D.38964;
  unsigned char D.38965;
  int D.38966;
  unsigned char D.38967;
  int D.38968;
  _Bool D.38969;
  _Bool D.38970;
  _Bool D.38971;
  const unsigned char * D.38974;
  unsigned char D.38975;
  int D.38976;
  const unsigned char * D.38977;
  unsigned char D.38978;
  int D.38979;
  _Bool D.38980;
  _Bool D.38981;
  const unsigned char * D.38984;
  unsigned char D.38985;
  int D.38986;
  const unsigned char * D.38987;
  unsigned char D.38988;
  int D.38989;
  _Bool D.38990;
  _Bool D.38991;
  const unsigned char * D.38994;
  unsigned char D.38995;
  int D.38996;
  const unsigned char * D.38997;
  unsigned char D.38998;
  int D.38999;
  int D.39003;
  struct MonoException * D.39006;
  struct MonoClass * D.39010;
  int D.23455;
  int iftmp.803;
  int D.23454;
  const char[11] * D.39020;
  unsigned char D.39021;
  int D.39022;
  unsigned char D.39023;
  int D.39024;
  _Bool D.39025;
  _Bool D.39026;
  _Bool D.39027;
  const unsigned char * D.39030;
  unsigned char D.39031;
  int D.39032;
  const unsigned char * D.39033;
  unsigned char D.39034;
  int D.39035;
  _Bool D.39036;
  _Bool D.39037;
  const unsigned char * D.39040;
  unsigned char D.39041;
  int D.39042;
  const unsigned char * D.39043;
  unsigned char D.39044;
  int D.39045;
  _Bool D.39046;
  _Bool D.39047;
  const unsigned char * D.39050;
  unsigned char D.39051;
  int D.39052;
  const unsigned char * D.39053;
  unsigned char D.39054;
  int D.39055;
  int D.23464;
  int iftmp.804;
  int D.23463;
  const char[12] * D.39061;
  unsigned char D.39062;
  int D.39063;
  unsigned char D.39064;
  int D.39065;
  _Bool D.39066;
  _Bool D.39067;
  _Bool D.39068;
  const unsigned char * D.39071;
  unsigned char D.39072;
  int D.39073;
  const unsigned char * D.39074;
  unsigned char D.39075;
  int D.39076;
  _Bool D.39077;
  _Bool D.39078;
  const unsigned char * D.39081;
  unsigned char D.39082;
  int D.39083;
  const unsigned char * D.39084;
  unsigned char D.39085;
  int D.39086;
  _Bool D.39087;
  _Bool D.39088;
  const unsigned char * D.39091;
  unsigned char D.39092;
  int D.39093;
  const unsigned char * D.39094;
  unsigned char D.39095;
  int D.39096;
  int D.23473;
  int iftmp.805;
  int D.23472;
  const char[19] * D.39102;
  unsigned char D.39103;
  int D.39104;
  unsigned char D.39105;
  int D.39106;
  _Bool D.39107;
  _Bool D.39108;
  _Bool D.39109;
  const unsigned char * D.39112;
  unsigned char D.39113;
  int D.39114;
  const unsigned char * D.39115;
  unsigned char D.39116;
  int D.39117;
  _Bool D.39118;
  _Bool D.39119;
  const unsigned char * D.39122;
  unsigned char D.39123;
  int D.39124;
  const unsigned char * D.39125;
  unsigned char D.39126;
  int D.39127;
  _Bool D.39128;
  _Bool D.39129;
  const unsigned char * D.39132;
  unsigned char D.39133;
  int D.39134;
  const unsigned char * D.39135;
  unsigned char D.39136;
  int D.39137;
  int D.23482;
  int iftmp.806;
  int D.23481;
  const char[18] * D.39143;
  unsigned char D.39144;
  int D.39145;
  unsigned char D.39146;
  int D.39147;
  _Bool D.39148;
  _Bool D.39149;
  _Bool D.39150;
  const unsigned char * D.39153;
  unsigned char D.39154;
  int D.39155;
  const unsigned char * D.39156;
  unsigned char D.39157;
  int D.39158;
  _Bool D.39159;
  _Bool D.39160;
  const unsigned char * D.39163;
  unsigned char D.39164;
  int D.39165;
  const unsigned char * D.39166;
  unsigned char D.39167;
  int D.39168;
  _Bool D.39169;
  _Bool D.39170;
  const unsigned char * D.39173;
  unsigned char D.39174;
  int D.39175;
  const unsigned char * D.39176;
  unsigned char D.39177;
  int D.39178;
  struct MonoClass * D.39182;
  int D.23491;
  int iftmp.807;
  int D.23490;
  const char[14] * D.39188;
  unsigned char D.39189;
  int D.39190;
  unsigned char D.39191;
  int D.39192;
  _Bool D.39193;
  _Bool D.39194;
  _Bool D.39195;
  const unsigned char * D.39198;
  unsigned char D.39199;
  int D.39200;
  const unsigned char * D.39201;
  unsigned char D.39202;
  int D.39203;
  _Bool D.39204;
  _Bool D.39205;
  const unsigned char * D.39208;
  unsigned char D.39209;
  int D.39210;
  const unsigned char * D.39211;
  unsigned char D.39212;
  int D.39213;
  _Bool D.39214;
  _Bool D.39215;
  const unsigned char * D.39218;
  unsigned char D.39219;
  int D.39220;
  const unsigned char * D.39221;
  unsigned char D.39222;
  int D.39223;
  struct MonoDomain * D.39229;
  int D.23502;
  int iftmp.808;
  int D.23501;
  const char[19] * D.39236;
  unsigned char D.39237;
  int D.39238;
  unsigned char D.39239;
  int D.39240;
  _Bool D.39241;
  _Bool D.39242;
  _Bool D.39243;
  const unsigned char * D.39246;
  unsigned char D.39247;
  int D.39248;
  const unsigned char * D.39249;
  unsigned char D.39250;
  int D.39251;
  _Bool D.39252;
  _Bool D.39253;
  const unsigned char * D.39256;
  unsigned char D.39257;
  int D.39258;
  const unsigned char * D.39259;
  unsigned char D.39260;
  int D.39261;
  _Bool D.39262;
  _Bool D.39263;
  const unsigned char * D.39266;
  unsigned char D.39267;
  int D.39268;
  const unsigned char * D.39269;
  unsigned char D.39270;
  int D.39271;
  struct MonoDomain * D.39277;
  int D.23513;
  int iftmp.809;
  int D.23512;
  const char[10] * D.39284;
  unsigned char D.39285;
  int D.39286;
  unsigned char D.39287;
  int D.39288;
  _Bool D.39289;
  _Bool D.39290;
  _Bool D.39291;
  const unsigned char * D.39294;
  unsigned char D.39295;
  int D.39296;
  const unsigned char * D.39297;
  unsigned char D.39298;
  int D.39299;
  _Bool D.39300;
  _Bool D.39301;
  const unsigned char * D.39304;
  unsigned char D.39305;
  int D.39306;
  const unsigned char * D.39307;
  unsigned char D.39308;
  int D.39309;
  _Bool D.39310;
  _Bool D.39311;
  const unsigned char * D.39314;
  unsigned char D.39315;
  int D.39316;
  const unsigned char * D.39317;
  unsigned char D.39318;
  int D.39319;
  struct MonoClass * D.39323;
  struct MonoType * D.39326;
  int D.23527;
  const char * D.39327;
  const char * D.39328;
  int iftmp.810;
  int D.23539;
  _Bool D.39335;
  long int D.39336;
  long int D.39337;
  struct MonoClass * D.39341;
  int D.23548;
  int iftmp.811;
  int D.23547;
  const char[13] * D.39348;
  unsigned char D.39349;
  int D.39350;
  unsigned char D.39351;
  int D.39352;
  _Bool D.39353;
  _Bool D.39354;
  _Bool D.39355;
  const unsigned char * D.39358;
  unsigned char D.39359;
  int D.39360;
  const unsigned char * D.39361;
  unsigned char D.39362;
  int D.39363;
  _Bool D.39364;
  _Bool D.39365;
  const unsigned char * D.39368;
  unsigned char D.39369;
  int D.39370;
  const unsigned char * D.39371;
  unsigned char D.39372;
  int D.39373;
  _Bool D.39374;
  _Bool D.39375;
  const unsigned char * D.39378;
  unsigned char D.39379;
  int D.39380;
  const unsigned char * D.39381;
  unsigned char D.39382;
  int D.39383;
  struct MonoDomain * D.39389;
  struct MonoClassField * D.39390;
  struct MonoClass * D.39393;
  struct MonoGenericContainer * D.39394;
  struct MonoType * D.39397;
  const char * D.39398;
  int D.23562;
  int iftmp.812;
  int D.23561;
  const char[12] * D.39405;
  unsigned char D.39406;
  int D.39407;
  unsigned char D.39408;
  int D.39409;
  _Bool D.39410;
  _Bool D.39411;
  _Bool D.39412;
  const unsigned char * D.39415;
  unsigned char D.39416;
  int D.39417;
  const unsigned char * D.39418;
  unsigned char D.39419;
  int D.39420;
  _Bool D.39421;
  _Bool D.39422;
  const unsigned char * D.39425;
  unsigned char D.39426;
  int D.39427;
  const unsigned char * D.39428;
  unsigned char D.39429;
  int D.39430;
  _Bool D.39431;
  _Bool D.39432;
  const unsigned char * D.39435;
  unsigned char D.39436;
  int D.39437;
  const unsigned char * D.39438;
  unsigned char D.39439;
  int D.39440;
  unsigned char D.39444;
  unsigned char D.39445;
  struct MonoDomain * D.39449;
  int D.23574;
  int iftmp.813;
  int D.23573;
  const char[16] * D.39456;
  unsigned char D.39457;
  int D.39458;
  unsigned char D.39459;
  int D.39460;
  _Bool D.39461;
  _Bool D.39462;
  _Bool D.39463;
  const unsigned char * D.39466;
  unsigned char D.39467;
  int D.39468;
  const unsigned char * D.39469;
  unsigned char D.39470;
  int D.39471;
  _Bool D.39472;
  _Bool D.39473;
  const unsigned char * D.39476;
  unsigned char D.39477;
  int D.39478;
  const unsigned char * D.39479;
  unsigned char D.39480;
  int D.39481;
  _Bool D.39482;
  _Bool D.39483;
  const unsigned char * D.39486;
  unsigned char D.39487;
  int D.39488;
  const unsigned char * D.39489;
  unsigned char D.39490;
  int D.39491;
  struct MonoArray * D.39495;
  unsigned int D.39498;
  unsigned int nargs.814;
  unsigned int D.39501;
  unsigned int D.39502;
  _Bool D.39503;
  unsigned int D.39504;
  _Bool D.39505;
  unsigned int D.39506;
  unsigned char D.39509;
  unsigned char D.39510;
  <unnamed-unsigned:6> D.39511;
  unsigned int D.39513;
  short unsigned int D.39517;
  struct MonoReflectionType * D.39518;
  struct MonoType * D.39519;
  unsigned int i.815;
  char * D.39521;
  void * D.39522;
  struct MonoType * D.39523;
  int D.23590;
  int iftmp.816;
  int D.23589;
  const char[14] * D.39528;
  unsigned char D.39529;
  int D.39530;
  unsigned char D.39531;
  int D.39532;
  _Bool D.39533;
  _Bool D.39534;
  _Bool D.39535;
  const unsigned char * D.39538;
  unsigned char D.39539;
  int D.39540;
  const unsigned char * D.39541;
  unsigned char D.39542;
  int D.39543;
  _Bool D.39544;
  _Bool D.39545;
  const unsigned char * D.39548;
  unsigned char D.39549;
  int D.39550;
  const unsigned char * D.39551;
  unsigned char D.39552;
  int D.39553;
  _Bool D.39554;
  _Bool D.39555;
  const unsigned char * D.39558;
  unsigned char D.39559;
  int D.39560;
  const unsigned char * D.39561;
  unsigned char D.39562;
  int D.39563;
  struct MonoMethod * D.39567;
  _Bool D.39568;
  long int D.39569;
  long int D.39570;
  int D.23600;
  int iftmp.817;
  int D.23599;
  const char[28] * D.39577;
  unsigned char D.39578;
  int D.39579;
  unsigned char D.39580;
  int D.39581;
  _Bool D.39582;
  _Bool D.39583;
  _Bool D.39584;
  const unsigned char * D.39587;
  unsigned char D.39588;
  int D.39589;
  const unsigned char * D.39590;
  unsigned char D.39591;
  int D.39592;
  _Bool D.39593;
  _Bool D.39594;
  const unsigned char * D.39597;
  unsigned char D.39598;
  int D.39599;
  const unsigned char * D.39600;
  unsigned char D.39601;
  int D.39602;
  _Bool D.39603;
  _Bool D.39604;
  const unsigned char * D.39607;
  unsigned char D.39608;
  int D.39609;
  const unsigned char * D.39610;
  unsigned char D.39611;
  int D.39612;
  int D.23610;
  int iftmp.818;
  int D.23609;
  const char[17] * D.39622;
  unsigned char D.39623;
  int D.39624;
  unsigned char D.39625;
  int D.39626;
  _Bool D.39627;
  _Bool D.39628;
  _Bool D.39629;
  const unsigned char * D.39632;
  unsigned char D.39633;
  int D.39634;
  const unsigned char * D.39635;
  unsigned char D.39636;
  int D.39637;
  _Bool D.39638;
  _Bool D.39639;
  const unsigned char * D.39642;
  unsigned char D.39643;
  int D.39644;
  const unsigned char * D.39645;
  unsigned char D.39646;
  int D.39647;
  _Bool D.39648;
  _Bool D.39649;
  const unsigned char * D.39652;
  unsigned char D.39653;
  int D.39654;
  const unsigned char * D.39655;
  unsigned char D.39656;
  int D.39657;
  int D.23620;
  int iftmp.819;
  int D.23619;
  const char[23] * D.39667;
  unsigned char D.39668;
  int D.39669;
  unsigned char D.39670;
  int D.39671;
  _Bool D.39672;
  _Bool D.39673;
  _Bool D.39674;
  const unsigned char * D.39677;
  unsigned char D.39678;
  int D.39679;
  const unsigned char * D.39680;
  unsigned char D.39681;
  int D.39682;
  _Bool D.39683;
  _Bool D.39684;
  const unsigned char * D.39687;
  unsigned char D.39688;
  int D.39689;
  const unsigned char * D.39690;
  unsigned char D.39691;
  int D.39692;
  _Bool D.39693;
  _Bool D.39694;
  const unsigned char * D.39697;
  unsigned char D.39698;
  int D.39699;
  const unsigned char * D.39700;
  unsigned char D.39701;
  int D.39702;
  struct MonoObject * D.39706;
  struct MonoVTable * D.39707;
  struct MonoClass * D.39708;
  int D.39709;
  int D.39713;
  char * D.39717;
  struct MonoReflectionGenericClass * D.39718;
  struct MonoType * D.39719;
  const char * D.39720;
  struct MonoClass * D.39721;
  int D.23634;
  int iftmp.820;
  int D.23633;
  const char[29] * D.39728;
  unsigned char D.39729;
  int D.39730;
  unsigned char D.39731;
  int D.39732;
  _Bool D.39733;
  _Bool D.39734;
  _Bool D.39735;
  const unsigned char * D.39738;
  unsigned char D.39739;
  int D.39740;
  const unsigned char * D.39741;
  unsigned char D.39742;
  int D.39743;
  _Bool D.39744;
  _Bool D.39745;
  const unsigned char * D.39748;
  unsigned char D.39749;
  int D.39750;
  const unsigned char * D.39751;
  unsigned char D.39752;
  int D.39753;
  _Bool D.39754;
  _Bool D.39755;
  const unsigned char * D.39758;
  unsigned char D.39759;
  int D.39760;
  const unsigned char * D.39761;
  unsigned char D.39762;
  int D.39763;
  struct MonoReflectionGenericClass * D.39767;
  struct MonoType * D.39768;
  struct MonoObject * D.39769;
  struct MonoVTable * D.39770;
  struct MonoClass * D.39771;
  int D.39772;
  int D.39776;
  char * D.39780;
  int D.23648;
  int iftmp.821;
  int D.23647;
  const char[24] * D.39785;
  unsigned char D.39786;
  int D.39787;
  unsigned char D.39788;
  int D.39789;
  _Bool D.39790;
  _Bool D.39791;
  _Bool D.39792;
  const unsigned char * D.39795;
  unsigned char D.39796;
  int D.39797;
  const unsigned char * D.39798;
  unsigned char D.39799;
  int D.39800;
  _Bool D.39801;
  _Bool D.39802;
  const unsigned char * D.39805;
  unsigned char D.39806;
  int D.39807;
  const unsigned char * D.39808;
  unsigned char D.39809;
  int D.39810;
  _Bool D.39811;
  _Bool D.39812;
  const unsigned char * D.39815;
  unsigned char D.39816;
  int D.39817;
  const unsigned char * D.39818;
  unsigned char D.39819;
  int D.39820;
  struct MonoArray * D.39824;
  struct MonoReflectionType * D.39830;
  struct MonoType * D.39831;
  struct MonoObject * D.39832;
  struct MonoVTable * D.39833;
  struct MonoClass * D.39834;
  int D.39835;
  int D.39839;
  char * D.39843;
  int D.23662;
  int iftmp.822;
  int D.23661;
  const char[16] * D.39848;
  unsigned char D.39849;
  int D.39850;
  unsigned char D.39851;
  int D.39852;
  _Bool D.39853;
  _Bool D.39854;
  _Bool D.39855;
  const unsigned char * D.39858;
  unsigned char D.39859;
  int D.39860;
  const unsigned char * D.39861;
  unsigned char D.39862;
  int D.39863;
  _Bool D.39864;
  _Bool D.39865;
  const unsigned char * D.39868;
  unsigned char D.39869;
  int D.39870;
  const unsigned char * D.39871;
  unsigned char D.39872;
  int D.39873;
  _Bool D.39874;
  _Bool D.39875;
  const unsigned char * D.39878;
  unsigned char D.39879;
  int D.39880;
  const unsigned char * D.39881;
  unsigned char D.39882;
  int D.39883;
  struct MonoReflectionType * D.39887;
  struct MonoString * D.39888;
  int D.23677;
  const char * D.39889;
  _Bool D.39891;
  long int D.39892;
  long int D.39893;
  struct MonoClass * D.39900;
  int D.39901;
  struct MonoClass * D.39903;
  int D.39904;
  struct MonoClass * D.39906;
  int D.39907;
  void * D.39911;
  void * result;

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

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.38914 = "String";
      D.38915 = MEM[(const unsigned char *)D.38914];
      D.38916 = (int) D.38915;
      D.38917 = *__s2;
      D.38918 = (int) D.38917;
      __result = D.38916 - D.38918;
      {
        D.38919 = __s2_len != 0;
        D.38920 = __result == 0;
        D.38921 = D.38919 & D.38920;
        if (D.38921 != 0) goto <D.38922>; else goto <D.38923>;
        <D.38922>:
        D.38924 = &MEM[(void *)"String" + 1B];
        D.38925 = *D.38924;
        D.38926 = (int) D.38925;
        D.38927 = __s2 + 1;
        D.38928 = *D.38927;
        D.38929 = (int) D.38928;
        __result = D.38926 - D.38929;
        D.38930 = __s2_len > 1;
        D.38920 = __result == 0;
        D.38931 = D.38930 & D.38920;
        if (D.38931 != 0) goto <D.38932>; else goto <D.38933>;
        <D.38932>:
        D.38934 = &MEM[(void *)"String" + 2B];
        D.38935 = *D.38934;
        D.38936 = (int) D.38935;
        D.38937 = __s2 + 2;
        D.38938 = *D.38937;
        D.38939 = (int) D.38938;
        __result = D.38936 - D.38939;
        D.38940 = __s2_len > 2;
        D.38920 = __result == 0;
        D.38941 = D.38940 & D.38920;
        if (D.38941 != 0) goto <D.38942>; else goto <D.38943>;
        <D.38942>:
        D.38944 = &MEM[(void *)"String" + 3B];
        D.38945 = *D.38944;
        D.38946 = (int) D.38945;
        D.38947 = __s2 + 3;
        D.38948 = *D.38947;
        D.38949 = (int) D.38948;
        __result = D.38946 - D.38949;
        <D.38943>:
        <D.38933>:
        <D.38923>:
      }
      D.23433 = __result;
    }
    iftmp.801 = -D.23433;
    goto <D.38950>;
    <D.38911>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.801 = __builtin_strcmp (D.38951, "String");
    <D.38950>:
    D.23434 = iftmp.801;
  }
  if (D.23434 == 0) goto <D.38952>; else goto <D.38953>;
  <D.38952>:
  result = mono_string_intern (obj);
  D.38954 = mono_defaults.string_class;
  *handle_class = D.38954;
  D.38955 = result == 0B;
  D.38956 = (long int) D.38955;
  D.38957 = __builtin_expect (D.38956, 0);
  if (D.38957 != 0) goto <D.38958>; else goto <D.38959>;
  <D.38958>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11751, "result");
  <D.38959>:
  goto <D.38960>;
  <D.38953>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.38964 = "MonoType";
      D.38965 = MEM[(const unsigned char *)D.38964];
      D.38966 = (int) D.38965;
      D.38967 = *__s2;
      D.38968 = (int) D.38967;
      __result = D.38966 - D.38968;
      {
        D.38969 = __s2_len != 0;
        D.38970 = __result == 0;
        D.38971 = D.38969 & D.38970;
        if (D.38971 != 0) goto <D.38972>; else goto <D.38973>;
        <D.38972>:
        D.38974 = &MEM[(void *)"MonoType" + 1B];
        D.38975 = *D.38974;
        D.38976 = (int) D.38975;
        D.38977 = __s2 + 1;
        D.38978 = *D.38977;
        D.38979 = (int) D.38978;
        __result = D.38976 - D.38979;
        D.38980 = __s2_len > 1;
        D.38970 = __result == 0;
        D.38981 = D.38980 & D.38970;
        if (D.38981 != 0) goto <D.38982>; else goto <D.38983>;
        <D.38982>:
        D.38984 = &MEM[(void *)"MonoType" + 2B];
        D.38985 = *D.38984;
        D.38986 = (int) D.38985;
        D.38987 = __s2 + 2;
        D.38988 = *D.38987;
        D.38989 = (int) D.38988;
        __result = D.38986 - D.38989;
        D.38990 = __s2_len > 2;
        D.38970 = __result == 0;
        D.38991 = D.38990 & D.38970;
        if (D.38991 != 0) goto <D.38992>; else goto <D.38993>;
        <D.38992>:
        D.38994 = &MEM[(void *)"MonoType" + 3B];
        D.38995 = *D.38994;
        D.38996 = (int) D.38995;
        D.38997 = __s2 + 3;
        D.38998 = *D.38997;
        D.38999 = (int) D.38998;
        __result = D.38996 - D.38999;
        <D.38993>:
        <D.38983>:
        <D.38973>:
      }
      D.23442 = __result;
    }
    iftmp.802 = -D.23442;
    goto <D.39000>;
    <D.38963>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.802 = __builtin_strcmp (D.38951, "MonoType");
    <D.39000>:
    D.23443 = iftmp.802;
  }
  if (D.23443 == 0) goto <D.39001>; else goto <D.39002>;
  <D.39001>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.39003 = mono_class_init (mc);
    if (D.39003 == 0) goto <D.39004>; else goto <D.39005>;
    <D.39004>:
    D.39006 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.39006);
    <D.39005>:
    if (context != 0B) goto <D.39007>; else goto <D.39008>;
    <D.39007>:
    {
      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.39009>;
    <D.39008>:
    result = mono_class_from_mono_type (type);
    <D.39009>:
    D.39010 = mono_defaults.typehandle_class;
    *handle_class = D.39010;
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39011>; else goto <D.39012>;
    <D.39011>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11766, "result");
    <D.39012>:
  }
  goto <D.39013>;
  <D.39002>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39020 = "MonoMethod";
      D.39021 = MEM[(const unsigned char *)D.39020];
      D.39022 = (int) D.39021;
      D.39023 = *__s2;
      D.39024 = (int) D.39023;
      __result = D.39022 - D.39024;
      {
        D.39025 = __s2_len != 0;
        D.39026 = __result == 0;
        D.39027 = D.39025 & D.39026;
        if (D.39027 != 0) goto <D.39028>; else goto <D.39029>;
        <D.39028>:
        D.39030 = &MEM[(void *)"MonoMethod" + 1B];
        D.39031 = *D.39030;
        D.39032 = (int) D.39031;
        D.39033 = __s2 + 1;
        D.39034 = *D.39033;
        D.39035 = (int) D.39034;
        __result = D.39032 - D.39035;
        D.39036 = __s2_len > 1;
        D.39026 = __result == 0;
        D.39037 = D.39036 & D.39026;
        if (D.39037 != 0) goto <D.39038>; else goto <D.39039>;
        <D.39038>:
        D.39040 = &MEM[(void *)"MonoMethod" + 2B];
        D.39041 = *D.39040;
        D.39042 = (int) D.39041;
        D.39043 = __s2 + 2;
        D.39044 = *D.39043;
        D.39045 = (int) D.39044;
        __result = D.39042 - D.39045;
        D.39046 = __s2_len > 2;
        D.39026 = __result == 0;
        D.39047 = D.39046 & D.39026;
        if (D.39047 != 0) goto <D.39048>; else goto <D.39049>;
        <D.39048>:
        D.39050 = &MEM[(void *)"MonoMethod" + 3B];
        D.39051 = *D.39050;
        D.39052 = (int) D.39051;
        D.39053 = __s2 + 3;
        D.39054 = *D.39053;
        D.39055 = (int) D.39054;
        __result = D.39052 - D.39055;
        <D.39049>:
        <D.39039>:
        <D.39029>:
      }
      D.23454 = __result;
    }
    iftmp.803 = -D.23454;
    goto <D.39056>;
    <D.39019>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.803 = __builtin_strcmp (D.38951, "MonoMethod");
    <D.39056>:
    D.23455 = iftmp.803;
  }
  if (D.23455 == 0) goto <D.39014>; else goto <D.39057>;
  <D.39057>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39061 = "MonoCMethod";
      D.39062 = MEM[(const unsigned char *)D.39061];
      D.39063 = (int) D.39062;
      D.39064 = *__s2;
      D.39065 = (int) D.39064;
      __result = D.39063 - D.39065;
      {
        D.39066 = __s2_len != 0;
        D.39067 = __result == 0;
        D.39068 = D.39066 & D.39067;
        if (D.39068 != 0) goto <D.39069>; else goto <D.39070>;
        <D.39069>:
        D.39071 = &MEM[(void *)"MonoCMethod" + 1B];
        D.39072 = *D.39071;
        D.39073 = (int) D.39072;
        D.39074 = __s2 + 1;
        D.39075 = *D.39074;
        D.39076 = (int) D.39075;
        __result = D.39073 - D.39076;
        D.39077 = __s2_len > 1;
        D.39067 = __result == 0;
        D.39078 = D.39077 & D.39067;
        if (D.39078 != 0) goto <D.39079>; else goto <D.39080>;
        <D.39079>:
        D.39081 = &MEM[(void *)"MonoCMethod" + 2B];
        D.39082 = *D.39081;
        D.39083 = (int) D.39082;
        D.39084 = __s2 + 2;
        D.39085 = *D.39084;
        D.39086 = (int) D.39085;
        __result = D.39083 - D.39086;
        D.39087 = __s2_len > 2;
        D.39067 = __result == 0;
        D.39088 = D.39087 & D.39067;
        if (D.39088 != 0) goto <D.39089>; else goto <D.39090>;
        <D.39089>:
        D.39091 = &MEM[(void *)"MonoCMethod" + 3B];
        D.39092 = *D.39091;
        D.39093 = (int) D.39092;
        D.39094 = __s2 + 3;
        D.39095 = *D.39094;
        D.39096 = (int) D.39095;
        __result = D.39093 - D.39096;
        <D.39090>:
        <D.39080>:
        <D.39070>:
      }
      D.23463 = __result;
    }
    iftmp.804 = -D.23463;
    goto <D.39097>;
    <D.39060>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.804 = __builtin_strcmp (D.38951, "MonoCMethod");
    <D.39097>:
    D.23464 = iftmp.804;
  }
  if (D.23464 == 0) goto <D.39014>; else goto <D.39098>;
  <D.39098>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39102 = "MonoGenericCMethod";
      D.39103 = MEM[(const unsigned char *)D.39102];
      D.39104 = (int) D.39103;
      D.39105 = *__s2;
      D.39106 = (int) D.39105;
      __result = D.39104 - D.39106;
      {
        D.39107 = __s2_len != 0;
        D.39108 = __result == 0;
        D.39109 = D.39107 & D.39108;
        if (D.39109 != 0) goto <D.39110>; else goto <D.39111>;
        <D.39110>:
        D.39112 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.39113 = *D.39112;
        D.39114 = (int) D.39113;
        D.39115 = __s2 + 1;
        D.39116 = *D.39115;
        D.39117 = (int) D.39116;
        __result = D.39114 - D.39117;
        D.39118 = __s2_len > 1;
        D.39108 = __result == 0;
        D.39119 = D.39118 & D.39108;
        if (D.39119 != 0) goto <D.39120>; else goto <D.39121>;
        <D.39120>:
        D.39122 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.39123 = *D.39122;
        D.39124 = (int) D.39123;
        D.39125 = __s2 + 2;
        D.39126 = *D.39125;
        D.39127 = (int) D.39126;
        __result = D.39124 - D.39127;
        D.39128 = __s2_len > 2;
        D.39108 = __result == 0;
        D.39129 = D.39128 & D.39108;
        if (D.39129 != 0) goto <D.39130>; else goto <D.39131>;
        <D.39130>:
        D.39132 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.39133 = *D.39132;
        D.39134 = (int) D.39133;
        D.39135 = __s2 + 3;
        D.39136 = *D.39135;
        D.39137 = (int) D.39136;
        __result = D.39134 - D.39137;
        <D.39131>:
        <D.39121>:
        <D.39111>:
      }
      D.23472 = __result;
    }
    iftmp.805 = -D.23472;
    goto <D.39138>;
    <D.39101>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.805 = __builtin_strcmp (D.38951, "MonoGenericCMethod");
    <D.39138>:
    D.23473 = iftmp.805;
  }
  if (D.23473 == 0) goto <D.39014>; else goto <D.39139>;
  <D.39139>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39143 = "MonoGenericMethod";
      D.39144 = MEM[(const unsigned char *)D.39143];
      D.39145 = (int) D.39144;
      D.39146 = *__s2;
      D.39147 = (int) D.39146;
      __result = D.39145 - D.39147;
      {
        D.39148 = __s2_len != 0;
        D.39149 = __result == 0;
        D.39150 = D.39148 & D.39149;
        if (D.39150 != 0) goto <D.39151>; else goto <D.39152>;
        <D.39151>:
        D.39153 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.39154 = *D.39153;
        D.39155 = (int) D.39154;
        D.39156 = __s2 + 1;
        D.39157 = *D.39156;
        D.39158 = (int) D.39157;
        __result = D.39155 - D.39158;
        D.39159 = __s2_len > 1;
        D.39149 = __result == 0;
        D.39160 = D.39159 & D.39149;
        if (D.39160 != 0) goto <D.39161>; else goto <D.39162>;
        <D.39161>:
        D.39163 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.39164 = *D.39163;
        D.39165 = (int) D.39164;
        D.39166 = __s2 + 2;
        D.39167 = *D.39166;
        D.39168 = (int) D.39167;
        __result = D.39165 - D.39168;
        D.39169 = __s2_len > 2;
        D.39149 = __result == 0;
        D.39170 = D.39169 & D.39149;
        if (D.39170 != 0) goto <D.39171>; else goto <D.39172>;
        <D.39171>:
        D.39173 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.39174 = *D.39173;
        D.39175 = (int) D.39174;
        D.39176 = __s2 + 3;
        D.39177 = *D.39176;
        D.39178 = (int) D.39177;
        __result = D.39175 - D.39178;
        <D.39172>:
        <D.39162>:
        <D.39152>:
      }
      D.23481 = __result;
    }
    iftmp.806 = -D.23481;
    goto <D.39179>;
    <D.39142>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.806 = __builtin_strcmp (D.38951, "MonoGenericMethod");
    <D.39179>:
    D.23482 = iftmp.806;
  }
  if (D.23482 == 0) goto <D.39014>; else goto <D.39015>;
  <D.39014>:
  result = MEM[(struct MonoReflectionMethod *)obj].method;
  if (context != 0B) goto <D.39180>; else goto <D.39181>;
  <D.39180>:
  result = mono_class_inflate_generic_method (result, context);
  <D.39181>:
  D.39182 = mono_defaults.methodhandle_class;
  *handle_class = D.39182;
  D.38955 = result == 0B;
  D.38956 = (long int) D.38955;
  D.38957 = __builtin_expect (D.38956, 0);
  if (D.38957 != 0) goto <D.39183>; else goto <D.39184>;
  <D.39183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11775, "result");
  <D.39184>:
  goto <D.39016>;
  <D.39015>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39188 = "MethodBuilder";
      D.39189 = MEM[(const unsigned char *)D.39188];
      D.39190 = (int) D.39189;
      D.39191 = *__s2;
      D.39192 = (int) D.39191;
      __result = D.39190 - D.39192;
      {
        D.39193 = __s2_len != 0;
        D.39194 = __result == 0;
        D.39195 = D.39193 & D.39194;
        if (D.39195 != 0) goto <D.39196>; else goto <D.39197>;
        <D.39196>:
        D.39198 = &MEM[(void *)"MethodBuilder" + 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;
        D.39204 = __s2_len > 1;
        D.39194 = __result == 0;
        D.39205 = D.39204 & D.39194;
        if (D.39205 != 0) goto <D.39206>; else goto <D.39207>;
        <D.39206>:
        D.39208 = &MEM[(void *)"MethodBuilder" + 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;
        D.39214 = __s2_len > 2;
        D.39194 = __result == 0;
        D.39215 = D.39214 & D.39194;
        if (D.39215 != 0) goto <D.39216>; else goto <D.39217>;
        <D.39216>:
        D.39218 = &MEM[(void *)"MethodBuilder" + 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.39207>:
        <D.39197>:
      }
      D.23490 = __result;
    }
    iftmp.807 = -D.23490;
    goto <D.39224>;
    <D.39187>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.807 = __builtin_strcmp (D.38951, "MethodBuilder");
    <D.39224>:
    D.23491 = iftmp.807;
  }
  if (D.23491 == 0) goto <D.39225>; else goto <D.39226>;
  <D.39225>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    result = mb->mhandle;
    if (result == 0B) goto <D.39227>; else goto <D.39228>;
    <D.39227>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = mb->type;
      D.39229 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39229, 0B, tb);
      result = mb->mhandle;
    }
    <D.39228>:
    if (context != 0B) goto <D.39230>; else goto <D.39231>;
    <D.39230>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39231>:
    D.39182 = mono_defaults.methodhandle_class;
    *handle_class = D.39182;
  }
  goto <D.39232>;
  <D.39226>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39236 = "ConstructorBuilder";
      D.39237 = MEM[(const unsigned char *)D.39236];
      D.39238 = (int) D.39237;
      D.39239 = *__s2;
      D.39240 = (int) D.39239;
      __result = D.39238 - D.39240;
      {
        D.39241 = __s2_len != 0;
        D.39242 = __result == 0;
        D.39243 = D.39241 & D.39242;
        if (D.39243 != 0) goto <D.39244>; else goto <D.39245>;
        <D.39244>:
        D.39246 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.39247 = *D.39246;
        D.39248 = (int) D.39247;
        D.39249 = __s2 + 1;
        D.39250 = *D.39249;
        D.39251 = (int) D.39250;
        __result = D.39248 - D.39251;
        D.39252 = __s2_len > 1;
        D.39242 = __result == 0;
        D.39253 = D.39252 & D.39242;
        if (D.39253 != 0) goto <D.39254>; else goto <D.39255>;
        <D.39254>:
        D.39256 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.39257 = *D.39256;
        D.39258 = (int) D.39257;
        D.39259 = __s2 + 2;
        D.39260 = *D.39259;
        D.39261 = (int) D.39260;
        __result = D.39258 - D.39261;
        D.39262 = __s2_len > 2;
        D.39242 = __result == 0;
        D.39263 = D.39262 & D.39242;
        if (D.39263 != 0) goto <D.39264>; else goto <D.39265>;
        <D.39264>:
        D.39266 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.39267 = *D.39266;
        D.39268 = (int) D.39267;
        D.39269 = __s2 + 3;
        D.39270 = *D.39269;
        D.39271 = (int) D.39270;
        __result = D.39268 - D.39271;
        <D.39265>:
        <D.39255>:
        <D.39245>:
      }
      D.23501 = __result;
    }
    iftmp.808 = -D.23501;
    goto <D.39272>;
    <D.39235>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.808 = __builtin_strcmp (D.38951, "ConstructorBuilder");
    <D.39272>:
    D.23502 = iftmp.808;
  }
  if (D.23502 == 0) goto <D.39273>; else goto <D.39274>;
  <D.39273>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    result = cb->mhandle;
    if (result == 0B) goto <D.39275>; else goto <D.39276>;
    <D.39275>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = cb->type;
      D.39277 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39277, 0B, tb);
      result = cb->mhandle;
    }
    <D.39276>:
    if (context != 0B) goto <D.39278>; else goto <D.39279>;
    <D.39278>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39279>:
    D.39182 = mono_defaults.methodhandle_class;
    *handle_class = D.39182;
  }
  goto <D.39280>;
  <D.39274>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39284 = "MonoField";
      D.39285 = MEM[(const unsigned char *)D.39284];
      D.39286 = (int) D.39285;
      D.39287 = *__s2;
      D.39288 = (int) D.39287;
      __result = D.39286 - D.39288;
      {
        D.39289 = __s2_len != 0;
        D.39290 = __result == 0;
        D.39291 = D.39289 & D.39290;
        if (D.39291 != 0) goto <D.39292>; else goto <D.39293>;
        <D.39292>:
        D.39294 = &MEM[(void *)"MonoField" + 1B];
        D.39295 = *D.39294;
        D.39296 = (int) D.39295;
        D.39297 = __s2 + 1;
        D.39298 = *D.39297;
        D.39299 = (int) D.39298;
        __result = D.39296 - D.39299;
        D.39300 = __s2_len > 1;
        D.39290 = __result == 0;
        D.39301 = D.39300 & D.39290;
        if (D.39301 != 0) goto <D.39302>; else goto <D.39303>;
        <D.39302>:
        D.39304 = &MEM[(void *)"MonoField" + 2B];
        D.39305 = *D.39304;
        D.39306 = (int) D.39305;
        D.39307 = __s2 + 2;
        D.39308 = *D.39307;
        D.39309 = (int) D.39308;
        __result = D.39306 - D.39309;
        D.39310 = __s2_len > 2;
        D.39290 = __result == 0;
        D.39311 = D.39310 & D.39290;
        if (D.39311 != 0) goto <D.39312>; else goto <D.39313>;
        <D.39312>:
        D.39314 = &MEM[(void *)"MonoField" + 3B];
        D.39315 = *D.39314;
        D.39316 = (int) D.39315;
        D.39317 = __s2 + 3;
        D.39318 = *D.39317;
        D.39319 = (int) D.39318;
        __result = D.39316 - D.39319;
        <D.39313>:
        <D.39303>:
        <D.39293>:
      }
      D.23512 = __result;
    }
    iftmp.809 = -D.23512;
    goto <D.39320>;
    <D.39283>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.809 = __builtin_strcmp (D.38951, "MonoField");
    <D.39320>:
    D.23513 = iftmp.809;
  }
  if (D.23513 == 0) goto <D.39321>; else goto <D.39322>;
  <D.39321>:
  {
    struct MonoClassField * field;

    field = MEM[(struct MonoReflectionField *)obj].field;
    D.39323 = field->parent;
    ensure_complete_type (D.39323);
    if (context != 0B) goto <D.39324>; else goto <D.39325>;
    <D.39324>:
    {
      struct MonoType * inflated;
      struct MonoClass * class;
      struct MonoClassField * inflated_field;
      void * iter;

      try
        {
          D.39323 = field->parent;
          D.39326 = &D.39323->byval_arg;
          inflated = mono_class_inflate_generic_type (D.39326, context);
          class = mono_class_from_mono_type (inflated);
          iter = 0B;
          mono_metadata_free_type (inflated);
          goto <D.23530>;
          <D.23529>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.39327 = inflated_field->name;
            D.39328 = field->name;
            D.23527 = __builtin_strcmp (D.39328, D.39327);
          }
          if (D.23527 == 0) goto <D.23528>; else goto <D.39329>;
          <D.39329>:
          <D.23530>:
          inflated_field = mono_class_get_fields (class, &iter);
          if (inflated_field != 0B) goto <D.23529>; else goto <D.23528>;
          <D.23528>:
          if (inflated_field == 0B) goto <D.39331>; else goto <D.39334>;
          <D.39334>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.39327 = inflated_field->name;
            D.39328 = field->name;
            D.23539 = __builtin_strcmp (D.39328, D.39327);
          }
          if (D.23539 != 0) goto <D.39331>; else goto <D.39332>;
          <D.39331>:
          iftmp.810 = 1;
          goto <D.39333>;
          <D.39332>:
          iftmp.810 = 0;
          <D.39333>:
          D.39335 = iftmp.810 != 0;
          D.39336 = (long int) D.39335;
          D.39337 = __builtin_expect (D.39336, 0);
          if (D.39337 != 0) goto <D.39338>; else goto <D.39339>;
          <D.39338>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11825, "inflated_field && !strcmp (field->name, inflated_field->name)");
          <D.39339>:
          result = inflated_field;
        }
      finally
        {
          iter = {CLOBBER};
        }
    }
    goto <D.39340>;
    <D.39325>:
    result = field;
    <D.39340>:
    D.39341 = mono_defaults.fieldhandle_class;
    *handle_class = D.39341;
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39342>; else goto <D.39343>;
    <D.39342>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11831, "result");
    <D.39343>:
  }
  goto <D.39344>;
  <D.39322>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39348 = "FieldBuilder";
      D.39349 = MEM[(const unsigned char *)D.39348];
      D.39350 = (int) D.39349;
      D.39351 = *__s2;
      D.39352 = (int) D.39351;
      __result = D.39350 - D.39352;
      {
        D.39353 = __s2_len != 0;
        D.39354 = __result == 0;
        D.39355 = D.39353 & D.39354;
        if (D.39355 != 0) goto <D.39356>; else goto <D.39357>;
        <D.39356>:
        D.39358 = &MEM[(void *)"FieldBuilder" + 1B];
        D.39359 = *D.39358;
        D.39360 = (int) D.39359;
        D.39361 = __s2 + 1;
        D.39362 = *D.39361;
        D.39363 = (int) D.39362;
        __result = D.39360 - D.39363;
        D.39364 = __s2_len > 1;
        D.39354 = __result == 0;
        D.39365 = D.39364 & D.39354;
        if (D.39365 != 0) goto <D.39366>; else goto <D.39367>;
        <D.39366>:
        D.39368 = &MEM[(void *)"FieldBuilder" + 2B];
        D.39369 = *D.39368;
        D.39370 = (int) D.39369;
        D.39371 = __s2 + 2;
        D.39372 = *D.39371;
        D.39373 = (int) D.39372;
        __result = D.39370 - D.39373;
        D.39374 = __s2_len > 2;
        D.39354 = __result == 0;
        D.39375 = D.39374 & D.39354;
        if (D.39375 != 0) goto <D.39376>; else goto <D.39377>;
        <D.39376>:
        D.39378 = &MEM[(void *)"FieldBuilder" + 3B];
        D.39379 = *D.39378;
        D.39380 = (int) D.39379;
        D.39381 = __s2 + 3;
        D.39382 = *D.39381;
        D.39383 = (int) D.39382;
        __result = D.39380 - D.39383;
        <D.39377>:
        <D.39367>:
        <D.39357>:
      }
      D.23547 = __result;
    }
    iftmp.811 = -D.23547;
    goto <D.39384>;
    <D.39347>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.811 = __builtin_strcmp (D.38951, "FieldBuilder");
    <D.39384>:
    D.23548 = iftmp.811;
  }
  if (D.23548 == 0) goto <D.39385>; else goto <D.39386>;
  <D.39385>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    result = fb->handle;
    if (result == 0B) goto <D.39387>; else goto <D.39388>;
    <D.39387>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = fb->typeb;
      D.39389 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39389, 0B, tb);
      result = fb->handle;
    }
    <D.39388>:
    D.39390 = fb->handle;
    if (D.39390 != 0B) goto <D.39391>; else goto <D.39392>;
    <D.39391>:
    D.39390 = fb->handle;
    D.39393 = D.39390->parent;
    D.39394 = D.39393->generic_container;
    if (D.39394 != 0B) goto <D.39395>; else goto <D.39396>;
    <D.39395>:
    {
      struct MonoClass * klass;
      struct MonoType * type;
      struct MonoClass * inflated;

      D.39390 = fb->handle;
      klass = D.39390->parent;
      D.39397 = &klass->byval_arg;
      type = mono_class_inflate_generic_type (D.39397, context);
      inflated = mono_class_from_mono_type (type);
      D.39390 = fb->handle;
      D.39398 = mono_field_get_name (D.39390);
      result = mono_class_get_field_from_name (inflated, D.39398);
      D.38955 = result == 0B;
      D.38956 = (long int) D.38955;
      D.38957 = __builtin_expect (D.38956, 0);
      if (D.38957 != 0) goto <D.39399>; else goto <D.39400>;
      <D.39399>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11849, "result");
      <D.39400>:
      mono_metadata_free_type (type);
    }
    <D.39396>:
    <D.39392>:
    D.39341 = mono_defaults.fieldhandle_class;
    *handle_class = D.39341;
  }
  goto <D.39401>;
  <D.39386>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39405 = "TypeBuilder";
      D.39406 = MEM[(const unsigned char *)D.39405];
      D.39407 = (int) D.39406;
      D.39408 = *__s2;
      D.39409 = (int) D.39408;
      __result = D.39407 - D.39409;
      {
        D.39410 = __s2_len != 0;
        D.39411 = __result == 0;
        D.39412 = D.39410 & D.39411;
        if (D.39412 != 0) goto <D.39413>; else goto <D.39414>;
        <D.39413>:
        D.39415 = &MEM[(void *)"TypeBuilder" + 1B];
        D.39416 = *D.39415;
        D.39417 = (int) D.39416;
        D.39418 = __s2 + 1;
        D.39419 = *D.39418;
        D.39420 = (int) D.39419;
        __result = D.39417 - D.39420;
        D.39421 = __s2_len > 1;
        D.39411 = __result == 0;
        D.39422 = D.39421 & D.39411;
        if (D.39422 != 0) goto <D.39423>; else goto <D.39424>;
        <D.39423>:
        D.39425 = &MEM[(void *)"TypeBuilder" + 2B];
        D.39426 = *D.39425;
        D.39427 = (int) D.39426;
        D.39428 = __s2 + 2;
        D.39429 = *D.39428;
        D.39430 = (int) D.39429;
        __result = D.39427 - D.39430;
        D.39431 = __s2_len > 2;
        D.39411 = __result == 0;
        D.39432 = D.39431 & D.39411;
        if (D.39432 != 0) goto <D.39433>; else goto <D.39434>;
        <D.39433>:
        D.39435 = &MEM[(void *)"TypeBuilder" + 3B];
        D.39436 = *D.39435;
        D.39437 = (int) D.39436;
        D.39438 = __s2 + 3;
        D.39439 = *D.39438;
        D.39440 = (int) D.39439;
        __result = D.39437 - D.39440;
        <D.39434>:
        <D.39424>:
        <D.39414>:
      }
      D.23561 = __result;
    }
    iftmp.812 = -D.23561;
    goto <D.39441>;
    <D.39404>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.812 = __builtin_strcmp (D.38951, "TypeBuilder");
    <D.39441>:
    D.23562 = iftmp.812;
  }
  if (D.23562 == 0) goto <D.39442>; else goto <D.39443>;
  <D.39442>:
  {
    struct MonoReflectionTypeBuilder * tb;
    struct MonoType * type;
    struct MonoClass * klass;

    tb = obj;
    type = mono_reflection_type_get_handle (tb);
    klass = type->data.klass;
    D.39444 = BIT_FIELD_REF <*klass, 8, 160>;
    D.39445 = D.39444 & 128;
    if (D.39445 != 0) goto <D.39446>; else goto <D.39447>;
    <D.39446>:
    result = klass;
    goto <D.39448>;
    <D.39447>:
    D.39449 = mono_domain_get ();
    mono_domain_try_type_resolve (D.39449, 0B, tb);
    result = type->data.klass;
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39450>; else goto <D.39451>;
    <D.39450>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11866, "result");
    <D.39451>:
    <D.39448>:
    D.39010 = mono_defaults.typehandle_class;
    *handle_class = D.39010;
  }
  goto <D.39452>;
  <D.39443>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39456 = "SignatureHelper";
      D.39457 = MEM[(const unsigned char *)D.39456];
      D.39458 = (int) D.39457;
      D.39459 = *__s2;
      D.39460 = (int) D.39459;
      __result = D.39458 - D.39460;
      {
        D.39461 = __s2_len != 0;
        D.39462 = __result == 0;
        D.39463 = D.39461 & D.39462;
        if (D.39463 != 0) goto <D.39464>; else goto <D.39465>;
        <D.39464>:
        D.39466 = &MEM[(void *)"SignatureHelper" + 1B];
        D.39467 = *D.39466;
        D.39468 = (int) D.39467;
        D.39469 = __s2 + 1;
        D.39470 = *D.39469;
        D.39471 = (int) D.39470;
        __result = D.39468 - D.39471;
        D.39472 = __s2_len > 1;
        D.39462 = __result == 0;
        D.39473 = D.39472 & D.39462;
        if (D.39473 != 0) goto <D.39474>; else goto <D.39475>;
        <D.39474>:
        D.39476 = &MEM[(void *)"SignatureHelper" + 2B];
        D.39477 = *D.39476;
        D.39478 = (int) D.39477;
        D.39479 = __s2 + 2;
        D.39480 = *D.39479;
        D.39481 = (int) D.39480;
        __result = D.39478 - D.39481;
        D.39482 = __s2_len > 2;
        D.39462 = __result == 0;
        D.39483 = D.39482 & D.39462;
        if (D.39483 != 0) goto <D.39484>; else goto <D.39485>;
        <D.39484>:
        D.39486 = &MEM[(void *)"SignatureHelper" + 3B];
        D.39487 = *D.39486;
        D.39488 = (int) D.39487;
        D.39489 = __s2 + 3;
        D.39490 = *D.39489;
        D.39491 = (int) D.39490;
        __result = D.39488 - D.39491;
        <D.39485>:
        <D.39475>:
        <D.39465>:
      }
      D.23573 = __result;
    }
    iftmp.813 = -D.23573;
    goto <D.39492>;
    <D.39455>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.813 = __builtin_strcmp (D.38951, "SignatureHelper");
    <D.39492>:
    D.23574 = iftmp.813;
  }
  if (D.23574 == 0) goto <D.39493>; else goto <D.39494>;
  <D.39493>:
  {
    struct MonoReflectionSigHelper * helper;
    struct MonoMethodSignature * sig;
    int nargs;
    int i;

    helper = obj;
    D.39495 = helper->arguments;
    if (D.39495 != 0B) goto <D.39496>; else goto <D.39497>;
    <D.39496>:
    D.39495 = helper->arguments;
    D.39498 = mono_array_length (D.39495);
    nargs = (int) D.39498;
    goto <D.39499>;
    <D.39497>:
    nargs = 0;
    <D.39499>:
    nargs.814 = (unsigned int) nargs;
    sig = mono_metadata_signature_alloc (image, nargs.814);
    D.39501 = helper->call_conv;
    D.39502 = D.39501 & 64;
    D.39503 = D.39502 != 0;
    sig->explicit_this = D.39503;
    D.39501 = helper->call_conv;
    D.39504 = D.39501 & 32;
    D.39505 = D.39504 != 0;
    sig->hasthis = D.39505;
    D.39506 = helper->unmanaged_call_conv;
    if (D.39506 != 0) goto <D.39507>; else goto <D.39508>;
    <D.39507>:
    D.39506 = helper->unmanaged_call_conv;
    D.39509 = (unsigned char) D.39506;
    D.39510 = D.39509 + 255;
    D.39511 = (<unnamed-unsigned:6>) D.39510;
    sig->call_convention = D.39511;
    sig->pinvoke = 1;
    goto <D.39512>;
    <D.39508>:
    D.39501 = helper->call_conv;
    D.39513 = D.39501 & 2;
    if (D.39513 != 0) goto <D.39514>; else goto <D.39515>;
    <D.39514>:
    sig->call_convention = 5;
    goto <D.39516>;
    <D.39515>:
    sig->call_convention = 0;
    <D.39516>:
    <D.39512>:
    D.39517 = (short unsigned int) nargs;
    sig->param_count = D.39517;
    D.39518 = helper->return_type;
    D.39519 = D.39518->type;
    sig->ret = D.39519;
    i = 0;
    goto <D.23580>;
    <D.23579>:
    i.815 = (unsigned int) i;
    D.39495 = helper->arguments;
    D.39521 = mono_array_addr_with_size (D.39495, 4, i.815);
    D.39522 = MEM[(void * *)D.39521];
    D.39523 = mono_reflection_type_get_handle (D.39522);
    sig->params[i] = D.39523;
    i = i + 1;
    <D.23580>:
    if (i < nargs) goto <D.23579>; else goto <D.23581>;
    <D.23581>:
    result = sig;
    *handle_class = 0B;
  }
  goto <D.39524>;
  <D.39494>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39528 = "DynamicMethod";
      D.39529 = MEM[(const unsigned char *)D.39528];
      D.39530 = (int) D.39529;
      D.39531 = *__s2;
      D.39532 = (int) D.39531;
      __result = D.39530 - D.39532;
      {
        D.39533 = __s2_len != 0;
        D.39534 = __result == 0;
        D.39535 = D.39533 & D.39534;
        if (D.39535 != 0) goto <D.39536>; else goto <D.39537>;
        <D.39536>:
        D.39538 = &MEM[(void *)"DynamicMethod" + 1B];
        D.39539 = *D.39538;
        D.39540 = (int) D.39539;
        D.39541 = __s2 + 1;
        D.39542 = *D.39541;
        D.39543 = (int) D.39542;
        __result = D.39540 - D.39543;
        D.39544 = __s2_len > 1;
        D.39534 = __result == 0;
        D.39545 = D.39544 & D.39534;
        if (D.39545 != 0) goto <D.39546>; else goto <D.39547>;
        <D.39546>:
        D.39548 = &MEM[(void *)"DynamicMethod" + 2B];
        D.39549 = *D.39548;
        D.39550 = (int) D.39549;
        D.39551 = __s2 + 2;
        D.39552 = *D.39551;
        D.39553 = (int) D.39552;
        __result = D.39550 - D.39553;
        D.39554 = __s2_len > 2;
        D.39534 = __result == 0;
        D.39555 = D.39554 & D.39534;
        if (D.39555 != 0) goto <D.39556>; else goto <D.39557>;
        <D.39556>:
        D.39558 = &MEM[(void *)"DynamicMethod" + 3B];
        D.39559 = *D.39558;
        D.39560 = (int) D.39559;
        D.39561 = __s2 + 3;
        D.39562 = *D.39561;
        D.39563 = (int) D.39562;
        __result = D.39560 - D.39563;
        <D.39557>:
        <D.39547>:
        <D.39537>:
      }
      D.23589 = __result;
    }
    iftmp.816 = -D.23589;
    goto <D.39564>;
    <D.39527>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.816 = __builtin_strcmp (D.38951, "DynamicMethod");
    <D.39564>:
    D.23590 = iftmp.816;
  }
  if (D.23590 == 0) goto <D.39565>; else goto <D.39566>;
  <D.39565>:
  {
    struct MonoReflectionDynamicMethod * method;

    method = obj;
    D.39567 = method->mhandle;
    D.39568 = D.39567 == 0B;
    D.39569 = (long int) D.39568;
    D.39570 = __builtin_expect (D.39569, 0);
    if (D.39570 != 0) goto <D.39571>; else goto <D.39572>;
    <D.39571>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11903, "method->mhandle");
    <D.39572>:
    result = method->mhandle;
    D.39182 = mono_defaults.methodhandle_class;
    *handle_class = D.39182;
  }
  goto <D.39573>;
  <D.39566>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39577 = "GenericTypeParameterBuilder";
      D.39578 = MEM[(const unsigned char *)D.39577];
      D.39579 = (int) D.39578;
      D.39580 = *__s2;
      D.39581 = (int) D.39580;
      __result = D.39579 - D.39581;
      {
        D.39582 = __s2_len != 0;
        D.39583 = __result == 0;
        D.39584 = D.39582 & D.39583;
        if (D.39584 != 0) goto <D.39585>; else goto <D.39586>;
        <D.39585>:
        D.39587 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.39588 = *D.39587;
        D.39589 = (int) D.39588;
        D.39590 = __s2 + 1;
        D.39591 = *D.39590;
        D.39592 = (int) D.39591;
        __result = D.39589 - D.39592;
        D.39593 = __s2_len > 1;
        D.39583 = __result == 0;
        D.39594 = D.39593 & D.39583;
        if (D.39594 != 0) goto <D.39595>; else goto <D.39596>;
        <D.39595>:
        D.39597 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.39598 = *D.39597;
        D.39599 = (int) D.39598;
        D.39600 = __s2 + 2;
        D.39601 = *D.39600;
        D.39602 = (int) D.39601;
        __result = D.39599 - D.39602;
        D.39603 = __s2_len > 2;
        D.39583 = __result == 0;
        D.39604 = D.39603 & D.39583;
        if (D.39604 != 0) goto <D.39605>; else goto <D.39606>;
        <D.39605>:
        D.39607 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.39608 = *D.39607;
        D.39609 = (int) D.39608;
        D.39610 = __s2 + 3;
        D.39611 = *D.39610;
        D.39612 = (int) D.39611;
        __result = D.39609 - D.39612;
        <D.39606>:
        <D.39596>:
        <D.39586>:
      }
      D.23599 = __result;
    }
    iftmp.817 = -D.23599;
    goto <D.39613>;
    <D.39576>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.817 = __builtin_strcmp (D.38951, "GenericTypeParameterBuilder");
    <D.39613>:
    D.23600 = iftmp.817;
  }
  if (D.23600 == 0) goto <D.39614>; else goto <D.39615>;
  <D.39614>:
  {
    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.39010 = mono_defaults.typehandle_class;
    *handle_class = D.39010;
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39616>; else goto <D.39617>;
    <D.39616>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11911, "result");
    <D.39617>:
    mono_metadata_free_type (type);
  }
  goto <D.39618>;
  <D.39615>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39622 = "MonoGenericClass";
      D.39623 = MEM[(const unsigned char *)D.39622];
      D.39624 = (int) D.39623;
      D.39625 = *__s2;
      D.39626 = (int) D.39625;
      __result = D.39624 - D.39626;
      {
        D.39627 = __s2_len != 0;
        D.39628 = __result == 0;
        D.39629 = D.39627 & D.39628;
        if (D.39629 != 0) goto <D.39630>; else goto <D.39631>;
        <D.39630>:
        D.39632 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.39633 = *D.39632;
        D.39634 = (int) D.39633;
        D.39635 = __s2 + 1;
        D.39636 = *D.39635;
        D.39637 = (int) D.39636;
        __result = D.39634 - D.39637;
        D.39638 = __s2_len > 1;
        D.39628 = __result == 0;
        D.39639 = D.39638 & D.39628;
        if (D.39639 != 0) goto <D.39640>; else goto <D.39641>;
        <D.39640>:
        D.39642 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.39643 = *D.39642;
        D.39644 = (int) D.39643;
        D.39645 = __s2 + 2;
        D.39646 = *D.39645;
        D.39647 = (int) D.39646;
        __result = D.39644 - D.39647;
        D.39648 = __s2_len > 2;
        D.39628 = __result == 0;
        D.39649 = D.39648 & D.39628;
        if (D.39649 != 0) goto <D.39650>; else goto <D.39651>;
        <D.39650>:
        D.39652 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.39653 = *D.39652;
        D.39654 = (int) D.39653;
        D.39655 = __s2 + 3;
        D.39656 = *D.39655;
        D.39657 = (int) D.39656;
        __result = D.39654 - D.39657;
        <D.39651>:
        <D.39641>:
        <D.39631>:
      }
      D.23609 = __result;
    }
    iftmp.818 = -D.23609;
    goto <D.39658>;
    <D.39621>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.818 = __builtin_strcmp (D.38951, "MonoGenericClass");
    <D.39658>:
    D.23610 = iftmp.818;
  }
  if (D.23610 == 0) goto <D.39659>; else goto <D.39660>;
  <D.39659>:
  {
    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.39010 = mono_defaults.typehandle_class;
    *handle_class = D.39010;
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39661>; else goto <D.39662>;
    <D.39661>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11918, "result");
    <D.39662>:
    mono_metadata_free_type (type);
  }
  goto <D.39663>;
  <D.39660>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39667 = "FieldOnTypeBuilderInst";
      D.39668 = MEM[(const unsigned char *)D.39667];
      D.39669 = (int) D.39668;
      D.39670 = *__s2;
      D.39671 = (int) D.39670;
      __result = D.39669 - D.39671;
      {
        D.39672 = __s2_len != 0;
        D.39673 = __result == 0;
        D.39674 = D.39672 & D.39673;
        if (D.39674 != 0) goto <D.39675>; else goto <D.39676>;
        <D.39675>:
        D.39677 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.39678 = *D.39677;
        D.39679 = (int) D.39678;
        D.39680 = __s2 + 1;
        D.39681 = *D.39680;
        D.39682 = (int) D.39681;
        __result = D.39679 - D.39682;
        D.39683 = __s2_len > 1;
        D.39673 = __result == 0;
        D.39684 = D.39683 & D.39673;
        if (D.39684 != 0) goto <D.39685>; else goto <D.39686>;
        <D.39685>:
        D.39687 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.39688 = *D.39687;
        D.39689 = (int) D.39688;
        D.39690 = __s2 + 2;
        D.39691 = *D.39690;
        D.39692 = (int) D.39691;
        __result = D.39689 - D.39692;
        D.39693 = __s2_len > 2;
        D.39673 = __result == 0;
        D.39694 = D.39693 & D.39673;
        if (D.39694 != 0) goto <D.39695>; else goto <D.39696>;
        <D.39695>:
        D.39697 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.39698 = *D.39697;
        D.39699 = (int) D.39698;
        D.39700 = __s2 + 3;
        D.39701 = *D.39700;
        D.39702 = (int) D.39701;
        __result = D.39699 - D.39702;
        <D.39696>:
        <D.39686>:
        <D.39676>:
      }
      D.23619 = __result;
    }
    iftmp.819 = -D.23619;
    goto <D.39703>;
    <D.39666>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.819 = __builtin_strcmp (D.38951, "FieldOnTypeBuilderInst");
    <D.39703>:
    D.23620 = iftmp.819;
  }
  if (D.23620 == 0) goto <D.39704>; else goto <D.39705>;
  <D.39704>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;
    struct MonoClass * inflated;
    struct MonoType * type;
    struct MonoClassField * field;

    f = obj;
    D.39706 = f->fb;
    D.39707 = D.39706->vtable;
    D.39708 = D.39707->klass;
    D.39709 = is_sre_field_builder (D.39708);
    if (D.39709 != 0) goto <D.39710>; else goto <D.39711>;
    <D.39710>:
    D.39706 = f->fb;
    field = MEM[(struct MonoReflectionFieldBuilder *)D.39706].handle;
    goto <D.39712>;
    <D.39711>:
    D.39706 = f->fb;
    D.39707 = D.39706->vtable;
    D.39708 = D.39707->klass;
    D.39713 = is_sr_mono_field (D.39708);
    if (D.39713 != 0) goto <D.39714>; else goto <D.39715>;
    <D.39714>:
    D.39706 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.39706].field;
    goto <D.39716>;
    <D.39715>:
    D.39706 = f->fb;
    D.39707 = D.39706->vtable;
    D.39708 = D.39707->klass;
    D.39717 = mono_type_get_full_name (D.39708);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a FTBI with base_method of type %s", D.39717);
    <D.23625>:
    goto <D.23625>;
    <D.39716>:
    <D.39712>:
    D.39718 = f->inst;
    D.39719 = mono_reflection_type_get_handle (D.39718);
    type = mono_class_inflate_generic_type (D.39719, context);
    inflated = mono_class_from_mono_type (type);
    D.39720 = mono_field_get_name (field);
    field = mono_class_get_field_from_name (inflated, D.39720);
    result = field;
    D.39721 = field->parent;
    ensure_complete_type (D.39721);
    D.38955 = result == 0B;
    D.38956 = (long int) D.38955;
    D.38957 = __builtin_expect (D.38956, 0);
    if (D.38957 != 0) goto <D.39722>; else goto <D.39723>;
    <D.39722>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11938, "result");
    <D.39723>:
    mono_metadata_free_type (type);
    D.39341 = mono_defaults.fieldhandle_class;
    *handle_class = D.39341;
  }
  goto <D.39724>;
  <D.39705>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39728 = "ConstructorOnTypeBuilderInst";
      D.39729 = MEM[(const unsigned char *)D.39728];
      D.39730 = (int) D.39729;
      D.39731 = *__s2;
      D.39732 = (int) D.39731;
      __result = D.39730 - D.39732;
      {
        D.39733 = __s2_len != 0;
        D.39734 = __result == 0;
        D.39735 = D.39733 & D.39734;
        if (D.39735 != 0) goto <D.39736>; else goto <D.39737>;
        <D.39736>:
        D.39738 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.39739 = *D.39738;
        D.39740 = (int) D.39739;
        D.39741 = __s2 + 1;
        D.39742 = *D.39741;
        D.39743 = (int) D.39742;
        __result = D.39740 - D.39743;
        D.39744 = __s2_len > 1;
        D.39734 = __result == 0;
        D.39745 = D.39744 & D.39734;
        if (D.39745 != 0) goto <D.39746>; else goto <D.39747>;
        <D.39746>:
        D.39748 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.39749 = *D.39748;
        D.39750 = (int) D.39749;
        D.39751 = __s2 + 2;
        D.39752 = *D.39751;
        D.39753 = (int) D.39752;
        __result = D.39750 - D.39753;
        D.39754 = __s2_len > 2;
        D.39734 = __result == 0;
        D.39755 = D.39754 & D.39734;
        if (D.39755 != 0) goto <D.39756>; else goto <D.39757>;
        <D.39756>:
        D.39758 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.39759 = *D.39758;
        D.39760 = (int) D.39759;
        D.39761 = __s2 + 3;
        D.39762 = *D.39761;
        D.39763 = (int) D.39762;
        __result = D.39760 - D.39763;
        <D.39757>:
        <D.39747>:
        <D.39737>:
      }
      D.23633 = __result;
    }
    iftmp.820 = -D.23633;
    goto <D.39764>;
    <D.39727>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.820 = __builtin_strcmp (D.38951, "ConstructorOnTypeBuilderInst");
    <D.39764>:
    D.23634 = iftmp.820;
  }
  if (D.23634 == 0) goto <D.39765>; else goto <D.39766>;
  <D.39765>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;
    struct MonoType * type;
    struct MonoClass * inflated_klass;
    struct MonoMethod * method;

    c = obj;
    D.39767 = c->inst;
    D.39768 = mono_reflection_type_get_handle (D.39767);
    type = mono_class_inflate_generic_type (D.39768, context);
    inflated_klass = mono_class_from_mono_type (type);
    D.39769 = c->cb;
    D.39770 = D.39769->vtable;
    D.39771 = D.39770->klass;
    D.39772 = is_sre_ctor_builder (D.39771);
    if (D.39772 != 0) goto <D.39773>; else goto <D.39774>;
    <D.39773>:
    D.39769 = c->cb;
    method = MEM[(struct MonoReflectionCtorBuilder *)D.39769].mhandle;
    goto <D.39775>;
    <D.39774>:
    D.39769 = c->cb;
    D.39770 = D.39769->vtable;
    D.39771 = D.39770->klass;
    D.39776 = is_sr_mono_cmethod (D.39771);
    if (D.39776 != 0) goto <D.39777>; else goto <D.39778>;
    <D.39777>:
    D.39769 = c->cb;
    method = MEM[(struct MonoReflectionMethod *)D.39769].method;
    goto <D.39779>;
    <D.39778>:
    D.39769 = c->cb;
    D.39770 = D.39769->vtable;
    D.39771 = D.39770->klass;
    D.39780 = mono_type_get_full_name (D.39771);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a CTBI with base_method of type %s", D.39780);
    <D.23639>:
    goto <D.23639>;
    <D.39779>:
    <D.39775>:
    D.39769 = c->cb;
    result = inflate_mono_method (inflated_klass, method, D.39769);
    D.39182 = mono_defaults.methodhandle_class;
    *handle_class = D.39182;
    mono_metadata_free_type (type);
  }
  goto <D.39781>;
  <D.39766>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39785 = "MethodOnTypeBuilderInst";
      D.39786 = MEM[(const unsigned char *)D.39785];
      D.39787 = (int) D.39786;
      D.39788 = *__s2;
      D.39789 = (int) D.39788;
      __result = D.39787 - D.39789;
      {
        D.39790 = __s2_len != 0;
        D.39791 = __result == 0;
        D.39792 = D.39790 & D.39791;
        if (D.39792 != 0) goto <D.39793>; else goto <D.39794>;
        <D.39793>:
        D.39795 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.39796 = *D.39795;
        D.39797 = (int) D.39796;
        D.39798 = __s2 + 1;
        D.39799 = *D.39798;
        D.39800 = (int) D.39799;
        __result = D.39797 - D.39800;
        D.39801 = __s2_len > 1;
        D.39791 = __result == 0;
        D.39802 = D.39801 & D.39791;
        if (D.39802 != 0) goto <D.39803>; else goto <D.39804>;
        <D.39803>:
        D.39805 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.39806 = *D.39805;
        D.39807 = (int) D.39806;
        D.39808 = __s2 + 2;
        D.39809 = *D.39808;
        D.39810 = (int) D.39809;
        __result = D.39807 - D.39810;
        D.39811 = __s2_len > 2;
        D.39791 = __result == 0;
        D.39812 = D.39811 & D.39791;
        if (D.39812 != 0) goto <D.39813>; else goto <D.39814>;
        <D.39813>:
        D.39815 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.39816 = *D.39815;
        D.39817 = (int) D.39816;
        D.39818 = __s2 + 3;
        D.39819 = *D.39818;
        D.39820 = (int) D.39819;
        __result = D.39817 - D.39820;
        <D.39814>:
        <D.39804>:
        <D.39794>:
      }
      D.23647 = __result;
    }
    iftmp.821 = -D.23647;
    goto <D.39821>;
    <D.39784>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.821 = __builtin_strcmp (D.38951, "MethodOnTypeBuilderInst");
    <D.39821>:
    D.23648 = iftmp.821;
  }
  if (D.23648 == 0) goto <D.39822>; else goto <D.39823>;
  <D.39822>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    D.39824 = m->method_args;
    if (D.39824 != 0B) goto <D.39825>; else goto <D.39826>;
    <D.39825>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    if (context != 0B) goto <D.39827>; else goto <D.39828>;
    <D.39827>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39828>:
    goto <D.39829>;
    <D.39826>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * method;

      D.39830 = m->inst;
      D.39831 = mono_reflection_type_get_handle (D.39830);
      type = mono_class_inflate_generic_type (D.39831, context);
      inflated_klass = mono_class_from_mono_type (type);
      D.39832 = m->mb;
      D.39833 = D.39832->vtable;
      D.39834 = D.39833->klass;
      D.39835 = is_sre_method_builder (D.39834);
      if (D.39835 != 0) goto <D.39836>; else goto <D.39837>;
      <D.39836>:
      D.39832 = m->mb;
      method = MEM[(struct MonoReflectionMethodBuilder *)D.39832].mhandle;
      goto <D.39838>;
      <D.39837>:
      D.39832 = m->mb;
      D.39833 = D.39832->vtable;
      D.39834 = D.39833->klass;
      D.39839 = is_sr_mono_method (D.39834);
      if (D.39839 != 0) goto <D.39840>; else goto <D.39841>;
      <D.39840>:
      D.39832 = m->mb;
      method = MEM[(struct MonoReflectionMethod *)D.39832].method;
      goto <D.39842>;
      <D.39841>:
      D.39832 = m->mb;
      D.39833 = D.39832->vtable;
      D.39834 = D.39833->klass;
      D.39843 = mono_type_get_full_name (D.39834);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.39843);
      <D.23653>:
      goto <D.23653>;
      <D.39842>:
      <D.39838>:
      D.39832 = m->mb;
      result = inflate_mono_method (inflated_klass, method, D.39832);
      mono_metadata_free_type (type);
    }
    <D.39829>:
    D.39182 = mono_defaults.methodhandle_class;
    *handle_class = D.39182;
  }
  goto <D.39844>;
  <D.39823>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38912 = obj->vtable;
      D.38913 = D.38912->klass;
      __s2 = D.38913->name;
      D.39848 = "MonoArrayMethod";
      D.39849 = MEM[(const unsigned char *)D.39848];
      D.39850 = (int) D.39849;
      D.39851 = *__s2;
      D.39852 = (int) D.39851;
      __result = D.39850 - D.39852;
      {
        D.39853 = __s2_len != 0;
        D.39854 = __result == 0;
        D.39855 = D.39853 & D.39854;
        if (D.39855 != 0) goto <D.39856>; else goto <D.39857>;
        <D.39856>:
        D.39858 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.39859 = *D.39858;
        D.39860 = (int) D.39859;
        D.39861 = __s2 + 1;
        D.39862 = *D.39861;
        D.39863 = (int) D.39862;
        __result = D.39860 - D.39863;
        D.39864 = __s2_len > 1;
        D.39854 = __result == 0;
        D.39865 = D.39864 & D.39854;
        if (D.39865 != 0) goto <D.39866>; else goto <D.39867>;
        <D.39866>:
        D.39868 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.39869 = *D.39868;
        D.39870 = (int) D.39869;
        D.39871 = __s2 + 2;
        D.39872 = *D.39871;
        D.39873 = (int) D.39872;
        __result = D.39870 - D.39873;
        D.39874 = __s2_len > 2;
        D.39854 = __result == 0;
        D.39875 = D.39874 & D.39854;
        if (D.39875 != 0) goto <D.39876>; else goto <D.39877>;
        <D.39876>:
        D.39878 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.39879 = *D.39878;
        D.39880 = (int) D.39879;
        D.39881 = __s2 + 3;
        D.39882 = *D.39881;
        D.39883 = (int) D.39882;
        __result = D.39880 - D.39883;
        <D.39877>:
        <D.39867>:
        <D.39857>:
      }
      D.23661 = __result;
    }
    iftmp.822 = -D.23661;
    goto <D.39884>;
    <D.39847>:
    D.38912 = obj->vtable;
    D.38913 = D.38912->klass;
    D.38951 = D.38913->name;
    iftmp.822 = __builtin_strcmp (D.38951, "MonoArrayMethod");
    <D.39884>:
    D.23662 = iftmp.822;
  }
  if (D.23662 == 0) goto <D.39885>; else goto <D.39886>;
  <D.39885>:
  {
    struct MonoReflectionArrayMethod * m;
    struct MonoType * mtype;
    struct MonoClass * klass;
    struct MonoMethod * method;
    void * iter;
    char * name;

    try
      {
        m = obj;
        D.39887 = m->parent;
        mtype = mono_reflection_type_get_handle (D.39887);
        klass = mono_class_from_mono_type (mtype);
        D.39888 = m->name;
        name = mono_string_to_utf8 (D.39888);
        iter = 0B;
        goto <D.23680>;
        <D.23679>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.39889 = method->name;
          D.23677 = __builtin_strcmp (D.39889, name);
        }
        if (D.23677 == 0) goto <D.23678>; else goto <D.39890>;
        <D.39890>:
        <D.23680>:
        method = mono_class_get_methods (klass, &iter);
        if (method != 0B) goto <D.23679>; else goto <D.23678>;
        <D.23678>:
        monoeg_g_free (name);
        D.39891 = method == 0B;
        D.39892 = (long int) D.39891;
        D.39893 = __builtin_expect (D.39892, 0);
        if (D.39893 != 0) goto <D.39894>; else goto <D.39895>;
        <D.39894>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12001, "method");
        <D.39895>:
        result = method;
        D.39182 = mono_defaults.methodhandle_class;
        *handle_class = D.39182;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  goto <D.39896>;
  <D.39886>:
  D.39900 = mono_object_get_class (obj);
  D.39901 = is_sre_array (D.39900);
  if (D.39901 != 0) goto <D.39897>; else goto <D.39902>;
  <D.39902>:
  D.39903 = mono_object_get_class (obj);
  D.39904 = is_sre_byref (D.39903);
  if (D.39904 != 0) goto <D.39897>; else goto <D.39905>;
  <D.39905>:
  D.39906 = mono_object_get_class (obj);
  D.39907 = is_sre_pointer (D.39906);
  if (D.39907 != 0) goto <D.39897>; else goto <D.39898>;
  <D.39897>:
  {
    struct MonoReflectionType * ref_type;
    struct MonoType * type;

    ref_type = obj;
    type = mono_reflection_type_get_handle (ref_type);
    if (context != 0B) goto <D.39908>; else goto <D.39909>;
    <D.39908>:
    {
      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.39910>;
    <D.39909>:
    result = mono_class_from_mono_type (type);
    <D.39910>:
    D.39010 = mono_defaults.typehandle_class;
    *handle_class = D.39010;
  }
  goto <D.39899>;
  <D.39898>:
  D.38912 = obj->vtable;
  D.38913 = D.38912->klass;
  D.38951 = D.38913->name;
  monoeg_g_print ("%s\n", D.38951);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12022);
  <D.39899>:
  <D.39896>:
  <D.39844>:
  <D.39781>:
  <D.39724>:
  <D.39663>:
  <D.39618>:
  <D.39573>:
  <D.39524>:
  <D.39452>:
  <D.39401>:
  <D.39344>:
  <D.39280>:
  <D.39232>:
  <D.39016>:
  <D.39013>:
  <D.38960>:
  D.39911 = result;
  return D.39911;
}


ensure_complete_type (struct MonoClass * klass)
{
  struct MonoImage * D.39913;
  unsigned char D.39914;
  unsigned char D.39915;
  unsigned char D.39918;
  unsigned char D.39919;
  void * D.39922;
  struct MonoDomain * D.39925;
  struct MonoGenericClass * D.39926;
  struct MonoType * D.39929;
  struct MonoClass * D.39930;
  <unnamed-unsigned:22> D.39931;
  int D.39932;

  D.39913 = klass->image;
  D.39914 = BIT_FIELD_REF <*D.39913, 8, 128>;
  D.39915 = D.39914 & 8;
  if (D.39915 != 0) goto <D.39916>; else goto <D.39917>;
  <D.39916>:
  D.39918 = BIT_FIELD_REF <*klass, 8, 160>;
  D.39919 = D.39918 & 128;
  if (D.39919 == 0) goto <D.39920>; else goto <D.39921>;
  <D.39920>:
  D.39922 = mono_class_get_ref_info (klass);
  if (D.39922 != 0B) goto <D.39923>; else goto <D.39924>;
  <D.39923>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.39925 = mono_domain_get ();
    mono_domain_try_type_resolve (D.39925, 0B, tb);
  }
  <D.39924>:
  <D.39921>:
  <D.39917>:
  D.39926 = klass->generic_class;
  if (D.39926 != 0B) goto <D.39927>; else goto <D.39928>;
  <D.39927>:
  {
    struct MonoGenericInst * inst;
    int i;

    D.39926 = klass->generic_class;
    inst = D.39926->context.class_inst;
    i = 0;
    goto <D.23417>;
    <D.23416>:
    D.39929 = inst->type_argv[i];
    D.39930 = mono_class_from_mono_type (D.39929);
    ensure_complete_type (D.39930);
    i = i + 1;
    <D.23417>:
    D.39931 = inst->type_argc;
    D.39932 = (int) D.39931;
    if (D.39932 > i) goto <D.23416>; else goto <D.23418>;
    <D.23418>:
  }
  <D.39928>:
}


mono_reflection_is_valid_dynamic_token (struct MonoDynamicImage * image, guint32 token)
{
  gboolean D.39933;
  const void * token.823;
  struct MonoGHashTable * D.39935;
  void * D.39936;
  _Bool D.39937;

  token.823 = (const void *) token;
  D.39935 = image->tokens;
  D.39936 = mono_g_hash_table_lookup (D.39935, token.823);
  D.39937 = D.39936 != 0B;
  D.39933 = (gboolean) D.39937;
  return D.39933;
}


mono_reflection_lookup_signature (struct MonoImage * image, struct MonoMethod * method, guint32 token)
{
  unsigned char D.39939;
  unsigned char D.39940;
  _Bool D.39941;
  long int D.39942;
  long int D.39943;
  const void * token.824;
  struct GHashTable * D.39947;
  struct MonoMethodSignature * D.39950;
  struct MonoMethodSignature * sig;

  D.39939 = BIT_FIELD_REF <*image, 8, 128>;
  D.39940 = D.39939 & 8;
  D.39941 = D.39940 == 0;
  D.39942 = (long int) D.39941;
  D.39943 = __builtin_expect (D.39942, 0);
  if (D.39943 != 0) goto <D.39944>; else goto <D.39945>;
  <D.39944>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11672, "image->dynamic");
  <D.39945>:
  token.824 = (const void *) token;
  D.39947 = MEM[(struct MonoDynamicImage *)image].vararg_aux_hash;
  sig = monoeg_g_hash_table_lookup (D.39947, token.824);
  if (sig != 0B) goto <D.39948>; else goto <D.39949>;
  <D.39948>:
  D.39950 = sig;
  return D.39950;
  <D.39949>:
  D.39950 = mono_method_signature (method);
  return D.39950;
}


mono_reflection_lookup_dynamic_token (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  const void * token.825;
  struct MonoGHashTable * D.39953;
  void * D.39958;
  struct MonoDynamicImage * assembly;
  struct MonoObject * obj;
  struct MonoClass * klass;

  try
    {
      assembly = image;
      mono_loader_lock ();
      token.825 = (const void *) token;
      D.39953 = assembly->tokens;
      obj = mono_g_hash_table_lookup (D.39953, token.825);
      mono_loader_unlock ();
      if (obj == 0B) goto <D.39954>; else goto <D.39955>;
      <D.39954>:
      if (valid_token != 0) goto <D.39956>; else goto <D.39957>;
      <D.39956>:
      monoeg_g_log (0B, 4, "Could not find required dynamic token 0x%08x", token);
      <D.23409>:
      goto <D.23409>;
      <D.39957>:
      D.39958 = 0B;
      return D.39958;
      <D.39955>:
      if (handle_class == 0B) goto <D.39959>; else goto <D.39960>;
      <D.39959>:
      handle_class = &klass;
      <D.39960>:
      D.39958 = resolve_object (image, obj, handle_class, context);
      return D.39958;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


mono_declsec_flags_from_method (struct MonoMethod * method)
{
  short unsigned int D.39963;
  int D.39964;
  int D.39965;
  uint32_t D.39968;
  struct MonoClass * D.39969;
  struct MonoImage * D.39970;

  D.39963 = method->flags;
  D.39964 = (int) D.39963;
  D.39965 = D.39964 & 16384;
  if (D.39965 != 0) goto <D.39966>; else goto <D.39967>;
  <D.39966>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.39969 = method->klass;
    D.39970 = D.39969->image;
    D.39968 = mono_declsec_get_flags (D.39970, idx);
    return D.39968;
  }
  <D.39967>:
  D.39968 = 0;
  return D.39968;
}


mono_declsec_get_flags (struct MonoImage * image, guint32 token)
{
  unsigned int D.39972;
  guint32 D.39975;
  unsigned int D.39976;
  unsigned int D.39978;
  unsigned int D.39981;
  <unnamed-unsigned:24> D.39983;
  int D.39984;
  int index;
  struct MonoTableInfo * t;
  guint32 result;
  guint32 action;
  int i;

  D.39972 = mono_metadata_declsec_from_index (image, token);
  index = (int) D.39972;
  t = &image->tables[14];
  result = 0;
  if (index < 0) goto <D.39973>; else goto <D.39974>;
  <D.39973>:
  D.39975 = 0;
  return D.39975;
  <D.39974>:
  i = index;
  goto <D.23697>;
  <D.23696>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.39976 = cols[1];
        if (D.39976 != token) goto <D.23695>; else goto <D.39977>;
        <D.39977>:
        action = cols[0];
        D.39978 = action + 4294967295;
        if (D.39978 <= 17) goto <D.39979>; else goto <D.39980>;
        <D.39979>:
        D.39981 = declsec_flags_map[action];
        result = D.39981 | result;
        goto <D.39982>;
        <D.39980>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12239);
        <D.39982>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.23697>:
  D.39983 = t->rows;
  D.39984 = (int) D.39983;
  if (D.39984 > i) goto <D.23696>; else goto <D.23695>;
  <D.23695>:
  D.39975 = result;
  return D.39975;
}


mono_declsec_flags_from_class (struct MonoClass * klass)
{
  unsigned int D.39988;
  unsigned int D.39989;
  struct MonoClassExt * D.39994;
  unsigned int D.39996;
  unsigned int D.39997;
  struct MonoImage * D.39998;
  unsigned int D.39999;
  uint32_t D.40000;

  D.39988 = klass->flags;
  D.39989 = D.39988 & 262144;
  if (D.39989 != 0) goto <D.39990>; else goto <D.39991>;
  <D.39990>:
  D.39994 = klass->ext;
  if (D.39994 == 0B) goto <D.39992>; else goto <D.39995>;
  <D.39995>:
  D.39994 = klass->ext;
  D.39996 = D.39994->declsec_flags;
  if (D.39996 == 0) goto <D.39992>; else goto <D.39993>;
  <D.39992>:
  {
    guint32 idx;

    D.39997 = klass->type_token;
    idx = D.39997 & 16777215;
    idx = idx << 2;
    idx = idx;
    mono_loader_lock ();
    mono_class_alloc_ext (klass);
    mono_loader_unlock ();
    D.39994 = klass->ext;
    D.39998 = klass->image;
    D.39999 = mono_declsec_get_flags (D.39998, idx);
    D.39994->declsec_flags = D.39999;
  }
  <D.39993>:
  D.39994 = klass->ext;
  D.40000 = D.39994->declsec_flags;
  return D.40000;
  <D.39991>:
  D.40000 = 0;
  return D.40000;
}


mono_declsec_flags_from_assembly (struct MonoAssembly * assembly)
{
  uint32_t D.40002;
  struct MonoImage * D.40003;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.40003 = assembly->image;
  D.40002 = mono_declsec_get_flags (D.40003, idx);
  return D.40002;
}


mono_declsec_get_demands (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.40005;
  struct MonoImage * D.40006;
  unsigned int D.40007;
  unsigned int D.40008;
  MonoBoolean D.40011;
  unsigned char D.40012;
  unsigned char D.40013;
  _Bool D.40014;
  _Bool D.40015;
  _Bool D.40016;
  short unsigned int D.40021;
  int D.40022;
  int D.40023;
  unsigned int D.40026;
  unsigned char D.40031;
  guint32 mask;
  MonoBoolean result;
  guint32 flags;

  mask = 135170;
  result = 0;
  D.40005 = method->klass;
  D.40006 = D.40005->image;
  D.40007 = BIT_FIELD_REF <*D.40006, 32, 2176>;
  D.40008 = D.40007 & 16777215;
  if (D.40008 == 0) goto <D.40009>; else goto <D.40010>;
  <D.40009>:
  D.40011 = 0;
  return D.40011;
  <D.40010>:
  D.40012 = BIT_FIELD_REF <*method, 8, 160>;
  D.40013 = D.40012 & 124;
  D.40014 = D.40013 == 24;
  D.40015 = D.40013 == 28;
  D.40016 = D.40014 | D.40015;
  if (D.40016 != 0) goto <D.40017>; else goto <D.40018>;
  <D.40017>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40019>; else goto <D.40020>;
  <D.40019>:
  D.40011 = 0;
  return D.40011;
  <D.40020>:
  <D.40018>:
  D.40021 = method->flags;
  D.40022 = (int) D.40021;
  D.40023 = D.40022 & 16384;
  if (D.40023 != 0) goto <D.40024>; else goto <D.40025>;
  <D.40024>:
  D.40005 = method->klass;
  mono_class_init (D.40005);
  memset (demands, 0, 36);
  result = mono_declsec_get_method_demands_params (method, demands, 2, 13, 18);
  <D.40025>:
  D.40005 = method->klass;
  flags = mono_declsec_flags_from_class (D.40005);
  D.40026 = flags & mask;
  if (D.40026 != 0) goto <D.40027>; else goto <D.40028>;
  <D.40027>:
  if (result == 0) goto <D.40029>; else goto <D.40030>;
  <D.40029>:
  D.40005 = method->klass;
  mono_class_init (D.40005);
  memset (demands, 0, 36);
  <D.40030>:
  D.40005 = method->klass;
  D.40031 = mono_declsec_get_class_demands_params (D.40005, demands, 2, 13, 18);
  result = D.40031 | result;
  <D.40028>:
  D.40011 = result;
  return D.40011;
}


mono_declsec_get_method_demands_params (struct MonoMethod * method, struct MonoDeclSecurityActions * demands, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  MonoBoolean D.40033;
  struct MonoClass * D.40034;
  struct MonoImage * D.40035;
  guint32 idx;

  idx = mono_method_get_index (method);
  idx = idx << 2;
  idx = idx | 1;
  D.40034 = method->klass;
  D.40035 = D.40034->image;
  D.40033 = fill_actions_from_index (D.40035, idx, demands, id_std, id_noncas, id_choice);
  return D.40033;
}


fill_actions_from_index (struct MonoImage * image, guint32 token, struct MonoDeclSecurityActions * actions, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  unsigned int D.40037;
  unsigned int D.40038;
  MonoBoolean D.40041;
  unsigned int D.40042;
  char * D.40045;
  unsigned int D.40048;
  const char * blob.826;
  const char * blob.827;
  char * D.40051;
  unsigned int D.40052;
  char * D.40056;
  const char * blob.828;
  const char * blob.829;
  char * D.40061;
  unsigned int D.40062;
  char * D.40066;
  const char * blob.830;
  const char * blob.831;
  char * D.40071;
  unsigned int D.40072;
  <unnamed-unsigned:24> D.40073;
  int D.40074;
  MonoBoolean result;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int index;
  int i;

  try
    {
      result = 0;
      D.40037 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.40037;
      t = &image->tables[14];
      i = index;
      goto <D.23727>;
      <D.23726>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.40038 = cols[1];
      if (D.40038 != token) goto <D.40039>; else goto <D.40040>;
      <D.40039>:
      D.40041 = result;
      return D.40041;
      <D.40040>:
      D.40042 = cols[0];
      if (D.40042 == id_std) goto <D.40043>; else goto <D.40044>;
      <D.40043>:
      D.40045 = actions->demand.blob;
      if (D.40045 == 0B) goto <D.40046>; else goto <D.40047>;
      <D.40046>:
      {
        const char * blob;

        try
          {
            D.40048 = cols[2];
            blob.826 = mono_metadata_blob_heap (image, D.40048);
            blob = blob.826;
            D.40048 = cols[2];
            actions->demand.index = D.40048;
            blob.827 = blob;
            D.40051 = blob.827 + 2;
            actions->demand.blob = D.40051;
            blob.827 = blob;
            D.40052 = mono_metadata_decode_blob_size (blob.827, &blob);
            actions->demand.size = D.40052;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40047>:
      goto <D.40053>;
      <D.40044>:
      D.40042 = cols[0];
      if (D.40042 == id_noncas) goto <D.40054>; else goto <D.40055>;
      <D.40054>:
      D.40056 = actions->noncasdemand.blob;
      if (D.40056 == 0B) goto <D.40057>; else goto <D.40058>;
      <D.40057>:
      {
        const char * blob;

        try
          {
            D.40048 = cols[2];
            blob.828 = mono_metadata_blob_heap (image, D.40048);
            blob = blob.828;
            D.40048 = cols[2];
            actions->noncasdemand.index = D.40048;
            blob.829 = blob;
            D.40061 = blob.829 + 2;
            actions->noncasdemand.blob = D.40061;
            blob.829 = blob;
            D.40062 = mono_metadata_decode_blob_size (blob.829, &blob);
            actions->noncasdemand.size = D.40062;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40058>:
      goto <D.40063>;
      <D.40055>:
      D.40042 = cols[0];
      if (D.40042 == id_choice) goto <D.40064>; else goto <D.40065>;
      <D.40064>:
      D.40066 = actions->demandchoice.blob;
      if (D.40066 == 0B) goto <D.40067>; else goto <D.40068>;
      <D.40067>:
      {
        const char * blob;

        try
          {
            D.40048 = cols[2];
            blob.830 = mono_metadata_blob_heap (image, D.40048);
            blob = blob.830;
            D.40048 = cols[2];
            actions->demandchoice.index = D.40048;
            blob.831 = blob;
            D.40071 = blob.831 + 2;
            actions->demandchoice.blob = D.40071;
            blob.831 = blob;
            D.40072 = mono_metadata_decode_blob_size (blob.831, &blob);
            actions->demandchoice.size = D.40072;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40068>:
      <D.40065>:
      <D.40063>:
      <D.40053>:
      i = i + 1;
      <D.23727>:
      D.40073 = t->rows;
      D.40074 = (int) D.40073;
      if (D.40074 > i) goto <D.23726>; else goto <D.23728>;
      <D.23728>:
      D.40041 = result;
      return D.40041;
    }
  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.40077;
  MonoBoolean D.40078;
  struct MonoImage * D.40079;
  guint32 idx;

  D.40077 = klass->type_token;
  idx = D.40077 & 16777215;
  idx = idx << 2;
  idx = idx;
  D.40079 = klass->image;
  D.40078 = fill_actions_from_index (D.40079, idx, demands, id_std, id_noncas, id_choice);
  return D.40078;
}


mono_declsec_get_linkdemands (struct MonoMethod * method, struct MonoDeclSecurityActions * klass, struct MonoDeclSecurityActions * cmethod)
{
  struct MonoClass * D.40081;
  struct MonoImage * D.40082;
  unsigned int D.40083;
  unsigned int D.40084;
  MonoBoolean D.40087;
  unsigned char D.40088;
  unsigned char D.40089;
  _Bool D.40090;
  _Bool D.40091;
  _Bool D.40092;
  short unsigned int D.40097;
  int D.40098;
  int D.40099;
  unsigned int D.40102;
  unsigned char D.40105;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.40081 = method->klass;
  D.40082 = D.40081->image;
  D.40083 = BIT_FIELD_REF <*D.40082, 32, 2176>;
  D.40084 = D.40083 & 16777215;
  if (D.40084 == 0) goto <D.40085>; else goto <D.40086>;
  <D.40085>:
  D.40087 = 0;
  return D.40087;
  <D.40086>:
  D.40088 = BIT_FIELD_REF <*method, 8, 160>;
  D.40089 = D.40088 & 124;
  D.40090 = D.40089 == 24;
  D.40091 = D.40089 == 28;
  D.40092 = D.40090 | D.40091;
  if (D.40092 != 0) goto <D.40093>; else goto <D.40094>;
  <D.40093>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40095>; else goto <D.40096>;
  <D.40095>:
  D.40087 = 0;
  return D.40087;
  <D.40096>:
  <D.40094>:
  memset (cmethod, 0, 36);
  memset (klass, 0, 36);
  D.40097 = method->flags;
  D.40098 = (int) D.40097;
  D.40099 = D.40098 & 16384;
  if (D.40099 != 0) goto <D.40100>; else goto <D.40101>;
  <D.40100>:
  D.40081 = method->klass;
  mono_class_init (D.40081);
  result = mono_declsec_get_method_demands_params (method, cmethod, 6, 14, 16);
  <D.40101>:
  D.40081 = method->klass;
  flags = mono_declsec_flags_from_class (D.40081);
  D.40102 = flags & 40992;
  if (D.40102 != 0) goto <D.40103>; else goto <D.40104>;
  <D.40103>:
  D.40081 = method->klass;
  mono_class_init (D.40081);
  D.40081 = method->klass;
  D.40105 = mono_declsec_get_class_demands_params (D.40081, klass, 6, 14, 16);
  result = D.40105 | result;
  <D.40104>:
  D.40087 = result;
  return D.40087;
}


mono_declsec_get_inheritdemands_class (struct MonoClass * klass, struct MonoDeclSecurityActions * demands)
{
  struct MonoImage * D.40107;
  unsigned int D.40108;
  unsigned int D.40109;
  MonoBoolean D.40112;
  unsigned int D.40113;
  unsigned char D.40116;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.40107 = klass->image;
  D.40108 = BIT_FIELD_REF <*D.40107, 32, 2176>;
  D.40109 = D.40108 & 16777215;
  if (D.40109 == 0) goto <D.40110>; else goto <D.40111>;
  <D.40110>:
  D.40112 = 0;
  return D.40112;
  <D.40111>:
  flags = mono_declsec_flags_from_class (klass);
  D.40113 = flags & 81984;
  if (D.40113 != 0) goto <D.40114>; else goto <D.40115>;
  <D.40114>:
  mono_class_init (klass);
  memset (demands, 0, 36);
  D.40116 = mono_declsec_get_class_demands_params (klass, demands, 7, 15, 17);
  result = D.40116 | result;
  <D.40115>:
  D.40112 = result;
  return D.40112;
}


mono_declsec_get_inheritdemands_method (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.40118;
  struct MonoImage * D.40119;
  unsigned int D.40120;
  unsigned int D.40121;
  MonoBoolean D.40124;
  unsigned char D.40125;
  unsigned char D.40126;
  _Bool D.40127;
  _Bool D.40128;
  _Bool D.40129;
  short unsigned int D.40134;
  int D.40135;
  int D.40136;

  D.40118 = method->klass;
  D.40119 = D.40118->image;
  D.40120 = BIT_FIELD_REF <*D.40119, 32, 2176>;
  D.40121 = D.40120 & 16777215;
  if (D.40121 == 0) goto <D.40122>; else goto <D.40123>;
  <D.40122>:
  D.40124 = 0;
  return D.40124;
  <D.40123>:
  D.40125 = BIT_FIELD_REF <*method, 8, 160>;
  D.40126 = D.40125 & 124;
  D.40127 = D.40126 == 24;
  D.40128 = D.40126 == 28;
  D.40129 = D.40127 | D.40128;
  if (D.40129 != 0) goto <D.40130>; else goto <D.40131>;
  <D.40130>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40132>; else goto <D.40133>;
  <D.40132>:
  D.40124 = 0;
  return D.40124;
  <D.40133>:
  <D.40131>:
  D.40134 = method->flags;
  D.40135 = (int) D.40134;
  D.40136 = D.40135 & 16384;
  if (D.40136 != 0) goto <D.40137>; else goto <D.40138>;
  <D.40137>:
  D.40118 = method->klass;
  mono_class_init (D.40118);
  memset (demands, 0, 36);
  D.40124 = mono_declsec_get_method_demands_params (method, demands, 7, 15, 17);
  return D.40124;
  <D.40138>:
  D.40124 = 0;
  return D.40124;
}


mono_declsec_get_method_action (struct MonoMethod * method, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  short unsigned int D.40140;
  int D.40141;
  int D.40142;
  MonoBoolean D.40145;
  struct MonoClass * D.40146;
  struct MonoImage * D.40147;

  D.40140 = method->flags;
  D.40141 = (int) D.40140;
  D.40142 = D.40141 & 16384;
  if (D.40142 != 0) goto <D.40143>; else goto <D.40144>;
  <D.40143>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.40146 = method->klass;
    D.40147 = D.40146->image;
    D.40145 = get_declsec_action (D.40147, idx, action, entry);
    return D.40145;
  }
  <D.40144>:
  D.40145 = 0;
  return D.40145;
}


get_declsec_action (struct MonoImage * image, guint32 token, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.40149;
  MonoBoolean D.40152;
  unsigned int D.40153;
  unsigned int D.40156;
  unsigned int D.40159;
  const char * metadata.832;
  const char * metadata.833;
  char * D.40162;
  unsigned int D.40163;
  <unnamed-unsigned:24> D.40164;
  int D.40165;
  guint32 cols[3];
  struct MonoTableInfo * t;
  int i;
  int index;

  try
    {
      D.40149 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.40149;
      if (index == -1) goto <D.40150>; else goto <D.40151>;
      <D.40150>:
      D.40152 = 0;
      return D.40152;
      <D.40151>:
      t = &image->tables[14];
      i = index;
      goto <D.23781>;
      <D.23780>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.40153 = cols[1];
      if (D.40153 != token) goto <D.40154>; else goto <D.40155>;
      <D.40154>:
      D.40152 = 0;
      return D.40152;
      <D.40155>:
      D.40156 = cols[0];
      if (D.40156 == action) goto <D.40157>; else goto <D.40158>;
      <D.40157>:
      {
        const char * metadata;

        try
          {
            D.40159 = cols[2];
            metadata.832 = mono_metadata_blob_heap (image, D.40159);
            metadata = metadata.832;
            metadata.833 = metadata;
            D.40162 = metadata.833 + 2;
            entry->blob = D.40162;
            metadata.833 = metadata;
            D.40163 = mono_metadata_decode_blob_size (metadata.833, &metadata);
            entry->size = D.40163;
            D.40152 = 1;
            return D.40152;
          }
        finally
          {
            metadata = {CLOBBER};
          }
      }
      <D.40158>:
      i = i + 1;
      <D.23781>:
      D.40164 = t->rows;
      D.40165 = (int) D.40164;
      if (D.40165 > i) goto <D.23780>; else goto <D.23782>;
      <D.23782>:
      D.40152 = 0;
      return D.40152;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_declsec_get_class_action (struct MonoClass * klass, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.40169;
  unsigned int D.40170;
  unsigned int D.40173;
  MonoBoolean D.40174;
  struct MonoImage * D.40175;
  guint32 flags;

  flags = mono_declsec_flags_from_class (klass);
  D.40169 = declsec_flags_map[action];
  D.40170 = D.40169 & flags;
  if (D.40170 != 0) goto <D.40171>; else goto <D.40172>;
  <D.40171>:
  {
    guint32 idx;

    D.40173 = klass->type_token;
    idx = D.40173 & 16777215;
    idx = idx << 2;
    idx = idx;
    D.40175 = klass->image;
    D.40174 = get_declsec_action (D.40175, idx, action, entry);
    return D.40174;
  }
  <D.40172>:
  D.40174 = 0;
  return D.40174;
}


mono_declsec_get_assembly_action (struct MonoAssembly * assembly, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  MonoBoolean D.40177;
  struct MonoImage * D.40178;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.40178 = assembly->image;
  D.40177 = get_declsec_action (D.40178, idx, action, entry);
  return D.40177;
}


mono_reflection_call_is_assignable_to (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * System_Reflection_Emit_TypeBuilder.834;
  struct MonoImage * D.40183;
  struct MonoClass * System_Reflection_Emit_TypeBuilder.835;
  _Bool D.40185;
  long int D.40186;
  long int D.40187;
  struct MonoMethod * method.836;
  struct MonoMethod * method.837;
  _Bool D.40194;
  long int D.40195;
  long int D.40196;
  void * D.40199;
  _Bool D.40200;
  long int D.40201;
  long int D.40202;
  int D.23819;
  int iftmp.838;
  int D.23818;
  void * D.40208;
  struct MonoVTable * D.40209;
  struct MonoClass * D.40210;
  const char[12] * D.40211;
  unsigned char D.40212;
  int D.40213;
  unsigned char D.40214;
  int D.40215;
  _Bool D.40216;
  _Bool D.40217;
  _Bool D.40218;
  const unsigned char * D.40221;
  unsigned char D.40222;
  int D.40223;
  const unsigned char * D.40224;
  unsigned char D.40225;
  int D.40226;
  _Bool D.40227;
  _Bool D.40228;
  const unsigned char * D.40231;
  unsigned char D.40232;
  int D.40233;
  const unsigned char * D.40234;
  unsigned char D.40235;
  int D.40236;
  _Bool D.40237;
  _Bool D.40238;
  const unsigned char * D.40241;
  unsigned char D.40242;
  int D.40243;
  const unsigned char * D.40244;
  unsigned char D.40245;
  int D.40246;
  void * D.40248;
  struct MonoVTable * D.40249;
  struct MonoClass * D.40250;
  const char * D.40251;
  _Bool D.40252;
  long int D.40253;
  long int D.40254;
  struct MonoType * D.40257;
  struct MonoDomain * D.40258;
  struct MonoReflectionType * D.40259;
  void * D.40260;
  struct MonoObject * exc.839;
  gboolean D.40264;
  void * D.40265;
  unsigned char D.40266;
  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.40181>; else goto <D.40182>;
      <D.40181>:
      D.40183 = mono_defaults.corlib;
      System_Reflection_Emit_TypeBuilder.835 = mono_class_from_name (D.40183, "System.Reflection.Emit", "TypeBuilder");
      System_Reflection_Emit_TypeBuilder = System_Reflection_Emit_TypeBuilder.835;
      System_Reflection_Emit_TypeBuilder.834 = System_Reflection_Emit_TypeBuilder;
      D.40185 = System_Reflection_Emit_TypeBuilder.834 == 0B;
      D.40186 = (long int) D.40185;
      D.40187 = __builtin_expect (D.40186, 0);
      if (D.40187 != 0) goto <D.40188>; else goto <D.40189>;
      <D.40188>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12621, "System_Reflection_Emit_TypeBuilder");
      <D.40189>:
      <D.40182>:
      method.836 = method;
      if (method.836 == 0B) goto <D.40191>; else goto <D.40192>;
      <D.40191>:
      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.40194 = method.836 == 0B;
      D.40195 = (long int) D.40194;
      D.40196 = __builtin_expect (D.40195, 0);
      if (D.40196 != 0) goto <D.40197>; else goto <D.40198>;
      <D.40197>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12625, "method");
      <D.40198>:
      <D.40192>:
      D.40199 = mono_class_get_ref_info (klass);
      D.40200 = D.40199 == 0B;
      D.40201 = (long int) D.40200;
      D.40202 = __builtin_expect (D.40201, 0);
      if (D.40202 != 0) goto <D.40203>; else goto <D.40204>;
      <D.40203>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12632, "mono_class_get_ref_info (klass)");
      <D.40204>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.40208 = mono_class_get_ref_info (klass);
          D.40209 = MEM[(struct MonoObject *)D.40208].vtable;
          D.40210 = D.40209->klass;
          __s2 = D.40210->name;
          D.40211 = "TypeBuilder";
          D.40212 = MEM[(const unsigned char *)D.40211];
          D.40213 = (int) D.40212;
          D.40214 = *__s2;
          D.40215 = (int) D.40214;
          __result = D.40213 - D.40215;
          {
            D.40216 = __s2_len != 0;
            D.40217 = __result == 0;
            D.40218 = D.40216 & D.40217;
            if (D.40218 != 0) goto <D.40219>; else goto <D.40220>;
            <D.40219>:
            D.40221 = &MEM[(void *)"TypeBuilder" + 1B];
            D.40222 = *D.40221;
            D.40223 = (int) D.40222;
            D.40224 = __s2 + 1;
            D.40225 = *D.40224;
            D.40226 = (int) D.40225;
            __result = D.40223 - D.40226;
            D.40227 = __s2_len > 1;
            D.40217 = __result == 0;
            D.40228 = D.40227 & D.40217;
            if (D.40228 != 0) goto <D.40229>; else goto <D.40230>;
            <D.40229>:
            D.40231 = &MEM[(void *)"TypeBuilder" + 2B];
            D.40232 = *D.40231;
            D.40233 = (int) D.40232;
            D.40234 = __s2 + 2;
            D.40235 = *D.40234;
            D.40236 = (int) D.40235;
            __result = D.40233 - D.40236;
            D.40237 = __s2_len > 2;
            D.40217 = __result == 0;
            D.40238 = D.40237 & D.40217;
            if (D.40238 != 0) goto <D.40239>; else goto <D.40240>;
            <D.40239>:
            D.40241 = &MEM[(void *)"TypeBuilder" + 3B];
            D.40242 = *D.40241;
            D.40243 = (int) D.40242;
            D.40244 = __s2 + 3;
            D.40245 = *D.40244;
            D.40246 = (int) D.40245;
            __result = D.40243 - D.40246;
            <D.40240>:
            <D.40230>:
            <D.40220>:
          }
          D.23818 = __result;
        }
        iftmp.838 = -D.23818;
        goto <D.40247>;
        <D.40207>:
        D.40248 = mono_class_get_ref_info (klass);
        D.40249 = MEM[(struct MonoObject *)D.40248].vtable;
        D.40250 = D.40249->klass;
        D.40251 = D.40250->name;
        iftmp.838 = __builtin_strcmp (D.40251, "TypeBuilder");
        <D.40247>:
        D.23819 = iftmp.838;
      }
      D.40252 = D.23819 != 0;
      D.40253 = (long int) D.40252;
      D.40254 = __builtin_expect (D.40253, 0);
      if (D.40254 != 0) goto <D.40255>; else goto <D.40256>;
      <D.40255>:
      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.40256>:
      D.40257 = &oklass->byval_arg;
      D.40258 = mono_domain_get ();
      D.40259 = mono_type_get_object (D.40258, D.40257);
      params[0] = D.40259;
      D.40260 = mono_class_get_ref_info (klass);
      method.836 = method;
      res = mono_runtime_invoke (method.836, D.40260, &params, &exc);
      exc.839 = exc;
      if (exc.839 != 0B) goto <D.40262>; else goto <D.40263>;
      <D.40262>:
      D.40264 = 0;
      return D.40264;
      <D.40263>:
      D.40265 = mono_object_unbox (res);
      D.40266 = MEM[(MonoBoolean *)D.40265];
      D.40264 = (gboolean) D.40266;
      return D.40264;
    }
  finally
    {
      exc = {CLOBBER};
      params = {CLOBBER};
    }
}


mono_reflection_type_get_type (struct MonoReflectionType * reftype)
{
  _Bool D.40269;
  long int D.40270;
  long int D.40271;
  struct MonoType * D.40274;

  D.40269 = reftype == 0B;
  D.40270 = (long int) D.40269;
  D.40271 = __builtin_expect (D.40270, 0);
  if (D.40271 != 0) goto <D.40272>; else goto <D.40273>;
  <D.40272>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12653, "reftype");
  <D.40273>:
  D.40274 = mono_reflection_type_get_handle (reftype);
  return D.40274;
}


