mono_reflection_init ()
{

}


mono_class_get_ref_info (struct MonoClass * klass)
{
  unsigned int D.24718;
  void * D.24721;

  D.24718 = klass->ref_info_handle;
  if (D.24718 == 0) goto <D.24719>; else goto <D.24720>;
  <D.24719>:
  D.24721 = 0B;
  return D.24721;
  <D.24720>:
  D.24718 = klass->ref_info_handle;
  D.24721 = mono_gchandle_get_target (D.24718);
  return D.24721;
}


mono_class_set_ref_info (struct MonoClass * klass, void * obj)
{
  unsigned int D.24723;
  unsigned int D.24724;
  _Bool D.24725;
  long int D.24726;
  long int D.24727;

  D.24723 = mono_gchandle_new (obj, 0);
  klass->ref_info_handle = D.24723;
  D.24724 = klass->ref_info_handle;
  D.24725 = D.24724 == 0;
  D.24726 = (long int) D.24725;
  D.24727 = __builtin_expect (D.24726, 0);
  if (D.24727 != 0) goto <D.24728>; else goto <D.24729>;
  <D.24728>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 641, "klass->ref_info_handle != 0");
  <D.24729>:
}


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

  D.24730 = klass->ref_info_handle;
  if (D.24730 != 0) goto <D.24731>; else goto <D.24732>;
  <D.24731>:
  D.24730 = klass->ref_info_handle;
  mono_gchandle_free (D.24730);
  klass->ref_info_handle = 0;
  <D.24732>:
}


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

  D.24733 = ainfo->cached;
  if (D.24733 == 0) goto <D.24734>; else goto <D.24735>;
  <D.24734>:
  monoeg_g_free (ainfo);
  <D.24735>:
}


mono_image_build_metadata (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.24736;
  unsigned int D.24737;
  int D.24740;
  unsigned int D.24743;
  unsigned int D.24744;
  unsigned int D.24745;
  guint32 * D.24746;
  unsigned char D.24747;
  long unsigned int D.24748;
  long unsigned int D.24749;
  guint32 * D.24750;
  struct MonoDynamicStream * D.24751;
  unsigned int D.24752;
  guint32 * D.24753;
  unsigned int D.24754;
  guint32 * D.24755;
  guint32 * D.24756;
  guint32 * D.24757;
  struct MonoArray * D.24758;
  long unsigned int D.24761;
  unsigned int D.24762;
  unsigned int D.24763;
  long unsigned int D.24764;
  char * D.24765;
  struct MonoReflectionMethodBuilder * D.24766;
  long unsigned int D.24767;
  struct MonoArray * D.24768;
  long unsigned int D.24771;
  unsigned int D.24772;
  unsigned int D.24773;
  char * D.24774;
  struct MonoReflectionFieldBuilder * D.24775;
  long unsigned int D.24776;
  int D.24777;
  int D.24778;
  void * iftmp.0;
  long unsigned int D.24782;
  long unsigned int D.24783;
  void * D.24784;
  struct MonoArray * D.24786;
  char * D.24789;
  void * * D.24790;
  int D.24791;
  long unsigned int D.24792;
  unsigned int D.24793;
  unsigned int D.24794;
  long unsigned int D.24795;
  long unsigned int D.24796;
  void * * D.24797;
  struct MonoString * D.24798;
  struct MonoString * D.24799;
  struct MonoArray * D.24800;
  struct MonoArray * D.24801;
  struct MonoArray * D.24804;
  struct MonoArray * D.24807;
  struct MonoGHashTable * D.24810;
  char * D.24813;
  long unsigned int D.24814;
  struct MonoArray * D.24815;
  long unsigned int D.24818;
  char * D.24819;
  int D.24820;
  int D.24821;
  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.24736 = MEM[(struct MonoObject *)assemblyb].vtable;
      domain = D.24736->domain;
      D.24737 = assembly->text_rva;
      if (D.24737 != 0) goto <D.24738>; else goto <D.24739>;
      <D.24738>:
      return;
      <D.24739>:
      assembly->text_rva = 8192;
      D.24740 = moduleb->is_main;
      if (D.24740 != 0) goto <D.24741>; else goto <D.24742>;
      <D.24741>:
      mono_image_emit_manifest (moduleb);
      <D.24742>:
      table = &assembly->tables[2];
      table->rows = 1;
      D.24743 = table->next_idx;
      D.24744 = D.24743 + 1;
      table->next_idx = D.24744;
      D.24745 = table->rows;
      alloc_table (table, D.24745);
      D.24746 = table->values;
      D.24747 = table->columns;
      D.24748 = (long unsigned int) D.24747;
      D.24749 = D.24748 * 4;
      values = D.24746 + D.24749;
      *values = 0;
      D.24750 = values + 4;
      D.24751 = &assembly->sheap;
      D.24752 = string_heap_insert (D.24751, "<Module>");
      *D.24750 = D.24752;
      D.24753 = values + 8;
      D.24751 = &assembly->sheap;
      D.24754 = string_heap_insert (D.24751, "");
      *D.24753 = D.24754;
      D.24755 = values + 12;
      *D.24755 = 0;
      D.24756 = values + 16;
      *D.24756 = 1;
      D.24757 = values + 20;
      *D.24757 = 1;
      D.24758 = moduleb->global_methods;
      if (D.24758 != 0B) goto <D.24759>; else goto <D.24760>;
      <D.24759>:
      table = &assembly->tables[6];
      D.24758 = moduleb->global_methods;
      D.24761 = mono_array_length (D.24758);
      D.24745 = table->rows;
      D.24762 = (unsigned int) D.24761;
      D.24763 = D.24745 + D.24762;
      table->rows = D.24763;
      D.24745 = table->rows;
      alloc_table (table, D.24745);
      i = 0;
      goto <D.20930>;
      <D.20929>:
      D.24758 = moduleb->global_methods;
      D.24764 = (long unsigned int) i;
      D.24765 = mono_array_addr_with_size (D.24758, 8, D.24764);
      D.24766 = MEM[(struct MonoReflectionMethodBuilder * *)D.24765];
      mono_image_get_method_info (D.24766, assembly);
      i = i + 1;
      <D.20930>:
      D.24764 = (long unsigned int) i;
      D.24758 = moduleb->global_methods;
      D.24767 = mono_array_length (D.24758);
      if (D.24764 < D.24767) goto <D.20929>; else goto <D.20931>;
      <D.20931>:
      <D.24760>:
      D.24768 = moduleb->global_fields;
      if (D.24768 != 0B) goto <D.24769>; else goto <D.24770>;
      <D.24769>:
      table = &assembly->tables[4];
      D.24768 = moduleb->global_fields;
      D.24771 = mono_array_length (D.24768);
      D.24745 = table->rows;
      D.24772 = (unsigned int) D.24771;
      D.24773 = D.24745 + D.24772;
      table->rows = D.24773;
      D.24745 = table->rows;
      alloc_table (table, D.24745);
      i = 0;
      goto <D.20933>;
      <D.20932>:
      D.24768 = moduleb->global_fields;
      D.24764 = (long unsigned int) i;
      D.24774 = mono_array_addr_with_size (D.24768, 8, D.24764);
      D.24775 = MEM[(struct MonoReflectionFieldBuilder * *)D.24774];
      mono_image_get_field_info (D.24775, assembly);
      i = i + 1;
      <D.20933>:
      D.24764 = (long unsigned int) i;
      D.24768 = moduleb->global_fields;
      D.24776 = mono_array_length (D.24768);
      if (D.24764 < D.24776) goto <D.20932>; else goto <D.20934>;
      <D.20934>:
      <D.24770>:
      table = &assembly->tables[0];
      alloc_table (table, 1);
      mono_image_fill_module_table (domain, moduleb, assembly);
      types.size = 0;
      D.24777 = moduleb->num_types;
      D.24778 = MAX_EXPR <D.24777, 16>;
      types.capacity = D.24778;
      D.24777 = moduleb->num_types;
      if (D.24777 > 16) goto <D.24780>; else goto <D.24781>;
      <D.24780>:
      D.24777 = moduleb->num_types;
      D.24782 = (long unsigned int) D.24777;
      D.24783 = D.24782 * 8;
      D.24777 = moduleb->num_types;
      D.24784 = mono_gc_make_root_descr_all_refs (D.24777);
      iftmp.0 = mono_gc_alloc_fixed (D.24783, D.24784);
      goto <D.24785>;
      <D.24781>:
      iftmp.0 = __builtin_alloca (128);
      <D.24785>:
      types.data = iftmp.0;
      D.24786 = moduleb->types;
      if (D.24786 != 0B) goto <D.24787>; else goto <D.24788>;
      <D.24787>:
      i = 0;
      goto <D.20937>;
      <D.20936>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24786 = moduleb->types;
        D.24764 = (long unsigned int) i;
        D.24789 = mono_array_addr_with_size (D.24786, 8, D.24764);
        type = MEM[(struct MonoReflectionTypeBuilder * *)D.24789];
        collect_types (&types, type);
      }
      i = i + 1;
      <D.20937>:
      D.24777 = moduleb->num_types;
      if (D.24777 > i) goto <D.20936>; else goto <D.20938>;
      <D.20938>:
      <D.24788>:
      D.24790 = types.data;
      D.24791 = types.size;
      D.24792 = (long unsigned int) D.24791;
      qsort (D.24790, D.24792, 8, compare_types_by_table_idx);
      table = &assembly->tables[2];
      D.24745 = table->rows;
      D.24791 = types.size;
      D.24793 = (unsigned int) D.24791;
      D.24794 = D.24745 + D.24793;
      table->rows = D.24794;
      D.24745 = table->rows;
      alloc_table (table, D.24745);
      i = 0;
      goto <D.20941>;
      <D.20940>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.24790 = types.data;
        D.24795 = (long unsigned int) i;
        D.24796 = D.24795 * 8;
        D.24797 = D.24790 + D.24796;
        tb = *D.24797;
        D.24751 = &assembly->sheap;
        D.24798 = tb->nspace;
        string_heap_insert_mstring (D.24751, D.24798);
      }
      i = i + 1;
      <D.20941>:
      D.24791 = types.size;
      if (D.24791 > i) goto <D.20940>; else goto <D.20942>;
      <D.20942>:
      i = 0;
      goto <D.20945>;
      <D.20944>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.24790 = types.data;
        D.24795 = (long unsigned int) i;
        D.24796 = D.24795 * 8;
        D.24797 = D.24790 + D.24796;
        tb = *D.24797;
        D.24751 = &assembly->sheap;
        D.24799 = tb->name;
        string_heap_insert_mstring (D.24751, D.24799);
      }
      i = i + 1;
      <D.20945>:
      D.24791 = types.size;
      if (D.24791 > i) goto <D.20944>; else goto <D.20946>;
      <D.20946>:
      i = 0;
      goto <D.20949>;
      <D.20948>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24790 = types.data;
        D.24795 = (long unsigned int) i;
        D.24796 = D.24795 * 8;
        D.24797 = D.24790 + D.24796;
        type = *D.24797;
        mono_image_get_type_info (domain, type, assembly);
      }
      i = i + 1;
      <D.20949>:
      D.24791 = types.size;
      if (D.24791 > i) goto <D.20948>; else goto <D.20950>;
      <D.20950>:
      D.24800 = assemblyb->cattrs;
      mono_image_add_cattrs (assembly, 1, 14, D.24800);
      D.24801 = assemblyb->permissions_minimum;
      if (D.24801 != 0B) goto <D.24802>; else goto <D.24803>;
      <D.24802>:
      D.24801 = assemblyb->permissions_minimum;
      mono_image_add_decl_security (assembly, 536870913, D.24801);
      <D.24803>:
      D.24804 = assemblyb->permissions_optional;
      if (D.24804 != 0B) goto <D.24805>; else goto <D.24806>;
      <D.24805>:
      D.24804 = assemblyb->permissions_optional;
      mono_image_add_decl_security (assembly, 536870913, D.24804);
      <D.24806>:
      D.24807 = assemblyb->permissions_refused;
      if (D.24807 != 0B) goto <D.24808>; else goto <D.24809>;
      <D.24808>:
      D.24807 = assemblyb->permissions_refused;
      mono_image_add_decl_security (assembly, 536870913, D.24807);
      <D.24809>:
      module_add_cattrs (assembly, moduleb);
      D.24810 = assembly->token_fixups;
      mono_g_hash_table_foreach (D.24810, fixup_method, assembly);
      D.24758 = moduleb->global_methods;
      if (D.24758 != 0B) goto <D.24811>; else goto <D.24812>;
      <D.24811>:
      i = 0;
      goto <D.20953>;
      <D.20952>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.24758 = moduleb->global_methods;
        D.24764 = (long unsigned int) i;
        D.24813 = mono_array_addr_with_size (D.24758, 8, D.24764);
        mb = MEM[(struct MonoReflectionMethodBuilder * *)D.24813];
        mono_image_add_methodimpl (assembly, mb);
      }
      i = i + 1;
      <D.20953>:
      D.24764 = (long unsigned int) i;
      D.24758 = moduleb->global_methods;
      D.24814 = mono_array_length (D.24758);
      if (D.24764 < D.24814) goto <D.20952>; else goto <D.20954>;
      <D.20954>:
      <D.24812>:
      i = 0;
      goto <D.20961>;
      <D.20960>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24790 = types.data;
        D.24795 = (long unsigned int) i;
        D.24796 = D.24795 * 8;
        D.24797 = D.24790 + D.24796;
        type = *D.24797;
        D.24815 = type->methods;
        if (D.24815 != 0B) goto <D.24816>; else goto <D.24817>;
        <D.24816>:
        j = 0;
        goto <D.20958>;
        <D.20957>:
        {
          struct MonoReflectionMethodBuilder * mb;

          D.24815 = type->methods;
          D.24818 = (long unsigned int) j;
          D.24819 = mono_array_addr_with_size (D.24815, 8, D.24818);
          mb = MEM[(struct MonoReflectionMethodBuilder * *)D.24819];
          mono_image_add_methodimpl (assembly, mb);
        }
        j = j + 1;
        <D.20958>:
        D.24820 = type->num_methods;
        if (D.24820 > j) goto <D.20957>; else goto <D.20959>;
        <D.20959>:
        <D.24817>:
      }
      i = i + 1;
      <D.20961>:
      D.24791 = types.size;
      if (D.24791 > i) goto <D.20960>; else goto <D.20962>;
      <D.20962>:
      D.24821 = types.capacity;
      if (D.24821 > 16) goto <D.24822>; else goto <D.24823>;
      <D.24822>:
      D.24790 = types.data;
      mono_gc_free_fixed (D.24790);
      <D.24823>:
      fixup_cattrs (assembly);
    }
  finally
    {
      types = {CLOBBER};
    }
}


fixup_method (struct MonoReflectionILGen * ilgen, void * value, struct MonoDynamicImage * assembly)
{
  long int value.1;
  struct MonoArray * D.24828;
  long unsigned int D.24829;
  char * D.24830;
  sizetype D.24831;
  int D.24832;
  sizetype D.24833;
  sizetype D.24834;
  unsigned char * D.24835;
  unsigned char D.24836;
  int D.24837;
  int D.20599;
  int iftmp.2;
  int D.20598;
  struct MonoObject * D.24841;
  struct MonoVTable * D.24842;
  struct MonoClass * D.24843;
  const char[13] * D.24844;
  unsigned char D.24845;
  int D.24846;
  unsigned char D.24847;
  int D.24848;
  const unsigned char * D.24853;
  unsigned char D.24854;
  int D.24855;
  const unsigned char * D.24856;
  unsigned char D.24857;
  int D.24858;
  const unsigned char * D.24863;
  unsigned char D.24864;
  int D.24865;
  const unsigned char * D.24866;
  unsigned char D.24867;
  int D.24868;
  const unsigned char * D.24873;
  unsigned char D.24874;
  int D.24875;
  const unsigned char * D.24876;
  unsigned char D.24877;
  int D.24878;
  const char * D.24880;
  int D.24883;
  int D.20608;
  int iftmp.3;
  int D.20607;
  const char[10] * D.24888;
  unsigned char D.24889;
  int D.24890;
  unsigned char D.24891;
  int D.24892;
  const unsigned char * D.24897;
  unsigned char D.24898;
  int D.24899;
  const unsigned char * D.24900;
  unsigned char D.24901;
  int D.24902;
  const unsigned char * D.24907;
  unsigned char D.24908;
  int D.24909;
  const unsigned char * D.24910;
  unsigned char D.24911;
  int D.24912;
  const unsigned char * D.24917;
  unsigned char D.24918;
  int D.24919;
  const unsigned char * D.24920;
  unsigned char D.24921;
  int D.24922;
  struct GHashTable * D.24926;
  void * D.24927;
  long int D.24928;
  int D.20620;
  int iftmp.4;
  int D.20619;
  const char[14] * D.24933;
  unsigned char D.24934;
  int D.24935;
  unsigned char D.24936;
  int D.24937;
  const unsigned char * D.24942;
  unsigned char D.24943;
  int D.24944;
  const unsigned char * D.24945;
  unsigned char D.24946;
  int D.24947;
  const unsigned char * D.24952;
  unsigned char D.24953;
  int D.24954;
  const unsigned char * D.24955;
  unsigned char D.24956;
  int D.24957;
  const unsigned char * D.24962;
  unsigned char D.24963;
  int D.24964;
  const unsigned char * D.24965;
  unsigned char D.24966;
  int D.24967;
  int D.20629;
  int iftmp.5;
  int D.20628;
  const char[19] * D.24975;
  unsigned char D.24976;
  int D.24977;
  unsigned char D.24978;
  int D.24979;
  const unsigned char * D.24984;
  unsigned char D.24985;
  int D.24986;
  const unsigned char * D.24987;
  unsigned char D.24988;
  int D.24989;
  const unsigned char * D.24994;
  unsigned char D.24995;
  int D.24996;
  const unsigned char * D.24997;
  unsigned char D.24998;
  int D.24999;
  const unsigned char * D.25004;
  unsigned char D.25005;
  int D.25006;
  const unsigned char * D.25007;
  unsigned char D.25008;
  int D.25009;
  int D.20638;
  int iftmp.6;
  int D.20637;
  const char[11] * D.25020;
  unsigned char D.25021;
  int D.25022;
  unsigned char D.25023;
  int D.25024;
  const unsigned char * D.25029;
  unsigned char D.25030;
  int D.25031;
  const unsigned char * D.25032;
  unsigned char D.25033;
  int D.25034;
  const unsigned char * D.25039;
  unsigned char D.25040;
  int D.25041;
  const unsigned char * D.25042;
  unsigned char D.25043;
  int D.25044;
  const unsigned char * D.25049;
  unsigned char D.25050;
  int D.25051;
  const unsigned char * D.25052;
  unsigned char D.25053;
  int D.25054;
  int D.20647;
  int iftmp.7;
  int D.20646;
  const char[12] * D.25060;
  unsigned char D.25061;
  int D.25062;
  unsigned char D.25063;
  int D.25064;
  const unsigned char * D.25069;
  unsigned char D.25070;
  int D.25071;
  const unsigned char * D.25072;
  unsigned char D.25073;
  int D.25074;
  const unsigned char * D.25079;
  unsigned char D.25080;
  int D.25081;
  const unsigned char * D.25082;
  unsigned char D.25083;
  int D.25084;
  const unsigned char * D.25089;
  unsigned char D.25090;
  int D.25091;
  const unsigned char * D.25092;
  unsigned char D.25093;
  int D.25094;
  struct GHashTable * D.25096;
  void * D.25097;
  long int D.25098;
  int D.20658;
  int iftmp.8;
  int D.20657;
  const char[12] * D.25102;
  unsigned char D.25103;
  int D.25104;
  unsigned char D.25105;
  int D.25106;
  const unsigned char * D.25111;
  unsigned char D.25112;
  int D.25113;
  const unsigned char * D.25114;
  unsigned char D.25115;
  int D.25116;
  const unsigned char * D.25121;
  unsigned char D.25122;
  int D.25123;
  const unsigned char * D.25124;
  unsigned char D.25125;
  int D.25126;
  const unsigned char * D.25131;
  unsigned char D.25132;
  int D.25133;
  const unsigned char * D.25134;
  unsigned char D.25135;
  int D.25136;
  int D.20668;
  int iftmp.9;
  int D.20667;
  const char[16] * D.25143;
  unsigned char D.25144;
  int D.25145;
  unsigned char D.25146;
  int D.25147;
  const unsigned char * D.25152;
  unsigned char D.25153;
  int D.25154;
  const unsigned char * D.25155;
  unsigned char D.25156;
  int D.25157;
  const unsigned char * D.25162;
  unsigned char D.25163;
  int D.25164;
  const unsigned char * D.25165;
  unsigned char D.25166;
  int D.25167;
  const unsigned char * D.25172;
  unsigned char D.25173;
  int D.25174;
  const unsigned char * D.25175;
  unsigned char D.25176;
  int D.25177;
  int D.20677;
  int iftmp.10;
  int D.20676;
  unsigned char D.25187;
  int D.25188;
  const unsigned char * D.25193;
  unsigned char D.25194;
  int D.25195;
  const unsigned char * D.25200;
  unsigned char D.25201;
  int D.25202;
  const unsigned char * D.25207;
  unsigned char D.25208;
  int D.25209;
  int D.20686;
  int iftmp.11;
  int D.20685;
  unsigned char D.25215;
  int D.25216;
  const unsigned char * D.25221;
  unsigned char D.25222;
  int D.25223;
  const unsigned char * D.25228;
  unsigned char D.25229;
  int D.25230;
  const unsigned char * D.25235;
  unsigned char D.25236;
  int D.25237;
  int D.20695;
  int iftmp.12;
  int D.20694;
  const char[18] * D.25243;
  unsigned char D.25244;
  int D.25245;
  unsigned char D.25246;
  int D.25247;
  const unsigned char * D.25252;
  unsigned char D.25253;
  int D.25254;
  const unsigned char * D.25255;
  unsigned char D.25256;
  int D.25257;
  const unsigned char * D.25262;
  unsigned char D.25263;
  int D.25264;
  const unsigned char * D.25265;
  unsigned char D.25266;
  int D.25267;
  const unsigned char * D.25272;
  unsigned char D.25273;
  int D.25274;
  const unsigned char * D.25275;
  unsigned char D.25276;
  int D.25277;
  int D.20704;
  int iftmp.13;
  int D.20703;
  const char[19] * D.25283;
  unsigned char D.25284;
  int D.25285;
  unsigned char D.25286;
  int D.25287;
  const unsigned char * D.25292;
  unsigned char D.25293;
  int D.25294;
  const unsigned char * D.25295;
  unsigned char D.25296;
  int D.25297;
  const unsigned char * D.25302;
  unsigned char D.25303;
  int D.25304;
  const unsigned char * D.25305;
  unsigned char D.25306;
  int D.25307;
  const unsigned char * D.25312;
  unsigned char D.25313;
  int D.25314;
  const unsigned char * D.25315;
  unsigned char D.25316;
  int D.25317;
  int iftmp.14;
  struct MonoClass * D.25322;
  struct MonoGenericClass * D.25323;
  struct MonoGenericContainer * D.25325;
  _Bool D.25327;
  long int D.25328;
  long int D.25329;
  int D.20715;
  int iftmp.15;
  int D.20714;
  unsigned char D.25335;
  int D.25336;
  const unsigned char * D.25341;
  unsigned char D.25342;
  int D.25343;
  const unsigned char * D.25348;
  unsigned char D.25349;
  int D.25350;
  const unsigned char * D.25355;
  unsigned char D.25356;
  int D.25357;
  int D.20724;
  int iftmp.16;
  int D.20723;
  unsigned char D.25364;
  int D.25365;
  const unsigned char * D.25370;
  unsigned char D.25371;
  int D.25372;
  const unsigned char * D.25377;
  unsigned char D.25378;
  int D.25379;
  const unsigned char * D.25384;
  unsigned char D.25385;
  int D.25386;
  int D.25390;
  _Bool D.25391;
  long int D.25392;
  long int D.25393;
  int D.20734;
  int iftmp.17;
  int D.20733;
  unsigned char D.25401;
  int D.25402;
  const unsigned char * D.25407;
  unsigned char D.25408;
  int D.25409;
  const unsigned char * D.25414;
  unsigned char D.25415;
  int D.25416;
  const unsigned char * D.25421;
  unsigned char D.25422;
  int D.25423;
  int D.20743;
  int iftmp.18;
  int D.20742;
  unsigned char D.25429;
  int D.25430;
  const unsigned char * D.25435;
  unsigned char D.25436;
  int D.25437;
  const unsigned char * D.25442;
  unsigned char D.25443;
  int D.25444;
  const unsigned char * D.25449;
  unsigned char D.25450;
  int D.25451;
  int D.20752;
  int iftmp.19;
  int D.20751;
  const char[23] * D.25456;
  unsigned char D.25457;
  int D.25458;
  unsigned char D.25459;
  int D.25460;
  const unsigned char * D.25465;
  unsigned char D.25466;
  int D.25467;
  const unsigned char * D.25468;
  unsigned char D.25469;
  int D.25470;
  const unsigned char * D.25475;
  unsigned char D.25476;
  int D.25477;
  const unsigned char * D.25478;
  unsigned char D.25479;
  int D.25480;
  const unsigned char * D.25485;
  unsigned char D.25486;
  int D.25487;
  const unsigned char * D.25488;
  unsigned char D.25489;
  int D.25490;
  int D.20761;
  int iftmp.20;
  int D.20760;
  const char[24] * D.25497;
  unsigned char D.25498;
  int D.25499;
  unsigned char D.25500;
  int D.25501;
  const unsigned char * D.25506;
  unsigned char D.25507;
  int D.25508;
  const unsigned char * D.25509;
  unsigned char D.25510;
  int D.25511;
  const unsigned char * D.25516;
  unsigned char D.25517;
  int D.25518;
  const unsigned char * D.25519;
  unsigned char D.25520;
  int D.25521;
  const unsigned char * D.25526;
  unsigned char D.25527;
  int D.25528;
  const unsigned char * D.25529;
  unsigned char D.25530;
  int D.25531;
  int D.20770;
  int iftmp.21;
  int D.20769;
  const char[29] * D.25538;
  unsigned char D.25539;
  int D.25540;
  unsigned char D.25541;
  int D.25542;
  const unsigned char * D.25547;
  unsigned char D.25548;
  int D.25549;
  const unsigned char * D.25550;
  unsigned char D.25551;
  int D.25552;
  const unsigned char * D.25557;
  unsigned char D.25558;
  int D.25559;
  const unsigned char * D.25560;
  unsigned char D.25561;
  int D.25562;
  const unsigned char * D.25567;
  unsigned char D.25568;
  int D.25569;
  const unsigned char * D.25570;
  unsigned char D.25571;
  int D.25572;
  int D.20780;
  int iftmp.22;
  int D.20779;
  unsigned char D.25579;
  int D.25580;
  const unsigned char * D.25585;
  unsigned char D.25586;
  int D.25587;
  const unsigned char * D.25592;
  unsigned char D.25593;
  int D.25594;
  const unsigned char * D.25599;
  unsigned char D.25600;
  int D.25601;
  struct MonoMethodSignature * D.25605;
  short unsigned int D.25606;
  _Bool D.25607;
  long int D.25608;
  long int D.25609;
  int D.20790;
  int iftmp.23;
  int D.20789;
  unsigned char D.25615;
  int D.25616;
  const unsigned char * D.25621;
  unsigned char D.25622;
  int D.25623;
  const unsigned char * D.25628;
  unsigned char D.25629;
  int D.25630;
  const unsigned char * D.25635;
  unsigned char D.25636;
  int D.25637;
  int D.20799;
  int iftmp.24;
  int D.20798;
  unsigned char D.25644;
  int D.25645;
  const unsigned char * D.25650;
  unsigned char D.25651;
  int D.25652;
  const unsigned char * D.25657;
  unsigned char D.25658;
  int D.25659;
  const unsigned char * D.25664;
  unsigned char D.25665;
  int D.25666;
  unsigned char D.25670;
  unsigned char * D.25671;
  unsigned int D.25672;
  unsigned char D.25673;
  unsigned char * D.25674;
  unsigned int D.25675;
  unsigned char D.25676;
  int D.25677;
  unsigned int D.25678;
  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;

  value.1 = (long int) value;
  code_idx = (guint32) value.1;
  idx = 0;
  i = 0;
  goto <D.20803>;
  <D.20802>:
  D.24828 = ilgen->token_fixups;
  D.24829 = (long unsigned int) i;
  iltoken = mono_array_addr_with_size (D.24828, 16, D.24829);
  D.24830 = assembly->code.data;
  D.24831 = (sizetype) code_idx;
  D.24832 = iltoken->code_pos;
  D.24833 = (sizetype) D.24832;
  D.24834 = D.24831 + D.24833;
  target = D.24830 + D.24834;
  D.24835 = target + 3;
  D.24836 = *D.24835;
  D.24837 = (int) D.24836;
  switch (D.24837) <default: <D.20800>, case 2: <D.20649>, case 4: <D.20590>, case 6: <D.20611>, case 10: <D.20659>, case 43: <D.20771>>
  <D.20590>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24844 = "FieldBuilder";
      D.24845 = MEM[(const unsigned char *)D.24844];
      D.24846 = (int) D.24845;
      D.24847 = *__s2;
      D.24848 = (int) D.24847;
      __result = D.24846 - D.24848;
      {
        if (__s2_len != 0) goto <D.24849>; else goto <D.24850>;
        <D.24849>:
        if (__result == 0) goto <D.24851>; else goto <D.24852>;
        <D.24851>:
        D.24853 = &MEM[(void *)"FieldBuilder" + 1B];
        D.24854 = *D.24853;
        D.24855 = (int) D.24854;
        D.24856 = __s2 + 1;
        D.24857 = *D.24856;
        D.24858 = (int) D.24857;
        __result = D.24855 - D.24858;
        if (__s2_len > 1) goto <D.24859>; else goto <D.24860>;
        <D.24859>:
        if (__result == 0) goto <D.24861>; else goto <D.24862>;
        <D.24861>:
        D.24863 = &MEM[(void *)"FieldBuilder" + 2B];
        D.24864 = *D.24863;
        D.24865 = (int) D.24864;
        D.24866 = __s2 + 2;
        D.24867 = *D.24866;
        D.24868 = (int) D.24867;
        __result = D.24865 - D.24868;
        if (__s2_len > 2) goto <D.24869>; else goto <D.24870>;
        <D.24869>:
        if (__result == 0) goto <D.24871>; else goto <D.24872>;
        <D.24871>:
        D.24873 = &MEM[(void *)"FieldBuilder" + 3B];
        D.24874 = *D.24873;
        D.24875 = (int) D.24874;
        D.24876 = __s2 + 3;
        D.24877 = *D.24876;
        D.24878 = (int) D.24877;
        __result = D.24875 - D.24878;
        <D.24872>:
        <D.24870>:
        <D.24862>:
        <D.24860>:
        <D.24852>:
        <D.24850>:
      }
      D.20598 = __result;
    }
    iftmp.2 = -D.20598;
    goto <D.24879>;
    <D.24840>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.2 = __builtin_strcmp (D.24880, "FieldBuilder");
    <D.24879>:
    D.20599 = iftmp.2;
  }
  if (D.20599 == 0) goto <D.24881>; else goto <D.24882>;
  <D.24881>:
  field = iltoken->member;
  D.24883 = field->table_idx;
  idx = (guint32) D.24883;
  goto <D.24884>;
  <D.24882>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24888 = "MonoField";
      D.24889 = MEM[(const unsigned char *)D.24888];
      D.24890 = (int) D.24889;
      D.24891 = *__s2;
      D.24892 = (int) D.24891;
      __result = D.24890 - D.24892;
      {
        if (__s2_len != 0) goto <D.24893>; else goto <D.24894>;
        <D.24893>:
        if (__result == 0) goto <D.24895>; else goto <D.24896>;
        <D.24895>:
        D.24897 = &MEM[(void *)"MonoField" + 1B];
        D.24898 = *D.24897;
        D.24899 = (int) D.24898;
        D.24900 = __s2 + 1;
        D.24901 = *D.24900;
        D.24902 = (int) D.24901;
        __result = D.24899 - D.24902;
        if (__s2_len > 1) goto <D.24903>; else goto <D.24904>;
        <D.24903>:
        if (__result == 0) goto <D.24905>; else goto <D.24906>;
        <D.24905>:
        D.24907 = &MEM[(void *)"MonoField" + 2B];
        D.24908 = *D.24907;
        D.24909 = (int) D.24908;
        D.24910 = __s2 + 2;
        D.24911 = *D.24910;
        D.24912 = (int) D.24911;
        __result = D.24909 - D.24912;
        if (__s2_len > 2) goto <D.24913>; else goto <D.24914>;
        <D.24913>:
        if (__result == 0) goto <D.24915>; else goto <D.24916>;
        <D.24915>:
        D.24917 = &MEM[(void *)"MonoField" + 3B];
        D.24918 = *D.24917;
        D.24919 = (int) D.24918;
        D.24920 = __s2 + 3;
        D.24921 = *D.24920;
        D.24922 = (int) D.24921;
        __result = D.24919 - D.24922;
        <D.24916>:
        <D.24914>:
        <D.24906>:
        <D.24904>:
        <D.24896>:
        <D.24894>:
      }
      D.20607 = __result;
    }
    iftmp.3 = -D.20607;
    goto <D.24923>;
    <D.24887>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.3 = __builtin_strcmp (D.24880, "MonoField");
    <D.24923>:
    D.20608 = iftmp.3;
  }
  if (D.20608 == 0) goto <D.24924>; else goto <D.24925>;
  <D.24924>:
  {
    struct MonoClassField * f;

    D.24841 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.24841].field;
    D.24926 = assembly->field_to_table_idx;
    D.24927 = monoeg_g_hash_table_lookup (D.24926, f);
    D.24928 = (long int) D.24927;
    idx = (guint32) D.24928;
  }
  goto <D.24929>;
  <D.24925>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4237);
  <D.24929>:
  <D.24884>:
  goto <D.20610>;
  <D.20611>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24933 = "MethodBuilder";
      D.24934 = MEM[(const unsigned char *)D.24933];
      D.24935 = (int) D.24934;
      D.24936 = *__s2;
      D.24937 = (int) D.24936;
      __result = D.24935 - D.24937;
      {
        if (__s2_len != 0) goto <D.24938>; else goto <D.24939>;
        <D.24938>:
        if (__result == 0) goto <D.24940>; else goto <D.24941>;
        <D.24940>:
        D.24942 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24943 = *D.24942;
        D.24944 = (int) D.24943;
        D.24945 = __s2 + 1;
        D.24946 = *D.24945;
        D.24947 = (int) D.24946;
        __result = D.24944 - D.24947;
        if (__s2_len > 1) goto <D.24948>; else goto <D.24949>;
        <D.24948>:
        if (__result == 0) goto <D.24950>; else goto <D.24951>;
        <D.24950>:
        D.24952 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24953 = *D.24952;
        D.24954 = (int) D.24953;
        D.24955 = __s2 + 2;
        D.24956 = *D.24955;
        D.24957 = (int) D.24956;
        __result = D.24954 - D.24957;
        if (__s2_len > 2) goto <D.24958>; else goto <D.24959>;
        <D.24958>:
        if (__result == 0) goto <D.24960>; else goto <D.24961>;
        <D.24960>:
        D.24962 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24963 = *D.24962;
        D.24964 = (int) D.24963;
        D.24965 = __s2 + 3;
        D.24966 = *D.24965;
        D.24967 = (int) D.24966;
        __result = D.24964 - D.24967;
        <D.24961>:
        <D.24959>:
        <D.24951>:
        <D.24949>:
        <D.24941>:
        <D.24939>:
      }
      D.20619 = __result;
    }
    iftmp.4 = -D.20619;
    goto <D.24968>;
    <D.24932>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.4 = __builtin_strcmp (D.24880, "MethodBuilder");
    <D.24968>:
    D.20620 = iftmp.4;
  }
  if (D.20620 == 0) goto <D.24969>; else goto <D.24970>;
  <D.24969>:
  method = iltoken->member;
  idx = method->table_idx;
  goto <D.24971>;
  <D.24970>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24975 = "ConstructorBuilder";
      D.24976 = MEM[(const unsigned char *)D.24975];
      D.24977 = (int) D.24976;
      D.24978 = *__s2;
      D.24979 = (int) D.24978;
      __result = D.24977 - D.24979;
      {
        if (__s2_len != 0) goto <D.24980>; else goto <D.24981>;
        <D.24980>:
        if (__result == 0) goto <D.24982>; else goto <D.24983>;
        <D.24982>:
        D.24984 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24985 = *D.24984;
        D.24986 = (int) D.24985;
        D.24987 = __s2 + 1;
        D.24988 = *D.24987;
        D.24989 = (int) D.24988;
        __result = D.24986 - D.24989;
        if (__s2_len > 1) goto <D.24990>; else goto <D.24991>;
        <D.24990>:
        if (__result == 0) goto <D.24992>; else goto <D.24993>;
        <D.24992>:
        D.24994 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24995 = *D.24994;
        D.24996 = (int) D.24995;
        D.24997 = __s2 + 2;
        D.24998 = *D.24997;
        D.24999 = (int) D.24998;
        __result = D.24996 - D.24999;
        if (__s2_len > 2) goto <D.25000>; else goto <D.25001>;
        <D.25000>:
        if (__result == 0) goto <D.25002>; else goto <D.25003>;
        <D.25002>:
        D.25004 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.25005 = *D.25004;
        D.25006 = (int) D.25005;
        D.25007 = __s2 + 3;
        D.25008 = *D.25007;
        D.25009 = (int) D.25008;
        __result = D.25006 - D.25009;
        <D.25003>:
        <D.25001>:
        <D.24993>:
        <D.24991>:
        <D.24983>:
        <D.24981>:
      }
      D.20628 = __result;
    }
    iftmp.5 = -D.20628;
    goto <D.25010>;
    <D.24974>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.5 = __builtin_strcmp (D.24880, "ConstructorBuilder");
    <D.25010>:
    D.20629 = iftmp.5;
  }
  if (D.20629 == 0) goto <D.25011>; else goto <D.25012>;
  <D.25011>:
  ctor = iltoken->member;
  idx = ctor->table_idx;
  goto <D.25013>;
  <D.25012>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25020 = "MonoMethod";
      D.25021 = MEM[(const unsigned char *)D.25020];
      D.25022 = (int) D.25021;
      D.25023 = *__s2;
      D.25024 = (int) D.25023;
      __result = D.25022 - D.25024;
      {
        if (__s2_len != 0) goto <D.25025>; else goto <D.25026>;
        <D.25025>:
        if (__result == 0) goto <D.25027>; else goto <D.25028>;
        <D.25027>:
        D.25029 = &MEM[(void *)"MonoMethod" + 1B];
        D.25030 = *D.25029;
        D.25031 = (int) D.25030;
        D.25032 = __s2 + 1;
        D.25033 = *D.25032;
        D.25034 = (int) D.25033;
        __result = D.25031 - D.25034;
        if (__s2_len > 1) goto <D.25035>; else goto <D.25036>;
        <D.25035>:
        if (__result == 0) goto <D.25037>; else goto <D.25038>;
        <D.25037>:
        D.25039 = &MEM[(void *)"MonoMethod" + 2B];
        D.25040 = *D.25039;
        D.25041 = (int) D.25040;
        D.25042 = __s2 + 2;
        D.25043 = *D.25042;
        D.25044 = (int) D.25043;
        __result = D.25041 - D.25044;
        if (__s2_len > 2) goto <D.25045>; else goto <D.25046>;
        <D.25045>:
        if (__result == 0) goto <D.25047>; else goto <D.25048>;
        <D.25047>:
        D.25049 = &MEM[(void *)"MonoMethod" + 3B];
        D.25050 = *D.25049;
        D.25051 = (int) D.25050;
        D.25052 = __s2 + 3;
        D.25053 = *D.25052;
        D.25054 = (int) D.25053;
        __result = D.25051 - D.25054;
        <D.25048>:
        <D.25046>:
        <D.25038>:
        <D.25036>:
        <D.25028>:
        <D.25026>:
      }
      D.20637 = __result;
    }
    iftmp.6 = -D.20637;
    goto <D.25055>;
    <D.25019>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.6 = __builtin_strcmp (D.24880, "MonoMethod");
    <D.25055>:
    D.20638 = iftmp.6;
  }
  if (D.20638 == 0) goto <D.25014>; else goto <D.25056>;
  <D.25056>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25060 = "MonoCMethod";
      D.25061 = MEM[(const unsigned char *)D.25060];
      D.25062 = (int) D.25061;
      D.25063 = *__s2;
      D.25064 = (int) D.25063;
      __result = D.25062 - D.25064;
      {
        if (__s2_len != 0) goto <D.25065>; else goto <D.25066>;
        <D.25065>:
        if (__result == 0) goto <D.25067>; else goto <D.25068>;
        <D.25067>:
        D.25069 = &MEM[(void *)"MonoCMethod" + 1B];
        D.25070 = *D.25069;
        D.25071 = (int) D.25070;
        D.25072 = __s2 + 1;
        D.25073 = *D.25072;
        D.25074 = (int) D.25073;
        __result = D.25071 - D.25074;
        if (__s2_len > 1) goto <D.25075>; else goto <D.25076>;
        <D.25075>:
        if (__result == 0) goto <D.25077>; else goto <D.25078>;
        <D.25077>:
        D.25079 = &MEM[(void *)"MonoCMethod" + 2B];
        D.25080 = *D.25079;
        D.25081 = (int) D.25080;
        D.25082 = __s2 + 2;
        D.25083 = *D.25082;
        D.25084 = (int) D.25083;
        __result = D.25081 - D.25084;
        if (__s2_len > 2) goto <D.25085>; else goto <D.25086>;
        <D.25085>:
        if (__result == 0) goto <D.25087>; else goto <D.25088>;
        <D.25087>:
        D.25089 = &MEM[(void *)"MonoCMethod" + 3B];
        D.25090 = *D.25089;
        D.25091 = (int) D.25090;
        D.25092 = __s2 + 3;
        D.25093 = *D.25092;
        D.25094 = (int) D.25093;
        __result = D.25091 - D.25094;
        <D.25088>:
        <D.25086>:
        <D.25078>:
        <D.25076>:
        <D.25068>:
        <D.25066>:
      }
      D.20646 = __result;
    }
    iftmp.7 = -D.20646;
    goto <D.25095>;
    <D.25059>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.7 = __builtin_strcmp (D.24880, "MonoCMethod");
    <D.25095>:
    D.20647 = iftmp.7;
  }
  if (D.20647 == 0) goto <D.25014>; else goto <D.25015>;
  <D.25014>:
  {
    struct MonoMethod * m;

    D.24841 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24841].method;
    D.25096 = assembly->method_to_table_idx;
    D.25097 = monoeg_g_hash_table_lookup (D.25096, m);
    D.25098 = (long int) D.25097;
    idx = (guint32) D.25098;
  }
  goto <D.25016>;
  <D.25015>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4252);
  <D.25016>:
  <D.25013>:
  <D.24971>:
  goto <D.20610>;
  <D.20649>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25102 = "TypeBuilder";
      D.25103 = MEM[(const unsigned char *)D.25102];
      D.25104 = (int) D.25103;
      D.25105 = *__s2;
      D.25106 = (int) D.25105;
      __result = D.25104 - D.25106;
      {
        if (__s2_len != 0) goto <D.25107>; else goto <D.25108>;
        <D.25107>:
        if (__result == 0) goto <D.25109>; else goto <D.25110>;
        <D.25109>:
        D.25111 = &MEM[(void *)"TypeBuilder" + 1B];
        D.25112 = *D.25111;
        D.25113 = (int) D.25112;
        D.25114 = __s2 + 1;
        D.25115 = *D.25114;
        D.25116 = (int) D.25115;
        __result = D.25113 - D.25116;
        if (__s2_len > 1) goto <D.25117>; else goto <D.25118>;
        <D.25117>:
        if (__result == 0) goto <D.25119>; else goto <D.25120>;
        <D.25119>:
        D.25121 = &MEM[(void *)"TypeBuilder" + 2B];
        D.25122 = *D.25121;
        D.25123 = (int) D.25122;
        D.25124 = __s2 + 2;
        D.25125 = *D.25124;
        D.25126 = (int) D.25125;
        __result = D.25123 - D.25126;
        if (__s2_len > 2) goto <D.25127>; else goto <D.25128>;
        <D.25127>:
        if (__result == 0) goto <D.25129>; else goto <D.25130>;
        <D.25129>:
        D.25131 = &MEM[(void *)"TypeBuilder" + 3B];
        D.25132 = *D.25131;
        D.25133 = (int) D.25132;
        D.25134 = __s2 + 3;
        D.25135 = *D.25134;
        D.25136 = (int) D.25135;
        __result = D.25133 - D.25136;
        <D.25130>:
        <D.25128>:
        <D.25120>:
        <D.25118>:
        <D.25110>:
        <D.25108>:
      }
      D.20657 = __result;
    }
    iftmp.8 = -D.20657;
    goto <D.25137>;
    <D.25101>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.8 = __builtin_strcmp (D.24880, "TypeBuilder");
    <D.25137>:
    D.20658 = iftmp.8;
  }
  if (D.20658 != 0) goto <D.25138>; else goto <D.25139>;
  <D.25138>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4257);
  <D.25139>:
  tb = iltoken->member;
  idx = tb->table_idx;
  goto <D.20610>;
  <D.20659>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25143 = "MonoArrayMethod";
      D.25144 = MEM[(const unsigned char *)D.25143];
      D.25145 = (int) D.25144;
      D.25146 = *__s2;
      D.25147 = (int) D.25146;
      __result = D.25145 - D.25147;
      {
        if (__s2_len != 0) goto <D.25148>; else goto <D.25149>;
        <D.25148>:
        if (__result == 0) goto <D.25150>; else goto <D.25151>;
        <D.25150>:
        D.25152 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.25153 = *D.25152;
        D.25154 = (int) D.25153;
        D.25155 = __s2 + 1;
        D.25156 = *D.25155;
        D.25157 = (int) D.25156;
        __result = D.25154 - D.25157;
        if (__s2_len > 1) goto <D.25158>; else goto <D.25159>;
        <D.25158>:
        if (__result == 0) goto <D.25160>; else goto <D.25161>;
        <D.25160>:
        D.25162 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.25163 = *D.25162;
        D.25164 = (int) D.25163;
        D.25165 = __s2 + 2;
        D.25166 = *D.25165;
        D.25167 = (int) D.25166;
        __result = D.25164 - D.25167;
        if (__s2_len > 2) goto <D.25168>; else goto <D.25169>;
        <D.25168>:
        if (__result == 0) goto <D.25170>; else goto <D.25171>;
        <D.25170>:
        D.25172 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.25173 = *D.25172;
        D.25174 = (int) D.25173;
        D.25175 = __s2 + 3;
        D.25176 = *D.25175;
        D.25177 = (int) D.25176;
        __result = D.25174 - D.25177;
        <D.25171>:
        <D.25169>:
        <D.25161>:
        <D.25159>:
        <D.25151>:
        <D.25149>:
      }
      D.20667 = __result;
    }
    iftmp.9 = -D.20667;
    goto <D.25178>;
    <D.25142>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.9 = __builtin_strcmp (D.24880, "MonoArrayMethod");
    <D.25178>:
    D.20668 = iftmp.9;
  }
  if (D.20668 == 0) goto <D.25179>; else goto <D.25180>;
  <D.25179>:
  am = iltoken->member;
  idx = am->table_idx;
  goto <D.25181>;
  <D.25180>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25020 = "MonoMethod";
      D.25021 = MEM[(const unsigned char *)D.25020];
      D.25022 = (int) D.25021;
      D.25187 = *__s2;
      D.25188 = (int) D.25187;
      __result = D.25022 - D.25188;
      {
        if (__s2_len != 0) goto <D.25189>; else goto <D.25190>;
        <D.25189>:
        if (__result == 0) goto <D.25191>; else goto <D.25192>;
        <D.25191>:
        D.25029 = &MEM[(void *)"MonoMethod" + 1B];
        D.25030 = *D.25029;
        D.25031 = (int) D.25030;
        D.25193 = __s2 + 1;
        D.25194 = *D.25193;
        D.25195 = (int) D.25194;
        __result = D.25031 - D.25195;
        if (__s2_len > 1) goto <D.25196>; else goto <D.25197>;
        <D.25196>:
        if (__result == 0) goto <D.25198>; else goto <D.25199>;
        <D.25198>:
        D.25039 = &MEM[(void *)"MonoMethod" + 2B];
        D.25040 = *D.25039;
        D.25041 = (int) D.25040;
        D.25200 = __s2 + 2;
        D.25201 = *D.25200;
        D.25202 = (int) D.25201;
        __result = D.25041 - D.25202;
        if (__s2_len > 2) goto <D.25203>; else goto <D.25204>;
        <D.25203>:
        if (__result == 0) goto <D.25205>; else goto <D.25206>;
        <D.25205>:
        D.25049 = &MEM[(void *)"MonoMethod" + 3B];
        D.25050 = *D.25049;
        D.25051 = (int) D.25050;
        D.25207 = __s2 + 3;
        D.25208 = *D.25207;
        D.25209 = (int) D.25208;
        __result = D.25051 - D.25209;
        <D.25206>:
        <D.25204>:
        <D.25199>:
        <D.25197>:
        <D.25192>:
        <D.25190>:
      }
      D.20676 = __result;
    }
    iftmp.10 = -D.20676;
    goto <D.25210>;
    <D.25186>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.10 = __builtin_strcmp (D.24880, "MonoMethod");
    <D.25210>:
    D.20677 = iftmp.10;
  }
  if (D.20677 == 0) goto <D.25182>; else goto <D.25211>;
  <D.25211>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25060 = "MonoCMethod";
      D.25061 = MEM[(const unsigned char *)D.25060];
      D.25062 = (int) D.25061;
      D.25215 = *__s2;
      D.25216 = (int) D.25215;
      __result = D.25062 - D.25216;
      {
        if (__s2_len != 0) goto <D.25217>; else goto <D.25218>;
        <D.25217>:
        if (__result == 0) goto <D.25219>; else goto <D.25220>;
        <D.25219>:
        D.25069 = &MEM[(void *)"MonoCMethod" + 1B];
        D.25070 = *D.25069;
        D.25071 = (int) D.25070;
        D.25221 = __s2 + 1;
        D.25222 = *D.25221;
        D.25223 = (int) D.25222;
        __result = D.25071 - D.25223;
        if (__s2_len > 1) goto <D.25224>; else goto <D.25225>;
        <D.25224>:
        if (__result == 0) goto <D.25226>; else goto <D.25227>;
        <D.25226>:
        D.25079 = &MEM[(void *)"MonoCMethod" + 2B];
        D.25080 = *D.25079;
        D.25081 = (int) D.25080;
        D.25228 = __s2 + 2;
        D.25229 = *D.25228;
        D.25230 = (int) D.25229;
        __result = D.25081 - D.25230;
        if (__s2_len > 2) goto <D.25231>; else goto <D.25232>;
        <D.25231>:
        if (__result == 0) goto <D.25233>; else goto <D.25234>;
        <D.25233>:
        D.25089 = &MEM[(void *)"MonoCMethod" + 3B];
        D.25090 = *D.25089;
        D.25091 = (int) D.25090;
        D.25235 = __s2 + 3;
        D.25236 = *D.25235;
        D.25237 = (int) D.25236;
        __result = D.25091 - D.25237;
        <D.25234>:
        <D.25232>:
        <D.25227>:
        <D.25225>:
        <D.25220>:
        <D.25218>:
      }
      D.20685 = __result;
    }
    iftmp.11 = -D.20685;
    goto <D.25238>;
    <D.25214>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.11 = __builtin_strcmp (D.24880, "MonoCMethod");
    <D.25238>:
    D.20686 = iftmp.11;
  }
  if (D.20686 == 0) goto <D.25182>; else goto <D.25239>;
  <D.25239>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25243 = "MonoGenericMethod";
      D.25244 = MEM[(const unsigned char *)D.25243];
      D.25245 = (int) D.25244;
      D.25246 = *__s2;
      D.25247 = (int) D.25246;
      __result = D.25245 - D.25247;
      {
        if (__s2_len != 0) goto <D.25248>; else goto <D.25249>;
        <D.25248>:
        if (__result == 0) goto <D.25250>; else goto <D.25251>;
        <D.25250>:
        D.25252 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.25253 = *D.25252;
        D.25254 = (int) D.25253;
        D.25255 = __s2 + 1;
        D.25256 = *D.25255;
        D.25257 = (int) D.25256;
        __result = D.25254 - D.25257;
        if (__s2_len > 1) goto <D.25258>; else goto <D.25259>;
        <D.25258>:
        if (__result == 0) goto <D.25260>; else goto <D.25261>;
        <D.25260>:
        D.25262 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.25263 = *D.25262;
        D.25264 = (int) D.25263;
        D.25265 = __s2 + 2;
        D.25266 = *D.25265;
        D.25267 = (int) D.25266;
        __result = D.25264 - D.25267;
        if (__s2_len > 2) goto <D.25268>; else goto <D.25269>;
        <D.25268>:
        if (__result == 0) goto <D.25270>; else goto <D.25271>;
        <D.25270>:
        D.25272 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.25273 = *D.25272;
        D.25274 = (int) D.25273;
        D.25275 = __s2 + 3;
        D.25276 = *D.25275;
        D.25277 = (int) D.25276;
        __result = D.25274 - D.25277;
        <D.25271>:
        <D.25269>:
        <D.25261>:
        <D.25259>:
        <D.25251>:
        <D.25249>:
      }
      D.20694 = __result;
    }
    iftmp.12 = -D.20694;
    goto <D.25278>;
    <D.25242>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.12 = __builtin_strcmp (D.24880, "MonoGenericMethod");
    <D.25278>:
    D.20695 = iftmp.12;
  }
  if (D.20695 == 0) goto <D.25182>; else goto <D.25279>;
  <D.25279>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25283 = "MonoGenericCMethod";
      D.25284 = MEM[(const unsigned char *)D.25283];
      D.25285 = (int) D.25284;
      D.25286 = *__s2;
      D.25287 = (int) D.25286;
      __result = D.25285 - D.25287;
      {
        if (__s2_len != 0) goto <D.25288>; else goto <D.25289>;
        <D.25288>:
        if (__result == 0) goto <D.25290>; else goto <D.25291>;
        <D.25290>:
        D.25292 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.25293 = *D.25292;
        D.25294 = (int) D.25293;
        D.25295 = __s2 + 1;
        D.25296 = *D.25295;
        D.25297 = (int) D.25296;
        __result = D.25294 - D.25297;
        if (__s2_len > 1) goto <D.25298>; else goto <D.25299>;
        <D.25298>:
        if (__result == 0) goto <D.25300>; else goto <D.25301>;
        <D.25300>:
        D.25302 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.25303 = *D.25302;
        D.25304 = (int) D.25303;
        D.25305 = __s2 + 2;
        D.25306 = *D.25305;
        D.25307 = (int) D.25306;
        __result = D.25304 - D.25307;
        if (__s2_len > 2) goto <D.25308>; else goto <D.25309>;
        <D.25308>:
        if (__result == 0) goto <D.25310>; else goto <D.25311>;
        <D.25310>:
        D.25312 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.25313 = *D.25312;
        D.25314 = (int) D.25313;
        D.25315 = __s2 + 3;
        D.25316 = *D.25315;
        D.25317 = (int) D.25316;
        __result = D.25314 - D.25317;
        <D.25311>:
        <D.25309>:
        <D.25301>:
        <D.25299>:
        <D.25291>:
        <D.25289>:
      }
      D.20703 = __result;
    }
    iftmp.13 = -D.20703;
    goto <D.25318>;
    <D.25282>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.13 = __builtin_strcmp (D.24880, "MonoGenericCMethod");
    <D.25318>:
    D.20704 = iftmp.13;
  }
  if (D.20704 == 0) goto <D.25182>; else goto <D.25183>;
  <D.25182>:
  {
    struct MonoMethod * m;

    D.24841 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24841].method;
    D.25322 = m->klass;
    D.25323 = D.25322->generic_class;
    if (D.25323 == 0B) goto <D.25324>; else goto <D.25320>;
    <D.25324>:
    D.25322 = m->klass;
    D.25325 = D.25322->generic_container;
    if (D.25325 == 0B) goto <D.25326>; else goto <D.25320>;
    <D.25326>:
    iftmp.14 = 1;
    goto <D.25321>;
    <D.25320>:
    iftmp.14 = 0;
    <D.25321>:
    D.25327 = iftmp.14 != 0;
    D.25328 = (long int) D.25327;
    D.25329 = __builtin_expect (D.25328, 0);
    if (D.25329 != 0) goto <D.25330>; else goto <D.25331>;
    <D.25330>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4270, "m->klass->generic_class || m->klass->generic_container");
    <D.25331>:
    // predicted unlikely by continue predictor.
    goto <D.20706>;
  }
  <D.25183>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24844 = "FieldBuilder";
      D.24845 = MEM[(const unsigned char *)D.24844];
      D.24846 = (int) D.24845;
      D.25335 = *__s2;
      D.25336 = (int) D.25335;
      __result = D.24846 - D.25336;
      {
        if (__s2_len != 0) goto <D.25337>; else goto <D.25338>;
        <D.25337>:
        if (__result == 0) goto <D.25339>; else goto <D.25340>;
        <D.25339>:
        D.24853 = &MEM[(void *)"FieldBuilder" + 1B];
        D.24854 = *D.24853;
        D.24855 = (int) D.24854;
        D.25341 = __s2 + 1;
        D.25342 = *D.25341;
        D.25343 = (int) D.25342;
        __result = D.24855 - D.25343;
        if (__s2_len > 1) goto <D.25344>; else goto <D.25345>;
        <D.25344>:
        if (__result == 0) goto <D.25346>; else goto <D.25347>;
        <D.25346>:
        D.24863 = &MEM[(void *)"FieldBuilder" + 2B];
        D.24864 = *D.24863;
        D.24865 = (int) D.24864;
        D.25348 = __s2 + 2;
        D.25349 = *D.25348;
        D.25350 = (int) D.25349;
        __result = D.24865 - D.25350;
        if (__s2_len > 2) goto <D.25351>; else goto <D.25352>;
        <D.25351>:
        if (__result == 0) goto <D.25353>; else goto <D.25354>;
        <D.25353>:
        D.24873 = &MEM[(void *)"FieldBuilder" + 3B];
        D.24874 = *D.24873;
        D.24875 = (int) D.24874;
        D.25355 = __s2 + 3;
        D.25356 = *D.25355;
        D.25357 = (int) D.25356;
        __result = D.24875 - D.25357;
        <D.25354>:
        <D.25352>:
        <D.25347>:
        <D.25345>:
        <D.25340>:
        <D.25338>:
      }
      D.20714 = __result;
    }
    iftmp.15 = -D.20714;
    goto <D.25358>;
    <D.25334>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.15 = __builtin_strcmp (D.24880, "FieldBuilder");
    <D.25358>:
    D.20715 = iftmp.15;
  }
  if (D.20715 == 0) goto <D.25359>; else goto <D.25360>;
  <D.25359>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25360>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24888 = "MonoField";
      D.24889 = MEM[(const unsigned char *)D.24888];
      D.24890 = (int) D.24889;
      D.25364 = *__s2;
      D.25365 = (int) D.25364;
      __result = D.24890 - D.25365;
      {
        if (__s2_len != 0) goto <D.25366>; else goto <D.25367>;
        <D.25366>:
        if (__result == 0) goto <D.25368>; else goto <D.25369>;
        <D.25368>:
        D.24897 = &MEM[(void *)"MonoField" + 1B];
        D.24898 = *D.24897;
        D.24899 = (int) D.24898;
        D.25370 = __s2 + 1;
        D.25371 = *D.25370;
        D.25372 = (int) D.25371;
        __result = D.24899 - D.25372;
        if (__s2_len > 1) goto <D.25373>; else goto <D.25374>;
        <D.25373>:
        if (__result == 0) goto <D.25375>; else goto <D.25376>;
        <D.25375>:
        D.24907 = &MEM[(void *)"MonoField" + 2B];
        D.24908 = *D.24907;
        D.24909 = (int) D.24908;
        D.25377 = __s2 + 2;
        D.25378 = *D.25377;
        D.25379 = (int) D.25378;
        __result = D.24909 - D.25379;
        if (__s2_len > 2) goto <D.25380>; else goto <D.25381>;
        <D.25380>:
        if (__result == 0) goto <D.25382>; else goto <D.25383>;
        <D.25382>:
        D.24917 = &MEM[(void *)"MonoField" + 3B];
        D.24918 = *D.24917;
        D.24919 = (int) D.24918;
        D.25384 = __s2 + 3;
        D.25385 = *D.25384;
        D.25386 = (int) D.25385;
        __result = D.24919 - D.25386;
        <D.25383>:
        <D.25381>:
        <D.25376>:
        <D.25374>:
        <D.25369>:
        <D.25367>:
      }
      D.20723 = __result;
    }
    iftmp.16 = -D.20723;
    goto <D.25387>;
    <D.25363>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.16 = __builtin_strcmp (D.24880, "MonoField");
    <D.25387>:
    D.20724 = iftmp.16;
  }
  if (D.20724 == 0) goto <D.25388>; else goto <D.25389>;
  <D.25388>:
  {
    struct MonoClassField * f;

    D.24841 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.24841].field;
    D.25390 = is_field_on_inst (f);
    D.25391 = D.25390 == 0;
    D.25392 = (long int) D.25391;
    D.25393 = __builtin_expect (D.25392, 0);
    if (D.25393 != 0) goto <D.25394>; else goto <D.25395>;
    <D.25394>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4276, "is_field_on_inst (f)");
    <D.25395>:
    // predicted unlikely by continue predictor.
    goto <D.20706>;
  }
  <D.25389>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24933 = "MethodBuilder";
      D.24934 = MEM[(const unsigned char *)D.24933];
      D.24935 = (int) D.24934;
      D.25401 = *__s2;
      D.25402 = (int) D.25401;
      __result = D.24935 - D.25402;
      {
        if (__s2_len != 0) goto <D.25403>; else goto <D.25404>;
        <D.25403>:
        if (__result == 0) goto <D.25405>; else goto <D.25406>;
        <D.25405>:
        D.24942 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24943 = *D.24942;
        D.24944 = (int) D.24943;
        D.25407 = __s2 + 1;
        D.25408 = *D.25407;
        D.25409 = (int) D.25408;
        __result = D.24944 - D.25409;
        if (__s2_len > 1) goto <D.25410>; else goto <D.25411>;
        <D.25410>:
        if (__result == 0) goto <D.25412>; else goto <D.25413>;
        <D.25412>:
        D.24952 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24953 = *D.24952;
        D.24954 = (int) D.24953;
        D.25414 = __s2 + 2;
        D.25415 = *D.25414;
        D.25416 = (int) D.25415;
        __result = D.24954 - D.25416;
        if (__s2_len > 2) goto <D.25417>; else goto <D.25418>;
        <D.25417>:
        if (__result == 0) goto <D.25419>; else goto <D.25420>;
        <D.25419>:
        D.24962 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24963 = *D.24962;
        D.24964 = (int) D.24963;
        D.25421 = __s2 + 3;
        D.25422 = *D.25421;
        D.25423 = (int) D.25422;
        __result = D.24964 - D.25423;
        <D.25420>:
        <D.25418>:
        <D.25413>:
        <D.25411>:
        <D.25406>:
        <D.25404>:
      }
      D.20733 = __result;
    }
    iftmp.17 = -D.20733;
    goto <D.25424>;
    <D.25400>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.17 = __builtin_strcmp (D.24880, "MethodBuilder");
    <D.25424>:
    D.20734 = iftmp.17;
  }
  if (D.20734 == 0) goto <D.25396>; else goto <D.25425>;
  <D.25425>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24975 = "ConstructorBuilder";
      D.24976 = MEM[(const unsigned char *)D.24975];
      D.24977 = (int) D.24976;
      D.25429 = *__s2;
      D.25430 = (int) D.25429;
      __result = D.24977 - D.25430;
      {
        if (__s2_len != 0) goto <D.25431>; else goto <D.25432>;
        <D.25431>:
        if (__result == 0) goto <D.25433>; else goto <D.25434>;
        <D.25433>:
        D.24984 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24985 = *D.24984;
        D.24986 = (int) D.24985;
        D.25435 = __s2 + 1;
        D.25436 = *D.25435;
        D.25437 = (int) D.25436;
        __result = D.24986 - D.25437;
        if (__s2_len > 1) goto <D.25438>; else goto <D.25439>;
        <D.25438>:
        if (__result == 0) goto <D.25440>; else goto <D.25441>;
        <D.25440>:
        D.24994 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24995 = *D.24994;
        D.24996 = (int) D.24995;
        D.25442 = __s2 + 2;
        D.25443 = *D.25442;
        D.25444 = (int) D.25443;
        __result = D.24996 - D.25444;
        if (__s2_len > 2) goto <D.25445>; else goto <D.25446>;
        <D.25445>:
        if (__result == 0) goto <D.25447>; else goto <D.25448>;
        <D.25447>:
        D.25004 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.25005 = *D.25004;
        D.25006 = (int) D.25005;
        D.25449 = __s2 + 3;
        D.25450 = *D.25449;
        D.25451 = (int) D.25450;
        __result = D.25006 - D.25451;
        <D.25448>:
        <D.25446>:
        <D.25441>:
        <D.25439>:
        <D.25434>:
        <D.25432>:
      }
      D.20742 = __result;
    }
    iftmp.18 = -D.20742;
    goto <D.25452>;
    <D.25428>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.18 = __builtin_strcmp (D.24880, "ConstructorBuilder");
    <D.25452>:
    D.20743 = iftmp.18;
  }
  if (D.20743 == 0) goto <D.25396>; else goto <D.25397>;
  <D.25396>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25397>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25456 = "FieldOnTypeBuilderInst";
      D.25457 = MEM[(const unsigned char *)D.25456];
      D.25458 = (int) D.25457;
      D.25459 = *__s2;
      D.25460 = (int) D.25459;
      __result = D.25458 - D.25460;
      {
        if (__s2_len != 0) goto <D.25461>; else goto <D.25462>;
        <D.25461>:
        if (__result == 0) goto <D.25463>; else goto <D.25464>;
        <D.25463>:
        D.25465 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.25466 = *D.25465;
        D.25467 = (int) D.25466;
        D.25468 = __s2 + 1;
        D.25469 = *D.25468;
        D.25470 = (int) D.25469;
        __result = D.25467 - D.25470;
        if (__s2_len > 1) goto <D.25471>; else goto <D.25472>;
        <D.25471>:
        if (__result == 0) goto <D.25473>; else goto <D.25474>;
        <D.25473>:
        D.25475 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.25476 = *D.25475;
        D.25477 = (int) D.25476;
        D.25478 = __s2 + 2;
        D.25479 = *D.25478;
        D.25480 = (int) D.25479;
        __result = D.25477 - D.25480;
        if (__s2_len > 2) goto <D.25481>; else goto <D.25482>;
        <D.25481>:
        if (__result == 0) goto <D.25483>; else goto <D.25484>;
        <D.25483>:
        D.25485 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.25486 = *D.25485;
        D.25487 = (int) D.25486;
        D.25488 = __s2 + 3;
        D.25489 = *D.25488;
        D.25490 = (int) D.25489;
        __result = D.25487 - D.25490;
        <D.25484>:
        <D.25482>:
        <D.25474>:
        <D.25472>:
        <D.25464>:
        <D.25462>:
      }
      D.20751 = __result;
    }
    iftmp.19 = -D.20751;
    goto <D.25491>;
    <D.25455>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.19 = __builtin_strcmp (D.24880, "FieldOnTypeBuilderInst");
    <D.25491>:
    D.20752 = iftmp.19;
  }
  if (D.20752 == 0) goto <D.25492>; else goto <D.25493>;
  <D.25492>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25493>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25497 = "MethodOnTypeBuilderInst";
      D.25498 = MEM[(const unsigned char *)D.25497];
      D.25499 = (int) D.25498;
      D.25500 = *__s2;
      D.25501 = (int) D.25500;
      __result = D.25499 - D.25501;
      {
        if (__s2_len != 0) goto <D.25502>; else goto <D.25503>;
        <D.25502>:
        if (__result == 0) goto <D.25504>; else goto <D.25505>;
        <D.25504>:
        D.25506 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.25507 = *D.25506;
        D.25508 = (int) D.25507;
        D.25509 = __s2 + 1;
        D.25510 = *D.25509;
        D.25511 = (int) D.25510;
        __result = D.25508 - D.25511;
        if (__s2_len > 1) goto <D.25512>; else goto <D.25513>;
        <D.25512>:
        if (__result == 0) goto <D.25514>; else goto <D.25515>;
        <D.25514>:
        D.25516 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.25517 = *D.25516;
        D.25518 = (int) D.25517;
        D.25519 = __s2 + 2;
        D.25520 = *D.25519;
        D.25521 = (int) D.25520;
        __result = D.25518 - D.25521;
        if (__s2_len > 2) goto <D.25522>; else goto <D.25523>;
        <D.25522>:
        if (__result == 0) goto <D.25524>; else goto <D.25525>;
        <D.25524>:
        D.25526 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.25527 = *D.25526;
        D.25528 = (int) D.25527;
        D.25529 = __s2 + 3;
        D.25530 = *D.25529;
        D.25531 = (int) D.25530;
        __result = D.25528 - D.25531;
        <D.25525>:
        <D.25523>:
        <D.25515>:
        <D.25513>:
        <D.25505>:
        <D.25503>:
      }
      D.20760 = __result;
    }
    iftmp.20 = -D.20760;
    goto <D.25532>;
    <D.25496>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.20 = __builtin_strcmp (D.24880, "MethodOnTypeBuilderInst");
    <D.25532>:
    D.20761 = iftmp.20;
  }
  if (D.20761 == 0) goto <D.25533>; else goto <D.25534>;
  <D.25533>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25534>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25538 = "ConstructorOnTypeBuilderInst";
      D.25539 = MEM[(const unsigned char *)D.25538];
      D.25540 = (int) D.25539;
      D.25541 = *__s2;
      D.25542 = (int) D.25541;
      __result = D.25540 - D.25542;
      {
        if (__s2_len != 0) goto <D.25543>; else goto <D.25544>;
        <D.25543>:
        if (__result == 0) goto <D.25545>; else goto <D.25546>;
        <D.25545>:
        D.25547 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.25548 = *D.25547;
        D.25549 = (int) D.25548;
        D.25550 = __s2 + 1;
        D.25551 = *D.25550;
        D.25552 = (int) D.25551;
        __result = D.25549 - D.25552;
        if (__s2_len > 1) goto <D.25553>; else goto <D.25554>;
        <D.25553>:
        if (__result == 0) goto <D.25555>; else goto <D.25556>;
        <D.25555>:
        D.25557 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.25558 = *D.25557;
        D.25559 = (int) D.25558;
        D.25560 = __s2 + 2;
        D.25561 = *D.25560;
        D.25562 = (int) D.25561;
        __result = D.25559 - D.25562;
        if (__s2_len > 2) goto <D.25563>; else goto <D.25564>;
        <D.25563>:
        if (__result == 0) goto <D.25565>; else goto <D.25566>;
        <D.25565>:
        D.25567 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.25568 = *D.25567;
        D.25569 = (int) D.25568;
        D.25570 = __s2 + 3;
        D.25571 = *D.25570;
        D.25572 = (int) D.25571;
        __result = D.25569 - D.25572;
        <D.25566>:
        <D.25564>:
        <D.25556>:
        <D.25554>:
        <D.25546>:
        <D.25544>:
      }
      D.20769 = __result;
    }
    iftmp.21 = -D.20769;
    goto <D.25573>;
    <D.25537>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.21 = __builtin_strcmp (D.24880, "ConstructorOnTypeBuilderInst");
    <D.25573>:
    D.20770 = iftmp.21;
  }
  if (D.20770 == 0) goto <D.25574>; else goto <D.25575>;
  <D.25574>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25575>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4288);
  <D.25181>:
  goto <D.20610>;
  <D.20771>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25243 = "MonoGenericMethod";
      D.25244 = MEM[(const unsigned char *)D.25243];
      D.25245 = (int) D.25244;
      D.25579 = *__s2;
      D.25580 = (int) D.25579;
      __result = D.25245 - D.25580;
      {
        if (__s2_len != 0) goto <D.25581>; else goto <D.25582>;
        <D.25581>:
        if (__result == 0) goto <D.25583>; else goto <D.25584>;
        <D.25583>:
        D.25252 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.25253 = *D.25252;
        D.25254 = (int) D.25253;
        D.25585 = __s2 + 1;
        D.25586 = *D.25585;
        D.25587 = (int) D.25586;
        __result = D.25254 - D.25587;
        if (__s2_len > 1) goto <D.25588>; else goto <D.25589>;
        <D.25588>:
        if (__result == 0) goto <D.25590>; else goto <D.25591>;
        <D.25590>:
        D.25262 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.25263 = *D.25262;
        D.25264 = (int) D.25263;
        D.25592 = __s2 + 2;
        D.25593 = *D.25592;
        D.25594 = (int) D.25593;
        __result = D.25264 - D.25594;
        if (__s2_len > 2) goto <D.25595>; else goto <D.25596>;
        <D.25595>:
        if (__result == 0) goto <D.25597>; else goto <D.25598>;
        <D.25597>:
        D.25272 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.25273 = *D.25272;
        D.25274 = (int) D.25273;
        D.25599 = __s2 + 3;
        D.25600 = *D.25599;
        D.25601 = (int) D.25600;
        __result = D.25274 - D.25601;
        <D.25598>:
        <D.25596>:
        <D.25591>:
        <D.25589>:
        <D.25584>:
        <D.25582>:
      }
      D.20779 = __result;
    }
    iftmp.22 = -D.20779;
    goto <D.25602>;
    <D.25578>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.22 = __builtin_strcmp (D.24880, "MonoGenericMethod");
    <D.25602>:
    D.20780 = iftmp.22;
  }
  if (D.20780 == 0) goto <D.25603>; else goto <D.25604>;
  <D.25603>:
  {
    struct MonoMethod * m;

    D.24841 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24841].method;
    D.25605 = mono_method_signature (m);
    D.25606 = D.25605->generic_param_count;
    D.25607 = D.25606 == 0;
    D.25608 = (long int) D.25607;
    D.25609 = __builtin_expect (D.25608, 0);
    if (D.25609 != 0) goto <D.25610>; else goto <D.25611>;
    <D.25610>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4294, "mono_method_signature (m)->generic_param_count");
    <D.25611>:
    // predicted unlikely by continue predictor.
    goto <D.20706>;
  }
  <D.25604>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.24933 = "MethodBuilder";
      D.24934 = MEM[(const unsigned char *)D.24933];
      D.24935 = (int) D.24934;
      D.25615 = *__s2;
      D.25616 = (int) D.25615;
      __result = D.24935 - D.25616;
      {
        if (__s2_len != 0) goto <D.25617>; else goto <D.25618>;
        <D.25617>:
        if (__result == 0) goto <D.25619>; else goto <D.25620>;
        <D.25619>:
        D.24942 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24943 = *D.24942;
        D.24944 = (int) D.24943;
        D.25621 = __s2 + 1;
        D.25622 = *D.25621;
        D.25623 = (int) D.25622;
        __result = D.24944 - D.25623;
        if (__s2_len > 1) goto <D.25624>; else goto <D.25625>;
        <D.25624>:
        if (__result == 0) goto <D.25626>; else goto <D.25627>;
        <D.25626>:
        D.24952 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24953 = *D.24952;
        D.24954 = (int) D.24953;
        D.25628 = __s2 + 2;
        D.25629 = *D.25628;
        D.25630 = (int) D.25629;
        __result = D.24954 - D.25630;
        if (__s2_len > 2) goto <D.25631>; else goto <D.25632>;
        <D.25631>:
        if (__result == 0) goto <D.25633>; else goto <D.25634>;
        <D.25633>:
        D.24962 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24963 = *D.24962;
        D.24964 = (int) D.24963;
        D.25635 = __s2 + 3;
        D.25636 = *D.25635;
        D.25637 = (int) D.25636;
        __result = D.24964 - D.25637;
        <D.25634>:
        <D.25632>:
        <D.25627>:
        <D.25625>:
        <D.25620>:
        <D.25618>:
      }
      D.20789 = __result;
    }
    iftmp.23 = -D.20789;
    goto <D.25638>;
    <D.25614>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.23 = __builtin_strcmp (D.24880, "MethodBuilder");
    <D.25638>:
    D.20790 = iftmp.23;
  }
  if (D.20790 == 0) goto <D.25639>; else goto <D.25640>;
  <D.25639>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25640>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24841 = iltoken->member;
      D.24842 = D.24841->vtable;
      D.24843 = D.24842->klass;
      __s2 = D.24843->name;
      D.25497 = "MethodOnTypeBuilderInst";
      D.25498 = MEM[(const unsigned char *)D.25497];
      D.25499 = (int) D.25498;
      D.25644 = *__s2;
      D.25645 = (int) D.25644;
      __result = D.25499 - D.25645;
      {
        if (__s2_len != 0) goto <D.25646>; else goto <D.25647>;
        <D.25646>:
        if (__result == 0) goto <D.25648>; else goto <D.25649>;
        <D.25648>:
        D.25506 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.25507 = *D.25506;
        D.25508 = (int) D.25507;
        D.25650 = __s2 + 1;
        D.25651 = *D.25650;
        D.25652 = (int) D.25651;
        __result = D.25508 - D.25652;
        if (__s2_len > 1) goto <D.25653>; else goto <D.25654>;
        <D.25653>:
        if (__result == 0) goto <D.25655>; else goto <D.25656>;
        <D.25655>:
        D.25516 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.25517 = *D.25516;
        D.25518 = (int) D.25517;
        D.25657 = __s2 + 2;
        D.25658 = *D.25657;
        D.25659 = (int) D.25658;
        __result = D.25518 - D.25659;
        if (__s2_len > 2) goto <D.25660>; else goto <D.25661>;
        <D.25660>:
        if (__result == 0) goto <D.25662>; else goto <D.25663>;
        <D.25662>:
        D.25526 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.25527 = *D.25526;
        D.25528 = (int) D.25527;
        D.25664 = __s2 + 3;
        D.25665 = *D.25664;
        D.25666 = (int) D.25665;
        __result = D.25528 - D.25666;
        <D.25663>:
        <D.25661>:
        <D.25656>:
        <D.25654>:
        <D.25649>:
        <D.25647>:
      }
      D.20798 = __result;
    }
    iftmp.24 = -D.20798;
    goto <D.25667>;
    <D.25643>:
    D.24841 = iltoken->member;
    D.24842 = D.24841->vtable;
    D.24843 = D.24842->klass;
    D.24880 = D.24843->name;
    iftmp.24 = __builtin_strcmp (D.24880, "MethodOnTypeBuilderInst");
    <D.25667>:
    D.20799 = iftmp.24;
  }
  if (D.20799 == 0) goto <D.25668>; else goto <D.25669>;
  <D.25668>:
  // predicted unlikely by continue predictor.
  goto <D.20706>;
  <D.25669>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4301);
  <D.20800>:
  D.24835 = target + 3;
  D.24836 = *D.24835;
  D.24837 = (int) D.24836;
  monoeg_g_log (0B, 4, "got unexpected table 0x%02x in fixup", D.24837);
  <D.20801>:
  goto <D.20801>;
  <D.20610>:
  D.25670 = (unsigned char) idx;
  *target = D.25670;
  D.25671 = target + 1;
  D.25672 = idx >> 8;
  D.25673 = (unsigned char) D.25672;
  *D.25671 = D.25673;
  D.25674 = target + 2;
  D.25675 = idx >> 16;
  D.25676 = (unsigned char) D.25675;
  *D.25674 = D.25676;
  <D.20706>:
  i = i + 1;
  <D.20803>:
  D.25677 = ilgen->num_token_fixups;
  D.25678 = (unsigned int) D.25677;
  if (D.25678 > i) goto <D.20802>; else goto <D.20804>;
  <D.20804>:
}


is_field_on_inst (struct MonoClassField * field)
{
  gboolean D.25679;
  int iftmp.25;
  struct MonoClass * D.25683;
  struct MonoGenericClass * D.25684;
  long unsigned int D.25686;
  long unsigned int D.25687;
  struct MonoClassField * D.25689;

  D.25683 = field->parent;
  D.25684 = D.25683->generic_class;
  if (D.25684 != 0B) goto <D.25685>; else goto <D.25681>;
  <D.25685>:
  D.25683 = field->parent;
  D.25684 = D.25683->generic_class;
  D.25686 = BIT_FIELD_REF <*D.25684, 64, 192>;
  D.25687 = D.25686 & 1;
  if (D.25687 != 0) goto <D.25688>; else goto <D.25681>;
  <D.25688>:
  D.25683 = field->parent;
  D.25684 = D.25683->generic_class;
  D.25689 = MEM[(struct MonoDynamicGenericClass *)D.25684].fields;
  if (D.25689 != 0B) goto <D.25690>; else goto <D.25681>;
  <D.25690>:
  iftmp.25 = 1;
  goto <D.25682>;
  <D.25681>:
  iftmp.25 = 0;
  <D.25682>:
  D.25679 = iftmp.25;
  return D.25679;
}


compare_types_by_table_idx (struct MonoReflectionTypeBuilder * * type1, struct MonoReflectionTypeBuilder * * type2)
{
  struct MonoReflectionTypeBuilder * D.25692;
  unsigned int D.25693;
  struct MonoReflectionTypeBuilder * D.25694;
  unsigned int D.25695;
  gint D.25698;

  D.25692 = *type1;
  D.25693 = D.25692->table_idx;
  D.25694 = *type2;
  D.25695 = D.25694->table_idx;
  if (D.25693 < D.25695) goto <D.25696>; else goto <D.25697>;
  <D.25696>:
  D.25698 = -1;
  return D.25698;
  <D.25697>:
  D.25692 = *type1;
  D.25693 = D.25692->table_idx;
  D.25694 = *type2;
  D.25695 = D.25694->table_idx;
  if (D.25693 > D.25695) goto <D.25699>; else goto <D.25700>;
  <D.25699>:
  D.25698 = 1;
  return D.25698;
  <D.25700>:
  D.25698 = 0;
  return D.25698;
}


mono_image_emit_manifest (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.25702;
  guint32 * D.25703;
  guint32 iftmp.26;
  unsigned int D.25705;
  guint32 * D.25709;
  struct MonoDynamicStream * D.25710;
  struct MonoString * D.25711;
  unsigned int D.25712;
  struct MonoString * D.25713;
  guint32 * D.25716;
  unsigned int D.25717;
  unsigned int D.25719;
  guint32 * D.25720;
  struct MonoArray * D.25721;
  unsigned int D.25722;
  guint32 * D.25723;
  unsigned int D.25724;
  struct MonoString * D.25725;
  struct MonoArray * D.25726;
  long unsigned int D.25727;
  char * D.25728;
  struct MonoArray * D.25731;
  long unsigned int D.25734;
  char * D.25735;
  int D.25736;
  long unsigned int D.25737;
  struct MonoArray * D.25738;
  char * D.25741;
  long unsigned int D.25742;
  struct MonoArray * D.25743;
  char * D.25746;
  struct MonoArray * D.25749;
  long unsigned int D.25752;
  long unsigned int D.25753;
  unsigned int D.25754;
  long unsigned int D.25755;
  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.25702 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.25702->domain;
  table = &assembly->tables[32];
  alloc_table (table, 1);
  D.25703 = table->values;
  values = D.25703 + 36;
  D.25705 = assemblyb->algid;
  if (D.25705 != 0) goto <D.25706>; else goto <D.25707>;
  <D.25706>:
  iftmp.26 = assemblyb->algid;
  goto <D.25708>;
  <D.25707>:
  iftmp.26 = 32772;
  <D.25708>:
  *values = iftmp.26;
  D.25709 = values + 28;
  D.25710 = &assembly->sheap;
  D.25711 = assemblyb->name;
  D.25712 = string_heap_insert_mstring (D.25710, D.25711);
  *D.25709 = D.25712;
  D.25713 = assemblyb->culture;
  if (D.25713 != 0B) goto <D.25714>; else goto <D.25715>;
  <D.25714>:
  D.25716 = values + 32;
  D.25710 = &assembly->sheap;
  D.25713 = assemblyb->culture;
  D.25717 = string_heap_insert_mstring (D.25710, D.25713);
  *D.25716 = D.25717;
  goto <D.25718>;
  <D.25715>:
  D.25716 = values + 32;
  D.25710 = &assembly->sheap;
  D.25719 = string_heap_insert (D.25710, "");
  *D.25716 = D.25719;
  <D.25718>:
  D.25720 = values + 24;
  D.25721 = assemblyb->public_key;
  D.25722 = load_public_key (D.25721, assembly);
  *D.25720 = D.25722;
  D.25723 = values + 20;
  D.25724 = assemblyb->flags;
  *D.25723 = D.25724;
  D.25725 = assemblyb->version;
  set_version_from_string (D.25725, values);
  module_index = 0;
  i = 0;
  goto <D.20902>;
  <D.20901>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.25726 = assemblyb->modules;
    D.25727 = (long unsigned int) i;
    D.25728 = mono_array_addr_with_size (D.25726, 8, D.25727);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.25728];
    if (file_module != moduleb) goto <D.25729>; else goto <D.25730>;
    <D.25729>:
    mono_image_fill_file_table (domain, file_module, assembly);
    module_index = module_index + 1;
    D.25731 = file_module->types;
    if (D.25731 != 0B) goto <D.25732>; else goto <D.25733>;
    <D.25732>:
    j = 0;
    goto <D.20899>;
    <D.20898>:
    {
      struct MonoReflectionTypeBuilder * tb;

      D.25731 = file_module->types;
      D.25734 = (long unsigned int) j;
      D.25735 = mono_array_addr_with_size (D.25731, 8, D.25734);
      tb = MEM[(struct MonoReflectionTypeBuilder * *)D.25735];
      mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
    }
    j = j + 1;
    <D.20899>:
    D.25736 = file_module->num_types;
    if (D.25736 > j) goto <D.20898>; else goto <D.20900>;
    <D.20900>:
    <D.25733>:
    <D.25730>:
  }
  i = i + 1;
  <D.20902>:
  D.25727 = (long unsigned int) i;
  D.25726 = assemblyb->modules;
  D.25737 = mono_array_length (D.25726);
  if (D.25727 < D.25737) goto <D.20901>; else goto <D.20903>;
  <D.20903>:
  D.25738 = assemblyb->loaded_modules;
  if (D.25738 != 0B) goto <D.25739>; else goto <D.25740>;
  <D.25739>:
  i = 0;
  goto <D.20906>;
  <D.20905>:
  {
    struct MonoReflectionModule * file_module;

    D.25738 = assemblyb->loaded_modules;
    D.25727 = (long unsigned int) i;
    D.25741 = mono_array_addr_with_size (D.25738, 8, D.25727);
    file_module = MEM[(struct MonoReflectionModule * *)D.25741];
    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.20906>:
  D.25727 = (long unsigned int) i;
  D.25738 = assemblyb->loaded_modules;
  D.25742 = mono_array_length (D.25738);
  if (D.25727 < D.25742) goto <D.20905>; else goto <D.20907>;
  <D.20907>:
  <D.25740>:
  D.25743 = assemblyb->type_forwarders;
  if (D.25743 != 0B) goto <D.25744>; else goto <D.25745>;
  <D.25744>:
  mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
  <D.25745>:
  module_index = 0;
  i = 0;
  goto <D.20916>;
  <D.20915>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.25726 = assemblyb->modules;
    D.25727 = (long unsigned int) i;
    D.25746 = mono_array_addr_with_size (D.25726, 8, D.25727);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.25746];
    if (file_module != moduleb) goto <D.25747>; else goto <D.25748>;
    <D.25747>:
    module_index = module_index + 1;
    D.25749 = file_module->resources;
    if (D.25749 != 0B) goto <D.25750>; else goto <D.25751>;
    <D.25750>:
    {
      int len;

      D.25749 = file_module->resources;
      D.25752 = mono_array_length (D.25749);
      len = (int) D.25752;
      j = 0;
      goto <D.20913>;
      <D.20912>:
      {
        struct MonoReflectionResource * res;

        D.25749 = file_module->resources;
        D.25753 = (long unsigned int) j;
        res = mono_array_addr_with_size (D.25749, 40, D.25753);
        D.25754 = module_index << 2;
        assembly_add_resource_manifest (file_module, assembly, res, D.25754);
      }
      j = j + 1;
      <D.20913>:
      if (j < len) goto <D.20912>; else goto <D.20914>;
      <D.20914>:
    }
    <D.25751>:
    <D.25748>:
  }
  i = i + 1;
  <D.20916>:
  D.25727 = (long unsigned int) i;
  D.25726 = assemblyb->modules;
  D.25755 = mono_array_length (D.25726);
  if (D.25727 < D.25755) goto <D.20915>; else goto <D.20917>;
  <D.20917>:
}


load_public_key (struct MonoArray * pkey, struct MonoDynamicImage * assembly)
{
  guint32 D.25758;
  unsigned int D.25759;
  char * b.27;
  struct MonoDynamicStream * D.25761;
  long int b.28;
  long int blob_size.29;
  long int D.25764;
  unsigned int D.25765;
  char * D.25766;
  unsigned int D.25767;
  void * D.25768;
  guint8 * D.25769;
  char * D.25770;
  int D.25771;
  char * D.25775;
  int D.25776;
  unsigned int D.25780;
  long unsigned int D.25782;
  long unsigned int D.25783;
  int D.25784;
  unsigned int D.25785;
  long unsigned int D.25786;
  void * D.25787;
  gsize len;
  guint32 token;
  char blob_size[6];
  char * b;

  try
    {
      token = 0;
      b = &blob_size;
      if (pkey == 0B) goto <D.25756>; else goto <D.25757>;
      <D.25756>:
      D.25758 = token;
      return D.25758;
      <D.25757>:
      len = mono_array_length (pkey);
      D.25759 = (unsigned int) len;
      b.27 = b;
      mono_metadata_encode_value (D.25759, b.27, &b);
      D.25761 = &assembly->blob;
      b.27 = b;
      b.28 = (long int) b.27;
      blob_size.29 = (long int) &blob_size;
      D.25764 = b.28 - blob_size.29;
      D.25765 = (unsigned int) D.25764;
      token = mono_image_add_stream_data (D.25761, &blob_size, D.25765);
      D.25761 = &assembly->blob;
      D.25766 = mono_array_addr_with_size (pkey, 1, 0);
      D.25767 = (unsigned int) len;
      mono_image_add_stream_data (D.25761, D.25766, D.25767);
      D.25768 = monoeg_malloc (len);
      assembly->public_key = D.25768;
      D.25769 = assembly->public_key;
      D.25770 = mono_array_addr_with_size (pkey, 1, 0);
      memcpy (D.25769, D.25770, len);
      D.25771 = (int) len;
      assembly->public_key_len = D.25771;
      if (len == 16) goto <D.25774>; else goto <D.25772>;
      <D.25774>:
      D.25775 = mono_array_addr_with_size (pkey, 1, 0);
      D.25771 = (int) len;
      D.25776 = mono_is_ecma_key (D.25775, D.25771);
      if (D.25776 != 0) goto <D.25777>; else goto <D.25772>;
      <D.25777>:
      assembly->strong_name_size = 128;
      goto <D.25773>;
      <D.25772>:
      if (len > 79) goto <D.25778>; else goto <D.25779>;
      <D.25778>:
      D.25767 = (unsigned int) len;
      D.25780 = D.25767 + 4294967264;
      assembly->strong_name_size = D.25780;
      goto <D.25781>;
      <D.25779>:
      D.25782 = len + 18446744073709551584;
      D.25783 = D.25782 << 3;
      D.25784 = (int) D.25783;
      D.25771 = (int) len;
      monoeg_g_log (0B, 16, "Invalid public key length: %d bits (total: %d)", D.25784, D.25771);
      assembly->strong_name_size = 128;
      <D.25781>:
      <D.25773>:
      D.25785 = assembly->strong_name_size;
      D.25786 = (long unsigned int) D.25785;
      D.25787 = monoeg_malloc0 (D.25786);
      assembly->strong_name = D.25787;
      D.25758 = token;
      return D.25758;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.25790;
  unsigned int D.25791;
  int D.25792;
  char * D.25793;
  sizetype D.25794;
  char * D.25795;
  long unsigned int D.25796;
  guint32 D.25797;
  guint32 idx;

  D.25790 = stream->index;
  D.25791 = D.25790 + len;
  D.25792 = (int) D.25791;
  make_room_in_stream (stream, D.25792);
  D.25793 = stream->data;
  D.25790 = stream->index;
  D.25794 = (sizetype) D.25790;
  D.25795 = D.25793 + D.25794;
  D.25796 = (long unsigned int) len;
  memcpy (D.25795, data, D.25796);
  idx = stream->index;
  D.25790 = stream->index;
  D.25791 = D.25790 + len;
  stream->index = D.25791;
  D.25797 = idx;
  return D.25797;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.30;
  unsigned int D.25800;
  unsigned int D.25806;
  char * D.25807;
  long unsigned int D.25808;
  void * D.25809;

  size.30 = (unsigned int) size;
  D.25800 = stream->alloc_size;
  if (size.30 <= D.25800) goto <D.25801>; else goto <D.25802>;
  <D.25801>:
  return;
  <D.25802>:
  goto <D.19239>;
  <D.19238>:
  D.25800 = stream->alloc_size;
  if (D.25800 <= 4095) goto <D.25803>; else goto <D.25804>;
  <D.25803>:
  stream->alloc_size = 4096;
  goto <D.25805>;
  <D.25804>:
  D.25800 = stream->alloc_size;
  D.25806 = D.25800 * 2;
  stream->alloc_size = D.25806;
  <D.25805>:
  <D.19239>:
  D.25800 = stream->alloc_size;
  size.30 = (unsigned int) size;
  if (D.25800 <= size.30) goto <D.19238>; else goto <D.19240>;
  <D.19240>:
  D.25807 = stream->data;
  D.25800 = stream->alloc_size;
  D.25808 = (long unsigned int) D.25800;
  D.25809 = monoeg_realloc (D.25807, D.25808);
  stream->data = D.25809;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25811;
  long unsigned int D.25812;

  D.25812 = __builtin_object_size (__dest, 0);
  D.25811 = __builtin___memcpy_chk (__dest, __src, __len, D.25812);
  return D.25811;
}


set_version_from_string (struct MonoString * version, guint32 * values)
{
  guint32 * D.25814;
  guint32 * D.25815;
  guint32 * D.25816;
  guint32 * D.25817;
  unsigned int D.25820;
  long unsigned int D.25821;
  long unsigned int D.25822;
  guint32 * D.25823;
  long int D.25824;
  unsigned int D.25825;
  gchar * p.31;
  char D.25827;
  int D.25828;
  gchar * p.32;
  gchar * ver;
  gchar * p;
  gchar * str;
  guint32 i;

  try
    {
      D.25814 = values + 4;
      *D.25814 = 0;
      D.25815 = values + 8;
      *D.25815 = 0;
      D.25816 = values + 16;
      *D.25816 = 0;
      D.25817 = values + 12;
      *D.25817 = 0;
      if (version == 0B) goto <D.25818>; else goto <D.25819>;
      <D.25818>:
      return;
      <D.25819>:
      str = mono_string_to_utf8 (version);
      ver = str;
      i = 0;
      goto <D.20875>;
      <D.20874>:
      D.25820 = i + 1;
      D.25821 = (long unsigned int) D.25820;
      D.25822 = D.25821 * 4;
      D.25823 = values + D.25822;
      D.25824 = strtol (ver, &p, 10);
      D.25825 = (unsigned int) D.25824;
      *D.25823 = D.25825;
      p.31 = p;
      D.25827 = *p.31;
      D.25828 = (int) D.25827;
      switch (D.25828) <default: <D.25830>, case 42: <D.20873>, case 46: <D.20871>>
      <D.20871>:
      p.31 = p;
      p.32 = p.31 + 1;
      p = p.32;
      goto <D.20872>;
      <D.20873>:
      p.31 = p;
      p.32 = p.31 + 1;
      p = p.32;
      goto <D.20872>;
      <D.25830>:
      <D.20872>:
      ver = p;
      i = i + 1;
      <D.20875>:
      if (i <= 3) goto <D.20874>; else goto <D.20876>;
      <D.20876>:
      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.25834;
  unsigned int D.25835;
  unsigned int D.25836;
  struct MonoArray * D.25837;
  long unsigned int D.25840;
  char * D.25841;
  struct MonoReflectionTypeBuilder * D.25842;
  long unsigned int D.25843;
  struct MonoClass * klass;
  guint32 idx;
  guint32 i;

  D.25834 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.25834);
  D.25835 = tb->table_idx;
  D.25836 = D.25835 | 33554432;
  klass->type_token = D.25836;
  idx = mono_image_fill_export_table_from_class (domain, klass, module_index, parent_index, assembly);
  D.25837 = tb->subtypes;
  if (D.25837 != 0B) goto <D.25838>; else goto <D.25839>;
  <D.25838>:
  i = 0;
  goto <D.20416>;
  <D.20415>:
  D.25837 = tb->subtypes;
  D.25840 = (long unsigned int) i;
  D.25841 = mono_array_addr_with_size (D.25837, 8, D.25840);
  D.25842 = MEM[(struct MonoReflectionTypeBuilder * *)D.25841];
  mono_image_fill_export_table (domain, D.25842, module_index, idx, assembly);
  i = i + 1;
  <D.20416>:
  D.25840 = (long unsigned int) i;
  D.25837 = tb->subtypes;
  D.25843 = mono_array_length (D.25837);
  if (D.25840 < D.25843) goto <D.20415>; else goto <D.20417>;
  <D.20417>:
  <D.25839>:
}


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.25844;
  unsigned int D.25845;
  guint32 D.25848;
  unsigned int D.25849;
  unsigned int D.25850;
  guint32 * D.25851;
  unsigned int D.25852;
  unsigned int D.25853;
  long unsigned int D.25854;
  long unsigned int D.25855;
  guint32 * D.25856;
  unsigned int D.25857;
  struct MonoClass * D.25858;
  guint32 * D.25861;
  unsigned int D.25862;
  unsigned int D.25863;
  unsigned int D.25865;
  guint32 * D.25866;
  struct MonoDynamicStream * D.25867;
  const char * D.25868;
  unsigned int D.25869;
  guint32 * D.25870;
  const char * D.25871;
  unsigned int D.25872;
  unsigned int D.25873;
  struct MonoClassExt * D.25874;
  struct GList * D.25877;
  void * D.25880;
  unsigned int D.25881;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 visib;
  guint32 res;

  D.25844 = klass->flags;
  visib = D.25844 & 7;
  D.25845 = visib & 3;
  if (D.25845 == 0) goto <D.25846>; else goto <D.25847>;
  <D.25846>:
  D.25848 = 0;
  return D.25848;
  <D.25847>:
  table = &assembly->tables[39];
  D.25849 = table->rows;
  D.25850 = D.25849 + 1;
  table->rows = D.25850;
  D.25849 = table->rows;
  alloc_table (table, D.25849);
  D.25851 = table->values;
  D.25852 = table->next_idx;
  D.25853 = D.25852 * 5;
  D.25854 = (long unsigned int) D.25853;
  D.25855 = D.25854 * 4;
  values = D.25851 + D.25855;
  D.25844 = klass->flags;
  *values = D.25844;
  D.25856 = values + 4;
  D.25857 = klass->type_token;
  *D.25856 = D.25857;
  D.25858 = klass->nested_in;
  if (D.25858 != 0B) goto <D.25859>; else goto <D.25860>;
  <D.25859>:
  D.25861 = values + 16;
  D.25862 = parent_index << 2;
  D.25863 = D.25862 + 2;
  *D.25861 = D.25863;
  goto <D.25864>;
  <D.25860>:
  D.25861 = values + 16;
  D.25865 = module_index << 2;
  *D.25861 = D.25865;
  <D.25864>:
  D.25866 = values + 8;
  D.25867 = &assembly->sheap;
  D.25868 = klass->name;
  D.25869 = string_heap_insert (D.25867, D.25868);
  *D.25866 = D.25869;
  D.25870 = values + 12;
  D.25867 = &assembly->sheap;
  D.25871 = klass->name_space;
  D.25872 = string_heap_insert (D.25867, D.25871);
  *D.25870 = D.25872;
  res = table->next_idx;
  D.25852 = table->next_idx;
  D.25873 = D.25852 + 1;
  table->next_idx = D.25873;
  D.25874 = klass->ext;
  if (D.25874 != 0B) goto <D.25875>; else goto <D.25876>;
  <D.25875>:
  D.25874 = klass->ext;
  D.25877 = D.25874->nested_classes;
  if (D.25877 != 0B) goto <D.25878>; else goto <D.25879>;
  <D.25878>:
  {
    struct GList * tmp;

    D.25874 = klass->ext;
    tmp = D.25874->nested_classes;
    goto <D.20403>;
    <D.20402>:
    D.25880 = tmp->data;
    D.25852 = table->next_idx;
    D.25881 = D.25852 + 4294967295;
    mono_image_fill_export_table_from_class (domain, D.25880, module_index, D.25881, assembly);
    tmp = tmp->next;
    <D.20403>:
    if (tmp != 0B) goto <D.20402>; else goto <D.20404>;
    <D.20404>:
  }
  <D.25879>:
  <D.25876>:
  D.25848 = res;
  return D.25848;
}


mono_image_fill_file_table (struct MonoDomain * domain, struct MonoReflectionModule * module, struct MonoDynamicImage * assembly)
{
  unsigned int D.25883;
  unsigned int D.25884;
  guint32 * D.25885;
  unsigned int D.25886;
  unsigned int D.25887;
  long unsigned int D.25888;
  long unsigned int D.25889;
  guint32 * D.25890;
  struct MonoDynamicStream * D.25891;
  struct MonoImage * D.25892;
  const char * D.25893;
  unsigned int D.25894;
  long unsigned int D.25895;
  long unsigned int D.25896;
  struct MonoReflectionAssemblyBuilder * D.25899;
  struct MonoString * D.25900;
  char * D.25902;
  char * b.33;
  guint32 * D.25904;
  struct MonoDynamicStream * D.25905;
  long int b.34;
  long int blob_size.35;
  long int D.25908;
  unsigned int D.25909;
  unsigned int D.25910;
  unsigned int D.25911;
  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.25883 = table->rows;
      D.25884 = D.25883 + 1;
      table->rows = D.25884;
      D.25883 = table->rows;
      alloc_table (table, D.25883);
      D.25885 = table->values;
      D.25886 = table->next_idx;
      D.25887 = D.25886 * 3;
      D.25888 = (long unsigned int) D.25887;
      D.25889 = D.25888 * 4;
      values = D.25885 + D.25889;
      *values = 0;
      D.25890 = values + 4;
      D.25891 = &assembly->sheap;
      D.25892 = module->image;
      D.25893 = D.25892->module_name;
      D.25894 = string_heap_insert (D.25891, D.25893);
      *D.25890 = D.25894;
      D.25892 = module->image;
      D.25895 = BIT_FIELD_REF <*D.25892, 64, 192>;
      D.25896 = D.25895 & 34359738368;
      if (D.25896 != 0) goto <D.25897>; else goto <D.25898>;
      <D.25897>:
      D.25899 = MEM[(struct MonoReflectionModuleBuilder *)module].assemblyb;
      D.25900 = D.25899->dir;
      dir = mono_string_to_utf8 (D.25900);
      D.25892 = module->image;
      D.25893 = D.25892->module_name;
      path = monoeg_g_strdup_printf ("%s%c%s", dir, 47, D.25893);
      goto <D.25901>;
      <D.25898>:
      dir = 0B;
      D.25892 = module->image;
      D.25902 = D.25892->name;
      path = monoeg_strdup (D.25902);
      <D.25901>:
      mono_sha1_get_digest_from_file (path, &hash);
      monoeg_g_free (dir);
      monoeg_g_free (path);
      b.33 = b;
      mono_metadata_encode_value (20, b.33, &b);
      D.25904 = values + 8;
      D.25905 = &assembly->blob;
      b.33 = b;
      b.34 = (long int) b.33;
      blob_size.35 = (long int) &blob_size;
      D.25908 = b.34 - blob_size.35;
      D.25909 = (unsigned int) D.25908;
      D.25910 = mono_image_add_stream_data (D.25905, &blob_size, D.25909);
      *D.25904 = D.25910;
      D.25905 = &assembly->blob;
      mono_image_add_stream_data (D.25905, &hash, 20);
      D.25886 = table->next_idx;
      D.25911 = D.25886 + 1;
      table->next_idx = D.25911;
    }
  finally
    {
      blob_size = {CLOBBER};
      hash = {CLOBBER};
      b = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.25912>; else goto <D.25913>;
  <D.25912>:
  D.25914 = __strdup (str);
  return D.25914;
  <D.25913>:
  D.25914 = 0B;
  return D.25914;
}


mono_image_fill_export_table_from_module (struct MonoDomain * domain, struct MonoReflectionModule * module, guint32 module_index, struct MonoDynamicImage * assembly)
{
  unsigned int D.25916;
  unsigned int D.25917;
  unsigned int D.25918;
  unsigned int D.25919;
  <unnamed-unsigned:24> D.25922;
  unsigned int D.25923;
  struct MonoImage * image;
  struct MonoTableInfo * t;
  guint32 i;

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

    D.25916 = i + 1;
    D.25917 = D.25916 | 33554432;
    klass = mono_class_get (image, D.25917);
    D.25918 = klass->flags;
    D.25919 = D.25918 & 1;
    if (D.25919 != 0) goto <D.25920>; else goto <D.25921>;
    <D.25920>:
    mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
    <D.25921>:
  }
  i = i + 1;
  <D.20429>:
  D.25922 = t->rows;
  D.25923 = (unsigned int) D.25922;
  if (D.25923 > i) goto <D.20428>; else goto <D.20430>;
  <D.20430>:
}


mono_image_fill_export_table_from_type_forwarders (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.25924;
  long unsigned int D.25927;
  char * D.25928;
  _Bool D.25931;
  long int D.25932;
  long int D.25933;
  long unsigned int D.25936;
  struct MonoClass * klass;
  int i;

  D.25924 = assemblyb->type_forwarders;
  if (D.25924 == 0B) goto <D.25925>; else goto <D.25926>;
  <D.25925>:
  return;
  <D.25926>:
  i = 0;
  goto <D.20459>;
  <D.20458>:
  {
    struct MonoReflectionType * t;
    struct MonoType * type;

    D.25924 = assemblyb->type_forwarders;
    D.25927 = (long unsigned int) i;
    D.25928 = mono_array_addr_with_size (D.25924, 8, D.25927);
    t = MEM[(struct MonoReflectionType * *)D.25928];
    if (t == 0B) goto <D.25929>; else goto <D.25930>;
    <D.25929>:
    // predicted unlikely by continue predictor.
    goto <D.20457>;
    <D.25930>:
    type = mono_reflection_type_get_handle (t);
    D.25931 = type == 0B;
    D.25932 = (long int) D.25931;
    D.25933 = __builtin_expect (D.25932, 0);
    if (D.25933 != 0) goto <D.25934>; else goto <D.25935>;
    <D.25934>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3863, "type");
    <D.25935>:
    klass = mono_class_from_mono_type (type);
    add_exported_type (assemblyb, assembly, klass, 0);
  }
  <D.20457>:
  i = i + 1;
  <D.20459>:
  D.25927 = (long unsigned int) i;
  D.25924 = assemblyb->type_forwarders;
  D.25936 = mono_array_length (D.25924);
  if (D.25927 < D.25936) goto <D.20458>; else goto <D.20460>;
  <D.20460>:
}


add_exported_type (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly, struct MonoClass * klass, guint32 parent_index)
{
  struct MonoClass * D.25938;
  unsigned int D.25941;
  struct MonoImage * D.25943;
  unsigned int D.25944;
  _Bool D.25945;
  long int D.25946;
  long int D.25947;
  unsigned int D.25950;
  unsigned int D.25951;
  unsigned int D.25952;
  guint32 * D.25953;
  unsigned int D.25954;
  long unsigned int D.25955;
  long unsigned int D.25956;
  guint32 iftmp.36;
  guint32 * D.25961;
  guint32 * D.25962;
  guint32 * D.25963;
  struct MonoDynamicStream * D.25964;
  const char * D.25965;
  unsigned int D.25966;
  guint32 * D.25967;
  const char * D.25968;
  unsigned int D.25969;
  unsigned int D.25970;
  unsigned int D.25971;
  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.25938 = klass->nested_in;
      if (D.25938 != 0B) goto <D.25939>; else goto <D.25940>;
      <D.25939>:
      D.25941 = parent_index << 2;
      impl = D.25941 + 2;
      forwarder = 0;
      goto <D.25942>;
      <D.25940>:
      D.25943 = klass->image;
      scope = resolution_scope_from_image (assembly, D.25943);
      D.25944 = scope & 3;
      D.25945 = D.25944 != 2;
      D.25946 = (long int) D.25945;
      D.25947 = __builtin_expect (D.25946, 0);
      if (D.25947 != 0) goto <D.25948>; else goto <D.25949>;
      <D.25948>:
      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.25949>:
      scope_idx = scope >> 2;
      D.25950 = scope_idx << 2;
      impl = D.25950 + 1;
      <D.25942>:
      table = &assembly->tables[39];
      D.25951 = table->rows;
      D.25952 = D.25951 + 1;
      table->rows = D.25952;
      D.25951 = table->rows;
      alloc_table (table, D.25951);
      current_idx = table->next_idx;
      D.25953 = table->values;
      D.25954 = current_idx * 5;
      D.25955 = (long unsigned int) D.25954;
      D.25956 = D.25955 * 4;
      values = D.25953 + D.25956;
      if (forwarder != 0) goto <D.25958>; else goto <D.25959>;
      <D.25958>:
      iftmp.36 = 2097152;
      goto <D.25960>;
      <D.25959>:
      iftmp.36 = 0;
      <D.25960>:
      *values = iftmp.36;
      D.25961 = values + 4;
      *D.25961 = 0;
      D.25962 = values + 16;
      *D.25962 = impl;
      D.25963 = values + 8;
      D.25964 = &assembly->sheap;
      D.25965 = klass->name;
      D.25966 = string_heap_insert (D.25964, D.25965);
      *D.25963 = D.25966;
      D.25967 = values + 12;
      D.25964 = &assembly->sheap;
      D.25968 = klass->name_space;
      D.25969 = string_heap_insert (D.25964, D.25968);
      *D.25967 = D.25969;
      D.25970 = table->next_idx;
      D.25971 = D.25970 + 1;
      table->next_idx = D.25971;
      goto <D.20447>;
      <D.20446>:
      add_exported_type (assemblyb, assembly, nested, current_idx);
      <D.20447>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.20446>; else goto <D.20448>;
      <D.20448>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


resolution_scope_from_image (struct MonoDynamicImage * assembly, struct MonoImage * image)
{
  struct GHashTable * D.25972;
  void * D.25973;
  long int D.25974;
  guint32 D.25977;
  struct MonoAssembly * D.25978;
  unsigned char D.25979;
  struct MonoAssembly * D.25982;
  unsigned int D.25985;
  unsigned int token.37;
  unsigned int D.25987;
  unsigned int D.25988;
  unsigned int D.25989;
  guint32 * D.25990;
  long unsigned int D.25991;
  long unsigned int D.25992;
  struct MonoDynamicStream * D.25993;
  const char * D.25994;
  unsigned int D.25995;
  void * D.25996;
  struct MonoTableInfo * D.26000;
  unsigned int token.38;
  unsigned int D.26002;
  unsigned int D.26003;
  long unsigned int D.26004;
  long unsigned int D.26005;
  guint32 * D.26006;
  const char * D.26007;
  unsigned int D.26008;
  unsigned int D.26009;
  guint32 * D.26010;
  unsigned int D.26011;
  guint32 * D.26012;
  unsigned int D.26013;
  guint32 * D.26014;
  unsigned int D.26015;
  guint32 * D.26016;
  guint32 * D.26017;
  guint32 * D.26018;
  int D.19883;
  int iftmp.39;
  int D.19879;
  const char[1] * D.26022;
  unsigned char D.26023;
  int D.26024;
  unsigned char D.26025;
  int D.26026;
  const unsigned char * D.26031;
  unsigned char D.26032;
  int D.26033;
  const unsigned char * D.26034;
  unsigned char D.26035;
  int D.26036;
  const unsigned char * D.26041;
  unsigned char D.26042;
  int D.26043;
  const unsigned char * D.26044;
  unsigned char D.26045;
  int D.26046;
  const unsigned char * D.26051;
  unsigned char D.26052;
  int D.26053;
  const unsigned char * D.26054;
  unsigned char D.26055;
  int D.26056;
  const char * D.26058;
  unsigned char D.26059;
  int D.26060;
  unsigned int D.26063;
  unsigned int publen.40;
  guint32 * D.26067;
  struct MonoDynamicStream * D.26068;
  unsigned int D.26069;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;
  guint32 cols[9];
  const char * pubkey;
  guint32 publen;

  try
    {
      D.25972 = assembly->handleref;
      D.25973 = monoeg_g_hash_table_lookup (D.25972, image);
      D.25974 = (long int) D.25973;
      token = (guint32) D.25974;
      if (token != 0) goto <D.25975>; else goto <D.25976>;
      <D.25975>:
      D.25977 = token;
      return D.25977;
      <D.25976>:
      D.25978 = image->assembly;
      D.25979 = D.25978->dynamic;
      if (D.25979 != 0) goto <D.25980>; else goto <D.25981>;
      <D.25980>:
      D.25978 = image->assembly;
      D.25982 = assembly->image.assembly;
      if (D.25978 == D.25982) goto <D.25983>; else goto <D.25984>;
      <D.25983>:
      table = &assembly->tables[26];
      D.25985 = table->next_idx;
      token.37 = D.25985;
      D.25987 = token.37 + 1;
      table->next_idx = D.25987;
      token = token.37;
      D.25988 = table->rows;
      D.25989 = D.25988 + 1;
      table->rows = D.25989;
      D.25988 = table->rows;
      alloc_table (table, D.25988);
      D.25990 = table->values;
      D.25991 = (long unsigned int) token;
      D.25992 = D.25991 * 4;
      values = D.25990 + D.25992;
      D.25993 = &assembly->sheap;
      D.25994 = image->module_name;
      D.25995 = string_heap_insert (D.25993, D.25994);
      *values = D.25995;
      token = token << 2;
      token = token | 1;
      D.25972 = assembly->handleref;
      D.25991 = (long unsigned int) token;
      D.25996 = (void *) D.25991;
      monoeg_g_hash_table_insert_replace (D.25972, image, D.25996, 0);
      D.25977 = token;
      return D.25977;
      <D.25984>:
      <D.25981>:
      D.25978 = image->assembly;
      D.25979 = D.25978->dynamic;
      if (D.25979 != 0) goto <D.25997>; else goto <D.25998>;
      <D.25997>:
      memset (&cols, 0, 36);
      goto <D.25999>;
      <D.25998>:
      D.25978 = image->assembly;
      image = D.25978->image;
      D.26000 = &image->tables[32];
      mono_metadata_decode_row (D.26000, 0, &cols, 9);
      <D.25999>:
      table = &assembly->tables[35];
      D.25985 = table->next_idx;
      token.38 = D.25985;
      D.26002 = token.38 + 1;
      table->next_idx = D.26002;
      token = token.38;
      D.25988 = table->rows;
      D.25989 = D.25988 + 1;
      table->rows = D.25989;
      D.25988 = table->rows;
      alloc_table (table, D.25988);
      D.25990 = table->values;
      D.26003 = token * 9;
      D.26004 = (long unsigned int) D.26003;
      D.26005 = D.26004 * 4;
      values = D.25990 + D.26005;
      D.26006 = values + 24;
      D.25993 = &assembly->sheap;
      D.26007 = image->assembly_name;
      D.26008 = string_heap_insert (D.25993, D.26007);
      *D.26006 = D.26008;
      D.26009 = cols[1];
      *values = D.26009;
      D.26010 = values + 4;
      D.26011 = cols[2];
      *D.26010 = D.26011;
      D.26012 = values + 8;
      D.26013 = cols[3];
      *D.26012 = D.26013;
      D.26014 = values + 12;
      D.26015 = cols[4];
      *D.26014 = D.26015;
      D.26016 = values + 16;
      *D.26016 = 0;
      D.26017 = values + 28;
      *D.26017 = 0;
      D.26018 = values + 32;
      *D.26018 = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.25978 = image->assembly;
          __s2 = D.25978->aname.culture;
          D.26022 = "";
          D.26023 = MEM[(const unsigned char *)D.26022];
          D.26024 = (int) D.26023;
          D.26025 = *__s2;
          D.26026 = (int) D.26025;
          __result = D.26024 - D.26026;
          {
            if (__s1_len != 0) goto <D.26027>; else goto <D.26028>;
            <D.26027>:
            if (__result == 0) goto <D.26029>; else goto <D.26030>;
            <D.26029>:
            D.26031 = &MEM[(void *)"" + 1B];
            D.26032 = *D.26031;
            D.26033 = (int) D.26032;
            D.26034 = __s2 + 1;
            D.26035 = *D.26034;
            D.26036 = (int) D.26035;
            __result = D.26033 - D.26036;
            if (__s1_len > 1) goto <D.26037>; else goto <D.26038>;
            <D.26037>:
            if (__result == 0) goto <D.26039>; else goto <D.26040>;
            <D.26039>:
            D.26041 = &MEM[(void *)"" + 2B];
            D.26042 = *D.26041;
            D.26043 = (int) D.26042;
            D.26044 = __s2 + 2;
            D.26045 = *D.26044;
            D.26046 = (int) D.26045;
            __result = D.26043 - D.26046;
            if (__s1_len > 2) goto <D.26047>; else goto <D.26048>;
            <D.26047>:
            if (__result == 0) goto <D.26049>; else goto <D.26050>;
            <D.26049>:
            D.26051 = &MEM[(void *)"" + 3B];
            D.26052 = *D.26051;
            D.26053 = (int) D.26052;
            D.26054 = __s2 + 3;
            D.26055 = *D.26054;
            D.26056 = (int) D.26055;
            __result = D.26053 - D.26056;
            <D.26050>:
            <D.26048>:
            <D.26040>:
            <D.26038>:
            <D.26030>:
            <D.26028>:
          }
          D.19879 = __result;
        }
        iftmp.39 = D.19879;
        goto <D.26057>;
        <D.26021>:
        D.25978 = image->assembly;
        D.26058 = D.25978->aname.culture;
        D.26059 = MEM[(const unsigned char * {ref-all})D.26058];
        D.26060 = (int) D.26059;
        iftmp.39 = -D.26060;
        <D.26057>:
        D.19883 = iftmp.39;
      }
      if (D.19883 != 0) goto <D.26061>; else goto <D.26062>;
      <D.26061>:
      D.26017 = values + 28;
      D.25993 = &assembly->sheap;
      D.25978 = image->assembly;
      D.26058 = D.25978->aname.culture;
      D.26063 = string_heap_insert (D.25993, D.26058);
      *D.26017 = D.26063;
      <D.26062>:
      pubkey = mono_image_get_public_key (image, &publen);
      if (pubkey != 0B) goto <D.26064>; else goto <D.26065>;
      <D.26064>:
      {
        guchar pubtoken[9];

        try
          {
            pubtoken[0] = 8;
            publen.40 = publen;
            mono_digest_get_public_token (&MEM[(void *)&pubtoken + 1B], pubkey, publen.40);
            D.26067 = values + 20;
            D.26068 = &assembly->blob;
            D.26069 = mono_image_add_stream_data (D.26068, &pubtoken, 9);
            *D.26067 = D.26069;
          }
        finally
          {
            pubtoken = {CLOBBER};
          }
      }
      goto <D.26070>;
      <D.26065>:
      D.26067 = values + 20;
      *D.26067 = 0;
      <D.26070>:
      token = token << 2;
      token = token | 2;
      D.25972 = assembly->handleref;
      D.25991 = (long unsigned int) token;
      D.25996 = (void *) D.25991;
      monoeg_g_hash_table_insert_replace (D.25972, image, D.25996, 0);
      D.25977 = token;
      return D.25977;
    }
  finally
    {
      cols = {CLOBBER};
      publen = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26075;
  int D.26080;
  void * D.26082;
  long unsigned int D.26083;

  D.26075 = __builtin_constant_p (__len);
  if (D.26075 != 0) goto <D.26076>; else goto <D.26077>;
  <D.26076>:
  if (__len == 0) goto <D.26078>; else goto <D.26079>;
  <D.26078>:
  D.26080 = __builtin_constant_p (__ch);
  if (D.26080 == 0) goto <D.26073>; else goto <D.26081>;
  <D.26081>:
  if (__ch != 0) goto <D.26073>; else goto <D.26074>;
  <D.26073>:
  __warn_memset_zero_len ();
  D.26082 = __dest;
  return D.26082;
  <D.26074>:
  <D.26079>:
  <D.26077>:
  D.26083 = __builtin_object_size (__dest, 0);
  D.26082 = __builtin___memset_chk (__dest, __ch, __len, D.26083);
  return D.26082;
}


assembly_add_resource_manifest (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc, guint32 implementation)
{
  unsigned int D.26085;
  unsigned int D.26086;
  guint32 * D.26087;
  unsigned int D.26088;
  unsigned int D.26089;
  long unsigned int D.26090;
  long unsigned int D.26091;
  unsigned int D.26092;
  guint32 * D.26093;
  unsigned int D.26094;
  guint32 * D.26095;
  struct MonoDynamicStream * D.26096;
  struct MonoString * D.26097;
  unsigned int D.26098;
  guint32 * D.26099;
  unsigned int D.26100;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[40];
  D.26085 = table->rows;
  D.26086 = D.26085 + 1;
  table->rows = D.26086;
  D.26085 = table->rows;
  alloc_table (table, D.26085);
  D.26087 = table->values;
  D.26088 = table->next_idx;
  D.26089 = D.26088 * 4;
  D.26090 = (long unsigned int) D.26089;
  D.26091 = D.26090 * 4;
  values = D.26087 + D.26091;
  D.26092 = rsrc->offset;
  *values = D.26092;
  D.26093 = values + 4;
  D.26094 = rsrc->attrs;
  *D.26093 = D.26094;
  D.26095 = values + 8;
  D.26096 = &assembly->sheap;
  D.26097 = rsrc->name;
  D.26098 = string_heap_insert_mstring (D.26096, D.26097);
  *D.26095 = D.26098;
  D.26099 = values + 12;
  *D.26099 = implementation;
  D.26088 = table->next_idx;
  D.26100 = D.26088 + 1;
  table->next_idx = D.26100;
}


string_heap_insert (struct MonoDynamicStream * sh, const char * str)
{
  struct GHashTable * D.26101;
  int D.26102;
  guint32 D.26105;
  void * oldval.41;
  long int oldval.42;
  long unsigned int D.26108;
  unsigned int D.26109;
  unsigned int D.26110;
  int D.26111;
  gchar * D.26112;
  long unsigned int D.26113;
  void * D.26114;
  char * D.26115;
  sizetype D.26116;
  char * D.26117;
  long unsigned int D.26118;
  unsigned int D.26119;
  unsigned int D.26120;
  guint32 idx;
  guint32 len;
  void * oldkey;
  void * oldval;

  try
    {
      D.26101 = sh->hash;
      D.26102 = monoeg_g_hash_table_lookup_extended (D.26101, str, &oldkey, &oldval);
      if (D.26102 != 0) goto <D.26103>; else goto <D.26104>;
      <D.26103>:
      oldval.41 = oldval;
      oldval.42 = (long int) oldval.41;
      D.26105 = (guint32) oldval.42;
      return D.26105;
      <D.26104>:
      D.26108 = strlen (str);
      D.26109 = (unsigned int) D.26108;
      len = D.26109 + 1;
      idx = sh->index;
      D.26110 = idx + len;
      D.26111 = (int) D.26110;
      make_room_in_stream (sh, D.26111);
      D.26101 = sh->hash;
      D.26112 = monoeg_strdup (str);
      D.26113 = (long unsigned int) idx;
      D.26114 = (void *) D.26113;
      monoeg_g_hash_table_insert_replace (D.26101, D.26112, D.26114, 0);
      D.26115 = sh->data;
      D.26116 = (sizetype) idx;
      D.26117 = D.26115 + D.26116;
      D.26118 = (long unsigned int) len;
      memcpy (D.26117, str, D.26118);
      D.26119 = sh->index;
      D.26120 = D.26119 + len;
      sh->index = D.26120;
      D.26105 = idx;
      return D.26105;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


mono_image_get_method_info (struct MonoReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26123;
  unsigned int D.26124;
  struct MonoString * D.26125;
  int iftmp.43;
  unsigned int D.26129;
  unsigned int D.26132;
  unsigned int D.26133;
  unsigned int D.26135;
  unsigned int D.26136;
  unsigned int D.26137;
  guint32 * D.26138;
  unsigned int D.26139;
  long unsigned int D.26140;
  long unsigned int D.26141;
  unsigned int D.26142;
  unsigned int D.26143;
  unsigned int ncharset.44;
  unsigned int D.26145;
  unsigned int extra_flags.45;
  unsigned int D.26147;
  guint32 * D.26148;
  unsigned int D.26149;
  unsigned int D.26150;
  unsigned int D.26151;
  struct MonoString * D.26152;
  guint32 * D.26155;
  struct MonoDynamicStream * D.26156;
  unsigned int D.26157;
  struct MonoString * D.26159;
  unsigned int D.26160;
  guint32 * D.26161;
  unsigned int D.26162;
  unsigned int D.26163;
  long unsigned int D.26166;
  long unsigned int D.26167;
  guint32 * D.26168;
  struct MonoArray * D.26169;
  long unsigned int D.26172;
  unsigned int D.26173;
  unsigned int D.26174;
  long unsigned int D.26175;
  char * D.26176;
  void * D.26177;
  long unsigned int D.26178;
  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.26123 = rmb.table_idx;
      D.26124 = *D.26123;
      mb->table_idx = D.26124;
      D.26125 = mb->dll;
      if (D.26125 != 0B) goto <D.26126>; else goto <D.26127>;
      <D.26126>:
      {
        guint32 moduleref;
        int ncharset;
        int extra_flags;

        D.26129 = mb->charset;
        if (D.26129 != 0) goto <D.26130>; else goto <D.26131>;
        <D.26130>:
        D.26129 = mb->charset;
        D.26132 = D.26129 + 2147483647;
        D.26133 = D.26132 * 2;
        iftmp.43 = (int) D.26133;
        goto <D.26134>;
        <D.26131>:
        iftmp.43 = 0;
        <D.26134>:
        ncharset = iftmp.43;
        D.26135 = mb->extra_flags;
        extra_flags = (int) D.26135;
        table = &assembly->tables[28];
        D.26136 = table->rows;
        D.26137 = D.26136 + 1;
        table->rows = D.26137;
        D.26136 = table->rows;
        alloc_table (table, D.26136);
        D.26138 = table->values;
        D.26136 = table->rows;
        D.26139 = D.26136 * 4;
        D.26140 = (long unsigned int) D.26139;
        D.26141 = D.26140 * 4;
        values = D.26138 + D.26141;
        D.26142 = mb->native_cc;
        D.26143 = D.26142 << 8;
        ncharset.44 = (unsigned int) ncharset;
        D.26145 = D.26143 | ncharset.44;
        extra_flags.45 = (unsigned int) extra_flags;
        D.26147 = D.26145 | extra_flags.45;
        *values = D.26147;
        D.26148 = values + 4;
        D.26149 = mb->table_idx;
        D.26150 = D.26149 << 1;
        D.26151 = D.26150 | 1;
        *D.26148 = D.26151;
        D.26152 = mb->dllentry;
        if (D.26152 != 0B) goto <D.26153>; else goto <D.26154>;
        <D.26153>:
        D.26155 = values + 8;
        D.26156 = &assembly->sheap;
        D.26152 = mb->dllentry;
        D.26157 = string_heap_insert_mstring (D.26156, D.26152);
        *D.26155 = D.26157;
        goto <D.26158>;
        <D.26154>:
        D.26155 = values + 8;
        D.26156 = &assembly->sheap;
        D.26159 = mb->name;
        D.26160 = string_heap_insert_mstring (D.26156, D.26159);
        *D.26155 = D.26160;
        <D.26158>:
        D.26156 = &assembly->sheap;
        D.26125 = mb->dll;
        moduleref = string_heap_insert_mstring (D.26156, D.26125);
        D.26161 = values + 12;
        D.26162 = find_index_in_table (assembly, 26, 0, moduleref);
        *D.26161 = D.26162;
        D.26163 = *D.26161;
        if (D.26163 == 0) goto <D.26164>; else goto <D.26165>;
        <D.26164>:
        table = &assembly->tables[26];
        D.26136 = table->rows;
        D.26137 = D.26136 + 1;
        table->rows = D.26137;
        D.26136 = table->rows;
        alloc_table (table, D.26136);
        D.26138 = table->values;
        D.26136 = table->rows;
        D.26166 = (long unsigned int) D.26136;
        D.26167 = D.26166 * 4;
        D.26168 = D.26138 + D.26167;
        *D.26168 = moduleref;
        D.26161 = values + 12;
        D.26136 = table->rows;
        *D.26161 = D.26136;
        <D.26165>:
      }
      <D.26127>:
      D.26169 = mb->generic_params;
      if (D.26169 != 0B) goto <D.26170>; else goto <D.26171>;
      <D.26170>:
      table = &assembly->tables[42];
      D.26169 = mb->generic_params;
      D.26172 = mono_array_length (D.26169);
      D.26136 = table->rows;
      D.26173 = (unsigned int) D.26172;
      D.26174 = D.26136 + D.26173;
      table->rows = D.26174;
      D.26136 = table->rows;
      alloc_table (table, D.26136);
      i = 0;
      goto <D.19685>;
      <D.19684>:
      {
        guint32 owner;

        D.26149 = mb->table_idx;
        D.26150 = D.26149 << 1;
        owner = D.26150 | 1;
        D.26169 = mb->generic_params;
        D.26175 = (long unsigned int) i;
        D.26176 = mono_array_addr_with_size (D.26169, 8, D.26175);
        D.26177 = MEM[(void * *)D.26176];
        mono_image_get_generic_param_info (D.26177, owner, assembly);
      }
      i = i + 1;
      <D.19685>:
      D.26175 = (long unsigned int) i;
      D.26169 = mb->generic_params;
      D.26178 = mono_array_length (D.26169);
      if (D.26175 < D.26178) goto <D.19684>; else goto <D.19686>;
      <D.19686>:
      <D.26171>:
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


reflection_methodbuilder_from_method_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoReflectionILGen * D.26179;
  struct MonoObject * D.26180;
  struct MonoReflectionType * D.26181;
  struct MonoArray * D.26182;
  struct MonoArray * D.26183;
  struct MonoGenericContainer * D.26184;
  struct MonoArray * D.26185;
  unsigned int D.26186;
  unsigned int D.26187;
  unsigned int D.26188;
  struct MonoArray * D.26189;
  struct MonoObject * D.26190;
  struct MonoString * D.26191;
  guint32 * D.26192;
  unsigned char D.26193;
  struct MonoArray * D.26194;
  struct MonoArray * D.26195;
  struct MonoArray * D.26196;
  struct MonoArray * D.26197;
  struct MonoArray * D.26198;
  struct MonoMethod * D.26199;
  struct MonoString * D.26200;
  unsigned int D.26203;
  int D.26204;
  unsigned int D.26205;
  int D.26206;
  unsigned int D.26207;
  int D.26208;
  struct MonoString * D.26209;

  memset (rmb, 0, 208);
  D.26179 = mb->ilgen;
  rmb->ilgen = D.26179;
  D.26180 = mb->rtype;
  D.26181 = mono_reflection_type_resolve_user_types (D.26180);
  rmb->rtype = D.26181;
  D.26182 = mb->parameters;
  rmb->parameters = D.26182;
  D.26183 = mb->generic_params;
  rmb->generic_params = D.26183;
  D.26184 = mb->generic_container;
  rmb->generic_container = D.26184;
  rmb->opt_types = 0B;
  D.26185 = mb->pinfo;
  rmb->pinfo = D.26185;
  D.26186 = mb->attrs;
  rmb->attrs = D.26186;
  D.26187 = mb->iattrs;
  rmb->iattrs = D.26187;
  D.26188 = mb->call_conv;
  rmb->call_conv = D.26188;
  D.26189 = mb->code;
  rmb->code = D.26189;
  D.26190 = mb->type;
  rmb->type = D.26190;
  D.26191 = mb->name;
  rmb->name = D.26191;
  D.26192 = &mb->table_idx;
  rmb->table_idx = D.26192;
  D.26193 = mb->init_locals;
  rmb->init_locals = D.26193;
  rmb->skip_visibility = 0;
  D.26194 = mb->return_modreq;
  rmb->return_modreq = D.26194;
  D.26195 = mb->return_modopt;
  rmb->return_modopt = D.26195;
  D.26196 = mb->param_modreq;
  rmb->param_modreq = D.26196;
  D.26197 = mb->param_modopt;
  rmb->param_modopt = D.26197;
  D.26198 = mb->permissions;
  rmb->permissions = D.26198;
  D.26199 = mb->mhandle;
  rmb->mhandle = D.26199;
  rmb->nrefs = 0;
  rmb->refs = 0B;
  D.26200 = mb->dll;
  if (D.26200 != 0B) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  D.26203 = mb->charset;
  D.26204 = (int) D.26203;
  rmb->charset = D.26204;
  D.26205 = mb->extra_flags;
  D.26206 = (int) D.26205;
  rmb->extra_flags = D.26206;
  D.26207 = mb->native_cc;
  D.26208 = (int) D.26207;
  rmb->native_cc = D.26208;
  D.26209 = mb->dllentry;
  rmb->dllentry = D.26209;
  D.26200 = mb->dll;
  rmb->dll = D.26200;
  <D.26202>:
}


mono_reflection_type_resolve_user_types (struct MonoReflectionType * type)
{
  struct MonoType * D.26213;
  struct MonoReflectionType * D.26214;
  int D.26215;
  int D.26218;
  struct MonoException * D.26221;

  if (type == 0B) goto <D.26210>; else goto <D.26212>;
  <D.26212>:
  D.26213 = type->type;
  if (D.26213 != 0B) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  D.26214 = type;
  return D.26214;
  <D.26211>:
  D.26215 = is_usertype (type);
  if (D.26215 != 0) goto <D.26216>; else goto <D.26217>;
  <D.26216>:
  type = mono_reflection_type_get_underlying_system_type (type);
  D.26218 = is_usertype (type);
  if (D.26218 != 0) goto <D.26219>; else goto <D.26220>;
  <D.26219>:
  D.26221 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported22");
  mono_raise_exception (D.26221);
  <D.26220>:
  <D.26217>:
  D.26214 = type;
  return D.26214;
}


mono_reflection_type_get_underlying_system_type (struct MonoReflectionType * t)
{
  struct MonoMethod * method_get_underlying_system_type.46;
  struct MonoClass * D.26226;
  struct MonoMethod * method_get_underlying_system_type.47;
  struct MonoReflectionType * D.26228;
  static struct MonoMethod * method_get_underlying_system_type = 0B;
  struct MonoMethod * usertype_method;

  method_get_underlying_system_type.46 = method_get_underlying_system_type;
  if (method_get_underlying_system_type.46 == 0B) goto <D.26224>; else goto <D.26225>;
  <D.26224>:
  D.26226 = mono_defaults.systemtype_class;
  method_get_underlying_system_type.47 = mono_class_get_method_from_name (D.26226, "get_UnderlyingSystemType", 0);
  method_get_underlying_system_type = method_get_underlying_system_type.47;
  <D.26225>:
  method_get_underlying_system_type.46 = method_get_underlying_system_type;
  usertype_method = mono_object_get_virtual_method (t, method_get_underlying_system_type.46);
  D.26228 = mono_runtime_invoke (usertype_method, t, 0B, 0B);
  return D.26228;
}


is_usertype (struct MonoReflectionType * ref)
{
  struct MonoVTable * D.26230;
  gboolean D.26231;
  int iftmp.48;
  struct MonoImage * D.26236;
  struct MonoImage * D.26237;
  int D.23477;
  int iftmp.49;
  int D.23473;
  const char[14] * D.26242;
  unsigned char D.26243;
  int D.26244;
  unsigned char D.26245;
  int D.26246;
  const unsigned char * D.26251;
  unsigned char D.26252;
  int D.26253;
  const unsigned char * D.26254;
  unsigned char D.26255;
  int D.26256;
  const unsigned char * D.26261;
  unsigned char D.26262;
  int D.26263;
  const unsigned char * D.26264;
  unsigned char D.26265;
  int D.26266;
  const unsigned char * D.26271;
  unsigned char D.26272;
  int D.26273;
  const unsigned char * D.26274;
  unsigned char D.26275;
  int D.26276;
  const char * D.26278;
  struct MonoClass * class;

  D.26230 = MEM[(struct MonoObject *)ref].vtable;
  class = D.26230->klass;
  D.26236 = class->image;
  D.26237 = mono_defaults.corlib;
  if (D.26236 != D.26237) goto <D.26233>; else goto <D.26238>;
  <D.26238>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.26242 = "TypeDelegator";
      D.26243 = MEM[(const unsigned char *)D.26242];
      D.26244 = (int) D.26243;
      D.26245 = *__s2;
      D.26246 = (int) D.26245;
      __result = D.26244 - D.26246;
      {
        if (__s1_len != 0) goto <D.26247>; else goto <D.26248>;
        <D.26247>:
        if (__result == 0) goto <D.26249>; else goto <D.26250>;
        <D.26249>:
        D.26251 = &MEM[(void *)"TypeDelegator" + 1B];
        D.26252 = *D.26251;
        D.26253 = (int) D.26252;
        D.26254 = __s2 + 1;
        D.26255 = *D.26254;
        D.26256 = (int) D.26255;
        __result = D.26253 - D.26256;
        if (__s1_len > 1) goto <D.26257>; else goto <D.26258>;
        <D.26257>:
        if (__result == 0) goto <D.26259>; else goto <D.26260>;
        <D.26259>:
        D.26261 = &MEM[(void *)"TypeDelegator" + 2B];
        D.26262 = *D.26261;
        D.26263 = (int) D.26262;
        D.26264 = __s2 + 2;
        D.26265 = *D.26264;
        D.26266 = (int) D.26265;
        __result = D.26263 - D.26266;
        if (__s1_len > 2) goto <D.26267>; else goto <D.26268>;
        <D.26267>:
        if (__result == 0) goto <D.26269>; else goto <D.26270>;
        <D.26269>:
        D.26271 = &MEM[(void *)"TypeDelegator" + 3B];
        D.26272 = *D.26271;
        D.26273 = (int) D.26272;
        D.26274 = __s2 + 3;
        D.26275 = *D.26274;
        D.26276 = (int) D.26275;
        __result = D.26273 - D.26276;
        <D.26270>:
        <D.26268>:
        <D.26260>:
        <D.26258>:
        <D.26250>:
        <D.26248>:
      }
      D.23473 = __result;
    }
    iftmp.49 = D.23473;
    goto <D.26277>;
    <D.26241>:
    D.26278 = class->name;
    iftmp.49 = __builtin_strcmp ("TypeDelegator", D.26278);
    <D.26277>:
    D.23477 = iftmp.49;
  }
  if (D.23477 == 0) goto <D.26233>; else goto <D.26234>;
  <D.26233>:
  iftmp.48 = 1;
  goto <D.26235>;
  <D.26234>:
  iftmp.48 = 0;
  <D.26235>:
  D.26231 = iftmp.48;
  return D.26231;
}


mono_image_basic_method (struct ReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26280;
  unsigned int D.26281;
  unsigned int D.26282;
  unsigned int D.26283;
  struct GHashTable * D.26284;
  struct MonoMethod * D.26285;
  unsigned int D.26286;
  long unsigned int D.26287;
  void * D.26288;
  guint32 * D.26289;
  unsigned int D.26290;
  long unsigned int D.26291;
  long unsigned int D.26292;
  guint32 * D.26293;
  struct MonoDynamicStream * D.26294;
  struct MonoString * D.26295;
  unsigned int D.26296;
  guint32 * D.26297;
  unsigned int D.26298;
  guint32 * D.26299;
  unsigned int D.26300;
  guint32 * D.26301;
  unsigned int D.26302;
  unsigned int D.26303;
  guint32 * D.26304;
  unsigned int D.26305;
  struct MonoArray * D.26306;
  struct MonoArray * D.26307;
  guint32 * D.26310;
  unsigned int D.26311;
  unsigned int D.26312;
  long unsigned int D.26313;
  long unsigned int D.26314;
  long unsigned int D.26315;
  char * D.26316;
  void * D.26317;
  long unsigned int D.26320;
  unsigned int D.26321;
  unsigned int D.26322;
  unsigned int D.26323;
  long unsigned int D.26324;
  long unsigned int D.26325;
  char * D.26326;
  unsigned int D.26329;
  struct MonoString * D.26330;
  unsigned int D.26333;
  struct MonoReflectionMarshal * D.26335;
  unsigned int D.26338;
  unsigned int D.26339;
  unsigned int D.26340;
  long unsigned int D.26341;
  long unsigned int D.26342;
  unsigned int D.26343;
  unsigned int D.26344;
  guint32 * D.26345;
  unsigned int D.26346;
  unsigned int D.26347;
  unsigned int D.26348;
  unsigned int D.26349;
  unsigned int D.26352;
  long unsigned int D.26353;
  long unsigned int D.26354;
  guint32 * D.26355;
  unsigned int D.26356;
  unsigned int D.26357;
  unsigned int D.26358;
  guint32 * D.26359;
  struct MonoObject * D.26360;
  unsigned int D.26361;
  unsigned int field_type.50;
  long unsigned int D.26363;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint i;
  guint count;

  table = &assembly->tables[6];
  D.26280 = mb->table_idx;
  D.26281 = table->next_idx;
  D.26282 = D.26281;
  D.26283 = D.26282 + 1;
  table->next_idx = D.26283;
  *D.26280 = D.26282;
  D.26284 = assembly->method_to_table_idx;
  D.26285 = mb->mhandle;
  D.26280 = mb->table_idx;
  D.26286 = *D.26280;
  D.26287 = (long unsigned int) D.26286;
  D.26288 = (void *) D.26287;
  monoeg_g_hash_table_insert_replace (D.26284, D.26285, D.26288, 0);
  D.26289 = table->values;
  D.26280 = mb->table_idx;
  D.26286 = *D.26280;
  D.26290 = D.26286 * 6;
  D.26291 = (long unsigned int) D.26290;
  D.26292 = D.26291 * 4;
  values = D.26289 + D.26292;
  D.26293 = values + 12;
  D.26294 = &assembly->sheap;
  D.26295 = mb->name;
  D.26296 = string_heap_insert_mstring (D.26294, D.26295);
  *D.26293 = D.26296;
  D.26297 = values + 8;
  D.26298 = mb->attrs;
  *D.26297 = D.26298;
  D.26299 = values + 4;
  D.26300 = mb->iattrs;
  *D.26299 = D.26300;
  D.26301 = values + 16;
  D.26302 = method_builder_encode_signature (assembly, mb);
  *D.26301 = D.26302;
  D.26303 = method_encode_code (assembly, mb);
  *values = D.26303;
  table = &assembly->tables[8];
  D.26304 = values + 20;
  D.26281 = table->next_idx;
  *D.26304 = D.26281;
  D.26280 = mb->table_idx;
  D.26286 = *D.26280;
  D.26305 = D.26286 | 100663296;
  D.26306 = mb->permissions;
  mono_image_add_decl_security (assembly, D.26305, D.26306);
  D.26307 = mb->pinfo;
  if (D.26307 != 0B) goto <D.26308>; else goto <D.26309>;
  <D.26308>:
  {
    struct MonoDynamicTable * mtable;
    guint32 * mvalues;

    mtable = &assembly->tables[13];
    D.26310 = mtable->values;
    D.26311 = mtable->next_idx;
    D.26312 = D.26311 * 2;
    D.26313 = (long unsigned int) D.26312;
    D.26314 = D.26313 * 4;
    mvalues = D.26310 + D.26314;
    count = 0;
    i = 0;
    goto <D.19635>;
    <D.19634>:
    D.26307 = mb->pinfo;
    D.26315 = (long unsigned int) i;
    D.26316 = mono_array_addr_with_size (D.26307, 8, D.26315);
    D.26317 = MEM[(void * *)D.26316];
    if (D.26317 != 0B) goto <D.26318>; else goto <D.26319>;
    <D.26318>:
    count = count + 1;
    <D.26319>:
    i = i + 1;
    <D.19635>:
    D.26315 = (long unsigned int) i;
    D.26307 = mb->pinfo;
    D.26320 = mono_array_length (D.26307);
    if (D.26315 < D.26320) goto <D.19634>; else goto <D.19636>;
    <D.19636>:
    D.26321 = table->rows;
    D.26322 = D.26321 + count;
    table->rows = D.26322;
    D.26321 = table->rows;
    alloc_table (table, D.26321);
    D.26289 = table->values;
    D.26281 = table->next_idx;
    D.26323 = D.26281 * 3;
    D.26324 = (long unsigned int) D.26323;
    D.26325 = D.26324 * 4;
    values = D.26289 + D.26325;
    i = 0;
    goto <D.19640>;
    <D.19639>:
    {
      struct MonoReflectionParamBuilder * pb;

      D.26307 = mb->pinfo;
      D.26315 = (long unsigned int) i;
      D.26326 = mono_array_addr_with_size (D.26307, 8, D.26315);
      pb = MEM[(struct MonoReflectionParamBuilder * *)D.26326];
      if (pb != 0B) goto <D.26327>; else goto <D.26328>;
      <D.26327>:
      D.26329 = pb->attrs;
      *values = D.26329;
      D.26299 = values + 4;
      *D.26299 = i;
      D.26330 = pb->name;
      if (D.26330 != 0B) goto <D.26331>; else goto <D.26332>;
      <D.26331>:
      D.26297 = values + 8;
      D.26294 = &assembly->sheap;
      D.26330 = pb->name;
      D.26333 = string_heap_insert_mstring (D.26294, D.26330);
      *D.26297 = D.26333;
      goto <D.26334>;
      <D.26332>:
      D.26297 = values + 8;
      *D.26297 = 0;
      <D.26334>:
      values = values + 12;
      D.26335 = pb->marshal_info;
      if (D.26335 != 0B) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      D.26338 = mtable->rows;
      D.26339 = D.26338 + 1;
      mtable->rows = D.26339;
      D.26338 = mtable->rows;
      alloc_table (mtable, D.26338);
      D.26310 = mtable->values;
      D.26338 = mtable->rows;
      D.26340 = D.26338 * 2;
      D.26341 = (long unsigned int) D.26340;
      D.26342 = D.26341 * 4;
      mvalues = D.26310 + D.26342;
      D.26281 = table->next_idx;
      D.26343 = D.26281 << 1;
      D.26344 = D.26343 | 1;
      *mvalues = D.26344;
      D.26345 = mvalues + 4;
      D.26335 = pb->marshal_info;
      D.26346 = encode_marshal_blob (assembly, D.26335);
      *D.26345 = D.26346;
      <D.26337>:
      D.26281 = table->next_idx;
      D.26347 = D.26281;
      D.26348 = D.26347 + 1;
      table->next_idx = D.26348;
      pb->table_idx = D.26347;
      D.26329 = pb->attrs;
      D.26349 = D.26329 & 4096;
      if (D.26349 != 0) goto <D.26350>; else goto <D.26351>;
      <D.26350>:
      {
        guint32 field_type;

        try
          {
            field_type = 0;
            mtable = &assembly->tables[11];
            D.26338 = mtable->rows;
            D.26339 = D.26338 + 1;
            mtable->rows = D.26339;
            D.26338 = mtable->rows;
            alloc_table (mtable, D.26338);
            D.26310 = mtable->values;
            D.26338 = mtable->rows;
            D.26352 = D.26338 * 4;
            D.26353 = (long unsigned int) D.26352;
            D.26354 = D.26353 * 4;
            mvalues = D.26310 + D.26354;
            D.26355 = mvalues + 8;
            D.26356 = pb->table_idx;
            D.26357 = D.26356 << 2;
            D.26358 = D.26357 | 1;
            *D.26355 = D.26358;
            D.26359 = mvalues + 12;
            D.26360 = pb->def_value;
            D.26361 = encode_constant (assembly, D.26360, &field_type);
            *D.26359 = D.26361;
            field_type.50 = field_type;
            *mvalues = field_type.50;
            D.26345 = mvalues + 4;
            *D.26345 = 0;
          }
        finally
          {
            field_type = {CLOBBER};
          }
      }
      <D.26351>:
      <D.26328>:
    }
    i = i + 1;
    <D.19640>:
    D.26315 = (long unsigned int) i;
    D.26307 = mb->pinfo;
    D.26363 = mono_array_length (D.26307);
    if (D.26315 < D.26363) goto <D.19639>; else goto <D.19641>;
    <D.19641>:
  }
  <D.26309>:
}


method_builder_encode_signature (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  guint32 iftmp.51;
  struct MonoArray * D.26365;
  long unsigned int D.26368;
  guint32 iftmp.52;
  struct MonoArray * D.26371;
  long unsigned int D.26374;
  guint32 iftmp.53;
  struct MonoArray * D.26377;
  long unsigned int D.26380;
  unsigned int D.26382;
  unsigned int D.26383;
  unsigned int D.26386;
  unsigned int D.26387;
  unsigned char D.26392;
  unsigned int D.26395;
  struct MonoArray * D.26396;
  struct MonoArray * D.26397;
  struct MonoReflectionType * D.26398;
  struct MonoArray * D.26399;
  long unsigned int D.26402;
  long unsigned int D.26403;
  char * D.26406;
  struct MonoArray * D.26407;
  long unsigned int D.26410;
  char * D.26413;
  char * D.26414;
  unsigned int i.54;
  char * D.26418;
  guint32 D.26419;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 ngparams;
  guint32 notypes;
  guint32 idx;

  try
    {
      D.26365 = mb->parameters;
      if (D.26365 != 0B) goto <D.26366>; else goto <D.26367>;
      <D.26366>:
      D.26365 = mb->parameters;
      D.26368 = mono_array_length (D.26365);
      iftmp.51 = (guint32) D.26368;
      goto <D.26369>;
      <D.26367>:
      iftmp.51 = 0;
      <D.26369>:
      nparams = iftmp.51;
      D.26371 = mb->generic_params;
      if (D.26371 != 0B) goto <D.26372>; else goto <D.26373>;
      <D.26372>:
      D.26371 = mb->generic_params;
      D.26374 = mono_array_length (D.26371);
      iftmp.52 = (guint32) D.26374;
      goto <D.26375>;
      <D.26373>:
      iftmp.52 = 0;
      <D.26375>:
      ngparams = iftmp.52;
      D.26377 = mb->opt_types;
      if (D.26377 != 0B) goto <D.26378>; else goto <D.26379>;
      <D.26378>:
      D.26377 = mb->opt_types;
      D.26380 = mono_array_length (D.26377);
      iftmp.53 = (guint32) D.26380;
      goto <D.26381>;
      <D.26379>:
      iftmp.53 = 0;
      <D.26381>:
      notypes = iftmp.53;
      sigbuffer_init (&buf, 32);
      D.26382 = mb->call_conv;
      idx = D.26382 & 96;
      D.26382 = mb->call_conv;
      D.26383 = D.26382 & 2;
      if (D.26383 != 0) goto <D.26384>; else goto <D.26385>;
      <D.26384>:
      idx = idx | 5;
      <D.26385>:
      D.26386 = mb->attrs;
      D.26387 = D.26386 & 16;
      if (D.26387 == 0) goto <D.26388>; else goto <D.26389>;
      <D.26388>:
      idx = idx | 32;
      <D.26389>:
      if (ngparams != 0) goto <D.26390>; else goto <D.26391>;
      <D.26390>:
      idx = idx | 16;
      <D.26391>:
      D.26392 = (unsigned char) idx;
      sigbuffer_add_byte (&buf, D.26392);
      if (ngparams != 0) goto <D.26393>; else goto <D.26394>;
      <D.26393>:
      sigbuffer_add_value (&buf, ngparams);
      <D.26394>:
      D.26395 = nparams + notypes;
      sigbuffer_add_value (&buf, D.26395);
      D.26396 = mb->return_modreq;
      D.26397 = mb->return_modopt;
      encode_custom_modifiers (assembly, D.26396, D.26397, &buf);
      D.26398 = mb->rtype;
      encode_reflection_type (assembly, D.26398, &buf);
      i = 0;
      goto <D.19446>;
      <D.19445>:
      {
        struct MonoArray * modreq;
        struct MonoArray * modopt;
        struct MonoReflectionType * pt;

        modreq = 0B;
        modopt = 0B;
        D.26399 = mb->param_modreq;
        if (D.26399 != 0B) goto <D.26400>; else goto <D.26401>;
        <D.26400>:
        D.26402 = (long unsigned int) i;
        D.26399 = mb->param_modreq;
        D.26403 = mono_array_length (D.26399);
        if (D.26402 < D.26403) goto <D.26404>; else goto <D.26405>;
        <D.26404>:
        D.26399 = mb->param_modreq;
        D.26402 = (long unsigned int) i;
        D.26406 = mono_array_addr_with_size (D.26399, 8, D.26402);
        modreq = MEM[(struct MonoArray * *)D.26406];
        <D.26405>:
        <D.26401>:
        D.26407 = mb->param_modopt;
        if (D.26407 != 0B) goto <D.26408>; else goto <D.26409>;
        <D.26408>:
        D.26402 = (long unsigned int) i;
        D.26407 = mb->param_modopt;
        D.26410 = mono_array_length (D.26407);
        if (D.26402 < D.26410) goto <D.26411>; else goto <D.26412>;
        <D.26411>:
        D.26407 = mb->param_modopt;
        D.26402 = (long unsigned int) i;
        D.26413 = mono_array_addr_with_size (D.26407, 8, D.26402);
        modopt = MEM[(struct MonoArray * *)D.26413];
        <D.26412>:
        <D.26409>:
        encode_custom_modifiers (assembly, modreq, modopt, &buf);
        D.26365 = mb->parameters;
        D.26402 = (long unsigned int) i;
        D.26414 = mono_array_addr_with_size (D.26365, 8, D.26402);
        pt = MEM[(struct MonoReflectionType * *)D.26414];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19446>:
      i.54 = (unsigned int) i;
      if (i.54 < nparams) goto <D.19445>; else goto <D.19447>;
      <D.19447>:
      if (notypes != 0) goto <D.26416>; else goto <D.26417>;
      <D.26416>:
      sigbuffer_add_byte (&buf, 65);
      <D.26417>:
      i = 0;
      goto <D.19450>;
      <D.19449>:
      {
        struct MonoReflectionType * pt;

        D.26377 = mb->opt_types;
        D.26402 = (long unsigned int) i;
        D.26418 = mono_array_addr_with_size (D.26377, 8, D.26402);
        pt = MEM[(struct MonoReflectionType * *)D.26418];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19450>:
      i.54 = (unsigned int) i;
      if (i.54 < notypes) goto <D.19449>; else goto <D.19451>;
      <D.19451>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26419 = idx;
      return D.26419;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sigbuffer_init (struct SigBuffer * buf, int size)
{
  long unsigned int D.26422;
  void * D.26423;
  char * D.26424;
  sizetype D.26425;
  char * D.26426;

  D.26422 = (long unsigned int) size;
  D.26423 = monoeg_malloc (D.26422);
  buf->buf = D.26423;
  D.26424 = buf->buf;
  buf->p = D.26424;
  D.26424 = buf->buf;
  D.26425 = (sizetype) size;
  D.26426 = D.26424 + D.26425;
  buf->end = D.26426;
}


sigbuffer_add_value (struct SigBuffer * buf, guint32 val)
{
  char * D.26427;
  char * * D.26428;

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


sigbuffer_make_room (struct SigBuffer * buf, int size)
{
  char * D.26429;
  long int D.26430;
  char * D.26431;
  long int D.26432;
  long int D.26433;
  long int D.26434;
  char * D.26437;
  long int D.26438;
  long int D.26439;
  unsigned int D.26440;
  unsigned int size.55;
  unsigned int D.26442;
  unsigned int D.26443;
  long unsigned int D.26444;
  long int D.26445;
  sizetype D.26446;
  char * D.26447;
  sizetype D.26448;
  char * D.26449;

  D.26429 = buf->end;
  D.26430 = (long int) D.26429;
  D.26431 = buf->p;
  D.26432 = (long int) D.26431;
  D.26433 = D.26430 - D.26432;
  D.26434 = (long int) size;
  if (D.26433 < D.26434) goto <D.26435>; else goto <D.26436>;
  <D.26435>:
  {
    int new_size;
    char * p;

    D.26429 = buf->end;
    D.26430 = (long int) D.26429;
    D.26437 = buf->buf;
    D.26438 = (long int) D.26437;
    D.26439 = D.26430 - D.26438;
    D.26440 = (unsigned int) D.26439;
    size.55 = (unsigned int) size;
    D.26442 = D.26440 + size.55;
    D.26443 = D.26442 + 32;
    new_size = (int) D.26443;
    D.26437 = buf->buf;
    D.26444 = (long unsigned int) new_size;
    p = monoeg_realloc (D.26437, D.26444);
    D.26431 = buf->p;
    D.26432 = (long int) D.26431;
    D.26437 = buf->buf;
    D.26438 = (long int) D.26437;
    D.26445 = D.26432 - D.26438;
    size = (int) D.26445;
    buf->buf = p;
    D.26446 = (sizetype) size;
    D.26447 = p + D.26446;
    buf->p = D.26447;
    D.26437 = buf->buf;
    D.26448 = (sizetype) new_size;
    D.26449 = D.26437 + D.26448;
    buf->end = D.26449;
  }
  <D.26436>:
}


encode_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoArray * modreq, struct MonoArray * modopt, struct SigBuffer * buf)
{
  long unsigned int D.26452;
  char * D.26453;
  void * D.26454;
  unsigned int D.26455;
  long unsigned int D.26456;
  char * D.26459;
  void * D.26460;
  unsigned int D.26461;
  long unsigned int D.26462;
  int i;

  if (modreq != 0B) goto <D.26450>; else goto <D.26451>;
  <D.26450>:
  i = 0;
  goto <D.19415>;
  <D.19414>:
  {
    struct MonoType * mod;

    D.26452 = (long unsigned int) i;
    D.26453 = mono_array_addr_with_size (modreq, 8, D.26452);
    D.26454 = MEM[(void * *)D.26453];
    mod = mono_reflection_type_get_handle (D.26454);
    sigbuffer_add_byte (buf, 31);
    D.26455 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.26455);
  }
  i = i + 1;
  <D.19415>:
  D.26452 = (long unsigned int) i;
  D.26456 = mono_array_length (modreq);
  if (D.26452 < D.26456) goto <D.19414>; else goto <D.19416>;
  <D.19416>:
  <D.26451>:
  if (modopt != 0B) goto <D.26457>; else goto <D.26458>;
  <D.26457>:
  i = 0;
  goto <D.19419>;
  <D.19418>:
  {
    struct MonoType * mod;

    D.26452 = (long unsigned int) i;
    D.26459 = mono_array_addr_with_size (modopt, 8, D.26452);
    D.26460 = MEM[(void * *)D.26459];
    mod = mono_reflection_type_get_handle (D.26460);
    sigbuffer_add_byte (buf, 32);
    D.26461 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.26461);
  }
  i = i + 1;
  <D.19419>:
  D.26452 = (long unsigned int) i;
  D.26462 = mono_array_length (modopt);
  if (D.26452 < D.26462) goto <D.19418>; else goto <D.19420>;
  <D.19420>:
  <D.26458>:
}


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

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


mono_image_typedef_or_ref_full (struct MonoDynamicImage * assembly, struct MonoType * type, gboolean try_typespec)
{
  guint32 D.26469;
  struct GHashTable * D.26470;
  void * D.26471;
  long int D.26472;
  struct MonoImage * D.26477;
  struct MonoImage * D.26478;
  unsigned char D.26481;
  unsigned int D.26486;
  struct MonoGHashTable * D.26487;
  long unsigned int D.26488;
  void * D.26489;
  void * D.26490;
  struct MonoClass * D.26491;
  struct MonoType * D.26494;
  unsigned int D.26495;
  int D.26497;
  unsigned int D.26500;
  unsigned int D.26501;
  guint32 * D.26502;
  unsigned int D.26503;
  unsigned int D.26504;
  long unsigned int D.26505;
  long unsigned int D.26506;
  guint32 * D.26507;
  struct MonoDynamicStream * D.26508;
  const char * D.26509;
  unsigned int D.26510;
  guint32 * D.26511;
  const char * D.26512;
  unsigned int D.26513;
  unsigned int D.26514;
  unsigned int D.26515;
  void * D.26516;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 scope;
  guint32 enclosing;
  struct MonoClass * klass;

  if (try_typespec != 0) goto <D.26465>; else goto <D.26466>;
  <D.26465>:
  token = create_typespec (assembly, type);
  if (token != 0) goto <D.26467>; else goto <D.26468>;
  <D.26467>:
  D.26469 = token;
  return D.26469;
  <D.26468>:
  <D.26466>:
  D.26470 = assembly->typeref;
  D.26471 = monoeg_g_hash_table_lookup (D.26470, type);
  D.26472 = (long int) D.26471;
  token = (guint32) D.26472;
  if (token != 0) goto <D.26473>; else goto <D.26474>;
  <D.26473>:
  D.26469 = token;
  return D.26469;
  <D.26474>:
  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.26475>; else goto <D.26476>;
  <D.26475>:
  klass = mono_class_from_mono_type (type);
  <D.26476>:
  D.26477 = klass->image;
  D.26478 = &assembly->image;
  if (D.26477 == D.26478) goto <D.26479>; else goto <D.26480>;
  <D.26479>:
  D.26481 = type->type;
  if (D.26481 != 19) goto <D.26482>; else goto <D.26483>;
  <D.26482>:
  D.26481 = type->type;
  if (D.26481 != 30) goto <D.26484>; else goto <D.26485>;
  <D.26484>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.26486 = tb->table_idx;
    token = D.26486 << 2;
    D.26487 = assembly->tokens;
    D.26488 = (long unsigned int) token;
    D.26489 = (void *) D.26488;
    D.26490 = mono_class_get_ref_info (klass);
    mono_g_hash_table_insert (D.26487, D.26489, D.26490);
    D.26469 = token;
    return D.26469;
  }
  <D.26485>:
  <D.26483>:
  <D.26480>:
  D.26491 = klass->nested_in;
  if (D.26491 != 0B) goto <D.26492>; else goto <D.26493>;
  <D.26492>:
  D.26491 = klass->nested_in;
  D.26494 = &D.26491->byval_arg;
  enclosing = mono_image_typedef_or_ref_full (assembly, D.26494, 0);
  enclosing = enclosing >> 2;
  D.26495 = enclosing << 2;
  scope = D.26495 | 3;
  goto <D.26496>;
  <D.26493>:
  D.26477 = klass->image;
  scope = resolution_scope_from_image (assembly, D.26477);
  <D.26496>:
  table = &assembly->tables[1];
  D.26497 = assembly->save;
  if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
  <D.26498>:
  D.26500 = table->rows;
  D.26501 = D.26500 + 1;
  alloc_table (table, D.26501);
  D.26502 = table->values;
  D.26503 = table->next_idx;
  D.26504 = D.26503 * 3;
  D.26505 = (long unsigned int) D.26504;
  D.26506 = D.26505 * 4;
  values = D.26502 + D.26506;
  *values = scope;
  D.26507 = values + 4;
  D.26508 = &assembly->sheap;
  D.26509 = klass->name;
  D.26510 = string_heap_insert (D.26508, D.26509);
  *D.26507 = D.26510;
  D.26511 = values + 8;
  D.26508 = &assembly->sheap;
  D.26512 = klass->name_space;
  D.26513 = string_heap_insert (D.26508, D.26512);
  *D.26511 = D.26513;
  <D.26499>:
  D.26503 = table->next_idx;
  D.26514 = D.26503 << 2;
  token = D.26514 | 1;
  D.26470 = assembly->typeref;
  D.26488 = (long unsigned int) token;
  D.26489 = (void *) D.26488;
  monoeg_g_hash_table_insert_replace (D.26470, type, D.26489, 0);
  D.26503 = table->next_idx;
  D.26515 = D.26503 + 1;
  table->next_idx = D.26515;
  D.26487 = assembly->tokens;
  D.26488 = (long unsigned int) token;
  D.26489 = (void *) D.26488;
  D.26516 = mono_class_get_ref_info (klass);
  mono_g_hash_table_insert (D.26487, D.26489, D.26516);
  D.26469 = token;
  return D.26469;
}


create_typespec (struct MonoDynamicImage * assembly, struct MonoType * type)
{
  struct GHashTable * D.26518;
  void * D.26519;
  long int D.26520;
  guint32 D.26523;
  unsigned char D.26524;
  int D.26525;
  struct MonoGenericContainer * D.26529;
  int D.26530;
  unsigned int D.26533;
  unsigned int D.26534;
  guint32 * D.26535;
  unsigned int D.26536;
  long unsigned int D.26537;
  long unsigned int D.26538;
  unsigned int D.26539;
  long unsigned int D.26540;
  void * D.26541;
  unsigned int D.26542;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  struct SigBuffer buf;

  try
    {
      D.26518 = assembly->typespec;
      D.26519 = monoeg_g_hash_table_lookup (D.26518, type);
      D.26520 = (long int) D.26519;
      token = (guint32) D.26520;
      if (token != 0) goto <D.26521>; else goto <D.26522>;
      <D.26521>:
      D.26523 = token;
      return D.26523;
      <D.26522>:
      sigbuffer_init (&buf, 32);
      D.26524 = type->type;
      D.26525 = (int) D.26524;
      switch (D.26525) <default: <D.19904>, case 15: <D.19894>, case 17: <D.19902>, case 18: <D.19901>, case 19: <D.19897>, case 20: <D.19896>, case 21: <D.19899>, case 27: <D.19893>, case 29: <D.19895>, case 30: <D.19898>>
      <D.19893>:
      <D.19894>:
      <D.19895>:
      <D.19896>:
      <D.19897>:
      <D.19898>:
      <D.19899>:
      encode_type (assembly, type, &buf);
      goto <D.19900>;
      <D.19901>:
      <D.19902>:
      {
        struct MonoClass * k;

        k = mono_class_from_mono_type (type);
        if (k == 0B) goto <D.26526>; else goto <D.26528>;
        <D.26528>:
        D.26529 = k->generic_container;
        if (D.26529 == 0B) goto <D.26526>; else goto <D.26527>;
        <D.26526>:
        sigbuffer_free (&buf);
        D.26523 = 0;
        return D.26523;
        <D.26527>:
        encode_type (assembly, type, &buf);
        goto <D.19900>;
      }
      <D.19904>:
      sigbuffer_free (&buf);
      D.26523 = 0;
      return D.26523;
      <D.19900>:
      table = &assembly->tables[27];
      D.26530 = assembly->save;
      if (D.26530 != 0) goto <D.26531>; else goto <D.26532>;
      <D.26531>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.26533 = table->rows;
      D.26534 = D.26533 + 1;
      alloc_table (table, D.26534);
      D.26535 = table->values;
      D.26536 = table->next_idx;
      D.26537 = (long unsigned int) D.26536;
      D.26538 = D.26537 * 4;
      values = D.26535 + D.26538;
      *values = token;
      <D.26532>:
      sigbuffer_free (&buf);
      D.26536 = table->next_idx;
      D.26539 = D.26536 << 2;
      token = D.26539 | 2;
      D.26518 = assembly->typespec;
      D.26540 = (long unsigned int) token;
      D.26541 = (void *) D.26540;
      monoeg_g_hash_table_insert_replace (D.26518, type, D.26541, 0);
      D.26536 = table->next_idx;
      D.26542 = D.26536 + 1;
      table->next_idx = D.26542;
      D.26523 = token;
      return D.26523;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_type (struct MonoDynamicImage * assembly, struct MonoType * type, struct SigBuffer * buf)
{
  long unsigned int D.26547;
  long unsigned int D.26548;
  unsigned char D.26551;
  int D.26552;
  unsigned int D.26553;
  struct MonoType * D.26554;
  struct MonoClass * D.26555;
  struct MonoType * D.26556;
  struct MonoGenericContainer * D.26557;
  struct MonoGenericInst * D.26560;
  unsigned char D.26562;
  unsigned int D.26563;
  struct MonoType * D.26564;
  unsigned int D.26565;
  struct MonoArrayType * D.26566;
  struct MonoClass * D.26567;
  struct MonoType * D.26568;
  unsigned char D.26569;
  unsigned int D.26570;
  struct MonoGenericClass * D.26571;
  struct MonoGenericParam * D.26572;
  short unsigned int D.26573;
  unsigned int D.26574;

  if (type == 0B) goto <D.26545>; else goto <D.26546>;
  <D.26545>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 679);
  return;
  <D.26546>:
  D.26547 = BIT_FIELD_REF <*type, 64, 64>;
  D.26548 = D.26547 & 1073741824;
  if (D.26548 != 0) goto <D.26549>; else goto <D.26550>;
  <D.26549>:
  sigbuffer_add_value (buf, 16);
  <D.26550>:
  D.26551 = type->type;
  D.26552 = (int) D.26551;
  switch (D.26552) <default: <D.19399>, case 1: <D.19370>, case 2: <D.19371>, case 3: <D.19372>, case 4: <D.19373>, case 5: <D.19374>, case 6: <D.19375>, case 7: <D.19376>, case 8: <D.19377>, case 9: <D.19378>, case 10: <D.19379>, case 11: <D.19380>, case 12: <D.19381>, case 13: <D.19382>, case 14: <D.19385>, case 15: <D.19389>, case 17: <D.19391>, case 18: <D.19392>, case 19: <D.19397>, case 20: <D.19395>, case 21: <D.19396>, case 22: <D.19387>, case 24: <D.19383>, case 25: <D.19384>, case 28: <D.19386>, case 29: <D.19390>, case 30: <D.19398>>
  <D.19370>:
  <D.19371>:
  <D.19372>:
  <D.19373>:
  <D.19374>:
  <D.19375>:
  <D.19376>:
  <D.19377>:
  <D.19378>:
  <D.19379>:
  <D.19380>:
  <D.19381>:
  <D.19382>:
  <D.19383>:
  <D.19384>:
  <D.19385>:
  <D.19386>:
  <D.19387>:
  D.26551 = type->type;
  D.26553 = (unsigned int) D.26551;
  sigbuffer_add_value (buf, D.26553);
  goto <D.19388>;
  <D.19389>:
  D.26551 = type->type;
  D.26553 = (unsigned int) D.26551;
  sigbuffer_add_value (buf, D.26553);
  D.26554 = type->data.type;
  encode_type (assembly, D.26554, buf);
  goto <D.19388>;
  <D.19390>:
  D.26551 = type->type;
  D.26553 = (unsigned int) D.26551;
  sigbuffer_add_value (buf, D.26553);
  D.26555 = type->data.klass;
  D.26556 = &D.26555->byval_arg;
  encode_type (assembly, D.26556, buf);
  goto <D.19388>;
  <D.19391>:
  <D.19392>:
  {
    struct MonoClass * k;

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

      D.26557 = k->generic_container;
      D.26560 = D.26557->context.class_inst;
      gclass = mono_metadata_lookup_generic_class (k, D.26560, 1);
      encode_generic_class (assembly, gclass, buf);
    }
    goto <D.26561>;
    <D.26559>:
    D.26562 = k->byval_arg.type;
    D.26563 = (unsigned int) D.26562;
    sigbuffer_add_value (buf, D.26563);
    D.26564 = &k->byval_arg;
    D.26565 = mono_image_typedef_or_ref (assembly, D.26564);
    sigbuffer_add_value (buf, D.26565);
    <D.26561>:
    goto <D.19388>;
  }
  <D.19395>:
  D.26551 = type->type;
  D.26553 = (unsigned int) D.26551;
  sigbuffer_add_value (buf, D.26553);
  D.26566 = type->data.array;
  D.26567 = D.26566->eklass;
  D.26568 = &D.26567->byval_arg;
  encode_type (assembly, D.26568, buf);
  D.26566 = type->data.array;
  D.26569 = D.26566->rank;
  D.26570 = (unsigned int) D.26569;
  sigbuffer_add_value (buf, D.26570);
  sigbuffer_add_value (buf, 0);
  sigbuffer_add_value (buf, 0);
  goto <D.19388>;
  <D.19396>:
  D.26571 = type->data.generic_class;
  encode_generic_class (assembly, D.26571, buf);
  goto <D.19388>;
  <D.19397>:
  <D.19398>:
  D.26551 = type->type;
  D.26553 = (unsigned int) D.26551;
  sigbuffer_add_value (buf, D.26553);
  D.26572 = type->data.generic_param;
  D.26573 = D.26572->num;
  D.26574 = (unsigned int) D.26573;
  sigbuffer_add_value (buf, D.26574);
  goto <D.19388>;
  <D.19399>:
  D.26551 = type->type;
  D.26552 = (int) D.26551;
  monoeg_g_log (0B, 4, "need to encode type %x", D.26552);
  <D.19400>:
  goto <D.19400>;
  <D.19388>:
}


encode_generic_class (struct MonoDynamicImage * assembly, struct MonoGenericClass * gclass, struct SigBuffer * buf)
{
  _Bool D.26575;
  long int D.26576;
  long int D.26577;
  unsigned char D.26580;
  unsigned int D.26581;
  struct MonoType * D.26582;
  unsigned int D.26583;
  <unnamed-unsigned:22> D.26584;
  unsigned int D.26585;
  struct MonoType * D.26586;
  int D.26587;
  int i;
  struct MonoGenericInst * class_inst;
  struct MonoClass * klass;

  D.26575 = gclass == 0B;
  D.26576 = (long int) D.26575;
  D.26577 = __builtin_expect (D.26576, 0);
  if (D.26577 != 0) goto <D.26578>; else goto <D.26579>;
  <D.26578>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 660, "gclass");
  <D.26579>:
  class_inst = gclass->context.class_inst;
  sigbuffer_add_value (buf, 21);
  klass = gclass->container_class;
  D.26580 = klass->byval_arg.type;
  D.26581 = (unsigned int) D.26580;
  sigbuffer_add_value (buf, D.26581);
  D.26582 = &klass->byval_arg;
  D.26583 = mono_image_typedef_or_ref_full (assembly, D.26582, 0);
  sigbuffer_add_value (buf, D.26583);
  D.26584 = class_inst->type_argc;
  D.26585 = (unsigned int) D.26584;
  sigbuffer_add_value (buf, D.26585);
  i = 0;
  goto <D.19363>;
  <D.19362>:
  D.26586 = class_inst->type_argv[i];
  encode_type (assembly, D.26586, buf);
  i = i + 1;
  <D.19363>:
  D.26584 = class_inst->type_argc;
  D.26587 = (int) D.26584;
  if (D.26587 > i) goto <D.19362>; else goto <D.19364>;
  <D.19364>:
}


sigbuffer_add_byte (struct SigBuffer * buf, guint8 val)
{
  char * D.26588;
  char * D.26589;

  sigbuffer_make_room (buf, 1);
  D.26588 = buf->p;
  *D.26588 = val;
  D.26588 = buf->p;
  D.26589 = D.26588 + 1;
  buf->p = D.26589;
}


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

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


sigbuffer_add_to_blob_cached (struct MonoDynamicImage * assembly, struct SigBuffer * buf)
{
  char * D.26594;
  long int D.26595;
  char * D.26596;
  long int D.26597;
  long int D.26598;
  long int D.26599;
  char * D.26600;
  long int D.26601;
  long int D.26602;
  _Bool D.26603;
  long int D.26604;
  long int D.26605;
  char * b.56;
  guint32 D.26609;
  long int b.57;
  long int blob_size.58;
  long int D.26612;
  int D.26613;
  int size.59;
  char blob_size[8];
  char * b;
  guint32 size;

  try
    {
      b = &blob_size;
      D.26594 = buf->p;
      D.26595 = (long int) D.26594;
      D.26596 = buf->buf;
      D.26597 = (long int) D.26596;
      D.26598 = D.26595 - D.26597;
      size = (guint32) D.26598;
      D.26599 = (long int) size;
      D.26600 = buf->end;
      D.26601 = (long int) D.26600;
      D.26596 = buf->buf;
      D.26597 = (long int) D.26596;
      D.26602 = D.26601 - D.26597;
      D.26603 = D.26599 > D.26602;
      D.26604 = (long int) D.26603;
      D.26605 = __builtin_expect (D.26604, 0);
      if (D.26605 != 0) goto <D.26606>; else goto <D.26607>;
      <D.26606>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 501, "size <= (buf->end - buf->buf)");
      <D.26607>:
      b.56 = b;
      mono_metadata_encode_value (size, b.56, &b);
      b.56 = b;
      b.57 = (long int) b.56;
      blob_size.58 = (long int) &blob_size;
      D.26612 = b.57 - blob_size.58;
      D.26613 = (int) D.26612;
      D.26596 = buf->buf;
      size.59 = (int) size;
      D.26609 = add_to_blob_cached (assembly, &blob_size, D.26613, D.26596, size.59);
      return D.26609;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


add_to_blob_cached (struct MonoDynamicImage * assembly, char * b1, int s1, char * b2, int s2)
{
  int D.26617;
  long unsigned int D.26618;
  long unsigned int D.26619;
  sizetype D.26620;
  char * D.26621;
  long unsigned int D.26622;
  struct GHashTable * D.26623;
  int D.26624;
  void * oldval.60;
  long int oldval.61;
  struct MonoDynamicStream * D.26630;
  unsigned int s1.62;
  unsigned int s2.63;
  long unsigned int D.26633;
  void * D.26634;
  guint32 D.26635;
  guint32 idx;
  char * copy;
  void * oldkey;
  void * oldval;

  try
    {
      D.26617 = s1 + s2;
      D.26618 = (long unsigned int) D.26617;
      copy = monoeg_malloc (D.26618);
      D.26619 = (long unsigned int) s1;
      memcpy (copy, b1, D.26619);
      D.26620 = (sizetype) s1;
      D.26621 = copy + D.26620;
      D.26622 = (long unsigned int) s2;
      memcpy (D.26621, b2, D.26622);
      D.26623 = assembly->blob_cache;
      D.26624 = monoeg_g_hash_table_lookup_extended (D.26623, copy, &oldkey, &oldval);
      if (D.26624 != 0) goto <D.26625>; else goto <D.26626>;
      <D.26625>:
      monoeg_g_free (copy);
      oldval.60 = oldval;
      oldval.61 = (long int) oldval.60;
      idx = (guint32) oldval.61;
      goto <D.26629>;
      <D.26626>:
      D.26630 = &assembly->blob;
      s1.62 = (unsigned int) s1;
      idx = mono_image_add_stream_data (D.26630, b1, s1.62);
      D.26630 = &assembly->blob;
      s2.63 = (unsigned int) s2;
      mono_image_add_stream_data (D.26630, b2, s2.63);
      D.26623 = assembly->blob_cache;
      D.26633 = (long unsigned int) idx;
      D.26634 = (void *) D.26633;
      monoeg_g_hash_table_insert_replace (D.26623, copy, D.26634, 0);
      <D.26629>:
      D.26635 = idx;
      return D.26635;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


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

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


method_encode_code (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  long unsigned int D.26639;
  long unsigned int D.26640;
  guint32 D.26643;
  struct MonoReflectionILGen * D.26644;
  int D.26647;
  gint32 iftmp.64;
  struct MonoArray * D.26649;
  long unsigned int D.26652;
  struct MonoArray * D.26654;
  unsigned int D.26657;
  struct MonoString * D.26661;
  long unsigned int D.26662;
  struct MonoDynamicStream * D.26663;
  int iftmp.65;
  int D.26668;
  unsigned int D.26675;
  char D.26677;
  char D.26678;
  char flags.66;
  char flags.67;
  int D.26685;
  struct MonoGHashTable * D.26688;
  unsigned int D.26689;
  long unsigned int D.26690;
  void * D.26691;
  char * D.26692;
  unsigned int D.26693;
  unsigned int D.26696;
  unsigned char D.26699;
  char D.26702;
  unsigned int D.26703;
  char D.26704;
  char D.26705;
  short unsigned int short_value.68;
  unsigned int D.26711;
  long unsigned int D.26712;
  void * D.26713;
  char * D.26714;
  unsigned int num_exception.69;
  unsigned int D.26718;
  unsigned char D.26719;
  int D.26720;
  unsigned char D.26721;
  int D.26722;
  unsigned char D.26723;
  long unsigned int D.26724;
  unsigned int D.26725;
  unsigned int D.26726;
  long unsigned int D.26727;
  struct MonoArray * D.26728;
  int D.26731;
  int D.26732;
  long unsigned int D.26733;
  int D.26734;
  unsigned int val.70;
  unsigned int val.71;
  int D.26739;
  unsigned int val.72;
  unsigned int val.73;
  int D.26743;
  unsigned int val.74;
  int D.26745;
  unsigned int val.75;
  struct MonoObject * D.26747;
  struct MonoType * D.26750;
  unsigned int D.26751;
  unsigned int val.76;
  int D.26756;
  unsigned int val.77;
  unsigned int val.78;
  long unsigned int D.26760;
  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.26639 = BIT_FIELD_REF <*mb, 64, 448>;
      D.26640 = D.26639 & 17605070955520;
      if (D.26640 != 0) goto <D.26641>; else goto <D.26642>;
      <D.26641>:
      D.26643 = 0;
      return D.26643;
      <D.26642>:
      D.26644 = mb->ilgen;
      if (D.26644 != 0B) goto <D.26645>; else goto <D.26646>;
      <D.26645>:
      D.26644 = mb->ilgen;
      code = D.26644->code;
      D.26644 = mb->ilgen;
      D.26647 = D.26644->code_len;
      code_size = (guint32) D.26647;
      D.26644 = mb->ilgen;
      max_stack = D.26644->max_stack;
      D.26644 = mb->ilgen;
      D.26649 = D.26644->locals;
      if (D.26649 != 0B) goto <D.26650>; else goto <D.26651>;
      <D.26650>:
      D.26644 = mb->ilgen;
      D.26649 = D.26644->locals;
      D.26652 = mono_array_length (D.26649);
      iftmp.64 = (gint32) D.26652;
      goto <D.26653>;
      <D.26651>:
      iftmp.64 = 0;
      <D.26653>:
      num_locals = iftmp.64;
      D.26644 = mb->ilgen;
      D.26654 = D.26644->ex_handlers;
      if (D.26654 != 0B) goto <D.26655>; else goto <D.26656>;
      <D.26655>:
      D.26644 = mb->ilgen;
      D.26657 = method_count_clauses (D.26644);
      num_exception = (gint32) D.26657;
      <D.26656>:
      goto <D.26658>;
      <D.26646>:
      code = mb->code;
      if (code == 0B) goto <D.26659>; else goto <D.26660>;
      <D.26659>:
      {
        char * name;
        char * str;
        struct MonoException * exception;

        D.26661 = mb->name;
        name = mono_string_to_utf8 (D.26661);
        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.26660>:
      D.26662 = mono_array_length (code);
      code_size = (guint32) D.26662;
      max_stack = 8;
      <D.26658>:
      D.26663 = &assembly->code;
      stream_data_align (D.26663);
      if (max_stack <= 8) goto <D.26667>; else goto <D.26665>;
      <D.26667>:
      D.26668 = num_locals | num_exception;
      if (D.26668 == 0) goto <D.26669>; else goto <D.26665>;
      <D.26669>:
      iftmp.65 = 1;
      goto <D.26666>;
      <D.26665>:
      iftmp.65 = 0;
      <D.26666>:
      maybe_small = iftmp.65;
      if (maybe_small != 0) goto <D.26670>; else goto <D.26671>;
      <D.26670>:
      if (code_size <= 63) goto <D.26674>; else goto <D.26672>;
      <D.26674>:
      D.26675 = code_size & 1;
      if (D.26675 == 0) goto <D.26676>; else goto <D.26672>;
      <D.26676>:
      D.26677 = (char) code_size;
      D.26678 = D.26677 << 2;
      flags.66 = D.26678 | 2;
      flags = flags.66;
      goto <D.26673>;
      <D.26672>:
      if (code_size <= 31) goto <D.26680>; else goto fat_header;
      <D.26680>:
      D.26675 = code_size & 1;
      if (D.26675 != 0) goto <D.26681>; else goto fat_header;
      <D.26681>:
      D.26677 = (char) code_size;
      D.26678 = D.26677 << 2;
      flags.67 = D.26678 | 6;
      flags = flags.67;
      <D.26673>:
      D.26663 = &assembly->code;
      idx = mono_image_add_stream_data (D.26663, &flags, 1);
      D.26644 = mb->ilgen;
      if (D.26644 != 0B) goto <D.26683>; else goto <D.26684>;
      <D.26683>:
      D.26644 = mb->ilgen;
      D.26685 = D.26644->num_token_fixups;
      if (D.26685 != 0) goto <D.26686>; else goto <D.26687>;
      <D.26686>:
      D.26688 = assembly->token_fixups;
      D.26644 = mb->ilgen;
      D.26689 = idx + 1;
      D.26690 = (long unsigned int) D.26689;
      D.26691 = (void *) D.26690;
      mono_g_hash_table_insert (D.26688, D.26644, D.26691);
      <D.26687>:
      <D.26684>:
      D.26663 = &assembly->code;
      D.26692 = mono_array_addr_with_size (code, 1, 0);
      mono_image_add_stream_data (D.26663, D.26692, code_size);
      D.26693 = assembly->text_rva;
      D.26643 = D.26693 + idx;
      return D.26643;
      <D.26671>:
      fat_header:
      if (num_locals != 0) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      D.26644 = mb->ilgen;
      D.26696 = encode_locals (assembly, D.26644);
      local_sig = D.26696 | 285212672;
      <D.26695>:
      fat_flags = 3;
      if (num_exception != 0) goto <D.26697>; else goto <D.26698>;
      <D.26697>:
      fat_flags = fat_flags | 8;
      <D.26698>:
      D.26699 = mb->init_locals;
      if (D.26699 != 0) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      fat_flags = fat_flags | 16;
      <D.26701>:
      D.26702 = (char) fat_flags;
      fat_header[0] = D.26702;
      D.26703 = header_size / 4;
      D.26704 = (char) D.26703;
      D.26705 = D.26704 << 4;
      fat_header[1] = D.26705;
      short_value.68 = (short unsigned int) max_stack;
      short_value = short_value.68;
      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.26663 = &assembly->code;
      idx = mono_image_add_stream_data (D.26663, &fat_header, 12);
      D.26644 = mb->ilgen;
      if (D.26644 != 0B) goto <D.26707>; else goto <D.26708>;
      <D.26707>:
      D.26644 = mb->ilgen;
      D.26685 = D.26644->num_token_fixups;
      if (D.26685 != 0) goto <D.26709>; else goto <D.26710>;
      <D.26709>:
      D.26688 = assembly->token_fixups;
      D.26644 = mb->ilgen;
      D.26711 = idx + 12;
      D.26712 = (long unsigned int) D.26711;
      D.26713 = (void *) D.26712;
      mono_g_hash_table_insert (D.26688, D.26644, D.26713);
      <D.26710>:
      <D.26708>:
      D.26663 = &assembly->code;
      D.26714 = mono_array_addr_with_size (code, 1, 0);
      mono_image_add_stream_data (D.26663, D.26714, code_size);
      if (num_exception != 0) goto <D.26715>; else goto <D.26716>;
      <D.26715>:
      {
        unsigned char sheader[4];
        struct MonoILExceptionInfo * ex_info;
        struct MonoILExceptionBlock * ex_block;
        int j;

        try
          {
            D.26663 = &assembly->code;
            stream_data_align (D.26663);
            sheader[0] = 65;
            num_exception.69 = (unsigned int) num_exception;
            D.26718 = num_exception.69 * 24;
            num_exception = (gint32) D.26718;
            num_exception = num_exception + 4;
            D.26719 = (unsigned char) num_exception;
            sheader[1] = D.26719;
            D.26720 = num_exception >> 8;
            D.26721 = (unsigned char) D.26720;
            sheader[2] = D.26721;
            D.26722 = num_exception >> 16;
            D.26723 = (unsigned char) D.26722;
            sheader[3] = D.26723;
            D.26663 = &assembly->code;
            mono_image_add_stream_data (D.26663, &sheader, 4);
            D.26644 = mb->ilgen;
            D.26654 = D.26644->ex_handlers;
            D.26724 = mono_array_length (D.26654);
            D.26725 = (unsigned int) D.26724;
            D.26726 = D.26725 + 4294967295;
            i = (gint32) D.26726;
            goto <D.19531>;
            <D.19530>:
            D.26644 = mb->ilgen;
            D.26654 = D.26644->ex_handlers;
            D.26727 = (long unsigned int) i;
            ex_info = mono_array_addr_with_size (D.26654, 24, D.26727);
            D.26728 = ex_info->handlers;
            if (D.26728 != 0B) goto <D.26729>; else goto <D.26730>;
            <D.26729>:
            {
              int finally_start;

              D.26731 = ex_info->start;
              D.26732 = ex_info->len;
              finally_start = D.26731 + D.26732;
              j = 0;
              goto <D.19527>;
              <D.19526>:
              {
                guint32 val;

                try
                  {
                    D.26728 = ex_info->handlers;
                    D.26733 = (long unsigned int) j;
                    ex_block = mono_array_addr_with_size (D.26728, 24, D.26733);
                    D.26734 = ex_block->type;
                    val.70 = (unsigned int) D.26734;
                    val = val.70;
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                    D.26731 = ex_info->start;
                    val.71 = (unsigned int) D.26731;
                    val = val.71;
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                    D.26734 = ex_block->type;
                    if (D.26734 == 2) goto <D.26737>; else goto <D.26738>;
                    <D.26737>:
                    D.26731 = ex_info->start;
                    D.26739 = finally_start - D.26731;
                    val.72 = (unsigned int) D.26739;
                    val = val.72;
                    goto <D.26741>;
                    <D.26738>:
                    D.26732 = ex_info->len;
                    val.73 = (unsigned int) D.26732;
                    val = val.73;
                    <D.26741>:
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                    D.26743 = ex_block->start;
                    val.74 = (unsigned int) D.26743;
                    val = val.74;
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                    D.26745 = ex_block->len;
                    val.75 = (unsigned int) D.26745;
                    val = val.75;
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                    D.26743 = ex_block->start;
                    D.26745 = ex_block->len;
                    finally_start = D.26743 + D.26745;
                    D.26747 = ex_block->extype;
                    if (D.26747 != 0B) goto <D.26748>; else goto <D.26749>;
                    <D.26748>:
                    D.26747 = ex_block->extype;
                    D.26750 = mono_reflection_type_get_handle (D.26747);
                    D.26751 = mono_image_typedef_or_ref (assembly, D.26750);
                    val.76 = mono_metadata_token_from_dor (D.26751);
                    val = val.76;
                    goto <D.26753>;
                    <D.26749>:
                    D.26734 = ex_block->type;
                    if (D.26734 == 1) goto <D.26754>; else goto <D.26755>;
                    <D.26754>:
                    D.26756 = ex_block->filter_offset;
                    val.77 = (unsigned int) D.26756;
                    val = val.77;
                    goto <D.26758>;
                    <D.26755>:
                    val = 0;
                    <D.26758>:
                    <D.26753>:
                    val.78 = val;
                    val = val.78;
                    D.26663 = &assembly->code;
                    mono_image_add_stream_data (D.26663, &val, 4);
                  }
                finally
                  {
                    val = {CLOBBER};
                  }
              }
              j = j + 1;
              <D.19527>:
              D.26733 = (long unsigned int) j;
              D.26728 = ex_info->handlers;
              D.26760 = mono_array_length (D.26728);
              if (D.26733 < D.26760) goto <D.19526>; else goto <D.19528>;
              <D.19528>:
            }
            goto <D.26761>;
            <D.26730>:
            monoeg_g_log (0B, 4, "No clauses for ex info block %d", i);
            <D.19529>:
            goto <D.19529>;
            <D.26761>:
            i = i + -1;
            <D.19531>:
            if (i >= 0) goto <D.19530>; else goto <D.19532>;
            <D.19532>:
          }
        finally
          {
            sheader = {CLOBBER};
          }
      }
      <D.26716>:
      D.26693 = assembly->text_rva;
      D.26643 = D.26693 + idx;
      return D.26643;
    }
  finally
    {
      flags = {CLOBBER};
      fat_header = {CLOBBER};
      int_value = {CLOBBER};
      short_value = {CLOBBER};
    }
}


method_count_clauses (struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.26764;
  long unsigned int D.26765;
  struct MonoArray * D.26766;
  long unsigned int D.26769;
  unsigned int D.26770;
  long unsigned int D.26772;
  guint32 D.26773;
  guint32 num_clauses;
  int i;
  struct MonoILExceptionInfo * ex_info;

  num_clauses = 0;
  i = 0;
  goto <D.19474>;
  <D.19473>:
  D.26764 = ilgen->ex_handlers;
  D.26765 = (long unsigned int) i;
  ex_info = mono_array_addr_with_size (D.26764, 24, D.26765);
  D.26766 = ex_info->handlers;
  if (D.26766 != 0B) goto <D.26767>; else goto <D.26768>;
  <D.26767>:
  D.26766 = ex_info->handlers;
  D.26769 = mono_array_length (D.26766);
  D.26770 = (unsigned int) D.26769;
  num_clauses = D.26770 + num_clauses;
  goto <D.26771>;
  <D.26768>:
  num_clauses = num_clauses + 1;
  <D.26771>:
  i = i + 1;
  <D.19474>:
  D.26765 = (long unsigned int) i;
  D.26764 = ilgen->ex_handlers;
  D.26772 = mono_array_length (D.26764);
  if (D.26765 < D.26772) goto <D.19473>; else goto <D.19475>;
  <D.19475>:
  D.26773 = num_clauses;
  return D.26773;
}


encode_locals (struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.26775;
  long unsigned int D.26776;
  long unsigned int D.26777;
  char * D.26778;
  unsigned char D.26779;
  struct MonoObject * D.26782;
  unsigned int i.79;
  struct GHashTable * D.26784;
  struct GHashTable * D.26787;
  long unsigned int D.26788;
  const void * D.26789;
  void * D.26790;
  long int D.26791;
  guint32 D.26794;
  unsigned int D.26795;
  unsigned int idx.80;
  unsigned int D.26797;
  unsigned int D.26798;
  unsigned int D.26799;
  guint32 * D.26800;
  long unsigned int D.26801;
  long unsigned int D.26802;
  void * D.26803;
  void * D.26804;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 idx;
  guint32 sig_idx;
  guint nl;
  struct SigBuffer buf;
  int i;

  try
    {
      D.26775 = ilgen->locals;
      D.26776 = mono_array_length (D.26775);
      nl = (guint) D.26776;
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, nl);
      i = 0;
      goto <D.19465>;
      <D.19464>:
      {
        struct MonoReflectionLocalBuilder * lb;

        D.26775 = ilgen->locals;
        D.26777 = (long unsigned int) i;
        D.26778 = mono_array_addr_with_size (D.26775, 8, D.26777);
        lb = MEM[(struct MonoReflectionLocalBuilder * *)D.26778];
        D.26779 = lb->is_pinned;
        if (D.26779 != 0) goto <D.26780>; else goto <D.26781>;
        <D.26780>:
        sigbuffer_add_value (&buf, 69);
        <D.26781>:
        D.26782 = lb->type;
        encode_reflection_type (assembly, D.26782, &buf);
      }
      i = i + 1;
      <D.19465>:
      i.79 = (unsigned int) i;
      if (i.79 < nl) goto <D.19464>; else goto <D.19466>;
      <D.19466>:
      sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26784 = assembly->standalonesig_cache;
      if (D.26784 == 0B) goto <D.26785>; else goto <D.26786>;
      <D.26785>:
      D.26787 = monoeg_g_hash_table_new (0B, 0B);
      assembly->standalonesig_cache = D.26787;
      <D.26786>:
      D.26784 = assembly->standalonesig_cache;
      D.26788 = (long unsigned int) sig_idx;
      D.26789 = (const void *) D.26788;
      D.26790 = monoeg_g_hash_table_lookup (D.26784, D.26789);
      D.26791 = (long int) D.26790;
      idx = (guint32) D.26791;
      if (idx != 0) goto <D.26792>; else goto <D.26793>;
      <D.26792>:
      D.26794 = idx;
      return D.26794;
      <D.26793>:
      table = &assembly->tables[17];
      D.26795 = table->next_idx;
      idx.80 = D.26795;
      D.26797 = idx.80 + 1;
      table->next_idx = D.26797;
      idx = idx.80;
      D.26798 = table->rows;
      D.26799 = D.26798 + 1;
      table->rows = D.26799;
      D.26798 = table->rows;
      alloc_table (table, D.26798);
      D.26800 = table->values;
      D.26801 = (long unsigned int) idx;
      D.26802 = D.26801 * 4;
      values = D.26800 + D.26802;
      *values = sig_idx;
      D.26784 = assembly->standalonesig_cache;
      D.26788 = (long unsigned int) sig_idx;
      D.26803 = (void *) D.26788;
      D.26801 = (long unsigned int) idx;
      D.26804 = (void *) D.26801;
      monoeg_g_hash_table_insert_replace (D.26784, D.26803, D.26804, 0);
      D.26794 = idx;
      return D.26794;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  try
    {
      buf = {};
      D.26807 = stream->index;
      count = D.26807 & 3;
      if (count != 0) goto <D.26808>; else goto <D.26809>;
      <D.26808>:
      D.26810 = 4 - count;
      mono_image_add_stream_data (stream, &buf, D.26810);
      <D.26809>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_marshal_blob (struct MonoDynamicImage * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.26811;
  unsigned int D.26812;
  int D.26813;
  unsigned int D.26814;
  int D.26817;
  unsigned char D.26819;
  unsigned int D.26820;
  guint32 iftmp.81;
  int D.26824;
  guint32 iftmp.82;
  _Bool D.26832;
  unsigned int D.26833;
  struct MonoString * D.26836;
  long unsigned int D.26839;
  struct MonoString * D.26844;
  struct MonoObject * D.26846;
  struct MonoType * D.26849;
  long unsigned int D.26851;
  struct MonoString * D.26852;
  long unsigned int D.26855;
  guint32 D.26857;
  char * str;
  struct SigBuffer buf;
  guint32 idx;
  guint32 len;

  try
    {
      sigbuffer_init (&buf, 32);
      D.26811 = minfo->type;
      D.26812 = (unsigned int) D.26811;
      sigbuffer_add_value (&buf, D.26812);
      D.26811 = minfo->type;
      switch (D.26811) <default: <D.19793>, case 23: <D.19787>, case 29: <D.19791>, case 30: <D.19788>, case 42: <D.19790>, case 44: <D.19792>>
      <D.19787>:
      <D.19788>:
      D.26813 = minfo->count;
      D.26814 = (unsigned int) D.26813;
      sigbuffer_add_value (&buf, D.26814);
      goto <D.19789>;
      <D.19790>:
      D.26817 = minfo->eltype;
      if (D.26817 != 0) goto <D.26815>; else goto <D.26818>;
      <D.26818>:
      D.26819 = minfo->has_size;
      if (D.26819 != 0) goto <D.26815>; else goto <D.26816>;
      <D.26815>:
      D.26817 = minfo->eltype;
      D.26820 = (unsigned int) D.26817;
      sigbuffer_add_value (&buf, D.26820);
      D.26819 = minfo->has_size;
      if (D.26819 != 0) goto <D.26821>; else goto <D.26822>;
      <D.26821>:
      D.26824 = minfo->param_num;
      if (D.26824 != -1) goto <D.26825>; else goto <D.26826>;
      <D.26825>:
      D.26824 = minfo->param_num;
      iftmp.81 = (guint32) D.26824;
      goto <D.26827>;
      <D.26826>:
      iftmp.81 = 0;
      <D.26827>:
      sigbuffer_add_value (&buf, iftmp.81);
      D.26813 = minfo->count;
      if (D.26813 != -1) goto <D.26829>; else goto <D.26830>;
      <D.26829>:
      D.26813 = minfo->count;
      iftmp.82 = (guint32) D.26813;
      goto <D.26831>;
      <D.26830>:
      iftmp.82 = 0;
      <D.26831>:
      sigbuffer_add_value (&buf, iftmp.82);
      D.26824 = minfo->param_num;
      D.26832 = D.26824 != -1;
      D.26833 = (unsigned int) D.26832;
      sigbuffer_add_value (&buf, D.26833);
      <D.26822>:
      <D.26816>:
      goto <D.19789>;
      <D.19791>:
      D.26817 = minfo->eltype;
      if (D.26817 != 0) goto <D.26834>; else goto <D.26835>;
      <D.26834>:
      D.26817 = minfo->eltype;
      D.26820 = (unsigned int) D.26817;
      sigbuffer_add_value (&buf, D.26820);
      <D.26835>:
      goto <D.19789>;
      <D.19792>:
      D.26836 = minfo->guid;
      if (D.26836 != 0B) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      D.26836 = minfo->guid;
      str = mono_string_to_utf8 (D.26836);
      D.26839 = strlen (str);
      len = (guint32) D.26839;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26840>;
      <D.26838>:
      sigbuffer_add_value (&buf, 0);
      <D.26840>:
      sigbuffer_add_value (&buf, 0);
      D.26844 = minfo->marshaltype;
      if (D.26844 != 0B) goto <D.26841>; else goto <D.26845>;
      <D.26845>:
      D.26846 = minfo->marshaltyperef;
      if (D.26846 != 0B) goto <D.26841>; else goto <D.26842>;
      <D.26841>:
      D.26846 = minfo->marshaltyperef;
      if (D.26846 != 0B) goto <D.26847>; else goto <D.26848>;
      <D.26847>:
      D.26846 = minfo->marshaltyperef;
      D.26849 = mono_reflection_type_get_handle (D.26846);
      str = type_get_fully_qualified_name (D.26849);
      goto <D.26850>;
      <D.26848>:
      D.26844 = minfo->marshaltype;
      str = mono_string_to_utf8 (D.26844);
      <D.26850>:
      D.26851 = strlen (str);
      len = (guint32) D.26851;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26843>;
      <D.26842>:
      sigbuffer_add_value (&buf, 0);
      <D.26843>:
      D.26852 = minfo->mcookie;
      if (D.26852 != 0B) goto <D.26853>; else goto <D.26854>;
      <D.26853>:
      D.26852 = minfo->mcookie;
      str = mono_string_to_utf8 (D.26852);
      D.26855 = strlen (str);
      len = (guint32) D.26855;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26856>;
      <D.26854>:
      sigbuffer_add_value (&buf, 0);
      <D.26856>:
      goto <D.19789>;
      <D.19793>:
      goto <D.19789>;
      <D.19789>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26857 = idx;
      return D.26857;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


sigbuffer_add_mem (struct SigBuffer * buf, char * p, guint32 size)
{
  int size.83;
  char * D.26864;
  long unsigned int D.26865;
  sizetype D.26866;
  char * D.26867;

  size.83 = (int) size;
  sigbuffer_make_room (buf, size.83);
  D.26864 = buf->p;
  D.26865 = (long unsigned int) size;
  memcpy (D.26864, p, D.26865);
  D.26864 = buf->p;
  D.26866 = (sizetype) size;
  D.26867 = D.26864 + D.26866;
  buf->p = D.26867;
}


encode_constant (struct MonoDynamicImage * assembly, struct MonoObject * val, guint32 * ret_type)
{
  struct MonoVTable * D.26871;
  struct MonoClass * D.26872;
  unsigned char D.26873;
  unsigned int D.26874;
  unsigned int D.26875;
  long unsigned int D.26876;
  long unsigned int D.26877;
  struct MonoType * D.26880;
  unsigned char D.26881;
  unsigned int D.26882;
  struct MonoImage * D.26885;
  int D.26886;
  int D.19762;
  int iftmp.84;
  int D.19761;
  const char[7] * D.26891;
  unsigned char D.26892;
  int D.26893;
  unsigned char D.26894;
  int D.26895;
  const unsigned char * D.26900;
  unsigned char D.26901;
  int D.26902;
  const unsigned char * D.26903;
  unsigned char D.26904;
  int D.26905;
  const unsigned char * D.26910;
  unsigned char D.26911;
  int D.26912;
  const unsigned char * D.26913;
  unsigned char D.26914;
  int D.26915;
  const unsigned char * D.26920;
  unsigned char D.26921;
  int D.26922;
  const unsigned char * D.26923;
  unsigned char D.26924;
  int D.26925;
  const char * D.26927;
  int D.19771;
  int iftmp.85;
  int D.19770;
  const char[9] * D.26932;
  unsigned char D.26933;
  int D.26934;
  unsigned char D.26935;
  int D.26936;
  const unsigned char * D.26941;
  unsigned char D.26942;
  int D.26943;
  const unsigned char * D.26944;
  unsigned char D.26945;
  int D.26946;
  const unsigned char * D.26951;
  unsigned char D.26952;
  int D.26953;
  const unsigned char * D.26954;
  unsigned char D.26955;
  int D.26956;
  const unsigned char * D.26961;
  unsigned char D.26962;
  int D.26963;
  const unsigned char * D.26964;
  unsigned char D.26965;
  int D.26966;
  const char * D.26968;
  int D.26970;
  int D.26971;
  char * b.86;
  long int b.87;
  long int blob_size.88;
  long int D.26975;
  int D.26976;
  mono_unichar2 * D.26977;
  int len.89;
  guint32 D.26979;
  struct MonoGenericClass * D.26980;
  struct MonoClass * D.26981;
  unsigned char D.26982;
  unsigned int D.26983;
  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.26868>; else goto <D.26869>;
      <D.26868>:
      *ret_type = 18;
      len = 4;
      box_val = &dummy;
      goto <D.26870>;
      <D.26869>:
      box_val = val + 16;
      D.26871 = val->vtable;
      D.26872 = D.26871->klass;
      D.26873 = D.26872->byval_arg.type;
      D.26874 = (unsigned int) D.26873;
      *ret_type = D.26874;
      <D.26870>:
      handle_enum:
      D.26875 = *ret_type;
      switch (D.26875) <default: <D.19777>, case 2: <D.19739>, case 3: <D.19743>, case 4: <D.19741>, case 5: <D.19740>, case 6: <D.19745>, case 7: <D.19744>, case 8: <D.19747>, case 9: <D.19746>, case 10: <D.19750>, case 11: <D.19749>, case 12: <D.19748>, case 13: <D.19751>, case 14: <D.19774>, case 17: <D.19752>, case 18: <D.19773>, case 21: <D.19776>>
      <D.19739>:
      <D.19740>:
      <D.19741>:
      len = 1;
      goto <D.19742>;
      <D.19743>:
      <D.19744>:
      <D.19745>:
      len = 2;
      goto <D.19742>;
      <D.19746>:
      <D.19747>:
      <D.19748>:
      len = 4;
      goto <D.19742>;
      <D.19749>:
      <D.19750>:
      len = 8;
      goto <D.19742>;
      <D.19751>:
      len = 8;
      goto <D.19742>;
      <D.19752>:
      {
        struct MonoClass * klass;

        D.26871 = val->vtable;
        klass = D.26871->klass;
        D.26876 = BIT_FIELD_REF <*klass, 64, 256>;
        D.26877 = D.26876 & 16;
        if (D.26877 != 0) goto <D.26878>; else goto <D.26879>;
        <D.26878>:
        D.26880 = mono_class_enum_basetype (klass);
        D.26881 = D.26880->type;
        D.26882 = (unsigned int) D.26881;
        *ret_type = D.26882;
        goto handle_enum;
        <D.26879>:
        D.26885 = klass->image;
        D.26886 = mono_is_corlib_image (D.26885);
        if (D.26886 != 0) goto <D.26887>; else goto <D.26883>;
        <D.26887>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.26891 = "System";
            D.26892 = MEM[(const unsigned char *)D.26891];
            D.26893 = (int) D.26892;
            D.26894 = *__s2;
            D.26895 = (int) D.26894;
            __result = D.26893 - D.26895;
            {
              if (__s2_len != 0) goto <D.26896>; else goto <D.26897>;
              <D.26896>:
              if (__result == 0) goto <D.26898>; else goto <D.26899>;
              <D.26898>:
              D.26900 = &MEM[(void *)"System" + 1B];
              D.26901 = *D.26900;
              D.26902 = (int) D.26901;
              D.26903 = __s2 + 1;
              D.26904 = *D.26903;
              D.26905 = (int) D.26904;
              __result = D.26902 - D.26905;
              if (__s2_len > 1) goto <D.26906>; else goto <D.26907>;
              <D.26906>:
              if (__result == 0) goto <D.26908>; else goto <D.26909>;
              <D.26908>:
              D.26910 = &MEM[(void *)"System" + 2B];
              D.26911 = *D.26910;
              D.26912 = (int) D.26911;
              D.26913 = __s2 + 2;
              D.26914 = *D.26913;
              D.26915 = (int) D.26914;
              __result = D.26912 - D.26915;
              if (__s2_len > 2) goto <D.26916>; else goto <D.26917>;
              <D.26916>:
              if (__result == 0) goto <D.26918>; else goto <D.26919>;
              <D.26918>:
              D.26920 = &MEM[(void *)"System" + 3B];
              D.26921 = *D.26920;
              D.26922 = (int) D.26921;
              D.26923 = __s2 + 3;
              D.26924 = *D.26923;
              D.26925 = (int) D.26924;
              __result = D.26922 - D.26925;
              <D.26919>:
              <D.26917>:
              <D.26909>:
              <D.26907>:
              <D.26899>:
              <D.26897>:
            }
            D.19761 = __result;
          }
          iftmp.84 = -D.19761;
          goto <D.26926>;
          <D.26890>:
          D.26927 = klass->name_space;
          iftmp.84 = __builtin_strcmp (D.26927, "System");
          <D.26926>:
          D.19762 = iftmp.84;
        }
        if (D.19762 == 0) goto <D.26928>; else goto <D.26883>;
        <D.26928>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.26932 = "DateTime";
            D.26933 = MEM[(const unsigned char *)D.26932];
            D.26934 = (int) D.26933;
            D.26935 = *__s2;
            D.26936 = (int) D.26935;
            __result = D.26934 - D.26936;
            {
              if (__s2_len != 0) goto <D.26937>; else goto <D.26938>;
              <D.26937>:
              if (__result == 0) goto <D.26939>; else goto <D.26940>;
              <D.26939>:
              D.26941 = &MEM[(void *)"DateTime" + 1B];
              D.26942 = *D.26941;
              D.26943 = (int) D.26942;
              D.26944 = __s2 + 1;
              D.26945 = *D.26944;
              D.26946 = (int) D.26945;
              __result = D.26943 - D.26946;
              if (__s2_len > 1) goto <D.26947>; else goto <D.26948>;
              <D.26947>:
              if (__result == 0) goto <D.26949>; else goto <D.26950>;
              <D.26949>:
              D.26951 = &MEM[(void *)"DateTime" + 2B];
              D.26952 = *D.26951;
              D.26953 = (int) D.26952;
              D.26954 = __s2 + 2;
              D.26955 = *D.26954;
              D.26956 = (int) D.26955;
              __result = D.26953 - D.26956;
              if (__s2_len > 2) goto <D.26957>; else goto <D.26958>;
              <D.26957>:
              if (__result == 0) goto <D.26959>; else goto <D.26960>;
              <D.26959>:
              D.26961 = &MEM[(void *)"DateTime" + 3B];
              D.26962 = *D.26961;
              D.26963 = (int) D.26962;
              D.26964 = __s2 + 3;
              D.26965 = *D.26964;
              D.26966 = (int) D.26965;
              __result = D.26963 - D.26966;
              <D.26960>:
              <D.26958>:
              <D.26950>:
              <D.26948>:
              <D.26940>:
              <D.26938>:
            }
            D.19770 = __result;
          }
          iftmp.85 = -D.19770;
          goto <D.26967>;
          <D.26931>:
          D.26968 = klass->name;
          iftmp.85 = __builtin_strcmp (D.26968, "DateTime");
          <D.26967>:
          D.19771 = iftmp.85;
        }
        if (D.19771 == 0) goto <D.26969>; else goto <D.26883>;
        <D.26969>:
        len = 8;
        goto <D.26884>;
        <D.26883>:
        monoeg_g_log (0B, 4, "we can\'t encode valuetypes, we should have never reached this line");
        <D.19772>:
        goto <D.19772>;
        <D.26884>:
        goto <D.19742>;
      }
      <D.19773>:
      goto <D.19742>;
      <D.19774>:
      {
        struct MonoString * str;

        str = val;
        D.26970 = str->length;
        D.26971 = D.26970 * 2;
        len = (guint32) D.26971;
        b.86 = b;
        mono_metadata_encode_value (len, b.86, &b);
        b.86 = b;
        b.87 = (long int) b.86;
        blob_size.88 = (long int) &blob_size;
        D.26975 = b.87 - blob_size.88;
        D.26976 = (int) D.26975;
        D.26977 = mono_string_chars (str);
        len.89 = (int) len;
        idx = add_to_blob_cached (assembly, &blob_size, D.26976, D.26977, len.89);
        monoeg_g_free (buf);
        D.26979 = idx;
        return D.26979;
      }
      <D.19776>:
      D.26871 = val->vtable;
      D.26872 = D.26871->klass;
      D.26980 = D.26872->generic_class;
      D.26981 = D.26980->container_class;
      D.26982 = D.26981->byval_arg.type;
      D.26983 = (unsigned int) D.26982;
      *ret_type = D.26983;
      goto handle_enum;
      <D.19777>:
      D.26875 = *ret_type;
      monoeg_g_log (0B, 4, "we don\'t encode constant type 0x%02x yet", D.26875);
      <D.19778>:
      goto <D.19778>;
      <D.19742>:
      b.86 = b;
      mono_metadata_encode_value (len, b.86, &b);
      b.86 = b;
      b.87 = (long int) b.86;
      blob_size.88 = (long int) &blob_size;
      D.26975 = b.87 - blob_size.88;
      D.26976 = (int) D.26975;
      len.89 = (int) len;
      idx = add_to_blob_cached (assembly, &blob_size, D.26976, box_val, len.89);
      monoeg_g_free (buf);
      D.26979 = idx;
      return D.26979;
    }
  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.26987;
  int D.26988;
  _Bool D.26989;
  long int D.26990;
  long int D.26991;
  guint32 * D.26994;
  long unsigned int D.26995;
  long unsigned int D.26996;
  long unsigned int D.26997;
  long unsigned int D.26998;
  guint32 * D.26999;
  unsigned int D.27000;
  guint32 D.27003;
  unsigned int i.90;
  unsigned int D.27005;
  int i;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[table_idx];
  D.26987 = table->columns;
  D.26988 = (int) D.26987;
  D.26989 = D.26988 <= col;
  D.26990 = (long int) D.26989;
  D.26991 = __builtin_expect (D.26990, 0);
  if (D.26991 != 0) goto <D.26992>; else goto <D.26993>;
  <D.26992>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1155, "col < table->columns");
  <D.26993>:
  D.26994 = table->values;
  D.26987 = table->columns;
  D.26995 = (long unsigned int) D.26987;
  D.26996 = D.26995 * 4;
  values = D.26994 + D.26996;
  i = 1;
  goto <D.19543>;
  <D.19542>:
  D.26997 = (long unsigned int) col;
  D.26998 = D.26997 * 4;
  D.26999 = values + D.26998;
  D.27000 = *D.26999;
  if (D.27000 == token) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  D.27003 = (guint32) i;
  return D.27003;
  <D.27002>:
  D.26987 = table->columns;
  D.26995 = (long unsigned int) D.26987;
  D.26996 = D.26995 * 4;
  values = values + D.26996;
  i = i + 1;
  <D.19543>:
  i.90 = (unsigned int) i;
  D.27005 = table->rows;
  if (i.90 <= D.27005) goto <D.19542>; else goto <D.19544>;
  <D.19544>:
  D.27003 = 0;
  return D.27003;
}


mono_image_get_generic_param_info (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  int D.27007;
  struct MonoReflectionGenericParam * * D.27012;
  void * D.27013;
  struct GPtrArray * D.27014;
  struct GenericParamTableEntry * entry;

  entry = monoeg_malloc0 (16);
  entry->owner = owner;
  D.27007 = mono_gc_is_moving ();
  if (D.27007 != 0) goto <D.27008>; else goto <D.27009>;
  <D.27008>:
  if (0 != 0) goto <D.27010>; else goto <D.27011>;
  <D.27010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2206, "sizeof (entry->gparam) == sizeof (MonoObject*)");
  <D.27011>:
  D.27012 = &entry->gparam;
  D.27013 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (D.27012, 8, D.27013);
  <D.27009>:
  entry->gparam = gparam;
  D.27014 = assembly->gen_params;
  monoeg_g_ptr_array_add (D.27014, entry);
}


mono_image_get_field_info (struct MonoReflectionFieldBuilder * fb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27015;
  unsigned int D.27016;
  unsigned int D.27019;
  unsigned int D.27020;
  unsigned int D.27021;
  unsigned int D.27022;
  int D.27023;
  struct GHashTable * D.27024;
  struct MonoClassField * D.27025;
  int D.27026;
  long unsigned int D.27027;
  void * D.27028;
  guint32 * D.27029;
  int D.27030;
  long unsigned int D.27031;
  long unsigned int D.27032;
  guint32 * D.27033;
  struct MonoDynamicStream * D.27034;
  struct MonoString * D.27035;
  unsigned int D.27036;
  guint32 * D.27037;
  unsigned int D.27038;
  int D.27039;
  unsigned int D.27042;
  unsigned int D.27043;
  unsigned int D.27044;
  long unsigned int D.27045;
  long unsigned int D.27046;
  unsigned int D.27047;
  unsigned int D.27048;
  unsigned int D.27051;
  long unsigned int D.27052;
  long unsigned int D.27053;
  int D.27054;
  unsigned int D.27055;
  guint32 * D.27056;
  struct MonoObject * D.27057;
  unsigned int D.27058;
  unsigned int field_type.91;
  unsigned int D.27060;
  struct MonoArray * D.27063;
  long unsigned int D.27066;
  struct MonoDynamicStream * D.27069;
  char * D.27070;
  long unsigned int D.27071;
  unsigned int D.27072;
  struct MonoClass * D.27074;
  int D.27075;
  unsigned int D.27076;
  unsigned int D.27077;
  unsigned int D.27078;
  struct MonoReflectionMarshal * D.27079;
  int D.27082;
  unsigned int D.27083;
  unsigned int D.27084;
  struct MonoDynamicTable * table;
  guint32 * values;

  D.27015 = fb->attrs;
  D.27016 = D.27015 & 64;
  if (D.27016 != 0) goto <D.27017>; else goto <D.27018>;
  <D.27017>:
  D.27015 = fb->attrs;
  D.27019 = D.27015 | 32768;
  fb->attrs = D.27019;
  <D.27018>:
  table = &assembly->tables[4];
  D.27020 = table->next_idx;
  D.27021 = D.27020;
  D.27022 = D.27021 + 1;
  table->next_idx = D.27022;
  D.27023 = (int) D.27021;
  fb->table_idx = D.27023;
  D.27024 = assembly->field_to_table_idx;
  D.27025 = fb->handle;
  D.27026 = fb->table_idx;
  D.27027 = (long unsigned int) D.27026;
  D.27028 = (void *) D.27027;
  monoeg_g_hash_table_insert_replace (D.27024, D.27025, D.27028, 0);
  D.27029 = table->values;
  D.27026 = fb->table_idx;
  D.27030 = D.27026 * 3;
  D.27031 = (long unsigned int) D.27030;
  D.27032 = D.27031 * 4;
  values = D.27029 + D.27032;
  D.27033 = values + 4;
  D.27034 = &assembly->sheap;
  D.27035 = fb->name;
  D.27036 = string_heap_insert_mstring (D.27034, D.27035);
  *D.27033 = D.27036;
  D.27015 = fb->attrs;
  *values = D.27015;
  D.27037 = values + 8;
  D.27038 = field_encode_signature (assembly, fb);
  *D.27037 = D.27038;
  D.27039 = fb->offset;
  if (D.27039 != -1) goto <D.27040>; else goto <D.27041>;
  <D.27040>:
  table = &assembly->tables[16];
  D.27042 = table->rows;
  D.27043 = D.27042 + 1;
  table->rows = D.27043;
  D.27042 = table->rows;
  alloc_table (table, D.27042);
  D.27029 = table->values;
  D.27042 = table->rows;
  D.27044 = D.27042 * 2;
  D.27045 = (long unsigned int) D.27044;
  D.27046 = D.27045 * 4;
  values = D.27029 + D.27046;
  D.27033 = values + 4;
  D.27026 = fb->table_idx;
  D.27047 = (unsigned int) D.27026;
  *D.27033 = D.27047;
  D.27039 = fb->offset;
  D.27048 = (unsigned int) D.27039;
  *values = D.27048;
  <D.27041>:
  D.27015 = fb->attrs;
  D.27016 = D.27015 & 64;
  if (D.27016 != 0) goto <D.27049>; else goto <D.27050>;
  <D.27049>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.27042 = table->rows;
        D.27043 = D.27042 + 1;
        table->rows = D.27043;
        D.27042 = table->rows;
        alloc_table (table, D.27042);
        D.27029 = table->values;
        D.27042 = table->rows;
        D.27051 = D.27042 * 4;
        D.27052 = (long unsigned int) D.27051;
        D.27053 = D.27052 * 4;
        values = D.27029 + D.27053;
        D.27037 = values + 8;
        D.27026 = fb->table_idx;
        D.27054 = D.27026 << 2;
        D.27055 = (unsigned int) D.27054;
        *D.27037 = D.27055;
        D.27056 = values + 12;
        D.27057 = fb->def_value;
        D.27058 = encode_constant (assembly, D.27057, &field_type);
        *D.27056 = D.27058;
        field_type.91 = field_type;
        *values = field_type.91;
        D.27033 = values + 4;
        *D.27033 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.27050>:
  D.27015 = fb->attrs;
  D.27060 = D.27015 & 256;
  if (D.27060 != 0) goto <D.27061>; else goto <D.27062>;
  <D.27061>:
  {
    guint32 rva_idx;

    table = &assembly->tables[29];
    D.27042 = table->rows;
    D.27043 = D.27042 + 1;
    table->rows = D.27043;
    D.27042 = table->rows;
    alloc_table (table, D.27042);
    D.27029 = table->values;
    D.27042 = table->rows;
    D.27044 = D.27042 * 2;
    D.27045 = (long unsigned int) D.27044;
    D.27046 = D.27045 * 4;
    values = D.27029 + D.27046;
    D.27033 = values + 4;
    D.27026 = fb->table_idx;
    D.27047 = (unsigned int) D.27026;
    *D.27033 = D.27047;
    D.27063 = fb->rva_data;
    if (D.27063 != 0B) goto <D.27064>; else goto <D.27065>;
    <D.27064>:
    D.27063 = fb->rva_data;
    D.27066 = mono_array_length (D.27063);
    if (D.27066 > 9) goto <D.27067>; else goto <D.27068>;
    <D.27067>:
    D.27069 = &assembly->code;
    stream_data_align (D.27069);
    <D.27068>:
    D.27069 = &assembly->code;
    D.27063 = fb->rva_data;
    D.27070 = mono_array_addr_with_size (D.27063, 1, 0);
    D.27063 = fb->rva_data;
    D.27071 = mono_array_length (D.27063);
    D.27072 = (unsigned int) D.27071;
    rva_idx = mono_image_add_stream_data (D.27069, D.27070, D.27072);
    goto <D.27073>;
    <D.27065>:
    D.27069 = &assembly->code;
    D.27025 = fb->handle;
    D.27074 = D.27025->parent;
    D.27075 = mono_class_value_size (D.27074, 0B);
    D.27076 = (unsigned int) D.27075;
    rva_idx = mono_image_add_stream_zero (D.27069, D.27076);
    <D.27073>:
    D.27077 = assembly->text_rva;
    D.27078 = D.27077 + rva_idx;
    *values = D.27078;
  }
  <D.27062>:
  D.27079 = fb->marshal_info;
  if (D.27079 != 0B) goto <D.27080>; else goto <D.27081>;
  <D.27080>:
  table = &assembly->tables[13];
  D.27042 = table->rows;
  D.27043 = D.27042 + 1;
  table->rows = D.27043;
  D.27042 = table->rows;
  alloc_table (table, D.27042);
  D.27029 = table->values;
  D.27042 = table->rows;
  D.27044 = D.27042 * 2;
  D.27045 = (long unsigned int) D.27044;
  D.27046 = D.27045 * 4;
  values = D.27029 + D.27046;
  D.27026 = fb->table_idx;
  D.27082 = D.27026 << 1;
  D.27083 = (unsigned int) D.27082;
  *values = D.27083;
  D.27033 = values + 4;
  D.27079 = fb->marshal_info;
  D.27084 = encode_marshal_blob (assembly, D.27079);
  *D.27033 = D.27084;
  <D.27081>:
}


field_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoObject * D.27085;
  struct MonoArray * D.27086;
  struct MonoArray * D.27087;
  struct MonoGenericContainer * D.27088;
  struct MonoGenericInst * D.27093;
  guint32 D.27095;
  struct SigBuffer buf;
  guint32 idx;
  guint32 typespec;
  struct MonoType * type;
  struct MonoClass * class;

  try
    {
      typespec = 0;
      D.27085 = fb->type;
      init_type_builder_generics (D.27085);
      D.27085 = fb->type;
      type = mono_reflection_type_get_handle (D.27085);
      class = mono_class_from_mono_type (type);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.27086 = fb->modreq;
      D.27087 = fb->modopt;
      encode_custom_modifiers (assembly, D.27086, D.27087, &buf);
      D.27088 = class->generic_container;
      if (D.27088 != 0B) goto <D.27089>; else goto <D.27090>;
      <D.27089>:
      typespec = create_typespec (assembly, type);
      <D.27090>:
      if (typespec != 0) goto <D.27091>; else goto <D.27092>;
      <D.27091>:
      {
        struct MonoGenericClass * gclass;

        D.27088 = class->generic_container;
        D.27093 = D.27088->context.class_inst;
        gclass = mono_metadata_lookup_generic_class (class, D.27093, 1);
        encode_generic_class (assembly, gclass, &buf);
      }
      goto <D.27094>;
      <D.27092>:
      encode_type (assembly, type, &buf);
      <D.27094>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27095 = idx;
      return D.27095;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


init_type_builder_generics (struct MonoObject * type)
{
  struct MonoVTable * D.27098;
  struct MonoClass * D.27099;
  int D.27100;
  struct MonoGenericContainer * D.27105;
  struct MonoReflectionTypeBuilder * tb;

  D.27098 = type->vtable;
  D.27099 = D.27098->klass;
  D.27100 = is_sre_type_builder (D.27099);
  if (D.27100 == 0) goto <D.27101>; else goto <D.27102>;
  <D.27101>:
  return;
  <D.27102>:
  tb = type;
  if (tb != 0B) goto <D.27103>; else goto <D.27104>;
  <D.27103>:
  D.27105 = tb->generic_container;
  if (D.27105 != 0B) goto <D.27106>; else goto <D.27107>;
  <D.27106>:
  mono_reflection_create_generic_class (tb);
  <D.27107>:
  <D.27104>:
}


is_sre_type_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.92;
  gboolean D.27112;
  _Bool D.27113;
  int D.27114;
  int D.23118;
  int iftmp.93;
  int D.23114;
  const char[12] * D.27120;
  unsigned char D.27121;
  int D.27122;
  unsigned char D.27123;
  int D.27124;
  const unsigned char * D.27129;
  unsigned char D.27130;
  int D.27131;
  const unsigned char * D.27132;
  unsigned char D.27133;
  int D.27134;
  const unsigned char * D.27139;
  unsigned char D.27140;
  int D.27141;
  const unsigned char * D.27142;
  unsigned char D.27143;
  int D.27144;
  const unsigned char * D.27149;
  unsigned char D.27150;
  int D.27151;
  const unsigned char * D.27152;
  unsigned char D.27153;
  int D.27154;
  const char * D.27156;
  int D.23127;
  int iftmp.94;
  int D.23123;
  const char[23] * D.27162;
  unsigned char D.27163;
  int D.27164;
  unsigned char D.27165;
  int D.27166;
  const unsigned char * D.27171;
  unsigned char D.27172;
  int D.27173;
  const unsigned char * D.27174;
  unsigned char D.27175;
  int D.27176;
  const unsigned char * D.27181;
  unsigned char D.27182;
  int D.27183;
  const unsigned char * D.27184;
  unsigned char D.27185;
  int D.27186;
  const unsigned char * D.27191;
  unsigned char D.27192;
  int D.27193;
  const unsigned char * D.27194;
  unsigned char D.27195;
  int D.27196;
  const char * D.27198;

  {
    static struct MonoClass * cached_class;

    cached_class.92 = cached_class;
    if (cached_class.92 != 0B) goto <D.27110>; else goto <D.27111>;
    <D.27110>:
    cached_class.92 = cached_class;
    D.27113 = cached_class.92 == class;
    D.27112 = (gboolean) D.27113;
    return D.27112;
    <D.27111>:
    D.27114 = is_corlib_type (class);
    if (D.27114 != 0) goto <D.27115>; else goto <D.27116>;
    <D.27115>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.27120 = "TypeBuilder";
        D.27121 = MEM[(const unsigned char *)D.27120];
        D.27122 = (int) D.27121;
        D.27123 = *__s2;
        D.27124 = (int) D.27123;
        __result = D.27122 - D.27124;
        {
          if (__s1_len != 0) goto <D.27125>; else goto <D.27126>;
          <D.27125>:
          if (__result == 0) goto <D.27127>; else goto <D.27128>;
          <D.27127>:
          D.27129 = &MEM[(void *)"TypeBuilder" + 1B];
          D.27130 = *D.27129;
          D.27131 = (int) D.27130;
          D.27132 = __s2 + 1;
          D.27133 = *D.27132;
          D.27134 = (int) D.27133;
          __result = D.27131 - D.27134;
          if (__s1_len > 1) goto <D.27135>; else goto <D.27136>;
          <D.27135>:
          if (__result == 0) goto <D.27137>; else goto <D.27138>;
          <D.27137>:
          D.27139 = &MEM[(void *)"TypeBuilder" + 2B];
          D.27140 = *D.27139;
          D.27141 = (int) D.27140;
          D.27142 = __s2 + 2;
          D.27143 = *D.27142;
          D.27144 = (int) D.27143;
          __result = D.27141 - D.27144;
          if (__s1_len > 2) goto <D.27145>; else goto <D.27146>;
          <D.27145>:
          if (__result == 0) goto <D.27147>; else goto <D.27148>;
          <D.27147>:
          D.27149 = &MEM[(void *)"TypeBuilder" + 3B];
          D.27150 = *D.27149;
          D.27151 = (int) D.27150;
          D.27152 = __s2 + 3;
          D.27153 = *D.27152;
          D.27154 = (int) D.27153;
          __result = D.27151 - D.27154;
          <D.27148>:
          <D.27146>:
          <D.27138>:
          <D.27136>:
          <D.27128>:
          <D.27126>:
        }
        D.23114 = __result;
      }
      iftmp.93 = D.23114;
      goto <D.27155>;
      <D.27119>:
      D.27156 = class->name;
      iftmp.93 = __builtin_strcmp ("TypeBuilder", D.27156);
      <D.27155>:
      D.23118 = iftmp.93;
    }
    if (D.23118 == 0) goto <D.27157>; else goto <D.27158>;
    <D.27157>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.27162 = "System.Reflection.Emit";
        D.27163 = MEM[(const unsigned char *)D.27162];
        D.27164 = (int) D.27163;
        D.27165 = *__s2;
        D.27166 = (int) D.27165;
        __result = D.27164 - D.27166;
        {
          if (__s1_len != 0) goto <D.27167>; else goto <D.27168>;
          <D.27167>:
          if (__result == 0) goto <D.27169>; else goto <D.27170>;
          <D.27169>:
          D.27171 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.27172 = *D.27171;
          D.27173 = (int) D.27172;
          D.27174 = __s2 + 1;
          D.27175 = *D.27174;
          D.27176 = (int) D.27175;
          __result = D.27173 - D.27176;
          if (__s1_len > 1) goto <D.27177>; else goto <D.27178>;
          <D.27177>:
          if (__result == 0) goto <D.27179>; else goto <D.27180>;
          <D.27179>:
          D.27181 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.27182 = *D.27181;
          D.27183 = (int) D.27182;
          D.27184 = __s2 + 2;
          D.27185 = *D.27184;
          D.27186 = (int) D.27185;
          __result = D.27183 - D.27186;
          if (__s1_len > 2) goto <D.27187>; else goto <D.27188>;
          <D.27187>:
          if (__result == 0) goto <D.27189>; else goto <D.27190>;
          <D.27189>:
          D.27191 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.27192 = *D.27191;
          D.27193 = (int) D.27192;
          D.27194 = __s2 + 3;
          D.27195 = *D.27194;
          D.27196 = (int) D.27195;
          __result = D.27193 - D.27196;
          <D.27190>:
          <D.27188>:
          <D.27180>:
          <D.27178>:
          <D.27170>:
          <D.27168>:
        }
        D.23123 = __result;
      }
      iftmp.94 = D.23123;
      goto <D.27197>;
      <D.27161>:
      D.27198 = class->name_space;
      iftmp.94 = __builtin_strcmp ("System.Reflection.Emit", D.27198);
      <D.27197>:
      D.23127 = iftmp.94;
    }
    if (D.23127 == 0) goto <D.27199>; else goto <D.27200>;
    <D.27199>:
    cached_class = class;
    D.27112 = 1;
    return D.27112;
    <D.27200>:
    <D.27158>:
    <D.27116>:
    D.27112 = 0;
    return D.27112;
  }
}


is_corlib_type (struct MonoClass * class)
{
  gboolean D.27202;
  struct MonoImage * D.27203;
  struct MonoImage * D.27204;
  _Bool D.27205;

  D.27203 = class->image;
  D.27204 = mono_defaults.corlib;
  D.27205 = D.27203 == D.27204;
  D.27202 = (gboolean) D.27205;
  return D.27202;
}


mono_image_add_stream_zero (struct MonoDynamicStream * stream, guint32 len)
{
  unsigned int D.27207;
  unsigned int D.27208;
  int D.27209;
  char * D.27210;
  sizetype D.27211;
  void * D.27212;
  long unsigned int D.27213;
  guint32 D.27214;
  guint32 idx;

  D.27207 = stream->index;
  D.27208 = D.27207 + len;
  D.27209 = (int) D.27208;
  make_room_in_stream (stream, D.27209);
  D.27210 = stream->data;
  D.27207 = stream->index;
  D.27211 = (sizetype) D.27207;
  D.27212 = D.27210 + D.27211;
  D.27213 = (long unsigned int) len;
  memset (D.27212, 0, D.27213);
  idx = stream->index;
  D.27207 = stream->index;
  D.27208 = D.27207 + len;
  stream->index = D.27208;
  D.27214 = idx;
  return D.27214;
}


mono_image_fill_module_table (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27216;
  unsigned int D.27217;
  unsigned int D.27218;
  guint32 * D.27219;
  unsigned int D.27220;
  unsigned int D.27221;
  unsigned int D.27222;
  long unsigned int D.27223;
  long unsigned int D.27224;
  guint32 * D.27225;
  struct MonoDynamicStream * D.27226;
  struct MonoString * D.27227;
  unsigned int D.27228;
  struct MonoDynamicStream * D.27229;
  struct MonoArray * D.27230;
  char * D.27231;
  unsigned int D.27232;
  long unsigned int D.27233;
  long unsigned int D.27234;
  guint32 * D.27235;
  unsigned int D.27236;
  long unsigned int D.27237;
  long unsigned int D.27238;
  guint32 * D.27239;
  unsigned int i.95;
  unsigned int D.27241;
  long unsigned int D.27242;
  long unsigned int D.27243;
  guint32 * D.27244;
  unsigned int D.27245;
  long unsigned int D.27246;
  long unsigned int D.27247;
  guint32 * D.27248;
  struct MonoDynamicTable * table;
  int i;

  table = &assembly->tables[0];
  D.27216 = table->next_idx;
  D.27217 = D.27216;
  D.27218 = D.27217 + 1;
  table->next_idx = D.27218;
  mb->table_idx = D.27217;
  D.27219 = table->values;
  D.27220 = mb->table_idx;
  D.27221 = D.27220 * 5;
  D.27222 = D.27221 + 1;
  D.27223 = (long unsigned int) D.27222;
  D.27224 = D.27223 * 4;
  D.27225 = D.27219 + D.27224;
  D.27226 = &assembly->sheap;
  D.27227 = mb->module.name;
  D.27228 = string_heap_insert_mstring (D.27226, D.27227);
  *D.27225 = D.27228;
  D.27229 = &assembly->guid;
  D.27230 = mb->guid;
  D.27231 = mono_array_addr_with_size (D.27230, 1, 0);
  D.27232 = mono_image_add_stream_data (D.27229, D.27231, 16);
  i = (int) D.27232;
  i = i / 16;
  i = i + 1;
  D.27219 = table->values;
  D.27220 = mb->table_idx;
  D.27221 = D.27220 * 5;
  D.27233 = (long unsigned int) D.27221;
  D.27234 = D.27233 * 4;
  D.27235 = D.27219 + D.27234;
  *D.27235 = 0;
  D.27219 = table->values;
  D.27220 = mb->table_idx;
  D.27221 = D.27220 * 5;
  D.27236 = D.27221 + 2;
  D.27237 = (long unsigned int) D.27236;
  D.27238 = D.27237 * 4;
  D.27239 = D.27219 + D.27238;
  i.95 = (unsigned int) i;
  *D.27239 = i.95;
  D.27219 = table->values;
  D.27220 = mb->table_idx;
  D.27221 = D.27220 * 5;
  D.27241 = D.27221 + 3;
  D.27242 = (long unsigned int) D.27241;
  D.27243 = D.27242 * 4;
  D.27244 = D.27219 + D.27243;
  *D.27244 = 0;
  D.27219 = table->values;
  D.27220 = mb->table_idx;
  D.27221 = D.27220 * 5;
  D.27245 = D.27221 + 4;
  D.27246 = (long unsigned int) D.27245;
  D.27247 = D.27246 * 4;
  D.27248 = D.27219 + D.27247;
  *D.27248 = 0;
}


collect_types (struct MonoPtrArray * types, struct MonoReflectionTypeBuilder * type)
{
  int D.27249;
  int D.27250;
  long unsigned int D.27253;
  long unsigned int D.27254;
  int D.27255;
  void * D.27256;
  void * * D.27257;
  long unsigned int D.27258;
  int D.27261;
  int D.27262;
  long unsigned int D.27263;
  long unsigned int D.27264;
  void * * D.27265;
  struct MonoArray * D.27266;
  long unsigned int D.27269;
  char * D.27270;
  long unsigned int D.27271;
  int i;

  D.27249 = types->size;
  D.27250 = types->capacity;
  if (D.27249 >= D.27250) goto <D.27251>; else goto <D.27252>;
  <D.27251>:
  {
    void * __tmp;

    D.27250 = types->capacity;
    D.27253 = (long unsigned int) D.27250;
    D.27254 = D.27253 * 16;
    D.27250 = types->capacity;
    D.27255 = D.27250 * 2;
    D.27256 = mono_gc_make_root_descr_all_refs (D.27255);
    __tmp = mono_gc_alloc_fixed (D.27254, D.27256);
    D.27257 = types->data;
    D.27250 = types->capacity;
    D.27253 = (long unsigned int) D.27250;
    D.27258 = D.27253 * 8;
    mono_gc_memmove_aligned (__tmp, D.27257, D.27258);
    D.27250 = types->capacity;
    if (D.27250 > 16) goto <D.27259>; else goto <D.27260>;
    <D.27259>:
    D.27257 = types->data;
    mono_gc_free_fixed (D.27257);
    <D.27260>:
    types->data = __tmp;
    D.27250 = types->capacity;
    D.27255 = D.27250 * 2;
    types->capacity = D.27255;
  }
  <D.27252>:
  D.27257 = types->data;
  D.27249 = types->size;
  D.27261 = D.27249;
  D.27262 = D.27261 + 1;
  types->size = D.27262;
  D.27263 = (long unsigned int) D.27261;
  D.27264 = D.27263 * 8;
  D.27265 = D.27257 + D.27264;
  *D.27265 = type;
  D.27266 = type->subtypes;
  if (D.27266 == 0B) goto <D.27267>; else goto <D.27268>;
  <D.27267>:
  return;
  <D.27268>:
  i = 0;
  goto <D.20311>;
  <D.20310>:
  {
    struct MonoReflectionTypeBuilder * subtype;

    D.27266 = type->subtypes;
    D.27269 = (long unsigned int) i;
    D.27270 = mono_array_addr_with_size (D.27266, 8, D.27269);
    subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.27270];
    collect_types (types, subtype);
  }
  i = i + 1;
  <D.20311>:
  D.27269 = (long unsigned int) i;
  D.27266 = type->subtypes;
  D.27271 = mono_array_length (D.27266);
  if (D.27269 < D.27271) goto <D.20310>; else goto <D.20312>;
  <D.20312>:
}


alloc_table (struct MonoDynamicTable * table, guint nrows)
{
  unsigned char D.27273;
  _Bool D.27274;
  long int D.27275;
  long int D.27276;
  unsigned int D.27279;
  unsigned int D.27280;
  unsigned int D.27286;
  guint32 * D.27287;
  long unsigned int D.27288;
  long unsigned int D.27289;
  long unsigned int D.27290;
  long unsigned int D.27291;
  void * D.27292;

  table->rows = nrows;
  D.27273 = table->columns;
  D.27274 = D.27273 == 0;
  D.27275 = (long int) D.27274;
  D.27276 = __builtin_expect (D.27275, 0);
  if (D.27276 != 0) goto <D.27277>; else goto <D.27278>;
  <D.27277>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 327, "table->columns");
  <D.27278>:
  D.27279 = nrows + 1;
  D.27280 = table->alloc_rows;
  if (D.27279 >= D.27280) goto <D.27281>; else goto <D.27282>;
  <D.27281>:
  goto <D.19232>;
  <D.19231>:
  D.27280 = table->alloc_rows;
  if (D.27280 == 0) goto <D.27283>; else goto <D.27284>;
  <D.27283>:
  table->alloc_rows = 16;
  goto <D.27285>;
  <D.27284>:
  D.27280 = table->alloc_rows;
  D.27286 = D.27280 * 2;
  table->alloc_rows = D.27286;
  <D.27285>:
  <D.19232>:
  D.27279 = nrows + 1;
  D.27280 = table->alloc_rows;
  if (D.27279 >= D.27280) goto <D.19231>; else goto <D.19233>;
  <D.19233>:
  D.27287 = table->values;
  D.27280 = table->alloc_rows;
  D.27288 = (long unsigned int) D.27280;
  D.27273 = table->columns;
  D.27289 = (long unsigned int) D.27273;
  D.27290 = D.27288 * D.27289;
  D.27291 = D.27290 * 4;
  D.27292 = monoeg_realloc (D.27287, D.27291);
  table->values = D.27292;
  <D.27282>:
}


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

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


mono_image_get_type_info (struct MonoDomain * domain, struct MonoReflectionTypeBuilder * tb, struct MonoDynamicImage * assembly)
{
  guint32 * D.27295;
  unsigned int D.27296;
  unsigned int D.27297;
  long unsigned int D.27298;
  long unsigned int D.27299;
  unsigned int D.27300;
  struct MonoString * D.27301;
  int D.20265;
  int iftmp.96;
  int D.20264;
  const char[7] * D.27305;
  unsigned char D.27306;
  int D.27307;
  unsigned char D.27308;
  int D.27309;
  const unsigned char * D.27314;
  unsigned char D.27315;
  int D.27316;
  const unsigned char * D.27317;
  unsigned char D.27318;
  int D.27319;
  const unsigned char * D.27324;
  unsigned char D.27325;
  int D.27326;
  const unsigned char * D.27327;
  unsigned char D.27328;
  int D.27329;
  const unsigned char * D.27334;
  unsigned char D.27335;
  int D.27336;
  const unsigned char * D.27337;
  unsigned char D.27338;
  int D.27339;
  guint * D.27343;
  struct MonoDynamicStream * D.27344;
  unsigned int D.27345;
  struct MonoString * D.27346;
  int D.20274;
  int iftmp.97;
  int D.20273;
  const char[7] * D.27350;
  unsigned char D.27351;
  int D.27352;
  unsigned char D.27353;
  int D.27354;
  const unsigned char * D.27359;
  unsigned char D.27360;
  int D.27361;
  const unsigned char * D.27362;
  unsigned char D.27363;
  int D.27364;
  const unsigned char * D.27369;
  unsigned char D.27370;
  int D.27371;
  const unsigned char * D.27372;
  unsigned char D.27373;
  int D.27374;
  const unsigned char * D.27379;
  unsigned char D.27380;
  int D.27381;
  const unsigned char * D.27382;
  unsigned char D.27383;
  int D.27384;
  guint * D.27388;
  unsigned int D.27389;
  struct MonoObject * D.27393;
  unsigned int D.27396;
  guint * D.27398;
  struct MonoType * D.27399;
  unsigned int D.27400;
  guint * D.27401;
  unsigned int D.27402;
  guint * D.27403;
  unsigned int D.27404;
  unsigned int D.27407;
  int D.27410;
  int D.27412;
  unsigned int D.27413;
  unsigned int D.27414;
  unsigned int D.27415;
  long unsigned int D.27416;
  long unsigned int D.27417;
  unsigned int D.27418;
  unsigned int D.27419;
  struct MonoArray * D.27420;
  long unsigned int D.27423;
  unsigned int D.27424;
  unsigned int D.27425;
  int D.27426;
  int D.27427;
  long unsigned int D.27428;
  long unsigned int D.27429;
  long unsigned int D.27430;
  char * D.27431;
  struct MonoType * D.27432;
  unsigned int D.27433;
  long unsigned int D.27434;
  struct MonoArray * D.27435;
  int D.27438;
  unsigned int D.27439;
  unsigned int D.27440;
  char * D.27441;
  struct MonoReflectionFieldBuilder * D.27442;
  struct MonoArray * D.27443;
  long unsigned int D.27446;
  unsigned int D.27447;
  unsigned int D.27448;
  char * D.27449;
  struct MonoReflectionCtorBuilder * D.27450;
  long unsigned int D.27451;
  struct MonoArray * D.27452;
  int D.27455;
  unsigned int D.27456;
  unsigned int D.27457;
  char * D.27458;
  struct MonoReflectionMethodBuilder * D.27459;
  struct MonoArray * D.27460;
  long unsigned int D.27463;
  long unsigned int D.27466;
  unsigned int D.27467;
  unsigned int D.27468;
  unsigned int D.27469;
  long unsigned int D.27470;
  long unsigned int D.27471;
  unsigned int D.27472;
  char * D.27473;
  struct MonoReflectionEventBuilder * D.27474;
  long unsigned int D.27475;
  struct MonoArray * D.27476;
  long unsigned int D.27479;
  long unsigned int D.27482;
  unsigned int D.27483;
  unsigned int D.27484;
  unsigned int D.27485;
  char * D.27486;
  struct MonoReflectionPropertyBuilder * D.27487;
  long unsigned int D.27488;
  struct MonoArray * D.27489;
  long unsigned int D.27492;
  unsigned int D.27493;
  unsigned int D.27494;
  char * D.27495;
  struct MonoReflectionGenericParam * D.27496;
  long unsigned int D.27497;
  unsigned int D.27498;
  struct MonoArray * D.27499;
  struct MonoArray * D.27500;
  long unsigned int D.27503;
  unsigned int D.27504;
  unsigned int D.27505;
  unsigned int D.27506;
  guint32 * D.27507;
  unsigned int D.27508;
  unsigned int D.27509;
  long unsigned int D.27510;
  long unsigned int D.27511;
  char * D.27512;
  unsigned int D.27513;
  unsigned int D.27514;
  long unsigned int D.27515;
  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.27295 = table->values;
  D.27296 = tb->table_idx;
  D.27297 = D.27296 * 6;
  D.27298 = (long unsigned int) D.27297;
  D.27299 = D.27298 * 4;
  values = D.27295 + D.27299;
  D.27300 = tb->attrs;
  *values = D.27300;
  D.27301 = tb->name;
  n = mono_string_to_utf8 (D.27301);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.27305 = "Object";
      D.27306 = MEM[(const unsigned char *)D.27305];
      D.27307 = (int) D.27306;
      D.27308 = *__s2;
      D.27309 = (int) D.27308;
      __result = D.27307 - D.27309;
      {
        if (__s2_len != 0) goto <D.27310>; else goto <D.27311>;
        <D.27310>:
        if (__result == 0) goto <D.27312>; else goto <D.27313>;
        <D.27312>:
        D.27314 = &MEM[(void *)"Object" + 1B];
        D.27315 = *D.27314;
        D.27316 = (int) D.27315;
        D.27317 = __s2 + 1;
        D.27318 = *D.27317;
        D.27319 = (int) D.27318;
        __result = D.27316 - D.27319;
        if (__s2_len > 1) goto <D.27320>; else goto <D.27321>;
        <D.27320>:
        if (__result == 0) goto <D.27322>; else goto <D.27323>;
        <D.27322>:
        D.27324 = &MEM[(void *)"Object" + 2B];
        D.27325 = *D.27324;
        D.27326 = (int) D.27325;
        D.27327 = __s2 + 2;
        D.27328 = *D.27327;
        D.27329 = (int) D.27328;
        __result = D.27326 - D.27329;
        if (__s2_len > 2) goto <D.27330>; else goto <D.27331>;
        <D.27330>:
        if (__result == 0) goto <D.27332>; else goto <D.27333>;
        <D.27332>:
        D.27334 = &MEM[(void *)"Object" + 3B];
        D.27335 = *D.27334;
        D.27336 = (int) D.27335;
        D.27337 = __s2 + 3;
        D.27338 = *D.27337;
        D.27339 = (int) D.27338;
        __result = D.27336 - D.27339;
        <D.27333>:
        <D.27331>:
        <D.27323>:
        <D.27321>:
        <D.27313>:
        <D.27311>:
      }
      D.20264 = __result;
    }
    iftmp.96 = -D.20264;
    goto <D.27340>;
    <D.27304>:
    iftmp.96 = __builtin_strcmp (n, "Object");
    <D.27340>:
    D.20265 = iftmp.96;
  }
  if (D.20265 == 0) goto <D.27341>; else goto <D.27342>;
  <D.27341>:
  is_object = is_object + 1;
  <D.27342>:
  D.27343 = values + 4;
  D.27344 = &assembly->sheap;
  D.27345 = string_heap_insert (D.27344, n);
  *D.27343 = D.27345;
  monoeg_g_free (n);
  D.27346 = tb->nspace;
  n = mono_string_to_utf8 (D.27346);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.27350 = "System";
      D.27351 = MEM[(const unsigned char *)D.27350];
      D.27352 = (int) D.27351;
      D.27353 = *__s2;
      D.27354 = (int) D.27353;
      __result = D.27352 - D.27354;
      {
        if (__s2_len != 0) goto <D.27355>; else goto <D.27356>;
        <D.27355>:
        if (__result == 0) goto <D.27357>; else goto <D.27358>;
        <D.27357>:
        D.27359 = &MEM[(void *)"System" + 1B];
        D.27360 = *D.27359;
        D.27361 = (int) D.27360;
        D.27362 = __s2 + 1;
        D.27363 = *D.27362;
        D.27364 = (int) D.27363;
        __result = D.27361 - D.27364;
        if (__s2_len > 1) goto <D.27365>; else goto <D.27366>;
        <D.27365>:
        if (__result == 0) goto <D.27367>; else goto <D.27368>;
        <D.27367>:
        D.27369 = &MEM[(void *)"System" + 2B];
        D.27370 = *D.27369;
        D.27371 = (int) D.27370;
        D.27372 = __s2 + 2;
        D.27373 = *D.27372;
        D.27374 = (int) D.27373;
        __result = D.27371 - D.27374;
        if (__s2_len > 2) goto <D.27375>; else goto <D.27376>;
        <D.27375>:
        if (__result == 0) goto <D.27377>; else goto <D.27378>;
        <D.27377>:
        D.27379 = &MEM[(void *)"System" + 3B];
        D.27380 = *D.27379;
        D.27381 = (int) D.27380;
        D.27382 = __s2 + 3;
        D.27383 = *D.27382;
        D.27384 = (int) D.27383;
        __result = D.27381 - D.27384;
        <D.27378>:
        <D.27376>:
        <D.27368>:
        <D.27366>:
        <D.27358>:
        <D.27356>:
      }
      D.20273 = __result;
    }
    iftmp.97 = -D.20273;
    goto <D.27385>;
    <D.27349>:
    iftmp.97 = __builtin_strcmp (n, "System");
    <D.27385>:
    D.20274 = iftmp.97;
  }
  if (D.20274 == 0) goto <D.27386>; else goto <D.27387>;
  <D.27386>:
  is_system = is_system + 1;
  <D.27387>:
  D.27388 = values + 8;
  D.27344 = &assembly->sheap;
  D.27389 = string_heap_insert (D.27344, n);
  *D.27388 = D.27389;
  monoeg_g_free (n);
  D.27393 = tb->parent;
  if (D.27393 != 0B) goto <D.27394>; else goto <D.27390>;
  <D.27394>:
  if (is_system == 0) goto <D.27391>; else goto <D.27395>;
  <D.27395>:
  if (is_object == 0) goto <D.27391>; else goto <D.27390>;
  <D.27391>:
  D.27300 = tb->attrs;
  D.27396 = D.27300 & 32;
  if (D.27396 == 0) goto <D.27397>; else goto <D.27390>;
  <D.27397>:
  D.27398 = values + 12;
  D.27393 = tb->parent;
  D.27399 = mono_reflection_type_get_handle (D.27393);
  D.27400 = mono_image_typedef_or_ref (assembly, D.27399);
  *D.27398 = D.27400;
  goto <D.27392>;
  <D.27390>:
  D.27398 = values + 12;
  *D.27398 = 0;
  <D.27392>:
  D.27401 = values + 16;
  D.27402 = assembly->tables[4].next_idx;
  *D.27401 = D.27402;
  D.27403 = values + 20;
  D.27404 = assembly->tables[6].next_idx;
  *D.27403 = D.27404;
  D.27300 = tb->attrs;
  D.27407 = D.27300 & 24;
  if (D.27407 != 0) goto <D.27408>; else goto <D.27409>;
  <D.27408>:
  D.27410 = tb->class_size;
  if (D.27410 > 0) goto <D.27405>; else goto <D.27411>;
  <D.27411>:
  D.27412 = tb->packing_size;
  if (D.27412 > 0) goto <D.27405>; else goto <D.27406>;
  <D.27405>:
  table = &assembly->tables[15];
  D.27413 = table->rows;
  D.27414 = D.27413 + 1;
  table->rows = D.27414;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  D.27295 = table->values;
  D.27413 = table->rows;
  D.27415 = D.27413 * 3;
  D.27416 = (long unsigned int) D.27415;
  D.27417 = D.27416 * 4;
  values = D.27295 + D.27417;
  D.27388 = values + 8;
  D.27296 = tb->table_idx;
  *D.27388 = D.27296;
  D.27343 = values + 4;
  D.27410 = tb->class_size;
  D.27418 = (unsigned int) D.27410;
  *D.27343 = D.27418;
  D.27412 = tb->packing_size;
  D.27419 = (unsigned int) D.27412;
  *values = D.27419;
  <D.27406>:
  <D.27409>:
  D.27420 = tb->interfaces;
  if (D.27420 != 0B) goto <D.27421>; else goto <D.27422>;
  <D.27421>:
  table = &assembly->tables[9];
  D.27413 = table->rows;
  i = (int) D.27413;
  D.27420 = tb->interfaces;
  D.27423 = mono_array_length (D.27420);
  D.27413 = table->rows;
  D.27424 = (unsigned int) D.27423;
  D.27425 = D.27413 + D.27424;
  table->rows = D.27425;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  D.27295 = table->values;
  D.27426 = i + 1;
  D.27427 = D.27426 * 2;
  D.27428 = (long unsigned int) D.27427;
  D.27429 = D.27428 * 4;
  values = D.27295 + D.27429;
  i = 0;
  goto <D.20277>;
  <D.20276>:
  {
    struct MonoReflectionType * iface;

    D.27420 = tb->interfaces;
    D.27430 = (long unsigned int) i;
    D.27431 = mono_array_addr_with_size (D.27420, 8, D.27430);
    iface = MEM[(void * *)D.27431];
    D.27296 = tb->table_idx;
    *values = D.27296;
    D.27343 = values + 4;
    D.27432 = mono_reflection_type_get_handle (iface);
    D.27433 = mono_image_typedef_or_ref (assembly, D.27432);
    *D.27343 = D.27433;
    values = values + 8;
  }
  i = i + 1;
  <D.20277>:
  D.27430 = (long unsigned int) i;
  D.27420 = tb->interfaces;
  D.27434 = mono_array_length (D.27420);
  if (D.27430 < D.27434) goto <D.20276>; else goto <D.20278>;
  <D.20278>:
  <D.27422>:
  D.27435 = tb->fields;
  if (D.27435 != 0B) goto <D.27436>; else goto <D.27437>;
  <D.27436>:
  table = &assembly->tables[4];
  D.27413 = table->rows;
  D.27438 = tb->num_fields;
  D.27439 = (unsigned int) D.27438;
  D.27440 = D.27413 + D.27439;
  table->rows = D.27440;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  i = 0;
  goto <D.20280>;
  <D.20279>:
  D.27435 = tb->fields;
  D.27430 = (long unsigned int) i;
  D.27441 = mono_array_addr_with_size (D.27435, 8, D.27430);
  D.27442 = MEM[(struct MonoReflectionFieldBuilder * *)D.27441];
  mono_image_get_field_info (D.27442, assembly);
  i = i + 1;
  <D.20280>:
  D.27438 = tb->num_fields;
  if (D.27438 > i) goto <D.20279>; else goto <D.20281>;
  <D.20281>:
  <D.27437>:
  D.27443 = tb->ctors;
  if (D.27443 != 0B) goto <D.27444>; else goto <D.27445>;
  <D.27444>:
  table = &assembly->tables[6];
  D.27443 = tb->ctors;
  D.27446 = mono_array_length (D.27443);
  D.27413 = table->rows;
  D.27447 = (unsigned int) D.27446;
  D.27448 = D.27413 + D.27447;
  table->rows = D.27448;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  i = 0;
  goto <D.20283>;
  <D.20282>:
  D.27443 = tb->ctors;
  D.27430 = (long unsigned int) i;
  D.27449 = mono_array_addr_with_size (D.27443, 8, D.27430);
  D.27450 = MEM[(struct MonoReflectionCtorBuilder * *)D.27449];
  mono_image_get_ctor_info (domain, D.27450, assembly);
  i = i + 1;
  <D.20283>:
  D.27430 = (long unsigned int) i;
  D.27443 = tb->ctors;
  D.27451 = mono_array_length (D.27443);
  if (D.27430 < D.27451) goto <D.20282>; else goto <D.20284>;
  <D.20284>:
  <D.27445>:
  D.27452 = tb->methods;
  if (D.27452 != 0B) goto <D.27453>; else goto <D.27454>;
  <D.27453>:
  table = &assembly->tables[6];
  D.27413 = table->rows;
  D.27455 = tb->num_methods;
  D.27456 = (unsigned int) D.27455;
  D.27457 = D.27413 + D.27456;
  table->rows = D.27457;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  i = 0;
  goto <D.20286>;
  <D.20285>:
  D.27452 = tb->methods;
  D.27430 = (long unsigned int) i;
  D.27458 = mono_array_addr_with_size (D.27452, 8, D.27430);
  D.27459 = MEM[(struct MonoReflectionMethodBuilder * *)D.27458];
  mono_image_get_method_info (D.27459, assembly);
  i = i + 1;
  <D.20286>:
  D.27455 = tb->num_methods;
  if (D.27455 > i) goto <D.20285>; else goto <D.20287>;
  <D.20287>:
  <D.27454>:
  D.27460 = tb->events;
  if (D.27460 != 0B) goto <D.27461>; else goto <D.27462>;
  <D.27461>:
  D.27460 = tb->events;
  D.27463 = mono_array_length (D.27460);
  if (D.27463 != 0) goto <D.27464>; else goto <D.27465>;
  <D.27464>:
  table = &assembly->tables[20];
  D.27460 = tb->events;
  D.27466 = mono_array_length (D.27460);
  D.27413 = table->rows;
  D.27467 = (unsigned int) D.27466;
  D.27468 = D.27413 + D.27467;
  table->rows = D.27468;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  table = &assembly->tables[18];
  D.27413 = table->rows;
  D.27414 = D.27413 + 1;
  table->rows = D.27414;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  D.27295 = table->values;
  D.27413 = table->rows;
  D.27469 = D.27413 * 2;
  D.27470 = (long unsigned int) D.27469;
  D.27471 = D.27470 * 4;
  values = D.27295 + D.27471;
  D.27296 = tb->table_idx;
  *values = D.27296;
  D.27343 = values + 4;
  D.27472 = assembly->tables[20].next_idx;
  *D.27343 = D.27472;
  i = 0;
  goto <D.20289>;
  <D.20288>:
  D.27460 = tb->events;
  D.27430 = (long unsigned int) i;
  D.27473 = mono_array_addr_with_size (D.27460, 8, D.27430);
  D.27474 = MEM[(struct MonoReflectionEventBuilder * *)D.27473];
  mono_image_get_event_info (D.27474, assembly);
  i = i + 1;
  <D.20289>:
  D.27430 = (long unsigned int) i;
  D.27460 = tb->events;
  D.27475 = mono_array_length (D.27460);
  if (D.27430 < D.27475) goto <D.20288>; else goto <D.20290>;
  <D.20290>:
  <D.27465>:
  <D.27462>:
  D.27476 = tb->properties;
  if (D.27476 != 0B) goto <D.27477>; else goto <D.27478>;
  <D.27477>:
  D.27476 = tb->properties;
  D.27479 = mono_array_length (D.27476);
  if (D.27479 != 0) goto <D.27480>; else goto <D.27481>;
  <D.27480>:
  table = &assembly->tables[23];
  D.27476 = tb->properties;
  D.27482 = mono_array_length (D.27476);
  D.27413 = table->rows;
  D.27483 = (unsigned int) D.27482;
  D.27484 = D.27413 + D.27483;
  table->rows = D.27484;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  table = &assembly->tables[21];
  D.27413 = table->rows;
  D.27414 = D.27413 + 1;
  table->rows = D.27414;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  D.27295 = table->values;
  D.27413 = table->rows;
  D.27469 = D.27413 * 2;
  D.27470 = (long unsigned int) D.27469;
  D.27471 = D.27470 * 4;
  values = D.27295 + D.27471;
  D.27296 = tb->table_idx;
  *values = D.27296;
  D.27343 = values + 4;
  D.27485 = assembly->tables[23].next_idx;
  *D.27343 = D.27485;
  i = 0;
  goto <D.20292>;
  <D.20291>:
  D.27476 = tb->properties;
  D.27430 = (long unsigned int) i;
  D.27486 = mono_array_addr_with_size (D.27476, 8, D.27430);
  D.27487 = MEM[(struct MonoReflectionPropertyBuilder * *)D.27486];
  mono_image_get_property_info (D.27487, assembly);
  i = i + 1;
  <D.20292>:
  D.27430 = (long unsigned int) i;
  D.27476 = tb->properties;
  D.27488 = mono_array_length (D.27476);
  if (D.27430 < D.27488) goto <D.20291>; else goto <D.20293>;
  <D.20293>:
  <D.27481>:
  <D.27478>:
  D.27489 = tb->generic_params;
  if (D.27489 != 0B) goto <D.27490>; else goto <D.27491>;
  <D.27490>:
  table = &assembly->tables[42];
  D.27489 = tb->generic_params;
  D.27492 = mono_array_length (D.27489);
  D.27413 = table->rows;
  D.27493 = (unsigned int) D.27492;
  D.27494 = D.27413 + D.27493;
  table->rows = D.27494;
  D.27413 = table->rows;
  alloc_table (table, D.27413);
  i = 0;
  goto <D.20296>;
  <D.20295>:
  {
    guint32 owner;

    D.27296 = tb->table_idx;
    owner = D.27296 << 1;
    D.27489 = tb->generic_params;
    D.27430 = (long unsigned int) i;
    D.27495 = mono_array_addr_with_size (D.27489, 8, D.27430);
    D.27496 = MEM[(struct MonoReflectionGenericParam * *)D.27495];
    mono_image_get_generic_param_info (D.27496, owner, assembly);
  }
  i = i + 1;
  <D.20296>:
  D.27430 = (long unsigned int) i;
  D.27489 = tb->generic_params;
  D.27497 = mono_array_length (D.27489);
  if (D.27430 < D.27497) goto <D.20295>; else goto <D.20297>;
  <D.20297>:
  <D.27491>:
  D.27296 = tb->table_idx;
  D.27498 = D.27296 | 33554432;
  D.27499 = tb->permissions;
  mono_image_add_decl_security (assembly, D.27498, D.27499);
  D.27500 = tb->subtypes;
  if (D.27500 != 0B) goto <D.27501>; else goto <D.27502>;
  <D.27501>:
  {
    struct MonoDynamicTable * ntable;

    ntable = &assembly->tables[41];
    D.27500 = tb->subtypes;
    D.27503 = mono_array_length (D.27500);
    D.27504 = ntable->rows;
    D.27505 = (unsigned int) D.27503;
    D.27506 = D.27504 + D.27505;
    ntable->rows = D.27506;
    D.27504 = ntable->rows;
    alloc_table (ntable, D.27504);
    D.27507 = ntable->values;
    D.27508 = ntable->next_idx;
    D.27509 = D.27508 * 2;
    D.27510 = (long unsigned int) D.27509;
    D.27511 = D.27510 * 4;
    values = D.27507 + D.27511;
    i = 0;
    goto <D.20301>;
    <D.20300>:
    {
      struct MonoReflectionTypeBuilder * subtype;

      D.27500 = tb->subtypes;
      D.27430 = (long unsigned int) i;
      D.27512 = mono_array_addr_with_size (D.27500, 8, D.27430);
      subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.27512];
      D.27513 = subtype->table_idx;
      *values = D.27513;
      D.27343 = values + 4;
      D.27296 = tb->table_idx;
      *D.27343 = D.27296;
      values = values + 8;
      D.27508 = ntable->next_idx;
      D.27514 = D.27508 + 1;
      ntable->next_idx = D.27514;
    }
    i = i + 1;
    <D.20301>:
    D.27430 = (long unsigned int) i;
    D.27500 = tb->subtypes;
    D.27515 = mono_array_length (D.27500);
    if (D.27430 < D.27515) goto <D.20300>; else goto <D.20302>;
    <D.20302>:
  }
  <D.27502>:
}


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

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


reflection_methodbuilder_from_ctor_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionCtorBuilder * mb)
{
  const char * iftmp.98;
  unsigned int D.27519;
  unsigned int D.27520;
  struct MonoReflectionILGen * D.27524;
  struct MonoDomain * D.27525;
  struct MonoClass * D.27526;
  struct MonoType * D.27527;
  struct MonoReflectionType * D.27528;
  struct MonoArray * D.27529;
  struct MonoArray * D.27530;
  unsigned int D.27531;
  unsigned int D.27532;
  struct MonoObject * D.27533;
  struct MonoDomain * D.27534;
  struct MonoString * D.27535;
  guint32 * D.27536;
  unsigned char D.27537;
  struct MonoArray * D.27538;
  struct MonoArray * D.27539;
  struct MonoArray * D.27540;
  struct MonoMethod * D.27541;
  const char * name;

  D.27519 = mb->attrs;
  D.27520 = D.27519 & 16;
  if (D.27520 != 0) goto <D.27521>; else goto <D.27522>;
  <D.27521>:
  iftmp.98 = ".cctor";
  goto <D.27523>;
  <D.27522>:
  iftmp.98 = ".ctor";
  <D.27523>:
  name = iftmp.98;
  memset (rmb, 0, 208);
  D.27524 = mb->ilgen;
  rmb->ilgen = D.27524;
  D.27525 = mono_domain_get ();
  D.27526 = mono_defaults.void_class;
  D.27527 = &D.27526->byval_arg;
  D.27528 = mono_type_get_object (D.27525, D.27527);
  rmb->rtype = D.27528;
  D.27529 = mb->parameters;
  rmb->parameters = D.27529;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  D.27530 = mb->pinfo;
  rmb->pinfo = D.27530;
  D.27519 = mb->attrs;
  rmb->attrs = D.27519;
  D.27531 = mb->iattrs;
  rmb->iattrs = D.27531;
  D.27532 = mb->call_conv;
  rmb->call_conv = D.27532;
  rmb->code = 0B;
  D.27533 = mb->type;
  rmb->type = D.27533;
  D.27534 = mono_domain_get ();
  D.27535 = mono_string_new (D.27534, name);
  rmb->name = D.27535;
  D.27536 = &mb->table_idx;
  rmb->table_idx = D.27536;
  D.27537 = mb->init_locals;
  rmb->init_locals = D.27537;
  rmb->skip_visibility = 0;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  D.27538 = mb->param_modreq;
  rmb->param_modreq = D.27538;
  D.27539 = mb->param_modopt;
  rmb->param_modopt = D.27539;
  D.27540 = mb->permissions;
  rmb->permissions = D.27540;
  D.27541 = mb->mhandle;
  rmb->mhandle = D.27541;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


mono_image_get_event_info (struct MonoReflectionEventBuilder * eb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27542;
  unsigned int D.27543;
  unsigned int D.27544;
  guint32 * D.27545;
  unsigned int D.27546;
  unsigned int D.27547;
  long unsigned int D.27548;
  long unsigned int D.27549;
  guint32 * D.27550;
  struct MonoDynamicStream * D.27551;
  struct MonoString * D.27552;
  unsigned int D.27553;
  unsigned int D.27554;
  guint32 * D.27555;
  struct MonoReflectionType * D.27556;
  struct MonoType * D.27557;
  unsigned int D.27558;
  struct MonoReflectionMethodBuilder * D.27559;
  struct MonoReflectionMethodBuilder * D.27562;
  struct MonoReflectionMethodBuilder * D.27565;
  unsigned int D.27568;
  unsigned int D.27569;
  unsigned int semaidx.99;
  unsigned int D.27573;
  unsigned int D.27574;
  long unsigned int D.27575;
  long unsigned int D.27576;
  unsigned int D.27577;
  unsigned int D.27578;
  unsigned int semaidx.100;
  unsigned int D.27582;
  unsigned int D.27583;
  unsigned int semaidx.101;
  unsigned int D.27587;
  unsigned int D.27588;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[20];
  D.27542 = table->next_idx;
  D.27543 = D.27542;
  D.27544 = D.27543 + 1;
  table->next_idx = D.27544;
  eb->table_idx = D.27543;
  D.27545 = table->values;
  D.27546 = eb->table_idx;
  D.27547 = D.27546 * 3;
  D.27548 = (long unsigned int) D.27547;
  D.27549 = D.27548 * 4;
  values = D.27545 + D.27549;
  D.27550 = values + 4;
  D.27551 = &assembly->sheap;
  D.27552 = eb->name;
  D.27553 = string_heap_insert_mstring (D.27551, D.27552);
  *D.27550 = D.27553;
  D.27554 = eb->attrs;
  *values = D.27554;
  D.27555 = values + 8;
  D.27556 = eb->type;
  D.27557 = mono_reflection_type_get_handle (D.27556);
  D.27558 = mono_image_typedef_or_ref (assembly, D.27557);
  *D.27555 = D.27558;
  D.27559 = eb->add_method;
  if (D.27559 != 0B) goto <D.27560>; else goto <D.27561>;
  <D.27560>:
  num_methods = num_methods + 1;
  <D.27561>:
  D.27562 = eb->remove_method;
  if (D.27562 != 0B) goto <D.27563>; else goto <D.27564>;
  <D.27563>:
  num_methods = num_methods + 1;
  <D.27564>:
  D.27565 = eb->raise_method;
  if (D.27565 != 0B) goto <D.27566>; else goto <D.27567>;
  <D.27566>:
  num_methods = num_methods + 1;
  <D.27567>:
  table = &assembly->tables[24];
  D.27568 = table->rows;
  D.27569 = D.27568 + num_methods;
  table->rows = D.27569;
  D.27568 = table->rows;
  alloc_table (table, D.27568);
  D.27559 = eb->add_method;
  if (D.27559 != 0B) goto <D.27570>; else goto <D.27571>;
  <D.27570>:
  D.27542 = table->next_idx;
  semaidx.99 = D.27542;
  D.27573 = semaidx.99 + 1;
  table->next_idx = D.27573;
  semaidx = semaidx.99;
  D.27545 = table->values;
  D.27574 = semaidx * 3;
  D.27575 = (long unsigned int) D.27574;
  D.27576 = D.27575 * 4;
  values = D.27545 + D.27576;
  *values = 8;
  D.27550 = values + 4;
  D.27559 = eb->add_method;
  D.27577 = D.27559->table_idx;
  *D.27550 = D.27577;
  D.27555 = values + 8;
  D.27546 = eb->table_idx;
  D.27578 = D.27546 << 1;
  *D.27555 = D.27578;
  <D.27571>:
  D.27562 = eb->remove_method;
  if (D.27562 != 0B) goto <D.27579>; else goto <D.27580>;
  <D.27579>:
  D.27542 = table->next_idx;
  semaidx.100 = D.27542;
  D.27582 = semaidx.100 + 1;
  table->next_idx = D.27582;
  semaidx = semaidx.100;
  D.27545 = table->values;
  D.27574 = semaidx * 3;
  D.27575 = (long unsigned int) D.27574;
  D.27576 = D.27575 * 4;
  values = D.27545 + D.27576;
  *values = 16;
  D.27550 = values + 4;
  D.27562 = eb->remove_method;
  D.27583 = D.27562->table_idx;
  *D.27550 = D.27583;
  D.27555 = values + 8;
  D.27546 = eb->table_idx;
  D.27578 = D.27546 << 1;
  *D.27555 = D.27578;
  <D.27580>:
  D.27565 = eb->raise_method;
  if (D.27565 != 0B) goto <D.27584>; else goto <D.27585>;
  <D.27584>:
  D.27542 = table->next_idx;
  semaidx.101 = D.27542;
  D.27587 = semaidx.101 + 1;
  table->next_idx = D.27587;
  semaidx = semaidx.101;
  D.27545 = table->values;
  D.27574 = semaidx * 3;
  D.27575 = (long unsigned int) D.27574;
  D.27576 = D.27575 * 4;
  values = D.27545 + D.27576;
  *values = 32;
  D.27550 = values + 4;
  D.27565 = eb->raise_method;
  D.27588 = D.27565->table_idx;
  *D.27550 = D.27588;
  D.27555 = values + 8;
  D.27546 = eb->table_idx;
  D.27578 = D.27546 << 1;
  *D.27555 = D.27578;
  <D.27585>:
}


mono_image_get_property_info (struct MonoReflectionPropertyBuilder * pb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27589;
  unsigned int D.27590;
  unsigned int D.27591;
  int D.27592;
  guint32 * D.27593;
  int D.27594;
  int D.27595;
  long unsigned int D.27596;
  long unsigned int D.27597;
  guint32 * D.27598;
  struct MonoDynamicStream * D.27599;
  struct MonoString * D.27600;
  unsigned int D.27601;
  unsigned int D.27602;
  guint32 * D.27603;
  unsigned int D.27604;
  struct MonoReflectionMethodBuilder * D.27605;
  struct MonoReflectionMethodBuilder * D.27608;
  unsigned int D.27611;
  unsigned int D.27612;
  unsigned int semaidx.102;
  unsigned int D.27616;
  unsigned int D.27617;
  long unsigned int D.27618;
  long unsigned int D.27619;
  unsigned int D.27620;
  int D.27621;
  int D.27622;
  unsigned int D.27623;
  unsigned int semaidx.103;
  unsigned int D.27627;
  unsigned int D.27628;
  unsigned int D.27629;
  unsigned int D.27632;
  unsigned int D.27633;
  long unsigned int D.27634;
  long unsigned int D.27635;
  int D.27636;
  int D.27637;
  unsigned int D.27638;
  guint32 * D.27639;
  struct MonoObject * D.27640;
  unsigned int D.27641;
  unsigned int field_type.104;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[23];
  D.27589 = table->next_idx;
  D.27590 = D.27589;
  D.27591 = D.27590 + 1;
  table->next_idx = D.27591;
  D.27592 = (int) D.27590;
  pb->table_idx = D.27592;
  D.27593 = table->values;
  D.27594 = pb->table_idx;
  D.27595 = D.27594 * 3;
  D.27596 = (long unsigned int) D.27595;
  D.27597 = D.27596 * 4;
  values = D.27593 + D.27597;
  D.27598 = values + 4;
  D.27599 = &assembly->sheap;
  D.27600 = pb->name;
  D.27601 = string_heap_insert_mstring (D.27599, D.27600);
  *D.27598 = D.27601;
  D.27602 = pb->attrs;
  *values = D.27602;
  D.27603 = values + 8;
  D.27604 = property_encode_signature (assembly, pb);
  *D.27603 = D.27604;
  D.27605 = pb->get_method;
  if (D.27605 != 0B) goto <D.27606>; else goto <D.27607>;
  <D.27606>:
  num_methods = num_methods + 1;
  <D.27607>:
  D.27608 = pb->set_method;
  if (D.27608 != 0B) goto <D.27609>; else goto <D.27610>;
  <D.27609>:
  num_methods = num_methods + 1;
  <D.27610>:
  table = &assembly->tables[24];
  D.27611 = table->rows;
  D.27612 = D.27611 + num_methods;
  table->rows = D.27612;
  D.27611 = table->rows;
  alloc_table (table, D.27611);
  D.27605 = pb->get_method;
  if (D.27605 != 0B) goto <D.27613>; else goto <D.27614>;
  <D.27613>:
  D.27589 = table->next_idx;
  semaidx.102 = D.27589;
  D.27616 = semaidx.102 + 1;
  table->next_idx = D.27616;
  semaidx = semaidx.102;
  D.27593 = table->values;
  D.27617 = semaidx * 3;
  D.27618 = (long unsigned int) D.27617;
  D.27619 = D.27618 * 4;
  values = D.27593 + D.27619;
  *values = 2;
  D.27598 = values + 4;
  D.27605 = pb->get_method;
  D.27620 = D.27605->table_idx;
  *D.27598 = D.27620;
  D.27603 = values + 8;
  D.27594 = pb->table_idx;
  D.27621 = D.27594 << 1;
  D.27622 = D.27621 | 1;
  D.27623 = (unsigned int) D.27622;
  *D.27603 = D.27623;
  <D.27614>:
  D.27608 = pb->set_method;
  if (D.27608 != 0B) goto <D.27624>; else goto <D.27625>;
  <D.27624>:
  D.27589 = table->next_idx;
  semaidx.103 = D.27589;
  D.27627 = semaidx.103 + 1;
  table->next_idx = D.27627;
  semaidx = semaidx.103;
  D.27593 = table->values;
  D.27617 = semaidx * 3;
  D.27618 = (long unsigned int) D.27617;
  D.27619 = D.27618 * 4;
  values = D.27593 + D.27619;
  *values = 1;
  D.27598 = values + 4;
  D.27608 = pb->set_method;
  D.27628 = D.27608->table_idx;
  *D.27598 = D.27628;
  D.27603 = values + 8;
  D.27594 = pb->table_idx;
  D.27621 = D.27594 << 1;
  D.27622 = D.27621 | 1;
  D.27623 = (unsigned int) D.27622;
  *D.27603 = D.27623;
  <D.27625>:
  D.27602 = pb->attrs;
  D.27629 = D.27602 & 4096;
  if (D.27629 != 0) goto <D.27630>; else goto <D.27631>;
  <D.27630>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.27611 = table->rows;
        D.27632 = D.27611 + 1;
        table->rows = D.27632;
        D.27611 = table->rows;
        alloc_table (table, D.27611);
        D.27593 = table->values;
        D.27611 = table->rows;
        D.27633 = D.27611 * 4;
        D.27634 = (long unsigned int) D.27633;
        D.27635 = D.27634 * 4;
        values = D.27593 + D.27635;
        D.27603 = values + 8;
        D.27594 = pb->table_idx;
        D.27636 = D.27594 << 2;
        D.27637 = D.27636 | 2;
        D.27638 = (unsigned int) D.27637;
        *D.27603 = D.27638;
        D.27639 = values + 12;
        D.27640 = pb->def_value;
        D.27641 = encode_constant (assembly, D.27640, &field_type);
        *D.27639 = D.27641;
        field_type.104 = field_type;
        *values = field_type.104;
        D.27598 = values + 4;
        *D.27598 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.27631>:
}


property_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionPropertyBuilder * fb)
{
  struct MonoArray * D.27645;
  long unsigned int D.27648;
  struct MonoArray * D.27653;
  long unsigned int D.27656;
  unsigned int D.27657;
  unsigned int D.27658;
  unsigned int D.27659;
  struct MonoObject * D.27665;
  long unsigned int D.27666;
  char * D.27667;
  long unsigned int D.27673;
  char * D.27674;
  struct MonoReflectionType * D.27675;
  char * D.27676;
  struct MonoObject * D.27677;
  guint32 D.27678;
  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.27643>; else goto <D.27644>;
      <D.27643>:
      D.27645 = mb->parameters;
      if (D.27645 != 0B) goto <D.27646>; else goto <D.27647>;
      <D.27646>:
      D.27645 = mb->parameters;
      D.27648 = mono_array_length (D.27645);
      nparams = (guint32) D.27648;
      <D.27647>:
      <D.27644>:
      if (mb == 0B) goto <D.27649>; else goto <D.27650>;
      <D.27649>:
      if (smb != 0B) goto <D.27651>; else goto <D.27652>;
      <D.27651>:
      D.27653 = smb->parameters;
      if (D.27653 != 0B) goto <D.27654>; else goto <D.27655>;
      <D.27654>:
      D.27653 = smb->parameters;
      D.27656 = mono_array_length (D.27653);
      D.27657 = (unsigned int) D.27656;
      nparams = D.27657 + 4294967295;
      <D.27655>:
      <D.27652>:
      <D.27650>:
      sigbuffer_init (&buf, 32);
      D.27658 = fb->call_conv;
      D.27659 = D.27658 & 32;
      if (D.27659 != 0) goto <D.27660>; else goto <D.27661>;
      <D.27660>:
      sigbuffer_add_byte (&buf, 40);
      goto <D.27662>;
      <D.27661>:
      sigbuffer_add_byte (&buf, 8);
      <D.27662>:
      sigbuffer_add_value (&buf, nparams);
      if (mb != 0B) goto <D.27663>; else goto <D.27664>;
      <D.27663>:
      D.27665 = mb->rtype;
      encode_reflection_type (assembly, D.27665, &buf);
      i = 0;
      goto <D.19814>;
      <D.19813>:
      {
        struct MonoReflectionType * pt;

        D.27645 = mb->parameters;
        D.27666 = (long unsigned int) i;
        D.27667 = mono_array_addr_with_size (D.27645, 8, D.27666);
        pt = MEM[(struct MonoReflectionType * *)D.27667];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19814>:
      if (i < nparams) goto <D.19813>; else goto <D.19815>;
      <D.19815>:
      goto <D.27668>;
      <D.27664>:
      if (smb != 0B) goto <D.27671>; else goto <D.27669>;
      <D.27671>:
      D.27653 = smb->parameters;
      if (D.27653 != 0B) goto <D.27672>; else goto <D.27669>;
      <D.27672>:
      D.27653 = smb->parameters;
      D.27673 = (long unsigned int) nparams;
      D.27674 = mono_array_addr_with_size (D.27653, 8, D.27673);
      D.27675 = MEM[(struct MonoReflectionType * *)D.27674];
      encode_reflection_type (assembly, D.27675, &buf);
      i = 0;
      goto <D.19818>;
      <D.19817>:
      {
        struct MonoReflectionType * pt;

        D.27653 = smb->parameters;
        D.27666 = (long unsigned int) i;
        D.27676 = mono_array_addr_with_size (D.27653, 8, D.27666);
        pt = MEM[(struct MonoReflectionType * *)D.27676];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19818>:
      if (i < nparams) goto <D.19817>; else goto <D.19819>;
      <D.19819>:
      goto <D.27670>;
      <D.27669>:
      D.27677 = fb->type;
      encode_reflection_type (assembly, D.27677, &buf);
      <D.27670>:
      <D.27668>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27678 = idx;
      return D.27678;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_cattrs (struct MonoDynamicImage * assembly, guint32 idx, guint32 type, struct MonoArray * cattrs)
{
  long unsigned int D.27683;
  unsigned int D.27684;
  unsigned int D.27685;
  guint32 * D.27686;
  unsigned int D.27687;
  unsigned int D.27688;
  long unsigned int D.27689;
  long unsigned int D.27690;
  long unsigned int D.27691;
  char * D.27692;
  struct MonoReflectionMethod * D.27693;
  unsigned int D.27694;
  struct MonoGHashTable * D.27695;
  long unsigned int D.27696;
  void * D.27697;
  guint32 * D.27698;
  struct MonoArray * D.27699;
  long unsigned int D.27700;
  unsigned int D.27701;
  char * p.105;
  guint32 * D.27703;
  long int p.106;
  long int blob_size.107;
  long int D.27706;
  int D.27707;
  char * D.27708;
  long unsigned int D.27709;
  int D.27710;
  unsigned int D.27711;
  unsigned int D.27712;
  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.27681>; else goto <D.27682>;
      <D.27681>:
      return;
      <D.27682>:
      D.27683 = mono_array_length (cattrs);
      count = (guint32) D.27683;
      table = &assembly->tables[12];
      D.27684 = table->rows;
      D.27685 = D.27684 + count;
      table->rows = D.27685;
      D.27684 = table->rows;
      alloc_table (table, D.27684);
      D.27686 = table->values;
      D.27687 = table->next_idx;
      D.27688 = D.27687 * 3;
      D.27689 = (long unsigned int) D.27688;
      D.27690 = D.27689 * 4;
      values = D.27686 + D.27690;
      idx = idx << 5;
      idx = idx | type;
      i = 0;
      goto <D.19603>;
      <D.19602>:
      D.27691 = (long unsigned int) i;
      D.27692 = mono_array_addr_with_size (cattrs, 8, D.27691);
      cattr = MEM[(void * *)D.27692];
      *values = idx;
      D.27693 = cattr->ctor;
      token = mono_image_create_token (assembly, D.27693, 0, 0);
      type = token & 16777215;
      type = type << 3;
      D.27694 = token >> 24;
      switch (D.27694) <default: <D.19600>, case 6: <D.19597>, case 10: <D.19599>>
      <D.19597>:
      type = type | 2;
      D.27695 = assembly->remapped_tokens;
      D.27696 = (long unsigned int) token;
      D.27697 = (void *) D.27696;
      D.27693 = cattr->ctor;
      mono_g_hash_table_insert (D.27695, D.27697, D.27693);
      goto <D.19598>;
      <D.19599>:
      type = type | 3;
      goto <D.19598>;
      <D.19600>:
      monoeg_g_log (0B, 16, "got wrong token in custom attr");
      // predicted unlikely by continue predictor.
      goto <D.19601>;
      <D.19598>:
      D.27698 = values + 4;
      *D.27698 = type;
      p = &blob_size;
      D.27699 = cattr->data;
      D.27700 = mono_array_length (D.27699);
      D.27701 = (unsigned int) D.27700;
      p.105 = p;
      mono_metadata_encode_value (D.27701, p.105, &p);
      D.27703 = values + 8;
      p.105 = p;
      p.106 = (long int) p.105;
      blob_size.107 = (long int) &blob_size;
      D.27706 = p.106 - blob_size.107;
      D.27707 = (int) D.27706;
      D.27699 = cattr->data;
      D.27708 = mono_array_addr_with_size (D.27699, 1, 0);
      D.27699 = cattr->data;
      D.27709 = mono_array_length (D.27699);
      D.27710 = (int) D.27709;
      D.27711 = add_to_blob_cached (assembly, &blob_size, D.27707, D.27708, D.27710);
      *D.27703 = D.27711;
      values = values + 12;
      D.27687 = table->next_idx;
      D.27712 = D.27687 + 1;
      table->next_idx = D.27712;
      <D.19601>:
      i = i + 1;
      <D.19603>:
      if (i < count) goto <D.19602>; else goto <D.19604>;
      <D.19604>:
    }
  finally
    {
      blob_size = {CLOBBER};
      p = {CLOBBER};
    }
}


mono_image_add_decl_security (struct MonoDynamicImage * assembly, guint32 parent_token, struct MonoArray * permissions)
{
  long unsigned int D.27718;
  unsigned int D.27719;
  unsigned int D.27720;
  long unsigned int D.27721;
  guint32 * D.27722;
  unsigned int D.27723;
  unsigned int D.27724;
  long unsigned int D.27725;
  long unsigned int D.27726;
  unsigned int D.27727;
  unsigned int D.27728;
  guint32 * D.27729;
  guint32 * D.27730;
  struct MonoString * D.27731;
  unsigned int D.27732;
  unsigned int D.27733;
  long unsigned int D.27734;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 count;
  guint32 i;
  guint32 idx;
  struct MonoReflectionPermissionSet * perm;

  if (permissions == 0B) goto <D.27716>; else goto <D.27717>;
  <D.27716>:
  return;
  <D.27717>:
  D.27718 = mono_array_length (permissions);
  count = (guint32) D.27718;
  table = &assembly->tables[14];
  D.27719 = table->rows;
  D.27720 = D.27719 + count;
  table->rows = D.27720;
  D.27719 = table->rows;
  alloc_table (table, D.27719);
  i = 0;
  goto <D.19622>;
  <D.19621>:
  D.27721 = (long unsigned int) i;
  perm = mono_array_addr_with_size (permissions, 16, D.27721);
  D.27722 = table->values;
  D.27723 = table->next_idx;
  D.27724 = D.27723 * 3;
  D.27725 = (long unsigned int) D.27724;
  D.27726 = D.27725 * 4;
  values = D.27722 + D.27726;
  idx = parent_token & 16777215;
  idx = idx << 2;
  D.27727 = parent_token >> 24;
  switch (D.27727) <default: <D.19620>, case 2: <D.19616>, case 6: <D.19618>, case 32: <D.19619>>
  <D.19616>:
  idx = idx;
  goto <D.19617>;
  <D.19618>:
  idx = idx | 1;
  goto <D.19617>;
  <D.19619>:
  idx = idx | 2;
  goto <D.19617>;
  <D.19620>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1363);
  <D.19617>:
  D.27728 = perm->action;
  *values = D.27728;
  D.27729 = values + 4;
  *D.27729 = idx;
  D.27730 = values + 8;
  D.27731 = perm->pset;
  D.27732 = add_mono_string_to_blob_cached (assembly, D.27731);
  *D.27730 = D.27732;
  D.27723 = table->next_idx;
  D.27733 = D.27723 + 1;
  table->next_idx = D.27733;
  i = i + 1;
  <D.19622>:
  D.27721 = (long unsigned int) i;
  D.27734 = mono_array_length (permissions);
  if (D.27721 < D.27734) goto <D.19621>; else goto <D.19623>;
  <D.19623>:
}


add_mono_string_to_blob_cached (struct MonoDynamicImage * assembly, struct MonoString * str)
{
  int D.27736;
  int D.27737;
  char * b.108;
  long int b.109;
  long int blob_size.110;
  long int D.27741;
  int D.27742;
  mono_unichar2 * D.27743;
  int len.111;
  guint32 D.27745;
  char blob_size[64];
  char * b;
  guint32 idx;
  guint32 len;

  try
    {
      b = &blob_size;
      idx = 0;
      D.27736 = str->length;
      D.27737 = D.27736 * 2;
      len = (guint32) D.27737;
      b.108 = b;
      mono_metadata_encode_value (len, b.108, &b);
      b.108 = b;
      b.109 = (long int) b.108;
      blob_size.110 = (long int) &blob_size;
      D.27741 = b.109 - blob_size.110;
      D.27742 = (int) D.27741;
      D.27743 = mono_string_chars (str);
      len.111 = (int) len;
      idx = add_to_blob_cached (assembly, &blob_size, D.27742, D.27743, len.111);
      D.27745 = idx;
      return D.27745;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


module_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionModuleBuilder * moduleb)
{
  unsigned int D.27748;
  struct MonoArray * D.27749;
  struct MonoArray * D.27750;
  long unsigned int D.27753;
  char * D.27754;
  unsigned int D.27755;
  struct MonoArray * D.27756;
  struct MonoArray * D.27757;
  long unsigned int D.27758;
  struct MonoArray * D.27759;
  char * D.27762;
  int D.27763;
  unsigned int D.27764;
  struct MonoArray * D.27765;
  long unsigned int D.27766;
  struct MonoArray * D.27767;
  char * D.27770;
  struct MonoReflectionTypeBuilder * D.27771;
  int D.27772;
  int i;

  D.27748 = moduleb->table_idx;
  D.27749 = moduleb->cattrs;
  mono_image_add_cattrs (assembly, D.27748, 7, D.27749);
  D.27750 = moduleb->global_methods;
  if (D.27750 != 0B) goto <D.27751>; else goto <D.27752>;
  <D.27751>:
  i = 0;
  goto <D.20362>;
  <D.20361>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.27750 = moduleb->global_methods;
    D.27753 = (long unsigned int) i;
    D.27754 = mono_array_addr_with_size (D.27750, 8, D.27753);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.27754];
    D.27755 = mb->table_idx;
    D.27756 = mb->cattrs;
    mono_image_add_cattrs (assembly, D.27755, 0, D.27756);
    D.27757 = mb->pinfo;
    params_add_cattrs (assembly, D.27757);
  }
  i = i + 1;
  <D.20362>:
  D.27753 = (long unsigned int) i;
  D.27750 = moduleb->global_methods;
  D.27758 = mono_array_length (D.27750);
  if (D.27753 < D.27758) goto <D.20361>; else goto <D.20363>;
  <D.20363>:
  <D.27752>:
  D.27759 = moduleb->global_fields;
  if (D.27759 != 0B) goto <D.27760>; else goto <D.27761>;
  <D.27760>:
  i = 0;
  goto <D.20366>;
  <D.20365>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.27759 = moduleb->global_fields;
    D.27753 = (long unsigned int) i;
    D.27762 = mono_array_addr_with_size (D.27759, 8, D.27753);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.27762];
    D.27763 = fb->table_idx;
    D.27764 = (unsigned int) D.27763;
    D.27765 = fb->cattrs;
    mono_image_add_cattrs (assembly, D.27764, 1, D.27765);
  }
  i = i + 1;
  <D.20366>:
  D.27753 = (long unsigned int) i;
  D.27759 = moduleb->global_fields;
  D.27766 = mono_array_length (D.27759);
  if (D.27753 < D.27766) goto <D.20365>; else goto <D.20367>;
  <D.20367>:
  <D.27761>:
  D.27767 = moduleb->types;
  if (D.27767 != 0B) goto <D.27768>; else goto <D.27769>;
  <D.27768>:
  i = 0;
  goto <D.20369>;
  <D.20368>:
  D.27767 = moduleb->types;
  D.27753 = (long unsigned int) i;
  D.27770 = mono_array_addr_with_size (D.27767, 8, D.27753);
  D.27771 = MEM[(struct MonoReflectionTypeBuilder * *)D.27770];
  type_add_cattrs (assembly, D.27771);
  i = i + 1;
  <D.20369>:
  D.27772 = moduleb->num_types;
  if (D.27772 > i) goto <D.20368>; else goto <D.20370>;
  <D.20370>:
  <D.27769>:
}


params_add_cattrs (struct MonoDynamicImage * assembly, struct MonoArray * pinfo)
{
  long unsigned int D.27775;
  char * D.27776;
  unsigned int D.27779;
  struct MonoArray * D.27780;
  long unsigned int D.27781;
  int i;

  if (pinfo == 0B) goto <D.27773>; else goto <D.27774>;
  <D.27773>:
  return;
  <D.27774>:
  i = 0;
  goto <D.20325>;
  <D.20324>:
  {
    struct MonoReflectionParamBuilder * pb;

    D.27775 = (long unsigned int) i;
    D.27776 = mono_array_addr_with_size (pinfo, 8, D.27775);
    pb = MEM[(struct MonoReflectionParamBuilder * *)D.27776];
    if (pb == 0B) goto <D.27777>; else goto <D.27778>;
    <D.27777>:
    // predicted unlikely by continue predictor.
    goto <D.20323>;
    <D.27778>:
    D.27779 = pb->table_idx;
    D.27780 = pb->cattrs;
    mono_image_add_cattrs (assembly, D.27779, 4, D.27780);
  }
  <D.20323>:
  i = i + 1;
  <D.20325>:
  D.27775 = (long unsigned int) i;
  D.27781 = mono_array_length (pinfo);
  if (D.27775 < D.27781) goto <D.20324>; else goto <D.20326>;
  <D.20326>:
}


type_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  unsigned int D.27783;
  struct MonoArray * D.27784;
  struct MonoArray * D.27785;
  long unsigned int D.27788;
  char * D.27789;
  int D.27790;
  unsigned int D.27791;
  struct MonoArray * D.27792;
  int D.27793;
  struct MonoArray * D.27794;
  char * D.27797;
  unsigned int D.27798;
  struct MonoArray * D.27799;
  long unsigned int D.27800;
  struct MonoArray * D.27801;
  char * D.27804;
  int D.27805;
  unsigned int D.27806;
  struct MonoArray * D.27807;
  long unsigned int D.27808;
  struct MonoArray * D.27809;
  char * D.27812;
  unsigned int D.27813;
  struct MonoArray * D.27814;
  struct MonoArray * D.27815;
  long unsigned int D.27816;
  struct MonoArray * D.27817;
  char * D.27820;
  unsigned int D.27821;
  struct MonoArray * D.27822;
  struct MonoArray * D.27823;
  int D.27824;
  struct MonoArray * D.27825;
  char * D.27828;
  struct MonoReflectionTypeBuilder * D.27829;
  long unsigned int D.27830;
  int i;

  D.27783 = tb->table_idx;
  D.27784 = tb->cattrs;
  mono_image_add_cattrs (assembly, D.27783, 3, D.27784);
  D.27785 = tb->fields;
  if (D.27785 != 0B) goto <D.27786>; else goto <D.27787>;
  <D.27786>:
  i = 0;
  goto <D.20334>;
  <D.20333>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.27785 = tb->fields;
    D.27788 = (long unsigned int) i;
    D.27789 = mono_array_addr_with_size (D.27785, 8, D.27788);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.27789];
    D.27790 = fb->table_idx;
    D.27791 = (unsigned int) D.27790;
    D.27792 = fb->cattrs;
    mono_image_add_cattrs (assembly, D.27791, 1, D.27792);
  }
  i = i + 1;
  <D.20334>:
  D.27793 = tb->num_fields;
  if (D.27793 > i) goto <D.20333>; else goto <D.20335>;
  <D.20335>:
  <D.27787>:
  D.27794 = tb->events;
  if (D.27794 != 0B) goto <D.27795>; else goto <D.27796>;
  <D.27795>:
  i = 0;
  goto <D.20338>;
  <D.20337>:
  {
    struct MonoReflectionEventBuilder * eb;

    D.27794 = tb->events;
    D.27788 = (long unsigned int) i;
    D.27797 = mono_array_addr_with_size (D.27794, 8, D.27788);
    eb = MEM[(struct MonoReflectionEventBuilder * *)D.27797];
    D.27798 = eb->table_idx;
    D.27799 = eb->cattrs;
    mono_image_add_cattrs (assembly, D.27798, 10, D.27799);
  }
  i = i + 1;
  <D.20338>:
  D.27788 = (long unsigned int) i;
  D.27794 = tb->events;
  D.27800 = mono_array_length (D.27794);
  if (D.27788 < D.27800) goto <D.20337>; else goto <D.20339>;
  <D.20339>:
  <D.27796>:
  D.27801 = tb->properties;
  if (D.27801 != 0B) goto <D.27802>; else goto <D.27803>;
  <D.27802>:
  i = 0;
  goto <D.20342>;
  <D.20341>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    D.27801 = tb->properties;
    D.27788 = (long unsigned int) i;
    D.27804 = mono_array_addr_with_size (D.27801, 8, D.27788);
    pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.27804];
    D.27805 = pb->table_idx;
    D.27806 = (unsigned int) D.27805;
    D.27807 = pb->cattrs;
    mono_image_add_cattrs (assembly, D.27806, 9, D.27807);
  }
  i = i + 1;
  <D.20342>:
  D.27788 = (long unsigned int) i;
  D.27801 = tb->properties;
  D.27808 = mono_array_length (D.27801);
  if (D.27788 < D.27808) goto <D.20341>; else goto <D.20343>;
  <D.20343>:
  <D.27803>:
  D.27809 = tb->ctors;
  if (D.27809 != 0B) goto <D.27810>; else goto <D.27811>;
  <D.27810>:
  i = 0;
  goto <D.20346>;
  <D.20345>:
  {
    struct MonoReflectionCtorBuilder * cb;

    D.27809 = tb->ctors;
    D.27788 = (long unsigned int) i;
    D.27812 = mono_array_addr_with_size (D.27809, 8, D.27788);
    cb = MEM[(struct MonoReflectionCtorBuilder * *)D.27812];
    D.27813 = cb->table_idx;
    D.27814 = cb->cattrs;
    mono_image_add_cattrs (assembly, D.27813, 0, D.27814);
    D.27815 = cb->pinfo;
    params_add_cattrs (assembly, D.27815);
  }
  i = i + 1;
  <D.20346>:
  D.27788 = (long unsigned int) i;
  D.27809 = tb->ctors;
  D.27816 = mono_array_length (D.27809);
  if (D.27788 < D.27816) goto <D.20345>; else goto <D.20347>;
  <D.20347>:
  <D.27811>:
  D.27817 = tb->methods;
  if (D.27817 != 0B) goto <D.27818>; else goto <D.27819>;
  <D.27818>:
  i = 0;
  goto <D.20350>;
  <D.20349>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.27817 = tb->methods;
    D.27788 = (long unsigned int) i;
    D.27820 = mono_array_addr_with_size (D.27817, 8, D.27788);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.27820];
    D.27821 = mb->table_idx;
    D.27822 = mb->cattrs;
    mono_image_add_cattrs (assembly, D.27821, 0, D.27822);
    D.27823 = mb->pinfo;
    params_add_cattrs (assembly, D.27823);
  }
  i = i + 1;
  <D.20350>:
  D.27824 = tb->num_methods;
  if (D.27824 > i) goto <D.20349>; else goto <D.20351>;
  <D.20351>:
  <D.27819>:
  D.27825 = tb->subtypes;
  if (D.27825 != 0B) goto <D.27826>; else goto <D.27827>;
  <D.27826>:
  i = 0;
  goto <D.20353>;
  <D.20352>:
  D.27825 = tb->subtypes;
  D.27788 = (long unsigned int) i;
  D.27828 = mono_array_addr_with_size (D.27825, 8, D.27788);
  D.27829 = MEM[(struct MonoReflectionTypeBuilder * *)D.27828];
  type_add_cattrs (assembly, D.27829);
  i = i + 1;
  <D.20353>:
  D.27788 = (long unsigned int) i;
  D.27825 = tb->subtypes;
  D.27830 = mono_array_length (D.27825);
  if (D.27788 < D.27830) goto <D.20352>; else goto <D.20354>;
  <D.20354>:
  <D.27827>:
}


mono_image_add_methodimpl (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.27831;
  long unsigned int D.27834;
  char * D.27835;
  unsigned int D.27836;
  unsigned int D.27837;
  guint32 * D.27838;
  unsigned int D.27839;
  long unsigned int D.27840;
  long unsigned int D.27841;
  unsigned int D.27842;
  guint32 * D.27843;
  unsigned int D.27844;
  unsigned int D.27845;
  unsigned int D.27846;
  unsigned int D.27847;
  unsigned int D.27848;
  guint32 * D.27849;
  long unsigned int D.27850;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 tok;
  struct MonoReflectionMethod * m;
  int i;

  tb = mb->type;
  D.27831 = mb->override_methods;
  if (D.27831 == 0B) goto <D.27832>; else goto <D.27833>;
  <D.27832>:
  return;
  <D.27833>:
  i = 0;
  goto <D.19670>;
  <D.19669>:
  D.27831 = mb->override_methods;
  D.27834 = (long unsigned int) i;
  D.27835 = mono_array_addr_with_size (D.27831, 8, D.27834);
  m = MEM[(struct MonoReflectionMethod * *)D.27835];
  table = &assembly->tables[25];
  D.27836 = table->rows;
  D.27837 = D.27836 + 1;
  table->rows = D.27837;
  D.27836 = table->rows;
  alloc_table (table, D.27836);
  D.27838 = table->values;
  D.27836 = table->rows;
  D.27839 = D.27836 * 3;
  D.27840 = (long unsigned int) D.27839;
  D.27841 = D.27840 * 4;
  values = D.27838 + D.27841;
  D.27842 = tb->table_idx;
  *values = D.27842;
  D.27843 = values + 4;
  D.27844 = mb->table_idx;
  D.27845 = D.27844 << 1;
  *D.27843 = D.27845;
  tok = mono_image_create_token (assembly, m, 0, 0);
  D.27846 = tok >> 24;
  switch (D.27846) <default: <D.19668>, case 6: <D.19667>, case 10: <D.19665>>
  <D.19665>:
  D.27847 = tok & 16777215;
  D.27848 = D.27847 << 1;
  tok = D.27848 | 1;
  goto <D.19666>;
  <D.19667>:
  D.27847 = tok & 16777215;
  tok = D.27847 << 1;
  goto <D.19666>;
  <D.19668>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1589);
  <D.19666>:
  D.27849 = values + 8;
  *D.27849 = tok;
  i = i + 1;
  <D.19670>:
  D.27834 = (long unsigned int) i;
  D.27831 = mb->override_methods;
  D.27850 = mono_array_length (D.27831);
  if (D.27834 < D.27850) goto <D.19669>; else goto <D.19671>;
  <D.19671>:
}


fixup_cattrs (struct MonoDynamicImage * assembly)
{
  guint32 * D.27852;
  unsigned int D.27853;
  unsigned int D.27854;
  long unsigned int D.27855;
  long unsigned int D.27856;
  unsigned int D.27857;
  struct MonoGHashTable * D.27860;
  long unsigned int D.27861;
  const void * D.27862;
  _Bool D.27863;
  long int D.27864;
  long int D.27865;
  int D.20823;
  int iftmp.112;
  int D.20822;
  struct MonoVTable * D.27871;
  struct MonoClass * D.27872;
  const char[12] * D.27873;
  unsigned char D.27874;
  int D.27875;
  unsigned char D.27876;
  int D.27877;
  const unsigned char * D.27882;
  unsigned char D.27883;
  int D.27884;
  const unsigned char * D.27885;
  unsigned char D.27886;
  int D.27887;
  const unsigned char * D.27892;
  unsigned char D.27893;
  int D.27894;
  const unsigned char * D.27895;
  unsigned char D.27896;
  int D.27897;
  const unsigned char * D.27902;
  unsigned char D.27903;
  int D.27904;
  const unsigned char * D.27905;
  unsigned char D.27906;
  int D.27907;
  const char * D.27909;
  struct GHashTable * D.27912;
  void * D.27913;
  long int D.27914;
  guint32 * D.27915;
  unsigned int D.27916;
  unsigned int D.27917;
  int D.20833;
  int iftmp.113;
  int D.20832;
  const char[19] * D.27922;
  unsigned char D.27923;
  int D.27924;
  unsigned char D.27925;
  int D.27926;
  const unsigned char * D.27931;
  unsigned char D.27932;
  int D.27933;
  const unsigned char * D.27934;
  unsigned char D.27935;
  int D.27936;
  const unsigned char * D.27941;
  unsigned char D.27942;
  int D.27943;
  const unsigned char * D.27944;
  unsigned char D.27945;
  int D.27946;
  const unsigned char * D.27951;
  unsigned char D.27952;
  int D.27953;
  const unsigned char * D.27954;
  unsigned char D.27955;
  int D.27956;
  void * D.27960;
  long int D.27961;
  unsigned int D.27962;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 type;
  guint32 i;
  guint32 idx;
  guint32 token;
  struct MonoObject * ctor;

  table = &assembly->tables[12];
  i = 0;
  goto <D.20836>;
  <D.20835>:
  D.27852 = table->values;
  D.27853 = i + 1;
  D.27854 = D.27853 * 3;
  D.27855 = (long unsigned int) D.27854;
  D.27856 = D.27855 * 4;
  values = D.27852 + D.27856;
  type = MEM[(guint32 *)values + 4B];
  D.27857 = type & 7;
  if (D.27857 == 2) goto <D.27858>; else goto <D.27859>;
  <D.27858>:
  idx = type >> 3;
  token = idx | 100663296;
  D.27860 = assembly->remapped_tokens;
  D.27861 = (long unsigned int) token;
  D.27862 = (const void *) D.27861;
  ctor = mono_g_hash_table_lookup (D.27860, D.27862);
  D.27863 = ctor == 0B;
  D.27864 = (long int) D.27863;
  D.27865 = __builtin_expect (D.27864, 0);
  if (D.27865 != 0) goto <D.27866>; else goto <D.27867>;
  <D.27866>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4337, "ctor");
  <D.27867>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.27871 = ctor->vtable;
      D.27872 = D.27871->klass;
      __s2 = D.27872->name;
      D.27873 = "MonoCMethod";
      D.27874 = MEM[(const unsigned char *)D.27873];
      D.27875 = (int) D.27874;
      D.27876 = *__s2;
      D.27877 = (int) D.27876;
      __result = D.27875 - D.27877;
      {
        if (__s2_len != 0) goto <D.27878>; else goto <D.27879>;
        <D.27878>:
        if (__result == 0) goto <D.27880>; else goto <D.27881>;
        <D.27880>:
        D.27882 = &MEM[(void *)"MonoCMethod" + 1B];
        D.27883 = *D.27882;
        D.27884 = (int) D.27883;
        D.27885 = __s2 + 1;
        D.27886 = *D.27885;
        D.27887 = (int) D.27886;
        __result = D.27884 - D.27887;
        if (__s2_len > 1) goto <D.27888>; else goto <D.27889>;
        <D.27888>:
        if (__result == 0) goto <D.27890>; else goto <D.27891>;
        <D.27890>:
        D.27892 = &MEM[(void *)"MonoCMethod" + 2B];
        D.27893 = *D.27892;
        D.27894 = (int) D.27893;
        D.27895 = __s2 + 2;
        D.27896 = *D.27895;
        D.27897 = (int) D.27896;
        __result = D.27894 - D.27897;
        if (__s2_len > 2) goto <D.27898>; else goto <D.27899>;
        <D.27898>:
        if (__result == 0) goto <D.27900>; else goto <D.27901>;
        <D.27900>:
        D.27902 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27903 = *D.27902;
        D.27904 = (int) D.27903;
        D.27905 = __s2 + 3;
        D.27906 = *D.27905;
        D.27907 = (int) D.27906;
        __result = D.27904 - D.27907;
        <D.27901>:
        <D.27899>:
        <D.27891>:
        <D.27889>:
        <D.27881>:
        <D.27879>:
      }
      D.20822 = __result;
    }
    iftmp.112 = -D.20822;
    goto <D.27908>;
    <D.27870>:
    D.27871 = ctor->vtable;
    D.27872 = D.27871->klass;
    D.27909 = D.27872->name;
    iftmp.112 = __builtin_strcmp (D.27909, "MonoCMethod");
    <D.27908>:
    D.20823 = iftmp.112;
  }
  if (D.20823 == 0) goto <D.27910>; else goto <D.27911>;
  <D.27910>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionMethod *)ctor].method;
    D.27912 = assembly->method_to_table_idx;
    D.27913 = monoeg_g_hash_table_lookup (D.27912, m);
    D.27914 = (long int) D.27913;
    idx = (guint32) D.27914;
    D.27915 = values + 4;
    D.27916 = idx << 3;
    D.27917 = D.27916 | 2;
    *D.27915 = D.27917;
  }
  goto <D.27918>;
  <D.27911>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.27871 = ctor->vtable;
      D.27872 = D.27871->klass;
      __s2 = D.27872->name;
      D.27922 = "ConstructorBuilder";
      D.27923 = MEM[(const unsigned char *)D.27922];
      D.27924 = (int) D.27923;
      D.27925 = *__s2;
      D.27926 = (int) D.27925;
      __result = D.27924 - D.27926;
      {
        if (__s2_len != 0) goto <D.27927>; else goto <D.27928>;
        <D.27927>:
        if (__result == 0) goto <D.27929>; else goto <D.27930>;
        <D.27929>:
        D.27931 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.27932 = *D.27931;
        D.27933 = (int) D.27932;
        D.27934 = __s2 + 1;
        D.27935 = *D.27934;
        D.27936 = (int) D.27935;
        __result = D.27933 - D.27936;
        if (__s2_len > 1) goto <D.27937>; else goto <D.27938>;
        <D.27937>:
        if (__result == 0) goto <D.27939>; else goto <D.27940>;
        <D.27939>:
        D.27941 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.27942 = *D.27941;
        D.27943 = (int) D.27942;
        D.27944 = __s2 + 2;
        D.27945 = *D.27944;
        D.27946 = (int) D.27945;
        __result = D.27943 - D.27946;
        if (__s2_len > 2) goto <D.27947>; else goto <D.27948>;
        <D.27947>:
        if (__result == 0) goto <D.27949>; else goto <D.27950>;
        <D.27949>:
        D.27951 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.27952 = *D.27951;
        D.27953 = (int) D.27952;
        D.27954 = __s2 + 3;
        D.27955 = *D.27954;
        D.27956 = (int) D.27955;
        __result = D.27953 - D.27956;
        <D.27950>:
        <D.27948>:
        <D.27940>:
        <D.27938>:
        <D.27930>:
        <D.27928>:
      }
      D.20832 = __result;
    }
    iftmp.113 = -D.20832;
    goto <D.27957>;
    <D.27921>:
    D.27871 = ctor->vtable;
    D.27872 = D.27871->klass;
    D.27909 = D.27872->name;
    iftmp.113 = __builtin_strcmp (D.27909, "ConstructorBuilder");
    <D.27957>:
    D.20833 = iftmp.113;
  }
  if (D.20833 == 0) goto <D.27958>; else goto <D.27959>;
  <D.27958>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionCtorBuilder *)ctor].mhandle;
    D.27912 = assembly->method_to_table_idx;
    D.27960 = monoeg_g_hash_table_lookup (D.27912, m);
    D.27961 = (long int) D.27960;
    idx = (guint32) D.27961;
    D.27915 = values + 4;
    D.27916 = idx << 3;
    D.27917 = D.27916 | 2;
    *D.27915 = D.27917;
  }
  <D.27959>:
  <D.27918>:
  <D.27859>:
  i = i + 1;
  <D.20836>:
  D.27962 = table->rows;
  if (D.27962 > i) goto <D.20835>; else goto <D.20837>;
  <D.20837>:
}


mono_image_insert_string (struct MonoReflectionModuleBuilder * module, struct MonoString * str)
{
  struct MonoDynamicImage * D.27963;
  int D.27966;
  int D.27969;
  int D.27970;
  int D.27971;
  unsigned int D.27972;
  char * b.114;
  struct MonoDynamicStream * D.27974;
  long int b.115;
  long int buf.116;
  long int D.27977;
  unsigned int D.27978;
  mono_unichar2 * D.27979;
  unsigned int D.27980;
  unsigned int D.27982;
  unsigned int idx.117;
  unsigned int D.27984;
  struct MonoGHashTable * D.27985;
  unsigned int D.27986;
  long unsigned int D.27987;
  void * D.27988;
  guint32 D.27989;
  struct MonoDynamicImage * assembly;
  guint32 idx;
  char buf[16];
  char * b;

  try
    {
      b = &buf;
      D.27963 = module->dynamic_image;
      if (D.27963 == 0B) goto <D.27964>; else goto <D.27965>;
      <D.27964>:
      mono_image_module_basic_init (module);
      <D.27965>:
      assembly = module->dynamic_image;
      D.27966 = assembly->save;
      if (D.27966 != 0) goto <D.27967>; else goto <D.27968>;
      <D.27967>:
      D.27969 = str->length;
      D.27970 = D.27969 * 2;
      D.27971 = D.27970 | 1;
      D.27972 = (unsigned int) D.27971;
      b.114 = b;
      mono_metadata_encode_value (D.27972, b.114, &b);
      D.27974 = &assembly->us;
      b.114 = b;
      b.115 = (long int) b.114;
      buf.116 = (long int) &buf;
      D.27977 = b.115 - buf.116;
      D.27978 = (unsigned int) D.27977;
      idx = mono_image_add_stream_data (D.27974, &buf, D.27978);
      D.27974 = &assembly->us;
      D.27979 = mono_string_chars (str);
      D.27969 = str->length;
      D.27970 = D.27969 * 2;
      D.27980 = (unsigned int) D.27970;
      mono_image_add_stream_data (D.27974, D.27979, D.27980);
      D.27974 = &assembly->us;
      mono_image_add_stream_data (D.27974, "", 1);
      goto <D.27981>;
      <D.27968>:
      D.27982 = assembly->us.index;
      idx.117 = D.27982;
      D.27984 = idx.117 + 1;
      assembly->us.index = D.27984;
      idx = idx.117;
      <D.27981>:
      D.27985 = assembly->tokens;
      D.27986 = idx | 1879048192;
      D.27987 = (long unsigned int) D.27986;
      D.27988 = (void *) D.27987;
      mono_g_hash_table_insert (D.27985, D.27988, str);
      D.27989 = idx | 1879048192;
      return D.27989;
    }
  finally
    {
      buf = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_create_method_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, struct MonoArray * opt_param_types)
{
  struct MonoVTable * D.27992;
  int D.20998;
  int iftmp.118;
  int D.20997;
  const char[11] * D.27999;
  unsigned char D.28000;
  int D.28001;
  unsigned char D.28002;
  int D.28003;
  const unsigned char * D.28008;
  unsigned char D.28009;
  int D.28010;
  const unsigned char * D.28011;
  unsigned char D.28012;
  int D.28013;
  const unsigned char * D.28018;
  unsigned char D.28019;
  int D.28020;
  const unsigned char * D.28021;
  unsigned char D.28022;
  int D.28023;
  const unsigned char * D.28028;
  unsigned char D.28029;
  int D.28030;
  const unsigned char * D.28031;
  unsigned char D.28032;
  int D.28033;
  const char * D.28035;
  int D.21007;
  int iftmp.119;
  int D.21006;
  const char[12] * D.28040;
  unsigned char D.28041;
  int D.28042;
  unsigned char D.28043;
  int D.28044;
  const unsigned char * D.28049;
  unsigned char D.28050;
  int D.28051;
  const unsigned char * D.28052;
  unsigned char D.28053;
  int D.28054;
  const unsigned char * D.28059;
  unsigned char D.28060;
  int D.28061;
  const unsigned char * D.28062;
  unsigned char D.28063;
  int D.28064;
  const unsigned char * D.28069;
  unsigned char D.28070;
  int D.28071;
  const unsigned char * D.28072;
  unsigned char D.28073;
  int D.28074;
  int iftmp.120;
  struct MonoMethodSignature * D.28081;
  short int D.28082;
  _Bool D.28083;
  long int D.28084;
  long int D.28085;
  long unsigned int D.28088;
  struct MonoImage * D.28089;
  short unsigned int D.28090;
  int D.28091;
  int D.28092;
  unsigned int D.28093;
  <unnamed-unsigned:1> D.28094;
  <unnamed-unsigned:1> D.28095;
  <unnamed-unsigned:6> D.28096;
  short unsigned int D.28097;
  short unsigned int D.28098;
  short unsigned int D.28099;
  short int D.28100;
  struct MonoType * D.28101;
  struct MonoType * D.28102;
  long unsigned int D.28103;
  char * D.28104;
  int D.28105;
  struct MonoType * D.28106;
  struct MonoClass * D.28107;
  struct MonoType * D.28108;
  unsigned int D.28109;
  _Bool D.28110;
  long int D.28111;
  long int D.28112;
  const char * D.28115;
  int D.21029;
  int iftmp.121;
  int D.21028;
  const char[14] * D.28119;
  unsigned char D.28120;
  int D.28121;
  unsigned char D.28122;
  int D.28123;
  const unsigned char * D.28128;
  unsigned char D.28129;
  int D.28130;
  const unsigned char * D.28131;
  unsigned char D.28132;
  int D.28133;
  const unsigned char * D.28138;
  unsigned char D.28139;
  int D.28140;
  const unsigned char * D.28141;
  unsigned char D.28142;
  int D.28143;
  const unsigned char * D.28148;
  unsigned char D.28149;
  int D.28150;
  const unsigned char * D.28151;
  unsigned char D.28152;
  int D.28153;
  long unsigned int D.28157;
  int iftmp.122;
  struct MonoArray * D.28159;
  long unsigned int D.28162;
  int iftmp.123;
  struct MonoArray * D.28165;
  long unsigned int D.28168;
  int D.28170;
  unsigned int D.28171;
  unsigned int D.28172;
  unsigned int D.28173;
  _Bool D.28174;
  unsigned int D.28175;
  unsigned int D.28176;
  _Bool D.28177;
  unsigned char D.28178;
  <unnamed-unsigned:6> D.28179;
  short unsigned int D.28180;
  short unsigned int D.28181;
  short unsigned int D.28182;
  short unsigned int D.28183;
  short int D.28184;
  struct MonoReflectionType * D.28185;
  struct MonoType * D.28186;
  long unsigned int D.28187;
  char * D.28188;
  struct MonoType * D.28189;
  char * D.28190;
  int D.28191;
  struct MonoType * D.28192;
  unsigned int D.28193;
  _Bool D.28194;
  long int D.28195;
  long int D.28196;
  unsigned int D.28199;
  struct MonoString * D.28200;
  struct GHashTable * D.28202;
  long unsigned int D.28203;
  void * D.28204;
  struct MonoGHashTable * D.28205;
  guint32 D.28206;
  struct MonoClass * klass;
  guint32 token;
  struct MonoMethodSignature * sig;

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

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

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

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

      __s2 = klass->name;
      D.28040 = "MonoCMethod";
      D.28041 = MEM[(const unsigned char *)D.28040];
      D.28042 = (int) D.28041;
      D.28043 = *__s2;
      D.28044 = (int) D.28043;
      __result = D.28042 - D.28044;
      {
        if (__s2_len != 0) goto <D.28045>; else goto <D.28046>;
        <D.28045>:
        if (__result == 0) goto <D.28047>; else goto <D.28048>;
        <D.28047>:
        D.28049 = &MEM[(void *)"MonoCMethod" + 1B];
        D.28050 = *D.28049;
        D.28051 = (int) D.28050;
        D.28052 = __s2 + 1;
        D.28053 = *D.28052;
        D.28054 = (int) D.28053;
        __result = D.28051 - D.28054;
        if (__s2_len > 1) goto <D.28055>; else goto <D.28056>;
        <D.28055>:
        if (__result == 0) goto <D.28057>; else goto <D.28058>;
        <D.28057>:
        D.28059 = &MEM[(void *)"MonoCMethod" + 2B];
        D.28060 = *D.28059;
        D.28061 = (int) D.28060;
        D.28062 = __s2 + 2;
        D.28063 = *D.28062;
        D.28064 = (int) D.28063;
        __result = D.28061 - D.28064;
        if (__s2_len > 2) goto <D.28065>; else goto <D.28066>;
        <D.28065>:
        if (__result == 0) goto <D.28067>; else goto <D.28068>;
        <D.28067>:
        D.28069 = &MEM[(void *)"MonoCMethod" + 3B];
        D.28070 = *D.28069;
        D.28071 = (int) D.28070;
        D.28072 = __s2 + 3;
        D.28073 = *D.28072;
        D.28074 = (int) D.28073;
        __result = D.28071 - D.28074;
        <D.28068>:
        <D.28066>:
        <D.28058>:
        <D.28056>:
        <D.28048>:
        <D.28046>:
      }
      D.21006 = __result;
    }
    iftmp.119 = -D.21006;
    goto <D.28075>;
    <D.28039>:
    D.28035 = klass->name;
    iftmp.119 = __builtin_strcmp (D.28035, "MonoCMethod");
    <D.28075>:
    D.21007 = iftmp.119;
  }
  if (D.21007 == 0) goto <D.27993>; else goto <D.27994>;
  <D.27993>:
  {
    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.28077>; else goto <D.28080>;
    <D.28080>:
    D.28081 = mono_method_signature (method);
    D.28082 = D.28081->sentinelpos;
    if (D.28082 < 0) goto <D.28077>; else goto <D.28078>;
    <D.28077>:
    iftmp.120 = 1;
    goto <D.28079>;
    <D.28078>:
    iftmp.120 = 0;
    <D.28079>:
    D.28083 = iftmp.120 != 0;
    D.28084 = (long int) D.28083;
    D.28085 = __builtin_expect (D.28084, 0);
    if (D.28085 != 0) goto <D.28086>; else goto <D.28087>;
    <D.28086>:
    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.28087>:
    D.28088 = mono_array_length (opt_param_types);
    nargs = (int) D.28088;
    old = mono_method_signature (method);
    D.28089 = &assembly->image;
    D.28090 = old->param_count;
    D.28091 = (int) D.28090;
    D.28092 = D.28091 + nargs;
    D.28093 = (unsigned int) D.28092;
    sig = mono_metadata_signature_alloc (D.28089, D.28093);
    D.28094 = old->hasthis;
    sig->hasthis = D.28094;
    D.28095 = old->explicit_this;
    sig->explicit_this = D.28095;
    D.28096 = old->call_convention;
    sig->call_convention = D.28096;
    D.28097 = old->generic_param_count;
    sig->generic_param_count = D.28097;
    D.28090 = old->param_count;
    D.28098 = (short unsigned int) nargs;
    D.28099 = D.28090 + D.28098;
    sig->param_count = D.28099;
    D.28090 = old->param_count;
    D.28100 = (short int) D.28090;
    sig->sentinelpos = D.28100;
    D.28101 = old->ret;
    sig->ret = D.28101;
    i = 0;
    goto <D.21015>;
    <D.21014>:
    D.28102 = old->params[i];
    sig->params[i] = D.28102;
    i = i + 1;
    <D.21015>:
    D.28090 = old->param_count;
    D.28091 = (int) D.28090;
    if (D.28091 > i) goto <D.21014>; else goto <D.21016>;
    <D.21016>:
    i = 0;
    goto <D.21019>;
    <D.21018>:
    {
      struct MonoReflectionType * rt;

      D.28103 = (long unsigned int) i;
      D.28104 = mono_array_addr_with_size (opt_param_types, 8, D.28103);
      rt = MEM[(struct MonoReflectionType * *)D.28104];
      D.28090 = old->param_count;
      D.28091 = (int) D.28090;
      D.28105 = D.28091 + i;
      D.28106 = mono_reflection_type_get_handle (rt);
      sig->params[D.28105] = D.28106;
    }
    i = i + 1;
    <D.21019>:
    if (i < nargs) goto <D.21018>; else goto <D.21020>;
    <D.21020>:
    D.28107 = method->klass;
    D.28108 = &D.28107->byval_arg;
    parent = mono_image_typedef_or_ref (assembly, D.28108);
    D.28109 = parent & 3;
    D.28110 = D.28109 != 1;
    D.28111 = (long int) D.28110;
    D.28112 = __builtin_expect (D.28111, 0);
    if (D.28112 != 0) goto <D.28113>; else goto <D.28114>;
    <D.28113>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4836, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF");
    <D.28114>:
    parent = parent >> 2;
    parent = parent << 3;
    parent = parent | 1;
    sig_token = method_encode_signature (assembly, sig);
    D.28115 = method->name;
    token = mono_image_get_varargs_method_token (assembly, parent, D.28115, sig_token);
  }
  goto <D.27995>;
  <D.27994>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28119 = "MethodBuilder";
      D.28120 = MEM[(const unsigned char *)D.28119];
      D.28121 = (int) D.28120;
      D.28122 = *__s2;
      D.28123 = (int) D.28122;
      __result = D.28121 - D.28123;
      {
        if (__s2_len != 0) goto <D.28124>; else goto <D.28125>;
        <D.28124>:
        if (__result == 0) goto <D.28126>; else goto <D.28127>;
        <D.28126>:
        D.28128 = &MEM[(void *)"MethodBuilder" + 1B];
        D.28129 = *D.28128;
        D.28130 = (int) D.28129;
        D.28131 = __s2 + 1;
        D.28132 = *D.28131;
        D.28133 = (int) D.28132;
        __result = D.28130 - D.28133;
        if (__s2_len > 1) goto <D.28134>; else goto <D.28135>;
        <D.28134>:
        if (__result == 0) goto <D.28136>; else goto <D.28137>;
        <D.28136>:
        D.28138 = &MEM[(void *)"MethodBuilder" + 2B];
        D.28139 = *D.28138;
        D.28140 = (int) D.28139;
        D.28141 = __s2 + 2;
        D.28142 = *D.28141;
        D.28143 = (int) D.28142;
        __result = D.28140 - D.28143;
        if (__s2_len > 2) goto <D.28144>; else goto <D.28145>;
        <D.28144>:
        if (__result == 0) goto <D.28146>; else goto <D.28147>;
        <D.28146>:
        D.28148 = &MEM[(void *)"MethodBuilder" + 3B];
        D.28149 = *D.28148;
        D.28150 = (int) D.28149;
        D.28151 = __s2 + 3;
        D.28152 = *D.28151;
        D.28153 = (int) D.28152;
        __result = D.28150 - D.28153;
        <D.28147>:
        <D.28145>:
        <D.28137>:
        <D.28135>:
        <D.28127>:
        <D.28125>:
      }
      D.21028 = __result;
    }
    iftmp.121 = -D.21028;
    goto <D.28154>;
    <D.28118>:
    D.28035 = klass->name;
    iftmp.121 = __builtin_strcmp (D.28035, "MethodBuilder");
    <D.28154>:
    D.21029 = iftmp.121;
  }
  if (D.21029 == 0) goto <D.28155>; else goto <D.28156>;
  <D.28155>:
  {
    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.28157 = mono_array_length (opt_param_types);
        nopt_args = (int) D.28157;
        D.28159 = rmb.parameters;
        if (D.28159 != 0B) goto <D.28160>; else goto <D.28161>;
        <D.28160>:
        D.28159 = rmb.parameters;
        D.28162 = mono_array_length (D.28159);
        iftmp.122 = (int) D.28162;
        goto <D.28163>;
        <D.28161>:
        iftmp.122 = 0;
        <D.28163>:
        nparams = iftmp.122;
        D.28165 = rmb.generic_params;
        if (D.28165 != 0B) goto <D.28166>; else goto <D.28167>;
        <D.28166>:
        D.28165 = rmb.generic_params;
        D.28168 = mono_array_length (D.28165);
        iftmp.123 = (int) D.28168;
        goto <D.28169>;
        <D.28167>:
        iftmp.123 = 0;
        <D.28169>:
        ngparams = iftmp.123;
        D.28089 = &assembly->image;
        D.28170 = nparams + nopt_args;
        D.28171 = (unsigned int) D.28170;
        sig = mono_metadata_signature_alloc (D.28089, D.28171);
        D.28172 = rmb.attrs;
        D.28173 = D.28172 & 16;
        D.28174 = D.28173 == 0;
        sig->hasthis = D.28174;
        D.28175 = rmb.call_conv;
        D.28176 = D.28175 & 64;
        D.28177 = D.28176 != 0;
        sig->explicit_this = D.28177;
        D.28175 = rmb.call_conv;
        D.28178 = (unsigned char) D.28175;
        D.28179 = (<unnamed-unsigned:6>) D.28178;
        sig->call_convention = D.28179;
        D.28180 = (short unsigned int) ngparams;
        sig->generic_param_count = D.28180;
        D.28181 = (short unsigned int) nparams;
        D.28182 = (short unsigned int) nopt_args;
        D.28183 = D.28181 + D.28182;
        sig->param_count = D.28183;
        D.28184 = (short int) nparams;
        sig->sentinelpos = D.28184;
        D.28185 = rmb.rtype;
        D.28186 = mono_reflection_type_get_handle (D.28185);
        sig->ret = D.28186;
        i = 0;
        goto <D.21041>;
        <D.21040>:
        {
          struct MonoReflectionType * rt;

          D.28159 = rmb.parameters;
          D.28187 = (long unsigned int) i;
          D.28188 = mono_array_addr_with_size (D.28159, 8, D.28187);
          rt = MEM[(struct MonoReflectionType * *)D.28188];
          D.28189 = mono_reflection_type_get_handle (rt);
          sig->params[i] = D.28189;
        }
        i = i + 1;
        <D.21041>:
        if (i < nparams) goto <D.21040>; else goto <D.21042>;
        <D.21042>:
        i = 0;
        goto <D.21045>;
        <D.21044>:
        {
          struct MonoReflectionType * rt;

          D.28187 = (long unsigned int) i;
          D.28190 = mono_array_addr_with_size (opt_param_types, 8, D.28187);
          rt = MEM[(struct MonoReflectionType * *)D.28190];
          D.28191 = nparams + i;
          D.28192 = mono_reflection_type_get_handle (rt);
          sig->params[D.28191] = D.28192;
        }
        i = i + 1;
        <D.21045>:
        if (i < nopt_args) goto <D.21044>; else goto <D.21046>;
        <D.21046>:
        sig_token = method_builder_encode_signature (assembly, &rmb);
        parent = mono_image_create_token (assembly, obj, 1, 1);
        D.28193 = parent >> 24;
        D.28194 = D.28193 != 6;
        D.28195 = (long int) D.28194;
        D.28196 = __builtin_expect (D.28195, 0);
        if (D.28196 != 0) goto <D.28197>; else goto <D.28198>;
        <D.28197>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4880, "mono_metadata_token_table (parent) == MONO_TABLE_METHOD");
        <D.28198>:
        D.28199 = parent & 16777215;
        parent = D.28199 << 3;
        parent = parent | 3;
        D.28200 = rmb.name;
        name = mono_string_to_utf8 (D.28200);
        token = mono_image_get_varargs_method_token (assembly, parent, name, sig_token);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.28201>;
  <D.28156>:
  D.28035 = klass->name;
  monoeg_g_log (0B, 4, "requested method token for %s\n", D.28035);
  <D.21047>:
  goto <D.21047>;
  <D.28201>:
  <D.27995>:
  D.28202 = assembly->vararg_aux_hash;
  D.28203 = (long unsigned int) token;
  D.28204 = (void *) D.28203;
  monoeg_g_hash_table_insert_replace (D.28202, D.28204, sig, 0);
  D.28205 = assembly->tokens;
  D.28203 = (long unsigned int) token;
  D.28204 = (void *) D.28203;
  mono_g_hash_table_insert (D.28205, D.28204, obj);
  D.28206 = token;
  return D.28206;
}


method_encode_signature (struct MonoDynamicImage * assembly, struct MonoMethodSignature * sig)
{
  short unsigned int D.28208;
  int D.28209;
  guint32 D.28212;
  <unnamed-unsigned:6> D.28213;
  long unsigned int D.28214;
  long unsigned int D.28215;
  short unsigned int D.28218;
  unsigned char D.28221;
  unsigned int D.28224;
  struct MonoType * D.28225;
  short int D.28226;
  int D.28227;
  struct MonoType * D.28230;
  unsigned int i.124;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.28208 = sig->param_count;
      nparams = (guint32) D.28208;
      D.28209 = assembly->save;
      if (D.28209 == 0) goto <D.28210>; else goto <D.28211>;
      <D.28210>:
      D.28212 = 0;
      return D.28212;
      <D.28211>:
      sigbuffer_init (&buf, 32);
      D.28213 = sig->call_convention;
      idx = (guint32) D.28213;
      D.28214 = BIT_FIELD_REF <*sig, 64, 64>;
      D.28215 = D.28214 & 18014398509481984;
      if (D.28215 != 0) goto <D.28216>; else goto <D.28217>;
      <D.28216>:
      idx = idx | 32;
      <D.28217>:
      D.28218 = sig->generic_param_count;
      if (D.28218 != 0) goto <D.28219>; else goto <D.28220>;
      <D.28219>:
      idx = idx | 16;
      <D.28220>:
      D.28221 = (unsigned char) idx;
      sigbuffer_add_byte (&buf, D.28221);
      D.28218 = sig->generic_param_count;
      if (D.28218 != 0) goto <D.28222>; else goto <D.28223>;
      <D.28222>:
      D.28218 = sig->generic_param_count;
      D.28224 = (unsigned int) D.28218;
      sigbuffer_add_value (&buf, D.28224);
      <D.28223>:
      sigbuffer_add_value (&buf, nparams);
      D.28225 = sig->ret;
      encode_type (assembly, D.28225, &buf);
      i = 0;
      goto <D.19430>;
      <D.19429>:
      D.28226 = sig->sentinelpos;
      D.28227 = (int) D.28226;
      if (D.28227 == i) goto <D.28228>; else goto <D.28229>;
      <D.28228>:
      sigbuffer_add_byte (&buf, 65);
      <D.28229>:
      D.28230 = sig->params[i];
      encode_type (assembly, D.28230, &buf);
      i = i + 1;
      <D.19430>:
      i.124 = (unsigned int) i;
      if (i.124 < nparams) goto <D.19429>; else goto <D.19431>;
      <D.19431>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28212 = idx;
      return D.28212;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_varargs_method_token (struct MonoDynamicImage * assembly, guint32 original, const gchar * name, guint32 sig)
{
  int D.28234;
  unsigned int D.28237;
  unsigned int D.28238;
  guint32 * D.28239;
  unsigned int D.28240;
  unsigned int D.28241;
  long unsigned int D.28242;
  long unsigned int D.28243;
  guint32 * D.28244;
  struct MonoDynamicStream * D.28245;
  unsigned int D.28246;
  guint32 * D.28247;
  unsigned int D.28248;
  guint32 D.28249;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;

  table = &assembly->tables[10];
  D.28234 = assembly->save;
  if (D.28234 != 0) goto <D.28235>; else goto <D.28236>;
  <D.28235>:
  D.28237 = table->rows;
  D.28238 = D.28237 + 1;
  alloc_table (table, D.28238);
  D.28239 = table->values;
  D.28240 = table->next_idx;
  D.28241 = D.28240 * 3;
  D.28242 = (long unsigned int) D.28241;
  D.28243 = D.28242 * 4;
  values = D.28239 + D.28243;
  *values = original;
  D.28244 = values + 4;
  D.28245 = &assembly->sheap;
  D.28246 = string_heap_insert (D.28245, name);
  *D.28244 = D.28246;
  D.28247 = values + 8;
  *D.28247 = sig;
  <D.28236>:
  D.28240 = table->next_idx;
  token = D.28240 | 167772160;
  D.28240 = table->next_idx;
  D.28248 = D.28240 + 1;
  table->next_idx = D.28248;
  D.28249 = token;
  return D.28249;
}


mono_image_create_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, gboolean create_open_instance, gboolean register_token)
{
  struct MonoVTable * D.28251;
  struct MonoImage * D.28254;
  struct MonoImage * D.28255;
  int D.21064;
  int iftmp.125;
  int D.21063;
  const char[14] * D.28260;
  unsigned char D.28261;
  int D.28262;
  unsigned char D.28263;
  int D.28264;
  const unsigned char * D.28269;
  unsigned char D.28270;
  int D.28271;
  const unsigned char * D.28272;
  unsigned char D.28273;
  int D.28274;
  const unsigned char * D.28279;
  unsigned char D.28280;
  int D.28281;
  const unsigned char * D.28282;
  unsigned char D.28283;
  int D.28284;
  const unsigned char * D.28289;
  unsigned char D.28290;
  int D.28291;
  const unsigned char * D.28292;
  unsigned char D.28293;
  int D.28294;
  const char * D.28296;
  struct MonoException * D.28297;
  int D.21073;
  int iftmp.126;
  int D.21072;
  const char[14] * D.28301;
  unsigned char D.28302;
  int D.28303;
  unsigned char D.28304;
  int D.28305;
  const unsigned char * D.28310;
  unsigned char D.28311;
  int D.28312;
  const unsigned char * D.28313;
  unsigned char D.28314;
  int D.28315;
  const unsigned char * D.28320;
  unsigned char D.28321;
  int D.28322;
  const unsigned char * D.28323;
  unsigned char D.28324;
  int D.28325;
  const unsigned char * D.28330;
  unsigned char D.28331;
  int D.28332;
  const unsigned char * D.28333;
  unsigned char D.28334;
  int D.28335;
  struct MonoReflectionModuleBuilder * D.28341;
  struct MonoDynamicImage * D.28342;
  struct MonoArray * D.28344;
  struct MonoArray * D.28346;
  unsigned int D.28348;
  int D.21084;
  int iftmp.127;
  int D.21083;
  const char[19] * D.28353;
  unsigned char D.28354;
  int D.28355;
  unsigned char D.28356;
  int D.28357;
  const unsigned char * D.28362;
  unsigned char D.28363;
  int D.28364;
  const unsigned char * D.28365;
  unsigned char D.28366;
  int D.28367;
  const unsigned char * D.28372;
  unsigned char D.28373;
  int D.28374;
  const unsigned char * D.28375;
  unsigned char D.28376;
  int D.28377;
  const unsigned char * D.28382;
  unsigned char D.28383;
  int D.28384;
  const unsigned char * D.28385;
  unsigned char D.28386;
  int D.28387;
  struct MonoReflectionModuleBuilder * D.28393;
  struct MonoDynamicImage * D.28394;
  struct MonoArray * D.28396;
  unsigned int D.28398;
  int D.21095;
  int iftmp.128;
  int D.21094;
  const char[13] * D.28403;
  unsigned char D.28404;
  int D.28405;
  unsigned char D.28406;
  int D.28407;
  const unsigned char * D.28412;
  unsigned char D.28413;
  int D.28414;
  const unsigned char * D.28415;
  unsigned char D.28416;
  int D.28417;
  const unsigned char * D.28422;
  unsigned char D.28423;
  int D.28424;
  const unsigned char * D.28425;
  unsigned char D.28426;
  int D.28427;
  const unsigned char * D.28432;
  unsigned char D.28433;
  int D.28434;
  const unsigned char * D.28435;
  unsigned char D.28436;
  int D.28437;
  struct MonoArray * D.28441;
  struct MonoReflectionModuleBuilder * D.28445;
  struct MonoDynamicImage * D.28446;
  int D.28449;
  int D.28450;
  struct MonoClassField * D.28452;
  int D.21106;
  int iftmp.129;
  int D.21105;
  const char[12] * D.28457;
  unsigned char D.28458;
  int D.28459;
  unsigned char D.28460;
  int D.28461;
  const unsigned char * D.28466;
  unsigned char D.28467;
  int D.28468;
  const unsigned char * D.28469;
  unsigned char D.28470;
  int D.28471;
  const unsigned char * D.28476;
  unsigned char D.28477;
  int D.28478;
  const unsigned char * D.28479;
  unsigned char D.28480;
  int D.28481;
  const unsigned char * D.28486;
  unsigned char D.28487;
  int D.28488;
  const unsigned char * D.28489;
  unsigned char D.28490;
  int D.28491;
  struct MonoArray * D.28498;
  struct MonoReflectionModuleBuilder * D.28500;
  struct MonoDynamicImage * D.28501;
  unsigned int D.28504;
  unsigned int D.28506;
  int D.21118;
  int iftmp.130;
  int D.21117;
  const char[9] * D.28511;
  unsigned char D.28512;
  int D.28513;
  unsigned char D.28514;
  int D.28515;
  const unsigned char * D.28520;
  unsigned char D.28521;
  int D.28522;
  const unsigned char * D.28523;
  unsigned char D.28524;
  int D.28525;
  const unsigned char * D.28530;
  unsigned char D.28531;
  int D.28532;
  const unsigned char * D.28533;
  unsigned char D.28534;
  int D.28535;
  const unsigned char * D.28540;
  unsigned char D.28541;
  int D.28542;
  const unsigned char * D.28543;
  unsigned char D.28544;
  int D.28545;
  int iftmp.131;
  struct MonoGenericContainer * D.28553;
  unsigned int D.28555;
  int D.21129;
  int iftmp.132;
  int D.21128;
  const char[28] * D.28560;
  unsigned char D.28561;
  int D.28562;
  unsigned char D.28563;
  int D.28564;
  const unsigned char * D.28569;
  unsigned char D.28570;
  int D.28571;
  const unsigned char * D.28572;
  unsigned char D.28573;
  int D.28574;
  const unsigned char * D.28579;
  unsigned char D.28580;
  int D.28581;
  const unsigned char * D.28582;
  unsigned char D.28583;
  int D.28584;
  const unsigned char * D.28589;
  unsigned char D.28590;
  int D.28591;
  const unsigned char * D.28592;
  unsigned char D.28593;
  int D.28594;
  unsigned int D.28598;
  int D.21139;
  int iftmp.133;
  int D.21138;
  const char[17] * D.28603;
  unsigned char D.28604;
  int D.28605;
  unsigned char D.28606;
  int D.28607;
  const unsigned char * D.28612;
  unsigned char D.28613;
  int D.28614;
  const unsigned char * D.28615;
  unsigned char D.28616;
  int D.28617;
  const unsigned char * D.28622;
  unsigned char D.28623;
  int D.28624;
  const unsigned char * D.28625;
  unsigned char D.28626;
  int D.28627;
  const unsigned char * D.28632;
  unsigned char D.28633;
  int D.28634;
  const unsigned char * D.28635;
  unsigned char D.28636;
  int D.28637;
  unsigned int D.28641;
  int D.21149;
  int iftmp.134;
  int D.21148;
  const char[12] * D.28649;
  unsigned char D.28650;
  int D.28651;
  unsigned char D.28652;
  int D.28653;
  const unsigned char * D.28658;
  unsigned char D.28659;
  int D.28660;
  const unsigned char * D.28661;
  unsigned char D.28662;
  int D.28663;
  const unsigned char * D.28668;
  unsigned char D.28669;
  int D.28670;
  const unsigned char * D.28671;
  unsigned char D.28672;
  int D.28673;
  const unsigned char * D.28678;
  unsigned char D.28679;
  int D.28680;
  const unsigned char * D.28681;
  unsigned char D.28682;
  int D.28683;
  int D.21158;
  int iftmp.135;
  int D.21157;
  const char[11] * D.28689;
  unsigned char D.28690;
  int D.28691;
  unsigned char D.28692;
  int D.28693;
  const unsigned char * D.28698;
  unsigned char D.28699;
  int D.28700;
  const unsigned char * D.28701;
  unsigned char D.28702;
  int D.28703;
  const unsigned char * D.28708;
  unsigned char D.28709;
  int D.28710;
  const unsigned char * D.28711;
  unsigned char D.28712;
  int D.28713;
  const unsigned char * D.28718;
  unsigned char D.28719;
  int D.28720;
  const unsigned char * D.28721;
  unsigned char D.28722;
  int D.28723;
  int D.21167;
  int iftmp.136;
  int D.21166;
  const char[18] * D.28729;
  unsigned char D.28730;
  int D.28731;
  unsigned char D.28732;
  int D.28733;
  const unsigned char * D.28738;
  unsigned char D.28739;
  int D.28740;
  const unsigned char * D.28741;
  unsigned char D.28742;
  int D.28743;
  const unsigned char * D.28748;
  unsigned char D.28749;
  int D.28750;
  const unsigned char * D.28751;
  unsigned char D.28752;
  int D.28753;
  const unsigned char * D.28758;
  unsigned char D.28759;
  int D.28760;
  const unsigned char * D.28761;
  unsigned char D.28762;
  int D.28763;
  int D.21176;
  int iftmp.137;
  int D.21175;
  const char[19] * D.28769;
  unsigned char D.28770;
  int D.28771;
  unsigned char D.28772;
  int D.28773;
  const unsigned char * D.28778;
  unsigned char D.28779;
  int D.28780;
  const unsigned char * D.28781;
  unsigned char D.28782;
  int D.28783;
  const unsigned char * D.28788;
  unsigned char D.28789;
  int D.28790;
  const unsigned char * D.28791;
  unsigned char D.28792;
  int D.28793;
  const unsigned char * D.28798;
  unsigned char D.28799;
  int D.28800;
  const unsigned char * D.28801;
  unsigned char D.28802;
  int D.28803;
  struct MonoMethod * D.28805;
  long unsigned int D.28806;
  long unsigned int D.28807;
  struct MonoClass * D.28816;
  struct MonoImage * D.28817;
  struct MonoImage * D.28818;
  struct MonoGenericClass * D.28820;
  long unsigned int D.28822;
  long unsigned int D.28823;
  unsigned int method_table_idx.138;
  unsigned int method_table_idx.139;
  int D.21187;
  int iftmp.140;
  int D.21186;
  const char[10] * D.28832;
  unsigned char D.28833;
  int D.28834;
  unsigned char D.28835;
  int D.28836;
  const unsigned char * D.28841;
  unsigned char D.28842;
  int D.28843;
  const unsigned char * D.28844;
  unsigned char D.28845;
  int D.28846;
  const unsigned char * D.28851;
  unsigned char D.28852;
  int D.28853;
  const unsigned char * D.28854;
  unsigned char D.28855;
  int D.28856;
  const unsigned char * D.28861;
  unsigned char D.28862;
  int D.28863;
  const unsigned char * D.28864;
  unsigned char D.28865;
  int D.28866;
  struct MonoClassField * D.28872;
  struct MonoClass * D.28873;
  struct MonoImage * D.28874;
  int D.28876;
  unsigned int field_table_idx.141;
  unsigned int field_table_idx.142;
  int D.21198;
  int iftmp.143;
  int D.21197;
  const char[16] * D.28884;
  unsigned char D.28885;
  int D.28886;
  unsigned char D.28887;
  int D.28888;
  const unsigned char * D.28893;
  unsigned char D.28894;
  int D.28895;
  const unsigned char * D.28896;
  unsigned char D.28897;
  int D.28898;
  const unsigned char * D.28903;
  unsigned char D.28904;
  int D.28905;
  const unsigned char * D.28906;
  unsigned char D.28907;
  int D.28908;
  const unsigned char * D.28913;
  unsigned char D.28914;
  int D.28915;
  const unsigned char * D.28916;
  unsigned char D.28917;
  int D.28918;
  int D.21208;
  int iftmp.144;
  int D.21207;
  const char[16] * D.28926;
  unsigned char D.28927;
  int D.28928;
  unsigned char D.28929;
  int D.28930;
  const unsigned char * D.28935;
  unsigned char D.28936;
  int D.28937;
  const unsigned char * D.28938;
  unsigned char D.28939;
  int D.28940;
  const unsigned char * D.28945;
  unsigned char D.28946;
  int D.28947;
  const unsigned char * D.28948;
  unsigned char D.28949;
  int D.28950;
  const unsigned char * D.28955;
  unsigned char D.28956;
  int D.28957;
  const unsigned char * D.28958;
  unsigned char D.28959;
  int D.28960;
  unsigned int D.28964;
  int D.21218;
  int iftmp.145;
  int D.21217;
  const char[12] * D.28969;
  unsigned char D.28970;
  int D.28971;
  unsigned char D.28972;
  int D.28973;
  const unsigned char * D.28978;
  unsigned char D.28979;
  int D.28980;
  const unsigned char * D.28981;
  unsigned char D.28982;
  int D.28983;
  const unsigned char * D.28988;
  unsigned char D.28989;
  int D.28990;
  const unsigned char * D.28991;
  unsigned char D.28992;
  int D.28993;
  const unsigned char * D.28998;
  unsigned char D.28999;
  int D.29000;
  const unsigned char * D.29001;
  unsigned char D.29002;
  int D.29003;
  unsigned int D.29007;
  int D.21228;
  int iftmp.146;
  int D.21227;
  const char[23] * D.29012;
  unsigned char D.29013;
  int D.29014;
  unsigned char D.29015;
  int D.29016;
  const unsigned char * D.29021;
  unsigned char D.29022;
  int D.29023;
  const unsigned char * D.29024;
  unsigned char D.29025;
  int D.29026;
  const unsigned char * D.29031;
  unsigned char D.29032;
  int D.29033;
  const unsigned char * D.29034;
  unsigned char D.29035;
  int D.29036;
  const unsigned char * D.29041;
  unsigned char D.29042;
  int D.29043;
  const unsigned char * D.29044;
  unsigned char D.29045;
  int D.29046;
  int D.21238;
  int iftmp.147;
  int D.21237;
  const char[29] * D.29054;
  unsigned char D.29055;
  int D.29056;
  unsigned char D.29057;
  int D.29058;
  const unsigned char * D.29063;
  unsigned char D.29064;
  int D.29065;
  const unsigned char * D.29066;
  unsigned char D.29067;
  int D.29068;
  const unsigned char * D.29073;
  unsigned char D.29074;
  int D.29075;
  const unsigned char * D.29076;
  unsigned char D.29077;
  int D.29078;
  const unsigned char * D.29083;
  unsigned char D.29084;
  int D.29085;
  const unsigned char * D.29086;
  unsigned char D.29087;
  int D.29088;
  int D.21248;
  int iftmp.148;
  int D.21247;
  const char[24] * D.29096;
  unsigned char D.29097;
  int D.29098;
  unsigned char D.29099;
  int D.29100;
  const unsigned char * D.29105;
  unsigned char D.29106;
  int D.29107;
  const unsigned char * D.29108;
  unsigned char D.29109;
  int D.29110;
  const unsigned char * D.29115;
  unsigned char D.29116;
  int D.29117;
  const unsigned char * D.29118;
  unsigned char D.29119;
  int D.29120;
  const unsigned char * D.29125;
  unsigned char D.29126;
  int D.29127;
  const unsigned char * D.29128;
  unsigned char D.29129;
  int D.29130;
  int D.29138;
  int D.29140;
  int D.29142;
  struct MonoType * D.29143;
  unsigned int D.29144;
  guint32 D.29147;
  struct MonoClass * klass;
  guint32 token;

  token = 0;
  D.28251 = obj->vtable;
  klass = D.28251->klass;
  D.28254 = klass->image;
  D.28255 = mono_defaults.corlib;
  if (D.28254 != D.28255) goto <D.28252>; else goto <D.28256>;
  <D.28256>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28260 = "TypeDelegator";
      D.28261 = MEM[(const unsigned char *)D.28260];
      D.28262 = (int) D.28261;
      D.28263 = *__s2;
      D.28264 = (int) D.28263;
      __result = D.28262 - D.28264;
      {
        if (__s2_len != 0) goto <D.28265>; else goto <D.28266>;
        <D.28265>:
        if (__result == 0) goto <D.28267>; else goto <D.28268>;
        <D.28267>:
        D.28269 = &MEM[(void *)"TypeDelegator" + 1B];
        D.28270 = *D.28269;
        D.28271 = (int) D.28270;
        D.28272 = __s2 + 1;
        D.28273 = *D.28272;
        D.28274 = (int) D.28273;
        __result = D.28271 - D.28274;
        if (__s2_len > 1) goto <D.28275>; else goto <D.28276>;
        <D.28275>:
        if (__result == 0) goto <D.28277>; else goto <D.28278>;
        <D.28277>:
        D.28279 = &MEM[(void *)"TypeDelegator" + 2B];
        D.28280 = *D.28279;
        D.28281 = (int) D.28280;
        D.28282 = __s2 + 2;
        D.28283 = *D.28282;
        D.28284 = (int) D.28283;
        __result = D.28281 - D.28284;
        if (__s2_len > 2) goto <D.28285>; else goto <D.28286>;
        <D.28285>:
        if (__result == 0) goto <D.28287>; else goto <D.28288>;
        <D.28287>:
        D.28289 = &MEM[(void *)"TypeDelegator" + 3B];
        D.28290 = *D.28289;
        D.28291 = (int) D.28290;
        D.28292 = __s2 + 3;
        D.28293 = *D.28292;
        D.28294 = (int) D.28293;
        __result = D.28291 - D.28294;
        <D.28288>:
        <D.28286>:
        <D.28278>:
        <D.28276>:
        <D.28268>:
        <D.28266>:
      }
      D.21063 = __result;
    }
    iftmp.125 = -D.21063;
    goto <D.28295>;
    <D.28259>:
    D.28296 = klass->name;
    iftmp.125 = __builtin_strcmp (D.28296, "TypeDelegator");
    <D.28295>:
    D.21064 = iftmp.125;
  }
  if (D.21064 == 0) goto <D.28252>; else goto <D.28253>;
  <D.28252>:
  D.28297 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported");
  mono_raise_exception (D.28297);
  <D.28253>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28301 = "MethodBuilder";
      D.28302 = MEM[(const unsigned char *)D.28301];
      D.28303 = (int) D.28302;
      D.28304 = *__s2;
      D.28305 = (int) D.28304;
      __result = D.28303 - D.28305;
      {
        if (__s2_len != 0) goto <D.28306>; else goto <D.28307>;
        <D.28306>:
        if (__result == 0) goto <D.28308>; else goto <D.28309>;
        <D.28308>:
        D.28310 = &MEM[(void *)"MethodBuilder" + 1B];
        D.28311 = *D.28310;
        D.28312 = (int) D.28311;
        D.28313 = __s2 + 1;
        D.28314 = *D.28313;
        D.28315 = (int) D.28314;
        __result = D.28312 - D.28315;
        if (__s2_len > 1) goto <D.28316>; else goto <D.28317>;
        <D.28316>:
        if (__result == 0) goto <D.28318>; else goto <D.28319>;
        <D.28318>:
        D.28320 = &MEM[(void *)"MethodBuilder" + 2B];
        D.28321 = *D.28320;
        D.28322 = (int) D.28321;
        D.28323 = __s2 + 2;
        D.28324 = *D.28323;
        D.28325 = (int) D.28324;
        __result = D.28322 - D.28325;
        if (__s2_len > 2) goto <D.28326>; else goto <D.28327>;
        <D.28326>:
        if (__result == 0) goto <D.28328>; else goto <D.28329>;
        <D.28328>:
        D.28330 = &MEM[(void *)"MethodBuilder" + 3B];
        D.28331 = *D.28330;
        D.28332 = (int) D.28331;
        D.28333 = __s2 + 3;
        D.28334 = *D.28333;
        D.28335 = (int) D.28334;
        __result = D.28332 - D.28335;
        <D.28329>:
        <D.28327>:
        <D.28319>:
        <D.28317>:
        <D.28309>:
        <D.28307>:
      }
      D.21072 = __result;
    }
    iftmp.126 = -D.21072;
    goto <D.28336>;
    <D.28300>:
    D.28296 = klass->name;
    iftmp.126 = __builtin_strcmp (D.28296, "MethodBuilder");
    <D.28336>:
    D.21073 = iftmp.126;
  }
  if (D.21073 == 0) goto <D.28337>; else goto <D.28338>;
  <D.28337>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.28341 = tb->module;
    D.28342 = D.28341->dynamic_image;
    if (D.28342 == assembly) goto <D.28343>; else goto <D.28339>;
    <D.28343>:
    D.28344 = tb->generic_params;
    if (D.28344 == 0B) goto <D.28345>; else goto <D.28339>;
    <D.28345>:
    D.28346 = mb->generic_params;
    if (D.28346 == 0B) goto <D.28347>; else goto <D.28339>;
    <D.28347>:
    D.28348 = mb->table_idx;
    token = D.28348 | 100663296;
    goto <D.28340>;
    <D.28339>:
    token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
    <D.28340>:
  }
  goto <D.28349>;
  <D.28338>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28353 = "ConstructorBuilder";
      D.28354 = MEM[(const unsigned char *)D.28353];
      D.28355 = (int) D.28354;
      D.28356 = *__s2;
      D.28357 = (int) D.28356;
      __result = D.28355 - D.28357;
      {
        if (__s2_len != 0) goto <D.28358>; else goto <D.28359>;
        <D.28358>:
        if (__result == 0) goto <D.28360>; else goto <D.28361>;
        <D.28360>:
        D.28362 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.28363 = *D.28362;
        D.28364 = (int) D.28363;
        D.28365 = __s2 + 1;
        D.28366 = *D.28365;
        D.28367 = (int) D.28366;
        __result = D.28364 - D.28367;
        if (__s2_len > 1) goto <D.28368>; else goto <D.28369>;
        <D.28368>:
        if (__result == 0) goto <D.28370>; else goto <D.28371>;
        <D.28370>:
        D.28372 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.28373 = *D.28372;
        D.28374 = (int) D.28373;
        D.28375 = __s2 + 2;
        D.28376 = *D.28375;
        D.28377 = (int) D.28376;
        __result = D.28374 - D.28377;
        if (__s2_len > 2) goto <D.28378>; else goto <D.28379>;
        <D.28378>:
        if (__result == 0) goto <D.28380>; else goto <D.28381>;
        <D.28380>:
        D.28382 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.28383 = *D.28382;
        D.28384 = (int) D.28383;
        D.28385 = __s2 + 3;
        D.28386 = *D.28385;
        D.28387 = (int) D.28386;
        __result = D.28384 - D.28387;
        <D.28381>:
        <D.28379>:
        <D.28371>:
        <D.28369>:
        <D.28361>:
        <D.28359>:
      }
      D.21083 = __result;
    }
    iftmp.127 = -D.21083;
    goto <D.28388>;
    <D.28352>:
    D.28296 = klass->name;
    iftmp.127 = __builtin_strcmp (D.28296, "ConstructorBuilder");
    <D.28388>:
    D.21084 = iftmp.127;
  }
  if (D.21084 == 0) goto <D.28389>; else goto <D.28390>;
  <D.28389>:
  {
    struct MonoReflectionCtorBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.28393 = tb->module;
    D.28394 = D.28393->dynamic_image;
    if (D.28394 == assembly) goto <D.28395>; else goto <D.28391>;
    <D.28395>:
    D.28396 = tb->generic_params;
    if (D.28396 == 0B) goto <D.28397>; else goto <D.28391>;
    <D.28397>:
    D.28398 = mb->table_idx;
    token = D.28398 | 100663296;
    goto <D.28392>;
    <D.28391>:
    token = mono_image_get_ctorbuilder_token (assembly, mb);
    <D.28392>:
  }
  goto <D.28399>;
  <D.28390>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28403 = "FieldBuilder";
      D.28404 = MEM[(const unsigned char *)D.28403];
      D.28405 = (int) D.28404;
      D.28406 = *__s2;
      D.28407 = (int) D.28406;
      __result = D.28405 - D.28407;
      {
        if (__s2_len != 0) goto <D.28408>; else goto <D.28409>;
        <D.28408>:
        if (__result == 0) goto <D.28410>; else goto <D.28411>;
        <D.28410>:
        D.28412 = &MEM[(void *)"FieldBuilder" + 1B];
        D.28413 = *D.28412;
        D.28414 = (int) D.28413;
        D.28415 = __s2 + 1;
        D.28416 = *D.28415;
        D.28417 = (int) D.28416;
        __result = D.28414 - D.28417;
        if (__s2_len > 1) goto <D.28418>; else goto <D.28419>;
        <D.28418>:
        if (__result == 0) goto <D.28420>; else goto <D.28421>;
        <D.28420>:
        D.28422 = &MEM[(void *)"FieldBuilder" + 2B];
        D.28423 = *D.28422;
        D.28424 = (int) D.28423;
        D.28425 = __s2 + 2;
        D.28426 = *D.28425;
        D.28427 = (int) D.28426;
        __result = D.28424 - D.28427;
        if (__s2_len > 2) goto <D.28428>; else goto <D.28429>;
        <D.28428>:
        if (__result == 0) goto <D.28430>; else goto <D.28431>;
        <D.28430>:
        D.28432 = &MEM[(void *)"FieldBuilder" + 3B];
        D.28433 = *D.28432;
        D.28434 = (int) D.28433;
        D.28435 = __s2 + 3;
        D.28436 = *D.28435;
        D.28437 = (int) D.28436;
        __result = D.28434 - D.28437;
        <D.28431>:
        <D.28429>:
        <D.28421>:
        <D.28419>:
        <D.28411>:
        <D.28409>:
      }
      D.21094 = __result;
    }
    iftmp.128 = -D.21094;
    goto <D.28438>;
    <D.28402>:
    D.28296 = klass->name;
    iftmp.128 = __builtin_strcmp (D.28296, "FieldBuilder");
    <D.28438>:
    D.21095 = iftmp.128;
  }
  if (D.21095 == 0) goto <D.28439>; else goto <D.28440>;
  <D.28439>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoReflectionTypeBuilder * tb;

    fb = obj;
    tb = fb->typeb;
    D.28441 = tb->generic_params;
    if (D.28441 != 0B) goto <D.28442>; else goto <D.28443>;
    <D.28442>:
    token = mono_image_get_generic_field_token (assembly, fb);
    goto <D.28444>;
    <D.28443>:
    D.28445 = tb->module;
    D.28446 = D.28445->dynamic_image;
    if (D.28446 == assembly) goto <D.28447>; else goto <D.28448>;
    <D.28447>:
    D.28449 = fb->table_idx;
    D.28450 = D.28449 | 67108864;
    token = (guint32) D.28450;
    goto <D.28451>;
    <D.28448>:
    D.28452 = fb->handle;
    token = mono_image_get_fieldref_token (assembly, fb, D.28452);
    <D.28451>:
    <D.28444>:
  }
  goto <D.28453>;
  <D.28440>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28457 = "TypeBuilder";
      D.28458 = MEM[(const unsigned char *)D.28457];
      D.28459 = (int) D.28458;
      D.28460 = *__s2;
      D.28461 = (int) D.28460;
      __result = D.28459 - D.28461;
      {
        if (__s2_len != 0) goto <D.28462>; else goto <D.28463>;
        <D.28462>:
        if (__result == 0) goto <D.28464>; else goto <D.28465>;
        <D.28464>:
        D.28466 = &MEM[(void *)"TypeBuilder" + 1B];
        D.28467 = *D.28466;
        D.28468 = (int) D.28467;
        D.28469 = __s2 + 1;
        D.28470 = *D.28469;
        D.28471 = (int) D.28470;
        __result = D.28468 - D.28471;
        if (__s2_len > 1) goto <D.28472>; else goto <D.28473>;
        <D.28472>:
        if (__result == 0) goto <D.28474>; else goto <D.28475>;
        <D.28474>:
        D.28476 = &MEM[(void *)"TypeBuilder" + 2B];
        D.28477 = *D.28476;
        D.28478 = (int) D.28477;
        D.28479 = __s2 + 2;
        D.28480 = *D.28479;
        D.28481 = (int) D.28480;
        __result = D.28478 - D.28481;
        if (__s2_len > 2) goto <D.28482>; else goto <D.28483>;
        <D.28482>:
        if (__result == 0) goto <D.28484>; else goto <D.28485>;
        <D.28484>:
        D.28486 = &MEM[(void *)"TypeBuilder" + 3B];
        D.28487 = *D.28486;
        D.28488 = (int) D.28487;
        D.28489 = __s2 + 3;
        D.28490 = *D.28489;
        D.28491 = (int) D.28490;
        __result = D.28488 - D.28491;
        <D.28485>:
        <D.28483>:
        <D.28475>:
        <D.28473>:
        <D.28465>:
        <D.28463>:
      }
      D.21105 = __result;
    }
    iftmp.129 = -D.21105;
    goto <D.28492>;
    <D.28456>:
    D.28296 = klass->name;
    iftmp.129 = __builtin_strcmp (D.28296, "TypeBuilder");
    <D.28492>:
    D.21106 = iftmp.129;
  }
  if (D.21106 == 0) goto <D.28493>; else goto <D.28494>;
  <D.28493>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    if (create_open_instance != 0) goto <D.28497>; else goto <D.28495>;
    <D.28497>:
    D.28498 = tb->generic_params;
    if (D.28498 != 0B) goto <D.28499>; else goto <D.28495>;
    <D.28499>:
    {
      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.28496>;
    <D.28495>:
    D.28500 = tb->module;
    D.28501 = D.28500->dynamic_image;
    if (D.28501 == assembly) goto <D.28502>; else goto <D.28503>;
    <D.28502>:
    D.28504 = tb->table_idx;
    token = D.28504 | 33554432;
    goto <D.28505>;
    <D.28503>:
    {
      struct MonoType * type;

      type = mono_reflection_type_get_handle (obj);
      D.28506 = mono_image_typedef_or_ref (assembly, type);
      token = mono_metadata_token_from_dor (D.28506);
    }
    <D.28505>:
    <D.28496>:
  }
  goto <D.28507>;
  <D.28494>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28511 = "MonoType";
      D.28512 = MEM[(const unsigned char *)D.28511];
      D.28513 = (int) D.28512;
      D.28514 = *__s2;
      D.28515 = (int) D.28514;
      __result = D.28513 - D.28515;
      {
        if (__s2_len != 0) goto <D.28516>; else goto <D.28517>;
        <D.28516>:
        if (__result == 0) goto <D.28518>; else goto <D.28519>;
        <D.28518>:
        D.28520 = &MEM[(void *)"MonoType" + 1B];
        D.28521 = *D.28520;
        D.28522 = (int) D.28521;
        D.28523 = __s2 + 1;
        D.28524 = *D.28523;
        D.28525 = (int) D.28524;
        __result = D.28522 - D.28525;
        if (__s2_len > 1) goto <D.28526>; else goto <D.28527>;
        <D.28526>:
        if (__result == 0) goto <D.28528>; else goto <D.28529>;
        <D.28528>:
        D.28530 = &MEM[(void *)"MonoType" + 2B];
        D.28531 = *D.28530;
        D.28532 = (int) D.28531;
        D.28533 = __s2 + 2;
        D.28534 = *D.28533;
        D.28535 = (int) D.28534;
        __result = D.28532 - D.28535;
        if (__s2_len > 2) goto <D.28536>; else goto <D.28537>;
        <D.28536>:
        if (__result == 0) goto <D.28538>; else goto <D.28539>;
        <D.28538>:
        D.28540 = &MEM[(void *)"MonoType" + 3B];
        D.28541 = *D.28540;
        D.28542 = (int) D.28541;
        D.28543 = __s2 + 3;
        D.28544 = *D.28543;
        D.28545 = (int) D.28544;
        __result = D.28542 - D.28545;
        <D.28539>:
        <D.28537>:
        <D.28529>:
        <D.28527>:
        <D.28519>:
        <D.28517>:
      }
      D.21117 = __result;
    }
    iftmp.130 = -D.21117;
    goto <D.28546>;
    <D.28510>:
    D.28296 = klass->name;
    iftmp.130 = __builtin_strcmp (D.28296, "MonoType");
    <D.28546>:
    D.21118 = iftmp.130;
  }
  if (D.21118 == 0) goto <D.28547>; else goto <D.28548>;
  <D.28547>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.28553 = mc->generic_container;
    if (D.28553 == 0B) goto <D.28550>; else goto <D.28554>;
    <D.28554>:
    if (create_open_instance != 0) goto <D.28550>; else goto <D.28551>;
    <D.28550>:
    iftmp.131 = 1;
    goto <D.28552>;
    <D.28551>:
    iftmp.131 = 0;
    <D.28552>:
    D.28555 = mono_image_typedef_or_ref_full (assembly, type, iftmp.131);
    token = mono_metadata_token_from_dor (D.28555);
  }
  goto <D.28556>;
  <D.28548>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28560 = "GenericTypeParameterBuilder";
      D.28561 = MEM[(const unsigned char *)D.28560];
      D.28562 = (int) D.28561;
      D.28563 = *__s2;
      D.28564 = (int) D.28563;
      __result = D.28562 - D.28564;
      {
        if (__s2_len != 0) goto <D.28565>; else goto <D.28566>;
        <D.28565>:
        if (__result == 0) goto <D.28567>; else goto <D.28568>;
        <D.28567>:
        D.28569 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.28570 = *D.28569;
        D.28571 = (int) D.28570;
        D.28572 = __s2 + 1;
        D.28573 = *D.28572;
        D.28574 = (int) D.28573;
        __result = D.28571 - D.28574;
        if (__s2_len > 1) goto <D.28575>; else goto <D.28576>;
        <D.28575>:
        if (__result == 0) goto <D.28577>; else goto <D.28578>;
        <D.28577>:
        D.28579 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.28580 = *D.28579;
        D.28581 = (int) D.28580;
        D.28582 = __s2 + 2;
        D.28583 = *D.28582;
        D.28584 = (int) D.28583;
        __result = D.28581 - D.28584;
        if (__s2_len > 2) goto <D.28585>; else goto <D.28586>;
        <D.28585>:
        if (__result == 0) goto <D.28587>; else goto <D.28588>;
        <D.28587>:
        D.28589 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.28590 = *D.28589;
        D.28591 = (int) D.28590;
        D.28592 = __s2 + 3;
        D.28593 = *D.28592;
        D.28594 = (int) D.28593;
        __result = D.28591 - D.28594;
        <D.28588>:
        <D.28586>:
        <D.28578>:
        <D.28576>:
        <D.28568>:
        <D.28566>:
      }
      D.21128 = __result;
    }
    iftmp.132 = -D.21128;
    goto <D.28595>;
    <D.28559>:
    D.28296 = klass->name;
    iftmp.132 = __builtin_strcmp (D.28296, "GenericTypeParameterBuilder");
    <D.28595>:
    D.21129 = iftmp.132;
  }
  if (D.21129 == 0) goto <D.28596>; else goto <D.28597>;
  <D.28596>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.28598 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28598);
  }
  goto <D.28599>;
  <D.28597>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28603 = "MonoGenericClass";
      D.28604 = MEM[(const unsigned char *)D.28603];
      D.28605 = (int) D.28604;
      D.28606 = *__s2;
      D.28607 = (int) D.28606;
      __result = D.28605 - D.28607;
      {
        if (__s2_len != 0) goto <D.28608>; else goto <D.28609>;
        <D.28608>:
        if (__result == 0) goto <D.28610>; else goto <D.28611>;
        <D.28610>:
        D.28612 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.28613 = *D.28612;
        D.28614 = (int) D.28613;
        D.28615 = __s2 + 1;
        D.28616 = *D.28615;
        D.28617 = (int) D.28616;
        __result = D.28614 - D.28617;
        if (__s2_len > 1) goto <D.28618>; else goto <D.28619>;
        <D.28618>:
        if (__result == 0) goto <D.28620>; else goto <D.28621>;
        <D.28620>:
        D.28622 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.28623 = *D.28622;
        D.28624 = (int) D.28623;
        D.28625 = __s2 + 2;
        D.28626 = *D.28625;
        D.28627 = (int) D.28626;
        __result = D.28624 - D.28627;
        if (__s2_len > 2) goto <D.28628>; else goto <D.28629>;
        <D.28628>:
        if (__result == 0) goto <D.28630>; else goto <D.28631>;
        <D.28630>:
        D.28632 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.28633 = *D.28632;
        D.28634 = (int) D.28633;
        D.28635 = __s2 + 3;
        D.28636 = *D.28635;
        D.28637 = (int) D.28636;
        __result = D.28634 - D.28637;
        <D.28631>:
        <D.28629>:
        <D.28621>:
        <D.28619>:
        <D.28611>:
        <D.28609>:
      }
      D.21138 = __result;
    }
    iftmp.133 = -D.21138;
    goto <D.28638>;
    <D.28602>:
    D.28296 = klass->name;
    iftmp.133 = __builtin_strcmp (D.28296, "MonoGenericClass");
    <D.28638>:
    D.21139 = iftmp.133;
  }
  if (D.21139 == 0) goto <D.28639>; else goto <D.28640>;
  <D.28639>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.28641 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28641);
  }
  goto <D.28642>;
  <D.28640>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28649 = "MonoCMethod";
      D.28650 = MEM[(const unsigned char *)D.28649];
      D.28651 = (int) D.28650;
      D.28652 = *__s2;
      D.28653 = (int) D.28652;
      __result = D.28651 - D.28653;
      {
        if (__s2_len != 0) goto <D.28654>; else goto <D.28655>;
        <D.28654>:
        if (__result == 0) goto <D.28656>; else goto <D.28657>;
        <D.28656>:
        D.28658 = &MEM[(void *)"MonoCMethod" + 1B];
        D.28659 = *D.28658;
        D.28660 = (int) D.28659;
        D.28661 = __s2 + 1;
        D.28662 = *D.28661;
        D.28663 = (int) D.28662;
        __result = D.28660 - D.28663;
        if (__s2_len > 1) goto <D.28664>; else goto <D.28665>;
        <D.28664>:
        if (__result == 0) goto <D.28666>; else goto <D.28667>;
        <D.28666>:
        D.28668 = &MEM[(void *)"MonoCMethod" + 2B];
        D.28669 = *D.28668;
        D.28670 = (int) D.28669;
        D.28671 = __s2 + 2;
        D.28672 = *D.28671;
        D.28673 = (int) D.28672;
        __result = D.28670 - D.28673;
        if (__s2_len > 2) goto <D.28674>; else goto <D.28675>;
        <D.28674>:
        if (__result == 0) goto <D.28676>; else goto <D.28677>;
        <D.28676>:
        D.28678 = &MEM[(void *)"MonoCMethod" + 3B];
        D.28679 = *D.28678;
        D.28680 = (int) D.28679;
        D.28681 = __s2 + 3;
        D.28682 = *D.28681;
        D.28683 = (int) D.28682;
        __result = D.28680 - D.28683;
        <D.28677>:
        <D.28675>:
        <D.28667>:
        <D.28665>:
        <D.28657>:
        <D.28655>:
      }
      D.21148 = __result;
    }
    iftmp.134 = -D.21148;
    goto <D.28684>;
    <D.28648>:
    D.28296 = klass->name;
    iftmp.134 = __builtin_strcmp (D.28296, "MonoCMethod");
    <D.28684>:
    D.21149 = iftmp.134;
  }
  if (D.21149 == 0) goto <D.28643>; else goto <D.28685>;
  <D.28685>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

      __s2 = klass->name;
      D.28729 = "MonoGenericMethod";
      D.28730 = MEM[(const unsigned char *)D.28729];
      D.28731 = (int) D.28730;
      D.28732 = *__s2;
      D.28733 = (int) D.28732;
      __result = D.28731 - D.28733;
      {
        if (__s2_len != 0) goto <D.28734>; else goto <D.28735>;
        <D.28734>:
        if (__result == 0) goto <D.28736>; else goto <D.28737>;
        <D.28736>:
        D.28738 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.28739 = *D.28738;
        D.28740 = (int) D.28739;
        D.28741 = __s2 + 1;
        D.28742 = *D.28741;
        D.28743 = (int) D.28742;
        __result = D.28740 - D.28743;
        if (__s2_len > 1) goto <D.28744>; else goto <D.28745>;
        <D.28744>:
        if (__result == 0) goto <D.28746>; else goto <D.28747>;
        <D.28746>:
        D.28748 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.28749 = *D.28748;
        D.28750 = (int) D.28749;
        D.28751 = __s2 + 2;
        D.28752 = *D.28751;
        D.28753 = (int) D.28752;
        __result = D.28750 - D.28753;
        if (__s2_len > 2) goto <D.28754>; else goto <D.28755>;
        <D.28754>:
        if (__result == 0) goto <D.28756>; else goto <D.28757>;
        <D.28756>:
        D.28758 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.28759 = *D.28758;
        D.28760 = (int) D.28759;
        D.28761 = __s2 + 3;
        D.28762 = *D.28761;
        D.28763 = (int) D.28762;
        __result = D.28760 - D.28763;
        <D.28757>:
        <D.28755>:
        <D.28747>:
        <D.28745>:
        <D.28737>:
        <D.28735>:
      }
      D.21166 = __result;
    }
    iftmp.136 = -D.21166;
    goto <D.28764>;
    <D.28728>:
    D.28296 = klass->name;
    iftmp.136 = __builtin_strcmp (D.28296, "MonoGenericMethod");
    <D.28764>:
    D.21167 = iftmp.136;
  }
  if (D.21167 == 0) goto <D.28643>; else goto <D.28765>;
  <D.28765>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28769 = "MonoGenericCMethod";
      D.28770 = MEM[(const unsigned char *)D.28769];
      D.28771 = (int) D.28770;
      D.28772 = *__s2;
      D.28773 = (int) D.28772;
      __result = D.28771 - D.28773;
      {
        if (__s2_len != 0) goto <D.28774>; else goto <D.28775>;
        <D.28774>:
        if (__result == 0) goto <D.28776>; else goto <D.28777>;
        <D.28776>:
        D.28778 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.28779 = *D.28778;
        D.28780 = (int) D.28779;
        D.28781 = __s2 + 1;
        D.28782 = *D.28781;
        D.28783 = (int) D.28782;
        __result = D.28780 - D.28783;
        if (__s2_len > 1) goto <D.28784>; else goto <D.28785>;
        <D.28784>:
        if (__result == 0) goto <D.28786>; else goto <D.28787>;
        <D.28786>:
        D.28788 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.28789 = *D.28788;
        D.28790 = (int) D.28789;
        D.28791 = __s2 + 2;
        D.28792 = *D.28791;
        D.28793 = (int) D.28792;
        __result = D.28790 - D.28793;
        if (__s2_len > 2) goto <D.28794>; else goto <D.28795>;
        <D.28794>:
        if (__result == 0) goto <D.28796>; else goto <D.28797>;
        <D.28796>:
        D.28798 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.28799 = *D.28798;
        D.28800 = (int) D.28799;
        D.28801 = __s2 + 3;
        D.28802 = *D.28801;
        D.28803 = (int) D.28802;
        __result = D.28800 - D.28803;
        <D.28797>:
        <D.28795>:
        <D.28787>:
        <D.28785>:
        <D.28777>:
        <D.28775>:
      }
      D.21175 = __result;
    }
    iftmp.137 = -D.21175;
    goto <D.28804>;
    <D.28768>:
    D.28296 = klass->name;
    iftmp.137 = __builtin_strcmp (D.28296, "MonoGenericCMethod");
    <D.28804>:
    D.21176 = iftmp.137;
  }
  if (D.21176 == 0) goto <D.28643>; else goto <D.28644>;
  <D.28643>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.28805 = m->method;
    D.28806 = BIT_FIELD_REF <*D.28805, 64, 256>;
    D.28807 = D.28806 & 4096;
    if (D.28807 != 0) goto <D.28808>; else goto <D.28809>;
    <D.28808>:
    if (create_open_instance != 0) goto <D.28810>; else goto <D.28811>;
    <D.28810>:
    D.28805 = m->method;
    token = mono_image_get_methodspec_token (assembly, D.28805);
    goto <D.28812>;
    <D.28811>:
    D.28805 = m->method;
    token = mono_image_get_inflated_method_token (assembly, D.28805);
    <D.28812>:
    goto <D.28813>;
    <D.28809>:
    D.28805 = m->method;
    D.28816 = D.28805->klass;
    D.28817 = D.28816->image;
    D.28818 = &assembly->image;
    if (D.28817 == D.28818) goto <D.28819>; else goto <D.28814>;
    <D.28819>:
    D.28805 = m->method;
    D.28816 = D.28805->klass;
    D.28820 = D.28816->generic_class;
    if (D.28820 == 0B) goto <D.28821>; else goto <D.28814>;
    <D.28821>:
    {
      static guint32 method_table_idx = 16777215;

      D.28805 = m->method;
      D.28816 = D.28805->klass;
      D.28822 = BIT_FIELD_REF <*D.28816, 64, 256>;
      D.28823 = D.28822 & 128;
      if (D.28823 != 0) goto <D.28824>; else goto <D.28825>;
      <D.28824>:
      D.28805 = m->method;
      token = D.28805->token;
      goto <D.28826>;
      <D.28825>:
      method_table_idx.138 = method_table_idx;
      method_table_idx.139 = method_table_idx.138 + 4294967295;
      method_table_idx = method_table_idx.139;
      method_table_idx.138 = method_table_idx;
      token = method_table_idx.138 | 100663296;
      <D.28826>:
    }
    goto <D.28815>;
    <D.28814>:
    D.28805 = m->method;
    token = mono_image_get_methodref_token (assembly, D.28805, create_open_instance);
    <D.28815>:
    <D.28813>:
  }
  goto <D.28645>;
  <D.28644>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28832 = "MonoField";
      D.28833 = MEM[(const unsigned char *)D.28832];
      D.28834 = (int) D.28833;
      D.28835 = *__s2;
      D.28836 = (int) D.28835;
      __result = D.28834 - D.28836;
      {
        if (__s2_len != 0) goto <D.28837>; else goto <D.28838>;
        <D.28837>:
        if (__result == 0) goto <D.28839>; else goto <D.28840>;
        <D.28839>:
        D.28841 = &MEM[(void *)"MonoField" + 1B];
        D.28842 = *D.28841;
        D.28843 = (int) D.28842;
        D.28844 = __s2 + 1;
        D.28845 = *D.28844;
        D.28846 = (int) D.28845;
        __result = D.28843 - D.28846;
        if (__s2_len > 1) goto <D.28847>; else goto <D.28848>;
        <D.28847>:
        if (__result == 0) goto <D.28849>; else goto <D.28850>;
        <D.28849>:
        D.28851 = &MEM[(void *)"MonoField" + 2B];
        D.28852 = *D.28851;
        D.28853 = (int) D.28852;
        D.28854 = __s2 + 2;
        D.28855 = *D.28854;
        D.28856 = (int) D.28855;
        __result = D.28853 - D.28856;
        if (__s2_len > 2) goto <D.28857>; else goto <D.28858>;
        <D.28857>:
        if (__result == 0) goto <D.28859>; else goto <D.28860>;
        <D.28859>:
        D.28861 = &MEM[(void *)"MonoField" + 3B];
        D.28862 = *D.28861;
        D.28863 = (int) D.28862;
        D.28864 = __s2 + 3;
        D.28865 = *D.28864;
        D.28866 = (int) D.28865;
        __result = D.28863 - D.28866;
        <D.28860>:
        <D.28858>:
        <D.28850>:
        <D.28848>:
        <D.28840>:
        <D.28838>:
      }
      D.21186 = __result;
    }
    iftmp.140 = -D.21186;
    goto <D.28867>;
    <D.28831>:
    D.28296 = klass->name;
    iftmp.140 = __builtin_strcmp (D.28296, "MonoField");
    <D.28867>:
    D.21187 = iftmp.140;
  }
  if (D.21187 == 0) goto <D.28868>; else goto <D.28869>;
  <D.28868>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.28872 = f->field;
    D.28873 = D.28872->parent;
    D.28874 = D.28873->image;
    D.28818 = &assembly->image;
    if (D.28874 == D.28818) goto <D.28875>; else goto <D.28870>;
    <D.28875>:
    D.28872 = f->field;
    D.28876 = is_field_on_inst (D.28872);
    if (D.28876 == 0) goto <D.28877>; else goto <D.28870>;
    <D.28877>:
    {
      static guint32 field_table_idx = 16777215;

      field_table_idx.141 = field_table_idx;
      field_table_idx.142 = field_table_idx.141 + 4294967295;
      field_table_idx = field_table_idx.142;
      field_table_idx.141 = field_table_idx;
      token = field_table_idx.141 | 67108864;
    }
    goto <D.28871>;
    <D.28870>:
    D.28872 = f->field;
    token = mono_image_get_fieldref_token (assembly, f, D.28872);
    <D.28871>:
  }
  goto <D.28880>;
  <D.28869>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28884 = "MonoArrayMethod";
      D.28885 = MEM[(const unsigned char *)D.28884];
      D.28886 = (int) D.28885;
      D.28887 = *__s2;
      D.28888 = (int) D.28887;
      __result = D.28886 - D.28888;
      {
        if (__s2_len != 0) goto <D.28889>; else goto <D.28890>;
        <D.28889>:
        if (__result == 0) goto <D.28891>; else goto <D.28892>;
        <D.28891>:
        D.28893 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.28894 = *D.28893;
        D.28895 = (int) D.28894;
        D.28896 = __s2 + 1;
        D.28897 = *D.28896;
        D.28898 = (int) D.28897;
        __result = D.28895 - D.28898;
        if (__s2_len > 1) goto <D.28899>; else goto <D.28900>;
        <D.28899>:
        if (__result == 0) goto <D.28901>; else goto <D.28902>;
        <D.28901>:
        D.28903 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.28904 = *D.28903;
        D.28905 = (int) D.28904;
        D.28906 = __s2 + 2;
        D.28907 = *D.28906;
        D.28908 = (int) D.28907;
        __result = D.28905 - D.28908;
        if (__s2_len > 2) goto <D.28909>; else goto <D.28910>;
        <D.28909>:
        if (__result == 0) goto <D.28911>; else goto <D.28912>;
        <D.28911>:
        D.28913 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.28914 = *D.28913;
        D.28915 = (int) D.28914;
        D.28916 = __s2 + 3;
        D.28917 = *D.28916;
        D.28918 = (int) D.28917;
        __result = D.28915 - D.28918;
        <D.28912>:
        <D.28910>:
        <D.28902>:
        <D.28900>:
        <D.28892>:
        <D.28890>:
      }
      D.21197 = __result;
    }
    iftmp.143 = -D.21197;
    goto <D.28919>;
    <D.28883>:
    D.28296 = klass->name;
    iftmp.143 = __builtin_strcmp (D.28296, "MonoArrayMethod");
    <D.28919>:
    D.21198 = iftmp.143;
  }
  if (D.21198 == 0) goto <D.28920>; else goto <D.28921>;
  <D.28920>:
  {
    struct MonoReflectionArrayMethod * m;

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

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

      __s2 = klass->name;
      D.28926 = "SignatureHelper";
      D.28927 = MEM[(const unsigned char *)D.28926];
      D.28928 = (int) D.28927;
      D.28929 = *__s2;
      D.28930 = (int) D.28929;
      __result = D.28928 - D.28930;
      {
        if (__s2_len != 0) goto <D.28931>; else goto <D.28932>;
        <D.28931>:
        if (__result == 0) goto <D.28933>; else goto <D.28934>;
        <D.28933>:
        D.28935 = &MEM[(void *)"SignatureHelper" + 1B];
        D.28936 = *D.28935;
        D.28937 = (int) D.28936;
        D.28938 = __s2 + 1;
        D.28939 = *D.28938;
        D.28940 = (int) D.28939;
        __result = D.28937 - D.28940;
        if (__s2_len > 1) goto <D.28941>; else goto <D.28942>;
        <D.28941>:
        if (__result == 0) goto <D.28943>; else goto <D.28944>;
        <D.28943>:
        D.28945 = &MEM[(void *)"SignatureHelper" + 2B];
        D.28946 = *D.28945;
        D.28947 = (int) D.28946;
        D.28948 = __s2 + 2;
        D.28949 = *D.28948;
        D.28950 = (int) D.28949;
        __result = D.28947 - D.28950;
        if (__s2_len > 2) goto <D.28951>; else goto <D.28952>;
        <D.28951>:
        if (__result == 0) goto <D.28953>; else goto <D.28954>;
        <D.28953>:
        D.28955 = &MEM[(void *)"SignatureHelper" + 3B];
        D.28956 = *D.28955;
        D.28957 = (int) D.28956;
        D.28958 = __s2 + 3;
        D.28959 = *D.28958;
        D.28960 = (int) D.28959;
        __result = D.28957 - D.28960;
        <D.28954>:
        <D.28952>:
        <D.28944>:
        <D.28942>:
        <D.28934>:
        <D.28932>:
      }
      D.21207 = __result;
    }
    iftmp.144 = -D.21207;
    goto <D.28961>;
    <D.28925>:
    D.28296 = klass->name;
    iftmp.144 = __builtin_strcmp (D.28296, "SignatureHelper");
    <D.28961>:
    D.21208 = iftmp.144;
  }
  if (D.21208 == 0) goto <D.28962>; else goto <D.28963>;
  <D.28962>:
  {
    struct MonoReflectionSigHelper * s;

    s = obj;
    D.28964 = mono_image_get_sighelper_token (assembly, s);
    token = D.28964 | 285212672;
  }
  goto <D.28965>;
  <D.28963>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28969 = "EnumBuilder";
      D.28970 = MEM[(const unsigned char *)D.28969];
      D.28971 = (int) D.28970;
      D.28972 = *__s2;
      D.28973 = (int) D.28972;
      __result = D.28971 - D.28973;
      {
        if (__s2_len != 0) goto <D.28974>; else goto <D.28975>;
        <D.28974>:
        if (__result == 0) goto <D.28976>; else goto <D.28977>;
        <D.28976>:
        D.28978 = &MEM[(void *)"EnumBuilder" + 1B];
        D.28979 = *D.28978;
        D.28980 = (int) D.28979;
        D.28981 = __s2 + 1;
        D.28982 = *D.28981;
        D.28983 = (int) D.28982;
        __result = D.28980 - D.28983;
        if (__s2_len > 1) goto <D.28984>; else goto <D.28985>;
        <D.28984>:
        if (__result == 0) goto <D.28986>; else goto <D.28987>;
        <D.28986>:
        D.28988 = &MEM[(void *)"EnumBuilder" + 2B];
        D.28989 = *D.28988;
        D.28990 = (int) D.28989;
        D.28991 = __s2 + 2;
        D.28992 = *D.28991;
        D.28993 = (int) D.28992;
        __result = D.28990 - D.28993;
        if (__s2_len > 2) goto <D.28994>; else goto <D.28995>;
        <D.28994>:
        if (__result == 0) goto <D.28996>; else goto <D.28997>;
        <D.28996>:
        D.28998 = &MEM[(void *)"EnumBuilder" + 3B];
        D.28999 = *D.28998;
        D.29000 = (int) D.28999;
        D.29001 = __s2 + 3;
        D.29002 = *D.29001;
        D.29003 = (int) D.29002;
        __result = D.29000 - D.29003;
        <D.28997>:
        <D.28995>:
        <D.28987>:
        <D.28985>:
        <D.28977>:
        <D.28975>:
      }
      D.21217 = __result;
    }
    iftmp.145 = -D.21217;
    goto <D.29004>;
    <D.28968>:
    D.28296 = klass->name;
    iftmp.145 = __builtin_strcmp (D.28296, "EnumBuilder");
    <D.29004>:
    D.21218 = iftmp.145;
  }
  if (D.21218 == 0) goto <D.29005>; else goto <D.29006>;
  <D.29005>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.29007 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.29007);
  }
  goto <D.29008>;
  <D.29006>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.29012 = "FieldOnTypeBuilderInst";
      D.29013 = MEM[(const unsigned char *)D.29012];
      D.29014 = (int) D.29013;
      D.29015 = *__s2;
      D.29016 = (int) D.29015;
      __result = D.29014 - D.29016;
      {
        if (__s2_len != 0) goto <D.29017>; else goto <D.29018>;
        <D.29017>:
        if (__result == 0) goto <D.29019>; else goto <D.29020>;
        <D.29019>:
        D.29021 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.29022 = *D.29021;
        D.29023 = (int) D.29022;
        D.29024 = __s2 + 1;
        D.29025 = *D.29024;
        D.29026 = (int) D.29025;
        __result = D.29023 - D.29026;
        if (__s2_len > 1) goto <D.29027>; else goto <D.29028>;
        <D.29027>:
        if (__result == 0) goto <D.29029>; else goto <D.29030>;
        <D.29029>:
        D.29031 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.29032 = *D.29031;
        D.29033 = (int) D.29032;
        D.29034 = __s2 + 2;
        D.29035 = *D.29034;
        D.29036 = (int) D.29035;
        __result = D.29033 - D.29036;
        if (__s2_len > 2) goto <D.29037>; else goto <D.29038>;
        <D.29037>:
        if (__result == 0) goto <D.29039>; else goto <D.29040>;
        <D.29039>:
        D.29041 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.29042 = *D.29041;
        D.29043 = (int) D.29042;
        D.29044 = __s2 + 3;
        D.29045 = *D.29044;
        D.29046 = (int) D.29045;
        __result = D.29043 - D.29046;
        <D.29040>:
        <D.29038>:
        <D.29030>:
        <D.29028>:
        <D.29020>:
        <D.29018>:
      }
      D.21227 = __result;
    }
    iftmp.146 = -D.21227;
    goto <D.29047>;
    <D.29011>:
    D.28296 = klass->name;
    iftmp.146 = __builtin_strcmp (D.28296, "FieldOnTypeBuilderInst");
    <D.29047>:
    D.21228 = iftmp.146;
  }
  if (D.21228 == 0) goto <D.29048>; else goto <D.29049>;
  <D.29048>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;

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

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

      __s2 = klass->name;
      D.29054 = "ConstructorOnTypeBuilderInst";
      D.29055 = MEM[(const unsigned char *)D.29054];
      D.29056 = (int) D.29055;
      D.29057 = *__s2;
      D.29058 = (int) D.29057;
      __result = D.29056 - D.29058;
      {
        if (__s2_len != 0) goto <D.29059>; else goto <D.29060>;
        <D.29059>:
        if (__result == 0) goto <D.29061>; else goto <D.29062>;
        <D.29061>:
        D.29063 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.29064 = *D.29063;
        D.29065 = (int) D.29064;
        D.29066 = __s2 + 1;
        D.29067 = *D.29066;
        D.29068 = (int) D.29067;
        __result = D.29065 - D.29068;
        if (__s2_len > 1) goto <D.29069>; else goto <D.29070>;
        <D.29069>:
        if (__result == 0) goto <D.29071>; else goto <D.29072>;
        <D.29071>:
        D.29073 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.29074 = *D.29073;
        D.29075 = (int) D.29074;
        D.29076 = __s2 + 2;
        D.29077 = *D.29076;
        D.29078 = (int) D.29077;
        __result = D.29075 - D.29078;
        if (__s2_len > 2) goto <D.29079>; else goto <D.29080>;
        <D.29079>:
        if (__result == 0) goto <D.29081>; else goto <D.29082>;
        <D.29081>:
        D.29083 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.29084 = *D.29083;
        D.29085 = (int) D.29084;
        D.29086 = __s2 + 3;
        D.29087 = *D.29086;
        D.29088 = (int) D.29087;
        __result = D.29085 - D.29088;
        <D.29082>:
        <D.29080>:
        <D.29072>:
        <D.29070>:
        <D.29062>:
        <D.29060>:
      }
      D.21237 = __result;
    }
    iftmp.147 = -D.21237;
    goto <D.29089>;
    <D.29053>:
    D.28296 = klass->name;
    iftmp.147 = __builtin_strcmp (D.28296, "ConstructorOnTypeBuilderInst");
    <D.29089>:
    D.21238 = iftmp.147;
  }
  if (D.21238 == 0) goto <D.29090>; else goto <D.29091>;
  <D.29090>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;

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

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

      __s2 = klass->name;
      D.29096 = "MethodOnTypeBuilderInst";
      D.29097 = MEM[(const unsigned char *)D.29096];
      D.29098 = (int) D.29097;
      D.29099 = *__s2;
      D.29100 = (int) D.29099;
      __result = D.29098 - D.29100;
      {
        if (__s2_len != 0) goto <D.29101>; else goto <D.29102>;
        <D.29101>:
        if (__result == 0) goto <D.29103>; else goto <D.29104>;
        <D.29103>:
        D.29105 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.29106 = *D.29105;
        D.29107 = (int) D.29106;
        D.29108 = __s2 + 1;
        D.29109 = *D.29108;
        D.29110 = (int) D.29109;
        __result = D.29107 - D.29110;
        if (__s2_len > 1) goto <D.29111>; else goto <D.29112>;
        <D.29111>:
        if (__result == 0) goto <D.29113>; else goto <D.29114>;
        <D.29113>:
        D.29115 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.29116 = *D.29115;
        D.29117 = (int) D.29116;
        D.29118 = __s2 + 2;
        D.29119 = *D.29118;
        D.29120 = (int) D.29119;
        __result = D.29117 - D.29120;
        if (__s2_len > 2) goto <D.29121>; else goto <D.29122>;
        <D.29121>:
        if (__result == 0) goto <D.29123>; else goto <D.29124>;
        <D.29123>:
        D.29125 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.29126 = *D.29125;
        D.29127 = (int) D.29126;
        D.29128 = __s2 + 3;
        D.29129 = *D.29128;
        D.29130 = (int) D.29129;
        __result = D.29127 - D.29130;
        <D.29124>:
        <D.29122>:
        <D.29114>:
        <D.29112>:
        <D.29104>:
        <D.29102>:
      }
      D.21247 = __result;
    }
    iftmp.148 = -D.21247;
    goto <D.29131>;
    <D.29095>:
    D.28296 = klass->name;
    iftmp.148 = __builtin_strcmp (D.28296, "MethodOnTypeBuilderInst");
    <D.29131>:
    D.21248 = iftmp.148;
  }
  if (D.21248 == 0) goto <D.29132>; else goto <D.29133>;
  <D.29132>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
  }
  goto <D.29134>;
  <D.29133>:
  D.29138 = is_sre_array (klass);
  if (D.29138 != 0) goto <D.29135>; else goto <D.29139>;
  <D.29139>:
  D.29140 = is_sre_byref (klass);
  if (D.29140 != 0) goto <D.29135>; else goto <D.29141>;
  <D.29141>:
  D.29142 = is_sre_pointer (klass);
  if (D.29142 != 0) goto <D.29135>; else goto <D.29136>;
  <D.29135>:
  {
    struct MonoReflectionType * type;

    type = obj;
    D.29143 = mono_reflection_type_get_handle (type);
    D.29144 = mono_image_typedef_or_ref (assembly, D.29143);
    token = mono_metadata_token_from_dor (D.29144);
  }
  goto <D.29137>;
  <D.29136>:
  D.28296 = klass->name;
  monoeg_g_log (0B, 4, "requested token for %s\n", D.28296);
  <D.21251>:
  goto <D.21251>;
  <D.29137>:
  <D.29134>:
  <D.29092>:
  <D.29050>:
  <D.29008>:
  <D.28965>:
  <D.28922>:
  <D.28880>:
  <D.28645>:
  <D.28642>:
  <D.28599>:
  <D.28556>:
  <D.28507>:
  <D.28453>:
  <D.28399>:
  <D.28349>:
  if (register_token != 0) goto <D.29145>; else goto <D.29146>;
  <D.29145>:
  mono_image_register_token (assembly, token, obj);
  <D.29146>:
  D.29147 = token;
  return D.29147;
}


mono_image_get_methodbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb, gboolean create_methodspec)
{
  struct MonoArray * D.29149;
  guint32 D.29154;
  struct MonoGHashTable * D.29155;
  void * D.29156;
  long int D.29157;
  long unsigned int D.29160;
  void * D.29161;
  guint32 token;

  D.29149 = mb->generic_params;
  if (D.29149 != 0B) goto <D.29150>; else goto <D.29151>;
  <D.29150>:
  if (create_methodspec != 0) goto <D.29152>; else goto <D.29153>;
  <D.29152>:
  D.29154 = mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
  return D.29154;
  <D.29153>:
  <D.29151>:
  D.29155 = assembly->handleref_managed;
  D.29156 = mono_g_hash_table_lookup (D.29155, mb);
  D.29157 = (long int) D.29156;
  token = (guint32) D.29157;
  if (token != 0) goto <D.29158>; else goto <D.29159>;
  <D.29158>:
  D.29154 = token;
  return D.29154;
  <D.29159>:
  token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.29155 = assembly->handleref_managed;
  D.29160 = (long unsigned int) token;
  D.29161 = (void *) D.29160;
  mono_g_hash_table_insert (D.29155, mb, D.29161);
  D.29154 = token;
  return D.29154;
}


mono_image_get_methodspec_token_for_generic_method_definition (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoGHashTable * D.29163;
  void * D.29164;
  long int D.29165;
  guint32 D.29168;
  unsigned int D.29169;
  unsigned int D.29170;
  unsigned int D.29171;
  int D.29172;
  unsigned int D.29175;
  unsigned int D.29176;
  guint32 * D.29177;
  unsigned int D.29178;
  unsigned int D.29179;
  long unsigned int D.29180;
  long unsigned int D.29181;
  guint32 * D.29182;
  unsigned int D.29183;
  unsigned int D.29184;
  long unsigned int D.29185;
  void * D.29186;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;

  mtoken = 0;
  D.29163 = assembly->methodspec;
  D.29164 = mono_g_hash_table_lookup (D.29163, mb);
  D.29165 = (long int) D.29164;
  token = (guint32) D.29165;
  if (token != 0) goto <D.29166>; else goto <D.29167>;
  <D.29166>:
  D.29168 = token;
  return D.29168;
  <D.29167>:
  table = &assembly->tables[43];
  mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.29169 = mtoken >> 24;
  switch (D.29169) <default: <D.19993>, case 6: <D.19992>, case 10: <D.19990>>
  <D.19990>:
  D.29170 = mtoken & 16777215;
  D.29171 = D.29170 << 1;
  mtoken = D.29171 | 1;
  goto <D.19991>;
  <D.19992>:
  D.29170 = mtoken & 16777215;
  mtoken = D.29170 << 1;
  goto <D.19991>;
  <D.19993>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2637);
  <D.19991>:
  D.29172 = assembly->save;
  if (D.29172 != 0) goto <D.29173>; else goto <D.29174>;
  <D.29173>:
  D.29175 = table->rows;
  D.29176 = D.29175 + 1;
  alloc_table (table, D.29176);
  D.29177 = table->values;
  D.29178 = table->next_idx;
  D.29179 = D.29178 * 2;
  D.29180 = (long unsigned int) D.29179;
  D.29181 = D.29180 * 4;
  values = D.29177 + D.29181;
  *values = mtoken;
  D.29182 = values + 4;
  D.29183 = encode_generic_method_definition_sig (assembly, mb);
  *D.29182 = D.29183;
  <D.29174>:
  D.29178 = table->next_idx;
  token = D.29178 | 721420288;
  D.29178 = table->next_idx;
  D.29184 = D.29178 + 1;
  table->next_idx = D.29184;
  D.29163 = assembly->methodspec;
  D.29185 = (long unsigned int) token;
  D.29186 = (void *) D.29185;
  mono_g_hash_table_insert (D.29163, mb, D.29186);
  D.29168 = token;
  return D.29168;
}


encode_generic_method_definition_sig (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.29188;
  long unsigned int D.29189;
  int D.29190;
  guint32 D.29193;
  unsigned int i.149;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.29188 = mb->generic_params;
      D.29189 = mono_array_length (D.29188);
      nparams = (guint32) D.29189;
      D.29190 = assembly->save;
      if (D.29190 == 0) goto <D.29191>; else goto <D.29192>;
      <D.29191>:
      D.29193 = 0;
      return D.29193;
      <D.29192>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19980>;
      <D.19979>:
      sigbuffer_add_value (&buf, 30);
      i.149 = (unsigned int) i;
      sigbuffer_add_value (&buf, i.149);
      i = i + 1;
      <D.19980>:
      i.149 = (unsigned int) i;
      if (i.149 < nparams) goto <D.19979>; else goto <D.19981>;
      <D.19981>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29193 = idx;
      return D.29193;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodref_token_for_methodbuilder (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * method)
{
  struct GHashTable * D.29197;
  void * D.29198;
  long int D.29199;
  guint32 D.29202;
  struct MonoString * D.29203;
  unsigned int D.29204;
  unsigned int D.29205;
  unsigned int D.29210;
  struct MonoArray * D.29211;
  struct MonoObject * D.29215;
  struct MonoType * D.29216;
  long unsigned int D.29217;
  void * D.29218;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = method->type;
      D.29197 = assembly->handleref;
      D.29198 = monoeg_g_hash_table_lookup (D.29197, method);
      D.29199 = (long int) D.29198;
      token = (guint32) D.29199;
      if (token != 0) goto <D.29200>; else goto <D.29201>;
      <D.29200>:
      D.29202 = token;
      return D.29202;
      <D.29201>:
      D.29203 = method->name;
      name = mono_string_to_utf8 (D.29203);
      reflection_methodbuilder_from_method_builder (&rmb, method);
      D.29204 = rmb.call_conv;
      D.29205 = D.29204 & 4294967199;
      if (D.29205 != 0) goto <D.29206>; else goto <D.29207>;
      <D.29206>:
      D.29204 = rmb.call_conv;
      D.29205 = D.29204 & 4294967199;
      if (D.29205 != 5) goto <D.29208>; else goto <D.29209>;
      <D.29208>:
      D.29204 = rmb.call_conv;
      D.29210 = D.29204 & 96;
      rmb.call_conv = D.29210;
      <D.29209>:
      <D.29207>:
      sig = method_builder_encode_signature (assembly, &rmb);
      D.29211 = tb->generic_params;
      if (D.29211 != 0B) goto <D.29212>; else goto <D.29213>;
      <D.29212>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.29214>;
      <D.29213>:
      D.29215 = rmb.type;
      D.29216 = mono_reflection_type_get_handle (D.29215);
      parent = mono_image_typedef_or_ref (assembly, D.29216);
      <D.29214>:
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.29197 = assembly->handleref;
      D.29217 = (long unsigned int) token;
      D.29218 = (void *) D.29217;
      monoeg_g_hash_table_insert_replace (D.29197, method, D.29218, 0);
      D.29202 = token;
      return D.29202;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


create_generic_typespec (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct GHashTable * D.29221;
  void * D.29222;
  long int D.29223;
  guint32 D.29226;
  struct MonoArray * D.29227;
  _Bool D.29228;
  long int D.29229;
  long int D.29230;
  struct MonoGenericContainer * D.29233;
  struct MonoGenericContainer * D.29236;
  _Bool D.29237;
  long int D.29238;
  long int D.29239;
  unsigned char D.29242;
  unsigned int D.29243;
  struct MonoType * D.29244;
  unsigned int D.29245;
  long unsigned int D.29246;
  unsigned int count.150;
  long unsigned int D.29248;
  char * D.29249;
  struct MonoType * D.29250;
  int D.29251;
  unsigned int D.29254;
  unsigned int D.29255;
  guint32 * D.29256;
  unsigned int D.29257;
  long unsigned int D.29258;
  long unsigned int D.29259;
  unsigned int D.29260;
  long unsigned int D.29261;
  void * D.29262;
  unsigned int D.29263;
  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.29221 = assembly->typespec;
      D.29222 = monoeg_g_hash_table_lookup (D.29221, type);
      D.29223 = (long int) D.29222;
      token = (guint32) D.29223;
      if (token != 0) goto <D.29224>; else goto <D.29225>;
      <D.29224>:
      D.29226 = token;
      return D.29226;
      <D.29225>:
      sigbuffer_init (&buf, 32);
      D.29227 = tb->generic_params;
      D.29228 = D.29227 == 0B;
      D.29229 = (long int) D.29228;
      D.29230 = __builtin_expect (D.29229, 0);
      if (D.29230 != 0) goto <D.29231>; else goto <D.29232>;
      <D.29231>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3096, "tb->generic_params");
      <D.29232>:
      klass = mono_class_from_mono_type (type);
      D.29233 = tb->generic_container;
      if (D.29233 != 0B) goto <D.29234>; else goto <D.29235>;
      <D.29234>:
      mono_reflection_create_generic_class (tb);
      <D.29235>:
      sigbuffer_add_value (&buf, 21);
      D.29236 = klass->generic_container;
      D.29237 = D.29236 == 0B;
      D.29238 = (long int) D.29237;
      D.29239 = __builtin_expect (D.29238, 0);
      if (D.29239 != 0) goto <D.29240>; else goto <D.29241>;
      <D.29240>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3103, "klass->generic_container");
      <D.29241>:
      D.29242 = klass->byval_arg.type;
      D.29243 = (unsigned int) D.29242;
      sigbuffer_add_value (&buf, D.29243);
      D.29244 = &klass->byval_arg;
      D.29245 = mono_image_typedef_or_ref_full (assembly, D.29244, 0);
      sigbuffer_add_value (&buf, D.29245);
      D.29227 = tb->generic_params;
      D.29246 = mono_array_length (D.29227);
      count = (int) D.29246;
      count.150 = (unsigned int) count;
      sigbuffer_add_value (&buf, count.150);
      i = 0;
      goto <D.20146>;
      <D.20145>:
      {
        struct MonoReflectionGenericParam * gparam;

        D.29227 = tb->generic_params;
        D.29248 = (long unsigned int) i;
        D.29249 = mono_array_addr_with_size (D.29227, 8, D.29248);
        gparam = MEM[(struct MonoReflectionGenericParam * *)D.29249];
        D.29250 = mono_reflection_type_get_handle (gparam);
        encode_type (assembly, D.29250, &buf);
      }
      i = i + 1;
      <D.20146>:
      if (i < count) goto <D.20145>; else goto <D.20147>;
      <D.20147>:
      table = &assembly->tables[27];
      D.29251 = assembly->save;
      if (D.29251 != 0) goto <D.29252>; else goto <D.29253>;
      <D.29252>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.29254 = table->rows;
      D.29255 = D.29254 + 1;
      alloc_table (table, D.29255);
      D.29256 = table->values;
      D.29257 = table->next_idx;
      D.29258 = (long unsigned int) D.29257;
      D.29259 = D.29258 * 4;
      values = D.29256 + D.29259;
      *values = token;
      <D.29253>:
      sigbuffer_free (&buf);
      D.29257 = table->next_idx;
      D.29260 = D.29257 << 2;
      token = D.29260 | 2;
      D.29221 = assembly->typespec;
      D.29261 = (long unsigned int) token;
      D.29262 = (void *) D.29261;
      monoeg_g_hash_table_insert_replace (D.29221, type, D.29262, 0);
      D.29257 = table->next_idx;
      D.29263 = D.29257 + 1;
      table->next_idx = D.29263;
      D.29226 = token;
      return D.29226;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_memberef_row (struct MonoDynamicImage * assembly, guint32 parent, const char * name, guint32 sig)
{
  unsigned int D.29266;
  guint32 D.29267;
  int D.29268;
  unsigned int D.29271;
  unsigned int D.29272;
  guint32 * D.29273;
  unsigned int D.29274;
  unsigned int D.29275;
  long unsigned int D.29276;
  long unsigned int D.29277;
  unsigned int D.29278;
  unsigned int D.29279;
  guint32 * D.29280;
  struct MonoDynamicStream * D.29281;
  unsigned int D.29282;
  guint32 * D.29283;
  unsigned int D.29284;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 pclass;

  D.29266 = parent & 3;
  switch (D.29266) <default: <D.19935>, case 0: <D.19934>, case 1: <D.19931>, case 2: <D.19933>>
  <D.19931>:
  pclass = 1;
  goto <D.19932>;
  <D.19933>:
  pclass = 4;
  goto <D.19932>;
  <D.19934>:
  pclass = 0;
  goto <D.19932>;
  <D.19935>:
  monoeg_g_log (0B, 16, "unknown typeref or def token 0x%08x for %s", parent, name);
  D.29267 = 0;
  return D.29267;
  <D.19932>:
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.29268 = assembly->save;
  if (D.29268 != 0) goto <D.29269>; else goto <D.29270>;
  <D.29269>:
  D.29271 = table->rows;
  D.29272 = D.29271 + 1;
  alloc_table (table, D.29272);
  D.29273 = table->values;
  D.29274 = table->next_idx;
  D.29275 = D.29274 * 3;
  D.29276 = (long unsigned int) D.29275;
  D.29277 = D.29276 * 4;
  values = D.29273 + D.29277;
  D.29278 = parent << 3;
  D.29279 = D.29278 | pclass;
  *values = D.29279;
  D.29280 = values + 4;
  D.29281 = &assembly->sheap;
  D.29282 = string_heap_insert (D.29281, name);
  *D.29280 = D.29282;
  D.29283 = values + 8;
  *D.29283 = sig;
  <D.29270>:
  D.29274 = table->next_idx;
  token = D.29274 | 167772160;
  D.29274 = table->next_idx;
  D.29284 = D.29274 + 1;
  table->next_idx = D.29284;
  D.29267 = token;
  return D.29267;
}


mono_image_get_ctorbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoGHashTable * D.29286;
  void * D.29287;
  long int D.29288;
  guint32 D.29291;
  struct MonoArray * D.29292;
  struct MonoType * D.29296;
  struct MonoString * D.29297;
  long unsigned int D.29298;
  void * D.29299;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = mb->type;
      D.29286 = assembly->handleref_managed;
      D.29287 = mono_g_hash_table_lookup (D.29286, mb);
      D.29288 = (long int) D.29287;
      token = (guint32) D.29288;
      if (token != 0) goto <D.29289>; else goto <D.29290>;
      <D.29289>:
      D.29291 = token;
      return D.29291;
      <D.29290>:
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.29292 = tb->generic_params;
      if (D.29292 != 0B) goto <D.29293>; else goto <D.29294>;
      <D.29293>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.29295>;
      <D.29294>:
      D.29296 = mono_reflection_type_get_handle (tb);
      parent = mono_image_typedef_or_ref (assembly, D.29296);
      <D.29295>:
      D.29297 = rmb.name;
      name = mono_string_to_utf8 (D.29297);
      sig = method_builder_encode_signature (assembly, &rmb);
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.29286 = assembly->handleref_managed;
      D.29298 = (long unsigned int) token;
      D.29299 = (void *) D.29298;
      mono_g_hash_table_insert (D.29286, mb, D.29299);
      D.29291 = token;
      return D.29291;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


mono_image_get_generic_field_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoGHashTable * D.29302;
  void * D.29303;
  long int D.29304;
  guint32 D.29307;
  struct MonoReflectionType * D.29308;
  struct MonoType * D.29309;
  struct MonoString * D.29310;
  struct MonoObject * D.29311;
  struct MonoArray * D.29314;
  struct MonoArray * D.29316;
  unsigned int D.29317;
  _Bool D.29318;
  long int D.29319;
  long int D.29320;
  int D.29323;
  unsigned int D.29326;
  unsigned int D.29327;
  guint32 * D.29328;
  unsigned int D.29329;
  unsigned int D.29330;
  long unsigned int D.29331;
  long unsigned int D.29332;
  unsigned int D.29333;
  unsigned int D.29334;
  guint32 * D.29335;
  struct MonoDynamicStream * D.29336;
  unsigned int D.29337;
  guint32 * D.29338;
  unsigned int D.29339;
  long unsigned int D.29340;
  void * D.29341;
  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.29302 = assembly->handleref_managed;
  D.29303 = mono_g_hash_table_lookup (D.29302, fb);
  D.29304 = (long int) D.29303;
  token = (guint32) D.29304;
  if (token != 0) goto <D.29305>; else goto <D.29306>;
  <D.29305>:
  D.29307 = token;
  return D.29307;
  <D.29306>:
  D.29308 = fb->typeb;
  D.29309 = mono_reflection_type_get_handle (D.29308);
  klass = mono_class_from_mono_type (D.29309);
  D.29310 = fb->name;
  name = mono_string_to_utf8 (D.29310);
  D.29311 = fb->type;
  init_type_builder_generics (D.29311);
  D.29311 = fb->type;
  type = mono_reflection_type_get_handle (D.29311);
  D.29314 = fb->modreq;
  if (D.29314 != 0B) goto <D.29312>; else goto <D.29315>;
  <D.29315>:
  D.29316 = fb->modopt;
  if (D.29316 != 0B) goto <D.29312>; else goto <D.29313>;
  <D.29312>:
  D.29314 = fb->modreq;
  D.29316 = fb->modopt;
  custom = add_custom_modifiers (assembly, type, D.29314, D.29316);
  type = custom;
  <D.29313>:
  sig = fieldref_encode_signature (assembly, 0B, type);
  monoeg_g_free (custom);
  D.29308 = fb->typeb;
  parent = create_generic_typespec (assembly, D.29308);
  D.29317 = parent & 3;
  D.29318 = D.29317 != 2;
  D.29319 = (long int) D.29318;
  D.29320 = __builtin_expect (D.29319, 0);
  if (D.29320 != 0) goto <D.29321>; else goto <D.29322>;
  <D.29321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3220, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC");
  <D.29322>:
  pclass = 4;
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.29323 = assembly->save;
  if (D.29323 != 0) goto <D.29324>; else goto <D.29325>;
  <D.29324>:
  D.29326 = table->rows;
  D.29327 = D.29326 + 1;
  alloc_table (table, D.29327);
  D.29328 = table->values;
  D.29329 = table->next_idx;
  D.29330 = D.29329 * 3;
  D.29331 = (long unsigned int) D.29330;
  D.29332 = D.29331 * 4;
  values = D.29328 + D.29332;
  D.29333 = parent << 3;
  D.29334 = D.29333 | pclass;
  *values = D.29334;
  D.29335 = values + 4;
  D.29336 = &assembly->sheap;
  D.29337 = string_heap_insert (D.29336, name);
  *D.29335 = D.29337;
  D.29338 = values + 8;
  *D.29338 = sig;
  <D.29325>:
  D.29329 = table->next_idx;
  token = D.29329 | 167772160;
  D.29329 = table->next_idx;
  D.29339 = D.29329 + 1;
  table->next_idx = D.29339;
  D.29302 = assembly->handleref_managed;
  D.29340 = (long unsigned int) token;
  D.29341 = (void *) D.29340;
  mono_g_hash_table_insert (D.29302, fb, D.29341);
  monoeg_g_free (name);
  D.29307 = token;
  return D.29307;
}


add_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoType * type, struct MonoArray * modreq, struct MonoArray * modopt)
{
  long unsigned int D.29345;
  unsigned int D.29346;
  unsigned int count.151;
  unsigned int D.29348;
  long unsigned int D.29351;
  unsigned int D.29352;
  unsigned int D.29353;
  struct MonoType * D.29356;
  long unsigned int D.29357;
  long unsigned int D.29358;
  unsigned int D.29359;
  unsigned int D.29360;
  long unsigned int D.29361;
  unsigned char D.29362;
  <unnamed-unsigned:6> D.29363;
  long unsigned int D.29366;
  char * D.29367;
  void * D.29368;
  unsigned int D.29369;
  <unnamed-unsigned:31> D.29370;
  long unsigned int D.29371;
  char * D.29374;
  void * D.29375;
  unsigned int D.29376;
  <unnamed-unsigned:31> D.29377;
  long unsigned int D.29378;
  int i;
  int count;
  int len;
  int pos;
  struct MonoType * t;

  count = 0;
  if (modreq != 0B) goto <D.29343>; else goto <D.29344>;
  <D.29343>:
  D.29345 = mono_array_length (modreq);
  D.29346 = (unsigned int) D.29345;
  count.151 = (unsigned int) count;
  D.29348 = D.29346 + count.151;
  count = (int) D.29348;
  <D.29344>:
  if (modopt != 0B) goto <D.29349>; else goto <D.29350>;
  <D.29349>:
  D.29351 = mono_array_length (modopt);
  D.29352 = (unsigned int) D.29351;
  count.151 = (unsigned int) count;
  D.29353 = D.29352 + count.151;
  count = (int) D.29353;
  <D.29350>:
  if (count == 0) goto <D.29354>; else goto <D.29355>;
  <D.29354>:
  D.29356 = mono_metadata_type_dup (0B, type);
  return D.29356;
  <D.29355>:
  D.29357 = (long unsigned int) count;
  D.29358 = D.29357 + 3;
  D.29359 = (unsigned int) D.29358;
  D.29360 = D.29359 * 4;
  len = (int) D.29360;
  D.29361 = (long unsigned int) len;
  t = monoeg_malloc (D.29361);
  memcpy (t, type, 12);
  D.29362 = (unsigned char) count;
  D.29363 = (<unnamed-unsigned:6>) D.29362;
  t->num_mods = D.29363;
  pos = 0;
  if (modreq != 0B) goto <D.29364>; else goto <D.29365>;
  <D.29364>:
  i = 0;
  goto <D.20161>;
  <D.20160>:
  {
    struct MonoType * mod;

    D.29366 = (long unsigned int) i;
    D.29367 = mono_array_addr_with_size (modreq, 8, D.29366);
    D.29368 = MEM[(void * *)D.29367];
    mod = mono_reflection_type_get_handle (D.29368);
    t->modifiers[pos].required = 1;
    D.29369 = mono_image_typedef_or_ref (assembly, mod);
    D.29370 = (<unnamed-unsigned:31>) D.29369;
    t->modifiers[pos].token = D.29370;
    pos = pos + 1;
  }
  i = i + 1;
  <D.20161>:
  D.29366 = (long unsigned int) i;
  D.29371 = mono_array_length (modreq);
  if (D.29366 < D.29371) goto <D.20160>; else goto <D.20162>;
  <D.20162>:
  <D.29365>:
  if (modopt != 0B) goto <D.29372>; else goto <D.29373>;
  <D.29372>:
  i = 0;
  goto <D.20165>;
  <D.20164>:
  {
    struct MonoType * mod;

    D.29366 = (long unsigned int) i;
    D.29374 = mono_array_addr_with_size (modopt, 8, D.29366);
    D.29375 = MEM[(void * *)D.29374];
    mod = mono_reflection_type_get_handle (D.29375);
    t->modifiers[pos].required = 0;
    D.29376 = mono_image_typedef_or_ref (assembly, mod);
    D.29377 = (<unnamed-unsigned:31>) D.29376;
    t->modifiers[pos].token = D.29377;
    pos = pos + 1;
  }
  i = i + 1;
  <D.20165>:
  D.29366 = (long unsigned int) i;
  D.29378 = mono_array_length (modopt);
  if (D.29366 < D.29378) goto <D.20164>; else goto <D.20166>;
  <D.20166>:
  <D.29373>:
  D.29356 = t;
  return D.29356;
}


fieldref_encode_signature (struct MonoDynamicImage * assembly, struct MonoImage * field_image, struct MonoType * type)
{
  int D.29380;
  guint32 D.29383;
  long unsigned int D.29384;
  long unsigned int D.29385;
  <unnamed-unsigned:31> D.29390;
  unsigned int D.29391;
  _Bool D.29392;
  long int D.29393;
  long int D.29394;
  struct MonoType * D.29397;
  <unnamed-unsigned:1> D.29399;
  <unnamed-unsigned:6> D.29403;
  unsigned int D.29404;
  struct SigBuffer buf;
  guint32 idx;
  guint32 i;
  guint32 token;

  try
    {
      D.29380 = assembly->save;
      if (D.29380 == 0) goto <D.29381>; else goto <D.29382>;
      <D.29381>:
      D.29383 = 0;
      return D.29383;
      <D.29382>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.29384 = BIT_FIELD_REF <*type, 64, 64>;
      D.29385 = D.29384 & 1056964608;
      if (D.29385 != 0) goto <D.29386>; else goto <D.29387>;
      <D.29386>:
      i = 0;
      goto <D.19713>;
      <D.19712>:
      if (field_image != 0B) goto <D.29388>; else goto <D.29389>;
      <D.29388>:
      {
        struct MonoClass * class;

        D.29390 = type->modifiers[i].token;
        D.29391 = (unsigned int) D.29390;
        class = mono_class_get (field_image, D.29391);
        D.29392 = class == 0B;
        D.29393 = (long int) D.29392;
        D.29394 = __builtin_expect (D.29393, 0);
        if (D.29394 != 0) goto <D.29395>; else goto <D.29396>;
        <D.29395>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1706, "class");
        <D.29396>:
        D.29397 = &class->byval_arg;
        token = mono_image_typedef_or_ref (assembly, D.29397);
      }
      goto <D.29398>;
      <D.29389>:
      D.29390 = type->modifiers[i].token;
      token = (guint32) D.29390;
      <D.29398>:
      D.29399 = type->modifiers[i].required;
      if (D.29399 != 0) goto <D.29400>; else goto <D.29401>;
      <D.29400>:
      sigbuffer_add_byte (&buf, 31);
      goto <D.29402>;
      <D.29401>:
      sigbuffer_add_byte (&buf, 32);
      <D.29402>:
      sigbuffer_add_value (&buf, token);
      i = i + 1;
      <D.19713>:
      D.29403 = type->num_mods;
      D.29404 = (unsigned int) D.29403;
      if (D.29404 > i) goto <D.19712>; else goto <D.19714>;
      <D.19714>:
      <D.29387>:
      encode_type (assembly, type, &buf);
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29383 = idx;
      return D.29383;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodspec_token (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  struct GHashTable * D.29407;
  void * D.29408;
  long int D.29409;
  guint32 D.29412;
  long unsigned int D.29413;
  long unsigned int D.29414;
  _Bool D.29415;
  long int D.29416;
  long int D.29417;
  struct MonoMethod * D.29420;
  struct MonoMethodSignature * D.29421;
  short unsigned int D.29422;
  struct MonoMethodSignature * D.29426;
  struct MonoClass * D.29427;
  struct MonoType * D.29428;
  const char * D.29429;
  long unsigned int D.29430;
  void * D.29431;
  struct MonoMethodInflated * imethod;
  guint32 token;

  D.29407 = assembly->handleref;
  D.29408 = monoeg_g_hash_table_lookup (D.29407, method);
  D.29409 = (long int) D.29408;
  token = (guint32) D.29409;
  if (token != 0) goto <D.29410>; else goto <D.29411>;
  <D.29410>:
  D.29412 = token;
  return D.29412;
  <D.29411>:
  D.29413 = BIT_FIELD_REF <*method, 64, 256>;
  D.29414 = D.29413 & 4096;
  D.29415 = D.29414 == 0;
  D.29416 = (long int) D.29415;
  D.29417 = __builtin_expect (D.29416, 0);
  if (D.29417 != 0) goto <D.29418>; else goto <D.29419>;
  <D.29418>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3044, "method->is_inflated");
  <D.29419>:
  imethod = method;
  D.29420 = imethod->declaring;
  D.29421 = mono_method_signature (D.29420);
  D.29422 = D.29421->generic_param_count;
  if (D.29422 != 0) goto <D.29423>; else goto <D.29424>;
  <D.29423>:
  token = method_encode_methodspec (assembly, method);
  goto <D.29425>;
  <D.29424>:
  {
    guint32 sig;

    D.29420 = imethod->declaring;
    D.29426 = mono_method_signature (D.29420);
    sig = method_encode_signature (assembly, D.29426);
    D.29427 = method->klass;
    D.29428 = &D.29427->byval_arg;
    D.29429 = method->name;
    token = mono_image_get_memberref_token (assembly, D.29428, D.29429, sig);
  }
  <D.29425>:
  D.29407 = assembly->handleref;
  D.29430 = (long unsigned int) token;
  D.29431 = (void *) D.29430;
  monoeg_g_hash_table_insert_replace (D.29407, method, D.29431, 0);
  D.29412 = token;
  return D.29412;
}


method_encode_methodspec (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  long unsigned int D.29433;
  long unsigned int D.29434;
  _Bool D.29435;
  long int D.29436;
  long int D.29437;
  struct MonoMethodSignature * D.29440;
  struct MonoClass * D.29441;
  struct MonoType * D.29442;
  const char * D.29443;
  struct MonoMethodSignature * D.29444;
  short unsigned int D.29445;
  guint32 D.29448;
  unsigned int D.29449;
  unsigned int D.29450;
  unsigned int D.29451;
  struct MonoGenericContext * D.29452;
  int D.29453;
  unsigned int D.29456;
  unsigned int D.29457;
  guint32 * D.29458;
  unsigned int D.29459;
  unsigned int D.29460;
  long unsigned int D.29461;
  long unsigned int D.29462;
  guint32 * D.29463;
  unsigned int D.29464;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;
  guint32 sig;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * declaring;

  mtoken = 0;
  table = &assembly->tables[43];
  D.29433 = BIT_FIELD_REF <*method, 64, 256>;
  D.29434 = D.29433 & 4096;
  D.29435 = D.29434 == 0;
  D.29436 = (long int) D.29435;
  D.29437 = __builtin_expect (D.29436, 0);
  if (D.29437 != 0) goto <D.29438>; else goto <D.29439>;
  <D.29438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2998, "method->is_inflated");
  <D.29439>:
  imethod = method;
  declaring = imethod->declaring;
  D.29440 = mono_method_signature (declaring);
  sig = method_encode_signature (assembly, D.29440);
  D.29441 = method->klass;
  D.29442 = &D.29441->byval_arg;
  D.29443 = declaring->name;
  mtoken = mono_image_get_memberref_token (assembly, D.29442, D.29443, sig);
  D.29444 = mono_method_signature (declaring);
  D.29445 = D.29444->generic_param_count;
  if (D.29445 == 0) goto <D.29446>; else goto <D.29447>;
  <D.29446>:
  D.29448 = mtoken;
  return D.29448;
  <D.29447>:
  D.29449 = mtoken >> 24;
  switch (D.29449) <default: <D.20117>, case 6: <D.20116>, case 10: <D.20114>>
  <D.20114>:
  D.29450 = mtoken & 16777215;
  D.29451 = D.29450 << 1;
  mtoken = D.29451 | 1;
  goto <D.20115>;
  <D.20116>:
  D.29450 = mtoken & 16777215;
  mtoken = D.29450 << 1;
  goto <D.20115>;
  <D.20117>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3016);
  <D.20115>:
  D.29452 = mono_method_get_context (method);
  sig = encode_generic_method_sig (assembly, D.29452);
  D.29453 = assembly->save;
  if (D.29453 != 0) goto <D.29454>; else goto <D.29455>;
  <D.29454>:
  D.29456 = table->rows;
  D.29457 = D.29456 + 1;
  alloc_table (table, D.29457);
  D.29458 = table->values;
  D.29459 = table->next_idx;
  D.29460 = D.29459 * 2;
  D.29461 = (long unsigned int) D.29460;
  D.29462 = D.29461 * 4;
  values = D.29458 + D.29462;
  *values = mtoken;
  D.29463 = values + 4;
  *D.29463 = sig;
  <D.29455>:
  D.29459 = table->next_idx;
  token = D.29459 | 721420288;
  D.29459 = table->next_idx;
  D.29464 = D.29459 + 1;
  table->next_idx = D.29464;
  D.29448 = token;
  return D.29448;
}


encode_generic_method_sig (struct MonoDynamicImage * assembly, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.29466;
  <unnamed-unsigned:22> D.29467;
  int D.29468;
  guint32 D.29471;
  struct MonoType * D.29472;
  unsigned int i.152;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.29466 = context->method_inst;
      D.29467 = D.29466->type_argc;
      nparams = (guint32) D.29467;
      D.29468 = assembly->save;
      if (D.29468 == 0) goto <D.29469>; else goto <D.29470>;
      <D.29469>:
      D.29471 = 0;
      return D.29471;
      <D.29470>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.20101>;
      <D.20100>:
      D.29466 = context->method_inst;
      D.29472 = D.29466->type_argv[i];
      encode_type (assembly, D.29472, &buf);
      i = i + 1;
      <D.20101>:
      i.152 = (unsigned int) i;
      if (i.152 < nparams) goto <D.20100>; else goto <D.20102>;
      <D.20102>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29471 = idx;
      return D.29471;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


mono_image_get_inflated_method_token (struct MonoDynamicImage * assembly, struct MonoMethod * m)
{
  struct MonoMethod * D.29478;
  struct MonoMethodSignature * D.29479;
  struct MonoClass * D.29480;
  struct MonoType * D.29481;
  const char * D.29482;
  guint32 D.29483;
  struct MonoMethodInflated * imethod;
  guint32 sig;
  guint32 token;

  imethod = m;
  D.29478 = imethod->declaring;
  D.29479 = mono_method_signature (D.29478);
  sig = method_encode_signature (assembly, D.29479);
  D.29480 = m->klass;
  D.29481 = &D.29480->byval_arg;
  D.29482 = m->name;
  token = mono_image_get_memberref_token (assembly, D.29481, D.29482, sig);
  D.29483 = token;
  return D.29483;
}


mono_image_get_methodref_token (struct MonoDynamicImage * assembly, struct MonoMethod * method, gboolean create_typespec)
{
  int iftmp.153;
  long unsigned int D.29489;
  long unsigned int D.29490;
  struct MonoClass * D.29492;
  struct MonoImage * D.29493;
  struct MonoImage * D.29494;
  struct GHashTable * D.29498;
  long int method.154;
  unsigned int D.29500;
  unsigned int D.29501;
  long unsigned int D.29502;
  const void * D.29503;
  void * D.29504;
  long int D.29505;
  guint32 D.29508;
  void * D.29509;
  long int D.29510;
  long unsigned int D.29515;
  _Bool D.29516;
  long int D.29517;
  long int D.29518;
  struct MonoMethodSignature * D.29523;
  long unsigned int D.29524;
  long unsigned int D.29525;
  struct MonoType * D.29530;
  const char * D.29531;
  unsigned int D.29532;
  long unsigned int D.29533;
  void * D.29534;
  unsigned int D.29537;
  _Bool D.29538;
  long int D.29539;
  long int D.29540;
  unsigned int D.29543;
  unsigned int D.29544;
  int D.29545;
  unsigned int D.29548;
  unsigned int D.29549;
  guint32 * D.29550;
  unsigned int D.29551;
  unsigned int D.29552;
  long unsigned int D.29553;
  long unsigned int D.29554;
  guint32 * D.29555;
  struct MonoGenericContainer * D.29556;
  struct MonoGenericContext * D.29557;
  unsigned int D.29558;
  unsigned int D.29559;
  void * D.29560;
  guint32 token;
  struct MonoMethodSignature * sig;

  if (create_typespec != 0) goto <D.29488>; else goto <D.29486>;
  <D.29488>:
  D.29489 = BIT_FIELD_REF <*method, 64, 256>;
  D.29490 = D.29489 & 2048;
  if (D.29490 != 0) goto <D.29491>; else goto <D.29486>;
  <D.29491>:
  D.29492 = method->klass;
  D.29493 = D.29492->image;
  D.29494 = &assembly->image;
  if (D.29493 != D.29494) goto <D.29495>; else goto <D.29486>;
  <D.29495>:
  iftmp.153 = 1;
  goto <D.29487>;
  <D.29486>:
  iftmp.153 = 0;
  <D.29487>:
  create_typespec = iftmp.153;
  if (create_typespec != 0) goto <D.29496>; else goto <D.29497>;
  <D.29496>:
  D.29498 = assembly->handleref;
  method.154 = (long int) method;
  D.29500 = (unsigned int) method.154;
  D.29501 = D.29500 + 1;
  D.29502 = (long unsigned int) D.29501;
  D.29503 = (const void *) D.29502;
  D.29504 = monoeg_g_hash_table_lookup (D.29498, D.29503);
  D.29505 = (long int) D.29504;
  token = (guint32) D.29505;
  if (token != 0) goto <D.29506>; else goto <D.29507>;
  <D.29506>:
  D.29508 = token;
  return D.29508;
  <D.29507>:
  <D.29497>:
  D.29498 = assembly->handleref;
  D.29509 = monoeg_g_hash_table_lookup (D.29498, method);
  D.29510 = (long int) D.29509;
  token = (guint32) D.29510;
  if (token != 0) goto <D.29511>; else goto <D.29512>;
  <D.29511>:
  if (create_typespec == 0) goto <D.29513>; else goto <D.29514>;
  <D.29513>:
  D.29508 = token;
  return D.29508;
  <D.29514>:
  <D.29512>:
  D.29489 = BIT_FIELD_REF <*method, 64, 256>;
  D.29515 = D.29489 & 4096;
  D.29516 = D.29515 != 0;
  D.29517 = (long int) D.29516;
  D.29518 = __builtin_expect (D.29517, 0);
  if (D.29518 != 0) goto <D.29519>; else goto <D.29520>;
  <D.29519>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2492, "!method->is_inflated");
  <D.29520>:
  if (token == 0) goto <D.29521>; else goto <D.29522>;
  <D.29521>:
  D.29523 = mono_method_signature (method);
  sig = mono_metadata_signature_dup (D.29523);
  D.29524 = BIT_FIELD_REF <*sig, 64, 64>;
  D.29525 = D.29524 & 17732923532771328;
  if (D.29525 != 0) goto <D.29526>; else goto <D.29527>;
  <D.29526>:
  D.29524 = BIT_FIELD_REF <*sig, 64, 64>;
  D.29525 = D.29524 & 17732923532771328;
  if (D.29525 != 1407374883553280) goto <D.29528>; else goto <D.29529>;
  <D.29528>:
  sig->call_convention = 0;
  <D.29529>:
  <D.29527>:
  D.29492 = method->klass;
  D.29530 = &D.29492->byval_arg;
  D.29531 = method->name;
  D.29532 = method_encode_signature (assembly, sig);
  token = mono_image_get_memberref_token (assembly, D.29530, D.29531, D.29532);
  monoeg_g_free (sig);
  D.29498 = assembly->handleref;
  D.29533 = (long unsigned int) token;
  D.29534 = (void *) D.29533;
  monoeg_g_hash_table_insert_replace (D.29498, method, D.29534, 0);
  <D.29522>:
  if (create_typespec != 0) goto <D.29535>; else goto <D.29536>;
  <D.29535>:
  {
    struct MonoDynamicTable * table;

    table = &assembly->tables[43];
    D.29537 = token >> 24;
    D.29538 = D.29537 != 10;
    D.29539 = (long int) D.29538;
    D.29540 = __builtin_expect (D.29539, 0);
    if (D.29540 != 0) goto <D.29541>; else goto <D.29542>;
    <D.29541>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2508, "mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF");
    <D.29542>:
    D.29543 = token & 16777215;
    D.29544 = D.29543 << 1;
    token = D.29544 | 1;
    D.29545 = assembly->save;
    if (D.29545 != 0) goto <D.29546>; else goto <D.29547>;
    <D.29546>:
    {
      guint32 * values;

      D.29548 = table->rows;
      D.29549 = D.29548 + 1;
      alloc_table (table, D.29549);
      D.29550 = table->values;
      D.29551 = table->next_idx;
      D.29552 = D.29551 * 2;
      D.29553 = (long unsigned int) D.29552;
      D.29554 = D.29553 * 4;
      values = D.29550 + D.29554;
      *values = token;
      D.29555 = values + 4;
      D.29556 = mono_method_get_generic_container (method);
      D.29557 = &D.29556->context;
      D.29558 = encode_generic_method_sig (assembly, D.29557);
      *D.29555 = D.29558;
    }
    <D.29547>:
    D.29551 = table->next_idx;
    token = D.29551 | 721420288;
    D.29551 = table->next_idx;
    D.29559 = D.29551 + 1;
    table->next_idx = D.29559;
    D.29498 = assembly->handleref;
    method.154 = (long int) method;
    D.29500 = (unsigned int) method.154;
    D.29501 = D.29500 + 1;
    D.29502 = (long unsigned int) D.29501;
    D.29560 = (void *) D.29502;
    D.29533 = (long unsigned int) token;
    D.29534 = (void *) D.29533;
    monoeg_g_hash_table_insert_replace (D.29498, D.29560, D.29534, 0);
    D.29508 = token;
    return D.29508;
  }
  <D.29536>:
  D.29508 = token;
  return D.29508;
}


mono_image_get_fieldref_token (struct MonoDynamicImage * assembly, struct MonoObject * f, struct MonoClassField * field)
{
  _Bool D.29562;
  long int D.29563;
  long int D.29564;
  struct MonoClass * D.29567;
  _Bool D.29568;
  long int D.29569;
  long int D.29570;
  struct MonoGHashTable * D.29573;
  void * D.29574;
  long int D.29575;
  guint32 D.29578;
  struct MonoGenericClass * D.29581;
  struct MonoClass * D.29583;
  struct MonoClassField * D.29585;
  long int field.155;
  struct MonoClassField * D.29588;
  long int D.29589;
  long int D.29590;
  long int D.29591;
  long unsigned int D.29592;
  long unsigned int D.29593;
  struct MonoClassField * D.29594;
  int D.29595;
  struct MonoType * D.29599;
  const char * D.29600;
  struct MonoImage * D.29601;
  unsigned int D.29602;
  long unsigned int D.29603;
  void * D.29604;
  struct MonoType * type;
  guint32 token;

  D.29562 = field == 0B;
  D.29563 = (long int) D.29562;
  D.29564 = __builtin_expect (D.29563, 0);
  if (D.29564 != 0) goto <D.29565>; else goto <D.29566>;
  <D.29565>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2745, "field");
  <D.29566>:
  D.29567 = field->parent;
  D.29568 = D.29567 == 0B;
  D.29569 = (long int) D.29568;
  D.29570 = __builtin_expect (D.29569, 0);
  if (D.29570 != 0) goto <D.29571>; else goto <D.29572>;
  <D.29571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2746, "field->parent");
  <D.29572>:
  D.29573 = assembly->handleref_managed;
  D.29574 = mono_g_hash_table_lookup (D.29573, f);
  D.29575 = (long int) D.29574;
  token = (guint32) D.29575;
  if (token != 0) goto <D.29576>; else goto <D.29577>;
  <D.29576>:
  D.29578 = token;
  return D.29578;
  <D.29577>:
  D.29567 = field->parent;
  D.29581 = D.29567->generic_class;
  if (D.29581 != 0B) goto <D.29582>; else goto <D.29579>;
  <D.29582>:
  D.29567 = field->parent;
  D.29581 = D.29567->generic_class;
  D.29583 = D.29581->container_class;
  if (D.29583 != 0B) goto <D.29584>; else goto <D.29579>;
  <D.29584>:
  D.29567 = field->parent;
  D.29581 = D.29567->generic_class;
  D.29583 = D.29581->container_class;
  D.29585 = D.29583->fields;
  if (D.29585 != 0B) goto <D.29586>; else goto <D.29579>;
  <D.29586>:
  {
    int index;

    field.155 = (long int) field;
    D.29567 = field->parent;
    D.29588 = D.29567->fields;
    D.29589 = (long int) D.29588;
    D.29590 = field.155 - D.29589;
    D.29591 = D.29590 /[ex] 32;
    index = (int) D.29591;
    D.29567 = field->parent;
    D.29581 = D.29567->generic_class;
    D.29583 = D.29581->container_class;
    D.29585 = D.29583->fields;
    D.29592 = (long unsigned int) index;
    D.29593 = D.29592 * 32;
    D.29594 = D.29585 + D.29593;
    type = mono_field_get_type (D.29594);
  }
  goto <D.29580>;
  <D.29579>:
  D.29595 = is_field_on_inst (field);
  if (D.29595 != 0) goto <D.29596>; else goto <D.29597>;
  <D.29596>:
  type = get_field_on_inst_generic_type (field);
  goto <D.29598>;
  <D.29597>:
  type = mono_field_get_type (field);
  <D.29598>:
  <D.29580>:
  D.29567 = field->parent;
  D.29599 = &D.29567->byval_arg;
  D.29600 = mono_field_get_name (field);
  D.29567 = field->parent;
  D.29601 = D.29567->image;
  D.29602 = fieldref_encode_signature (assembly, D.29601, type);
  token = mono_image_get_memberref_token (assembly, D.29599, D.29600, D.29602);
  D.29573 = assembly->handleref_managed;
  D.29603 = (long unsigned int) token;
  D.29604 = (void *) D.29603;
  mono_g_hash_table_insert (D.29573, f, D.29604);
  D.29578 = token;
  return D.29578;
}


get_field_on_inst_generic_type (struct MonoClassField * field)
{
  int D.29606;
  _Bool D.29607;
  long int D.29608;
  long int D.29609;
  struct MonoClass * D.29612;
  struct MonoClassField * D.29613;
  long int field.156;
  long int D.29617;
  long int D.29618;
  long int D.29619;
  int D.29620;
  long int D.29621;
  struct MonoType * D.29624;
  struct MonoType * * D.29625;
  long unsigned int D.29626;
  long unsigned int D.29627;
  struct MonoType * * D.29628;
  struct MonoGenericClass * D.29629;
  struct MonoClassField * D.29630;
  long int D.29633;
  long int D.29634;
  long int D.29635;
  unsigned int D.29636;
  long int D.29637;
  struct MonoClassField * D.29640;
  long unsigned int D.29641;
  struct MonoClassField * D.29642;
  struct MonoClass * class;
  struct MonoClass * gtd;
  struct MonoDynamicGenericClass * dgclass;
  int field_index;

  D.29606 = is_field_on_inst (field);
  D.29607 = D.29606 == 0;
  D.29608 = (long int) D.29607;
  D.29609 = __builtin_expect (D.29608, 0);
  if (D.29609 != 0) goto <D.29610>; else goto <D.29611>;
  <D.29610>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2717, "is_field_on_inst (field)");
  <D.29611>:
  D.29612 = field->parent;
  dgclass = D.29612->generic_class;
  D.29613 = dgclass->fields;
  if (D.29613 <= field) goto <D.29614>; else goto <D.29615>;
  <D.29614>:
  field.156 = (long int) field;
  D.29613 = dgclass->fields;
  D.29617 = (long int) D.29613;
  D.29618 = field.156 - D.29617;
  D.29619 = D.29618 /[ex] 32;
  D.29620 = dgclass->count_fields;
  D.29621 = (long int) D.29620;
  if (D.29619 < D.29621) goto <D.29622>; else goto <D.29623>;
  <D.29622>:
  field.156 = (long int) field;
  D.29613 = dgclass->fields;
  D.29617 = (long int) D.29613;
  D.29618 = field.156 - D.29617;
  D.29619 = D.29618 /[ex] 32;
  field_index = (int) D.29619;
  D.29625 = dgclass->field_generic_types;
  D.29626 = (long unsigned int) field_index;
  D.29627 = D.29626 * 8;
  D.29628 = D.29625 + D.29627;
  D.29624 = *D.29628;
  return D.29624;
  <D.29623>:
  <D.29615>:
  class = field->parent;
  D.29629 = class->generic_class;
  gtd = D.29629->container_class;
  D.29630 = class->fields;
  if (D.29630 <= field) goto <D.29631>; else goto <D.29632>;
  <D.29631>:
  field.156 = (long int) field;
  D.29630 = class->fields;
  D.29633 = (long int) D.29630;
  D.29634 = field.156 - D.29633;
  D.29635 = D.29634 /[ex] 32;
  D.29636 = class->field.count;
  D.29637 = (long int) D.29636;
  if (D.29635 < D.29637) goto <D.29638>; else goto <D.29639>;
  <D.29638>:
  field.156 = (long int) field;
  D.29630 = class->fields;
  D.29633 = (long int) D.29630;
  D.29634 = field.156 - D.29633;
  D.29635 = D.29634 /[ex] 32;
  field_index = (int) D.29635;
  D.29640 = gtd->fields;
  D.29626 = (long unsigned int) field_index;
  D.29641 = D.29626 * 32;
  D.29642 = D.29640 + D.29641;
  D.29624 = D.29642->type;
  return D.29624;
  <D.29639>:
  <D.29632>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2734);
  D.29624 = 0B;
  return D.29624;
}


mono_image_get_array_token (struct MonoDynamicImage * assembly, struct MonoReflectionArrayMethod * m)
{
  struct MonoString * D.29644;
  struct MonoArray * D.29645;
  long unsigned int D.29646;
  long unsigned int D.29647;
  long unsigned int D.29648;
  long unsigned int D.29649;
  unsigned int D.29650;
  int D.29651;
  int D.29652;
  unsigned char D.29653;
  <unnamed-unsigned:6> D.29654;
  short unsigned int D.29655;
  struct MonoType * iftmp.157;
  struct MonoReflectionType * D.29657;
  struct MonoClass * D.29661;
  struct MonoReflectionType * D.29662;
  long unsigned int D.29663;
  char * D.29664;
  void * D.29665;
  struct MonoType * D.29666;
  int D.20242;
  char * D.29667;
  struct MonoType * D.29670;
  int D.29671;
  struct MonoMethodSignature * D.29674;
  int D.29675;
  unsigned int D.29678;
  unsigned int D.29679;
  guint32 D.29680;
  unsigned int D.29681;
  unsigned int D.29682;
  struct GList * D.29683;
  struct GList * D.29684;
  guint32 nparams;
  guint32 i;
  struct GList * tmp;
  char * name;
  struct MonoMethodSignature * sig;
  struct ArrayMethod * am;
  struct MonoType * mtype;

  D.29644 = m->name;
  name = mono_string_to_utf8 (D.29644);
  D.29645 = m->parameters;
  D.29646 = mono_array_length (D.29645);
  nparams = (guint32) D.29646;
  D.29647 = (long unsigned int) nparams;
  D.29648 = D.29647 + 2;
  D.29649 = D.29648 * 8;
  sig = monoeg_malloc0 (D.29649);
  sig->hasthis = 1;
  sig->sentinelpos = -1;
  D.29650 = m->call_conv;
  D.29651 = (int) D.29650;
  D.29652 = reflection_cc_to_file (D.29651);
  D.29653 = (unsigned char) D.29652;
  D.29654 = (<unnamed-unsigned:6>) D.29653;
  sig->call_convention = D.29654;
  D.29655 = (short unsigned int) nparams;
  sig->param_count = D.29655;
  D.29657 = m->ret;
  if (D.29657 != 0B) goto <D.29658>; else goto <D.29659>;
  <D.29658>:
  D.29657 = m->ret;
  iftmp.157 = mono_reflection_type_get_handle (D.29657);
  goto <D.29660>;
  <D.29659>:
  D.29661 = mono_defaults.void_class;
  iftmp.157 = &D.29661->byval_arg;
  <D.29660>:
  sig->ret = iftmp.157;
  D.29662 = m->parent;
  mtype = mono_reflection_type_get_handle (D.29662);
  i = 0;
  goto <D.20232>;
  <D.20231>:
  D.29645 = m->parameters;
  D.29663 = (long unsigned int) i;
  D.29664 = mono_array_addr_with_size (D.29645, 8, D.29663);
  D.29665 = MEM[(void * *)D.29664];
  D.29666 = mono_reflection_type_get_handle (D.29665);
  sig->params[i] = D.29666;
  i = i + 1;
  <D.20232>:
  if (i < nparams) goto <D.20231>; else goto <D.20233>;
  <D.20233>:
  tmp = assembly->array_methods;
  goto <D.20244>;
  <D.20243>:
  am = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.29667 = am->name;
    D.20242 = __builtin_strcmp (name, D.29667);
  }
  if (D.20242 == 0) goto <D.29668>; else goto <D.29669>;
  <D.29668>:
  D.29670 = am->parent;
  D.29671 = mono_metadata_type_equal (D.29670, mtype);
  if (D.29671 != 0) goto <D.29672>; else goto <D.29673>;
  <D.29672>:
  D.29674 = am->sig;
  D.29675 = mono_metadata_signature_equal (D.29674, sig);
  if (D.29675 != 0) goto <D.29676>; else goto <D.29677>;
  <D.29676>:
  monoeg_g_free (name);
  monoeg_g_free (sig);
  D.29678 = am->token;
  D.29679 = D.29678 & 16777215;
  m->table_idx = D.29679;
  D.29680 = am->token;
  return D.29680;
  <D.29677>:
  <D.29673>:
  <D.29669>:
  tmp = tmp->next;
  <D.20244>:
  if (tmp != 0B) goto <D.20243>; else goto <D.20245>;
  <D.20245>:
  am = monoeg_malloc0 (32);
  am->name = name;
  am->sig = sig;
  am->parent = mtype;
  D.29670 = am->parent;
  D.29681 = method_encode_signature (assembly, sig);
  D.29682 = mono_image_get_memberref_token (assembly, D.29670, name, D.29681);
  am->token = D.29682;
  D.29683 = assembly->array_methods;
  D.29684 = monoeg_g_list_prepend (D.29683, am);
  assembly->array_methods = D.29684;
  D.29678 = am->token;
  D.29679 = D.29678 & 16777215;
  m->table_idx = D.29679;
  D.29680 = am->token;
  return D.29680;
}


reflection_cc_to_file (int call_conv)
{
  int D.29686;
  int D.29687;

  D.29686 = call_conv & 3;
  switch (D.29686) <default: <D.20213>, case 0: <D.20210>, case 1: <D.20211>, case 2: <D.20212>>
  <D.20210>:
  <D.20211>:
  D.29687 = 0;
  return D.29687;
  <D.20212>:
  D.29687 = 5;
  return D.29687;
  <D.20213>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3331);
  D.29687 = 0;
  return D.29687;
}


mono_image_get_sighelper_token (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  unsigned int D.29689;
  unsigned int idx.158;
  unsigned int D.29691;
  unsigned int D.29692;
  unsigned int D.29693;
  guint32 * D.29694;
  long unsigned int D.29695;
  long unsigned int D.29696;
  unsigned int D.29697;
  guint32 D.29698;
  guint32 idx;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[17];
  D.29689 = table->next_idx;
  idx.158 = D.29689;
  D.29691 = idx.158 + 1;
  table->next_idx = D.29691;
  idx = idx.158;
  D.29692 = table->rows;
  D.29693 = D.29692 + 1;
  table->rows = D.29693;
  D.29692 = table->rows;
  alloc_table (table, D.29692);
  D.29694 = table->values;
  D.29695 = (long unsigned int) idx;
  D.29696 = D.29695 * 4;
  values = D.29694 + D.29696;
  D.29697 = mono_reflection_encode_sighelper (assembly, helper);
  *values = D.29697;
  D.29698 = idx;
  return D.29698;
}


mono_reflection_encode_sighelper (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  int D.29700;
  guint32 D.29703;
  unsigned int D.29704;
  _Bool D.29705;
  long int D.29706;
  long int D.29707;
  struct MonoArray * D.29710;
  long unsigned int D.29713;
  unsigned int D.29715;
  unsigned int D.29716;
  unsigned int D.29717;
  unsigned int D.29720;
  unsigned int D.29723;
  unsigned int D.29726;
  unsigned int D.29728;
  unsigned char D.29731;
  struct MonoReflectionType * D.29732;
  struct MonoArray * D.29733;
  long unsigned int D.29736;
  long unsigned int D.29737;
  char * D.29740;
  struct MonoArray * D.29741;
  long unsigned int D.29744;
  char * D.29747;
  char * D.29748;
  struct SigBuffer buf;
  guint32 nargs;
  guint32 size;
  guint32 i;
  guint32 idx;

  try
    {
      D.29700 = assembly->save;
      if (D.29700 == 0) goto <D.29701>; else goto <D.29702>;
      <D.29701>:
      D.29703 = 0;
      return D.29703;
      <D.29702>:
      D.29704 = helper->type;
      D.29705 = D.29704 != 2;
      D.29706 = (long int) D.29705;
      D.29707 = __builtin_expect (D.29706, 0);
      if (D.29707 != 0) goto <D.29708>; else goto <D.29709>;
      <D.29708>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3254, "helper->type == 2");
      <D.29709>:
      D.29710 = helper->arguments;
      if (D.29710 != 0B) goto <D.29711>; else goto <D.29712>;
      <D.29711>:
      D.29710 = helper->arguments;
      D.29713 = mono_array_length (D.29710);
      nargs = (guint32) D.29713;
      goto <D.29714>;
      <D.29712>:
      nargs = 0;
      <D.29714>:
      D.29715 = nargs + 1;
      size = D.29715 * 10;
      sigbuffer_init (&buf, 32);
      D.29716 = helper->call_conv;
      D.29717 = D.29716 & 3;
      if (D.29717 == 3) goto <D.29718>; else goto <D.29719>;
      <D.29718>:
      helper->call_conv = 1;
      <D.29719>:
      D.29716 = helper->call_conv;
      D.29720 = D.29716 & 64;
      if (D.29720 != 0) goto <D.29721>; else goto <D.29722>;
      <D.29721>:
      D.29716 = helper->call_conv;
      D.29723 = D.29716 & 32;
      helper->call_conv = D.29723;
      <D.29722>:
      D.29716 = helper->call_conv;
      if (D.29716 == 0) goto <D.29724>; else goto <D.29725>;
      <D.29724>:
      D.29726 = helper->unmanaged_call_conv;
      idx = D.29726 + 4294967295;
      goto <D.29727>;
      <D.29725>:
      D.29716 = helper->call_conv;
      idx = D.29716 & 96;
      D.29716 = helper->call_conv;
      D.29728 = D.29716 & 2;
      if (D.29728 != 0) goto <D.29729>; else goto <D.29730>;
      <D.29729>:
      idx = idx + 5;
      <D.29730>:
      <D.29727>:
      D.29731 = (unsigned char) idx;
      sigbuffer_add_byte (&buf, D.29731);
      sigbuffer_add_value (&buf, nargs);
      D.29732 = helper->return_type;
      encode_reflection_type (assembly, D.29732, &buf);
      i = 0;
      goto <D.20198>;
      <D.20197>:
      {
        struct MonoArray * modreqs;
        struct MonoArray * modopts;
        struct MonoReflectionType * pt;

        modreqs = 0B;
        modopts = 0B;
        D.29733 = helper->modreqs;
        if (D.29733 != 0B) goto <D.29734>; else goto <D.29735>;
        <D.29734>:
        D.29736 = (long unsigned int) i;
        D.29733 = helper->modreqs;
        D.29737 = mono_array_length (D.29733);
        if (D.29736 < D.29737) goto <D.29738>; else goto <D.29739>;
        <D.29738>:
        D.29733 = helper->modreqs;
        D.29736 = (long unsigned int) i;
        D.29740 = mono_array_addr_with_size (D.29733, 8, D.29736);
        modreqs = MEM[(struct MonoArray * *)D.29740];
        <D.29739>:
        <D.29735>:
        D.29741 = helper->modopts;
        if (D.29741 != 0B) goto <D.29742>; else goto <D.29743>;
        <D.29742>:
        D.29736 = (long unsigned int) i;
        D.29741 = helper->modopts;
        D.29744 = mono_array_length (D.29741);
        if (D.29736 < D.29744) goto <D.29745>; else goto <D.29746>;
        <D.29745>:
        D.29741 = helper->modopts;
        D.29736 = (long unsigned int) i;
        D.29747 = mono_array_addr_with_size (D.29741, 8, D.29736);
        modopts = MEM[(struct MonoArray * *)D.29747];
        <D.29746>:
        <D.29743>:
        encode_custom_modifiers (assembly, modreqs, modopts, &buf);
        D.29710 = helper->arguments;
        D.29736 = (long unsigned int) i;
        D.29748 = mono_array_addr_with_size (D.29710, 8, D.29736);
        pt = MEM[(struct MonoReflectionType * *)D.29748];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.20198>:
      if (i < nargs) goto <D.20197>; else goto <D.20199>;
      <D.20199>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29703 = idx;
      return D.29703;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_field_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldOnTypeBuilderInst * f)
{
  struct MonoGHashTable * D.29751;
  void * D.29752;
  long int D.29753;
  guint32 D.29756;
  struct MonoObject * D.29757;
  struct MonoVTable * D.29758;
  struct MonoClass * D.29759;
  int D.29760;
  struct MonoReflectionGenericClass * D.29763;
  long unsigned int D.29764;
  long unsigned int D.29765;
  _Bool D.29766;
  long int D.29767;
  long int D.29768;
  struct MonoString * D.29771;
  struct MonoType * D.29772;
  unsigned int D.29773;
  int D.29775;
  struct MonoClass * D.29778;
  struct MonoImage * D.29779;
  struct MonoType * D.29780;
  const char * D.29781;
  long unsigned int D.29783;
  void * D.29784;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoDynamicGenericClass * dgclass;
  struct MonoType * type;
  char * name;

  D.29751 = assembly->handleref_managed;
  D.29752 = mono_g_hash_table_lookup (D.29751, f);
  D.29753 = (long int) D.29752;
  token = (guint32) D.29753;
  if (token != 0) goto <D.29754>; else goto <D.29755>;
  <D.29754>:
  D.29756 = token;
  return D.29756;
  <D.29755>:
  D.29757 = f->fb;
  D.29758 = D.29757->vtable;
  D.29759 = D.29758->klass;
  D.29760 = is_sre_field_builder (D.29759);
  if (D.29760 != 0) goto <D.29761>; else goto <D.29762>;
  <D.29761>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = f->fb;
    D.29763 = f->inst;
    type = mono_reflection_type_get_handle (D.29763);
    klass = mono_class_from_mono_type (type);
    gclass = type->data.generic_class;
    D.29764 = BIT_FIELD_REF <*gclass, 64, 192>;
    D.29765 = D.29764 & 1;
    D.29766 = D.29765 == 0;
    D.29767 = (long int) D.29766;
    D.29768 = __builtin_expect (D.29767, 0);
    if (D.29768 != 0) goto <D.29769>; else goto <D.29770>;
    <D.29769>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2786, "gclass->is_dynamic");
    <D.29770>:
    dgclass = gclass;
    D.29771 = fb->name;
    name = mono_string_to_utf8 (D.29771);
    D.29772 = &klass->byval_arg;
    D.29773 = field_encode_signature (assembly, fb);
    token = mono_image_get_memberref_token (assembly, D.29772, name, D.29773);
    monoeg_g_free (name);
  }
  goto <D.29774>;
  <D.29762>:
  D.29757 = f->fb;
  D.29758 = D.29757->vtable;
  D.29759 = D.29758->klass;
  D.29775 = is_sr_mono_field (D.29759);
  if (D.29775 != 0) goto <D.29776>; else goto <D.29777>;
  <D.29776>:
  {
    guint32 sig;
    struct MonoClassField * field;

    D.29757 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.29757].field;
    D.29763 = f->inst;
    type = mono_reflection_type_get_handle (D.29763);
    klass = mono_class_from_mono_type (type);
    D.29778 = field->parent;
    D.29779 = D.29778->image;
    D.29780 = field->type;
    sig = fieldref_encode_signature (assembly, D.29779, D.29780);
    D.29772 = &klass->byval_arg;
    D.29781 = field->name;
    token = mono_image_get_memberref_token (assembly, D.29772, D.29781, sig);
  }
  goto <D.29782>;
  <D.29777>:
  {
    char * name;

    D.29757 = f->fb;
    D.29758 = D.29757->vtable;
    D.29759 = D.29758->klass;
    name = mono_type_get_full_name (D.29759);
    monoeg_g_log (0B, 4, "mono_image_get_field_on_inst_token: don\'t know how to handle %s", name);
    <D.20042>:
    goto <D.20042>;
  }
  <D.29782>:
  <D.29774>:
  D.29751 = assembly->handleref_managed;
  D.29783 = (long unsigned int) token;
  D.29784 = (void *) D.29783;
  mono_g_hash_table_insert (D.29751, f, D.29784);
  D.29756 = token;
  return D.29756;
}


is_sre_field_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.159;
  gboolean D.29789;
  _Bool D.29790;
  int D.29791;
  int D.23184;
  int iftmp.160;
  int D.23180;
  const char[13] * D.29797;
  unsigned char D.29798;
  int D.29799;
  unsigned char D.29800;
  int D.29801;
  const unsigned char * D.29806;
  unsigned char D.29807;
  int D.29808;
  const unsigned char * D.29809;
  unsigned char D.29810;
  int D.29811;
  const unsigned char * D.29816;
  unsigned char D.29817;
  int D.29818;
  const unsigned char * D.29819;
  unsigned char D.29820;
  int D.29821;
  const unsigned char * D.29826;
  unsigned char D.29827;
  int D.29828;
  const unsigned char * D.29829;
  unsigned char D.29830;
  int D.29831;
  const char * D.29833;
  int D.23193;
  int iftmp.161;
  int D.23189;
  const char[23] * D.29839;
  unsigned char D.29840;
  int D.29841;
  unsigned char D.29842;
  int D.29843;
  const unsigned char * D.29848;
  unsigned char D.29849;
  int D.29850;
  const unsigned char * D.29851;
  unsigned char D.29852;
  int D.29853;
  const unsigned char * D.29858;
  unsigned char D.29859;
  int D.29860;
  const unsigned char * D.29861;
  unsigned char D.29862;
  int D.29863;
  const unsigned char * D.29868;
  unsigned char D.29869;
  int D.29870;
  const unsigned char * D.29871;
  unsigned char D.29872;
  int D.29873;
  const char * D.29875;

  {
    static struct MonoClass * cached_class;

    cached_class.159 = cached_class;
    if (cached_class.159 != 0B) goto <D.29787>; else goto <D.29788>;
    <D.29787>:
    cached_class.159 = cached_class;
    D.29790 = cached_class.159 == class;
    D.29789 = (gboolean) D.29790;
    return D.29789;
    <D.29788>:
    D.29791 = is_corlib_type (class);
    if (D.29791 != 0) goto <D.29792>; else goto <D.29793>;
    <D.29792>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29797 = "FieldBuilder";
        D.29798 = MEM[(const unsigned char *)D.29797];
        D.29799 = (int) D.29798;
        D.29800 = *__s2;
        D.29801 = (int) D.29800;
        __result = D.29799 - D.29801;
        {
          if (__s1_len != 0) goto <D.29802>; else goto <D.29803>;
          <D.29802>:
          if (__result == 0) goto <D.29804>; else goto <D.29805>;
          <D.29804>:
          D.29806 = &MEM[(void *)"FieldBuilder" + 1B];
          D.29807 = *D.29806;
          D.29808 = (int) D.29807;
          D.29809 = __s2 + 1;
          D.29810 = *D.29809;
          D.29811 = (int) D.29810;
          __result = D.29808 - D.29811;
          if (__s1_len > 1) goto <D.29812>; else goto <D.29813>;
          <D.29812>:
          if (__result == 0) goto <D.29814>; else goto <D.29815>;
          <D.29814>:
          D.29816 = &MEM[(void *)"FieldBuilder" + 2B];
          D.29817 = *D.29816;
          D.29818 = (int) D.29817;
          D.29819 = __s2 + 2;
          D.29820 = *D.29819;
          D.29821 = (int) D.29820;
          __result = D.29818 - D.29821;
          if (__s1_len > 2) goto <D.29822>; else goto <D.29823>;
          <D.29822>:
          if (__result == 0) goto <D.29824>; else goto <D.29825>;
          <D.29824>:
          D.29826 = &MEM[(void *)"FieldBuilder" + 3B];
          D.29827 = *D.29826;
          D.29828 = (int) D.29827;
          D.29829 = __s2 + 3;
          D.29830 = *D.29829;
          D.29831 = (int) D.29830;
          __result = D.29828 - D.29831;
          <D.29825>:
          <D.29823>:
          <D.29815>:
          <D.29813>:
          <D.29805>:
          <D.29803>:
        }
        D.23180 = __result;
      }
      iftmp.160 = D.23180;
      goto <D.29832>;
      <D.29796>:
      D.29833 = class->name;
      iftmp.160 = __builtin_strcmp ("FieldBuilder", D.29833);
      <D.29832>:
      D.23184 = iftmp.160;
    }
    if (D.23184 == 0) goto <D.29834>; else goto <D.29835>;
    <D.29834>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29839 = "System.Reflection.Emit";
        D.29840 = MEM[(const unsigned char *)D.29839];
        D.29841 = (int) D.29840;
        D.29842 = *__s2;
        D.29843 = (int) D.29842;
        __result = D.29841 - D.29843;
        {
          if (__s1_len != 0) goto <D.29844>; else goto <D.29845>;
          <D.29844>:
          if (__result == 0) goto <D.29846>; else goto <D.29847>;
          <D.29846>:
          D.29848 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.29849 = *D.29848;
          D.29850 = (int) D.29849;
          D.29851 = __s2 + 1;
          D.29852 = *D.29851;
          D.29853 = (int) D.29852;
          __result = D.29850 - D.29853;
          if (__s1_len > 1) goto <D.29854>; else goto <D.29855>;
          <D.29854>:
          if (__result == 0) goto <D.29856>; else goto <D.29857>;
          <D.29856>:
          D.29858 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.29859 = *D.29858;
          D.29860 = (int) D.29859;
          D.29861 = __s2 + 2;
          D.29862 = *D.29861;
          D.29863 = (int) D.29862;
          __result = D.29860 - D.29863;
          if (__s1_len > 2) goto <D.29864>; else goto <D.29865>;
          <D.29864>:
          if (__result == 0) goto <D.29866>; else goto <D.29867>;
          <D.29866>:
          D.29868 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.29869 = *D.29868;
          D.29870 = (int) D.29869;
          D.29871 = __s2 + 3;
          D.29872 = *D.29871;
          D.29873 = (int) D.29872;
          __result = D.29870 - D.29873;
          <D.29867>:
          <D.29865>:
          <D.29857>:
          <D.29855>:
          <D.29847>:
          <D.29845>:
        }
        D.23189 = __result;
      }
      iftmp.161 = D.23189;
      goto <D.29874>;
      <D.29838>:
      D.29875 = class->name_space;
      iftmp.161 = __builtin_strcmp ("System.Reflection.Emit", D.29875);
      <D.29874>:
      D.23193 = iftmp.161;
    }
    if (D.23193 == 0) goto <D.29876>; else goto <D.29877>;
    <D.29876>:
    cached_class = class;
    D.29789 = 1;
    return D.29789;
    <D.29877>:
    <D.29835>:
    <D.29793>:
    D.29789 = 0;
    return D.29789;
  }
}


is_sr_mono_field (struct MonoClass * class)
{
  struct MonoClass * cached_class.162;
  gboolean D.29882;
  _Bool D.29883;
  int D.29884;
  int D.23342;
  int iftmp.163;
  int D.23338;
  const char[10] * D.29890;
  unsigned char D.29891;
  int D.29892;
  unsigned char D.29893;
  int D.29894;
  const unsigned char * D.29899;
  unsigned char D.29900;
  int D.29901;
  const unsigned char * D.29902;
  unsigned char D.29903;
  int D.29904;
  const unsigned char * D.29909;
  unsigned char D.29910;
  int D.29911;
  const unsigned char * D.29912;
  unsigned char D.29913;
  int D.29914;
  const unsigned char * D.29919;
  unsigned char D.29920;
  int D.29921;
  const unsigned char * D.29922;
  unsigned char D.29923;
  int D.29924;
  const char * D.29926;
  int D.23351;
  int iftmp.164;
  int D.23347;
  const char[18] * D.29932;
  unsigned char D.29933;
  int D.29934;
  unsigned char D.29935;
  int D.29936;
  const unsigned char * D.29941;
  unsigned char D.29942;
  int D.29943;
  const unsigned char * D.29944;
  unsigned char D.29945;
  int D.29946;
  const unsigned char * D.29951;
  unsigned char D.29952;
  int D.29953;
  const unsigned char * D.29954;
  unsigned char D.29955;
  int D.29956;
  const unsigned char * D.29961;
  unsigned char D.29962;
  int D.29963;
  const unsigned char * D.29964;
  unsigned char D.29965;
  int D.29966;
  const char * D.29968;

  {
    static struct MonoClass * cached_class;

    cached_class.162 = cached_class;
    if (cached_class.162 != 0B) goto <D.29880>; else goto <D.29881>;
    <D.29880>:
    cached_class.162 = cached_class;
    D.29883 = cached_class.162 == class;
    D.29882 = (gboolean) D.29883;
    return D.29882;
    <D.29881>:
    D.29884 = is_corlib_type (class);
    if (D.29884 != 0) goto <D.29885>; else goto <D.29886>;
    <D.29885>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29890 = "MonoField";
        D.29891 = MEM[(const unsigned char *)D.29890];
        D.29892 = (int) D.29891;
        D.29893 = *__s2;
        D.29894 = (int) D.29893;
        __result = D.29892 - D.29894;
        {
          if (__s1_len != 0) goto <D.29895>; else goto <D.29896>;
          <D.29895>:
          if (__result == 0) goto <D.29897>; else goto <D.29898>;
          <D.29897>:
          D.29899 = &MEM[(void *)"MonoField" + 1B];
          D.29900 = *D.29899;
          D.29901 = (int) D.29900;
          D.29902 = __s2 + 1;
          D.29903 = *D.29902;
          D.29904 = (int) D.29903;
          __result = D.29901 - D.29904;
          if (__s1_len > 1) goto <D.29905>; else goto <D.29906>;
          <D.29905>:
          if (__result == 0) goto <D.29907>; else goto <D.29908>;
          <D.29907>:
          D.29909 = &MEM[(void *)"MonoField" + 2B];
          D.29910 = *D.29909;
          D.29911 = (int) D.29910;
          D.29912 = __s2 + 2;
          D.29913 = *D.29912;
          D.29914 = (int) D.29913;
          __result = D.29911 - D.29914;
          if (__s1_len > 2) goto <D.29915>; else goto <D.29916>;
          <D.29915>:
          if (__result == 0) goto <D.29917>; else goto <D.29918>;
          <D.29917>:
          D.29919 = &MEM[(void *)"MonoField" + 3B];
          D.29920 = *D.29919;
          D.29921 = (int) D.29920;
          D.29922 = __s2 + 3;
          D.29923 = *D.29922;
          D.29924 = (int) D.29923;
          __result = D.29921 - D.29924;
          <D.29918>:
          <D.29916>:
          <D.29908>:
          <D.29906>:
          <D.29898>:
          <D.29896>:
        }
        D.23338 = __result;
      }
      iftmp.163 = D.23338;
      goto <D.29925>;
      <D.29889>:
      D.29926 = class->name;
      iftmp.163 = __builtin_strcmp ("MonoField", D.29926);
      <D.29925>:
      D.23342 = iftmp.163;
    }
    if (D.23342 == 0) goto <D.29927>; else goto <D.29928>;
    <D.29927>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29932 = "System.Reflection";
        D.29933 = MEM[(const unsigned char *)D.29932];
        D.29934 = (int) D.29933;
        D.29935 = *__s2;
        D.29936 = (int) D.29935;
        __result = D.29934 - D.29936;
        {
          if (__s1_len != 0) goto <D.29937>; else goto <D.29938>;
          <D.29937>:
          if (__result == 0) goto <D.29939>; else goto <D.29940>;
          <D.29939>:
          D.29941 = &MEM[(void *)"System.Reflection" + 1B];
          D.29942 = *D.29941;
          D.29943 = (int) D.29942;
          D.29944 = __s2 + 1;
          D.29945 = *D.29944;
          D.29946 = (int) D.29945;
          __result = D.29943 - D.29946;
          if (__s1_len > 1) goto <D.29947>; else goto <D.29948>;
          <D.29947>:
          if (__result == 0) goto <D.29949>; else goto <D.29950>;
          <D.29949>:
          D.29951 = &MEM[(void *)"System.Reflection" + 2B];
          D.29952 = *D.29951;
          D.29953 = (int) D.29952;
          D.29954 = __s2 + 2;
          D.29955 = *D.29954;
          D.29956 = (int) D.29955;
          __result = D.29953 - D.29956;
          if (__s1_len > 2) goto <D.29957>; else goto <D.29958>;
          <D.29957>:
          if (__result == 0) goto <D.29959>; else goto <D.29960>;
          <D.29959>:
          D.29961 = &MEM[(void *)"System.Reflection" + 3B];
          D.29962 = *D.29961;
          D.29963 = (int) D.29962;
          D.29964 = __s2 + 3;
          D.29965 = *D.29964;
          D.29966 = (int) D.29965;
          __result = D.29963 - D.29966;
          <D.29960>:
          <D.29958>:
          <D.29950>:
          <D.29948>:
          <D.29940>:
          <D.29938>:
        }
        D.23347 = __result;
      }
      iftmp.164 = D.23347;
      goto <D.29967>;
      <D.29931>:
      D.29968 = class->name_space;
      iftmp.164 = __builtin_strcmp ("System.Reflection", D.29968);
      <D.29967>:
      D.23351 = iftmp.164;
    }
    if (D.23351 == 0) goto <D.29969>; else goto <D.29970>;
    <D.29969>:
    cached_class = class;
    D.29882 = 1;
    return D.29882;
    <D.29970>:
    <D.29928>:
    <D.29886>:
    D.29882 = 0;
    return D.29882;
  }
}


mono_image_get_ctor_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorOnTypeBuilderInst * c, gboolean create_methodspec)
{
  struct MonoGHashTable * D.29972;
  void * D.29973;
  long int D.29974;
  guint32 D.29977;
  struct MonoObject * D.29978;
  struct MonoVTable * D.29979;
  struct MonoClass * D.29980;
  int D.29981;
  struct MonoReflectionGenericClass * D.29984;
  long unsigned int D.29985;
  long unsigned int D.29986;
  _Bool D.29987;
  long int D.29988;
  long int D.29989;
  struct MonoString * D.29992;
  struct MonoType * D.29993;
  int D.29995;
  struct MonoMethodSignature * D.29998;
  const char * D.29999;
  long unsigned int D.30001;
  void * D.30002;
  guint32 sig;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoType * type;

  D.29972 = assembly->handleref_managed;
  D.29973 = mono_g_hash_table_lookup (D.29972, c);
  D.29974 = (long int) D.29973;
  token = (guint32) D.29974;
  if (token != 0) goto <D.29975>; else goto <D.29976>;
  <D.29975>:
  D.29977 = token;
  return D.29977;
  <D.29976>:
  D.29978 = c->cb;
  D.29979 = D.29978->vtable;
  D.29980 = D.29979->klass;
  D.29981 = is_sre_ctor_builder (D.29980);
  if (D.29981 != 0) goto <D.29982>; else goto <D.29983>;
  <D.29982>:
  {
    struct MonoReflectionCtorBuilder * cb;
    struct MonoDynamicGenericClass * dgclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        cb = c->cb;
        D.29984 = c->inst;
        type = mono_reflection_type_get_handle (D.29984);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.29985 = BIT_FIELD_REF <*gclass, 64, 192>;
        D.29986 = D.29985 & 1;
        D.29987 = D.29986 == 0;
        D.29988 = (long int) D.29987;
        D.29989 = __builtin_expect (D.29988, 0);
        if (D.29989 != 0) goto <D.29990>; else goto <D.29991>;
        <D.29990>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2835, "gclass->is_dynamic");
        <D.29991>:
        dgclass = gclass;
        reflection_methodbuilder_from_ctor_builder (&rmb, cb);
        D.29992 = rmb.name;
        name = mono_string_to_utf8 (D.29992);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.29993 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.29993, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.29994>;
  <D.29983>:
  D.29978 = c->cb;
  D.29979 = D.29978->vtable;
  D.29980 = D.29979->klass;
  D.29995 = is_sr_mono_cmethod (D.29980);
  if (D.29995 != 0) goto <D.29996>; else goto <D.29997>;
  <D.29996>:
  {
    struct MonoMethod * mm;

    D.29978 = c->cb;
    mm = MEM[(struct MonoReflectionMethod *)D.29978].method;
    D.29984 = c->inst;
    type = mono_reflection_type_get_handle (D.29984);
    klass = mono_class_from_mono_type (type);
    D.29998 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.29998);
    D.29993 = &klass->byval_arg;
    D.29999 = mm->name;
    token = mono_image_get_memberref_token (assembly, D.29993, D.29999, sig);
  }
  goto <D.30000>;
  <D.29997>:
  {
    char * name;

    D.29978 = c->cb;
    D.29979 = D.29978->vtable;
    D.29980 = D.29979->klass;
    name = mono_type_get_full_name (D.29980);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.20059>:
    goto <D.20059>;
  }
  <D.30000>:
  <D.29994>:
  D.29972 = assembly->handleref_managed;
  D.30001 = (long unsigned int) token;
  D.30002 = (void *) D.30001;
  mono_g_hash_table_insert (D.29972, c, D.30002);
  D.29977 = token;
  return D.29977;
}


is_sre_ctor_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.165;
  gboolean D.30007;
  _Bool D.30008;
  int D.30009;
  int D.23162;
  int iftmp.166;
  int D.23158;
  const char[19] * D.30015;
  unsigned char D.30016;
  int D.30017;
  unsigned char D.30018;
  int D.30019;
  const unsigned char * D.30024;
  unsigned char D.30025;
  int D.30026;
  const unsigned char * D.30027;
  unsigned char D.30028;
  int D.30029;
  const unsigned char * D.30034;
  unsigned char D.30035;
  int D.30036;
  const unsigned char * D.30037;
  unsigned char D.30038;
  int D.30039;
  const unsigned char * D.30044;
  unsigned char D.30045;
  int D.30046;
  const unsigned char * D.30047;
  unsigned char D.30048;
  int D.30049;
  const char * D.30051;
  int D.23171;
  int iftmp.167;
  int D.23167;
  const char[23] * D.30057;
  unsigned char D.30058;
  int D.30059;
  unsigned char D.30060;
  int D.30061;
  const unsigned char * D.30066;
  unsigned char D.30067;
  int D.30068;
  const unsigned char * D.30069;
  unsigned char D.30070;
  int D.30071;
  const unsigned char * D.30076;
  unsigned char D.30077;
  int D.30078;
  const unsigned char * D.30079;
  unsigned char D.30080;
  int D.30081;
  const unsigned char * D.30086;
  unsigned char D.30087;
  int D.30088;
  const unsigned char * D.30089;
  unsigned char D.30090;
  int D.30091;
  const char * D.30093;

  {
    static struct MonoClass * cached_class;

    cached_class.165 = cached_class;
    if (cached_class.165 != 0B) goto <D.30005>; else goto <D.30006>;
    <D.30005>:
    cached_class.165 = cached_class;
    D.30008 = cached_class.165 == class;
    D.30007 = (gboolean) D.30008;
    return D.30007;
    <D.30006>:
    D.30009 = is_corlib_type (class);
    if (D.30009 != 0) goto <D.30010>; else goto <D.30011>;
    <D.30010>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

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


is_sr_mono_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.168;
  gboolean D.30100;
  _Bool D.30101;
  int D.30102;
  int D.23408;
  int iftmp.169;
  int D.23404;
  const char[12] * D.30108;
  unsigned char D.30109;
  int D.30110;
  unsigned char D.30111;
  int D.30112;
  const unsigned char * D.30117;
  unsigned char D.30118;
  int D.30119;
  const unsigned char * D.30120;
  unsigned char D.30121;
  int D.30122;
  const unsigned char * D.30127;
  unsigned char D.30128;
  int D.30129;
  const unsigned char * D.30130;
  unsigned char D.30131;
  int D.30132;
  const unsigned char * D.30137;
  unsigned char D.30138;
  int D.30139;
  const unsigned char * D.30140;
  unsigned char D.30141;
  int D.30142;
  const char * D.30144;
  int D.23417;
  int iftmp.170;
  int D.23413;
  const char[18] * D.30150;
  unsigned char D.30151;
  int D.30152;
  unsigned char D.30153;
  int D.30154;
  const unsigned char * D.30159;
  unsigned char D.30160;
  int D.30161;
  const unsigned char * D.30162;
  unsigned char D.30163;
  int D.30164;
  const unsigned char * D.30169;
  unsigned char D.30170;
  int D.30171;
  const unsigned char * D.30172;
  unsigned char D.30173;
  int D.30174;
  const unsigned char * D.30179;
  unsigned char D.30180;
  int D.30181;
  const unsigned char * D.30182;
  unsigned char D.30183;
  int D.30184;
  const char * D.30186;

  {
    static struct MonoClass * cached_class;

    cached_class.168 = cached_class;
    if (cached_class.168 != 0B) goto <D.30098>; else goto <D.30099>;
    <D.30098>:
    cached_class.168 = cached_class;
    D.30101 = cached_class.168 == class;
    D.30100 = (gboolean) D.30101;
    return D.30100;
    <D.30099>:
    D.30102 = is_corlib_type (class);
    if (D.30102 != 0) goto <D.30103>; else goto <D.30104>;
    <D.30103>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

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

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

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


mono_image_get_method_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodOnTypeBuilderInst * m, gboolean create_methodspec)
{
  struct MonoArray * D.30190;
  guint32 D.30196;
  struct MonoGHashTable * D.30197;
  void * D.30198;
  long int D.30199;
  struct MonoObject * D.30202;
  struct MonoVTable * D.30203;
  struct MonoClass * D.30204;
  int D.30205;
  struct MonoReflectionType * D.30208;
  long unsigned int D.30209;
  long unsigned int D.30210;
  _Bool D.30211;
  long int D.30212;
  long int D.30213;
  struct MonoString * D.30216;
  struct MonoType * D.30217;
  int D.30219;
  struct MonoMethodSignature * D.30222;
  const char * D.30223;
  long unsigned int D.30225;
  void * D.30226;
  guint32 sig;
  guint32 token;
  struct MonoType * type;
  struct MonoClass * klass;

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

    inflated = mono_reflection_method_on_tb_inst_get_handle (m);
    if (create_methodspec != 0) goto <D.30193>; else goto <D.30194>;
    <D.30193>:
    token = mono_image_get_methodspec_token (assembly, inflated);
    goto <D.30195>;
    <D.30194>:
    token = mono_image_get_inflated_method_token (assembly, inflated);
    <D.30195>:
    D.30196 = token;
    return D.30196;
  }
  <D.30192>:
  D.30197 = assembly->handleref_managed;
  D.30198 = mono_g_hash_table_lookup (D.30197, m);
  D.30199 = (long int) D.30198;
  token = (guint32) D.30199;
  if (token != 0) goto <D.30200>; else goto <D.30201>;
  <D.30200>:
  D.30196 = token;
  return D.30196;
  <D.30201>:
  D.30202 = m->mb;
  D.30203 = D.30202->vtable;
  D.30204 = D.30203->klass;
  D.30205 = is_sre_method_builder (D.30204);
  if (D.30205 != 0) goto <D.30206>; else goto <D.30207>;
  <D.30206>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoGenericClass * gclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        mb = m->mb;
        D.30208 = m->inst;
        type = mono_reflection_type_get_handle (D.30208);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.30209 = BIT_FIELD_REF <*gclass, 64, 192>;
        D.30210 = D.30209 & 1;
        D.30211 = D.30210 == 0;
        D.30212 = (long int) D.30211;
        D.30213 = __builtin_expect (D.30212, 0);
        if (D.30213 != 0) goto <D.30214>; else goto <D.30215>;
        <D.30214>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2934, "gclass->is_dynamic");
        <D.30215>:
        reflection_methodbuilder_from_method_builder (&rmb, mb);
        D.30216 = rmb.name;
        name = mono_string_to_utf8 (D.30216);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.30217 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.30217, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.30218>;
  <D.30207>:
  D.30202 = m->mb;
  D.30203 = D.30202->vtable;
  D.30204 = D.30203->klass;
  D.30219 = is_sr_mono_method (D.30204);
  if (D.30219 != 0) goto <D.30220>; else goto <D.30221>;
  <D.30220>:
  {
    struct MonoMethod * mm;

    D.30202 = m->mb;
    mm = MEM[(struct MonoReflectionMethod *)D.30202].method;
    D.30208 = m->inst;
    type = mono_reflection_type_get_handle (D.30208);
    klass = mono_class_from_mono_type (type);
    D.30222 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.30222);
    D.30217 = &klass->byval_arg;
    D.30223 = mm->name;
    token = mono_image_get_memberref_token (assembly, D.30217, D.30223, sig);
  }
  goto <D.30224>;
  <D.30221>:
  {
    char * name;

    D.30202 = m->mb;
    D.30203 = D.30202->vtable;
    D.30204 = D.30203->klass;
    name = mono_type_get_full_name (D.30204);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.20091>:
    goto <D.20091>;
  }
  <D.30224>:
  <D.30218>:
  D.30197 = assembly->handleref_managed;
  D.30225 = (long unsigned int) token;
  D.30226 = (void *) D.30225;
  mono_g_hash_table_insert (D.30197, m, D.30226);
  D.30196 = token;
  return D.30196;
}


mono_reflection_method_on_tb_inst_get_handle (struct MonoReflectionMethodOnTypeBuilderInst * m)
{
  struct MonoReflectionType * D.30228;
  struct MonoObject * D.30229;
  struct MonoArray * D.30230;
  struct MonoMethod * D.30233;
  long unsigned int D.30234;
  long unsigned int D.30235;
  long unsigned int D.30238;
  long unsigned int D.30239;
  long unsigned int D.30240;
  long unsigned int D.30241;
  char * D.30242;
  long unsigned int D.30243;
  long unsigned int D.30244;
  struct MonoType * * D.30245;
  struct MonoType * D.30246;
  struct MonoGenericInst * iftmp.171;
  struct MonoGenericClass * D.30248;
  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.30228 = m->inst;
      init_type_builder_generics (D.30228);
      D.30228 = m->inst;
      D.30229 = m->mb;
      method = inflate_method (D.30228, D.30229);
      klass = method->klass;
      D.30230 = m->method_args;
      if (D.30230 == 0B) goto <D.30231>; else goto <D.30232>;
      <D.30231>:
      D.30233 = method;
      return D.30233;
      <D.30232>:
      D.30234 = BIT_FIELD_REF <*method, 64, 256>;
      D.30235 = D.30234 & 4096;
      if (D.30235 != 0) goto <D.30236>; else goto <D.30237>;
      <D.30236>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.30237>:
      D.30230 = m->method_args;
      D.30238 = mono_array_length (D.30230);
      count = (int) D.30238;
      D.30239 = (long unsigned int) count;
      D.30240 = D.30239 * 8;
      type_argv = monoeg_malloc0 (D.30240);
      i = 0;
      goto <D.20073>;
      <D.20072>:
      {
        struct MonoReflectionType * garg;

        D.30230 = m->method_args;
        D.30241 = (long unsigned int) i;
        D.30242 = mono_array_addr_with_size (D.30230, 8, D.30241);
        garg = MEM[(void * *)D.30242];
        D.30243 = (long unsigned int) i;
        D.30244 = D.30243 * 8;
        D.30245 = type_argv + D.30244;
        D.30246 = mono_reflection_type_get_handle (garg);
        *D.30245 = D.30246;
      }
      i = i + 1;
      <D.20073>:
      if (i < count) goto <D.20072>; else goto <D.20074>;
      <D.20074>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.30248 = klass->generic_class;
      if (D.30248 != 0B) goto <D.30249>; else goto <D.30250>;
      <D.30249>:
      D.30248 = klass->generic_class;
      iftmp.171 = D.30248->context.class_inst;
      goto <D.30251>;
      <D.30250>:
      iftmp.171 = 0B;
      <D.30251>:
      tmp_context.class_inst = iftmp.171;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      D.30233 = inflated;
      return D.30233;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_method (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoVTable * D.30254;
  int D.30255;
  struct MonoReflectionType * D.30258;
  struct MonoType * D.30259;
  int D.30261;
  struct MonoType * D.30264;
  struct MonoType * D.30266;
  struct MonoClass * D.30270;
  char * D.30271;
  int D.23914;
  int iftmp.172;
  int D.23913;
  struct MonoVTable * D.30275;
  struct MonoClass * D.30276;
  const char[14] * D.30277;
  unsigned char D.30278;
  int D.30279;
  unsigned char D.30280;
  int D.30281;
  const unsigned char * D.30286;
  unsigned char D.30287;
  int D.30288;
  const unsigned char * D.30289;
  unsigned char D.30290;
  int D.30291;
  const unsigned char * D.30296;
  unsigned char D.30297;
  int D.30298;
  const unsigned char * D.30299;
  unsigned char D.30300;
  int D.30301;
  const unsigned char * D.30306;
  unsigned char D.30307;
  int D.30308;
  const unsigned char * D.30309;
  unsigned char D.30310;
  int D.30311;
  const char * D.30313;
  struct MonoMethod * D.30316;
  int D.23923;
  int iftmp.173;
  int D.23922;
  const char[19] * D.30324;
  unsigned char D.30325;
  int D.30326;
  unsigned char D.30327;
  int D.30328;
  const unsigned char * D.30333;
  unsigned char D.30334;
  int D.30335;
  const unsigned char * D.30336;
  unsigned char D.30337;
  int D.30338;
  const unsigned char * D.30343;
  unsigned char D.30344;
  int D.30345;
  const unsigned char * D.30346;
  unsigned char D.30347;
  int D.30348;
  const unsigned char * D.30353;
  unsigned char D.30354;
  int D.30355;
  const unsigned char * D.30356;
  unsigned char D.30357;
  int D.30358;
  int D.23932;
  int iftmp.174;
  int D.23931;
  const char[11] * D.30369;
  unsigned char D.30370;
  int D.30371;
  unsigned char D.30372;
  int D.30373;
  const unsigned char * D.30378;
  unsigned char D.30379;
  int D.30380;
  const unsigned char * D.30381;
  unsigned char D.30382;
  int D.30383;
  const unsigned char * D.30388;
  unsigned char D.30389;
  int D.30390;
  const unsigned char * D.30391;
  unsigned char D.30392;
  int D.30393;
  const unsigned char * D.30398;
  unsigned char D.30399;
  int D.30400;
  const unsigned char * D.30401;
  unsigned char D.30402;
  int D.30403;
  int D.23941;
  int iftmp.175;
  int D.23940;
  const char[12] * D.30409;
  unsigned char D.30410;
  int D.30411;
  unsigned char D.30412;
  int D.30413;
  const unsigned char * D.30418;
  unsigned char D.30419;
  int D.30420;
  const unsigned char * D.30421;
  unsigned char D.30422;
  int D.30423;
  const unsigned char * D.30428;
  unsigned char D.30429;
  int D.30430;
  const unsigned char * D.30431;
  unsigned char D.30432;
  int D.30433;
  const unsigned char * D.30438;
  unsigned char D.30439;
  int D.30440;
  const unsigned char * D.30441;
  unsigned char D.30442;
  int D.30443;
  struct MonoMethod * D.30445;
  struct MonoType * D.30446;
  struct MonoClass * D.30447;
  struct MonoMethod * method;
  struct MonoClass * gklass;
  struct MonoClass * type_class;

  D.30254 = MEM[(struct MonoObject *)type].vtable;
  type_class = D.30254->klass;
  D.30255 = is_sre_generic_instance (type_class);
  if (D.30255 != 0) goto <D.30256>; else goto <D.30257>;
  <D.30256>:
  {
    struct MonoReflectionGenericClass * mgc;

    mgc = type;
    D.30258 = mgc->generic_type;
    D.30259 = mono_reflection_type_get_handle (D.30258);
    gklass = mono_class_from_mono_type (D.30259);
  }
  goto <D.30260>;
  <D.30257>:
  D.30261 = is_sre_type_builder (type_class);
  if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
  <D.30262>:
  D.30264 = mono_reflection_type_get_handle (type);
  gklass = mono_class_from_mono_type (D.30264);
  goto <D.30265>;
  <D.30263>:
  D.30266 = type->type;
  if (D.30266 != 0B) goto <D.30267>; else goto <D.30268>;
  <D.30267>:
  D.30266 = type->type;
  gklass = mono_class_from_mono_type (D.30266);
  gklass = mono_class_get_generic_type_definition (gklass);
  goto <D.30269>;
  <D.30268>:
  D.30254 = MEM[(struct MonoObject *)type].vtable;
  D.30270 = D.30254->klass;
  D.30271 = mono_type_get_full_name (D.30270);
  monoeg_g_log (0B, 4, "Can\'t handle type %s", D.30271);
  <D.23905>:
  goto <D.23905>;
  <D.30269>:
  <D.30265>:
  <D.30260>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.30275 = obj->vtable;
      D.30276 = D.30275->klass;
      __s2 = D.30276->name;
      D.30277 = "MethodBuilder";
      D.30278 = MEM[(const unsigned char *)D.30277];
      D.30279 = (int) D.30278;
      D.30280 = *__s2;
      D.30281 = (int) D.30280;
      __result = D.30279 - D.30281;
      {
        if (__s2_len != 0) goto <D.30282>; else goto <D.30283>;
        <D.30282>:
        if (__result == 0) goto <D.30284>; else goto <D.30285>;
        <D.30284>:
        D.30286 = &MEM[(void *)"MethodBuilder" + 1B];
        D.30287 = *D.30286;
        D.30288 = (int) D.30287;
        D.30289 = __s2 + 1;
        D.30290 = *D.30289;
        D.30291 = (int) D.30290;
        __result = D.30288 - D.30291;
        if (__s2_len > 1) goto <D.30292>; else goto <D.30293>;
        <D.30292>:
        if (__result == 0) goto <D.30294>; else goto <D.30295>;
        <D.30294>:
        D.30296 = &MEM[(void *)"MethodBuilder" + 2B];
        D.30297 = *D.30296;
        D.30298 = (int) D.30297;
        D.30299 = __s2 + 2;
        D.30300 = *D.30299;
        D.30301 = (int) D.30300;
        __result = D.30298 - D.30301;
        if (__s2_len > 2) goto <D.30302>; else goto <D.30303>;
        <D.30302>:
        if (__result == 0) goto <D.30304>; else goto <D.30305>;
        <D.30304>:
        D.30306 = &MEM[(void *)"MethodBuilder" + 3B];
        D.30307 = *D.30306;
        D.30308 = (int) D.30307;
        D.30309 = __s2 + 3;
        D.30310 = *D.30309;
        D.30311 = (int) D.30310;
        __result = D.30308 - D.30311;
        <D.30305>:
        <D.30303>:
        <D.30295>:
        <D.30293>:
        <D.30285>:
        <D.30283>:
      }
      D.23913 = __result;
    }
    iftmp.172 = -D.23913;
    goto <D.30312>;
    <D.30274>:
    D.30275 = obj->vtable;
    D.30276 = D.30275->klass;
    D.30313 = D.30276->name;
    iftmp.172 = __builtin_strcmp (D.30313, "MethodBuilder");
    <D.30312>:
    D.23914 = iftmp.172;
  }
  if (D.23914 == 0) goto <D.30314>; else goto <D.30315>;
  <D.30314>:
  D.30316 = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  if (D.30316 != 0B) goto <D.30317>; else goto <D.30318>;
  <D.30317>:
  method = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  goto <D.30319>;
  <D.30318>:
  method = methodbuilder_to_mono_method (gklass, obj);
  <D.30319>:
  goto <D.30320>;
  <D.30315>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.30275 = obj->vtable;
      D.30276 = D.30275->klass;
      __s2 = D.30276->name;
      D.30324 = "ConstructorBuilder";
      D.30325 = MEM[(const unsigned char *)D.30324];
      D.30326 = (int) D.30325;
      D.30327 = *__s2;
      D.30328 = (int) D.30327;
      __result = D.30326 - D.30328;
      {
        if (__s2_len != 0) goto <D.30329>; else goto <D.30330>;
        <D.30329>:
        if (__result == 0) goto <D.30331>; else goto <D.30332>;
        <D.30331>:
        D.30333 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.30334 = *D.30333;
        D.30335 = (int) D.30334;
        D.30336 = __s2 + 1;
        D.30337 = *D.30336;
        D.30338 = (int) D.30337;
        __result = D.30335 - D.30338;
        if (__s2_len > 1) goto <D.30339>; else goto <D.30340>;
        <D.30339>:
        if (__result == 0) goto <D.30341>; else goto <D.30342>;
        <D.30341>:
        D.30343 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.30344 = *D.30343;
        D.30345 = (int) D.30344;
        D.30346 = __s2 + 2;
        D.30347 = *D.30346;
        D.30348 = (int) D.30347;
        __result = D.30345 - D.30348;
        if (__s2_len > 2) goto <D.30349>; else goto <D.30350>;
        <D.30349>:
        if (__result == 0) goto <D.30351>; else goto <D.30352>;
        <D.30351>:
        D.30353 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.30354 = *D.30353;
        D.30355 = (int) D.30354;
        D.30356 = __s2 + 3;
        D.30357 = *D.30356;
        D.30358 = (int) D.30357;
        __result = D.30355 - D.30358;
        <D.30352>:
        <D.30350>:
        <D.30342>:
        <D.30340>:
        <D.30332>:
        <D.30330>:
      }
      D.23922 = __result;
    }
    iftmp.173 = -D.23922;
    goto <D.30359>;
    <D.30323>:
    D.30275 = obj->vtable;
    D.30276 = D.30275->klass;
    D.30313 = D.30276->name;
    iftmp.173 = __builtin_strcmp (D.30313, "ConstructorBuilder");
    <D.30359>:
    D.23923 = iftmp.173;
  }
  if (D.23923 == 0) goto <D.30360>; else goto <D.30361>;
  <D.30360>:
  method = ctorbuilder_to_mono_method (gklass, obj);
  goto <D.30362>;
  <D.30361>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.30275 = obj->vtable;
      D.30276 = D.30275->klass;
      __s2 = D.30276->name;
      D.30369 = "MonoMethod";
      D.30370 = MEM[(const unsigned char *)D.30369];
      D.30371 = (int) D.30370;
      D.30372 = *__s2;
      D.30373 = (int) D.30372;
      __result = D.30371 - D.30373;
      {
        if (__s2_len != 0) goto <D.30374>; else goto <D.30375>;
        <D.30374>:
        if (__result == 0) goto <D.30376>; else goto <D.30377>;
        <D.30376>:
        D.30378 = &MEM[(void *)"MonoMethod" + 1B];
        D.30379 = *D.30378;
        D.30380 = (int) D.30379;
        D.30381 = __s2 + 1;
        D.30382 = *D.30381;
        D.30383 = (int) D.30382;
        __result = D.30380 - D.30383;
        if (__s2_len > 1) goto <D.30384>; else goto <D.30385>;
        <D.30384>:
        if (__result == 0) goto <D.30386>; else goto <D.30387>;
        <D.30386>:
        D.30388 = &MEM[(void *)"MonoMethod" + 2B];
        D.30389 = *D.30388;
        D.30390 = (int) D.30389;
        D.30391 = __s2 + 2;
        D.30392 = *D.30391;
        D.30393 = (int) D.30392;
        __result = D.30390 - D.30393;
        if (__s2_len > 2) goto <D.30394>; else goto <D.30395>;
        <D.30394>:
        if (__result == 0) goto <D.30396>; else goto <D.30397>;
        <D.30396>:
        D.30398 = &MEM[(void *)"MonoMethod" + 3B];
        D.30399 = *D.30398;
        D.30400 = (int) D.30399;
        D.30401 = __s2 + 3;
        D.30402 = *D.30401;
        D.30403 = (int) D.30402;
        __result = D.30400 - D.30403;
        <D.30397>:
        <D.30395>:
        <D.30387>:
        <D.30385>:
        <D.30377>:
        <D.30375>:
      }
      D.23931 = __result;
    }
    iftmp.174 = -D.23931;
    goto <D.30404>;
    <D.30368>:
    D.30275 = obj->vtable;
    D.30276 = D.30275->klass;
    D.30313 = D.30276->name;
    iftmp.174 = __builtin_strcmp (D.30313, "MonoMethod");
    <D.30404>:
    D.23932 = iftmp.174;
  }
  if (D.23932 == 0) goto <D.30363>; else goto <D.30405>;
  <D.30405>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.30275 = obj->vtable;
      D.30276 = D.30275->klass;
      __s2 = D.30276->name;
      D.30409 = "MonoCMethod";
      D.30410 = MEM[(const unsigned char *)D.30409];
      D.30411 = (int) D.30410;
      D.30412 = *__s2;
      D.30413 = (int) D.30412;
      __result = D.30411 - D.30413;
      {
        if (__s2_len != 0) goto <D.30414>; else goto <D.30415>;
        <D.30414>:
        if (__result == 0) goto <D.30416>; else goto <D.30417>;
        <D.30416>:
        D.30418 = &MEM[(void *)"MonoCMethod" + 1B];
        D.30419 = *D.30418;
        D.30420 = (int) D.30419;
        D.30421 = __s2 + 1;
        D.30422 = *D.30421;
        D.30423 = (int) D.30422;
        __result = D.30420 - D.30423;
        if (__s2_len > 1) goto <D.30424>; else goto <D.30425>;
        <D.30424>:
        if (__result == 0) goto <D.30426>; else goto <D.30427>;
        <D.30426>:
        D.30428 = &MEM[(void *)"MonoCMethod" + 2B];
        D.30429 = *D.30428;
        D.30430 = (int) D.30429;
        D.30431 = __s2 + 2;
        D.30432 = *D.30431;
        D.30433 = (int) D.30432;
        __result = D.30430 - D.30433;
        if (__s2_len > 2) goto <D.30434>; else goto <D.30435>;
        <D.30434>:
        if (__result == 0) goto <D.30436>; else goto <D.30437>;
        <D.30436>:
        D.30438 = &MEM[(void *)"MonoCMethod" + 3B];
        D.30439 = *D.30438;
        D.30440 = (int) D.30439;
        D.30441 = __s2 + 3;
        D.30442 = *D.30441;
        D.30443 = (int) D.30442;
        __result = D.30440 - D.30443;
        <D.30437>:
        <D.30435>:
        <D.30427>:
        <D.30425>:
        <D.30417>:
        <D.30415>:
      }
      D.23940 = __result;
    }
    iftmp.175 = -D.23940;
    goto <D.30444>;
    <D.30408>:
    D.30275 = obj->vtable;
    D.30276 = D.30275->klass;
    D.30313 = D.30276->name;
    iftmp.175 = __builtin_strcmp (D.30313, "MonoCMethod");
    <D.30444>:
    D.23941 = iftmp.175;
  }
  if (D.23941 == 0) goto <D.30363>; else goto <D.30364>;
  <D.30363>:
  method = MEM[(struct MonoReflectionMethod *)obj].method;
  goto <D.30365>;
  <D.30364>:
  method = 0B;
  D.30275 = obj->vtable;
  D.30276 = D.30275->klass;
  D.30313 = D.30276->name;
  monoeg_g_log (0B, 4, "can\'t handle type %s", D.30313);
  <D.23942>:
  goto <D.23942>;
  <D.30365>:
  <D.30362>:
  <D.30320>:
  D.30446 = mono_reflection_type_get_handle (type);
  D.30447 = mono_class_from_mono_type (D.30446);
  D.30445 = inflate_mono_method (D.30447, method, obj);
  return D.30445;
}


is_sre_generic_instance (struct MonoClass * class)
{
  struct MonoClass * cached_class.176;
  gboolean D.30452;
  _Bool D.30453;
  int D.30454;
  int D.23096;
  int iftmp.177;
  int D.23092;
  const char[17] * D.30460;
  unsigned char D.30461;
  int D.30462;
  unsigned char D.30463;
  int D.30464;
  const unsigned char * D.30469;
  unsigned char D.30470;
  int D.30471;
  const unsigned char * D.30472;
  unsigned char D.30473;
  int D.30474;
  const unsigned char * D.30479;
  unsigned char D.30480;
  int D.30481;
  const unsigned char * D.30482;
  unsigned char D.30483;
  int D.30484;
  const unsigned char * D.30489;
  unsigned char D.30490;
  int D.30491;
  const unsigned char * D.30492;
  unsigned char D.30493;
  int D.30494;
  const char * D.30496;
  int D.23105;
  int iftmp.178;
  int D.23101;
  const char[18] * D.30502;
  unsigned char D.30503;
  int D.30504;
  unsigned char D.30505;
  int D.30506;
  const unsigned char * D.30511;
  unsigned char D.30512;
  int D.30513;
  const unsigned char * D.30514;
  unsigned char D.30515;
  int D.30516;
  const unsigned char * D.30521;
  unsigned char D.30522;
  int D.30523;
  const unsigned char * D.30524;
  unsigned char D.30525;
  int D.30526;
  const unsigned char * D.30531;
  unsigned char D.30532;
  int D.30533;
  const unsigned char * D.30534;
  unsigned char D.30535;
  int D.30536;
  const char * D.30538;

  {
    static struct MonoClass * cached_class;

    cached_class.176 = cached_class;
    if (cached_class.176 != 0B) goto <D.30450>; else goto <D.30451>;
    <D.30450>:
    cached_class.176 = cached_class;
    D.30453 = cached_class.176 == class;
    D.30452 = (gboolean) D.30453;
    return D.30452;
    <D.30451>:
    D.30454 = is_corlib_type (class);
    if (D.30454 != 0) goto <D.30455>; else goto <D.30456>;
    <D.30455>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30460 = "MonoGenericClass";
        D.30461 = MEM[(const unsigned char *)D.30460];
        D.30462 = (int) D.30461;
        D.30463 = *__s2;
        D.30464 = (int) D.30463;
        __result = D.30462 - D.30464;
        {
          if (__s1_len != 0) goto <D.30465>; else goto <D.30466>;
          <D.30465>:
          if (__result == 0) goto <D.30467>; else goto <D.30468>;
          <D.30467>:
          D.30469 = &MEM[(void *)"MonoGenericClass" + 1B];
          D.30470 = *D.30469;
          D.30471 = (int) D.30470;
          D.30472 = __s2 + 1;
          D.30473 = *D.30472;
          D.30474 = (int) D.30473;
          __result = D.30471 - D.30474;
          if (__s1_len > 1) goto <D.30475>; else goto <D.30476>;
          <D.30475>:
          if (__result == 0) goto <D.30477>; else goto <D.30478>;
          <D.30477>:
          D.30479 = &MEM[(void *)"MonoGenericClass" + 2B];
          D.30480 = *D.30479;
          D.30481 = (int) D.30480;
          D.30482 = __s2 + 2;
          D.30483 = *D.30482;
          D.30484 = (int) D.30483;
          __result = D.30481 - D.30484;
          if (__s1_len > 2) goto <D.30485>; else goto <D.30486>;
          <D.30485>:
          if (__result == 0) goto <D.30487>; else goto <D.30488>;
          <D.30487>:
          D.30489 = &MEM[(void *)"MonoGenericClass" + 3B];
          D.30490 = *D.30489;
          D.30491 = (int) D.30490;
          D.30492 = __s2 + 3;
          D.30493 = *D.30492;
          D.30494 = (int) D.30493;
          __result = D.30491 - D.30494;
          <D.30488>:
          <D.30486>:
          <D.30478>:
          <D.30476>:
          <D.30468>:
          <D.30466>:
        }
        D.23092 = __result;
      }
      iftmp.177 = D.23092;
      goto <D.30495>;
      <D.30459>:
      D.30496 = class->name;
      iftmp.177 = __builtin_strcmp ("MonoGenericClass", D.30496);
      <D.30495>:
      D.23096 = iftmp.177;
    }
    if (D.23096 == 0) goto <D.30497>; else goto <D.30498>;
    <D.30497>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30502 = "System.Reflection";
        D.30503 = MEM[(const unsigned char *)D.30502];
        D.30504 = (int) D.30503;
        D.30505 = *__s2;
        D.30506 = (int) D.30505;
        __result = D.30504 - D.30506;
        {
          if (__s1_len != 0) goto <D.30507>; else goto <D.30508>;
          <D.30507>:
          if (__result == 0) goto <D.30509>; else goto <D.30510>;
          <D.30509>:
          D.30511 = &MEM[(void *)"System.Reflection" + 1B];
          D.30512 = *D.30511;
          D.30513 = (int) D.30512;
          D.30514 = __s2 + 1;
          D.30515 = *D.30514;
          D.30516 = (int) D.30515;
          __result = D.30513 - D.30516;
          if (__s1_len > 1) goto <D.30517>; else goto <D.30518>;
          <D.30517>:
          if (__result == 0) goto <D.30519>; else goto <D.30520>;
          <D.30519>:
          D.30521 = &MEM[(void *)"System.Reflection" + 2B];
          D.30522 = *D.30521;
          D.30523 = (int) D.30522;
          D.30524 = __s2 + 2;
          D.30525 = *D.30524;
          D.30526 = (int) D.30525;
          __result = D.30523 - D.30526;
          if (__s1_len > 2) goto <D.30527>; else goto <D.30528>;
          <D.30527>:
          if (__result == 0) goto <D.30529>; else goto <D.30530>;
          <D.30529>:
          D.30531 = &MEM[(void *)"System.Reflection" + 3B];
          D.30532 = *D.30531;
          D.30533 = (int) D.30532;
          D.30534 = __s2 + 3;
          D.30535 = *D.30534;
          D.30536 = (int) D.30535;
          __result = D.30533 - D.30536;
          <D.30530>:
          <D.30528>:
          <D.30520>:
          <D.30518>:
          <D.30510>:
          <D.30508>:
        }
        D.23101 = __result;
      }
      iftmp.178 = D.23101;
      goto <D.30537>;
      <D.30501>:
      D.30538 = class->name_space;
      iftmp.178 = __builtin_strcmp ("System.Reflection", D.30538);
      <D.30537>:
      D.23105 = iftmp.178;
    }
    if (D.23105 == 0) goto <D.30539>; else goto <D.30540>;
    <D.30539>:
    cached_class = class;
    D.30452 = 1;
    return D.30452;
    <D.30540>:
    <D.30498>:
    <D.30456>:
    D.30452 = 0;
    return D.30452;
  }
}


methodbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoImage * D.30542;
  struct MonoMethod * D.30543;
  struct MonoMethod * D.30544;
  struct MonoArray * D.30545;
  int D.30546;
  struct MonoGenericContainer * D.30549;
  struct MonoMethod * D.30552;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.30542 = klass->image;
      sig = method_builder_to_signature (D.30542, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_method_builder (&rmb, mb);
      D.30543 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.30543;
      D.30542 = klass->image;
      D.30544 = mb->mhandle;
      D.30545 = mb->cattrs;
      mono_save_custom_attrs (D.30542, D.30544, D.30545);
      D.30542 = klass->image;
      D.30546 = MEM[(struct MonoDynamicImage *)D.30542].save;
      if (D.30546 == 0) goto <D.30547>; else goto <D.30548>;
      <D.30547>:
      D.30549 = klass->generic_container;
      if (D.30549 == 0B) goto <D.30550>; else goto <D.30551>;
      <D.30550>:
      mb->ilgen = 0B;
      <D.30551>:
      <D.30548>:
      D.30552 = mb->mhandle;
      return D.30552;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


method_builder_to_signature (struct MonoImage * image, struct MonoReflectionMethodBuilder * method)
{
  struct MonoArray * D.30555;
  unsigned int D.30556;
  unsigned int D.30557;
  _Bool D.30558;
  struct MonoType * iftmp.179;
  struct MonoObject * D.30560;
  struct MonoClass * D.30564;
  short unsigned int iftmp.180;
  struct MonoArray * D.30566;
  long unsigned int D.30569;
  struct MonoMethodSignature * D.30571;
  struct MonoMethodSignature * sig;

  D.30555 = method->parameters;
  sig = parameters_to_signature (image, D.30555);
  D.30556 = method->attrs;
  D.30557 = D.30556 & 16;
  D.30558 = D.30557 == 0;
  sig->hasthis = D.30558;
  D.30560 = method->rtype;
  if (D.30560 != 0B) goto <D.30561>; else goto <D.30562>;
  <D.30561>:
  D.30560 = method->rtype;
  iftmp.179 = mono_reflection_type_get_handle (D.30560);
  goto <D.30563>;
  <D.30562>:
  D.30564 = mono_defaults.void_class;
  iftmp.179 = &D.30564->byval_arg;
  <D.30563>:
  sig->ret = iftmp.179;
  D.30566 = method->generic_params;
  if (D.30566 != 0B) goto <D.30567>; else goto <D.30568>;
  <D.30567>:
  D.30566 = method->generic_params;
  D.30569 = mono_array_length (D.30566);
  iftmp.180 = (short unsigned int) D.30569;
  goto <D.30570>;
  <D.30568>:
  iftmp.180 = 0;
  <D.30570>:
  sig->generic_param_count = iftmp.180;
  D.30571 = sig;
  return D.30571;
}


parameters_to_signature (struct MonoImage * image, struct MonoArray * parameters)
{
  int iftmp.181;
  long unsigned int D.30576;
  long unsigned int D.30578;
  long unsigned int D.30579;
  unsigned int D.30580;
  unsigned int D.30581;
  short unsigned int D.30582;
  long unsigned int D.30583;
  char * D.30584;
  void * D.30585;
  struct MonoType * D.30586;
  struct MonoMethodSignature * D.30587;
  struct MonoMethodSignature * sig;
  int count;
  int i;

  if (parameters != 0B) goto <D.30574>; else goto <D.30575>;
  <D.30574>:
  D.30576 = mono_array_length (parameters);
  iftmp.181 = (int) D.30576;
  goto <D.30577>;
  <D.30575>:
  iftmp.181 = 0;
  <D.30577>:
  count = iftmp.181;
  D.30578 = (long unsigned int) count;
  D.30579 = D.30578 + 2;
  D.30580 = (unsigned int) D.30579;
  D.30581 = D.30580 * 8;
  sig = image_g_malloc0 (image, D.30581);
  D.30582 = (short unsigned int) count;
  sig->param_count = D.30582;
  sig->sentinelpos = -1;
  i = 0;
  goto <D.23280>;
  <D.23279>:
  D.30583 = (long unsigned int) i;
  D.30584 = mono_array_addr_with_size (parameters, 8, D.30583);
  D.30585 = MEM[(void * *)D.30584];
  D.30586 = mono_reflection_type_get_handle (D.30585);
  sig->params[i] = D.30586;
  i = i + 1;
  <D.23280>:
  if (i < count) goto <D.23279>; else goto <D.23281>;
  <D.23281>:
  D.30587 = sig;
  return D.30587;
}


image_g_malloc0 (struct MonoImage * image, guint size)
{
  void * D.30591;
  long unsigned int D.30592;

  if (image != 0B) goto <D.30589>; else goto <D.30590>;
  <D.30589>:
  D.30591 = mono_image_alloc0 (image, size);
  return D.30591;
  <D.30590>:
  D.30592 = (long unsigned int) size;
  D.30591 = monoeg_malloc0 (D.30592);
  return D.30591;
}


reflection_methodbuilder_to_mono_method (struct MonoClass * klass, struct ReflectionMethodBuilder * rmb, struct MonoMethodSignature * sig)
{
  void * * D.30594;
  _Bool D.30595;
  struct MonoImage * iftmp.182;
  struct MonoGenericClass * D.30602;
  _Bool D.30603;
  long int D.30604;
  long int D.30605;
  long unsigned int D.30608;
  long unsigned int D.30609;
  unsigned char D.30613;
  <unnamed-unsigned:1> D.30614;
  unsigned int D.30615;
  short unsigned int D.30616;
  unsigned int D.30617;
  short unsigned int D.30618;
  struct MonoString * D.30619;
  char * D.30620;
  unsigned char D.30621;
  <unnamed-unsigned:1> D.30622;
  guint32 * D.30623;
  unsigned int D.30626;
  unsigned int D.30627;
  short unsigned int D.30628;
  int D.30629;
  int D.30630;
  struct MonoClass * D.30633;
  int D.23772;
  int iftmp.183;
  int D.23771;
  const char[6] * D.30639;
  unsigned char D.30640;
  int D.30641;
  unsigned char D.30642;
  int D.30643;
  const unsigned char * D.30648;
  unsigned char D.30649;
  int D.30650;
  const unsigned char * D.30651;
  unsigned char D.30652;
  int D.30653;
  const unsigned char * D.30658;
  unsigned char D.30659;
  int D.30660;
  const unsigned char * D.30661;
  unsigned char D.30662;
  int D.30663;
  const unsigned char * D.30668;
  unsigned char D.30669;
  int D.30670;
  const unsigned char * D.30671;
  unsigned char D.30672;
  int D.30673;
  const char * D.30675;
  struct MonoMethodSignature * D.30678;
  short unsigned int D.30680;
  int D.30681;
  int D.30682;
  char * iftmp.184;
  struct MonoString * D.30686;
  int D.30690;
  _Bool D.30691;
  long int D.30692;
  long int D.30693;
  struct MonoString * D.30696;
  char * D.30697;
  int D.30698;
  _Bool D.30699;
  long int D.30700;
  long int D.30701;
  int D.30704;
  int D.30705;
  signed short D.30706;
  signed short iftmp.185;
  int D.30708;
  int D.30711;
  unsigned short D.30712;
  unsigned short D.30713;
  signed short D.30715;
  int D.30716;
  signed short D.30717;
  signed short D.30718;
  short unsigned int D.30719;
  struct MonoImage * D.30720;
  long unsigned int D.30721;
  long unsigned int D.30722;
  struct GHashTable * D.30725;
  struct MonoMethod * D.30726;
  int D.30727;
  int D.30730;
  struct MonoReflectionILGen * D.30733;
  struct MonoArray * D.30736;
  int D.30737;
  gint32 iftmp.186;
  struct MonoArray * D.30739;
  long unsigned int D.30742;
  struct MonoArray * D.30744;
  unsigned int D.30747;
  struct MonoArray * D.30749;
  long unsigned int D.30752;
  long unsigned int D.30754;
  long unsigned int D.30755;
  unsigned int D.30756;
  unsigned int D.30757;
  void * D.30758;
  const unsigned char * D.30759;
  long unsigned int D.30760;
  short unsigned int D.30761;
  <unnamed-unsigned:15> D.30762;
  unsigned char D.30763;
  <unnamed-unsigned:1> D.30764;
  short unsigned int D.30765;
  long unsigned int D.30766;
  char * D.30767;
  void * D.30768;
  struct MonoType * D.30769;
  struct MonoObject * D.30770;
  struct MonoType * D.30771;
  short unsigned int D.30772;
  <unnamed-unsigned:15> D.30773;
  unsigned int num_clauses.187;
  struct MonoExceptionClause * D.30777;
  struct MonoArray * D.30778;
  long unsigned int D.30781;
  _Bool D.30782;
  long int D.30783;
  long int D.30784;
  <unnamed-signed:31> D.30787;
  long unsigned int D.30788;
  unsigned int D.30789;
  unsigned int D.30790;
  void * D.30791;
  long unsigned int D.30792;
  char * D.30793;
  struct MonoType * D.30794;
  struct MonoGenericParamFull * D.30795;
  long unsigned int D.30796;
  long unsigned int D.30797;
  struct MonoGenericParamFull * D.30798;
  unsigned char D.30799;
  short unsigned int D.30802;
  int D.30803;
  struct MonoType * D.30806;
  struct MonoType * D.30807;
  long unsigned int D.30808;
  long unsigned int D.30809;
  struct MonoGenericParam * D.30810;
  short unsigned int D.30811;
  int D.30812;
  struct MonoGenericContainer * D.30813;
  struct MonoGenericInst * D.30816;
  struct MonoGenericInst * D.30817;
  unsigned int D.30820;
  unsigned int D.30821;
  unsigned int D.30822;
  long unsigned int D.30823;
  void * D.30824;
  sizetype D.30825;
  sizetype D.30826;
  sizetype D.30827;
  void * * D.30828;
  long unsigned int D.30829;
  long unsigned int D.30830;
  void * * D.30831;
  void * D.30832;
  unsigned int i.188;
  struct MonoArray * D.30834;
  struct MonoMethodSignature * D.30839;
  short unsigned int D.30840;
  int D.30841;
  int D.30842;
  long unsigned int D.30843;
  unsigned int D.30844;
  unsigned int D.30845;
  void * D.30846;
  char * D.30847;
  unsigned int D.30852;
  int D.30855;
  struct MonoType * D.30856;
  struct MonoType * D.30857;
  short unsigned int D.30858;
  unsigned int D.30859;
  uint8_t * * D.30862;
  int D.30865;
  long unsigned int D.30866;
  unsigned int D.30867;
  unsigned int D.30868;
  void * D.30869;
  unsigned int D.30870;
  void * D.30871;
  struct MonoObject * D.30872;
  char * D.30873;
  sizetype D.30874;
  const char * p2.189;
  long int p2.190;
  long int p.191;
  long int D.30878;
  unsigned int D.30879;
  long unsigned int D.30880;
  uint8_t * * D.30881;
  void * D.30882;
  uint32_t * D.30883;
  long unsigned int D.30884;
  uint32_t * D.30885;
  unsigned int def_type.192;
  uint8_t * D.30887;
  long unsigned int D.30888;
  struct MonoString * D.30889;
  char * * D.30892;
  char * * D.30893;
  char * D.30894;
  int D.30895;
  _Bool D.30896;
  long int D.30897;
  long int D.30898;
  struct MonoArray * D.30901;
  struct MonoCustomAttrInfo * * D.30904;
  void * D.30907;
  struct MonoCustomAttrInfo * * D.30908;
  struct MonoCustomAttrInfo * D.30909;
  char * D.30912;
  struct MonoReflectionMarshal * D.30915;
  short unsigned int D.30920;
  int D.30921;
  int D.30922;
  long unsigned int D.30923;
  unsigned int D.30924;
  unsigned int D.30925;
  int D.30926;
  long unsigned int D.30927;
  long unsigned int D.30928;
  struct MonoMarshalSpec * * D.30929;
  struct MonoAssembly * D.30930;
  struct MonoMarshalSpec * D.30931;
  long unsigned int D.30932;
  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.30594 = rmb->refs;
      D.30595 = D.30594 != 0B;
      dynamic = (gboolean) D.30595;
      if (dynamic == 0) goto <D.30597>; else goto <D.30598>;
      <D.30597>:
      iftmp.182 = klass->image;
      goto <D.30599>;
      <D.30598>:
      iftmp.182 = 0B;
      <D.30599>:
      image = iftmp.182;
      if (dynamic == 0) goto <D.30600>; else goto <D.30601>;
      <D.30600>:
      D.30602 = klass->generic_class;
      D.30603 = D.30602 != 0B;
      D.30604 = (long int) D.30603;
      D.30605 = __builtin_expect (D.30604, 0);
      if (D.30605 != 0) goto <D.30606>; else goto <D.30607>;
      <D.30606>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10133, "!klass->generic_class");
      <D.30607>:
      <D.30601>:
      mono_loader_lock ();
      D.30608 = BIT_FIELD_REF <*rmb, 64, 448>;
      D.30609 = D.30608 & 17592186052608;
      if (D.30609 != 0) goto <D.30610>; else goto <D.30611>;
      <D.30610>:
      m = image_g_malloc0 (image, 56);
      goto <D.30612>;
      <D.30611>:
      m = image_g_malloc0 (image, 56);
      <D.30612>:
      wrapperm = m;
      D.30613 = (unsigned char) dynamic;
      D.30614 = (<unnamed-unsigned:1>) D.30613;
      m->dynamic = D.30614;
      m->slot = -1;
      D.30615 = rmb->attrs;
      D.30616 = (short unsigned int) D.30615;
      m->flags = D.30616;
      D.30617 = rmb->iattrs;
      D.30618 = (short unsigned int) D.30617;
      m->iflags = D.30618;
      D.30619 = rmb->name;
      D.30620 = mono_string_to_utf8_image_ignore (image, D.30619);
      m->name = D.30620;
      m->klass = klass;
      m->signature = sig;
      m->sre_method = 1;
      D.30621 = rmb->skip_visibility;
      D.30622 = (<unnamed-unsigned:1>) D.30621;
      m->skip_visibility = D.30622;
      D.30623 = rmb->table_idx;
      if (D.30623 != 0B) goto <D.30624>; else goto <D.30625>;
      <D.30624>:
      D.30623 = rmb->table_idx;
      D.30626 = *D.30623;
      D.30627 = D.30626 | 100663296;
      m->token = D.30627;
      <D.30625>:
      D.30628 = m->iflags;
      D.30629 = (int) D.30628;
      D.30630 = D.30629 & 4096;
      if (D.30630 != 0) goto <D.30631>; else goto <D.30632>;
      <D.30631>:
      D.30633 = mono_defaults.string_class;
      if (D.30633 == klass) goto <D.30634>; else goto <D.30635>;
      <D.30634>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.30639 = ".ctor";
          D.30640 = MEM[(const unsigned char *)D.30639];
          D.30641 = (int) D.30640;
          D.30642 = *__s2;
          D.30643 = (int) D.30642;
          __result = D.30641 - D.30643;
          {
            if (__s2_len != 0) goto <D.30644>; else goto <D.30645>;
            <D.30644>:
            if (__result == 0) goto <D.30646>; else goto <D.30647>;
            <D.30646>:
            D.30648 = &MEM[(void *)".ctor" + 1B];
            D.30649 = *D.30648;
            D.30650 = (int) D.30649;
            D.30651 = __s2 + 1;
            D.30652 = *D.30651;
            D.30653 = (int) D.30652;
            __result = D.30650 - D.30653;
            if (__s2_len > 1) goto <D.30654>; else goto <D.30655>;
            <D.30654>:
            if (__result == 0) goto <D.30656>; else goto <D.30657>;
            <D.30656>:
            D.30658 = &MEM[(void *)".ctor" + 2B];
            D.30659 = *D.30658;
            D.30660 = (int) D.30659;
            D.30661 = __s2 + 2;
            D.30662 = *D.30661;
            D.30663 = (int) D.30662;
            __result = D.30660 - D.30663;
            if (__s2_len > 2) goto <D.30664>; else goto <D.30665>;
            <D.30664>:
            if (__result == 0) goto <D.30666>; else goto <D.30667>;
            <D.30666>:
            D.30668 = &MEM[(void *)".ctor" + 3B];
            D.30669 = *D.30668;
            D.30670 = (int) D.30669;
            D.30671 = __s2 + 3;
            D.30672 = *D.30671;
            D.30673 = (int) D.30672;
            __result = D.30670 - D.30673;
            <D.30667>:
            <D.30665>:
            <D.30657>:
            <D.30655>:
            <D.30647>:
            <D.30645>:
          }
          D.23771 = __result;
        }
        iftmp.183 = -D.23771;
        goto <D.30674>;
        <D.30638>:
        D.30675 = m->name;
        iftmp.183 = __builtin_strcmp (D.30675, ".ctor");
        <D.30674>:
        D.23772 = iftmp.183;
      }
      if (D.23772 == 0) goto <D.30676>; else goto <D.30677>;
      <D.30676>:
      m->string_ctor = 1;
      <D.30677>:
      <D.30635>:
      D.30678 = m->signature;
      D.30678->pinvoke = 1;
      goto <D.30679>;
      <D.30632>:
      D.30680 = m->flags;
      D.30681 = (int) D.30680;
      D.30682 = D.30681 & 8192;
      if (D.30682 != 0) goto <D.30683>; else goto <D.30684>;
      <D.30683>:
      D.30678 = m->signature;
      D.30678->pinvoke = 1;
      method_aux = image_g_malloc0 (image, 56);
      D.30686 = rmb->dllentry;
      if (D.30686 != 0B) goto <D.30687>; else goto <D.30688>;
      <D.30687>:
      D.30686 = rmb->dllentry;
      iftmp.184 = mono_string_to_utf8_image (image, D.30686, &error);
      goto <D.30689>;
      <D.30688>:
      D.30675 = m->name;
      iftmp.184 = image_strdup (image, D.30675);
      <D.30689>:
      method_aux->dllentry = iftmp.184;
      D.30690 = mono_error_ok (&error);
      D.30691 = D.30690 == 0;
      D.30692 = (long int) D.30691;
      D.30693 = __builtin_expect (D.30692, 0);
      if (D.30693 != 0) goto <D.30694>; else goto <D.30695>;
      <D.30694>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10168, "mono_error_ok (&error)");
      <D.30695>:
      D.30696 = rmb->dll;
      D.30697 = mono_string_to_utf8_image (image, D.30696, &error);
      method_aux->dll = D.30697;
      D.30698 = mono_error_ok (&error);
      D.30699 = D.30698 == 0;
      D.30700 = (long int) D.30699;
      D.30701 = __builtin_expect (D.30700, 0);
      if (D.30701 != 0) goto <D.30702>; else goto <D.30703>;
      <D.30702>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10170, "mono_error_ok (&error)");
      <D.30703>:
      D.30704 = rmb->native_cc;
      D.30705 = D.30704 << 8;
      D.30706 = (signed short) D.30705;
      D.30708 = rmb->charset;
      if (D.30708 != 0) goto <D.30709>; else goto <D.30710>;
      <D.30709>:
      D.30708 = rmb->charset;
      D.30711 = D.30708 + -1;
      D.30712 = (unsigned short) D.30711;
      D.30713 = D.30712 * 2;
      iftmp.185 = (signed short) D.30713;
      goto <D.30714>;
      <D.30710>:
      iftmp.185 = 0;
      <D.30714>:
      D.30715 = D.30706 | iftmp.185;
      D.30716 = rmb->extra_flags;
      D.30717 = (signed short) D.30716;
      D.30718 = D.30715 | D.30717;
      D.30719 = (short unsigned int) D.30718;
      MEM[(struct MonoMethodPInvoke *)m].piflags = D.30719;
      D.30720 = klass->image;
      D.30721 = BIT_FIELD_REF <*D.30720, 64, 192>;
      D.30722 = D.30721 & 34359738368;
      if (D.30722 != 0) goto <D.30723>; else goto <D.30724>;
      <D.30723>:
      D.30720 = klass->image;
      D.30725 = MEM[(struct MonoDynamicImage *)D.30720].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.30725, m, method_aux, 0);
      <D.30724>:
      mono_loader_unlock ();
      D.30726 = m;
      return D.30726;
      <D.30684>:
      D.30680 = m->flags;
      D.30681 = (int) D.30680;
      D.30727 = D.30681 & 1024;
      if (D.30727 == 0) goto <D.30728>; else goto <D.30729>;
      <D.30728>:
      D.30628 = m->iflags;
      D.30629 = (int) D.30628;
      D.30730 = D.30629 & 3;
      if (D.30730 == 0) goto <D.30731>; else goto <D.30732>;
      <D.30731>:
      {
        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.30733 = rmb->ilgen;
        if (D.30733 != 0B) goto <D.30734>; else goto <D.30735>;
        <D.30734>:
        D.30733 = rmb->ilgen;
        D.30736 = D.30733->code;
        code = mono_array_addr_with_size (D.30736, 1, 0);
        D.30733 = rmb->ilgen;
        D.30737 = D.30733->code_len;
        code_size = (guint32) D.30737;
        D.30733 = rmb->ilgen;
        max_stack = D.30733->max_stack;
        D.30733 = rmb->ilgen;
        D.30739 = D.30733->locals;
        if (D.30739 != 0B) goto <D.30740>; else goto <D.30741>;
        <D.30740>:
        D.30733 = rmb->ilgen;
        D.30739 = D.30733->locals;
        D.30742 = mono_array_length (D.30739);
        iftmp.186 = (gint32) D.30742;
        goto <D.30743>;
        <D.30741>:
        iftmp.186 = 0;
        <D.30743>:
        num_locals = iftmp.186;
        D.30733 = rmb->ilgen;
        D.30744 = D.30733->ex_handlers;
        if (D.30744 != 0B) goto <D.30745>; else goto <D.30746>;
        <D.30745>:
        D.30733 = rmb->ilgen;
        D.30747 = method_count_clauses (D.30733);
        num_clauses = (gint32) D.30747;
        <D.30746>:
        goto <D.30748>;
        <D.30735>:
        D.30749 = rmb->code;
        if (D.30749 != 0B) goto <D.30750>; else goto <D.30751>;
        <D.30750>:
        D.30749 = rmb->code;
        code = mono_array_addr_with_size (D.30749, 1, 0);
        D.30749 = rmb->code;
        D.30752 = mono_array_length (D.30749);
        code_size = (guint32) D.30752;
        max_stack = 8;
        goto <D.30753>;
        <D.30751>:
        code = 0B;
        code_size = 0;
        max_stack = 8;
        <D.30753>:
        <D.30748>:
        D.30754 = (long unsigned int) num_locals;
        D.30755 = D.30754 + 4;
        D.30756 = (unsigned int) D.30755;
        D.30757 = D.30756 * 8;
        header = image_g_malloc0 (image, D.30757);
        header->code_size = code_size;
        D.30758 = image_g_malloc (image, code_size);
        header->code = D.30758;
        D.30759 = header->code;
        D.30760 = (long unsigned int) code_size;
        memcpy (D.30759, code, D.30760);
        D.30761 = (short unsigned int) max_stack;
        D.30762 = (<unnamed-unsigned:15>) D.30761;
        header->max_stack = D.30762;
        D.30763 = rmb->init_locals;
        D.30764 = (<unnamed-unsigned:1>) D.30763;
        header->init_locals = D.30764;
        D.30765 = (short unsigned int) num_locals;
        header->num_locals = D.30765;
        i = 0;
        goto <D.23782>;
        <D.23781>:
        {
          struct MonoReflectionLocalBuilder * lb;

          D.30733 = rmb->ilgen;
          D.30739 = D.30733->locals;
          D.30766 = (long unsigned int) i;
          D.30767 = mono_array_addr_with_size (D.30739, 8, D.30766);
          lb = MEM[(struct MonoReflectionLocalBuilder * *)D.30767];
          D.30768 = image_g_malloc0 (image, 16);
          header->locals[i] = D.30768;
          D.30769 = header->locals[i];
          D.30770 = lb->type;
          D.30771 = mono_reflection_type_get_handle (D.30770);
          memcpy (D.30769, D.30771, 12);
        }
        i = i + 1;
        <D.23782>:
        if (i < num_locals) goto <D.23781>; else goto <D.23783>;
        <D.23783>:
        D.30772 = (short unsigned int) num_clauses;
        D.30773 = (<unnamed-unsigned:15>) D.30772;
        header->num_clauses = D.30773;
        if (num_clauses != 0) goto <D.30774>; else goto <D.30775>;
        <D.30774>:
        D.30720 = klass->image;
        D.30733 = rmb->ilgen;
        num_clauses.187 = (unsigned int) num_clauses;
        D.30777 = method_encode_clauses (image, D.30720, D.30733, num_clauses.187);
        header->clauses = D.30777;
        <D.30775>:
        wrapperm->header = header;
      }
      <D.30732>:
      <D.30729>:
      <D.30679>:
      D.30778 = rmb->generic_params;
      if (D.30778 != 0B) goto <D.30779>; else goto <D.30780>;
      <D.30779>:
      {
        int count;
        struct MonoGenericContainer * container;

        D.30778 = rmb->generic_params;
        D.30781 = mono_array_length (D.30778);
        count = (int) D.30781;
        container = rmb->generic_container;
        D.30782 = container == 0B;
        D.30783 = (long int) D.30782;
        D.30784 = __builtin_expect (D.30783, 0);
        if (D.30784 != 0) goto <D.30785>; else goto <D.30786>;
        <D.30785>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10239, "container");
        <D.30786>:
        D.30787 = (<unnamed-signed:31>) count;
        container->type_argc = D.30787;
        D.30788 = (long unsigned int) count;
        D.30789 = (unsigned int) D.30788;
        D.30790 = D.30789 * 56;
        D.30791 = image_g_malloc0 (image, D.30790);
        container->type_params = D.30791;
        container->owner.method = m;
        m->is_generic = 1;
        mono_method_set_generic_container (m, container);
        i = 0;
        goto <D.23789>;
        <D.23788>:
        {
          struct MonoReflectionGenericParam * gp;
          struct MonoGenericParamFull * param;

          D.30778 = rmb->generic_params;
          D.30792 = (long unsigned int) i;
          D.30793 = mono_array_addr_with_size (D.30778, 8, D.30792);
          gp = MEM[(struct MonoReflectionGenericParam * *)D.30793];
          D.30794 = mono_reflection_type_get_handle (gp);
          param = D.30794->data.generic_param;
          D.30795 = container->type_params;
          D.30796 = (long unsigned int) i;
          D.30797 = D.30796 * 56;
          D.30798 = D.30795 + D.30797;
          *D.30798 = *param;
        }
        i = i + 1;
        <D.23789>:
        if (i < count) goto <D.23788>; else goto <D.23790>;
        <D.23790>:
        i = 0;
        goto <D.23794>;
        <D.23793>:
        {
          struct MonoType * t;

          D.30678 = m->signature;
          t = D.30678->params[i];
          D.30799 = t->type;
          if (D.30799 == 30) goto <D.30800>; else goto <D.30801>;
          <D.30800>:
          {
            struct MonoGenericParam * gparam;

            gparam = t->data.generic_param;
            D.30802 = gparam->num;
            D.30803 = (int) D.30802;
            if (D.30803 < count) goto <D.30804>; else goto <D.30805>;
            <D.30804>:
            D.30678 = m->signature;
            D.30678 = m->signature;
            D.30806 = D.30678->params[i];
            D.30807 = mono_metadata_type_dup (image, D.30806);
            D.30678->params[i] = D.30807;
            D.30678 = m->signature;
            D.30806 = D.30678->params[i];
            D.30795 = container->type_params;
            D.30802 = gparam->num;
            D.30808 = (long unsigned int) D.30802;
            D.30809 = D.30808 * 56;
            D.30810 = D.30795 + D.30809;
            D.30806->data.generic_param = D.30810;
            <D.30805>:
          }
          <D.30801>:
        }
        i = i + 1;
        <D.23794>:
        D.30678 = m->signature;
        D.30811 = D.30678->param_count;
        D.30812 = (int) D.30811;
        if (D.30812 > i) goto <D.23793>; else goto <D.23795>;
        <D.23795>:
        D.30813 = klass->generic_container;
        if (D.30813 != 0B) goto <D.30814>; else goto <D.30815>;
        <D.30814>:
        D.30813 = klass->generic_container;
        container->parent = D.30813;
        D.30813 = klass->generic_container;
        D.30816 = D.30813->context.class_inst;
        container->context.class_inst = D.30816;
        <D.30815>:
        D.30817 = mono_get_shared_generic_inst (container);
        container->context.method_inst = D.30817;
      }
      <D.30780>:
      D.30594 = rmb->refs;
      if (D.30594 != 0B) goto <D.30818>; else goto <D.30819>;
      <D.30818>:
      {
        struct MonoMethodWrapper * mw;
        int i;
        void * * data;

        mw = m;
        m->wrapper_type = 17;
        D.30820 = rmb->nrefs;
        D.30821 = D.30820 + 1;
        D.30822 = D.30821 * 8;
        data = image_g_malloc (image, D.30822);
        mw->method_data = data;
        D.30820 = rmb->nrefs;
        D.30823 = (long unsigned int) D.30820;
        D.30824 = (void *) D.30823;
        *data = D.30824;
        i = 0;
        goto <D.23800>;
        <D.23799>:
        D.30825 = (sizetype) i;
        D.30826 = D.30825 + 1;
        D.30827 = D.30826 * 8;
        D.30828 = data + D.30827;
        D.30594 = rmb->refs;
        D.30829 = (long unsigned int) i;
        D.30830 = D.30829 * 8;
        D.30831 = D.30594 + D.30830;
        D.30832 = *D.30831;
        *D.30828 = D.30832;
        i = i + 1;
        <D.23800>:
        i.188 = (unsigned int) i;
        D.30820 = rmb->nrefs;
        if (i.188 < D.30820) goto <D.23799>; else goto <D.23801>;
        <D.23801>:
      }
      <D.30819>:
      method_aux = 0B;
      D.30834 = rmb->pinfo;
      if (D.30834 != 0B) goto <D.30835>; else goto <D.30836>;
      <D.30835>:
      if (method_aux == 0B) goto <D.30837>; else goto <D.30838>;
      <D.30837>:
      method_aux = image_g_malloc0 (image, 56);
      <D.30838>:
      D.30839 = mono_method_signature (m);
      D.30840 = D.30839->param_count;
      D.30841 = (int) D.30840;
      D.30842 = D.30841 + 1;
      D.30843 = (long unsigned int) D.30842;
      D.30844 = (unsigned int) D.30843;
      D.30845 = D.30844 * 8;
      D.30846 = image_g_malloc0 (image, D.30845);
      method_aux->param_names = D.30846;
      i = 0;
      goto <D.23810>;
      <D.23809>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.30834 = rmb->pinfo;
        D.30792 = (long unsigned int) i;
        D.30847 = mono_array_addr_with_size (D.30834, 8, D.30792);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.30847];
        if (pb != 0B) goto <D.30848>; else goto <D.30849>;
        <D.30848>:
        if (i > 0) goto <D.30850>; else goto <D.30851>;
        <D.30850>:
        D.30852 = pb->attrs;
        if (D.30852 != 0) goto <D.30853>; else goto <D.30854>;
        <D.30853>:
        D.30678 = m->signature;
        D.30855 = i + -1;
        D.30720 = klass->image;
        D.30678 = m->signature;
        D.30855 = i + -1;
        D.30856 = D.30678->params[D.30855];
        D.30857 = mono_metadata_type_dup (D.30720, D.30856);
        D.30678->params[D.30855] = D.30857;
        D.30678 = m->signature;
        D.30855 = i + -1;
        D.30856 = D.30678->params[D.30855];
        D.30852 = pb->attrs;
        D.30858 = (short unsigned int) D.30852;
        D.30856->attrs = D.30858;
        <D.30854>:
        <D.30851>:
        D.30852 = pb->attrs;
        D.30859 = D.30852 & 4096;
        if (D.30859 != 0) goto <D.30860>; else goto <D.30861>;
        <D.30860>:
        {
          struct MonoDynamicImage * assembly;
          guint32 idx;
          guint32 def_type;
          guint32 len;
          char * p;
          const char * p2;

          try
            {
              D.30862 = method_aux->param_defaults;
              if (D.30862 == 0B) goto <D.30863>; else goto <D.30864>;
              <D.30863>:
              D.30678 = m->signature;
              D.30811 = D.30678->param_count;
              D.30812 = (int) D.30811;
              D.30865 = D.30812 + 1;
              D.30866 = (long unsigned int) D.30865;
              D.30867 = (unsigned int) D.30866;
              D.30868 = D.30867 * 8;
              D.30869 = image_g_malloc0 (image, D.30868);
              method_aux->param_defaults = D.30869;
              D.30678 = m->signature;
              D.30811 = D.30678->param_count;
              D.30812 = (int) D.30811;
              D.30865 = D.30812 + 1;
              D.30866 = (long unsigned int) D.30865;
              D.30867 = (unsigned int) D.30866;
              D.30870 = D.30867 * 4;
              D.30871 = image_g_malloc0 (image, D.30870);
              method_aux->param_default_types = D.30871;
              <D.30864>:
              assembly = klass->image;
              D.30872 = pb->def_value;
              idx = encode_constant (assembly, D.30872, &def_type);
              D.30873 = assembly->blob.data;
              D.30874 = (sizetype) idx;
              p = D.30873 + D.30874;
              len = mono_metadata_decode_blob_size (p, &p2);
              p2.189 = p2;
              p2.190 = (long int) p2.189;
              p.191 = (long int) p;
              D.30878 = p2.190 - p.191;
              D.30879 = (unsigned int) D.30878;
              len = D.30879 + len;
              D.30862 = method_aux->param_defaults;
              D.30796 = (long unsigned int) i;
              D.30880 = D.30796 * 8;
              D.30881 = D.30862 + D.30880;
              D.30882 = image_g_malloc (image, len);
              *D.30881 = D.30882;
              D.30883 = method_aux->param_default_types;
              D.30796 = (long unsigned int) i;
              D.30884 = D.30796 * 4;
              D.30885 = D.30883 + D.30884;
              def_type.192 = def_type;
              *D.30885 = def_type.192;
              D.30862 = method_aux->param_defaults;
              D.30796 = (long unsigned int) i;
              D.30880 = D.30796 * 8;
              D.30881 = D.30862 + D.30880;
              D.30887 = *D.30881;
              D.30888 = (long unsigned int) len;
              memcpy (D.30887, p, D.30888);
            }
          finally
            {
              def_type = {CLOBBER};
              p2 = {CLOBBER};
            }
        }
        <D.30861>:
        D.30889 = pb->name;
        if (D.30889 != 0B) goto <D.30890>; else goto <D.30891>;
        <D.30890>:
        D.30892 = method_aux->param_names;
        D.30796 = (long unsigned int) i;
        D.30880 = D.30796 * 8;
        D.30893 = D.30892 + D.30880;
        D.30889 = pb->name;
        D.30894 = mono_string_to_utf8_image (image, D.30889, &error);
        *D.30893 = D.30894;
        D.30895 = mono_error_ok (&error);
        D.30896 = D.30895 == 0;
        D.30897 = (long int) D.30896;
        D.30898 = __builtin_expect (D.30897, 0);
        if (D.30898 != 0) goto <D.30899>; else goto <D.30900>;
        <D.30899>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10331, "mono_error_ok (&error)");
        <D.30900>:
        <D.30891>:
        D.30901 = pb->cattrs;
        if (D.30901 != 0B) goto <D.30902>; else goto <D.30903>;
        <D.30902>:
        D.30904 = method_aux->param_cattr;
        if (D.30904 == 0B) goto <D.30905>; else goto <D.30906>;
        <D.30905>:
        D.30678 = m->signature;
        D.30811 = D.30678->param_count;
        D.30812 = (int) D.30811;
        D.30865 = D.30812 + 1;
        D.30866 = (long unsigned int) D.30865;
        D.30867 = (unsigned int) D.30866;
        D.30868 = D.30867 * 8;
        D.30907 = image_g_malloc0 (image, D.30868);
        method_aux->param_cattr = D.30907;
        <D.30906>:
        D.30904 = method_aux->param_cattr;
        D.30796 = (long unsigned int) i;
        D.30880 = D.30796 * 8;
        D.30908 = D.30904 + D.30880;
        D.30720 = klass->image;
        D.30901 = pb->cattrs;
        D.30909 = mono_custom_attrs_from_builders (image, D.30720, D.30901);
        *D.30908 = D.30909;
        <D.30903>:
        <D.30849>:
      }
      i = i + 1;
      <D.23810>:
      D.30678 = m->signature;
      D.30811 = D.30678->param_count;
      D.30812 = (int) D.30811;
      if (D.30812 >= i) goto <D.23809>; else goto <D.23811>;
      <D.23811>:
      <D.30836>:
      specs = 0B;
      D.30834 = rmb->pinfo;
      if (D.30834 != 0B) goto <D.30910>; else goto <D.30911>;
      <D.30910>:
      i = 0;
      goto <D.23814>;
      <D.23813>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.30834 = rmb->pinfo;
        D.30792 = (long unsigned int) i;
        D.30912 = mono_array_addr_with_size (D.30834, 8, D.30792);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.30912];
        if (pb != 0B) goto <D.30913>; else goto <D.30914>;
        <D.30913>:
        D.30915 = pb->marshal_info;
        if (D.30915 != 0B) goto <D.30916>; else goto <D.30917>;
        <D.30916>:
        if (specs == 0B) goto <D.30918>; else goto <D.30919>;
        <D.30918>:
        D.30920 = sig->param_count;
        D.30921 = (int) D.30920;
        D.30922 = D.30921 + 1;
        D.30923 = (long unsigned int) D.30922;
        D.30924 = (unsigned int) D.30923;
        D.30925 = D.30924 * 8;
        specs = image_g_malloc0 (image, D.30925);
        <D.30919>:
        D.30926 = pb->position;
        D.30927 = (long unsigned int) D.30926;
        D.30928 = D.30927 * 8;
        D.30929 = specs + D.30928;
        D.30720 = klass->image;
        D.30930 = D.30720->assembly;
        D.30915 = pb->marshal_info;
        D.30931 = mono_marshal_spec_from_builder (image, D.30930, D.30915);
        *D.30929 = D.30931;
        <D.30917>:
        <D.30914>:
      }
      i = i + 1;
      <D.23814>:
      D.30792 = (long unsigned int) i;
      D.30834 = rmb->pinfo;
      D.30932 = mono_array_length (D.30834);
      if (D.30792 < D.30932) goto <D.23813>; else goto <D.23815>;
      <D.23815>:
      <D.30911>:
      if (specs != 0B) goto <D.30933>; else goto <D.30934>;
      <D.30933>:
      if (method_aux == 0B) goto <D.30935>; else goto <D.30936>;
      <D.30935>:
      method_aux = image_g_malloc0 (image, 56);
      <D.30936>:
      method_aux->param_marshall = specs;
      <D.30934>:
      D.30720 = klass->image;
      D.30721 = BIT_FIELD_REF <*D.30720, 64, 192>;
      D.30722 = D.30721 & 34359738368;
      if (D.30722 != 0) goto <D.30937>; else goto <D.30938>;
      <D.30937>:
      if (method_aux != 0B) goto <D.30939>; else goto <D.30940>;
      <D.30939>:
      D.30720 = klass->image;
      D.30725 = MEM[(struct MonoDynamicImage *)D.30720].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.30725, m, method_aux, 0);
      <D.30940>:
      <D.30938>:
      mono_loader_unlock ();
      D.30726 = m;
      return D.30726;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

  if (image != 0B) goto <D.30943>; else goto <D.30944>;
  <D.30943>:
  D.30945 = mono_image_strdup (image, s);
  return D.30945;
  <D.30944>:
  D.30945 = monoeg_strdup (s);
  return D.30945;
}


method_encode_clauses (struct MonoImage * image, struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen, guint32 num_clauses)
{
  unsigned int D.30947;
  struct MonoArray * D.30948;
  long unsigned int D.30949;
  unsigned int D.30950;
  unsigned int D.30951;
  long unsigned int D.30952;
  int D.30953;
  int D.30954;
  int D.30955;
  struct MonoArray * D.30956;
  long unsigned int D.30959;
  long unsigned int D.30960;
  long unsigned int D.30961;
  int D.30962;
  unsigned int D.30963;
  unsigned int D.30964;
  unsigned int D.30967;
  unsigned int D.30968;
  unsigned int D.30970;
  int D.30971;
  unsigned int D.30972;
  int D.30973;
  unsigned int D.30974;
  struct MonoObject * D.30975;
  struct MonoType * D.30978;
  struct MonoClass * D.30979;
  int D.30983;
  unsigned int D.30984;
  int D.30986;
  long unsigned int D.30987;
  struct MonoExceptionClause * D.30988;
  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.30947 = num_clauses * 32;
  clauses = image_g_malloc0 (image, D.30947);
  clause_index = 0;
  D.30948 = ilgen->ex_handlers;
  D.30949 = mono_array_length (D.30948);
  D.30950 = (unsigned int) D.30949;
  D.30951 = D.30950 + 4294967295;
  i = (int) D.30951;
  goto <D.19495>;
  <D.19494>:
  D.30948 = ilgen->ex_handlers;
  D.30952 = (long unsigned int) i;
  ex_info = mono_array_addr_with_size (D.30948, 24, D.30952);
  D.30953 = ex_info->start;
  D.30954 = ex_info->len;
  D.30955 = D.30953 + D.30954;
  finally_start = (guint32) D.30955;
  D.30956 = ex_info->handlers;
  if (D.30956 == 0B) goto <D.30957>; else goto <D.30958>;
  <D.30957>:
  // predicted unlikely by continue predictor.
  goto <D.19490>;
  <D.30958>:
  j = 0;
  goto <D.19492>;
  <D.19491>:
  D.30956 = ex_info->handlers;
  D.30959 = (long unsigned int) j;
  ex_block = mono_array_addr_with_size (D.30956, 24, D.30959);
  D.30960 = (long unsigned int) clause_index;
  D.30961 = D.30960 * 32;
  clause = clauses + D.30961;
  D.30962 = ex_block->type;
  D.30963 = (unsigned int) D.30962;
  clause->flags = D.30963;
  D.30953 = ex_info->start;
  D.30964 = (unsigned int) D.30953;
  clause->try_offset = D.30964;
  D.30962 = ex_block->type;
  if (D.30962 == 2) goto <D.30965>; else goto <D.30966>;
  <D.30965>:
  D.30953 = ex_info->start;
  D.30967 = (unsigned int) D.30953;
  D.30968 = finally_start - D.30967;
  clause->try_len = D.30968;
  goto <D.30969>;
  <D.30966>:
  D.30954 = ex_info->len;
  D.30970 = (unsigned int) D.30954;
  clause->try_len = D.30970;
  <D.30969>:
  D.30971 = ex_block->start;
  D.30972 = (unsigned int) D.30971;
  clause->handler_offset = D.30972;
  D.30973 = ex_block->len;
  D.30974 = (unsigned int) D.30973;
  clause->handler_len = D.30974;
  D.30975 = ex_block->extype;
  if (D.30975 != 0B) goto <D.30976>; else goto <D.30977>;
  <D.30976>:
  D.30975 = ex_block->extype;
  D.30978 = mono_reflection_type_get_handle (D.30975);
  D.30979 = mono_class_from_mono_type (D.30978);
  clause->data.catch_class = D.30979;
  goto <D.30980>;
  <D.30977>:
  D.30962 = ex_block->type;
  if (D.30962 == 1) goto <D.30981>; else goto <D.30982>;
  <D.30981>:
  D.30983 = ex_block->filter_offset;
  D.30984 = (unsigned int) D.30983;
  clause->data.filter_offset = D.30984;
  goto <D.30985>;
  <D.30982>:
  clause->data.filter_offset = 0;
  <D.30985>:
  <D.30980>:
  D.30971 = ex_block->start;
  D.30973 = ex_block->len;
  D.30986 = D.30971 + D.30973;
  finally_start = (guint32) D.30986;
  clause_index = clause_index + 1;
  j = j + 1;
  <D.19492>:
  D.30959 = (long unsigned int) j;
  D.30956 = ex_info->handlers;
  D.30987 = mono_array_length (D.30956);
  if (D.30959 < D.30987) goto <D.19491>; else goto <D.19493>;
  <D.19493>:
  <D.19490>:
  i = i + -1;
  <D.19495>:
  if (i >= 0) goto <D.19494>; else goto <D.19496>;
  <D.19496>:
  D.30988 = clauses;
  return D.30988;
}


image_g_malloc (struct MonoImage * image, guint size)
{
  void * D.30992;
  long unsigned int D.30993;

  if (image != 0B) goto <D.30990>; else goto <D.30991>;
  <D.30990>:
  D.30992 = mono_image_alloc (image, size);
  return D.30992;
  <D.30991>:
  D.30993 = (long unsigned int) size;
  D.30992 = monoeg_malloc (D.30993);
  return D.30992;
}


mono_custom_attrs_from_builders (struct MonoImage * alloc_img, struct MonoImage * image, struct MonoArray * cattrs)
{
  struct MonoCustomAttrInfo * D.30997;
  long unsigned int D.30998;
  long unsigned int D.30999;
  char * D.31000;
  int D.31001;
  long unsigned int D.31004;
  unsigned int D.31005;
  unsigned int D.31006;
  unsigned int D.31007;
  _Bool D.31008;
  int D.31009;
  char * D.31010;
  int D.31011;
  struct MonoArray * D.31014;
  long unsigned int D.31015;
  unsigned int D.31016;
  char * D.31017;
  long unsigned int D.31018;
  struct MonoReflectionMethod * D.31019;
  struct MonoMethod * D.31020;
  long unsigned int D.31021;
  unsigned int D.31022;
  int i;
  int index;
  int count;
  int not_visible;
  struct MonoCustomAttrInfo * ainfo;
  struct MonoReflectionCustomAttr * cattr;

  if (cattrs == 0B) goto <D.30995>; else goto <D.30996>;
  <D.30995>:
  D.30997 = 0B;
  return D.30997;
  <D.30996>:
  D.30998 = mono_array_length (cattrs);
  count = (int) D.30998;
  not_visible = 0;
  i = 0;
  goto <D.19567>;
  <D.19566>:
  D.30999 = (long unsigned int) i;
  D.31000 = mono_array_addr_with_size (cattrs, 8, D.30999);
  cattr = MEM[(void * *)D.31000];
  D.31001 = custom_attr_visible (image, cattr);
  if (D.31001 == 0) goto <D.31002>; else goto <D.31003>;
  <D.31002>:
  not_visible = not_visible + 1;
  <D.31003>:
  i = i + 1;
  <D.19567>:
  if (i < count) goto <D.19566>; else goto <D.19568>;
  <D.19568>:
  count = count - not_visible;
  D.31004 = (long unsigned int) count;
  D.31005 = (unsigned int) D.31004;
  D.31006 = D.31005 * 24;
  D.31007 = D.31006 + 16;
  ainfo = image_g_malloc0 (alloc_img, D.31007);
  ainfo->image = image;
  ainfo->num_attrs = count;
  D.31008 = alloc_img != 0B;
  D.31009 = (int) D.31008;
  ainfo->cached = D.31009;
  index = 0;
  i = 0;
  goto <D.19571>;
  <D.19570>:
  D.30999 = (long unsigned int) i;
  D.31010 = mono_array_addr_with_size (cattrs, 8, D.30999);
  cattr = MEM[(void * *)D.31010];
  D.31011 = custom_attr_visible (image, cattr);
  if (D.31011 != 0) goto <D.31012>; else goto <D.31013>;
  <D.31012>:
  {
    unsigned char * saved;

    D.31014 = cattr->data;
    D.31015 = mono_array_length (D.31014);
    D.31016 = (unsigned int) D.31015;
    saved = mono_image_alloc (image, D.31016);
    D.31014 = cattr->data;
    D.31017 = mono_array_addr_with_size (D.31014, 1, 0);
    D.31014 = cattr->data;
    D.31018 = mono_array_length (D.31014);
    memcpy (saved, D.31017, D.31018);
    D.31019 = cattr->ctor;
    D.31020 = D.31019->method;
    ainfo->attrs[index].ctor = D.31020;
    ainfo->attrs[index].data = saved;
    D.31014 = cattr->data;
    D.31021 = mono_array_length (D.31014);
    D.31022 = (unsigned int) D.31021;
    ainfo->attrs[index].data_size = D.31022;
    index = index + 1;
  }
  <D.31013>:
  i = i + 1;
  <D.19571>:
  if (i < count) goto <D.19570>; else goto <D.19572>;
  <D.19572>:
  D.30997 = ainfo;
  return D.30997;
}


custom_attr_visible (struct MonoImage * image, struct MonoReflectionCustomAttr * cattr)
{
  struct MonoReflectionMethod * D.31024;
  struct MonoMethod * D.31025;
  struct MonoClass * D.31028;
  struct MonoImage * D.31029;
  unsigned int D.31032;
  int D.31033;
  unsigned int visibility.193;
  unsigned int D.31035;
  gboolean D.31038;

  D.31024 = cattr->ctor;
  D.31025 = D.31024->method;
  if (D.31025 != 0B) goto <D.31026>; else goto <D.31027>;
  <D.31026>:
  D.31024 = cattr->ctor;
  D.31025 = D.31024->method;
  D.31028 = D.31025->klass;
  D.31029 = D.31028->image;
  if (D.31029 != image) goto <D.31030>; else goto <D.31031>;
  <D.31030>:
  {
    int visibility;

    D.31024 = cattr->ctor;
    D.31025 = D.31024->method;
    D.31028 = D.31025->klass;
    D.31032 = D.31028->flags;
    D.31033 = (int) D.31032;
    visibility = D.31033 & 7;
    visibility.193 = (unsigned int) visibility;
    D.31035 = visibility.193 + 4294967295;
    if (D.31035 > 1) goto <D.31036>; else goto <D.31037>;
    <D.31036>:
    D.31038 = 0;
    return D.31038;
    <D.31037>:
  }
  <D.31031>:
  <D.31027>:
  D.31038 = 1;
  return D.31038;
}


mono_marshal_spec_from_builder (struct MonoImage * image, struct MonoAssembly * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.31040;
  <unnamed type> D.31041;
  int D.31042;
  <unnamed type> D.31043;
  unsigned char D.31044;
  int D.31047;
  short int D.31048;
  int D.31049;
  _Bool D.31050;
  short int D.31051;
  struct MonoObject * D.31053;
  struct MonoType * D.31056;
  char * D.31057;
  struct MonoString * D.31058;
  char * D.31061;
  struct MonoMarshalSpec * D.31062;
  struct MonoMarshalSpec * res;

  res = image_g_malloc0 (image, 24);
  D.31040 = minfo->type;
  D.31041 = (<unnamed type>) D.31040;
  res->native = D.31041;
  D.31040 = minfo->type;
  switch (D.31040) <default: <D.23736>, case 23: <D.23733>, case 30: <D.23734>, case 42: <D.23731>, case 44: <D.23735>>
  <D.23731>:
  D.31042 = minfo->eltype;
  D.31043 = (<unnamed type>) D.31042;
  res->data.array_data.elem_type = D.31043;
  D.31044 = minfo->has_size;
  if (D.31044 != 0) goto <D.31045>; else goto <D.31046>;
  <D.31045>:
  D.31047 = minfo->param_num;
  D.31048 = (short int) D.31047;
  res->data.array_data.param_num = D.31048;
  D.31049 = minfo->count;
  res->data.array_data.num_elem = D.31049;
  D.31047 = minfo->param_num;
  D.31050 = D.31047 != -1;
  D.31051 = (short int) D.31050;
  res->data.array_data.elem_mult = D.31051;
  goto <D.31052>;
  <D.31046>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  <D.31052>:
  goto <D.23732>;
  <D.23733>:
  <D.23734>:
  D.31049 = minfo->count;
  res->data.array_data.num_elem = D.31049;
  goto <D.23732>;
  <D.23735>:
  D.31053 = minfo->marshaltyperef;
  if (D.31053 != 0B) goto <D.31054>; else goto <D.31055>;
  <D.31054>:
  D.31053 = minfo->marshaltyperef;
  D.31056 = mono_reflection_type_get_handle (D.31053);
  D.31057 = type_get_fully_qualified_name (D.31056);
  res->data.custom_data.custom_name = D.31057;
  <D.31055>:
  D.31058 = minfo->mcookie;
  if (D.31058 != 0B) goto <D.31059>; else goto <D.31060>;
  <D.31059>:
  D.31058 = minfo->mcookie;
  D.31061 = mono_string_to_utf8 (D.31058);
  res->data.custom_data.cookie = D.31061;
  <D.31060>:
  goto <D.23732>;
  <D.23736>:
  goto <D.23732>;
  <D.23732>:
  D.31062 = res;
  return D.31062;
}


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

  if (cattrs == 0B) goto <D.31065>; else goto <D.31067>;
  <D.31067>:
  D.31068 = mono_array_length (cattrs);
  if (D.31068 == 0) goto <D.31065>; else goto <D.31066>;
  <D.31065>:
  return;
  <D.31066>:
  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.31069>; else goto <D.31070>;
  <D.31069>:
  mono_custom_attrs_free (tmp);
  <D.31070>:
  mono_image_property_insert (image, obj, 4096, ainfo);
  mono_loader_unlock ();
}


ctorbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoImage * D.31072;
  struct MonoMethod * D.31073;
  struct MonoMethod * D.31074;
  struct MonoArray * D.31075;
  int D.31076;
  struct MonoGenericContainer * D.31079;
  struct MonoMethod * D.31082;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.31072 = klass->image;
      sig = ctor_builder_to_signature (D.31072, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.31073 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.31073;
      D.31072 = klass->image;
      D.31074 = mb->mhandle;
      D.31075 = mb->cattrs;
      mono_save_custom_attrs (D.31072, D.31074, D.31075);
      D.31072 = klass->image;
      D.31076 = MEM[(struct MonoDynamicImage *)D.31072].save;
      if (D.31076 == 0) goto <D.31077>; else goto <D.31078>;
      <D.31077>:
      D.31079 = klass->generic_container;
      if (D.31079 == 0B) goto <D.31080>; else goto <D.31081>;
      <D.31080>:
      mb->ilgen = 0B;
      <D.31081>:
      <D.31078>:
      D.31082 = mb->mhandle;
      return D.31082;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


ctor_builder_to_signature (struct MonoImage * image, struct MonoReflectionCtorBuilder * ctor)
{
  struct MonoArray * D.31085;
  unsigned int D.31086;
  unsigned int D.31087;
  _Bool D.31088;
  struct MonoClass * D.31089;
  struct MonoType * D.31090;
  struct MonoMethodSignature * D.31091;
  struct MonoMethodSignature * sig;

  D.31085 = ctor->parameters;
  sig = parameters_to_signature (image, D.31085);
  D.31086 = ctor->attrs;
  D.31087 = D.31086 & 16;
  D.31088 = D.31087 == 0;
  sig->hasthis = D.31088;
  D.31089 = mono_defaults.void_class;
  D.31090 = &D.31089->byval_arg;
  sig->ret = D.31090;
  D.31091 = sig;
  return D.31091;
}


inflate_mono_method (struct MonoClass * klass, struct MonoMethod * method, struct MonoObject * obj)
{
  struct MonoGenericClass * D.31093;
  struct MonoMethod * D.31096;
  unsigned int D.31099;
  struct MonoMethod * * D.31101;
  long unsigned int D.31103;
  long unsigned int D.31104;
  struct MonoMethod * * D.31105;
  struct MonoMethod * D.31106;
  long unsigned int D.31107;
  long unsigned int D.31108;
  _Bool D.31109;
  long int D.31110;
  long int D.31111;
  struct MonoMethod * D.31114;
  unsigned int i.194;
  _Bool D.31117;
  long int D.31118;
  long int D.31119;
  long unsigned int D.31122;
  long unsigned int D.31123;
  struct MonoClass * D.31126;
  struct MonoImage * D.31127;
  long unsigned int D.31128;
  long unsigned int D.31129;
  struct MonoGHashTable * D.31132;
  struct MonoMethodInflated * imethod;
  struct MonoGenericContext * context;
  int i;

  D.31093 = klass->generic_class;
  if (D.31093 == 0B) goto <D.31094>; else goto <D.31095>;
  <D.31094>:
  D.31096 = method;
  return D.31096;
  <D.31095>:
  context = mono_class_get_context (klass);
  D.31099 = klass->method.count;
  if (D.31099 != 0) goto <D.31100>; else goto <D.31097>;
  <D.31100>:
  D.31101 = klass->methods;
  if (D.31101 != 0B) goto <D.31102>; else goto <D.31097>;
  <D.31102>:
  i = 0;
  goto <D.23895>;
  <D.23894>:
  D.31101 = klass->methods;
  D.31103 = (long unsigned int) i;
  D.31104 = D.31103 * 8;
  D.31105 = D.31101 + D.31104;
  D.31106 = *D.31105;
  D.31107 = BIT_FIELD_REF <*D.31106, 64, 256>;
  D.31108 = D.31107 & 4096;
  D.31109 = D.31108 == 0;
  D.31110 = (long int) D.31109;
  D.31111 = __builtin_expect (D.31110, 0);
  if (D.31111 != 0) goto <D.31112>; else goto <D.31113>;
  <D.31112>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10611, "klass->methods [i]->is_inflated");
  <D.31113>:
  D.31101 = klass->methods;
  D.31103 = (long unsigned int) i;
  D.31104 = D.31103 * 8;
  D.31105 = D.31101 + D.31104;
  D.31106 = *D.31105;
  D.31114 = MEM[(struct MonoMethodInflated *)D.31106].declaring;
  if (D.31114 == method) goto <D.23893>; else goto <D.31115>;
  <D.31115>:
  i = i + 1;
  <D.23895>:
  i.194 = (unsigned int) i;
  D.31099 = klass->method.count;
  if (i.194 < D.31099) goto <D.23894>; else goto <D.23893>;
  <D.23893>:
  i.194 = (unsigned int) i;
  D.31099 = klass->method.count;
  D.31117 = i.194 >= D.31099;
  D.31118 = (long int) D.31117;
  D.31119 = __builtin_expect (D.31118, 0);
  if (D.31119 != 0) goto <D.31120>; else goto <D.31121>;
  <D.31120>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10615, "i < klass->method.count");
  <D.31121>:
  D.31101 = klass->methods;
  D.31103 = (long unsigned int) i;
  D.31104 = D.31103 * 8;
  D.31105 = D.31101 + D.31104;
  imethod = *D.31105;
  goto <D.31098>;
  <D.31097>:
  imethod = mono_class_inflate_generic_method_full (method, klass, context);
  <D.31098>:
  D.31122 = BIT_FIELD_REF <*method, 64, 256>;
  D.31123 = D.31122 & 2048;
  if (D.31123 != 0) goto <D.31124>; else goto <D.31125>;
  <D.31124>:
  D.31126 = method->klass;
  D.31127 = D.31126->image;
  D.31128 = BIT_FIELD_REF <*D.31127, 64, 192>;
  D.31129 = D.31128 & 34359738368;
  if (D.31129 != 0) goto <D.31130>; else goto <D.31131>;
  <D.31130>:
  {
    struct MonoDynamicImage * image;

    D.31126 = method->klass;
    image = D.31126->image;
    mono_image_lock (image);
    D.31132 = image->generic_def_objects;
    mono_g_hash_table_insert (D.31132, imethod, obj);
    mono_image_unlock (image);
  }
  <D.31131>:
  <D.31125>:
  D.31096 = imethod;
  return D.31096;
}


is_sre_method_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.195;
  gboolean D.31137;
  _Bool D.31138;
  int D.31139;
  int D.23140;
  int iftmp.196;
  int D.23136;
  const char[14] * D.31145;
  unsigned char D.31146;
  int D.31147;
  unsigned char D.31148;
  int D.31149;
  const unsigned char * D.31154;
  unsigned char D.31155;
  int D.31156;
  const unsigned char * D.31157;
  unsigned char D.31158;
  int D.31159;
  const unsigned char * D.31164;
  unsigned char D.31165;
  int D.31166;
  const unsigned char * D.31167;
  unsigned char D.31168;
  int D.31169;
  const unsigned char * D.31174;
  unsigned char D.31175;
  int D.31176;
  const unsigned char * D.31177;
  unsigned char D.31178;
  int D.31179;
  const char * D.31181;
  int D.23149;
  int iftmp.197;
  int D.23145;
  const char[23] * D.31187;
  unsigned char D.31188;
  int D.31189;
  unsigned char D.31190;
  int D.31191;
  const unsigned char * D.31196;
  unsigned char D.31197;
  int D.31198;
  const unsigned char * D.31199;
  unsigned char D.31200;
  int D.31201;
  const unsigned char * D.31206;
  unsigned char D.31207;
  int D.31208;
  const unsigned char * D.31209;
  unsigned char D.31210;
  int D.31211;
  const unsigned char * D.31216;
  unsigned char D.31217;
  int D.31218;
  const unsigned char * D.31219;
  unsigned char D.31220;
  int D.31221;
  const char * D.31223;

  {
    static struct MonoClass * cached_class;

    cached_class.195 = cached_class;
    if (cached_class.195 != 0B) goto <D.31135>; else goto <D.31136>;
    <D.31135>:
    cached_class.195 = cached_class;
    D.31138 = cached_class.195 == class;
    D.31137 = (gboolean) D.31138;
    return D.31137;
    <D.31136>:
    D.31139 = is_corlib_type (class);
    if (D.31139 != 0) goto <D.31140>; else goto <D.31141>;
    <D.31140>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31145 = "MethodBuilder";
        D.31146 = MEM[(const unsigned char *)D.31145];
        D.31147 = (int) D.31146;
        D.31148 = *__s2;
        D.31149 = (int) D.31148;
        __result = D.31147 - D.31149;
        {
          if (__s1_len != 0) goto <D.31150>; else goto <D.31151>;
          <D.31150>:
          if (__result == 0) goto <D.31152>; else goto <D.31153>;
          <D.31152>:
          D.31154 = &MEM[(void *)"MethodBuilder" + 1B];
          D.31155 = *D.31154;
          D.31156 = (int) D.31155;
          D.31157 = __s2 + 1;
          D.31158 = *D.31157;
          D.31159 = (int) D.31158;
          __result = D.31156 - D.31159;
          if (__s1_len > 1) goto <D.31160>; else goto <D.31161>;
          <D.31160>:
          if (__result == 0) goto <D.31162>; else goto <D.31163>;
          <D.31162>:
          D.31164 = &MEM[(void *)"MethodBuilder" + 2B];
          D.31165 = *D.31164;
          D.31166 = (int) D.31165;
          D.31167 = __s2 + 2;
          D.31168 = *D.31167;
          D.31169 = (int) D.31168;
          __result = D.31166 - D.31169;
          if (__s1_len > 2) goto <D.31170>; else goto <D.31171>;
          <D.31170>:
          if (__result == 0) goto <D.31172>; else goto <D.31173>;
          <D.31172>:
          D.31174 = &MEM[(void *)"MethodBuilder" + 3B];
          D.31175 = *D.31174;
          D.31176 = (int) D.31175;
          D.31177 = __s2 + 3;
          D.31178 = *D.31177;
          D.31179 = (int) D.31178;
          __result = D.31176 - D.31179;
          <D.31173>:
          <D.31171>:
          <D.31163>:
          <D.31161>:
          <D.31153>:
          <D.31151>:
        }
        D.23136 = __result;
      }
      iftmp.196 = D.23136;
      goto <D.31180>;
      <D.31144>:
      D.31181 = class->name;
      iftmp.196 = __builtin_strcmp ("MethodBuilder", D.31181);
      <D.31180>:
      D.23140 = iftmp.196;
    }
    if (D.23140 == 0) goto <D.31182>; else goto <D.31183>;
    <D.31182>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31187 = "System.Reflection.Emit";
        D.31188 = MEM[(const unsigned char *)D.31187];
        D.31189 = (int) D.31188;
        D.31190 = *__s2;
        D.31191 = (int) D.31190;
        __result = D.31189 - D.31191;
        {
          if (__s1_len != 0) goto <D.31192>; else goto <D.31193>;
          <D.31192>:
          if (__result == 0) goto <D.31194>; else goto <D.31195>;
          <D.31194>:
          D.31196 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31197 = *D.31196;
          D.31198 = (int) D.31197;
          D.31199 = __s2 + 1;
          D.31200 = *D.31199;
          D.31201 = (int) D.31200;
          __result = D.31198 - D.31201;
          if (__s1_len > 1) goto <D.31202>; else goto <D.31203>;
          <D.31202>:
          if (__result == 0) goto <D.31204>; else goto <D.31205>;
          <D.31204>:
          D.31206 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31207 = *D.31206;
          D.31208 = (int) D.31207;
          D.31209 = __s2 + 2;
          D.31210 = *D.31209;
          D.31211 = (int) D.31210;
          __result = D.31208 - D.31211;
          if (__s1_len > 2) goto <D.31212>; else goto <D.31213>;
          <D.31212>:
          if (__result == 0) goto <D.31214>; else goto <D.31215>;
          <D.31214>:
          D.31216 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31217 = *D.31216;
          D.31218 = (int) D.31217;
          D.31219 = __s2 + 3;
          D.31220 = *D.31219;
          D.31221 = (int) D.31220;
          __result = D.31218 - D.31221;
          <D.31215>:
          <D.31213>:
          <D.31205>:
          <D.31203>:
          <D.31195>:
          <D.31193>:
        }
        D.23145 = __result;
      }
      iftmp.197 = D.23145;
      goto <D.31222>;
      <D.31186>:
      D.31223 = class->name_space;
      iftmp.197 = __builtin_strcmp ("System.Reflection.Emit", D.31223);
      <D.31222>:
      D.23149 = iftmp.197;
    }
    if (D.23149 == 0) goto <D.31224>; else goto <D.31225>;
    <D.31224>:
    cached_class = class;
    D.31137 = 1;
    return D.31137;
    <D.31225>:
    <D.31183>:
    <D.31141>:
    D.31137 = 0;
    return D.31137;
  }
}


is_sr_mono_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.198;
  gboolean D.31230;
  _Bool D.31231;
  int D.31232;
  int D.23386;
  int iftmp.199;
  int D.23382;
  const char[11] * D.31238;
  unsigned char D.31239;
  int D.31240;
  unsigned char D.31241;
  int D.31242;
  const unsigned char * D.31247;
  unsigned char D.31248;
  int D.31249;
  const unsigned char * D.31250;
  unsigned char D.31251;
  int D.31252;
  const unsigned char * D.31257;
  unsigned char D.31258;
  int D.31259;
  const unsigned char * D.31260;
  unsigned char D.31261;
  int D.31262;
  const unsigned char * D.31267;
  unsigned char D.31268;
  int D.31269;
  const unsigned char * D.31270;
  unsigned char D.31271;
  int D.31272;
  const char * D.31274;
  int D.23395;
  int iftmp.200;
  int D.23391;
  const char[18] * D.31280;
  unsigned char D.31281;
  int D.31282;
  unsigned char D.31283;
  int D.31284;
  const unsigned char * D.31289;
  unsigned char D.31290;
  int D.31291;
  const unsigned char * D.31292;
  unsigned char D.31293;
  int D.31294;
  const unsigned char * D.31299;
  unsigned char D.31300;
  int D.31301;
  const unsigned char * D.31302;
  unsigned char D.31303;
  int D.31304;
  const unsigned char * D.31309;
  unsigned char D.31310;
  int D.31311;
  const unsigned char * D.31312;
  unsigned char D.31313;
  int D.31314;
  const char * D.31316;

  {
    static struct MonoClass * cached_class;

    cached_class.198 = cached_class;
    if (cached_class.198 != 0B) goto <D.31228>; else goto <D.31229>;
    <D.31228>:
    cached_class.198 = cached_class;
    D.31231 = cached_class.198 == class;
    D.31230 = (gboolean) D.31231;
    return D.31230;
    <D.31229>:
    D.31232 = is_corlib_type (class);
    if (D.31232 != 0) goto <D.31233>; else goto <D.31234>;
    <D.31233>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31238 = "MonoMethod";
        D.31239 = MEM[(const unsigned char *)D.31238];
        D.31240 = (int) D.31239;
        D.31241 = *__s2;
        D.31242 = (int) D.31241;
        __result = D.31240 - D.31242;
        {
          if (__s1_len != 0) goto <D.31243>; else goto <D.31244>;
          <D.31243>:
          if (__result == 0) goto <D.31245>; else goto <D.31246>;
          <D.31245>:
          D.31247 = &MEM[(void *)"MonoMethod" + 1B];
          D.31248 = *D.31247;
          D.31249 = (int) D.31248;
          D.31250 = __s2 + 1;
          D.31251 = *D.31250;
          D.31252 = (int) D.31251;
          __result = D.31249 - D.31252;
          if (__s1_len > 1) goto <D.31253>; else goto <D.31254>;
          <D.31253>:
          if (__result == 0) goto <D.31255>; else goto <D.31256>;
          <D.31255>:
          D.31257 = &MEM[(void *)"MonoMethod" + 2B];
          D.31258 = *D.31257;
          D.31259 = (int) D.31258;
          D.31260 = __s2 + 2;
          D.31261 = *D.31260;
          D.31262 = (int) D.31261;
          __result = D.31259 - D.31262;
          if (__s1_len > 2) goto <D.31263>; else goto <D.31264>;
          <D.31263>:
          if (__result == 0) goto <D.31265>; else goto <D.31266>;
          <D.31265>:
          D.31267 = &MEM[(void *)"MonoMethod" + 3B];
          D.31268 = *D.31267;
          D.31269 = (int) D.31268;
          D.31270 = __s2 + 3;
          D.31271 = *D.31270;
          D.31272 = (int) D.31271;
          __result = D.31269 - D.31272;
          <D.31266>:
          <D.31264>:
          <D.31256>:
          <D.31254>:
          <D.31246>:
          <D.31244>:
        }
        D.23382 = __result;
      }
      iftmp.199 = D.23382;
      goto <D.31273>;
      <D.31237>:
      D.31274 = class->name;
      iftmp.199 = __builtin_strcmp ("MonoMethod", D.31274);
      <D.31273>:
      D.23386 = iftmp.199;
    }
    if (D.23386 == 0) goto <D.31275>; else goto <D.31276>;
    <D.31275>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31280 = "System.Reflection";
        D.31281 = MEM[(const unsigned char *)D.31280];
        D.31282 = (int) D.31281;
        D.31283 = *__s2;
        D.31284 = (int) D.31283;
        __result = D.31282 - D.31284;
        {
          if (__s1_len != 0) goto <D.31285>; else goto <D.31286>;
          <D.31285>:
          if (__result == 0) goto <D.31287>; else goto <D.31288>;
          <D.31287>:
          D.31289 = &MEM[(void *)"System.Reflection" + 1B];
          D.31290 = *D.31289;
          D.31291 = (int) D.31290;
          D.31292 = __s2 + 1;
          D.31293 = *D.31292;
          D.31294 = (int) D.31293;
          __result = D.31291 - D.31294;
          if (__s1_len > 1) goto <D.31295>; else goto <D.31296>;
          <D.31295>:
          if (__result == 0) goto <D.31297>; else goto <D.31298>;
          <D.31297>:
          D.31299 = &MEM[(void *)"System.Reflection" + 2B];
          D.31300 = *D.31299;
          D.31301 = (int) D.31300;
          D.31302 = __s2 + 2;
          D.31303 = *D.31302;
          D.31304 = (int) D.31303;
          __result = D.31301 - D.31304;
          if (__s1_len > 2) goto <D.31305>; else goto <D.31306>;
          <D.31305>:
          if (__result == 0) goto <D.31307>; else goto <D.31308>;
          <D.31307>:
          D.31309 = &MEM[(void *)"System.Reflection" + 3B];
          D.31310 = *D.31309;
          D.31311 = (int) D.31310;
          D.31312 = __s2 + 3;
          D.31313 = *D.31312;
          D.31314 = (int) D.31313;
          __result = D.31311 - D.31314;
          <D.31308>:
          <D.31306>:
          <D.31298>:
          <D.31296>:
          <D.31288>:
          <D.31286>:
        }
        D.23391 = __result;
      }
      iftmp.200 = D.23391;
      goto <D.31315>;
      <D.31279>:
      D.31316 = class->name_space;
      iftmp.200 = __builtin_strcmp ("System.Reflection", D.31316);
      <D.31315>:
      D.23395 = iftmp.200;
    }
    if (D.23395 == 0) goto <D.31317>; else goto <D.31318>;
    <D.31317>:
    cached_class = class;
    D.31230 = 1;
    return D.31230;
    <D.31318>:
    <D.31276>:
    <D.31234>:
    D.31230 = 0;
    return D.31230;
  }
}


is_sre_array (struct MonoClass * class)
{
  struct MonoClass * cached_class.201;
  gboolean D.31323;
  _Bool D.31324;
  int D.31325;
  int D.23030;
  int iftmp.202;
  int D.23026;
  const char[10] * D.31331;
  unsigned char D.31332;
  int D.31333;
  unsigned char D.31334;
  int D.31335;
  const unsigned char * D.31340;
  unsigned char D.31341;
  int D.31342;
  const unsigned char * D.31343;
  unsigned char D.31344;
  int D.31345;
  const unsigned char * D.31350;
  unsigned char D.31351;
  int D.31352;
  const unsigned char * D.31353;
  unsigned char D.31354;
  int D.31355;
  const unsigned char * D.31360;
  unsigned char D.31361;
  int D.31362;
  const unsigned char * D.31363;
  unsigned char D.31364;
  int D.31365;
  const char * D.31367;
  int D.23039;
  int iftmp.203;
  int D.23035;
  const char[23] * D.31373;
  unsigned char D.31374;
  int D.31375;
  unsigned char D.31376;
  int D.31377;
  const unsigned char * D.31382;
  unsigned char D.31383;
  int D.31384;
  const unsigned char * D.31385;
  unsigned char D.31386;
  int D.31387;
  const unsigned char * D.31392;
  unsigned char D.31393;
  int D.31394;
  const unsigned char * D.31395;
  unsigned char D.31396;
  int D.31397;
  const unsigned char * D.31402;
  unsigned char D.31403;
  int D.31404;
  const unsigned char * D.31405;
  unsigned char D.31406;
  int D.31407;
  const char * D.31409;

  {
    static struct MonoClass * cached_class;

    cached_class.201 = cached_class;
    if (cached_class.201 != 0B) goto <D.31321>; else goto <D.31322>;
    <D.31321>:
    cached_class.201 = cached_class;
    D.31324 = cached_class.201 == class;
    D.31323 = (gboolean) D.31324;
    return D.31323;
    <D.31322>:
    D.31325 = is_corlib_type (class);
    if (D.31325 != 0) goto <D.31326>; else goto <D.31327>;
    <D.31326>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31331 = "ArrayType";
        D.31332 = MEM[(const unsigned char *)D.31331];
        D.31333 = (int) D.31332;
        D.31334 = *__s2;
        D.31335 = (int) D.31334;
        __result = D.31333 - D.31335;
        {
          if (__s1_len != 0) goto <D.31336>; else goto <D.31337>;
          <D.31336>:
          if (__result == 0) goto <D.31338>; else goto <D.31339>;
          <D.31338>:
          D.31340 = &MEM[(void *)"ArrayType" + 1B];
          D.31341 = *D.31340;
          D.31342 = (int) D.31341;
          D.31343 = __s2 + 1;
          D.31344 = *D.31343;
          D.31345 = (int) D.31344;
          __result = D.31342 - D.31345;
          if (__s1_len > 1) goto <D.31346>; else goto <D.31347>;
          <D.31346>:
          if (__result == 0) goto <D.31348>; else goto <D.31349>;
          <D.31348>:
          D.31350 = &MEM[(void *)"ArrayType" + 2B];
          D.31351 = *D.31350;
          D.31352 = (int) D.31351;
          D.31353 = __s2 + 2;
          D.31354 = *D.31353;
          D.31355 = (int) D.31354;
          __result = D.31352 - D.31355;
          if (__s1_len > 2) goto <D.31356>; else goto <D.31357>;
          <D.31356>:
          if (__result == 0) goto <D.31358>; else goto <D.31359>;
          <D.31358>:
          D.31360 = &MEM[(void *)"ArrayType" + 3B];
          D.31361 = *D.31360;
          D.31362 = (int) D.31361;
          D.31363 = __s2 + 3;
          D.31364 = *D.31363;
          D.31365 = (int) D.31364;
          __result = D.31362 - D.31365;
          <D.31359>:
          <D.31357>:
          <D.31349>:
          <D.31347>:
          <D.31339>:
          <D.31337>:
        }
        D.23026 = __result;
      }
      iftmp.202 = D.23026;
      goto <D.31366>;
      <D.31330>:
      D.31367 = class->name;
      iftmp.202 = __builtin_strcmp ("ArrayType", D.31367);
      <D.31366>:
      D.23030 = iftmp.202;
    }
    if (D.23030 == 0) goto <D.31368>; else goto <D.31369>;
    <D.31368>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31373 = "System.Reflection.Emit";
        D.31374 = MEM[(const unsigned char *)D.31373];
        D.31375 = (int) D.31374;
        D.31376 = *__s2;
        D.31377 = (int) D.31376;
        __result = D.31375 - D.31377;
        {
          if (__s1_len != 0) goto <D.31378>; else goto <D.31379>;
          <D.31378>:
          if (__result == 0) goto <D.31380>; else goto <D.31381>;
          <D.31380>:
          D.31382 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31383 = *D.31382;
          D.31384 = (int) D.31383;
          D.31385 = __s2 + 1;
          D.31386 = *D.31385;
          D.31387 = (int) D.31386;
          __result = D.31384 - D.31387;
          if (__s1_len > 1) goto <D.31388>; else goto <D.31389>;
          <D.31388>:
          if (__result == 0) goto <D.31390>; else goto <D.31391>;
          <D.31390>:
          D.31392 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31393 = *D.31392;
          D.31394 = (int) D.31393;
          D.31395 = __s2 + 2;
          D.31396 = *D.31395;
          D.31397 = (int) D.31396;
          __result = D.31394 - D.31397;
          if (__s1_len > 2) goto <D.31398>; else goto <D.31399>;
          <D.31398>:
          if (__result == 0) goto <D.31400>; else goto <D.31401>;
          <D.31400>:
          D.31402 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31403 = *D.31402;
          D.31404 = (int) D.31403;
          D.31405 = __s2 + 3;
          D.31406 = *D.31405;
          D.31407 = (int) D.31406;
          __result = D.31404 - D.31407;
          <D.31401>:
          <D.31399>:
          <D.31391>:
          <D.31389>:
          <D.31381>:
          <D.31379>:
        }
        D.23035 = __result;
      }
      iftmp.203 = D.23035;
      goto <D.31408>;
      <D.31372>:
      D.31409 = class->name_space;
      iftmp.203 = __builtin_strcmp ("System.Reflection.Emit", D.31409);
      <D.31408>:
      D.23039 = iftmp.203;
    }
    if (D.23039 == 0) goto <D.31410>; else goto <D.31411>;
    <D.31410>:
    cached_class = class;
    D.31323 = 1;
    return D.31323;
    <D.31411>:
    <D.31369>:
    <D.31327>:
    D.31323 = 0;
    return D.31323;
  }
}


is_sre_byref (struct MonoClass * class)
{
  struct MonoClass * cached_class.204;
  gboolean D.31416;
  _Bool D.31417;
  int D.31418;
  int D.23052;
  int iftmp.205;
  int D.23048;
  const char[10] * D.31424;
  unsigned char D.31425;
  int D.31426;
  unsigned char D.31427;
  int D.31428;
  const unsigned char * D.31433;
  unsigned char D.31434;
  int D.31435;
  const unsigned char * D.31436;
  unsigned char D.31437;
  int D.31438;
  const unsigned char * D.31443;
  unsigned char D.31444;
  int D.31445;
  const unsigned char * D.31446;
  unsigned char D.31447;
  int D.31448;
  const unsigned char * D.31453;
  unsigned char D.31454;
  int D.31455;
  const unsigned char * D.31456;
  unsigned char D.31457;
  int D.31458;
  const char * D.31460;
  int D.23061;
  int iftmp.206;
  int D.23057;
  const char[23] * D.31466;
  unsigned char D.31467;
  int D.31468;
  unsigned char D.31469;
  int D.31470;
  const unsigned char * D.31475;
  unsigned char D.31476;
  int D.31477;
  const unsigned char * D.31478;
  unsigned char D.31479;
  int D.31480;
  const unsigned char * D.31485;
  unsigned char D.31486;
  int D.31487;
  const unsigned char * D.31488;
  unsigned char D.31489;
  int D.31490;
  const unsigned char * D.31495;
  unsigned char D.31496;
  int D.31497;
  const unsigned char * D.31498;
  unsigned char D.31499;
  int D.31500;
  const char * D.31502;

  {
    static struct MonoClass * cached_class;

    cached_class.204 = cached_class;
    if (cached_class.204 != 0B) goto <D.31414>; else goto <D.31415>;
    <D.31414>:
    cached_class.204 = cached_class;
    D.31417 = cached_class.204 == class;
    D.31416 = (gboolean) D.31417;
    return D.31416;
    <D.31415>:
    D.31418 = is_corlib_type (class);
    if (D.31418 != 0) goto <D.31419>; else goto <D.31420>;
    <D.31419>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31424 = "ByRefType";
        D.31425 = MEM[(const unsigned char *)D.31424];
        D.31426 = (int) D.31425;
        D.31427 = *__s2;
        D.31428 = (int) D.31427;
        __result = D.31426 - D.31428;
        {
          if (__s1_len != 0) goto <D.31429>; else goto <D.31430>;
          <D.31429>:
          if (__result == 0) goto <D.31431>; else goto <D.31432>;
          <D.31431>:
          D.31433 = &MEM[(void *)"ByRefType" + 1B];
          D.31434 = *D.31433;
          D.31435 = (int) D.31434;
          D.31436 = __s2 + 1;
          D.31437 = *D.31436;
          D.31438 = (int) D.31437;
          __result = D.31435 - D.31438;
          if (__s1_len > 1) goto <D.31439>; else goto <D.31440>;
          <D.31439>:
          if (__result == 0) goto <D.31441>; else goto <D.31442>;
          <D.31441>:
          D.31443 = &MEM[(void *)"ByRefType" + 2B];
          D.31444 = *D.31443;
          D.31445 = (int) D.31444;
          D.31446 = __s2 + 2;
          D.31447 = *D.31446;
          D.31448 = (int) D.31447;
          __result = D.31445 - D.31448;
          if (__s1_len > 2) goto <D.31449>; else goto <D.31450>;
          <D.31449>:
          if (__result == 0) goto <D.31451>; else goto <D.31452>;
          <D.31451>:
          D.31453 = &MEM[(void *)"ByRefType" + 3B];
          D.31454 = *D.31453;
          D.31455 = (int) D.31454;
          D.31456 = __s2 + 3;
          D.31457 = *D.31456;
          D.31458 = (int) D.31457;
          __result = D.31455 - D.31458;
          <D.31452>:
          <D.31450>:
          <D.31442>:
          <D.31440>:
          <D.31432>:
          <D.31430>:
        }
        D.23048 = __result;
      }
      iftmp.205 = D.23048;
      goto <D.31459>;
      <D.31423>:
      D.31460 = class->name;
      iftmp.205 = __builtin_strcmp ("ByRefType", D.31460);
      <D.31459>:
      D.23052 = iftmp.205;
    }
    if (D.23052 == 0) goto <D.31461>; else goto <D.31462>;
    <D.31461>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31466 = "System.Reflection.Emit";
        D.31467 = MEM[(const unsigned char *)D.31466];
        D.31468 = (int) D.31467;
        D.31469 = *__s2;
        D.31470 = (int) D.31469;
        __result = D.31468 - D.31470;
        {
          if (__s1_len != 0) goto <D.31471>; else goto <D.31472>;
          <D.31471>:
          if (__result == 0) goto <D.31473>; else goto <D.31474>;
          <D.31473>:
          D.31475 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31476 = *D.31475;
          D.31477 = (int) D.31476;
          D.31478 = __s2 + 1;
          D.31479 = *D.31478;
          D.31480 = (int) D.31479;
          __result = D.31477 - D.31480;
          if (__s1_len > 1) goto <D.31481>; else goto <D.31482>;
          <D.31481>:
          if (__result == 0) goto <D.31483>; else goto <D.31484>;
          <D.31483>:
          D.31485 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31486 = *D.31485;
          D.31487 = (int) D.31486;
          D.31488 = __s2 + 2;
          D.31489 = *D.31488;
          D.31490 = (int) D.31489;
          __result = D.31487 - D.31490;
          if (__s1_len > 2) goto <D.31491>; else goto <D.31492>;
          <D.31491>:
          if (__result == 0) goto <D.31493>; else goto <D.31494>;
          <D.31493>:
          D.31495 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31496 = *D.31495;
          D.31497 = (int) D.31496;
          D.31498 = __s2 + 3;
          D.31499 = *D.31498;
          D.31500 = (int) D.31499;
          __result = D.31497 - D.31500;
          <D.31494>:
          <D.31492>:
          <D.31484>:
          <D.31482>:
          <D.31474>:
          <D.31472>:
        }
        D.23057 = __result;
      }
      iftmp.206 = D.23057;
      goto <D.31501>;
      <D.31465>:
      D.31502 = class->name_space;
      iftmp.206 = __builtin_strcmp ("System.Reflection.Emit", D.31502);
      <D.31501>:
      D.23061 = iftmp.206;
    }
    if (D.23061 == 0) goto <D.31503>; else goto <D.31504>;
    <D.31503>:
    cached_class = class;
    D.31416 = 1;
    return D.31416;
    <D.31504>:
    <D.31462>:
    <D.31420>:
    D.31416 = 0;
    return D.31416;
  }
}


is_sre_pointer (struct MonoClass * class)
{
  struct MonoClass * cached_class.207;
  gboolean D.31509;
  _Bool D.31510;
  int D.31511;
  int D.23074;
  int iftmp.208;
  int D.23070;
  const char[12] * D.31517;
  unsigned char D.31518;
  int D.31519;
  unsigned char D.31520;
  int D.31521;
  const unsigned char * D.31526;
  unsigned char D.31527;
  int D.31528;
  const unsigned char * D.31529;
  unsigned char D.31530;
  int D.31531;
  const unsigned char * D.31536;
  unsigned char D.31537;
  int D.31538;
  const unsigned char * D.31539;
  unsigned char D.31540;
  int D.31541;
  const unsigned char * D.31546;
  unsigned char D.31547;
  int D.31548;
  const unsigned char * D.31549;
  unsigned char D.31550;
  int D.31551;
  const char * D.31553;
  int D.23083;
  int iftmp.209;
  int D.23079;
  const char[23] * D.31559;
  unsigned char D.31560;
  int D.31561;
  unsigned char D.31562;
  int D.31563;
  const unsigned char * D.31568;
  unsigned char D.31569;
  int D.31570;
  const unsigned char * D.31571;
  unsigned char D.31572;
  int D.31573;
  const unsigned char * D.31578;
  unsigned char D.31579;
  int D.31580;
  const unsigned char * D.31581;
  unsigned char D.31582;
  int D.31583;
  const unsigned char * D.31588;
  unsigned char D.31589;
  int D.31590;
  const unsigned char * D.31591;
  unsigned char D.31592;
  int D.31593;
  const char * D.31595;

  {
    static struct MonoClass * cached_class;

    cached_class.207 = cached_class;
    if (cached_class.207 != 0B) goto <D.31507>; else goto <D.31508>;
    <D.31507>:
    cached_class.207 = cached_class;
    D.31510 = cached_class.207 == class;
    D.31509 = (gboolean) D.31510;
    return D.31509;
    <D.31508>:
    D.31511 = is_corlib_type (class);
    if (D.31511 != 0) goto <D.31512>; else goto <D.31513>;
    <D.31512>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31517 = "PointerType";
        D.31518 = MEM[(const unsigned char *)D.31517];
        D.31519 = (int) D.31518;
        D.31520 = *__s2;
        D.31521 = (int) D.31520;
        __result = D.31519 - D.31521;
        {
          if (__s1_len != 0) goto <D.31522>; else goto <D.31523>;
          <D.31522>:
          if (__result == 0) goto <D.31524>; else goto <D.31525>;
          <D.31524>:
          D.31526 = &MEM[(void *)"PointerType" + 1B];
          D.31527 = *D.31526;
          D.31528 = (int) D.31527;
          D.31529 = __s2 + 1;
          D.31530 = *D.31529;
          D.31531 = (int) D.31530;
          __result = D.31528 - D.31531;
          if (__s1_len > 1) goto <D.31532>; else goto <D.31533>;
          <D.31532>:
          if (__result == 0) goto <D.31534>; else goto <D.31535>;
          <D.31534>:
          D.31536 = &MEM[(void *)"PointerType" + 2B];
          D.31537 = *D.31536;
          D.31538 = (int) D.31537;
          D.31539 = __s2 + 2;
          D.31540 = *D.31539;
          D.31541 = (int) D.31540;
          __result = D.31538 - D.31541;
          if (__s1_len > 2) goto <D.31542>; else goto <D.31543>;
          <D.31542>:
          if (__result == 0) goto <D.31544>; else goto <D.31545>;
          <D.31544>:
          D.31546 = &MEM[(void *)"PointerType" + 3B];
          D.31547 = *D.31546;
          D.31548 = (int) D.31547;
          D.31549 = __s2 + 3;
          D.31550 = *D.31549;
          D.31551 = (int) D.31550;
          __result = D.31548 - D.31551;
          <D.31545>:
          <D.31543>:
          <D.31535>:
          <D.31533>:
          <D.31525>:
          <D.31523>:
        }
        D.23070 = __result;
      }
      iftmp.208 = D.23070;
      goto <D.31552>;
      <D.31516>:
      D.31553 = class->name;
      iftmp.208 = __builtin_strcmp ("PointerType", D.31553);
      <D.31552>:
      D.23074 = iftmp.208;
    }
    if (D.23074 == 0) goto <D.31554>; else goto <D.31555>;
    <D.31554>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31559 = "System.Reflection.Emit";
        D.31560 = MEM[(const unsigned char *)D.31559];
        D.31561 = (int) D.31560;
        D.31562 = *__s2;
        D.31563 = (int) D.31562;
        __result = D.31561 - D.31563;
        {
          if (__s1_len != 0) goto <D.31564>; else goto <D.31565>;
          <D.31564>:
          if (__result == 0) goto <D.31566>; else goto <D.31567>;
          <D.31566>:
          D.31568 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31569 = *D.31568;
          D.31570 = (int) D.31569;
          D.31571 = __s2 + 1;
          D.31572 = *D.31571;
          D.31573 = (int) D.31572;
          __result = D.31570 - D.31573;
          if (__s1_len > 1) goto <D.31574>; else goto <D.31575>;
          <D.31574>:
          if (__result == 0) goto <D.31576>; else goto <D.31577>;
          <D.31576>:
          D.31578 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31579 = *D.31578;
          D.31580 = (int) D.31579;
          D.31581 = __s2 + 2;
          D.31582 = *D.31581;
          D.31583 = (int) D.31582;
          __result = D.31580 - D.31583;
          if (__s1_len > 2) goto <D.31584>; else goto <D.31585>;
          <D.31584>:
          if (__result == 0) goto <D.31586>; else goto <D.31587>;
          <D.31586>:
          D.31588 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31589 = *D.31588;
          D.31590 = (int) D.31589;
          D.31591 = __s2 + 3;
          D.31592 = *D.31591;
          D.31593 = (int) D.31592;
          __result = D.31590 - D.31593;
          <D.31587>:
          <D.31585>:
          <D.31577>:
          <D.31575>:
          <D.31567>:
          <D.31565>:
        }
        D.23079 = __result;
      }
      iftmp.209 = D.23079;
      goto <D.31594>;
      <D.31558>:
      D.31595 = class->name_space;
      iftmp.209 = __builtin_strcmp ("System.Reflection.Emit", D.31595);
      <D.31594>:
      D.23083 = iftmp.209;
    }
    if (D.23083 == 0) goto <D.31596>; else goto <D.31597>;
    <D.31596>:
    cached_class = class;
    D.31509 = 1;
    return D.31509;
    <D.31597>:
    <D.31555>:
    <D.31513>:
    D.31509 = 0;
    return D.31509;
  }
}


mono_image_register_token (struct MonoDynamicImage * assembly, guint32 token, struct MonoObject * obj)
{
  struct MonoGHashTable * D.31599;
  long unsigned int D.31600;
  const void * D.31601;
  void * D.31605;
  struct MonoObject * prev;

  D.31599 = assembly->tokens;
  D.31600 = (long unsigned int) token;
  D.31601 = (const void *) D.31600;
  prev = mono_g_hash_table_lookup (D.31599, D.31601);
  if (prev != 0B) goto <D.31602>; else goto <D.31603>;
  <D.31602>:
  goto <D.31604>;
  <D.31603>:
  D.31599 = assembly->tokens;
  D.31600 = (long unsigned int) token;
  D.31605 = (void *) D.31600;
  mono_g_hash_table_insert (D.31599, D.31605, obj);
  <D.31604>:
}


mono_dynamic_image_release_gc_roots (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * * D.31606;
  struct MonoGHashTable * * D.31607;
  struct MonoGHashTable * * D.31608;
  struct MonoGHashTable * * D.31609;
  struct MonoGHashTable * * D.31610;
  struct MonoGHashTable * * D.31611;

  D.31606 = &image->token_fixups;
  release_hashtable (D.31606);
  D.31607 = &image->handleref_managed;
  release_hashtable (D.31607);
  D.31608 = &image->tokens;
  release_hashtable (D.31608);
  D.31609 = &image->remapped_tokens;
  release_hashtable (D.31609);
  D.31610 = &image->generic_def_objects;
  release_hashtable (D.31610);
  D.31611 = &image->methodspec;
  release_hashtable (D.31611);
}


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

  D.31612 = *hash;
  if (D.31612 != 0B) goto <D.31613>; else goto <D.31614>;
  <D.31613>:
  D.31612 = *hash;
  mono_g_hash_table_destroy (D.31612);
  *hash = 0B;
  <D.31614>:
}


mono_dynamic_image_free (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * D.31615;
  struct GHashTable * D.31618;
  struct GHashTable * D.31621;
  struct GHashTable * D.31624;
  struct MonoGHashTable * D.31627;
  struct MonoGHashTable * D.31630;
  struct MonoGHashTable * D.31633;
  struct MonoGHashTable * D.31636;
  struct GHashTable * D.31639;
  struct GHashTable * D.31642;
  struct MonoMethodSignature * D.31645;
  char * D.31646;
  struct GList * D.31647;
  struct GPtrArray * D.31648;
  void * * D.31651;
  long unsigned int D.31652;
  long unsigned int D.31653;
  void * * D.31654;
  struct MonoReflectionGenericParam * * D.31655;
  unsigned int i.210;
  unsigned int D.31657;
  struct MonoGHashTable * D.31658;
  struct GHashTable * D.31661;
  struct GHashTable * D.31664;
  struct GHashTable * D.31667;
  struct GHashTable * D.31670;
  char * D.31673;
  char * D.31674;
  guint8 * D.31675;
  struct MonoDynamicStream * D.31678;
  struct MonoDynamicStream * D.31679;
  struct MonoDynamicStream * D.31680;
  struct MonoDynamicStream * D.31681;
  struct MonoDynamicStream * D.31682;
  struct MonoDynamicStream * D.31683;
  struct MonoDynamicStream * D.31684;
  guint32 * D.31685;
  struct MonoDynamicImage * di;
  struct GList * list;
  int i;

  di = image;
  D.31615 = di->methodspec;
  if (D.31615 != 0B) goto <D.31616>; else goto <D.31617>;
  <D.31616>:
  D.31615 = di->methodspec;
  mono_g_hash_table_destroy (D.31615);
  <D.31617>:
  D.31618 = di->typespec;
  if (D.31618 != 0B) goto <D.31619>; else goto <D.31620>;
  <D.31619>:
  D.31618 = di->typespec;
  monoeg_g_hash_table_destroy (D.31618);
  <D.31620>:
  D.31621 = di->typeref;
  if (D.31621 != 0B) goto <D.31622>; else goto <D.31623>;
  <D.31622>:
  D.31621 = di->typeref;
  monoeg_g_hash_table_destroy (D.31621);
  <D.31623>:
  D.31624 = di->handleref;
  if (D.31624 != 0B) goto <D.31625>; else goto <D.31626>;
  <D.31625>:
  D.31624 = di->handleref;
  monoeg_g_hash_table_destroy (D.31624);
  <D.31626>:
  D.31627 = di->handleref_managed;
  if (D.31627 != 0B) goto <D.31628>; else goto <D.31629>;
  <D.31628>:
  D.31627 = di->handleref_managed;
  mono_g_hash_table_destroy (D.31627);
  <D.31629>:
  D.31630 = di->tokens;
  if (D.31630 != 0B) goto <D.31631>; else goto <D.31632>;
  <D.31631>:
  D.31630 = di->tokens;
  mono_g_hash_table_destroy (D.31630);
  <D.31632>:
  D.31633 = di->remapped_tokens;
  if (D.31633 != 0B) goto <D.31634>; else goto <D.31635>;
  <D.31634>:
  D.31633 = di->remapped_tokens;
  mono_g_hash_table_destroy (D.31633);
  <D.31635>:
  D.31636 = di->generic_def_objects;
  if (D.31636 != 0B) goto <D.31637>; else goto <D.31638>;
  <D.31637>:
  D.31636 = di->generic_def_objects;
  mono_g_hash_table_destroy (D.31636);
  <D.31638>:
  D.31639 = di->blob_cache;
  if (D.31639 != 0B) goto <D.31640>; else goto <D.31641>;
  <D.31640>:
  D.31639 = di->blob_cache;
  monoeg_g_hash_table_foreach (D.31639, free_blob_cache_entry, 0B);
  D.31639 = di->blob_cache;
  monoeg_g_hash_table_destroy (D.31639);
  <D.31641>:
  D.31642 = di->standalonesig_cache;
  if (D.31642 != 0B) goto <D.31643>; else goto <D.31644>;
  <D.31643>:
  D.31642 = di->standalonesig_cache;
  monoeg_g_hash_table_destroy (D.31642);
  <D.31644>:
  list = di->array_methods;
  goto <D.21298>;
  <D.21297>:
  {
    struct ArrayMethod * am;

    am = list->data;
    D.31645 = am->sig;
    monoeg_g_free (D.31645);
    D.31646 = am->name;
    monoeg_g_free (D.31646);
    monoeg_g_free (am);
  }
  list = list->next;
  <D.21298>:
  if (list != 0B) goto <D.21297>; else goto <D.21299>;
  <D.21299>:
  D.31647 = di->array_methods;
  monoeg_g_list_free (D.31647);
  D.31648 = di->gen_params;
  if (D.31648 != 0B) goto <D.31649>; else goto <D.31650>;
  <D.31649>:
  i = 0;
  goto <D.21302>;
  <D.21301>:
  {
    struct GenericParamTableEntry * entry;

    D.31648 = di->gen_params;
    D.31651 = D.31648->pdata;
    D.31652 = (long unsigned int) i;
    D.31653 = D.31652 * 8;
    D.31654 = D.31651 + D.31653;
    entry = *D.31654;
    D.31655 = &entry->gparam;
    mono_gc_deregister_root (D.31655);
    monoeg_g_free (entry);
  }
  i = i + 1;
  <D.21302>:
  i.210 = (unsigned int) i;
  D.31648 = di->gen_params;
  D.31657 = D.31648->len;
  if (i.210 < D.31657) goto <D.21301>; else goto <D.21303>;
  <D.21303>:
  D.31648 = di->gen_params;
  monoeg_g_ptr_array_free (D.31648, 1);
  <D.31650>:
  D.31658 = di->token_fixups;
  if (D.31658 != 0B) goto <D.31659>; else goto <D.31660>;
  <D.31659>:
  D.31658 = di->token_fixups;
  mono_g_hash_table_destroy (D.31658);
  <D.31660>:
  D.31661 = di->method_to_table_idx;
  if (D.31661 != 0B) goto <D.31662>; else goto <D.31663>;
  <D.31662>:
  D.31661 = di->method_to_table_idx;
  monoeg_g_hash_table_destroy (D.31661);
  <D.31663>:
  D.31664 = di->field_to_table_idx;
  if (D.31664 != 0B) goto <D.31665>; else goto <D.31666>;
  <D.31665>:
  D.31664 = di->field_to_table_idx;
  monoeg_g_hash_table_destroy (D.31664);
  <D.31666>:
  D.31667 = di->method_aux_hash;
  if (D.31667 != 0B) goto <D.31668>; else goto <D.31669>;
  <D.31668>:
  D.31667 = di->method_aux_hash;
  monoeg_g_hash_table_destroy (D.31667);
  <D.31669>:
  D.31670 = di->vararg_aux_hash;
  if (D.31670 != 0B) goto <D.31671>; else goto <D.31672>;
  <D.31671>:
  D.31670 = di->vararg_aux_hash;
  monoeg_g_hash_table_destroy (D.31670);
  <D.31672>:
  D.31673 = di->strong_name;
  monoeg_g_free (D.31673);
  D.31674 = di->win32_res;
  monoeg_g_free (D.31674);
  D.31675 = di->public_key;
  if (D.31675 != 0B) goto <D.31676>; else goto <D.31677>;
  <D.31676>:
  D.31675 = di->public_key;
  monoeg_g_free (D.31675);
  <D.31677>:
  D.31678 = &di->sheap;
  mono_dynamic_stream_reset (D.31678);
  D.31679 = &di->code;
  mono_dynamic_stream_reset (D.31679);
  D.31680 = &di->resources;
  mono_dynamic_stream_reset (D.31680);
  D.31681 = &di->us;
  mono_dynamic_stream_reset (D.31681);
  D.31682 = &di->blob;
  mono_dynamic_stream_reset (D.31682);
  D.31683 = &di->tstream;
  mono_dynamic_stream_reset (D.31683);
  D.31684 = &di->guid;
  mono_dynamic_stream_reset (D.31684);
  i = 0;
  goto <D.21305>;
  <D.21304>:
  D.31685 = di->tables[i].values;
  monoeg_g_free (D.31685);
  i = i + 1;
  <D.21305>:
  if (i <= 44) goto <D.21304>; else goto <D.21306>;
  <D.21306>:
}


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.31686;
  struct MonoDynamicAssembly * D.31687;
  void * D.31690;
  struct MonoAssembly * D.31691;
  unsigned char D.31692;
  struct MonoString * D.31693;
  char * D.31694;
  struct MonoString * D.31695;
  char * D.31698;
  gchar * D.31700;
  struct MonoString * D.31701;
  char * * parts.211;
  char * D.31705;
  int D.31706;
  short unsigned int D.31707;
  char * * parts.212;
  char * D.31709;
  int D.31710;
  short unsigned int D.31711;
  uint16_t iftmp.213;
  char * D.31713;
  char * * parts.214;
  char * D.31717;
  int D.31718;
  uint16_t iftmp.215;
  int D.31723;
  unsigned int D.31726;
  _Bool D.31727;
  unsigned char D.31728;
  _Bool D.31729;
  unsigned char D.31730;
  struct MonoString * D.31731;
  char * D.31732;
  gchar * D.31733;
  char * D.31734;
  struct MonoImage * D.31735;
  struct MonoArray * D.31736;
  unsigned int D.31739;
  const char * D.31744;
  mono_byte[17] * D.31745;
  char * D.31746;
  long unsigned int D.31747;
  union mono_mutex_t * D.31748;
  _Bool D.31751;
  long int D.31752;
  long int D.31753;
  struct GSList * D.31756;
  struct GSList * D.31757;
  _Bool D.31760;
  long int D.31761;
  long int D.31762;
  struct MonoDomain * D.31765;
  struct MonoReflectionAssembly * D.31766;
  struct MonoDynamicAssembly * assembly;
  struct MonoDynamicImage * image;
  struct MonoDomain * domain;

  D.31686 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.31686->domain;
  D.31687 = assemblyb->dynamic_assembly;
  if (D.31687 != 0B) goto <D.31688>; else goto <D.31689>;
  <D.31688>:
  return;
  <D.31689>:
  D.31690 = monoeg_malloc0 (152);
  assemblyb->dynamic_assembly = D.31690;
  assembly = assemblyb->dynamic_assembly;
  D.31691 = &assembly->assembly;
  mono_profiler_assembly_event (D.31691, 0);
  assembly->assembly.ref_count = 1;
  assembly->assembly.dynamic = 1;
  D.31692 = assemblyb->corlib_internal;
  assembly->assembly.corlib_internal = D.31692;
  assemblyb->assembly.assembly = assembly;
  D.31693 = assemblyb->dir;
  D.31694 = mono_string_to_utf8 (D.31693);
  assembly->assembly.basedir = D.31694;
  D.31695 = assemblyb->culture;
  if (D.31695 != 0B) goto <D.31696>; else goto <D.31697>;
  <D.31696>:
  D.31695 = assemblyb->culture;
  D.31698 = mono_string_to_utf8 (D.31695);
  assembly->assembly.aname.culture = D.31698;
  goto <D.31699>;
  <D.31697>:
  D.31700 = monoeg_strdup ("");
  assembly->assembly.aname.culture = D.31700;
  <D.31699>:
  D.31701 = assemblyb->version;
  if (D.31701 != 0B) goto <D.31702>; else goto <D.31703>;
  <D.31702>:
  {
    char * vstr;
    char * * version;
    char * * parts;

    D.31701 = assemblyb->version;
    vstr = mono_string_to_utf8 (D.31701);
    version = monoeg_g_strsplit (vstr, ".", 4);
    parts = version;
    parts.211 = parts;
    parts = parts.211 + 8;
    D.31705 = *parts.211;
    D.31706 = atoi (D.31705);
    D.31707 = (short unsigned int) D.31706;
    assembly->assembly.aname.major = D.31707;
    parts.212 = parts;
    parts = parts.212 + 8;
    D.31709 = *parts.212;
    D.31710 = atoi (D.31709);
    D.31711 = (short unsigned int) D.31710;
    assembly->assembly.aname.minor = D.31711;
    D.31713 = *parts;
    if (D.31713 != 0B) goto <D.31714>; else goto <D.31715>;
    <D.31714>:
    parts.214 = parts;
    parts = parts.214 + 8;
    D.31717 = *parts.214;
    D.31718 = atoi (D.31717);
    iftmp.213 = (uint16_t) D.31718;
    goto <D.31719>;
    <D.31715>:
    iftmp.213 = 0;
    <D.31719>:
    assembly->assembly.aname.build = iftmp.213;
    D.31713 = *parts;
    if (D.31713 != 0B) goto <D.31721>; else goto <D.31722>;
    <D.31721>:
    D.31713 = *parts;
    D.31723 = atoi (D.31713);
    iftmp.215 = (uint16_t) D.31723;
    goto <D.31724>;
    <D.31722>:
    iftmp.215 = 0;
    <D.31724>:
    assembly->assembly.aname.revision = iftmp.215;
    monoeg_g_strfreev (version);
    monoeg_g_free (vstr);
  }
  goto <D.31725>;
  <D.31703>:
  assembly->assembly.aname.major = 0;
  assembly->assembly.aname.minor = 0;
  assembly->assembly.aname.build = 0;
  assembly->assembly.aname.revision = 0;
  <D.31725>:
  D.31726 = assemblyb->access;
  D.31727 = D.31726 != 2;
  D.31728 = (unsigned char) D.31727;
  assembly->run = D.31728;
  D.31726 = assemblyb->access;
  D.31729 = D.31726 != 1;
  D.31730 = (unsigned char) D.31729;
  assembly->save = D.31730;
  assembly->domain = domain;
  D.31731 = assemblyb->name;
  D.31732 = mono_string_to_utf8 (D.31731);
  D.31733 = monoeg_strdup ("RefEmit_YouForgotToDefineAModule");
  image = create_dynamic_mono_image (assembly, D.31732, D.31733);
  image->initial_image = 1;
  D.31734 = image->image.name;
  assembly->assembly.aname.name = D.31734;
  D.31735 = &image->image;
  assembly->assembly.image = D.31735;
  D.31736 = assemblyb->pktoken;
  if (D.31736 != 0B) goto <D.31737>; else goto <D.31738>;
  <D.31737>:
  D.31736 = assemblyb->pktoken;
  D.31739 = D.31736->max_length;
  if (D.31739 != 0) goto <D.31740>; else goto <D.31741>;
  <D.31740>:
  D.31736 = assemblyb->pktoken;
  D.31739 = D.31736->max_length;
  if (D.31739 != 16) goto <D.31742>; else goto <D.31743>;
  <D.31742>:
  D.31744 = assembly->assembly.aname.name;
  D.31736 = assemblyb->pktoken;
  D.31739 = D.31736->max_length;
  monoeg_g_log (0B, 4, "Public key token length invalid for assembly %s: %i", D.31744, D.31739);
  <D.21316>:
  goto <D.21316>;
  <D.31743>:
  D.31745 = &assembly->assembly.aname.public_key_token;
  D.31736 = assemblyb->pktoken;
  D.31746 = mono_array_addr_with_size (D.31736, 1, 0);
  D.31736 = assemblyb->pktoken;
  D.31739 = D.31736->max_length;
  D.31747 = (long unsigned int) D.31739;
  memcpy (D.31745, D.31746, D.31747);
  <D.31741>:
  <D.31738>:
  {
    int ret;

    D.31748 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.31748);
    if (ret != 0) goto <D.31749>; else goto <D.31750>;
    <D.31749>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock 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", 5333, "ret == 0");
    <D.31755>:
  }
  D.31756 = domain->domain_assemblies;
  D.31757 = monoeg_g_slist_append (D.31756, assembly);
  domain->domain_assemblies = D.31757;
  {
    int ret;

    D.31748 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.31748);
    if (ret != 0) goto <D.31758>; else goto <D.31759>;
    <D.31758>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31759>:
    D.31760 = ret != 0;
    D.31761 = (long int) D.31760;
    D.31762 = __builtin_expect (D.31761, 0);
    if (D.31762 != 0) goto <D.31763>; else goto <D.31764>;
    <D.31763>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5335, "ret == 0");
    <D.31764>:
  }
  D.31686 = MEM[(struct MonoObject *)assemblyb].vtable;
  D.31765 = D.31686->domain;
  D.31766 = &assemblyb->assembly;
  D.31691 = &assembly->assembly;
  register_assembly (D.31765, D.31766, D.31691);
  D.31691 = &assembly->assembly;
  mono_profiler_assembly_loaded (D.31691, 0);
  mono_assembly_invoke_load_hook (assembly);
}


atoi (const char * __nptr)
{
  int D.31768;
  long int D.31769;

  D.31769 = strtol (__nptr, 0B, 10);
  D.31768 = (int) D.31769;
  return D.31768;
}


create_dynamic_mono_image (struct MonoDynamicAssembly * assembly, char * assembly_name, char * module_name)
{
  int D.21275;
  int iftmp.216;
  int D.21274;
  const struct MonoRuntimeInfo * D.31774;
  const char[4] * D.31775;
  unsigned char D.31776;
  int D.31777;
  unsigned char D.31778;
  int D.31779;
  const unsigned char * D.31784;
  unsigned char D.31785;
  int D.31786;
  const unsigned char * D.31787;
  unsigned char D.31788;
  int D.31789;
  const unsigned char * D.31794;
  unsigned char D.31795;
  int D.31796;
  const unsigned char * D.31797;
  unsigned char D.31798;
  int D.31799;
  const unsigned char * D.31804;
  unsigned char D.31805;
  int D.31806;
  const unsigned char * D.31807;
  unsigned char D.31808;
  int D.31809;
  const struct MonoRuntimeInfo * D.31811;
  const char[4] * D.31812;
  const struct MonoRuntimeInfo * D.31816;
  struct MonoImage * D.31817;
  char * D.31818;
  gchar * D.31819;
  void * D.31820;
  struct MonoAssembly * * D.31821;
  struct MonoGHashTable * D.31822;
  struct GHashTable * D.31823;
  struct GHashTable * D.31824;
  struct GHashTable * D.31825;
  struct GHashTable * D.31826;
  struct GHashTable * D.31827;
  struct MonoGHashTable * D.31828;
  struct MonoGHashTable * D.31829;
  struct MonoGHashTable * D.31830;
  struct MonoGHashTable * D.31831;
  struct GHashTable * D.31832;
  struct GHashTable * D.31833;
  struct GHashTable * D.31834;
  struct GPtrArray * D.31835;
  struct MonoGHashTable * D.31836;
  struct MonoDynamicStream * D.31837;
  struct MonoDynamicStream * D.31838;
  struct MonoDynamicStream * D.31839;
  unsigned int D.31840;
  unsigned int D.31841;
  unsigned int D.31842;
  unsigned int D.31843;
  unsigned int D.31844;
  unsigned char D.31845;
  unsigned char D.31846;
  int D.31847;
  unsigned char D.31848;
  int D.31849;
  struct MonoDynamicImage * D.31850;
  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.31772>; else goto <D.31773>;
    <D.31772>:
    {
      const unsigned char * __s2;
      int __result;

      D.31774 = mono_get_runtime_info ();
      __s2 = &D.31774->framework_version;
      D.31775 = "2.1";
      D.31776 = MEM[(const unsigned char *)D.31775];
      D.31777 = (int) D.31776;
      D.31778 = *__s2;
      D.31779 = (int) D.31778;
      __result = D.31777 - D.31779;
      {
        if (__s2_len != 0) goto <D.31780>; else goto <D.31781>;
        <D.31780>:
        if (__result == 0) goto <D.31782>; else goto <D.31783>;
        <D.31782>:
        D.31784 = &MEM[(void *)"2.1" + 1B];
        D.31785 = *D.31784;
        D.31786 = (int) D.31785;
        D.31787 = __s2 + 1;
        D.31788 = *D.31787;
        D.31789 = (int) D.31788;
        __result = D.31786 - D.31789;
        if (__s2_len > 1) goto <D.31790>; else goto <D.31791>;
        <D.31790>:
        if (__result == 0) goto <D.31792>; else goto <D.31793>;
        <D.31792>:
        D.31794 = &MEM[(void *)"2.1" + 2B];
        D.31795 = *D.31794;
        D.31796 = (int) D.31795;
        D.31797 = __s2 + 2;
        D.31798 = *D.31797;
        D.31799 = (int) D.31798;
        __result = D.31796 - D.31799;
        if (__s2_len > 2) goto <D.31800>; else goto <D.31801>;
        <D.31800>:
        if (__result == 0) goto <D.31802>; else goto <D.31803>;
        <D.31802>:
        D.31804 = &MEM[(void *)"2.1" + 3B];
        D.31805 = *D.31804;
        D.31806 = (int) D.31805;
        D.31807 = __s2 + 3;
        D.31808 = *D.31807;
        D.31809 = (int) D.31808;
        __result = D.31806 - D.31809;
        <D.31803>:
        <D.31801>:
        <D.31793>:
        <D.31791>:
        <D.31783>:
        <D.31781>:
      }
      D.21274 = __result;
    }
    iftmp.216 = -D.21274;
    goto <D.31810>;
    <D.31773>:
    D.31811 = mono_get_runtime_info ();
    D.31812 = &D.31811->framework_version;
    iftmp.216 = __builtin_strcmp (D.31812, "2.1");
    <D.31810>:
    D.21275 = iftmp.216;
  }
  if (D.21275 == 0) goto <D.31813>; else goto <D.31814>;
  <D.31813>:
  version = "v2.0.50727";
  goto <D.31815>;
  <D.31814>:
  D.31816 = mono_get_runtime_info ();
  version = &D.31816->runtime_version;
  <D.31815>:
  image = monoeg_malloc0 (3176);
  D.31817 = &image->image;
  mono_profiler_module_event (D.31817, 0);
  image->image.name = assembly_name;
  D.31818 = image->image.name;
  image->image.assembly_name = D.31818;
  image->image.module_name = module_name;
  D.31819 = monoeg_strdup (version);
  image->image.version = D.31819;
  image->image.md_version_major = 1;
  image->image.md_version_minor = 1;
  image->image.dynamic = 1;
  D.31820 = monoeg_malloc0 (8);
  image->image.references = D.31820;
  D.31821 = image->image.references;
  *D.31821 = 0B;
  D.31817 = &image->image;
  mono_image_init (D.31817);
  D.31822 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->token_fixups = D.31822;
  D.31823 = monoeg_g_hash_table_new (0B, 0B);
  image->method_to_table_idx = D.31823;
  D.31824 = monoeg_g_hash_table_new (0B, 0B);
  image->field_to_table_idx = D.31824;
  D.31825 = monoeg_g_hash_table_new (0B, 0B);
  image->method_aux_hash = D.31825;
  D.31826 = monoeg_g_hash_table_new (0B, 0B);
  image->vararg_aux_hash = D.31826;
  D.31827 = monoeg_g_hash_table_new (0B, 0B);
  image->handleref = D.31827;
  D.31828 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->handleref_managed = D.31828;
  D.31829 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->tokens = D.31829;
  D.31830 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->generic_def_objects = D.31830;
  D.31831 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->methodspec = D.31831;
  D.31832 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typespec = D.31832;
  D.31833 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typeref = D.31833;
  D.31834 = monoeg_g_hash_table_new (mono_blob_entry_hash, mono_blob_entry_equal);
  image->blob_cache = D.31834;
  D.31835 = monoeg_g_ptr_array_new ();
  image->gen_params = D.31835;
  D.31836 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->remapped_tokens = D.31836;
  D.31837 = &image->sheap;
  string_heap_init (D.31837);
  D.31838 = &image->us;
  mono_image_add_stream_data (D.31838, "", 1);
  add_to_blob_cached (image, "", 1, 0B, 0);
  D.31839 = &image->code;
  mono_image_add_stream_data (D.31839, &entrycode, 16);
  D.31839 = &image->code;
  D.31840 = mono_image_add_stream_zero (D.31839, 8);
  image->iat_offset = D.31840;
  D.31839 = &image->code;
  D.31841 = mono_image_add_stream_zero (D.31839, 40);
  image->idt_offset = D.31841;
  D.31839 = &image->code;
  D.31842 = mono_image_add_stream_zero (D.31839, 2);
  image->imp_names_offset = D.31842;
  D.31839 = &image->code;
  mono_image_add_stream_data (D.31839, "_CorExeMain", 12);
  D.31839 = &image->code;
  mono_image_add_stream_data (D.31839, "mscoree.dll", 12);
  D.31839 = &image->code;
  D.31843 = mono_image_add_stream_zero (D.31839, 8);
  image->ilt_offset = D.31843;
  D.31839 = &image->code;
  stream_data_align (D.31839);
  D.31839 = &image->code;
  D.31844 = mono_image_add_stream_zero (D.31839, 136);
  image->cli_header_offset = D.31844;
  i = 0;
  goto <D.21277>;
  <D.21276>:
  image->tables[i].next_idx = 1;
  D.31845 = table_sizes[i];
  image->tables[i].columns = D.31845;
  i = i + 1;
  <D.21277>:
  if (i <= 44) goto <D.21276>; else goto <D.21278>;
  <D.21278>:
  image->image.assembly = assembly;
  D.31846 = assembly->run;
  D.31847 = (int) D.31846;
  image->run = D.31847;
  D.31848 = assembly->save;
  D.31849 = (int) D.31848;
  image->save = D.31849;
  image->pe_kind = 1;
  image->machine = 332;
  D.31817 = &image->image;
  mono_profiler_module_loaded (D.31817, 0);
  D.31850 = image;
  return D.31850;
}


mono_blob_entry_equal (const char * str1, const char * str2)
{
  unsigned int D.31852;
  unsigned int D.31853;
  gboolean D.31856;
  const char * end1.217;
  const char * end2.218;
  long unsigned int D.31859;
  int D.31860;
  _Bool D.31861;
  int len;
  int len2;
  const char * end1;
  const char * end2;

  try
    {
      D.31852 = mono_metadata_decode_blob_size (str1, &end1);
      len = (int) D.31852;
      D.31853 = mono_metadata_decode_blob_size (str2, &end2);
      len2 = (int) D.31853;
      if (len != len2) goto <D.31854>; else goto <D.31855>;
      <D.31854>:
      D.31856 = 0;
      return D.31856;
      <D.31855>:
      end1.217 = end1;
      end2.218 = end2;
      D.31859 = (long unsigned int) len;
      D.31860 = memcmp (end1.217, end2.218, D.31859);
      D.31861 = D.31860 == 0;
      D.31856 = (gboolean) D.31861;
      return D.31856;
    }
  finally
    {
      end1 = {CLOBBER};
      end2 = {CLOBBER};
    }
}


mono_blob_entry_hash (const char * str)
{
  const char * str.219;
  sizetype D.31867;
  char D.31868;
  const char * str.220;
  unsigned int D.31870;
  unsigned int D.31871;
  unsigned int D.31872;
  int D.31873;
  guint len;
  guint h;
  const char * end;

  str.219 = str;
  len = mono_metadata_decode_blob_size (str.219, &str);
  if (len != 0) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  str.219 = str;
  D.31867 = (sizetype) len;
  end = str.219 + D.31867;
  str.219 = str;
  D.31868 = *str.219;
  h = (guint) D.31868;
  str.219 = str;
  str.220 = str.219 + 1;
  str = str.220;
  goto <D.19281>;
  <D.19280>:
  D.31870 = h << 5;
  D.31871 = D.31870 - h;
  str.219 = str;
  D.31868 = *str.219;
  D.31872 = (unsigned int) D.31868;
  h = D.31871 + D.31872;
  str.219 = str;
  str.220 = str.219 + 1;
  str = str.220;
  <D.19281>:
  str.219 = str;
  if (str.219 < end) goto <D.19280>; else goto <D.19282>;
  <D.19282>:
  D.31873 = (int) h;
  return D.31873;
  <D.31866>:
  D.31873 = 0;
  return D.31873;
}


string_heap_init (struct MonoDynamicStream * sh)
{
  void * D.31875;
  struct GHashTable * D.31876;

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


register_assembly (struct MonoDomain * domain, struct MonoReflectionAssembly * res, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.31877;
  _Bool D.31880;
  long int D.31881;
  long int D.31882;
  struct MonoGHashTable * D.31885;
  struct MonoGHashTable * D.31888;
  struct MonoMemPool * D.31891;
  _Bool D.31894;
  long int D.31895;
  long int D.31896;
  void * D.31899;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

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

          D.31877 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31877);
          if (ret != 0) goto <D.31878>; else goto <D.31879>;
          <D.31878>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31879>:
          D.31880 = ret != 0;
          D.31881 = (long int) D.31880;
          D.31882 = __builtin_expect (D.31881, 0);
          if (D.31882 != 0) goto <D.31883>; else goto <D.31884>;
          <D.31883>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.31884>:
        }
        D.31885 = domain->refobject_hash;
        if (D.31885 == 0B) goto <D.31886>; else goto <D.31887>;
        <D.31886>:
        D.31888 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31888;
        <D.31887>:
        D.31885 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31885, &pe);
        if (_obj == 0B) goto <D.31889>; else goto <D.31890>;
        <D.31889>:
        {
          struct ReflectedEntry * e;

          D.31891 = domain->mp;
          e = mono_mempool_alloc (D.31891, 16);
          e->item = assembly;
          e->refclass = 0B;
          D.31885 = domain->refobject_hash;
          mono_g_hash_table_insert (D.31885, e, res);
          _obj = res;
        }
        <D.31890>:
        {
          int ret;

          D.31877 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31877);
          if (ret != 0) goto <D.31892>; else goto <D.31893>;
          <D.31892>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31893>:
          D.31894 = ret != 0;
          D.31895 = (long int) D.31894;
          D.31896 = __builtin_expect (D.31895, 0);
          if (D.31896 != 0) goto <D.31897>; else goto <D.31898>;
          <D.31897>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.31898>:
        }
        D.31899 = _obj;
        return D.31899;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


reflected_equal (const void * a, const void * b)
{
  gboolean D.31902;
  int iftmp.221;
  void * D.31906;
  void * D.31907;
  struct MonoClass * D.31909;
  struct MonoClass * D.31910;
  const struct ReflectedEntry * ea;
  const struct ReflectedEntry * eb;

  ea = a;
  eb = b;
  D.31906 = ea->item;
  D.31907 = eb->item;
  if (D.31906 == D.31907) goto <D.31908>; else goto <D.31904>;
  <D.31908>:
  D.31909 = ea->refclass;
  D.31910 = eb->refclass;
  if (D.31909 == D.31910) goto <D.31911>; else goto <D.31904>;
  <D.31911>:
  iftmp.221 = 1;
  goto <D.31905>;
  <D.31904>:
  iftmp.221 = 0;
  <D.31905>:
  D.31902 = iftmp.221;
  return D.31902;
}


reflected_hash (const void * a)
{
  guint D.31913;
  void * D.31914;
  const struct ReflectedEntry * ea;

  ea = a;
  D.31914 = ea->item;
  D.31913 = mono_aligned_addr_hash (D.31914);
  return D.31913;
}


mono_image_create_pefile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  int D.31916;
  unsigned int D.31917;
  int D.31918;
  unsigned int D.31919;
  struct MonoDynamicAssembly * D.31920;
  struct MonoImage * D.31921;
  int D.31922;
  struct MonoArray * D.31925;
  long unsigned int D.31928;
  long unsigned int D.31929;
  char * D.31930;
  struct MonoArray * D.31931;
  long unsigned int D.31934;
  char * D.31935;
  long unsigned int D.31940;
  unsigned int D.31941;
  unsigned int D.31942;
  unsigned int D.31943;
  unsigned int D.31946;
  unsigned int D.31947;
  unsigned int D.31948;
  char * D.31949;
  sizetype D.31950;
  short unsigned int D.31951;
  short unsigned int D.31952;
  long int D.31953;
  unsigned int D.31954;
  unsigned int D.31955;
  unsigned int D.31959;
  _Bool D.31960;
  long int D.31961;
  long int D.31962;
  unsigned int D.31965;
  short unsigned int kind.222;
  unsigned int D.31970;
  unsigned int D.31971;
  unsigned int D.31972;
  unsigned int D.31973;
  unsigned int D.31974;
  unsigned int D.31975;
  unsigned int D.31976;
  unsigned int D.31977;
  char * D.31980;
  unsigned int D.31981;
  sizetype D.31982;
  sizetype D.31983;
  char * D.31984;
  sizetype D.31986;
  unsigned int D.31987;
  unsigned int D.31988;
  unsigned int D.31989;
  sizetype D.31990;
  sizetype D.31991;
  unsigned int D.31992;
  sizetype D.31993;
  unsigned int D.31994;
  unsigned int D.31995;
  sizetype D.31996;
  guchar * p.223;
  unsigned char D.31998;
  guchar * p.224;
  unsigned int D.32000;
  unsigned char D.32001;
  guchar * p.225;
  unsigned int D.32003;
  unsigned char D.32004;
  guchar * p.226;
  unsigned int D.32006;
  unsigned char D.32007;
  sizetype D.32008;
  struct MonoReflectionMethod * D.32009;
  int D.21464;
  int iftmp.227;
  int D.21463;
  struct MonoVTable * D.32015;
  struct MonoClass * D.32016;
  const char[14] * D.32017;
  unsigned char D.32018;
  int D.32019;
  unsigned char D.32020;
  int D.32021;
  const unsigned char * D.32026;
  unsigned char D.32027;
  int D.32028;
  const unsigned char * D.32029;
  unsigned char D.32030;
  int D.32031;
  const unsigned char * D.32036;
  unsigned char D.32037;
  int D.32038;
  const unsigned char * D.32039;
  unsigned char D.32040;
  int D.32041;
  const unsigned char * D.32046;
  unsigned char D.32047;
  int D.32048;
  const unsigned char * D.32049;
  unsigned char D.32050;
  int D.32051;
  const char * D.32053;
  struct GHashTable * D.32057;
  struct MonoMethod * D.32058;
  void * D.32059;
  long int D.32060;
  unsigned int D.32061;
  unsigned int D.32063;
  unsigned int D.32064;
  unsigned int D.32065;
  unsigned int D.32066;
  sizetype D.32069;
  char[8] * D.32072;
  const char[7] * D.32073;
  unsigned int D.32074;
  unsigned int D.32075;
  unsigned int D.32076;
  unsigned int D.32077;
  unsigned int D.32078;
  unsigned int D.32079;
  unsigned int D.32080;
  unsigned int D.32081;
  int D.32084;
  unsigned int D.32085;
  unsigned int D.32088;
  unsigned int D.32089;
  guchar * p.228;
  guchar * p.229;
  guchar * p.230;
  guchar * p.231;
  char * D.32094;
  char * D.32095;
  char * D.32096;
  char * D.32099;
  unsigned int D.32102;
  int file_offset.232;
  unsigned int D.32104;
  unsigned int D.32107;
  int D.32108;
  unsigned int D.32111;
  struct MonoDynamicStream * D.32112;
  struct MonoDynamicStream * D.32113;
  struct MonoDynamicStream * D.32114;
  struct MonoDynamicStream * D.32115;
  struct MonoDynamicStream * D.32116;
  struct GHashTable * D.32117;
  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.31916 = assemblyb->pe_kind;
      D.31917 = (unsigned int) D.31916;
      assembly->pe_kind = D.31917;
      D.31918 = assemblyb->machine;
      D.31919 = (unsigned int) D.31918;
      assembly->machine = D.31919;
      D.31920 = assemblyb->dynamic_assembly;
      D.31921 = D.31920->assembly.image;
      D.31916 = assemblyb->pe_kind;
      D.31917 = (unsigned int) D.31916;
      MEM[(struct MonoDynamicImage *)D.31921].pe_kind = D.31917;
      D.31920 = assemblyb->dynamic_assembly;
      D.31921 = D.31920->assembly.image;
      D.31918 = assemblyb->machine;
      D.31919 = (unsigned int) D.31918;
      MEM[(struct MonoDynamicImage *)D.31921].machine = D.31919;
      mono_image_build_metadata (mb);
      D.31922 = mb->is_main;
      if (D.31922 != 0) goto <D.31923>; else goto <D.31924>;
      <D.31923>:
      D.31925 = assemblyb->resources;
      if (D.31925 != 0B) goto <D.31926>; else goto <D.31927>;
      <D.31926>:
      {
        int len;

        D.31925 = assemblyb->resources;
        D.31928 = mono_array_length (D.31925);
        len = (int) D.31928;
        i = 0;
        goto <D.21444>;
        <D.21443>:
        D.31925 = assemblyb->resources;
        D.31929 = (long unsigned int) i;
        D.31930 = mono_array_addr_with_size (D.31925, 40, D.31929);
        assembly_add_resource (mb, assembly, D.31930);
        i = i + 1;
        <D.21444>:
        if (i < len) goto <D.21443>; else goto <D.21445>;
        <D.21445>:
      }
      <D.31927>:
      <D.31924>:
      D.31931 = mb->resources;
      if (D.31931 != 0B) goto <D.31932>; else goto <D.31933>;
      <D.31932>:
      {
        int len;

        D.31931 = mb->resources;
        D.31934 = mono_array_length (D.31931);
        len = (int) D.31934;
        i = 0;
        goto <D.21448>;
        <D.21447>:
        D.31931 = mb->resources;
        D.31929 = (long unsigned int) i;
        D.31935 = mono_array_addr_with_size (D.31931, 40, D.31929);
        assembly_add_resource (mb, assembly, D.31935);
        i = i + 1;
        <D.21448>:
        if (i < len) goto <D.21447>; else goto <D.21449>;
        <D.21449>:
      }
      <D.31933>:
      build_compressed_metadata (assembly);
      D.31922 = mb->is_main;
      if (D.31922 != 0) goto <D.31936>; else goto <D.31937>;
      <D.31936>:
      assembly_add_win32_resources (assembly, assemblyb);
      <D.31937>:
      nsections = calc_section_size (assembly);
      if (0 != 0) goto <D.31938>; else goto <D.31939>;
      <D.31938>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5690, "sizeof (MonoMSDOSHeader) == sizeof (msheader)");
      <D.31939>:
      mono_image_add_stream_data (pefile, &msheader, 128);
      header_start = mono_image_add_stream_zero (pefile, 248);
      D.31940 = (long unsigned int) nsections;
      D.31941 = (unsigned int) D.31940;
      D.31942 = D.31941 * 40;
      section_start = mono_image_add_stream_zero (pefile, D.31942);
      D.31940 = (long unsigned int) nsections;
      D.31941 = (unsigned int) D.31940;
      D.31942 = D.31941 * 40;
      file_offset = D.31942 + section_start;
      virtual_offset = 8192;
      image_size = 0;
      i = 0;
      goto <D.21452>;
      <D.21451>:
      D.31943 = assembly->sections[i].size;
      if (D.31943 == 0) goto <D.31944>; else goto <D.31945>;
      <D.31944>:
      // predicted unlikely by continue predictor.
      goto <D.21450>;
      <D.31945>:
      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.31943 = assembly->sections[i].size;
      file_offset = D.31943 + file_offset;
      D.31943 = assembly->sections[i].size;
      virtual_offset = D.31943 + virtual_offset;
      D.31943 = assembly->sections[i].size;
      D.31946 = D.31943 + 8191;
      D.31947 = D.31946 & 4294959104;
      image_size = D.31947 + image_size;
      <D.21450>:
      i = i + 1;
      <D.21452>:
      if (i <= 2) goto <D.21451>; else goto <D.21453>;
      <D.21453>:
      file_offset = file_offset + 511;
      file_offset = file_offset & 4294966784;
      D.31940 = (long unsigned int) nsections;
      D.31941 = (unsigned int) D.31940;
      D.31942 = D.31941 * 40;
      D.31948 = D.31942 + section_start;
      image_size = D.31948 + image_size;
      msdos = pefile->data;
      msdos->pe_offset = 128;
      D.31949 = pefile->data;
      D.31950 = (sizetype) header_start;
      header = D.31949 + D.31950;
      header->pesig[0] = 80;
      header->pesig[1] = 69;
      D.31918 = assemblyb->machine;
      D.31951 = (short unsigned int) D.31918;
      header->coff.coff_machine = D.31951;
      D.31952 = (short unsigned int) nsections;
      header->coff.coff_sections = D.31952;
      D.31953 = time (0B);
      D.31954 = (unsigned int) D.31953;
      header->coff.coff_time = D.31954;
      header->coff.coff_opt_header_size = 224;
      D.31955 = assemblyb->pekind;
      if (D.31955 == 1) goto <D.31956>; else goto <D.31957>;
      <D.31956>:
      header->coff.coff_attributes = 8462;
      goto <D.31958>;
      <D.31957>:
      header->coff.coff_attributes = 270;
      <D.31958>:
      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.31959 = assembly->sections[0].rva;
      D.31960 = D.31959 != 8192;
      D.31961 = (long int) D.31960;
      D.31962 = __builtin_expect (D.31961, 0);
      if (D.31962 != 0) goto <D.31963>; else goto <D.31964>;
      <D.31963>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5758, "START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva");
      <D.31964>:
      D.31959 = assembly->sections[0].rva;
      header->pe.pe_rva_code_base = D.31959;
      D.31965 = assembly->sections[1].rva;
      header->pe.pe_rva_data_base = D.31965;
      D.31959 = assembly->sections[0].rva;
      header->pe.pe_rva_entry_point = D.31959;
      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.31955 = assemblyb->pekind;
        if (D.31955 == 3) goto <D.31966>; else goto <D.31967>;
        <D.31966>:
        kind = 2;
        goto <D.31968>;
        <D.31967>:
        kind = 3;
        <D.31968>:
        kind.222 = (short unsigned int) kind;
        header->nt.pe_subsys_required = kind.222;
      }
      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.31970 = assembly->sections[1].size;
      header->datadir.pe_resource_table.size = D.31970;
      D.31965 = assembly->sections[1].rva;
      header->datadir.pe_resource_table.rva = D.31965;
      D.31971 = assembly->sections[2].size;
      header->datadir.pe_reloc_table.size = D.31971;
      D.31972 = assembly->sections[2].rva;
      header->datadir.pe_reloc_table.rva = D.31972;
      header->datadir.pe_cli_header.size = 72;
      D.31973 = assembly->text_rva;
      D.31974 = assembly->cli_header_offset;
      D.31975 = D.31973 + D.31974;
      header->datadir.pe_cli_header.rva = D.31975;
      header->datadir.pe_iat.size = 8;
      D.31973 = assembly->text_rva;
      D.31976 = assembly->iat_offset;
      D.31977 = D.31973 + D.31976;
      header->datadir.pe_iat.rva = D.31977;
      D.31955 = assemblyb->pekind;
      if (D.31955 == 1) goto <D.31978>; else goto <D.31979>;
      <D.31978>:
      D.31980 = assembly->code.data;
      D.31981 = assembly->imp_names_offset;
      D.31982 = (sizetype) D.31981;
      D.31983 = D.31982 + 2;
      D.31984 = D.31980 + D.31983;
      memcpy (D.31984, "_CorDllMain", 12);
      goto <D.31985>;
      <D.31979>:
      D.31980 = assembly->code.data;
      D.31981 = assembly->imp_names_offset;
      D.31982 = (sizetype) D.31981;
      D.31983 = D.31982 + 2;
      D.31984 = D.31980 + D.31983;
      memcpy (D.31984, "_CorExeMain", 12);
      <D.31985>:
      D.31980 = assembly->code.data;
      D.31976 = assembly->iat_offset;
      D.31986 = (sizetype) D.31976;
      rva = D.31980 + D.31986;
      D.31973 = assembly->text_rva;
      D.31981 = assembly->imp_names_offset;
      D.31987 = D.31973 + D.31981;
      *rva = D.31987;
      header->datadir.pe_import_table.size = 79;
      D.31973 = assembly->text_rva;
      D.31988 = assembly->idt_offset;
      D.31989 = D.31973 + D.31988;
      header->datadir.pe_import_table.rva = D.31989;
      D.31980 = assembly->code.data;
      D.31988 = assembly->idt_offset;
      D.31990 = (sizetype) D.31988;
      D.31991 = D.31990 + 12;
      rva = D.31980 + D.31991;
      D.31973 = assembly->text_rva;
      D.31981 = assembly->imp_names_offset;
      D.31987 = D.31973 + D.31981;
      D.31992 = D.31987 + 14;
      *rva = D.31992;
      D.31980 = assembly->code.data;
      D.31988 = assembly->idt_offset;
      D.31990 = (sizetype) D.31988;
      D.31993 = D.31990 + 16;
      rva = D.31980 + D.31993;
      D.31973 = assembly->text_rva;
      D.31976 = assembly->iat_offset;
      D.31977 = D.31973 + D.31976;
      *rva = D.31977;
      D.31980 = assembly->code.data;
      D.31988 = assembly->idt_offset;
      D.31990 = (sizetype) D.31988;
      rva = D.31980 + D.31990;
      D.31973 = assembly->text_rva;
      D.31994 = assembly->ilt_offset;
      D.31995 = D.31973 + D.31994;
      *rva = D.31995;
      D.31980 = assembly->code.data;
      D.31994 = assembly->ilt_offset;
      D.31996 = (sizetype) D.31994;
      p = D.31980 + D.31996;
      D.31973 = assembly->text_rva;
      D.31981 = assembly->imp_names_offset;
      value = D.31973 + D.31981;
      p.223 = p;
      p = p.223 + 1;
      D.31998 = (unsigned char) value;
      *p.223 = D.31998;
      p.224 = p;
      p = p.224 + 1;
      D.32000 = value >> 8;
      D.32001 = (unsigned char) D.32000;
      *p.224 = D.32001;
      p.225 = p;
      p = p.225 + 1;
      D.32003 = value >> 16;
      D.32004 = (unsigned char) D.32003;
      *p.225 = D.32004;
      p.226 = p;
      p = p.226 + 1;
      D.32006 = value >> 24;
      D.32007 = (unsigned char) D.32006;
      *p.226 = D.32007;
      D.31980 = assembly->code.data;
      D.31974 = assembly->cli_header_offset;
      D.32008 = (sizetype) D.31974;
      cli_header = D.31980 + D.32008;
      cli_header->ch_size = 72;
      cli_header->ch_runtime_major = 2;
      cli_header->ch_runtime_minor = 5;
      D.31916 = assemblyb->pe_kind;
      D.31917 = (unsigned int) D.31916;
      cli_header->ch_flags = D.31917;
      D.32009 = assemblyb->entry_point;
      if (D.32009 != 0B) goto <D.32010>; else goto <D.32011>;
      <D.32010>:
      {
        guint32 table_idx;

        table_idx = 0;
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.32009 = assemblyb->entry_point;
            D.32015 = D.32009->object.vtable;
            D.32016 = D.32015->klass;
            __s2 = D.32016->name;
            D.32017 = "MethodBuilder";
            D.32018 = MEM[(const unsigned char *)D.32017];
            D.32019 = (int) D.32018;
            D.32020 = *__s2;
            D.32021 = (int) D.32020;
            __result = D.32019 - D.32021;
            {
              if (__s2_len != 0) goto <D.32022>; else goto <D.32023>;
              <D.32022>:
              if (__result == 0) goto <D.32024>; else goto <D.32025>;
              <D.32024>:
              D.32026 = &MEM[(void *)"MethodBuilder" + 1B];
              D.32027 = *D.32026;
              D.32028 = (int) D.32027;
              D.32029 = __s2 + 1;
              D.32030 = *D.32029;
              D.32031 = (int) D.32030;
              __result = D.32028 - D.32031;
              if (__s2_len > 1) goto <D.32032>; else goto <D.32033>;
              <D.32032>:
              if (__result == 0) goto <D.32034>; else goto <D.32035>;
              <D.32034>:
              D.32036 = &MEM[(void *)"MethodBuilder" + 2B];
              D.32037 = *D.32036;
              D.32038 = (int) D.32037;
              D.32039 = __s2 + 2;
              D.32040 = *D.32039;
              D.32041 = (int) D.32040;
              __result = D.32038 - D.32041;
              if (__s2_len > 2) goto <D.32042>; else goto <D.32043>;
              <D.32042>:
              if (__result == 0) goto <D.32044>; else goto <D.32045>;
              <D.32044>:
              D.32046 = &MEM[(void *)"MethodBuilder" + 3B];
              D.32047 = *D.32046;
              D.32048 = (int) D.32047;
              D.32049 = __s2 + 3;
              D.32050 = *D.32049;
              D.32051 = (int) D.32050;
              __result = D.32048 - D.32051;
              <D.32045>:
              <D.32043>:
              <D.32035>:
              <D.32033>:
              <D.32025>:
              <D.32023>:
            }
            D.21463 = __result;
          }
          iftmp.227 = -D.21463;
          goto <D.32052>;
          <D.32014>:
          D.32009 = assemblyb->entry_point;
          D.32015 = D.32009->object.vtable;
          D.32016 = D.32015->klass;
          D.32053 = D.32016->name;
          iftmp.227 = __builtin_strcmp (D.32053, "MethodBuilder");
          <D.32052>:
          D.21464 = iftmp.227;
        }
        if (D.21464 == 0) goto <D.32054>; else goto <D.32055>;
        <D.32054>:
        {
          struct MonoReflectionMethodBuilder * methodb;

          methodb = assemblyb->entry_point;
          table_idx = methodb->table_idx;
        }
        goto <D.32056>;
        <D.32055>:
        D.32057 = assembly->method_to_table_idx;
        D.32009 = assemblyb->entry_point;
        D.32058 = D.32009->method;
        D.32059 = monoeg_g_hash_table_lookup (D.32057, D.32058);
        D.32060 = (long int) D.32059;
        table_idx = (guint32) D.32060;
        <D.32056>:
        D.32061 = table_idx | 100663296;
        cli_header->ch_entry_point = D.32061;
      }
      goto <D.32062>;
      <D.32011>:
      cli_header->ch_entry_point = 0;
      <D.32062>:
      D.31973 = assembly->text_rva;
      D.32063 = assembly->code.index;
      text_offset = D.31973 + D.32063;
      cli_header->ch_resources.rva = text_offset;
      D.32064 = assembly->resources.index;
      cli_header->ch_resources.size = D.32064;
      D.32064 = assembly->resources.index;
      text_offset = D.32064 + text_offset;
      cli_header->ch_metadata.rva = text_offset;
      D.32065 = assembly->meta_size;
      cli_header->ch_metadata.size = D.32065;
      D.32065 = assembly->meta_size;
      text_offset = D.32065 + text_offset;
      D.32066 = assembly->strong_name_size;
      if (D.32066 != 0) goto <D.32067>; else goto <D.32068>;
      <D.32067>:
      cli_header->ch_strong_name.rva = text_offset;
      D.32066 = assembly->strong_name_size;
      cli_header->ch_strong_name.size = D.32066;
      D.32066 = assembly->strong_name_size;
      text_offset = D.32066 + text_offset;
      <D.32068>:
      D.31949 = pefile->data;
      D.32069 = (sizetype) section_start;
      section = D.31949 + D.32069;
      i = 0;
      goto <D.21469>;
      <D.21468>:
      {
        static const char section_names[3][7] = {".text", ".rsrc", ".reloc"};

        D.31943 = assembly->sections[i].size;
        if (D.31943 == 0) goto <D.32070>; else goto <D.32071>;
        <D.32070>:
        // predicted unlikely by continue predictor.
        goto <D.21467>;
        <D.32071>:
        D.32072 = &section->st_name;
        D.32073 = &section_names[i];
        strcpy (D.32072, D.32073);
        D.32074 = assembly->sections[i].rva;
        section->st_virtual_address = D.32074;
        D.31943 = assembly->sections[i].size;
        section->st_virtual_size = D.31943;
        D.32075 = section->st_virtual_size;
        D.32076 = D.32075 + 511;
        section->st_raw_data_size = D.32076;
        D.32077 = section->st_raw_data_size;
        D.32078 = D.32077 & 4294966784;
        section->st_raw_data_size = D.32078;
        D.32079 = assembly->sections[i].offset;
        section->st_raw_data_ptr = D.32079;
        D.32080 = assembly->sections[i].attrs;
        section->st_flags = D.32080;
        section = section + 40;
      }
      <D.21467>:
      i = i + 1;
      <D.21469>:
      if (i <= 2) goto <D.21468>; else goto <D.21470>;
      <D.21470>:
      D.31949 = pefile->data;
      D.32081 = pefile->index;
      checked_write_file (file, D.31949, D.32081);
      mono_dynamic_stream_reset (pefile);
      i = 0;
      goto <D.21485>;
      <D.21484>:
      D.31943 = assembly->sections[i].size;
      if (D.31943 == 0) goto <D.32082>; else goto <D.32083>;
      <D.32082>:
      // predicted unlikely by continue predictor.
      goto <D.21471>;
      <D.32083>:
      D.32079 = assembly->sections[i].offset;
      D.32084 = (int) D.32079;
      D.32085 = SetFilePointer (file, D.32084, 0B, 0);
      if (D.32085 == 4294967295) goto <D.32086>; else goto <D.32087>;
      <D.32086>:
      D.32088 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.32088);
      <D.21472>:
      goto <D.21472>;
      <D.32087>:
      switch (i) <default: <D.21483>, case 0: <D.21473>, case 1: <D.21482>, case 2: <D.21475>>
      <D.21473>:
      D.31980 = assembly->code.data;
      p = D.31980 + 2;
      D.31973 = assembly->text_rva;
      D.32089 = D.31973 + virtual_base;
      D.31976 = assembly->iat_offset;
      value = D.32089 + D.31976;
      p.228 = p;
      p = p.228 + 1;
      D.31998 = (unsigned char) value;
      *p.228 = D.31998;
      p.229 = p;
      p = p.229 + 1;
      D.32000 = value >> 8;
      D.32001 = (unsigned char) D.32000;
      *p.229 = D.32001;
      p.230 = p;
      p = p.230 + 1;
      D.32003 = value >> 16;
      D.32004 = (unsigned char) D.32003;
      *p.230 = D.32004;
      p.231 = p;
      p = p.231 + 1;
      D.32006 = value >> 24;
      D.32007 = (unsigned char) D.32006;
      *p.231 = D.32007;
      D.31980 = assembly->code.data;
      D.32063 = assembly->code.index;
      checked_write_file (file, D.31980, D.32063);
      D.32094 = assembly->resources.data;
      D.32064 = assembly->resources.index;
      checked_write_file (file, D.32094, D.32064);
      D.32095 = assembly->image.raw_metadata;
      D.32065 = assembly->meta_size;
      checked_write_file (file, D.32095, D.32065);
      D.32096 = assembly->strong_name;
      D.32066 = assembly->strong_name_size;
      checked_write_file (file, D.32096, D.32066);
      D.32095 = assembly->image.raw_metadata;
      monoeg_g_free (D.32095);
      goto <D.21474>;
      <D.21475>:
      {
        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.32097>; else goto <D.32098>;
            <D.32097>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5935, "sizeof (reloc) == 12");
            <D.32098>:
            D.31973 = assembly->text_rva;
            reloc.page_rva = D.31973;
            reloc.block_size = 12;
            reloc.type_and_offset = 12290;
            reloc.term = 0;
            checked_write_file (file, &reloc, 12);
            goto <D.21474>;
          }
        finally
          {
            reloc = {CLOBBER};
          }
      }
      <D.21482>:
      D.32099 = assembly->win32_res;
      if (D.32099 != 0B) goto <D.32100>; else goto <D.32101>;
      <D.32100>:
      D.32099 = assembly->win32_res;
      D.32099 = assembly->win32_res;
      D.32074 = assembly->sections[i].rva;
      fixup_resource_directory (D.32099, D.32099, D.32074);
      D.32099 = assembly->win32_res;
      D.32102 = assembly->win32_res_size;
      checked_write_file (file, D.32099, D.32102);
      <D.32101>:
      goto <D.21474>;
      <D.21483>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 5961);
      <D.21474>:
      <D.21471>:
      i = i + 1;
      <D.21485>:
      if (i <= 2) goto <D.21484>; else goto <D.21486>;
      <D.21486>:
      file_offset.232 = (int) file_offset;
      D.32104 = SetFilePointer (file, file_offset.232, 0B, 0);
      if (D.32104 == 4294967295) goto <D.32105>; else goto <D.32106>;
      <D.32105>:
      D.32107 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.32107);
      <D.21487>:
      goto <D.21487>;
      <D.32106>:
      D.32108 = SetEndOfFile (file);
      if (D.32108 == 0) goto <D.32109>; else goto <D.32110>;
      <D.32109>:
      D.32111 = GetLastError ();
      monoeg_g_log (0B, 4, "SetEndOfFile returned %d\n", D.32111);
      <D.21488>:
      goto <D.21488>;
      <D.32110>:
      D.32112 = &assembly->code;
      mono_dynamic_stream_reset (D.32112);
      D.32113 = &assembly->us;
      mono_dynamic_stream_reset (D.32113);
      D.32114 = &assembly->blob;
      mono_dynamic_stream_reset (D.32114);
      D.32115 = &assembly->guid;
      mono_dynamic_stream_reset (D.32115);
      D.32116 = &assembly->sheap;
      mono_dynamic_stream_reset (D.32116);
      D.32117 = assembly->blob_cache;
      monoeg_g_hash_table_foreach (D.32117, monoeg_g_free, 0B);
      D.32117 = assembly->blob_cache;
      monoeg_g_hash_table_destroy (D.32117);
      assembly->blob_cache = 0B;
    }
  finally
    {
      pefile_stream = {CLOBBER};
    }
}


assembly_add_resource (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc)
{
  struct MonoString * D.32120;
  unsigned int D.32123;
  unsigned int D.32124;
  guint32 * D.32125;
  unsigned int D.32126;
  unsigned int D.32127;
  long unsigned int D.32128;
  long unsigned int D.32129;
  guint32 * D.32130;
  struct MonoDynamicStream * D.32131;
  unsigned int D.32132;
  char * b.233;
  guint32 * D.32134;
  struct MonoDynamicStream * D.32135;
  long int b.234;
  long int blob_size.235;
  long int D.32138;
  unsigned int D.32139;
  unsigned int D.32140;
  unsigned int idx.236;
  unsigned int D.32142;
  struct MonoArray * D.32144;
  long unsigned int D.32147;
  char D.32149;
  unsigned int D.32150;
  char D.32151;
  unsigned int D.32152;
  char D.32153;
  unsigned int D.32154;
  char D.32155;
  struct MonoDynamicStream * D.32156;
  unsigned int D.32157;
  int D.32158;
  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.32120 = rsrc->filename;
      if (D.32120 != 0B) goto <D.32121>; else goto <D.32122>;
      <D.32121>:
      D.32120 = rsrc->filename;
      name = mono_string_to_utf8 (D.32120);
      sname = monoeg_g_path_get_basename (name);
      table = &assembly->tables[38];
      D.32123 = table->rows;
      D.32124 = D.32123 + 1;
      table->rows = D.32124;
      D.32123 = table->rows;
      alloc_table (table, D.32123);
      D.32125 = table->values;
      D.32126 = table->next_idx;
      D.32127 = D.32126 * 3;
      D.32128 = (long unsigned int) D.32127;
      D.32129 = D.32128 * 4;
      values = D.32125 + D.32129;
      *values = 1;
      D.32130 = values + 4;
      D.32131 = &assembly->sheap;
      D.32132 = string_heap_insert (D.32131, sname);
      *D.32130 = D.32132;
      monoeg_g_free (sname);
      mono_sha1_get_digest_from_file (name, &hash);
      b.233 = b;
      mono_metadata_encode_value (20, b.233, &b);
      D.32134 = values + 8;
      D.32135 = &assembly->blob;
      b.233 = b;
      b.234 = (long int) b.233;
      blob_size.235 = (long int) &blob_size;
      D.32138 = b.234 - blob_size.235;
      D.32139 = (unsigned int) D.32138;
      D.32140 = mono_image_add_stream_data (D.32135, &blob_size, D.32139);
      *D.32134 = D.32140;
      D.32135 = &assembly->blob;
      mono_image_add_stream_data (D.32135, &hash, 20);
      monoeg_g_free (name);
      D.32126 = table->next_idx;
      idx.236 = D.32126;
      D.32142 = idx.236 + 1;
      table->next_idx = D.32142;
      idx = idx.236;
      rsrc->offset = 0;
      idx = idx << 2;
      goto <D.32143>;
      <D.32122>:
      {
        char sizebuf[4];
        char * data;
        guint len;

        try
          {
            D.32144 = rsrc->data;
            if (D.32144 != 0B) goto <D.32145>; else goto <D.32146>;
            <D.32145>:
            D.32144 = rsrc->data;
            data = mono_array_addr_with_size (D.32144, 1, 0);
            D.32144 = rsrc->data;
            D.32147 = mono_array_length (D.32144);
            len = (guint) D.32147;
            goto <D.32148>;
            <D.32146>:
            data = 0B;
            len = 0;
            <D.32148>:
            offset = len;
            D.32149 = (char) offset;
            sizebuf[0] = D.32149;
            D.32150 = offset >> 8;
            D.32151 = (char) D.32150;
            sizebuf[1] = D.32151;
            D.32152 = offset >> 16;
            D.32153 = (char) D.32152;
            sizebuf[2] = D.32153;
            D.32154 = offset >> 24;
            D.32155 = (char) D.32154;
            sizebuf[3] = D.32155;
            D.32156 = &assembly->resources;
            D.32157 = mono_image_add_stream_data (D.32156, &sizebuf, 4);
            rsrc->offset = D.32157;
            D.32156 = &assembly->resources;
            mono_image_add_stream_data (D.32156, data, len);
            D.32158 = mb->is_main;
            if (D.32158 == 0) goto <D.32159>; else goto <D.32160>;
            <D.32159>:
            return;
            <D.32160>:
            idx = 0;
          }
        finally
          {
            sizebuf = {CLOBBER};
          }
      }
      <D.32143>:
      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.32166;
  void * * D.32167;
  unsigned int D.32168;
  long unsigned int D.32169;
  long unsigned int D.32170;
  long unsigned int D.32171;
  void * * D.32172;
  unsigned int i.237;
  struct MonoDynamicStream * D.32174;
  struct MonoDynamicStream * D.32175;
  struct MonoDynamicStream * D.32176;
  struct MonoDynamicStream * D.32177;
  struct MonoDynamicStream * D.32178;
  unsigned int D.32179;
  _Bool D.32180;
  unsigned int D.32181;
  _Bool D.32182;
  unsigned int D.32183;
  _Bool D.32184;
  unsigned int D.32185;
  unsigned int D.32186;
  <unnamed-unsigned:24> D.32187;
  <unnamed-unsigned:24> D.32188;
  long unsigned int D.32191;
  guint32 * D.32192;
  int D.32193;
  unsigned char D.32194;
  unsigned char D.32195;
  int D.32196;
  int D.32197;
  int D.32198;
  unsigned int D.32199;
  unsigned int D.32200;
  long unsigned int D.32201;
  void * D.32202;
  unsigned char * p.238;
  unsigned char * p.239;
  unsigned char * p.240;
  unsigned char * p.241;
  guint16 * int16val.242;
  short int D.32208;
  short unsigned int D.32209;
  short int D.32210;
  short unsigned int D.32211;
  char * D.32212;
  long unsigned int D.32213;
  unsigned int D.32214;
  unsigned int D.32215;
  unsigned int D.32216;
  long unsigned int D.32217;
  unsigned int D.32218;
  sizetype D.32219;
  long int p.243;
  char * D.32221;
  long int D.32222;
  long int D.32223;
  unsigned int D.32224;
  unsigned int D.32227;
  sizetype D.32228;
  guint16 * int16val.244;
  unsigned int D.32230;
  struct MonoDynamicStream * D.32231;
  guint32 * int32val.245;
  unsigned int D.32233;
  const char * D.32234;
  long unsigned int D.32235;
  sizetype D.32236;
  unsigned int D.32237;
  unsigned int D.32240;
  sizetype D.32241;
  unsigned int D.32242;
  long int D.32243;
  _Bool D.32244;
  long int D.32245;
  long int D.32246;
  sizetype D.32249;
  unsigned char * p.246;
  unsigned char * p.247;
  long unsigned int D.32252;
  long unsigned int D.32253;
  unsigned char D.32256;
  unsigned char D.32257;
  long unsigned int D.32258;
  unsigned char D.32261;
  long unsigned int D.32262;
  unsigned char D.32265;
  unsigned char * p.248;
  guint64 * int64val.249;
  guint64 * int64val.250;
  long unsigned int D.32269;
  guint32 * int32val.251;
  unsigned int D.32273;
  unsigned int D.32274;
  guint32 * D.32277;
  void * D.32278;
  long unsigned int D.32279;
  void * D.32282;
  void * D.32287;
  unsigned char D.32296;
  unsigned int D.32297;
  unsigned int D.32298;
  int D.32301;
  guint32 * D.32302;
  int D.32303;
  long unsigned int D.32304;
  long unsigned int D.32305;
  int D.32306;
  unsigned int D.32307;
  unsigned int D.32308;
  unsigned int D.32309;
  unsigned char * p.252;
  long unsigned int D.32311;
  long unsigned int D.32312;
  guint32 * D.32313;
  unsigned int D.32314;
  unsigned char D.32315;
  unsigned char * p.253;
  unsigned char * p.254;
  unsigned int D.32318;
  unsigned char D.32319;
  unsigned char * p.255;
  unsigned char * p.256;
  unsigned char * p.257;
  unsigned int D.32323;
  unsigned char D.32324;
  unsigned char * p.258;
  unsigned int D.32326;
  unsigned char D.32327;
  const char * D.32328;
  long int D.32329;
  long int D.32330;
  long int D.32331;
  _Bool D.32332;
  long int D.32333;
  long int D.32334;
  unsigned int D.32337;
  unsigned int D.32338;
  _Bool D.32339;
  long int D.32340;
  long int D.32341;
  unsigned int D.32344;
  sizetype D.32345;
  char * D.32346;
  char * D.32347;
  long unsigned int D.32348;
  unsigned int D.32349;
  sizetype D.32350;
  char * D.32351;
  char * D.32352;
  long unsigned int D.32353;
  unsigned int D.32354;
  sizetype D.32355;
  char * D.32356;
  char * D.32357;
  long unsigned int D.32358;
  sizetype D.32359;
  char * D.32360;
  char * D.32361;
  long unsigned int D.32362;
  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.32166 = assembly->gen_params;
      D.32167 = D.32166->pdata;
      D.32166 = assembly->gen_params;
      D.32168 = D.32166->len;
      D.32169 = (long unsigned int) D.32168;
      qsort (D.32167, D.32169, 8, compare_genericparam);
      i = 0;
      goto <D.20537>;
      <D.20536>:
      {
        struct GenericParamTableEntry * entry;

        D.32166 = assembly->gen_params;
        D.32167 = D.32166->pdata;
        D.32170 = (long unsigned int) i;
        D.32171 = D.32170 * 8;
        D.32172 = D.32167 + D.32171;
        entry = *D.32172;
        write_generic_param_entry (assembly, entry);
      }
      i = i + 1;
      <D.20537>:
      i.237 = (unsigned int) i;
      D.32166 = assembly->gen_params;
      D.32168 = D.32166->len;
      if (i.237 < D.32168) goto <D.20536>; else goto <D.20538>;
      <D.20538>:
      stream_desc[0].name = "#~";
      D.32174 = &assembly->tstream;
      stream_desc[0].stream = D.32174;
      stream_desc[1].name = "#Strings";
      D.32175 = &assembly->sheap;
      stream_desc[1].stream = D.32175;
      stream_desc[2].name = "#US";
      D.32176 = &assembly->us;
      stream_desc[2].stream = D.32176;
      stream_desc[3].name = "#Blob";
      D.32177 = &assembly->blob;
      stream_desc[3].stream = D.32177;
      stream_desc[4].name = "#GUID";
      D.32178 = &assembly->guid;
      stream_desc[4].stream = D.32178;
      sorted_mask = 6597925534208;
      meta = &assembly->image;
      D.32177 = &assembly->blob;
      pad_heap (D.32177);
      D.32178 = &assembly->guid;
      pad_heap (D.32178);
      D.32175 = &assembly->sheap;
      pad_heap (D.32175);
      D.32176 = &assembly->us;
      pad_heap (D.32176);
      D.32179 = assembly->blob.index;
      D.32180 = D.32179 > 65535;
      meta->idx_blob_wide = D.32180;
      D.32181 = assembly->guid.index;
      D.32182 = D.32181 > 65535;
      meta->idx_guid_wide = D.32182;
      D.32183 = assembly->sheap.index;
      D.32184 = D.32183 > 65535;
      meta->idx_string_wide = D.32184;
      D.32179 = assembly->blob.index;
      meta_size = D.32179 + meta_size;
      D.32181 = assembly->guid.index;
      meta_size = D.32181 + meta_size;
      D.32183 = assembly->sheap.index;
      meta_size = D.32183 + meta_size;
      D.32185 = assembly->us.index;
      meta_size = D.32185 + meta_size;
      i = 0;
      goto <D.20540>;
      <D.20539>:
      D.32186 = assembly->tables[i].rows;
      D.32187 = (<unnamed-unsigned:24>) D.32186;
      meta->tables[i].rows = D.32187;
      i = i + 1;
      <D.20540>:
      if (i <= 44) goto <D.20539>; else goto <D.20541>;
      <D.20541>:
      i = 0;
      goto <D.20544>;
      <D.20543>:
      D.32188 = meta->tables[i].rows;
      if (D.32188 == 0) goto <D.32189>; else goto <D.32190>;
      <D.32189>:
      // predicted unlikely by continue predictor.
      goto <D.20542>;
      <D.32190>:
      D.32191 = 1 << i;
      valid_mask = D.32191 | valid_mask;
      ntables = ntables + 1;
      D.32192 = &meta->tables[i].size_bitfield;
      D.32193 = mono_metadata_compute_size (meta, i, D.32192);
      D.32194 = (unsigned char) D.32193;
      meta->tables[i].row_size = D.32194;
      D.32195 = meta->tables[i].row_size;
      D.32196 = (int) D.32195;
      D.32188 = meta->tables[i].rows;
      D.32197 = (int) D.32188;
      D.32198 = D.32196 * D.32197;
      D.32199 = (unsigned int) D.32198;
      heapt_size = D.32199 + heapt_size;
      <D.20542>:
      i = i + 1;
      <D.20544>:
      if (i <= 44) goto <D.20543>; else goto <D.20545>;
      <D.20545>:
      heapt_size = heapt_size + 24;
      D.32200 = ntables * 4;
      heapt_size = D.32200 + heapt_size;
      heapt_size = heapt_size + 3;
      heapt_size = heapt_size & 4294967292;
      meta_size = meta_size + heapt_size;
      D.32201 = (long unsigned int) meta_size;
      D.32202 = monoeg_malloc0 (D.32201);
      meta->raw_metadata = D.32202;
      p = meta->raw_metadata;
      p.238 = p;
      p = p.238 + 1;
      *p.238 = 66;
      p.239 = p;
      p = p.239 + 1;
      *p.239 = 83;
      p.240 = p;
      p = p.240 + 1;
      *p.240 = 74;
      p.241 = p;
      p = p.241 + 1;
      *p.241 = 66;
      int16val = p;
      int16val.242 = int16val;
      int16val = int16val.242 + 2;
      D.32208 = meta->md_version_major;
      D.32209 = (short unsigned int) D.32208;
      *int16val.242 = D.32209;
      D.32210 = meta->md_version_minor;
      D.32211 = (short unsigned int) D.32210;
      *int16val = D.32211;
      p = p + 8;
      int32val = p;
      D.32212 = meta->version;
      D.32213 = strlen (D.32212);
      D.32214 = (unsigned int) D.32213;
      D.32215 = D.32214 + 3;
      D.32216 = D.32215 & 4294967292;
      *int32val = D.32216;
      p = p + 4;
      D.32212 = meta->version;
      D.32212 = meta->version;
      D.32217 = strlen (D.32212);
      memcpy (p, D.32212, D.32217);
      D.32218 = *int32val;
      D.32219 = (sizetype) D.32218;
      p = p + D.32219;
      {
        guint32 __diff;

        p.243 = (long int) p;
        D.32221 = meta->raw_metadata;
        D.32222 = (long int) D.32221;
        D.32223 = p.243 - D.32222;
        __diff = (guint32) D.32223;
        D.32224 = __diff & 3;
        if (D.32224 != 0) goto <D.32225>; else goto <D.32226>;
        <D.32225>:
        D.32224 = __diff & 3;
        D.32227 = 4 - D.32224;
        D.32228 = (sizetype) D.32227;
        p = p + D.32228;
        <D.32226>:
      }
      int16val = p;
      int16val.244 = int16val;
      int16val = int16val.244 + 2;
      *int16val.244 = 0;
      *int16val = 5;
      p = p + 4;
      p.243 = (long int) p;
      D.32221 = meta->raw_metadata;
      D.32222 = (long int) D.32221;
      D.32223 = p.243 - D.32222;
      D.32230 = (unsigned int) D.32223;
      table_offset = D.32230 + 80;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      assembly->tstream.index = heapt_size;
      i = 0;
      goto <D.20549>;
      <D.20548>:
      int32val = p;
      D.32231 = stream_desc[i].stream;
      D.32231->offset = table_offset;
      int32val.245 = int32val;
      int32val = int32val.245 + 4;
      *int32val.245 = table_offset;
      D.32231 = stream_desc[i].stream;
      D.32233 = D.32231->index;
      *int32val = D.32233;
      D.32218 = *int32val;
      table_offset = D.32218 + table_offset;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      p = p + 8;
      D.32234 = stream_desc[i].name;
      strcpy (p, D.32234);
      D.32234 = stream_desc[i].name;
      D.32235 = strlen (D.32234);
      D.32236 = D.32235 + 1;
      p = p + D.32236;
      {
        guint32 __diff;

        p.243 = (long int) p;
        D.32221 = meta->raw_metadata;
        D.32222 = (long int) D.32221;
        D.32223 = p.243 - D.32222;
        __diff = (guint32) D.32223;
        D.32237 = __diff & 3;
        if (D.32237 != 0) goto <D.32238>; else goto <D.32239>;
        <D.32238>:
        D.32237 = __diff & 3;
        D.32240 = 4 - D.32237;
        D.32241 = (sizetype) D.32240;
        p = p + D.32241;
        <D.32239>:
      }
      i = i + 1;
      <D.20549>:
      if (i <= 4) goto <D.20548>; else goto <D.20550>;
      <D.20550>:
      p.243 = (long int) p;
      D.32221 = meta->raw_metadata;
      D.32222 = (long int) D.32221;
      D.32223 = p.243 - D.32222;
      D.32242 = assembly->tstream.offset;
      D.32243 = (long int) D.32242;
      D.32244 = D.32223 >= D.32243;
      D.32245 = (long int) D.32244;
      D.32246 = __builtin_expect (D.32245, 0);
      if (D.32246 != 0) goto <D.32247>; else goto <D.32248>;
      <D.32247>:
      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.32248>:
      D.32221 = meta->raw_metadata;
      D.32242 = assembly->tstream.offset;
      D.32249 = (sizetype) D.32242;
      p = D.32221 + D.32249;
      int32val = p;
      *int32val = 0;
      p = p + 4;
      p.246 = p;
      p = p.246 + 1;
      *p.246 = 2;
      p.247 = p;
      p = p.247 + 1;
      *p.247 = 0;
      D.32252 = BIT_FIELD_REF <*meta, 64, 192>;
      D.32253 = D.32252 & 1099511627776;
      if (D.32253 != 0) goto <D.32254>; else goto <D.32255>;
      <D.32254>:
      D.32256 = *p;
      D.32257 = D.32256 | 1;
      *p = D.32257;
      <D.32255>:
      D.32252 = BIT_FIELD_REF <*meta, 64, 192>;
      D.32258 = D.32252 & 2199023255552;
      if (D.32258 != 0) goto <D.32259>; else goto <D.32260>;
      <D.32259>:
      D.32256 = *p;
      D.32261 = D.32256 | 2;
      *p = D.32261;
      <D.32260>:
      D.32252 = BIT_FIELD_REF <*meta, 64, 192>;
      D.32262 = D.32252 & 4398046511104;
      if (D.32262 != 0) goto <D.32263>; else goto <D.32264>;
      <D.32263>:
      D.32256 = *p;
      D.32265 = D.32256 | 4;
      *p = D.32265;
      <D.32264>:
      p = p + 1;
      p.248 = p;
      p = p.248 + 1;
      *p.248 = 1;
      int64val = p;
      int64val.249 = int64val;
      int64val = int64val.249 + 8;
      *int64val.249 = valid_mask;
      int64val.250 = int64val;
      int64val = int64val.250 + 8;
      D.32269 = valid_mask & sorted_mask;
      *int64val.250 = D.32269;
      p = p + 16;
      int32val = p;
      i = 0;
      goto <D.20553>;
      <D.20552>:
      D.32188 = meta->tables[i].rows;
      if (D.32188 == 0) goto <D.32270>; else goto <D.32271>;
      <D.32270>:
      // predicted unlikely by continue predictor.
      goto <D.20551>;
      <D.32271>:
      int32val.251 = int32val;
      int32val = int32val.251 + 4;
      D.32188 = meta->tables[i].rows;
      D.32273 = (unsigned int) D.32188;
      *int32val.251 = D.32273;
      <D.20551>:
      i = i + 1;
      <D.20553>:
      if (i <= 44) goto <D.20552>; else goto <D.20554>;
      <D.20554>:
      p = int32val;
      table = &assembly->tables[11];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32275>; else goto <D.32276>;
      <D.32275>:
      D.32277 = table->values;
      D.32278 = D.32277 + 16;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32278, D.32279, 16, compare_constants);
      <D.32276>:
      table = &assembly->tables[24];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32280>; else goto <D.32281>;
      <D.32280>:
      D.32277 = table->values;
      D.32282 = D.32277 + 12;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32282, D.32279, 12, compare_semantics);
      <D.32281>:
      table = &assembly->tables[12];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32283>; else goto <D.32284>;
      <D.32283>:
      D.32277 = table->values;
      D.32282 = D.32277 + 12;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32282, D.32279, 12, compare_custom_attrs);
      <D.32284>:
      table = &assembly->tables[13];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32285>; else goto <D.32286>;
      <D.32285>:
      D.32277 = table->values;
      D.32287 = D.32277 + 8;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32287, D.32279, 8, compare_field_marshal);
      <D.32286>:
      table = &assembly->tables[41];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32288>; else goto <D.32289>;
      <D.32288>:
      D.32277 = table->values;
      D.32287 = D.32277 + 8;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32287, D.32279, 8, compare_nested);
      <D.32289>:
      table = &assembly->tables[14];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32290>; else goto <D.32291>;
      <D.32290>:
      D.32277 = table->values;
      D.32282 = D.32277 + 12;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32282, D.32279, 12, compare_declsecurity_attrs);
      <D.32291>:
      table = &assembly->tables[9];
      D.32274 = table->rows;
      if (D.32274 != 0) goto <D.32292>; else goto <D.32293>;
      <D.32292>:
      D.32277 = table->values;
      D.32287 = D.32277 + 8;
      D.32274 = table->rows;
      D.32279 = (long unsigned int) D.32274;
      qsort (D.32287, D.32279, 8, compare_interface_impl);
      <D.32293>:
      i = 0;
      goto <D.20573>;
      <D.20572>:
      {
        int row;
        int col;
        guint32 * values;
        guint32 bitfield;

        bitfield = meta->tables[i].size_bitfield;
        D.32188 = meta->tables[i].rows;
        if (D.32188 == 0) goto <D.32294>; else goto <D.32295>;
        <D.32294>:
        // predicted unlikely by continue predictor.
        goto <D.20559>;
        <D.32295>:
        D.32296 = assembly->tables[i].columns;
        D.32297 = (unsigned int) D.32296;
        D.32298 = bitfield >> 24;
        if (D.32297 != D.32298) goto <D.32299>; else goto <D.32300>;
        <D.32299>:
        D.32296 = assembly->tables[i].columns;
        D.32301 = (int) D.32296;
        D.32298 = bitfield >> 24;
        monoeg_g_log (0B, 4, "col count mismatch in %d: %d %d", i, D.32301, D.32298);
        <D.20560>:
        goto <D.20560>;
        <D.32300>:
        meta->tables[i].base = p;
        row = 1;
        goto <D.20570>;
        <D.20569>:
        D.32302 = assembly->tables[i].values;
        D.32296 = assembly->tables[i].columns;
        D.32301 = (int) D.32296;
        D.32303 = D.32301 * row;
        D.32304 = (long unsigned int) D.32303;
        D.32305 = D.32304 * 4;
        values = D.32302 + D.32305;
        col = 0;
        goto <D.20567>;
        <D.20566>:
        D.32306 = col * 2;
        D.32307 = bitfield >> D.32306;
        D.32308 = D.32307 & 3;
        D.32309 = D.32308 + 1;
        switch (D.32309) <default: <D.20565>, case 1: <D.20561>, case 2: <D.20563>, case 4: <D.20564>>
        <D.20561>:
        p.252 = p;
        p = p.252 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32315 = (unsigned char) D.32314;
        *p.252 = D.32315;
        goto <D.20562>;
        <D.20563>:
        p.253 = p;
        p = p.253 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32315 = (unsigned char) D.32314;
        *p.253 = D.32315;
        p.254 = p;
        p = p.254 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32318 = D.32314 >> 8;
        D.32319 = (unsigned char) D.32318;
        *p.254 = D.32319;
        goto <D.20562>;
        <D.20564>:
        p.255 = p;
        p = p.255 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32315 = (unsigned char) D.32314;
        *p.255 = D.32315;
        p.256 = p;
        p = p.256 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32318 = D.32314 >> 8;
        D.32319 = (unsigned char) D.32318;
        *p.256 = D.32319;
        p.257 = p;
        p = p.257 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32323 = D.32314 >> 16;
        D.32324 = (unsigned char) D.32323;
        *p.257 = D.32324;
        p.258 = p;
        p = p.258 + 1;
        D.32311 = (long unsigned int) col;
        D.32312 = D.32311 * 4;
        D.32313 = values + D.32312;
        D.32314 = *D.32313;
        D.32326 = D.32314 >> 24;
        D.32327 = (unsigned char) D.32326;
        *p.258 = D.32327;
        goto <D.20562>;
        <D.20565>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4187);
        <D.20562>:
        col = col + 1;
        <D.20567>:
        D.32296 = assembly->tables[i].columns;
        D.32301 = (int) D.32296;
        if (D.32301 > col) goto <D.20566>; else goto <D.20568>;
        <D.20568>:
        row = row + 1;
        <D.20570>:
        D.32188 = meta->tables[i].rows;
        D.32197 = (int) D.32188;
        if (D.32197 >= row) goto <D.20569>; else goto <D.20571>;
        <D.20571>:
        p.243 = (long int) p;
        D.32328 = meta->tables[i].base;
        D.32329 = (long int) D.32328;
        D.32330 = p.243 - D.32329;
        D.32188 = meta->tables[i].rows;
        D.32197 = (int) D.32188;
        D.32195 = meta->tables[i].row_size;
        D.32196 = (int) D.32195;
        D.32198 = D.32197 * D.32196;
        D.32331 = (long int) D.32198;
        D.32332 = D.32330 != D.32331;
        D.32333 = (long int) D.32332;
        D.32334 = __builtin_expect (D.32333, 0);
        if (D.32334 != 0) goto <D.32335>; else goto <D.32336>;
        <D.32335>:
        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.32336>:
      }
      <D.20559>:
      i = i + 1;
      <D.20573>:
      if (i <= 44) goto <D.20572>; else goto <D.20574>;
      <D.20574>:
      D.32337 = assembly->guid.offset;
      D.32181 = assembly->guid.index;
      D.32338 = D.32337 + D.32181;
      D.32339 = D.32338 >= meta_size;
      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", 4194, "assembly->guid.offset + assembly->guid.index < meta_size");
      <D.32343>:
      D.32221 = meta->raw_metadata;
      D.32344 = assembly->sheap.offset;
      D.32345 = (sizetype) D.32344;
      D.32346 = D.32221 + D.32345;
      D.32347 = assembly->sheap.data;
      D.32183 = assembly->sheap.index;
      D.32348 = (long unsigned int) D.32183;
      memcpy (D.32346, D.32347, D.32348);
      D.32221 = meta->raw_metadata;
      D.32349 = assembly->us.offset;
      D.32350 = (sizetype) D.32349;
      D.32351 = D.32221 + D.32350;
      D.32352 = assembly->us.data;
      D.32185 = assembly->us.index;
      D.32353 = (long unsigned int) D.32185;
      memcpy (D.32351, D.32352, D.32353);
      D.32221 = meta->raw_metadata;
      D.32354 = assembly->blob.offset;
      D.32355 = (sizetype) D.32354;
      D.32356 = D.32221 + D.32355;
      D.32357 = assembly->blob.data;
      D.32179 = assembly->blob.index;
      D.32358 = (long unsigned int) D.32179;
      memcpy (D.32356, D.32357, D.32358);
      D.32221 = meta->raw_metadata;
      D.32337 = assembly->guid.offset;
      D.32359 = (sizetype) D.32337;
      D.32360 = D.32221 + D.32359;
      D.32361 = assembly->guid.data;
      D.32181 = assembly->guid.index;
      D.32362 = (long unsigned int) D.32181;
      memcpy (D.32360, D.32361, D.32362);
      D.32337 = assembly->guid.offset;
      D.32181 = assembly->guid.index;
      D.32338 = D.32337 + D.32181;
      assembly->meta_size = D.32338;
    }
  finally
    {
      stream_desc = {CLOBBER};
    }
}


compare_interface_impl (const void * a, const void * b)
{
  unsigned int D.32363;
  unsigned int D.32364;
  unsigned int D.32365;
  int D.32368;
  const guint32 * D.32369;
  unsigned int D.32370;
  const guint32 * D.32371;
  unsigned int D.32372;
  unsigned int D.32373;
  const guint32 * a_values;
  const guint32 * b_values;
  int klass;

  a_values = a;
  b_values = b;
  D.32363 = *a_values;
  D.32364 = *b_values;
  D.32365 = D.32363 - D.32364;
  klass = (int) D.32365;
  if (klass != 0) goto <D.32366>; else goto <D.32367>;
  <D.32366>:
  D.32368 = klass;
  return D.32368;
  <D.32367>:
  D.32369 = a_values + 4;
  D.32370 = *D.32369;
  D.32371 = b_values + 4;
  D.32372 = *D.32371;
  D.32373 = D.32370 - D.32372;
  D.32368 = (int) D.32373;
  return D.32368;
}


compare_declsecurity_attrs (const void * a, const void * b)
{
  int D.32375;
  const guint32 * D.32376;
  unsigned int D.32377;
  const guint32 * D.32378;
  unsigned int D.32379;
  unsigned int D.32380;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.32376 = a_values + 4;
  D.32377 = *D.32376;
  D.32378 = b_values + 4;
  D.32379 = *D.32378;
  D.32380 = D.32377 - D.32379;
  D.32375 = (int) D.32380;
  return D.32375;
}


compare_nested (const void * a, const void * b)
{
  int D.32382;
  unsigned int D.32383;
  unsigned int D.32384;
  unsigned int D.32385;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.32383 = *a_values;
  D.32384 = *b_values;
  D.32385 = D.32383 - D.32384;
  D.32382 = (int) D.32385;
  return D.32382;
}


compare_field_marshal (const void * a, const void * b)
{
  int D.32387;
  unsigned int D.32388;
  unsigned int D.32389;
  unsigned int D.32390;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.32388 = *a_values;
  D.32389 = *b_values;
  D.32390 = D.32388 - D.32389;
  D.32387 = (int) D.32390;
  return D.32387;
}


compare_custom_attrs (const void * a, const void * b)
{
  int D.32392;
  unsigned int D.32393;
  unsigned int D.32394;
  unsigned int D.32395;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.32393 = *a_values;
  D.32394 = *b_values;
  D.32395 = D.32393 - D.32394;
  D.32392 = (int) D.32395;
  return D.32392;
}


compare_semantics (const void * a, const void * b)
{
  const guint32 * D.32397;
  unsigned int D.32398;
  const guint32 * D.32399;
  unsigned int D.32400;
  unsigned int D.32401;
  int D.32404;
  unsigned int D.32405;
  unsigned int D.32406;
  unsigned int D.32407;
  const guint32 * a_values;
  const guint32 * b_values;
  int assoc;

  a_values = a;
  b_values = b;
  D.32397 = a_values + 8;
  D.32398 = *D.32397;
  D.32399 = b_values + 8;
  D.32400 = *D.32399;
  D.32401 = D.32398 - D.32400;
  assoc = (int) D.32401;
  if (assoc != 0) goto <D.32402>; else goto <D.32403>;
  <D.32402>:
  D.32404 = assoc;
  return D.32404;
  <D.32403>:
  D.32405 = *a_values;
  D.32406 = *b_values;
  D.32407 = D.32405 - D.32406;
  D.32404 = (int) D.32407;
  return D.32404;
}


compare_constants (const void * a, const void * b)
{
  int D.32409;
  const guint32 * D.32410;
  unsigned int D.32411;
  const guint32 * D.32412;
  unsigned int D.32413;
  unsigned int D.32414;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.32410 = a_values + 8;
  D.32411 = *D.32410;
  D.32412 = b_values + 8;
  D.32413 = *D.32412;
  D.32414 = D.32411 - D.32413;
  D.32409 = (int) D.32414;
  return D.32409;
}


compare_genericparam (const void * a, const void * b)
{
  const struct GenericParamTableEntry * D.32416;
  unsigned int D.32417;
  const struct GenericParamTableEntry * D.32418;
  unsigned int D.32419;
  int D.32422;
  struct MonoReflectionGenericParam * D.32423;
  struct MonoType * D.32424;
  struct MonoGenericParam * D.32425;
  short unsigned int D.32426;
  int D.32427;
  struct MonoReflectionGenericParam * D.32428;
  struct MonoType * D.32429;
  struct MonoGenericParam * D.32430;
  short unsigned int D.32431;
  int D.32432;
  unsigned int D.32433;
  const struct GenericParamTableEntry * * a_entry;
  const struct GenericParamTableEntry * * b_entry;

  a_entry = a;
  b_entry = b;
  D.32416 = *b_entry;
  D.32417 = D.32416->owner;
  D.32418 = *a_entry;
  D.32419 = D.32418->owner;
  if (D.32417 == D.32419) goto <D.32420>; else goto <D.32421>;
  <D.32420>:
  D.32418 = *a_entry;
  D.32423 = D.32418->gparam;
  D.32424 = mono_reflection_type_get_handle (D.32423);
  D.32425 = D.32424->data.generic_param;
  D.32426 = D.32425->num;
  D.32427 = (int) D.32426;
  D.32416 = *b_entry;
  D.32428 = D.32416->gparam;
  D.32429 = mono_reflection_type_get_handle (D.32428);
  D.32430 = D.32429->data.generic_param;
  D.32431 = D.32430->num;
  D.32432 = (int) D.32431;
  D.32422 = D.32427 - D.32432;
  return D.32422;
  <D.32421>:
  D.32418 = *a_entry;
  D.32419 = D.32418->owner;
  D.32416 = *b_entry;
  D.32417 = D.32416->owner;
  D.32433 = D.32419 - D.32417;
  D.32422 = (int) D.32433;
  return D.32422;
}


write_generic_param_entry (struct MonoDynamicImage * assembly, struct GenericParamTableEntry * entry)
{
  unsigned int D.32435;
  unsigned int table_idx.259;
  unsigned int D.32437;
  guint32 * D.32438;
  unsigned int D.32439;
  long unsigned int D.32440;
  long unsigned int D.32441;
  struct MonoReflectionGenericParam * D.32442;
  struct MonoType * D.32443;
  guint32 * D.32444;
  unsigned int D.32445;
  guint32 * D.32446;
  unsigned int D.32447;
  short unsigned int D.32448;
  unsigned int D.32449;
  guint32 * D.32450;
  struct MonoDynamicStream * D.32451;
  struct MonoGenericParamInfo * iftmp.260;
  struct MonoGenericContainer * D.32453;
  const char * D.32457;
  unsigned int D.32458;
  struct MonoArray * D.32459;
  struct MonoDynamicTable * table;
  struct MonoGenericParam * param;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[42];
  D.32435 = table->next_idx;
  table_idx.259 = D.32435;
  D.32437 = table_idx.259 + 1;
  table->next_idx = D.32437;
  table_idx = table_idx.259;
  D.32438 = table->values;
  D.32439 = table_idx * 4;
  D.32440 = (long unsigned int) D.32439;
  D.32441 = D.32440 * 4;
  values = D.32438 + D.32441;
  D.32442 = entry->gparam;
  D.32443 = mono_reflection_type_get_handle (D.32442);
  param = D.32443->data.generic_param;
  D.32444 = values + 8;
  D.32445 = entry->owner;
  *D.32444 = D.32445;
  D.32446 = values + 4;
  D.32442 = entry->gparam;
  D.32447 = D.32442->attrs;
  *D.32446 = D.32447;
  D.32448 = param->num;
  D.32449 = (unsigned int) D.32448;
  *values = D.32449;
  D.32450 = values + 12;
  D.32451 = &assembly->sheap;
  D.32453 = param->owner;
  if (D.32453 != 0B) goto <D.32454>; else goto <D.32455>;
  <D.32454>:
  iftmp.260 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.32456>;
  <D.32455>:
  iftmp.260 = 0B;
  <D.32456>:
  D.32457 = iftmp.260->name;
  D.32458 = string_heap_insert (D.32451, D.32457);
  *D.32450 = D.32458;
  D.32442 = entry->gparam;
  D.32459 = D.32442->cattrs;
  mono_image_add_cattrs (assembly, table_idx, 19, D.32459);
  D.32442 = entry->gparam;
  encode_constraints (D.32442, table_idx, assembly);
}


encode_constraints (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  guint32 iftmp.261;
  struct MonoArray * D.32461;
  long unsigned int D.32464;
  unsigned int D.32466;
  unsigned int D.32467;
  struct MonoReflectionType * D.32468;
  unsigned int D.32471;
  unsigned int D.32474;
  unsigned int table_idx.262;
  unsigned int D.32476;
  guint32 * D.32477;
  unsigned int D.32478;
  long unsigned int D.32479;
  long unsigned int D.32480;
  guint32 * D.32481;
  struct MonoType * D.32482;
  unsigned int D.32483;
  long unsigned int D.32484;
  char * D.32485;
  unsigned int table_idx.263;
  unsigned int D.32487;
  struct MonoType * D.32488;
  unsigned int D.32489;
  struct MonoDynamicTable * table;
  guint32 num_constraints;
  guint32 i;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[44];
  D.32461 = gparam->iface_constraints;
  if (D.32461 != 0B) goto <D.32462>; else goto <D.32463>;
  <D.32462>:
  D.32461 = gparam->iface_constraints;
  D.32464 = mono_array_length (D.32461);
  iftmp.261 = (guint32) D.32464;
  goto <D.32465>;
  <D.32463>:
  iftmp.261 = 0;
  <D.32465>:
  num_constraints = iftmp.261;
  D.32466 = table->rows;
  D.32467 = D.32466 + num_constraints;
  table->rows = D.32467;
  D.32468 = gparam->base_type;
  if (D.32468 != 0B) goto <D.32469>; else goto <D.32470>;
  <D.32469>:
  D.32466 = table->rows;
  D.32471 = D.32466 + 1;
  table->rows = D.32471;
  <D.32470>:
  D.32466 = table->rows;
  alloc_table (table, D.32466);
  D.32468 = gparam->base_type;
  if (D.32468 != 0B) goto <D.32472>; else goto <D.32473>;
  <D.32472>:
  D.32474 = table->next_idx;
  table_idx.262 = D.32474;
  D.32476 = table_idx.262 + 1;
  table->next_idx = D.32476;
  table_idx = table_idx.262;
  D.32477 = table->values;
  D.32478 = table_idx * 2;
  D.32479 = (long unsigned int) D.32478;
  D.32480 = D.32479 * 4;
  values = D.32477 + D.32480;
  *values = owner;
  D.32481 = values + 4;
  D.32468 = gparam->base_type;
  D.32482 = mono_reflection_type_get_handle (D.32468);
  D.32483 = mono_image_typedef_or_ref (assembly, D.32482);
  *D.32481 = D.32483;
  <D.32473>:
  i = 0;
  goto <D.19849>;
  <D.19848>:
  {
    struct MonoReflectionType * constraint;

    D.32461 = gparam->iface_constraints;
    D.32484 = (long unsigned int) i;
    D.32485 = mono_array_addr_with_size (D.32461, 8, D.32484);
    constraint = MEM[(void * *)D.32485];
    D.32474 = table->next_idx;
    table_idx.263 = D.32474;
    D.32487 = table_idx.263 + 1;
    table->next_idx = D.32487;
    table_idx = table_idx.263;
    D.32477 = table->values;
    D.32478 = table_idx * 2;
    D.32479 = (long unsigned int) D.32478;
    D.32480 = D.32479 * 4;
    values = D.32477 + D.32480;
    *values = owner;
    D.32481 = values + 4;
    D.32488 = mono_reflection_type_get_handle (constraint);
    D.32489 = mono_image_typedef_or_ref (assembly, D.32488);
    *D.32481 = D.32489;
  }
  i = i + 1;
  <D.19849>:
  if (i < num_constraints) goto <D.19848>; else goto <D.19850>;
  <D.19850>:
}


pad_heap (struct MonoDynamicStream * sh)
{
  unsigned int D.32490;
  unsigned int D.32491;
  unsigned int D.32494;
  char * D.32495;
  sizetype D.32496;
  void * D.32497;
  long unsigned int D.32498;
  unsigned int sz.264;
  unsigned int D.32500;

  D.32490 = sh->index;
  D.32491 = D.32490 & 3;
  if (D.32491 != 0) goto <D.32492>; else goto <D.32493>;
  <D.32492>:
  {
    int sz;

    D.32490 = sh->index;
    D.32491 = D.32490 & 3;
    D.32494 = 4 - D.32491;
    sz = (int) D.32494;
    D.32495 = sh->data;
    D.32490 = sh->index;
    D.32496 = (sizetype) D.32490;
    D.32497 = D.32495 + D.32496;
    D.32498 = (long unsigned int) sz;
    memset (D.32497, 0, D.32498);
    D.32490 = sh->index;
    sz.264 = (unsigned int) sz;
    D.32500 = D.32490 + sz.264;
    sh->index = D.32500;
  }
  <D.32493>:
}


assembly_add_win32_resources (struct MonoDynamicImage * assembly, struct MonoReflectionAssemblyBuilder * assemblyb)
{
  struct MonoArray * D.32501;
  long unsigned int D.32504;
  struct MonoArray * D.32505;
  long unsigned int D.32506;
  unsigned int D.32507;
  long unsigned int D.32508;
  long unsigned int D.32509;
  long unsigned int D.32510;
  unsigned int D.32511;
  long unsigned int D.32512;
  char * p.265;
  long int p.266;
  long int buf.267;
  long int D.32516;
  long int D.32517;
  _Bool D.32518;
  long int D.32519;
  long int D.32520;
  long unsigned int D.32523;
  void * D.32524;
  unsigned int D.32525;
  char * D.32526;
  long unsigned int D.32527;
  char * buf;
  char * p;
  guint32 size;
  guint32 i;
  struct MonoReflectionWin32Resource * win32_res;
  struct ResTreeNode * tree;

  try
    {
      D.32501 = assemblyb->win32_resources;
      if (D.32501 == 0B) goto <D.32502>; else goto <D.32503>;
      <D.32502>:
      return;
      <D.32503>:
      D.32501 = assemblyb->win32_resources;
      tree = resource_tree_create (D.32501);
      size = 0;
      i = 0;
      goto <D.21394>;
      <D.21393>:
      D.32501 = assemblyb->win32_resources;
      D.32504 = (long unsigned int) i;
      win32_res = mono_array_addr_with_size (D.32501, 24, D.32504);
      D.32505 = win32_res->res_data;
      D.32506 = mono_array_length (D.32505);
      D.32507 = (unsigned int) D.32506;
      size = D.32507 + size;
      i = i + 1;
      <D.21394>:
      D.32504 = (long unsigned int) i;
      D.32501 = assemblyb->win32_resources;
      D.32508 = mono_array_length (D.32501);
      if (D.32504 < D.32508) goto <D.21393>; else goto <D.21395>;
      <D.21395>:
      D.32501 = assemblyb->win32_resources;
      D.32509 = mono_array_length (D.32501);
      D.32510 = D.32509 * 256;
      D.32511 = (unsigned int) D.32510;
      size = D.32511 + size;
      D.32512 = (long unsigned int) size;
      buf = monoeg_malloc (D.32512);
      p = buf;
      p.265 = p;
      p.265 = p;
      resource_tree_encode (tree, p.265, p.265, &p);
      p.265 = p;
      p.266 = (long int) p.265;
      buf.267 = (long int) buf;
      D.32516 = p.266 - buf.267;
      D.32517 = (long int) size;
      D.32518 = D.32516 > D.32517;
      D.32519 = (long int) D.32518;
      D.32520 = __builtin_expect (D.32519, 0);
      if (D.32520 != 0) goto <D.32521>; else goto <D.32522>;
      <D.32521>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5585, "p - buf <= size");
      <D.32522>:
      p.265 = p;
      p.266 = (long int) p.265;
      buf.267 = (long int) buf;
      D.32516 = p.266 - buf.267;
      D.32523 = (long unsigned int) D.32516;
      D.32524 = monoeg_malloc (D.32523);
      assembly->win32_res = D.32524;
      p.265 = p;
      p.266 = (long int) p.265;
      buf.267 = (long int) buf;
      D.32516 = p.266 - buf.267;
      D.32525 = (unsigned int) D.32516;
      assembly->win32_res_size = D.32525;
      D.32526 = assembly->win32_res;
      p.265 = p;
      p.266 = (long int) p.265;
      buf.267 = (long int) buf;
      D.32516 = p.266 - buf.267;
      D.32527 = (long unsigned int) D.32516;
      memcpy (D.32526, buf, D.32527);
      monoeg_g_free (buf);
      resource_tree_free (tree);
    }
  finally
    {
      p = {CLOBBER};
    }
}


resource_tree_create (struct MonoArray * win32_resources)
{
  long unsigned int D.32531;
  unsigned int D.32532;
  void * D.32533;
  unsigned int D.32534;
  unsigned int D.32535;
  struct GSList * D.32540;
  struct GSList * D.32541;
  unsigned int D.32542;
  struct GSList * D.32547;
  struct GSList * D.32548;
  struct GSList * D.32549;
  struct GSList * D.32550;
  long unsigned int D.32551;
  struct ResTreeNode * D.32552;
  struct ResTreeNode * tree;
  struct ResTreeNode * res_node;
  struct ResTreeNode * type_node;
  struct ResTreeNode * lang_node;
  struct GSList * l;
  int i;

  tree = monoeg_malloc0 (24);
  i = 0;
  goto <D.21353>;
  <D.21352>:
  {
    struct MonoReflectionWin32Resource * win32_res;

    D.32531 = (long unsigned int) i;
    win32_res = mono_array_addr_with_size (win32_resources, 24, D.32531);
    lang_node = monoeg_malloc0 (24);
    D.32532 = win32_res->lang_id;
    lang_node->id = D.32532;
    lang_node->win32_res = win32_res;
    type_node = 0B;
    l = tree->children;
    goto <D.21348>;
    <D.21347>:
    D.32533 = l->data;
    D.32534 = MEM[(struct ResTreeNode *)D.32533].id;
    D.32535 = win32_res->res_type;
    if (D.32534 == D.32535) goto <D.32536>; else goto <D.32537>;
    <D.32536>:
    type_node = l->data;
    goto <D.21346>;
    <D.32537>:
    l = l->next;
    <D.21348>:
    if (l != 0B) goto <D.21347>; else goto <D.21346>;
    <D.21346>:
    if (type_node == 0B) goto <D.32538>; else goto <D.32539>;
    <D.32538>:
    type_node = monoeg_malloc0 (24);
    D.32535 = win32_res->res_type;
    type_node->id = D.32535;
    D.32540 = tree->children;
    D.32541 = monoeg_g_slist_insert_sorted (D.32540, type_node, resource_tree_compare_by_id);
    tree->children = D.32541;
    <D.32539>:
    res_node = 0B;
    l = type_node->children;
    goto <D.21351>;
    <D.21350>:
    D.32533 = l->data;
    D.32534 = MEM[(struct ResTreeNode *)D.32533].id;
    D.32542 = win32_res->res_id;
    if (D.32534 == D.32542) goto <D.32543>; else goto <D.32544>;
    <D.32543>:
    res_node = l->data;
    goto <D.21349>;
    <D.32544>:
    l = l->next;
    <D.21351>:
    if (l != 0B) goto <D.21350>; else goto <D.21349>;
    <D.21349>:
    if (res_node == 0B) goto <D.32545>; else goto <D.32546>;
    <D.32545>:
    res_node = monoeg_malloc0 (24);
    D.32542 = win32_res->res_id;
    res_node->id = D.32542;
    D.32547 = type_node->children;
    D.32548 = monoeg_g_slist_append (D.32547, res_node);
    type_node->children = D.32548;
    <D.32546>:
    D.32549 = res_node->children;
    D.32550 = monoeg_g_slist_append (D.32549, lang_node);
    res_node->children = D.32550;
  }
  i = i + 1;
  <D.21353>:
  D.32531 = (long unsigned int) i;
  D.32551 = mono_array_length (win32_resources);
  if (D.32531 < D.32551) goto <D.21352>; else goto <D.21354>;
  <D.21354>:
  D.32552 = tree;
  return D.32552;
}


resource_tree_compare_by_id (const void * a, const void * b)
{
  int D.32554;
  unsigned int D.32555;
  unsigned int D.32556;
  unsigned int D.32557;
  struct ResTreeNode * t1;
  struct ResTreeNode * t2;

  t1 = a;
  t2 = b;
  D.32555 = t1->id;
  D.32556 = t2->id;
  D.32557 = D.32555 - D.32556;
  D.32554 = (int) D.32557;
  return D.32554;
}


resource_tree_encode (struct ResTreeNode * node, char * begin, char * p, char * * endbuf)
{
  char * p.268;
  long int p.269;
  long int begin.270;
  long int D.32568;
  unsigned int D.32569;
  struct GSList * D.32570;
  short unsigned int D.32571;
  char * p.271;
  long unsigned int D.32573;
  long unsigned int D.32574;
  char * p.272;
  struct MonoReflectionWin32Resource * D.32576;
  unsigned int D.32579;
  struct MonoArray * D.32580;
  long unsigned int D.32581;
  char * D.32582;
  long unsigned int D.32583;
  sizetype D.32584;
  char * p.273;
  unsigned int D.32587;
  unsigned int D.32588;
  unsigned int iftmp.274;
  struct MonoReflectionWin32Resource * D.32590;
  unsigned int D.32594;
  unsigned int D.32595;
  unsigned int D.32596;
  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.32559>; else goto <D.32560>;
      <D.32559>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5486, "sizeof (dir) == 16");
      <D.32560>:
      if (0 != 0) goto <D.32561>; else goto <D.32562>;
      <D.32561>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5487, "sizeof (dir_entry) == 8");
      <D.32562>:
      if (0 != 0) goto <D.32563>; else goto <D.32564>;
      <D.32563>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5488, "sizeof (data_entry) == 16");
      <D.32564>:
      p.268 = p;
      p.269 = (long int) p.268;
      begin.270 = (long int) begin;
      D.32568 = p.269 - begin.270;
      D.32569 = (unsigned int) D.32568;
      node->offset = D.32569;
      D.32570 = node->children;
      res_id_entries = monoeg_g_slist_length (D.32570);
      D.32571 = (short unsigned int) res_id_entries;
      dir.res_id_entries = D.32571;
      p.268 = p;
      memcpy (p.268, &dir, 16);
      p.268 = p;
      p.271 = p.268 + 16;
      p = p.271;
      entries = p;
      p.268 = p;
      D.32573 = (long unsigned int) res_id_entries;
      D.32574 = D.32573 * 8;
      p.272 = p.268 + D.32574;
      p = p.272;
      l = node->children;
      goto <D.21370>;
      <D.21369>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.32576 = child->win32_res;
        if (D.32576 != 0B) goto <D.32577>; else goto <D.32578>;
        <D.32577>:
        {
          guint32 size;

          p.268 = p;
          p.269 = (long int) p.268;
          begin.270 = (long int) begin;
          D.32568 = p.269 - begin.270;
          D.32569 = (unsigned int) D.32568;
          child->offset = D.32569;
          p.268 = p;
          p.269 = (long int) p.268;
          begin.270 = (long int) begin;
          D.32568 = p.269 - begin.270;
          D.32569 = (unsigned int) D.32568;
          D.32579 = D.32569 + 16;
          data_entry.rde_data_offset = D.32579;
          D.32576 = child->win32_res;
          D.32580 = D.32576->res_data;
          D.32581 = mono_array_length (D.32580);
          size = (guint32) D.32581;
          data_entry.rde_size = size;
          p.268 = p;
          memcpy (p.268, &data_entry, 16);
          p.268 = p;
          p.271 = p.268 + 16;
          p = p.271;
          p.268 = p;
          D.32576 = child->win32_res;
          D.32580 = D.32576->res_data;
          D.32582 = mono_array_addr_with_size (D.32580, 1, 0);
          D.32583 = (long unsigned int) size;
          memcpy (p.268, D.32582, D.32583);
          p.268 = p;
          D.32584 = (sizetype) size;
          p.273 = p.268 + D.32584;
          p = p.273;
        }
        goto <D.32586>;
        <D.32578>:
        p.268 = p;
        resource_tree_encode (child, begin, p.268, &p);
        <D.32586>:
      }
      l = l->next;
      <D.21370>:
      if (l != 0B) goto <D.21369>; else goto <D.21371>;
      <D.21371>:
      l = node->children;
      goto <D.21374>;
      <D.21373>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.32587 = child->id;
        D.32588 = D.32587 & 2147483647;
        dir_entry.name = D.32588;
        D.32590 = child->win32_res;
        if (D.32590 == 0B) goto <D.32591>; else goto <D.32592>;
        <D.32591>:
        iftmp.274 = 2147483648;
        goto <D.32593>;
        <D.32592>:
        iftmp.274 = 0;
        <D.32593>:
        D.32594 = child->offset;
        D.32595 = D.32594 & 2147483647;
        D.32596 = iftmp.274 | D.32595;
        dir_entry.dir = D.32596;
        memcpy (entries, &dir_entry, 8);
        entries = entries + 8;
      }
      l = l->next;
      <D.21374>:
      if (l != 0B) goto <D.21373>; else goto <D.21375>;
      <D.21375>:
      p.268 = p;
      *endbuf = p.268;
    }
  finally
    {
      dir = {CLOBBER};
      dir_entry = {CLOBBER};
      data_entry = {CLOBBER};
    }
}


resource_tree_free (struct ResTreeNode * node)
{
  void * D.32597;
  struct GSList * D.32598;
  struct GSList * list;

  list = node->children;
  goto <D.21381>;
  <D.21380>:
  D.32597 = list->data;
  resource_tree_free (D.32597);
  list = list->next;
  <D.21381>:
  if (list != 0B) goto <D.21380>; else goto <D.21382>;
  <D.21382>:
  D.32598 = node->children;
  monoeg_g_slist_free (D.32598);
  monoeg_g_free (node);
}


calc_section_size (struct MonoDynamicImage * assembly)
{
  struct MonoDynamicStream * D.32599;
  unsigned int D.32600;
  unsigned int D.32601;
  unsigned int D.32602;
  _Bool D.32603;
  long int D.32604;
  long int D.32605;
  unsigned int D.32608;
  unsigned int D.32609;
  unsigned int D.32610;
  struct MonoDynamicStream * D.32611;
  unsigned int D.32612;
  unsigned int D.32613;
  unsigned int D.32614;
  _Bool D.32615;
  long int D.32616;
  long int D.32617;
  unsigned int D.32620;
  unsigned int D.32621;
  unsigned int D.32622;
  unsigned int D.32623;
  char * D.32624;
  unsigned int D.32627;
  unsigned int D.32628;
  int D.32629;
  int nsections;

  nsections = 0;
  D.32599 = &assembly->code;
  D.32600 = assembly->code.index;
  D.32601 = D.32600 & 3;
  D.32602 = 4 - D.32601;
  mono_image_add_stream_zero (D.32599, D.32602);
  D.32600 = assembly->code.index;
  D.32601 = D.32600 & 3;
  D.32603 = D.32601 != 0;
  D.32604 = (long int) D.32603;
  D.32605 = __builtin_expect (D.32604, 0);
  if (D.32605 != 0) goto <D.32606>; else goto <D.32607>;
  <D.32606>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5355, "(assembly->code.index % 4) == 0");
  <D.32607>:
  D.32608 = assembly->meta_size;
  D.32609 = D.32608 + 3;
  assembly->meta_size = D.32609;
  D.32608 = assembly->meta_size;
  D.32610 = D.32608 & 4294967292;
  assembly->meta_size = D.32610;
  D.32611 = &assembly->resources;
  D.32612 = assembly->resources.index;
  D.32613 = D.32612 & 3;
  D.32614 = 4 - D.32613;
  mono_image_add_stream_zero (D.32611, D.32614);
  D.32612 = assembly->resources.index;
  D.32613 = D.32612 & 3;
  D.32615 = D.32613 != 0;
  D.32616 = (long int) D.32615;
  D.32617 = __builtin_expect (D.32616, 0);
  if (D.32617 != 0) goto <D.32618>; else goto <D.32619>;
  <D.32618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5359, "(assembly->resources.index % 4) == 0");
  <D.32619>:
  D.32608 = assembly->meta_size;
  D.32600 = assembly->code.index;
  D.32620 = D.32608 + D.32600;
  D.32612 = assembly->resources.index;
  D.32621 = D.32620 + D.32612;
  D.32622 = assembly->strong_name_size;
  D.32623 = D.32621 + D.32622;
  assembly->sections[0].size = D.32623;
  assembly->sections[0].attrs = 1610612768;
  nsections = nsections + 1;
  D.32624 = assembly->win32_res;
  if (D.32624 != 0B) goto <D.32625>; else goto <D.32626>;
  <D.32625>:
  {
    guint32 res_size;

    D.32627 = assembly->win32_res_size;
    D.32628 = D.32627 + 3;
    res_size = D.32628 & 4294967292;
    assembly->sections[1].size = res_size;
    assembly->sections[1].attrs = 1073741888;
    nsections = nsections + 1;
  }
  <D.32626>:
  assembly->sections[2].size = 12;
  assembly->sections[2].attrs = 1107296320;
  nsections = nsections + 1;
  D.32629 = nsections;
  return D.32629;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.32631;
  long unsigned int D.32632;

  D.32632 = __builtin_object_size (__dest, 1);
  D.32631 = __builtin___strcpy_chk (__dest, __src, D.32632);
  return D.32631;
}


fixup_resource_directory (char * res_section, char * p, guint32 rva)
{
  unsigned int D.32634;
  sizetype D.32635;
  sizetype D.32636;
  signed int D.32637;
  unsigned int D.32641;
  unsigned int D.32642;
  short unsigned int D.32643;
  int D.32644;
  short unsigned int D.32645;
  int D.32646;
  int D.32647;
  struct MonoPEResourceDir * dir;
  int i;

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

    dir_entry = p;
    D.32634 = dir_entry->dir;
    D.32635 = (sizetype) D.32634;
    D.32636 = D.32635 & 2147483647;
    child = res_section + D.32636;
    D.32634 = dir_entry->dir;
    D.32637 = (signed int) D.32634;
    if (D.32637 < 0) goto <D.32638>; else goto <D.32639>;
    <D.32638>:
    fixup_resource_directory (res_section, child, rva);
    goto <D.32640>;
    <D.32639>:
    {
      struct MonoPEResourceDataEntry * data_entry;

      data_entry = child;
      D.32641 = data_entry->rde_data_offset;
      D.32642 = D.32641 + rva;
      data_entry->rde_data_offset = D.32642;
    }
    <D.32640>:
    p = p + 8;
  }
  i = i + 1;
  <D.21407>:
  D.32643 = dir->res_named_entries;
  D.32644 = (int) D.32643;
  D.32645 = dir->res_id_entries;
  D.32646 = (int) D.32645;
  D.32647 = D.32644 + D.32646;
  if (D.32647 > i) goto <D.21406>; else goto <D.21408>;
  <D.21408>:
}


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

  try
    {
      D.32648 = WriteFile (f, buffer, numbytes, &dummy, 0B);
      if (D.32648 == 0) goto <D.32649>; else goto <D.32650>;
      <D.32649>:
      D.32651 = GetLastError ();
      monoeg_g_log (0B, 4, "WriteFile returned %d\n", D.32651);
      <D.21415>:
      goto <D.21415>;
      <D.32650>:
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


mono_image_load_module_dynamic (struct MonoReflectionAssemblyBuilder * ab, struct MonoString * fileName)
{
  <unnamed type> status.275;
  struct MonoAssembly * D.32658;
  struct MonoImage * D.32659;
  unsigned int D.32660;
  long unsigned int D.32661;
  long unsigned int D.32662;
  long unsigned int D.32663;
  struct MonoImage * * D.32664;
  long unsigned int D.32667;
  long unsigned int D.32668;
  gboolean * D.32669;
  long unsigned int D.32672;
  struct MonoImage * * D.32673;
  gboolean * D.32674;
  unsigned int D.32675;
  unsigned int D.32676;
  struct MonoException * D.32679;
  struct MonoReflectionModule * D.32680;
  struct MonoDomain * D.32681;
  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.32652>; else goto <D.32653>;
      <D.32652>:
      {
        struct MonoException * exc;

        status.275 = status;
        if (status.275 == 1) goto <D.32655>; else goto <D.32656>;
        <D.32655>:
        exc = mono_get_exception_file_not_found (fileName);
        goto <D.32657>;
        <D.32656>:
        exc = mono_get_exception_bad_image_format (name);
        <D.32657>:
        monoeg_g_free (name);
        mono_raise_exception (exc);
      }
      <D.32653>:
      monoeg_g_free (name);
      assembly = ab->dynamic_assembly;
      image->assembly = assembly;
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      module_count = D.32659->module_count;
      D.32660 = module_count + 1;
      D.32661 = (long unsigned int) D.32660;
      D.32662 = D.32661 * 8;
      new_modules = monoeg_malloc0 (D.32662);
      D.32660 = module_count + 1;
      D.32661 = (long unsigned int) D.32660;
      D.32663 = D.32661 * 4;
      new_modules_loaded = monoeg_malloc0 (D.32663);
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32664 = D.32659->modules;
      if (D.32664 != 0B) goto <D.32665>; else goto <D.32666>;
      <D.32665>:
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32664 = D.32659->modules;
      D.32667 = (long unsigned int) module_count;
      D.32668 = D.32667 * 8;
      memcpy (new_modules, D.32664, D.32668);
      <D.32666>:
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32669 = D.32659->modules_loaded;
      if (D.32669 != 0B) goto <D.32670>; else goto <D.32671>;
      <D.32670>:
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32669 = D.32659->modules_loaded;
      D.32667 = (long unsigned int) module_count;
      D.32672 = D.32667 * 4;
      memcpy (new_modules_loaded, D.32669, D.32672);
      <D.32671>:
      D.32667 = (long unsigned int) module_count;
      D.32668 = D.32667 * 8;
      D.32673 = new_modules + D.32668;
      *D.32673 = image;
      D.32667 = (long unsigned int) module_count;
      D.32672 = D.32667 * 4;
      D.32674 = new_modules_loaded + D.32672;
      *D.32674 = 1;
      mono_image_addref (image);
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32664 = D.32659->modules;
      monoeg_g_free (D.32664);
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32659->modules = new_modules;
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32659->modules_loaded = new_modules_loaded;
      D.32658 = image->assembly;
      D.32659 = D.32658->image;
      D.32675 = D.32659->module_count;
      D.32676 = D.32675 + 1;
      D.32659->module_count = D.32676;
      mono_assembly_load_references (image, &status);
      status.275 = status;
      if (status.275 != 0) goto <D.32677>; else goto <D.32678>;
      <D.32677>:
      mono_image_close (image);
      D.32679 = mono_get_exception_file_not_found (fileName);
      mono_raise_exception (D.32679);
      <D.32678>:
      D.32681 = mono_domain_get ();
      D.32680 = mono_module_get_object (D.32681, image);
      return D.32680;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

  D.32684 = domain->refobject_hash;
  if (D.32684 != 0B) goto <D.32685>; else goto <D.32686>;
  <D.32685>:
  D.32684 = domain->refobject_hash;
  mono_g_hash_table_destroy (D.32684);
  domain->refobject_hash = 0B;
  <D.32686>:
}


mono_image_module_basic_init (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoString * D.32689;
  struct MonoString * D.32690;
  int D.32691;
  struct MonoDynamicAssembly * D.32694;
  struct MonoImage * D.32695;
  struct MonoVTable * D.32696;
  struct MonoDomain * D.32697;
  unsigned int D.32698;
  int D.32699;
  long unsigned int D.32700;
  long unsigned int D.32701;
  struct MonoImage * * D.32702;
  long unsigned int D.32705;
  long unsigned int D.32706;
  struct MonoImage * * D.32707;
  unsigned int D.32708;
  struct MonoDynamicImage * image;
  struct MonoReflectionAssemblyBuilder * ab;

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

    try
      {
        D.32689 = ab->name;
        name = mono_string_to_utf8 (D.32689);
        D.32690 = moduleb->module.fqname;
        fqname = mono_string_to_utf8_checked (D.32690, &error);
        D.32691 = mono_error_ok (&error);
        if (D.32691 == 0) goto <D.32692>; else goto <D.32693>;
        <D.32692>:
        monoeg_g_free (name);
        mono_error_raise_exception (&error);
        <D.32693>:
        D.32694 = ab->dynamic_assembly;
        image = create_dynamic_mono_image (D.32694, name, fqname);
        D.32695 = &image->image;
        moduleb->module.image = D.32695;
        moduleb->dynamic_image = image;
        D.32696 = MEM[(struct MonoObject *)moduleb].vtable;
        D.32697 = D.32696->domain;
        register_module (D.32697, moduleb, image);
        D.32694 = ab->dynamic_assembly;
        ass = D.32694->assembly.image;
        D.32698 = ass->module_count;
        module_count = (int) D.32698;
        D.32699 = module_count + 1;
        D.32700 = (long unsigned int) D.32699;
        D.32701 = D.32700 * 8;
        new_modules = monoeg_malloc0 (D.32701);
        D.32702 = ass->modules;
        if (D.32702 != 0B) goto <D.32703>; else goto <D.32704>;
        <D.32703>:
        D.32702 = ass->modules;
        D.32705 = (long unsigned int) module_count;
        D.32706 = D.32705 * 8;
        memcpy (new_modules, D.32702, D.32706);
        <D.32704>:
        D.32705 = (long unsigned int) module_count;
        D.32706 = D.32705 * 8;
        D.32707 = new_modules + D.32706;
        D.32695 = &image->image;
        *D.32707 = D.32695;
        D.32695 = &image->image;
        mono_image_addref (D.32695);
        D.32702 = ass->modules;
        monoeg_g_free (D.32702);
        ass->modules = new_modules;
        D.32698 = ass->module_count;
        D.32708 = D.32698 + 1;
        ass->module_count = D.32708;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.32688>:
}


register_module (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * res, struct MonoDynamicImage * module)
{
  union mono_mutex_t * D.32709;
  _Bool D.32712;
  long int D.32713;
  long int D.32714;
  struct MonoGHashTable * D.32717;
  struct MonoGHashTable * D.32720;
  struct MonoMemPool * D.32723;
  _Bool D.32726;
  long int D.32727;
  long int D.32728;
  void * D.32731;

  {
    struct MonoReflectionModuleBuilder * _obj;
    struct ReflectedEntry pe;

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

          D.32709 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32709);
          if (ret != 0) goto <D.32710>; else goto <D.32711>;
          <D.32710>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32711>:
          D.32712 = ret != 0;
          D.32713 = (long int) D.32712;
          D.32714 = __builtin_expect (D.32713, 0);
          if (D.32714 != 0) goto <D.32715>; else goto <D.32716>;
          <D.32715>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.32716>:
        }
        D.32717 = domain->refobject_hash;
        if (D.32717 == 0B) goto <D.32718>; else goto <D.32719>;
        <D.32718>:
        D.32720 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32720;
        <D.32719>:
        D.32717 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32717, &pe);
        if (_obj == 0B) goto <D.32721>; else goto <D.32722>;
        <D.32721>:
        {
          struct ReflectedEntry * e;

          D.32723 = domain->mp;
          e = mono_mempool_alloc (D.32723, 16);
          e->item = module;
          e->refclass = 0B;
          D.32717 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32717, e, res);
          _obj = res;
        }
        <D.32722>:
        {
          int ret;

          D.32709 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32709);
          if (ret != 0) goto <D.32724>; else goto <D.32725>;
          <D.32724>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32725>:
          D.32726 = ret != 0;
          D.32727 = (long int) D.32726;
          D.32728 = __builtin_expect (D.32727, 0);
          if (D.32728 != 0) goto <D.32729>; else goto <D.32730>;
          <D.32729>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.32730>:
        }
        D.32731 = _obj;
        return D.32731;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_image_set_wrappers_type (struct MonoReflectionModuleBuilder * moduleb, struct MonoReflectionType * type)
{
  struct MonoType * D.32734;
  _Bool D.32735;
  long int D.32736;
  long int D.32737;
  struct MonoClass * D.32740;
  struct MonoDynamicImage * image;

  image = moduleb->dynamic_image;
  D.32734 = type->type;
  D.32735 = D.32734 == 0B;
  D.32736 = (long int) D.32735;
  D.32737 = __builtin_expect (D.32736, 0);
  if (D.32737 != 0) goto <D.32738>; else goto <D.32739>;
  <D.32738>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6226, "type->type");
  <D.32739>:
  D.32734 = type->type;
  D.32740 = mono_class_from_mono_type (D.32734);
  image->wrappers_type = D.32740;
}


mono_assembly_get_object (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.32741;
  _Bool D.32744;
  long int D.32745;
  long int D.32746;
  struct MonoGHashTable * D.32749;
  struct MonoGHashTable * D.32752;
  _Bool D.32757;
  long int D.32758;
  long int D.32759;
  struct MonoReflectionAssembly * D.32762;
  _Bool D.32765;
  long int D.32766;
  long int D.32767;
  struct MonoClass * assembly_type.276;
  struct MonoImage * D.32773;
  _Bool D.32776;
  long int D.32777;
  long int D.32778;
  _Bool D.32783;
  long int D.32784;
  long int D.32785;
  struct MonoGHashTable * D.32790;
  struct MonoMemPool * D.32793;
  _Bool D.32796;
  long int D.32797;
  long int D.32798;
  static struct MonoClass * assembly_type;
  struct MonoReflectionAssembly * res;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry e;

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

          D.32741 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32741);
          if (ret != 0) goto <D.32742>; else goto <D.32743>;
          <D.32742>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32743>:
          D.32744 = ret != 0;
          D.32745 = (long int) D.32744;
          D.32746 = __builtin_expect (D.32745, 0);
          if (D.32746 != 0) goto <D.32747>; else goto <D.32748>;
          <D.32747>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.32748>:
        }
        D.32749 = domain->refobject_hash;
        if (D.32749 == 0B) goto <D.32750>; else goto <D.32751>;
        <D.32750>:
        D.32752 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32752;
        <D.32751>:
        D.32749 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32749, &e);
        if (_obj != 0B) goto <D.32753>; else goto <D.32754>;
        <D.32753>:
        {
          int ret;

          D.32741 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32741);
          if (ret != 0) goto <D.32755>; else goto <D.32756>;
          <D.32755>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32756>:
          D.32757 = ret != 0;
          D.32758 = (long int) D.32757;
          D.32759 = __builtin_expect (D.32758, 0);
          if (D.32759 != 0) goto <D.32760>; else goto <D.32761>;
          <D.32760>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.32761>:
        }
        D.32762 = _obj;
        return D.32762;
        <D.32754>:
        {
          int ret;

          D.32741 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32741);
          if (ret != 0) goto <D.32763>; else goto <D.32764>;
          <D.32763>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32764>:
          D.32765 = ret != 0;
          D.32766 = (long int) D.32765;
          D.32767 = __builtin_expect (D.32766, 0);
          if (D.32767 != 0) goto <D.32768>; else goto <D.32769>;
          <D.32768>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.32769>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  assembly_type.276 = assembly_type;
  if (assembly_type.276 == 0B) goto <D.32771>; else goto <D.32772>;
  <D.32771>:
  {
    struct MonoClass * class;

    D.32773 = mono_defaults.corlib;
    class = mono_class_from_name (D.32773, "System.Reflection", "MonoAssembly");
    if (class == 0B) goto <D.32774>; else goto <D.32775>;
    <D.32774>:
    D.32773 = mono_defaults.corlib;
    class = mono_class_from_name (D.32773, "System.Reflection", "Assembly");
    <D.32775>:
    D.32776 = class == 0B;
    D.32777 = (long int) D.32776;
    D.32778 = __builtin_expect (D.32777, 0);
    if (D.32778 != 0) goto <D.32779>; else goto <D.32780>;
    <D.32779>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6250, "class");
    <D.32780>:
    assembly_type = class;
  }
  <D.32772>:
  assembly_type.276 = assembly_type;
  res = mono_object_new (domain, assembly_type.276);
  res->assembly = assembly;
  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

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

          D.32741 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32741);
          if (ret != 0) goto <D.32781>; else goto <D.32782>;
          <D.32781>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32782>:
          D.32783 = ret != 0;
          D.32784 = (long int) D.32783;
          D.32785 = __builtin_expect (D.32784, 0);
          if (D.32785 != 0) goto <D.32786>; else goto <D.32787>;
          <D.32786>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.32787>:
        }
        D.32749 = domain->refobject_hash;
        if (D.32749 == 0B) goto <D.32788>; else goto <D.32789>;
        <D.32788>:
        D.32790 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32790;
        <D.32789>:
        D.32749 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32749, &pe);
        if (_obj == 0B) goto <D.32791>; else goto <D.32792>;
        <D.32791>:
        {
          struct ReflectedEntry * e;

          D.32793 = domain->mp;
          e = mono_mempool_alloc (D.32793, 16);
          e->item = assembly;
          e->refclass = 0B;
          D.32749 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32749, e, res);
          _obj = res;
        }
        <D.32792>:
        {
          int ret;

          D.32741 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32741);
          if (ret != 0) goto <D.32794>; else goto <D.32795>;
          <D.32794>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32795>:
          D.32796 = ret != 0;
          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", 6256, "ret == 0");
          <D.32800>:
        }
        D.32762 = _obj;
        return D.32762;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_get_object (struct MonoDomain * domain, struct MonoImage * image)
{
  union mono_mutex_t * D.32805;
  _Bool D.32808;
  long int D.32809;
  long int D.32810;
  struct MonoGHashTable * D.32813;
  struct MonoGHashTable * D.32816;
  _Bool D.32821;
  long int D.32822;
  long int D.32823;
  struct MonoReflectionModule * D.32826;
  _Bool D.32829;
  long int D.32830;
  long int D.32831;
  struct MonoClass * module_type.277;
  struct MonoImage * D.32837;
  _Bool D.32840;
  long int D.32841;
  long int D.32842;
  struct MonoReflectionAssembly * * D.32845;
  struct MonoAssembly * D.32846;
  struct MonoReflectionAssembly * D.32847;
  struct MonoString * * D.32848;
  char * D.32849;
  struct MonoString * D.32850;
  struct MonoString * * D.32851;
  struct MonoString * D.32852;
  struct MonoString * * D.32853;
  const char * D.32854;
  struct MonoString * D.32855;
  struct MonoImage * D.32856;
  struct MonoImage * * D.32860;
  long unsigned int D.32863;
  long unsigned int D.32864;
  struct MonoImage * * D.32865;
  struct MonoImage * D.32866;
  int D.32869;
  int D.32870;
  unsigned int D.32871;
  unsigned int i.278;
  unsigned int D.32873;
  unsigned int D.32874;
  _Bool D.32875;
  long int D.32876;
  long int D.32877;
  _Bool D.32882;
  long int D.32883;
  long int D.32884;
  struct MonoGHashTable * D.32889;
  struct MonoMemPool * D.32892;
  _Bool D.32895;
  long int D.32896;
  long int D.32897;
  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.32805 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32805);
          if (ret != 0) goto <D.32806>; else goto <D.32807>;
          <D.32806>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32807>:
          D.32808 = ret != 0;
          D.32809 = (long int) D.32808;
          D.32810 = __builtin_expect (D.32809, 0);
          if (D.32810 != 0) goto <D.32811>; else goto <D.32812>;
          <D.32811>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32812>:
        }
        D.32813 = domain->refobject_hash;
        if (D.32813 == 0B) goto <D.32814>; else goto <D.32815>;
        <D.32814>:
        D.32816 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32816;
        <D.32815>:
        D.32813 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32813, &e);
        if (_obj != 0B) goto <D.32817>; else goto <D.32818>;
        <D.32817>:
        {
          int ret;

          D.32805 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32805);
          if (ret != 0) goto <D.32819>; else goto <D.32820>;
          <D.32819>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32820>:
          D.32821 = ret != 0;
          D.32822 = (long int) D.32821;
          D.32823 = __builtin_expect (D.32822, 0);
          if (D.32823 != 0) goto <D.32824>; else goto <D.32825>;
          <D.32824>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32825>:
        }
        D.32826 = _obj;
        return D.32826;
        <D.32818>:
        {
          int ret;

          D.32805 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32805);
          if (ret != 0) goto <D.32827>; else goto <D.32828>;
          <D.32827>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32828>:
          D.32829 = ret != 0;
          D.32830 = (long int) D.32829;
          D.32831 = __builtin_expect (D.32830, 0);
          if (D.32831 != 0) goto <D.32832>; else goto <D.32833>;
          <D.32832>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32833>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  module_type.277 = module_type;
  if (module_type.277 == 0B) goto <D.32835>; else goto <D.32836>;
  <D.32835>:
  {
    struct MonoClass * class;

    D.32837 = mono_defaults.corlib;
    class = mono_class_from_name (D.32837, "System.Reflection", "MonoModule");
    if (class == 0B) goto <D.32838>; else goto <D.32839>;
    <D.32838>:
    D.32837 = mono_defaults.corlib;
    class = mono_class_from_name (D.32837, "System.Reflection", "Module");
    <D.32839>:
    D.32840 = class == 0B;
    D.32841 = (long int) D.32840;
    D.32842 = __builtin_expect (D.32841, 0);
    if (D.32842 != 0) goto <D.32843>; else goto <D.32844>;
    <D.32843>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6273, "class");
    <D.32844>:
    module_type = class;
  }
  <D.32836>:
  module_type.277 = module_type;
  res = mono_object_new (domain, module_type.277);
  res->image = image;
  D.32845 = &res->assembly;
  D.32846 = image->assembly;
  D.32847 = mono_assembly_get_object (domain, D.32846);
  mono_gc_wbarrier_set_field (res, D.32845, D.32847);
  D.32848 = &res->fqname;
  D.32849 = image->name;
  D.32850 = mono_string_new (domain, D.32849);
  mono_gc_wbarrier_set_field (res, D.32848, D.32850);
  D.32849 = image->name;
  basename = monoeg_g_path_get_basename (D.32849);
  D.32851 = &res->name;
  D.32852 = mono_string_new (domain, basename);
  mono_gc_wbarrier_set_field (res, D.32851, D.32852);
  D.32853 = &res->scopename;
  D.32854 = image->module_name;
  D.32855 = mono_string_new (domain, D.32854);
  mono_gc_wbarrier_set_field (res, D.32853, D.32855);
  monoeg_g_free (basename);
  D.32846 = image->assembly;
  D.32856 = D.32846->image;
  if (D.32856 == image) goto <D.32857>; else goto <D.32858>;
  <D.32857>:
  res->token = 1;
  goto <D.32859>;
  <D.32858>:
  {
    int i;

    res->token = 0;
    D.32846 = image->assembly;
    D.32856 = D.32846->image;
    D.32860 = D.32856->modules;
    if (D.32860 != 0B) goto <D.32861>; else goto <D.32862>;
    <D.32861>:
    i = 0;
    goto <D.21596>;
    <D.21595>:
    D.32846 = image->assembly;
    D.32856 = D.32846->image;
    D.32860 = D.32856->modules;
    D.32863 = (long unsigned int) i;
    D.32864 = D.32863 * 8;
    D.32865 = D.32860 + D.32864;
    D.32866 = *D.32865;
    if (D.32866 == image) goto <D.32867>; else goto <D.32868>;
    <D.32867>:
    D.32869 = i + 1;
    D.32870 = D.32869 | 436207616;
    D.32871 = (unsigned int) D.32870;
    res->token = D.32871;
    <D.32868>:
    i = i + 1;
    <D.21596>:
    i.278 = (unsigned int) i;
    D.32846 = image->assembly;
    D.32856 = D.32846->image;
    D.32873 = D.32856->module_count;
    if (i.278 < D.32873) goto <D.21595>; else goto <D.21597>;
    <D.21597>:
    D.32874 = res->token;
    D.32875 = D.32874 == 0;
    D.32876 = (long int) D.32875;
    D.32877 = __builtin_expect (D.32876, 0);
    if (D.32877 != 0) goto <D.32878>; else goto <D.32879>;
    <D.32878>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6298, "res->token");
    <D.32879>:
    <D.32862>:
  }
  <D.32859>:
  {
    struct MonoReflectionModule * _obj;
    struct ReflectedEntry pe;

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

          D.32805 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32805);
          if (ret != 0) goto <D.32880>; else goto <D.32881>;
          <D.32880>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32881>:
          D.32882 = ret != 0;
          D.32883 = (long int) D.32882;
          D.32884 = __builtin_expect (D.32883, 0);
          if (D.32884 != 0) goto <D.32885>; else goto <D.32886>;
          <D.32885>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.32886>:
        }
        D.32813 = domain->refobject_hash;
        if (D.32813 == 0B) goto <D.32887>; else goto <D.32888>;
        <D.32887>:
        D.32889 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32889;
        <D.32888>:
        D.32813 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32813, &pe);
        if (_obj == 0B) goto <D.32890>; else goto <D.32891>;
        <D.32890>:
        {
          struct ReflectedEntry * e;

          D.32892 = domain->mp;
          e = mono_mempool_alloc (D.32892, 16);
          e->item = image;
          e->refclass = 0B;
          D.32813 = domain->refobject_hash;
          mono_g_hash_table_insert (D.32813, e, res);
          _obj = res;
        }
        <D.32891>:
        {
          int ret;

          D.32805 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32805);
          if (ret != 0) goto <D.32893>; else goto <D.32894>;
          <D.32893>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32894>:
          D.32895 = ret != 0;
          D.32896 = (long int) D.32895;
          D.32897 = __builtin_expect (D.32896, 0);
          if (D.32897 != 0) goto <D.32898>; else goto <D.32899>;
          <D.32898>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.32899>:
        }
        D.32826 = _obj;
        return D.32826;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_file_get_object (struct MonoDomain * domain, struct MonoImage * image, int table_index)
{
  struct MonoClass * module_type.279;
  struct MonoImage * D.32907;
  _Bool D.32910;
  long int D.32911;
  long int D.32912;
  <unnamed-unsigned:24> D.32915;
  int D.32916;
  _Bool D.32917;
  long int D.32918;
  long int D.32919;
  struct MonoReflectionAssembly * * D.32922;
  struct MonoAssembly * D.32923;
  struct MonoReflectionAssembly * D.32924;
  unsigned int D.32925;
  int i.280;
  int D.21625;
  struct MonoImage * * D.32929;
  long unsigned int D.32930;
  long unsigned int D.32931;
  struct MonoImage * * D.32932;
  struct MonoImage * D.32933;
  unsigned int D.32934;
  struct MonoString * * D.32935;
  struct MonoString * D.32936;
  struct MonoString * * D.32937;
  struct MonoString * D.32938;
  struct MonoString * * D.32939;
  struct MonoString * D.32940;
  unsigned int D.32941;
  _Bool D.32942;
  unsigned char D.32943;
  int D.32944;
  int D.32945;
  unsigned int D.32946;
  struct MonoReflectionModule * D.32947;
  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.279 = module_type;
      if (module_type.279 == 0B) goto <D.32905>; else goto <D.32906>;
      <D.32905>:
      {
        struct MonoClass * class;

        D.32907 = mono_defaults.corlib;
        class = mono_class_from_name (D.32907, "System.Reflection", "MonoModule");
        if (class == 0B) goto <D.32908>; else goto <D.32909>;
        <D.32908>:
        D.32907 = mono_defaults.corlib;
        class = mono_class_from_name (D.32907, "System.Reflection", "Module");
        <D.32909>:
        D.32910 = class == 0B;
        D.32911 = (long int) D.32910;
        D.32912 = __builtin_expect (D.32911, 0);
        if (D.32912 != 0) goto <D.32913>; else goto <D.32914>;
        <D.32913>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6320, "class");
        <D.32914>:
        module_type = class;
      }
      <D.32906>:
      module_type.279 = module_type;
      res = mono_object_new (domain, module_type.279);
      table = &image->tables[38];
      D.32915 = table->rows;
      D.32916 = (int) D.32915;
      D.32917 = D.32916 <= table_index;
      D.32918 = (long int) D.32917;
      D.32919 = __builtin_expect (D.32918, 0);
      if (D.32919 != 0) goto <D.32920>; else goto <D.32921>;
      <D.32920>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6326, "table_index < table->rows");
      <D.32921>:
      mono_metadata_decode_row (table, table_index, &cols, 3);
      res->image = 0B;
      D.32922 = &res->assembly;
      D.32923 = image->assembly;
      D.32924 = mono_assembly_get_object (domain, D.32923);
      mono_gc_wbarrier_set_field (res, D.32922, D.32924);
      D.32925 = cols[1];
      name = mono_metadata_string_heap (image, D.32925);
      table = &image->tables[26];
      i = 0;
      goto <D.21627>;
      <D.21626>:
      i.280 = (int) i;
      name_idx = mono_metadata_decode_row_col (table, i.280, 0);
      val = mono_metadata_string_heap (image, name_idx);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.21625 = __builtin_strcmp (val, name);
      }
      if (D.21625 == 0) goto <D.32927>; else goto <D.32928>;
      <D.32927>:
      D.32929 = image->modules;
      D.32930 = (long unsigned int) i;
      D.32931 = D.32930 * 8;
      D.32932 = D.32929 + D.32931;
      D.32933 = *D.32932;
      res->image = D.32933;
      <D.32928>:
      i = i + 1;
      <D.21627>:
      D.32915 = table->rows;
      D.32934 = (unsigned int) D.32915;
      if (D.32934 > i) goto <D.21626>; else goto <D.21628>;
      <D.21628>:
      D.32935 = &res->fqname;
      D.32936 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.32935, D.32936);
      D.32937 = &res->name;
      D.32938 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.32937, D.32938);
      D.32939 = &res->scopename;
      D.32940 = mono_string_new (domain, name);
      mono_gc_wbarrier_set_field (res, D.32939, D.32940);
      D.32941 = cols[0];
      D.32942 = D.32941 != 0;
      D.32943 = (unsigned char) D.32942;
      res->is_resource = D.32943;
      D.32944 = table_index + 1;
      D.32945 = D.32944 | 637534208;
      D.32946 = (unsigned int) D.32945;
      res->token = D.32946;
      D.32947 = res;
      return D.32947;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_type_get_object (struct MonoDomain * domain, struct MonoType * type)
{
  struct MonoType * iftmp.281;
  <unnamed-unsigned:1> D.32951;
  <unnamed-unsigned:1> D.32952;
  unsigned char D.32956;
  struct MonoObject * D.32959;
  struct MonoReflectionType * D.32962;
  struct MonoType * D.32963;
  struct MonoImage * D.32966;
  long unsigned int D.32967;
  long unsigned int D.32968;
  void * D.32973;
  union mono_mutex_t * D.32976;
  _Bool D.32979;
  long int D.32980;
  long int D.32981;
  struct MonoGHashTable * D.32984;
  struct MonoGHashTable * D.32987;
  _Bool D.32992;
  long int D.32993;
  long int D.32994;
  _Bool D.33001;
  long int D.33002;
  long int D.33003;
  struct MonoGenericClass * D.33008;
  long unsigned int D.33009;
  long unsigned int D.33010;
  struct MonoClass * D.33013;
  long unsigned int D.33014;
  long unsigned int D.33015;
  int D.33020;
  _Bool D.33025;
  long int D.33026;
  long int D.33027;
  struct MonoException * D.33030;
  void * D.33031;
  long unsigned int D.33034;
  long unsigned int D.33035;
  unsigned char D.33040;
  struct MonoGenericContainer * D.33044;
  long unsigned int D.33046;
  long unsigned int D.33047;
  struct MonoClass * D.33051;
  struct MonoClass * D.33052;
  long unsigned int D.33053;
  long unsigned int D.33054;
  struct MonoClass * D.33063;
  long unsigned int D.33064;
  long unsigned int D.33065;
  long unsigned int D.33070;
  long unsigned int D.33071;
  _Bool D.33076;
  long int D.33077;
  long int D.33078;
  struct MonoClass * D.33081;
  _Bool D.33086;
  long int D.33087;
  long int D.33088;
  struct MonoType * norm_type;
  struct MonoReflectionType * res;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (type);
  D.32951 = klass->byval_arg.byref;
  D.32952 = type->byref;
  if (D.32951 == D.32952) goto <D.32953>; else goto <D.32954>;
  <D.32953>:
  iftmp.281 = &klass->byval_arg;
  goto <D.32955>;
  <D.32954>:
  iftmp.281 = &klass->this_arg;
  <D.32955>:
  type = iftmp.281;
  D.32956 = type->type;
  if (D.32956 == 1) goto <D.32957>; else goto <D.32958>;
  <D.32957>:
  D.32959 = domain->typeof_void;
  if (D.32959 != 0B) goto <D.32960>; else goto <D.32961>;
  <D.32960>:
  D.32962 = domain->typeof_void;
  return D.32962;
  <D.32961>:
  <D.32958>:
  D.32963 = &klass->byval_arg;
  if (D.32963 == type) goto <D.32964>; else goto <D.32965>;
  <D.32964>:
  D.32966 = klass->image;
  D.32967 = BIT_FIELD_REF <*D.32966, 64, 192>;
  D.32968 = D.32967 & 34359738368;
  if (D.32968 == 0) goto <D.32969>; else goto <D.32970>;
  <D.32969>:
  {
    struct MonoVTable * vtable;

    vtable = mono_class_try_get_vtable (domain, klass);
    if (vtable != 0B) goto <D.32971>; else goto <D.32972>;
    <D.32971>:
    D.32973 = vtable->type;
    if (D.32973 != 0B) goto <D.32974>; else goto <D.32975>;
    <D.32974>:
    D.32962 = vtable->type;
    return D.32962;
    <D.32975>:
    <D.32972>:
  }
  <D.32970>:
  <D.32965>:
  mono_loader_lock ();
  {
    int ret;

    D.32976 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32976);
    if (ret != 0) goto <D.32977>; else goto <D.32978>;
    <D.32977>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32978>:
    D.32979 = ret != 0;
    D.32980 = (long int) D.32979;
    D.32981 = __builtin_expect (D.32980, 0);
    if (D.32981 != 0) goto <D.32982>; else goto <D.32983>;
    <D.32982>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6462, "ret == 0");
    <D.32983>:
  }
  D.32984 = domain->type_hash;
  if (D.32984 == 0B) goto <D.32985>; else goto <D.32986>;
  <D.32985>:
  D.32987 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.32987;
  <D.32986>:
  D.32984 = domain->type_hash;
  res = mono_g_hash_table_lookup (D.32984, type);
  if (res != 0B) goto <D.32988>; else goto <D.32989>;
  <D.32988>:
  {
    int ret;

    D.32976 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32976);
    if (ret != 0) goto <D.32990>; else goto <D.32991>;
    <D.32990>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32991>:
    D.32992 = ret != 0;
    D.32993 = (long int) D.32992;
    D.32994 = __builtin_expect (D.32993, 0);
    if (D.32994 != 0) goto <D.32995>; else goto <D.32996>;
    <D.32995>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6467, "ret == 0");
    <D.32996>:
  }
  mono_loader_unlock ();
  D.32962 = res;
  return D.32962;
  <D.32989>:
  norm_type = mono_type_normalize (type);
  if (norm_type != type) goto <D.32997>; else goto <D.32998>;
  <D.32997>:
  res = mono_type_get_object (domain, norm_type);
  D.32984 = domain->type_hash;
  mono_g_hash_table_insert (D.32984, type, res);
  {
    int ret;

    D.32976 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32976);
    if (ret != 0) goto <D.32999>; else goto <D.33000>;
    <D.32999>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33000>:
    D.33001 = ret != 0;
    D.33002 = (long int) D.33001;
    D.33003 = __builtin_expect (D.33002, 0);
    if (D.33003 != 0) goto <D.33004>; else goto <D.33005>;
    <D.33004>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6483, "ret == 0");
    <D.33005>:
  }
  mono_loader_unlock ();
  D.32962 = res;
  return D.32962;
  <D.32998>:
  D.32956 = type->type;
  if (D.32956 == 21) goto <D.33006>; else goto <D.33007>;
  <D.33006>:
  D.33008 = type->data.generic_class;
  D.33009 = BIT_FIELD_REF <*D.33008, 64, 192>;
  D.33010 = D.33009 & 1;
  if (D.33010 != 0) goto <D.33011>; else goto <D.33012>;
  <D.33011>:
  D.33008 = type->data.generic_class;
  D.33013 = D.33008->container_class;
  D.33014 = BIT_FIELD_REF <*D.33013, 64, 256>;
  D.33015 = D.33014 & 128;
  if (D.33015 == 0) goto <D.33016>; else goto <D.33017>;
  <D.33016>:
  if (1 != 0) goto <D.33018>; else goto <D.33019>;
  <D.33018>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6490, "0");
  <D.33019>:
  <D.33017>:
  <D.33012>:
  <D.33007>:
  D.33020 = verify_safe_for_managed_space (type);
  if (D.33020 == 0) goto <D.33021>; else goto <D.33022>;
  <D.33021>:
  {
    int ret;

    D.32976 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32976);
    if (ret != 0) goto <D.33023>; else goto <D.33024>;
    <D.33023>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33024>:
    D.33025 = ret != 0;
    D.33026 = (long int) D.33025;
    D.33027 = __builtin_expect (D.33026, 0);
    if (D.33027 != 0) goto <D.33028>; else goto <D.33029>;
    <D.33028>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6493, "ret == 0");
    <D.33029>:
  }
  mono_loader_unlock ();
  D.33030 = mono_get_exception_invalid_operation ("This type cannot be propagated to managed space");
  mono_raise_exception (D.33030);
  <D.33022>:
  D.33031 = mono_class_get_ref_info (klass);
  if (D.33031 != 0B) goto <D.33032>; else goto <D.33033>;
  <D.33032>:
  D.33034 = BIT_FIELD_REF <*klass, 64, 256>;
  D.33035 = D.33034 & 128;
  if (D.33035 == 0) goto <D.33036>; else goto <D.33037>;
  <D.33036>:
  {
    gboolean is_type_done;

    is_type_done = 1;
    D.33040 = klass->byval_arg.type;
    if (D.33040 == 30) goto <D.33038>; else goto <D.33041>;
    <D.33041>:
    D.33040 = klass->byval_arg.type;
    if (D.33040 == 19) goto <D.33038>; else goto <D.33039>;
    <D.33038>:
    {
      struct MonoGenericParam * gparam;

      gparam = klass->byval_arg.data.generic_param;
      D.33044 = gparam->owner;
      if (D.33044 != 0B) goto <D.33045>; else goto <D.33042>;
      <D.33045>:
      D.33044 = gparam->owner;
      D.33046 = BIT_FIELD_REF <*D.33044, 64, 256>;
      D.33047 = D.33046 & 2147483648;
      if (D.33047 != 0) goto <D.33048>; else goto <D.33042>;
      <D.33048>:
      {
        struct MonoMethod * method;

        D.33044 = gparam->owner;
        method = D.33044->owner.method;
        if (method != 0B) goto <D.33049>; else goto <D.33050>;
        <D.33049>:
        D.33051 = method->klass;
        D.33052 = mono_class_get_generic_type_definition (D.33051);
        D.33053 = BIT_FIELD_REF <*D.33052, 64, 256>;
        D.33054 = D.33053 & 128;
        if (D.33054 != 0) goto <D.33055>; else goto <D.33056>;
        <D.33055>:
        is_type_done = 0;
        <D.33056>:
        <D.33050>:
      }
      goto <D.33043>;
      <D.33042>:
      D.33044 = gparam->owner;
      if (D.33044 != 0B) goto <D.33057>; else goto <D.33058>;
      <D.33057>:
      D.33044 = gparam->owner;
      D.33046 = BIT_FIELD_REF <*D.33044, 64, 256>;
      D.33047 = D.33046 & 2147483648;
      if (D.33047 == 0) goto <D.33059>; else goto <D.33060>;
      <D.33059>:
      {
        struct MonoClass * klass;

        D.33044 = gparam->owner;
        klass = D.33044->owner.klass;
        if (klass != 0B) goto <D.33061>; else goto <D.33062>;
        <D.33061>:
        D.33063 = mono_class_get_generic_type_definition (klass);
        D.33064 = BIT_FIELD_REF <*D.33063, 64, 256>;
        D.33065 = D.33064 & 128;
        if (D.33065 != 0) goto <D.33066>; else goto <D.33067>;
        <D.33066>:
        is_type_done = 0;
        <D.33067>:
        <D.33062>:
      }
      <D.33060>:
      <D.33058>:
      <D.33043>:
    }
    <D.33039>:
    if (is_type_done != 0) goto <D.33068>; else goto <D.33069>;
    <D.33068>:
    D.33070 = BIT_FIELD_REF <*type, 64, 64>;
    D.33071 = D.33070 & 1073741824;
    if (D.33071 == 0) goto <D.33072>; else goto <D.33073>;
    <D.33072>:
    {
      int ret;

      D.32976 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32976);
      if (ret != 0) goto <D.33074>; else goto <D.33075>;
      <D.33074>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.33075>:
      D.33076 = ret != 0;
      D.33077 = (long int) D.33076;
      D.33078 = __builtin_expect (D.33077, 0);
      if (D.33078 != 0) goto <D.33079>; else goto <D.33080>;
      <D.33079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6521, "ret == 0");
      <D.33080>:
    }
    mono_loader_unlock ();
    D.32962 = mono_class_get_ref_info (klass);
    return D.32962;
    <D.33073>:
    <D.33069>:
  }
  <D.33037>:
  <D.33033>:
  D.33081 = mono_defaults.monotype_class;
  res = mono_object_new_pinned (domain, D.33081);
  res->type = type;
  D.32984 = domain->type_hash;
  mono_g_hash_table_insert (D.32984, type, res);
  D.32956 = type->type;
  if (D.32956 == 1) goto <D.33082>; else goto <D.33083>;
  <D.33082>:
  domain->typeof_void = res;
  <D.33083>:
  {
    int ret;

    D.32976 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32976);
    if (ret != 0) goto <D.33084>; else goto <D.33085>;
    <D.33084>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33085>:
    D.33086 = ret != 0;
    D.33087 = (long int) D.33086;
    D.33088 = __builtin_expect (D.33087, 0);
    if (D.33088 != 0) goto <D.33089>; else goto <D.33090>;
    <D.33089>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6534, "ret == 0");
    <D.33090>:
  }
  mono_loader_unlock ();
  D.32962 = res;
  return D.32962;
}


mono_type_normalize (struct MonoType * type)
{
  unsigned char D.33092;
  struct MonoType * D.33095;
  long unsigned int D.33096;
  long unsigned int D.33097;
  <unnamed-unsigned:22> D.33100;
  long unsigned int D.33101;
  long unsigned int D.33102;
  unsigned char D.33105;
  struct MonoGenericParam * D.33107;
  short unsigned int D.33108;
  int D.33109;
  struct MonoGenericContainer * D.33111;
  long unsigned int D.33112;
  long unsigned int D.33113;
  struct MonoType * * D.33114;
  int D.33117;
  struct MonoType * iftmp.282;
  <unnamed-unsigned:1> D.33121;
  <unnamed-unsigned:1> D.33122;
  <unnamed-unsigned:1> D.33128;
  int D.33129;
  struct MonoType * iftmp.283;
  <unnamed-unsigned:1> D.33131;
  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.33092 = type->type;
  if (D.33092 != 21) goto <D.33093>; else goto <D.33094>;
  <D.33093>:
  D.33095 = type;
  return D.33095;
  <D.33094>:
  gclass = type->data.generic_class;
  ginst = gclass->context.class_inst;
  D.33096 = BIT_FIELD_REF <*ginst, 64, 0>;
  D.33097 = D.33096 & 18014398509481984;
  if (D.33097 == 0) goto <D.33098>; else goto <D.33099>;
  <D.33098>:
  D.33095 = type;
  return D.33095;
  <D.33099>:
  gtd = gclass->container_class;
  gcontainer = gtd->generic_container;
  D.33100 = ginst->type_argc;
  D.33101 = (long unsigned int) D.33100;
  D.33102 = D.33101 * 8;
  argv = __builtin_alloca (D.33102);
  i = 0;
  goto <D.21648>;
  <D.21647>:
  {
    struct MonoType * t;
    struct MonoType * norm;

    t = ginst->type_argv[i];
    D.33105 = t->type;
    if (D.33105 != 19) goto <D.33103>; else goto <D.33106>;
    <D.33106>:
    D.33107 = t->data.generic_param;
    D.33108 = D.33107->num;
    D.33109 = (int) D.33108;
    if (D.33109 != i) goto <D.33103>; else goto <D.33110>;
    <D.33110>:
    D.33107 = t->data.generic_param;
    D.33111 = D.33107->owner;
    if (D.33111 != gcontainer) goto <D.33103>; else goto <D.33104>;
    <D.33103>:
    is_denorm_gtd = 0;
    <D.33104>:
    norm = mono_type_normalize (t);
    D.33112 = (long unsigned int) i;
    D.33113 = D.33112 * 8;
    D.33114 = argv + D.33113;
    *D.33114 = norm;
    if (norm != t) goto <D.33115>; else goto <D.33116>;
    <D.33115>:
    requires_rebind = 1;
    <D.33116>:
  }
  i = i + 1;
  <D.21648>:
  D.33100 = ginst->type_argc;
  D.33117 = (int) D.33100;
  if (D.33117 > i) goto <D.21647>; else goto <D.21649>;
  <D.21649>:
  if (is_denorm_gtd != 0) goto <D.33118>; else goto <D.33119>;
  <D.33118>:
  D.33121 = type->byref;
  D.33122 = gtd->byval_arg.byref;
  if (D.33121 == D.33122) goto <D.33123>; else goto <D.33124>;
  <D.33123>:
  iftmp.282 = &gtd->byval_arg;
  goto <D.33125>;
  <D.33124>:
  iftmp.282 = &gtd->this_arg;
  <D.33125>:
  D.33095 = iftmp.282;
  return D.33095;
  <D.33119>:
  if (requires_rebind != 0) goto <D.33126>; else goto <D.33127>;
  <D.33126>:
  {
    struct MonoClass * klass;

    D.33100 = ginst->type_argc;
    D.33117 = (int) D.33100;
    D.33128 = gclass->is_dynamic;
    D.33129 = (int) D.33128;
    klass = mono_class_bind_generic_parameters (gtd, D.33117, argv, D.33129);
    D.33121 = type->byref;
    D.33131 = klass->byval_arg.byref;
    if (D.33121 == D.33131) goto <D.33132>; else goto <D.33133>;
    <D.33132>:
    iftmp.283 = &klass->byval_arg;
    goto <D.33134>;
    <D.33133>:
    iftmp.283 = &klass->this_arg;
    <D.33134>:
    D.33095 = iftmp.283;
    return D.33095;
  }
  <D.33127>:
  D.33095 = type;
  return D.33095;
}


verify_safe_for_managed_space (struct MonoType * type)
{
  unsigned char D.33136;
  int D.33137;
  gboolean D.33138;

  D.33136 = type->type;
  D.33137 = (int) D.33136;
  switch (D.33137) <default: <D.33139>, case 19: <D.21632>, case 30: <D.21633>>
  <D.21632>:
  <D.21633>:
  D.33138 = 1;
  return D.33138;
  <D.33139>:
  D.33138 = 1;
  return D.33138;
}


mono_method_get_object (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  long unsigned int D.33141;
  long unsigned int D.33142;
  union mono_mutex_t * D.33145;
  _Bool D.33148;
  long int D.33149;
  long int D.33150;
  struct MonoGHashTable * D.33153;
  struct MonoGHashTable * D.33156;
  _Bool D.33161;
  long int D.33162;
  long int D.33163;
  struct MonoReflectionMethod * D.33166;
  _Bool D.33169;
  long int D.33170;
  long int D.33171;
  const char * D.33177;
  char D.33178;
  int D.21694;
  int iftmp.284;
  int D.21693;
  const char[6] * D.33183;
  unsigned char D.33184;
  int D.33185;
  unsigned char D.33186;
  int D.33187;
  const unsigned char * D.33192;
  unsigned char D.33193;
  int D.33194;
  const unsigned char * D.33195;
  unsigned char D.33196;
  int D.33197;
  const unsigned char * D.33202;
  unsigned char D.33203;
  int D.33204;
  const unsigned char * D.33205;
  unsigned char D.33206;
  int D.33207;
  const unsigned char * D.33212;
  unsigned char D.33213;
  int D.33214;
  const unsigned char * D.33215;
  unsigned char D.33216;
  int D.33217;
  int D.21703;
  int iftmp.285;
  int D.21702;
  const char[7] * D.33223;
  unsigned char D.33224;
  int D.33225;
  unsigned char D.33226;
  int D.33227;
  const unsigned char * D.33232;
  unsigned char D.33233;
  int D.33234;
  const unsigned char * D.33235;
  unsigned char D.33236;
  int D.33237;
  const unsigned char * D.33242;
  unsigned char D.33243;
  int D.33244;
  const unsigned char * D.33245;
  unsigned char D.33246;
  int D.33247;
  const unsigned char * D.33252;
  unsigned char D.33253;
  int D.33254;
  const unsigned char * D.33255;
  unsigned char D.33256;
  int D.33257;
  struct MonoClass * System_Reflection_MonoGenericCMethod.286;
  struct MonoImage * D.33262;
  struct MonoClass * System_Reflection_MonoGenericCMethod.287;
  struct MonoClass * System_Reflection_MonoGenericMethod.288;
  struct MonoClass * System_Reflection_MonoGenericMethod.289;
  struct MonoString * * D.33268;
  struct MonoString * D.33269;
  struct MonoReflectionType * * D.33270;
  struct MonoType * D.33271;
  struct MonoReflectionType * D.33272;
  _Bool D.33275;
  long int D.33276;
  long int D.33277;
  struct MonoGHashTable * D.33282;
  struct MonoMemPool * D.33285;
  _Bool D.33288;
  long int D.33289;
  long int D.33290;
  _Bool D.33297;
  long int D.33298;
  long int D.33299;
  struct MonoGHashTable * D.33304;
  _Bool D.33309;
  long int D.33310;
  long int D.33311;
  _Bool D.33316;
  long int D.33317;
  long int D.33318;
  int D.21722;
  int iftmp.290;
  int D.21721;
  unsigned char D.33328;
  int D.33329;
  const unsigned char * D.33334;
  unsigned char D.33335;
  int D.33336;
  const unsigned char * D.33341;
  unsigned char D.33342;
  int D.33343;
  const unsigned char * D.33348;
  unsigned char D.33349;
  int D.33350;
  int D.21731;
  int iftmp.291;
  int D.21730;
  unsigned char D.33356;
  int D.33357;
  const unsigned char * D.33362;
  unsigned char D.33363;
  int D.33364;
  const unsigned char * D.33369;
  unsigned char D.33370;
  int D.33371;
  const unsigned char * D.33376;
  unsigned char D.33377;
  int D.33378;
  struct MonoClass * System_Reflection_MonoCMethod.292;
  struct MonoClass * System_Reflection_MonoCMethod.293;
  struct MonoClass * System_Reflection_MonoMethod.294;
  struct MonoClass * System_Reflection_MonoMethod.295;
  struct MonoReflectionType * * D.33388;
  struct MonoReflectionType * D.33389;
  _Bool D.33392;
  long int D.33393;
  long int D.33394;
  struct MonoGHashTable * D.33399;
  _Bool D.33404;
  long int D.33405;
  long int D.33406;
  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.33141 = BIT_FIELD_REF <*method, 64, 256>;
  D.33142 = D.33141 & 4096;
  if (D.33142 != 0) goto <D.33143>; else goto <D.33144>;
  <D.33143>:
  {
    struct MonoReflectionGenericMethod * gret;

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

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

            D.33145 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.33145);
            if (ret != 0) goto <D.33146>; else goto <D.33147>;
            <D.33146>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.33147>:
            D.33148 = ret != 0;
            D.33149 = (long int) D.33148;
            D.33150 = __builtin_expect (D.33149, 0);
            if (D.33150 != 0) goto <D.33151>; else goto <D.33152>;
            <D.33151>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.33152>:
          }
          D.33153 = domain->refobject_hash;
          if (D.33153 == 0B) goto <D.33154>; else goto <D.33155>;
          <D.33154>:
          D.33156 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.33156;
          <D.33155>:
          D.33153 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.33153, &e);
          if (_obj != 0B) goto <D.33157>; else goto <D.33158>;
          <D.33157>:
          {
            int ret;

            D.33145 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.33145);
            if (ret != 0) goto <D.33159>; else goto <D.33160>;
            <D.33159>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.33160>:
            D.33161 = ret != 0;
            D.33162 = (long int) D.33161;
            D.33163 = __builtin_expect (D.33162, 0);
            if (D.33163 != 0) goto <D.33164>; else goto <D.33165>;
            <D.33164>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.33165>:
          }
          D.33166 = _obj;
          return D.33166;
          <D.33158>:
          {
            int ret;

            D.33145 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.33145);
            if (ret != 0) goto <D.33167>; else goto <D.33168>;
            <D.33167>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.33168>:
            D.33169 = ret != 0;
            D.33170 = (long int) D.33169;
            D.33171 = __builtin_expect (D.33170, 0);
            if (D.33171 != 0) goto <D.33172>; else goto <D.33173>;
            <D.33172>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.33173>:
          }
        }
      finally
        {
          e = {CLOBBER};
        }
    }
    D.33177 = method->name;
    D.33178 = *D.33177;
    if (D.33178 == 46) goto <D.33179>; else goto <D.33174>;
    <D.33179>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.33183 = ".ctor";
        D.33184 = MEM[(const unsigned char *)D.33183];
        D.33185 = (int) D.33184;
        D.33186 = *__s2;
        D.33187 = (int) D.33186;
        __result = D.33185 - D.33187;
        {
          if (__s2_len != 0) goto <D.33188>; else goto <D.33189>;
          <D.33188>:
          if (__result == 0) goto <D.33190>; else goto <D.33191>;
          <D.33190>:
          D.33192 = &MEM[(void *)".ctor" + 1B];
          D.33193 = *D.33192;
          D.33194 = (int) D.33193;
          D.33195 = __s2 + 1;
          D.33196 = *D.33195;
          D.33197 = (int) D.33196;
          __result = D.33194 - D.33197;
          if (__s2_len > 1) goto <D.33198>; else goto <D.33199>;
          <D.33198>:
          if (__result == 0) goto <D.33200>; else goto <D.33201>;
          <D.33200>:
          D.33202 = &MEM[(void *)".ctor" + 2B];
          D.33203 = *D.33202;
          D.33204 = (int) D.33203;
          D.33205 = __s2 + 2;
          D.33206 = *D.33205;
          D.33207 = (int) D.33206;
          __result = D.33204 - D.33207;
          if (__s2_len > 2) goto <D.33208>; else goto <D.33209>;
          <D.33208>:
          if (__result == 0) goto <D.33210>; else goto <D.33211>;
          <D.33210>:
          D.33212 = &MEM[(void *)".ctor" + 3B];
          D.33213 = *D.33212;
          D.33214 = (int) D.33213;
          D.33215 = __s2 + 3;
          D.33216 = *D.33215;
          D.33217 = (int) D.33216;
          __result = D.33214 - D.33217;
          <D.33211>:
          <D.33209>:
          <D.33201>:
          <D.33199>:
          <D.33191>:
          <D.33189>:
        }
        D.21693 = __result;
      }
      iftmp.284 = -D.21693;
      goto <D.33218>;
      <D.33182>:
      D.33177 = method->name;
      iftmp.284 = __builtin_strcmp (D.33177, ".ctor");
      <D.33218>:
      D.21694 = iftmp.284;
    }
    if (D.21694 == 0) goto <D.33175>; else goto <D.33219>;
    <D.33219>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.33223 = ".cctor";
        D.33224 = MEM[(const unsigned char *)D.33223];
        D.33225 = (int) D.33224;
        D.33226 = *__s2;
        D.33227 = (int) D.33226;
        __result = D.33225 - D.33227;
        {
          if (__s2_len != 0) goto <D.33228>; else goto <D.33229>;
          <D.33228>:
          if (__result == 0) goto <D.33230>; else goto <D.33231>;
          <D.33230>:
          D.33232 = &MEM[(void *)".cctor" + 1B];
          D.33233 = *D.33232;
          D.33234 = (int) D.33233;
          D.33235 = __s2 + 1;
          D.33236 = *D.33235;
          D.33237 = (int) D.33236;
          __result = D.33234 - D.33237;
          if (__s2_len > 1) goto <D.33238>; else goto <D.33239>;
          <D.33238>:
          if (__result == 0) goto <D.33240>; else goto <D.33241>;
          <D.33240>:
          D.33242 = &MEM[(void *)".cctor" + 2B];
          D.33243 = *D.33242;
          D.33244 = (int) D.33243;
          D.33245 = __s2 + 2;
          D.33246 = *D.33245;
          D.33247 = (int) D.33246;
          __result = D.33244 - D.33247;
          if (__s2_len > 2) goto <D.33248>; else goto <D.33249>;
          <D.33248>:
          if (__result == 0) goto <D.33250>; else goto <D.33251>;
          <D.33250>:
          D.33252 = &MEM[(void *)".cctor" + 3B];
          D.33253 = *D.33252;
          D.33254 = (int) D.33253;
          D.33255 = __s2 + 3;
          D.33256 = *D.33255;
          D.33257 = (int) D.33256;
          __result = D.33254 - D.33257;
          <D.33251>:
          <D.33249>:
          <D.33241>:
          <D.33239>:
          <D.33231>:
          <D.33229>:
        }
        D.21702 = __result;
      }
      iftmp.285 = -D.21702;
      goto <D.33258>;
      <D.33222>:
      D.33177 = method->name;
      iftmp.285 = __builtin_strcmp (D.33177, ".cctor");
      <D.33258>:
      D.21703 = iftmp.285;
    }
    if (D.21703 == 0) goto <D.33175>; else goto <D.33174>;
    <D.33175>:
    System_Reflection_MonoGenericCMethod.286 = System_Reflection_MonoGenericCMethod;
    if (System_Reflection_MonoGenericCMethod.286 == 0B) goto <D.33260>; else goto <D.33261>;
    <D.33260>:
    D.33262 = mono_defaults.corlib;
    System_Reflection_MonoGenericCMethod.287 = mono_class_from_name (D.33262, "System.Reflection", "MonoGenericCMethod");
    System_Reflection_MonoGenericCMethod = System_Reflection_MonoGenericCMethod.287;
    <D.33261>:
    klass = System_Reflection_MonoGenericCMethod;
    goto <D.33176>;
    <D.33174>:
    System_Reflection_MonoGenericMethod.288 = System_Reflection_MonoGenericMethod;
    if (System_Reflection_MonoGenericMethod.288 == 0B) goto <D.33265>; else goto <D.33266>;
    <D.33265>:
    D.33262 = mono_defaults.corlib;
    System_Reflection_MonoGenericMethod.289 = mono_class_from_name (D.33262, "System.Reflection", "MonoGenericMethod");
    System_Reflection_MonoGenericMethod = System_Reflection_MonoGenericMethod.289;
    <D.33266>:
    klass = System_Reflection_MonoGenericMethod;
    <D.33176>:
    gret = mono_object_new (domain, klass);
    gret->method.method = method;
    D.33268 = &gret->method.name;
    D.33177 = method->name;
    D.33269 = mono_string_new (domain, D.33177);
    mono_gc_wbarrier_set_field (gret, D.33268, D.33269);
    D.33270 = &gret->method.reftype;
    D.33271 = &refclass->byval_arg;
    D.33272 = mono_type_get_object (domain, D.33271);
    mono_gc_wbarrier_set_field (gret, D.33270, D.33272);
    {
      struct MonoReflectionMethod * _obj;
      struct ReflectedEntry pe;

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

            D.33145 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.33145);
            if (ret != 0) goto <D.33273>; else goto <D.33274>;
            <D.33273>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.33274>:
            D.33275 = ret != 0;
            D.33276 = (long int) D.33275;
            D.33277 = __builtin_expect (D.33276, 0);
            if (D.33277 != 0) goto <D.33278>; else goto <D.33279>;
            <D.33278>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.33279>:
          }
          D.33153 = domain->refobject_hash;
          if (D.33153 == 0B) goto <D.33280>; else goto <D.33281>;
          <D.33280>:
          D.33282 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.33282;
          <D.33281>:
          D.33153 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.33153, &pe);
          if (_obj == 0B) goto <D.33283>; else goto <D.33284>;
          <D.33283>:
          {
            struct ReflectedEntry * e;

            D.33285 = domain->mp;
            e = mono_mempool_alloc (D.33285, 16);
            e->item = method;
            e->refclass = refclass;
            D.33153 = domain->refobject_hash;
            mono_g_hash_table_insert (D.33153, e, gret);
            _obj = gret;
          }
          <D.33284>:
          {
            int ret;

            D.33145 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.33145);
            if (ret != 0) goto <D.33286>; else goto <D.33287>;
            <D.33286>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.33287>:
            D.33288 = ret != 0;
            D.33289 = (long int) D.33288;
            D.33290 = __builtin_expect (D.33289, 0);
            if (D.33290 != 0) goto <D.33291>; else goto <D.33292>;
            <D.33291>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.33292>:
          }
          D.33166 = _obj;
          return D.33166;
        }
      finally
        {
          pe = {CLOBBER};
        }
    }
  }
  <D.33144>:
  if (refclass == 0B) goto <D.33293>; else goto <D.33294>;
  <D.33293>:
  refclass = method->klass;
  <D.33294>:
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry e;

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

          D.33145 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33145);
          if (ret != 0) goto <D.33295>; else goto <D.33296>;
          <D.33295>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33296>:
          D.33297 = ret != 0;
          D.33298 = (long int) D.33297;
          D.33299 = __builtin_expect (D.33298, 0);
          if (D.33299 != 0) goto <D.33300>; else goto <D.33301>;
          <D.33300>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.33301>:
        }
        D.33153 = domain->refobject_hash;
        if (D.33153 == 0B) goto <D.33302>; else goto <D.33303>;
        <D.33302>:
        D.33304 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33304;
        <D.33303>:
        D.33153 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33153, &e);
        if (_obj != 0B) goto <D.33305>; else goto <D.33306>;
        <D.33305>:
        {
          int ret;

          D.33145 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33145);
          if (ret != 0) goto <D.33307>; else goto <D.33308>;
          <D.33307>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33308>:
          D.33309 = ret != 0;
          D.33310 = (long int) D.33309;
          D.33311 = __builtin_expect (D.33310, 0);
          if (D.33311 != 0) goto <D.33312>; else goto <D.33313>;
          <D.33312>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.33313>:
        }
        D.33166 = _obj;
        return D.33166;
        <D.33306>:
        {
          int ret;

          D.33145 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33145);
          if (ret != 0) goto <D.33314>; else goto <D.33315>;
          <D.33314>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33315>:
          D.33316 = ret != 0;
          D.33317 = (long int) D.33316;
          D.33318 = __builtin_expect (D.33317, 0);
          if (D.33318 != 0) goto <D.33319>; else goto <D.33320>;
          <D.33319>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.33320>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.33177 = method->name;
  D.33178 = *D.33177;
  if (D.33178 == 46) goto <D.33324>; else goto <D.33321>;
  <D.33324>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.33183 = ".ctor";
      D.33184 = MEM[(const unsigned char *)D.33183];
      D.33185 = (int) D.33184;
      D.33328 = *__s2;
      D.33329 = (int) D.33328;
      __result = D.33185 - D.33329;
      {
        if (__s2_len != 0) goto <D.33330>; else goto <D.33331>;
        <D.33330>:
        if (__result == 0) goto <D.33332>; else goto <D.33333>;
        <D.33332>:
        D.33192 = &MEM[(void *)".ctor" + 1B];
        D.33193 = *D.33192;
        D.33194 = (int) D.33193;
        D.33334 = __s2 + 1;
        D.33335 = *D.33334;
        D.33336 = (int) D.33335;
        __result = D.33194 - D.33336;
        if (__s2_len > 1) goto <D.33337>; else goto <D.33338>;
        <D.33337>:
        if (__result == 0) goto <D.33339>; else goto <D.33340>;
        <D.33339>:
        D.33202 = &MEM[(void *)".ctor" + 2B];
        D.33203 = *D.33202;
        D.33204 = (int) D.33203;
        D.33341 = __s2 + 2;
        D.33342 = *D.33341;
        D.33343 = (int) D.33342;
        __result = D.33204 - D.33343;
        if (__s2_len > 2) goto <D.33344>; else goto <D.33345>;
        <D.33344>:
        if (__result == 0) goto <D.33346>; else goto <D.33347>;
        <D.33346>:
        D.33212 = &MEM[(void *)".ctor" + 3B];
        D.33213 = *D.33212;
        D.33214 = (int) D.33213;
        D.33348 = __s2 + 3;
        D.33349 = *D.33348;
        D.33350 = (int) D.33349;
        __result = D.33214 - D.33350;
        <D.33347>:
        <D.33345>:
        <D.33340>:
        <D.33338>:
        <D.33333>:
        <D.33331>:
      }
      D.21721 = __result;
    }
    iftmp.290 = -D.21721;
    goto <D.33351>;
    <D.33327>:
    D.33177 = method->name;
    iftmp.290 = __builtin_strcmp (D.33177, ".ctor");
    <D.33351>:
    D.21722 = iftmp.290;
  }
  if (D.21722 == 0) goto <D.33322>; else goto <D.33352>;
  <D.33352>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.33223 = ".cctor";
      D.33224 = MEM[(const unsigned char *)D.33223];
      D.33225 = (int) D.33224;
      D.33356 = *__s2;
      D.33357 = (int) D.33356;
      __result = D.33225 - D.33357;
      {
        if (__s2_len != 0) goto <D.33358>; else goto <D.33359>;
        <D.33358>:
        if (__result == 0) goto <D.33360>; else goto <D.33361>;
        <D.33360>:
        D.33232 = &MEM[(void *)".cctor" + 1B];
        D.33233 = *D.33232;
        D.33234 = (int) D.33233;
        D.33362 = __s2 + 1;
        D.33363 = *D.33362;
        D.33364 = (int) D.33363;
        __result = D.33234 - D.33364;
        if (__s2_len > 1) goto <D.33365>; else goto <D.33366>;
        <D.33365>:
        if (__result == 0) goto <D.33367>; else goto <D.33368>;
        <D.33367>:
        D.33242 = &MEM[(void *)".cctor" + 2B];
        D.33243 = *D.33242;
        D.33244 = (int) D.33243;
        D.33369 = __s2 + 2;
        D.33370 = *D.33369;
        D.33371 = (int) D.33370;
        __result = D.33244 - D.33371;
        if (__s2_len > 2) goto <D.33372>; else goto <D.33373>;
        <D.33372>:
        if (__result == 0) goto <D.33374>; else goto <D.33375>;
        <D.33374>:
        D.33252 = &MEM[(void *)".cctor" + 3B];
        D.33253 = *D.33252;
        D.33254 = (int) D.33253;
        D.33376 = __s2 + 3;
        D.33377 = *D.33376;
        D.33378 = (int) D.33377;
        __result = D.33254 - D.33378;
        <D.33375>:
        <D.33373>:
        <D.33368>:
        <D.33366>:
        <D.33361>:
        <D.33359>:
      }
      D.21730 = __result;
    }
    iftmp.291 = -D.21730;
    goto <D.33379>;
    <D.33355>:
    D.33177 = method->name;
    iftmp.291 = __builtin_strcmp (D.33177, ".cctor");
    <D.33379>:
    D.21731 = iftmp.291;
  }
  if (D.21731 == 0) goto <D.33322>; else goto <D.33321>;
  <D.33322>:
  System_Reflection_MonoCMethod.292 = System_Reflection_MonoCMethod;
  if (System_Reflection_MonoCMethod.292 == 0B) goto <D.33381>; else goto <D.33382>;
  <D.33381>:
  D.33262 = mono_defaults.corlib;
  System_Reflection_MonoCMethod.293 = mono_class_from_name (D.33262, "System.Reflection", "MonoCMethod");
  System_Reflection_MonoCMethod = System_Reflection_MonoCMethod.293;
  <D.33382>:
  klass = System_Reflection_MonoCMethod;
  goto <D.33323>;
  <D.33321>:
  System_Reflection_MonoMethod.294 = System_Reflection_MonoMethod;
  if (System_Reflection_MonoMethod.294 == 0B) goto <D.33385>; else goto <D.33386>;
  <D.33385>:
  D.33262 = mono_defaults.corlib;
  System_Reflection_MonoMethod.295 = mono_class_from_name (D.33262, "System.Reflection", "MonoMethod");
  System_Reflection_MonoMethod = System_Reflection_MonoMethod.295;
  <D.33386>:
  klass = System_Reflection_MonoMethod;
  <D.33323>:
  ret = mono_object_new (domain, klass);
  ret->method = method;
  D.33388 = &ret->reftype;
  D.33271 = &refclass->byval_arg;
  D.33389 = mono_type_get_object (domain, D.33271);
  mono_gc_wbarrier_set_field (ret, D.33388, D.33389);
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry pe;

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

          D.33145 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33145);
          if (ret != 0) goto <D.33390>; else goto <D.33391>;
          <D.33390>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33391>:
          D.33392 = ret != 0;
          D.33393 = (long int) D.33392;
          D.33394 = __builtin_expect (D.33393, 0);
          if (D.33394 != 0) goto <D.33395>; else goto <D.33396>;
          <D.33395>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.33396>:
        }
        D.33153 = domain->refobject_hash;
        if (D.33153 == 0B) goto <D.33397>; else goto <D.33398>;
        <D.33397>:
        D.33399 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33399;
        <D.33398>:
        D.33153 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33153, &pe);
        if (_obj == 0B) goto <D.33400>; else goto <D.33401>;
        <D.33400>:
        {
          struct ReflectedEntry * e;

          D.33285 = domain->mp;
          e = mono_mempool_alloc (D.33285, 16);
          e->item = method;
          e->refclass = refclass;
          D.33153 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33153, e, ret);
          _obj = ret;
        }
        <D.33401>:
        {
          int ret;

          D.33145 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33145);
          if (ret != 0) goto <D.33402>; else goto <D.33403>;
          <D.33402>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33403>:
          D.33404 = ret != 0;
          D.33405 = (long int) D.33404;
          D.33406 = __builtin_expect (D.33405, 0);
          if (D.33406 != 0) goto <D.33407>; else goto <D.33408>;
          <D.33407>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.33408>:
        }
        D.33166 = _obj;
        return D.33166;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_method_clear_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  long unsigned int D.33416;
  long unsigned int D.33417;
  _Bool D.33418;
  long int D.33419;
  long int D.33420;
  struct MonoMethodSignature * * D.33423;
  struct MonoClass * klass;

  D.33416 = BIT_FIELD_REF <*method, 64, 256>;
  D.33417 = D.33416 & 512;
  D.33418 = D.33417 == 0;
  D.33419 = (long int) D.33418;
  D.33420 = __builtin_expect (D.33419, 0);
  if (D.33420 != 0) goto <D.33421>; else goto <D.33422>;
  <D.33421>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6611, "method->dynamic");
  <D.33422>:
  klass = method->klass;
  goto <D.21743>;
  <D.21742>:
  clear_cached_object (domain, method, klass);
  klass = klass->parent;
  <D.21743>:
  if (klass != 0B) goto <D.21742>; else goto <D.21744>;
  <D.21744>:
  D.33423 = &method->signature;
  clear_cached_object (domain, D.33423, 0B);
  klass = method->klass;
  goto <D.21746>;
  <D.21745>:
  D.33423 = &method->signature;
  clear_cached_object (domain, D.33423, klass);
  klass = klass->parent;
  <D.21746>:
  if (klass != 0B) goto <D.21745>; else goto <D.21747>;
  <D.21747>:
}


clear_cached_object (struct MonoDomain * domain, void * o, struct MonoClass * klass)
{
  union mono_mutex_t * D.33424;
  _Bool D.33427;
  long int D.33428;
  long int D.33429;
  struct MonoGHashTable * D.33432;
  int D.33435;
  _Bool D.33440;
  long int D.33441;
  long int D.33442;

  {
    int ret;

    D.33424 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.33424);
    if (ret != 0) goto <D.33425>; else goto <D.33426>;
    <D.33425>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.33426>:
    D.33427 = ret != 0;
    D.33428 = (long int) D.33427;
    D.33429 = __builtin_expect (D.33428, 0);
    if (D.33429 != 0) goto <D.33430>; else goto <D.33431>;
    <D.33430>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6127, "ret == 0");
    <D.33431>:
  }
  D.33432 = domain->refobject_hash;
  if (D.33432 != 0B) goto <D.33433>; else goto <D.33434>;
  <D.33433>:
  {
    struct ReflectedEntry pe;
    void * orig_pe;
    void * orig_value;

    try
      {
        pe.item = o;
        pe.refclass = klass;
        D.33432 = domain->refobject_hash;
        D.33435 = mono_g_hash_table_lookup_extended (D.33432, &pe, &orig_pe, &orig_value);
        if (D.33435 != 0) goto <D.33436>; else goto <D.33437>;
        <D.33436>:
        D.33432 = domain->refobject_hash;
        mono_g_hash_table_remove (D.33432, &pe);
        <D.33437>:
      }
    finally
      {
        pe = {CLOBBER};
        orig_pe = {CLOBBER};
        orig_value = {CLOBBER};
      }
  }
  <D.33434>:
  {
    int ret;

    D.33424 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.33424);
    if (ret != 0) goto <D.33438>; else goto <D.33439>;
    <D.33438>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33439>:
    D.33440 = ret != 0;
    D.33441 = (long int) D.33440;
    D.33442 = __builtin_expect (D.33441, 0);
    if (D.33442 != 0) goto <D.33443>; else goto <D.33444>;
    <D.33443>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6139, "ret == 0");
    <D.33444>:
  }
}


mono_field_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoClassField * field)
{
  union mono_mutex_t * D.33445;
  _Bool D.33448;
  long int D.33449;
  long int D.33450;
  struct MonoGHashTable * D.33453;
  struct MonoGHashTable * D.33456;
  _Bool D.33461;
  long int D.33462;
  long int D.33463;
  struct MonoReflectionField * D.33466;
  _Bool D.33469;
  long int D.33470;
  long int D.33471;
  struct MonoClass * monofield_klass.296;
  struct MonoImage * D.33477;
  struct MonoClass * monofield_klass.297;
  struct MonoString * * D.33479;
  const char * D.33480;
  struct MonoString * D.33481;
  int D.33482;
  struct MonoType * D.33485;
  short unsigned int D.33486;
  unsigned int D.33487;
  struct MonoReflectionType * * D.33488;
  struct MonoType * D.33489;
  struct MonoReflectionType * D.33490;
  struct MonoReflectionType * D.33494;
  unsigned int D.33495;
  _Bool D.33498;
  long int D.33499;
  long int D.33500;
  struct MonoGHashTable * D.33505;
  struct MonoMemPool * D.33508;
  _Bool D.33511;
  long int D.33512;
  long int D.33513;
  struct MonoReflectionField * res;
  static struct MonoClass * monofield_klass;

  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry e;

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

          D.33445 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33445);
          if (ret != 0) goto <D.33446>; else goto <D.33447>;
          <D.33446>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33447>:
          D.33448 = ret != 0;
          D.33449 = (long int) D.33448;
          D.33450 = __builtin_expect (D.33449, 0);
          if (D.33450 != 0) goto <D.33451>; else goto <D.33452>;
          <D.33451>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33452>:
        }
        D.33453 = domain->refobject_hash;
        if (D.33453 == 0B) goto <D.33454>; else goto <D.33455>;
        <D.33454>:
        D.33456 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33456;
        <D.33455>:
        D.33453 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33453, &e);
        if (_obj != 0B) goto <D.33457>; else goto <D.33458>;
        <D.33457>:
        {
          int ret;

          D.33445 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33445);
          if (ret != 0) goto <D.33459>; else goto <D.33460>;
          <D.33459>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33460>:
          D.33461 = ret != 0;
          D.33462 = (long int) D.33461;
          D.33463 = __builtin_expect (D.33462, 0);
          if (D.33463 != 0) goto <D.33464>; else goto <D.33465>;
          <D.33464>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33465>:
        }
        D.33466 = _obj;
        return D.33466;
        <D.33458>:
        {
          int ret;

          D.33445 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33445);
          if (ret != 0) goto <D.33467>; else goto <D.33468>;
          <D.33467>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33468>:
          D.33469 = ret != 0;
          D.33470 = (long int) D.33469;
          D.33471 = __builtin_expect (D.33470, 0);
          if (D.33471 != 0) goto <D.33472>; else goto <D.33473>;
          <D.33472>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33473>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monofield_klass.296 = monofield_klass;
  if (monofield_klass.296 == 0B) goto <D.33475>; else goto <D.33476>;
  <D.33475>:
  D.33477 = mono_defaults.corlib;
  monofield_klass.297 = mono_class_from_name (D.33477, "System.Reflection", "MonoField");
  monofield_klass = monofield_klass.297;
  <D.33476>:
  monofield_klass.296 = monofield_klass;
  res = mono_object_new (domain, monofield_klass.296);
  res->klass = klass;
  res->field = field;
  D.33479 = &res->name;
  D.33480 = mono_field_get_name (field);
  D.33481 = mono_string_new (domain, D.33480);
  mono_gc_wbarrier_set_field (res, D.33479, D.33481);
  D.33482 = is_field_on_inst (field);
  if (D.33482 != 0) goto <D.33483>; else goto <D.33484>;
  <D.33483>:
  D.33485 = get_field_on_inst_generic_type (field);
  D.33486 = D.33485->attrs;
  D.33487 = (unsigned int) D.33486;
  res->attrs = D.33487;
  D.33488 = &res->type;
  D.33489 = field->type;
  D.33490 = mono_type_get_object (domain, D.33489);
  mono_gc_wbarrier_set_field (res, D.33488, D.33490);
  goto <D.33491>;
  <D.33484>:
  D.33489 = field->type;
  if (D.33489 != 0B) goto <D.33492>; else goto <D.33493>;
  <D.33492>:
  D.33488 = &res->type;
  D.33489 = field->type;
  D.33494 = mono_type_get_object (domain, D.33489);
  mono_gc_wbarrier_set_field (res, D.33488, D.33494);
  <D.33493>:
  D.33495 = mono_field_get_flags (field);
  res->attrs = D.33495;
  <D.33491>:
  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry pe;

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

          D.33445 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33445);
          if (ret != 0) goto <D.33496>; else goto <D.33497>;
          <D.33496>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33497>:
          D.33498 = ret != 0;
          D.33499 = (long int) D.33498;
          D.33500 = __builtin_expect (D.33499, 0);
          if (D.33500 != 0) goto <D.33501>; else goto <D.33502>;
          <D.33501>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.33502>:
        }
        D.33453 = domain->refobject_hash;
        if (D.33453 == 0B) goto <D.33503>; else goto <D.33504>;
        <D.33503>:
        D.33505 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33505;
        <D.33504>:
        D.33453 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33453, &pe);
        if (_obj == 0B) goto <D.33506>; else goto <D.33507>;
        <D.33506>:
        {
          struct ReflectedEntry * e;

          D.33508 = domain->mp;
          e = mono_mempool_alloc (D.33508, 16);
          e->item = field;
          e->refclass = klass;
          D.33453 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33453, e, res);
          _obj = res;
        }
        <D.33507>:
        {
          int ret;

          D.33445 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33445);
          if (ret != 0) goto <D.33509>; else goto <D.33510>;
          <D.33509>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33510>:
          D.33511 = ret != 0;
          D.33512 = (long int) D.33511;
          D.33513 = __builtin_expect (D.33512, 0);
          if (D.33513 != 0) goto <D.33514>; else goto <D.33515>;
          <D.33514>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.33515>:
        }
        D.33466 = _obj;
        return D.33466;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_property_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoProperty * property)
{
  union mono_mutex_t * D.33520;
  _Bool D.33523;
  long int D.33524;
  long int D.33525;
  struct MonoGHashTable * D.33528;
  struct MonoGHashTable * D.33531;
  _Bool D.33536;
  long int D.33537;
  long int D.33538;
  struct MonoReflectionProperty * D.33541;
  _Bool D.33544;
  long int D.33545;
  long int D.33546;
  struct MonoClass * monoproperty_klass.298;
  struct MonoImage * D.33552;
  struct MonoClass * monoproperty_klass.299;
  _Bool D.33556;
  long int D.33557;
  long int D.33558;
  struct MonoGHashTable * D.33563;
  struct MonoMemPool * D.33566;
  _Bool D.33569;
  long int D.33570;
  long int D.33571;
  struct MonoReflectionProperty * res;
  static struct MonoClass * monoproperty_klass;

  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry e;

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

          D.33520 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33520);
          if (ret != 0) goto <D.33521>; else goto <D.33522>;
          <D.33521>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33522>:
          D.33523 = ret != 0;
          D.33524 = (long int) D.33523;
          D.33525 = __builtin_expect (D.33524, 0);
          if (D.33525 != 0) goto <D.33526>; else goto <D.33527>;
          <D.33526>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33527>:
        }
        D.33528 = domain->refobject_hash;
        if (D.33528 == 0B) goto <D.33529>; else goto <D.33530>;
        <D.33529>:
        D.33531 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33531;
        <D.33530>:
        D.33528 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33528, &e);
        if (_obj != 0B) goto <D.33532>; else goto <D.33533>;
        <D.33532>:
        {
          int ret;

          D.33520 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33520);
          if (ret != 0) goto <D.33534>; else goto <D.33535>;
          <D.33534>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33535>:
          D.33536 = ret != 0;
          D.33537 = (long int) D.33536;
          D.33538 = __builtin_expect (D.33537, 0);
          if (D.33538 != 0) goto <D.33539>; else goto <D.33540>;
          <D.33539>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33540>:
        }
        D.33541 = _obj;
        return D.33541;
        <D.33533>:
        {
          int ret;

          D.33520 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33520);
          if (ret != 0) goto <D.33542>; else goto <D.33543>;
          <D.33542>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33543>:
          D.33544 = ret != 0;
          D.33545 = (long int) D.33544;
          D.33546 = __builtin_expect (D.33545, 0);
          if (D.33546 != 0) goto <D.33547>; else goto <D.33548>;
          <D.33547>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33548>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoproperty_klass.298 = monoproperty_klass;
  if (monoproperty_klass.298 == 0B) goto <D.33550>; else goto <D.33551>;
  <D.33550>:
  D.33552 = mono_defaults.corlib;
  monoproperty_klass.299 = mono_class_from_name (D.33552, "System.Reflection", "MonoProperty");
  monoproperty_klass = monoproperty_klass.299;
  <D.33551>:
  monoproperty_klass.298 = monoproperty_klass;
  res = mono_object_new (domain, monoproperty_klass.298);
  res->klass = klass;
  res->property = property;
  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry pe;

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

          D.33520 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33520);
          if (ret != 0) goto <D.33554>; else goto <D.33555>;
          <D.33554>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33555>:
          D.33556 = ret != 0;
          D.33557 = (long int) D.33556;
          D.33558 = __builtin_expect (D.33557, 0);
          if (D.33558 != 0) goto <D.33559>; else goto <D.33560>;
          <D.33559>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.33560>:
        }
        D.33528 = domain->refobject_hash;
        if (D.33528 == 0B) goto <D.33561>; else goto <D.33562>;
        <D.33561>:
        D.33563 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33563;
        <D.33562>:
        D.33528 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33528, &pe);
        if (_obj == 0B) goto <D.33564>; else goto <D.33565>;
        <D.33564>:
        {
          struct ReflectedEntry * e;

          D.33566 = domain->mp;
          e = mono_mempool_alloc (D.33566, 16);
          e->item = property;
          e->refclass = klass;
          D.33528 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33528, e, res);
          _obj = res;
        }
        <D.33565>:
        {
          int ret;

          D.33520 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33520);
          if (ret != 0) goto <D.33567>; else goto <D.33568>;
          <D.33567>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33568>:
          D.33569 = ret != 0;
          D.33570 = (long int) D.33569;
          D.33571 = __builtin_expect (D.33570, 0);
          if (D.33571 != 0) goto <D.33572>; else goto <D.33573>;
          <D.33572>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.33573>:
        }
        D.33541 = _obj;
        return D.33541;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_event_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoEvent * event)
{
  union mono_mutex_t * D.33578;
  _Bool D.33581;
  long int D.33582;
  long int D.33583;
  struct MonoGHashTable * D.33586;
  struct MonoGHashTable * D.33589;
  _Bool D.33594;
  long int D.33595;
  long int D.33596;
  struct MonoReflectionEvent * D.33599;
  _Bool D.33602;
  long int D.33603;
  long int D.33604;
  struct MonoClass * monoevent_klass.300;
  struct MonoImage * D.33610;
  struct MonoClass * monoevent_klass.301;
  _Bool D.33614;
  long int D.33615;
  long int D.33616;
  struct MonoGHashTable * D.33621;
  struct MonoMemPool * D.33624;
  _Bool D.33627;
  long int D.33628;
  long int D.33629;
  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.33578 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33578);
          if (ret != 0) goto <D.33579>; else goto <D.33580>;
          <D.33579>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33580>:
          D.33581 = ret != 0;
          D.33582 = (long int) D.33581;
          D.33583 = __builtin_expect (D.33582, 0);
          if (D.33583 != 0) goto <D.33584>; else goto <D.33585>;
          <D.33584>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.33585>:
        }
        D.33586 = domain->refobject_hash;
        if (D.33586 == 0B) goto <D.33587>; else goto <D.33588>;
        <D.33587>:
        D.33589 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33589;
        <D.33588>:
        D.33586 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33586, &e);
        if (_obj != 0B) goto <D.33590>; else goto <D.33591>;
        <D.33590>:
        {
          int ret;

          D.33578 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33578);
          if (ret != 0) goto <D.33592>; else goto <D.33593>;
          <D.33592>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33593>:
          D.33594 = ret != 0;
          D.33595 = (long int) D.33594;
          D.33596 = __builtin_expect (D.33595, 0);
          if (D.33596 != 0) goto <D.33597>; else goto <D.33598>;
          <D.33597>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.33598>:
        }
        D.33599 = _obj;
        return D.33599;
        <D.33591>:
        {
          int ret;

          D.33578 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33578);
          if (ret != 0) goto <D.33600>; else goto <D.33601>;
          <D.33600>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33601>:
          D.33602 = ret != 0;
          D.33603 = (long int) D.33602;
          D.33604 = __builtin_expect (D.33603, 0);
          if (D.33604 != 0) goto <D.33605>; else goto <D.33606>;
          <D.33605>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.33606>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoevent_klass.300 = monoevent_klass;
  if (monoevent_klass.300 == 0B) goto <D.33608>; else goto <D.33609>;
  <D.33608>:
  D.33610 = mono_defaults.corlib;
  monoevent_klass.301 = mono_class_from_name (D.33610, "System.Reflection", "MonoEvent");
  monoevent_klass = monoevent_klass.301;
  <D.33609>:
  monoevent_klass.300 = monoevent_klass;
  mono_event = mono_object_new (domain, monoevent_klass.300);
  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.33578 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33578);
          if (ret != 0) goto <D.33612>; else goto <D.33613>;
          <D.33612>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33613>:
          D.33614 = ret != 0;
          D.33615 = (long int) D.33614;
          D.33616 = __builtin_expect (D.33615, 0);
          if (D.33616 != 0) goto <D.33617>; else goto <D.33618>;
          <D.33617>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.33618>:
        }
        D.33586 = domain->refobject_hash;
        if (D.33586 == 0B) goto <D.33619>; else goto <D.33620>;
        <D.33619>:
        D.33621 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33621;
        <D.33620>:
        D.33586 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33586, &pe);
        if (_obj == 0B) goto <D.33622>; else goto <D.33623>;
        <D.33622>:
        {
          struct ReflectedEntry * e;

          D.33624 = domain->mp;
          e = mono_mempool_alloc (D.33624, 16);
          e->item = event;
          e->refclass = klass;
          D.33586 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33586, e, res);
          _obj = res;
        }
        <D.33623>:
        {
          int ret;

          D.33578 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33578);
          if (ret != 0) goto <D.33625>; else goto <D.33626>;
          <D.33625>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33626>:
          D.33627 = ret != 0;
          D.33628 = (long int) D.33627;
          D.33629 = __builtin_expect (D.33628, 0);
          if (D.33629 != 0) goto <D.33630>; else goto <D.33631>;
          <D.33630>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.33631>:
        }
        D.33599 = _obj;
        return D.33599;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_param_get_objects_internal (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  struct MonoClass * System_Reflection_ParameterInfo_array.302;
  struct MonoImage * D.33639;
  int D.33642;
  short unsigned int D.33645;
  struct MonoArray * D.33648;
  struct MonoVTable * D.33649;
  struct MonoMethodSignature * * D.33650;
  union mono_mutex_t * D.33651;
  _Bool D.33654;
  long int D.33655;
  long int D.33656;
  struct MonoGHashTable * D.33659;
  struct MonoGHashTable * D.33662;
  _Bool D.33667;
  long int D.33668;
  long int D.33669;
  _Bool D.33674;
  long int D.33675;
  long int D.33676;
  long unsigned int D.33679;
  long unsigned int D.33680;
  int D.33681;
  int D.33682;
  long unsigned int D.33683;
  long unsigned int D.33684;
  struct MonoVTable * D.33685;
  long unsigned int D.33686;
  struct MonoClass * System_Reflection_ParameterInfo.303;
  struct MonoReflectionType * * D.33688;
  struct MonoType * D.33689;
  struct MonoReflectionType * D.33690;
  struct MonoObject * * D.33691;
  struct MonoString * * D.33692;
  long unsigned int D.33693;
  long unsigned int D.33694;
  char * * D.33695;
  char * D.33696;
  struct MonoString * D.33697;
  short unsigned int D.33698;
  unsigned int D.33699;
  unsigned int D.33700;
  unsigned int D.33701;
  unsigned int D.33704;
  struct MonoObject * * D.33707;
  struct MonoObject * D.33708;
  struct MonoObject * D.33710;
  long unsigned int D.33714;
  long unsigned int D.33717;
  guint32 * D.33718;
  unsigned int D.33719;
  unsigned char D.33720;
  struct MonoClass * D.33723;
  unsigned char D.33727;
  struct MonoClass * D.33729;
  long unsigned int D.33730;
  long unsigned int D.33731;
  struct MonoClass * D.33733;
  struct MonoClass * D.33734;
  char * * D.33735;
  char * D.33736;
  struct MonoObject * D.33737;
  struct MonoObject * D.33740;
  struct MonoObject * D.33745;
  struct MonoObject * D.33747;
  sizetype D.33748;
  sizetype D.33749;
  sizetype D.33750;
  struct MonoMarshalSpec * * D.33751;
  struct MonoMarshalSpec * D.33752;
  struct MonoObject * * D.33755;
  struct MonoClass * D.33756;
  struct MonoReflectionMarshalAsAttribute * D.33757;
  long unsigned int D.33758;
  struct MonoMethodSignature * D.33759;
  short unsigned int D.33760;
  struct MonoMarshalSpec * * D.33761;
  struct MonoMarshalSpec * D.33762;
  _Bool D.33767;
  long int D.33768;
  long int D.33769;
  struct MonoGHashTable * D.33774;
  struct MonoMemPool * D.33777;
  _Bool D.33780;
  long int D.33781;
  long int D.33782;
  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.302 = System_Reflection_ParameterInfo_array;
      if (System_Reflection_ParameterInfo_array.302 == 0B) goto <D.33637>; else goto <D.33638>;
      <D.33637>:
      {
        struct MonoClass * klass;

        D.33639 = mono_defaults.corlib;
        klass = mono_class_from_name (D.33639, "System.Reflection", "MonoParameterInfo");
        if (klass == 0B) goto <D.33640>; else goto <D.33641>;
        <D.33640>:
        D.33639 = mono_defaults.corlib;
        klass = mono_class_from_name (D.33639, "System.Reflection", "ParameterInfo");
        <D.33641>:
        mono_memory_barrier ();
        System_Reflection_ParameterInfo = klass;
        klass = mono_array_class_get (klass, 1);
        mono_memory_barrier ();
        System_Reflection_ParameterInfo_array = klass;
      }
      <D.33638>:
      sig = mono_method_signature_checked (method, &error);
      D.33642 = mono_error_ok (&error);
      if (D.33642 == 0) goto <D.33643>; else goto <D.33644>;
      <D.33643>:
      mono_error_raise_exception (&error);
      <D.33644>:
      D.33645 = sig->param_count;
      if (D.33645 == 0) goto <D.33646>; else goto <D.33647>;
      <D.33646>:
      System_Reflection_ParameterInfo_array.302 = System_Reflection_ParameterInfo_array;
      D.33649 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.302);
      D.33648 = mono_array_new_specific (D.33649, 0);
      return D.33648;
      <D.33647>:
      {
        struct MonoArray * _obj;
        struct ReflectedEntry e;

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

              D.33651 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.33651);
              if (ret != 0) goto <D.33652>; else goto <D.33653>;
              <D.33652>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.33653>:
              D.33654 = ret != 0;
              D.33655 = (long int) D.33654;
              D.33656 = __builtin_expect (D.33655, 0);
              if (D.33656 != 0) goto <D.33657>; else goto <D.33658>;
              <D.33657>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33658>:
            }
            D.33659 = domain->refobject_hash;
            if (D.33659 == 0B) goto <D.33660>; else goto <D.33661>;
            <D.33660>:
            D.33662 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.33662;
            <D.33661>:
            D.33659 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.33659, &e);
            if (_obj != 0B) goto <D.33663>; else goto <D.33664>;
            <D.33663>:
            {
              int ret;

              D.33651 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33651);
              if (ret != 0) goto <D.33665>; else goto <D.33666>;
              <D.33665>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33666>:
              D.33667 = ret != 0;
              D.33668 = (long int) D.33667;
              D.33669 = __builtin_expect (D.33668, 0);
              if (D.33669 != 0) goto <D.33670>; else goto <D.33671>;
              <D.33670>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33671>:
            }
            D.33648 = _obj;
            return D.33648;
            <D.33664>:
            {
              int ret;

              D.33651 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33651);
              if (ret != 0) goto <D.33672>; else goto <D.33673>;
              <D.33672>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33673>:
              D.33674 = ret != 0;
              D.33675 = (long int) D.33674;
              D.33676 = __builtin_expect (D.33675, 0);
              if (D.33676 != 0) goto <D.33677>; else goto <D.33678>;
              <D.33677>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33678>:
            }
          }
        finally
          {
            e = {CLOBBER};
          }
      }
      member = mono_method_get_object (domain, method, refclass);
      D.33645 = sig->param_count;
      D.33679 = (long unsigned int) D.33645;
      D.33680 = D.33679 * 8;
      names = monoeg_malloc (D.33680);
      mono_method_get_param_names (method, names);
      D.33645 = sig->param_count;
      D.33681 = (int) D.33645;
      D.33682 = D.33681 + 1;
      D.33683 = (long unsigned int) D.33682;
      D.33684 = D.33683 * 8;
      mspecs = monoeg_malloc (D.33684);
      mono_method_get_marshal_info (method, mspecs);
      System_Reflection_ParameterInfo_array.302 = System_Reflection_ParameterInfo_array;
      D.33685 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.302);
      D.33645 = sig->param_count;
      D.33686 = (long unsigned int) D.33645;
      res = mono_array_new_specific (D.33685, D.33686);
      System_Reflection_ParameterInfo.303 = System_Reflection_ParameterInfo;
      pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo.303);
      i = 0;
      goto <D.21843>;
      <D.21842>:
      param = mono_object_new_specific (pinfo_vtable);
      D.33688 = &param->ClassImpl;
      D.33689 = sig->params[i];
      D.33690 = mono_type_get_object (domain, D.33689);
      mono_gc_wbarrier_set_field (param, D.33688, D.33690);
      D.33691 = &param->MemberImpl;
      mono_gc_wbarrier_set_field (param, D.33691, member);
      D.33692 = &param->NameImpl;
      D.33693 = (long unsigned int) i;
      D.33694 = D.33693 * 8;
      D.33695 = names + D.33694;
      D.33696 = *D.33695;
      D.33697 = mono_string_new (domain, D.33696);
      mono_gc_wbarrier_set_field (param, D.33692, D.33697);
      param->PositionImpl = i;
      D.33689 = sig->params[i];
      D.33698 = D.33689->attrs;
      D.33699 = (unsigned int) D.33698;
      param->AttrsImpl = D.33699;
      D.33700 = param->AttrsImpl;
      D.33701 = D.33700 & 4096;
      if (D.33701 == 0) goto <D.33702>; else goto <D.33703>;
      <D.33702>:
      D.33700 = param->AttrsImpl;
      D.33704 = D.33700 & 16;
      if (D.33704 != 0) goto <D.33705>; else goto <D.33706>;
      <D.33705>:
      D.33707 = &param->DefaultValueImpl;
      D.33708 = get_reflection_missing (domain, &missing);
      mono_gc_wbarrier_set_field (param, D.33707, D.33708);
      goto <D.33709>;
      <D.33706>:
      D.33707 = &param->DefaultValueImpl;
      D.33710 = get_dbnull (domain, &dbnull);
      mono_gc_wbarrier_set_field (param, D.33707, D.33710);
      <D.33709>:
      goto <D.33711>;
      <D.33703>:
      if (blobs == 0B) goto <D.33712>; else goto <D.33713>;
      <D.33712>:
      D.33645 = sig->param_count;
      D.33679 = (long unsigned int) D.33645;
      D.33680 = D.33679 * 8;
      blobs = monoeg_malloc0 (D.33680);
      D.33645 = sig->param_count;
      D.33679 = (long unsigned int) D.33645;
      D.33714 = D.33679 * 4;
      types = monoeg_malloc0 (D.33714);
      get_default_param_value_blobs (method, blobs, types);
      <D.33713>:
      if (type == 0B) goto <D.33715>; else goto <D.33716>;
      <D.33715>:
      type = monoeg_malloc0 (16);
      <D.33716>:
      D.33693 = (long unsigned int) i;
      D.33717 = D.33693 * 4;
      D.33718 = types + D.33717;
      D.33719 = *D.33718;
      D.33720 = (unsigned char) D.33719;
      type->type = D.33720;
      type->data.klass = 0B;
      D.33693 = (long unsigned int) i;
      D.33717 = D.33693 * 4;
      D.33718 = types + D.33717;
      D.33719 = *D.33718;
      if (D.33719 == 18) goto <D.33721>; else goto <D.33722>;
      <D.33721>:
      D.33723 = mono_defaults.object_class;
      type->data.klass = D.33723;
      goto <D.33724>;
      <D.33722>:
      D.33689 = sig->params[i];
      D.33727 = D.33689->type;
      if (D.33727 == 17) goto <D.33728>; else goto <D.33725>;
      <D.33728>:
      D.33689 = sig->params[i];
      D.33729 = D.33689->data.klass;
      D.33730 = BIT_FIELD_REF <*D.33729, 64, 256>;
      D.33731 = D.33730 & 16;
      if (D.33731 != 0) goto <D.33732>; else goto <D.33725>;
      <D.33732>:
      type->type = 17;
      D.33689 = sig->params[i];
      D.33733 = mono_class_from_mono_type (D.33689);
      type->data.klass = D.33733;
      goto <D.33726>;
      <D.33725>:
      D.33734 = mono_class_from_mono_type (type);
      type->data.klass = D.33734;
      <D.33726>:
      <D.33724>:
      D.33707 = &param->DefaultValueImpl;
      D.33693 = (long unsigned int) i;
      D.33694 = D.33693 * 8;
      D.33735 = blobs + D.33694;
      D.33736 = *D.33735;
      D.33737 = mono_get_object_from_blob (domain, type, D.33736);
      mono_gc_wbarrier_set_field (param, D.33707, D.33737);
      D.33693 = (long unsigned int) i;
      D.33717 = D.33693 * 4;
      D.33718 = types + D.33717;
      D.33719 = *D.33718;
      if (D.33719 != 18) goto <D.33738>; else goto <D.33739>;
      <D.33738>:
      D.33740 = param->DefaultValueImpl;
      if (D.33740 == 0B) goto <D.33741>; else goto <D.33742>;
      <D.33741>:
      D.33700 = param->AttrsImpl;
      D.33704 = D.33700 & 16;
      if (D.33704 != 0) goto <D.33743>; else goto <D.33744>;
      <D.33743>:
      D.33707 = &param->DefaultValueImpl;
      D.33745 = get_reflection_missing (domain, &missing);
      mono_gc_wbarrier_set_field (param, D.33707, D.33745);
      goto <D.33746>;
      <D.33744>:
      D.33707 = &param->DefaultValueImpl;
      D.33747 = get_dbnull (domain, &dbnull);
      mono_gc_wbarrier_set_field (param, D.33707, D.33747);
      <D.33746>:
      <D.33742>:
      <D.33739>:
      <D.33711>:
      D.33748 = (sizetype) i;
      D.33749 = D.33748 + 1;
      D.33750 = D.33749 * 8;
      D.33751 = mspecs + D.33750;
      D.33752 = *D.33751;
      if (D.33752 != 0B) goto <D.33753>; else goto <D.33754>;
      <D.33753>:
      D.33755 = &param->MarshalAsImpl;
      D.33756 = method->klass;
      D.33748 = (sizetype) i;
      D.33749 = D.33748 + 1;
      D.33750 = D.33749 * 8;
      D.33751 = mspecs + D.33750;
      D.33752 = *D.33751;
      D.33757 = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.33756, D.33752);
      mono_gc_wbarrier_set_field (param, D.33755, D.33757);
      <D.33754>:
      {
        void * * __p;

        D.33758 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.33758);
        mono_gc_wbarrier_set_arrayref (res, __p, param);
      }
      i = i + 1;
      <D.21843>:
      D.33645 = sig->param_count;
      D.33681 = (int) D.33645;
      if (D.33681 > i) goto <D.21842>; else goto <D.21844>;
      <D.21844>:
      monoeg_g_free (names);
      monoeg_g_free (blobs);
      monoeg_g_free (types);
      monoeg_g_free (type);
      D.33759 = mono_method_signature (method);
      D.33760 = D.33759->param_count;
      i = (int) D.33760;
      goto <D.21846>;
      <D.21845>:
      D.33693 = (long unsigned int) i;
      D.33694 = D.33693 * 8;
      D.33761 = mspecs + D.33694;
      D.33762 = *D.33761;
      if (D.33762 != 0B) goto <D.33763>; else goto <D.33764>;
      <D.33763>:
      D.33693 = (long unsigned int) i;
      D.33694 = D.33693 * 8;
      D.33761 = mspecs + D.33694;
      D.33762 = *D.33761;
      mono_metadata_free_marshal_spec (D.33762);
      <D.33764>:
      i = i + -1;
      <D.21846>:
      if (i >= 0) goto <D.21845>; else goto <D.21847>;
      <D.21847>:
      monoeg_g_free (mspecs);
      {
        struct MonoArray * _obj;
        struct ReflectedEntry pe;

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

              D.33651 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.33651);
              if (ret != 0) goto <D.33765>; else goto <D.33766>;
              <D.33765>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.33766>:
              D.33767 = ret != 0;
              D.33768 = (long int) D.33767;
              D.33769 = __builtin_expect (D.33768, 0);
              if (D.33769 != 0) goto <D.33770>; else goto <D.33771>;
              <D.33770>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.33771>:
            }
            D.33659 = domain->refobject_hash;
            if (D.33659 == 0B) goto <D.33772>; else goto <D.33773>;
            <D.33772>:
            D.33774 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.33774;
            <D.33773>:
            D.33659 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.33659, &pe);
            if (_obj == 0B) goto <D.33775>; else goto <D.33776>;
            <D.33775>:
            {
              struct ReflectedEntry * e;

              D.33777 = domain->mp;
              e = mono_mempool_alloc (D.33777, 16);
              D.33650 = &method->signature;
              e->item = D.33650;
              e->refclass = refclass;
              D.33659 = domain->refobject_hash;
              mono_g_hash_table_insert (D.33659, e, res);
              _obj = res;
            }
            <D.33776>:
            {
              int ret;

              D.33651 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33651);
              if (ret != 0) goto <D.33778>; else goto <D.33779>;
              <D.33778>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33779>:
              D.33780 = ret != 0;
              D.33781 = (long int) D.33780;
              D.33782 = __builtin_expect (D.33781, 0);
              if (D.33782 != 0) goto <D.33783>; else goto <D.33784>;
              <D.33783>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.33784>:
            }
            D.33648 = _obj;
            return D.33648;
          }
        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.33790;
  struct MonoImage * D.33793;
  long unsigned int D.33794;
  long unsigned int D.33795;
  long unsigned int D.33798;
  long unsigned int D.33799;
  struct MonoClass * D.33802;
  struct MonoImage * D.33803;
  struct GHashTable * D.33804;
  uint8_t * * D.33807;
  uint8_t * * D.33810;
  long unsigned int D.33811;
  long unsigned int D.33812;
  uint32_t * D.33813;
  uint32_t * D.33814;
  long unsigned int D.33815;
  unsigned int D.33816;
  unsigned int D.33817;
  _Bool D.33818;
  long int D.33819;
  long int D.33820;
  int D.33823;
  <unnamed-unsigned:24> D.33824;
  int D.33825;
  <unnamed-unsigned:24> D.33829;
  int D.33830;
  int D.33831;
  unsigned int D.33832;
  int D.33833;
  unsigned int D.33834;
  unsigned int D.33835;
  unsigned int D.33838;
  unsigned int D.33839;
  unsigned int D.33842;
  int D.33843;
  unsigned int D.33844;
  long unsigned int D.33845;
  long unsigned int D.33846;
  char * * D.33847;
  unsigned int D.33848;
  const char * D.33849;
  long unsigned int D.33850;
  guint32 * D.33851;
  unsigned int D.33852;
  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.33790 = methodsig->param_count;
      if (D.33790 == 0) goto <D.33791>; else goto <D.33792>;
      <D.33791>:
      return;
      <D.33792>:
      mono_class_init (klass);
      D.33793 = klass->image;
      D.33794 = BIT_FIELD_REF <*D.33793, 64, 192>;
      D.33795 = D.33794 & 34359738368;
      if (D.33795 != 0) goto <D.33796>; else goto <D.33797>;
      <D.33796>:
      {
        struct MonoReflectionMethodAux * aux;

        D.33798 = BIT_FIELD_REF <*method, 64, 256>;
        D.33799 = D.33798 & 4096;
        if (D.33799 != 0) goto <D.33800>; else goto <D.33801>;
        <D.33800>:
        method = MEM[(struct MonoMethodInflated *)method].declaring;
        <D.33801>:
        D.33802 = method->klass;
        D.33803 = D.33802->image;
        D.33804 = MEM[(struct MonoDynamicImage *)D.33803].method_aux_hash;
        aux = monoeg_g_hash_table_lookup (D.33804, method);
        if (aux != 0B) goto <D.33805>; else goto <D.33806>;
        <D.33805>:
        D.33807 = aux->param_defaults;
        if (D.33807 != 0B) goto <D.33808>; else goto <D.33809>;
        <D.33808>:
        D.33807 = aux->param_defaults;
        D.33810 = D.33807 + 8;
        D.33790 = methodsig->param_count;
        D.33811 = (long unsigned int) D.33790;
        D.33812 = D.33811 * 8;
        memcpy (blobs, D.33810, D.33812);
        D.33813 = aux->param_default_types;
        D.33814 = D.33813 + 4;
        D.33790 = methodsig->param_count;
        D.33811 = (long unsigned int) D.33790;
        D.33815 = D.33811 * 4;
        memcpy (types, D.33814, D.33815);
        <D.33809>:
        <D.33806>:
        return;
      }
      <D.33797>:
      D.33793 = klass->image;
      methodt = &D.33793->tables[6];
      D.33793 = klass->image;
      paramt = &D.33793->tables[8];
      constt = &image->tables[11];
      D.33816 = mono_method_get_index (method);
      D.33817 = D.33816 + 4294967295;
      idx = (gint32) D.33817;
      D.33818 = idx == -1;
      D.33819 = (long int) D.33818;
      D.33820 = __builtin_expect (D.33819, 0);
      if (D.33820 != 0) goto <D.33821>; else goto <D.33822>;
      <D.33821>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7061, "idx != -1");
      <D.33822>:
      param_index = mono_metadata_decode_row_col (methodt, idx, 5);
      D.33823 = idx + 1;
      D.33824 = methodt->rows;
      D.33825 = (int) D.33824;
      if (D.33823 < D.33825) goto <D.33826>; else goto <D.33827>;
      <D.33826>:
      D.33823 = idx + 1;
      lastp = mono_metadata_decode_row_col (methodt, D.33823, 5);
      goto <D.33828>;
      <D.33827>:
      D.33829 = paramt->rows;
      D.33830 = (int) D.33829;
      D.33831 = D.33830 + 1;
      lastp = (guint32) D.33831;
      <D.33828>:
      i = param_index;
      goto <D.21932>;
      <D.21931>:
      {
        guint32 paramseq;

        D.33832 = i + 4294967295;
        D.33833 = (int) D.33832;
        mono_metadata_decode_row (paramt, D.33833, &param_cols, 3);
        paramseq = param_cols[1];
        D.33834 = param_cols[0];
        D.33835 = D.33834 & 4096;
        if (D.33835 == 0) goto <D.33836>; else goto <D.33837>;
        <D.33836>:
        // predicted unlikely by continue predictor.
        goto <D.21930>;
        <D.33837>:
        D.33838 = i | 134217728;
        D.33839 = crow + 1;
        crow = mono_metadata_get_constant_index (image, D.33838, D.33839);
        if (crow == 0) goto <D.33840>; else goto <D.33841>;
        <D.33840>:
        // predicted unlikely by continue predictor.
        goto <D.21930>;
        <D.33841>:
        D.33842 = crow + 4294967295;
        D.33843 = (int) D.33842;
        mono_metadata_decode_row (constt, D.33843, &const_cols, 4);
        D.33844 = paramseq + 4294967295;
        D.33845 = (long unsigned int) D.33844;
        D.33846 = D.33845 * 8;
        D.33847 = blobs + D.33846;
        D.33848 = const_cols[3];
        D.33849 = mono_metadata_blob_heap (image, D.33848);
        *D.33847 = D.33849;
        D.33844 = paramseq + 4294967295;
        D.33845 = (long unsigned int) D.33844;
        D.33850 = D.33845 * 4;
        D.33851 = types + D.33850;
        D.33852 = const_cols[0];
        *D.33851 = D.33852;
      }
      <D.21930>:
      i = i + 1;
      <D.21932>:
      if (i < lastp) goto <D.21931>; else goto <D.21933>;
      <D.21933>:
      return;
    }
  finally
    {
      param_cols = {CLOBBER};
      const_cols = {CLOBBER};
    }
}


get_reflection_missing (struct MonoDomain * domain, struct MonoObject * * reflection_missing)
{
  struct MonoObject * D.33855;
  struct MonoObject * D.33858;
  struct MonoObject * D.33859;

  D.33855 = *reflection_missing;
  if (D.33855 == 0B) goto <D.33856>; else goto <D.33857>;
  <D.33856>:
  D.33858 = mono_get_reflection_missing_object (domain);
  *reflection_missing = D.33858;
  <D.33857>:
  D.33859 = *reflection_missing;
  return D.33859;
}


mono_get_reflection_missing_object (struct MonoDomain * domain)
{
  struct MonoClassField * missing_value_field.304;
  struct MonoImage * D.33864;
  struct MonoClassField * missing_value_field.305;
  _Bool D.33866;
  long int D.33867;
  long int D.33868;
  _Bool D.33871;
  long int D.33872;
  long int D.33873;
  struct MonoObject * D.33876;
  struct MonoObject * obj;
  static struct MonoClassField * missing_value_field = 0B;

  missing_value_field.304 = missing_value_field;
  if (missing_value_field.304 == 0B) goto <D.33862>; else goto <D.33863>;
  <D.33862>:
  {
    struct MonoClass * missing_klass;

    D.33864 = mono_defaults.corlib;
    missing_klass = mono_class_from_name (D.33864, "System.Reflection", "Missing");
    mono_class_init (missing_klass);
    missing_value_field.305 = mono_class_get_field_from_name (missing_klass, "Value");
    missing_value_field = missing_value_field.305;
    missing_value_field.304 = missing_value_field;
    D.33866 = missing_value_field.304 == 0B;
    D.33867 = (long int) D.33866;
    D.33868 = __builtin_expect (D.33867, 0);
    if (D.33868 != 0) goto <D.33869>; else goto <D.33870>;
    <D.33869>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6732, "missing_value_field");
    <D.33870>:
  }
  <D.33863>:
  missing_value_field.304 = missing_value_field;
  obj = mono_field_get_value_object (domain, missing_value_field.304, 0B);
  D.33871 = obj == 0B;
  D.33872 = (long int) D.33871;
  D.33873 = __builtin_expect (D.33872, 0);
  if (D.33873 != 0) goto <D.33874>; else goto <D.33875>;
  <D.33874>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6735, "obj");
  <D.33875>:
  D.33876 = obj;
  return D.33876;
}


get_dbnull (struct MonoDomain * domain, struct MonoObject * * dbnull)
{
  struct MonoObject * D.33878;
  struct MonoObject * D.33881;
  struct MonoObject * D.33882;

  D.33878 = *dbnull;
  if (D.33878 == 0B) goto <D.33879>; else goto <D.33880>;
  <D.33879>:
  D.33881 = mono_get_dbnull_object (domain);
  *dbnull = D.33881;
  <D.33880>:
  D.33882 = *dbnull;
  return D.33882;
}


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

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


mono_method_body_get_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  long unsigned int D.33886;
  long unsigned int D.33887;
  struct MonoException * D.33890;
  struct MonoClass * System_Reflection_MethodBody.306;
  struct MonoImage * D.33894;
  struct MonoClass * System_Reflection_MethodBody.307;
  struct MonoClass * System_Reflection_LocalVariableInfo.308;
  struct MonoClass * System_Reflection_LocalVariableInfo.309;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.310;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.311;
  union mono_mutex_t * D.33904;
  _Bool D.33907;
  long int D.33908;
  long int D.33909;
  struct MonoGHashTable * D.33912;
  struct MonoGHashTable * D.33915;
  _Bool D.33920;
  long int D.33921;
  long int D.33922;
  struct MonoReflectionMethodBody * D.33925;
  _Bool D.33928;
  long int D.33929;
  long int D.33930;
  short unsigned int D.33935;
  unsigned int D.33936;
  unsigned int D.33937;
  short unsigned int D.33939;
  unsigned int D.33940;
  unsigned int D.33941;
  struct MonoClass * D.33942;
  long unsigned int D.33943;
  long unsigned int D.33944;
  struct MonoTableInfo * D.33947;
  unsigned int D.33948;
  unsigned int D.33949;
  unsigned int D.33950;
  int D.33951;
  int D.33952;
  <unnamed-unsigned:1> D.33954;
  unsigned char D.33955;
  <unnamed-unsigned:15> D.33956;
  unsigned int D.33957;
  struct MonoArray * * D.33958;
  struct MonoClass * D.21883;
  struct MonoClass * tmp_klass.312;
  struct MonoClass * D.33962;
  struct MonoClass * tmp_klass.313;
  _Bool D.33964;
  long int D.33965;
  long int D.33966;
  struct MonoVTable * D.33969;
  unsigned int D.33970;
  long unsigned int D.33971;
  struct MonoArray * D.33972;
  struct MonoArray * D.33973;
  char * D.33974;
  const unsigned char * D.33975;
  long unsigned int D.33976;
  struct MonoArray * * D.33977;
  struct MonoClass * D.21885;
  struct MonoClass * tmp_klass.314;
  struct MonoClass * tmp_klass.315;
  _Bool D.33982;
  long int D.33983;
  long int D.33984;
  struct MonoVTable * D.33987;
  short unsigned int D.33988;
  long unsigned int D.33989;
  struct MonoArray * D.33990;
  struct MonoReflectionType * * D.33991;
  struct MonoType * D.33992;
  struct MonoReflectionType * D.33993;
  <unnamed-unsigned:1> D.33994;
  unsigned char D.33995;
  short unsigned int D.33996;
  struct MonoArray * D.33997;
  long unsigned int D.33998;
  int D.33999;
  struct MonoArray * * D.34000;
  struct MonoClass * D.21892;
  struct MonoClass * tmp_klass.316;
  struct MonoClass * tmp_klass.317;
  _Bool D.34005;
  long int D.34006;
  long int D.34007;
  struct MonoVTable * D.34010;
  <unnamed-unsigned:15> D.34011;
  long unsigned int D.34012;
  struct MonoArray * D.34013;
  struct MonoExceptionClause * D.34014;
  long unsigned int D.34015;
  long unsigned int D.34016;
  unsigned int D.34017;
  int D.34018;
  unsigned int D.34019;
  int D.34020;
  unsigned int D.34021;
  int D.34022;
  unsigned int D.34023;
  int D.34024;
  unsigned int D.34025;
  int D.34026;
  unsigned int D.34029;
  int D.34030;
  struct MonoClass * D.34032;
  struct MonoObject * * D.34035;
  struct MonoDomain * D.34036;
  struct MonoType * D.34037;
  struct MonoReflectionType * D.34038;
  struct MonoArray * D.34039;
  int D.34040;
  _Bool D.34043;
  long int D.34044;
  long int D.34045;
  struct MonoGHashTable * D.34050;
  struct MonoMemPool * D.34053;
  _Bool D.34056;
  long int D.34057;
  long int D.34058;
  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.33886 = BIT_FIELD_REF <*method, 64, 256>;
  D.33887 = D.33886 & 512;
  if (D.33887 != 0) goto <D.33888>; else goto <D.33889>;
  <D.33888>:
  D.33890 = mono_get_exception_invalid_operation (0B);
  mono_raise_exception (D.33890);
  <D.33889>:
  System_Reflection_MethodBody.306 = System_Reflection_MethodBody;
  if (System_Reflection_MethodBody.306 == 0B) goto <D.33892>; else goto <D.33893>;
  <D.33892>:
  D.33894 = mono_defaults.corlib;
  System_Reflection_MethodBody.307 = mono_class_from_name (D.33894, "System.Reflection", "MethodBody");
  System_Reflection_MethodBody = System_Reflection_MethodBody.307;
  <D.33893>:
  System_Reflection_LocalVariableInfo.308 = System_Reflection_LocalVariableInfo;
  if (System_Reflection_LocalVariableInfo.308 == 0B) goto <D.33897>; else goto <D.33898>;
  <D.33897>:
  D.33894 = mono_defaults.corlib;
  System_Reflection_LocalVariableInfo.309 = mono_class_from_name (D.33894, "System.Reflection", "LocalVariableInfo");
  System_Reflection_LocalVariableInfo = System_Reflection_LocalVariableInfo.309;
  <D.33898>:
  System_Reflection_ExceptionHandlingClause.310 = System_Reflection_ExceptionHandlingClause;
  if (System_Reflection_ExceptionHandlingClause.310 == 0B) goto <D.33901>; else goto <D.33902>;
  <D.33901>:
  D.33894 = mono_defaults.corlib;
  System_Reflection_ExceptionHandlingClause.311 = mono_class_from_name (D.33894, "System.Reflection", "ExceptionHandlingClause");
  System_Reflection_ExceptionHandlingClause = System_Reflection_ExceptionHandlingClause.311;
  <D.33902>:
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry e;

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

          D.33904 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33904);
          if (ret != 0) goto <D.33905>; else goto <D.33906>;
          <D.33905>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33906>:
          D.33907 = ret != 0;
          D.33908 = (long int) D.33907;
          D.33909 = __builtin_expect (D.33908, 0);
          if (D.33909 != 0) goto <D.33910>; else goto <D.33911>;
          <D.33910>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33911>:
        }
        D.33912 = domain->refobject_hash;
        if (D.33912 == 0B) goto <D.33913>; else goto <D.33914>;
        <D.33913>:
        D.33915 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33915;
        <D.33914>:
        D.33912 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33912, &e);
        if (_obj != 0B) goto <D.33916>; else goto <D.33917>;
        <D.33916>:
        {
          int ret;

          D.33904 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33904);
          if (ret != 0) goto <D.33918>; else goto <D.33919>;
          <D.33918>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33919>:
          D.33920 = ret != 0;
          D.33921 = (long int) D.33920;
          D.33922 = __builtin_expect (D.33921, 0);
          if (D.33922 != 0) goto <D.33923>; else goto <D.33924>;
          <D.33923>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33924>:
        }
        D.33925 = _obj;
        return D.33925;
        <D.33917>:
        {
          int ret;

          D.33904 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33904);
          if (ret != 0) goto <D.33926>; else goto <D.33927>;
          <D.33926>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33927>:
          D.33928 = ret != 0;
          D.33929 = (long int) D.33928;
          D.33930 = __builtin_expect (D.33929, 0);
          if (D.33930 != 0) goto <D.33931>; else goto <D.33932>;
          <D.33931>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33932>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.33935 = method->flags;
  D.33936 = (unsigned int) D.33935;
  D.33937 = D.33936 & 9216;
  if (D.33937 != 0) goto <D.33933>; else goto <D.33938>;
  <D.33938>:
  D.33939 = method->iflags;
  D.33940 = (unsigned int) D.33939;
  D.33941 = D.33940 & 4099;
  if (D.33941 != 0) goto <D.33933>; else goto <D.33934>;
  <D.33933>:
  D.33925 = 0B;
  return D.33925;
  <D.33934>:
  D.33942 = method->klass;
  image = D.33942->image;
  header = mono_method_get_header (method);
  D.33943 = BIT_FIELD_REF <*image, 64, 192>;
  D.33944 = D.33943 & 34359738368;
  if (D.33944 == 0) goto <D.33945>; else goto <D.33946>;
  <D.33945>:
  D.33947 = &image->tables[6];
  D.33948 = method->token;
  D.33949 = D.33948 & 16777215;
  D.33950 = D.33949 + 4294967295;
  D.33951 = (int) D.33950;
  method_rva = mono_metadata_decode_row_col (D.33947, D.33951, 0);
  ptr = mono_image_rva_map (image, method_rva);
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.33952 = (int) format;
  switch (D.33952) <default: <D.21881>, case 2: <D.21878>, case 3: <D.21880>>
  <D.21878>:
  local_var_sig_token = 0;
  goto <D.21879>;
  <D.21880>:
  ptr = ptr + 2;
  ptr = ptr + 2;
  ptr = ptr + 4;
  local_var_sig_token = MEM[(const guint32 *)ptr];
  goto <D.21879>;
  <D.21881>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 6951);
  <D.21879>:
  goto <D.33953>;
  <D.33946>:
  local_var_sig_token = 0;
  <D.33953>:
  System_Reflection_MethodBody.306 = System_Reflection_MethodBody;
  ret = mono_object_new (domain, System_Reflection_MethodBody.306);
  D.33954 = header->init_locals;
  D.33955 = (unsigned char) D.33954;
  ret->init_locals = D.33955;
  D.33956 = header->max_stack;
  D.33957 = (unsigned int) D.33956;
  ret->max_stack = D.33957;
  ret->local_var_sig_token = local_var_sig_token;
  D.33958 = &ret->il;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.312 = tmp_klass;
      if (tmp_klass.312 == 0B) goto <D.33960>; else goto <D.33961>;
      <D.33960>:
      D.33962 = mono_defaults.byte_class;
      tmp_klass.313 = mono_array_class_get (D.33962, 1);
      tmp_klass = tmp_klass.313;
      tmp_klass.312 = tmp_klass;
      D.33964 = tmp_klass.312 == 0B;
      D.33965 = (long int) D.33964;
      D.33966 = __builtin_expect (D.33965, 0);
      if (D.33966 != 0) goto <D.33967>; else goto <D.33968>;
      <D.33967>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6961, "tmp_klass");
      <D.33968>:
      <D.33961>:
    }
    D.21883 = tmp_klass;
  }
  D.33969 = mono_class_vtable (domain, D.21883);
  D.33970 = header->code_size;
  D.33971 = (long unsigned int) D.33970;
  D.33972 = mono_array_new_specific (D.33969, D.33971);
  mono_gc_wbarrier_set_field (ret, D.33958, D.33972);
  D.33973 = ret->il;
  D.33974 = mono_array_addr_with_size (D.33973, 1, 0);
  D.33975 = header->code;
  D.33970 = header->code_size;
  D.33976 = (long unsigned int) D.33970;
  memcpy (D.33974, D.33975, D.33976);
  D.33977 = &ret->locals;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.314 = tmp_klass;
      if (tmp_klass.314 == 0B) goto <D.33979>; else goto <D.33980>;
      <D.33979>:
      System_Reflection_LocalVariableInfo.308 = System_Reflection_LocalVariableInfo;
      tmp_klass.315 = mono_array_class_get (System_Reflection_LocalVariableInfo.308, 1);
      tmp_klass = tmp_klass.315;
      tmp_klass.314 = tmp_klass;
      D.33982 = tmp_klass.314 == 0B;
      D.33983 = (long int) D.33982;
      D.33984 = __builtin_expect (D.33983, 0);
      if (D.33984 != 0) goto <D.33985>; else goto <D.33986>;
      <D.33985>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6965, "tmp_klass");
      <D.33986>:
      <D.33980>:
    }
    D.21885 = tmp_klass;
  }
  D.33987 = mono_class_vtable (domain, D.21885);
  D.33988 = header->num_locals;
  D.33989 = (long unsigned int) D.33988;
  D.33990 = mono_array_new_specific (D.33987, D.33989);
  mono_gc_wbarrier_set_field (ret, D.33977, D.33990);
  i = 0;
  goto <D.21889>;
  <D.21888>:
  {
    struct MonoReflectionLocalVariableInfo * info;

    System_Reflection_LocalVariableInfo.308 = System_Reflection_LocalVariableInfo;
    info = mono_object_new (domain, System_Reflection_LocalVariableInfo.308);
    D.33991 = &info->local_type;
    D.33992 = header->locals[i];
    D.33993 = mono_type_get_object (domain, D.33992);
    mono_gc_wbarrier_set_field (info, D.33991, D.33993);
    D.33992 = header->locals[i];
    D.33994 = D.33992->pinned;
    D.33995 = (unsigned char) D.33994;
    info->is_pinned = D.33995;
    D.33996 = (short unsigned int) i;
    info->local_index = D.33996;
    {
      void * * __p;

      D.33997 = ret->locals;
      D.33998 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.33997, 8, D.33998);
      D.33997 = ret->locals;
      mono_gc_wbarrier_set_arrayref (D.33997, __p, info);
    }
  }
  i = i + 1;
  <D.21889>:
  D.33988 = header->num_locals;
  D.33999 = (int) D.33988;
  if (D.33999 > i) goto <D.21888>; else goto <D.21890>;
  <D.21890>:
  D.34000 = &ret->clauses;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.316 = tmp_klass;
      if (tmp_klass.316 == 0B) goto <D.34002>; else goto <D.34003>;
      <D.34002>:
      System_Reflection_ExceptionHandlingClause.310 = System_Reflection_ExceptionHandlingClause;
      tmp_klass.317 = mono_array_class_get (System_Reflection_ExceptionHandlingClause.310, 1);
      tmp_klass = tmp_klass.317;
      tmp_klass.316 = tmp_klass;
      D.34005 = tmp_klass.316 == 0B;
      D.34006 = (long int) D.34005;
      D.34007 = __builtin_expect (D.34006, 0);
      if (D.34007 != 0) goto <D.34008>; else goto <D.34009>;
      <D.34008>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6975, "tmp_klass");
      <D.34009>:
      <D.34003>:
    }
    D.21892 = tmp_klass;
  }
  D.34010 = mono_class_vtable (domain, D.21892);
  D.34011 = header->num_clauses;
  D.34012 = (long unsigned int) D.34011;
  D.34013 = mono_array_new_specific (D.34010, D.34012);
  mono_gc_wbarrier_set_field (ret, D.34000, D.34013);
  i = 0;
  goto <D.21897>;
  <D.21896>:
  {
    struct MonoReflectionExceptionHandlingClause * info;
    struct MonoExceptionClause * clause;

    System_Reflection_ExceptionHandlingClause.310 = System_Reflection_ExceptionHandlingClause;
    info = mono_object_new (domain, System_Reflection_ExceptionHandlingClause.310);
    D.34014 = header->clauses;
    D.34015 = (long unsigned int) i;
    D.34016 = D.34015 * 32;
    clause = D.34014 + D.34016;
    D.34017 = clause->flags;
    D.34018 = (int) D.34017;
    info->flags = D.34018;
    D.34019 = clause->try_offset;
    D.34020 = (int) D.34019;
    info->try_offset = D.34020;
    D.34021 = clause->try_len;
    D.34022 = (int) D.34021;
    info->try_length = D.34022;
    D.34023 = clause->handler_offset;
    D.34024 = (int) D.34023;
    info->handler_offset = D.34024;
    D.34025 = clause->handler_len;
    D.34026 = (int) D.34025;
    info->handler_length = D.34026;
    D.34017 = clause->flags;
    if (D.34017 == 1) goto <D.34027>; else goto <D.34028>;
    <D.34027>:
    D.34029 = clause->data.filter_offset;
    D.34030 = (int) D.34029;
    info->filter_offset = D.34030;
    goto <D.34031>;
    <D.34028>:
    D.34032 = clause->data.catch_class;
    if (D.34032 != 0B) goto <D.34033>; else goto <D.34034>;
    <D.34033>:
    D.34035 = &info->catch_type;
    D.34036 = mono_domain_get ();
    D.34032 = clause->data.catch_class;
    D.34037 = &D.34032->byval_arg;
    D.34038 = mono_type_get_object (D.34036, D.34037);
    mono_gc_wbarrier_set_field (info, D.34035, D.34038);
    <D.34034>:
    <D.34031>:
    {
      void * * __p;

      D.34039 = ret->clauses;
      D.33998 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.34039, 8, D.33998);
      D.34039 = ret->clauses;
      mono_gc_wbarrier_set_arrayref (D.34039, __p, info);
    }
  }
  i = i + 1;
  <D.21897>:
  D.34011 = header->num_clauses;
  D.34040 = (int) D.34011;
  if (D.34040 > i) goto <D.21896>; else goto <D.21898>;
  <D.21898>:
  mono_metadata_free_mh (header);
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry pe;

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

          D.33904 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33904);
          if (ret != 0) goto <D.34041>; else goto <D.34042>;
          <D.34041>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.34042>:
          D.34043 = ret != 0;
          D.34044 = (long int) D.34043;
          D.34045 = __builtin_expect (D.34044, 0);
          if (D.34045 != 0) goto <D.34046>; else goto <D.34047>;
          <D.34046>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.34047>:
        }
        D.33912 = domain->refobject_hash;
        if (D.33912 == 0B) goto <D.34048>; else goto <D.34049>;
        <D.34048>:
        D.34050 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.34050;
        <D.34049>:
        D.33912 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33912, &pe);
        if (_obj == 0B) goto <D.34051>; else goto <D.34052>;
        <D.34051>:
        {
          struct ReflectedEntry * e;

          D.34053 = domain->mp;
          e = mono_mempool_alloc (D.34053, 16);
          e->item = method;
          e->refclass = 0B;
          D.33912 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33912, e, ret);
          _obj = ret;
        }
        <D.34052>:
        {
          int ret;

          D.33904 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33904);
          if (ret != 0) goto <D.34054>; else goto <D.34055>;
          <D.34054>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.34055>:
          D.34056 = ret != 0;
          D.34057 = (long int) D.34056;
          D.34058 = __builtin_expect (D.34057, 0);
          if (D.34058 != 0) goto <D.34059>; else goto <D.34060>;
          <D.34059>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6994, "ret == 0");
          <D.34060>:
        }
        D.33925 = _obj;
        return D.33925;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
  D.33925 = ret;
  return D.33925;
}


mono_get_dbnull_object (struct MonoDomain * domain)
{
  struct MonoClassField * dbnull_value_field.318;
  struct MonoImage * D.34068;
  struct MonoClassField * dbnull_value_field.319;
  _Bool D.34070;
  long int D.34071;
  long int D.34072;
  _Bool D.34075;
  long int D.34076;
  long int D.34077;
  struct MonoObject * D.34080;
  struct MonoObject * obj;
  static struct MonoClassField * dbnull_value_field = 0B;

  dbnull_value_field.318 = dbnull_value_field;
  if (dbnull_value_field.318 == 0B) goto <D.34066>; else goto <D.34067>;
  <D.34066>:
  {
    struct MonoClass * dbnull_klass;

    D.34068 = mono_defaults.corlib;
    dbnull_klass = mono_class_from_name (D.34068, "System", "DBNull");
    mono_class_init (dbnull_klass);
    dbnull_value_field.319 = mono_class_get_field_from_name (dbnull_klass, "Value");
    dbnull_value_field = dbnull_value_field.319;
    dbnull_value_field.318 = dbnull_value_field;
    D.34070 = dbnull_value_field.318 == 0B;
    D.34071 = (long int) D.34070;
    D.34072 = __builtin_expect (D.34071, 0);
    if (D.34072 != 0) goto <D.34073>; else goto <D.34074>;
    <D.34073>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7017, "dbnull_value_field");
    <D.34074>:
  }
  <D.34067>:
  dbnull_value_field.318 = dbnull_value_field;
  obj = mono_field_get_value_object (domain, dbnull_value_field.318, 0B);
  D.34075 = obj == 0B;
  D.34076 = (long int) D.34075;
  D.34077 = __builtin_expect (D.34076, 0);
  if (D.34077 != 0) goto <D.34078>; else goto <D.34079>;
  <D.34078>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7020, "obj");
  <D.34079>:
  D.34080 = obj;
  return D.34080;
}


mono_get_object_from_blob (struct MonoDomain * domain, struct MonoType * type, const char * blob)
{
  struct MonoObject * D.34084;
  long unsigned int D.34085;
  long unsigned int D.34086;
  struct MonoObject * object.320;
  struct MonoObject * object.321;
  long unsigned int D.34091;
  unsigned char D.34095;
  <unnamed type> D.34096;
  int D.34097;
  void * retval;
  struct MonoClass * klass;
  struct MonoObject * object;
  struct MonoType * basetype;

  try
    {
      basetype = type;
      if (blob == 0B) goto <D.34082>; else goto <D.34083>;
      <D.34082>:
      D.34084 = 0B;
      return D.34084;
      <D.34083>:
      klass = mono_class_from_mono_type (type);
      D.34085 = BIT_FIELD_REF <*klass, 64, 256>;
      D.34086 = D.34085 & 8;
      if (D.34086 != 0) goto <D.34087>; else goto <D.34088>;
      <D.34087>:
      object.320 = mono_object_new (domain, klass);
      object = object.320;
      object.321 = object;
      retval = object.321 + 16;
      D.34085 = BIT_FIELD_REF <*klass, 64, 256>;
      D.34091 = D.34085 & 16;
      if (D.34091 != 0) goto <D.34092>; else goto <D.34093>;
      <D.34092>:
      basetype = mono_class_enum_basetype (klass);
      <D.34093>:
      goto <D.34094>;
      <D.34088>:
      retval = &object;
      <D.34094>:
      D.34095 = basetype->type;
      D.34096 = (<unnamed type>) D.34095;
      D.34097 = mono_get_constant_value_from_blob (domain, D.34096, blob, retval);
      if (D.34097 == 0) goto <D.34098>; else goto <D.34099>;
      <D.34098>:
      D.34084 = object;
      return D.34084;
      <D.34099>:
      D.34084 = 0B;
      return D.34084;
    }
  finally
    {
      object = {CLOBBER};
    }
}


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

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


_mono_reflection_parse_type (char * name, char * * endptr, gboolean is_recursed, struct MonoTypeNameParse * info)
{
  struct MonoAssemblyName * D.34104;
  char * D.34105;
  char * p.322;
  char * p.323;
  char D.34108;
  int D.34109;
  struct GList * D.34110;
  struct GList * D.34111;
  char * D.34112;
  char * D.34116;
  int D.34126;
  struct GList * D.34127;
  struct GList * D.34128;
  char * p.324;
  char * p.325;
  struct GList * D.34131;
  char * p.326;
  char * p.327;
  char * p.328;
  char * p.329;
  struct GList * D.34148;
  char * p.330;
  char * p.331;
  char D.34152;
  long unsigned int D.34155;
  void * D.34156;
  struct GList * D.34157;
  struct GPtrArray * D.34160;
  struct GPtrArray * D.34161;
  int D.34164;
  char * p.332;
  char * p.333;
  char * p.334;
  char * p.335;
  const short unsigned int * * D.34180;
  const short unsigned int * D.34181;
  char D.34182;
  long unsigned int D.34183;
  long unsigned int D.34184;
  const short unsigned int * D.34185;
  short unsigned int D.34186;
  int D.34187;
  int D.34188;
  struct MonoAssemblyName * D.34194;
  int D.34195;
  char * p.336;
  char * p.337;
  char * p.338;
  char * p.339;
  char * p.340;
  char * p.341;
  char * p.342;
  char * p.343;
  long unsigned int D.34214;
  long unsigned int D.34215;
  const short unsigned int * D.34216;
  short unsigned int D.34217;
  int D.34218;
  int D.34219;
  int D.34224;
  const char * D.34227;
  char D.34232;
  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.34104 = &info->assembly;
      memset (D.34104, 0, 80);
      info->name_space = 0B;
      D.34105 = info->name_space;
      info->name = D.34105;
      info->nested = 0B;
      info->modifiers = 0B;
      info->type_arguments = 0B;
      last_point = 0B;
      goto <D.22000>;
      <D.21999>:
      p.322 = p;
      p.323 = p.322 + 1;
      p = p.323;
      start = start + 1;
      w = w + 1;
      name = name + 1;
      <D.22000>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 32) goto <D.21999>; else goto <D.22001>;
      <D.22001>:
      goto <D.22014>;
      <D.22013>:
      p.322 = p;
      D.34108 = *p.322;
      D.34109 = (int) D.34108;
      switch (D.34109) <default: <D.22011>, case 38: <D.22006>, case 42: <D.22007>, case 43: <D.22002>, case 44: <D.22009>, case 46: <D.22004>, case 91: <D.22008>, case 92: <D.22005>, case 93: <D.22010>>
      <D.22002>:
      p.322 = p;
      *p.322 = 0;
      p.322 = p;
      startn = p.322 + 1;
      D.34110 = info->nested;
      D.34111 = monoeg_g_list_append (D.34110, startn);
      info->nested = D.34111;
      D.34112 = info->name;
      if (D.34112 != 0B) goto <D.22003>; else goto <D.34113>;
      <D.34113>:
      if (last_point != 0B) goto <D.34114>; else goto <D.34115>;
      <D.34114>:
      info->name_space = start;
      *last_point = 0;
      D.34116 = last_point + 1;
      info->name = D.34116;
      goto <D.34117>;
      <D.34115>:
      info->name_space = "";
      info->name = start;
      <D.34117>:
      goto <D.22003>;
      <D.22004>:
      last_point = p;
      goto <D.22003>;
      <D.22005>:
      p.322 = p;
      p.323 = p.322 + 1;
      p = p.323;
      goto <D.22003>;
      <D.22006>:
      <D.22007>:
      <D.22008>:
      <D.22009>:
      <D.22010>:
      in_modifiers = 1;
      goto <D.22003>;
      <D.22011>:
      goto <D.22003>;
      <D.22003>:
      if (in_modifiers != 0) goto <D.22012>; else goto <D.34118>;
      <D.34118>:
      p.322 = p;
      p.323 = p.322 + 1;
      p = p.323;
      <D.22014>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 != 0) goto <D.22013>; else goto <D.22012>;
      <D.22012>:
      D.34112 = info->name;
      if (D.34112 == 0B) goto <D.34119>; else goto <D.34120>;
      <D.34119>:
      if (last_point != 0B) goto <D.34121>; else goto <D.34122>;
      <D.34121>:
      info->name_space = start;
      *last_point = 0;
      D.34116 = last_point + 1;
      info->name = D.34116;
      goto <D.34123>;
      <D.34122>:
      info->name_space = "";
      info->name = start;
      <D.34123>:
      <D.34120>:
      goto <D.22043>;
      <D.22042>:
      p.322 = p;
      D.34108 = *p.322;
      D.34109 = (int) D.34108;
      switch (D.34109) <default: <D.22040>, case 38: <D.22015>, case 42: <D.22017>, case 44: <D.22036>, case 91: <D.22018>, case 93: <D.22034>>
      <D.22015>:
      if (isbyref != 0) goto <D.34124>; else goto <D.34125>;
      <D.34124>:
      D.34126 = 0;
      return D.34126;
      <D.34125>:
      isbyref = 1;
      D.34127 = info->modifiers;
      D.34128 = monoeg_g_list_append (D.34127, 0B);
      info->modifiers = D.34128;
      p.322 = p;
      p.324 = p.322;
      p.325 = p.324 + 1;
      p = p.325;
      *p.324 = 0;
      goto <D.22016>;
      <D.22017>:
      D.34127 = info->modifiers;
      D.34131 = monoeg_g_list_append (D.34127, -1B);
      info->modifiers = D.34131;
      p.322 = p;
      p.326 = p.322;
      p.327 = p.326 + 1;
      p = p.327;
      *p.326 = 0;
      goto <D.22016>;
      <D.22018>:
      p.322 = p;
      p.328 = p.322;
      p.329 = p.328 + 1;
      p = p.329;
      *p.328 = 0;
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 0) goto <D.34136>; else goto <D.34137>;
      <D.34136>:
      D.34126 = 0;
      return D.34126;
      <D.34137>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 44) goto <D.34138>; else goto <D.34140>;
      <D.34140>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 42) goto <D.34138>; else goto <D.34141>;
      <D.34141>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 93) goto <D.34138>; else goto <D.34139>;
      <D.34138>:
      rank = 1;
      goto <D.22021>;
      <D.22020>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 93) goto <D.22019>; else goto <D.34142>;
      <D.34142>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 44) goto <D.34143>; else goto <D.34144>;
      <D.34143>:
      rank = rank + 1;
      goto <D.34145>;
      <D.34144>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 42) goto <D.34146>; else goto <D.34147>;
      <D.34146>:
      D.34127 = info->modifiers;
      D.34148 = monoeg_g_list_append (D.34127, -2B);
      info->modifiers = D.34148;
      goto <D.34149>;
      <D.34147>:
      D.34126 = 0;
      return D.34126;
      <D.34149>:
      <D.34145>:
      p.322 = p;
      p.323 = p.322 + 1;
      p = p.323;
      <D.22021>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 != 0) goto <D.22020>; else goto <D.22019>;
      <D.22019>:
      p.322 = p;
      p.330 = p.322;
      p.331 = p.330 + 1;
      p = p.331;
      D.34152 = *p.330;
      if (D.34152 != 93) goto <D.34153>; else goto <D.34154>;
      <D.34153>:
      D.34126 = 0;
      return D.34126;
      <D.34154>:
      D.34127 = info->modifiers;
      D.34155 = (long unsigned int) rank;
      D.34156 = (void *) D.34155;
      D.34157 = monoeg_g_list_append (D.34127, D.34156);
      info->modifiers = D.34157;
      goto <D.22031>;
      <D.34139>:
      if (rank != 0) goto <D.34158>; else goto <D.34159>;
      <D.34158>:
      D.34126 = 0;
      return D.34126;
      <D.34159>:
      D.34160 = monoeg_g_ptr_array_new ();
      info->type_arguments = D.34160;
      goto <D.22033>;
      <D.22032>:
      {
        struct MonoTypeNameParse * subinfo;
        gboolean fqname;

        subinfo = monoeg_malloc0 (120);
        fqname = 0;
        D.34161 = info->type_arguments;
        monoeg_g_ptr_array_add (D.34161, subinfo);
        p.322 = p;
        D.34108 = *p.322;
        if (D.34108 == 91) goto <D.34162>; else goto <D.34163>;
        <D.34162>:
        p.322 = p;
        p.323 = p.322 + 1;
        p = p.323;
        fqname = 1;
        <D.34163>:
        p.322 = p;
        D.34164 = _mono_reflection_parse_type (p.322, &p, 1, subinfo);
        if (D.34164 == 0) goto <D.34165>; else goto <D.34166>;
        <D.34165>:
        D.34126 = 0;
        return D.34126;
        <D.34166>:
        if (fqname != 0) goto <D.34169>; else goto <D.34167>;
        <D.34169>:
        p.322 = p;
        D.34108 = *p.322;
        if (D.34108 != 93) goto <D.34170>; else goto <D.34167>;
        <D.34170>:
        {
          char * aname;

          p.322 = p;
          D.34108 = *p.322;
          if (D.34108 != 44) goto <D.34171>; else goto <D.34172>;
          <D.34171>:
          D.34126 = 0;
          return D.34126;
          <D.34172>:
          p.322 = p;
          p.332 = p.322;
          p.333 = p.332 + 1;
          p = p.333;
          *p.332 = 0;
          aname = p;
          goto <D.22026>;
          <D.22025>:
          p.322 = p;
          p.323 = p.322 + 1;
          p = p.323;
          <D.22026>:
          p.322 = p;
          D.34108 = *p.322;
          if (D.34108 != 0) goto <D.34175>; else goto <D.22027>;
          <D.34175>:
          p.322 = p;
          D.34108 = *p.322;
          if (D.34108 != 93) goto <D.22025>; else goto <D.22027>;
          <D.22027>:
          p.322 = p;
          D.34108 = *p.322;
          if (D.34108 != 93) goto <D.34176>; else goto <D.34177>;
          <D.34176>:
          D.34126 = 0;
          return D.34126;
          <D.34177>:
          p.322 = p;
          p.334 = p.322;
          p.335 = p.334 + 1;
          p = p.335;
          *p.334 = 0;
          goto <D.22028>;
          <D.22030>:
          D.34180 = __ctype_b_loc ();
          D.34181 = *D.34180;
          D.34182 = *aname;
          D.34183 = (long unsigned int) D.34182;
          D.34184 = D.34183 * 2;
          D.34185 = D.34181 + D.34184;
          D.34186 = *D.34185;
          D.34187 = (int) D.34186;
          D.34188 = D.34187 & 8192;
          if (D.34188 != 0) goto <D.34189>; else goto <D.34190>;
          <D.34189>:
          aname = aname + 1;
          // predicted unlikely by continue predictor.
          goto <D.22028>;
          <D.34190>:
          goto <D.22029>;
          <D.22028>:
          D.34182 = *aname;
          if (D.34182 != 0) goto <D.22030>; else goto <D.22029>;
          <D.22029>:
          D.34182 = *aname;
          if (D.34182 == 0) goto <D.34191>; else goto <D.34193>;
          <D.34193>:
          D.34194 = &subinfo->assembly;
          D.34195 = assembly_name_to_aname (D.34194, aname);
          if (D.34195 == 0) goto <D.34191>; else goto <D.34192>;
          <D.34191>:
          D.34126 = 0;
          return D.34126;
          <D.34192>:
        }
        goto <D.34168>;
        <D.34167>:
        if (fqname != 0) goto <D.34196>; else goto <D.34197>;
        <D.34196>:
        p.322 = p;
        D.34108 = *p.322;
        if (D.34108 == 93) goto <D.34198>; else goto <D.34199>;
        <D.34198>:
        p.322 = p;
        p.336 = p.322;
        p.337 = p.336 + 1;
        p = p.337;
        *p.336 = 0;
        <D.34199>:
        <D.34197>:
        <D.34168>:
        p.322 = p;
        D.34108 = *p.322;
        if (D.34108 == 93) goto <D.34202>; else goto <D.34203>;
        <D.34202>:
        p.322 = p;
        p.338 = p.322;
        p.339 = p.338 + 1;
        p = p.339;
        *p.338 = 0;
        goto <D.22031>;
        <D.34203>:
        p.322 = p;
        D.34108 = *p.322;
        if (D.34108 == 0) goto <D.34206>; else goto <D.34207>;
        <D.34206>:
        D.34126 = 0;
        return D.34126;
        <D.34207>:
        p.322 = p;
        p.340 = p.322;
        p.341 = p.340 + 1;
        p = p.341;
        *p.340 = 0;
      }
      <D.22033>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 != 0) goto <D.22032>; else goto <D.22031>;
      <D.22031>:
      goto <D.22016>;
      <D.22034>:
      if (is_recursed != 0) goto end; else goto <D.34210>;
      <D.34210>:
      D.34126 = 0;
      return D.34126;
      <D.22036>:
      if (is_recursed != 0) goto end; else goto <D.34211>;
      <D.34211>:
      p.322 = p;
      p.342 = p.322;
      p.343 = p.342 + 1;
      p = p.343;
      *p.342 = 0;
      goto <D.22037>;
      <D.22039>:
      D.34180 = __ctype_b_loc ();
      D.34181 = *D.34180;
      p.322 = p;
      D.34108 = *p.322;
      D.34214 = (long unsigned int) D.34108;
      D.34215 = D.34214 * 2;
      D.34216 = D.34181 + D.34215;
      D.34217 = *D.34216;
      D.34218 = (int) D.34217;
      D.34219 = D.34218 & 8192;
      if (D.34219 != 0) goto <D.34220>; else goto <D.34221>;
      <D.34220>:
      p.322 = p;
      p.323 = p.322 + 1;
      p = p.323;
      // predicted unlikely by continue predictor.
      goto <D.22037>;
      <D.34221>:
      goto <D.22038>;
      <D.22037>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 != 0) goto <D.22039>; else goto <D.22038>;
      <D.22038>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 == 0) goto <D.34222>; else goto <D.34223>;
      <D.34222>:
      D.34126 = 0;
      return D.34126;
      <D.34223>:
      D.34104 = &info->assembly;
      p.322 = p;
      D.34224 = assembly_name_to_aname (D.34104, p.322);
      if (D.34224 == 0) goto <D.34225>; else goto <D.34226>;
      <D.34225>:
      D.34126 = 0;
      return D.34126;
      <D.34226>:
      goto <D.22016>;
      <D.22040>:
      D.34126 = 0;
      return D.34126;
      <D.22016>:
      D.34227 = info->assembly.name;
      if (D.34227 != 0B) goto <D.22041>; else goto <D.34228>;
      <D.34228>:
      <D.22043>:
      p.322 = p;
      D.34108 = *p.322;
      if (D.34108 != 0) goto <D.22042>; else goto <D.22041>;
      <D.22041>:
      end:
      D.34112 = info->name;
      if (D.34112 == 0B) goto <D.34229>; else goto <D.34231>;
      <D.34231>:
      D.34112 = info->name;
      D.34232 = *D.34112;
      if (D.34232 == 0) goto <D.34229>; else goto <D.34230>;
      <D.34229>:
      D.34126 = 0;
      return D.34126;
      <D.34230>:
      if (endptr != 0B) goto <D.34233>; else goto <D.34234>;
      <D.34233>:
      p.322 = p;
      *endptr = p.322;
      <D.34234>:
      D.34126 = 1;
      return D.34126;
    }
  finally
    {
      p = {CLOBBER};
    }
}


assembly_name_to_aname (struct MonoAssemblyName * assembly, char * p)
{
  mono_byte[17] * D.34238;
  char D.34239;
  const short unsigned int * * D.34243;
  const short unsigned int * D.34244;
  long unsigned int D.34245;
  long unsigned int D.34246;
  const short unsigned int * D.34247;
  short unsigned int D.34248;
  int D.34249;
  int D.34250;
  int D.34257;
  int D.34262;
  char * s.344;
  char * s.345;
  char * s.346;
  char * s.347;
  char D.34269;
  long unsigned int D.34271;
  long unsigned int D.34272;
  const short unsigned int * D.34273;
  short unsigned int D.34274;
  int D.34275;
  int D.34276;
  int D.34280;
  long unsigned int D.34282;
  short unsigned int D.34283;
  char * s.348;
  long unsigned int D.34288;
  short unsigned int D.34289;
  long unsigned int D.34293;
  short unsigned int D.34294;
  long unsigned int D.34298;
  short unsigned int D.34299;
  int D.34305;
  int D.34307;
  int D.34314;
  int D.34316;
  long int p.349;
  long int start.350;
  long int D.34323;
  unsigned int D.34324;
  unsigned int D.34325;
  long unsigned int D.34328;
  char * p.351;
  int found_sep;
  char * s;
  gboolean quoted;

  try
    {
      quoted = 0;
      memset (assembly, 0, 80);
      assembly->culture = "";
      D.34238 = &assembly->public_key_token;
      memset (D.34238, 0, 17);
      D.34239 = *p;
      if (D.34239 == 34) goto <D.34240>; else goto <D.34241>;
      <D.34240>:
      quoted = 1;
      p = p + 1;
      <D.34241>:
      assembly->name = p;
      goto <D.21951>;
      <D.21950>:
      p = p + 1;
      <D.21951>:
      D.34239 = *p;
      if (D.34239 != 0) goto <D.34242>; else goto <D.21952>;
      <D.34242>:
      D.34243 = __ctype_b_loc ();
      D.34244 = *D.34243;
      D.34239 = *p;
      D.34245 = (long unsigned int) D.34239;
      D.34246 = D.34245 * 2;
      D.34247 = D.34244 + D.34246;
      D.34248 = *D.34247;
      D.34249 = (int) D.34248;
      D.34250 = D.34249 & 8;
      if (D.34250 != 0) goto <D.21950>; else goto <D.34251>;
      <D.34251>:
      D.34239 = *p;
      if (D.34239 == 46) goto <D.21950>; else goto <D.34252>;
      <D.34252>:
      D.34239 = *p;
      if (D.34239 == 45) goto <D.21950>; else goto <D.34253>;
      <D.34253>:
      D.34239 = *p;
      if (D.34239 == 95) goto <D.21950>; else goto <D.34254>;
      <D.34254>:
      D.34239 = *p;
      if (D.34239 == 36) goto <D.21950>; else goto <D.34255>;
      <D.34255>:
      D.34239 = *p;
      if (D.34239 == 64) goto <D.21950>; else goto <D.34256>;
      <D.34256>:
      D.34243 = __ctype_b_loc ();
      D.34244 = *D.34243;
      D.34239 = *p;
      D.34245 = (long unsigned int) D.34239;
      D.34246 = D.34245 * 2;
      D.34247 = D.34244 + D.34246;
      D.34248 = *D.34247;
      D.34249 = (int) D.34248;
      D.34257 = D.34249 & 8192;
      if (D.34257 != 0) goto <D.21950>; else goto <D.21952>;
      <D.21952>:
      if (quoted != 0) goto <D.34258>; else goto <D.34259>;
      <D.34258>:
      D.34239 = *p;
      if (D.34239 != 34) goto <D.34260>; else goto <D.34261>;
      <D.34260>:
      D.34262 = 1;
      return D.34262;
      <D.34261>:
      *p = 0;
      p = p + 1;
      <D.34259>:
      D.34239 = *p;
      if (D.34239 != 44) goto <D.34263>; else goto <D.34264>;
      <D.34263>:
      D.34262 = 1;
      return D.34262;
      <D.34264>:
      *p = 0;
      s.344 = p + 18446744073709551615;
      s = s.344;
      goto <D.21954>;
      <D.21953>:
      s.345 = s;
      s.346 = s.345;
      s.347 = s.346 + 18446744073709551615;
      s = s.347;
      *s.346 = 0;
      <D.21954>:
      s.345 = s;
      D.34269 = *s.345;
      if (D.34269 != 0) goto <D.34270>; else goto <D.21955>;
      <D.34270>:
      D.34243 = __ctype_b_loc ();
      D.34244 = *D.34243;
      s.345 = s;
      D.34269 = *s.345;
      D.34271 = (long unsigned int) D.34269;
      D.34272 = D.34271 * 2;
      D.34273 = D.34244 + D.34272;
      D.34274 = *D.34273;
      D.34275 = (int) D.34274;
      D.34276 = D.34275 & 8192;
      if (D.34276 != 0) goto <D.21953>; else goto <D.21955>;
      <D.21955>:
      p = p + 1;
      goto <D.21957>;
      <D.21956>:
      p = p + 1;
      <D.21957>:
      D.34243 = __ctype_b_loc ();
      D.34244 = *D.34243;
      D.34239 = *p;
      D.34245 = (long unsigned int) D.34239;
      D.34246 = D.34245 * 2;
      D.34247 = D.34244 + D.34246;
      D.34248 = *D.34247;
      D.34249 = (int) D.34248;
      D.34257 = D.34249 & 8192;
      if (D.34257 != 0) goto <D.21956>; else goto <D.21958>;
      <D.21958>:
      goto <D.21983>;
      <D.21982>:
      D.34239 = *p;
      if (D.34239 == 86) goto <D.34279>; else goto <D.34277>;
      <D.34279>:
      D.34280 = monoeg_g_ascii_strncasecmp (p, "Version=", 8);
      if (D.34280 == 0) goto <D.34281>; else goto <D.34277>;
      <D.34281>:
      p = p + 8;
      D.34282 = strtoul (p, &s, 10);
      D.34283 = (short unsigned int) D.34282;
      assembly->major = D.34283;
      s.345 = s;
      if (s.345 == p) goto <D.34284>; else goto <D.34286>;
      <D.34286>:
      s.345 = s;
      D.34269 = *s.345;
      if (D.34269 != 46) goto <D.34284>; else goto <D.34285>;
      <D.34284>:
      D.34262 = 1;
      return D.34262;
      <D.34285>:
      s.345 = s;
      s.348 = s.345 + 1;
      s = s.348;
      p = s;
      D.34288 = strtoul (p, &s, 10);
      D.34289 = (short unsigned int) D.34288;
      assembly->minor = D.34289;
      s.345 = s;
      if (s.345 == p) goto <D.34290>; else goto <D.34292>;
      <D.34292>:
      s.345 = s;
      D.34269 = *s.345;
      if (D.34269 != 46) goto <D.34290>; else goto <D.34291>;
      <D.34290>:
      D.34262 = 1;
      return D.34262;
      <D.34291>:
      s.345 = s;
      s.348 = s.345 + 1;
      s = s.348;
      p = s;
      D.34293 = strtoul (p, &s, 10);
      D.34294 = (short unsigned int) D.34293;
      assembly->build = D.34294;
      s.345 = s;
      if (s.345 == p) goto <D.34295>; else goto <D.34297>;
      <D.34297>:
      s.345 = s;
      D.34269 = *s.345;
      if (D.34269 != 46) goto <D.34295>; else goto <D.34296>;
      <D.34295>:
      D.34262 = 1;
      return D.34262;
      <D.34296>:
      s.345 = s;
      s.348 = s.345 + 1;
      s = s.348;
      p = s;
      D.34298 = strtoul (p, &s, 10);
      D.34299 = (short unsigned int) D.34298;
      assembly->revision = D.34299;
      s.345 = s;
      if (s.345 == p) goto <D.34300>; else goto <D.34301>;
      <D.34300>:
      D.34262 = 1;
      return D.34262;
      <D.34301>:
      p = s;
      goto <D.34278>;
      <D.34277>:
      D.34239 = *p;
      if (D.34239 == 67) goto <D.34304>; else goto <D.34302>;
      <D.34304>:
      D.34305 = monoeg_g_ascii_strncasecmp (p, "Culture=", 8);
      if (D.34305 == 0) goto <D.34306>; else goto <D.34302>;
      <D.34306>:
      p = p + 8;
      D.34307 = monoeg_g_ascii_strncasecmp (p, "neutral", 7);
      if (D.34307 == 0) goto <D.34308>; else goto <D.34309>;
      <D.34308>:
      assembly->culture = "";
      p = p + 7;
      goto <D.34310>;
      <D.34309>:
      assembly->culture = p;
      goto <D.21960>;
      <D.21959>:
      p = p + 1;
      <D.21960>:
      D.34239 = *p;
      if (D.34239 != 0) goto <D.34311>; else goto <D.21961>;
      <D.34311>:
      D.34239 = *p;
      if (D.34239 != 44) goto <D.21959>; else goto <D.21961>;
      <D.21961>:
      <D.34310>:
      goto <D.34303>;
      <D.34302>:
      D.34239 = *p;
      if (D.34239 == 80) goto <D.34313>; else goto <D.34312>;
      <D.34313>:
      D.34314 = monoeg_g_ascii_strncasecmp (p, "PublicKeyToken=", 15);
      if (D.34314 == 0) goto <D.34315>; else goto <D.34312>;
      <D.34315>:
      p = p + 15;
      D.34316 = strncmp (p, "null", 4);
      if (D.34316 == 0) goto <D.34317>; else goto <D.34318>;
      <D.34317>:
      p = p + 4;
      goto <D.34319>;
      <D.34318>:
      {
        int len;
        gchar * start;

        start = p;
        goto <D.21974>;
        <D.21973>:
        p = p + 1;
        <D.21974>:
        D.34239 = *p;
        if (D.34239 != 0) goto <D.34320>; else goto <D.21975>;
        <D.34320>:
        D.34239 = *p;
        if (D.34239 != 44) goto <D.21973>; else goto <D.21975>;
        <D.21975>:
        p.349 = (long int) p;
        start.350 = (long int) start;
        D.34323 = p.349 - start.350;
        D.34324 = (unsigned int) D.34323;
        D.34325 = D.34324 + 1;
        len = (int) D.34325;
        if (len > 17) goto <D.34326>; else goto <D.34327>;
        <D.34326>:
        len = 17;
        <D.34327>:
        D.34238 = &assembly->public_key_token;
        D.34328 = (long unsigned int) len;
        monoeg_g_strlcpy (D.34238, start, D.34328);
      }
      <D.34319>:
      goto <D.21978>;
      <D.34312>:
      goto <D.21977>;
      <D.21976>:
      p = p + 1;
      <D.21977>:
      D.34239 = *p;
      if (D.34239 != 0) goto <D.34329>; else goto <D.21978>;
      <D.34329>:
      D.34239 = *p;
      if (D.34239 != 44) goto <D.21976>; else goto <D.21978>;
      <D.21978>:
      <D.34303>:
      <D.34278>:
      found_sep = 0;
      goto <D.21979>;
      <D.21980>:
      p.351 = p;
      p = p.351 + 1;
      *p.351 = 0;
      found_sep = 1;
      // predicted unlikely by continue predictor.
      goto <D.21979>;
      <D.21979>:
      D.34243 = __ctype_b_loc ();
      D.34244 = *D.34243;
      D.34239 = *p;
      D.34245 = (long unsigned int) D.34239;
      D.34246 = D.34245 * 2;
      D.34247 = D.34244 + D.34246;
      D.34248 = *D.34247;
      D.34249 = (int) D.34248;
      D.34257 = D.34249 & 8192;
      if (D.34257 != 0) goto <D.21980>; else goto <D.34331>;
      <D.34331>:
      D.34239 = *p;
      if (D.34239 == 44) goto <D.21980>; else goto <D.21981>;
      <D.21981>:
      if (found_sep == 0) goto <D.34332>; else goto <D.34333>;
      <D.34332>:
      D.34262 = 1;
      return D.34262;
      <D.34333>:
      <D.21983>:
      D.34239 = *p;
      if (D.34239 != 0) goto <D.21982>; else goto <D.21984>;
      <D.21984>:
      D.34262 = 0;
      return D.34262;
    }
  finally
    {
      s = {CLOBBER};
    }
}


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

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


mono_reflection_get_type_with_rootimage (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  long unsigned int D.34341;
  long unsigned int D.34342;
  struct MonoAssembly * D.34344;
  struct MonoType * D.34347;
  struct MonoDomain * D.34348;
  int D.34349;
  int D.34354;
  char * D.34359;
  char D.34361;
  char * D.34363;
  void * D.34364;
  struct MonoDomain * D.34365;
  char * D.34366;
  struct MonoAssembly * D.34369;
  unsigned char D.34370;
  struct MonoImage * D.34374;
  struct MonoType * type;
  struct MonoReflectionAssembly * assembly;
  struct GString * fullName;
  struct GList * mod;

  if (image != 0B) goto <D.34340>; else goto <D.34338>;
  <D.34340>:
  D.34341 = BIT_FIELD_REF <*image, 64, 192>;
  D.34342 = D.34341 & 34359738368;
  if (D.34342 != 0) goto <D.34343>; else goto <D.34338>;
  <D.34343>:
  D.34344 = image->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.34344, info, ignorecase);
  goto <D.34339>;
  <D.34338>:
  type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
  <D.34339>:
  if (type != 0B) goto <D.34345>; else goto <D.34346>;
  <D.34345>:
  D.34347 = type;
  return D.34347;
  <D.34346>:
  D.34348 = mono_domain_get ();
  D.34349 = mono_domain_has_type_resolve (D.34348);
  if (D.34349 == 0) goto <D.34350>; else goto <D.34351>;
  <D.34350>:
  D.34347 = 0B;
  return D.34347;
  <D.34351>:
  if (type_resolve != 0B) goto <D.34352>; else goto <D.34353>;
  <D.34352>:
  D.34354 = *type_resolve;
  if (D.34354 != 0) goto <D.34355>; else goto <D.34356>;
  <D.34355>:
  D.34347 = 0B;
  return D.34347;
  <D.34356>:
  *type_resolve = 1;
  <D.34353>:
  fullName = monoeg_g_string_new ("");
  D.34359 = info->name_space;
  if (D.34359 != 0B) goto <D.34360>; else goto <D.34357>;
  <D.34360>:
  D.34359 = info->name_space;
  D.34361 = *D.34359;
  if (D.34361 != 0) goto <D.34362>; else goto <D.34357>;
  <D.34362>:
  D.34359 = info->name_space;
  D.34363 = info->name;
  monoeg_g_string_printf (fullName, "%s.%s", D.34359, D.34363);
  goto <D.34358>;
  <D.34357>:
  D.34363 = info->name;
  monoeg_g_string_printf (fullName, "%s", D.34363);
  <D.34358>:
  mod = info->nested;
  goto <D.22130>;
  <D.22129>:
  D.34364 = mod->data;
  monoeg_g_string_append_printf (fullName, "+%s", D.34364);
  mod = mod->next;
  <D.22130>:
  if (mod != 0B) goto <D.22129>; else goto <D.22131>;
  <D.22131>:
  D.34365 = mono_domain_get ();
  D.34366 = fullName->str;
  assembly = mono_domain_try_type_resolve (D.34365, D.34366, 0B);
  if (assembly != 0B) goto <D.34367>; else goto <D.34368>;
  <D.34367>:
  D.34369 = assembly->assembly;
  D.34370 = D.34369->dynamic;
  if (D.34370 != 0) goto <D.34371>; else goto <D.34372>;
  <D.34371>:
  D.34369 = assembly->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.34369, info, ignorecase);
  goto <D.34373>;
  <D.34372>:
  D.34369 = assembly->assembly;
  D.34374 = D.34369->image;
  type = mono_reflection_get_type_internal (rootimage, D.34374, info, ignorecase);
  <D.34373>:
  <D.34368>:
  monoeg_g_string_free (fullName, 1);
  D.34347 = type;
  return D.34347;
}


mono_reflection_get_type_internal_dynamic (struct MonoImage * rootimage, struct MonoAssembly * assembly, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  unsigned char D.34376;
  _Bool D.34377;
  long int D.34378;
  long int D.34379;
  struct MonoDomain * D.34382;
  struct MonoArray * D.34383;
  long unsigned int D.34386;
  char * D.34387;
  struct MonoDynamicImage * D.34388;
  struct MonoImage * D.34389;
  long unsigned int D.34391;
  struct MonoArray * D.34394;
  char * D.34397;
  struct MonoImage * D.34398;
  long unsigned int D.34400;
  struct MonoType * D.34401;
  struct MonoReflectionAssemblyBuilder * abuilder;
  struct MonoType * type;
  int i;

  D.34376 = assembly->dynamic;
  D.34377 = D.34376 == 0;
  D.34378 = (long int) D.34377;
  D.34379 = __builtin_expect (D.34378, 0);
  if (D.34379 != 0) goto <D.34380>; else goto <D.34381>;
  <D.34380>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7574, "assembly->dynamic");
  <D.34381>:
  D.34382 = MEM[(struct MonoDynamicAssembly *)assembly].domain;
  abuilder = mono_assembly_get_object (D.34382, assembly);
  type = 0B;
  D.34383 = abuilder->modules;
  if (D.34383 != 0B) goto <D.34384>; else goto <D.34385>;
  <D.34384>:
  i = 0;
  goto <D.22113>;
  <D.22112>:
  {
    struct MonoReflectionModuleBuilder * mb;

    D.34383 = abuilder->modules;
    D.34386 = (long unsigned int) i;
    D.34387 = mono_array_addr_with_size (D.34383, 8, D.34386);
    mb = MEM[(struct MonoReflectionModuleBuilder * *)D.34387];
    D.34388 = mb->dynamic_image;
    D.34389 = &D.34388->image;
    type = mono_reflection_get_type_internal (rootimage, D.34389, info, ignorecase);
    if (type != 0B) goto <D.22111>; else goto <D.34390>;
    <D.34390>:
  }
  i = i + 1;
  <D.22113>:
  D.34386 = (long unsigned int) i;
  D.34383 = abuilder->modules;
  D.34391 = mono_array_length (D.34383);
  if (D.34386 < D.34391) goto <D.22112>; else goto <D.22111>;
  <D.22111>:
  <D.34385>:
  if (type == 0B) goto <D.34392>; else goto <D.34393>;
  <D.34392>:
  D.34394 = abuilder->loaded_modules;
  if (D.34394 != 0B) goto <D.34395>; else goto <D.34396>;
  <D.34395>:
  i = 0;
  goto <D.22117>;
  <D.22116>:
  {
    struct MonoReflectionModule * mod;

    D.34394 = abuilder->loaded_modules;
    D.34386 = (long unsigned int) i;
    D.34397 = mono_array_addr_with_size (D.34394, 8, D.34386);
    mod = MEM[(struct MonoReflectionModule * *)D.34397];
    D.34398 = mod->image;
    type = mono_reflection_get_type_internal (rootimage, D.34398, info, ignorecase);
    if (type != 0B) goto <D.22115>; else goto <D.34399>;
    <D.34399>:
  }
  i = i + 1;
  <D.22117>:
  D.34386 = (long unsigned int) i;
  D.34394 = abuilder->loaded_modules;
  D.34400 = mono_array_length (D.34394);
  if (D.34386 < D.34400) goto <D.22116>; else goto <D.22115>;
  <D.22115>:
  <D.34396>:
  <D.34393>:
  D.34401 = type;
  return D.34401;
}


mono_reflection_get_type_internal (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  char * D.34407;
  char * D.34408;
  struct MonoType * D.34412;
  const char * D.34415;
  void * D.34416;
  int D.34417;
  int D.22078;
  struct GPtrArray * D.34424;
  unsigned int D.34427;
  long unsigned int D.34428;
  long unsigned int D.34429;
  void * * D.34430;
  long unsigned int D.34431;
  long unsigned int D.34432;
  void * * D.34433;
  struct MonoType * * D.34434;
  struct MonoType * D.34435;
  struct MonoType * D.34436;
  unsigned int i.352;
  struct MonoDomain * D.34440;
  struct MonoType * D.34441;
  int D.34442;
  long int D.34445;
  unsigned int modval.353;
  struct MonoClass * klass;
  struct GList * mod;
  int modval;
  gboolean bounded;

  bounded = 0;
  if (image == 0B) goto <D.34403>; else goto <D.34404>;
  <D.34403>:
  image = mono_defaults.corlib;
  <D.34404>:
  if (ignorecase != 0) goto <D.34405>; else goto <D.34406>;
  <D.34405>:
  D.34407 = info->name_space;
  D.34408 = info->name;
  klass = mono_class_from_name_case (image, D.34407, D.34408);
  goto <D.34409>;
  <D.34406>:
  D.34407 = info->name_space;
  D.34408 = info->name;
  klass = mono_class_from_name (image, D.34407, D.34408);
  <D.34409>:
  if (klass == 0B) goto <D.34410>; else goto <D.34411>;
  <D.34410>:
  D.34412 = 0B;
  return D.34412;
  <D.34411>:
  mod = info->nested;
  goto <D.22083>;
  <D.22082>:
  {
    void * iter;
    struct MonoClass * parent;

    try
      {
        iter = 0B;
        parent = klass;
        mono_class_init (parent);
        goto <D.22080>;
        <D.22079>:
        if (ignorecase != 0) goto <D.34413>; else goto <D.34414>;
        <D.34413>:
        D.34415 = klass->name;
        D.34416 = mod->data;
        D.34417 = monoeg_ascii_strcasecmp (D.34415, D.34416);
        if (D.34417 == 0) goto <D.22069>; else goto <D.34418>;
        <D.34418>:
        goto <D.34419>;
        <D.34414>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.34415 = klass->name;
          D.34416 = mod->data;
          D.22078 = __builtin_strcmp (D.34415, D.34416);
        }
        if (D.22078 == 0) goto <D.22069>; else goto <D.34420>;
        <D.34420>:
        <D.34419>:
        <D.22080>:
        klass = mono_class_get_nested_types (parent, &iter);
        if (klass != 0B) goto <D.22079>; else goto <D.22069>;
        <D.22069>:
        if (klass == 0B) goto <D.22081>; else goto <D.34421>;
        <D.34421>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  mod = mod->next;
  <D.22083>:
  if (mod != 0B) goto <D.22082>; else goto <D.22081>;
  <D.22081>:
  if (klass == 0B) goto <D.34422>; else goto <D.34423>;
  <D.34422>:
  D.34412 = 0B;
  return D.34412;
  <D.34423>:
  D.34424 = info->type_arguments;
  if (D.34424 != 0B) goto <D.34425>; else goto <D.34426>;
  <D.34425>:
  {
    struct MonoType * * type_args;
    struct MonoReflectionType * the_type;
    struct MonoType * instance;
    int i;

    D.34424 = info->type_arguments;
    D.34427 = D.34424->len;
    D.34428 = (long unsigned int) D.34427;
    D.34429 = D.34428 * 8;
    type_args = monoeg_malloc0 (D.34429);
    i = 0;
    goto <D.22090>;
    <D.22089>:
    {
      struct MonoTypeNameParse * subinfo;

      D.34424 = info->type_arguments;
      D.34430 = D.34424->pdata;
      D.34431 = (long unsigned int) i;
      D.34432 = D.34431 * 8;
      D.34433 = D.34430 + D.34432;
      subinfo = *D.34433;
      D.34431 = (long unsigned int) i;
      D.34432 = D.34431 * 8;
      D.34434 = type_args + D.34432;
      D.34435 = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
      *D.34434 = D.34435;
      D.34431 = (long unsigned int) i;
      D.34432 = D.34431 * 8;
      D.34434 = type_args + D.34432;
      D.34436 = *D.34434;
      if (D.34436 == 0B) goto <D.34437>; else goto <D.34438>;
      <D.34437>:
      monoeg_g_free (type_args);
      D.34412 = 0B;
      return D.34412;
      <D.34438>:
    }
    i = i + 1;
    <D.22090>:
    i.352 = (unsigned int) i;
    D.34424 = info->type_arguments;
    D.34427 = D.34424->len;
    if (i.352 < D.34427) goto <D.22089>; else goto <D.22091>;
    <D.22091>:
    D.34440 = mono_domain_get ();
    D.34441 = &klass->byval_arg;
    the_type = mono_type_get_object (D.34440, D.34441);
    D.34424 = info->type_arguments;
    D.34427 = D.34424->len;
    D.34442 = (int) D.34427;
    instance = mono_reflection_bind_generic_parameters (the_type, D.34442, type_args);
    monoeg_g_free (type_args);
    if (instance == 0B) goto <D.34443>; else goto <D.34444>;
    <D.34443>:
    D.34412 = 0B;
    return D.34412;
    <D.34444>:
    klass = mono_class_from_mono_type (instance);
  }
  <D.34426>:
  mod = info->modifiers;
  goto <D.22093>;
  <D.22092>:
  D.34416 = mod->data;
  D.34445 = (long int) D.34416;
  modval = (int) D.34445;
  if (modval == 0) goto <D.34446>; else goto <D.34447>;
  <D.34446>:
  D.34412 = &klass->this_arg;
  return D.34412;
  <D.34447>:
  if (modval == -1) goto <D.34448>; else goto <D.34449>;
  <D.34448>:
  D.34441 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.34441);
  goto <D.34450>;
  <D.34449>:
  if (modval == -2) goto <D.34451>; else goto <D.34452>;
  <D.34451>:
  bounded = 1;
  goto <D.34453>;
  <D.34452>:
  modval.353 = (unsigned int) modval;
  klass = mono_bounded_array_class_get (klass, modval.353, bounded);
  <D.34453>:
  <D.34450>:
  mod = mod->next;
  <D.22093>:
  if (mod != 0B) goto <D.22092>; else goto <D.22094>;
  <D.22094>:
  D.34412 = &klass->byval_arg;
  return D.34412;
}


_mono_reflection_get_type_from_info (struct MonoTypeNameParse * info, struct MonoImage * image, gboolean ignorecase)
{
  const char * D.34458;
  struct MonoAssemblyName * D.34461;
  struct MonoAssembly * D.34466;
  struct MonoAssemblyName * D.34469;
  int D.34470;
  struct MonoType * D.34477;
  struct MonoImage * D.34485;
  gboolean type_resolve;
  struct MonoType * type;
  struct MonoImage * rootimage;

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

        D.34461 = &info->assembly;
        assembly = mono_assembly_loaded (D.34461);
        if (assembly == 0B) goto <D.34462>; else goto <D.34463>;
        <D.34462>:
        if (image != 0B) goto <D.34464>; else goto <D.34465>;
        <D.34464>:
        D.34466 = image->assembly;
        if (D.34466 != 0B) goto <D.34467>; else goto <D.34468>;
        <D.34467>:
        D.34461 = &info->assembly;
        D.34466 = image->assembly;
        D.34469 = &D.34466->aname;
        D.34470 = mono_assembly_names_equal (D.34461, D.34469);
        if (D.34470 != 0) goto <D.34471>; else goto <D.34472>;
        <D.34471>:
        assembly = image->assembly;
        <D.34472>:
        <D.34468>:
        <D.34465>:
        <D.34463>:
        if (assembly == 0B) goto <D.34473>; else goto <D.34474>;
        <D.34473>:
        D.34461 = &info->assembly;
        assembly = mono_assembly_load (D.34461, 0B, 0B);
        if (assembly == 0B) goto <D.34475>; else goto <D.34476>;
        <D.34475>:
        D.34477 = 0B;
        return D.34477;
        <D.34476>:
        <D.34474>:
        image = assembly->image;
      }
      goto <D.34478>;
      <D.34460>:
      if (image == 0B) goto <D.34479>; else goto <D.34480>;
      <D.34479>:
      image = mono_defaults.corlib;
      <D.34480>:
      <D.34478>:
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      if (type == 0B) goto <D.34481>; else goto <D.34482>;
      <D.34481>:
      D.34458 = info->assembly.name;
      if (D.34458 == 0B) goto <D.34483>; else goto <D.34484>;
      <D.34483>:
      D.34485 = mono_defaults.corlib;
      if (D.34485 != image) goto <D.34486>; else goto <D.34487>;
      <D.34486>:
      image = mono_defaults.corlib;
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      <D.34487>:
      <D.34484>:
      <D.34482>:
      D.34477 = type;
      return D.34477;
    }
  finally
    {
      type_resolve = {CLOBBER};
    }
}


mono_reflection_free_type_info (struct MonoTypeNameParse * info)
{
  struct GList * D.34490;
  struct GList * D.34491;
  struct GPtrArray * D.34492;
  void * * D.34495;
  long unsigned int D.34496;
  long unsigned int D.34497;
  void * * D.34498;
  unsigned int i.354;
  unsigned int D.34500;

  D.34490 = info->modifiers;
  monoeg_g_list_free (D.34490);
  D.34491 = info->nested;
  monoeg_g_list_free (D.34491);
  D.34492 = info->type_arguments;
  if (D.34492 != 0B) goto <D.34493>; else goto <D.34494>;
  <D.34493>:
  {
    int i;

    i = 0;
    goto <D.22138>;
    <D.22137>:
    {
      struct MonoTypeNameParse * subinfo;

      D.34492 = info->type_arguments;
      D.34495 = D.34492->pdata;
      D.34496 = (long unsigned int) i;
      D.34497 = D.34496 * 8;
      D.34498 = D.34495 + D.34497;
      subinfo = *D.34498;
      mono_reflection_free_type_info (subinfo);
      monoeg_g_free (subinfo);
    }
    i = i + 1;
    <D.22138>:
    i.354 = (unsigned int) i;
    D.34492 = info->type_arguments;
    D.34500 = D.34492->len;
    if (i.354 < D.34500) goto <D.22137>; else goto <D.22139>;
    <D.22139>:
    D.34492 = info->type_arguments;
    monoeg_g_ptr_array_free (D.34492, 1);
  }
  <D.34494>:
}


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

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


mono_reflection_get_token (struct MonoObject * obj)
{
  struct MonoVTable * D.34507;
  int D.22160;
  int iftmp.355;
  int D.22159;
  const char[14] * D.34511;
  unsigned char D.34512;
  int D.34513;
  unsigned char D.34514;
  int D.34515;
  const unsigned char * D.34520;
  unsigned char D.34521;
  int D.34522;
  const unsigned char * D.34523;
  unsigned char D.34524;
  int D.34525;
  const unsigned char * D.34530;
  unsigned char D.34531;
  int D.34532;
  const unsigned char * D.34533;
  unsigned char D.34534;
  int D.34535;
  const unsigned char * D.34540;
  unsigned char D.34541;
  int D.34542;
  const unsigned char * D.34543;
  unsigned char D.34544;
  int D.34545;
  const char * D.34547;
  unsigned int D.34550;
  int D.22170;
  int iftmp.356;
  int D.22169;
  const char[19] * D.34555;
  unsigned char D.34556;
  int D.34557;
  unsigned char D.34558;
  int D.34559;
  const unsigned char * D.34564;
  unsigned char D.34565;
  int D.34566;
  const unsigned char * D.34567;
  unsigned char D.34568;
  int D.34569;
  const unsigned char * D.34574;
  unsigned char D.34575;
  int D.34576;
  const unsigned char * D.34577;
  unsigned char D.34578;
  int D.34579;
  const unsigned char * D.34584;
  unsigned char D.34585;
  int D.34586;
  const unsigned char * D.34587;
  unsigned char D.34588;
  int D.34589;
  unsigned int D.34593;
  int D.22180;
  int iftmp.357;
  int D.22179;
  const char[13] * D.34598;
  unsigned char D.34599;
  int D.34600;
  unsigned char D.34601;
  int D.34602;
  const unsigned char * D.34607;
  unsigned char D.34608;
  int D.34609;
  const unsigned char * D.34610;
  unsigned char D.34611;
  int D.34612;
  const unsigned char * D.34617;
  unsigned char D.34618;
  int D.34619;
  const unsigned char * D.34620;
  unsigned char D.34621;
  int D.34622;
  const unsigned char * D.34627;
  unsigned char D.34628;
  int D.34629;
  const unsigned char * D.34630;
  unsigned char D.34631;
  int D.34632;
  int D.34636;
  int D.34637;
  int D.22190;
  int iftmp.358;
  int D.22189;
  const char[12] * D.34642;
  unsigned char D.34643;
  int D.34644;
  unsigned char D.34645;
  int D.34646;
  const unsigned char * D.34651;
  unsigned char D.34652;
  int D.34653;
  const unsigned char * D.34654;
  unsigned char D.34655;
  int D.34656;
  const unsigned char * D.34661;
  unsigned char D.34662;
  int D.34663;
  const unsigned char * D.34664;
  unsigned char D.34665;
  int D.34666;
  const unsigned char * D.34671;
  unsigned char D.34672;
  int D.34673;
  const unsigned char * D.34674;
  unsigned char D.34675;
  int D.34676;
  unsigned int D.34680;
  int D.22200;
  int iftmp.359;
  int D.22199;
  const char[9] * D.34685;
  unsigned char D.34686;
  int D.34687;
  unsigned char D.34688;
  int D.34689;
  const unsigned char * D.34694;
  unsigned char D.34695;
  int D.34696;
  const unsigned char * D.34697;
  unsigned char D.34698;
  int D.34699;
  const unsigned char * D.34704;
  unsigned char D.34705;
  int D.34706;
  const unsigned char * D.34707;
  unsigned char D.34708;
  int D.34709;
  const unsigned char * D.34714;
  unsigned char D.34715;
  int D.34716;
  const unsigned char * D.34717;
  unsigned char D.34718;
  int D.34719;
  int D.34723;
  struct MonoException * D.34726;
  int D.22211;
  int iftmp.360;
  int D.22210;
  const char[12] * D.34734;
  unsigned char D.34735;
  int D.34736;
  unsigned char D.34737;
  int D.34738;
  const unsigned char * D.34743;
  unsigned char D.34744;
  int D.34745;
  const unsigned char * D.34746;
  unsigned char D.34747;
  int D.34748;
  const unsigned char * D.34753;
  unsigned char D.34754;
  int D.34755;
  const unsigned char * D.34756;
  unsigned char D.34757;
  int D.34758;
  const unsigned char * D.34763;
  unsigned char D.34764;
  int D.34765;
  const unsigned char * D.34766;
  unsigned char D.34767;
  int D.34768;
  int D.22220;
  int iftmp.361;
  int D.22219;
  const char[11] * D.34774;
  unsigned char D.34775;
  int D.34776;
  unsigned char D.34777;
  int D.34778;
  const unsigned char * D.34783;
  unsigned char D.34784;
  int D.34785;
  const unsigned char * D.34786;
  unsigned char D.34787;
  int D.34788;
  const unsigned char * D.34793;
  unsigned char D.34794;
  int D.34795;
  const unsigned char * D.34796;
  unsigned char D.34797;
  int D.34798;
  const unsigned char * D.34803;
  unsigned char D.34804;
  int D.34805;
  const unsigned char * D.34806;
  unsigned char D.34807;
  int D.34808;
  int D.22229;
  int iftmp.362;
  int D.22228;
  const char[18] * D.34814;
  unsigned char D.34815;
  int D.34816;
  unsigned char D.34817;
  int D.34818;
  const unsigned char * D.34823;
  unsigned char D.34824;
  int D.34825;
  const unsigned char * D.34826;
  unsigned char D.34827;
  int D.34828;
  const unsigned char * D.34833;
  unsigned char D.34834;
  int D.34835;
  const unsigned char * D.34836;
  unsigned char D.34837;
  int D.34838;
  const unsigned char * D.34843;
  unsigned char D.34844;
  int D.34845;
  const unsigned char * D.34846;
  unsigned char D.34847;
  int D.34848;
  int D.22238;
  int iftmp.363;
  int D.22237;
  const char[19] * D.34854;
  unsigned char D.34855;
  int D.34856;
  unsigned char D.34857;
  int D.34858;
  const unsigned char * D.34863;
  unsigned char D.34864;
  int D.34865;
  const unsigned char * D.34866;
  unsigned char D.34867;
  int D.34868;
  const unsigned char * D.34873;
  unsigned char D.34874;
  int D.34875;
  const unsigned char * D.34876;
  unsigned char D.34877;
  int D.34878;
  const unsigned char * D.34883;
  unsigned char D.34884;
  int D.34885;
  const unsigned char * D.34886;
  unsigned char D.34887;
  int D.34888;
  struct MonoMethod * D.34890;
  long unsigned int D.34891;
  long unsigned int D.34892;
  uint32_t D.34895;
  struct MonoMethod * D.34896;
  int D.22249;
  int iftmp.364;
  int D.22248;
  const char[10] * D.34900;
  unsigned char D.34901;
  int D.34902;
  unsigned char D.34903;
  int D.34904;
  const unsigned char * D.34909;
  unsigned char D.34910;
  int D.34911;
  const unsigned char * D.34912;
  unsigned char D.34913;
  int D.34914;
  const unsigned char * D.34919;
  unsigned char D.34920;
  int D.34921;
  const unsigned char * D.34922;
  unsigned char D.34923;
  int D.34924;
  const unsigned char * D.34929;
  unsigned char D.34930;
  int D.34931;
  const unsigned char * D.34932;
  unsigned char D.34933;
  int D.34934;
  struct MonoClassField * D.34938;
  int D.34939;
  struct MonoClass * D.34942;
  long int D.34943;
  struct MonoClassField * D.34944;
  long int D.34945;
  long int D.34946;
  long int D.34947;
  int iftmp.365;
  int D.34953;
  _Bool D.34954;
  long int D.34955;
  long int D.34956;
  struct MonoObject * * D.34959;
  long unsigned int D.34960;
  long unsigned int D.34961;
  struct MonoObject * * D.34962;
  int D.22262;
  int iftmp.366;
  int D.22261;
  const char[13] * D.34967;
  unsigned char D.34968;
  int D.34969;
  unsigned char D.34970;
  int D.34971;
  const unsigned char * D.34976;
  unsigned char D.34977;
  int D.34978;
  const unsigned char * D.34979;
  unsigned char D.34980;
  int D.34981;
  const unsigned char * D.34986;
  unsigned char D.34987;
  int D.34988;
  const unsigned char * D.34989;
  unsigned char D.34990;
  int D.34991;
  const unsigned char * D.34996;
  unsigned char D.34997;
  int D.34998;
  const unsigned char * D.34999;
  unsigned char D.35000;
  int D.35001;
  struct MonoProperty * D.35005;
  int D.22272;
  int iftmp.367;
  int D.22271;
  const char[10] * D.35010;
  unsigned char D.35011;
  int D.35012;
  unsigned char D.35013;
  int D.35014;
  const unsigned char * D.35019;
  unsigned char D.35020;
  int D.35021;
  const unsigned char * D.35022;
  unsigned char D.35023;
  int D.35024;
  const unsigned char * D.35029;
  unsigned char D.35030;
  int D.35031;
  const unsigned char * D.35032;
  unsigned char D.35033;
  int D.35034;
  const unsigned char * D.35039;
  unsigned char D.35040;
  int D.35041;
  const unsigned char * D.35042;
  unsigned char D.35043;
  int D.35044;
  struct MonoEvent * D.35048;
  int D.22282;
  int iftmp.368;
  int D.22281;
  const char[14] * D.35056;
  unsigned char D.35057;
  int D.35058;
  unsigned char D.35059;
  int D.35060;
  const unsigned char * D.35065;
  unsigned char D.35066;
  int D.35067;
  const unsigned char * D.35068;
  unsigned char D.35069;
  int D.35070;
  const unsigned char * D.35075;
  unsigned char D.35076;
  int D.35077;
  const unsigned char * D.35078;
  unsigned char D.35079;
  int D.35080;
  const unsigned char * D.35085;
  unsigned char D.35086;
  int D.35087;
  const unsigned char * D.35088;
  unsigned char D.35089;
  int D.35090;
  int D.22291;
  int iftmp.369;
  int D.22290;
  const char[18] * D.35096;
  unsigned char D.35097;
  int D.35098;
  unsigned char D.35099;
  int D.35100;
  const unsigned char * D.35105;
  unsigned char D.35106;
  int D.35107;
  const unsigned char * D.35108;
  unsigned char D.35109;
  int D.35110;
  const unsigned char * D.35115;
  unsigned char D.35116;
  int D.35117;
  const unsigned char * D.35118;
  unsigned char D.35119;
  int D.35120;
  const unsigned char * D.35125;
  unsigned char D.35126;
  int D.35127;
  const unsigned char * D.35128;
  unsigned char D.35129;
  int D.35130;
  struct MonoObject * D.35132;
  struct MonoVTable * D.35133;
  int D.35134;
  _Bool D.35135;
  long int D.35136;
  long int D.35137;
  struct MonoMethod * D.35140;
  int D.35141;
  int D.22302;
  int iftmp.370;
  int D.22301;
  const char[7] * D.35148;
  unsigned char D.35149;
  int D.35150;
  unsigned char D.35151;
  int D.35152;
  const unsigned char * D.35157;
  unsigned char D.35158;
  int D.35159;
  const unsigned char * D.35160;
  unsigned char D.35161;
  int D.35162;
  const unsigned char * D.35167;
  unsigned char D.35168;
  int D.35169;
  const unsigned char * D.35170;
  unsigned char D.35171;
  int D.35172;
  const unsigned char * D.35177;
  unsigned char D.35178;
  int D.35179;
  const unsigned char * D.35180;
  unsigned char D.35181;
  int D.35182;
  int D.22311;
  int iftmp.371;
  int D.22310;
  const char[11] * D.35188;
  unsigned char D.35189;
  int D.35190;
  unsigned char D.35191;
  int D.35192;
  const unsigned char * D.35197;
  unsigned char D.35198;
  int D.35199;
  const unsigned char * D.35200;
  unsigned char D.35201;
  int D.35202;
  const unsigned char * D.35207;
  unsigned char D.35208;
  int D.35209;
  const unsigned char * D.35210;
  unsigned char D.35211;
  int D.35212;
  const unsigned char * D.35217;
  unsigned char D.35218;
  int D.35219;
  const unsigned char * D.35220;
  unsigned char D.35221;
  int D.35222;
  int D.22321;
  int iftmp.372;
  int D.22320;
  const char[9] * D.35230;
  unsigned char D.35231;
  int D.35232;
  unsigned char D.35233;
  int D.35234;
  const unsigned char * D.35239;
  unsigned char D.35240;
  int D.35241;
  const unsigned char * D.35242;
  unsigned char D.35243;
  int D.35244;
  const unsigned char * D.35249;
  unsigned char D.35250;
  int D.35251;
  const unsigned char * D.35252;
  unsigned char D.35253;
  int D.35254;
  const unsigned char * D.35259;
  unsigned char D.35260;
  int D.35261;
  const unsigned char * D.35262;
  unsigned char D.35263;
  int D.35264;
  int D.22330;
  int iftmp.373;
  int D.22329;
  const char[13] * D.35270;
  unsigned char D.35271;
  int D.35272;
  unsigned char D.35273;
  int D.35274;
  const unsigned char * D.35279;
  unsigned char D.35280;
  int D.35281;
  const unsigned char * D.35282;
  unsigned char D.35283;
  int D.35284;
  const unsigned char * D.35289;
  unsigned char D.35290;
  int D.35291;
  const unsigned char * D.35292;
  unsigned char D.35293;
  int D.35294;
  const unsigned char * D.35299;
  unsigned char D.35300;
  int D.35301;
  const unsigned char * D.35302;
  unsigned char D.35303;
  int D.35304;
  const char * D.35306;
  struct MonoClass * klass;
  guint32 token;

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

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

      __s2 = klass->name;
      D.34511 = "MethodBuilder";
      D.34512 = MEM[(const unsigned char *)D.34511];
      D.34513 = (int) D.34512;
      D.34514 = *__s2;
      D.34515 = (int) D.34514;
      __result = D.34513 - D.34515;
      {
        if (__s2_len != 0) goto <D.34516>; else goto <D.34517>;
        <D.34516>:
        if (__result == 0) goto <D.34518>; else goto <D.34519>;
        <D.34518>:
        D.34520 = &MEM[(void *)"MethodBuilder" + 1B];
        D.34521 = *D.34520;
        D.34522 = (int) D.34521;
        D.34523 = __s2 + 1;
        D.34524 = *D.34523;
        D.34525 = (int) D.34524;
        __result = D.34522 - D.34525;
        if (__s2_len > 1) goto <D.34526>; else goto <D.34527>;
        <D.34526>:
        if (__result == 0) goto <D.34528>; else goto <D.34529>;
        <D.34528>:
        D.34530 = &MEM[(void *)"MethodBuilder" + 2B];
        D.34531 = *D.34530;
        D.34532 = (int) D.34531;
        D.34533 = __s2 + 2;
        D.34534 = *D.34533;
        D.34535 = (int) D.34534;
        __result = D.34532 - D.34535;
        if (__s2_len > 2) goto <D.34536>; else goto <D.34537>;
        <D.34536>:
        if (__result == 0) goto <D.34538>; else goto <D.34539>;
        <D.34538>:
        D.34540 = &MEM[(void *)"MethodBuilder" + 3B];
        D.34541 = *D.34540;
        D.34542 = (int) D.34541;
        D.34543 = __s2 + 3;
        D.34544 = *D.34543;
        D.34545 = (int) D.34544;
        __result = D.34542 - D.34545;
        <D.34539>:
        <D.34537>:
        <D.34529>:
        <D.34527>:
        <D.34519>:
        <D.34517>:
      }
      D.22159 = __result;
    }
    iftmp.355 = -D.22159;
    goto <D.34546>;
    <D.34510>:
    D.34547 = klass->name;
    iftmp.355 = __builtin_strcmp (D.34547, "MethodBuilder");
    <D.34546>:
    D.22160 = iftmp.355;
  }
  if (D.22160 == 0) goto <D.34548>; else goto <D.34549>;
  <D.34548>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.34550 = mb->table_idx;
    token = D.34550 | 100663296;
  }
  goto <D.34551>;
  <D.34549>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34555 = "ConstructorBuilder";
      D.34556 = MEM[(const unsigned char *)D.34555];
      D.34557 = (int) D.34556;
      D.34558 = *__s2;
      D.34559 = (int) D.34558;
      __result = D.34557 - D.34559;
      {
        if (__s2_len != 0) goto <D.34560>; else goto <D.34561>;
        <D.34560>:
        if (__result == 0) goto <D.34562>; else goto <D.34563>;
        <D.34562>:
        D.34564 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.34565 = *D.34564;
        D.34566 = (int) D.34565;
        D.34567 = __s2 + 1;
        D.34568 = *D.34567;
        D.34569 = (int) D.34568;
        __result = D.34566 - D.34569;
        if (__s2_len > 1) goto <D.34570>; else goto <D.34571>;
        <D.34570>:
        if (__result == 0) goto <D.34572>; else goto <D.34573>;
        <D.34572>:
        D.34574 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.34575 = *D.34574;
        D.34576 = (int) D.34575;
        D.34577 = __s2 + 2;
        D.34578 = *D.34577;
        D.34579 = (int) D.34578;
        __result = D.34576 - D.34579;
        if (__s2_len > 2) goto <D.34580>; else goto <D.34581>;
        <D.34580>:
        if (__result == 0) goto <D.34582>; else goto <D.34583>;
        <D.34582>:
        D.34584 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.34585 = *D.34584;
        D.34586 = (int) D.34585;
        D.34587 = __s2 + 3;
        D.34588 = *D.34587;
        D.34589 = (int) D.34588;
        __result = D.34586 - D.34589;
        <D.34583>:
        <D.34581>:
        <D.34573>:
        <D.34571>:
        <D.34563>:
        <D.34561>:
      }
      D.22169 = __result;
    }
    iftmp.356 = -D.22169;
    goto <D.34590>;
    <D.34554>:
    D.34547 = klass->name;
    iftmp.356 = __builtin_strcmp (D.34547, "ConstructorBuilder");
    <D.34590>:
    D.22170 = iftmp.356;
  }
  if (D.22170 == 0) goto <D.34591>; else goto <D.34592>;
  <D.34591>:
  {
    struct MonoReflectionCtorBuilder * mb;

    mb = obj;
    D.34593 = mb->table_idx;
    token = D.34593 | 100663296;
  }
  goto <D.34594>;
  <D.34592>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34598 = "FieldBuilder";
      D.34599 = MEM[(const unsigned char *)D.34598];
      D.34600 = (int) D.34599;
      D.34601 = *__s2;
      D.34602 = (int) D.34601;
      __result = D.34600 - D.34602;
      {
        if (__s2_len != 0) goto <D.34603>; else goto <D.34604>;
        <D.34603>:
        if (__result == 0) goto <D.34605>; else goto <D.34606>;
        <D.34605>:
        D.34607 = &MEM[(void *)"FieldBuilder" + 1B];
        D.34608 = *D.34607;
        D.34609 = (int) D.34608;
        D.34610 = __s2 + 1;
        D.34611 = *D.34610;
        D.34612 = (int) D.34611;
        __result = D.34609 - D.34612;
        if (__s2_len > 1) goto <D.34613>; else goto <D.34614>;
        <D.34613>:
        if (__result == 0) goto <D.34615>; else goto <D.34616>;
        <D.34615>:
        D.34617 = &MEM[(void *)"FieldBuilder" + 2B];
        D.34618 = *D.34617;
        D.34619 = (int) D.34618;
        D.34620 = __s2 + 2;
        D.34621 = *D.34620;
        D.34622 = (int) D.34621;
        __result = D.34619 - D.34622;
        if (__s2_len > 2) goto <D.34623>; else goto <D.34624>;
        <D.34623>:
        if (__result == 0) goto <D.34625>; else goto <D.34626>;
        <D.34625>:
        D.34627 = &MEM[(void *)"FieldBuilder" + 3B];
        D.34628 = *D.34627;
        D.34629 = (int) D.34628;
        D.34630 = __s2 + 3;
        D.34631 = *D.34630;
        D.34632 = (int) D.34631;
        __result = D.34629 - D.34632;
        <D.34626>:
        <D.34624>:
        <D.34616>:
        <D.34614>:
        <D.34606>:
        <D.34604>:
      }
      D.22179 = __result;
    }
    iftmp.357 = -D.22179;
    goto <D.34633>;
    <D.34597>:
    D.34547 = klass->name;
    iftmp.357 = __builtin_strcmp (D.34547, "FieldBuilder");
    <D.34633>:
    D.22180 = iftmp.357;
  }
  if (D.22180 == 0) goto <D.34634>; else goto <D.34635>;
  <D.34634>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.34636 = fb->table_idx;
    D.34637 = D.34636 | 67108864;
    token = (guint32) D.34637;
  }
  goto <D.34638>;
  <D.34635>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34642 = "TypeBuilder";
      D.34643 = MEM[(const unsigned char *)D.34642];
      D.34644 = (int) D.34643;
      D.34645 = *__s2;
      D.34646 = (int) D.34645;
      __result = D.34644 - D.34646;
      {
        if (__s2_len != 0) goto <D.34647>; else goto <D.34648>;
        <D.34647>:
        if (__result == 0) goto <D.34649>; else goto <D.34650>;
        <D.34649>:
        D.34651 = &MEM[(void *)"TypeBuilder" + 1B];
        D.34652 = *D.34651;
        D.34653 = (int) D.34652;
        D.34654 = __s2 + 1;
        D.34655 = *D.34654;
        D.34656 = (int) D.34655;
        __result = D.34653 - D.34656;
        if (__s2_len > 1) goto <D.34657>; else goto <D.34658>;
        <D.34657>:
        if (__result == 0) goto <D.34659>; else goto <D.34660>;
        <D.34659>:
        D.34661 = &MEM[(void *)"TypeBuilder" + 2B];
        D.34662 = *D.34661;
        D.34663 = (int) D.34662;
        D.34664 = __s2 + 2;
        D.34665 = *D.34664;
        D.34666 = (int) D.34665;
        __result = D.34663 - D.34666;
        if (__s2_len > 2) goto <D.34667>; else goto <D.34668>;
        <D.34667>:
        if (__result == 0) goto <D.34669>; else goto <D.34670>;
        <D.34669>:
        D.34671 = &MEM[(void *)"TypeBuilder" + 3B];
        D.34672 = *D.34671;
        D.34673 = (int) D.34672;
        D.34674 = __s2 + 3;
        D.34675 = *D.34674;
        D.34676 = (int) D.34675;
        __result = D.34673 - D.34676;
        <D.34670>:
        <D.34668>:
        <D.34660>:
        <D.34658>:
        <D.34650>:
        <D.34648>:
      }
      D.22189 = __result;
    }
    iftmp.358 = -D.22189;
    goto <D.34677>;
    <D.34641>:
    D.34547 = klass->name;
    iftmp.358 = __builtin_strcmp (D.34547, "TypeBuilder");
    <D.34677>:
    D.22190 = iftmp.358;
  }
  if (D.22190 == 0) goto <D.34678>; else goto <D.34679>;
  <D.34678>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.34680 = tb->table_idx;
    token = D.34680 | 33554432;
  }
  goto <D.34681>;
  <D.34679>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34685 = "MonoType";
      D.34686 = MEM[(const unsigned char *)D.34685];
      D.34687 = (int) D.34686;
      D.34688 = *__s2;
      D.34689 = (int) D.34688;
      __result = D.34687 - D.34689;
      {
        if (__s2_len != 0) goto <D.34690>; else goto <D.34691>;
        <D.34690>:
        if (__result == 0) goto <D.34692>; else goto <D.34693>;
        <D.34692>:
        D.34694 = &MEM[(void *)"MonoType" + 1B];
        D.34695 = *D.34694;
        D.34696 = (int) D.34695;
        D.34697 = __s2 + 1;
        D.34698 = *D.34697;
        D.34699 = (int) D.34698;
        __result = D.34696 - D.34699;
        if (__s2_len > 1) goto <D.34700>; else goto <D.34701>;
        <D.34700>:
        if (__result == 0) goto <D.34702>; else goto <D.34703>;
        <D.34702>:
        D.34704 = &MEM[(void *)"MonoType" + 2B];
        D.34705 = *D.34704;
        D.34706 = (int) D.34705;
        D.34707 = __s2 + 2;
        D.34708 = *D.34707;
        D.34709 = (int) D.34708;
        __result = D.34706 - D.34709;
        if (__s2_len > 2) goto <D.34710>; else goto <D.34711>;
        <D.34710>:
        if (__result == 0) goto <D.34712>; else goto <D.34713>;
        <D.34712>:
        D.34714 = &MEM[(void *)"MonoType" + 3B];
        D.34715 = *D.34714;
        D.34716 = (int) D.34715;
        D.34717 = __s2 + 3;
        D.34718 = *D.34717;
        D.34719 = (int) D.34718;
        __result = D.34716 - D.34719;
        <D.34713>:
        <D.34711>:
        <D.34703>:
        <D.34701>:
        <D.34693>:
        <D.34691>:
      }
      D.22199 = __result;
    }
    iftmp.359 = -D.22199;
    goto <D.34720>;
    <D.34684>:
    D.34547 = klass->name;
    iftmp.359 = __builtin_strcmp (D.34547, "MonoType");
    <D.34720>:
    D.22200 = iftmp.359;
  }
  if (D.22200 == 0) goto <D.34721>; else goto <D.34722>;
  <D.34721>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.34723 = mono_class_init (mc);
    if (D.34723 == 0) goto <D.34724>; else goto <D.34725>;
    <D.34724>:
    D.34726 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.34726);
    <D.34725>:
    token = mc->type_token;
  }
  goto <D.34727>;
  <D.34722>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34734 = "MonoCMethod";
      D.34735 = MEM[(const unsigned char *)D.34734];
      D.34736 = (int) D.34735;
      D.34737 = *__s2;
      D.34738 = (int) D.34737;
      __result = D.34736 - D.34738;
      {
        if (__s2_len != 0) goto <D.34739>; else goto <D.34740>;
        <D.34739>:
        if (__result == 0) goto <D.34741>; else goto <D.34742>;
        <D.34741>:
        D.34743 = &MEM[(void *)"MonoCMethod" + 1B];
        D.34744 = *D.34743;
        D.34745 = (int) D.34744;
        D.34746 = __s2 + 1;
        D.34747 = *D.34746;
        D.34748 = (int) D.34747;
        __result = D.34745 - D.34748;
        if (__s2_len > 1) goto <D.34749>; else goto <D.34750>;
        <D.34749>:
        if (__result == 0) goto <D.34751>; else goto <D.34752>;
        <D.34751>:
        D.34753 = &MEM[(void *)"MonoCMethod" + 2B];
        D.34754 = *D.34753;
        D.34755 = (int) D.34754;
        D.34756 = __s2 + 2;
        D.34757 = *D.34756;
        D.34758 = (int) D.34757;
        __result = D.34755 - D.34758;
        if (__s2_len > 2) goto <D.34759>; else goto <D.34760>;
        <D.34759>:
        if (__result == 0) goto <D.34761>; else goto <D.34762>;
        <D.34761>:
        D.34763 = &MEM[(void *)"MonoCMethod" + 3B];
        D.34764 = *D.34763;
        D.34765 = (int) D.34764;
        D.34766 = __s2 + 3;
        D.34767 = *D.34766;
        D.34768 = (int) D.34767;
        __result = D.34765 - D.34768;
        <D.34762>:
        <D.34760>:
        <D.34752>:
        <D.34750>:
        <D.34742>:
        <D.34740>:
      }
      D.22210 = __result;
    }
    iftmp.360 = -D.22210;
    goto <D.34769>;
    <D.34733>:
    D.34547 = klass->name;
    iftmp.360 = __builtin_strcmp (D.34547, "MonoCMethod");
    <D.34769>:
    D.22211 = iftmp.360;
  }
  if (D.22211 == 0) goto <D.34728>; else goto <D.34770>;
  <D.34770>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34774 = "MonoMethod";
      D.34775 = MEM[(const unsigned char *)D.34774];
      D.34776 = (int) D.34775;
      D.34777 = *__s2;
      D.34778 = (int) D.34777;
      __result = D.34776 - D.34778;
      {
        if (__s2_len != 0) goto <D.34779>; else goto <D.34780>;
        <D.34779>:
        if (__result == 0) goto <D.34781>; else goto <D.34782>;
        <D.34781>:
        D.34783 = &MEM[(void *)"MonoMethod" + 1B];
        D.34784 = *D.34783;
        D.34785 = (int) D.34784;
        D.34786 = __s2 + 1;
        D.34787 = *D.34786;
        D.34788 = (int) D.34787;
        __result = D.34785 - D.34788;
        if (__s2_len > 1) goto <D.34789>; else goto <D.34790>;
        <D.34789>:
        if (__result == 0) goto <D.34791>; else goto <D.34792>;
        <D.34791>:
        D.34793 = &MEM[(void *)"MonoMethod" + 2B];
        D.34794 = *D.34793;
        D.34795 = (int) D.34794;
        D.34796 = __s2 + 2;
        D.34797 = *D.34796;
        D.34798 = (int) D.34797;
        __result = D.34795 - D.34798;
        if (__s2_len > 2) goto <D.34799>; else goto <D.34800>;
        <D.34799>:
        if (__result == 0) goto <D.34801>; else goto <D.34802>;
        <D.34801>:
        D.34803 = &MEM[(void *)"MonoMethod" + 3B];
        D.34804 = *D.34803;
        D.34805 = (int) D.34804;
        D.34806 = __s2 + 3;
        D.34807 = *D.34806;
        D.34808 = (int) D.34807;
        __result = D.34805 - D.34808;
        <D.34802>:
        <D.34800>:
        <D.34792>:
        <D.34790>:
        <D.34782>:
        <D.34780>:
      }
      D.22219 = __result;
    }
    iftmp.361 = -D.22219;
    goto <D.34809>;
    <D.34773>:
    D.34547 = klass->name;
    iftmp.361 = __builtin_strcmp (D.34547, "MonoMethod");
    <D.34809>:
    D.22220 = iftmp.361;
  }
  if (D.22220 == 0) goto <D.34728>; else goto <D.34810>;
  <D.34810>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34814 = "MonoGenericMethod";
      D.34815 = MEM[(const unsigned char *)D.34814];
      D.34816 = (int) D.34815;
      D.34817 = *__s2;
      D.34818 = (int) D.34817;
      __result = D.34816 - D.34818;
      {
        if (__s2_len != 0) goto <D.34819>; else goto <D.34820>;
        <D.34819>:
        if (__result == 0) goto <D.34821>; else goto <D.34822>;
        <D.34821>:
        D.34823 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.34824 = *D.34823;
        D.34825 = (int) D.34824;
        D.34826 = __s2 + 1;
        D.34827 = *D.34826;
        D.34828 = (int) D.34827;
        __result = D.34825 - D.34828;
        if (__s2_len > 1) goto <D.34829>; else goto <D.34830>;
        <D.34829>:
        if (__result == 0) goto <D.34831>; else goto <D.34832>;
        <D.34831>:
        D.34833 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.34834 = *D.34833;
        D.34835 = (int) D.34834;
        D.34836 = __s2 + 2;
        D.34837 = *D.34836;
        D.34838 = (int) D.34837;
        __result = D.34835 - D.34838;
        if (__s2_len > 2) goto <D.34839>; else goto <D.34840>;
        <D.34839>:
        if (__result == 0) goto <D.34841>; else goto <D.34842>;
        <D.34841>:
        D.34843 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.34844 = *D.34843;
        D.34845 = (int) D.34844;
        D.34846 = __s2 + 3;
        D.34847 = *D.34846;
        D.34848 = (int) D.34847;
        __result = D.34845 - D.34848;
        <D.34842>:
        <D.34840>:
        <D.34832>:
        <D.34830>:
        <D.34822>:
        <D.34820>:
      }
      D.22228 = __result;
    }
    iftmp.362 = -D.22228;
    goto <D.34849>;
    <D.34813>:
    D.34547 = klass->name;
    iftmp.362 = __builtin_strcmp (D.34547, "MonoGenericMethod");
    <D.34849>:
    D.22229 = iftmp.362;
  }
  if (D.22229 == 0) goto <D.34728>; else goto <D.34850>;
  <D.34850>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34854 = "MonoGenericCMethod";
      D.34855 = MEM[(const unsigned char *)D.34854];
      D.34856 = (int) D.34855;
      D.34857 = *__s2;
      D.34858 = (int) D.34857;
      __result = D.34856 - D.34858;
      {
        if (__s2_len != 0) goto <D.34859>; else goto <D.34860>;
        <D.34859>:
        if (__result == 0) goto <D.34861>; else goto <D.34862>;
        <D.34861>:
        D.34863 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.34864 = *D.34863;
        D.34865 = (int) D.34864;
        D.34866 = __s2 + 1;
        D.34867 = *D.34866;
        D.34868 = (int) D.34867;
        __result = D.34865 - D.34868;
        if (__s2_len > 1) goto <D.34869>; else goto <D.34870>;
        <D.34869>:
        if (__result == 0) goto <D.34871>; else goto <D.34872>;
        <D.34871>:
        D.34873 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.34874 = *D.34873;
        D.34875 = (int) D.34874;
        D.34876 = __s2 + 2;
        D.34877 = *D.34876;
        D.34878 = (int) D.34877;
        __result = D.34875 - D.34878;
        if (__s2_len > 2) goto <D.34879>; else goto <D.34880>;
        <D.34879>:
        if (__result == 0) goto <D.34881>; else goto <D.34882>;
        <D.34881>:
        D.34883 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.34884 = *D.34883;
        D.34885 = (int) D.34884;
        D.34886 = __s2 + 3;
        D.34887 = *D.34886;
        D.34888 = (int) D.34887;
        __result = D.34885 - D.34888;
        <D.34882>:
        <D.34880>:
        <D.34872>:
        <D.34870>:
        <D.34862>:
        <D.34860>:
      }
      D.22237 = __result;
    }
    iftmp.363 = -D.22237;
    goto <D.34889>;
    <D.34853>:
    D.34547 = klass->name;
    iftmp.363 = __builtin_strcmp (D.34547, "MonoGenericCMethod");
    <D.34889>:
    D.22238 = iftmp.363;
  }
  if (D.22238 == 0) goto <D.34728>; else goto <D.34729>;
  <D.34728>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.34890 = m->method;
    D.34891 = BIT_FIELD_REF <*D.34890, 64, 256>;
    D.34892 = D.34891 & 4096;
    if (D.34892 != 0) goto <D.34893>; else goto <D.34894>;
    <D.34893>:
    {
      struct MonoMethodInflated * inflated;

      inflated = m->method;
      D.34896 = inflated->declaring;
      D.34895 = D.34896->token;
      return D.34895;
    }
    <D.34894>:
    D.34890 = m->method;
    token = D.34890->token;
  }
  goto <D.34730>;
  <D.34729>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34900 = "MonoField";
      D.34901 = MEM[(const unsigned char *)D.34900];
      D.34902 = (int) D.34901;
      D.34903 = *__s2;
      D.34904 = (int) D.34903;
      __result = D.34902 - D.34904;
      {
        if (__s2_len != 0) goto <D.34905>; else goto <D.34906>;
        <D.34905>:
        if (__result == 0) goto <D.34907>; else goto <D.34908>;
        <D.34907>:
        D.34909 = &MEM[(void *)"MonoField" + 1B];
        D.34910 = *D.34909;
        D.34911 = (int) D.34910;
        D.34912 = __s2 + 1;
        D.34913 = *D.34912;
        D.34914 = (int) D.34913;
        __result = D.34911 - D.34914;
        if (__s2_len > 1) goto <D.34915>; else goto <D.34916>;
        <D.34915>:
        if (__result == 0) goto <D.34917>; else goto <D.34918>;
        <D.34917>:
        D.34919 = &MEM[(void *)"MonoField" + 2B];
        D.34920 = *D.34919;
        D.34921 = (int) D.34920;
        D.34922 = __s2 + 2;
        D.34923 = *D.34922;
        D.34924 = (int) D.34923;
        __result = D.34921 - D.34924;
        if (__s2_len > 2) goto <D.34925>; else goto <D.34926>;
        <D.34925>:
        if (__result == 0) goto <D.34927>; else goto <D.34928>;
        <D.34927>:
        D.34929 = &MEM[(void *)"MonoField" + 3B];
        D.34930 = *D.34929;
        D.34931 = (int) D.34930;
        D.34932 = __s2 + 3;
        D.34933 = *D.34932;
        D.34934 = (int) D.34933;
        __result = D.34931 - D.34934;
        <D.34928>:
        <D.34926>:
        <D.34918>:
        <D.34916>:
        <D.34908>:
        <D.34906>:
      }
      D.22248 = __result;
    }
    iftmp.364 = -D.22248;
    goto <D.34935>;
    <D.34899>:
    D.34547 = klass->name;
    iftmp.364 = __builtin_strcmp (D.34547, "MonoField");
    <D.34935>:
    D.22249 = iftmp.364;
  }
  if (D.22249 == 0) goto <D.34936>; else goto <D.34937>;
  <D.34936>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.34938 = f->field;
    D.34939 = is_field_on_inst (D.34938);
    if (D.34939 != 0) goto <D.34940>; else goto <D.34941>;
    <D.34940>:
    {
      struct MonoDynamicGenericClass * dgclass;
      int field_index;
      struct MonoObject * obj;

      D.34938 = f->field;
      D.34942 = D.34938->parent;
      dgclass = D.34942->generic_class;
      D.34938 = f->field;
      D.34943 = (long int) D.34938;
      D.34944 = dgclass->fields;
      D.34945 = (long int) D.34944;
      D.34946 = D.34943 - D.34945;
      D.34947 = D.34946 /[ex] 32;
      field_index = (int) D.34947;
      if (field_index < 0) goto <D.34949>; else goto <D.34952>;
      <D.34952>:
      D.34953 = dgclass->count_fields;
      if (D.34953 <= field_index) goto <D.34949>; else goto <D.34950>;
      <D.34949>:
      iftmp.365 = 1;
      goto <D.34951>;
      <D.34950>:
      iftmp.365 = 0;
      <D.34951>:
      D.34954 = iftmp.365 != 0;
      D.34955 = (long int) D.34954;
      D.34956 = __builtin_expect (D.34955, 0);
      if (D.34956 != 0) goto <D.34957>; else goto <D.34958>;
      <D.34957>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7752, "field_index >= 0 && field_index < dgclass->count_fields");
      <D.34958>:
      D.34959 = dgclass->field_objects;
      D.34960 = (long unsigned int) field_index;
      D.34961 = D.34960 * 8;
      D.34962 = D.34959 + D.34961;
      obj = *D.34962;
      D.34895 = mono_reflection_get_token (obj);
      return D.34895;
    }
    <D.34941>:
    D.34938 = f->field;
    token = mono_class_get_field_token (D.34938);
  }
  goto <D.34963>;
  <D.34937>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34967 = "MonoProperty";
      D.34968 = MEM[(const unsigned char *)D.34967];
      D.34969 = (int) D.34968;
      D.34970 = *__s2;
      D.34971 = (int) D.34970;
      __result = D.34969 - D.34971;
      {
        if (__s2_len != 0) goto <D.34972>; else goto <D.34973>;
        <D.34972>:
        if (__result == 0) goto <D.34974>; else goto <D.34975>;
        <D.34974>:
        D.34976 = &MEM[(void *)"MonoProperty" + 1B];
        D.34977 = *D.34976;
        D.34978 = (int) D.34977;
        D.34979 = __s2 + 1;
        D.34980 = *D.34979;
        D.34981 = (int) D.34980;
        __result = D.34978 - D.34981;
        if (__s2_len > 1) goto <D.34982>; else goto <D.34983>;
        <D.34982>:
        if (__result == 0) goto <D.34984>; else goto <D.34985>;
        <D.34984>:
        D.34986 = &MEM[(void *)"MonoProperty" + 2B];
        D.34987 = *D.34986;
        D.34988 = (int) D.34987;
        D.34989 = __s2 + 2;
        D.34990 = *D.34989;
        D.34991 = (int) D.34990;
        __result = D.34988 - D.34991;
        if (__s2_len > 2) goto <D.34992>; else goto <D.34993>;
        <D.34992>:
        if (__result == 0) goto <D.34994>; else goto <D.34995>;
        <D.34994>:
        D.34996 = &MEM[(void *)"MonoProperty" + 3B];
        D.34997 = *D.34996;
        D.34998 = (int) D.34997;
        D.34999 = __s2 + 3;
        D.35000 = *D.34999;
        D.35001 = (int) D.35000;
        __result = D.34998 - D.35001;
        <D.34995>:
        <D.34993>:
        <D.34985>:
        <D.34983>:
        <D.34975>:
        <D.34973>:
      }
      D.22261 = __result;
    }
    iftmp.366 = -D.22261;
    goto <D.35002>;
    <D.34966>:
    D.34547 = klass->name;
    iftmp.366 = __builtin_strcmp (D.34547, "MonoProperty");
    <D.35002>:
    D.22262 = iftmp.366;
  }
  if (D.22262 == 0) goto <D.35003>; else goto <D.35004>;
  <D.35003>:
  {
    struct MonoReflectionProperty * p;

    p = obj;
    D.35005 = p->property;
    token = mono_class_get_property_token (D.35005);
  }
  goto <D.35006>;
  <D.35004>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35010 = "MonoEvent";
      D.35011 = MEM[(const unsigned char *)D.35010];
      D.35012 = (int) D.35011;
      D.35013 = *__s2;
      D.35014 = (int) D.35013;
      __result = D.35012 - D.35014;
      {
        if (__s2_len != 0) goto <D.35015>; else goto <D.35016>;
        <D.35015>:
        if (__result == 0) goto <D.35017>; else goto <D.35018>;
        <D.35017>:
        D.35019 = &MEM[(void *)"MonoEvent" + 1B];
        D.35020 = *D.35019;
        D.35021 = (int) D.35020;
        D.35022 = __s2 + 1;
        D.35023 = *D.35022;
        D.35024 = (int) D.35023;
        __result = D.35021 - D.35024;
        if (__s2_len > 1) goto <D.35025>; else goto <D.35026>;
        <D.35025>:
        if (__result == 0) goto <D.35027>; else goto <D.35028>;
        <D.35027>:
        D.35029 = &MEM[(void *)"MonoEvent" + 2B];
        D.35030 = *D.35029;
        D.35031 = (int) D.35030;
        D.35032 = __s2 + 2;
        D.35033 = *D.35032;
        D.35034 = (int) D.35033;
        __result = D.35031 - D.35034;
        if (__s2_len > 2) goto <D.35035>; else goto <D.35036>;
        <D.35035>:
        if (__result == 0) goto <D.35037>; else goto <D.35038>;
        <D.35037>:
        D.35039 = &MEM[(void *)"MonoEvent" + 3B];
        D.35040 = *D.35039;
        D.35041 = (int) D.35040;
        D.35042 = __s2 + 3;
        D.35043 = *D.35042;
        D.35044 = (int) D.35043;
        __result = D.35041 - D.35044;
        <D.35038>:
        <D.35036>:
        <D.35028>:
        <D.35026>:
        <D.35018>:
        <D.35016>:
      }
      D.22271 = __result;
    }
    iftmp.367 = -D.22271;
    goto <D.35045>;
    <D.35009>:
    D.34547 = klass->name;
    iftmp.367 = __builtin_strcmp (D.34547, "MonoEvent");
    <D.35045>:
    D.22272 = iftmp.367;
  }
  if (D.22272 == 0) goto <D.35046>; else goto <D.35047>;
  <D.35046>:
  {
    struct MonoReflectionMonoEvent * p;

    p = obj;
    D.35048 = p->event;
    token = mono_class_get_event_token (D.35048);
  }
  goto <D.35049>;
  <D.35047>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35056 = "ParameterInfo";
      D.35057 = MEM[(const unsigned char *)D.35056];
      D.35058 = (int) D.35057;
      D.35059 = *__s2;
      D.35060 = (int) D.35059;
      __result = D.35058 - D.35060;
      {
        if (__s2_len != 0) goto <D.35061>; else goto <D.35062>;
        <D.35061>:
        if (__result == 0) goto <D.35063>; else goto <D.35064>;
        <D.35063>:
        D.35065 = &MEM[(void *)"ParameterInfo" + 1B];
        D.35066 = *D.35065;
        D.35067 = (int) D.35066;
        D.35068 = __s2 + 1;
        D.35069 = *D.35068;
        D.35070 = (int) D.35069;
        __result = D.35067 - D.35070;
        if (__s2_len > 1) goto <D.35071>; else goto <D.35072>;
        <D.35071>:
        if (__result == 0) goto <D.35073>; else goto <D.35074>;
        <D.35073>:
        D.35075 = &MEM[(void *)"ParameterInfo" + 2B];
        D.35076 = *D.35075;
        D.35077 = (int) D.35076;
        D.35078 = __s2 + 2;
        D.35079 = *D.35078;
        D.35080 = (int) D.35079;
        __result = D.35077 - D.35080;
        if (__s2_len > 2) goto <D.35081>; else goto <D.35082>;
        <D.35081>:
        if (__result == 0) goto <D.35083>; else goto <D.35084>;
        <D.35083>:
        D.35085 = &MEM[(void *)"ParameterInfo" + 3B];
        D.35086 = *D.35085;
        D.35087 = (int) D.35086;
        D.35088 = __s2 + 3;
        D.35089 = *D.35088;
        D.35090 = (int) D.35089;
        __result = D.35087 - D.35090;
        <D.35084>:
        <D.35082>:
        <D.35074>:
        <D.35072>:
        <D.35064>:
        <D.35062>:
      }
      D.22281 = __result;
    }
    iftmp.368 = -D.22281;
    goto <D.35091>;
    <D.35055>:
    D.34547 = klass->name;
    iftmp.368 = __builtin_strcmp (D.34547, "ParameterInfo");
    <D.35091>:
    D.22282 = iftmp.368;
  }
  if (D.22282 == 0) goto <D.35050>; else goto <D.35092>;
  <D.35092>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35096 = "MonoParameterInfo";
      D.35097 = MEM[(const unsigned char *)D.35096];
      D.35098 = (int) D.35097;
      D.35099 = *__s2;
      D.35100 = (int) D.35099;
      __result = D.35098 - D.35100;
      {
        if (__s2_len != 0) goto <D.35101>; else goto <D.35102>;
        <D.35101>:
        if (__result == 0) goto <D.35103>; else goto <D.35104>;
        <D.35103>:
        D.35105 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.35106 = *D.35105;
        D.35107 = (int) D.35106;
        D.35108 = __s2 + 1;
        D.35109 = *D.35108;
        D.35110 = (int) D.35109;
        __result = D.35107 - D.35110;
        if (__s2_len > 1) goto <D.35111>; else goto <D.35112>;
        <D.35111>:
        if (__result == 0) goto <D.35113>; else goto <D.35114>;
        <D.35113>:
        D.35115 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.35116 = *D.35115;
        D.35117 = (int) D.35116;
        D.35118 = __s2 + 2;
        D.35119 = *D.35118;
        D.35120 = (int) D.35119;
        __result = D.35117 - D.35120;
        if (__s2_len > 2) goto <D.35121>; else goto <D.35122>;
        <D.35121>:
        if (__result == 0) goto <D.35123>; else goto <D.35124>;
        <D.35123>:
        D.35125 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.35126 = *D.35125;
        D.35127 = (int) D.35126;
        D.35128 = __s2 + 3;
        D.35129 = *D.35128;
        D.35130 = (int) D.35129;
        __result = D.35127 - D.35130;
        <D.35124>:
        <D.35122>:
        <D.35114>:
        <D.35112>:
        <D.35104>:
        <D.35102>:
      }
      D.22290 = __result;
    }
    iftmp.369 = -D.22290;
    goto <D.35131>;
    <D.35095>:
    D.34547 = klass->name;
    iftmp.369 = __builtin_strcmp (D.34547, "MonoParameterInfo");
    <D.35131>:
    D.22291 = iftmp.369;
  }
  if (D.22291 == 0) goto <D.35050>; else goto <D.35051>;
  <D.35050>:
  {
    struct MonoReflectionParameter * p;
    struct MonoClass * member_class;

    p = obj;
    D.35132 = p->MemberImpl;
    D.35133 = D.35132->vtable;
    member_class = D.35133->klass;
    D.35134 = mono_class_is_reflection_method_or_constructor (member_class);
    D.35135 = D.35134 == 0;
    D.35136 = (long int) D.35135;
    D.35137 = __builtin_expect (D.35136, 0);
    if (D.35137 != 0) goto <D.35138>; else goto <D.35139>;
    <D.35138>:
    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.35139>:
    D.35132 = p->MemberImpl;
    D.35140 = MEM[(struct MonoReflectionMethod *)D.35132].method;
    D.35141 = p->PositionImpl;
    token = mono_method_get_param_token (D.35140, D.35141);
  }
  goto <D.35052>;
  <D.35051>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35148 = "Module";
      D.35149 = MEM[(const unsigned char *)D.35148];
      D.35150 = (int) D.35149;
      D.35151 = *__s2;
      D.35152 = (int) D.35151;
      __result = D.35150 - D.35152;
      {
        if (__s2_len != 0) goto <D.35153>; else goto <D.35154>;
        <D.35153>:
        if (__result == 0) goto <D.35155>; else goto <D.35156>;
        <D.35155>:
        D.35157 = &MEM[(void *)"Module" + 1B];
        D.35158 = *D.35157;
        D.35159 = (int) D.35158;
        D.35160 = __s2 + 1;
        D.35161 = *D.35160;
        D.35162 = (int) D.35161;
        __result = D.35159 - D.35162;
        if (__s2_len > 1) goto <D.35163>; else goto <D.35164>;
        <D.35163>:
        if (__result == 0) goto <D.35165>; else goto <D.35166>;
        <D.35165>:
        D.35167 = &MEM[(void *)"Module" + 2B];
        D.35168 = *D.35167;
        D.35169 = (int) D.35168;
        D.35170 = __s2 + 2;
        D.35171 = *D.35170;
        D.35172 = (int) D.35171;
        __result = D.35169 - D.35172;
        if (__s2_len > 2) goto <D.35173>; else goto <D.35174>;
        <D.35173>:
        if (__result == 0) goto <D.35175>; else goto <D.35176>;
        <D.35175>:
        D.35177 = &MEM[(void *)"Module" + 3B];
        D.35178 = *D.35177;
        D.35179 = (int) D.35178;
        D.35180 = __s2 + 3;
        D.35181 = *D.35180;
        D.35182 = (int) D.35181;
        __result = D.35179 - D.35182;
        <D.35176>:
        <D.35174>:
        <D.35166>:
        <D.35164>:
        <D.35156>:
        <D.35154>:
      }
      D.22301 = __result;
    }
    iftmp.370 = -D.22301;
    goto <D.35183>;
    <D.35147>:
    D.34547 = klass->name;
    iftmp.370 = __builtin_strcmp (D.34547, "Module");
    <D.35183>:
    D.22302 = iftmp.370;
  }
  if (D.22302 == 0) goto <D.35142>; else goto <D.35184>;
  <D.35184>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35188 = "MonoModule";
      D.35189 = MEM[(const unsigned char *)D.35188];
      D.35190 = (int) D.35189;
      D.35191 = *__s2;
      D.35192 = (int) D.35191;
      __result = D.35190 - D.35192;
      {
        if (__s2_len != 0) goto <D.35193>; else goto <D.35194>;
        <D.35193>:
        if (__result == 0) goto <D.35195>; else goto <D.35196>;
        <D.35195>:
        D.35197 = &MEM[(void *)"MonoModule" + 1B];
        D.35198 = *D.35197;
        D.35199 = (int) D.35198;
        D.35200 = __s2 + 1;
        D.35201 = *D.35200;
        D.35202 = (int) D.35201;
        __result = D.35199 - D.35202;
        if (__s2_len > 1) goto <D.35203>; else goto <D.35204>;
        <D.35203>:
        if (__result == 0) goto <D.35205>; else goto <D.35206>;
        <D.35205>:
        D.35207 = &MEM[(void *)"MonoModule" + 2B];
        D.35208 = *D.35207;
        D.35209 = (int) D.35208;
        D.35210 = __s2 + 2;
        D.35211 = *D.35210;
        D.35212 = (int) D.35211;
        __result = D.35209 - D.35212;
        if (__s2_len > 2) goto <D.35213>; else goto <D.35214>;
        <D.35213>:
        if (__result == 0) goto <D.35215>; else goto <D.35216>;
        <D.35215>:
        D.35217 = &MEM[(void *)"MonoModule" + 3B];
        D.35218 = *D.35217;
        D.35219 = (int) D.35218;
        D.35220 = __s2 + 3;
        D.35221 = *D.35220;
        D.35222 = (int) D.35221;
        __result = D.35219 - D.35222;
        <D.35216>:
        <D.35214>:
        <D.35206>:
        <D.35204>:
        <D.35196>:
        <D.35194>:
      }
      D.22310 = __result;
    }
    iftmp.371 = -D.22310;
    goto <D.35223>;
    <D.35187>:
    D.34547 = klass->name;
    iftmp.371 = __builtin_strcmp (D.34547, "MonoModule");
    <D.35223>:
    D.22311 = iftmp.371;
  }
  if (D.22311 == 0) goto <D.35142>; else goto <D.35143>;
  <D.35142>:
  {
    struct MonoReflectionModule * m;

    m = obj;
    token = m->token;
  }
  goto <D.35144>;
  <D.35143>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35230 = "Assembly";
      D.35231 = MEM[(const unsigned char *)D.35230];
      D.35232 = (int) D.35231;
      D.35233 = *__s2;
      D.35234 = (int) D.35233;
      __result = D.35232 - D.35234;
      {
        if (__s2_len != 0) goto <D.35235>; else goto <D.35236>;
        <D.35235>:
        if (__result == 0) goto <D.35237>; else goto <D.35238>;
        <D.35237>:
        D.35239 = &MEM[(void *)"Assembly" + 1B];
        D.35240 = *D.35239;
        D.35241 = (int) D.35240;
        D.35242 = __s2 + 1;
        D.35243 = *D.35242;
        D.35244 = (int) D.35243;
        __result = D.35241 - D.35244;
        if (__s2_len > 1) goto <D.35245>; else goto <D.35246>;
        <D.35245>:
        if (__result == 0) goto <D.35247>; else goto <D.35248>;
        <D.35247>:
        D.35249 = &MEM[(void *)"Assembly" + 2B];
        D.35250 = *D.35249;
        D.35251 = (int) D.35250;
        D.35252 = __s2 + 2;
        D.35253 = *D.35252;
        D.35254 = (int) D.35253;
        __result = D.35251 - D.35254;
        if (__s2_len > 2) goto <D.35255>; else goto <D.35256>;
        <D.35255>:
        if (__result == 0) goto <D.35257>; else goto <D.35258>;
        <D.35257>:
        D.35259 = &MEM[(void *)"Assembly" + 3B];
        D.35260 = *D.35259;
        D.35261 = (int) D.35260;
        D.35262 = __s2 + 3;
        D.35263 = *D.35262;
        D.35264 = (int) D.35263;
        __result = D.35261 - D.35264;
        <D.35258>:
        <D.35256>:
        <D.35248>:
        <D.35246>:
        <D.35238>:
        <D.35236>:
      }
      D.22320 = __result;
    }
    iftmp.372 = -D.22320;
    goto <D.35265>;
    <D.35229>:
    D.34547 = klass->name;
    iftmp.372 = __builtin_strcmp (D.34547, "Assembly");
    <D.35265>:
    D.22321 = iftmp.372;
  }
  if (D.22321 == 0) goto <D.35224>; else goto <D.35266>;
  <D.35266>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35270 = "MonoAssembly";
      D.35271 = MEM[(const unsigned char *)D.35270];
      D.35272 = (int) D.35271;
      D.35273 = *__s2;
      D.35274 = (int) D.35273;
      __result = D.35272 - D.35274;
      {
        if (__s2_len != 0) goto <D.35275>; else goto <D.35276>;
        <D.35275>:
        if (__result == 0) goto <D.35277>; else goto <D.35278>;
        <D.35277>:
        D.35279 = &MEM[(void *)"MonoAssembly" + 1B];
        D.35280 = *D.35279;
        D.35281 = (int) D.35280;
        D.35282 = __s2 + 1;
        D.35283 = *D.35282;
        D.35284 = (int) D.35283;
        __result = D.35281 - D.35284;
        if (__s2_len > 1) goto <D.35285>; else goto <D.35286>;
        <D.35285>:
        if (__result == 0) goto <D.35287>; else goto <D.35288>;
        <D.35287>:
        D.35289 = &MEM[(void *)"MonoAssembly" + 2B];
        D.35290 = *D.35289;
        D.35291 = (int) D.35290;
        D.35292 = __s2 + 2;
        D.35293 = *D.35292;
        D.35294 = (int) D.35293;
        __result = D.35291 - D.35294;
        if (__s2_len > 2) goto <D.35295>; else goto <D.35296>;
        <D.35295>:
        if (__result == 0) goto <D.35297>; else goto <D.35298>;
        <D.35297>:
        D.35299 = &MEM[(void *)"MonoAssembly" + 3B];
        D.35300 = *D.35299;
        D.35301 = (int) D.35300;
        D.35302 = __s2 + 3;
        D.35303 = *D.35302;
        D.35304 = (int) D.35303;
        __result = D.35301 - D.35304;
        <D.35298>:
        <D.35296>:
        <D.35288>:
        <D.35286>:
        <D.35278>:
        <D.35276>:
      }
      D.22329 = __result;
    }
    iftmp.373 = -D.22329;
    goto <D.35305>;
    <D.35269>:
    D.34547 = klass->name;
    iftmp.373 = __builtin_strcmp (D.34547, "MonoAssembly");
    <D.35305>:
    D.22330 = iftmp.373;
  }
  if (D.22330 == 0) goto <D.35224>; else goto <D.35225>;
  <D.35224>:
  token = 536870913;
  goto <D.35226>;
  <D.35225>:
  {
    gchar * msg;
    struct MonoException * ex;

    D.35306 = klass->name_space;
    D.34547 = klass->name;
    msg = monoeg_g_strdup_printf ("MetadataToken is not supported for type \'%s.%s\'", D.35306, D.34547);
    ex = mono_get_exception_not_implemented (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.35226>:
  <D.35144>:
  <D.35052>:
  <D.35049>:
  <D.35006>:
  <D.34963>:
  <D.34730>:
  <D.34727>:
  <D.34681>:
  <D.34638>:
  <D.34594>:
  <D.34551>:
  D.34895 = token;
  return D.34895;
}


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.35308;
  struct MonoClass * D.35311;
  const char * p.374;
  short unsigned int D.35316;
  struct MonoClass * D.35317;
  struct MonoMethodSignature * D.35318;
  short unsigned int D.35319;
  long unsigned int D.35320;
  const char * p.375;
  struct MonoMethodSignature * D.35322;
  struct MonoType * D.35323;
  struct MonoObject * iftmp.376;
  struct MonoMethodSignature * D.35325;
  struct MonoType * D.35326;
  int D.35327;
  struct MonoMethodSignature * D.35330;
  struct MonoType * D.35331;
  struct MonoClass * D.35332;
  long unsigned int D.35334;
  struct MonoMethodSignature * D.35335;
  struct MonoType * D.35336;
  int D.35337;
  struct MonoMethodSignature * D.35340;
  short unsigned int D.35341;
  unsigned int D.35342;
  const char * named.377;
  short unsigned int D.35344;
  struct MonoClass * D.35345;
  long unsigned int D.35346;
  const char * named.378;
  long unsigned int D.35348;
  long unsigned int D.35349;
  const char * named.379;
  const char * named.380;
  const char * named.381;
  const char * named.382;
  const char * named.383;
  const char * named.384;
  unsigned int D.35360;
  sizetype D.35361;
  const guchar * D.35362;
  sizetype D.35363;
  const guchar * D.35364;
  long unsigned int D.35366;
  long unsigned int D.35367;
  long unsigned int named.385;
  int D.35370;
  long unsigned int D.35371;
  long unsigned int D.35372;
  char * D.35373;
  const char * named.386;
  unsigned int D.35375;
  sizetype D.35376;
  const guchar * D.35377;
  long unsigned int D.35379;
  long unsigned int D.35380;
  int D.35382;
  long unsigned int D.35383;
  long unsigned int D.35384;
  char * D.35385;
  const char * named.387;
  long unsigned int D.35389;
  long unsigned int D.35390;
  struct CattrNamedArg * D.35391;
  struct MonoType * D.35392;
  struct MonoObject * iftmp.388;
  int D.35394;
  struct MonoClass * D.35397;
  long unsigned int D.35399;
  int D.35400;
  struct MonoType * iftmp.389;
  struct MonoMethod * D.35407;
  struct MonoMethodSignature * D.35410;
  struct MonoMethod * D.35412;
  struct MonoMethodSignature * D.35413;
  struct MonoMethodSignature * D.35414;
  short unsigned int D.35415;
  int D.35416;
  int D.35417;
  struct MonoObject * iftmp.390;
  int D.35419;
  struct MonoClass * D.35422;
  int D.35424;
  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.35308 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.35308 == 0) goto <D.35309>; else goto <D.35310>;
      <D.35309>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      return;
      <D.35310>:
      D.35311 = method->klass;
      mono_class_init (D.35311);
      domain = mono_domain_get ();
      if (len <= 1) goto <D.35312>; else goto <D.35314>;
      <D.35314>:
      p.374 = p;
      D.35316 = MEM[(const guint16 *)p.374];
      if (D.35316 != 1) goto <D.35312>; else goto <D.35313>;
      <D.35312>:
      return;
      <D.35313>:
      D.35317 = mono_get_object_class ();
      D.35318 = mono_method_signature (method);
      D.35319 = D.35318->param_count;
      D.35320 = (long unsigned int) D.35319;
      typedargs = mono_array_new (domain, D.35317, D.35320);
      p.374 = p;
      p.375 = p.374 + 2;
      p = p.375;
      i = 0;
      goto <D.22593>;
      <D.22592>:
      {
        struct MonoObject * obj;
        void * val;

        D.35322 = mono_method_signature (method);
        D.35323 = D.35322->params[i];
        p.374 = p;
        val = load_cattr_value (image, D.35323, p.374, &p);
        D.35325 = mono_method_signature (method);
        D.35326 = D.35325->params[i];
        D.35327 = type_is_reference (D.35326);
        if (D.35327 == 0) goto <D.35328>; else goto <D.35329>;
        <D.35328>:
        D.35330 = mono_method_signature (method);
        D.35331 = D.35330->params[i];
        D.35332 = mono_class_from_mono_type (D.35331);
        iftmp.376 = mono_value_box (domain, D.35332, val);
        goto <D.35333>;
        <D.35329>:
        iftmp.376 = val;
        <D.35333>:
        obj = iftmp.376;
        {
          void * * __p;

          D.35334 = (long unsigned int) i;
          __p = mono_array_addr_with_size (typedargs, 8, D.35334);
          mono_gc_wbarrier_set_arrayref (typedargs, __p, obj);
        }
        D.35335 = mono_method_signature (method);
        D.35336 = D.35335->params[i];
        D.35337 = type_is_reference (D.35336);
        if (D.35337 == 0) goto <D.35338>; else goto <D.35339>;
        <D.35338>:
        monoeg_g_free (val);
        <D.35339>:
      }
      i = i + 1;
      <D.22593>:
      D.35340 = mono_method_signature (method);
      D.35341 = D.35340->param_count;
      D.35342 = (unsigned int) D.35341;
      if (D.35342 > i) goto <D.22592>; else goto <D.22594>;
      <D.22594>:
      p.374 = p;
      named = p.374;
      named.377 = named;
      D.35344 = MEM[(const guint16 *)named.377];
      num_named = (guint32) D.35344;
      D.35345 = mono_get_object_class ();
      D.35346 = (long unsigned int) num_named;
      namedargs = mono_array_new (domain, D.35345, D.35346);
      named.377 = named;
      named.378 = named.377 + 2;
      named = named.378;
      attrklass = method->klass;
      D.35348 = (long unsigned int) num_named;
      D.35349 = D.35348 * 24;
      arginfo = monoeg_malloc0 (D.35349);
      *named_arg_info = arginfo;
      j = 0;
      goto <D.22612>;
      <D.22611>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.377 = named;
        named.379 = named.377;
        named.380 = named.379 + 1;
        named = named.380;
        named_type = *named.379;
        named.377 = named;
        named.381 = named.377;
        named.382 = named.381 + 1;
        named = named.382;
        data_type = *named.381;
        if (data_type == 29) goto <D.35354>; else goto <D.35355>;
        <D.35354>:
        named.377 = named;
        named.383 = named.377;
        named.384 = named.383 + 1;
        named = named.384;
        data_type = *named.383;
        <D.35355>:
        if (data_type == 85) goto <D.35358>; else goto <D.35359>;
        <D.35358>:
        {
          gint type_len;
          char * type_name;

          named.377 = named;
          D.35360 = mono_metadata_decode_blob_size (named.377, &named);
          type_len = (gint) D.35360;
          named.377 = named;
          D.35361 = (sizetype) type_len;
          D.35362 = named.377 + D.35361;
          D.35363 = (sizetype) len;
          D.35364 = data + D.35363;
          if (D.35362 > D.35364) goto fail; else goto <D.35365>;
          <D.35365>:
          D.35366 = (long unsigned int) type_len;
          D.35367 = ~D.35366;
          named.377 = named;
          named.385 = (long unsigned int) named.377;
          if (D.35367 < named.385) goto fail; else goto <D.35369>;
          <D.35369>:
          D.35370 = type_len + 1;
          D.35371 = (long unsigned int) D.35370;
          type_name = monoeg_malloc (D.35371);
          named.377 = named;
          D.35372 = (long unsigned int) type_len;
          memcpy (type_name, named.377, D.35372);
          D.35361 = (sizetype) type_len;
          D.35373 = type_name + D.35361;
          *D.35373 = 0;
          named.377 = named;
          D.35361 = (sizetype) type_len;
          named.386 = named.377 + D.35361;
          named = named.386;
          monoeg_g_free (type_name);
        }
        <D.35359>:
        named.377 = named;
        D.35375 = mono_metadata_decode_blob_size (named.377, &named);
        name_len = (gint) D.35375;
        named.377 = named;
        D.35376 = (sizetype) name_len;
        D.35377 = named.377 + D.35376;
        D.35363 = (sizetype) len;
        D.35364 = data + D.35363;
        if (D.35377 > D.35364) goto fail; else goto <D.35378>;
        <D.35378>:
        D.35379 = (long unsigned int) name_len;
        D.35380 = ~D.35379;
        named.377 = named;
        named.385 = (long unsigned int) named.377;
        if (D.35380 < named.385) goto fail; else goto <D.35381>;
        <D.35381>:
        D.35382 = name_len + 1;
        D.35383 = (long unsigned int) D.35382;
        name = monoeg_malloc (D.35383);
        named.377 = named;
        D.35384 = (long unsigned int) name_len;
        memcpy (name, named.377, D.35384);
        D.35376 = (sizetype) name_len;
        D.35385 = name + D.35376;
        *D.35385 = 0;
        named.377 = named;
        D.35376 = (sizetype) name_len;
        named.387 = named.377 + D.35376;
        named = named.387;
        if (named_type == 83) goto <D.35387>; else goto <D.35388>;
        <D.35387>:
        {
          struct MonoObject * obj;
          struct MonoClassField * field;
          void * val;

          field = mono_class_get_field_from_name (attrklass, name);
          D.35389 = (long unsigned int) j;
          D.35390 = D.35389 * 24;
          D.35391 = arginfo + D.35390;
          D.35392 = field->type;
          D.35391->type = D.35392;
          D.35389 = (long unsigned int) j;
          D.35390 = D.35389 * 24;
          D.35391 = arginfo + D.35390;
          D.35391->field = field;
          D.35392 = field->type;
          named.377 = named;
          val = load_cattr_value (image, D.35392, named.377, &named);
          D.35392 = field->type;
          D.35394 = type_is_reference (D.35392);
          if (D.35394 == 0) goto <D.35395>; else goto <D.35396>;
          <D.35395>:
          D.35392 = field->type;
          D.35397 = mono_class_from_mono_type (D.35392);
          iftmp.388 = mono_value_box (domain, D.35397, val);
          goto <D.35398>;
          <D.35396>:
          iftmp.388 = val;
          <D.35398>:
          obj = iftmp.388;
          {
            void * * __p;

            D.35399 = (long unsigned int) j;
            __p = mono_array_addr_with_size (namedargs, 8, D.35399);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.35392 = field->type;
          D.35400 = type_is_reference (D.35392);
          if (D.35400 == 0) goto <D.35401>; else goto <D.35402>;
          <D.35401>:
          monoeg_g_free (val);
          <D.35402>:
        }
        goto <D.35403>;
        <D.35388>:
        if (named_type == 84) goto <D.35404>; else goto <D.35405>;
        <D.35404>:
        {
          struct MonoObject * obj;
          struct MonoType * prop_type;
          struct MonoProperty * prop;
          void * val;

          prop = mono_class_get_property_from_name (attrklass, name);
          D.35407 = prop->get;
          if (D.35407 != 0B) goto <D.35408>; else goto <D.35409>;
          <D.35408>:
          D.35407 = prop->get;
          D.35410 = mono_method_signature (D.35407);
          iftmp.389 = D.35410->ret;
          goto <D.35411>;
          <D.35409>:
          D.35412 = prop->set;
          D.35413 = mono_method_signature (D.35412);
          D.35412 = prop->set;
          D.35414 = mono_method_signature (D.35412);
          D.35415 = D.35414->param_count;
          D.35416 = (int) D.35415;
          D.35417 = D.35416 + -1;
          iftmp.389 = D.35413->params[D.35417];
          <D.35411>:
          prop_type = iftmp.389;
          D.35389 = (long unsigned int) j;
          D.35390 = D.35389 * 24;
          D.35391 = arginfo + D.35390;
          D.35391->type = prop_type;
          D.35389 = (long unsigned int) j;
          D.35390 = D.35389 * 24;
          D.35391 = arginfo + D.35390;
          D.35391->prop = prop;
          named.377 = named;
          val = load_cattr_value (image, prop_type, named.377, &named);
          D.35419 = type_is_reference (prop_type);
          if (D.35419 == 0) goto <D.35420>; else goto <D.35421>;
          <D.35420>:
          D.35422 = mono_class_from_mono_type (prop_type);
          iftmp.390 = mono_value_box (domain, D.35422, val);
          goto <D.35423>;
          <D.35421>:
          iftmp.390 = val;
          <D.35423>:
          obj = iftmp.390;
          {
            void * * __p;

            D.35399 = (long unsigned int) j;
            __p = mono_array_addr_with_size (namedargs, 8, D.35399);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.35424 = type_is_reference (prop_type);
          if (D.35424 == 0) goto <D.35425>; else goto <D.35426>;
          <D.35425>:
          monoeg_g_free (val);
          <D.35426>:
        }
        <D.35405>:
        <D.35403>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.22612>:
      if (j < num_named) goto <D.22611>; else goto <D.22613>;
      <D.22613>:
      *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.35430;
  const char * p.391;
  char D.35432;
  const char * p.397;
  void * D.35434;
  short unsigned int D.35435;
  const char * p.402;
  unsigned int D.35437;
  const char * p.399;
  long unsigned int D.35439;
  const char * p.405;
  double D.35441;
  struct MonoClass * D.35442;
  long unsigned int D.35443;
  long unsigned int D.35444;
  struct MonoType * D.35447;
  unsigned char D.35448;
  struct MonoImage * D.35449;
  int D.35450;
  int D.22382;
  int iftmp.392;
  int D.22381;
  const char[7] * D.35456;
  unsigned char D.35457;
  int D.35458;
  unsigned char D.35459;
  int D.35460;
  const unsigned char * D.35465;
  unsigned char D.35466;
  int D.35467;
  const unsigned char * D.35468;
  unsigned char D.35469;
  int D.35470;
  const unsigned char * D.35475;
  unsigned char D.35476;
  int D.35477;
  const unsigned char * D.35478;
  unsigned char D.35479;
  int D.35480;
  const unsigned char * D.35485;
  unsigned char D.35486;
  int D.35487;
  const unsigned char * D.35488;
  unsigned char D.35489;
  int D.35490;
  const char * D.35492;
  int D.22391;
  int iftmp.393;
  int D.22390;
  const char[9] * D.35498;
  unsigned char D.35499;
  int D.35500;
  unsigned char D.35501;
  int D.35502;
  const unsigned char * D.35507;
  unsigned char D.35508;
  int D.35509;
  const unsigned char * D.35510;
  unsigned char D.35511;
  int D.35512;
  const unsigned char * D.35517;
  unsigned char D.35518;
  int D.35519;
  const unsigned char * D.35520;
  unsigned char D.35521;
  int D.35522;
  const unsigned char * D.35527;
  unsigned char D.35528;
  int D.35529;
  const unsigned char * D.35530;
  unsigned char D.35531;
  int D.35532;
  const char * D.35534;
  const char * D.35537;
  unsigned int D.35540;
  sizetype D.35541;
  const char * p.398;
  struct MonoDomain * D.35543;
  unsigned int slen.394;
  unsigned int D.35547;
  int D.35548;
  unsigned int D.35549;
  char * D.35550;
  struct MonoDomain * D.35555;
  const char * p.395;
  const char * p.396;
  unsigned char D.35571;
  unsigned int D.35574;
  char * D.35575;
  char D.35579;
  int D.35583;
  struct MonoType * D.35584;
  struct MonoDomain * D.35585;
  long unsigned int D.35586;
  long unsigned int D.35587;
  _Bool D.35588;
  long int D.35589;
  long int D.35590;
  void * D.35593;
  int D.35594;
  long unsigned int D.35595;
  struct MonoDomain * D.35598;
  long unsigned int D.35599;
  unsigned char D.35600;
  long unsigned int D.35603;
  long unsigned int D.35604;
  struct MonoType * D.35607;
  unsigned char D.35608;
  const char * p.400;
  const char * p.401;
  long unsigned int D.35611;
  double val.403;
  double val.404;
  struct MonoType * D.35614;
  int slen;
  int type;
  struct MonoClass * tklass;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  D.35430 = t->type;
  type = (int) D.35430;
  tklass = t->data.klass;
  handle_enum:
  switch (type) <default: <D.22465>, case 2: <D.22354>, case 3: <D.22356>, case 4: <D.22353>, case 5: <D.22352>, case 6: <D.22358>, case 7: <D.22357>, case 8: <D.22362>, case 9: <D.22361>, case 10: <D.22367>, case 11: <D.22366>, case 12: <D.22360>, case 13: <D.22369>, case 14: <D.22394>, case 17: <D.22372>, case 18: <D.22395>, case 24: <D.22365>, case 25: <D.22364>, case 28: <D.22399>, case 29: <D.22411>>
  <D.22352>:
  <D.22353>:
  <D.22354>:
  {
    MonoBoolean * bval;

    bval = monoeg_malloc (1);
    p.391 = p;
    D.35432 = *p.391;
    *bval = D.35432;
    p.391 = p;
    p.397 = p.391 + 1;
    *end = p.397;
    D.35434 = bval;
    return D.35434;
  }
  <D.22356>:
  <D.22357>:
  <D.22358>:
  {
    guint16 * val;

    val = monoeg_malloc (2);
    p.391 = p;
    D.35435 = MEM[(const guint16 *)p.391];
    *val = D.35435;
    p.391 = p;
    p.402 = p.391 + 2;
    *end = p.402;
    D.35434 = val;
    return D.35434;
  }
  <D.22360>:
  <D.22361>:
  <D.22362>:
  {
    guint32 * val;

    val = monoeg_malloc (4);
    p.391 = p;
    D.35437 = MEM[(const guint32 *)p.391];
    *val = D.35437;
    p.391 = p;
    p.399 = p.391 + 4;
    *end = p.399;
    D.35434 = val;
    return D.35434;
  }
  <D.22364>:
  <D.22365>:
  <D.22366>:
  <D.22367>:
  {
    guint64 * val;

    val = monoeg_malloc (8);
    p.391 = p;
    D.35439 = MEM[(const guint64 *)p.391];
    *val = D.35439;
    p.391 = p;
    p.405 = p.391 + 8;
    *end = p.405;
    D.35434 = val;
    return D.35434;
  }
  <D.22369>:
  {
    double * val;

    val = monoeg_malloc (8);
    {
      union mono_rdouble mf;

      try
        {
          p.391 = p;
          D.35439 = MEM[(const guint64 *)p.391];
          mf.ival = D.35439;
          D.35441 = mf.fval;
          *val = D.35441;
        }
      finally
        {
          mf = {CLOBBER};
        }
    }
    p.391 = p;
    p.405 = p.391 + 8;
    *end = p.405;
    D.35434 = val;
    return D.35434;
  }
  <D.22372>:
  D.35442 = t->data.klass;
  D.35443 = BIT_FIELD_REF <*D.35442, 64, 256>;
  D.35444 = D.35443 & 16;
  if (D.35444 != 0) goto <D.35445>; else goto <D.35446>;
  <D.35445>:
  D.35442 = t->data.klass;
  D.35447 = mono_class_enum_basetype (D.35442);
  D.35448 = D.35447->type;
  type = (int) D.35448;
  goto handle_enum;
  <D.35446>:
  {
    struct MonoClass * k;

    k = t->data.klass;
    D.35449 = k->image;
    D.35450 = mono_is_corlib_image (D.35449);
    if (D.35450 != 0) goto <D.35451>; else goto <D.35452>;
    <D.35451>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name_space;
        D.35456 = "System";
        D.35457 = MEM[(const unsigned char *)D.35456];
        D.35458 = (int) D.35457;
        D.35459 = *__s2;
        D.35460 = (int) D.35459;
        __result = D.35458 - D.35460;
        {
          if (__s2_len != 0) goto <D.35461>; else goto <D.35462>;
          <D.35461>:
          if (__result == 0) goto <D.35463>; else goto <D.35464>;
          <D.35463>:
          D.35465 = &MEM[(void *)"System" + 1B];
          D.35466 = *D.35465;
          D.35467 = (int) D.35466;
          D.35468 = __s2 + 1;
          D.35469 = *D.35468;
          D.35470 = (int) D.35469;
          __result = D.35467 - D.35470;
          if (__s2_len > 1) goto <D.35471>; else goto <D.35472>;
          <D.35471>:
          if (__result == 0) goto <D.35473>; else goto <D.35474>;
          <D.35473>:
          D.35475 = &MEM[(void *)"System" + 2B];
          D.35476 = *D.35475;
          D.35477 = (int) D.35476;
          D.35478 = __s2 + 2;
          D.35479 = *D.35478;
          D.35480 = (int) D.35479;
          __result = D.35477 - D.35480;
          if (__s2_len > 2) goto <D.35481>; else goto <D.35482>;
          <D.35481>:
          if (__result == 0) goto <D.35483>; else goto <D.35484>;
          <D.35483>:
          D.35485 = &MEM[(void *)"System" + 3B];
          D.35486 = *D.35485;
          D.35487 = (int) D.35486;
          D.35488 = __s2 + 3;
          D.35489 = *D.35488;
          D.35490 = (int) D.35489;
          __result = D.35487 - D.35490;
          <D.35484>:
          <D.35482>:
          <D.35474>:
          <D.35472>:
          <D.35464>:
          <D.35462>:
        }
        D.22381 = __result;
      }
      iftmp.392 = -D.22381;
      goto <D.35491>;
      <D.35455>:
      D.35492 = k->name_space;
      iftmp.392 = __builtin_strcmp (D.35492, "System");
      <D.35491>:
      D.22382 = iftmp.392;
    }
    if (D.22382 == 0) goto <D.35493>; else goto <D.35494>;
    <D.35493>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name;
        D.35498 = "DateTime";
        D.35499 = MEM[(const unsigned char *)D.35498];
        D.35500 = (int) D.35499;
        D.35501 = *__s2;
        D.35502 = (int) D.35501;
        __result = D.35500 - D.35502;
        {
          if (__s2_len != 0) goto <D.35503>; else goto <D.35504>;
          <D.35503>:
          if (__result == 0) goto <D.35505>; else goto <D.35506>;
          <D.35505>:
          D.35507 = &MEM[(void *)"DateTime" + 1B];
          D.35508 = *D.35507;
          D.35509 = (int) D.35508;
          D.35510 = __s2 + 1;
          D.35511 = *D.35510;
          D.35512 = (int) D.35511;
          __result = D.35509 - D.35512;
          if (__s2_len > 1) goto <D.35513>; else goto <D.35514>;
          <D.35513>:
          if (__result == 0) goto <D.35515>; else goto <D.35516>;
          <D.35515>:
          D.35517 = &MEM[(void *)"DateTime" + 2B];
          D.35518 = *D.35517;
          D.35519 = (int) D.35518;
          D.35520 = __s2 + 2;
          D.35521 = *D.35520;
          D.35522 = (int) D.35521;
          __result = D.35519 - D.35522;
          if (__s2_len > 2) goto <D.35523>; else goto <D.35524>;
          <D.35523>:
          if (__result == 0) goto <D.35525>; else goto <D.35526>;
          <D.35525>:
          D.35527 = &MEM[(void *)"DateTime" + 3B];
          D.35528 = *D.35527;
          D.35529 = (int) D.35528;
          D.35530 = __s2 + 3;
          D.35531 = *D.35530;
          D.35532 = (int) D.35531;
          __result = D.35529 - D.35532;
          <D.35526>:
          <D.35524>:
          <D.35516>:
          <D.35514>:
          <D.35506>:
          <D.35504>:
        }
        D.22390 = __result;
      }
      iftmp.393 = -D.22390;
      goto <D.35533>;
      <D.35497>:
      D.35534 = k->name;
      iftmp.393 = __builtin_strcmp (D.35534, "DateTime");
      <D.35533>:
      D.22391 = iftmp.393;
    }
    if (D.22391 == 0) goto <D.35535>; else goto <D.35536>;
    <D.35535>:
    {
      guint64 * val;

      val = monoeg_malloc (8);
      p.391 = p;
      D.35439 = MEM[(const guint64 *)p.391];
      *val = D.35439;
      p.391 = p;
      p.405 = p.391 + 8;
      *end = p.405;
      D.35434 = val;
      return D.35434;
    }
    <D.35536>:
    <D.35494>:
    <D.35452>:
  }
  D.35442 = t->data.klass;
  D.35537 = D.35442->name;
  monoeg_g_log (0B, 4, "generic valutype %s not handled in custom attr value decoding", D.35537);
  <D.22393>:
  goto <D.22393>;
  <D.22394>:
  p.391 = p;
  D.35432 = *p.391;
  if (D.35432 == 255) goto <D.35538>; else goto <D.35539>;
  <D.35538>:
  p.391 = p;
  p.397 = p.391 + 1;
  *end = p.397;
  D.35434 = 0B;
  return D.35434;
  <D.35539>:
  p.391 = p;
  D.35540 = mono_metadata_decode_value (p.391, &p);
  slen = (int) D.35540;
  p.391 = p;
  D.35541 = (sizetype) slen;
  p.398 = p.391 + D.35541;
  *end = p.398;
  D.35543 = mono_domain_get ();
  p.391 = p;
  slen.394 = (unsigned int) slen;
  D.35434 = mono_string_new_len (D.35543, p.391, slen.394);
  return D.35434;
  <D.22395>:
  {
    char * n;
    struct MonoType * t;

    p.391 = p;
    D.35432 = *p.391;
    if (D.35432 == 255) goto <D.35545>; else goto <D.35546>;
    <D.35545>:
    p.391 = p;
    p.397 = p.391 + 1;
    *end = p.397;
    D.35434 = 0B;
    return D.35434;
    <D.35546>:
    handle_type:
    p.391 = p;
    D.35547 = mono_metadata_decode_value (p.391, &p);
    slen = (int) D.35547;
    p.391 = p;
    D.35548 = slen + 1;
    D.35549 = (unsigned int) D.35548;
    n = monoeg_g_memdup (p.391, D.35549);
    D.35541 = (sizetype) slen;
    D.35550 = n + D.35541;
    *D.35550 = 0;
    t = mono_reflection_type_from_name (n, image);
    if (t == 0B) goto <D.35551>; else goto <D.35552>;
    <D.35551>:
    monoeg_g_log (0B, 16, "Cannot load type \'%s\'", n);
    <D.35552>:
    monoeg_g_free (n);
    p.391 = p;
    D.35541 = (sizetype) slen;
    p.398 = p.391 + D.35541;
    *end = p.398;
    if (t != 0B) goto <D.35553>; else goto <D.35554>;
    <D.35553>:
    D.35555 = mono_domain_get ();
    D.35434 = mono_type_get_object (D.35555, t);
    return D.35434;
    <D.35554>:
    D.35434 = 0B;
    return D.35434;
  }
  <D.22399>:
  {
    char subt;
    struct MonoObject * obj;
    struct MonoClass * subc;
    void * val;

    p.391 = p;
    p.395 = p.391;
    p.396 = p.395 + 1;
    p = p.396;
    subt = *p.395;
    subc = 0B;
    if (subt == 80) goto handle_type; else goto <D.35558>;
    <D.35558>:
    if (subt == 14) goto <D.35559>; else goto <D.35560>;
    <D.35559>:
    type = 14;
    goto handle_enum;
    <D.35560>:
    if (subt == 29) goto <D.35561>; else goto <D.35562>;
    <D.35561>:
    {
      struct MonoType simple_type;
      int etype;

      try
        {
          simple_type = {};
          p.391 = p;
          D.35432 = *p.391;
          etype = (int) D.35432;
          p.391 = p;
          p.397 = p.391 + 1;
          p = p.397;
          type = 29;
          if (etype == 80) goto <D.35563>; else goto <D.35564>;
          <D.35563>:
          tklass = mono_defaults.systemtype_class;
          goto <D.35565>;
          <D.35564>:
          if (etype == 85) goto <D.35566>; else goto <D.35567>;
          <D.35566>:
          p.391 = p;
          tklass = load_cattr_enum_type (image, p.391, &p);
          goto <D.35568>;
          <D.35567>:
          if (etype == 81) goto <D.35569>; else goto <D.35570>;
          <D.35569>:
          etype = 28;
          <D.35570>:
          D.35571 = (unsigned char) etype;
          simple_type.type = D.35571;
          tklass = mono_class_from_mono_type (&simple_type);
          <D.35568>:
          <D.35565>:
          goto handle_enum;
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    <D.35562>:
    if (subt == 85) goto <D.35572>; else goto <D.35573>;
    <D.35572>:
    {
      char * n;
      struct MonoType * t;

      p.391 = p;
      D.35574 = mono_metadata_decode_value (p.391, &p);
      slen = (int) D.35574;
      p.391 = p;
      D.35548 = slen + 1;
      D.35549 = (unsigned int) D.35548;
      n = monoeg_g_memdup (p.391, D.35549);
      D.35541 = (sizetype) slen;
      D.35575 = n + D.35541;
      *D.35575 = 0;
      t = mono_reflection_type_from_name (n, image);
      if (t == 0B) goto <D.35576>; else goto <D.35577>;
      <D.35576>:
      monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
      <D.22408>:
      goto <D.22408>;
      <D.35577>:
      monoeg_g_free (n);
      p.391 = p;
      D.35541 = (sizetype) slen;
      p.398 = p.391 + D.35541;
      p = p.398;
      subc = mono_class_from_mono_type (t);
    }
    goto <D.35578>;
    <D.35573>:
    D.35579 = subt + 254;
    if (D.35579 <= 11) goto <D.35580>; else goto <D.35581>;
    <D.35580>:
    {
      struct MonoType simple_type;

      try
        {
          simple_type = {};
          simple_type.type = subt;
          subc = mono_class_from_mono_type (&simple_type);
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    goto <D.35582>;
    <D.35581>:
    D.35583 = (int) subt;
    monoeg_g_log (0B, 4, "Unknown type 0x%02x for object type encoding in custom attr", D.35583);
    <D.22410>:
    goto <D.22410>;
    <D.35582>:
    <D.35578>:
    D.35584 = &subc->byval_arg;
    p.391 = p;
    val = load_cattr_value (image, D.35584, p.391, end);
    D.35585 = mono_domain_get ();
    obj = mono_object_new (D.35585, subc);
    D.35586 = BIT_FIELD_REF <*subc, 64, 256>;
    D.35587 = D.35586 & 134217728;
    D.35588 = D.35587 != 0;
    D.35589 = (long int) D.35588;
    D.35590 = __builtin_expect (D.35589, 0);
    if (D.35590 != 0) goto <D.35591>; else goto <D.35592>;
    <D.35591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7953, "!subc->has_references");
    <D.35592>:
    D.35593 = obj + 16;
    D.35594 = mono_class_value_size (subc, 0B);
    D.35595 = (long unsigned int) D.35594;
    mono_gc_memmove_atomic (D.35593, val, D.35595);
    monoeg_g_free (val);
    D.35434 = obj;
    return D.35434;
  }
  <D.22411>:
  {
    struct MonoArray * arr;
    guint32 i;
    guint32 alen;
    guint32 basetype;

    p.391 = p;
    alen = MEM[(const guint32 *)p.391];
    p.391 = p;
    p.399 = p.391 + 4;
    p = p.399;
    if (alen == 4294967295) goto <D.35596>; else goto <D.35597>;
    <D.35596>:
    p.391 = p;
    *end = p.391;
    D.35434 = 0B;
    return D.35434;
    <D.35597>:
    D.35598 = mono_domain_get ();
    D.35599 = (long unsigned int) alen;
    arr = mono_array_new (D.35598, tklass, D.35599);
    D.35600 = tklass->byval_arg.type;
    basetype = (guint32) D.35600;
    if (basetype == 17) goto <D.35601>; else goto <D.35602>;
    <D.35601>:
    D.35603 = BIT_FIELD_REF <*tklass, 64, 256>;
    D.35604 = D.35603 & 16;
    if (D.35604 != 0) goto <D.35605>; else goto <D.35606>;
    <D.35605>:
    D.35607 = mono_class_enum_basetype (tklass);
    D.35608 = D.35607->type;
    basetype = (guint32) D.35608;
    <D.35606>:
    <D.35602>:
    switch (basetype) <default: <D.22463>, case 2: <D.22418>, case 3: <D.22425>, case 4: <D.22417>, case 5: <D.22416>, case 6: <D.22427>, case 7: <D.22426>, case 8: <D.22435>, case 9: <D.22434>, case 10: <D.22449>, case 11: <D.22448>, case 12: <D.22433>, case 13: <D.22441>, case 14: <D.22457>, case 18: <D.22455>, case 28: <D.22456>>
    <D.22416>:
    <D.22417>:
    <D.22418>:
    i = 0;
    goto <D.22422>;
    <D.22421>:
    {
      MonoBoolean val;

      p.391 = p;
      p.400 = p.391;
      p.401 = p.400 + 1;
      p = p.401;
      val = *p.400;
      {
        MonoBoolean * __p;

        D.35611 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 1, D.35611);
        *__p = val;
      }
    }
    i = i + 1;
    <D.22422>:
    if (i < alen) goto <D.22421>; else goto <D.22423>;
    <D.22423>:
    goto <D.22424>;
    <D.22425>:
    <D.22426>:
    <D.22427>:
    i = 0;
    goto <D.22431>;
    <D.22430>:
    {
      guint16 val;

      p.391 = p;
      val = MEM[(const guint16 *)p.391];
      {
        guint16 * __p;

        D.35611 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 2, D.35611);
        *__p = val;
      }
      p.391 = p;
      p.402 = p.391 + 2;
      p = p.402;
    }
    i = i + 1;
    <D.22431>:
    if (i < alen) goto <D.22430>; else goto <D.22432>;
    <D.22432>:
    goto <D.22424>;
    <D.22433>:
    <D.22434>:
    <D.22435>:
    i = 0;
    goto <D.22439>;
    <D.22438>:
    {
      guint32 val;

      p.391 = p;
      val = MEM[(const guint32 *)p.391];
      {
        guint32 * __p;

        D.35611 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 4, D.35611);
        *__p = val;
      }
      p.391 = p;
      p.399 = p.391 + 4;
      p = p.399;
    }
    i = i + 1;
    <D.22439>:
    if (i < alen) goto <D.22438>; else goto <D.22440>;
    <D.22440>:
    goto <D.22424>;
    <D.22441>:
    i = 0;
    goto <D.22446>;
    <D.22445>:
    {
      double val;

      try
        {
          {
            union mono_rdouble mf;

            try
              {
                p.391 = p;
                D.35439 = MEM[(const guint64 *)p.391];
                mf.ival = D.35439;
                val.403 = mf.fval;
                val = val.403;
              }
            finally
              {
                mf = {CLOBBER};
              }
          }
          {
            double * __p;

            D.35611 = (long unsigned int) i;
            __p = mono_array_addr_with_size (arr, 8, D.35611);
            val.404 = val;
            *__p = val.404;
          }
          p.391 = p;
          p.405 = p.391 + 8;
          p = p.405;
        }
      finally
        {
          val = {CLOBBER};
        }
    }
    i = i + 1;
    <D.22446>:
    if (i < alen) goto <D.22445>; else goto <D.22447>;
    <D.22447>:
    goto <D.22424>;
    <D.22448>:
    <D.22449>:
    i = 0;
    goto <D.22453>;
    <D.22452>:
    {
      guint64 val;

      p.391 = p;
      val = MEM[(const guint64 *)p.391];
      {
        guint64 * __p;

        D.35611 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 8, D.35611);
        *__p = val;
      }
      p.391 = p;
      p.405 = p.391 + 8;
      p = p.405;
    }
    i = i + 1;
    <D.22453>:
    if (i < alen) goto <D.22452>; else goto <D.22454>;
    <D.22454>:
    goto <D.22424>;
    <D.22455>:
    <D.22456>:
    <D.22457>:
    i = 0;
    goto <D.22461>;
    <D.22460>:
    {
      struct MonoObject * item;

      D.35614 = &tklass->byval_arg;
      p.391 = p;
      item = load_cattr_value (image, D.35614, p.391, &p);
      {
        void * * __p;

        D.35611 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 8, D.35611);
        mono_gc_wbarrier_set_arrayref (arr, __p, item);
      }
    }
    i = i + 1;
    <D.22461>:
    if (i < alen) goto <D.22460>; else goto <D.22462>;
    <D.22462>:
    goto <D.22424>;
    <D.22463>:
    monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr array decoding", basetype);
    <D.22464>:
    goto <D.22464>;
    <D.22424>:
    p.391 = p;
    *end = p.391;
    D.35434 = arr;
    return D.35434;
  }
  <D.22465>:
  monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr value decoding", type);
  <D.22466>:
  goto <D.22466>;
  D.35434 = 0B;
  return D.35434;
}


load_cattr_enum_type (struct MonoImage * image, const char * p, const char * * end)
{
  const char * p.406;
  unsigned int D.35618;
  int D.35619;
  unsigned int D.35620;
  sizetype D.35621;
  char * D.35622;
  const char * p.407;
  struct MonoClass * D.35626;
  char * n;
  struct MonoType * t;
  int slen;

  p.406 = p;
  D.35618 = mono_metadata_decode_value (p.406, &p);
  slen = (int) D.35618;
  p.406 = p;
  D.35619 = slen + 1;
  D.35620 = (unsigned int) D.35619;
  n = monoeg_g_memdup (p.406, D.35620);
  D.35621 = (sizetype) slen;
  D.35622 = n + D.35621;
  *D.35622 = 0;
  t = mono_reflection_type_from_name (n, image);
  if (t == 0B) goto <D.35623>; else goto <D.35624>;
  <D.35623>:
  monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
  <D.22341>:
  goto <D.22341>;
  <D.35624>:
  monoeg_g_free (n);
  p.406 = p;
  D.35621 = (sizetype) slen;
  p.407 = p.406 + D.35621;
  p = p.407;
  p.406 = p;
  *end = p.406;
  D.35626 = mono_class_from_mono_type (t);
  return D.35626;
}


type_is_reference (struct MonoType * type)
{
  unsigned char D.35628;
  int D.35629;
  gboolean D.35630;

  D.35628 = type->type;
  D.35629 = (int) D.35628;
  switch (D.35629) <default: <D.22503>, case 2: <D.22488>, case 3: <D.22489>, case 4: <D.22493>, case 5: <D.22492>, case 6: <D.22495>, case 7: <D.22494>, case 8: <D.22497>, case 9: <D.22496>, case 10: <D.22499>, case 11: <D.22498>, case 12: <D.22501>, case 13: <D.22500>, case 17: <D.22502>, case 24: <D.22491>, case 25: <D.22490>>
  <D.22488>:
  <D.22489>:
  <D.22490>:
  <D.22491>:
  <D.22492>:
  <D.22493>:
  <D.22494>:
  <D.22495>:
  <D.22496>:
  <D.22497>:
  <D.22498>:
  <D.22499>:
  <D.22500>:
  <D.22501>:
  <D.22502>:
  D.35630 = 0;
  return D.35630;
  <D.22503>:
  D.35630 = 1;
  return D.35630;
}


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.35634;
  struct MonoVTable * D.35635;
  struct MonoClass * D.35636;
  int D.35637;
  struct MonoException * D.35640;
  int D.35641;
  struct MonoLoaderError * D.35644;
  struct MonoLoaderError * D.35647;
  struct MonoException * D.35648;
  struct MonoArray * typedargs.408;
  struct MonoArray * namedargs.409;
  struct CattrNamedArg * arginfo.410;
  long unsigned int D.35655;
  char * D.35656;
  struct MonoMethodSignature * D.35657;
  struct MonoType * D.35658;
  struct MonoMethodSignature * D.35659;
  short unsigned int D.35660;
  int D.35661;
  char * D.35662;
  long unsigned int D.35663;
  long unsigned int D.35664;
  struct CattrNamedArg * D.35665;
  struct MonoProperty * D.35666;
  struct MonoClassField * D.35670;
  struct MonoType * D.35671;
  long unsigned int D.35672;
  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.35632>; else goto <D.35633>;
      <D.35632>:
      return;
      <D.35633>:
      D.35634 = assembly->assembly;
      image = D.35634->image;
      method = ref_method->method;
      D.35635 = MEM[(struct MonoObject *)ref_method].vtable;
      domain = D.35635->domain;
      D.35636 = method->klass;
      D.35637 = mono_class_init (D.35636);
      if (D.35637 == 0) goto <D.35638>; else goto <D.35639>;
      <D.35638>:
      D.35636 = method->klass;
      D.35640 = mono_class_get_exception_for_failure (D.35636);
      mono_raise_exception (D.35640);
      <D.35639>:
      mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
      D.35641 = mono_error_ok (&error);
      if (D.35641 == 0) goto <D.35642>; else goto <D.35643>;
      <D.35642>:
      mono_error_raise_exception (&error);
      <D.35643>:
      D.35644 = mono_loader_get_last_error ();
      if (D.35644 != 0B) goto <D.35645>; else goto <D.35646>;
      <D.35645>:
      D.35647 = mono_loader_get_last_error ();
      D.35648 = mono_loader_error_prepare_exception (D.35647);
      mono_raise_exception (D.35648);
      <D.35646>:
      typedargs.408 = typedargs;
      if (typedargs.408 == 0B) goto <D.35649>; else goto <D.35652>;
      <D.35652>:
      namedargs.409 = namedargs;
      if (namedargs.409 == 0B) goto <D.35649>; else goto <D.35650>;
      <D.35649>:
      arginfo.410 = arginfo;
      monoeg_g_free (arginfo.410);
      return;
      <D.35650>:
      i = 0;
      goto <D.22634>;
      <D.22633>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;

        typedargs.408 = typedargs;
        D.35655 = (long unsigned int) i;
        D.35656 = mono_array_addr_with_size (typedargs.408, 8, D.35655);
        obj = MEM[(struct MonoObject * *)D.35656];
        D.35657 = mono_method_signature (method);
        D.35658 = D.35657->params[i];
        typedarg = create_cattr_typed_arg (D.35658, obj);
        {
          void * * __p;

          typedargs.408 = typedargs;
          D.35655 = (long unsigned int) i;
          __p = mono_array_addr_with_size (typedargs.408, 8, D.35655);
          typedargs.408 = typedargs;
          mono_gc_wbarrier_set_arrayref (typedargs.408, __p, typedarg);
        }
      }
      i = i + 1;
      <D.22634>:
      D.35659 = mono_method_signature (method);
      D.35660 = D.35659->param_count;
      D.35661 = (int) D.35660;
      if (D.35661 > i) goto <D.22633>; else goto <D.22635>;
      <D.22635>:
      i = 0;
      goto <D.22642>;
      <D.22641>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;
        struct MonoObject * namedarg;
        struct MonoObject * minfo;

        namedargs.409 = namedargs;
        D.35655 = (long unsigned int) i;
        D.35662 = mono_array_addr_with_size (namedargs.409, 8, D.35655);
        obj = MEM[(struct MonoObject * *)D.35662];
        arginfo.410 = arginfo;
        D.35663 = (long unsigned int) i;
        D.35664 = D.35663 * 24;
        D.35665 = arginfo.410 + D.35664;
        D.35666 = D.35665->prop;
        if (D.35666 != 0B) goto <D.35667>; else goto <D.35668>;
        <D.35667>:
        arginfo.410 = arginfo;
        D.35663 = (long unsigned int) i;
        D.35664 = D.35663 * 24;
        D.35665 = arginfo.410 + D.35664;
        D.35666 = D.35665->prop;
        minfo = mono_property_get_object (domain, 0B, D.35666);
        goto <D.35669>;
        <D.35668>:
        arginfo.410 = arginfo;
        D.35663 = (long unsigned int) i;
        D.35664 = D.35663 * 24;
        D.35665 = arginfo.410 + D.35664;
        D.35670 = D.35665->field;
        minfo = mono_field_get_object (domain, 0B, D.35670);
        <D.35669>:
        arginfo.410 = arginfo;
        D.35663 = (long unsigned int) i;
        D.35664 = D.35663 * 24;
        D.35665 = arginfo.410 + D.35664;
        D.35671 = D.35665->type;
        typedarg = create_cattr_typed_arg (D.35671, obj);
        namedarg = create_cattr_named_arg (minfo, typedarg);
        {
          void * * __p;

          namedargs.409 = namedargs;
          D.35655 = (long unsigned int) i;
          __p = mono_array_addr_with_size (namedargs.409, 8, D.35655);
          namedargs.409 = namedargs;
          mono_gc_wbarrier_set_arrayref (namedargs.409, __p, namedarg);
        }
      }
      i = i + 1;
      <D.22642>:
      D.35655 = (long unsigned int) i;
      namedargs.409 = namedargs;
      D.35672 = mono_array_length (namedargs.409);
      if (D.35655 < D.35672) goto <D.22641>; else goto <D.22643>;
      <D.22643>:
      typedargs.408 = typedargs;
      *ctor_args = typedargs.408;
      namedargs.409 = namedargs;
      *named_args = namedargs.409;
      arginfo.410 = arginfo;
      monoeg_g_free (arginfo.410);
    }
  finally
    {
      typedargs = {CLOBBER};
      namedargs = {CLOBBER};
      arginfo = {CLOBBER};
      error = {CLOBBER};
    }
}


create_cattr_typed_arg (struct MonoType * t, struct MonoObject * val)
{
  struct MonoClass * klass.411;
  struct MonoImage * D.35679;
  struct MonoClass * klass.412;
  struct MonoMethod * ctor.413;
  struct MonoMethod * ctor.414;
  struct MonoDomain * D.35685;
  struct MonoReflectionType * D.35686;
  struct MonoDomain * D.35687;
  struct MonoObject * D.35688;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * params[2];
  void * unboxed;

  try
    {
      klass.411 = klass;
      if (klass.411 == 0B) goto <D.35677>; else goto <D.35678>;
      <D.35677>:
      D.35679 = mono_defaults.corlib;
      klass.412 = mono_class_from_name (D.35679, "System.Reflection", "CustomAttributeTypedArgument");
      klass = klass.412;
      <D.35678>:
      ctor.413 = ctor;
      if (ctor.413 == 0B) goto <D.35682>; else goto <D.35683>;
      <D.35682>:
      klass.411 = klass;
      ctor.414 = mono_class_get_method_from_name (klass.411, ".ctor", 2);
      ctor = ctor.414;
      <D.35683>:
      D.35685 = mono_domain_get ();
      D.35686 = mono_type_get_object (D.35685, t);
      params[0] = D.35686;
      params[1] = val;
      D.35687 = mono_domain_get ();
      klass.411 = klass;
      retval = mono_object_new (D.35687, klass.411);
      unboxed = mono_object_unbox (retval);
      ctor.413 = ctor;
      mono_runtime_invoke (ctor.413, unboxed, &params, 0B);
      D.35688 = retval;
      return D.35688;
    }
  finally
    {
      params = {CLOBBER};
    }
}


create_cattr_named_arg (void * minfo, struct MonoObject * typedarg)
{
  struct MonoClass * klass.415;
  struct MonoImage * D.35694;
  struct MonoClass * klass.416;
  struct MonoMethod * ctor.417;
  struct MonoMethod * ctor.418;
  struct MonoDomain * D.35700;
  struct MonoObject * D.35701;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * unboxed;
  void * params[2];

  try
    {
      klass.415 = klass;
      if (klass.415 == 0B) goto <D.35692>; else goto <D.35693>;
      <D.35692>:
      D.35694 = mono_defaults.corlib;
      klass.416 = mono_class_from_name (D.35694, "System.Reflection", "CustomAttributeNamedArgument");
      klass = klass.416;
      <D.35693>:
      ctor.417 = ctor;
      if (ctor.417 == 0B) goto <D.35697>; else goto <D.35698>;
      <D.35697>:
      klass.415 = klass;
      ctor.418 = mono_class_get_method_from_name (klass.415, ".ctor", 2);
      ctor = ctor.418;
      <D.35698>:
      params[0] = minfo;
      params[1] = typedarg;
      D.35700 = mono_domain_get ();
      klass.415 = klass;
      retval = mono_object_new (D.35700, klass.415);
      unboxed = mono_object_unbox (retval);
      ctor.417 = ctor;
      mono_runtime_invoke (ctor.417, unboxed, &params, 0B);
      D.35701 = retval;
      return D.35701;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_custom_attrs_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoArray * D.35704;
  struct MonoError error;

  try
    {
      D.35704 = mono_custom_attrs_construct_by_type (cinfo, 0B, &error);
      return D.35704;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_custom_attrs_construct_by_type (struct MonoCustomAttrInfo * cinfo, struct MonoClass * attr_klass, struct MonoError * error)
{
  struct MonoMethod * D.35710;
  struct MonoClass * D.35711;
  int D.35712;
  int D.35713;
  struct MonoDomain * D.35714;
  struct MonoClass * D.22665;
  struct MonoClass * tmp_klass.419;
  struct MonoClass * D.35718;
  struct MonoClass * tmp_klass.420;
  _Bool D.35720;
  long int D.35721;
  long int D.35722;
  struct MonoVTable * D.35725;
  long unsigned int D.35726;
  struct MonoException * D.35729;
  int D.35733;
  struct MonoImage * D.35734;
  const mono_byte * D.35735;
  unsigned int D.35736;
  int D.35737;
  struct MonoArray * D.35740;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;
  int n;

  mono_error_init (error);
  n = 0;
  i = 0;
  goto <D.22662>;
  <D.22661>:
  if (attr_klass == 0B) goto <D.35707>; else goto <D.35709>;
  <D.35709>:
  D.35710 = cinfo->attrs[i].ctor;
  D.35711 = D.35710->klass;
  D.35712 = mono_class_is_assignable_from (attr_klass, D.35711);
  if (D.35712 != 0) goto <D.35707>; else goto <D.35708>;
  <D.35707>:
  n = n + 1;
  <D.35708>:
  i = i + 1;
  <D.22662>:
  D.35713 = cinfo->num_attrs;
  if (D.35713 > i) goto <D.22661>; else goto <D.22663>;
  <D.22663>:
  D.35714 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.419 = tmp_klass;
      if (tmp_klass.419 == 0B) goto <D.35716>; else goto <D.35717>;
      <D.35716>:
      D.35718 = mono_defaults.attribute_class;
      tmp_klass.420 = mono_array_class_get (D.35718, 1);
      tmp_klass = tmp_klass.420;
      tmp_klass.419 = tmp_klass;
      D.35720 = tmp_klass.419 == 0B;
      D.35721 = (long int) D.35720;
      D.35722 = __builtin_expect (D.35721, 0);
      if (D.35722 != 0) goto <D.35723>; else goto <D.35724>;
      <D.35723>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8491, "tmp_klass");
      <D.35724>:
      <D.35717>:
    }
    D.22665 = tmp_klass;
  }
  D.35725 = mono_class_vtable (D.35714, D.22665);
  D.35726 = (long unsigned int) n;
  result = mono_array_new_specific (D.35725, D.35726);
  n = 0;
  i = 0;
  goto <D.22668>;
  <D.22667>:
  D.35710 = cinfo->attrs[i].ctor;
  if (D.35710 == 0B) goto <D.35727>; else goto <D.35728>;
  <D.35727>:
  D.35729 = mono_get_exception_type_load (0B, 0B);
  mono_raise_exception (D.35729);
  <D.35728>:
  if (attr_klass == 0B) goto <D.35730>; else goto <D.35732>;
  <D.35732>:
  D.35710 = cinfo->attrs[i].ctor;
  D.35711 = D.35710->klass;
  D.35733 = mono_class_is_assignable_from (attr_klass, D.35711);
  if (D.35733 != 0) goto <D.35730>; else goto <D.35731>;
  <D.35730>:
  D.35734 = cinfo->image;
  D.35710 = cinfo->attrs[i].ctor;
  D.35735 = cinfo->attrs[i].data;
  D.35736 = cinfo->attrs[i].data_size;
  attr = create_custom_attr (D.35734, D.35710, D.35735, D.35736, error);
  D.35737 = mono_error_ok (error);
  if (D.35737 == 0) goto <D.35738>; else goto <D.35739>;
  <D.35738>:
  D.35740 = result;
  return D.35740;
  <D.35739>:
  {
    void * * __p;

    D.35726 = (long unsigned int) n;
    __p = mono_array_addr_with_size (result, 8, D.35726);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  n = n + 1;
  <D.35731>:
  i = i + 1;
  <D.22668>:
  D.35713 = cinfo->num_attrs;
  if (D.35713 > i) goto <D.22667>; else goto <D.22669>;
  <D.22669>:
  D.35740 = result;
  return D.35740;
}


create_custom_attr (struct MonoImage * image, struct MonoMethod * method, const guchar * data, guint32 len, struct MonoError * error)
{
  struct MonoClass * D.35742;
  int D.35743;
  struct MonoObject * D.35746;
  struct MonoDomain * D.35749;
  const char * p.421;
  short unsigned int D.35754;
  short unsigned int D.35755;
  long unsigned int D.35759;
  long unsigned int D.35760;
  const char * p.422;
  long unsigned int D.35762;
  long unsigned int D.35763;
  void * * D.35764;
  struct MonoMethodSignature * D.35765;
  struct MonoType * D.35766;
  void * D.35767;
  struct MonoMethodSignature * D.35768;
  short unsigned int D.35769;
  unsigned int D.35770;
  struct MonoDomain * D.35771;
  struct MonoMethodSignature * D.35772;
  const char * named.423;
  short unsigned int D.35774;
  const char * named.424;
  const char * named.425;
  const char * named.426;
  const char * named.427;
  const char * named.428;
  const char * named.429;
  const char * named.430;
  unsigned int D.35786;
  int D.35787;
  long unsigned int D.35788;
  long unsigned int D.35789;
  sizetype D.35790;
  char * D.35791;
  const char * named.431;
  unsigned int D.35793;
  int D.35794;
  long unsigned int D.35795;
  long unsigned int D.35796;
  sizetype D.35797;
  char * D.35798;
  const char * named.432;
  struct MonoVTable * D.35802;
  struct MonoClass * D.35803;
  struct MonoType * D.35804;
  int D.35805;
  struct MonoType * iftmp.433;
  struct MonoMethod * D.35812;
  struct MonoMethodSignature * D.35815;
  struct MonoMethod * D.35817;
  struct MonoMethodSignature * D.35818;
  struct MonoMethodSignature * D.35819;
  short unsigned int D.35820;
  int D.35821;
  int D.35822;
  void * D.35823;
  int D.35824;
  void * D.35827;
  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.35742 = method->klass;
      mono_class_init (D.35742);
      D.35743 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.35743 == 0) goto <D.35744>; else goto <D.35745>;
      <D.35744>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      D.35746 = 0B;
      return D.35746;
      <D.35745>:
      if (len == 0) goto <D.35747>; else goto <D.35748>;
      <D.35747>:
      D.35749 = mono_domain_get ();
      D.35742 = method->klass;
      attr = mono_object_new (D.35749, D.35742);
      mono_runtime_invoke (method, attr, 0B, 0B);
      D.35746 = attr;
      return D.35746;
      <D.35748>:
      if (len <= 1) goto <D.35750>; else goto <D.35752>;
      <D.35752>:
      p.421 = p;
      D.35754 = MEM[(const guint16 *)p.421];
      if (D.35754 != 1) goto <D.35750>; else goto <D.35751>;
      <D.35750>:
      D.35746 = 0B;
      return D.35746;
      <D.35751>:
      sig = mono_method_signature (method);
      D.35755 = sig->param_count;
      if (D.35755 <= 31) goto <D.35756>; else goto <D.35757>;
      <D.35756>:
      params = &params_buf;
      goto <D.35758>;
      <D.35757>:
      D.35755 = sig->param_count;
      D.35759 = (long unsigned int) D.35755;
      D.35760 = D.35759 * 8;
      params = mono_gc_alloc_fixed (D.35760, 0B);
      <D.35758>:
      p.421 = p;
      p.422 = p.421 + 2;
      p = p.422;
      i = 0;
      goto <D.22553>;
      <D.22552>:
      D.35762 = (long unsigned int) i;
      D.35763 = D.35762 * 8;
      D.35764 = params + D.35763;
      D.35765 = mono_method_signature (method);
      D.35766 = D.35765->params[i];
      p.421 = p;
      D.35767 = load_cattr_value (image, D.35766, p.421, &p);
      *D.35764 = D.35767;
      i = i + 1;
      <D.22553>:
      D.35768 = mono_method_signature (method);
      D.35769 = D.35768->param_count;
      D.35770 = (unsigned int) D.35769;
      if (D.35770 > i) goto <D.22552>; else goto <D.22554>;
      <D.22554>:
      p.421 = p;
      named = p.421;
      D.35771 = mono_domain_get ();
      D.35742 = method->klass;
      attr = mono_object_new (D.35771, D.35742);
      mono_runtime_invoke (method, attr, params, 0B);
      D.35772 = method->signature;
      free_param_data (D.35772, params);
      named.423 = named;
      D.35774 = MEM[(const guint16 *)named.423];
      num_named = (guint32) D.35774;
      named.423 = named;
      named.424 = named.423 + 2;
      named = named.424;
      j = 0;
      goto <D.22567>;
      <D.22566>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.423 = named;
        named.425 = named.423;
        named.426 = named.425 + 1;
        named = named.426;
        named_type = *named.425;
        named.423 = named;
        named.427 = named.423;
        named.428 = named.427 + 1;
        named = named.428;
        data_type = *named.427;
        if (data_type == 29) goto <D.35780>; else goto <D.35781>;
        <D.35780>:
        named.423 = named;
        named.429 = named.423;
        named.430 = named.429 + 1;
        named = named.430;
        data_type = *named.429;
        <D.35781>:
        if (data_type == 85) goto <D.35784>; else goto <D.35785>;
        <D.35784>:
        {
          gint type_len;
          char * type_name;

          named.423 = named;
          D.35786 = mono_metadata_decode_blob_size (named.423, &named);
          type_len = (gint) D.35786;
          D.35787 = type_len + 1;
          D.35788 = (long unsigned int) D.35787;
          type_name = monoeg_malloc (D.35788);
          named.423 = named;
          D.35789 = (long unsigned int) type_len;
          memcpy (type_name, named.423, D.35789);
          D.35790 = (sizetype) type_len;
          D.35791 = type_name + D.35790;
          *D.35791 = 0;
          named.423 = named;
          D.35790 = (sizetype) type_len;
          named.431 = named.423 + D.35790;
          named = named.431;
          monoeg_g_free (type_name);
        }
        <D.35785>:
        named.423 = named;
        D.35793 = mono_metadata_decode_blob_size (named.423, &named);
        name_len = (gint) D.35793;
        D.35794 = name_len + 1;
        D.35795 = (long unsigned int) D.35794;
        name = monoeg_malloc (D.35795);
        named.423 = named;
        D.35796 = (long unsigned int) name_len;
        memcpy (name, named.423, D.35796);
        D.35797 = (sizetype) name_len;
        D.35798 = name + D.35797;
        *D.35798 = 0;
        named.423 = named;
        D.35797 = (sizetype) name_len;
        named.432 = named.423 + D.35797;
        named = named.432;
        if (named_type == 83) goto <D.35800>; else goto <D.35801>;
        <D.35800>:
        {
          struct MonoClassField * field;
          void * val;

          D.35802 = attr->vtable;
          D.35803 = D.35802->klass;
          field = mono_class_get_field_from_name (D.35803, name);
          D.35804 = field->type;
          named.423 = named;
          val = load_cattr_value (image, D.35804, named.423, &named);
          mono_field_set_value (attr, field, val);
          D.35804 = field->type;
          D.35805 = type_is_reference (D.35804);
          if (D.35805 == 0) goto <D.35806>; else goto <D.35807>;
          <D.35806>:
          monoeg_g_free (val);
          <D.35807>:
        }
        goto <D.35808>;
        <D.35801>:
        if (named_type == 84) goto <D.35809>; else goto <D.35810>;
        <D.35809>:
        {
          struct MonoProperty * prop;
          void * pparams[1];
          struct MonoType * prop_type;

          try
            {
              D.35802 = attr->vtable;
              D.35803 = D.35802->klass;
              prop = mono_class_get_property_from_name (D.35803, name);
              D.35812 = prop->get;
              if (D.35812 != 0B) goto <D.35813>; else goto <D.35814>;
              <D.35813>:
              D.35812 = prop->get;
              D.35815 = mono_method_signature (D.35812);
              iftmp.433 = D.35815->ret;
              goto <D.35816>;
              <D.35814>:
              D.35817 = prop->set;
              D.35818 = mono_method_signature (D.35817);
              D.35817 = prop->set;
              D.35819 = mono_method_signature (D.35817);
              D.35820 = D.35819->param_count;
              D.35821 = (int) D.35820;
              D.35822 = D.35821 + -1;
              iftmp.433 = D.35818->params[D.35822];
              <D.35816>:
              prop_type = iftmp.433;
              named.423 = named;
              D.35823 = load_cattr_value (image, prop_type, named.423, &named);
              pparams[0] = D.35823;
              mono_property_set_value (prop, attr, &pparams, 0B);
              D.35824 = type_is_reference (prop_type);
              if (D.35824 == 0) goto <D.35825>; else goto <D.35826>;
              <D.35825>:
              D.35827 = pparams[0];
              monoeg_g_free (D.35827);
              <D.35826>:
            }
          finally
            {
              pparams = {CLOBBER};
            }
        }
        <D.35810>:
        <D.35808>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.22567>:
      if (j < num_named) goto <D.22566>; else goto <D.22568>;
      <D.22568>:
      if (&params_buf != params) goto <D.35828>; else goto <D.35829>;
      <D.35828>:
      mono_gc_free_fixed (params);
      <D.35829>:
      D.35746 = attr;
      return D.35746;
    }
  finally
    {
      p = {CLOBBER};
      named = {CLOBBER};
      params_buf = {CLOBBER};
    }
}


free_param_data (struct MonoMethodSignature * sig, void * * params)
{
  struct MonoType * D.35832;
  int D.35833;
  long unsigned int D.35836;
  long unsigned int D.35837;
  void * * D.35838;
  void * D.35839;
  short unsigned int D.35840;
  int D.35841;
  int i;

  i = 0;
  goto <D.22510>;
  <D.22509>:
  D.35832 = sig->params[i];
  D.35833 = type_is_reference (D.35832);
  if (D.35833 == 0) goto <D.35834>; else goto <D.35835>;
  <D.35834>:
  D.35836 = (long unsigned int) i;
  D.35837 = D.35836 * 8;
  D.35838 = params + D.35837;
  D.35839 = *D.35838;
  monoeg_g_free (D.35839);
  <D.35835>:
  i = i + 1;
  <D.22510>:
  D.35840 = sig->param_count;
  D.35841 = (int) D.35840;
  if (D.35841 > i) goto <D.22509>; else goto <D.22511>;
  <D.22511>:
}


mono_custom_attrs_from_index (struct MonoImage * image, guint32 idx)
{
  struct MonoCustomAttrInfo * D.35844;
  int i.434;
  unsigned int D.35846;
  long unsigned int D.35848;
  void * D.35849;
  <unnamed-unsigned:24> D.35850;
  unsigned int D.35851;
  long unsigned int D.35854;
  long unsigned int D.35855;
  long unsigned int D.35856;
  int len.435;
  void * D.35858;
  long int D.35859;
  int D.35860;
  unsigned int D.35861;
  unsigned int D.35862;
  struct MonoMethod * D.35863;
  struct MonoMethod * D.35864;
  char * D.35867;
  unsigned int D.35868;
  int D.35869;
  const char * data.436;
  const char * data.437;
  unsigned int D.35874;
  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.35842>; else goto <D.35843>;
      <D.35842>:
      D.35844 = 0B;
      return D.35844;
      <D.35843>:
      i = i + 4294967295;
      goto <D.22699>;
      <D.22698>:
      i.434 = (int) i;
      D.35846 = mono_metadata_decode_row_col (ca, i.434, 0);
      if (D.35846 != idx) goto <D.22697>; else goto <D.35847>;
      <D.35847>:
      D.35848 = (long unsigned int) i;
      D.35849 = (void *) D.35848;
      list = monoeg_g_list_prepend (list, D.35849);
      i = i + 1;
      <D.22699>:
      D.35850 = ca->rows;
      D.35851 = (unsigned int) D.35850;
      if (D.35851 > i) goto <D.22698>; else goto <D.22697>;
      <D.22697>:
      len = monoeg_g_list_length (list);
      if (len == 0) goto <D.35852>; else goto <D.35853>;
      <D.35852>:
      D.35844 = 0B;
      return D.35844;
      <D.35853>:
      D.35854 = (long unsigned int) len;
      D.35855 = D.35854 * 24;
      D.35856 = D.35855 + 16;
      ainfo = monoeg_malloc0 (D.35856);
      len.435 = (int) len;
      ainfo->num_attrs = len.435;
      ainfo->image = image;
      i = 0;
      tmp = list;
      goto <D.22706>;
      <D.22705>:
      D.35858 = tmp->data;
      D.35859 = (long int) D.35858;
      D.35860 = (int) D.35859;
      mono_metadata_decode_row (ca, D.35860, &cols, 3);
      D.35861 = cols[1];
      mtoken = D.35861 >> 3;
      D.35861 = cols[1];
      D.35862 = D.35861 & 7;
      switch (D.35862) <default: <D.22703>, case 2: <D.22700>, case 3: <D.22702>>
      <D.22700>:
      mtoken = mtoken | 100663296;
      goto <D.22701>;
      <D.22702>:
      mtoken = mtoken | 167772160;
      goto <D.22701>;
      <D.22703>:
      D.35861 = cols[1];
      monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.35861);
      <D.22704>:
      goto <D.22704>;
      <D.22701>:
      D.35863 = mono_get_method (image, mtoken, 0B);
      ainfo->attrs[i].ctor = D.35863;
      D.35864 = ainfo->attrs[i].ctor;
      if (D.35864 == 0B) goto <D.35865>; else goto <D.35866>;
      <D.35865>:
      D.35867 = image->name;
      monoeg_g_log (0B, 16, "Can\'t find custom attr constructor image: %s mtoken: 0x%08x", D.35867, mtoken);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.35844 = 0B;
      return D.35844;
      <D.35866>:
      D.35868 = cols[2];
      D.35869 = mono_verifier_verify_cattr_blob (image, D.35868, 0B);
      if (D.35869 == 0) goto <D.35870>; else goto <D.35871>;
      <D.35870>:
      D.35867 = image->name;
      monoeg_g_log (0B, 16, "Invalid custom attribute blob on image %s for index %x", D.35867, idx);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.35844 = 0B;
      return D.35844;
      <D.35871>:
      D.35868 = cols[2];
      data.436 = mono_metadata_blob_heap (image, D.35868);
      data = data.436;
      data.437 = data;
      D.35874 = mono_metadata_decode_value (data.437, &data);
      ainfo->attrs[i].data_size = D.35874;
      data.437 = data;
      ainfo->attrs[i].data = data.437;
      i = i + 1;
      tmp = tmp->next;
      <D.22706>:
      if (i < len) goto <D.22705>; else goto <D.22707>;
      <D.22707>:
      monoeg_g_list_free (list);
      D.35844 = ainfo;
      return D.35844;
    }
  finally
    {
      cols = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_custom_attrs_from_method (struct MonoMethod * method)
{
  long unsigned int D.35877;
  long unsigned int D.35878;
  long unsigned int D.35883;
  struct MonoClass * D.35885;
  struct MonoImage * D.35886;
  long unsigned int D.35887;
  long unsigned int D.35888;
  struct MonoCustomAttrInfo * D.35889;
  unsigned int D.35890;
  guint32 idx;

  D.35877 = BIT_FIELD_REF <*method, 64, 256>;
  D.35878 = D.35877 & 4096;
  if (D.35878 != 0) goto <D.35879>; else goto <D.35880>;
  <D.35879>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.35880>:
  D.35877 = BIT_FIELD_REF <*method, 64, 256>;
  D.35883 = D.35877 & 512;
  if (D.35883 != 0) goto <D.35881>; else goto <D.35884>;
  <D.35884>:
  D.35885 = method->klass;
  D.35886 = D.35885->image;
  D.35887 = BIT_FIELD_REF <*D.35886, 64, 192>;
  D.35888 = D.35887 & 34359738368;
  if (D.35888 != 0) goto <D.35881>; else goto <D.35882>;
  <D.35881>:
  D.35885 = method->klass;
  D.35886 = D.35885->image;
  D.35889 = lookup_custom_attr (D.35886, method);
  return D.35889;
  <D.35882>:
  D.35890 = method->token;
  if (D.35890 == 0) goto <D.35891>; else goto <D.35892>;
  <D.35891>:
  D.35889 = 0B;
  return D.35889;
  <D.35892>:
  idx = mono_method_get_index (method);
  idx = idx << 5;
  idx = idx;
  D.35885 = method->klass;
  D.35886 = D.35885->image;
  D.35889 = mono_custom_attrs_from_index (D.35886, idx);
  return D.35889;
}


lookup_custom_attr (struct MonoImage * image, void * member)
{
  struct MonoCustomAttrInfo * D.35896;
  int D.35897;
  long unsigned int D.35898;
  unsigned int D.35899;
  unsigned int D.35900;
  unsigned int D.35901;
  struct MonoCustomAttrInfo * res;

  res = mono_image_property_lookup (image, member, 4096);
  if (res == 0B) goto <D.35894>; else goto <D.35895>;
  <D.35894>:
  D.35896 = 0B;
  return D.35896;
  <D.35895>:
  D.35897 = res->num_attrs;
  D.35898 = (long unsigned int) D.35897;
  D.35899 = (unsigned int) D.35898;
  D.35900 = D.35899 * 24;
  D.35901 = D.35900 + 16;
  res = monoeg_g_memdup (res, D.35901);
  res->cached = 0;
  D.35896 = res;
  return D.35896;
}


mono_custom_attrs_from_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.35903;
  struct MonoImage * D.35906;
  long unsigned int D.35907;
  long unsigned int D.35908;
  struct MonoCustomAttrInfo * D.35911;
  unsigned char D.35915;
  int D.35917;
  unsigned int D.35918;
  unsigned int D.35919;
  guint32 idx;

  D.35903 = klass->generic_class;
  if (D.35903 != 0B) goto <D.35904>; else goto <D.35905>;
  <D.35904>:
  D.35903 = klass->generic_class;
  klass = D.35903->container_class;
  <D.35905>:
  D.35906 = klass->image;
  D.35907 = BIT_FIELD_REF <*D.35906, 64, 192>;
  D.35908 = D.35907 & 34359738368;
  if (D.35908 != 0) goto <D.35909>; else goto <D.35910>;
  <D.35909>:
  D.35906 = klass->image;
  D.35911 = lookup_custom_attr (D.35906, klass);
  return D.35911;
  <D.35910>:
  D.35915 = klass->byval_arg.type;
  if (D.35915 == 19) goto <D.35912>; else goto <D.35916>;
  <D.35916>:
  D.35915 = klass->byval_arg.type;
  if (D.35915 == 30) goto <D.35912>; else goto <D.35913>;
  <D.35912>:
  D.35917 = klass->sizes.generic_param_token;
  D.35918 = (unsigned int) D.35917;
  idx = D.35918 & 16777215;
  idx = idx << 5;
  idx = idx | 19;
  goto <D.35914>;
  <D.35913>:
  D.35919 = klass->type_token;
  idx = D.35919 & 16777215;
  idx = idx << 5;
  idx = idx | 3;
  <D.35914>:
  D.35906 = klass->image;
  D.35911 = mono_custom_attrs_from_index (D.35906, idx);
  return D.35911;
}


mono_custom_attrs_from_assembly (struct MonoAssembly * assembly)
{
  struct MonoImage * D.35921;
  long unsigned int D.35922;
  long unsigned int D.35923;
  struct MonoCustomAttrInfo * D.35926;
  guint32 idx;

  D.35921 = assembly->image;
  D.35922 = BIT_FIELD_REF <*D.35921, 64, 192>;
  D.35923 = D.35922 & 34359738368;
  if (D.35923 != 0) goto <D.35924>; else goto <D.35925>;
  <D.35924>:
  D.35921 = assembly->image;
  D.35926 = lookup_custom_attr (D.35921, assembly);
  return D.35926;
  <D.35925>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 14;
  D.35921 = assembly->image;
  D.35926 = mono_custom_attrs_from_index (D.35921, idx);
  return D.35926;
}


mono_custom_attrs_from_property (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoImage * D.35928;
  long unsigned int D.35929;
  long unsigned int D.35930;
  struct MonoCustomAttrInfo * D.35933;
  guint32 idx;

  D.35928 = klass->image;
  D.35929 = BIT_FIELD_REF <*D.35928, 64, 192>;
  D.35930 = D.35929 & 34359738368;
  if (D.35930 != 0) goto <D.35931>; else goto <D.35932>;
  <D.35931>:
  property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
  D.35928 = klass->image;
  D.35933 = lookup_custom_attr (D.35928, property);
  return D.35933;
  <D.35932>:
  idx = find_property_index (klass, property);
  idx = idx << 5;
  idx = idx | 9;
  D.35928 = klass->image;
  D.35933 = mono_custom_attrs_from_index (D.35928, idx);
  return D.35933;
}


find_property_index (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoClassExt * D.35935;
  struct MonoProperty * D.35936;
  long unsigned int D.35937;
  long unsigned int D.35938;
  struct MonoProperty * D.35939;
  guint32 D.35942;
  unsigned int D.35943;
  unsigned int i.438;
  unsigned int D.35945;
  unsigned int D.35946;
  int i;

  i = 0;
  goto <D.22526>;
  <D.22525>:
  D.35935 = klass->ext;
  D.35936 = D.35935->properties;
  D.35937 = (long unsigned int) i;
  D.35938 = D.35937 * 40;
  D.35939 = D.35936 + D.35938;
  if (D.35939 == property) goto <D.35940>; else goto <D.35941>;
  <D.35940>:
  D.35935 = klass->ext;
  D.35943 = D.35935->property.first;
  i.438 = (unsigned int) i;
  D.35945 = D.35943 + i.438;
  D.35942 = D.35945 + 1;
  return D.35942;
  <D.35941>:
  i = i + 1;
  <D.22526>:
  i.438 = (unsigned int) i;
  D.35935 = klass->ext;
  D.35946 = D.35935->property.count;
  if (i.438 < D.35946) goto <D.22525>; else goto <D.22527>;
  <D.22527>:
  D.35942 = 0;
  return D.35942;
}


mono_custom_attrs_from_event (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoImage * D.35948;
  long unsigned int D.35949;
  long unsigned int D.35950;
  struct MonoCustomAttrInfo * D.35953;
  guint32 idx;

  D.35948 = klass->image;
  D.35949 = BIT_FIELD_REF <*D.35948, 64, 192>;
  D.35950 = D.35949 & 34359738368;
  if (D.35950 != 0) goto <D.35951>; else goto <D.35952>;
  <D.35951>:
  event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
  D.35948 = klass->image;
  D.35953 = lookup_custom_attr (D.35948, event);
  return D.35953;
  <D.35952>:
  idx = find_event_index (klass, event);
  idx = idx << 5;
  idx = idx | 10;
  D.35948 = klass->image;
  D.35953 = mono_custom_attrs_from_index (D.35948, idx);
  return D.35953;
}


find_event_index (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoClassExt * D.35955;
  struct MonoEvent * D.35956;
  long unsigned int D.35957;
  long unsigned int D.35958;
  struct MonoEvent * D.35959;
  guint32 D.35962;
  unsigned int D.35963;
  unsigned int i.439;
  unsigned int D.35965;
  unsigned int D.35966;
  int i;

  i = 0;
  goto <D.22534>;
  <D.22533>:
  D.35955 = klass->ext;
  D.35956 = D.35955->events;
  D.35957 = (long unsigned int) i;
  D.35958 = D.35957 * 56;
  D.35959 = D.35956 + D.35958;
  if (D.35959 == event) goto <D.35960>; else goto <D.35961>;
  <D.35960>:
  D.35955 = klass->ext;
  D.35963 = D.35955->event.first;
  i.439 = (unsigned int) i;
  D.35965 = D.35963 + i.439;
  D.35962 = D.35965 + 1;
  return D.35962;
  <D.35961>:
  i = i + 1;
  <D.22534>:
  i.439 = (unsigned int) i;
  D.35955 = klass->ext;
  D.35966 = D.35955->event.count;
  if (i.439 < D.35966) goto <D.22533>; else goto <D.22535>;
  <D.22535>:
  D.35962 = 0;
  return D.35962;
}


mono_custom_attrs_from_field (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoImage * D.35968;
  long unsigned int D.35969;
  long unsigned int D.35970;
  struct MonoCustomAttrInfo * D.35973;
  guint32 idx;

  D.35968 = klass->image;
  D.35969 = BIT_FIELD_REF <*D.35968, 64, 192>;
  D.35970 = D.35969 & 34359738368;
  if (D.35970 != 0) goto <D.35971>; else goto <D.35972>;
  <D.35971>:
  field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
  D.35968 = klass->image;
  D.35973 = lookup_custom_attr (D.35968, field);
  return D.35973;
  <D.35972>:
  idx = find_field_index (klass, field);
  idx = idx << 5;
  idx = idx | 1;
  D.35968 = klass->image;
  D.35973 = mono_custom_attrs_from_index (D.35968, idx);
  return D.35973;
}


find_field_index (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoClassField * D.35975;
  long unsigned int D.35976;
  long unsigned int D.35977;
  struct MonoClassField * D.35978;
  guint32 D.35981;
  unsigned int D.35982;
  unsigned int i.440;
  unsigned int D.35984;
  unsigned int D.35985;
  int i;

  i = 0;
  goto <D.22518>;
  <D.22517>:
  D.35975 = klass->fields;
  D.35976 = (long unsigned int) i;
  D.35977 = D.35976 * 32;
  D.35978 = D.35975 + D.35977;
  if (D.35978 == field) goto <D.35979>; else goto <D.35980>;
  <D.35979>:
  D.35982 = klass->field.first;
  i.440 = (unsigned int) i;
  D.35984 = D.35982 + i.440;
  D.35981 = D.35984 + 1;
  return D.35981;
  <D.35980>:
  i = i + 1;
  <D.22518>:
  i.440 = (unsigned int) i;
  D.35985 = klass->field.count;
  if (i.440 < D.35985) goto <D.22517>; else goto <D.22519>;
  <D.22519>:
  D.35981 = 0;
  return D.35981;
}


mono_custom_attrs_from_param (struct MonoMethod * method, guint32 param)
{
  long unsigned int D.35987;
  long unsigned int D.35988;
  struct MonoClass * D.35991;
  struct MonoImage * D.35992;
  long unsigned int D.35993;
  long unsigned int D.35994;
  struct GHashTable * D.35997;
  struct MonoCustomAttrInfo * * D.36001;
  struct MonoCustomAttrInfo * D.36002;
  long unsigned int D.36003;
  long unsigned int D.36004;
  struct MonoCustomAttrInfo * * D.36005;
  int D.36008;
  long unsigned int D.36009;
  unsigned int D.36010;
  unsigned int D.36011;
  unsigned int D.36012;
  long unsigned int D.36013;
  long unsigned int D.36014;
  unsigned int D.36017;
  int D.36018;
  <unnamed-unsigned:24> D.36019;
  unsigned int D.36020;
  int D.36023;
  int D.36024;
  int method_index.441;
  unsigned int D.36027;
  int D.36028;
  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.35987 = BIT_FIELD_REF <*method, 64, 256>;
  D.35988 = D.35987 & 4096;
  if (D.35988 != 0) goto <D.35989>; else goto <D.35990>;
  <D.35989>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.35990>:
  D.35991 = method->klass;
  D.35992 = D.35991->image;
  D.35993 = BIT_FIELD_REF <*D.35992, 64, 192>;
  D.35994 = D.35993 & 34359738368;
  if (D.35994 != 0) goto <D.35995>; else goto <D.35996>;
  <D.35995>:
  {
    struct MonoCustomAttrInfo * res;
    struct MonoCustomAttrInfo * ainfo;
    int size;

    D.35991 = method->klass;
    D.35992 = D.35991->image;
    D.35997 = MEM[(struct MonoDynamicImage *)D.35992].method_aux_hash;
    aux = monoeg_g_hash_table_lookup (D.35997, method);
    if (aux == 0B) goto <D.35998>; else goto <D.36000>;
    <D.36000>:
    D.36001 = aux->param_cattr;
    if (D.36001 == 0B) goto <D.35998>; else goto <D.35999>;
    <D.35998>:
    D.36002 = 0B;
    return D.36002;
    <D.35999>:
    D.36001 = aux->param_cattr;
    D.36003 = (long unsigned int) param;
    D.36004 = D.36003 * 8;
    D.36005 = D.36001 + D.36004;
    ainfo = *D.36005;
    if (ainfo == 0B) goto <D.36006>; else goto <D.36007>;
    <D.36006>:
    D.36002 = 0B;
    return D.36002;
    <D.36007>:
    D.36008 = ainfo->num_attrs;
    D.36009 = (long unsigned int) D.36008;
    D.36010 = (unsigned int) D.36009;
    D.36011 = D.36010 * 24;
    D.36012 = D.36011 + 16;
    size = (int) D.36012;
    D.36013 = (long unsigned int) size;
    res = monoeg_malloc0 (D.36013);
    D.36014 = (long unsigned int) size;
    memcpy (res, ainfo, D.36014);
    D.36002 = res;
    return D.36002;
  }
  <D.35996>:
  D.35991 = method->klass;
  image = D.35991->image;
  method_index = mono_method_get_index (method);
  if (method_index == 0) goto <D.36015>; else goto <D.36016>;
  <D.36015>:
  D.36002 = 0B;
  return D.36002;
  <D.36016>:
  ca = &image->tables[6];
  D.36017 = method_index + 4294967295;
  D.36018 = (int) D.36017;
  param_list = mono_metadata_decode_row_col (ca, D.36018, 5);
  D.36019 = ca->rows;
  D.36020 = (unsigned int) D.36019;
  if (D.36020 == method_index) goto <D.36021>; else goto <D.36022>;
  <D.36021>:
  ca = &image->tables[8];
  D.36019 = ca->rows;
  D.36023 = (int) D.36019;
  D.36024 = D.36023 + 1;
  param_last = (guint32) D.36024;
  goto <D.36025>;
  <D.36022>:
  method_index.441 = (int) method_index;
  param_last = mono_metadata_decode_row_col (ca, method_index.441, 5);
  ca = &image->tables[8];
  <D.36025>:
  found = 0;
  i = param_list;
  goto <D.22758>;
  <D.22757>:
  D.36027 = i + 4294967295;
  D.36028 = (int) D.36027;
  param_pos = mono_metadata_decode_row_col (ca, D.36028, 1);
  if (param_pos == param) goto <D.36029>; else goto <D.36030>;
  <D.36029>:
  found = 1;
  goto <D.22756>;
  <D.36030>:
  i = i + 1;
  <D.22758>:
  if (i < param_last) goto <D.22757>; else goto <D.22756>;
  <D.22756>:
  if (found == 0) goto <D.36031>; else goto <D.36032>;
  <D.36031>:
  D.36002 = 0B;
  return D.36002;
  <D.36032>:
  idx = i;
  idx = idx << 5;
  idx = idx | 4;
  D.36002 = mono_custom_attrs_from_index (image, idx);
  return D.36002;
}


mono_custom_attrs_has_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.36034;
  int D.36038;
  unsigned int D.36040;
  unsigned int D.36041;
  unsigned char D.36043;
  int D.36045;
  mono_bool D.36046;
  int D.36047;
  int i;
  struct MonoClass * klass;

  i = 0;
  goto <D.22766>;
  <D.22765>:
  D.36034 = ainfo->attrs[i].ctor;
  klass = D.36034->klass;
  D.36038 = mono_class_has_parent (klass, attr_klass);
  if (D.36038 != 0) goto <D.36035>; else goto <D.36039>;
  <D.36039>:
  D.36040 = attr_klass->flags;
  D.36041 = D.36040 & 32;
  if (D.36041 != 0) goto <D.36036>; else goto <D.36042>;
  <D.36042>:
  D.36043 = attr_klass->byval_arg.type;
  if (D.36043 == 19) goto <D.36036>; else goto <D.36044>;
  <D.36044>:
  D.36043 = attr_klass->byval_arg.type;
  if (D.36043 == 30) goto <D.36036>; else goto <D.36037>;
  <D.36036>:
  D.36045 = mono_class_is_assignable_from (attr_klass, klass);
  if (D.36045 != 0) goto <D.36035>; else goto <D.36037>;
  <D.36035>:
  D.36046 = 1;
  return D.36046;
  <D.36037>:
  i = i + 1;
  <D.22766>:
  D.36047 = ainfo->num_attrs;
  if (D.36047 > i) goto <D.22765>; else goto <D.22767>;
  <D.22767>:
  D.36046 = 0;
  return D.36046;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.36049;
  _Bool D.36050;
  long int D.36051;
  long int D.36052;
  struct MonoClass * * D.36055;
  _Bool D.36056;
  long int D.36057;
  long int D.36058;
  gboolean D.36061;

  D.36049 = klass->supertypes;
  D.36050 = D.36049 == 0B;
  D.36051 = (long int) D.36050;
  D.36052 = __builtin_expect (D.36051, 0);
  if (D.36052 != 0) goto <D.36053>; else goto <D.36054>;
  <D.36053>:
  mono_class_setup_supertypes (klass);
  <D.36054>:
  D.36055 = parent->supertypes;
  D.36056 = D.36055 == 0B;
  D.36057 = (long int) D.36056;
  D.36058 = __builtin_expect (D.36057, 0);
  if (D.36058 != 0) goto <D.36059>; else goto <D.36060>;
  <D.36059>:
  mono_class_setup_supertypes (parent);
  <D.36060>:
  D.36061 = mono_class_has_parent_fast (klass, parent);
  return D.36061;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.36063;
  int iftmp.442;
  short unsigned int D.36067;
  short unsigned int D.36068;
  struct MonoClass * * D.36070;
  long unsigned int D.36071;
  long unsigned int D.36072;
  sizetype D.36073;
  struct MonoClass * * D.36074;
  struct MonoClass * D.36075;

  D.36067 = klass->idepth;
  D.36068 = parent->idepth;
  if (D.36067 >= D.36068) goto <D.36069>; else goto <D.36065>;
  <D.36069>:
  D.36070 = klass->supertypes;
  D.36068 = parent->idepth;
  D.36071 = (long unsigned int) D.36068;
  D.36072 = D.36071 * 8;
  D.36073 = D.36072 + 18446744073709551608;
  D.36074 = D.36070 + D.36073;
  D.36075 = *D.36074;
  if (D.36075 == parent) goto <D.36076>; else goto <D.36065>;
  <D.36076>:
  iftmp.442 = 1;
  goto <D.36066>;
  <D.36065>:
  iftmp.442 = 0;
  <D.36066>:
  D.36063 = iftmp.442;
  return D.36063;
}


mono_custom_attrs_get_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.36078;
  int D.36079;
  int D.36082;
  struct MonoObject * D.36085;
  long unsigned int D.36088;
  char * D.36089;
  int i;
  int attr_index;
  struct MonoClass * klass;
  struct MonoArray * attrs;

  attr_index = -1;
  i = 0;
  goto <D.22778>;
  <D.22777>:
  D.36078 = ainfo->attrs[i].ctor;
  klass = D.36078->klass;
  D.36079 = mono_class_has_parent (klass, attr_klass);
  if (D.36079 != 0) goto <D.36080>; else goto <D.36081>;
  <D.36080>:
  attr_index = i;
  goto <D.22776>;
  <D.36081>:
  i = i + 1;
  <D.22778>:
  D.36082 = ainfo->num_attrs;
  if (D.36082 > i) goto <D.22777>; else goto <D.22776>;
  <D.22776>:
  if (attr_index == -1) goto <D.36083>; else goto <D.36084>;
  <D.36083>:
  D.36085 = 0B;
  return D.36085;
  <D.36084>:
  attrs = mono_custom_attrs_construct (ainfo);
  if (attrs != 0B) goto <D.36086>; else goto <D.36087>;
  <D.36086>:
  D.36088 = (long unsigned int) attr_index;
  D.36089 = mono_array_addr_with_size (attrs, 8, D.36088);
  D.36085 = MEM[(struct MonoObject * *)D.36089];
  return D.36085;
  <D.36087>:
  D.36085 = 0B;
  return D.36085;
}


mono_reflection_get_custom_attrs_info (struct MonoObject * obj)
{
  struct MonoVTable * D.36091;
  struct MonoClass * D.36092;
  int D.22793;
  int iftmp.443;
  int D.22789;
  const char[9] * D.36102;
  unsigned char D.36103;
  int D.36104;
  unsigned char D.36105;
  int D.36106;
  const unsigned char * D.36111;
  unsigned char D.36112;
  int D.36113;
  const unsigned char * D.36114;
  unsigned char D.36115;
  int D.36116;
  const unsigned char * D.36121;
  unsigned char D.36122;
  int D.36123;
  const unsigned char * D.36124;
  unsigned char D.36125;
  int D.36126;
  const unsigned char * D.36131;
  unsigned char D.36132;
  int D.36133;
  const unsigned char * D.36134;
  unsigned char D.36135;
  int D.36136;
  const char * D.36138;
  int D.22802;
  int iftmp.444;
  int D.22798;
  const char[13] * D.36143;
  unsigned char D.36144;
  int D.36145;
  unsigned char D.36146;
  int D.36147;
  const unsigned char * D.36152;
  unsigned char D.36153;
  int D.36154;
  const unsigned char * D.36155;
  unsigned char D.36156;
  int D.36157;
  const unsigned char * D.36162;
  unsigned char D.36163;
  int D.36164;
  const unsigned char * D.36165;
  unsigned char D.36166;
  int D.36167;
  const unsigned char * D.36172;
  unsigned char D.36173;
  int D.36174;
  const unsigned char * D.36175;
  unsigned char D.36176;
  int D.36177;
  struct MonoAssembly * D.36179;
  int D.22812;
  int iftmp.445;
  int D.22808;
  const char[7] * D.36186;
  unsigned char D.36187;
  int D.36188;
  unsigned char D.36189;
  int D.36190;
  const unsigned char * D.36195;
  unsigned char D.36196;
  int D.36197;
  const unsigned char * D.36198;
  unsigned char D.36199;
  int D.36200;
  const unsigned char * D.36205;
  unsigned char D.36206;
  int D.36207;
  const unsigned char * D.36208;
  unsigned char D.36209;
  int D.36210;
  const unsigned char * D.36215;
  unsigned char D.36216;
  int D.36217;
  const unsigned char * D.36218;
  unsigned char D.36219;
  int D.36220;
  int D.22821;
  int iftmp.446;
  int D.22817;
  const char[11] * D.36226;
  unsigned char D.36227;
  int D.36228;
  unsigned char D.36229;
  int D.36230;
  const unsigned char * D.36235;
  unsigned char D.36236;
  int D.36237;
  const unsigned char * D.36238;
  unsigned char D.36239;
  int D.36240;
  const unsigned char * D.36245;
  unsigned char D.36246;
  int D.36247;
  const unsigned char * D.36248;
  unsigned char D.36249;
  int D.36250;
  const unsigned char * D.36255;
  unsigned char D.36256;
  int D.36257;
  const unsigned char * D.36258;
  unsigned char D.36259;
  int D.36260;
  struct MonoImage * D.36262;
  int D.22831;
  int iftmp.447;
  int D.22827;
  const char[13] * D.36266;
  unsigned char D.36267;
  int D.36268;
  unsigned char D.36269;
  int D.36270;
  const unsigned char * D.36275;
  unsigned char D.36276;
  int D.36277;
  const unsigned char * D.36278;
  unsigned char D.36279;
  int D.36280;
  const unsigned char * D.36285;
  unsigned char D.36286;
  int D.36287;
  const unsigned char * D.36288;
  unsigned char D.36289;
  int D.36290;
  const unsigned char * D.36295;
  unsigned char D.36296;
  int D.36297;
  const unsigned char * D.36298;
  unsigned char D.36299;
  int D.36300;
  struct MonoProperty * D.36304;
  struct MonoClass * D.36305;
  int D.22841;
  int iftmp.448;
  int D.22837;
  const char[10] * D.36310;
  unsigned char D.36311;
  int D.36312;
  unsigned char D.36313;
  int D.36314;
  const unsigned char * D.36319;
  unsigned char D.36320;
  int D.36321;
  const unsigned char * D.36322;
  unsigned char D.36323;
  int D.36324;
  const unsigned char * D.36329;
  unsigned char D.36330;
  int D.36331;
  const unsigned char * D.36332;
  unsigned char D.36333;
  int D.36334;
  const unsigned char * D.36339;
  unsigned char D.36340;
  int D.36341;
  const unsigned char * D.36342;
  unsigned char D.36343;
  int D.36344;
  struct MonoEvent * D.36348;
  struct MonoClass * D.36349;
  int D.22851;
  int iftmp.449;
  int D.22847;
  const char[10] * D.36354;
  unsigned char D.36355;
  int D.36356;
  unsigned char D.36357;
  int D.36358;
  const unsigned char * D.36363;
  unsigned char D.36364;
  int D.36365;
  const unsigned char * D.36366;
  unsigned char D.36367;
  int D.36368;
  const unsigned char * D.36373;
  unsigned char D.36374;
  int D.36375;
  const unsigned char * D.36376;
  unsigned char D.36377;
  int D.36378;
  const unsigned char * D.36383;
  unsigned char D.36384;
  int D.36385;
  const unsigned char * D.36386;
  unsigned char D.36387;
  int D.36388;
  struct MonoClassField * D.36392;
  struct MonoClass * D.36393;
  int D.22861;
  int iftmp.450;
  int D.22857;
  const char[11] * D.36401;
  unsigned char D.36402;
  int D.36403;
  unsigned char D.36404;
  int D.36405;
  const unsigned char * D.36410;
  unsigned char D.36411;
  int D.36412;
  const unsigned char * D.36413;
  unsigned char D.36414;
  int D.36415;
  const unsigned char * D.36420;
  unsigned char D.36421;
  int D.36422;
  const unsigned char * D.36423;
  unsigned char D.36424;
  int D.36425;
  const unsigned char * D.36430;
  unsigned char D.36431;
  int D.36432;
  const unsigned char * D.36433;
  unsigned char D.36434;
  int D.36435;
  int D.22870;
  int iftmp.451;
  int D.22866;
  const char[12] * D.36441;
  unsigned char D.36442;
  int D.36443;
  unsigned char D.36444;
  int D.36445;
  const unsigned char * D.36450;
  unsigned char D.36451;
  int D.36452;
  const unsigned char * D.36453;
  unsigned char D.36454;
  int D.36455;
  const unsigned char * D.36460;
  unsigned char D.36461;
  int D.36462;
  const unsigned char * D.36463;
  unsigned char D.36464;
  int D.36465;
  const unsigned char * D.36470;
  unsigned char D.36471;
  int D.36472;
  const unsigned char * D.36473;
  unsigned char D.36474;
  int D.36475;
  struct MonoMethod * D.36477;
  int D.22880;
  int iftmp.452;
  int D.22876;
  const char[18] * D.36484;
  unsigned char D.36485;
  int D.36486;
  unsigned char D.36487;
  int D.36488;
  const unsigned char * D.36493;
  unsigned char D.36494;
  int D.36495;
  const unsigned char * D.36496;
  unsigned char D.36497;
  int D.36498;
  const unsigned char * D.36503;
  unsigned char D.36504;
  int D.36505;
  const unsigned char * D.36506;
  unsigned char D.36507;
  int D.36508;
  const unsigned char * D.36513;
  unsigned char D.36514;
  int D.36515;
  const unsigned char * D.36516;
  unsigned char D.36517;
  int D.36518;
  int D.22889;
  int iftmp.453;
  int D.22885;
  const char[19] * D.36524;
  unsigned char D.36525;
  int D.36526;
  unsigned char D.36527;
  int D.36528;
  const unsigned char * D.36533;
  unsigned char D.36534;
  int D.36535;
  const unsigned char * D.36536;
  unsigned char D.36537;
  int D.36538;
  const unsigned char * D.36543;
  unsigned char D.36544;
  int D.36545;
  const unsigned char * D.36546;
  unsigned char D.36547;
  int D.36548;
  const unsigned char * D.36553;
  unsigned char D.36554;
  int D.36555;
  const unsigned char * D.36556;
  unsigned char D.36557;
  int D.36558;
  struct MonoMethod * D.36560;
  int D.22899;
  int iftmp.454;
  int D.22895;
  const char[14] * D.36567;
  unsigned char D.36568;
  int D.36569;
  unsigned char D.36570;
  int D.36571;
  const unsigned char * D.36576;
  unsigned char D.36577;
  int D.36578;
  const unsigned char * D.36579;
  unsigned char D.36580;
  int D.36581;
  const unsigned char * D.36586;
  unsigned char D.36587;
  int D.36588;
  const unsigned char * D.36589;
  unsigned char D.36590;
  int D.36591;
  const unsigned char * D.36596;
  unsigned char D.36597;
  int D.36598;
  const unsigned char * D.36599;
  unsigned char D.36600;
  int D.36601;
  int D.22908;
  int iftmp.455;
  int D.22904;
  const char[18] * D.36607;
  unsigned char D.36608;
  int D.36609;
  unsigned char D.36610;
  int D.36611;
  const unsigned char * D.36616;
  unsigned char D.36617;
  int D.36618;
  const unsigned char * D.36619;
  unsigned char D.36620;
  int D.36621;
  const unsigned char * D.36626;
  unsigned char D.36627;
  int D.36628;
  const unsigned char * D.36629;
  unsigned char D.36630;
  int D.36631;
  const unsigned char * D.36636;
  unsigned char D.36637;
  int D.36638;
  const unsigned char * D.36639;
  unsigned char D.36640;
  int D.36641;
  struct MonoObject * D.36643;
  struct MonoVTable * D.36644;
  int D.36645;
  struct MonoMethod * D.36648;
  int D.36649;
  int D.36650;
  unsigned int D.36651;
  int D.36653;
  struct MonoProperty * D.36656;
  _Bool D.36659;
  long int D.36660;
  long int D.36661;
  int D.36665;
  int D.36669;
  struct MonoObject * D.36672;
  struct MonoVTable * D.36673;
  struct MonoClass * D.36674;
  int D.36675;
  int D.36679;
  char * D.36683;
  int D.22929;
  int iftmp.456;
  int D.22925;
  const char[16] * D.36688;
  unsigned char D.36689;
  int D.36690;
  unsigned char D.36691;
  int D.36692;
  const unsigned char * D.36697;
  unsigned char D.36698;
  int D.36699;
  const unsigned char * D.36700;
  unsigned char D.36701;
  int D.36702;
  const unsigned char * D.36707;
  unsigned char D.36708;
  int D.36709;
  const unsigned char * D.36710;
  unsigned char D.36711;
  int D.36712;
  const unsigned char * D.36717;
  unsigned char D.36718;
  int D.36719;
  const unsigned char * D.36720;
  unsigned char D.36721;
  int D.36722;
  struct MonoAssembly * D.36726;
  struct MonoImage * D.36727;
  struct MonoArray * D.36728;
  int D.22939;
  int iftmp.457;
  int D.22935;
  const char[12] * D.36733;
  unsigned char D.36734;
  int D.36735;
  unsigned char D.36736;
  int D.36737;
  const unsigned char * D.36742;
  unsigned char D.36743;
  int D.36744;
  const unsigned char * D.36745;
  unsigned char D.36746;
  int D.36747;
  const unsigned char * D.36752;
  unsigned char D.36753;
  int D.36754;
  const unsigned char * D.36755;
  unsigned char D.36756;
  int D.36757;
  const unsigned char * D.36762;
  unsigned char D.36763;
  int D.36764;
  const unsigned char * D.36765;
  unsigned char D.36766;
  int D.36767;
  struct MonoReflectionModuleBuilder * D.36771;
  struct MonoDynamicImage * D.36772;
  struct MonoImage * D.36773;
  struct MonoArray * D.36774;
  int D.22949;
  int iftmp.458;
  int D.22945;
  const char[14] * D.36779;
  unsigned char D.36780;
  int D.36781;
  unsigned char D.36782;
  int D.36783;
  const unsigned char * D.36788;
  unsigned char D.36789;
  int D.36790;
  const unsigned char * D.36791;
  unsigned char D.36792;
  int D.36793;
  const unsigned char * D.36798;
  unsigned char D.36799;
  int D.36800;
  const unsigned char * D.36801;
  unsigned char D.36802;
  int D.36803;
  const unsigned char * D.36808;
  unsigned char D.36809;
  int D.36810;
  const unsigned char * D.36811;
  unsigned char D.36812;
  int D.36813;
  struct MonoDynamicImage * D.36817;
  struct MonoImage * D.36818;
  struct MonoArray * D.36819;
  int D.22959;
  int iftmp.459;
  int D.22955;
  const char[19] * D.36824;
  unsigned char D.36825;
  int D.36826;
  unsigned char D.36827;
  int D.36828;
  const unsigned char * D.36833;
  unsigned char D.36834;
  int D.36835;
  const unsigned char * D.36836;
  unsigned char D.36837;
  int D.36838;
  const unsigned char * D.36843;
  unsigned char D.36844;
  int D.36845;
  const unsigned char * D.36846;
  unsigned char D.36847;
  int D.36848;
  const unsigned char * D.36853;
  unsigned char D.36854;
  int D.36855;
  const unsigned char * D.36856;
  unsigned char D.36857;
  int D.36858;
  struct MonoMethod * D.36862;
  struct MonoClass * D.36863;
  struct MonoImage * D.36864;
  struct MonoArray * D.36865;
  int D.22969;
  int iftmp.460;
  int D.22965;
  const char[14] * D.36870;
  unsigned char D.36871;
  int D.36872;
  unsigned char D.36873;
  int D.36874;
  const unsigned char * D.36879;
  unsigned char D.36880;
  int D.36881;
  const unsigned char * D.36882;
  unsigned char D.36883;
  int D.36884;
  const unsigned char * D.36889;
  unsigned char D.36890;
  int D.36891;
  const unsigned char * D.36892;
  unsigned char D.36893;
  int D.36894;
  const unsigned char * D.36899;
  unsigned char D.36900;
  int D.36901;
  const unsigned char * D.36902;
  unsigned char D.36903;
  int D.36904;
  struct MonoMethod * D.36908;
  struct MonoClass * D.36909;
  struct MonoImage * D.36910;
  struct MonoArray * D.36911;
  int D.22979;
  int iftmp.461;
  int D.22975;
  const char[13] * D.36916;
  unsigned char D.36917;
  int D.36918;
  unsigned char D.36919;
  int D.36920;
  const unsigned char * D.36925;
  unsigned char D.36926;
  int D.36927;
  const unsigned char * D.36928;
  unsigned char D.36929;
  int D.36930;
  const unsigned char * D.36935;
  unsigned char D.36936;
  int D.36937;
  const unsigned char * D.36938;
  unsigned char D.36939;
  int D.36940;
  const unsigned char * D.36945;
  unsigned char D.36946;
  int D.36947;
  const unsigned char * D.36948;
  unsigned char D.36949;
  int D.36950;
  struct MonoReflectionType * D.36954;
  struct MonoReflectionModuleBuilder * D.36955;
  struct MonoDynamicImage * D.36956;
  struct MonoImage * D.36957;
  struct MonoArray * D.36958;
  int D.22989;
  int iftmp.462;
  int D.22985;
  const char[17] * D.36963;
  unsigned char D.36964;
  int D.36965;
  unsigned char D.36966;
  int D.36967;
  const unsigned char * D.36972;
  unsigned char D.36973;
  int D.36974;
  const unsigned char * D.36975;
  unsigned char D.36976;
  int D.36977;
  const unsigned char * D.36982;
  unsigned char D.36983;
  int D.36984;
  const unsigned char * D.36985;
  unsigned char D.36986;
  int D.36987;
  const unsigned char * D.36992;
  unsigned char D.36993;
  int D.36994;
  const unsigned char * D.36995;
  unsigned char D.36996;
  int D.36997;
  struct MonoReflectionType * D.37001;
  struct MonoCustomAttrInfo * D.37003;
  struct MonoClass * klass;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = 0B;
  D.36091 = obj->vtable;
  klass = D.36091->klass;
  D.36092 = mono_defaults.monotype_class;
  if (D.36092 == klass) goto <D.36093>; else goto <D.36094>;
  <D.36093>:
  {
    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.36095>;
  <D.36094>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.36100>; else goto <D.36101>;
    <D.36100>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.36102 = "Assembly";
      D.36103 = MEM[(const unsigned char *)D.36102];
      D.36104 = (int) D.36103;
      D.36105 = *__s2;
      D.36106 = (int) D.36105;
      __result = D.36104 - D.36106;
      {
        if (__s1_len != 0) goto <D.36107>; else goto <D.36108>;
        <D.36107>:
        if (__result == 0) goto <D.36109>; else goto <D.36110>;
        <D.36109>:
        D.36111 = &MEM[(void *)"Assembly" + 1B];
        D.36112 = *D.36111;
        D.36113 = (int) D.36112;
        D.36114 = __s2 + 1;
        D.36115 = *D.36114;
        D.36116 = (int) D.36115;
        __result = D.36113 - D.36116;
        if (__s1_len > 1) goto <D.36117>; else goto <D.36118>;
        <D.36117>:
        if (__result == 0) goto <D.36119>; else goto <D.36120>;
        <D.36119>:
        D.36121 = &MEM[(void *)"Assembly" + 2B];
        D.36122 = *D.36121;
        D.36123 = (int) D.36122;
        D.36124 = __s2 + 2;
        D.36125 = *D.36124;
        D.36126 = (int) D.36125;
        __result = D.36123 - D.36126;
        if (__s1_len > 2) goto <D.36127>; else goto <D.36128>;
        <D.36127>:
        if (__result == 0) goto <D.36129>; else goto <D.36130>;
        <D.36129>:
        D.36131 = &MEM[(void *)"Assembly" + 3B];
        D.36132 = *D.36131;
        D.36133 = (int) D.36132;
        D.36134 = __s2 + 3;
        D.36135 = *D.36134;
        D.36136 = (int) D.36135;
        __result = D.36133 - D.36136;
        <D.36130>:
        <D.36128>:
        <D.36120>:
        <D.36118>:
        <D.36110>:
        <D.36108>:
      }
      D.22789 = __result;
    }
    iftmp.443 = D.22789;
    goto <D.36137>;
    <D.36101>:
    D.36138 = klass->name;
    iftmp.443 = __builtin_strcmp ("Assembly", D.36138);
    <D.36137>:
    D.22793 = iftmp.443;
  }
  if (D.22793 == 0) goto <D.36096>; else goto <D.36139>;
  <D.36139>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36143 = "MonoAssembly";
      D.36144 = MEM[(const unsigned char *)D.36143];
      D.36145 = (int) D.36144;
      D.36146 = *__s2;
      D.36147 = (int) D.36146;
      __result = D.36145 - D.36147;
      {
        if (__s1_len != 0) goto <D.36148>; else goto <D.36149>;
        <D.36148>:
        if (__result == 0) goto <D.36150>; else goto <D.36151>;
        <D.36150>:
        D.36152 = &MEM[(void *)"MonoAssembly" + 1B];
        D.36153 = *D.36152;
        D.36154 = (int) D.36153;
        D.36155 = __s2 + 1;
        D.36156 = *D.36155;
        D.36157 = (int) D.36156;
        __result = D.36154 - D.36157;
        if (__s1_len > 1) goto <D.36158>; else goto <D.36159>;
        <D.36158>:
        if (__result == 0) goto <D.36160>; else goto <D.36161>;
        <D.36160>:
        D.36162 = &MEM[(void *)"MonoAssembly" + 2B];
        D.36163 = *D.36162;
        D.36164 = (int) D.36163;
        D.36165 = __s2 + 2;
        D.36166 = *D.36165;
        D.36167 = (int) D.36166;
        __result = D.36164 - D.36167;
        if (__s1_len > 2) goto <D.36168>; else goto <D.36169>;
        <D.36168>:
        if (__result == 0) goto <D.36170>; else goto <D.36171>;
        <D.36170>:
        D.36172 = &MEM[(void *)"MonoAssembly" + 3B];
        D.36173 = *D.36172;
        D.36174 = (int) D.36173;
        D.36175 = __s2 + 3;
        D.36176 = *D.36175;
        D.36177 = (int) D.36176;
        __result = D.36174 - D.36177;
        <D.36171>:
        <D.36169>:
        <D.36161>:
        <D.36159>:
        <D.36151>:
        <D.36149>:
      }
      D.22798 = __result;
    }
    iftmp.444 = D.22798;
    goto <D.36178>;
    <D.36142>:
    D.36138 = klass->name;
    iftmp.444 = __builtin_strcmp ("MonoAssembly", D.36138);
    <D.36178>:
    D.22802 = iftmp.444;
  }
  if (D.22802 == 0) goto <D.36096>; else goto <D.36097>;
  <D.36096>:
  {
    struct MonoReflectionAssembly * rassembly;

    rassembly = obj;
    D.36179 = rassembly->assembly;
    cinfo = mono_custom_attrs_from_assembly (D.36179);
  }
  goto <D.36098>;
  <D.36097>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36186 = "Module";
      D.36187 = MEM[(const unsigned char *)D.36186];
      D.36188 = (int) D.36187;
      D.36189 = *__s2;
      D.36190 = (int) D.36189;
      __result = D.36188 - D.36190;
      {
        if (__s1_len != 0) goto <D.36191>; else goto <D.36192>;
        <D.36191>:
        if (__result == 0) goto <D.36193>; else goto <D.36194>;
        <D.36193>:
        D.36195 = &MEM[(void *)"Module" + 1B];
        D.36196 = *D.36195;
        D.36197 = (int) D.36196;
        D.36198 = __s2 + 1;
        D.36199 = *D.36198;
        D.36200 = (int) D.36199;
        __result = D.36197 - D.36200;
        if (__s1_len > 1) goto <D.36201>; else goto <D.36202>;
        <D.36201>:
        if (__result == 0) goto <D.36203>; else goto <D.36204>;
        <D.36203>:
        D.36205 = &MEM[(void *)"Module" + 2B];
        D.36206 = *D.36205;
        D.36207 = (int) D.36206;
        D.36208 = __s2 + 2;
        D.36209 = *D.36208;
        D.36210 = (int) D.36209;
        __result = D.36207 - D.36210;
        if (__s1_len > 2) goto <D.36211>; else goto <D.36212>;
        <D.36211>:
        if (__result == 0) goto <D.36213>; else goto <D.36214>;
        <D.36213>:
        D.36215 = &MEM[(void *)"Module" + 3B];
        D.36216 = *D.36215;
        D.36217 = (int) D.36216;
        D.36218 = __s2 + 3;
        D.36219 = *D.36218;
        D.36220 = (int) D.36219;
        __result = D.36217 - D.36220;
        <D.36214>:
        <D.36212>:
        <D.36204>:
        <D.36202>:
        <D.36194>:
        <D.36192>:
      }
      D.22808 = __result;
    }
    iftmp.445 = D.22808;
    goto <D.36221>;
    <D.36185>:
    D.36138 = klass->name;
    iftmp.445 = __builtin_strcmp ("Module", D.36138);
    <D.36221>:
    D.22812 = iftmp.445;
  }
  if (D.22812 == 0) goto <D.36180>; else goto <D.36222>;
  <D.36222>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36226 = "MonoModule";
      D.36227 = MEM[(const unsigned char *)D.36226];
      D.36228 = (int) D.36227;
      D.36229 = *__s2;
      D.36230 = (int) D.36229;
      __result = D.36228 - D.36230;
      {
        if (__s1_len != 0) goto <D.36231>; else goto <D.36232>;
        <D.36231>:
        if (__result == 0) goto <D.36233>; else goto <D.36234>;
        <D.36233>:
        D.36235 = &MEM[(void *)"MonoModule" + 1B];
        D.36236 = *D.36235;
        D.36237 = (int) D.36236;
        D.36238 = __s2 + 1;
        D.36239 = *D.36238;
        D.36240 = (int) D.36239;
        __result = D.36237 - D.36240;
        if (__s1_len > 1) goto <D.36241>; else goto <D.36242>;
        <D.36241>:
        if (__result == 0) goto <D.36243>; else goto <D.36244>;
        <D.36243>:
        D.36245 = &MEM[(void *)"MonoModule" + 2B];
        D.36246 = *D.36245;
        D.36247 = (int) D.36246;
        D.36248 = __s2 + 2;
        D.36249 = *D.36248;
        D.36250 = (int) D.36249;
        __result = D.36247 - D.36250;
        if (__s1_len > 2) goto <D.36251>; else goto <D.36252>;
        <D.36251>:
        if (__result == 0) goto <D.36253>; else goto <D.36254>;
        <D.36253>:
        D.36255 = &MEM[(void *)"MonoModule" + 3B];
        D.36256 = *D.36255;
        D.36257 = (int) D.36256;
        D.36258 = __s2 + 3;
        D.36259 = *D.36258;
        D.36260 = (int) D.36259;
        __result = D.36257 - D.36260;
        <D.36254>:
        <D.36252>:
        <D.36244>:
        <D.36242>:
        <D.36234>:
        <D.36232>:
      }
      D.22817 = __result;
    }
    iftmp.446 = D.22817;
    goto <D.36261>;
    <D.36225>:
    D.36138 = klass->name;
    iftmp.446 = __builtin_strcmp ("MonoModule", D.36138);
    <D.36261>:
    D.22821 = iftmp.446;
  }
  if (D.22821 == 0) goto <D.36180>; else goto <D.36181>;
  <D.36180>:
  {
    struct MonoReflectionModule * module;

    module = obj;
    D.36262 = module->image;
    cinfo = mono_custom_attrs_from_module (D.36262);
  }
  goto <D.36182>;
  <D.36181>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36266 = "MonoProperty";
      D.36267 = MEM[(const unsigned char *)D.36266];
      D.36268 = (int) D.36267;
      D.36269 = *__s2;
      D.36270 = (int) D.36269;
      __result = D.36268 - D.36270;
      {
        if (__s1_len != 0) goto <D.36271>; else goto <D.36272>;
        <D.36271>:
        if (__result == 0) goto <D.36273>; else goto <D.36274>;
        <D.36273>:
        D.36275 = &MEM[(void *)"MonoProperty" + 1B];
        D.36276 = *D.36275;
        D.36277 = (int) D.36276;
        D.36278 = __s2 + 1;
        D.36279 = *D.36278;
        D.36280 = (int) D.36279;
        __result = D.36277 - D.36280;
        if (__s1_len > 1) goto <D.36281>; else goto <D.36282>;
        <D.36281>:
        if (__result == 0) goto <D.36283>; else goto <D.36284>;
        <D.36283>:
        D.36285 = &MEM[(void *)"MonoProperty" + 2B];
        D.36286 = *D.36285;
        D.36287 = (int) D.36286;
        D.36288 = __s2 + 2;
        D.36289 = *D.36288;
        D.36290 = (int) D.36289;
        __result = D.36287 - D.36290;
        if (__s1_len > 2) goto <D.36291>; else goto <D.36292>;
        <D.36291>:
        if (__result == 0) goto <D.36293>; else goto <D.36294>;
        <D.36293>:
        D.36295 = &MEM[(void *)"MonoProperty" + 3B];
        D.36296 = *D.36295;
        D.36297 = (int) D.36296;
        D.36298 = __s2 + 3;
        D.36299 = *D.36298;
        D.36300 = (int) D.36299;
        __result = D.36297 - D.36300;
        <D.36294>:
        <D.36292>:
        <D.36284>:
        <D.36282>:
        <D.36274>:
        <D.36272>:
      }
      D.22827 = __result;
    }
    iftmp.447 = D.22827;
    goto <D.36301>;
    <D.36265>:
    D.36138 = klass->name;
    iftmp.447 = __builtin_strcmp ("MonoProperty", D.36138);
    <D.36301>:
    D.22831 = iftmp.447;
  }
  if (D.22831 == 0) goto <D.36302>; else goto <D.36303>;
  <D.36302>:
  {
    struct MonoReflectionProperty * rprop;

    rprop = obj;
    D.36304 = rprop->property;
    D.36305 = D.36304->parent;
    D.36304 = rprop->property;
    cinfo = mono_custom_attrs_from_property (D.36305, D.36304);
  }
  goto <D.36306>;
  <D.36303>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36310 = "MonoEvent";
      D.36311 = MEM[(const unsigned char *)D.36310];
      D.36312 = (int) D.36311;
      D.36313 = *__s2;
      D.36314 = (int) D.36313;
      __result = D.36312 - D.36314;
      {
        if (__s1_len != 0) goto <D.36315>; else goto <D.36316>;
        <D.36315>:
        if (__result == 0) goto <D.36317>; else goto <D.36318>;
        <D.36317>:
        D.36319 = &MEM[(void *)"MonoEvent" + 1B];
        D.36320 = *D.36319;
        D.36321 = (int) D.36320;
        D.36322 = __s2 + 1;
        D.36323 = *D.36322;
        D.36324 = (int) D.36323;
        __result = D.36321 - D.36324;
        if (__s1_len > 1) goto <D.36325>; else goto <D.36326>;
        <D.36325>:
        if (__result == 0) goto <D.36327>; else goto <D.36328>;
        <D.36327>:
        D.36329 = &MEM[(void *)"MonoEvent" + 2B];
        D.36330 = *D.36329;
        D.36331 = (int) D.36330;
        D.36332 = __s2 + 2;
        D.36333 = *D.36332;
        D.36334 = (int) D.36333;
        __result = D.36331 - D.36334;
        if (__s1_len > 2) goto <D.36335>; else goto <D.36336>;
        <D.36335>:
        if (__result == 0) goto <D.36337>; else goto <D.36338>;
        <D.36337>:
        D.36339 = &MEM[(void *)"MonoEvent" + 3B];
        D.36340 = *D.36339;
        D.36341 = (int) D.36340;
        D.36342 = __s2 + 3;
        D.36343 = *D.36342;
        D.36344 = (int) D.36343;
        __result = D.36341 - D.36344;
        <D.36338>:
        <D.36336>:
        <D.36328>:
        <D.36326>:
        <D.36318>:
        <D.36316>:
      }
      D.22837 = __result;
    }
    iftmp.448 = D.22837;
    goto <D.36345>;
    <D.36309>:
    D.36138 = klass->name;
    iftmp.448 = __builtin_strcmp ("MonoEvent", D.36138);
    <D.36345>:
    D.22841 = iftmp.448;
  }
  if (D.22841 == 0) goto <D.36346>; else goto <D.36347>;
  <D.36346>:
  {
    struct MonoReflectionMonoEvent * revent;

    revent = obj;
    D.36348 = revent->event;
    D.36349 = D.36348->parent;
    D.36348 = revent->event;
    cinfo = mono_custom_attrs_from_event (D.36349, D.36348);
  }
  goto <D.36350>;
  <D.36347>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36354 = "MonoField";
      D.36355 = MEM[(const unsigned char *)D.36354];
      D.36356 = (int) D.36355;
      D.36357 = *__s2;
      D.36358 = (int) D.36357;
      __result = D.36356 - D.36358;
      {
        if (__s1_len != 0) goto <D.36359>; else goto <D.36360>;
        <D.36359>:
        if (__result == 0) goto <D.36361>; else goto <D.36362>;
        <D.36361>:
        D.36363 = &MEM[(void *)"MonoField" + 1B];
        D.36364 = *D.36363;
        D.36365 = (int) D.36364;
        D.36366 = __s2 + 1;
        D.36367 = *D.36366;
        D.36368 = (int) D.36367;
        __result = D.36365 - D.36368;
        if (__s1_len > 1) goto <D.36369>; else goto <D.36370>;
        <D.36369>:
        if (__result == 0) goto <D.36371>; else goto <D.36372>;
        <D.36371>:
        D.36373 = &MEM[(void *)"MonoField" + 2B];
        D.36374 = *D.36373;
        D.36375 = (int) D.36374;
        D.36376 = __s2 + 2;
        D.36377 = *D.36376;
        D.36378 = (int) D.36377;
        __result = D.36375 - D.36378;
        if (__s1_len > 2) goto <D.36379>; else goto <D.36380>;
        <D.36379>:
        if (__result == 0) goto <D.36381>; else goto <D.36382>;
        <D.36381>:
        D.36383 = &MEM[(void *)"MonoField" + 3B];
        D.36384 = *D.36383;
        D.36385 = (int) D.36384;
        D.36386 = __s2 + 3;
        D.36387 = *D.36386;
        D.36388 = (int) D.36387;
        __result = D.36385 - D.36388;
        <D.36382>:
        <D.36380>:
        <D.36372>:
        <D.36370>:
        <D.36362>:
        <D.36360>:
      }
      D.22847 = __result;
    }
    iftmp.449 = D.22847;
    goto <D.36389>;
    <D.36353>:
    D.36138 = klass->name;
    iftmp.449 = __builtin_strcmp ("MonoField", D.36138);
    <D.36389>:
    D.22851 = iftmp.449;
  }
  if (D.22851 == 0) goto <D.36390>; else goto <D.36391>;
  <D.36390>:
  {
    struct MonoReflectionField * rfield;

    rfield = obj;
    D.36392 = rfield->field;
    D.36393 = D.36392->parent;
    D.36392 = rfield->field;
    cinfo = mono_custom_attrs_from_field (D.36393, D.36392);
  }
  goto <D.36394>;
  <D.36391>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36401 = "MonoMethod";
      D.36402 = MEM[(const unsigned char *)D.36401];
      D.36403 = (int) D.36402;
      D.36404 = *__s2;
      D.36405 = (int) D.36404;
      __result = D.36403 - D.36405;
      {
        if (__s1_len != 0) goto <D.36406>; else goto <D.36407>;
        <D.36406>:
        if (__result == 0) goto <D.36408>; else goto <D.36409>;
        <D.36408>:
        D.36410 = &MEM[(void *)"MonoMethod" + 1B];
        D.36411 = *D.36410;
        D.36412 = (int) D.36411;
        D.36413 = __s2 + 1;
        D.36414 = *D.36413;
        D.36415 = (int) D.36414;
        __result = D.36412 - D.36415;
        if (__s1_len > 1) goto <D.36416>; else goto <D.36417>;
        <D.36416>:
        if (__result == 0) goto <D.36418>; else goto <D.36419>;
        <D.36418>:
        D.36420 = &MEM[(void *)"MonoMethod" + 2B];
        D.36421 = *D.36420;
        D.36422 = (int) D.36421;
        D.36423 = __s2 + 2;
        D.36424 = *D.36423;
        D.36425 = (int) D.36424;
        __result = D.36422 - D.36425;
        if (__s1_len > 2) goto <D.36426>; else goto <D.36427>;
        <D.36426>:
        if (__result == 0) goto <D.36428>; else goto <D.36429>;
        <D.36428>:
        D.36430 = &MEM[(void *)"MonoMethod" + 3B];
        D.36431 = *D.36430;
        D.36432 = (int) D.36431;
        D.36433 = __s2 + 3;
        D.36434 = *D.36433;
        D.36435 = (int) D.36434;
        __result = D.36432 - D.36435;
        <D.36429>:
        <D.36427>:
        <D.36419>:
        <D.36417>:
        <D.36409>:
        <D.36407>:
      }
      D.22857 = __result;
    }
    iftmp.450 = D.22857;
    goto <D.36436>;
    <D.36400>:
    D.36138 = klass->name;
    iftmp.450 = __builtin_strcmp ("MonoMethod", D.36138);
    <D.36436>:
    D.22861 = iftmp.450;
  }
  if (D.22861 == 0) goto <D.36395>; else goto <D.36437>;
  <D.36437>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36441 = "MonoCMethod";
      D.36442 = MEM[(const unsigned char *)D.36441];
      D.36443 = (int) D.36442;
      D.36444 = *__s2;
      D.36445 = (int) D.36444;
      __result = D.36443 - D.36445;
      {
        if (__s1_len != 0) goto <D.36446>; else goto <D.36447>;
        <D.36446>:
        if (__result == 0) goto <D.36448>; else goto <D.36449>;
        <D.36448>:
        D.36450 = &MEM[(void *)"MonoCMethod" + 1B];
        D.36451 = *D.36450;
        D.36452 = (int) D.36451;
        D.36453 = __s2 + 1;
        D.36454 = *D.36453;
        D.36455 = (int) D.36454;
        __result = D.36452 - D.36455;
        if (__s1_len > 1) goto <D.36456>; else goto <D.36457>;
        <D.36456>:
        if (__result == 0) goto <D.36458>; else goto <D.36459>;
        <D.36458>:
        D.36460 = &MEM[(void *)"MonoCMethod" + 2B];
        D.36461 = *D.36460;
        D.36462 = (int) D.36461;
        D.36463 = __s2 + 2;
        D.36464 = *D.36463;
        D.36465 = (int) D.36464;
        __result = D.36462 - D.36465;
        if (__s1_len > 2) goto <D.36466>; else goto <D.36467>;
        <D.36466>:
        if (__result == 0) goto <D.36468>; else goto <D.36469>;
        <D.36468>:
        D.36470 = &MEM[(void *)"MonoCMethod" + 3B];
        D.36471 = *D.36470;
        D.36472 = (int) D.36471;
        D.36473 = __s2 + 3;
        D.36474 = *D.36473;
        D.36475 = (int) D.36474;
        __result = D.36472 - D.36475;
        <D.36469>:
        <D.36467>:
        <D.36459>:
        <D.36457>:
        <D.36449>:
        <D.36447>:
      }
      D.22866 = __result;
    }
    iftmp.451 = D.22866;
    goto <D.36476>;
    <D.36440>:
    D.36138 = klass->name;
    iftmp.451 = __builtin_strcmp ("MonoCMethod", D.36138);
    <D.36476>:
    D.22870 = iftmp.451;
  }
  if (D.22870 == 0) goto <D.36395>; else goto <D.36396>;
  <D.36395>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.36477 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.36477);
  }
  goto <D.36397>;
  <D.36396>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36484 = "MonoGenericMethod";
      D.36485 = MEM[(const unsigned char *)D.36484];
      D.36486 = (int) D.36485;
      D.36487 = *__s2;
      D.36488 = (int) D.36487;
      __result = D.36486 - D.36488;
      {
        if (__s1_len != 0) goto <D.36489>; else goto <D.36490>;
        <D.36489>:
        if (__result == 0) goto <D.36491>; else goto <D.36492>;
        <D.36491>:
        D.36493 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.36494 = *D.36493;
        D.36495 = (int) D.36494;
        D.36496 = __s2 + 1;
        D.36497 = *D.36496;
        D.36498 = (int) D.36497;
        __result = D.36495 - D.36498;
        if (__s1_len > 1) goto <D.36499>; else goto <D.36500>;
        <D.36499>:
        if (__result == 0) goto <D.36501>; else goto <D.36502>;
        <D.36501>:
        D.36503 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.36504 = *D.36503;
        D.36505 = (int) D.36504;
        D.36506 = __s2 + 2;
        D.36507 = *D.36506;
        D.36508 = (int) D.36507;
        __result = D.36505 - D.36508;
        if (__s1_len > 2) goto <D.36509>; else goto <D.36510>;
        <D.36509>:
        if (__result == 0) goto <D.36511>; else goto <D.36512>;
        <D.36511>:
        D.36513 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.36514 = *D.36513;
        D.36515 = (int) D.36514;
        D.36516 = __s2 + 3;
        D.36517 = *D.36516;
        D.36518 = (int) D.36517;
        __result = D.36515 - D.36518;
        <D.36512>:
        <D.36510>:
        <D.36502>:
        <D.36500>:
        <D.36492>:
        <D.36490>:
      }
      D.22876 = __result;
    }
    iftmp.452 = D.22876;
    goto <D.36519>;
    <D.36483>:
    D.36138 = klass->name;
    iftmp.452 = __builtin_strcmp ("MonoGenericMethod", D.36138);
    <D.36519>:
    D.22880 = iftmp.452;
  }
  if (D.22880 == 0) goto <D.36478>; else goto <D.36520>;
  <D.36520>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36524 = "MonoGenericCMethod";
      D.36525 = MEM[(const unsigned char *)D.36524];
      D.36526 = (int) D.36525;
      D.36527 = *__s2;
      D.36528 = (int) D.36527;
      __result = D.36526 - D.36528;
      {
        if (__s1_len != 0) goto <D.36529>; else goto <D.36530>;
        <D.36529>:
        if (__result == 0) goto <D.36531>; else goto <D.36532>;
        <D.36531>:
        D.36533 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.36534 = *D.36533;
        D.36535 = (int) D.36534;
        D.36536 = __s2 + 1;
        D.36537 = *D.36536;
        D.36538 = (int) D.36537;
        __result = D.36535 - D.36538;
        if (__s1_len > 1) goto <D.36539>; else goto <D.36540>;
        <D.36539>:
        if (__result == 0) goto <D.36541>; else goto <D.36542>;
        <D.36541>:
        D.36543 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.36544 = *D.36543;
        D.36545 = (int) D.36544;
        D.36546 = __s2 + 2;
        D.36547 = *D.36546;
        D.36548 = (int) D.36547;
        __result = D.36545 - D.36548;
        if (__s1_len > 2) goto <D.36549>; else goto <D.36550>;
        <D.36549>:
        if (__result == 0) goto <D.36551>; else goto <D.36552>;
        <D.36551>:
        D.36553 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.36554 = *D.36553;
        D.36555 = (int) D.36554;
        D.36556 = __s2 + 3;
        D.36557 = *D.36556;
        D.36558 = (int) D.36557;
        __result = D.36555 - D.36558;
        <D.36552>:
        <D.36550>:
        <D.36542>:
        <D.36540>:
        <D.36532>:
        <D.36530>:
      }
      D.22885 = __result;
    }
    iftmp.453 = D.22885;
    goto <D.36559>;
    <D.36523>:
    D.36138 = klass->name;
    iftmp.453 = __builtin_strcmp ("MonoGenericCMethod", D.36138);
    <D.36559>:
    D.22889 = iftmp.453;
  }
  if (D.22889 == 0) goto <D.36478>; else goto <D.36479>;
  <D.36478>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.36560 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.36560);
  }
  goto <D.36480>;
  <D.36479>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36567 = "ParameterInfo";
      D.36568 = MEM[(const unsigned char *)D.36567];
      D.36569 = (int) D.36568;
      D.36570 = *__s2;
      D.36571 = (int) D.36570;
      __result = D.36569 - D.36571;
      {
        if (__s1_len != 0) goto <D.36572>; else goto <D.36573>;
        <D.36572>:
        if (__result == 0) goto <D.36574>; else goto <D.36575>;
        <D.36574>:
        D.36576 = &MEM[(void *)"ParameterInfo" + 1B];
        D.36577 = *D.36576;
        D.36578 = (int) D.36577;
        D.36579 = __s2 + 1;
        D.36580 = *D.36579;
        D.36581 = (int) D.36580;
        __result = D.36578 - D.36581;
        if (__s1_len > 1) goto <D.36582>; else goto <D.36583>;
        <D.36582>:
        if (__result == 0) goto <D.36584>; else goto <D.36585>;
        <D.36584>:
        D.36586 = &MEM[(void *)"ParameterInfo" + 2B];
        D.36587 = *D.36586;
        D.36588 = (int) D.36587;
        D.36589 = __s2 + 2;
        D.36590 = *D.36589;
        D.36591 = (int) D.36590;
        __result = D.36588 - D.36591;
        if (__s1_len > 2) goto <D.36592>; else goto <D.36593>;
        <D.36592>:
        if (__result == 0) goto <D.36594>; else goto <D.36595>;
        <D.36594>:
        D.36596 = &MEM[(void *)"ParameterInfo" + 3B];
        D.36597 = *D.36596;
        D.36598 = (int) D.36597;
        D.36599 = __s2 + 3;
        D.36600 = *D.36599;
        D.36601 = (int) D.36600;
        __result = D.36598 - D.36601;
        <D.36595>:
        <D.36593>:
        <D.36585>:
        <D.36583>:
        <D.36575>:
        <D.36573>:
      }
      D.22895 = __result;
    }
    iftmp.454 = D.22895;
    goto <D.36602>;
    <D.36566>:
    D.36138 = klass->name;
    iftmp.454 = __builtin_strcmp ("ParameterInfo", D.36138);
    <D.36602>:
    D.22899 = iftmp.454;
  }
  if (D.22899 == 0) goto <D.36561>; else goto <D.36603>;
  <D.36603>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36607 = "MonoParameterInfo";
      D.36608 = MEM[(const unsigned char *)D.36607];
      D.36609 = (int) D.36608;
      D.36610 = *__s2;
      D.36611 = (int) D.36610;
      __result = D.36609 - D.36611;
      {
        if (__s1_len != 0) goto <D.36612>; else goto <D.36613>;
        <D.36612>:
        if (__result == 0) goto <D.36614>; else goto <D.36615>;
        <D.36614>:
        D.36616 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.36617 = *D.36616;
        D.36618 = (int) D.36617;
        D.36619 = __s2 + 1;
        D.36620 = *D.36619;
        D.36621 = (int) D.36620;
        __result = D.36618 - D.36621;
        if (__s1_len > 1) goto <D.36622>; else goto <D.36623>;
        <D.36622>:
        if (__result == 0) goto <D.36624>; else goto <D.36625>;
        <D.36624>:
        D.36626 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.36627 = *D.36626;
        D.36628 = (int) D.36627;
        D.36629 = __s2 + 2;
        D.36630 = *D.36629;
        D.36631 = (int) D.36630;
        __result = D.36628 - D.36631;
        if (__s1_len > 2) goto <D.36632>; else goto <D.36633>;
        <D.36632>:
        if (__result == 0) goto <D.36634>; else goto <D.36635>;
        <D.36634>:
        D.36636 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.36637 = *D.36636;
        D.36638 = (int) D.36637;
        D.36639 = __s2 + 3;
        D.36640 = *D.36639;
        D.36641 = (int) D.36640;
        __result = D.36638 - D.36641;
        <D.36635>:
        <D.36633>:
        <D.36625>:
        <D.36623>:
        <D.36615>:
        <D.36613>:
      }
      D.22904 = __result;
    }
    iftmp.455 = D.22904;
    goto <D.36642>;
    <D.36606>:
    D.36138 = klass->name;
    iftmp.455 = __builtin_strcmp ("MonoParameterInfo", D.36138);
    <D.36642>:
    D.22908 = iftmp.455;
  }
  if (D.22908 == 0) goto <D.36561>; else goto <D.36562>;
  <D.36561>:
  {
    struct MonoReflectionParameter * param;
    struct MonoClass * member_class;

    param = obj;
    D.36643 = param->MemberImpl;
    D.36644 = D.36643->vtable;
    member_class = D.36644->klass;
    D.36645 = mono_class_is_reflection_method_or_constructor (member_class);
    if (D.36645 != 0) goto <D.36646>; else goto <D.36647>;
    <D.36646>:
    {
      struct MonoReflectionMethod * rmethod;

      rmethod = param->MemberImpl;
      D.36648 = rmethod->method;
      D.36649 = param->PositionImpl;
      D.36650 = D.36649 + 1;
      D.36651 = (unsigned int) D.36650;
      cinfo = mono_custom_attrs_from_param (D.36648, D.36651);
    }
    goto <D.36652>;
    <D.36647>:
    D.36653 = is_sr_mono_property (member_class);
    if (D.36653 != 0) goto <D.36654>; else goto <D.36655>;
    <D.36654>:
    {
      struct MonoReflectionProperty * prop;
      struct MonoMethod * method;

      prop = param->MemberImpl;
      D.36656 = prop->property;
      method = D.36656->get;
      if (method == 0B) goto <D.36657>; else goto <D.36658>;
      <D.36657>:
      D.36656 = prop->property;
      method = D.36656->set;
      <D.36658>:
      D.36659 = method == 0B;
      D.36660 = (long int) D.36659;
      D.36661 = __builtin_expect (D.36660, 0);
      if (D.36661 != 0) goto <D.36662>; else goto <D.36663>;
      <D.36662>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8889, "method");
      <D.36663>:
      D.36649 = param->PositionImpl;
      D.36650 = D.36649 + 1;
      D.36651 = (unsigned int) D.36650;
      cinfo = mono_custom_attrs_from_param (method, D.36651);
    }
    goto <D.36664>;
    <D.36655>:
    D.36665 = is_sre_method_on_tb_inst (member_class);
    if (D.36665 != 0) goto <D.36666>; else goto <D.36667>;
    <D.36666>:
    {
      struct MonoMethod * method;

      D.36643 = param->MemberImpl;
      method = mono_reflection_method_on_tb_inst_get_handle (D.36643);
      D.36649 = param->PositionImpl;
      D.36650 = D.36649 + 1;
      D.36651 = (unsigned int) D.36650;
      cinfo = mono_custom_attrs_from_param (method, D.36651);
    }
    goto <D.36668>;
    <D.36667>:
    D.36669 = is_sre_ctor_on_tb_inst (member_class);
    if (D.36669 != 0) goto <D.36670>; else goto <D.36671>;
    <D.36670>:
    {
      struct MonoReflectionCtorOnTypeBuilderInst * c;
      struct MonoMethod * method;

      c = param->MemberImpl;
      method = 0B;
      D.36672 = c->cb;
      D.36673 = D.36672->vtable;
      D.36674 = D.36673->klass;
      D.36675 = is_sre_ctor_builder (D.36674);
      if (D.36675 != 0) goto <D.36676>; else goto <D.36677>;
      <D.36676>:
      D.36672 = c->cb;
      method = MEM[(struct MonoReflectionCtorBuilder *)D.36672].mhandle;
      goto <D.36678>;
      <D.36677>:
      D.36672 = c->cb;
      D.36673 = D.36672->vtable;
      D.36674 = D.36673->klass;
      D.36679 = is_sr_mono_cmethod (D.36674);
      if (D.36679 != 0) goto <D.36680>; else goto <D.36681>;
      <D.36680>:
      D.36672 = c->cb;
      method = MEM[(struct MonoReflectionMethod *)D.36672].method;
      goto <D.36682>;
      <D.36681>:
      D.36683 = 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.36683);
      <D.22917>:
      goto <D.22917>;
      <D.36682>:
      <D.36678>:
      D.36649 = param->PositionImpl;
      D.36650 = D.36649 + 1;
      D.36651 = (unsigned int) D.36650;
      cinfo = mono_custom_attrs_from_param (method, D.36651);
    }
    goto <D.36684>;
    <D.36671>:
    {
      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.36684>:
    <D.36668>:
    <D.36664>:
    <D.36652>:
  }
  goto <D.36563>;
  <D.36562>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 15;
    if (__s1_len <= 3) goto <D.36686>; else goto <D.36687>;
    <D.36686>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.36688 = "AssemblyBuilder";
      D.36689 = MEM[(const unsigned char *)D.36688];
      D.36690 = (int) D.36689;
      D.36691 = *__s2;
      D.36692 = (int) D.36691;
      __result = D.36690 - D.36692;
      {
        if (__s1_len != 0) goto <D.36693>; else goto <D.36694>;
        <D.36693>:
        if (__result == 0) goto <D.36695>; else goto <D.36696>;
        <D.36695>:
        D.36697 = &MEM[(void *)"AssemblyBuilder" + 1B];
        D.36698 = *D.36697;
        D.36699 = (int) D.36698;
        D.36700 = __s2 + 1;
        D.36701 = *D.36700;
        D.36702 = (int) D.36701;
        __result = D.36699 - D.36702;
        if (__s1_len > 1) goto <D.36703>; else goto <D.36704>;
        <D.36703>:
        if (__result == 0) goto <D.36705>; else goto <D.36706>;
        <D.36705>:
        D.36707 = &MEM[(void *)"AssemblyBuilder" + 2B];
        D.36708 = *D.36707;
        D.36709 = (int) D.36708;
        D.36710 = __s2 + 2;
        D.36711 = *D.36710;
        D.36712 = (int) D.36711;
        __result = D.36709 - D.36712;
        if (__s1_len > 2) goto <D.36713>; else goto <D.36714>;
        <D.36713>:
        if (__result == 0) goto <D.36715>; else goto <D.36716>;
        <D.36715>:
        D.36717 = &MEM[(void *)"AssemblyBuilder" + 3B];
        D.36718 = *D.36717;
        D.36719 = (int) D.36718;
        D.36720 = __s2 + 3;
        D.36721 = *D.36720;
        D.36722 = (int) D.36721;
        __result = D.36719 - D.36722;
        <D.36716>:
        <D.36714>:
        <D.36706>:
        <D.36704>:
        <D.36696>:
        <D.36694>:
      }
      D.22925 = __result;
    }
    iftmp.456 = D.22925;
    goto <D.36723>;
    <D.36687>:
    D.36138 = klass->name;
    iftmp.456 = __builtin_strcmp ("AssemblyBuilder", D.36138);
    <D.36723>:
    D.22929 = iftmp.456;
  }
  if (D.22929 == 0) goto <D.36724>; else goto <D.36725>;
  <D.36724>:
  {
    struct MonoReflectionAssemblyBuilder * assemblyb;

    assemblyb = obj;
    D.36726 = assemblyb->assembly.assembly;
    D.36727 = D.36726->image;
    D.36728 = assemblyb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36727, D.36728);
  }
  goto <D.36729>;
  <D.36725>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36733 = "TypeBuilder";
      D.36734 = MEM[(const unsigned char *)D.36733];
      D.36735 = (int) D.36734;
      D.36736 = *__s2;
      D.36737 = (int) D.36736;
      __result = D.36735 - D.36737;
      {
        if (__s1_len != 0) goto <D.36738>; else goto <D.36739>;
        <D.36738>:
        if (__result == 0) goto <D.36740>; else goto <D.36741>;
        <D.36740>:
        D.36742 = &MEM[(void *)"TypeBuilder" + 1B];
        D.36743 = *D.36742;
        D.36744 = (int) D.36743;
        D.36745 = __s2 + 1;
        D.36746 = *D.36745;
        D.36747 = (int) D.36746;
        __result = D.36744 - D.36747;
        if (__s1_len > 1) goto <D.36748>; else goto <D.36749>;
        <D.36748>:
        if (__result == 0) goto <D.36750>; else goto <D.36751>;
        <D.36750>:
        D.36752 = &MEM[(void *)"TypeBuilder" + 2B];
        D.36753 = *D.36752;
        D.36754 = (int) D.36753;
        D.36755 = __s2 + 2;
        D.36756 = *D.36755;
        D.36757 = (int) D.36756;
        __result = D.36754 - D.36757;
        if (__s1_len > 2) goto <D.36758>; else goto <D.36759>;
        <D.36758>:
        if (__result == 0) goto <D.36760>; else goto <D.36761>;
        <D.36760>:
        D.36762 = &MEM[(void *)"TypeBuilder" + 3B];
        D.36763 = *D.36762;
        D.36764 = (int) D.36763;
        D.36765 = __s2 + 3;
        D.36766 = *D.36765;
        D.36767 = (int) D.36766;
        __result = D.36764 - D.36767;
        <D.36761>:
        <D.36759>:
        <D.36751>:
        <D.36749>:
        <D.36741>:
        <D.36739>:
      }
      D.22935 = __result;
    }
    iftmp.457 = D.22935;
    goto <D.36768>;
    <D.36732>:
    D.36138 = klass->name;
    iftmp.457 = __builtin_strcmp ("TypeBuilder", D.36138);
    <D.36768>:
    D.22939 = iftmp.457;
  }
  if (D.22939 == 0) goto <D.36769>; else goto <D.36770>;
  <D.36769>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.36771 = tb->module;
    D.36772 = D.36771->dynamic_image;
    D.36773 = &D.36772->image;
    D.36774 = tb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36773, D.36774);
  }
  goto <D.36775>;
  <D.36770>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36779 = "ModuleBuilder";
      D.36780 = MEM[(const unsigned char *)D.36779];
      D.36781 = (int) D.36780;
      D.36782 = *__s2;
      D.36783 = (int) D.36782;
      __result = D.36781 - D.36783;
      {
        if (__s1_len != 0) goto <D.36784>; else goto <D.36785>;
        <D.36784>:
        if (__result == 0) goto <D.36786>; else goto <D.36787>;
        <D.36786>:
        D.36788 = &MEM[(void *)"ModuleBuilder" + 1B];
        D.36789 = *D.36788;
        D.36790 = (int) D.36789;
        D.36791 = __s2 + 1;
        D.36792 = *D.36791;
        D.36793 = (int) D.36792;
        __result = D.36790 - D.36793;
        if (__s1_len > 1) goto <D.36794>; else goto <D.36795>;
        <D.36794>:
        if (__result == 0) goto <D.36796>; else goto <D.36797>;
        <D.36796>:
        D.36798 = &MEM[(void *)"ModuleBuilder" + 2B];
        D.36799 = *D.36798;
        D.36800 = (int) D.36799;
        D.36801 = __s2 + 2;
        D.36802 = *D.36801;
        D.36803 = (int) D.36802;
        __result = D.36800 - D.36803;
        if (__s1_len > 2) goto <D.36804>; else goto <D.36805>;
        <D.36804>:
        if (__result == 0) goto <D.36806>; else goto <D.36807>;
        <D.36806>:
        D.36808 = &MEM[(void *)"ModuleBuilder" + 3B];
        D.36809 = *D.36808;
        D.36810 = (int) D.36809;
        D.36811 = __s2 + 3;
        D.36812 = *D.36811;
        D.36813 = (int) D.36812;
        __result = D.36810 - D.36813;
        <D.36807>:
        <D.36805>:
        <D.36797>:
        <D.36795>:
        <D.36787>:
        <D.36785>:
      }
      D.22945 = __result;
    }
    iftmp.458 = D.22945;
    goto <D.36814>;
    <D.36778>:
    D.36138 = klass->name;
    iftmp.458 = __builtin_strcmp ("ModuleBuilder", D.36138);
    <D.36814>:
    D.22949 = iftmp.458;
  }
  if (D.22949 == 0) goto <D.36815>; else goto <D.36816>;
  <D.36815>:
  {
    struct MonoReflectionModuleBuilder * mb;

    mb = obj;
    D.36817 = mb->dynamic_image;
    D.36818 = &D.36817->image;
    D.36819 = mb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36818, D.36819);
  }
  goto <D.36820>;
  <D.36816>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36824 = "ConstructorBuilder";
      D.36825 = MEM[(const unsigned char *)D.36824];
      D.36826 = (int) D.36825;
      D.36827 = *__s2;
      D.36828 = (int) D.36827;
      __result = D.36826 - D.36828;
      {
        if (__s1_len != 0) goto <D.36829>; else goto <D.36830>;
        <D.36829>:
        if (__result == 0) goto <D.36831>; else goto <D.36832>;
        <D.36831>:
        D.36833 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.36834 = *D.36833;
        D.36835 = (int) D.36834;
        D.36836 = __s2 + 1;
        D.36837 = *D.36836;
        D.36838 = (int) D.36837;
        __result = D.36835 - D.36838;
        if (__s1_len > 1) goto <D.36839>; else goto <D.36840>;
        <D.36839>:
        if (__result == 0) goto <D.36841>; else goto <D.36842>;
        <D.36841>:
        D.36843 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.36844 = *D.36843;
        D.36845 = (int) D.36844;
        D.36846 = __s2 + 2;
        D.36847 = *D.36846;
        D.36848 = (int) D.36847;
        __result = D.36845 - D.36848;
        if (__s1_len > 2) goto <D.36849>; else goto <D.36850>;
        <D.36849>:
        if (__result == 0) goto <D.36851>; else goto <D.36852>;
        <D.36851>:
        D.36853 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.36854 = *D.36853;
        D.36855 = (int) D.36854;
        D.36856 = __s2 + 3;
        D.36857 = *D.36856;
        D.36858 = (int) D.36857;
        __result = D.36855 - D.36858;
        <D.36852>:
        <D.36850>:
        <D.36842>:
        <D.36840>:
        <D.36832>:
        <D.36830>:
      }
      D.22955 = __result;
    }
    iftmp.459 = D.22955;
    goto <D.36859>;
    <D.36823>:
    D.36138 = klass->name;
    iftmp.459 = __builtin_strcmp ("ConstructorBuilder", D.36138);
    <D.36859>:
    D.22959 = iftmp.459;
  }
  if (D.22959 == 0) goto <D.36860>; else goto <D.36861>;
  <D.36860>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    D.36862 = cb->mhandle;
    D.36863 = D.36862->klass;
    D.36864 = D.36863->image;
    D.36865 = cb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36864, D.36865);
  }
  goto <D.36866>;
  <D.36861>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36870 = "MethodBuilder";
      D.36871 = MEM[(const unsigned char *)D.36870];
      D.36872 = (int) D.36871;
      D.36873 = *__s2;
      D.36874 = (int) D.36873;
      __result = D.36872 - D.36874;
      {
        if (__s1_len != 0) goto <D.36875>; else goto <D.36876>;
        <D.36875>:
        if (__result == 0) goto <D.36877>; else goto <D.36878>;
        <D.36877>:
        D.36879 = &MEM[(void *)"MethodBuilder" + 1B];
        D.36880 = *D.36879;
        D.36881 = (int) D.36880;
        D.36882 = __s2 + 1;
        D.36883 = *D.36882;
        D.36884 = (int) D.36883;
        __result = D.36881 - D.36884;
        if (__s1_len > 1) goto <D.36885>; else goto <D.36886>;
        <D.36885>:
        if (__result == 0) goto <D.36887>; else goto <D.36888>;
        <D.36887>:
        D.36889 = &MEM[(void *)"MethodBuilder" + 2B];
        D.36890 = *D.36889;
        D.36891 = (int) D.36890;
        D.36892 = __s2 + 2;
        D.36893 = *D.36892;
        D.36894 = (int) D.36893;
        __result = D.36891 - D.36894;
        if (__s1_len > 2) goto <D.36895>; else goto <D.36896>;
        <D.36895>:
        if (__result == 0) goto <D.36897>; else goto <D.36898>;
        <D.36897>:
        D.36899 = &MEM[(void *)"MethodBuilder" + 3B];
        D.36900 = *D.36899;
        D.36901 = (int) D.36900;
        D.36902 = __s2 + 3;
        D.36903 = *D.36902;
        D.36904 = (int) D.36903;
        __result = D.36901 - D.36904;
        <D.36898>:
        <D.36896>:
        <D.36888>:
        <D.36886>:
        <D.36878>:
        <D.36876>:
      }
      D.22965 = __result;
    }
    iftmp.460 = D.22965;
    goto <D.36905>;
    <D.36869>:
    D.36138 = klass->name;
    iftmp.460 = __builtin_strcmp ("MethodBuilder", D.36138);
    <D.36905>:
    D.22969 = iftmp.460;
  }
  if (D.22969 == 0) goto <D.36906>; else goto <D.36907>;
  <D.36906>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.36908 = mb->mhandle;
    D.36909 = D.36908->klass;
    D.36910 = D.36909->image;
    D.36911 = mb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36910, D.36911);
  }
  goto <D.36912>;
  <D.36907>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36916 = "FieldBuilder";
      D.36917 = MEM[(const unsigned char *)D.36916];
      D.36918 = (int) D.36917;
      D.36919 = *__s2;
      D.36920 = (int) D.36919;
      __result = D.36918 - D.36920;
      {
        if (__s1_len != 0) goto <D.36921>; else goto <D.36922>;
        <D.36921>:
        if (__result == 0) goto <D.36923>; else goto <D.36924>;
        <D.36923>:
        D.36925 = &MEM[(void *)"FieldBuilder" + 1B];
        D.36926 = *D.36925;
        D.36927 = (int) D.36926;
        D.36928 = __s2 + 1;
        D.36929 = *D.36928;
        D.36930 = (int) D.36929;
        __result = D.36927 - D.36930;
        if (__s1_len > 1) goto <D.36931>; else goto <D.36932>;
        <D.36931>:
        if (__result == 0) goto <D.36933>; else goto <D.36934>;
        <D.36933>:
        D.36935 = &MEM[(void *)"FieldBuilder" + 2B];
        D.36936 = *D.36935;
        D.36937 = (int) D.36936;
        D.36938 = __s2 + 2;
        D.36939 = *D.36938;
        D.36940 = (int) D.36939;
        __result = D.36937 - D.36940;
        if (__s1_len > 2) goto <D.36941>; else goto <D.36942>;
        <D.36941>:
        if (__result == 0) goto <D.36943>; else goto <D.36944>;
        <D.36943>:
        D.36945 = &MEM[(void *)"FieldBuilder" + 3B];
        D.36946 = *D.36945;
        D.36947 = (int) D.36946;
        D.36948 = __s2 + 3;
        D.36949 = *D.36948;
        D.36950 = (int) D.36949;
        __result = D.36947 - D.36950;
        <D.36944>:
        <D.36942>:
        <D.36934>:
        <D.36932>:
        <D.36924>:
        <D.36922>:
      }
      D.22975 = __result;
    }
    iftmp.461 = D.22975;
    goto <D.36951>;
    <D.36915>:
    D.36138 = klass->name;
    iftmp.461 = __builtin_strcmp ("FieldBuilder", D.36138);
    <D.36951>:
    D.22979 = iftmp.461;
  }
  if (D.22979 == 0) goto <D.36952>; else goto <D.36953>;
  <D.36952>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.36954 = fb->typeb;
    D.36955 = MEM[(struct MonoReflectionTypeBuilder *)D.36954].module;
    D.36956 = D.36955->dynamic_image;
    D.36957 = &D.36956->image;
    D.36958 = fb->cattrs;
    cinfo = mono_custom_attrs_from_builders (0B, D.36957, D.36958);
  }
  goto <D.36959>;
  <D.36953>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36963 = "MonoGenericClass";
      D.36964 = MEM[(const unsigned char *)D.36963];
      D.36965 = (int) D.36964;
      D.36966 = *__s2;
      D.36967 = (int) D.36966;
      __result = D.36965 - D.36967;
      {
        if (__s1_len != 0) goto <D.36968>; else goto <D.36969>;
        <D.36968>:
        if (__result == 0) goto <D.36970>; else goto <D.36971>;
        <D.36970>:
        D.36972 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.36973 = *D.36972;
        D.36974 = (int) D.36973;
        D.36975 = __s2 + 1;
        D.36976 = *D.36975;
        D.36977 = (int) D.36976;
        __result = D.36974 - D.36977;
        if (__s1_len > 1) goto <D.36978>; else goto <D.36979>;
        <D.36978>:
        if (__result == 0) goto <D.36980>; else goto <D.36981>;
        <D.36980>:
        D.36982 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.36983 = *D.36982;
        D.36984 = (int) D.36983;
        D.36985 = __s2 + 2;
        D.36986 = *D.36985;
        D.36987 = (int) D.36986;
        __result = D.36984 - D.36987;
        if (__s1_len > 2) goto <D.36988>; else goto <D.36989>;
        <D.36988>:
        if (__result == 0) goto <D.36990>; else goto <D.36991>;
        <D.36990>:
        D.36992 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.36993 = *D.36992;
        D.36994 = (int) D.36993;
        D.36995 = __s2 + 3;
        D.36996 = *D.36995;
        D.36997 = (int) D.36996;
        __result = D.36994 - D.36997;
        <D.36991>:
        <D.36989>:
        <D.36981>:
        <D.36979>:
        <D.36971>:
        <D.36969>:
      }
      D.22985 = __result;
    }
    iftmp.462 = D.22985;
    goto <D.36998>;
    <D.36962>:
    D.36138 = klass->name;
    iftmp.462 = __builtin_strcmp ("MonoGenericClass", D.36138);
    <D.36998>:
    D.22989 = iftmp.462;
  }
  if (D.22989 == 0) goto <D.36999>; else goto <D.37000>;
  <D.36999>:
  {
    struct MonoReflectionGenericClass * gclass;

    gclass = obj;
    D.37001 = gclass->generic_type;
    cinfo = mono_reflection_get_custom_attrs_info (D.37001);
  }
  goto <D.37002>;
  <D.37000>:
  D.36138 = klass->name;
  monoeg_g_log (0B, 4, "get custom attrs not yet supported for %s", D.36138);
  <D.22991>:
  goto <D.22991>;
  <D.37002>:
  <D.36959>:
  <D.36912>:
  <D.36866>:
  <D.36820>:
  <D.36775>:
  <D.36729>:
  <D.36563>:
  <D.36480>:
  <D.36397>:
  <D.36394>:
  <D.36350>:
  <D.36306>:
  <D.36182>:
  <D.36098>:
  <D.36095>:
  D.37003 = cinfo;
  return D.37003;
}


mono_custom_attrs_from_module (struct MonoImage * image)
{
  long unsigned int D.37005;
  long unsigned int D.37006;
  struct MonoCustomAttrInfo * D.37009;
  guint32 idx;

  D.37005 = BIT_FIELD_REF <*image, 64, 192>;
  D.37006 = D.37005 & 34359738368;
  if (D.37006 != 0) goto <D.37007>; else goto <D.37008>;
  <D.37007>:
  D.37009 = lookup_custom_attr (image, image);
  return D.37009;
  <D.37008>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 7;
  D.37009 = mono_custom_attrs_from_index (image, idx);
  return D.37009;
}


is_sr_mono_property (struct MonoClass * class)
{
  struct MonoClass * cached_class.463;
  gboolean D.37014;
  _Bool D.37015;
  int D.37016;
  int D.23364;
  int iftmp.464;
  int D.23360;
  const char[13] * D.37022;
  unsigned char D.37023;
  int D.37024;
  unsigned char D.37025;
  int D.37026;
  const unsigned char * D.37031;
  unsigned char D.37032;
  int D.37033;
  const unsigned char * D.37034;
  unsigned char D.37035;
  int D.37036;
  const unsigned char * D.37041;
  unsigned char D.37042;
  int D.37043;
  const unsigned char * D.37044;
  unsigned char D.37045;
  int D.37046;
  const unsigned char * D.37051;
  unsigned char D.37052;
  int D.37053;
  const unsigned char * D.37054;
  unsigned char D.37055;
  int D.37056;
  const char * D.37058;
  int D.23373;
  int iftmp.465;
  int D.23369;
  const char[18] * D.37064;
  unsigned char D.37065;
  int D.37066;
  unsigned char D.37067;
  int D.37068;
  const unsigned char * D.37073;
  unsigned char D.37074;
  int D.37075;
  const unsigned char * D.37076;
  unsigned char D.37077;
  int D.37078;
  const unsigned char * D.37083;
  unsigned char D.37084;
  int D.37085;
  const unsigned char * D.37086;
  unsigned char D.37087;
  int D.37088;
  const unsigned char * D.37093;
  unsigned char D.37094;
  int D.37095;
  const unsigned char * D.37096;
  unsigned char D.37097;
  int D.37098;
  const char * D.37100;

  {
    static struct MonoClass * cached_class;

    cached_class.463 = cached_class;
    if (cached_class.463 != 0B) goto <D.37012>; else goto <D.37013>;
    <D.37012>:
    cached_class.463 = cached_class;
    D.37015 = cached_class.463 == class;
    D.37014 = (gboolean) D.37015;
    return D.37014;
    <D.37013>:
    D.37016 = is_corlib_type (class);
    if (D.37016 != 0) goto <D.37017>; else goto <D.37018>;
    <D.37017>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.37022 = "MonoProperty";
        D.37023 = MEM[(const unsigned char *)D.37022];
        D.37024 = (int) D.37023;
        D.37025 = *__s2;
        D.37026 = (int) D.37025;
        __result = D.37024 - D.37026;
        {
          if (__s1_len != 0) goto <D.37027>; else goto <D.37028>;
          <D.37027>:
          if (__result == 0) goto <D.37029>; else goto <D.37030>;
          <D.37029>:
          D.37031 = &MEM[(void *)"MonoProperty" + 1B];
          D.37032 = *D.37031;
          D.37033 = (int) D.37032;
          D.37034 = __s2 + 1;
          D.37035 = *D.37034;
          D.37036 = (int) D.37035;
          __result = D.37033 - D.37036;
          if (__s1_len > 1) goto <D.37037>; else goto <D.37038>;
          <D.37037>:
          if (__result == 0) goto <D.37039>; else goto <D.37040>;
          <D.37039>:
          D.37041 = &MEM[(void *)"MonoProperty" + 2B];
          D.37042 = *D.37041;
          D.37043 = (int) D.37042;
          D.37044 = __s2 + 2;
          D.37045 = *D.37044;
          D.37046 = (int) D.37045;
          __result = D.37043 - D.37046;
          if (__s1_len > 2) goto <D.37047>; else goto <D.37048>;
          <D.37047>:
          if (__result == 0) goto <D.37049>; else goto <D.37050>;
          <D.37049>:
          D.37051 = &MEM[(void *)"MonoProperty" + 3B];
          D.37052 = *D.37051;
          D.37053 = (int) D.37052;
          D.37054 = __s2 + 3;
          D.37055 = *D.37054;
          D.37056 = (int) D.37055;
          __result = D.37053 - D.37056;
          <D.37050>:
          <D.37048>:
          <D.37040>:
          <D.37038>:
          <D.37030>:
          <D.37028>:
        }
        D.23360 = __result;
      }
      iftmp.464 = D.23360;
      goto <D.37057>;
      <D.37021>:
      D.37058 = class->name;
      iftmp.464 = __builtin_strcmp ("MonoProperty", D.37058);
      <D.37057>:
      D.23364 = iftmp.464;
    }
    if (D.23364 == 0) goto <D.37059>; else goto <D.37060>;
    <D.37059>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37064 = "System.Reflection";
        D.37065 = MEM[(const unsigned char *)D.37064];
        D.37066 = (int) D.37065;
        D.37067 = *__s2;
        D.37068 = (int) D.37067;
        __result = D.37066 - D.37068;
        {
          if (__s1_len != 0) goto <D.37069>; else goto <D.37070>;
          <D.37069>:
          if (__result == 0) goto <D.37071>; else goto <D.37072>;
          <D.37071>:
          D.37073 = &MEM[(void *)"System.Reflection" + 1B];
          D.37074 = *D.37073;
          D.37075 = (int) D.37074;
          D.37076 = __s2 + 1;
          D.37077 = *D.37076;
          D.37078 = (int) D.37077;
          __result = D.37075 - D.37078;
          if (__s1_len > 1) goto <D.37079>; else goto <D.37080>;
          <D.37079>:
          if (__result == 0) goto <D.37081>; else goto <D.37082>;
          <D.37081>:
          D.37083 = &MEM[(void *)"System.Reflection" + 2B];
          D.37084 = *D.37083;
          D.37085 = (int) D.37084;
          D.37086 = __s2 + 2;
          D.37087 = *D.37086;
          D.37088 = (int) D.37087;
          __result = D.37085 - D.37088;
          if (__s1_len > 2) goto <D.37089>; else goto <D.37090>;
          <D.37089>:
          if (__result == 0) goto <D.37091>; else goto <D.37092>;
          <D.37091>:
          D.37093 = &MEM[(void *)"System.Reflection" + 3B];
          D.37094 = *D.37093;
          D.37095 = (int) D.37094;
          D.37096 = __s2 + 3;
          D.37097 = *D.37096;
          D.37098 = (int) D.37097;
          __result = D.37095 - D.37098;
          <D.37092>:
          <D.37090>:
          <D.37082>:
          <D.37080>:
          <D.37072>:
          <D.37070>:
        }
        D.23369 = __result;
      }
      iftmp.465 = D.23369;
      goto <D.37099>;
      <D.37063>:
      D.37100 = class->name_space;
      iftmp.465 = __builtin_strcmp ("System.Reflection", D.37100);
      <D.37099>:
      D.23373 = iftmp.465;
    }
    if (D.23373 == 0) goto <D.37101>; else goto <D.37102>;
    <D.37101>:
    cached_class = class;
    D.37014 = 1;
    return D.37014;
    <D.37102>:
    <D.37060>:
    <D.37018>:
    D.37014 = 0;
    return D.37014;
  }
}


is_sre_method_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.466;
  gboolean D.37107;
  _Bool D.37108;
  int D.37109;
  int D.23206;
  int iftmp.467;
  int D.23202;
  const char[24] * D.37115;
  unsigned char D.37116;
  int D.37117;
  unsigned char D.37118;
  int D.37119;
  const unsigned char * D.37124;
  unsigned char D.37125;
  int D.37126;
  const unsigned char * D.37127;
  unsigned char D.37128;
  int D.37129;
  const unsigned char * D.37134;
  unsigned char D.37135;
  int D.37136;
  const unsigned char * D.37137;
  unsigned char D.37138;
  int D.37139;
  const unsigned char * D.37144;
  unsigned char D.37145;
  int D.37146;
  const unsigned char * D.37147;
  unsigned char D.37148;
  int D.37149;
  const char * D.37151;
  int D.23215;
  int iftmp.468;
  int D.23211;
  const char[23] * D.37157;
  unsigned char D.37158;
  int D.37159;
  unsigned char D.37160;
  int D.37161;
  const unsigned char * D.37166;
  unsigned char D.37167;
  int D.37168;
  const unsigned char * D.37169;
  unsigned char D.37170;
  int D.37171;
  const unsigned char * D.37176;
  unsigned char D.37177;
  int D.37178;
  const unsigned char * D.37179;
  unsigned char D.37180;
  int D.37181;
  const unsigned char * D.37186;
  unsigned char D.37187;
  int D.37188;
  const unsigned char * D.37189;
  unsigned char D.37190;
  int D.37191;
  const char * D.37193;

  {
    static struct MonoClass * cached_class;

    cached_class.466 = cached_class;
    if (cached_class.466 != 0B) goto <D.37105>; else goto <D.37106>;
    <D.37105>:
    cached_class.466 = cached_class;
    D.37108 = cached_class.466 == class;
    D.37107 = (gboolean) D.37108;
    return D.37107;
    <D.37106>:
    D.37109 = is_corlib_type (class);
    if (D.37109 != 0) goto <D.37110>; else goto <D.37111>;
    <D.37110>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 23;
      if (__s1_len <= 3) goto <D.37113>; else goto <D.37114>;
      <D.37113>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.37115 = "MethodOnTypeBuilderInst";
        D.37116 = MEM[(const unsigned char *)D.37115];
        D.37117 = (int) D.37116;
        D.37118 = *__s2;
        D.37119 = (int) D.37118;
        __result = D.37117 - D.37119;
        {
          if (__s1_len != 0) goto <D.37120>; else goto <D.37121>;
          <D.37120>:
          if (__result == 0) goto <D.37122>; else goto <D.37123>;
          <D.37122>:
          D.37124 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
          D.37125 = *D.37124;
          D.37126 = (int) D.37125;
          D.37127 = __s2 + 1;
          D.37128 = *D.37127;
          D.37129 = (int) D.37128;
          __result = D.37126 - D.37129;
          if (__s1_len > 1) goto <D.37130>; else goto <D.37131>;
          <D.37130>:
          if (__result == 0) goto <D.37132>; else goto <D.37133>;
          <D.37132>:
          D.37134 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
          D.37135 = *D.37134;
          D.37136 = (int) D.37135;
          D.37137 = __s2 + 2;
          D.37138 = *D.37137;
          D.37139 = (int) D.37138;
          __result = D.37136 - D.37139;
          if (__s1_len > 2) goto <D.37140>; else goto <D.37141>;
          <D.37140>:
          if (__result == 0) goto <D.37142>; else goto <D.37143>;
          <D.37142>:
          D.37144 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
          D.37145 = *D.37144;
          D.37146 = (int) D.37145;
          D.37147 = __s2 + 3;
          D.37148 = *D.37147;
          D.37149 = (int) D.37148;
          __result = D.37146 - D.37149;
          <D.37143>:
          <D.37141>:
          <D.37133>:
          <D.37131>:
          <D.37123>:
          <D.37121>:
        }
        D.23202 = __result;
      }
      iftmp.467 = D.23202;
      goto <D.37150>;
      <D.37114>:
      D.37151 = class->name;
      iftmp.467 = __builtin_strcmp ("MethodOnTypeBuilderInst", D.37151);
      <D.37150>:
      D.23206 = iftmp.467;
    }
    if (D.23206 == 0) goto <D.37152>; else goto <D.37153>;
    <D.37152>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37157 = "System.Reflection.Emit";
        D.37158 = MEM[(const unsigned char *)D.37157];
        D.37159 = (int) D.37158;
        D.37160 = *__s2;
        D.37161 = (int) D.37160;
        __result = D.37159 - D.37161;
        {
          if (__s1_len != 0) goto <D.37162>; else goto <D.37163>;
          <D.37162>:
          if (__result == 0) goto <D.37164>; else goto <D.37165>;
          <D.37164>:
          D.37166 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.37167 = *D.37166;
          D.37168 = (int) D.37167;
          D.37169 = __s2 + 1;
          D.37170 = *D.37169;
          D.37171 = (int) D.37170;
          __result = D.37168 - D.37171;
          if (__s1_len > 1) goto <D.37172>; else goto <D.37173>;
          <D.37172>:
          if (__result == 0) goto <D.37174>; else goto <D.37175>;
          <D.37174>:
          D.37176 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.37177 = *D.37176;
          D.37178 = (int) D.37177;
          D.37179 = __s2 + 2;
          D.37180 = *D.37179;
          D.37181 = (int) D.37180;
          __result = D.37178 - D.37181;
          if (__s1_len > 2) goto <D.37182>; else goto <D.37183>;
          <D.37182>:
          if (__result == 0) goto <D.37184>; else goto <D.37185>;
          <D.37184>:
          D.37186 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.37187 = *D.37186;
          D.37188 = (int) D.37187;
          D.37189 = __s2 + 3;
          D.37190 = *D.37189;
          D.37191 = (int) D.37190;
          __result = D.37188 - D.37191;
          <D.37185>:
          <D.37183>:
          <D.37175>:
          <D.37173>:
          <D.37165>:
          <D.37163>:
        }
        D.23211 = __result;
      }
      iftmp.468 = D.23211;
      goto <D.37192>;
      <D.37156>:
      D.37193 = class->name_space;
      iftmp.468 = __builtin_strcmp ("System.Reflection.Emit", D.37193);
      <D.37192>:
      D.23215 = iftmp.468;
    }
    if (D.23215 == 0) goto <D.37194>; else goto <D.37195>;
    <D.37194>:
    cached_class = class;
    D.37107 = 1;
    return D.37107;
    <D.37195>:
    <D.37153>:
    <D.37111>:
    D.37107 = 0;
    return D.37107;
  }
}


is_sre_ctor_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.469;
  gboolean D.37200;
  _Bool D.37201;
  int D.37202;
  int D.23228;
  int iftmp.470;
  int D.23224;
  const char[29] * D.37208;
  unsigned char D.37209;
  int D.37210;
  unsigned char D.37211;
  int D.37212;
  const unsigned char * D.37217;
  unsigned char D.37218;
  int D.37219;
  const unsigned char * D.37220;
  unsigned char D.37221;
  int D.37222;
  const unsigned char * D.37227;
  unsigned char D.37228;
  int D.37229;
  const unsigned char * D.37230;
  unsigned char D.37231;
  int D.37232;
  const unsigned char * D.37237;
  unsigned char D.37238;
  int D.37239;
  const unsigned char * D.37240;
  unsigned char D.37241;
  int D.37242;
  const char * D.37244;
  int D.23237;
  int iftmp.471;
  int D.23233;
  const char[23] * D.37250;
  unsigned char D.37251;
  int D.37252;
  unsigned char D.37253;
  int D.37254;
  const unsigned char * D.37259;
  unsigned char D.37260;
  int D.37261;
  const unsigned char * D.37262;
  unsigned char D.37263;
  int D.37264;
  const unsigned char * D.37269;
  unsigned char D.37270;
  int D.37271;
  const unsigned char * D.37272;
  unsigned char D.37273;
  int D.37274;
  const unsigned char * D.37279;
  unsigned char D.37280;
  int D.37281;
  const unsigned char * D.37282;
  unsigned char D.37283;
  int D.37284;
  const char * D.37286;

  {
    static struct MonoClass * cached_class;

    cached_class.469 = cached_class;
    if (cached_class.469 != 0B) goto <D.37198>; else goto <D.37199>;
    <D.37198>:
    cached_class.469 = cached_class;
    D.37201 = cached_class.469 == class;
    D.37200 = (gboolean) D.37201;
    return D.37200;
    <D.37199>:
    D.37202 = is_corlib_type (class);
    if (D.37202 != 0) goto <D.37203>; else goto <D.37204>;
    <D.37203>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 28;
      if (__s1_len <= 3) goto <D.37206>; else goto <D.37207>;
      <D.37206>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.37208 = "ConstructorOnTypeBuilderInst";
        D.37209 = MEM[(const unsigned char *)D.37208];
        D.37210 = (int) D.37209;
        D.37211 = *__s2;
        D.37212 = (int) D.37211;
        __result = D.37210 - D.37212;
        {
          if (__s1_len != 0) goto <D.37213>; else goto <D.37214>;
          <D.37213>:
          if (__result == 0) goto <D.37215>; else goto <D.37216>;
          <D.37215>:
          D.37217 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
          D.37218 = *D.37217;
          D.37219 = (int) D.37218;
          D.37220 = __s2 + 1;
          D.37221 = *D.37220;
          D.37222 = (int) D.37221;
          __result = D.37219 - D.37222;
          if (__s1_len > 1) goto <D.37223>; else goto <D.37224>;
          <D.37223>:
          if (__result == 0) goto <D.37225>; else goto <D.37226>;
          <D.37225>:
          D.37227 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
          D.37228 = *D.37227;
          D.37229 = (int) D.37228;
          D.37230 = __s2 + 2;
          D.37231 = *D.37230;
          D.37232 = (int) D.37231;
          __result = D.37229 - D.37232;
          if (__s1_len > 2) goto <D.37233>; else goto <D.37234>;
          <D.37233>:
          if (__result == 0) goto <D.37235>; else goto <D.37236>;
          <D.37235>:
          D.37237 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
          D.37238 = *D.37237;
          D.37239 = (int) D.37238;
          D.37240 = __s2 + 3;
          D.37241 = *D.37240;
          D.37242 = (int) D.37241;
          __result = D.37239 - D.37242;
          <D.37236>:
          <D.37234>:
          <D.37226>:
          <D.37224>:
          <D.37216>:
          <D.37214>:
        }
        D.23224 = __result;
      }
      iftmp.470 = D.23224;
      goto <D.37243>;
      <D.37207>:
      D.37244 = class->name;
      iftmp.470 = __builtin_strcmp ("ConstructorOnTypeBuilderInst", D.37244);
      <D.37243>:
      D.23228 = iftmp.470;
    }
    if (D.23228 == 0) goto <D.37245>; else goto <D.37246>;
    <D.37245>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37250 = "System.Reflection.Emit";
        D.37251 = MEM[(const unsigned char *)D.37250];
        D.37252 = (int) D.37251;
        D.37253 = *__s2;
        D.37254 = (int) D.37253;
        __result = D.37252 - D.37254;
        {
          if (__s1_len != 0) goto <D.37255>; else goto <D.37256>;
          <D.37255>:
          if (__result == 0) goto <D.37257>; else goto <D.37258>;
          <D.37257>:
          D.37259 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.37260 = *D.37259;
          D.37261 = (int) D.37260;
          D.37262 = __s2 + 1;
          D.37263 = *D.37262;
          D.37264 = (int) D.37263;
          __result = D.37261 - D.37264;
          if (__s1_len > 1) goto <D.37265>; else goto <D.37266>;
          <D.37265>:
          if (__result == 0) goto <D.37267>; else goto <D.37268>;
          <D.37267>:
          D.37269 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.37270 = *D.37269;
          D.37271 = (int) D.37270;
          D.37272 = __s2 + 2;
          D.37273 = *D.37272;
          D.37274 = (int) D.37273;
          __result = D.37271 - D.37274;
          if (__s1_len > 2) goto <D.37275>; else goto <D.37276>;
          <D.37275>:
          if (__result == 0) goto <D.37277>; else goto <D.37278>;
          <D.37277>:
          D.37279 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.37280 = *D.37279;
          D.37281 = (int) D.37280;
          D.37282 = __s2 + 3;
          D.37283 = *D.37282;
          D.37284 = (int) D.37283;
          __result = D.37281 - D.37284;
          <D.37278>:
          <D.37276>:
          <D.37268>:
          <D.37266>:
          <D.37258>:
          <D.37256>:
        }
        D.23233 = __result;
      }
      iftmp.471 = D.23233;
      goto <D.37285>;
      <D.37249>:
      D.37286 = class->name_space;
      iftmp.471 = __builtin_strcmp ("System.Reflection.Emit", D.37286);
      <D.37285>:
      D.23237 = iftmp.471;
    }
    if (D.23237 == 0) goto <D.37287>; else goto <D.37288>;
    <D.37287>:
    cached_class = class;
    D.37200 = 1;
    return D.37200;
    <D.37288>:
    <D.37246>:
    <D.37204>:
    D.37200 = 0;
    return D.37200;
  }
}


mono_reflection_get_custom_attrs_by_type (struct MonoObject * obj, struct MonoClass * attr_klass, struct MonoError * error)
{
  int D.37292;
  struct MonoLoaderError * D.37296;
  struct MonoArray * D.37299;
  struct MonoDomain * D.37300;
  struct MonoClass * D.23000;
  struct MonoClass * tmp_klass.472;
  struct MonoClass * D.37304;
  struct MonoClass * tmp_klass.473;
  _Bool D.37306;
  long int D.37307;
  long int D.37308;
  struct MonoVTable * D.37311;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  mono_error_init (error);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.37290>; else goto <D.37291>;
  <D.37290>:
  result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
  D.37292 = cinfo->cached;
  if (D.37292 == 0) goto <D.37293>; else goto <D.37294>;
  <D.37293>:
  mono_custom_attrs_free (cinfo);
  <D.37294>:
  goto <D.37295>;
  <D.37291>:
  D.37296 = mono_loader_get_last_error ();
  if (D.37296 != 0B) goto <D.37297>; else goto <D.37298>;
  <D.37297>:
  D.37299 = 0B;
  return D.37299;
  <D.37298>:
  D.37300 = mono_domain_get ();
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.472 = tmp_klass;
      if (tmp_klass.472 == 0B) goto <D.37302>; else goto <D.37303>;
      <D.37302>:
      D.37304 = mono_defaults.attribute_class;
      tmp_klass.473 = mono_array_class_get (D.37304, 1);
      tmp_klass = tmp_klass.473;
      tmp_klass.472 = tmp_klass;
      D.37306 = tmp_klass.472 == 0B;
      D.37307 = (long int) D.37306;
      D.37308 = __builtin_expect (D.37307, 0);
      if (D.37308 != 0) goto <D.37309>; else goto <D.37310>;
      <D.37309>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8971, "tmp_klass");
      <D.37310>:
      <D.37303>:
    }
    D.23000 = tmp_klass;
  }
  D.37311 = mono_class_vtable (D.37300, D.23000);
  result = mono_array_new_specific (D.37311, 0);
  <D.37295>:
  D.37299 = result;
  return D.37299;
}


mono_reflection_get_custom_attrs (struct MonoObject * obj)
{
  struct MonoArray * D.37313;
  struct MonoError error;

  try
    {
      D.37313 = mono_reflection_get_custom_attrs_by_type (obj, 0B, &error);
      return D.37313;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_get_custom_attrs_data (struct MonoObject * obj)
{
  int D.37318;
  struct MonoDomain * D.37322;
  struct MonoClass * D.37323;
  struct MonoArray * D.37324;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.37316>; else goto <D.37317>;
  <D.37316>:
  result = mono_custom_attrs_data_construct (cinfo);
  D.37318 = cinfo->cached;
  if (D.37318 == 0) goto <D.37319>; else goto <D.37320>;
  <D.37319>:
  mono_custom_attrs_free (cinfo);
  <D.37320>:
  goto <D.37321>;
  <D.37317>:
  D.37322 = mono_domain_get ();
  D.37323 = mono_defaults.customattribute_data_class;
  result = mono_array_new (D.37322, D.37323, 0);
  <D.37321>:
  D.37324 = result;
  return D.37324;
}


mono_custom_attrs_data_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoDomain * D.37326;
  struct MonoClass * D.37327;
  int D.37328;
  long unsigned int D.37329;
  struct MonoImage * D.37330;
  struct MonoCustomAttrEntry * D.37331;
  long unsigned int D.37332;
  struct MonoArray * D.37333;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;

  D.37326 = mono_domain_get ();
  D.37327 = mono_defaults.customattribute_data_class;
  D.37328 = cinfo->num_attrs;
  D.37329 = (long unsigned int) D.37328;
  result = mono_array_new (D.37326, D.37327, D.37329);
  i = 0;
  goto <D.22682>;
  <D.22681>:
  D.37330 = cinfo->image;
  D.37331 = &cinfo->attrs[i];
  attr = create_custom_attr_data (D.37330, D.37331);
  {
    void * * __p;

    D.37332 = (long unsigned int) i;
    __p = mono_array_addr_with_size (result, 8, D.37332);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  i = i + 1;
  <D.22682>:
  D.37328 = cinfo->num_attrs;
  if (D.37328 > i) goto <D.22681>; else goto <D.22683>;
  <D.22683>:
  D.37333 = result;
  return D.37333;
}


create_custom_attr_data (struct MonoImage * image, struct MonoCustomAttrEntry * cattr)
{
  struct MonoAssembly * D.37335;
  _Bool D.37336;
  long int D.37337;
  long int D.37338;
  struct MonoMethod * ctor.474;
  struct MonoClass * D.37344;
  struct MonoMethod * ctor.475;
  struct MonoMethod * D.37346;
  struct MonoReflectionMethod * D.37347;
  struct MonoReflectionAssembly * D.37348;
  const mono_byte * * D.37349;
  uint32_t * D.37350;
  struct MonoObject * D.37351;
  static struct MonoMethod * ctor;
  struct MonoDomain * domain;
  struct MonoObject * attr;
  void * params[4];

  try
    {
      D.37335 = image->assembly;
      D.37336 = D.37335 == 0B;
      D.37337 = (long int) D.37336;
      D.37338 = __builtin_expect (D.37337, 0);
      if (D.37338 != 0) goto <D.37339>; else goto <D.37340>;
      <D.37339>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8461, "image->assembly");
      <D.37340>:
      ctor.474 = ctor;
      if (ctor.474 == 0B) goto <D.37342>; else goto <D.37343>;
      <D.37342>:
      D.37344 = mono_defaults.customattribute_data_class;
      ctor.475 = mono_class_get_method_from_name (D.37344, ".ctor", 4);
      ctor = ctor.475;
      <D.37343>:
      domain = mono_domain_get ();
      D.37344 = mono_defaults.customattribute_data_class;
      attr = mono_object_new (domain, D.37344);
      D.37346 = cattr->ctor;
      D.37347 = mono_method_get_object (domain, D.37346, 0B);
      params[0] = D.37347;
      D.37335 = image->assembly;
      D.37348 = mono_assembly_get_object (domain, D.37335);
      params[1] = D.37348;
      D.37349 = &cattr->data;
      params[2] = D.37349;
      D.37350 = &cattr->data_size;
      params[3] = D.37350;
      ctor.474 = ctor;
      mono_runtime_invoke (ctor.474, attr, &params, 0B);
      D.37351 = attr;
      return D.37351;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_reflection_type_get_handle (struct MonoReflectionType * ref)
{
  struct MonoType * D.37356;
  struct MonoType * D.37357;
  int D.37360;
  int D.37366;
  struct MonoVTable * D.37369;
  int D.37370;
  struct MonoReflectionType * D.37373;
  _Bool D.37374;
  long int D.37375;
  long int D.37376;
  int D.37379;
  struct MonoClass * D.37382;
  struct MonoClass * D.37383;
  struct MonoClass * D.37385;
  unsigned int D.37386;
  struct MonoClass * D.37387;
  int D.37388;
  struct MonoReflectionType * D.37391;
  _Bool D.37392;
  long int D.37393;
  long int D.37394;
  struct MonoClass * D.37397;
  int D.37398;
  struct MonoReflectionType * D.37401;
  _Bool D.37402;
  long int D.37403;
  long int D.37404;
  struct MonoClass * D.37407;
  int D.37408;
  struct MonoArray * D.37411;
  long unsigned int D.37412;
  long unsigned int D.37413;
  long unsigned int D.37414;
  long unsigned int D.37415;
  char * D.37416;
  long unsigned int D.37417;
  long unsigned int D.37418;
  struct MonoType * * D.37419;
  struct MonoType * D.37420;
  struct MonoType * D.37421;
  struct MonoReflectionType * D.37424;
  _Bool D.37425;
  long int D.37426;
  long int D.37427;
  struct MonoClass * D.37430;
  struct MonoType * D.37431;
  char * D.37432;
  struct MonoClass * class;

  if (ref == 0B) goto <D.37354>; else goto <D.37355>;
  <D.37354>:
  D.37356 = 0B;
  return D.37356;
  <D.37355>:
  D.37357 = ref->type;
  if (D.37357 != 0B) goto <D.37358>; else goto <D.37359>;
  <D.37358>:
  D.37356 = ref->type;
  return D.37356;
  <D.37359>:
  D.37360 = is_usertype (ref);
  if (D.37360 != 0) goto <D.37361>; else goto <D.37362>;
  <D.37361>:
  ref = mono_reflection_type_get_underlying_system_type (ref);
  if (ref == 0B) goto <D.37363>; else goto <D.37365>;
  <D.37365>:
  D.37366 = is_usertype (ref);
  if (D.37366 != 0) goto <D.37363>; else goto <D.37364>;
  <D.37363>:
  D.37356 = 0B;
  return D.37356;
  <D.37364>:
  D.37357 = ref->type;
  if (D.37357 != 0B) goto <D.37367>; else goto <D.37368>;
  <D.37367>:
  D.37356 = ref->type;
  return D.37356;
  <D.37368>:
  <D.37362>:
  D.37369 = MEM[(struct MonoObject *)ref].vtable;
  class = D.37369->klass;
  D.37370 = is_sre_array (class);
  if (D.37370 != 0) goto <D.37371>; else goto <D.37372>;
  <D.37371>:
  {
    struct MonoType * res;
    struct MonoReflectionArrayType * sre_array;
    struct MonoType * base;

    sre_array = ref;
    D.37373 = sre_array->element_type;
    base = mono_reflection_type_get_handle (D.37373);
    D.37374 = base == 0B;
    D.37375 = (long int) D.37374;
    D.37376 = __builtin_expect (D.37375, 0);
    if (D.37376 != 0) goto <D.37377>; else goto <D.37378>;
    <D.37377>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9133, "base");
    <D.37378>:
    D.37379 = sre_array->rank;
    if (D.37379 == 0) goto <D.37380>; else goto <D.37381>;
    <D.37380>:
    D.37382 = mono_class_from_mono_type (base);
    D.37383 = mono_array_class_get (D.37382, 1);
    res = &D.37383->byval_arg;
    goto <D.37384>;
    <D.37381>:
    D.37385 = mono_class_from_mono_type (base);
    D.37379 = sre_array->rank;
    D.37386 = (unsigned int) D.37379;
    D.37387 = mono_bounded_array_class_get (D.37385, D.37386, 1);
    res = &D.37387->byval_arg;
    <D.37384>:
    sre_array->type.type = res;
    D.37356 = res;
    return D.37356;
  }
  <D.37372>:
  D.37388 = is_sre_byref (class);
  if (D.37388 != 0) goto <D.37389>; else goto <D.37390>;
  <D.37389>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_byref;
    struct MonoType * base;

    sre_byref = ref;
    D.37391 = sre_byref->element_type;
    base = mono_reflection_type_get_handle (D.37391);
    D.37392 = base == 0B;
    D.37393 = (long int) D.37392;
    D.37394 = __builtin_expect (D.37393, 0);
    if (D.37394 != 0) goto <D.37395>; else goto <D.37396>;
    <D.37395>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9144, "base");
    <D.37396>:
    D.37397 = mono_class_from_mono_type (base);
    res = &D.37397->this_arg;
    sre_byref->type.type = res;
    D.37356 = res;
    return D.37356;
  }
  <D.37390>:
  D.37398 = is_sre_pointer (class);
  if (D.37398 != 0) goto <D.37399>; else goto <D.37400>;
  <D.37399>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_pointer;
    struct MonoType * base;

    sre_pointer = ref;
    D.37401 = sre_pointer->element_type;
    base = mono_reflection_type_get_handle (D.37401);
    D.37402 = base == 0B;
    D.37403 = (long int) D.37402;
    D.37404 = __builtin_expect (D.37403, 0);
    if (D.37404 != 0) goto <D.37405>; else goto <D.37406>;
    <D.37405>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9152, "base");
    <D.37406>:
    D.37407 = mono_ptr_class_get (base);
    res = &D.37407->byval_arg;
    sre_pointer->type.type = res;
    D.37356 = res;
    return D.37356;
  }
  <D.37400>:
  D.37408 = is_sre_generic_instance (class);
  if (D.37408 != 0) goto <D.37409>; else goto <D.37410>;
  <D.37409>:
  {
    struct MonoType * res;
    struct MonoType * * types;
    struct MonoReflectionGenericClass * gclass;
    int i;
    int count;

    gclass = ref;
    D.37411 = gclass->type_arguments;
    D.37412 = mono_array_length (D.37411);
    count = (int) D.37412;
    D.37413 = (long unsigned int) count;
    D.37414 = D.37413 * 8;
    types = monoeg_malloc0 (D.37414);
    i = 0;
    goto <D.23258>;
    <D.23257>:
    {
      struct MonoReflectionType * t;

      D.37411 = gclass->type_arguments;
      D.37415 = (long unsigned int) i;
      D.37416 = mono_array_addr_with_size (D.37411, 8, D.37415);
      t = MEM[(void * *)D.37416];
      D.37417 = (long unsigned int) i;
      D.37418 = D.37417 * 8;
      D.37419 = types + D.37418;
      D.37420 = mono_reflection_type_get_handle (t);
      *D.37419 = D.37420;
      D.37417 = (long unsigned int) i;
      D.37418 = D.37417 * 8;
      D.37419 = types + D.37418;
      D.37421 = *D.37419;
      if (D.37421 == 0B) goto <D.37422>; else goto <D.37423>;
      <D.37422>:
      monoeg_g_free (types);
      D.37356 = 0B;
      return D.37356;
      <D.37423>:
    }
    i = i + 1;
    <D.23258>:
    if (i < count) goto <D.23257>; else goto <D.23259>;
    <D.23259>:
    D.37424 = gclass->generic_type;
    res = mono_reflection_bind_generic_parameters (D.37424, count, types);
    monoeg_g_free (types);
    D.37425 = res == 0B;
    D.37426 = (long int) D.37425;
    D.37427 = __builtin_expect (D.37426, 0);
    if (D.37427 != 0) goto <D.37428>; else goto <D.37429>;
    <D.37428>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9174, "res");
    <D.37429>:
    gclass->type.type = res;
    D.37356 = res;
    return D.37356;
  }
  <D.37410>:
  D.37369 = MEM[(struct MonoObject *)ref].vtable;
  D.37430 = D.37369->klass;
  D.37431 = &D.37430->byval_arg;
  D.37432 = mono_type_full_name (D.37431);
  monoeg_g_log (0B, 4, "Cannot handle corlib user type %s", D.37432);
  <D.23260>:
  goto <D.23260>;
  D.37356 = 0B;
  return D.37356;
}


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.37434;
  struct MonoException * D.37437;
  union mono_mutex_t * D.37438;
  _Bool D.37441;
  long int D.37442;
  long int D.37443;
  struct MonoImage * D.37446;
  long unsigned int D.37447;
  long unsigned int D.37448;
  struct MonoGHashTable * D.37452;
  struct MonoGHashTable * D.37455;
  _Bool D.37458;
  long int D.37459;
  long int D.37460;
  struct MonoType * res;
  struct MonoDomain * domain;
  struct MonoClass * class;

  res = mono_reflection_type_get_handle (type);
  D.37434 = MEM[(struct MonoObject *)type].vtable;
  domain = D.37434->domain;
  if (res == 0B) goto <D.37435>; else goto <D.37436>;
  <D.37435>:
  D.37437 = mono_get_exception_argument (0B, "Invalid generic instantiation, one or more arguments are not proper user types");
  mono_raise_exception (D.37437);
  <D.37436>:
  class = mono_class_from_mono_type (res);
  mono_loader_lock ();
  {
    int ret;

    D.37438 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.37438);
    if (ret != 0) goto <D.37439>; else goto <D.37440>;
    <D.37439>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.37440>:
    D.37441 = ret != 0;
    D.37442 = (long int) D.37441;
    D.37443 = __builtin_expect (D.37442, 0);
    if (D.37443 != 0) goto <D.37444>; else goto <D.37445>;
    <D.37444>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9204, "ret == 0");
    <D.37445>:
  }
  D.37446 = class->image;
  D.37447 = BIT_FIELD_REF <*D.37446, 64, 192>;
  D.37448 = D.37447 & 34359738368;
  if (D.37448 == 0) goto <D.37449>; else goto <D.37450>;
  <D.37449>:
  mono_class_setup_supertypes (class);
  goto <D.37451>;
  <D.37450>:
  D.37452 = domain->type_hash;
  if (D.37452 == 0B) goto <D.37453>; else goto <D.37454>;
  <D.37453>:
  D.37455 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.37455;
  <D.37454>:
  D.37452 = domain->type_hash;
  mono_g_hash_table_insert (D.37452, res, type);
  <D.37451>:
  {
    int ret;

    D.37438 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.37438);
    if (ret != 0) goto <D.37456>; else goto <D.37457>;
    <D.37456>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.37457>:
    D.37458 = ret != 0;
    D.37459 = (long int) D.37458;
    D.37460 = __builtin_expect (D.37459, 0);
    if (D.37460 != 0) goto <D.37461>; else goto <D.37462>;
    <D.37461>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9214, "ret == 0");
    <D.37462>:
  }
  mono_loader_unlock ();
}


mono_class_is_reflection_method_or_constructor (struct MonoClass * class)
{
  gboolean D.37463;
  int iftmp.476;
  int D.37468;
  int D.37470;
  int D.37472;
  int D.37474;

  D.37468 = is_sr_mono_method (class);
  if (D.37468 != 0) goto <D.37465>; else goto <D.37469>;
  <D.37469>:
  D.37470 = is_sr_mono_cmethod (class);
  if (D.37470 != 0) goto <D.37465>; else goto <D.37471>;
  <D.37471>:
  D.37472 = is_sr_mono_generic_method (class);
  if (D.37472 != 0) goto <D.37465>; else goto <D.37473>;
  <D.37473>:
  D.37474 = is_sr_mono_generic_cmethod (class);
  if (D.37474 != 0) goto <D.37465>; else goto <D.37466>;
  <D.37465>:
  iftmp.476 = 1;
  goto <D.37467>;
  <D.37466>:
  iftmp.476 = 0;
  <D.37467>:
  D.37463 = iftmp.476;
  return D.37463;
}


is_sr_mono_generic_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.477;
  gboolean D.37479;
  _Bool D.37480;
  int D.37481;
  int D.23430;
  int iftmp.478;
  int D.23426;
  const char[18] * D.37487;
  unsigned char D.37488;
  int D.37489;
  unsigned char D.37490;
  int D.37491;
  const unsigned char * D.37496;
  unsigned char D.37497;
  int D.37498;
  const unsigned char * D.37499;
  unsigned char D.37500;
  int D.37501;
  const unsigned char * D.37506;
  unsigned char D.37507;
  int D.37508;
  const unsigned char * D.37509;
  unsigned char D.37510;
  int D.37511;
  const unsigned char * D.37516;
  unsigned char D.37517;
  int D.37518;
  const unsigned char * D.37519;
  unsigned char D.37520;
  int D.37521;
  const char * D.37523;
  int D.23439;
  int iftmp.479;
  int D.23435;
  const char[18] * D.37529;
  unsigned char D.37530;
  int D.37531;
  unsigned char D.37532;
  int D.37533;
  const unsigned char * D.37538;
  unsigned char D.37539;
  int D.37540;
  const unsigned char * D.37541;
  unsigned char D.37542;
  int D.37543;
  const unsigned char * D.37548;
  unsigned char D.37549;
  int D.37550;
  const unsigned char * D.37551;
  unsigned char D.37552;
  int D.37553;
  const unsigned char * D.37558;
  unsigned char D.37559;
  int D.37560;
  const unsigned char * D.37561;
  unsigned char D.37562;
  int D.37563;
  const char * D.37565;

  {
    static struct MonoClass * cached_class;

    cached_class.477 = cached_class;
    if (cached_class.477 != 0B) goto <D.37477>; else goto <D.37478>;
    <D.37477>:
    cached_class.477 = cached_class;
    D.37480 = cached_class.477 == class;
    D.37479 = (gboolean) D.37480;
    return D.37479;
    <D.37478>:
    D.37481 = is_corlib_type (class);
    if (D.37481 != 0) goto <D.37482>; else goto <D.37483>;
    <D.37482>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.37487 = "MonoGenericMethod";
        D.37488 = MEM[(const unsigned char *)D.37487];
        D.37489 = (int) D.37488;
        D.37490 = *__s2;
        D.37491 = (int) D.37490;
        __result = D.37489 - D.37491;
        {
          if (__s1_len != 0) goto <D.37492>; else goto <D.37493>;
          <D.37492>:
          if (__result == 0) goto <D.37494>; else goto <D.37495>;
          <D.37494>:
          D.37496 = &MEM[(void *)"MonoGenericMethod" + 1B];
          D.37497 = *D.37496;
          D.37498 = (int) D.37497;
          D.37499 = __s2 + 1;
          D.37500 = *D.37499;
          D.37501 = (int) D.37500;
          __result = D.37498 - D.37501;
          if (__s1_len > 1) goto <D.37502>; else goto <D.37503>;
          <D.37502>:
          if (__result == 0) goto <D.37504>; else goto <D.37505>;
          <D.37504>:
          D.37506 = &MEM[(void *)"MonoGenericMethod" + 2B];
          D.37507 = *D.37506;
          D.37508 = (int) D.37507;
          D.37509 = __s2 + 2;
          D.37510 = *D.37509;
          D.37511 = (int) D.37510;
          __result = D.37508 - D.37511;
          if (__s1_len > 2) goto <D.37512>; else goto <D.37513>;
          <D.37512>:
          if (__result == 0) goto <D.37514>; else goto <D.37515>;
          <D.37514>:
          D.37516 = &MEM[(void *)"MonoGenericMethod" + 3B];
          D.37517 = *D.37516;
          D.37518 = (int) D.37517;
          D.37519 = __s2 + 3;
          D.37520 = *D.37519;
          D.37521 = (int) D.37520;
          __result = D.37518 - D.37521;
          <D.37515>:
          <D.37513>:
          <D.37505>:
          <D.37503>:
          <D.37495>:
          <D.37493>:
        }
        D.23426 = __result;
      }
      iftmp.478 = D.23426;
      goto <D.37522>;
      <D.37486>:
      D.37523 = class->name;
      iftmp.478 = __builtin_strcmp ("MonoGenericMethod", D.37523);
      <D.37522>:
      D.23430 = iftmp.478;
    }
    if (D.23430 == 0) goto <D.37524>; else goto <D.37525>;
    <D.37524>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37529 = "System.Reflection";
        D.37530 = MEM[(const unsigned char *)D.37529];
        D.37531 = (int) D.37530;
        D.37532 = *__s2;
        D.37533 = (int) D.37532;
        __result = D.37531 - D.37533;
        {
          if (__s1_len != 0) goto <D.37534>; else goto <D.37535>;
          <D.37534>:
          if (__result == 0) goto <D.37536>; else goto <D.37537>;
          <D.37536>:
          D.37538 = &MEM[(void *)"System.Reflection" + 1B];
          D.37539 = *D.37538;
          D.37540 = (int) D.37539;
          D.37541 = __s2 + 1;
          D.37542 = *D.37541;
          D.37543 = (int) D.37542;
          __result = D.37540 - D.37543;
          if (__s1_len > 1) goto <D.37544>; else goto <D.37545>;
          <D.37544>:
          if (__result == 0) goto <D.37546>; else goto <D.37547>;
          <D.37546>:
          D.37548 = &MEM[(void *)"System.Reflection" + 2B];
          D.37549 = *D.37548;
          D.37550 = (int) D.37549;
          D.37551 = __s2 + 2;
          D.37552 = *D.37551;
          D.37553 = (int) D.37552;
          __result = D.37550 - D.37553;
          if (__s1_len > 2) goto <D.37554>; else goto <D.37555>;
          <D.37554>:
          if (__result == 0) goto <D.37556>; else goto <D.37557>;
          <D.37556>:
          D.37558 = &MEM[(void *)"System.Reflection" + 3B];
          D.37559 = *D.37558;
          D.37560 = (int) D.37559;
          D.37561 = __s2 + 3;
          D.37562 = *D.37561;
          D.37563 = (int) D.37562;
          __result = D.37560 - D.37563;
          <D.37557>:
          <D.37555>:
          <D.37547>:
          <D.37545>:
          <D.37537>:
          <D.37535>:
        }
        D.23435 = __result;
      }
      iftmp.479 = D.23435;
      goto <D.37564>;
      <D.37528>:
      D.37565 = class->name_space;
      iftmp.479 = __builtin_strcmp ("System.Reflection", D.37565);
      <D.37564>:
      D.23439 = iftmp.479;
    }
    if (D.23439 == 0) goto <D.37566>; else goto <D.37567>;
    <D.37566>:
    cached_class = class;
    D.37479 = 1;
    return D.37479;
    <D.37567>:
    <D.37525>:
    <D.37483>:
    D.37479 = 0;
    return D.37479;
  }
}


is_sr_mono_generic_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.480;
  gboolean D.37572;
  _Bool D.37573;
  int D.37574;
  int D.23452;
  int iftmp.481;
  int D.23448;
  const char[19] * D.37580;
  unsigned char D.37581;
  int D.37582;
  unsigned char D.37583;
  int D.37584;
  const unsigned char * D.37589;
  unsigned char D.37590;
  int D.37591;
  const unsigned char * D.37592;
  unsigned char D.37593;
  int D.37594;
  const unsigned char * D.37599;
  unsigned char D.37600;
  int D.37601;
  const unsigned char * D.37602;
  unsigned char D.37603;
  int D.37604;
  const unsigned char * D.37609;
  unsigned char D.37610;
  int D.37611;
  const unsigned char * D.37612;
  unsigned char D.37613;
  int D.37614;
  const char * D.37616;
  int D.23461;
  int iftmp.482;
  int D.23457;
  const char[18] * D.37622;
  unsigned char D.37623;
  int D.37624;
  unsigned char D.37625;
  int D.37626;
  const unsigned char * D.37631;
  unsigned char D.37632;
  int D.37633;
  const unsigned char * D.37634;
  unsigned char D.37635;
  int D.37636;
  const unsigned char * D.37641;
  unsigned char D.37642;
  int D.37643;
  const unsigned char * D.37644;
  unsigned char D.37645;
  int D.37646;
  const unsigned char * D.37651;
  unsigned char D.37652;
  int D.37653;
  const unsigned char * D.37654;
  unsigned char D.37655;
  int D.37656;
  const char * D.37658;

  {
    static struct MonoClass * cached_class;

    cached_class.480 = cached_class;
    if (cached_class.480 != 0B) goto <D.37570>; else goto <D.37571>;
    <D.37570>:
    cached_class.480 = cached_class;
    D.37573 = cached_class.480 == class;
    D.37572 = (gboolean) D.37573;
    return D.37572;
    <D.37571>:
    D.37574 = is_corlib_type (class);
    if (D.37574 != 0) goto <D.37575>; else goto <D.37576>;
    <D.37575>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.37580 = "MonoGenericCMethod";
        D.37581 = MEM[(const unsigned char *)D.37580];
        D.37582 = (int) D.37581;
        D.37583 = *__s2;
        D.37584 = (int) D.37583;
        __result = D.37582 - D.37584;
        {
          if (__s1_len != 0) goto <D.37585>; else goto <D.37586>;
          <D.37585>:
          if (__result == 0) goto <D.37587>; else goto <D.37588>;
          <D.37587>:
          D.37589 = &MEM[(void *)"MonoGenericCMethod" + 1B];
          D.37590 = *D.37589;
          D.37591 = (int) D.37590;
          D.37592 = __s2 + 1;
          D.37593 = *D.37592;
          D.37594 = (int) D.37593;
          __result = D.37591 - D.37594;
          if (__s1_len > 1) goto <D.37595>; else goto <D.37596>;
          <D.37595>:
          if (__result == 0) goto <D.37597>; else goto <D.37598>;
          <D.37597>:
          D.37599 = &MEM[(void *)"MonoGenericCMethod" + 2B];
          D.37600 = *D.37599;
          D.37601 = (int) D.37600;
          D.37602 = __s2 + 2;
          D.37603 = *D.37602;
          D.37604 = (int) D.37603;
          __result = D.37601 - D.37604;
          if (__s1_len > 2) goto <D.37605>; else goto <D.37606>;
          <D.37605>:
          if (__result == 0) goto <D.37607>; else goto <D.37608>;
          <D.37607>:
          D.37609 = &MEM[(void *)"MonoGenericCMethod" + 3B];
          D.37610 = *D.37609;
          D.37611 = (int) D.37610;
          D.37612 = __s2 + 3;
          D.37613 = *D.37612;
          D.37614 = (int) D.37613;
          __result = D.37611 - D.37614;
          <D.37608>:
          <D.37606>:
          <D.37598>:
          <D.37596>:
          <D.37588>:
          <D.37586>:
        }
        D.23448 = __result;
      }
      iftmp.481 = D.23448;
      goto <D.37615>;
      <D.37579>:
      D.37616 = class->name;
      iftmp.481 = __builtin_strcmp ("MonoGenericCMethod", D.37616);
      <D.37615>:
      D.23452 = iftmp.481;
    }
    if (D.23452 == 0) goto <D.37617>; else goto <D.37618>;
    <D.37617>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37622 = "System.Reflection";
        D.37623 = MEM[(const unsigned char *)D.37622];
        D.37624 = (int) D.37623;
        D.37625 = *__s2;
        D.37626 = (int) D.37625;
        __result = D.37624 - D.37626;
        {
          if (__s1_len != 0) goto <D.37627>; else goto <D.37628>;
          <D.37627>:
          if (__result == 0) goto <D.37629>; else goto <D.37630>;
          <D.37629>:
          D.37631 = &MEM[(void *)"System.Reflection" + 1B];
          D.37632 = *D.37631;
          D.37633 = (int) D.37632;
          D.37634 = __s2 + 1;
          D.37635 = *D.37634;
          D.37636 = (int) D.37635;
          __result = D.37633 - D.37636;
          if (__s1_len > 1) goto <D.37637>; else goto <D.37638>;
          <D.37637>:
          if (__result == 0) goto <D.37639>; else goto <D.37640>;
          <D.37639>:
          D.37641 = &MEM[(void *)"System.Reflection" + 2B];
          D.37642 = *D.37641;
          D.37643 = (int) D.37642;
          D.37644 = __s2 + 2;
          D.37645 = *D.37644;
          D.37646 = (int) D.37645;
          __result = D.37643 - D.37646;
          if (__s1_len > 2) goto <D.37647>; else goto <D.37648>;
          <D.37647>:
          if (__result == 0) goto <D.37649>; else goto <D.37650>;
          <D.37649>:
          D.37651 = &MEM[(void *)"System.Reflection" + 3B];
          D.37652 = *D.37651;
          D.37653 = (int) D.37652;
          D.37654 = __s2 + 3;
          D.37655 = *D.37654;
          D.37656 = (int) D.37655;
          __result = D.37653 - D.37656;
          <D.37650>:
          <D.37648>:
          <D.37640>:
          <D.37638>:
          <D.37630>:
          <D.37628>:
        }
        D.23457 = __result;
      }
      iftmp.482 = D.23457;
      goto <D.37657>;
      <D.37621>:
      D.37658 = class->name_space;
      iftmp.482 = __builtin_strcmp ("System.Reflection", D.37658);
      <D.37657>:
      D.23461 = iftmp.482;
    }
    if (D.23461 == 0) goto <D.37659>; else goto <D.37660>;
    <D.37659>:
    cached_class = class;
    D.37572 = 1;
    return D.37572;
    <D.37660>:
    <D.37618>:
    <D.37576>:
    D.37572 = 0;
    return D.37572;
  }
}


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.23590;
  int iftmp.483;
  int D.23589;
  struct MonoVTable * D.37665;
  struct MonoClass * D.37666;
  const char[12] * D.37667;
  unsigned char D.37668;
  int D.37669;
  unsigned char D.37670;
  int D.37671;
  const unsigned char * D.37676;
  unsigned char D.37677;
  int D.37678;
  const unsigned char * D.37679;
  unsigned char D.37680;
  int D.37681;
  const unsigned char * D.37686;
  unsigned char D.37687;
  int D.37688;
  const unsigned char * D.37689;
  unsigned char D.37690;
  int D.37691;
  const unsigned char * D.37696;
  unsigned char D.37697;
  int D.37698;
  const unsigned char * D.37699;
  unsigned char D.37700;
  int D.37701;
  const char * D.37703;
  struct MonoMethod * D.37707;
  long unsigned int D.37708;
  short unsigned int D.37709;
  long unsigned int D.37710;
  _Bool D.37711;
  long int D.37712;
  long int D.37713;
  unsigned int buflen.484;
  long unsigned int D.37717;
  void * buffer.485;
  char * buffer.486;
  char * p.487;
  char * p.488;
  char * p.489;
  char * p.490;
  char * p.491;
  long unsigned int D.37725;
  char * D.37726;
  struct MonoAssembly * D.37727;
  struct MonoType * D.37728;
  unsigned int D.37729;
  long unsigned int D.37732;
  unsigned int D.37733;
  long unsigned int D.37736;
  unsigned int D.37737;
  char * p.492;
  char * p.493;
  char D.37740;
  char * p.494;
  char * p.495;
  unsigned int D.37743;
  char D.37744;
  char * D.37747;
  char * p.496;
  char * p.497;
  struct MonoType * ptype.498;
  char * pname.499;
  char * D.37752;
  void * D.37753;
  long unsigned int D.37754;
  char * D.37757;
  char * p.500;
  char * p.501;
  struct MonoType * ftype.502;
  char * fname.503;
  char * D.37762;
  void * D.37763;
  long unsigned int D.37764;
  long int p.504;
  long int buffer.505;
  long int D.37767;
  long int D.37768;
  _Bool D.37769;
  long int D.37770;
  long int D.37771;
  unsigned int buflen.506;
  struct MonoDomain * D.37775;
  struct MonoClass * D.37776;
  long unsigned int D.37777;
  char * p.507;
  long unsigned int D.37779;
  int D.23614;
  int iftmp.508;
  int D.23613;
  unsigned char D.37783;
  int D.37784;
  const unsigned char * D.37789;
  unsigned char D.37790;
  int D.37791;
  const unsigned char * D.37796;
  unsigned char D.37797;
  int D.37798;
  const unsigned char * D.37803;
  unsigned char D.37804;
  int D.37805;
  struct MonoArray * D.37809;
  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.37663>; else goto <D.37664>;
        <D.37663>:
        {
          const unsigned char * __s2;
          int __result;

          D.37665 = ctor->vtable;
          D.37666 = D.37665->klass;
          __s2 = D.37666->name;
          D.37667 = "MonoCMethod";
          D.37668 = MEM[(const unsigned char *)D.37667];
          D.37669 = (int) D.37668;
          D.37670 = *__s2;
          D.37671 = (int) D.37670;
          __result = D.37669 - D.37671;
          {
            if (__s2_len != 0) goto <D.37672>; else goto <D.37673>;
            <D.37672>:
            if (__result == 0) goto <D.37674>; else goto <D.37675>;
            <D.37674>:
            D.37676 = &MEM[(void *)"MonoCMethod" + 1B];
            D.37677 = *D.37676;
            D.37678 = (int) D.37677;
            D.37679 = __s2 + 1;
            D.37680 = *D.37679;
            D.37681 = (int) D.37680;
            __result = D.37678 - D.37681;
            if (__s2_len > 1) goto <D.37682>; else goto <D.37683>;
            <D.37682>:
            if (__result == 0) goto <D.37684>; else goto <D.37685>;
            <D.37684>:
            D.37686 = &MEM[(void *)"MonoCMethod" + 2B];
            D.37687 = *D.37686;
            D.37688 = (int) D.37687;
            D.37689 = __s2 + 2;
            D.37690 = *D.37689;
            D.37691 = (int) D.37690;
            __result = D.37688 - D.37691;
            if (__s2_len > 2) goto <D.37692>; else goto <D.37693>;
            <D.37692>:
            if (__result == 0) goto <D.37694>; else goto <D.37695>;
            <D.37694>:
            D.37696 = &MEM[(void *)"MonoCMethod" + 3B];
            D.37697 = *D.37696;
            D.37698 = (int) D.37697;
            D.37699 = __s2 + 3;
            D.37700 = *D.37699;
            D.37701 = (int) D.37700;
            __result = D.37698 - D.37701;
            <D.37695>:
            <D.37693>:
            <D.37685>:
            <D.37683>:
            <D.37675>:
            <D.37673>:
          }
          D.23589 = __result;
        }
        iftmp.483 = -D.23589;
        goto <D.37702>;
        <D.37664>:
        D.37665 = ctor->vtable;
        D.37666 = D.37665->klass;
        D.37703 = D.37666->name;
        iftmp.483 = __builtin_strcmp (D.37703, "MonoCMethod");
        <D.37702>:
        D.23590 = iftmp.483;
      }
      if (D.23590 != 0) goto <D.37704>; else goto <D.37705>;
      <D.37704>:
      sig = ctor_builder_to_signature (0B, ctor);
      goto <D.37706>;
      <D.37705>:
      D.37707 = MEM[(struct MonoReflectionMethod *)ctor].method;
      sig = mono_method_signature (D.37707);
      <D.37706>:
      D.37708 = mono_array_length (ctorArgs);
      D.37709 = sig->param_count;
      D.37710 = (long unsigned int) D.37709;
      D.37711 = D.37708 != D.37710;
      D.37712 = (long int) D.37711;
      D.37713 = __builtin_expect (D.37712, 0);
      if (D.37713 != 0) goto <D.37714>; else goto <D.37715>;
      <D.37714>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9719, "mono_array_length (ctorArgs) == sig->param_count");
      <D.37715>:
      buflen = 256;
      buflen.484 = buflen;
      D.37717 = (long unsigned int) buflen.484;
      buffer.485 = monoeg_malloc (D.37717);
      buffer = buffer.485;
      buffer.486 = buffer;
      p = buffer.486;
      p.487 = p;
      p.488 = p.487;
      p.489 = p.488 + 1;
      p = p.489;
      *p.488 = 1;
      p.487 = p;
      p.490 = p.487;
      p.491 = p.490 + 1;
      p = p.491;
      *p.490 = 0;
      i = 0;
      goto <D.23592>;
      <D.23591>:
      D.37725 = (long unsigned int) i;
      D.37726 = mono_array_addr_with_size (ctorArgs, 8, D.37725);
      arg = MEM[(struct MonoObject * *)D.37726];
      D.37727 = assembly->assembly;
      buffer.486 = buffer;
      p.487 = p;
      D.37728 = sig->params[i];
      encode_cattr_value (D.37727, buffer.486, p.487, &buffer, &p, &buflen, D.37728, arg, 0B);
      i = i + 1;
      <D.23592>:
      D.37709 = sig->param_count;
      D.37729 = (unsigned int) D.37709;
      if (D.37729 > i) goto <D.23591>; else goto <D.23593>;
      <D.23593>:
      i = 0;
      if (properties != 0B) goto <D.37730>; else goto <D.37731>;
      <D.37730>:
      D.37732 = mono_array_length (properties);
      D.37733 = (unsigned int) D.37732;
      i = D.37733 + i;
      <D.37731>:
      if (fields != 0B) goto <D.37734>; else goto <D.37735>;
      <D.37734>:
      D.37736 = mono_array_length (fields);
      D.37737 = (unsigned int) D.37736;
      i = D.37737 + i;
      <D.37735>:
      p.487 = p;
      p.492 = p.487;
      p.493 = p.492 + 1;
      p = p.493;
      D.37740 = (char) i;
      *p.492 = D.37740;
      p.487 = p;
      p.494 = p.487;
      p.495 = p.494 + 1;
      p = p.495;
      D.37743 = i >> 8;
      D.37744 = (char) D.37743;
      *p.494 = D.37744;
      if (properties != 0B) goto <D.37745>; else goto <D.37746>;
      <D.37745>:
      {
        struct MonoObject * prop;

        i = 0;
        goto <D.23598>;
        <D.23597>:
        {
          struct MonoType * ptype;
          char * pname;

          try
            {
              D.37725 = (long unsigned int) i;
              D.37747 = mono_array_addr_with_size (properties, 8, D.37725);
              prop = MEM[(void * *)D.37747];
              get_prop_name_and_type (prop, &pname, &ptype);
              p.487 = p;
              p.496 = p.487;
              p.497 = p.496 + 1;
              p = p.497;
              *p.496 = 84;
              buffer.486 = buffer;
              p.487 = p;
              ptype.498 = ptype;
              pname.499 = pname;
              D.37725 = (long unsigned int) i;
              D.37752 = mono_array_addr_with_size (propValues, 8, D.37725);
              D.37753 = MEM[(void * *)D.37752];
              encode_named_val (assembly, buffer.486, p.487, &buffer, &p, &buflen, ptype.498, pname.499, D.37753);
              pname.499 = pname;
              monoeg_g_free (pname.499);
            }
          finally
            {
              ptype = {CLOBBER};
              pname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.23598>:
        D.37725 = (long unsigned int) i;
        D.37754 = mono_array_length (properties);
        if (D.37725 < D.37754) goto <D.23597>; else goto <D.23599>;
        <D.23599>:
      }
      <D.37746>:
      if (fields != 0B) goto <D.37755>; else goto <D.37756>;
      <D.37755>:
      {
        struct MonoObject * field;

        i = 0;
        goto <D.23604>;
        <D.23603>:
        {
          struct MonoType * ftype;
          char * fname;

          try
            {
              D.37725 = (long unsigned int) i;
              D.37757 = mono_array_addr_with_size (fields, 8, D.37725);
              field = MEM[(void * *)D.37757];
              get_field_name_and_type (field, &fname, &ftype);
              p.487 = p;
              p.500 = p.487;
              p.501 = p.500 + 1;
              p = p.501;
              *p.500 = 83;
              buffer.486 = buffer;
              p.487 = p;
              ftype.502 = ftype;
              fname.503 = fname;
              D.37725 = (long unsigned int) i;
              D.37762 = mono_array_addr_with_size (fieldValues, 8, D.37725);
              D.37763 = MEM[(void * *)D.37762];
              encode_named_val (assembly, buffer.486, p.487, &buffer, &p, &buflen, ftype.502, fname.503, D.37763);
              fname.503 = fname;
              monoeg_g_free (fname.503);
            }
          finally
            {
              ftype = {CLOBBER};
              fname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.23604>:
        D.37725 = (long unsigned int) i;
        D.37764 = mono_array_length (fields);
        if (D.37725 < D.37764) goto <D.23603>; else goto <D.23605>;
        <D.23605>:
      }
      <D.37756>:
      p.487 = p;
      p.504 = (long int) p.487;
      buffer.486 = buffer;
      buffer.505 = (long int) buffer.486;
      D.37767 = p.504 - buffer.505;
      buflen.484 = buflen;
      D.37768 = (long int) buflen.484;
      D.37769 = D.37767 > D.37768;
      D.37770 = (long int) D.37769;
      D.37771 = __builtin_expect (D.37770, 0);
      if (D.37771 != 0) goto <D.37772>; else goto <D.37773>;
      <D.37772>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9764, "p - buffer <= buflen");
      <D.37773>:
      p.487 = p;
      p.504 = (long int) p.487;
      buffer.486 = buffer;
      buffer.505 = (long int) buffer.486;
      D.37767 = p.504 - buffer.505;
      buflen.506 = (unsigned int) D.37767;
      buflen = buflen.506;
      D.37775 = mono_domain_get ();
      D.37776 = mono_defaults.byte_class;
      buflen.484 = buflen;
      D.37777 = (long unsigned int) buflen.484;
      result = mono_array_new (D.37775, D.37776, D.37777);
      p.507 = mono_array_addr_with_size (result, 1, 0);
      p = p.507;
      p.487 = p;
      buffer.486 = buffer;
      buflen.484 = buflen;
      D.37779 = (long unsigned int) buflen.484;
      memcpy (p.487, buffer.486, D.37779);
      buffer.486 = buffer;
      monoeg_g_free (buffer.486);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.37665 = ctor->vtable;
          D.37666 = D.37665->klass;
          __s2 = D.37666->name;
          D.37667 = "MonoCMethod";
          D.37668 = MEM[(const unsigned char *)D.37667];
          D.37669 = (int) D.37668;
          D.37783 = *__s2;
          D.37784 = (int) D.37783;
          __result = D.37669 - D.37784;
          {
            if (__s2_len != 0) goto <D.37785>; else goto <D.37786>;
            <D.37785>:
            if (__result == 0) goto <D.37787>; else goto <D.37788>;
            <D.37787>:
            D.37676 = &MEM[(void *)"MonoCMethod" + 1B];
            D.37677 = *D.37676;
            D.37678 = (int) D.37677;
            D.37789 = __s2 + 1;
            D.37790 = *D.37789;
            D.37791 = (int) D.37790;
            __result = D.37678 - D.37791;
            if (__s2_len > 1) goto <D.37792>; else goto <D.37793>;
            <D.37792>:
            if (__result == 0) goto <D.37794>; else goto <D.37795>;
            <D.37794>:
            D.37686 = &MEM[(void *)"MonoCMethod" + 2B];
            D.37687 = *D.37686;
            D.37688 = (int) D.37687;
            D.37796 = __s2 + 2;
            D.37797 = *D.37796;
            D.37798 = (int) D.37797;
            __result = D.37688 - D.37798;
            if (__s2_len > 2) goto <D.37799>; else goto <D.37800>;
            <D.37799>:
            if (__result == 0) goto <D.37801>; else goto <D.37802>;
            <D.37801>:
            D.37696 = &MEM[(void *)"MonoCMethod" + 3B];
            D.37697 = *D.37696;
            D.37698 = (int) D.37697;
            D.37803 = __s2 + 3;
            D.37804 = *D.37803;
            D.37805 = (int) D.37804;
            __result = D.37698 - D.37805;
            <D.37802>:
            <D.37800>:
            <D.37795>:
            <D.37793>:
            <D.37788>:
            <D.37786>:
          }
          D.23613 = __result;
        }
        iftmp.508 = -D.23613;
        goto <D.37806>;
        <D.37782>:
        D.37665 = ctor->vtable;
        D.37666 = D.37665->klass;
        D.37703 = D.37666->name;
        iftmp.508 = __builtin_strcmp (D.37703, "MonoCMethod");
        <D.37806>:
        D.23614 = iftmp.508;
      }
      if (D.23614 != 0) goto <D.37807>; else goto <D.37808>;
      <D.37807>:
      monoeg_g_free (sig);
      <D.37808>:
      D.37809 = result;
      return D.37809;
    }
  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.509;
  long int p.510;
  char * buffer.511;
  long int buffer.512;
  long int D.37816;
  long int D.37817;
  unsigned int D.37818;
  long int D.37819;
  unsigned int D.37822;
  long unsigned int D.37823;
  sizetype D.37824;
  char * p.513;
  unsigned char D.37828;
  char * p.514;
  char * p.515;
  char D.37831;
  char * p.516;
  char * p.517;
  char * p.518;
  struct MonoClass * D.37835;
  long unsigned int D.37836;
  long unsigned int D.37837;
  struct MonoType * D.37840;
  unsigned char D.37841;
  const char * D.37842;
  char * p.519;
  char * p.520;
  long unsigned int D.37847;
  long int D.37848;
  long int D.37849;
  unsigned int D.37852;
  char * p.521;
  long unsigned int D.37854;
  sizetype D.37855;
  char * p.522;
  char * p.523;
  char * p.524;
  struct MonoType * D.37861;
  long unsigned int D.37862;
  long int D.37863;
  long int D.37864;
  unsigned int D.37867;
  char * p.525;
  long unsigned int D.37869;
  sizetype D.37870;
  char * p.526;
  char * p.527;
  char * p.528;
  char * p.529;
  char * p.530;
  char * p.531;
  char * p.532;
  char * p.533;
  char * p.534;
  long unsigned int D.37882;
  char * p.535;
  char * p.536;
  char D.37885;
  char * p.537;
  char * p.538;
  int D.37888;
  char D.37889;
  char * p.539;
  char * p.540;
  int D.37892;
  char D.37893;
  char * p.541;
  char * p.542;
  unsigned int len.543;
  unsigned int D.37897;
  char D.37898;
  struct MonoVTable * D.37899;
  struct MonoClass * D.37900;
  struct MonoClass * D.37905;
  long unsigned int D.37907;
  long unsigned int D.37908;
  struct MonoType * D.37910;
  sizetype D.37911;
  long unsigned int D.37913;
  long unsigned int D.37914;
  struct MonoType * D.37917;
  sizetype D.37918;
  long unsigned int D.37919;
  char * D.37920;
  struct MonoObject * D.37921;
  char * p.544;
  char * p.545;
  char * p.546;
  char * p.547;
  struct MonoClass * D.37928;
  struct MonoObject * D.37929;
  char * p.548;
  char * p.549;
  long unsigned int D.37934;
  long unsigned int D.37935;
  char * p.550;
  char * p.551;
  struct MonoClass * D.37941;
  char * p.552;
  char * p.553;
  unsigned char D.37946;
  char * p.554;
  char * p.555;
  struct MonoClass * D.37951;
  unsigned char D.37952;
  char * p.556;
  char * p.557;
  char * p.558;
  char * p.559;
  struct MonoType * D.37960;
  unsigned char D.37961;
  unsigned char D.37962;
  char * p.560;
  char * p.561;
  char D.37967;
  struct MonoType * D.37968;
  long unsigned int D.37969;
  long int D.37970;
  long int D.37971;
  unsigned int D.37974;
  char * p.562;
  long unsigned int D.37976;
  sizetype D.37977;
  char * p.563;
  struct MonoType * D.37979;
  unsigned char D.37980;
  MonoTypeEnum simple_type;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  p.509 = p;
  p.510 = (long int) p.509;
  buffer.511 = buffer;
  buffer.512 = (long int) buffer.511;
  D.37816 = p.510 - buffer.512;
  D.37817 = D.37816 + 10;
  D.37818 = *buflen;
  D.37819 = (long int) D.37818;
  if (D.37817 >= D.37819) goto <D.37820>; else goto <D.37821>;
  <D.37820>:
  {
    char * newbuf;

    D.37818 = *buflen;
    D.37822 = D.37818 * 2;
    *buflen = D.37822;
    buffer.511 = buffer;
    D.37818 = *buflen;
    D.37823 = (long unsigned int) D.37818;
    newbuf = monoeg_realloc (buffer.511, D.37823);
    p.509 = p;
    p.510 = (long int) p.509;
    buffer.511 = buffer;
    buffer.512 = (long int) buffer.511;
    D.37816 = p.510 - buffer.512;
    D.37824 = (sizetype) D.37816;
    p.513 = newbuf + D.37824;
    p = p.513;
    buffer = newbuf;
  }
  <D.37821>:
  if (argval == 0B) goto <D.37826>; else goto <D.37827>;
  <D.37826>:
  argval = arg + 16;
  <D.37827>:
  D.37828 = type->type;
  simple_type = (MonoTypeEnum) D.37828;
  handle_enum:
  switch (simple_type) <default: <D.23542>, case 2: <D.23495>, case 3: <D.23499>, case 4: <D.23497>, case 5: <D.23496>, case 6: <D.23501>, case 7: <D.23500>, case 8: <D.23503>, case 9: <D.23502>, case 10: <D.23507>, case 11: <D.23506>, case 12: <D.23504>, case 13: <D.23505>, case 14: <D.23509>, case 17: <D.23508>, case 18: <D.23513>, case 28: <D.23536>, case 29: <D.23518>>
  <D.23495>:
  <D.23496>:
  <D.23497>:
  p.509 = p;
  p.514 = p.509;
  p.515 = p.514 + 1;
  p = p.515;
  D.37831 = *argval;
  *p.514 = D.37831;
  goto <D.23498>;
  <D.23499>:
  <D.23500>:
  <D.23501>:
  p.509 = p;
  swap_with_size (p.509, argval, 2, 1);
  p.509 = p;
  p.516 = p.509 + 2;
  p = p.516;
  goto <D.23498>;
  <D.23502>:
  <D.23503>:
  <D.23504>:
  p.509 = p;
  swap_with_size (p.509, argval, 4, 1);
  p.509 = p;
  p.517 = p.509 + 4;
  p = p.517;
  goto <D.23498>;
  <D.23505>:
  p.509 = p;
  swap_with_size (p.509, argval, 8, 1);
  p.509 = p;
  p.518 = p.509 + 8;
  p = p.518;
  goto <D.23498>;
  <D.23506>:
  <D.23507>:
  p.509 = p;
  swap_with_size (p.509, argval, 8, 1);
  p.509 = p;
  p.518 = p.509 + 8;
  p = p.518;
  goto <D.23498>;
  <D.23508>:
  D.37835 = type->data.klass;
  D.37836 = BIT_FIELD_REF <*D.37835, 64, 256>;
  D.37837 = D.37836 & 16;
  if (D.37837 != 0) goto <D.37838>; else goto <D.37839>;
  <D.37838>:
  D.37835 = type->data.klass;
  D.37840 = mono_class_enum_basetype (D.37835);
  D.37841 = D.37840->type;
  simple_type = (MonoTypeEnum) D.37841;
  goto handle_enum;
  <D.37839>:
  D.37835 = type->data.klass;
  D.37842 = D.37835->name;
  monoeg_g_log (0B, 16, "generic valutype %s not handled in custom attr value decoding", D.37842);
  goto <D.23498>;
  <D.23509>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37843>; else goto <D.37844>;
    <D.37843>:
    p.509 = p;
    p.519 = p.509;
    p.520 = p.519 + 1;
    p = p.520;
    *p.519 = 255;
    goto <D.23498>;
    <D.37844>:
    str = mono_string_to_utf8 (arg);
    D.37847 = strlen (str);
    slen = (guint32) D.37847;
    p.509 = p;
    p.510 = (long int) p.509;
    buffer.511 = buffer;
    buffer.512 = (long int) buffer.511;
    D.37816 = p.510 - buffer.512;
    D.37817 = D.37816 + 10;
    D.37848 = (long int) slen;
    D.37849 = D.37817 + D.37848;
    D.37818 = *buflen;
    D.37819 = (long int) D.37818;
    if (D.37849 >= D.37819) goto <D.37850>; else goto <D.37851>;
    <D.37850>:
    {
      char * newbuf;

      D.37818 = *buflen;
      D.37822 = D.37818 * 2;
      *buflen = D.37822;
      D.37818 = *buflen;
      D.37852 = D.37818 + slen;
      *buflen = D.37852;
      buffer.511 = buffer;
      D.37818 = *buflen;
      D.37823 = (long unsigned int) D.37818;
      newbuf = monoeg_realloc (buffer.511, D.37823);
      p.509 = p;
      p.510 = (long int) p.509;
      buffer.511 = buffer;
      buffer.512 = (long int) buffer.511;
      D.37816 = p.510 - buffer.512;
      D.37824 = (sizetype) D.37816;
      p.521 = newbuf + D.37824;
      p = p.521;
      buffer = newbuf;
    }
    <D.37851>:
    p.509 = p;
    mono_metadata_encode_value (slen, p.509, &p);
    p.509 = p;
    D.37854 = (long unsigned int) slen;
    memcpy (p.509, str, D.37854);
    p.509 = p;
    D.37855 = (sizetype) slen;
    p.522 = p.509 + D.37855;
    p = p.522;
    monoeg_g_free (str);
    goto <D.23498>;
  }
  <D.23513>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37857>; else goto <D.37858>;
    <D.37857>:
    p.509 = p;
    p.523 = p.509;
    p.524 = p.523 + 1;
    p = p.524;
    *p.523 = 255;
    goto <D.23498>;
    <D.37858>:
    handle_type:
    D.37861 = mono_reflection_type_get_handle (arg);
    str = type_get_qualified_name (D.37861, 0B);
    D.37862 = strlen (str);
    slen = (guint32) D.37862;
    p.509 = p;
    p.510 = (long int) p.509;
    buffer.511 = buffer;
    buffer.512 = (long int) buffer.511;
    D.37816 = p.510 - buffer.512;
    D.37817 = D.37816 + 10;
    D.37863 = (long int) slen;
    D.37864 = D.37817 + D.37863;
    D.37818 = *buflen;
    D.37819 = (long int) D.37818;
    if (D.37864 >= D.37819) goto <D.37865>; else goto <D.37866>;
    <D.37865>:
    {
      char * newbuf;

      D.37818 = *buflen;
      D.37822 = D.37818 * 2;
      *buflen = D.37822;
      D.37818 = *buflen;
      D.37867 = D.37818 + slen;
      *buflen = D.37867;
      buffer.511 = buffer;
      D.37818 = *buflen;
      D.37823 = (long unsigned int) D.37818;
      newbuf = monoeg_realloc (buffer.511, D.37823);
      p.509 = p;
      p.510 = (long int) p.509;
      buffer.511 = buffer;
      buffer.512 = (long int) buffer.511;
      D.37816 = p.510 - buffer.512;
      D.37824 = (sizetype) D.37816;
      p.525 = newbuf + D.37824;
      p = p.525;
      buffer = newbuf;
    }
    <D.37866>:
    p.509 = p;
    mono_metadata_encode_value (slen, p.509, &p);
    p.509 = p;
    D.37869 = (long unsigned int) slen;
    memcpy (p.509, str, D.37869);
    p.509 = p;
    D.37870 = (sizetype) slen;
    p.526 = p.509 + D.37870;
    p = p.526;
    monoeg_g_free (str);
    goto <D.23498>;
  }
  <D.23518>:
  {
    int len;
    int i;
    struct MonoClass * eclass;
    struct MonoClass * arg_eclass;

    if (arg == 0B) goto <D.37872>; else goto <D.37873>;
    <D.37872>:
    p.509 = p;
    p.527 = p.509;
    p.528 = p.527 + 1;
    p = p.528;
    *p.527 = 255;
    p.509 = p;
    p.529 = p.509;
    p.530 = p.529 + 1;
    p = p.530;
    *p.529 = 255;
    p.509 = p;
    p.531 = p.509;
    p.532 = p.531 + 1;
    p = p.532;
    *p.531 = 255;
    p.509 = p;
    p.533 = p.509;
    p.534 = p.533 + 1;
    p = p.534;
    *p.533 = 255;
    goto <D.23498>;
    <D.37873>:
    D.37882 = mono_array_length (arg);
    len = (int) D.37882;
    p.509 = p;
    p.535 = p.509;
    p.536 = p.535 + 1;
    p = p.536;
    D.37885 = (char) len;
    *p.535 = D.37885;
    p.509 = p;
    p.537 = p.509;
    p.538 = p.537 + 1;
    p = p.538;
    D.37888 = len >> 8;
    D.37889 = (char) D.37888;
    *p.537 = D.37889;
    p.509 = p;
    p.539 = p.509;
    p.540 = p.539 + 1;
    p = p.540;
    D.37892 = len >> 16;
    D.37893 = (char) D.37892;
    *p.539 = D.37893;
    p.509 = p;
    p.541 = p.509;
    p.542 = p.541 + 1;
    p = p.542;
    len.543 = (unsigned int) len;
    D.37897 = len.543 >> 24;
    D.37898 = (char) D.37897;
    *p.541 = D.37898;
    p.509 = p;
    *retp = p.509;
    buffer.511 = buffer;
    *retbuffer = buffer.511;
    eclass = type->data.klass;
    D.37899 = arg->vtable;
    D.37900 = D.37899->klass;
    arg_eclass = D.37900->element_class;
    if (eclass == 0B) goto <D.37901>; else goto <D.37902>;
    <D.37901>:
    eclass = mono_defaults.object_class;
    <D.37902>:
    D.37905 = mono_defaults.object_class;
    if (D.37905 == eclass) goto <D.37906>; else goto <D.37903>;
    <D.37906>:
    D.37907 = BIT_FIELD_REF <*arg_eclass, 64, 256>;
    D.37908 = D.37907 & 8;
    if (D.37908 != 0) goto <D.37909>; else goto <D.37903>;
    <D.37909>:
    {
      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.23526>;
      <D.23525>:
      buffer.511 = buffer;
      p.509 = p;
      D.37910 = &arg_eclass->byval_arg;
      encode_cattr_value (assembly, buffer.511, p.509, &buffer, &p, buflen, D.37910, 0B, elptr);
      D.37911 = (sizetype) elsize;
      elptr = elptr + D.37911;
      i = i + 1;
      <D.23526>:
      if (i < len) goto <D.23525>; else goto <D.23527>;
      <D.23527>:
    }
    goto <D.37904>;
    <D.37903>:
    D.37913 = BIT_FIELD_REF <*eclass, 64, 256>;
    D.37914 = D.37913 & 8;
    if (D.37914 != 0) goto <D.37915>; else goto <D.37912>;
    <D.37915>:
    D.37907 = BIT_FIELD_REF <*arg_eclass, 64, 256>;
    D.37908 = D.37907 & 8;
    if (D.37908 != 0) goto <D.37916>; else goto <D.37912>;
    <D.37916>:
    {
      char * elptr;
      int elsize;

      elptr = mono_array_addr_with_size (arg, 1, 0);
      elsize = mono_class_array_element_size (eclass);
      i = 0;
      goto <D.23531>;
      <D.23530>:
      buffer.511 = buffer;
      p.509 = p;
      D.37917 = &eclass->byval_arg;
      encode_cattr_value (assembly, buffer.511, p.509, &buffer, &p, buflen, D.37917, 0B, elptr);
      D.37918 = (sizetype) elsize;
      elptr = elptr + D.37918;
      i = i + 1;
      <D.23531>:
      if (i < len) goto <D.23530>; else goto <D.23532>;
      <D.23532>:
    }
    goto <D.23535>;
    <D.37912>:
    i = 0;
    goto <D.23534>;
    <D.23533>:
    buffer.511 = buffer;
    p.509 = p;
    D.37917 = &eclass->byval_arg;
    D.37919 = (long unsigned int) i;
    D.37920 = mono_array_addr_with_size (arg, 8, D.37919);
    D.37921 = MEM[(struct MonoObject * *)D.37920];
    encode_cattr_value (assembly, buffer.511, p.509, &buffer, &p, buflen, D.37917, D.37921, 0B);
    i = i + 1;
    <D.23534>:
    if (i < len) goto <D.23533>; else goto <D.23535>;
    <D.23535>:
    <D.37904>:
    goto <D.23498>;
  }
  <D.23536>:
  {
    struct MonoClass * klass;
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37922>; else goto <D.37923>;
    <D.37922>:
    p.509 = p;
    p.544 = p.509;
    p.545 = p.544 + 1;
    p = p.545;
    *p.544 = 14;
    p.509 = p;
    p.546 = p.509;
    p.547 = p.546 + 1;
    p = p.547;
    *p.546 = 255;
    goto <D.23498>;
    <D.37923>:
    D.37899 = arg->vtable;
    klass = D.37899->klass;
    D.37928 = mono_defaults.systemtype_class;
    D.37929 = mono_object_isinst (arg, D.37928);
    if (D.37929 != 0B) goto <D.37930>; else goto <D.37931>;
    <D.37930>:
    p.509 = p;
    p.548 = p.509;
    p.549 = p.548 + 1;
    p = p.549;
    *p.548 = 80;
    goto handle_type;
    <D.37931>:
    D.37934 = BIT_FIELD_REF <*klass, 64, 256>;
    D.37935 = D.37934 & 16;
    if (D.37935 != 0) goto <D.37936>; else goto <D.37937>;
    <D.37936>:
    p.509 = p;
    p.550 = p.509;
    p.551 = p.550 + 1;
    p = p.551;
    *p.550 = 85;
    goto <D.37940>;
    <D.37937>:
    D.37941 = mono_defaults.string_class;
    if (D.37941 == klass) goto <D.37942>; else goto <D.37943>;
    <D.37942>:
    simple_type = 14;
    p.509 = p;
    p.552 = p.509;
    p.553 = p.552 + 1;
    p = p.553;
    *p.552 = 14;
    goto handle_enum;
    <D.37943>:
    D.37946 = klass->rank;
    if (D.37946 == 1) goto <D.37947>; else goto <D.37948>;
    <D.37947>:
    p.509 = p;
    p.554 = p.509;
    p.555 = p.554 + 1;
    p = p.555;
    *p.554 = 29;
    D.37951 = klass->element_class;
    D.37952 = D.37951->byval_arg.type;
    if (D.37952 == 28) goto <D.37953>; else goto <D.37954>;
    <D.37953>:
    p.509 = p;
    p.556 = p.509;
    p.557 = p.556 + 1;
    p = p.557;
    *p.556 = 81;
    goto <D.37957>;
    <D.37954>:
    p.509 = p;
    p.558 = p.509;
    p.559 = p.558 + 1;
    p = p.559;
    D.37951 = klass->element_class;
    D.37952 = D.37951->byval_arg.type;
    *p.558 = D.37952;
    <D.37957>:
    buffer.511 = buffer;
    p.509 = p;
    D.37960 = &klass->byval_arg;
    encode_cattr_value (assembly, buffer.511, p.509, &buffer, &p, buflen, D.37960, arg, 0B);
    goto <D.23498>;
    <D.37948>:
    D.37961 = klass->byval_arg.type;
    D.37962 = D.37961 + 254;
    if (D.37962 <= 11) goto <D.37963>; else goto <D.37964>;
    <D.37963>:
    p.509 = p;
    p.560 = p.509;
    p.561 = p.560 + 1;
    p = p.561;
    D.37961 = klass->byval_arg.type;
    simple_type = (MonoTypeEnum) D.37961;
    D.37967 = (char) simple_type;
    *p.560 = D.37967;
    goto handle_enum;
    <D.37964>:
    monoeg_g_log (0B, 4, "unhandled type in custom attr");
    <D.23540>:
    goto <D.23540>;
    <D.37940>:
    D.37968 = mono_class_get_type (klass);
    str = type_get_qualified_name (D.37968, 0B);
    D.37969 = strlen (str);
    slen = (guint32) D.37969;
    p.509 = p;
    p.510 = (long int) p.509;
    buffer.511 = buffer;
    buffer.512 = (long int) buffer.511;
    D.37816 = p.510 - buffer.512;
    D.37817 = D.37816 + 10;
    D.37970 = (long int) slen;
    D.37971 = D.37817 + D.37970;
    D.37818 = *buflen;
    D.37819 = (long int) D.37818;
    if (D.37971 >= D.37819) goto <D.37972>; else goto <D.37973>;
    <D.37972>:
    {
      char * newbuf;

      D.37818 = *buflen;
      D.37822 = D.37818 * 2;
      *buflen = D.37822;
      D.37818 = *buflen;
      D.37974 = D.37818 + slen;
      *buflen = D.37974;
      buffer.511 = buffer;
      D.37818 = *buflen;
      D.37823 = (long unsigned int) D.37818;
      newbuf = monoeg_realloc (buffer.511, D.37823);
      p.509 = p;
      p.510 = (long int) p.509;
      buffer.511 = buffer;
      buffer.512 = (long int) buffer.511;
      D.37816 = p.510 - buffer.512;
      D.37824 = (sizetype) D.37816;
      p.562 = newbuf + D.37824;
      p = p.562;
      buffer = newbuf;
    }
    <D.37973>:
    p.509 = p;
    mono_metadata_encode_value (slen, p.509, &p);
    p.509 = p;
    D.37976 = (long unsigned int) slen;
    memcpy (p.509, str, D.37976);
    p.509 = p;
    D.37977 = (sizetype) slen;
    p.563 = p.509 + D.37977;
    p = p.563;
    monoeg_g_free (str);
    D.37979 = mono_class_enum_basetype (klass);
    D.37980 = D.37979->type;
    simple_type = (MonoTypeEnum) D.37980;
    goto handle_enum;
  }
  <D.23542>:
  monoeg_g_log (0B, 4, "type 0x%02x not yet supported in custom attr encoder", simple_type);
  <D.23543>:
  goto <D.23543>;
  <D.23498>:
  p.509 = p;
  *retp = p.509;
  buffer.511 = buffer;
  *retbuffer = buffer.511;
}


swap_with_size (char * dest, const char * val, int len, int nelem)
{
  int D.37981;
  long unsigned int D.37982;

  D.37981 = len * nelem;
  D.37982 = (long unsigned int) D.37981;
  memcpy (dest, val, D.37982);
}


type_get_qualified_name (struct MonoType * type, struct MonoAssembly * ass)
{
  char * D.37985;
  struct MonoImage * D.37986;
  unsigned char D.37989;
  struct MonoGenericClass * D.37993;
  struct MonoGenericContainer * D.37995;
  struct MonoClass * klass;
  struct MonoAssembly * ta;

  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.37983>; else goto <D.37984>;
  <D.37983>:
  D.37985 = mono_type_get_name_full (type, 1);
  return D.37985;
  <D.37984>:
  D.37986 = klass->image;
  ta = D.37986->assembly;
  D.37989 = ta->dynamic;
  if (D.37989 != 0) goto <D.37987>; else goto <D.37990>;
  <D.37990>:
  if (ta == ass) goto <D.37987>; else goto <D.37988>;
  <D.37987>:
  D.37993 = klass->generic_class;
  if (D.37993 != 0B) goto <D.37991>; else goto <D.37994>;
  <D.37994>:
  D.37995 = klass->generic_container;
  if (D.37995 != 0B) goto <D.37991>; else goto <D.37992>;
  <D.37991>:
  D.37985 = mono_type_get_name_full (type, 2);
  return D.37985;
  <D.37992>:
  D.37985 = mono_type_get_name_full (type, 1);
  return D.37985;
  <D.37988>:
  D.37985 = mono_type_get_name_full (type, 3);
  return D.37985;
}


get_prop_name_and_type (struct MonoObject * prop, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.37997;
  int D.23310;
  int iftmp.564;
  int D.23309;
  const char[16] * D.38001;
  unsigned char D.38002;
  int D.38003;
  unsigned char D.38004;
  int D.38005;
  const unsigned char * D.38010;
  unsigned char D.38011;
  int D.38012;
  const unsigned char * D.38013;
  unsigned char D.38014;
  int D.38015;
  const unsigned char * D.38020;
  unsigned char D.38021;
  int D.38022;
  const unsigned char * D.38023;
  unsigned char D.38024;
  int D.38025;
  const unsigned char * D.38030;
  unsigned char D.38031;
  int D.38032;
  const unsigned char * D.38033;
  unsigned char D.38034;
  int D.38035;
  const char * D.38037;
  struct MonoString * D.38040;
  char * D.38041;
  struct MonoObject * D.38042;
  struct MonoType * D.38043;
  struct MonoProperty * D.38045;
  const char * D.38046;
  gchar * D.38047;
  struct MonoMethod * D.38048;
  struct MonoMethodSignature * D.38051;
  struct MonoType * D.38052;
  struct MonoMethod * D.38054;
  struct MonoMethodSignature * D.38055;
  struct MonoMethodSignature * D.38056;
  short unsigned int D.38057;
  int D.38058;
  int D.38059;
  struct MonoType * D.38060;
  struct MonoClass * klass;

  D.37997 = prop->vtable;
  klass = D.37997->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.38001 = "PropertyBuilder";
      D.38002 = MEM[(const unsigned char *)D.38001];
      D.38003 = (int) D.38002;
      D.38004 = *__s2;
      D.38005 = (int) D.38004;
      __result = D.38003 - D.38005;
      {
        if (__s2_len != 0) goto <D.38006>; else goto <D.38007>;
        <D.38006>:
        if (__result == 0) goto <D.38008>; else goto <D.38009>;
        <D.38008>:
        D.38010 = &MEM[(void *)"PropertyBuilder" + 1B];
        D.38011 = *D.38010;
        D.38012 = (int) D.38011;
        D.38013 = __s2 + 1;
        D.38014 = *D.38013;
        D.38015 = (int) D.38014;
        __result = D.38012 - D.38015;
        if (__s2_len > 1) goto <D.38016>; else goto <D.38017>;
        <D.38016>:
        if (__result == 0) goto <D.38018>; else goto <D.38019>;
        <D.38018>:
        D.38020 = &MEM[(void *)"PropertyBuilder" + 2B];
        D.38021 = *D.38020;
        D.38022 = (int) D.38021;
        D.38023 = __s2 + 2;
        D.38024 = *D.38023;
        D.38025 = (int) D.38024;
        __result = D.38022 - D.38025;
        if (__s2_len > 2) goto <D.38026>; else goto <D.38027>;
        <D.38026>:
        if (__result == 0) goto <D.38028>; else goto <D.38029>;
        <D.38028>:
        D.38030 = &MEM[(void *)"PropertyBuilder" + 3B];
        D.38031 = *D.38030;
        D.38032 = (int) D.38031;
        D.38033 = __s2 + 3;
        D.38034 = *D.38033;
        D.38035 = (int) D.38034;
        __result = D.38032 - D.38035;
        <D.38029>:
        <D.38027>:
        <D.38019>:
        <D.38017>:
        <D.38009>:
        <D.38007>:
      }
      D.23309 = __result;
    }
    iftmp.564 = -D.23309;
    goto <D.38036>;
    <D.38000>:
    D.38037 = klass->name;
    iftmp.564 = __builtin_strcmp (D.38037, "PropertyBuilder");
    <D.38036>:
    D.23310 = iftmp.564;
  }
  if (D.23310 == 0) goto <D.38038>; else goto <D.38039>;
  <D.38038>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    pb = prop;
    D.38040 = pb->name;
    D.38041 = mono_string_to_utf8 (D.38040);
    *name = D.38041;
    D.38042 = pb->type;
    D.38043 = mono_reflection_type_get_handle (D.38042);
    *type = D.38043;
  }
  goto <D.38044>;
  <D.38039>:
  {
    struct MonoReflectionProperty * p;

    p = prop;
    D.38045 = p->property;
    D.38046 = D.38045->name;
    D.38047 = monoeg_strdup (D.38046);
    *name = D.38047;
    D.38045 = p->property;
    D.38048 = D.38045->get;
    if (D.38048 != 0B) goto <D.38049>; else goto <D.38050>;
    <D.38049>:
    D.38045 = p->property;
    D.38048 = D.38045->get;
    D.38051 = mono_method_signature (D.38048);
    D.38052 = D.38051->ret;
    *type = D.38052;
    goto <D.38053>;
    <D.38050>:
    D.38045 = p->property;
    D.38054 = D.38045->set;
    D.38055 = mono_method_signature (D.38054);
    D.38045 = p->property;
    D.38054 = D.38045->set;
    D.38056 = mono_method_signature (D.38054);
    D.38057 = D.38056->param_count;
    D.38058 = (int) D.38057;
    D.38059 = D.38058 + -1;
    D.38060 = D.38055->params[D.38059];
    *type = D.38060;
    <D.38053>:
  }
  <D.38044>:
}


get_field_name_and_type (struct MonoObject * field, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.38061;
  int D.23327;
  int iftmp.565;
  int D.23326;
  const char[13] * D.38065;
  unsigned char D.38066;
  int D.38067;
  unsigned char D.38068;
  int D.38069;
  const unsigned char * D.38074;
  unsigned char D.38075;
  int D.38076;
  const unsigned char * D.38077;
  unsigned char D.38078;
  int D.38079;
  const unsigned char * D.38084;
  unsigned char D.38085;
  int D.38086;
  const unsigned char * D.38087;
  unsigned char D.38088;
  int D.38089;
  const unsigned char * D.38094;
  unsigned char D.38095;
  int D.38096;
  const unsigned char * D.38097;
  unsigned char D.38098;
  int D.38099;
  const char * D.38101;
  struct MonoString * D.38104;
  char * D.38105;
  struct MonoObject * D.38106;
  struct MonoType * D.38107;
  struct MonoClassField * D.38109;
  const char * D.38110;
  gchar * D.38111;
  struct MonoType * D.38112;
  struct MonoClass * klass;

  D.38061 = field->vtable;
  klass = D.38061->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.38065 = "FieldBuilder";
      D.38066 = MEM[(const unsigned char *)D.38065];
      D.38067 = (int) D.38066;
      D.38068 = *__s2;
      D.38069 = (int) D.38068;
      __result = D.38067 - D.38069;
      {
        if (__s2_len != 0) goto <D.38070>; else goto <D.38071>;
        <D.38070>:
        if (__result == 0) goto <D.38072>; else goto <D.38073>;
        <D.38072>:
        D.38074 = &MEM[(void *)"FieldBuilder" + 1B];
        D.38075 = *D.38074;
        D.38076 = (int) D.38075;
        D.38077 = __s2 + 1;
        D.38078 = *D.38077;
        D.38079 = (int) D.38078;
        __result = D.38076 - D.38079;
        if (__s2_len > 1) goto <D.38080>; else goto <D.38081>;
        <D.38080>:
        if (__result == 0) goto <D.38082>; else goto <D.38083>;
        <D.38082>:
        D.38084 = &MEM[(void *)"FieldBuilder" + 2B];
        D.38085 = *D.38084;
        D.38086 = (int) D.38085;
        D.38087 = __s2 + 2;
        D.38088 = *D.38087;
        D.38089 = (int) D.38088;
        __result = D.38086 - D.38089;
        if (__s2_len > 2) goto <D.38090>; else goto <D.38091>;
        <D.38090>:
        if (__result == 0) goto <D.38092>; else goto <D.38093>;
        <D.38092>:
        D.38094 = &MEM[(void *)"FieldBuilder" + 3B];
        D.38095 = *D.38094;
        D.38096 = (int) D.38095;
        D.38097 = __s2 + 3;
        D.38098 = *D.38097;
        D.38099 = (int) D.38098;
        __result = D.38096 - D.38099;
        <D.38093>:
        <D.38091>:
        <D.38083>:
        <D.38081>:
        <D.38073>:
        <D.38071>:
      }
      D.23326 = __result;
    }
    iftmp.565 = -D.23326;
    goto <D.38100>;
    <D.38064>:
    D.38101 = klass->name;
    iftmp.565 = __builtin_strcmp (D.38101, "FieldBuilder");
    <D.38100>:
    D.23327 = iftmp.565;
  }
  if (D.23327 == 0) goto <D.38102>; else goto <D.38103>;
  <D.38102>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = field;
    D.38104 = fb->name;
    D.38105 = mono_string_to_utf8 (D.38104);
    *name = D.38105;
    D.38106 = fb->type;
    D.38107 = mono_reflection_type_get_handle (D.38106);
    *type = D.38107;
  }
  goto <D.38108>;
  <D.38103>:
  {
    struct MonoReflectionField * f;

    f = field;
    D.38109 = f->field;
    D.38110 = mono_field_get_name (D.38109);
    D.38111 = monoeg_strdup (D.38110);
    *name = D.38111;
    D.38109 = f->field;
    D.38112 = D.38109->type;
    *type = D.38112;
  }
  <D.38108>:
}


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.38115;
  struct MonoClass * D.38117;
  long unsigned int D.38118;
  long unsigned int D.38119;
  long unsigned int D.38121;
  struct MonoType * D.38126;
  long unsigned int D.38127;
  long unsigned int D.38128;
  unsigned int D.38129;
  unsigned int len.566;
  unsigned int D.38131;
  char * p.567;
  long int p.568;
  char * buffer.569;
  long int buffer.570;
  long int D.38136;
  long int D.38137;
  long int D.38138;
  long int D.38139;
  unsigned int D.38140;
  long int D.38141;
  unsigned int D.38144;
  unsigned int len.571;
  unsigned int D.38146;
  long unsigned int D.38147;
  sizetype D.38148;
  char * p.572;
  long unsigned int D.38150;
  unsigned int len.573;
  long unsigned int D.38152;
  sizetype D.38153;
  char * p.574;
  struct MonoAssembly * D.38155;
  int len;

  D.38115 = type->type;
  if (D.38115 == 17) goto <D.38116>; else goto <D.38113>;
  <D.38116>:
  D.38117 = type->data.klass;
  D.38118 = BIT_FIELD_REF <*D.38117, 64, 256>;
  D.38119 = D.38118 & 16;
  if (D.38119 != 0) goto <D.38120>; else goto <D.38113>;
  <D.38120>:
  {
    char * str;

    str = type_get_qualified_name (type, 0B);
    D.38121 = strlen (str);
    len = (int) D.38121;
    monoeg_g_free (str);
  }
  goto <D.38114>;
  <D.38113>:
  D.38115 = type->type;
  if (D.38115 == 29) goto <D.38124>; else goto <D.38122>;
  <D.38124>:
  D.38117 = type->data.klass;
  D.38118 = BIT_FIELD_REF <*D.38117, 64, 256>;
  D.38119 = D.38118 & 16;
  if (D.38119 != 0) goto <D.38125>; else goto <D.38122>;
  <D.38125>:
  {
    char * str;

    D.38117 = type->data.klass;
    D.38126 = &D.38117->byval_arg;
    str = type_get_qualified_name (D.38126, 0B);
    D.38127 = strlen (str);
    len = (int) D.38127;
    monoeg_g_free (str);
  }
  goto <D.38123>;
  <D.38122>:
  len = 0;
  <D.38123>:
  <D.38114>:
  D.38128 = strlen (name);
  D.38129 = (unsigned int) D.38128;
  len.566 = (unsigned int) len;
  D.38131 = D.38129 + len.566;
  len = (int) D.38131;
  p.567 = p;
  p.568 = (long int) p.567;
  buffer.569 = buffer;
  buffer.570 = (long int) buffer.569;
  D.38136 = p.568 - buffer.570;
  D.38137 = D.38136 + 20;
  D.38138 = (long int) len;
  D.38139 = D.38137 + D.38138;
  D.38140 = *buflen;
  D.38141 = (long int) D.38140;
  if (D.38139 >= D.38141) goto <D.38142>; else goto <D.38143>;
  <D.38142>:
  {
    char * newbuf;

    D.38140 = *buflen;
    D.38144 = D.38140 * 2;
    *buflen = D.38144;
    D.38140 = *buflen;
    len.571 = (unsigned int) len;
    D.38146 = D.38140 + len.571;
    *buflen = D.38146;
    buffer.569 = buffer;
    D.38140 = *buflen;
    D.38147 = (long unsigned int) D.38140;
    newbuf = monoeg_realloc (buffer.569, D.38147);
    p.567 = p;
    p.568 = (long int) p.567;
    buffer.569 = buffer;
    buffer.570 = (long int) buffer.569;
    D.38136 = p.568 - buffer.570;
    D.38148 = (sizetype) D.38136;
    p.572 = newbuf + D.38148;
    p = p.572;
    buffer = newbuf;
  }
  <D.38143>:
  p.567 = p;
  encode_field_or_prop_type (type, p.567, &p);
  D.38150 = strlen (name);
  len = (int) D.38150;
  len.573 = (unsigned int) len;
  p.567 = p;
  mono_metadata_encode_value (len.573, p.567, &p);
  p.567 = p;
  D.38152 = (long unsigned int) len;
  memcpy (p.567, name, D.38152);
  p.567 = p;
  D.38153 = (sizetype) len;
  p.574 = p.567 + D.38153;
  p = p.574;
  D.38155 = assembly->assembly;
  buffer.569 = buffer;
  p.567 = p;
  encode_cattr_value (D.38155, buffer.569, p.567, &buffer, &p, buflen, type, value, 0B);
  p.567 = p;
  *retp = p.567;
  buffer.569 = buffer;
  *retbuffer = buffer.569;
}


encode_field_or_prop_type (struct MonoType * type, char * p, char * * retp)
{
  unsigned char D.38158;
  struct MonoClass * D.38160;
  long unsigned int D.38161;
  long unsigned int D.38162;
  long unsigned int D.38164;
  char * p.575;
  char * p.576;
  char * p.577;
  unsigned int slen.578;
  long unsigned int D.38169;
  sizetype D.38170;
  char * p.579;
  char * p.580;
  char * p.581;
  char * p.582;
  char * p.583;
  unsigned int D.38182;
  struct MonoType * D.38185;

  D.38158 = type->type;
  if (D.38158 == 17) goto <D.38159>; else goto <D.38156>;
  <D.38159>:
  D.38160 = type->data.klass;
  D.38161 = BIT_FIELD_REF <*D.38160, 64, 256>;
  D.38162 = D.38161 & 16;
  if (D.38162 != 0) goto <D.38163>; else goto <D.38156>;
  <D.38163>:
  {
    char * str;
    int slen;

    str = type_get_qualified_name (type, 0B);
    D.38164 = strlen (str);
    slen = (int) D.38164;
    p.575 = p;
    p.576 = p.575;
    p.577 = p.576 + 1;
    p = p.577;
    *p.576 = 85;
    slen.578 = (unsigned int) slen;
    p.575 = p;
    mono_metadata_encode_value (slen.578, p.575, &p);
    p.575 = p;
    D.38169 = (long unsigned int) slen;
    memcpy (p.575, str, D.38169);
    p.575 = p;
    D.38170 = (sizetype) slen;
    p.579 = p.575 + D.38170;
    p = p.579;
    monoeg_g_free (str);
  }
  goto <D.38157>;
  <D.38156>:
  D.38158 = type->type;
  if (D.38158 == 28) goto <D.38172>; else goto <D.38173>;
  <D.38172>:
  p.575 = p;
  p.580 = p.575;
  p.581 = p.580 + 1;
  p = p.581;
  *p.580 = 81;
  goto <D.38176>;
  <D.38173>:
  D.38158 = type->type;
  if (D.38158 == 18) goto <D.38177>; else goto <D.38178>;
  <D.38177>:
  p.575 = p;
  p.582 = p.575;
  p.583 = p.582 + 1;
  p = p.583;
  *p.582 = 80;
  goto <D.38181>;
  <D.38178>:
  D.38158 = type->type;
  D.38182 = (unsigned int) D.38158;
  p.575 = p;
  mono_metadata_encode_value (D.38182, p.575, &p);
  D.38158 = type->type;
  if (D.38158 == 29) goto <D.38183>; else goto <D.38184>;
  <D.38183>:
  D.38160 = type->data.klass;
  D.38185 = &D.38160->byval_arg;
  p.575 = p;
  encode_field_or_prop_type (D.38185, p.575, &p);
  <D.38184>:
  <D.38181>:
  <D.38176>:
  <D.38157>:
  p.575 = p;
  *retp = p.575;
}


mono_reflection_setup_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoObject * D.38186;
  struct MonoReflectionType * D.38187;
  int D.23629;
  int iftmp.584;
  int D.23628;
  struct MonoVTable * D.38193;
  struct MonoClass * D.38194;
  const char[12] * D.38195;
  unsigned char D.38196;
  int D.38197;
  unsigned char D.38198;
  int D.38199;
  const unsigned char * D.38204;
  unsigned char D.38205;
  int D.38206;
  const unsigned char * D.38207;
  unsigned char D.38208;
  int D.38209;
  const unsigned char * D.38214;
  unsigned char D.38215;
  int D.38216;
  const unsigned char * D.38217;
  unsigned char D.38218;
  int D.38219;
  const unsigned char * D.38224;
  unsigned char D.38225;
  int D.38226;
  const unsigned char * D.38227;
  unsigned char D.38228;
  int D.38229;
  const char * D.38231;
  struct MonoType * D.38234;
  struct MonoType * D.38236;
  struct MonoType * D.38238;
  struct MonoReflectionModuleBuilder * D.38241;
  struct MonoDynamicImage * D.38242;
  struct MonoImage * D.38243;
  struct MonoImage * D.38244;
  struct MonoString * D.38245;
  char * D.38246;
  int D.38247;
  struct MonoString * D.38249;
  char * D.38250;
  int D.38251;
  unsigned int D.38253;
  unsigned int D.38254;
  unsigned int D.38255;
  void * D.38256;
  struct MonoReflectionType * D.38259;
  const char * D.38262;
  const char * D.38263;
  void * D.38265;
  _Bool D.38266;
  long int D.38267;
  long int D.38268;
  struct MonoGHashTable * D.38271;
  long unsigned int D.38272;
  void * D.38273;
  int D.23639;
  int iftmp.585;
  int D.23638;
  const char[7] * D.38280;
  unsigned char D.38281;
  int D.38282;
  unsigned char D.38283;
  int D.38284;
  const unsigned char * D.38289;
  unsigned char D.38290;
  int D.38291;
  const unsigned char * D.38292;
  unsigned char D.38293;
  int D.38294;
  const unsigned char * D.38299;
  unsigned char D.38300;
  int D.38301;
  const unsigned char * D.38302;
  unsigned char D.38303;
  int D.38304;
  const unsigned char * D.38309;
  unsigned char D.38310;
  int D.38311;
  const unsigned char * D.38312;
  unsigned char D.38313;
  int D.38314;
  int D.23648;
  int iftmp.586;
  int D.23647;
  const char[7] * D.38321;
  unsigned char D.38322;
  int D.38323;
  unsigned char D.38324;
  int D.38325;
  const unsigned char * D.38330;
  unsigned char D.38331;
  int D.38332;
  const unsigned char * D.38333;
  unsigned char D.38334;
  int D.38335;
  const unsigned char * D.38340;
  unsigned char D.38341;
  int D.38342;
  const unsigned char * D.38343;
  unsigned char D.38344;
  int D.38345;
  const unsigned char * D.38350;
  unsigned char D.38351;
  int D.38352;
  const unsigned char * D.38353;
  unsigned char D.38354;
  int D.38355;
  struct MonoClass * D.38359;
  int D.23658;
  int iftmp.587;
  int D.23657;
  const char[10] * D.38367;
  unsigned char D.38368;
  int D.38369;
  unsigned char D.38370;
  int D.38371;
  const unsigned char * D.38376;
  unsigned char D.38377;
  int D.38378;
  const unsigned char * D.38379;
  unsigned char D.38380;
  int D.38381;
  const unsigned char * D.38386;
  unsigned char D.38387;
  int D.38388;
  const unsigned char * D.38389;
  unsigned char D.38390;
  int D.38391;
  const unsigned char * D.38396;
  unsigned char D.38397;
  int D.38398;
  const unsigned char * D.38399;
  unsigned char D.38400;
  int D.38401;
  int D.23667;
  int iftmp.588;
  int D.23666;
  unsigned char D.38407;
  int D.38408;
  const unsigned char * D.38413;
  unsigned char D.38414;
  int D.38415;
  const unsigned char * D.38420;
  unsigned char D.38421;
  int D.38422;
  const unsigned char * D.38427;
  unsigned char D.38428;
  int D.38429;
  int D.23676;
  int iftmp.589;
  int D.23675;
  unsigned char D.38434;
  int D.38435;
  const unsigned char * D.38440;
  unsigned char D.38441;
  int D.38442;
  const unsigned char * D.38447;
  unsigned char D.38448;
  int D.38449;
  const unsigned char * D.38454;
  unsigned char D.38455;
  int D.38456;
  int D.23685;
  int iftmp.590;
  int D.23684;
  unsigned char D.38462;
  int D.38463;
  const unsigned char * D.38468;
  unsigned char D.38469;
  int D.38470;
  const unsigned char * D.38475;
  unsigned char D.38476;
  int D.38477;
  const unsigned char * D.38482;
  unsigned char D.38483;
  int D.38484;
  int D.23694;
  int iftmp.591;
  int D.23693;
  const char[5] * D.38489;
  unsigned char D.38490;
  int D.38491;
  unsigned char D.38492;
  int D.38493;
  const unsigned char * D.38498;
  unsigned char D.38499;
  int D.38500;
  const unsigned char * D.38501;
  unsigned char D.38502;
  int D.38503;
  const unsigned char * D.38508;
  unsigned char D.38509;
  int D.38510;
  const unsigned char * D.38511;
  unsigned char D.38512;
  int D.38513;
  const unsigned char * D.38518;
  unsigned char D.38519;
  int D.38520;
  const unsigned char * D.38521;
  unsigned char D.38522;
  int D.38523;
  int D.23703;
  int iftmp.592;
  int D.23702;
  unsigned char D.38529;
  int D.38530;
  const unsigned char * D.38535;
  unsigned char D.38536;
  int D.38537;
  const unsigned char * D.38542;
  unsigned char D.38543;
  int D.38544;
  const unsigned char * D.38549;
  unsigned char D.38550;
  int D.38551;
  struct MonoType * D.38553;
  struct MonoType * D.38556;
  _Bool D.38557;
  long int D.38558;
  long int D.38559;
  struct MonoType * D.38562;
  struct MonoClass * D.38563;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoClass * parent;
  void failure = <<< error >>>;

  try
    {
      D.38186 = tb->parent;
      D.38187 = mono_reflection_type_resolve_user_types (D.38186);
      tb->parent = D.38187;
      mono_loader_lock ();
      D.38186 = tb->parent;
      if (D.38186 != 0B) goto <D.38188>; else goto <D.38189>;
      <D.38188>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.38186 = tb->parent;
          D.38193 = D.38186->vtable;
          D.38194 = D.38193->klass;
          __s2 = D.38194->name;
          D.38195 = "TypeBuilder";
          D.38196 = MEM[(const unsigned char *)D.38195];
          D.38197 = (int) D.38196;
          D.38198 = *__s2;
          D.38199 = (int) D.38198;
          __result = D.38197 - D.38199;
          {
            if (__s2_len != 0) goto <D.38200>; else goto <D.38201>;
            <D.38200>:
            if (__result == 0) goto <D.38202>; else goto <D.38203>;
            <D.38202>:
            D.38204 = &MEM[(void *)"TypeBuilder" + 1B];
            D.38205 = *D.38204;
            D.38206 = (int) D.38205;
            D.38207 = __s2 + 1;
            D.38208 = *D.38207;
            D.38209 = (int) D.38208;
            __result = D.38206 - D.38209;
            if (__s2_len > 1) goto <D.38210>; else goto <D.38211>;
            <D.38210>:
            if (__result == 0) goto <D.38212>; else goto <D.38213>;
            <D.38212>:
            D.38214 = &MEM[(void *)"TypeBuilder" + 2B];
            D.38215 = *D.38214;
            D.38216 = (int) D.38215;
            D.38217 = __s2 + 2;
            D.38218 = *D.38217;
            D.38219 = (int) D.38218;
            __result = D.38216 - D.38219;
            if (__s2_len > 2) goto <D.38220>; else goto <D.38221>;
            <D.38220>:
            if (__result == 0) goto <D.38222>; else goto <D.38223>;
            <D.38222>:
            D.38224 = &MEM[(void *)"TypeBuilder" + 3B];
            D.38225 = *D.38224;
            D.38226 = (int) D.38225;
            D.38227 = __s2 + 3;
            D.38228 = *D.38227;
            D.38229 = (int) D.38228;
            __result = D.38226 - D.38229;
            <D.38223>:
            <D.38221>:
            <D.38213>:
            <D.38211>:
            <D.38203>:
            <D.38201>:
          }
          D.23628 = __result;
        }
        iftmp.584 = -D.23628;
        goto <D.38230>;
        <D.38192>:
        D.38186 = tb->parent;
        D.38193 = D.38186->vtable;
        D.38194 = D.38193->klass;
        D.38231 = D.38194->name;
        iftmp.584 = __builtin_strcmp (D.38231, "TypeBuilder");
        <D.38230>:
        D.23629 = iftmp.584;
      }
      if (D.23629 == 0) goto <D.38232>; else goto <D.38233>;
      <D.38232>:
      D.38186 = tb->parent;
      D.38234 = mono_reflection_type_get_handle (D.38186);
      parent = D.38234->data.klass;
      goto <D.38235>;
      <D.38233>:
      D.38186 = tb->parent;
      D.38236 = mono_reflection_type_get_handle (D.38186);
      parent = mono_class_from_mono_type (D.38236);
      <D.38235>:
      goto <D.38237>;
      <D.38189>:
      parent = 0B;
      <D.38237>:
      D.38238 = tb->type.type;
      if (D.38238 != 0B) goto <D.38239>; else goto <D.38240>;
      <D.38239>:
      D.38238 = tb->type.type;
      klass = mono_class_from_mono_type (D.38238);
      klass->parent = 0B;
      klass->supertypes = 0B;
      mono_class_setup_parent (klass, parent);
      mono_class_setup_mono_type (klass);
      mono_loader_unlock ();
      return;
      <D.38240>:
      D.38241 = tb->module;
      D.38242 = D.38241->dynamic_image;
      D.38243 = &D.38242->image;
      klass = mono_image_alloc0 (D.38243, 272);
      D.38241 = tb->module;
      D.38242 = D.38241->dynamic_image;
      D.38243 = &D.38242->image;
      klass->image = D.38243;
      klass->inited = 1;
      D.38244 = klass->image;
      D.38245 = tb->name;
      D.38246 = mono_string_to_utf8_image (D.38244, D.38245, &error);
      klass->name = D.38246;
      D.38247 = mono_error_ok (&error);
      if (D.38247 == 0) goto failure; else goto <D.38248>;
      <D.38248>:
      D.38244 = klass->image;
      D.38249 = tb->nspace;
      D.38250 = mono_string_to_utf8_image (D.38244, D.38249, &error);
      klass->name_space = D.38250;
      D.38251 = mono_error_ok (&error);
      if (D.38251 == 0) goto failure; else goto <D.38252>;
      <D.38252>:
      D.38253 = tb->table_idx;
      D.38254 = D.38253 | 33554432;
      klass->type_token = D.38254;
      D.38255 = tb->attrs;
      klass->flags = D.38255;
      mono_profiler_class_event (klass, 0);
      klass->element_class = klass;
      D.38256 = mono_class_get_ref_info (klass);
      if (D.38256 == 0B) goto <D.38257>; else goto <D.38258>;
      <D.38257>:
      mono_class_set_ref_info (klass, tb);
      D.38259 = tb->nesting_type;
      if (D.38259 == 0B) goto <D.38260>; else goto <D.38261>;
      <D.38260>:
      D.38244 = klass->image;
      D.38262 = klass->name_space;
      D.38263 = klass->name;
      D.38253 = tb->table_idx;
      mono_image_add_to_name_cache (D.38244, D.38262, D.38263, D.38253);
      <D.38261>:
      mono_image_append_class_to_reflection_info_set (klass);
      goto <D.38264>;
      <D.38258>:
      D.38265 = mono_class_get_ref_info (klass);
      D.38266 = D.38265 != tb;
      D.38267 = (long int) D.38266;
      D.38268 = __builtin_expect (D.38267, 0);
      if (D.38268 != 0) goto <D.38269>; else goto <D.38270>;
      <D.38269>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9854, "mono_class_get_ref_info (klass) == tb");
      <D.38270>:
      <D.38264>:
      D.38241 = tb->module;
      D.38242 = D.38241->dynamic_image;
      D.38271 = D.38242->tokens;
      D.38253 = tb->table_idx;
      D.38254 = D.38253 | 33554432;
      D.38272 = (long unsigned int) D.38254;
      D.38273 = (void *) D.38272;
      mono_g_hash_table_insert (D.38271, D.38273, tb);
      if (parent != 0B) goto <D.38274>; else goto <D.38275>;
      <D.38274>:
      mono_class_setup_parent (klass, parent);
      goto <D.38276>;
      <D.38275>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38280 = "Object";
          D.38281 = MEM[(const unsigned char *)D.38280];
          D.38282 = (int) D.38281;
          D.38283 = *__s2;
          D.38284 = (int) D.38283;
          __result = D.38282 - D.38284;
          {
            if (__s2_len != 0) goto <D.38285>; else goto <D.38286>;
            <D.38285>:
            if (__result == 0) goto <D.38287>; else goto <D.38288>;
            <D.38287>:
            D.38289 = &MEM[(void *)"Object" + 1B];
            D.38290 = *D.38289;
            D.38291 = (int) D.38290;
            D.38292 = __s2 + 1;
            D.38293 = *D.38292;
            D.38294 = (int) D.38293;
            __result = D.38291 - D.38294;
            if (__s2_len > 1) goto <D.38295>; else goto <D.38296>;
            <D.38295>:
            if (__result == 0) goto <D.38297>; else goto <D.38298>;
            <D.38297>:
            D.38299 = &MEM[(void *)"Object" + 2B];
            D.38300 = *D.38299;
            D.38301 = (int) D.38300;
            D.38302 = __s2 + 2;
            D.38303 = *D.38302;
            D.38304 = (int) D.38303;
            __result = D.38301 - D.38304;
            if (__s2_len > 2) goto <D.38305>; else goto <D.38306>;
            <D.38305>:
            if (__result == 0) goto <D.38307>; else goto <D.38308>;
            <D.38307>:
            D.38309 = &MEM[(void *)"Object" + 3B];
            D.38310 = *D.38309;
            D.38311 = (int) D.38310;
            D.38312 = __s2 + 3;
            D.38313 = *D.38312;
            D.38314 = (int) D.38313;
            __result = D.38311 - D.38314;
            <D.38308>:
            <D.38306>:
            <D.38298>:
            <D.38296>:
            <D.38288>:
            <D.38286>:
          }
          D.23638 = __result;
        }
        iftmp.585 = -D.23638;
        goto <D.38315>;
        <D.38279>:
        D.38263 = klass->name;
        iftmp.585 = __builtin_strcmp (D.38263, "Object");
        <D.38315>:
        D.23639 = iftmp.585;
      }
      if (D.23639 == 0) goto <D.38316>; else goto <D.38317>;
      <D.38316>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.38321 = "System";
          D.38322 = MEM[(const unsigned char *)D.38321];
          D.38323 = (int) D.38322;
          D.38324 = *__s2;
          D.38325 = (int) D.38324;
          __result = D.38323 - D.38325;
          {
            if (__s2_len != 0) goto <D.38326>; else goto <D.38327>;
            <D.38326>:
            if (__result == 0) goto <D.38328>; else goto <D.38329>;
            <D.38328>:
            D.38330 = &MEM[(void *)"System" + 1B];
            D.38331 = *D.38330;
            D.38332 = (int) D.38331;
            D.38333 = __s2 + 1;
            D.38334 = *D.38333;
            D.38335 = (int) D.38334;
            __result = D.38332 - D.38335;
            if (__s2_len > 1) goto <D.38336>; else goto <D.38337>;
            <D.38336>:
            if (__result == 0) goto <D.38338>; else goto <D.38339>;
            <D.38338>:
            D.38340 = &MEM[(void *)"System" + 2B];
            D.38341 = *D.38340;
            D.38342 = (int) D.38341;
            D.38343 = __s2 + 2;
            D.38344 = *D.38343;
            D.38345 = (int) D.38344;
            __result = D.38342 - D.38345;
            if (__s2_len > 2) goto <D.38346>; else goto <D.38347>;
            <D.38346>:
            if (__result == 0) goto <D.38348>; else goto <D.38349>;
            <D.38348>:
            D.38350 = &MEM[(void *)"System" + 3B];
            D.38351 = *D.38350;
            D.38352 = (int) D.38351;
            D.38353 = __s2 + 3;
            D.38354 = *D.38353;
            D.38355 = (int) D.38354;
            __result = D.38352 - D.38355;
            <D.38349>:
            <D.38347>:
            <D.38339>:
            <D.38337>:
            <D.38329>:
            <D.38327>:
          }
          D.23647 = __result;
        }
        iftmp.586 = -D.23647;
        goto <D.38356>;
        <D.38320>:
        D.38262 = klass->name_space;
        iftmp.586 = __builtin_strcmp (D.38262, "System");
        <D.38356>:
        D.23648 = iftmp.586;
      }
      if (D.23648 == 0) goto <D.38357>; else goto <D.38358>;
      <D.38357>:
      {
        const char * old_n;

        old_n = klass->name;
        klass->name = "BuildingObject";
        D.38359 = mono_defaults.object_class;
        mono_class_setup_parent (klass, D.38359);
        klass->name = old_n;
      }
      <D.38358>:
      <D.38317>:
      <D.38276>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38367 = "ValueType";
          D.38368 = MEM[(const unsigned char *)D.38367];
          D.38369 = (int) D.38368;
          D.38370 = *__s2;
          D.38371 = (int) D.38370;
          __result = D.38369 - D.38371;
          {
            if (__s2_len != 0) goto <D.38372>; else goto <D.38373>;
            <D.38372>:
            if (__result == 0) goto <D.38374>; else goto <D.38375>;
            <D.38374>:
            D.38376 = &MEM[(void *)"ValueType" + 1B];
            D.38377 = *D.38376;
            D.38378 = (int) D.38377;
            D.38379 = __s2 + 1;
            D.38380 = *D.38379;
            D.38381 = (int) D.38380;
            __result = D.38378 - D.38381;
            if (__s2_len > 1) goto <D.38382>; else goto <D.38383>;
            <D.38382>:
            if (__result == 0) goto <D.38384>; else goto <D.38385>;
            <D.38384>:
            D.38386 = &MEM[(void *)"ValueType" + 2B];
            D.38387 = *D.38386;
            D.38388 = (int) D.38387;
            D.38389 = __s2 + 2;
            D.38390 = *D.38389;
            D.38391 = (int) D.38390;
            __result = D.38388 - D.38391;
            if (__s2_len > 2) goto <D.38392>; else goto <D.38393>;
            <D.38392>:
            if (__result == 0) goto <D.38394>; else goto <D.38395>;
            <D.38394>:
            D.38396 = &MEM[(void *)"ValueType" + 3B];
            D.38397 = *D.38396;
            D.38398 = (int) D.38397;
            D.38399 = __s2 + 3;
            D.38400 = *D.38399;
            D.38401 = (int) D.38400;
            __result = D.38398 - D.38401;
            <D.38395>:
            <D.38393>:
            <D.38385>:
            <D.38383>:
            <D.38375>:
            <D.38373>:
          }
          D.23657 = __result;
        }
        iftmp.587 = -D.23657;
        goto <D.38402>;
        <D.38366>:
        D.38263 = klass->name;
        iftmp.587 = __builtin_strcmp (D.38263, "ValueType");
        <D.38402>:
        D.23658 = iftmp.587;
      }
      if (D.23658 == 0) goto <D.38403>; else goto <D.38360>;
      <D.38403>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.38321 = "System";
          D.38322 = MEM[(const unsigned char *)D.38321];
          D.38323 = (int) D.38322;
          D.38407 = *__s2;
          D.38408 = (int) D.38407;
          __result = D.38323 - D.38408;
          {
            if (__s2_len != 0) goto <D.38409>; else goto <D.38410>;
            <D.38409>:
            if (__result == 0) goto <D.38411>; else goto <D.38412>;
            <D.38411>:
            D.38330 = &MEM[(void *)"System" + 1B];
            D.38331 = *D.38330;
            D.38332 = (int) D.38331;
            D.38413 = __s2 + 1;
            D.38414 = *D.38413;
            D.38415 = (int) D.38414;
            __result = D.38332 - D.38415;
            if (__s2_len > 1) goto <D.38416>; else goto <D.38417>;
            <D.38416>:
            if (__result == 0) goto <D.38418>; else goto <D.38419>;
            <D.38418>:
            D.38340 = &MEM[(void *)"System" + 2B];
            D.38341 = *D.38340;
            D.38342 = (int) D.38341;
            D.38420 = __s2 + 2;
            D.38421 = *D.38420;
            D.38422 = (int) D.38421;
            __result = D.38342 - D.38422;
            if (__s2_len > 2) goto <D.38423>; else goto <D.38424>;
            <D.38423>:
            if (__result == 0) goto <D.38425>; else goto <D.38426>;
            <D.38425>:
            D.38350 = &MEM[(void *)"System" + 3B];
            D.38351 = *D.38350;
            D.38352 = (int) D.38351;
            D.38427 = __s2 + 3;
            D.38428 = *D.38427;
            D.38429 = (int) D.38428;
            __result = D.38352 - D.38429;
            <D.38426>:
            <D.38424>:
            <D.38419>:
            <D.38417>:
            <D.38412>:
            <D.38410>:
          }
          D.23666 = __result;
        }
        iftmp.588 = -D.23666;
        goto <D.38430>;
        <D.38406>:
        D.38262 = klass->name_space;
        iftmp.588 = __builtin_strcmp (D.38262, "System");
        <D.38430>:
        D.23667 = iftmp.588;
      }
      if (D.23667 == 0) goto <D.38361>; else goto <D.38360>;
      <D.38360>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38280 = "Object";
          D.38281 = MEM[(const unsigned char *)D.38280];
          D.38282 = (int) D.38281;
          D.38434 = *__s2;
          D.38435 = (int) D.38434;
          __result = D.38282 - D.38435;
          {
            if (__s2_len != 0) goto <D.38436>; else goto <D.38437>;
            <D.38436>:
            if (__result == 0) goto <D.38438>; else goto <D.38439>;
            <D.38438>:
            D.38289 = &MEM[(void *)"Object" + 1B];
            D.38290 = *D.38289;
            D.38291 = (int) D.38290;
            D.38440 = __s2 + 1;
            D.38441 = *D.38440;
            D.38442 = (int) D.38441;
            __result = D.38291 - D.38442;
            if (__s2_len > 1) goto <D.38443>; else goto <D.38444>;
            <D.38443>:
            if (__result == 0) goto <D.38445>; else goto <D.38446>;
            <D.38445>:
            D.38299 = &MEM[(void *)"Object" + 2B];
            D.38300 = *D.38299;
            D.38301 = (int) D.38300;
            D.38447 = __s2 + 2;
            D.38448 = *D.38447;
            D.38449 = (int) D.38448;
            __result = D.38301 - D.38449;
            if (__s2_len > 2) goto <D.38450>; else goto <D.38451>;
            <D.38450>:
            if (__result == 0) goto <D.38452>; else goto <D.38453>;
            <D.38452>:
            D.38309 = &MEM[(void *)"Object" + 3B];
            D.38310 = *D.38309;
            D.38311 = (int) D.38310;
            D.38454 = __s2 + 3;
            D.38455 = *D.38454;
            D.38456 = (int) D.38455;
            __result = D.38311 - D.38456;
            <D.38453>:
            <D.38451>:
            <D.38446>:
            <D.38444>:
            <D.38439>:
            <D.38437>:
          }
          D.23675 = __result;
        }
        iftmp.589 = -D.23675;
        goto <D.38457>;
        <D.38433>:
        D.38263 = klass->name;
        iftmp.589 = __builtin_strcmp (D.38263, "Object");
        <D.38457>:
        D.23676 = iftmp.589;
      }
      if (D.23676 == 0) goto <D.38458>; else goto <D.38362>;
      <D.38458>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.38321 = "System";
          D.38322 = MEM[(const unsigned char *)D.38321];
          D.38323 = (int) D.38322;
          D.38462 = *__s2;
          D.38463 = (int) D.38462;
          __result = D.38323 - D.38463;
          {
            if (__s2_len != 0) goto <D.38464>; else goto <D.38465>;
            <D.38464>:
            if (__result == 0) goto <D.38466>; else goto <D.38467>;
            <D.38466>:
            D.38330 = &MEM[(void *)"System" + 1B];
            D.38331 = *D.38330;
            D.38332 = (int) D.38331;
            D.38468 = __s2 + 1;
            D.38469 = *D.38468;
            D.38470 = (int) D.38469;
            __result = D.38332 - D.38470;
            if (__s2_len > 1) goto <D.38471>; else goto <D.38472>;
            <D.38471>:
            if (__result == 0) goto <D.38473>; else goto <D.38474>;
            <D.38473>:
            D.38340 = &MEM[(void *)"System" + 2B];
            D.38341 = *D.38340;
            D.38342 = (int) D.38341;
            D.38475 = __s2 + 2;
            D.38476 = *D.38475;
            D.38477 = (int) D.38476;
            __result = D.38342 - D.38477;
            if (__s2_len > 2) goto <D.38478>; else goto <D.38479>;
            <D.38478>:
            if (__result == 0) goto <D.38480>; else goto <D.38481>;
            <D.38480>:
            D.38350 = &MEM[(void *)"System" + 3B];
            D.38351 = *D.38350;
            D.38352 = (int) D.38351;
            D.38482 = __s2 + 3;
            D.38483 = *D.38482;
            D.38484 = (int) D.38483;
            __result = D.38352 - D.38484;
            <D.38481>:
            <D.38479>:
            <D.38474>:
            <D.38472>:
            <D.38467>:
            <D.38465>:
          }
          D.23684 = __result;
        }
        iftmp.590 = -D.23684;
        goto <D.38485>;
        <D.38461>:
        D.38262 = klass->name_space;
        iftmp.590 = __builtin_strcmp (D.38262, "System");
        <D.38485>:
        D.23685 = iftmp.590;
      }
      if (D.23685 == 0) goto <D.38361>; else goto <D.38362>;
      <D.38362>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38489 = "Enum";
          D.38490 = MEM[(const unsigned char *)D.38489];
          D.38491 = (int) D.38490;
          D.38492 = *__s2;
          D.38493 = (int) D.38492;
          __result = D.38491 - D.38493;
          {
            if (__s2_len != 0) goto <D.38494>; else goto <D.38495>;
            <D.38494>:
            if (__result == 0) goto <D.38496>; else goto <D.38497>;
            <D.38496>:
            D.38498 = &MEM[(void *)"Enum" + 1B];
            D.38499 = *D.38498;
            D.38500 = (int) D.38499;
            D.38501 = __s2 + 1;
            D.38502 = *D.38501;
            D.38503 = (int) D.38502;
            __result = D.38500 - D.38503;
            if (__s2_len > 1) goto <D.38504>; else goto <D.38505>;
            <D.38504>:
            if (__result == 0) goto <D.38506>; else goto <D.38507>;
            <D.38506>:
            D.38508 = &MEM[(void *)"Enum" + 2B];
            D.38509 = *D.38508;
            D.38510 = (int) D.38509;
            D.38511 = __s2 + 2;
            D.38512 = *D.38511;
            D.38513 = (int) D.38512;
            __result = D.38510 - D.38513;
            if (__s2_len > 2) goto <D.38514>; else goto <D.38515>;
            <D.38514>:
            if (__result == 0) goto <D.38516>; else goto <D.38517>;
            <D.38516>:
            D.38518 = &MEM[(void *)"Enum" + 3B];
            D.38519 = *D.38518;
            D.38520 = (int) D.38519;
            D.38521 = __s2 + 3;
            D.38522 = *D.38521;
            D.38523 = (int) D.38522;
            __result = D.38520 - D.38523;
            <D.38517>:
            <D.38515>:
            <D.38507>:
            <D.38505>:
            <D.38497>:
            <D.38495>:
          }
          D.23693 = __result;
        }
        iftmp.591 = -D.23693;
        goto <D.38524>;
        <D.38488>:
        D.38263 = klass->name;
        iftmp.591 = __builtin_strcmp (D.38263, "Enum");
        <D.38524>:
        D.23694 = iftmp.591;
      }
      if (D.23694 == 0) goto <D.38525>; else goto <D.38363>;
      <D.38525>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.38321 = "System";
          D.38322 = MEM[(const unsigned char *)D.38321];
          D.38323 = (int) D.38322;
          D.38529 = *__s2;
          D.38530 = (int) D.38529;
          __result = D.38323 - D.38530;
          {
            if (__s2_len != 0) goto <D.38531>; else goto <D.38532>;
            <D.38531>:
            if (__result == 0) goto <D.38533>; else goto <D.38534>;
            <D.38533>:
            D.38330 = &MEM[(void *)"System" + 1B];
            D.38331 = *D.38330;
            D.38332 = (int) D.38331;
            D.38535 = __s2 + 1;
            D.38536 = *D.38535;
            D.38537 = (int) D.38536;
            __result = D.38332 - D.38537;
            if (__s2_len > 1) goto <D.38538>; else goto <D.38539>;
            <D.38538>:
            if (__result == 0) goto <D.38540>; else goto <D.38541>;
            <D.38540>:
            D.38340 = &MEM[(void *)"System" + 2B];
            D.38341 = *D.38340;
            D.38342 = (int) D.38341;
            D.38542 = __s2 + 2;
            D.38543 = *D.38542;
            D.38544 = (int) D.38543;
            __result = D.38342 - D.38544;
            if (__s2_len > 2) goto <D.38545>; else goto <D.38546>;
            <D.38545>:
            if (__result == 0) goto <D.38547>; else goto <D.38548>;
            <D.38547>:
            D.38350 = &MEM[(void *)"System" + 3B];
            D.38351 = *D.38350;
            D.38352 = (int) D.38351;
            D.38549 = __s2 + 3;
            D.38550 = *D.38549;
            D.38551 = (int) D.38550;
            __result = D.38352 - D.38551;
            <D.38548>:
            <D.38546>:
            <D.38541>:
            <D.38539>:
            <D.38534>:
            <D.38532>:
          }
          D.23702 = __result;
        }
        iftmp.592 = -D.23702;
        goto <D.38552>;
        <D.38528>:
        D.38262 = klass->name_space;
        iftmp.592 = __builtin_strcmp (D.38262, "System");
        <D.38552>:
        D.23703 = iftmp.592;
      }
      if (D.23703 == 0) goto <D.38361>; else goto <D.38363>;
      <D.38361>:
      klass->instance_size = 16;
      klass->size_inited = 1;
      mono_class_setup_vtable_general (klass, 0B, 0, 0B);
      <D.38363>:
      mono_class_setup_mono_type (klass);
      mono_class_setup_supertypes (klass);
      D.38553 = &klass->byval_arg;
      tb->type.type = D.38553;
      D.38259 = tb->nesting_type;
      if (D.38259 != 0B) goto <D.38554>; else goto <D.38555>;
      <D.38554>:
      D.38259 = tb->nesting_type;
      D.38556 = D.38259->type;
      D.38557 = D.38556 == 0B;
      D.38558 = (long int) D.38557;
      D.38559 = __builtin_expect (D.38558, 0);
      if (D.38559 != 0) goto <D.38560>; else goto <D.38561>;
      <D.38560>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9889, "tb->nesting_type->type");
      <D.38561>:
      D.38259 = tb->nesting_type;
      D.38562 = mono_reflection_type_get_handle (D.38259);
      D.38563 = mono_class_from_mono_type (D.38562);
      klass->nested_in = D.38563;
      <D.38555>:
      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.38567;
  int iftmp.593;
  struct MonoArray * D.38569;
  long unsigned int D.38572;
  struct MonoGenericContainer * D.38576;
  int iftmp.594;
  struct MonoGenericContainer * D.38582;
  struct MonoClass * D.38584;
  _Bool D.38585;
  long int D.38586;
  long int D.38587;
  struct MonoImage * D.38590;
  void * D.38591;
  <unnamed-signed:31> D.38592;
  long unsigned int D.38593;
  unsigned int D.38594;
  unsigned int D.38595;
  void * D.38596;
  long unsigned int D.38597;
  char * D.38598;
  struct MonoType * D.38599;
  struct MonoGenericParamFull * D.38600;
  long unsigned int D.38601;
  long unsigned int D.38602;
  struct MonoGenericParamFull * D.38603;
  unsigned int D.38604;
  short unsigned int D.38605;
  struct MonoGenericContainer * D.38606;
  _Bool D.38607;
  long int D.38608;
  long int D.38609;
  struct MonoGenericInst * D.38612;
  struct MonoClass * klass;
  int count;
  int i;

  D.38567 = tb->type.type;
  klass = mono_class_from_mono_type (D.38567);
  D.38569 = tb->generic_params;
  if (D.38569 != 0B) goto <D.38570>; else goto <D.38571>;
  <D.38570>:
  D.38569 = tb->generic_params;
  D.38572 = mono_array_length (D.38569);
  iftmp.593 = (int) D.38572;
  goto <D.38573>;
  <D.38571>:
  iftmp.593 = 0;
  <D.38573>:
  count = iftmp.593;
  D.38576 = klass->generic_container;
  if (D.38576 != 0B) goto <D.38574>; else goto <D.38577>;
  <D.38577>:
  if (count == 0) goto <D.38574>; else goto <D.38575>;
  <D.38574>:
  return;
  <D.38575>:
  D.38582 = tb->generic_container;
  if (D.38582 == 0B) goto <D.38579>; else goto <D.38583>;
  <D.38583>:
  D.38582 = tb->generic_container;
  D.38584 = D.38582->owner.klass;
  if (D.38584 != klass) goto <D.38579>; else goto <D.38580>;
  <D.38579>:
  iftmp.594 = 1;
  goto <D.38581>;
  <D.38580>:
  iftmp.594 = 0;
  <D.38581>:
  D.38585 = iftmp.594 != 0;
  D.38586 = (long int) D.38585;
  D.38587 = __builtin_expect (D.38586, 0);
  if (D.38587 != 0) goto <D.38588>; else goto <D.38589>;
  <D.38588>:
  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.38589>:
  D.38590 = klass->image;
  D.38591 = mono_image_alloc0 (D.38590, 56);
  klass->generic_container = D.38591;
  D.38576 = klass->generic_container;
  D.38576->owner.klass = klass;
  D.38576 = klass->generic_container;
  D.38592 = (<unnamed-signed:31>) count;
  D.38576->type_argc = D.38592;
  D.38576 = klass->generic_container;
  D.38590 = klass->image;
  D.38593 = (long unsigned int) count;
  D.38594 = (unsigned int) D.38593;
  D.38595 = D.38594 * 56;
  D.38596 = mono_image_alloc0 (D.38590, D.38595);
  D.38576->type_params = D.38596;
  klass->is_generic = 1;
  i = 0;
  goto <D.23716>;
  <D.23715>:
  {
    struct MonoReflectionGenericParam * gparam;
    struct MonoGenericParamFull * param;

    D.38569 = tb->generic_params;
    D.38597 = (long unsigned int) i;
    D.38598 = mono_array_addr_with_size (D.38569, 8, D.38597);
    gparam = MEM[(void * *)D.38598];
    D.38599 = mono_reflection_type_get_handle (gparam);
    param = D.38599->data.generic_param;
    D.38576 = klass->generic_container;
    D.38600 = D.38576->type_params;
    D.38601 = (long unsigned int) i;
    D.38602 = D.38601 * 56;
    D.38603 = D.38600 + D.38602;
    *D.38603 = *param;
    D.38576 = klass->generic_container;
    D.38600 = D.38576->type_params;
    D.38601 = (long unsigned int) i;
    D.38602 = D.38601 * 56;
    D.38603 = D.38600 + D.38602;
    D.38576 = klass->generic_container;
    D.38603->param.owner = D.38576;
    D.38576 = klass->generic_container;
    D.38600 = D.38576->type_params;
    D.38601 = (long unsigned int) i;
    D.38602 = D.38601 * 56;
    D.38603 = D.38600 + D.38602;
    D.38603->info.pklass = 0B;
    D.38576 = klass->generic_container;
    D.38600 = D.38576->type_params;
    D.38601 = (long unsigned int) i;
    D.38602 = D.38601 * 56;
    D.38603 = D.38600 + D.38602;
    D.38604 = gparam->attrs;
    D.38605 = (short unsigned int) D.38604;
    D.38603->info.flags = D.38605;
    D.38576 = klass->generic_container;
    D.38600 = D.38576->type_params;
    D.38601 = (long unsigned int) i;
    D.38602 = D.38601 * 56;
    D.38603 = D.38600 + D.38602;
    D.38606 = D.38603->param.owner;
    D.38607 = D.38606 == 0B;
    D.38608 = (long int) D.38607;
    D.38609 = __builtin_expect (D.38608, 0);
    if (D.38609 != 0) goto <D.38610>; else goto <D.38611>;
    <D.38610>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9956, "klass->generic_container->type_params [i].param.owner");
    <D.38611>:
  }
  i = i + 1;
  <D.23716>:
  if (i < count) goto <D.23715>; else goto <D.23717>;
  <D.23717>:
  D.38576 = klass->generic_container;
  D.38576 = klass->generic_container;
  D.38612 = mono_get_shared_generic_inst (D.38576);
  D.38576->context.class_inst = D.38612;
}


mono_reflection_create_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoType * D.38614;
  long unsigned int D.38615;
  long unsigned int D.38616;
  struct MonoType * D.38619;
  struct MonoArray * D.38622;
  _Bool D.38623;
  long int D.38624;
  long int D.38625;
  long unsigned int D.38628;
  _Bool D.38629;
  long int D.38630;
  long int D.38631;
  char * D.38634;
  struct MonoObject * D.38635;
  struct MonoType * D.38636;
  int D.38637;
  struct MonoClass * D.38640;
  struct MonoClass * D.38641;
  struct MonoClass * D.38644;
  int D.38645;
  struct MonoClass * klass;

  D.38614 = tb->type.type;
  klass = mono_class_from_mono_type (D.38614);
  mono_loader_lock ();
  D.38615 = BIT_FIELD_REF <*klass, 64, 256>;
  D.38616 = D.38615 & 16;
  if (D.38616 != 0) goto <D.38617>; else goto <D.38618>;
  <D.38617>:
  D.38619 = mono_class_enum_basetype (klass);
  if (D.38619 == 0B) goto <D.38620>; else goto <D.38621>;
  <D.38620>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoClass * ec;
    struct MonoType * enum_basetype;

    D.38622 = tb->fields;
    D.38623 = D.38622 == 0B;
    D.38624 = (long int) D.38623;
    D.38625 = __builtin_expect (D.38624, 0);
    if (D.38625 != 0) goto <D.38626>; else goto <D.38627>;
    <D.38626>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9983, "tb->fields != NULL");
    <D.38627>:
    D.38622 = tb->fields;
    D.38628 = mono_array_length (D.38622);
    D.38629 = D.38628 == 0;
    D.38630 = (long int) D.38629;
    D.38631 = __builtin_expect (D.38630, 0);
    if (D.38631 != 0) goto <D.38632>; else goto <D.38633>;
    <D.38632>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9984, "mono_array_length (tb->fields) >= 1");
    <D.38633>:
    D.38622 = tb->fields;
    D.38634 = mono_array_addr_with_size (D.38622, 8, 0);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.38634];
    D.38635 = fb->type;
    D.38636 = mono_reflection_type_get_handle (D.38635);
    D.38637 = mono_type_is_valid_enum_basetype (D.38636);
    if (D.38637 == 0) goto <D.38638>; else goto <D.38639>;
    <D.38638>:
    mono_loader_unlock ();
    return;
    <D.38639>:
    D.38635 = fb->type;
    enum_basetype = mono_reflection_type_get_handle (D.38635);
    D.38640 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.38640;
    D.38641 = klass->element_class;
    if (D.38641 == 0B) goto <D.38642>; else goto <D.38643>;
    <D.38642>:
    D.38644 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.38644;
    <D.38643>:
    ec = default_class_from_mono_type (enum_basetype);
    D.38645 = ec->instance_size;
    klass->instance_size = D.38645;
    klass->size_inited = 1;
    mono_class_setup_vtable_general (klass, 0B, 0, 0B);
  }
  <D.38621>:
  <D.38618>:
  mono_loader_unlock ();
}


default_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.38647;
  int D.38648;
  struct MonoClass * D.38649;

  D.38647 = type->type;
  D.38648 = (int) D.38647;
  switch (D.38648) <default: <D.19343>, case 1: <D.19327>, case 2: <D.19328>, case 3: <D.19329>, case 4: <D.19330>, case 5: <D.19331>, case 6: <D.19332>, case 7: <D.19333>, case 8: <D.19334>, case 9: <D.19335>, case 10: <D.19338>, case 11: <D.19339>, case 12: <D.19340>, case 13: <D.19341>, case 14: <D.19342>, case 24: <D.19336>, case 25: <D.19337>, case 28: <D.19326>>
  <D.19326>:
  D.38649 = mono_defaults.object_class;
  return D.38649;
  <D.19327>:
  D.38649 = mono_defaults.void_class;
  return D.38649;
  <D.19328>:
  D.38649 = mono_defaults.boolean_class;
  return D.38649;
  <D.19329>:
  D.38649 = mono_defaults.char_class;
  return D.38649;
  <D.19330>:
  D.38649 = mono_defaults.sbyte_class;
  return D.38649;
  <D.19331>:
  D.38649 = mono_defaults.byte_class;
  return D.38649;
  <D.19332>:
  D.38649 = mono_defaults.int16_class;
  return D.38649;
  <D.19333>:
  D.38649 = mono_defaults.uint16_class;
  return D.38649;
  <D.19334>:
  D.38649 = mono_defaults.int32_class;
  return D.38649;
  <D.19335>:
  D.38649 = mono_defaults.uint32_class;
  return D.38649;
  <D.19336>:
  D.38649 = mono_defaults.int_class;
  return D.38649;
  <D.19337>:
  D.38649 = mono_defaults.uint_class;
  return D.38649;
  <D.19338>:
  D.38649 = mono_defaults.int64_class;
  return D.38649;
  <D.19339>:
  D.38649 = mono_defaults.uint64_class;
  return D.38649;
  <D.19340>:
  D.38649 = mono_defaults.single_class;
  return D.38649;
  <D.19341>:
  D.38649 = mono_defaults.double_class;
  return D.38649;
  <D.19342>:
  D.38649 = mono_defaults.string_class;
  return D.38649;
  <D.19343>:
  D.38647 = type->type;
  D.38648 = (int) D.38647;
  monoeg_g_log (0B, 16, "default_class_from_mono_type: implement me 0x%02x\n", D.38648);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 616);
  D.38649 = 0B;
  return D.38649;
}


mono_reflection_marshal_as_attribute_from_marshal_spec (struct MonoDomain * domain, struct MonoClass * klass, struct MonoMarshalSpec * spec)
{
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.595;
  struct MonoImage * D.38654;
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.596;
  _Bool D.38656;
  long int D.38657;
  long int D.38658;
  <unnamed type> D.38661;
  unsigned int D.38662;
  <unnamed type> D.38663;
  int D.38664;
  short int D.38665;
  char * D.38668;
  struct MonoImage * D.38671;
  struct MonoReflectionType * * D.38674;
  struct MonoReflectionType * D.38675;
  struct MonoString * * D.38676;
  struct MonoString * D.38677;
  char * D.38678;
  struct MonoString * * D.38681;
  struct MonoString * D.38682;
  struct MonoReflectionMarshalAsAttribute * D.38683;
  static struct MonoClass * System_Reflection_Emit_MarshalAsAttribute;
  struct MonoReflectionMarshalAsAttribute * minfo;
  struct MonoType * mtype;

  System_Reflection_Emit_MarshalAsAttribute.595 = System_Reflection_Emit_MarshalAsAttribute;
  if (System_Reflection_Emit_MarshalAsAttribute.595 == 0B) goto <D.38652>; else goto <D.38653>;
  <D.38652>:
  D.38654 = mono_defaults.corlib;
  System_Reflection_Emit_MarshalAsAttribute.596 = mono_class_from_name (D.38654, "System.Runtime.InteropServices", "MarshalAsAttribute");
  System_Reflection_Emit_MarshalAsAttribute = System_Reflection_Emit_MarshalAsAttribute.596;
  System_Reflection_Emit_MarshalAsAttribute.595 = System_Reflection_Emit_MarshalAsAttribute;
  D.38656 = System_Reflection_Emit_MarshalAsAttribute.595 == 0B;
  D.38657 = (long int) D.38656;
  D.38658 = __builtin_expect (D.38657, 0);
  if (D.38658 != 0) goto <D.38659>; else goto <D.38660>;
  <D.38659>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10070, "System_Reflection_Emit_MarshalAsAttribute");
  <D.38660>:
  <D.38653>:
  System_Reflection_Emit_MarshalAsAttribute.595 = System_Reflection_Emit_MarshalAsAttribute;
  minfo = mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute.595);
  D.38661 = spec->native;
  minfo->utype = D.38661;
  D.38662 = minfo->utype;
  switch (D.38662) <default: <D.23750>, case 23: <D.23747>, case 30: <D.23748>, case 42: <D.23745>, case 44: <D.23749>>
  <D.23745>:
  D.38663 = spec->data.array_data.elem_type;
  minfo->array_subtype = D.38663;
  D.38664 = spec->data.array_data.num_elem;
  minfo->size_const = D.38664;
  D.38665 = spec->data.array_data.param_num;
  if (D.38665 != -1) goto <D.38666>; else goto <D.38667>;
  <D.38666>:
  D.38665 = spec->data.array_data.param_num;
  minfo->size_param_index = D.38665;
  <D.38667>:
  goto <D.23746>;
  <D.23747>:
  <D.23748>:
  D.38664 = spec->data.array_data.num_elem;
  minfo->size_const = D.38664;
  goto <D.23746>;
  <D.23749>:
  D.38668 = spec->data.custom_data.custom_name;
  if (D.38668 != 0B) goto <D.38669>; else goto <D.38670>;
  <D.38669>:
  D.38668 = spec->data.custom_data.custom_name;
  D.38671 = klass->image;
  mtype = mono_reflection_type_from_name (D.38668, D.38671);
  if (mtype != 0B) goto <D.38672>; else goto <D.38673>;
  <D.38672>:
  D.38674 = &minfo->marshal_type_ref;
  D.38675 = mono_type_get_object (domain, mtype);
  mono_gc_wbarrier_set_field (minfo, D.38674, D.38675);
  <D.38673>:
  D.38676 = &minfo->marshal_type;
  D.38668 = spec->data.custom_data.custom_name;
  D.38677 = mono_string_new (domain, D.38668);
  mono_gc_wbarrier_set_field (minfo, D.38676, D.38677);
  <D.38670>:
  D.38678 = spec->data.custom_data.cookie;
  if (D.38678 != 0B) goto <D.38679>; else goto <D.38680>;
  <D.38679>:
  D.38681 = &minfo->marshal_cookie;
  D.38678 = spec->data.custom_data.cookie;
  D.38682 = mono_string_new (domain, D.38678);
  mono_gc_wbarrier_set_field (minfo, D.38681, D.38682);
  <D.38680>:
  goto <D.23746>;
  <D.23750>:
  goto <D.23746>;
  <D.23746>:
  D.38683 = minfo;
  return D.38683;
}


mono_reflection_bind_generic_parameters (struct MonoReflectionType * type, int type_argc, struct MonoType * * types)
{
  struct MonoVTable * D.38686;
  struct MonoClass * D.38687;
  int D.38688;
  int D.38692;
  struct MonoVTable * D.38695;
  struct MonoClass * D.38696;
  int D.38697;
  struct MonoGenericContainer * D.38702;
  struct MonoType * D.38705;
  struct MonoGenericContainer * D.38706;
  struct MonoType * D.38709;
  long unsigned int D.38710;
  long unsigned int D.38711;
  struct MonoClass * klass;
  struct MonoReflectionTypeBuilder * tb;
  gboolean is_dynamic;
  struct MonoDomain * domain;
  struct MonoClass * geninst;

  tb = 0B;
  is_dynamic = 0;
  mono_loader_lock ();
  D.38686 = MEM[(struct MonoObject *)type].vtable;
  domain = D.38686->domain;
  D.38686 = MEM[(struct MonoObject *)type].vtable;
  D.38687 = D.38686->klass;
  D.38688 = is_sre_type_builder (D.38687);
  if (D.38688 != 0) goto <D.38689>; else goto <D.38690>;
  <D.38689>:
  tb = type;
  is_dynamic = 1;
  goto <D.38691>;
  <D.38690>:
  D.38686 = MEM[(struct MonoObject *)type].vtable;
  D.38687 = D.38686->klass;
  D.38692 = is_sre_generic_instance (D.38687);
  if (D.38692 != 0) goto <D.38693>; else goto <D.38694>;
  <D.38693>:
  {
    struct MonoReflectionGenericClass * rgi;
    struct MonoReflectionType * gtd;

    rgi = type;
    gtd = rgi->generic_type;
    D.38695 = MEM[(struct MonoObject *)gtd].vtable;
    D.38696 = D.38695->klass;
    D.38697 = is_sre_type_builder (D.38696);
    if (D.38697 != 0) goto <D.38698>; else goto <D.38699>;
    <D.38698>:
    tb = gtd;
    is_dynamic = 1;
    <D.38699>:
  }
  <D.38694>:
  <D.38691>:
  if (tb != 0B) goto <D.38700>; else goto <D.38701>;
  <D.38700>:
  D.38702 = tb->generic_container;
  if (D.38702 != 0B) goto <D.38703>; else goto <D.38704>;
  <D.38703>:
  mono_reflection_create_generic_class (tb);
  <D.38704>:
  <D.38701>:
  D.38705 = mono_reflection_type_get_handle (type);
  klass = mono_class_from_mono_type (D.38705);
  D.38706 = klass->generic_container;
  if (D.38706 == 0B) goto <D.38707>; else goto <D.38708>;
  <D.38707>:
  mono_loader_unlock ();
  D.38709 = 0B;
  return D.38709;
  <D.38708>:
  D.38710 = BIT_FIELD_REF <*klass, 64, 256>;
  D.38711 = D.38710 & 128;
  if (D.38711 != 0) goto <D.38712>; else goto <D.38713>;
  <D.38712>:
  tb = mono_class_get_ref_info (klass);
  is_dynamic = 1;
  <D.38713>:
  mono_loader_unlock ();
  geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
  D.38709 = &geninst->byval_arg;
  return D.38709;
}


mono_class_bind_generic_parameters (struct MonoClass * klass, int type_argc, struct MonoType * * types, gboolean is_dynamic)
{
  struct MonoGenericContainer * D.38715;
  _Bool D.38716;
  long int D.38717;
  long int D.38718;
  struct MonoClass * D.38721;
  struct MonoGenericClass * gclass;
  struct MonoGenericInst * inst;

  D.38715 = klass->generic_container;
  D.38716 = D.38715 == 0B;
  D.38717 = (long int) D.38716;
  D.38718 = __builtin_expect (D.38717, 0);
  if (D.38718 != 0) goto <D.38719>; else goto <D.38720>;
  <D.38719>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10507, "klass->generic_container");
  <D.38720>:
  inst = mono_metadata_get_generic_inst (type_argc, types);
  gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
  D.38721 = mono_generic_class_get_class (gclass);
  return D.38721;
}


mono_reflection_bind_generic_method_parameters (struct MonoReflectionMethod * rmethod, struct MonoArray * types)
{
  int D.23876;
  int iftmp.597;
  int D.23875;
  struct MonoVTable * D.38726;
  struct MonoClass * D.38727;
  const char[14] * D.38728;
  unsigned char D.38729;
  int D.38730;
  unsigned char D.38731;
  int D.38732;
  const unsigned char * D.38737;
  unsigned char D.38738;
  int D.38739;
  const unsigned char * D.38740;
  unsigned char D.38741;
  int D.38742;
  const unsigned char * D.38747;
  unsigned char D.38748;
  int D.38749;
  const unsigned char * D.38750;
  unsigned char D.38751;
  int D.38752;
  const unsigned char * D.38757;
  unsigned char D.38758;
  int D.38759;
  const unsigned char * D.38760;
  unsigned char D.38761;
  int D.38762;
  const char * D.38764;
  struct MonoType * D.38767;
  long unsigned int D.38769;
  long unsigned int D.38770;
  struct MonoMethodSignature * D.38773;
  short unsigned int D.38774;
  long unsigned int D.38775;
  long unsigned int D.38776;
  struct MonoReflectionMethod * D.38779;
  long unsigned int D.38780;
  long unsigned int D.38781;
  long unsigned int D.38782;
  char * D.38783;
  long unsigned int D.38784;
  long unsigned int D.38785;
  struct MonoType * * D.38786;
  struct MonoType * D.38787;
  struct MonoGenericInst * iftmp.598;
  struct MonoGenericClass * D.38789;
  struct MonoClass * D.38793;
  struct MonoImage * D.38794;
  long unsigned int D.38795;
  long unsigned int D.38796;
  struct MonoGHashTable * D.38799;
  int D.38800;
  struct MonoException * D.38803;
  struct MonoVTable * D.38804;
  struct MonoDomain * D.38805;
  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.38724>; else goto <D.38725>;
        <D.38724>:
        {
          const unsigned char * __s2;
          int __result;

          D.38726 = rmethod->object.vtable;
          D.38727 = D.38726->klass;
          __s2 = D.38727->name;
          D.38728 = "MethodBuilder";
          D.38729 = MEM[(const unsigned char *)D.38728];
          D.38730 = (int) D.38729;
          D.38731 = *__s2;
          D.38732 = (int) D.38731;
          __result = D.38730 - D.38732;
          {
            if (__s2_len != 0) goto <D.38733>; else goto <D.38734>;
            <D.38733>:
            if (__result == 0) goto <D.38735>; else goto <D.38736>;
            <D.38735>:
            D.38737 = &MEM[(void *)"MethodBuilder" + 1B];
            D.38738 = *D.38737;
            D.38739 = (int) D.38738;
            D.38740 = __s2 + 1;
            D.38741 = *D.38740;
            D.38742 = (int) D.38741;
            __result = D.38739 - D.38742;
            if (__s2_len > 1) goto <D.38743>; else goto <D.38744>;
            <D.38743>:
            if (__result == 0) goto <D.38745>; else goto <D.38746>;
            <D.38745>:
            D.38747 = &MEM[(void *)"MethodBuilder" + 2B];
            D.38748 = *D.38747;
            D.38749 = (int) D.38748;
            D.38750 = __s2 + 2;
            D.38751 = *D.38750;
            D.38752 = (int) D.38751;
            __result = D.38749 - D.38752;
            if (__s2_len > 2) goto <D.38753>; else goto <D.38754>;
            <D.38753>:
            if (__result == 0) goto <D.38755>; else goto <D.38756>;
            <D.38755>:
            D.38757 = &MEM[(void *)"MethodBuilder" + 3B];
            D.38758 = *D.38757;
            D.38759 = (int) D.38758;
            D.38760 = __s2 + 3;
            D.38761 = *D.38760;
            D.38762 = (int) D.38761;
            __result = D.38759 - D.38762;
            <D.38756>:
            <D.38754>:
            <D.38746>:
            <D.38744>:
            <D.38736>:
            <D.38734>:
          }
          D.23875 = __result;
        }
        iftmp.597 = -D.23875;
        goto <D.38763>;
        <D.38725>:
        D.38726 = rmethod->object.vtable;
        D.38727 = D.38726->klass;
        D.38764 = D.38727->name;
        iftmp.597 = __builtin_strcmp (D.38764, "MethodBuilder");
        <D.38763>:
        D.23876 = iftmp.597;
      }
      if (D.23876 == 0) goto <D.38765>; else goto <D.38766>;
      <D.38765>:
      {
        struct MonoReflectionMethodBuilder * mb;
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        mb = 0B;
        mb = rmethod;
        tb = mb->type;
        D.38767 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.38767);
        method = methodbuilder_to_mono_method (klass, mb);
      }
      goto <D.38768>;
      <D.38766>:
      method = rmethod->method;
      <D.38768>:
      klass = method->klass;
      D.38769 = BIT_FIELD_REF <*method, 64, 256>;
      D.38770 = D.38769 & 4096;
      if (D.38770 != 0) goto <D.38771>; else goto <D.38772>;
      <D.38771>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.38772>:
      D.38773 = mono_method_signature (method);
      D.38774 = D.38773->generic_param_count;
      count = (int) D.38774;
      D.38775 = (long unsigned int) count;
      D.38776 = mono_array_length (types);
      if (D.38775 != D.38776) goto <D.38777>; else goto <D.38778>;
      <D.38777>:
      D.38779 = 0B;
      return D.38779;
      <D.38778>:
      D.38780 = (long unsigned int) count;
      D.38781 = D.38780 * 8;
      type_argv = monoeg_malloc0 (D.38781);
      i = 0;
      goto <D.23882>;
      <D.23881>:
      {
        struct MonoReflectionType * garg;

        D.38782 = (long unsigned int) i;
        D.38783 = mono_array_addr_with_size (types, 8, D.38782);
        garg = MEM[(void * *)D.38783];
        D.38784 = (long unsigned int) i;
        D.38785 = D.38784 * 8;
        D.38786 = type_argv + D.38785;
        D.38787 = mono_reflection_type_get_handle (garg);
        *D.38786 = D.38787;
      }
      i = i + 1;
      <D.23882>:
      if (i < count) goto <D.23881>; else goto <D.23883>;
      <D.23883>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.38789 = klass->generic_class;
      if (D.38789 != 0B) goto <D.38790>; else goto <D.38791>;
      <D.38790>:
      D.38789 = klass->generic_class;
      iftmp.598 = D.38789->context.class_inst;
      goto <D.38792>;
      <D.38791>:
      iftmp.598 = 0B;
      <D.38792>:
      tmp_context.class_inst = iftmp.598;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      imethod = inflated;
      D.38793 = method->klass;
      D.38794 = D.38793->image;
      D.38795 = BIT_FIELD_REF <*D.38794, 64, 192>;
      D.38796 = D.38795 & 34359738368;
      if (D.38796 != 0) goto <D.38797>; else goto <D.38798>;
      <D.38797>:
      {
        struct MonoDynamicImage * image;

        D.38793 = method->klass;
        image = D.38793->image;
        mono_image_lock (image);
        D.38799 = image->generic_def_objects;
        mono_g_hash_table_insert (D.38799, imethod, rmethod);
        mono_image_unlock (image);
      }
      <D.38798>:
      D.38800 = mono_verifier_is_method_valid_generic_instantiation (inflated);
      if (D.38800 == 0) goto <D.38801>; else goto <D.38802>;
      <D.38801>:
      D.38803 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
      mono_raise_exception (D.38803);
      <D.38802>:
      D.38804 = MEM[(struct MonoObject *)rmethod].vtable;
      D.38805 = D.38804->domain;
      D.38779 = mono_method_get_object (D.38805, inflated, 0B);
      return D.38779;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


mono_reflection_generic_class_initialize (struct MonoReflectionGenericClass * type, struct MonoArray * fields)
{
  unsigned char D.38808;
  _Bool D.38809;
  long int D.38810;
  long int D.38811;
  long unsigned int D.38814;
  long unsigned int D.38815;
  unsigned int D.38818;
  int iftmp.599;
  long unsigned int D.38824;
  struct MonoImageSet * D.38826;
  int D.38827;
  long unsigned int D.38828;
  unsigned int D.38829;
  unsigned int D.38830;
  void * D.38831;
  unsigned int D.38832;
  void * D.38833;
  void * D.38834;
  long unsigned int D.38835;
  char * D.38836;
  int D.23964;
  int iftmp.600;
  int D.23963;
  struct MonoVTable * D.38840;
  struct MonoClass * D.38841;
  const char[13] * D.38842;
  unsigned char D.38843;
  int D.38844;
  unsigned char D.38845;
  int D.38846;
  const unsigned char * D.38851;
  unsigned char D.38852;
  int D.38853;
  const unsigned char * D.38854;
  unsigned char D.38855;
  int D.38856;
  const unsigned char * D.38861;
  unsigned char D.38862;
  int D.38863;
  const unsigned char * D.38864;
  unsigned char D.38865;
  int D.38866;
  const unsigned char * D.38871;
  unsigned char D.38872;
  int D.38873;
  const unsigned char * D.38874;
  unsigned char D.38875;
  int D.38876;
  const char * D.38878;
  int D.23973;
  int iftmp.601;
  int D.23972;
  const char[10] * D.38885;
  unsigned char D.38886;
  int D.38887;
  unsigned char D.38888;
  int D.38889;
  const unsigned char * D.38894;
  unsigned char D.38895;
  int D.38896;
  const unsigned char * D.38897;
  unsigned char D.38898;
  int D.38899;
  const unsigned char * D.38904;
  unsigned char D.38905;
  int D.38906;
  const unsigned char * D.38907;
  unsigned char D.38908;
  int D.38909;
  const unsigned char * D.38914;
  unsigned char D.38915;
  int D.38916;
  const unsigned char * D.38917;
  unsigned char D.38918;
  int D.38919;
  struct MonoClassField * D.38924;
  long unsigned int D.38925;
  long unsigned int D.38926;
  struct MonoClassField * D.38927;
  struct MonoType * D.38928;
  struct MonoGenericContext * D.38929;
  struct MonoType * D.38930;
  struct MonoType * * D.38931;
  long unsigned int D.38932;
  struct MonoType * * D.38933;
  int D.38934;
  struct MonoObject * * D.38939;
  char * D.38940;
  void * D.38941;
  struct MonoObject * * D.38942;
  const char * D.38946;
  char * D.38947;
  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.38808 = gtype->type;
  D.38809 = D.38808 != 21;
  D.38810 = (long int) D.38809;
  D.38811 = __builtin_expect (D.38810, 0);
  if (D.38811 != 0) goto <D.38812>; else goto <D.38813>;
  <D.38812>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10682, "gtype->type == MONO_TYPE_GENERICINST");
  <D.38813>:
  gclass = gtype->data.generic_class;
  D.38814 = BIT_FIELD_REF <*gclass, 64, 192>;
  D.38815 = D.38814 & 1;
  if (D.38815 == 0) goto <D.38816>; else goto <D.38817>;
  <D.38816>:
  return;
  <D.38817>:
  dgclass = gclass;
  D.38818 = dgclass->initialized;
  if (D.38818 != 0) goto <D.38819>; else goto <D.38820>;
  <D.38819>:
  return;
  <D.38820>:
  gklass = gclass->container_class;
  mono_class_init (gklass);
  if (fields != 0B) goto <D.38822>; else goto <D.38823>;
  <D.38822>:
  D.38824 = mono_array_length (fields);
  iftmp.599 = (int) D.38824;
  goto <D.38825>;
  <D.38823>:
  iftmp.599 = 0;
  <D.38825>:
  dgclass->count_fields = iftmp.599;
  D.38826 = gclass->owner;
  D.38827 = dgclass->count_fields;
  D.38828 = (long unsigned int) D.38827;
  D.38829 = (unsigned int) D.38828;
  D.38830 = D.38829 * 32;
  D.38831 = mono_image_set_alloc0 (D.38826, D.38830);
  dgclass->fields = D.38831;
  D.38826 = gclass->owner;
  D.38827 = dgclass->count_fields;
  D.38828 = (long unsigned int) D.38827;
  D.38829 = (unsigned int) D.38828;
  D.38832 = D.38829 * 8;
  D.38833 = mono_image_set_alloc0 (D.38826, D.38832);
  dgclass->field_objects = D.38833;
  D.38826 = gclass->owner;
  D.38827 = dgclass->count_fields;
  D.38828 = (long unsigned int) D.38827;
  D.38829 = (unsigned int) D.38828;
  D.38832 = D.38829 * 8;
  D.38834 = mono_image_set_alloc0 (D.38826, D.38832);
  dgclass->field_generic_types = D.38834;
  i = 0;
  goto <D.23975>;
  <D.23974>:
  {
    struct MonoObject * obj;
    struct MonoClassField * field;
    struct MonoClassField * inflated_field;

    D.38835 = (long unsigned int) i;
    D.38836 = mono_array_addr_with_size (fields, 8, D.38835);
    obj = MEM[(void * *)D.38836];
    inflated_field = 0B;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.38840 = obj->vtable;
        D.38841 = D.38840->klass;
        __s2 = D.38841->name;
        D.38842 = "FieldBuilder";
        D.38843 = MEM[(const unsigned char *)D.38842];
        D.38844 = (int) D.38843;
        D.38845 = *__s2;
        D.38846 = (int) D.38845;
        __result = D.38844 - D.38846;
        {
          if (__s2_len != 0) goto <D.38847>; else goto <D.38848>;
          <D.38847>:
          if (__result == 0) goto <D.38849>; else goto <D.38850>;
          <D.38849>:
          D.38851 = &MEM[(void *)"FieldBuilder" + 1B];
          D.38852 = *D.38851;
          D.38853 = (int) D.38852;
          D.38854 = __s2 + 1;
          D.38855 = *D.38854;
          D.38856 = (int) D.38855;
          __result = D.38853 - D.38856;
          if (__s2_len > 1) goto <D.38857>; else goto <D.38858>;
          <D.38857>:
          if (__result == 0) goto <D.38859>; else goto <D.38860>;
          <D.38859>:
          D.38861 = &MEM[(void *)"FieldBuilder" + 2B];
          D.38862 = *D.38861;
          D.38863 = (int) D.38862;
          D.38864 = __s2 + 2;
          D.38865 = *D.38864;
          D.38866 = (int) D.38865;
          __result = D.38863 - D.38866;
          if (__s2_len > 2) goto <D.38867>; else goto <D.38868>;
          <D.38867>:
          if (__result == 0) goto <D.38869>; else goto <D.38870>;
          <D.38869>:
          D.38871 = &MEM[(void *)"FieldBuilder" + 3B];
          D.38872 = *D.38871;
          D.38873 = (int) D.38872;
          D.38874 = __s2 + 3;
          D.38875 = *D.38874;
          D.38876 = (int) D.38875;
          __result = D.38873 - D.38876;
          <D.38870>:
          <D.38868>:
          <D.38860>:
          <D.38858>:
          <D.38850>:
          <D.38848>:
        }
        D.23963 = __result;
      }
      iftmp.600 = -D.23963;
      goto <D.38877>;
      <D.38839>:
      D.38840 = obj->vtable;
      D.38841 = D.38840->klass;
      D.38878 = D.38841->name;
      iftmp.600 = __builtin_strcmp (D.38878, "FieldBuilder");
      <D.38877>:
      D.23964 = iftmp.600;
    }
    if (D.23964 == 0) goto <D.38879>; else goto <D.38880>;
    <D.38879>:
    field = fieldbuilder_to_mono_class_field (klass, obj);
    inflated_field = field;
    goto <D.38881>;
    <D.38880>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.38840 = obj->vtable;
        D.38841 = D.38840->klass;
        __s2 = D.38841->name;
        D.38885 = "MonoField";
        D.38886 = MEM[(const unsigned char *)D.38885];
        D.38887 = (int) D.38886;
        D.38888 = *__s2;
        D.38889 = (int) D.38888;
        __result = D.38887 - D.38889;
        {
          if (__s2_len != 0) goto <D.38890>; else goto <D.38891>;
          <D.38890>:
          if (__result == 0) goto <D.38892>; else goto <D.38893>;
          <D.38892>:
          D.38894 = &MEM[(void *)"MonoField" + 1B];
          D.38895 = *D.38894;
          D.38896 = (int) D.38895;
          D.38897 = __s2 + 1;
          D.38898 = *D.38897;
          D.38899 = (int) D.38898;
          __result = D.38896 - D.38899;
          if (__s2_len > 1) goto <D.38900>; else goto <D.38901>;
          <D.38900>:
          if (__result == 0) goto <D.38902>; else goto <D.38903>;
          <D.38902>:
          D.38904 = &MEM[(void *)"MonoField" + 2B];
          D.38905 = *D.38904;
          D.38906 = (int) D.38905;
          D.38907 = __s2 + 2;
          D.38908 = *D.38907;
          D.38909 = (int) D.38908;
          __result = D.38906 - D.38909;
          if (__s2_len > 2) goto <D.38910>; else goto <D.38911>;
          <D.38910>:
          if (__result == 0) goto <D.38912>; else goto <D.38913>;
          <D.38912>:
          D.38914 = &MEM[(void *)"MonoField" + 3B];
          D.38915 = *D.38914;
          D.38916 = (int) D.38915;
          D.38917 = __s2 + 3;
          D.38918 = *D.38917;
          D.38919 = (int) D.38918;
          __result = D.38916 - D.38919;
          <D.38913>:
          <D.38911>:
          <D.38903>:
          <D.38901>:
          <D.38893>:
          <D.38891>:
        }
        D.23972 = __result;
      }
      iftmp.601 = -D.23972;
      goto <D.38920>;
      <D.38884>:
      D.38840 = obj->vtable;
      D.38841 = D.38840->klass;
      D.38878 = D.38841->name;
      iftmp.601 = __builtin_strcmp (D.38878, "MonoField");
      <D.38920>:
      D.23973 = iftmp.601;
    }
    if (D.23973 == 0) goto <D.38921>; else goto <D.38922>;
    <D.38921>:
    field = MEM[(struct MonoReflectionField *)obj].field;
    goto <D.38923>;
    <D.38922>:
    field = 0B;
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 10712);
    <D.38923>:
    <D.38881>:
    D.38924 = dgclass->fields;
    D.38925 = (long unsigned int) i;
    D.38926 = D.38925 * 32;
    D.38927 = D.38924 + D.38926;
    *D.38927 = *field;
    D.38924 = dgclass->fields;
    D.38925 = (long unsigned int) i;
    D.38926 = D.38925 * 32;
    D.38927 = D.38924 + D.38926;
    D.38927->parent = klass;
    D.38924 = dgclass->fields;
    D.38925 = (long unsigned int) i;
    D.38926 = D.38925 * 32;
    D.38927 = D.38924 + D.38926;
    D.38928 = field->type;
    D.38929 = mono_generic_class_get_context (dgclass);
    D.38930 = mono_class_inflate_generic_type (D.38928, D.38929);
    D.38927->type = D.38930;
    D.38931 = dgclass->field_generic_types;
    D.38925 = (long unsigned int) i;
    D.38932 = D.38925 * 8;
    D.38933 = D.38931 + D.38932;
    D.38928 = field->type;
    *D.38933 = D.38928;
    D.38934 = mono_gc_is_moving ();
    if (D.38934 != 0) goto <D.38935>; else goto <D.38936>;
    <D.38935>:
    if (0 != 0) goto <D.38937>; else goto <D.38938>;
    <D.38937>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10720, "sizeof (dgclass->field_objects [i]) == sizeof (MonoObject*)");
    <D.38938>:
    D.38939 = dgclass->field_objects;
    D.38925 = (long unsigned int) i;
    D.38932 = D.38925 * 8;
    D.38940 = D.38939 + D.38932;
    D.38941 = mono_gc_make_root_descr_all_refs (1);
    mono_gc_register_root (D.38940, 8, D.38941);
    <D.38936>:
    D.38939 = dgclass->field_objects;
    D.38925 = (long unsigned int) i;
    D.38932 = D.38925 * 8;
    D.38942 = D.38939 + D.38932;
    *D.38942 = obj;
    if (inflated_field != 0B) goto <D.38943>; else goto <D.38944>;
    <D.38943>:
    monoeg_g_free (inflated_field);
    goto <D.38945>;
    <D.38944>:
    D.38924 = dgclass->fields;
    D.38925 = (long unsigned int) i;
    D.38926 = D.38925 * 32;
    D.38927 = D.38924 + D.38926;
    D.38826 = gclass->owner;
    D.38924 = dgclass->fields;
    D.38925 = (long unsigned int) i;
    D.38926 = D.38925 * 32;
    D.38927 = D.38924 + D.38926;
    D.38946 = D.38927->name;
    D.38947 = mono_image_set_strdup (D.38826, D.38946);
    D.38927->name = D.38947;
    <D.38945>:
  }
  i = i + 1;
  <D.23975>:
  D.38827 = dgclass->count_fields;
  if (D.38827 > i) goto <D.23974>; else goto <D.23976>;
  <D.23976>:
  dgclass->initialized = 1;
}


fieldbuilder_to_mono_class_field (struct MonoClass * klass, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoImage * D.38949;
  struct MonoString * D.38950;
  char * D.38951;
  int D.38952;
  _Bool D.38953;
  long int D.38954;
  long int D.38955;
  unsigned int D.38961;
  struct MonoArray * D.38963;
  struct MonoArray * D.38965;
  struct MonoObject * D.38966;
  struct MonoType * D.38967;
  struct MonoType * D.38968;
  struct MonoType * D.38969;
  short unsigned int D.38970;
  long unsigned int D.38971;
  long unsigned int D.38972;
  _Bool D.38973;
  long int D.38974;
  long int D.38975;
  struct MonoType * D.38978;
  struct MonoType * D.38979;
  int D.38980;
  struct MonoArray * D.38983;
  struct MonoClassField * D.38984;
  struct MonoClassField * field;
  struct MonoType * custom;
  struct MonoError error;

  try
    {
      field = monoeg_malloc0 (32);
      D.38949 = klass->image;
      D.38950 = fb->name;
      D.38951 = mono_string_to_utf8_image (D.38949, D.38950, &error);
      field->name = D.38951;
      D.38952 = mono_error_ok (&error);
      D.38953 = D.38952 == 0;
      D.38954 = (long int) D.38953;
      D.38955 = __builtin_expect (D.38954, 0);
      if (D.38955 != 0) goto <D.38956>; else goto <D.38957>;
      <D.38956>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10427, "mono_error_ok (&error)");
      <D.38957>:
      D.38961 = fb->attrs;
      if (D.38961 != 0) goto <D.38958>; else goto <D.38962>;
      <D.38962>:
      D.38963 = fb->modreq;
      if (D.38963 != 0B) goto <D.38958>; else goto <D.38964>;
      <D.38964>:
      D.38965 = fb->modopt;
      if (D.38965 != 0B) goto <D.38958>; else goto <D.38959>;
      <D.38958>:
      D.38966 = fb->type;
      D.38967 = mono_reflection_type_get_handle (D.38966);
      D.38968 = mono_metadata_type_dup (0B, D.38967);
      field->type = D.38968;
      D.38969 = field->type;
      D.38961 = fb->attrs;
      D.38970 = (short unsigned int) D.38961;
      D.38969->attrs = D.38970;
      D.38949 = klass->image;
      D.38971 = BIT_FIELD_REF <*D.38949, 64, 192>;
      D.38972 = D.38971 & 34359738368;
      D.38973 = D.38972 == 0;
      D.38974 = (long int) D.38973;
      D.38975 = __builtin_expect (D.38974, 0);
      if (D.38975 != 0) goto <D.38976>; else goto <D.38977>;
      <D.38976>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10432, "klass->image->dynamic");
      <D.38977>:
      D.38949 = klass->image;
      D.38969 = field->type;
      D.38963 = fb->modreq;
      D.38965 = fb->modopt;
      custom = add_custom_modifiers (D.38949, D.38969, D.38963, D.38965);
      D.38969 = field->type;
      monoeg_g_free (D.38969);
      D.38949 = klass->image;
      D.38978 = mono_metadata_type_dup (D.38949, custom);
      field->type = D.38978;
      monoeg_g_free (custom);
      goto <D.38960>;
      <D.38959>:
      D.38966 = fb->type;
      D.38979 = mono_reflection_type_get_handle (D.38966);
      field->type = D.38979;
      <D.38960>:
      D.38980 = fb->offset;
      if (D.38980 != -1) goto <D.38981>; else goto <D.38982>;
      <D.38981>:
      D.38980 = fb->offset;
      field->offset = D.38980;
      <D.38982>:
      field->parent = klass;
      D.38949 = klass->image;
      D.38983 = fb->cattrs;
      mono_save_custom_attrs (D.38949, field, D.38983);
      D.38984 = field;
      return D.38984;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_free_dynamic_generic_class (struct MonoGenericClass * gclass)
{
  long unsigned int D.38987;
  long unsigned int D.38988;
  _Bool D.38989;
  long int D.38990;
  long int D.38991;
  struct MonoClassField * D.38994;
  long unsigned int D.38995;
  long unsigned int D.38996;
  struct MonoType * D.38997;
  int D.38998;
  struct MonoObject * * D.39001;
  long unsigned int D.39002;
  char * D.39003;
  int D.39004;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.38987 = BIT_FIELD_REF <*gclass, 64, 192>;
  D.38988 = D.38987 & 1;
  D.38989 = D.38988 == 0;
  D.38990 = (long int) D.38989;
  D.38991 = __builtin_expect (D.38990, 0);
  if (D.38991 != 0) goto <D.38992>; else goto <D.38993>;
  <D.38992>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10739, "gclass->is_dynamic");
  <D.38993>:
  dgclass = gclass;
  i = 0;
  goto <D.23984>;
  <D.23983>:
  {
    struct MonoClassField * field;

    D.38994 = dgclass->fields;
    D.38995 = (long unsigned int) i;
    D.38996 = D.38995 * 32;
    field = D.38994 + D.38996;
    D.38997 = field->type;
    mono_metadata_free_type (D.38997);
    D.38998 = mono_gc_is_moving ();
    if (D.38998 != 0) goto <D.38999>; else goto <D.39000>;
    <D.38999>:
    D.39001 = dgclass->field_objects;
    D.38995 = (long unsigned int) i;
    D.39002 = D.38995 * 8;
    D.39003 = D.39001 + D.39002;
    mono_gc_deregister_root (D.39003);
    <D.39000>:
  }
  i = i + 1;
  <D.23984>:
  D.39004 = dgclass->count_fields;
  if (D.39004 > i) goto <D.23983>; else goto <D.23985>;
  <D.23985>:
}


mono_reflection_get_dynamic_overrides (struct MonoClass * klass, struct MonoMethod * * * overrides, int * num_overrides)
{
  struct MonoImage * D.39005;
  long unsigned int D.39006;
  long unsigned int D.39007;
  _Bool D.39008;
  long int D.39009;
  long int D.39010;
  void * D.39013;
  int D.24062;
  int iftmp.602;
  int D.24061;
  void * D.39019;
  struct MonoVTable * D.39020;
  struct MonoClass * D.39021;
  const char[12] * D.39022;
  unsigned char D.39023;
  int D.39024;
  unsigned char D.39025;
  int D.39026;
  const unsigned char * D.39031;
  unsigned char D.39032;
  int D.39033;
  const unsigned char * D.39034;
  unsigned char D.39035;
  int D.39036;
  const unsigned char * D.39041;
  unsigned char D.39042;
  int D.39043;
  const unsigned char * D.39044;
  unsigned char D.39045;
  int D.39046;
  const unsigned char * D.39051;
  unsigned char D.39052;
  int D.39053;
  const unsigned char * D.39054;
  unsigned char D.39055;
  int D.39056;
  void * D.39058;
  struct MonoVTable * D.39059;
  struct MonoClass * D.39060;
  const char * D.39061;
  _Bool D.39062;
  long int D.39063;
  long int D.39064;
  struct MonoArray * D.39067;
  long unsigned int D.39070;
  char * D.39071;
  struct MonoArray * D.39072;
  long unsigned int D.39075;
  unsigned int D.39076;
  unsigned int onum.603;
  unsigned int D.39078;
  int D.39079;
  int D.39082;
  long unsigned int D.39083;
  long unsigned int D.39084;
  void * D.39085;
  char * D.39086;
  struct MonoArray * D.39087;
  long unsigned int D.39090;
  char * D.39091;
  struct MonoMethod * * D.39092;
  struct MonoMethod * * D.39093;
  struct MonoMethod * D.39094;
  sizetype D.39095;
  sizetype D.39096;
  sizetype D.39097;
  struct MonoMethod * * D.39098;
  struct MonoMethod * D.39099;
  _Bool D.39100;
  long int D.39101;
  long int D.39102;
  long unsigned int D.39105;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int j;
  int onum;
  struct MonoReflectionMethod * m;

  *overrides = 0B;
  *num_overrides = 0;
  D.39005 = klass->image;
  D.39006 = BIT_FIELD_REF <*D.39005, 64, 192>;
  D.39007 = D.39006 & 34359738368;
  D.39008 = D.39007 == 0;
  D.39009 = (long int) D.39008;
  D.39010 = __builtin_expect (D.39009, 0);
  if (D.39010 != 0) goto <D.39011>; else goto <D.39012>;
  <D.39011>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10948, "klass->image->dynamic");
  <D.39012>:
  D.39013 = mono_class_get_ref_info (klass);
  if (D.39013 == 0B) goto <D.39014>; else goto <D.39015>;
  <D.39014>:
  return;
  <D.39015>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39019 = mono_class_get_ref_info (klass);
      D.39020 = MEM[(struct MonoObject *)D.39019].vtable;
      D.39021 = D.39020->klass;
      __s2 = D.39021->name;
      D.39022 = "TypeBuilder";
      D.39023 = MEM[(const unsigned char *)D.39022];
      D.39024 = (int) D.39023;
      D.39025 = *__s2;
      D.39026 = (int) D.39025;
      __result = D.39024 - D.39026;
      {
        if (__s2_len != 0) goto <D.39027>; else goto <D.39028>;
        <D.39027>:
        if (__result == 0) goto <D.39029>; else goto <D.39030>;
        <D.39029>:
        D.39031 = &MEM[(void *)"TypeBuilder" + 1B];
        D.39032 = *D.39031;
        D.39033 = (int) D.39032;
        D.39034 = __s2 + 1;
        D.39035 = *D.39034;
        D.39036 = (int) D.39035;
        __result = D.39033 - D.39036;
        if (__s2_len > 1) goto <D.39037>; else goto <D.39038>;
        <D.39037>:
        if (__result == 0) goto <D.39039>; else goto <D.39040>;
        <D.39039>:
        D.39041 = &MEM[(void *)"TypeBuilder" + 2B];
        D.39042 = *D.39041;
        D.39043 = (int) D.39042;
        D.39044 = __s2 + 2;
        D.39045 = *D.39044;
        D.39046 = (int) D.39045;
        __result = D.39043 - D.39046;
        if (__s2_len > 2) goto <D.39047>; else goto <D.39048>;
        <D.39047>:
        if (__result == 0) goto <D.39049>; else goto <D.39050>;
        <D.39049>:
        D.39051 = &MEM[(void *)"TypeBuilder" + 3B];
        D.39052 = *D.39051;
        D.39053 = (int) D.39052;
        D.39054 = __s2 + 3;
        D.39055 = *D.39054;
        D.39056 = (int) D.39055;
        __result = D.39053 - D.39056;
        <D.39050>:
        <D.39048>:
        <D.39040>:
        <D.39038>:
        <D.39030>:
        <D.39028>:
      }
      D.24061 = __result;
    }
    iftmp.602 = -D.24061;
    goto <D.39057>;
    <D.39018>:
    D.39058 = mono_class_get_ref_info (klass);
    D.39059 = MEM[(struct MonoObject *)D.39058].vtable;
    D.39060 = D.39059->klass;
    D.39061 = D.39060->name;
    iftmp.602 = __builtin_strcmp (D.39061, "TypeBuilder");
    <D.39057>:
    D.24062 = iftmp.602;
  }
  D.39062 = D.24062 != 0;
  D.39063 = (long int) D.39062;
  D.39064 = __builtin_expect (D.39063, 0);
  if (D.39064 != 0) goto <D.39065>; else goto <D.39066>;
  <D.39065>:
  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.39066>:
  tb = mono_class_get_ref_info (klass);
  onum = 0;
  D.39067 = tb->methods;
  if (D.39067 != 0B) goto <D.39068>; else goto <D.39069>;
  <D.39068>:
  i = 0;
  goto <D.24065>;
  <D.24064>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.39067 = tb->methods;
    D.39070 = (long unsigned int) i;
    D.39071 = mono_array_addr_with_size (D.39067, 8, D.39070);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.39071];
    D.39072 = mb->override_methods;
    if (D.39072 != 0B) goto <D.39073>; else goto <D.39074>;
    <D.39073>:
    D.39072 = mb->override_methods;
    D.39075 = mono_array_length (D.39072);
    D.39076 = (unsigned int) D.39075;
    onum.603 = (unsigned int) onum;
    D.39078 = D.39076 + onum.603;
    onum = (int) D.39078;
    <D.39074>:
  }
  i = i + 1;
  <D.24065>:
  D.39079 = tb->num_methods;
  if (D.39079 > i) goto <D.24064>; else goto <D.24066>;
  <D.24066>:
  <D.39069>:
  if (onum != 0) goto <D.39080>; else goto <D.39081>;
  <D.39080>:
  D.39082 = onum * 2;
  D.39083 = (long unsigned int) D.39082;
  D.39084 = D.39083 * 8;
  D.39085 = monoeg_malloc0 (D.39084);
  *overrides = D.39085;
  onum = 0;
  i = 0;
  goto <D.24072>;
  <D.24071>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.39067 = tb->methods;
    D.39070 = (long unsigned int) i;
    D.39086 = mono_array_addr_with_size (D.39067, 8, D.39070);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.39086];
    D.39087 = mb->override_methods;
    if (D.39087 != 0B) goto <D.39088>; else goto <D.39089>;
    <D.39088>:
    j = 0;
    goto <D.24069>;
    <D.24068>:
    D.39087 = mb->override_methods;
    D.39090 = (long unsigned int) j;
    D.39091 = mono_array_addr_with_size (D.39087, 8, D.39090);
    m = MEM[(struct MonoReflectionMethod * *)D.39091];
    D.39092 = *overrides;
    D.39082 = onum * 2;
    D.39083 = (long unsigned int) D.39082;
    D.39084 = D.39083 * 8;
    D.39093 = D.39092 + D.39084;
    D.39094 = mono_reflection_method_get_handle (m);
    *D.39093 = D.39094;
    D.39092 = *overrides;
    D.39082 = onum * 2;
    D.39095 = (sizetype) D.39082;
    D.39096 = D.39095 + 1;
    D.39097 = D.39096 * 8;
    D.39098 = D.39092 + D.39097;
    D.39099 = mb->mhandle;
    *D.39098 = D.39099;
    D.39099 = mb->mhandle;
    D.39100 = D.39099 == 0B;
    D.39101 = (long int) D.39100;
    D.39102 = __builtin_expect (D.39101, 0);
    if (D.39102 != 0) goto <D.39103>; else goto <D.39104>;
    <D.39103>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10981, "mb->mhandle");
    <D.39104>:
    onum = onum + 1;
    j = j + 1;
    <D.24069>:
    D.39090 = (long unsigned int) j;
    D.39087 = mb->override_methods;
    D.39105 = mono_array_length (D.39087);
    if (D.39090 < D.39105) goto <D.24068>; else goto <D.24070>;
    <D.24070>:
    <D.39089>:
  }
  i = i + 1;
  <D.24072>:
  D.39079 = tb->num_methods;
  if (D.39079 > i) goto <D.24071>; else goto <D.24073>;
  <D.24073>:
  <D.39081>:
  *num_overrides = onum;
}


mono_reflection_method_get_handle (struct MonoObject * method)
{
  struct MonoVTable * D.39107;
  int D.39110;
  int D.39112;
  struct MonoMethod * D.39113;
  int D.39114;
  int D.39117;
  struct MonoArray * D.39120;
  struct MonoReflectionType * D.39124;
  struct MonoObject * D.39125;
  struct MonoVTable * D.39126;
  struct MonoClass * D.39127;
  int D.39128;
  int D.39132;
  char * D.39136;
  const char * D.39137;
  const char * D.39138;
  struct MonoClass * class;

  D.39107 = method->vtable;
  class = D.39107->klass;
  D.39110 = is_sr_mono_method (class);
  if (D.39110 != 0) goto <D.39108>; else goto <D.39111>;
  <D.39111>:
  D.39112 = is_sr_mono_generic_method (class);
  if (D.39112 != 0) goto <D.39108>; else goto <D.39109>;
  <D.39108>:
  {
    struct MonoReflectionMethod * sr_method;

    sr_method = method;
    D.39113 = sr_method->method;
    return D.39113;
  }
  <D.39109>:
  D.39114 = is_sre_method_builder (class);
  if (D.39114 != 0) goto <D.39115>; else goto <D.39116>;
  <D.39115>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = method;
    D.39113 = mb->mhandle;
    return D.39113;
  }
  <D.39116>:
  D.39117 = is_sre_method_on_tb_inst (class);
  if (D.39117 != 0) goto <D.39118>; else goto <D.39119>;
  <D.39118>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;
    struct MonoMethod * result;

    m = method;
    D.39120 = m->method_args;
    if (D.39120 != 0B) goto <D.39121>; else goto <D.39122>;
    <D.39121>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    goto <D.39123>;
    <D.39122>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * mono_method;

      D.39124 = m->inst;
      type = mono_reflection_type_get_handle (D.39124);
      inflated_klass = mono_class_from_mono_type (type);
      D.39125 = m->mb;
      D.39126 = D.39125->vtable;
      D.39127 = D.39126->klass;
      D.39128 = is_sre_method_builder (D.39127);
      if (D.39128 != 0) goto <D.39129>; else goto <D.39130>;
      <D.39129>:
      D.39125 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethodBuilder *)D.39125].mhandle;
      goto <D.39131>;
      <D.39130>:
      D.39125 = m->mb;
      D.39126 = D.39125->vtable;
      D.39127 = D.39126->klass;
      D.39132 = is_sr_mono_method (D.39127);
      if (D.39132 != 0) goto <D.39133>; else goto <D.39134>;
      <D.39133>:
      D.39125 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethod *)D.39125].method;
      goto <D.39135>;
      <D.39134>:
      D.39125 = m->mb;
      D.39126 = D.39125->vtable;
      D.39127 = D.39126->klass;
      D.39136 = mono_type_get_full_name (D.39127);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.39136);
      <D.24042>:
      goto <D.24042>;
      <D.39135>:
      <D.39131>:
      D.39125 = m->mb;
      result = inflate_mono_method (inflated_klass, mono_method, D.39125);
    }
    <D.39123>:
    D.39113 = result;
    return D.39113;
  }
  <D.39119>:
  D.39137 = class->name_space;
  D.39138 = class->name;
  monoeg_g_log (0B, 4, "Can\'t handle methods of type %s:%s", D.39137, D.39138);
  <D.24043>:
  goto <D.24043>;
  D.39113 = 0B;
  return D.39113;
}


mono_reflection_event_builder_get_event_info (struct MonoReflectionTypeBuilder * tb, struct MonoReflectionEventBuilder * eb)
{
  struct MonoType * D.39140;
  unsigned int D.39141;
  struct MonoString * D.39142;
  char * D.39143;
  struct MonoReflectionMethodBuilder * D.39144;
  struct MonoMethod * D.39147;
  struct MonoReflectionMethodBuilder * D.39148;
  struct MonoMethod * D.39151;
  struct MonoReflectionMethodBuilder * D.39152;
  struct MonoMethod * D.39155;
  struct MonoArray * D.39156;
  long unsigned int D.39159;
  long unsigned int D.39160;
  long unsigned int D.39161;
  void * D.39162;
  long unsigned int D.39163;
  char * D.39164;
  struct MonoMethod * * D.39165;
  long unsigned int D.39166;
  long unsigned int D.39167;
  struct MonoMethod * * D.39168;
  struct MonoMethod * D.39169;
  long unsigned int D.39170;
  struct MonoReflectionEvent * D.39171;
  struct MonoVTable * D.39172;
  struct MonoDomain * D.39173;
  struct MonoEvent * event;
  struct MonoClass * klass;

  event = monoeg_malloc0 (56);
  D.39140 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.39140);
  event->parent = klass;
  D.39141 = eb->attrs;
  event->attrs = D.39141;
  D.39142 = eb->name;
  D.39143 = mono_string_to_utf8 (D.39142);
  event->name = D.39143;
  D.39144 = eb->add_method;
  if (D.39144 != 0B) goto <D.39145>; else goto <D.39146>;
  <D.39145>:
  D.39144 = eb->add_method;
  D.39147 = D.39144->mhandle;
  event->add = D.39147;
  <D.39146>:
  D.39148 = eb->remove_method;
  if (D.39148 != 0B) goto <D.39149>; else goto <D.39150>;
  <D.39149>:
  D.39148 = eb->remove_method;
  D.39151 = D.39148->mhandle;
  event->remove = D.39151;
  <D.39150>:
  D.39152 = eb->raise_method;
  if (D.39152 != 0B) goto <D.39153>; else goto <D.39154>;
  <D.39153>:
  D.39152 = eb->raise_method;
  D.39155 = D.39152->mhandle;
  event->raise = D.39155;
  <D.39154>:
  D.39156 = eb->other_methods;
  if (D.39156 != 0B) goto <D.39157>; else goto <D.39158>;
  <D.39157>:
  {
    int j;

    D.39156 = eb->other_methods;
    D.39159 = mono_array_length (D.39156);
    D.39160 = D.39159 + 1;
    D.39161 = D.39160 * 8;
    D.39162 = monoeg_malloc0 (D.39161);
    event->other = D.39162;
    j = 0;
    goto <D.24123>;
    <D.24122>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.39156 = eb->other_methods;
      D.39163 = (long unsigned int) j;
      D.39164 = mono_array_addr_with_size (D.39156, 8, D.39163);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.39164];
      D.39165 = event->other;
      D.39166 = (long unsigned int) j;
      D.39167 = D.39166 * 8;
      D.39168 = D.39165 + D.39167;
      D.39169 = mb->mhandle;
      *D.39168 = D.39169;
    }
    j = j + 1;
    <D.24123>:
    D.39163 = (long unsigned int) j;
    D.39156 = eb->other_methods;
    D.39170 = mono_array_length (D.39156);
    if (D.39163 < D.39170) goto <D.24122>; else goto <D.24124>;
    <D.24124>:
  }
  <D.39158>:
  D.39172 = MEM[(struct MonoObject *)tb].vtable;
  D.39173 = D.39172->domain;
  D.39171 = mono_event_get_object (D.39173, klass, event);
  return D.39171;
}


mono_reflection_create_runtime_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoVTable * D.39175;
  struct MonoType * D.39176;
  struct MonoObject * D.39177;
  struct MonoReflectionType * D.39178;
  struct MonoArray * D.39179;
  struct MonoArray * D.39180;
  long unsigned int D.39183;
  char * D.39184;
  struct MonoObject * D.39187;
  struct MonoReflectionType * D.39188;
  struct MonoArray * D.39189;
  struct MonoArray * D.39190;
  struct MonoReflectionMarshal * D.39191;
  struct MonoObject * D.39194;
  struct MonoReflectionType * D.39197;
  long unsigned int D.39198;
  struct MonoArray * D.39199;
  char * D.39202;
  struct MonoObject * D.39205;
  struct MonoReflectionType * D.39206;
  struct MonoArray * D.39207;
  struct MonoArray * D.39208;
  struct MonoArray * D.39209;
  struct MonoArray * D.39210;
  long unsigned int D.39213;
  char * D.39214;
  struct MonoArray * D.39215;
  long unsigned int D.39216;
  struct MonoArray * D.39217;
  char * D.39220;
  struct MonoArray * D.39221;
  long unsigned int D.39222;
  long unsigned int D.39223;
  struct MonoArray * D.39224;
  char * D.39227;
  struct MonoArray * D.39230;
  struct MonoArray * D.39231;
  char * D.39234;
  struct MonoArray * D.39235;
  long unsigned int D.39236;
  struct MonoArray * D.39237;
  char * D.39240;
  struct MonoArray * D.39241;
  long unsigned int D.39242;
  long unsigned int D.39243;
  struct MonoImage * D.39244;
  struct MonoArray * D.39245;
  union mono_mutex_t * D.39246;
  _Bool D.39249;
  long int D.39250;
  long int D.39251;
  long unsigned int D.39254;
  long unsigned int D.39255;
  _Bool D.39260;
  long int D.39261;
  long int D.39262;
  struct MonoReflectionType * D.39265;
  struct MonoDomain * D.39266;
  struct MonoType * D.39267;
  unsigned int D.39268;
  struct MonoClass * D.39269;
  long unsigned int D.39270;
  struct MonoArray * D.39273;
  char * D.39276;
  struct MonoClassExt * D.39277;
  struct GList * D.39278;
  struct MonoType * D.39279;
  struct MonoClass * D.39280;
  struct GList * D.39281;
  long unsigned int D.39282;
  long unsigned int D.39285;
  long unsigned int D.39286;
  int D.39289;
  unsigned char D.39290;
  <unnamed-unsigned:1> D.39291;
  unsigned char D.39292;
  <unnamed-unsigned:1> D.39293;
  unsigned char D.39294;
  unsigned char D.39295;
  <unnamed-unsigned:1> D.39296;
  int D.39298;
  int D.39300;
  int D.39302;
  struct MonoGHashTable * D.39304;
  struct MonoGenericContainer * D.39307;
  _Bool D.39312;
  long int D.39313;
  long int D.39314;
  int D.39319;
  struct MonoString * D.39322;
  struct MonoException * D.39323;
  _Bool D.39324;
  long int D.39325;
  long int D.39326;
  _Bool D.39331;
  long int D.39332;
  long int D.39333;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoReflectionType * res;
  int i;
  int j;
  void failure = <<< error >>>;

  try
    {
      D.39175 = MEM[(struct MonoObject *)tb].vtable;
      domain = D.39175->domain;
      D.39176 = tb->type.type;
      klass = mono_class_from_mono_type (D.39176);
      D.39177 = tb->parent;
      D.39178 = mono_reflection_type_resolve_user_types (D.39177);
      tb->parent = D.39178;
      D.39179 = tb->interfaces;
      check_array_for_usertypes (D.39179);
      D.39180 = tb->fields;
      if (D.39180 != 0B) goto <D.39181>; else goto <D.39182>;
      <D.39181>:
      i = 0;
      goto <D.24169>;
      <D.24168>:
      {
        struct MonoReflectionFieldBuilder * fb;

        D.39180 = tb->fields;
        D.39183 = (long unsigned int) i;
        D.39184 = mono_array_addr_with_size (D.39180, 8, D.39183);
        fb = MEM[(void * *)D.39184];
        if (fb != 0B) goto <D.39185>; else goto <D.39186>;
        <D.39185>:
        D.39187 = fb->type;
        D.39188 = mono_reflection_type_resolve_user_types (D.39187);
        fb->type = D.39188;
        D.39189 = fb->modreq;
        check_array_for_usertypes (D.39189);
        D.39190 = fb->modopt;
        check_array_for_usertypes (D.39190);
        D.39191 = fb->marshal_info;
        if (D.39191 != 0B) goto <D.39192>; else goto <D.39193>;
        <D.39192>:
        D.39191 = fb->marshal_info;
        D.39194 = D.39191->marshaltyperef;
        if (D.39194 != 0B) goto <D.39195>; else goto <D.39196>;
        <D.39195>:
        D.39191 = fb->marshal_info;
        D.39191 = fb->marshal_info;
        D.39194 = D.39191->marshaltyperef;
        D.39197 = mono_reflection_type_resolve_user_types (D.39194);
        D.39191->marshaltyperef = D.39197;
        <D.39196>:
        <D.39193>:
        <D.39186>:
      }
      i = i + 1;
      <D.24169>:
      D.39183 = (long unsigned int) i;
      D.39180 = tb->fields;
      D.39198 = mono_array_length (D.39180);
      if (D.39183 < D.39198) goto <D.24168>; else goto <D.24170>;
      <D.24170>:
      <D.39182>:
      D.39199 = tb->methods;
      if (D.39199 != 0B) goto <D.39200>; else goto <D.39201>;
      <D.39200>:
      i = 0;
      goto <D.24179>;
      <D.24178>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.39199 = tb->methods;
        D.39183 = (long unsigned int) i;
        D.39202 = mono_array_addr_with_size (D.39199, 8, D.39183);
        mb = MEM[(void * *)D.39202];
        if (mb != 0B) goto <D.39203>; else goto <D.39204>;
        <D.39203>:
        D.39205 = mb->rtype;
        D.39206 = mono_reflection_type_resolve_user_types (D.39205);
        mb->rtype = D.39206;
        D.39207 = mb->return_modreq;
        check_array_for_usertypes (D.39207);
        D.39208 = mb->return_modopt;
        check_array_for_usertypes (D.39208);
        D.39209 = mb->parameters;
        check_array_for_usertypes (D.39209);
        D.39210 = mb->param_modreq;
        if (D.39210 != 0B) goto <D.39211>; else goto <D.39212>;
        <D.39211>:
        j = 0;
        goto <D.24173>;
        <D.24172>:
        D.39210 = mb->param_modreq;
        D.39213 = (long unsigned int) j;
        D.39214 = mono_array_addr_with_size (D.39210, 8, D.39213);
        D.39215 = MEM[(struct MonoArray * *)D.39214];
        check_array_for_usertypes (D.39215);
        j = j + 1;
        <D.24173>:
        D.39213 = (long unsigned int) j;
        D.39210 = mb->param_modreq;
        D.39216 = mono_array_length (D.39210);
        if (D.39213 < D.39216) goto <D.24172>; else goto <D.24174>;
        <D.24174>:
        <D.39212>:
        D.39217 = mb->param_modopt;
        if (D.39217 != 0B) goto <D.39218>; else goto <D.39219>;
        <D.39218>:
        j = 0;
        goto <D.24176>;
        <D.24175>:
        D.39217 = mb->param_modopt;
        D.39213 = (long unsigned int) j;
        D.39220 = mono_array_addr_with_size (D.39217, 8, D.39213);
        D.39221 = MEM[(struct MonoArray * *)D.39220];
        check_array_for_usertypes (D.39221);
        j = j + 1;
        <D.24176>:
        D.39213 = (long unsigned int) j;
        D.39217 = mb->param_modopt;
        D.39222 = mono_array_length (D.39217);
        if (D.39213 < D.39222) goto <D.24175>; else goto <D.24177>;
        <D.24177>:
        <D.39219>:
        <D.39204>:
      }
      i = i + 1;
      <D.24179>:
      D.39183 = (long unsigned int) i;
      D.39199 = tb->methods;
      D.39223 = mono_array_length (D.39199);
      if (D.39183 < D.39223) goto <D.24178>; else goto <D.24180>;
      <D.24180>:
      <D.39201>:
      D.39224 = tb->ctors;
      if (D.39224 != 0B) goto <D.39225>; else goto <D.39226>;
      <D.39225>:
      i = 0;
      goto <D.24189>;
      <D.24188>:
      {
        struct MonoReflectionCtorBuilder * mb;

        D.39224 = tb->ctors;
        D.39183 = (long unsigned int) i;
        D.39227 = mono_array_addr_with_size (D.39224, 8, D.39183);
        mb = MEM[(void * *)D.39227];
        if (mb != 0B) goto <D.39228>; else goto <D.39229>;
        <D.39228>:
        D.39230 = mb->parameters;
        check_array_for_usertypes (D.39230);
        D.39231 = mb->param_modreq;
        if (D.39231 != 0B) goto <D.39232>; else goto <D.39233>;
        <D.39232>:
        j = 0;
        goto <D.24183>;
        <D.24182>:
        D.39231 = mb->param_modreq;
        D.39213 = (long unsigned int) j;
        D.39234 = mono_array_addr_with_size (D.39231, 8, D.39213);
        D.39235 = MEM[(struct MonoArray * *)D.39234];
        check_array_for_usertypes (D.39235);
        j = j + 1;
        <D.24183>:
        D.39213 = (long unsigned int) j;
        D.39231 = mb->param_modreq;
        D.39236 = mono_array_length (D.39231);
        if (D.39213 < D.39236) goto <D.24182>; else goto <D.24184>;
        <D.24184>:
        <D.39233>:
        D.39237 = mb->param_modopt;
        if (D.39237 != 0B) goto <D.39238>; else goto <D.39239>;
        <D.39238>:
        j = 0;
        goto <D.24186>;
        <D.24185>:
        D.39237 = mb->param_modopt;
        D.39213 = (long unsigned int) j;
        D.39240 = mono_array_addr_with_size (D.39237, 8, D.39213);
        D.39241 = MEM[(struct MonoArray * *)D.39240];
        check_array_for_usertypes (D.39241);
        j = j + 1;
        <D.24186>:
        D.39213 = (long unsigned int) j;
        D.39237 = mb->param_modopt;
        D.39242 = mono_array_length (D.39237);
        if (D.39213 < D.39242) goto <D.24185>; else goto <D.24187>;
        <D.24187>:
        <D.39239>:
        <D.39229>:
      }
      i = i + 1;
      <D.24189>:
      D.39183 = (long unsigned int) i;
      D.39224 = tb->ctors;
      D.39243 = mono_array_length (D.39224);
      if (D.39183 < D.39243) goto <D.24188>; else goto <D.24190>;
      <D.24190>:
      <D.39226>:
      D.39244 = klass->image;
      D.39245 = tb->cattrs;
      mono_save_custom_attrs (D.39244, klass, D.39245);
      mono_loader_lock ();
      {
        int ret;

        D.39246 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.39246);
        if (ret != 0) goto <D.39247>; else goto <D.39248>;
        <D.39247>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.39248>:
        D.39249 = ret != 0;
        D.39250 = (long int) D.39249;
        D.39251 = __builtin_expect (D.39250, 0);
        if (D.39251 != 0) goto <D.39252>; else goto <D.39253>;
        <D.39252>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11312, "ret == 0");
        <D.39253>:
      }
      D.39254 = BIT_FIELD_REF <*klass, 64, 256>;
      D.39255 = D.39254 & 128;
      if (D.39255 != 0) goto <D.39256>; else goto <D.39257>;
      <D.39256>:
      {
        int ret;

        D.39246 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.39246);
        if (ret != 0) goto <D.39258>; else goto <D.39259>;
        <D.39258>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.39259>:
        D.39260 = ret != 0;
        D.39261 = (long int) D.39260;
        D.39262 = __builtin_expect (D.39261, 0);
        if (D.39262 != 0) goto <D.39263>; else goto <D.39264>;
        <D.39263>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11314, "ret == 0");
        <D.39264>:
      }
      mono_loader_unlock ();
      D.39175 = MEM[(struct MonoObject *)tb].vtable;
      D.39266 = D.39175->domain;
      D.39267 = &klass->byval_arg;
      D.39265 = mono_type_get_object (D.39266, D.39267);
      return D.39265;
      <D.39257>:
      D.39268 = tb->attrs;
      klass->flags = D.39268;
      klass->has_cctor = 1;
      klass->has_finalize = 1;
      klass->has_finalize_inited = 1;
      klass->supertypes = 0B;
      D.39269 = klass->parent;
      mono_class_setup_parent (klass, D.39269);
      mono_class_setup_mono_type (klass);
      D.39254 = BIT_FIELD_REF <*klass, 64, 256>;
      D.39270 = D.39254 & 16;
      if (D.39270 == 0) goto <D.39271>; else goto <D.39272>;
      <D.39271>:
      ensure_runtime_vtable (klass);
      <D.39272>:
      D.39273 = tb->subtypes;
      if (D.39273 != 0B) goto <D.39274>; else goto <D.39275>;
      <D.39274>:
      i = 0;
      goto <D.24195>;
      <D.24194>:
      {
        struct MonoReflectionTypeBuilder * subtb;

        D.39273 = tb->subtypes;
        D.39183 = (long unsigned int) i;
        D.39276 = mono_array_addr_with_size (D.39273, 8, D.39183);
        subtb = MEM[(struct MonoReflectionTypeBuilder * *)D.39276];
        mono_class_alloc_ext (klass);
        D.39277 = klass->ext;
        D.39244 = klass->image;
        D.39277 = klass->ext;
        D.39278 = D.39277->nested_classes;
        D.39279 = mono_reflection_type_get_handle (subtb);
        D.39280 = mono_class_from_mono_type (D.39279);
        D.39281 = g_list_prepend_image (D.39244, D.39278, D.39280);
        D.39277->nested_classes = D.39281;
      }
      i = i + 1;
      <D.24195>:
      D.39183 = (long unsigned int) i;
      D.39273 = tb->subtypes;
      D.39282 = mono_array_length (D.39273);
      if (D.39183 < D.39282) goto <D.24194>; else goto <D.24196>;
      <D.24196>:
      <D.39275>:
      klass->nested_classes_inited = 1;
      D.39269 = klass->parent;
      if (D.39269 != 0B) goto <D.39283>; else goto <D.39284>;
      <D.39283>:
      D.39269 = klass->parent;
      D.39285 = BIT_FIELD_REF <*D.39269, 64, 256>;
      D.39286 = D.39285 & 4;
      if (D.39286 == 0) goto <D.39287>; else goto <D.39288>;
      <D.39287>:
      D.39269 = klass->parent;
      mono_class_init (D.39269);
      <D.39288>:
      D.39269 = klass->parent;
      D.39289 = D.39269->instance_size;
      klass->instance_size = D.39289;
      klass->sizes.class_size = 0;
      D.39269 = klass->parent;
      D.39290 = D.39269->min_align;
      klass->min_align = D.39290;
      D.39291 = klass->has_references;
      D.39292 = (unsigned char) D.39291;
      D.39269 = klass->parent;
      D.39293 = D.39269->has_references;
      D.39294 = (unsigned char) D.39293;
      D.39295 = D.39292 | D.39294;
      D.39296 = (<unnamed-unsigned:1>) D.39295;
      klass->has_references = D.39296;
      goto <D.39297>;
      <D.39284>:
      klass->instance_size = 16;
      klass->min_align = 1;
      <D.39297>:
      typebuilder_setup_fields (klass, &error);
      D.39298 = mono_error_ok (&error);
      if (D.39298 == 0) goto failure; else goto <D.39299>;
      <D.39299>:
      typebuilder_setup_properties (klass, &error);
      D.39300 = mono_error_ok (&error);
      if (D.39300 == 0) goto failure; else goto <D.39301>;
      <D.39301>:
      typebuilder_setup_events (klass, &error);
      D.39302 = mono_error_ok (&error);
      if (D.39302 == 0) goto failure; else goto <D.39303>;
      <D.39303>:
      klass->wastypebuilder = 1;
      D.39304 = domain->type_hash;
      if (D.39304 != 0B) goto <D.39305>; else goto <D.39306>;
      <D.39305>:
      D.39307 = klass->generic_container;
      if (D.39307 != 0B) goto <D.39308>; else goto <D.39309>;
      <D.39308>:
      D.39304 = domain->type_hash;
      mono_g_hash_table_foreach_remove (D.39304, remove_instantiations_of_and_ensure_contents, klass);
      <D.39309>:
      <D.39306>:
      {
        int ret;

        D.39246 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.39246);
        if (ret != 0) goto <D.39310>; else goto <D.39311>;
        <D.39310>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.39311>:
        D.39312 = ret != 0;
        D.39313 = (long int) D.39312;
        D.39314 = __builtin_expect (D.39313, 0);
        if (D.39314 != 0) goto <D.39315>; else goto <D.39316>;
        <D.39315>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11398, "ret == 0");
        <D.39316>:
      }
      mono_loader_unlock ();
      D.39254 = BIT_FIELD_REF <*klass, 64, 256>;
      D.39270 = D.39254 & 16;
      if (D.39270 != 0) goto <D.39317>; else goto <D.39318>;
      <D.39317>:
      D.39319 = mono_class_is_valid_enum (klass);
      if (D.39319 == 0) goto <D.39320>; else goto <D.39321>;
      <D.39320>:
      mono_class_set_failure (klass, 7, 0B);
      D.39322 = tb->name;
      D.39323 = mono_get_exception_type_load (D.39322, 0B);
      mono_raise_exception (D.39323);
      <D.39321>:
      <D.39318>:
      D.39175 = MEM[(struct MonoObject *)tb].vtable;
      D.39266 = D.39175->domain;
      D.39267 = &klass->byval_arg;
      res = mono_type_get_object (D.39266, D.39267);
      D.39324 = res == tb;
      D.39325 = (long int) D.39324;
      D.39326 = __builtin_expect (D.39325, 0);
      if (D.39326 != 0) goto <D.39327>; else goto <D.39328>;
      <D.39327>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11407, "res != (MonoReflectionType*)tb");
      <D.39328>:
      D.39265 = res;
      return D.39265;
      failure:
      mono_class_set_failure (klass, 7, 0B);
      klass->wastypebuilder = 1;
      {
        int ret;

        D.39246 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.39246);
        if (ret != 0) goto <D.39329>; else goto <D.39330>;
        <D.39329>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.39330>:
        D.39331 = ret != 0;
        D.39332 = (long int) D.39331;
        D.39333 = __builtin_expect (D.39332, 0);
        if (D.39333 != 0) goto <D.39334>; else goto <D.39335>;
        <D.39334>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11414, "ret == 0");
        <D.39335>:
      }
      mono_loader_unlock ();
      mono_error_raise_exception (&error);
      D.39265 = 0B;
      return D.39265;
    }
  finally
    {
      error = {CLOBBER};
    }
}


remove_instantiations_of_and_ensure_contents (void * key, void * value, void * user_data)
{
  unsigned char D.39339;
  struct MonoGenericClass * D.39341;
  struct MonoClass * D.39342;
  struct MonoClass * D.39344;
  gboolean D.39345;
  struct MonoType * type;
  struct MonoClass * klass;

  type = key;
  klass = user_data;
  D.39339 = type->type;
  if (D.39339 == 21) goto <D.39340>; else goto <D.39338>;
  <D.39340>:
  D.39341 = type->data.generic_class;
  D.39342 = D.39341->container_class;
  if (D.39342 == klass) goto <D.39343>; else goto <D.39338>;
  <D.39343>:
  D.39344 = mono_class_from_mono_type (type);
  fix_partial_generic_class (D.39344);
  D.39345 = 1;
  return D.39345;
  <D.39338>:
  D.39345 = 0;
  return D.39345;
}


fix_partial_generic_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.39347;
  long unsigned int D.39348;
  long unsigned int D.39349;
  struct MonoClass * D.39352;
  struct MonoClass * D.39353;
  struct MonoType * D.39356;
  struct MonoGenericContext * D.39357;
  int D.39358;
  long unsigned int D.39364;
  long unsigned int D.39365;
  unsigned int D.39368;
  unsigned int D.39371;
  unsigned int D.39372;
  struct MonoImage * D.39375;
  unsigned int D.39376;
  unsigned int D.39377;
  void * D.39378;
  struct MonoMethod * * D.39379;
  long unsigned int D.39380;
  long unsigned int D.39381;
  struct MonoMethod * * D.39382;
  struct MonoMethod * * D.39383;
  struct MonoMethod * * D.39384;
  struct MonoMethod * D.39385;
  struct MonoGenericContext * D.39386;
  struct MonoMethod * D.39387;
  unsigned int i.604;
  short unsigned int D.39389;
  short unsigned int D.39392;
  unsigned int D.39395;
  unsigned int D.39396;
  void * D.39397;
  struct MonoClass * * D.39398;
  struct MonoClass * * D.39399;
  struct MonoClass * D.39400;
  struct MonoType * D.39401;
  struct MonoGenericContext * D.39402;
  struct MonoClass * * D.39403;
  struct MonoClass * * D.39404;
  struct MonoClass * D.39405;
  struct MonoClass * D.39406;
  int D.39407;
  unsigned int D.39408;
  unsigned int D.39409;
  unsigned int D.39412;
  void * D.39413;
  struct MonoClassField * D.39414;
  long unsigned int D.39415;
  struct MonoClassField * D.39416;
  struct MonoClassField * D.39417;
  struct MonoClassField * D.39418;
  struct MonoType * D.39419;
  struct MonoGenericContext * D.39420;
  struct MonoType * D.39421;
  struct MonoClass * gklass;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.39347 = klass->generic_class;
  gklass = D.39347->container_class;
  D.39348 = BIT_FIELD_REF <*klass, 64, 256>;
  D.39349 = D.39348 & 128;
  if (D.39349 != 0) goto <D.39350>; else goto <D.39351>;
  <D.39350>:
  return;
  <D.39351>:
  dgclass = klass->generic_class;
  D.39352 = klass->parent;
  D.39353 = gklass->parent;
  if (D.39352 != D.39353) goto <D.39354>; else goto <D.39355>;
  <D.39354>:
  {
    struct MonoError error;
    struct MonoType * parent_type;

    try
      {
        D.39353 = gklass->parent;
        D.39356 = &D.39353->byval_arg;
        D.39347 = klass->generic_class;
        D.39357 = &D.39347->context;
        parent_type = mono_class_inflate_generic_type_checked (D.39356, D.39357, &error);
        D.39358 = mono_error_ok (&error);
        if (D.39358 != 0) goto <D.39359>; else goto <D.39360>;
        <D.39359>:
        {
          struct MonoClass * parent;

          parent = mono_class_from_mono_type (parent_type);
          mono_metadata_free_type (parent_type);
          D.39352 = klass->parent;
          if (D.39352 != parent) goto <D.39361>; else goto <D.39362>;
          <D.39361>:
          klass->supertypes = 0B;
          mono_class_setup_parent (klass, parent);
          <D.39362>:
        }
        goto <D.39363>;
        <D.39360>:
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        D.39364 = BIT_FIELD_REF <*gklass, 64, 256>;
        D.39365 = D.39364 & 128;
        if (D.39365 != 0) goto <D.39366>; else goto <D.39367>;
        <D.39366>:
        klass->wastypebuilder = 1;
        <D.39367>:
        return;
        <D.39363>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.39355>:
  D.39368 = dgclass->initialized;
  if (D.39368 == 0) goto <D.39369>; else goto <D.39370>;
  <D.39369>:
  return;
  <D.39370>:
  D.39371 = klass->method.count;
  D.39372 = gklass->method.count;
  if (D.39371 != D.39372) goto <D.39373>; else goto <D.39374>;
  <D.39373>:
  D.39372 = gklass->method.count;
  klass->method.count = D.39372;
  D.39375 = klass->image;
  D.39371 = klass->method.count;
  D.39376 = D.39371 + 1;
  D.39377 = D.39376 * 8;
  D.39378 = mono_image_alloc (D.39375, D.39377);
  klass->methods = D.39378;
  i = 0;
  goto <D.23996>;
  <D.23995>:
  D.39379 = klass->methods;
  D.39380 = (long unsigned int) i;
  D.39381 = D.39380 * 8;
  D.39382 = D.39379 + D.39381;
  D.39383 = gklass->methods;
  D.39380 = (long unsigned int) i;
  D.39381 = D.39380 * 8;
  D.39384 = D.39383 + D.39381;
  D.39385 = *D.39384;
  D.39386 = mono_class_get_context (klass);
  D.39387 = mono_class_inflate_generic_method_full (D.39385, klass, D.39386);
  *D.39382 = D.39387;
  i = i + 1;
  <D.23996>:
  i.604 = (unsigned int) i;
  D.39371 = klass->method.count;
  if (i.604 < D.39371) goto <D.23995>; else goto <D.23997>;
  <D.23997>:
  <D.39374>:
  D.39389 = klass->interface_count;
  if (D.39389 != 0) goto <D.39390>; else goto <D.39391>;
  <D.39390>:
  D.39389 = klass->interface_count;
  D.39392 = gklass->interface_count;
  if (D.39389 != D.39392) goto <D.39393>; else goto <D.39394>;
  <D.39393>:
  D.39392 = gklass->interface_count;
  klass->interface_count = D.39392;
  D.39375 = klass->image;
  D.39392 = gklass->interface_count;
  D.39395 = (unsigned int) D.39392;
  D.39396 = D.39395 * 8;
  D.39397 = mono_image_alloc (D.39375, D.39396);
  klass->interfaces = D.39397;
  klass->interfaces_packed = 0B;
  i = 0;
  goto <D.24000>;
  <D.23999>:
  {
    struct MonoType * iface_type;

    D.39398 = gklass->interfaces;
    D.39380 = (long unsigned int) i;
    D.39381 = D.39380 * 8;
    D.39399 = D.39398 + D.39381;
    D.39400 = *D.39399;
    D.39401 = &D.39400->byval_arg;
    D.39402 = mono_class_get_context (klass);
    iface_type = mono_class_inflate_generic_type (D.39401, D.39402);
    D.39403 = klass->interfaces;
    D.39380 = (long unsigned int) i;
    D.39381 = D.39380 * 8;
    D.39404 = D.39403 + D.39381;
    D.39405 = mono_class_from_mono_type (iface_type);
    *D.39404 = D.39405;
    mono_metadata_free_type (iface_type);
    D.39403 = klass->interfaces;
    D.39380 = (long unsigned int) i;
    D.39381 = D.39380 * 8;
    D.39404 = D.39403 + D.39381;
    D.39406 = *D.39404;
    ensure_runtime_vtable (D.39406);
  }
  i = i + 1;
  <D.24000>:
  D.39392 = gklass->interface_count;
  D.39407 = (int) D.39392;
  if (D.39407 > i) goto <D.23999>; else goto <D.24001>;
  <D.24001>:
  klass->interfaces_inited = 1;
  <D.39394>:
  <D.39391>:
  D.39408 = klass->field.count;
  D.39409 = gklass->field.count;
  if (D.39408 != D.39409) goto <D.39410>; else goto <D.39411>;
  <D.39410>:
  D.39409 = gklass->field.count;
  klass->field.count = D.39409;
  D.39375 = klass->image;
  D.39408 = klass->field.count;
  D.39412 = D.39408 * 32;
  D.39413 = image_g_malloc0 (D.39375, D.39412);
  klass->fields = D.39413;
  i = 0;
  goto <D.24003>;
  <D.24002>:
  D.39414 = klass->fields;
  D.39380 = (long unsigned int) i;
  D.39415 = D.39380 * 32;
  D.39416 = D.39414 + D.39415;
  D.39417 = gklass->fields;
  D.39380 = (long unsigned int) i;
  D.39415 = D.39380 * 32;
  D.39418 = D.39417 + D.39415;
  *D.39416 = *D.39418;
  D.39414 = klass->fields;
  D.39380 = (long unsigned int) i;
  D.39415 = D.39380 * 32;
  D.39416 = D.39414 + D.39415;
  D.39416->parent = klass;
  D.39414 = klass->fields;
  D.39380 = (long unsigned int) i;
  D.39415 = D.39380 * 32;
  D.39416 = D.39414 + D.39415;
  D.39417 = gklass->fields;
  D.39380 = (long unsigned int) i;
  D.39415 = D.39380 * 32;
  D.39418 = D.39417 + D.39415;
  D.39419 = D.39418->type;
  D.39420 = mono_class_get_context (klass);
  D.39421 = mono_class_inflate_generic_type (D.39419, D.39420);
  D.39416->type = D.39421;
  i = i + 1;
  <D.24003>:
  i.604 = (unsigned int) i;
  D.39408 = klass->field.count;
  if (i.604 < D.39408) goto <D.24002>; else goto <D.24004>;
  <D.24004>:
  <D.39411>:
  D.39364 = BIT_FIELD_REF <*gklass, 64, 256>;
  D.39365 = D.39364 & 128;
  if (D.39365 != 0) goto <D.39422>; else goto <D.39423>;
  <D.39422>:
  klass->wastypebuilder = 1;
  <D.39423>:
  return;
}


check_array_for_usertypes (struct MonoArray * arr)
{
  long unsigned int D.39429;
  char * D.39430;
  long unsigned int D.39431;
  int i;

  if (arr == 0B) goto <D.39427>; else goto <D.39428>;
  <D.39427>:
  return;
  <D.39428>:
  i = 0;
  goto <D.24156>;
  <D.24155>:
  {
    struct MonoReflectionType * __type;

    D.39429 = (long unsigned int) i;
    D.39430 = mono_array_addr_with_size (arr, 8, D.39429);
    __type = MEM[(struct MonoReflectionType * *)D.39430];
    __type = mono_reflection_type_resolve_user_types (__type);
    {
      struct MonoReflectionType * * __p;

      D.39429 = (long unsigned int) i;
      __p = mono_array_addr_with_size (arr, 8, D.39429);
      *__p = __type;
    }
  }
  i = i + 1;
  <D.24156>:
  D.39429 = (long unsigned int) i;
  D.39431 = mono_array_length (arr);
  if (D.39429 < D.39431) goto <D.24155>; else goto <D.24157>;
  <D.24157>:
}


ensure_runtime_vtable (struct MonoClass * klass)
{
  struct MonoImage * D.39436;
  long unsigned int D.39437;
  long unsigned int D.39438;
  struct MonoGenericClass * D.39441;
  long unsigned int D.39442;
  long unsigned int D.39443;
  struct MonoClass * D.39444;
  int iftmp.605;
  struct MonoArray * D.39450;
  long unsigned int D.39453;
  int D.39455;
  unsigned int num.606;
  long unsigned int D.39457;
  unsigned int D.39458;
  unsigned int D.39459;
  void * D.39460;
  int iftmp.607;
  long unsigned int D.39464;
  struct MonoMethod * * D.39466;
  long unsigned int D.39467;
  long unsigned int D.39468;
  struct MonoMethod * * D.39469;
  long unsigned int D.39470;
  char * D.39471;
  struct MonoReflectionCtorBuilder * D.39472;
  struct MonoMethod * D.39473;
  int j.608;
  long unsigned int D.39475;
  long unsigned int D.39476;
  struct MonoMethod * * D.39477;
  struct MonoArray * D.39478;
  char * D.39479;
  struct MonoReflectionMethodBuilder * D.39480;
  struct MonoMethod * D.39481;
  struct MonoArray * D.39482;
  long unsigned int D.39485;
  short unsigned int D.39486;
  short unsigned int D.39487;
  unsigned int D.39488;
  unsigned int D.39489;
  void * D.39490;
  char * D.39491;
  void * D.39492;
  struct MonoClass * * D.39493;
  struct MonoClass * * D.39494;
  struct MonoClass * D.39495;
  struct MonoClass * D.39496;
  int D.39497;
  unsigned int D.39501;
  unsigned int D.39502;
  short unsigned int D.39505;
  int D.39506;
  int D.39507;
  int slot_num.609;
  short int D.39511;
  unsigned int i.610;
  unsigned int D.39513;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int num;
  int j;

  tb = mono_class_get_ref_info (klass);
  D.39436 = klass->image;
  D.39437 = BIT_FIELD_REF <*D.39436, 64, 192>;
  D.39438 = D.39437 & 34359738368;
  if (D.39438 == 0) goto <D.39433>; else goto <D.39439>;
  <D.39439>:
  if (tb == 0B) goto <D.39440>; else goto <D.39434>;
  <D.39440>:
  D.39441 = klass->generic_class;
  if (D.39441 == 0B) goto <D.39433>; else goto <D.39434>;
  <D.39434>:
  D.39442 = BIT_FIELD_REF <*klass, 64, 256>;
  D.39443 = D.39442 & 128;
  if (D.39443 != 0) goto <D.39433>; else goto <D.39435>;
  <D.39433>:
  return;
  <D.39435>:
  D.39444 = klass->parent;
  if (D.39444 != 0B) goto <D.39445>; else goto <D.39446>;
  <D.39445>:
  D.39444 = klass->parent;
  ensure_runtime_vtable (D.39444);
  <D.39446>:
  if (tb != 0B) goto <D.39447>; else goto <D.39448>;
  <D.39447>:
  D.39450 = tb->ctors;
  if (D.39450 != 0B) goto <D.39451>; else goto <D.39452>;
  <D.39451>:
  D.39450 = tb->ctors;
  D.39453 = mono_array_length (D.39450);
  iftmp.605 = (int) D.39453;
  goto <D.39454>;
  <D.39452>:
  iftmp.605 = 0;
  <D.39454>:
  num = iftmp.605;
  D.39455 = tb->num_methods;
  num = D.39455 + num;
  num.606 = (unsigned int) num;
  klass->method.count = num.606;
  D.39436 = klass->image;
  D.39457 = (long unsigned int) num;
  D.39458 = (unsigned int) D.39457;
  D.39459 = D.39458 * 8;
  D.39460 = mono_image_alloc (D.39436, D.39459);
  klass->methods = D.39460;
  D.39450 = tb->ctors;
  if (D.39450 != 0B) goto <D.39462>; else goto <D.39463>;
  <D.39462>:
  D.39450 = tb->ctors;
  D.39464 = mono_array_length (D.39450);
  iftmp.607 = (int) D.39464;
  goto <D.39465>;
  <D.39463>:
  iftmp.607 = 0;
  <D.39465>:
  num = iftmp.607;
  i = 0;
  goto <D.24017>;
  <D.24016>:
  D.39466 = klass->methods;
  D.39467 = (long unsigned int) i;
  D.39468 = D.39467 * 8;
  D.39469 = D.39466 + D.39468;
  D.39450 = tb->ctors;
  D.39470 = (long unsigned int) i;
  D.39471 = mono_array_addr_with_size (D.39450, 8, D.39470);
  D.39472 = MEM[(struct MonoReflectionCtorBuilder * *)D.39471];
  D.39473 = ctorbuilder_to_mono_method (klass, D.39472);
  *D.39469 = D.39473;
  i = i + 1;
  <D.24017>:
  if (i < num) goto <D.24016>; else goto <D.24018>;
  <D.24018>:
  num = tb->num_methods;
  j = i;
  i = 0;
  goto <D.24020>;
  <D.24019>:
  D.39466 = klass->methods;
  j.608 = j;
  j = j.608 + 1;
  D.39475 = (long unsigned int) j.608;
  D.39476 = D.39475 * 8;
  D.39477 = D.39466 + D.39476;
  D.39478 = tb->methods;
  D.39470 = (long unsigned int) i;
  D.39479 = mono_array_addr_with_size (D.39478, 8, D.39470);
  D.39480 = MEM[(struct MonoReflectionMethodBuilder * *)D.39479];
  D.39481 = methodbuilder_to_mono_method (klass, D.39480);
  *D.39477 = D.39481;
  i = i + 1;
  <D.24020>:
  if (i < num) goto <D.24019>; else goto <D.24021>;
  <D.24021>:
  D.39482 = tb->interfaces;
  if (D.39482 != 0B) goto <D.39483>; else goto <D.39484>;
  <D.39483>:
  D.39482 = tb->interfaces;
  D.39485 = mono_array_length (D.39482);
  D.39486 = (short unsigned int) D.39485;
  klass->interface_count = D.39486;
  D.39436 = klass->image;
  D.39487 = klass->interface_count;
  D.39488 = (unsigned int) D.39487;
  D.39489 = D.39488 * 8;
  D.39490 = mono_image_alloc (D.39436, D.39489);
  klass->interfaces = D.39490;
  i = 0;
  goto <D.24024>;
  <D.24023>:
  {
    struct MonoType * iface;

    D.39482 = tb->interfaces;
    D.39470 = (long unsigned int) i;
    D.39491 = mono_array_addr_with_size (D.39482, 8, D.39470);
    D.39492 = MEM[(void * *)D.39491];
    iface = mono_reflection_type_get_handle (D.39492);
    D.39493 = klass->interfaces;
    D.39467 = (long unsigned int) i;
    D.39468 = D.39467 * 8;
    D.39494 = D.39493 + D.39468;
    D.39495 = mono_class_from_mono_type (iface);
    *D.39494 = D.39495;
    D.39493 = klass->interfaces;
    D.39467 = (long unsigned int) i;
    D.39468 = D.39467 * 8;
    D.39494 = D.39493 + D.39468;
    D.39496 = *D.39494;
    ensure_runtime_vtable (D.39496);
  }
  i = i + 1;
  <D.24024>:
  D.39487 = klass->interface_count;
  D.39497 = (int) D.39487;
  if (D.39497 > i) goto <D.24023>; else goto <D.24025>;
  <D.24025>:
  klass->interfaces_inited = 1;
  <D.39484>:
  goto <D.39498>;
  <D.39448>:
  D.39441 = klass->generic_class;
  if (D.39441 != 0B) goto <D.39499>; else goto <D.39500>;
  <D.39499>:
  ensure_generic_class_runtime_vtable (klass);
  <D.39500>:
  <D.39498>:
  D.39501 = klass->flags;
  D.39502 = D.39501 & 32;
  if (D.39502 != 0) goto <D.39503>; else goto <D.39504>;
  <D.39503>:
  {
    int slot_num;

    slot_num = 0;
    i = 0;
    goto <D.24029>;
    <D.24028>:
    {
      struct MonoMethod * im;

      D.39466 = klass->methods;
      D.39467 = (long unsigned int) i;
      D.39468 = D.39467 * 8;
      D.39469 = D.39466 + D.39468;
      im = *D.39469;
      D.39505 = im->flags;
      D.39506 = (int) D.39505;
      D.39507 = D.39506 & 16;
      if (D.39507 == 0) goto <D.39508>; else goto <D.39509>;
      <D.39508>:
      slot_num.609 = slot_num;
      slot_num = slot_num.609 + 1;
      D.39511 = (short int) slot_num.609;
      im->slot = D.39511;
      <D.39509>:
    }
    i = i + 1;
    <D.24029>:
    i.610 = (unsigned int) i;
    D.39513 = klass->method.count;
    if (i.610 < D.39513) goto <D.24028>; else goto <D.24030>;
    <D.24030>:
    klass->interfaces_packed = 0B;
    mono_class_setup_interface_offsets (klass);
    mono_class_setup_interface_id (klass);
  }
  <D.39504>:
}


ensure_generic_class_runtime_vtable (struct MonoClass * klass)
{
  struct MonoGenericClass * D.39515;
  struct MonoClass * gklass;

  D.39515 = klass->generic_class;
  gklass = D.39515->container_class;
  ensure_runtime_vtable (gklass);
  fix_partial_generic_class (klass);
}


typebuilder_setup_fields (struct MonoClass * klass, struct MonoError * error)
{
  int D.39516;
  unsigned int D.39517;
  int D.39518;
  int D.39521;
  unsigned int D.39522;
  unsigned int D.39523;
  const char * D.39526;
  unsigned char D.39527;
  <unnamed-unsigned:4> D.39528;
  int D.39529;
  int D.39530;
  unsigned int D.39531;
  unsigned int D.39534;
  unsigned int D.39535;
  int D.39536;
  unsigned int D.39537;
  void * D.39538;
  struct MonoClassExt * D.39539;
  unsigned int D.39540;
  void * D.39541;
  struct MonoArray * D.39542;
  long unsigned int D.39543;
  char * D.39544;
  struct MonoClassField * D.39545;
  long unsigned int D.39546;
  long unsigned int D.39547;
  struct MonoString * D.39548;
  char * D.39549;
  int D.39550;
  unsigned int D.39553;
  struct MonoImage * D.39556;
  struct MonoObject * D.39557;
  struct MonoType * D.39558;
  struct MonoType * D.39559;
  struct MonoType * D.39560;
  short unsigned int D.39561;
  struct MonoType * D.39563;
  unsigned int D.39564;
  unsigned int D.39569;
  struct MonoFieldDefaultValue * D.39570;
  long unsigned int D.39571;
  struct MonoFieldDefaultValue * D.39572;
  int D.39573;
  struct MonoArray * D.39576;
  long unsigned int D.39577;
  long unsigned int D.39578;
  short unsigned int D.39581;
  int D.39582;
  int D.39583;
  struct MonoClass * D.39586;
  struct MonoClass * D.39587;
  struct MonoObject * D.39588;
  short unsigned int D.39591;
  MonoTypeEnum * D.39592;
  char * D.39593;
  sizetype D.39594;
  const char * p2.611;
  long int p2.612;
  long int p.613;
  long int D.39598;
  unsigned int D.39599;
  void * D.39600;
  const char * D.39601;
  long unsigned int D.39602;
  unsigned int i.614;
  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.39516 = tb->num_fields;
      D.39517 = (unsigned int) D.39516;
      klass->field.count = D.39517;
      klass->field.first = 0;
      mono_error_init (error);
      D.39518 = tb->class_size;
      if (D.39518 != 0) goto <D.39519>; else goto <D.39520>;
      <D.39519>:
      D.39521 = tb->packing_size;
      D.39522 = (unsigned int) D.39521;
      D.39523 = D.39522 & 4294967280;
      if (D.39523 != 0) goto <D.39524>; else goto <D.39525>;
      <D.39524>:
      {
        char * err_msg;

        D.39526 = klass->name;
        D.39521 = tb->packing_size;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.39526, D.39521);
        mono_class_set_failure (klass, 7, err_msg);
        return;
      }
      <D.39525>:
      D.39521 = tb->packing_size;
      D.39527 = (unsigned char) D.39521;
      D.39528 = (<unnamed-unsigned:4>) D.39527;
      klass->packing_size = D.39528;
      D.39529 = klass->instance_size;
      D.39518 = tb->class_size;
      D.39530 = D.39529 + D.39518;
      real_size = (guint32) D.39530;
      <D.39520>:
      D.39531 = klass->field.count;
      if (D.39531 == 0) goto <D.39532>; else goto <D.39533>;
      <D.39532>:
      D.39529 = klass->instance_size;
      D.39534 = (unsigned int) D.39529;
      D.39535 = MAX_EXPR <D.39534, real_size>;
      D.39536 = (int) D.39535;
      klass->instance_size = D.39536;
      return;
      <D.39533>:
      D.39531 = klass->field.count;
      D.39537 = D.39531 * 32;
      D.39538 = image_g_malloc0 (image, D.39537);
      klass->fields = D.39538;
      mono_class_alloc_ext (klass);
      D.39539 = klass->ext;
      D.39531 = klass->field.count;
      D.39540 = D.39531 * 16;
      D.39541 = image_g_malloc0 (image, D.39540);
      D.39539->field_def_values = D.39541;
      klass->size_inited = 1;
      i = 0;
      goto <D.24095>;
      <D.24094>:
      {
        struct MonoArray * rva_data;

        D.39542 = tb->fields;
        D.39543 = (long unsigned int) i;
        D.39544 = mono_array_addr_with_size (D.39542, 8, D.39543);
        fb = MEM[(void * *)D.39544];
        D.39545 = klass->fields;
        D.39546 = (long unsigned int) i;
        D.39547 = D.39546 * 32;
        field = D.39545 + D.39547;
        D.39548 = fb->name;
        D.39549 = mono_string_to_utf8_image (image, D.39548, error);
        field->name = D.39549;
        D.39550 = mono_error_ok (error);
        if (D.39550 == 0) goto <D.39551>; else goto <D.39552>;
        <D.39551>:
        return;
        <D.39552>:
        D.39553 = fb->attrs;
        if (D.39553 != 0) goto <D.39554>; else goto <D.39555>;
        <D.39554>:
        D.39556 = klass->image;
        D.39557 = fb->type;
        D.39558 = mono_reflection_type_get_handle (D.39557);
        D.39559 = mono_metadata_type_dup (D.39556, D.39558);
        field->type = D.39559;
        D.39560 = field->type;
        D.39553 = fb->attrs;
        D.39561 = (short unsigned int) D.39553;
        D.39560->attrs = D.39561;
        goto <D.39562>;
        <D.39555>:
        D.39557 = fb->type;
        D.39563 = mono_reflection_type_get_handle (D.39557);
        field->type = D.39563;
        <D.39562>:
        D.39553 = fb->attrs;
        D.39564 = D.39553 & 256;
        if (D.39564 != 0) goto <D.39565>; else goto <D.39566>;
        <D.39565>:
        rva_data = fb->rva_data;
        if (rva_data != 0B) goto <D.39567>; else goto <D.39568>;
        <D.39567>:
        {
          char * base;
          size_t size;
          char * data;

          base = mono_array_addr_with_size (rva_data, 1, 0);
          size = mono_array_length (rva_data);
          D.39556 = klass->image;
          D.39569 = (unsigned int) size;
          data = mono_image_alloc (D.39556, D.39569);
          memcpy (data, base, size);
          D.39539 = klass->ext;
          D.39570 = D.39539->field_def_values;
          D.39546 = (long unsigned int) i;
          D.39571 = D.39546 * 16;
          D.39572 = D.39570 + D.39571;
          D.39572->data = data;
        }
        <D.39568>:
        <D.39566>:
        D.39573 = fb->offset;
        if (D.39573 != -1) goto <D.39574>; else goto <D.39575>;
        <D.39574>:
        D.39573 = fb->offset;
        field->offset = D.39573;
        <D.39575>:
        field->parent = klass;
        fb->handle = field;
        D.39556 = klass->image;
        D.39576 = fb->cattrs;
        mono_save_custom_attrs (D.39556, field, D.39576);
        D.39577 = BIT_FIELD_REF <*klass, 64, 256>;
        D.39578 = D.39577 & 16;
        if (D.39578 != 0) goto <D.39579>; else goto <D.39580>;
        <D.39579>:
        D.39560 = field->type;
        D.39581 = D.39560->attrs;
        D.39582 = (int) D.39581;
        D.39583 = D.39582 & 16;
        if (D.39583 == 0) goto <D.39584>; else goto <D.39585>;
        <D.39584>:
        D.39560 = field->type;
        D.39586 = mono_class_from_mono_type (D.39560);
        klass->element_class = D.39586;
        D.39587 = klass->element_class;
        klass->cast_class = D.39587;
        <D.39585>:
        <D.39580>:
        D.39588 = fb->def_value;
        if (D.39588 != 0B) goto <D.39589>; else goto <D.39590>;
        <D.39589>:
        {
          struct MonoDynamicImage * assembly;

          assembly = klass->image;
          D.39560 = field->type;
          D.39560 = field->type;
          D.39581 = D.39560->attrs;
          D.39591 = D.39581 | 32768;
          D.39560->attrs = D.39591;
          D.39588 = fb->def_value;
          D.39539 = klass->ext;
          D.39570 = D.39539->field_def_values;
          D.39546 = (long unsigned int) i;
          D.39571 = D.39546 * 16;
          D.39572 = D.39570 + D.39571;
          D.39592 = &D.39572->def_type;
          idx = encode_constant (assembly, D.39588, D.39592);
          D.39593 = assembly->blob.data;
          D.39594 = (sizetype) idx;
          p = D.39593 + D.39594;
          len = mono_metadata_decode_blob_size (p, &p2);
          p2.611 = p2;
          p2.612 = (long int) p2.611;
          p.613 = (long int) p;
          D.39598 = p2.612 - p.613;
          D.39599 = (unsigned int) D.39598;
          len = D.39599 + len;
          D.39539 = klass->ext;
          D.39570 = D.39539->field_def_values;
          D.39546 = (long unsigned int) i;
          D.39571 = D.39546 * 16;
          D.39572 = D.39570 + D.39571;
          D.39600 = mono_image_alloc (image, len);
          D.39572->data = D.39600;
          D.39539 = klass->ext;
          D.39570 = D.39539->field_def_values;
          D.39546 = (long unsigned int) i;
          D.39571 = D.39546 * 16;
          D.39572 = D.39570 + D.39571;
          D.39601 = D.39572->data;
          D.39602 = (long unsigned int) len;
          memcpy (D.39601, p, D.39602);
        }
        <D.39590>:
      }
      i = i + 1;
      <D.24095>:
      i.614 = (unsigned int) i;
      D.39531 = klass->field.count;
      if (i.614 < D.39531) goto <D.24094>; else goto <D.24096>;
      <D.24096>:
      D.39529 = klass->instance_size;
      D.39534 = (unsigned int) D.39529;
      D.39535 = MAX_EXPR <D.39534, real_size>;
      D.39536 = (int) D.39535;
      klass->instance_size = D.39536;
      mono_class_layout_fields (klass);
    }
  finally
    {
      p2 = {CLOBBER};
    }
}


typebuilder_setup_properties (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.39607;
  void * D.39610;
  guint32 iftmp.615;
  struct MonoArray * D.39612;
  long unsigned int D.39615;
  unsigned int D.39617;
  unsigned int D.39618;
  long unsigned int D.39619;
  char * D.39620;
  long unsigned int D.39621;
  long unsigned int D.39622;
  struct MonoProperty * D.39623;
  unsigned int D.39624;
  struct MonoString * D.39625;
  char * D.39626;
  int D.39627;
  struct MonoReflectionMethodBuilder * D.39630;
  struct MonoMethod * D.39633;
  struct MonoReflectionMethodBuilder * D.39634;
  struct MonoMethod * D.39637;
  struct MonoImage * D.39638;
  void * D.39639;
  struct MonoArray * D.39640;
  struct MonoObject * D.39641;
  struct MonoFieldDefaultValue * D.39644;
  unsigned int D.39647;
  void * D.39648;
  unsigned int D.39649;
  unsigned int D.39650;
  long unsigned int D.39651;
  struct MonoFieldDefaultValue * D.39652;
  MonoTypeEnum * D.39653;
  char * D.39654;
  sizetype D.39655;
  const char * p2.616;
  long int p2.617;
  long int p.618;
  long int D.39659;
  unsigned int D.39660;
  void * D.39661;
  const char * D.39662;
  long unsigned int D.39663;
  unsigned int i.619;
  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.39607 = klass->ext;
  if (D.39607 == 0B) goto <D.39608>; else goto <D.39609>;
  <D.39608>:
  D.39610 = image_g_malloc0 (image, 64);
  klass->ext = D.39610;
  <D.39609>:
  D.39607 = klass->ext;
  D.39612 = tb->properties;
  if (D.39612 != 0B) goto <D.39613>; else goto <D.39614>;
  <D.39613>:
  D.39612 = tb->properties;
  D.39615 = mono_array_length (D.39612);
  iftmp.615 = (guint32) D.39615;
  goto <D.39616>;
  <D.39614>:
  iftmp.615 = 0;
  <D.39616>:
  D.39607->property.count = iftmp.615;
  D.39607 = klass->ext;
  D.39607->property.first = 0;
  D.39607 = klass->ext;
  D.39617 = D.39607->property.count;
  D.39618 = D.39617 * 40;
  properties = image_g_malloc0 (image, D.39618);
  D.39607 = klass->ext;
  D.39607->properties = properties;
  i = 0;
  goto <D.24112>;
  <D.24111>:
  D.39612 = tb->properties;
  D.39619 = (long unsigned int) i;
  D.39620 = mono_array_addr_with_size (D.39612, 8, D.39619);
  pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.39620];
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39623 = properties + D.39622;
  D.39623->parent = klass;
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39623 = properties + D.39622;
  D.39624 = pb->attrs;
  D.39623->attrs = D.39624;
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39623 = properties + D.39622;
  D.39625 = pb->name;
  D.39626 = mono_string_to_utf8_image (image, D.39625, error);
  D.39623->name = D.39626;
  D.39627 = mono_error_ok (error);
  if (D.39627 == 0) goto <D.39628>; else goto <D.39629>;
  <D.39628>:
  return;
  <D.39629>:
  D.39630 = pb->get_method;
  if (D.39630 != 0B) goto <D.39631>; else goto <D.39632>;
  <D.39631>:
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39623 = properties + D.39622;
  D.39630 = pb->get_method;
  D.39633 = D.39630->mhandle;
  D.39623->get = D.39633;
  <D.39632>:
  D.39634 = pb->set_method;
  if (D.39634 != 0B) goto <D.39635>; else goto <D.39636>;
  <D.39635>:
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39623 = properties + D.39622;
  D.39634 = pb->set_method;
  D.39637 = D.39634->mhandle;
  D.39623->set = D.39637;
  <D.39636>:
  D.39638 = klass->image;
  D.39621 = (long unsigned int) i;
  D.39622 = D.39621 * 40;
  D.39639 = properties + D.39622;
  D.39640 = pb->cattrs;
  mono_save_custom_attrs (D.39638, D.39639, D.39640);
  D.39641 = pb->def_value;
  if (D.39641 != 0B) goto <D.39642>; else goto <D.39643>;
  <D.39642>:
  {
    guint32 len;
    guint32 idx;
    const char * p;
    const char * p2;
    struct MonoDynamicImage * assembly;

    try
      {
        assembly = klass->image;
        D.39607 = klass->ext;
        D.39644 = D.39607->prop_def_values;
        if (D.39644 == 0B) goto <D.39645>; else goto <D.39646>;
        <D.39645>:
        D.39607 = klass->ext;
        D.39607 = klass->ext;
        D.39617 = D.39607->property.count;
        D.39647 = D.39617 * 16;
        D.39648 = image_g_malloc0 (image, D.39647);
        D.39607->prop_def_values = D.39648;
        <D.39646>:
        D.39621 = (long unsigned int) i;
        D.39622 = D.39621 * 40;
        D.39623 = properties + D.39622;
        D.39621 = (long unsigned int) i;
        D.39622 = D.39621 * 40;
        D.39623 = properties + D.39622;
        D.39649 = D.39623->attrs;
        D.39650 = D.39649 | 4096;
        D.39623->attrs = D.39650;
        D.39641 = pb->def_value;
        D.39607 = klass->ext;
        D.39644 = D.39607->prop_def_values;
        D.39621 = (long unsigned int) i;
        D.39651 = D.39621 * 16;
        D.39652 = D.39644 + D.39651;
        D.39653 = &D.39652->def_type;
        idx = encode_constant (assembly, D.39641, D.39653);
        D.39654 = assembly->blob.data;
        D.39655 = (sizetype) idx;
        p = D.39654 + D.39655;
        len = mono_metadata_decode_blob_size (p, &p2);
        p2.616 = p2;
        p2.617 = (long int) p2.616;
        p.618 = (long int) p;
        D.39659 = p2.617 - p.618;
        D.39660 = (unsigned int) D.39659;
        len = D.39660 + len;
        D.39607 = klass->ext;
        D.39644 = D.39607->prop_def_values;
        D.39621 = (long unsigned int) i;
        D.39651 = D.39621 * 16;
        D.39652 = D.39644 + D.39651;
        D.39661 = mono_image_alloc (image, len);
        D.39652->data = D.39661;
        D.39607 = klass->ext;
        D.39644 = D.39607->prop_def_values;
        D.39621 = (long unsigned int) i;
        D.39651 = D.39621 * 16;
        D.39652 = D.39644 + D.39651;
        D.39662 = D.39652->data;
        D.39663 = (long unsigned int) len;
        memcpy (D.39662, p, D.39663);
      }
    finally
      {
        p2 = {CLOBBER};
      }
  }
  <D.39643>:
  i = i + 1;
  <D.24112>:
  i.619 = (unsigned int) i;
  D.39607 = klass->ext;
  D.39617 = D.39607->property.count;
  if (i.619 < D.39617) goto <D.24111>; else goto <D.24113>;
  <D.24113>:
}


typebuilder_setup_events (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.39666;
  void * D.39669;
  guint32 iftmp.620;
  struct MonoArray * D.39671;
  long unsigned int D.39674;
  unsigned int D.39676;
  unsigned int D.39677;
  long unsigned int D.39678;
  char * D.39679;
  long unsigned int D.39680;
  long unsigned int D.39681;
  struct MonoEvent * D.39682;
  unsigned int D.39683;
  struct MonoString * D.39684;
  char * D.39685;
  int D.39686;
  struct MonoReflectionMethodBuilder * D.39689;
  struct MonoMethod * D.39692;
  struct MonoReflectionMethodBuilder * D.39693;
  struct MonoMethod * D.39696;
  struct MonoReflectionMethodBuilder * D.39697;
  struct MonoMethod * D.39700;
  struct MonoArray * D.39701;
  long unsigned int D.39704;
  long unsigned int D.39705;
  unsigned int D.39706;
  unsigned int D.39707;
  void * D.39708;
  long unsigned int D.39709;
  char * D.39710;
  struct MonoMethod * * D.39711;
  long unsigned int D.39712;
  long unsigned int D.39713;
  struct MonoMethod * * D.39714;
  struct MonoMethod * D.39715;
  long unsigned int D.39716;
  struct MonoImage * D.39717;
  void * D.39718;
  struct MonoArray * D.39719;
  unsigned int i.621;
  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.39666 = klass->ext;
  if (D.39666 == 0B) goto <D.39667>; else goto <D.39668>;
  <D.39667>:
  D.39669 = image_g_malloc0 (image, 64);
  klass->ext = D.39669;
  <D.39668>:
  D.39666 = klass->ext;
  D.39671 = tb->events;
  if (D.39671 != 0B) goto <D.39672>; else goto <D.39673>;
  <D.39672>:
  D.39671 = tb->events;
  D.39674 = mono_array_length (D.39671);
  iftmp.620 = (guint32) D.39674;
  goto <D.39675>;
  <D.39673>:
  iftmp.620 = 0;
  <D.39675>:
  D.39666->event.count = iftmp.620;
  D.39666 = klass->ext;
  D.39666->event.first = 0;
  D.39666 = klass->ext;
  D.39676 = D.39666->event.count;
  D.39677 = D.39676 * 56;
  events = image_g_malloc0 (image, D.39677);
  D.39666 = klass->ext;
  D.39666->events = events;
  i = 0;
  goto <D.24140>;
  <D.24139>:
  D.39671 = tb->events;
  D.39678 = (long unsigned int) i;
  D.39679 = mono_array_addr_with_size (D.39671, 8, D.39678);
  eb = MEM[(struct MonoReflectionEventBuilder * *)D.39679];
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39682->parent = klass;
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39683 = eb->attrs;
  D.39682->attrs = D.39683;
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39684 = eb->name;
  D.39685 = mono_string_to_utf8_image (image, D.39684, error);
  D.39682->name = D.39685;
  D.39686 = mono_error_ok (error);
  if (D.39686 == 0) goto <D.39687>; else goto <D.39688>;
  <D.39687>:
  return;
  <D.39688>:
  D.39689 = eb->add_method;
  if (D.39689 != 0B) goto <D.39690>; else goto <D.39691>;
  <D.39690>:
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39689 = eb->add_method;
  D.39692 = D.39689->mhandle;
  D.39682->add = D.39692;
  <D.39691>:
  D.39693 = eb->remove_method;
  if (D.39693 != 0B) goto <D.39694>; else goto <D.39695>;
  <D.39694>:
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39693 = eb->remove_method;
  D.39696 = D.39693->mhandle;
  D.39682->remove = D.39696;
  <D.39695>:
  D.39697 = eb->raise_method;
  if (D.39697 != 0B) goto <D.39698>; else goto <D.39699>;
  <D.39698>:
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39682 = events + D.39681;
  D.39697 = eb->raise_method;
  D.39700 = D.39697->mhandle;
  D.39682->raise = D.39700;
  <D.39699>:
  D.39701 = eb->other_methods;
  if (D.39701 != 0B) goto <D.39702>; else goto <D.39703>;
  <D.39702>:
  {
    int j;

    D.39680 = (long unsigned int) i;
    D.39681 = D.39680 * 56;
    D.39682 = events + D.39681;
    D.39701 = eb->other_methods;
    D.39704 = mono_array_length (D.39701);
    D.39705 = D.39704 + 1;
    D.39706 = (unsigned int) D.39705;
    D.39707 = D.39706 * 8;
    D.39708 = image_g_malloc0 (image, D.39707);
    D.39682->other = D.39708;
    j = 0;
    goto <D.24137>;
    <D.24136>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.39701 = eb->other_methods;
      D.39709 = (long unsigned int) j;
      D.39710 = mono_array_addr_with_size (D.39701, 8, D.39709);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.39710];
      D.39680 = (long unsigned int) i;
      D.39681 = D.39680 * 56;
      D.39682 = events + D.39681;
      D.39711 = D.39682->other;
      D.39712 = (long unsigned int) j;
      D.39713 = D.39712 * 8;
      D.39714 = D.39711 + D.39713;
      D.39715 = mb->mhandle;
      *D.39714 = D.39715;
    }
    j = j + 1;
    <D.24137>:
    D.39709 = (long unsigned int) j;
    D.39701 = eb->other_methods;
    D.39716 = mono_array_length (D.39701);
    if (D.39709 < D.39716) goto <D.24136>; else goto <D.24138>;
    <D.24138>:
  }
  <D.39703>:
  D.39717 = klass->image;
  D.39680 = (long unsigned int) i;
  D.39681 = D.39680 * 56;
  D.39718 = events + D.39681;
  D.39719 = eb->cattrs;
  mono_save_custom_attrs (D.39717, D.39718, D.39719);
  i = i + 1;
  <D.24140>:
  i.621 = (unsigned int) i;
  D.39666 = klass->ext;
  D.39676 = D.39666->event.count;
  if (i.621 < D.39676) goto <D.24139>; else goto <D.24141>;
  <D.24141>:
}


mono_reflection_initialize_generic_parameter (struct MonoReflectionGenericParam * gparam)
{
  struct MonoReflectionTypeBuilder * D.39722;
  struct MonoReflectionModuleBuilder * D.39723;
  struct MonoDynamicImage * D.39724;
  struct MonoString * D.39725;
  char * D.39726;
  int D.39727;
  _Bool D.39728;
  long int D.39729;
  long int D.39730;
  unsigned int D.39733;
  short unsigned int D.39734;
  struct MonoReflectionMethodBuilder * D.39735;
  struct MonoGenericContainer * D.39738;
  struct MonoType * D.39741;
  struct MonoImage * D.39742;
  void * D.39743;
  struct MonoGenericContainer * D.39747;
  struct MonoType * D.39750;
  struct MonoImage * D.39751;
  void * D.39752;
  _Bool D.39753;
  int D.39754;
  struct MonoType * D.39755;
  struct MonoGenericParamFull * param;
  struct MonoImage * image;
  struct MonoClass * pklass;
  struct MonoError error;

  try
    {
      D.39722 = gparam->tbuilder;
      D.39723 = D.39722->module;
      D.39724 = D.39723->dynamic_image;
      image = &D.39724->image;
      param = mono_image_alloc0 (image, 56);
      D.39725 = gparam->name;
      D.39726 = mono_string_to_utf8_image (image, D.39725, &error);
      param->info.name = D.39726;
      D.39727 = mono_error_ok (&error);
      D.39728 = D.39727 == 0;
      D.39729 = (long int) D.39728;
      D.39730 = __builtin_expect (D.39729, 0);
      if (D.39730 != 0) goto <D.39731>; else goto <D.39732>;
      <D.39731>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11435, "mono_error_ok (&error)");
      <D.39732>:
      D.39733 = gparam->index;
      D.39734 = (short unsigned int) D.39733;
      param->param.num = D.39734;
      D.39735 = gparam->mbuilder;
      if (D.39735 != 0B) goto <D.39736>; else goto <D.39737>;
      <D.39736>:
      D.39735 = gparam->mbuilder;
      D.39738 = D.39735->generic_container;
      if (D.39738 == 0B) goto <D.39739>; else goto <D.39740>;
      <D.39739>:
      {
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        D.39735 = gparam->mbuilder;
        tb = D.39735->type;
        D.39741 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.39741);
        D.39735 = gparam->mbuilder;
        D.39742 = klass->image;
        D.39743 = mono_image_alloc0 (D.39742, 56);
        D.39735->generic_container = D.39743;
        D.39735 = gparam->mbuilder;
        D.39738 = D.39735->generic_container;
        D.39738->is_method = -1;
        D.39735 = gparam->mbuilder;
        D.39738 = D.39735->generic_container;
        D.39742 = klass->image;
        D.39738->image = D.39742;
      }
      <D.39740>:
      D.39735 = gparam->mbuilder;
      D.39738 = D.39735->generic_container;
      param->param.owner = D.39738;
      goto <D.39744>;
      <D.39737>:
      D.39722 = gparam->tbuilder;
      if (D.39722 != 0B) goto <D.39745>; else goto <D.39746>;
      <D.39745>:
      D.39722 = gparam->tbuilder;
      D.39747 = D.39722->generic_container;
      if (D.39747 == 0B) goto <D.39748>; else goto <D.39749>;
      <D.39748>:
      {
        struct MonoClass * klass;

        D.39722 = gparam->tbuilder;
        D.39750 = mono_reflection_type_get_handle (D.39722);
        klass = mono_class_from_mono_type (D.39750);
        D.39722 = gparam->tbuilder;
        D.39751 = klass->image;
        D.39752 = mono_image_alloc0 (D.39751, 56);
        D.39722->generic_container = D.39752;
        D.39722 = gparam->tbuilder;
        D.39747 = D.39722->generic_container;
        D.39747->owner.klass = klass;
      }
      <D.39749>:
      D.39722 = gparam->tbuilder;
      D.39747 = D.39722->generic_container;
      param->param.owner = D.39747;
      <D.39746>:
      <D.39744>:
      D.39735 = gparam->mbuilder;
      D.39753 = D.39735 != 0B;
      D.39754 = (int) D.39753;
      pklass = mono_class_from_generic_parameter (param, image, D.39754);
      D.39755 = &pklass->byval_arg;
      gparam->type.type = D.39755;
      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.622;
  guint32 iftmp.623;
  struct MonoArray * D.39761;
  long unsigned int D.39764;
  long unsigned int D.39768;
  char * D.39769;
  char * D.39770;
  long int D.39771;
  char * D.39772;
  long int D.39773;
  long int D.39774;
  struct MonoDomain * D.39775;
  struct MonoClass * D.39776;
  long unsigned int D.39777;
  char * D.39778;
  long unsigned int D.39779;
  struct MonoArray * D.39780;
  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.39757>; else goto <D.39758>;
      <D.39757>:
      iftmp.622 = module->dynamic_image;
      goto <D.39759>;
      <D.39758>:
      iftmp.622 = 0B;
      <D.39759>:
      assembly = iftmp.622;
      D.39761 = sig->arguments;
      if (D.39761 != 0B) goto <D.39762>; else goto <D.39763>;
      <D.39762>:
      D.39761 = sig->arguments;
      D.39764 = mono_array_length (D.39761);
      iftmp.623 = (guint32) D.39764;
      goto <D.39765>;
      <D.39763>:
      iftmp.623 = 0;
      <D.39765>:
      na = iftmp.623;
      D.39761 = sig->arguments;
      check_array_for_usertypes (D.39761);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, na);
      if (assembly != 0B) goto <D.39766>; else goto <D.39767>;
      <D.39766>:
      i = 0;
      goto <D.24222>;
      <D.24221>:
      {
        struct MonoReflectionType * type;

        D.39761 = sig->arguments;
        D.39768 = (long unsigned int) i;
        D.39769 = mono_array_addr_with_size (D.39761, 8, D.39768);
        type = MEM[(struct MonoReflectionType * *)D.39769];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.24222>:
      if (i < na) goto <D.24221>; else goto <D.24223>;
      <D.24223>:
      <D.39767>:
      D.39770 = buf.p;
      D.39771 = (long int) D.39770;
      D.39772 = buf.buf;
      D.39773 = (long int) D.39772;
      D.39774 = D.39771 - D.39773;
      buflen = (guint32) D.39774;
      D.39775 = mono_domain_get ();
      D.39776 = mono_defaults.byte_class;
      D.39777 = (long unsigned int) buflen;
      result = mono_array_new (D.39775, D.39776, D.39777);
      D.39778 = mono_array_addr_with_size (result, 1, 0);
      D.39772 = buf.buf;
      D.39779 = (long unsigned int) buflen;
      memcpy (D.39778, D.39772, D.39779);
      sigbuffer_free (&buf);
      D.39780 = result;
      return D.39780;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_sighelper_get_signature_field (struct MonoReflectionSigHelper * sig)
{
  struct MonoReflectionModuleBuilder * D.39783;
  guint32 iftmp.624;
  struct MonoArray * D.39785;
  long unsigned int D.39788;
  long unsigned int D.39790;
  char * D.39791;
  char * D.39792;
  long int D.39793;
  char * D.39794;
  long int D.39795;
  long int D.39796;
  struct MonoDomain * D.39797;
  struct MonoClass * D.39798;
  long unsigned int D.39799;
  char * D.39800;
  long unsigned int D.39801;
  struct MonoArray * D.39802;
  struct MonoDynamicImage * assembly;
  guint32 na;
  guint32 buflen;
  guint32 i;
  struct MonoArray * result;
  struct SigBuffer buf;

  try
    {
      D.39783 = sig->module;
      assembly = D.39783->dynamic_image;
      D.39785 = sig->arguments;
      if (D.39785 != 0B) goto <D.39786>; else goto <D.39787>;
      <D.39786>:
      D.39785 = sig->arguments;
      D.39788 = mono_array_length (D.39785);
      iftmp.624 = (guint32) D.39788;
      goto <D.39789>;
      <D.39787>:
      iftmp.624 = 0;
      <D.39789>:
      na = iftmp.624;
      D.39785 = sig->arguments;
      check_array_for_usertypes (D.39785);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      i = 0;
      goto <D.24235>;
      <D.24234>:
      {
        struct MonoReflectionType * type;

        D.39785 = sig->arguments;
        D.39790 = (long unsigned int) i;
        D.39791 = mono_array_addr_with_size (D.39785, 8, D.39790);
        type = MEM[(struct MonoReflectionType * *)D.39791];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.24235>:
      if (i < na) goto <D.24234>; else goto <D.24236>;
      <D.24236>:
      D.39792 = buf.p;
      D.39793 = (long int) D.39792;
      D.39794 = buf.buf;
      D.39795 = (long int) D.39794;
      D.39796 = D.39793 - D.39795;
      buflen = (guint32) D.39796;
      D.39797 = mono_domain_get ();
      D.39798 = mono_defaults.byte_class;
      D.39799 = (long unsigned int) buflen;
      result = mono_array_new (D.39797, D.39798, D.39799);
      D.39800 = mono_array_addr_with_size (result, 1, 0);
      D.39794 = buf.buf;
      D.39801 = (long unsigned int) buflen;
      memcpy (D.39800, D.39794, D.39801);
      sigbuffer_free (&buf);
      D.39802 = result;
      return D.39802;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_create_dynamic_method (struct MonoReflectionDynamicMethod * mb)
{
  int D.39805;
  struct MonoException * D.39808;
  struct MonoReferenceQueue * dynamic_method_queue.625;
  int D.39814;
  unsigned int D.39815;
  int D.39816;
  long unsigned int D.39817;
  long unsigned int D.39818;
  void * D.39819;
  struct MonoArray * D.39820;
  long unsigned int D.39821;
  char * D.39822;
  int D.24268;
  int iftmp.626;
  int D.24267;
  struct MonoVTable * D.39826;
  struct MonoClass * D.39827;
  const char[14] * D.39828;
  unsigned char D.39829;
  int D.39830;
  unsigned char D.39831;
  int D.39832;
  const unsigned char * D.39837;
  unsigned char D.39838;
  int D.39839;
  const unsigned char * D.39840;
  unsigned char D.39841;
  int D.39842;
  const unsigned char * D.39847;
  unsigned char D.39848;
  int D.39849;
  const unsigned char * D.39850;
  unsigned char D.39851;
  int D.39852;
  const unsigned char * D.39857;
  unsigned char D.39858;
  int D.39859;
  const unsigned char * D.39860;
  unsigned char D.39861;
  int D.39862;
  const char * D.39864;
  struct MonoMethod * D.39867;
  struct GSList * D.39871;
  struct GSList * D.39872;
  struct MonoClass * handle_class.627;
  struct MonoReflectionModule * D.39875;
  struct MonoImage * D.39876;
  <unnamed type> D.39880;
  struct MonoClass * handle_class.628;
  void * * D.39886;
  long unsigned int D.39887;
  long unsigned int D.39888;
  void * * D.39889;
  sizetype D.39890;
  sizetype D.39891;
  sizetype D.39892;
  void * * D.39893;
  struct MonoClass * iftmp.629;
  struct MonoReflectionType * D.39895;
  struct MonoType * D.39898;
  struct MonoDomain * D.39900;
  int D.39901;
  struct MonoMethod * D.39904;
  _Bool D.39905;
  long int D.39906;
  long int D.39907;
  void * * D.39910;
  void * D.39911;
  int D.39914;
  sizetype D.39915;
  sizetype D.39916;
  sizetype D.39917;
  void * * D.39918;
  void * D.39919;
  struct MonoMethod * D.39922;
  unsigned int i.630;
  void * D.39924;
  long int D.39925;
  unsigned int D.39926;
  struct GSList * D.39927;
  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.39805 = mono_runtime_is_shutting_down ();
      if (D.39805 != 0) goto <D.39806>; else goto <D.39807>;
      <D.39806>:
      D.39808 = mono_get_exception_invalid_operation ("");
      mono_raise_exception (D.39808);
      <D.39807>:
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.39809>; else goto <D.39810>;
      <D.39809>:
      mono_loader_lock ();
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.39811>; else goto <D.39812>;
      <D.39811>:
      dynamic_method_queue.625 = mono_gc_reference_queue_new (free_dynamic_method);
      dynamic_method_queue = dynamic_method_queue.625;
      queue = dynamic_method_queue;
      <D.39812>:
      mono_loader_unlock ();
      <D.39810>:
      sig = dynamic_method_to_signature (mb);
      reflection_methodbuilder_from_dynamic_method (&rmb, mb);
      D.39814 = mb->nrefs;
      D.39815 = (unsigned int) D.39814;
      rmb.nrefs = D.39815;
      D.39814 = mb->nrefs;
      D.39816 = D.39814 + 1;
      D.39817 = (long unsigned int) D.39816;
      D.39818 = D.39817 * 8;
      D.39819 = monoeg_malloc0 (D.39818);
      rmb.refs = D.39819;
      i = 0;
      goto <D.24272>;
      <D.24271>:
      {
        struct MonoClass * handle_class;
        void * ref;
        struct MonoObject * obj;

        try
          {
            D.39820 = mb->refs;
            D.39821 = (long unsigned int) i;
            D.39822 = mono_array_addr_with_size (D.39820, 8, D.39821);
            obj = MEM[(struct MonoObject * *)D.39822];
            {
              size_t __s1_len;
              size_t __s2_len;

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

                D.39826 = obj->vtable;
                D.39827 = D.39826->klass;
                __s2 = D.39827->name;
                D.39828 = "DynamicMethod";
                D.39829 = MEM[(const unsigned char *)D.39828];
                D.39830 = (int) D.39829;
                D.39831 = *__s2;
                D.39832 = (int) D.39831;
                __result = D.39830 - D.39832;
                {
                  if (__s2_len != 0) goto <D.39833>; else goto <D.39834>;
                  <D.39833>:
                  if (__result == 0) goto <D.39835>; else goto <D.39836>;
                  <D.39835>:
                  D.39837 = &MEM[(void *)"DynamicMethod" + 1B];
                  D.39838 = *D.39837;
                  D.39839 = (int) D.39838;
                  D.39840 = __s2 + 1;
                  D.39841 = *D.39840;
                  D.39842 = (int) D.39841;
                  __result = D.39839 - D.39842;
                  if (__s2_len > 1) goto <D.39843>; else goto <D.39844>;
                  <D.39843>:
                  if (__result == 0) goto <D.39845>; else goto <D.39846>;
                  <D.39845>:
                  D.39847 = &MEM[(void *)"DynamicMethod" + 2B];
                  D.39848 = *D.39847;
                  D.39849 = (int) D.39848;
                  D.39850 = __s2 + 2;
                  D.39851 = *D.39850;
                  D.39852 = (int) D.39851;
                  __result = D.39849 - D.39852;
                  if (__s2_len > 2) goto <D.39853>; else goto <D.39854>;
                  <D.39853>:
                  if (__result == 0) goto <D.39855>; else goto <D.39856>;
                  <D.39855>:
                  D.39857 = &MEM[(void *)"DynamicMethod" + 3B];
                  D.39858 = *D.39857;
                  D.39859 = (int) D.39858;
                  D.39860 = __s2 + 3;
                  D.39861 = *D.39860;
                  D.39862 = (int) D.39861;
                  __result = D.39859 - D.39862;
                  <D.39856>:
                  <D.39854>:
                  <D.39846>:
                  <D.39844>:
                  <D.39836>:
                  <D.39834>:
                }
                D.24267 = __result;
              }
              iftmp.626 = -D.24267;
              goto <D.39863>;
              <D.39825>:
              D.39826 = obj->vtable;
              D.39827 = D.39826->klass;
              D.39864 = D.39827->name;
              iftmp.626 = __builtin_strcmp (D.39864, "DynamicMethod");
              <D.39863>:
              D.24268 = iftmp.626;
            }
            if (D.24268 == 0) goto <D.39865>; else goto <D.39866>;
            <D.39865>:
            {
              struct MonoReflectionDynamicMethod * method;

              method = obj;
              D.39867 = method->mhandle;
              if (D.39867 != 0B) goto <D.39868>; else goto <D.39869>;
              <D.39868>:
              ref = method->mhandle;
              goto <D.39870>;
              <D.39869>:
              ref = method;
              D.39871 = method->referenced_by;
              D.39872 = monoeg_g_slist_append (D.39871, mb);
              method->referenced_by = D.39872;
              <D.39870>:
              handle_class.627 = mono_defaults.methodhandle_class;
              handle_class = handle_class.627;
            }
            goto <D.39874>;
            <D.39866>:
            {
              struct MonoException * ex;

              ex = 0B;
              D.39875 = mb->module;
              D.39876 = D.39875->image;
              ref = resolve_object (D.39876, obj, &handle_class, 0B);
              if (ref == 0B) goto <D.39877>; else goto <D.39878>;
              <D.39877>:
              ex = mono_get_exception_type_load (0B, 0B);
              goto <D.39879>;
              <D.39878>:
              D.39880 = mono_security_get_mode ();
              if (D.39880 == 1) goto <D.39881>; else goto <D.39882>;
              <D.39881>:
              handle_class.628 = handle_class;
              ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class.628);
              <D.39882>:
              <D.39879>:
              if (ex != 0B) goto <D.39884>; else goto <D.39885>;
              <D.39884>:
              D.39886 = rmb.refs;
              monoeg_g_free (D.39886);
              mono_raise_exception (ex);
              return;
              <D.39885>:
            }
            <D.39874>:
            D.39886 = rmb.refs;
            D.39887 = (long unsigned int) i;
            D.39888 = D.39887 * 8;
            D.39889 = D.39886 + D.39888;
            *D.39889 = ref;
            D.39886 = rmb.refs;
            D.39890 = (sizetype) i;
            D.39891 = D.39890 + 1;
            D.39892 = D.39891 * 8;
            D.39893 = D.39886 + D.39892;
            handle_class.628 = handle_class;
            *D.39893 = handle_class.628;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      i = i + 2;
      <D.24272>:
      D.39814 = mb->nrefs;
      if (D.39814 > i) goto <D.24271>; else goto <D.24273>;
      <D.24273>:
      D.39895 = mb->owner;
      if (D.39895 != 0B) goto <D.39896>; else goto <D.39897>;
      <D.39896>:
      D.39895 = mb->owner;
      D.39898 = mono_reflection_type_get_handle (D.39895);
      iftmp.629 = mono_class_from_mono_type (D.39898);
      goto <D.39899>;
      <D.39897>:
      iftmp.629 = mono_defaults.object_class;
      <D.39899>:
      klass = iftmp.629;
      handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = handle;
      release_data = monoeg_malloc (16);
      release_data->handle = handle;
      D.39900 = mono_object_get_domain (mb);
      release_data->domain = D.39900;
      D.39901 = mono_gc_reference_queue_add (queue, mb, release_data);
      if (D.39901 == 0) goto <D.39902>; else goto <D.39903>;
      <D.39902>:
      monoeg_g_free (release_data);
      <D.39903>:
      l = mb->referenced_by;
      goto <D.24281>;
      <D.24280>:
      {
        struct MonoReflectionDynamicMethod * method;
        struct MonoMethodWrapper * wrapper;
        void * * data;

        method = l->data;
        wrapper = method->mhandle;
        D.39904 = method->mhandle;
        D.39905 = D.39904 == 0B;
        D.39906 = (long int) D.39905;
        D.39907 = __builtin_expect (D.39906, 0);
        if (D.39907 != 0) goto <D.39908>; else goto <D.39909>;
        <D.39908>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11637, "method->mhandle");
        <D.39909>:
        data = wrapper->method_data;
        i = 0;
        goto <D.24278>;
        <D.24277>:
        D.39890 = (sizetype) i;
        D.39891 = D.39890 + 1;
        D.39892 = D.39891 * 8;
        D.39910 = data + D.39892;
        D.39911 = *D.39910;
        if (D.39911 == mb) goto <D.39912>; else goto <D.39913>;
        <D.39912>:
        D.39914 = i + 1;
        D.39915 = (sizetype) D.39914;
        D.39916 = D.39915 + 1;
        D.39917 = D.39916 * 8;
        D.39918 = data + D.39917;
        D.39919 = *D.39918;
        handle_class.627 = mono_defaults.methodhandle_class;
        if (D.39919 == handle_class.627) goto <D.39920>; else goto <D.39921>;
        <D.39920>:
        D.39890 = (sizetype) i;
        D.39891 = D.39890 + 1;
        D.39892 = D.39891 * 8;
        D.39910 = data + D.39892;
        D.39922 = mb->mhandle;
        *D.39910 = D.39922;
        <D.39921>:
        <D.39913>:
        i = i + 2;
        <D.24278>:
        i.630 = (unsigned int) i;
        D.39924 = *data;
        D.39925 = (long int) D.39924;
        D.39926 = (unsigned int) D.39925;
        if (i.630 < D.39926) goto <D.24277>; else goto <D.24279>;
        <D.24279>:
      }
      l = l->next;
      <D.24281>:
      if (l != 0B) goto <D.24280>; else goto <D.24282>;
      <D.24282>:
      D.39927 = mb->referenced_by;
      monoeg_g_slist_free (D.39927);
      D.39886 = rmb.refs;
      monoeg_g_free (D.39886);
      mb->ilgen = 0B;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


free_dynamic_method (void * dynamic_method)
{
  struct MonoDomain * D.39933;
  struct MonoMethod * D.39934;
  struct DynamicMethodReleaseData * data;

  data = dynamic_method;
  D.39933 = data->domain;
  D.39934 = data->handle;
  mono_runtime_free_method (D.39933, D.39934);
  monoeg_g_free (data);
}


dynamic_method_to_signature (struct MonoReflectionDynamicMethod * method)
{
  struct MonoArray * D.39935;
  unsigned int D.39936;
  unsigned int D.39937;
  _Bool D.39938;
  struct MonoType * iftmp.631;
  struct MonoReflectionType * D.39940;
  struct MonoClass * D.39944;
  struct MonoMethodSignature * D.39945;
  struct MonoMethodSignature * sig;

  D.39935 = method->parameters;
  sig = parameters_to_signature (0B, D.39935);
  D.39936 = method->attrs;
  D.39937 = D.39936 & 16;
  D.39938 = D.39937 == 0;
  sig->hasthis = D.39938;
  D.39940 = method->rtype;
  if (D.39940 != 0B) goto <D.39941>; else goto <D.39942>;
  <D.39941>:
  D.39940 = method->rtype;
  iftmp.631 = mono_reflection_type_get_handle (D.39940);
  goto <D.39943>;
  <D.39942>:
  D.39944 = mono_defaults.void_class;
  iftmp.631 = &D.39944->byval_arg;
  <D.39943>:
  sig->ret = iftmp.631;
  sig->generic_param_count = 0;
  D.39945 = sig;
  return D.39945;
}


reflection_methodbuilder_from_dynamic_method (struct ReflectionMethodBuilder * rmb, struct MonoReflectionDynamicMethod * mb)
{
  struct MonoReflectionILGen * D.39947;
  struct MonoReflectionType * D.39948;
  struct MonoArray * D.39949;
  unsigned int D.39950;
  unsigned int D.39951;
  struct MonoReflectionType * D.39952;
  struct MonoString * D.39953;
  unsigned char D.39954;
  unsigned char D.39955;
  struct MonoMethod * D.39956;

  memset (rmb, 0, 208);
  D.39947 = mb->ilgen;
  rmb->ilgen = D.39947;
  D.39948 = mb->rtype;
  rmb->rtype = D.39948;
  D.39949 = mb->parameters;
  rmb->parameters = D.39949;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  rmb->pinfo = 0B;
  D.39950 = mb->attrs;
  rmb->attrs = D.39950;
  rmb->iattrs = 0;
  D.39951 = mb->call_conv;
  rmb->call_conv = D.39951;
  rmb->code = 0B;
  D.39952 = mb->owner;
  rmb->type = D.39952;
  D.39953 = mb->name;
  rmb->name = D.39953;
  rmb->table_idx = 0B;
  D.39954 = mb->init_locals;
  rmb->init_locals = D.39954;
  D.39955 = mb->skip_visibility;
  rmb->skip_visibility = D.39955;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  rmb->param_modreq = 0B;
  rmb->param_modopt = 0B;
  rmb->permissions = 0B;
  D.39956 = mb->mhandle;
  rmb->mhandle = D.39956;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


resolve_object (struct MonoImage * image, struct MonoObject * obj, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  int D.24328;
  int iftmp.632;
  int D.24327;
  struct MonoVTable * D.39960;
  struct MonoClass * D.39961;
  const char[7] * D.39962;
  unsigned char D.39963;
  int D.39964;
  unsigned char D.39965;
  int D.39966;
  const unsigned char * D.39971;
  unsigned char D.39972;
  int D.39973;
  const unsigned char * D.39974;
  unsigned char D.39975;
  int D.39976;
  const unsigned char * D.39981;
  unsigned char D.39982;
  int D.39983;
  const unsigned char * D.39984;
  unsigned char D.39985;
  int D.39986;
  const unsigned char * D.39991;
  unsigned char D.39992;
  int D.39993;
  const unsigned char * D.39994;
  unsigned char D.39995;
  int D.39996;
  const char * D.39998;
  struct MonoClass * D.40001;
  _Bool D.40002;
  long int D.40003;
  long int D.40004;
  int D.24337;
  int iftmp.633;
  int D.24336;
  const char[9] * D.40011;
  unsigned char D.40012;
  int D.40013;
  unsigned char D.40014;
  int D.40015;
  const unsigned char * D.40020;
  unsigned char D.40021;
  int D.40022;
  const unsigned char * D.40023;
  unsigned char D.40024;
  int D.40025;
  const unsigned char * D.40030;
  unsigned char D.40031;
  int D.40032;
  const unsigned char * D.40033;
  unsigned char D.40034;
  int D.40035;
  const unsigned char * D.40040;
  unsigned char D.40041;
  int D.40042;
  const unsigned char * D.40043;
  unsigned char D.40044;
  int D.40045;
  int D.40049;
  struct MonoException * D.40052;
  struct MonoClass * D.40056;
  int D.24349;
  int iftmp.634;
  int D.24348;
  const char[11] * D.40066;
  unsigned char D.40067;
  int D.40068;
  unsigned char D.40069;
  int D.40070;
  const unsigned char * D.40075;
  unsigned char D.40076;
  int D.40077;
  const unsigned char * D.40078;
  unsigned char D.40079;
  int D.40080;
  const unsigned char * D.40085;
  unsigned char D.40086;
  int D.40087;
  const unsigned char * D.40088;
  unsigned char D.40089;
  int D.40090;
  const unsigned char * D.40095;
  unsigned char D.40096;
  int D.40097;
  const unsigned char * D.40098;
  unsigned char D.40099;
  int D.40100;
  int D.24358;
  int iftmp.635;
  int D.24357;
  const char[12] * D.40106;
  unsigned char D.40107;
  int D.40108;
  unsigned char D.40109;
  int D.40110;
  const unsigned char * D.40115;
  unsigned char D.40116;
  int D.40117;
  const unsigned char * D.40118;
  unsigned char D.40119;
  int D.40120;
  const unsigned char * D.40125;
  unsigned char D.40126;
  int D.40127;
  const unsigned char * D.40128;
  unsigned char D.40129;
  int D.40130;
  const unsigned char * D.40135;
  unsigned char D.40136;
  int D.40137;
  const unsigned char * D.40138;
  unsigned char D.40139;
  int D.40140;
  int D.24367;
  int iftmp.636;
  int D.24366;
  const char[19] * D.40146;
  unsigned char D.40147;
  int D.40148;
  unsigned char D.40149;
  int D.40150;
  const unsigned char * D.40155;
  unsigned char D.40156;
  int D.40157;
  const unsigned char * D.40158;
  unsigned char D.40159;
  int D.40160;
  const unsigned char * D.40165;
  unsigned char D.40166;
  int D.40167;
  const unsigned char * D.40168;
  unsigned char D.40169;
  int D.40170;
  const unsigned char * D.40175;
  unsigned char D.40176;
  int D.40177;
  const unsigned char * D.40178;
  unsigned char D.40179;
  int D.40180;
  int D.24376;
  int iftmp.637;
  int D.24375;
  const char[18] * D.40186;
  unsigned char D.40187;
  int D.40188;
  unsigned char D.40189;
  int D.40190;
  const unsigned char * D.40195;
  unsigned char D.40196;
  int D.40197;
  const unsigned char * D.40198;
  unsigned char D.40199;
  int D.40200;
  const unsigned char * D.40205;
  unsigned char D.40206;
  int D.40207;
  const unsigned char * D.40208;
  unsigned char D.40209;
  int D.40210;
  const unsigned char * D.40215;
  unsigned char D.40216;
  int D.40217;
  const unsigned char * D.40218;
  unsigned char D.40219;
  int D.40220;
  struct MonoClass * D.40224;
  int D.24385;
  int iftmp.638;
  int D.24384;
  const char[14] * D.40230;
  unsigned char D.40231;
  int D.40232;
  unsigned char D.40233;
  int D.40234;
  const unsigned char * D.40239;
  unsigned char D.40240;
  int D.40241;
  const unsigned char * D.40242;
  unsigned char D.40243;
  int D.40244;
  const unsigned char * D.40249;
  unsigned char D.40250;
  int D.40251;
  const unsigned char * D.40252;
  unsigned char D.40253;
  int D.40254;
  const unsigned char * D.40259;
  unsigned char D.40260;
  int D.40261;
  const unsigned char * D.40262;
  unsigned char D.40263;
  int D.40264;
  struct MonoDomain * D.40270;
  int D.24396;
  int iftmp.639;
  int D.24395;
  const char[19] * D.40277;
  unsigned char D.40278;
  int D.40279;
  unsigned char D.40280;
  int D.40281;
  const unsigned char * D.40286;
  unsigned char D.40287;
  int D.40288;
  const unsigned char * D.40289;
  unsigned char D.40290;
  int D.40291;
  const unsigned char * D.40296;
  unsigned char D.40297;
  int D.40298;
  const unsigned char * D.40299;
  unsigned char D.40300;
  int D.40301;
  const unsigned char * D.40306;
  unsigned char D.40307;
  int D.40308;
  const unsigned char * D.40309;
  unsigned char D.40310;
  int D.40311;
  struct MonoDomain * D.40317;
  int D.24407;
  int iftmp.640;
  int D.24406;
  const char[10] * D.40324;
  unsigned char D.40325;
  int D.40326;
  unsigned char D.40327;
  int D.40328;
  const unsigned char * D.40333;
  unsigned char D.40334;
  int D.40335;
  const unsigned char * D.40336;
  unsigned char D.40337;
  int D.40338;
  const unsigned char * D.40343;
  unsigned char D.40344;
  int D.40345;
  const unsigned char * D.40346;
  unsigned char D.40347;
  int D.40348;
  const unsigned char * D.40353;
  unsigned char D.40354;
  int D.40355;
  const unsigned char * D.40356;
  unsigned char D.40357;
  int D.40358;
  struct MonoClass * D.40362;
  struct MonoType * D.40365;
  int D.24421;
  const char * D.40366;
  const char * D.40367;
  int iftmp.641;
  int D.24433;
  _Bool D.40374;
  long int D.40375;
  long int D.40376;
  struct MonoClass * D.40380;
  int D.24442;
  int iftmp.642;
  int D.24441;
  const char[13] * D.40387;
  unsigned char D.40388;
  int D.40389;
  unsigned char D.40390;
  int D.40391;
  const unsigned char * D.40396;
  unsigned char D.40397;
  int D.40398;
  const unsigned char * D.40399;
  unsigned char D.40400;
  int D.40401;
  const unsigned char * D.40406;
  unsigned char D.40407;
  int D.40408;
  const unsigned char * D.40409;
  unsigned char D.40410;
  int D.40411;
  const unsigned char * D.40416;
  unsigned char D.40417;
  int D.40418;
  const unsigned char * D.40419;
  unsigned char D.40420;
  int D.40421;
  struct MonoDomain * D.40427;
  struct MonoClassField * D.40428;
  struct MonoClass * D.40431;
  struct MonoGenericContainer * D.40432;
  struct MonoType * D.40435;
  const char * D.40436;
  int D.24456;
  int iftmp.643;
  int D.24455;
  const char[12] * D.40443;
  unsigned char D.40444;
  int D.40445;
  unsigned char D.40446;
  int D.40447;
  const unsigned char * D.40452;
  unsigned char D.40453;
  int D.40454;
  const unsigned char * D.40455;
  unsigned char D.40456;
  int D.40457;
  const unsigned char * D.40462;
  unsigned char D.40463;
  int D.40464;
  const unsigned char * D.40465;
  unsigned char D.40466;
  int D.40467;
  const unsigned char * D.40472;
  unsigned char D.40473;
  int D.40474;
  const unsigned char * D.40475;
  unsigned char D.40476;
  int D.40477;
  long unsigned int D.40481;
  long unsigned int D.40482;
  struct MonoDomain * D.40486;
  int D.24468;
  int iftmp.644;
  int D.24467;
  const char[16] * D.40493;
  unsigned char D.40494;
  int D.40495;
  unsigned char D.40496;
  int D.40497;
  const unsigned char * D.40502;
  unsigned char D.40503;
  int D.40504;
  const unsigned char * D.40505;
  unsigned char D.40506;
  int D.40507;
  const unsigned char * D.40512;
  unsigned char D.40513;
  int D.40514;
  const unsigned char * D.40515;
  unsigned char D.40516;
  int D.40517;
  const unsigned char * D.40522;
  unsigned char D.40523;
  int D.40524;
  const unsigned char * D.40525;
  unsigned char D.40526;
  int D.40527;
  struct MonoArray * D.40531;
  long unsigned int D.40534;
  unsigned int nargs.645;
  unsigned int D.40537;
  unsigned int D.40538;
  _Bool D.40539;
  unsigned int D.40540;
  _Bool D.40541;
  unsigned int D.40542;
  unsigned char D.40545;
  unsigned char D.40546;
  <unnamed-unsigned:6> D.40547;
  unsigned int D.40549;
  short unsigned int D.40553;
  struct MonoReflectionType * D.40554;
  struct MonoType * D.40555;
  long unsigned int D.40556;
  char * D.40557;
  void * D.40558;
  struct MonoType * D.40559;
  int D.24484;
  int iftmp.646;
  int D.24483;
  const char[14] * D.40564;
  unsigned char D.40565;
  int D.40566;
  unsigned char D.40567;
  int D.40568;
  const unsigned char * D.40573;
  unsigned char D.40574;
  int D.40575;
  const unsigned char * D.40576;
  unsigned char D.40577;
  int D.40578;
  const unsigned char * D.40583;
  unsigned char D.40584;
  int D.40585;
  const unsigned char * D.40586;
  unsigned char D.40587;
  int D.40588;
  const unsigned char * D.40593;
  unsigned char D.40594;
  int D.40595;
  const unsigned char * D.40596;
  unsigned char D.40597;
  int D.40598;
  struct MonoMethod * D.40602;
  _Bool D.40603;
  long int D.40604;
  long int D.40605;
  int D.24494;
  int iftmp.647;
  int D.24493;
  const char[28] * D.40612;
  unsigned char D.40613;
  int D.40614;
  unsigned char D.40615;
  int D.40616;
  const unsigned char * D.40621;
  unsigned char D.40622;
  int D.40623;
  const unsigned char * D.40624;
  unsigned char D.40625;
  int D.40626;
  const unsigned char * D.40631;
  unsigned char D.40632;
  int D.40633;
  const unsigned char * D.40634;
  unsigned char D.40635;
  int D.40636;
  const unsigned char * D.40641;
  unsigned char D.40642;
  int D.40643;
  const unsigned char * D.40644;
  unsigned char D.40645;
  int D.40646;
  int D.24504;
  int iftmp.648;
  int D.24503;
  const char[17] * D.40656;
  unsigned char D.40657;
  int D.40658;
  unsigned char D.40659;
  int D.40660;
  const unsigned char * D.40665;
  unsigned char D.40666;
  int D.40667;
  const unsigned char * D.40668;
  unsigned char D.40669;
  int D.40670;
  const unsigned char * D.40675;
  unsigned char D.40676;
  int D.40677;
  const unsigned char * D.40678;
  unsigned char D.40679;
  int D.40680;
  const unsigned char * D.40685;
  unsigned char D.40686;
  int D.40687;
  const unsigned char * D.40688;
  unsigned char D.40689;
  int D.40690;
  int D.24514;
  int iftmp.649;
  int D.24513;
  const char[23] * D.40700;
  unsigned char D.40701;
  int D.40702;
  unsigned char D.40703;
  int D.40704;
  const unsigned char * D.40709;
  unsigned char D.40710;
  int D.40711;
  const unsigned char * D.40712;
  unsigned char D.40713;
  int D.40714;
  const unsigned char * D.40719;
  unsigned char D.40720;
  int D.40721;
  const unsigned char * D.40722;
  unsigned char D.40723;
  int D.40724;
  const unsigned char * D.40729;
  unsigned char D.40730;
  int D.40731;
  const unsigned char * D.40732;
  unsigned char D.40733;
  int D.40734;
  struct MonoObject * D.40738;
  struct MonoVTable * D.40739;
  struct MonoClass * D.40740;
  int D.40741;
  int D.40745;
  char * D.40749;
  struct MonoReflectionGenericClass * D.40750;
  struct MonoType * D.40751;
  const char * D.40752;
  struct MonoClass * D.40753;
  int D.24528;
  int iftmp.650;
  int D.24527;
  const char[29] * D.40760;
  unsigned char D.40761;
  int D.40762;
  unsigned char D.40763;
  int D.40764;
  const unsigned char * D.40769;
  unsigned char D.40770;
  int D.40771;
  const unsigned char * D.40772;
  unsigned char D.40773;
  int D.40774;
  const unsigned char * D.40779;
  unsigned char D.40780;
  int D.40781;
  const unsigned char * D.40782;
  unsigned char D.40783;
  int D.40784;
  const unsigned char * D.40789;
  unsigned char D.40790;
  int D.40791;
  const unsigned char * D.40792;
  unsigned char D.40793;
  int D.40794;
  struct MonoReflectionGenericClass * D.40798;
  struct MonoType * D.40799;
  struct MonoObject * D.40800;
  struct MonoVTable * D.40801;
  struct MonoClass * D.40802;
  int D.40803;
  int D.40807;
  char * D.40811;
  int D.24542;
  int iftmp.651;
  int D.24541;
  const char[24] * D.40816;
  unsigned char D.40817;
  int D.40818;
  unsigned char D.40819;
  int D.40820;
  const unsigned char * D.40825;
  unsigned char D.40826;
  int D.40827;
  const unsigned char * D.40828;
  unsigned char D.40829;
  int D.40830;
  const unsigned char * D.40835;
  unsigned char D.40836;
  int D.40837;
  const unsigned char * D.40838;
  unsigned char D.40839;
  int D.40840;
  const unsigned char * D.40845;
  unsigned char D.40846;
  int D.40847;
  const unsigned char * D.40848;
  unsigned char D.40849;
  int D.40850;
  struct MonoArray * D.40854;
  struct MonoReflectionType * D.40860;
  struct MonoType * D.40861;
  struct MonoObject * D.40862;
  struct MonoVTable * D.40863;
  struct MonoClass * D.40864;
  int D.40865;
  int D.40869;
  char * D.40873;
  int D.24556;
  int iftmp.652;
  int D.24555;
  const char[16] * D.40878;
  unsigned char D.40879;
  int D.40880;
  unsigned char D.40881;
  int D.40882;
  const unsigned char * D.40887;
  unsigned char D.40888;
  int D.40889;
  const unsigned char * D.40890;
  unsigned char D.40891;
  int D.40892;
  const unsigned char * D.40897;
  unsigned char D.40898;
  int D.40899;
  const unsigned char * D.40900;
  unsigned char D.40901;
  int D.40902;
  const unsigned char * D.40907;
  unsigned char D.40908;
  int D.40909;
  const unsigned char * D.40910;
  unsigned char D.40911;
  int D.40912;
  struct MonoReflectionType * D.40916;
  struct MonoString * D.40917;
  int D.24571;
  const char * D.40918;
  _Bool D.40920;
  long int D.40921;
  long int D.40922;
  struct MonoClass * D.40929;
  int D.40930;
  struct MonoClass * D.40932;
  int D.40933;
  struct MonoClass * D.40935;
  int D.40936;
  void * D.40940;
  void * result;

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

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.39962 = "String";
      D.39963 = MEM[(const unsigned char *)D.39962];
      D.39964 = (int) D.39963;
      D.39965 = *__s2;
      D.39966 = (int) D.39965;
      __result = D.39964 - D.39966;
      {
        if (__s2_len != 0) goto <D.39967>; else goto <D.39968>;
        <D.39967>:
        if (__result == 0) goto <D.39969>; else goto <D.39970>;
        <D.39969>:
        D.39971 = &MEM[(void *)"String" + 1B];
        D.39972 = *D.39971;
        D.39973 = (int) D.39972;
        D.39974 = __s2 + 1;
        D.39975 = *D.39974;
        D.39976 = (int) D.39975;
        __result = D.39973 - D.39976;
        if (__s2_len > 1) goto <D.39977>; else goto <D.39978>;
        <D.39977>:
        if (__result == 0) goto <D.39979>; else goto <D.39980>;
        <D.39979>:
        D.39981 = &MEM[(void *)"String" + 2B];
        D.39982 = *D.39981;
        D.39983 = (int) D.39982;
        D.39984 = __s2 + 2;
        D.39985 = *D.39984;
        D.39986 = (int) D.39985;
        __result = D.39983 - D.39986;
        if (__s2_len > 2) goto <D.39987>; else goto <D.39988>;
        <D.39987>:
        if (__result == 0) goto <D.39989>; else goto <D.39990>;
        <D.39989>:
        D.39991 = &MEM[(void *)"String" + 3B];
        D.39992 = *D.39991;
        D.39993 = (int) D.39992;
        D.39994 = __s2 + 3;
        D.39995 = *D.39994;
        D.39996 = (int) D.39995;
        __result = D.39993 - D.39996;
        <D.39990>:
        <D.39988>:
        <D.39980>:
        <D.39978>:
        <D.39970>:
        <D.39968>:
      }
      D.24327 = __result;
    }
    iftmp.632 = -D.24327;
    goto <D.39997>;
    <D.39959>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.632 = __builtin_strcmp (D.39998, "String");
    <D.39997>:
    D.24328 = iftmp.632;
  }
  if (D.24328 == 0) goto <D.39999>; else goto <D.40000>;
  <D.39999>:
  result = mono_string_intern (obj);
  D.40001 = mono_defaults.string_class;
  *handle_class = D.40001;
  D.40002 = result == 0B;
  D.40003 = (long int) D.40002;
  D.40004 = __builtin_expect (D.40003, 0);
  if (D.40004 != 0) goto <D.40005>; else goto <D.40006>;
  <D.40005>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11751, "result");
  <D.40006>:
  goto <D.40007>;
  <D.40000>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40011 = "MonoType";
      D.40012 = MEM[(const unsigned char *)D.40011];
      D.40013 = (int) D.40012;
      D.40014 = *__s2;
      D.40015 = (int) D.40014;
      __result = D.40013 - D.40015;
      {
        if (__s2_len != 0) goto <D.40016>; else goto <D.40017>;
        <D.40016>:
        if (__result == 0) goto <D.40018>; else goto <D.40019>;
        <D.40018>:
        D.40020 = &MEM[(void *)"MonoType" + 1B];
        D.40021 = *D.40020;
        D.40022 = (int) D.40021;
        D.40023 = __s2 + 1;
        D.40024 = *D.40023;
        D.40025 = (int) D.40024;
        __result = D.40022 - D.40025;
        if (__s2_len > 1) goto <D.40026>; else goto <D.40027>;
        <D.40026>:
        if (__result == 0) goto <D.40028>; else goto <D.40029>;
        <D.40028>:
        D.40030 = &MEM[(void *)"MonoType" + 2B];
        D.40031 = *D.40030;
        D.40032 = (int) D.40031;
        D.40033 = __s2 + 2;
        D.40034 = *D.40033;
        D.40035 = (int) D.40034;
        __result = D.40032 - D.40035;
        if (__s2_len > 2) goto <D.40036>; else goto <D.40037>;
        <D.40036>:
        if (__result == 0) goto <D.40038>; else goto <D.40039>;
        <D.40038>:
        D.40040 = &MEM[(void *)"MonoType" + 3B];
        D.40041 = *D.40040;
        D.40042 = (int) D.40041;
        D.40043 = __s2 + 3;
        D.40044 = *D.40043;
        D.40045 = (int) D.40044;
        __result = D.40042 - D.40045;
        <D.40039>:
        <D.40037>:
        <D.40029>:
        <D.40027>:
        <D.40019>:
        <D.40017>:
      }
      D.24336 = __result;
    }
    iftmp.633 = -D.24336;
    goto <D.40046>;
    <D.40010>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.633 = __builtin_strcmp (D.39998, "MonoType");
    <D.40046>:
    D.24337 = iftmp.633;
  }
  if (D.24337 == 0) goto <D.40047>; else goto <D.40048>;
  <D.40047>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.40049 = mono_class_init (mc);
    if (D.40049 == 0) goto <D.40050>; else goto <D.40051>;
    <D.40050>:
    D.40052 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.40052);
    <D.40051>:
    if (context != 0B) goto <D.40053>; else goto <D.40054>;
    <D.40053>:
    {
      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.40055>;
    <D.40054>:
    result = mono_class_from_mono_type (type);
    <D.40055>:
    D.40056 = mono_defaults.typehandle_class;
    *handle_class = D.40056;
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40057>; else goto <D.40058>;
    <D.40057>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11766, "result");
    <D.40058>:
  }
  goto <D.40059>;
  <D.40048>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40066 = "MonoMethod";
      D.40067 = MEM[(const unsigned char *)D.40066];
      D.40068 = (int) D.40067;
      D.40069 = *__s2;
      D.40070 = (int) D.40069;
      __result = D.40068 - D.40070;
      {
        if (__s2_len != 0) goto <D.40071>; else goto <D.40072>;
        <D.40071>:
        if (__result == 0) goto <D.40073>; else goto <D.40074>;
        <D.40073>:
        D.40075 = &MEM[(void *)"MonoMethod" + 1B];
        D.40076 = *D.40075;
        D.40077 = (int) D.40076;
        D.40078 = __s2 + 1;
        D.40079 = *D.40078;
        D.40080 = (int) D.40079;
        __result = D.40077 - D.40080;
        if (__s2_len > 1) goto <D.40081>; else goto <D.40082>;
        <D.40081>:
        if (__result == 0) goto <D.40083>; else goto <D.40084>;
        <D.40083>:
        D.40085 = &MEM[(void *)"MonoMethod" + 2B];
        D.40086 = *D.40085;
        D.40087 = (int) D.40086;
        D.40088 = __s2 + 2;
        D.40089 = *D.40088;
        D.40090 = (int) D.40089;
        __result = D.40087 - D.40090;
        if (__s2_len > 2) goto <D.40091>; else goto <D.40092>;
        <D.40091>:
        if (__result == 0) goto <D.40093>; else goto <D.40094>;
        <D.40093>:
        D.40095 = &MEM[(void *)"MonoMethod" + 3B];
        D.40096 = *D.40095;
        D.40097 = (int) D.40096;
        D.40098 = __s2 + 3;
        D.40099 = *D.40098;
        D.40100 = (int) D.40099;
        __result = D.40097 - D.40100;
        <D.40094>:
        <D.40092>:
        <D.40084>:
        <D.40082>:
        <D.40074>:
        <D.40072>:
      }
      D.24348 = __result;
    }
    iftmp.634 = -D.24348;
    goto <D.40101>;
    <D.40065>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.634 = __builtin_strcmp (D.39998, "MonoMethod");
    <D.40101>:
    D.24349 = iftmp.634;
  }
  if (D.24349 == 0) goto <D.40060>; else goto <D.40102>;
  <D.40102>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40106 = "MonoCMethod";
      D.40107 = MEM[(const unsigned char *)D.40106];
      D.40108 = (int) D.40107;
      D.40109 = *__s2;
      D.40110 = (int) D.40109;
      __result = D.40108 - D.40110;
      {
        if (__s2_len != 0) goto <D.40111>; else goto <D.40112>;
        <D.40111>:
        if (__result == 0) goto <D.40113>; else goto <D.40114>;
        <D.40113>:
        D.40115 = &MEM[(void *)"MonoCMethod" + 1B];
        D.40116 = *D.40115;
        D.40117 = (int) D.40116;
        D.40118 = __s2 + 1;
        D.40119 = *D.40118;
        D.40120 = (int) D.40119;
        __result = D.40117 - D.40120;
        if (__s2_len > 1) goto <D.40121>; else goto <D.40122>;
        <D.40121>:
        if (__result == 0) goto <D.40123>; else goto <D.40124>;
        <D.40123>:
        D.40125 = &MEM[(void *)"MonoCMethod" + 2B];
        D.40126 = *D.40125;
        D.40127 = (int) D.40126;
        D.40128 = __s2 + 2;
        D.40129 = *D.40128;
        D.40130 = (int) D.40129;
        __result = D.40127 - D.40130;
        if (__s2_len > 2) goto <D.40131>; else goto <D.40132>;
        <D.40131>:
        if (__result == 0) goto <D.40133>; else goto <D.40134>;
        <D.40133>:
        D.40135 = &MEM[(void *)"MonoCMethod" + 3B];
        D.40136 = *D.40135;
        D.40137 = (int) D.40136;
        D.40138 = __s2 + 3;
        D.40139 = *D.40138;
        D.40140 = (int) D.40139;
        __result = D.40137 - D.40140;
        <D.40134>:
        <D.40132>:
        <D.40124>:
        <D.40122>:
        <D.40114>:
        <D.40112>:
      }
      D.24357 = __result;
    }
    iftmp.635 = -D.24357;
    goto <D.40141>;
    <D.40105>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.635 = __builtin_strcmp (D.39998, "MonoCMethod");
    <D.40141>:
    D.24358 = iftmp.635;
  }
  if (D.24358 == 0) goto <D.40060>; else goto <D.40142>;
  <D.40142>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40146 = "MonoGenericCMethod";
      D.40147 = MEM[(const unsigned char *)D.40146];
      D.40148 = (int) D.40147;
      D.40149 = *__s2;
      D.40150 = (int) D.40149;
      __result = D.40148 - D.40150;
      {
        if (__s2_len != 0) goto <D.40151>; else goto <D.40152>;
        <D.40151>:
        if (__result == 0) goto <D.40153>; else goto <D.40154>;
        <D.40153>:
        D.40155 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.40156 = *D.40155;
        D.40157 = (int) D.40156;
        D.40158 = __s2 + 1;
        D.40159 = *D.40158;
        D.40160 = (int) D.40159;
        __result = D.40157 - D.40160;
        if (__s2_len > 1) goto <D.40161>; else goto <D.40162>;
        <D.40161>:
        if (__result == 0) goto <D.40163>; else goto <D.40164>;
        <D.40163>:
        D.40165 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.40166 = *D.40165;
        D.40167 = (int) D.40166;
        D.40168 = __s2 + 2;
        D.40169 = *D.40168;
        D.40170 = (int) D.40169;
        __result = D.40167 - D.40170;
        if (__s2_len > 2) goto <D.40171>; else goto <D.40172>;
        <D.40171>:
        if (__result == 0) goto <D.40173>; else goto <D.40174>;
        <D.40173>:
        D.40175 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.40176 = *D.40175;
        D.40177 = (int) D.40176;
        D.40178 = __s2 + 3;
        D.40179 = *D.40178;
        D.40180 = (int) D.40179;
        __result = D.40177 - D.40180;
        <D.40174>:
        <D.40172>:
        <D.40164>:
        <D.40162>:
        <D.40154>:
        <D.40152>:
      }
      D.24366 = __result;
    }
    iftmp.636 = -D.24366;
    goto <D.40181>;
    <D.40145>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.636 = __builtin_strcmp (D.39998, "MonoGenericCMethod");
    <D.40181>:
    D.24367 = iftmp.636;
  }
  if (D.24367 == 0) goto <D.40060>; else goto <D.40182>;
  <D.40182>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40186 = "MonoGenericMethod";
      D.40187 = MEM[(const unsigned char *)D.40186];
      D.40188 = (int) D.40187;
      D.40189 = *__s2;
      D.40190 = (int) D.40189;
      __result = D.40188 - D.40190;
      {
        if (__s2_len != 0) goto <D.40191>; else goto <D.40192>;
        <D.40191>:
        if (__result == 0) goto <D.40193>; else goto <D.40194>;
        <D.40193>:
        D.40195 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.40196 = *D.40195;
        D.40197 = (int) D.40196;
        D.40198 = __s2 + 1;
        D.40199 = *D.40198;
        D.40200 = (int) D.40199;
        __result = D.40197 - D.40200;
        if (__s2_len > 1) goto <D.40201>; else goto <D.40202>;
        <D.40201>:
        if (__result == 0) goto <D.40203>; else goto <D.40204>;
        <D.40203>:
        D.40205 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.40206 = *D.40205;
        D.40207 = (int) D.40206;
        D.40208 = __s2 + 2;
        D.40209 = *D.40208;
        D.40210 = (int) D.40209;
        __result = D.40207 - D.40210;
        if (__s2_len > 2) goto <D.40211>; else goto <D.40212>;
        <D.40211>:
        if (__result == 0) goto <D.40213>; else goto <D.40214>;
        <D.40213>:
        D.40215 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.40216 = *D.40215;
        D.40217 = (int) D.40216;
        D.40218 = __s2 + 3;
        D.40219 = *D.40218;
        D.40220 = (int) D.40219;
        __result = D.40217 - D.40220;
        <D.40214>:
        <D.40212>:
        <D.40204>:
        <D.40202>:
        <D.40194>:
        <D.40192>:
      }
      D.24375 = __result;
    }
    iftmp.637 = -D.24375;
    goto <D.40221>;
    <D.40185>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.637 = __builtin_strcmp (D.39998, "MonoGenericMethod");
    <D.40221>:
    D.24376 = iftmp.637;
  }
  if (D.24376 == 0) goto <D.40060>; else goto <D.40061>;
  <D.40060>:
  result = MEM[(struct MonoReflectionMethod *)obj].method;
  if (context != 0B) goto <D.40222>; else goto <D.40223>;
  <D.40222>:
  result = mono_class_inflate_generic_method (result, context);
  <D.40223>:
  D.40224 = mono_defaults.methodhandle_class;
  *handle_class = D.40224;
  D.40002 = result == 0B;
  D.40003 = (long int) D.40002;
  D.40004 = __builtin_expect (D.40003, 0);
  if (D.40004 != 0) goto <D.40225>; else goto <D.40226>;
  <D.40225>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11775, "result");
  <D.40226>:
  goto <D.40062>;
  <D.40061>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40230 = "MethodBuilder";
      D.40231 = MEM[(const unsigned char *)D.40230];
      D.40232 = (int) D.40231;
      D.40233 = *__s2;
      D.40234 = (int) D.40233;
      __result = D.40232 - D.40234;
      {
        if (__s2_len != 0) goto <D.40235>; else goto <D.40236>;
        <D.40235>:
        if (__result == 0) goto <D.40237>; else goto <D.40238>;
        <D.40237>:
        D.40239 = &MEM[(void *)"MethodBuilder" + 1B];
        D.40240 = *D.40239;
        D.40241 = (int) D.40240;
        D.40242 = __s2 + 1;
        D.40243 = *D.40242;
        D.40244 = (int) D.40243;
        __result = D.40241 - D.40244;
        if (__s2_len > 1) goto <D.40245>; else goto <D.40246>;
        <D.40245>:
        if (__result == 0) goto <D.40247>; else goto <D.40248>;
        <D.40247>:
        D.40249 = &MEM[(void *)"MethodBuilder" + 2B];
        D.40250 = *D.40249;
        D.40251 = (int) D.40250;
        D.40252 = __s2 + 2;
        D.40253 = *D.40252;
        D.40254 = (int) D.40253;
        __result = D.40251 - D.40254;
        if (__s2_len > 2) goto <D.40255>; else goto <D.40256>;
        <D.40255>:
        if (__result == 0) goto <D.40257>; else goto <D.40258>;
        <D.40257>:
        D.40259 = &MEM[(void *)"MethodBuilder" + 3B];
        D.40260 = *D.40259;
        D.40261 = (int) D.40260;
        D.40262 = __s2 + 3;
        D.40263 = *D.40262;
        D.40264 = (int) D.40263;
        __result = D.40261 - D.40264;
        <D.40258>:
        <D.40256>:
        <D.40248>:
        <D.40246>:
        <D.40238>:
        <D.40236>:
      }
      D.24384 = __result;
    }
    iftmp.638 = -D.24384;
    goto <D.40265>;
    <D.40229>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.638 = __builtin_strcmp (D.39998, "MethodBuilder");
    <D.40265>:
    D.24385 = iftmp.638;
  }
  if (D.24385 == 0) goto <D.40266>; else goto <D.40267>;
  <D.40266>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    result = mb->mhandle;
    if (result == 0B) goto <D.40268>; else goto <D.40269>;
    <D.40268>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = mb->type;
      D.40270 = mono_domain_get ();
      mono_domain_try_type_resolve (D.40270, 0B, tb);
      result = mb->mhandle;
    }
    <D.40269>:
    if (context != 0B) goto <D.40271>; else goto <D.40272>;
    <D.40271>:
    result = mono_class_inflate_generic_method (result, context);
    <D.40272>:
    D.40224 = mono_defaults.methodhandle_class;
    *handle_class = D.40224;
  }
  goto <D.40273>;
  <D.40267>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40277 = "ConstructorBuilder";
      D.40278 = MEM[(const unsigned char *)D.40277];
      D.40279 = (int) D.40278;
      D.40280 = *__s2;
      D.40281 = (int) D.40280;
      __result = D.40279 - D.40281;
      {
        if (__s2_len != 0) goto <D.40282>; else goto <D.40283>;
        <D.40282>:
        if (__result == 0) goto <D.40284>; else goto <D.40285>;
        <D.40284>:
        D.40286 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.40287 = *D.40286;
        D.40288 = (int) D.40287;
        D.40289 = __s2 + 1;
        D.40290 = *D.40289;
        D.40291 = (int) D.40290;
        __result = D.40288 - D.40291;
        if (__s2_len > 1) goto <D.40292>; else goto <D.40293>;
        <D.40292>:
        if (__result == 0) goto <D.40294>; else goto <D.40295>;
        <D.40294>:
        D.40296 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.40297 = *D.40296;
        D.40298 = (int) D.40297;
        D.40299 = __s2 + 2;
        D.40300 = *D.40299;
        D.40301 = (int) D.40300;
        __result = D.40298 - D.40301;
        if (__s2_len > 2) goto <D.40302>; else goto <D.40303>;
        <D.40302>:
        if (__result == 0) goto <D.40304>; else goto <D.40305>;
        <D.40304>:
        D.40306 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.40307 = *D.40306;
        D.40308 = (int) D.40307;
        D.40309 = __s2 + 3;
        D.40310 = *D.40309;
        D.40311 = (int) D.40310;
        __result = D.40308 - D.40311;
        <D.40305>:
        <D.40303>:
        <D.40295>:
        <D.40293>:
        <D.40285>:
        <D.40283>:
      }
      D.24395 = __result;
    }
    iftmp.639 = -D.24395;
    goto <D.40312>;
    <D.40276>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.639 = __builtin_strcmp (D.39998, "ConstructorBuilder");
    <D.40312>:
    D.24396 = iftmp.639;
  }
  if (D.24396 == 0) goto <D.40313>; else goto <D.40314>;
  <D.40313>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    result = cb->mhandle;
    if (result == 0B) goto <D.40315>; else goto <D.40316>;
    <D.40315>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = cb->type;
      D.40317 = mono_domain_get ();
      mono_domain_try_type_resolve (D.40317, 0B, tb);
      result = cb->mhandle;
    }
    <D.40316>:
    if (context != 0B) goto <D.40318>; else goto <D.40319>;
    <D.40318>:
    result = mono_class_inflate_generic_method (result, context);
    <D.40319>:
    D.40224 = mono_defaults.methodhandle_class;
    *handle_class = D.40224;
  }
  goto <D.40320>;
  <D.40314>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40324 = "MonoField";
      D.40325 = MEM[(const unsigned char *)D.40324];
      D.40326 = (int) D.40325;
      D.40327 = *__s2;
      D.40328 = (int) D.40327;
      __result = D.40326 - D.40328;
      {
        if (__s2_len != 0) goto <D.40329>; else goto <D.40330>;
        <D.40329>:
        if (__result == 0) goto <D.40331>; else goto <D.40332>;
        <D.40331>:
        D.40333 = &MEM[(void *)"MonoField" + 1B];
        D.40334 = *D.40333;
        D.40335 = (int) D.40334;
        D.40336 = __s2 + 1;
        D.40337 = *D.40336;
        D.40338 = (int) D.40337;
        __result = D.40335 - D.40338;
        if (__s2_len > 1) goto <D.40339>; else goto <D.40340>;
        <D.40339>:
        if (__result == 0) goto <D.40341>; else goto <D.40342>;
        <D.40341>:
        D.40343 = &MEM[(void *)"MonoField" + 2B];
        D.40344 = *D.40343;
        D.40345 = (int) D.40344;
        D.40346 = __s2 + 2;
        D.40347 = *D.40346;
        D.40348 = (int) D.40347;
        __result = D.40345 - D.40348;
        if (__s2_len > 2) goto <D.40349>; else goto <D.40350>;
        <D.40349>:
        if (__result == 0) goto <D.40351>; else goto <D.40352>;
        <D.40351>:
        D.40353 = &MEM[(void *)"MonoField" + 3B];
        D.40354 = *D.40353;
        D.40355 = (int) D.40354;
        D.40356 = __s2 + 3;
        D.40357 = *D.40356;
        D.40358 = (int) D.40357;
        __result = D.40355 - D.40358;
        <D.40352>:
        <D.40350>:
        <D.40342>:
        <D.40340>:
        <D.40332>:
        <D.40330>:
      }
      D.24406 = __result;
    }
    iftmp.640 = -D.24406;
    goto <D.40359>;
    <D.40323>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.640 = __builtin_strcmp (D.39998, "MonoField");
    <D.40359>:
    D.24407 = iftmp.640;
  }
  if (D.24407 == 0) goto <D.40360>; else goto <D.40361>;
  <D.40360>:
  {
    struct MonoClassField * field;

    field = MEM[(struct MonoReflectionField *)obj].field;
    D.40362 = field->parent;
    ensure_complete_type (D.40362);
    if (context != 0B) goto <D.40363>; else goto <D.40364>;
    <D.40363>:
    {
      struct MonoType * inflated;
      struct MonoClass * class;
      struct MonoClassField * inflated_field;
      void * iter;

      try
        {
          D.40362 = field->parent;
          D.40365 = &D.40362->byval_arg;
          inflated = mono_class_inflate_generic_type (D.40365, context);
          class = mono_class_from_mono_type (inflated);
          iter = 0B;
          mono_metadata_free_type (inflated);
          goto <D.24424>;
          <D.24423>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.40366 = field->name;
            D.40367 = inflated_field->name;
            D.24421 = __builtin_strcmp (D.40366, D.40367);
          }
          if (D.24421 == 0) goto <D.24422>; else goto <D.40368>;
          <D.40368>:
          <D.24424>:
          inflated_field = mono_class_get_fields (class, &iter);
          if (inflated_field != 0B) goto <D.24423>; else goto <D.24422>;
          <D.24422>:
          if (inflated_field == 0B) goto <D.40370>; else goto <D.40373>;
          <D.40373>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.40366 = field->name;
            D.40367 = inflated_field->name;
            D.24433 = __builtin_strcmp (D.40366, D.40367);
          }
          if (D.24433 != 0) goto <D.40370>; else goto <D.40371>;
          <D.40370>:
          iftmp.641 = 1;
          goto <D.40372>;
          <D.40371>:
          iftmp.641 = 0;
          <D.40372>:
          D.40374 = iftmp.641 != 0;
          D.40375 = (long int) D.40374;
          D.40376 = __builtin_expect (D.40375, 0);
          if (D.40376 != 0) goto <D.40377>; else goto <D.40378>;
          <D.40377>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11825, "inflated_field && !strcmp (field->name, inflated_field->name)");
          <D.40378>:
          result = inflated_field;
        }
      finally
        {
          iter = {CLOBBER};
        }
    }
    goto <D.40379>;
    <D.40364>:
    result = field;
    <D.40379>:
    D.40380 = mono_defaults.fieldhandle_class;
    *handle_class = D.40380;
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40381>; else goto <D.40382>;
    <D.40381>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11831, "result");
    <D.40382>:
  }
  goto <D.40383>;
  <D.40361>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40387 = "FieldBuilder";
      D.40388 = MEM[(const unsigned char *)D.40387];
      D.40389 = (int) D.40388;
      D.40390 = *__s2;
      D.40391 = (int) D.40390;
      __result = D.40389 - D.40391;
      {
        if (__s2_len != 0) goto <D.40392>; else goto <D.40393>;
        <D.40392>:
        if (__result == 0) goto <D.40394>; else goto <D.40395>;
        <D.40394>:
        D.40396 = &MEM[(void *)"FieldBuilder" + 1B];
        D.40397 = *D.40396;
        D.40398 = (int) D.40397;
        D.40399 = __s2 + 1;
        D.40400 = *D.40399;
        D.40401 = (int) D.40400;
        __result = D.40398 - D.40401;
        if (__s2_len > 1) goto <D.40402>; else goto <D.40403>;
        <D.40402>:
        if (__result == 0) goto <D.40404>; else goto <D.40405>;
        <D.40404>:
        D.40406 = &MEM[(void *)"FieldBuilder" + 2B];
        D.40407 = *D.40406;
        D.40408 = (int) D.40407;
        D.40409 = __s2 + 2;
        D.40410 = *D.40409;
        D.40411 = (int) D.40410;
        __result = D.40408 - D.40411;
        if (__s2_len > 2) goto <D.40412>; else goto <D.40413>;
        <D.40412>:
        if (__result == 0) goto <D.40414>; else goto <D.40415>;
        <D.40414>:
        D.40416 = &MEM[(void *)"FieldBuilder" + 3B];
        D.40417 = *D.40416;
        D.40418 = (int) D.40417;
        D.40419 = __s2 + 3;
        D.40420 = *D.40419;
        D.40421 = (int) D.40420;
        __result = D.40418 - D.40421;
        <D.40415>:
        <D.40413>:
        <D.40405>:
        <D.40403>:
        <D.40395>:
        <D.40393>:
      }
      D.24441 = __result;
    }
    iftmp.642 = -D.24441;
    goto <D.40422>;
    <D.40386>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.642 = __builtin_strcmp (D.39998, "FieldBuilder");
    <D.40422>:
    D.24442 = iftmp.642;
  }
  if (D.24442 == 0) goto <D.40423>; else goto <D.40424>;
  <D.40423>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    result = fb->handle;
    if (result == 0B) goto <D.40425>; else goto <D.40426>;
    <D.40425>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = fb->typeb;
      D.40427 = mono_domain_get ();
      mono_domain_try_type_resolve (D.40427, 0B, tb);
      result = fb->handle;
    }
    <D.40426>:
    D.40428 = fb->handle;
    if (D.40428 != 0B) goto <D.40429>; else goto <D.40430>;
    <D.40429>:
    D.40428 = fb->handle;
    D.40431 = D.40428->parent;
    D.40432 = D.40431->generic_container;
    if (D.40432 != 0B) goto <D.40433>; else goto <D.40434>;
    <D.40433>:
    {
      struct MonoClass * klass;
      struct MonoType * type;
      struct MonoClass * inflated;

      D.40428 = fb->handle;
      klass = D.40428->parent;
      D.40435 = &klass->byval_arg;
      type = mono_class_inflate_generic_type (D.40435, context);
      inflated = mono_class_from_mono_type (type);
      D.40428 = fb->handle;
      D.40436 = mono_field_get_name (D.40428);
      result = mono_class_get_field_from_name (inflated, D.40436);
      D.40002 = result == 0B;
      D.40003 = (long int) D.40002;
      D.40004 = __builtin_expect (D.40003, 0);
      if (D.40004 != 0) goto <D.40437>; else goto <D.40438>;
      <D.40437>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11849, "result");
      <D.40438>:
      mono_metadata_free_type (type);
    }
    <D.40434>:
    <D.40430>:
    D.40380 = mono_defaults.fieldhandle_class;
    *handle_class = D.40380;
  }
  goto <D.40439>;
  <D.40424>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40443 = "TypeBuilder";
      D.40444 = MEM[(const unsigned char *)D.40443];
      D.40445 = (int) D.40444;
      D.40446 = *__s2;
      D.40447 = (int) D.40446;
      __result = D.40445 - D.40447;
      {
        if (__s2_len != 0) goto <D.40448>; else goto <D.40449>;
        <D.40448>:
        if (__result == 0) goto <D.40450>; else goto <D.40451>;
        <D.40450>:
        D.40452 = &MEM[(void *)"TypeBuilder" + 1B];
        D.40453 = *D.40452;
        D.40454 = (int) D.40453;
        D.40455 = __s2 + 1;
        D.40456 = *D.40455;
        D.40457 = (int) D.40456;
        __result = D.40454 - D.40457;
        if (__s2_len > 1) goto <D.40458>; else goto <D.40459>;
        <D.40458>:
        if (__result == 0) goto <D.40460>; else goto <D.40461>;
        <D.40460>:
        D.40462 = &MEM[(void *)"TypeBuilder" + 2B];
        D.40463 = *D.40462;
        D.40464 = (int) D.40463;
        D.40465 = __s2 + 2;
        D.40466 = *D.40465;
        D.40467 = (int) D.40466;
        __result = D.40464 - D.40467;
        if (__s2_len > 2) goto <D.40468>; else goto <D.40469>;
        <D.40468>:
        if (__result == 0) goto <D.40470>; else goto <D.40471>;
        <D.40470>:
        D.40472 = &MEM[(void *)"TypeBuilder" + 3B];
        D.40473 = *D.40472;
        D.40474 = (int) D.40473;
        D.40475 = __s2 + 3;
        D.40476 = *D.40475;
        D.40477 = (int) D.40476;
        __result = D.40474 - D.40477;
        <D.40471>:
        <D.40469>:
        <D.40461>:
        <D.40459>:
        <D.40451>:
        <D.40449>:
      }
      D.24455 = __result;
    }
    iftmp.643 = -D.24455;
    goto <D.40478>;
    <D.40442>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.643 = __builtin_strcmp (D.39998, "TypeBuilder");
    <D.40478>:
    D.24456 = iftmp.643;
  }
  if (D.24456 == 0) goto <D.40479>; else goto <D.40480>;
  <D.40479>:
  {
    struct MonoReflectionTypeBuilder * tb;
    struct MonoType * type;
    struct MonoClass * klass;

    tb = obj;
    type = mono_reflection_type_get_handle (tb);
    klass = type->data.klass;
    D.40481 = BIT_FIELD_REF <*klass, 64, 256>;
    D.40482 = D.40481 & 128;
    if (D.40482 != 0) goto <D.40483>; else goto <D.40484>;
    <D.40483>:
    result = klass;
    goto <D.40485>;
    <D.40484>:
    D.40486 = mono_domain_get ();
    mono_domain_try_type_resolve (D.40486, 0B, tb);
    result = type->data.klass;
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40487>; else goto <D.40488>;
    <D.40487>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11866, "result");
    <D.40488>:
    <D.40485>:
    D.40056 = mono_defaults.typehandle_class;
    *handle_class = D.40056;
  }
  goto <D.40489>;
  <D.40480>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40493 = "SignatureHelper";
      D.40494 = MEM[(const unsigned char *)D.40493];
      D.40495 = (int) D.40494;
      D.40496 = *__s2;
      D.40497 = (int) D.40496;
      __result = D.40495 - D.40497;
      {
        if (__s2_len != 0) goto <D.40498>; else goto <D.40499>;
        <D.40498>:
        if (__result == 0) goto <D.40500>; else goto <D.40501>;
        <D.40500>:
        D.40502 = &MEM[(void *)"SignatureHelper" + 1B];
        D.40503 = *D.40502;
        D.40504 = (int) D.40503;
        D.40505 = __s2 + 1;
        D.40506 = *D.40505;
        D.40507 = (int) D.40506;
        __result = D.40504 - D.40507;
        if (__s2_len > 1) goto <D.40508>; else goto <D.40509>;
        <D.40508>:
        if (__result == 0) goto <D.40510>; else goto <D.40511>;
        <D.40510>:
        D.40512 = &MEM[(void *)"SignatureHelper" + 2B];
        D.40513 = *D.40512;
        D.40514 = (int) D.40513;
        D.40515 = __s2 + 2;
        D.40516 = *D.40515;
        D.40517 = (int) D.40516;
        __result = D.40514 - D.40517;
        if (__s2_len > 2) goto <D.40518>; else goto <D.40519>;
        <D.40518>:
        if (__result == 0) goto <D.40520>; else goto <D.40521>;
        <D.40520>:
        D.40522 = &MEM[(void *)"SignatureHelper" + 3B];
        D.40523 = *D.40522;
        D.40524 = (int) D.40523;
        D.40525 = __s2 + 3;
        D.40526 = *D.40525;
        D.40527 = (int) D.40526;
        __result = D.40524 - D.40527;
        <D.40521>:
        <D.40519>:
        <D.40511>:
        <D.40509>:
        <D.40501>:
        <D.40499>:
      }
      D.24467 = __result;
    }
    iftmp.644 = -D.24467;
    goto <D.40528>;
    <D.40492>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.644 = __builtin_strcmp (D.39998, "SignatureHelper");
    <D.40528>:
    D.24468 = iftmp.644;
  }
  if (D.24468 == 0) goto <D.40529>; else goto <D.40530>;
  <D.40529>:
  {
    struct MonoReflectionSigHelper * helper;
    struct MonoMethodSignature * sig;
    int nargs;
    int i;

    helper = obj;
    D.40531 = helper->arguments;
    if (D.40531 != 0B) goto <D.40532>; else goto <D.40533>;
    <D.40532>:
    D.40531 = helper->arguments;
    D.40534 = mono_array_length (D.40531);
    nargs = (int) D.40534;
    goto <D.40535>;
    <D.40533>:
    nargs = 0;
    <D.40535>:
    nargs.645 = (unsigned int) nargs;
    sig = mono_metadata_signature_alloc (image, nargs.645);
    D.40537 = helper->call_conv;
    D.40538 = D.40537 & 64;
    D.40539 = D.40538 != 0;
    sig->explicit_this = D.40539;
    D.40537 = helper->call_conv;
    D.40540 = D.40537 & 32;
    D.40541 = D.40540 != 0;
    sig->hasthis = D.40541;
    D.40542 = helper->unmanaged_call_conv;
    if (D.40542 != 0) goto <D.40543>; else goto <D.40544>;
    <D.40543>:
    D.40542 = helper->unmanaged_call_conv;
    D.40545 = (unsigned char) D.40542;
    D.40546 = D.40545 + 255;
    D.40547 = (<unnamed-unsigned:6>) D.40546;
    sig->call_convention = D.40547;
    sig->pinvoke = 1;
    goto <D.40548>;
    <D.40544>:
    D.40537 = helper->call_conv;
    D.40549 = D.40537 & 2;
    if (D.40549 != 0) goto <D.40550>; else goto <D.40551>;
    <D.40550>:
    sig->call_convention = 5;
    goto <D.40552>;
    <D.40551>:
    sig->call_convention = 0;
    <D.40552>:
    <D.40548>:
    D.40553 = (short unsigned int) nargs;
    sig->param_count = D.40553;
    D.40554 = helper->return_type;
    D.40555 = D.40554->type;
    sig->ret = D.40555;
    i = 0;
    goto <D.24474>;
    <D.24473>:
    D.40531 = helper->arguments;
    D.40556 = (long unsigned int) i;
    D.40557 = mono_array_addr_with_size (D.40531, 8, D.40556);
    D.40558 = MEM[(void * *)D.40557];
    D.40559 = mono_reflection_type_get_handle (D.40558);
    sig->params[i] = D.40559;
    i = i + 1;
    <D.24474>:
    if (i < nargs) goto <D.24473>; else goto <D.24475>;
    <D.24475>:
    result = sig;
    *handle_class = 0B;
  }
  goto <D.40560>;
  <D.40530>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40564 = "DynamicMethod";
      D.40565 = MEM[(const unsigned char *)D.40564];
      D.40566 = (int) D.40565;
      D.40567 = *__s2;
      D.40568 = (int) D.40567;
      __result = D.40566 - D.40568;
      {
        if (__s2_len != 0) goto <D.40569>; else goto <D.40570>;
        <D.40569>:
        if (__result == 0) goto <D.40571>; else goto <D.40572>;
        <D.40571>:
        D.40573 = &MEM[(void *)"DynamicMethod" + 1B];
        D.40574 = *D.40573;
        D.40575 = (int) D.40574;
        D.40576 = __s2 + 1;
        D.40577 = *D.40576;
        D.40578 = (int) D.40577;
        __result = D.40575 - D.40578;
        if (__s2_len > 1) goto <D.40579>; else goto <D.40580>;
        <D.40579>:
        if (__result == 0) goto <D.40581>; else goto <D.40582>;
        <D.40581>:
        D.40583 = &MEM[(void *)"DynamicMethod" + 2B];
        D.40584 = *D.40583;
        D.40585 = (int) D.40584;
        D.40586 = __s2 + 2;
        D.40587 = *D.40586;
        D.40588 = (int) D.40587;
        __result = D.40585 - D.40588;
        if (__s2_len > 2) goto <D.40589>; else goto <D.40590>;
        <D.40589>:
        if (__result == 0) goto <D.40591>; else goto <D.40592>;
        <D.40591>:
        D.40593 = &MEM[(void *)"DynamicMethod" + 3B];
        D.40594 = *D.40593;
        D.40595 = (int) D.40594;
        D.40596 = __s2 + 3;
        D.40597 = *D.40596;
        D.40598 = (int) D.40597;
        __result = D.40595 - D.40598;
        <D.40592>:
        <D.40590>:
        <D.40582>:
        <D.40580>:
        <D.40572>:
        <D.40570>:
      }
      D.24483 = __result;
    }
    iftmp.646 = -D.24483;
    goto <D.40599>;
    <D.40563>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.646 = __builtin_strcmp (D.39998, "DynamicMethod");
    <D.40599>:
    D.24484 = iftmp.646;
  }
  if (D.24484 == 0) goto <D.40600>; else goto <D.40601>;
  <D.40600>:
  {
    struct MonoReflectionDynamicMethod * method;

    method = obj;
    D.40602 = method->mhandle;
    D.40603 = D.40602 == 0B;
    D.40604 = (long int) D.40603;
    D.40605 = __builtin_expect (D.40604, 0);
    if (D.40605 != 0) goto <D.40606>; else goto <D.40607>;
    <D.40606>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11903, "method->mhandle");
    <D.40607>:
    result = method->mhandle;
    D.40224 = mono_defaults.methodhandle_class;
    *handle_class = D.40224;
  }
  goto <D.40608>;
  <D.40601>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40612 = "GenericTypeParameterBuilder";
      D.40613 = MEM[(const unsigned char *)D.40612];
      D.40614 = (int) D.40613;
      D.40615 = *__s2;
      D.40616 = (int) D.40615;
      __result = D.40614 - D.40616;
      {
        if (__s2_len != 0) goto <D.40617>; else goto <D.40618>;
        <D.40617>:
        if (__result == 0) goto <D.40619>; else goto <D.40620>;
        <D.40619>:
        D.40621 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.40622 = *D.40621;
        D.40623 = (int) D.40622;
        D.40624 = __s2 + 1;
        D.40625 = *D.40624;
        D.40626 = (int) D.40625;
        __result = D.40623 - D.40626;
        if (__s2_len > 1) goto <D.40627>; else goto <D.40628>;
        <D.40627>:
        if (__result == 0) goto <D.40629>; else goto <D.40630>;
        <D.40629>:
        D.40631 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.40632 = *D.40631;
        D.40633 = (int) D.40632;
        D.40634 = __s2 + 2;
        D.40635 = *D.40634;
        D.40636 = (int) D.40635;
        __result = D.40633 - D.40636;
        if (__s2_len > 2) goto <D.40637>; else goto <D.40638>;
        <D.40637>:
        if (__result == 0) goto <D.40639>; else goto <D.40640>;
        <D.40639>:
        D.40641 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.40642 = *D.40641;
        D.40643 = (int) D.40642;
        D.40644 = __s2 + 3;
        D.40645 = *D.40644;
        D.40646 = (int) D.40645;
        __result = D.40643 - D.40646;
        <D.40640>:
        <D.40638>:
        <D.40630>:
        <D.40628>:
        <D.40620>:
        <D.40618>:
      }
      D.24493 = __result;
    }
    iftmp.647 = -D.24493;
    goto <D.40647>;
    <D.40611>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.647 = __builtin_strcmp (D.39998, "GenericTypeParameterBuilder");
    <D.40647>:
    D.24494 = iftmp.647;
  }
  if (D.24494 == 0) goto <D.40648>; else goto <D.40649>;
  <D.40648>:
  {
    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.40056 = mono_defaults.typehandle_class;
    *handle_class = D.40056;
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40650>; else goto <D.40651>;
    <D.40650>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11911, "result");
    <D.40651>:
    mono_metadata_free_type (type);
  }
  goto <D.40652>;
  <D.40649>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40656 = "MonoGenericClass";
      D.40657 = MEM[(const unsigned char *)D.40656];
      D.40658 = (int) D.40657;
      D.40659 = *__s2;
      D.40660 = (int) D.40659;
      __result = D.40658 - D.40660;
      {
        if (__s2_len != 0) goto <D.40661>; else goto <D.40662>;
        <D.40661>:
        if (__result == 0) goto <D.40663>; else goto <D.40664>;
        <D.40663>:
        D.40665 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.40666 = *D.40665;
        D.40667 = (int) D.40666;
        D.40668 = __s2 + 1;
        D.40669 = *D.40668;
        D.40670 = (int) D.40669;
        __result = D.40667 - D.40670;
        if (__s2_len > 1) goto <D.40671>; else goto <D.40672>;
        <D.40671>:
        if (__result == 0) goto <D.40673>; else goto <D.40674>;
        <D.40673>:
        D.40675 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.40676 = *D.40675;
        D.40677 = (int) D.40676;
        D.40678 = __s2 + 2;
        D.40679 = *D.40678;
        D.40680 = (int) D.40679;
        __result = D.40677 - D.40680;
        if (__s2_len > 2) goto <D.40681>; else goto <D.40682>;
        <D.40681>:
        if (__result == 0) goto <D.40683>; else goto <D.40684>;
        <D.40683>:
        D.40685 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.40686 = *D.40685;
        D.40687 = (int) D.40686;
        D.40688 = __s2 + 3;
        D.40689 = *D.40688;
        D.40690 = (int) D.40689;
        __result = D.40687 - D.40690;
        <D.40684>:
        <D.40682>:
        <D.40674>:
        <D.40672>:
        <D.40664>:
        <D.40662>:
      }
      D.24503 = __result;
    }
    iftmp.648 = -D.24503;
    goto <D.40691>;
    <D.40655>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.648 = __builtin_strcmp (D.39998, "MonoGenericClass");
    <D.40691>:
    D.24504 = iftmp.648;
  }
  if (D.24504 == 0) goto <D.40692>; else goto <D.40693>;
  <D.40692>:
  {
    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.40056 = mono_defaults.typehandle_class;
    *handle_class = D.40056;
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40694>; else goto <D.40695>;
    <D.40694>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11918, "result");
    <D.40695>:
    mono_metadata_free_type (type);
  }
  goto <D.40696>;
  <D.40693>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40700 = "FieldOnTypeBuilderInst";
      D.40701 = MEM[(const unsigned char *)D.40700];
      D.40702 = (int) D.40701;
      D.40703 = *__s2;
      D.40704 = (int) D.40703;
      __result = D.40702 - D.40704;
      {
        if (__s2_len != 0) goto <D.40705>; else goto <D.40706>;
        <D.40705>:
        if (__result == 0) goto <D.40707>; else goto <D.40708>;
        <D.40707>:
        D.40709 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.40710 = *D.40709;
        D.40711 = (int) D.40710;
        D.40712 = __s2 + 1;
        D.40713 = *D.40712;
        D.40714 = (int) D.40713;
        __result = D.40711 - D.40714;
        if (__s2_len > 1) goto <D.40715>; else goto <D.40716>;
        <D.40715>:
        if (__result == 0) goto <D.40717>; else goto <D.40718>;
        <D.40717>:
        D.40719 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.40720 = *D.40719;
        D.40721 = (int) D.40720;
        D.40722 = __s2 + 2;
        D.40723 = *D.40722;
        D.40724 = (int) D.40723;
        __result = D.40721 - D.40724;
        if (__s2_len > 2) goto <D.40725>; else goto <D.40726>;
        <D.40725>:
        if (__result == 0) goto <D.40727>; else goto <D.40728>;
        <D.40727>:
        D.40729 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.40730 = *D.40729;
        D.40731 = (int) D.40730;
        D.40732 = __s2 + 3;
        D.40733 = *D.40732;
        D.40734 = (int) D.40733;
        __result = D.40731 - D.40734;
        <D.40728>:
        <D.40726>:
        <D.40718>:
        <D.40716>:
        <D.40708>:
        <D.40706>:
      }
      D.24513 = __result;
    }
    iftmp.649 = -D.24513;
    goto <D.40735>;
    <D.40699>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.649 = __builtin_strcmp (D.39998, "FieldOnTypeBuilderInst");
    <D.40735>:
    D.24514 = iftmp.649;
  }
  if (D.24514 == 0) goto <D.40736>; else goto <D.40737>;
  <D.40736>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;
    struct MonoClass * inflated;
    struct MonoType * type;
    struct MonoClassField * field;

    f = obj;
    D.40738 = f->fb;
    D.40739 = D.40738->vtable;
    D.40740 = D.40739->klass;
    D.40741 = is_sre_field_builder (D.40740);
    if (D.40741 != 0) goto <D.40742>; else goto <D.40743>;
    <D.40742>:
    D.40738 = f->fb;
    field = MEM[(struct MonoReflectionFieldBuilder *)D.40738].handle;
    goto <D.40744>;
    <D.40743>:
    D.40738 = f->fb;
    D.40739 = D.40738->vtable;
    D.40740 = D.40739->klass;
    D.40745 = is_sr_mono_field (D.40740);
    if (D.40745 != 0) goto <D.40746>; else goto <D.40747>;
    <D.40746>:
    D.40738 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.40738].field;
    goto <D.40748>;
    <D.40747>:
    D.40738 = f->fb;
    D.40739 = D.40738->vtable;
    D.40740 = D.40739->klass;
    D.40749 = mono_type_get_full_name (D.40740);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a FTBI with base_method of type %s", D.40749);
    <D.24519>:
    goto <D.24519>;
    <D.40748>:
    <D.40744>:
    D.40750 = f->inst;
    D.40751 = mono_reflection_type_get_handle (D.40750);
    type = mono_class_inflate_generic_type (D.40751, context);
    inflated = mono_class_from_mono_type (type);
    D.40752 = mono_field_get_name (field);
    field = mono_class_get_field_from_name (inflated, D.40752);
    result = field;
    D.40753 = field->parent;
    ensure_complete_type (D.40753);
    D.40002 = result == 0B;
    D.40003 = (long int) D.40002;
    D.40004 = __builtin_expect (D.40003, 0);
    if (D.40004 != 0) goto <D.40754>; else goto <D.40755>;
    <D.40754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11938, "result");
    <D.40755>:
    mono_metadata_free_type (type);
    D.40380 = mono_defaults.fieldhandle_class;
    *handle_class = D.40380;
  }
  goto <D.40756>;
  <D.40737>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40760 = "ConstructorOnTypeBuilderInst";
      D.40761 = MEM[(const unsigned char *)D.40760];
      D.40762 = (int) D.40761;
      D.40763 = *__s2;
      D.40764 = (int) D.40763;
      __result = D.40762 - D.40764;
      {
        if (__s2_len != 0) goto <D.40765>; else goto <D.40766>;
        <D.40765>:
        if (__result == 0) goto <D.40767>; else goto <D.40768>;
        <D.40767>:
        D.40769 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.40770 = *D.40769;
        D.40771 = (int) D.40770;
        D.40772 = __s2 + 1;
        D.40773 = *D.40772;
        D.40774 = (int) D.40773;
        __result = D.40771 - D.40774;
        if (__s2_len > 1) goto <D.40775>; else goto <D.40776>;
        <D.40775>:
        if (__result == 0) goto <D.40777>; else goto <D.40778>;
        <D.40777>:
        D.40779 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.40780 = *D.40779;
        D.40781 = (int) D.40780;
        D.40782 = __s2 + 2;
        D.40783 = *D.40782;
        D.40784 = (int) D.40783;
        __result = D.40781 - D.40784;
        if (__s2_len > 2) goto <D.40785>; else goto <D.40786>;
        <D.40785>:
        if (__result == 0) goto <D.40787>; else goto <D.40788>;
        <D.40787>:
        D.40789 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.40790 = *D.40789;
        D.40791 = (int) D.40790;
        D.40792 = __s2 + 3;
        D.40793 = *D.40792;
        D.40794 = (int) D.40793;
        __result = D.40791 - D.40794;
        <D.40788>:
        <D.40786>:
        <D.40778>:
        <D.40776>:
        <D.40768>:
        <D.40766>:
      }
      D.24527 = __result;
    }
    iftmp.650 = -D.24527;
    goto <D.40795>;
    <D.40759>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.650 = __builtin_strcmp (D.39998, "ConstructorOnTypeBuilderInst");
    <D.40795>:
    D.24528 = iftmp.650;
  }
  if (D.24528 == 0) goto <D.40796>; else goto <D.40797>;
  <D.40796>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;
    struct MonoType * type;
    struct MonoClass * inflated_klass;
    struct MonoMethod * method;

    c = obj;
    D.40798 = c->inst;
    D.40799 = mono_reflection_type_get_handle (D.40798);
    type = mono_class_inflate_generic_type (D.40799, context);
    inflated_klass = mono_class_from_mono_type (type);
    D.40800 = c->cb;
    D.40801 = D.40800->vtable;
    D.40802 = D.40801->klass;
    D.40803 = is_sre_ctor_builder (D.40802);
    if (D.40803 != 0) goto <D.40804>; else goto <D.40805>;
    <D.40804>:
    D.40800 = c->cb;
    method = MEM[(struct MonoReflectionCtorBuilder *)D.40800].mhandle;
    goto <D.40806>;
    <D.40805>:
    D.40800 = c->cb;
    D.40801 = D.40800->vtable;
    D.40802 = D.40801->klass;
    D.40807 = is_sr_mono_cmethod (D.40802);
    if (D.40807 != 0) goto <D.40808>; else goto <D.40809>;
    <D.40808>:
    D.40800 = c->cb;
    method = MEM[(struct MonoReflectionMethod *)D.40800].method;
    goto <D.40810>;
    <D.40809>:
    D.40800 = c->cb;
    D.40801 = D.40800->vtable;
    D.40802 = D.40801->klass;
    D.40811 = mono_type_get_full_name (D.40802);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a CTBI with base_method of type %s", D.40811);
    <D.24533>:
    goto <D.24533>;
    <D.40810>:
    <D.40806>:
    D.40800 = c->cb;
    result = inflate_mono_method (inflated_klass, method, D.40800);
    D.40224 = mono_defaults.methodhandle_class;
    *handle_class = D.40224;
    mono_metadata_free_type (type);
  }
  goto <D.40812>;
  <D.40797>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40816 = "MethodOnTypeBuilderInst";
      D.40817 = MEM[(const unsigned char *)D.40816];
      D.40818 = (int) D.40817;
      D.40819 = *__s2;
      D.40820 = (int) D.40819;
      __result = D.40818 - D.40820;
      {
        if (__s2_len != 0) goto <D.40821>; else goto <D.40822>;
        <D.40821>:
        if (__result == 0) goto <D.40823>; else goto <D.40824>;
        <D.40823>:
        D.40825 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.40826 = *D.40825;
        D.40827 = (int) D.40826;
        D.40828 = __s2 + 1;
        D.40829 = *D.40828;
        D.40830 = (int) D.40829;
        __result = D.40827 - D.40830;
        if (__s2_len > 1) goto <D.40831>; else goto <D.40832>;
        <D.40831>:
        if (__result == 0) goto <D.40833>; else goto <D.40834>;
        <D.40833>:
        D.40835 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.40836 = *D.40835;
        D.40837 = (int) D.40836;
        D.40838 = __s2 + 2;
        D.40839 = *D.40838;
        D.40840 = (int) D.40839;
        __result = D.40837 - D.40840;
        if (__s2_len > 2) goto <D.40841>; else goto <D.40842>;
        <D.40841>:
        if (__result == 0) goto <D.40843>; else goto <D.40844>;
        <D.40843>:
        D.40845 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.40846 = *D.40845;
        D.40847 = (int) D.40846;
        D.40848 = __s2 + 3;
        D.40849 = *D.40848;
        D.40850 = (int) D.40849;
        __result = D.40847 - D.40850;
        <D.40844>:
        <D.40842>:
        <D.40834>:
        <D.40832>:
        <D.40824>:
        <D.40822>:
      }
      D.24541 = __result;
    }
    iftmp.651 = -D.24541;
    goto <D.40851>;
    <D.40815>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.651 = __builtin_strcmp (D.39998, "MethodOnTypeBuilderInst");
    <D.40851>:
    D.24542 = iftmp.651;
  }
  if (D.24542 == 0) goto <D.40852>; else goto <D.40853>;
  <D.40852>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    D.40854 = m->method_args;
    if (D.40854 != 0B) goto <D.40855>; else goto <D.40856>;
    <D.40855>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    if (context != 0B) goto <D.40857>; else goto <D.40858>;
    <D.40857>:
    result = mono_class_inflate_generic_method (result, context);
    <D.40858>:
    goto <D.40859>;
    <D.40856>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * method;

      D.40860 = m->inst;
      D.40861 = mono_reflection_type_get_handle (D.40860);
      type = mono_class_inflate_generic_type (D.40861, context);
      inflated_klass = mono_class_from_mono_type (type);
      D.40862 = m->mb;
      D.40863 = D.40862->vtable;
      D.40864 = D.40863->klass;
      D.40865 = is_sre_method_builder (D.40864);
      if (D.40865 != 0) goto <D.40866>; else goto <D.40867>;
      <D.40866>:
      D.40862 = m->mb;
      method = MEM[(struct MonoReflectionMethodBuilder *)D.40862].mhandle;
      goto <D.40868>;
      <D.40867>:
      D.40862 = m->mb;
      D.40863 = D.40862->vtable;
      D.40864 = D.40863->klass;
      D.40869 = is_sr_mono_method (D.40864);
      if (D.40869 != 0) goto <D.40870>; else goto <D.40871>;
      <D.40870>:
      D.40862 = m->mb;
      method = MEM[(struct MonoReflectionMethod *)D.40862].method;
      goto <D.40872>;
      <D.40871>:
      D.40862 = m->mb;
      D.40863 = D.40862->vtable;
      D.40864 = D.40863->klass;
      D.40873 = mono_type_get_full_name (D.40864);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.40873);
      <D.24547>:
      goto <D.24547>;
      <D.40872>:
      <D.40868>:
      D.40862 = m->mb;
      result = inflate_mono_method (inflated_klass, method, D.40862);
      mono_metadata_free_type (type);
    }
    <D.40859>:
    D.40224 = mono_defaults.methodhandle_class;
    *handle_class = D.40224;
  }
  goto <D.40874>;
  <D.40853>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39960 = obj->vtable;
      D.39961 = D.39960->klass;
      __s2 = D.39961->name;
      D.40878 = "MonoArrayMethod";
      D.40879 = MEM[(const unsigned char *)D.40878];
      D.40880 = (int) D.40879;
      D.40881 = *__s2;
      D.40882 = (int) D.40881;
      __result = D.40880 - D.40882;
      {
        if (__s2_len != 0) goto <D.40883>; else goto <D.40884>;
        <D.40883>:
        if (__result == 0) goto <D.40885>; else goto <D.40886>;
        <D.40885>:
        D.40887 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.40888 = *D.40887;
        D.40889 = (int) D.40888;
        D.40890 = __s2 + 1;
        D.40891 = *D.40890;
        D.40892 = (int) D.40891;
        __result = D.40889 - D.40892;
        if (__s2_len > 1) goto <D.40893>; else goto <D.40894>;
        <D.40893>:
        if (__result == 0) goto <D.40895>; else goto <D.40896>;
        <D.40895>:
        D.40897 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.40898 = *D.40897;
        D.40899 = (int) D.40898;
        D.40900 = __s2 + 2;
        D.40901 = *D.40900;
        D.40902 = (int) D.40901;
        __result = D.40899 - D.40902;
        if (__s2_len > 2) goto <D.40903>; else goto <D.40904>;
        <D.40903>:
        if (__result == 0) goto <D.40905>; else goto <D.40906>;
        <D.40905>:
        D.40907 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.40908 = *D.40907;
        D.40909 = (int) D.40908;
        D.40910 = __s2 + 3;
        D.40911 = *D.40910;
        D.40912 = (int) D.40911;
        __result = D.40909 - D.40912;
        <D.40906>:
        <D.40904>:
        <D.40896>:
        <D.40894>:
        <D.40886>:
        <D.40884>:
      }
      D.24555 = __result;
    }
    iftmp.652 = -D.24555;
    goto <D.40913>;
    <D.40877>:
    D.39960 = obj->vtable;
    D.39961 = D.39960->klass;
    D.39998 = D.39961->name;
    iftmp.652 = __builtin_strcmp (D.39998, "MonoArrayMethod");
    <D.40913>:
    D.24556 = iftmp.652;
  }
  if (D.24556 == 0) goto <D.40914>; else goto <D.40915>;
  <D.40914>:
  {
    struct MonoReflectionArrayMethod * m;
    struct MonoType * mtype;
    struct MonoClass * klass;
    struct MonoMethod * method;
    void * iter;
    char * name;

    try
      {
        m = obj;
        D.40916 = m->parent;
        mtype = mono_reflection_type_get_handle (D.40916);
        klass = mono_class_from_mono_type (mtype);
        D.40917 = m->name;
        name = mono_string_to_utf8 (D.40917);
        iter = 0B;
        goto <D.24574>;
        <D.24573>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.40918 = method->name;
          D.24571 = __builtin_strcmp (D.40918, name);
        }
        if (D.24571 == 0) goto <D.24572>; else goto <D.40919>;
        <D.40919>:
        <D.24574>:
        method = mono_class_get_methods (klass, &iter);
        if (method != 0B) goto <D.24573>; else goto <D.24572>;
        <D.24572>:
        monoeg_g_free (name);
        D.40920 = method == 0B;
        D.40921 = (long int) D.40920;
        D.40922 = __builtin_expect (D.40921, 0);
        if (D.40922 != 0) goto <D.40923>; else goto <D.40924>;
        <D.40923>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12001, "method");
        <D.40924>:
        result = method;
        D.40224 = mono_defaults.methodhandle_class;
        *handle_class = D.40224;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  goto <D.40925>;
  <D.40915>:
  D.40929 = mono_object_get_class (obj);
  D.40930 = is_sre_array (D.40929);
  if (D.40930 != 0) goto <D.40926>; else goto <D.40931>;
  <D.40931>:
  D.40932 = mono_object_get_class (obj);
  D.40933 = is_sre_byref (D.40932);
  if (D.40933 != 0) goto <D.40926>; else goto <D.40934>;
  <D.40934>:
  D.40935 = mono_object_get_class (obj);
  D.40936 = is_sre_pointer (D.40935);
  if (D.40936 != 0) goto <D.40926>; else goto <D.40927>;
  <D.40926>:
  {
    struct MonoReflectionType * ref_type;
    struct MonoType * type;

    ref_type = obj;
    type = mono_reflection_type_get_handle (ref_type);
    if (context != 0B) goto <D.40937>; else goto <D.40938>;
    <D.40937>:
    {
      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.40939>;
    <D.40938>:
    result = mono_class_from_mono_type (type);
    <D.40939>:
    D.40056 = mono_defaults.typehandle_class;
    *handle_class = D.40056;
  }
  goto <D.40928>;
  <D.40927>:
  D.39960 = obj->vtable;
  D.39961 = D.39960->klass;
  D.39998 = D.39961->name;
  monoeg_g_print ("%s\n", D.39998);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12022);
  <D.40928>:
  <D.40925>:
  <D.40874>:
  <D.40812>:
  <D.40756>:
  <D.40696>:
  <D.40652>:
  <D.40608>:
  <D.40560>:
  <D.40489>:
  <D.40439>:
  <D.40383>:
  <D.40320>:
  <D.40273>:
  <D.40062>:
  <D.40059>:
  <D.40007>:
  D.40940 = result;
  return D.40940;
}


ensure_complete_type (struct MonoClass * klass)
{
  struct MonoImage * D.40942;
  long unsigned int D.40943;
  long unsigned int D.40944;
  long unsigned int D.40947;
  long unsigned int D.40948;
  void * D.40951;
  struct MonoDomain * D.40954;
  struct MonoGenericClass * D.40955;
  struct MonoType * D.40958;
  struct MonoClass * D.40959;
  <unnamed-unsigned:22> D.40960;
  int D.40961;

  D.40942 = klass->image;
  D.40943 = BIT_FIELD_REF <*D.40942, 64, 192>;
  D.40944 = D.40943 & 34359738368;
  if (D.40944 != 0) goto <D.40945>; else goto <D.40946>;
  <D.40945>:
  D.40947 = BIT_FIELD_REF <*klass, 64, 256>;
  D.40948 = D.40947 & 128;
  if (D.40948 == 0) goto <D.40949>; else goto <D.40950>;
  <D.40949>:
  D.40951 = mono_class_get_ref_info (klass);
  if (D.40951 != 0B) goto <D.40952>; else goto <D.40953>;
  <D.40952>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.40954 = mono_domain_get ();
    mono_domain_try_type_resolve (D.40954, 0B, tb);
  }
  <D.40953>:
  <D.40950>:
  <D.40946>:
  D.40955 = klass->generic_class;
  if (D.40955 != 0B) goto <D.40956>; else goto <D.40957>;
  <D.40956>:
  {
    struct MonoGenericInst * inst;
    int i;

    D.40955 = klass->generic_class;
    inst = D.40955->context.class_inst;
    i = 0;
    goto <D.24311>;
    <D.24310>:
    D.40958 = inst->type_argv[i];
    D.40959 = mono_class_from_mono_type (D.40958);
    ensure_complete_type (D.40959);
    i = i + 1;
    <D.24311>:
    D.40960 = inst->type_argc;
    D.40961 = (int) D.40960;
    if (D.40961 > i) goto <D.24310>; else goto <D.24312>;
    <D.24312>:
  }
  <D.40957>:
}


mono_reflection_is_valid_dynamic_token (struct MonoDynamicImage * image, guint32 token)
{
  gboolean D.40962;
  struct MonoGHashTable * D.40963;
  long unsigned int D.40964;
  const void * D.40965;
  void * D.40966;
  _Bool D.40967;

  D.40963 = image->tokens;
  D.40964 = (long unsigned int) token;
  D.40965 = (const void *) D.40964;
  D.40966 = mono_g_hash_table_lookup (D.40963, D.40965);
  D.40967 = D.40966 != 0B;
  D.40962 = (gboolean) D.40967;
  return D.40962;
}


mono_reflection_lookup_signature (struct MonoImage * image, struct MonoMethod * method, guint32 token)
{
  long unsigned int D.40969;
  long unsigned int D.40970;
  _Bool D.40971;
  long int D.40972;
  long int D.40973;
  struct GHashTable * D.40976;
  long unsigned int D.40977;
  const void * D.40978;
  struct MonoMethodSignature * D.40981;
  struct MonoMethodSignature * sig;

  D.40969 = BIT_FIELD_REF <*image, 64, 192>;
  D.40970 = D.40969 & 34359738368;
  D.40971 = D.40970 == 0;
  D.40972 = (long int) D.40971;
  D.40973 = __builtin_expect (D.40972, 0);
  if (D.40973 != 0) goto <D.40974>; else goto <D.40975>;
  <D.40974>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11672, "image->dynamic");
  <D.40975>:
  D.40976 = MEM[(struct MonoDynamicImage *)image].vararg_aux_hash;
  D.40977 = (long unsigned int) token;
  D.40978 = (const void *) D.40977;
  sig = monoeg_g_hash_table_lookup (D.40976, D.40978);
  if (sig != 0B) goto <D.40979>; else goto <D.40980>;
  <D.40979>:
  D.40981 = sig;
  return D.40981;
  <D.40980>:
  D.40981 = mono_method_signature (method);
  return D.40981;
}


mono_reflection_lookup_dynamic_token (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  struct MonoGHashTable * D.40983;
  long unsigned int D.40984;
  const void * D.40985;
  void * D.40990;
  struct MonoDynamicImage * assembly;
  struct MonoObject * obj;
  struct MonoClass * klass;

  try
    {
      assembly = image;
      mono_loader_lock ();
      D.40983 = assembly->tokens;
      D.40984 = (long unsigned int) token;
      D.40985 = (const void *) D.40984;
      obj = mono_g_hash_table_lookup (D.40983, D.40985);
      mono_loader_unlock ();
      if (obj == 0B) goto <D.40986>; else goto <D.40987>;
      <D.40986>:
      if (valid_token != 0) goto <D.40988>; else goto <D.40989>;
      <D.40988>:
      monoeg_g_log (0B, 4, "Could not find required dynamic token 0x%08x", token);
      <D.24303>:
      goto <D.24303>;
      <D.40989>:
      D.40990 = 0B;
      return D.40990;
      <D.40987>:
      if (handle_class == 0B) goto <D.40991>; else goto <D.40992>;
      <D.40991>:
      handle_class = &klass;
      <D.40992>:
      D.40990 = resolve_object (image, obj, handle_class, context);
      return D.40990;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


mono_declsec_flags_from_method (struct MonoMethod * method)
{
  short unsigned int D.40995;
  int D.40996;
  int D.40997;
  uint32_t D.41000;
  struct MonoClass * D.41001;
  struct MonoImage * D.41002;

  D.40995 = method->flags;
  D.40996 = (int) D.40995;
  D.40997 = D.40996 & 16384;
  if (D.40997 != 0) goto <D.40998>; else goto <D.40999>;
  <D.40998>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.41001 = method->klass;
    D.41002 = D.41001->image;
    D.41000 = mono_declsec_get_flags (D.41002, idx);
    return D.41000;
  }
  <D.40999>:
  D.41000 = 0;
  return D.41000;
}


mono_declsec_get_flags (struct MonoImage * image, guint32 token)
{
  unsigned int D.41004;
  guint32 D.41007;
  unsigned int D.41008;
  unsigned int D.41010;
  unsigned int D.41013;
  <unnamed-unsigned:24> D.41015;
  int D.41016;
  int index;
  struct MonoTableInfo * t;
  guint32 result;
  guint32 action;
  int i;

  D.41004 = mono_metadata_declsec_from_index (image, token);
  index = (int) D.41004;
  t = &image->tables[14];
  result = 0;
  if (index < 0) goto <D.41005>; else goto <D.41006>;
  <D.41005>:
  D.41007 = 0;
  return D.41007;
  <D.41006>:
  i = index;
  goto <D.24591>;
  <D.24590>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.41008 = cols[1];
        if (D.41008 != token) goto <D.24589>; else goto <D.41009>;
        <D.41009>:
        action = cols[0];
        D.41010 = action + 4294967295;
        if (D.41010 <= 17) goto <D.41011>; else goto <D.41012>;
        <D.41011>:
        D.41013 = declsec_flags_map[action];
        result = D.41013 | result;
        goto <D.41014>;
        <D.41012>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12239);
        <D.41014>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.24591>:
  D.41015 = t->rows;
  D.41016 = (int) D.41015;
  if (D.41016 > i) goto <D.24590>; else goto <D.24589>;
  <D.24589>:
  D.41007 = result;
  return D.41007;
}


mono_declsec_flags_from_class (struct MonoClass * klass)
{
  unsigned int D.41020;
  unsigned int D.41021;
  struct MonoClassExt * D.41026;
  unsigned int D.41028;
  unsigned int D.41029;
  struct MonoImage * D.41030;
  unsigned int D.41031;
  uint32_t D.41032;

  D.41020 = klass->flags;
  D.41021 = D.41020 & 262144;
  if (D.41021 != 0) goto <D.41022>; else goto <D.41023>;
  <D.41022>:
  D.41026 = klass->ext;
  if (D.41026 == 0B) goto <D.41024>; else goto <D.41027>;
  <D.41027>:
  D.41026 = klass->ext;
  D.41028 = D.41026->declsec_flags;
  if (D.41028 == 0) goto <D.41024>; else goto <D.41025>;
  <D.41024>:
  {
    guint32 idx;

    D.41029 = klass->type_token;
    idx = D.41029 & 16777215;
    idx = idx << 2;
    idx = idx;
    mono_loader_lock ();
    mono_class_alloc_ext (klass);
    mono_loader_unlock ();
    D.41026 = klass->ext;
    D.41030 = klass->image;
    D.41031 = mono_declsec_get_flags (D.41030, idx);
    D.41026->declsec_flags = D.41031;
  }
  <D.41025>:
  D.41026 = klass->ext;
  D.41032 = D.41026->declsec_flags;
  return D.41032;
  <D.41023>:
  D.41032 = 0;
  return D.41032;
}


mono_declsec_flags_from_assembly (struct MonoAssembly * assembly)
{
  uint32_t D.41034;
  struct MonoImage * D.41035;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.41035 = assembly->image;
  D.41034 = mono_declsec_get_flags (D.41035, idx);
  return D.41034;
}


mono_declsec_get_demands (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.41037;
  struct MonoImage * D.41038;
  long unsigned int D.41039;
  long unsigned int D.41040;
  MonoBoolean D.41043;
  long unsigned int D.41046;
  long unsigned int D.41047;
  short unsigned int D.41051;
  int D.41052;
  int D.41053;
  unsigned int D.41056;
  unsigned char D.41061;
  guint32 mask;
  MonoBoolean result;
  guint32 flags;

  mask = 135170;
  result = 0;
  D.41037 = method->klass;
  D.41038 = D.41037->image;
  D.41039 = BIT_FIELD_REF <*D.41038, 64, 3392>;
  D.41040 = D.41039 & 16777215;
  if (D.41040 == 0) goto <D.41041>; else goto <D.41042>;
  <D.41041>:
  D.41043 = 0;
  return D.41043;
  <D.41042>:
  D.41046 = BIT_FIELD_REF <*method, 64, 256>;
  D.41047 = D.41046 & 124;
  if (D.41047 == 24) goto <D.41044>; else goto <D.41048>;
  <D.41048>:
  D.41046 = BIT_FIELD_REF <*method, 64, 256>;
  D.41047 = D.41046 & 124;
  if (D.41047 == 28) goto <D.41044>; else goto <D.41045>;
  <D.41044>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.41049>; else goto <D.41050>;
  <D.41049>:
  D.41043 = 0;
  return D.41043;
  <D.41050>:
  <D.41045>:
  D.41051 = method->flags;
  D.41052 = (int) D.41051;
  D.41053 = D.41052 & 16384;
  if (D.41053 != 0) goto <D.41054>; else goto <D.41055>;
  <D.41054>:
  D.41037 = method->klass;
  mono_class_init (D.41037);
  memset (demands, 0, 48);
  result = mono_declsec_get_method_demands_params (method, demands, 2, 13, 18);
  <D.41055>:
  D.41037 = method->klass;
  flags = mono_declsec_flags_from_class (D.41037);
  D.41056 = flags & mask;
  if (D.41056 != 0) goto <D.41057>; else goto <D.41058>;
  <D.41057>:
  if (result == 0) goto <D.41059>; else goto <D.41060>;
  <D.41059>:
  D.41037 = method->klass;
  mono_class_init (D.41037);
  memset (demands, 0, 48);
  <D.41060>:
  D.41037 = method->klass;
  D.41061 = mono_declsec_get_class_demands_params (D.41037, demands, 2, 13, 18);
  result = D.41061 | result;
  <D.41058>:
  D.41043 = result;
  return D.41043;
}


mono_declsec_get_method_demands_params (struct MonoMethod * method, struct MonoDeclSecurityActions * demands, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  MonoBoolean D.41063;
  struct MonoClass * D.41064;
  struct MonoImage * D.41065;
  guint32 idx;

  idx = mono_method_get_index (method);
  idx = idx << 2;
  idx = idx | 1;
  D.41064 = method->klass;
  D.41065 = D.41064->image;
  D.41063 = fill_actions_from_index (D.41065, idx, demands, id_std, id_noncas, id_choice);
  return D.41063;
}


fill_actions_from_index (struct MonoImage * image, guint32 token, struct MonoDeclSecurityActions * actions, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  unsigned int D.41067;
  unsigned int D.41068;
  MonoBoolean D.41071;
  unsigned int D.41072;
  char * D.41075;
  unsigned int D.41078;
  const char * blob.653;
  const char * blob.654;
  char * D.41081;
  unsigned int D.41082;
  char * D.41086;
  const char * blob.655;
  const char * blob.656;
  char * D.41091;
  unsigned int D.41092;
  char * D.41096;
  const char * blob.657;
  const char * blob.658;
  char * D.41101;
  unsigned int D.41102;
  <unnamed-unsigned:24> D.41103;
  int D.41104;
  MonoBoolean result;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int index;
  int i;

  try
    {
      result = 0;
      D.41067 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.41067;
      t = &image->tables[14];
      i = index;
      goto <D.24621>;
      <D.24620>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.41068 = cols[1];
      if (D.41068 != token) goto <D.41069>; else goto <D.41070>;
      <D.41069>:
      D.41071 = result;
      return D.41071;
      <D.41070>:
      D.41072 = cols[0];
      if (D.41072 == id_std) goto <D.41073>; else goto <D.41074>;
      <D.41073>:
      D.41075 = actions->demand.blob;
      if (D.41075 == 0B) goto <D.41076>; else goto <D.41077>;
      <D.41076>:
      {
        const char * blob;

        try
          {
            D.41078 = cols[2];
            blob.653 = mono_metadata_blob_heap (image, D.41078);
            blob = blob.653;
            D.41078 = cols[2];
            actions->demand.index = D.41078;
            blob.654 = blob;
            D.41081 = blob.654 + 2;
            actions->demand.blob = D.41081;
            blob.654 = blob;
            D.41082 = mono_metadata_decode_blob_size (blob.654, &blob);
            actions->demand.size = D.41082;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.41077>:
      goto <D.41083>;
      <D.41074>:
      D.41072 = cols[0];
      if (D.41072 == id_noncas) goto <D.41084>; else goto <D.41085>;
      <D.41084>:
      D.41086 = actions->noncasdemand.blob;
      if (D.41086 == 0B) goto <D.41087>; else goto <D.41088>;
      <D.41087>:
      {
        const char * blob;

        try
          {
            D.41078 = cols[2];
            blob.655 = mono_metadata_blob_heap (image, D.41078);
            blob = blob.655;
            D.41078 = cols[2];
            actions->noncasdemand.index = D.41078;
            blob.656 = blob;
            D.41091 = blob.656 + 2;
            actions->noncasdemand.blob = D.41091;
            blob.656 = blob;
            D.41092 = mono_metadata_decode_blob_size (blob.656, &blob);
            actions->noncasdemand.size = D.41092;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.41088>:
      goto <D.41093>;
      <D.41085>:
      D.41072 = cols[0];
      if (D.41072 == id_choice) goto <D.41094>; else goto <D.41095>;
      <D.41094>:
      D.41096 = actions->demandchoice.blob;
      if (D.41096 == 0B) goto <D.41097>; else goto <D.41098>;
      <D.41097>:
      {
        const char * blob;

        try
          {
            D.41078 = cols[2];
            blob.657 = mono_metadata_blob_heap (image, D.41078);
            blob = blob.657;
            D.41078 = cols[2];
            actions->demandchoice.index = D.41078;
            blob.658 = blob;
            D.41101 = blob.658 + 2;
            actions->demandchoice.blob = D.41101;
            blob.658 = blob;
            D.41102 = mono_metadata_decode_blob_size (blob.658, &blob);
            actions->demandchoice.size = D.41102;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.41098>:
      <D.41095>:
      <D.41093>:
      <D.41083>:
      i = i + 1;
      <D.24621>:
      D.41103 = t->rows;
      D.41104 = (int) D.41103;
      if (D.41104 > i) goto <D.24620>; else goto <D.24622>;
      <D.24622>:
      D.41071 = result;
      return D.41071;
    }
  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.41107;
  MonoBoolean D.41108;
  struct MonoImage * D.41109;
  guint32 idx;

  D.41107 = klass->type_token;
  idx = D.41107 & 16777215;
  idx = idx << 2;
  idx = idx;
  D.41109 = klass->image;
  D.41108 = fill_actions_from_index (D.41109, idx, demands, id_std, id_noncas, id_choice);
  return D.41108;
}


mono_declsec_get_linkdemands (struct MonoMethod * method, struct MonoDeclSecurityActions * klass, struct MonoDeclSecurityActions * cmethod)
{
  struct MonoClass * D.41111;
  struct MonoImage * D.41112;
  long unsigned int D.41113;
  long unsigned int D.41114;
  MonoBoolean D.41117;
  long unsigned int D.41120;
  long unsigned int D.41121;
  short unsigned int D.41125;
  int D.41126;
  int D.41127;
  unsigned int D.41130;
  unsigned char D.41133;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.41111 = method->klass;
  D.41112 = D.41111->image;
  D.41113 = BIT_FIELD_REF <*D.41112, 64, 3392>;
  D.41114 = D.41113 & 16777215;
  if (D.41114 == 0) goto <D.41115>; else goto <D.41116>;
  <D.41115>:
  D.41117 = 0;
  return D.41117;
  <D.41116>:
  D.41120 = BIT_FIELD_REF <*method, 64, 256>;
  D.41121 = D.41120 & 124;
  if (D.41121 == 24) goto <D.41118>; else goto <D.41122>;
  <D.41122>:
  D.41120 = BIT_FIELD_REF <*method, 64, 256>;
  D.41121 = D.41120 & 124;
  if (D.41121 == 28) goto <D.41118>; else goto <D.41119>;
  <D.41118>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.41123>; else goto <D.41124>;
  <D.41123>:
  D.41117 = 0;
  return D.41117;
  <D.41124>:
  <D.41119>:
  memset (cmethod, 0, 48);
  memset (klass, 0, 48);
  D.41125 = method->flags;
  D.41126 = (int) D.41125;
  D.41127 = D.41126 & 16384;
  if (D.41127 != 0) goto <D.41128>; else goto <D.41129>;
  <D.41128>:
  D.41111 = method->klass;
  mono_class_init (D.41111);
  result = mono_declsec_get_method_demands_params (method, cmethod, 6, 14, 16);
  <D.41129>:
  D.41111 = method->klass;
  flags = mono_declsec_flags_from_class (D.41111);
  D.41130 = flags & 40992;
  if (D.41130 != 0) goto <D.41131>; else goto <D.41132>;
  <D.41131>:
  D.41111 = method->klass;
  mono_class_init (D.41111);
  D.41111 = method->klass;
  D.41133 = mono_declsec_get_class_demands_params (D.41111, klass, 6, 14, 16);
  result = D.41133 | result;
  <D.41132>:
  D.41117 = result;
  return D.41117;
}


mono_declsec_get_inheritdemands_class (struct MonoClass * klass, struct MonoDeclSecurityActions * demands)
{
  struct MonoImage * D.41135;
  long unsigned int D.41136;
  long unsigned int D.41137;
  MonoBoolean D.41140;
  unsigned int D.41141;
  unsigned char D.41144;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.41135 = klass->image;
  D.41136 = BIT_FIELD_REF <*D.41135, 64, 3392>;
  D.41137 = D.41136 & 16777215;
  if (D.41137 == 0) goto <D.41138>; else goto <D.41139>;
  <D.41138>:
  D.41140 = 0;
  return D.41140;
  <D.41139>:
  flags = mono_declsec_flags_from_class (klass);
  D.41141 = flags & 81984;
  if (D.41141 != 0) goto <D.41142>; else goto <D.41143>;
  <D.41142>:
  mono_class_init (klass);
  memset (demands, 0, 48);
  D.41144 = mono_declsec_get_class_demands_params (klass, demands, 7, 15, 17);
  result = D.41144 | result;
  <D.41143>:
  D.41140 = result;
  return D.41140;
}


mono_declsec_get_inheritdemands_method (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.41146;
  struct MonoImage * D.41147;
  long unsigned int D.41148;
  long unsigned int D.41149;
  MonoBoolean D.41152;
  long unsigned int D.41155;
  long unsigned int D.41156;
  short unsigned int D.41160;
  int D.41161;
  int D.41162;

  D.41146 = method->klass;
  D.41147 = D.41146->image;
  D.41148 = BIT_FIELD_REF <*D.41147, 64, 3392>;
  D.41149 = D.41148 & 16777215;
  if (D.41149 == 0) goto <D.41150>; else goto <D.41151>;
  <D.41150>:
  D.41152 = 0;
  return D.41152;
  <D.41151>:
  D.41155 = BIT_FIELD_REF <*method, 64, 256>;
  D.41156 = D.41155 & 124;
  if (D.41156 == 24) goto <D.41153>; else goto <D.41157>;
  <D.41157>:
  D.41155 = BIT_FIELD_REF <*method, 64, 256>;
  D.41156 = D.41155 & 124;
  if (D.41156 == 28) goto <D.41153>; else goto <D.41154>;
  <D.41153>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.41158>; else goto <D.41159>;
  <D.41158>:
  D.41152 = 0;
  return D.41152;
  <D.41159>:
  <D.41154>:
  D.41160 = method->flags;
  D.41161 = (int) D.41160;
  D.41162 = D.41161 & 16384;
  if (D.41162 != 0) goto <D.41163>; else goto <D.41164>;
  <D.41163>:
  D.41146 = method->klass;
  mono_class_init (D.41146);
  memset (demands, 0, 48);
  D.41152 = mono_declsec_get_method_demands_params (method, demands, 7, 15, 17);
  return D.41152;
  <D.41164>:
  D.41152 = 0;
  return D.41152;
}


mono_declsec_get_method_action (struct MonoMethod * method, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  short unsigned int D.41166;
  int D.41167;
  int D.41168;
  MonoBoolean D.41171;
  struct MonoClass * D.41172;
  struct MonoImage * D.41173;

  D.41166 = method->flags;
  D.41167 = (int) D.41166;
  D.41168 = D.41167 & 16384;
  if (D.41168 != 0) goto <D.41169>; else goto <D.41170>;
  <D.41169>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.41172 = method->klass;
    D.41173 = D.41172->image;
    D.41171 = get_declsec_action (D.41173, idx, action, entry);
    return D.41171;
  }
  <D.41170>:
  D.41171 = 0;
  return D.41171;
}


get_declsec_action (struct MonoImage * image, guint32 token, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.41175;
  MonoBoolean D.41178;
  unsigned int D.41179;
  unsigned int D.41182;
  unsigned int D.41185;
  const char * metadata.659;
  const char * metadata.660;
  char * D.41188;
  unsigned int D.41189;
  <unnamed-unsigned:24> D.41190;
  int D.41191;
  guint32 cols[3];
  struct MonoTableInfo * t;
  int i;
  int index;

  try
    {
      D.41175 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.41175;
      if (index == -1) goto <D.41176>; else goto <D.41177>;
      <D.41176>:
      D.41178 = 0;
      return D.41178;
      <D.41177>:
      t = &image->tables[14];
      i = index;
      goto <D.24675>;
      <D.24674>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.41179 = cols[1];
      if (D.41179 != token) goto <D.41180>; else goto <D.41181>;
      <D.41180>:
      D.41178 = 0;
      return D.41178;
      <D.41181>:
      D.41182 = cols[0];
      if (D.41182 == action) goto <D.41183>; else goto <D.41184>;
      <D.41183>:
      {
        const char * metadata;

        try
          {
            D.41185 = cols[2];
            metadata.659 = mono_metadata_blob_heap (image, D.41185);
            metadata = metadata.659;
            metadata.660 = metadata;
            D.41188 = metadata.660 + 2;
            entry->blob = D.41188;
            metadata.660 = metadata;
            D.41189 = mono_metadata_decode_blob_size (metadata.660, &metadata);
            entry->size = D.41189;
            D.41178 = 1;
            return D.41178;
          }
        finally
          {
            metadata = {CLOBBER};
          }
      }
      <D.41184>:
      i = i + 1;
      <D.24675>:
      D.41190 = t->rows;
      D.41191 = (int) D.41190;
      if (D.41191 > i) goto <D.24674>; else goto <D.24676>;
      <D.24676>:
      D.41178 = 0;
      return D.41178;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_declsec_get_class_action (struct MonoClass * klass, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.41195;
  unsigned int D.41196;
  unsigned int D.41199;
  MonoBoolean D.41200;
  struct MonoImage * D.41201;
  guint32 flags;

  flags = mono_declsec_flags_from_class (klass);
  D.41195 = declsec_flags_map[action];
  D.41196 = D.41195 & flags;
  if (D.41196 != 0) goto <D.41197>; else goto <D.41198>;
  <D.41197>:
  {
    guint32 idx;

    D.41199 = klass->type_token;
    idx = D.41199 & 16777215;
    idx = idx << 2;
    idx = idx;
    D.41201 = klass->image;
    D.41200 = get_declsec_action (D.41201, idx, action, entry);
    return D.41200;
  }
  <D.41198>:
  D.41200 = 0;
  return D.41200;
}


mono_declsec_get_assembly_action (struct MonoAssembly * assembly, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  MonoBoolean D.41203;
  struct MonoImage * D.41204;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.41204 = assembly->image;
  D.41203 = get_declsec_action (D.41204, idx, action, entry);
  return D.41203;
}


mono_reflection_call_is_assignable_to (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * System_Reflection_Emit_TypeBuilder.661;
  struct MonoImage * D.41209;
  struct MonoClass * System_Reflection_Emit_TypeBuilder.662;
  _Bool D.41211;
  long int D.41212;
  long int D.41213;
  struct MonoMethod * method.663;
  struct MonoMethod * method.664;
  _Bool D.41220;
  long int D.41221;
  long int D.41222;
  void * D.41225;
  _Bool D.41226;
  long int D.41227;
  long int D.41228;
  int D.24713;
  int iftmp.665;
  int D.24712;
  void * D.41234;
  struct MonoVTable * D.41235;
  struct MonoClass * D.41236;
  const char[12] * D.41237;
  unsigned char D.41238;
  int D.41239;
  unsigned char D.41240;
  int D.41241;
  const unsigned char * D.41246;
  unsigned char D.41247;
  int D.41248;
  const unsigned char * D.41249;
  unsigned char D.41250;
  int D.41251;
  const unsigned char * D.41256;
  unsigned char D.41257;
  int D.41258;
  const unsigned char * D.41259;
  unsigned char D.41260;
  int D.41261;
  const unsigned char * D.41266;
  unsigned char D.41267;
  int D.41268;
  const unsigned char * D.41269;
  unsigned char D.41270;
  int D.41271;
  void * D.41273;
  struct MonoVTable * D.41274;
  struct MonoClass * D.41275;
  const char * D.41276;
  _Bool D.41277;
  long int D.41278;
  long int D.41279;
  struct MonoDomain * D.41282;
  struct MonoType * D.41283;
  struct MonoReflectionType * D.41284;
  void * D.41285;
  struct MonoObject * exc.666;
  gboolean D.41289;
  void * D.41290;
  unsigned char D.41291;
  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.661 = System_Reflection_Emit_TypeBuilder;
      if (System_Reflection_Emit_TypeBuilder.661 == 0B) goto <D.41207>; else goto <D.41208>;
      <D.41207>:
      D.41209 = mono_defaults.corlib;
      System_Reflection_Emit_TypeBuilder.662 = mono_class_from_name (D.41209, "System.Reflection.Emit", "TypeBuilder");
      System_Reflection_Emit_TypeBuilder = System_Reflection_Emit_TypeBuilder.662;
      System_Reflection_Emit_TypeBuilder.661 = System_Reflection_Emit_TypeBuilder;
      D.41211 = System_Reflection_Emit_TypeBuilder.661 == 0B;
      D.41212 = (long int) D.41211;
      D.41213 = __builtin_expect (D.41212, 0);
      if (D.41213 != 0) goto <D.41214>; else goto <D.41215>;
      <D.41214>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12621, "System_Reflection_Emit_TypeBuilder");
      <D.41215>:
      <D.41208>:
      method.663 = method;
      if (method.663 == 0B) goto <D.41217>; else goto <D.41218>;
      <D.41217>:
      System_Reflection_Emit_TypeBuilder.661 = System_Reflection_Emit_TypeBuilder;
      method.664 = mono_class_get_method_from_name (System_Reflection_Emit_TypeBuilder.661, "IsAssignableTo", 1);
      method = method.664;
      method.663 = method;
      D.41220 = method.663 == 0B;
      D.41221 = (long int) D.41220;
      D.41222 = __builtin_expect (D.41221, 0);
      if (D.41222 != 0) goto <D.41223>; else goto <D.41224>;
      <D.41223>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12625, "method");
      <D.41224>:
      <D.41218>:
      D.41225 = mono_class_get_ref_info (klass);
      D.41226 = D.41225 == 0B;
      D.41227 = (long int) D.41226;
      D.41228 = __builtin_expect (D.41227, 0);
      if (D.41228 != 0) goto <D.41229>; else goto <D.41230>;
      <D.41229>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12632, "mono_class_get_ref_info (klass)");
      <D.41230>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.41234 = mono_class_get_ref_info (klass);
          D.41235 = MEM[(struct MonoObject *)D.41234].vtable;
          D.41236 = D.41235->klass;
          __s2 = D.41236->name;
          D.41237 = "TypeBuilder";
          D.41238 = MEM[(const unsigned char *)D.41237];
          D.41239 = (int) D.41238;
          D.41240 = *__s2;
          D.41241 = (int) D.41240;
          __result = D.41239 - D.41241;
          {
            if (__s2_len != 0) goto <D.41242>; else goto <D.41243>;
            <D.41242>:
            if (__result == 0) goto <D.41244>; else goto <D.41245>;
            <D.41244>:
            D.41246 = &MEM[(void *)"TypeBuilder" + 1B];
            D.41247 = *D.41246;
            D.41248 = (int) D.41247;
            D.41249 = __s2 + 1;
            D.41250 = *D.41249;
            D.41251 = (int) D.41250;
            __result = D.41248 - D.41251;
            if (__s2_len > 1) goto <D.41252>; else goto <D.41253>;
            <D.41252>:
            if (__result == 0) goto <D.41254>; else goto <D.41255>;
            <D.41254>:
            D.41256 = &MEM[(void *)"TypeBuilder" + 2B];
            D.41257 = *D.41256;
            D.41258 = (int) D.41257;
            D.41259 = __s2 + 2;
            D.41260 = *D.41259;
            D.41261 = (int) D.41260;
            __result = D.41258 - D.41261;
            if (__s2_len > 2) goto <D.41262>; else goto <D.41263>;
            <D.41262>:
            if (__result == 0) goto <D.41264>; else goto <D.41265>;
            <D.41264>:
            D.41266 = &MEM[(void *)"TypeBuilder" + 3B];
            D.41267 = *D.41266;
            D.41268 = (int) D.41267;
            D.41269 = __s2 + 3;
            D.41270 = *D.41269;
            D.41271 = (int) D.41270;
            __result = D.41268 - D.41271;
            <D.41265>:
            <D.41263>:
            <D.41255>:
            <D.41253>:
            <D.41245>:
            <D.41243>:
          }
          D.24712 = __result;
        }
        iftmp.665 = -D.24712;
        goto <D.41272>;
        <D.41233>:
        D.41273 = mono_class_get_ref_info (klass);
        D.41274 = MEM[(struct MonoObject *)D.41273].vtable;
        D.41275 = D.41274->klass;
        D.41276 = D.41275->name;
        iftmp.665 = __builtin_strcmp (D.41276, "TypeBuilder");
        <D.41272>:
        D.24713 = iftmp.665;
      }
      D.41277 = D.24713 != 0;
      D.41278 = (long int) D.41277;
      D.41279 = __builtin_expect (D.41278, 0);
      if (D.41279 != 0) goto <D.41280>; else goto <D.41281>;
      <D.41280>:
      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.41281>:
      D.41282 = mono_domain_get ();
      D.41283 = &oklass->byval_arg;
      D.41284 = mono_type_get_object (D.41282, D.41283);
      params[0] = D.41284;
      method.663 = method;
      D.41285 = mono_class_get_ref_info (klass);
      res = mono_runtime_invoke (method.663, D.41285, &params, &exc);
      exc.666 = exc;
      if (exc.666 != 0B) goto <D.41287>; else goto <D.41288>;
      <D.41287>:
      D.41289 = 0;
      return D.41289;
      <D.41288>:
      D.41290 = mono_object_unbox (res);
      D.41291 = MEM[(MonoBoolean *)D.41290];
      D.41289 = (gboolean) D.41291;
      return D.41289;
    }
  finally
    {
      exc = {CLOBBER};
      params = {CLOBBER};
    }
}


mono_reflection_type_get_type (struct MonoReflectionType * reftype)
{
  _Bool D.41294;
  long int D.41295;
  long int D.41296;
  struct MonoType * D.41299;

  D.41294 = reftype == 0B;
  D.41295 = (long int) D.41294;
  D.41296 = __builtin_expect (D.41295, 0);
  if (D.41296 != 0) goto <D.41297>; else goto <D.41298>;
  <D.41297>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12653, "reftype");
  <D.41298>:
  D.41299 = mono_reflection_type_get_handle (reftype);
  return D.41299;
}