mono_reflection_init ()
{

}


mono_class_get_ref_info (struct MonoClass * klass)
{
  unsigned int D.24188;
  void * D.24191;

  D.24188 = klass->ref_info_handle;
  if (D.24188 == 0) goto <D.24189>; else goto <D.24190>;
  <D.24189>:
  D.24191 = 0B;
  return D.24191;
  <D.24190>:
  D.24188 = klass->ref_info_handle;
  D.24191 = mono_gchandle_get_target (D.24188);
  return D.24191;
}


mono_class_set_ref_info (struct MonoClass * klass, void * obj)
{
  unsigned int D.24193;
  unsigned int D.24194;
  _Bool D.24195;
  long int D.24196;
  long int D.24197;

  D.24193 = mono_gchandle_new (obj, 0);
  klass->ref_info_handle = D.24193;
  D.24194 = klass->ref_info_handle;
  D.24195 = D.24194 == 0;
  D.24196 = (long int) D.24195;
  D.24197 = __builtin_expect (D.24196, 0);
  if (D.24197 != 0) goto <D.24198>; else goto <D.24199>;
  <D.24198>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 641, "klass->ref_info_handle != 0");
  <D.24199>:
}


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

  D.24200 = klass->ref_info_handle;
  if (D.24200 != 0) goto <D.24201>; else goto <D.24202>;
  <D.24201>:
  D.24200 = klass->ref_info_handle;
  mono_gchandle_free (D.24200);
  klass->ref_info_handle = 0;
  <D.24202>:
}


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

  D.24203 = ainfo->cached;
  if (D.24203 == 0) goto <D.24204>; else goto <D.24205>;
  <D.24204>:
  monoeg_g_free (ainfo);
  <D.24205>:
}


mono_image_build_metadata (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.24206;
  unsigned int D.24207;
  int D.24210;
  unsigned int D.24213;
  unsigned int D.24214;
  unsigned int D.24215;
  guint32 * D.24216;
  unsigned char D.24217;
  long unsigned int D.24218;
  long unsigned int D.24219;
  guint32 * D.24220;
  struct MonoDynamicStream * D.24221;
  unsigned int D.24222;
  guint32 * D.24223;
  unsigned int D.24224;
  guint32 * D.24225;
  guint32 * D.24226;
  guint32 * D.24227;
  struct MonoArray * D.24228;
  long unsigned int D.24231;
  unsigned int D.24232;
  unsigned int D.24233;
  long unsigned int D.24234;
  char * D.24235;
  struct MonoReflectionMethodBuilder * D.24236;
  long unsigned int D.24237;
  struct MonoArray * D.24238;
  long unsigned int D.24241;
  unsigned int D.24242;
  unsigned int D.24243;
  char * D.24244;
  struct MonoReflectionFieldBuilder * D.24245;
  long unsigned int D.24246;
  int D.24247;
  int D.24248;
  void * iftmp.0;
  void * D.24252;
  long unsigned int D.24253;
  long unsigned int D.24254;
  struct MonoArray * D.24256;
  char * D.24259;
  int D.24260;
  long unsigned int D.24261;
  void * * D.24262;
  unsigned int D.24263;
  unsigned int D.24264;
  long unsigned int D.24265;
  long unsigned int D.24266;
  void * * D.24267;
  struct MonoString * D.24268;
  struct MonoString * D.24269;
  struct MonoArray * D.24270;
  struct MonoArray * D.24271;
  struct MonoArray * D.24274;
  struct MonoArray * D.24277;
  struct MonoGHashTable * D.24280;
  char * D.24283;
  long unsigned int D.24284;
  struct MonoArray * D.24285;
  long unsigned int D.24288;
  char * D.24289;
  int D.24290;
  int D.24291;
  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.24206 = MEM[(struct MonoObject *)assemblyb].vtable;
      domain = D.24206->domain;
      D.24207 = assembly->text_rva;
      if (D.24207 != 0) goto <D.24208>; else goto <D.24209>;
      <D.24208>:
      return;
      <D.24209>:
      assembly->text_rva = 8192;
      D.24210 = moduleb->is_main;
      if (D.24210 != 0) goto <D.24211>; else goto <D.24212>;
      <D.24211>:
      mono_image_emit_manifest (moduleb);
      <D.24212>:
      table = &assembly->tables[2];
      table->rows = 1;
      D.24213 = table->next_idx;
      D.24214 = D.24213 + 1;
      table->next_idx = D.24214;
      D.24215 = table->rows;
      alloc_table (table, D.24215);
      D.24216 = table->values;
      D.24217 = table->columns;
      D.24218 = (long unsigned int) D.24217;
      D.24219 = D.24218 * 4;
      values = D.24216 + D.24219;
      *values = 0;
      D.24220 = values + 4;
      D.24221 = &assembly->sheap;
      D.24222 = string_heap_insert (D.24221, "<Module>");
      *D.24220 = D.24222;
      D.24223 = values + 8;
      D.24221 = &assembly->sheap;
      D.24224 = string_heap_insert (D.24221, "");
      *D.24223 = D.24224;
      D.24225 = values + 12;
      *D.24225 = 0;
      D.24226 = values + 16;
      *D.24226 = 1;
      D.24227 = values + 20;
      *D.24227 = 1;
      D.24228 = moduleb->global_methods;
      if (D.24228 != 0B) goto <D.24229>; else goto <D.24230>;
      <D.24229>:
      table = &assembly->tables[6];
      D.24228 = moduleb->global_methods;
      D.24231 = mono_array_length (D.24228);
      D.24215 = table->rows;
      D.24232 = (unsigned int) D.24231;
      D.24233 = D.24215 + D.24232;
      table->rows = D.24233;
      D.24215 = table->rows;
      alloc_table (table, D.24215);
      i = 0;
      goto <D.20400>;
      <D.20399>:
      D.24234 = (long unsigned int) i;
      D.24228 = moduleb->global_methods;
      D.24235 = mono_array_addr_with_size (D.24228, 8, D.24234);
      D.24236 = MEM[(struct MonoReflectionMethodBuilder * *)D.24235];
      mono_image_get_method_info (D.24236, assembly);
      i = i + 1;
      <D.20400>:
      D.24234 = (long unsigned int) i;
      D.24228 = moduleb->global_methods;
      D.24237 = mono_array_length (D.24228);
      if (D.24234 < D.24237) goto <D.20399>; else goto <D.20401>;
      <D.20401>:
      <D.24230>:
      D.24238 = moduleb->global_fields;
      if (D.24238 != 0B) goto <D.24239>; else goto <D.24240>;
      <D.24239>:
      table = &assembly->tables[4];
      D.24238 = moduleb->global_fields;
      D.24241 = mono_array_length (D.24238);
      D.24215 = table->rows;
      D.24242 = (unsigned int) D.24241;
      D.24243 = D.24215 + D.24242;
      table->rows = D.24243;
      D.24215 = table->rows;
      alloc_table (table, D.24215);
      i = 0;
      goto <D.20403>;
      <D.20402>:
      D.24234 = (long unsigned int) i;
      D.24238 = moduleb->global_fields;
      D.24244 = mono_array_addr_with_size (D.24238, 8, D.24234);
      D.24245 = MEM[(struct MonoReflectionFieldBuilder * *)D.24244];
      mono_image_get_field_info (D.24245, assembly);
      i = i + 1;
      <D.20403>:
      D.24234 = (long unsigned int) i;
      D.24238 = moduleb->global_fields;
      D.24246 = mono_array_length (D.24238);
      if (D.24234 < D.24246) goto <D.20402>; else goto <D.20404>;
      <D.20404>:
      <D.24240>:
      table = &assembly->tables[0];
      alloc_table (table, 1);
      mono_image_fill_module_table (domain, moduleb, assembly);
      types.size = 0;
      D.24247 = moduleb->num_types;
      D.24248 = MAX_EXPR <D.24247, 16>;
      types.capacity = D.24248;
      D.24247 = moduleb->num_types;
      if (D.24247 > 16) goto <D.24250>; else goto <D.24251>;
      <D.24250>:
      D.24247 = moduleb->num_types;
      D.24252 = mono_gc_make_root_descr_all_refs (D.24247);
      D.24247 = moduleb->num_types;
      D.24253 = (long unsigned int) D.24247;
      D.24254 = D.24253 * 8;
      iftmp.0 = mono_gc_alloc_fixed (D.24254, D.24252);
      goto <D.24255>;
      <D.24251>:
      iftmp.0 = __builtin_alloca (128);
      <D.24255>:
      types.data = iftmp.0;
      D.24256 = moduleb->types;
      if (D.24256 != 0B) goto <D.24257>; else goto <D.24258>;
      <D.24257>:
      i = 0;
      goto <D.20407>;
      <D.20406>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24234 = (long unsigned int) i;
        D.24256 = moduleb->types;
        D.24259 = mono_array_addr_with_size (D.24256, 8, D.24234);
        type = MEM[(struct MonoReflectionTypeBuilder * *)D.24259];
        collect_types (&types, type);
      }
      i = i + 1;
      <D.20407>:
      D.24247 = moduleb->num_types;
      if (D.24247 > i) goto <D.20406>; else goto <D.20408>;
      <D.20408>:
      <D.24258>:
      D.24260 = types.size;
      D.24261 = (long unsigned int) D.24260;
      D.24262 = types.data;
      qsort (D.24262, D.24261, 8, compare_types_by_table_idx);
      table = &assembly->tables[2];
      D.24215 = table->rows;
      D.24260 = types.size;
      D.24263 = (unsigned int) D.24260;
      D.24264 = D.24215 + D.24263;
      table->rows = D.24264;
      D.24215 = table->rows;
      alloc_table (table, D.24215);
      i = 0;
      goto <D.20411>;
      <D.20410>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.24262 = types.data;
        D.24265 = (long unsigned int) i;
        D.24266 = D.24265 * 8;
        D.24267 = D.24262 + D.24266;
        tb = *D.24267;
        D.24268 = tb->nspace;
        D.24221 = &assembly->sheap;
        string_heap_insert_mstring (D.24221, D.24268);
      }
      i = i + 1;
      <D.20411>:
      D.24260 = types.size;
      if (D.24260 > i) goto <D.20410>; else goto <D.20412>;
      <D.20412>:
      i = 0;
      goto <D.20415>;
      <D.20414>:
      {
        struct MonoReflectionTypeBuilder * tb;

        D.24262 = types.data;
        D.24265 = (long unsigned int) i;
        D.24266 = D.24265 * 8;
        D.24267 = D.24262 + D.24266;
        tb = *D.24267;
        D.24269 = tb->name;
        D.24221 = &assembly->sheap;
        string_heap_insert_mstring (D.24221, D.24269);
      }
      i = i + 1;
      <D.20415>:
      D.24260 = types.size;
      if (D.24260 > i) goto <D.20414>; else goto <D.20416>;
      <D.20416>:
      i = 0;
      goto <D.20419>;
      <D.20418>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24262 = types.data;
        D.24265 = (long unsigned int) i;
        D.24266 = D.24265 * 8;
        D.24267 = D.24262 + D.24266;
        type = *D.24267;
        mono_image_get_type_info (domain, type, assembly);
      }
      i = i + 1;
      <D.20419>:
      D.24260 = types.size;
      if (D.24260 > i) goto <D.20418>; else goto <D.20420>;
      <D.20420>:
      D.24270 = assemblyb->cattrs;
      mono_image_add_cattrs (assembly, 1, 14, D.24270);
      D.24271 = assemblyb->permissions_minimum;
      if (D.24271 != 0B) goto <D.24272>; else goto <D.24273>;
      <D.24272>:
      D.24271 = assemblyb->permissions_minimum;
      mono_image_add_decl_security (assembly, 536870913, D.24271);
      <D.24273>:
      D.24274 = assemblyb->permissions_optional;
      if (D.24274 != 0B) goto <D.24275>; else goto <D.24276>;
      <D.24275>:
      D.24274 = assemblyb->permissions_optional;
      mono_image_add_decl_security (assembly, 536870913, D.24274);
      <D.24276>:
      D.24277 = assemblyb->permissions_refused;
      if (D.24277 != 0B) goto <D.24278>; else goto <D.24279>;
      <D.24278>:
      D.24277 = assemblyb->permissions_refused;
      mono_image_add_decl_security (assembly, 536870913, D.24277);
      <D.24279>:
      module_add_cattrs (assembly, moduleb);
      D.24280 = assembly->token_fixups;
      mono_g_hash_table_foreach (D.24280, fixup_method, assembly);
      D.24228 = moduleb->global_methods;
      if (D.24228 != 0B) goto <D.24281>; else goto <D.24282>;
      <D.24281>:
      i = 0;
      goto <D.20423>;
      <D.20422>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.24234 = (long unsigned int) i;
        D.24228 = moduleb->global_methods;
        D.24283 = mono_array_addr_with_size (D.24228, 8, D.24234);
        mb = MEM[(struct MonoReflectionMethodBuilder * *)D.24283];
        mono_image_add_methodimpl (assembly, mb);
      }
      i = i + 1;
      <D.20423>:
      D.24234 = (long unsigned int) i;
      D.24228 = moduleb->global_methods;
      D.24284 = mono_array_length (D.24228);
      if (D.24234 < D.24284) goto <D.20422>; else goto <D.20424>;
      <D.20424>:
      <D.24282>:
      i = 0;
      goto <D.20431>;
      <D.20430>:
      {
        struct MonoReflectionTypeBuilder * type;

        D.24262 = types.data;
        D.24265 = (long unsigned int) i;
        D.24266 = D.24265 * 8;
        D.24267 = D.24262 + D.24266;
        type = *D.24267;
        D.24285 = type->methods;
        if (D.24285 != 0B) goto <D.24286>; else goto <D.24287>;
        <D.24286>:
        j = 0;
        goto <D.20428>;
        <D.20427>:
        {
          struct MonoReflectionMethodBuilder * mb;

          D.24288 = (long unsigned int) j;
          D.24285 = type->methods;
          D.24289 = mono_array_addr_with_size (D.24285, 8, D.24288);
          mb = MEM[(struct MonoReflectionMethodBuilder * *)D.24289];
          mono_image_add_methodimpl (assembly, mb);
        }
        j = j + 1;
        <D.20428>:
        D.24290 = type->num_methods;
        if (D.24290 > j) goto <D.20427>; else goto <D.20429>;
        <D.20429>:
        <D.24287>:
      }
      i = i + 1;
      <D.20431>:
      D.24260 = types.size;
      if (D.24260 > i) goto <D.20430>; else goto <D.20432>;
      <D.20432>:
      D.24291 = types.capacity;
      if (D.24291 > 16) goto <D.24292>; else goto <D.24293>;
      <D.24292>:
      D.24262 = types.data;
      mono_gc_free_fixed (D.24262);
      <D.24293>:
      fixup_cattrs (assembly);
    }
  finally
    {
      types = {CLOBBER};
    }
}


fixup_method (struct MonoReflectionILGen * ilgen, void * value, struct MonoDynamicImage * assembly)
{
  long int value.1;
  long unsigned int D.24298;
  struct MonoArray * D.24299;
  char * D.24300;
  sizetype D.24301;
  int D.24302;
  sizetype D.24303;
  sizetype D.24304;
  unsigned char * D.24305;
  unsigned char D.24306;
  int D.24307;
  int D.20069;
  int iftmp.2;
  int D.20068;
  struct MonoObject * D.24311;
  struct MonoVTable * D.24312;
  struct MonoClass * D.24313;
  const char[13] * D.24314;
  unsigned char D.24315;
  int D.24316;
  unsigned char D.24317;
  int D.24318;
  _Bool D.24319;
  _Bool D.24320;
  _Bool D.24321;
  const unsigned char * D.24324;
  unsigned char D.24325;
  int D.24326;
  const unsigned char * D.24327;
  unsigned char D.24328;
  int D.24329;
  _Bool D.24330;
  _Bool D.24331;
  const unsigned char * D.24334;
  unsigned char D.24335;
  int D.24336;
  const unsigned char * D.24337;
  unsigned char D.24338;
  int D.24339;
  _Bool D.24340;
  _Bool D.24341;
  const unsigned char * D.24344;
  unsigned char D.24345;
  int D.24346;
  const unsigned char * D.24347;
  unsigned char D.24348;
  int D.24349;
  const char * D.24351;
  int D.24354;
  int D.20078;
  int iftmp.3;
  int D.20077;
  const char[10] * D.24359;
  unsigned char D.24360;
  int D.24361;
  unsigned char D.24362;
  int D.24363;
  _Bool D.24364;
  _Bool D.24365;
  _Bool D.24366;
  const unsigned char * D.24369;
  unsigned char D.24370;
  int D.24371;
  const unsigned char * D.24372;
  unsigned char D.24373;
  int D.24374;
  _Bool D.24375;
  _Bool D.24376;
  const unsigned char * D.24379;
  unsigned char D.24380;
  int D.24381;
  const unsigned char * D.24382;
  unsigned char D.24383;
  int D.24384;
  _Bool D.24385;
  _Bool D.24386;
  const unsigned char * D.24389;
  unsigned char D.24390;
  int D.24391;
  const unsigned char * D.24392;
  unsigned char D.24393;
  int D.24394;
  struct GHashTable * D.24398;
  void * D.24399;
  long int D.24400;
  int D.20090;
  int iftmp.4;
  int D.20089;
  const char[14] * D.24405;
  unsigned char D.24406;
  int D.24407;
  unsigned char D.24408;
  int D.24409;
  _Bool D.24410;
  _Bool D.24411;
  _Bool D.24412;
  const unsigned char * D.24415;
  unsigned char D.24416;
  int D.24417;
  const unsigned char * D.24418;
  unsigned char D.24419;
  int D.24420;
  _Bool D.24421;
  _Bool D.24422;
  const unsigned char * D.24425;
  unsigned char D.24426;
  int D.24427;
  const unsigned char * D.24428;
  unsigned char D.24429;
  int D.24430;
  _Bool D.24431;
  _Bool D.24432;
  const unsigned char * D.24435;
  unsigned char D.24436;
  int D.24437;
  const unsigned char * D.24438;
  unsigned char D.24439;
  int D.24440;
  int D.20099;
  int iftmp.5;
  int D.20098;
  const char[19] * D.24448;
  unsigned char D.24449;
  int D.24450;
  unsigned char D.24451;
  int D.24452;
  _Bool D.24453;
  _Bool D.24454;
  _Bool D.24455;
  const unsigned char * D.24458;
  unsigned char D.24459;
  int D.24460;
  const unsigned char * D.24461;
  unsigned char D.24462;
  int D.24463;
  _Bool D.24464;
  _Bool D.24465;
  const unsigned char * D.24468;
  unsigned char D.24469;
  int D.24470;
  const unsigned char * D.24471;
  unsigned char D.24472;
  int D.24473;
  _Bool D.24474;
  _Bool D.24475;
  const unsigned char * D.24478;
  unsigned char D.24479;
  int D.24480;
  const unsigned char * D.24481;
  unsigned char D.24482;
  int D.24483;
  int D.20108;
  int iftmp.6;
  int D.20107;
  const char[11] * D.24494;
  unsigned char D.24495;
  int D.24496;
  unsigned char D.24497;
  int D.24498;
  _Bool D.24499;
  _Bool D.24500;
  _Bool D.24501;
  const unsigned char * D.24504;
  unsigned char D.24505;
  int D.24506;
  const unsigned char * D.24507;
  unsigned char D.24508;
  int D.24509;
  _Bool D.24510;
  _Bool D.24511;
  const unsigned char * D.24514;
  unsigned char D.24515;
  int D.24516;
  const unsigned char * D.24517;
  unsigned char D.24518;
  int D.24519;
  _Bool D.24520;
  _Bool D.24521;
  const unsigned char * D.24524;
  unsigned char D.24525;
  int D.24526;
  const unsigned char * D.24527;
  unsigned char D.24528;
  int D.24529;
  int D.20117;
  int iftmp.7;
  int D.20116;
  const char[12] * D.24535;
  unsigned char D.24536;
  int D.24537;
  unsigned char D.24538;
  int D.24539;
  _Bool D.24540;
  _Bool D.24541;
  _Bool D.24542;
  const unsigned char * D.24545;
  unsigned char D.24546;
  int D.24547;
  const unsigned char * D.24548;
  unsigned char D.24549;
  int D.24550;
  _Bool D.24551;
  _Bool D.24552;
  const unsigned char * D.24555;
  unsigned char D.24556;
  int D.24557;
  const unsigned char * D.24558;
  unsigned char D.24559;
  int D.24560;
  _Bool D.24561;
  _Bool D.24562;
  const unsigned char * D.24565;
  unsigned char D.24566;
  int D.24567;
  const unsigned char * D.24568;
  unsigned char D.24569;
  int D.24570;
  struct GHashTable * D.24572;
  void * D.24573;
  long int D.24574;
  int D.20128;
  int iftmp.8;
  int D.20127;
  const char[12] * D.24578;
  unsigned char D.24579;
  int D.24580;
  unsigned char D.24581;
  int D.24582;
  _Bool D.24583;
  _Bool D.24584;
  _Bool D.24585;
  const unsigned char * D.24588;
  unsigned char D.24589;
  int D.24590;
  const unsigned char * D.24591;
  unsigned char D.24592;
  int D.24593;
  _Bool D.24594;
  _Bool D.24595;
  const unsigned char * D.24598;
  unsigned char D.24599;
  int D.24600;
  const unsigned char * D.24601;
  unsigned char D.24602;
  int D.24603;
  _Bool D.24604;
  _Bool D.24605;
  const unsigned char * D.24608;
  unsigned char D.24609;
  int D.24610;
  const unsigned char * D.24611;
  unsigned char D.24612;
  int D.24613;
  int D.20138;
  int iftmp.9;
  int D.20137;
  const char[16] * D.24620;
  unsigned char D.24621;
  int D.24622;
  unsigned char D.24623;
  int D.24624;
  _Bool D.24625;
  _Bool D.24626;
  _Bool D.24627;
  const unsigned char * D.24630;
  unsigned char D.24631;
  int D.24632;
  const unsigned char * D.24633;
  unsigned char D.24634;
  int D.24635;
  _Bool D.24636;
  _Bool D.24637;
  const unsigned char * D.24640;
  unsigned char D.24641;
  int D.24642;
  const unsigned char * D.24643;
  unsigned char D.24644;
  int D.24645;
  _Bool D.24646;
  _Bool D.24647;
  const unsigned char * D.24650;
  unsigned char D.24651;
  int D.24652;
  const unsigned char * D.24653;
  unsigned char D.24654;
  int D.24655;
  int D.20147;
  int iftmp.10;
  int D.20146;
  unsigned char D.24665;
  int D.24666;
  _Bool D.24667;
  _Bool D.24668;
  _Bool D.24669;
  const unsigned char * D.24672;
  unsigned char D.24673;
  int D.24674;
  _Bool D.24675;
  _Bool D.24676;
  const unsigned char * D.24679;
  unsigned char D.24680;
  int D.24681;
  _Bool D.24682;
  _Bool D.24683;
  const unsigned char * D.24686;
  unsigned char D.24687;
  int D.24688;
  int D.20156;
  int iftmp.11;
  int D.20155;
  unsigned char D.24694;
  int D.24695;
  _Bool D.24696;
  _Bool D.24697;
  _Bool D.24698;
  const unsigned char * D.24701;
  unsigned char D.24702;
  int D.24703;
  _Bool D.24704;
  _Bool D.24705;
  const unsigned char * D.24708;
  unsigned char D.24709;
  int D.24710;
  _Bool D.24711;
  _Bool D.24712;
  const unsigned char * D.24715;
  unsigned char D.24716;
  int D.24717;
  int D.20165;
  int iftmp.12;
  int D.20164;
  const char[18] * D.24723;
  unsigned char D.24724;
  int D.24725;
  unsigned char D.24726;
  int D.24727;
  _Bool D.24728;
  _Bool D.24729;
  _Bool D.24730;
  const unsigned char * D.24733;
  unsigned char D.24734;
  int D.24735;
  const unsigned char * D.24736;
  unsigned char D.24737;
  int D.24738;
  _Bool D.24739;
  _Bool D.24740;
  const unsigned char * D.24743;
  unsigned char D.24744;
  int D.24745;
  const unsigned char * D.24746;
  unsigned char D.24747;
  int D.24748;
  _Bool D.24749;
  _Bool D.24750;
  const unsigned char * D.24753;
  unsigned char D.24754;
  int D.24755;
  const unsigned char * D.24756;
  unsigned char D.24757;
  int D.24758;
  int D.20174;
  int iftmp.13;
  int D.20173;
  const char[19] * D.24764;
  unsigned char D.24765;
  int D.24766;
  unsigned char D.24767;
  int D.24768;
  _Bool D.24769;
  _Bool D.24770;
  _Bool D.24771;
  const unsigned char * D.24774;
  unsigned char D.24775;
  int D.24776;
  const unsigned char * D.24777;
  unsigned char D.24778;
  int D.24779;
  _Bool D.24780;
  _Bool D.24781;
  const unsigned char * D.24784;
  unsigned char D.24785;
  int D.24786;
  const unsigned char * D.24787;
  unsigned char D.24788;
  int D.24789;
  _Bool D.24790;
  _Bool D.24791;
  const unsigned char * D.24794;
  unsigned char D.24795;
  int D.24796;
  const unsigned char * D.24797;
  unsigned char D.24798;
  int D.24799;
  int iftmp.14;
  struct MonoClass * D.24804;
  struct MonoGenericClass * D.24805;
  struct MonoGenericContainer * D.24807;
  _Bool D.24809;
  long int D.24810;
  long int D.24811;
  int D.20185;
  int iftmp.15;
  int D.20184;
  unsigned char D.24817;
  int D.24818;
  _Bool D.24819;
  _Bool D.24820;
  _Bool D.24821;
  const unsigned char * D.24824;
  unsigned char D.24825;
  int D.24826;
  _Bool D.24827;
  _Bool D.24828;
  const unsigned char * D.24831;
  unsigned char D.24832;
  int D.24833;
  _Bool D.24834;
  _Bool D.24835;
  const unsigned char * D.24838;
  unsigned char D.24839;
  int D.24840;
  int D.20194;
  int iftmp.16;
  int D.20193;
  unsigned char D.24847;
  int D.24848;
  _Bool D.24849;
  _Bool D.24850;
  _Bool D.24851;
  const unsigned char * D.24854;
  unsigned char D.24855;
  int D.24856;
  _Bool D.24857;
  _Bool D.24858;
  const unsigned char * D.24861;
  unsigned char D.24862;
  int D.24863;
  _Bool D.24864;
  _Bool D.24865;
  const unsigned char * D.24868;
  unsigned char D.24869;
  int D.24870;
  int D.24874;
  _Bool D.24875;
  long int D.24876;
  long int D.24877;
  int D.20204;
  int iftmp.17;
  int D.20203;
  unsigned char D.24885;
  int D.24886;
  _Bool D.24887;
  _Bool D.24888;
  _Bool D.24889;
  const unsigned char * D.24892;
  unsigned char D.24893;
  int D.24894;
  _Bool D.24895;
  _Bool D.24896;
  const unsigned char * D.24899;
  unsigned char D.24900;
  int D.24901;
  _Bool D.24902;
  _Bool D.24903;
  const unsigned char * D.24906;
  unsigned char D.24907;
  int D.24908;
  int D.20213;
  int iftmp.18;
  int D.20212;
  unsigned char D.24914;
  int D.24915;
  _Bool D.24916;
  _Bool D.24917;
  _Bool D.24918;
  const unsigned char * D.24921;
  unsigned char D.24922;
  int D.24923;
  _Bool D.24924;
  _Bool D.24925;
  const unsigned char * D.24928;
  unsigned char D.24929;
  int D.24930;
  _Bool D.24931;
  _Bool D.24932;
  const unsigned char * D.24935;
  unsigned char D.24936;
  int D.24937;
  int D.20222;
  int iftmp.19;
  int D.20221;
  const char[23] * D.24942;
  unsigned char D.24943;
  int D.24944;
  unsigned char D.24945;
  int D.24946;
  _Bool D.24947;
  _Bool D.24948;
  _Bool D.24949;
  const unsigned char * D.24952;
  unsigned char D.24953;
  int D.24954;
  const unsigned char * D.24955;
  unsigned char D.24956;
  int D.24957;
  _Bool D.24958;
  _Bool D.24959;
  const unsigned char * D.24962;
  unsigned char D.24963;
  int D.24964;
  const unsigned char * D.24965;
  unsigned char D.24966;
  int D.24967;
  _Bool D.24968;
  _Bool D.24969;
  const unsigned char * D.24972;
  unsigned char D.24973;
  int D.24974;
  const unsigned char * D.24975;
  unsigned char D.24976;
  int D.24977;
  int D.20231;
  int iftmp.20;
  int D.20230;
  const char[24] * D.24984;
  unsigned char D.24985;
  int D.24986;
  unsigned char D.24987;
  int D.24988;
  _Bool D.24989;
  _Bool D.24990;
  _Bool D.24991;
  const unsigned char * D.24994;
  unsigned char D.24995;
  int D.24996;
  const unsigned char * D.24997;
  unsigned char D.24998;
  int D.24999;
  _Bool D.25000;
  _Bool D.25001;
  const unsigned char * D.25004;
  unsigned char D.25005;
  int D.25006;
  const unsigned char * D.25007;
  unsigned char D.25008;
  int D.25009;
  _Bool D.25010;
  _Bool D.25011;
  const unsigned char * D.25014;
  unsigned char D.25015;
  int D.25016;
  const unsigned char * D.25017;
  unsigned char D.25018;
  int D.25019;
  int D.20240;
  int iftmp.21;
  int D.20239;
  const char[29] * D.25026;
  unsigned char D.25027;
  int D.25028;
  unsigned char D.25029;
  int D.25030;
  _Bool D.25031;
  _Bool D.25032;
  _Bool D.25033;
  const unsigned char * D.25036;
  unsigned char D.25037;
  int D.25038;
  const unsigned char * D.25039;
  unsigned char D.25040;
  int D.25041;
  _Bool D.25042;
  _Bool D.25043;
  const unsigned char * D.25046;
  unsigned char D.25047;
  int D.25048;
  const unsigned char * D.25049;
  unsigned char D.25050;
  int D.25051;
  _Bool D.25052;
  _Bool D.25053;
  const unsigned char * D.25056;
  unsigned char D.25057;
  int D.25058;
  const unsigned char * D.25059;
  unsigned char D.25060;
  int D.25061;
  int D.20250;
  int iftmp.22;
  int D.20249;
  unsigned char D.25068;
  int D.25069;
  _Bool D.25070;
  _Bool D.25071;
  _Bool D.25072;
  const unsigned char * D.25075;
  unsigned char D.25076;
  int D.25077;
  _Bool D.25078;
  _Bool D.25079;
  const unsigned char * D.25082;
  unsigned char D.25083;
  int D.25084;
  _Bool D.25085;
  _Bool D.25086;
  const unsigned char * D.25089;
  unsigned char D.25090;
  int D.25091;
  struct MonoMethodSignature * D.25095;
  short unsigned int D.25096;
  _Bool D.25097;
  long int D.25098;
  long int D.25099;
  int D.20260;
  int iftmp.23;
  int D.20259;
  unsigned char D.25105;
  int D.25106;
  _Bool D.25107;
  _Bool D.25108;
  _Bool D.25109;
  const unsigned char * D.25112;
  unsigned char D.25113;
  int D.25114;
  _Bool D.25115;
  _Bool D.25116;
  const unsigned char * D.25119;
  unsigned char D.25120;
  int D.25121;
  _Bool D.25122;
  _Bool D.25123;
  const unsigned char * D.25126;
  unsigned char D.25127;
  int D.25128;
  int D.20269;
  int iftmp.24;
  int D.20268;
  unsigned char D.25135;
  int D.25136;
  _Bool D.25137;
  _Bool D.25138;
  _Bool D.25139;
  const unsigned char * D.25142;
  unsigned char D.25143;
  int D.25144;
  _Bool D.25145;
  _Bool D.25146;
  const unsigned char * D.25149;
  unsigned char D.25150;
  int D.25151;
  _Bool D.25152;
  _Bool D.25153;
  const unsigned char * D.25156;
  unsigned char D.25157;
  int D.25158;
  unsigned char D.25162;
  unsigned char * D.25163;
  unsigned int D.25164;
  unsigned char D.25165;
  unsigned char * D.25166;
  unsigned int D.25167;
  unsigned char D.25168;
  int D.25169;
  unsigned int D.25170;
  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.20273>;
  <D.20272>:
  D.24298 = (long unsigned int) i;
  D.24299 = ilgen->token_fixups;
  iltoken = mono_array_addr_with_size (D.24299, 16, D.24298);
  D.24300 = assembly->code.data;
  D.24301 = (sizetype) code_idx;
  D.24302 = iltoken->code_pos;
  D.24303 = (sizetype) D.24302;
  D.24304 = D.24301 + D.24303;
  target = D.24300 + D.24304;
  D.24305 = target + 3;
  D.24306 = *D.24305;
  D.24307 = (int) D.24306;
  switch (D.24307) <default: <D.20270>, case 2: <D.20119>, case 4: <D.20060>, case 6: <D.20081>, case 10: <D.20129>, case 43: <D.20241>>
  <D.20060>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24314 = "FieldBuilder";
      D.24315 = MEM[(const unsigned char *)D.24314];
      D.24316 = (int) D.24315;
      D.24317 = *__s2;
      D.24318 = (int) D.24317;
      __result = D.24316 - D.24318;
      {
        D.24319 = __s2_len != 0;
        D.24320 = __result == 0;
        D.24321 = D.24319 & D.24320;
        if (D.24321 != 0) goto <D.24322>; else goto <D.24323>;
        <D.24322>:
        D.24324 = &MEM[(void *)"FieldBuilder" + 1B];
        D.24325 = *D.24324;
        D.24326 = (int) D.24325;
        D.24327 = __s2 + 1;
        D.24328 = *D.24327;
        D.24329 = (int) D.24328;
        __result = D.24326 - D.24329;
        D.24330 = __s2_len > 1;
        D.24320 = __result == 0;
        D.24331 = D.24330 & D.24320;
        if (D.24331 != 0) goto <D.24332>; else goto <D.24333>;
        <D.24332>:
        D.24334 = &MEM[(void *)"FieldBuilder" + 2B];
        D.24335 = *D.24334;
        D.24336 = (int) D.24335;
        D.24337 = __s2 + 2;
        D.24338 = *D.24337;
        D.24339 = (int) D.24338;
        __result = D.24336 - D.24339;
        D.24340 = __s2_len > 2;
        D.24320 = __result == 0;
        D.24341 = D.24340 & D.24320;
        if (D.24341 != 0) goto <D.24342>; else goto <D.24343>;
        <D.24342>:
        D.24344 = &MEM[(void *)"FieldBuilder" + 3B];
        D.24345 = *D.24344;
        D.24346 = (int) D.24345;
        D.24347 = __s2 + 3;
        D.24348 = *D.24347;
        D.24349 = (int) D.24348;
        __result = D.24346 - D.24349;
        <D.24343>:
        <D.24333>:
        <D.24323>:
      }
      D.20068 = __result;
    }
    iftmp.2 = -D.20068;
    goto <D.24350>;
    <D.24310>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.2 = __builtin_strcmp (D.24351, "FieldBuilder");
    <D.24350>:
    D.20069 = iftmp.2;
  }
  if (D.20069 == 0) goto <D.24352>; else goto <D.24353>;
  <D.24352>:
  field = iltoken->member;
  D.24354 = field->table_idx;
  idx = (guint32) D.24354;
  goto <D.24355>;
  <D.24353>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24359 = "MonoField";
      D.24360 = MEM[(const unsigned char *)D.24359];
      D.24361 = (int) D.24360;
      D.24362 = *__s2;
      D.24363 = (int) D.24362;
      __result = D.24361 - D.24363;
      {
        D.24364 = __s2_len != 0;
        D.24365 = __result == 0;
        D.24366 = D.24364 & D.24365;
        if (D.24366 != 0) goto <D.24367>; else goto <D.24368>;
        <D.24367>:
        D.24369 = &MEM[(void *)"MonoField" + 1B];
        D.24370 = *D.24369;
        D.24371 = (int) D.24370;
        D.24372 = __s2 + 1;
        D.24373 = *D.24372;
        D.24374 = (int) D.24373;
        __result = D.24371 - D.24374;
        D.24375 = __s2_len > 1;
        D.24365 = __result == 0;
        D.24376 = D.24375 & D.24365;
        if (D.24376 != 0) goto <D.24377>; else goto <D.24378>;
        <D.24377>:
        D.24379 = &MEM[(void *)"MonoField" + 2B];
        D.24380 = *D.24379;
        D.24381 = (int) D.24380;
        D.24382 = __s2 + 2;
        D.24383 = *D.24382;
        D.24384 = (int) D.24383;
        __result = D.24381 - D.24384;
        D.24385 = __s2_len > 2;
        D.24365 = __result == 0;
        D.24386 = D.24385 & D.24365;
        if (D.24386 != 0) goto <D.24387>; else goto <D.24388>;
        <D.24387>:
        D.24389 = &MEM[(void *)"MonoField" + 3B];
        D.24390 = *D.24389;
        D.24391 = (int) D.24390;
        D.24392 = __s2 + 3;
        D.24393 = *D.24392;
        D.24394 = (int) D.24393;
        __result = D.24391 - D.24394;
        <D.24388>:
        <D.24378>:
        <D.24368>:
      }
      D.20077 = __result;
    }
    iftmp.3 = -D.20077;
    goto <D.24395>;
    <D.24358>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.3 = __builtin_strcmp (D.24351, "MonoField");
    <D.24395>:
    D.20078 = iftmp.3;
  }
  if (D.20078 == 0) goto <D.24396>; else goto <D.24397>;
  <D.24396>:
  {
    struct MonoClassField * f;

    D.24311 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.24311].field;
    D.24398 = assembly->field_to_table_idx;
    D.24399 = monoeg_g_hash_table_lookup (D.24398, f);
    D.24400 = (long int) D.24399;
    idx = (guint32) D.24400;
  }
  goto <D.24401>;
  <D.24397>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4237);
  <D.24401>:
  <D.24355>:
  goto <D.20080>;
  <D.20081>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24405 = "MethodBuilder";
      D.24406 = MEM[(const unsigned char *)D.24405];
      D.24407 = (int) D.24406;
      D.24408 = *__s2;
      D.24409 = (int) D.24408;
      __result = D.24407 - D.24409;
      {
        D.24410 = __s2_len != 0;
        D.24411 = __result == 0;
        D.24412 = D.24410 & D.24411;
        if (D.24412 != 0) goto <D.24413>; else goto <D.24414>;
        <D.24413>:
        D.24415 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24416 = *D.24415;
        D.24417 = (int) D.24416;
        D.24418 = __s2 + 1;
        D.24419 = *D.24418;
        D.24420 = (int) D.24419;
        __result = D.24417 - D.24420;
        D.24421 = __s2_len > 1;
        D.24411 = __result == 0;
        D.24422 = D.24421 & D.24411;
        if (D.24422 != 0) goto <D.24423>; else goto <D.24424>;
        <D.24423>:
        D.24425 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24426 = *D.24425;
        D.24427 = (int) D.24426;
        D.24428 = __s2 + 2;
        D.24429 = *D.24428;
        D.24430 = (int) D.24429;
        __result = D.24427 - D.24430;
        D.24431 = __s2_len > 2;
        D.24411 = __result == 0;
        D.24432 = D.24431 & D.24411;
        if (D.24432 != 0) goto <D.24433>; else goto <D.24434>;
        <D.24433>:
        D.24435 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24436 = *D.24435;
        D.24437 = (int) D.24436;
        D.24438 = __s2 + 3;
        D.24439 = *D.24438;
        D.24440 = (int) D.24439;
        __result = D.24437 - D.24440;
        <D.24434>:
        <D.24424>:
        <D.24414>:
      }
      D.20089 = __result;
    }
    iftmp.4 = -D.20089;
    goto <D.24441>;
    <D.24404>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.4 = __builtin_strcmp (D.24351, "MethodBuilder");
    <D.24441>:
    D.20090 = iftmp.4;
  }
  if (D.20090 == 0) goto <D.24442>; else goto <D.24443>;
  <D.24442>:
  method = iltoken->member;
  idx = method->table_idx;
  goto <D.24444>;
  <D.24443>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24448 = "ConstructorBuilder";
      D.24449 = MEM[(const unsigned char *)D.24448];
      D.24450 = (int) D.24449;
      D.24451 = *__s2;
      D.24452 = (int) D.24451;
      __result = D.24450 - D.24452;
      {
        D.24453 = __s2_len != 0;
        D.24454 = __result == 0;
        D.24455 = D.24453 & D.24454;
        if (D.24455 != 0) goto <D.24456>; else goto <D.24457>;
        <D.24456>:
        D.24458 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24459 = *D.24458;
        D.24460 = (int) D.24459;
        D.24461 = __s2 + 1;
        D.24462 = *D.24461;
        D.24463 = (int) D.24462;
        __result = D.24460 - D.24463;
        D.24464 = __s2_len > 1;
        D.24454 = __result == 0;
        D.24465 = D.24464 & D.24454;
        if (D.24465 != 0) goto <D.24466>; else goto <D.24467>;
        <D.24466>:
        D.24468 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24469 = *D.24468;
        D.24470 = (int) D.24469;
        D.24471 = __s2 + 2;
        D.24472 = *D.24471;
        D.24473 = (int) D.24472;
        __result = D.24470 - D.24473;
        D.24474 = __s2_len > 2;
        D.24454 = __result == 0;
        D.24475 = D.24474 & D.24454;
        if (D.24475 != 0) goto <D.24476>; else goto <D.24477>;
        <D.24476>:
        D.24478 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24479 = *D.24478;
        D.24480 = (int) D.24479;
        D.24481 = __s2 + 3;
        D.24482 = *D.24481;
        D.24483 = (int) D.24482;
        __result = D.24480 - D.24483;
        <D.24477>:
        <D.24467>:
        <D.24457>:
      }
      D.20098 = __result;
    }
    iftmp.5 = -D.20098;
    goto <D.24484>;
    <D.24447>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.5 = __builtin_strcmp (D.24351, "ConstructorBuilder");
    <D.24484>:
    D.20099 = iftmp.5;
  }
  if (D.20099 == 0) goto <D.24485>; else goto <D.24486>;
  <D.24485>:
  ctor = iltoken->member;
  idx = ctor->table_idx;
  goto <D.24487>;
  <D.24486>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24494 = "MonoMethod";
      D.24495 = MEM[(const unsigned char *)D.24494];
      D.24496 = (int) D.24495;
      D.24497 = *__s2;
      D.24498 = (int) D.24497;
      __result = D.24496 - D.24498;
      {
        D.24499 = __s2_len != 0;
        D.24500 = __result == 0;
        D.24501 = D.24499 & D.24500;
        if (D.24501 != 0) goto <D.24502>; else goto <D.24503>;
        <D.24502>:
        D.24504 = &MEM[(void *)"MonoMethod" + 1B];
        D.24505 = *D.24504;
        D.24506 = (int) D.24505;
        D.24507 = __s2 + 1;
        D.24508 = *D.24507;
        D.24509 = (int) D.24508;
        __result = D.24506 - D.24509;
        D.24510 = __s2_len > 1;
        D.24500 = __result == 0;
        D.24511 = D.24510 & D.24500;
        if (D.24511 != 0) goto <D.24512>; else goto <D.24513>;
        <D.24512>:
        D.24514 = &MEM[(void *)"MonoMethod" + 2B];
        D.24515 = *D.24514;
        D.24516 = (int) D.24515;
        D.24517 = __s2 + 2;
        D.24518 = *D.24517;
        D.24519 = (int) D.24518;
        __result = D.24516 - D.24519;
        D.24520 = __s2_len > 2;
        D.24500 = __result == 0;
        D.24521 = D.24520 & D.24500;
        if (D.24521 != 0) goto <D.24522>; else goto <D.24523>;
        <D.24522>:
        D.24524 = &MEM[(void *)"MonoMethod" + 3B];
        D.24525 = *D.24524;
        D.24526 = (int) D.24525;
        D.24527 = __s2 + 3;
        D.24528 = *D.24527;
        D.24529 = (int) D.24528;
        __result = D.24526 - D.24529;
        <D.24523>:
        <D.24513>:
        <D.24503>:
      }
      D.20107 = __result;
    }
    iftmp.6 = -D.20107;
    goto <D.24530>;
    <D.24493>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.6 = __builtin_strcmp (D.24351, "MonoMethod");
    <D.24530>:
    D.20108 = iftmp.6;
  }
  if (D.20108 == 0) goto <D.24488>; else goto <D.24531>;
  <D.24531>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24535 = "MonoCMethod";
      D.24536 = MEM[(const unsigned char *)D.24535];
      D.24537 = (int) D.24536;
      D.24538 = *__s2;
      D.24539 = (int) D.24538;
      __result = D.24537 - D.24539;
      {
        D.24540 = __s2_len != 0;
        D.24541 = __result == 0;
        D.24542 = D.24540 & D.24541;
        if (D.24542 != 0) goto <D.24543>; else goto <D.24544>;
        <D.24543>:
        D.24545 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24546 = *D.24545;
        D.24547 = (int) D.24546;
        D.24548 = __s2 + 1;
        D.24549 = *D.24548;
        D.24550 = (int) D.24549;
        __result = D.24547 - D.24550;
        D.24551 = __s2_len > 1;
        D.24541 = __result == 0;
        D.24552 = D.24551 & D.24541;
        if (D.24552 != 0) goto <D.24553>; else goto <D.24554>;
        <D.24553>:
        D.24555 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24556 = *D.24555;
        D.24557 = (int) D.24556;
        D.24558 = __s2 + 2;
        D.24559 = *D.24558;
        D.24560 = (int) D.24559;
        __result = D.24557 - D.24560;
        D.24561 = __s2_len > 2;
        D.24541 = __result == 0;
        D.24562 = D.24561 & D.24541;
        if (D.24562 != 0) goto <D.24563>; else goto <D.24564>;
        <D.24563>:
        D.24565 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24566 = *D.24565;
        D.24567 = (int) D.24566;
        D.24568 = __s2 + 3;
        D.24569 = *D.24568;
        D.24570 = (int) D.24569;
        __result = D.24567 - D.24570;
        <D.24564>:
        <D.24554>:
        <D.24544>:
      }
      D.20116 = __result;
    }
    iftmp.7 = -D.20116;
    goto <D.24571>;
    <D.24534>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.7 = __builtin_strcmp (D.24351, "MonoCMethod");
    <D.24571>:
    D.20117 = iftmp.7;
  }
  if (D.20117 == 0) goto <D.24488>; else goto <D.24489>;
  <D.24488>:
  {
    struct MonoMethod * m;

    D.24311 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24311].method;
    D.24572 = assembly->method_to_table_idx;
    D.24573 = monoeg_g_hash_table_lookup (D.24572, m);
    D.24574 = (long int) D.24573;
    idx = (guint32) D.24574;
  }
  goto <D.24490>;
  <D.24489>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4252);
  <D.24490>:
  <D.24487>:
  <D.24444>:
  goto <D.20080>;
  <D.20119>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24578 = "TypeBuilder";
      D.24579 = MEM[(const unsigned char *)D.24578];
      D.24580 = (int) D.24579;
      D.24581 = *__s2;
      D.24582 = (int) D.24581;
      __result = D.24580 - D.24582;
      {
        D.24583 = __s2_len != 0;
        D.24584 = __result == 0;
        D.24585 = D.24583 & D.24584;
        if (D.24585 != 0) goto <D.24586>; else goto <D.24587>;
        <D.24586>:
        D.24588 = &MEM[(void *)"TypeBuilder" + 1B];
        D.24589 = *D.24588;
        D.24590 = (int) D.24589;
        D.24591 = __s2 + 1;
        D.24592 = *D.24591;
        D.24593 = (int) D.24592;
        __result = D.24590 - D.24593;
        D.24594 = __s2_len > 1;
        D.24584 = __result == 0;
        D.24595 = D.24594 & D.24584;
        if (D.24595 != 0) goto <D.24596>; else goto <D.24597>;
        <D.24596>:
        D.24598 = &MEM[(void *)"TypeBuilder" + 2B];
        D.24599 = *D.24598;
        D.24600 = (int) D.24599;
        D.24601 = __s2 + 2;
        D.24602 = *D.24601;
        D.24603 = (int) D.24602;
        __result = D.24600 - D.24603;
        D.24604 = __s2_len > 2;
        D.24584 = __result == 0;
        D.24605 = D.24604 & D.24584;
        if (D.24605 != 0) goto <D.24606>; else goto <D.24607>;
        <D.24606>:
        D.24608 = &MEM[(void *)"TypeBuilder" + 3B];
        D.24609 = *D.24608;
        D.24610 = (int) D.24609;
        D.24611 = __s2 + 3;
        D.24612 = *D.24611;
        D.24613 = (int) D.24612;
        __result = D.24610 - D.24613;
        <D.24607>:
        <D.24597>:
        <D.24587>:
      }
      D.20127 = __result;
    }
    iftmp.8 = -D.20127;
    goto <D.24614>;
    <D.24577>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.8 = __builtin_strcmp (D.24351, "TypeBuilder");
    <D.24614>:
    D.20128 = iftmp.8;
  }
  if (D.20128 != 0) goto <D.24615>; else goto <D.24616>;
  <D.24615>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4257);
  <D.24616>:
  tb = iltoken->member;
  idx = tb->table_idx;
  goto <D.20080>;
  <D.20129>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24620 = "MonoArrayMethod";
      D.24621 = MEM[(const unsigned char *)D.24620];
      D.24622 = (int) D.24621;
      D.24623 = *__s2;
      D.24624 = (int) D.24623;
      __result = D.24622 - D.24624;
      {
        D.24625 = __s2_len != 0;
        D.24626 = __result == 0;
        D.24627 = D.24625 & D.24626;
        if (D.24627 != 0) goto <D.24628>; else goto <D.24629>;
        <D.24628>:
        D.24630 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.24631 = *D.24630;
        D.24632 = (int) D.24631;
        D.24633 = __s2 + 1;
        D.24634 = *D.24633;
        D.24635 = (int) D.24634;
        __result = D.24632 - D.24635;
        D.24636 = __s2_len > 1;
        D.24626 = __result == 0;
        D.24637 = D.24636 & D.24626;
        if (D.24637 != 0) goto <D.24638>; else goto <D.24639>;
        <D.24638>:
        D.24640 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.24641 = *D.24640;
        D.24642 = (int) D.24641;
        D.24643 = __s2 + 2;
        D.24644 = *D.24643;
        D.24645 = (int) D.24644;
        __result = D.24642 - D.24645;
        D.24646 = __s2_len > 2;
        D.24626 = __result == 0;
        D.24647 = D.24646 & D.24626;
        if (D.24647 != 0) goto <D.24648>; else goto <D.24649>;
        <D.24648>:
        D.24650 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.24651 = *D.24650;
        D.24652 = (int) D.24651;
        D.24653 = __s2 + 3;
        D.24654 = *D.24653;
        D.24655 = (int) D.24654;
        __result = D.24652 - D.24655;
        <D.24649>:
        <D.24639>:
        <D.24629>:
      }
      D.20137 = __result;
    }
    iftmp.9 = -D.20137;
    goto <D.24656>;
    <D.24619>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.9 = __builtin_strcmp (D.24351, "MonoArrayMethod");
    <D.24656>:
    D.20138 = iftmp.9;
  }
  if (D.20138 == 0) goto <D.24657>; else goto <D.24658>;
  <D.24657>:
  am = iltoken->member;
  idx = am->table_idx;
  goto <D.24659>;
  <D.24658>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24494 = "MonoMethod";
      D.24495 = MEM[(const unsigned char *)D.24494];
      D.24496 = (int) D.24495;
      D.24665 = *__s2;
      D.24666 = (int) D.24665;
      __result = D.24496 - D.24666;
      {
        D.24667 = __s2_len != 0;
        D.24668 = __result == 0;
        D.24669 = D.24667 & D.24668;
        if (D.24669 != 0) goto <D.24670>; else goto <D.24671>;
        <D.24670>:
        D.24504 = &MEM[(void *)"MonoMethod" + 1B];
        D.24505 = *D.24504;
        D.24506 = (int) D.24505;
        D.24672 = __s2 + 1;
        D.24673 = *D.24672;
        D.24674 = (int) D.24673;
        __result = D.24506 - D.24674;
        D.24675 = __s2_len > 1;
        D.24668 = __result == 0;
        D.24676 = D.24675 & D.24668;
        if (D.24676 != 0) goto <D.24677>; else goto <D.24678>;
        <D.24677>:
        D.24514 = &MEM[(void *)"MonoMethod" + 2B];
        D.24515 = *D.24514;
        D.24516 = (int) D.24515;
        D.24679 = __s2 + 2;
        D.24680 = *D.24679;
        D.24681 = (int) D.24680;
        __result = D.24516 - D.24681;
        D.24682 = __s2_len > 2;
        D.24668 = __result == 0;
        D.24683 = D.24682 & D.24668;
        if (D.24683 != 0) goto <D.24684>; else goto <D.24685>;
        <D.24684>:
        D.24524 = &MEM[(void *)"MonoMethod" + 3B];
        D.24525 = *D.24524;
        D.24526 = (int) D.24525;
        D.24686 = __s2 + 3;
        D.24687 = *D.24686;
        D.24688 = (int) D.24687;
        __result = D.24526 - D.24688;
        <D.24685>:
        <D.24678>:
        <D.24671>:
      }
      D.20146 = __result;
    }
    iftmp.10 = -D.20146;
    goto <D.24689>;
    <D.24664>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.10 = __builtin_strcmp (D.24351, "MonoMethod");
    <D.24689>:
    D.20147 = iftmp.10;
  }
  if (D.20147 == 0) goto <D.24660>; else goto <D.24690>;
  <D.24690>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24535 = "MonoCMethod";
      D.24536 = MEM[(const unsigned char *)D.24535];
      D.24537 = (int) D.24536;
      D.24694 = *__s2;
      D.24695 = (int) D.24694;
      __result = D.24537 - D.24695;
      {
        D.24696 = __s2_len != 0;
        D.24697 = __result == 0;
        D.24698 = D.24696 & D.24697;
        if (D.24698 != 0) goto <D.24699>; else goto <D.24700>;
        <D.24699>:
        D.24545 = &MEM[(void *)"MonoCMethod" + 1B];
        D.24546 = *D.24545;
        D.24547 = (int) D.24546;
        D.24701 = __s2 + 1;
        D.24702 = *D.24701;
        D.24703 = (int) D.24702;
        __result = D.24547 - D.24703;
        D.24704 = __s2_len > 1;
        D.24697 = __result == 0;
        D.24705 = D.24704 & D.24697;
        if (D.24705 != 0) goto <D.24706>; else goto <D.24707>;
        <D.24706>:
        D.24555 = &MEM[(void *)"MonoCMethod" + 2B];
        D.24556 = *D.24555;
        D.24557 = (int) D.24556;
        D.24708 = __s2 + 2;
        D.24709 = *D.24708;
        D.24710 = (int) D.24709;
        __result = D.24557 - D.24710;
        D.24711 = __s2_len > 2;
        D.24697 = __result == 0;
        D.24712 = D.24711 & D.24697;
        if (D.24712 != 0) goto <D.24713>; else goto <D.24714>;
        <D.24713>:
        D.24565 = &MEM[(void *)"MonoCMethod" + 3B];
        D.24566 = *D.24565;
        D.24567 = (int) D.24566;
        D.24715 = __s2 + 3;
        D.24716 = *D.24715;
        D.24717 = (int) D.24716;
        __result = D.24567 - D.24717;
        <D.24714>:
        <D.24707>:
        <D.24700>:
      }
      D.20155 = __result;
    }
    iftmp.11 = -D.20155;
    goto <D.24718>;
    <D.24693>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.11 = __builtin_strcmp (D.24351, "MonoCMethod");
    <D.24718>:
    D.20156 = iftmp.11;
  }
  if (D.20156 == 0) goto <D.24660>; else goto <D.24719>;
  <D.24719>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24723 = "MonoGenericMethod";
      D.24724 = MEM[(const unsigned char *)D.24723];
      D.24725 = (int) D.24724;
      D.24726 = *__s2;
      D.24727 = (int) D.24726;
      __result = D.24725 - D.24727;
      {
        D.24728 = __s2_len != 0;
        D.24729 = __result == 0;
        D.24730 = D.24728 & D.24729;
        if (D.24730 != 0) goto <D.24731>; else goto <D.24732>;
        <D.24731>:
        D.24733 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24734 = *D.24733;
        D.24735 = (int) D.24734;
        D.24736 = __s2 + 1;
        D.24737 = *D.24736;
        D.24738 = (int) D.24737;
        __result = D.24735 - D.24738;
        D.24739 = __s2_len > 1;
        D.24729 = __result == 0;
        D.24740 = D.24739 & D.24729;
        if (D.24740 != 0) goto <D.24741>; else goto <D.24742>;
        <D.24741>:
        D.24743 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24744 = *D.24743;
        D.24745 = (int) D.24744;
        D.24746 = __s2 + 2;
        D.24747 = *D.24746;
        D.24748 = (int) D.24747;
        __result = D.24745 - D.24748;
        D.24749 = __s2_len > 2;
        D.24729 = __result == 0;
        D.24750 = D.24749 & D.24729;
        if (D.24750 != 0) goto <D.24751>; else goto <D.24752>;
        <D.24751>:
        D.24753 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24754 = *D.24753;
        D.24755 = (int) D.24754;
        D.24756 = __s2 + 3;
        D.24757 = *D.24756;
        D.24758 = (int) D.24757;
        __result = D.24755 - D.24758;
        <D.24752>:
        <D.24742>:
        <D.24732>:
      }
      D.20164 = __result;
    }
    iftmp.12 = -D.20164;
    goto <D.24759>;
    <D.24722>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.12 = __builtin_strcmp (D.24351, "MonoGenericMethod");
    <D.24759>:
    D.20165 = iftmp.12;
  }
  if (D.20165 == 0) goto <D.24660>; else goto <D.24760>;
  <D.24760>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24764 = "MonoGenericCMethod";
      D.24765 = MEM[(const unsigned char *)D.24764];
      D.24766 = (int) D.24765;
      D.24767 = *__s2;
      D.24768 = (int) D.24767;
      __result = D.24766 - D.24768;
      {
        D.24769 = __s2_len != 0;
        D.24770 = __result == 0;
        D.24771 = D.24769 & D.24770;
        if (D.24771 != 0) goto <D.24772>; else goto <D.24773>;
        <D.24772>:
        D.24774 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.24775 = *D.24774;
        D.24776 = (int) D.24775;
        D.24777 = __s2 + 1;
        D.24778 = *D.24777;
        D.24779 = (int) D.24778;
        __result = D.24776 - D.24779;
        D.24780 = __s2_len > 1;
        D.24770 = __result == 0;
        D.24781 = D.24780 & D.24770;
        if (D.24781 != 0) goto <D.24782>; else goto <D.24783>;
        <D.24782>:
        D.24784 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.24785 = *D.24784;
        D.24786 = (int) D.24785;
        D.24787 = __s2 + 2;
        D.24788 = *D.24787;
        D.24789 = (int) D.24788;
        __result = D.24786 - D.24789;
        D.24790 = __s2_len > 2;
        D.24770 = __result == 0;
        D.24791 = D.24790 & D.24770;
        if (D.24791 != 0) goto <D.24792>; else goto <D.24793>;
        <D.24792>:
        D.24794 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.24795 = *D.24794;
        D.24796 = (int) D.24795;
        D.24797 = __s2 + 3;
        D.24798 = *D.24797;
        D.24799 = (int) D.24798;
        __result = D.24796 - D.24799;
        <D.24793>:
        <D.24783>:
        <D.24773>:
      }
      D.20173 = __result;
    }
    iftmp.13 = -D.20173;
    goto <D.24800>;
    <D.24763>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.13 = __builtin_strcmp (D.24351, "MonoGenericCMethod");
    <D.24800>:
    D.20174 = iftmp.13;
  }
  if (D.20174 == 0) goto <D.24660>; else goto <D.24661>;
  <D.24660>:
  {
    struct MonoMethod * m;

    D.24311 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24311].method;
    D.24804 = m->klass;
    D.24805 = D.24804->generic_class;
    if (D.24805 == 0B) goto <D.24806>; else goto <D.24802>;
    <D.24806>:
    D.24804 = m->klass;
    D.24807 = D.24804->generic_container;
    if (D.24807 == 0B) goto <D.24808>; else goto <D.24802>;
    <D.24808>:
    iftmp.14 = 1;
    goto <D.24803>;
    <D.24802>:
    iftmp.14 = 0;
    <D.24803>:
    D.24809 = iftmp.14 != 0;
    D.24810 = (long int) D.24809;
    D.24811 = __builtin_expect (D.24810, 0);
    if (D.24811 != 0) goto <D.24812>; else goto <D.24813>;
    <D.24812>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4270, "m->klass->generic_class || m->klass->generic_container");
    <D.24813>:
    // predicted unlikely by continue predictor.
    goto <D.20176>;
  }
  <D.24661>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24314 = "FieldBuilder";
      D.24315 = MEM[(const unsigned char *)D.24314];
      D.24316 = (int) D.24315;
      D.24817 = *__s2;
      D.24818 = (int) D.24817;
      __result = D.24316 - D.24818;
      {
        D.24819 = __s2_len != 0;
        D.24820 = __result == 0;
        D.24821 = D.24819 & D.24820;
        if (D.24821 != 0) goto <D.24822>; else goto <D.24823>;
        <D.24822>:
        D.24324 = &MEM[(void *)"FieldBuilder" + 1B];
        D.24325 = *D.24324;
        D.24326 = (int) D.24325;
        D.24824 = __s2 + 1;
        D.24825 = *D.24824;
        D.24826 = (int) D.24825;
        __result = D.24326 - D.24826;
        D.24827 = __s2_len > 1;
        D.24820 = __result == 0;
        D.24828 = D.24827 & D.24820;
        if (D.24828 != 0) goto <D.24829>; else goto <D.24830>;
        <D.24829>:
        D.24334 = &MEM[(void *)"FieldBuilder" + 2B];
        D.24335 = *D.24334;
        D.24336 = (int) D.24335;
        D.24831 = __s2 + 2;
        D.24832 = *D.24831;
        D.24833 = (int) D.24832;
        __result = D.24336 - D.24833;
        D.24834 = __s2_len > 2;
        D.24820 = __result == 0;
        D.24835 = D.24834 & D.24820;
        if (D.24835 != 0) goto <D.24836>; else goto <D.24837>;
        <D.24836>:
        D.24344 = &MEM[(void *)"FieldBuilder" + 3B];
        D.24345 = *D.24344;
        D.24346 = (int) D.24345;
        D.24838 = __s2 + 3;
        D.24839 = *D.24838;
        D.24840 = (int) D.24839;
        __result = D.24346 - D.24840;
        <D.24837>:
        <D.24830>:
        <D.24823>:
      }
      D.20184 = __result;
    }
    iftmp.15 = -D.20184;
    goto <D.24841>;
    <D.24816>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.15 = __builtin_strcmp (D.24351, "FieldBuilder");
    <D.24841>:
    D.20185 = iftmp.15;
  }
  if (D.20185 == 0) goto <D.24842>; else goto <D.24843>;
  <D.24842>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.24843>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24359 = "MonoField";
      D.24360 = MEM[(const unsigned char *)D.24359];
      D.24361 = (int) D.24360;
      D.24847 = *__s2;
      D.24848 = (int) D.24847;
      __result = D.24361 - D.24848;
      {
        D.24849 = __s2_len != 0;
        D.24850 = __result == 0;
        D.24851 = D.24849 & D.24850;
        if (D.24851 != 0) goto <D.24852>; else goto <D.24853>;
        <D.24852>:
        D.24369 = &MEM[(void *)"MonoField" + 1B];
        D.24370 = *D.24369;
        D.24371 = (int) D.24370;
        D.24854 = __s2 + 1;
        D.24855 = *D.24854;
        D.24856 = (int) D.24855;
        __result = D.24371 - D.24856;
        D.24857 = __s2_len > 1;
        D.24850 = __result == 0;
        D.24858 = D.24857 & D.24850;
        if (D.24858 != 0) goto <D.24859>; else goto <D.24860>;
        <D.24859>:
        D.24379 = &MEM[(void *)"MonoField" + 2B];
        D.24380 = *D.24379;
        D.24381 = (int) D.24380;
        D.24861 = __s2 + 2;
        D.24862 = *D.24861;
        D.24863 = (int) D.24862;
        __result = D.24381 - D.24863;
        D.24864 = __s2_len > 2;
        D.24850 = __result == 0;
        D.24865 = D.24864 & D.24850;
        if (D.24865 != 0) goto <D.24866>; else goto <D.24867>;
        <D.24866>:
        D.24389 = &MEM[(void *)"MonoField" + 3B];
        D.24390 = *D.24389;
        D.24391 = (int) D.24390;
        D.24868 = __s2 + 3;
        D.24869 = *D.24868;
        D.24870 = (int) D.24869;
        __result = D.24391 - D.24870;
        <D.24867>:
        <D.24860>:
        <D.24853>:
      }
      D.20193 = __result;
    }
    iftmp.16 = -D.20193;
    goto <D.24871>;
    <D.24846>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.16 = __builtin_strcmp (D.24351, "MonoField");
    <D.24871>:
    D.20194 = iftmp.16;
  }
  if (D.20194 == 0) goto <D.24872>; else goto <D.24873>;
  <D.24872>:
  {
    struct MonoClassField * f;

    D.24311 = iltoken->member;
    f = MEM[(struct MonoReflectionField *)D.24311].field;
    D.24874 = is_field_on_inst (f);
    D.24875 = D.24874 == 0;
    D.24876 = (long int) D.24875;
    D.24877 = __builtin_expect (D.24876, 0);
    if (D.24877 != 0) goto <D.24878>; else goto <D.24879>;
    <D.24878>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4276, "is_field_on_inst (f)");
    <D.24879>:
    // predicted unlikely by continue predictor.
    goto <D.20176>;
  }
  <D.24873>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24405 = "MethodBuilder";
      D.24406 = MEM[(const unsigned char *)D.24405];
      D.24407 = (int) D.24406;
      D.24885 = *__s2;
      D.24886 = (int) D.24885;
      __result = D.24407 - D.24886;
      {
        D.24887 = __s2_len != 0;
        D.24888 = __result == 0;
        D.24889 = D.24887 & D.24888;
        if (D.24889 != 0) goto <D.24890>; else goto <D.24891>;
        <D.24890>:
        D.24415 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24416 = *D.24415;
        D.24417 = (int) D.24416;
        D.24892 = __s2 + 1;
        D.24893 = *D.24892;
        D.24894 = (int) D.24893;
        __result = D.24417 - D.24894;
        D.24895 = __s2_len > 1;
        D.24888 = __result == 0;
        D.24896 = D.24895 & D.24888;
        if (D.24896 != 0) goto <D.24897>; else goto <D.24898>;
        <D.24897>:
        D.24425 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24426 = *D.24425;
        D.24427 = (int) D.24426;
        D.24899 = __s2 + 2;
        D.24900 = *D.24899;
        D.24901 = (int) D.24900;
        __result = D.24427 - D.24901;
        D.24902 = __s2_len > 2;
        D.24888 = __result == 0;
        D.24903 = D.24902 & D.24888;
        if (D.24903 != 0) goto <D.24904>; else goto <D.24905>;
        <D.24904>:
        D.24435 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24436 = *D.24435;
        D.24437 = (int) D.24436;
        D.24906 = __s2 + 3;
        D.24907 = *D.24906;
        D.24908 = (int) D.24907;
        __result = D.24437 - D.24908;
        <D.24905>:
        <D.24898>:
        <D.24891>:
      }
      D.20203 = __result;
    }
    iftmp.17 = -D.20203;
    goto <D.24909>;
    <D.24884>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.17 = __builtin_strcmp (D.24351, "MethodBuilder");
    <D.24909>:
    D.20204 = iftmp.17;
  }
  if (D.20204 == 0) goto <D.24880>; else goto <D.24910>;
  <D.24910>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24448 = "ConstructorBuilder";
      D.24449 = MEM[(const unsigned char *)D.24448];
      D.24450 = (int) D.24449;
      D.24914 = *__s2;
      D.24915 = (int) D.24914;
      __result = D.24450 - D.24915;
      {
        D.24916 = __s2_len != 0;
        D.24917 = __result == 0;
        D.24918 = D.24916 & D.24917;
        if (D.24918 != 0) goto <D.24919>; else goto <D.24920>;
        <D.24919>:
        D.24458 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.24459 = *D.24458;
        D.24460 = (int) D.24459;
        D.24921 = __s2 + 1;
        D.24922 = *D.24921;
        D.24923 = (int) D.24922;
        __result = D.24460 - D.24923;
        D.24924 = __s2_len > 1;
        D.24917 = __result == 0;
        D.24925 = D.24924 & D.24917;
        if (D.24925 != 0) goto <D.24926>; else goto <D.24927>;
        <D.24926>:
        D.24468 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.24469 = *D.24468;
        D.24470 = (int) D.24469;
        D.24928 = __s2 + 2;
        D.24929 = *D.24928;
        D.24930 = (int) D.24929;
        __result = D.24470 - D.24930;
        D.24931 = __s2_len > 2;
        D.24917 = __result == 0;
        D.24932 = D.24931 & D.24917;
        if (D.24932 != 0) goto <D.24933>; else goto <D.24934>;
        <D.24933>:
        D.24478 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.24479 = *D.24478;
        D.24480 = (int) D.24479;
        D.24935 = __s2 + 3;
        D.24936 = *D.24935;
        D.24937 = (int) D.24936;
        __result = D.24480 - D.24937;
        <D.24934>:
        <D.24927>:
        <D.24920>:
      }
      D.20212 = __result;
    }
    iftmp.18 = -D.20212;
    goto <D.24938>;
    <D.24913>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.18 = __builtin_strcmp (D.24351, "ConstructorBuilder");
    <D.24938>:
    D.20213 = iftmp.18;
  }
  if (D.20213 == 0) goto <D.24880>; else goto <D.24881>;
  <D.24880>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.24881>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24942 = "FieldOnTypeBuilderInst";
      D.24943 = MEM[(const unsigned char *)D.24942];
      D.24944 = (int) D.24943;
      D.24945 = *__s2;
      D.24946 = (int) D.24945;
      __result = D.24944 - D.24946;
      {
        D.24947 = __s2_len != 0;
        D.24948 = __result == 0;
        D.24949 = D.24947 & D.24948;
        if (D.24949 != 0) goto <D.24950>; else goto <D.24951>;
        <D.24950>:
        D.24952 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.24953 = *D.24952;
        D.24954 = (int) D.24953;
        D.24955 = __s2 + 1;
        D.24956 = *D.24955;
        D.24957 = (int) D.24956;
        __result = D.24954 - D.24957;
        D.24958 = __s2_len > 1;
        D.24948 = __result == 0;
        D.24959 = D.24958 & D.24948;
        if (D.24959 != 0) goto <D.24960>; else goto <D.24961>;
        <D.24960>:
        D.24962 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.24963 = *D.24962;
        D.24964 = (int) D.24963;
        D.24965 = __s2 + 2;
        D.24966 = *D.24965;
        D.24967 = (int) D.24966;
        __result = D.24964 - D.24967;
        D.24968 = __s2_len > 2;
        D.24948 = __result == 0;
        D.24969 = D.24968 & D.24948;
        if (D.24969 != 0) goto <D.24970>; else goto <D.24971>;
        <D.24970>:
        D.24972 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.24973 = *D.24972;
        D.24974 = (int) D.24973;
        D.24975 = __s2 + 3;
        D.24976 = *D.24975;
        D.24977 = (int) D.24976;
        __result = D.24974 - D.24977;
        <D.24971>:
        <D.24961>:
        <D.24951>:
      }
      D.20221 = __result;
    }
    iftmp.19 = -D.20221;
    goto <D.24978>;
    <D.24941>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.19 = __builtin_strcmp (D.24351, "FieldOnTypeBuilderInst");
    <D.24978>:
    D.20222 = iftmp.19;
  }
  if (D.20222 == 0) goto <D.24979>; else goto <D.24980>;
  <D.24979>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.24980>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24984 = "MethodOnTypeBuilderInst";
      D.24985 = MEM[(const unsigned char *)D.24984];
      D.24986 = (int) D.24985;
      D.24987 = *__s2;
      D.24988 = (int) D.24987;
      __result = D.24986 - D.24988;
      {
        D.24989 = __s2_len != 0;
        D.24990 = __result == 0;
        D.24991 = D.24989 & D.24990;
        if (D.24991 != 0) goto <D.24992>; else goto <D.24993>;
        <D.24992>:
        D.24994 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24995 = *D.24994;
        D.24996 = (int) D.24995;
        D.24997 = __s2 + 1;
        D.24998 = *D.24997;
        D.24999 = (int) D.24998;
        __result = D.24996 - D.24999;
        D.25000 = __s2_len > 1;
        D.24990 = __result == 0;
        D.25001 = D.25000 & D.24990;
        if (D.25001 != 0) goto <D.25002>; else goto <D.25003>;
        <D.25002>:
        D.25004 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.25005 = *D.25004;
        D.25006 = (int) D.25005;
        D.25007 = __s2 + 2;
        D.25008 = *D.25007;
        D.25009 = (int) D.25008;
        __result = D.25006 - D.25009;
        D.25010 = __s2_len > 2;
        D.24990 = __result == 0;
        D.25011 = D.25010 & D.24990;
        if (D.25011 != 0) goto <D.25012>; else goto <D.25013>;
        <D.25012>:
        D.25014 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.25015 = *D.25014;
        D.25016 = (int) D.25015;
        D.25017 = __s2 + 3;
        D.25018 = *D.25017;
        D.25019 = (int) D.25018;
        __result = D.25016 - D.25019;
        <D.25013>:
        <D.25003>:
        <D.24993>:
      }
      D.20230 = __result;
    }
    iftmp.20 = -D.20230;
    goto <D.25020>;
    <D.24983>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.20 = __builtin_strcmp (D.24351, "MethodOnTypeBuilderInst");
    <D.25020>:
    D.20231 = iftmp.20;
  }
  if (D.20231 == 0) goto <D.25021>; else goto <D.25022>;
  <D.25021>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.25022>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.25026 = "ConstructorOnTypeBuilderInst";
      D.25027 = MEM[(const unsigned char *)D.25026];
      D.25028 = (int) D.25027;
      D.25029 = *__s2;
      D.25030 = (int) D.25029;
      __result = D.25028 - D.25030;
      {
        D.25031 = __s2_len != 0;
        D.25032 = __result == 0;
        D.25033 = D.25031 & D.25032;
        if (D.25033 != 0) goto <D.25034>; else goto <D.25035>;
        <D.25034>:
        D.25036 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.25037 = *D.25036;
        D.25038 = (int) D.25037;
        D.25039 = __s2 + 1;
        D.25040 = *D.25039;
        D.25041 = (int) D.25040;
        __result = D.25038 - D.25041;
        D.25042 = __s2_len > 1;
        D.25032 = __result == 0;
        D.25043 = D.25042 & D.25032;
        if (D.25043 != 0) goto <D.25044>; else goto <D.25045>;
        <D.25044>:
        D.25046 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.25047 = *D.25046;
        D.25048 = (int) D.25047;
        D.25049 = __s2 + 2;
        D.25050 = *D.25049;
        D.25051 = (int) D.25050;
        __result = D.25048 - D.25051;
        D.25052 = __s2_len > 2;
        D.25032 = __result == 0;
        D.25053 = D.25052 & D.25032;
        if (D.25053 != 0) goto <D.25054>; else goto <D.25055>;
        <D.25054>:
        D.25056 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.25057 = *D.25056;
        D.25058 = (int) D.25057;
        D.25059 = __s2 + 3;
        D.25060 = *D.25059;
        D.25061 = (int) D.25060;
        __result = D.25058 - D.25061;
        <D.25055>:
        <D.25045>:
        <D.25035>:
      }
      D.20239 = __result;
    }
    iftmp.21 = -D.20239;
    goto <D.25062>;
    <D.25025>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.21 = __builtin_strcmp (D.24351, "ConstructorOnTypeBuilderInst");
    <D.25062>:
    D.20240 = iftmp.21;
  }
  if (D.20240 == 0) goto <D.25063>; else goto <D.25064>;
  <D.25063>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.25064>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4288);
  <D.24659>:
  goto <D.20080>;
  <D.20241>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24723 = "MonoGenericMethod";
      D.24724 = MEM[(const unsigned char *)D.24723];
      D.24725 = (int) D.24724;
      D.25068 = *__s2;
      D.25069 = (int) D.25068;
      __result = D.24725 - D.25069;
      {
        D.25070 = __s2_len != 0;
        D.25071 = __result == 0;
        D.25072 = D.25070 & D.25071;
        if (D.25072 != 0) goto <D.25073>; else goto <D.25074>;
        <D.25073>:
        D.24733 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.24734 = *D.24733;
        D.24735 = (int) D.24734;
        D.25075 = __s2 + 1;
        D.25076 = *D.25075;
        D.25077 = (int) D.25076;
        __result = D.24735 - D.25077;
        D.25078 = __s2_len > 1;
        D.25071 = __result == 0;
        D.25079 = D.25078 & D.25071;
        if (D.25079 != 0) goto <D.25080>; else goto <D.25081>;
        <D.25080>:
        D.24743 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.24744 = *D.24743;
        D.24745 = (int) D.24744;
        D.25082 = __s2 + 2;
        D.25083 = *D.25082;
        D.25084 = (int) D.25083;
        __result = D.24745 - D.25084;
        D.25085 = __s2_len > 2;
        D.25071 = __result == 0;
        D.25086 = D.25085 & D.25071;
        if (D.25086 != 0) goto <D.25087>; else goto <D.25088>;
        <D.25087>:
        D.24753 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.24754 = *D.24753;
        D.24755 = (int) D.24754;
        D.25089 = __s2 + 3;
        D.25090 = *D.25089;
        D.25091 = (int) D.25090;
        __result = D.24755 - D.25091;
        <D.25088>:
        <D.25081>:
        <D.25074>:
      }
      D.20249 = __result;
    }
    iftmp.22 = -D.20249;
    goto <D.25092>;
    <D.25067>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.22 = __builtin_strcmp (D.24351, "MonoGenericMethod");
    <D.25092>:
    D.20250 = iftmp.22;
  }
  if (D.20250 == 0) goto <D.25093>; else goto <D.25094>;
  <D.25093>:
  {
    struct MonoMethod * m;

    D.24311 = iltoken->member;
    m = MEM[(struct MonoReflectionMethod *)D.24311].method;
    D.25095 = mono_method_signature (m);
    D.25096 = D.25095->generic_param_count;
    D.25097 = D.25096 == 0;
    D.25098 = (long int) D.25097;
    D.25099 = __builtin_expect (D.25098, 0);
    if (D.25099 != 0) goto <D.25100>; else goto <D.25101>;
    <D.25100>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4294, "mono_method_signature (m)->generic_param_count");
    <D.25101>:
    // predicted unlikely by continue predictor.
    goto <D.20176>;
  }
  <D.25094>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24405 = "MethodBuilder";
      D.24406 = MEM[(const unsigned char *)D.24405];
      D.24407 = (int) D.24406;
      D.25105 = *__s2;
      D.25106 = (int) D.25105;
      __result = D.24407 - D.25106;
      {
        D.25107 = __s2_len != 0;
        D.25108 = __result == 0;
        D.25109 = D.25107 & D.25108;
        if (D.25109 != 0) goto <D.25110>; else goto <D.25111>;
        <D.25110>:
        D.24415 = &MEM[(void *)"MethodBuilder" + 1B];
        D.24416 = *D.24415;
        D.24417 = (int) D.24416;
        D.25112 = __s2 + 1;
        D.25113 = *D.25112;
        D.25114 = (int) D.25113;
        __result = D.24417 - D.25114;
        D.25115 = __s2_len > 1;
        D.25108 = __result == 0;
        D.25116 = D.25115 & D.25108;
        if (D.25116 != 0) goto <D.25117>; else goto <D.25118>;
        <D.25117>:
        D.24425 = &MEM[(void *)"MethodBuilder" + 2B];
        D.24426 = *D.24425;
        D.24427 = (int) D.24426;
        D.25119 = __s2 + 2;
        D.25120 = *D.25119;
        D.25121 = (int) D.25120;
        __result = D.24427 - D.25121;
        D.25122 = __s2_len > 2;
        D.25108 = __result == 0;
        D.25123 = D.25122 & D.25108;
        if (D.25123 != 0) goto <D.25124>; else goto <D.25125>;
        <D.25124>:
        D.24435 = &MEM[(void *)"MethodBuilder" + 3B];
        D.24436 = *D.24435;
        D.24437 = (int) D.24436;
        D.25126 = __s2 + 3;
        D.25127 = *D.25126;
        D.25128 = (int) D.25127;
        __result = D.24437 - D.25128;
        <D.25125>:
        <D.25118>:
        <D.25111>:
      }
      D.20259 = __result;
    }
    iftmp.23 = -D.20259;
    goto <D.25129>;
    <D.25104>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.23 = __builtin_strcmp (D.24351, "MethodBuilder");
    <D.25129>:
    D.20260 = iftmp.23;
  }
  if (D.20260 == 0) goto <D.25130>; else goto <D.25131>;
  <D.25130>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.25131>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.24311 = iltoken->member;
      D.24312 = D.24311->vtable;
      D.24313 = D.24312->klass;
      __s2 = D.24313->name;
      D.24984 = "MethodOnTypeBuilderInst";
      D.24985 = MEM[(const unsigned char *)D.24984];
      D.24986 = (int) D.24985;
      D.25135 = *__s2;
      D.25136 = (int) D.25135;
      __result = D.24986 - D.25136;
      {
        D.25137 = __s2_len != 0;
        D.25138 = __result == 0;
        D.25139 = D.25137 & D.25138;
        if (D.25139 != 0) goto <D.25140>; else goto <D.25141>;
        <D.25140>:
        D.24994 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.24995 = *D.24994;
        D.24996 = (int) D.24995;
        D.25142 = __s2 + 1;
        D.25143 = *D.25142;
        D.25144 = (int) D.25143;
        __result = D.24996 - D.25144;
        D.25145 = __s2_len > 1;
        D.25138 = __result == 0;
        D.25146 = D.25145 & D.25138;
        if (D.25146 != 0) goto <D.25147>; else goto <D.25148>;
        <D.25147>:
        D.25004 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.25005 = *D.25004;
        D.25006 = (int) D.25005;
        D.25149 = __s2 + 2;
        D.25150 = *D.25149;
        D.25151 = (int) D.25150;
        __result = D.25006 - D.25151;
        D.25152 = __s2_len > 2;
        D.25138 = __result == 0;
        D.25153 = D.25152 & D.25138;
        if (D.25153 != 0) goto <D.25154>; else goto <D.25155>;
        <D.25154>:
        D.25014 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.25015 = *D.25014;
        D.25016 = (int) D.25015;
        D.25156 = __s2 + 3;
        D.25157 = *D.25156;
        D.25158 = (int) D.25157;
        __result = D.25016 - D.25158;
        <D.25155>:
        <D.25148>:
        <D.25141>:
      }
      D.20268 = __result;
    }
    iftmp.24 = -D.20268;
    goto <D.25159>;
    <D.25134>:
    D.24311 = iltoken->member;
    D.24312 = D.24311->vtable;
    D.24313 = D.24312->klass;
    D.24351 = D.24313->name;
    iftmp.24 = __builtin_strcmp (D.24351, "MethodOnTypeBuilderInst");
    <D.25159>:
    D.20269 = iftmp.24;
  }
  if (D.20269 == 0) goto <D.25160>; else goto <D.25161>;
  <D.25160>:
  // predicted unlikely by continue predictor.
  goto <D.20176>;
  <D.25161>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4301);
  <D.20270>:
  D.24305 = target + 3;
  D.24306 = *D.24305;
  D.24307 = (int) D.24306;
  monoeg_g_log (0B, 4, "got unexpected table 0x%02x in fixup", D.24307);
  <D.20271>:
  goto <D.20271>;
  <D.20080>:
  D.25162 = (unsigned char) idx;
  *target = D.25162;
  D.25163 = target + 1;
  D.25164 = idx >> 8;
  D.25165 = (unsigned char) D.25164;
  *D.25163 = D.25165;
  D.25166 = target + 2;
  D.25167 = idx >> 16;
  D.25168 = (unsigned char) D.25167;
  *D.25166 = D.25168;
  <D.20176>:
  i = i + 1;
  <D.20273>:
  D.25169 = ilgen->num_token_fixups;
  D.25170 = (unsigned int) D.25169;
  if (D.25170 > i) goto <D.20272>; else goto <D.20274>;
  <D.20274>:
}


is_field_on_inst (struct MonoClassField * field)
{
  gboolean D.25171;
  int iftmp.25;
  struct MonoClass * D.25175;
  struct MonoGenericClass * D.25176;
  unsigned char D.25178;
  unsigned char D.25179;
  struct MonoClassField * D.25181;

  D.25175 = field->parent;
  D.25176 = D.25175->generic_class;
  if (D.25176 != 0B) goto <D.25177>; else goto <D.25173>;
  <D.25177>:
  D.25175 = field->parent;
  D.25176 = D.25175->generic_class;
  D.25178 = BIT_FIELD_REF <*D.25176, 8, 192>;
  D.25179 = D.25178 & 1;
  if (D.25179 != 0) goto <D.25180>; else goto <D.25173>;
  <D.25180>:
  D.25175 = field->parent;
  D.25176 = D.25175->generic_class;
  D.25181 = MEM[(struct MonoDynamicGenericClass *)D.25176].fields;
  if (D.25181 != 0B) goto <D.25182>; else goto <D.25173>;
  <D.25182>:
  iftmp.25 = 1;
  goto <D.25174>;
  <D.25173>:
  iftmp.25 = 0;
  <D.25174>:
  D.25171 = iftmp.25;
  return D.25171;
}


compare_types_by_table_idx (struct MonoReflectionTypeBuilder * * type1, struct MonoReflectionTypeBuilder * * type2)
{
  struct MonoReflectionTypeBuilder * D.25184;
  unsigned int D.25185;
  struct MonoReflectionTypeBuilder * D.25186;
  unsigned int D.25187;
  gint D.25190;

  D.25184 = *type1;
  D.25185 = D.25184->table_idx;
  D.25186 = *type2;
  D.25187 = D.25186->table_idx;
  if (D.25185 < D.25187) goto <D.25188>; else goto <D.25189>;
  <D.25188>:
  D.25190 = -1;
  return D.25190;
  <D.25189>:
  D.25184 = *type1;
  D.25185 = D.25184->table_idx;
  D.25186 = *type2;
  D.25187 = D.25186->table_idx;
  if (D.25185 > D.25187) goto <D.25191>; else goto <D.25192>;
  <D.25191>:
  D.25190 = 1;
  return D.25190;
  <D.25192>:
  D.25190 = 0;
  return D.25190;
}


mono_image_emit_manifest (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoVTable * D.25194;
  guint32 * D.25195;
  guint32 iftmp.26;
  unsigned int D.25197;
  guint32 * D.25201;
  struct MonoString * D.25202;
  struct MonoDynamicStream * D.25203;
  unsigned int D.25204;
  struct MonoString * D.25205;
  guint32 * D.25208;
  unsigned int D.25209;
  unsigned int D.25211;
  guint32 * D.25212;
  struct MonoArray * D.25213;
  unsigned int D.25214;
  guint32 * D.25215;
  unsigned int D.25216;
  struct MonoString * D.25217;
  long unsigned int D.25218;
  struct MonoArray * D.25219;
  char * D.25220;
  struct MonoArray * D.25223;
  long unsigned int D.25226;
  char * D.25227;
  int D.25228;
  long unsigned int D.25229;
  struct MonoArray * D.25230;
  char * D.25233;
  long unsigned int D.25234;
  struct MonoArray * D.25235;
  char * D.25238;
  struct MonoArray * D.25241;
  long unsigned int D.25244;
  long unsigned int D.25245;
  unsigned int D.25246;
  long unsigned int D.25247;
  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.25194 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.25194->domain;
  table = &assembly->tables[32];
  alloc_table (table, 1);
  D.25195 = table->values;
  values = D.25195 + 36;
  D.25197 = assemblyb->algid;
  if (D.25197 != 0) goto <D.25198>; else goto <D.25199>;
  <D.25198>:
  iftmp.26 = assemblyb->algid;
  goto <D.25200>;
  <D.25199>:
  iftmp.26 = 32772;
  <D.25200>:
  *values = iftmp.26;
  D.25201 = values + 28;
  D.25202 = assemblyb->name;
  D.25203 = &assembly->sheap;
  D.25204 = string_heap_insert_mstring (D.25203, D.25202);
  *D.25201 = D.25204;
  D.25205 = assemblyb->culture;
  if (D.25205 != 0B) goto <D.25206>; else goto <D.25207>;
  <D.25206>:
  D.25208 = values + 32;
  D.25205 = assemblyb->culture;
  D.25203 = &assembly->sheap;
  D.25209 = string_heap_insert_mstring (D.25203, D.25205);
  *D.25208 = D.25209;
  goto <D.25210>;
  <D.25207>:
  D.25208 = values + 32;
  D.25203 = &assembly->sheap;
  D.25211 = string_heap_insert (D.25203, "");
  *D.25208 = D.25211;
  <D.25210>:
  D.25212 = values + 24;
  D.25213 = assemblyb->public_key;
  D.25214 = load_public_key (D.25213, assembly);
  *D.25212 = D.25214;
  D.25215 = values + 20;
  D.25216 = assemblyb->flags;
  *D.25215 = D.25216;
  D.25217 = assemblyb->version;
  set_version_from_string (D.25217, values);
  module_index = 0;
  i = 0;
  goto <D.20372>;
  <D.20371>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.25218 = (long unsigned int) i;
    D.25219 = assemblyb->modules;
    D.25220 = mono_array_addr_with_size (D.25219, 8, D.25218);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.25220];
    if (file_module != moduleb) goto <D.25221>; else goto <D.25222>;
    <D.25221>:
    mono_image_fill_file_table (domain, file_module, assembly);
    module_index = module_index + 1;
    D.25223 = file_module->types;
    if (D.25223 != 0B) goto <D.25224>; else goto <D.25225>;
    <D.25224>:
    j = 0;
    goto <D.20369>;
    <D.20368>:
    {
      struct MonoReflectionTypeBuilder * tb;

      D.25226 = (long unsigned int) j;
      D.25223 = file_module->types;
      D.25227 = mono_array_addr_with_size (D.25223, 8, D.25226);
      tb = MEM[(struct MonoReflectionTypeBuilder * *)D.25227];
      mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
    }
    j = j + 1;
    <D.20369>:
    D.25228 = file_module->num_types;
    if (D.25228 > j) goto <D.20368>; else goto <D.20370>;
    <D.20370>:
    <D.25225>:
    <D.25222>:
  }
  i = i + 1;
  <D.20372>:
  D.25218 = (long unsigned int) i;
  D.25219 = assemblyb->modules;
  D.25229 = mono_array_length (D.25219);
  if (D.25218 < D.25229) goto <D.20371>; else goto <D.20373>;
  <D.20373>:
  D.25230 = assemblyb->loaded_modules;
  if (D.25230 != 0B) goto <D.25231>; else goto <D.25232>;
  <D.25231>:
  i = 0;
  goto <D.20376>;
  <D.20375>:
  {
    struct MonoReflectionModule * file_module;

    D.25218 = (long unsigned int) i;
    D.25230 = assemblyb->loaded_modules;
    D.25233 = mono_array_addr_with_size (D.25230, 8, D.25218);
    file_module = MEM[(struct MonoReflectionModule * *)D.25233];
    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.20376>:
  D.25218 = (long unsigned int) i;
  D.25230 = assemblyb->loaded_modules;
  D.25234 = mono_array_length (D.25230);
  if (D.25218 < D.25234) goto <D.20375>; else goto <D.20377>;
  <D.20377>:
  <D.25232>:
  D.25235 = assemblyb->type_forwarders;
  if (D.25235 != 0B) goto <D.25236>; else goto <D.25237>;
  <D.25236>:
  mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
  <D.25237>:
  module_index = 0;
  i = 0;
  goto <D.20386>;
  <D.20385>:
  {
    int j;
    struct MonoReflectionModuleBuilder * file_module;

    D.25218 = (long unsigned int) i;
    D.25219 = assemblyb->modules;
    D.25238 = mono_array_addr_with_size (D.25219, 8, D.25218);
    file_module = MEM[(struct MonoReflectionModuleBuilder * *)D.25238];
    if (file_module != moduleb) goto <D.25239>; else goto <D.25240>;
    <D.25239>:
    module_index = module_index + 1;
    D.25241 = file_module->resources;
    if (D.25241 != 0B) goto <D.25242>; else goto <D.25243>;
    <D.25242>:
    {
      int len;

      D.25241 = file_module->resources;
      D.25244 = mono_array_length (D.25241);
      len = (int) D.25244;
      j = 0;
      goto <D.20383>;
      <D.20382>:
      {
        struct MonoReflectionResource * res;

        D.25245 = (long unsigned int) j;
        D.25241 = file_module->resources;
        res = mono_array_addr_with_size (D.25241, 40, D.25245);
        D.25246 = module_index << 2;
        assembly_add_resource_manifest (file_module, assembly, res, D.25246);
      }
      j = j + 1;
      <D.20383>:
      if (j < len) goto <D.20382>; else goto <D.20384>;
      <D.20384>:
    }
    <D.25243>:
    <D.25240>:
  }
  i = i + 1;
  <D.20386>:
  D.25218 = (long unsigned int) i;
  D.25219 = assemblyb->modules;
  D.25247 = mono_array_length (D.25219);
  if (D.25218 < D.25247) goto <D.20385>; else goto <D.20387>;
  <D.20387>:
}


load_public_key (struct MonoArray * pkey, struct MonoDynamicImage * assembly)
{
  guint32 D.25250;
  char * b.27;
  unsigned int D.25252;
  long int b.28;
  long int blob_size.29;
  long int D.25255;
  unsigned int D.25256;
  struct MonoDynamicStream * D.25257;
  unsigned int D.25258;
  char * D.25259;
  void * D.25260;
  char * D.25261;
  guint8 * D.25262;
  int D.25263;
  char * D.25267;
  int D.25268;
  unsigned int D.25272;
  long unsigned int D.25274;
  long unsigned int D.25275;
  int D.25276;
  unsigned int D.25277;
  long unsigned int D.25278;
  void * D.25279;
  gsize len;
  guint32 token;
  char blob_size[6];
  char * b;

  try
    {
      token = 0;
      b = &blob_size;
      if (pkey == 0B) goto <D.25248>; else goto <D.25249>;
      <D.25248>:
      D.25250 = token;
      return D.25250;
      <D.25249>:
      len = mono_array_length (pkey);
      b.27 = b;
      D.25252 = (unsigned int) len;
      mono_metadata_encode_value (D.25252, b.27, &b);
      b.27 = b;
      b.28 = (long int) b.27;
      blob_size.29 = (long int) &blob_size;
      D.25255 = b.28 - blob_size.29;
      D.25256 = (unsigned int) D.25255;
      D.25257 = &assembly->blob;
      token = mono_image_add_stream_data (D.25257, &blob_size, D.25256);
      D.25258 = (unsigned int) len;
      D.25259 = mono_array_addr_with_size (pkey, 1, 0);
      D.25257 = &assembly->blob;
      mono_image_add_stream_data (D.25257, D.25259, D.25258);
      D.25260 = monoeg_malloc (len);
      assembly->public_key = D.25260;
      D.25261 = mono_array_addr_with_size (pkey, 1, 0);
      D.25262 = assembly->public_key;
      memcpy (D.25262, D.25261, len);
      D.25263 = (int) len;
      assembly->public_key_len = D.25263;
      if (len == 16) goto <D.25266>; else goto <D.25264>;
      <D.25266>:
      D.25263 = (int) len;
      D.25267 = mono_array_addr_with_size (pkey, 1, 0);
      D.25268 = mono_is_ecma_key (D.25267, D.25263);
      if (D.25268 != 0) goto <D.25269>; else goto <D.25264>;
      <D.25269>:
      assembly->strong_name_size = 128;
      goto <D.25265>;
      <D.25264>:
      if (len > 79) goto <D.25270>; else goto <D.25271>;
      <D.25270>:
      D.25258 = (unsigned int) len;
      D.25272 = D.25258 + 4294967264;
      assembly->strong_name_size = D.25272;
      goto <D.25273>;
      <D.25271>:
      D.25263 = (int) len;
      D.25274 = len + 18446744073709551584;
      D.25275 = D.25274 << 3;
      D.25276 = (int) D.25275;
      monoeg_g_log (0B, 16, "Invalid public key length: %d bits (total: %d)", D.25276, D.25263);
      assembly->strong_name_size = 128;
      <D.25273>:
      <D.25265>:
      D.25277 = assembly->strong_name_size;
      D.25278 = (long unsigned int) D.25277;
      D.25279 = monoeg_malloc0 (D.25278);
      assembly->strong_name = D.25279;
      D.25250 = token;
      return D.25250;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_add_stream_data (struct MonoDynamicStream * stream, const char * data, guint32 len)
{
  unsigned int D.25282;
  unsigned int D.25283;
  int D.25284;
  long unsigned int D.25285;
  char * D.25286;
  sizetype D.25287;
  char * D.25288;
  guint32 D.25289;
  guint32 idx;

  D.25282 = stream->index;
  D.25283 = D.25282 + len;
  D.25284 = (int) D.25283;
  make_room_in_stream (stream, D.25284);
  D.25285 = (long unsigned int) len;
  D.25286 = stream->data;
  D.25282 = stream->index;
  D.25287 = (sizetype) D.25282;
  D.25288 = D.25286 + D.25287;
  memcpy (D.25288, data, D.25285);
  idx = stream->index;
  D.25282 = stream->index;
  D.25283 = D.25282 + len;
  stream->index = D.25283;
  D.25289 = idx;
  return D.25289;
}


make_room_in_stream (struct MonoDynamicStream * stream, int size)
{
  unsigned int size.30;
  unsigned int D.25292;
  unsigned int D.25298;
  long unsigned int D.25299;
  char * D.25300;
  void * D.25301;

  size.30 = (unsigned int) size;
  D.25292 = stream->alloc_size;
  if (size.30 <= D.25292) goto <D.25293>; else goto <D.25294>;
  <D.25293>:
  return;
  <D.25294>:
  goto <D.18709>;
  <D.18708>:
  D.25292 = stream->alloc_size;
  if (D.25292 <= 4095) goto <D.25295>; else goto <D.25296>;
  <D.25295>:
  stream->alloc_size = 4096;
  goto <D.25297>;
  <D.25296>:
  D.25292 = stream->alloc_size;
  D.25298 = D.25292 * 2;
  stream->alloc_size = D.25298;
  <D.25297>:
  <D.18709>:
  D.25292 = stream->alloc_size;
  size.30 = (unsigned int) size;
  if (D.25292 <= size.30) goto <D.18708>; else goto <D.18710>;
  <D.18710>:
  D.25292 = stream->alloc_size;
  D.25299 = (long unsigned int) D.25292;
  D.25300 = stream->data;
  D.25301 = monoeg_realloc (D.25300, D.25299);
  stream->data = D.25301;
}


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

  D.25304 = __builtin_object_size (__dest, 0);
  D.25303 = __builtin___memcpy_chk (__dest, __src, __len, D.25304);
  return D.25303;
}


set_version_from_string (struct MonoString * version, guint32 * values)
{
  guint32 * D.25306;
  guint32 * D.25307;
  guint32 * D.25308;
  guint32 * D.25309;
  unsigned int D.25312;
  long unsigned int D.25313;
  long unsigned int D.25314;
  guint32 * D.25315;
  long int D.25316;
  unsigned int D.25317;
  gchar * p.31;
  char D.25319;
  int D.25320;
  gchar * p.32;
  gchar * ver;
  gchar * p;
  gchar * str;
  guint32 i;

  try
    {
      D.25306 = values + 4;
      *D.25306 = 0;
      D.25307 = values + 8;
      *D.25307 = 0;
      D.25308 = values + 16;
      *D.25308 = 0;
      D.25309 = values + 12;
      *D.25309 = 0;
      if (version == 0B) goto <D.25310>; else goto <D.25311>;
      <D.25310>:
      return;
      <D.25311>:
      str = mono_string_to_utf8 (version);
      ver = str;
      i = 0;
      goto <D.20345>;
      <D.20344>:
      D.25312 = i + 1;
      D.25313 = (long unsigned int) D.25312;
      D.25314 = D.25313 * 4;
      D.25315 = values + D.25314;
      D.25316 = strtol (ver, &p, 10);
      D.25317 = (unsigned int) D.25316;
      *D.25315 = D.25317;
      p.31 = p;
      D.25319 = *p.31;
      D.25320 = (int) D.25319;
      switch (D.25320) <default: <D.25322>, case 42: <D.20343>, case 46: <D.20341>>
      <D.20341>:
      p.31 = p;
      p.32 = p.31 + 1;
      p = p.32;
      goto <D.20342>;
      <D.20343>:
      p.31 = p;
      p.32 = p.31 + 1;
      p = p.32;
      goto <D.20342>;
      <D.25322>:
      <D.20342>:
      ver = p;
      i = i + 1;
      <D.20345>:
      if (i <= 3) goto <D.20344>; else goto <D.20346>;
      <D.20346>:
      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.25326;
  unsigned int D.25327;
  unsigned int D.25328;
  struct MonoArray * D.25329;
  long unsigned int D.25332;
  char * D.25333;
  struct MonoReflectionTypeBuilder * D.25334;
  long unsigned int D.25335;
  struct MonoClass * klass;
  guint32 idx;
  guint32 i;

  D.25326 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.25326);
  D.25327 = tb->table_idx;
  D.25328 = D.25327 | 33554432;
  klass->type_token = D.25328;
  idx = mono_image_fill_export_table_from_class (domain, klass, module_index, parent_index, assembly);
  D.25329 = tb->subtypes;
  if (D.25329 != 0B) goto <D.25330>; else goto <D.25331>;
  <D.25330>:
  i = 0;
  goto <D.19886>;
  <D.19885>:
  D.25332 = (long unsigned int) i;
  D.25329 = tb->subtypes;
  D.25333 = mono_array_addr_with_size (D.25329, 8, D.25332);
  D.25334 = MEM[(struct MonoReflectionTypeBuilder * *)D.25333];
  mono_image_fill_export_table (domain, D.25334, module_index, idx, assembly);
  i = i + 1;
  <D.19886>:
  D.25332 = (long unsigned int) i;
  D.25329 = tb->subtypes;
  D.25335 = mono_array_length (D.25329);
  if (D.25332 < D.25335) goto <D.19885>; else goto <D.19887>;
  <D.19887>:
  <D.25331>:
}


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.25336;
  unsigned int D.25337;
  guint32 D.25340;
  unsigned int D.25341;
  unsigned int D.25342;
  guint32 * D.25343;
  unsigned int D.25344;
  unsigned int D.25345;
  long unsigned int D.25346;
  long unsigned int D.25347;
  guint32 * D.25348;
  unsigned int D.25349;
  struct MonoClass * D.25350;
  guint32 * D.25353;
  unsigned int D.25354;
  unsigned int D.25355;
  unsigned int D.25357;
  guint32 * D.25358;
  const char * D.25359;
  struct MonoDynamicStream * D.25360;
  unsigned int D.25361;
  guint32 * D.25362;
  const char * D.25363;
  unsigned int D.25364;
  unsigned int D.25365;
  struct MonoClassExt * D.25366;
  struct GList * D.25369;
  unsigned int D.25372;
  void * D.25373;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 visib;
  guint32 res;

  D.25336 = klass->flags;
  visib = D.25336 & 7;
  D.25337 = visib & 3;
  if (D.25337 == 0) goto <D.25338>; else goto <D.25339>;
  <D.25338>:
  D.25340 = 0;
  return D.25340;
  <D.25339>:
  table = &assembly->tables[39];
  D.25341 = table->rows;
  D.25342 = D.25341 + 1;
  table->rows = D.25342;
  D.25341 = table->rows;
  alloc_table (table, D.25341);
  D.25343 = table->values;
  D.25344 = table->next_idx;
  D.25345 = D.25344 * 5;
  D.25346 = (long unsigned int) D.25345;
  D.25347 = D.25346 * 4;
  values = D.25343 + D.25347;
  D.25336 = klass->flags;
  *values = D.25336;
  D.25348 = values + 4;
  D.25349 = klass->type_token;
  *D.25348 = D.25349;
  D.25350 = klass->nested_in;
  if (D.25350 != 0B) goto <D.25351>; else goto <D.25352>;
  <D.25351>:
  D.25353 = values + 16;
  D.25354 = parent_index << 2;
  D.25355 = D.25354 + 2;
  *D.25353 = D.25355;
  goto <D.25356>;
  <D.25352>:
  D.25353 = values + 16;
  D.25357 = module_index << 2;
  *D.25353 = D.25357;
  <D.25356>:
  D.25358 = values + 8;
  D.25359 = klass->name;
  D.25360 = &assembly->sheap;
  D.25361 = string_heap_insert (D.25360, D.25359);
  *D.25358 = D.25361;
  D.25362 = values + 12;
  D.25363 = klass->name_space;
  D.25360 = &assembly->sheap;
  D.25364 = string_heap_insert (D.25360, D.25363);
  *D.25362 = D.25364;
  res = table->next_idx;
  D.25344 = table->next_idx;
  D.25365 = D.25344 + 1;
  table->next_idx = D.25365;
  D.25366 = klass->ext;
  if (D.25366 != 0B) goto <D.25367>; else goto <D.25368>;
  <D.25367>:
  D.25366 = klass->ext;
  D.25369 = D.25366->nested_classes;
  if (D.25369 != 0B) goto <D.25370>; else goto <D.25371>;
  <D.25370>:
  {
    struct GList * tmp;

    D.25366 = klass->ext;
    tmp = D.25366->nested_classes;
    goto <D.19873>;
    <D.19872>:
    D.25344 = table->next_idx;
    D.25372 = D.25344 + 4294967295;
    D.25373 = tmp->data;
    mono_image_fill_export_table_from_class (domain, D.25373, module_index, D.25372, assembly);
    tmp = tmp->next;
    <D.19873>:
    if (tmp != 0B) goto <D.19872>; else goto <D.19874>;
    <D.19874>:
  }
  <D.25371>:
  <D.25368>:
  D.25340 = res;
  return D.25340;
}


mono_image_fill_file_table (struct MonoDomain * domain, struct MonoReflectionModule * module, struct MonoDynamicImage * assembly)
{
  unsigned int D.25375;
  unsigned int D.25376;
  guint32 * D.25377;
  unsigned int D.25378;
  unsigned int D.25379;
  long unsigned int D.25380;
  long unsigned int D.25381;
  guint32 * D.25382;
  struct MonoImage * D.25383;
  const char * D.25384;
  struct MonoDynamicStream * D.25385;
  unsigned int D.25386;
  unsigned char D.25387;
  unsigned char D.25388;
  struct MonoReflectionAssemblyBuilder * D.25391;
  struct MonoString * D.25392;
  char * D.25394;
  char * b.33;
  guint32 * D.25396;
  long int b.34;
  long int blob_size.35;
  long int D.25399;
  unsigned int D.25400;
  struct MonoDynamicStream * D.25401;
  unsigned int D.25402;
  unsigned int D.25403;
  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.25375 = table->rows;
      D.25376 = D.25375 + 1;
      table->rows = D.25376;
      D.25375 = table->rows;
      alloc_table (table, D.25375);
      D.25377 = table->values;
      D.25378 = table->next_idx;
      D.25379 = D.25378 * 3;
      D.25380 = (long unsigned int) D.25379;
      D.25381 = D.25380 * 4;
      values = D.25377 + D.25381;
      *values = 0;
      D.25382 = values + 4;
      D.25383 = module->image;
      D.25384 = D.25383->module_name;
      D.25385 = &assembly->sheap;
      D.25386 = string_heap_insert (D.25385, D.25384);
      *D.25382 = D.25386;
      D.25383 = module->image;
      D.25387 = BIT_FIELD_REF <*D.25383, 8, 224>;
      D.25388 = D.25387 & 8;
      if (D.25388 != 0) goto <D.25389>; else goto <D.25390>;
      <D.25389>:
      D.25391 = MEM[(struct MonoReflectionModuleBuilder *)module].assemblyb;
      D.25392 = D.25391->dir;
      dir = mono_string_to_utf8 (D.25392);
      D.25383 = module->image;
      D.25384 = D.25383->module_name;
      path = monoeg_g_strdup_printf ("%s%c%s", dir, 47, D.25384);
      goto <D.25393>;
      <D.25390>:
      dir = 0B;
      D.25383 = module->image;
      D.25394 = D.25383->name;
      path = monoeg_strdup (D.25394);
      <D.25393>:
      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.25396 = values + 8;
      b.33 = b;
      b.34 = (long int) b.33;
      blob_size.35 = (long int) &blob_size;
      D.25399 = b.34 - blob_size.35;
      D.25400 = (unsigned int) D.25399;
      D.25401 = &assembly->blob;
      D.25402 = mono_image_add_stream_data (D.25401, &blob_size, D.25400);
      *D.25396 = D.25402;
      D.25401 = &assembly->blob;
      mono_image_add_stream_data (D.25401, &hash, 20);
      D.25378 = table->next_idx;
      D.25403 = D.25378 + 1;
      table->next_idx = D.25403;
    }
  finally
    {
      blob_size = {CLOBBER};
      hash = {CLOBBER};
      b = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.25404>; else goto <D.25405>;
  <D.25404>:
  D.25406 = __strdup (str);
  return D.25406;
  <D.25405>:
  D.25406 = 0B;
  return D.25406;
}


mono_image_fill_export_table_from_module (struct MonoDomain * domain, struct MonoReflectionModule * module, guint32 module_index, struct MonoDynamicImage * assembly)
{
  unsigned int D.25408;
  unsigned int D.25409;
  unsigned int D.25410;
  unsigned int D.25411;
  <unnamed-unsigned:24> D.25414;
  unsigned int D.25415;
  struct MonoImage * image;
  struct MonoTableInfo * t;
  guint32 i;

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

    D.25408 = i + 1;
    D.25409 = D.25408 | 33554432;
    klass = mono_class_get (image, D.25409);
    D.25410 = klass->flags;
    D.25411 = D.25410 & 1;
    if (D.25411 != 0) goto <D.25412>; else goto <D.25413>;
    <D.25412>:
    mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
    <D.25413>:
  }
  i = i + 1;
  <D.19899>:
  D.25414 = t->rows;
  D.25415 = (unsigned int) D.25414;
  if (D.25415 > i) goto <D.19898>; else goto <D.19900>;
  <D.19900>:
}


mono_image_fill_export_table_from_type_forwarders (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly)
{
  struct MonoArray * D.25416;
  long unsigned int D.25419;
  char * D.25420;
  _Bool D.25423;
  long int D.25424;
  long int D.25425;
  long unsigned int D.25428;
  struct MonoClass * klass;
  int i;

  D.25416 = assemblyb->type_forwarders;
  if (D.25416 == 0B) goto <D.25417>; else goto <D.25418>;
  <D.25417>:
  return;
  <D.25418>:
  i = 0;
  goto <D.19929>;
  <D.19928>:
  {
    struct MonoReflectionType * t;
    struct MonoType * type;

    D.25419 = (long unsigned int) i;
    D.25416 = assemblyb->type_forwarders;
    D.25420 = mono_array_addr_with_size (D.25416, 8, D.25419);
    t = MEM[(struct MonoReflectionType * *)D.25420];
    if (t == 0B) goto <D.25421>; else goto <D.25422>;
    <D.25421>:
    // predicted unlikely by continue predictor.
    goto <D.19927>;
    <D.25422>:
    type = mono_reflection_type_get_handle (t);
    D.25423 = type == 0B;
    D.25424 = (long int) D.25423;
    D.25425 = __builtin_expect (D.25424, 0);
    if (D.25425 != 0) goto <D.25426>; else goto <D.25427>;
    <D.25426>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3863, "type");
    <D.25427>:
    klass = mono_class_from_mono_type (type);
    add_exported_type (assemblyb, assembly, klass, 0);
  }
  <D.19927>:
  i = i + 1;
  <D.19929>:
  D.25419 = (long unsigned int) i;
  D.25416 = assemblyb->type_forwarders;
  D.25428 = mono_array_length (D.25416);
  if (D.25419 < D.25428) goto <D.19928>; else goto <D.19930>;
  <D.19930>:
}


add_exported_type (struct MonoReflectionAssemblyBuilder * assemblyb, struct MonoDynamicImage * assembly, struct MonoClass * klass, guint32 parent_index)
{
  struct MonoClass * D.25430;
  unsigned int D.25433;
  struct MonoImage * D.25435;
  unsigned int D.25436;
  _Bool D.25437;
  long int D.25438;
  long int D.25439;
  unsigned int D.25442;
  unsigned int D.25443;
  unsigned int D.25444;
  guint32 * D.25445;
  unsigned int D.25446;
  long unsigned int D.25447;
  long unsigned int D.25448;
  guint32 iftmp.36;
  guint32 * D.25453;
  guint32 * D.25454;
  guint32 * D.25455;
  const char * D.25456;
  struct MonoDynamicStream * D.25457;
  unsigned int D.25458;
  guint32 * D.25459;
  const char * D.25460;
  unsigned int D.25461;
  unsigned int D.25462;
  unsigned int D.25463;
  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.25430 = klass->nested_in;
      if (D.25430 != 0B) goto <D.25431>; else goto <D.25432>;
      <D.25431>:
      D.25433 = parent_index << 2;
      impl = D.25433 + 2;
      forwarder = 0;
      goto <D.25434>;
      <D.25432>:
      D.25435 = klass->image;
      scope = resolution_scope_from_image (assembly, D.25435);
      D.25436 = scope & 3;
      D.25437 = D.25436 != 2;
      D.25438 = (long int) D.25437;
      D.25439 = __builtin_expect (D.25438, 0);
      if (D.25439 != 0) goto <D.25440>; else goto <D.25441>;
      <D.25440>:
      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.25441>:
      scope_idx = scope >> 2;
      D.25442 = scope_idx << 2;
      impl = D.25442 + 1;
      <D.25434>:
      table = &assembly->tables[39];
      D.25443 = table->rows;
      D.25444 = D.25443 + 1;
      table->rows = D.25444;
      D.25443 = table->rows;
      alloc_table (table, D.25443);
      current_idx = table->next_idx;
      D.25445 = table->values;
      D.25446 = current_idx * 5;
      D.25447 = (long unsigned int) D.25446;
      D.25448 = D.25447 * 4;
      values = D.25445 + D.25448;
      if (forwarder != 0) goto <D.25450>; else goto <D.25451>;
      <D.25450>:
      iftmp.36 = 2097152;
      goto <D.25452>;
      <D.25451>:
      iftmp.36 = 0;
      <D.25452>:
      *values = iftmp.36;
      D.25453 = values + 4;
      *D.25453 = 0;
      D.25454 = values + 16;
      *D.25454 = impl;
      D.25455 = values + 8;
      D.25456 = klass->name;
      D.25457 = &assembly->sheap;
      D.25458 = string_heap_insert (D.25457, D.25456);
      *D.25455 = D.25458;
      D.25459 = values + 12;
      D.25460 = klass->name_space;
      D.25457 = &assembly->sheap;
      D.25461 = string_heap_insert (D.25457, D.25460);
      *D.25459 = D.25461;
      D.25462 = table->next_idx;
      D.25463 = D.25462 + 1;
      table->next_idx = D.25463;
      goto <D.19917>;
      <D.19916>:
      add_exported_type (assemblyb, assembly, nested, current_idx);
      <D.19917>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.19916>; else goto <D.19918>;
      <D.19918>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


resolution_scope_from_image (struct MonoDynamicImage * assembly, struct MonoImage * image)
{
  struct GHashTable * D.25464;
  void * D.25465;
  long int D.25466;
  guint32 D.25469;
  struct MonoAssembly * D.25470;
  unsigned char D.25471;
  struct MonoAssembly * D.25474;
  unsigned int D.25477;
  unsigned int token.37;
  unsigned int D.25479;
  unsigned int D.25480;
  unsigned int D.25481;
  guint32 * D.25482;
  long unsigned int D.25483;
  long unsigned int D.25484;
  const char * D.25485;
  struct MonoDynamicStream * D.25486;
  unsigned int D.25487;
  void * D.25488;
  struct MonoTableInfo * D.25492;
  unsigned int token.38;
  unsigned int D.25494;
  unsigned int D.25495;
  long unsigned int D.25496;
  long unsigned int D.25497;
  guint32 * D.25498;
  const char * D.25499;
  unsigned int D.25500;
  unsigned int D.25501;
  guint32 * D.25502;
  unsigned int D.25503;
  guint32 * D.25504;
  unsigned int D.25505;
  guint32 * D.25506;
  unsigned int D.25507;
  guint32 * D.25508;
  guint32 * D.25509;
  guint32 * D.25510;
  int D.19353;
  int iftmp.39;
  int D.19349;
  const char[1] * D.25514;
  unsigned char D.25515;
  int D.25516;
  unsigned char D.25517;
  int D.25518;
  _Bool D.25519;
  _Bool D.25520;
  _Bool D.25521;
  const unsigned char * D.25524;
  unsigned char D.25525;
  int D.25526;
  const unsigned char * D.25527;
  unsigned char D.25528;
  int D.25529;
  _Bool D.25530;
  _Bool D.25531;
  const unsigned char * D.25534;
  unsigned char D.25535;
  int D.25536;
  const unsigned char * D.25537;
  unsigned char D.25538;
  int D.25539;
  _Bool D.25540;
  _Bool D.25541;
  const unsigned char * D.25544;
  unsigned char D.25545;
  int D.25546;
  const unsigned char * D.25547;
  unsigned char D.25548;
  int D.25549;
  const char * D.25551;
  unsigned char D.25552;
  int D.25553;
  unsigned int D.25556;
  unsigned int publen.40;
  guint32 * D.25560;
  struct MonoDynamicStream * D.25561;
  unsigned int D.25562;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;
  guint32 cols[9];
  const char * pubkey;
  guint32 publen;

  try
    {
      D.25464 = assembly->handleref;
      D.25465 = monoeg_g_hash_table_lookup (D.25464, image);
      D.25466 = (long int) D.25465;
      token = (guint32) D.25466;
      if (token != 0) goto <D.25467>; else goto <D.25468>;
      <D.25467>:
      D.25469 = token;
      return D.25469;
      <D.25468>:
      D.25470 = image->assembly;
      D.25471 = D.25470->dynamic;
      if (D.25471 != 0) goto <D.25472>; else goto <D.25473>;
      <D.25472>:
      D.25470 = image->assembly;
      D.25474 = assembly->image.assembly;
      if (D.25470 == D.25474) goto <D.25475>; else goto <D.25476>;
      <D.25475>:
      table = &assembly->tables[26];
      D.25477 = table->next_idx;
      token.37 = D.25477;
      D.25479 = token.37 + 1;
      table->next_idx = D.25479;
      token = token.37;
      D.25480 = table->rows;
      D.25481 = D.25480 + 1;
      table->rows = D.25481;
      D.25480 = table->rows;
      alloc_table (table, D.25480);
      D.25482 = table->values;
      D.25483 = (long unsigned int) token;
      D.25484 = D.25483 * 4;
      values = D.25482 + D.25484;
      D.25485 = image->module_name;
      D.25486 = &assembly->sheap;
      D.25487 = string_heap_insert (D.25486, D.25485);
      *values = D.25487;
      token = token << 2;
      token = token | 1;
      D.25483 = (long unsigned int) token;
      D.25488 = (void *) D.25483;
      D.25464 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.25464, image, D.25488, 0);
      D.25469 = token;
      return D.25469;
      <D.25476>:
      <D.25473>:
      D.25470 = image->assembly;
      D.25471 = D.25470->dynamic;
      if (D.25471 != 0) goto <D.25489>; else goto <D.25490>;
      <D.25489>:
      memset (&cols, 0, 36);
      goto <D.25491>;
      <D.25490>:
      D.25470 = image->assembly;
      image = D.25470->image;
      D.25492 = &image->tables[32];
      mono_metadata_decode_row (D.25492, 0, &cols, 9);
      <D.25491>:
      table = &assembly->tables[35];
      D.25477 = table->next_idx;
      token.38 = D.25477;
      D.25494 = token.38 + 1;
      table->next_idx = D.25494;
      token = token.38;
      D.25480 = table->rows;
      D.25481 = D.25480 + 1;
      table->rows = D.25481;
      D.25480 = table->rows;
      alloc_table (table, D.25480);
      D.25482 = table->values;
      D.25495 = token * 9;
      D.25496 = (long unsigned int) D.25495;
      D.25497 = D.25496 * 4;
      values = D.25482 + D.25497;
      D.25498 = values + 24;
      D.25499 = image->assembly_name;
      D.25486 = &assembly->sheap;
      D.25500 = string_heap_insert (D.25486, D.25499);
      *D.25498 = D.25500;
      D.25501 = cols[1];
      *values = D.25501;
      D.25502 = values + 4;
      D.25503 = cols[2];
      *D.25502 = D.25503;
      D.25504 = values + 8;
      D.25505 = cols[3];
      *D.25504 = D.25505;
      D.25506 = values + 12;
      D.25507 = cols[4];
      *D.25506 = D.25507;
      D.25508 = values + 16;
      *D.25508 = 0;
      D.25509 = values + 28;
      *D.25509 = 0;
      D.25510 = values + 32;
      *D.25510 = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.25470 = image->assembly;
          __s2 = D.25470->aname.culture;
          D.25514 = "";
          D.25515 = MEM[(const unsigned char *)D.25514];
          D.25516 = (int) D.25515;
          D.25517 = *__s2;
          D.25518 = (int) D.25517;
          __result = D.25516 - D.25518;
          {
            D.25519 = __s1_len != 0;
            D.25520 = __result == 0;
            D.25521 = D.25519 & D.25520;
            if (D.25521 != 0) goto <D.25522>; else goto <D.25523>;
            <D.25522>:
            D.25524 = &MEM[(void *)"" + 1B];
            D.25525 = *D.25524;
            D.25526 = (int) D.25525;
            D.25527 = __s2 + 1;
            D.25528 = *D.25527;
            D.25529 = (int) D.25528;
            __result = D.25526 - D.25529;
            D.25530 = __s1_len > 1;
            D.25520 = __result == 0;
            D.25531 = D.25530 & D.25520;
            if (D.25531 != 0) goto <D.25532>; else goto <D.25533>;
            <D.25532>:
            D.25534 = &MEM[(void *)"" + 2B];
            D.25535 = *D.25534;
            D.25536 = (int) D.25535;
            D.25537 = __s2 + 2;
            D.25538 = *D.25537;
            D.25539 = (int) D.25538;
            __result = D.25536 - D.25539;
            D.25540 = __s1_len > 2;
            D.25520 = __result == 0;
            D.25541 = D.25540 & D.25520;
            if (D.25541 != 0) goto <D.25542>; else goto <D.25543>;
            <D.25542>:
            D.25544 = &MEM[(void *)"" + 3B];
            D.25545 = *D.25544;
            D.25546 = (int) D.25545;
            D.25547 = __s2 + 3;
            D.25548 = *D.25547;
            D.25549 = (int) D.25548;
            __result = D.25546 - D.25549;
            <D.25543>:
            <D.25533>:
            <D.25523>:
          }
          D.19349 = __result;
        }
        iftmp.39 = D.19349;
        goto <D.25550>;
        <D.25513>:
        D.25470 = image->assembly;
        D.25551 = D.25470->aname.culture;
        D.25552 = MEM[(const unsigned char * {ref-all})D.25551];
        D.25553 = (int) D.25552;
        iftmp.39 = -D.25553;
        <D.25550>:
        D.19353 = iftmp.39;
      }
      if (D.19353 != 0) goto <D.25554>; else goto <D.25555>;
      <D.25554>:
      D.25509 = values + 28;
      D.25470 = image->assembly;
      D.25551 = D.25470->aname.culture;
      D.25486 = &assembly->sheap;
      D.25556 = string_heap_insert (D.25486, D.25551);
      *D.25509 = D.25556;
      <D.25555>:
      pubkey = mono_image_get_public_key (image, &publen);
      if (pubkey != 0B) goto <D.25557>; else goto <D.25558>;
      <D.25557>:
      {
        guchar pubtoken[9];

        try
          {
            pubtoken[0] = 8;
            publen.40 = publen;
            mono_digest_get_public_token (&MEM[(void *)&pubtoken + 1B], pubkey, publen.40);
            D.25560 = values + 20;
            D.25561 = &assembly->blob;
            D.25562 = mono_image_add_stream_data (D.25561, &pubtoken, 9);
            *D.25560 = D.25562;
          }
        finally
          {
            pubtoken = {CLOBBER};
          }
      }
      goto <D.25563>;
      <D.25558>:
      D.25560 = values + 20;
      *D.25560 = 0;
      <D.25563>:
      token = token << 2;
      token = token | 2;
      D.25483 = (long unsigned int) token;
      D.25488 = (void *) D.25483;
      D.25464 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.25464, image, D.25488, 0);
      D.25469 = token;
      return D.25469;
    }
  finally
    {
      cols = {CLOBBER};
      publen = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25568;
  int D.25573;
  void * D.25575;
  long unsigned int D.25576;

  D.25568 = __builtin_constant_p (__len);
  if (D.25568 != 0) goto <D.25569>; else goto <D.25570>;
  <D.25569>:
  if (__len == 0) goto <D.25571>; else goto <D.25572>;
  <D.25571>:
  D.25573 = __builtin_constant_p (__ch);
  if (D.25573 == 0) goto <D.25566>; else goto <D.25574>;
  <D.25574>:
  if (__ch != 0) goto <D.25566>; else goto <D.25567>;
  <D.25566>:
  __warn_memset_zero_len ();
  D.25575 = __dest;
  return D.25575;
  <D.25567>:
  <D.25572>:
  <D.25570>:
  D.25576 = __builtin_object_size (__dest, 0);
  D.25575 = __builtin___memset_chk (__dest, __ch, __len, D.25576);
  return D.25575;
}


assembly_add_resource_manifest (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc, guint32 implementation)
{
  unsigned int D.25578;
  unsigned int D.25579;
  guint32 * D.25580;
  unsigned int D.25581;
  unsigned int D.25582;
  long unsigned int D.25583;
  long unsigned int D.25584;
  unsigned int D.25585;
  guint32 * D.25586;
  unsigned int D.25587;
  guint32 * D.25588;
  struct MonoString * D.25589;
  struct MonoDynamicStream * D.25590;
  unsigned int D.25591;
  guint32 * D.25592;
  unsigned int D.25593;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[40];
  D.25578 = table->rows;
  D.25579 = D.25578 + 1;
  table->rows = D.25579;
  D.25578 = table->rows;
  alloc_table (table, D.25578);
  D.25580 = table->values;
  D.25581 = table->next_idx;
  D.25582 = D.25581 * 4;
  D.25583 = (long unsigned int) D.25582;
  D.25584 = D.25583 * 4;
  values = D.25580 + D.25584;
  D.25585 = rsrc->offset;
  *values = D.25585;
  D.25586 = values + 4;
  D.25587 = rsrc->attrs;
  *D.25586 = D.25587;
  D.25588 = values + 8;
  D.25589 = rsrc->name;
  D.25590 = &assembly->sheap;
  D.25591 = string_heap_insert_mstring (D.25590, D.25589);
  *D.25588 = D.25591;
  D.25592 = values + 12;
  *D.25592 = implementation;
  D.25581 = table->next_idx;
  D.25593 = D.25581 + 1;
  table->next_idx = D.25593;
}


string_heap_insert (struct MonoDynamicStream * sh, const char * str)
{
  struct GHashTable * D.25594;
  int D.25595;
  guint32 D.25598;
  void * oldval.41;
  long int oldval.42;
  long unsigned int D.25601;
  unsigned int D.25602;
  unsigned int D.25603;
  int D.25604;
  long unsigned int D.25605;
  void * D.25606;
  gchar * D.25607;
  long unsigned int D.25608;
  char * D.25609;
  sizetype D.25610;
  char * D.25611;
  unsigned int D.25612;
  unsigned int D.25613;
  guint32 idx;
  guint32 len;
  void * oldkey;
  void * oldval;

  try
    {
      D.25594 = sh->hash;
      D.25595 = monoeg_g_hash_table_lookup_extended (D.25594, str, &oldkey, &oldval);
      if (D.25595 != 0) goto <D.25596>; else goto <D.25597>;
      <D.25596>:
      oldval.41 = oldval;
      oldval.42 = (long int) oldval.41;
      D.25598 = (guint32) oldval.42;
      return D.25598;
      <D.25597>:
      D.25601 = strlen (str);
      D.25602 = (unsigned int) D.25601;
      len = D.25602 + 1;
      idx = sh->index;
      D.25603 = idx + len;
      D.25604 = (int) D.25603;
      make_room_in_stream (sh, D.25604);
      D.25605 = (long unsigned int) idx;
      D.25606 = (void *) D.25605;
      D.25607 = monoeg_strdup (str);
      D.25594 = sh->hash;
      monoeg_g_hash_table_insert_replace (D.25594, D.25607, D.25606, 0);
      D.25608 = (long unsigned int) len;
      D.25609 = sh->data;
      D.25610 = (sizetype) idx;
      D.25611 = D.25609 + D.25610;
      memcpy (D.25611, str, D.25608);
      D.25612 = sh->index;
      D.25613 = D.25612 + len;
      sh->index = D.25613;
      D.25598 = idx;
      return D.25598;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


mono_image_get_method_info (struct MonoReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25616;
  unsigned int D.25617;
  struct MonoString * D.25618;
  int iftmp.43;
  unsigned int D.25622;
  unsigned int D.25625;
  unsigned int D.25626;
  unsigned int D.25628;
  unsigned int D.25629;
  unsigned int D.25630;
  guint32 * D.25631;
  unsigned int D.25632;
  long unsigned int D.25633;
  long unsigned int D.25634;
  unsigned int D.25635;
  unsigned int D.25636;
  unsigned int ncharset.44;
  unsigned int D.25638;
  unsigned int extra_flags.45;
  unsigned int D.25640;
  guint32 * D.25641;
  unsigned int D.25642;
  unsigned int D.25643;
  unsigned int D.25644;
  struct MonoString * D.25645;
  guint32 * D.25648;
  struct MonoDynamicStream * D.25649;
  unsigned int D.25650;
  struct MonoString * D.25652;
  unsigned int D.25653;
  guint32 * D.25654;
  unsigned int D.25655;
  unsigned int D.25656;
  long unsigned int D.25659;
  long unsigned int D.25660;
  guint32 * D.25661;
  struct MonoArray * D.25662;
  long unsigned int D.25665;
  unsigned int D.25666;
  unsigned int D.25667;
  long unsigned int D.25668;
  char * D.25669;
  void * D.25670;
  long unsigned int D.25671;
  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.25616 = rmb.table_idx;
      D.25617 = *D.25616;
      mb->table_idx = D.25617;
      D.25618 = mb->dll;
      if (D.25618 != 0B) goto <D.25619>; else goto <D.25620>;
      <D.25619>:
      {
        guint32 moduleref;
        int ncharset;
        int extra_flags;

        D.25622 = mb->charset;
        if (D.25622 != 0) goto <D.25623>; else goto <D.25624>;
        <D.25623>:
        D.25622 = mb->charset;
        D.25625 = D.25622 + 2147483647;
        D.25626 = D.25625 * 2;
        iftmp.43 = (int) D.25626;
        goto <D.25627>;
        <D.25624>:
        iftmp.43 = 0;
        <D.25627>:
        ncharset = iftmp.43;
        D.25628 = mb->extra_flags;
        extra_flags = (int) D.25628;
        table = &assembly->tables[28];
        D.25629 = table->rows;
        D.25630 = D.25629 + 1;
        table->rows = D.25630;
        D.25629 = table->rows;
        alloc_table (table, D.25629);
        D.25631 = table->values;
        D.25629 = table->rows;
        D.25632 = D.25629 * 4;
        D.25633 = (long unsigned int) D.25632;
        D.25634 = D.25633 * 4;
        values = D.25631 + D.25634;
        D.25635 = mb->native_cc;
        D.25636 = D.25635 << 8;
        ncharset.44 = (unsigned int) ncharset;
        D.25638 = D.25636 | ncharset.44;
        extra_flags.45 = (unsigned int) extra_flags;
        D.25640 = D.25638 | extra_flags.45;
        *values = D.25640;
        D.25641 = values + 4;
        D.25642 = mb->table_idx;
        D.25643 = D.25642 << 1;
        D.25644 = D.25643 | 1;
        *D.25641 = D.25644;
        D.25645 = mb->dllentry;
        if (D.25645 != 0B) goto <D.25646>; else goto <D.25647>;
        <D.25646>:
        D.25648 = values + 8;
        D.25645 = mb->dllentry;
        D.25649 = &assembly->sheap;
        D.25650 = string_heap_insert_mstring (D.25649, D.25645);
        *D.25648 = D.25650;
        goto <D.25651>;
        <D.25647>:
        D.25648 = values + 8;
        D.25652 = mb->name;
        D.25649 = &assembly->sheap;
        D.25653 = string_heap_insert_mstring (D.25649, D.25652);
        *D.25648 = D.25653;
        <D.25651>:
        D.25618 = mb->dll;
        D.25649 = &assembly->sheap;
        moduleref = string_heap_insert_mstring (D.25649, D.25618);
        D.25654 = values + 12;
        D.25655 = find_index_in_table (assembly, 26, 0, moduleref);
        *D.25654 = D.25655;
        D.25656 = *D.25654;
        if (D.25656 == 0) goto <D.25657>; else goto <D.25658>;
        <D.25657>:
        table = &assembly->tables[26];
        D.25629 = table->rows;
        D.25630 = D.25629 + 1;
        table->rows = D.25630;
        D.25629 = table->rows;
        alloc_table (table, D.25629);
        D.25631 = table->values;
        D.25629 = table->rows;
        D.25659 = (long unsigned int) D.25629;
        D.25660 = D.25659 * 4;
        D.25661 = D.25631 + D.25660;
        *D.25661 = moduleref;
        D.25654 = values + 12;
        D.25629 = table->rows;
        *D.25654 = D.25629;
        <D.25658>:
      }
      <D.25620>:
      D.25662 = mb->generic_params;
      if (D.25662 != 0B) goto <D.25663>; else goto <D.25664>;
      <D.25663>:
      table = &assembly->tables[42];
      D.25662 = mb->generic_params;
      D.25665 = mono_array_length (D.25662);
      D.25629 = table->rows;
      D.25666 = (unsigned int) D.25665;
      D.25667 = D.25629 + D.25666;
      table->rows = D.25667;
      D.25629 = table->rows;
      alloc_table (table, D.25629);
      i = 0;
      goto <D.19155>;
      <D.19154>:
      {
        guint32 owner;

        D.25642 = mb->table_idx;
        D.25643 = D.25642 << 1;
        owner = D.25643 | 1;
        D.25668 = (long unsigned int) i;
        D.25662 = mb->generic_params;
        D.25669 = mono_array_addr_with_size (D.25662, 8, D.25668);
        D.25670 = MEM[(void * *)D.25669];
        mono_image_get_generic_param_info (D.25670, owner, assembly);
      }
      i = i + 1;
      <D.19155>:
      D.25668 = (long unsigned int) i;
      D.25662 = mb->generic_params;
      D.25671 = mono_array_length (D.25662);
      if (D.25668 < D.25671) goto <D.19154>; else goto <D.19156>;
      <D.19156>:
      <D.25664>:
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


reflection_methodbuilder_from_method_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoReflectionILGen * D.25672;
  struct MonoObject * D.25673;
  struct MonoReflectionType * D.25674;
  struct MonoArray * D.25675;
  struct MonoArray * D.25676;
  struct MonoGenericContainer * D.25677;
  struct MonoArray * D.25678;
  unsigned int D.25679;
  unsigned int D.25680;
  unsigned int D.25681;
  struct MonoArray * D.25682;
  struct MonoObject * D.25683;
  struct MonoString * D.25684;
  guint32 * D.25685;
  unsigned char D.25686;
  struct MonoArray * D.25687;
  struct MonoArray * D.25688;
  struct MonoArray * D.25689;
  struct MonoArray * D.25690;
  struct MonoArray * D.25691;
  struct MonoMethod * D.25692;
  struct MonoString * D.25693;
  unsigned int D.25696;
  int D.25697;
  unsigned int D.25698;
  int D.25699;
  unsigned int D.25700;
  int D.25701;
  struct MonoString * D.25702;

  memset (rmb, 0, 208);
  D.25672 = mb->ilgen;
  rmb->ilgen = D.25672;
  D.25673 = mb->rtype;
  D.25674 = mono_reflection_type_resolve_user_types (D.25673);
  rmb->rtype = D.25674;
  D.25675 = mb->parameters;
  rmb->parameters = D.25675;
  D.25676 = mb->generic_params;
  rmb->generic_params = D.25676;
  D.25677 = mb->generic_container;
  rmb->generic_container = D.25677;
  rmb->opt_types = 0B;
  D.25678 = mb->pinfo;
  rmb->pinfo = D.25678;
  D.25679 = mb->attrs;
  rmb->attrs = D.25679;
  D.25680 = mb->iattrs;
  rmb->iattrs = D.25680;
  D.25681 = mb->call_conv;
  rmb->call_conv = D.25681;
  D.25682 = mb->code;
  rmb->code = D.25682;
  D.25683 = mb->type;
  rmb->type = D.25683;
  D.25684 = mb->name;
  rmb->name = D.25684;
  D.25685 = &mb->table_idx;
  rmb->table_idx = D.25685;
  D.25686 = mb->init_locals;
  rmb->init_locals = D.25686;
  rmb->skip_visibility = 0;
  D.25687 = mb->return_modreq;
  rmb->return_modreq = D.25687;
  D.25688 = mb->return_modopt;
  rmb->return_modopt = D.25688;
  D.25689 = mb->param_modreq;
  rmb->param_modreq = D.25689;
  D.25690 = mb->param_modopt;
  rmb->param_modopt = D.25690;
  D.25691 = mb->permissions;
  rmb->permissions = D.25691;
  D.25692 = mb->mhandle;
  rmb->mhandle = D.25692;
  rmb->nrefs = 0;
  rmb->refs = 0B;
  D.25693 = mb->dll;
  if (D.25693 != 0B) goto <D.25694>; else goto <D.25695>;
  <D.25694>:
  D.25696 = mb->charset;
  D.25697 = (int) D.25696;
  rmb->charset = D.25697;
  D.25698 = mb->extra_flags;
  D.25699 = (int) D.25698;
  rmb->extra_flags = D.25699;
  D.25700 = mb->native_cc;
  D.25701 = (int) D.25700;
  rmb->native_cc = D.25701;
  D.25702 = mb->dllentry;
  rmb->dllentry = D.25702;
  D.25693 = mb->dll;
  rmb->dll = D.25693;
  <D.25695>:
}


mono_reflection_type_resolve_user_types (struct MonoReflectionType * type)
{
  struct MonoType * D.25706;
  struct MonoReflectionType * D.25707;
  int D.25708;
  int D.25711;
  struct MonoException * D.25714;

  if (type == 0B) goto <D.25703>; else goto <D.25705>;
  <D.25705>:
  D.25706 = type->type;
  if (D.25706 != 0B) goto <D.25703>; else goto <D.25704>;
  <D.25703>:
  D.25707 = type;
  return D.25707;
  <D.25704>:
  D.25708 = is_usertype (type);
  if (D.25708 != 0) goto <D.25709>; else goto <D.25710>;
  <D.25709>:
  type = mono_reflection_type_get_underlying_system_type (type);
  D.25711 = is_usertype (type);
  if (D.25711 != 0) goto <D.25712>; else goto <D.25713>;
  <D.25712>:
  D.25714 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported22");
  mono_raise_exception (D.25714);
  <D.25713>:
  <D.25710>:
  D.25707 = type;
  return D.25707;
}


mono_reflection_type_get_underlying_system_type (struct MonoReflectionType * t)
{
  struct MonoMethod * method_get_underlying_system_type.46;
  struct MonoClass * D.25719;
  struct MonoMethod * method_get_underlying_system_type.47;
  struct MonoReflectionType * D.25721;
  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.25717>; else goto <D.25718>;
  <D.25717>:
  D.25719 = mono_defaults.systemtype_class;
  method_get_underlying_system_type.47 = mono_class_get_method_from_name (D.25719, "get_UnderlyingSystemType", 0);
  method_get_underlying_system_type = method_get_underlying_system_type.47;
  <D.25718>:
  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.25721 = mono_runtime_invoke (usertype_method, t, 0B, 0B);
  return D.25721;
}


is_usertype (struct MonoReflectionType * ref)
{
  struct MonoVTable * D.25723;
  gboolean D.25724;
  int iftmp.48;
  struct MonoImage * D.25729;
  struct MonoImage * D.25730;
  int D.22947;
  int iftmp.49;
  int D.22943;
  const char[14] * D.25735;
  unsigned char D.25736;
  int D.25737;
  unsigned char D.25738;
  int D.25739;
  _Bool D.25740;
  _Bool D.25741;
  _Bool D.25742;
  const unsigned char * D.25745;
  unsigned char D.25746;
  int D.25747;
  const unsigned char * D.25748;
  unsigned char D.25749;
  int D.25750;
  _Bool D.25751;
  _Bool D.25752;
  const unsigned char * D.25755;
  unsigned char D.25756;
  int D.25757;
  const unsigned char * D.25758;
  unsigned char D.25759;
  int D.25760;
  _Bool D.25761;
  _Bool D.25762;
  const unsigned char * D.25765;
  unsigned char D.25766;
  int D.25767;
  const unsigned char * D.25768;
  unsigned char D.25769;
  int D.25770;
  const char * D.25772;
  struct MonoClass * class;

  D.25723 = MEM[(struct MonoObject *)ref].vtable;
  class = D.25723->klass;
  D.25729 = class->image;
  D.25730 = mono_defaults.corlib;
  if (D.25729 != D.25730) goto <D.25726>; else goto <D.25731>;
  <D.25731>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.25735 = "TypeDelegator";
      D.25736 = MEM[(const unsigned char *)D.25735];
      D.25737 = (int) D.25736;
      D.25738 = *__s2;
      D.25739 = (int) D.25738;
      __result = D.25737 - D.25739;
      {
        D.25740 = __s1_len != 0;
        D.25741 = __result == 0;
        D.25742 = D.25740 & D.25741;
        if (D.25742 != 0) goto <D.25743>; else goto <D.25744>;
        <D.25743>:
        D.25745 = &MEM[(void *)"TypeDelegator" + 1B];
        D.25746 = *D.25745;
        D.25747 = (int) D.25746;
        D.25748 = __s2 + 1;
        D.25749 = *D.25748;
        D.25750 = (int) D.25749;
        __result = D.25747 - D.25750;
        D.25751 = __s1_len > 1;
        D.25741 = __result == 0;
        D.25752 = D.25751 & D.25741;
        if (D.25752 != 0) goto <D.25753>; else goto <D.25754>;
        <D.25753>:
        D.25755 = &MEM[(void *)"TypeDelegator" + 2B];
        D.25756 = *D.25755;
        D.25757 = (int) D.25756;
        D.25758 = __s2 + 2;
        D.25759 = *D.25758;
        D.25760 = (int) D.25759;
        __result = D.25757 - D.25760;
        D.25761 = __s1_len > 2;
        D.25741 = __result == 0;
        D.25762 = D.25761 & D.25741;
        if (D.25762 != 0) goto <D.25763>; else goto <D.25764>;
        <D.25763>:
        D.25765 = &MEM[(void *)"TypeDelegator" + 3B];
        D.25766 = *D.25765;
        D.25767 = (int) D.25766;
        D.25768 = __s2 + 3;
        D.25769 = *D.25768;
        D.25770 = (int) D.25769;
        __result = D.25767 - D.25770;
        <D.25764>:
        <D.25754>:
        <D.25744>:
      }
      D.22943 = __result;
    }
    iftmp.49 = D.22943;
    goto <D.25771>;
    <D.25734>:
    D.25772 = class->name;
    iftmp.49 = __builtin_strcmp ("TypeDelegator", D.25772);
    <D.25771>:
    D.22947 = iftmp.49;
  }
  if (D.22947 == 0) goto <D.25726>; else goto <D.25727>;
  <D.25726>:
  iftmp.48 = 1;
  goto <D.25728>;
  <D.25727>:
  iftmp.48 = 0;
  <D.25728>:
  D.25724 = iftmp.48;
  return D.25724;
}


mono_image_basic_method (struct ReflectionMethodBuilder * mb, struct MonoDynamicImage * assembly)
{
  guint32 * D.25774;
  unsigned int D.25775;
  unsigned int D.25776;
  unsigned int D.25777;
  unsigned int D.25778;
  long unsigned int D.25779;
  void * D.25780;
  struct MonoMethod * D.25781;
  struct GHashTable * D.25782;
  guint32 * D.25783;
  unsigned int D.25784;
  long unsigned int D.25785;
  long unsigned int D.25786;
  guint32 * D.25787;
  struct MonoString * D.25788;
  struct MonoDynamicStream * D.25789;
  unsigned int D.25790;
  guint32 * D.25791;
  unsigned int D.25792;
  guint32 * D.25793;
  unsigned int D.25794;
  guint32 * D.25795;
  unsigned int D.25796;
  unsigned int D.25797;
  guint32 * D.25798;
  struct MonoArray * D.25799;
  unsigned int D.25800;
  struct MonoArray * D.25801;
  guint32 * D.25804;
  unsigned int D.25805;
  unsigned int D.25806;
  long unsigned int D.25807;
  long unsigned int D.25808;
  long unsigned int D.25809;
  char * D.25810;
  void * D.25811;
  long unsigned int D.25814;
  unsigned int D.25815;
  unsigned int D.25816;
  unsigned int D.25817;
  long unsigned int D.25818;
  long unsigned int D.25819;
  char * D.25820;
  unsigned int D.25823;
  struct MonoString * D.25824;
  unsigned int D.25827;
  struct MonoReflectionMarshal * D.25829;
  unsigned int D.25832;
  unsigned int D.25833;
  unsigned int D.25834;
  long unsigned int D.25835;
  long unsigned int D.25836;
  unsigned int D.25837;
  unsigned int D.25838;
  guint32 * D.25839;
  unsigned int D.25840;
  unsigned int D.25841;
  unsigned int D.25842;
  unsigned int D.25843;
  unsigned int D.25846;
  long unsigned int D.25847;
  long unsigned int D.25848;
  guint32 * D.25849;
  unsigned int D.25850;
  unsigned int D.25851;
  unsigned int D.25852;
  guint32 * D.25853;
  struct MonoObject * D.25854;
  unsigned int D.25855;
  unsigned int field_type.50;
  long unsigned int D.25857;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint i;
  guint count;

  table = &assembly->tables[6];
  D.25774 = mb->table_idx;
  D.25775 = table->next_idx;
  D.25776 = D.25775;
  D.25777 = D.25776 + 1;
  table->next_idx = D.25777;
  *D.25774 = D.25776;
  D.25774 = mb->table_idx;
  D.25778 = *D.25774;
  D.25779 = (long unsigned int) D.25778;
  D.25780 = (void *) D.25779;
  D.25781 = mb->mhandle;
  D.25782 = assembly->method_to_table_idx;
  monoeg_g_hash_table_insert_replace (D.25782, D.25781, D.25780, 0);
  D.25783 = table->values;
  D.25774 = mb->table_idx;
  D.25778 = *D.25774;
  D.25784 = D.25778 * 6;
  D.25785 = (long unsigned int) D.25784;
  D.25786 = D.25785 * 4;
  values = D.25783 + D.25786;
  D.25787 = values + 12;
  D.25788 = mb->name;
  D.25789 = &assembly->sheap;
  D.25790 = string_heap_insert_mstring (D.25789, D.25788);
  *D.25787 = D.25790;
  D.25791 = values + 8;
  D.25792 = mb->attrs;
  *D.25791 = D.25792;
  D.25793 = values + 4;
  D.25794 = mb->iattrs;
  *D.25793 = D.25794;
  D.25795 = values + 16;
  D.25796 = method_builder_encode_signature (assembly, mb);
  *D.25795 = D.25796;
  D.25797 = method_encode_code (assembly, mb);
  *values = D.25797;
  table = &assembly->tables[8];
  D.25798 = values + 20;
  D.25775 = table->next_idx;
  *D.25798 = D.25775;
  D.25799 = mb->permissions;
  D.25774 = mb->table_idx;
  D.25778 = *D.25774;
  D.25800 = D.25778 | 100663296;
  mono_image_add_decl_security (assembly, D.25800, D.25799);
  D.25801 = mb->pinfo;
  if (D.25801 != 0B) goto <D.25802>; else goto <D.25803>;
  <D.25802>:
  {
    struct MonoDynamicTable * mtable;
    guint32 * mvalues;

    mtable = &assembly->tables[13];
    D.25804 = mtable->values;
    D.25805 = mtable->next_idx;
    D.25806 = D.25805 * 2;
    D.25807 = (long unsigned int) D.25806;
    D.25808 = D.25807 * 4;
    mvalues = D.25804 + D.25808;
    count = 0;
    i = 0;
    goto <D.19105>;
    <D.19104>:
    D.25809 = (long unsigned int) i;
    D.25801 = mb->pinfo;
    D.25810 = mono_array_addr_with_size (D.25801, 8, D.25809);
    D.25811 = MEM[(void * *)D.25810];
    if (D.25811 != 0B) goto <D.25812>; else goto <D.25813>;
    <D.25812>:
    count = count + 1;
    <D.25813>:
    i = i + 1;
    <D.19105>:
    D.25809 = (long unsigned int) i;
    D.25801 = mb->pinfo;
    D.25814 = mono_array_length (D.25801);
    if (D.25809 < D.25814) goto <D.19104>; else goto <D.19106>;
    <D.19106>:
    D.25815 = table->rows;
    D.25816 = D.25815 + count;
    table->rows = D.25816;
    D.25815 = table->rows;
    alloc_table (table, D.25815);
    D.25783 = table->values;
    D.25775 = table->next_idx;
    D.25817 = D.25775 * 3;
    D.25818 = (long unsigned int) D.25817;
    D.25819 = D.25818 * 4;
    values = D.25783 + D.25819;
    i = 0;
    goto <D.19110>;
    <D.19109>:
    {
      struct MonoReflectionParamBuilder * pb;

      D.25809 = (long unsigned int) i;
      D.25801 = mb->pinfo;
      D.25820 = mono_array_addr_with_size (D.25801, 8, D.25809);
      pb = MEM[(struct MonoReflectionParamBuilder * *)D.25820];
      if (pb != 0B) goto <D.25821>; else goto <D.25822>;
      <D.25821>:
      D.25823 = pb->attrs;
      *values = D.25823;
      D.25793 = values + 4;
      *D.25793 = i;
      D.25824 = pb->name;
      if (D.25824 != 0B) goto <D.25825>; else goto <D.25826>;
      <D.25825>:
      D.25791 = values + 8;
      D.25824 = pb->name;
      D.25789 = &assembly->sheap;
      D.25827 = string_heap_insert_mstring (D.25789, D.25824);
      *D.25791 = D.25827;
      goto <D.25828>;
      <D.25826>:
      D.25791 = values + 8;
      *D.25791 = 0;
      <D.25828>:
      values = values + 12;
      D.25829 = pb->marshal_info;
      if (D.25829 != 0B) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      D.25832 = mtable->rows;
      D.25833 = D.25832 + 1;
      mtable->rows = D.25833;
      D.25832 = mtable->rows;
      alloc_table (mtable, D.25832);
      D.25804 = mtable->values;
      D.25832 = mtable->rows;
      D.25834 = D.25832 * 2;
      D.25835 = (long unsigned int) D.25834;
      D.25836 = D.25835 * 4;
      mvalues = D.25804 + D.25836;
      D.25775 = table->next_idx;
      D.25837 = D.25775 << 1;
      D.25838 = D.25837 | 1;
      *mvalues = D.25838;
      D.25839 = mvalues + 4;
      D.25829 = pb->marshal_info;
      D.25840 = encode_marshal_blob (assembly, D.25829);
      *D.25839 = D.25840;
      <D.25831>:
      D.25775 = table->next_idx;
      D.25841 = D.25775;
      D.25842 = D.25841 + 1;
      table->next_idx = D.25842;
      pb->table_idx = D.25841;
      D.25823 = pb->attrs;
      D.25843 = D.25823 & 4096;
      if (D.25843 != 0) goto <D.25844>; else goto <D.25845>;
      <D.25844>:
      {
        guint32 field_type;

        try
          {
            field_type = 0;
            mtable = &assembly->tables[11];
            D.25832 = mtable->rows;
            D.25833 = D.25832 + 1;
            mtable->rows = D.25833;
            D.25832 = mtable->rows;
            alloc_table (mtable, D.25832);
            D.25804 = mtable->values;
            D.25832 = mtable->rows;
            D.25846 = D.25832 * 4;
            D.25847 = (long unsigned int) D.25846;
            D.25848 = D.25847 * 4;
            mvalues = D.25804 + D.25848;
            D.25849 = mvalues + 8;
            D.25850 = pb->table_idx;
            D.25851 = D.25850 << 2;
            D.25852 = D.25851 | 1;
            *D.25849 = D.25852;
            D.25853 = mvalues + 12;
            D.25854 = pb->def_value;
            D.25855 = encode_constant (assembly, D.25854, &field_type);
            *D.25853 = D.25855;
            field_type.50 = field_type;
            *mvalues = field_type.50;
            D.25839 = mvalues + 4;
            *D.25839 = 0;
          }
        finally
          {
            field_type = {CLOBBER};
          }
      }
      <D.25845>:
      <D.25822>:
    }
    i = i + 1;
    <D.19110>:
    D.25809 = (long unsigned int) i;
    D.25801 = mb->pinfo;
    D.25857 = mono_array_length (D.25801);
    if (D.25809 < D.25857) goto <D.19109>; else goto <D.19111>;
    <D.19111>:
  }
  <D.25803>:
}


method_builder_encode_signature (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  guint32 iftmp.51;
  struct MonoArray * D.25859;
  long unsigned int D.25862;
  guint32 iftmp.52;
  struct MonoArray * D.25865;
  long unsigned int D.25868;
  guint32 iftmp.53;
  struct MonoArray * D.25871;
  long unsigned int D.25874;
  unsigned int D.25876;
  unsigned int D.25877;
  unsigned int D.25880;
  unsigned int D.25881;
  unsigned char D.25886;
  int D.25887;
  unsigned int D.25890;
  struct MonoArray * D.25891;
  struct MonoArray * D.25892;
  struct MonoReflectionType * D.25893;
  struct MonoArray * D.25894;
  long unsigned int D.25897;
  long unsigned int D.25898;
  char * D.25901;
  struct MonoArray * D.25902;
  long unsigned int D.25905;
  char * D.25908;
  char * D.25909;
  unsigned int i.54;
  char * D.25913;
  guint32 D.25914;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 ngparams;
  guint32 notypes;
  guint32 idx;

  try
    {
      D.25859 = mb->parameters;
      if (D.25859 != 0B) goto <D.25860>; else goto <D.25861>;
      <D.25860>:
      D.25859 = mb->parameters;
      D.25862 = mono_array_length (D.25859);
      iftmp.51 = (guint32) D.25862;
      goto <D.25863>;
      <D.25861>:
      iftmp.51 = 0;
      <D.25863>:
      nparams = iftmp.51;
      D.25865 = mb->generic_params;
      if (D.25865 != 0B) goto <D.25866>; else goto <D.25867>;
      <D.25866>:
      D.25865 = mb->generic_params;
      D.25868 = mono_array_length (D.25865);
      iftmp.52 = (guint32) D.25868;
      goto <D.25869>;
      <D.25867>:
      iftmp.52 = 0;
      <D.25869>:
      ngparams = iftmp.52;
      D.25871 = mb->opt_types;
      if (D.25871 != 0B) goto <D.25872>; else goto <D.25873>;
      <D.25872>:
      D.25871 = mb->opt_types;
      D.25874 = mono_array_length (D.25871);
      iftmp.53 = (guint32) D.25874;
      goto <D.25875>;
      <D.25873>:
      iftmp.53 = 0;
      <D.25875>:
      notypes = iftmp.53;
      sigbuffer_init (&buf, 32);
      D.25876 = mb->call_conv;
      idx = D.25876 & 96;
      D.25876 = mb->call_conv;
      D.25877 = D.25876 & 2;
      if (D.25877 != 0) goto <D.25878>; else goto <D.25879>;
      <D.25878>:
      idx = idx | 5;
      <D.25879>:
      D.25880 = mb->attrs;
      D.25881 = D.25880 & 16;
      if (D.25881 == 0) goto <D.25882>; else goto <D.25883>;
      <D.25882>:
      idx = idx | 32;
      <D.25883>:
      if (ngparams != 0) goto <D.25884>; else goto <D.25885>;
      <D.25884>:
      idx = idx | 16;
      <D.25885>:
      D.25886 = (unsigned char) idx;
      D.25887 = (int) D.25886;
      sigbuffer_add_byte (&buf, D.25887);
      if (ngparams != 0) goto <D.25888>; else goto <D.25889>;
      <D.25888>:
      sigbuffer_add_value (&buf, ngparams);
      <D.25889>:
      D.25890 = nparams + notypes;
      sigbuffer_add_value (&buf, D.25890);
      D.25891 = mb->return_modopt;
      D.25892 = mb->return_modreq;
      encode_custom_modifiers (assembly, D.25892, D.25891, &buf);
      D.25893 = mb->rtype;
      encode_reflection_type (assembly, D.25893, &buf);
      i = 0;
      goto <D.18916>;
      <D.18915>:
      {
        struct MonoArray * modreq;
        struct MonoArray * modopt;
        struct MonoReflectionType * pt;

        modreq = 0B;
        modopt = 0B;
        D.25894 = mb->param_modreq;
        if (D.25894 != 0B) goto <D.25895>; else goto <D.25896>;
        <D.25895>:
        D.25897 = (long unsigned int) i;
        D.25894 = mb->param_modreq;
        D.25898 = mono_array_length (D.25894);
        if (D.25897 < D.25898) goto <D.25899>; else goto <D.25900>;
        <D.25899>:
        D.25897 = (long unsigned int) i;
        D.25894 = mb->param_modreq;
        D.25901 = mono_array_addr_with_size (D.25894, 8, D.25897);
        modreq = MEM[(struct MonoArray * *)D.25901];
        <D.25900>:
        <D.25896>:
        D.25902 = mb->param_modopt;
        if (D.25902 != 0B) goto <D.25903>; else goto <D.25904>;
        <D.25903>:
        D.25897 = (long unsigned int) i;
        D.25902 = mb->param_modopt;
        D.25905 = mono_array_length (D.25902);
        if (D.25897 < D.25905) goto <D.25906>; else goto <D.25907>;
        <D.25906>:
        D.25897 = (long unsigned int) i;
        D.25902 = mb->param_modopt;
        D.25908 = mono_array_addr_with_size (D.25902, 8, D.25897);
        modopt = MEM[(struct MonoArray * *)D.25908];
        <D.25907>:
        <D.25904>:
        encode_custom_modifiers (assembly, modreq, modopt, &buf);
        D.25897 = (long unsigned int) i;
        D.25859 = mb->parameters;
        D.25909 = mono_array_addr_with_size (D.25859, 8, D.25897);
        pt = MEM[(struct MonoReflectionType * *)D.25909];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18916>:
      i.54 = (unsigned int) i;
      if (i.54 < nparams) goto <D.18915>; else goto <D.18917>;
      <D.18917>:
      if (notypes != 0) goto <D.25911>; else goto <D.25912>;
      <D.25911>:
      sigbuffer_add_byte (&buf, 65);
      <D.25912>:
      i = 0;
      goto <D.18920>;
      <D.18919>:
      {
        struct MonoReflectionType * pt;

        D.25897 = (long unsigned int) i;
        D.25871 = mb->opt_types;
        D.25913 = mono_array_addr_with_size (D.25871, 8, D.25897);
        pt = MEM[(struct MonoReflectionType * *)D.25913];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.18920>:
      i.54 = (unsigned int) i;
      if (i.54 < notypes) goto <D.18919>; else goto <D.18921>;
      <D.18921>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.25914 = idx;
      return D.25914;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


sigbuffer_init (struct SigBuffer * buf, int size)
{
  long unsigned int D.25917;
  void * D.25918;
  char * D.25919;
  sizetype D.25920;
  char * D.25921;

  D.25917 = (long unsigned int) size;
  D.25918 = monoeg_malloc (D.25917);
  buf->buf = D.25918;
  D.25919 = buf->buf;
  buf->p = D.25919;
  D.25919 = buf->buf;
  D.25920 = (sizetype) size;
  D.25921 = D.25919 + D.25920;
  buf->end = D.25921;
}


sigbuffer_add_value (struct SigBuffer * buf, guint32 val)
{
  char * * D.25922;
  char * D.25923;

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


sigbuffer_make_room (struct SigBuffer * buf, int size)
{
  char * D.25924;
  long int D.25925;
  char * D.25926;
  long int D.25927;
  long int D.25928;
  long int D.25929;
  char * D.25932;
  long int D.25933;
  long int D.25934;
  unsigned int D.25935;
  unsigned int size.55;
  unsigned int D.25937;
  unsigned int D.25938;
  long unsigned int D.25939;
  long int D.25940;
  sizetype D.25941;
  char * D.25942;
  sizetype D.25943;
  char * D.25944;

  D.25924 = buf->end;
  D.25925 = (long int) D.25924;
  D.25926 = buf->p;
  D.25927 = (long int) D.25926;
  D.25928 = D.25925 - D.25927;
  D.25929 = (long int) size;
  if (D.25928 < D.25929) goto <D.25930>; else goto <D.25931>;
  <D.25930>:
  {
    int new_size;
    char * p;

    D.25924 = buf->end;
    D.25925 = (long int) D.25924;
    D.25932 = buf->buf;
    D.25933 = (long int) D.25932;
    D.25934 = D.25925 - D.25933;
    D.25935 = (unsigned int) D.25934;
    size.55 = (unsigned int) size;
    D.25937 = D.25935 + size.55;
    D.25938 = D.25937 + 32;
    new_size = (int) D.25938;
    D.25939 = (long unsigned int) new_size;
    D.25932 = buf->buf;
    p = monoeg_realloc (D.25932, D.25939);
    D.25926 = buf->p;
    D.25927 = (long int) D.25926;
    D.25932 = buf->buf;
    D.25933 = (long int) D.25932;
    D.25940 = D.25927 - D.25933;
    size = (int) D.25940;
    buf->buf = p;
    D.25941 = (sizetype) size;
    D.25942 = p + D.25941;
    buf->p = D.25942;
    D.25932 = buf->buf;
    D.25943 = (sizetype) new_size;
    D.25944 = D.25932 + D.25943;
    buf->end = D.25944;
  }
  <D.25931>:
}


encode_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoArray * modreq, struct MonoArray * modopt, struct SigBuffer * buf)
{
  long unsigned int D.25947;
  char * D.25948;
  void * D.25949;
  unsigned int D.25950;
  long unsigned int D.25951;
  char * D.25954;
  void * D.25955;
  unsigned int D.25956;
  long unsigned int D.25957;
  int i;

  if (modreq != 0B) goto <D.25945>; else goto <D.25946>;
  <D.25945>:
  i = 0;
  goto <D.18885>;
  <D.18884>:
  {
    struct MonoType * mod;

    D.25947 = (long unsigned int) i;
    D.25948 = mono_array_addr_with_size (modreq, 8, D.25947);
    D.25949 = MEM[(void * *)D.25948];
    mod = mono_reflection_type_get_handle (D.25949);
    sigbuffer_add_byte (buf, 31);
    D.25950 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25950);
  }
  i = i + 1;
  <D.18885>:
  D.25947 = (long unsigned int) i;
  D.25951 = mono_array_length (modreq);
  if (D.25947 < D.25951) goto <D.18884>; else goto <D.18886>;
  <D.18886>:
  <D.25946>:
  if (modopt != 0B) goto <D.25952>; else goto <D.25953>;
  <D.25952>:
  i = 0;
  goto <D.18889>;
  <D.18888>:
  {
    struct MonoType * mod;

    D.25947 = (long unsigned int) i;
    D.25954 = mono_array_addr_with_size (modopt, 8, D.25947);
    D.25955 = MEM[(void * *)D.25954];
    mod = mono_reflection_type_get_handle (D.25955);
    sigbuffer_add_byte (buf, 32);
    D.25956 = mono_image_typedef_or_ref (assembly, mod);
    sigbuffer_add_value (buf, D.25956);
  }
  i = i + 1;
  <D.18889>:
  D.25947 = (long unsigned int) i;
  D.25957 = mono_array_length (modopt);
  if (D.25947 < D.25957) goto <D.18888>; else goto <D.18890>;
  <D.18890>:
  <D.25953>:
}


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

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


mono_image_typedef_or_ref_full (struct MonoDynamicImage * assembly, struct MonoType * type, gboolean try_typespec)
{
  guint32 D.25964;
  struct GHashTable * D.25965;
  void * D.25966;
  long int D.25967;
  struct MonoImage * D.25972;
  struct MonoImage * D.25973;
  unsigned char D.25976;
  unsigned int D.25981;
  void * D.25982;
  long unsigned int D.25983;
  void * D.25984;
  struct MonoGHashTable * D.25985;
  struct MonoClass * D.25986;
  struct MonoType * D.25989;
  unsigned int D.25990;
  int D.25992;
  unsigned int D.25995;
  unsigned int D.25996;
  guint32 * D.25997;
  unsigned int D.25998;
  unsigned int D.25999;
  long unsigned int D.26000;
  long unsigned int D.26001;
  guint32 * D.26002;
  const char * D.26003;
  struct MonoDynamicStream * D.26004;
  unsigned int D.26005;
  guint32 * D.26006;
  const char * D.26007;
  unsigned int D.26008;
  unsigned int D.26009;
  unsigned int D.26010;
  void * D.26011;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 scope;
  guint32 enclosing;
  struct MonoClass * klass;

  if (try_typespec != 0) goto <D.25960>; else goto <D.25961>;
  <D.25960>:
  token = create_typespec (assembly, type);
  if (token != 0) goto <D.25962>; else goto <D.25963>;
  <D.25962>:
  D.25964 = token;
  return D.25964;
  <D.25963>:
  <D.25961>:
  D.25965 = assembly->typeref;
  D.25966 = monoeg_g_hash_table_lookup (D.25965, type);
  D.25967 = (long int) D.25966;
  token = (guint32) D.25967;
  if (token != 0) goto <D.25968>; else goto <D.25969>;
  <D.25968>:
  D.25964 = token;
  return D.25964;
  <D.25969>:
  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.25970>; else goto <D.25971>;
  <D.25970>:
  klass = mono_class_from_mono_type (type);
  <D.25971>:
  D.25972 = klass->image;
  D.25973 = &assembly->image;
  if (D.25972 == D.25973) goto <D.25974>; else goto <D.25975>;
  <D.25974>:
  D.25976 = type->type;
  if (D.25976 != 19) goto <D.25977>; else goto <D.25978>;
  <D.25977>:
  D.25976 = type->type;
  if (D.25976 != 30) goto <D.25979>; else goto <D.25980>;
  <D.25979>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.25981 = tb->table_idx;
    token = D.25981 << 2;
    D.25982 = mono_class_get_ref_info (klass);
    D.25983 = (long unsigned int) token;
    D.25984 = (void *) D.25983;
    D.25985 = assembly->tokens;
    mono_g_hash_table_insert (D.25985, D.25984, D.25982);
    D.25964 = token;
    return D.25964;
  }
  <D.25980>:
  <D.25978>:
  <D.25975>:
  D.25986 = klass->nested_in;
  if (D.25986 != 0B) goto <D.25987>; else goto <D.25988>;
  <D.25987>:
  D.25986 = klass->nested_in;
  D.25989 = &D.25986->byval_arg;
  enclosing = mono_image_typedef_or_ref_full (assembly, D.25989, 0);
  enclosing = enclosing >> 2;
  D.25990 = enclosing << 2;
  scope = D.25990 | 3;
  goto <D.25991>;
  <D.25988>:
  D.25972 = klass->image;
  scope = resolution_scope_from_image (assembly, D.25972);
  <D.25991>:
  table = &assembly->tables[1];
  D.25992 = assembly->save;
  if (D.25992 != 0) goto <D.25993>; else goto <D.25994>;
  <D.25993>:
  D.25995 = table->rows;
  D.25996 = D.25995 + 1;
  alloc_table (table, D.25996);
  D.25997 = table->values;
  D.25998 = table->next_idx;
  D.25999 = D.25998 * 3;
  D.26000 = (long unsigned int) D.25999;
  D.26001 = D.26000 * 4;
  values = D.25997 + D.26001;
  *values = scope;
  D.26002 = values + 4;
  D.26003 = klass->name;
  D.26004 = &assembly->sheap;
  D.26005 = string_heap_insert (D.26004, D.26003);
  *D.26002 = D.26005;
  D.26006 = values + 8;
  D.26007 = klass->name_space;
  D.26004 = &assembly->sheap;
  D.26008 = string_heap_insert (D.26004, D.26007);
  *D.26006 = D.26008;
  <D.25994>:
  D.25998 = table->next_idx;
  D.26009 = D.25998 << 2;
  token = D.26009 | 1;
  D.25983 = (long unsigned int) token;
  D.25984 = (void *) D.25983;
  D.25965 = assembly->typeref;
  monoeg_g_hash_table_insert_replace (D.25965, type, D.25984, 0);
  D.25998 = table->next_idx;
  D.26010 = D.25998 + 1;
  table->next_idx = D.26010;
  D.26011 = mono_class_get_ref_info (klass);
  D.25983 = (long unsigned int) token;
  D.25984 = (void *) D.25983;
  D.25985 = assembly->tokens;
  mono_g_hash_table_insert (D.25985, D.25984, D.26011);
  D.25964 = token;
  return D.25964;
}


create_typespec (struct MonoDynamicImage * assembly, struct MonoType * type)
{
  struct GHashTable * D.26013;
  void * D.26014;
  long int D.26015;
  guint32 D.26018;
  unsigned char D.26019;
  int D.26020;
  struct MonoGenericContainer * D.26024;
  int D.26025;
  unsigned int D.26028;
  unsigned int D.26029;
  guint32 * D.26030;
  unsigned int D.26031;
  long unsigned int D.26032;
  long unsigned int D.26033;
  unsigned int D.26034;
  long unsigned int D.26035;
  void * D.26036;
  unsigned int D.26037;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  struct SigBuffer buf;

  try
    {
      D.26013 = assembly->typespec;
      D.26014 = monoeg_g_hash_table_lookup (D.26013, type);
      D.26015 = (long int) D.26014;
      token = (guint32) D.26015;
      if (token != 0) goto <D.26016>; else goto <D.26017>;
      <D.26016>:
      D.26018 = token;
      return D.26018;
      <D.26017>:
      sigbuffer_init (&buf, 32);
      D.26019 = type->type;
      D.26020 = (int) D.26019;
      switch (D.26020) <default: <D.19374>, case 15: <D.19364>, case 17: <D.19372>, case 18: <D.19371>, case 19: <D.19367>, case 20: <D.19366>, case 21: <D.19369>, case 27: <D.19363>, case 29: <D.19365>, case 30: <D.19368>>
      <D.19363>:
      <D.19364>:
      <D.19365>:
      <D.19366>:
      <D.19367>:
      <D.19368>:
      <D.19369>:
      encode_type (assembly, type, &buf);
      goto <D.19370>;
      <D.19371>:
      <D.19372>:
      {
        struct MonoClass * k;

        k = mono_class_from_mono_type (type);
        if (k == 0B) goto <D.26021>; else goto <D.26023>;
        <D.26023>:
        D.26024 = k->generic_container;
        if (D.26024 == 0B) goto <D.26021>; else goto <D.26022>;
        <D.26021>:
        sigbuffer_free (&buf);
        D.26018 = 0;
        return D.26018;
        <D.26022>:
        encode_type (assembly, type, &buf);
        goto <D.19370>;
      }
      <D.19374>:
      sigbuffer_free (&buf);
      D.26018 = 0;
      return D.26018;
      <D.19370>:
      table = &assembly->tables[27];
      D.26025 = assembly->save;
      if (D.26025 != 0) goto <D.26026>; else goto <D.26027>;
      <D.26026>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.26028 = table->rows;
      D.26029 = D.26028 + 1;
      alloc_table (table, D.26029);
      D.26030 = table->values;
      D.26031 = table->next_idx;
      D.26032 = (long unsigned int) D.26031;
      D.26033 = D.26032 * 4;
      values = D.26030 + D.26033;
      *values = token;
      <D.26027>:
      sigbuffer_free (&buf);
      D.26031 = table->next_idx;
      D.26034 = D.26031 << 2;
      token = D.26034 | 2;
      D.26035 = (long unsigned int) token;
      D.26036 = (void *) D.26035;
      D.26013 = assembly->typespec;
      monoeg_g_hash_table_insert_replace (D.26013, type, D.26036, 0);
      D.26031 = table->next_idx;
      D.26037 = D.26031 + 1;
      table->next_idx = D.26037;
      D.26018 = token;
      return D.26018;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_type (struct MonoDynamicImage * assembly, struct MonoType * type, struct SigBuffer * buf)
{
  unsigned char D.26042;
  unsigned char D.26043;
  unsigned char D.26046;
  int D.26047;
  unsigned int D.26048;
  struct MonoType * D.26049;
  struct MonoClass * D.26050;
  struct MonoType * D.26051;
  struct MonoGenericContainer * D.26052;
  struct MonoGenericInst * D.26055;
  unsigned char D.26057;
  unsigned int D.26058;
  struct MonoType * D.26059;
  unsigned int D.26060;
  struct MonoArrayType * D.26061;
  struct MonoClass * D.26062;
  struct MonoType * D.26063;
  unsigned char D.26064;
  unsigned int D.26065;
  struct MonoGenericClass * D.26066;
  struct MonoGenericParam * D.26067;
  short unsigned int D.26068;
  unsigned int D.26069;

  if (type == 0B) goto <D.26040>; else goto <D.26041>;
  <D.26040>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 679);
  return;
  <D.26041>:
  D.26042 = BIT_FIELD_REF <*type, 8, 88>;
  D.26043 = D.26042 & 64;
  if (D.26043 != 0) goto <D.26044>; else goto <D.26045>;
  <D.26044>:
  sigbuffer_add_value (buf, 16);
  <D.26045>:
  D.26046 = type->type;
  D.26047 = (int) D.26046;
  switch (D.26047) <default: <D.18869>, case 1: <D.18840>, case 2: <D.18841>, case 3: <D.18842>, case 4: <D.18843>, case 5: <D.18844>, case 6: <D.18845>, case 7: <D.18846>, case 8: <D.18847>, case 9: <D.18848>, case 10: <D.18849>, case 11: <D.18850>, case 12: <D.18851>, case 13: <D.18852>, case 14: <D.18855>, case 15: <D.18859>, case 17: <D.18861>, case 18: <D.18862>, case 19: <D.18867>, case 20: <D.18865>, case 21: <D.18866>, case 22: <D.18857>, case 24: <D.18853>, case 25: <D.18854>, case 28: <D.18856>, case 29: <D.18860>, case 30: <D.18868>>
  <D.18840>:
  <D.18841>:
  <D.18842>:
  <D.18843>:
  <D.18844>:
  <D.18845>:
  <D.18846>:
  <D.18847>:
  <D.18848>:
  <D.18849>:
  <D.18850>:
  <D.18851>:
  <D.18852>:
  <D.18853>:
  <D.18854>:
  <D.18855>:
  <D.18856>:
  <D.18857>:
  D.26046 = type->type;
  D.26048 = (unsigned int) D.26046;
  sigbuffer_add_value (buf, D.26048);
  goto <D.18858>;
  <D.18859>:
  D.26046 = type->type;
  D.26048 = (unsigned int) D.26046;
  sigbuffer_add_value (buf, D.26048);
  D.26049 = type->data.type;
  encode_type (assembly, D.26049, buf);
  goto <D.18858>;
  <D.18860>:
  D.26046 = type->type;
  D.26048 = (unsigned int) D.26046;
  sigbuffer_add_value (buf, D.26048);
  D.26050 = type->data.klass;
  D.26051 = &D.26050->byval_arg;
  encode_type (assembly, D.26051, buf);
  goto <D.18858>;
  <D.18861>:
  <D.18862>:
  {
    struct MonoClass * k;

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

      D.26052 = k->generic_container;
      D.26055 = D.26052->context.class_inst;
      gclass = mono_metadata_lookup_generic_class (k, D.26055, 1);
      encode_generic_class (assembly, gclass, buf);
    }
    goto <D.26056>;
    <D.26054>:
    D.26057 = k->byval_arg.type;
    D.26058 = (unsigned int) D.26057;
    sigbuffer_add_value (buf, D.26058);
    D.26059 = &k->byval_arg;
    D.26060 = mono_image_typedef_or_ref (assembly, D.26059);
    sigbuffer_add_value (buf, D.26060);
    <D.26056>:
    goto <D.18858>;
  }
  <D.18865>:
  D.26046 = type->type;
  D.26048 = (unsigned int) D.26046;
  sigbuffer_add_value (buf, D.26048);
  D.26061 = type->data.array;
  D.26062 = D.26061->eklass;
  D.26063 = &D.26062->byval_arg;
  encode_type (assembly, D.26063, buf);
  D.26061 = type->data.array;
  D.26064 = D.26061->rank;
  D.26065 = (unsigned int) D.26064;
  sigbuffer_add_value (buf, D.26065);
  sigbuffer_add_value (buf, 0);
  sigbuffer_add_value (buf, 0);
  goto <D.18858>;
  <D.18866>:
  D.26066 = type->data.generic_class;
  encode_generic_class (assembly, D.26066, buf);
  goto <D.18858>;
  <D.18867>:
  <D.18868>:
  D.26046 = type->type;
  D.26048 = (unsigned int) D.26046;
  sigbuffer_add_value (buf, D.26048);
  D.26067 = type->data.generic_param;
  D.26068 = D.26067->num;
  D.26069 = (unsigned int) D.26068;
  sigbuffer_add_value (buf, D.26069);
  goto <D.18858>;
  <D.18869>:
  D.26046 = type->type;
  D.26047 = (int) D.26046;
  monoeg_g_log (0B, 4, "need to encode type %x", D.26047);
  <D.18870>:
  goto <D.18870>;
  <D.18858>:
}


encode_generic_class (struct MonoDynamicImage * assembly, struct MonoGenericClass * gclass, struct SigBuffer * buf)
{
  _Bool D.26070;
  long int D.26071;
  long int D.26072;
  unsigned char D.26075;
  unsigned int D.26076;
  struct MonoType * D.26077;
  unsigned int D.26078;
  <unnamed-unsigned:22> D.26079;
  unsigned int D.26080;
  struct MonoType * D.26081;
  int D.26082;
  int i;
  struct MonoGenericInst * class_inst;
  struct MonoClass * klass;

  D.26070 = gclass == 0B;
  D.26071 = (long int) D.26070;
  D.26072 = __builtin_expect (D.26071, 0);
  if (D.26072 != 0) goto <D.26073>; else goto <D.26074>;
  <D.26073>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 660, "gclass");
  <D.26074>:
  class_inst = gclass->context.class_inst;
  sigbuffer_add_value (buf, 21);
  klass = gclass->container_class;
  D.26075 = klass->byval_arg.type;
  D.26076 = (unsigned int) D.26075;
  sigbuffer_add_value (buf, D.26076);
  D.26077 = &klass->byval_arg;
  D.26078 = mono_image_typedef_or_ref_full (assembly, D.26077, 0);
  sigbuffer_add_value (buf, D.26078);
  D.26079 = class_inst->type_argc;
  D.26080 = (unsigned int) D.26079;
  sigbuffer_add_value (buf, D.26080);
  i = 0;
  goto <D.18833>;
  <D.18832>:
  D.26081 = class_inst->type_argv[i];
  encode_type (assembly, D.26081, buf);
  i = i + 1;
  <D.18833>:
  D.26079 = class_inst->type_argc;
  D.26082 = (int) D.26079;
  if (D.26082 > i) goto <D.18832>; else goto <D.18834>;
  <D.18834>:
}


sigbuffer_add_byte (struct SigBuffer * buf, guint8 val)
{
  char * D.26083;
  char val.56;
  char * D.26085;

  sigbuffer_make_room (buf, 1);
  D.26083 = buf->p;
  val.56 = (char) val;
  *D.26083 = val.56;
  D.26083 = buf->p;
  D.26085 = D.26083 + 1;
  buf->p = D.26085;
}


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

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


sigbuffer_add_to_blob_cached (struct MonoDynamicImage * assembly, struct SigBuffer * buf)
{
  char * D.26090;
  long int D.26091;
  char * D.26092;
  long int D.26093;
  long int D.26094;
  long int D.26095;
  char * D.26096;
  long int D.26097;
  long int D.26098;
  _Bool D.26099;
  long int D.26100;
  long int D.26101;
  char * b.57;
  guint32 D.26105;
  int size.58;
  long int b.59;
  long int blob_size.60;
  long int D.26109;
  int D.26110;
  char blob_size[8];
  char * b;
  guint32 size;

  try
    {
      b = &blob_size;
      D.26090 = buf->p;
      D.26091 = (long int) D.26090;
      D.26092 = buf->buf;
      D.26093 = (long int) D.26092;
      D.26094 = D.26091 - D.26093;
      size = (guint32) D.26094;
      D.26095 = (long int) size;
      D.26096 = buf->end;
      D.26097 = (long int) D.26096;
      D.26092 = buf->buf;
      D.26093 = (long int) D.26092;
      D.26098 = D.26097 - D.26093;
      D.26099 = D.26095 > D.26098;
      D.26100 = (long int) D.26099;
      D.26101 = __builtin_expect (D.26100, 0);
      if (D.26101 != 0) goto <D.26102>; else goto <D.26103>;
      <D.26102>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 501, "size <= (buf->end - buf->buf)");
      <D.26103>:
      b.57 = b;
      mono_metadata_encode_value (size, b.57, &b);
      size.58 = (int) size;
      D.26092 = buf->buf;
      b.57 = b;
      b.59 = (long int) b.57;
      blob_size.60 = (long int) &blob_size;
      D.26109 = b.59 - blob_size.60;
      D.26110 = (int) D.26109;
      D.26105 = add_to_blob_cached (assembly, &blob_size, D.26110, D.26092, size.58);
      return D.26105;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


add_to_blob_cached (struct MonoDynamicImage * assembly, char * b1, int s1, char * b2, int s2)
{
  int D.26113;
  long unsigned int D.26114;
  long unsigned int D.26115;
  long unsigned int D.26116;
  sizetype D.26117;
  char * D.26118;
  struct GHashTable * D.26119;
  int D.26120;
  void * oldval.61;
  long int oldval.62;
  unsigned int s1.63;
  struct MonoDynamicStream * D.26127;
  unsigned int s2.64;
  long unsigned int D.26129;
  void * D.26130;
  guint32 D.26131;
  guint32 idx;
  char * copy;
  void * oldkey;
  void * oldval;

  try
    {
      D.26113 = s1 + s2;
      D.26114 = (long unsigned int) D.26113;
      copy = monoeg_malloc (D.26114);
      D.26115 = (long unsigned int) s1;
      memcpy (copy, b1, D.26115);
      D.26116 = (long unsigned int) s2;
      D.26117 = (sizetype) s1;
      D.26118 = copy + D.26117;
      memcpy (D.26118, b2, D.26116);
      D.26119 = assembly->blob_cache;
      D.26120 = monoeg_g_hash_table_lookup_extended (D.26119, copy, &oldkey, &oldval);
      if (D.26120 != 0) goto <D.26121>; else goto <D.26122>;
      <D.26121>:
      monoeg_g_free (copy);
      oldval.61 = oldval;
      oldval.62 = (long int) oldval.61;
      idx = (guint32) oldval.62;
      goto <D.26125>;
      <D.26122>:
      s1.63 = (unsigned int) s1;
      D.26127 = &assembly->blob;
      idx = mono_image_add_stream_data (D.26127, b1, s1.63);
      s2.64 = (unsigned int) s2;
      D.26127 = &assembly->blob;
      mono_image_add_stream_data (D.26127, b2, s2.64);
      D.26129 = (long unsigned int) idx;
      D.26130 = (void *) D.26129;
      D.26119 = assembly->blob_cache;
      monoeg_g_hash_table_insert_replace (D.26119, copy, D.26130, 0);
      <D.26125>:
      D.26131 = idx;
      return D.26131;
    }
  finally
    {
      oldkey = {CLOBBER};
      oldval = {CLOBBER};
    }
}


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

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


method_encode_code (struct MonoDynamicImage * assembly, struct ReflectionMethodBuilder * mb)
{
  long unsigned int D.26135;
  long unsigned int D.26136;
  guint32 D.26139;
  struct MonoReflectionILGen * D.26140;
  int D.26143;
  gint32 iftmp.65;
  struct MonoArray * D.26145;
  long unsigned int D.26148;
  struct MonoArray * D.26150;
  unsigned int D.26153;
  struct MonoString * D.26157;
  long unsigned int D.26158;
  struct MonoDynamicStream * D.26159;
  int iftmp.66;
  _Bool D.26163;
  _Bool D.26164;
  _Bool D.26165;
  unsigned int D.26173;
  unsigned char D.26175;
  unsigned char D.26176;
  unsigned char D.26177;
  char flags.67;
  unsigned char D.26181;
  char flags.68;
  int D.26185;
  unsigned int D.26188;
  long unsigned int D.26189;
  void * D.26190;
  struct MonoGHashTable * D.26191;
  char * D.26192;
  unsigned int D.26193;
  unsigned int D.26196;
  unsigned char D.26199;
  char D.26202;
  unsigned int D.26203;
  unsigned int D.26204;
  char D.26205;
  short unsigned int short_value.69;
  unsigned int D.26211;
  long unsigned int D.26212;
  void * D.26213;
  char * D.26214;
  unsigned int num_exception.70;
  unsigned int D.26218;
  unsigned char D.26219;
  int D.26220;
  unsigned char D.26221;
  int D.26222;
  unsigned char D.26223;
  long unsigned int D.26224;
  unsigned int D.26225;
  unsigned int D.26226;
  long unsigned int D.26227;
  struct MonoArray * D.26228;
  int D.26231;
  int D.26232;
  long unsigned int D.26233;
  int D.26234;
  unsigned int val.71;
  unsigned int val.72;
  int D.26239;
  unsigned int val.73;
  unsigned int val.74;
  int D.26243;
  unsigned int val.75;
  int D.26245;
  unsigned int val.76;
  struct MonoObject * D.26247;
  struct MonoType * D.26250;
  unsigned int D.26251;
  unsigned int val.77;
  int D.26256;
  unsigned int val.78;
  unsigned int val.79;
  long unsigned int D.26260;
  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.26135 = BIT_FIELD_REF <*mb, 64, 448>;
      D.26136 = D.26135 & 17605070955520;
      if (D.26136 != 0) goto <D.26137>; else goto <D.26138>;
      <D.26137>:
      D.26139 = 0;
      return D.26139;
      <D.26138>:
      D.26140 = mb->ilgen;
      if (D.26140 != 0B) goto <D.26141>; else goto <D.26142>;
      <D.26141>:
      D.26140 = mb->ilgen;
      code = D.26140->code;
      D.26140 = mb->ilgen;
      D.26143 = D.26140->code_len;
      code_size = (guint32) D.26143;
      D.26140 = mb->ilgen;
      max_stack = D.26140->max_stack;
      D.26140 = mb->ilgen;
      D.26145 = D.26140->locals;
      if (D.26145 != 0B) goto <D.26146>; else goto <D.26147>;
      <D.26146>:
      D.26140 = mb->ilgen;
      D.26145 = D.26140->locals;
      D.26148 = mono_array_length (D.26145);
      iftmp.65 = (gint32) D.26148;
      goto <D.26149>;
      <D.26147>:
      iftmp.65 = 0;
      <D.26149>:
      num_locals = iftmp.65;
      D.26140 = mb->ilgen;
      D.26150 = D.26140->ex_handlers;
      if (D.26150 != 0B) goto <D.26151>; else goto <D.26152>;
      <D.26151>:
      D.26140 = mb->ilgen;
      D.26153 = method_count_clauses (D.26140);
      num_exception = (gint32) D.26153;
      <D.26152>:
      goto <D.26154>;
      <D.26142>:
      code = mb->code;
      if (code == 0B) goto <D.26155>; else goto <D.26156>;
      <D.26155>:
      {
        char * name;
        char * str;
        struct MonoException * exception;

        D.26157 = mb->name;
        name = mono_string_to_utf8 (D.26157);
        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.26156>:
      D.26158 = mono_array_length (code);
      code_size = (guint32) D.26158;
      max_stack = 8;
      <D.26154>:
      D.26159 = &assembly->code;
      stream_data_align (D.26159);
      D.26163 = max_stack <= 8;
      D.26164 = num_locals == 0;
      D.26165 = D.26163 & D.26164;
      if (D.26165 != 0) goto <D.26166>; else goto <D.26161>;
      <D.26166>:
      if (num_exception == 0) goto <D.26167>; else goto <D.26161>;
      <D.26167>:
      iftmp.66 = 1;
      goto <D.26162>;
      <D.26161>:
      iftmp.66 = 0;
      <D.26162>:
      maybe_small = iftmp.66;
      if (maybe_small != 0) goto <D.26168>; else goto <D.26169>;
      <D.26168>:
      if (code_size <= 63) goto <D.26172>; else goto <D.26170>;
      <D.26172>:
      D.26173 = code_size & 1;
      if (D.26173 == 0) goto <D.26174>; else goto <D.26170>;
      <D.26174>:
      D.26175 = (unsigned char) code_size;
      D.26176 = D.26175 << 2;
      D.26177 = D.26176 | 2;
      flags.67 = (char) D.26177;
      flags = flags.67;
      goto <D.26171>;
      <D.26170>:
      if (code_size <= 31) goto <D.26179>; else goto fat_header;
      <D.26179>:
      D.26173 = code_size & 1;
      if (D.26173 != 0) goto <D.26180>; else goto fat_header;
      <D.26180>:
      D.26175 = (unsigned char) code_size;
      D.26176 = D.26175 << 2;
      D.26181 = D.26176 | 6;
      flags.68 = (char) D.26181;
      flags = flags.68;
      <D.26171>:
      D.26159 = &assembly->code;
      idx = mono_image_add_stream_data (D.26159, &flags, 1);
      D.26140 = mb->ilgen;
      if (D.26140 != 0B) goto <D.26183>; else goto <D.26184>;
      <D.26183>:
      D.26140 = mb->ilgen;
      D.26185 = D.26140->num_token_fixups;
      if (D.26185 != 0) goto <D.26186>; else goto <D.26187>;
      <D.26186>:
      D.26188 = idx + 1;
      D.26189 = (long unsigned int) D.26188;
      D.26190 = (void *) D.26189;
      D.26140 = mb->ilgen;
      D.26191 = assembly->token_fixups;
      mono_g_hash_table_insert (D.26191, D.26140, D.26190);
      <D.26187>:
      <D.26184>:
      D.26192 = mono_array_addr_with_size (code, 1, 0);
      D.26159 = &assembly->code;
      mono_image_add_stream_data (D.26159, D.26192, code_size);
      D.26193 = assembly->text_rva;
      D.26139 = D.26193 + idx;
      return D.26139;
      <D.26169>:
      fat_header:
      if (num_locals != 0) goto <D.26194>; else goto <D.26195>;
      <D.26194>:
      D.26140 = mb->ilgen;
      D.26196 = encode_locals (assembly, D.26140);
      local_sig = D.26196 | 285212672;
      <D.26195>:
      fat_flags = 3;
      if (num_exception != 0) goto <D.26197>; else goto <D.26198>;
      <D.26197>:
      fat_flags = fat_flags | 8;
      <D.26198>:
      D.26199 = mb->init_locals;
      if (D.26199 != 0) goto <D.26200>; else goto <D.26201>;
      <D.26200>:
      fat_flags = fat_flags | 16;
      <D.26201>:
      D.26202 = (char) fat_flags;
      fat_header[0] = D.26202;
      D.26203 = header_size / 4;
      D.26204 = D.26203 << 4;
      D.26205 = (char) D.26204;
      fat_header[1] = D.26205;
      short_value.69 = (short unsigned int) max_stack;
      short_value = short_value.69;
      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.26159 = &assembly->code;
      idx = mono_image_add_stream_data (D.26159, &fat_header, 12);
      D.26140 = mb->ilgen;
      if (D.26140 != 0B) goto <D.26207>; else goto <D.26208>;
      <D.26207>:
      D.26140 = mb->ilgen;
      D.26185 = D.26140->num_token_fixups;
      if (D.26185 != 0) goto <D.26209>; else goto <D.26210>;
      <D.26209>:
      D.26211 = idx + 12;
      D.26212 = (long unsigned int) D.26211;
      D.26213 = (void *) D.26212;
      D.26140 = mb->ilgen;
      D.26191 = assembly->token_fixups;
      mono_g_hash_table_insert (D.26191, D.26140, D.26213);
      <D.26210>:
      <D.26208>:
      D.26214 = mono_array_addr_with_size (code, 1, 0);
      D.26159 = &assembly->code;
      mono_image_add_stream_data (D.26159, D.26214, code_size);
      if (num_exception != 0) goto <D.26215>; else goto <D.26216>;
      <D.26215>:
      {
        unsigned char sheader[4];
        struct MonoILExceptionInfo * ex_info;
        struct MonoILExceptionBlock * ex_block;
        int j;

        try
          {
            D.26159 = &assembly->code;
            stream_data_align (D.26159);
            sheader[0] = 65;
            num_exception.70 = (unsigned int) num_exception;
            D.26218 = num_exception.70 * 24;
            num_exception = (gint32) D.26218;
            num_exception = num_exception + 4;
            D.26219 = (unsigned char) num_exception;
            sheader[1] = D.26219;
            D.26220 = num_exception >> 8;
            D.26221 = (unsigned char) D.26220;
            sheader[2] = D.26221;
            D.26222 = num_exception >> 16;
            D.26223 = (unsigned char) D.26222;
            sheader[3] = D.26223;
            D.26159 = &assembly->code;
            mono_image_add_stream_data (D.26159, &sheader, 4);
            D.26140 = mb->ilgen;
            D.26150 = D.26140->ex_handlers;
            D.26224 = mono_array_length (D.26150);
            D.26225 = (unsigned int) D.26224;
            D.26226 = D.26225 + 4294967295;
            i = (gint32) D.26226;
            goto <D.19001>;
            <D.19000>:
            D.26227 = (long unsigned int) i;
            D.26140 = mb->ilgen;
            D.26150 = D.26140->ex_handlers;
            ex_info = mono_array_addr_with_size (D.26150, 24, D.26227);
            D.26228 = ex_info->handlers;
            if (D.26228 != 0B) goto <D.26229>; else goto <D.26230>;
            <D.26229>:
            {
              int finally_start;

              D.26231 = ex_info->start;
              D.26232 = ex_info->len;
              finally_start = D.26231 + D.26232;
              j = 0;
              goto <D.18997>;
              <D.18996>:
              {
                guint32 val;

                try
                  {
                    D.26233 = (long unsigned int) j;
                    D.26228 = ex_info->handlers;
                    ex_block = mono_array_addr_with_size (D.26228, 24, D.26233);
                    D.26234 = ex_block->type;
                    val.71 = (unsigned int) D.26234;
                    val = val.71;
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                    D.26231 = ex_info->start;
                    val.72 = (unsigned int) D.26231;
                    val = val.72;
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                    D.26234 = ex_block->type;
                    if (D.26234 == 2) goto <D.26237>; else goto <D.26238>;
                    <D.26237>:
                    D.26231 = ex_info->start;
                    D.26239 = finally_start - D.26231;
                    val.73 = (unsigned int) D.26239;
                    val = val.73;
                    goto <D.26241>;
                    <D.26238>:
                    D.26232 = ex_info->len;
                    val.74 = (unsigned int) D.26232;
                    val = val.74;
                    <D.26241>:
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                    D.26243 = ex_block->start;
                    val.75 = (unsigned int) D.26243;
                    val = val.75;
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                    D.26245 = ex_block->len;
                    val.76 = (unsigned int) D.26245;
                    val = val.76;
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                    D.26243 = ex_block->start;
                    D.26245 = ex_block->len;
                    finally_start = D.26243 + D.26245;
                    D.26247 = ex_block->extype;
                    if (D.26247 != 0B) goto <D.26248>; else goto <D.26249>;
                    <D.26248>:
                    D.26247 = ex_block->extype;
                    D.26250 = mono_reflection_type_get_handle (D.26247);
                    D.26251 = mono_image_typedef_or_ref (assembly, D.26250);
                    val.77 = mono_metadata_token_from_dor (D.26251);
                    val = val.77;
                    goto <D.26253>;
                    <D.26249>:
                    D.26234 = ex_block->type;
                    if (D.26234 == 1) goto <D.26254>; else goto <D.26255>;
                    <D.26254>:
                    D.26256 = ex_block->filter_offset;
                    val.78 = (unsigned int) D.26256;
                    val = val.78;
                    goto <D.26258>;
                    <D.26255>:
                    val = 0;
                    <D.26258>:
                    <D.26253>:
                    val.79 = val;
                    val = val.79;
                    D.26159 = &assembly->code;
                    mono_image_add_stream_data (D.26159, &val, 4);
                  }
                finally
                  {
                    val = {CLOBBER};
                  }
              }
              j = j + 1;
              <D.18997>:
              D.26233 = (long unsigned int) j;
              D.26228 = ex_info->handlers;
              D.26260 = mono_array_length (D.26228);
              if (D.26233 < D.26260) goto <D.18996>; else goto <D.18998>;
              <D.18998>:
            }
            goto <D.26261>;
            <D.26230>:
            monoeg_g_log (0B, 4, "No clauses for ex info block %d", i);
            <D.18999>:
            goto <D.18999>;
            <D.26261>:
            i = i + -1;
            <D.19001>:
            if (i >= 0) goto <D.19000>; else goto <D.19002>;
            <D.19002>:
          }
        finally
          {
            sheader = {CLOBBER};
          }
      }
      <D.26216>:
      D.26193 = assembly->text_rva;
      D.26139 = D.26193 + idx;
      return D.26139;
    }
  finally
    {
      flags = {CLOBBER};
      fat_header = {CLOBBER};
      int_value = {CLOBBER};
      short_value = {CLOBBER};
    }
}


method_count_clauses (struct MonoReflectionILGen * ilgen)
{
  long unsigned int D.26264;
  struct MonoArray * D.26265;
  struct MonoArray * D.26266;
  long unsigned int D.26269;
  unsigned int D.26270;
  long unsigned int D.26272;
  guint32 D.26273;
  guint32 num_clauses;
  int i;
  struct MonoILExceptionInfo * ex_info;

  num_clauses = 0;
  i = 0;
  goto <D.18944>;
  <D.18943>:
  D.26264 = (long unsigned int) i;
  D.26265 = ilgen->ex_handlers;
  ex_info = mono_array_addr_with_size (D.26265, 24, D.26264);
  D.26266 = ex_info->handlers;
  if (D.26266 != 0B) goto <D.26267>; else goto <D.26268>;
  <D.26267>:
  D.26266 = ex_info->handlers;
  D.26269 = mono_array_length (D.26266);
  D.26270 = (unsigned int) D.26269;
  num_clauses = D.26270 + num_clauses;
  goto <D.26271>;
  <D.26268>:
  num_clauses = num_clauses + 1;
  <D.26271>:
  i = i + 1;
  <D.18944>:
  D.26264 = (long unsigned int) i;
  D.26265 = ilgen->ex_handlers;
  D.26272 = mono_array_length (D.26265);
  if (D.26264 < D.26272) goto <D.18943>; else goto <D.18945>;
  <D.18945>:
  D.26273 = num_clauses;
  return D.26273;
}


encode_locals (struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen)
{
  struct MonoArray * D.26275;
  long unsigned int D.26276;
  long unsigned int D.26277;
  char * D.26278;
  unsigned char D.26279;
  struct MonoObject * D.26282;
  unsigned int i.80;
  struct GHashTable * D.26284;
  struct GHashTable * D.26287;
  long unsigned int D.26288;
  const void * D.26289;
  void * D.26290;
  long int D.26291;
  guint32 D.26294;
  unsigned int D.26295;
  unsigned int idx.81;
  unsigned int D.26297;
  unsigned int D.26298;
  unsigned int D.26299;
  guint32 * D.26300;
  long unsigned int D.26301;
  long unsigned int D.26302;
  void * D.26303;
  void * D.26304;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 idx;
  guint32 sig_idx;
  guint nl;
  struct SigBuffer buf;
  int i;

  try
    {
      D.26275 = ilgen->locals;
      D.26276 = mono_array_length (D.26275);
      nl = (guint) D.26276;
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, nl);
      i = 0;
      goto <D.18935>;
      <D.18934>:
      {
        struct MonoReflectionLocalBuilder * lb;

        D.26277 = (long unsigned int) i;
        D.26275 = ilgen->locals;
        D.26278 = mono_array_addr_with_size (D.26275, 8, D.26277);
        lb = MEM[(struct MonoReflectionLocalBuilder * *)D.26278];
        D.26279 = lb->is_pinned;
        if (D.26279 != 0) goto <D.26280>; else goto <D.26281>;
        <D.26280>:
        sigbuffer_add_value (&buf, 69);
        <D.26281>:
        D.26282 = lb->type;
        encode_reflection_type (assembly, D.26282, &buf);
      }
      i = i + 1;
      <D.18935>:
      i.80 = (unsigned int) i;
      if (i.80 < nl) goto <D.18934>; else goto <D.18936>;
      <D.18936>:
      sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26284 = assembly->standalonesig_cache;
      if (D.26284 == 0B) goto <D.26285>; else goto <D.26286>;
      <D.26285>:
      D.26287 = monoeg_g_hash_table_new (0B, 0B);
      assembly->standalonesig_cache = D.26287;
      <D.26286>:
      D.26288 = (long unsigned int) sig_idx;
      D.26289 = (const void *) D.26288;
      D.26284 = assembly->standalonesig_cache;
      D.26290 = monoeg_g_hash_table_lookup (D.26284, D.26289);
      D.26291 = (long int) D.26290;
      idx = (guint32) D.26291;
      if (idx != 0) goto <D.26292>; else goto <D.26293>;
      <D.26292>:
      D.26294 = idx;
      return D.26294;
      <D.26293>:
      table = &assembly->tables[17];
      D.26295 = table->next_idx;
      idx.81 = D.26295;
      D.26297 = idx.81 + 1;
      table->next_idx = D.26297;
      idx = idx.81;
      D.26298 = table->rows;
      D.26299 = D.26298 + 1;
      table->rows = D.26299;
      D.26298 = table->rows;
      alloc_table (table, D.26298);
      D.26300 = table->values;
      D.26301 = (long unsigned int) idx;
      D.26302 = D.26301 * 4;
      values = D.26300 + D.26302;
      *values = sig_idx;
      D.26301 = (long unsigned int) idx;
      D.26303 = (void *) D.26301;
      D.26288 = (long unsigned int) sig_idx;
      D.26304 = (void *) D.26288;
      D.26284 = assembly->standalonesig_cache;
      monoeg_g_hash_table_insert_replace (D.26284, D.26304, D.26303, 0);
      D.26294 = idx;
      return D.26294;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

  try
    {
      buf = {};
      D.26307 = stream->index;
      count = D.26307 & 3;
      if (count != 0) goto <D.26308>; else goto <D.26309>;
      <D.26308>:
      D.26310 = 4 - count;
      mono_image_add_stream_data (stream, &buf, D.26310);
      <D.26309>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


encode_marshal_blob (struct MonoDynamicImage * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.26311;
  unsigned int D.26312;
  int D.26313;
  unsigned int D.26314;
  int D.26317;
  unsigned char D.26319;
  unsigned int D.26320;
  guint32 iftmp.82;
  int D.26324;
  guint32 iftmp.83;
  _Bool D.26332;
  unsigned int D.26333;
  struct MonoString * D.26336;
  long unsigned int D.26339;
  struct MonoString * D.26344;
  struct MonoObject * D.26346;
  struct MonoType * D.26349;
  long unsigned int D.26351;
  struct MonoString * D.26352;
  long unsigned int D.26355;
  guint32 D.26357;
  char * str;
  struct SigBuffer buf;
  guint32 idx;
  guint32 len;

  try
    {
      sigbuffer_init (&buf, 32);
      D.26311 = minfo->type;
      D.26312 = (unsigned int) D.26311;
      sigbuffer_add_value (&buf, D.26312);
      D.26311 = minfo->type;
      switch (D.26311) <default: <D.19263>, case 23: <D.19257>, case 29: <D.19261>, case 30: <D.19258>, case 42: <D.19260>, case 44: <D.19262>>
      <D.19257>:
      <D.19258>:
      D.26313 = minfo->count;
      D.26314 = (unsigned int) D.26313;
      sigbuffer_add_value (&buf, D.26314);
      goto <D.19259>;
      <D.19260>:
      D.26317 = minfo->eltype;
      if (D.26317 != 0) goto <D.26315>; else goto <D.26318>;
      <D.26318>:
      D.26319 = minfo->has_size;
      if (D.26319 != 0) goto <D.26315>; else goto <D.26316>;
      <D.26315>:
      D.26317 = minfo->eltype;
      D.26320 = (unsigned int) D.26317;
      sigbuffer_add_value (&buf, D.26320);
      D.26319 = minfo->has_size;
      if (D.26319 != 0) goto <D.26321>; else goto <D.26322>;
      <D.26321>:
      D.26324 = minfo->param_num;
      if (D.26324 != -1) goto <D.26325>; else goto <D.26326>;
      <D.26325>:
      D.26324 = minfo->param_num;
      iftmp.82 = (guint32) D.26324;
      goto <D.26327>;
      <D.26326>:
      iftmp.82 = 0;
      <D.26327>:
      sigbuffer_add_value (&buf, iftmp.82);
      D.26313 = minfo->count;
      if (D.26313 != -1) goto <D.26329>; else goto <D.26330>;
      <D.26329>:
      D.26313 = minfo->count;
      iftmp.83 = (guint32) D.26313;
      goto <D.26331>;
      <D.26330>:
      iftmp.83 = 0;
      <D.26331>:
      sigbuffer_add_value (&buf, iftmp.83);
      D.26324 = minfo->param_num;
      D.26332 = D.26324 != -1;
      D.26333 = (unsigned int) D.26332;
      sigbuffer_add_value (&buf, D.26333);
      <D.26322>:
      <D.26316>:
      goto <D.19259>;
      <D.19261>:
      D.26317 = minfo->eltype;
      if (D.26317 != 0) goto <D.26334>; else goto <D.26335>;
      <D.26334>:
      D.26317 = minfo->eltype;
      D.26320 = (unsigned int) D.26317;
      sigbuffer_add_value (&buf, D.26320);
      <D.26335>:
      goto <D.19259>;
      <D.19262>:
      D.26336 = minfo->guid;
      if (D.26336 != 0B) goto <D.26337>; else goto <D.26338>;
      <D.26337>:
      D.26336 = minfo->guid;
      str = mono_string_to_utf8 (D.26336);
      D.26339 = strlen (str);
      len = (guint32) D.26339;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26340>;
      <D.26338>:
      sigbuffer_add_value (&buf, 0);
      <D.26340>:
      sigbuffer_add_value (&buf, 0);
      D.26344 = minfo->marshaltype;
      if (D.26344 != 0B) goto <D.26341>; else goto <D.26345>;
      <D.26345>:
      D.26346 = minfo->marshaltyperef;
      if (D.26346 != 0B) goto <D.26341>; else goto <D.26342>;
      <D.26341>:
      D.26346 = minfo->marshaltyperef;
      if (D.26346 != 0B) goto <D.26347>; else goto <D.26348>;
      <D.26347>:
      D.26346 = minfo->marshaltyperef;
      D.26349 = mono_reflection_type_get_handle (D.26346);
      str = type_get_fully_qualified_name (D.26349);
      goto <D.26350>;
      <D.26348>:
      D.26344 = minfo->marshaltype;
      str = mono_string_to_utf8 (D.26344);
      <D.26350>:
      D.26351 = strlen (str);
      len = (guint32) D.26351;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26343>;
      <D.26342>:
      sigbuffer_add_value (&buf, 0);
      <D.26343>:
      D.26352 = minfo->mcookie;
      if (D.26352 != 0B) goto <D.26353>; else goto <D.26354>;
      <D.26353>:
      D.26352 = minfo->mcookie;
      str = mono_string_to_utf8 (D.26352);
      D.26355 = strlen (str);
      len = (guint32) D.26355;
      sigbuffer_add_value (&buf, len);
      sigbuffer_add_mem (&buf, str, len);
      monoeg_g_free (str);
      goto <D.26356>;
      <D.26354>:
      sigbuffer_add_value (&buf, 0);
      <D.26356>:
      goto <D.19259>;
      <D.19263>:
      goto <D.19259>;
      <D.19259>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26357 = idx;
      return D.26357;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


sigbuffer_add_mem (struct SigBuffer * buf, char * p, guint32 size)
{
  int size.84;
  long unsigned int D.26364;
  char * D.26365;
  sizetype D.26366;
  char * D.26367;

  size.84 = (int) size;
  sigbuffer_make_room (buf, size.84);
  D.26364 = (long unsigned int) size;
  D.26365 = buf->p;
  memcpy (D.26365, p, D.26364);
  D.26365 = buf->p;
  D.26366 = (sizetype) size;
  D.26367 = D.26365 + D.26366;
  buf->p = D.26367;
}


encode_constant (struct MonoDynamicImage * assembly, struct MonoObject * val, guint32 * ret_type)
{
  struct MonoVTable * D.26371;
  struct MonoClass * D.26372;
  unsigned char D.26373;
  unsigned int D.26374;
  unsigned int D.26375;
  unsigned char D.26376;
  unsigned char D.26377;
  struct MonoType * D.26380;
  unsigned char D.26381;
  unsigned int D.26382;
  struct MonoImage * D.26385;
  int D.26386;
  int D.19232;
  int iftmp.85;
  int D.19231;
  const char[7] * D.26391;
  unsigned char D.26392;
  int D.26393;
  unsigned char D.26394;
  int D.26395;
  _Bool D.26396;
  _Bool D.26397;
  _Bool D.26398;
  const unsigned char * D.26401;
  unsigned char D.26402;
  int D.26403;
  const unsigned char * D.26404;
  unsigned char D.26405;
  int D.26406;
  _Bool D.26407;
  _Bool D.26408;
  const unsigned char * D.26411;
  unsigned char D.26412;
  int D.26413;
  const unsigned char * D.26414;
  unsigned char D.26415;
  int D.26416;
  _Bool D.26417;
  _Bool D.26418;
  const unsigned char * D.26421;
  unsigned char D.26422;
  int D.26423;
  const unsigned char * D.26424;
  unsigned char D.26425;
  int D.26426;
  const char * D.26428;
  int D.19241;
  int iftmp.86;
  int D.19240;
  const char[9] * D.26433;
  unsigned char D.26434;
  int D.26435;
  unsigned char D.26436;
  int D.26437;
  _Bool D.26438;
  _Bool D.26439;
  _Bool D.26440;
  const unsigned char * D.26443;
  unsigned char D.26444;
  int D.26445;
  const unsigned char * D.26446;
  unsigned char D.26447;
  int D.26448;
  _Bool D.26449;
  _Bool D.26450;
  const unsigned char * D.26453;
  unsigned char D.26454;
  int D.26455;
  const unsigned char * D.26456;
  unsigned char D.26457;
  int D.26458;
  _Bool D.26459;
  _Bool D.26460;
  const unsigned char * D.26463;
  unsigned char D.26464;
  int D.26465;
  const unsigned char * D.26466;
  unsigned char D.26467;
  int D.26468;
  const char * D.26470;
  int D.26472;
  int D.26473;
  char * b.87;
  int len.88;
  mono_unichar2 * D.26476;
  long int b.89;
  long int blob_size.90;
  long int D.26479;
  int D.26480;
  guint32 D.26481;
  struct MonoGenericClass * D.26482;
  struct MonoClass * D.26483;
  unsigned char D.26484;
  unsigned int D.26485;
  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.26368>; else goto <D.26369>;
      <D.26368>:
      *ret_type = 18;
      len = 4;
      box_val = &dummy;
      goto <D.26370>;
      <D.26369>:
      box_val = val + 16;
      D.26371 = val->vtable;
      D.26372 = D.26371->klass;
      D.26373 = D.26372->byval_arg.type;
      D.26374 = (unsigned int) D.26373;
      *ret_type = D.26374;
      <D.26370>:
      handle_enum:
      D.26375 = *ret_type;
      switch (D.26375) <default: <D.19247>, case 2: <D.19209>, case 3: <D.19213>, case 4: <D.19211>, case 5: <D.19210>, case 6: <D.19215>, case 7: <D.19214>, case 8: <D.19217>, case 9: <D.19216>, case 10: <D.19220>, case 11: <D.19219>, case 12: <D.19218>, case 13: <D.19221>, case 14: <D.19244>, case 17: <D.19222>, case 18: <D.19243>, case 21: <D.19246>>
      <D.19209>:
      <D.19210>:
      <D.19211>:
      len = 1;
      goto <D.19212>;
      <D.19213>:
      <D.19214>:
      <D.19215>:
      len = 2;
      goto <D.19212>;
      <D.19216>:
      <D.19217>:
      <D.19218>:
      len = 4;
      goto <D.19212>;
      <D.19219>:
      <D.19220>:
      len = 8;
      goto <D.19212>;
      <D.19221>:
      len = 8;
      goto <D.19212>;
      <D.19222>:
      {
        struct MonoClass * klass;

        D.26371 = val->vtable;
        klass = D.26371->klass;
        D.26376 = BIT_FIELD_REF <*klass, 8, 256>;
        D.26377 = D.26376 & 16;
        if (D.26377 != 0) goto <D.26378>; else goto <D.26379>;
        <D.26378>:
        D.26380 = mono_class_enum_basetype (klass);
        D.26381 = D.26380->type;
        D.26382 = (unsigned int) D.26381;
        *ret_type = D.26382;
        goto handle_enum;
        <D.26379>:
        D.26385 = klass->image;
        D.26386 = mono_is_corlib_image (D.26385);
        if (D.26386 != 0) goto <D.26387>; else goto <D.26383>;
        <D.26387>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.26391 = "System";
            D.26392 = MEM[(const unsigned char *)D.26391];
            D.26393 = (int) D.26392;
            D.26394 = *__s2;
            D.26395 = (int) D.26394;
            __result = D.26393 - D.26395;
            {
              D.26396 = __s2_len != 0;
              D.26397 = __result == 0;
              D.26398 = D.26396 & D.26397;
              if (D.26398 != 0) goto <D.26399>; else goto <D.26400>;
              <D.26399>:
              D.26401 = &MEM[(void *)"System" + 1B];
              D.26402 = *D.26401;
              D.26403 = (int) D.26402;
              D.26404 = __s2 + 1;
              D.26405 = *D.26404;
              D.26406 = (int) D.26405;
              __result = D.26403 - D.26406;
              D.26407 = __s2_len > 1;
              D.26397 = __result == 0;
              D.26408 = D.26407 & D.26397;
              if (D.26408 != 0) goto <D.26409>; else goto <D.26410>;
              <D.26409>:
              D.26411 = &MEM[(void *)"System" + 2B];
              D.26412 = *D.26411;
              D.26413 = (int) D.26412;
              D.26414 = __s2 + 2;
              D.26415 = *D.26414;
              D.26416 = (int) D.26415;
              __result = D.26413 - D.26416;
              D.26417 = __s2_len > 2;
              D.26397 = __result == 0;
              D.26418 = D.26417 & D.26397;
              if (D.26418 != 0) goto <D.26419>; else goto <D.26420>;
              <D.26419>:
              D.26421 = &MEM[(void *)"System" + 3B];
              D.26422 = *D.26421;
              D.26423 = (int) D.26422;
              D.26424 = __s2 + 3;
              D.26425 = *D.26424;
              D.26426 = (int) D.26425;
              __result = D.26423 - D.26426;
              <D.26420>:
              <D.26410>:
              <D.26400>:
            }
            D.19231 = __result;
          }
          iftmp.85 = -D.19231;
          goto <D.26427>;
          <D.26390>:
          D.26428 = klass->name_space;
          iftmp.85 = __builtin_strcmp (D.26428, "System");
          <D.26427>:
          D.19232 = iftmp.85;
        }
        if (D.19232 == 0) goto <D.26429>; else goto <D.26383>;
        <D.26429>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.26433 = "DateTime";
            D.26434 = MEM[(const unsigned char *)D.26433];
            D.26435 = (int) D.26434;
            D.26436 = *__s2;
            D.26437 = (int) D.26436;
            __result = D.26435 - D.26437;
            {
              D.26438 = __s2_len != 0;
              D.26439 = __result == 0;
              D.26440 = D.26438 & D.26439;
              if (D.26440 != 0) goto <D.26441>; else goto <D.26442>;
              <D.26441>:
              D.26443 = &MEM[(void *)"DateTime" + 1B];
              D.26444 = *D.26443;
              D.26445 = (int) D.26444;
              D.26446 = __s2 + 1;
              D.26447 = *D.26446;
              D.26448 = (int) D.26447;
              __result = D.26445 - D.26448;
              D.26449 = __s2_len > 1;
              D.26439 = __result == 0;
              D.26450 = D.26449 & D.26439;
              if (D.26450 != 0) goto <D.26451>; else goto <D.26452>;
              <D.26451>:
              D.26453 = &MEM[(void *)"DateTime" + 2B];
              D.26454 = *D.26453;
              D.26455 = (int) D.26454;
              D.26456 = __s2 + 2;
              D.26457 = *D.26456;
              D.26458 = (int) D.26457;
              __result = D.26455 - D.26458;
              D.26459 = __s2_len > 2;
              D.26439 = __result == 0;
              D.26460 = D.26459 & D.26439;
              if (D.26460 != 0) goto <D.26461>; else goto <D.26462>;
              <D.26461>:
              D.26463 = &MEM[(void *)"DateTime" + 3B];
              D.26464 = *D.26463;
              D.26465 = (int) D.26464;
              D.26466 = __s2 + 3;
              D.26467 = *D.26466;
              D.26468 = (int) D.26467;
              __result = D.26465 - D.26468;
              <D.26462>:
              <D.26452>:
              <D.26442>:
            }
            D.19240 = __result;
          }
          iftmp.86 = -D.19240;
          goto <D.26469>;
          <D.26432>:
          D.26470 = klass->name;
          iftmp.86 = __builtin_strcmp (D.26470, "DateTime");
          <D.26469>:
          D.19241 = iftmp.86;
        }
        if (D.19241 == 0) goto <D.26471>; else goto <D.26383>;
        <D.26471>:
        len = 8;
        goto <D.26384>;
        <D.26383>:
        monoeg_g_log (0B, 4, "we can\'t encode valuetypes, we should have never reached this line");
        <D.19242>:
        goto <D.19242>;
        <D.26384>:
        goto <D.19212>;
      }
      <D.19243>:
      goto <D.19212>;
      <D.19244>:
      {
        struct MonoString * str;

        str = val;
        D.26472 = str->length;
        D.26473 = D.26472 * 2;
        len = (guint32) D.26473;
        b.87 = b;
        mono_metadata_encode_value (len, b.87, &b);
        len.88 = (int) len;
        D.26476 = mono_string_chars (str);
        b.87 = b;
        b.89 = (long int) b.87;
        blob_size.90 = (long int) &blob_size;
        D.26479 = b.89 - blob_size.90;
        D.26480 = (int) D.26479;
        idx = add_to_blob_cached (assembly, &blob_size, D.26480, D.26476, len.88);
        monoeg_g_free (buf);
        D.26481 = idx;
        return D.26481;
      }
      <D.19246>:
      D.26371 = val->vtable;
      D.26372 = D.26371->klass;
      D.26482 = D.26372->generic_class;
      D.26483 = D.26482->container_class;
      D.26484 = D.26483->byval_arg.type;
      D.26485 = (unsigned int) D.26484;
      *ret_type = D.26485;
      goto handle_enum;
      <D.19247>:
      D.26375 = *ret_type;
      monoeg_g_log (0B, 4, "we don\'t encode constant type 0x%02x yet", D.26375);
      <D.19248>:
      goto <D.19248>;
      <D.19212>:
      b.87 = b;
      mono_metadata_encode_value (len, b.87, &b);
      len.88 = (int) len;
      b.87 = b;
      b.89 = (long int) b.87;
      blob_size.90 = (long int) &blob_size;
      D.26479 = b.89 - blob_size.90;
      D.26480 = (int) D.26479;
      idx = add_to_blob_cached (assembly, &blob_size, D.26480, box_val, len.88);
      monoeg_g_free (buf);
      D.26481 = idx;
      return D.26481;
    }
  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.26489;
  int D.26490;
  _Bool D.26491;
  long int D.26492;
  long int D.26493;
  guint32 * D.26496;
  long unsigned int D.26497;
  long unsigned int D.26498;
  long unsigned int D.26499;
  long unsigned int D.26500;
  guint32 * D.26501;
  unsigned int D.26502;
  guint32 D.26505;
  unsigned int i.91;
  unsigned int D.26507;
  int i;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[table_idx];
  D.26489 = table->columns;
  D.26490 = (int) D.26489;
  D.26491 = D.26490 <= col;
  D.26492 = (long int) D.26491;
  D.26493 = __builtin_expect (D.26492, 0);
  if (D.26493 != 0) goto <D.26494>; else goto <D.26495>;
  <D.26494>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1155, "col < table->columns");
  <D.26495>:
  D.26496 = table->values;
  D.26489 = table->columns;
  D.26497 = (long unsigned int) D.26489;
  D.26498 = D.26497 * 4;
  values = D.26496 + D.26498;
  i = 1;
  goto <D.19013>;
  <D.19012>:
  D.26499 = (long unsigned int) col;
  D.26500 = D.26499 * 4;
  D.26501 = values + D.26500;
  D.26502 = *D.26501;
  if (D.26502 == token) goto <D.26503>; else goto <D.26504>;
  <D.26503>:
  D.26505 = (guint32) i;
  return D.26505;
  <D.26504>:
  D.26489 = table->columns;
  D.26497 = (long unsigned int) D.26489;
  D.26498 = D.26497 * 4;
  values = values + D.26498;
  i = i + 1;
  <D.19013>:
  i.91 = (unsigned int) i;
  D.26507 = table->rows;
  if (i.91 <= D.26507) goto <D.19012>; else goto <D.19014>;
  <D.19014>:
  D.26505 = 0;
  return D.26505;
}


mono_image_get_generic_param_info (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  int D.26509;
  void * D.26514;
  struct MonoReflectionGenericParam * * D.26515;
  struct GPtrArray * D.26516;
  struct GenericParamTableEntry * entry;

  entry = monoeg_malloc0 (16);
  entry->owner = owner;
  D.26509 = mono_gc_is_moving ();
  if (D.26509 != 0) goto <D.26510>; else goto <D.26511>;
  <D.26510>:
  if (0 != 0) goto <D.26512>; else goto <D.26513>;
  <D.26512>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2206, "sizeof (entry->gparam) == sizeof (MonoObject*)");
  <D.26513>:
  D.26514 = mono_gc_make_root_descr_all_refs (1);
  D.26515 = &entry->gparam;
  mono_gc_register_root (D.26515, 8, D.26514);
  <D.26511>:
  entry->gparam = gparam;
  D.26516 = assembly->gen_params;
  monoeg_g_ptr_array_add (D.26516, entry);
}


mono_image_get_field_info (struct MonoReflectionFieldBuilder * fb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26517;
  unsigned int D.26518;
  unsigned int D.26521;
  unsigned int D.26522;
  unsigned int D.26523;
  unsigned int D.26524;
  int D.26525;
  int D.26526;
  long unsigned int D.26527;
  void * D.26528;
  struct MonoClassField * D.26529;
  struct GHashTable * D.26530;
  guint32 * D.26531;
  int D.26532;
  long unsigned int D.26533;
  long unsigned int D.26534;
  guint32 * D.26535;
  struct MonoString * D.26536;
  struct MonoDynamicStream * D.26537;
  unsigned int D.26538;
  guint32 * D.26539;
  unsigned int D.26540;
  int D.26541;
  unsigned int D.26544;
  unsigned int D.26545;
  unsigned int D.26546;
  long unsigned int D.26547;
  long unsigned int D.26548;
  unsigned int D.26549;
  unsigned int D.26550;
  unsigned int D.26553;
  long unsigned int D.26554;
  long unsigned int D.26555;
  int D.26556;
  unsigned int D.26557;
  guint32 * D.26558;
  struct MonoObject * D.26559;
  unsigned int D.26560;
  unsigned int field_type.92;
  unsigned int D.26562;
  struct MonoArray * D.26565;
  long unsigned int D.26568;
  struct MonoDynamicStream * D.26571;
  long unsigned int D.26572;
  unsigned int D.26573;
  char * D.26574;
  struct MonoClass * D.26576;
  int D.26577;
  unsigned int D.26578;
  unsigned int D.26579;
  unsigned int D.26580;
  struct MonoReflectionMarshal * D.26581;
  int D.26584;
  unsigned int D.26585;
  unsigned int D.26586;
  struct MonoDynamicTable * table;
  guint32 * values;

  D.26517 = fb->attrs;
  D.26518 = D.26517 & 64;
  if (D.26518 != 0) goto <D.26519>; else goto <D.26520>;
  <D.26519>:
  D.26517 = fb->attrs;
  D.26521 = D.26517 | 32768;
  fb->attrs = D.26521;
  <D.26520>:
  table = &assembly->tables[4];
  D.26522 = table->next_idx;
  D.26523 = D.26522;
  D.26524 = D.26523 + 1;
  table->next_idx = D.26524;
  D.26525 = (int) D.26523;
  fb->table_idx = D.26525;
  D.26526 = fb->table_idx;
  D.26527 = (long unsigned int) D.26526;
  D.26528 = (void *) D.26527;
  D.26529 = fb->handle;
  D.26530 = assembly->field_to_table_idx;
  monoeg_g_hash_table_insert_replace (D.26530, D.26529, D.26528, 0);
  D.26531 = table->values;
  D.26526 = fb->table_idx;
  D.26532 = D.26526 * 3;
  D.26533 = (long unsigned int) D.26532;
  D.26534 = D.26533 * 4;
  values = D.26531 + D.26534;
  D.26535 = values + 4;
  D.26536 = fb->name;
  D.26537 = &assembly->sheap;
  D.26538 = string_heap_insert_mstring (D.26537, D.26536);
  *D.26535 = D.26538;
  D.26517 = fb->attrs;
  *values = D.26517;
  D.26539 = values + 8;
  D.26540 = field_encode_signature (assembly, fb);
  *D.26539 = D.26540;
  D.26541 = fb->offset;
  if (D.26541 != -1) goto <D.26542>; else goto <D.26543>;
  <D.26542>:
  table = &assembly->tables[16];
  D.26544 = table->rows;
  D.26545 = D.26544 + 1;
  table->rows = D.26545;
  D.26544 = table->rows;
  alloc_table (table, D.26544);
  D.26531 = table->values;
  D.26544 = table->rows;
  D.26546 = D.26544 * 2;
  D.26547 = (long unsigned int) D.26546;
  D.26548 = D.26547 * 4;
  values = D.26531 + D.26548;
  D.26535 = values + 4;
  D.26526 = fb->table_idx;
  D.26549 = (unsigned int) D.26526;
  *D.26535 = D.26549;
  D.26541 = fb->offset;
  D.26550 = (unsigned int) D.26541;
  *values = D.26550;
  <D.26543>:
  D.26517 = fb->attrs;
  D.26518 = D.26517 & 64;
  if (D.26518 != 0) goto <D.26551>; else goto <D.26552>;
  <D.26551>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.26544 = table->rows;
        D.26545 = D.26544 + 1;
        table->rows = D.26545;
        D.26544 = table->rows;
        alloc_table (table, D.26544);
        D.26531 = table->values;
        D.26544 = table->rows;
        D.26553 = D.26544 * 4;
        D.26554 = (long unsigned int) D.26553;
        D.26555 = D.26554 * 4;
        values = D.26531 + D.26555;
        D.26539 = values + 8;
        D.26526 = fb->table_idx;
        D.26556 = D.26526 << 2;
        D.26557 = (unsigned int) D.26556;
        *D.26539 = D.26557;
        D.26558 = values + 12;
        D.26559 = fb->def_value;
        D.26560 = encode_constant (assembly, D.26559, &field_type);
        *D.26558 = D.26560;
        field_type.92 = field_type;
        *values = field_type.92;
        D.26535 = values + 4;
        *D.26535 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.26552>:
  D.26517 = fb->attrs;
  D.26562 = D.26517 & 256;
  if (D.26562 != 0) goto <D.26563>; else goto <D.26564>;
  <D.26563>:
  {
    guint32 rva_idx;

    table = &assembly->tables[29];
    D.26544 = table->rows;
    D.26545 = D.26544 + 1;
    table->rows = D.26545;
    D.26544 = table->rows;
    alloc_table (table, D.26544);
    D.26531 = table->values;
    D.26544 = table->rows;
    D.26546 = D.26544 * 2;
    D.26547 = (long unsigned int) D.26546;
    D.26548 = D.26547 * 4;
    values = D.26531 + D.26548;
    D.26535 = values + 4;
    D.26526 = fb->table_idx;
    D.26549 = (unsigned int) D.26526;
    *D.26535 = D.26549;
    D.26565 = fb->rva_data;
    if (D.26565 != 0B) goto <D.26566>; else goto <D.26567>;
    <D.26566>:
    D.26565 = fb->rva_data;
    D.26568 = mono_array_length (D.26565);
    if (D.26568 > 9) goto <D.26569>; else goto <D.26570>;
    <D.26569>:
    D.26571 = &assembly->code;
    stream_data_align (D.26571);
    <D.26570>:
    D.26565 = fb->rva_data;
    D.26572 = mono_array_length (D.26565);
    D.26573 = (unsigned int) D.26572;
    D.26565 = fb->rva_data;
    D.26574 = mono_array_addr_with_size (D.26565, 1, 0);
    D.26571 = &assembly->code;
    rva_idx = mono_image_add_stream_data (D.26571, D.26574, D.26573);
    goto <D.26575>;
    <D.26567>:
    D.26529 = fb->handle;
    D.26576 = D.26529->parent;
    D.26577 = mono_class_value_size (D.26576, 0B);
    D.26578 = (unsigned int) D.26577;
    D.26571 = &assembly->code;
    rva_idx = mono_image_add_stream_zero (D.26571, D.26578);
    <D.26575>:
    D.26579 = assembly->text_rva;
    D.26580 = D.26579 + rva_idx;
    *values = D.26580;
  }
  <D.26564>:
  D.26581 = fb->marshal_info;
  if (D.26581 != 0B) goto <D.26582>; else goto <D.26583>;
  <D.26582>:
  table = &assembly->tables[13];
  D.26544 = table->rows;
  D.26545 = D.26544 + 1;
  table->rows = D.26545;
  D.26544 = table->rows;
  alloc_table (table, D.26544);
  D.26531 = table->values;
  D.26544 = table->rows;
  D.26546 = D.26544 * 2;
  D.26547 = (long unsigned int) D.26546;
  D.26548 = D.26547 * 4;
  values = D.26531 + D.26548;
  D.26526 = fb->table_idx;
  D.26584 = D.26526 << 1;
  D.26585 = (unsigned int) D.26584;
  *values = D.26585;
  D.26535 = values + 4;
  D.26581 = fb->marshal_info;
  D.26586 = encode_marshal_blob (assembly, D.26581);
  *D.26535 = D.26586;
  <D.26583>:
}


field_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoObject * D.26587;
  struct MonoArray * D.26588;
  struct MonoArray * D.26589;
  struct MonoGenericContainer * D.26590;
  struct MonoGenericInst * D.26595;
  guint32 D.26597;
  struct SigBuffer buf;
  guint32 idx;
  guint32 typespec;
  struct MonoType * type;
  struct MonoClass * class;

  try
    {
      typespec = 0;
      D.26587 = fb->type;
      init_type_builder_generics (D.26587);
      D.26587 = fb->type;
      type = mono_reflection_type_get_handle (D.26587);
      class = mono_class_from_mono_type (type);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.26588 = fb->modopt;
      D.26589 = fb->modreq;
      encode_custom_modifiers (assembly, D.26589, D.26588, &buf);
      D.26590 = class->generic_container;
      if (D.26590 != 0B) goto <D.26591>; else goto <D.26592>;
      <D.26591>:
      typespec = create_typespec (assembly, type);
      <D.26592>:
      if (typespec != 0) goto <D.26593>; else goto <D.26594>;
      <D.26593>:
      {
        struct MonoGenericClass * gclass;

        D.26590 = class->generic_container;
        D.26595 = D.26590->context.class_inst;
        gclass = mono_metadata_lookup_generic_class (class, D.26595, 1);
        encode_generic_class (assembly, gclass, &buf);
      }
      goto <D.26596>;
      <D.26594>:
      encode_type (assembly, type, &buf);
      <D.26596>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.26597 = idx;
      return D.26597;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


init_type_builder_generics (struct MonoObject * type)
{
  struct MonoVTable * D.26600;
  struct MonoClass * D.26601;
  int D.26602;
  struct MonoGenericContainer * D.26607;
  struct MonoReflectionTypeBuilder * tb;

  D.26600 = type->vtable;
  D.26601 = D.26600->klass;
  D.26602 = is_sre_type_builder (D.26601);
  if (D.26602 == 0) goto <D.26603>; else goto <D.26604>;
  <D.26603>:
  return;
  <D.26604>:
  tb = type;
  if (tb != 0B) goto <D.26605>; else goto <D.26606>;
  <D.26605>:
  D.26607 = tb->generic_container;
  if (D.26607 != 0B) goto <D.26608>; else goto <D.26609>;
  <D.26608>:
  mono_reflection_create_generic_class (tb);
  <D.26609>:
  <D.26606>:
}


is_sre_type_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.93;
  gboolean D.26614;
  _Bool D.26615;
  int D.26616;
  int D.22588;
  int iftmp.94;
  int D.22584;
  const char[12] * D.26622;
  unsigned char D.26623;
  int D.26624;
  unsigned char D.26625;
  int D.26626;
  _Bool D.26627;
  _Bool D.26628;
  _Bool D.26629;
  const unsigned char * D.26632;
  unsigned char D.26633;
  int D.26634;
  const unsigned char * D.26635;
  unsigned char D.26636;
  int D.26637;
  _Bool D.26638;
  _Bool D.26639;
  const unsigned char * D.26642;
  unsigned char D.26643;
  int D.26644;
  const unsigned char * D.26645;
  unsigned char D.26646;
  int D.26647;
  _Bool D.26648;
  _Bool D.26649;
  const unsigned char * D.26652;
  unsigned char D.26653;
  int D.26654;
  const unsigned char * D.26655;
  unsigned char D.26656;
  int D.26657;
  const char * D.26659;
  int D.22597;
  int iftmp.95;
  int D.22593;
  const char[23] * D.26665;
  unsigned char D.26666;
  int D.26667;
  unsigned char D.26668;
  int D.26669;
  _Bool D.26670;
  _Bool D.26671;
  _Bool D.26672;
  const unsigned char * D.26675;
  unsigned char D.26676;
  int D.26677;
  const unsigned char * D.26678;
  unsigned char D.26679;
  int D.26680;
  _Bool D.26681;
  _Bool D.26682;
  const unsigned char * D.26685;
  unsigned char D.26686;
  int D.26687;
  const unsigned char * D.26688;
  unsigned char D.26689;
  int D.26690;
  _Bool D.26691;
  _Bool D.26692;
  const unsigned char * D.26695;
  unsigned char D.26696;
  int D.26697;
  const unsigned char * D.26698;
  unsigned char D.26699;
  int D.26700;
  const char * D.26702;

  {
    static struct MonoClass * cached_class;

    cached_class.93 = cached_class;
    if (cached_class.93 != 0B) goto <D.26612>; else goto <D.26613>;
    <D.26612>:
    cached_class.93 = cached_class;
    D.26615 = cached_class.93 == class;
    D.26614 = (gboolean) D.26615;
    return D.26614;
    <D.26613>:
    D.26616 = is_corlib_type (class);
    if (D.26616 != 0) goto <D.26617>; else goto <D.26618>;
    <D.26617>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.26622 = "TypeBuilder";
        D.26623 = MEM[(const unsigned char *)D.26622];
        D.26624 = (int) D.26623;
        D.26625 = *__s2;
        D.26626 = (int) D.26625;
        __result = D.26624 - D.26626;
        {
          D.26627 = __s1_len != 0;
          D.26628 = __result == 0;
          D.26629 = D.26627 & D.26628;
          if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
          <D.26630>:
          D.26632 = &MEM[(void *)"TypeBuilder" + 1B];
          D.26633 = *D.26632;
          D.26634 = (int) D.26633;
          D.26635 = __s2 + 1;
          D.26636 = *D.26635;
          D.26637 = (int) D.26636;
          __result = D.26634 - D.26637;
          D.26638 = __s1_len > 1;
          D.26628 = __result == 0;
          D.26639 = D.26638 & D.26628;
          if (D.26639 != 0) goto <D.26640>; else goto <D.26641>;
          <D.26640>:
          D.26642 = &MEM[(void *)"TypeBuilder" + 2B];
          D.26643 = *D.26642;
          D.26644 = (int) D.26643;
          D.26645 = __s2 + 2;
          D.26646 = *D.26645;
          D.26647 = (int) D.26646;
          __result = D.26644 - D.26647;
          D.26648 = __s1_len > 2;
          D.26628 = __result == 0;
          D.26649 = D.26648 & D.26628;
          if (D.26649 != 0) goto <D.26650>; else goto <D.26651>;
          <D.26650>:
          D.26652 = &MEM[(void *)"TypeBuilder" + 3B];
          D.26653 = *D.26652;
          D.26654 = (int) D.26653;
          D.26655 = __s2 + 3;
          D.26656 = *D.26655;
          D.26657 = (int) D.26656;
          __result = D.26654 - D.26657;
          <D.26651>:
          <D.26641>:
          <D.26631>:
        }
        D.22584 = __result;
      }
      iftmp.94 = D.22584;
      goto <D.26658>;
      <D.26621>:
      D.26659 = class->name;
      iftmp.94 = __builtin_strcmp ("TypeBuilder", D.26659);
      <D.26658>:
      D.22588 = iftmp.94;
    }
    if (D.22588 == 0) goto <D.26660>; else goto <D.26661>;
    <D.26660>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.26665 = "System.Reflection.Emit";
        D.26666 = MEM[(const unsigned char *)D.26665];
        D.26667 = (int) D.26666;
        D.26668 = *__s2;
        D.26669 = (int) D.26668;
        __result = D.26667 - D.26669;
        {
          D.26670 = __s1_len != 0;
          D.26671 = __result == 0;
          D.26672 = D.26670 & D.26671;
          if (D.26672 != 0) goto <D.26673>; else goto <D.26674>;
          <D.26673>:
          D.26675 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.26676 = *D.26675;
          D.26677 = (int) D.26676;
          D.26678 = __s2 + 1;
          D.26679 = *D.26678;
          D.26680 = (int) D.26679;
          __result = D.26677 - D.26680;
          D.26681 = __s1_len > 1;
          D.26671 = __result == 0;
          D.26682 = D.26681 & D.26671;
          if (D.26682 != 0) goto <D.26683>; else goto <D.26684>;
          <D.26683>:
          D.26685 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.26686 = *D.26685;
          D.26687 = (int) D.26686;
          D.26688 = __s2 + 2;
          D.26689 = *D.26688;
          D.26690 = (int) D.26689;
          __result = D.26687 - D.26690;
          D.26691 = __s1_len > 2;
          D.26671 = __result == 0;
          D.26692 = D.26691 & D.26671;
          if (D.26692 != 0) goto <D.26693>; else goto <D.26694>;
          <D.26693>:
          D.26695 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.26696 = *D.26695;
          D.26697 = (int) D.26696;
          D.26698 = __s2 + 3;
          D.26699 = *D.26698;
          D.26700 = (int) D.26699;
          __result = D.26697 - D.26700;
          <D.26694>:
          <D.26684>:
          <D.26674>:
        }
        D.22593 = __result;
      }
      iftmp.95 = D.22593;
      goto <D.26701>;
      <D.26664>:
      D.26702 = class->name_space;
      iftmp.95 = __builtin_strcmp ("System.Reflection.Emit", D.26702);
      <D.26701>:
      D.22597 = iftmp.95;
    }
    if (D.22597 == 0) goto <D.26703>; else goto <D.26704>;
    <D.26703>:
    cached_class = class;
    D.26614 = 1;
    return D.26614;
    <D.26704>:
    <D.26661>:
    <D.26618>:
    D.26614 = 0;
    return D.26614;
  }
}


is_corlib_type (struct MonoClass * class)
{
  gboolean D.26706;
  struct MonoImage * D.26707;
  struct MonoImage * D.26708;
  _Bool D.26709;

  D.26707 = class->image;
  D.26708 = mono_defaults.corlib;
  D.26709 = D.26707 == D.26708;
  D.26706 = (gboolean) D.26709;
  return D.26706;
}


mono_image_add_stream_zero (struct MonoDynamicStream * stream, guint32 len)
{
  unsigned int D.26711;
  unsigned int D.26712;
  int D.26713;
  long unsigned int D.26714;
  char * D.26715;
  sizetype D.26716;
  void * D.26717;
  guint32 D.26718;
  guint32 idx;

  D.26711 = stream->index;
  D.26712 = D.26711 + len;
  D.26713 = (int) D.26712;
  make_room_in_stream (stream, D.26713);
  D.26714 = (long unsigned int) len;
  D.26715 = stream->data;
  D.26711 = stream->index;
  D.26716 = (sizetype) D.26711;
  D.26717 = D.26715 + D.26716;
  memset (D.26717, 0, D.26714);
  idx = stream->index;
  D.26711 = stream->index;
  D.26712 = D.26711 + len;
  stream->index = D.26712;
  D.26718 = idx;
  return D.26718;
}


mono_image_fill_module_table (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly)
{
  unsigned int D.26720;
  unsigned int D.26721;
  unsigned int D.26722;
  guint32 * D.26723;
  unsigned int D.26724;
  unsigned int D.26725;
  unsigned int D.26726;
  long unsigned int D.26727;
  long unsigned int D.26728;
  guint32 * D.26729;
  struct MonoString * D.26730;
  struct MonoDynamicStream * D.26731;
  unsigned int D.26732;
  struct MonoArray * D.26733;
  char * D.26734;
  struct MonoDynamicStream * D.26735;
  unsigned int D.26736;
  long unsigned int D.26737;
  long unsigned int D.26738;
  guint32 * D.26739;
  unsigned int D.26740;
  long unsigned int D.26741;
  long unsigned int D.26742;
  guint32 * D.26743;
  unsigned int i.96;
  unsigned int D.26745;
  long unsigned int D.26746;
  long unsigned int D.26747;
  guint32 * D.26748;
  unsigned int D.26749;
  long unsigned int D.26750;
  long unsigned int D.26751;
  guint32 * D.26752;
  struct MonoDynamicTable * table;
  int i;

  table = &assembly->tables[0];
  D.26720 = table->next_idx;
  D.26721 = D.26720;
  D.26722 = D.26721 + 1;
  table->next_idx = D.26722;
  mb->table_idx = D.26721;
  D.26723 = table->values;
  D.26724 = mb->table_idx;
  D.26725 = D.26724 * 5;
  D.26726 = D.26725 + 1;
  D.26727 = (long unsigned int) D.26726;
  D.26728 = D.26727 * 4;
  D.26729 = D.26723 + D.26728;
  D.26730 = mb->module.name;
  D.26731 = &assembly->sheap;
  D.26732 = string_heap_insert_mstring (D.26731, D.26730);
  *D.26729 = D.26732;
  D.26733 = mb->guid;
  D.26734 = mono_array_addr_with_size (D.26733, 1, 0);
  D.26735 = &assembly->guid;
  D.26736 = mono_image_add_stream_data (D.26735, D.26734, 16);
  i = (int) D.26736;
  i = i / 16;
  i = i + 1;
  D.26723 = table->values;
  D.26724 = mb->table_idx;
  D.26725 = D.26724 * 5;
  D.26737 = (long unsigned int) D.26725;
  D.26738 = D.26737 * 4;
  D.26739 = D.26723 + D.26738;
  *D.26739 = 0;
  D.26723 = table->values;
  D.26724 = mb->table_idx;
  D.26725 = D.26724 * 5;
  D.26740 = D.26725 + 2;
  D.26741 = (long unsigned int) D.26740;
  D.26742 = D.26741 * 4;
  D.26743 = D.26723 + D.26742;
  i.96 = (unsigned int) i;
  *D.26743 = i.96;
  D.26723 = table->values;
  D.26724 = mb->table_idx;
  D.26725 = D.26724 * 5;
  D.26745 = D.26725 + 3;
  D.26746 = (long unsigned int) D.26745;
  D.26747 = D.26746 * 4;
  D.26748 = D.26723 + D.26747;
  *D.26748 = 0;
  D.26723 = table->values;
  D.26724 = mb->table_idx;
  D.26725 = D.26724 * 5;
  D.26749 = D.26725 + 4;
  D.26750 = (long unsigned int) D.26749;
  D.26751 = D.26750 * 4;
  D.26752 = D.26723 + D.26751;
  *D.26752 = 0;
}


collect_types (struct MonoPtrArray * types, struct MonoReflectionTypeBuilder * type)
{
  int D.26753;
  int D.26754;
  int D.26757;
  void * D.26758;
  long unsigned int D.26759;
  long unsigned int D.26760;
  long unsigned int D.26761;
  void * * D.26762;
  int D.26765;
  int D.26766;
  long unsigned int D.26767;
  long unsigned int D.26768;
  void * * D.26769;
  struct MonoArray * D.26770;
  long unsigned int D.26773;
  char * D.26774;
  long unsigned int D.26775;
  int i;

  D.26753 = types->size;
  D.26754 = types->capacity;
  if (D.26753 >= D.26754) goto <D.26755>; else goto <D.26756>;
  <D.26755>:
  {
    void * __tmp;

    D.26754 = types->capacity;
    D.26757 = D.26754 * 2;
    D.26758 = mono_gc_make_root_descr_all_refs (D.26757);
    D.26754 = types->capacity;
    D.26759 = (long unsigned int) D.26754;
    D.26760 = D.26759 * 16;
    __tmp = mono_gc_alloc_fixed (D.26760, D.26758);
    D.26754 = types->capacity;
    D.26759 = (long unsigned int) D.26754;
    D.26761 = D.26759 * 8;
    D.26762 = types->data;
    mono_gc_memmove_aligned (__tmp, D.26762, D.26761);
    D.26754 = types->capacity;
    if (D.26754 > 16) goto <D.26763>; else goto <D.26764>;
    <D.26763>:
    D.26762 = types->data;
    mono_gc_free_fixed (D.26762);
    <D.26764>:
    types->data = __tmp;
    D.26754 = types->capacity;
    D.26757 = D.26754 * 2;
    types->capacity = D.26757;
  }
  <D.26756>:
  D.26762 = types->data;
  D.26753 = types->size;
  D.26765 = D.26753;
  D.26766 = D.26765 + 1;
  types->size = D.26766;
  D.26767 = (long unsigned int) D.26765;
  D.26768 = D.26767 * 8;
  D.26769 = D.26762 + D.26768;
  *D.26769 = type;
  D.26770 = type->subtypes;
  if (D.26770 == 0B) goto <D.26771>; else goto <D.26772>;
  <D.26771>:
  return;
  <D.26772>:
  i = 0;
  goto <D.19781>;
  <D.19780>:
  {
    struct MonoReflectionTypeBuilder * subtype;

    D.26773 = (long unsigned int) i;
    D.26770 = type->subtypes;
    D.26774 = mono_array_addr_with_size (D.26770, 8, D.26773);
    subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.26774];
    collect_types (types, subtype);
  }
  i = i + 1;
  <D.19781>:
  D.26773 = (long unsigned int) i;
  D.26770 = type->subtypes;
  D.26775 = mono_array_length (D.26770);
  if (D.26773 < D.26775) goto <D.19780>; else goto <D.19782>;
  <D.19782>:
}


alloc_table (struct MonoDynamicTable * table, guint nrows)
{
  unsigned char D.26777;
  _Bool D.26778;
  long int D.26779;
  long int D.26780;
  unsigned int D.26783;
  unsigned int D.26784;
  unsigned int D.26790;
  long unsigned int D.26791;
  long unsigned int D.26792;
  long unsigned int D.26793;
  long unsigned int D.26794;
  guint32 * D.26795;
  void * D.26796;

  table->rows = nrows;
  D.26777 = table->columns;
  D.26778 = D.26777 == 0;
  D.26779 = (long int) D.26778;
  D.26780 = __builtin_expect (D.26779, 0);
  if (D.26780 != 0) goto <D.26781>; else goto <D.26782>;
  <D.26781>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 327, "table->columns");
  <D.26782>:
  D.26783 = nrows + 1;
  D.26784 = table->alloc_rows;
  if (D.26783 >= D.26784) goto <D.26785>; else goto <D.26786>;
  <D.26785>:
  goto <D.18702>;
  <D.18701>:
  D.26784 = table->alloc_rows;
  if (D.26784 == 0) goto <D.26787>; else goto <D.26788>;
  <D.26787>:
  table->alloc_rows = 16;
  goto <D.26789>;
  <D.26788>:
  D.26784 = table->alloc_rows;
  D.26790 = D.26784 * 2;
  table->alloc_rows = D.26790;
  <D.26789>:
  <D.18702>:
  D.26783 = nrows + 1;
  D.26784 = table->alloc_rows;
  if (D.26783 >= D.26784) goto <D.18701>; else goto <D.18703>;
  <D.18703>:
  D.26784 = table->alloc_rows;
  D.26791 = (long unsigned int) D.26784;
  D.26777 = table->columns;
  D.26792 = (long unsigned int) D.26777;
  D.26793 = D.26791 * D.26792;
  D.26794 = D.26793 * 4;
  D.26795 = table->values;
  D.26796 = monoeg_realloc (D.26795, D.26794);
  table->values = D.26796;
  <D.26786>:
}


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

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


mono_image_get_type_info (struct MonoDomain * domain, struct MonoReflectionTypeBuilder * tb, struct MonoDynamicImage * assembly)
{
  guint32 * D.26799;
  unsigned int D.26800;
  unsigned int D.26801;
  long unsigned int D.26802;
  long unsigned int D.26803;
  unsigned int D.26804;
  struct MonoString * D.26805;
  int D.19735;
  int iftmp.97;
  int D.19734;
  const char[7] * D.26809;
  unsigned char D.26810;
  int D.26811;
  unsigned char D.26812;
  int D.26813;
  _Bool D.26814;
  _Bool D.26815;
  _Bool D.26816;
  const unsigned char * D.26819;
  unsigned char D.26820;
  int D.26821;
  const unsigned char * D.26822;
  unsigned char D.26823;
  int D.26824;
  _Bool D.26825;
  _Bool D.26826;
  const unsigned char * D.26829;
  unsigned char D.26830;
  int D.26831;
  const unsigned char * D.26832;
  unsigned char D.26833;
  int D.26834;
  _Bool D.26835;
  _Bool D.26836;
  const unsigned char * D.26839;
  unsigned char D.26840;
  int D.26841;
  const unsigned char * D.26842;
  unsigned char D.26843;
  int D.26844;
  guint * D.26848;
  struct MonoDynamicStream * D.26849;
  unsigned int D.26850;
  struct MonoString * D.26851;
  int D.19744;
  int iftmp.98;
  int D.19743;
  const char[7] * D.26855;
  unsigned char D.26856;
  int D.26857;
  unsigned char D.26858;
  int D.26859;
  _Bool D.26860;
  _Bool D.26861;
  _Bool D.26862;
  const unsigned char * D.26865;
  unsigned char D.26866;
  int D.26867;
  const unsigned char * D.26868;
  unsigned char D.26869;
  int D.26870;
  _Bool D.26871;
  _Bool D.26872;
  const unsigned char * D.26875;
  unsigned char D.26876;
  int D.26877;
  const unsigned char * D.26878;
  unsigned char D.26879;
  int D.26880;
  _Bool D.26881;
  _Bool D.26882;
  const unsigned char * D.26885;
  unsigned char D.26886;
  int D.26887;
  const unsigned char * D.26888;
  unsigned char D.26889;
  int D.26890;
  guint * D.26894;
  unsigned int D.26895;
  struct MonoObject * D.26898;
  _Bool D.26900;
  _Bool D.26901;
  _Bool D.26902;
  unsigned int D.26904;
  guint * D.26906;
  struct MonoType * D.26907;
  unsigned int D.26908;
  guint * D.26909;
  unsigned int D.26910;
  guint * D.26911;
  unsigned int D.26912;
  unsigned int D.26915;
  int D.26918;
  int D.26920;
  unsigned int D.26921;
  unsigned int D.26922;
  unsigned int D.26923;
  long unsigned int D.26924;
  long unsigned int D.26925;
  unsigned int D.26926;
  unsigned int D.26927;
  struct MonoArray * D.26928;
  long unsigned int D.26931;
  unsigned int D.26932;
  unsigned int D.26933;
  int D.26934;
  int D.26935;
  long unsigned int D.26936;
  long unsigned int D.26937;
  long unsigned int D.26938;
  char * D.26939;
  struct MonoType * D.26940;
  unsigned int D.26941;
  long unsigned int D.26942;
  struct MonoArray * D.26943;
  int D.26946;
  unsigned int D.26947;
  unsigned int D.26948;
  char * D.26949;
  struct MonoReflectionFieldBuilder * D.26950;
  struct MonoArray * D.26951;
  long unsigned int D.26954;
  unsigned int D.26955;
  unsigned int D.26956;
  char * D.26957;
  struct MonoReflectionCtorBuilder * D.26958;
  long unsigned int D.26959;
  struct MonoArray * D.26960;
  int D.26963;
  unsigned int D.26964;
  unsigned int D.26965;
  char * D.26966;
  struct MonoReflectionMethodBuilder * D.26967;
  struct MonoArray * D.26968;
  long unsigned int D.26971;
  long unsigned int D.26974;
  unsigned int D.26975;
  unsigned int D.26976;
  unsigned int D.26977;
  long unsigned int D.26978;
  long unsigned int D.26979;
  unsigned int D.26980;
  char * D.26981;
  struct MonoReflectionEventBuilder * D.26982;
  long unsigned int D.26983;
  struct MonoArray * D.26984;
  long unsigned int D.26987;
  long unsigned int D.26990;
  unsigned int D.26991;
  unsigned int D.26992;
  unsigned int D.26993;
  char * D.26994;
  struct MonoReflectionPropertyBuilder * D.26995;
  long unsigned int D.26996;
  struct MonoArray * D.26997;
  long unsigned int D.27000;
  unsigned int D.27001;
  unsigned int D.27002;
  char * D.27003;
  struct MonoReflectionGenericParam * D.27004;
  long unsigned int D.27005;
  struct MonoArray * D.27006;
  unsigned int D.27007;
  struct MonoArray * D.27008;
  long unsigned int D.27011;
  unsigned int D.27012;
  unsigned int D.27013;
  unsigned int D.27014;
  guint32 * D.27015;
  unsigned int D.27016;
  unsigned int D.27017;
  long unsigned int D.27018;
  long unsigned int D.27019;
  char * D.27020;
  unsigned int D.27021;
  unsigned int D.27022;
  long unsigned int D.27023;
  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.26799 = table->values;
  D.26800 = tb->table_idx;
  D.26801 = D.26800 * 6;
  D.26802 = (long unsigned int) D.26801;
  D.26803 = D.26802 * 4;
  values = D.26799 + D.26803;
  D.26804 = tb->attrs;
  *values = D.26804;
  D.26805 = tb->name;
  n = mono_string_to_utf8 (D.26805);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26809 = "Object";
      D.26810 = MEM[(const unsigned char *)D.26809];
      D.26811 = (int) D.26810;
      D.26812 = *__s2;
      D.26813 = (int) D.26812;
      __result = D.26811 - D.26813;
      {
        D.26814 = __s2_len != 0;
        D.26815 = __result == 0;
        D.26816 = D.26814 & D.26815;
        if (D.26816 != 0) goto <D.26817>; else goto <D.26818>;
        <D.26817>:
        D.26819 = &MEM[(void *)"Object" + 1B];
        D.26820 = *D.26819;
        D.26821 = (int) D.26820;
        D.26822 = __s2 + 1;
        D.26823 = *D.26822;
        D.26824 = (int) D.26823;
        __result = D.26821 - D.26824;
        D.26825 = __s2_len > 1;
        D.26815 = __result == 0;
        D.26826 = D.26825 & D.26815;
        if (D.26826 != 0) goto <D.26827>; else goto <D.26828>;
        <D.26827>:
        D.26829 = &MEM[(void *)"Object" + 2B];
        D.26830 = *D.26829;
        D.26831 = (int) D.26830;
        D.26832 = __s2 + 2;
        D.26833 = *D.26832;
        D.26834 = (int) D.26833;
        __result = D.26831 - D.26834;
        D.26835 = __s2_len > 2;
        D.26815 = __result == 0;
        D.26836 = D.26835 & D.26815;
        if (D.26836 != 0) goto <D.26837>; else goto <D.26838>;
        <D.26837>:
        D.26839 = &MEM[(void *)"Object" + 3B];
        D.26840 = *D.26839;
        D.26841 = (int) D.26840;
        D.26842 = __s2 + 3;
        D.26843 = *D.26842;
        D.26844 = (int) D.26843;
        __result = D.26841 - D.26844;
        <D.26838>:
        <D.26828>:
        <D.26818>:
      }
      D.19734 = __result;
    }
    iftmp.97 = -D.19734;
    goto <D.26845>;
    <D.26808>:
    iftmp.97 = __builtin_strcmp (n, "Object");
    <D.26845>:
    D.19735 = iftmp.97;
  }
  if (D.19735 == 0) goto <D.26846>; else goto <D.26847>;
  <D.26846>:
  is_object = is_object + 1;
  <D.26847>:
  D.26848 = values + 4;
  D.26849 = &assembly->sheap;
  D.26850 = string_heap_insert (D.26849, n);
  *D.26848 = D.26850;
  monoeg_g_free (n);
  D.26851 = tb->nspace;
  n = mono_string_to_utf8 (D.26851);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = n;
      D.26855 = "System";
      D.26856 = MEM[(const unsigned char *)D.26855];
      D.26857 = (int) D.26856;
      D.26858 = *__s2;
      D.26859 = (int) D.26858;
      __result = D.26857 - D.26859;
      {
        D.26860 = __s2_len != 0;
        D.26861 = __result == 0;
        D.26862 = D.26860 & D.26861;
        if (D.26862 != 0) goto <D.26863>; else goto <D.26864>;
        <D.26863>:
        D.26865 = &MEM[(void *)"System" + 1B];
        D.26866 = *D.26865;
        D.26867 = (int) D.26866;
        D.26868 = __s2 + 1;
        D.26869 = *D.26868;
        D.26870 = (int) D.26869;
        __result = D.26867 - D.26870;
        D.26871 = __s2_len > 1;
        D.26861 = __result == 0;
        D.26872 = D.26871 & D.26861;
        if (D.26872 != 0) goto <D.26873>; else goto <D.26874>;
        <D.26873>:
        D.26875 = &MEM[(void *)"System" + 2B];
        D.26876 = *D.26875;
        D.26877 = (int) D.26876;
        D.26878 = __s2 + 2;
        D.26879 = *D.26878;
        D.26880 = (int) D.26879;
        __result = D.26877 - D.26880;
        D.26881 = __s2_len > 2;
        D.26861 = __result == 0;
        D.26882 = D.26881 & D.26861;
        if (D.26882 != 0) goto <D.26883>; else goto <D.26884>;
        <D.26883>:
        D.26885 = &MEM[(void *)"System" + 3B];
        D.26886 = *D.26885;
        D.26887 = (int) D.26886;
        D.26888 = __s2 + 3;
        D.26889 = *D.26888;
        D.26890 = (int) D.26889;
        __result = D.26887 - D.26890;
        <D.26884>:
        <D.26874>:
        <D.26864>:
      }
      D.19743 = __result;
    }
    iftmp.98 = -D.19743;
    goto <D.26891>;
    <D.26854>:
    iftmp.98 = __builtin_strcmp (n, "System");
    <D.26891>:
    D.19744 = iftmp.98;
  }
  if (D.19744 == 0) goto <D.26892>; else goto <D.26893>;
  <D.26892>:
  is_system = is_system + 1;
  <D.26893>:
  D.26894 = values + 8;
  D.26849 = &assembly->sheap;
  D.26895 = string_heap_insert (D.26849, n);
  *D.26894 = D.26895;
  monoeg_g_free (n);
  D.26898 = tb->parent;
  if (D.26898 != 0B) goto <D.26899>; else goto <D.26896>;
  <D.26899>:
  D.26900 = is_system == 0;
  D.26901 = is_object == 0;
  D.26902 = D.26900 | D.26901;
  if (D.26902 != 0) goto <D.26903>; else goto <D.26896>;
  <D.26903>:
  D.26804 = tb->attrs;
  D.26904 = D.26804 & 32;
  if (D.26904 == 0) goto <D.26905>; else goto <D.26896>;
  <D.26905>:
  D.26906 = values + 12;
  D.26898 = tb->parent;
  D.26907 = mono_reflection_type_get_handle (D.26898);
  D.26908 = mono_image_typedef_or_ref (assembly, D.26907);
  *D.26906 = D.26908;
  goto <D.26897>;
  <D.26896>:
  D.26906 = values + 12;
  *D.26906 = 0;
  <D.26897>:
  D.26909 = values + 16;
  D.26910 = assembly->tables[4].next_idx;
  *D.26909 = D.26910;
  D.26911 = values + 20;
  D.26912 = assembly->tables[6].next_idx;
  *D.26911 = D.26912;
  D.26804 = tb->attrs;
  D.26915 = D.26804 & 24;
  if (D.26915 != 0) goto <D.26916>; else goto <D.26917>;
  <D.26916>:
  D.26918 = tb->class_size;
  if (D.26918 > 0) goto <D.26913>; else goto <D.26919>;
  <D.26919>:
  D.26920 = tb->packing_size;
  if (D.26920 > 0) goto <D.26913>; else goto <D.26914>;
  <D.26913>:
  table = &assembly->tables[15];
  D.26921 = table->rows;
  D.26922 = D.26921 + 1;
  table->rows = D.26922;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  D.26799 = table->values;
  D.26921 = table->rows;
  D.26923 = D.26921 * 3;
  D.26924 = (long unsigned int) D.26923;
  D.26925 = D.26924 * 4;
  values = D.26799 + D.26925;
  D.26894 = values + 8;
  D.26800 = tb->table_idx;
  *D.26894 = D.26800;
  D.26848 = values + 4;
  D.26918 = tb->class_size;
  D.26926 = (unsigned int) D.26918;
  *D.26848 = D.26926;
  D.26920 = tb->packing_size;
  D.26927 = (unsigned int) D.26920;
  *values = D.26927;
  <D.26914>:
  <D.26917>:
  D.26928 = tb->interfaces;
  if (D.26928 != 0B) goto <D.26929>; else goto <D.26930>;
  <D.26929>:
  table = &assembly->tables[9];
  D.26921 = table->rows;
  i = (int) D.26921;
  D.26928 = tb->interfaces;
  D.26931 = mono_array_length (D.26928);
  D.26921 = table->rows;
  D.26932 = (unsigned int) D.26931;
  D.26933 = D.26921 + D.26932;
  table->rows = D.26933;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  D.26799 = table->values;
  D.26934 = i + 1;
  D.26935 = D.26934 * 2;
  D.26936 = (long unsigned int) D.26935;
  D.26937 = D.26936 * 4;
  values = D.26799 + D.26937;
  i = 0;
  goto <D.19747>;
  <D.19746>:
  {
    struct MonoReflectionType * iface;

    D.26938 = (long unsigned int) i;
    D.26928 = tb->interfaces;
    D.26939 = mono_array_addr_with_size (D.26928, 8, D.26938);
    iface = MEM[(void * *)D.26939];
    D.26800 = tb->table_idx;
    *values = D.26800;
    D.26848 = values + 4;
    D.26940 = mono_reflection_type_get_handle (iface);
    D.26941 = mono_image_typedef_or_ref (assembly, D.26940);
    *D.26848 = D.26941;
    values = values + 8;
  }
  i = i + 1;
  <D.19747>:
  D.26938 = (long unsigned int) i;
  D.26928 = tb->interfaces;
  D.26942 = mono_array_length (D.26928);
  if (D.26938 < D.26942) goto <D.19746>; else goto <D.19748>;
  <D.19748>:
  <D.26930>:
  D.26943 = tb->fields;
  if (D.26943 != 0B) goto <D.26944>; else goto <D.26945>;
  <D.26944>:
  table = &assembly->tables[4];
  D.26921 = table->rows;
  D.26946 = tb->num_fields;
  D.26947 = (unsigned int) D.26946;
  D.26948 = D.26921 + D.26947;
  table->rows = D.26948;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  i = 0;
  goto <D.19750>;
  <D.19749>:
  D.26938 = (long unsigned int) i;
  D.26943 = tb->fields;
  D.26949 = mono_array_addr_with_size (D.26943, 8, D.26938);
  D.26950 = MEM[(struct MonoReflectionFieldBuilder * *)D.26949];
  mono_image_get_field_info (D.26950, assembly);
  i = i + 1;
  <D.19750>:
  D.26946 = tb->num_fields;
  if (D.26946 > i) goto <D.19749>; else goto <D.19751>;
  <D.19751>:
  <D.26945>:
  D.26951 = tb->ctors;
  if (D.26951 != 0B) goto <D.26952>; else goto <D.26953>;
  <D.26952>:
  table = &assembly->tables[6];
  D.26951 = tb->ctors;
  D.26954 = mono_array_length (D.26951);
  D.26921 = table->rows;
  D.26955 = (unsigned int) D.26954;
  D.26956 = D.26921 + D.26955;
  table->rows = D.26956;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  i = 0;
  goto <D.19753>;
  <D.19752>:
  D.26938 = (long unsigned int) i;
  D.26951 = tb->ctors;
  D.26957 = mono_array_addr_with_size (D.26951, 8, D.26938);
  D.26958 = MEM[(struct MonoReflectionCtorBuilder * *)D.26957];
  mono_image_get_ctor_info (domain, D.26958, assembly);
  i = i + 1;
  <D.19753>:
  D.26938 = (long unsigned int) i;
  D.26951 = tb->ctors;
  D.26959 = mono_array_length (D.26951);
  if (D.26938 < D.26959) goto <D.19752>; else goto <D.19754>;
  <D.19754>:
  <D.26953>:
  D.26960 = tb->methods;
  if (D.26960 != 0B) goto <D.26961>; else goto <D.26962>;
  <D.26961>:
  table = &assembly->tables[6];
  D.26921 = table->rows;
  D.26963 = tb->num_methods;
  D.26964 = (unsigned int) D.26963;
  D.26965 = D.26921 + D.26964;
  table->rows = D.26965;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  i = 0;
  goto <D.19756>;
  <D.19755>:
  D.26938 = (long unsigned int) i;
  D.26960 = tb->methods;
  D.26966 = mono_array_addr_with_size (D.26960, 8, D.26938);
  D.26967 = MEM[(struct MonoReflectionMethodBuilder * *)D.26966];
  mono_image_get_method_info (D.26967, assembly);
  i = i + 1;
  <D.19756>:
  D.26963 = tb->num_methods;
  if (D.26963 > i) goto <D.19755>; else goto <D.19757>;
  <D.19757>:
  <D.26962>:
  D.26968 = tb->events;
  if (D.26968 != 0B) goto <D.26969>; else goto <D.26970>;
  <D.26969>:
  D.26968 = tb->events;
  D.26971 = mono_array_length (D.26968);
  if (D.26971 != 0) goto <D.26972>; else goto <D.26973>;
  <D.26972>:
  table = &assembly->tables[20];
  D.26968 = tb->events;
  D.26974 = mono_array_length (D.26968);
  D.26921 = table->rows;
  D.26975 = (unsigned int) D.26974;
  D.26976 = D.26921 + D.26975;
  table->rows = D.26976;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  table = &assembly->tables[18];
  D.26921 = table->rows;
  D.26922 = D.26921 + 1;
  table->rows = D.26922;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  D.26799 = table->values;
  D.26921 = table->rows;
  D.26977 = D.26921 * 2;
  D.26978 = (long unsigned int) D.26977;
  D.26979 = D.26978 * 4;
  values = D.26799 + D.26979;
  D.26800 = tb->table_idx;
  *values = D.26800;
  D.26848 = values + 4;
  D.26980 = assembly->tables[20].next_idx;
  *D.26848 = D.26980;
  i = 0;
  goto <D.19759>;
  <D.19758>:
  D.26938 = (long unsigned int) i;
  D.26968 = tb->events;
  D.26981 = mono_array_addr_with_size (D.26968, 8, D.26938);
  D.26982 = MEM[(struct MonoReflectionEventBuilder * *)D.26981];
  mono_image_get_event_info (D.26982, assembly);
  i = i + 1;
  <D.19759>:
  D.26938 = (long unsigned int) i;
  D.26968 = tb->events;
  D.26983 = mono_array_length (D.26968);
  if (D.26938 < D.26983) goto <D.19758>; else goto <D.19760>;
  <D.19760>:
  <D.26973>:
  <D.26970>:
  D.26984 = tb->properties;
  if (D.26984 != 0B) goto <D.26985>; else goto <D.26986>;
  <D.26985>:
  D.26984 = tb->properties;
  D.26987 = mono_array_length (D.26984);
  if (D.26987 != 0) goto <D.26988>; else goto <D.26989>;
  <D.26988>:
  table = &assembly->tables[23];
  D.26984 = tb->properties;
  D.26990 = mono_array_length (D.26984);
  D.26921 = table->rows;
  D.26991 = (unsigned int) D.26990;
  D.26992 = D.26921 + D.26991;
  table->rows = D.26992;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  table = &assembly->tables[21];
  D.26921 = table->rows;
  D.26922 = D.26921 + 1;
  table->rows = D.26922;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  D.26799 = table->values;
  D.26921 = table->rows;
  D.26977 = D.26921 * 2;
  D.26978 = (long unsigned int) D.26977;
  D.26979 = D.26978 * 4;
  values = D.26799 + D.26979;
  D.26800 = tb->table_idx;
  *values = D.26800;
  D.26848 = values + 4;
  D.26993 = assembly->tables[23].next_idx;
  *D.26848 = D.26993;
  i = 0;
  goto <D.19762>;
  <D.19761>:
  D.26938 = (long unsigned int) i;
  D.26984 = tb->properties;
  D.26994 = mono_array_addr_with_size (D.26984, 8, D.26938);
  D.26995 = MEM[(struct MonoReflectionPropertyBuilder * *)D.26994];
  mono_image_get_property_info (D.26995, assembly);
  i = i + 1;
  <D.19762>:
  D.26938 = (long unsigned int) i;
  D.26984 = tb->properties;
  D.26996 = mono_array_length (D.26984);
  if (D.26938 < D.26996) goto <D.19761>; else goto <D.19763>;
  <D.19763>:
  <D.26989>:
  <D.26986>:
  D.26997 = tb->generic_params;
  if (D.26997 != 0B) goto <D.26998>; else goto <D.26999>;
  <D.26998>:
  table = &assembly->tables[42];
  D.26997 = tb->generic_params;
  D.27000 = mono_array_length (D.26997);
  D.26921 = table->rows;
  D.27001 = (unsigned int) D.27000;
  D.27002 = D.26921 + D.27001;
  table->rows = D.27002;
  D.26921 = table->rows;
  alloc_table (table, D.26921);
  i = 0;
  goto <D.19766>;
  <D.19765>:
  {
    guint32 owner;

    D.26800 = tb->table_idx;
    owner = D.26800 << 1;
    D.26938 = (long unsigned int) i;
    D.26997 = tb->generic_params;
    D.27003 = mono_array_addr_with_size (D.26997, 8, D.26938);
    D.27004 = MEM[(struct MonoReflectionGenericParam * *)D.27003];
    mono_image_get_generic_param_info (D.27004, owner, assembly);
  }
  i = i + 1;
  <D.19766>:
  D.26938 = (long unsigned int) i;
  D.26997 = tb->generic_params;
  D.27005 = mono_array_length (D.26997);
  if (D.26938 < D.27005) goto <D.19765>; else goto <D.19767>;
  <D.19767>:
  <D.26999>:
  D.27006 = tb->permissions;
  D.26800 = tb->table_idx;
  D.27007 = D.26800 | 33554432;
  mono_image_add_decl_security (assembly, D.27007, D.27006);
  D.27008 = tb->subtypes;
  if (D.27008 != 0B) goto <D.27009>; else goto <D.27010>;
  <D.27009>:
  {
    struct MonoDynamicTable * ntable;

    ntable = &assembly->tables[41];
    D.27008 = tb->subtypes;
    D.27011 = mono_array_length (D.27008);
    D.27012 = ntable->rows;
    D.27013 = (unsigned int) D.27011;
    D.27014 = D.27012 + D.27013;
    ntable->rows = D.27014;
    D.27012 = ntable->rows;
    alloc_table (ntable, D.27012);
    D.27015 = ntable->values;
    D.27016 = ntable->next_idx;
    D.27017 = D.27016 * 2;
    D.27018 = (long unsigned int) D.27017;
    D.27019 = D.27018 * 4;
    values = D.27015 + D.27019;
    i = 0;
    goto <D.19771>;
    <D.19770>:
    {
      struct MonoReflectionTypeBuilder * subtype;

      D.26938 = (long unsigned int) i;
      D.27008 = tb->subtypes;
      D.27020 = mono_array_addr_with_size (D.27008, 8, D.26938);
      subtype = MEM[(struct MonoReflectionTypeBuilder * *)D.27020];
      D.27021 = subtype->table_idx;
      *values = D.27021;
      D.26848 = values + 4;
      D.26800 = tb->table_idx;
      *D.26848 = D.26800;
      values = values + 8;
      D.27016 = ntable->next_idx;
      D.27022 = D.27016 + 1;
      ntable->next_idx = D.27022;
    }
    i = i + 1;
    <D.19771>:
    D.26938 = (long unsigned int) i;
    D.27008 = tb->subtypes;
    D.27023 = mono_array_length (D.27008);
    if (D.26938 < D.27023) goto <D.19770>; else goto <D.19772>;
    <D.19772>:
  }
  <D.27010>:
}


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

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


reflection_methodbuilder_from_ctor_builder (struct ReflectionMethodBuilder * rmb, struct MonoReflectionCtorBuilder * mb)
{
  const char * iftmp.99;
  unsigned int D.27027;
  unsigned int D.27028;
  struct MonoReflectionILGen * D.27032;
  struct MonoClass * D.27033;
  struct MonoType * D.27034;
  struct MonoDomain * D.27035;
  struct MonoReflectionType * D.27036;
  struct MonoArray * D.27037;
  struct MonoArray * D.27038;
  unsigned int D.27039;
  unsigned int D.27040;
  struct MonoObject * D.27041;
  struct MonoDomain * D.27042;
  struct MonoString * D.27043;
  guint32 * D.27044;
  unsigned char D.27045;
  struct MonoArray * D.27046;
  struct MonoArray * D.27047;
  struct MonoArray * D.27048;
  struct MonoMethod * D.27049;
  const char * name;

  D.27027 = mb->attrs;
  D.27028 = D.27027 & 16;
  if (D.27028 != 0) goto <D.27029>; else goto <D.27030>;
  <D.27029>:
  iftmp.99 = ".cctor";
  goto <D.27031>;
  <D.27030>:
  iftmp.99 = ".ctor";
  <D.27031>:
  name = iftmp.99;
  memset (rmb, 0, 208);
  D.27032 = mb->ilgen;
  rmb->ilgen = D.27032;
  D.27033 = mono_defaults.void_class;
  D.27034 = &D.27033->byval_arg;
  D.27035 = mono_domain_get ();
  D.27036 = mono_type_get_object (D.27035, D.27034);
  rmb->rtype = D.27036;
  D.27037 = mb->parameters;
  rmb->parameters = D.27037;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  D.27038 = mb->pinfo;
  rmb->pinfo = D.27038;
  D.27027 = mb->attrs;
  rmb->attrs = D.27027;
  D.27039 = mb->iattrs;
  rmb->iattrs = D.27039;
  D.27040 = mb->call_conv;
  rmb->call_conv = D.27040;
  rmb->code = 0B;
  D.27041 = mb->type;
  rmb->type = D.27041;
  D.27042 = mono_domain_get ();
  D.27043 = mono_string_new (D.27042, name);
  rmb->name = D.27043;
  D.27044 = &mb->table_idx;
  rmb->table_idx = D.27044;
  D.27045 = mb->init_locals;
  rmb->init_locals = D.27045;
  rmb->skip_visibility = 0;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  D.27046 = mb->param_modreq;
  rmb->param_modreq = D.27046;
  D.27047 = mb->param_modopt;
  rmb->param_modopt = D.27047;
  D.27048 = mb->permissions;
  rmb->permissions = D.27048;
  D.27049 = mb->mhandle;
  rmb->mhandle = D.27049;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


mono_image_get_event_info (struct MonoReflectionEventBuilder * eb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27050;
  unsigned int D.27051;
  unsigned int D.27052;
  guint32 * D.27053;
  unsigned int D.27054;
  unsigned int D.27055;
  long unsigned int D.27056;
  long unsigned int D.27057;
  guint32 * D.27058;
  struct MonoString * D.27059;
  struct MonoDynamicStream * D.27060;
  unsigned int D.27061;
  unsigned int D.27062;
  guint32 * D.27063;
  struct MonoReflectionType * D.27064;
  struct MonoType * D.27065;
  unsigned int D.27066;
  struct MonoReflectionMethodBuilder * D.27067;
  struct MonoReflectionMethodBuilder * D.27070;
  struct MonoReflectionMethodBuilder * D.27073;
  unsigned int D.27076;
  unsigned int D.27077;
  unsigned int semaidx.100;
  unsigned int D.27081;
  unsigned int D.27082;
  long unsigned int D.27083;
  long unsigned int D.27084;
  unsigned int D.27085;
  unsigned int D.27086;
  unsigned int semaidx.101;
  unsigned int D.27090;
  unsigned int D.27091;
  unsigned int semaidx.102;
  unsigned int D.27095;
  unsigned int D.27096;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[20];
  D.27050 = table->next_idx;
  D.27051 = D.27050;
  D.27052 = D.27051 + 1;
  table->next_idx = D.27052;
  eb->table_idx = D.27051;
  D.27053 = table->values;
  D.27054 = eb->table_idx;
  D.27055 = D.27054 * 3;
  D.27056 = (long unsigned int) D.27055;
  D.27057 = D.27056 * 4;
  values = D.27053 + D.27057;
  D.27058 = values + 4;
  D.27059 = eb->name;
  D.27060 = &assembly->sheap;
  D.27061 = string_heap_insert_mstring (D.27060, D.27059);
  *D.27058 = D.27061;
  D.27062 = eb->attrs;
  *values = D.27062;
  D.27063 = values + 8;
  D.27064 = eb->type;
  D.27065 = mono_reflection_type_get_handle (D.27064);
  D.27066 = mono_image_typedef_or_ref (assembly, D.27065);
  *D.27063 = D.27066;
  D.27067 = eb->add_method;
  if (D.27067 != 0B) goto <D.27068>; else goto <D.27069>;
  <D.27068>:
  num_methods = num_methods + 1;
  <D.27069>:
  D.27070 = eb->remove_method;
  if (D.27070 != 0B) goto <D.27071>; else goto <D.27072>;
  <D.27071>:
  num_methods = num_methods + 1;
  <D.27072>:
  D.27073 = eb->raise_method;
  if (D.27073 != 0B) goto <D.27074>; else goto <D.27075>;
  <D.27074>:
  num_methods = num_methods + 1;
  <D.27075>:
  table = &assembly->tables[24];
  D.27076 = table->rows;
  D.27077 = D.27076 + num_methods;
  table->rows = D.27077;
  D.27076 = table->rows;
  alloc_table (table, D.27076);
  D.27067 = eb->add_method;
  if (D.27067 != 0B) goto <D.27078>; else goto <D.27079>;
  <D.27078>:
  D.27050 = table->next_idx;
  semaidx.100 = D.27050;
  D.27081 = semaidx.100 + 1;
  table->next_idx = D.27081;
  semaidx = semaidx.100;
  D.27053 = table->values;
  D.27082 = semaidx * 3;
  D.27083 = (long unsigned int) D.27082;
  D.27084 = D.27083 * 4;
  values = D.27053 + D.27084;
  *values = 8;
  D.27058 = values + 4;
  D.27067 = eb->add_method;
  D.27085 = D.27067->table_idx;
  *D.27058 = D.27085;
  D.27063 = values + 8;
  D.27054 = eb->table_idx;
  D.27086 = D.27054 << 1;
  *D.27063 = D.27086;
  <D.27079>:
  D.27070 = eb->remove_method;
  if (D.27070 != 0B) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  D.27050 = table->next_idx;
  semaidx.101 = D.27050;
  D.27090 = semaidx.101 + 1;
  table->next_idx = D.27090;
  semaidx = semaidx.101;
  D.27053 = table->values;
  D.27082 = semaidx * 3;
  D.27083 = (long unsigned int) D.27082;
  D.27084 = D.27083 * 4;
  values = D.27053 + D.27084;
  *values = 16;
  D.27058 = values + 4;
  D.27070 = eb->remove_method;
  D.27091 = D.27070->table_idx;
  *D.27058 = D.27091;
  D.27063 = values + 8;
  D.27054 = eb->table_idx;
  D.27086 = D.27054 << 1;
  *D.27063 = D.27086;
  <D.27088>:
  D.27073 = eb->raise_method;
  if (D.27073 != 0B) goto <D.27092>; else goto <D.27093>;
  <D.27092>:
  D.27050 = table->next_idx;
  semaidx.102 = D.27050;
  D.27095 = semaidx.102 + 1;
  table->next_idx = D.27095;
  semaidx = semaidx.102;
  D.27053 = table->values;
  D.27082 = semaidx * 3;
  D.27083 = (long unsigned int) D.27082;
  D.27084 = D.27083 * 4;
  values = D.27053 + D.27084;
  *values = 32;
  D.27058 = values + 4;
  D.27073 = eb->raise_method;
  D.27096 = D.27073->table_idx;
  *D.27058 = D.27096;
  D.27063 = values + 8;
  D.27054 = eb->table_idx;
  D.27086 = D.27054 << 1;
  *D.27063 = D.27086;
  <D.27093>:
}


mono_image_get_property_info (struct MonoReflectionPropertyBuilder * pb, struct MonoDynamicImage * assembly)
{
  unsigned int D.27097;
  unsigned int D.27098;
  unsigned int D.27099;
  int D.27100;
  guint32 * D.27101;
  int D.27102;
  int D.27103;
  long unsigned int D.27104;
  long unsigned int D.27105;
  guint32 * D.27106;
  struct MonoString * D.27107;
  struct MonoDynamicStream * D.27108;
  unsigned int D.27109;
  unsigned int D.27110;
  guint32 * D.27111;
  unsigned int D.27112;
  struct MonoReflectionMethodBuilder * D.27113;
  struct MonoReflectionMethodBuilder * D.27116;
  unsigned int D.27119;
  unsigned int D.27120;
  unsigned int semaidx.103;
  unsigned int D.27124;
  unsigned int D.27125;
  long unsigned int D.27126;
  long unsigned int D.27127;
  unsigned int D.27128;
  int D.27129;
  int D.27130;
  unsigned int D.27131;
  unsigned int semaidx.104;
  unsigned int D.27135;
  unsigned int D.27136;
  unsigned int D.27137;
  unsigned int D.27140;
  unsigned int D.27141;
  long unsigned int D.27142;
  long unsigned int D.27143;
  int D.27144;
  int D.27145;
  unsigned int D.27146;
  guint32 * D.27147;
  struct MonoObject * D.27148;
  unsigned int D.27149;
  unsigned int field_type.105;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint num_methods;
  guint32 semaidx;

  num_methods = 0;
  table = &assembly->tables[23];
  D.27097 = table->next_idx;
  D.27098 = D.27097;
  D.27099 = D.27098 + 1;
  table->next_idx = D.27099;
  D.27100 = (int) D.27098;
  pb->table_idx = D.27100;
  D.27101 = table->values;
  D.27102 = pb->table_idx;
  D.27103 = D.27102 * 3;
  D.27104 = (long unsigned int) D.27103;
  D.27105 = D.27104 * 4;
  values = D.27101 + D.27105;
  D.27106 = values + 4;
  D.27107 = pb->name;
  D.27108 = &assembly->sheap;
  D.27109 = string_heap_insert_mstring (D.27108, D.27107);
  *D.27106 = D.27109;
  D.27110 = pb->attrs;
  *values = D.27110;
  D.27111 = values + 8;
  D.27112 = property_encode_signature (assembly, pb);
  *D.27111 = D.27112;
  D.27113 = pb->get_method;
  if (D.27113 != 0B) goto <D.27114>; else goto <D.27115>;
  <D.27114>:
  num_methods = num_methods + 1;
  <D.27115>:
  D.27116 = pb->set_method;
  if (D.27116 != 0B) goto <D.27117>; else goto <D.27118>;
  <D.27117>:
  num_methods = num_methods + 1;
  <D.27118>:
  table = &assembly->tables[24];
  D.27119 = table->rows;
  D.27120 = D.27119 + num_methods;
  table->rows = D.27120;
  D.27119 = table->rows;
  alloc_table (table, D.27119);
  D.27113 = pb->get_method;
  if (D.27113 != 0B) goto <D.27121>; else goto <D.27122>;
  <D.27121>:
  D.27097 = table->next_idx;
  semaidx.103 = D.27097;
  D.27124 = semaidx.103 + 1;
  table->next_idx = D.27124;
  semaidx = semaidx.103;
  D.27101 = table->values;
  D.27125 = semaidx * 3;
  D.27126 = (long unsigned int) D.27125;
  D.27127 = D.27126 * 4;
  values = D.27101 + D.27127;
  *values = 2;
  D.27106 = values + 4;
  D.27113 = pb->get_method;
  D.27128 = D.27113->table_idx;
  *D.27106 = D.27128;
  D.27111 = values + 8;
  D.27102 = pb->table_idx;
  D.27129 = D.27102 << 1;
  D.27130 = D.27129 | 1;
  D.27131 = (unsigned int) D.27130;
  *D.27111 = D.27131;
  <D.27122>:
  D.27116 = pb->set_method;
  if (D.27116 != 0B) goto <D.27132>; else goto <D.27133>;
  <D.27132>:
  D.27097 = table->next_idx;
  semaidx.104 = D.27097;
  D.27135 = semaidx.104 + 1;
  table->next_idx = D.27135;
  semaidx = semaidx.104;
  D.27101 = table->values;
  D.27125 = semaidx * 3;
  D.27126 = (long unsigned int) D.27125;
  D.27127 = D.27126 * 4;
  values = D.27101 + D.27127;
  *values = 1;
  D.27106 = values + 4;
  D.27116 = pb->set_method;
  D.27136 = D.27116->table_idx;
  *D.27106 = D.27136;
  D.27111 = values + 8;
  D.27102 = pb->table_idx;
  D.27129 = D.27102 << 1;
  D.27130 = D.27129 | 1;
  D.27131 = (unsigned int) D.27130;
  *D.27111 = D.27131;
  <D.27133>:
  D.27110 = pb->attrs;
  D.27137 = D.27110 & 4096;
  if (D.27137 != 0) goto <D.27138>; else goto <D.27139>;
  <D.27138>:
  {
    guint32 field_type;

    try
      {
        field_type = 0;
        table = &assembly->tables[11];
        D.27119 = table->rows;
        D.27140 = D.27119 + 1;
        table->rows = D.27140;
        D.27119 = table->rows;
        alloc_table (table, D.27119);
        D.27101 = table->values;
        D.27119 = table->rows;
        D.27141 = D.27119 * 4;
        D.27142 = (long unsigned int) D.27141;
        D.27143 = D.27142 * 4;
        values = D.27101 + D.27143;
        D.27111 = values + 8;
        D.27102 = pb->table_idx;
        D.27144 = D.27102 << 2;
        D.27145 = D.27144 | 2;
        D.27146 = (unsigned int) D.27145;
        *D.27111 = D.27146;
        D.27147 = values + 12;
        D.27148 = pb->def_value;
        D.27149 = encode_constant (assembly, D.27148, &field_type);
        *D.27147 = D.27149;
        field_type.105 = field_type;
        *values = field_type.105;
        D.27106 = values + 4;
        *D.27106 = 0;
      }
    finally
      {
        field_type = {CLOBBER};
      }
  }
  <D.27139>:
}


property_encode_signature (struct MonoDynamicImage * assembly, struct MonoReflectionPropertyBuilder * fb)
{
  struct MonoArray * D.27153;
  long unsigned int D.27156;
  _Bool D.27157;
  _Bool D.27158;
  _Bool D.27159;
  struct MonoArray * D.27162;
  long unsigned int D.27165;
  unsigned int D.27166;
  unsigned int D.27167;
  unsigned int D.27168;
  struct MonoObject * D.27174;
  long unsigned int D.27175;
  char * D.27176;
  long unsigned int D.27182;
  char * D.27183;
  struct MonoReflectionType * D.27184;
  char * D.27185;
  struct MonoObject * D.27186;
  guint32 D.27187;
  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.27151>; else goto <D.27152>;
      <D.27151>:
      D.27153 = mb->parameters;
      if (D.27153 != 0B) goto <D.27154>; else goto <D.27155>;
      <D.27154>:
      D.27153 = mb->parameters;
      D.27156 = mono_array_length (D.27153);
      nparams = (guint32) D.27156;
      <D.27155>:
      <D.27152>:
      D.27157 = mb == 0B;
      D.27158 = smb != 0B;
      D.27159 = D.27157 & D.27158;
      if (D.27159 != 0) goto <D.27160>; else goto <D.27161>;
      <D.27160>:
      D.27162 = smb->parameters;
      if (D.27162 != 0B) goto <D.27163>; else goto <D.27164>;
      <D.27163>:
      D.27162 = smb->parameters;
      D.27165 = mono_array_length (D.27162);
      D.27166 = (unsigned int) D.27165;
      nparams = D.27166 + 4294967295;
      <D.27164>:
      <D.27161>:
      sigbuffer_init (&buf, 32);
      D.27167 = fb->call_conv;
      D.27168 = D.27167 & 32;
      if (D.27168 != 0) goto <D.27169>; else goto <D.27170>;
      <D.27169>:
      sigbuffer_add_byte (&buf, 40);
      goto <D.27171>;
      <D.27170>:
      sigbuffer_add_byte (&buf, 8);
      <D.27171>:
      sigbuffer_add_value (&buf, nparams);
      if (mb != 0B) goto <D.27172>; else goto <D.27173>;
      <D.27172>:
      D.27174 = mb->rtype;
      encode_reflection_type (assembly, D.27174, &buf);
      i = 0;
      goto <D.19284>;
      <D.19283>:
      {
        struct MonoReflectionType * pt;

        D.27175 = (long unsigned int) i;
        D.27153 = mb->parameters;
        D.27176 = mono_array_addr_with_size (D.27153, 8, D.27175);
        pt = MEM[(struct MonoReflectionType * *)D.27176];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19284>:
      if (i < nparams) goto <D.19283>; else goto <D.19285>;
      <D.19285>:
      goto <D.27177>;
      <D.27173>:
      if (smb != 0B) goto <D.27180>; else goto <D.27178>;
      <D.27180>:
      D.27162 = smb->parameters;
      if (D.27162 != 0B) goto <D.27181>; else goto <D.27178>;
      <D.27181>:
      D.27182 = (long unsigned int) nparams;
      D.27162 = smb->parameters;
      D.27183 = mono_array_addr_with_size (D.27162, 8, D.27182);
      D.27184 = MEM[(struct MonoReflectionType * *)D.27183];
      encode_reflection_type (assembly, D.27184, &buf);
      i = 0;
      goto <D.19288>;
      <D.19287>:
      {
        struct MonoReflectionType * pt;

        D.27175 = (long unsigned int) i;
        D.27162 = smb->parameters;
        D.27185 = mono_array_addr_with_size (D.27162, 8, D.27175);
        pt = MEM[(struct MonoReflectionType * *)D.27185];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19288>:
      if (i < nparams) goto <D.19287>; else goto <D.19289>;
      <D.19289>:
      goto <D.27179>;
      <D.27178>:
      D.27186 = fb->type;
      encode_reflection_type (assembly, D.27186, &buf);
      <D.27179>:
      <D.27177>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27187 = idx;
      return D.27187;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_cattrs (struct MonoDynamicImage * assembly, guint32 idx, guint32 type, struct MonoArray * cattrs)
{
  long unsigned int D.27192;
  unsigned int D.27193;
  unsigned int D.27194;
  guint32 * D.27195;
  unsigned int D.27196;
  unsigned int D.27197;
  long unsigned int D.27198;
  long unsigned int D.27199;
  long unsigned int D.27200;
  char * D.27201;
  struct MonoReflectionMethod * D.27202;
  unsigned int D.27203;
  long unsigned int D.27204;
  void * D.27205;
  struct MonoGHashTable * D.27206;
  guint32 * D.27207;
  char * p.106;
  struct MonoArray * D.27209;
  long unsigned int D.27210;
  unsigned int D.27211;
  guint32 * D.27212;
  long unsigned int D.27213;
  int D.27214;
  char * D.27215;
  long int p.107;
  long int blob_size.108;
  long int D.27218;
  int D.27219;
  unsigned int D.27220;
  unsigned int D.27221;
  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.27190>; else goto <D.27191>;
      <D.27190>:
      return;
      <D.27191>:
      D.27192 = mono_array_length (cattrs);
      count = (guint32) D.27192;
      table = &assembly->tables[12];
      D.27193 = table->rows;
      D.27194 = D.27193 + count;
      table->rows = D.27194;
      D.27193 = table->rows;
      alloc_table (table, D.27193);
      D.27195 = table->values;
      D.27196 = table->next_idx;
      D.27197 = D.27196 * 3;
      D.27198 = (long unsigned int) D.27197;
      D.27199 = D.27198 * 4;
      values = D.27195 + D.27199;
      idx = idx << 5;
      idx = idx | type;
      i = 0;
      goto <D.19073>;
      <D.19072>:
      D.27200 = (long unsigned int) i;
      D.27201 = mono_array_addr_with_size (cattrs, 8, D.27200);
      cattr = MEM[(void * *)D.27201];
      *values = idx;
      D.27202 = cattr->ctor;
      token = mono_image_create_token (assembly, D.27202, 0, 0);
      type = token & 16777215;
      type = type << 3;
      D.27203 = token >> 24;
      switch (D.27203) <default: <D.19070>, case 6: <D.19067>, case 10: <D.19069>>
      <D.19067>:
      type = type | 2;
      D.27202 = cattr->ctor;
      D.27204 = (long unsigned int) token;
      D.27205 = (void *) D.27204;
      D.27206 = assembly->remapped_tokens;
      mono_g_hash_table_insert (D.27206, D.27205, D.27202);
      goto <D.19068>;
      <D.19069>:
      type = type | 3;
      goto <D.19068>;
      <D.19070>:
      monoeg_g_log (0B, 16, "got wrong token in custom attr");
      // predicted unlikely by continue predictor.
      goto <D.19071>;
      <D.19068>:
      D.27207 = values + 4;
      *D.27207 = type;
      p = &blob_size;
      p.106 = p;
      D.27209 = cattr->data;
      D.27210 = mono_array_length (D.27209);
      D.27211 = (unsigned int) D.27210;
      mono_metadata_encode_value (D.27211, p.106, &p);
      D.27212 = values + 8;
      D.27209 = cattr->data;
      D.27213 = mono_array_length (D.27209);
      D.27214 = (int) D.27213;
      D.27209 = cattr->data;
      D.27215 = mono_array_addr_with_size (D.27209, 1, 0);
      p.106 = p;
      p.107 = (long int) p.106;
      blob_size.108 = (long int) &blob_size;
      D.27218 = p.107 - blob_size.108;
      D.27219 = (int) D.27218;
      D.27220 = add_to_blob_cached (assembly, &blob_size, D.27219, D.27215, D.27214);
      *D.27212 = D.27220;
      values = values + 12;
      D.27196 = table->next_idx;
      D.27221 = D.27196 + 1;
      table->next_idx = D.27221;
      <D.19071>:
      i = i + 1;
      <D.19073>:
      if (i < count) goto <D.19072>; else goto <D.19074>;
      <D.19074>:
    }
  finally
    {
      blob_size = {CLOBBER};
      p = {CLOBBER};
    }
}


mono_image_add_decl_security (struct MonoDynamicImage * assembly, guint32 parent_token, struct MonoArray * permissions)
{
  long unsigned int D.27227;
  unsigned int D.27228;
  unsigned int D.27229;
  long unsigned int D.27230;
  guint32 * D.27231;
  unsigned int D.27232;
  unsigned int D.27233;
  long unsigned int D.27234;
  long unsigned int D.27235;
  unsigned int D.27236;
  unsigned int D.27237;
  guint32 * D.27238;
  guint32 * D.27239;
  struct MonoString * D.27240;
  unsigned int D.27241;
  unsigned int D.27242;
  long unsigned int D.27243;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 count;
  guint32 i;
  guint32 idx;
  struct MonoReflectionPermissionSet * perm;

  if (permissions == 0B) goto <D.27225>; else goto <D.27226>;
  <D.27225>:
  return;
  <D.27226>:
  D.27227 = mono_array_length (permissions);
  count = (guint32) D.27227;
  table = &assembly->tables[14];
  D.27228 = table->rows;
  D.27229 = D.27228 + count;
  table->rows = D.27229;
  D.27228 = table->rows;
  alloc_table (table, D.27228);
  i = 0;
  goto <D.19092>;
  <D.19091>:
  D.27230 = (long unsigned int) i;
  perm = mono_array_addr_with_size (permissions, 16, D.27230);
  D.27231 = table->values;
  D.27232 = table->next_idx;
  D.27233 = D.27232 * 3;
  D.27234 = (long unsigned int) D.27233;
  D.27235 = D.27234 * 4;
  values = D.27231 + D.27235;
  idx = parent_token & 16777215;
  idx = idx << 2;
  D.27236 = parent_token >> 24;
  switch (D.27236) <default: <D.19090>, case 2: <D.19086>, case 6: <D.19088>, case 32: <D.19089>>
  <D.19086>:
  idx = idx;
  goto <D.19087>;
  <D.19088>:
  idx = idx | 1;
  goto <D.19087>;
  <D.19089>:
  idx = idx | 2;
  goto <D.19087>;
  <D.19090>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1363);
  <D.19087>:
  D.27237 = perm->action;
  *values = D.27237;
  D.27238 = values + 4;
  *D.27238 = idx;
  D.27239 = values + 8;
  D.27240 = perm->pset;
  D.27241 = add_mono_string_to_blob_cached (assembly, D.27240);
  *D.27239 = D.27241;
  D.27232 = table->next_idx;
  D.27242 = D.27232 + 1;
  table->next_idx = D.27242;
  i = i + 1;
  <D.19092>:
  D.27230 = (long unsigned int) i;
  D.27243 = mono_array_length (permissions);
  if (D.27230 < D.27243) goto <D.19091>; else goto <D.19093>;
  <D.19093>:
}


add_mono_string_to_blob_cached (struct MonoDynamicImage * assembly, struct MonoString * str)
{
  int D.27245;
  int D.27246;
  char * b.109;
  int len.110;
  mono_unichar2 * D.27249;
  long int b.111;
  long int blob_size.112;
  long int D.27252;
  int D.27253;
  guint32 D.27254;
  char blob_size[64];
  char * b;
  guint32 idx;
  guint32 len;

  try
    {
      b = &blob_size;
      idx = 0;
      D.27245 = str->length;
      D.27246 = D.27245 * 2;
      len = (guint32) D.27246;
      b.109 = b;
      mono_metadata_encode_value (len, b.109, &b);
      len.110 = (int) len;
      D.27249 = mono_string_chars (str);
      b.109 = b;
      b.111 = (long int) b.109;
      blob_size.112 = (long int) &blob_size;
      D.27252 = b.111 - blob_size.112;
      D.27253 = (int) D.27252;
      idx = add_to_blob_cached (assembly, &blob_size, D.27253, D.27249, len.110);
      D.27254 = idx;
      return D.27254;
    }
  finally
    {
      blob_size = {CLOBBER};
      b = {CLOBBER};
    }
}


module_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoArray * D.27257;
  unsigned int D.27258;
  struct MonoArray * D.27259;
  long unsigned int D.27262;
  char * D.27263;
  struct MonoArray * D.27264;
  unsigned int D.27265;
  struct MonoArray * D.27266;
  long unsigned int D.27267;
  struct MonoArray * D.27268;
  char * D.27271;
  struct MonoArray * D.27272;
  int D.27273;
  unsigned int D.27274;
  long unsigned int D.27275;
  struct MonoArray * D.27276;
  char * D.27279;
  struct MonoReflectionTypeBuilder * D.27280;
  int D.27281;
  int i;

  D.27257 = moduleb->cattrs;
  D.27258 = moduleb->table_idx;
  mono_image_add_cattrs (assembly, D.27258, 7, D.27257);
  D.27259 = moduleb->global_methods;
  if (D.27259 != 0B) goto <D.27260>; else goto <D.27261>;
  <D.27260>:
  i = 0;
  goto <D.19832>;
  <D.19831>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.27262 = (long unsigned int) i;
    D.27259 = moduleb->global_methods;
    D.27263 = mono_array_addr_with_size (D.27259, 8, D.27262);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.27263];
    D.27264 = mb->cattrs;
    D.27265 = mb->table_idx;
    mono_image_add_cattrs (assembly, D.27265, 0, D.27264);
    D.27266 = mb->pinfo;
    params_add_cattrs (assembly, D.27266);
  }
  i = i + 1;
  <D.19832>:
  D.27262 = (long unsigned int) i;
  D.27259 = moduleb->global_methods;
  D.27267 = mono_array_length (D.27259);
  if (D.27262 < D.27267) goto <D.19831>; else goto <D.19833>;
  <D.19833>:
  <D.27261>:
  D.27268 = moduleb->global_fields;
  if (D.27268 != 0B) goto <D.27269>; else goto <D.27270>;
  <D.27269>:
  i = 0;
  goto <D.19836>;
  <D.19835>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.27262 = (long unsigned int) i;
    D.27268 = moduleb->global_fields;
    D.27271 = mono_array_addr_with_size (D.27268, 8, D.27262);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.27271];
    D.27272 = fb->cattrs;
    D.27273 = fb->table_idx;
    D.27274 = (unsigned int) D.27273;
    mono_image_add_cattrs (assembly, D.27274, 1, D.27272);
  }
  i = i + 1;
  <D.19836>:
  D.27262 = (long unsigned int) i;
  D.27268 = moduleb->global_fields;
  D.27275 = mono_array_length (D.27268);
  if (D.27262 < D.27275) goto <D.19835>; else goto <D.19837>;
  <D.19837>:
  <D.27270>:
  D.27276 = moduleb->types;
  if (D.27276 != 0B) goto <D.27277>; else goto <D.27278>;
  <D.27277>:
  i = 0;
  goto <D.19839>;
  <D.19838>:
  D.27262 = (long unsigned int) i;
  D.27276 = moduleb->types;
  D.27279 = mono_array_addr_with_size (D.27276, 8, D.27262);
  D.27280 = MEM[(struct MonoReflectionTypeBuilder * *)D.27279];
  type_add_cattrs (assembly, D.27280);
  i = i + 1;
  <D.19839>:
  D.27281 = moduleb->num_types;
  if (D.27281 > i) goto <D.19838>; else goto <D.19840>;
  <D.19840>:
  <D.27278>:
}


params_add_cattrs (struct MonoDynamicImage * assembly, struct MonoArray * pinfo)
{
  long unsigned int D.27284;
  char * D.27285;
  struct MonoArray * D.27288;
  unsigned int D.27289;
  long unsigned int D.27290;
  int i;

  if (pinfo == 0B) goto <D.27282>; else goto <D.27283>;
  <D.27282>:
  return;
  <D.27283>:
  i = 0;
  goto <D.19795>;
  <D.19794>:
  {
    struct MonoReflectionParamBuilder * pb;

    D.27284 = (long unsigned int) i;
    D.27285 = mono_array_addr_with_size (pinfo, 8, D.27284);
    pb = MEM[(struct MonoReflectionParamBuilder * *)D.27285];
    if (pb == 0B) goto <D.27286>; else goto <D.27287>;
    <D.27286>:
    // predicted unlikely by continue predictor.
    goto <D.19793>;
    <D.27287>:
    D.27288 = pb->cattrs;
    D.27289 = pb->table_idx;
    mono_image_add_cattrs (assembly, D.27289, 4, D.27288);
  }
  <D.19793>:
  i = i + 1;
  <D.19795>:
  D.27284 = (long unsigned int) i;
  D.27290 = mono_array_length (pinfo);
  if (D.27284 < D.27290) goto <D.19794>; else goto <D.19796>;
  <D.19796>:
}


type_add_cattrs (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct MonoArray * D.27292;
  unsigned int D.27293;
  struct MonoArray * D.27294;
  long unsigned int D.27297;
  char * D.27298;
  struct MonoArray * D.27299;
  int D.27300;
  unsigned int D.27301;
  int D.27302;
  struct MonoArray * D.27303;
  char * D.27306;
  struct MonoArray * D.27307;
  unsigned int D.27308;
  long unsigned int D.27309;
  struct MonoArray * D.27310;
  char * D.27313;
  struct MonoArray * D.27314;
  int D.27315;
  unsigned int D.27316;
  long unsigned int D.27317;
  struct MonoArray * D.27318;
  char * D.27321;
  struct MonoArray * D.27322;
  unsigned int D.27323;
  struct MonoArray * D.27324;
  long unsigned int D.27325;
  struct MonoArray * D.27326;
  char * D.27329;
  struct MonoArray * D.27330;
  unsigned int D.27331;
  struct MonoArray * D.27332;
  int D.27333;
  struct MonoArray * D.27334;
  char * D.27337;
  struct MonoReflectionTypeBuilder * D.27338;
  long unsigned int D.27339;
  int i;

  D.27292 = tb->cattrs;
  D.27293 = tb->table_idx;
  mono_image_add_cattrs (assembly, D.27293, 3, D.27292);
  D.27294 = tb->fields;
  if (D.27294 != 0B) goto <D.27295>; else goto <D.27296>;
  <D.27295>:
  i = 0;
  goto <D.19804>;
  <D.19803>:
  {
    struct MonoReflectionFieldBuilder * fb;

    D.27297 = (long unsigned int) i;
    D.27294 = tb->fields;
    D.27298 = mono_array_addr_with_size (D.27294, 8, D.27297);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.27298];
    D.27299 = fb->cattrs;
    D.27300 = fb->table_idx;
    D.27301 = (unsigned int) D.27300;
    mono_image_add_cattrs (assembly, D.27301, 1, D.27299);
  }
  i = i + 1;
  <D.19804>:
  D.27302 = tb->num_fields;
  if (D.27302 > i) goto <D.19803>; else goto <D.19805>;
  <D.19805>:
  <D.27296>:
  D.27303 = tb->events;
  if (D.27303 != 0B) goto <D.27304>; else goto <D.27305>;
  <D.27304>:
  i = 0;
  goto <D.19808>;
  <D.19807>:
  {
    struct MonoReflectionEventBuilder * eb;

    D.27297 = (long unsigned int) i;
    D.27303 = tb->events;
    D.27306 = mono_array_addr_with_size (D.27303, 8, D.27297);
    eb = MEM[(struct MonoReflectionEventBuilder * *)D.27306];
    D.27307 = eb->cattrs;
    D.27308 = eb->table_idx;
    mono_image_add_cattrs (assembly, D.27308, 10, D.27307);
  }
  i = i + 1;
  <D.19808>:
  D.27297 = (long unsigned int) i;
  D.27303 = tb->events;
  D.27309 = mono_array_length (D.27303);
  if (D.27297 < D.27309) goto <D.19807>; else goto <D.19809>;
  <D.19809>:
  <D.27305>:
  D.27310 = tb->properties;
  if (D.27310 != 0B) goto <D.27311>; else goto <D.27312>;
  <D.27311>:
  i = 0;
  goto <D.19812>;
  <D.19811>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    D.27297 = (long unsigned int) i;
    D.27310 = tb->properties;
    D.27313 = mono_array_addr_with_size (D.27310, 8, D.27297);
    pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.27313];
    D.27314 = pb->cattrs;
    D.27315 = pb->table_idx;
    D.27316 = (unsigned int) D.27315;
    mono_image_add_cattrs (assembly, D.27316, 9, D.27314);
  }
  i = i + 1;
  <D.19812>:
  D.27297 = (long unsigned int) i;
  D.27310 = tb->properties;
  D.27317 = mono_array_length (D.27310);
  if (D.27297 < D.27317) goto <D.19811>; else goto <D.19813>;
  <D.19813>:
  <D.27312>:
  D.27318 = tb->ctors;
  if (D.27318 != 0B) goto <D.27319>; else goto <D.27320>;
  <D.27319>:
  i = 0;
  goto <D.19816>;
  <D.19815>:
  {
    struct MonoReflectionCtorBuilder * cb;

    D.27297 = (long unsigned int) i;
    D.27318 = tb->ctors;
    D.27321 = mono_array_addr_with_size (D.27318, 8, D.27297);
    cb = MEM[(struct MonoReflectionCtorBuilder * *)D.27321];
    D.27322 = cb->cattrs;
    D.27323 = cb->table_idx;
    mono_image_add_cattrs (assembly, D.27323, 0, D.27322);
    D.27324 = cb->pinfo;
    params_add_cattrs (assembly, D.27324);
  }
  i = i + 1;
  <D.19816>:
  D.27297 = (long unsigned int) i;
  D.27318 = tb->ctors;
  D.27325 = mono_array_length (D.27318);
  if (D.27297 < D.27325) goto <D.19815>; else goto <D.19817>;
  <D.19817>:
  <D.27320>:
  D.27326 = tb->methods;
  if (D.27326 != 0B) goto <D.27327>; else goto <D.27328>;
  <D.27327>:
  i = 0;
  goto <D.19820>;
  <D.19819>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.27297 = (long unsigned int) i;
    D.27326 = tb->methods;
    D.27329 = mono_array_addr_with_size (D.27326, 8, D.27297);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.27329];
    D.27330 = mb->cattrs;
    D.27331 = mb->table_idx;
    mono_image_add_cattrs (assembly, D.27331, 0, D.27330);
    D.27332 = mb->pinfo;
    params_add_cattrs (assembly, D.27332);
  }
  i = i + 1;
  <D.19820>:
  D.27333 = tb->num_methods;
  if (D.27333 > i) goto <D.19819>; else goto <D.19821>;
  <D.19821>:
  <D.27328>:
  D.27334 = tb->subtypes;
  if (D.27334 != 0B) goto <D.27335>; else goto <D.27336>;
  <D.27335>:
  i = 0;
  goto <D.19823>;
  <D.19822>:
  D.27297 = (long unsigned int) i;
  D.27334 = tb->subtypes;
  D.27337 = mono_array_addr_with_size (D.27334, 8, D.27297);
  D.27338 = MEM[(struct MonoReflectionTypeBuilder * *)D.27337];
  type_add_cattrs (assembly, D.27338);
  i = i + 1;
  <D.19823>:
  D.27297 = (long unsigned int) i;
  D.27334 = tb->subtypes;
  D.27339 = mono_array_length (D.27334);
  if (D.27297 < D.27339) goto <D.19822>; else goto <D.19824>;
  <D.19824>:
  <D.27336>:
}


mono_image_add_methodimpl (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.27340;
  long unsigned int D.27343;
  char * D.27344;
  unsigned int D.27345;
  unsigned int D.27346;
  guint32 * D.27347;
  unsigned int D.27348;
  long unsigned int D.27349;
  long unsigned int D.27350;
  unsigned int D.27351;
  guint32 * D.27352;
  unsigned int D.27353;
  unsigned int D.27354;
  unsigned int D.27355;
  unsigned int D.27356;
  unsigned int D.27357;
  guint32 * D.27358;
  long unsigned int D.27359;
  struct MonoReflectionTypeBuilder * tb;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 tok;
  struct MonoReflectionMethod * m;
  int i;

  tb = mb->type;
  D.27340 = mb->override_methods;
  if (D.27340 == 0B) goto <D.27341>; else goto <D.27342>;
  <D.27341>:
  return;
  <D.27342>:
  i = 0;
  goto <D.19140>;
  <D.19139>:
  D.27343 = (long unsigned int) i;
  D.27340 = mb->override_methods;
  D.27344 = mono_array_addr_with_size (D.27340, 8, D.27343);
  m = MEM[(struct MonoReflectionMethod * *)D.27344];
  table = &assembly->tables[25];
  D.27345 = table->rows;
  D.27346 = D.27345 + 1;
  table->rows = D.27346;
  D.27345 = table->rows;
  alloc_table (table, D.27345);
  D.27347 = table->values;
  D.27345 = table->rows;
  D.27348 = D.27345 * 3;
  D.27349 = (long unsigned int) D.27348;
  D.27350 = D.27349 * 4;
  values = D.27347 + D.27350;
  D.27351 = tb->table_idx;
  *values = D.27351;
  D.27352 = values + 4;
  D.27353 = mb->table_idx;
  D.27354 = D.27353 << 1;
  *D.27352 = D.27354;
  tok = mono_image_create_token (assembly, m, 0, 0);
  D.27355 = tok >> 24;
  switch (D.27355) <default: <D.19138>, case 6: <D.19137>, case 10: <D.19135>>
  <D.19135>:
  D.27356 = tok & 16777215;
  D.27357 = D.27356 << 1;
  tok = D.27357 | 1;
  goto <D.19136>;
  <D.19137>:
  D.27356 = tok & 16777215;
  tok = D.27356 << 1;
  goto <D.19136>;
  <D.19138>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 1589);
  <D.19136>:
  D.27358 = values + 8;
  *D.27358 = tok;
  i = i + 1;
  <D.19140>:
  D.27343 = (long unsigned int) i;
  D.27340 = mb->override_methods;
  D.27359 = mono_array_length (D.27340);
  if (D.27343 < D.27359) goto <D.19139>; else goto <D.19141>;
  <D.19141>:
}


fixup_cattrs (struct MonoDynamicImage * assembly)
{
  guint32 * D.27361;
  unsigned int D.27362;
  unsigned int D.27363;
  long unsigned int D.27364;
  long unsigned int D.27365;
  unsigned int D.27366;
  long unsigned int D.27369;
  const void * D.27370;
  struct MonoGHashTable * D.27371;
  _Bool D.27372;
  long int D.27373;
  long int D.27374;
  int D.20293;
  int iftmp.113;
  int D.20292;
  struct MonoVTable * D.27380;
  struct MonoClass * D.27381;
  const char[12] * D.27382;
  unsigned char D.27383;
  int D.27384;
  unsigned char D.27385;
  int D.27386;
  _Bool D.27387;
  _Bool D.27388;
  _Bool D.27389;
  const unsigned char * D.27392;
  unsigned char D.27393;
  int D.27394;
  const unsigned char * D.27395;
  unsigned char D.27396;
  int D.27397;
  _Bool D.27398;
  _Bool D.27399;
  const unsigned char * D.27402;
  unsigned char D.27403;
  int D.27404;
  const unsigned char * D.27405;
  unsigned char D.27406;
  int D.27407;
  _Bool D.27408;
  _Bool D.27409;
  const unsigned char * D.27412;
  unsigned char D.27413;
  int D.27414;
  const unsigned char * D.27415;
  unsigned char D.27416;
  int D.27417;
  const char * D.27419;
  struct GHashTable * D.27422;
  void * D.27423;
  long int D.27424;
  guint32 * D.27425;
  unsigned int D.27426;
  unsigned int D.27427;
  int D.20303;
  int iftmp.114;
  int D.20302;
  const char[19] * D.27432;
  unsigned char D.27433;
  int D.27434;
  unsigned char D.27435;
  int D.27436;
  _Bool D.27437;
  _Bool D.27438;
  _Bool D.27439;
  const unsigned char * D.27442;
  unsigned char D.27443;
  int D.27444;
  const unsigned char * D.27445;
  unsigned char D.27446;
  int D.27447;
  _Bool D.27448;
  _Bool D.27449;
  const unsigned char * D.27452;
  unsigned char D.27453;
  int D.27454;
  const unsigned char * D.27455;
  unsigned char D.27456;
  int D.27457;
  _Bool D.27458;
  _Bool D.27459;
  const unsigned char * D.27462;
  unsigned char D.27463;
  int D.27464;
  const unsigned char * D.27465;
  unsigned char D.27466;
  int D.27467;
  void * D.27471;
  long int D.27472;
  unsigned int D.27473;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 type;
  guint32 i;
  guint32 idx;
  guint32 token;
  struct MonoObject * ctor;

  table = &assembly->tables[12];
  i = 0;
  goto <D.20306>;
  <D.20305>:
  D.27361 = table->values;
  D.27362 = i + 1;
  D.27363 = D.27362 * 3;
  D.27364 = (long unsigned int) D.27363;
  D.27365 = D.27364 * 4;
  values = D.27361 + D.27365;
  type = MEM[(guint32 *)values + 4B];
  D.27366 = type & 7;
  if (D.27366 == 2) goto <D.27367>; else goto <D.27368>;
  <D.27367>:
  idx = type >> 3;
  token = idx | 100663296;
  D.27369 = (long unsigned int) token;
  D.27370 = (const void *) D.27369;
  D.27371 = assembly->remapped_tokens;
  ctor = mono_g_hash_table_lookup (D.27371, D.27370);
  D.27372 = ctor == 0B;
  D.27373 = (long int) D.27372;
  D.27374 = __builtin_expect (D.27373, 0);
  if (D.27374 != 0) goto <D.27375>; else goto <D.27376>;
  <D.27375>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4337, "ctor");
  <D.27376>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.27380 = ctor->vtable;
      D.27381 = D.27380->klass;
      __s2 = D.27381->name;
      D.27382 = "MonoCMethod";
      D.27383 = MEM[(const unsigned char *)D.27382];
      D.27384 = (int) D.27383;
      D.27385 = *__s2;
      D.27386 = (int) D.27385;
      __result = D.27384 - D.27386;
      {
        D.27387 = __s2_len != 0;
        D.27388 = __result == 0;
        D.27389 = D.27387 & D.27388;
        if (D.27389 != 0) goto <D.27390>; else goto <D.27391>;
        <D.27390>:
        D.27392 = &MEM[(void *)"MonoCMethod" + 1B];
        D.27393 = *D.27392;
        D.27394 = (int) D.27393;
        D.27395 = __s2 + 1;
        D.27396 = *D.27395;
        D.27397 = (int) D.27396;
        __result = D.27394 - D.27397;
        D.27398 = __s2_len > 1;
        D.27388 = __result == 0;
        D.27399 = D.27398 & D.27388;
        if (D.27399 != 0) goto <D.27400>; else goto <D.27401>;
        <D.27400>:
        D.27402 = &MEM[(void *)"MonoCMethod" + 2B];
        D.27403 = *D.27402;
        D.27404 = (int) D.27403;
        D.27405 = __s2 + 2;
        D.27406 = *D.27405;
        D.27407 = (int) D.27406;
        __result = D.27404 - D.27407;
        D.27408 = __s2_len > 2;
        D.27388 = __result == 0;
        D.27409 = D.27408 & D.27388;
        if (D.27409 != 0) goto <D.27410>; else goto <D.27411>;
        <D.27410>:
        D.27412 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27413 = *D.27412;
        D.27414 = (int) D.27413;
        D.27415 = __s2 + 3;
        D.27416 = *D.27415;
        D.27417 = (int) D.27416;
        __result = D.27414 - D.27417;
        <D.27411>:
        <D.27401>:
        <D.27391>:
      }
      D.20292 = __result;
    }
    iftmp.113 = -D.20292;
    goto <D.27418>;
    <D.27379>:
    D.27380 = ctor->vtable;
    D.27381 = D.27380->klass;
    D.27419 = D.27381->name;
    iftmp.113 = __builtin_strcmp (D.27419, "MonoCMethod");
    <D.27418>:
    D.20293 = iftmp.113;
  }
  if (D.20293 == 0) goto <D.27420>; else goto <D.27421>;
  <D.27420>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionMethod *)ctor].method;
    D.27422 = assembly->method_to_table_idx;
    D.27423 = monoeg_g_hash_table_lookup (D.27422, m);
    D.27424 = (long int) D.27423;
    idx = (guint32) D.27424;
    D.27425 = values + 4;
    D.27426 = idx << 3;
    D.27427 = D.27426 | 2;
    *D.27425 = D.27427;
  }
  goto <D.27428>;
  <D.27421>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.27380 = ctor->vtable;
      D.27381 = D.27380->klass;
      __s2 = D.27381->name;
      D.27432 = "ConstructorBuilder";
      D.27433 = MEM[(const unsigned char *)D.27432];
      D.27434 = (int) D.27433;
      D.27435 = *__s2;
      D.27436 = (int) D.27435;
      __result = D.27434 - D.27436;
      {
        D.27437 = __s2_len != 0;
        D.27438 = __result == 0;
        D.27439 = D.27437 & D.27438;
        if (D.27439 != 0) goto <D.27440>; else goto <D.27441>;
        <D.27440>:
        D.27442 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.27443 = *D.27442;
        D.27444 = (int) D.27443;
        D.27445 = __s2 + 1;
        D.27446 = *D.27445;
        D.27447 = (int) D.27446;
        __result = D.27444 - D.27447;
        D.27448 = __s2_len > 1;
        D.27438 = __result == 0;
        D.27449 = D.27448 & D.27438;
        if (D.27449 != 0) goto <D.27450>; else goto <D.27451>;
        <D.27450>:
        D.27452 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.27453 = *D.27452;
        D.27454 = (int) D.27453;
        D.27455 = __s2 + 2;
        D.27456 = *D.27455;
        D.27457 = (int) D.27456;
        __result = D.27454 - D.27457;
        D.27458 = __s2_len > 2;
        D.27438 = __result == 0;
        D.27459 = D.27458 & D.27438;
        if (D.27459 != 0) goto <D.27460>; else goto <D.27461>;
        <D.27460>:
        D.27462 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.27463 = *D.27462;
        D.27464 = (int) D.27463;
        D.27465 = __s2 + 3;
        D.27466 = *D.27465;
        D.27467 = (int) D.27466;
        __result = D.27464 - D.27467;
        <D.27461>:
        <D.27451>:
        <D.27441>:
      }
      D.20302 = __result;
    }
    iftmp.114 = -D.20302;
    goto <D.27468>;
    <D.27431>:
    D.27380 = ctor->vtable;
    D.27381 = D.27380->klass;
    D.27419 = D.27381->name;
    iftmp.114 = __builtin_strcmp (D.27419, "ConstructorBuilder");
    <D.27468>:
    D.20303 = iftmp.114;
  }
  if (D.20303 == 0) goto <D.27469>; else goto <D.27470>;
  <D.27469>:
  {
    struct MonoMethod * m;

    m = MEM[(struct MonoReflectionCtorBuilder *)ctor].mhandle;
    D.27422 = assembly->method_to_table_idx;
    D.27471 = monoeg_g_hash_table_lookup (D.27422, m);
    D.27472 = (long int) D.27471;
    idx = (guint32) D.27472;
    D.27425 = values + 4;
    D.27426 = idx << 3;
    D.27427 = D.27426 | 2;
    *D.27425 = D.27427;
  }
  <D.27470>:
  <D.27428>:
  <D.27368>:
  i = i + 1;
  <D.20306>:
  D.27473 = table->rows;
  if (D.27473 > i) goto <D.20305>; else goto <D.20307>;
  <D.20307>:
}


mono_image_insert_string (struct MonoReflectionModuleBuilder * module, struct MonoString * str)
{
  struct MonoDynamicImage * D.27474;
  int D.27477;
  char * b.115;
  int D.27481;
  int D.27482;
  int D.27483;
  unsigned int D.27484;
  long int b.116;
  long int buf.117;
  long int D.27487;
  unsigned int D.27488;
  struct MonoDynamicStream * D.27489;
  unsigned int D.27490;
  mono_unichar2 * D.27491;
  unsigned int D.27493;
  unsigned int idx.118;
  unsigned int D.27495;
  unsigned int D.27496;
  long unsigned int D.27497;
  void * D.27498;
  struct MonoGHashTable * D.27499;
  guint32 D.27500;
  struct MonoDynamicImage * assembly;
  guint32 idx;
  char buf[16];
  char * b;

  try
    {
      b = &buf;
      D.27474 = module->dynamic_image;
      if (D.27474 == 0B) goto <D.27475>; else goto <D.27476>;
      <D.27475>:
      mono_image_module_basic_init (module);
      <D.27476>:
      assembly = module->dynamic_image;
      D.27477 = assembly->save;
      if (D.27477 != 0) goto <D.27478>; else goto <D.27479>;
      <D.27478>:
      b.115 = b;
      D.27481 = str->length;
      D.27482 = D.27481 * 2;
      D.27483 = D.27482 | 1;
      D.27484 = (unsigned int) D.27483;
      mono_metadata_encode_value (D.27484, b.115, &b);
      b.115 = b;
      b.116 = (long int) b.115;
      buf.117 = (long int) &buf;
      D.27487 = b.116 - buf.117;
      D.27488 = (unsigned int) D.27487;
      D.27489 = &assembly->us;
      idx = mono_image_add_stream_data (D.27489, &buf, D.27488);
      D.27481 = str->length;
      D.27482 = D.27481 * 2;
      D.27490 = (unsigned int) D.27482;
      D.27491 = mono_string_chars (str);
      D.27489 = &assembly->us;
      mono_image_add_stream_data (D.27489, D.27491, D.27490);
      D.27489 = &assembly->us;
      mono_image_add_stream_data (D.27489, "", 1);
      goto <D.27492>;
      <D.27479>:
      D.27493 = assembly->us.index;
      idx.118 = D.27493;
      D.27495 = idx.118 + 1;
      assembly->us.index = D.27495;
      idx = idx.118;
      <D.27492>:
      D.27496 = idx | 1879048192;
      D.27497 = (long unsigned int) D.27496;
      D.27498 = (void *) D.27497;
      D.27499 = assembly->tokens;
      mono_g_hash_table_insert (D.27499, D.27498, str);
      D.27500 = idx | 1879048192;
      return D.27500;
    }
  finally
    {
      buf = {CLOBBER};
      b = {CLOBBER};
    }
}


mono_image_create_method_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, struct MonoArray * opt_param_types)
{
  struct MonoVTable * D.27503;
  int D.20468;
  int iftmp.119;
  int D.20467;
  const char[11] * D.27510;
  unsigned char D.27511;
  int D.27512;
  unsigned char D.27513;
  int D.27514;
  _Bool D.27515;
  _Bool D.27516;
  _Bool D.27517;
  const unsigned char * D.27520;
  unsigned char D.27521;
  int D.27522;
  const unsigned char * D.27523;
  unsigned char D.27524;
  int D.27525;
  _Bool D.27526;
  _Bool D.27527;
  const unsigned char * D.27530;
  unsigned char D.27531;
  int D.27532;
  const unsigned char * D.27533;
  unsigned char D.27534;
  int D.27535;
  _Bool D.27536;
  _Bool D.27537;
  const unsigned char * D.27540;
  unsigned char D.27541;
  int D.27542;
  const unsigned char * D.27543;
  unsigned char D.27544;
  int D.27545;
  const char * D.27547;
  int D.20477;
  int iftmp.120;
  int D.20476;
  const char[12] * D.27552;
  unsigned char D.27553;
  int D.27554;
  unsigned char D.27555;
  int D.27556;
  _Bool D.27557;
  _Bool D.27558;
  _Bool D.27559;
  const unsigned char * D.27562;
  unsigned char D.27563;
  int D.27564;
  const unsigned char * D.27565;
  unsigned char D.27566;
  int D.27567;
  _Bool D.27568;
  _Bool D.27569;
  const unsigned char * D.27572;
  unsigned char D.27573;
  int D.27574;
  const unsigned char * D.27575;
  unsigned char D.27576;
  int D.27577;
  _Bool D.27578;
  _Bool D.27579;
  const unsigned char * D.27582;
  unsigned char D.27583;
  int D.27584;
  const unsigned char * D.27585;
  unsigned char D.27586;
  int D.27587;
  int iftmp.121;
  struct MonoMethodSignature * D.27594;
  short int D.27595;
  _Bool D.27596;
  long int D.27597;
  long int D.27598;
  long unsigned int D.27601;
  short unsigned int D.27602;
  int D.27603;
  int D.27604;
  unsigned int D.27605;
  struct MonoImage * D.27606;
  <unnamed-unsigned:1> D.27607;
  <unnamed-unsigned:1> D.27608;
  <unnamed-unsigned:6> D.27609;
  short unsigned int D.27610;
  short unsigned int D.27611;
  short unsigned int D.27612;
  short int D.27613;
  struct MonoType * D.27614;
  struct MonoType * D.27615;
  long unsigned int D.27616;
  char * D.27617;
  int D.27618;
  struct MonoType * D.27619;
  struct MonoClass * D.27620;
  struct MonoType * D.27621;
  unsigned int D.27622;
  _Bool D.27623;
  long int D.27624;
  long int D.27625;
  const char * D.27628;
  int D.20499;
  int iftmp.122;
  int D.20498;
  const char[14] * D.27632;
  unsigned char D.27633;
  int D.27634;
  unsigned char D.27635;
  int D.27636;
  _Bool D.27637;
  _Bool D.27638;
  _Bool D.27639;
  const unsigned char * D.27642;
  unsigned char D.27643;
  int D.27644;
  const unsigned char * D.27645;
  unsigned char D.27646;
  int D.27647;
  _Bool D.27648;
  _Bool D.27649;
  const unsigned char * D.27652;
  unsigned char D.27653;
  int D.27654;
  const unsigned char * D.27655;
  unsigned char D.27656;
  int D.27657;
  _Bool D.27658;
  _Bool D.27659;
  const unsigned char * D.27662;
  unsigned char D.27663;
  int D.27664;
  const unsigned char * D.27665;
  unsigned char D.27666;
  int D.27667;
  long unsigned int D.27671;
  int iftmp.123;
  struct MonoArray * D.27673;
  long unsigned int D.27676;
  int iftmp.124;
  struct MonoArray * D.27679;
  long unsigned int D.27682;
  int D.27684;
  unsigned int D.27685;
  unsigned int D.27686;
  unsigned int D.27687;
  _Bool D.27688;
  unsigned int D.27689;
  unsigned int D.27690;
  _Bool D.27691;
  unsigned char D.27692;
  <unnamed-unsigned:6> D.27693;
  short unsigned int D.27694;
  short unsigned int D.27695;
  short unsigned int D.27696;
  short unsigned int D.27697;
  short int D.27698;
  struct MonoReflectionType * D.27699;
  struct MonoType * D.27700;
  long unsigned int D.27701;
  char * D.27702;
  struct MonoType * D.27703;
  char * D.27704;
  int D.27705;
  struct MonoType * D.27706;
  unsigned int D.27707;
  _Bool D.27708;
  long int D.27709;
  long int D.27710;
  unsigned int D.27713;
  struct MonoString * D.27714;
  long unsigned int D.27716;
  void * D.27717;
  struct GHashTable * D.27718;
  struct MonoGHashTable * D.27719;
  guint32 D.27720;
  struct MonoClass * klass;
  guint32 token;
  struct MonoMethodSignature * sig;

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

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

      __s2 = klass->name;
      D.27510 = "MonoMethod";
      D.27511 = MEM[(const unsigned char *)D.27510];
      D.27512 = (int) D.27511;
      D.27513 = *__s2;
      D.27514 = (int) D.27513;
      __result = D.27512 - D.27514;
      {
        D.27515 = __s2_len != 0;
        D.27516 = __result == 0;
        D.27517 = D.27515 & D.27516;
        if (D.27517 != 0) goto <D.27518>; else goto <D.27519>;
        <D.27518>:
        D.27520 = &MEM[(void *)"MonoMethod" + 1B];
        D.27521 = *D.27520;
        D.27522 = (int) D.27521;
        D.27523 = __s2 + 1;
        D.27524 = *D.27523;
        D.27525 = (int) D.27524;
        __result = D.27522 - D.27525;
        D.27526 = __s2_len > 1;
        D.27516 = __result == 0;
        D.27527 = D.27526 & D.27516;
        if (D.27527 != 0) goto <D.27528>; else goto <D.27529>;
        <D.27528>:
        D.27530 = &MEM[(void *)"MonoMethod" + 2B];
        D.27531 = *D.27530;
        D.27532 = (int) D.27531;
        D.27533 = __s2 + 2;
        D.27534 = *D.27533;
        D.27535 = (int) D.27534;
        __result = D.27532 - D.27535;
        D.27536 = __s2_len > 2;
        D.27516 = __result == 0;
        D.27537 = D.27536 & D.27516;
        if (D.27537 != 0) goto <D.27538>; else goto <D.27539>;
        <D.27538>:
        D.27540 = &MEM[(void *)"MonoMethod" + 3B];
        D.27541 = *D.27540;
        D.27542 = (int) D.27541;
        D.27543 = __s2 + 3;
        D.27544 = *D.27543;
        D.27545 = (int) D.27544;
        __result = D.27542 - D.27545;
        <D.27539>:
        <D.27529>:
        <D.27519>:
      }
      D.20467 = __result;
    }
    iftmp.119 = -D.20467;
    goto <D.27546>;
    <D.27509>:
    D.27547 = klass->name;
    iftmp.119 = __builtin_strcmp (D.27547, "MonoMethod");
    <D.27546>:
    D.20468 = iftmp.119;
  }
  if (D.20468 == 0) goto <D.27504>; else goto <D.27548>;
  <D.27548>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27552 = "MonoCMethod";
      D.27553 = MEM[(const unsigned char *)D.27552];
      D.27554 = (int) D.27553;
      D.27555 = *__s2;
      D.27556 = (int) D.27555;
      __result = D.27554 - D.27556;
      {
        D.27557 = __s2_len != 0;
        D.27558 = __result == 0;
        D.27559 = D.27557 & D.27558;
        if (D.27559 != 0) goto <D.27560>; else goto <D.27561>;
        <D.27560>:
        D.27562 = &MEM[(void *)"MonoCMethod" + 1B];
        D.27563 = *D.27562;
        D.27564 = (int) D.27563;
        D.27565 = __s2 + 1;
        D.27566 = *D.27565;
        D.27567 = (int) D.27566;
        __result = D.27564 - D.27567;
        D.27568 = __s2_len > 1;
        D.27558 = __result == 0;
        D.27569 = D.27568 & D.27558;
        if (D.27569 != 0) goto <D.27570>; else goto <D.27571>;
        <D.27570>:
        D.27572 = &MEM[(void *)"MonoCMethod" + 2B];
        D.27573 = *D.27572;
        D.27574 = (int) D.27573;
        D.27575 = __s2 + 2;
        D.27576 = *D.27575;
        D.27577 = (int) D.27576;
        __result = D.27574 - D.27577;
        D.27578 = __s2_len > 2;
        D.27558 = __result == 0;
        D.27579 = D.27578 & D.27558;
        if (D.27579 != 0) goto <D.27580>; else goto <D.27581>;
        <D.27580>:
        D.27582 = &MEM[(void *)"MonoCMethod" + 3B];
        D.27583 = *D.27582;
        D.27584 = (int) D.27583;
        D.27585 = __s2 + 3;
        D.27586 = *D.27585;
        D.27587 = (int) D.27586;
        __result = D.27584 - D.27587;
        <D.27581>:
        <D.27571>:
        <D.27561>:
      }
      D.20476 = __result;
    }
    iftmp.120 = -D.20476;
    goto <D.27588>;
    <D.27551>:
    D.27547 = klass->name;
    iftmp.120 = __builtin_strcmp (D.27547, "MonoCMethod");
    <D.27588>:
    D.20477 = iftmp.120;
  }
  if (D.20477 == 0) goto <D.27504>; else goto <D.27505>;
  <D.27504>:
  {
    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.27590>; else goto <D.27593>;
    <D.27593>:
    D.27594 = mono_method_signature (method);
    D.27595 = D.27594->sentinelpos;
    if (D.27595 < 0) goto <D.27590>; else goto <D.27591>;
    <D.27590>:
    iftmp.121 = 1;
    goto <D.27592>;
    <D.27591>:
    iftmp.121 = 0;
    <D.27592>:
    D.27596 = iftmp.121 != 0;
    D.27597 = (long int) D.27596;
    D.27598 = __builtin_expect (D.27597, 0);
    if (D.27598 != 0) goto <D.27599>; else goto <D.27600>;
    <D.27599>:
    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.27600>:
    D.27601 = mono_array_length (opt_param_types);
    nargs = (int) D.27601;
    old = mono_method_signature (method);
    D.27602 = old->param_count;
    D.27603 = (int) D.27602;
    D.27604 = D.27603 + nargs;
    D.27605 = (unsigned int) D.27604;
    D.27606 = &assembly->image;
    sig = mono_metadata_signature_alloc (D.27606, D.27605);
    D.27607 = old->hasthis;
    sig->hasthis = D.27607;
    D.27608 = old->explicit_this;
    sig->explicit_this = D.27608;
    D.27609 = old->call_convention;
    sig->call_convention = D.27609;
    D.27610 = old->generic_param_count;
    sig->generic_param_count = D.27610;
    D.27602 = old->param_count;
    D.27611 = (short unsigned int) nargs;
    D.27612 = D.27602 + D.27611;
    sig->param_count = D.27612;
    D.27602 = old->param_count;
    D.27613 = (short int) D.27602;
    sig->sentinelpos = D.27613;
    D.27614 = old->ret;
    sig->ret = D.27614;
    i = 0;
    goto <D.20485>;
    <D.20484>:
    D.27615 = old->params[i];
    sig->params[i] = D.27615;
    i = i + 1;
    <D.20485>:
    D.27602 = old->param_count;
    D.27603 = (int) D.27602;
    if (D.27603 > i) goto <D.20484>; else goto <D.20486>;
    <D.20486>:
    i = 0;
    goto <D.20489>;
    <D.20488>:
    {
      struct MonoReflectionType * rt;

      D.27616 = (long unsigned int) i;
      D.27617 = mono_array_addr_with_size (opt_param_types, 8, D.27616);
      rt = MEM[(struct MonoReflectionType * *)D.27617];
      D.27602 = old->param_count;
      D.27603 = (int) D.27602;
      D.27618 = D.27603 + i;
      D.27619 = mono_reflection_type_get_handle (rt);
      sig->params[D.27618] = D.27619;
    }
    i = i + 1;
    <D.20489>:
    if (i < nargs) goto <D.20488>; else goto <D.20490>;
    <D.20490>:
    D.27620 = method->klass;
    D.27621 = &D.27620->byval_arg;
    parent = mono_image_typedef_or_ref (assembly, D.27621);
    D.27622 = parent & 3;
    D.27623 = D.27622 != 1;
    D.27624 = (long int) D.27623;
    D.27625 = __builtin_expect (D.27624, 0);
    if (D.27625 != 0) goto <D.27626>; else goto <D.27627>;
    <D.27626>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4836, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF");
    <D.27627>:
    parent = parent >> 2;
    parent = parent << 3;
    parent = parent | 1;
    sig_token = method_encode_signature (assembly, sig);
    D.27628 = method->name;
    token = mono_image_get_varargs_method_token (assembly, parent, D.27628, sig_token);
  }
  goto <D.27506>;
  <D.27505>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27632 = "MethodBuilder";
      D.27633 = MEM[(const unsigned char *)D.27632];
      D.27634 = (int) D.27633;
      D.27635 = *__s2;
      D.27636 = (int) D.27635;
      __result = D.27634 - D.27636;
      {
        D.27637 = __s2_len != 0;
        D.27638 = __result == 0;
        D.27639 = D.27637 & D.27638;
        if (D.27639 != 0) goto <D.27640>; else goto <D.27641>;
        <D.27640>:
        D.27642 = &MEM[(void *)"MethodBuilder" + 1B];
        D.27643 = *D.27642;
        D.27644 = (int) D.27643;
        D.27645 = __s2 + 1;
        D.27646 = *D.27645;
        D.27647 = (int) D.27646;
        __result = D.27644 - D.27647;
        D.27648 = __s2_len > 1;
        D.27638 = __result == 0;
        D.27649 = D.27648 & D.27638;
        if (D.27649 != 0) goto <D.27650>; else goto <D.27651>;
        <D.27650>:
        D.27652 = &MEM[(void *)"MethodBuilder" + 2B];
        D.27653 = *D.27652;
        D.27654 = (int) D.27653;
        D.27655 = __s2 + 2;
        D.27656 = *D.27655;
        D.27657 = (int) D.27656;
        __result = D.27654 - D.27657;
        D.27658 = __s2_len > 2;
        D.27638 = __result == 0;
        D.27659 = D.27658 & D.27638;
        if (D.27659 != 0) goto <D.27660>; else goto <D.27661>;
        <D.27660>:
        D.27662 = &MEM[(void *)"MethodBuilder" + 3B];
        D.27663 = *D.27662;
        D.27664 = (int) D.27663;
        D.27665 = __s2 + 3;
        D.27666 = *D.27665;
        D.27667 = (int) D.27666;
        __result = D.27664 - D.27667;
        <D.27661>:
        <D.27651>:
        <D.27641>:
      }
      D.20498 = __result;
    }
    iftmp.122 = -D.20498;
    goto <D.27668>;
    <D.27631>:
    D.27547 = klass->name;
    iftmp.122 = __builtin_strcmp (D.27547, "MethodBuilder");
    <D.27668>:
    D.20499 = iftmp.122;
  }
  if (D.20499 == 0) goto <D.27669>; else goto <D.27670>;
  <D.27669>:
  {
    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.27671 = mono_array_length (opt_param_types);
        nopt_args = (int) D.27671;
        D.27673 = rmb.parameters;
        if (D.27673 != 0B) goto <D.27674>; else goto <D.27675>;
        <D.27674>:
        D.27673 = rmb.parameters;
        D.27676 = mono_array_length (D.27673);
        iftmp.123 = (int) D.27676;
        goto <D.27677>;
        <D.27675>:
        iftmp.123 = 0;
        <D.27677>:
        nparams = iftmp.123;
        D.27679 = rmb.generic_params;
        if (D.27679 != 0B) goto <D.27680>; else goto <D.27681>;
        <D.27680>:
        D.27679 = rmb.generic_params;
        D.27682 = mono_array_length (D.27679);
        iftmp.124 = (int) D.27682;
        goto <D.27683>;
        <D.27681>:
        iftmp.124 = 0;
        <D.27683>:
        ngparams = iftmp.124;
        D.27684 = nparams + nopt_args;
        D.27685 = (unsigned int) D.27684;
        D.27606 = &assembly->image;
        sig = mono_metadata_signature_alloc (D.27606, D.27685);
        D.27686 = rmb.attrs;
        D.27687 = D.27686 & 16;
        D.27688 = D.27687 == 0;
        sig->hasthis = D.27688;
        D.27689 = rmb.call_conv;
        D.27690 = D.27689 & 64;
        D.27691 = D.27690 != 0;
        sig->explicit_this = D.27691;
        D.27689 = rmb.call_conv;
        D.27692 = (unsigned char) D.27689;
        D.27693 = (<unnamed-unsigned:6>) D.27692;
        sig->call_convention = D.27693;
        D.27694 = (short unsigned int) ngparams;
        sig->generic_param_count = D.27694;
        D.27695 = (short unsigned int) nparams;
        D.27696 = (short unsigned int) nopt_args;
        D.27697 = D.27695 + D.27696;
        sig->param_count = D.27697;
        D.27698 = (short int) nparams;
        sig->sentinelpos = D.27698;
        D.27699 = rmb.rtype;
        D.27700 = mono_reflection_type_get_handle (D.27699);
        sig->ret = D.27700;
        i = 0;
        goto <D.20511>;
        <D.20510>:
        {
          struct MonoReflectionType * rt;

          D.27701 = (long unsigned int) i;
          D.27673 = rmb.parameters;
          D.27702 = mono_array_addr_with_size (D.27673, 8, D.27701);
          rt = MEM[(struct MonoReflectionType * *)D.27702];
          D.27703 = mono_reflection_type_get_handle (rt);
          sig->params[i] = D.27703;
        }
        i = i + 1;
        <D.20511>:
        if (i < nparams) goto <D.20510>; else goto <D.20512>;
        <D.20512>:
        i = 0;
        goto <D.20515>;
        <D.20514>:
        {
          struct MonoReflectionType * rt;

          D.27701 = (long unsigned int) i;
          D.27704 = mono_array_addr_with_size (opt_param_types, 8, D.27701);
          rt = MEM[(struct MonoReflectionType * *)D.27704];
          D.27705 = nparams + i;
          D.27706 = mono_reflection_type_get_handle (rt);
          sig->params[D.27705] = D.27706;
        }
        i = i + 1;
        <D.20515>:
        if (i < nopt_args) goto <D.20514>; else goto <D.20516>;
        <D.20516>:
        sig_token = method_builder_encode_signature (assembly, &rmb);
        parent = mono_image_create_token (assembly, obj, 1, 1);
        D.27707 = parent >> 24;
        D.27708 = D.27707 != 6;
        D.27709 = (long int) D.27708;
        D.27710 = __builtin_expect (D.27709, 0);
        if (D.27710 != 0) goto <D.27711>; else goto <D.27712>;
        <D.27711>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4880, "mono_metadata_token_table (parent) == MONO_TABLE_METHOD");
        <D.27712>:
        D.27713 = parent & 16777215;
        parent = D.27713 << 3;
        parent = parent | 3;
        D.27714 = rmb.name;
        name = mono_string_to_utf8 (D.27714);
        token = mono_image_get_varargs_method_token (assembly, parent, name, sig_token);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.27715>;
  <D.27670>:
  D.27547 = klass->name;
  monoeg_g_log (0B, 4, "requested method token for %s\n", D.27547);
  <D.20517>:
  goto <D.20517>;
  <D.27715>:
  <D.27506>:
  D.27716 = (long unsigned int) token;
  D.27717 = (void *) D.27716;
  D.27718 = assembly->vararg_aux_hash;
  monoeg_g_hash_table_insert_replace (D.27718, D.27717, sig, 0);
  D.27716 = (long unsigned int) token;
  D.27717 = (void *) D.27716;
  D.27719 = assembly->tokens;
  mono_g_hash_table_insert (D.27719, D.27717, obj);
  D.27720 = token;
  return D.27720;
}


method_encode_signature (struct MonoDynamicImage * assembly, struct MonoMethodSignature * sig)
{
  short unsigned int D.27722;
  int D.27723;
  guint32 D.27726;
  <unnamed-unsigned:6> D.27727;
  unsigned char D.27728;
  unsigned char D.27729;
  short unsigned int D.27732;
  unsigned char D.27735;
  int D.27736;
  unsigned int D.27739;
  struct MonoType * D.27740;
  short int D.27741;
  int D.27742;
  struct MonoType * D.27745;
  unsigned int i.125;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.27722 = sig->param_count;
      nparams = (guint32) D.27722;
      D.27723 = assembly->save;
      if (D.27723 == 0) goto <D.27724>; else goto <D.27725>;
      <D.27724>:
      D.27726 = 0;
      return D.27726;
      <D.27725>:
      sigbuffer_init (&buf, 32);
      D.27727 = sig->call_convention;
      idx = (guint32) D.27727;
      D.27728 = BIT_FIELD_REF <*sig, 8, 112>;
      D.27729 = D.27728 & 64;
      if (D.27729 != 0) goto <D.27730>; else goto <D.27731>;
      <D.27730>:
      idx = idx | 32;
      <D.27731>:
      D.27732 = sig->generic_param_count;
      if (D.27732 != 0) goto <D.27733>; else goto <D.27734>;
      <D.27733>:
      idx = idx | 16;
      <D.27734>:
      D.27735 = (unsigned char) idx;
      D.27736 = (int) D.27735;
      sigbuffer_add_byte (&buf, D.27736);
      D.27732 = sig->generic_param_count;
      if (D.27732 != 0) goto <D.27737>; else goto <D.27738>;
      <D.27737>:
      D.27732 = sig->generic_param_count;
      D.27739 = (unsigned int) D.27732;
      sigbuffer_add_value (&buf, D.27739);
      <D.27738>:
      sigbuffer_add_value (&buf, nparams);
      D.27740 = sig->ret;
      encode_type (assembly, D.27740, &buf);
      i = 0;
      goto <D.18900>;
      <D.18899>:
      D.27741 = sig->sentinelpos;
      D.27742 = (int) D.27741;
      if (D.27742 == i) goto <D.27743>; else goto <D.27744>;
      <D.27743>:
      sigbuffer_add_byte (&buf, 65);
      <D.27744>:
      D.27745 = sig->params[i];
      encode_type (assembly, D.27745, &buf);
      i = i + 1;
      <D.18900>:
      i.125 = (unsigned int) i;
      if (i.125 < nparams) goto <D.18899>; else goto <D.18901>;
      <D.18901>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.27726 = idx;
      return D.27726;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_varargs_method_token (struct MonoDynamicImage * assembly, guint32 original, const gchar * name, guint32 sig)
{
  int D.27749;
  unsigned int D.27752;
  unsigned int D.27753;
  guint32 * D.27754;
  unsigned int D.27755;
  unsigned int D.27756;
  long unsigned int D.27757;
  long unsigned int D.27758;
  guint32 * D.27759;
  struct MonoDynamicStream * D.27760;
  unsigned int D.27761;
  guint32 * D.27762;
  unsigned int D.27763;
  guint32 D.27764;
  struct MonoDynamicTable * table;
  guint32 token;
  guint32 * values;

  table = &assembly->tables[10];
  D.27749 = assembly->save;
  if (D.27749 != 0) goto <D.27750>; else goto <D.27751>;
  <D.27750>:
  D.27752 = table->rows;
  D.27753 = D.27752 + 1;
  alloc_table (table, D.27753);
  D.27754 = table->values;
  D.27755 = table->next_idx;
  D.27756 = D.27755 * 3;
  D.27757 = (long unsigned int) D.27756;
  D.27758 = D.27757 * 4;
  values = D.27754 + D.27758;
  *values = original;
  D.27759 = values + 4;
  D.27760 = &assembly->sheap;
  D.27761 = string_heap_insert (D.27760, name);
  *D.27759 = D.27761;
  D.27762 = values + 8;
  *D.27762 = sig;
  <D.27751>:
  D.27755 = table->next_idx;
  token = D.27755 | 167772160;
  D.27755 = table->next_idx;
  D.27763 = D.27755 + 1;
  table->next_idx = D.27763;
  D.27764 = token;
  return D.27764;
}


mono_image_create_token (struct MonoDynamicImage * assembly, struct MonoObject * obj, gboolean create_open_instance, gboolean register_token)
{
  struct MonoVTable * D.27766;
  struct MonoImage * D.27769;
  struct MonoImage * D.27770;
  int D.20534;
  int iftmp.126;
  int D.20533;
  const char[14] * D.27775;
  unsigned char D.27776;
  int D.27777;
  unsigned char D.27778;
  int D.27779;
  _Bool D.27780;
  _Bool D.27781;
  _Bool D.27782;
  const unsigned char * D.27785;
  unsigned char D.27786;
  int D.27787;
  const unsigned char * D.27788;
  unsigned char D.27789;
  int D.27790;
  _Bool D.27791;
  _Bool D.27792;
  const unsigned char * D.27795;
  unsigned char D.27796;
  int D.27797;
  const unsigned char * D.27798;
  unsigned char D.27799;
  int D.27800;
  _Bool D.27801;
  _Bool D.27802;
  const unsigned char * D.27805;
  unsigned char D.27806;
  int D.27807;
  const unsigned char * D.27808;
  unsigned char D.27809;
  int D.27810;
  const char * D.27812;
  struct MonoException * D.27813;
  int D.20543;
  int iftmp.127;
  int D.20542;
  const char[14] * D.27817;
  unsigned char D.27818;
  int D.27819;
  unsigned char D.27820;
  int D.27821;
  _Bool D.27822;
  _Bool D.27823;
  _Bool D.27824;
  const unsigned char * D.27827;
  unsigned char D.27828;
  int D.27829;
  const unsigned char * D.27830;
  unsigned char D.27831;
  int D.27832;
  _Bool D.27833;
  _Bool D.27834;
  const unsigned char * D.27837;
  unsigned char D.27838;
  int D.27839;
  const unsigned char * D.27840;
  unsigned char D.27841;
  int D.27842;
  _Bool D.27843;
  _Bool D.27844;
  const unsigned char * D.27847;
  unsigned char D.27848;
  int D.27849;
  const unsigned char * D.27850;
  unsigned char D.27851;
  int D.27852;
  struct MonoReflectionModuleBuilder * D.27858;
  struct MonoDynamicImage * D.27859;
  struct MonoArray * D.27861;
  struct MonoArray * D.27863;
  unsigned int D.27865;
  int D.20554;
  int iftmp.128;
  int D.20553;
  const char[19] * D.27870;
  unsigned char D.27871;
  int D.27872;
  unsigned char D.27873;
  int D.27874;
  _Bool D.27875;
  _Bool D.27876;
  _Bool D.27877;
  const unsigned char * D.27880;
  unsigned char D.27881;
  int D.27882;
  const unsigned char * D.27883;
  unsigned char D.27884;
  int D.27885;
  _Bool D.27886;
  _Bool D.27887;
  const unsigned char * D.27890;
  unsigned char D.27891;
  int D.27892;
  const unsigned char * D.27893;
  unsigned char D.27894;
  int D.27895;
  _Bool D.27896;
  _Bool D.27897;
  const unsigned char * D.27900;
  unsigned char D.27901;
  int D.27902;
  const unsigned char * D.27903;
  unsigned char D.27904;
  int D.27905;
  struct MonoReflectionModuleBuilder * D.27911;
  struct MonoDynamicImage * D.27912;
  struct MonoArray * D.27914;
  unsigned int D.27916;
  int D.20565;
  int iftmp.129;
  int D.20564;
  const char[13] * D.27921;
  unsigned char D.27922;
  int D.27923;
  unsigned char D.27924;
  int D.27925;
  _Bool D.27926;
  _Bool D.27927;
  _Bool D.27928;
  const unsigned char * D.27931;
  unsigned char D.27932;
  int D.27933;
  const unsigned char * D.27934;
  unsigned char D.27935;
  int D.27936;
  _Bool D.27937;
  _Bool D.27938;
  const unsigned char * D.27941;
  unsigned char D.27942;
  int D.27943;
  const unsigned char * D.27944;
  unsigned char D.27945;
  int D.27946;
  _Bool D.27947;
  _Bool D.27948;
  const unsigned char * D.27951;
  unsigned char D.27952;
  int D.27953;
  const unsigned char * D.27954;
  unsigned char D.27955;
  int D.27956;
  struct MonoArray * D.27960;
  struct MonoReflectionModuleBuilder * D.27964;
  struct MonoDynamicImage * D.27965;
  int D.27968;
  int D.27969;
  struct MonoClassField * D.27971;
  int D.20576;
  int iftmp.130;
  int D.20575;
  const char[12] * D.27976;
  unsigned char D.27977;
  int D.27978;
  unsigned char D.27979;
  int D.27980;
  _Bool D.27981;
  _Bool D.27982;
  _Bool D.27983;
  const unsigned char * D.27986;
  unsigned char D.27987;
  int D.27988;
  const unsigned char * D.27989;
  unsigned char D.27990;
  int D.27991;
  _Bool D.27992;
  _Bool D.27993;
  const unsigned char * D.27996;
  unsigned char D.27997;
  int D.27998;
  const unsigned char * D.27999;
  unsigned char D.28000;
  int D.28001;
  _Bool D.28002;
  _Bool D.28003;
  const unsigned char * D.28006;
  unsigned char D.28007;
  int D.28008;
  const unsigned char * D.28009;
  unsigned char D.28010;
  int D.28011;
  struct MonoArray * D.28018;
  struct MonoReflectionModuleBuilder * D.28020;
  struct MonoDynamicImage * D.28021;
  unsigned int D.28024;
  unsigned int D.28026;
  int D.20588;
  int iftmp.131;
  int D.20587;
  const char[9] * D.28031;
  unsigned char D.28032;
  int D.28033;
  unsigned char D.28034;
  int D.28035;
  _Bool D.28036;
  _Bool D.28037;
  _Bool D.28038;
  const unsigned char * D.28041;
  unsigned char D.28042;
  int D.28043;
  const unsigned char * D.28044;
  unsigned char D.28045;
  int D.28046;
  _Bool D.28047;
  _Bool D.28048;
  const unsigned char * D.28051;
  unsigned char D.28052;
  int D.28053;
  const unsigned char * D.28054;
  unsigned char D.28055;
  int D.28056;
  _Bool D.28057;
  _Bool D.28058;
  const unsigned char * D.28061;
  unsigned char D.28062;
  int D.28063;
  const unsigned char * D.28064;
  unsigned char D.28065;
  int D.28066;
  int iftmp.132;
  struct MonoGenericContainer * D.28074;
  unsigned int D.28076;
  int D.20599;
  int iftmp.133;
  int D.20598;
  const char[28] * D.28081;
  unsigned char D.28082;
  int D.28083;
  unsigned char D.28084;
  int D.28085;
  _Bool D.28086;
  _Bool D.28087;
  _Bool D.28088;
  const unsigned char * D.28091;
  unsigned char D.28092;
  int D.28093;
  const unsigned char * D.28094;
  unsigned char D.28095;
  int D.28096;
  _Bool D.28097;
  _Bool D.28098;
  const unsigned char * D.28101;
  unsigned char D.28102;
  int D.28103;
  const unsigned char * D.28104;
  unsigned char D.28105;
  int D.28106;
  _Bool D.28107;
  _Bool D.28108;
  const unsigned char * D.28111;
  unsigned char D.28112;
  int D.28113;
  const unsigned char * D.28114;
  unsigned char D.28115;
  int D.28116;
  unsigned int D.28120;
  int D.20609;
  int iftmp.134;
  int D.20608;
  const char[17] * D.28125;
  unsigned char D.28126;
  int D.28127;
  unsigned char D.28128;
  int D.28129;
  _Bool D.28130;
  _Bool D.28131;
  _Bool D.28132;
  const unsigned char * D.28135;
  unsigned char D.28136;
  int D.28137;
  const unsigned char * D.28138;
  unsigned char D.28139;
  int D.28140;
  _Bool D.28141;
  _Bool D.28142;
  const unsigned char * D.28145;
  unsigned char D.28146;
  int D.28147;
  const unsigned char * D.28148;
  unsigned char D.28149;
  int D.28150;
  _Bool D.28151;
  _Bool D.28152;
  const unsigned char * D.28155;
  unsigned char D.28156;
  int D.28157;
  const unsigned char * D.28158;
  unsigned char D.28159;
  int D.28160;
  unsigned int D.28164;
  int D.20619;
  int iftmp.135;
  int D.20618;
  const char[12] * D.28172;
  unsigned char D.28173;
  int D.28174;
  unsigned char D.28175;
  int D.28176;
  _Bool D.28177;
  _Bool D.28178;
  _Bool D.28179;
  const unsigned char * D.28182;
  unsigned char D.28183;
  int D.28184;
  const unsigned char * D.28185;
  unsigned char D.28186;
  int D.28187;
  _Bool D.28188;
  _Bool D.28189;
  const unsigned char * D.28192;
  unsigned char D.28193;
  int D.28194;
  const unsigned char * D.28195;
  unsigned char D.28196;
  int D.28197;
  _Bool D.28198;
  _Bool D.28199;
  const unsigned char * D.28202;
  unsigned char D.28203;
  int D.28204;
  const unsigned char * D.28205;
  unsigned char D.28206;
  int D.28207;
  int D.20628;
  int iftmp.136;
  int D.20627;
  const char[11] * D.28213;
  unsigned char D.28214;
  int D.28215;
  unsigned char D.28216;
  int D.28217;
  _Bool D.28218;
  _Bool D.28219;
  _Bool D.28220;
  const unsigned char * D.28223;
  unsigned char D.28224;
  int D.28225;
  const unsigned char * D.28226;
  unsigned char D.28227;
  int D.28228;
  _Bool D.28229;
  _Bool D.28230;
  const unsigned char * D.28233;
  unsigned char D.28234;
  int D.28235;
  const unsigned char * D.28236;
  unsigned char D.28237;
  int D.28238;
  _Bool D.28239;
  _Bool D.28240;
  const unsigned char * D.28243;
  unsigned char D.28244;
  int D.28245;
  const unsigned char * D.28246;
  unsigned char D.28247;
  int D.28248;
  int D.20637;
  int iftmp.137;
  int D.20636;
  const char[18] * D.28254;
  unsigned char D.28255;
  int D.28256;
  unsigned char D.28257;
  int D.28258;
  _Bool D.28259;
  _Bool D.28260;
  _Bool D.28261;
  const unsigned char * D.28264;
  unsigned char D.28265;
  int D.28266;
  const unsigned char * D.28267;
  unsigned char D.28268;
  int D.28269;
  _Bool D.28270;
  _Bool D.28271;
  const unsigned char * D.28274;
  unsigned char D.28275;
  int D.28276;
  const unsigned char * D.28277;
  unsigned char D.28278;
  int D.28279;
  _Bool D.28280;
  _Bool D.28281;
  const unsigned char * D.28284;
  unsigned char D.28285;
  int D.28286;
  const unsigned char * D.28287;
  unsigned char D.28288;
  int D.28289;
  int D.20646;
  int iftmp.138;
  int D.20645;
  const char[19] * D.28295;
  unsigned char D.28296;
  int D.28297;
  unsigned char D.28298;
  int D.28299;
  _Bool D.28300;
  _Bool D.28301;
  _Bool D.28302;
  const unsigned char * D.28305;
  unsigned char D.28306;
  int D.28307;
  const unsigned char * D.28308;
  unsigned char D.28309;
  int D.28310;
  _Bool D.28311;
  _Bool D.28312;
  const unsigned char * D.28315;
  unsigned char D.28316;
  int D.28317;
  const unsigned char * D.28318;
  unsigned char D.28319;
  int D.28320;
  _Bool D.28321;
  _Bool D.28322;
  const unsigned char * D.28325;
  unsigned char D.28326;
  int D.28327;
  const unsigned char * D.28328;
  unsigned char D.28329;
  int D.28330;
  struct MonoMethod * D.28332;
  unsigned char D.28333;
  unsigned char D.28334;
  struct MonoClass * D.28343;
  struct MonoImage * D.28344;
  struct MonoImage * D.28345;
  struct MonoGenericClass * D.28347;
  unsigned char D.28349;
  unsigned char D.28350;
  unsigned int method_table_idx.139;
  unsigned int method_table_idx.140;
  int D.20657;
  int iftmp.141;
  int D.20656;
  const char[10] * D.28359;
  unsigned char D.28360;
  int D.28361;
  unsigned char D.28362;
  int D.28363;
  _Bool D.28364;
  _Bool D.28365;
  _Bool D.28366;
  const unsigned char * D.28369;
  unsigned char D.28370;
  int D.28371;
  const unsigned char * D.28372;
  unsigned char D.28373;
  int D.28374;
  _Bool D.28375;
  _Bool D.28376;
  const unsigned char * D.28379;
  unsigned char D.28380;
  int D.28381;
  const unsigned char * D.28382;
  unsigned char D.28383;
  int D.28384;
  _Bool D.28385;
  _Bool D.28386;
  const unsigned char * D.28389;
  unsigned char D.28390;
  int D.28391;
  const unsigned char * D.28392;
  unsigned char D.28393;
  int D.28394;
  struct MonoClassField * D.28400;
  struct MonoClass * D.28401;
  struct MonoImage * D.28402;
  int D.28404;
  unsigned int field_table_idx.142;
  unsigned int field_table_idx.143;
  int D.20668;
  int iftmp.144;
  int D.20667;
  const char[16] * D.28412;
  unsigned char D.28413;
  int D.28414;
  unsigned char D.28415;
  int D.28416;
  _Bool D.28417;
  _Bool D.28418;
  _Bool D.28419;
  const unsigned char * D.28422;
  unsigned char D.28423;
  int D.28424;
  const unsigned char * D.28425;
  unsigned char D.28426;
  int D.28427;
  _Bool D.28428;
  _Bool D.28429;
  const unsigned char * D.28432;
  unsigned char D.28433;
  int D.28434;
  const unsigned char * D.28435;
  unsigned char D.28436;
  int D.28437;
  _Bool D.28438;
  _Bool D.28439;
  const unsigned char * D.28442;
  unsigned char D.28443;
  int D.28444;
  const unsigned char * D.28445;
  unsigned char D.28446;
  int D.28447;
  int D.20678;
  int iftmp.145;
  int D.20677;
  const char[16] * D.28455;
  unsigned char D.28456;
  int D.28457;
  unsigned char D.28458;
  int D.28459;
  _Bool D.28460;
  _Bool D.28461;
  _Bool D.28462;
  const unsigned char * D.28465;
  unsigned char D.28466;
  int D.28467;
  const unsigned char * D.28468;
  unsigned char D.28469;
  int D.28470;
  _Bool D.28471;
  _Bool D.28472;
  const unsigned char * D.28475;
  unsigned char D.28476;
  int D.28477;
  const unsigned char * D.28478;
  unsigned char D.28479;
  int D.28480;
  _Bool D.28481;
  _Bool D.28482;
  const unsigned char * D.28485;
  unsigned char D.28486;
  int D.28487;
  const unsigned char * D.28488;
  unsigned char D.28489;
  int D.28490;
  unsigned int D.28494;
  int D.20688;
  int iftmp.146;
  int D.20687;
  const char[12] * D.28499;
  unsigned char D.28500;
  int D.28501;
  unsigned char D.28502;
  int D.28503;
  _Bool D.28504;
  _Bool D.28505;
  _Bool D.28506;
  const unsigned char * D.28509;
  unsigned char D.28510;
  int D.28511;
  const unsigned char * D.28512;
  unsigned char D.28513;
  int D.28514;
  _Bool D.28515;
  _Bool D.28516;
  const unsigned char * D.28519;
  unsigned char D.28520;
  int D.28521;
  const unsigned char * D.28522;
  unsigned char D.28523;
  int D.28524;
  _Bool D.28525;
  _Bool D.28526;
  const unsigned char * D.28529;
  unsigned char D.28530;
  int D.28531;
  const unsigned char * D.28532;
  unsigned char D.28533;
  int D.28534;
  unsigned int D.28538;
  int D.20698;
  int iftmp.147;
  int D.20697;
  const char[23] * D.28543;
  unsigned char D.28544;
  int D.28545;
  unsigned char D.28546;
  int D.28547;
  _Bool D.28548;
  _Bool D.28549;
  _Bool D.28550;
  const unsigned char * D.28553;
  unsigned char D.28554;
  int D.28555;
  const unsigned char * D.28556;
  unsigned char D.28557;
  int D.28558;
  _Bool D.28559;
  _Bool D.28560;
  const unsigned char * D.28563;
  unsigned char D.28564;
  int D.28565;
  const unsigned char * D.28566;
  unsigned char D.28567;
  int D.28568;
  _Bool D.28569;
  _Bool D.28570;
  const unsigned char * D.28573;
  unsigned char D.28574;
  int D.28575;
  const unsigned char * D.28576;
  unsigned char D.28577;
  int D.28578;
  int D.20708;
  int iftmp.148;
  int D.20707;
  const char[29] * D.28586;
  unsigned char D.28587;
  int D.28588;
  unsigned char D.28589;
  int D.28590;
  _Bool D.28591;
  _Bool D.28592;
  _Bool D.28593;
  const unsigned char * D.28596;
  unsigned char D.28597;
  int D.28598;
  const unsigned char * D.28599;
  unsigned char D.28600;
  int D.28601;
  _Bool D.28602;
  _Bool D.28603;
  const unsigned char * D.28606;
  unsigned char D.28607;
  int D.28608;
  const unsigned char * D.28609;
  unsigned char D.28610;
  int D.28611;
  _Bool D.28612;
  _Bool D.28613;
  const unsigned char * D.28616;
  unsigned char D.28617;
  int D.28618;
  const unsigned char * D.28619;
  unsigned char D.28620;
  int D.28621;
  int D.20718;
  int iftmp.149;
  int D.20717;
  const char[24] * D.28629;
  unsigned char D.28630;
  int D.28631;
  unsigned char D.28632;
  int D.28633;
  _Bool D.28634;
  _Bool D.28635;
  _Bool D.28636;
  const unsigned char * D.28639;
  unsigned char D.28640;
  int D.28641;
  const unsigned char * D.28642;
  unsigned char D.28643;
  int D.28644;
  _Bool D.28645;
  _Bool D.28646;
  const unsigned char * D.28649;
  unsigned char D.28650;
  int D.28651;
  const unsigned char * D.28652;
  unsigned char D.28653;
  int D.28654;
  _Bool D.28655;
  _Bool D.28656;
  const unsigned char * D.28659;
  unsigned char D.28660;
  int D.28661;
  const unsigned char * D.28662;
  unsigned char D.28663;
  int D.28664;
  int D.28672;
  int D.28674;
  int D.28676;
  struct MonoType * D.28677;
  unsigned int D.28678;
  guint32 D.28681;
  struct MonoClass * klass;
  guint32 token;

  token = 0;
  D.27766 = obj->vtable;
  klass = D.27766->klass;
  D.27769 = klass->image;
  D.27770 = mono_defaults.corlib;
  if (D.27769 != D.27770) goto <D.27767>; else goto <D.27771>;
  <D.27771>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27775 = "TypeDelegator";
      D.27776 = MEM[(const unsigned char *)D.27775];
      D.27777 = (int) D.27776;
      D.27778 = *__s2;
      D.27779 = (int) D.27778;
      __result = D.27777 - D.27779;
      {
        D.27780 = __s2_len != 0;
        D.27781 = __result == 0;
        D.27782 = D.27780 & D.27781;
        if (D.27782 != 0) goto <D.27783>; else goto <D.27784>;
        <D.27783>:
        D.27785 = &MEM[(void *)"TypeDelegator" + 1B];
        D.27786 = *D.27785;
        D.27787 = (int) D.27786;
        D.27788 = __s2 + 1;
        D.27789 = *D.27788;
        D.27790 = (int) D.27789;
        __result = D.27787 - D.27790;
        D.27791 = __s2_len > 1;
        D.27781 = __result == 0;
        D.27792 = D.27791 & D.27781;
        if (D.27792 != 0) goto <D.27793>; else goto <D.27794>;
        <D.27793>:
        D.27795 = &MEM[(void *)"TypeDelegator" + 2B];
        D.27796 = *D.27795;
        D.27797 = (int) D.27796;
        D.27798 = __s2 + 2;
        D.27799 = *D.27798;
        D.27800 = (int) D.27799;
        __result = D.27797 - D.27800;
        D.27801 = __s2_len > 2;
        D.27781 = __result == 0;
        D.27802 = D.27801 & D.27781;
        if (D.27802 != 0) goto <D.27803>; else goto <D.27804>;
        <D.27803>:
        D.27805 = &MEM[(void *)"TypeDelegator" + 3B];
        D.27806 = *D.27805;
        D.27807 = (int) D.27806;
        D.27808 = __s2 + 3;
        D.27809 = *D.27808;
        D.27810 = (int) D.27809;
        __result = D.27807 - D.27810;
        <D.27804>:
        <D.27794>:
        <D.27784>:
      }
      D.20533 = __result;
    }
    iftmp.126 = -D.20533;
    goto <D.27811>;
    <D.27774>:
    D.27812 = klass->name;
    iftmp.126 = __builtin_strcmp (D.27812, "TypeDelegator");
    <D.27811>:
    D.20534 = iftmp.126;
  }
  if (D.20534 == 0) goto <D.27767>; else goto <D.27768>;
  <D.27767>:
  D.27813 = mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported");
  mono_raise_exception (D.27813);
  <D.27768>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

    mb = obj;
    tb = mb->type;
    D.27858 = tb->module;
    D.27859 = D.27858->dynamic_image;
    if (D.27859 == assembly) goto <D.27860>; else goto <D.27856>;
    <D.27860>:
    D.27861 = tb->generic_params;
    if (D.27861 == 0B) goto <D.27862>; else goto <D.27856>;
    <D.27862>:
    D.27863 = mb->generic_params;
    if (D.27863 == 0B) goto <D.27864>; else goto <D.27856>;
    <D.27864>:
    D.27865 = mb->table_idx;
    token = D.27865 | 100663296;
    goto <D.27857>;
    <D.27856>:
    token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
    <D.27857>:
  }
  goto <D.27866>;
  <D.27855>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27870 = "ConstructorBuilder";
      D.27871 = MEM[(const unsigned char *)D.27870];
      D.27872 = (int) D.27871;
      D.27873 = *__s2;
      D.27874 = (int) D.27873;
      __result = D.27872 - D.27874;
      {
        D.27875 = __s2_len != 0;
        D.27876 = __result == 0;
        D.27877 = D.27875 & D.27876;
        if (D.27877 != 0) goto <D.27878>; else goto <D.27879>;
        <D.27878>:
        D.27880 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.27881 = *D.27880;
        D.27882 = (int) D.27881;
        D.27883 = __s2 + 1;
        D.27884 = *D.27883;
        D.27885 = (int) D.27884;
        __result = D.27882 - D.27885;
        D.27886 = __s2_len > 1;
        D.27876 = __result == 0;
        D.27887 = D.27886 & D.27876;
        if (D.27887 != 0) goto <D.27888>; else goto <D.27889>;
        <D.27888>:
        D.27890 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.27891 = *D.27890;
        D.27892 = (int) D.27891;
        D.27893 = __s2 + 2;
        D.27894 = *D.27893;
        D.27895 = (int) D.27894;
        __result = D.27892 - D.27895;
        D.27896 = __s2_len > 2;
        D.27876 = __result == 0;
        D.27897 = D.27896 & D.27876;
        if (D.27897 != 0) goto <D.27898>; else goto <D.27899>;
        <D.27898>:
        D.27900 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.27901 = *D.27900;
        D.27902 = (int) D.27901;
        D.27903 = __s2 + 3;
        D.27904 = *D.27903;
        D.27905 = (int) D.27904;
        __result = D.27902 - D.27905;
        <D.27899>:
        <D.27889>:
        <D.27879>:
      }
      D.20553 = __result;
    }
    iftmp.128 = -D.20553;
    goto <D.27906>;
    <D.27869>:
    D.27812 = klass->name;
    iftmp.128 = __builtin_strcmp (D.27812, "ConstructorBuilder");
    <D.27906>:
    D.20554 = iftmp.128;
  }
  if (D.20554 == 0) goto <D.27907>; else goto <D.27908>;
  <D.27907>:
  {
    struct MonoReflectionCtorBuilder * mb;
    struct MonoReflectionTypeBuilder * tb;

    mb = obj;
    tb = mb->type;
    D.27911 = tb->module;
    D.27912 = D.27911->dynamic_image;
    if (D.27912 == assembly) goto <D.27913>; else goto <D.27909>;
    <D.27913>:
    D.27914 = tb->generic_params;
    if (D.27914 == 0B) goto <D.27915>; else goto <D.27909>;
    <D.27915>:
    D.27916 = mb->table_idx;
    token = D.27916 | 100663296;
    goto <D.27910>;
    <D.27909>:
    token = mono_image_get_ctorbuilder_token (assembly, mb);
    <D.27910>:
  }
  goto <D.27917>;
  <D.27908>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27921 = "FieldBuilder";
      D.27922 = MEM[(const unsigned char *)D.27921];
      D.27923 = (int) D.27922;
      D.27924 = *__s2;
      D.27925 = (int) D.27924;
      __result = D.27923 - D.27925;
      {
        D.27926 = __s2_len != 0;
        D.27927 = __result == 0;
        D.27928 = D.27926 & D.27927;
        if (D.27928 != 0) goto <D.27929>; else goto <D.27930>;
        <D.27929>:
        D.27931 = &MEM[(void *)"FieldBuilder" + 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;
        D.27937 = __s2_len > 1;
        D.27927 = __result == 0;
        D.27938 = D.27937 & D.27927;
        if (D.27938 != 0) goto <D.27939>; else goto <D.27940>;
        <D.27939>:
        D.27941 = &MEM[(void *)"FieldBuilder" + 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;
        D.27947 = __s2_len > 2;
        D.27927 = __result == 0;
        D.27948 = D.27947 & D.27927;
        if (D.27948 != 0) goto <D.27949>; else goto <D.27950>;
        <D.27949>:
        D.27951 = &MEM[(void *)"FieldBuilder" + 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.27940>:
        <D.27930>:
      }
      D.20564 = __result;
    }
    iftmp.129 = -D.20564;
    goto <D.27957>;
    <D.27920>:
    D.27812 = klass->name;
    iftmp.129 = __builtin_strcmp (D.27812, "FieldBuilder");
    <D.27957>:
    D.20565 = iftmp.129;
  }
  if (D.20565 == 0) goto <D.27958>; else goto <D.27959>;
  <D.27958>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoReflectionTypeBuilder * tb;

    fb = obj;
    tb = fb->typeb;
    D.27960 = tb->generic_params;
    if (D.27960 != 0B) goto <D.27961>; else goto <D.27962>;
    <D.27961>:
    token = mono_image_get_generic_field_token (assembly, fb);
    goto <D.27963>;
    <D.27962>:
    D.27964 = tb->module;
    D.27965 = D.27964->dynamic_image;
    if (D.27965 == assembly) goto <D.27966>; else goto <D.27967>;
    <D.27966>:
    D.27968 = fb->table_idx;
    D.27969 = D.27968 | 67108864;
    token = (guint32) D.27969;
    goto <D.27970>;
    <D.27967>:
    D.27971 = fb->handle;
    token = mono_image_get_fieldref_token (assembly, fb, D.27971);
    <D.27970>:
    <D.27963>:
  }
  goto <D.27972>;
  <D.27959>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.27976 = "TypeBuilder";
      D.27977 = MEM[(const unsigned char *)D.27976];
      D.27978 = (int) D.27977;
      D.27979 = *__s2;
      D.27980 = (int) D.27979;
      __result = D.27978 - D.27980;
      {
        D.27981 = __s2_len != 0;
        D.27982 = __result == 0;
        D.27983 = D.27981 & D.27982;
        if (D.27983 != 0) goto <D.27984>; else goto <D.27985>;
        <D.27984>:
        D.27986 = &MEM[(void *)"TypeBuilder" + 1B];
        D.27987 = *D.27986;
        D.27988 = (int) D.27987;
        D.27989 = __s2 + 1;
        D.27990 = *D.27989;
        D.27991 = (int) D.27990;
        __result = D.27988 - D.27991;
        D.27992 = __s2_len > 1;
        D.27982 = __result == 0;
        D.27993 = D.27992 & D.27982;
        if (D.27993 != 0) goto <D.27994>; else goto <D.27995>;
        <D.27994>:
        D.27996 = &MEM[(void *)"TypeBuilder" + 2B];
        D.27997 = *D.27996;
        D.27998 = (int) D.27997;
        D.27999 = __s2 + 2;
        D.28000 = *D.27999;
        D.28001 = (int) D.28000;
        __result = D.27998 - D.28001;
        D.28002 = __s2_len > 2;
        D.27982 = __result == 0;
        D.28003 = D.28002 & D.27982;
        if (D.28003 != 0) goto <D.28004>; else goto <D.28005>;
        <D.28004>:
        D.28006 = &MEM[(void *)"TypeBuilder" + 3B];
        D.28007 = *D.28006;
        D.28008 = (int) D.28007;
        D.28009 = __s2 + 3;
        D.28010 = *D.28009;
        D.28011 = (int) D.28010;
        __result = D.28008 - D.28011;
        <D.28005>:
        <D.27995>:
        <D.27985>:
      }
      D.20575 = __result;
    }
    iftmp.130 = -D.20575;
    goto <D.28012>;
    <D.27975>:
    D.27812 = klass->name;
    iftmp.130 = __builtin_strcmp (D.27812, "TypeBuilder");
    <D.28012>:
    D.20576 = iftmp.130;
  }
  if (D.20576 == 0) goto <D.28013>; else goto <D.28014>;
  <D.28013>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    if (create_open_instance != 0) goto <D.28017>; else goto <D.28015>;
    <D.28017>:
    D.28018 = tb->generic_params;
    if (D.28018 != 0B) goto <D.28019>; else goto <D.28015>;
    <D.28019>:
    {
      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.28016>;
    <D.28015>:
    D.28020 = tb->module;
    D.28021 = D.28020->dynamic_image;
    if (D.28021 == assembly) goto <D.28022>; else goto <D.28023>;
    <D.28022>:
    D.28024 = tb->table_idx;
    token = D.28024 | 33554432;
    goto <D.28025>;
    <D.28023>:
    {
      struct MonoType * type;

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

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

      __s2 = klass->name;
      D.28031 = "MonoType";
      D.28032 = MEM[(const unsigned char *)D.28031];
      D.28033 = (int) D.28032;
      D.28034 = *__s2;
      D.28035 = (int) D.28034;
      __result = D.28033 - D.28035;
      {
        D.28036 = __s2_len != 0;
        D.28037 = __result == 0;
        D.28038 = D.28036 & D.28037;
        if (D.28038 != 0) goto <D.28039>; else goto <D.28040>;
        <D.28039>:
        D.28041 = &MEM[(void *)"MonoType" + 1B];
        D.28042 = *D.28041;
        D.28043 = (int) D.28042;
        D.28044 = __s2 + 1;
        D.28045 = *D.28044;
        D.28046 = (int) D.28045;
        __result = D.28043 - D.28046;
        D.28047 = __s2_len > 1;
        D.28037 = __result == 0;
        D.28048 = D.28047 & D.28037;
        if (D.28048 != 0) goto <D.28049>; else goto <D.28050>;
        <D.28049>:
        D.28051 = &MEM[(void *)"MonoType" + 2B];
        D.28052 = *D.28051;
        D.28053 = (int) D.28052;
        D.28054 = __s2 + 2;
        D.28055 = *D.28054;
        D.28056 = (int) D.28055;
        __result = D.28053 - D.28056;
        D.28057 = __s2_len > 2;
        D.28037 = __result == 0;
        D.28058 = D.28057 & D.28037;
        if (D.28058 != 0) goto <D.28059>; else goto <D.28060>;
        <D.28059>:
        D.28061 = &MEM[(void *)"MonoType" + 3B];
        D.28062 = *D.28061;
        D.28063 = (int) D.28062;
        D.28064 = __s2 + 3;
        D.28065 = *D.28064;
        D.28066 = (int) D.28065;
        __result = D.28063 - D.28066;
        <D.28060>:
        <D.28050>:
        <D.28040>:
      }
      D.20587 = __result;
    }
    iftmp.131 = -D.20587;
    goto <D.28067>;
    <D.28030>:
    D.27812 = klass->name;
    iftmp.131 = __builtin_strcmp (D.27812, "MonoType");
    <D.28067>:
    D.20588 = iftmp.131;
  }
  if (D.20588 == 0) goto <D.28068>; else goto <D.28069>;
  <D.28068>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.28074 = mc->generic_container;
    if (D.28074 == 0B) goto <D.28071>; else goto <D.28075>;
    <D.28075>:
    if (create_open_instance != 0) goto <D.28071>; else goto <D.28072>;
    <D.28071>:
    iftmp.132 = 1;
    goto <D.28073>;
    <D.28072>:
    iftmp.132 = 0;
    <D.28073>:
    D.28076 = mono_image_typedef_or_ref_full (assembly, type, iftmp.132);
    token = mono_metadata_token_from_dor (D.28076);
  }
  goto <D.28077>;
  <D.28069>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28081 = "GenericTypeParameterBuilder";
      D.28082 = MEM[(const unsigned char *)D.28081];
      D.28083 = (int) D.28082;
      D.28084 = *__s2;
      D.28085 = (int) D.28084;
      __result = D.28083 - D.28085;
      {
        D.28086 = __s2_len != 0;
        D.28087 = __result == 0;
        D.28088 = D.28086 & D.28087;
        if (D.28088 != 0) goto <D.28089>; else goto <D.28090>;
        <D.28089>:
        D.28091 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.28092 = *D.28091;
        D.28093 = (int) D.28092;
        D.28094 = __s2 + 1;
        D.28095 = *D.28094;
        D.28096 = (int) D.28095;
        __result = D.28093 - D.28096;
        D.28097 = __s2_len > 1;
        D.28087 = __result == 0;
        D.28098 = D.28097 & D.28087;
        if (D.28098 != 0) goto <D.28099>; else goto <D.28100>;
        <D.28099>:
        D.28101 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.28102 = *D.28101;
        D.28103 = (int) D.28102;
        D.28104 = __s2 + 2;
        D.28105 = *D.28104;
        D.28106 = (int) D.28105;
        __result = D.28103 - D.28106;
        D.28107 = __s2_len > 2;
        D.28087 = __result == 0;
        D.28108 = D.28107 & D.28087;
        if (D.28108 != 0) goto <D.28109>; else goto <D.28110>;
        <D.28109>:
        D.28111 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.28112 = *D.28111;
        D.28113 = (int) D.28112;
        D.28114 = __s2 + 3;
        D.28115 = *D.28114;
        D.28116 = (int) D.28115;
        __result = D.28113 - D.28116;
        <D.28110>:
        <D.28100>:
        <D.28090>:
      }
      D.20598 = __result;
    }
    iftmp.133 = -D.20598;
    goto <D.28117>;
    <D.28080>:
    D.27812 = klass->name;
    iftmp.133 = __builtin_strcmp (D.27812, "GenericTypeParameterBuilder");
    <D.28117>:
    D.20599 = iftmp.133;
  }
  if (D.20599 == 0) goto <D.28118>; else goto <D.28119>;
  <D.28118>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.28120 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28120);
  }
  goto <D.28121>;
  <D.28119>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28125 = "MonoGenericClass";
      D.28126 = MEM[(const unsigned char *)D.28125];
      D.28127 = (int) D.28126;
      D.28128 = *__s2;
      D.28129 = (int) D.28128;
      __result = D.28127 - D.28129;
      {
        D.28130 = __s2_len != 0;
        D.28131 = __result == 0;
        D.28132 = D.28130 & D.28131;
        if (D.28132 != 0) goto <D.28133>; else goto <D.28134>;
        <D.28133>:
        D.28135 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.28136 = *D.28135;
        D.28137 = (int) D.28136;
        D.28138 = __s2 + 1;
        D.28139 = *D.28138;
        D.28140 = (int) D.28139;
        __result = D.28137 - D.28140;
        D.28141 = __s2_len > 1;
        D.28131 = __result == 0;
        D.28142 = D.28141 & D.28131;
        if (D.28142 != 0) goto <D.28143>; else goto <D.28144>;
        <D.28143>:
        D.28145 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.28146 = *D.28145;
        D.28147 = (int) D.28146;
        D.28148 = __s2 + 2;
        D.28149 = *D.28148;
        D.28150 = (int) D.28149;
        __result = D.28147 - D.28150;
        D.28151 = __s2_len > 2;
        D.28131 = __result == 0;
        D.28152 = D.28151 & D.28131;
        if (D.28152 != 0) goto <D.28153>; else goto <D.28154>;
        <D.28153>:
        D.28155 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.28156 = *D.28155;
        D.28157 = (int) D.28156;
        D.28158 = __s2 + 3;
        D.28159 = *D.28158;
        D.28160 = (int) D.28159;
        __result = D.28157 - D.28160;
        <D.28154>:
        <D.28144>:
        <D.28134>:
      }
      D.20608 = __result;
    }
    iftmp.134 = -D.20608;
    goto <D.28161>;
    <D.28124>:
    D.27812 = klass->name;
    iftmp.134 = __builtin_strcmp (D.27812, "MonoGenericClass");
    <D.28161>:
    D.20609 = iftmp.134;
  }
  if (D.20609 == 0) goto <D.28162>; else goto <D.28163>;
  <D.28162>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.28164 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28164);
  }
  goto <D.28165>;
  <D.28163>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28172 = "MonoCMethod";
      D.28173 = MEM[(const unsigned char *)D.28172];
      D.28174 = (int) D.28173;
      D.28175 = *__s2;
      D.28176 = (int) D.28175;
      __result = D.28174 - D.28176;
      {
        D.28177 = __s2_len != 0;
        D.28178 = __result == 0;
        D.28179 = D.28177 & D.28178;
        if (D.28179 != 0) goto <D.28180>; else goto <D.28181>;
        <D.28180>:
        D.28182 = &MEM[(void *)"MonoCMethod" + 1B];
        D.28183 = *D.28182;
        D.28184 = (int) D.28183;
        D.28185 = __s2 + 1;
        D.28186 = *D.28185;
        D.28187 = (int) D.28186;
        __result = D.28184 - D.28187;
        D.28188 = __s2_len > 1;
        D.28178 = __result == 0;
        D.28189 = D.28188 & D.28178;
        if (D.28189 != 0) goto <D.28190>; else goto <D.28191>;
        <D.28190>:
        D.28192 = &MEM[(void *)"MonoCMethod" + 2B];
        D.28193 = *D.28192;
        D.28194 = (int) D.28193;
        D.28195 = __s2 + 2;
        D.28196 = *D.28195;
        D.28197 = (int) D.28196;
        __result = D.28194 - D.28197;
        D.28198 = __s2_len > 2;
        D.28178 = __result == 0;
        D.28199 = D.28198 & D.28178;
        if (D.28199 != 0) goto <D.28200>; else goto <D.28201>;
        <D.28200>:
        D.28202 = &MEM[(void *)"MonoCMethod" + 3B];
        D.28203 = *D.28202;
        D.28204 = (int) D.28203;
        D.28205 = __s2 + 3;
        D.28206 = *D.28205;
        D.28207 = (int) D.28206;
        __result = D.28204 - D.28207;
        <D.28201>:
        <D.28191>:
        <D.28181>:
      }
      D.20618 = __result;
    }
    iftmp.135 = -D.20618;
    goto <D.28208>;
    <D.28171>:
    D.27812 = klass->name;
    iftmp.135 = __builtin_strcmp (D.27812, "MonoCMethod");
    <D.28208>:
    D.20619 = iftmp.135;
  }
  if (D.20619 == 0) goto <D.28166>; else goto <D.28209>;
  <D.28209>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28213 = "MonoMethod";
      D.28214 = MEM[(const unsigned char *)D.28213];
      D.28215 = (int) D.28214;
      D.28216 = *__s2;
      D.28217 = (int) D.28216;
      __result = D.28215 - D.28217;
      {
        D.28218 = __s2_len != 0;
        D.28219 = __result == 0;
        D.28220 = D.28218 & D.28219;
        if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
        <D.28221>:
        D.28223 = &MEM[(void *)"MonoMethod" + 1B];
        D.28224 = *D.28223;
        D.28225 = (int) D.28224;
        D.28226 = __s2 + 1;
        D.28227 = *D.28226;
        D.28228 = (int) D.28227;
        __result = D.28225 - D.28228;
        D.28229 = __s2_len > 1;
        D.28219 = __result == 0;
        D.28230 = D.28229 & D.28219;
        if (D.28230 != 0) goto <D.28231>; else goto <D.28232>;
        <D.28231>:
        D.28233 = &MEM[(void *)"MonoMethod" + 2B];
        D.28234 = *D.28233;
        D.28235 = (int) D.28234;
        D.28236 = __s2 + 2;
        D.28237 = *D.28236;
        D.28238 = (int) D.28237;
        __result = D.28235 - D.28238;
        D.28239 = __s2_len > 2;
        D.28219 = __result == 0;
        D.28240 = D.28239 & D.28219;
        if (D.28240 != 0) goto <D.28241>; else goto <D.28242>;
        <D.28241>:
        D.28243 = &MEM[(void *)"MonoMethod" + 3B];
        D.28244 = *D.28243;
        D.28245 = (int) D.28244;
        D.28246 = __s2 + 3;
        D.28247 = *D.28246;
        D.28248 = (int) D.28247;
        __result = D.28245 - D.28248;
        <D.28242>:
        <D.28232>:
        <D.28222>:
      }
      D.20627 = __result;
    }
    iftmp.136 = -D.20627;
    goto <D.28249>;
    <D.28212>:
    D.27812 = klass->name;
    iftmp.136 = __builtin_strcmp (D.27812, "MonoMethod");
    <D.28249>:
    D.20628 = iftmp.136;
  }
  if (D.20628 == 0) goto <D.28166>; else goto <D.28250>;
  <D.28250>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28254 = "MonoGenericMethod";
      D.28255 = MEM[(const unsigned char *)D.28254];
      D.28256 = (int) D.28255;
      D.28257 = *__s2;
      D.28258 = (int) D.28257;
      __result = D.28256 - D.28258;
      {
        D.28259 = __s2_len != 0;
        D.28260 = __result == 0;
        D.28261 = D.28259 & D.28260;
        if (D.28261 != 0) goto <D.28262>; else goto <D.28263>;
        <D.28262>:
        D.28264 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.28265 = *D.28264;
        D.28266 = (int) D.28265;
        D.28267 = __s2 + 1;
        D.28268 = *D.28267;
        D.28269 = (int) D.28268;
        __result = D.28266 - D.28269;
        D.28270 = __s2_len > 1;
        D.28260 = __result == 0;
        D.28271 = D.28270 & D.28260;
        if (D.28271 != 0) goto <D.28272>; else goto <D.28273>;
        <D.28272>:
        D.28274 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.28275 = *D.28274;
        D.28276 = (int) D.28275;
        D.28277 = __s2 + 2;
        D.28278 = *D.28277;
        D.28279 = (int) D.28278;
        __result = D.28276 - D.28279;
        D.28280 = __s2_len > 2;
        D.28260 = __result == 0;
        D.28281 = D.28280 & D.28260;
        if (D.28281 != 0) goto <D.28282>; else goto <D.28283>;
        <D.28282>:
        D.28284 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.28285 = *D.28284;
        D.28286 = (int) D.28285;
        D.28287 = __s2 + 3;
        D.28288 = *D.28287;
        D.28289 = (int) D.28288;
        __result = D.28286 - D.28289;
        <D.28283>:
        <D.28273>:
        <D.28263>:
      }
      D.20636 = __result;
    }
    iftmp.137 = -D.20636;
    goto <D.28290>;
    <D.28253>:
    D.27812 = klass->name;
    iftmp.137 = __builtin_strcmp (D.27812, "MonoGenericMethod");
    <D.28290>:
    D.20637 = iftmp.137;
  }
  if (D.20637 == 0) goto <D.28166>; else goto <D.28291>;
  <D.28291>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28295 = "MonoGenericCMethod";
      D.28296 = MEM[(const unsigned char *)D.28295];
      D.28297 = (int) D.28296;
      D.28298 = *__s2;
      D.28299 = (int) D.28298;
      __result = D.28297 - D.28299;
      {
        D.28300 = __s2_len != 0;
        D.28301 = __result == 0;
        D.28302 = D.28300 & D.28301;
        if (D.28302 != 0) goto <D.28303>; else goto <D.28304>;
        <D.28303>:
        D.28305 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.28306 = *D.28305;
        D.28307 = (int) D.28306;
        D.28308 = __s2 + 1;
        D.28309 = *D.28308;
        D.28310 = (int) D.28309;
        __result = D.28307 - D.28310;
        D.28311 = __s2_len > 1;
        D.28301 = __result == 0;
        D.28312 = D.28311 & D.28301;
        if (D.28312 != 0) goto <D.28313>; else goto <D.28314>;
        <D.28313>:
        D.28315 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.28316 = *D.28315;
        D.28317 = (int) D.28316;
        D.28318 = __s2 + 2;
        D.28319 = *D.28318;
        D.28320 = (int) D.28319;
        __result = D.28317 - D.28320;
        D.28321 = __s2_len > 2;
        D.28301 = __result == 0;
        D.28322 = D.28321 & D.28301;
        if (D.28322 != 0) goto <D.28323>; else goto <D.28324>;
        <D.28323>:
        D.28325 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.28326 = *D.28325;
        D.28327 = (int) D.28326;
        D.28328 = __s2 + 3;
        D.28329 = *D.28328;
        D.28330 = (int) D.28329;
        __result = D.28327 - D.28330;
        <D.28324>:
        <D.28314>:
        <D.28304>:
      }
      D.20645 = __result;
    }
    iftmp.138 = -D.20645;
    goto <D.28331>;
    <D.28294>:
    D.27812 = klass->name;
    iftmp.138 = __builtin_strcmp (D.27812, "MonoGenericCMethod");
    <D.28331>:
    D.20646 = iftmp.138;
  }
  if (D.20646 == 0) goto <D.28166>; else goto <D.28167>;
  <D.28166>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.28332 = m->method;
    D.28333 = BIT_FIELD_REF <*D.28332, 8, 264>;
    D.28334 = D.28333 & 16;
    if (D.28334 != 0) goto <D.28335>; else goto <D.28336>;
    <D.28335>:
    if (create_open_instance != 0) goto <D.28337>; else goto <D.28338>;
    <D.28337>:
    D.28332 = m->method;
    token = mono_image_get_methodspec_token (assembly, D.28332);
    goto <D.28339>;
    <D.28338>:
    D.28332 = m->method;
    token = mono_image_get_inflated_method_token (assembly, D.28332);
    <D.28339>:
    goto <D.28340>;
    <D.28336>:
    D.28332 = m->method;
    D.28343 = D.28332->klass;
    D.28344 = D.28343->image;
    D.28345 = &assembly->image;
    if (D.28344 == D.28345) goto <D.28346>; else goto <D.28341>;
    <D.28346>:
    D.28332 = m->method;
    D.28343 = D.28332->klass;
    D.28347 = D.28343->generic_class;
    if (D.28347 == 0B) goto <D.28348>; else goto <D.28341>;
    <D.28348>:
    {
      static guint32 method_table_idx = 16777215;

      D.28332 = m->method;
      D.28343 = D.28332->klass;
      D.28349 = BIT_FIELD_REF <*D.28343, 8, 256>;
      D.28350 = D.28349 & 128;
      if (D.28350 != 0) goto <D.28351>; else goto <D.28352>;
      <D.28351>:
      D.28332 = m->method;
      token = D.28332->token;
      goto <D.28353>;
      <D.28352>:
      method_table_idx.139 = method_table_idx;
      method_table_idx.140 = method_table_idx.139 + 4294967295;
      method_table_idx = method_table_idx.140;
      method_table_idx.139 = method_table_idx;
      token = method_table_idx.139 | 100663296;
      <D.28353>:
    }
    goto <D.28342>;
    <D.28341>:
    D.28332 = m->method;
    token = mono_image_get_methodref_token (assembly, D.28332, create_open_instance);
    <D.28342>:
    <D.28340>:
  }
  goto <D.28168>;
  <D.28167>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28359 = "MonoField";
      D.28360 = MEM[(const unsigned char *)D.28359];
      D.28361 = (int) D.28360;
      D.28362 = *__s2;
      D.28363 = (int) D.28362;
      __result = D.28361 - D.28363;
      {
        D.28364 = __s2_len != 0;
        D.28365 = __result == 0;
        D.28366 = D.28364 & D.28365;
        if (D.28366 != 0) goto <D.28367>; else goto <D.28368>;
        <D.28367>:
        D.28369 = &MEM[(void *)"MonoField" + 1B];
        D.28370 = *D.28369;
        D.28371 = (int) D.28370;
        D.28372 = __s2 + 1;
        D.28373 = *D.28372;
        D.28374 = (int) D.28373;
        __result = D.28371 - D.28374;
        D.28375 = __s2_len > 1;
        D.28365 = __result == 0;
        D.28376 = D.28375 & D.28365;
        if (D.28376 != 0) goto <D.28377>; else goto <D.28378>;
        <D.28377>:
        D.28379 = &MEM[(void *)"MonoField" + 2B];
        D.28380 = *D.28379;
        D.28381 = (int) D.28380;
        D.28382 = __s2 + 2;
        D.28383 = *D.28382;
        D.28384 = (int) D.28383;
        __result = D.28381 - D.28384;
        D.28385 = __s2_len > 2;
        D.28365 = __result == 0;
        D.28386 = D.28385 & D.28365;
        if (D.28386 != 0) goto <D.28387>; else goto <D.28388>;
        <D.28387>:
        D.28389 = &MEM[(void *)"MonoField" + 3B];
        D.28390 = *D.28389;
        D.28391 = (int) D.28390;
        D.28392 = __s2 + 3;
        D.28393 = *D.28392;
        D.28394 = (int) D.28393;
        __result = D.28391 - D.28394;
        <D.28388>:
        <D.28378>:
        <D.28368>:
      }
      D.20656 = __result;
    }
    iftmp.141 = -D.20656;
    goto <D.28395>;
    <D.28358>:
    D.27812 = klass->name;
    iftmp.141 = __builtin_strcmp (D.27812, "MonoField");
    <D.28395>:
    D.20657 = iftmp.141;
  }
  if (D.20657 == 0) goto <D.28396>; else goto <D.28397>;
  <D.28396>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.28400 = f->field;
    D.28401 = D.28400->parent;
    D.28402 = D.28401->image;
    D.28345 = &assembly->image;
    if (D.28402 == D.28345) goto <D.28403>; else goto <D.28398>;
    <D.28403>:
    D.28400 = f->field;
    D.28404 = is_field_on_inst (D.28400);
    if (D.28404 == 0) goto <D.28405>; else goto <D.28398>;
    <D.28405>:
    {
      static guint32 field_table_idx = 16777215;

      field_table_idx.142 = field_table_idx;
      field_table_idx.143 = field_table_idx.142 + 4294967295;
      field_table_idx = field_table_idx.143;
      field_table_idx.142 = field_table_idx;
      token = field_table_idx.142 | 67108864;
    }
    goto <D.28399>;
    <D.28398>:
    D.28400 = f->field;
    token = mono_image_get_fieldref_token (assembly, f, D.28400);
    <D.28399>:
  }
  goto <D.28408>;
  <D.28397>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28412 = "MonoArrayMethod";
      D.28413 = MEM[(const unsigned char *)D.28412];
      D.28414 = (int) D.28413;
      D.28415 = *__s2;
      D.28416 = (int) D.28415;
      __result = D.28414 - D.28416;
      {
        D.28417 = __s2_len != 0;
        D.28418 = __result == 0;
        D.28419 = D.28417 & D.28418;
        if (D.28419 != 0) goto <D.28420>; else goto <D.28421>;
        <D.28420>:
        D.28422 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.28423 = *D.28422;
        D.28424 = (int) D.28423;
        D.28425 = __s2 + 1;
        D.28426 = *D.28425;
        D.28427 = (int) D.28426;
        __result = D.28424 - D.28427;
        D.28428 = __s2_len > 1;
        D.28418 = __result == 0;
        D.28429 = D.28428 & D.28418;
        if (D.28429 != 0) goto <D.28430>; else goto <D.28431>;
        <D.28430>:
        D.28432 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.28433 = *D.28432;
        D.28434 = (int) D.28433;
        D.28435 = __s2 + 2;
        D.28436 = *D.28435;
        D.28437 = (int) D.28436;
        __result = D.28434 - D.28437;
        D.28438 = __s2_len > 2;
        D.28418 = __result == 0;
        D.28439 = D.28438 & D.28418;
        if (D.28439 != 0) goto <D.28440>; else goto <D.28441>;
        <D.28440>:
        D.28442 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.28443 = *D.28442;
        D.28444 = (int) D.28443;
        D.28445 = __s2 + 3;
        D.28446 = *D.28445;
        D.28447 = (int) D.28446;
        __result = D.28444 - D.28447;
        <D.28441>:
        <D.28431>:
        <D.28421>:
      }
      D.20667 = __result;
    }
    iftmp.144 = -D.20667;
    goto <D.28448>;
    <D.28411>:
    D.27812 = klass->name;
    iftmp.144 = __builtin_strcmp (D.27812, "MonoArrayMethod");
    <D.28448>:
    D.20668 = iftmp.144;
  }
  if (D.20668 == 0) goto <D.28449>; else goto <D.28450>;
  <D.28449>:
  {
    struct MonoReflectionArrayMethod * m;

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

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

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

    s = obj;
    D.28494 = mono_image_get_sighelper_token (assembly, s);
    token = D.28494 | 285212672;
  }
  goto <D.28495>;
  <D.28493>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28499 = "EnumBuilder";
      D.28500 = MEM[(const unsigned char *)D.28499];
      D.28501 = (int) D.28500;
      D.28502 = *__s2;
      D.28503 = (int) D.28502;
      __result = D.28501 - D.28503;
      {
        D.28504 = __s2_len != 0;
        D.28505 = __result == 0;
        D.28506 = D.28504 & D.28505;
        if (D.28506 != 0) goto <D.28507>; else goto <D.28508>;
        <D.28507>:
        D.28509 = &MEM[(void *)"EnumBuilder" + 1B];
        D.28510 = *D.28509;
        D.28511 = (int) D.28510;
        D.28512 = __s2 + 1;
        D.28513 = *D.28512;
        D.28514 = (int) D.28513;
        __result = D.28511 - D.28514;
        D.28515 = __s2_len > 1;
        D.28505 = __result == 0;
        D.28516 = D.28515 & D.28505;
        if (D.28516 != 0) goto <D.28517>; else goto <D.28518>;
        <D.28517>:
        D.28519 = &MEM[(void *)"EnumBuilder" + 2B];
        D.28520 = *D.28519;
        D.28521 = (int) D.28520;
        D.28522 = __s2 + 2;
        D.28523 = *D.28522;
        D.28524 = (int) D.28523;
        __result = D.28521 - D.28524;
        D.28525 = __s2_len > 2;
        D.28505 = __result == 0;
        D.28526 = D.28525 & D.28505;
        if (D.28526 != 0) goto <D.28527>; else goto <D.28528>;
        <D.28527>:
        D.28529 = &MEM[(void *)"EnumBuilder" + 3B];
        D.28530 = *D.28529;
        D.28531 = (int) D.28530;
        D.28532 = __s2 + 3;
        D.28533 = *D.28532;
        D.28534 = (int) D.28533;
        __result = D.28531 - D.28534;
        <D.28528>:
        <D.28518>:
        <D.28508>:
      }
      D.20687 = __result;
    }
    iftmp.146 = -D.20687;
    goto <D.28535>;
    <D.28498>:
    D.27812 = klass->name;
    iftmp.146 = __builtin_strcmp (D.27812, "EnumBuilder");
    <D.28535>:
    D.20688 = iftmp.146;
  }
  if (D.20688 == 0) goto <D.28536>; else goto <D.28537>;
  <D.28536>:
  {
    struct MonoType * type;

    type = mono_reflection_type_get_handle (obj);
    D.28538 = mono_image_typedef_or_ref (assembly, type);
    token = mono_metadata_token_from_dor (D.28538);
  }
  goto <D.28539>;
  <D.28537>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.28543 = "FieldOnTypeBuilderInst";
      D.28544 = MEM[(const unsigned char *)D.28543];
      D.28545 = (int) D.28544;
      D.28546 = *__s2;
      D.28547 = (int) D.28546;
      __result = D.28545 - D.28547;
      {
        D.28548 = __s2_len != 0;
        D.28549 = __result == 0;
        D.28550 = D.28548 & D.28549;
        if (D.28550 != 0) goto <D.28551>; else goto <D.28552>;
        <D.28551>:
        D.28553 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.28554 = *D.28553;
        D.28555 = (int) D.28554;
        D.28556 = __s2 + 1;
        D.28557 = *D.28556;
        D.28558 = (int) D.28557;
        __result = D.28555 - D.28558;
        D.28559 = __s2_len > 1;
        D.28549 = __result == 0;
        D.28560 = D.28559 & D.28549;
        if (D.28560 != 0) goto <D.28561>; else goto <D.28562>;
        <D.28561>:
        D.28563 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.28564 = *D.28563;
        D.28565 = (int) D.28564;
        D.28566 = __s2 + 2;
        D.28567 = *D.28566;
        D.28568 = (int) D.28567;
        __result = D.28565 - D.28568;
        D.28569 = __s2_len > 2;
        D.28549 = __result == 0;
        D.28570 = D.28569 & D.28549;
        if (D.28570 != 0) goto <D.28571>; else goto <D.28572>;
        <D.28571>:
        D.28573 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.28574 = *D.28573;
        D.28575 = (int) D.28574;
        D.28576 = __s2 + 3;
        D.28577 = *D.28576;
        D.28578 = (int) D.28577;
        __result = D.28575 - D.28578;
        <D.28572>:
        <D.28562>:
        <D.28552>:
      }
      D.20697 = __result;
    }
    iftmp.147 = -D.20697;
    goto <D.28579>;
    <D.28542>:
    D.27812 = klass->name;
    iftmp.147 = __builtin_strcmp (D.27812, "FieldOnTypeBuilderInst");
    <D.28579>:
    D.20698 = iftmp.147;
  }
  if (D.20698 == 0) goto <D.28580>; else goto <D.28581>;
  <D.28580>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;

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

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

      __s2 = klass->name;
      D.28586 = "ConstructorOnTypeBuilderInst";
      D.28587 = MEM[(const unsigned char *)D.28586];
      D.28588 = (int) D.28587;
      D.28589 = *__s2;
      D.28590 = (int) D.28589;
      __result = D.28588 - D.28590;
      {
        D.28591 = __s2_len != 0;
        D.28592 = __result == 0;
        D.28593 = D.28591 & D.28592;
        if (D.28593 != 0) goto <D.28594>; else goto <D.28595>;
        <D.28594>:
        D.28596 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.28597 = *D.28596;
        D.28598 = (int) D.28597;
        D.28599 = __s2 + 1;
        D.28600 = *D.28599;
        D.28601 = (int) D.28600;
        __result = D.28598 - D.28601;
        D.28602 = __s2_len > 1;
        D.28592 = __result == 0;
        D.28603 = D.28602 & D.28592;
        if (D.28603 != 0) goto <D.28604>; else goto <D.28605>;
        <D.28604>:
        D.28606 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.28607 = *D.28606;
        D.28608 = (int) D.28607;
        D.28609 = __s2 + 2;
        D.28610 = *D.28609;
        D.28611 = (int) D.28610;
        __result = D.28608 - D.28611;
        D.28612 = __s2_len > 2;
        D.28592 = __result == 0;
        D.28613 = D.28612 & D.28592;
        if (D.28613 != 0) goto <D.28614>; else goto <D.28615>;
        <D.28614>:
        D.28616 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.28617 = *D.28616;
        D.28618 = (int) D.28617;
        D.28619 = __s2 + 3;
        D.28620 = *D.28619;
        D.28621 = (int) D.28620;
        __result = D.28618 - D.28621;
        <D.28615>:
        <D.28605>:
        <D.28595>:
      }
      D.20707 = __result;
    }
    iftmp.148 = -D.20707;
    goto <D.28622>;
    <D.28585>:
    D.27812 = klass->name;
    iftmp.148 = __builtin_strcmp (D.27812, "ConstructorOnTypeBuilderInst");
    <D.28622>:
    D.20708 = iftmp.148;
  }
  if (D.20708 == 0) goto <D.28623>; else goto <D.28624>;
  <D.28623>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;

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

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

      __s2 = klass->name;
      D.28629 = "MethodOnTypeBuilderInst";
      D.28630 = MEM[(const unsigned char *)D.28629];
      D.28631 = (int) D.28630;
      D.28632 = *__s2;
      D.28633 = (int) D.28632;
      __result = D.28631 - D.28633;
      {
        D.28634 = __s2_len != 0;
        D.28635 = __result == 0;
        D.28636 = D.28634 & D.28635;
        if (D.28636 != 0) goto <D.28637>; else goto <D.28638>;
        <D.28637>:
        D.28639 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.28640 = *D.28639;
        D.28641 = (int) D.28640;
        D.28642 = __s2 + 1;
        D.28643 = *D.28642;
        D.28644 = (int) D.28643;
        __result = D.28641 - D.28644;
        D.28645 = __s2_len > 1;
        D.28635 = __result == 0;
        D.28646 = D.28645 & D.28635;
        if (D.28646 != 0) goto <D.28647>; else goto <D.28648>;
        <D.28647>:
        D.28649 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.28650 = *D.28649;
        D.28651 = (int) D.28650;
        D.28652 = __s2 + 2;
        D.28653 = *D.28652;
        D.28654 = (int) D.28653;
        __result = D.28651 - D.28654;
        D.28655 = __s2_len > 2;
        D.28635 = __result == 0;
        D.28656 = D.28655 & D.28635;
        if (D.28656 != 0) goto <D.28657>; else goto <D.28658>;
        <D.28657>:
        D.28659 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.28660 = *D.28659;
        D.28661 = (int) D.28660;
        D.28662 = __s2 + 3;
        D.28663 = *D.28662;
        D.28664 = (int) D.28663;
        __result = D.28661 - D.28664;
        <D.28658>:
        <D.28648>:
        <D.28638>:
      }
      D.20717 = __result;
    }
    iftmp.149 = -D.20717;
    goto <D.28665>;
    <D.28628>:
    D.27812 = klass->name;
    iftmp.149 = __builtin_strcmp (D.27812, "MethodOnTypeBuilderInst");
    <D.28665>:
    D.20718 = iftmp.149;
  }
  if (D.20718 == 0) goto <D.28666>; else goto <D.28667>;
  <D.28666>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
  }
  goto <D.28668>;
  <D.28667>:
  D.28672 = is_sre_array (klass);
  if (D.28672 != 0) goto <D.28669>; else goto <D.28673>;
  <D.28673>:
  D.28674 = is_sre_byref (klass);
  if (D.28674 != 0) goto <D.28669>; else goto <D.28675>;
  <D.28675>:
  D.28676 = is_sre_pointer (klass);
  if (D.28676 != 0) goto <D.28669>; else goto <D.28670>;
  <D.28669>:
  {
    struct MonoReflectionType * type;

    type = obj;
    D.28677 = mono_reflection_type_get_handle (type);
    D.28678 = mono_image_typedef_or_ref (assembly, D.28677);
    token = mono_metadata_token_from_dor (D.28678);
  }
  goto <D.28671>;
  <D.28670>:
  D.27812 = klass->name;
  monoeg_g_log (0B, 4, "requested token for %s\n", D.27812);
  <D.20721>:
  goto <D.20721>;
  <D.28671>:
  <D.28668>:
  <D.28625>:
  <D.28582>:
  <D.28539>:
  <D.28495>:
  <D.28451>:
  <D.28408>:
  <D.28168>:
  <D.28165>:
  <D.28121>:
  <D.28077>:
  <D.28027>:
  <D.27972>:
  <D.27917>:
  <D.27866>:
  if (register_token != 0) goto <D.28679>; else goto <D.28680>;
  <D.28679>:
  mono_image_register_token (assembly, token, obj);
  <D.28680>:
  D.28681 = token;
  return D.28681;
}


mono_image_get_methodbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb, gboolean create_methodspec)
{
  struct MonoArray * D.28683;
  guint32 D.28688;
  struct MonoGHashTable * D.28689;
  void * D.28690;
  long int D.28691;
  long unsigned int D.28694;
  void * D.28695;
  guint32 token;

  D.28683 = mb->generic_params;
  if (D.28683 != 0B) goto <D.28684>; else goto <D.28685>;
  <D.28684>:
  if (create_methodspec != 0) goto <D.28686>; else goto <D.28687>;
  <D.28686>:
  D.28688 = mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
  return D.28688;
  <D.28687>:
  <D.28685>:
  D.28689 = assembly->handleref_managed;
  D.28690 = mono_g_hash_table_lookup (D.28689, mb);
  D.28691 = (long int) D.28690;
  token = (guint32) D.28691;
  if (token != 0) goto <D.28692>; else goto <D.28693>;
  <D.28692>:
  D.28688 = token;
  return D.28688;
  <D.28693>:
  token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.28694 = (long unsigned int) token;
  D.28695 = (void *) D.28694;
  D.28689 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28689, mb, D.28695);
  D.28688 = token;
  return D.28688;
}


mono_image_get_methodspec_token_for_generic_method_definition (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoGHashTable * D.28697;
  void * D.28698;
  long int D.28699;
  guint32 D.28702;
  unsigned int D.28703;
  unsigned int D.28704;
  unsigned int D.28705;
  int D.28706;
  unsigned int D.28709;
  unsigned int D.28710;
  guint32 * D.28711;
  unsigned int D.28712;
  unsigned int D.28713;
  long unsigned int D.28714;
  long unsigned int D.28715;
  guint32 * D.28716;
  unsigned int D.28717;
  unsigned int D.28718;
  long unsigned int D.28719;
  void * D.28720;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;

  mtoken = 0;
  D.28697 = assembly->methodspec;
  D.28698 = mono_g_hash_table_lookup (D.28697, mb);
  D.28699 = (long int) D.28698;
  token = (guint32) D.28699;
  if (token != 0) goto <D.28700>; else goto <D.28701>;
  <D.28700>:
  D.28702 = token;
  return D.28702;
  <D.28701>:
  table = &assembly->tables[43];
  mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
  D.28703 = mtoken >> 24;
  switch (D.28703) <default: <D.19463>, case 6: <D.19462>, case 10: <D.19460>>
  <D.19460>:
  D.28704 = mtoken & 16777215;
  D.28705 = D.28704 << 1;
  mtoken = D.28705 | 1;
  goto <D.19461>;
  <D.19462>:
  D.28704 = mtoken & 16777215;
  mtoken = D.28704 << 1;
  goto <D.19461>;
  <D.19463>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2637);
  <D.19461>:
  D.28706 = assembly->save;
  if (D.28706 != 0) goto <D.28707>; else goto <D.28708>;
  <D.28707>:
  D.28709 = table->rows;
  D.28710 = D.28709 + 1;
  alloc_table (table, D.28710);
  D.28711 = table->values;
  D.28712 = table->next_idx;
  D.28713 = D.28712 * 2;
  D.28714 = (long unsigned int) D.28713;
  D.28715 = D.28714 * 4;
  values = D.28711 + D.28715;
  *values = mtoken;
  D.28716 = values + 4;
  D.28717 = encode_generic_method_definition_sig (assembly, mb);
  *D.28716 = D.28717;
  <D.28708>:
  D.28712 = table->next_idx;
  token = D.28712 | 721420288;
  D.28712 = table->next_idx;
  D.28718 = D.28712 + 1;
  table->next_idx = D.28718;
  D.28719 = (long unsigned int) token;
  D.28720 = (void *) D.28719;
  D.28697 = assembly->methodspec;
  mono_g_hash_table_insert (D.28697, mb, D.28720);
  D.28702 = token;
  return D.28702;
}


encode_generic_method_definition_sig (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoArray * D.28722;
  long unsigned int D.28723;
  int D.28724;
  guint32 D.28727;
  unsigned int i.150;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.28722 = mb->generic_params;
      D.28723 = mono_array_length (D.28722);
      nparams = (guint32) D.28723;
      D.28724 = assembly->save;
      if (D.28724 == 0) goto <D.28725>; else goto <D.28726>;
      <D.28725>:
      D.28727 = 0;
      return D.28727;
      <D.28726>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19450>;
      <D.19449>:
      sigbuffer_add_value (&buf, 30);
      i.150 = (unsigned int) i;
      sigbuffer_add_value (&buf, i.150);
      i = i + 1;
      <D.19450>:
      i.150 = (unsigned int) i;
      if (i.150 < nparams) goto <D.19449>; else goto <D.19451>;
      <D.19451>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28727 = idx;
      return D.28727;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodref_token_for_methodbuilder (struct MonoDynamicImage * assembly, struct MonoReflectionMethodBuilder * method)
{
  struct GHashTable * D.28731;
  void * D.28732;
  long int D.28733;
  guint32 D.28736;
  struct MonoString * D.28737;
  unsigned int D.28738;
  unsigned int D.28739;
  _Bool D.28740;
  _Bool D.28741;
  _Bool D.28742;
  unsigned int D.28745;
  struct MonoArray * D.28746;
  struct MonoObject * D.28750;
  struct MonoType * D.28751;
  long unsigned int D.28752;
  void * D.28753;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = method->type;
      D.28731 = assembly->handleref;
      D.28732 = monoeg_g_hash_table_lookup (D.28731, method);
      D.28733 = (long int) D.28732;
      token = (guint32) D.28733;
      if (token != 0) goto <D.28734>; else goto <D.28735>;
      <D.28734>:
      D.28736 = token;
      return D.28736;
      <D.28735>:
      D.28737 = method->name;
      name = mono_string_to_utf8 (D.28737);
      reflection_methodbuilder_from_method_builder (&rmb, method);
      D.28738 = rmb.call_conv;
      D.28739 = D.28738 & 4294967199;
      D.28740 = D.28739 != 0;
      D.28741 = D.28739 != 5;
      D.28742 = D.28740 & D.28741;
      if (D.28742 != 0) goto <D.28743>; else goto <D.28744>;
      <D.28743>:
      D.28738 = rmb.call_conv;
      D.28745 = D.28738 & 96;
      rmb.call_conv = D.28745;
      <D.28744>:
      sig = method_builder_encode_signature (assembly, &rmb);
      D.28746 = tb->generic_params;
      if (D.28746 != 0B) goto <D.28747>; else goto <D.28748>;
      <D.28747>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28749>;
      <D.28748>:
      D.28750 = rmb.type;
      D.28751 = mono_reflection_type_get_handle (D.28750);
      parent = mono_image_typedef_or_ref (assembly, D.28751);
      <D.28749>:
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.28752 = (long unsigned int) token;
      D.28753 = (void *) D.28752;
      D.28731 = assembly->handleref;
      monoeg_g_hash_table_insert_replace (D.28731, method, D.28753, 0);
      D.28736 = token;
      return D.28736;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


create_generic_typespec (struct MonoDynamicImage * assembly, struct MonoReflectionTypeBuilder * tb)
{
  struct GHashTable * D.28756;
  void * D.28757;
  long int D.28758;
  guint32 D.28761;
  struct MonoArray * D.28762;
  _Bool D.28763;
  long int D.28764;
  long int D.28765;
  struct MonoGenericContainer * D.28768;
  struct MonoGenericContainer * D.28771;
  _Bool D.28772;
  long int D.28773;
  long int D.28774;
  unsigned char D.28777;
  unsigned int D.28778;
  struct MonoType * D.28779;
  unsigned int D.28780;
  long unsigned int D.28781;
  unsigned int count.151;
  long unsigned int D.28783;
  char * D.28784;
  struct MonoType * D.28785;
  int D.28786;
  unsigned int D.28789;
  unsigned int D.28790;
  guint32 * D.28791;
  unsigned int D.28792;
  long unsigned int D.28793;
  long unsigned int D.28794;
  unsigned int D.28795;
  long unsigned int D.28796;
  void * D.28797;
  unsigned int D.28798;
  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.28756 = assembly->typespec;
      D.28757 = monoeg_g_hash_table_lookup (D.28756, type);
      D.28758 = (long int) D.28757;
      token = (guint32) D.28758;
      if (token != 0) goto <D.28759>; else goto <D.28760>;
      <D.28759>:
      D.28761 = token;
      return D.28761;
      <D.28760>:
      sigbuffer_init (&buf, 32);
      D.28762 = tb->generic_params;
      D.28763 = D.28762 == 0B;
      D.28764 = (long int) D.28763;
      D.28765 = __builtin_expect (D.28764, 0);
      if (D.28765 != 0) goto <D.28766>; else goto <D.28767>;
      <D.28766>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3096, "tb->generic_params");
      <D.28767>:
      klass = mono_class_from_mono_type (type);
      D.28768 = tb->generic_container;
      if (D.28768 != 0B) goto <D.28769>; else goto <D.28770>;
      <D.28769>:
      mono_reflection_create_generic_class (tb);
      <D.28770>:
      sigbuffer_add_value (&buf, 21);
      D.28771 = klass->generic_container;
      D.28772 = D.28771 == 0B;
      D.28773 = (long int) D.28772;
      D.28774 = __builtin_expect (D.28773, 0);
      if (D.28774 != 0) goto <D.28775>; else goto <D.28776>;
      <D.28775>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3103, "klass->generic_container");
      <D.28776>:
      D.28777 = klass->byval_arg.type;
      D.28778 = (unsigned int) D.28777;
      sigbuffer_add_value (&buf, D.28778);
      D.28779 = &klass->byval_arg;
      D.28780 = mono_image_typedef_or_ref_full (assembly, D.28779, 0);
      sigbuffer_add_value (&buf, D.28780);
      D.28762 = tb->generic_params;
      D.28781 = mono_array_length (D.28762);
      count = (int) D.28781;
      count.151 = (unsigned int) count;
      sigbuffer_add_value (&buf, count.151);
      i = 0;
      goto <D.19616>;
      <D.19615>:
      {
        struct MonoReflectionGenericParam * gparam;

        D.28783 = (long unsigned int) i;
        D.28762 = tb->generic_params;
        D.28784 = mono_array_addr_with_size (D.28762, 8, D.28783);
        gparam = MEM[(struct MonoReflectionGenericParam * *)D.28784];
        D.28785 = mono_reflection_type_get_handle (gparam);
        encode_type (assembly, D.28785, &buf);
      }
      i = i + 1;
      <D.19616>:
      if (i < count) goto <D.19615>; else goto <D.19617>;
      <D.19617>:
      table = &assembly->tables[27];
      D.28786 = assembly->save;
      if (D.28786 != 0) goto <D.28787>; else goto <D.28788>;
      <D.28787>:
      token = sigbuffer_add_to_blob_cached (assembly, &buf);
      D.28789 = table->rows;
      D.28790 = D.28789 + 1;
      alloc_table (table, D.28790);
      D.28791 = table->values;
      D.28792 = table->next_idx;
      D.28793 = (long unsigned int) D.28792;
      D.28794 = D.28793 * 4;
      values = D.28791 + D.28794;
      *values = token;
      <D.28788>:
      sigbuffer_free (&buf);
      D.28792 = table->next_idx;
      D.28795 = D.28792 << 2;
      token = D.28795 | 2;
      D.28796 = (long unsigned int) token;
      D.28797 = (void *) D.28796;
      D.28756 = assembly->typespec;
      monoeg_g_hash_table_insert_replace (D.28756, type, D.28797, 0);
      D.28792 = table->next_idx;
      D.28798 = D.28792 + 1;
      table->next_idx = D.28798;
      D.28761 = token;
      return D.28761;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_add_memberef_row (struct MonoDynamicImage * assembly, guint32 parent, const char * name, guint32 sig)
{
  unsigned int D.28801;
  guint32 D.28802;
  int D.28803;
  unsigned int D.28806;
  unsigned int D.28807;
  guint32 * D.28808;
  unsigned int D.28809;
  unsigned int D.28810;
  long unsigned int D.28811;
  long unsigned int D.28812;
  unsigned int D.28813;
  unsigned int D.28814;
  guint32 * D.28815;
  struct MonoDynamicStream * D.28816;
  unsigned int D.28817;
  guint32 * D.28818;
  unsigned int D.28819;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 pclass;

  D.28801 = parent & 3;
  switch (D.28801) <default: <D.19405>, case 0: <D.19404>, case 1: <D.19401>, case 2: <D.19403>>
  <D.19401>:
  pclass = 1;
  goto <D.19402>;
  <D.19403>:
  pclass = 4;
  goto <D.19402>;
  <D.19404>:
  pclass = 0;
  goto <D.19402>;
  <D.19405>:
  monoeg_g_log (0B, 16, "unknown typeref or def token 0x%08x for %s", parent, name);
  D.28802 = 0;
  return D.28802;
  <D.19402>:
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28803 = assembly->save;
  if (D.28803 != 0) goto <D.28804>; else goto <D.28805>;
  <D.28804>:
  D.28806 = table->rows;
  D.28807 = D.28806 + 1;
  alloc_table (table, D.28807);
  D.28808 = table->values;
  D.28809 = table->next_idx;
  D.28810 = D.28809 * 3;
  D.28811 = (long unsigned int) D.28810;
  D.28812 = D.28811 * 4;
  values = D.28808 + D.28812;
  D.28813 = parent << 3;
  D.28814 = D.28813 | pclass;
  *values = D.28814;
  D.28815 = values + 4;
  D.28816 = &assembly->sheap;
  D.28817 = string_heap_insert (D.28816, name);
  *D.28815 = D.28817;
  D.28818 = values + 8;
  *D.28818 = sig;
  <D.28805>:
  D.28809 = table->next_idx;
  token = D.28809 | 167772160;
  D.28809 = table->next_idx;
  D.28819 = D.28809 + 1;
  table->next_idx = D.28819;
  D.28802 = token;
  return D.28802;
}


mono_image_get_ctorbuilder_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoGHashTable * D.28821;
  void * D.28822;
  long int D.28823;
  guint32 D.28826;
  struct MonoArray * D.28827;
  struct MonoType * D.28831;
  struct MonoString * D.28832;
  long unsigned int D.28833;
  void * D.28834;
  guint32 token;
  guint32 parent;
  guint32 sig;
  struct ReflectionMethodBuilder rmb;
  char * name;
  struct MonoReflectionTypeBuilder * tb;

  try
    {
      tb = mb->type;
      D.28821 = assembly->handleref_managed;
      D.28822 = mono_g_hash_table_lookup (D.28821, mb);
      D.28823 = (long int) D.28822;
      token = (guint32) D.28823;
      if (token != 0) goto <D.28824>; else goto <D.28825>;
      <D.28824>:
      D.28826 = token;
      return D.28826;
      <D.28825>:
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.28827 = tb->generic_params;
      if (D.28827 != 0B) goto <D.28828>; else goto <D.28829>;
      <D.28828>:
      parent = create_generic_typespec (assembly, tb);
      goto <D.28830>;
      <D.28829>:
      D.28831 = mono_reflection_type_get_handle (tb);
      parent = mono_image_typedef_or_ref (assembly, D.28831);
      <D.28830>:
      D.28832 = rmb.name;
      name = mono_string_to_utf8 (D.28832);
      sig = method_builder_encode_signature (assembly, &rmb);
      token = mono_image_add_memberef_row (assembly, parent, name, sig);
      monoeg_g_free (name);
      D.28833 = (long unsigned int) token;
      D.28834 = (void *) D.28833;
      D.28821 = assembly->handleref_managed;
      mono_g_hash_table_insert (D.28821, mb, D.28834);
      D.28826 = token;
      return D.28826;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


mono_image_get_generic_field_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoGHashTable * D.28837;
  void * D.28838;
  long int D.28839;
  guint32 D.28842;
  struct MonoReflectionType * D.28843;
  struct MonoType * D.28844;
  struct MonoString * D.28845;
  struct MonoObject * D.28846;
  struct MonoArray * D.28849;
  struct MonoArray * D.28851;
  unsigned int D.28852;
  _Bool D.28853;
  long int D.28854;
  long int D.28855;
  int D.28858;
  unsigned int D.28861;
  unsigned int D.28862;
  guint32 * D.28863;
  unsigned int D.28864;
  unsigned int D.28865;
  long unsigned int D.28866;
  long unsigned int D.28867;
  unsigned int D.28868;
  unsigned int D.28869;
  guint32 * D.28870;
  struct MonoDynamicStream * D.28871;
  unsigned int D.28872;
  guint32 * D.28873;
  unsigned int D.28874;
  long unsigned int D.28875;
  void * D.28876;
  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.28837 = assembly->handleref_managed;
  D.28838 = mono_g_hash_table_lookup (D.28837, fb);
  D.28839 = (long int) D.28838;
  token = (guint32) D.28839;
  if (token != 0) goto <D.28840>; else goto <D.28841>;
  <D.28840>:
  D.28842 = token;
  return D.28842;
  <D.28841>:
  D.28843 = fb->typeb;
  D.28844 = mono_reflection_type_get_handle (D.28843);
  klass = mono_class_from_mono_type (D.28844);
  D.28845 = fb->name;
  name = mono_string_to_utf8 (D.28845);
  D.28846 = fb->type;
  init_type_builder_generics (D.28846);
  D.28846 = fb->type;
  type = mono_reflection_type_get_handle (D.28846);
  D.28849 = fb->modreq;
  if (D.28849 != 0B) goto <D.28847>; else goto <D.28850>;
  <D.28850>:
  D.28851 = fb->modopt;
  if (D.28851 != 0B) goto <D.28847>; else goto <D.28848>;
  <D.28847>:
  D.28851 = fb->modopt;
  D.28849 = fb->modreq;
  custom = add_custom_modifiers (assembly, type, D.28849, D.28851);
  type = custom;
  <D.28848>:
  sig = fieldref_encode_signature (assembly, 0B, type);
  monoeg_g_free (custom);
  D.28843 = fb->typeb;
  parent = create_generic_typespec (assembly, D.28843);
  D.28852 = parent & 3;
  D.28853 = D.28852 != 2;
  D.28854 = (long int) D.28853;
  D.28855 = __builtin_expect (D.28854, 0);
  if (D.28855 != 0) goto <D.28856>; else goto <D.28857>;
  <D.28856>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3220, "(parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC");
  <D.28857>:
  pclass = 4;
  parent = parent >> 2;
  table = &assembly->tables[10];
  D.28858 = assembly->save;
  if (D.28858 != 0) goto <D.28859>; else goto <D.28860>;
  <D.28859>:
  D.28861 = table->rows;
  D.28862 = D.28861 + 1;
  alloc_table (table, D.28862);
  D.28863 = table->values;
  D.28864 = table->next_idx;
  D.28865 = D.28864 * 3;
  D.28866 = (long unsigned int) D.28865;
  D.28867 = D.28866 * 4;
  values = D.28863 + D.28867;
  D.28868 = parent << 3;
  D.28869 = D.28868 | pclass;
  *values = D.28869;
  D.28870 = values + 4;
  D.28871 = &assembly->sheap;
  D.28872 = string_heap_insert (D.28871, name);
  *D.28870 = D.28872;
  D.28873 = values + 8;
  *D.28873 = sig;
  <D.28860>:
  D.28864 = table->next_idx;
  token = D.28864 | 167772160;
  D.28864 = table->next_idx;
  D.28874 = D.28864 + 1;
  table->next_idx = D.28874;
  D.28875 = (long unsigned int) token;
  D.28876 = (void *) D.28875;
  D.28837 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.28837, fb, D.28876);
  monoeg_g_free (name);
  D.28842 = token;
  return D.28842;
}


add_custom_modifiers (struct MonoDynamicImage * assembly, struct MonoType * type, struct MonoArray * modreq, struct MonoArray * modopt)
{
  long unsigned int D.28880;
  unsigned int D.28881;
  unsigned int count.152;
  unsigned int D.28883;
  long unsigned int D.28886;
  unsigned int D.28887;
  unsigned int D.28888;
  struct MonoType * D.28891;
  long unsigned int D.28892;
  long unsigned int D.28893;
  unsigned int D.28894;
  unsigned int D.28895;
  long unsigned int D.28896;
  unsigned char D.28897;
  <unnamed-unsigned:6> D.28898;
  long unsigned int D.28901;
  char * D.28902;
  void * D.28903;
  unsigned int D.28904;
  <unnamed-unsigned:31> D.28905;
  long unsigned int D.28906;
  char * D.28909;
  void * D.28910;
  unsigned int D.28911;
  <unnamed-unsigned:31> D.28912;
  long unsigned int D.28913;
  int i;
  int count;
  int len;
  int pos;
  struct MonoType * t;

  count = 0;
  if (modreq != 0B) goto <D.28878>; else goto <D.28879>;
  <D.28878>:
  D.28880 = mono_array_length (modreq);
  D.28881 = (unsigned int) D.28880;
  count.152 = (unsigned int) count;
  D.28883 = D.28881 + count.152;
  count = (int) D.28883;
  <D.28879>:
  if (modopt != 0B) goto <D.28884>; else goto <D.28885>;
  <D.28884>:
  D.28886 = mono_array_length (modopt);
  D.28887 = (unsigned int) D.28886;
  count.152 = (unsigned int) count;
  D.28888 = D.28887 + count.152;
  count = (int) D.28888;
  <D.28885>:
  if (count == 0) goto <D.28889>; else goto <D.28890>;
  <D.28889>:
  D.28891 = mono_metadata_type_dup (0B, type);
  return D.28891;
  <D.28890>:
  D.28892 = (long unsigned int) count;
  D.28893 = D.28892 + 3;
  D.28894 = (unsigned int) D.28893;
  D.28895 = D.28894 * 4;
  len = (int) D.28895;
  D.28896 = (long unsigned int) len;
  t = monoeg_malloc (D.28896);
  memcpy (t, type, 12);
  D.28897 = (unsigned char) count;
  D.28898 = (<unnamed-unsigned:6>) D.28897;
  t->num_mods = D.28898;
  pos = 0;
  if (modreq != 0B) goto <D.28899>; else goto <D.28900>;
  <D.28899>:
  i = 0;
  goto <D.19631>;
  <D.19630>:
  {
    struct MonoType * mod;

    D.28901 = (long unsigned int) i;
    D.28902 = mono_array_addr_with_size (modreq, 8, D.28901);
    D.28903 = MEM[(void * *)D.28902];
    mod = mono_reflection_type_get_handle (D.28903);
    t->modifiers[pos].required = 1;
    D.28904 = mono_image_typedef_or_ref (assembly, mod);
    D.28905 = (<unnamed-unsigned:31>) D.28904;
    t->modifiers[pos].token = D.28905;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19631>:
  D.28901 = (long unsigned int) i;
  D.28906 = mono_array_length (modreq);
  if (D.28901 < D.28906) goto <D.19630>; else goto <D.19632>;
  <D.19632>:
  <D.28900>:
  if (modopt != 0B) goto <D.28907>; else goto <D.28908>;
  <D.28907>:
  i = 0;
  goto <D.19635>;
  <D.19634>:
  {
    struct MonoType * mod;

    D.28901 = (long unsigned int) i;
    D.28909 = mono_array_addr_with_size (modopt, 8, D.28901);
    D.28910 = MEM[(void * *)D.28909];
    mod = mono_reflection_type_get_handle (D.28910);
    t->modifiers[pos].required = 0;
    D.28911 = mono_image_typedef_or_ref (assembly, mod);
    D.28912 = (<unnamed-unsigned:31>) D.28911;
    t->modifiers[pos].token = D.28912;
    pos = pos + 1;
  }
  i = i + 1;
  <D.19635>:
  D.28901 = (long unsigned int) i;
  D.28913 = mono_array_length (modopt);
  if (D.28901 < D.28913) goto <D.19634>; else goto <D.19636>;
  <D.19636>:
  <D.28908>:
  D.28891 = t;
  return D.28891;
}


fieldref_encode_signature (struct MonoDynamicImage * assembly, struct MonoImage * field_image, struct MonoType * type)
{
  int D.28915;
  guint32 D.28918;
  unsigned char D.28919;
  unsigned char D.28920;
  <unnamed-unsigned:31> D.28925;
  unsigned int D.28926;
  _Bool D.28927;
  long int D.28928;
  long int D.28929;
  struct MonoType * D.28932;
  <unnamed-unsigned:1> D.28934;
  <unnamed-unsigned:6> D.28938;
  unsigned int D.28939;
  struct SigBuffer buf;
  guint32 idx;
  guint32 i;
  guint32 token;

  try
    {
      D.28915 = assembly->save;
      if (D.28915 == 0) goto <D.28916>; else goto <D.28917>;
      <D.28916>:
      D.28918 = 0;
      return D.28918;
      <D.28917>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      D.28919 = BIT_FIELD_REF <*type, 8, 88>;
      D.28920 = D.28919 & 63;
      if (D.28920 != 0) goto <D.28921>; else goto <D.28922>;
      <D.28921>:
      i = 0;
      goto <D.19183>;
      <D.19182>:
      if (field_image != 0B) goto <D.28923>; else goto <D.28924>;
      <D.28923>:
      {
        struct MonoClass * class;

        D.28925 = type->modifiers[i].token;
        D.28926 = (unsigned int) D.28925;
        class = mono_class_get (field_image, D.28926);
        D.28927 = class == 0B;
        D.28928 = (long int) D.28927;
        D.28929 = __builtin_expect (D.28928, 0);
        if (D.28929 != 0) goto <D.28930>; else goto <D.28931>;
        <D.28930>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 1706, "class");
        <D.28931>:
        D.28932 = &class->byval_arg;
        token = mono_image_typedef_or_ref (assembly, D.28932);
      }
      goto <D.28933>;
      <D.28924>:
      D.28925 = type->modifiers[i].token;
      token = (guint32) D.28925;
      <D.28933>:
      D.28934 = type->modifiers[i].required;
      if (D.28934 != 0) goto <D.28935>; else goto <D.28936>;
      <D.28935>:
      sigbuffer_add_byte (&buf, 31);
      goto <D.28937>;
      <D.28936>:
      sigbuffer_add_byte (&buf, 32);
      <D.28937>:
      sigbuffer_add_value (&buf, token);
      i = i + 1;
      <D.19183>:
      D.28938 = type->num_mods;
      D.28939 = (unsigned int) D.28938;
      if (D.28939 > i) goto <D.19182>; else goto <D.19184>;
      <D.19184>:
      <D.28922>:
      encode_type (assembly, type, &buf);
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.28918 = idx;
      return D.28918;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_methodspec_token (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  struct GHashTable * D.28942;
  void * D.28943;
  long int D.28944;
  guint32 D.28947;
  unsigned char D.28948;
  unsigned char D.28949;
  _Bool D.28950;
  long int D.28951;
  long int D.28952;
  struct MonoMethod * D.28955;
  struct MonoMethodSignature * D.28956;
  short unsigned int D.28957;
  struct MonoMethodSignature * D.28961;
  const char * D.28962;
  struct MonoClass * D.28963;
  struct MonoType * D.28964;
  long unsigned int D.28965;
  void * D.28966;
  struct MonoMethodInflated * imethod;
  guint32 token;

  D.28942 = assembly->handleref;
  D.28943 = monoeg_g_hash_table_lookup (D.28942, method);
  D.28944 = (long int) D.28943;
  token = (guint32) D.28944;
  if (token != 0) goto <D.28945>; else goto <D.28946>;
  <D.28945>:
  D.28947 = token;
  return D.28947;
  <D.28946>:
  D.28948 = BIT_FIELD_REF <*method, 8, 264>;
  D.28949 = D.28948 & 16;
  D.28950 = D.28949 == 0;
  D.28951 = (long int) D.28950;
  D.28952 = __builtin_expect (D.28951, 0);
  if (D.28952 != 0) goto <D.28953>; else goto <D.28954>;
  <D.28953>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3044, "method->is_inflated");
  <D.28954>:
  imethod = method;
  D.28955 = imethod->declaring;
  D.28956 = mono_method_signature (D.28955);
  D.28957 = D.28956->generic_param_count;
  if (D.28957 != 0) goto <D.28958>; else goto <D.28959>;
  <D.28958>:
  token = method_encode_methodspec (assembly, method);
  goto <D.28960>;
  <D.28959>:
  {
    guint32 sig;

    D.28955 = imethod->declaring;
    D.28961 = mono_method_signature (D.28955);
    sig = method_encode_signature (assembly, D.28961);
    D.28962 = method->name;
    D.28963 = method->klass;
    D.28964 = &D.28963->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.28964, D.28962, sig);
  }
  <D.28960>:
  D.28965 = (long unsigned int) token;
  D.28966 = (void *) D.28965;
  D.28942 = assembly->handleref;
  monoeg_g_hash_table_insert_replace (D.28942, method, D.28966, 0);
  D.28947 = token;
  return D.28947;
}


method_encode_methodspec (struct MonoDynamicImage * assembly, struct MonoMethod * method)
{
  unsigned char D.28968;
  unsigned char D.28969;
  _Bool D.28970;
  long int D.28971;
  long int D.28972;
  struct MonoMethodSignature * D.28975;
  const char * D.28976;
  struct MonoClass * D.28977;
  struct MonoType * D.28978;
  struct MonoMethodSignature * D.28979;
  short unsigned int D.28980;
  guint32 D.28983;
  unsigned int D.28984;
  unsigned int D.28985;
  unsigned int D.28986;
  struct MonoGenericContext * D.28987;
  int D.28988;
  unsigned int D.28991;
  unsigned int D.28992;
  guint32 * D.28993;
  unsigned int D.28994;
  unsigned int D.28995;
  long unsigned int D.28996;
  long unsigned int D.28997;
  guint32 * D.28998;
  unsigned int D.28999;
  struct MonoDynamicTable * table;
  guint32 * values;
  guint32 token;
  guint32 mtoken;
  guint32 sig;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * declaring;

  mtoken = 0;
  table = &assembly->tables[43];
  D.28968 = BIT_FIELD_REF <*method, 8, 264>;
  D.28969 = D.28968 & 16;
  D.28970 = D.28969 == 0;
  D.28971 = (long int) D.28970;
  D.28972 = __builtin_expect (D.28971, 0);
  if (D.28972 != 0) goto <D.28973>; else goto <D.28974>;
  <D.28973>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2998, "method->is_inflated");
  <D.28974>:
  imethod = method;
  declaring = imethod->declaring;
  D.28975 = mono_method_signature (declaring);
  sig = method_encode_signature (assembly, D.28975);
  D.28976 = declaring->name;
  D.28977 = method->klass;
  D.28978 = &D.28977->byval_arg;
  mtoken = mono_image_get_memberref_token (assembly, D.28978, D.28976, sig);
  D.28979 = mono_method_signature (declaring);
  D.28980 = D.28979->generic_param_count;
  if (D.28980 == 0) goto <D.28981>; else goto <D.28982>;
  <D.28981>:
  D.28983 = mtoken;
  return D.28983;
  <D.28982>:
  D.28984 = mtoken >> 24;
  switch (D.28984) <default: <D.19587>, case 6: <D.19586>, case 10: <D.19584>>
  <D.19584>:
  D.28985 = mtoken & 16777215;
  D.28986 = D.28985 << 1;
  mtoken = D.28986 | 1;
  goto <D.19585>;
  <D.19586>:
  D.28985 = mtoken & 16777215;
  mtoken = D.28985 << 1;
  goto <D.19585>;
  <D.19587>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3016);
  <D.19585>:
  D.28987 = mono_method_get_context (method);
  sig = encode_generic_method_sig (assembly, D.28987);
  D.28988 = assembly->save;
  if (D.28988 != 0) goto <D.28989>; else goto <D.28990>;
  <D.28989>:
  D.28991 = table->rows;
  D.28992 = D.28991 + 1;
  alloc_table (table, D.28992);
  D.28993 = table->values;
  D.28994 = table->next_idx;
  D.28995 = D.28994 * 2;
  D.28996 = (long unsigned int) D.28995;
  D.28997 = D.28996 * 4;
  values = D.28993 + D.28997;
  *values = mtoken;
  D.28998 = values + 4;
  *D.28998 = sig;
  <D.28990>:
  D.28994 = table->next_idx;
  token = D.28994 | 721420288;
  D.28994 = table->next_idx;
  D.28999 = D.28994 + 1;
  table->next_idx = D.28999;
  D.28983 = token;
  return D.28983;
}


encode_generic_method_sig (struct MonoDynamicImage * assembly, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.29001;
  <unnamed-unsigned:22> D.29002;
  int D.29003;
  guint32 D.29006;
  struct MonoType * D.29007;
  unsigned int i.153;
  struct SigBuffer buf;
  int i;
  guint32 nparams;
  guint32 idx;

  try
    {
      D.29001 = context->method_inst;
      D.29002 = D.29001->type_argc;
      nparams = (guint32) D.29002;
      D.29003 = assembly->save;
      if (D.29003 == 0) goto <D.29004>; else goto <D.29005>;
      <D.29004>:
      D.29006 = 0;
      return D.29006;
      <D.29005>:
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 10);
      sigbuffer_add_value (&buf, nparams);
      i = 0;
      goto <D.19571>;
      <D.19570>:
      D.29001 = context->method_inst;
      D.29007 = D.29001->type_argv[i];
      encode_type (assembly, D.29007, &buf);
      i = i + 1;
      <D.19571>:
      i.153 = (unsigned int) i;
      if (i.153 < nparams) goto <D.19570>; else goto <D.19572>;
      <D.19572>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29006 = idx;
      return D.29006;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


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

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


mono_image_get_inflated_method_token (struct MonoDynamicImage * assembly, struct MonoMethod * m)
{
  struct MonoMethod * D.29013;
  struct MonoMethodSignature * D.29014;
  const char * D.29015;
  struct MonoClass * D.29016;
  struct MonoType * D.29017;
  guint32 D.29018;
  struct MonoMethodInflated * imethod;
  guint32 sig;
  guint32 token;

  imethod = m;
  D.29013 = imethod->declaring;
  D.29014 = mono_method_signature (D.29013);
  sig = method_encode_signature (assembly, D.29014);
  D.29015 = m->name;
  D.29016 = m->klass;
  D.29017 = &D.29016->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.29017, D.29015, sig);
  D.29018 = token;
  return D.29018;
}


mono_image_get_methodref_token (struct MonoDynamicImage * assembly, struct MonoMethod * method, gboolean create_typespec)
{
  int iftmp.154;
  unsigned char D.29024;
  unsigned char D.29025;
  struct MonoClass * D.29027;
  struct MonoImage * D.29028;
  struct MonoImage * D.29029;
  long int method.155;
  unsigned int D.29034;
  unsigned int D.29035;
  long unsigned int D.29036;
  const void * D.29037;
  struct GHashTable * D.29038;
  void * D.29039;
  long int D.29040;
  guint32 D.29043;
  void * D.29044;
  long int D.29045;
  _Bool D.29046;
  _Bool D.29047;
  _Bool D.29048;
  unsigned char D.29051;
  _Bool D.29052;
  long int D.29053;
  long int D.29054;
  struct MonoMethodSignature * D.29059;
  unsigned char D.29060;
  unsigned char D.29061;
  _Bool D.29062;
  _Bool D.29063;
  _Bool D.29064;
  unsigned int D.29067;
  const char * D.29068;
  struct MonoType * D.29069;
  long unsigned int D.29070;
  void * D.29071;
  unsigned int D.29074;
  _Bool D.29075;
  long int D.29076;
  long int D.29077;
  unsigned int D.29080;
  unsigned int D.29081;
  int D.29082;
  unsigned int D.29085;
  unsigned int D.29086;
  guint32 * D.29087;
  unsigned int D.29088;
  unsigned int D.29089;
  long unsigned int D.29090;
  long unsigned int D.29091;
  guint32 * D.29092;
  struct MonoGenericContainer * D.29093;
  struct MonoGenericContext * D.29094;
  unsigned int D.29095;
  unsigned int D.29096;
  void * D.29097;
  guint32 token;
  struct MonoMethodSignature * sig;

  if (create_typespec != 0) goto <D.29023>; else goto <D.29021>;
  <D.29023>:
  D.29024 = BIT_FIELD_REF <*method, 8, 264>;
  D.29025 = D.29024 & 8;
  if (D.29025 != 0) goto <D.29026>; else goto <D.29021>;
  <D.29026>:
  D.29027 = method->klass;
  D.29028 = D.29027->image;
  D.29029 = &assembly->image;
  if (D.29028 != D.29029) goto <D.29030>; else goto <D.29021>;
  <D.29030>:
  iftmp.154 = 1;
  goto <D.29022>;
  <D.29021>:
  iftmp.154 = 0;
  <D.29022>:
  create_typespec = iftmp.154;
  if (create_typespec != 0) goto <D.29031>; else goto <D.29032>;
  <D.29031>:
  method.155 = (long int) method;
  D.29034 = (unsigned int) method.155;
  D.29035 = D.29034 + 1;
  D.29036 = (long unsigned int) D.29035;
  D.29037 = (const void *) D.29036;
  D.29038 = assembly->handleref;
  D.29039 = monoeg_g_hash_table_lookup (D.29038, D.29037);
  D.29040 = (long int) D.29039;
  token = (guint32) D.29040;
  if (token != 0) goto <D.29041>; else goto <D.29042>;
  <D.29041>:
  D.29043 = token;
  return D.29043;
  <D.29042>:
  <D.29032>:
  D.29038 = assembly->handleref;
  D.29044 = monoeg_g_hash_table_lookup (D.29038, method);
  D.29045 = (long int) D.29044;
  token = (guint32) D.29045;
  D.29046 = token != 0;
  D.29047 = create_typespec == 0;
  D.29048 = D.29046 & D.29047;
  if (D.29048 != 0) goto <D.29049>; else goto <D.29050>;
  <D.29049>:
  D.29043 = token;
  return D.29043;
  <D.29050>:
  D.29024 = BIT_FIELD_REF <*method, 8, 264>;
  D.29051 = D.29024 & 16;
  D.29052 = D.29051 != 0;
  D.29053 = (long int) D.29052;
  D.29054 = __builtin_expect (D.29053, 0);
  if (D.29054 != 0) goto <D.29055>; else goto <D.29056>;
  <D.29055>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2492, "!method->is_inflated");
  <D.29056>:
  if (token == 0) goto <D.29057>; else goto <D.29058>;
  <D.29057>:
  D.29059 = mono_method_signature (method);
  sig = mono_metadata_signature_dup (D.29059);
  D.29060 = BIT_FIELD_REF <*sig, 8, 112>;
  D.29061 = D.29060 & 63;
  D.29062 = D.29061 != 0;
  D.29063 = D.29061 != 5;
  D.29064 = D.29062 & D.29063;
  if (D.29064 != 0) goto <D.29065>; else goto <D.29066>;
  <D.29065>:
  sig->call_convention = 0;
  <D.29066>:
  D.29067 = method_encode_signature (assembly, sig);
  D.29068 = method->name;
  D.29027 = method->klass;
  D.29069 = &D.29027->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.29069, D.29068, D.29067);
  monoeg_g_free (sig);
  D.29070 = (long unsigned int) token;
  D.29071 = (void *) D.29070;
  D.29038 = assembly->handleref;
  monoeg_g_hash_table_insert_replace (D.29038, method, D.29071, 0);
  <D.29058>:
  if (create_typespec != 0) goto <D.29072>; else goto <D.29073>;
  <D.29072>:
  {
    struct MonoDynamicTable * table;

    table = &assembly->tables[43];
    D.29074 = token >> 24;
    D.29075 = D.29074 != 10;
    D.29076 = (long int) D.29075;
    D.29077 = __builtin_expect (D.29076, 0);
    if (D.29077 != 0) goto <D.29078>; else goto <D.29079>;
    <D.29078>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2508, "mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF");
    <D.29079>:
    D.29080 = token & 16777215;
    D.29081 = D.29080 << 1;
    token = D.29081 | 1;
    D.29082 = assembly->save;
    if (D.29082 != 0) goto <D.29083>; else goto <D.29084>;
    <D.29083>:
    {
      guint32 * values;

      D.29085 = table->rows;
      D.29086 = D.29085 + 1;
      alloc_table (table, D.29086);
      D.29087 = table->values;
      D.29088 = table->next_idx;
      D.29089 = D.29088 * 2;
      D.29090 = (long unsigned int) D.29089;
      D.29091 = D.29090 * 4;
      values = D.29087 + D.29091;
      *values = token;
      D.29092 = values + 4;
      D.29093 = mono_method_get_generic_container (method);
      D.29094 = &D.29093->context;
      D.29095 = encode_generic_method_sig (assembly, D.29094);
      *D.29092 = D.29095;
    }
    <D.29084>:
    D.29088 = table->next_idx;
    token = D.29088 | 721420288;
    D.29088 = table->next_idx;
    D.29096 = D.29088 + 1;
    table->next_idx = D.29096;
    D.29070 = (long unsigned int) token;
    D.29071 = (void *) D.29070;
    method.155 = (long int) method;
    D.29034 = (unsigned int) method.155;
    D.29035 = D.29034 + 1;
    D.29036 = (long unsigned int) D.29035;
    D.29097 = (void *) D.29036;
    D.29038 = assembly->handleref;
    monoeg_g_hash_table_insert_replace (D.29038, D.29097, D.29071, 0);
    D.29043 = token;
    return D.29043;
  }
  <D.29073>:
  D.29043 = token;
  return D.29043;
}


mono_image_get_fieldref_token (struct MonoDynamicImage * assembly, struct MonoObject * f, struct MonoClassField * field)
{
  _Bool D.29099;
  long int D.29100;
  long int D.29101;
  struct MonoClass * D.29104;
  _Bool D.29105;
  long int D.29106;
  long int D.29107;
  struct MonoGHashTable * D.29110;
  void * D.29111;
  long int D.29112;
  guint32 D.29115;
  struct MonoGenericClass * D.29118;
  struct MonoClass * D.29120;
  struct MonoClassField * D.29122;
  long int field.156;
  struct MonoClassField * D.29125;
  long int D.29126;
  long int D.29127;
  long int D.29128;
  long unsigned int D.29129;
  long unsigned int D.29130;
  struct MonoClassField * D.29131;
  int D.29132;
  struct MonoImage * D.29136;
  unsigned int D.29137;
  const char * D.29138;
  struct MonoType * D.29139;
  long unsigned int D.29140;
  void * D.29141;
  struct MonoType * type;
  guint32 token;

  D.29099 = field == 0B;
  D.29100 = (long int) D.29099;
  D.29101 = __builtin_expect (D.29100, 0);
  if (D.29101 != 0) goto <D.29102>; else goto <D.29103>;
  <D.29102>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2745, "field");
  <D.29103>:
  D.29104 = field->parent;
  D.29105 = D.29104 == 0B;
  D.29106 = (long int) D.29105;
  D.29107 = __builtin_expect (D.29106, 0);
  if (D.29107 != 0) goto <D.29108>; else goto <D.29109>;
  <D.29108>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2746, "field->parent");
  <D.29109>:
  D.29110 = assembly->handleref_managed;
  D.29111 = mono_g_hash_table_lookup (D.29110, f);
  D.29112 = (long int) D.29111;
  token = (guint32) D.29112;
  if (token != 0) goto <D.29113>; else goto <D.29114>;
  <D.29113>:
  D.29115 = token;
  return D.29115;
  <D.29114>:
  D.29104 = field->parent;
  D.29118 = D.29104->generic_class;
  if (D.29118 != 0B) goto <D.29119>; else goto <D.29116>;
  <D.29119>:
  D.29104 = field->parent;
  D.29118 = D.29104->generic_class;
  D.29120 = D.29118->container_class;
  if (D.29120 != 0B) goto <D.29121>; else goto <D.29116>;
  <D.29121>:
  D.29104 = field->parent;
  D.29118 = D.29104->generic_class;
  D.29120 = D.29118->container_class;
  D.29122 = D.29120->fields;
  if (D.29122 != 0B) goto <D.29123>; else goto <D.29116>;
  <D.29123>:
  {
    int index;

    field.156 = (long int) field;
    D.29104 = field->parent;
    D.29125 = D.29104->fields;
    D.29126 = (long int) D.29125;
    D.29127 = field.156 - D.29126;
    D.29128 = D.29127 /[ex] 32;
    index = (int) D.29128;
    D.29104 = field->parent;
    D.29118 = D.29104->generic_class;
    D.29120 = D.29118->container_class;
    D.29122 = D.29120->fields;
    D.29129 = (long unsigned int) index;
    D.29130 = D.29129 * 32;
    D.29131 = D.29122 + D.29130;
    type = mono_field_get_type (D.29131);
  }
  goto <D.29117>;
  <D.29116>:
  D.29132 = is_field_on_inst (field);
  if (D.29132 != 0) goto <D.29133>; else goto <D.29134>;
  <D.29133>:
  type = get_field_on_inst_generic_type (field);
  goto <D.29135>;
  <D.29134>:
  type = mono_field_get_type (field);
  <D.29135>:
  <D.29117>:
  D.29104 = field->parent;
  D.29136 = D.29104->image;
  D.29137 = fieldref_encode_signature (assembly, D.29136, type);
  D.29138 = mono_field_get_name (field);
  D.29104 = field->parent;
  D.29139 = &D.29104->byval_arg;
  token = mono_image_get_memberref_token (assembly, D.29139, D.29138, D.29137);
  D.29140 = (long unsigned int) token;
  D.29141 = (void *) D.29140;
  D.29110 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.29110, f, D.29141);
  D.29115 = token;
  return D.29115;
}


get_field_on_inst_generic_type (struct MonoClassField * field)
{
  int D.29143;
  _Bool D.29144;
  long int D.29145;
  long int D.29146;
  struct MonoClass * D.29149;
  struct MonoClassField * D.29150;
  long int field.157;
  long int D.29154;
  long int D.29155;
  long int D.29156;
  int D.29157;
  long int D.29158;
  struct MonoType * D.29161;
  struct MonoType * * D.29162;
  long unsigned int D.29163;
  long unsigned int D.29164;
  struct MonoType * * D.29165;
  struct MonoGenericClass * D.29166;
  struct MonoClassField * D.29167;
  long int D.29170;
  long int D.29171;
  long int D.29172;
  unsigned int D.29173;
  long int D.29174;
  struct MonoClassField * D.29177;
  long unsigned int D.29178;
  struct MonoClassField * D.29179;
  struct MonoClass * class;
  struct MonoClass * gtd;
  struct MonoDynamicGenericClass * dgclass;
  int field_index;

  D.29143 = is_field_on_inst (field);
  D.29144 = D.29143 == 0;
  D.29145 = (long int) D.29144;
  D.29146 = __builtin_expect (D.29145, 0);
  if (D.29146 != 0) goto <D.29147>; else goto <D.29148>;
  <D.29147>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2717, "is_field_on_inst (field)");
  <D.29148>:
  D.29149 = field->parent;
  dgclass = D.29149->generic_class;
  D.29150 = dgclass->fields;
  if (D.29150 <= field) goto <D.29151>; else goto <D.29152>;
  <D.29151>:
  field.157 = (long int) field;
  D.29150 = dgclass->fields;
  D.29154 = (long int) D.29150;
  D.29155 = field.157 - D.29154;
  D.29156 = D.29155 /[ex] 32;
  D.29157 = dgclass->count_fields;
  D.29158 = (long int) D.29157;
  if (D.29156 < D.29158) goto <D.29159>; else goto <D.29160>;
  <D.29159>:
  field.157 = (long int) field;
  D.29150 = dgclass->fields;
  D.29154 = (long int) D.29150;
  D.29155 = field.157 - D.29154;
  D.29156 = D.29155 /[ex] 32;
  field_index = (int) D.29156;
  D.29162 = dgclass->field_generic_types;
  D.29163 = (long unsigned int) field_index;
  D.29164 = D.29163 * 8;
  D.29165 = D.29162 + D.29164;
  D.29161 = *D.29165;
  return D.29161;
  <D.29160>:
  <D.29152>:
  class = field->parent;
  D.29166 = class->generic_class;
  gtd = D.29166->container_class;
  D.29167 = class->fields;
  if (D.29167 <= field) goto <D.29168>; else goto <D.29169>;
  <D.29168>:
  field.157 = (long int) field;
  D.29167 = class->fields;
  D.29170 = (long int) D.29167;
  D.29171 = field.157 - D.29170;
  D.29172 = D.29171 /[ex] 32;
  D.29173 = class->field.count;
  D.29174 = (long int) D.29173;
  if (D.29172 < D.29174) goto <D.29175>; else goto <D.29176>;
  <D.29175>:
  field.157 = (long int) field;
  D.29167 = class->fields;
  D.29170 = (long int) D.29167;
  D.29171 = field.157 - D.29170;
  D.29172 = D.29171 /[ex] 32;
  field_index = (int) D.29172;
  D.29177 = gtd->fields;
  D.29163 = (long unsigned int) field_index;
  D.29178 = D.29163 * 32;
  D.29179 = D.29177 + D.29178;
  D.29161 = D.29179->type;
  return D.29161;
  <D.29176>:
  <D.29169>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 2734);
  D.29161 = 0B;
  return D.29161;
}


mono_image_get_array_token (struct MonoDynamicImage * assembly, struct MonoReflectionArrayMethod * m)
{
  struct MonoString * D.29181;
  struct MonoArray * D.29182;
  long unsigned int D.29183;
  long unsigned int D.29184;
  long unsigned int D.29185;
  long unsigned int D.29186;
  unsigned int D.29187;
  int D.29188;
  int D.29189;
  unsigned char D.29190;
  <unnamed-unsigned:6> D.29191;
  short unsigned int D.29192;
  struct MonoType * iftmp.158;
  struct MonoReflectionType * D.29194;
  struct MonoClass * D.29198;
  struct MonoReflectionType * D.29199;
  long unsigned int D.29200;
  char * D.29201;
  void * D.29202;
  struct MonoType * D.29203;
  int D.19712;
  char * D.29204;
  struct MonoType * D.29207;
  int D.29208;
  struct MonoMethodSignature * D.29211;
  int D.29212;
  unsigned int D.29215;
  unsigned int D.29216;
  guint32 D.29217;
  unsigned int D.29218;
  unsigned int D.29219;
  struct GList * D.29220;
  struct GList * D.29221;
  guint32 nparams;
  guint32 i;
  struct GList * tmp;
  char * name;
  struct MonoMethodSignature * sig;
  struct ArrayMethod * am;
  struct MonoType * mtype;

  D.29181 = m->name;
  name = mono_string_to_utf8 (D.29181);
  D.29182 = m->parameters;
  D.29183 = mono_array_length (D.29182);
  nparams = (guint32) D.29183;
  D.29184 = (long unsigned int) nparams;
  D.29185 = D.29184 + 2;
  D.29186 = D.29185 * 8;
  sig = monoeg_malloc0 (D.29186);
  sig->hasthis = 1;
  sig->sentinelpos = -1;
  D.29187 = m->call_conv;
  D.29188 = (int) D.29187;
  D.29189 = reflection_cc_to_file (D.29188);
  D.29190 = (unsigned char) D.29189;
  D.29191 = (<unnamed-unsigned:6>) D.29190;
  sig->call_convention = D.29191;
  D.29192 = (short unsigned int) nparams;
  sig->param_count = D.29192;
  D.29194 = m->ret;
  if (D.29194 != 0B) goto <D.29195>; else goto <D.29196>;
  <D.29195>:
  D.29194 = m->ret;
  iftmp.158 = mono_reflection_type_get_handle (D.29194);
  goto <D.29197>;
  <D.29196>:
  D.29198 = mono_defaults.void_class;
  iftmp.158 = &D.29198->byval_arg;
  <D.29197>:
  sig->ret = iftmp.158;
  D.29199 = m->parent;
  mtype = mono_reflection_type_get_handle (D.29199);
  i = 0;
  goto <D.19702>;
  <D.19701>:
  D.29200 = (long unsigned int) i;
  D.29182 = m->parameters;
  D.29201 = mono_array_addr_with_size (D.29182, 8, D.29200);
  D.29202 = MEM[(void * *)D.29201];
  D.29203 = mono_reflection_type_get_handle (D.29202);
  sig->params[i] = D.29203;
  i = i + 1;
  <D.19702>:
  if (i < nparams) goto <D.19701>; else goto <D.19703>;
  <D.19703>:
  tmp = assembly->array_methods;
  goto <D.19714>;
  <D.19713>:
  am = tmp->data;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.29204 = am->name;
    D.19712 = __builtin_strcmp (name, D.29204);
  }
  if (D.19712 == 0) goto <D.29205>; else goto <D.29206>;
  <D.29205>:
  D.29207 = am->parent;
  D.29208 = mono_metadata_type_equal (D.29207, mtype);
  if (D.29208 != 0) goto <D.29209>; else goto <D.29210>;
  <D.29209>:
  D.29211 = am->sig;
  D.29212 = mono_metadata_signature_equal (D.29211, sig);
  if (D.29212 != 0) goto <D.29213>; else goto <D.29214>;
  <D.29213>:
  monoeg_g_free (name);
  monoeg_g_free (sig);
  D.29215 = am->token;
  D.29216 = D.29215 & 16777215;
  m->table_idx = D.29216;
  D.29217 = am->token;
  return D.29217;
  <D.29214>:
  <D.29210>:
  <D.29206>:
  tmp = tmp->next;
  <D.19714>:
  if (tmp != 0B) goto <D.19713>; else goto <D.19715>;
  <D.19715>:
  am = monoeg_malloc0 (32);
  am->name = name;
  am->sig = sig;
  am->parent = mtype;
  D.29218 = method_encode_signature (assembly, sig);
  D.29207 = am->parent;
  D.29219 = mono_image_get_memberref_token (assembly, D.29207, name, D.29218);
  am->token = D.29219;
  D.29220 = assembly->array_methods;
  D.29221 = monoeg_g_list_prepend (D.29220, am);
  assembly->array_methods = D.29221;
  D.29215 = am->token;
  D.29216 = D.29215 & 16777215;
  m->table_idx = D.29216;
  D.29217 = am->token;
  return D.29217;
}


reflection_cc_to_file (int call_conv)
{
  int D.29223;
  int D.29224;

  D.29223 = call_conv & 3;
  switch (D.29223) <default: <D.19683>, case 0: <D.19680>, case 1: <D.19681>, case 2: <D.19682>>
  <D.19680>:
  <D.19681>:
  D.29224 = 0;
  return D.29224;
  <D.19682>:
  D.29224 = 5;
  return D.29224;
  <D.19683>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 3331);
  D.29224 = 0;
  return D.29224;
}


mono_image_get_sighelper_token (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  unsigned int D.29226;
  unsigned int idx.159;
  unsigned int D.29228;
  unsigned int D.29229;
  unsigned int D.29230;
  guint32 * D.29231;
  long unsigned int D.29232;
  long unsigned int D.29233;
  unsigned int D.29234;
  guint32 D.29235;
  guint32 idx;
  struct MonoDynamicTable * table;
  guint32 * values;

  table = &assembly->tables[17];
  D.29226 = table->next_idx;
  idx.159 = D.29226;
  D.29228 = idx.159 + 1;
  table->next_idx = D.29228;
  idx = idx.159;
  D.29229 = table->rows;
  D.29230 = D.29229 + 1;
  table->rows = D.29230;
  D.29229 = table->rows;
  alloc_table (table, D.29229);
  D.29231 = table->values;
  D.29232 = (long unsigned int) idx;
  D.29233 = D.29232 * 4;
  values = D.29231 + D.29233;
  D.29234 = mono_reflection_encode_sighelper (assembly, helper);
  *values = D.29234;
  D.29235 = idx;
  return D.29235;
}


mono_reflection_encode_sighelper (struct MonoDynamicImage * assembly, struct MonoReflectionSigHelper * helper)
{
  int D.29237;
  guint32 D.29240;
  unsigned int D.29241;
  _Bool D.29242;
  long int D.29243;
  long int D.29244;
  struct MonoArray * D.29247;
  long unsigned int D.29250;
  unsigned int D.29252;
  unsigned int D.29253;
  unsigned int D.29254;
  unsigned int D.29257;
  unsigned int D.29260;
  unsigned int D.29263;
  unsigned int D.29265;
  unsigned char D.29268;
  int D.29269;
  struct MonoReflectionType * D.29270;
  struct MonoArray * D.29271;
  long unsigned int D.29274;
  long unsigned int D.29275;
  char * D.29278;
  struct MonoArray * D.29279;
  long unsigned int D.29282;
  char * D.29285;
  char * D.29286;
  struct SigBuffer buf;
  guint32 nargs;
  guint32 size;
  guint32 i;
  guint32 idx;

  try
    {
      D.29237 = assembly->save;
      if (D.29237 == 0) goto <D.29238>; else goto <D.29239>;
      <D.29238>:
      D.29240 = 0;
      return D.29240;
      <D.29239>:
      D.29241 = helper->type;
      D.29242 = D.29241 != 2;
      D.29243 = (long int) D.29242;
      D.29244 = __builtin_expect (D.29243, 0);
      if (D.29244 != 0) goto <D.29245>; else goto <D.29246>;
      <D.29245>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 3254, "helper->type == 2");
      <D.29246>:
      D.29247 = helper->arguments;
      if (D.29247 != 0B) goto <D.29248>; else goto <D.29249>;
      <D.29248>:
      D.29247 = helper->arguments;
      D.29250 = mono_array_length (D.29247);
      nargs = (guint32) D.29250;
      goto <D.29251>;
      <D.29249>:
      nargs = 0;
      <D.29251>:
      D.29252 = nargs + 1;
      size = D.29252 * 10;
      sigbuffer_init (&buf, 32);
      D.29253 = helper->call_conv;
      D.29254 = D.29253 & 3;
      if (D.29254 == 3) goto <D.29255>; else goto <D.29256>;
      <D.29255>:
      helper->call_conv = 1;
      <D.29256>:
      D.29253 = helper->call_conv;
      D.29257 = D.29253 & 64;
      if (D.29257 != 0) goto <D.29258>; else goto <D.29259>;
      <D.29258>:
      D.29253 = helper->call_conv;
      D.29260 = D.29253 & 32;
      helper->call_conv = D.29260;
      <D.29259>:
      D.29253 = helper->call_conv;
      if (D.29253 == 0) goto <D.29261>; else goto <D.29262>;
      <D.29261>:
      D.29263 = helper->unmanaged_call_conv;
      idx = D.29263 + 4294967295;
      goto <D.29264>;
      <D.29262>:
      D.29253 = helper->call_conv;
      idx = D.29253 & 96;
      D.29253 = helper->call_conv;
      D.29265 = D.29253 & 2;
      if (D.29265 != 0) goto <D.29266>; else goto <D.29267>;
      <D.29266>:
      idx = idx + 5;
      <D.29267>:
      <D.29264>:
      D.29268 = (unsigned char) idx;
      D.29269 = (int) D.29268;
      sigbuffer_add_byte (&buf, D.29269);
      sigbuffer_add_value (&buf, nargs);
      D.29270 = helper->return_type;
      encode_reflection_type (assembly, D.29270, &buf);
      i = 0;
      goto <D.19668>;
      <D.19667>:
      {
        struct MonoArray * modreqs;
        struct MonoArray * modopts;
        struct MonoReflectionType * pt;

        modreqs = 0B;
        modopts = 0B;
        D.29271 = helper->modreqs;
        if (D.29271 != 0B) goto <D.29272>; else goto <D.29273>;
        <D.29272>:
        D.29274 = (long unsigned int) i;
        D.29271 = helper->modreqs;
        D.29275 = mono_array_length (D.29271);
        if (D.29274 < D.29275) goto <D.29276>; else goto <D.29277>;
        <D.29276>:
        D.29274 = (long unsigned int) i;
        D.29271 = helper->modreqs;
        D.29278 = mono_array_addr_with_size (D.29271, 8, D.29274);
        modreqs = MEM[(struct MonoArray * *)D.29278];
        <D.29277>:
        <D.29273>:
        D.29279 = helper->modopts;
        if (D.29279 != 0B) goto <D.29280>; else goto <D.29281>;
        <D.29280>:
        D.29274 = (long unsigned int) i;
        D.29279 = helper->modopts;
        D.29282 = mono_array_length (D.29279);
        if (D.29274 < D.29282) goto <D.29283>; else goto <D.29284>;
        <D.29283>:
        D.29274 = (long unsigned int) i;
        D.29279 = helper->modopts;
        D.29285 = mono_array_addr_with_size (D.29279, 8, D.29274);
        modopts = MEM[(struct MonoArray * *)D.29285];
        <D.29284>:
        <D.29281>:
        encode_custom_modifiers (assembly, modreqs, modopts, &buf);
        D.29274 = (long unsigned int) i;
        D.29247 = helper->arguments;
        D.29286 = mono_array_addr_with_size (D.29247, 8, D.29274);
        pt = MEM[(struct MonoReflectionType * *)D.29286];
        encode_reflection_type (assembly, pt, &buf);
      }
      i = i + 1;
      <D.19668>:
      if (i < nargs) goto <D.19667>; else goto <D.19669>;
      <D.19669>:
      idx = sigbuffer_add_to_blob_cached (assembly, &buf);
      sigbuffer_free (&buf);
      D.29240 = idx;
      return D.29240;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_image_get_field_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionFieldOnTypeBuilderInst * f)
{
  struct MonoGHashTable * D.29289;
  void * D.29290;
  long int D.29291;
  guint32 D.29294;
  struct MonoObject * D.29295;
  struct MonoVTable * D.29296;
  struct MonoClass * D.29297;
  int D.29298;
  struct MonoReflectionGenericClass * D.29301;
  unsigned char D.29302;
  unsigned char D.29303;
  _Bool D.29304;
  long int D.29305;
  long int D.29306;
  struct MonoString * D.29309;
  unsigned int D.29310;
  struct MonoType * D.29311;
  int D.29313;
  struct MonoType * D.29316;
  struct MonoClass * D.29317;
  struct MonoImage * D.29318;
  const char * D.29319;
  long unsigned int D.29321;
  void * D.29322;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoDynamicGenericClass * dgclass;
  struct MonoType * type;
  char * name;

  D.29289 = assembly->handleref_managed;
  D.29290 = mono_g_hash_table_lookup (D.29289, f);
  D.29291 = (long int) D.29290;
  token = (guint32) D.29291;
  if (token != 0) goto <D.29292>; else goto <D.29293>;
  <D.29292>:
  D.29294 = token;
  return D.29294;
  <D.29293>:
  D.29295 = f->fb;
  D.29296 = D.29295->vtable;
  D.29297 = D.29296->klass;
  D.29298 = is_sre_field_builder (D.29297);
  if (D.29298 != 0) goto <D.29299>; else goto <D.29300>;
  <D.29299>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = f->fb;
    D.29301 = f->inst;
    type = mono_reflection_type_get_handle (D.29301);
    klass = mono_class_from_mono_type (type);
    gclass = type->data.generic_class;
    D.29302 = BIT_FIELD_REF <*gclass, 8, 192>;
    D.29303 = D.29302 & 1;
    D.29304 = D.29303 == 0;
    D.29305 = (long int) D.29304;
    D.29306 = __builtin_expect (D.29305, 0);
    if (D.29306 != 0) goto <D.29307>; else goto <D.29308>;
    <D.29307>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2786, "gclass->is_dynamic");
    <D.29308>:
    dgclass = gclass;
    D.29309 = fb->name;
    name = mono_string_to_utf8 (D.29309);
    D.29310 = field_encode_signature (assembly, fb);
    D.29311 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.29311, name, D.29310);
    monoeg_g_free (name);
  }
  goto <D.29312>;
  <D.29300>:
  D.29295 = f->fb;
  D.29296 = D.29295->vtable;
  D.29297 = D.29296->klass;
  D.29313 = is_sr_mono_field (D.29297);
  if (D.29313 != 0) goto <D.29314>; else goto <D.29315>;
  <D.29314>:
  {
    guint32 sig;
    struct MonoClassField * field;

    D.29295 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.29295].field;
    D.29301 = f->inst;
    type = mono_reflection_type_get_handle (D.29301);
    klass = mono_class_from_mono_type (type);
    D.29316 = field->type;
    D.29317 = field->parent;
    D.29318 = D.29317->image;
    sig = fieldref_encode_signature (assembly, D.29318, D.29316);
    D.29319 = field->name;
    D.29311 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.29311, D.29319, sig);
  }
  goto <D.29320>;
  <D.29315>:
  {
    char * name;

    D.29295 = f->fb;
    D.29296 = D.29295->vtable;
    D.29297 = D.29296->klass;
    name = mono_type_get_full_name (D.29297);
    monoeg_g_log (0B, 4, "mono_image_get_field_on_inst_token: don\'t know how to handle %s", name);
    <D.19512>:
    goto <D.19512>;
  }
  <D.29320>:
  <D.29312>:
  D.29321 = (long unsigned int) token;
  D.29322 = (void *) D.29321;
  D.29289 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.29289, f, D.29322);
  D.29294 = token;
  return D.29294;
}


is_sre_field_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.160;
  gboolean D.29327;
  _Bool D.29328;
  int D.29329;
  int D.22654;
  int iftmp.161;
  int D.22650;
  const char[13] * D.29335;
  unsigned char D.29336;
  int D.29337;
  unsigned char D.29338;
  int D.29339;
  _Bool D.29340;
  _Bool D.29341;
  _Bool D.29342;
  const unsigned char * D.29345;
  unsigned char D.29346;
  int D.29347;
  const unsigned char * D.29348;
  unsigned char D.29349;
  int D.29350;
  _Bool D.29351;
  _Bool D.29352;
  const unsigned char * D.29355;
  unsigned char D.29356;
  int D.29357;
  const unsigned char * D.29358;
  unsigned char D.29359;
  int D.29360;
  _Bool D.29361;
  _Bool D.29362;
  const unsigned char * D.29365;
  unsigned char D.29366;
  int D.29367;
  const unsigned char * D.29368;
  unsigned char D.29369;
  int D.29370;
  const char * D.29372;
  int D.22663;
  int iftmp.162;
  int D.22659;
  const char[23] * D.29378;
  unsigned char D.29379;
  int D.29380;
  unsigned char D.29381;
  int D.29382;
  _Bool D.29383;
  _Bool D.29384;
  _Bool D.29385;
  const unsigned char * D.29388;
  unsigned char D.29389;
  int D.29390;
  const unsigned char * D.29391;
  unsigned char D.29392;
  int D.29393;
  _Bool D.29394;
  _Bool D.29395;
  const unsigned char * D.29398;
  unsigned char D.29399;
  int D.29400;
  const unsigned char * D.29401;
  unsigned char D.29402;
  int D.29403;
  _Bool D.29404;
  _Bool D.29405;
  const unsigned char * D.29408;
  unsigned char D.29409;
  int D.29410;
  const unsigned char * D.29411;
  unsigned char D.29412;
  int D.29413;
  const char * D.29415;

  {
    static struct MonoClass * cached_class;

    cached_class.160 = cached_class;
    if (cached_class.160 != 0B) goto <D.29325>; else goto <D.29326>;
    <D.29325>:
    cached_class.160 = cached_class;
    D.29328 = cached_class.160 == class;
    D.29327 = (gboolean) D.29328;
    return D.29327;
    <D.29326>:
    D.29329 = is_corlib_type (class);
    if (D.29329 != 0) goto <D.29330>; else goto <D.29331>;
    <D.29330>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29335 = "FieldBuilder";
        D.29336 = MEM[(const unsigned char *)D.29335];
        D.29337 = (int) D.29336;
        D.29338 = *__s2;
        D.29339 = (int) D.29338;
        __result = D.29337 - D.29339;
        {
          D.29340 = __s1_len != 0;
          D.29341 = __result == 0;
          D.29342 = D.29340 & D.29341;
          if (D.29342 != 0) goto <D.29343>; else goto <D.29344>;
          <D.29343>:
          D.29345 = &MEM[(void *)"FieldBuilder" + 1B];
          D.29346 = *D.29345;
          D.29347 = (int) D.29346;
          D.29348 = __s2 + 1;
          D.29349 = *D.29348;
          D.29350 = (int) D.29349;
          __result = D.29347 - D.29350;
          D.29351 = __s1_len > 1;
          D.29341 = __result == 0;
          D.29352 = D.29351 & D.29341;
          if (D.29352 != 0) goto <D.29353>; else goto <D.29354>;
          <D.29353>:
          D.29355 = &MEM[(void *)"FieldBuilder" + 2B];
          D.29356 = *D.29355;
          D.29357 = (int) D.29356;
          D.29358 = __s2 + 2;
          D.29359 = *D.29358;
          D.29360 = (int) D.29359;
          __result = D.29357 - D.29360;
          D.29361 = __s1_len > 2;
          D.29341 = __result == 0;
          D.29362 = D.29361 & D.29341;
          if (D.29362 != 0) goto <D.29363>; else goto <D.29364>;
          <D.29363>:
          D.29365 = &MEM[(void *)"FieldBuilder" + 3B];
          D.29366 = *D.29365;
          D.29367 = (int) D.29366;
          D.29368 = __s2 + 3;
          D.29369 = *D.29368;
          D.29370 = (int) D.29369;
          __result = D.29367 - D.29370;
          <D.29364>:
          <D.29354>:
          <D.29344>:
        }
        D.22650 = __result;
      }
      iftmp.161 = D.22650;
      goto <D.29371>;
      <D.29334>:
      D.29372 = class->name;
      iftmp.161 = __builtin_strcmp ("FieldBuilder", D.29372);
      <D.29371>:
      D.22654 = iftmp.161;
    }
    if (D.22654 == 0) goto <D.29373>; else goto <D.29374>;
    <D.29373>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29378 = "System.Reflection.Emit";
        D.29379 = MEM[(const unsigned char *)D.29378];
        D.29380 = (int) D.29379;
        D.29381 = *__s2;
        D.29382 = (int) D.29381;
        __result = D.29380 - D.29382;
        {
          D.29383 = __s1_len != 0;
          D.29384 = __result == 0;
          D.29385 = D.29383 & D.29384;
          if (D.29385 != 0) goto <D.29386>; else goto <D.29387>;
          <D.29386>:
          D.29388 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.29389 = *D.29388;
          D.29390 = (int) D.29389;
          D.29391 = __s2 + 1;
          D.29392 = *D.29391;
          D.29393 = (int) D.29392;
          __result = D.29390 - D.29393;
          D.29394 = __s1_len > 1;
          D.29384 = __result == 0;
          D.29395 = D.29394 & D.29384;
          if (D.29395 != 0) goto <D.29396>; else goto <D.29397>;
          <D.29396>:
          D.29398 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.29399 = *D.29398;
          D.29400 = (int) D.29399;
          D.29401 = __s2 + 2;
          D.29402 = *D.29401;
          D.29403 = (int) D.29402;
          __result = D.29400 - D.29403;
          D.29404 = __s1_len > 2;
          D.29384 = __result == 0;
          D.29405 = D.29404 & D.29384;
          if (D.29405 != 0) goto <D.29406>; else goto <D.29407>;
          <D.29406>:
          D.29408 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.29409 = *D.29408;
          D.29410 = (int) D.29409;
          D.29411 = __s2 + 3;
          D.29412 = *D.29411;
          D.29413 = (int) D.29412;
          __result = D.29410 - D.29413;
          <D.29407>:
          <D.29397>:
          <D.29387>:
        }
        D.22659 = __result;
      }
      iftmp.162 = D.22659;
      goto <D.29414>;
      <D.29377>:
      D.29415 = class->name_space;
      iftmp.162 = __builtin_strcmp ("System.Reflection.Emit", D.29415);
      <D.29414>:
      D.22663 = iftmp.162;
    }
    if (D.22663 == 0) goto <D.29416>; else goto <D.29417>;
    <D.29416>:
    cached_class = class;
    D.29327 = 1;
    return D.29327;
    <D.29417>:
    <D.29374>:
    <D.29331>:
    D.29327 = 0;
    return D.29327;
  }
}


is_sr_mono_field (struct MonoClass * class)
{
  struct MonoClass * cached_class.163;
  gboolean D.29422;
  _Bool D.29423;
  int D.29424;
  int D.22812;
  int iftmp.164;
  int D.22808;
  const char[10] * D.29430;
  unsigned char D.29431;
  int D.29432;
  unsigned char D.29433;
  int D.29434;
  _Bool D.29435;
  _Bool D.29436;
  _Bool D.29437;
  const unsigned char * D.29440;
  unsigned char D.29441;
  int D.29442;
  const unsigned char * D.29443;
  unsigned char D.29444;
  int D.29445;
  _Bool D.29446;
  _Bool D.29447;
  const unsigned char * D.29450;
  unsigned char D.29451;
  int D.29452;
  const unsigned char * D.29453;
  unsigned char D.29454;
  int D.29455;
  _Bool D.29456;
  _Bool D.29457;
  const unsigned char * D.29460;
  unsigned char D.29461;
  int D.29462;
  const unsigned char * D.29463;
  unsigned char D.29464;
  int D.29465;
  const char * D.29467;
  int D.22821;
  int iftmp.165;
  int D.22817;
  const char[18] * D.29473;
  unsigned char D.29474;
  int D.29475;
  unsigned char D.29476;
  int D.29477;
  _Bool D.29478;
  _Bool D.29479;
  _Bool D.29480;
  const unsigned char * D.29483;
  unsigned char D.29484;
  int D.29485;
  const unsigned char * D.29486;
  unsigned char D.29487;
  int D.29488;
  _Bool D.29489;
  _Bool D.29490;
  const unsigned char * D.29493;
  unsigned char D.29494;
  int D.29495;
  const unsigned char * D.29496;
  unsigned char D.29497;
  int D.29498;
  _Bool D.29499;
  _Bool D.29500;
  const unsigned char * D.29503;
  unsigned char D.29504;
  int D.29505;
  const unsigned char * D.29506;
  unsigned char D.29507;
  int D.29508;
  const char * D.29510;

  {
    static struct MonoClass * cached_class;

    cached_class.163 = cached_class;
    if (cached_class.163 != 0B) goto <D.29420>; else goto <D.29421>;
    <D.29420>:
    cached_class.163 = cached_class;
    D.29423 = cached_class.163 == class;
    D.29422 = (gboolean) D.29423;
    return D.29422;
    <D.29421>:
    D.29424 = is_corlib_type (class);
    if (D.29424 != 0) goto <D.29425>; else goto <D.29426>;
    <D.29425>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29430 = "MonoField";
        D.29431 = MEM[(const unsigned char *)D.29430];
        D.29432 = (int) D.29431;
        D.29433 = *__s2;
        D.29434 = (int) D.29433;
        __result = D.29432 - D.29434;
        {
          D.29435 = __s1_len != 0;
          D.29436 = __result == 0;
          D.29437 = D.29435 & D.29436;
          if (D.29437 != 0) goto <D.29438>; else goto <D.29439>;
          <D.29438>:
          D.29440 = &MEM[(void *)"MonoField" + 1B];
          D.29441 = *D.29440;
          D.29442 = (int) D.29441;
          D.29443 = __s2 + 1;
          D.29444 = *D.29443;
          D.29445 = (int) D.29444;
          __result = D.29442 - D.29445;
          D.29446 = __s1_len > 1;
          D.29436 = __result == 0;
          D.29447 = D.29446 & D.29436;
          if (D.29447 != 0) goto <D.29448>; else goto <D.29449>;
          <D.29448>:
          D.29450 = &MEM[(void *)"MonoField" + 2B];
          D.29451 = *D.29450;
          D.29452 = (int) D.29451;
          D.29453 = __s2 + 2;
          D.29454 = *D.29453;
          D.29455 = (int) D.29454;
          __result = D.29452 - D.29455;
          D.29456 = __s1_len > 2;
          D.29436 = __result == 0;
          D.29457 = D.29456 & D.29436;
          if (D.29457 != 0) goto <D.29458>; else goto <D.29459>;
          <D.29458>:
          D.29460 = &MEM[(void *)"MonoField" + 3B];
          D.29461 = *D.29460;
          D.29462 = (int) D.29461;
          D.29463 = __s2 + 3;
          D.29464 = *D.29463;
          D.29465 = (int) D.29464;
          __result = D.29462 - D.29465;
          <D.29459>:
          <D.29449>:
          <D.29439>:
        }
        D.22808 = __result;
      }
      iftmp.164 = D.22808;
      goto <D.29466>;
      <D.29429>:
      D.29467 = class->name;
      iftmp.164 = __builtin_strcmp ("MonoField", D.29467);
      <D.29466>:
      D.22812 = iftmp.164;
    }
    if (D.22812 == 0) goto <D.29468>; else goto <D.29469>;
    <D.29468>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29473 = "System.Reflection";
        D.29474 = MEM[(const unsigned char *)D.29473];
        D.29475 = (int) D.29474;
        D.29476 = *__s2;
        D.29477 = (int) D.29476;
        __result = D.29475 - D.29477;
        {
          D.29478 = __s1_len != 0;
          D.29479 = __result == 0;
          D.29480 = D.29478 & D.29479;
          if (D.29480 != 0) goto <D.29481>; else goto <D.29482>;
          <D.29481>:
          D.29483 = &MEM[(void *)"System.Reflection" + 1B];
          D.29484 = *D.29483;
          D.29485 = (int) D.29484;
          D.29486 = __s2 + 1;
          D.29487 = *D.29486;
          D.29488 = (int) D.29487;
          __result = D.29485 - D.29488;
          D.29489 = __s1_len > 1;
          D.29479 = __result == 0;
          D.29490 = D.29489 & D.29479;
          if (D.29490 != 0) goto <D.29491>; else goto <D.29492>;
          <D.29491>:
          D.29493 = &MEM[(void *)"System.Reflection" + 2B];
          D.29494 = *D.29493;
          D.29495 = (int) D.29494;
          D.29496 = __s2 + 2;
          D.29497 = *D.29496;
          D.29498 = (int) D.29497;
          __result = D.29495 - D.29498;
          D.29499 = __s1_len > 2;
          D.29479 = __result == 0;
          D.29500 = D.29499 & D.29479;
          if (D.29500 != 0) goto <D.29501>; else goto <D.29502>;
          <D.29501>:
          D.29503 = &MEM[(void *)"System.Reflection" + 3B];
          D.29504 = *D.29503;
          D.29505 = (int) D.29504;
          D.29506 = __s2 + 3;
          D.29507 = *D.29506;
          D.29508 = (int) D.29507;
          __result = D.29505 - D.29508;
          <D.29502>:
          <D.29492>:
          <D.29482>:
        }
        D.22817 = __result;
      }
      iftmp.165 = D.22817;
      goto <D.29509>;
      <D.29472>:
      D.29510 = class->name_space;
      iftmp.165 = __builtin_strcmp ("System.Reflection", D.29510);
      <D.29509>:
      D.22821 = iftmp.165;
    }
    if (D.22821 == 0) goto <D.29511>; else goto <D.29512>;
    <D.29511>:
    cached_class = class;
    D.29422 = 1;
    return D.29422;
    <D.29512>:
    <D.29469>:
    <D.29426>:
    D.29422 = 0;
    return D.29422;
  }
}


mono_image_get_ctor_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionCtorOnTypeBuilderInst * c, gboolean create_methodspec)
{
  struct MonoGHashTable * D.29514;
  void * D.29515;
  long int D.29516;
  guint32 D.29519;
  struct MonoObject * D.29520;
  struct MonoVTable * D.29521;
  struct MonoClass * D.29522;
  int D.29523;
  struct MonoReflectionGenericClass * D.29526;
  unsigned char D.29527;
  unsigned char D.29528;
  _Bool D.29529;
  long int D.29530;
  long int D.29531;
  struct MonoString * D.29534;
  struct MonoType * D.29535;
  int D.29537;
  struct MonoMethodSignature * D.29540;
  const char * D.29541;
  long unsigned int D.29543;
  void * D.29544;
  guint32 sig;
  guint32 token;
  struct MonoClass * klass;
  struct MonoGenericClass * gclass;
  struct MonoType * type;

  D.29514 = assembly->handleref_managed;
  D.29515 = mono_g_hash_table_lookup (D.29514, c);
  D.29516 = (long int) D.29515;
  token = (guint32) D.29516;
  if (token != 0) goto <D.29517>; else goto <D.29518>;
  <D.29517>:
  D.29519 = token;
  return D.29519;
  <D.29518>:
  D.29520 = c->cb;
  D.29521 = D.29520->vtable;
  D.29522 = D.29521->klass;
  D.29523 = is_sre_ctor_builder (D.29522);
  if (D.29523 != 0) goto <D.29524>; else goto <D.29525>;
  <D.29524>:
  {
    struct MonoReflectionCtorBuilder * cb;
    struct MonoDynamicGenericClass * dgclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        cb = c->cb;
        D.29526 = c->inst;
        type = mono_reflection_type_get_handle (D.29526);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.29527 = BIT_FIELD_REF <*gclass, 8, 192>;
        D.29528 = D.29527 & 1;
        D.29529 = D.29528 == 0;
        D.29530 = (long int) D.29529;
        D.29531 = __builtin_expect (D.29530, 0);
        if (D.29531 != 0) goto <D.29532>; else goto <D.29533>;
        <D.29532>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2835, "gclass->is_dynamic");
        <D.29533>:
        dgclass = gclass;
        reflection_methodbuilder_from_ctor_builder (&rmb, cb);
        D.29534 = rmb.name;
        name = mono_string_to_utf8 (D.29534);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.29535 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.29535, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.29536>;
  <D.29525>:
  D.29520 = c->cb;
  D.29521 = D.29520->vtable;
  D.29522 = D.29521->klass;
  D.29537 = is_sr_mono_cmethod (D.29522);
  if (D.29537 != 0) goto <D.29538>; else goto <D.29539>;
  <D.29538>:
  {
    struct MonoMethod * mm;

    D.29520 = c->cb;
    mm = MEM[(struct MonoReflectionMethod *)D.29520].method;
    D.29526 = c->inst;
    type = mono_reflection_type_get_handle (D.29526);
    klass = mono_class_from_mono_type (type);
    D.29540 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.29540);
    D.29541 = mm->name;
    D.29535 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.29535, D.29541, sig);
  }
  goto <D.29542>;
  <D.29539>:
  {
    char * name;

    D.29520 = c->cb;
    D.29521 = D.29520->vtable;
    D.29522 = D.29521->klass;
    name = mono_type_get_full_name (D.29522);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19529>:
    goto <D.19529>;
  }
  <D.29542>:
  <D.29536>:
  D.29543 = (long unsigned int) token;
  D.29544 = (void *) D.29543;
  D.29514 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.29514, c, D.29544);
  D.29519 = token;
  return D.29519;
}


is_sre_ctor_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.166;
  gboolean D.29549;
  _Bool D.29550;
  int D.29551;
  int D.22632;
  int iftmp.167;
  int D.22628;
  const char[19] * D.29557;
  unsigned char D.29558;
  int D.29559;
  unsigned char D.29560;
  int D.29561;
  _Bool D.29562;
  _Bool D.29563;
  _Bool D.29564;
  const unsigned char * D.29567;
  unsigned char D.29568;
  int D.29569;
  const unsigned char * D.29570;
  unsigned char D.29571;
  int D.29572;
  _Bool D.29573;
  _Bool D.29574;
  const unsigned char * D.29577;
  unsigned char D.29578;
  int D.29579;
  const unsigned char * D.29580;
  unsigned char D.29581;
  int D.29582;
  _Bool D.29583;
  _Bool D.29584;
  const unsigned char * D.29587;
  unsigned char D.29588;
  int D.29589;
  const unsigned char * D.29590;
  unsigned char D.29591;
  int D.29592;
  const char * D.29594;
  int D.22641;
  int iftmp.168;
  int D.22637;
  const char[23] * D.29600;
  unsigned char D.29601;
  int D.29602;
  unsigned char D.29603;
  int D.29604;
  _Bool D.29605;
  _Bool D.29606;
  _Bool D.29607;
  const unsigned char * D.29610;
  unsigned char D.29611;
  int D.29612;
  const unsigned char * D.29613;
  unsigned char D.29614;
  int D.29615;
  _Bool D.29616;
  _Bool D.29617;
  const unsigned char * D.29620;
  unsigned char D.29621;
  int D.29622;
  const unsigned char * D.29623;
  unsigned char D.29624;
  int D.29625;
  _Bool D.29626;
  _Bool D.29627;
  const unsigned char * D.29630;
  unsigned char D.29631;
  int D.29632;
  const unsigned char * D.29633;
  unsigned char D.29634;
  int D.29635;
  const char * D.29637;

  {
    static struct MonoClass * cached_class;

    cached_class.166 = cached_class;
    if (cached_class.166 != 0B) goto <D.29547>; else goto <D.29548>;
    <D.29547>:
    cached_class.166 = cached_class;
    D.29550 = cached_class.166 == class;
    D.29549 = (gboolean) D.29550;
    return D.29549;
    <D.29548>:
    D.29551 = is_corlib_type (class);
    if (D.29551 != 0) goto <D.29552>; else goto <D.29553>;
    <D.29552>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29557 = "ConstructorBuilder";
        D.29558 = MEM[(const unsigned char *)D.29557];
        D.29559 = (int) D.29558;
        D.29560 = *__s2;
        D.29561 = (int) D.29560;
        __result = D.29559 - D.29561;
        {
          D.29562 = __s1_len != 0;
          D.29563 = __result == 0;
          D.29564 = D.29562 & D.29563;
          if (D.29564 != 0) goto <D.29565>; else goto <D.29566>;
          <D.29565>:
          D.29567 = &MEM[(void *)"ConstructorBuilder" + 1B];
          D.29568 = *D.29567;
          D.29569 = (int) D.29568;
          D.29570 = __s2 + 1;
          D.29571 = *D.29570;
          D.29572 = (int) D.29571;
          __result = D.29569 - D.29572;
          D.29573 = __s1_len > 1;
          D.29563 = __result == 0;
          D.29574 = D.29573 & D.29563;
          if (D.29574 != 0) goto <D.29575>; else goto <D.29576>;
          <D.29575>:
          D.29577 = &MEM[(void *)"ConstructorBuilder" + 2B];
          D.29578 = *D.29577;
          D.29579 = (int) D.29578;
          D.29580 = __s2 + 2;
          D.29581 = *D.29580;
          D.29582 = (int) D.29581;
          __result = D.29579 - D.29582;
          D.29583 = __s1_len > 2;
          D.29563 = __result == 0;
          D.29584 = D.29583 & D.29563;
          if (D.29584 != 0) goto <D.29585>; else goto <D.29586>;
          <D.29585>:
          D.29587 = &MEM[(void *)"ConstructorBuilder" + 3B];
          D.29588 = *D.29587;
          D.29589 = (int) D.29588;
          D.29590 = __s2 + 3;
          D.29591 = *D.29590;
          D.29592 = (int) D.29591;
          __result = D.29589 - D.29592;
          <D.29586>:
          <D.29576>:
          <D.29566>:
        }
        D.22628 = __result;
      }
      iftmp.167 = D.22628;
      goto <D.29593>;
      <D.29556>:
      D.29594 = class->name;
      iftmp.167 = __builtin_strcmp ("ConstructorBuilder", D.29594);
      <D.29593>:
      D.22632 = iftmp.167;
    }
    if (D.22632 == 0) goto <D.29595>; else goto <D.29596>;
    <D.29595>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29600 = "System.Reflection.Emit";
        D.29601 = MEM[(const unsigned char *)D.29600];
        D.29602 = (int) D.29601;
        D.29603 = *__s2;
        D.29604 = (int) D.29603;
        __result = D.29602 - D.29604;
        {
          D.29605 = __s1_len != 0;
          D.29606 = __result == 0;
          D.29607 = D.29605 & D.29606;
          if (D.29607 != 0) goto <D.29608>; else goto <D.29609>;
          <D.29608>:
          D.29610 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.29611 = *D.29610;
          D.29612 = (int) D.29611;
          D.29613 = __s2 + 1;
          D.29614 = *D.29613;
          D.29615 = (int) D.29614;
          __result = D.29612 - D.29615;
          D.29616 = __s1_len > 1;
          D.29606 = __result == 0;
          D.29617 = D.29616 & D.29606;
          if (D.29617 != 0) goto <D.29618>; else goto <D.29619>;
          <D.29618>:
          D.29620 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.29621 = *D.29620;
          D.29622 = (int) D.29621;
          D.29623 = __s2 + 2;
          D.29624 = *D.29623;
          D.29625 = (int) D.29624;
          __result = D.29622 - D.29625;
          D.29626 = __s1_len > 2;
          D.29606 = __result == 0;
          D.29627 = D.29626 & D.29606;
          if (D.29627 != 0) goto <D.29628>; else goto <D.29629>;
          <D.29628>:
          D.29630 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.29631 = *D.29630;
          D.29632 = (int) D.29631;
          D.29633 = __s2 + 3;
          D.29634 = *D.29633;
          D.29635 = (int) D.29634;
          __result = D.29632 - D.29635;
          <D.29629>:
          <D.29619>:
          <D.29609>:
        }
        D.22637 = __result;
      }
      iftmp.168 = D.22637;
      goto <D.29636>;
      <D.29599>:
      D.29637 = class->name_space;
      iftmp.168 = __builtin_strcmp ("System.Reflection.Emit", D.29637);
      <D.29636>:
      D.22641 = iftmp.168;
    }
    if (D.22641 == 0) goto <D.29638>; else goto <D.29639>;
    <D.29638>:
    cached_class = class;
    D.29549 = 1;
    return D.29549;
    <D.29639>:
    <D.29596>:
    <D.29553>:
    D.29549 = 0;
    return D.29549;
  }
}


is_sr_mono_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.169;
  gboolean D.29644;
  _Bool D.29645;
  int D.29646;
  int D.22878;
  int iftmp.170;
  int D.22874;
  const char[12] * D.29652;
  unsigned char D.29653;
  int D.29654;
  unsigned char D.29655;
  int D.29656;
  _Bool D.29657;
  _Bool D.29658;
  _Bool D.29659;
  const unsigned char * D.29662;
  unsigned char D.29663;
  int D.29664;
  const unsigned char * D.29665;
  unsigned char D.29666;
  int D.29667;
  _Bool D.29668;
  _Bool D.29669;
  const unsigned char * D.29672;
  unsigned char D.29673;
  int D.29674;
  const unsigned char * D.29675;
  unsigned char D.29676;
  int D.29677;
  _Bool D.29678;
  _Bool D.29679;
  const unsigned char * D.29682;
  unsigned char D.29683;
  int D.29684;
  const unsigned char * D.29685;
  unsigned char D.29686;
  int D.29687;
  const char * D.29689;
  int D.22887;
  int iftmp.171;
  int D.22883;
  const char[18] * D.29695;
  unsigned char D.29696;
  int D.29697;
  unsigned char D.29698;
  int D.29699;
  _Bool D.29700;
  _Bool D.29701;
  _Bool D.29702;
  const unsigned char * D.29705;
  unsigned char D.29706;
  int D.29707;
  const unsigned char * D.29708;
  unsigned char D.29709;
  int D.29710;
  _Bool D.29711;
  _Bool D.29712;
  const unsigned char * D.29715;
  unsigned char D.29716;
  int D.29717;
  const unsigned char * D.29718;
  unsigned char D.29719;
  int D.29720;
  _Bool D.29721;
  _Bool D.29722;
  const unsigned char * D.29725;
  unsigned char D.29726;
  int D.29727;
  const unsigned char * D.29728;
  unsigned char D.29729;
  int D.29730;
  const char * D.29732;

  {
    static struct MonoClass * cached_class;

    cached_class.169 = cached_class;
    if (cached_class.169 != 0B) goto <D.29642>; else goto <D.29643>;
    <D.29642>:
    cached_class.169 = cached_class;
    D.29645 = cached_class.169 == class;
    D.29644 = (gboolean) D.29645;
    return D.29644;
    <D.29643>:
    D.29646 = is_corlib_type (class);
    if (D.29646 != 0) goto <D.29647>; else goto <D.29648>;
    <D.29647>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.29652 = "MonoCMethod";
        D.29653 = MEM[(const unsigned char *)D.29652];
        D.29654 = (int) D.29653;
        D.29655 = *__s2;
        D.29656 = (int) D.29655;
        __result = D.29654 - D.29656;
        {
          D.29657 = __s1_len != 0;
          D.29658 = __result == 0;
          D.29659 = D.29657 & D.29658;
          if (D.29659 != 0) goto <D.29660>; else goto <D.29661>;
          <D.29660>:
          D.29662 = &MEM[(void *)"MonoCMethod" + 1B];
          D.29663 = *D.29662;
          D.29664 = (int) D.29663;
          D.29665 = __s2 + 1;
          D.29666 = *D.29665;
          D.29667 = (int) D.29666;
          __result = D.29664 - D.29667;
          D.29668 = __s1_len > 1;
          D.29658 = __result == 0;
          D.29669 = D.29668 & D.29658;
          if (D.29669 != 0) goto <D.29670>; else goto <D.29671>;
          <D.29670>:
          D.29672 = &MEM[(void *)"MonoCMethod" + 2B];
          D.29673 = *D.29672;
          D.29674 = (int) D.29673;
          D.29675 = __s2 + 2;
          D.29676 = *D.29675;
          D.29677 = (int) D.29676;
          __result = D.29674 - D.29677;
          D.29678 = __s1_len > 2;
          D.29658 = __result == 0;
          D.29679 = D.29678 & D.29658;
          if (D.29679 != 0) goto <D.29680>; else goto <D.29681>;
          <D.29680>:
          D.29682 = &MEM[(void *)"MonoCMethod" + 3B];
          D.29683 = *D.29682;
          D.29684 = (int) D.29683;
          D.29685 = __s2 + 3;
          D.29686 = *D.29685;
          D.29687 = (int) D.29686;
          __result = D.29684 - D.29687;
          <D.29681>:
          <D.29671>:
          <D.29661>:
        }
        D.22874 = __result;
      }
      iftmp.170 = D.22874;
      goto <D.29688>;
      <D.29651>:
      D.29689 = class->name;
      iftmp.170 = __builtin_strcmp ("MonoCMethod", D.29689);
      <D.29688>:
      D.22878 = iftmp.170;
    }
    if (D.22878 == 0) goto <D.29690>; else goto <D.29691>;
    <D.29690>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.29695 = "System.Reflection";
        D.29696 = MEM[(const unsigned char *)D.29695];
        D.29697 = (int) D.29696;
        D.29698 = *__s2;
        D.29699 = (int) D.29698;
        __result = D.29697 - D.29699;
        {
          D.29700 = __s1_len != 0;
          D.29701 = __result == 0;
          D.29702 = D.29700 & D.29701;
          if (D.29702 != 0) goto <D.29703>; else goto <D.29704>;
          <D.29703>:
          D.29705 = &MEM[(void *)"System.Reflection" + 1B];
          D.29706 = *D.29705;
          D.29707 = (int) D.29706;
          D.29708 = __s2 + 1;
          D.29709 = *D.29708;
          D.29710 = (int) D.29709;
          __result = D.29707 - D.29710;
          D.29711 = __s1_len > 1;
          D.29701 = __result == 0;
          D.29712 = D.29711 & D.29701;
          if (D.29712 != 0) goto <D.29713>; else goto <D.29714>;
          <D.29713>:
          D.29715 = &MEM[(void *)"System.Reflection" + 2B];
          D.29716 = *D.29715;
          D.29717 = (int) D.29716;
          D.29718 = __s2 + 2;
          D.29719 = *D.29718;
          D.29720 = (int) D.29719;
          __result = D.29717 - D.29720;
          D.29721 = __s1_len > 2;
          D.29701 = __result == 0;
          D.29722 = D.29721 & D.29701;
          if (D.29722 != 0) goto <D.29723>; else goto <D.29724>;
          <D.29723>:
          D.29725 = &MEM[(void *)"System.Reflection" + 3B];
          D.29726 = *D.29725;
          D.29727 = (int) D.29726;
          D.29728 = __s2 + 3;
          D.29729 = *D.29728;
          D.29730 = (int) D.29729;
          __result = D.29727 - D.29730;
          <D.29724>:
          <D.29714>:
          <D.29704>:
        }
        D.22883 = __result;
      }
      iftmp.171 = D.22883;
      goto <D.29731>;
      <D.29694>:
      D.29732 = class->name_space;
      iftmp.171 = __builtin_strcmp ("System.Reflection", D.29732);
      <D.29731>:
      D.22887 = iftmp.171;
    }
    if (D.22887 == 0) goto <D.29733>; else goto <D.29734>;
    <D.29733>:
    cached_class = class;
    D.29644 = 1;
    return D.29644;
    <D.29734>:
    <D.29691>:
    <D.29648>:
    D.29644 = 0;
    return D.29644;
  }
}


mono_image_get_method_on_inst_token (struct MonoDynamicImage * assembly, struct MonoReflectionMethodOnTypeBuilderInst * m, gboolean create_methodspec)
{
  struct MonoArray * D.29736;
  guint32 D.29742;
  struct MonoGHashTable * D.29743;
  void * D.29744;
  long int D.29745;
  struct MonoObject * D.29748;
  struct MonoVTable * D.29749;
  struct MonoClass * D.29750;
  int D.29751;
  struct MonoReflectionType * D.29754;
  unsigned char D.29755;
  unsigned char D.29756;
  _Bool D.29757;
  long int D.29758;
  long int D.29759;
  struct MonoString * D.29762;
  struct MonoType * D.29763;
  int D.29765;
  struct MonoMethodSignature * D.29768;
  const char * D.29769;
  long unsigned int D.29771;
  void * D.29772;
  guint32 sig;
  guint32 token;
  struct MonoType * type;
  struct MonoClass * klass;

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

    inflated = mono_reflection_method_on_tb_inst_get_handle (m);
    if (create_methodspec != 0) goto <D.29739>; else goto <D.29740>;
    <D.29739>:
    token = mono_image_get_methodspec_token (assembly, inflated);
    goto <D.29741>;
    <D.29740>:
    token = mono_image_get_inflated_method_token (assembly, inflated);
    <D.29741>:
    D.29742 = token;
    return D.29742;
  }
  <D.29738>:
  D.29743 = assembly->handleref_managed;
  D.29744 = mono_g_hash_table_lookup (D.29743, m);
  D.29745 = (long int) D.29744;
  token = (guint32) D.29745;
  if (token != 0) goto <D.29746>; else goto <D.29747>;
  <D.29746>:
  D.29742 = token;
  return D.29742;
  <D.29747>:
  D.29748 = m->mb;
  D.29749 = D.29748->vtable;
  D.29750 = D.29749->klass;
  D.29751 = is_sre_method_builder (D.29750);
  if (D.29751 != 0) goto <D.29752>; else goto <D.29753>;
  <D.29752>:
  {
    struct MonoReflectionMethodBuilder * mb;
    struct MonoGenericClass * gclass;
    struct ReflectionMethodBuilder rmb;
    char * name;

    try
      {
        mb = m->mb;
        D.29754 = m->inst;
        type = mono_reflection_type_get_handle (D.29754);
        klass = mono_class_from_mono_type (type);
        gclass = type->data.generic_class;
        D.29755 = BIT_FIELD_REF <*gclass, 8, 192>;
        D.29756 = D.29755 & 1;
        D.29757 = D.29756 == 0;
        D.29758 = (long int) D.29757;
        D.29759 = __builtin_expect (D.29758, 0);
        if (D.29759 != 0) goto <D.29760>; else goto <D.29761>;
        <D.29760>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 2934, "gclass->is_dynamic");
        <D.29761>:
        reflection_methodbuilder_from_method_builder (&rmb, mb);
        D.29762 = rmb.name;
        name = mono_string_to_utf8 (D.29762);
        sig = method_builder_encode_signature (assembly, &rmb);
        D.29763 = &klass->byval_arg;
        token = mono_image_get_memberref_token (assembly, D.29763, name, sig);
        monoeg_g_free (name);
      }
    finally
      {
        rmb = {CLOBBER};
      }
  }
  goto <D.29764>;
  <D.29753>:
  D.29748 = m->mb;
  D.29749 = D.29748->vtable;
  D.29750 = D.29749->klass;
  D.29765 = is_sr_mono_method (D.29750);
  if (D.29765 != 0) goto <D.29766>; else goto <D.29767>;
  <D.29766>:
  {
    struct MonoMethod * mm;

    D.29748 = m->mb;
    mm = MEM[(struct MonoReflectionMethod *)D.29748].method;
    D.29754 = m->inst;
    type = mono_reflection_type_get_handle (D.29754);
    klass = mono_class_from_mono_type (type);
    D.29768 = mono_method_signature (mm);
    sig = method_encode_signature (assembly, D.29768);
    D.29769 = mm->name;
    D.29763 = &klass->byval_arg;
    token = mono_image_get_memberref_token (assembly, D.29763, D.29769, sig);
  }
  goto <D.29770>;
  <D.29767>:
  {
    char * name;

    D.29748 = m->mb;
    D.29749 = D.29748->vtable;
    D.29750 = D.29749->klass;
    name = mono_type_get_full_name (D.29750);
    monoeg_g_log (0B, 4, "mono_image_get_method_on_inst_token: don\'t know how to handle %s", name);
    <D.19561>:
    goto <D.19561>;
  }
  <D.29770>:
  <D.29764>:
  D.29771 = (long unsigned int) token;
  D.29772 = (void *) D.29771;
  D.29743 = assembly->handleref_managed;
  mono_g_hash_table_insert (D.29743, m, D.29772);
  D.29742 = token;
  return D.29742;
}


mono_reflection_method_on_tb_inst_get_handle (struct MonoReflectionMethodOnTypeBuilderInst * m)
{
  struct MonoReflectionType * D.29774;
  struct MonoObject * D.29775;
  struct MonoArray * D.29776;
  struct MonoMethod * D.29779;
  unsigned char D.29780;
  unsigned char D.29781;
  long unsigned int D.29784;
  long unsigned int D.29785;
  long unsigned int D.29786;
  long unsigned int D.29787;
  char * D.29788;
  long unsigned int D.29789;
  long unsigned int D.29790;
  struct MonoType * * D.29791;
  struct MonoType * D.29792;
  struct MonoGenericInst * iftmp.172;
  struct MonoGenericClass * D.29794;
  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.29774 = m->inst;
      init_type_builder_generics (D.29774);
      D.29775 = m->mb;
      D.29774 = m->inst;
      method = inflate_method (D.29774, D.29775);
      klass = method->klass;
      D.29776 = m->method_args;
      if (D.29776 == 0B) goto <D.29777>; else goto <D.29778>;
      <D.29777>:
      D.29779 = method;
      return D.29779;
      <D.29778>:
      D.29780 = BIT_FIELD_REF <*method, 8, 264>;
      D.29781 = D.29780 & 16;
      if (D.29781 != 0) goto <D.29782>; else goto <D.29783>;
      <D.29782>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.29783>:
      D.29776 = m->method_args;
      D.29784 = mono_array_length (D.29776);
      count = (int) D.29784;
      D.29785 = (long unsigned int) count;
      D.29786 = D.29785 * 8;
      type_argv = monoeg_malloc0 (D.29786);
      i = 0;
      goto <D.19543>;
      <D.19542>:
      {
        struct MonoReflectionType * garg;

        D.29787 = (long unsigned int) i;
        D.29776 = m->method_args;
        D.29788 = mono_array_addr_with_size (D.29776, 8, D.29787);
        garg = MEM[(void * *)D.29788];
        D.29789 = (long unsigned int) i;
        D.29790 = D.29789 * 8;
        D.29791 = type_argv + D.29790;
        D.29792 = mono_reflection_type_get_handle (garg);
        *D.29791 = D.29792;
      }
      i = i + 1;
      <D.19543>:
      if (i < count) goto <D.19542>; else goto <D.19544>;
      <D.19544>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.29794 = klass->generic_class;
      if (D.29794 != 0B) goto <D.29795>; else goto <D.29796>;
      <D.29795>:
      D.29794 = klass->generic_class;
      iftmp.172 = D.29794->context.class_inst;
      goto <D.29797>;
      <D.29796>:
      iftmp.172 = 0B;
      <D.29797>:
      tmp_context.class_inst = iftmp.172;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      D.29779 = inflated;
      return D.29779;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_method (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoVTable * D.29800;
  int D.29801;
  struct MonoReflectionType * D.29804;
  struct MonoType * D.29805;
  int D.29807;
  struct MonoType * D.29810;
  struct MonoType * D.29812;
  struct MonoClass * D.29816;
  char * D.29817;
  int D.23384;
  int iftmp.173;
  int D.23383;
  struct MonoVTable * D.29821;
  struct MonoClass * D.29822;
  const char[14] * D.29823;
  unsigned char D.29824;
  int D.29825;
  unsigned char D.29826;
  int D.29827;
  _Bool D.29828;
  _Bool D.29829;
  _Bool D.29830;
  const unsigned char * D.29833;
  unsigned char D.29834;
  int D.29835;
  const unsigned char * D.29836;
  unsigned char D.29837;
  int D.29838;
  _Bool D.29839;
  _Bool D.29840;
  const unsigned char * D.29843;
  unsigned char D.29844;
  int D.29845;
  const unsigned char * D.29846;
  unsigned char D.29847;
  int D.29848;
  _Bool D.29849;
  _Bool D.29850;
  const unsigned char * D.29853;
  unsigned char D.29854;
  int D.29855;
  const unsigned char * D.29856;
  unsigned char D.29857;
  int D.29858;
  const char * D.29860;
  struct MonoMethod * D.29863;
  int D.23393;
  int iftmp.174;
  int D.23392;
  const char[19] * D.29871;
  unsigned char D.29872;
  int D.29873;
  unsigned char D.29874;
  int D.29875;
  _Bool D.29876;
  _Bool D.29877;
  _Bool D.29878;
  const unsigned char * D.29881;
  unsigned char D.29882;
  int D.29883;
  const unsigned char * D.29884;
  unsigned char D.29885;
  int D.29886;
  _Bool D.29887;
  _Bool D.29888;
  const unsigned char * D.29891;
  unsigned char D.29892;
  int D.29893;
  const unsigned char * D.29894;
  unsigned char D.29895;
  int D.29896;
  _Bool D.29897;
  _Bool D.29898;
  const unsigned char * D.29901;
  unsigned char D.29902;
  int D.29903;
  const unsigned char * D.29904;
  unsigned char D.29905;
  int D.29906;
  int D.23402;
  int iftmp.175;
  int D.23401;
  const char[11] * D.29917;
  unsigned char D.29918;
  int D.29919;
  unsigned char D.29920;
  int D.29921;
  _Bool D.29922;
  _Bool D.29923;
  _Bool D.29924;
  const unsigned char * D.29927;
  unsigned char D.29928;
  int D.29929;
  const unsigned char * D.29930;
  unsigned char D.29931;
  int D.29932;
  _Bool D.29933;
  _Bool D.29934;
  const unsigned char * D.29937;
  unsigned char D.29938;
  int D.29939;
  const unsigned char * D.29940;
  unsigned char D.29941;
  int D.29942;
  _Bool D.29943;
  _Bool D.29944;
  const unsigned char * D.29947;
  unsigned char D.29948;
  int D.29949;
  const unsigned char * D.29950;
  unsigned char D.29951;
  int D.29952;
  int D.23411;
  int iftmp.176;
  int D.23410;
  const char[12] * D.29958;
  unsigned char D.29959;
  int D.29960;
  unsigned char D.29961;
  int D.29962;
  _Bool D.29963;
  _Bool D.29964;
  _Bool D.29965;
  const unsigned char * D.29968;
  unsigned char D.29969;
  int D.29970;
  const unsigned char * D.29971;
  unsigned char D.29972;
  int D.29973;
  _Bool D.29974;
  _Bool D.29975;
  const unsigned char * D.29978;
  unsigned char D.29979;
  int D.29980;
  const unsigned char * D.29981;
  unsigned char D.29982;
  int D.29983;
  _Bool D.29984;
  _Bool D.29985;
  const unsigned char * D.29988;
  unsigned char D.29989;
  int D.29990;
  const unsigned char * D.29991;
  unsigned char D.29992;
  int D.29993;
  struct MonoMethod * D.29995;
  struct MonoType * D.29996;
  struct MonoClass * D.29997;
  struct MonoMethod * method;
  struct MonoClass * gklass;
  struct MonoClass * type_class;

  D.29800 = MEM[(struct MonoObject *)type].vtable;
  type_class = D.29800->klass;
  D.29801 = is_sre_generic_instance (type_class);
  if (D.29801 != 0) goto <D.29802>; else goto <D.29803>;
  <D.29802>:
  {
    struct MonoReflectionGenericClass * mgc;

    mgc = type;
    D.29804 = mgc->generic_type;
    D.29805 = mono_reflection_type_get_handle (D.29804);
    gklass = mono_class_from_mono_type (D.29805);
  }
  goto <D.29806>;
  <D.29803>:
  D.29807 = is_sre_type_builder (type_class);
  if (D.29807 != 0) goto <D.29808>; else goto <D.29809>;
  <D.29808>:
  D.29810 = mono_reflection_type_get_handle (type);
  gklass = mono_class_from_mono_type (D.29810);
  goto <D.29811>;
  <D.29809>:
  D.29812 = type->type;
  if (D.29812 != 0B) goto <D.29813>; else goto <D.29814>;
  <D.29813>:
  D.29812 = type->type;
  gklass = mono_class_from_mono_type (D.29812);
  gklass = mono_class_get_generic_type_definition (gklass);
  goto <D.29815>;
  <D.29814>:
  D.29800 = MEM[(struct MonoObject *)type].vtable;
  D.29816 = D.29800->klass;
  D.29817 = mono_type_get_full_name (D.29816);
  monoeg_g_log (0B, 4, "Can\'t handle type %s", D.29817);
  <D.23375>:
  goto <D.23375>;
  <D.29815>:
  <D.29811>:
  <D.29806>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29821 = obj->vtable;
      D.29822 = D.29821->klass;
      __s2 = D.29822->name;
      D.29823 = "MethodBuilder";
      D.29824 = MEM[(const unsigned char *)D.29823];
      D.29825 = (int) D.29824;
      D.29826 = *__s2;
      D.29827 = (int) D.29826;
      __result = D.29825 - D.29827;
      {
        D.29828 = __s2_len != 0;
        D.29829 = __result == 0;
        D.29830 = D.29828 & D.29829;
        if (D.29830 != 0) goto <D.29831>; else goto <D.29832>;
        <D.29831>:
        D.29833 = &MEM[(void *)"MethodBuilder" + 1B];
        D.29834 = *D.29833;
        D.29835 = (int) D.29834;
        D.29836 = __s2 + 1;
        D.29837 = *D.29836;
        D.29838 = (int) D.29837;
        __result = D.29835 - D.29838;
        D.29839 = __s2_len > 1;
        D.29829 = __result == 0;
        D.29840 = D.29839 & D.29829;
        if (D.29840 != 0) goto <D.29841>; else goto <D.29842>;
        <D.29841>:
        D.29843 = &MEM[(void *)"MethodBuilder" + 2B];
        D.29844 = *D.29843;
        D.29845 = (int) D.29844;
        D.29846 = __s2 + 2;
        D.29847 = *D.29846;
        D.29848 = (int) D.29847;
        __result = D.29845 - D.29848;
        D.29849 = __s2_len > 2;
        D.29829 = __result == 0;
        D.29850 = D.29849 & D.29829;
        if (D.29850 != 0) goto <D.29851>; else goto <D.29852>;
        <D.29851>:
        D.29853 = &MEM[(void *)"MethodBuilder" + 3B];
        D.29854 = *D.29853;
        D.29855 = (int) D.29854;
        D.29856 = __s2 + 3;
        D.29857 = *D.29856;
        D.29858 = (int) D.29857;
        __result = D.29855 - D.29858;
        <D.29852>:
        <D.29842>:
        <D.29832>:
      }
      D.23383 = __result;
    }
    iftmp.173 = -D.23383;
    goto <D.29859>;
    <D.29820>:
    D.29821 = obj->vtable;
    D.29822 = D.29821->klass;
    D.29860 = D.29822->name;
    iftmp.173 = __builtin_strcmp (D.29860, "MethodBuilder");
    <D.29859>:
    D.23384 = iftmp.173;
  }
  if (D.23384 == 0) goto <D.29861>; else goto <D.29862>;
  <D.29861>:
  D.29863 = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  if (D.29863 != 0B) goto <D.29864>; else goto <D.29865>;
  <D.29864>:
  method = MEM[(struct MonoReflectionMethodBuilder *)obj].mhandle;
  goto <D.29866>;
  <D.29865>:
  method = methodbuilder_to_mono_method (gklass, obj);
  <D.29866>:
  goto <D.29867>;
  <D.29862>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29821 = obj->vtable;
      D.29822 = D.29821->klass;
      __s2 = D.29822->name;
      D.29871 = "ConstructorBuilder";
      D.29872 = MEM[(const unsigned char *)D.29871];
      D.29873 = (int) D.29872;
      D.29874 = *__s2;
      D.29875 = (int) D.29874;
      __result = D.29873 - D.29875;
      {
        D.29876 = __s2_len != 0;
        D.29877 = __result == 0;
        D.29878 = D.29876 & D.29877;
        if (D.29878 != 0) goto <D.29879>; else goto <D.29880>;
        <D.29879>:
        D.29881 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.29882 = *D.29881;
        D.29883 = (int) D.29882;
        D.29884 = __s2 + 1;
        D.29885 = *D.29884;
        D.29886 = (int) D.29885;
        __result = D.29883 - D.29886;
        D.29887 = __s2_len > 1;
        D.29877 = __result == 0;
        D.29888 = D.29887 & D.29877;
        if (D.29888 != 0) goto <D.29889>; else goto <D.29890>;
        <D.29889>:
        D.29891 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.29892 = *D.29891;
        D.29893 = (int) D.29892;
        D.29894 = __s2 + 2;
        D.29895 = *D.29894;
        D.29896 = (int) D.29895;
        __result = D.29893 - D.29896;
        D.29897 = __s2_len > 2;
        D.29877 = __result == 0;
        D.29898 = D.29897 & D.29877;
        if (D.29898 != 0) goto <D.29899>; else goto <D.29900>;
        <D.29899>:
        D.29901 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.29902 = *D.29901;
        D.29903 = (int) D.29902;
        D.29904 = __s2 + 3;
        D.29905 = *D.29904;
        D.29906 = (int) D.29905;
        __result = D.29903 - D.29906;
        <D.29900>:
        <D.29890>:
        <D.29880>:
      }
      D.23392 = __result;
    }
    iftmp.174 = -D.23392;
    goto <D.29907>;
    <D.29870>:
    D.29821 = obj->vtable;
    D.29822 = D.29821->klass;
    D.29860 = D.29822->name;
    iftmp.174 = __builtin_strcmp (D.29860, "ConstructorBuilder");
    <D.29907>:
    D.23393 = iftmp.174;
  }
  if (D.23393 == 0) goto <D.29908>; else goto <D.29909>;
  <D.29908>:
  method = ctorbuilder_to_mono_method (gklass, obj);
  goto <D.29910>;
  <D.29909>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29821 = obj->vtable;
      D.29822 = D.29821->klass;
      __s2 = D.29822->name;
      D.29917 = "MonoMethod";
      D.29918 = MEM[(const unsigned char *)D.29917];
      D.29919 = (int) D.29918;
      D.29920 = *__s2;
      D.29921 = (int) D.29920;
      __result = D.29919 - D.29921;
      {
        D.29922 = __s2_len != 0;
        D.29923 = __result == 0;
        D.29924 = D.29922 & D.29923;
        if (D.29924 != 0) goto <D.29925>; else goto <D.29926>;
        <D.29925>:
        D.29927 = &MEM[(void *)"MonoMethod" + 1B];
        D.29928 = *D.29927;
        D.29929 = (int) D.29928;
        D.29930 = __s2 + 1;
        D.29931 = *D.29930;
        D.29932 = (int) D.29931;
        __result = D.29929 - D.29932;
        D.29933 = __s2_len > 1;
        D.29923 = __result == 0;
        D.29934 = D.29933 & D.29923;
        if (D.29934 != 0) goto <D.29935>; else goto <D.29936>;
        <D.29935>:
        D.29937 = &MEM[(void *)"MonoMethod" + 2B];
        D.29938 = *D.29937;
        D.29939 = (int) D.29938;
        D.29940 = __s2 + 2;
        D.29941 = *D.29940;
        D.29942 = (int) D.29941;
        __result = D.29939 - D.29942;
        D.29943 = __s2_len > 2;
        D.29923 = __result == 0;
        D.29944 = D.29943 & D.29923;
        if (D.29944 != 0) goto <D.29945>; else goto <D.29946>;
        <D.29945>:
        D.29947 = &MEM[(void *)"MonoMethod" + 3B];
        D.29948 = *D.29947;
        D.29949 = (int) D.29948;
        D.29950 = __s2 + 3;
        D.29951 = *D.29950;
        D.29952 = (int) D.29951;
        __result = D.29949 - D.29952;
        <D.29946>:
        <D.29936>:
        <D.29926>:
      }
      D.23401 = __result;
    }
    iftmp.175 = -D.23401;
    goto <D.29953>;
    <D.29916>:
    D.29821 = obj->vtable;
    D.29822 = D.29821->klass;
    D.29860 = D.29822->name;
    iftmp.175 = __builtin_strcmp (D.29860, "MonoMethod");
    <D.29953>:
    D.23402 = iftmp.175;
  }
  if (D.23402 == 0) goto <D.29911>; else goto <D.29954>;
  <D.29954>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29821 = obj->vtable;
      D.29822 = D.29821->klass;
      __s2 = D.29822->name;
      D.29958 = "MonoCMethod";
      D.29959 = MEM[(const unsigned char *)D.29958];
      D.29960 = (int) D.29959;
      D.29961 = *__s2;
      D.29962 = (int) D.29961;
      __result = D.29960 - D.29962;
      {
        D.29963 = __s2_len != 0;
        D.29964 = __result == 0;
        D.29965 = D.29963 & D.29964;
        if (D.29965 != 0) goto <D.29966>; else goto <D.29967>;
        <D.29966>:
        D.29968 = &MEM[(void *)"MonoCMethod" + 1B];
        D.29969 = *D.29968;
        D.29970 = (int) D.29969;
        D.29971 = __s2 + 1;
        D.29972 = *D.29971;
        D.29973 = (int) D.29972;
        __result = D.29970 - D.29973;
        D.29974 = __s2_len > 1;
        D.29964 = __result == 0;
        D.29975 = D.29974 & D.29964;
        if (D.29975 != 0) goto <D.29976>; else goto <D.29977>;
        <D.29976>:
        D.29978 = &MEM[(void *)"MonoCMethod" + 2B];
        D.29979 = *D.29978;
        D.29980 = (int) D.29979;
        D.29981 = __s2 + 2;
        D.29982 = *D.29981;
        D.29983 = (int) D.29982;
        __result = D.29980 - D.29983;
        D.29984 = __s2_len > 2;
        D.29964 = __result == 0;
        D.29985 = D.29984 & D.29964;
        if (D.29985 != 0) goto <D.29986>; else goto <D.29987>;
        <D.29986>:
        D.29988 = &MEM[(void *)"MonoCMethod" + 3B];
        D.29989 = *D.29988;
        D.29990 = (int) D.29989;
        D.29991 = __s2 + 3;
        D.29992 = *D.29991;
        D.29993 = (int) D.29992;
        __result = D.29990 - D.29993;
        <D.29987>:
        <D.29977>:
        <D.29967>:
      }
      D.23410 = __result;
    }
    iftmp.176 = -D.23410;
    goto <D.29994>;
    <D.29957>:
    D.29821 = obj->vtable;
    D.29822 = D.29821->klass;
    D.29860 = D.29822->name;
    iftmp.176 = __builtin_strcmp (D.29860, "MonoCMethod");
    <D.29994>:
    D.23411 = iftmp.176;
  }
  if (D.23411 == 0) goto <D.29911>; else goto <D.29912>;
  <D.29911>:
  method = MEM[(struct MonoReflectionMethod *)obj].method;
  goto <D.29913>;
  <D.29912>:
  method = 0B;
  D.29821 = obj->vtable;
  D.29822 = D.29821->klass;
  D.29860 = D.29822->name;
  monoeg_g_log (0B, 4, "can\'t handle type %s", D.29860);
  <D.23412>:
  goto <D.23412>;
  <D.29913>:
  <D.29910>:
  <D.29867>:
  D.29996 = mono_reflection_type_get_handle (type);
  D.29997 = mono_class_from_mono_type (D.29996);
  D.29995 = inflate_mono_method (D.29997, method, obj);
  return D.29995;
}


is_sre_generic_instance (struct MonoClass * class)
{
  struct MonoClass * cached_class.177;
  gboolean D.30002;
  _Bool D.30003;
  int D.30004;
  int D.22566;
  int iftmp.178;
  int D.22562;
  const char[17] * D.30010;
  unsigned char D.30011;
  int D.30012;
  unsigned char D.30013;
  int D.30014;
  _Bool D.30015;
  _Bool D.30016;
  _Bool D.30017;
  const unsigned char * D.30020;
  unsigned char D.30021;
  int D.30022;
  const unsigned char * D.30023;
  unsigned char D.30024;
  int D.30025;
  _Bool D.30026;
  _Bool D.30027;
  const unsigned char * D.30030;
  unsigned char D.30031;
  int D.30032;
  const unsigned char * D.30033;
  unsigned char D.30034;
  int D.30035;
  _Bool D.30036;
  _Bool D.30037;
  const unsigned char * D.30040;
  unsigned char D.30041;
  int D.30042;
  const unsigned char * D.30043;
  unsigned char D.30044;
  int D.30045;
  const char * D.30047;
  int D.22575;
  int iftmp.179;
  int D.22571;
  const char[18] * D.30053;
  unsigned char D.30054;
  int D.30055;
  unsigned char D.30056;
  int D.30057;
  _Bool D.30058;
  _Bool D.30059;
  _Bool D.30060;
  const unsigned char * D.30063;
  unsigned char D.30064;
  int D.30065;
  const unsigned char * D.30066;
  unsigned char D.30067;
  int D.30068;
  _Bool D.30069;
  _Bool D.30070;
  const unsigned char * D.30073;
  unsigned char D.30074;
  int D.30075;
  const unsigned char * D.30076;
  unsigned char D.30077;
  int D.30078;
  _Bool D.30079;
  _Bool D.30080;
  const unsigned char * D.30083;
  unsigned char D.30084;
  int D.30085;
  const unsigned char * D.30086;
  unsigned char D.30087;
  int D.30088;
  const char * D.30090;

  {
    static struct MonoClass * cached_class;

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

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

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

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

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


methodbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionMethodBuilder * mb)
{
  struct MonoImage * D.30094;
  struct MonoMethod * D.30095;
  struct MonoArray * D.30096;
  struct MonoMethod * D.30097;
  int D.30098;
  struct MonoGenericContainer * D.30101;
  struct MonoMethod * D.30104;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.30094 = klass->image;
      sig = method_builder_to_signature (D.30094, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_method_builder (&rmb, mb);
      D.30095 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.30095;
      D.30096 = mb->cattrs;
      D.30097 = mb->mhandle;
      D.30094 = klass->image;
      mono_save_custom_attrs (D.30094, D.30097, D.30096);
      D.30094 = klass->image;
      D.30098 = MEM[(struct MonoDynamicImage *)D.30094].save;
      if (D.30098 == 0) goto <D.30099>; else goto <D.30100>;
      <D.30099>:
      D.30101 = klass->generic_container;
      if (D.30101 == 0B) goto <D.30102>; else goto <D.30103>;
      <D.30102>:
      mb->ilgen = 0B;
      <D.30103>:
      <D.30100>:
      D.30104 = mb->mhandle;
      return D.30104;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


method_builder_to_signature (struct MonoImage * image, struct MonoReflectionMethodBuilder * method)
{
  struct MonoArray * D.30107;
  unsigned int D.30108;
  unsigned int D.30109;
  _Bool D.30110;
  struct MonoType * iftmp.180;
  struct MonoObject * D.30112;
  struct MonoClass * D.30116;
  short unsigned int iftmp.181;
  struct MonoArray * D.30118;
  long unsigned int D.30121;
  struct MonoMethodSignature * D.30123;
  struct MonoMethodSignature * sig;

  D.30107 = method->parameters;
  sig = parameters_to_signature (image, D.30107);
  D.30108 = method->attrs;
  D.30109 = D.30108 & 16;
  D.30110 = D.30109 == 0;
  sig->hasthis = D.30110;
  D.30112 = method->rtype;
  if (D.30112 != 0B) goto <D.30113>; else goto <D.30114>;
  <D.30113>:
  D.30112 = method->rtype;
  iftmp.180 = mono_reflection_type_get_handle (D.30112);
  goto <D.30115>;
  <D.30114>:
  D.30116 = mono_defaults.void_class;
  iftmp.180 = &D.30116->byval_arg;
  <D.30115>:
  sig->ret = iftmp.180;
  D.30118 = method->generic_params;
  if (D.30118 != 0B) goto <D.30119>; else goto <D.30120>;
  <D.30119>:
  D.30118 = method->generic_params;
  D.30121 = mono_array_length (D.30118);
  iftmp.181 = (short unsigned int) D.30121;
  goto <D.30122>;
  <D.30120>:
  iftmp.181 = 0;
  <D.30122>:
  sig->generic_param_count = iftmp.181;
  D.30123 = sig;
  return D.30123;
}


parameters_to_signature (struct MonoImage * image, struct MonoArray * parameters)
{
  int iftmp.182;
  long unsigned int D.30128;
  long unsigned int D.30130;
  long unsigned int D.30131;
  unsigned int D.30132;
  unsigned int D.30133;
  short unsigned int D.30134;
  long unsigned int D.30135;
  char * D.30136;
  void * D.30137;
  struct MonoType * D.30138;
  struct MonoMethodSignature * D.30139;
  struct MonoMethodSignature * sig;
  int count;
  int i;

  if (parameters != 0B) goto <D.30126>; else goto <D.30127>;
  <D.30126>:
  D.30128 = mono_array_length (parameters);
  iftmp.182 = (int) D.30128;
  goto <D.30129>;
  <D.30127>:
  iftmp.182 = 0;
  <D.30129>:
  count = iftmp.182;
  D.30130 = (long unsigned int) count;
  D.30131 = D.30130 + 2;
  D.30132 = (unsigned int) D.30131;
  D.30133 = D.30132 * 8;
  sig = image_g_malloc0 (image, D.30133);
  D.30134 = (short unsigned int) count;
  sig->param_count = D.30134;
  sig->sentinelpos = -1;
  i = 0;
  goto <D.22750>;
  <D.22749>:
  D.30135 = (long unsigned int) i;
  D.30136 = mono_array_addr_with_size (parameters, 8, D.30135);
  D.30137 = MEM[(void * *)D.30136];
  D.30138 = mono_reflection_type_get_handle (D.30137);
  sig->params[i] = D.30138;
  i = i + 1;
  <D.22750>:
  if (i < count) goto <D.22749>; else goto <D.22751>;
  <D.22751>:
  D.30139 = sig;
  return D.30139;
}


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

  if (image != 0B) goto <D.30141>; else goto <D.30142>;
  <D.30141>:
  D.30143 = mono_image_alloc0 (image, size);
  return D.30143;
  <D.30142>:
  D.30144 = (long unsigned int) size;
  D.30143 = monoeg_malloc0 (D.30144);
  return D.30143;
}


reflection_methodbuilder_to_mono_method (struct MonoClass * klass, struct ReflectionMethodBuilder * rmb, struct MonoMethodSignature * sig)
{
  void * * D.30146;
  _Bool D.30147;
  struct MonoImage * iftmp.183;
  struct MonoGenericClass * D.30154;
  _Bool D.30155;
  long int D.30156;
  long int D.30157;
  long unsigned int D.30160;
  long unsigned int D.30161;
  unsigned char D.30165;
  <unnamed-unsigned:1> D.30166;
  unsigned int D.30167;
  short unsigned int D.30168;
  unsigned int D.30169;
  short unsigned int D.30170;
  struct MonoString * D.30171;
  char * D.30172;
  unsigned char D.30173;
  <unnamed-unsigned:1> D.30174;
  guint32 * D.30175;
  unsigned int D.30178;
  unsigned int D.30179;
  short unsigned int D.30180;
  int D.30181;
  int D.30182;
  struct MonoClass * D.30185;
  int D.23242;
  int iftmp.184;
  int D.23241;
  const char[6] * D.30191;
  unsigned char D.30192;
  int D.30193;
  unsigned char D.30194;
  int D.30195;
  _Bool D.30196;
  _Bool D.30197;
  _Bool D.30198;
  const unsigned char * D.30201;
  unsigned char D.30202;
  int D.30203;
  const unsigned char * D.30204;
  unsigned char D.30205;
  int D.30206;
  _Bool D.30207;
  _Bool D.30208;
  const unsigned char * D.30211;
  unsigned char D.30212;
  int D.30213;
  const unsigned char * D.30214;
  unsigned char D.30215;
  int D.30216;
  _Bool D.30217;
  _Bool D.30218;
  const unsigned char * D.30221;
  unsigned char D.30222;
  int D.30223;
  const unsigned char * D.30224;
  unsigned char D.30225;
  int D.30226;
  const char * D.30228;
  struct MonoMethodSignature * D.30231;
  short unsigned int D.30233;
  int D.30234;
  int D.30235;
  char * iftmp.185;
  struct MonoString * D.30239;
  int D.30243;
  _Bool D.30244;
  long int D.30245;
  long int D.30246;
  struct MonoString * D.30249;
  char * D.30250;
  int D.30251;
  _Bool D.30252;
  long int D.30253;
  long int D.30254;
  int D.30257;
  int D.30258;
  signed short D.30259;
  signed short iftmp.186;
  int D.30261;
  int D.30264;
  unsigned short D.30265;
  unsigned short D.30266;
  signed short D.30268;
  int D.30269;
  signed short D.30270;
  signed short D.30271;
  short unsigned int D.30272;
  struct MonoImage * D.30273;
  unsigned char D.30274;
  unsigned char D.30275;
  struct GHashTable * D.30278;
  struct MonoMethod * D.30279;
  int D.30280;
  int D.30283;
  struct MonoReflectionILGen * D.30286;
  struct MonoArray * D.30289;
  int D.30290;
  gint32 iftmp.187;
  struct MonoArray * D.30292;
  long unsigned int D.30295;
  struct MonoArray * D.30297;
  unsigned int D.30300;
  struct MonoArray * D.30302;
  long unsigned int D.30305;
  long unsigned int D.30307;
  long unsigned int D.30308;
  unsigned int D.30309;
  unsigned int D.30310;
  void * D.30311;
  long unsigned int D.30312;
  const unsigned char * D.30313;
  short unsigned int D.30314;
  <unnamed-unsigned:15> D.30315;
  unsigned char D.30316;
  <unnamed-unsigned:1> D.30317;
  short unsigned int D.30318;
  long unsigned int D.30319;
  char * D.30320;
  void * D.30321;
  struct MonoObject * D.30322;
  struct MonoType * D.30323;
  struct MonoType * D.30324;
  short unsigned int D.30325;
  <unnamed-unsigned:15> D.30326;
  unsigned int num_clauses.188;
  struct MonoExceptionClause * D.30330;
  struct MonoArray * D.30331;
  long unsigned int D.30334;
  _Bool D.30335;
  long int D.30336;
  long int D.30337;
  <unnamed-signed:31> D.30340;
  long unsigned int D.30341;
  unsigned int D.30342;
  unsigned int D.30343;
  void * D.30344;
  long unsigned int D.30345;
  char * D.30346;
  struct MonoType * D.30347;
  struct MonoGenericParamFull * D.30348;
  long unsigned int D.30349;
  long unsigned int D.30350;
  struct MonoGenericParamFull * D.30351;
  unsigned char D.30352;
  short unsigned int D.30355;
  int D.30356;
  struct MonoType * D.30359;
  struct MonoType * D.30360;
  long unsigned int D.30361;
  long unsigned int D.30362;
  struct MonoGenericParam * D.30363;
  short unsigned int D.30364;
  int D.30365;
  struct MonoGenericContainer * D.30366;
  struct MonoGenericInst * D.30369;
  struct MonoGenericInst * D.30370;
  unsigned int D.30373;
  unsigned int D.30374;
  unsigned int D.30375;
  long unsigned int D.30376;
  void * D.30377;
  sizetype D.30378;
  sizetype D.30379;
  sizetype D.30380;
  void * * D.30381;
  long unsigned int D.30382;
  long unsigned int D.30383;
  void * * D.30384;
  void * D.30385;
  unsigned int i.189;
  struct MonoArray * D.30387;
  struct MonoMethodSignature * D.30392;
  short unsigned int D.30393;
  int D.30394;
  int D.30395;
  long unsigned int D.30396;
  unsigned int D.30397;
  unsigned int D.30398;
  void * D.30399;
  char * D.30400;
  unsigned int D.30405;
  int D.30408;
  struct MonoType * D.30409;
  struct MonoType * D.30410;
  short unsigned int D.30411;
  unsigned int D.30412;
  uint8_t * * D.30415;
  int D.30418;
  long unsigned int D.30419;
  unsigned int D.30420;
  unsigned int D.30421;
  void * D.30422;
  unsigned int D.30423;
  void * D.30424;
  struct MonoObject * D.30425;
  char * D.30426;
  sizetype D.30427;
  const char * p2.190;
  long int p2.191;
  long int p.192;
  long int D.30431;
  unsigned int D.30432;
  long unsigned int D.30433;
  uint8_t * * D.30434;
  void * D.30435;
  uint32_t * D.30436;
  long unsigned int D.30437;
  uint32_t * D.30438;
  unsigned int def_type.193;
  long unsigned int D.30440;
  uint8_t * D.30441;
  struct MonoString * D.30442;
  char * * D.30445;
  char * * D.30446;
  char * D.30447;
  int D.30448;
  _Bool D.30449;
  long int D.30450;
  long int D.30451;
  struct MonoArray * D.30454;
  struct MonoCustomAttrInfo * * D.30457;
  void * D.30460;
  struct MonoCustomAttrInfo * * D.30461;
  struct MonoCustomAttrInfo * D.30462;
  char * D.30465;
  struct MonoReflectionMarshal * D.30468;
  short unsigned int D.30473;
  int D.30474;
  int D.30475;
  long unsigned int D.30476;
  unsigned int D.30477;
  unsigned int D.30478;
  int D.30479;
  long unsigned int D.30480;
  long unsigned int D.30481;
  struct MonoMarshalSpec * * D.30482;
  struct MonoAssembly * D.30483;
  struct MonoMarshalSpec * D.30484;
  long unsigned int D.30485;
  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.30146 = rmb->refs;
      D.30147 = D.30146 != 0B;
      dynamic = (gboolean) D.30147;
      if (dynamic == 0) goto <D.30149>; else goto <D.30150>;
      <D.30149>:
      iftmp.183 = klass->image;
      goto <D.30151>;
      <D.30150>:
      iftmp.183 = 0B;
      <D.30151>:
      image = iftmp.183;
      if (dynamic == 0) goto <D.30152>; else goto <D.30153>;
      <D.30152>:
      D.30154 = klass->generic_class;
      D.30155 = D.30154 != 0B;
      D.30156 = (long int) D.30155;
      D.30157 = __builtin_expect (D.30156, 0);
      if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
      <D.30158>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10133, "!klass->generic_class");
      <D.30159>:
      <D.30153>:
      mono_loader_lock ();
      D.30160 = BIT_FIELD_REF <*rmb, 64, 448>;
      D.30161 = D.30160 & 17592186052608;
      if (D.30161 != 0) goto <D.30162>; else goto <D.30163>;
      <D.30162>:
      m = image_g_malloc0 (image, 56);
      goto <D.30164>;
      <D.30163>:
      m = image_g_malloc0 (image, 56);
      <D.30164>:
      wrapperm = m;
      D.30165 = (unsigned char) dynamic;
      D.30166 = (<unnamed-unsigned:1>) D.30165;
      m->dynamic = D.30166;
      m->slot = -1;
      D.30167 = rmb->attrs;
      D.30168 = (short unsigned int) D.30167;
      m->flags = D.30168;
      D.30169 = rmb->iattrs;
      D.30170 = (short unsigned int) D.30169;
      m->iflags = D.30170;
      D.30171 = rmb->name;
      D.30172 = mono_string_to_utf8_image_ignore (image, D.30171);
      m->name = D.30172;
      m->klass = klass;
      m->signature = sig;
      m->sre_method = 1;
      D.30173 = rmb->skip_visibility;
      D.30174 = (<unnamed-unsigned:1>) D.30173;
      m->skip_visibility = D.30174;
      D.30175 = rmb->table_idx;
      if (D.30175 != 0B) goto <D.30176>; else goto <D.30177>;
      <D.30176>:
      D.30175 = rmb->table_idx;
      D.30178 = *D.30175;
      D.30179 = D.30178 | 100663296;
      m->token = D.30179;
      <D.30177>:
      D.30180 = m->iflags;
      D.30181 = (int) D.30180;
      D.30182 = D.30181 & 4096;
      if (D.30182 != 0) goto <D.30183>; else goto <D.30184>;
      <D.30183>:
      D.30185 = mono_defaults.string_class;
      if (D.30185 == klass) goto <D.30186>; else goto <D.30187>;
      <D.30186>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = m->name;
          D.30191 = ".ctor";
          D.30192 = MEM[(const unsigned char *)D.30191];
          D.30193 = (int) D.30192;
          D.30194 = *__s2;
          D.30195 = (int) D.30194;
          __result = D.30193 - D.30195;
          {
            D.30196 = __s2_len != 0;
            D.30197 = __result == 0;
            D.30198 = D.30196 & D.30197;
            if (D.30198 != 0) goto <D.30199>; else goto <D.30200>;
            <D.30199>:
            D.30201 = &MEM[(void *)".ctor" + 1B];
            D.30202 = *D.30201;
            D.30203 = (int) D.30202;
            D.30204 = __s2 + 1;
            D.30205 = *D.30204;
            D.30206 = (int) D.30205;
            __result = D.30203 - D.30206;
            D.30207 = __s2_len > 1;
            D.30197 = __result == 0;
            D.30208 = D.30207 & D.30197;
            if (D.30208 != 0) goto <D.30209>; else goto <D.30210>;
            <D.30209>:
            D.30211 = &MEM[(void *)".ctor" + 2B];
            D.30212 = *D.30211;
            D.30213 = (int) D.30212;
            D.30214 = __s2 + 2;
            D.30215 = *D.30214;
            D.30216 = (int) D.30215;
            __result = D.30213 - D.30216;
            D.30217 = __s2_len > 2;
            D.30197 = __result == 0;
            D.30218 = D.30217 & D.30197;
            if (D.30218 != 0) goto <D.30219>; else goto <D.30220>;
            <D.30219>:
            D.30221 = &MEM[(void *)".ctor" + 3B];
            D.30222 = *D.30221;
            D.30223 = (int) D.30222;
            D.30224 = __s2 + 3;
            D.30225 = *D.30224;
            D.30226 = (int) D.30225;
            __result = D.30223 - D.30226;
            <D.30220>:
            <D.30210>:
            <D.30200>:
          }
          D.23241 = __result;
        }
        iftmp.184 = -D.23241;
        goto <D.30227>;
        <D.30190>:
        D.30228 = m->name;
        iftmp.184 = __builtin_strcmp (D.30228, ".ctor");
        <D.30227>:
        D.23242 = iftmp.184;
      }
      if (D.23242 == 0) goto <D.30229>; else goto <D.30230>;
      <D.30229>:
      m->string_ctor = 1;
      <D.30230>:
      <D.30187>:
      D.30231 = m->signature;
      D.30231->pinvoke = 1;
      goto <D.30232>;
      <D.30184>:
      D.30233 = m->flags;
      D.30234 = (int) D.30233;
      D.30235 = D.30234 & 8192;
      if (D.30235 != 0) goto <D.30236>; else goto <D.30237>;
      <D.30236>:
      D.30231 = m->signature;
      D.30231->pinvoke = 1;
      method_aux = image_g_malloc0 (image, 56);
      D.30239 = rmb->dllentry;
      if (D.30239 != 0B) goto <D.30240>; else goto <D.30241>;
      <D.30240>:
      D.30239 = rmb->dllentry;
      iftmp.185 = mono_string_to_utf8_image (image, D.30239, &error);
      goto <D.30242>;
      <D.30241>:
      D.30228 = m->name;
      iftmp.185 = image_strdup (image, D.30228);
      <D.30242>:
      method_aux->dllentry = iftmp.185;
      D.30243 = mono_error_ok (&error);
      D.30244 = D.30243 == 0;
      D.30245 = (long int) D.30244;
      D.30246 = __builtin_expect (D.30245, 0);
      if (D.30246 != 0) goto <D.30247>; else goto <D.30248>;
      <D.30247>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10168, "mono_error_ok (&error)");
      <D.30248>:
      D.30249 = rmb->dll;
      D.30250 = mono_string_to_utf8_image (image, D.30249, &error);
      method_aux->dll = D.30250;
      D.30251 = mono_error_ok (&error);
      D.30252 = D.30251 == 0;
      D.30253 = (long int) D.30252;
      D.30254 = __builtin_expect (D.30253, 0);
      if (D.30254 != 0) goto <D.30255>; else goto <D.30256>;
      <D.30255>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10170, "mono_error_ok (&error)");
      <D.30256>:
      D.30257 = rmb->native_cc;
      D.30258 = D.30257 << 8;
      D.30259 = (signed short) D.30258;
      D.30261 = rmb->charset;
      if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
      <D.30262>:
      D.30261 = rmb->charset;
      D.30264 = D.30261 + -1;
      D.30265 = (unsigned short) D.30264;
      D.30266 = D.30265 * 2;
      iftmp.186 = (signed short) D.30266;
      goto <D.30267>;
      <D.30263>:
      iftmp.186 = 0;
      <D.30267>:
      D.30268 = D.30259 | iftmp.186;
      D.30269 = rmb->extra_flags;
      D.30270 = (signed short) D.30269;
      D.30271 = D.30268 | D.30270;
      D.30272 = (short unsigned int) D.30271;
      MEM[(struct MonoMethodPInvoke *)m].piflags = D.30272;
      D.30273 = klass->image;
      D.30274 = BIT_FIELD_REF <*D.30273, 8, 224>;
      D.30275 = D.30274 & 8;
      if (D.30275 != 0) goto <D.30276>; else goto <D.30277>;
      <D.30276>:
      D.30273 = klass->image;
      D.30278 = MEM[(struct MonoDynamicImage *)D.30273].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.30278, m, method_aux, 0);
      <D.30277>:
      mono_loader_unlock ();
      D.30279 = m;
      return D.30279;
      <D.30237>:
      D.30233 = m->flags;
      D.30234 = (int) D.30233;
      D.30280 = D.30234 & 1024;
      if (D.30280 == 0) goto <D.30281>; else goto <D.30282>;
      <D.30281>:
      D.30180 = m->iflags;
      D.30181 = (int) D.30180;
      D.30283 = D.30181 & 3;
      if (D.30283 == 0) goto <D.30284>; else goto <D.30285>;
      <D.30284>:
      {
        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.30286 = rmb->ilgen;
        if (D.30286 != 0B) goto <D.30287>; else goto <D.30288>;
        <D.30287>:
        D.30286 = rmb->ilgen;
        D.30289 = D.30286->code;
        code = mono_array_addr_with_size (D.30289, 1, 0);
        D.30286 = rmb->ilgen;
        D.30290 = D.30286->code_len;
        code_size = (guint32) D.30290;
        D.30286 = rmb->ilgen;
        max_stack = D.30286->max_stack;
        D.30286 = rmb->ilgen;
        D.30292 = D.30286->locals;
        if (D.30292 != 0B) goto <D.30293>; else goto <D.30294>;
        <D.30293>:
        D.30286 = rmb->ilgen;
        D.30292 = D.30286->locals;
        D.30295 = mono_array_length (D.30292);
        iftmp.187 = (gint32) D.30295;
        goto <D.30296>;
        <D.30294>:
        iftmp.187 = 0;
        <D.30296>:
        num_locals = iftmp.187;
        D.30286 = rmb->ilgen;
        D.30297 = D.30286->ex_handlers;
        if (D.30297 != 0B) goto <D.30298>; else goto <D.30299>;
        <D.30298>:
        D.30286 = rmb->ilgen;
        D.30300 = method_count_clauses (D.30286);
        num_clauses = (gint32) D.30300;
        <D.30299>:
        goto <D.30301>;
        <D.30288>:
        D.30302 = rmb->code;
        if (D.30302 != 0B) goto <D.30303>; else goto <D.30304>;
        <D.30303>:
        D.30302 = rmb->code;
        code = mono_array_addr_with_size (D.30302, 1, 0);
        D.30302 = rmb->code;
        D.30305 = mono_array_length (D.30302);
        code_size = (guint32) D.30305;
        max_stack = 8;
        goto <D.30306>;
        <D.30304>:
        code = 0B;
        code_size = 0;
        max_stack = 8;
        <D.30306>:
        <D.30301>:
        D.30307 = (long unsigned int) num_locals;
        D.30308 = D.30307 + 4;
        D.30309 = (unsigned int) D.30308;
        D.30310 = D.30309 * 8;
        header = image_g_malloc0 (image, D.30310);
        header->code_size = code_size;
        D.30311 = image_g_malloc (image, code_size);
        header->code = D.30311;
        D.30312 = (long unsigned int) code_size;
        D.30313 = header->code;
        memcpy (D.30313, code, D.30312);
        D.30314 = (short unsigned int) max_stack;
        D.30315 = (<unnamed-unsigned:15>) D.30314;
        header->max_stack = D.30315;
        D.30316 = rmb->init_locals;
        D.30317 = (<unnamed-unsigned:1>) D.30316;
        header->init_locals = D.30317;
        D.30318 = (short unsigned int) num_locals;
        header->num_locals = D.30318;
        i = 0;
        goto <D.23252>;
        <D.23251>:
        {
          struct MonoReflectionLocalBuilder * lb;

          D.30319 = (long unsigned int) i;
          D.30286 = rmb->ilgen;
          D.30292 = D.30286->locals;
          D.30320 = mono_array_addr_with_size (D.30292, 8, D.30319);
          lb = MEM[(struct MonoReflectionLocalBuilder * *)D.30320];
          D.30321 = image_g_malloc0 (image, 16);
          header->locals[i] = D.30321;
          D.30322 = lb->type;
          D.30323 = mono_reflection_type_get_handle (D.30322);
          D.30324 = header->locals[i];
          memcpy (D.30324, D.30323, 12);
        }
        i = i + 1;
        <D.23252>:
        if (i < num_locals) goto <D.23251>; else goto <D.23253>;
        <D.23253>:
        D.30325 = (short unsigned int) num_clauses;
        D.30326 = (<unnamed-unsigned:15>) D.30325;
        header->num_clauses = D.30326;
        if (num_clauses != 0) goto <D.30327>; else goto <D.30328>;
        <D.30327>:
        num_clauses.188 = (unsigned int) num_clauses;
        D.30286 = rmb->ilgen;
        D.30273 = klass->image;
        D.30330 = method_encode_clauses (image, D.30273, D.30286, num_clauses.188);
        header->clauses = D.30330;
        <D.30328>:
        wrapperm->header = header;
      }
      <D.30285>:
      <D.30282>:
      <D.30232>:
      D.30331 = rmb->generic_params;
      if (D.30331 != 0B) goto <D.30332>; else goto <D.30333>;
      <D.30332>:
      {
        int count;
        struct MonoGenericContainer * container;

        D.30331 = rmb->generic_params;
        D.30334 = mono_array_length (D.30331);
        count = (int) D.30334;
        container = rmb->generic_container;
        D.30335 = container == 0B;
        D.30336 = (long int) D.30335;
        D.30337 = __builtin_expect (D.30336, 0);
        if (D.30337 != 0) goto <D.30338>; else goto <D.30339>;
        <D.30338>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10239, "container");
        <D.30339>:
        D.30340 = (<unnamed-signed:31>) count;
        container->type_argc = D.30340;
        D.30341 = (long unsigned int) count;
        D.30342 = (unsigned int) D.30341;
        D.30343 = D.30342 * 56;
        D.30344 = image_g_malloc0 (image, D.30343);
        container->type_params = D.30344;
        container->owner.method = m;
        m->is_generic = 1;
        mono_method_set_generic_container (m, container);
        i = 0;
        goto <D.23259>;
        <D.23258>:
        {
          struct MonoReflectionGenericParam * gp;
          struct MonoGenericParamFull * param;

          D.30345 = (long unsigned int) i;
          D.30331 = rmb->generic_params;
          D.30346 = mono_array_addr_with_size (D.30331, 8, D.30345);
          gp = MEM[(struct MonoReflectionGenericParam * *)D.30346];
          D.30347 = mono_reflection_type_get_handle (gp);
          param = D.30347->data.generic_param;
          D.30348 = container->type_params;
          D.30349 = (long unsigned int) i;
          D.30350 = D.30349 * 56;
          D.30351 = D.30348 + D.30350;
          *D.30351 = *param;
        }
        i = i + 1;
        <D.23259>:
        if (i < count) goto <D.23258>; else goto <D.23260>;
        <D.23260>:
        i = 0;
        goto <D.23264>;
        <D.23263>:
        {
          struct MonoType * t;

          D.30231 = m->signature;
          t = D.30231->params[i];
          D.30352 = t->type;
          if (D.30352 == 30) goto <D.30353>; else goto <D.30354>;
          <D.30353>:
          {
            struct MonoGenericParam * gparam;

            gparam = t->data.generic_param;
            D.30355 = gparam->num;
            D.30356 = (int) D.30355;
            if (D.30356 < count) goto <D.30357>; else goto <D.30358>;
            <D.30357>:
            D.30231 = m->signature;
            D.30231 = m->signature;
            D.30359 = D.30231->params[i];
            D.30360 = mono_metadata_type_dup (image, D.30359);
            D.30231->params[i] = D.30360;
            D.30231 = m->signature;
            D.30359 = D.30231->params[i];
            D.30348 = container->type_params;
            D.30355 = gparam->num;
            D.30361 = (long unsigned int) D.30355;
            D.30362 = D.30361 * 56;
            D.30363 = D.30348 + D.30362;
            D.30359->data.generic_param = D.30363;
            <D.30358>:
          }
          <D.30354>:
        }
        i = i + 1;
        <D.23264>:
        D.30231 = m->signature;
        D.30364 = D.30231->param_count;
        D.30365 = (int) D.30364;
        if (D.30365 > i) goto <D.23263>; else goto <D.23265>;
        <D.23265>:
        D.30366 = klass->generic_container;
        if (D.30366 != 0B) goto <D.30367>; else goto <D.30368>;
        <D.30367>:
        D.30366 = klass->generic_container;
        container->parent = D.30366;
        D.30366 = klass->generic_container;
        D.30369 = D.30366->context.class_inst;
        container->context.class_inst = D.30369;
        <D.30368>:
        D.30370 = mono_get_shared_generic_inst (container);
        container->context.method_inst = D.30370;
      }
      <D.30333>:
      D.30146 = rmb->refs;
      if (D.30146 != 0B) goto <D.30371>; else goto <D.30372>;
      <D.30371>:
      {
        struct MonoMethodWrapper * mw;
        int i;
        void * * data;

        mw = m;
        m->wrapper_type = 17;
        D.30373 = rmb->nrefs;
        D.30374 = D.30373 + 1;
        D.30375 = D.30374 * 8;
        data = image_g_malloc (image, D.30375);
        mw->method_data = data;
        D.30373 = rmb->nrefs;
        D.30376 = (long unsigned int) D.30373;
        D.30377 = (void *) D.30376;
        *data = D.30377;
        i = 0;
        goto <D.23270>;
        <D.23269>:
        D.30378 = (sizetype) i;
        D.30379 = D.30378 + 1;
        D.30380 = D.30379 * 8;
        D.30381 = data + D.30380;
        D.30146 = rmb->refs;
        D.30382 = (long unsigned int) i;
        D.30383 = D.30382 * 8;
        D.30384 = D.30146 + D.30383;
        D.30385 = *D.30384;
        *D.30381 = D.30385;
        i = i + 1;
        <D.23270>:
        i.189 = (unsigned int) i;
        D.30373 = rmb->nrefs;
        if (i.189 < D.30373) goto <D.23269>; else goto <D.23271>;
        <D.23271>:
      }
      <D.30372>:
      method_aux = 0B;
      D.30387 = rmb->pinfo;
      if (D.30387 != 0B) goto <D.30388>; else goto <D.30389>;
      <D.30388>:
      if (method_aux == 0B) goto <D.30390>; else goto <D.30391>;
      <D.30390>:
      method_aux = image_g_malloc0 (image, 56);
      <D.30391>:
      D.30392 = mono_method_signature (m);
      D.30393 = D.30392->param_count;
      D.30394 = (int) D.30393;
      D.30395 = D.30394 + 1;
      D.30396 = (long unsigned int) D.30395;
      D.30397 = (unsigned int) D.30396;
      D.30398 = D.30397 * 8;
      D.30399 = image_g_malloc0 (image, D.30398);
      method_aux->param_names = D.30399;
      i = 0;
      goto <D.23280>;
      <D.23279>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.30345 = (long unsigned int) i;
        D.30387 = rmb->pinfo;
        D.30400 = mono_array_addr_with_size (D.30387, 8, D.30345);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.30400];
        if (pb != 0B) goto <D.30401>; else goto <D.30402>;
        <D.30401>:
        if (i > 0) goto <D.30403>; else goto <D.30404>;
        <D.30403>:
        D.30405 = pb->attrs;
        if (D.30405 != 0) goto <D.30406>; else goto <D.30407>;
        <D.30406>:
        D.30231 = m->signature;
        D.30408 = i + -1;
        D.30231 = m->signature;
        D.30408 = i + -1;
        D.30409 = D.30231->params[D.30408];
        D.30273 = klass->image;
        D.30410 = mono_metadata_type_dup (D.30273, D.30409);
        D.30231->params[D.30408] = D.30410;
        D.30231 = m->signature;
        D.30408 = i + -1;
        D.30409 = D.30231->params[D.30408];
        D.30405 = pb->attrs;
        D.30411 = (short unsigned int) D.30405;
        D.30409->attrs = D.30411;
        <D.30407>:
        <D.30404>:
        D.30405 = pb->attrs;
        D.30412 = D.30405 & 4096;
        if (D.30412 != 0) goto <D.30413>; else goto <D.30414>;
        <D.30413>:
        {
          struct MonoDynamicImage * assembly;
          guint32 idx;
          guint32 def_type;
          guint32 len;
          char * p;
          const char * p2;

          try
            {
              D.30415 = method_aux->param_defaults;
              if (D.30415 == 0B) goto <D.30416>; else goto <D.30417>;
              <D.30416>:
              D.30231 = m->signature;
              D.30364 = D.30231->param_count;
              D.30365 = (int) D.30364;
              D.30418 = D.30365 + 1;
              D.30419 = (long unsigned int) D.30418;
              D.30420 = (unsigned int) D.30419;
              D.30421 = D.30420 * 8;
              D.30422 = image_g_malloc0 (image, D.30421);
              method_aux->param_defaults = D.30422;
              D.30231 = m->signature;
              D.30364 = D.30231->param_count;
              D.30365 = (int) D.30364;
              D.30418 = D.30365 + 1;
              D.30419 = (long unsigned int) D.30418;
              D.30420 = (unsigned int) D.30419;
              D.30423 = D.30420 * 4;
              D.30424 = image_g_malloc0 (image, D.30423);
              method_aux->param_default_types = D.30424;
              <D.30417>:
              assembly = klass->image;
              D.30425 = pb->def_value;
              idx = encode_constant (assembly, D.30425, &def_type);
              D.30426 = assembly->blob.data;
              D.30427 = (sizetype) idx;
              p = D.30426 + D.30427;
              len = mono_metadata_decode_blob_size (p, &p2);
              p2.190 = p2;
              p2.191 = (long int) p2.190;
              p.192 = (long int) p;
              D.30431 = p2.191 - p.192;
              D.30432 = (unsigned int) D.30431;
              len = D.30432 + len;
              D.30415 = method_aux->param_defaults;
              D.30349 = (long unsigned int) i;
              D.30433 = D.30349 * 8;
              D.30434 = D.30415 + D.30433;
              D.30435 = image_g_malloc (image, len);
              *D.30434 = D.30435;
              D.30436 = method_aux->param_default_types;
              D.30349 = (long unsigned int) i;
              D.30437 = D.30349 * 4;
              D.30438 = D.30436 + D.30437;
              def_type.193 = def_type;
              *D.30438 = def_type.193;
              D.30440 = (long unsigned int) len;
              D.30415 = method_aux->param_defaults;
              D.30349 = (long unsigned int) i;
              D.30433 = D.30349 * 8;
              D.30434 = D.30415 + D.30433;
              D.30441 = *D.30434;
              memcpy (D.30441, p, D.30440);
            }
          finally
            {
              def_type = {CLOBBER};
              p2 = {CLOBBER};
            }
        }
        <D.30414>:
        D.30442 = pb->name;
        if (D.30442 != 0B) goto <D.30443>; else goto <D.30444>;
        <D.30443>:
        D.30445 = method_aux->param_names;
        D.30349 = (long unsigned int) i;
        D.30433 = D.30349 * 8;
        D.30446 = D.30445 + D.30433;
        D.30442 = pb->name;
        D.30447 = mono_string_to_utf8_image (image, D.30442, &error);
        *D.30446 = D.30447;
        D.30448 = mono_error_ok (&error);
        D.30449 = D.30448 == 0;
        D.30450 = (long int) D.30449;
        D.30451 = __builtin_expect (D.30450, 0);
        if (D.30451 != 0) goto <D.30452>; else goto <D.30453>;
        <D.30452>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10331, "mono_error_ok (&error)");
        <D.30453>:
        <D.30444>:
        D.30454 = pb->cattrs;
        if (D.30454 != 0B) goto <D.30455>; else goto <D.30456>;
        <D.30455>:
        D.30457 = method_aux->param_cattr;
        if (D.30457 == 0B) goto <D.30458>; else goto <D.30459>;
        <D.30458>:
        D.30231 = m->signature;
        D.30364 = D.30231->param_count;
        D.30365 = (int) D.30364;
        D.30418 = D.30365 + 1;
        D.30419 = (long unsigned int) D.30418;
        D.30420 = (unsigned int) D.30419;
        D.30421 = D.30420 * 8;
        D.30460 = image_g_malloc0 (image, D.30421);
        method_aux->param_cattr = D.30460;
        <D.30459>:
        D.30457 = method_aux->param_cattr;
        D.30349 = (long unsigned int) i;
        D.30433 = D.30349 * 8;
        D.30461 = D.30457 + D.30433;
        D.30454 = pb->cattrs;
        D.30273 = klass->image;
        D.30462 = mono_custom_attrs_from_builders (image, D.30273, D.30454);
        *D.30461 = D.30462;
        <D.30456>:
        <D.30402>:
      }
      i = i + 1;
      <D.23280>:
      D.30231 = m->signature;
      D.30364 = D.30231->param_count;
      D.30365 = (int) D.30364;
      if (D.30365 >= i) goto <D.23279>; else goto <D.23281>;
      <D.23281>:
      <D.30389>:
      specs = 0B;
      D.30387 = rmb->pinfo;
      if (D.30387 != 0B) goto <D.30463>; else goto <D.30464>;
      <D.30463>:
      i = 0;
      goto <D.23284>;
      <D.23283>:
      {
        struct MonoReflectionParamBuilder * pb;

        D.30345 = (long unsigned int) i;
        D.30387 = rmb->pinfo;
        D.30465 = mono_array_addr_with_size (D.30387, 8, D.30345);
        pb = MEM[(struct MonoReflectionParamBuilder * *)D.30465];
        if (pb != 0B) goto <D.30466>; else goto <D.30467>;
        <D.30466>:
        D.30468 = pb->marshal_info;
        if (D.30468 != 0B) goto <D.30469>; else goto <D.30470>;
        <D.30469>:
        if (specs == 0B) goto <D.30471>; else goto <D.30472>;
        <D.30471>:
        D.30473 = sig->param_count;
        D.30474 = (int) D.30473;
        D.30475 = D.30474 + 1;
        D.30476 = (long unsigned int) D.30475;
        D.30477 = (unsigned int) D.30476;
        D.30478 = D.30477 * 8;
        specs = image_g_malloc0 (image, D.30478);
        <D.30472>:
        D.30479 = pb->position;
        D.30480 = (long unsigned int) D.30479;
        D.30481 = D.30480 * 8;
        D.30482 = specs + D.30481;
        D.30468 = pb->marshal_info;
        D.30273 = klass->image;
        D.30483 = D.30273->assembly;
        D.30484 = mono_marshal_spec_from_builder (image, D.30483, D.30468);
        *D.30482 = D.30484;
        <D.30470>:
        <D.30467>:
      }
      i = i + 1;
      <D.23284>:
      D.30345 = (long unsigned int) i;
      D.30387 = rmb->pinfo;
      D.30485 = mono_array_length (D.30387);
      if (D.30345 < D.30485) goto <D.23283>; else goto <D.23285>;
      <D.23285>:
      <D.30464>:
      if (specs != 0B) goto <D.30486>; else goto <D.30487>;
      <D.30486>:
      if (method_aux == 0B) goto <D.30488>; else goto <D.30489>;
      <D.30488>:
      method_aux = image_g_malloc0 (image, 56);
      <D.30489>:
      method_aux->param_marshall = specs;
      <D.30487>:
      D.30273 = klass->image;
      D.30274 = BIT_FIELD_REF <*D.30273, 8, 224>;
      D.30275 = D.30274 & 8;
      if (D.30275 != 0) goto <D.30490>; else goto <D.30491>;
      <D.30490>:
      if (method_aux != 0B) goto <D.30492>; else goto <D.30493>;
      <D.30492>:
      D.30273 = klass->image;
      D.30278 = MEM[(struct MonoDynamicImage *)D.30273].method_aux_hash;
      monoeg_g_hash_table_insert_replace (D.30278, m, method_aux, 0);
      <D.30493>:
      <D.30491>:
      mono_loader_unlock ();
      D.30279 = m;
      return D.30279;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

  if (image != 0B) goto <D.30496>; else goto <D.30497>;
  <D.30496>:
  D.30498 = mono_image_strdup (image, s);
  return D.30498;
  <D.30497>:
  D.30498 = monoeg_strdup (s);
  return D.30498;
}


method_encode_clauses (struct MonoImage * image, struct MonoDynamicImage * assembly, struct MonoReflectionILGen * ilgen, guint32 num_clauses)
{
  unsigned int D.30500;
  struct MonoArray * D.30501;
  long unsigned int D.30502;
  unsigned int D.30503;
  unsigned int D.30504;
  long unsigned int D.30505;
  int D.30506;
  int D.30507;
  int D.30508;
  struct MonoArray * D.30509;
  long unsigned int D.30512;
  long unsigned int D.30513;
  long unsigned int D.30514;
  int D.30515;
  unsigned int D.30516;
  unsigned int D.30517;
  unsigned int D.30520;
  unsigned int D.30521;
  unsigned int D.30523;
  int D.30524;
  unsigned int D.30525;
  int D.30526;
  unsigned int D.30527;
  struct MonoObject * D.30528;
  struct MonoType * D.30531;
  struct MonoClass * D.30532;
  int D.30536;
  unsigned int D.30537;
  int D.30539;
  long unsigned int D.30540;
  struct MonoExceptionClause * D.30541;
  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.30500 = num_clauses * 32;
  clauses = image_g_malloc0 (image, D.30500);
  clause_index = 0;
  D.30501 = ilgen->ex_handlers;
  D.30502 = mono_array_length (D.30501);
  D.30503 = (unsigned int) D.30502;
  D.30504 = D.30503 + 4294967295;
  i = (int) D.30504;
  goto <D.18965>;
  <D.18964>:
  D.30505 = (long unsigned int) i;
  D.30501 = ilgen->ex_handlers;
  ex_info = mono_array_addr_with_size (D.30501, 24, D.30505);
  D.30506 = ex_info->start;
  D.30507 = ex_info->len;
  D.30508 = D.30506 + D.30507;
  finally_start = (guint32) D.30508;
  D.30509 = ex_info->handlers;
  if (D.30509 == 0B) goto <D.30510>; else goto <D.30511>;
  <D.30510>:
  // predicted unlikely by continue predictor.
  goto <D.18960>;
  <D.30511>:
  j = 0;
  goto <D.18962>;
  <D.18961>:
  D.30512 = (long unsigned int) j;
  D.30509 = ex_info->handlers;
  ex_block = mono_array_addr_with_size (D.30509, 24, D.30512);
  D.30513 = (long unsigned int) clause_index;
  D.30514 = D.30513 * 32;
  clause = clauses + D.30514;
  D.30515 = ex_block->type;
  D.30516 = (unsigned int) D.30515;
  clause->flags = D.30516;
  D.30506 = ex_info->start;
  D.30517 = (unsigned int) D.30506;
  clause->try_offset = D.30517;
  D.30515 = ex_block->type;
  if (D.30515 == 2) goto <D.30518>; else goto <D.30519>;
  <D.30518>:
  D.30506 = ex_info->start;
  D.30520 = (unsigned int) D.30506;
  D.30521 = finally_start - D.30520;
  clause->try_len = D.30521;
  goto <D.30522>;
  <D.30519>:
  D.30507 = ex_info->len;
  D.30523 = (unsigned int) D.30507;
  clause->try_len = D.30523;
  <D.30522>:
  D.30524 = ex_block->start;
  D.30525 = (unsigned int) D.30524;
  clause->handler_offset = D.30525;
  D.30526 = ex_block->len;
  D.30527 = (unsigned int) D.30526;
  clause->handler_len = D.30527;
  D.30528 = ex_block->extype;
  if (D.30528 != 0B) goto <D.30529>; else goto <D.30530>;
  <D.30529>:
  D.30528 = ex_block->extype;
  D.30531 = mono_reflection_type_get_handle (D.30528);
  D.30532 = mono_class_from_mono_type (D.30531);
  clause->data.catch_class = D.30532;
  goto <D.30533>;
  <D.30530>:
  D.30515 = ex_block->type;
  if (D.30515 == 1) goto <D.30534>; else goto <D.30535>;
  <D.30534>:
  D.30536 = ex_block->filter_offset;
  D.30537 = (unsigned int) D.30536;
  clause->data.filter_offset = D.30537;
  goto <D.30538>;
  <D.30535>:
  clause->data.filter_offset = 0;
  <D.30538>:
  <D.30533>:
  D.30524 = ex_block->start;
  D.30526 = ex_block->len;
  D.30539 = D.30524 + D.30526;
  finally_start = (guint32) D.30539;
  clause_index = clause_index + 1;
  j = j + 1;
  <D.18962>:
  D.30512 = (long unsigned int) j;
  D.30509 = ex_info->handlers;
  D.30540 = mono_array_length (D.30509);
  if (D.30512 < D.30540) goto <D.18961>; else goto <D.18963>;
  <D.18963>:
  <D.18960>:
  i = i + -1;
  <D.18965>:
  if (i >= 0) goto <D.18964>; else goto <D.18966>;
  <D.18966>:
  D.30541 = clauses;
  return D.30541;
}


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

  if (image != 0B) goto <D.30543>; else goto <D.30544>;
  <D.30543>:
  D.30545 = mono_image_alloc (image, size);
  return D.30545;
  <D.30544>:
  D.30546 = (long unsigned int) size;
  D.30545 = monoeg_malloc (D.30546);
  return D.30545;
}


mono_custom_attrs_from_builders (struct MonoImage * alloc_img, struct MonoImage * image, struct MonoArray * cattrs)
{
  struct MonoCustomAttrInfo * D.30550;
  long unsigned int D.30551;
  long unsigned int D.30552;
  char * D.30553;
  int D.30554;
  long unsigned int D.30557;
  unsigned int D.30558;
  unsigned int D.30559;
  unsigned int D.30560;
  _Bool D.30561;
  int D.30562;
  char * D.30563;
  int D.30564;
  struct MonoArray * D.30567;
  long unsigned int D.30568;
  unsigned int D.30569;
  long unsigned int D.30570;
  char * D.30571;
  struct MonoReflectionMethod * D.30572;
  struct MonoMethod * D.30573;
  long unsigned int D.30574;
  unsigned int D.30575;
  int i;
  int index;
  int count;
  int not_visible;
  struct MonoCustomAttrInfo * ainfo;
  struct MonoReflectionCustomAttr * cattr;

  if (cattrs == 0B) goto <D.30548>; else goto <D.30549>;
  <D.30548>:
  D.30550 = 0B;
  return D.30550;
  <D.30549>:
  D.30551 = mono_array_length (cattrs);
  count = (int) D.30551;
  not_visible = 0;
  i = 0;
  goto <D.19037>;
  <D.19036>:
  D.30552 = (long unsigned int) i;
  D.30553 = mono_array_addr_with_size (cattrs, 8, D.30552);
  cattr = MEM[(void * *)D.30553];
  D.30554 = custom_attr_visible (image, cattr);
  if (D.30554 == 0) goto <D.30555>; else goto <D.30556>;
  <D.30555>:
  not_visible = not_visible + 1;
  <D.30556>:
  i = i + 1;
  <D.19037>:
  if (i < count) goto <D.19036>; else goto <D.19038>;
  <D.19038>:
  count = count - not_visible;
  D.30557 = (long unsigned int) count;
  D.30558 = (unsigned int) D.30557;
  D.30559 = D.30558 * 24;
  D.30560 = D.30559 + 16;
  ainfo = image_g_malloc0 (alloc_img, D.30560);
  ainfo->image = image;
  ainfo->num_attrs = count;
  D.30561 = alloc_img != 0B;
  D.30562 = (int) D.30561;
  ainfo->cached = D.30562;
  index = 0;
  i = 0;
  goto <D.19041>;
  <D.19040>:
  D.30552 = (long unsigned int) i;
  D.30563 = mono_array_addr_with_size (cattrs, 8, D.30552);
  cattr = MEM[(void * *)D.30563];
  D.30564 = custom_attr_visible (image, cattr);
  if (D.30564 != 0) goto <D.30565>; else goto <D.30566>;
  <D.30565>:
  {
    unsigned char * saved;

    D.30567 = cattr->data;
    D.30568 = mono_array_length (D.30567);
    D.30569 = (unsigned int) D.30568;
    saved = mono_image_alloc (image, D.30569);
    D.30567 = cattr->data;
    D.30570 = mono_array_length (D.30567);
    D.30567 = cattr->data;
    D.30571 = mono_array_addr_with_size (D.30567, 1, 0);
    memcpy (saved, D.30571, D.30570);
    D.30572 = cattr->ctor;
    D.30573 = D.30572->method;
    ainfo->attrs[index].ctor = D.30573;
    ainfo->attrs[index].data = saved;
    D.30567 = cattr->data;
    D.30574 = mono_array_length (D.30567);
    D.30575 = (unsigned int) D.30574;
    ainfo->attrs[index].data_size = D.30575;
    index = index + 1;
  }
  <D.30566>:
  i = i + 1;
  <D.19041>:
  if (i < count) goto <D.19040>; else goto <D.19042>;
  <D.19042>:
  D.30550 = ainfo;
  return D.30550;
}


custom_attr_visible (struct MonoImage * image, struct MonoReflectionCustomAttr * cattr)
{
  struct MonoReflectionMethod * D.30577;
  struct MonoMethod * D.30578;
  struct MonoClass * D.30581;
  struct MonoImage * D.30582;
  unsigned int D.30585;
  int D.30586;
  unsigned int visibility.194;
  unsigned int D.30588;
  gboolean D.30591;

  D.30577 = cattr->ctor;
  D.30578 = D.30577->method;
  if (D.30578 != 0B) goto <D.30579>; else goto <D.30580>;
  <D.30579>:
  D.30577 = cattr->ctor;
  D.30578 = D.30577->method;
  D.30581 = D.30578->klass;
  D.30582 = D.30581->image;
  if (D.30582 != image) goto <D.30583>; else goto <D.30584>;
  <D.30583>:
  {
    int visibility;

    D.30577 = cattr->ctor;
    D.30578 = D.30577->method;
    D.30581 = D.30578->klass;
    D.30585 = D.30581->flags;
    D.30586 = (int) D.30585;
    visibility = D.30586 & 7;
    visibility.194 = (unsigned int) visibility;
    D.30588 = visibility.194 + 4294967295;
    if (D.30588 > 1) goto <D.30589>; else goto <D.30590>;
    <D.30589>:
    D.30591 = 0;
    return D.30591;
    <D.30590>:
  }
  <D.30584>:
  <D.30580>:
  D.30591 = 1;
  return D.30591;
}


mono_marshal_spec_from_builder (struct MonoImage * image, struct MonoAssembly * assembly, struct MonoReflectionMarshal * minfo)
{
  int D.30593;
  <unnamed type> D.30594;
  int D.30595;
  <unnamed type> D.30596;
  unsigned char D.30597;
  int D.30600;
  short int D.30601;
  int D.30602;
  _Bool D.30603;
  short int D.30604;
  struct MonoObject * D.30606;
  struct MonoType * D.30609;
  char * D.30610;
  struct MonoString * D.30611;
  char * D.30614;
  struct MonoMarshalSpec * D.30615;
  struct MonoMarshalSpec * res;

  res = image_g_malloc0 (image, 24);
  D.30593 = minfo->type;
  D.30594 = (<unnamed type>) D.30593;
  res->native = D.30594;
  D.30593 = minfo->type;
  switch (D.30593) <default: <D.23206>, case 23: <D.23203>, case 30: <D.23204>, case 42: <D.23201>, case 44: <D.23205>>
  <D.23201>:
  D.30595 = minfo->eltype;
  D.30596 = (<unnamed type>) D.30595;
  res->data.array_data.elem_type = D.30596;
  D.30597 = minfo->has_size;
  if (D.30597 != 0) goto <D.30598>; else goto <D.30599>;
  <D.30598>:
  D.30600 = minfo->param_num;
  D.30601 = (short int) D.30600;
  res->data.array_data.param_num = D.30601;
  D.30602 = minfo->count;
  res->data.array_data.num_elem = D.30602;
  D.30600 = minfo->param_num;
  D.30603 = D.30600 != -1;
  D.30604 = (short int) D.30603;
  res->data.array_data.elem_mult = D.30604;
  goto <D.30605>;
  <D.30599>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  <D.30605>:
  goto <D.23202>;
  <D.23203>:
  <D.23204>:
  D.30602 = minfo->count;
  res->data.array_data.num_elem = D.30602;
  goto <D.23202>;
  <D.23205>:
  D.30606 = minfo->marshaltyperef;
  if (D.30606 != 0B) goto <D.30607>; else goto <D.30608>;
  <D.30607>:
  D.30606 = minfo->marshaltyperef;
  D.30609 = mono_reflection_type_get_handle (D.30606);
  D.30610 = type_get_fully_qualified_name (D.30609);
  res->data.custom_data.custom_name = D.30610;
  <D.30608>:
  D.30611 = minfo->mcookie;
  if (D.30611 != 0B) goto <D.30612>; else goto <D.30613>;
  <D.30612>:
  D.30611 = minfo->mcookie;
  D.30614 = mono_string_to_utf8 (D.30611);
  res->data.custom_data.cookie = D.30614;
  <D.30613>:
  goto <D.23202>;
  <D.23206>:
  goto <D.23202>;
  <D.23202>:
  D.30615 = res;
  return D.30615;
}


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

  if (cattrs == 0B) goto <D.30618>; else goto <D.30620>;
  <D.30620>:
  D.30621 = mono_array_length (cattrs);
  if (D.30621 == 0) goto <D.30618>; else goto <D.30619>;
  <D.30618>:
  return;
  <D.30619>:
  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.30622>; else goto <D.30623>;
  <D.30622>:
  mono_custom_attrs_free (tmp);
  <D.30623>:
  mono_image_property_insert (image, obj, 4096, ainfo);
  mono_loader_unlock ();
}


ctorbuilder_to_mono_method (struct MonoClass * klass, struct MonoReflectionCtorBuilder * mb)
{
  struct MonoImage * D.30625;
  struct MonoMethod * D.30626;
  struct MonoArray * D.30627;
  struct MonoMethod * D.30628;
  int D.30629;
  struct MonoGenericContainer * D.30632;
  struct MonoMethod * D.30635;
  struct ReflectionMethodBuilder rmb;
  struct MonoMethodSignature * sig;

  try
    {
      mono_loader_lock ();
      D.30625 = klass->image;
      sig = ctor_builder_to_signature (D.30625, mb);
      mono_loader_unlock ();
      reflection_methodbuilder_from_ctor_builder (&rmb, mb);
      D.30626 = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = D.30626;
      D.30627 = mb->cattrs;
      D.30628 = mb->mhandle;
      D.30625 = klass->image;
      mono_save_custom_attrs (D.30625, D.30628, D.30627);
      D.30625 = klass->image;
      D.30629 = MEM[(struct MonoDynamicImage *)D.30625].save;
      if (D.30629 == 0) goto <D.30630>; else goto <D.30631>;
      <D.30630>:
      D.30632 = klass->generic_container;
      if (D.30632 == 0B) goto <D.30633>; else goto <D.30634>;
      <D.30633>:
      mb->ilgen = 0B;
      <D.30634>:
      <D.30631>:
      D.30635 = mb->mhandle;
      return D.30635;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


ctor_builder_to_signature (struct MonoImage * image, struct MonoReflectionCtorBuilder * ctor)
{
  struct MonoArray * D.30638;
  unsigned int D.30639;
  unsigned int D.30640;
  _Bool D.30641;
  struct MonoClass * D.30642;
  struct MonoType * D.30643;
  struct MonoMethodSignature * D.30644;
  struct MonoMethodSignature * sig;

  D.30638 = ctor->parameters;
  sig = parameters_to_signature (image, D.30638);
  D.30639 = ctor->attrs;
  D.30640 = D.30639 & 16;
  D.30641 = D.30640 == 0;
  sig->hasthis = D.30641;
  D.30642 = mono_defaults.void_class;
  D.30643 = &D.30642->byval_arg;
  sig->ret = D.30643;
  D.30644 = sig;
  return D.30644;
}


inflate_mono_method (struct MonoClass * klass, struct MonoMethod * method, struct MonoObject * obj)
{
  struct MonoGenericClass * D.30646;
  struct MonoMethod * D.30649;
  unsigned int D.30652;
  struct MonoMethod * * D.30654;
  long unsigned int D.30656;
  long unsigned int D.30657;
  struct MonoMethod * * D.30658;
  struct MonoMethod * D.30659;
  unsigned char D.30660;
  unsigned char D.30661;
  _Bool D.30662;
  long int D.30663;
  long int D.30664;
  struct MonoMethod * D.30667;
  unsigned int i.195;
  _Bool D.30670;
  long int D.30671;
  long int D.30672;
  unsigned char D.30675;
  unsigned char D.30676;
  struct MonoClass * D.30679;
  struct MonoImage * D.30680;
  unsigned char D.30681;
  unsigned char D.30682;
  struct MonoGHashTable * D.30685;
  struct MonoMethodInflated * imethod;
  struct MonoGenericContext * context;
  int i;

  D.30646 = klass->generic_class;
  if (D.30646 == 0B) goto <D.30647>; else goto <D.30648>;
  <D.30647>:
  D.30649 = method;
  return D.30649;
  <D.30648>:
  context = mono_class_get_context (klass);
  D.30652 = klass->method.count;
  if (D.30652 != 0) goto <D.30653>; else goto <D.30650>;
  <D.30653>:
  D.30654 = klass->methods;
  if (D.30654 != 0B) goto <D.30655>; else goto <D.30650>;
  <D.30655>:
  i = 0;
  goto <D.23365>;
  <D.23364>:
  D.30654 = klass->methods;
  D.30656 = (long unsigned int) i;
  D.30657 = D.30656 * 8;
  D.30658 = D.30654 + D.30657;
  D.30659 = *D.30658;
  D.30660 = BIT_FIELD_REF <*D.30659, 8, 264>;
  D.30661 = D.30660 & 16;
  D.30662 = D.30661 == 0;
  D.30663 = (long int) D.30662;
  D.30664 = __builtin_expect (D.30663, 0);
  if (D.30664 != 0) goto <D.30665>; else goto <D.30666>;
  <D.30665>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10611, "klass->methods [i]->is_inflated");
  <D.30666>:
  D.30654 = klass->methods;
  D.30656 = (long unsigned int) i;
  D.30657 = D.30656 * 8;
  D.30658 = D.30654 + D.30657;
  D.30659 = *D.30658;
  D.30667 = MEM[(struct MonoMethodInflated *)D.30659].declaring;
  if (D.30667 == method) goto <D.23363>; else goto <D.30668>;
  <D.30668>:
  i = i + 1;
  <D.23365>:
  i.195 = (unsigned int) i;
  D.30652 = klass->method.count;
  if (i.195 < D.30652) goto <D.23364>; else goto <D.23363>;
  <D.23363>:
  i.195 = (unsigned int) i;
  D.30652 = klass->method.count;
  D.30670 = i.195 >= D.30652;
  D.30671 = (long int) D.30670;
  D.30672 = __builtin_expect (D.30671, 0);
  if (D.30672 != 0) goto <D.30673>; else goto <D.30674>;
  <D.30673>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10615, "i < klass->method.count");
  <D.30674>:
  D.30654 = klass->methods;
  D.30656 = (long unsigned int) i;
  D.30657 = D.30656 * 8;
  D.30658 = D.30654 + D.30657;
  imethod = *D.30658;
  goto <D.30651>;
  <D.30650>:
  imethod = mono_class_inflate_generic_method_full (method, klass, context);
  <D.30651>:
  D.30675 = BIT_FIELD_REF <*method, 8, 264>;
  D.30676 = D.30675 & 8;
  if (D.30676 != 0) goto <D.30677>; else goto <D.30678>;
  <D.30677>:
  D.30679 = method->klass;
  D.30680 = D.30679->image;
  D.30681 = BIT_FIELD_REF <*D.30680, 8, 224>;
  D.30682 = D.30681 & 8;
  if (D.30682 != 0) goto <D.30683>; else goto <D.30684>;
  <D.30683>:
  {
    struct MonoDynamicImage * image;

    D.30679 = method->klass;
    image = D.30679->image;
    mono_image_lock (image);
    D.30685 = image->generic_def_objects;
    mono_g_hash_table_insert (D.30685, imethod, obj);
    mono_image_unlock (image);
  }
  <D.30684>:
  <D.30678>:
  D.30649 = imethod;
  return D.30649;
}


is_sre_method_builder (struct MonoClass * class)
{
  struct MonoClass * cached_class.196;
  gboolean D.30690;
  _Bool D.30691;
  int D.30692;
  int D.22610;
  int iftmp.197;
  int D.22606;
  const char[14] * D.30698;
  unsigned char D.30699;
  int D.30700;
  unsigned char D.30701;
  int D.30702;
  _Bool D.30703;
  _Bool D.30704;
  _Bool D.30705;
  const unsigned char * D.30708;
  unsigned char D.30709;
  int D.30710;
  const unsigned char * D.30711;
  unsigned char D.30712;
  int D.30713;
  _Bool D.30714;
  _Bool D.30715;
  const unsigned char * D.30718;
  unsigned char D.30719;
  int D.30720;
  const unsigned char * D.30721;
  unsigned char D.30722;
  int D.30723;
  _Bool D.30724;
  _Bool D.30725;
  const unsigned char * D.30728;
  unsigned char D.30729;
  int D.30730;
  const unsigned char * D.30731;
  unsigned char D.30732;
  int D.30733;
  const char * D.30735;
  int D.22619;
  int iftmp.198;
  int D.22615;
  const char[23] * D.30741;
  unsigned char D.30742;
  int D.30743;
  unsigned char D.30744;
  int D.30745;
  _Bool D.30746;
  _Bool D.30747;
  _Bool D.30748;
  const unsigned char * D.30751;
  unsigned char D.30752;
  int D.30753;
  const unsigned char * D.30754;
  unsigned char D.30755;
  int D.30756;
  _Bool D.30757;
  _Bool D.30758;
  const unsigned char * D.30761;
  unsigned char D.30762;
  int D.30763;
  const unsigned char * D.30764;
  unsigned char D.30765;
  int D.30766;
  _Bool D.30767;
  _Bool D.30768;
  const unsigned char * D.30771;
  unsigned char D.30772;
  int D.30773;
  const unsigned char * D.30774;
  unsigned char D.30775;
  int D.30776;
  const char * D.30778;

  {
    static struct MonoClass * cached_class;

    cached_class.196 = cached_class;
    if (cached_class.196 != 0B) goto <D.30688>; else goto <D.30689>;
    <D.30688>:
    cached_class.196 = cached_class;
    D.30691 = cached_class.196 == class;
    D.30690 = (gboolean) D.30691;
    return D.30690;
    <D.30689>:
    D.30692 = is_corlib_type (class);
    if (D.30692 != 0) goto <D.30693>; else goto <D.30694>;
    <D.30693>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30698 = "MethodBuilder";
        D.30699 = MEM[(const unsigned char *)D.30698];
        D.30700 = (int) D.30699;
        D.30701 = *__s2;
        D.30702 = (int) D.30701;
        __result = D.30700 - D.30702;
        {
          D.30703 = __s1_len != 0;
          D.30704 = __result == 0;
          D.30705 = D.30703 & D.30704;
          if (D.30705 != 0) goto <D.30706>; else goto <D.30707>;
          <D.30706>:
          D.30708 = &MEM[(void *)"MethodBuilder" + 1B];
          D.30709 = *D.30708;
          D.30710 = (int) D.30709;
          D.30711 = __s2 + 1;
          D.30712 = *D.30711;
          D.30713 = (int) D.30712;
          __result = D.30710 - D.30713;
          D.30714 = __s1_len > 1;
          D.30704 = __result == 0;
          D.30715 = D.30714 & D.30704;
          if (D.30715 != 0) goto <D.30716>; else goto <D.30717>;
          <D.30716>:
          D.30718 = &MEM[(void *)"MethodBuilder" + 2B];
          D.30719 = *D.30718;
          D.30720 = (int) D.30719;
          D.30721 = __s2 + 2;
          D.30722 = *D.30721;
          D.30723 = (int) D.30722;
          __result = D.30720 - D.30723;
          D.30724 = __s1_len > 2;
          D.30704 = __result == 0;
          D.30725 = D.30724 & D.30704;
          if (D.30725 != 0) goto <D.30726>; else goto <D.30727>;
          <D.30726>:
          D.30728 = &MEM[(void *)"MethodBuilder" + 3B];
          D.30729 = *D.30728;
          D.30730 = (int) D.30729;
          D.30731 = __s2 + 3;
          D.30732 = *D.30731;
          D.30733 = (int) D.30732;
          __result = D.30730 - D.30733;
          <D.30727>:
          <D.30717>:
          <D.30707>:
        }
        D.22606 = __result;
      }
      iftmp.197 = D.22606;
      goto <D.30734>;
      <D.30697>:
      D.30735 = class->name;
      iftmp.197 = __builtin_strcmp ("MethodBuilder", D.30735);
      <D.30734>:
      D.22610 = iftmp.197;
    }
    if (D.22610 == 0) goto <D.30736>; else goto <D.30737>;
    <D.30736>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30741 = "System.Reflection.Emit";
        D.30742 = MEM[(const unsigned char *)D.30741];
        D.30743 = (int) D.30742;
        D.30744 = *__s2;
        D.30745 = (int) D.30744;
        __result = D.30743 - D.30745;
        {
          D.30746 = __s1_len != 0;
          D.30747 = __result == 0;
          D.30748 = D.30746 & D.30747;
          if (D.30748 != 0) goto <D.30749>; else goto <D.30750>;
          <D.30749>:
          D.30751 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30752 = *D.30751;
          D.30753 = (int) D.30752;
          D.30754 = __s2 + 1;
          D.30755 = *D.30754;
          D.30756 = (int) D.30755;
          __result = D.30753 - D.30756;
          D.30757 = __s1_len > 1;
          D.30747 = __result == 0;
          D.30758 = D.30757 & D.30747;
          if (D.30758 != 0) goto <D.30759>; else goto <D.30760>;
          <D.30759>:
          D.30761 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30762 = *D.30761;
          D.30763 = (int) D.30762;
          D.30764 = __s2 + 2;
          D.30765 = *D.30764;
          D.30766 = (int) D.30765;
          __result = D.30763 - D.30766;
          D.30767 = __s1_len > 2;
          D.30747 = __result == 0;
          D.30768 = D.30767 & D.30747;
          if (D.30768 != 0) goto <D.30769>; else goto <D.30770>;
          <D.30769>:
          D.30771 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30772 = *D.30771;
          D.30773 = (int) D.30772;
          D.30774 = __s2 + 3;
          D.30775 = *D.30774;
          D.30776 = (int) D.30775;
          __result = D.30773 - D.30776;
          <D.30770>:
          <D.30760>:
          <D.30750>:
        }
        D.22615 = __result;
      }
      iftmp.198 = D.22615;
      goto <D.30777>;
      <D.30740>:
      D.30778 = class->name_space;
      iftmp.198 = __builtin_strcmp ("System.Reflection.Emit", D.30778);
      <D.30777>:
      D.22619 = iftmp.198;
    }
    if (D.22619 == 0) goto <D.30779>; else goto <D.30780>;
    <D.30779>:
    cached_class = class;
    D.30690 = 1;
    return D.30690;
    <D.30780>:
    <D.30737>:
    <D.30694>:
    D.30690 = 0;
    return D.30690;
  }
}


is_sr_mono_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.199;
  gboolean D.30785;
  _Bool D.30786;
  int D.30787;
  int D.22856;
  int iftmp.200;
  int D.22852;
  const char[11] * D.30793;
  unsigned char D.30794;
  int D.30795;
  unsigned char D.30796;
  int D.30797;
  _Bool D.30798;
  _Bool D.30799;
  _Bool D.30800;
  const unsigned char * D.30803;
  unsigned char D.30804;
  int D.30805;
  const unsigned char * D.30806;
  unsigned char D.30807;
  int D.30808;
  _Bool D.30809;
  _Bool D.30810;
  const unsigned char * D.30813;
  unsigned char D.30814;
  int D.30815;
  const unsigned char * D.30816;
  unsigned char D.30817;
  int D.30818;
  _Bool D.30819;
  _Bool D.30820;
  const unsigned char * D.30823;
  unsigned char D.30824;
  int D.30825;
  const unsigned char * D.30826;
  unsigned char D.30827;
  int D.30828;
  const char * D.30830;
  int D.22865;
  int iftmp.201;
  int D.22861;
  const char[18] * D.30836;
  unsigned char D.30837;
  int D.30838;
  unsigned char D.30839;
  int D.30840;
  _Bool D.30841;
  _Bool D.30842;
  _Bool D.30843;
  const unsigned char * D.30846;
  unsigned char D.30847;
  int D.30848;
  const unsigned char * D.30849;
  unsigned char D.30850;
  int D.30851;
  _Bool D.30852;
  _Bool D.30853;
  const unsigned char * D.30856;
  unsigned char D.30857;
  int D.30858;
  const unsigned char * D.30859;
  unsigned char D.30860;
  int D.30861;
  _Bool D.30862;
  _Bool D.30863;
  const unsigned char * D.30866;
  unsigned char D.30867;
  int D.30868;
  const unsigned char * D.30869;
  unsigned char D.30870;
  int D.30871;
  const char * D.30873;

  {
    static struct MonoClass * cached_class;

    cached_class.199 = cached_class;
    if (cached_class.199 != 0B) goto <D.30783>; else goto <D.30784>;
    <D.30783>:
    cached_class.199 = cached_class;
    D.30786 = cached_class.199 == class;
    D.30785 = (gboolean) D.30786;
    return D.30785;
    <D.30784>:
    D.30787 = is_corlib_type (class);
    if (D.30787 != 0) goto <D.30788>; else goto <D.30789>;
    <D.30788>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30793 = "MonoMethod";
        D.30794 = MEM[(const unsigned char *)D.30793];
        D.30795 = (int) D.30794;
        D.30796 = *__s2;
        D.30797 = (int) D.30796;
        __result = D.30795 - D.30797;
        {
          D.30798 = __s1_len != 0;
          D.30799 = __result == 0;
          D.30800 = D.30798 & D.30799;
          if (D.30800 != 0) goto <D.30801>; else goto <D.30802>;
          <D.30801>:
          D.30803 = &MEM[(void *)"MonoMethod" + 1B];
          D.30804 = *D.30803;
          D.30805 = (int) D.30804;
          D.30806 = __s2 + 1;
          D.30807 = *D.30806;
          D.30808 = (int) D.30807;
          __result = D.30805 - D.30808;
          D.30809 = __s1_len > 1;
          D.30799 = __result == 0;
          D.30810 = D.30809 & D.30799;
          if (D.30810 != 0) goto <D.30811>; else goto <D.30812>;
          <D.30811>:
          D.30813 = &MEM[(void *)"MonoMethod" + 2B];
          D.30814 = *D.30813;
          D.30815 = (int) D.30814;
          D.30816 = __s2 + 2;
          D.30817 = *D.30816;
          D.30818 = (int) D.30817;
          __result = D.30815 - D.30818;
          D.30819 = __s1_len > 2;
          D.30799 = __result == 0;
          D.30820 = D.30819 & D.30799;
          if (D.30820 != 0) goto <D.30821>; else goto <D.30822>;
          <D.30821>:
          D.30823 = &MEM[(void *)"MonoMethod" + 3B];
          D.30824 = *D.30823;
          D.30825 = (int) D.30824;
          D.30826 = __s2 + 3;
          D.30827 = *D.30826;
          D.30828 = (int) D.30827;
          __result = D.30825 - D.30828;
          <D.30822>:
          <D.30812>:
          <D.30802>:
        }
        D.22852 = __result;
      }
      iftmp.200 = D.22852;
      goto <D.30829>;
      <D.30792>:
      D.30830 = class->name;
      iftmp.200 = __builtin_strcmp ("MonoMethod", D.30830);
      <D.30829>:
      D.22856 = iftmp.200;
    }
    if (D.22856 == 0) goto <D.30831>; else goto <D.30832>;
    <D.30831>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30836 = "System.Reflection";
        D.30837 = MEM[(const unsigned char *)D.30836];
        D.30838 = (int) D.30837;
        D.30839 = *__s2;
        D.30840 = (int) D.30839;
        __result = D.30838 - D.30840;
        {
          D.30841 = __s1_len != 0;
          D.30842 = __result == 0;
          D.30843 = D.30841 & D.30842;
          if (D.30843 != 0) goto <D.30844>; else goto <D.30845>;
          <D.30844>:
          D.30846 = &MEM[(void *)"System.Reflection" + 1B];
          D.30847 = *D.30846;
          D.30848 = (int) D.30847;
          D.30849 = __s2 + 1;
          D.30850 = *D.30849;
          D.30851 = (int) D.30850;
          __result = D.30848 - D.30851;
          D.30852 = __s1_len > 1;
          D.30842 = __result == 0;
          D.30853 = D.30852 & D.30842;
          if (D.30853 != 0) goto <D.30854>; else goto <D.30855>;
          <D.30854>:
          D.30856 = &MEM[(void *)"System.Reflection" + 2B];
          D.30857 = *D.30856;
          D.30858 = (int) D.30857;
          D.30859 = __s2 + 2;
          D.30860 = *D.30859;
          D.30861 = (int) D.30860;
          __result = D.30858 - D.30861;
          D.30862 = __s1_len > 2;
          D.30842 = __result == 0;
          D.30863 = D.30862 & D.30842;
          if (D.30863 != 0) goto <D.30864>; else goto <D.30865>;
          <D.30864>:
          D.30866 = &MEM[(void *)"System.Reflection" + 3B];
          D.30867 = *D.30866;
          D.30868 = (int) D.30867;
          D.30869 = __s2 + 3;
          D.30870 = *D.30869;
          D.30871 = (int) D.30870;
          __result = D.30868 - D.30871;
          <D.30865>:
          <D.30855>:
          <D.30845>:
        }
        D.22861 = __result;
      }
      iftmp.201 = D.22861;
      goto <D.30872>;
      <D.30835>:
      D.30873 = class->name_space;
      iftmp.201 = __builtin_strcmp ("System.Reflection", D.30873);
      <D.30872>:
      D.22865 = iftmp.201;
    }
    if (D.22865 == 0) goto <D.30874>; else goto <D.30875>;
    <D.30874>:
    cached_class = class;
    D.30785 = 1;
    return D.30785;
    <D.30875>:
    <D.30832>:
    <D.30789>:
    D.30785 = 0;
    return D.30785;
  }
}


is_sre_array (struct MonoClass * class)
{
  struct MonoClass * cached_class.202;
  gboolean D.30880;
  _Bool D.30881;
  int D.30882;
  int D.22500;
  int iftmp.203;
  int D.22496;
  const char[10] * D.30888;
  unsigned char D.30889;
  int D.30890;
  unsigned char D.30891;
  int D.30892;
  _Bool D.30893;
  _Bool D.30894;
  _Bool D.30895;
  const unsigned char * D.30898;
  unsigned char D.30899;
  int D.30900;
  const unsigned char * D.30901;
  unsigned char D.30902;
  int D.30903;
  _Bool D.30904;
  _Bool D.30905;
  const unsigned char * D.30908;
  unsigned char D.30909;
  int D.30910;
  const unsigned char * D.30911;
  unsigned char D.30912;
  int D.30913;
  _Bool D.30914;
  _Bool D.30915;
  const unsigned char * D.30918;
  unsigned char D.30919;
  int D.30920;
  const unsigned char * D.30921;
  unsigned char D.30922;
  int D.30923;
  const char * D.30925;
  int D.22509;
  int iftmp.204;
  int D.22505;
  const char[23] * D.30931;
  unsigned char D.30932;
  int D.30933;
  unsigned char D.30934;
  int D.30935;
  _Bool D.30936;
  _Bool D.30937;
  _Bool D.30938;
  const unsigned char * D.30941;
  unsigned char D.30942;
  int D.30943;
  const unsigned char * D.30944;
  unsigned char D.30945;
  int D.30946;
  _Bool D.30947;
  _Bool D.30948;
  const unsigned char * D.30951;
  unsigned char D.30952;
  int D.30953;
  const unsigned char * D.30954;
  unsigned char D.30955;
  int D.30956;
  _Bool D.30957;
  _Bool D.30958;
  const unsigned char * D.30961;
  unsigned char D.30962;
  int D.30963;
  const unsigned char * D.30964;
  unsigned char D.30965;
  int D.30966;
  const char * D.30968;

  {
    static struct MonoClass * cached_class;

    cached_class.202 = cached_class;
    if (cached_class.202 != 0B) goto <D.30878>; else goto <D.30879>;
    <D.30878>:
    cached_class.202 = cached_class;
    D.30881 = cached_class.202 == class;
    D.30880 = (gboolean) D.30881;
    return D.30880;
    <D.30879>:
    D.30882 = is_corlib_type (class);
    if (D.30882 != 0) goto <D.30883>; else goto <D.30884>;
    <D.30883>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30888 = "ArrayType";
        D.30889 = MEM[(const unsigned char *)D.30888];
        D.30890 = (int) D.30889;
        D.30891 = *__s2;
        D.30892 = (int) D.30891;
        __result = D.30890 - D.30892;
        {
          D.30893 = __s1_len != 0;
          D.30894 = __result == 0;
          D.30895 = D.30893 & D.30894;
          if (D.30895 != 0) goto <D.30896>; else goto <D.30897>;
          <D.30896>:
          D.30898 = &MEM[(void *)"ArrayType" + 1B];
          D.30899 = *D.30898;
          D.30900 = (int) D.30899;
          D.30901 = __s2 + 1;
          D.30902 = *D.30901;
          D.30903 = (int) D.30902;
          __result = D.30900 - D.30903;
          D.30904 = __s1_len > 1;
          D.30894 = __result == 0;
          D.30905 = D.30904 & D.30894;
          if (D.30905 != 0) goto <D.30906>; else goto <D.30907>;
          <D.30906>:
          D.30908 = &MEM[(void *)"ArrayType" + 2B];
          D.30909 = *D.30908;
          D.30910 = (int) D.30909;
          D.30911 = __s2 + 2;
          D.30912 = *D.30911;
          D.30913 = (int) D.30912;
          __result = D.30910 - D.30913;
          D.30914 = __s1_len > 2;
          D.30894 = __result == 0;
          D.30915 = D.30914 & D.30894;
          if (D.30915 != 0) goto <D.30916>; else goto <D.30917>;
          <D.30916>:
          D.30918 = &MEM[(void *)"ArrayType" + 3B];
          D.30919 = *D.30918;
          D.30920 = (int) D.30919;
          D.30921 = __s2 + 3;
          D.30922 = *D.30921;
          D.30923 = (int) D.30922;
          __result = D.30920 - D.30923;
          <D.30917>:
          <D.30907>:
          <D.30897>:
        }
        D.22496 = __result;
      }
      iftmp.203 = D.22496;
      goto <D.30924>;
      <D.30887>:
      D.30925 = class->name;
      iftmp.203 = __builtin_strcmp ("ArrayType", D.30925);
      <D.30924>:
      D.22500 = iftmp.203;
    }
    if (D.22500 == 0) goto <D.30926>; else goto <D.30927>;
    <D.30926>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.30931 = "System.Reflection.Emit";
        D.30932 = MEM[(const unsigned char *)D.30931];
        D.30933 = (int) D.30932;
        D.30934 = *__s2;
        D.30935 = (int) D.30934;
        __result = D.30933 - D.30935;
        {
          D.30936 = __s1_len != 0;
          D.30937 = __result == 0;
          D.30938 = D.30936 & D.30937;
          if (D.30938 != 0) goto <D.30939>; else goto <D.30940>;
          <D.30939>:
          D.30941 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.30942 = *D.30941;
          D.30943 = (int) D.30942;
          D.30944 = __s2 + 1;
          D.30945 = *D.30944;
          D.30946 = (int) D.30945;
          __result = D.30943 - D.30946;
          D.30947 = __s1_len > 1;
          D.30937 = __result == 0;
          D.30948 = D.30947 & D.30937;
          if (D.30948 != 0) goto <D.30949>; else goto <D.30950>;
          <D.30949>:
          D.30951 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.30952 = *D.30951;
          D.30953 = (int) D.30952;
          D.30954 = __s2 + 2;
          D.30955 = *D.30954;
          D.30956 = (int) D.30955;
          __result = D.30953 - D.30956;
          D.30957 = __s1_len > 2;
          D.30937 = __result == 0;
          D.30958 = D.30957 & D.30937;
          if (D.30958 != 0) goto <D.30959>; else goto <D.30960>;
          <D.30959>:
          D.30961 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.30962 = *D.30961;
          D.30963 = (int) D.30962;
          D.30964 = __s2 + 3;
          D.30965 = *D.30964;
          D.30966 = (int) D.30965;
          __result = D.30963 - D.30966;
          <D.30960>:
          <D.30950>:
          <D.30940>:
        }
        D.22505 = __result;
      }
      iftmp.204 = D.22505;
      goto <D.30967>;
      <D.30930>:
      D.30968 = class->name_space;
      iftmp.204 = __builtin_strcmp ("System.Reflection.Emit", D.30968);
      <D.30967>:
      D.22509 = iftmp.204;
    }
    if (D.22509 == 0) goto <D.30969>; else goto <D.30970>;
    <D.30969>:
    cached_class = class;
    D.30880 = 1;
    return D.30880;
    <D.30970>:
    <D.30927>:
    <D.30884>:
    D.30880 = 0;
    return D.30880;
  }
}


is_sre_byref (struct MonoClass * class)
{
  struct MonoClass * cached_class.205;
  gboolean D.30975;
  _Bool D.30976;
  int D.30977;
  int D.22522;
  int iftmp.206;
  int D.22518;
  const char[10] * D.30983;
  unsigned char D.30984;
  int D.30985;
  unsigned char D.30986;
  int D.30987;
  _Bool D.30988;
  _Bool D.30989;
  _Bool D.30990;
  const unsigned char * D.30993;
  unsigned char D.30994;
  int D.30995;
  const unsigned char * D.30996;
  unsigned char D.30997;
  int D.30998;
  _Bool D.30999;
  _Bool D.31000;
  const unsigned char * D.31003;
  unsigned char D.31004;
  int D.31005;
  const unsigned char * D.31006;
  unsigned char D.31007;
  int D.31008;
  _Bool D.31009;
  _Bool D.31010;
  const unsigned char * D.31013;
  unsigned char D.31014;
  int D.31015;
  const unsigned char * D.31016;
  unsigned char D.31017;
  int D.31018;
  const char * D.31020;
  int D.22531;
  int iftmp.207;
  int D.22527;
  const char[23] * D.31026;
  unsigned char D.31027;
  int D.31028;
  unsigned char D.31029;
  int D.31030;
  _Bool D.31031;
  _Bool D.31032;
  _Bool D.31033;
  const unsigned char * D.31036;
  unsigned char D.31037;
  int D.31038;
  const unsigned char * D.31039;
  unsigned char D.31040;
  int D.31041;
  _Bool D.31042;
  _Bool D.31043;
  const unsigned char * D.31046;
  unsigned char D.31047;
  int D.31048;
  const unsigned char * D.31049;
  unsigned char D.31050;
  int D.31051;
  _Bool D.31052;
  _Bool D.31053;
  const unsigned char * D.31056;
  unsigned char D.31057;
  int D.31058;
  const unsigned char * D.31059;
  unsigned char D.31060;
  int D.31061;
  const char * D.31063;

  {
    static struct MonoClass * cached_class;

    cached_class.205 = cached_class;
    if (cached_class.205 != 0B) goto <D.30973>; else goto <D.30974>;
    <D.30973>:
    cached_class.205 = cached_class;
    D.30976 = cached_class.205 == class;
    D.30975 = (gboolean) D.30976;
    return D.30975;
    <D.30974>:
    D.30977 = is_corlib_type (class);
    if (D.30977 != 0) goto <D.30978>; else goto <D.30979>;
    <D.30978>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.30983 = "ByRefType";
        D.30984 = MEM[(const unsigned char *)D.30983];
        D.30985 = (int) D.30984;
        D.30986 = *__s2;
        D.30987 = (int) D.30986;
        __result = D.30985 - D.30987;
        {
          D.30988 = __s1_len != 0;
          D.30989 = __result == 0;
          D.30990 = D.30988 & D.30989;
          if (D.30990 != 0) goto <D.30991>; else goto <D.30992>;
          <D.30991>:
          D.30993 = &MEM[(void *)"ByRefType" + 1B];
          D.30994 = *D.30993;
          D.30995 = (int) D.30994;
          D.30996 = __s2 + 1;
          D.30997 = *D.30996;
          D.30998 = (int) D.30997;
          __result = D.30995 - D.30998;
          D.30999 = __s1_len > 1;
          D.30989 = __result == 0;
          D.31000 = D.30999 & D.30989;
          if (D.31000 != 0) goto <D.31001>; else goto <D.31002>;
          <D.31001>:
          D.31003 = &MEM[(void *)"ByRefType" + 2B];
          D.31004 = *D.31003;
          D.31005 = (int) D.31004;
          D.31006 = __s2 + 2;
          D.31007 = *D.31006;
          D.31008 = (int) D.31007;
          __result = D.31005 - D.31008;
          D.31009 = __s1_len > 2;
          D.30989 = __result == 0;
          D.31010 = D.31009 & D.30989;
          if (D.31010 != 0) goto <D.31011>; else goto <D.31012>;
          <D.31011>:
          D.31013 = &MEM[(void *)"ByRefType" + 3B];
          D.31014 = *D.31013;
          D.31015 = (int) D.31014;
          D.31016 = __s2 + 3;
          D.31017 = *D.31016;
          D.31018 = (int) D.31017;
          __result = D.31015 - D.31018;
          <D.31012>:
          <D.31002>:
          <D.30992>:
        }
        D.22518 = __result;
      }
      iftmp.206 = D.22518;
      goto <D.31019>;
      <D.30982>:
      D.31020 = class->name;
      iftmp.206 = __builtin_strcmp ("ByRefType", D.31020);
      <D.31019>:
      D.22522 = iftmp.206;
    }
    if (D.22522 == 0) goto <D.31021>; else goto <D.31022>;
    <D.31021>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31026 = "System.Reflection.Emit";
        D.31027 = MEM[(const unsigned char *)D.31026];
        D.31028 = (int) D.31027;
        D.31029 = *__s2;
        D.31030 = (int) D.31029;
        __result = D.31028 - D.31030;
        {
          D.31031 = __s1_len != 0;
          D.31032 = __result == 0;
          D.31033 = D.31031 & D.31032;
          if (D.31033 != 0) goto <D.31034>; else goto <D.31035>;
          <D.31034>:
          D.31036 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31037 = *D.31036;
          D.31038 = (int) D.31037;
          D.31039 = __s2 + 1;
          D.31040 = *D.31039;
          D.31041 = (int) D.31040;
          __result = D.31038 - D.31041;
          D.31042 = __s1_len > 1;
          D.31032 = __result == 0;
          D.31043 = D.31042 & D.31032;
          if (D.31043 != 0) goto <D.31044>; else goto <D.31045>;
          <D.31044>:
          D.31046 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31047 = *D.31046;
          D.31048 = (int) D.31047;
          D.31049 = __s2 + 2;
          D.31050 = *D.31049;
          D.31051 = (int) D.31050;
          __result = D.31048 - D.31051;
          D.31052 = __s1_len > 2;
          D.31032 = __result == 0;
          D.31053 = D.31052 & D.31032;
          if (D.31053 != 0) goto <D.31054>; else goto <D.31055>;
          <D.31054>:
          D.31056 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31057 = *D.31056;
          D.31058 = (int) D.31057;
          D.31059 = __s2 + 3;
          D.31060 = *D.31059;
          D.31061 = (int) D.31060;
          __result = D.31058 - D.31061;
          <D.31055>:
          <D.31045>:
          <D.31035>:
        }
        D.22527 = __result;
      }
      iftmp.207 = D.22527;
      goto <D.31062>;
      <D.31025>:
      D.31063 = class->name_space;
      iftmp.207 = __builtin_strcmp ("System.Reflection.Emit", D.31063);
      <D.31062>:
      D.22531 = iftmp.207;
    }
    if (D.22531 == 0) goto <D.31064>; else goto <D.31065>;
    <D.31064>:
    cached_class = class;
    D.30975 = 1;
    return D.30975;
    <D.31065>:
    <D.31022>:
    <D.30979>:
    D.30975 = 0;
    return D.30975;
  }
}


is_sre_pointer (struct MonoClass * class)
{
  struct MonoClass * cached_class.208;
  gboolean D.31070;
  _Bool D.31071;
  int D.31072;
  int D.22544;
  int iftmp.209;
  int D.22540;
  const char[12] * D.31078;
  unsigned char D.31079;
  int D.31080;
  unsigned char D.31081;
  int D.31082;
  _Bool D.31083;
  _Bool D.31084;
  _Bool D.31085;
  const unsigned char * D.31088;
  unsigned char D.31089;
  int D.31090;
  const unsigned char * D.31091;
  unsigned char D.31092;
  int D.31093;
  _Bool D.31094;
  _Bool D.31095;
  const unsigned char * D.31098;
  unsigned char D.31099;
  int D.31100;
  const unsigned char * D.31101;
  unsigned char D.31102;
  int D.31103;
  _Bool D.31104;
  _Bool D.31105;
  const unsigned char * D.31108;
  unsigned char D.31109;
  int D.31110;
  const unsigned char * D.31111;
  unsigned char D.31112;
  int D.31113;
  const char * D.31115;
  int D.22553;
  int iftmp.210;
  int D.22549;
  const char[23] * D.31121;
  unsigned char D.31122;
  int D.31123;
  unsigned char D.31124;
  int D.31125;
  _Bool D.31126;
  _Bool D.31127;
  _Bool D.31128;
  const unsigned char * D.31131;
  unsigned char D.31132;
  int D.31133;
  const unsigned char * D.31134;
  unsigned char D.31135;
  int D.31136;
  _Bool D.31137;
  _Bool D.31138;
  const unsigned char * D.31141;
  unsigned char D.31142;
  int D.31143;
  const unsigned char * D.31144;
  unsigned char D.31145;
  int D.31146;
  _Bool D.31147;
  _Bool D.31148;
  const unsigned char * D.31151;
  unsigned char D.31152;
  int D.31153;
  const unsigned char * D.31154;
  unsigned char D.31155;
  int D.31156;
  const char * D.31158;

  {
    static struct MonoClass * cached_class;

    cached_class.208 = cached_class;
    if (cached_class.208 != 0B) goto <D.31068>; else goto <D.31069>;
    <D.31068>:
    cached_class.208 = cached_class;
    D.31071 = cached_class.208 == class;
    D.31070 = (gboolean) D.31071;
    return D.31070;
    <D.31069>:
    D.31072 = is_corlib_type (class);
    if (D.31072 != 0) goto <D.31073>; else goto <D.31074>;
    <D.31073>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.31078 = "PointerType";
        D.31079 = MEM[(const unsigned char *)D.31078];
        D.31080 = (int) D.31079;
        D.31081 = *__s2;
        D.31082 = (int) D.31081;
        __result = D.31080 - D.31082;
        {
          D.31083 = __s1_len != 0;
          D.31084 = __result == 0;
          D.31085 = D.31083 & D.31084;
          if (D.31085 != 0) goto <D.31086>; else goto <D.31087>;
          <D.31086>:
          D.31088 = &MEM[(void *)"PointerType" + 1B];
          D.31089 = *D.31088;
          D.31090 = (int) D.31089;
          D.31091 = __s2 + 1;
          D.31092 = *D.31091;
          D.31093 = (int) D.31092;
          __result = D.31090 - D.31093;
          D.31094 = __s1_len > 1;
          D.31084 = __result == 0;
          D.31095 = D.31094 & D.31084;
          if (D.31095 != 0) goto <D.31096>; else goto <D.31097>;
          <D.31096>:
          D.31098 = &MEM[(void *)"PointerType" + 2B];
          D.31099 = *D.31098;
          D.31100 = (int) D.31099;
          D.31101 = __s2 + 2;
          D.31102 = *D.31101;
          D.31103 = (int) D.31102;
          __result = D.31100 - D.31103;
          D.31104 = __s1_len > 2;
          D.31084 = __result == 0;
          D.31105 = D.31104 & D.31084;
          if (D.31105 != 0) goto <D.31106>; else goto <D.31107>;
          <D.31106>:
          D.31108 = &MEM[(void *)"PointerType" + 3B];
          D.31109 = *D.31108;
          D.31110 = (int) D.31109;
          D.31111 = __s2 + 3;
          D.31112 = *D.31111;
          D.31113 = (int) D.31112;
          __result = D.31110 - D.31113;
          <D.31107>:
          <D.31097>:
          <D.31087>:
        }
        D.22540 = __result;
      }
      iftmp.209 = D.22540;
      goto <D.31114>;
      <D.31077>:
      D.31115 = class->name;
      iftmp.209 = __builtin_strcmp ("PointerType", D.31115);
      <D.31114>:
      D.22544 = iftmp.209;
    }
    if (D.22544 == 0) goto <D.31116>; else goto <D.31117>;
    <D.31116>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.31121 = "System.Reflection.Emit";
        D.31122 = MEM[(const unsigned char *)D.31121];
        D.31123 = (int) D.31122;
        D.31124 = *__s2;
        D.31125 = (int) D.31124;
        __result = D.31123 - D.31125;
        {
          D.31126 = __s1_len != 0;
          D.31127 = __result == 0;
          D.31128 = D.31126 & D.31127;
          if (D.31128 != 0) goto <D.31129>; else goto <D.31130>;
          <D.31129>:
          D.31131 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.31132 = *D.31131;
          D.31133 = (int) D.31132;
          D.31134 = __s2 + 1;
          D.31135 = *D.31134;
          D.31136 = (int) D.31135;
          __result = D.31133 - D.31136;
          D.31137 = __s1_len > 1;
          D.31127 = __result == 0;
          D.31138 = D.31137 & D.31127;
          if (D.31138 != 0) goto <D.31139>; else goto <D.31140>;
          <D.31139>:
          D.31141 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.31142 = *D.31141;
          D.31143 = (int) D.31142;
          D.31144 = __s2 + 2;
          D.31145 = *D.31144;
          D.31146 = (int) D.31145;
          __result = D.31143 - D.31146;
          D.31147 = __s1_len > 2;
          D.31127 = __result == 0;
          D.31148 = D.31147 & D.31127;
          if (D.31148 != 0) goto <D.31149>; else goto <D.31150>;
          <D.31149>:
          D.31151 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.31152 = *D.31151;
          D.31153 = (int) D.31152;
          D.31154 = __s2 + 3;
          D.31155 = *D.31154;
          D.31156 = (int) D.31155;
          __result = D.31153 - D.31156;
          <D.31150>:
          <D.31140>:
          <D.31130>:
        }
        D.22549 = __result;
      }
      iftmp.210 = D.22549;
      goto <D.31157>;
      <D.31120>:
      D.31158 = class->name_space;
      iftmp.210 = __builtin_strcmp ("System.Reflection.Emit", D.31158);
      <D.31157>:
      D.22553 = iftmp.210;
    }
    if (D.22553 == 0) goto <D.31159>; else goto <D.31160>;
    <D.31159>:
    cached_class = class;
    D.31070 = 1;
    return D.31070;
    <D.31160>:
    <D.31117>:
    <D.31074>:
    D.31070 = 0;
    return D.31070;
  }
}


mono_image_register_token (struct MonoDynamicImage * assembly, guint32 token, struct MonoObject * obj)
{
  long unsigned int D.31162;
  const void * D.31163;
  struct MonoGHashTable * D.31164;
  void * D.31168;
  struct MonoObject * prev;

  D.31162 = (long unsigned int) token;
  D.31163 = (const void *) D.31162;
  D.31164 = assembly->tokens;
  prev = mono_g_hash_table_lookup (D.31164, D.31163);
  if (prev != 0B) goto <D.31165>; else goto <D.31166>;
  <D.31165>:
  goto <D.31167>;
  <D.31166>:
  D.31162 = (long unsigned int) token;
  D.31168 = (void *) D.31162;
  D.31164 = assembly->tokens;
  mono_g_hash_table_insert (D.31164, D.31168, obj);
  <D.31167>:
}


mono_dynamic_image_release_gc_roots (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * * D.31169;
  struct MonoGHashTable * * D.31170;
  struct MonoGHashTable * * D.31171;
  struct MonoGHashTable * * D.31172;
  struct MonoGHashTable * * D.31173;
  struct MonoGHashTable * * D.31174;

  D.31169 = &image->token_fixups;
  release_hashtable (D.31169);
  D.31170 = &image->handleref_managed;
  release_hashtable (D.31170);
  D.31171 = &image->tokens;
  release_hashtable (D.31171);
  D.31172 = &image->remapped_tokens;
  release_hashtable (D.31172);
  D.31173 = &image->generic_def_objects;
  release_hashtable (D.31173);
  D.31174 = &image->methodspec;
  release_hashtable (D.31174);
}


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

  D.31175 = *hash;
  if (D.31175 != 0B) goto <D.31176>; else goto <D.31177>;
  <D.31176>:
  D.31175 = *hash;
  mono_g_hash_table_destroy (D.31175);
  *hash = 0B;
  <D.31177>:
}


mono_dynamic_image_free (struct MonoDynamicImage * image)
{
  struct MonoGHashTable * D.31178;
  struct GHashTable * D.31181;
  struct GHashTable * D.31184;
  struct GHashTable * D.31187;
  struct MonoGHashTable * D.31190;
  struct MonoGHashTable * D.31193;
  struct MonoGHashTable * D.31196;
  struct MonoGHashTable * D.31199;
  struct GHashTable * D.31202;
  struct GHashTable * D.31205;
  struct MonoMethodSignature * D.31208;
  char * D.31209;
  struct GList * D.31210;
  struct GPtrArray * D.31211;
  void * * D.31214;
  long unsigned int D.31215;
  long unsigned int D.31216;
  void * * D.31217;
  struct MonoReflectionGenericParam * * D.31218;
  unsigned int i.211;
  unsigned int D.31220;
  struct MonoGHashTable * D.31221;
  struct GHashTable * D.31224;
  struct GHashTable * D.31227;
  struct GHashTable * D.31230;
  struct GHashTable * D.31233;
  char * D.31236;
  char * D.31237;
  guint8 * D.31238;
  struct MonoDynamicStream * D.31241;
  struct MonoDynamicStream * D.31242;
  struct MonoDynamicStream * D.31243;
  struct MonoDynamicStream * D.31244;
  struct MonoDynamicStream * D.31245;
  struct MonoDynamicStream * D.31246;
  struct MonoDynamicStream * D.31247;
  guint32 * D.31248;
  struct MonoDynamicImage * di;
  struct GList * list;
  int i;

  di = image;
  D.31178 = di->methodspec;
  if (D.31178 != 0B) goto <D.31179>; else goto <D.31180>;
  <D.31179>:
  D.31178 = di->methodspec;
  mono_g_hash_table_destroy (D.31178);
  <D.31180>:
  D.31181 = di->typespec;
  if (D.31181 != 0B) goto <D.31182>; else goto <D.31183>;
  <D.31182>:
  D.31181 = di->typespec;
  monoeg_g_hash_table_destroy (D.31181);
  <D.31183>:
  D.31184 = di->typeref;
  if (D.31184 != 0B) goto <D.31185>; else goto <D.31186>;
  <D.31185>:
  D.31184 = di->typeref;
  monoeg_g_hash_table_destroy (D.31184);
  <D.31186>:
  D.31187 = di->handleref;
  if (D.31187 != 0B) goto <D.31188>; else goto <D.31189>;
  <D.31188>:
  D.31187 = di->handleref;
  monoeg_g_hash_table_destroy (D.31187);
  <D.31189>:
  D.31190 = di->handleref_managed;
  if (D.31190 != 0B) goto <D.31191>; else goto <D.31192>;
  <D.31191>:
  D.31190 = di->handleref_managed;
  mono_g_hash_table_destroy (D.31190);
  <D.31192>:
  D.31193 = di->tokens;
  if (D.31193 != 0B) goto <D.31194>; else goto <D.31195>;
  <D.31194>:
  D.31193 = di->tokens;
  mono_g_hash_table_destroy (D.31193);
  <D.31195>:
  D.31196 = di->remapped_tokens;
  if (D.31196 != 0B) goto <D.31197>; else goto <D.31198>;
  <D.31197>:
  D.31196 = di->remapped_tokens;
  mono_g_hash_table_destroy (D.31196);
  <D.31198>:
  D.31199 = di->generic_def_objects;
  if (D.31199 != 0B) goto <D.31200>; else goto <D.31201>;
  <D.31200>:
  D.31199 = di->generic_def_objects;
  mono_g_hash_table_destroy (D.31199);
  <D.31201>:
  D.31202 = di->blob_cache;
  if (D.31202 != 0B) goto <D.31203>; else goto <D.31204>;
  <D.31203>:
  D.31202 = di->blob_cache;
  monoeg_g_hash_table_foreach (D.31202, free_blob_cache_entry, 0B);
  D.31202 = di->blob_cache;
  monoeg_g_hash_table_destroy (D.31202);
  <D.31204>:
  D.31205 = di->standalonesig_cache;
  if (D.31205 != 0B) goto <D.31206>; else goto <D.31207>;
  <D.31206>:
  D.31205 = di->standalonesig_cache;
  monoeg_g_hash_table_destroy (D.31205);
  <D.31207>:
  list = di->array_methods;
  goto <D.20768>;
  <D.20767>:
  {
    struct ArrayMethod * am;

    am = list->data;
    D.31208 = am->sig;
    monoeg_g_free (D.31208);
    D.31209 = am->name;
    monoeg_g_free (D.31209);
    monoeg_g_free (am);
  }
  list = list->next;
  <D.20768>:
  if (list != 0B) goto <D.20767>; else goto <D.20769>;
  <D.20769>:
  D.31210 = di->array_methods;
  monoeg_g_list_free (D.31210);
  D.31211 = di->gen_params;
  if (D.31211 != 0B) goto <D.31212>; else goto <D.31213>;
  <D.31212>:
  i = 0;
  goto <D.20772>;
  <D.20771>:
  {
    struct GenericParamTableEntry * entry;

    D.31211 = di->gen_params;
    D.31214 = D.31211->pdata;
    D.31215 = (long unsigned int) i;
    D.31216 = D.31215 * 8;
    D.31217 = D.31214 + D.31216;
    entry = *D.31217;
    D.31218 = &entry->gparam;
    mono_gc_deregister_root (D.31218);
    monoeg_g_free (entry);
  }
  i = i + 1;
  <D.20772>:
  i.211 = (unsigned int) i;
  D.31211 = di->gen_params;
  D.31220 = D.31211->len;
  if (i.211 < D.31220) goto <D.20771>; else goto <D.20773>;
  <D.20773>:
  D.31211 = di->gen_params;
  monoeg_g_ptr_array_free (D.31211, 1);
  <D.31213>:
  D.31221 = di->token_fixups;
  if (D.31221 != 0B) goto <D.31222>; else goto <D.31223>;
  <D.31222>:
  D.31221 = di->token_fixups;
  mono_g_hash_table_destroy (D.31221);
  <D.31223>:
  D.31224 = di->method_to_table_idx;
  if (D.31224 != 0B) goto <D.31225>; else goto <D.31226>;
  <D.31225>:
  D.31224 = di->method_to_table_idx;
  monoeg_g_hash_table_destroy (D.31224);
  <D.31226>:
  D.31227 = di->field_to_table_idx;
  if (D.31227 != 0B) goto <D.31228>; else goto <D.31229>;
  <D.31228>:
  D.31227 = di->field_to_table_idx;
  monoeg_g_hash_table_destroy (D.31227);
  <D.31229>:
  D.31230 = di->method_aux_hash;
  if (D.31230 != 0B) goto <D.31231>; else goto <D.31232>;
  <D.31231>:
  D.31230 = di->method_aux_hash;
  monoeg_g_hash_table_destroy (D.31230);
  <D.31232>:
  D.31233 = di->vararg_aux_hash;
  if (D.31233 != 0B) goto <D.31234>; else goto <D.31235>;
  <D.31234>:
  D.31233 = di->vararg_aux_hash;
  monoeg_g_hash_table_destroy (D.31233);
  <D.31235>:
  D.31236 = di->strong_name;
  monoeg_g_free (D.31236);
  D.31237 = di->win32_res;
  monoeg_g_free (D.31237);
  D.31238 = di->public_key;
  if (D.31238 != 0B) goto <D.31239>; else goto <D.31240>;
  <D.31239>:
  D.31238 = di->public_key;
  monoeg_g_free (D.31238);
  <D.31240>:
  D.31241 = &di->sheap;
  mono_dynamic_stream_reset (D.31241);
  D.31242 = &di->code;
  mono_dynamic_stream_reset (D.31242);
  D.31243 = &di->resources;
  mono_dynamic_stream_reset (D.31243);
  D.31244 = &di->us;
  mono_dynamic_stream_reset (D.31244);
  D.31245 = &di->blob;
  mono_dynamic_stream_reset (D.31245);
  D.31246 = &di->tstream;
  mono_dynamic_stream_reset (D.31246);
  D.31247 = &di->guid;
  mono_dynamic_stream_reset (D.31247);
  i = 0;
  goto <D.20775>;
  <D.20774>:
  D.31248 = di->tables[i].values;
  monoeg_g_free (D.31248);
  i = i + 1;
  <D.20775>:
  if (i <= 44) goto <D.20774>; else goto <D.20776>;
  <D.20776>:
}


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.31249;
  struct MonoDynamicAssembly * D.31250;
  void * D.31253;
  struct MonoAssembly * D.31254;
  unsigned char D.31255;
  struct MonoString * D.31256;
  char * D.31257;
  struct MonoString * D.31258;
  char * D.31261;
  gchar * D.31263;
  struct MonoString * D.31264;
  char * * parts.212;
  char * D.31268;
  int D.31269;
  short unsigned int D.31270;
  char * * parts.213;
  char * D.31272;
  int D.31273;
  short unsigned int D.31274;
  uint16_t iftmp.214;
  char * D.31276;
  char * * parts.215;
  char * D.31280;
  int D.31281;
  uint16_t iftmp.216;
  int D.31286;
  unsigned int D.31289;
  _Bool D.31290;
  unsigned char D.31291;
  _Bool D.31292;
  unsigned char D.31293;
  gchar * D.31294;
  struct MonoString * D.31295;
  char * D.31296;
  char * D.31297;
  struct MonoImage * D.31298;
  struct MonoArray * D.31299;
  unsigned int D.31302;
  const char * D.31307;
  long unsigned int D.31308;
  char * D.31309;
  mono_byte[17] * D.31310;
  union mono_mutex_t * D.31311;
  _Bool D.31314;
  long int D.31315;
  long int D.31316;
  struct GSList * D.31319;
  struct GSList * D.31320;
  _Bool D.31323;
  long int D.31324;
  long int D.31325;
  struct MonoReflectionAssembly * D.31328;
  struct MonoDomain * D.31329;
  struct MonoDynamicAssembly * assembly;
  struct MonoDynamicImage * image;
  struct MonoDomain * domain;

  D.31249 = MEM[(struct MonoObject *)assemblyb].vtable;
  domain = D.31249->domain;
  D.31250 = assemblyb->dynamic_assembly;
  if (D.31250 != 0B) goto <D.31251>; else goto <D.31252>;
  <D.31251>:
  return;
  <D.31252>:
  D.31253 = monoeg_malloc0 (152);
  assemblyb->dynamic_assembly = D.31253;
  assembly = assemblyb->dynamic_assembly;
  D.31254 = &assembly->assembly;
  mono_profiler_assembly_event (D.31254, 0);
  assembly->assembly.ref_count = 1;
  assembly->assembly.dynamic = 1;
  D.31255 = assemblyb->corlib_internal;
  assembly->assembly.corlib_internal = D.31255;
  assemblyb->assembly.assembly = assembly;
  D.31256 = assemblyb->dir;
  D.31257 = mono_string_to_utf8 (D.31256);
  assembly->assembly.basedir = D.31257;
  D.31258 = assemblyb->culture;
  if (D.31258 != 0B) goto <D.31259>; else goto <D.31260>;
  <D.31259>:
  D.31258 = assemblyb->culture;
  D.31261 = mono_string_to_utf8 (D.31258);
  assembly->assembly.aname.culture = D.31261;
  goto <D.31262>;
  <D.31260>:
  D.31263 = monoeg_strdup ("");
  assembly->assembly.aname.culture = D.31263;
  <D.31262>:
  D.31264 = assemblyb->version;
  if (D.31264 != 0B) goto <D.31265>; else goto <D.31266>;
  <D.31265>:
  {
    char * vstr;
    char * * version;
    char * * parts;

    D.31264 = assemblyb->version;
    vstr = mono_string_to_utf8 (D.31264);
    version = monoeg_g_strsplit (vstr, ".", 4);
    parts = version;
    parts.212 = parts;
    parts = parts.212 + 8;
    D.31268 = *parts.212;
    D.31269 = atoi (D.31268);
    D.31270 = (short unsigned int) D.31269;
    assembly->assembly.aname.major = D.31270;
    parts.213 = parts;
    parts = parts.213 + 8;
    D.31272 = *parts.213;
    D.31273 = atoi (D.31272);
    D.31274 = (short unsigned int) D.31273;
    assembly->assembly.aname.minor = D.31274;
    D.31276 = *parts;
    if (D.31276 != 0B) goto <D.31277>; else goto <D.31278>;
    <D.31277>:
    parts.215 = parts;
    parts = parts.215 + 8;
    D.31280 = *parts.215;
    D.31281 = atoi (D.31280);
    iftmp.214 = (uint16_t) D.31281;
    goto <D.31282>;
    <D.31278>:
    iftmp.214 = 0;
    <D.31282>:
    assembly->assembly.aname.build = iftmp.214;
    D.31276 = *parts;
    if (D.31276 != 0B) goto <D.31284>; else goto <D.31285>;
    <D.31284>:
    D.31276 = *parts;
    D.31286 = atoi (D.31276);
    iftmp.216 = (uint16_t) D.31286;
    goto <D.31287>;
    <D.31285>:
    iftmp.216 = 0;
    <D.31287>:
    assembly->assembly.aname.revision = iftmp.216;
    monoeg_g_strfreev (version);
    monoeg_g_free (vstr);
  }
  goto <D.31288>;
  <D.31266>:
  assembly->assembly.aname.major = 0;
  assembly->assembly.aname.minor = 0;
  assembly->assembly.aname.build = 0;
  assembly->assembly.aname.revision = 0;
  <D.31288>:
  D.31289 = assemblyb->access;
  D.31290 = D.31289 != 2;
  D.31291 = (unsigned char) D.31290;
  assembly->run = D.31291;
  D.31289 = assemblyb->access;
  D.31292 = D.31289 != 1;
  D.31293 = (unsigned char) D.31292;
  assembly->save = D.31293;
  assembly->domain = domain;
  D.31294 = monoeg_strdup ("RefEmit_YouForgotToDefineAModule");
  D.31295 = assemblyb->name;
  D.31296 = mono_string_to_utf8 (D.31295);
  image = create_dynamic_mono_image (assembly, D.31296, D.31294);
  image->initial_image = 1;
  D.31297 = image->image.name;
  assembly->assembly.aname.name = D.31297;
  D.31298 = &image->image;
  assembly->assembly.image = D.31298;
  D.31299 = assemblyb->pktoken;
  if (D.31299 != 0B) goto <D.31300>; else goto <D.31301>;
  <D.31300>:
  D.31299 = assemblyb->pktoken;
  D.31302 = D.31299->max_length;
  if (D.31302 != 0) goto <D.31303>; else goto <D.31304>;
  <D.31303>:
  D.31299 = assemblyb->pktoken;
  D.31302 = D.31299->max_length;
  if (D.31302 != 16) goto <D.31305>; else goto <D.31306>;
  <D.31305>:
  D.31299 = assemblyb->pktoken;
  D.31302 = D.31299->max_length;
  D.31307 = assembly->assembly.aname.name;
  monoeg_g_log (0B, 4, "Public key token length invalid for assembly %s: %i", D.31307, D.31302);
  <D.20786>:
  goto <D.20786>;
  <D.31306>:
  D.31299 = assemblyb->pktoken;
  D.31302 = D.31299->max_length;
  D.31308 = (long unsigned int) D.31302;
  D.31299 = assemblyb->pktoken;
  D.31309 = mono_array_addr_with_size (D.31299, 1, 0);
  D.31310 = &assembly->assembly.aname.public_key_token;
  memcpy (D.31310, D.31309, D.31308);
  <D.31304>:
  <D.31301>:
  {
    int ret;

    D.31311 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.31311);
    if (ret != 0) goto <D.31312>; else goto <D.31313>;
    <D.31312>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.31313>:
    D.31314 = ret != 0;
    D.31315 = (long int) D.31314;
    D.31316 = __builtin_expect (D.31315, 0);
    if (D.31316 != 0) goto <D.31317>; else goto <D.31318>;
    <D.31317>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5333, "ret == 0");
    <D.31318>:
  }
  D.31319 = domain->domain_assemblies;
  D.31320 = monoeg_g_slist_append (D.31319, assembly);
  domain->domain_assemblies = D.31320;
  {
    int ret;

    D.31311 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.31311);
    if (ret != 0) goto <D.31321>; else goto <D.31322>;
    <D.31321>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.31322>:
    D.31323 = ret != 0;
    D.31324 = (long int) D.31323;
    D.31325 = __builtin_expect (D.31324, 0);
    if (D.31325 != 0) goto <D.31326>; else goto <D.31327>;
    <D.31326>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5335, "ret == 0");
    <D.31327>:
  }
  D.31254 = &assembly->assembly;
  D.31328 = &assemblyb->assembly;
  D.31249 = MEM[(struct MonoObject *)assemblyb].vtable;
  D.31329 = D.31249->domain;
  register_assembly (D.31329, D.31328, D.31254);
  D.31254 = &assembly->assembly;
  mono_profiler_assembly_loaded (D.31254, 0);
  mono_assembly_invoke_load_hook (assembly);
}


atoi (const char * __nptr)
{
  int D.31331;
  long int D.31332;

  D.31332 = strtol (__nptr, 0B, 10);
  D.31331 = (int) D.31332;
  return D.31331;
}


create_dynamic_mono_image (struct MonoDynamicAssembly * assembly, char * assembly_name, char * module_name)
{
  int D.20745;
  int iftmp.217;
  int D.20744;
  const struct MonoRuntimeInfo * D.31337;
  const char[4] * D.31338;
  unsigned char D.31339;
  int D.31340;
  unsigned char D.31341;
  int D.31342;
  _Bool D.31343;
  _Bool D.31344;
  _Bool D.31345;
  const unsigned char * D.31348;
  unsigned char D.31349;
  int D.31350;
  const unsigned char * D.31351;
  unsigned char D.31352;
  int D.31353;
  _Bool D.31354;
  _Bool D.31355;
  const unsigned char * D.31358;
  unsigned char D.31359;
  int D.31360;
  const unsigned char * D.31361;
  unsigned char D.31362;
  int D.31363;
  _Bool D.31364;
  _Bool D.31365;
  const unsigned char * D.31368;
  unsigned char D.31369;
  int D.31370;
  const unsigned char * D.31371;
  unsigned char D.31372;
  int D.31373;
  const struct MonoRuntimeInfo * D.31375;
  const char[4] * D.31376;
  const struct MonoRuntimeInfo * D.31380;
  struct MonoImage * D.31381;
  char * D.31382;
  gchar * D.31383;
  void * D.31384;
  struct MonoAssembly * * D.31385;
  struct MonoGHashTable * D.31386;
  struct GHashTable * D.31387;
  struct GHashTable * D.31388;
  struct GHashTable * D.31389;
  struct GHashTable * D.31390;
  struct GHashTable * D.31391;
  struct MonoGHashTable * D.31392;
  struct MonoGHashTable * D.31393;
  struct MonoGHashTable * D.31394;
  struct MonoGHashTable * D.31395;
  struct GHashTable * D.31396;
  struct GHashTable * D.31397;
  struct GHashTable * D.31398;
  struct GPtrArray * D.31399;
  struct MonoGHashTable * D.31400;
  struct MonoDynamicStream * D.31401;
  struct MonoDynamicStream * D.31402;
  struct MonoDynamicStream * D.31403;
  unsigned int D.31404;
  unsigned int D.31405;
  unsigned int D.31406;
  unsigned int D.31407;
  unsigned int D.31408;
  unsigned char D.31409;
  unsigned char D.31410;
  int D.31411;
  unsigned char D.31412;
  int D.31413;
  struct MonoDynamicImage * D.31414;
  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.31335>; else goto <D.31336>;
    <D.31335>:
    {
      const unsigned char * __s2;
      int __result;

      D.31337 = mono_get_runtime_info ();
      __s2 = &D.31337->framework_version;
      D.31338 = "2.1";
      D.31339 = MEM[(const unsigned char *)D.31338];
      D.31340 = (int) D.31339;
      D.31341 = *__s2;
      D.31342 = (int) D.31341;
      __result = D.31340 - D.31342;
      {
        D.31343 = __s2_len != 0;
        D.31344 = __result == 0;
        D.31345 = D.31343 & D.31344;
        if (D.31345 != 0) goto <D.31346>; else goto <D.31347>;
        <D.31346>:
        D.31348 = &MEM[(void *)"2.1" + 1B];
        D.31349 = *D.31348;
        D.31350 = (int) D.31349;
        D.31351 = __s2 + 1;
        D.31352 = *D.31351;
        D.31353 = (int) D.31352;
        __result = D.31350 - D.31353;
        D.31354 = __s2_len > 1;
        D.31344 = __result == 0;
        D.31355 = D.31354 & D.31344;
        if (D.31355 != 0) goto <D.31356>; else goto <D.31357>;
        <D.31356>:
        D.31358 = &MEM[(void *)"2.1" + 2B];
        D.31359 = *D.31358;
        D.31360 = (int) D.31359;
        D.31361 = __s2 + 2;
        D.31362 = *D.31361;
        D.31363 = (int) D.31362;
        __result = D.31360 - D.31363;
        D.31364 = __s2_len > 2;
        D.31344 = __result == 0;
        D.31365 = D.31364 & D.31344;
        if (D.31365 != 0) goto <D.31366>; else goto <D.31367>;
        <D.31366>:
        D.31368 = &MEM[(void *)"2.1" + 3B];
        D.31369 = *D.31368;
        D.31370 = (int) D.31369;
        D.31371 = __s2 + 3;
        D.31372 = *D.31371;
        D.31373 = (int) D.31372;
        __result = D.31370 - D.31373;
        <D.31367>:
        <D.31357>:
        <D.31347>:
      }
      D.20744 = __result;
    }
    iftmp.217 = -D.20744;
    goto <D.31374>;
    <D.31336>:
    D.31375 = mono_get_runtime_info ();
    D.31376 = &D.31375->framework_version;
    iftmp.217 = __builtin_strcmp (D.31376, "2.1");
    <D.31374>:
    D.20745 = iftmp.217;
  }
  if (D.20745 == 0) goto <D.31377>; else goto <D.31378>;
  <D.31377>:
  version = "v2.0.50727";
  goto <D.31379>;
  <D.31378>:
  D.31380 = mono_get_runtime_info ();
  version = &D.31380->runtime_version;
  <D.31379>:
  image = monoeg_malloc0 (3176);
  D.31381 = &image->image;
  mono_profiler_module_event (D.31381, 0);
  image->image.name = assembly_name;
  D.31382 = image->image.name;
  image->image.assembly_name = D.31382;
  image->image.module_name = module_name;
  D.31383 = monoeg_strdup (version);
  image->image.version = D.31383;
  image->image.md_version_major = 1;
  image->image.md_version_minor = 1;
  image->image.dynamic = 1;
  D.31384 = monoeg_malloc0 (8);
  image->image.references = D.31384;
  D.31385 = image->image.references;
  *D.31385 = 0B;
  D.31381 = &image->image;
  mono_image_init (D.31381);
  D.31386 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->token_fixups = D.31386;
  D.31387 = monoeg_g_hash_table_new (0B, 0B);
  image->method_to_table_idx = D.31387;
  D.31388 = monoeg_g_hash_table_new (0B, 0B);
  image->field_to_table_idx = D.31388;
  D.31389 = monoeg_g_hash_table_new (0B, 0B);
  image->method_aux_hash = D.31389;
  D.31390 = monoeg_g_hash_table_new (0B, 0B);
  image->vararg_aux_hash = D.31390;
  D.31391 = monoeg_g_hash_table_new (0B, 0B);
  image->handleref = D.31391;
  D.31392 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->handleref_managed = D.31392;
  D.31393 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->tokens = D.31393;
  D.31394 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->generic_def_objects = D.31394;
  D.31395 = mono_g_hash_table_new_type (mono_object_hash, 0B, 1);
  image->methodspec = D.31395;
  D.31396 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typespec = D.31396;
  D.31397 = monoeg_g_hash_table_new (mono_metadata_type_hash, mono_metadata_type_equal);
  image->typeref = D.31397;
  D.31398 = monoeg_g_hash_table_new (mono_blob_entry_hash, mono_blob_entry_equal);
  image->blob_cache = D.31398;
  D.31399 = monoeg_g_ptr_array_new ();
  image->gen_params = D.31399;
  D.31400 = mono_g_hash_table_new_type (0B, 0B, 2);
  image->remapped_tokens = D.31400;
  D.31401 = &image->sheap;
  string_heap_init (D.31401);
  D.31402 = &image->us;
  mono_image_add_stream_data (D.31402, "", 1);
  add_to_blob_cached (image, "", 1, 0B, 0);
  D.31403 = &image->code;
  mono_image_add_stream_data (D.31403, &entrycode, 16);
  D.31403 = &image->code;
  D.31404 = mono_image_add_stream_zero (D.31403, 8);
  image->iat_offset = D.31404;
  D.31403 = &image->code;
  D.31405 = mono_image_add_stream_zero (D.31403, 40);
  image->idt_offset = D.31405;
  D.31403 = &image->code;
  D.31406 = mono_image_add_stream_zero (D.31403, 2);
  image->imp_names_offset = D.31406;
  D.31403 = &image->code;
  mono_image_add_stream_data (D.31403, "_CorExeMain", 12);
  D.31403 = &image->code;
  mono_image_add_stream_data (D.31403, "mscoree.dll", 12);
  D.31403 = &image->code;
  D.31407 = mono_image_add_stream_zero (D.31403, 8);
  image->ilt_offset = D.31407;
  D.31403 = &image->code;
  stream_data_align (D.31403);
  D.31403 = &image->code;
  D.31408 = mono_image_add_stream_zero (D.31403, 136);
  image->cli_header_offset = D.31408;
  i = 0;
  goto <D.20747>;
  <D.20746>:
  image->tables[i].next_idx = 1;
  D.31409 = table_sizes[i];
  image->tables[i].columns = D.31409;
  i = i + 1;
  <D.20747>:
  if (i <= 44) goto <D.20746>; else goto <D.20748>;
  <D.20748>:
  image->image.assembly = assembly;
  D.31410 = assembly->run;
  D.31411 = (int) D.31410;
  image->run = D.31411;
  D.31412 = assembly->save;
  D.31413 = (int) D.31412;
  image->save = D.31413;
  image->pe_kind = 1;
  image->machine = 332;
  D.31381 = &image->image;
  mono_profiler_module_loaded (D.31381, 0);
  D.31414 = image;
  return D.31414;
}


mono_blob_entry_equal (const char * str1, const char * str2)
{
  unsigned int D.31416;
  unsigned int D.31417;
  gboolean D.31420;
  long unsigned int D.31421;
  const char * end2.218;
  const char * end1.219;
  int D.31424;
  _Bool D.31425;
  int len;
  int len2;
  const char * end1;
  const char * end2;

  try
    {
      D.31416 = mono_metadata_decode_blob_size (str1, &end1);
      len = (int) D.31416;
      D.31417 = mono_metadata_decode_blob_size (str2, &end2);
      len2 = (int) D.31417;
      if (len != len2) goto <D.31418>; else goto <D.31419>;
      <D.31418>:
      D.31420 = 0;
      return D.31420;
      <D.31419>:
      D.31421 = (long unsigned int) len;
      end2.218 = end2;
      end1.219 = end1;
      D.31424 = memcmp (end1.219, end2.218, D.31421);
      D.31425 = D.31424 == 0;
      D.31420 = (gboolean) D.31425;
      return D.31420;
    }
  finally
    {
      end1 = {CLOBBER};
      end2 = {CLOBBER};
    }
}


mono_blob_entry_hash (const char * str)
{
  const char * str.220;
  sizetype D.31431;
  char D.31432;
  const char * str.221;
  unsigned int D.31434;
  unsigned int D.31435;
  unsigned int D.31436;
  int D.31437;
  guint len;
  guint h;
  const char * end;

  str.220 = str;
  len = mono_metadata_decode_blob_size (str.220, &str);
  if (len != 0) goto <D.31429>; else goto <D.31430>;
  <D.31429>:
  str.220 = str;
  D.31431 = (sizetype) len;
  end = str.220 + D.31431;
  str.220 = str;
  D.31432 = *str.220;
  h = (guint) D.31432;
  str.220 = str;
  str.221 = str.220 + 1;
  str = str.221;
  goto <D.18751>;
  <D.18750>:
  D.31434 = h << 5;
  D.31435 = D.31434 - h;
  str.220 = str;
  D.31432 = *str.220;
  D.31436 = (unsigned int) D.31432;
  h = D.31435 + D.31436;
  str.220 = str;
  str.221 = str.220 + 1;
  str = str.221;
  <D.18751>:
  str.220 = str;
  if (str.220 < end) goto <D.18750>; else goto <D.18752>;
  <D.18752>:
  D.31437 = (int) h;
  return D.31437;
  <D.31430>:
  D.31437 = 0;
  return D.31437;
}


string_heap_init (struct MonoDynamicStream * sh)
{
  void * D.31439;
  struct GHashTable * D.31440;

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


register_assembly (struct MonoDomain * domain, struct MonoReflectionAssembly * res, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.31441;
  _Bool D.31444;
  long int D.31445;
  long int D.31446;
  struct MonoGHashTable * D.31449;
  struct MonoGHashTable * D.31452;
  struct MonoMemPool * D.31455;
  _Bool D.31458;
  long int D.31459;
  long int D.31460;
  void * D.31463;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

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

          D.31441 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.31441);
          if (ret != 0) goto <D.31442>; else goto <D.31443>;
          <D.31442>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.31443>:
          D.31444 = ret != 0;
          D.31445 = (long int) D.31444;
          D.31446 = __builtin_expect (D.31445, 0);
          if (D.31446 != 0) goto <D.31447>; else goto <D.31448>;
          <D.31447>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.31448>:
        }
        D.31449 = domain->refobject_hash;
        if (D.31449 == 0B) goto <D.31450>; else goto <D.31451>;
        <D.31450>:
        D.31452 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.31452;
        <D.31451>:
        D.31449 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.31449, &pe);
        if (_obj == 0B) goto <D.31453>; else goto <D.31454>;
        <D.31453>:
        {
          struct ReflectedEntry * e;

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

          D.31441 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.31441);
          if (ret != 0) goto <D.31456>; else goto <D.31457>;
          <D.31456>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.31457>:
          D.31458 = ret != 0;
          D.31459 = (long int) D.31458;
          D.31460 = __builtin_expect (D.31459, 0);
          if (D.31460 != 0) goto <D.31461>; else goto <D.31462>;
          <D.31461>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6167, "ret == 0");
          <D.31462>:
        }
        D.31463 = _obj;
        return D.31463;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


reflected_equal (const void * a, const void * b)
{
  gboolean D.31466;
  int iftmp.222;
  void * D.31470;
  void * D.31471;
  struct MonoClass * D.31473;
  struct MonoClass * D.31474;
  const struct ReflectedEntry * ea;
  const struct ReflectedEntry * eb;

  ea = a;
  eb = b;
  D.31470 = ea->item;
  D.31471 = eb->item;
  if (D.31470 == D.31471) goto <D.31472>; else goto <D.31468>;
  <D.31472>:
  D.31473 = ea->refclass;
  D.31474 = eb->refclass;
  if (D.31473 == D.31474) goto <D.31475>; else goto <D.31468>;
  <D.31475>:
  iftmp.222 = 1;
  goto <D.31469>;
  <D.31468>:
  iftmp.222 = 0;
  <D.31469>:
  D.31466 = iftmp.222;
  return D.31466;
}


reflected_hash (const void * a)
{
  guint D.31477;
  void * D.31478;
  const struct ReflectedEntry * ea;

  ea = a;
  D.31478 = ea->item;
  D.31477 = mono_aligned_addr_hash (D.31478);
  return D.31477;
}


mono_image_create_pefile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  int D.31480;
  unsigned int D.31481;
  int D.31482;
  unsigned int D.31483;
  struct MonoDynamicAssembly * D.31484;
  struct MonoImage * D.31485;
  int D.31486;
  struct MonoArray * D.31489;
  long unsigned int D.31492;
  long unsigned int D.31493;
  char * D.31494;
  struct MonoArray * D.31495;
  long unsigned int D.31498;
  char * D.31499;
  long unsigned int D.31504;
  unsigned int D.31505;
  unsigned int D.31506;
  unsigned int D.31507;
  unsigned int D.31510;
  unsigned int D.31511;
  unsigned int D.31512;
  char * D.31513;
  sizetype D.31514;
  short unsigned int D.31515;
  short unsigned int D.31516;
  long int D.31517;
  unsigned int D.31518;
  unsigned int D.31519;
  unsigned int D.31523;
  _Bool D.31524;
  long int D.31525;
  long int D.31526;
  unsigned int D.31529;
  short unsigned int kind.223;
  unsigned int D.31534;
  unsigned int D.31535;
  unsigned int D.31536;
  unsigned int D.31537;
  unsigned int D.31538;
  unsigned int D.31539;
  unsigned int D.31540;
  unsigned int D.31541;
  char * D.31544;
  unsigned int D.31545;
  sizetype D.31546;
  sizetype D.31547;
  char * D.31548;
  sizetype D.31550;
  unsigned int D.31551;
  unsigned int D.31552;
  unsigned int D.31553;
  sizetype D.31554;
  sizetype D.31555;
  unsigned int D.31556;
  sizetype D.31557;
  unsigned int D.31558;
  unsigned int D.31559;
  sizetype D.31560;
  guchar * p.224;
  unsigned char D.31562;
  guchar * p.225;
  unsigned int D.31564;
  unsigned char D.31565;
  guchar * p.226;
  unsigned int D.31567;
  unsigned char D.31568;
  guchar * p.227;
  unsigned int D.31570;
  unsigned char D.31571;
  sizetype D.31572;
  struct MonoReflectionMethod * D.31573;
  int D.20934;
  int iftmp.228;
  int D.20933;
  struct MonoVTable * D.31579;
  struct MonoClass * D.31580;
  const char[14] * D.31581;
  unsigned char D.31582;
  int D.31583;
  unsigned char D.31584;
  int D.31585;
  _Bool D.31586;
  _Bool D.31587;
  _Bool D.31588;
  const unsigned char * D.31591;
  unsigned char D.31592;
  int D.31593;
  const unsigned char * D.31594;
  unsigned char D.31595;
  int D.31596;
  _Bool D.31597;
  _Bool D.31598;
  const unsigned char * D.31601;
  unsigned char D.31602;
  int D.31603;
  const unsigned char * D.31604;
  unsigned char D.31605;
  int D.31606;
  _Bool D.31607;
  _Bool D.31608;
  const unsigned char * D.31611;
  unsigned char D.31612;
  int D.31613;
  const unsigned char * D.31614;
  unsigned char D.31615;
  int D.31616;
  const char * D.31618;
  struct MonoMethod * D.31622;
  struct GHashTable * D.31623;
  void * D.31624;
  long int D.31625;
  unsigned int D.31626;
  unsigned int D.31628;
  unsigned int D.31629;
  unsigned int D.31630;
  unsigned int D.31631;
  sizetype D.31634;
  const char[7] * D.31637;
  char[8] * D.31638;
  unsigned int D.31639;
  unsigned int D.31640;
  unsigned int D.31641;
  unsigned int D.31642;
  unsigned int D.31643;
  unsigned int D.31644;
  unsigned int D.31645;
  unsigned int D.31646;
  int D.31649;
  unsigned int D.31650;
  unsigned int D.31653;
  unsigned int D.31654;
  guchar * p.229;
  guchar * p.230;
  guchar * p.231;
  guchar * p.232;
  char * D.31659;
  char * D.31660;
  char * D.31661;
  char * D.31664;
  unsigned int D.31667;
  int file_offset.233;
  unsigned int D.31669;
  unsigned int D.31672;
  int D.31673;
  unsigned int D.31676;
  struct MonoDynamicStream * D.31677;
  struct MonoDynamicStream * D.31678;
  struct MonoDynamicStream * D.31679;
  struct MonoDynamicStream * D.31680;
  struct MonoDynamicStream * D.31681;
  struct GHashTable * D.31682;
  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.31480 = assemblyb->pe_kind;
      D.31481 = (unsigned int) D.31480;
      assembly->pe_kind = D.31481;
      D.31482 = assemblyb->machine;
      D.31483 = (unsigned int) D.31482;
      assembly->machine = D.31483;
      D.31484 = assemblyb->dynamic_assembly;
      D.31485 = D.31484->assembly.image;
      D.31480 = assemblyb->pe_kind;
      D.31481 = (unsigned int) D.31480;
      MEM[(struct MonoDynamicImage *)D.31485].pe_kind = D.31481;
      D.31484 = assemblyb->dynamic_assembly;
      D.31485 = D.31484->assembly.image;
      D.31482 = assemblyb->machine;
      D.31483 = (unsigned int) D.31482;
      MEM[(struct MonoDynamicImage *)D.31485].machine = D.31483;
      mono_image_build_metadata (mb);
      D.31486 = mb->is_main;
      if (D.31486 != 0) goto <D.31487>; else goto <D.31488>;
      <D.31487>:
      D.31489 = assemblyb->resources;
      if (D.31489 != 0B) goto <D.31490>; else goto <D.31491>;
      <D.31490>:
      {
        int len;

        D.31489 = assemblyb->resources;
        D.31492 = mono_array_length (D.31489);
        len = (int) D.31492;
        i = 0;
        goto <D.20914>;
        <D.20913>:
        D.31493 = (long unsigned int) i;
        D.31489 = assemblyb->resources;
        D.31494 = mono_array_addr_with_size (D.31489, 40, D.31493);
        assembly_add_resource (mb, assembly, D.31494);
        i = i + 1;
        <D.20914>:
        if (i < len) goto <D.20913>; else goto <D.20915>;
        <D.20915>:
      }
      <D.31491>:
      <D.31488>:
      D.31495 = mb->resources;
      if (D.31495 != 0B) goto <D.31496>; else goto <D.31497>;
      <D.31496>:
      {
        int len;

        D.31495 = mb->resources;
        D.31498 = mono_array_length (D.31495);
        len = (int) D.31498;
        i = 0;
        goto <D.20918>;
        <D.20917>:
        D.31493 = (long unsigned int) i;
        D.31495 = mb->resources;
        D.31499 = mono_array_addr_with_size (D.31495, 40, D.31493);
        assembly_add_resource (mb, assembly, D.31499);
        i = i + 1;
        <D.20918>:
        if (i < len) goto <D.20917>; else goto <D.20919>;
        <D.20919>:
      }
      <D.31497>:
      build_compressed_metadata (assembly);
      D.31486 = mb->is_main;
      if (D.31486 != 0) goto <D.31500>; else goto <D.31501>;
      <D.31500>:
      assembly_add_win32_resources (assembly, assemblyb);
      <D.31501>:
      nsections = calc_section_size (assembly);
      if (0 != 0) goto <D.31502>; else goto <D.31503>;
      <D.31502>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5690, "sizeof (MonoMSDOSHeader) == sizeof (msheader)");
      <D.31503>:
      mono_image_add_stream_data (pefile, &msheader, 128);
      header_start = mono_image_add_stream_zero (pefile, 248);
      D.31504 = (long unsigned int) nsections;
      D.31505 = (unsigned int) D.31504;
      D.31506 = D.31505 * 40;
      section_start = mono_image_add_stream_zero (pefile, D.31506);
      D.31504 = (long unsigned int) nsections;
      D.31505 = (unsigned int) D.31504;
      D.31506 = D.31505 * 40;
      file_offset = D.31506 + section_start;
      virtual_offset = 8192;
      image_size = 0;
      i = 0;
      goto <D.20922>;
      <D.20921>:
      D.31507 = assembly->sections[i].size;
      if (D.31507 == 0) goto <D.31508>; else goto <D.31509>;
      <D.31508>:
      // predicted unlikely by continue predictor.
      goto <D.20920>;
      <D.31509>:
      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.31507 = assembly->sections[i].size;
      file_offset = D.31507 + file_offset;
      D.31507 = assembly->sections[i].size;
      virtual_offset = D.31507 + virtual_offset;
      D.31507 = assembly->sections[i].size;
      D.31510 = D.31507 + 8191;
      D.31511 = D.31510 & 4294959104;
      image_size = D.31511 + image_size;
      <D.20920>:
      i = i + 1;
      <D.20922>:
      if (i <= 2) goto <D.20921>; else goto <D.20923>;
      <D.20923>:
      file_offset = file_offset + 511;
      file_offset = file_offset & 4294966784;
      D.31504 = (long unsigned int) nsections;
      D.31505 = (unsigned int) D.31504;
      D.31506 = D.31505 * 40;
      D.31512 = D.31506 + section_start;
      image_size = D.31512 + image_size;
      msdos = pefile->data;
      msdos->pe_offset = 128;
      D.31513 = pefile->data;
      D.31514 = (sizetype) header_start;
      header = D.31513 + D.31514;
      header->pesig[0] = 80;
      header->pesig[1] = 69;
      D.31482 = assemblyb->machine;
      D.31515 = (short unsigned int) D.31482;
      header->coff.coff_machine = D.31515;
      D.31516 = (short unsigned int) nsections;
      header->coff.coff_sections = D.31516;
      D.31517 = time (0B);
      D.31518 = (unsigned int) D.31517;
      header->coff.coff_time = D.31518;
      header->coff.coff_opt_header_size = 224;
      D.31519 = assemblyb->pekind;
      if (D.31519 == 1) goto <D.31520>; else goto <D.31521>;
      <D.31520>:
      header->coff.coff_attributes = 8462;
      goto <D.31522>;
      <D.31521>:
      header->coff.coff_attributes = 270;
      <D.31522>:
      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.31523 = assembly->sections[0].rva;
      D.31524 = D.31523 != 8192;
      D.31525 = (long int) D.31524;
      D.31526 = __builtin_expect (D.31525, 0);
      if (D.31526 != 0) goto <D.31527>; else goto <D.31528>;
      <D.31527>:
      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.31528>:
      D.31523 = assembly->sections[0].rva;
      header->pe.pe_rva_code_base = D.31523;
      D.31529 = assembly->sections[1].rva;
      header->pe.pe_rva_data_base = D.31529;
      D.31523 = assembly->sections[0].rva;
      header->pe.pe_rva_entry_point = D.31523;
      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.31519 = assemblyb->pekind;
        if (D.31519 == 3) goto <D.31530>; else goto <D.31531>;
        <D.31530>:
        kind = 2;
        goto <D.31532>;
        <D.31531>:
        kind = 3;
        <D.31532>:
        kind.223 = (short unsigned int) kind;
        header->nt.pe_subsys_required = kind.223;
      }
      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.31534 = assembly->sections[1].size;
      header->datadir.pe_resource_table.size = D.31534;
      D.31529 = assembly->sections[1].rva;
      header->datadir.pe_resource_table.rva = D.31529;
      D.31535 = assembly->sections[2].size;
      header->datadir.pe_reloc_table.size = D.31535;
      D.31536 = assembly->sections[2].rva;
      header->datadir.pe_reloc_table.rva = D.31536;
      header->datadir.pe_cli_header.size = 72;
      D.31537 = assembly->text_rva;
      D.31538 = assembly->cli_header_offset;
      D.31539 = D.31537 + D.31538;
      header->datadir.pe_cli_header.rva = D.31539;
      header->datadir.pe_iat.size = 8;
      D.31537 = assembly->text_rva;
      D.31540 = assembly->iat_offset;
      D.31541 = D.31537 + D.31540;
      header->datadir.pe_iat.rva = D.31541;
      D.31519 = assemblyb->pekind;
      if (D.31519 == 1) goto <D.31542>; else goto <D.31543>;
      <D.31542>:
      D.31544 = assembly->code.data;
      D.31545 = assembly->imp_names_offset;
      D.31546 = (sizetype) D.31545;
      D.31547 = D.31546 + 2;
      D.31548 = D.31544 + D.31547;
      memcpy (D.31548, "_CorDllMain", 12);
      goto <D.31549>;
      <D.31543>:
      D.31544 = assembly->code.data;
      D.31545 = assembly->imp_names_offset;
      D.31546 = (sizetype) D.31545;
      D.31547 = D.31546 + 2;
      D.31548 = D.31544 + D.31547;
      memcpy (D.31548, "_CorExeMain", 12);
      <D.31549>:
      D.31544 = assembly->code.data;
      D.31540 = assembly->iat_offset;
      D.31550 = (sizetype) D.31540;
      rva = D.31544 + D.31550;
      D.31537 = assembly->text_rva;
      D.31545 = assembly->imp_names_offset;
      D.31551 = D.31537 + D.31545;
      *rva = D.31551;
      header->datadir.pe_import_table.size = 79;
      D.31537 = assembly->text_rva;
      D.31552 = assembly->idt_offset;
      D.31553 = D.31537 + D.31552;
      header->datadir.pe_import_table.rva = D.31553;
      D.31544 = assembly->code.data;
      D.31552 = assembly->idt_offset;
      D.31554 = (sizetype) D.31552;
      D.31555 = D.31554 + 12;
      rva = D.31544 + D.31555;
      D.31537 = assembly->text_rva;
      D.31545 = assembly->imp_names_offset;
      D.31551 = D.31537 + D.31545;
      D.31556 = D.31551 + 14;
      *rva = D.31556;
      D.31544 = assembly->code.data;
      D.31552 = assembly->idt_offset;
      D.31554 = (sizetype) D.31552;
      D.31557 = D.31554 + 16;
      rva = D.31544 + D.31557;
      D.31537 = assembly->text_rva;
      D.31540 = assembly->iat_offset;
      D.31541 = D.31537 + D.31540;
      *rva = D.31541;
      D.31544 = assembly->code.data;
      D.31552 = assembly->idt_offset;
      D.31554 = (sizetype) D.31552;
      rva = D.31544 + D.31554;
      D.31537 = assembly->text_rva;
      D.31558 = assembly->ilt_offset;
      D.31559 = D.31537 + D.31558;
      *rva = D.31559;
      D.31544 = assembly->code.data;
      D.31558 = assembly->ilt_offset;
      D.31560 = (sizetype) D.31558;
      p = D.31544 + D.31560;
      D.31537 = assembly->text_rva;
      D.31545 = assembly->imp_names_offset;
      value = D.31537 + D.31545;
      p.224 = p;
      p = p.224 + 1;
      D.31562 = (unsigned char) value;
      *p.224 = D.31562;
      p.225 = p;
      p = p.225 + 1;
      D.31564 = value >> 8;
      D.31565 = (unsigned char) D.31564;
      *p.225 = D.31565;
      p.226 = p;
      p = p.226 + 1;
      D.31567 = value >> 16;
      D.31568 = (unsigned char) D.31567;
      *p.226 = D.31568;
      p.227 = p;
      p = p.227 + 1;
      D.31570 = value >> 24;
      D.31571 = (unsigned char) D.31570;
      *p.227 = D.31571;
      D.31544 = assembly->code.data;
      D.31538 = assembly->cli_header_offset;
      D.31572 = (sizetype) D.31538;
      cli_header = D.31544 + D.31572;
      cli_header->ch_size = 72;
      cli_header->ch_runtime_major = 2;
      cli_header->ch_runtime_minor = 5;
      D.31480 = assemblyb->pe_kind;
      D.31481 = (unsigned int) D.31480;
      cli_header->ch_flags = D.31481;
      D.31573 = assemblyb->entry_point;
      if (D.31573 != 0B) goto <D.31574>; else goto <D.31575>;
      <D.31574>:
      {
        guint32 table_idx;

        table_idx = 0;
        {
          size_t __s1_len;
          size_t __s2_len;

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

            D.31573 = assemblyb->entry_point;
            D.31579 = D.31573->object.vtable;
            D.31580 = D.31579->klass;
            __s2 = D.31580->name;
            D.31581 = "MethodBuilder";
            D.31582 = MEM[(const unsigned char *)D.31581];
            D.31583 = (int) D.31582;
            D.31584 = *__s2;
            D.31585 = (int) D.31584;
            __result = D.31583 - D.31585;
            {
              D.31586 = __s2_len != 0;
              D.31587 = __result == 0;
              D.31588 = D.31586 & D.31587;
              if (D.31588 != 0) goto <D.31589>; else goto <D.31590>;
              <D.31589>:
              D.31591 = &MEM[(void *)"MethodBuilder" + 1B];
              D.31592 = *D.31591;
              D.31593 = (int) D.31592;
              D.31594 = __s2 + 1;
              D.31595 = *D.31594;
              D.31596 = (int) D.31595;
              __result = D.31593 - D.31596;
              D.31597 = __s2_len > 1;
              D.31587 = __result == 0;
              D.31598 = D.31597 & D.31587;
              if (D.31598 != 0) goto <D.31599>; else goto <D.31600>;
              <D.31599>:
              D.31601 = &MEM[(void *)"MethodBuilder" + 2B];
              D.31602 = *D.31601;
              D.31603 = (int) D.31602;
              D.31604 = __s2 + 2;
              D.31605 = *D.31604;
              D.31606 = (int) D.31605;
              __result = D.31603 - D.31606;
              D.31607 = __s2_len > 2;
              D.31587 = __result == 0;
              D.31608 = D.31607 & D.31587;
              if (D.31608 != 0) goto <D.31609>; else goto <D.31610>;
              <D.31609>:
              D.31611 = &MEM[(void *)"MethodBuilder" + 3B];
              D.31612 = *D.31611;
              D.31613 = (int) D.31612;
              D.31614 = __s2 + 3;
              D.31615 = *D.31614;
              D.31616 = (int) D.31615;
              __result = D.31613 - D.31616;
              <D.31610>:
              <D.31600>:
              <D.31590>:
            }
            D.20933 = __result;
          }
          iftmp.228 = -D.20933;
          goto <D.31617>;
          <D.31578>:
          D.31573 = assemblyb->entry_point;
          D.31579 = D.31573->object.vtable;
          D.31580 = D.31579->klass;
          D.31618 = D.31580->name;
          iftmp.228 = __builtin_strcmp (D.31618, "MethodBuilder");
          <D.31617>:
          D.20934 = iftmp.228;
        }
        if (D.20934 == 0) goto <D.31619>; else goto <D.31620>;
        <D.31619>:
        {
          struct MonoReflectionMethodBuilder * methodb;

          methodb = assemblyb->entry_point;
          table_idx = methodb->table_idx;
        }
        goto <D.31621>;
        <D.31620>:
        D.31573 = assemblyb->entry_point;
        D.31622 = D.31573->method;
        D.31623 = assembly->method_to_table_idx;
        D.31624 = monoeg_g_hash_table_lookup (D.31623, D.31622);
        D.31625 = (long int) D.31624;
        table_idx = (guint32) D.31625;
        <D.31621>:
        D.31626 = table_idx | 100663296;
        cli_header->ch_entry_point = D.31626;
      }
      goto <D.31627>;
      <D.31575>:
      cli_header->ch_entry_point = 0;
      <D.31627>:
      D.31537 = assembly->text_rva;
      D.31628 = assembly->code.index;
      text_offset = D.31537 + D.31628;
      cli_header->ch_resources.rva = text_offset;
      D.31629 = assembly->resources.index;
      cli_header->ch_resources.size = D.31629;
      D.31629 = assembly->resources.index;
      text_offset = D.31629 + text_offset;
      cli_header->ch_metadata.rva = text_offset;
      D.31630 = assembly->meta_size;
      cli_header->ch_metadata.size = D.31630;
      D.31630 = assembly->meta_size;
      text_offset = D.31630 + text_offset;
      D.31631 = assembly->strong_name_size;
      if (D.31631 != 0) goto <D.31632>; else goto <D.31633>;
      <D.31632>:
      cli_header->ch_strong_name.rva = text_offset;
      D.31631 = assembly->strong_name_size;
      cli_header->ch_strong_name.size = D.31631;
      D.31631 = assembly->strong_name_size;
      text_offset = D.31631 + text_offset;
      <D.31633>:
      D.31513 = pefile->data;
      D.31634 = (sizetype) section_start;
      section = D.31513 + D.31634;
      i = 0;
      goto <D.20939>;
      <D.20938>:
      {
        static const char section_names[3][7] = {".text", ".rsrc", ".reloc"};

        D.31507 = assembly->sections[i].size;
        if (D.31507 == 0) goto <D.31635>; else goto <D.31636>;
        <D.31635>:
        // predicted unlikely by continue predictor.
        goto <D.20937>;
        <D.31636>:
        D.31637 = &section_names[i];
        D.31638 = &section->st_name;
        strcpy (D.31638, D.31637);
        D.31639 = assembly->sections[i].rva;
        section->st_virtual_address = D.31639;
        D.31507 = assembly->sections[i].size;
        section->st_virtual_size = D.31507;
        D.31640 = section->st_virtual_size;
        D.31641 = D.31640 + 511;
        section->st_raw_data_size = D.31641;
        D.31642 = section->st_raw_data_size;
        D.31643 = D.31642 & 4294966784;
        section->st_raw_data_size = D.31643;
        D.31644 = assembly->sections[i].offset;
        section->st_raw_data_ptr = D.31644;
        D.31645 = assembly->sections[i].attrs;
        section->st_flags = D.31645;
        section = section + 40;
      }
      <D.20937>:
      i = i + 1;
      <D.20939>:
      if (i <= 2) goto <D.20938>; else goto <D.20940>;
      <D.20940>:
      D.31646 = pefile->index;
      D.31513 = pefile->data;
      checked_write_file (file, D.31513, D.31646);
      mono_dynamic_stream_reset (pefile);
      i = 0;
      goto <D.20955>;
      <D.20954>:
      D.31507 = assembly->sections[i].size;
      if (D.31507 == 0) goto <D.31647>; else goto <D.31648>;
      <D.31647>:
      // predicted unlikely by continue predictor.
      goto <D.20941>;
      <D.31648>:
      D.31644 = assembly->sections[i].offset;
      D.31649 = (int) D.31644;
      D.31650 = SetFilePointer (file, D.31649, 0B, 0);
      if (D.31650 == 4294967295) goto <D.31651>; else goto <D.31652>;
      <D.31651>:
      D.31653 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.31653);
      <D.20942>:
      goto <D.20942>;
      <D.31652>:
      switch (i) <default: <D.20953>, case 0: <D.20943>, case 1: <D.20952>, case 2: <D.20945>>
      <D.20943>:
      D.31544 = assembly->code.data;
      p = D.31544 + 2;
      D.31537 = assembly->text_rva;
      D.31654 = D.31537 + virtual_base;
      D.31540 = assembly->iat_offset;
      value = D.31654 + D.31540;
      p.229 = p;
      p = p.229 + 1;
      D.31562 = (unsigned char) value;
      *p.229 = D.31562;
      p.230 = p;
      p = p.230 + 1;
      D.31564 = value >> 8;
      D.31565 = (unsigned char) D.31564;
      *p.230 = D.31565;
      p.231 = p;
      p = p.231 + 1;
      D.31567 = value >> 16;
      D.31568 = (unsigned char) D.31567;
      *p.231 = D.31568;
      p.232 = p;
      p = p.232 + 1;
      D.31570 = value >> 24;
      D.31571 = (unsigned char) D.31570;
      *p.232 = D.31571;
      D.31628 = assembly->code.index;
      D.31544 = assembly->code.data;
      checked_write_file (file, D.31544, D.31628);
      D.31629 = assembly->resources.index;
      D.31659 = assembly->resources.data;
      checked_write_file (file, D.31659, D.31629);
      D.31630 = assembly->meta_size;
      D.31660 = assembly->image.raw_metadata;
      checked_write_file (file, D.31660, D.31630);
      D.31631 = assembly->strong_name_size;
      D.31661 = assembly->strong_name;
      checked_write_file (file, D.31661, D.31631);
      D.31660 = assembly->image.raw_metadata;
      monoeg_g_free (D.31660);
      goto <D.20944>;
      <D.20945>:
      {
        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.31662>; else goto <D.31663>;
            <D.31662>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5935, "sizeof (reloc) == 12");
            <D.31663>:
            D.31537 = assembly->text_rva;
            reloc.page_rva = D.31537;
            reloc.block_size = 12;
            reloc.type_and_offset = 12290;
            reloc.term = 0;
            checked_write_file (file, &reloc, 12);
            goto <D.20944>;
          }
        finally
          {
            reloc = {CLOBBER};
          }
      }
      <D.20952>:
      D.31664 = assembly->win32_res;
      if (D.31664 != 0B) goto <D.31665>; else goto <D.31666>;
      <D.31665>:
      D.31639 = assembly->sections[i].rva;
      D.31664 = assembly->win32_res;
      D.31664 = assembly->win32_res;
      fixup_resource_directory (D.31664, D.31664, D.31639);
      D.31667 = assembly->win32_res_size;
      D.31664 = assembly->win32_res;
      checked_write_file (file, D.31664, D.31667);
      <D.31666>:
      goto <D.20944>;
      <D.20953>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 5961);
      <D.20944>:
      <D.20941>:
      i = i + 1;
      <D.20955>:
      if (i <= 2) goto <D.20954>; else goto <D.20956>;
      <D.20956>:
      file_offset.233 = (int) file_offset;
      D.31669 = SetFilePointer (file, file_offset.233, 0B, 0);
      if (D.31669 == 4294967295) goto <D.31670>; else goto <D.31671>;
      <D.31670>:
      D.31672 = GetLastError ();
      monoeg_g_log (0B, 4, "SetFilePointer returned %d\n", D.31672);
      <D.20957>:
      goto <D.20957>;
      <D.31671>:
      D.31673 = SetEndOfFile (file);
      if (D.31673 == 0) goto <D.31674>; else goto <D.31675>;
      <D.31674>:
      D.31676 = GetLastError ();
      monoeg_g_log (0B, 4, "SetEndOfFile returned %d\n", D.31676);
      <D.20958>:
      goto <D.20958>;
      <D.31675>:
      D.31677 = &assembly->code;
      mono_dynamic_stream_reset (D.31677);
      D.31678 = &assembly->us;
      mono_dynamic_stream_reset (D.31678);
      D.31679 = &assembly->blob;
      mono_dynamic_stream_reset (D.31679);
      D.31680 = &assembly->guid;
      mono_dynamic_stream_reset (D.31680);
      D.31681 = &assembly->sheap;
      mono_dynamic_stream_reset (D.31681);
      D.31682 = assembly->blob_cache;
      monoeg_g_hash_table_foreach (D.31682, monoeg_g_free, 0B);
      D.31682 = assembly->blob_cache;
      monoeg_g_hash_table_destroy (D.31682);
      assembly->blob_cache = 0B;
    }
  finally
    {
      pefile_stream = {CLOBBER};
    }
}


assembly_add_resource (struct MonoReflectionModuleBuilder * mb, struct MonoDynamicImage * assembly, struct MonoReflectionResource * rsrc)
{
  struct MonoString * D.31685;
  unsigned int D.31688;
  unsigned int D.31689;
  guint32 * D.31690;
  unsigned int D.31691;
  unsigned int D.31692;
  long unsigned int D.31693;
  long unsigned int D.31694;
  guint32 * D.31695;
  struct MonoDynamicStream * D.31696;
  unsigned int D.31697;
  char * b.234;
  guint32 * D.31699;
  long int b.235;
  long int blob_size.236;
  long int D.31702;
  unsigned int D.31703;
  struct MonoDynamicStream * D.31704;
  unsigned int D.31705;
  unsigned int idx.237;
  unsigned int D.31707;
  struct MonoArray * D.31709;
  long unsigned int D.31712;
  char D.31714;
  unsigned int D.31715;
  char D.31716;
  unsigned int D.31717;
  char D.31718;
  unsigned int D.31719;
  char D.31720;
  struct MonoDynamicStream * D.31721;
  unsigned int D.31722;
  int D.31723;
  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.31685 = rsrc->filename;
      if (D.31685 != 0B) goto <D.31686>; else goto <D.31687>;
      <D.31686>:
      D.31685 = rsrc->filename;
      name = mono_string_to_utf8 (D.31685);
      sname = monoeg_g_path_get_basename (name);
      table = &assembly->tables[38];
      D.31688 = table->rows;
      D.31689 = D.31688 + 1;
      table->rows = D.31689;
      D.31688 = table->rows;
      alloc_table (table, D.31688);
      D.31690 = table->values;
      D.31691 = table->next_idx;
      D.31692 = D.31691 * 3;
      D.31693 = (long unsigned int) D.31692;
      D.31694 = D.31693 * 4;
      values = D.31690 + D.31694;
      *values = 1;
      D.31695 = values + 4;
      D.31696 = &assembly->sheap;
      D.31697 = string_heap_insert (D.31696, sname);
      *D.31695 = D.31697;
      monoeg_g_free (sname);
      mono_sha1_get_digest_from_file (name, &hash);
      b.234 = b;
      mono_metadata_encode_value (20, b.234, &b);
      D.31699 = values + 8;
      b.234 = b;
      b.235 = (long int) b.234;
      blob_size.236 = (long int) &blob_size;
      D.31702 = b.235 - blob_size.236;
      D.31703 = (unsigned int) D.31702;
      D.31704 = &assembly->blob;
      D.31705 = mono_image_add_stream_data (D.31704, &blob_size, D.31703);
      *D.31699 = D.31705;
      D.31704 = &assembly->blob;
      mono_image_add_stream_data (D.31704, &hash, 20);
      monoeg_g_free (name);
      D.31691 = table->next_idx;
      idx.237 = D.31691;
      D.31707 = idx.237 + 1;
      table->next_idx = D.31707;
      idx = idx.237;
      rsrc->offset = 0;
      idx = idx << 2;
      goto <D.31708>;
      <D.31687>:
      {
        char sizebuf[4];
        char * data;
        guint len;

        try
          {
            D.31709 = rsrc->data;
            if (D.31709 != 0B) goto <D.31710>; else goto <D.31711>;
            <D.31710>:
            D.31709 = rsrc->data;
            data = mono_array_addr_with_size (D.31709, 1, 0);
            D.31709 = rsrc->data;
            D.31712 = mono_array_length (D.31709);
            len = (guint) D.31712;
            goto <D.31713>;
            <D.31711>:
            data = 0B;
            len = 0;
            <D.31713>:
            offset = len;
            D.31714 = (char) offset;
            sizebuf[0] = D.31714;
            D.31715 = offset >> 8;
            D.31716 = (char) D.31715;
            sizebuf[1] = D.31716;
            D.31717 = offset >> 16;
            D.31718 = (char) D.31717;
            sizebuf[2] = D.31718;
            D.31719 = offset >> 24;
            D.31720 = (char) D.31719;
            sizebuf[3] = D.31720;
            D.31721 = &assembly->resources;
            D.31722 = mono_image_add_stream_data (D.31721, &sizebuf, 4);
            rsrc->offset = D.31722;
            D.31721 = &assembly->resources;
            mono_image_add_stream_data (D.31721, data, len);
            D.31723 = mb->is_main;
            if (D.31723 == 0) goto <D.31724>; else goto <D.31725>;
            <D.31724>:
            return;
            <D.31725>:
            idx = 0;
          }
        finally
          {
            sizebuf = {CLOBBER};
          }
      }
      <D.31708>:
      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.31731;
  unsigned int D.31732;
  long unsigned int D.31733;
  void * * D.31734;
  long unsigned int D.31735;
  long unsigned int D.31736;
  void * * D.31737;
  unsigned int i.238;
  struct MonoDynamicStream * D.31739;
  struct MonoDynamicStream * D.31740;
  struct MonoDynamicStream * D.31741;
  struct MonoDynamicStream * D.31742;
  struct MonoDynamicStream * D.31743;
  unsigned int D.31744;
  _Bool D.31745;
  unsigned int D.31746;
  _Bool D.31747;
  unsigned int D.31748;
  _Bool D.31749;
  unsigned int D.31750;
  unsigned int D.31751;
  <unnamed-unsigned:24> D.31752;
  <unnamed-unsigned:24> D.31753;
  long unsigned int D.31756;
  guint32 * D.31757;
  int D.31758;
  unsigned char D.31759;
  unsigned char D.31760;
  int D.31761;
  int D.31762;
  int D.31763;
  unsigned int D.31764;
  unsigned int D.31765;
  long unsigned int D.31766;
  void * D.31767;
  unsigned char * p.239;
  unsigned char * p.240;
  unsigned char * p.241;
  unsigned char * p.242;
  guint16 * int16val.243;
  short int D.31773;
  short unsigned int D.31774;
  short int D.31775;
  short unsigned int D.31776;
  char * D.31777;
  long unsigned int D.31778;
  unsigned int D.31779;
  unsigned int D.31780;
  unsigned int D.31781;
  long unsigned int D.31782;
  unsigned int D.31783;
  sizetype D.31784;
  long int p.244;
  char * D.31786;
  long int D.31787;
  long int D.31788;
  unsigned int D.31789;
  unsigned int D.31792;
  sizetype D.31793;
  guint16 * int16val.245;
  unsigned int D.31795;
  struct MonoDynamicStream * D.31796;
  guint32 * int32val.246;
  unsigned int D.31798;
  const char * D.31799;
  long unsigned int D.31800;
  sizetype D.31801;
  unsigned int D.31802;
  unsigned int D.31805;
  sizetype D.31806;
  unsigned int D.31807;
  long int D.31808;
  _Bool D.31809;
  long int D.31810;
  long int D.31811;
  sizetype D.31814;
  unsigned char * p.247;
  unsigned char * p.248;
  unsigned char D.31817;
  unsigned char D.31818;
  unsigned char D.31821;
  unsigned char D.31822;
  unsigned char D.31823;
  unsigned char D.31826;
  unsigned char D.31827;
  unsigned char D.31830;
  unsigned char * p.249;
  guint64 * int64val.250;
  guint64 * int64val.251;
  long unsigned int D.31834;
  guint32 * int32val.252;
  unsigned int D.31838;
  unsigned int D.31839;
  long unsigned int D.31842;
  guint32 * D.31843;
  void * D.31844;
  void * D.31847;
  void * D.31852;
  unsigned char D.31861;
  unsigned int D.31862;
  unsigned int D.31863;
  int D.31866;
  guint32 * D.31867;
  int D.31868;
  long unsigned int D.31869;
  long unsigned int D.31870;
  int D.31871;
  unsigned int D.31872;
  unsigned int D.31873;
  unsigned int D.31874;
  unsigned char * p.253;
  long unsigned int D.31876;
  long unsigned int D.31877;
  guint32 * D.31878;
  unsigned int D.31879;
  unsigned char D.31880;
  unsigned char * p.254;
  unsigned char * p.255;
  unsigned int D.31883;
  unsigned char D.31884;
  unsigned char * p.256;
  unsigned char * p.257;
  unsigned char * p.258;
  unsigned int D.31888;
  unsigned char D.31889;
  unsigned char * p.259;
  unsigned int D.31891;
  unsigned char D.31892;
  const char * D.31893;
  long int D.31894;
  long int D.31895;
  long int D.31896;
  _Bool D.31897;
  long int D.31898;
  long int D.31899;
  unsigned int D.31902;
  unsigned int D.31903;
  _Bool D.31904;
  long int D.31905;
  long int D.31906;
  long unsigned int D.31909;
  char * D.31910;
  unsigned int D.31911;
  sizetype D.31912;
  char * D.31913;
  long unsigned int D.31914;
  char * D.31915;
  unsigned int D.31916;
  sizetype D.31917;
  char * D.31918;
  long unsigned int D.31919;
  char * D.31920;
  unsigned int D.31921;
  sizetype D.31922;
  char * D.31923;
  long unsigned int D.31924;
  char * D.31925;
  sizetype D.31926;
  char * D.31927;
  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.31731 = assembly->gen_params;
      D.31732 = D.31731->len;
      D.31733 = (long unsigned int) D.31732;
      D.31731 = assembly->gen_params;
      D.31734 = D.31731->pdata;
      qsort (D.31734, D.31733, 8, compare_genericparam);
      i = 0;
      goto <D.20007>;
      <D.20006>:
      {
        struct GenericParamTableEntry * entry;

        D.31731 = assembly->gen_params;
        D.31734 = D.31731->pdata;
        D.31735 = (long unsigned int) i;
        D.31736 = D.31735 * 8;
        D.31737 = D.31734 + D.31736;
        entry = *D.31737;
        write_generic_param_entry (assembly, entry);
      }
      i = i + 1;
      <D.20007>:
      i.238 = (unsigned int) i;
      D.31731 = assembly->gen_params;
      D.31732 = D.31731->len;
      if (i.238 < D.31732) goto <D.20006>; else goto <D.20008>;
      <D.20008>:
      stream_desc[0].name = "#~";
      D.31739 = &assembly->tstream;
      stream_desc[0].stream = D.31739;
      stream_desc[1].name = "#Strings";
      D.31740 = &assembly->sheap;
      stream_desc[1].stream = D.31740;
      stream_desc[2].name = "#US";
      D.31741 = &assembly->us;
      stream_desc[2].stream = D.31741;
      stream_desc[3].name = "#Blob";
      D.31742 = &assembly->blob;
      stream_desc[3].stream = D.31742;
      stream_desc[4].name = "#GUID";
      D.31743 = &assembly->guid;
      stream_desc[4].stream = D.31743;
      sorted_mask = 6597925534208;
      meta = &assembly->image;
      D.31742 = &assembly->blob;
      pad_heap (D.31742);
      D.31743 = &assembly->guid;
      pad_heap (D.31743);
      D.31740 = &assembly->sheap;
      pad_heap (D.31740);
      D.31741 = &assembly->us;
      pad_heap (D.31741);
      D.31744 = assembly->blob.index;
      D.31745 = D.31744 > 65535;
      meta->idx_blob_wide = D.31745;
      D.31746 = assembly->guid.index;
      D.31747 = D.31746 > 65535;
      meta->idx_guid_wide = D.31747;
      D.31748 = assembly->sheap.index;
      D.31749 = D.31748 > 65535;
      meta->idx_string_wide = D.31749;
      D.31744 = assembly->blob.index;
      meta_size = D.31744 + meta_size;
      D.31746 = assembly->guid.index;
      meta_size = D.31746 + meta_size;
      D.31748 = assembly->sheap.index;
      meta_size = D.31748 + meta_size;
      D.31750 = assembly->us.index;
      meta_size = D.31750 + meta_size;
      i = 0;
      goto <D.20010>;
      <D.20009>:
      D.31751 = assembly->tables[i].rows;
      D.31752 = (<unnamed-unsigned:24>) D.31751;
      meta->tables[i].rows = D.31752;
      i = i + 1;
      <D.20010>:
      if (i <= 44) goto <D.20009>; else goto <D.20011>;
      <D.20011>:
      i = 0;
      goto <D.20014>;
      <D.20013>:
      D.31753 = meta->tables[i].rows;
      if (D.31753 == 0) goto <D.31754>; else goto <D.31755>;
      <D.31754>:
      // predicted unlikely by continue predictor.
      goto <D.20012>;
      <D.31755>:
      D.31756 = 1 << i;
      valid_mask = D.31756 | valid_mask;
      ntables = ntables + 1;
      D.31757 = &meta->tables[i].size_bitfield;
      D.31758 = mono_metadata_compute_size (meta, i, D.31757);
      D.31759 = (unsigned char) D.31758;
      meta->tables[i].row_size = D.31759;
      D.31760 = meta->tables[i].row_size;
      D.31761 = (int) D.31760;
      D.31753 = meta->tables[i].rows;
      D.31762 = (int) D.31753;
      D.31763 = D.31761 * D.31762;
      D.31764 = (unsigned int) D.31763;
      heapt_size = D.31764 + heapt_size;
      <D.20012>:
      i = i + 1;
      <D.20014>:
      if (i <= 44) goto <D.20013>; else goto <D.20015>;
      <D.20015>:
      heapt_size = heapt_size + 24;
      D.31765 = ntables * 4;
      heapt_size = D.31765 + heapt_size;
      heapt_size = heapt_size + 3;
      heapt_size = heapt_size & 4294967292;
      meta_size = meta_size + heapt_size;
      D.31766 = (long unsigned int) meta_size;
      D.31767 = monoeg_malloc0 (D.31766);
      meta->raw_metadata = D.31767;
      p = meta->raw_metadata;
      p.239 = p;
      p = p.239 + 1;
      *p.239 = 66;
      p.240 = p;
      p = p.240 + 1;
      *p.240 = 83;
      p.241 = p;
      p = p.241 + 1;
      *p.241 = 74;
      p.242 = p;
      p = p.242 + 1;
      *p.242 = 66;
      int16val = p;
      int16val.243 = int16val;
      int16val = int16val.243 + 2;
      D.31773 = meta->md_version_major;
      D.31774 = (short unsigned int) D.31773;
      *int16val.243 = D.31774;
      D.31775 = meta->md_version_minor;
      D.31776 = (short unsigned int) D.31775;
      *int16val = D.31776;
      p = p + 8;
      int32val = p;
      D.31777 = meta->version;
      D.31778 = strlen (D.31777);
      D.31779 = (unsigned int) D.31778;
      D.31780 = D.31779 + 3;
      D.31781 = D.31780 & 4294967292;
      *int32val = D.31781;
      p = p + 4;
      D.31777 = meta->version;
      D.31782 = strlen (D.31777);
      D.31777 = meta->version;
      memcpy (p, D.31777, D.31782);
      D.31783 = *int32val;
      D.31784 = (sizetype) D.31783;
      p = p + D.31784;
      {
        guint32 __diff;

        p.244 = (long int) p;
        D.31786 = meta->raw_metadata;
        D.31787 = (long int) D.31786;
        D.31788 = p.244 - D.31787;
        __diff = (guint32) D.31788;
        D.31789 = __diff & 3;
        if (D.31789 != 0) goto <D.31790>; else goto <D.31791>;
        <D.31790>:
        D.31789 = __diff & 3;
        D.31792 = 4 - D.31789;
        D.31793 = (sizetype) D.31792;
        p = p + D.31793;
        <D.31791>:
      }
      int16val = p;
      int16val.245 = int16val;
      int16val = int16val.245 + 2;
      *int16val.245 = 0;
      *int16val = 5;
      p = p + 4;
      p.244 = (long int) p;
      D.31786 = meta->raw_metadata;
      D.31787 = (long int) D.31786;
      D.31788 = p.244 - D.31787;
      D.31795 = (unsigned int) D.31788;
      table_offset = D.31795 + 80;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      assembly->tstream.index = heapt_size;
      i = 0;
      goto <D.20019>;
      <D.20018>:
      int32val = p;
      D.31796 = stream_desc[i].stream;
      D.31796->offset = table_offset;
      int32val.246 = int32val;
      int32val = int32val.246 + 4;
      *int32val.246 = table_offset;
      D.31796 = stream_desc[i].stream;
      D.31798 = D.31796->index;
      *int32val = D.31798;
      D.31783 = *int32val;
      table_offset = D.31783 + table_offset;
      table_offset = table_offset + 3;
      table_offset = table_offset & 4294967292;
      p = p + 8;
      D.31799 = stream_desc[i].name;
      strcpy (p, D.31799);
      D.31799 = stream_desc[i].name;
      D.31800 = strlen (D.31799);
      D.31801 = D.31800 + 1;
      p = p + D.31801;
      {
        guint32 __diff;

        p.244 = (long int) p;
        D.31786 = meta->raw_metadata;
        D.31787 = (long int) D.31786;
        D.31788 = p.244 - D.31787;
        __diff = (guint32) D.31788;
        D.31802 = __diff & 3;
        if (D.31802 != 0) goto <D.31803>; else goto <D.31804>;
        <D.31803>:
        D.31802 = __diff & 3;
        D.31805 = 4 - D.31802;
        D.31806 = (sizetype) D.31805;
        p = p + D.31806;
        <D.31804>:
      }
      i = i + 1;
      <D.20019>:
      if (i <= 4) goto <D.20018>; else goto <D.20020>;
      <D.20020>:
      p.244 = (long int) p;
      D.31786 = meta->raw_metadata;
      D.31787 = (long int) D.31786;
      D.31788 = p.244 - D.31787;
      D.31807 = assembly->tstream.offset;
      D.31808 = (long int) D.31807;
      D.31809 = D.31788 >= D.31808;
      D.31810 = (long int) D.31809;
      D.31811 = __builtin_expect (D.31810, 0);
      if (D.31811 != 0) goto <D.31812>; else goto <D.31813>;
      <D.31812>:
      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.31813>:
      D.31786 = meta->raw_metadata;
      D.31807 = assembly->tstream.offset;
      D.31814 = (sizetype) D.31807;
      p = D.31786 + D.31814;
      int32val = p;
      *int32val = 0;
      p = p + 4;
      p.247 = p;
      p = p.247 + 1;
      *p.247 = 2;
      p.248 = p;
      p = p.248 + 1;
      *p.248 = 0;
      D.31817 = BIT_FIELD_REF <*meta, 8, 232>;
      D.31818 = D.31817 & 1;
      if (D.31818 != 0) goto <D.31819>; else goto <D.31820>;
      <D.31819>:
      D.31821 = *p;
      D.31822 = D.31821 | 1;
      *p = D.31822;
      <D.31820>:
      D.31817 = BIT_FIELD_REF <*meta, 8, 232>;
      D.31823 = D.31817 & 2;
      if (D.31823 != 0) goto <D.31824>; else goto <D.31825>;
      <D.31824>:
      D.31821 = *p;
      D.31826 = D.31821 | 2;
      *p = D.31826;
      <D.31825>:
      D.31817 = BIT_FIELD_REF <*meta, 8, 232>;
      D.31827 = D.31817 & 4;
      if (D.31827 != 0) goto <D.31828>; else goto <D.31829>;
      <D.31828>:
      D.31821 = *p;
      D.31830 = D.31821 | 4;
      *p = D.31830;
      <D.31829>:
      p = p + 1;
      p.249 = p;
      p = p.249 + 1;
      *p.249 = 1;
      int64val = p;
      int64val.250 = int64val;
      int64val = int64val.250 + 8;
      *int64val.250 = valid_mask;
      int64val.251 = int64val;
      int64val = int64val.251 + 8;
      D.31834 = valid_mask & sorted_mask;
      *int64val.251 = D.31834;
      p = p + 16;
      int32val = p;
      i = 0;
      goto <D.20023>;
      <D.20022>:
      D.31753 = meta->tables[i].rows;
      if (D.31753 == 0) goto <D.31835>; else goto <D.31836>;
      <D.31835>:
      // predicted unlikely by continue predictor.
      goto <D.20021>;
      <D.31836>:
      int32val.252 = int32val;
      int32val = int32val.252 + 4;
      D.31753 = meta->tables[i].rows;
      D.31838 = (unsigned int) D.31753;
      *int32val.252 = D.31838;
      <D.20021>:
      i = i + 1;
      <D.20023>:
      if (i <= 44) goto <D.20022>; else goto <D.20024>;
      <D.20024>:
      p = int32val;
      table = &assembly->tables[11];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31840>; else goto <D.31841>;
      <D.31840>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31844 = D.31843 + 16;
      qsort (D.31844, D.31842, 16, compare_constants);
      <D.31841>:
      table = &assembly->tables[24];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31845>; else goto <D.31846>;
      <D.31845>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31847 = D.31843 + 12;
      qsort (D.31847, D.31842, 12, compare_semantics);
      <D.31846>:
      table = &assembly->tables[12];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31848>; else goto <D.31849>;
      <D.31848>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31847 = D.31843 + 12;
      qsort (D.31847, D.31842, 12, compare_custom_attrs);
      <D.31849>:
      table = &assembly->tables[13];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31850>; else goto <D.31851>;
      <D.31850>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31852 = D.31843 + 8;
      qsort (D.31852, D.31842, 8, compare_field_marshal);
      <D.31851>:
      table = &assembly->tables[41];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31853>; else goto <D.31854>;
      <D.31853>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31852 = D.31843 + 8;
      qsort (D.31852, D.31842, 8, compare_nested);
      <D.31854>:
      table = &assembly->tables[14];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31855>; else goto <D.31856>;
      <D.31855>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31847 = D.31843 + 12;
      qsort (D.31847, D.31842, 12, compare_declsecurity_attrs);
      <D.31856>:
      table = &assembly->tables[9];
      D.31839 = table->rows;
      if (D.31839 != 0) goto <D.31857>; else goto <D.31858>;
      <D.31857>:
      D.31839 = table->rows;
      D.31842 = (long unsigned int) D.31839;
      D.31843 = table->values;
      D.31852 = D.31843 + 8;
      qsort (D.31852, D.31842, 8, compare_interface_impl);
      <D.31858>:
      i = 0;
      goto <D.20043>;
      <D.20042>:
      {
        int row;
        int col;
        guint32 * values;
        guint32 bitfield;

        bitfield = meta->tables[i].size_bitfield;
        D.31753 = meta->tables[i].rows;
        if (D.31753 == 0) goto <D.31859>; else goto <D.31860>;
        <D.31859>:
        // predicted unlikely by continue predictor.
        goto <D.20029>;
        <D.31860>:
        D.31861 = assembly->tables[i].columns;
        D.31862 = (unsigned int) D.31861;
        D.31863 = bitfield >> 24;
        if (D.31862 != D.31863) goto <D.31864>; else goto <D.31865>;
        <D.31864>:
        D.31863 = bitfield >> 24;
        D.31861 = assembly->tables[i].columns;
        D.31866 = (int) D.31861;
        monoeg_g_log (0B, 4, "col count mismatch in %d: %d %d", i, D.31866, D.31863);
        <D.20030>:
        goto <D.20030>;
        <D.31865>:
        meta->tables[i].base = p;
        row = 1;
        goto <D.20040>;
        <D.20039>:
        D.31867 = assembly->tables[i].values;
        D.31861 = assembly->tables[i].columns;
        D.31866 = (int) D.31861;
        D.31868 = D.31866 * row;
        D.31869 = (long unsigned int) D.31868;
        D.31870 = D.31869 * 4;
        values = D.31867 + D.31870;
        col = 0;
        goto <D.20037>;
        <D.20036>:
        D.31871 = col * 2;
        D.31872 = bitfield >> D.31871;
        D.31873 = D.31872 & 3;
        D.31874 = D.31873 + 1;
        switch (D.31874) <default: <D.20035>, case 1: <D.20031>, case 2: <D.20033>, case 4: <D.20034>>
        <D.20031>:
        p.253 = p;
        p = p.253 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31880 = (unsigned char) D.31879;
        *p.253 = D.31880;
        goto <D.20032>;
        <D.20033>:
        p.254 = p;
        p = p.254 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31880 = (unsigned char) D.31879;
        *p.254 = D.31880;
        p.255 = p;
        p = p.255 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31883 = D.31879 >> 8;
        D.31884 = (unsigned char) D.31883;
        *p.255 = D.31884;
        goto <D.20032>;
        <D.20034>:
        p.256 = p;
        p = p.256 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31880 = (unsigned char) D.31879;
        *p.256 = D.31880;
        p.257 = p;
        p = p.257 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31883 = D.31879 >> 8;
        D.31884 = (unsigned char) D.31883;
        *p.257 = D.31884;
        p.258 = p;
        p = p.258 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31888 = D.31879 >> 16;
        D.31889 = (unsigned char) D.31888;
        *p.258 = D.31889;
        p.259 = p;
        p = p.259 + 1;
        D.31876 = (long unsigned int) col;
        D.31877 = D.31876 * 4;
        D.31878 = values + D.31877;
        D.31879 = *D.31878;
        D.31891 = D.31879 >> 24;
        D.31892 = (unsigned char) D.31891;
        *p.259 = D.31892;
        goto <D.20032>;
        <D.20035>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 4187);
        <D.20032>:
        col = col + 1;
        <D.20037>:
        D.31861 = assembly->tables[i].columns;
        D.31866 = (int) D.31861;
        if (D.31866 > col) goto <D.20036>; else goto <D.20038>;
        <D.20038>:
        row = row + 1;
        <D.20040>:
        D.31753 = meta->tables[i].rows;
        D.31762 = (int) D.31753;
        if (D.31762 >= row) goto <D.20039>; else goto <D.20041>;
        <D.20041>:
        p.244 = (long int) p;
        D.31893 = meta->tables[i].base;
        D.31894 = (long int) D.31893;
        D.31895 = p.244 - D.31894;
        D.31753 = meta->tables[i].rows;
        D.31762 = (int) D.31753;
        D.31760 = meta->tables[i].row_size;
        D.31761 = (int) D.31760;
        D.31763 = D.31762 * D.31761;
        D.31896 = (long int) D.31763;
        D.31897 = D.31895 != D.31896;
        D.31898 = (long int) D.31897;
        D.31899 = __builtin_expect (D.31898, 0);
        if (D.31899 != 0) goto <D.31900>; else goto <D.31901>;
        <D.31900>:
        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.31901>:
      }
      <D.20029>:
      i = i + 1;
      <D.20043>:
      if (i <= 44) goto <D.20042>; else goto <D.20044>;
      <D.20044>:
      D.31902 = assembly->guid.offset;
      D.31746 = assembly->guid.index;
      D.31903 = D.31902 + D.31746;
      D.31904 = D.31903 >= meta_size;
      D.31905 = (long int) D.31904;
      D.31906 = __builtin_expect (D.31905, 0);
      if (D.31906 != 0) goto <D.31907>; else goto <D.31908>;
      <D.31907>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 4194, "assembly->guid.offset + assembly->guid.index < meta_size");
      <D.31908>:
      D.31748 = assembly->sheap.index;
      D.31909 = (long unsigned int) D.31748;
      D.31910 = assembly->sheap.data;
      D.31786 = meta->raw_metadata;
      D.31911 = assembly->sheap.offset;
      D.31912 = (sizetype) D.31911;
      D.31913 = D.31786 + D.31912;
      memcpy (D.31913, D.31910, D.31909);
      D.31750 = assembly->us.index;
      D.31914 = (long unsigned int) D.31750;
      D.31915 = assembly->us.data;
      D.31786 = meta->raw_metadata;
      D.31916 = assembly->us.offset;
      D.31917 = (sizetype) D.31916;
      D.31918 = D.31786 + D.31917;
      memcpy (D.31918, D.31915, D.31914);
      D.31744 = assembly->blob.index;
      D.31919 = (long unsigned int) D.31744;
      D.31920 = assembly->blob.data;
      D.31786 = meta->raw_metadata;
      D.31921 = assembly->blob.offset;
      D.31922 = (sizetype) D.31921;
      D.31923 = D.31786 + D.31922;
      memcpy (D.31923, D.31920, D.31919);
      D.31746 = assembly->guid.index;
      D.31924 = (long unsigned int) D.31746;
      D.31925 = assembly->guid.data;
      D.31786 = meta->raw_metadata;
      D.31902 = assembly->guid.offset;
      D.31926 = (sizetype) D.31902;
      D.31927 = D.31786 + D.31926;
      memcpy (D.31927, D.31925, D.31924);
      D.31902 = assembly->guid.offset;
      D.31746 = assembly->guid.index;
      D.31903 = D.31902 + D.31746;
      assembly->meta_size = D.31903;
    }
  finally
    {
      stream_desc = {CLOBBER};
    }
}


compare_interface_impl (const void * a, const void * b)
{
  unsigned int D.31928;
  unsigned int D.31929;
  unsigned int D.31930;
  int D.31933;
  const guint32 * D.31934;
  unsigned int D.31935;
  const guint32 * D.31936;
  unsigned int D.31937;
  unsigned int D.31938;
  const guint32 * a_values;
  const guint32 * b_values;
  int klass;

  a_values = a;
  b_values = b;
  D.31928 = *a_values;
  D.31929 = *b_values;
  D.31930 = D.31928 - D.31929;
  klass = (int) D.31930;
  if (klass != 0) goto <D.31931>; else goto <D.31932>;
  <D.31931>:
  D.31933 = klass;
  return D.31933;
  <D.31932>:
  D.31934 = a_values + 4;
  D.31935 = *D.31934;
  D.31936 = b_values + 4;
  D.31937 = *D.31936;
  D.31938 = D.31935 - D.31937;
  D.31933 = (int) D.31938;
  return D.31933;
}


compare_declsecurity_attrs (const void * a, const void * b)
{
  int D.31940;
  const guint32 * D.31941;
  unsigned int D.31942;
  const guint32 * D.31943;
  unsigned int D.31944;
  unsigned int D.31945;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31941 = a_values + 4;
  D.31942 = *D.31941;
  D.31943 = b_values + 4;
  D.31944 = *D.31943;
  D.31945 = D.31942 - D.31944;
  D.31940 = (int) D.31945;
  return D.31940;
}


compare_nested (const void * a, const void * b)
{
  int D.31947;
  unsigned int D.31948;
  unsigned int D.31949;
  unsigned int D.31950;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31948 = *a_values;
  D.31949 = *b_values;
  D.31950 = D.31948 - D.31949;
  D.31947 = (int) D.31950;
  return D.31947;
}


compare_field_marshal (const void * a, const void * b)
{
  int D.31952;
  unsigned int D.31953;
  unsigned int D.31954;
  unsigned int D.31955;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31953 = *a_values;
  D.31954 = *b_values;
  D.31955 = D.31953 - D.31954;
  D.31952 = (int) D.31955;
  return D.31952;
}


compare_custom_attrs (const void * a, const void * b)
{
  int D.31957;
  unsigned int D.31958;
  unsigned int D.31959;
  unsigned int D.31960;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31958 = *a_values;
  D.31959 = *b_values;
  D.31960 = D.31958 - D.31959;
  D.31957 = (int) D.31960;
  return D.31957;
}


compare_semantics (const void * a, const void * b)
{
  const guint32 * D.31962;
  unsigned int D.31963;
  const guint32 * D.31964;
  unsigned int D.31965;
  unsigned int D.31966;
  int D.31969;
  unsigned int D.31970;
  unsigned int D.31971;
  unsigned int D.31972;
  const guint32 * a_values;
  const guint32 * b_values;
  int assoc;

  a_values = a;
  b_values = b;
  D.31962 = a_values + 8;
  D.31963 = *D.31962;
  D.31964 = b_values + 8;
  D.31965 = *D.31964;
  D.31966 = D.31963 - D.31965;
  assoc = (int) D.31966;
  if (assoc != 0) goto <D.31967>; else goto <D.31968>;
  <D.31967>:
  D.31969 = assoc;
  return D.31969;
  <D.31968>:
  D.31970 = *a_values;
  D.31971 = *b_values;
  D.31972 = D.31970 - D.31971;
  D.31969 = (int) D.31972;
  return D.31969;
}


compare_constants (const void * a, const void * b)
{
  int D.31974;
  const guint32 * D.31975;
  unsigned int D.31976;
  const guint32 * D.31977;
  unsigned int D.31978;
  unsigned int D.31979;
  const guint32 * a_values;
  const guint32 * b_values;

  a_values = a;
  b_values = b;
  D.31975 = a_values + 8;
  D.31976 = *D.31975;
  D.31977 = b_values + 8;
  D.31978 = *D.31977;
  D.31979 = D.31976 - D.31978;
  D.31974 = (int) D.31979;
  return D.31974;
}


compare_genericparam (const void * a, const void * b)
{
  const struct GenericParamTableEntry * D.31981;
  unsigned int D.31982;
  const struct GenericParamTableEntry * D.31983;
  unsigned int D.31984;
  int D.31987;
  struct MonoReflectionGenericParam * D.31988;
  struct MonoType * D.31989;
  struct MonoGenericParam * D.31990;
  short unsigned int D.31991;
  int D.31992;
  struct MonoReflectionGenericParam * D.31993;
  struct MonoType * D.31994;
  struct MonoGenericParam * D.31995;
  short unsigned int D.31996;
  int D.31997;
  unsigned int D.31998;
  const struct GenericParamTableEntry * * a_entry;
  const struct GenericParamTableEntry * * b_entry;

  a_entry = a;
  b_entry = b;
  D.31981 = *b_entry;
  D.31982 = D.31981->owner;
  D.31983 = *a_entry;
  D.31984 = D.31983->owner;
  if (D.31982 == D.31984) goto <D.31985>; else goto <D.31986>;
  <D.31985>:
  D.31983 = *a_entry;
  D.31988 = D.31983->gparam;
  D.31989 = mono_reflection_type_get_handle (D.31988);
  D.31990 = D.31989->data.generic_param;
  D.31991 = D.31990->num;
  D.31992 = (int) D.31991;
  D.31981 = *b_entry;
  D.31993 = D.31981->gparam;
  D.31994 = mono_reflection_type_get_handle (D.31993);
  D.31995 = D.31994->data.generic_param;
  D.31996 = D.31995->num;
  D.31997 = (int) D.31996;
  D.31987 = D.31992 - D.31997;
  return D.31987;
  <D.31986>:
  D.31983 = *a_entry;
  D.31984 = D.31983->owner;
  D.31981 = *b_entry;
  D.31982 = D.31981->owner;
  D.31998 = D.31984 - D.31982;
  D.31987 = (int) D.31998;
  return D.31987;
}


write_generic_param_entry (struct MonoDynamicImage * assembly, struct GenericParamTableEntry * entry)
{
  unsigned int D.32000;
  unsigned int table_idx.260;
  unsigned int D.32002;
  guint32 * D.32003;
  unsigned int D.32004;
  long unsigned int D.32005;
  long unsigned int D.32006;
  struct MonoReflectionGenericParam * D.32007;
  struct MonoType * D.32008;
  guint32 * D.32009;
  unsigned int D.32010;
  guint32 * D.32011;
  unsigned int D.32012;
  short unsigned int D.32013;
  unsigned int D.32014;
  guint32 * D.32015;
  struct MonoGenericParamInfo * iftmp.261;
  struct MonoGenericContainer * D.32017;
  const char * D.32021;
  struct MonoDynamicStream * D.32022;
  unsigned int D.32023;
  struct MonoArray * D.32024;
  struct MonoDynamicTable * table;
  struct MonoGenericParam * param;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[42];
  D.32000 = table->next_idx;
  table_idx.260 = D.32000;
  D.32002 = table_idx.260 + 1;
  table->next_idx = D.32002;
  table_idx = table_idx.260;
  D.32003 = table->values;
  D.32004 = table_idx * 4;
  D.32005 = (long unsigned int) D.32004;
  D.32006 = D.32005 * 4;
  values = D.32003 + D.32006;
  D.32007 = entry->gparam;
  D.32008 = mono_reflection_type_get_handle (D.32007);
  param = D.32008->data.generic_param;
  D.32009 = values + 8;
  D.32010 = entry->owner;
  *D.32009 = D.32010;
  D.32011 = values + 4;
  D.32007 = entry->gparam;
  D.32012 = D.32007->attrs;
  *D.32011 = D.32012;
  D.32013 = param->num;
  D.32014 = (unsigned int) D.32013;
  *values = D.32014;
  D.32015 = values + 12;
  D.32017 = param->owner;
  if (D.32017 != 0B) goto <D.32018>; else goto <D.32019>;
  <D.32018>:
  iftmp.261 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.32020>;
  <D.32019>:
  iftmp.261 = 0B;
  <D.32020>:
  D.32021 = iftmp.261->name;
  D.32022 = &assembly->sheap;
  D.32023 = string_heap_insert (D.32022, D.32021);
  *D.32015 = D.32023;
  D.32007 = entry->gparam;
  D.32024 = D.32007->cattrs;
  mono_image_add_cattrs (assembly, table_idx, 19, D.32024);
  D.32007 = entry->gparam;
  encode_constraints (D.32007, table_idx, assembly);
}


encode_constraints (struct MonoReflectionGenericParam * gparam, guint32 owner, struct MonoDynamicImage * assembly)
{
  guint32 iftmp.262;
  struct MonoArray * D.32026;
  long unsigned int D.32029;
  unsigned int D.32031;
  unsigned int D.32032;
  struct MonoReflectionType * D.32033;
  unsigned int D.32036;
  unsigned int D.32039;
  unsigned int table_idx.263;
  unsigned int D.32041;
  guint32 * D.32042;
  unsigned int D.32043;
  long unsigned int D.32044;
  long unsigned int D.32045;
  guint32 * D.32046;
  struct MonoType * D.32047;
  unsigned int D.32048;
  long unsigned int D.32049;
  char * D.32050;
  unsigned int table_idx.264;
  unsigned int D.32052;
  struct MonoType * D.32053;
  unsigned int D.32054;
  struct MonoDynamicTable * table;
  guint32 num_constraints;
  guint32 i;
  guint32 * values;
  guint32 table_idx;

  table = &assembly->tables[44];
  D.32026 = gparam->iface_constraints;
  if (D.32026 != 0B) goto <D.32027>; else goto <D.32028>;
  <D.32027>:
  D.32026 = gparam->iface_constraints;
  D.32029 = mono_array_length (D.32026);
  iftmp.262 = (guint32) D.32029;
  goto <D.32030>;
  <D.32028>:
  iftmp.262 = 0;
  <D.32030>:
  num_constraints = iftmp.262;
  D.32031 = table->rows;
  D.32032 = D.32031 + num_constraints;
  table->rows = D.32032;
  D.32033 = gparam->base_type;
  if (D.32033 != 0B) goto <D.32034>; else goto <D.32035>;
  <D.32034>:
  D.32031 = table->rows;
  D.32036 = D.32031 + 1;
  table->rows = D.32036;
  <D.32035>:
  D.32031 = table->rows;
  alloc_table (table, D.32031);
  D.32033 = gparam->base_type;
  if (D.32033 != 0B) goto <D.32037>; else goto <D.32038>;
  <D.32037>:
  D.32039 = table->next_idx;
  table_idx.263 = D.32039;
  D.32041 = table_idx.263 + 1;
  table->next_idx = D.32041;
  table_idx = table_idx.263;
  D.32042 = table->values;
  D.32043 = table_idx * 2;
  D.32044 = (long unsigned int) D.32043;
  D.32045 = D.32044 * 4;
  values = D.32042 + D.32045;
  *values = owner;
  D.32046 = values + 4;
  D.32033 = gparam->base_type;
  D.32047 = mono_reflection_type_get_handle (D.32033);
  D.32048 = mono_image_typedef_or_ref (assembly, D.32047);
  *D.32046 = D.32048;
  <D.32038>:
  i = 0;
  goto <D.19319>;
  <D.19318>:
  {
    struct MonoReflectionType * constraint;

    D.32049 = (long unsigned int) i;
    D.32026 = gparam->iface_constraints;
    D.32050 = mono_array_addr_with_size (D.32026, 8, D.32049);
    constraint = MEM[(void * *)D.32050];
    D.32039 = table->next_idx;
    table_idx.264 = D.32039;
    D.32052 = table_idx.264 + 1;
    table->next_idx = D.32052;
    table_idx = table_idx.264;
    D.32042 = table->values;
    D.32043 = table_idx * 2;
    D.32044 = (long unsigned int) D.32043;
    D.32045 = D.32044 * 4;
    values = D.32042 + D.32045;
    *values = owner;
    D.32046 = values + 4;
    D.32053 = mono_reflection_type_get_handle (constraint);
    D.32054 = mono_image_typedef_or_ref (assembly, D.32053);
    *D.32046 = D.32054;
  }
  i = i + 1;
  <D.19319>:
  if (i < num_constraints) goto <D.19318>; else goto <D.19320>;
  <D.19320>:
}


pad_heap (struct MonoDynamicStream * sh)
{
  unsigned int D.32055;
  unsigned int D.32056;
  unsigned int D.32059;
  long unsigned int D.32060;
  char * D.32061;
  sizetype D.32062;
  void * D.32063;
  unsigned int sz.265;
  unsigned int D.32065;

  D.32055 = sh->index;
  D.32056 = D.32055 & 3;
  if (D.32056 != 0) goto <D.32057>; else goto <D.32058>;
  <D.32057>:
  {
    int sz;

    D.32055 = sh->index;
    D.32056 = D.32055 & 3;
    D.32059 = 4 - D.32056;
    sz = (int) D.32059;
    D.32060 = (long unsigned int) sz;
    D.32061 = sh->data;
    D.32055 = sh->index;
    D.32062 = (sizetype) D.32055;
    D.32063 = D.32061 + D.32062;
    memset (D.32063, 0, D.32060);
    D.32055 = sh->index;
    sz.265 = (unsigned int) sz;
    D.32065 = D.32055 + sz.265;
    sh->index = D.32065;
  }
  <D.32058>:
}


assembly_add_win32_resources (struct MonoDynamicImage * assembly, struct MonoReflectionAssemblyBuilder * assemblyb)
{
  struct MonoArray * D.32066;
  long unsigned int D.32069;
  struct MonoArray * D.32070;
  long unsigned int D.32071;
  unsigned int D.32072;
  long unsigned int D.32073;
  long unsigned int D.32074;
  long unsigned int D.32075;
  unsigned int D.32076;
  long unsigned int D.32077;
  char * p.266;
  long int p.267;
  long int buf.268;
  long int D.32081;
  long int D.32082;
  _Bool D.32083;
  long int D.32084;
  long int D.32085;
  long unsigned int D.32088;
  void * D.32089;
  unsigned int D.32090;
  long unsigned int D.32091;
  char * D.32092;
  char * buf;
  char * p;
  guint32 size;
  guint32 i;
  struct MonoReflectionWin32Resource * win32_res;
  struct ResTreeNode * tree;

  try
    {
      D.32066 = assemblyb->win32_resources;
      if (D.32066 == 0B) goto <D.32067>; else goto <D.32068>;
      <D.32067>:
      return;
      <D.32068>:
      D.32066 = assemblyb->win32_resources;
      tree = resource_tree_create (D.32066);
      size = 0;
      i = 0;
      goto <D.20864>;
      <D.20863>:
      D.32069 = (long unsigned int) i;
      D.32066 = assemblyb->win32_resources;
      win32_res = mono_array_addr_with_size (D.32066, 24, D.32069);
      D.32070 = win32_res->res_data;
      D.32071 = mono_array_length (D.32070);
      D.32072 = (unsigned int) D.32071;
      size = D.32072 + size;
      i = i + 1;
      <D.20864>:
      D.32069 = (long unsigned int) i;
      D.32066 = assemblyb->win32_resources;
      D.32073 = mono_array_length (D.32066);
      if (D.32069 < D.32073) goto <D.20863>; else goto <D.20865>;
      <D.20865>:
      D.32066 = assemblyb->win32_resources;
      D.32074 = mono_array_length (D.32066);
      D.32075 = D.32074 * 256;
      D.32076 = (unsigned int) D.32075;
      size = D.32076 + size;
      D.32077 = (long unsigned int) size;
      buf = monoeg_malloc (D.32077);
      p = buf;
      p.266 = p;
      p.266 = p;
      resource_tree_encode (tree, p.266, p.266, &p);
      p.266 = p;
      p.267 = (long int) p.266;
      buf.268 = (long int) buf;
      D.32081 = p.267 - buf.268;
      D.32082 = (long int) size;
      D.32083 = D.32081 > D.32082;
      D.32084 = (long int) D.32083;
      D.32085 = __builtin_expect (D.32084, 0);
      if (D.32085 != 0) goto <D.32086>; else goto <D.32087>;
      <D.32086>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5585, "p - buf <= size");
      <D.32087>:
      p.266 = p;
      p.267 = (long int) p.266;
      buf.268 = (long int) buf;
      D.32081 = p.267 - buf.268;
      D.32088 = (long unsigned int) D.32081;
      D.32089 = monoeg_malloc (D.32088);
      assembly->win32_res = D.32089;
      p.266 = p;
      p.267 = (long int) p.266;
      buf.268 = (long int) buf;
      D.32081 = p.267 - buf.268;
      D.32090 = (unsigned int) D.32081;
      assembly->win32_res_size = D.32090;
      p.266 = p;
      p.267 = (long int) p.266;
      buf.268 = (long int) buf;
      D.32081 = p.267 - buf.268;
      D.32091 = (long unsigned int) D.32081;
      D.32092 = assembly->win32_res;
      memcpy (D.32092, buf, D.32091);
      monoeg_g_free (buf);
      resource_tree_free (tree);
    }
  finally
    {
      p = {CLOBBER};
    }
}


resource_tree_create (struct MonoArray * win32_resources)
{
  long unsigned int D.32096;
  unsigned int D.32097;
  void * D.32098;
  unsigned int D.32099;
  unsigned int D.32100;
  struct GSList * D.32105;
  struct GSList * D.32106;
  unsigned int D.32107;
  struct GSList * D.32112;
  struct GSList * D.32113;
  struct GSList * D.32114;
  struct GSList * D.32115;
  long unsigned int D.32116;
  struct ResTreeNode * D.32117;
  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.20823>;
  <D.20822>:
  {
    struct MonoReflectionWin32Resource * win32_res;

    D.32096 = (long unsigned int) i;
    win32_res = mono_array_addr_with_size (win32_resources, 24, D.32096);
    lang_node = monoeg_malloc0 (24);
    D.32097 = win32_res->lang_id;
    lang_node->id = D.32097;
    lang_node->win32_res = win32_res;
    type_node = 0B;
    l = tree->children;
    goto <D.20818>;
    <D.20817>:
    D.32098 = l->data;
    D.32099 = MEM[(struct ResTreeNode *)D.32098].id;
    D.32100 = win32_res->res_type;
    if (D.32099 == D.32100) goto <D.32101>; else goto <D.32102>;
    <D.32101>:
    type_node = l->data;
    goto <D.20816>;
    <D.32102>:
    l = l->next;
    <D.20818>:
    if (l != 0B) goto <D.20817>; else goto <D.20816>;
    <D.20816>:
    if (type_node == 0B) goto <D.32103>; else goto <D.32104>;
    <D.32103>:
    type_node = monoeg_malloc0 (24);
    D.32100 = win32_res->res_type;
    type_node->id = D.32100;
    D.32105 = tree->children;
    D.32106 = monoeg_g_slist_insert_sorted (D.32105, type_node, resource_tree_compare_by_id);
    tree->children = D.32106;
    <D.32104>:
    res_node = 0B;
    l = type_node->children;
    goto <D.20821>;
    <D.20820>:
    D.32098 = l->data;
    D.32099 = MEM[(struct ResTreeNode *)D.32098].id;
    D.32107 = win32_res->res_id;
    if (D.32099 == D.32107) goto <D.32108>; else goto <D.32109>;
    <D.32108>:
    res_node = l->data;
    goto <D.20819>;
    <D.32109>:
    l = l->next;
    <D.20821>:
    if (l != 0B) goto <D.20820>; else goto <D.20819>;
    <D.20819>:
    if (res_node == 0B) goto <D.32110>; else goto <D.32111>;
    <D.32110>:
    res_node = monoeg_malloc0 (24);
    D.32107 = win32_res->res_id;
    res_node->id = D.32107;
    D.32112 = type_node->children;
    D.32113 = monoeg_g_slist_append (D.32112, res_node);
    type_node->children = D.32113;
    <D.32111>:
    D.32114 = res_node->children;
    D.32115 = monoeg_g_slist_append (D.32114, lang_node);
    res_node->children = D.32115;
  }
  i = i + 1;
  <D.20823>:
  D.32096 = (long unsigned int) i;
  D.32116 = mono_array_length (win32_resources);
  if (D.32096 < D.32116) goto <D.20822>; else goto <D.20824>;
  <D.20824>:
  D.32117 = tree;
  return D.32117;
}


resource_tree_compare_by_id (const void * a, const void * b)
{
  int D.32119;
  unsigned int D.32120;
  unsigned int D.32121;
  unsigned int D.32122;
  struct ResTreeNode * t1;
  struct ResTreeNode * t2;

  t1 = a;
  t2 = b;
  D.32120 = t1->id;
  D.32121 = t2->id;
  D.32122 = D.32120 - D.32121;
  D.32119 = (int) D.32122;
  return D.32119;
}


resource_tree_encode (struct ResTreeNode * node, char * begin, char * p, char * * endbuf)
{
  char * p.269;
  long int p.270;
  long int begin.271;
  long int D.32133;
  unsigned int D.32134;
  struct GSList * D.32135;
  short unsigned int D.32136;
  char * p.272;
  long unsigned int D.32138;
  long unsigned int D.32139;
  char * p.273;
  struct MonoReflectionWin32Resource * D.32141;
  unsigned int D.32144;
  struct MonoArray * D.32145;
  long unsigned int D.32146;
  long unsigned int D.32147;
  char * D.32148;
  sizetype D.32149;
  char * p.274;
  unsigned int D.32152;
  unsigned int D.32153;
  unsigned int iftmp.275;
  struct MonoReflectionWin32Resource * D.32155;
  unsigned int D.32159;
  unsigned int D.32160;
  unsigned int D.32161;
  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.32124>; else goto <D.32125>;
      <D.32124>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5486, "sizeof (dir) == 16");
      <D.32125>:
      if (0 != 0) goto <D.32126>; else goto <D.32127>;
      <D.32126>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5487, "sizeof (dir_entry) == 8");
      <D.32127>:
      if (0 != 0) goto <D.32128>; else goto <D.32129>;
      <D.32128>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5488, "sizeof (data_entry) == 16");
      <D.32129>:
      p.269 = p;
      p.270 = (long int) p.269;
      begin.271 = (long int) begin;
      D.32133 = p.270 - begin.271;
      D.32134 = (unsigned int) D.32133;
      node->offset = D.32134;
      D.32135 = node->children;
      res_id_entries = monoeg_g_slist_length (D.32135);
      D.32136 = (short unsigned int) res_id_entries;
      dir.res_id_entries = D.32136;
      p.269 = p;
      memcpy (p.269, &dir, 16);
      p.269 = p;
      p.272 = p.269 + 16;
      p = p.272;
      entries = p;
      p.269 = p;
      D.32138 = (long unsigned int) res_id_entries;
      D.32139 = D.32138 * 8;
      p.273 = p.269 + D.32139;
      p = p.273;
      l = node->children;
      goto <D.20840>;
      <D.20839>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.32141 = child->win32_res;
        if (D.32141 != 0B) goto <D.32142>; else goto <D.32143>;
        <D.32142>:
        {
          guint32 size;

          p.269 = p;
          p.270 = (long int) p.269;
          begin.271 = (long int) begin;
          D.32133 = p.270 - begin.271;
          D.32134 = (unsigned int) D.32133;
          child->offset = D.32134;
          p.269 = p;
          p.270 = (long int) p.269;
          begin.271 = (long int) begin;
          D.32133 = p.270 - begin.271;
          D.32134 = (unsigned int) D.32133;
          D.32144 = D.32134 + 16;
          data_entry.rde_data_offset = D.32144;
          D.32141 = child->win32_res;
          D.32145 = D.32141->res_data;
          D.32146 = mono_array_length (D.32145);
          size = (guint32) D.32146;
          data_entry.rde_size = size;
          p.269 = p;
          memcpy (p.269, &data_entry, 16);
          p.269 = p;
          p.272 = p.269 + 16;
          p = p.272;
          D.32147 = (long unsigned int) size;
          D.32141 = child->win32_res;
          D.32145 = D.32141->res_data;
          D.32148 = mono_array_addr_with_size (D.32145, 1, 0);
          p.269 = p;
          memcpy (p.269, D.32148, D.32147);
          p.269 = p;
          D.32149 = (sizetype) size;
          p.274 = p.269 + D.32149;
          p = p.274;
        }
        goto <D.32151>;
        <D.32143>:
        p.269 = p;
        resource_tree_encode (child, begin, p.269, &p);
        <D.32151>:
      }
      l = l->next;
      <D.20840>:
      if (l != 0B) goto <D.20839>; else goto <D.20841>;
      <D.20841>:
      l = node->children;
      goto <D.20844>;
      <D.20843>:
      {
        struct ResTreeNode * child;

        child = l->data;
        D.32152 = child->id;
        D.32153 = D.32152 & 2147483647;
        dir_entry.name = D.32153;
        D.32155 = child->win32_res;
        if (D.32155 == 0B) goto <D.32156>; else goto <D.32157>;
        <D.32156>:
        iftmp.275 = 2147483648;
        goto <D.32158>;
        <D.32157>:
        iftmp.275 = 0;
        <D.32158>:
        D.32159 = child->offset;
        D.32160 = D.32159 & 2147483647;
        D.32161 = iftmp.275 | D.32160;
        dir_entry.dir = D.32161;
        memcpy (entries, &dir_entry, 8);
        entries = entries + 8;
      }
      l = l->next;
      <D.20844>:
      if (l != 0B) goto <D.20843>; else goto <D.20845>;
      <D.20845>:
      p.269 = p;
      *endbuf = p.269;
    }
  finally
    {
      dir = {CLOBBER};
      dir_entry = {CLOBBER};
      data_entry = {CLOBBER};
    }
}


resource_tree_free (struct ResTreeNode * node)
{
  void * D.32162;
  struct GSList * D.32163;
  struct GSList * list;

  list = node->children;
  goto <D.20851>;
  <D.20850>:
  D.32162 = list->data;
  resource_tree_free (D.32162);
  list = list->next;
  <D.20851>:
  if (list != 0B) goto <D.20850>; else goto <D.20852>;
  <D.20852>:
  D.32163 = node->children;
  monoeg_g_slist_free (D.32163);
  monoeg_g_free (node);
}


calc_section_size (struct MonoDynamicImage * assembly)
{
  unsigned int D.32164;
  unsigned int D.32165;
  unsigned int D.32166;
  struct MonoDynamicStream * D.32167;
  _Bool D.32168;
  long int D.32169;
  long int D.32170;
  unsigned int D.32173;
  unsigned int D.32174;
  unsigned int D.32175;
  unsigned int D.32176;
  unsigned int D.32177;
  unsigned int D.32178;
  struct MonoDynamicStream * D.32179;
  _Bool D.32180;
  long int D.32181;
  long int D.32182;
  unsigned int D.32185;
  unsigned int D.32186;
  unsigned int D.32187;
  unsigned int D.32188;
  char * D.32189;
  unsigned int D.32192;
  unsigned int D.32193;
  int D.32194;
  int nsections;

  nsections = 0;
  D.32164 = assembly->code.index;
  D.32165 = D.32164 & 3;
  D.32166 = 4 - D.32165;
  D.32167 = &assembly->code;
  mono_image_add_stream_zero (D.32167, D.32166);
  D.32164 = assembly->code.index;
  D.32165 = D.32164 & 3;
  D.32168 = D.32165 != 0;
  D.32169 = (long int) D.32168;
  D.32170 = __builtin_expect (D.32169, 0);
  if (D.32170 != 0) goto <D.32171>; else goto <D.32172>;
  <D.32171>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5355, "(assembly->code.index % 4) == 0");
  <D.32172>:
  D.32173 = assembly->meta_size;
  D.32174 = D.32173 + 3;
  assembly->meta_size = D.32174;
  D.32173 = assembly->meta_size;
  D.32175 = D.32173 & 4294967292;
  assembly->meta_size = D.32175;
  D.32176 = assembly->resources.index;
  D.32177 = D.32176 & 3;
  D.32178 = 4 - D.32177;
  D.32179 = &assembly->resources;
  mono_image_add_stream_zero (D.32179, D.32178);
  D.32176 = assembly->resources.index;
  D.32177 = D.32176 & 3;
  D.32180 = D.32177 != 0;
  D.32181 = (long int) D.32180;
  D.32182 = __builtin_expect (D.32181, 0);
  if (D.32182 != 0) goto <D.32183>; else goto <D.32184>;
  <D.32183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 5359, "(assembly->resources.index % 4) == 0");
  <D.32184>:
  D.32173 = assembly->meta_size;
  D.32164 = assembly->code.index;
  D.32185 = D.32173 + D.32164;
  D.32176 = assembly->resources.index;
  D.32186 = D.32185 + D.32176;
  D.32187 = assembly->strong_name_size;
  D.32188 = D.32186 + D.32187;
  assembly->sections[0].size = D.32188;
  assembly->sections[0].attrs = 1610612768;
  nsections = nsections + 1;
  D.32189 = assembly->win32_res;
  if (D.32189 != 0B) goto <D.32190>; else goto <D.32191>;
  <D.32190>:
  {
    guint32 res_size;

    D.32192 = assembly->win32_res_size;
    D.32193 = D.32192 + 3;
    res_size = D.32193 & 4294967292;
    assembly->sections[1].size = res_size;
    assembly->sections[1].attrs = 1073741888;
    nsections = nsections + 1;
  }
  <D.32191>:
  assembly->sections[2].size = 12;
  assembly->sections[2].attrs = 1107296320;
  nsections = nsections + 1;
  D.32194 = nsections;
  return D.32194;
}


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

  D.32197 = __builtin_object_size (__dest, 1);
  D.32196 = __builtin___strcpy_chk (__dest, __src, D.32197);
  return D.32196;
}


fixup_resource_directory (char * res_section, char * p, guint32 rva)
{
  unsigned int D.32199;
  sizetype D.32200;
  sizetype D.32201;
  signed int D.32202;
  unsigned int D.32206;
  unsigned int D.32207;
  short unsigned int D.32208;
  int D.32209;
  short unsigned int D.32210;
  int D.32211;
  int D.32212;
  struct MonoPEResourceDir * dir;
  int i;

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

    dir_entry = p;
    D.32199 = dir_entry->dir;
    D.32200 = (sizetype) D.32199;
    D.32201 = D.32200 & 2147483647;
    child = res_section + D.32201;
    D.32199 = dir_entry->dir;
    D.32202 = (signed int) D.32199;
    if (D.32202 < 0) goto <D.32203>; else goto <D.32204>;
    <D.32203>:
    fixup_resource_directory (res_section, child, rva);
    goto <D.32205>;
    <D.32204>:
    {
      struct MonoPEResourceDataEntry * data_entry;

      data_entry = child;
      D.32206 = data_entry->rde_data_offset;
      D.32207 = D.32206 + rva;
      data_entry->rde_data_offset = D.32207;
    }
    <D.32205>:
    p = p + 8;
  }
  i = i + 1;
  <D.20877>:
  D.32208 = dir->res_named_entries;
  D.32209 = (int) D.32208;
  D.32210 = dir->res_id_entries;
  D.32211 = (int) D.32210;
  D.32212 = D.32209 + D.32211;
  if (D.32212 > i) goto <D.20876>; else goto <D.20878>;
  <D.20878>:
}


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

  try
    {
      D.32213 = WriteFile (f, buffer, numbytes, &dummy, 0B);
      if (D.32213 == 0) goto <D.32214>; else goto <D.32215>;
      <D.32214>:
      D.32216 = GetLastError ();
      monoeg_g_log (0B, 4, "WriteFile returned %d\n", D.32216);
      <D.20885>:
      goto <D.20885>;
      <D.32215>:
    }
  finally
    {
      dummy = {CLOBBER};
    }
}


mono_image_load_module_dynamic (struct MonoReflectionAssemblyBuilder * ab, struct MonoString * fileName)
{
  <unnamed type> status.276;
  struct MonoAssembly * D.32223;
  struct MonoImage * D.32224;
  unsigned int D.32225;
  long unsigned int D.32226;
  long unsigned int D.32227;
  long unsigned int D.32228;
  struct MonoImage * * D.32229;
  long unsigned int D.32232;
  long unsigned int D.32233;
  gboolean * D.32234;
  long unsigned int D.32237;
  struct MonoImage * * D.32238;
  gboolean * D.32239;
  unsigned int D.32240;
  unsigned int D.32241;
  struct MonoException * D.32244;
  struct MonoReflectionModule * D.32245;
  struct MonoDomain * D.32246;
  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.32217>; else goto <D.32218>;
      <D.32217>:
      {
        struct MonoException * exc;

        status.276 = status;
        if (status.276 == 1) goto <D.32220>; else goto <D.32221>;
        <D.32220>:
        exc = mono_get_exception_file_not_found (fileName);
        goto <D.32222>;
        <D.32221>:
        exc = mono_get_exception_bad_image_format (name);
        <D.32222>:
        monoeg_g_free (name);
        mono_raise_exception (exc);
      }
      <D.32218>:
      monoeg_g_free (name);
      assembly = ab->dynamic_assembly;
      image->assembly = assembly;
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      module_count = D.32224->module_count;
      D.32225 = module_count + 1;
      D.32226 = (long unsigned int) D.32225;
      D.32227 = D.32226 * 8;
      new_modules = monoeg_malloc0 (D.32227);
      D.32225 = module_count + 1;
      D.32226 = (long unsigned int) D.32225;
      D.32228 = D.32226 * 4;
      new_modules_loaded = monoeg_malloc0 (D.32228);
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32229 = D.32224->modules;
      if (D.32229 != 0B) goto <D.32230>; else goto <D.32231>;
      <D.32230>:
      D.32232 = (long unsigned int) module_count;
      D.32233 = D.32232 * 8;
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32229 = D.32224->modules;
      memcpy (new_modules, D.32229, D.32233);
      <D.32231>:
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32234 = D.32224->modules_loaded;
      if (D.32234 != 0B) goto <D.32235>; else goto <D.32236>;
      <D.32235>:
      D.32232 = (long unsigned int) module_count;
      D.32237 = D.32232 * 4;
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32234 = D.32224->modules_loaded;
      memcpy (new_modules_loaded, D.32234, D.32237);
      <D.32236>:
      D.32232 = (long unsigned int) module_count;
      D.32233 = D.32232 * 8;
      D.32238 = new_modules + D.32233;
      *D.32238 = image;
      D.32232 = (long unsigned int) module_count;
      D.32237 = D.32232 * 4;
      D.32239 = new_modules_loaded + D.32237;
      *D.32239 = 1;
      mono_image_addref (image);
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32229 = D.32224->modules;
      monoeg_g_free (D.32229);
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32224->modules = new_modules;
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32224->modules_loaded = new_modules_loaded;
      D.32223 = image->assembly;
      D.32224 = D.32223->image;
      D.32240 = D.32224->module_count;
      D.32241 = D.32240 + 1;
      D.32224->module_count = D.32241;
      mono_assembly_load_references (image, &status);
      status.276 = status;
      if (status.276 != 0) goto <D.32242>; else goto <D.32243>;
      <D.32242>:
      mono_image_close (image);
      D.32244 = mono_get_exception_file_not_found (fileName);
      mono_raise_exception (D.32244);
      <D.32243>:
      D.32246 = mono_domain_get ();
      D.32245 = mono_module_get_object (D.32246, image);
      return D.32245;
    }
  finally
    {
      status = {CLOBBER};
    }
}


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

  D.32249 = domain->refobject_hash;
  if (D.32249 != 0B) goto <D.32250>; else goto <D.32251>;
  <D.32250>:
  D.32249 = domain->refobject_hash;
  mono_g_hash_table_destroy (D.32249);
  domain->refobject_hash = 0B;
  <D.32251>:
}


mono_image_module_basic_init (struct MonoReflectionModuleBuilder * moduleb)
{
  struct MonoString * D.32254;
  struct MonoString * D.32255;
  int D.32256;
  struct MonoDynamicAssembly * D.32259;
  struct MonoImage * D.32260;
  struct MonoVTable * D.32261;
  struct MonoDomain * D.32262;
  unsigned int D.32263;
  int D.32264;
  long unsigned int D.32265;
  long unsigned int D.32266;
  struct MonoImage * * D.32267;
  long unsigned int D.32270;
  long unsigned int D.32271;
  struct MonoImage * * D.32272;
  unsigned int D.32273;
  struct MonoDynamicImage * image;
  struct MonoReflectionAssemblyBuilder * ab;

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

    try
      {
        D.32254 = ab->name;
        name = mono_string_to_utf8 (D.32254);
        D.32255 = moduleb->module.fqname;
        fqname = mono_string_to_utf8_checked (D.32255, &error);
        D.32256 = mono_error_ok (&error);
        if (D.32256 == 0) goto <D.32257>; else goto <D.32258>;
        <D.32257>:
        monoeg_g_free (name);
        mono_error_raise_exception (&error);
        <D.32258>:
        D.32259 = ab->dynamic_assembly;
        image = create_dynamic_mono_image (D.32259, name, fqname);
        D.32260 = &image->image;
        moduleb->module.image = D.32260;
        moduleb->dynamic_image = image;
        D.32261 = MEM[(struct MonoObject *)moduleb].vtable;
        D.32262 = D.32261->domain;
        register_module (D.32262, moduleb, image);
        D.32259 = ab->dynamic_assembly;
        ass = D.32259->assembly.image;
        D.32263 = ass->module_count;
        module_count = (int) D.32263;
        D.32264 = module_count + 1;
        D.32265 = (long unsigned int) D.32264;
        D.32266 = D.32265 * 8;
        new_modules = monoeg_malloc0 (D.32266);
        D.32267 = ass->modules;
        if (D.32267 != 0B) goto <D.32268>; else goto <D.32269>;
        <D.32268>:
        D.32270 = (long unsigned int) module_count;
        D.32271 = D.32270 * 8;
        D.32267 = ass->modules;
        memcpy (new_modules, D.32267, D.32271);
        <D.32269>:
        D.32270 = (long unsigned int) module_count;
        D.32271 = D.32270 * 8;
        D.32272 = new_modules + D.32271;
        D.32260 = &image->image;
        *D.32272 = D.32260;
        D.32260 = &image->image;
        mono_image_addref (D.32260);
        D.32267 = ass->modules;
        monoeg_g_free (D.32267);
        ass->modules = new_modules;
        D.32263 = ass->module_count;
        D.32273 = D.32263 + 1;
        ass->module_count = D.32273;
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.32253>:
}


register_module (struct MonoDomain * domain, struct MonoReflectionModuleBuilder * res, struct MonoDynamicImage * module)
{
  union mono_mutex_t * D.32274;
  _Bool D.32277;
  long int D.32278;
  long int D.32279;
  struct MonoGHashTable * D.32282;
  struct MonoGHashTable * D.32285;
  struct MonoMemPool * D.32288;
  _Bool D.32291;
  long int D.32292;
  long int D.32293;
  void * D.32296;

  {
    struct MonoReflectionModuleBuilder * _obj;
    struct ReflectedEntry pe;

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

          D.32274 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32274);
          if (ret != 0) goto <D.32275>; else goto <D.32276>;
          <D.32275>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32276>:
          D.32277 = ret != 0;
          D.32278 = (long int) D.32277;
          D.32279 = __builtin_expect (D.32278, 0);
          if (D.32279 != 0) goto <D.32280>; else goto <D.32281>;
          <D.32280>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.32281>:
        }
        D.32282 = domain->refobject_hash;
        if (D.32282 == 0B) goto <D.32283>; else goto <D.32284>;
        <D.32283>:
        D.32285 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32285;
        <D.32284>:
        D.32282 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32282, &pe);
        if (_obj == 0B) goto <D.32286>; else goto <D.32287>;
        <D.32286>:
        {
          struct ReflectedEntry * e;

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

          D.32274 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32274);
          if (ret != 0) goto <D.32289>; else goto <D.32290>;
          <D.32289>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32290>:
          D.32291 = ret != 0;
          D.32292 = (long int) D.32291;
          D.32293 = __builtin_expect (D.32292, 0);
          if (D.32293 != 0) goto <D.32294>; else goto <D.32295>;
          <D.32294>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6173, "ret == 0");
          <D.32295>:
        }
        D.32296 = _obj;
        return D.32296;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_image_set_wrappers_type (struct MonoReflectionModuleBuilder * moduleb, struct MonoReflectionType * type)
{
  struct MonoType * D.32299;
  _Bool D.32300;
  long int D.32301;
  long int D.32302;
  struct MonoClass * D.32305;
  struct MonoDynamicImage * image;

  image = moduleb->dynamic_image;
  D.32299 = type->type;
  D.32300 = D.32299 == 0B;
  D.32301 = (long int) D.32300;
  D.32302 = __builtin_expect (D.32301, 0);
  if (D.32302 != 0) goto <D.32303>; else goto <D.32304>;
  <D.32303>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6226, "type->type");
  <D.32304>:
  D.32299 = type->type;
  D.32305 = mono_class_from_mono_type (D.32299);
  image->wrappers_type = D.32305;
}


mono_assembly_get_object (struct MonoDomain * domain, struct MonoAssembly * assembly)
{
  union mono_mutex_t * D.32306;
  _Bool D.32309;
  long int D.32310;
  long int D.32311;
  struct MonoGHashTable * D.32314;
  struct MonoGHashTable * D.32317;
  _Bool D.32322;
  long int D.32323;
  long int D.32324;
  struct MonoReflectionAssembly * D.32327;
  _Bool D.32330;
  long int D.32331;
  long int D.32332;
  struct MonoClass * assembly_type.277;
  struct MonoImage * D.32338;
  _Bool D.32341;
  long int D.32342;
  long int D.32343;
  _Bool D.32348;
  long int D.32349;
  long int D.32350;
  struct MonoGHashTable * D.32355;
  struct MonoMemPool * D.32358;
  _Bool D.32361;
  long int D.32362;
  long int D.32363;
  static struct MonoClass * assembly_type;
  struct MonoReflectionAssembly * res;

  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry e;

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

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

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

          D.32306 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32306);
          if (ret != 0) goto <D.32328>; else goto <D.32329>;
          <D.32328>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32329>:
          D.32330 = ret != 0;
          D.32331 = (long int) D.32330;
          D.32332 = __builtin_expect (D.32331, 0);
          if (D.32332 != 0) goto <D.32333>; else goto <D.32334>;
          <D.32333>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6245, "ret == 0");
          <D.32334>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  assembly_type.277 = assembly_type;
  if (assembly_type.277 == 0B) goto <D.32336>; else goto <D.32337>;
  <D.32336>:
  {
    struct MonoClass * class;

    D.32338 = mono_defaults.corlib;
    class = mono_class_from_name (D.32338, "System.Reflection", "MonoAssembly");
    if (class == 0B) goto <D.32339>; else goto <D.32340>;
    <D.32339>:
    D.32338 = mono_defaults.corlib;
    class = mono_class_from_name (D.32338, "System.Reflection", "Assembly");
    <D.32340>:
    D.32341 = class == 0B;
    D.32342 = (long int) D.32341;
    D.32343 = __builtin_expect (D.32342, 0);
    if (D.32343 != 0) goto <D.32344>; else goto <D.32345>;
    <D.32344>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6250, "class");
    <D.32345>:
    assembly_type = class;
  }
  <D.32337>:
  assembly_type.277 = assembly_type;
  res = mono_object_new (domain, assembly_type.277);
  res->assembly = assembly;
  {
    struct MonoReflectionAssembly * _obj;
    struct ReflectedEntry pe;

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

          D.32306 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32306);
          if (ret != 0) goto <D.32346>; else goto <D.32347>;
          <D.32346>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32347>:
          D.32348 = ret != 0;
          D.32349 = (long int) D.32348;
          D.32350 = __builtin_expect (D.32349, 0);
          if (D.32350 != 0) goto <D.32351>; else goto <D.32352>;
          <D.32351>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.32352>:
        }
        D.32314 = domain->refobject_hash;
        if (D.32314 == 0B) goto <D.32353>; else goto <D.32354>;
        <D.32353>:
        D.32355 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32355;
        <D.32354>:
        D.32314 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32314, &pe);
        if (_obj == 0B) goto <D.32356>; else goto <D.32357>;
        <D.32356>:
        {
          struct ReflectedEntry * e;

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

          D.32306 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32306);
          if (ret != 0) goto <D.32359>; else goto <D.32360>;
          <D.32359>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32360>:
          D.32361 = ret != 0;
          D.32362 = (long int) D.32361;
          D.32363 = __builtin_expect (D.32362, 0);
          if (D.32363 != 0) goto <D.32364>; else goto <D.32365>;
          <D.32364>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6256, "ret == 0");
          <D.32365>:
        }
        D.32327 = _obj;
        return D.32327;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_get_object (struct MonoDomain * domain, struct MonoImage * image)
{
  union mono_mutex_t * D.32370;
  _Bool D.32373;
  long int D.32374;
  long int D.32375;
  struct MonoGHashTable * D.32378;
  struct MonoGHashTable * D.32381;
  _Bool D.32386;
  long int D.32387;
  long int D.32388;
  struct MonoReflectionModule * D.32391;
  _Bool D.32394;
  long int D.32395;
  long int D.32396;
  struct MonoClass * module_type.278;
  struct MonoImage * D.32402;
  _Bool D.32405;
  long int D.32406;
  long int D.32407;
  struct MonoAssembly * D.32410;
  struct MonoReflectionAssembly * D.32411;
  struct MonoReflectionAssembly * * D.32412;
  char * D.32413;
  struct MonoString * D.32414;
  struct MonoString * * D.32415;
  struct MonoString * D.32416;
  struct MonoString * * D.32417;
  const char * D.32418;
  struct MonoString * D.32419;
  struct MonoString * * D.32420;
  struct MonoImage * D.32421;
  struct MonoImage * * D.32425;
  long unsigned int D.32428;
  long unsigned int D.32429;
  struct MonoImage * * D.32430;
  struct MonoImage * D.32431;
  int D.32434;
  int D.32435;
  unsigned int D.32436;
  unsigned int i.279;
  unsigned int D.32438;
  unsigned int D.32439;
  _Bool D.32440;
  long int D.32441;
  long int D.32442;
  _Bool D.32447;
  long int D.32448;
  long int D.32449;
  struct MonoGHashTable * D.32454;
  struct MonoMemPool * D.32457;
  _Bool D.32460;
  long int D.32461;
  long int D.32462;
  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.32370 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32370);
          if (ret != 0) goto <D.32371>; else goto <D.32372>;
          <D.32371>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32372>:
          D.32373 = ret != 0;
          D.32374 = (long int) D.32373;
          D.32375 = __builtin_expect (D.32374, 0);
          if (D.32375 != 0) goto <D.32376>; else goto <D.32377>;
          <D.32376>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32377>:
        }
        D.32378 = domain->refobject_hash;
        if (D.32378 == 0B) goto <D.32379>; else goto <D.32380>;
        <D.32379>:
        D.32381 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32381;
        <D.32380>:
        D.32378 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32378, &e);
        if (_obj != 0B) goto <D.32382>; else goto <D.32383>;
        <D.32382>:
        {
          int ret;

          D.32370 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32370);
          if (ret != 0) goto <D.32384>; else goto <D.32385>;
          <D.32384>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32385>:
          D.32386 = ret != 0;
          D.32387 = (long int) D.32386;
          D.32388 = __builtin_expect (D.32387, 0);
          if (D.32388 != 0) goto <D.32389>; else goto <D.32390>;
          <D.32389>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32390>:
        }
        D.32391 = _obj;
        return D.32391;
        <D.32383>:
        {
          int ret;

          D.32370 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32370);
          if (ret != 0) goto <D.32392>; else goto <D.32393>;
          <D.32392>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32393>:
          D.32394 = ret != 0;
          D.32395 = (long int) D.32394;
          D.32396 = __builtin_expect (D.32395, 0);
          if (D.32396 != 0) goto <D.32397>; else goto <D.32398>;
          <D.32397>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6268, "ret == 0");
          <D.32398>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  module_type.278 = module_type;
  if (module_type.278 == 0B) goto <D.32400>; else goto <D.32401>;
  <D.32400>:
  {
    struct MonoClass * class;

    D.32402 = mono_defaults.corlib;
    class = mono_class_from_name (D.32402, "System.Reflection", "MonoModule");
    if (class == 0B) goto <D.32403>; else goto <D.32404>;
    <D.32403>:
    D.32402 = mono_defaults.corlib;
    class = mono_class_from_name (D.32402, "System.Reflection", "Module");
    <D.32404>:
    D.32405 = class == 0B;
    D.32406 = (long int) D.32405;
    D.32407 = __builtin_expect (D.32406, 0);
    if (D.32407 != 0) goto <D.32408>; else goto <D.32409>;
    <D.32408>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6273, "class");
    <D.32409>:
    module_type = class;
  }
  <D.32401>:
  module_type.278 = module_type;
  res = mono_object_new (domain, module_type.278);
  res->image = image;
  D.32410 = image->assembly;
  D.32411 = mono_assembly_get_object (domain, D.32410);
  D.32412 = &res->assembly;
  mono_gc_wbarrier_set_field (res, D.32412, D.32411);
  D.32413 = image->name;
  D.32414 = mono_string_new (domain, D.32413);
  D.32415 = &res->fqname;
  mono_gc_wbarrier_set_field (res, D.32415, D.32414);
  D.32413 = image->name;
  basename = monoeg_g_path_get_basename (D.32413);
  D.32416 = mono_string_new (domain, basename);
  D.32417 = &res->name;
  mono_gc_wbarrier_set_field (res, D.32417, D.32416);
  D.32418 = image->module_name;
  D.32419 = mono_string_new (domain, D.32418);
  D.32420 = &res->scopename;
  mono_gc_wbarrier_set_field (res, D.32420, D.32419);
  monoeg_g_free (basename);
  D.32410 = image->assembly;
  D.32421 = D.32410->image;
  if (D.32421 == image) goto <D.32422>; else goto <D.32423>;
  <D.32422>:
  res->token = 1;
  goto <D.32424>;
  <D.32423>:
  {
    int i;

    res->token = 0;
    D.32410 = image->assembly;
    D.32421 = D.32410->image;
    D.32425 = D.32421->modules;
    if (D.32425 != 0B) goto <D.32426>; else goto <D.32427>;
    <D.32426>:
    i = 0;
    goto <D.21066>;
    <D.21065>:
    D.32410 = image->assembly;
    D.32421 = D.32410->image;
    D.32425 = D.32421->modules;
    D.32428 = (long unsigned int) i;
    D.32429 = D.32428 * 8;
    D.32430 = D.32425 + D.32429;
    D.32431 = *D.32430;
    if (D.32431 == image) goto <D.32432>; else goto <D.32433>;
    <D.32432>:
    D.32434 = i + 1;
    D.32435 = D.32434 | 436207616;
    D.32436 = (unsigned int) D.32435;
    res->token = D.32436;
    <D.32433>:
    i = i + 1;
    <D.21066>:
    i.279 = (unsigned int) i;
    D.32410 = image->assembly;
    D.32421 = D.32410->image;
    D.32438 = D.32421->module_count;
    if (i.279 < D.32438) goto <D.21065>; else goto <D.21067>;
    <D.21067>:
    D.32439 = res->token;
    D.32440 = D.32439 == 0;
    D.32441 = (long int) D.32440;
    D.32442 = __builtin_expect (D.32441, 0);
    if (D.32442 != 0) goto <D.32443>; else goto <D.32444>;
    <D.32443>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6298, "res->token");
    <D.32444>:
    <D.32427>:
  }
  <D.32424>:
  {
    struct MonoReflectionModule * _obj;
    struct ReflectedEntry pe;

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

          D.32370 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32370);
          if (ret != 0) goto <D.32445>; else goto <D.32446>;
          <D.32445>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32446>:
          D.32447 = ret != 0;
          D.32448 = (long int) D.32447;
          D.32449 = __builtin_expect (D.32448, 0);
          if (D.32449 != 0) goto <D.32450>; else goto <D.32451>;
          <D.32450>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.32451>:
        }
        D.32378 = domain->refobject_hash;
        if (D.32378 == 0B) goto <D.32452>; else goto <D.32453>;
        <D.32452>:
        D.32454 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32454;
        <D.32453>:
        D.32378 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32378, &pe);
        if (_obj == 0B) goto <D.32455>; else goto <D.32456>;
        <D.32455>:
        {
          struct ReflectedEntry * e;

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

          D.32370 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32370);
          if (ret != 0) goto <D.32458>; else goto <D.32459>;
          <D.32458>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32459>:
          D.32460 = ret != 0;
          D.32461 = (long int) D.32460;
          D.32462 = __builtin_expect (D.32461, 0);
          if (D.32462 != 0) goto <D.32463>; else goto <D.32464>;
          <D.32463>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6302, "ret == 0");
          <D.32464>:
        }
        D.32391 = _obj;
        return D.32391;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_module_file_get_object (struct MonoDomain * domain, struct MonoImage * image, int table_index)
{
  struct MonoClass * module_type.280;
  struct MonoImage * D.32472;
  _Bool D.32475;
  long int D.32476;
  long int D.32477;
  <unnamed-unsigned:24> D.32480;
  int D.32481;
  _Bool D.32482;
  long int D.32483;
  long int D.32484;
  struct MonoAssembly * D.32487;
  struct MonoReflectionAssembly * D.32488;
  struct MonoReflectionAssembly * * D.32489;
  unsigned int D.32490;
  int i.281;
  int D.21095;
  struct MonoImage * * D.32494;
  long unsigned int D.32495;
  long unsigned int D.32496;
  struct MonoImage * * D.32497;
  struct MonoImage * D.32498;
  unsigned int D.32499;
  struct MonoString * D.32500;
  struct MonoString * * D.32501;
  struct MonoString * D.32502;
  struct MonoString * * D.32503;
  struct MonoString * D.32504;
  struct MonoString * * D.32505;
  unsigned int D.32506;
  _Bool D.32507;
  unsigned char D.32508;
  int D.32509;
  int D.32510;
  unsigned int D.32511;
  struct MonoReflectionModule * D.32512;
  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.280 = module_type;
      if (module_type.280 == 0B) goto <D.32470>; else goto <D.32471>;
      <D.32470>:
      {
        struct MonoClass * class;

        D.32472 = mono_defaults.corlib;
        class = mono_class_from_name (D.32472, "System.Reflection", "MonoModule");
        if (class == 0B) goto <D.32473>; else goto <D.32474>;
        <D.32473>:
        D.32472 = mono_defaults.corlib;
        class = mono_class_from_name (D.32472, "System.Reflection", "Module");
        <D.32474>:
        D.32475 = class == 0B;
        D.32476 = (long int) D.32475;
        D.32477 = __builtin_expect (D.32476, 0);
        if (D.32477 != 0) goto <D.32478>; else goto <D.32479>;
        <D.32478>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6320, "class");
        <D.32479>:
        module_type = class;
      }
      <D.32471>:
      module_type.280 = module_type;
      res = mono_object_new (domain, module_type.280);
      table = &image->tables[38];
      D.32480 = table->rows;
      D.32481 = (int) D.32480;
      D.32482 = D.32481 <= table_index;
      D.32483 = (long int) D.32482;
      D.32484 = __builtin_expect (D.32483, 0);
      if (D.32484 != 0) goto <D.32485>; else goto <D.32486>;
      <D.32485>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6326, "table_index < table->rows");
      <D.32486>:
      mono_metadata_decode_row (table, table_index, &cols, 3);
      res->image = 0B;
      D.32487 = image->assembly;
      D.32488 = mono_assembly_get_object (domain, D.32487);
      D.32489 = &res->assembly;
      mono_gc_wbarrier_set_field (res, D.32489, D.32488);
      D.32490 = cols[1];
      name = mono_metadata_string_heap (image, D.32490);
      table = &image->tables[26];
      i = 0;
      goto <D.21097>;
      <D.21096>:
      i.281 = (int) i;
      name_idx = mono_metadata_decode_row_col (table, i.281, 0);
      val = mono_metadata_string_heap (image, name_idx);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.21095 = __builtin_strcmp (val, name);
      }
      if (D.21095 == 0) goto <D.32492>; else goto <D.32493>;
      <D.32492>:
      D.32494 = image->modules;
      D.32495 = (long unsigned int) i;
      D.32496 = D.32495 * 8;
      D.32497 = D.32494 + D.32496;
      D.32498 = *D.32497;
      res->image = D.32498;
      <D.32493>:
      i = i + 1;
      <D.21097>:
      D.32480 = table->rows;
      D.32499 = (unsigned int) D.32480;
      if (D.32499 > i) goto <D.21096>; else goto <D.21098>;
      <D.21098>:
      D.32500 = mono_string_new (domain, name);
      D.32501 = &res->fqname;
      mono_gc_wbarrier_set_field (res, D.32501, D.32500);
      D.32502 = mono_string_new (domain, name);
      D.32503 = &res->name;
      mono_gc_wbarrier_set_field (res, D.32503, D.32502);
      D.32504 = mono_string_new (domain, name);
      D.32505 = &res->scopename;
      mono_gc_wbarrier_set_field (res, D.32505, D.32504);
      D.32506 = cols[0];
      D.32507 = D.32506 != 0;
      D.32508 = (unsigned char) D.32507;
      res->is_resource = D.32508;
      D.32509 = table_index + 1;
      D.32510 = D.32509 | 637534208;
      D.32511 = (unsigned int) D.32510;
      res->token = D.32511;
      D.32512 = res;
      return D.32512;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_type_get_object (struct MonoDomain * domain, struct MonoType * type)
{
  struct MonoType * iftmp.282;
  <unnamed-unsigned:1> D.32516;
  <unnamed-unsigned:1> D.32517;
  unsigned char D.32521;
  struct MonoObject * D.32524;
  struct MonoReflectionType * D.32527;
  struct MonoType * D.32528;
  struct MonoImage * D.32531;
  unsigned char D.32532;
  unsigned char D.32533;
  void * D.32538;
  union mono_mutex_t * D.32541;
  _Bool D.32544;
  long int D.32545;
  long int D.32546;
  struct MonoGHashTable * D.32549;
  struct MonoGHashTable * D.32552;
  _Bool D.32557;
  long int D.32558;
  long int D.32559;
  _Bool D.32566;
  long int D.32567;
  long int D.32568;
  struct MonoGenericClass * D.32573;
  unsigned char D.32574;
  unsigned char D.32575;
  struct MonoClass * D.32578;
  unsigned char D.32579;
  unsigned char D.32580;
  int D.32585;
  _Bool D.32590;
  long int D.32591;
  long int D.32592;
  struct MonoException * D.32595;
  void * D.32596;
  unsigned char D.32599;
  unsigned char D.32600;
  unsigned char D.32603;
  _Bool D.32604;
  _Bool D.32605;
  _Bool D.32606;
  struct MonoGenericContainer * D.32611;
  unsigned char D.32613;
  unsigned char D.32614;
  struct MonoClass * D.32618;
  struct MonoClass * D.32619;
  unsigned char D.32620;
  unsigned char D.32621;
  struct MonoClass * D.32630;
  unsigned char D.32631;
  unsigned char D.32632;
  unsigned char D.32637;
  unsigned char D.32638;
  _Bool D.32643;
  long int D.32644;
  long int D.32645;
  struct MonoClass * D.32648;
  _Bool D.32653;
  long int D.32654;
  long int D.32655;
  struct MonoType * norm_type;
  struct MonoReflectionType * res;
  struct MonoClass * klass;

  klass = mono_class_from_mono_type (type);
  D.32516 = klass->byval_arg.byref;
  D.32517 = type->byref;
  if (D.32516 == D.32517) goto <D.32518>; else goto <D.32519>;
  <D.32518>:
  iftmp.282 = &klass->byval_arg;
  goto <D.32520>;
  <D.32519>:
  iftmp.282 = &klass->this_arg;
  <D.32520>:
  type = iftmp.282;
  D.32521 = type->type;
  if (D.32521 == 1) goto <D.32522>; else goto <D.32523>;
  <D.32522>:
  D.32524 = domain->typeof_void;
  if (D.32524 != 0B) goto <D.32525>; else goto <D.32526>;
  <D.32525>:
  D.32527 = domain->typeof_void;
  return D.32527;
  <D.32526>:
  <D.32523>:
  D.32528 = &klass->byval_arg;
  if (D.32528 == type) goto <D.32529>; else goto <D.32530>;
  <D.32529>:
  D.32531 = klass->image;
  D.32532 = BIT_FIELD_REF <*D.32531, 8, 224>;
  D.32533 = D.32532 & 8;
  if (D.32533 == 0) goto <D.32534>; else goto <D.32535>;
  <D.32534>:
  {
    struct MonoVTable * vtable;

    vtable = mono_class_try_get_vtable (domain, klass);
    if (vtable != 0B) goto <D.32536>; else goto <D.32537>;
    <D.32536>:
    D.32538 = vtable->type;
    if (D.32538 != 0B) goto <D.32539>; else goto <D.32540>;
    <D.32539>:
    D.32527 = vtable->type;
    return D.32527;
    <D.32540>:
    <D.32537>:
  }
  <D.32535>:
  <D.32530>:
  mono_loader_lock ();
  {
    int ret;

    D.32541 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32541);
    if (ret != 0) goto <D.32542>; else goto <D.32543>;
    <D.32542>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32543>:
    D.32544 = ret != 0;
    D.32545 = (long int) D.32544;
    D.32546 = __builtin_expect (D.32545, 0);
    if (D.32546 != 0) goto <D.32547>; else goto <D.32548>;
    <D.32547>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6462, "ret == 0");
    <D.32548>:
  }
  D.32549 = domain->type_hash;
  if (D.32549 == 0B) goto <D.32550>; else goto <D.32551>;
  <D.32550>:
  D.32552 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.32552;
  <D.32551>:
  D.32549 = domain->type_hash;
  res = mono_g_hash_table_lookup (D.32549, type);
  if (res != 0B) goto <D.32553>; else goto <D.32554>;
  <D.32553>:
  {
    int ret;

    D.32541 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32541);
    if (ret != 0) goto <D.32555>; else goto <D.32556>;
    <D.32555>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32556>:
    D.32557 = ret != 0;
    D.32558 = (long int) D.32557;
    D.32559 = __builtin_expect (D.32558, 0);
    if (D.32559 != 0) goto <D.32560>; else goto <D.32561>;
    <D.32560>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6467, "ret == 0");
    <D.32561>:
  }
  mono_loader_unlock ();
  D.32527 = res;
  return D.32527;
  <D.32554>:
  norm_type = mono_type_normalize (type);
  if (norm_type != type) goto <D.32562>; else goto <D.32563>;
  <D.32562>:
  res = mono_type_get_object (domain, norm_type);
  D.32549 = domain->type_hash;
  mono_g_hash_table_insert (D.32549, type, res);
  {
    int ret;

    D.32541 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32541);
    if (ret != 0) goto <D.32564>; else goto <D.32565>;
    <D.32564>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32565>:
    D.32566 = ret != 0;
    D.32567 = (long int) D.32566;
    D.32568 = __builtin_expect (D.32567, 0);
    if (D.32568 != 0) goto <D.32569>; else goto <D.32570>;
    <D.32569>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6483, "ret == 0");
    <D.32570>:
  }
  mono_loader_unlock ();
  D.32527 = res;
  return D.32527;
  <D.32563>:
  D.32521 = type->type;
  if (D.32521 == 21) goto <D.32571>; else goto <D.32572>;
  <D.32571>:
  D.32573 = type->data.generic_class;
  D.32574 = BIT_FIELD_REF <*D.32573, 8, 192>;
  D.32575 = D.32574 & 1;
  if (D.32575 != 0) goto <D.32576>; else goto <D.32577>;
  <D.32576>:
  D.32573 = type->data.generic_class;
  D.32578 = D.32573->container_class;
  D.32579 = BIT_FIELD_REF <*D.32578, 8, 256>;
  D.32580 = D.32579 & 128;
  if (D.32580 == 0) goto <D.32581>; else goto <D.32582>;
  <D.32581>:
  if (1 != 0) goto <D.32583>; else goto <D.32584>;
  <D.32583>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6490, "0");
  <D.32584>:
  <D.32582>:
  <D.32577>:
  <D.32572>:
  D.32585 = verify_safe_for_managed_space (type);
  if (D.32585 == 0) goto <D.32586>; else goto <D.32587>;
  <D.32586>:
  {
    int ret;

    D.32541 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32541);
    if (ret != 0) goto <D.32588>; else goto <D.32589>;
    <D.32588>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32589>:
    D.32590 = ret != 0;
    D.32591 = (long int) D.32590;
    D.32592 = __builtin_expect (D.32591, 0);
    if (D.32592 != 0) goto <D.32593>; else goto <D.32594>;
    <D.32593>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6493, "ret == 0");
    <D.32594>:
  }
  mono_loader_unlock ();
  D.32595 = mono_get_exception_invalid_operation ("This type cannot be propagated to managed space");
  mono_raise_exception (D.32595);
  <D.32587>:
  D.32596 = mono_class_get_ref_info (klass);
  if (D.32596 != 0B) goto <D.32597>; else goto <D.32598>;
  <D.32597>:
  D.32599 = BIT_FIELD_REF <*klass, 8, 256>;
  D.32600 = D.32599 & 128;
  if (D.32600 == 0) goto <D.32601>; else goto <D.32602>;
  <D.32601>:
  {
    gboolean is_type_done;

    is_type_done = 1;
    D.32603 = klass->byval_arg.type;
    D.32604 = D.32603 == 30;
    D.32605 = D.32603 == 19;
    D.32606 = D.32604 | D.32605;
    if (D.32606 != 0) goto <D.32607>; else goto <D.32608>;
    <D.32607>:
    {
      struct MonoGenericParam * gparam;

      gparam = klass->byval_arg.data.generic_param;
      D.32611 = gparam->owner;
      if (D.32611 != 0B) goto <D.32612>; else goto <D.32609>;
      <D.32612>:
      D.32611 = gparam->owner;
      D.32613 = BIT_FIELD_REF <*D.32611, 8, 280>;
      D.32614 = D.32613 & 128;
      if (D.32614 != 0) goto <D.32615>; else goto <D.32609>;
      <D.32615>:
      {
        struct MonoMethod * method;

        D.32611 = gparam->owner;
        method = D.32611->owner.method;
        if (method != 0B) goto <D.32616>; else goto <D.32617>;
        <D.32616>:
        D.32618 = method->klass;
        D.32619 = mono_class_get_generic_type_definition (D.32618);
        D.32620 = BIT_FIELD_REF <*D.32619, 8, 256>;
        D.32621 = D.32620 & 128;
        if (D.32621 != 0) goto <D.32622>; else goto <D.32623>;
        <D.32622>:
        is_type_done = 0;
        <D.32623>:
        <D.32617>:
      }
      goto <D.32610>;
      <D.32609>:
      D.32611 = gparam->owner;
      if (D.32611 != 0B) goto <D.32624>; else goto <D.32625>;
      <D.32624>:
      D.32611 = gparam->owner;
      D.32613 = BIT_FIELD_REF <*D.32611, 8, 280>;
      D.32614 = D.32613 & 128;
      if (D.32614 == 0) goto <D.32626>; else goto <D.32627>;
      <D.32626>:
      {
        struct MonoClass * klass;

        D.32611 = gparam->owner;
        klass = D.32611->owner.klass;
        if (klass != 0B) goto <D.32628>; else goto <D.32629>;
        <D.32628>:
        D.32630 = mono_class_get_generic_type_definition (klass);
        D.32631 = BIT_FIELD_REF <*D.32630, 8, 256>;
        D.32632 = D.32631 & 128;
        if (D.32632 != 0) goto <D.32633>; else goto <D.32634>;
        <D.32633>:
        is_type_done = 0;
        <D.32634>:
        <D.32629>:
      }
      <D.32627>:
      <D.32625>:
      <D.32610>:
    }
    <D.32608>:
    if (is_type_done != 0) goto <D.32635>; else goto <D.32636>;
    <D.32635>:
    D.32637 = BIT_FIELD_REF <*type, 8, 88>;
    D.32638 = D.32637 & 64;
    if (D.32638 == 0) goto <D.32639>; else goto <D.32640>;
    <D.32639>:
    {
      int ret;

      D.32541 = &domain->lock.mutex;
      ret = pthread_mutex_unlock (D.32541);
      if (ret != 0) goto <D.32641>; else goto <D.32642>;
      <D.32641>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.32642>:
      D.32643 = ret != 0;
      D.32644 = (long int) D.32643;
      D.32645 = __builtin_expect (D.32644, 0);
      if (D.32645 != 0) goto <D.32646>; else goto <D.32647>;
      <D.32646>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6521, "ret == 0");
      <D.32647>:
    }
    mono_loader_unlock ();
    D.32527 = mono_class_get_ref_info (klass);
    return D.32527;
    <D.32640>:
    <D.32636>:
  }
  <D.32602>:
  <D.32598>:
  D.32648 = mono_defaults.monotype_class;
  res = mono_object_new_pinned (domain, D.32648);
  res->type = type;
  D.32549 = domain->type_hash;
  mono_g_hash_table_insert (D.32549, type, res);
  D.32521 = type->type;
  if (D.32521 == 1) goto <D.32649>; else goto <D.32650>;
  <D.32649>:
  domain->typeof_void = res;
  <D.32650>:
  {
    int ret;

    D.32541 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32541);
    if (ret != 0) goto <D.32651>; else goto <D.32652>;
    <D.32651>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.32652>:
    D.32653 = ret != 0;
    D.32654 = (long int) D.32653;
    D.32655 = __builtin_expect (D.32654, 0);
    if (D.32655 != 0) goto <D.32656>; else goto <D.32657>;
    <D.32656>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6534, "ret == 0");
    <D.32657>:
  }
  mono_loader_unlock ();
  D.32527 = res;
  return D.32527;
}


mono_type_normalize (struct MonoType * type)
{
  unsigned char D.32659;
  struct MonoType * D.32662;
  unsigned char D.32663;
  unsigned char D.32664;
  <unnamed-unsigned:22> D.32667;
  long unsigned int D.32668;
  long unsigned int D.32669;
  unsigned char D.32672;
  struct MonoGenericParam * D.32674;
  short unsigned int D.32675;
  int D.32676;
  struct MonoGenericContainer * D.32678;
  long unsigned int D.32679;
  long unsigned int D.32680;
  struct MonoType * * D.32681;
  int D.32684;
  struct MonoType * iftmp.283;
  <unnamed-unsigned:1> D.32688;
  <unnamed-unsigned:1> D.32689;
  <unnamed-unsigned:1> D.32695;
  int D.32696;
  struct MonoType * iftmp.284;
  <unnamed-unsigned:1> D.32698;
  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.32659 = type->type;
  if (D.32659 != 21) goto <D.32660>; else goto <D.32661>;
  <D.32660>:
  D.32662 = type;
  return D.32662;
  <D.32661>:
  gclass = type->data.generic_class;
  ginst = gclass->context.class_inst;
  D.32663 = BIT_FIELD_REF <*ginst, 8, 48>;
  D.32664 = D.32663 & 64;
  if (D.32664 == 0) goto <D.32665>; else goto <D.32666>;
  <D.32665>:
  D.32662 = type;
  return D.32662;
  <D.32666>:
  gtd = gclass->container_class;
  gcontainer = gtd->generic_container;
  D.32667 = ginst->type_argc;
  D.32668 = (long unsigned int) D.32667;
  D.32669 = D.32668 * 8;
  argv = __builtin_alloca (D.32669);
  i = 0;
  goto <D.21118>;
  <D.21117>:
  {
    struct MonoType * t;
    struct MonoType * norm;

    t = ginst->type_argv[i];
    D.32672 = t->type;
    if (D.32672 != 19) goto <D.32670>; else goto <D.32673>;
    <D.32673>:
    D.32674 = t->data.generic_param;
    D.32675 = D.32674->num;
    D.32676 = (int) D.32675;
    if (D.32676 != i) goto <D.32670>; else goto <D.32677>;
    <D.32677>:
    D.32674 = t->data.generic_param;
    D.32678 = D.32674->owner;
    if (D.32678 != gcontainer) goto <D.32670>; else goto <D.32671>;
    <D.32670>:
    is_denorm_gtd = 0;
    <D.32671>:
    norm = mono_type_normalize (t);
    D.32679 = (long unsigned int) i;
    D.32680 = D.32679 * 8;
    D.32681 = argv + D.32680;
    *D.32681 = norm;
    if (norm != t) goto <D.32682>; else goto <D.32683>;
    <D.32682>:
    requires_rebind = 1;
    <D.32683>:
  }
  i = i + 1;
  <D.21118>:
  D.32667 = ginst->type_argc;
  D.32684 = (int) D.32667;
  if (D.32684 > i) goto <D.21117>; else goto <D.21119>;
  <D.21119>:
  if (is_denorm_gtd != 0) goto <D.32685>; else goto <D.32686>;
  <D.32685>:
  D.32688 = type->byref;
  D.32689 = gtd->byval_arg.byref;
  if (D.32688 == D.32689) goto <D.32690>; else goto <D.32691>;
  <D.32690>:
  iftmp.283 = &gtd->byval_arg;
  goto <D.32692>;
  <D.32691>:
  iftmp.283 = &gtd->this_arg;
  <D.32692>:
  D.32662 = iftmp.283;
  return D.32662;
  <D.32686>:
  if (requires_rebind != 0) goto <D.32693>; else goto <D.32694>;
  <D.32693>:
  {
    struct MonoClass * klass;

    D.32695 = gclass->is_dynamic;
    D.32696 = (int) D.32695;
    D.32667 = ginst->type_argc;
    D.32684 = (int) D.32667;
    klass = mono_class_bind_generic_parameters (gtd, D.32684, argv, D.32696);
    D.32688 = type->byref;
    D.32698 = klass->byval_arg.byref;
    if (D.32688 == D.32698) goto <D.32699>; else goto <D.32700>;
    <D.32699>:
    iftmp.284 = &klass->byval_arg;
    goto <D.32701>;
    <D.32700>:
    iftmp.284 = &klass->this_arg;
    <D.32701>:
    D.32662 = iftmp.284;
    return D.32662;
  }
  <D.32694>:
  D.32662 = type;
  return D.32662;
}


verify_safe_for_managed_space (struct MonoType * type)
{
  unsigned char D.32703;
  int D.32704;
  gboolean D.32705;

  D.32703 = type->type;
  D.32704 = (int) D.32703;
  switch (D.32704) <default: <D.32706>, case 19: <D.21102>, case 30: <D.21103>>
  <D.21102>:
  <D.21103>:
  D.32705 = 1;
  return D.32705;
  <D.32706>:
  D.32705 = 1;
  return D.32705;
}


mono_method_get_object (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  unsigned char D.32708;
  unsigned char D.32709;
  union mono_mutex_t * D.32712;
  _Bool D.32715;
  long int D.32716;
  long int D.32717;
  struct MonoGHashTable * D.32720;
  struct MonoGHashTable * D.32723;
  _Bool D.32728;
  long int D.32729;
  long int D.32730;
  struct MonoReflectionMethod * D.32733;
  _Bool D.32736;
  long int D.32737;
  long int D.32738;
  const char * D.32744;
  char D.32745;
  int D.21164;
  int iftmp.285;
  int D.21163;
  const char[6] * D.32750;
  unsigned char D.32751;
  int D.32752;
  unsigned char D.32753;
  int D.32754;
  _Bool D.32755;
  _Bool D.32756;
  _Bool D.32757;
  const unsigned char * D.32760;
  unsigned char D.32761;
  int D.32762;
  const unsigned char * D.32763;
  unsigned char D.32764;
  int D.32765;
  _Bool D.32766;
  _Bool D.32767;
  const unsigned char * D.32770;
  unsigned char D.32771;
  int D.32772;
  const unsigned char * D.32773;
  unsigned char D.32774;
  int D.32775;
  _Bool D.32776;
  _Bool D.32777;
  const unsigned char * D.32780;
  unsigned char D.32781;
  int D.32782;
  const unsigned char * D.32783;
  unsigned char D.32784;
  int D.32785;
  int D.21173;
  int iftmp.286;
  int D.21172;
  const char[7] * D.32791;
  unsigned char D.32792;
  int D.32793;
  unsigned char D.32794;
  int D.32795;
  _Bool D.32796;
  _Bool D.32797;
  _Bool D.32798;
  const unsigned char * D.32801;
  unsigned char D.32802;
  int D.32803;
  const unsigned char * D.32804;
  unsigned char D.32805;
  int D.32806;
  _Bool D.32807;
  _Bool D.32808;
  const unsigned char * D.32811;
  unsigned char D.32812;
  int D.32813;
  const unsigned char * D.32814;
  unsigned char D.32815;
  int D.32816;
  _Bool D.32817;
  _Bool D.32818;
  const unsigned char * D.32821;
  unsigned char D.32822;
  int D.32823;
  const unsigned char * D.32824;
  unsigned char D.32825;
  int D.32826;
  struct MonoClass * System_Reflection_MonoGenericCMethod.287;
  struct MonoImage * D.32831;
  struct MonoClass * System_Reflection_MonoGenericCMethod.288;
  struct MonoClass * System_Reflection_MonoGenericMethod.289;
  struct MonoClass * System_Reflection_MonoGenericMethod.290;
  struct MonoString * D.32837;
  struct MonoString * * D.32838;
  struct MonoType * D.32839;
  struct MonoReflectionType * D.32840;
  struct MonoReflectionType * * D.32841;
  _Bool D.32844;
  long int D.32845;
  long int D.32846;
  struct MonoGHashTable * D.32851;
  struct MonoMemPool * D.32854;
  _Bool D.32857;
  long int D.32858;
  long int D.32859;
  _Bool D.32866;
  long int D.32867;
  long int D.32868;
  struct MonoGHashTable * D.32873;
  _Bool D.32878;
  long int D.32879;
  long int D.32880;
  _Bool D.32885;
  long int D.32886;
  long int D.32887;
  int D.21192;
  int iftmp.291;
  int D.21191;
  unsigned char D.32897;
  int D.32898;
  _Bool D.32899;
  _Bool D.32900;
  _Bool D.32901;
  const unsigned char * D.32904;
  unsigned char D.32905;
  int D.32906;
  _Bool D.32907;
  _Bool D.32908;
  const unsigned char * D.32911;
  unsigned char D.32912;
  int D.32913;
  _Bool D.32914;
  _Bool D.32915;
  const unsigned char * D.32918;
  unsigned char D.32919;
  int D.32920;
  int D.21201;
  int iftmp.292;
  int D.21200;
  unsigned char D.32926;
  int D.32927;
  _Bool D.32928;
  _Bool D.32929;
  _Bool D.32930;
  const unsigned char * D.32933;
  unsigned char D.32934;
  int D.32935;
  _Bool D.32936;
  _Bool D.32937;
  const unsigned char * D.32940;
  unsigned char D.32941;
  int D.32942;
  _Bool D.32943;
  _Bool D.32944;
  const unsigned char * D.32947;
  unsigned char D.32948;
  int D.32949;
  struct MonoClass * System_Reflection_MonoCMethod.293;
  struct MonoClass * System_Reflection_MonoCMethod.294;
  struct MonoClass * System_Reflection_MonoMethod.295;
  struct MonoClass * System_Reflection_MonoMethod.296;
  struct MonoReflectionType * D.32959;
  struct MonoReflectionType * * D.32960;
  _Bool D.32963;
  long int D.32964;
  long int D.32965;
  struct MonoGHashTable * D.32970;
  _Bool D.32975;
  long int D.32976;
  long int D.32977;
  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.32708 = BIT_FIELD_REF <*method, 8, 264>;
  D.32709 = D.32708 & 16;
  if (D.32709 != 0) goto <D.32710>; else goto <D.32711>;
  <D.32710>:
  {
    struct MonoReflectionGenericMethod * gret;

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

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

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

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

            D.32712 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.32712);
            if (ret != 0) goto <D.32734>; else goto <D.32735>;
            <D.32734>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.32735>:
            D.32736 = ret != 0;
            D.32737 = (long int) D.32736;
            D.32738 = __builtin_expect (D.32737, 0);
            if (D.32738 != 0) goto <D.32739>; else goto <D.32740>;
            <D.32739>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6565, "ret == 0");
            <D.32740>:
          }
        }
      finally
        {
          e = {CLOBBER};
        }
    }
    D.32744 = method->name;
    D.32745 = *D.32744;
    if (D.32745 == 46) goto <D.32746>; else goto <D.32741>;
    <D.32746>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.32750 = ".ctor";
        D.32751 = MEM[(const unsigned char *)D.32750];
        D.32752 = (int) D.32751;
        D.32753 = *__s2;
        D.32754 = (int) D.32753;
        __result = D.32752 - D.32754;
        {
          D.32755 = __s2_len != 0;
          D.32756 = __result == 0;
          D.32757 = D.32755 & D.32756;
          if (D.32757 != 0) goto <D.32758>; else goto <D.32759>;
          <D.32758>:
          D.32760 = &MEM[(void *)".ctor" + 1B];
          D.32761 = *D.32760;
          D.32762 = (int) D.32761;
          D.32763 = __s2 + 1;
          D.32764 = *D.32763;
          D.32765 = (int) D.32764;
          __result = D.32762 - D.32765;
          D.32766 = __s2_len > 1;
          D.32756 = __result == 0;
          D.32767 = D.32766 & D.32756;
          if (D.32767 != 0) goto <D.32768>; else goto <D.32769>;
          <D.32768>:
          D.32770 = &MEM[(void *)".ctor" + 2B];
          D.32771 = *D.32770;
          D.32772 = (int) D.32771;
          D.32773 = __s2 + 2;
          D.32774 = *D.32773;
          D.32775 = (int) D.32774;
          __result = D.32772 - D.32775;
          D.32776 = __s2_len > 2;
          D.32756 = __result == 0;
          D.32777 = D.32776 & D.32756;
          if (D.32777 != 0) goto <D.32778>; else goto <D.32779>;
          <D.32778>:
          D.32780 = &MEM[(void *)".ctor" + 3B];
          D.32781 = *D.32780;
          D.32782 = (int) D.32781;
          D.32783 = __s2 + 3;
          D.32784 = *D.32783;
          D.32785 = (int) D.32784;
          __result = D.32782 - D.32785;
          <D.32779>:
          <D.32769>:
          <D.32759>:
        }
        D.21163 = __result;
      }
      iftmp.285 = -D.21163;
      goto <D.32786>;
      <D.32749>:
      D.32744 = method->name;
      iftmp.285 = __builtin_strcmp (D.32744, ".ctor");
      <D.32786>:
      D.21164 = iftmp.285;
    }
    if (D.21164 == 0) goto <D.32742>; else goto <D.32787>;
    <D.32787>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = method->name;
        D.32791 = ".cctor";
        D.32792 = MEM[(const unsigned char *)D.32791];
        D.32793 = (int) D.32792;
        D.32794 = *__s2;
        D.32795 = (int) D.32794;
        __result = D.32793 - D.32795;
        {
          D.32796 = __s2_len != 0;
          D.32797 = __result == 0;
          D.32798 = D.32796 & D.32797;
          if (D.32798 != 0) goto <D.32799>; else goto <D.32800>;
          <D.32799>:
          D.32801 = &MEM[(void *)".cctor" + 1B];
          D.32802 = *D.32801;
          D.32803 = (int) D.32802;
          D.32804 = __s2 + 1;
          D.32805 = *D.32804;
          D.32806 = (int) D.32805;
          __result = D.32803 - D.32806;
          D.32807 = __s2_len > 1;
          D.32797 = __result == 0;
          D.32808 = D.32807 & D.32797;
          if (D.32808 != 0) goto <D.32809>; else goto <D.32810>;
          <D.32809>:
          D.32811 = &MEM[(void *)".cctor" + 2B];
          D.32812 = *D.32811;
          D.32813 = (int) D.32812;
          D.32814 = __s2 + 2;
          D.32815 = *D.32814;
          D.32816 = (int) D.32815;
          __result = D.32813 - D.32816;
          D.32817 = __s2_len > 2;
          D.32797 = __result == 0;
          D.32818 = D.32817 & D.32797;
          if (D.32818 != 0) goto <D.32819>; else goto <D.32820>;
          <D.32819>:
          D.32821 = &MEM[(void *)".cctor" + 3B];
          D.32822 = *D.32821;
          D.32823 = (int) D.32822;
          D.32824 = __s2 + 3;
          D.32825 = *D.32824;
          D.32826 = (int) D.32825;
          __result = D.32823 - D.32826;
          <D.32820>:
          <D.32810>:
          <D.32800>:
        }
        D.21172 = __result;
      }
      iftmp.286 = -D.21172;
      goto <D.32827>;
      <D.32790>:
      D.32744 = method->name;
      iftmp.286 = __builtin_strcmp (D.32744, ".cctor");
      <D.32827>:
      D.21173 = iftmp.286;
    }
    if (D.21173 == 0) goto <D.32742>; else goto <D.32741>;
    <D.32742>:
    System_Reflection_MonoGenericCMethod.287 = System_Reflection_MonoGenericCMethod;
    if (System_Reflection_MonoGenericCMethod.287 == 0B) goto <D.32829>; else goto <D.32830>;
    <D.32829>:
    D.32831 = mono_defaults.corlib;
    System_Reflection_MonoGenericCMethod.288 = mono_class_from_name (D.32831, "System.Reflection", "MonoGenericCMethod");
    System_Reflection_MonoGenericCMethod = System_Reflection_MonoGenericCMethod.288;
    <D.32830>:
    klass = System_Reflection_MonoGenericCMethod;
    goto <D.32743>;
    <D.32741>:
    System_Reflection_MonoGenericMethod.289 = System_Reflection_MonoGenericMethod;
    if (System_Reflection_MonoGenericMethod.289 == 0B) goto <D.32834>; else goto <D.32835>;
    <D.32834>:
    D.32831 = mono_defaults.corlib;
    System_Reflection_MonoGenericMethod.290 = mono_class_from_name (D.32831, "System.Reflection", "MonoGenericMethod");
    System_Reflection_MonoGenericMethod = System_Reflection_MonoGenericMethod.290;
    <D.32835>:
    klass = System_Reflection_MonoGenericMethod;
    <D.32743>:
    gret = mono_object_new (domain, klass);
    gret->method.method = method;
    D.32744 = method->name;
    D.32837 = mono_string_new (domain, D.32744);
    D.32838 = &gret->method.name;
    mono_gc_wbarrier_set_field (gret, D.32838, D.32837);
    D.32839 = &refclass->byval_arg;
    D.32840 = mono_type_get_object (domain, D.32839);
    D.32841 = &gret->method.reftype;
    mono_gc_wbarrier_set_field (gret, D.32841, D.32840);
    {
      struct MonoReflectionMethod * _obj;
      struct ReflectedEntry pe;

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

            D.32712 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.32712);
            if (ret != 0) goto <D.32842>; else goto <D.32843>;
            <D.32842>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.32843>:
            D.32844 = ret != 0;
            D.32845 = (long int) D.32844;
            D.32846 = __builtin_expect (D.32845, 0);
            if (D.32846 != 0) goto <D.32847>; else goto <D.32848>;
            <D.32847>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.32848>:
          }
          D.32720 = domain->refobject_hash;
          if (D.32720 == 0B) goto <D.32849>; else goto <D.32850>;
          <D.32849>:
          D.32851 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
          domain->refobject_hash = D.32851;
          <D.32850>:
          D.32720 = domain->refobject_hash;
          _obj = mono_g_hash_table_lookup (D.32720, &pe);
          if (_obj == 0B) goto <D.32852>; else goto <D.32853>;
          <D.32852>:
          {
            struct ReflectedEntry * e;

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

            D.32712 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.32712);
            if (ret != 0) goto <D.32855>; else goto <D.32856>;
            <D.32855>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.32856>:
            D.32857 = ret != 0;
            D.32858 = (long int) D.32857;
            D.32859 = __builtin_expect (D.32858, 0);
            if (D.32859 != 0) goto <D.32860>; else goto <D.32861>;
            <D.32860>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6579, "ret == 0");
            <D.32861>:
          }
          D.32733 = _obj;
          return D.32733;
        }
      finally
        {
          pe = {CLOBBER};
        }
    }
  }
  <D.32711>:
  if (refclass == 0B) goto <D.32862>; else goto <D.32863>;
  <D.32862>:
  refclass = method->klass;
  <D.32863>:
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry e;

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

          D.32712 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32712);
          if (ret != 0) goto <D.32864>; else goto <D.32865>;
          <D.32864>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32865>:
          D.32866 = ret != 0;
          D.32867 = (long int) D.32866;
          D.32868 = __builtin_expect (D.32867, 0);
          if (D.32868 != 0) goto <D.32869>; else goto <D.32870>;
          <D.32869>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32870>:
        }
        D.32720 = domain->refobject_hash;
        if (D.32720 == 0B) goto <D.32871>; else goto <D.32872>;
        <D.32871>:
        D.32873 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32873;
        <D.32872>:
        D.32720 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32720, &e);
        if (_obj != 0B) goto <D.32874>; else goto <D.32875>;
        <D.32874>:
        {
          int ret;

          D.32712 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32712);
          if (ret != 0) goto <D.32876>; else goto <D.32877>;
          <D.32876>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32877>:
          D.32878 = ret != 0;
          D.32879 = (long int) D.32878;
          D.32880 = __builtin_expect (D.32879, 0);
          if (D.32880 != 0) goto <D.32881>; else goto <D.32882>;
          <D.32881>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32882>:
        }
        D.32733 = _obj;
        return D.32733;
        <D.32875>:
        {
          int ret;

          D.32712 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32712);
          if (ret != 0) goto <D.32883>; else goto <D.32884>;
          <D.32883>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32884>:
          D.32885 = ret != 0;
          D.32886 = (long int) D.32885;
          D.32887 = __builtin_expect (D.32886, 0);
          if (D.32887 != 0) goto <D.32888>; else goto <D.32889>;
          <D.32888>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6585, "ret == 0");
          <D.32889>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.32744 = method->name;
  D.32745 = *D.32744;
  if (D.32745 == 46) goto <D.32893>; else goto <D.32890>;
  <D.32893>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32750 = ".ctor";
      D.32751 = MEM[(const unsigned char *)D.32750];
      D.32752 = (int) D.32751;
      D.32897 = *__s2;
      D.32898 = (int) D.32897;
      __result = D.32752 - D.32898;
      {
        D.32899 = __s2_len != 0;
        D.32900 = __result == 0;
        D.32901 = D.32899 & D.32900;
        if (D.32901 != 0) goto <D.32902>; else goto <D.32903>;
        <D.32902>:
        D.32760 = &MEM[(void *)".ctor" + 1B];
        D.32761 = *D.32760;
        D.32762 = (int) D.32761;
        D.32904 = __s2 + 1;
        D.32905 = *D.32904;
        D.32906 = (int) D.32905;
        __result = D.32762 - D.32906;
        D.32907 = __s2_len > 1;
        D.32900 = __result == 0;
        D.32908 = D.32907 & D.32900;
        if (D.32908 != 0) goto <D.32909>; else goto <D.32910>;
        <D.32909>:
        D.32770 = &MEM[(void *)".ctor" + 2B];
        D.32771 = *D.32770;
        D.32772 = (int) D.32771;
        D.32911 = __s2 + 2;
        D.32912 = *D.32911;
        D.32913 = (int) D.32912;
        __result = D.32772 - D.32913;
        D.32914 = __s2_len > 2;
        D.32900 = __result == 0;
        D.32915 = D.32914 & D.32900;
        if (D.32915 != 0) goto <D.32916>; else goto <D.32917>;
        <D.32916>:
        D.32780 = &MEM[(void *)".ctor" + 3B];
        D.32781 = *D.32780;
        D.32782 = (int) D.32781;
        D.32918 = __s2 + 3;
        D.32919 = *D.32918;
        D.32920 = (int) D.32919;
        __result = D.32782 - D.32920;
        <D.32917>:
        <D.32910>:
        <D.32903>:
      }
      D.21191 = __result;
    }
    iftmp.291 = -D.21191;
    goto <D.32921>;
    <D.32896>:
    D.32744 = method->name;
    iftmp.291 = __builtin_strcmp (D.32744, ".ctor");
    <D.32921>:
    D.21192 = iftmp.291;
  }
  if (D.21192 == 0) goto <D.32891>; else goto <D.32922>;
  <D.32922>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.32791 = ".cctor";
      D.32792 = MEM[(const unsigned char *)D.32791];
      D.32793 = (int) D.32792;
      D.32926 = *__s2;
      D.32927 = (int) D.32926;
      __result = D.32793 - D.32927;
      {
        D.32928 = __s2_len != 0;
        D.32929 = __result == 0;
        D.32930 = D.32928 & D.32929;
        if (D.32930 != 0) goto <D.32931>; else goto <D.32932>;
        <D.32931>:
        D.32801 = &MEM[(void *)".cctor" + 1B];
        D.32802 = *D.32801;
        D.32803 = (int) D.32802;
        D.32933 = __s2 + 1;
        D.32934 = *D.32933;
        D.32935 = (int) D.32934;
        __result = D.32803 - D.32935;
        D.32936 = __s2_len > 1;
        D.32929 = __result == 0;
        D.32937 = D.32936 & D.32929;
        if (D.32937 != 0) goto <D.32938>; else goto <D.32939>;
        <D.32938>:
        D.32811 = &MEM[(void *)".cctor" + 2B];
        D.32812 = *D.32811;
        D.32813 = (int) D.32812;
        D.32940 = __s2 + 2;
        D.32941 = *D.32940;
        D.32942 = (int) D.32941;
        __result = D.32813 - D.32942;
        D.32943 = __s2_len > 2;
        D.32929 = __result == 0;
        D.32944 = D.32943 & D.32929;
        if (D.32944 != 0) goto <D.32945>; else goto <D.32946>;
        <D.32945>:
        D.32821 = &MEM[(void *)".cctor" + 3B];
        D.32822 = *D.32821;
        D.32823 = (int) D.32822;
        D.32947 = __s2 + 3;
        D.32948 = *D.32947;
        D.32949 = (int) D.32948;
        __result = D.32823 - D.32949;
        <D.32946>:
        <D.32939>:
        <D.32932>:
      }
      D.21200 = __result;
    }
    iftmp.292 = -D.21200;
    goto <D.32950>;
    <D.32925>:
    D.32744 = method->name;
    iftmp.292 = __builtin_strcmp (D.32744, ".cctor");
    <D.32950>:
    D.21201 = iftmp.292;
  }
  if (D.21201 == 0) goto <D.32891>; else goto <D.32890>;
  <D.32891>:
  System_Reflection_MonoCMethod.293 = System_Reflection_MonoCMethod;
  if (System_Reflection_MonoCMethod.293 == 0B) goto <D.32952>; else goto <D.32953>;
  <D.32952>:
  D.32831 = mono_defaults.corlib;
  System_Reflection_MonoCMethod.294 = mono_class_from_name (D.32831, "System.Reflection", "MonoCMethod");
  System_Reflection_MonoCMethod = System_Reflection_MonoCMethod.294;
  <D.32953>:
  klass = System_Reflection_MonoCMethod;
  goto <D.32892>;
  <D.32890>:
  System_Reflection_MonoMethod.295 = System_Reflection_MonoMethod;
  if (System_Reflection_MonoMethod.295 == 0B) goto <D.32956>; else goto <D.32957>;
  <D.32956>:
  D.32831 = mono_defaults.corlib;
  System_Reflection_MonoMethod.296 = mono_class_from_name (D.32831, "System.Reflection", "MonoMethod");
  System_Reflection_MonoMethod = System_Reflection_MonoMethod.296;
  <D.32957>:
  klass = System_Reflection_MonoMethod;
  <D.32892>:
  ret = mono_object_new (domain, klass);
  ret->method = method;
  D.32839 = &refclass->byval_arg;
  D.32959 = mono_type_get_object (domain, D.32839);
  D.32960 = &ret->reftype;
  mono_gc_wbarrier_set_field (ret, D.32960, D.32959);
  {
    struct MonoReflectionMethod * _obj;
    struct ReflectedEntry pe;

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

          D.32712 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.32712);
          if (ret != 0) goto <D.32961>; else goto <D.32962>;
          <D.32961>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.32962>:
          D.32963 = ret != 0;
          D.32964 = (long int) D.32963;
          D.32965 = __builtin_expect (D.32964, 0);
          if (D.32965 != 0) goto <D.32966>; else goto <D.32967>;
          <D.32966>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32967>:
        }
        D.32720 = domain->refobject_hash;
        if (D.32720 == 0B) goto <D.32968>; else goto <D.32969>;
        <D.32968>:
        D.32970 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.32970;
        <D.32969>:
        D.32720 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.32720, &pe);
        if (_obj == 0B) goto <D.32971>; else goto <D.32972>;
        <D.32971>:
        {
          struct ReflectedEntry * e;

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

          D.32712 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.32712);
          if (ret != 0) goto <D.32973>; else goto <D.32974>;
          <D.32973>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.32974>:
          D.32975 = ret != 0;
          D.32976 = (long int) D.32975;
          D.32977 = __builtin_expect (D.32976, 0);
          if (D.32977 != 0) goto <D.32978>; else goto <D.32979>;
          <D.32978>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6599, "ret == 0");
          <D.32979>:
        }
        D.32733 = _obj;
        return D.32733;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_method_clear_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.32987;
  unsigned char D.32988;
  _Bool D.32989;
  long int D.32990;
  long int D.32991;
  struct MonoMethodSignature * * D.32994;
  struct MonoClass * klass;

  D.32987 = BIT_FIELD_REF <*method, 8, 264>;
  D.32988 = D.32987 & 2;
  D.32989 = D.32988 == 0;
  D.32990 = (long int) D.32989;
  D.32991 = __builtin_expect (D.32990, 0);
  if (D.32991 != 0) goto <D.32992>; else goto <D.32993>;
  <D.32992>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6611, "method->dynamic");
  <D.32993>:
  klass = method->klass;
  goto <D.21213>;
  <D.21212>:
  clear_cached_object (domain, method, klass);
  klass = klass->parent;
  <D.21213>:
  if (klass != 0B) goto <D.21212>; else goto <D.21214>;
  <D.21214>:
  D.32994 = &method->signature;
  clear_cached_object (domain, D.32994, 0B);
  klass = method->klass;
  goto <D.21216>;
  <D.21215>:
  D.32994 = &method->signature;
  clear_cached_object (domain, D.32994, klass);
  klass = klass->parent;
  <D.21216>:
  if (klass != 0B) goto <D.21215>; else goto <D.21217>;
  <D.21217>:
}


clear_cached_object (struct MonoDomain * domain, void * o, struct MonoClass * klass)
{
  union mono_mutex_t * D.32995;
  _Bool D.32998;
  long int D.32999;
  long int D.33000;
  struct MonoGHashTable * D.33003;
  int D.33006;
  _Bool D.33011;
  long int D.33012;
  long int D.33013;

  {
    int ret;

    D.32995 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.32995);
    if (ret != 0) goto <D.32996>; else goto <D.32997>;
    <D.32996>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.32997>:
    D.32998 = ret != 0;
    D.32999 = (long int) D.32998;
    D.33000 = __builtin_expect (D.32999, 0);
    if (D.33000 != 0) goto <D.33001>; else goto <D.33002>;
    <D.33001>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6127, "ret == 0");
    <D.33002>:
  }
  D.33003 = domain->refobject_hash;
  if (D.33003 != 0B) goto <D.33004>; else goto <D.33005>;
  <D.33004>:
  {
    struct ReflectedEntry pe;
    void * orig_pe;
    void * orig_value;

    try
      {
        pe.item = o;
        pe.refclass = klass;
        D.33003 = domain->refobject_hash;
        D.33006 = mono_g_hash_table_lookup_extended (D.33003, &pe, &orig_pe, &orig_value);
        if (D.33006 != 0) goto <D.33007>; else goto <D.33008>;
        <D.33007>:
        D.33003 = domain->refobject_hash;
        mono_g_hash_table_remove (D.33003, &pe);
        <D.33008>:
      }
    finally
      {
        pe = {CLOBBER};
        orig_pe = {CLOBBER};
        orig_value = {CLOBBER};
      }
  }
  <D.33005>:
  {
    int ret;

    D.32995 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.32995);
    if (ret != 0) goto <D.33009>; else goto <D.33010>;
    <D.33009>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.33010>:
    D.33011 = ret != 0;
    D.33012 = (long int) D.33011;
    D.33013 = __builtin_expect (D.33012, 0);
    if (D.33013 != 0) goto <D.33014>; else goto <D.33015>;
    <D.33014>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6139, "ret == 0");
    <D.33015>:
  }
}


mono_field_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoClassField * field)
{
  union mono_mutex_t * D.33016;
  _Bool D.33019;
  long int D.33020;
  long int D.33021;
  struct MonoGHashTable * D.33024;
  struct MonoGHashTable * D.33027;
  _Bool D.33032;
  long int D.33033;
  long int D.33034;
  struct MonoReflectionField * D.33037;
  _Bool D.33040;
  long int D.33041;
  long int D.33042;
  struct MonoClass * monofield_klass.297;
  struct MonoImage * D.33048;
  struct MonoClass * monofield_klass.298;
  const char * D.33050;
  struct MonoString * D.33051;
  struct MonoString * * D.33052;
  int D.33053;
  struct MonoType * D.33056;
  short unsigned int D.33057;
  unsigned int D.33058;
  struct MonoType * D.33059;
  struct MonoReflectionType * D.33060;
  struct MonoReflectionType * * D.33061;
  struct MonoReflectionType * D.33065;
  unsigned int D.33066;
  _Bool D.33069;
  long int D.33070;
  long int D.33071;
  struct MonoGHashTable * D.33076;
  struct MonoMemPool * D.33079;
  _Bool D.33082;
  long int D.33083;
  long int D.33084;
  struct MonoReflectionField * res;
  static struct MonoClass * monofield_klass;

  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry e;

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

          D.33016 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33016);
          if (ret != 0) goto <D.33017>; else goto <D.33018>;
          <D.33017>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33018>:
          D.33019 = ret != 0;
          D.33020 = (long int) D.33019;
          D.33021 = __builtin_expect (D.33020, 0);
          if (D.33021 != 0) goto <D.33022>; else goto <D.33023>;
          <D.33022>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33023>:
        }
        D.33024 = domain->refobject_hash;
        if (D.33024 == 0B) goto <D.33025>; else goto <D.33026>;
        <D.33025>:
        D.33027 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33027;
        <D.33026>:
        D.33024 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33024, &e);
        if (_obj != 0B) goto <D.33028>; else goto <D.33029>;
        <D.33028>:
        {
          int ret;

          D.33016 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33016);
          if (ret != 0) goto <D.33030>; else goto <D.33031>;
          <D.33030>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33031>:
          D.33032 = ret != 0;
          D.33033 = (long int) D.33032;
          D.33034 = __builtin_expect (D.33033, 0);
          if (D.33034 != 0) goto <D.33035>; else goto <D.33036>;
          <D.33035>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33036>:
        }
        D.33037 = _obj;
        return D.33037;
        <D.33029>:
        {
          int ret;

          D.33016 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33016);
          if (ret != 0) goto <D.33038>; else goto <D.33039>;
          <D.33038>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33039>:
          D.33040 = ret != 0;
          D.33041 = (long int) D.33040;
          D.33042 = __builtin_expect (D.33041, 0);
          if (D.33042 != 0) goto <D.33043>; else goto <D.33044>;
          <D.33043>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6642, "ret == 0");
          <D.33044>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monofield_klass.297 = monofield_klass;
  if (monofield_klass.297 == 0B) goto <D.33046>; else goto <D.33047>;
  <D.33046>:
  D.33048 = mono_defaults.corlib;
  monofield_klass.298 = mono_class_from_name (D.33048, "System.Reflection", "MonoField");
  monofield_klass = monofield_klass.298;
  <D.33047>:
  monofield_klass.297 = monofield_klass;
  res = mono_object_new (domain, monofield_klass.297);
  res->klass = klass;
  res->field = field;
  D.33050 = mono_field_get_name (field);
  D.33051 = mono_string_new (domain, D.33050);
  D.33052 = &res->name;
  mono_gc_wbarrier_set_field (res, D.33052, D.33051);
  D.33053 = is_field_on_inst (field);
  if (D.33053 != 0) goto <D.33054>; else goto <D.33055>;
  <D.33054>:
  D.33056 = get_field_on_inst_generic_type (field);
  D.33057 = D.33056->attrs;
  D.33058 = (unsigned int) D.33057;
  res->attrs = D.33058;
  D.33059 = field->type;
  D.33060 = mono_type_get_object (domain, D.33059);
  D.33061 = &res->type;
  mono_gc_wbarrier_set_field (res, D.33061, D.33060);
  goto <D.33062>;
  <D.33055>:
  D.33059 = field->type;
  if (D.33059 != 0B) goto <D.33063>; else goto <D.33064>;
  <D.33063>:
  D.33059 = field->type;
  D.33065 = mono_type_get_object (domain, D.33059);
  D.33061 = &res->type;
  mono_gc_wbarrier_set_field (res, D.33061, D.33065);
  <D.33064>:
  D.33066 = mono_field_get_flags (field);
  res->attrs = D.33066;
  <D.33062>:
  {
    struct MonoReflectionField * _obj;
    struct ReflectedEntry pe;

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

          D.33016 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33016);
          if (ret != 0) goto <D.33067>; else goto <D.33068>;
          <D.33067>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33068>:
          D.33069 = ret != 0;
          D.33070 = (long int) D.33069;
          D.33071 = __builtin_expect (D.33070, 0);
          if (D.33071 != 0) goto <D.33072>; else goto <D.33073>;
          <D.33072>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.33073>:
        }
        D.33024 = domain->refobject_hash;
        if (D.33024 == 0B) goto <D.33074>; else goto <D.33075>;
        <D.33074>:
        D.33076 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33076;
        <D.33075>:
        D.33024 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33024, &pe);
        if (_obj == 0B) goto <D.33077>; else goto <D.33078>;
        <D.33077>:
        {
          struct ReflectedEntry * e;

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

          D.33016 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33016);
          if (ret != 0) goto <D.33080>; else goto <D.33081>;
          <D.33080>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33081>:
          D.33082 = ret != 0;
          D.33083 = (long int) D.33082;
          D.33084 = __builtin_expect (D.33083, 0);
          if (D.33084 != 0) goto <D.33085>; else goto <D.33086>;
          <D.33085>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6658, "ret == 0");
          <D.33086>:
        }
        D.33037 = _obj;
        return D.33037;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_property_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoProperty * property)
{
  union mono_mutex_t * D.33091;
  _Bool D.33094;
  long int D.33095;
  long int D.33096;
  struct MonoGHashTable * D.33099;
  struct MonoGHashTable * D.33102;
  _Bool D.33107;
  long int D.33108;
  long int D.33109;
  struct MonoReflectionProperty * D.33112;
  _Bool D.33115;
  long int D.33116;
  long int D.33117;
  struct MonoClass * monoproperty_klass.299;
  struct MonoImage * D.33123;
  struct MonoClass * monoproperty_klass.300;
  _Bool D.33127;
  long int D.33128;
  long int D.33129;
  struct MonoGHashTable * D.33134;
  struct MonoMemPool * D.33137;
  _Bool D.33140;
  long int D.33141;
  long int D.33142;
  struct MonoReflectionProperty * res;
  static struct MonoClass * monoproperty_klass;

  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry e;

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

          D.33091 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33091);
          if (ret != 0) goto <D.33092>; else goto <D.33093>;
          <D.33092>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33093>:
          D.33094 = ret != 0;
          D.33095 = (long int) D.33094;
          D.33096 = __builtin_expect (D.33095, 0);
          if (D.33096 != 0) goto <D.33097>; else goto <D.33098>;
          <D.33097>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33098>:
        }
        D.33099 = domain->refobject_hash;
        if (D.33099 == 0B) goto <D.33100>; else goto <D.33101>;
        <D.33100>:
        D.33102 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33102;
        <D.33101>:
        D.33099 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33099, &e);
        if (_obj != 0B) goto <D.33103>; else goto <D.33104>;
        <D.33103>:
        {
          int ret;

          D.33091 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33091);
          if (ret != 0) goto <D.33105>; else goto <D.33106>;
          <D.33105>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33106>:
          D.33107 = ret != 0;
          D.33108 = (long int) D.33107;
          D.33109 = __builtin_expect (D.33108, 0);
          if (D.33109 != 0) goto <D.33110>; else goto <D.33111>;
          <D.33110>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33111>:
        }
        D.33112 = _obj;
        return D.33112;
        <D.33104>:
        {
          int ret;

          D.33091 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33091);
          if (ret != 0) goto <D.33113>; else goto <D.33114>;
          <D.33113>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33114>:
          D.33115 = ret != 0;
          D.33116 = (long int) D.33115;
          D.33117 = __builtin_expect (D.33116, 0);
          if (D.33117 != 0) goto <D.33118>; else goto <D.33119>;
          <D.33118>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6676, "ret == 0");
          <D.33119>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoproperty_klass.299 = monoproperty_klass;
  if (monoproperty_klass.299 == 0B) goto <D.33121>; else goto <D.33122>;
  <D.33121>:
  D.33123 = mono_defaults.corlib;
  monoproperty_klass.300 = mono_class_from_name (D.33123, "System.Reflection", "MonoProperty");
  monoproperty_klass = monoproperty_klass.300;
  <D.33122>:
  monoproperty_klass.299 = monoproperty_klass;
  res = mono_object_new (domain, monoproperty_klass.299);
  res->klass = klass;
  res->property = property;
  {
    struct MonoReflectionProperty * _obj;
    struct ReflectedEntry pe;

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

          D.33091 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33091);
          if (ret != 0) goto <D.33125>; else goto <D.33126>;
          <D.33125>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33126>:
          D.33127 = ret != 0;
          D.33128 = (long int) D.33127;
          D.33129 = __builtin_expect (D.33128, 0);
          if (D.33129 != 0) goto <D.33130>; else goto <D.33131>;
          <D.33130>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.33131>:
        }
        D.33099 = domain->refobject_hash;
        if (D.33099 == 0B) goto <D.33132>; else goto <D.33133>;
        <D.33132>:
        D.33134 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33134;
        <D.33133>:
        D.33099 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33099, &pe);
        if (_obj == 0B) goto <D.33135>; else goto <D.33136>;
        <D.33135>:
        {
          struct ReflectedEntry * e;

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

          D.33091 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33091);
          if (ret != 0) goto <D.33138>; else goto <D.33139>;
          <D.33138>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33139>:
          D.33140 = ret != 0;
          D.33141 = (long int) D.33140;
          D.33142 = __builtin_expect (D.33141, 0);
          if (D.33142 != 0) goto <D.33143>; else goto <D.33144>;
          <D.33143>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6682, "ret == 0");
          <D.33144>:
        }
        D.33112 = _obj;
        return D.33112;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_event_get_object (struct MonoDomain * domain, struct MonoClass * klass, struct MonoEvent * event)
{
  union mono_mutex_t * D.33149;
  _Bool D.33152;
  long int D.33153;
  long int D.33154;
  struct MonoGHashTable * D.33157;
  struct MonoGHashTable * D.33160;
  _Bool D.33165;
  long int D.33166;
  long int D.33167;
  struct MonoReflectionEvent * D.33170;
  _Bool D.33173;
  long int D.33174;
  long int D.33175;
  struct MonoClass * monoevent_klass.301;
  struct MonoImage * D.33181;
  struct MonoClass * monoevent_klass.302;
  _Bool D.33185;
  long int D.33186;
  long int D.33187;
  struct MonoGHashTable * D.33192;
  struct MonoMemPool * D.33195;
  _Bool D.33198;
  long int D.33199;
  long int D.33200;
  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.33149 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33149);
          if (ret != 0) goto <D.33150>; else goto <D.33151>;
          <D.33150>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33151>:
          D.33152 = ret != 0;
          D.33153 = (long int) D.33152;
          D.33154 = __builtin_expect (D.33153, 0);
          if (D.33154 != 0) goto <D.33155>; else goto <D.33156>;
          <D.33155>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.33156>:
        }
        D.33157 = domain->refobject_hash;
        if (D.33157 == 0B) goto <D.33158>; else goto <D.33159>;
        <D.33158>:
        D.33160 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33160;
        <D.33159>:
        D.33157 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33157, &e);
        if (_obj != 0B) goto <D.33161>; else goto <D.33162>;
        <D.33161>:
        {
          int ret;

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

          D.33149 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33149);
          if (ret != 0) goto <D.33171>; else goto <D.33172>;
          <D.33171>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33172>:
          D.33173 = ret != 0;
          D.33174 = (long int) D.33173;
          D.33175 = __builtin_expect (D.33174, 0);
          if (D.33175 != 0) goto <D.33176>; else goto <D.33177>;
          <D.33176>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6701, "ret == 0");
          <D.33177>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  monoevent_klass.301 = monoevent_klass;
  if (monoevent_klass.301 == 0B) goto <D.33179>; else goto <D.33180>;
  <D.33179>:
  D.33181 = mono_defaults.corlib;
  monoevent_klass.302 = mono_class_from_name (D.33181, "System.Reflection", "MonoEvent");
  monoevent_klass = monoevent_klass.302;
  <D.33180>:
  monoevent_klass.301 = monoevent_klass;
  mono_event = mono_object_new (domain, monoevent_klass.301);
  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.33149 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33149);
          if (ret != 0) goto <D.33183>; else goto <D.33184>;
          <D.33183>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33184>:
          D.33185 = ret != 0;
          D.33186 = (long int) D.33185;
          D.33187 = __builtin_expect (D.33186, 0);
          if (D.33187 != 0) goto <D.33188>; else goto <D.33189>;
          <D.33188>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.33189>:
        }
        D.33157 = domain->refobject_hash;
        if (D.33157 == 0B) goto <D.33190>; else goto <D.33191>;
        <D.33190>:
        D.33192 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33192;
        <D.33191>:
        D.33157 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33157, &pe);
        if (_obj == 0B) goto <D.33193>; else goto <D.33194>;
        <D.33193>:
        {
          struct ReflectedEntry * e;

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

          D.33149 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33149);
          if (ret != 0) goto <D.33196>; else goto <D.33197>;
          <D.33196>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33197>:
          D.33198 = ret != 0;
          D.33199 = (long int) D.33198;
          D.33200 = __builtin_expect (D.33199, 0);
          if (D.33200 != 0) goto <D.33201>; else goto <D.33202>;
          <D.33201>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6708, "ret == 0");
          <D.33202>:
        }
        D.33170 = _obj;
        return D.33170;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
}


mono_param_get_objects_internal (struct MonoDomain * domain, struct MonoMethod * method, struct MonoClass * refclass)
{
  struct MonoClass * System_Reflection_ParameterInfo_array.303;
  struct MonoImage * D.33210;
  int D.33213;
  short unsigned int D.33216;
  struct MonoArray * D.33219;
  struct MonoVTable * D.33220;
  struct MonoMethodSignature * * D.33221;
  union mono_mutex_t * D.33222;
  _Bool D.33225;
  long int D.33226;
  long int D.33227;
  struct MonoGHashTable * D.33230;
  struct MonoGHashTable * D.33233;
  _Bool D.33238;
  long int D.33239;
  long int D.33240;
  _Bool D.33245;
  long int D.33246;
  long int D.33247;
  long unsigned int D.33250;
  long unsigned int D.33251;
  int D.33252;
  int D.33253;
  long unsigned int D.33254;
  long unsigned int D.33255;
  long unsigned int D.33256;
  struct MonoVTable * D.33257;
  struct MonoClass * System_Reflection_ParameterInfo.304;
  struct MonoType * D.33259;
  struct MonoReflectionType * D.33260;
  struct MonoReflectionType * * D.33261;
  struct MonoObject * * D.33262;
  long unsigned int D.33263;
  long unsigned int D.33264;
  char * * D.33265;
  char * D.33266;
  struct MonoString * D.33267;
  struct MonoString * * D.33268;
  short unsigned int D.33269;
  unsigned int D.33270;
  unsigned int D.33271;
  unsigned int D.33272;
  unsigned int D.33275;
  struct MonoObject * D.33278;
  struct MonoObject * * D.33279;
  struct MonoObject * D.33281;
  long unsigned int D.33285;
  long unsigned int D.33288;
  guint32 * D.33289;
  unsigned int D.33290;
  unsigned char D.33291;
  struct MonoClass * D.33294;
  unsigned char D.33298;
  struct MonoClass * D.33300;
  unsigned char D.33301;
  unsigned char D.33302;
  struct MonoClass * D.33304;
  struct MonoClass * D.33305;
  char * * D.33306;
  char * D.33307;
  struct MonoObject * D.33308;
  struct MonoObject * D.33311;
  struct MonoObject * D.33316;
  struct MonoObject * D.33318;
  sizetype D.33319;
  sizetype D.33320;
  sizetype D.33321;
  struct MonoMarshalSpec * * D.33322;
  struct MonoMarshalSpec * D.33323;
  struct MonoClass * D.33326;
  struct MonoReflectionMarshalAsAttribute * D.33327;
  struct MonoObject * * D.33328;
  long unsigned int D.33329;
  struct MonoMethodSignature * D.33330;
  short unsigned int D.33331;
  struct MonoMarshalSpec * * D.33332;
  struct MonoMarshalSpec * D.33333;
  _Bool D.33338;
  long int D.33339;
  long int D.33340;
  struct MonoGHashTable * D.33345;
  struct MonoMemPool * D.33348;
  _Bool D.33351;
  long int D.33352;
  long int D.33353;
  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.303 = System_Reflection_ParameterInfo_array;
      if (System_Reflection_ParameterInfo_array.303 == 0B) goto <D.33208>; else goto <D.33209>;
      <D.33208>:
      {
        struct MonoClass * klass;

        D.33210 = mono_defaults.corlib;
        klass = mono_class_from_name (D.33210, "System.Reflection", "MonoParameterInfo");
        if (klass == 0B) goto <D.33211>; else goto <D.33212>;
        <D.33211>:
        D.33210 = mono_defaults.corlib;
        klass = mono_class_from_name (D.33210, "System.Reflection", "ParameterInfo");
        <D.33212>:
        mono_memory_barrier ();
        System_Reflection_ParameterInfo = klass;
        klass = mono_array_class_get (klass, 1);
        mono_memory_barrier ();
        System_Reflection_ParameterInfo_array = klass;
      }
      <D.33209>:
      sig = mono_method_signature_checked (method, &error);
      D.33213 = mono_error_ok (&error);
      if (D.33213 == 0) goto <D.33214>; else goto <D.33215>;
      <D.33214>:
      mono_error_raise_exception (&error);
      <D.33215>:
      D.33216 = sig->param_count;
      if (D.33216 == 0) goto <D.33217>; else goto <D.33218>;
      <D.33217>:
      System_Reflection_ParameterInfo_array.303 = System_Reflection_ParameterInfo_array;
      D.33220 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.303);
      D.33219 = mono_array_new_specific (D.33220, 0);
      return D.33219;
      <D.33218>:
      {
        struct MonoArray * _obj;
        struct ReflectedEntry e;

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

              D.33222 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.33222);
              if (ret != 0) goto <D.33223>; else goto <D.33224>;
              <D.33223>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.33224>:
              D.33225 = ret != 0;
              D.33226 = (long int) D.33225;
              D.33227 = __builtin_expect (D.33226, 0);
              if (D.33227 != 0) goto <D.33228>; else goto <D.33229>;
              <D.33228>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33229>:
            }
            D.33230 = domain->refobject_hash;
            if (D.33230 == 0B) goto <D.33231>; else goto <D.33232>;
            <D.33231>:
            D.33233 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.33233;
            <D.33232>:
            D.33230 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.33230, &e);
            if (_obj != 0B) goto <D.33234>; else goto <D.33235>;
            <D.33234>:
            {
              int ret;

              D.33222 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33222);
              if (ret != 0) goto <D.33236>; else goto <D.33237>;
              <D.33236>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33237>:
              D.33238 = ret != 0;
              D.33239 = (long int) D.33238;
              D.33240 = __builtin_expect (D.33239, 0);
              if (D.33240 != 0) goto <D.33241>; else goto <D.33242>;
              <D.33241>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33242>:
            }
            D.33219 = _obj;
            return D.33219;
            <D.33235>:
            {
              int ret;

              D.33222 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33222);
              if (ret != 0) goto <D.33243>; else goto <D.33244>;
              <D.33243>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33244>:
              D.33245 = ret != 0;
              D.33246 = (long int) D.33245;
              D.33247 = __builtin_expect (D.33246, 0);
              if (D.33247 != 0) goto <D.33248>; else goto <D.33249>;
              <D.33248>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6808, "ret == 0");
              <D.33249>:
            }
          }
        finally
          {
            e = {CLOBBER};
          }
      }
      member = mono_method_get_object (domain, method, refclass);
      D.33216 = sig->param_count;
      D.33250 = (long unsigned int) D.33216;
      D.33251 = D.33250 * 8;
      names = monoeg_malloc (D.33251);
      mono_method_get_param_names (method, names);
      D.33216 = sig->param_count;
      D.33252 = (int) D.33216;
      D.33253 = D.33252 + 1;
      D.33254 = (long unsigned int) D.33253;
      D.33255 = D.33254 * 8;
      mspecs = monoeg_malloc (D.33255);
      mono_method_get_marshal_info (method, mspecs);
      D.33216 = sig->param_count;
      D.33256 = (long unsigned int) D.33216;
      System_Reflection_ParameterInfo_array.303 = System_Reflection_ParameterInfo_array;
      D.33257 = mono_class_vtable (domain, System_Reflection_ParameterInfo_array.303);
      res = mono_array_new_specific (D.33257, D.33256);
      System_Reflection_ParameterInfo.304 = System_Reflection_ParameterInfo;
      pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo.304);
      i = 0;
      goto <D.21313>;
      <D.21312>:
      param = mono_object_new_specific (pinfo_vtable);
      D.33259 = sig->params[i];
      D.33260 = mono_type_get_object (domain, D.33259);
      D.33261 = &param->ClassImpl;
      mono_gc_wbarrier_set_field (param, D.33261, D.33260);
      D.33262 = &param->MemberImpl;
      mono_gc_wbarrier_set_field (param, D.33262, member);
      D.33263 = (long unsigned int) i;
      D.33264 = D.33263 * 8;
      D.33265 = names + D.33264;
      D.33266 = *D.33265;
      D.33267 = mono_string_new (domain, D.33266);
      D.33268 = &param->NameImpl;
      mono_gc_wbarrier_set_field (param, D.33268, D.33267);
      param->PositionImpl = i;
      D.33259 = sig->params[i];
      D.33269 = D.33259->attrs;
      D.33270 = (unsigned int) D.33269;
      param->AttrsImpl = D.33270;
      D.33271 = param->AttrsImpl;
      D.33272 = D.33271 & 4096;
      if (D.33272 == 0) goto <D.33273>; else goto <D.33274>;
      <D.33273>:
      D.33271 = param->AttrsImpl;
      D.33275 = D.33271 & 16;
      if (D.33275 != 0) goto <D.33276>; else goto <D.33277>;
      <D.33276>:
      D.33278 = get_reflection_missing (domain, &missing);
      D.33279 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.33279, D.33278);
      goto <D.33280>;
      <D.33277>:
      D.33281 = get_dbnull (domain, &dbnull);
      D.33279 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.33279, D.33281);
      <D.33280>:
      goto <D.33282>;
      <D.33274>:
      if (blobs == 0B) goto <D.33283>; else goto <D.33284>;
      <D.33283>:
      D.33216 = sig->param_count;
      D.33250 = (long unsigned int) D.33216;
      D.33251 = D.33250 * 8;
      blobs = monoeg_malloc0 (D.33251);
      D.33216 = sig->param_count;
      D.33250 = (long unsigned int) D.33216;
      D.33285 = D.33250 * 4;
      types = monoeg_malloc0 (D.33285);
      get_default_param_value_blobs (method, blobs, types);
      <D.33284>:
      if (type == 0B) goto <D.33286>; else goto <D.33287>;
      <D.33286>:
      type = monoeg_malloc0 (16);
      <D.33287>:
      D.33263 = (long unsigned int) i;
      D.33288 = D.33263 * 4;
      D.33289 = types + D.33288;
      D.33290 = *D.33289;
      D.33291 = (unsigned char) D.33290;
      type->type = D.33291;
      type->data.klass = 0B;
      D.33263 = (long unsigned int) i;
      D.33288 = D.33263 * 4;
      D.33289 = types + D.33288;
      D.33290 = *D.33289;
      if (D.33290 == 18) goto <D.33292>; else goto <D.33293>;
      <D.33292>:
      D.33294 = mono_defaults.object_class;
      type->data.klass = D.33294;
      goto <D.33295>;
      <D.33293>:
      D.33259 = sig->params[i];
      D.33298 = D.33259->type;
      if (D.33298 == 17) goto <D.33299>; else goto <D.33296>;
      <D.33299>:
      D.33259 = sig->params[i];
      D.33300 = D.33259->data.klass;
      D.33301 = BIT_FIELD_REF <*D.33300, 8, 256>;
      D.33302 = D.33301 & 16;
      if (D.33302 != 0) goto <D.33303>; else goto <D.33296>;
      <D.33303>:
      type->type = 17;
      D.33259 = sig->params[i];
      D.33304 = mono_class_from_mono_type (D.33259);
      type->data.klass = D.33304;
      goto <D.33297>;
      <D.33296>:
      D.33305 = mono_class_from_mono_type (type);
      type->data.klass = D.33305;
      <D.33297>:
      <D.33295>:
      D.33263 = (long unsigned int) i;
      D.33264 = D.33263 * 8;
      D.33306 = blobs + D.33264;
      D.33307 = *D.33306;
      D.33308 = mono_get_object_from_blob (domain, type, D.33307);
      D.33279 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.33279, D.33308);
      D.33263 = (long unsigned int) i;
      D.33288 = D.33263 * 4;
      D.33289 = types + D.33288;
      D.33290 = *D.33289;
      if (D.33290 != 18) goto <D.33309>; else goto <D.33310>;
      <D.33309>:
      D.33311 = param->DefaultValueImpl;
      if (D.33311 == 0B) goto <D.33312>; else goto <D.33313>;
      <D.33312>:
      D.33271 = param->AttrsImpl;
      D.33275 = D.33271 & 16;
      if (D.33275 != 0) goto <D.33314>; else goto <D.33315>;
      <D.33314>:
      D.33316 = get_reflection_missing (domain, &missing);
      D.33279 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.33279, D.33316);
      goto <D.33317>;
      <D.33315>:
      D.33318 = get_dbnull (domain, &dbnull);
      D.33279 = &param->DefaultValueImpl;
      mono_gc_wbarrier_set_field (param, D.33279, D.33318);
      <D.33317>:
      <D.33313>:
      <D.33310>:
      <D.33282>:
      D.33319 = (sizetype) i;
      D.33320 = D.33319 + 1;
      D.33321 = D.33320 * 8;
      D.33322 = mspecs + D.33321;
      D.33323 = *D.33322;
      if (D.33323 != 0B) goto <D.33324>; else goto <D.33325>;
      <D.33324>:
      D.33319 = (sizetype) i;
      D.33320 = D.33319 + 1;
      D.33321 = D.33320 * 8;
      D.33322 = mspecs + D.33321;
      D.33323 = *D.33322;
      D.33326 = method->klass;
      D.33327 = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.33326, D.33323);
      D.33328 = &param->MarshalAsImpl;
      mono_gc_wbarrier_set_field (param, D.33328, D.33327);
      <D.33325>:
      {
        void * * __p;

        D.33329 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.33329);
        mono_gc_wbarrier_set_arrayref (res, __p, param);
      }
      i = i + 1;
      <D.21313>:
      D.33216 = sig->param_count;
      D.33252 = (int) D.33216;
      if (D.33252 > i) goto <D.21312>; else goto <D.21314>;
      <D.21314>:
      monoeg_g_free (names);
      monoeg_g_free (blobs);
      monoeg_g_free (types);
      monoeg_g_free (type);
      D.33330 = mono_method_signature (method);
      D.33331 = D.33330->param_count;
      i = (int) D.33331;
      goto <D.21316>;
      <D.21315>:
      D.33263 = (long unsigned int) i;
      D.33264 = D.33263 * 8;
      D.33332 = mspecs + D.33264;
      D.33333 = *D.33332;
      if (D.33333 != 0B) goto <D.33334>; else goto <D.33335>;
      <D.33334>:
      D.33263 = (long unsigned int) i;
      D.33264 = D.33263 * 8;
      D.33332 = mspecs + D.33264;
      D.33333 = *D.33332;
      mono_metadata_free_marshal_spec (D.33333);
      <D.33335>:
      i = i + -1;
      <D.21316>:
      if (i >= 0) goto <D.21315>; else goto <D.21317>;
      <D.21317>:
      monoeg_g_free (mspecs);
      {
        struct MonoArray * _obj;
        struct ReflectedEntry pe;

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

              D.33222 = &domain->lock.mutex;
              ret = pthread_mutex_lock (D.33222);
              if (ret != 0) goto <D.33336>; else goto <D.33337>;
              <D.33336>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.33337>:
              D.33338 = ret != 0;
              D.33339 = (long int) D.33338;
              D.33340 = __builtin_expect (D.33339, 0);
              if (D.33340 != 0) goto <D.33341>; else goto <D.33342>;
              <D.33341>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.33342>:
            }
            D.33230 = domain->refobject_hash;
            if (D.33230 == 0B) goto <D.33343>; else goto <D.33344>;
            <D.33343>:
            D.33345 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
            domain->refobject_hash = D.33345;
            <D.33344>:
            D.33230 = domain->refobject_hash;
            _obj = mono_g_hash_table_lookup (D.33230, &pe);
            if (_obj == 0B) goto <D.33346>; else goto <D.33347>;
            <D.33346>:
            {
              struct ReflectedEntry * e;

              D.33348 = domain->mp;
              e = mono_mempool_alloc (D.33348, 16);
              D.33221 = &method->signature;
              e->item = D.33221;
              e->refclass = refclass;
              D.33230 = domain->refobject_hash;
              mono_g_hash_table_insert (D.33230, e, res);
              _obj = res;
            }
            <D.33347>:
            {
              int ret;

              D.33222 = &domain->lock.mutex;
              ret = pthread_mutex_unlock (D.33222);
              if (ret != 0) goto <D.33349>; else goto <D.33350>;
              <D.33349>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.33350>:
              D.33351 = ret != 0;
              D.33352 = (long int) D.33351;
              D.33353 = __builtin_expect (D.33352, 0);
              if (D.33353 != 0) goto <D.33354>; else goto <D.33355>;
              <D.33354>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6882, "ret == 0");
              <D.33355>:
            }
            D.33219 = _obj;
            return D.33219;
          }
        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.33361;
  struct MonoImage * D.33364;
  unsigned char D.33365;
  unsigned char D.33366;
  unsigned char D.33369;
  unsigned char D.33370;
  struct MonoClass * D.33373;
  struct MonoImage * D.33374;
  struct GHashTable * D.33375;
  uint8_t * * D.33378;
  long unsigned int D.33381;
  long unsigned int D.33382;
  uint8_t * * D.33383;
  long unsigned int D.33384;
  uint32_t * D.33385;
  uint32_t * D.33386;
  unsigned int D.33387;
  unsigned int D.33388;
  _Bool D.33389;
  long int D.33390;
  long int D.33391;
  int D.33394;
  <unnamed-unsigned:24> D.33395;
  int D.33396;
  <unnamed-unsigned:24> D.33400;
  int D.33401;
  int D.33402;
  unsigned int D.33403;
  int D.33404;
  unsigned int D.33405;
  unsigned int D.33406;
  unsigned int D.33409;
  unsigned int D.33410;
  unsigned int D.33413;
  int D.33414;
  unsigned int D.33415;
  long unsigned int D.33416;
  long unsigned int D.33417;
  char * * D.33418;
  unsigned int D.33419;
  const char * D.33420;
  long unsigned int D.33421;
  guint32 * D.33422;
  unsigned int D.33423;
  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.33361 = methodsig->param_count;
      if (D.33361 == 0) goto <D.33362>; else goto <D.33363>;
      <D.33362>:
      return;
      <D.33363>:
      mono_class_init (klass);
      D.33364 = klass->image;
      D.33365 = BIT_FIELD_REF <*D.33364, 8, 224>;
      D.33366 = D.33365 & 8;
      if (D.33366 != 0) goto <D.33367>; else goto <D.33368>;
      <D.33367>:
      {
        struct MonoReflectionMethodAux * aux;

        D.33369 = BIT_FIELD_REF <*method, 8, 264>;
        D.33370 = D.33369 & 16;
        if (D.33370 != 0) goto <D.33371>; else goto <D.33372>;
        <D.33371>:
        method = MEM[(struct MonoMethodInflated *)method].declaring;
        <D.33372>:
        D.33373 = method->klass;
        D.33374 = D.33373->image;
        D.33375 = MEM[(struct MonoDynamicImage *)D.33374].method_aux_hash;
        aux = monoeg_g_hash_table_lookup (D.33375, method);
        if (aux != 0B) goto <D.33376>; else goto <D.33377>;
        <D.33376>:
        D.33378 = aux->param_defaults;
        if (D.33378 != 0B) goto <D.33379>; else goto <D.33380>;
        <D.33379>:
        D.33361 = methodsig->param_count;
        D.33381 = (long unsigned int) D.33361;
        D.33382 = D.33381 * 8;
        D.33378 = aux->param_defaults;
        D.33383 = D.33378 + 8;
        memcpy (blobs, D.33383, D.33382);
        D.33361 = methodsig->param_count;
        D.33381 = (long unsigned int) D.33361;
        D.33384 = D.33381 * 4;
        D.33385 = aux->param_default_types;
        D.33386 = D.33385 + 4;
        memcpy (types, D.33386, D.33384);
        <D.33380>:
        <D.33377>:
        return;
      }
      <D.33368>:
      D.33364 = klass->image;
      methodt = &D.33364->tables[6];
      D.33364 = klass->image;
      paramt = &D.33364->tables[8];
      constt = &image->tables[11];
      D.33387 = mono_method_get_index (method);
      D.33388 = D.33387 + 4294967295;
      idx = (gint32) D.33388;
      D.33389 = idx == -1;
      D.33390 = (long int) D.33389;
      D.33391 = __builtin_expect (D.33390, 0);
      if (D.33391 != 0) goto <D.33392>; else goto <D.33393>;
      <D.33392>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7061, "idx != -1");
      <D.33393>:
      param_index = mono_metadata_decode_row_col (methodt, idx, 5);
      D.33394 = idx + 1;
      D.33395 = methodt->rows;
      D.33396 = (int) D.33395;
      if (D.33394 < D.33396) goto <D.33397>; else goto <D.33398>;
      <D.33397>:
      D.33394 = idx + 1;
      lastp = mono_metadata_decode_row_col (methodt, D.33394, 5);
      goto <D.33399>;
      <D.33398>:
      D.33400 = paramt->rows;
      D.33401 = (int) D.33400;
      D.33402 = D.33401 + 1;
      lastp = (guint32) D.33402;
      <D.33399>:
      i = param_index;
      goto <D.21402>;
      <D.21401>:
      {
        guint32 paramseq;

        D.33403 = i + 4294967295;
        D.33404 = (int) D.33403;
        mono_metadata_decode_row (paramt, D.33404, &param_cols, 3);
        paramseq = param_cols[1];
        D.33405 = param_cols[0];
        D.33406 = D.33405 & 4096;
        if (D.33406 == 0) goto <D.33407>; else goto <D.33408>;
        <D.33407>:
        // predicted unlikely by continue predictor.
        goto <D.21400>;
        <D.33408>:
        D.33409 = crow + 1;
        D.33410 = i | 134217728;
        crow = mono_metadata_get_constant_index (image, D.33410, D.33409);
        if (crow == 0) goto <D.33411>; else goto <D.33412>;
        <D.33411>:
        // predicted unlikely by continue predictor.
        goto <D.21400>;
        <D.33412>:
        D.33413 = crow + 4294967295;
        D.33414 = (int) D.33413;
        mono_metadata_decode_row (constt, D.33414, &const_cols, 4);
        D.33415 = paramseq + 4294967295;
        D.33416 = (long unsigned int) D.33415;
        D.33417 = D.33416 * 8;
        D.33418 = blobs + D.33417;
        D.33419 = const_cols[3];
        D.33420 = mono_metadata_blob_heap (image, D.33419);
        *D.33418 = D.33420;
        D.33415 = paramseq + 4294967295;
        D.33416 = (long unsigned int) D.33415;
        D.33421 = D.33416 * 4;
        D.33422 = types + D.33421;
        D.33423 = const_cols[0];
        *D.33422 = D.33423;
      }
      <D.21400>:
      i = i + 1;
      <D.21402>:
      if (i < lastp) goto <D.21401>; else goto <D.21403>;
      <D.21403>:
      return;
    }
  finally
    {
      param_cols = {CLOBBER};
      const_cols = {CLOBBER};
    }
}


get_reflection_missing (struct MonoDomain * domain, struct MonoObject * * reflection_missing)
{
  struct MonoObject * D.33426;
  struct MonoObject * D.33429;
  struct MonoObject * D.33430;

  D.33426 = *reflection_missing;
  if (D.33426 == 0B) goto <D.33427>; else goto <D.33428>;
  <D.33427>:
  D.33429 = mono_get_reflection_missing_object (domain);
  *reflection_missing = D.33429;
  <D.33428>:
  D.33430 = *reflection_missing;
  return D.33430;
}


mono_get_reflection_missing_object (struct MonoDomain * domain)
{
  struct MonoClassField * missing_value_field.305;
  struct MonoImage * D.33435;
  struct MonoClassField * missing_value_field.306;
  _Bool D.33437;
  long int D.33438;
  long int D.33439;
  _Bool D.33442;
  long int D.33443;
  long int D.33444;
  struct MonoObject * D.33447;
  struct MonoObject * obj;
  static struct MonoClassField * missing_value_field = 0B;

  missing_value_field.305 = missing_value_field;
  if (missing_value_field.305 == 0B) goto <D.33433>; else goto <D.33434>;
  <D.33433>:
  {
    struct MonoClass * missing_klass;

    D.33435 = mono_defaults.corlib;
    missing_klass = mono_class_from_name (D.33435, "System.Reflection", "Missing");
    mono_class_init (missing_klass);
    missing_value_field.306 = mono_class_get_field_from_name (missing_klass, "Value");
    missing_value_field = missing_value_field.306;
    missing_value_field.305 = missing_value_field;
    D.33437 = missing_value_field.305 == 0B;
    D.33438 = (long int) D.33437;
    D.33439 = __builtin_expect (D.33438, 0);
    if (D.33439 != 0) goto <D.33440>; else goto <D.33441>;
    <D.33440>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6732, "missing_value_field");
    <D.33441>:
  }
  <D.33434>:
  missing_value_field.305 = missing_value_field;
  obj = mono_field_get_value_object (domain, missing_value_field.305, 0B);
  D.33442 = obj == 0B;
  D.33443 = (long int) D.33442;
  D.33444 = __builtin_expect (D.33443, 0);
  if (D.33444 != 0) goto <D.33445>; else goto <D.33446>;
  <D.33445>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6735, "obj");
  <D.33446>:
  D.33447 = obj;
  return D.33447;
}


get_dbnull (struct MonoDomain * domain, struct MonoObject * * dbnull)
{
  struct MonoObject * D.33449;
  struct MonoObject * D.33452;
  struct MonoObject * D.33453;

  D.33449 = *dbnull;
  if (D.33449 == 0B) goto <D.33450>; else goto <D.33451>;
  <D.33450>:
  D.33452 = mono_get_dbnull_object (domain);
  *dbnull = D.33452;
  <D.33451>:
  D.33453 = *dbnull;
  return D.33453;
}


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

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


mono_method_body_get_object (struct MonoDomain * domain, struct MonoMethod * method)
{
  unsigned char D.33457;
  unsigned char D.33458;
  struct MonoException * D.33461;
  struct MonoClass * System_Reflection_MethodBody.307;
  struct MonoImage * D.33465;
  struct MonoClass * System_Reflection_MethodBody.308;
  struct MonoClass * System_Reflection_LocalVariableInfo.309;
  struct MonoClass * System_Reflection_LocalVariableInfo.310;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.311;
  struct MonoClass * System_Reflection_ExceptionHandlingClause.312;
  union mono_mutex_t * D.33475;
  _Bool D.33478;
  long int D.33479;
  long int D.33480;
  struct MonoGHashTable * D.33483;
  struct MonoGHashTable * D.33486;
  _Bool D.33491;
  long int D.33492;
  long int D.33493;
  struct MonoReflectionMethodBody * D.33496;
  _Bool D.33499;
  long int D.33500;
  long int D.33501;
  short unsigned int D.33506;
  unsigned int D.33507;
  unsigned int D.33508;
  short unsigned int D.33510;
  unsigned int D.33511;
  unsigned int D.33512;
  struct MonoClass * D.33513;
  unsigned char D.33514;
  unsigned char D.33515;
  unsigned int D.33518;
  unsigned int D.33519;
  unsigned int D.33520;
  int D.33521;
  struct MonoTableInfo * D.33522;
  int D.33523;
  <unnamed-unsigned:1> D.33525;
  unsigned char D.33526;
  <unnamed-unsigned:15> D.33527;
  unsigned int D.33528;
  unsigned int D.33529;
  long unsigned int D.33530;
  struct MonoClass * D.21353;
  struct MonoClass * tmp_klass.313;
  struct MonoClass * D.33534;
  struct MonoClass * tmp_klass.314;
  _Bool D.33536;
  long int D.33537;
  long int D.33538;
  struct MonoVTable * D.33541;
  struct MonoArray * D.33542;
  struct MonoArray * * D.33543;
  long unsigned int D.33544;
  const unsigned char * D.33545;
  struct MonoArray * D.33546;
  char * D.33547;
  short unsigned int D.33548;
  long unsigned int D.33549;
  struct MonoClass * D.21355;
  struct MonoClass * tmp_klass.315;
  struct MonoClass * tmp_klass.316;
  _Bool D.33554;
  long int D.33555;
  long int D.33556;
  struct MonoVTable * D.33559;
  struct MonoArray * D.33560;
  struct MonoArray * * D.33561;
  struct MonoType * D.33562;
  struct MonoReflectionType * D.33563;
  struct MonoReflectionType * * D.33564;
  <unnamed-unsigned:1> D.33565;
  unsigned char D.33566;
  short unsigned int D.33567;
  long unsigned int D.33568;
  struct MonoArray * D.33569;
  int D.33570;
  <unnamed-unsigned:15> D.33571;
  long unsigned int D.33572;
  struct MonoClass * D.21362;
  struct MonoClass * tmp_klass.317;
  struct MonoClass * tmp_klass.318;
  _Bool D.33577;
  long int D.33578;
  long int D.33579;
  struct MonoVTable * D.33582;
  struct MonoArray * D.33583;
  struct MonoArray * * D.33584;
  struct MonoExceptionClause * D.33585;
  long unsigned int D.33586;
  long unsigned int D.33587;
  unsigned int D.33588;
  int D.33589;
  unsigned int D.33590;
  int D.33591;
  unsigned int D.33592;
  int D.33593;
  unsigned int D.33594;
  int D.33595;
  unsigned int D.33596;
  int D.33597;
  unsigned int D.33600;
  int D.33601;
  struct MonoClass * D.33603;
  struct MonoType * D.33606;
  struct MonoDomain * D.33607;
  struct MonoReflectionType * D.33608;
  struct MonoObject * * D.33609;
  struct MonoArray * D.33610;
  int D.33611;
  _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;
  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.33457 = BIT_FIELD_REF <*method, 8, 264>;
  D.33458 = D.33457 & 2;
  if (D.33458 != 0) goto <D.33459>; else goto <D.33460>;
  <D.33459>:
  D.33461 = mono_get_exception_invalid_operation (0B);
  mono_raise_exception (D.33461);
  <D.33460>:
  System_Reflection_MethodBody.307 = System_Reflection_MethodBody;
  if (System_Reflection_MethodBody.307 == 0B) goto <D.33463>; else goto <D.33464>;
  <D.33463>:
  D.33465 = mono_defaults.corlib;
  System_Reflection_MethodBody.308 = mono_class_from_name (D.33465, "System.Reflection", "MethodBody");
  System_Reflection_MethodBody = System_Reflection_MethodBody.308;
  <D.33464>:
  System_Reflection_LocalVariableInfo.309 = System_Reflection_LocalVariableInfo;
  if (System_Reflection_LocalVariableInfo.309 == 0B) goto <D.33468>; else goto <D.33469>;
  <D.33468>:
  D.33465 = mono_defaults.corlib;
  System_Reflection_LocalVariableInfo.310 = mono_class_from_name (D.33465, "System.Reflection", "LocalVariableInfo");
  System_Reflection_LocalVariableInfo = System_Reflection_LocalVariableInfo.310;
  <D.33469>:
  System_Reflection_ExceptionHandlingClause.311 = System_Reflection_ExceptionHandlingClause;
  if (System_Reflection_ExceptionHandlingClause.311 == 0B) goto <D.33472>; else goto <D.33473>;
  <D.33472>:
  D.33465 = mono_defaults.corlib;
  System_Reflection_ExceptionHandlingClause.312 = mono_class_from_name (D.33465, "System.Reflection", "ExceptionHandlingClause");
  System_Reflection_ExceptionHandlingClause = System_Reflection_ExceptionHandlingClause.312;
  <D.33473>:
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry e;

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

          D.33475 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33475);
          if (ret != 0) goto <D.33476>; else goto <D.33477>;
          <D.33476>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.33477>:
          D.33478 = ret != 0;
          D.33479 = (long int) D.33478;
          D.33480 = __builtin_expect (D.33479, 0);
          if (D.33480 != 0) goto <D.33481>; else goto <D.33482>;
          <D.33481>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33482>:
        }
        D.33483 = domain->refobject_hash;
        if (D.33483 == 0B) goto <D.33484>; else goto <D.33485>;
        <D.33484>:
        D.33486 = mono_g_hash_table_new_type (reflected_hash, reflected_equal, 2);
        domain->refobject_hash = D.33486;
        <D.33485>:
        D.33483 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33483, &e);
        if (_obj != 0B) goto <D.33487>; else goto <D.33488>;
        <D.33487>:
        {
          int ret;

          D.33475 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33475);
          if (ret != 0) goto <D.33489>; else goto <D.33490>;
          <D.33489>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33490>:
          D.33491 = ret != 0;
          D.33492 = (long int) D.33491;
          D.33493 = __builtin_expect (D.33492, 0);
          if (D.33493 != 0) goto <D.33494>; else goto <D.33495>;
          <D.33494>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33495>:
        }
        D.33496 = _obj;
        return D.33496;
        <D.33488>:
        {
          int ret;

          D.33475 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33475);
          if (ret != 0) goto <D.33497>; else goto <D.33498>;
          <D.33497>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.33498>:
          D.33499 = ret != 0;
          D.33500 = (long int) D.33499;
          D.33501 = __builtin_expect (D.33500, 0);
          if (D.33501 != 0) goto <D.33502>; else goto <D.33503>;
          <D.33502>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6923, "ret == 0");
          <D.33503>:
        }
      }
    finally
      {
        e = {CLOBBER};
      }
  }
  D.33506 = method->flags;
  D.33507 = (unsigned int) D.33506;
  D.33508 = D.33507 & 9216;
  if (D.33508 != 0) goto <D.33504>; else goto <D.33509>;
  <D.33509>:
  D.33510 = method->iflags;
  D.33511 = (unsigned int) D.33510;
  D.33512 = D.33511 & 4099;
  if (D.33512 != 0) goto <D.33504>; else goto <D.33505>;
  <D.33504>:
  D.33496 = 0B;
  return D.33496;
  <D.33505>:
  D.33513 = method->klass;
  image = D.33513->image;
  header = mono_method_get_header (method);
  D.33514 = BIT_FIELD_REF <*image, 8, 224>;
  D.33515 = D.33514 & 8;
  if (D.33515 == 0) goto <D.33516>; else goto <D.33517>;
  <D.33516>:
  D.33518 = method->token;
  D.33519 = D.33518 & 16777215;
  D.33520 = D.33519 + 4294967295;
  D.33521 = (int) D.33520;
  D.33522 = &image->tables[6];
  method_rva = mono_metadata_decode_row_col (D.33522, D.33521, 0);
  ptr = mono_image_rva_map (image, method_rva);
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.33523 = (int) format;
  switch (D.33523) <default: <D.21351>, case 2: <D.21348>, case 3: <D.21350>>
  <D.21348>:
  local_var_sig_token = 0;
  goto <D.21349>;
  <D.21350>:
  ptr = ptr + 2;
  ptr = ptr + 2;
  ptr = ptr + 4;
  local_var_sig_token = MEM[(const guint32 *)ptr];
  goto <D.21349>;
  <D.21351>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 6951);
  <D.21349>:
  goto <D.33524>;
  <D.33517>:
  local_var_sig_token = 0;
  <D.33524>:
  System_Reflection_MethodBody.307 = System_Reflection_MethodBody;
  ret = mono_object_new (domain, System_Reflection_MethodBody.307);
  D.33525 = header->init_locals;
  D.33526 = (unsigned char) D.33525;
  ret->init_locals = D.33526;
  D.33527 = header->max_stack;
  D.33528 = (unsigned int) D.33527;
  ret->max_stack = D.33528;
  ret->local_var_sig_token = local_var_sig_token;
  D.33529 = header->code_size;
  D.33530 = (long unsigned int) D.33529;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.313 = tmp_klass;
      if (tmp_klass.313 == 0B) goto <D.33532>; else goto <D.33533>;
      <D.33532>:
      D.33534 = mono_defaults.byte_class;
      tmp_klass.314 = mono_array_class_get (D.33534, 1);
      tmp_klass = tmp_klass.314;
      tmp_klass.313 = tmp_klass;
      D.33536 = tmp_klass.313 == 0B;
      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", 6961, "tmp_klass");
      <D.33540>:
      <D.33533>:
    }
    D.21353 = tmp_klass;
  }
  D.33541 = mono_class_vtable (domain, D.21353);
  D.33542 = mono_array_new_specific (D.33541, D.33530);
  D.33543 = &ret->il;
  mono_gc_wbarrier_set_field (ret, D.33543, D.33542);
  D.33529 = header->code_size;
  D.33544 = (long unsigned int) D.33529;
  D.33545 = header->code;
  D.33546 = ret->il;
  D.33547 = mono_array_addr_with_size (D.33546, 1, 0);
  memcpy (D.33547, D.33545, D.33544);
  D.33548 = header->num_locals;
  D.33549 = (long unsigned int) D.33548;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.315 = tmp_klass;
      if (tmp_klass.315 == 0B) goto <D.33551>; else goto <D.33552>;
      <D.33551>:
      System_Reflection_LocalVariableInfo.309 = System_Reflection_LocalVariableInfo;
      tmp_klass.316 = mono_array_class_get (System_Reflection_LocalVariableInfo.309, 1);
      tmp_klass = tmp_klass.316;
      tmp_klass.315 = tmp_klass;
      D.33554 = tmp_klass.315 == 0B;
      D.33555 = (long int) D.33554;
      D.33556 = __builtin_expect (D.33555, 0);
      if (D.33556 != 0) goto <D.33557>; else goto <D.33558>;
      <D.33557>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6965, "tmp_klass");
      <D.33558>:
      <D.33552>:
    }
    D.21355 = tmp_klass;
  }
  D.33559 = mono_class_vtable (domain, D.21355);
  D.33560 = mono_array_new_specific (D.33559, D.33549);
  D.33561 = &ret->locals;
  mono_gc_wbarrier_set_field (ret, D.33561, D.33560);
  i = 0;
  goto <D.21359>;
  <D.21358>:
  {
    struct MonoReflectionLocalVariableInfo * info;

    System_Reflection_LocalVariableInfo.309 = System_Reflection_LocalVariableInfo;
    info = mono_object_new (domain, System_Reflection_LocalVariableInfo.309);
    D.33562 = header->locals[i];
    D.33563 = mono_type_get_object (domain, D.33562);
    D.33564 = &info->local_type;
    mono_gc_wbarrier_set_field (info, D.33564, D.33563);
    D.33562 = header->locals[i];
    D.33565 = D.33562->pinned;
    D.33566 = (unsigned char) D.33565;
    info->is_pinned = D.33566;
    D.33567 = (short unsigned int) i;
    info->local_index = D.33567;
    {
      void * * __p;

      D.33568 = (long unsigned int) i;
      D.33569 = ret->locals;
      __p = mono_array_addr_with_size (D.33569, 8, D.33568);
      D.33569 = ret->locals;
      mono_gc_wbarrier_set_arrayref (D.33569, __p, info);
    }
  }
  i = i + 1;
  <D.21359>:
  D.33548 = header->num_locals;
  D.33570 = (int) D.33548;
  if (D.33570 > i) goto <D.21358>; else goto <D.21360>;
  <D.21360>:
  D.33571 = header->num_clauses;
  D.33572 = (long unsigned int) D.33571;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.317 = tmp_klass;
      if (tmp_klass.317 == 0B) goto <D.33574>; else goto <D.33575>;
      <D.33574>:
      System_Reflection_ExceptionHandlingClause.311 = System_Reflection_ExceptionHandlingClause;
      tmp_klass.318 = mono_array_class_get (System_Reflection_ExceptionHandlingClause.311, 1);
      tmp_klass = tmp_klass.318;
      tmp_klass.317 = tmp_klass;
      D.33577 = tmp_klass.317 == 0B;
      D.33578 = (long int) D.33577;
      D.33579 = __builtin_expect (D.33578, 0);
      if (D.33579 != 0) goto <D.33580>; else goto <D.33581>;
      <D.33580>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 6975, "tmp_klass");
      <D.33581>:
      <D.33575>:
    }
    D.21362 = tmp_klass;
  }
  D.33582 = mono_class_vtable (domain, D.21362);
  D.33583 = mono_array_new_specific (D.33582, D.33572);
  D.33584 = &ret->clauses;
  mono_gc_wbarrier_set_field (ret, D.33584, D.33583);
  i = 0;
  goto <D.21367>;
  <D.21366>:
  {
    struct MonoReflectionExceptionHandlingClause * info;
    struct MonoExceptionClause * clause;

    System_Reflection_ExceptionHandlingClause.311 = System_Reflection_ExceptionHandlingClause;
    info = mono_object_new (domain, System_Reflection_ExceptionHandlingClause.311);
    D.33585 = header->clauses;
    D.33586 = (long unsigned int) i;
    D.33587 = D.33586 * 32;
    clause = D.33585 + D.33587;
    D.33588 = clause->flags;
    D.33589 = (int) D.33588;
    info->flags = D.33589;
    D.33590 = clause->try_offset;
    D.33591 = (int) D.33590;
    info->try_offset = D.33591;
    D.33592 = clause->try_len;
    D.33593 = (int) D.33592;
    info->try_length = D.33593;
    D.33594 = clause->handler_offset;
    D.33595 = (int) D.33594;
    info->handler_offset = D.33595;
    D.33596 = clause->handler_len;
    D.33597 = (int) D.33596;
    info->handler_length = D.33597;
    D.33588 = clause->flags;
    if (D.33588 == 1) goto <D.33598>; else goto <D.33599>;
    <D.33598>:
    D.33600 = clause->data.filter_offset;
    D.33601 = (int) D.33600;
    info->filter_offset = D.33601;
    goto <D.33602>;
    <D.33599>:
    D.33603 = clause->data.catch_class;
    if (D.33603 != 0B) goto <D.33604>; else goto <D.33605>;
    <D.33604>:
    D.33603 = clause->data.catch_class;
    D.33606 = &D.33603->byval_arg;
    D.33607 = mono_domain_get ();
    D.33608 = mono_type_get_object (D.33607, D.33606);
    D.33609 = &info->catch_type;
    mono_gc_wbarrier_set_field (info, D.33609, D.33608);
    <D.33605>:
    <D.33602>:
    {
      void * * __p;

      D.33568 = (long unsigned int) i;
      D.33610 = ret->clauses;
      __p = mono_array_addr_with_size (D.33610, 8, D.33568);
      D.33610 = ret->clauses;
      mono_gc_wbarrier_set_arrayref (D.33610, __p, info);
    }
  }
  i = i + 1;
  <D.21367>:
  D.33571 = header->num_clauses;
  D.33611 = (int) D.33571;
  if (D.33611 > i) goto <D.21366>; else goto <D.21368>;
  <D.21368>:
  mono_metadata_free_mh (header);
  {
    struct MonoReflectionMethodBody * _obj;
    struct ReflectedEntry pe;

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

          D.33475 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.33475);
          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", 6994, "ret == 0");
          <D.33618>:
        }
        D.33483 = domain->refobject_hash;
        if (D.33483 == 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.33483 = domain->refobject_hash;
        _obj = mono_g_hash_table_lookup (D.33483, &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 = method;
          e->refclass = 0B;
          D.33483 = domain->refobject_hash;
          mono_g_hash_table_insert (D.33483, e, ret);
          _obj = ret;
        }
        <D.33623>:
        {
          int ret;

          D.33475 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.33475);
          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", 6994, "ret == 0");
          <D.33631>:
        }
        D.33496 = _obj;
        return D.33496;
      }
    finally
      {
        pe = {CLOBBER};
      }
  }
  D.33496 = ret;
  return D.33496;
}


mono_get_dbnull_object (struct MonoDomain * domain)
{
  struct MonoClassField * dbnull_value_field.319;
  struct MonoImage * D.33639;
  struct MonoClassField * dbnull_value_field.320;
  _Bool D.33641;
  long int D.33642;
  long int D.33643;
  _Bool D.33646;
  long int D.33647;
  long int D.33648;
  struct MonoObject * D.33651;
  struct MonoObject * obj;
  static struct MonoClassField * dbnull_value_field = 0B;

  dbnull_value_field.319 = dbnull_value_field;
  if (dbnull_value_field.319 == 0B) goto <D.33637>; else goto <D.33638>;
  <D.33637>:
  {
    struct MonoClass * dbnull_klass;

    D.33639 = mono_defaults.corlib;
    dbnull_klass = mono_class_from_name (D.33639, "System", "DBNull");
    mono_class_init (dbnull_klass);
    dbnull_value_field.320 = mono_class_get_field_from_name (dbnull_klass, "Value");
    dbnull_value_field = dbnull_value_field.320;
    dbnull_value_field.319 = dbnull_value_field;
    D.33641 = dbnull_value_field.319 == 0B;
    D.33642 = (long int) D.33641;
    D.33643 = __builtin_expect (D.33642, 0);
    if (D.33643 != 0) goto <D.33644>; else goto <D.33645>;
    <D.33644>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7017, "dbnull_value_field");
    <D.33645>:
  }
  <D.33638>:
  dbnull_value_field.319 = dbnull_value_field;
  obj = mono_field_get_value_object (domain, dbnull_value_field.319, 0B);
  D.33646 = obj == 0B;
  D.33647 = (long int) D.33646;
  D.33648 = __builtin_expect (D.33647, 0);
  if (D.33648 != 0) goto <D.33649>; else goto <D.33650>;
  <D.33649>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7020, "obj");
  <D.33650>:
  D.33651 = obj;
  return D.33651;
}


mono_get_object_from_blob (struct MonoDomain * domain, struct MonoType * type, const char * blob)
{
  struct MonoObject * D.33655;
  unsigned char D.33656;
  unsigned char D.33657;
  struct MonoObject * object.321;
  struct MonoObject * object.322;
  unsigned char D.33662;
  unsigned char D.33666;
  <unnamed type> D.33667;
  int D.33668;
  void * retval;
  struct MonoClass * klass;
  struct MonoObject * object;
  struct MonoType * basetype;

  try
    {
      basetype = type;
      if (blob == 0B) goto <D.33653>; else goto <D.33654>;
      <D.33653>:
      D.33655 = 0B;
      return D.33655;
      <D.33654>:
      klass = mono_class_from_mono_type (type);
      D.33656 = BIT_FIELD_REF <*klass, 8, 256>;
      D.33657 = D.33656 & 8;
      if (D.33657 != 0) goto <D.33658>; else goto <D.33659>;
      <D.33658>:
      object.321 = mono_object_new (domain, klass);
      object = object.321;
      object.322 = object;
      retval = object.322 + 16;
      D.33656 = BIT_FIELD_REF <*klass, 8, 256>;
      D.33662 = D.33656 & 16;
      if (D.33662 != 0) goto <D.33663>; else goto <D.33664>;
      <D.33663>:
      basetype = mono_class_enum_basetype (klass);
      <D.33664>:
      goto <D.33665>;
      <D.33659>:
      retval = &object;
      <D.33665>:
      D.33666 = basetype->type;
      D.33667 = (<unnamed type>) D.33666;
      D.33668 = mono_get_constant_value_from_blob (domain, D.33667, blob, retval);
      if (D.33668 == 0) goto <D.33669>; else goto <D.33670>;
      <D.33669>:
      D.33655 = object;
      return D.33655;
      <D.33670>:
      D.33655 = 0B;
      return D.33655;
    }
  finally
    {
      object = {CLOBBER};
    }
}


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

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


_mono_reflection_parse_type (char * name, char * * endptr, gboolean is_recursed, struct MonoTypeNameParse * info)
{
  struct MonoAssemblyName * D.33675;
  char * D.33676;
  char * p.323;
  char * p.324;
  char D.33679;
  int D.33680;
  struct GList * D.33681;
  struct GList * D.33682;
  char * D.33683;
  char * D.33687;
  int D.33697;
  struct GList * D.33698;
  struct GList * D.33699;
  char * p.325;
  char * p.326;
  struct GList * D.33702;
  char * p.327;
  char * p.328;
  char * p.329;
  char * p.330;
  char D.33711;
  _Bool D.33712;
  _Bool D.33713;
  _Bool D.33714;
  struct GList * D.33722;
  char * p.331;
  char * p.332;
  char D.33726;
  long unsigned int D.33729;
  void * D.33730;
  struct GList * D.33731;
  struct GPtrArray * D.33734;
  struct GPtrArray * D.33735;
  int D.33738;
  char * p.333;
  char * p.334;
  char D.33749;
  _Bool D.33750;
  _Bool D.33751;
  _Bool D.33752;
  char * p.335;
  char * p.336;
  const short unsigned int * * D.33757;
  const short unsigned int * D.33758;
  char D.33759;
  long unsigned int D.33760;
  long unsigned int D.33761;
  const short unsigned int * D.33762;
  short unsigned int D.33763;
  int D.33764;
  int D.33765;
  struct MonoAssemblyName * D.33771;
  int D.33772;
  char * p.337;
  char * p.338;
  char * p.339;
  char * p.340;
  char * p.341;
  char * p.342;
  char * p.343;
  char * p.344;
  long unsigned int D.33791;
  long unsigned int D.33792;
  const short unsigned int * D.33793;
  short unsigned int D.33794;
  int D.33795;
  int D.33796;
  int D.33801;
  const char * D.33804;
  char D.33809;
  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.33675 = &info->assembly;
      memset (D.33675, 0, 80);
      info->name_space = 0B;
      D.33676 = info->name_space;
      info->name = D.33676;
      info->nested = 0B;
      info->modifiers = 0B;
      info->type_arguments = 0B;
      last_point = 0B;
      goto <D.21470>;
      <D.21469>:
      p.323 = p;
      p.324 = p.323 + 1;
      p = p.324;
      start = start + 1;
      w = w + 1;
      name = name + 1;
      <D.21470>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 32) goto <D.21469>; else goto <D.21471>;
      <D.21471>:
      goto <D.21484>;
      <D.21483>:
      p.323 = p;
      D.33679 = *p.323;
      D.33680 = (int) D.33679;
      switch (D.33680) <default: <D.21481>, case 38: <D.21476>, case 42: <D.21477>, case 43: <D.21472>, case 44: <D.21479>, case 46: <D.21474>, case 91: <D.21478>, case 92: <D.21475>, case 93: <D.21480>>
      <D.21472>:
      p.323 = p;
      *p.323 = 0;
      p.323 = p;
      startn = p.323 + 1;
      D.33681 = info->nested;
      D.33682 = monoeg_g_list_append (D.33681, startn);
      info->nested = D.33682;
      D.33683 = info->name;
      if (D.33683 != 0B) goto <D.21473>; else goto <D.33684>;
      <D.33684>:
      if (last_point != 0B) goto <D.33685>; else goto <D.33686>;
      <D.33685>:
      info->name_space = start;
      *last_point = 0;
      D.33687 = last_point + 1;
      info->name = D.33687;
      goto <D.33688>;
      <D.33686>:
      info->name_space = "";
      info->name = start;
      <D.33688>:
      goto <D.21473>;
      <D.21474>:
      last_point = p;
      goto <D.21473>;
      <D.21475>:
      p.323 = p;
      p.324 = p.323 + 1;
      p = p.324;
      goto <D.21473>;
      <D.21476>:
      <D.21477>:
      <D.21478>:
      <D.21479>:
      <D.21480>:
      in_modifiers = 1;
      goto <D.21473>;
      <D.21481>:
      goto <D.21473>;
      <D.21473>:
      if (in_modifiers != 0) goto <D.21482>; else goto <D.33689>;
      <D.33689>:
      p.323 = p;
      p.324 = p.323 + 1;
      p = p.324;
      <D.21484>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 != 0) goto <D.21483>; else goto <D.21482>;
      <D.21482>:
      D.33683 = info->name;
      if (D.33683 == 0B) goto <D.33690>; else goto <D.33691>;
      <D.33690>:
      if (last_point != 0B) goto <D.33692>; else goto <D.33693>;
      <D.33692>:
      info->name_space = start;
      *last_point = 0;
      D.33687 = last_point + 1;
      info->name = D.33687;
      goto <D.33694>;
      <D.33693>:
      info->name_space = "";
      info->name = start;
      <D.33694>:
      <D.33691>:
      goto <D.21513>;
      <D.21512>:
      p.323 = p;
      D.33679 = *p.323;
      D.33680 = (int) D.33679;
      switch (D.33680) <default: <D.21510>, case 38: <D.21485>, case 42: <D.21487>, case 44: <D.21506>, case 91: <D.21488>, case 93: <D.21504>>
      <D.21485>:
      if (isbyref != 0) goto <D.33695>; else goto <D.33696>;
      <D.33695>:
      D.33697 = 0;
      return D.33697;
      <D.33696>:
      isbyref = 1;
      D.33698 = info->modifiers;
      D.33699 = monoeg_g_list_append (D.33698, 0B);
      info->modifiers = D.33699;
      p.323 = p;
      p.325 = p.323;
      p.326 = p.325 + 1;
      p = p.326;
      *p.325 = 0;
      goto <D.21486>;
      <D.21487>:
      D.33698 = info->modifiers;
      D.33702 = monoeg_g_list_append (D.33698, -1B);
      info->modifiers = D.33702;
      p.323 = p;
      p.327 = p.323;
      p.328 = p.327 + 1;
      p = p.328;
      *p.327 = 0;
      goto <D.21486>;
      <D.21488>:
      p.323 = p;
      p.329 = p.323;
      p.330 = p.329 + 1;
      p = p.330;
      *p.329 = 0;
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 0) goto <D.33707>; else goto <D.33708>;
      <D.33707>:
      D.33697 = 0;
      return D.33697;
      <D.33708>:
      p.323 = p;
      D.33711 = *p.323;
      D.33712 = D.33711 == 44;
      D.33713 = D.33711 == 42;
      D.33714 = D.33712 | D.33713;
      if (D.33714 != 0) goto <D.33709>; else goto <D.33715>;
      <D.33715>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 93) goto <D.33709>; else goto <D.33710>;
      <D.33709>:
      rank = 1;
      goto <D.21491>;
      <D.21490>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 93) goto <D.21489>; else goto <D.33716>;
      <D.33716>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 44) goto <D.33717>; else goto <D.33718>;
      <D.33717>:
      rank = rank + 1;
      goto <D.33719>;
      <D.33718>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 42) goto <D.33720>; else goto <D.33721>;
      <D.33720>:
      D.33698 = info->modifiers;
      D.33722 = monoeg_g_list_append (D.33698, -2B);
      info->modifiers = D.33722;
      goto <D.33723>;
      <D.33721>:
      D.33697 = 0;
      return D.33697;
      <D.33723>:
      <D.33719>:
      p.323 = p;
      p.324 = p.323 + 1;
      p = p.324;
      <D.21491>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 != 0) goto <D.21490>; else goto <D.21489>;
      <D.21489>:
      p.323 = p;
      p.331 = p.323;
      p.332 = p.331 + 1;
      p = p.332;
      D.33726 = *p.331;
      if (D.33726 != 93) goto <D.33727>; else goto <D.33728>;
      <D.33727>:
      D.33697 = 0;
      return D.33697;
      <D.33728>:
      D.33729 = (long unsigned int) rank;
      D.33730 = (void *) D.33729;
      D.33698 = info->modifiers;
      D.33731 = monoeg_g_list_append (D.33698, D.33730);
      info->modifiers = D.33731;
      goto <D.21501>;
      <D.33710>:
      if (rank != 0) goto <D.33732>; else goto <D.33733>;
      <D.33732>:
      D.33697 = 0;
      return D.33697;
      <D.33733>:
      D.33734 = monoeg_g_ptr_array_new ();
      info->type_arguments = D.33734;
      goto <D.21503>;
      <D.21502>:
      {
        struct MonoTypeNameParse * subinfo;
        gboolean fqname;

        subinfo = monoeg_malloc0 (120);
        fqname = 0;
        D.33735 = info->type_arguments;
        monoeg_g_ptr_array_add (D.33735, subinfo);
        p.323 = p;
        D.33679 = *p.323;
        if (D.33679 == 91) goto <D.33736>; else goto <D.33737>;
        <D.33736>:
        p.323 = p;
        p.324 = p.323 + 1;
        p = p.324;
        fqname = 1;
        <D.33737>:
        p.323 = p;
        D.33738 = _mono_reflection_parse_type (p.323, &p, 1, subinfo);
        if (D.33738 == 0) goto <D.33739>; else goto <D.33740>;
        <D.33739>:
        D.33697 = 0;
        return D.33697;
        <D.33740>:
        if (fqname != 0) goto <D.33743>; else goto <D.33741>;
        <D.33743>:
        p.323 = p;
        D.33679 = *p.323;
        if (D.33679 != 93) goto <D.33744>; else goto <D.33741>;
        <D.33744>:
        {
          char * aname;

          p.323 = p;
          D.33679 = *p.323;
          if (D.33679 != 44) goto <D.33745>; else goto <D.33746>;
          <D.33745>:
          D.33697 = 0;
          return D.33697;
          <D.33746>:
          p.323 = p;
          p.333 = p.323;
          p.334 = p.333 + 1;
          p = p.334;
          *p.333 = 0;
          aname = p;
          goto <D.21496>;
          <D.21495>:
          p.323 = p;
          p.324 = p.323 + 1;
          p = p.324;
          <D.21496>:
          p.323 = p;
          D.33749 = *p.323;
          D.33750 = D.33749 != 0;
          D.33751 = D.33749 != 93;
          D.33752 = D.33750 & D.33751;
          if (D.33752 != 0) goto <D.21495>; else goto <D.21497>;
          <D.21497>:
          p.323 = p;
          D.33679 = *p.323;
          if (D.33679 != 93) goto <D.33753>; else goto <D.33754>;
          <D.33753>:
          D.33697 = 0;
          return D.33697;
          <D.33754>:
          p.323 = p;
          p.335 = p.323;
          p.336 = p.335 + 1;
          p = p.336;
          *p.335 = 0;
          goto <D.21498>;
          <D.21500>:
          D.33757 = __ctype_b_loc ();
          D.33758 = *D.33757;
          D.33759 = *aname;
          D.33760 = (long unsigned int) D.33759;
          D.33761 = D.33760 * 2;
          D.33762 = D.33758 + D.33761;
          D.33763 = *D.33762;
          D.33764 = (int) D.33763;
          D.33765 = D.33764 & 8192;
          if (D.33765 != 0) goto <D.33766>; else goto <D.33767>;
          <D.33766>:
          aname = aname + 1;
          // predicted unlikely by continue predictor.
          goto <D.21498>;
          <D.33767>:
          goto <D.21499>;
          <D.21498>:
          D.33759 = *aname;
          if (D.33759 != 0) goto <D.21500>; else goto <D.21499>;
          <D.21499>:
          D.33759 = *aname;
          if (D.33759 == 0) goto <D.33768>; else goto <D.33770>;
          <D.33770>:
          D.33771 = &subinfo->assembly;
          D.33772 = assembly_name_to_aname (D.33771, aname);
          if (D.33772 == 0) goto <D.33768>; else goto <D.33769>;
          <D.33768>:
          D.33697 = 0;
          return D.33697;
          <D.33769>:
        }
        goto <D.33742>;
        <D.33741>:
        if (fqname != 0) goto <D.33773>; else goto <D.33774>;
        <D.33773>:
        p.323 = p;
        D.33679 = *p.323;
        if (D.33679 == 93) goto <D.33775>; else goto <D.33776>;
        <D.33775>:
        p.323 = p;
        p.337 = p.323;
        p.338 = p.337 + 1;
        p = p.338;
        *p.337 = 0;
        <D.33776>:
        <D.33774>:
        <D.33742>:
        p.323 = p;
        D.33679 = *p.323;
        if (D.33679 == 93) goto <D.33779>; else goto <D.33780>;
        <D.33779>:
        p.323 = p;
        p.339 = p.323;
        p.340 = p.339 + 1;
        p = p.340;
        *p.339 = 0;
        goto <D.21501>;
        <D.33780>:
        p.323 = p;
        D.33679 = *p.323;
        if (D.33679 == 0) goto <D.33783>; else goto <D.33784>;
        <D.33783>:
        D.33697 = 0;
        return D.33697;
        <D.33784>:
        p.323 = p;
        p.341 = p.323;
        p.342 = p.341 + 1;
        p = p.342;
        *p.341 = 0;
      }
      <D.21503>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 != 0) goto <D.21502>; else goto <D.21501>;
      <D.21501>:
      goto <D.21486>;
      <D.21504>:
      if (is_recursed != 0) goto end; else goto <D.33787>;
      <D.33787>:
      D.33697 = 0;
      return D.33697;
      <D.21506>:
      if (is_recursed != 0) goto end; else goto <D.33788>;
      <D.33788>:
      p.323 = p;
      p.343 = p.323;
      p.344 = p.343 + 1;
      p = p.344;
      *p.343 = 0;
      goto <D.21507>;
      <D.21509>:
      D.33757 = __ctype_b_loc ();
      D.33758 = *D.33757;
      p.323 = p;
      D.33679 = *p.323;
      D.33791 = (long unsigned int) D.33679;
      D.33792 = D.33791 * 2;
      D.33793 = D.33758 + D.33792;
      D.33794 = *D.33793;
      D.33795 = (int) D.33794;
      D.33796 = D.33795 & 8192;
      if (D.33796 != 0) goto <D.33797>; else goto <D.33798>;
      <D.33797>:
      p.323 = p;
      p.324 = p.323 + 1;
      p = p.324;
      // predicted unlikely by continue predictor.
      goto <D.21507>;
      <D.33798>:
      goto <D.21508>;
      <D.21507>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 != 0) goto <D.21509>; else goto <D.21508>;
      <D.21508>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 == 0) goto <D.33799>; else goto <D.33800>;
      <D.33799>:
      D.33697 = 0;
      return D.33697;
      <D.33800>:
      p.323 = p;
      D.33675 = &info->assembly;
      D.33801 = assembly_name_to_aname (D.33675, p.323);
      if (D.33801 == 0) goto <D.33802>; else goto <D.33803>;
      <D.33802>:
      D.33697 = 0;
      return D.33697;
      <D.33803>:
      goto <D.21486>;
      <D.21510>:
      D.33697 = 0;
      return D.33697;
      <D.21486>:
      D.33804 = info->assembly.name;
      if (D.33804 != 0B) goto <D.21511>; else goto <D.33805>;
      <D.33805>:
      <D.21513>:
      p.323 = p;
      D.33679 = *p.323;
      if (D.33679 != 0) goto <D.21512>; else goto <D.21511>;
      <D.21511>:
      end:
      D.33683 = info->name;
      if (D.33683 == 0B) goto <D.33806>; else goto <D.33808>;
      <D.33808>:
      D.33683 = info->name;
      D.33809 = *D.33683;
      if (D.33809 == 0) goto <D.33806>; else goto <D.33807>;
      <D.33806>:
      D.33697 = 0;
      return D.33697;
      <D.33807>:
      if (endptr != 0B) goto <D.33810>; else goto <D.33811>;
      <D.33810>:
      p.323 = p;
      *endptr = p.323;
      <D.33811>:
      D.33697 = 1;
      return D.33697;
    }
  finally
    {
      p = {CLOBBER};
    }
}


assembly_name_to_aname (struct MonoAssemblyName * assembly, char * p)
{
  mono_byte[17] * D.33815;
  char D.33816;
  const short unsigned int * * D.33820;
  const short unsigned int * D.33821;
  long unsigned int D.33822;
  long unsigned int D.33823;
  const short unsigned int * D.33824;
  short unsigned int D.33825;
  int D.33826;
  int D.33827;
  int D.33834;
  int D.33839;
  char * s.345;
  char * s.346;
  char * s.347;
  char * s.348;
  char D.33846;
  long unsigned int D.33848;
  long unsigned int D.33849;
  const short unsigned int * D.33850;
  short unsigned int D.33851;
  int D.33852;
  int D.33853;
  int D.33857;
  long unsigned int D.33859;
  short unsigned int D.33860;
  char * s.349;
  long unsigned int D.33865;
  short unsigned int D.33866;
  long unsigned int D.33870;
  short unsigned int D.33871;
  long unsigned int D.33875;
  short unsigned int D.33876;
  int D.33882;
  int D.33884;
  char D.33888;
  _Bool D.33889;
  _Bool D.33890;
  _Bool D.33891;
  int D.33894;
  int D.33896;
  char D.33900;
  _Bool D.33901;
  _Bool D.33902;
  _Bool D.33903;
  long int p.350;
  long int start.351;
  long int D.33906;
  unsigned int D.33907;
  unsigned int D.33908;
  long unsigned int D.33911;
  char D.33912;
  _Bool D.33913;
  _Bool D.33914;
  _Bool D.33915;
  char * p.352;
  int found_sep;
  char * s;
  gboolean quoted;

  try
    {
      quoted = 0;
      memset (assembly, 0, 80);
      assembly->culture = "";
      D.33815 = &assembly->public_key_token;
      memset (D.33815, 0, 17);
      D.33816 = *p;
      if (D.33816 == 34) goto <D.33817>; else goto <D.33818>;
      <D.33817>:
      quoted = 1;
      p = p + 1;
      <D.33818>:
      assembly->name = p;
      goto <D.21421>;
      <D.21420>:
      p = p + 1;
      <D.21421>:
      D.33816 = *p;
      if (D.33816 != 0) goto <D.33819>; else goto <D.21422>;
      <D.33819>:
      D.33820 = __ctype_b_loc ();
      D.33821 = *D.33820;
      D.33816 = *p;
      D.33822 = (long unsigned int) D.33816;
      D.33823 = D.33822 * 2;
      D.33824 = D.33821 + D.33823;
      D.33825 = *D.33824;
      D.33826 = (int) D.33825;
      D.33827 = D.33826 & 8;
      if (D.33827 != 0) goto <D.21420>; else goto <D.33828>;
      <D.33828>:
      D.33816 = *p;
      if (D.33816 == 46) goto <D.21420>; else goto <D.33829>;
      <D.33829>:
      D.33816 = *p;
      if (D.33816 == 45) goto <D.21420>; else goto <D.33830>;
      <D.33830>:
      D.33816 = *p;
      if (D.33816 == 95) goto <D.21420>; else goto <D.33831>;
      <D.33831>:
      D.33816 = *p;
      if (D.33816 == 36) goto <D.21420>; else goto <D.33832>;
      <D.33832>:
      D.33816 = *p;
      if (D.33816 == 64) goto <D.21420>; else goto <D.33833>;
      <D.33833>:
      D.33820 = __ctype_b_loc ();
      D.33821 = *D.33820;
      D.33816 = *p;
      D.33822 = (long unsigned int) D.33816;
      D.33823 = D.33822 * 2;
      D.33824 = D.33821 + D.33823;
      D.33825 = *D.33824;
      D.33826 = (int) D.33825;
      D.33834 = D.33826 & 8192;
      if (D.33834 != 0) goto <D.21420>; else goto <D.21422>;
      <D.21422>:
      if (quoted != 0) goto <D.33835>; else goto <D.33836>;
      <D.33835>:
      D.33816 = *p;
      if (D.33816 != 34) goto <D.33837>; else goto <D.33838>;
      <D.33837>:
      D.33839 = 1;
      return D.33839;
      <D.33838>:
      *p = 0;
      p = p + 1;
      <D.33836>:
      D.33816 = *p;
      if (D.33816 != 44) goto <D.33840>; else goto <D.33841>;
      <D.33840>:
      D.33839 = 1;
      return D.33839;
      <D.33841>:
      *p = 0;
      s.345 = p + 18446744073709551615;
      s = s.345;
      goto <D.21424>;
      <D.21423>:
      s.346 = s;
      s.347 = s.346;
      s.348 = s.347 + 18446744073709551615;
      s = s.348;
      *s.347 = 0;
      <D.21424>:
      s.346 = s;
      D.33846 = *s.346;
      if (D.33846 != 0) goto <D.33847>; else goto <D.21425>;
      <D.33847>:
      D.33820 = __ctype_b_loc ();
      D.33821 = *D.33820;
      s.346 = s;
      D.33846 = *s.346;
      D.33848 = (long unsigned int) D.33846;
      D.33849 = D.33848 * 2;
      D.33850 = D.33821 + D.33849;
      D.33851 = *D.33850;
      D.33852 = (int) D.33851;
      D.33853 = D.33852 & 8192;
      if (D.33853 != 0) goto <D.21423>; else goto <D.21425>;
      <D.21425>:
      p = p + 1;
      goto <D.21427>;
      <D.21426>:
      p = p + 1;
      <D.21427>:
      D.33820 = __ctype_b_loc ();
      D.33821 = *D.33820;
      D.33816 = *p;
      D.33822 = (long unsigned int) D.33816;
      D.33823 = D.33822 * 2;
      D.33824 = D.33821 + D.33823;
      D.33825 = *D.33824;
      D.33826 = (int) D.33825;
      D.33834 = D.33826 & 8192;
      if (D.33834 != 0) goto <D.21426>; else goto <D.21428>;
      <D.21428>:
      goto <D.21453>;
      <D.21452>:
      D.33816 = *p;
      if (D.33816 == 86) goto <D.33856>; else goto <D.33854>;
      <D.33856>:
      D.33857 = monoeg_g_ascii_strncasecmp (p, "Version=", 8);
      if (D.33857 == 0) goto <D.33858>; else goto <D.33854>;
      <D.33858>:
      p = p + 8;
      D.33859 = strtoul (p, &s, 10);
      D.33860 = (short unsigned int) D.33859;
      assembly->major = D.33860;
      s.346 = s;
      if (s.346 == p) goto <D.33861>; else goto <D.33863>;
      <D.33863>:
      s.346 = s;
      D.33846 = *s.346;
      if (D.33846 != 46) goto <D.33861>; else goto <D.33862>;
      <D.33861>:
      D.33839 = 1;
      return D.33839;
      <D.33862>:
      s.346 = s;
      s.349 = s.346 + 1;
      s = s.349;
      p = s;
      D.33865 = strtoul (p, &s, 10);
      D.33866 = (short unsigned int) D.33865;
      assembly->minor = D.33866;
      s.346 = s;
      if (s.346 == p) goto <D.33867>; else goto <D.33869>;
      <D.33869>:
      s.346 = s;
      D.33846 = *s.346;
      if (D.33846 != 46) goto <D.33867>; else goto <D.33868>;
      <D.33867>:
      D.33839 = 1;
      return D.33839;
      <D.33868>:
      s.346 = s;
      s.349 = s.346 + 1;
      s = s.349;
      p = s;
      D.33870 = strtoul (p, &s, 10);
      D.33871 = (short unsigned int) D.33870;
      assembly->build = D.33871;
      s.346 = s;
      if (s.346 == p) goto <D.33872>; else goto <D.33874>;
      <D.33874>:
      s.346 = s;
      D.33846 = *s.346;
      if (D.33846 != 46) goto <D.33872>; else goto <D.33873>;
      <D.33872>:
      D.33839 = 1;
      return D.33839;
      <D.33873>:
      s.346 = s;
      s.349 = s.346 + 1;
      s = s.349;
      p = s;
      D.33875 = strtoul (p, &s, 10);
      D.33876 = (short unsigned int) D.33875;
      assembly->revision = D.33876;
      s.346 = s;
      if (s.346 == p) goto <D.33877>; else goto <D.33878>;
      <D.33877>:
      D.33839 = 1;
      return D.33839;
      <D.33878>:
      p = s;
      goto <D.33855>;
      <D.33854>:
      D.33816 = *p;
      if (D.33816 == 67) goto <D.33881>; else goto <D.33879>;
      <D.33881>:
      D.33882 = monoeg_g_ascii_strncasecmp (p, "Culture=", 8);
      if (D.33882 == 0) goto <D.33883>; else goto <D.33879>;
      <D.33883>:
      p = p + 8;
      D.33884 = monoeg_g_ascii_strncasecmp (p, "neutral", 7);
      if (D.33884 == 0) goto <D.33885>; else goto <D.33886>;
      <D.33885>:
      assembly->culture = "";
      p = p + 7;
      goto <D.33887>;
      <D.33886>:
      assembly->culture = p;
      goto <D.21430>;
      <D.21429>:
      p = p + 1;
      <D.21430>:
      D.33888 = *p;
      D.33889 = D.33888 != 0;
      D.33890 = D.33888 != 44;
      D.33891 = D.33889 & D.33890;
      if (D.33891 != 0) goto <D.21429>; else goto <D.21431>;
      <D.21431>:
      <D.33887>:
      goto <D.33880>;
      <D.33879>:
      D.33816 = *p;
      if (D.33816 == 80) goto <D.33893>; else goto <D.33892>;
      <D.33893>:
      D.33894 = monoeg_g_ascii_strncasecmp (p, "PublicKeyToken=", 15);
      if (D.33894 == 0) goto <D.33895>; else goto <D.33892>;
      <D.33895>:
      p = p + 15;
      D.33896 = strncmp (p, "null", 4);
      if (D.33896 == 0) goto <D.33897>; else goto <D.33898>;
      <D.33897>:
      p = p + 4;
      goto <D.33899>;
      <D.33898>:
      {
        int len;
        gchar * start;

        start = p;
        goto <D.21444>;
        <D.21443>:
        p = p + 1;
        <D.21444>:
        D.33900 = *p;
        D.33901 = D.33900 != 0;
        D.33902 = D.33900 != 44;
        D.33903 = D.33901 & D.33902;
        if (D.33903 != 0) goto <D.21443>; else goto <D.21445>;
        <D.21445>:
        p.350 = (long int) p;
        start.351 = (long int) start;
        D.33906 = p.350 - start.351;
        D.33907 = (unsigned int) D.33906;
        D.33908 = D.33907 + 1;
        len = (int) D.33908;
        if (len > 17) goto <D.33909>; else goto <D.33910>;
        <D.33909>:
        len = 17;
        <D.33910>:
        D.33911 = (long unsigned int) len;
        D.33815 = &assembly->public_key_token;
        monoeg_g_strlcpy (D.33815, start, D.33911);
      }
      <D.33899>:
      goto <D.21448>;
      <D.33892>:
      goto <D.21447>;
      <D.21446>:
      p = p + 1;
      <D.21447>:
      D.33912 = *p;
      D.33913 = D.33912 != 0;
      D.33914 = D.33912 != 44;
      D.33915 = D.33913 & D.33914;
      if (D.33915 != 0) goto <D.21446>; else goto <D.21448>;
      <D.21448>:
      <D.33880>:
      <D.33855>:
      found_sep = 0;
      goto <D.21449>;
      <D.21450>:
      p.352 = p;
      p = p.352 + 1;
      *p.352 = 0;
      found_sep = 1;
      // predicted unlikely by continue predictor.
      goto <D.21449>;
      <D.21449>:
      D.33820 = __ctype_b_loc ();
      D.33821 = *D.33820;
      D.33816 = *p;
      D.33822 = (long unsigned int) D.33816;
      D.33823 = D.33822 * 2;
      D.33824 = D.33821 + D.33823;
      D.33825 = *D.33824;
      D.33826 = (int) D.33825;
      D.33834 = D.33826 & 8192;
      if (D.33834 != 0) goto <D.21450>; else goto <D.33917>;
      <D.33917>:
      D.33816 = *p;
      if (D.33816 == 44) goto <D.21450>; else goto <D.21451>;
      <D.21451>:
      if (found_sep == 0) goto <D.33918>; else goto <D.33919>;
      <D.33918>:
      D.33839 = 1;
      return D.33839;
      <D.33919>:
      <D.21453>:
      D.33816 = *p;
      if (D.33816 != 0) goto <D.21452>; else goto <D.21454>;
      <D.21454>:
      D.33839 = 0;
      return D.33839;
    }
  finally
    {
      s = {CLOBBER};
    }
}


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

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


mono_reflection_get_type_with_rootimage (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase, gboolean * type_resolve)
{
  unsigned char D.33927;
  unsigned char D.33928;
  struct MonoAssembly * D.33930;
  struct MonoType * D.33933;
  struct MonoDomain * D.33934;
  int D.33935;
  int D.33940;
  char * D.33945;
  char D.33947;
  char * D.33949;
  void * D.33950;
  char * D.33951;
  struct MonoDomain * D.33952;
  struct MonoAssembly * D.33955;
  unsigned char D.33956;
  struct MonoImage * D.33960;
  struct MonoType * type;
  struct MonoReflectionAssembly * assembly;
  struct GString * fullName;
  struct GList * mod;

  if (image != 0B) goto <D.33926>; else goto <D.33924>;
  <D.33926>:
  D.33927 = BIT_FIELD_REF <*image, 8, 224>;
  D.33928 = D.33927 & 8;
  if (D.33928 != 0) goto <D.33929>; else goto <D.33924>;
  <D.33929>:
  D.33930 = image->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33930, info, ignorecase);
  goto <D.33925>;
  <D.33924>:
  type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
  <D.33925>:
  if (type != 0B) goto <D.33931>; else goto <D.33932>;
  <D.33931>:
  D.33933 = type;
  return D.33933;
  <D.33932>:
  D.33934 = mono_domain_get ();
  D.33935 = mono_domain_has_type_resolve (D.33934);
  if (D.33935 == 0) goto <D.33936>; else goto <D.33937>;
  <D.33936>:
  D.33933 = 0B;
  return D.33933;
  <D.33937>:
  if (type_resolve != 0B) goto <D.33938>; else goto <D.33939>;
  <D.33938>:
  D.33940 = *type_resolve;
  if (D.33940 != 0) goto <D.33941>; else goto <D.33942>;
  <D.33941>:
  D.33933 = 0B;
  return D.33933;
  <D.33942>:
  *type_resolve = 1;
  <D.33939>:
  fullName = monoeg_g_string_new ("");
  D.33945 = info->name_space;
  if (D.33945 != 0B) goto <D.33946>; else goto <D.33943>;
  <D.33946>:
  D.33945 = info->name_space;
  D.33947 = *D.33945;
  if (D.33947 != 0) goto <D.33948>; else goto <D.33943>;
  <D.33948>:
  D.33949 = info->name;
  D.33945 = info->name_space;
  monoeg_g_string_printf (fullName, "%s.%s", D.33945, D.33949);
  goto <D.33944>;
  <D.33943>:
  D.33949 = info->name;
  monoeg_g_string_printf (fullName, "%s", D.33949);
  <D.33944>:
  mod = info->nested;
  goto <D.21600>;
  <D.21599>:
  D.33950 = mod->data;
  monoeg_g_string_append_printf (fullName, "+%s", D.33950);
  mod = mod->next;
  <D.21600>:
  if (mod != 0B) goto <D.21599>; else goto <D.21601>;
  <D.21601>:
  D.33951 = fullName->str;
  D.33952 = mono_domain_get ();
  assembly = mono_domain_try_type_resolve (D.33952, D.33951, 0B);
  if (assembly != 0B) goto <D.33953>; else goto <D.33954>;
  <D.33953>:
  D.33955 = assembly->assembly;
  D.33956 = D.33955->dynamic;
  if (D.33956 != 0) goto <D.33957>; else goto <D.33958>;
  <D.33957>:
  D.33955 = assembly->assembly;
  type = mono_reflection_get_type_internal_dynamic (rootimage, D.33955, info, ignorecase);
  goto <D.33959>;
  <D.33958>:
  D.33955 = assembly->assembly;
  D.33960 = D.33955->image;
  type = mono_reflection_get_type_internal (rootimage, D.33960, info, ignorecase);
  <D.33959>:
  <D.33954>:
  monoeg_g_string_free (fullName, 1);
  D.33933 = type;
  return D.33933;
}


mono_reflection_get_type_internal_dynamic (struct MonoImage * rootimage, struct MonoAssembly * assembly, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  unsigned char D.33962;
  _Bool D.33963;
  long int D.33964;
  long int D.33965;
  struct MonoDomain * D.33968;
  struct MonoArray * D.33969;
  long unsigned int D.33972;
  char * D.33973;
  struct MonoDynamicImage * D.33974;
  struct MonoImage * D.33975;
  long unsigned int D.33977;
  struct MonoArray * D.33980;
  char * D.33983;
  struct MonoImage * D.33984;
  long unsigned int D.33986;
  struct MonoType * D.33987;
  struct MonoReflectionAssemblyBuilder * abuilder;
  struct MonoType * type;
  int i;

  D.33962 = assembly->dynamic;
  D.33963 = D.33962 == 0;
  D.33964 = (long int) D.33963;
  D.33965 = __builtin_expect (D.33964, 0);
  if (D.33965 != 0) goto <D.33966>; else goto <D.33967>;
  <D.33966>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7574, "assembly->dynamic");
  <D.33967>:
  D.33968 = MEM[(struct MonoDynamicAssembly *)assembly].domain;
  abuilder = mono_assembly_get_object (D.33968, assembly);
  type = 0B;
  D.33969 = abuilder->modules;
  if (D.33969 != 0B) goto <D.33970>; else goto <D.33971>;
  <D.33970>:
  i = 0;
  goto <D.21583>;
  <D.21582>:
  {
    struct MonoReflectionModuleBuilder * mb;

    D.33972 = (long unsigned int) i;
    D.33969 = abuilder->modules;
    D.33973 = mono_array_addr_with_size (D.33969, 8, D.33972);
    mb = MEM[(struct MonoReflectionModuleBuilder * *)D.33973];
    D.33974 = mb->dynamic_image;
    D.33975 = &D.33974->image;
    type = mono_reflection_get_type_internal (rootimage, D.33975, info, ignorecase);
    if (type != 0B) goto <D.21581>; else goto <D.33976>;
    <D.33976>:
  }
  i = i + 1;
  <D.21583>:
  D.33972 = (long unsigned int) i;
  D.33969 = abuilder->modules;
  D.33977 = mono_array_length (D.33969);
  if (D.33972 < D.33977) goto <D.21582>; else goto <D.21581>;
  <D.21581>:
  <D.33971>:
  if (type == 0B) goto <D.33978>; else goto <D.33979>;
  <D.33978>:
  D.33980 = abuilder->loaded_modules;
  if (D.33980 != 0B) goto <D.33981>; else goto <D.33982>;
  <D.33981>:
  i = 0;
  goto <D.21587>;
  <D.21586>:
  {
    struct MonoReflectionModule * mod;

    D.33972 = (long unsigned int) i;
    D.33980 = abuilder->loaded_modules;
    D.33983 = mono_array_addr_with_size (D.33980, 8, D.33972);
    mod = MEM[(struct MonoReflectionModule * *)D.33983];
    D.33984 = mod->image;
    type = mono_reflection_get_type_internal (rootimage, D.33984, info, ignorecase);
    if (type != 0B) goto <D.21585>; else goto <D.33985>;
    <D.33985>:
  }
  i = i + 1;
  <D.21587>:
  D.33972 = (long unsigned int) i;
  D.33980 = abuilder->loaded_modules;
  D.33986 = mono_array_length (D.33980);
  if (D.33972 < D.33986) goto <D.21586>; else goto <D.21585>;
  <D.21585>:
  <D.33982>:
  <D.33979>:
  D.33987 = type;
  return D.33987;
}


mono_reflection_get_type_internal (struct MonoImage * rootimage, struct MonoImage * image, struct MonoTypeNameParse * info, gboolean ignorecase)
{
  char * D.33993;
  char * D.33994;
  struct MonoType * D.33998;
  void * D.34001;
  const char * D.34002;
  int D.34003;
  int D.21548;
  struct GPtrArray * D.34010;
  unsigned int D.34013;
  long unsigned int D.34014;
  long unsigned int D.34015;
  void * * D.34016;
  long unsigned int D.34017;
  long unsigned int D.34018;
  void * * D.34019;
  struct MonoType * * D.34020;
  struct MonoType * D.34021;
  struct MonoType * D.34022;
  unsigned int i.353;
  struct MonoType * D.34026;
  struct MonoDomain * D.34027;
  int D.34028;
  long int D.34031;
  unsigned int modval.354;
  struct MonoClass * klass;
  struct GList * mod;
  int modval;
  gboolean bounded;

  bounded = 0;
  if (image == 0B) goto <D.33989>; else goto <D.33990>;
  <D.33989>:
  image = mono_defaults.corlib;
  <D.33990>:
  if (ignorecase != 0) goto <D.33991>; else goto <D.33992>;
  <D.33991>:
  D.33993 = info->name;
  D.33994 = info->name_space;
  klass = mono_class_from_name_case (image, D.33994, D.33993);
  goto <D.33995>;
  <D.33992>:
  D.33993 = info->name;
  D.33994 = info->name_space;
  klass = mono_class_from_name (image, D.33994, D.33993);
  <D.33995>:
  if (klass == 0B) goto <D.33996>; else goto <D.33997>;
  <D.33996>:
  D.33998 = 0B;
  return D.33998;
  <D.33997>:
  mod = info->nested;
  goto <D.21553>;
  <D.21552>:
  {
    void * iter;
    struct MonoClass * parent;

    try
      {
        iter = 0B;
        parent = klass;
        mono_class_init (parent);
        goto <D.21550>;
        <D.21549>:
        if (ignorecase != 0) goto <D.33999>; else goto <D.34000>;
        <D.33999>:
        D.34001 = mod->data;
        D.34002 = klass->name;
        D.34003 = monoeg_ascii_strcasecmp (D.34002, D.34001);
        if (D.34003 == 0) goto <D.21539>; else goto <D.34004>;
        <D.34004>:
        goto <D.34005>;
        <D.34000>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.34001 = mod->data;
          D.34002 = klass->name;
          D.21548 = __builtin_strcmp (D.34002, D.34001);
        }
        if (D.21548 == 0) goto <D.21539>; else goto <D.34006>;
        <D.34006>:
        <D.34005>:
        <D.21550>:
        klass = mono_class_get_nested_types (parent, &iter);
        if (klass != 0B) goto <D.21549>; else goto <D.21539>;
        <D.21539>:
        if (klass == 0B) goto <D.21551>; else goto <D.34007>;
        <D.34007>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  mod = mod->next;
  <D.21553>:
  if (mod != 0B) goto <D.21552>; else goto <D.21551>;
  <D.21551>:
  if (klass == 0B) goto <D.34008>; else goto <D.34009>;
  <D.34008>:
  D.33998 = 0B;
  return D.33998;
  <D.34009>:
  D.34010 = info->type_arguments;
  if (D.34010 != 0B) goto <D.34011>; else goto <D.34012>;
  <D.34011>:
  {
    struct MonoType * * type_args;
    struct MonoReflectionType * the_type;
    struct MonoType * instance;
    int i;

    D.34010 = info->type_arguments;
    D.34013 = D.34010->len;
    D.34014 = (long unsigned int) D.34013;
    D.34015 = D.34014 * 8;
    type_args = monoeg_malloc0 (D.34015);
    i = 0;
    goto <D.21560>;
    <D.21559>:
    {
      struct MonoTypeNameParse * subinfo;

      D.34010 = info->type_arguments;
      D.34016 = D.34010->pdata;
      D.34017 = (long unsigned int) i;
      D.34018 = D.34017 * 8;
      D.34019 = D.34016 + D.34018;
      subinfo = *D.34019;
      D.34017 = (long unsigned int) i;
      D.34018 = D.34017 * 8;
      D.34020 = type_args + D.34018;
      D.34021 = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
      *D.34020 = D.34021;
      D.34017 = (long unsigned int) i;
      D.34018 = D.34017 * 8;
      D.34020 = type_args + D.34018;
      D.34022 = *D.34020;
      if (D.34022 == 0B) goto <D.34023>; else goto <D.34024>;
      <D.34023>:
      monoeg_g_free (type_args);
      D.33998 = 0B;
      return D.33998;
      <D.34024>:
    }
    i = i + 1;
    <D.21560>:
    i.353 = (unsigned int) i;
    D.34010 = info->type_arguments;
    D.34013 = D.34010->len;
    if (i.353 < D.34013) goto <D.21559>; else goto <D.21561>;
    <D.21561>:
    D.34026 = &klass->byval_arg;
    D.34027 = mono_domain_get ();
    the_type = mono_type_get_object (D.34027, D.34026);
    D.34010 = info->type_arguments;
    D.34013 = D.34010->len;
    D.34028 = (int) D.34013;
    instance = mono_reflection_bind_generic_parameters (the_type, D.34028, type_args);
    monoeg_g_free (type_args);
    if (instance == 0B) goto <D.34029>; else goto <D.34030>;
    <D.34029>:
    D.33998 = 0B;
    return D.33998;
    <D.34030>:
    klass = mono_class_from_mono_type (instance);
  }
  <D.34012>:
  mod = info->modifiers;
  goto <D.21563>;
  <D.21562>:
  D.34001 = mod->data;
  D.34031 = (long int) D.34001;
  modval = (int) D.34031;
  if (modval == 0) goto <D.34032>; else goto <D.34033>;
  <D.34032>:
  D.33998 = &klass->this_arg;
  return D.33998;
  <D.34033>:
  if (modval == -1) goto <D.34034>; else goto <D.34035>;
  <D.34034>:
  D.34026 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.34026);
  goto <D.34036>;
  <D.34035>:
  if (modval == -2) goto <D.34037>; else goto <D.34038>;
  <D.34037>:
  bounded = 1;
  goto <D.34039>;
  <D.34038>:
  modval.354 = (unsigned int) modval;
  klass = mono_bounded_array_class_get (klass, modval.354, bounded);
  <D.34039>:
  <D.34036>:
  mod = mod->next;
  <D.21563>:
  if (mod != 0B) goto <D.21562>; else goto <D.21564>;
  <D.21564>:
  D.33998 = &klass->byval_arg;
  return D.33998;
}


_mono_reflection_get_type_from_info (struct MonoTypeNameParse * info, struct MonoImage * image, gboolean ignorecase)
{
  const char * D.34044;
  struct MonoAssemblyName * D.34047;
  _Bool D.34048;
  _Bool D.34049;
  _Bool D.34050;
  struct MonoAssembly * D.34053;
  struct MonoAssemblyName * D.34056;
  int D.34057;
  struct MonoType * D.34064;
  struct MonoImage * D.34072;
  gboolean type_resolve;
  struct MonoType * type;
  struct MonoImage * rootimage;

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

        D.34047 = &info->assembly;
        assembly = mono_assembly_loaded (D.34047);
        D.34048 = assembly == 0B;
        D.34049 = image != 0B;
        D.34050 = D.34048 & D.34049;
        if (D.34050 != 0) goto <D.34051>; else goto <D.34052>;
        <D.34051>:
        D.34053 = image->assembly;
        if (D.34053 != 0B) goto <D.34054>; else goto <D.34055>;
        <D.34054>:
        D.34053 = image->assembly;
        D.34056 = &D.34053->aname;
        D.34047 = &info->assembly;
        D.34057 = mono_assembly_names_equal (D.34047, D.34056);
        if (D.34057 != 0) goto <D.34058>; else goto <D.34059>;
        <D.34058>:
        assembly = image->assembly;
        <D.34059>:
        <D.34055>:
        <D.34052>:
        if (assembly == 0B) goto <D.34060>; else goto <D.34061>;
        <D.34060>:
        D.34047 = &info->assembly;
        assembly = mono_assembly_load (D.34047, 0B, 0B);
        if (assembly == 0B) goto <D.34062>; else goto <D.34063>;
        <D.34062>:
        D.34064 = 0B;
        return D.34064;
        <D.34063>:
        <D.34061>:
        image = assembly->image;
      }
      goto <D.34065>;
      <D.34046>:
      if (image == 0B) goto <D.34066>; else goto <D.34067>;
      <D.34066>:
      image = mono_defaults.corlib;
      <D.34067>:
      <D.34065>:
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      if (type == 0B) goto <D.34068>; else goto <D.34069>;
      <D.34068>:
      D.34044 = info->assembly.name;
      if (D.34044 == 0B) goto <D.34070>; else goto <D.34071>;
      <D.34070>:
      D.34072 = mono_defaults.corlib;
      if (D.34072 != image) goto <D.34073>; else goto <D.34074>;
      <D.34073>:
      image = mono_defaults.corlib;
      type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
      <D.34074>:
      <D.34071>:
      <D.34069>:
      D.34064 = type;
      return D.34064;
    }
  finally
    {
      type_resolve = {CLOBBER};
    }
}


mono_reflection_free_type_info (struct MonoTypeNameParse * info)
{
  struct GList * D.34077;
  struct GList * D.34078;
  struct GPtrArray * D.34079;
  void * * D.34082;
  long unsigned int D.34083;
  long unsigned int D.34084;
  void * * D.34085;
  unsigned int i.355;
  unsigned int D.34087;

  D.34077 = info->modifiers;
  monoeg_g_list_free (D.34077);
  D.34078 = info->nested;
  monoeg_g_list_free (D.34078);
  D.34079 = info->type_arguments;
  if (D.34079 != 0B) goto <D.34080>; else goto <D.34081>;
  <D.34080>:
  {
    int i;

    i = 0;
    goto <D.21608>;
    <D.21607>:
    {
      struct MonoTypeNameParse * subinfo;

      D.34079 = info->type_arguments;
      D.34082 = D.34079->pdata;
      D.34083 = (long unsigned int) i;
      D.34084 = D.34083 * 8;
      D.34085 = D.34082 + D.34084;
      subinfo = *D.34085;
      mono_reflection_free_type_info (subinfo);
      monoeg_g_free (subinfo);
    }
    i = i + 1;
    <D.21608>:
    i.355 = (unsigned int) i;
    D.34079 = info->type_arguments;
    D.34087 = D.34079->len;
    if (i.355 < D.34087) goto <D.21607>; else goto <D.21609>;
    <D.21609>:
    D.34079 = info->type_arguments;
    monoeg_g_ptr_array_free (D.34079, 1);
  }
  <D.34081>:
}


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

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


mono_reflection_get_token (struct MonoObject * obj)
{
  struct MonoVTable * D.34094;
  int D.21630;
  int iftmp.356;
  int D.21629;
  const char[14] * D.34098;
  unsigned char D.34099;
  int D.34100;
  unsigned char D.34101;
  int D.34102;
  _Bool D.34103;
  _Bool D.34104;
  _Bool D.34105;
  const unsigned char * D.34108;
  unsigned char D.34109;
  int D.34110;
  const unsigned char * D.34111;
  unsigned char D.34112;
  int D.34113;
  _Bool D.34114;
  _Bool D.34115;
  const unsigned char * D.34118;
  unsigned char D.34119;
  int D.34120;
  const unsigned char * D.34121;
  unsigned char D.34122;
  int D.34123;
  _Bool D.34124;
  _Bool D.34125;
  const unsigned char * D.34128;
  unsigned char D.34129;
  int D.34130;
  const unsigned char * D.34131;
  unsigned char D.34132;
  int D.34133;
  const char * D.34135;
  unsigned int D.34138;
  int D.21640;
  int iftmp.357;
  int D.21639;
  const char[19] * D.34143;
  unsigned char D.34144;
  int D.34145;
  unsigned char D.34146;
  int D.34147;
  _Bool D.34148;
  _Bool D.34149;
  _Bool D.34150;
  const unsigned char * D.34153;
  unsigned char D.34154;
  int D.34155;
  const unsigned char * D.34156;
  unsigned char D.34157;
  int D.34158;
  _Bool D.34159;
  _Bool D.34160;
  const unsigned char * D.34163;
  unsigned char D.34164;
  int D.34165;
  const unsigned char * D.34166;
  unsigned char D.34167;
  int D.34168;
  _Bool D.34169;
  _Bool D.34170;
  const unsigned char * D.34173;
  unsigned char D.34174;
  int D.34175;
  const unsigned char * D.34176;
  unsigned char D.34177;
  int D.34178;
  unsigned int D.34182;
  int D.21650;
  int iftmp.358;
  int D.21649;
  const char[13] * D.34187;
  unsigned char D.34188;
  int D.34189;
  unsigned char D.34190;
  int D.34191;
  _Bool D.34192;
  _Bool D.34193;
  _Bool D.34194;
  const unsigned char * D.34197;
  unsigned char D.34198;
  int D.34199;
  const unsigned char * D.34200;
  unsigned char D.34201;
  int D.34202;
  _Bool D.34203;
  _Bool D.34204;
  const unsigned char * D.34207;
  unsigned char D.34208;
  int D.34209;
  const unsigned char * D.34210;
  unsigned char D.34211;
  int D.34212;
  _Bool D.34213;
  _Bool D.34214;
  const unsigned char * D.34217;
  unsigned char D.34218;
  int D.34219;
  const unsigned char * D.34220;
  unsigned char D.34221;
  int D.34222;
  int D.34226;
  int D.34227;
  int D.21660;
  int iftmp.359;
  int D.21659;
  const char[12] * D.34232;
  unsigned char D.34233;
  int D.34234;
  unsigned char D.34235;
  int D.34236;
  _Bool D.34237;
  _Bool D.34238;
  _Bool D.34239;
  const unsigned char * D.34242;
  unsigned char D.34243;
  int D.34244;
  const unsigned char * D.34245;
  unsigned char D.34246;
  int D.34247;
  _Bool D.34248;
  _Bool D.34249;
  const unsigned char * D.34252;
  unsigned char D.34253;
  int D.34254;
  const unsigned char * D.34255;
  unsigned char D.34256;
  int D.34257;
  _Bool D.34258;
  _Bool D.34259;
  const unsigned char * D.34262;
  unsigned char D.34263;
  int D.34264;
  const unsigned char * D.34265;
  unsigned char D.34266;
  int D.34267;
  unsigned int D.34271;
  int D.21670;
  int iftmp.360;
  int D.21669;
  const char[9] * D.34276;
  unsigned char D.34277;
  int D.34278;
  unsigned char D.34279;
  int D.34280;
  _Bool D.34281;
  _Bool D.34282;
  _Bool D.34283;
  const unsigned char * D.34286;
  unsigned char D.34287;
  int D.34288;
  const unsigned char * D.34289;
  unsigned char D.34290;
  int D.34291;
  _Bool D.34292;
  _Bool D.34293;
  const unsigned char * D.34296;
  unsigned char D.34297;
  int D.34298;
  const unsigned char * D.34299;
  unsigned char D.34300;
  int D.34301;
  _Bool D.34302;
  _Bool D.34303;
  const unsigned char * D.34306;
  unsigned char D.34307;
  int D.34308;
  const unsigned char * D.34309;
  unsigned char D.34310;
  int D.34311;
  int D.34315;
  struct MonoException * D.34318;
  int D.21681;
  int iftmp.361;
  int D.21680;
  const char[12] * D.34326;
  unsigned char D.34327;
  int D.34328;
  unsigned char D.34329;
  int D.34330;
  _Bool D.34331;
  _Bool D.34332;
  _Bool D.34333;
  const unsigned char * D.34336;
  unsigned char D.34337;
  int D.34338;
  const unsigned char * D.34339;
  unsigned char D.34340;
  int D.34341;
  _Bool D.34342;
  _Bool D.34343;
  const unsigned char * D.34346;
  unsigned char D.34347;
  int D.34348;
  const unsigned char * D.34349;
  unsigned char D.34350;
  int D.34351;
  _Bool D.34352;
  _Bool D.34353;
  const unsigned char * D.34356;
  unsigned char D.34357;
  int D.34358;
  const unsigned char * D.34359;
  unsigned char D.34360;
  int D.34361;
  int D.21690;
  int iftmp.362;
  int D.21689;
  const char[11] * D.34367;
  unsigned char D.34368;
  int D.34369;
  unsigned char D.34370;
  int D.34371;
  _Bool D.34372;
  _Bool D.34373;
  _Bool D.34374;
  const unsigned char * D.34377;
  unsigned char D.34378;
  int D.34379;
  const unsigned char * D.34380;
  unsigned char D.34381;
  int D.34382;
  _Bool D.34383;
  _Bool D.34384;
  const unsigned char * D.34387;
  unsigned char D.34388;
  int D.34389;
  const unsigned char * D.34390;
  unsigned char D.34391;
  int D.34392;
  _Bool D.34393;
  _Bool D.34394;
  const unsigned char * D.34397;
  unsigned char D.34398;
  int D.34399;
  const unsigned char * D.34400;
  unsigned char D.34401;
  int D.34402;
  int D.21699;
  int iftmp.363;
  int D.21698;
  const char[18] * D.34408;
  unsigned char D.34409;
  int D.34410;
  unsigned char D.34411;
  int D.34412;
  _Bool D.34413;
  _Bool D.34414;
  _Bool D.34415;
  const unsigned char * D.34418;
  unsigned char D.34419;
  int D.34420;
  const unsigned char * D.34421;
  unsigned char D.34422;
  int D.34423;
  _Bool D.34424;
  _Bool D.34425;
  const unsigned char * D.34428;
  unsigned char D.34429;
  int D.34430;
  const unsigned char * D.34431;
  unsigned char D.34432;
  int D.34433;
  _Bool D.34434;
  _Bool D.34435;
  const unsigned char * D.34438;
  unsigned char D.34439;
  int D.34440;
  const unsigned char * D.34441;
  unsigned char D.34442;
  int D.34443;
  int D.21708;
  int iftmp.364;
  int D.21707;
  const char[19] * D.34449;
  unsigned char D.34450;
  int D.34451;
  unsigned char D.34452;
  int D.34453;
  _Bool D.34454;
  _Bool D.34455;
  _Bool D.34456;
  const unsigned char * D.34459;
  unsigned char D.34460;
  int D.34461;
  const unsigned char * D.34462;
  unsigned char D.34463;
  int D.34464;
  _Bool D.34465;
  _Bool D.34466;
  const unsigned char * D.34469;
  unsigned char D.34470;
  int D.34471;
  const unsigned char * D.34472;
  unsigned char D.34473;
  int D.34474;
  _Bool D.34475;
  _Bool D.34476;
  const unsigned char * D.34479;
  unsigned char D.34480;
  int D.34481;
  const unsigned char * D.34482;
  unsigned char D.34483;
  int D.34484;
  struct MonoMethod * D.34486;
  unsigned char D.34487;
  unsigned char D.34488;
  uint32_t D.34491;
  struct MonoMethod * D.34492;
  int D.21719;
  int iftmp.365;
  int D.21718;
  const char[10] * D.34496;
  unsigned char D.34497;
  int D.34498;
  unsigned char D.34499;
  int D.34500;
  _Bool D.34501;
  _Bool D.34502;
  _Bool D.34503;
  const unsigned char * D.34506;
  unsigned char D.34507;
  int D.34508;
  const unsigned char * D.34509;
  unsigned char D.34510;
  int D.34511;
  _Bool D.34512;
  _Bool D.34513;
  const unsigned char * D.34516;
  unsigned char D.34517;
  int D.34518;
  const unsigned char * D.34519;
  unsigned char D.34520;
  int D.34521;
  _Bool D.34522;
  _Bool D.34523;
  const unsigned char * D.34526;
  unsigned char D.34527;
  int D.34528;
  const unsigned char * D.34529;
  unsigned char D.34530;
  int D.34531;
  struct MonoClassField * D.34535;
  int D.34536;
  struct MonoClass * D.34539;
  long int D.34540;
  struct MonoClassField * D.34541;
  long int D.34542;
  long int D.34543;
  long int D.34544;
  int iftmp.366;
  int D.34550;
  _Bool D.34551;
  long int D.34552;
  long int D.34553;
  struct MonoObject * * D.34556;
  long unsigned int D.34557;
  long unsigned int D.34558;
  struct MonoObject * * D.34559;
  int D.21732;
  int iftmp.367;
  int D.21731;
  const char[13] * D.34564;
  unsigned char D.34565;
  int D.34566;
  unsigned char D.34567;
  int D.34568;
  _Bool D.34569;
  _Bool D.34570;
  _Bool D.34571;
  const unsigned char * D.34574;
  unsigned char D.34575;
  int D.34576;
  const unsigned char * D.34577;
  unsigned char D.34578;
  int D.34579;
  _Bool D.34580;
  _Bool D.34581;
  const unsigned char * D.34584;
  unsigned char D.34585;
  int D.34586;
  const unsigned char * D.34587;
  unsigned char D.34588;
  int D.34589;
  _Bool D.34590;
  _Bool D.34591;
  const unsigned char * D.34594;
  unsigned char D.34595;
  int D.34596;
  const unsigned char * D.34597;
  unsigned char D.34598;
  int D.34599;
  struct MonoProperty * D.34603;
  int D.21742;
  int iftmp.368;
  int D.21741;
  const char[10] * D.34608;
  unsigned char D.34609;
  int D.34610;
  unsigned char D.34611;
  int D.34612;
  _Bool D.34613;
  _Bool D.34614;
  _Bool D.34615;
  const unsigned char * D.34618;
  unsigned char D.34619;
  int D.34620;
  const unsigned char * D.34621;
  unsigned char D.34622;
  int D.34623;
  _Bool D.34624;
  _Bool D.34625;
  const unsigned char * D.34628;
  unsigned char D.34629;
  int D.34630;
  const unsigned char * D.34631;
  unsigned char D.34632;
  int D.34633;
  _Bool D.34634;
  _Bool D.34635;
  const unsigned char * D.34638;
  unsigned char D.34639;
  int D.34640;
  const unsigned char * D.34641;
  unsigned char D.34642;
  int D.34643;
  struct MonoEvent * D.34647;
  int D.21752;
  int iftmp.369;
  int D.21751;
  const char[14] * D.34655;
  unsigned char D.34656;
  int D.34657;
  unsigned char D.34658;
  int D.34659;
  _Bool D.34660;
  _Bool D.34661;
  _Bool D.34662;
  const unsigned char * D.34665;
  unsigned char D.34666;
  int D.34667;
  const unsigned char * D.34668;
  unsigned char D.34669;
  int D.34670;
  _Bool D.34671;
  _Bool D.34672;
  const unsigned char * D.34675;
  unsigned char D.34676;
  int D.34677;
  const unsigned char * D.34678;
  unsigned char D.34679;
  int D.34680;
  _Bool D.34681;
  _Bool D.34682;
  const unsigned char * D.34685;
  unsigned char D.34686;
  int D.34687;
  const unsigned char * D.34688;
  unsigned char D.34689;
  int D.34690;
  int D.21761;
  int iftmp.370;
  int D.21760;
  const char[18] * D.34696;
  unsigned char D.34697;
  int D.34698;
  unsigned char D.34699;
  int D.34700;
  _Bool D.34701;
  _Bool D.34702;
  _Bool D.34703;
  const unsigned char * D.34706;
  unsigned char D.34707;
  int D.34708;
  const unsigned char * D.34709;
  unsigned char D.34710;
  int D.34711;
  _Bool D.34712;
  _Bool D.34713;
  const unsigned char * D.34716;
  unsigned char D.34717;
  int D.34718;
  const unsigned char * D.34719;
  unsigned char D.34720;
  int D.34721;
  _Bool D.34722;
  _Bool D.34723;
  const unsigned char * D.34726;
  unsigned char D.34727;
  int D.34728;
  const unsigned char * D.34729;
  unsigned char D.34730;
  int D.34731;
  struct MonoObject * D.34733;
  struct MonoVTable * D.34734;
  int D.34735;
  _Bool D.34736;
  long int D.34737;
  long int D.34738;
  int D.34741;
  struct MonoMethod * D.34742;
  int D.21772;
  int iftmp.371;
  int D.21771;
  const char[7] * D.34749;
  unsigned char D.34750;
  int D.34751;
  unsigned char D.34752;
  int D.34753;
  _Bool D.34754;
  _Bool D.34755;
  _Bool D.34756;
  const unsigned char * D.34759;
  unsigned char D.34760;
  int D.34761;
  const unsigned char * D.34762;
  unsigned char D.34763;
  int D.34764;
  _Bool D.34765;
  _Bool D.34766;
  const unsigned char * D.34769;
  unsigned char D.34770;
  int D.34771;
  const unsigned char * D.34772;
  unsigned char D.34773;
  int D.34774;
  _Bool D.34775;
  _Bool D.34776;
  const unsigned char * D.34779;
  unsigned char D.34780;
  int D.34781;
  const unsigned char * D.34782;
  unsigned char D.34783;
  int D.34784;
  int D.21781;
  int iftmp.372;
  int D.21780;
  const char[11] * D.34790;
  unsigned char D.34791;
  int D.34792;
  unsigned char D.34793;
  int D.34794;
  _Bool D.34795;
  _Bool D.34796;
  _Bool D.34797;
  const unsigned char * D.34800;
  unsigned char D.34801;
  int D.34802;
  const unsigned char * D.34803;
  unsigned char D.34804;
  int D.34805;
  _Bool D.34806;
  _Bool D.34807;
  const unsigned char * D.34810;
  unsigned char D.34811;
  int D.34812;
  const unsigned char * D.34813;
  unsigned char D.34814;
  int D.34815;
  _Bool D.34816;
  _Bool D.34817;
  const unsigned char * D.34820;
  unsigned char D.34821;
  int D.34822;
  const unsigned char * D.34823;
  unsigned char D.34824;
  int D.34825;
  int D.21791;
  int iftmp.373;
  int D.21790;
  const char[9] * D.34833;
  unsigned char D.34834;
  int D.34835;
  unsigned char D.34836;
  int D.34837;
  _Bool D.34838;
  _Bool D.34839;
  _Bool D.34840;
  const unsigned char * D.34843;
  unsigned char D.34844;
  int D.34845;
  const unsigned char * D.34846;
  unsigned char D.34847;
  int D.34848;
  _Bool D.34849;
  _Bool D.34850;
  const unsigned char * D.34853;
  unsigned char D.34854;
  int D.34855;
  const unsigned char * D.34856;
  unsigned char D.34857;
  int D.34858;
  _Bool D.34859;
  _Bool D.34860;
  const unsigned char * D.34863;
  unsigned char D.34864;
  int D.34865;
  const unsigned char * D.34866;
  unsigned char D.34867;
  int D.34868;
  int D.21800;
  int iftmp.374;
  int D.21799;
  const char[13] * D.34874;
  unsigned char D.34875;
  int D.34876;
  unsigned char D.34877;
  int D.34878;
  _Bool D.34879;
  _Bool D.34880;
  _Bool D.34881;
  const unsigned char * D.34884;
  unsigned char D.34885;
  int D.34886;
  const unsigned char * D.34887;
  unsigned char D.34888;
  int D.34889;
  _Bool D.34890;
  _Bool D.34891;
  const unsigned char * D.34894;
  unsigned char D.34895;
  int D.34896;
  const unsigned char * D.34897;
  unsigned char D.34898;
  int D.34899;
  _Bool D.34900;
  _Bool D.34901;
  const unsigned char * D.34904;
  unsigned char D.34905;
  int D.34906;
  const unsigned char * D.34907;
  unsigned char D.34908;
  int D.34909;
  const char * D.34911;
  struct MonoClass * klass;
  guint32 token;

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

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

      __s2 = klass->name;
      D.34098 = "MethodBuilder";
      D.34099 = MEM[(const unsigned char *)D.34098];
      D.34100 = (int) D.34099;
      D.34101 = *__s2;
      D.34102 = (int) D.34101;
      __result = D.34100 - D.34102;
      {
        D.34103 = __s2_len != 0;
        D.34104 = __result == 0;
        D.34105 = D.34103 & D.34104;
        if (D.34105 != 0) goto <D.34106>; else goto <D.34107>;
        <D.34106>:
        D.34108 = &MEM[(void *)"MethodBuilder" + 1B];
        D.34109 = *D.34108;
        D.34110 = (int) D.34109;
        D.34111 = __s2 + 1;
        D.34112 = *D.34111;
        D.34113 = (int) D.34112;
        __result = D.34110 - D.34113;
        D.34114 = __s2_len > 1;
        D.34104 = __result == 0;
        D.34115 = D.34114 & D.34104;
        if (D.34115 != 0) goto <D.34116>; else goto <D.34117>;
        <D.34116>:
        D.34118 = &MEM[(void *)"MethodBuilder" + 2B];
        D.34119 = *D.34118;
        D.34120 = (int) D.34119;
        D.34121 = __s2 + 2;
        D.34122 = *D.34121;
        D.34123 = (int) D.34122;
        __result = D.34120 - D.34123;
        D.34124 = __s2_len > 2;
        D.34104 = __result == 0;
        D.34125 = D.34124 & D.34104;
        if (D.34125 != 0) goto <D.34126>; else goto <D.34127>;
        <D.34126>:
        D.34128 = &MEM[(void *)"MethodBuilder" + 3B];
        D.34129 = *D.34128;
        D.34130 = (int) D.34129;
        D.34131 = __s2 + 3;
        D.34132 = *D.34131;
        D.34133 = (int) D.34132;
        __result = D.34130 - D.34133;
        <D.34127>:
        <D.34117>:
        <D.34107>:
      }
      D.21629 = __result;
    }
    iftmp.356 = -D.21629;
    goto <D.34134>;
    <D.34097>:
    D.34135 = klass->name;
    iftmp.356 = __builtin_strcmp (D.34135, "MethodBuilder");
    <D.34134>:
    D.21630 = iftmp.356;
  }
  if (D.21630 == 0) goto <D.34136>; else goto <D.34137>;
  <D.34136>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.34138 = mb->table_idx;
    token = D.34138 | 100663296;
  }
  goto <D.34139>;
  <D.34137>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34143 = "ConstructorBuilder";
      D.34144 = MEM[(const unsigned char *)D.34143];
      D.34145 = (int) D.34144;
      D.34146 = *__s2;
      D.34147 = (int) D.34146;
      __result = D.34145 - D.34147;
      {
        D.34148 = __s2_len != 0;
        D.34149 = __result == 0;
        D.34150 = D.34148 & D.34149;
        if (D.34150 != 0) goto <D.34151>; else goto <D.34152>;
        <D.34151>:
        D.34153 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.34154 = *D.34153;
        D.34155 = (int) D.34154;
        D.34156 = __s2 + 1;
        D.34157 = *D.34156;
        D.34158 = (int) D.34157;
        __result = D.34155 - D.34158;
        D.34159 = __s2_len > 1;
        D.34149 = __result == 0;
        D.34160 = D.34159 & D.34149;
        if (D.34160 != 0) goto <D.34161>; else goto <D.34162>;
        <D.34161>:
        D.34163 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.34164 = *D.34163;
        D.34165 = (int) D.34164;
        D.34166 = __s2 + 2;
        D.34167 = *D.34166;
        D.34168 = (int) D.34167;
        __result = D.34165 - D.34168;
        D.34169 = __s2_len > 2;
        D.34149 = __result == 0;
        D.34170 = D.34169 & D.34149;
        if (D.34170 != 0) goto <D.34171>; else goto <D.34172>;
        <D.34171>:
        D.34173 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.34174 = *D.34173;
        D.34175 = (int) D.34174;
        D.34176 = __s2 + 3;
        D.34177 = *D.34176;
        D.34178 = (int) D.34177;
        __result = D.34175 - D.34178;
        <D.34172>:
        <D.34162>:
        <D.34152>:
      }
      D.21639 = __result;
    }
    iftmp.357 = -D.21639;
    goto <D.34179>;
    <D.34142>:
    D.34135 = klass->name;
    iftmp.357 = __builtin_strcmp (D.34135, "ConstructorBuilder");
    <D.34179>:
    D.21640 = iftmp.357;
  }
  if (D.21640 == 0) goto <D.34180>; else goto <D.34181>;
  <D.34180>:
  {
    struct MonoReflectionCtorBuilder * mb;

    mb = obj;
    D.34182 = mb->table_idx;
    token = D.34182 | 100663296;
  }
  goto <D.34183>;
  <D.34181>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34187 = "FieldBuilder";
      D.34188 = MEM[(const unsigned char *)D.34187];
      D.34189 = (int) D.34188;
      D.34190 = *__s2;
      D.34191 = (int) D.34190;
      __result = D.34189 - D.34191;
      {
        D.34192 = __s2_len != 0;
        D.34193 = __result == 0;
        D.34194 = D.34192 & D.34193;
        if (D.34194 != 0) goto <D.34195>; else goto <D.34196>;
        <D.34195>:
        D.34197 = &MEM[(void *)"FieldBuilder" + 1B];
        D.34198 = *D.34197;
        D.34199 = (int) D.34198;
        D.34200 = __s2 + 1;
        D.34201 = *D.34200;
        D.34202 = (int) D.34201;
        __result = D.34199 - D.34202;
        D.34203 = __s2_len > 1;
        D.34193 = __result == 0;
        D.34204 = D.34203 & D.34193;
        if (D.34204 != 0) goto <D.34205>; else goto <D.34206>;
        <D.34205>:
        D.34207 = &MEM[(void *)"FieldBuilder" + 2B];
        D.34208 = *D.34207;
        D.34209 = (int) D.34208;
        D.34210 = __s2 + 2;
        D.34211 = *D.34210;
        D.34212 = (int) D.34211;
        __result = D.34209 - D.34212;
        D.34213 = __s2_len > 2;
        D.34193 = __result == 0;
        D.34214 = D.34213 & D.34193;
        if (D.34214 != 0) goto <D.34215>; else goto <D.34216>;
        <D.34215>:
        D.34217 = &MEM[(void *)"FieldBuilder" + 3B];
        D.34218 = *D.34217;
        D.34219 = (int) D.34218;
        D.34220 = __s2 + 3;
        D.34221 = *D.34220;
        D.34222 = (int) D.34221;
        __result = D.34219 - D.34222;
        <D.34216>:
        <D.34206>:
        <D.34196>:
      }
      D.21649 = __result;
    }
    iftmp.358 = -D.21649;
    goto <D.34223>;
    <D.34186>:
    D.34135 = klass->name;
    iftmp.358 = __builtin_strcmp (D.34135, "FieldBuilder");
    <D.34223>:
    D.21650 = iftmp.358;
  }
  if (D.21650 == 0) goto <D.34224>; else goto <D.34225>;
  <D.34224>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.34226 = fb->table_idx;
    D.34227 = D.34226 | 67108864;
    token = (guint32) D.34227;
  }
  goto <D.34228>;
  <D.34225>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34232 = "TypeBuilder";
      D.34233 = MEM[(const unsigned char *)D.34232];
      D.34234 = (int) D.34233;
      D.34235 = *__s2;
      D.34236 = (int) D.34235;
      __result = D.34234 - D.34236;
      {
        D.34237 = __s2_len != 0;
        D.34238 = __result == 0;
        D.34239 = D.34237 & D.34238;
        if (D.34239 != 0) goto <D.34240>; else goto <D.34241>;
        <D.34240>:
        D.34242 = &MEM[(void *)"TypeBuilder" + 1B];
        D.34243 = *D.34242;
        D.34244 = (int) D.34243;
        D.34245 = __s2 + 1;
        D.34246 = *D.34245;
        D.34247 = (int) D.34246;
        __result = D.34244 - D.34247;
        D.34248 = __s2_len > 1;
        D.34238 = __result == 0;
        D.34249 = D.34248 & D.34238;
        if (D.34249 != 0) goto <D.34250>; else goto <D.34251>;
        <D.34250>:
        D.34252 = &MEM[(void *)"TypeBuilder" + 2B];
        D.34253 = *D.34252;
        D.34254 = (int) D.34253;
        D.34255 = __s2 + 2;
        D.34256 = *D.34255;
        D.34257 = (int) D.34256;
        __result = D.34254 - D.34257;
        D.34258 = __s2_len > 2;
        D.34238 = __result == 0;
        D.34259 = D.34258 & D.34238;
        if (D.34259 != 0) goto <D.34260>; else goto <D.34261>;
        <D.34260>:
        D.34262 = &MEM[(void *)"TypeBuilder" + 3B];
        D.34263 = *D.34262;
        D.34264 = (int) D.34263;
        D.34265 = __s2 + 3;
        D.34266 = *D.34265;
        D.34267 = (int) D.34266;
        __result = D.34264 - D.34267;
        <D.34261>:
        <D.34251>:
        <D.34241>:
      }
      D.21659 = __result;
    }
    iftmp.359 = -D.21659;
    goto <D.34268>;
    <D.34231>:
    D.34135 = klass->name;
    iftmp.359 = __builtin_strcmp (D.34135, "TypeBuilder");
    <D.34268>:
    D.21660 = iftmp.359;
  }
  if (D.21660 == 0) goto <D.34269>; else goto <D.34270>;
  <D.34269>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.34271 = tb->table_idx;
    token = D.34271 | 33554432;
  }
  goto <D.34272>;
  <D.34270>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34276 = "MonoType";
      D.34277 = MEM[(const unsigned char *)D.34276];
      D.34278 = (int) D.34277;
      D.34279 = *__s2;
      D.34280 = (int) D.34279;
      __result = D.34278 - D.34280;
      {
        D.34281 = __s2_len != 0;
        D.34282 = __result == 0;
        D.34283 = D.34281 & D.34282;
        if (D.34283 != 0) goto <D.34284>; else goto <D.34285>;
        <D.34284>:
        D.34286 = &MEM[(void *)"MonoType" + 1B];
        D.34287 = *D.34286;
        D.34288 = (int) D.34287;
        D.34289 = __s2 + 1;
        D.34290 = *D.34289;
        D.34291 = (int) D.34290;
        __result = D.34288 - D.34291;
        D.34292 = __s2_len > 1;
        D.34282 = __result == 0;
        D.34293 = D.34292 & D.34282;
        if (D.34293 != 0) goto <D.34294>; else goto <D.34295>;
        <D.34294>:
        D.34296 = &MEM[(void *)"MonoType" + 2B];
        D.34297 = *D.34296;
        D.34298 = (int) D.34297;
        D.34299 = __s2 + 2;
        D.34300 = *D.34299;
        D.34301 = (int) D.34300;
        __result = D.34298 - D.34301;
        D.34302 = __s2_len > 2;
        D.34282 = __result == 0;
        D.34303 = D.34302 & D.34282;
        if (D.34303 != 0) goto <D.34304>; else goto <D.34305>;
        <D.34304>:
        D.34306 = &MEM[(void *)"MonoType" + 3B];
        D.34307 = *D.34306;
        D.34308 = (int) D.34307;
        D.34309 = __s2 + 3;
        D.34310 = *D.34309;
        D.34311 = (int) D.34310;
        __result = D.34308 - D.34311;
        <D.34305>:
        <D.34295>:
        <D.34285>:
      }
      D.21669 = __result;
    }
    iftmp.360 = -D.21669;
    goto <D.34312>;
    <D.34275>:
    D.34135 = klass->name;
    iftmp.360 = __builtin_strcmp (D.34135, "MonoType");
    <D.34312>:
    D.21670 = iftmp.360;
  }
  if (D.21670 == 0) goto <D.34313>; else goto <D.34314>;
  <D.34313>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.34315 = mono_class_init (mc);
    if (D.34315 == 0) goto <D.34316>; else goto <D.34317>;
    <D.34316>:
    D.34318 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.34318);
    <D.34317>:
    token = mc->type_token;
  }
  goto <D.34319>;
  <D.34314>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34326 = "MonoCMethod";
      D.34327 = MEM[(const unsigned char *)D.34326];
      D.34328 = (int) D.34327;
      D.34329 = *__s2;
      D.34330 = (int) D.34329;
      __result = D.34328 - D.34330;
      {
        D.34331 = __s2_len != 0;
        D.34332 = __result == 0;
        D.34333 = D.34331 & D.34332;
        if (D.34333 != 0) goto <D.34334>; else goto <D.34335>;
        <D.34334>:
        D.34336 = &MEM[(void *)"MonoCMethod" + 1B];
        D.34337 = *D.34336;
        D.34338 = (int) D.34337;
        D.34339 = __s2 + 1;
        D.34340 = *D.34339;
        D.34341 = (int) D.34340;
        __result = D.34338 - D.34341;
        D.34342 = __s2_len > 1;
        D.34332 = __result == 0;
        D.34343 = D.34342 & D.34332;
        if (D.34343 != 0) goto <D.34344>; else goto <D.34345>;
        <D.34344>:
        D.34346 = &MEM[(void *)"MonoCMethod" + 2B];
        D.34347 = *D.34346;
        D.34348 = (int) D.34347;
        D.34349 = __s2 + 2;
        D.34350 = *D.34349;
        D.34351 = (int) D.34350;
        __result = D.34348 - D.34351;
        D.34352 = __s2_len > 2;
        D.34332 = __result == 0;
        D.34353 = D.34352 & D.34332;
        if (D.34353 != 0) goto <D.34354>; else goto <D.34355>;
        <D.34354>:
        D.34356 = &MEM[(void *)"MonoCMethod" + 3B];
        D.34357 = *D.34356;
        D.34358 = (int) D.34357;
        D.34359 = __s2 + 3;
        D.34360 = *D.34359;
        D.34361 = (int) D.34360;
        __result = D.34358 - D.34361;
        <D.34355>:
        <D.34345>:
        <D.34335>:
      }
      D.21680 = __result;
    }
    iftmp.361 = -D.21680;
    goto <D.34362>;
    <D.34325>:
    D.34135 = klass->name;
    iftmp.361 = __builtin_strcmp (D.34135, "MonoCMethod");
    <D.34362>:
    D.21681 = iftmp.361;
  }
  if (D.21681 == 0) goto <D.34320>; else goto <D.34363>;
  <D.34363>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34367 = "MonoMethod";
      D.34368 = MEM[(const unsigned char *)D.34367];
      D.34369 = (int) D.34368;
      D.34370 = *__s2;
      D.34371 = (int) D.34370;
      __result = D.34369 - D.34371;
      {
        D.34372 = __s2_len != 0;
        D.34373 = __result == 0;
        D.34374 = D.34372 & D.34373;
        if (D.34374 != 0) goto <D.34375>; else goto <D.34376>;
        <D.34375>:
        D.34377 = &MEM[(void *)"MonoMethod" + 1B];
        D.34378 = *D.34377;
        D.34379 = (int) D.34378;
        D.34380 = __s2 + 1;
        D.34381 = *D.34380;
        D.34382 = (int) D.34381;
        __result = D.34379 - D.34382;
        D.34383 = __s2_len > 1;
        D.34373 = __result == 0;
        D.34384 = D.34383 & D.34373;
        if (D.34384 != 0) goto <D.34385>; else goto <D.34386>;
        <D.34385>:
        D.34387 = &MEM[(void *)"MonoMethod" + 2B];
        D.34388 = *D.34387;
        D.34389 = (int) D.34388;
        D.34390 = __s2 + 2;
        D.34391 = *D.34390;
        D.34392 = (int) D.34391;
        __result = D.34389 - D.34392;
        D.34393 = __s2_len > 2;
        D.34373 = __result == 0;
        D.34394 = D.34393 & D.34373;
        if (D.34394 != 0) goto <D.34395>; else goto <D.34396>;
        <D.34395>:
        D.34397 = &MEM[(void *)"MonoMethod" + 3B];
        D.34398 = *D.34397;
        D.34399 = (int) D.34398;
        D.34400 = __s2 + 3;
        D.34401 = *D.34400;
        D.34402 = (int) D.34401;
        __result = D.34399 - D.34402;
        <D.34396>:
        <D.34386>:
        <D.34376>:
      }
      D.21689 = __result;
    }
    iftmp.362 = -D.21689;
    goto <D.34403>;
    <D.34366>:
    D.34135 = klass->name;
    iftmp.362 = __builtin_strcmp (D.34135, "MonoMethod");
    <D.34403>:
    D.21690 = iftmp.362;
  }
  if (D.21690 == 0) goto <D.34320>; else goto <D.34404>;
  <D.34404>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34408 = "MonoGenericMethod";
      D.34409 = MEM[(const unsigned char *)D.34408];
      D.34410 = (int) D.34409;
      D.34411 = *__s2;
      D.34412 = (int) D.34411;
      __result = D.34410 - D.34412;
      {
        D.34413 = __s2_len != 0;
        D.34414 = __result == 0;
        D.34415 = D.34413 & D.34414;
        if (D.34415 != 0) goto <D.34416>; else goto <D.34417>;
        <D.34416>:
        D.34418 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.34419 = *D.34418;
        D.34420 = (int) D.34419;
        D.34421 = __s2 + 1;
        D.34422 = *D.34421;
        D.34423 = (int) D.34422;
        __result = D.34420 - D.34423;
        D.34424 = __s2_len > 1;
        D.34414 = __result == 0;
        D.34425 = D.34424 & D.34414;
        if (D.34425 != 0) goto <D.34426>; else goto <D.34427>;
        <D.34426>:
        D.34428 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.34429 = *D.34428;
        D.34430 = (int) D.34429;
        D.34431 = __s2 + 2;
        D.34432 = *D.34431;
        D.34433 = (int) D.34432;
        __result = D.34430 - D.34433;
        D.34434 = __s2_len > 2;
        D.34414 = __result == 0;
        D.34435 = D.34434 & D.34414;
        if (D.34435 != 0) goto <D.34436>; else goto <D.34437>;
        <D.34436>:
        D.34438 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.34439 = *D.34438;
        D.34440 = (int) D.34439;
        D.34441 = __s2 + 3;
        D.34442 = *D.34441;
        D.34443 = (int) D.34442;
        __result = D.34440 - D.34443;
        <D.34437>:
        <D.34427>:
        <D.34417>:
      }
      D.21698 = __result;
    }
    iftmp.363 = -D.21698;
    goto <D.34444>;
    <D.34407>:
    D.34135 = klass->name;
    iftmp.363 = __builtin_strcmp (D.34135, "MonoGenericMethod");
    <D.34444>:
    D.21699 = iftmp.363;
  }
  if (D.21699 == 0) goto <D.34320>; else goto <D.34445>;
  <D.34445>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34449 = "MonoGenericCMethod";
      D.34450 = MEM[(const unsigned char *)D.34449];
      D.34451 = (int) D.34450;
      D.34452 = *__s2;
      D.34453 = (int) D.34452;
      __result = D.34451 - D.34453;
      {
        D.34454 = __s2_len != 0;
        D.34455 = __result == 0;
        D.34456 = D.34454 & D.34455;
        if (D.34456 != 0) goto <D.34457>; else goto <D.34458>;
        <D.34457>:
        D.34459 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.34460 = *D.34459;
        D.34461 = (int) D.34460;
        D.34462 = __s2 + 1;
        D.34463 = *D.34462;
        D.34464 = (int) D.34463;
        __result = D.34461 - D.34464;
        D.34465 = __s2_len > 1;
        D.34455 = __result == 0;
        D.34466 = D.34465 & D.34455;
        if (D.34466 != 0) goto <D.34467>; else goto <D.34468>;
        <D.34467>:
        D.34469 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.34470 = *D.34469;
        D.34471 = (int) D.34470;
        D.34472 = __s2 + 2;
        D.34473 = *D.34472;
        D.34474 = (int) D.34473;
        __result = D.34471 - D.34474;
        D.34475 = __s2_len > 2;
        D.34455 = __result == 0;
        D.34476 = D.34475 & D.34455;
        if (D.34476 != 0) goto <D.34477>; else goto <D.34478>;
        <D.34477>:
        D.34479 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.34480 = *D.34479;
        D.34481 = (int) D.34480;
        D.34482 = __s2 + 3;
        D.34483 = *D.34482;
        D.34484 = (int) D.34483;
        __result = D.34481 - D.34484;
        <D.34478>:
        <D.34468>:
        <D.34458>:
      }
      D.21707 = __result;
    }
    iftmp.364 = -D.21707;
    goto <D.34485>;
    <D.34448>:
    D.34135 = klass->name;
    iftmp.364 = __builtin_strcmp (D.34135, "MonoGenericCMethod");
    <D.34485>:
    D.21708 = iftmp.364;
  }
  if (D.21708 == 0) goto <D.34320>; else goto <D.34321>;
  <D.34320>:
  {
    struct MonoReflectionMethod * m;

    m = obj;
    D.34486 = m->method;
    D.34487 = BIT_FIELD_REF <*D.34486, 8, 264>;
    D.34488 = D.34487 & 16;
    if (D.34488 != 0) goto <D.34489>; else goto <D.34490>;
    <D.34489>:
    {
      struct MonoMethodInflated * inflated;

      inflated = m->method;
      D.34492 = inflated->declaring;
      D.34491 = D.34492->token;
      return D.34491;
    }
    <D.34490>:
    D.34486 = m->method;
    token = D.34486->token;
  }
  goto <D.34322>;
  <D.34321>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34496 = "MonoField";
      D.34497 = MEM[(const unsigned char *)D.34496];
      D.34498 = (int) D.34497;
      D.34499 = *__s2;
      D.34500 = (int) D.34499;
      __result = D.34498 - D.34500;
      {
        D.34501 = __s2_len != 0;
        D.34502 = __result == 0;
        D.34503 = D.34501 & D.34502;
        if (D.34503 != 0) goto <D.34504>; else goto <D.34505>;
        <D.34504>:
        D.34506 = &MEM[(void *)"MonoField" + 1B];
        D.34507 = *D.34506;
        D.34508 = (int) D.34507;
        D.34509 = __s2 + 1;
        D.34510 = *D.34509;
        D.34511 = (int) D.34510;
        __result = D.34508 - D.34511;
        D.34512 = __s2_len > 1;
        D.34502 = __result == 0;
        D.34513 = D.34512 & D.34502;
        if (D.34513 != 0) goto <D.34514>; else goto <D.34515>;
        <D.34514>:
        D.34516 = &MEM[(void *)"MonoField" + 2B];
        D.34517 = *D.34516;
        D.34518 = (int) D.34517;
        D.34519 = __s2 + 2;
        D.34520 = *D.34519;
        D.34521 = (int) D.34520;
        __result = D.34518 - D.34521;
        D.34522 = __s2_len > 2;
        D.34502 = __result == 0;
        D.34523 = D.34522 & D.34502;
        if (D.34523 != 0) goto <D.34524>; else goto <D.34525>;
        <D.34524>:
        D.34526 = &MEM[(void *)"MonoField" + 3B];
        D.34527 = *D.34526;
        D.34528 = (int) D.34527;
        D.34529 = __s2 + 3;
        D.34530 = *D.34529;
        D.34531 = (int) D.34530;
        __result = D.34528 - D.34531;
        <D.34525>:
        <D.34515>:
        <D.34505>:
      }
      D.21718 = __result;
    }
    iftmp.365 = -D.21718;
    goto <D.34532>;
    <D.34495>:
    D.34135 = klass->name;
    iftmp.365 = __builtin_strcmp (D.34135, "MonoField");
    <D.34532>:
    D.21719 = iftmp.365;
  }
  if (D.21719 == 0) goto <D.34533>; else goto <D.34534>;
  <D.34533>:
  {
    struct MonoReflectionField * f;

    f = obj;
    D.34535 = f->field;
    D.34536 = is_field_on_inst (D.34535);
    if (D.34536 != 0) goto <D.34537>; else goto <D.34538>;
    <D.34537>:
    {
      struct MonoDynamicGenericClass * dgclass;
      int field_index;
      struct MonoObject * obj;

      D.34535 = f->field;
      D.34539 = D.34535->parent;
      dgclass = D.34539->generic_class;
      D.34535 = f->field;
      D.34540 = (long int) D.34535;
      D.34541 = dgclass->fields;
      D.34542 = (long int) D.34541;
      D.34543 = D.34540 - D.34542;
      D.34544 = D.34543 /[ex] 32;
      field_index = (int) D.34544;
      if (field_index < 0) goto <D.34546>; else goto <D.34549>;
      <D.34549>:
      D.34550 = dgclass->count_fields;
      if (D.34550 <= field_index) goto <D.34546>; else goto <D.34547>;
      <D.34546>:
      iftmp.366 = 1;
      goto <D.34548>;
      <D.34547>:
      iftmp.366 = 0;
      <D.34548>:
      D.34551 = iftmp.366 != 0;
      D.34552 = (long int) D.34551;
      D.34553 = __builtin_expect (D.34552, 0);
      if (D.34553 != 0) goto <D.34554>; else goto <D.34555>;
      <D.34554>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7752, "field_index >= 0 && field_index < dgclass->count_fields");
      <D.34555>:
      D.34556 = dgclass->field_objects;
      D.34557 = (long unsigned int) field_index;
      D.34558 = D.34557 * 8;
      D.34559 = D.34556 + D.34558;
      obj = *D.34559;
      D.34491 = mono_reflection_get_token (obj);
      return D.34491;
    }
    <D.34538>:
    D.34535 = f->field;
    token = mono_class_get_field_token (D.34535);
  }
  goto <D.34560>;
  <D.34534>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34564 = "MonoProperty";
      D.34565 = MEM[(const unsigned char *)D.34564];
      D.34566 = (int) D.34565;
      D.34567 = *__s2;
      D.34568 = (int) D.34567;
      __result = D.34566 - D.34568;
      {
        D.34569 = __s2_len != 0;
        D.34570 = __result == 0;
        D.34571 = D.34569 & D.34570;
        if (D.34571 != 0) goto <D.34572>; else goto <D.34573>;
        <D.34572>:
        D.34574 = &MEM[(void *)"MonoProperty" + 1B];
        D.34575 = *D.34574;
        D.34576 = (int) D.34575;
        D.34577 = __s2 + 1;
        D.34578 = *D.34577;
        D.34579 = (int) D.34578;
        __result = D.34576 - D.34579;
        D.34580 = __s2_len > 1;
        D.34570 = __result == 0;
        D.34581 = D.34580 & D.34570;
        if (D.34581 != 0) goto <D.34582>; else goto <D.34583>;
        <D.34582>:
        D.34584 = &MEM[(void *)"MonoProperty" + 2B];
        D.34585 = *D.34584;
        D.34586 = (int) D.34585;
        D.34587 = __s2 + 2;
        D.34588 = *D.34587;
        D.34589 = (int) D.34588;
        __result = D.34586 - D.34589;
        D.34590 = __s2_len > 2;
        D.34570 = __result == 0;
        D.34591 = D.34590 & D.34570;
        if (D.34591 != 0) goto <D.34592>; else goto <D.34593>;
        <D.34592>:
        D.34594 = &MEM[(void *)"MonoProperty" + 3B];
        D.34595 = *D.34594;
        D.34596 = (int) D.34595;
        D.34597 = __s2 + 3;
        D.34598 = *D.34597;
        D.34599 = (int) D.34598;
        __result = D.34596 - D.34599;
        <D.34593>:
        <D.34583>:
        <D.34573>:
      }
      D.21731 = __result;
    }
    iftmp.367 = -D.21731;
    goto <D.34600>;
    <D.34563>:
    D.34135 = klass->name;
    iftmp.367 = __builtin_strcmp (D.34135, "MonoProperty");
    <D.34600>:
    D.21732 = iftmp.367;
  }
  if (D.21732 == 0) goto <D.34601>; else goto <D.34602>;
  <D.34601>:
  {
    struct MonoReflectionProperty * p;

    p = obj;
    D.34603 = p->property;
    token = mono_class_get_property_token (D.34603);
  }
  goto <D.34604>;
  <D.34602>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34608 = "MonoEvent";
      D.34609 = MEM[(const unsigned char *)D.34608];
      D.34610 = (int) D.34609;
      D.34611 = *__s2;
      D.34612 = (int) D.34611;
      __result = D.34610 - D.34612;
      {
        D.34613 = __s2_len != 0;
        D.34614 = __result == 0;
        D.34615 = D.34613 & D.34614;
        if (D.34615 != 0) goto <D.34616>; else goto <D.34617>;
        <D.34616>:
        D.34618 = &MEM[(void *)"MonoEvent" + 1B];
        D.34619 = *D.34618;
        D.34620 = (int) D.34619;
        D.34621 = __s2 + 1;
        D.34622 = *D.34621;
        D.34623 = (int) D.34622;
        __result = D.34620 - D.34623;
        D.34624 = __s2_len > 1;
        D.34614 = __result == 0;
        D.34625 = D.34624 & D.34614;
        if (D.34625 != 0) goto <D.34626>; else goto <D.34627>;
        <D.34626>:
        D.34628 = &MEM[(void *)"MonoEvent" + 2B];
        D.34629 = *D.34628;
        D.34630 = (int) D.34629;
        D.34631 = __s2 + 2;
        D.34632 = *D.34631;
        D.34633 = (int) D.34632;
        __result = D.34630 - D.34633;
        D.34634 = __s2_len > 2;
        D.34614 = __result == 0;
        D.34635 = D.34634 & D.34614;
        if (D.34635 != 0) goto <D.34636>; else goto <D.34637>;
        <D.34636>:
        D.34638 = &MEM[(void *)"MonoEvent" + 3B];
        D.34639 = *D.34638;
        D.34640 = (int) D.34639;
        D.34641 = __s2 + 3;
        D.34642 = *D.34641;
        D.34643 = (int) D.34642;
        __result = D.34640 - D.34643;
        <D.34637>:
        <D.34627>:
        <D.34617>:
      }
      D.21741 = __result;
    }
    iftmp.368 = -D.21741;
    goto <D.34644>;
    <D.34607>:
    D.34135 = klass->name;
    iftmp.368 = __builtin_strcmp (D.34135, "MonoEvent");
    <D.34644>:
    D.21742 = iftmp.368;
  }
  if (D.21742 == 0) goto <D.34645>; else goto <D.34646>;
  <D.34645>:
  {
    struct MonoReflectionMonoEvent * p;

    p = obj;
    D.34647 = p->event;
    token = mono_class_get_event_token (D.34647);
  }
  goto <D.34648>;
  <D.34646>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34655 = "ParameterInfo";
      D.34656 = MEM[(const unsigned char *)D.34655];
      D.34657 = (int) D.34656;
      D.34658 = *__s2;
      D.34659 = (int) D.34658;
      __result = D.34657 - D.34659;
      {
        D.34660 = __s2_len != 0;
        D.34661 = __result == 0;
        D.34662 = D.34660 & D.34661;
        if (D.34662 != 0) goto <D.34663>; else goto <D.34664>;
        <D.34663>:
        D.34665 = &MEM[(void *)"ParameterInfo" + 1B];
        D.34666 = *D.34665;
        D.34667 = (int) D.34666;
        D.34668 = __s2 + 1;
        D.34669 = *D.34668;
        D.34670 = (int) D.34669;
        __result = D.34667 - D.34670;
        D.34671 = __s2_len > 1;
        D.34661 = __result == 0;
        D.34672 = D.34671 & D.34661;
        if (D.34672 != 0) goto <D.34673>; else goto <D.34674>;
        <D.34673>:
        D.34675 = &MEM[(void *)"ParameterInfo" + 2B];
        D.34676 = *D.34675;
        D.34677 = (int) D.34676;
        D.34678 = __s2 + 2;
        D.34679 = *D.34678;
        D.34680 = (int) D.34679;
        __result = D.34677 - D.34680;
        D.34681 = __s2_len > 2;
        D.34661 = __result == 0;
        D.34682 = D.34681 & D.34661;
        if (D.34682 != 0) goto <D.34683>; else goto <D.34684>;
        <D.34683>:
        D.34685 = &MEM[(void *)"ParameterInfo" + 3B];
        D.34686 = *D.34685;
        D.34687 = (int) D.34686;
        D.34688 = __s2 + 3;
        D.34689 = *D.34688;
        D.34690 = (int) D.34689;
        __result = D.34687 - D.34690;
        <D.34684>:
        <D.34674>:
        <D.34664>:
      }
      D.21751 = __result;
    }
    iftmp.369 = -D.21751;
    goto <D.34691>;
    <D.34654>:
    D.34135 = klass->name;
    iftmp.369 = __builtin_strcmp (D.34135, "ParameterInfo");
    <D.34691>:
    D.21752 = iftmp.369;
  }
  if (D.21752 == 0) goto <D.34649>; else goto <D.34692>;
  <D.34692>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34696 = "MonoParameterInfo";
      D.34697 = MEM[(const unsigned char *)D.34696];
      D.34698 = (int) D.34697;
      D.34699 = *__s2;
      D.34700 = (int) D.34699;
      __result = D.34698 - D.34700;
      {
        D.34701 = __s2_len != 0;
        D.34702 = __result == 0;
        D.34703 = D.34701 & D.34702;
        if (D.34703 != 0) goto <D.34704>; else goto <D.34705>;
        <D.34704>:
        D.34706 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.34707 = *D.34706;
        D.34708 = (int) D.34707;
        D.34709 = __s2 + 1;
        D.34710 = *D.34709;
        D.34711 = (int) D.34710;
        __result = D.34708 - D.34711;
        D.34712 = __s2_len > 1;
        D.34702 = __result == 0;
        D.34713 = D.34712 & D.34702;
        if (D.34713 != 0) goto <D.34714>; else goto <D.34715>;
        <D.34714>:
        D.34716 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.34717 = *D.34716;
        D.34718 = (int) D.34717;
        D.34719 = __s2 + 2;
        D.34720 = *D.34719;
        D.34721 = (int) D.34720;
        __result = D.34718 - D.34721;
        D.34722 = __s2_len > 2;
        D.34702 = __result == 0;
        D.34723 = D.34722 & D.34702;
        if (D.34723 != 0) goto <D.34724>; else goto <D.34725>;
        <D.34724>:
        D.34726 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.34727 = *D.34726;
        D.34728 = (int) D.34727;
        D.34729 = __s2 + 3;
        D.34730 = *D.34729;
        D.34731 = (int) D.34730;
        __result = D.34728 - D.34731;
        <D.34725>:
        <D.34715>:
        <D.34705>:
      }
      D.21760 = __result;
    }
    iftmp.370 = -D.21760;
    goto <D.34732>;
    <D.34695>:
    D.34135 = klass->name;
    iftmp.370 = __builtin_strcmp (D.34135, "MonoParameterInfo");
    <D.34732>:
    D.21761 = iftmp.370;
  }
  if (D.21761 == 0) goto <D.34649>; else goto <D.34650>;
  <D.34649>:
  {
    struct MonoReflectionParameter * p;
    struct MonoClass * member_class;

    p = obj;
    D.34733 = p->MemberImpl;
    D.34734 = D.34733->vtable;
    member_class = D.34734->klass;
    D.34735 = mono_class_is_reflection_method_or_constructor (member_class);
    D.34736 = D.34735 == 0;
    D.34737 = (long int) D.34736;
    D.34738 = __builtin_expect (D.34737, 0);
    if (D.34738 != 0) goto <D.34739>; else goto <D.34740>;
    <D.34739>:
    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.34740>:
    D.34741 = p->PositionImpl;
    D.34733 = p->MemberImpl;
    D.34742 = MEM[(struct MonoReflectionMethod *)D.34733].method;
    token = mono_method_get_param_token (D.34742, D.34741);
  }
  goto <D.34651>;
  <D.34650>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34749 = "Module";
      D.34750 = MEM[(const unsigned char *)D.34749];
      D.34751 = (int) D.34750;
      D.34752 = *__s2;
      D.34753 = (int) D.34752;
      __result = D.34751 - D.34753;
      {
        D.34754 = __s2_len != 0;
        D.34755 = __result == 0;
        D.34756 = D.34754 & D.34755;
        if (D.34756 != 0) goto <D.34757>; else goto <D.34758>;
        <D.34757>:
        D.34759 = &MEM[(void *)"Module" + 1B];
        D.34760 = *D.34759;
        D.34761 = (int) D.34760;
        D.34762 = __s2 + 1;
        D.34763 = *D.34762;
        D.34764 = (int) D.34763;
        __result = D.34761 - D.34764;
        D.34765 = __s2_len > 1;
        D.34755 = __result == 0;
        D.34766 = D.34765 & D.34755;
        if (D.34766 != 0) goto <D.34767>; else goto <D.34768>;
        <D.34767>:
        D.34769 = &MEM[(void *)"Module" + 2B];
        D.34770 = *D.34769;
        D.34771 = (int) D.34770;
        D.34772 = __s2 + 2;
        D.34773 = *D.34772;
        D.34774 = (int) D.34773;
        __result = D.34771 - D.34774;
        D.34775 = __s2_len > 2;
        D.34755 = __result == 0;
        D.34776 = D.34775 & D.34755;
        if (D.34776 != 0) goto <D.34777>; else goto <D.34778>;
        <D.34777>:
        D.34779 = &MEM[(void *)"Module" + 3B];
        D.34780 = *D.34779;
        D.34781 = (int) D.34780;
        D.34782 = __s2 + 3;
        D.34783 = *D.34782;
        D.34784 = (int) D.34783;
        __result = D.34781 - D.34784;
        <D.34778>:
        <D.34768>:
        <D.34758>:
      }
      D.21771 = __result;
    }
    iftmp.371 = -D.21771;
    goto <D.34785>;
    <D.34748>:
    D.34135 = klass->name;
    iftmp.371 = __builtin_strcmp (D.34135, "Module");
    <D.34785>:
    D.21772 = iftmp.371;
  }
  if (D.21772 == 0) goto <D.34743>; else goto <D.34786>;
  <D.34786>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34790 = "MonoModule";
      D.34791 = MEM[(const unsigned char *)D.34790];
      D.34792 = (int) D.34791;
      D.34793 = *__s2;
      D.34794 = (int) D.34793;
      __result = D.34792 - D.34794;
      {
        D.34795 = __s2_len != 0;
        D.34796 = __result == 0;
        D.34797 = D.34795 & D.34796;
        if (D.34797 != 0) goto <D.34798>; else goto <D.34799>;
        <D.34798>:
        D.34800 = &MEM[(void *)"MonoModule" + 1B];
        D.34801 = *D.34800;
        D.34802 = (int) D.34801;
        D.34803 = __s2 + 1;
        D.34804 = *D.34803;
        D.34805 = (int) D.34804;
        __result = D.34802 - D.34805;
        D.34806 = __s2_len > 1;
        D.34796 = __result == 0;
        D.34807 = D.34806 & D.34796;
        if (D.34807 != 0) goto <D.34808>; else goto <D.34809>;
        <D.34808>:
        D.34810 = &MEM[(void *)"MonoModule" + 2B];
        D.34811 = *D.34810;
        D.34812 = (int) D.34811;
        D.34813 = __s2 + 2;
        D.34814 = *D.34813;
        D.34815 = (int) D.34814;
        __result = D.34812 - D.34815;
        D.34816 = __s2_len > 2;
        D.34796 = __result == 0;
        D.34817 = D.34816 & D.34796;
        if (D.34817 != 0) goto <D.34818>; else goto <D.34819>;
        <D.34818>:
        D.34820 = &MEM[(void *)"MonoModule" + 3B];
        D.34821 = *D.34820;
        D.34822 = (int) D.34821;
        D.34823 = __s2 + 3;
        D.34824 = *D.34823;
        D.34825 = (int) D.34824;
        __result = D.34822 - D.34825;
        <D.34819>:
        <D.34809>:
        <D.34799>:
      }
      D.21780 = __result;
    }
    iftmp.372 = -D.21780;
    goto <D.34826>;
    <D.34789>:
    D.34135 = klass->name;
    iftmp.372 = __builtin_strcmp (D.34135, "MonoModule");
    <D.34826>:
    D.21781 = iftmp.372;
  }
  if (D.21781 == 0) goto <D.34743>; else goto <D.34744>;
  <D.34743>:
  {
    struct MonoReflectionModule * m;

    m = obj;
    token = m->token;
  }
  goto <D.34745>;
  <D.34744>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34833 = "Assembly";
      D.34834 = MEM[(const unsigned char *)D.34833];
      D.34835 = (int) D.34834;
      D.34836 = *__s2;
      D.34837 = (int) D.34836;
      __result = D.34835 - D.34837;
      {
        D.34838 = __s2_len != 0;
        D.34839 = __result == 0;
        D.34840 = D.34838 & D.34839;
        if (D.34840 != 0) goto <D.34841>; else goto <D.34842>;
        <D.34841>:
        D.34843 = &MEM[(void *)"Assembly" + 1B];
        D.34844 = *D.34843;
        D.34845 = (int) D.34844;
        D.34846 = __s2 + 1;
        D.34847 = *D.34846;
        D.34848 = (int) D.34847;
        __result = D.34845 - D.34848;
        D.34849 = __s2_len > 1;
        D.34839 = __result == 0;
        D.34850 = D.34849 & D.34839;
        if (D.34850 != 0) goto <D.34851>; else goto <D.34852>;
        <D.34851>:
        D.34853 = &MEM[(void *)"Assembly" + 2B];
        D.34854 = *D.34853;
        D.34855 = (int) D.34854;
        D.34856 = __s2 + 2;
        D.34857 = *D.34856;
        D.34858 = (int) D.34857;
        __result = D.34855 - D.34858;
        D.34859 = __s2_len > 2;
        D.34839 = __result == 0;
        D.34860 = D.34859 & D.34839;
        if (D.34860 != 0) goto <D.34861>; else goto <D.34862>;
        <D.34861>:
        D.34863 = &MEM[(void *)"Assembly" + 3B];
        D.34864 = *D.34863;
        D.34865 = (int) D.34864;
        D.34866 = __s2 + 3;
        D.34867 = *D.34866;
        D.34868 = (int) D.34867;
        __result = D.34865 - D.34868;
        <D.34862>:
        <D.34852>:
        <D.34842>:
      }
      D.21790 = __result;
    }
    iftmp.373 = -D.21790;
    goto <D.34869>;
    <D.34832>:
    D.34135 = klass->name;
    iftmp.373 = __builtin_strcmp (D.34135, "Assembly");
    <D.34869>:
    D.21791 = iftmp.373;
  }
  if (D.21791 == 0) goto <D.34827>; else goto <D.34870>;
  <D.34870>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.34874 = "MonoAssembly";
      D.34875 = MEM[(const unsigned char *)D.34874];
      D.34876 = (int) D.34875;
      D.34877 = *__s2;
      D.34878 = (int) D.34877;
      __result = D.34876 - D.34878;
      {
        D.34879 = __s2_len != 0;
        D.34880 = __result == 0;
        D.34881 = D.34879 & D.34880;
        if (D.34881 != 0) goto <D.34882>; else goto <D.34883>;
        <D.34882>:
        D.34884 = &MEM[(void *)"MonoAssembly" + 1B];
        D.34885 = *D.34884;
        D.34886 = (int) D.34885;
        D.34887 = __s2 + 1;
        D.34888 = *D.34887;
        D.34889 = (int) D.34888;
        __result = D.34886 - D.34889;
        D.34890 = __s2_len > 1;
        D.34880 = __result == 0;
        D.34891 = D.34890 & D.34880;
        if (D.34891 != 0) goto <D.34892>; else goto <D.34893>;
        <D.34892>:
        D.34894 = &MEM[(void *)"MonoAssembly" + 2B];
        D.34895 = *D.34894;
        D.34896 = (int) D.34895;
        D.34897 = __s2 + 2;
        D.34898 = *D.34897;
        D.34899 = (int) D.34898;
        __result = D.34896 - D.34899;
        D.34900 = __s2_len > 2;
        D.34880 = __result == 0;
        D.34901 = D.34900 & D.34880;
        if (D.34901 != 0) goto <D.34902>; else goto <D.34903>;
        <D.34902>:
        D.34904 = &MEM[(void *)"MonoAssembly" + 3B];
        D.34905 = *D.34904;
        D.34906 = (int) D.34905;
        D.34907 = __s2 + 3;
        D.34908 = *D.34907;
        D.34909 = (int) D.34908;
        __result = D.34906 - D.34909;
        <D.34903>:
        <D.34893>:
        <D.34883>:
      }
      D.21799 = __result;
    }
    iftmp.374 = -D.21799;
    goto <D.34910>;
    <D.34873>:
    D.34135 = klass->name;
    iftmp.374 = __builtin_strcmp (D.34135, "MonoAssembly");
    <D.34910>:
    D.21800 = iftmp.374;
  }
  if (D.21800 == 0) goto <D.34827>; else goto <D.34828>;
  <D.34827>:
  token = 536870913;
  goto <D.34829>;
  <D.34828>:
  {
    gchar * msg;
    struct MonoException * ex;

    D.34135 = klass->name;
    D.34911 = klass->name_space;
    msg = monoeg_g_strdup_printf ("MetadataToken is not supported for type \'%s.%s\'", D.34911, D.34135);
    ex = mono_get_exception_not_implemented (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.34829>:
  <D.34745>:
  <D.34651>:
  <D.34648>:
  <D.34604>:
  <D.34560>:
  <D.34322>:
  <D.34319>:
  <D.34272>:
  <D.34228>:
  <D.34183>:
  <D.34139>:
  D.34491 = token;
  return D.34491;
}


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.34913;
  struct MonoClass * D.34916;
  const char * p.375;
  short unsigned int D.34921;
  struct MonoMethodSignature * D.34922;
  short unsigned int D.34923;
  long unsigned int D.34924;
  struct MonoClass * D.34925;
  const char * p.376;
  struct MonoMethodSignature * D.34927;
  struct MonoType * D.34928;
  struct MonoObject * iftmp.377;
  struct MonoMethodSignature * D.34930;
  struct MonoType * D.34931;
  int D.34932;
  struct MonoMethodSignature * D.34935;
  struct MonoType * D.34936;
  struct MonoClass * D.34937;
  long unsigned int D.34939;
  struct MonoMethodSignature * D.34940;
  struct MonoType * D.34941;
  int D.34942;
  struct MonoMethodSignature * D.34945;
  short unsigned int D.34946;
  unsigned int D.34947;
  const char * named.378;
  short unsigned int D.34949;
  long unsigned int D.34950;
  struct MonoClass * D.34951;
  const char * named.379;
  long unsigned int D.34953;
  long unsigned int D.34954;
  const char * named.380;
  const char * named.381;
  const char * named.382;
  const char * named.383;
  const char * named.384;
  const char * named.385;
  unsigned int D.34965;
  sizetype D.34966;
  const guchar * D.34967;
  sizetype D.34968;
  const guchar * D.34969;
  long unsigned int D.34971;
  long unsigned int D.34972;
  long unsigned int named.386;
  int D.34975;
  long unsigned int D.34976;
  long unsigned int D.34977;
  char * D.34978;
  const char * named.387;
  unsigned int D.34980;
  sizetype D.34981;
  const guchar * D.34982;
  long unsigned int D.34984;
  long unsigned int D.34985;
  int D.34987;
  long unsigned int D.34988;
  long unsigned int D.34989;
  char * D.34990;
  const char * named.388;
  long unsigned int D.34994;
  long unsigned int D.34995;
  struct CattrNamedArg * D.34996;
  struct MonoType * D.34997;
  struct MonoObject * iftmp.389;
  int D.34999;
  struct MonoClass * D.35002;
  long unsigned int D.35004;
  int D.35005;
  struct MonoType * iftmp.390;
  struct MonoMethod * D.35012;
  struct MonoMethodSignature * D.35015;
  struct MonoMethod * D.35017;
  struct MonoMethodSignature * D.35018;
  struct MonoMethodSignature * D.35019;
  short unsigned int D.35020;
  int D.35021;
  int D.35022;
  struct MonoObject * iftmp.391;
  int D.35024;
  struct MonoClass * D.35027;
  int D.35029;
  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.34913 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.34913 == 0) goto <D.34914>; else goto <D.34915>;
      <D.34914>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      return;
      <D.34915>:
      D.34916 = method->klass;
      mono_class_init (D.34916);
      domain = mono_domain_get ();
      if (len <= 1) goto <D.34917>; else goto <D.34919>;
      <D.34919>:
      p.375 = p;
      D.34921 = MEM[(const guint16 *)p.375];
      if (D.34921 != 1) goto <D.34917>; else goto <D.34918>;
      <D.34917>:
      return;
      <D.34918>:
      D.34922 = mono_method_signature (method);
      D.34923 = D.34922->param_count;
      D.34924 = (long unsigned int) D.34923;
      D.34925 = mono_get_object_class ();
      typedargs = mono_array_new (domain, D.34925, D.34924);
      p.375 = p;
      p.376 = p.375 + 2;
      p = p.376;
      i = 0;
      goto <D.22063>;
      <D.22062>:
      {
        struct MonoObject * obj;
        void * val;

        p.375 = p;
        D.34927 = mono_method_signature (method);
        D.34928 = D.34927->params[i];
        val = load_cattr_value (image, D.34928, p.375, &p);
        D.34930 = mono_method_signature (method);
        D.34931 = D.34930->params[i];
        D.34932 = type_is_reference (D.34931);
        if (D.34932 == 0) goto <D.34933>; else goto <D.34934>;
        <D.34933>:
        D.34935 = mono_method_signature (method);
        D.34936 = D.34935->params[i];
        D.34937 = mono_class_from_mono_type (D.34936);
        iftmp.377 = mono_value_box (domain, D.34937, val);
        goto <D.34938>;
        <D.34934>:
        iftmp.377 = val;
        <D.34938>:
        obj = iftmp.377;
        {
          void * * __p;

          D.34939 = (long unsigned int) i;
          __p = mono_array_addr_with_size (typedargs, 8, D.34939);
          mono_gc_wbarrier_set_arrayref (typedargs, __p, obj);
        }
        D.34940 = mono_method_signature (method);
        D.34941 = D.34940->params[i];
        D.34942 = type_is_reference (D.34941);
        if (D.34942 == 0) goto <D.34943>; else goto <D.34944>;
        <D.34943>:
        monoeg_g_free (val);
        <D.34944>:
      }
      i = i + 1;
      <D.22063>:
      D.34945 = mono_method_signature (method);
      D.34946 = D.34945->param_count;
      D.34947 = (unsigned int) D.34946;
      if (D.34947 > i) goto <D.22062>; else goto <D.22064>;
      <D.22064>:
      p.375 = p;
      named = p.375;
      named.378 = named;
      D.34949 = MEM[(const guint16 *)named.378];
      num_named = (guint32) D.34949;
      D.34950 = (long unsigned int) num_named;
      D.34951 = mono_get_object_class ();
      namedargs = mono_array_new (domain, D.34951, D.34950);
      named.378 = named;
      named.379 = named.378 + 2;
      named = named.379;
      attrklass = method->klass;
      D.34953 = (long unsigned int) num_named;
      D.34954 = D.34953 * 24;
      arginfo = monoeg_malloc0 (D.34954);
      *named_arg_info = arginfo;
      j = 0;
      goto <D.22082>;
      <D.22081>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.378 = named;
        named.380 = named.378;
        named.381 = named.380 + 1;
        named = named.381;
        named_type = *named.380;
        named.378 = named;
        named.382 = named.378;
        named.383 = named.382 + 1;
        named = named.383;
        data_type = *named.382;
        if (data_type == 29) goto <D.34959>; else goto <D.34960>;
        <D.34959>:
        named.378 = named;
        named.384 = named.378;
        named.385 = named.384 + 1;
        named = named.385;
        data_type = *named.384;
        <D.34960>:
        if (data_type == 85) goto <D.34963>; else goto <D.34964>;
        <D.34963>:
        {
          gint type_len;
          char * type_name;

          named.378 = named;
          D.34965 = mono_metadata_decode_blob_size (named.378, &named);
          type_len = (gint) D.34965;
          named.378 = named;
          D.34966 = (sizetype) type_len;
          D.34967 = named.378 + D.34966;
          D.34968 = (sizetype) len;
          D.34969 = data + D.34968;
          if (D.34967 > D.34969) goto fail; else goto <D.34970>;
          <D.34970>:
          D.34971 = (long unsigned int) type_len;
          D.34972 = ~D.34971;
          named.378 = named;
          named.386 = (long unsigned int) named.378;
          if (D.34972 < named.386) goto fail; else goto <D.34974>;
          <D.34974>:
          D.34975 = type_len + 1;
          D.34976 = (long unsigned int) D.34975;
          type_name = monoeg_malloc (D.34976);
          D.34977 = (long unsigned int) type_len;
          named.378 = named;
          memcpy (type_name, named.378, D.34977);
          D.34966 = (sizetype) type_len;
          D.34978 = type_name + D.34966;
          *D.34978 = 0;
          named.378 = named;
          D.34966 = (sizetype) type_len;
          named.387 = named.378 + D.34966;
          named = named.387;
          monoeg_g_free (type_name);
        }
        <D.34964>:
        named.378 = named;
        D.34980 = mono_metadata_decode_blob_size (named.378, &named);
        name_len = (gint) D.34980;
        named.378 = named;
        D.34981 = (sizetype) name_len;
        D.34982 = named.378 + D.34981;
        D.34968 = (sizetype) len;
        D.34969 = data + D.34968;
        if (D.34982 > D.34969) goto fail; else goto <D.34983>;
        <D.34983>:
        D.34984 = (long unsigned int) name_len;
        D.34985 = ~D.34984;
        named.378 = named;
        named.386 = (long unsigned int) named.378;
        if (D.34985 < named.386) goto fail; else goto <D.34986>;
        <D.34986>:
        D.34987 = name_len + 1;
        D.34988 = (long unsigned int) D.34987;
        name = monoeg_malloc (D.34988);
        D.34989 = (long unsigned int) name_len;
        named.378 = named;
        memcpy (name, named.378, D.34989);
        D.34981 = (sizetype) name_len;
        D.34990 = name + D.34981;
        *D.34990 = 0;
        named.378 = named;
        D.34981 = (sizetype) name_len;
        named.388 = named.378 + D.34981;
        named = named.388;
        if (named_type == 83) goto <D.34992>; else goto <D.34993>;
        <D.34992>:
        {
          struct MonoObject * obj;
          struct MonoClassField * field;
          void * val;

          field = mono_class_get_field_from_name (attrklass, name);
          D.34994 = (long unsigned int) j;
          D.34995 = D.34994 * 24;
          D.34996 = arginfo + D.34995;
          D.34997 = field->type;
          D.34996->type = D.34997;
          D.34994 = (long unsigned int) j;
          D.34995 = D.34994 * 24;
          D.34996 = arginfo + D.34995;
          D.34996->field = field;
          named.378 = named;
          D.34997 = field->type;
          val = load_cattr_value (image, D.34997, named.378, &named);
          D.34997 = field->type;
          D.34999 = type_is_reference (D.34997);
          if (D.34999 == 0) goto <D.35000>; else goto <D.35001>;
          <D.35000>:
          D.34997 = field->type;
          D.35002 = mono_class_from_mono_type (D.34997);
          iftmp.389 = mono_value_box (domain, D.35002, val);
          goto <D.35003>;
          <D.35001>:
          iftmp.389 = val;
          <D.35003>:
          obj = iftmp.389;
          {
            void * * __p;

            D.35004 = (long unsigned int) j;
            __p = mono_array_addr_with_size (namedargs, 8, D.35004);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.34997 = field->type;
          D.35005 = type_is_reference (D.34997);
          if (D.35005 == 0) goto <D.35006>; else goto <D.35007>;
          <D.35006>:
          monoeg_g_free (val);
          <D.35007>:
        }
        goto <D.35008>;
        <D.34993>:
        if (named_type == 84) goto <D.35009>; else goto <D.35010>;
        <D.35009>:
        {
          struct MonoObject * obj;
          struct MonoType * prop_type;
          struct MonoProperty * prop;
          void * val;

          prop = mono_class_get_property_from_name (attrklass, name);
          D.35012 = prop->get;
          if (D.35012 != 0B) goto <D.35013>; else goto <D.35014>;
          <D.35013>:
          D.35012 = prop->get;
          D.35015 = mono_method_signature (D.35012);
          iftmp.390 = D.35015->ret;
          goto <D.35016>;
          <D.35014>:
          D.35017 = prop->set;
          D.35018 = mono_method_signature (D.35017);
          D.35017 = prop->set;
          D.35019 = mono_method_signature (D.35017);
          D.35020 = D.35019->param_count;
          D.35021 = (int) D.35020;
          D.35022 = D.35021 + -1;
          iftmp.390 = D.35018->params[D.35022];
          <D.35016>:
          prop_type = iftmp.390;
          D.34994 = (long unsigned int) j;
          D.34995 = D.34994 * 24;
          D.34996 = arginfo + D.34995;
          D.34996->type = prop_type;
          D.34994 = (long unsigned int) j;
          D.34995 = D.34994 * 24;
          D.34996 = arginfo + D.34995;
          D.34996->prop = prop;
          named.378 = named;
          val = load_cattr_value (image, prop_type, named.378, &named);
          D.35024 = type_is_reference (prop_type);
          if (D.35024 == 0) goto <D.35025>; else goto <D.35026>;
          <D.35025>:
          D.35027 = mono_class_from_mono_type (prop_type);
          iftmp.391 = mono_value_box (domain, D.35027, val);
          goto <D.35028>;
          <D.35026>:
          iftmp.391 = val;
          <D.35028>:
          obj = iftmp.391;
          {
            void * * __p;

            D.35004 = (long unsigned int) j;
            __p = mono_array_addr_with_size (namedargs, 8, D.35004);
            mono_gc_wbarrier_set_arrayref (namedargs, __p, obj);
          }
          D.35029 = type_is_reference (prop_type);
          if (D.35029 == 0) goto <D.35030>; else goto <D.35031>;
          <D.35030>:
          monoeg_g_free (val);
          <D.35031>:
        }
        <D.35010>:
        <D.35008>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.22082>:
      if (j < num_named) goto <D.22081>; else goto <D.22083>;
      <D.22083>:
      *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.35035;
  const char * p.392;
  char D.35037;
  unsigned char D.35038;
  const char * p.398;
  void * D.35040;
  short unsigned int D.35041;
  const char * p.405;
  unsigned int D.35043;
  const char * p.402;
  long unsigned int D.35045;
  const char * p.408;
  double D.35047;
  struct MonoClass * D.35048;
  unsigned char D.35049;
  unsigned char D.35050;
  struct MonoType * D.35053;
  unsigned char D.35054;
  struct MonoImage * D.35055;
  int D.35056;
  int D.21852;
  int iftmp.393;
  int D.21851;
  const char[7] * D.35062;
  unsigned char D.35063;
  int D.35064;
  unsigned char D.35065;
  int D.35066;
  _Bool D.35067;
  _Bool D.35068;
  _Bool D.35069;
  const unsigned char * D.35072;
  unsigned char D.35073;
  int D.35074;
  const unsigned char * D.35075;
  unsigned char D.35076;
  int D.35077;
  _Bool D.35078;
  _Bool D.35079;
  const unsigned char * D.35082;
  unsigned char D.35083;
  int D.35084;
  const unsigned char * D.35085;
  unsigned char D.35086;
  int D.35087;
  _Bool D.35088;
  _Bool D.35089;
  const unsigned char * D.35092;
  unsigned char D.35093;
  int D.35094;
  const unsigned char * D.35095;
  unsigned char D.35096;
  int D.35097;
  const char * D.35099;
  int D.21861;
  int iftmp.394;
  int D.21860;
  const char[9] * D.35105;
  unsigned char D.35106;
  int D.35107;
  unsigned char D.35108;
  int D.35109;
  _Bool D.35110;
  _Bool D.35111;
  _Bool D.35112;
  const unsigned char * D.35115;
  unsigned char D.35116;
  int D.35117;
  const unsigned char * D.35118;
  unsigned char D.35119;
  int D.35120;
  _Bool D.35121;
  _Bool D.35122;
  const unsigned char * D.35125;
  unsigned char D.35126;
  int D.35127;
  const unsigned char * D.35128;
  unsigned char D.35129;
  int D.35130;
  _Bool D.35131;
  _Bool D.35132;
  const unsigned char * D.35135;
  unsigned char D.35136;
  int D.35137;
  const unsigned char * D.35138;
  unsigned char D.35139;
  int D.35140;
  const char * D.35142;
  const char * D.35145;
  unsigned int D.35148;
  sizetype D.35149;
  const char * p.399;
  unsigned int slen.395;
  struct MonoDomain * D.35152;
  unsigned int D.35155;
  int D.35156;
  unsigned int D.35157;
  char * D.35158;
  struct MonoDomain * D.35163;
  const char * p.396;
  const char * p.397;
  unsigned char D.35179;
  unsigned int D.35182;
  char * D.35183;
  unsigned char subt.400;
  unsigned char D.35188;
  unsigned char subt.401;
  int D.35193;
  struct MonoType * D.35194;
  struct MonoDomain * D.35195;
  unsigned char D.35196;
  unsigned char D.35197;
  _Bool D.35198;
  long int D.35199;
  long int D.35200;
  int D.35203;
  long unsigned int D.35204;
  void * D.35205;
  long unsigned int D.35208;
  struct MonoDomain * D.35209;
  unsigned char D.35210;
  unsigned char D.35213;
  unsigned char D.35214;
  struct MonoType * D.35217;
  unsigned char D.35218;
  const char * p.403;
  const char * p.404;
  char D.35221;
  long unsigned int D.35222;
  double val.406;
  double val.407;
  struct MonoType * D.35225;
  int slen;
  int type;
  struct MonoClass * tklass;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  D.35035 = t->type;
  type = (int) D.35035;
  tklass = t->data.klass;
  handle_enum:
  switch (type) <default: <D.21935>, case 2: <D.21824>, case 3: <D.21826>, case 4: <D.21823>, case 5: <D.21822>, case 6: <D.21828>, case 7: <D.21827>, case 8: <D.21832>, case 9: <D.21831>, case 10: <D.21837>, case 11: <D.21836>, case 12: <D.21830>, case 13: <D.21839>, case 14: <D.21864>, case 17: <D.21842>, case 18: <D.21865>, case 24: <D.21835>, case 25: <D.21834>, case 28: <D.21869>, case 29: <D.21881>>
  <D.21822>:
  <D.21823>:
  <D.21824>:
  {
    MonoBoolean * bval;

    bval = monoeg_malloc (1);
    p.392 = p;
    D.35037 = *p.392;
    D.35038 = (unsigned char) D.35037;
    *bval = D.35038;
    p.392 = p;
    p.398 = p.392 + 1;
    *end = p.398;
    D.35040 = bval;
    return D.35040;
  }
  <D.21826>:
  <D.21827>:
  <D.21828>:
  {
    guint16 * val;

    val = monoeg_malloc (2);
    p.392 = p;
    D.35041 = MEM[(const guint16 *)p.392];
    *val = D.35041;
    p.392 = p;
    p.405 = p.392 + 2;
    *end = p.405;
    D.35040 = val;
    return D.35040;
  }
  <D.21830>:
  <D.21831>:
  <D.21832>:
  {
    guint32 * val;

    val = monoeg_malloc (4);
    p.392 = p;
    D.35043 = MEM[(const guint32 *)p.392];
    *val = D.35043;
    p.392 = p;
    p.402 = p.392 + 4;
    *end = p.402;
    D.35040 = val;
    return D.35040;
  }
  <D.21834>:
  <D.21835>:
  <D.21836>:
  <D.21837>:
  {
    guint64 * val;

    val = monoeg_malloc (8);
    p.392 = p;
    D.35045 = MEM[(const guint64 *)p.392];
    *val = D.35045;
    p.392 = p;
    p.408 = p.392 + 8;
    *end = p.408;
    D.35040 = val;
    return D.35040;
  }
  <D.21839>:
  {
    double * val;

    val = monoeg_malloc (8);
    {
      union mono_rdouble mf;

      try
        {
          p.392 = p;
          D.35045 = MEM[(const guint64 *)p.392];
          mf.ival = D.35045;
          D.35047 = mf.fval;
          *val = D.35047;
        }
      finally
        {
          mf = {CLOBBER};
        }
    }
    p.392 = p;
    p.408 = p.392 + 8;
    *end = p.408;
    D.35040 = val;
    return D.35040;
  }
  <D.21842>:
  D.35048 = t->data.klass;
  D.35049 = BIT_FIELD_REF <*D.35048, 8, 256>;
  D.35050 = D.35049 & 16;
  if (D.35050 != 0) goto <D.35051>; else goto <D.35052>;
  <D.35051>:
  D.35048 = t->data.klass;
  D.35053 = mono_class_enum_basetype (D.35048);
  D.35054 = D.35053->type;
  type = (int) D.35054;
  goto handle_enum;
  <D.35052>:
  {
    struct MonoClass * k;

    k = t->data.klass;
    D.35055 = k->image;
    D.35056 = mono_is_corlib_image (D.35055);
    if (D.35056 != 0) goto <D.35057>; else goto <D.35058>;
    <D.35057>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name_space;
        D.35062 = "System";
        D.35063 = MEM[(const unsigned char *)D.35062];
        D.35064 = (int) D.35063;
        D.35065 = *__s2;
        D.35066 = (int) D.35065;
        __result = D.35064 - D.35066;
        {
          D.35067 = __s2_len != 0;
          D.35068 = __result == 0;
          D.35069 = D.35067 & D.35068;
          if (D.35069 != 0) goto <D.35070>; else goto <D.35071>;
          <D.35070>:
          D.35072 = &MEM[(void *)"System" + 1B];
          D.35073 = *D.35072;
          D.35074 = (int) D.35073;
          D.35075 = __s2 + 1;
          D.35076 = *D.35075;
          D.35077 = (int) D.35076;
          __result = D.35074 - D.35077;
          D.35078 = __s2_len > 1;
          D.35068 = __result == 0;
          D.35079 = D.35078 & D.35068;
          if (D.35079 != 0) goto <D.35080>; else goto <D.35081>;
          <D.35080>:
          D.35082 = &MEM[(void *)"System" + 2B];
          D.35083 = *D.35082;
          D.35084 = (int) D.35083;
          D.35085 = __s2 + 2;
          D.35086 = *D.35085;
          D.35087 = (int) D.35086;
          __result = D.35084 - D.35087;
          D.35088 = __s2_len > 2;
          D.35068 = __result == 0;
          D.35089 = D.35088 & D.35068;
          if (D.35089 != 0) goto <D.35090>; else goto <D.35091>;
          <D.35090>:
          D.35092 = &MEM[(void *)"System" + 3B];
          D.35093 = *D.35092;
          D.35094 = (int) D.35093;
          D.35095 = __s2 + 3;
          D.35096 = *D.35095;
          D.35097 = (int) D.35096;
          __result = D.35094 - D.35097;
          <D.35091>:
          <D.35081>:
          <D.35071>:
        }
        D.21851 = __result;
      }
      iftmp.393 = -D.21851;
      goto <D.35098>;
      <D.35061>:
      D.35099 = k->name_space;
      iftmp.393 = __builtin_strcmp (D.35099, "System");
      <D.35098>:
      D.21852 = iftmp.393;
    }
    if (D.21852 == 0) goto <D.35100>; else goto <D.35101>;
    <D.35100>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = k->name;
        D.35105 = "DateTime";
        D.35106 = MEM[(const unsigned char *)D.35105];
        D.35107 = (int) D.35106;
        D.35108 = *__s2;
        D.35109 = (int) D.35108;
        __result = D.35107 - D.35109;
        {
          D.35110 = __s2_len != 0;
          D.35111 = __result == 0;
          D.35112 = D.35110 & D.35111;
          if (D.35112 != 0) goto <D.35113>; else goto <D.35114>;
          <D.35113>:
          D.35115 = &MEM[(void *)"DateTime" + 1B];
          D.35116 = *D.35115;
          D.35117 = (int) D.35116;
          D.35118 = __s2 + 1;
          D.35119 = *D.35118;
          D.35120 = (int) D.35119;
          __result = D.35117 - D.35120;
          D.35121 = __s2_len > 1;
          D.35111 = __result == 0;
          D.35122 = D.35121 & D.35111;
          if (D.35122 != 0) goto <D.35123>; else goto <D.35124>;
          <D.35123>:
          D.35125 = &MEM[(void *)"DateTime" + 2B];
          D.35126 = *D.35125;
          D.35127 = (int) D.35126;
          D.35128 = __s2 + 2;
          D.35129 = *D.35128;
          D.35130 = (int) D.35129;
          __result = D.35127 - D.35130;
          D.35131 = __s2_len > 2;
          D.35111 = __result == 0;
          D.35132 = D.35131 & D.35111;
          if (D.35132 != 0) goto <D.35133>; else goto <D.35134>;
          <D.35133>:
          D.35135 = &MEM[(void *)"DateTime" + 3B];
          D.35136 = *D.35135;
          D.35137 = (int) D.35136;
          D.35138 = __s2 + 3;
          D.35139 = *D.35138;
          D.35140 = (int) D.35139;
          __result = D.35137 - D.35140;
          <D.35134>:
          <D.35124>:
          <D.35114>:
        }
        D.21860 = __result;
      }
      iftmp.394 = -D.21860;
      goto <D.35141>;
      <D.35104>:
      D.35142 = k->name;
      iftmp.394 = __builtin_strcmp (D.35142, "DateTime");
      <D.35141>:
      D.21861 = iftmp.394;
    }
    if (D.21861 == 0) goto <D.35143>; else goto <D.35144>;
    <D.35143>:
    {
      guint64 * val;

      val = monoeg_malloc (8);
      p.392 = p;
      D.35045 = MEM[(const guint64 *)p.392];
      *val = D.35045;
      p.392 = p;
      p.408 = p.392 + 8;
      *end = p.408;
      D.35040 = val;
      return D.35040;
    }
    <D.35144>:
    <D.35101>:
    <D.35058>:
  }
  D.35048 = t->data.klass;
  D.35145 = D.35048->name;
  monoeg_g_log (0B, 4, "generic valutype %s not handled in custom attr value decoding", D.35145);
  <D.21863>:
  goto <D.21863>;
  <D.21864>:
  p.392 = p;
  D.35037 = *p.392;
  if (D.35037 == -1) goto <D.35146>; else goto <D.35147>;
  <D.35146>:
  p.392 = p;
  p.398 = p.392 + 1;
  *end = p.398;
  D.35040 = 0B;
  return D.35040;
  <D.35147>:
  p.392 = p;
  D.35148 = mono_metadata_decode_value (p.392, &p);
  slen = (int) D.35148;
  p.392 = p;
  D.35149 = (sizetype) slen;
  p.399 = p.392 + D.35149;
  *end = p.399;
  slen.395 = (unsigned int) slen;
  p.392 = p;
  D.35152 = mono_domain_get ();
  D.35040 = mono_string_new_len (D.35152, p.392, slen.395);
  return D.35040;
  <D.21865>:
  {
    char * n;
    struct MonoType * t;

    p.392 = p;
    D.35037 = *p.392;
    if (D.35037 == -1) goto <D.35153>; else goto <D.35154>;
    <D.35153>:
    p.392 = p;
    p.398 = p.392 + 1;
    *end = p.398;
    D.35040 = 0B;
    return D.35040;
    <D.35154>:
    handle_type:
    p.392 = p;
    D.35155 = mono_metadata_decode_value (p.392, &p);
    slen = (int) D.35155;
    D.35156 = slen + 1;
    D.35157 = (unsigned int) D.35156;
    p.392 = p;
    n = monoeg_g_memdup (p.392, D.35157);
    D.35149 = (sizetype) slen;
    D.35158 = n + D.35149;
    *D.35158 = 0;
    t = mono_reflection_type_from_name (n, image);
    if (t == 0B) goto <D.35159>; else goto <D.35160>;
    <D.35159>:
    monoeg_g_log (0B, 16, "Cannot load type \'%s\'", n);
    <D.35160>:
    monoeg_g_free (n);
    p.392 = p;
    D.35149 = (sizetype) slen;
    p.399 = p.392 + D.35149;
    *end = p.399;
    if (t != 0B) goto <D.35161>; else goto <D.35162>;
    <D.35161>:
    D.35163 = mono_domain_get ();
    D.35040 = mono_type_get_object (D.35163, t);
    return D.35040;
    <D.35162>:
    D.35040 = 0B;
    return D.35040;
  }
  <D.21869>:
  {
    char subt;
    struct MonoObject * obj;
    struct MonoClass * subc;
    void * val;

    p.392 = p;
    p.396 = p.392;
    p.397 = p.396 + 1;
    p = p.397;
    subt = *p.396;
    subc = 0B;
    if (subt == 80) goto handle_type; else goto <D.35166>;
    <D.35166>:
    if (subt == 14) goto <D.35167>; else goto <D.35168>;
    <D.35167>:
    type = 14;
    goto handle_enum;
    <D.35168>:
    if (subt == 29) goto <D.35169>; else goto <D.35170>;
    <D.35169>:
    {
      struct MonoType simple_type;
      int etype;

      try
        {
          simple_type = {};
          p.392 = p;
          D.35037 = *p.392;
          etype = (int) D.35037;
          p.392 = p;
          p.398 = p.392 + 1;
          p = p.398;
          type = 29;
          if (etype == 80) goto <D.35171>; else goto <D.35172>;
          <D.35171>:
          tklass = mono_defaults.systemtype_class;
          goto <D.35173>;
          <D.35172>:
          if (etype == 85) goto <D.35174>; else goto <D.35175>;
          <D.35174>:
          p.392 = p;
          tklass = load_cattr_enum_type (image, p.392, &p);
          goto <D.35176>;
          <D.35175>:
          if (etype == 81) goto <D.35177>; else goto <D.35178>;
          <D.35177>:
          etype = 28;
          <D.35178>:
          D.35179 = (unsigned char) etype;
          simple_type.type = D.35179;
          tklass = mono_class_from_mono_type (&simple_type);
          <D.35176>:
          <D.35173>:
          goto handle_enum;
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    <D.35170>:
    if (subt == 85) goto <D.35180>; else goto <D.35181>;
    <D.35180>:
    {
      char * n;
      struct MonoType * t;

      p.392 = p;
      D.35182 = mono_metadata_decode_value (p.392, &p);
      slen = (int) D.35182;
      D.35156 = slen + 1;
      D.35157 = (unsigned int) D.35156;
      p.392 = p;
      n = monoeg_g_memdup (p.392, D.35157);
      D.35149 = (sizetype) slen;
      D.35183 = n + D.35149;
      *D.35183 = 0;
      t = mono_reflection_type_from_name (n, image);
      if (t == 0B) goto <D.35184>; else goto <D.35185>;
      <D.35184>:
      monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
      <D.21878>:
      goto <D.21878>;
      <D.35185>:
      monoeg_g_free (n);
      p.392 = p;
      D.35149 = (sizetype) slen;
      p.399 = p.392 + D.35149;
      p = p.399;
      subc = mono_class_from_mono_type (t);
    }
    goto <D.35186>;
    <D.35181>:
    subt.400 = (unsigned char) subt;
    D.35188 = subt.400 + 254;
    if (D.35188 <= 11) goto <D.35189>; else goto <D.35190>;
    <D.35189>:
    {
      struct MonoType simple_type;

      try
        {
          simple_type = {};
          subt.401 = (unsigned char) subt;
          simple_type.type = subt.401;
          subc = mono_class_from_mono_type (&simple_type);
        }
      finally
        {
          simple_type = {CLOBBER};
        }
    }
    goto <D.35192>;
    <D.35190>:
    D.35193 = (int) subt;
    monoeg_g_log (0B, 4, "Unknown type 0x%02x for object type encoding in custom attr", D.35193);
    <D.21880>:
    goto <D.21880>;
    <D.35192>:
    <D.35186>:
    p.392 = p;
    D.35194 = &subc->byval_arg;
    val = load_cattr_value (image, D.35194, p.392, end);
    D.35195 = mono_domain_get ();
    obj = mono_object_new (D.35195, subc);
    D.35196 = BIT_FIELD_REF <*subc, 8, 280>;
    D.35197 = D.35196 & 8;
    D.35198 = D.35197 != 0;
    D.35199 = (long int) D.35198;
    D.35200 = __builtin_expect (D.35199, 0);
    if (D.35200 != 0) goto <D.35201>; else goto <D.35202>;
    <D.35201>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 7953, "!subc->has_references");
    <D.35202>:
    D.35203 = mono_class_value_size (subc, 0B);
    D.35204 = (long unsigned int) D.35203;
    D.35205 = obj + 16;
    mono_gc_memmove_atomic (D.35205, val, D.35204);
    monoeg_g_free (val);
    D.35040 = obj;
    return D.35040;
  }
  <D.21881>:
  {
    struct MonoArray * arr;
    guint32 i;
    guint32 alen;
    guint32 basetype;

    p.392 = p;
    alen = MEM[(const guint32 *)p.392];
    p.392 = p;
    p.402 = p.392 + 4;
    p = p.402;
    if (alen == 4294967295) goto <D.35206>; else goto <D.35207>;
    <D.35206>:
    p.392 = p;
    *end = p.392;
    D.35040 = 0B;
    return D.35040;
    <D.35207>:
    D.35208 = (long unsigned int) alen;
    D.35209 = mono_domain_get ();
    arr = mono_array_new (D.35209, tklass, D.35208);
    D.35210 = tklass->byval_arg.type;
    basetype = (guint32) D.35210;
    if (basetype == 17) goto <D.35211>; else goto <D.35212>;
    <D.35211>:
    D.35213 = BIT_FIELD_REF <*tklass, 8, 256>;
    D.35214 = D.35213 & 16;
    if (D.35214 != 0) goto <D.35215>; else goto <D.35216>;
    <D.35215>:
    D.35217 = mono_class_enum_basetype (tklass);
    D.35218 = D.35217->type;
    basetype = (guint32) D.35218;
    <D.35216>:
    <D.35212>:
    switch (basetype) <default: <D.21933>, case 2: <D.21888>, case 3: <D.21895>, case 4: <D.21887>, case 5: <D.21886>, case 6: <D.21897>, case 7: <D.21896>, case 8: <D.21905>, case 9: <D.21904>, case 10: <D.21919>, case 11: <D.21918>, case 12: <D.21903>, case 13: <D.21911>, case 14: <D.21927>, case 18: <D.21925>, case 28: <D.21926>>
    <D.21886>:
    <D.21887>:
    <D.21888>:
    i = 0;
    goto <D.21892>;
    <D.21891>:
    {
      MonoBoolean val;

      p.392 = p;
      p.403 = p.392;
      p.404 = p.403 + 1;
      p = p.404;
      D.35221 = *p.403;
      val = (MonoBoolean) D.35221;
      {
        MonoBoolean * __p;

        D.35222 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 1, D.35222);
        *__p = val;
      }
    }
    i = i + 1;
    <D.21892>:
    if (i < alen) goto <D.21891>; else goto <D.21893>;
    <D.21893>:
    goto <D.21894>;
    <D.21895>:
    <D.21896>:
    <D.21897>:
    i = 0;
    goto <D.21901>;
    <D.21900>:
    {
      guint16 val;

      p.392 = p;
      val = MEM[(const guint16 *)p.392];
      {
        guint16 * __p;

        D.35222 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 2, D.35222);
        *__p = val;
      }
      p.392 = p;
      p.405 = p.392 + 2;
      p = p.405;
    }
    i = i + 1;
    <D.21901>:
    if (i < alen) goto <D.21900>; else goto <D.21902>;
    <D.21902>:
    goto <D.21894>;
    <D.21903>:
    <D.21904>:
    <D.21905>:
    i = 0;
    goto <D.21909>;
    <D.21908>:
    {
      guint32 val;

      p.392 = p;
      val = MEM[(const guint32 *)p.392];
      {
        guint32 * __p;

        D.35222 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 4, D.35222);
        *__p = val;
      }
      p.392 = p;
      p.402 = p.392 + 4;
      p = p.402;
    }
    i = i + 1;
    <D.21909>:
    if (i < alen) goto <D.21908>; else goto <D.21910>;
    <D.21910>:
    goto <D.21894>;
    <D.21911>:
    i = 0;
    goto <D.21916>;
    <D.21915>:
    {
      double val;

      try
        {
          {
            union mono_rdouble mf;

            try
              {
                p.392 = p;
                D.35045 = MEM[(const guint64 *)p.392];
                mf.ival = D.35045;
                val.406 = mf.fval;
                val = val.406;
              }
            finally
              {
                mf = {CLOBBER};
              }
          }
          {
            double * __p;

            D.35222 = (long unsigned int) i;
            __p = mono_array_addr_with_size (arr, 8, D.35222);
            val.407 = val;
            *__p = val.407;
          }
          p.392 = p;
          p.408 = p.392 + 8;
          p = p.408;
        }
      finally
        {
          val = {CLOBBER};
        }
    }
    i = i + 1;
    <D.21916>:
    if (i < alen) goto <D.21915>; else goto <D.21917>;
    <D.21917>:
    goto <D.21894>;
    <D.21918>:
    <D.21919>:
    i = 0;
    goto <D.21923>;
    <D.21922>:
    {
      guint64 val;

      p.392 = p;
      val = MEM[(const guint64 *)p.392];
      {
        guint64 * __p;

        D.35222 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 8, D.35222);
        *__p = val;
      }
      p.392 = p;
      p.408 = p.392 + 8;
      p = p.408;
    }
    i = i + 1;
    <D.21923>:
    if (i < alen) goto <D.21922>; else goto <D.21924>;
    <D.21924>:
    goto <D.21894>;
    <D.21925>:
    <D.21926>:
    <D.21927>:
    i = 0;
    goto <D.21931>;
    <D.21930>:
    {
      struct MonoObject * item;

      p.392 = p;
      D.35225 = &tklass->byval_arg;
      item = load_cattr_value (image, D.35225, p.392, &p);
      {
        void * * __p;

        D.35222 = (long unsigned int) i;
        __p = mono_array_addr_with_size (arr, 8, D.35222);
        mono_gc_wbarrier_set_arrayref (arr, __p, item);
      }
    }
    i = i + 1;
    <D.21931>:
    if (i < alen) goto <D.21930>; else goto <D.21932>;
    <D.21932>:
    goto <D.21894>;
    <D.21933>:
    monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr array decoding", basetype);
    <D.21934>:
    goto <D.21934>;
    <D.21894>:
    p.392 = p;
    *end = p.392;
    D.35040 = arr;
    return D.35040;
  }
  <D.21935>:
  monoeg_g_log (0B, 4, "Type 0x%02x not handled in custom attr value decoding", type);
  <D.21936>:
  goto <D.21936>;
  D.35040 = 0B;
  return D.35040;
}


load_cattr_enum_type (struct MonoImage * image, const char * p, const char * * end)
{
  const char * p.409;
  unsigned int D.35229;
  int D.35230;
  unsigned int D.35231;
  sizetype D.35232;
  char * D.35233;
  const char * p.410;
  struct MonoClass * D.35237;
  char * n;
  struct MonoType * t;
  int slen;

  p.409 = p;
  D.35229 = mono_metadata_decode_value (p.409, &p);
  slen = (int) D.35229;
  D.35230 = slen + 1;
  D.35231 = (unsigned int) D.35230;
  p.409 = p;
  n = monoeg_g_memdup (p.409, D.35231);
  D.35232 = (sizetype) slen;
  D.35233 = n + D.35232;
  *D.35233 = 0;
  t = mono_reflection_type_from_name (n, image);
  if (t == 0B) goto <D.35234>; else goto <D.35235>;
  <D.35234>:
  monoeg_g_log (0B, 4, "Cannot load type \'%s\'", n);
  <D.21811>:
  goto <D.21811>;
  <D.35235>:
  monoeg_g_free (n);
  p.409 = p;
  D.35232 = (sizetype) slen;
  p.410 = p.409 + D.35232;
  p = p.410;
  p.409 = p;
  *end = p.409;
  D.35237 = mono_class_from_mono_type (t);
  return D.35237;
}


type_is_reference (struct MonoType * type)
{
  unsigned char D.35239;
  int D.35240;
  gboolean D.35241;

  D.35239 = type->type;
  D.35240 = (int) D.35239;
  switch (D.35240) <default: <D.21973>, case 2: <D.21958>, case 3: <D.21959>, case 4: <D.21963>, case 5: <D.21962>, case 6: <D.21965>, case 7: <D.21964>, case 8: <D.21967>, case 9: <D.21966>, case 10: <D.21969>, case 11: <D.21968>, case 12: <D.21971>, case 13: <D.21970>, case 17: <D.21972>, case 24: <D.21961>, case 25: <D.21960>>
  <D.21958>:
  <D.21959>:
  <D.21960>:
  <D.21961>:
  <D.21962>:
  <D.21963>:
  <D.21964>:
  <D.21965>:
  <D.21966>:
  <D.21967>:
  <D.21968>:
  <D.21969>:
  <D.21970>:
  <D.21971>:
  <D.21972>:
  D.35241 = 0;
  return D.35241;
  <D.21973>:
  D.35241 = 1;
  return D.35241;
}


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.35245;
  struct MonoVTable * D.35246;
  struct MonoClass * D.35247;
  int D.35248;
  struct MonoException * D.35251;
  int D.35252;
  struct MonoLoaderError * D.35255;
  struct MonoLoaderError * D.35258;
  struct MonoException * D.35259;
  struct MonoArray * typedargs.411;
  struct MonoArray * namedargs.412;
  struct CattrNamedArg * arginfo.413;
  long unsigned int D.35266;
  char * D.35267;
  struct MonoMethodSignature * D.35268;
  struct MonoType * D.35269;
  struct MonoMethodSignature * D.35270;
  short unsigned int D.35271;
  int D.35272;
  char * D.35273;
  long unsigned int D.35274;
  long unsigned int D.35275;
  struct CattrNamedArg * D.35276;
  struct MonoProperty * D.35277;
  struct MonoClassField * D.35281;
  struct MonoType * D.35282;
  long unsigned int D.35283;
  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.35243>; else goto <D.35244>;
      <D.35243>:
      return;
      <D.35244>:
      D.35245 = assembly->assembly;
      image = D.35245->image;
      method = ref_method->method;
      D.35246 = MEM[(struct MonoObject *)ref_method].vtable;
      domain = D.35246->domain;
      D.35247 = method->klass;
      D.35248 = mono_class_init (D.35247);
      if (D.35248 == 0) goto <D.35249>; else goto <D.35250>;
      <D.35249>:
      D.35247 = method->klass;
      D.35251 = mono_class_get_exception_for_failure (D.35247);
      mono_raise_exception (D.35251);
      <D.35250>:
      mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo, &error);
      D.35252 = mono_error_ok (&error);
      if (D.35252 == 0) goto <D.35253>; else goto <D.35254>;
      <D.35253>:
      mono_error_raise_exception (&error);
      <D.35254>:
      D.35255 = mono_loader_get_last_error ();
      if (D.35255 != 0B) goto <D.35256>; else goto <D.35257>;
      <D.35256>:
      D.35258 = mono_loader_get_last_error ();
      D.35259 = mono_loader_error_prepare_exception (D.35258);
      mono_raise_exception (D.35259);
      <D.35257>:
      typedargs.411 = typedargs;
      if (typedargs.411 == 0B) goto <D.35260>; else goto <D.35263>;
      <D.35263>:
      namedargs.412 = namedargs;
      if (namedargs.412 == 0B) goto <D.35260>; else goto <D.35261>;
      <D.35260>:
      arginfo.413 = arginfo;
      monoeg_g_free (arginfo.413);
      return;
      <D.35261>:
      i = 0;
      goto <D.22104>;
      <D.22103>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;

        D.35266 = (long unsigned int) i;
        typedargs.411 = typedargs;
        D.35267 = mono_array_addr_with_size (typedargs.411, 8, D.35266);
        obj = MEM[(struct MonoObject * *)D.35267];
        D.35268 = mono_method_signature (method);
        D.35269 = D.35268->params[i];
        typedarg = create_cattr_typed_arg (D.35269, obj);
        {
          void * * __p;

          D.35266 = (long unsigned int) i;
          typedargs.411 = typedargs;
          __p = mono_array_addr_with_size (typedargs.411, 8, D.35266);
          typedargs.411 = typedargs;
          mono_gc_wbarrier_set_arrayref (typedargs.411, __p, typedarg);
        }
      }
      i = i + 1;
      <D.22104>:
      D.35270 = mono_method_signature (method);
      D.35271 = D.35270->param_count;
      D.35272 = (int) D.35271;
      if (D.35272 > i) goto <D.22103>; else goto <D.22105>;
      <D.22105>:
      i = 0;
      goto <D.22112>;
      <D.22111>:
      {
        struct MonoObject * obj;
        struct MonoObject * typedarg;
        struct MonoObject * namedarg;
        struct MonoObject * minfo;

        D.35266 = (long unsigned int) i;
        namedargs.412 = namedargs;
        D.35273 = mono_array_addr_with_size (namedargs.412, 8, D.35266);
        obj = MEM[(struct MonoObject * *)D.35273];
        arginfo.413 = arginfo;
        D.35274 = (long unsigned int) i;
        D.35275 = D.35274 * 24;
        D.35276 = arginfo.413 + D.35275;
        D.35277 = D.35276->prop;
        if (D.35277 != 0B) goto <D.35278>; else goto <D.35279>;
        <D.35278>:
        arginfo.413 = arginfo;
        D.35274 = (long unsigned int) i;
        D.35275 = D.35274 * 24;
        D.35276 = arginfo.413 + D.35275;
        D.35277 = D.35276->prop;
        minfo = mono_property_get_object (domain, 0B, D.35277);
        goto <D.35280>;
        <D.35279>:
        arginfo.413 = arginfo;
        D.35274 = (long unsigned int) i;
        D.35275 = D.35274 * 24;
        D.35276 = arginfo.413 + D.35275;
        D.35281 = D.35276->field;
        minfo = mono_field_get_object (domain, 0B, D.35281);
        <D.35280>:
        arginfo.413 = arginfo;
        D.35274 = (long unsigned int) i;
        D.35275 = D.35274 * 24;
        D.35276 = arginfo.413 + D.35275;
        D.35282 = D.35276->type;
        typedarg = create_cattr_typed_arg (D.35282, obj);
        namedarg = create_cattr_named_arg (minfo, typedarg);
        {
          void * * __p;

          D.35266 = (long unsigned int) i;
          namedargs.412 = namedargs;
          __p = mono_array_addr_with_size (namedargs.412, 8, D.35266);
          namedargs.412 = namedargs;
          mono_gc_wbarrier_set_arrayref (namedargs.412, __p, namedarg);
        }
      }
      i = i + 1;
      <D.22112>:
      D.35266 = (long unsigned int) i;
      namedargs.412 = namedargs;
      D.35283 = mono_array_length (namedargs.412);
      if (D.35266 < D.35283) goto <D.22111>; else goto <D.22113>;
      <D.22113>:
      typedargs.411 = typedargs;
      *ctor_args = typedargs.411;
      namedargs.412 = namedargs;
      *named_args = namedargs.412;
      arginfo.413 = arginfo;
      monoeg_g_free (arginfo.413);
    }
  finally
    {
      typedargs = {CLOBBER};
      namedargs = {CLOBBER};
      arginfo = {CLOBBER};
      error = {CLOBBER};
    }
}


create_cattr_typed_arg (struct MonoType * t, struct MonoObject * val)
{
  struct MonoClass * klass.414;
  struct MonoImage * D.35290;
  struct MonoClass * klass.415;
  struct MonoMethod * ctor.416;
  struct MonoMethod * ctor.417;
  struct MonoDomain * D.35296;
  struct MonoReflectionType * D.35297;
  struct MonoDomain * D.35298;
  struct MonoObject * D.35299;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * params[2];
  void * unboxed;

  try
    {
      klass.414 = klass;
      if (klass.414 == 0B) goto <D.35288>; else goto <D.35289>;
      <D.35288>:
      D.35290 = mono_defaults.corlib;
      klass.415 = mono_class_from_name (D.35290, "System.Reflection", "CustomAttributeTypedArgument");
      klass = klass.415;
      <D.35289>:
      ctor.416 = ctor;
      if (ctor.416 == 0B) goto <D.35293>; else goto <D.35294>;
      <D.35293>:
      klass.414 = klass;
      ctor.417 = mono_class_get_method_from_name (klass.414, ".ctor", 2);
      ctor = ctor.417;
      <D.35294>:
      D.35296 = mono_domain_get ();
      D.35297 = mono_type_get_object (D.35296, t);
      params[0] = D.35297;
      params[1] = val;
      klass.414 = klass;
      D.35298 = mono_domain_get ();
      retval = mono_object_new (D.35298, klass.414);
      unboxed = mono_object_unbox (retval);
      ctor.416 = ctor;
      mono_runtime_invoke (ctor.416, unboxed, &params, 0B);
      D.35299 = retval;
      return D.35299;
    }
  finally
    {
      params = {CLOBBER};
    }
}


create_cattr_named_arg (void * minfo, struct MonoObject * typedarg)
{
  struct MonoClass * klass.418;
  struct MonoImage * D.35305;
  struct MonoClass * klass.419;
  struct MonoMethod * ctor.420;
  struct MonoMethod * ctor.421;
  struct MonoDomain * D.35311;
  struct MonoObject * D.35312;
  static struct MonoClass * klass;
  static struct MonoMethod * ctor;
  struct MonoObject * retval;
  void * unboxed;
  void * params[2];

  try
    {
      klass.418 = klass;
      if (klass.418 == 0B) goto <D.35303>; else goto <D.35304>;
      <D.35303>:
      D.35305 = mono_defaults.corlib;
      klass.419 = mono_class_from_name (D.35305, "System.Reflection", "CustomAttributeNamedArgument");
      klass = klass.419;
      <D.35304>:
      ctor.420 = ctor;
      if (ctor.420 == 0B) goto <D.35308>; else goto <D.35309>;
      <D.35308>:
      klass.418 = klass;
      ctor.421 = mono_class_get_method_from_name (klass.418, ".ctor", 2);
      ctor = ctor.421;
      <D.35309>:
      params[0] = minfo;
      params[1] = typedarg;
      klass.418 = klass;
      D.35311 = mono_domain_get ();
      retval = mono_object_new (D.35311, klass.418);
      unboxed = mono_object_unbox (retval);
      ctor.420 = ctor;
      mono_runtime_invoke (ctor.420, unboxed, &params, 0B);
      D.35312 = retval;
      return D.35312;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_custom_attrs_construct (struct MonoCustomAttrInfo * cinfo)
{
  struct MonoArray * D.35315;
  struct MonoError error;

  try
    {
      D.35315 = mono_custom_attrs_construct_by_type (cinfo, 0B, &error);
      return D.35315;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_custom_attrs_construct_by_type (struct MonoCustomAttrInfo * cinfo, struct MonoClass * attr_klass, struct MonoError * error)
{
  struct MonoMethod * D.35321;
  struct MonoClass * D.35322;
  int D.35323;
  int D.35324;
  long unsigned int D.35325;
  struct MonoClass * D.22135;
  struct MonoClass * tmp_klass.422;
  struct MonoClass * D.35329;
  struct MonoClass * tmp_klass.423;
  _Bool D.35331;
  long int D.35332;
  long int D.35333;
  struct MonoDomain * D.35336;
  struct MonoVTable * D.35337;
  struct MonoException * D.35340;
  int D.35344;
  unsigned int D.35345;
  const mono_byte * D.35346;
  struct MonoImage * D.35347;
  int D.35348;
  struct MonoArray * D.35351;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;
  int n;

  mono_error_init (error);
  n = 0;
  i = 0;
  goto <D.22132>;
  <D.22131>:
  if (attr_klass == 0B) goto <D.35318>; else goto <D.35320>;
  <D.35320>:
  D.35321 = cinfo->attrs[i].ctor;
  D.35322 = D.35321->klass;
  D.35323 = mono_class_is_assignable_from (attr_klass, D.35322);
  if (D.35323 != 0) goto <D.35318>; else goto <D.35319>;
  <D.35318>:
  n = n + 1;
  <D.35319>:
  i = i + 1;
  <D.22132>:
  D.35324 = cinfo->num_attrs;
  if (D.35324 > i) goto <D.22131>; else goto <D.22133>;
  <D.22133>:
  D.35325 = (long unsigned int) n;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.422 = tmp_klass;
      if (tmp_klass.422 == 0B) goto <D.35327>; else goto <D.35328>;
      <D.35327>:
      D.35329 = mono_defaults.attribute_class;
      tmp_klass.423 = mono_array_class_get (D.35329, 1);
      tmp_klass = tmp_klass.423;
      tmp_klass.422 = tmp_klass;
      D.35331 = tmp_klass.422 == 0B;
      D.35332 = (long int) D.35331;
      D.35333 = __builtin_expect (D.35332, 0);
      if (D.35333 != 0) goto <D.35334>; else goto <D.35335>;
      <D.35334>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8491, "tmp_klass");
      <D.35335>:
      <D.35328>:
    }
    D.22135 = tmp_klass;
  }
  D.35336 = mono_domain_get ();
  D.35337 = mono_class_vtable (D.35336, D.22135);
  result = mono_array_new_specific (D.35337, D.35325);
  n = 0;
  i = 0;
  goto <D.22138>;
  <D.22137>:
  D.35321 = cinfo->attrs[i].ctor;
  if (D.35321 == 0B) goto <D.35338>; else goto <D.35339>;
  <D.35338>:
  D.35340 = mono_get_exception_type_load (0B, 0B);
  mono_raise_exception (D.35340);
  <D.35339>:
  if (attr_klass == 0B) goto <D.35341>; else goto <D.35343>;
  <D.35343>:
  D.35321 = cinfo->attrs[i].ctor;
  D.35322 = D.35321->klass;
  D.35344 = mono_class_is_assignable_from (attr_klass, D.35322);
  if (D.35344 != 0) goto <D.35341>; else goto <D.35342>;
  <D.35341>:
  D.35345 = cinfo->attrs[i].data_size;
  D.35346 = cinfo->attrs[i].data;
  D.35321 = cinfo->attrs[i].ctor;
  D.35347 = cinfo->image;
  attr = create_custom_attr (D.35347, D.35321, D.35346, D.35345, error);
  D.35348 = mono_error_ok (error);
  if (D.35348 == 0) goto <D.35349>; else goto <D.35350>;
  <D.35349>:
  D.35351 = result;
  return D.35351;
  <D.35350>:
  {
    void * * __p;

    D.35325 = (long unsigned int) n;
    __p = mono_array_addr_with_size (result, 8, D.35325);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  n = n + 1;
  <D.35342>:
  i = i + 1;
  <D.22138>:
  D.35324 = cinfo->num_attrs;
  if (D.35324 > i) goto <D.22137>; else goto <D.22139>;
  <D.22139>:
  D.35351 = result;
  return D.35351;
}


create_custom_attr (struct MonoImage * image, struct MonoMethod * method, const guchar * data, guint32 len, struct MonoError * error)
{
  struct MonoClass * D.35353;
  int D.35354;
  struct MonoObject * D.35357;
  struct MonoDomain * D.35360;
  const char * p.424;
  short unsigned int D.35365;
  short unsigned int D.35366;
  long unsigned int D.35370;
  long unsigned int D.35371;
  const char * p.425;
  long unsigned int D.35373;
  long unsigned int D.35374;
  void * * D.35375;
  struct MonoMethodSignature * D.35376;
  struct MonoType * D.35377;
  void * D.35378;
  struct MonoMethodSignature * D.35379;
  short unsigned int D.35380;
  unsigned int D.35381;
  struct MonoDomain * D.35382;
  struct MonoMethodSignature * D.35383;
  const char * named.426;
  short unsigned int D.35385;
  const char * named.427;
  const char * named.428;
  const char * named.429;
  const char * named.430;
  const char * named.431;
  const char * named.432;
  const char * named.433;
  unsigned int D.35397;
  int D.35398;
  long unsigned int D.35399;
  long unsigned int D.35400;
  sizetype D.35401;
  char * D.35402;
  const char * named.434;
  unsigned int D.35404;
  int D.35405;
  long unsigned int D.35406;
  long unsigned int D.35407;
  sizetype D.35408;
  char * D.35409;
  const char * named.435;
  struct MonoVTable * D.35413;
  struct MonoClass * D.35414;
  struct MonoType * D.35415;
  int D.35416;
  struct MonoType * iftmp.436;
  struct MonoMethod * D.35423;
  struct MonoMethodSignature * D.35426;
  struct MonoMethod * D.35428;
  struct MonoMethodSignature * D.35429;
  struct MonoMethodSignature * D.35430;
  short unsigned int D.35431;
  int D.35432;
  int D.35433;
  void * D.35434;
  int D.35435;
  void * D.35438;
  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.35353 = method->klass;
      mono_class_init (D.35353);
      D.35354 = mono_verifier_verify_cattr_content (image, method, data, len, 0B);
      if (D.35354 == 0) goto <D.35355>; else goto <D.35356>;
      <D.35355>:
      mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
      D.35357 = 0B;
      return D.35357;
      <D.35356>:
      if (len == 0) goto <D.35358>; else goto <D.35359>;
      <D.35358>:
      D.35353 = method->klass;
      D.35360 = mono_domain_get ();
      attr = mono_object_new (D.35360, D.35353);
      mono_runtime_invoke (method, attr, 0B, 0B);
      D.35357 = attr;
      return D.35357;
      <D.35359>:
      if (len <= 1) goto <D.35361>; else goto <D.35363>;
      <D.35363>:
      p.424 = p;
      D.35365 = MEM[(const guint16 *)p.424];
      if (D.35365 != 1) goto <D.35361>; else goto <D.35362>;
      <D.35361>:
      D.35357 = 0B;
      return D.35357;
      <D.35362>:
      sig = mono_method_signature (method);
      D.35366 = sig->param_count;
      if (D.35366 <= 31) goto <D.35367>; else goto <D.35368>;
      <D.35367>:
      params = &params_buf;
      goto <D.35369>;
      <D.35368>:
      D.35366 = sig->param_count;
      D.35370 = (long unsigned int) D.35366;
      D.35371 = D.35370 * 8;
      params = mono_gc_alloc_fixed (D.35371, 0B);
      <D.35369>:
      p.424 = p;
      p.425 = p.424 + 2;
      p = p.425;
      i = 0;
      goto <D.22023>;
      <D.22022>:
      D.35373 = (long unsigned int) i;
      D.35374 = D.35373 * 8;
      D.35375 = params + D.35374;
      p.424 = p;
      D.35376 = mono_method_signature (method);
      D.35377 = D.35376->params[i];
      D.35378 = load_cattr_value (image, D.35377, p.424, &p);
      *D.35375 = D.35378;
      i = i + 1;
      <D.22023>:
      D.35379 = mono_method_signature (method);
      D.35380 = D.35379->param_count;
      D.35381 = (unsigned int) D.35380;
      if (D.35381 > i) goto <D.22022>; else goto <D.22024>;
      <D.22024>:
      p.424 = p;
      named = p.424;
      D.35353 = method->klass;
      D.35382 = mono_domain_get ();
      attr = mono_object_new (D.35382, D.35353);
      mono_runtime_invoke (method, attr, params, 0B);
      D.35383 = method->signature;
      free_param_data (D.35383, params);
      named.426 = named;
      D.35385 = MEM[(const guint16 *)named.426];
      num_named = (guint32) D.35385;
      named.426 = named;
      named.427 = named.426 + 2;
      named = named.427;
      j = 0;
      goto <D.22037>;
      <D.22036>:
      {
        gint name_len;
        char * name;
        char named_type;
        char data_type;

        named.426 = named;
        named.428 = named.426;
        named.429 = named.428 + 1;
        named = named.429;
        named_type = *named.428;
        named.426 = named;
        named.430 = named.426;
        named.431 = named.430 + 1;
        named = named.431;
        data_type = *named.430;
        if (data_type == 29) goto <D.35391>; else goto <D.35392>;
        <D.35391>:
        named.426 = named;
        named.432 = named.426;
        named.433 = named.432 + 1;
        named = named.433;
        data_type = *named.432;
        <D.35392>:
        if (data_type == 85) goto <D.35395>; else goto <D.35396>;
        <D.35395>:
        {
          gint type_len;
          char * type_name;

          named.426 = named;
          D.35397 = mono_metadata_decode_blob_size (named.426, &named);
          type_len = (gint) D.35397;
          D.35398 = type_len + 1;
          D.35399 = (long unsigned int) D.35398;
          type_name = monoeg_malloc (D.35399);
          D.35400 = (long unsigned int) type_len;
          named.426 = named;
          memcpy (type_name, named.426, D.35400);
          D.35401 = (sizetype) type_len;
          D.35402 = type_name + D.35401;
          *D.35402 = 0;
          named.426 = named;
          D.35401 = (sizetype) type_len;
          named.434 = named.426 + D.35401;
          named = named.434;
          monoeg_g_free (type_name);
        }
        <D.35396>:
        named.426 = named;
        D.35404 = mono_metadata_decode_blob_size (named.426, &named);
        name_len = (gint) D.35404;
        D.35405 = name_len + 1;
        D.35406 = (long unsigned int) D.35405;
        name = monoeg_malloc (D.35406);
        D.35407 = (long unsigned int) name_len;
        named.426 = named;
        memcpy (name, named.426, D.35407);
        D.35408 = (sizetype) name_len;
        D.35409 = name + D.35408;
        *D.35409 = 0;
        named.426 = named;
        D.35408 = (sizetype) name_len;
        named.435 = named.426 + D.35408;
        named = named.435;
        if (named_type == 83) goto <D.35411>; else goto <D.35412>;
        <D.35411>:
        {
          struct MonoClassField * field;
          void * val;

          D.35413 = attr->vtable;
          D.35414 = D.35413->klass;
          field = mono_class_get_field_from_name (D.35414, name);
          named.426 = named;
          D.35415 = field->type;
          val = load_cattr_value (image, D.35415, named.426, &named);
          mono_field_set_value (attr, field, val);
          D.35415 = field->type;
          D.35416 = type_is_reference (D.35415);
          if (D.35416 == 0) goto <D.35417>; else goto <D.35418>;
          <D.35417>:
          monoeg_g_free (val);
          <D.35418>:
        }
        goto <D.35419>;
        <D.35412>:
        if (named_type == 84) goto <D.35420>; else goto <D.35421>;
        <D.35420>:
        {
          struct MonoProperty * prop;
          void * pparams[1];
          struct MonoType * prop_type;

          try
            {
              D.35413 = attr->vtable;
              D.35414 = D.35413->klass;
              prop = mono_class_get_property_from_name (D.35414, name);
              D.35423 = prop->get;
              if (D.35423 != 0B) goto <D.35424>; else goto <D.35425>;
              <D.35424>:
              D.35423 = prop->get;
              D.35426 = mono_method_signature (D.35423);
              iftmp.436 = D.35426->ret;
              goto <D.35427>;
              <D.35425>:
              D.35428 = prop->set;
              D.35429 = mono_method_signature (D.35428);
              D.35428 = prop->set;
              D.35430 = mono_method_signature (D.35428);
              D.35431 = D.35430->param_count;
              D.35432 = (int) D.35431;
              D.35433 = D.35432 + -1;
              iftmp.436 = D.35429->params[D.35433];
              <D.35427>:
              prop_type = iftmp.436;
              named.426 = named;
              D.35434 = load_cattr_value (image, prop_type, named.426, &named);
              pparams[0] = D.35434;
              mono_property_set_value (prop, attr, &pparams, 0B);
              D.35435 = type_is_reference (prop_type);
              if (D.35435 == 0) goto <D.35436>; else goto <D.35437>;
              <D.35436>:
              D.35438 = pparams[0];
              monoeg_g_free (D.35438);
              <D.35437>:
            }
          finally
            {
              pparams = {CLOBBER};
            }
        }
        <D.35421>:
        <D.35419>:
        monoeg_g_free (name);
      }
      j = j + 1;
      <D.22037>:
      if (j < num_named) goto <D.22036>; else goto <D.22038>;
      <D.22038>:
      if (&params_buf != params) goto <D.35439>; else goto <D.35440>;
      <D.35439>:
      mono_gc_free_fixed (params);
      <D.35440>:
      D.35357 = attr;
      return D.35357;
    }
  finally
    {
      p = {CLOBBER};
      named = {CLOBBER};
      params_buf = {CLOBBER};
    }
}


free_param_data (struct MonoMethodSignature * sig, void * * params)
{
  struct MonoType * D.35443;
  int D.35444;
  long unsigned int D.35447;
  long unsigned int D.35448;
  void * * D.35449;
  void * D.35450;
  short unsigned int D.35451;
  int D.35452;
  int i;

  i = 0;
  goto <D.21980>;
  <D.21979>:
  D.35443 = sig->params[i];
  D.35444 = type_is_reference (D.35443);
  if (D.35444 == 0) goto <D.35445>; else goto <D.35446>;
  <D.35445>:
  D.35447 = (long unsigned int) i;
  D.35448 = D.35447 * 8;
  D.35449 = params + D.35448;
  D.35450 = *D.35449;
  monoeg_g_free (D.35450);
  <D.35446>:
  i = i + 1;
  <D.21980>:
  D.35451 = sig->param_count;
  D.35452 = (int) D.35451;
  if (D.35452 > i) goto <D.21979>; else goto <D.21981>;
  <D.21981>:
}


mono_custom_attrs_from_index (struct MonoImage * image, guint32 idx)
{
  struct MonoCustomAttrInfo * D.35455;
  int i.437;
  unsigned int D.35457;
  long unsigned int D.35459;
  void * D.35460;
  <unnamed-unsigned:24> D.35461;
  unsigned int D.35462;
  long unsigned int D.35465;
  long unsigned int D.35466;
  long unsigned int D.35467;
  int len.438;
  void * D.35469;
  long int D.35470;
  int D.35471;
  unsigned int D.35472;
  unsigned int D.35473;
  struct MonoMethod * D.35474;
  struct MonoMethod * D.35475;
  char * D.35478;
  unsigned int D.35479;
  int D.35480;
  const char * data.439;
  const char * data.440;
  unsigned int D.35485;
  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.35453>; else goto <D.35454>;
      <D.35453>:
      D.35455 = 0B;
      return D.35455;
      <D.35454>:
      i = i + 4294967295;
      goto <D.22169>;
      <D.22168>:
      i.437 = (int) i;
      D.35457 = mono_metadata_decode_row_col (ca, i.437, 0);
      if (D.35457 != idx) goto <D.22167>; else goto <D.35458>;
      <D.35458>:
      D.35459 = (long unsigned int) i;
      D.35460 = (void *) D.35459;
      list = monoeg_g_list_prepend (list, D.35460);
      i = i + 1;
      <D.22169>:
      D.35461 = ca->rows;
      D.35462 = (unsigned int) D.35461;
      if (D.35462 > i) goto <D.22168>; else goto <D.22167>;
      <D.22167>:
      len = monoeg_g_list_length (list);
      if (len == 0) goto <D.35463>; else goto <D.35464>;
      <D.35463>:
      D.35455 = 0B;
      return D.35455;
      <D.35464>:
      D.35465 = (long unsigned int) len;
      D.35466 = D.35465 * 24;
      D.35467 = D.35466 + 16;
      ainfo = monoeg_malloc0 (D.35467);
      len.438 = (int) len;
      ainfo->num_attrs = len.438;
      ainfo->image = image;
      i = 0;
      tmp = list;
      goto <D.22176>;
      <D.22175>:
      D.35469 = tmp->data;
      D.35470 = (long int) D.35469;
      D.35471 = (int) D.35470;
      mono_metadata_decode_row (ca, D.35471, &cols, 3);
      D.35472 = cols[1];
      mtoken = D.35472 >> 3;
      D.35472 = cols[1];
      D.35473 = D.35472 & 7;
      switch (D.35473) <default: <D.22173>, case 2: <D.22170>, case 3: <D.22172>>
      <D.22170>:
      mtoken = mtoken | 100663296;
      goto <D.22171>;
      <D.22172>:
      mtoken = mtoken | 167772160;
      goto <D.22171>;
      <D.22173>:
      D.35472 = cols[1];
      monoeg_g_log (0B, 4, "Unknown table for custom attr type %08x", D.35472);
      <D.22174>:
      goto <D.22174>;
      <D.22171>:
      D.35474 = mono_get_method (image, mtoken, 0B);
      ainfo->attrs[i].ctor = D.35474;
      D.35475 = ainfo->attrs[i].ctor;
      if (D.35475 == 0B) goto <D.35476>; else goto <D.35477>;
      <D.35476>:
      D.35478 = image->name;
      monoeg_g_log (0B, 16, "Can\'t find custom attr constructor image: %s mtoken: 0x%08x", D.35478, mtoken);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.35455 = 0B;
      return D.35455;
      <D.35477>:
      D.35479 = cols[2];
      D.35480 = mono_verifier_verify_cattr_blob (image, D.35479, 0B);
      if (D.35480 == 0) goto <D.35481>; else goto <D.35482>;
      <D.35481>:
      D.35478 = image->name;
      monoeg_g_log (0B, 16, "Invalid custom attribute blob on image %s for index %x", D.35478, idx);
      monoeg_g_list_free (list);
      monoeg_g_free (ainfo);
      D.35455 = 0B;
      return D.35455;
      <D.35482>:
      D.35479 = cols[2];
      data.439 = mono_metadata_blob_heap (image, D.35479);
      data = data.439;
      data.440 = data;
      D.35485 = mono_metadata_decode_value (data.440, &data);
      ainfo->attrs[i].data_size = D.35485;
      data.440 = data;
      ainfo->attrs[i].data = data.440;
      i = i + 1;
      tmp = tmp->next;
      <D.22176>:
      if (i < len) goto <D.22175>; else goto <D.22177>;
      <D.22177>:
      monoeg_g_list_free (list);
      D.35455 = ainfo;
      return D.35455;
    }
  finally
    {
      cols = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_custom_attrs_from_method (struct MonoMethod * method)
{
  unsigned char D.35488;
  unsigned char D.35489;
  unsigned char D.35494;
  struct MonoClass * D.35496;
  struct MonoImage * D.35497;
  unsigned char D.35498;
  unsigned char D.35499;
  struct MonoCustomAttrInfo * D.35500;
  unsigned int D.35501;
  guint32 idx;

  D.35488 = BIT_FIELD_REF <*method, 8, 264>;
  D.35489 = D.35488 & 16;
  if (D.35489 != 0) goto <D.35490>; else goto <D.35491>;
  <D.35490>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.35491>:
  D.35488 = BIT_FIELD_REF <*method, 8, 264>;
  D.35494 = D.35488 & 2;
  if (D.35494 != 0) goto <D.35492>; else goto <D.35495>;
  <D.35495>:
  D.35496 = method->klass;
  D.35497 = D.35496->image;
  D.35498 = BIT_FIELD_REF <*D.35497, 8, 224>;
  D.35499 = D.35498 & 8;
  if (D.35499 != 0) goto <D.35492>; else goto <D.35493>;
  <D.35492>:
  D.35496 = method->klass;
  D.35497 = D.35496->image;
  D.35500 = lookup_custom_attr (D.35497, method);
  return D.35500;
  <D.35493>:
  D.35501 = method->token;
  if (D.35501 == 0) goto <D.35502>; else goto <D.35503>;
  <D.35502>:
  D.35500 = 0B;
  return D.35500;
  <D.35503>:
  idx = mono_method_get_index (method);
  idx = idx << 5;
  idx = idx;
  D.35496 = method->klass;
  D.35497 = D.35496->image;
  D.35500 = mono_custom_attrs_from_index (D.35497, idx);
  return D.35500;
}


lookup_custom_attr (struct MonoImage * image, void * member)
{
  struct MonoCustomAttrInfo * D.35507;
  int D.35508;
  long unsigned int D.35509;
  unsigned int D.35510;
  unsigned int D.35511;
  unsigned int D.35512;
  struct MonoCustomAttrInfo * res;

  res = mono_image_property_lookup (image, member, 4096);
  if (res == 0B) goto <D.35505>; else goto <D.35506>;
  <D.35505>:
  D.35507 = 0B;
  return D.35507;
  <D.35506>:
  D.35508 = res->num_attrs;
  D.35509 = (long unsigned int) D.35508;
  D.35510 = (unsigned int) D.35509;
  D.35511 = D.35510 * 24;
  D.35512 = D.35511 + 16;
  res = monoeg_g_memdup (res, D.35512);
  res->cached = 0;
  D.35507 = res;
  return D.35507;
}


mono_custom_attrs_from_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.35514;
  struct MonoImage * D.35517;
  unsigned char D.35518;
  unsigned char D.35519;
  struct MonoCustomAttrInfo * D.35522;
  unsigned char D.35523;
  _Bool D.35524;
  _Bool D.35525;
  _Bool D.35526;
  int D.35529;
  unsigned int D.35530;
  unsigned int D.35532;
  guint32 idx;

  D.35514 = klass->generic_class;
  if (D.35514 != 0B) goto <D.35515>; else goto <D.35516>;
  <D.35515>:
  D.35514 = klass->generic_class;
  klass = D.35514->container_class;
  <D.35516>:
  D.35517 = klass->image;
  D.35518 = BIT_FIELD_REF <*D.35517, 8, 224>;
  D.35519 = D.35518 & 8;
  if (D.35519 != 0) goto <D.35520>; else goto <D.35521>;
  <D.35520>:
  D.35517 = klass->image;
  D.35522 = lookup_custom_attr (D.35517, klass);
  return D.35522;
  <D.35521>:
  D.35523 = klass->byval_arg.type;
  D.35524 = D.35523 == 19;
  D.35525 = D.35523 == 30;
  D.35526 = D.35524 | D.35525;
  if (D.35526 != 0) goto <D.35527>; else goto <D.35528>;
  <D.35527>:
  D.35529 = klass->sizes.generic_param_token;
  D.35530 = (unsigned int) D.35529;
  idx = D.35530 & 16777215;
  idx = idx << 5;
  idx = idx | 19;
  goto <D.35531>;
  <D.35528>:
  D.35532 = klass->type_token;
  idx = D.35532 & 16777215;
  idx = idx << 5;
  idx = idx | 3;
  <D.35531>:
  D.35517 = klass->image;
  D.35522 = mono_custom_attrs_from_index (D.35517, idx);
  return D.35522;
}


mono_custom_attrs_from_assembly (struct MonoAssembly * assembly)
{
  struct MonoImage * D.35534;
  unsigned char D.35535;
  unsigned char D.35536;
  struct MonoCustomAttrInfo * D.35539;
  guint32 idx;

  D.35534 = assembly->image;
  D.35535 = BIT_FIELD_REF <*D.35534, 8, 224>;
  D.35536 = D.35535 & 8;
  if (D.35536 != 0) goto <D.35537>; else goto <D.35538>;
  <D.35537>:
  D.35534 = assembly->image;
  D.35539 = lookup_custom_attr (D.35534, assembly);
  return D.35539;
  <D.35538>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 14;
  D.35534 = assembly->image;
  D.35539 = mono_custom_attrs_from_index (D.35534, idx);
  return D.35539;
}


mono_custom_attrs_from_property (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoImage * D.35541;
  unsigned char D.35542;
  unsigned char D.35543;
  struct MonoCustomAttrInfo * D.35546;
  guint32 idx;

  D.35541 = klass->image;
  D.35542 = BIT_FIELD_REF <*D.35541, 8, 224>;
  D.35543 = D.35542 & 8;
  if (D.35543 != 0) goto <D.35544>; else goto <D.35545>;
  <D.35544>:
  property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
  D.35541 = klass->image;
  D.35546 = lookup_custom_attr (D.35541, property);
  return D.35546;
  <D.35545>:
  idx = find_property_index (klass, property);
  idx = idx << 5;
  idx = idx | 9;
  D.35541 = klass->image;
  D.35546 = mono_custom_attrs_from_index (D.35541, idx);
  return D.35546;
}


find_property_index (struct MonoClass * klass, struct MonoProperty * property)
{
  struct MonoClassExt * D.35548;
  struct MonoProperty * D.35549;
  long unsigned int D.35550;
  long unsigned int D.35551;
  struct MonoProperty * D.35552;
  guint32 D.35555;
  unsigned int D.35556;
  unsigned int i.441;
  unsigned int D.35558;
  unsigned int D.35559;
  int i;

  i = 0;
  goto <D.21996>;
  <D.21995>:
  D.35548 = klass->ext;
  D.35549 = D.35548->properties;
  D.35550 = (long unsigned int) i;
  D.35551 = D.35550 * 40;
  D.35552 = D.35549 + D.35551;
  if (D.35552 == property) goto <D.35553>; else goto <D.35554>;
  <D.35553>:
  D.35548 = klass->ext;
  D.35556 = D.35548->property.first;
  i.441 = (unsigned int) i;
  D.35558 = D.35556 + i.441;
  D.35555 = D.35558 + 1;
  return D.35555;
  <D.35554>:
  i = i + 1;
  <D.21996>:
  i.441 = (unsigned int) i;
  D.35548 = klass->ext;
  D.35559 = D.35548->property.count;
  if (i.441 < D.35559) goto <D.21995>; else goto <D.21997>;
  <D.21997>:
  D.35555 = 0;
  return D.35555;
}


mono_custom_attrs_from_event (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoImage * D.35561;
  unsigned char D.35562;
  unsigned char D.35563;
  struct MonoCustomAttrInfo * D.35566;
  guint32 idx;

  D.35561 = klass->image;
  D.35562 = BIT_FIELD_REF <*D.35561, 8, 224>;
  D.35563 = D.35562 & 8;
  if (D.35563 != 0) goto <D.35564>; else goto <D.35565>;
  <D.35564>:
  event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
  D.35561 = klass->image;
  D.35566 = lookup_custom_attr (D.35561, event);
  return D.35566;
  <D.35565>:
  idx = find_event_index (klass, event);
  idx = idx << 5;
  idx = idx | 10;
  D.35561 = klass->image;
  D.35566 = mono_custom_attrs_from_index (D.35561, idx);
  return D.35566;
}


find_event_index (struct MonoClass * klass, struct MonoEvent * event)
{
  struct MonoClassExt * D.35568;
  struct MonoEvent * D.35569;
  long unsigned int D.35570;
  long unsigned int D.35571;
  struct MonoEvent * D.35572;
  guint32 D.35575;
  unsigned int D.35576;
  unsigned int i.442;
  unsigned int D.35578;
  unsigned int D.35579;
  int i;

  i = 0;
  goto <D.22004>;
  <D.22003>:
  D.35568 = klass->ext;
  D.35569 = D.35568->events;
  D.35570 = (long unsigned int) i;
  D.35571 = D.35570 * 56;
  D.35572 = D.35569 + D.35571;
  if (D.35572 == event) goto <D.35573>; else goto <D.35574>;
  <D.35573>:
  D.35568 = klass->ext;
  D.35576 = D.35568->event.first;
  i.442 = (unsigned int) i;
  D.35578 = D.35576 + i.442;
  D.35575 = D.35578 + 1;
  return D.35575;
  <D.35574>:
  i = i + 1;
  <D.22004>:
  i.442 = (unsigned int) i;
  D.35568 = klass->ext;
  D.35579 = D.35568->event.count;
  if (i.442 < D.35579) goto <D.22003>; else goto <D.22005>;
  <D.22005>:
  D.35575 = 0;
  return D.35575;
}


mono_custom_attrs_from_field (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoImage * D.35581;
  unsigned char D.35582;
  unsigned char D.35583;
  struct MonoCustomAttrInfo * D.35586;
  guint32 idx;

  D.35581 = klass->image;
  D.35582 = BIT_FIELD_REF <*D.35581, 8, 224>;
  D.35583 = D.35582 & 8;
  if (D.35583 != 0) goto <D.35584>; else goto <D.35585>;
  <D.35584>:
  field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
  D.35581 = klass->image;
  D.35586 = lookup_custom_attr (D.35581, field);
  return D.35586;
  <D.35585>:
  idx = find_field_index (klass, field);
  idx = idx << 5;
  idx = idx | 1;
  D.35581 = klass->image;
  D.35586 = mono_custom_attrs_from_index (D.35581, idx);
  return D.35586;
}


find_field_index (struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoClassField * D.35588;
  long unsigned int D.35589;
  long unsigned int D.35590;
  struct MonoClassField * D.35591;
  guint32 D.35594;
  unsigned int D.35595;
  unsigned int i.443;
  unsigned int D.35597;
  unsigned int D.35598;
  int i;

  i = 0;
  goto <D.21988>;
  <D.21987>:
  D.35588 = klass->fields;
  D.35589 = (long unsigned int) i;
  D.35590 = D.35589 * 32;
  D.35591 = D.35588 + D.35590;
  if (D.35591 == field) goto <D.35592>; else goto <D.35593>;
  <D.35592>:
  D.35595 = klass->field.first;
  i.443 = (unsigned int) i;
  D.35597 = D.35595 + i.443;
  D.35594 = D.35597 + 1;
  return D.35594;
  <D.35593>:
  i = i + 1;
  <D.21988>:
  i.443 = (unsigned int) i;
  D.35598 = klass->field.count;
  if (i.443 < D.35598) goto <D.21987>; else goto <D.21989>;
  <D.21989>:
  D.35594 = 0;
  return D.35594;
}


mono_custom_attrs_from_param (struct MonoMethod * method, guint32 param)
{
  unsigned char D.35600;
  unsigned char D.35601;
  struct MonoClass * D.35604;
  struct MonoImage * D.35605;
  unsigned char D.35606;
  unsigned char D.35607;
  struct GHashTable * D.35610;
  struct MonoCustomAttrInfo * * D.35614;
  struct MonoCustomAttrInfo * D.35615;
  long unsigned int D.35616;
  long unsigned int D.35617;
  struct MonoCustomAttrInfo * * D.35618;
  int D.35621;
  long unsigned int D.35622;
  unsigned int D.35623;
  unsigned int D.35624;
  unsigned int D.35625;
  long unsigned int D.35626;
  long unsigned int D.35627;
  unsigned int D.35630;
  int D.35631;
  <unnamed-unsigned:24> D.35632;
  unsigned int D.35633;
  int D.35636;
  int D.35637;
  int method_index.444;
  unsigned int D.35640;
  int D.35641;
  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.35600 = BIT_FIELD_REF <*method, 8, 264>;
  D.35601 = D.35600 & 16;
  if (D.35601 != 0) goto <D.35602>; else goto <D.35603>;
  <D.35602>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.35603>:
  D.35604 = method->klass;
  D.35605 = D.35604->image;
  D.35606 = BIT_FIELD_REF <*D.35605, 8, 224>;
  D.35607 = D.35606 & 8;
  if (D.35607 != 0) goto <D.35608>; else goto <D.35609>;
  <D.35608>:
  {
    struct MonoCustomAttrInfo * res;
    struct MonoCustomAttrInfo * ainfo;
    int size;

    D.35604 = method->klass;
    D.35605 = D.35604->image;
    D.35610 = MEM[(struct MonoDynamicImage *)D.35605].method_aux_hash;
    aux = monoeg_g_hash_table_lookup (D.35610, method);
    if (aux == 0B) goto <D.35611>; else goto <D.35613>;
    <D.35613>:
    D.35614 = aux->param_cattr;
    if (D.35614 == 0B) goto <D.35611>; else goto <D.35612>;
    <D.35611>:
    D.35615 = 0B;
    return D.35615;
    <D.35612>:
    D.35614 = aux->param_cattr;
    D.35616 = (long unsigned int) param;
    D.35617 = D.35616 * 8;
    D.35618 = D.35614 + D.35617;
    ainfo = *D.35618;
    if (ainfo == 0B) goto <D.35619>; else goto <D.35620>;
    <D.35619>:
    D.35615 = 0B;
    return D.35615;
    <D.35620>:
    D.35621 = ainfo->num_attrs;
    D.35622 = (long unsigned int) D.35621;
    D.35623 = (unsigned int) D.35622;
    D.35624 = D.35623 * 24;
    D.35625 = D.35624 + 16;
    size = (int) D.35625;
    D.35626 = (long unsigned int) size;
    res = monoeg_malloc0 (D.35626);
    D.35627 = (long unsigned int) size;
    memcpy (res, ainfo, D.35627);
    D.35615 = res;
    return D.35615;
  }
  <D.35609>:
  D.35604 = method->klass;
  image = D.35604->image;
  method_index = mono_method_get_index (method);
  if (method_index == 0) goto <D.35628>; else goto <D.35629>;
  <D.35628>:
  D.35615 = 0B;
  return D.35615;
  <D.35629>:
  ca = &image->tables[6];
  D.35630 = method_index + 4294967295;
  D.35631 = (int) D.35630;
  param_list = mono_metadata_decode_row_col (ca, D.35631, 5);
  D.35632 = ca->rows;
  D.35633 = (unsigned int) D.35632;
  if (D.35633 == method_index) goto <D.35634>; else goto <D.35635>;
  <D.35634>:
  ca = &image->tables[8];
  D.35632 = ca->rows;
  D.35636 = (int) D.35632;
  D.35637 = D.35636 + 1;
  param_last = (guint32) D.35637;
  goto <D.35638>;
  <D.35635>:
  method_index.444 = (int) method_index;
  param_last = mono_metadata_decode_row_col (ca, method_index.444, 5);
  ca = &image->tables[8];
  <D.35638>:
  found = 0;
  i = param_list;
  goto <D.22228>;
  <D.22227>:
  D.35640 = i + 4294967295;
  D.35641 = (int) D.35640;
  param_pos = mono_metadata_decode_row_col (ca, D.35641, 1);
  if (param_pos == param) goto <D.35642>; else goto <D.35643>;
  <D.35642>:
  found = 1;
  goto <D.22226>;
  <D.35643>:
  i = i + 1;
  <D.22228>:
  if (i < param_last) goto <D.22227>; else goto <D.22226>;
  <D.22226>:
  if (found == 0) goto <D.35644>; else goto <D.35645>;
  <D.35644>:
  D.35615 = 0B;
  return D.35615;
  <D.35645>:
  idx = i;
  idx = idx << 5;
  idx = idx | 4;
  D.35615 = mono_custom_attrs_from_index (image, idx);
  return D.35615;
}


mono_custom_attrs_has_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.35647;
  int D.35651;
  unsigned int D.35653;
  unsigned int D.35654;
  unsigned char D.35656;
  int D.35658;
  mono_bool D.35659;
  int D.35660;
  int i;
  struct MonoClass * klass;

  i = 0;
  goto <D.22236>;
  <D.22235>:
  D.35647 = ainfo->attrs[i].ctor;
  klass = D.35647->klass;
  D.35651 = mono_class_has_parent (klass, attr_klass);
  if (D.35651 != 0) goto <D.35648>; else goto <D.35652>;
  <D.35652>:
  D.35653 = attr_klass->flags;
  D.35654 = D.35653 & 32;
  if (D.35654 != 0) goto <D.35649>; else goto <D.35655>;
  <D.35655>:
  D.35656 = attr_klass->byval_arg.type;
  if (D.35656 == 19) goto <D.35649>; else goto <D.35657>;
  <D.35657>:
  D.35656 = attr_klass->byval_arg.type;
  if (D.35656 == 30) goto <D.35649>; else goto <D.35650>;
  <D.35649>:
  D.35658 = mono_class_is_assignable_from (attr_klass, klass);
  if (D.35658 != 0) goto <D.35648>; else goto <D.35650>;
  <D.35648>:
  D.35659 = 1;
  return D.35659;
  <D.35650>:
  i = i + 1;
  <D.22236>:
  D.35660 = ainfo->num_attrs;
  if (D.35660 > i) goto <D.22235>; else goto <D.22237>;
  <D.22237>:
  D.35659 = 0;
  return D.35659;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.35662;
  _Bool D.35663;
  long int D.35664;
  long int D.35665;
  struct MonoClass * * D.35668;
  _Bool D.35669;
  long int D.35670;
  long int D.35671;
  gboolean D.35674;

  D.35662 = klass->supertypes;
  D.35663 = D.35662 == 0B;
  D.35664 = (long int) D.35663;
  D.35665 = __builtin_expect (D.35664, 0);
  if (D.35665 != 0) goto <D.35666>; else goto <D.35667>;
  <D.35666>:
  mono_class_setup_supertypes (klass);
  <D.35667>:
  D.35668 = parent->supertypes;
  D.35669 = D.35668 == 0B;
  D.35670 = (long int) D.35669;
  D.35671 = __builtin_expect (D.35670, 0);
  if (D.35671 != 0) goto <D.35672>; else goto <D.35673>;
  <D.35672>:
  mono_class_setup_supertypes (parent);
  <D.35673>:
  D.35674 = mono_class_has_parent_fast (klass, parent);
  return D.35674;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.35676;
  int iftmp.445;
  short unsigned int D.35680;
  short unsigned int D.35681;
  struct MonoClass * * D.35683;
  long unsigned int D.35684;
  long unsigned int D.35685;
  sizetype D.35686;
  struct MonoClass * * D.35687;
  struct MonoClass * D.35688;

  D.35680 = klass->idepth;
  D.35681 = parent->idepth;
  if (D.35680 >= D.35681) goto <D.35682>; else goto <D.35678>;
  <D.35682>:
  D.35683 = klass->supertypes;
  D.35681 = parent->idepth;
  D.35684 = (long unsigned int) D.35681;
  D.35685 = D.35684 * 8;
  D.35686 = D.35685 + 18446744073709551608;
  D.35687 = D.35683 + D.35686;
  D.35688 = *D.35687;
  if (D.35688 == parent) goto <D.35689>; else goto <D.35678>;
  <D.35689>:
  iftmp.445 = 1;
  goto <D.35679>;
  <D.35678>:
  iftmp.445 = 0;
  <D.35679>:
  D.35676 = iftmp.445;
  return D.35676;
}


mono_custom_attrs_get_attr (struct MonoCustomAttrInfo * ainfo, struct MonoClass * attr_klass)
{
  struct MonoMethod * D.35691;
  int D.35692;
  int D.35695;
  struct MonoObject * D.35698;
  long unsigned int D.35701;
  char * D.35702;
  int i;
  int attr_index;
  struct MonoClass * klass;
  struct MonoArray * attrs;

  attr_index = -1;
  i = 0;
  goto <D.22248>;
  <D.22247>:
  D.35691 = ainfo->attrs[i].ctor;
  klass = D.35691->klass;
  D.35692 = mono_class_has_parent (klass, attr_klass);
  if (D.35692 != 0) goto <D.35693>; else goto <D.35694>;
  <D.35693>:
  attr_index = i;
  goto <D.22246>;
  <D.35694>:
  i = i + 1;
  <D.22248>:
  D.35695 = ainfo->num_attrs;
  if (D.35695 > i) goto <D.22247>; else goto <D.22246>;
  <D.22246>:
  if (attr_index == -1) goto <D.35696>; else goto <D.35697>;
  <D.35696>:
  D.35698 = 0B;
  return D.35698;
  <D.35697>:
  attrs = mono_custom_attrs_construct (ainfo);
  if (attrs != 0B) goto <D.35699>; else goto <D.35700>;
  <D.35699>:
  D.35701 = (long unsigned int) attr_index;
  D.35702 = mono_array_addr_with_size (attrs, 8, D.35701);
  D.35698 = MEM[(struct MonoObject * *)D.35702];
  return D.35698;
  <D.35700>:
  D.35698 = 0B;
  return D.35698;
}


mono_reflection_get_custom_attrs_info (struct MonoObject * obj)
{
  struct MonoVTable * D.35704;
  struct MonoClass * D.35705;
  int D.22263;
  int iftmp.446;
  int D.22259;
  const char[9] * D.35715;
  unsigned char D.35716;
  int D.35717;
  unsigned char D.35718;
  int D.35719;
  _Bool D.35720;
  _Bool D.35721;
  _Bool D.35722;
  const unsigned char * D.35725;
  unsigned char D.35726;
  int D.35727;
  const unsigned char * D.35728;
  unsigned char D.35729;
  int D.35730;
  _Bool D.35731;
  _Bool D.35732;
  const unsigned char * D.35735;
  unsigned char D.35736;
  int D.35737;
  const unsigned char * D.35738;
  unsigned char D.35739;
  int D.35740;
  _Bool D.35741;
  _Bool D.35742;
  const unsigned char * D.35745;
  unsigned char D.35746;
  int D.35747;
  const unsigned char * D.35748;
  unsigned char D.35749;
  int D.35750;
  const char * D.35752;
  int D.22272;
  int iftmp.447;
  int D.22268;
  const char[13] * D.35757;
  unsigned char D.35758;
  int D.35759;
  unsigned char D.35760;
  int D.35761;
  _Bool D.35762;
  _Bool D.35763;
  _Bool D.35764;
  const unsigned char * D.35767;
  unsigned char D.35768;
  int D.35769;
  const unsigned char * D.35770;
  unsigned char D.35771;
  int D.35772;
  _Bool D.35773;
  _Bool D.35774;
  const unsigned char * D.35777;
  unsigned char D.35778;
  int D.35779;
  const unsigned char * D.35780;
  unsigned char D.35781;
  int D.35782;
  _Bool D.35783;
  _Bool D.35784;
  const unsigned char * D.35787;
  unsigned char D.35788;
  int D.35789;
  const unsigned char * D.35790;
  unsigned char D.35791;
  int D.35792;
  struct MonoAssembly * D.35794;
  int D.22282;
  int iftmp.448;
  int D.22278;
  const char[7] * D.35801;
  unsigned char D.35802;
  int D.35803;
  unsigned char D.35804;
  int D.35805;
  _Bool D.35806;
  _Bool D.35807;
  _Bool D.35808;
  const unsigned char * D.35811;
  unsigned char D.35812;
  int D.35813;
  const unsigned char * D.35814;
  unsigned char D.35815;
  int D.35816;
  _Bool D.35817;
  _Bool D.35818;
  const unsigned char * D.35821;
  unsigned char D.35822;
  int D.35823;
  const unsigned char * D.35824;
  unsigned char D.35825;
  int D.35826;
  _Bool D.35827;
  _Bool D.35828;
  const unsigned char * D.35831;
  unsigned char D.35832;
  int D.35833;
  const unsigned char * D.35834;
  unsigned char D.35835;
  int D.35836;
  int D.22291;
  int iftmp.449;
  int D.22287;
  const char[11] * D.35842;
  unsigned char D.35843;
  int D.35844;
  unsigned char D.35845;
  int D.35846;
  _Bool D.35847;
  _Bool D.35848;
  _Bool D.35849;
  const unsigned char * D.35852;
  unsigned char D.35853;
  int D.35854;
  const unsigned char * D.35855;
  unsigned char D.35856;
  int D.35857;
  _Bool D.35858;
  _Bool D.35859;
  const unsigned char * D.35862;
  unsigned char D.35863;
  int D.35864;
  const unsigned char * D.35865;
  unsigned char D.35866;
  int D.35867;
  _Bool D.35868;
  _Bool D.35869;
  const unsigned char * D.35872;
  unsigned char D.35873;
  int D.35874;
  const unsigned char * D.35875;
  unsigned char D.35876;
  int D.35877;
  struct MonoImage * D.35879;
  int D.22301;
  int iftmp.450;
  int D.22297;
  const char[13] * D.35883;
  unsigned char D.35884;
  int D.35885;
  unsigned char D.35886;
  int D.35887;
  _Bool D.35888;
  _Bool D.35889;
  _Bool D.35890;
  const unsigned char * D.35893;
  unsigned char D.35894;
  int D.35895;
  const unsigned char * D.35896;
  unsigned char D.35897;
  int D.35898;
  _Bool D.35899;
  _Bool D.35900;
  const unsigned char * D.35903;
  unsigned char D.35904;
  int D.35905;
  const unsigned char * D.35906;
  unsigned char D.35907;
  int D.35908;
  _Bool D.35909;
  _Bool D.35910;
  const unsigned char * D.35913;
  unsigned char D.35914;
  int D.35915;
  const unsigned char * D.35916;
  unsigned char D.35917;
  int D.35918;
  struct MonoProperty * D.35922;
  struct MonoClass * D.35923;
  int D.22311;
  int iftmp.451;
  int D.22307;
  const char[10] * D.35928;
  unsigned char D.35929;
  int D.35930;
  unsigned char D.35931;
  int D.35932;
  _Bool D.35933;
  _Bool D.35934;
  _Bool D.35935;
  const unsigned char * D.35938;
  unsigned char D.35939;
  int D.35940;
  const unsigned char * D.35941;
  unsigned char D.35942;
  int D.35943;
  _Bool D.35944;
  _Bool D.35945;
  const unsigned char * D.35948;
  unsigned char D.35949;
  int D.35950;
  const unsigned char * D.35951;
  unsigned char D.35952;
  int D.35953;
  _Bool D.35954;
  _Bool D.35955;
  const unsigned char * D.35958;
  unsigned char D.35959;
  int D.35960;
  const unsigned char * D.35961;
  unsigned char D.35962;
  int D.35963;
  struct MonoEvent * D.35967;
  struct MonoClass * D.35968;
  int D.22321;
  int iftmp.452;
  int D.22317;
  const char[10] * D.35973;
  unsigned char D.35974;
  int D.35975;
  unsigned char D.35976;
  int D.35977;
  _Bool D.35978;
  _Bool D.35979;
  _Bool D.35980;
  const unsigned char * D.35983;
  unsigned char D.35984;
  int D.35985;
  const unsigned char * D.35986;
  unsigned char D.35987;
  int D.35988;
  _Bool D.35989;
  _Bool D.35990;
  const unsigned char * D.35993;
  unsigned char D.35994;
  int D.35995;
  const unsigned char * D.35996;
  unsigned char D.35997;
  int D.35998;
  _Bool D.35999;
  _Bool D.36000;
  const unsigned char * D.36003;
  unsigned char D.36004;
  int D.36005;
  const unsigned char * D.36006;
  unsigned char D.36007;
  int D.36008;
  struct MonoClassField * D.36012;
  struct MonoClass * D.36013;
  int D.22331;
  int iftmp.453;
  int D.22327;
  const char[11] * D.36021;
  unsigned char D.36022;
  int D.36023;
  unsigned char D.36024;
  int D.36025;
  _Bool D.36026;
  _Bool D.36027;
  _Bool D.36028;
  const unsigned char * D.36031;
  unsigned char D.36032;
  int D.36033;
  const unsigned char * D.36034;
  unsigned char D.36035;
  int D.36036;
  _Bool D.36037;
  _Bool D.36038;
  const unsigned char * D.36041;
  unsigned char D.36042;
  int D.36043;
  const unsigned char * D.36044;
  unsigned char D.36045;
  int D.36046;
  _Bool D.36047;
  _Bool D.36048;
  const unsigned char * D.36051;
  unsigned char D.36052;
  int D.36053;
  const unsigned char * D.36054;
  unsigned char D.36055;
  int D.36056;
  int D.22340;
  int iftmp.454;
  int D.22336;
  const char[12] * D.36062;
  unsigned char D.36063;
  int D.36064;
  unsigned char D.36065;
  int D.36066;
  _Bool D.36067;
  _Bool D.36068;
  _Bool D.36069;
  const unsigned char * D.36072;
  unsigned char D.36073;
  int D.36074;
  const unsigned char * D.36075;
  unsigned char D.36076;
  int D.36077;
  _Bool D.36078;
  _Bool D.36079;
  const unsigned char * D.36082;
  unsigned char D.36083;
  int D.36084;
  const unsigned char * D.36085;
  unsigned char D.36086;
  int D.36087;
  _Bool D.36088;
  _Bool D.36089;
  const unsigned char * D.36092;
  unsigned char D.36093;
  int D.36094;
  const unsigned char * D.36095;
  unsigned char D.36096;
  int D.36097;
  struct MonoMethod * D.36099;
  int D.22350;
  int iftmp.455;
  int D.22346;
  const char[18] * D.36106;
  unsigned char D.36107;
  int D.36108;
  unsigned char D.36109;
  int D.36110;
  _Bool D.36111;
  _Bool D.36112;
  _Bool D.36113;
  const unsigned char * D.36116;
  unsigned char D.36117;
  int D.36118;
  const unsigned char * D.36119;
  unsigned char D.36120;
  int D.36121;
  _Bool D.36122;
  _Bool D.36123;
  const unsigned char * D.36126;
  unsigned char D.36127;
  int D.36128;
  const unsigned char * D.36129;
  unsigned char D.36130;
  int D.36131;
  _Bool D.36132;
  _Bool D.36133;
  const unsigned char * D.36136;
  unsigned char D.36137;
  int D.36138;
  const unsigned char * D.36139;
  unsigned char D.36140;
  int D.36141;
  int D.22359;
  int iftmp.456;
  int D.22355;
  const char[19] * D.36147;
  unsigned char D.36148;
  int D.36149;
  unsigned char D.36150;
  int D.36151;
  _Bool D.36152;
  _Bool D.36153;
  _Bool D.36154;
  const unsigned char * D.36157;
  unsigned char D.36158;
  int D.36159;
  const unsigned char * D.36160;
  unsigned char D.36161;
  int D.36162;
  _Bool D.36163;
  _Bool D.36164;
  const unsigned char * D.36167;
  unsigned char D.36168;
  int D.36169;
  const unsigned char * D.36170;
  unsigned char D.36171;
  int D.36172;
  _Bool D.36173;
  _Bool D.36174;
  const unsigned char * D.36177;
  unsigned char D.36178;
  int D.36179;
  const unsigned char * D.36180;
  unsigned char D.36181;
  int D.36182;
  struct MonoMethod * D.36184;
  int D.22369;
  int iftmp.457;
  int D.22365;
  const char[14] * D.36191;
  unsigned char D.36192;
  int D.36193;
  unsigned char D.36194;
  int D.36195;
  _Bool D.36196;
  _Bool D.36197;
  _Bool D.36198;
  const unsigned char * D.36201;
  unsigned char D.36202;
  int D.36203;
  const unsigned char * D.36204;
  unsigned char D.36205;
  int D.36206;
  _Bool D.36207;
  _Bool D.36208;
  const unsigned char * D.36211;
  unsigned char D.36212;
  int D.36213;
  const unsigned char * D.36214;
  unsigned char D.36215;
  int D.36216;
  _Bool D.36217;
  _Bool D.36218;
  const unsigned char * D.36221;
  unsigned char D.36222;
  int D.36223;
  const unsigned char * D.36224;
  unsigned char D.36225;
  int D.36226;
  int D.22378;
  int iftmp.458;
  int D.22374;
  const char[18] * D.36232;
  unsigned char D.36233;
  int D.36234;
  unsigned char D.36235;
  int D.36236;
  _Bool D.36237;
  _Bool D.36238;
  _Bool D.36239;
  const unsigned char * D.36242;
  unsigned char D.36243;
  int D.36244;
  const unsigned char * D.36245;
  unsigned char D.36246;
  int D.36247;
  _Bool D.36248;
  _Bool D.36249;
  const unsigned char * D.36252;
  unsigned char D.36253;
  int D.36254;
  const unsigned char * D.36255;
  unsigned char D.36256;
  int D.36257;
  _Bool D.36258;
  _Bool D.36259;
  const unsigned char * D.36262;
  unsigned char D.36263;
  int D.36264;
  const unsigned char * D.36265;
  unsigned char D.36266;
  int D.36267;
  struct MonoObject * D.36269;
  struct MonoVTable * D.36270;
  int D.36271;
  int D.36274;
  int D.36275;
  unsigned int D.36276;
  struct MonoMethod * D.36277;
  int D.36279;
  struct MonoProperty * D.36282;
  _Bool D.36285;
  long int D.36286;
  long int D.36287;
  int D.36291;
  int D.36295;
  struct MonoObject * D.36298;
  struct MonoVTable * D.36299;
  struct MonoClass * D.36300;
  int D.36301;
  int D.36305;
  char * D.36309;
  int D.22399;
  int iftmp.459;
  int D.22395;
  const char[16] * D.36314;
  unsigned char D.36315;
  int D.36316;
  unsigned char D.36317;
  int D.36318;
  _Bool D.36319;
  _Bool D.36320;
  _Bool D.36321;
  const unsigned char * D.36324;
  unsigned char D.36325;
  int D.36326;
  const unsigned char * D.36327;
  unsigned char D.36328;
  int D.36329;
  _Bool D.36330;
  _Bool D.36331;
  const unsigned char * D.36334;
  unsigned char D.36335;
  int D.36336;
  const unsigned char * D.36337;
  unsigned char D.36338;
  int D.36339;
  _Bool D.36340;
  _Bool D.36341;
  const unsigned char * D.36344;
  unsigned char D.36345;
  int D.36346;
  const unsigned char * D.36347;
  unsigned char D.36348;
  int D.36349;
  struct MonoArray * D.36353;
  struct MonoAssembly * D.36354;
  struct MonoImage * D.36355;
  int D.22409;
  int iftmp.460;
  int D.22405;
  const char[12] * D.36360;
  unsigned char D.36361;
  int D.36362;
  unsigned char D.36363;
  int D.36364;
  _Bool D.36365;
  _Bool D.36366;
  _Bool D.36367;
  const unsigned char * D.36370;
  unsigned char D.36371;
  int D.36372;
  const unsigned char * D.36373;
  unsigned char D.36374;
  int D.36375;
  _Bool D.36376;
  _Bool D.36377;
  const unsigned char * D.36380;
  unsigned char D.36381;
  int D.36382;
  const unsigned char * D.36383;
  unsigned char D.36384;
  int D.36385;
  _Bool D.36386;
  _Bool D.36387;
  const unsigned char * D.36390;
  unsigned char D.36391;
  int D.36392;
  const unsigned char * D.36393;
  unsigned char D.36394;
  int D.36395;
  struct MonoArray * D.36399;
  struct MonoReflectionModuleBuilder * D.36400;
  struct MonoDynamicImage * D.36401;
  struct MonoImage * D.36402;
  int D.22419;
  int iftmp.461;
  int D.22415;
  const char[14] * D.36407;
  unsigned char D.36408;
  int D.36409;
  unsigned char D.36410;
  int D.36411;
  _Bool D.36412;
  _Bool D.36413;
  _Bool D.36414;
  const unsigned char * D.36417;
  unsigned char D.36418;
  int D.36419;
  const unsigned char * D.36420;
  unsigned char D.36421;
  int D.36422;
  _Bool D.36423;
  _Bool D.36424;
  const unsigned char * D.36427;
  unsigned char D.36428;
  int D.36429;
  const unsigned char * D.36430;
  unsigned char D.36431;
  int D.36432;
  _Bool D.36433;
  _Bool D.36434;
  const unsigned char * D.36437;
  unsigned char D.36438;
  int D.36439;
  const unsigned char * D.36440;
  unsigned char D.36441;
  int D.36442;
  struct MonoArray * D.36446;
  struct MonoDynamicImage * D.36447;
  struct MonoImage * D.36448;
  int D.22429;
  int iftmp.462;
  int D.22425;
  const char[19] * D.36453;
  unsigned char D.36454;
  int D.36455;
  unsigned char D.36456;
  int D.36457;
  _Bool D.36458;
  _Bool D.36459;
  _Bool D.36460;
  const unsigned char * D.36463;
  unsigned char D.36464;
  int D.36465;
  const unsigned char * D.36466;
  unsigned char D.36467;
  int D.36468;
  _Bool D.36469;
  _Bool D.36470;
  const unsigned char * D.36473;
  unsigned char D.36474;
  int D.36475;
  const unsigned char * D.36476;
  unsigned char D.36477;
  int D.36478;
  _Bool D.36479;
  _Bool D.36480;
  const unsigned char * D.36483;
  unsigned char D.36484;
  int D.36485;
  const unsigned char * D.36486;
  unsigned char D.36487;
  int D.36488;
  struct MonoArray * D.36492;
  struct MonoMethod * D.36493;
  struct MonoClass * D.36494;
  struct MonoImage * D.36495;
  int D.22439;
  int iftmp.463;
  int D.22435;
  const char[14] * D.36500;
  unsigned char D.36501;
  int D.36502;
  unsigned char D.36503;
  int D.36504;
  _Bool D.36505;
  _Bool D.36506;
  _Bool D.36507;
  const unsigned char * D.36510;
  unsigned char D.36511;
  int D.36512;
  const unsigned char * D.36513;
  unsigned char D.36514;
  int D.36515;
  _Bool D.36516;
  _Bool D.36517;
  const unsigned char * D.36520;
  unsigned char D.36521;
  int D.36522;
  const unsigned char * D.36523;
  unsigned char D.36524;
  int D.36525;
  _Bool D.36526;
  _Bool D.36527;
  const unsigned char * D.36530;
  unsigned char D.36531;
  int D.36532;
  const unsigned char * D.36533;
  unsigned char D.36534;
  int D.36535;
  struct MonoArray * D.36539;
  struct MonoMethod * D.36540;
  struct MonoClass * D.36541;
  struct MonoImage * D.36542;
  int D.22449;
  int iftmp.464;
  int D.22445;
  const char[13] * D.36547;
  unsigned char D.36548;
  int D.36549;
  unsigned char D.36550;
  int D.36551;
  _Bool D.36552;
  _Bool D.36553;
  _Bool D.36554;
  const unsigned char * D.36557;
  unsigned char D.36558;
  int D.36559;
  const unsigned char * D.36560;
  unsigned char D.36561;
  int D.36562;
  _Bool D.36563;
  _Bool D.36564;
  const unsigned char * D.36567;
  unsigned char D.36568;
  int D.36569;
  const unsigned char * D.36570;
  unsigned char D.36571;
  int D.36572;
  _Bool D.36573;
  _Bool D.36574;
  const unsigned char * D.36577;
  unsigned char D.36578;
  int D.36579;
  const unsigned char * D.36580;
  unsigned char D.36581;
  int D.36582;
  struct MonoArray * D.36586;
  struct MonoReflectionType * D.36587;
  struct MonoReflectionModuleBuilder * D.36588;
  struct MonoDynamicImage * D.36589;
  struct MonoImage * D.36590;
  int D.22459;
  int iftmp.465;
  int D.22455;
  const char[17] * D.36595;
  unsigned char D.36596;
  int D.36597;
  unsigned char D.36598;
  int D.36599;
  _Bool D.36600;
  _Bool D.36601;
  _Bool D.36602;
  const unsigned char * D.36605;
  unsigned char D.36606;
  int D.36607;
  const unsigned char * D.36608;
  unsigned char D.36609;
  int D.36610;
  _Bool D.36611;
  _Bool D.36612;
  const unsigned char * D.36615;
  unsigned char D.36616;
  int D.36617;
  const unsigned char * D.36618;
  unsigned char D.36619;
  int D.36620;
  _Bool D.36621;
  _Bool D.36622;
  const unsigned char * D.36625;
  unsigned char D.36626;
  int D.36627;
  const unsigned char * D.36628;
  unsigned char D.36629;
  int D.36630;
  struct MonoReflectionType * D.36634;
  struct MonoCustomAttrInfo * D.36636;
  struct MonoClass * klass;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = 0B;
  D.35704 = obj->vtable;
  klass = D.35704->klass;
  D.35705 = mono_defaults.monotype_class;
  if (D.35705 == klass) goto <D.35706>; else goto <D.35707>;
  <D.35706>:
  {
    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.35708>;
  <D.35707>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 8;
    if (__s1_len <= 3) goto <D.35713>; else goto <D.35714>;
    <D.35713>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.35715 = "Assembly";
      D.35716 = MEM[(const unsigned char *)D.35715];
      D.35717 = (int) D.35716;
      D.35718 = *__s2;
      D.35719 = (int) D.35718;
      __result = D.35717 - D.35719;
      {
        D.35720 = __s1_len != 0;
        D.35721 = __result == 0;
        D.35722 = D.35720 & D.35721;
        if (D.35722 != 0) goto <D.35723>; else goto <D.35724>;
        <D.35723>:
        D.35725 = &MEM[(void *)"Assembly" + 1B];
        D.35726 = *D.35725;
        D.35727 = (int) D.35726;
        D.35728 = __s2 + 1;
        D.35729 = *D.35728;
        D.35730 = (int) D.35729;
        __result = D.35727 - D.35730;
        D.35731 = __s1_len > 1;
        D.35721 = __result == 0;
        D.35732 = D.35731 & D.35721;
        if (D.35732 != 0) goto <D.35733>; else goto <D.35734>;
        <D.35733>:
        D.35735 = &MEM[(void *)"Assembly" + 2B];
        D.35736 = *D.35735;
        D.35737 = (int) D.35736;
        D.35738 = __s2 + 2;
        D.35739 = *D.35738;
        D.35740 = (int) D.35739;
        __result = D.35737 - D.35740;
        D.35741 = __s1_len > 2;
        D.35721 = __result == 0;
        D.35742 = D.35741 & D.35721;
        if (D.35742 != 0) goto <D.35743>; else goto <D.35744>;
        <D.35743>:
        D.35745 = &MEM[(void *)"Assembly" + 3B];
        D.35746 = *D.35745;
        D.35747 = (int) D.35746;
        D.35748 = __s2 + 3;
        D.35749 = *D.35748;
        D.35750 = (int) D.35749;
        __result = D.35747 - D.35750;
        <D.35744>:
        <D.35734>:
        <D.35724>:
      }
      D.22259 = __result;
    }
    iftmp.446 = D.22259;
    goto <D.35751>;
    <D.35714>:
    D.35752 = klass->name;
    iftmp.446 = __builtin_strcmp ("Assembly", D.35752);
    <D.35751>:
    D.22263 = iftmp.446;
  }
  if (D.22263 == 0) goto <D.35709>; else goto <D.35753>;
  <D.35753>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35757 = "MonoAssembly";
      D.35758 = MEM[(const unsigned char *)D.35757];
      D.35759 = (int) D.35758;
      D.35760 = *__s2;
      D.35761 = (int) D.35760;
      __result = D.35759 - D.35761;
      {
        D.35762 = __s1_len != 0;
        D.35763 = __result == 0;
        D.35764 = D.35762 & D.35763;
        if (D.35764 != 0) goto <D.35765>; else goto <D.35766>;
        <D.35765>:
        D.35767 = &MEM[(void *)"MonoAssembly" + 1B];
        D.35768 = *D.35767;
        D.35769 = (int) D.35768;
        D.35770 = __s2 + 1;
        D.35771 = *D.35770;
        D.35772 = (int) D.35771;
        __result = D.35769 - D.35772;
        D.35773 = __s1_len > 1;
        D.35763 = __result == 0;
        D.35774 = D.35773 & D.35763;
        if (D.35774 != 0) goto <D.35775>; else goto <D.35776>;
        <D.35775>:
        D.35777 = &MEM[(void *)"MonoAssembly" + 2B];
        D.35778 = *D.35777;
        D.35779 = (int) D.35778;
        D.35780 = __s2 + 2;
        D.35781 = *D.35780;
        D.35782 = (int) D.35781;
        __result = D.35779 - D.35782;
        D.35783 = __s1_len > 2;
        D.35763 = __result == 0;
        D.35784 = D.35783 & D.35763;
        if (D.35784 != 0) goto <D.35785>; else goto <D.35786>;
        <D.35785>:
        D.35787 = &MEM[(void *)"MonoAssembly" + 3B];
        D.35788 = *D.35787;
        D.35789 = (int) D.35788;
        D.35790 = __s2 + 3;
        D.35791 = *D.35790;
        D.35792 = (int) D.35791;
        __result = D.35789 - D.35792;
        <D.35786>:
        <D.35776>:
        <D.35766>:
      }
      D.22268 = __result;
    }
    iftmp.447 = D.22268;
    goto <D.35793>;
    <D.35756>:
    D.35752 = klass->name;
    iftmp.447 = __builtin_strcmp ("MonoAssembly", D.35752);
    <D.35793>:
    D.22272 = iftmp.447;
  }
  if (D.22272 == 0) goto <D.35709>; else goto <D.35710>;
  <D.35709>:
  {
    struct MonoReflectionAssembly * rassembly;

    rassembly = obj;
    D.35794 = rassembly->assembly;
    cinfo = mono_custom_attrs_from_assembly (D.35794);
  }
  goto <D.35711>;
  <D.35710>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35801 = "Module";
      D.35802 = MEM[(const unsigned char *)D.35801];
      D.35803 = (int) D.35802;
      D.35804 = *__s2;
      D.35805 = (int) D.35804;
      __result = D.35803 - D.35805;
      {
        D.35806 = __s1_len != 0;
        D.35807 = __result == 0;
        D.35808 = D.35806 & D.35807;
        if (D.35808 != 0) goto <D.35809>; else goto <D.35810>;
        <D.35809>:
        D.35811 = &MEM[(void *)"Module" + 1B];
        D.35812 = *D.35811;
        D.35813 = (int) D.35812;
        D.35814 = __s2 + 1;
        D.35815 = *D.35814;
        D.35816 = (int) D.35815;
        __result = D.35813 - D.35816;
        D.35817 = __s1_len > 1;
        D.35807 = __result == 0;
        D.35818 = D.35817 & D.35807;
        if (D.35818 != 0) goto <D.35819>; else goto <D.35820>;
        <D.35819>:
        D.35821 = &MEM[(void *)"Module" + 2B];
        D.35822 = *D.35821;
        D.35823 = (int) D.35822;
        D.35824 = __s2 + 2;
        D.35825 = *D.35824;
        D.35826 = (int) D.35825;
        __result = D.35823 - D.35826;
        D.35827 = __s1_len > 2;
        D.35807 = __result == 0;
        D.35828 = D.35827 & D.35807;
        if (D.35828 != 0) goto <D.35829>; else goto <D.35830>;
        <D.35829>:
        D.35831 = &MEM[(void *)"Module" + 3B];
        D.35832 = *D.35831;
        D.35833 = (int) D.35832;
        D.35834 = __s2 + 3;
        D.35835 = *D.35834;
        D.35836 = (int) D.35835;
        __result = D.35833 - D.35836;
        <D.35830>:
        <D.35820>:
        <D.35810>:
      }
      D.22278 = __result;
    }
    iftmp.448 = D.22278;
    goto <D.35837>;
    <D.35800>:
    D.35752 = klass->name;
    iftmp.448 = __builtin_strcmp ("Module", D.35752);
    <D.35837>:
    D.22282 = iftmp.448;
  }
  if (D.22282 == 0) goto <D.35795>; else goto <D.35838>;
  <D.35838>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35842 = "MonoModule";
      D.35843 = MEM[(const unsigned char *)D.35842];
      D.35844 = (int) D.35843;
      D.35845 = *__s2;
      D.35846 = (int) D.35845;
      __result = D.35844 - D.35846;
      {
        D.35847 = __s1_len != 0;
        D.35848 = __result == 0;
        D.35849 = D.35847 & D.35848;
        if (D.35849 != 0) goto <D.35850>; else goto <D.35851>;
        <D.35850>:
        D.35852 = &MEM[(void *)"MonoModule" + 1B];
        D.35853 = *D.35852;
        D.35854 = (int) D.35853;
        D.35855 = __s2 + 1;
        D.35856 = *D.35855;
        D.35857 = (int) D.35856;
        __result = D.35854 - D.35857;
        D.35858 = __s1_len > 1;
        D.35848 = __result == 0;
        D.35859 = D.35858 & D.35848;
        if (D.35859 != 0) goto <D.35860>; else goto <D.35861>;
        <D.35860>:
        D.35862 = &MEM[(void *)"MonoModule" + 2B];
        D.35863 = *D.35862;
        D.35864 = (int) D.35863;
        D.35865 = __s2 + 2;
        D.35866 = *D.35865;
        D.35867 = (int) D.35866;
        __result = D.35864 - D.35867;
        D.35868 = __s1_len > 2;
        D.35848 = __result == 0;
        D.35869 = D.35868 & D.35848;
        if (D.35869 != 0) goto <D.35870>; else goto <D.35871>;
        <D.35870>:
        D.35872 = &MEM[(void *)"MonoModule" + 3B];
        D.35873 = *D.35872;
        D.35874 = (int) D.35873;
        D.35875 = __s2 + 3;
        D.35876 = *D.35875;
        D.35877 = (int) D.35876;
        __result = D.35874 - D.35877;
        <D.35871>:
        <D.35861>:
        <D.35851>:
      }
      D.22287 = __result;
    }
    iftmp.449 = D.22287;
    goto <D.35878>;
    <D.35841>:
    D.35752 = klass->name;
    iftmp.449 = __builtin_strcmp ("MonoModule", D.35752);
    <D.35878>:
    D.22291 = iftmp.449;
  }
  if (D.22291 == 0) goto <D.35795>; else goto <D.35796>;
  <D.35795>:
  {
    struct MonoReflectionModule * module;

    module = obj;
    D.35879 = module->image;
    cinfo = mono_custom_attrs_from_module (D.35879);
  }
  goto <D.35797>;
  <D.35796>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35883 = "MonoProperty";
      D.35884 = MEM[(const unsigned char *)D.35883];
      D.35885 = (int) D.35884;
      D.35886 = *__s2;
      D.35887 = (int) D.35886;
      __result = D.35885 - D.35887;
      {
        D.35888 = __s1_len != 0;
        D.35889 = __result == 0;
        D.35890 = D.35888 & D.35889;
        if (D.35890 != 0) goto <D.35891>; else goto <D.35892>;
        <D.35891>:
        D.35893 = &MEM[(void *)"MonoProperty" + 1B];
        D.35894 = *D.35893;
        D.35895 = (int) D.35894;
        D.35896 = __s2 + 1;
        D.35897 = *D.35896;
        D.35898 = (int) D.35897;
        __result = D.35895 - D.35898;
        D.35899 = __s1_len > 1;
        D.35889 = __result == 0;
        D.35900 = D.35899 & D.35889;
        if (D.35900 != 0) goto <D.35901>; else goto <D.35902>;
        <D.35901>:
        D.35903 = &MEM[(void *)"MonoProperty" + 2B];
        D.35904 = *D.35903;
        D.35905 = (int) D.35904;
        D.35906 = __s2 + 2;
        D.35907 = *D.35906;
        D.35908 = (int) D.35907;
        __result = D.35905 - D.35908;
        D.35909 = __s1_len > 2;
        D.35889 = __result == 0;
        D.35910 = D.35909 & D.35889;
        if (D.35910 != 0) goto <D.35911>; else goto <D.35912>;
        <D.35911>:
        D.35913 = &MEM[(void *)"MonoProperty" + 3B];
        D.35914 = *D.35913;
        D.35915 = (int) D.35914;
        D.35916 = __s2 + 3;
        D.35917 = *D.35916;
        D.35918 = (int) D.35917;
        __result = D.35915 - D.35918;
        <D.35912>:
        <D.35902>:
        <D.35892>:
      }
      D.22297 = __result;
    }
    iftmp.450 = D.22297;
    goto <D.35919>;
    <D.35882>:
    D.35752 = klass->name;
    iftmp.450 = __builtin_strcmp ("MonoProperty", D.35752);
    <D.35919>:
    D.22301 = iftmp.450;
  }
  if (D.22301 == 0) goto <D.35920>; else goto <D.35921>;
  <D.35920>:
  {
    struct MonoReflectionProperty * rprop;

    rprop = obj;
    D.35922 = rprop->property;
    D.35922 = rprop->property;
    D.35923 = D.35922->parent;
    cinfo = mono_custom_attrs_from_property (D.35923, D.35922);
  }
  goto <D.35924>;
  <D.35921>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35928 = "MonoEvent";
      D.35929 = MEM[(const unsigned char *)D.35928];
      D.35930 = (int) D.35929;
      D.35931 = *__s2;
      D.35932 = (int) D.35931;
      __result = D.35930 - D.35932;
      {
        D.35933 = __s1_len != 0;
        D.35934 = __result == 0;
        D.35935 = D.35933 & D.35934;
        if (D.35935 != 0) goto <D.35936>; else goto <D.35937>;
        <D.35936>:
        D.35938 = &MEM[(void *)"MonoEvent" + 1B];
        D.35939 = *D.35938;
        D.35940 = (int) D.35939;
        D.35941 = __s2 + 1;
        D.35942 = *D.35941;
        D.35943 = (int) D.35942;
        __result = D.35940 - D.35943;
        D.35944 = __s1_len > 1;
        D.35934 = __result == 0;
        D.35945 = D.35944 & D.35934;
        if (D.35945 != 0) goto <D.35946>; else goto <D.35947>;
        <D.35946>:
        D.35948 = &MEM[(void *)"MonoEvent" + 2B];
        D.35949 = *D.35948;
        D.35950 = (int) D.35949;
        D.35951 = __s2 + 2;
        D.35952 = *D.35951;
        D.35953 = (int) D.35952;
        __result = D.35950 - D.35953;
        D.35954 = __s1_len > 2;
        D.35934 = __result == 0;
        D.35955 = D.35954 & D.35934;
        if (D.35955 != 0) goto <D.35956>; else goto <D.35957>;
        <D.35956>:
        D.35958 = &MEM[(void *)"MonoEvent" + 3B];
        D.35959 = *D.35958;
        D.35960 = (int) D.35959;
        D.35961 = __s2 + 3;
        D.35962 = *D.35961;
        D.35963 = (int) D.35962;
        __result = D.35960 - D.35963;
        <D.35957>:
        <D.35947>:
        <D.35937>:
      }
      D.22307 = __result;
    }
    iftmp.451 = D.22307;
    goto <D.35964>;
    <D.35927>:
    D.35752 = klass->name;
    iftmp.451 = __builtin_strcmp ("MonoEvent", D.35752);
    <D.35964>:
    D.22311 = iftmp.451;
  }
  if (D.22311 == 0) goto <D.35965>; else goto <D.35966>;
  <D.35965>:
  {
    struct MonoReflectionMonoEvent * revent;

    revent = obj;
    D.35967 = revent->event;
    D.35967 = revent->event;
    D.35968 = D.35967->parent;
    cinfo = mono_custom_attrs_from_event (D.35968, D.35967);
  }
  goto <D.35969>;
  <D.35966>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.35973 = "MonoField";
      D.35974 = MEM[(const unsigned char *)D.35973];
      D.35975 = (int) D.35974;
      D.35976 = *__s2;
      D.35977 = (int) D.35976;
      __result = D.35975 - D.35977;
      {
        D.35978 = __s1_len != 0;
        D.35979 = __result == 0;
        D.35980 = D.35978 & D.35979;
        if (D.35980 != 0) goto <D.35981>; else goto <D.35982>;
        <D.35981>:
        D.35983 = &MEM[(void *)"MonoField" + 1B];
        D.35984 = *D.35983;
        D.35985 = (int) D.35984;
        D.35986 = __s2 + 1;
        D.35987 = *D.35986;
        D.35988 = (int) D.35987;
        __result = D.35985 - D.35988;
        D.35989 = __s1_len > 1;
        D.35979 = __result == 0;
        D.35990 = D.35989 & D.35979;
        if (D.35990 != 0) goto <D.35991>; else goto <D.35992>;
        <D.35991>:
        D.35993 = &MEM[(void *)"MonoField" + 2B];
        D.35994 = *D.35993;
        D.35995 = (int) D.35994;
        D.35996 = __s2 + 2;
        D.35997 = *D.35996;
        D.35998 = (int) D.35997;
        __result = D.35995 - D.35998;
        D.35999 = __s1_len > 2;
        D.35979 = __result == 0;
        D.36000 = D.35999 & D.35979;
        if (D.36000 != 0) goto <D.36001>; else goto <D.36002>;
        <D.36001>:
        D.36003 = &MEM[(void *)"MonoField" + 3B];
        D.36004 = *D.36003;
        D.36005 = (int) D.36004;
        D.36006 = __s2 + 3;
        D.36007 = *D.36006;
        D.36008 = (int) D.36007;
        __result = D.36005 - D.36008;
        <D.36002>:
        <D.35992>:
        <D.35982>:
      }
      D.22317 = __result;
    }
    iftmp.452 = D.22317;
    goto <D.36009>;
    <D.35972>:
    D.35752 = klass->name;
    iftmp.452 = __builtin_strcmp ("MonoField", D.35752);
    <D.36009>:
    D.22321 = iftmp.452;
  }
  if (D.22321 == 0) goto <D.36010>; else goto <D.36011>;
  <D.36010>:
  {
    struct MonoReflectionField * rfield;

    rfield = obj;
    D.36012 = rfield->field;
    D.36012 = rfield->field;
    D.36013 = D.36012->parent;
    cinfo = mono_custom_attrs_from_field (D.36013, D.36012);
  }
  goto <D.36014>;
  <D.36011>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36021 = "MonoMethod";
      D.36022 = MEM[(const unsigned char *)D.36021];
      D.36023 = (int) D.36022;
      D.36024 = *__s2;
      D.36025 = (int) D.36024;
      __result = D.36023 - D.36025;
      {
        D.36026 = __s1_len != 0;
        D.36027 = __result == 0;
        D.36028 = D.36026 & D.36027;
        if (D.36028 != 0) goto <D.36029>; else goto <D.36030>;
        <D.36029>:
        D.36031 = &MEM[(void *)"MonoMethod" + 1B];
        D.36032 = *D.36031;
        D.36033 = (int) D.36032;
        D.36034 = __s2 + 1;
        D.36035 = *D.36034;
        D.36036 = (int) D.36035;
        __result = D.36033 - D.36036;
        D.36037 = __s1_len > 1;
        D.36027 = __result == 0;
        D.36038 = D.36037 & D.36027;
        if (D.36038 != 0) goto <D.36039>; else goto <D.36040>;
        <D.36039>:
        D.36041 = &MEM[(void *)"MonoMethod" + 2B];
        D.36042 = *D.36041;
        D.36043 = (int) D.36042;
        D.36044 = __s2 + 2;
        D.36045 = *D.36044;
        D.36046 = (int) D.36045;
        __result = D.36043 - D.36046;
        D.36047 = __s1_len > 2;
        D.36027 = __result == 0;
        D.36048 = D.36047 & D.36027;
        if (D.36048 != 0) goto <D.36049>; else goto <D.36050>;
        <D.36049>:
        D.36051 = &MEM[(void *)"MonoMethod" + 3B];
        D.36052 = *D.36051;
        D.36053 = (int) D.36052;
        D.36054 = __s2 + 3;
        D.36055 = *D.36054;
        D.36056 = (int) D.36055;
        __result = D.36053 - D.36056;
        <D.36050>:
        <D.36040>:
        <D.36030>:
      }
      D.22327 = __result;
    }
    iftmp.453 = D.22327;
    goto <D.36057>;
    <D.36020>:
    D.35752 = klass->name;
    iftmp.453 = __builtin_strcmp ("MonoMethod", D.35752);
    <D.36057>:
    D.22331 = iftmp.453;
  }
  if (D.22331 == 0) goto <D.36015>; else goto <D.36058>;
  <D.36058>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36062 = "MonoCMethod";
      D.36063 = MEM[(const unsigned char *)D.36062];
      D.36064 = (int) D.36063;
      D.36065 = *__s2;
      D.36066 = (int) D.36065;
      __result = D.36064 - D.36066;
      {
        D.36067 = __s1_len != 0;
        D.36068 = __result == 0;
        D.36069 = D.36067 & D.36068;
        if (D.36069 != 0) goto <D.36070>; else goto <D.36071>;
        <D.36070>:
        D.36072 = &MEM[(void *)"MonoCMethod" + 1B];
        D.36073 = *D.36072;
        D.36074 = (int) D.36073;
        D.36075 = __s2 + 1;
        D.36076 = *D.36075;
        D.36077 = (int) D.36076;
        __result = D.36074 - D.36077;
        D.36078 = __s1_len > 1;
        D.36068 = __result == 0;
        D.36079 = D.36078 & D.36068;
        if (D.36079 != 0) goto <D.36080>; else goto <D.36081>;
        <D.36080>:
        D.36082 = &MEM[(void *)"MonoCMethod" + 2B];
        D.36083 = *D.36082;
        D.36084 = (int) D.36083;
        D.36085 = __s2 + 2;
        D.36086 = *D.36085;
        D.36087 = (int) D.36086;
        __result = D.36084 - D.36087;
        D.36088 = __s1_len > 2;
        D.36068 = __result == 0;
        D.36089 = D.36088 & D.36068;
        if (D.36089 != 0) goto <D.36090>; else goto <D.36091>;
        <D.36090>:
        D.36092 = &MEM[(void *)"MonoCMethod" + 3B];
        D.36093 = *D.36092;
        D.36094 = (int) D.36093;
        D.36095 = __s2 + 3;
        D.36096 = *D.36095;
        D.36097 = (int) D.36096;
        __result = D.36094 - D.36097;
        <D.36091>:
        <D.36081>:
        <D.36071>:
      }
      D.22336 = __result;
    }
    iftmp.454 = D.22336;
    goto <D.36098>;
    <D.36061>:
    D.35752 = klass->name;
    iftmp.454 = __builtin_strcmp ("MonoCMethod", D.35752);
    <D.36098>:
    D.22340 = iftmp.454;
  }
  if (D.22340 == 0) goto <D.36015>; else goto <D.36016>;
  <D.36015>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.36099 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.36099);
  }
  goto <D.36017>;
  <D.36016>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36106 = "MonoGenericMethod";
      D.36107 = MEM[(const unsigned char *)D.36106];
      D.36108 = (int) D.36107;
      D.36109 = *__s2;
      D.36110 = (int) D.36109;
      __result = D.36108 - D.36110;
      {
        D.36111 = __s1_len != 0;
        D.36112 = __result == 0;
        D.36113 = D.36111 & D.36112;
        if (D.36113 != 0) goto <D.36114>; else goto <D.36115>;
        <D.36114>:
        D.36116 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.36117 = *D.36116;
        D.36118 = (int) D.36117;
        D.36119 = __s2 + 1;
        D.36120 = *D.36119;
        D.36121 = (int) D.36120;
        __result = D.36118 - D.36121;
        D.36122 = __s1_len > 1;
        D.36112 = __result == 0;
        D.36123 = D.36122 & D.36112;
        if (D.36123 != 0) goto <D.36124>; else goto <D.36125>;
        <D.36124>:
        D.36126 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.36127 = *D.36126;
        D.36128 = (int) D.36127;
        D.36129 = __s2 + 2;
        D.36130 = *D.36129;
        D.36131 = (int) D.36130;
        __result = D.36128 - D.36131;
        D.36132 = __s1_len > 2;
        D.36112 = __result == 0;
        D.36133 = D.36132 & D.36112;
        if (D.36133 != 0) goto <D.36134>; else goto <D.36135>;
        <D.36134>:
        D.36136 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.36137 = *D.36136;
        D.36138 = (int) D.36137;
        D.36139 = __s2 + 3;
        D.36140 = *D.36139;
        D.36141 = (int) D.36140;
        __result = D.36138 - D.36141;
        <D.36135>:
        <D.36125>:
        <D.36115>:
      }
      D.22346 = __result;
    }
    iftmp.455 = D.22346;
    goto <D.36142>;
    <D.36105>:
    D.35752 = klass->name;
    iftmp.455 = __builtin_strcmp ("MonoGenericMethod", D.35752);
    <D.36142>:
    D.22350 = iftmp.455;
  }
  if (D.22350 == 0) goto <D.36100>; else goto <D.36143>;
  <D.36143>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36147 = "MonoGenericCMethod";
      D.36148 = MEM[(const unsigned char *)D.36147];
      D.36149 = (int) D.36148;
      D.36150 = *__s2;
      D.36151 = (int) D.36150;
      __result = D.36149 - D.36151;
      {
        D.36152 = __s1_len != 0;
        D.36153 = __result == 0;
        D.36154 = D.36152 & D.36153;
        if (D.36154 != 0) goto <D.36155>; else goto <D.36156>;
        <D.36155>:
        D.36157 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.36158 = *D.36157;
        D.36159 = (int) D.36158;
        D.36160 = __s2 + 1;
        D.36161 = *D.36160;
        D.36162 = (int) D.36161;
        __result = D.36159 - D.36162;
        D.36163 = __s1_len > 1;
        D.36153 = __result == 0;
        D.36164 = D.36163 & D.36153;
        if (D.36164 != 0) goto <D.36165>; else goto <D.36166>;
        <D.36165>:
        D.36167 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.36168 = *D.36167;
        D.36169 = (int) D.36168;
        D.36170 = __s2 + 2;
        D.36171 = *D.36170;
        D.36172 = (int) D.36171;
        __result = D.36169 - D.36172;
        D.36173 = __s1_len > 2;
        D.36153 = __result == 0;
        D.36174 = D.36173 & D.36153;
        if (D.36174 != 0) goto <D.36175>; else goto <D.36176>;
        <D.36175>:
        D.36177 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.36178 = *D.36177;
        D.36179 = (int) D.36178;
        D.36180 = __s2 + 3;
        D.36181 = *D.36180;
        D.36182 = (int) D.36181;
        __result = D.36179 - D.36182;
        <D.36176>:
        <D.36166>:
        <D.36156>:
      }
      D.22355 = __result;
    }
    iftmp.456 = D.22355;
    goto <D.36183>;
    <D.36146>:
    D.35752 = klass->name;
    iftmp.456 = __builtin_strcmp ("MonoGenericCMethod", D.35752);
    <D.36183>:
    D.22359 = iftmp.456;
  }
  if (D.22359 == 0) goto <D.36100>; else goto <D.36101>;
  <D.36100>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = obj;
    D.36184 = rmethod->method;
    cinfo = mono_custom_attrs_from_method (D.36184);
  }
  goto <D.36102>;
  <D.36101>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36191 = "ParameterInfo";
      D.36192 = MEM[(const unsigned char *)D.36191];
      D.36193 = (int) D.36192;
      D.36194 = *__s2;
      D.36195 = (int) D.36194;
      __result = D.36193 - D.36195;
      {
        D.36196 = __s1_len != 0;
        D.36197 = __result == 0;
        D.36198 = D.36196 & D.36197;
        if (D.36198 != 0) goto <D.36199>; else goto <D.36200>;
        <D.36199>:
        D.36201 = &MEM[(void *)"ParameterInfo" + 1B];
        D.36202 = *D.36201;
        D.36203 = (int) D.36202;
        D.36204 = __s2 + 1;
        D.36205 = *D.36204;
        D.36206 = (int) D.36205;
        __result = D.36203 - D.36206;
        D.36207 = __s1_len > 1;
        D.36197 = __result == 0;
        D.36208 = D.36207 & D.36197;
        if (D.36208 != 0) goto <D.36209>; else goto <D.36210>;
        <D.36209>:
        D.36211 = &MEM[(void *)"ParameterInfo" + 2B];
        D.36212 = *D.36211;
        D.36213 = (int) D.36212;
        D.36214 = __s2 + 2;
        D.36215 = *D.36214;
        D.36216 = (int) D.36215;
        __result = D.36213 - D.36216;
        D.36217 = __s1_len > 2;
        D.36197 = __result == 0;
        D.36218 = D.36217 & D.36197;
        if (D.36218 != 0) goto <D.36219>; else goto <D.36220>;
        <D.36219>:
        D.36221 = &MEM[(void *)"ParameterInfo" + 3B];
        D.36222 = *D.36221;
        D.36223 = (int) D.36222;
        D.36224 = __s2 + 3;
        D.36225 = *D.36224;
        D.36226 = (int) D.36225;
        __result = D.36223 - D.36226;
        <D.36220>:
        <D.36210>:
        <D.36200>:
      }
      D.22365 = __result;
    }
    iftmp.457 = D.22365;
    goto <D.36227>;
    <D.36190>:
    D.35752 = klass->name;
    iftmp.457 = __builtin_strcmp ("ParameterInfo", D.35752);
    <D.36227>:
    D.22369 = iftmp.457;
  }
  if (D.22369 == 0) goto <D.36185>; else goto <D.36228>;
  <D.36228>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36232 = "MonoParameterInfo";
      D.36233 = MEM[(const unsigned char *)D.36232];
      D.36234 = (int) D.36233;
      D.36235 = *__s2;
      D.36236 = (int) D.36235;
      __result = D.36234 - D.36236;
      {
        D.36237 = __s1_len != 0;
        D.36238 = __result == 0;
        D.36239 = D.36237 & D.36238;
        if (D.36239 != 0) goto <D.36240>; else goto <D.36241>;
        <D.36240>:
        D.36242 = &MEM[(void *)"MonoParameterInfo" + 1B];
        D.36243 = *D.36242;
        D.36244 = (int) D.36243;
        D.36245 = __s2 + 1;
        D.36246 = *D.36245;
        D.36247 = (int) D.36246;
        __result = D.36244 - D.36247;
        D.36248 = __s1_len > 1;
        D.36238 = __result == 0;
        D.36249 = D.36248 & D.36238;
        if (D.36249 != 0) goto <D.36250>; else goto <D.36251>;
        <D.36250>:
        D.36252 = &MEM[(void *)"MonoParameterInfo" + 2B];
        D.36253 = *D.36252;
        D.36254 = (int) D.36253;
        D.36255 = __s2 + 2;
        D.36256 = *D.36255;
        D.36257 = (int) D.36256;
        __result = D.36254 - D.36257;
        D.36258 = __s1_len > 2;
        D.36238 = __result == 0;
        D.36259 = D.36258 & D.36238;
        if (D.36259 != 0) goto <D.36260>; else goto <D.36261>;
        <D.36260>:
        D.36262 = &MEM[(void *)"MonoParameterInfo" + 3B];
        D.36263 = *D.36262;
        D.36264 = (int) D.36263;
        D.36265 = __s2 + 3;
        D.36266 = *D.36265;
        D.36267 = (int) D.36266;
        __result = D.36264 - D.36267;
        <D.36261>:
        <D.36251>:
        <D.36241>:
      }
      D.22374 = __result;
    }
    iftmp.458 = D.22374;
    goto <D.36268>;
    <D.36231>:
    D.35752 = klass->name;
    iftmp.458 = __builtin_strcmp ("MonoParameterInfo", D.35752);
    <D.36268>:
    D.22378 = iftmp.458;
  }
  if (D.22378 == 0) goto <D.36185>; else goto <D.36186>;
  <D.36185>:
  {
    struct MonoReflectionParameter * param;
    struct MonoClass * member_class;

    param = obj;
    D.36269 = param->MemberImpl;
    D.36270 = D.36269->vtable;
    member_class = D.36270->klass;
    D.36271 = mono_class_is_reflection_method_or_constructor (member_class);
    if (D.36271 != 0) goto <D.36272>; else goto <D.36273>;
    <D.36272>:
    {
      struct MonoReflectionMethod * rmethod;

      rmethod = param->MemberImpl;
      D.36274 = param->PositionImpl;
      D.36275 = D.36274 + 1;
      D.36276 = (unsigned int) D.36275;
      D.36277 = rmethod->method;
      cinfo = mono_custom_attrs_from_param (D.36277, D.36276);
    }
    goto <D.36278>;
    <D.36273>:
    D.36279 = is_sr_mono_property (member_class);
    if (D.36279 != 0) goto <D.36280>; else goto <D.36281>;
    <D.36280>:
    {
      struct MonoReflectionProperty * prop;
      struct MonoMethod * method;

      prop = param->MemberImpl;
      D.36282 = prop->property;
      method = D.36282->get;
      if (method == 0B) goto <D.36283>; else goto <D.36284>;
      <D.36283>:
      D.36282 = prop->property;
      method = D.36282->set;
      <D.36284>:
      D.36285 = method == 0B;
      D.36286 = (long int) D.36285;
      D.36287 = __builtin_expect (D.36286, 0);
      if (D.36287 != 0) goto <D.36288>; else goto <D.36289>;
      <D.36288>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8889, "method");
      <D.36289>:
      D.36274 = param->PositionImpl;
      D.36275 = D.36274 + 1;
      D.36276 = (unsigned int) D.36275;
      cinfo = mono_custom_attrs_from_param (method, D.36276);
    }
    goto <D.36290>;
    <D.36281>:
    D.36291 = is_sre_method_on_tb_inst (member_class);
    if (D.36291 != 0) goto <D.36292>; else goto <D.36293>;
    <D.36292>:
    {
      struct MonoMethod * method;

      D.36269 = param->MemberImpl;
      method = mono_reflection_method_on_tb_inst_get_handle (D.36269);
      D.36274 = param->PositionImpl;
      D.36275 = D.36274 + 1;
      D.36276 = (unsigned int) D.36275;
      cinfo = mono_custom_attrs_from_param (method, D.36276);
    }
    goto <D.36294>;
    <D.36293>:
    D.36295 = is_sre_ctor_on_tb_inst (member_class);
    if (D.36295 != 0) goto <D.36296>; else goto <D.36297>;
    <D.36296>:
    {
      struct MonoReflectionCtorOnTypeBuilderInst * c;
      struct MonoMethod * method;

      c = param->MemberImpl;
      method = 0B;
      D.36298 = c->cb;
      D.36299 = D.36298->vtable;
      D.36300 = D.36299->klass;
      D.36301 = is_sre_ctor_builder (D.36300);
      if (D.36301 != 0) goto <D.36302>; else goto <D.36303>;
      <D.36302>:
      D.36298 = c->cb;
      method = MEM[(struct MonoReflectionCtorBuilder *)D.36298].mhandle;
      goto <D.36304>;
      <D.36303>:
      D.36298 = c->cb;
      D.36299 = D.36298->vtable;
      D.36300 = D.36299->klass;
      D.36305 = is_sr_mono_cmethod (D.36300);
      if (D.36305 != 0) goto <D.36306>; else goto <D.36307>;
      <D.36306>:
      D.36298 = c->cb;
      method = MEM[(struct MonoReflectionMethod *)D.36298].method;
      goto <D.36308>;
      <D.36307>:
      D.36309 = 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.36309);
      <D.22387>:
      goto <D.22387>;
      <D.36308>:
      <D.36304>:
      D.36274 = param->PositionImpl;
      D.36275 = D.36274 + 1;
      D.36276 = (unsigned int) D.36275;
      cinfo = mono_custom_attrs_from_param (method, D.36276);
    }
    goto <D.36310>;
    <D.36297>:
    {
      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.36310>:
    <D.36294>:
    <D.36290>:
    <D.36278>:
  }
  goto <D.36187>;
  <D.36186>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 15;
    if (__s1_len <= 3) goto <D.36312>; else goto <D.36313>;
    <D.36312>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = klass->name;
      D.36314 = "AssemblyBuilder";
      D.36315 = MEM[(const unsigned char *)D.36314];
      D.36316 = (int) D.36315;
      D.36317 = *__s2;
      D.36318 = (int) D.36317;
      __result = D.36316 - D.36318;
      {
        D.36319 = __s1_len != 0;
        D.36320 = __result == 0;
        D.36321 = D.36319 & D.36320;
        if (D.36321 != 0) goto <D.36322>; else goto <D.36323>;
        <D.36322>:
        D.36324 = &MEM[(void *)"AssemblyBuilder" + 1B];
        D.36325 = *D.36324;
        D.36326 = (int) D.36325;
        D.36327 = __s2 + 1;
        D.36328 = *D.36327;
        D.36329 = (int) D.36328;
        __result = D.36326 - D.36329;
        D.36330 = __s1_len > 1;
        D.36320 = __result == 0;
        D.36331 = D.36330 & D.36320;
        if (D.36331 != 0) goto <D.36332>; else goto <D.36333>;
        <D.36332>:
        D.36334 = &MEM[(void *)"AssemblyBuilder" + 2B];
        D.36335 = *D.36334;
        D.36336 = (int) D.36335;
        D.36337 = __s2 + 2;
        D.36338 = *D.36337;
        D.36339 = (int) D.36338;
        __result = D.36336 - D.36339;
        D.36340 = __s1_len > 2;
        D.36320 = __result == 0;
        D.36341 = D.36340 & D.36320;
        if (D.36341 != 0) goto <D.36342>; else goto <D.36343>;
        <D.36342>:
        D.36344 = &MEM[(void *)"AssemblyBuilder" + 3B];
        D.36345 = *D.36344;
        D.36346 = (int) D.36345;
        D.36347 = __s2 + 3;
        D.36348 = *D.36347;
        D.36349 = (int) D.36348;
        __result = D.36346 - D.36349;
        <D.36343>:
        <D.36333>:
        <D.36323>:
      }
      D.22395 = __result;
    }
    iftmp.459 = D.22395;
    goto <D.36350>;
    <D.36313>:
    D.35752 = klass->name;
    iftmp.459 = __builtin_strcmp ("AssemblyBuilder", D.35752);
    <D.36350>:
    D.22399 = iftmp.459;
  }
  if (D.22399 == 0) goto <D.36351>; else goto <D.36352>;
  <D.36351>:
  {
    struct MonoReflectionAssemblyBuilder * assemblyb;

    assemblyb = obj;
    D.36353 = assemblyb->cattrs;
    D.36354 = assemblyb->assembly.assembly;
    D.36355 = D.36354->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36355, D.36353);
  }
  goto <D.36356>;
  <D.36352>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36360 = "TypeBuilder";
      D.36361 = MEM[(const unsigned char *)D.36360];
      D.36362 = (int) D.36361;
      D.36363 = *__s2;
      D.36364 = (int) D.36363;
      __result = D.36362 - D.36364;
      {
        D.36365 = __s1_len != 0;
        D.36366 = __result == 0;
        D.36367 = D.36365 & D.36366;
        if (D.36367 != 0) goto <D.36368>; else goto <D.36369>;
        <D.36368>:
        D.36370 = &MEM[(void *)"TypeBuilder" + 1B];
        D.36371 = *D.36370;
        D.36372 = (int) D.36371;
        D.36373 = __s2 + 1;
        D.36374 = *D.36373;
        D.36375 = (int) D.36374;
        __result = D.36372 - D.36375;
        D.36376 = __s1_len > 1;
        D.36366 = __result == 0;
        D.36377 = D.36376 & D.36366;
        if (D.36377 != 0) goto <D.36378>; else goto <D.36379>;
        <D.36378>:
        D.36380 = &MEM[(void *)"TypeBuilder" + 2B];
        D.36381 = *D.36380;
        D.36382 = (int) D.36381;
        D.36383 = __s2 + 2;
        D.36384 = *D.36383;
        D.36385 = (int) D.36384;
        __result = D.36382 - D.36385;
        D.36386 = __s1_len > 2;
        D.36366 = __result == 0;
        D.36387 = D.36386 & D.36366;
        if (D.36387 != 0) goto <D.36388>; else goto <D.36389>;
        <D.36388>:
        D.36390 = &MEM[(void *)"TypeBuilder" + 3B];
        D.36391 = *D.36390;
        D.36392 = (int) D.36391;
        D.36393 = __s2 + 3;
        D.36394 = *D.36393;
        D.36395 = (int) D.36394;
        __result = D.36392 - D.36395;
        <D.36389>:
        <D.36379>:
        <D.36369>:
      }
      D.22405 = __result;
    }
    iftmp.460 = D.22405;
    goto <D.36396>;
    <D.36359>:
    D.35752 = klass->name;
    iftmp.460 = __builtin_strcmp ("TypeBuilder", D.35752);
    <D.36396>:
    D.22409 = iftmp.460;
  }
  if (D.22409 == 0) goto <D.36397>; else goto <D.36398>;
  <D.36397>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = obj;
    D.36399 = tb->cattrs;
    D.36400 = tb->module;
    D.36401 = D.36400->dynamic_image;
    D.36402 = &D.36401->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36402, D.36399);
  }
  goto <D.36403>;
  <D.36398>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36407 = "ModuleBuilder";
      D.36408 = MEM[(const unsigned char *)D.36407];
      D.36409 = (int) D.36408;
      D.36410 = *__s2;
      D.36411 = (int) D.36410;
      __result = D.36409 - D.36411;
      {
        D.36412 = __s1_len != 0;
        D.36413 = __result == 0;
        D.36414 = D.36412 & D.36413;
        if (D.36414 != 0) goto <D.36415>; else goto <D.36416>;
        <D.36415>:
        D.36417 = &MEM[(void *)"ModuleBuilder" + 1B];
        D.36418 = *D.36417;
        D.36419 = (int) D.36418;
        D.36420 = __s2 + 1;
        D.36421 = *D.36420;
        D.36422 = (int) D.36421;
        __result = D.36419 - D.36422;
        D.36423 = __s1_len > 1;
        D.36413 = __result == 0;
        D.36424 = D.36423 & D.36413;
        if (D.36424 != 0) goto <D.36425>; else goto <D.36426>;
        <D.36425>:
        D.36427 = &MEM[(void *)"ModuleBuilder" + 2B];
        D.36428 = *D.36427;
        D.36429 = (int) D.36428;
        D.36430 = __s2 + 2;
        D.36431 = *D.36430;
        D.36432 = (int) D.36431;
        __result = D.36429 - D.36432;
        D.36433 = __s1_len > 2;
        D.36413 = __result == 0;
        D.36434 = D.36433 & D.36413;
        if (D.36434 != 0) goto <D.36435>; else goto <D.36436>;
        <D.36435>:
        D.36437 = &MEM[(void *)"ModuleBuilder" + 3B];
        D.36438 = *D.36437;
        D.36439 = (int) D.36438;
        D.36440 = __s2 + 3;
        D.36441 = *D.36440;
        D.36442 = (int) D.36441;
        __result = D.36439 - D.36442;
        <D.36436>:
        <D.36426>:
        <D.36416>:
      }
      D.22415 = __result;
    }
    iftmp.461 = D.22415;
    goto <D.36443>;
    <D.36406>:
    D.35752 = klass->name;
    iftmp.461 = __builtin_strcmp ("ModuleBuilder", D.35752);
    <D.36443>:
    D.22419 = iftmp.461;
  }
  if (D.22419 == 0) goto <D.36444>; else goto <D.36445>;
  <D.36444>:
  {
    struct MonoReflectionModuleBuilder * mb;

    mb = obj;
    D.36446 = mb->cattrs;
    D.36447 = mb->dynamic_image;
    D.36448 = &D.36447->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36448, D.36446);
  }
  goto <D.36449>;
  <D.36445>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36453 = "ConstructorBuilder";
      D.36454 = MEM[(const unsigned char *)D.36453];
      D.36455 = (int) D.36454;
      D.36456 = *__s2;
      D.36457 = (int) D.36456;
      __result = D.36455 - D.36457;
      {
        D.36458 = __s1_len != 0;
        D.36459 = __result == 0;
        D.36460 = D.36458 & D.36459;
        if (D.36460 != 0) goto <D.36461>; else goto <D.36462>;
        <D.36461>:
        D.36463 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.36464 = *D.36463;
        D.36465 = (int) D.36464;
        D.36466 = __s2 + 1;
        D.36467 = *D.36466;
        D.36468 = (int) D.36467;
        __result = D.36465 - D.36468;
        D.36469 = __s1_len > 1;
        D.36459 = __result == 0;
        D.36470 = D.36469 & D.36459;
        if (D.36470 != 0) goto <D.36471>; else goto <D.36472>;
        <D.36471>:
        D.36473 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.36474 = *D.36473;
        D.36475 = (int) D.36474;
        D.36476 = __s2 + 2;
        D.36477 = *D.36476;
        D.36478 = (int) D.36477;
        __result = D.36475 - D.36478;
        D.36479 = __s1_len > 2;
        D.36459 = __result == 0;
        D.36480 = D.36479 & D.36459;
        if (D.36480 != 0) goto <D.36481>; else goto <D.36482>;
        <D.36481>:
        D.36483 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.36484 = *D.36483;
        D.36485 = (int) D.36484;
        D.36486 = __s2 + 3;
        D.36487 = *D.36486;
        D.36488 = (int) D.36487;
        __result = D.36485 - D.36488;
        <D.36482>:
        <D.36472>:
        <D.36462>:
      }
      D.22425 = __result;
    }
    iftmp.462 = D.22425;
    goto <D.36489>;
    <D.36452>:
    D.35752 = klass->name;
    iftmp.462 = __builtin_strcmp ("ConstructorBuilder", D.35752);
    <D.36489>:
    D.22429 = iftmp.462;
  }
  if (D.22429 == 0) goto <D.36490>; else goto <D.36491>;
  <D.36490>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    D.36492 = cb->cattrs;
    D.36493 = cb->mhandle;
    D.36494 = D.36493->klass;
    D.36495 = D.36494->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36495, D.36492);
  }
  goto <D.36496>;
  <D.36491>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36500 = "MethodBuilder";
      D.36501 = MEM[(const unsigned char *)D.36500];
      D.36502 = (int) D.36501;
      D.36503 = *__s2;
      D.36504 = (int) D.36503;
      __result = D.36502 - D.36504;
      {
        D.36505 = __s1_len != 0;
        D.36506 = __result == 0;
        D.36507 = D.36505 & D.36506;
        if (D.36507 != 0) goto <D.36508>; else goto <D.36509>;
        <D.36508>:
        D.36510 = &MEM[(void *)"MethodBuilder" + 1B];
        D.36511 = *D.36510;
        D.36512 = (int) D.36511;
        D.36513 = __s2 + 1;
        D.36514 = *D.36513;
        D.36515 = (int) D.36514;
        __result = D.36512 - D.36515;
        D.36516 = __s1_len > 1;
        D.36506 = __result == 0;
        D.36517 = D.36516 & D.36506;
        if (D.36517 != 0) goto <D.36518>; else goto <D.36519>;
        <D.36518>:
        D.36520 = &MEM[(void *)"MethodBuilder" + 2B];
        D.36521 = *D.36520;
        D.36522 = (int) D.36521;
        D.36523 = __s2 + 2;
        D.36524 = *D.36523;
        D.36525 = (int) D.36524;
        __result = D.36522 - D.36525;
        D.36526 = __s1_len > 2;
        D.36506 = __result == 0;
        D.36527 = D.36526 & D.36506;
        if (D.36527 != 0) goto <D.36528>; else goto <D.36529>;
        <D.36528>:
        D.36530 = &MEM[(void *)"MethodBuilder" + 3B];
        D.36531 = *D.36530;
        D.36532 = (int) D.36531;
        D.36533 = __s2 + 3;
        D.36534 = *D.36533;
        D.36535 = (int) D.36534;
        __result = D.36532 - D.36535;
        <D.36529>:
        <D.36519>:
        <D.36509>:
      }
      D.22435 = __result;
    }
    iftmp.463 = D.22435;
    goto <D.36536>;
    <D.36499>:
    D.35752 = klass->name;
    iftmp.463 = __builtin_strcmp ("MethodBuilder", D.35752);
    <D.36536>:
    D.22439 = iftmp.463;
  }
  if (D.22439 == 0) goto <D.36537>; else goto <D.36538>;
  <D.36537>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    D.36539 = mb->cattrs;
    D.36540 = mb->mhandle;
    D.36541 = D.36540->klass;
    D.36542 = D.36541->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36542, D.36539);
  }
  goto <D.36543>;
  <D.36538>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36547 = "FieldBuilder";
      D.36548 = MEM[(const unsigned char *)D.36547];
      D.36549 = (int) D.36548;
      D.36550 = *__s2;
      D.36551 = (int) D.36550;
      __result = D.36549 - D.36551;
      {
        D.36552 = __s1_len != 0;
        D.36553 = __result == 0;
        D.36554 = D.36552 & D.36553;
        if (D.36554 != 0) goto <D.36555>; else goto <D.36556>;
        <D.36555>:
        D.36557 = &MEM[(void *)"FieldBuilder" + 1B];
        D.36558 = *D.36557;
        D.36559 = (int) D.36558;
        D.36560 = __s2 + 1;
        D.36561 = *D.36560;
        D.36562 = (int) D.36561;
        __result = D.36559 - D.36562;
        D.36563 = __s1_len > 1;
        D.36553 = __result == 0;
        D.36564 = D.36563 & D.36553;
        if (D.36564 != 0) goto <D.36565>; else goto <D.36566>;
        <D.36565>:
        D.36567 = &MEM[(void *)"FieldBuilder" + 2B];
        D.36568 = *D.36567;
        D.36569 = (int) D.36568;
        D.36570 = __s2 + 2;
        D.36571 = *D.36570;
        D.36572 = (int) D.36571;
        __result = D.36569 - D.36572;
        D.36573 = __s1_len > 2;
        D.36553 = __result == 0;
        D.36574 = D.36573 & D.36553;
        if (D.36574 != 0) goto <D.36575>; else goto <D.36576>;
        <D.36575>:
        D.36577 = &MEM[(void *)"FieldBuilder" + 3B];
        D.36578 = *D.36577;
        D.36579 = (int) D.36578;
        D.36580 = __s2 + 3;
        D.36581 = *D.36580;
        D.36582 = (int) D.36581;
        __result = D.36579 - D.36582;
        <D.36576>:
        <D.36566>:
        <D.36556>:
      }
      D.22445 = __result;
    }
    iftmp.464 = D.22445;
    goto <D.36583>;
    <D.36546>:
    D.35752 = klass->name;
    iftmp.464 = __builtin_strcmp ("FieldBuilder", D.35752);
    <D.36583>:
    D.22449 = iftmp.464;
  }
  if (D.22449 == 0) goto <D.36584>; else goto <D.36585>;
  <D.36584>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    D.36586 = fb->cattrs;
    D.36587 = fb->typeb;
    D.36588 = MEM[(struct MonoReflectionTypeBuilder *)D.36587].module;
    D.36589 = D.36588->dynamic_image;
    D.36590 = &D.36589->image;
    cinfo = mono_custom_attrs_from_builders (0B, D.36590, D.36586);
  }
  goto <D.36591>;
  <D.36585>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.36595 = "MonoGenericClass";
      D.36596 = MEM[(const unsigned char *)D.36595];
      D.36597 = (int) D.36596;
      D.36598 = *__s2;
      D.36599 = (int) D.36598;
      __result = D.36597 - D.36599;
      {
        D.36600 = __s1_len != 0;
        D.36601 = __result == 0;
        D.36602 = D.36600 & D.36601;
        if (D.36602 != 0) goto <D.36603>; else goto <D.36604>;
        <D.36603>:
        D.36605 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.36606 = *D.36605;
        D.36607 = (int) D.36606;
        D.36608 = __s2 + 1;
        D.36609 = *D.36608;
        D.36610 = (int) D.36609;
        __result = D.36607 - D.36610;
        D.36611 = __s1_len > 1;
        D.36601 = __result == 0;
        D.36612 = D.36611 & D.36601;
        if (D.36612 != 0) goto <D.36613>; else goto <D.36614>;
        <D.36613>:
        D.36615 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.36616 = *D.36615;
        D.36617 = (int) D.36616;
        D.36618 = __s2 + 2;
        D.36619 = *D.36618;
        D.36620 = (int) D.36619;
        __result = D.36617 - D.36620;
        D.36621 = __s1_len > 2;
        D.36601 = __result == 0;
        D.36622 = D.36621 & D.36601;
        if (D.36622 != 0) goto <D.36623>; else goto <D.36624>;
        <D.36623>:
        D.36625 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.36626 = *D.36625;
        D.36627 = (int) D.36626;
        D.36628 = __s2 + 3;
        D.36629 = *D.36628;
        D.36630 = (int) D.36629;
        __result = D.36627 - D.36630;
        <D.36624>:
        <D.36614>:
        <D.36604>:
      }
      D.22455 = __result;
    }
    iftmp.465 = D.22455;
    goto <D.36631>;
    <D.36594>:
    D.35752 = klass->name;
    iftmp.465 = __builtin_strcmp ("MonoGenericClass", D.35752);
    <D.36631>:
    D.22459 = iftmp.465;
  }
  if (D.22459 == 0) goto <D.36632>; else goto <D.36633>;
  <D.36632>:
  {
    struct MonoReflectionGenericClass * gclass;

    gclass = obj;
    D.36634 = gclass->generic_type;
    cinfo = mono_reflection_get_custom_attrs_info (D.36634);
  }
  goto <D.36635>;
  <D.36633>:
  D.35752 = klass->name;
  monoeg_g_log (0B, 4, "get custom attrs not yet supported for %s", D.35752);
  <D.22461>:
  goto <D.22461>;
  <D.36635>:
  <D.36591>:
  <D.36543>:
  <D.36496>:
  <D.36449>:
  <D.36403>:
  <D.36356>:
  <D.36187>:
  <D.36102>:
  <D.36017>:
  <D.36014>:
  <D.35969>:
  <D.35924>:
  <D.35797>:
  <D.35711>:
  <D.35708>:
  D.36636 = cinfo;
  return D.36636;
}


mono_custom_attrs_from_module (struct MonoImage * image)
{
  unsigned char D.36638;
  unsigned char D.36639;
  struct MonoCustomAttrInfo * D.36642;
  guint32 idx;

  D.36638 = BIT_FIELD_REF <*image, 8, 224>;
  D.36639 = D.36638 & 8;
  if (D.36639 != 0) goto <D.36640>; else goto <D.36641>;
  <D.36640>:
  D.36642 = lookup_custom_attr (image, image);
  return D.36642;
  <D.36641>:
  idx = 1;
  idx = idx << 5;
  idx = idx | 7;
  D.36642 = mono_custom_attrs_from_index (image, idx);
  return D.36642;
}


is_sr_mono_property (struct MonoClass * class)
{
  struct MonoClass * cached_class.466;
  gboolean D.36647;
  _Bool D.36648;
  int D.36649;
  int D.22834;
  int iftmp.467;
  int D.22830;
  const char[13] * D.36655;
  unsigned char D.36656;
  int D.36657;
  unsigned char D.36658;
  int D.36659;
  _Bool D.36660;
  _Bool D.36661;
  _Bool D.36662;
  const unsigned char * D.36665;
  unsigned char D.36666;
  int D.36667;
  const unsigned char * D.36668;
  unsigned char D.36669;
  int D.36670;
  _Bool D.36671;
  _Bool D.36672;
  const unsigned char * D.36675;
  unsigned char D.36676;
  int D.36677;
  const unsigned char * D.36678;
  unsigned char D.36679;
  int D.36680;
  _Bool D.36681;
  _Bool D.36682;
  const unsigned char * D.36685;
  unsigned char D.36686;
  int D.36687;
  const unsigned char * D.36688;
  unsigned char D.36689;
  int D.36690;
  const char * D.36692;
  int D.22843;
  int iftmp.468;
  int D.22839;
  const char[18] * D.36698;
  unsigned char D.36699;
  int D.36700;
  unsigned char D.36701;
  int D.36702;
  _Bool D.36703;
  _Bool D.36704;
  _Bool D.36705;
  const unsigned char * D.36708;
  unsigned char D.36709;
  int D.36710;
  const unsigned char * D.36711;
  unsigned char D.36712;
  int D.36713;
  _Bool D.36714;
  _Bool D.36715;
  const unsigned char * D.36718;
  unsigned char D.36719;
  int D.36720;
  const unsigned char * D.36721;
  unsigned char D.36722;
  int D.36723;
  _Bool D.36724;
  _Bool D.36725;
  const unsigned char * D.36728;
  unsigned char D.36729;
  int D.36730;
  const unsigned char * D.36731;
  unsigned char D.36732;
  int D.36733;
  const char * D.36735;

  {
    static struct MonoClass * cached_class;

    cached_class.466 = cached_class;
    if (cached_class.466 != 0B) goto <D.36645>; else goto <D.36646>;
    <D.36645>:
    cached_class.466 = cached_class;
    D.36648 = cached_class.466 == class;
    D.36647 = (gboolean) D.36648;
    return D.36647;
    <D.36646>:
    D.36649 = is_corlib_type (class);
    if (D.36649 != 0) goto <D.36650>; else goto <D.36651>;
    <D.36650>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.36655 = "MonoProperty";
        D.36656 = MEM[(const unsigned char *)D.36655];
        D.36657 = (int) D.36656;
        D.36658 = *__s2;
        D.36659 = (int) D.36658;
        __result = D.36657 - D.36659;
        {
          D.36660 = __s1_len != 0;
          D.36661 = __result == 0;
          D.36662 = D.36660 & D.36661;
          if (D.36662 != 0) goto <D.36663>; else goto <D.36664>;
          <D.36663>:
          D.36665 = &MEM[(void *)"MonoProperty" + 1B];
          D.36666 = *D.36665;
          D.36667 = (int) D.36666;
          D.36668 = __s2 + 1;
          D.36669 = *D.36668;
          D.36670 = (int) D.36669;
          __result = D.36667 - D.36670;
          D.36671 = __s1_len > 1;
          D.36661 = __result == 0;
          D.36672 = D.36671 & D.36661;
          if (D.36672 != 0) goto <D.36673>; else goto <D.36674>;
          <D.36673>:
          D.36675 = &MEM[(void *)"MonoProperty" + 2B];
          D.36676 = *D.36675;
          D.36677 = (int) D.36676;
          D.36678 = __s2 + 2;
          D.36679 = *D.36678;
          D.36680 = (int) D.36679;
          __result = D.36677 - D.36680;
          D.36681 = __s1_len > 2;
          D.36661 = __result == 0;
          D.36682 = D.36681 & D.36661;
          if (D.36682 != 0) goto <D.36683>; else goto <D.36684>;
          <D.36683>:
          D.36685 = &MEM[(void *)"MonoProperty" + 3B];
          D.36686 = *D.36685;
          D.36687 = (int) D.36686;
          D.36688 = __s2 + 3;
          D.36689 = *D.36688;
          D.36690 = (int) D.36689;
          __result = D.36687 - D.36690;
          <D.36684>:
          <D.36674>:
          <D.36664>:
        }
        D.22830 = __result;
      }
      iftmp.467 = D.22830;
      goto <D.36691>;
      <D.36654>:
      D.36692 = class->name;
      iftmp.467 = __builtin_strcmp ("MonoProperty", D.36692);
      <D.36691>:
      D.22834 = iftmp.467;
    }
    if (D.22834 == 0) goto <D.36693>; else goto <D.36694>;
    <D.36693>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36698 = "System.Reflection";
        D.36699 = MEM[(const unsigned char *)D.36698];
        D.36700 = (int) D.36699;
        D.36701 = *__s2;
        D.36702 = (int) D.36701;
        __result = D.36700 - D.36702;
        {
          D.36703 = __s1_len != 0;
          D.36704 = __result == 0;
          D.36705 = D.36703 & D.36704;
          if (D.36705 != 0) goto <D.36706>; else goto <D.36707>;
          <D.36706>:
          D.36708 = &MEM[(void *)"System.Reflection" + 1B];
          D.36709 = *D.36708;
          D.36710 = (int) D.36709;
          D.36711 = __s2 + 1;
          D.36712 = *D.36711;
          D.36713 = (int) D.36712;
          __result = D.36710 - D.36713;
          D.36714 = __s1_len > 1;
          D.36704 = __result == 0;
          D.36715 = D.36714 & D.36704;
          if (D.36715 != 0) goto <D.36716>; else goto <D.36717>;
          <D.36716>:
          D.36718 = &MEM[(void *)"System.Reflection" + 2B];
          D.36719 = *D.36718;
          D.36720 = (int) D.36719;
          D.36721 = __s2 + 2;
          D.36722 = *D.36721;
          D.36723 = (int) D.36722;
          __result = D.36720 - D.36723;
          D.36724 = __s1_len > 2;
          D.36704 = __result == 0;
          D.36725 = D.36724 & D.36704;
          if (D.36725 != 0) goto <D.36726>; else goto <D.36727>;
          <D.36726>:
          D.36728 = &MEM[(void *)"System.Reflection" + 3B];
          D.36729 = *D.36728;
          D.36730 = (int) D.36729;
          D.36731 = __s2 + 3;
          D.36732 = *D.36731;
          D.36733 = (int) D.36732;
          __result = D.36730 - D.36733;
          <D.36727>:
          <D.36717>:
          <D.36707>:
        }
        D.22839 = __result;
      }
      iftmp.468 = D.22839;
      goto <D.36734>;
      <D.36697>:
      D.36735 = class->name_space;
      iftmp.468 = __builtin_strcmp ("System.Reflection", D.36735);
      <D.36734>:
      D.22843 = iftmp.468;
    }
    if (D.22843 == 0) goto <D.36736>; else goto <D.36737>;
    <D.36736>:
    cached_class = class;
    D.36647 = 1;
    return D.36647;
    <D.36737>:
    <D.36694>:
    <D.36651>:
    D.36647 = 0;
    return D.36647;
  }
}


is_sre_method_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.469;
  gboolean D.36742;
  _Bool D.36743;
  int D.36744;
  int D.22676;
  int iftmp.470;
  int D.22672;
  const char[24] * D.36750;
  unsigned char D.36751;
  int D.36752;
  unsigned char D.36753;
  int D.36754;
  _Bool D.36755;
  _Bool D.36756;
  _Bool D.36757;
  const unsigned char * D.36760;
  unsigned char D.36761;
  int D.36762;
  const unsigned char * D.36763;
  unsigned char D.36764;
  int D.36765;
  _Bool D.36766;
  _Bool D.36767;
  const unsigned char * D.36770;
  unsigned char D.36771;
  int D.36772;
  const unsigned char * D.36773;
  unsigned char D.36774;
  int D.36775;
  _Bool D.36776;
  _Bool D.36777;
  const unsigned char * D.36780;
  unsigned char D.36781;
  int D.36782;
  const unsigned char * D.36783;
  unsigned char D.36784;
  int D.36785;
  const char * D.36787;
  int D.22685;
  int iftmp.471;
  int D.22681;
  const char[23] * D.36793;
  unsigned char D.36794;
  int D.36795;
  unsigned char D.36796;
  int D.36797;
  _Bool D.36798;
  _Bool D.36799;
  _Bool D.36800;
  const unsigned char * D.36803;
  unsigned char D.36804;
  int D.36805;
  const unsigned char * D.36806;
  unsigned char D.36807;
  int D.36808;
  _Bool D.36809;
  _Bool D.36810;
  const unsigned char * D.36813;
  unsigned char D.36814;
  int D.36815;
  const unsigned char * D.36816;
  unsigned char D.36817;
  int D.36818;
  _Bool D.36819;
  _Bool D.36820;
  const unsigned char * D.36823;
  unsigned char D.36824;
  int D.36825;
  const unsigned char * D.36826;
  unsigned char D.36827;
  int D.36828;
  const char * D.36830;

  {
    static struct MonoClass * cached_class;

    cached_class.469 = cached_class;
    if (cached_class.469 != 0B) goto <D.36740>; else goto <D.36741>;
    <D.36740>:
    cached_class.469 = cached_class;
    D.36743 = cached_class.469 == class;
    D.36742 = (gboolean) D.36743;
    return D.36742;
    <D.36741>:
    D.36744 = is_corlib_type (class);
    if (D.36744 != 0) goto <D.36745>; else goto <D.36746>;
    <D.36745>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 23;
      if (__s1_len <= 3) goto <D.36748>; else goto <D.36749>;
      <D.36748>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36750 = "MethodOnTypeBuilderInst";
        D.36751 = MEM[(const unsigned char *)D.36750];
        D.36752 = (int) D.36751;
        D.36753 = *__s2;
        D.36754 = (int) D.36753;
        __result = D.36752 - D.36754;
        {
          D.36755 = __s1_len != 0;
          D.36756 = __result == 0;
          D.36757 = D.36755 & D.36756;
          if (D.36757 != 0) goto <D.36758>; else goto <D.36759>;
          <D.36758>:
          D.36760 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
          D.36761 = *D.36760;
          D.36762 = (int) D.36761;
          D.36763 = __s2 + 1;
          D.36764 = *D.36763;
          D.36765 = (int) D.36764;
          __result = D.36762 - D.36765;
          D.36766 = __s1_len > 1;
          D.36756 = __result == 0;
          D.36767 = D.36766 & D.36756;
          if (D.36767 != 0) goto <D.36768>; else goto <D.36769>;
          <D.36768>:
          D.36770 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
          D.36771 = *D.36770;
          D.36772 = (int) D.36771;
          D.36773 = __s2 + 2;
          D.36774 = *D.36773;
          D.36775 = (int) D.36774;
          __result = D.36772 - D.36775;
          D.36776 = __s1_len > 2;
          D.36756 = __result == 0;
          D.36777 = D.36776 & D.36756;
          if (D.36777 != 0) goto <D.36778>; else goto <D.36779>;
          <D.36778>:
          D.36780 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
          D.36781 = *D.36780;
          D.36782 = (int) D.36781;
          D.36783 = __s2 + 3;
          D.36784 = *D.36783;
          D.36785 = (int) D.36784;
          __result = D.36782 - D.36785;
          <D.36779>:
          <D.36769>:
          <D.36759>:
        }
        D.22672 = __result;
      }
      iftmp.470 = D.22672;
      goto <D.36786>;
      <D.36749>:
      D.36787 = class->name;
      iftmp.470 = __builtin_strcmp ("MethodOnTypeBuilderInst", D.36787);
      <D.36786>:
      D.22676 = iftmp.470;
    }
    if (D.22676 == 0) goto <D.36788>; else goto <D.36789>;
    <D.36788>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36793 = "System.Reflection.Emit";
        D.36794 = MEM[(const unsigned char *)D.36793];
        D.36795 = (int) D.36794;
        D.36796 = *__s2;
        D.36797 = (int) D.36796;
        __result = D.36795 - D.36797;
        {
          D.36798 = __s1_len != 0;
          D.36799 = __result == 0;
          D.36800 = D.36798 & D.36799;
          if (D.36800 != 0) goto <D.36801>; else goto <D.36802>;
          <D.36801>:
          D.36803 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.36804 = *D.36803;
          D.36805 = (int) D.36804;
          D.36806 = __s2 + 1;
          D.36807 = *D.36806;
          D.36808 = (int) D.36807;
          __result = D.36805 - D.36808;
          D.36809 = __s1_len > 1;
          D.36799 = __result == 0;
          D.36810 = D.36809 & D.36799;
          if (D.36810 != 0) goto <D.36811>; else goto <D.36812>;
          <D.36811>:
          D.36813 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.36814 = *D.36813;
          D.36815 = (int) D.36814;
          D.36816 = __s2 + 2;
          D.36817 = *D.36816;
          D.36818 = (int) D.36817;
          __result = D.36815 - D.36818;
          D.36819 = __s1_len > 2;
          D.36799 = __result == 0;
          D.36820 = D.36819 & D.36799;
          if (D.36820 != 0) goto <D.36821>; else goto <D.36822>;
          <D.36821>:
          D.36823 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.36824 = *D.36823;
          D.36825 = (int) D.36824;
          D.36826 = __s2 + 3;
          D.36827 = *D.36826;
          D.36828 = (int) D.36827;
          __result = D.36825 - D.36828;
          <D.36822>:
          <D.36812>:
          <D.36802>:
        }
        D.22681 = __result;
      }
      iftmp.471 = D.22681;
      goto <D.36829>;
      <D.36792>:
      D.36830 = class->name_space;
      iftmp.471 = __builtin_strcmp ("System.Reflection.Emit", D.36830);
      <D.36829>:
      D.22685 = iftmp.471;
    }
    if (D.22685 == 0) goto <D.36831>; else goto <D.36832>;
    <D.36831>:
    cached_class = class;
    D.36742 = 1;
    return D.36742;
    <D.36832>:
    <D.36789>:
    <D.36746>:
    D.36742 = 0;
    return D.36742;
  }
}


is_sre_ctor_on_tb_inst (struct MonoClass * class)
{
  struct MonoClass * cached_class.472;
  gboolean D.36837;
  _Bool D.36838;
  int D.36839;
  int D.22698;
  int iftmp.473;
  int D.22694;
  const char[29] * D.36845;
  unsigned char D.36846;
  int D.36847;
  unsigned char D.36848;
  int D.36849;
  _Bool D.36850;
  _Bool D.36851;
  _Bool D.36852;
  const unsigned char * D.36855;
  unsigned char D.36856;
  int D.36857;
  const unsigned char * D.36858;
  unsigned char D.36859;
  int D.36860;
  _Bool D.36861;
  _Bool D.36862;
  const unsigned char * D.36865;
  unsigned char D.36866;
  int D.36867;
  const unsigned char * D.36868;
  unsigned char D.36869;
  int D.36870;
  _Bool D.36871;
  _Bool D.36872;
  const unsigned char * D.36875;
  unsigned char D.36876;
  int D.36877;
  const unsigned char * D.36878;
  unsigned char D.36879;
  int D.36880;
  const char * D.36882;
  int D.22707;
  int iftmp.474;
  int D.22703;
  const char[23] * D.36888;
  unsigned char D.36889;
  int D.36890;
  unsigned char D.36891;
  int D.36892;
  _Bool D.36893;
  _Bool D.36894;
  _Bool D.36895;
  const unsigned char * D.36898;
  unsigned char D.36899;
  int D.36900;
  const unsigned char * D.36901;
  unsigned char D.36902;
  int D.36903;
  _Bool D.36904;
  _Bool D.36905;
  const unsigned char * D.36908;
  unsigned char D.36909;
  int D.36910;
  const unsigned char * D.36911;
  unsigned char D.36912;
  int D.36913;
  _Bool D.36914;
  _Bool D.36915;
  const unsigned char * D.36918;
  unsigned char D.36919;
  int D.36920;
  const unsigned char * D.36921;
  unsigned char D.36922;
  int D.36923;
  const char * D.36925;

  {
    static struct MonoClass * cached_class;

    cached_class.472 = cached_class;
    if (cached_class.472 != 0B) goto <D.36835>; else goto <D.36836>;
    <D.36835>:
    cached_class.472 = cached_class;
    D.36838 = cached_class.472 == class;
    D.36837 = (gboolean) D.36838;
    return D.36837;
    <D.36836>:
    D.36839 = is_corlib_type (class);
    if (D.36839 != 0) goto <D.36840>; else goto <D.36841>;
    <D.36840>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 28;
      if (__s1_len <= 3) goto <D.36843>; else goto <D.36844>;
      <D.36843>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = class->name;
        D.36845 = "ConstructorOnTypeBuilderInst";
        D.36846 = MEM[(const unsigned char *)D.36845];
        D.36847 = (int) D.36846;
        D.36848 = *__s2;
        D.36849 = (int) D.36848;
        __result = D.36847 - D.36849;
        {
          D.36850 = __s1_len != 0;
          D.36851 = __result == 0;
          D.36852 = D.36850 & D.36851;
          if (D.36852 != 0) goto <D.36853>; else goto <D.36854>;
          <D.36853>:
          D.36855 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
          D.36856 = *D.36855;
          D.36857 = (int) D.36856;
          D.36858 = __s2 + 1;
          D.36859 = *D.36858;
          D.36860 = (int) D.36859;
          __result = D.36857 - D.36860;
          D.36861 = __s1_len > 1;
          D.36851 = __result == 0;
          D.36862 = D.36861 & D.36851;
          if (D.36862 != 0) goto <D.36863>; else goto <D.36864>;
          <D.36863>:
          D.36865 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
          D.36866 = *D.36865;
          D.36867 = (int) D.36866;
          D.36868 = __s2 + 2;
          D.36869 = *D.36868;
          D.36870 = (int) D.36869;
          __result = D.36867 - D.36870;
          D.36871 = __s1_len > 2;
          D.36851 = __result == 0;
          D.36872 = D.36871 & D.36851;
          if (D.36872 != 0) goto <D.36873>; else goto <D.36874>;
          <D.36873>:
          D.36875 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
          D.36876 = *D.36875;
          D.36877 = (int) D.36876;
          D.36878 = __s2 + 3;
          D.36879 = *D.36878;
          D.36880 = (int) D.36879;
          __result = D.36877 - D.36880;
          <D.36874>:
          <D.36864>:
          <D.36854>:
        }
        D.22694 = __result;
      }
      iftmp.473 = D.22694;
      goto <D.36881>;
      <D.36844>:
      D.36882 = class->name;
      iftmp.473 = __builtin_strcmp ("ConstructorOnTypeBuilderInst", D.36882);
      <D.36881>:
      D.22698 = iftmp.473;
    }
    if (D.22698 == 0) goto <D.36883>; else goto <D.36884>;
    <D.36883>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.36888 = "System.Reflection.Emit";
        D.36889 = MEM[(const unsigned char *)D.36888];
        D.36890 = (int) D.36889;
        D.36891 = *__s2;
        D.36892 = (int) D.36891;
        __result = D.36890 - D.36892;
        {
          D.36893 = __s1_len != 0;
          D.36894 = __result == 0;
          D.36895 = D.36893 & D.36894;
          if (D.36895 != 0) goto <D.36896>; else goto <D.36897>;
          <D.36896>:
          D.36898 = &MEM[(void *)"System.Reflection.Emit" + 1B];
          D.36899 = *D.36898;
          D.36900 = (int) D.36899;
          D.36901 = __s2 + 1;
          D.36902 = *D.36901;
          D.36903 = (int) D.36902;
          __result = D.36900 - D.36903;
          D.36904 = __s1_len > 1;
          D.36894 = __result == 0;
          D.36905 = D.36904 & D.36894;
          if (D.36905 != 0) goto <D.36906>; else goto <D.36907>;
          <D.36906>:
          D.36908 = &MEM[(void *)"System.Reflection.Emit" + 2B];
          D.36909 = *D.36908;
          D.36910 = (int) D.36909;
          D.36911 = __s2 + 2;
          D.36912 = *D.36911;
          D.36913 = (int) D.36912;
          __result = D.36910 - D.36913;
          D.36914 = __s1_len > 2;
          D.36894 = __result == 0;
          D.36915 = D.36914 & D.36894;
          if (D.36915 != 0) goto <D.36916>; else goto <D.36917>;
          <D.36916>:
          D.36918 = &MEM[(void *)"System.Reflection.Emit" + 3B];
          D.36919 = *D.36918;
          D.36920 = (int) D.36919;
          D.36921 = __s2 + 3;
          D.36922 = *D.36921;
          D.36923 = (int) D.36922;
          __result = D.36920 - D.36923;
          <D.36917>:
          <D.36907>:
          <D.36897>:
        }
        D.22703 = __result;
      }
      iftmp.474 = D.22703;
      goto <D.36924>;
      <D.36887>:
      D.36925 = class->name_space;
      iftmp.474 = __builtin_strcmp ("System.Reflection.Emit", D.36925);
      <D.36924>:
      D.22707 = iftmp.474;
    }
    if (D.22707 == 0) goto <D.36926>; else goto <D.36927>;
    <D.36926>:
    cached_class = class;
    D.36837 = 1;
    return D.36837;
    <D.36927>:
    <D.36884>:
    <D.36841>:
    D.36837 = 0;
    return D.36837;
  }
}


mono_reflection_get_custom_attrs_by_type (struct MonoObject * obj, struct MonoClass * attr_klass, struct MonoError * error)
{
  int D.36931;
  struct MonoLoaderError * D.36935;
  struct MonoArray * D.36938;
  struct MonoClass * D.22470;
  struct MonoClass * tmp_klass.475;
  struct MonoClass * D.36942;
  struct MonoClass * tmp_klass.476;
  _Bool D.36944;
  long int D.36945;
  long int D.36946;
  struct MonoDomain * D.36949;
  struct MonoVTable * D.36950;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  mono_error_init (error);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36929>; else goto <D.36930>;
  <D.36929>:
  result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
  D.36931 = cinfo->cached;
  if (D.36931 == 0) goto <D.36932>; else goto <D.36933>;
  <D.36932>:
  mono_custom_attrs_free (cinfo);
  <D.36933>:
  goto <D.36934>;
  <D.36930>:
  D.36935 = mono_loader_get_last_error ();
  if (D.36935 != 0B) goto <D.36936>; else goto <D.36937>;
  <D.36936>:
  D.36938 = 0B;
  return D.36938;
  <D.36937>:
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.475 = tmp_klass;
      if (tmp_klass.475 == 0B) goto <D.36940>; else goto <D.36941>;
      <D.36940>:
      D.36942 = mono_defaults.attribute_class;
      tmp_klass.476 = mono_array_class_get (D.36942, 1);
      tmp_klass = tmp_klass.476;
      tmp_klass.475 = tmp_klass;
      D.36944 = tmp_klass.475 == 0B;
      D.36945 = (long int) D.36944;
      D.36946 = __builtin_expect (D.36945, 0);
      if (D.36946 != 0) goto <D.36947>; else goto <D.36948>;
      <D.36947>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8971, "tmp_klass");
      <D.36948>:
      <D.36941>:
    }
    D.22470 = tmp_klass;
  }
  D.36949 = mono_domain_get ();
  D.36950 = mono_class_vtable (D.36949, D.22470);
  result = mono_array_new_specific (D.36950, 0);
  <D.36934>:
  D.36938 = result;
  return D.36938;
}


mono_reflection_get_custom_attrs (struct MonoObject * obj)
{
  struct MonoArray * D.36952;
  struct MonoError error;

  try
    {
      D.36952 = mono_reflection_get_custom_attrs_by_type (obj, 0B, &error);
      return D.36952;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_get_custom_attrs_data (struct MonoObject * obj)
{
  int D.36957;
  struct MonoClass * D.36961;
  struct MonoDomain * D.36962;
  struct MonoArray * D.36963;
  struct MonoArray * result;
  struct MonoCustomAttrInfo * cinfo;

  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo != 0B) goto <D.36955>; else goto <D.36956>;
  <D.36955>:
  result = mono_custom_attrs_data_construct (cinfo);
  D.36957 = cinfo->cached;
  if (D.36957 == 0) goto <D.36958>; else goto <D.36959>;
  <D.36958>:
  mono_custom_attrs_free (cinfo);
  <D.36959>:
  goto <D.36960>;
  <D.36956>:
  D.36961 = mono_defaults.customattribute_data_class;
  D.36962 = mono_domain_get ();
  result = mono_array_new (D.36962, D.36961, 0);
  <D.36960>:
  D.36963 = result;
  return D.36963;
}


mono_custom_attrs_data_construct (struct MonoCustomAttrInfo * cinfo)
{
  int D.36965;
  long unsigned int D.36966;
  struct MonoClass * D.36967;
  struct MonoDomain * D.36968;
  struct MonoCustomAttrEntry * D.36969;
  struct MonoImage * D.36970;
  long unsigned int D.36971;
  struct MonoArray * D.36972;
  struct MonoArray * result;
  struct MonoObject * attr;
  int i;

  D.36965 = cinfo->num_attrs;
  D.36966 = (long unsigned int) D.36965;
  D.36967 = mono_defaults.customattribute_data_class;
  D.36968 = mono_domain_get ();
  result = mono_array_new (D.36968, D.36967, D.36966);
  i = 0;
  goto <D.22152>;
  <D.22151>:
  D.36969 = &cinfo->attrs[i];
  D.36970 = cinfo->image;
  attr = create_custom_attr_data (D.36970, D.36969);
  {
    void * * __p;

    D.36971 = (long unsigned int) i;
    __p = mono_array_addr_with_size (result, 8, D.36971);
    mono_gc_wbarrier_set_arrayref (result, __p, attr);
  }
  i = i + 1;
  <D.22152>:
  D.36965 = cinfo->num_attrs;
  if (D.36965 > i) goto <D.22151>; else goto <D.22153>;
  <D.22153>:
  D.36972 = result;
  return D.36972;
}


create_custom_attr_data (struct MonoImage * image, struct MonoCustomAttrEntry * cattr)
{
  struct MonoAssembly * D.36974;
  _Bool D.36975;
  long int D.36976;
  long int D.36977;
  struct MonoMethod * ctor.477;
  struct MonoClass * D.36983;
  struct MonoMethod * ctor.478;
  struct MonoMethod * D.36985;
  struct MonoReflectionMethod * D.36986;
  struct MonoReflectionAssembly * D.36987;
  const mono_byte * * D.36988;
  uint32_t * D.36989;
  struct MonoObject * D.36990;
  static struct MonoMethod * ctor;
  struct MonoDomain * domain;
  struct MonoObject * attr;
  void * params[4];

  try
    {
      D.36974 = image->assembly;
      D.36975 = D.36974 == 0B;
      D.36976 = (long int) D.36975;
      D.36977 = __builtin_expect (D.36976, 0);
      if (D.36977 != 0) goto <D.36978>; else goto <D.36979>;
      <D.36978>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 8461, "image->assembly");
      <D.36979>:
      ctor.477 = ctor;
      if (ctor.477 == 0B) goto <D.36981>; else goto <D.36982>;
      <D.36981>:
      D.36983 = mono_defaults.customattribute_data_class;
      ctor.478 = mono_class_get_method_from_name (D.36983, ".ctor", 4);
      ctor = ctor.478;
      <D.36982>:
      domain = mono_domain_get ();
      D.36983 = mono_defaults.customattribute_data_class;
      attr = mono_object_new (domain, D.36983);
      D.36985 = cattr->ctor;
      D.36986 = mono_method_get_object (domain, D.36985, 0B);
      params[0] = D.36986;
      D.36974 = image->assembly;
      D.36987 = mono_assembly_get_object (domain, D.36974);
      params[1] = D.36987;
      D.36988 = &cattr->data;
      params[2] = D.36988;
      D.36989 = &cattr->data_size;
      params[3] = D.36989;
      ctor.477 = ctor;
      mono_runtime_invoke (ctor.477, attr, &params, 0B);
      D.36990 = attr;
      return D.36990;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_reflection_type_get_handle (struct MonoReflectionType * ref)
{
  struct MonoType * D.36995;
  struct MonoType * D.36996;
  int D.36999;
  int D.37005;
  struct MonoVTable * D.37008;
  int D.37009;
  struct MonoReflectionType * D.37012;
  _Bool D.37013;
  long int D.37014;
  long int D.37015;
  int D.37018;
  struct MonoClass * D.37021;
  struct MonoClass * D.37022;
  unsigned int D.37024;
  struct MonoClass * D.37025;
  struct MonoClass * D.37026;
  int D.37027;
  struct MonoReflectionType * D.37030;
  _Bool D.37031;
  long int D.37032;
  long int D.37033;
  struct MonoClass * D.37036;
  int D.37037;
  struct MonoReflectionType * D.37040;
  _Bool D.37041;
  long int D.37042;
  long int D.37043;
  struct MonoClass * D.37046;
  int D.37047;
  struct MonoArray * D.37050;
  long unsigned int D.37051;
  long unsigned int D.37052;
  long unsigned int D.37053;
  long unsigned int D.37054;
  char * D.37055;
  long unsigned int D.37056;
  long unsigned int D.37057;
  struct MonoType * * D.37058;
  struct MonoType * D.37059;
  struct MonoType * D.37060;
  struct MonoReflectionType * D.37063;
  _Bool D.37064;
  long int D.37065;
  long int D.37066;
  struct MonoClass * D.37069;
  struct MonoType * D.37070;
  char * D.37071;
  struct MonoClass * class;

  if (ref == 0B) goto <D.36993>; else goto <D.36994>;
  <D.36993>:
  D.36995 = 0B;
  return D.36995;
  <D.36994>:
  D.36996 = ref->type;
  if (D.36996 != 0B) goto <D.36997>; else goto <D.36998>;
  <D.36997>:
  D.36995 = ref->type;
  return D.36995;
  <D.36998>:
  D.36999 = is_usertype (ref);
  if (D.36999 != 0) goto <D.37000>; else goto <D.37001>;
  <D.37000>:
  ref = mono_reflection_type_get_underlying_system_type (ref);
  if (ref == 0B) goto <D.37002>; else goto <D.37004>;
  <D.37004>:
  D.37005 = is_usertype (ref);
  if (D.37005 != 0) goto <D.37002>; else goto <D.37003>;
  <D.37002>:
  D.36995 = 0B;
  return D.36995;
  <D.37003>:
  D.36996 = ref->type;
  if (D.36996 != 0B) goto <D.37006>; else goto <D.37007>;
  <D.37006>:
  D.36995 = ref->type;
  return D.36995;
  <D.37007>:
  <D.37001>:
  D.37008 = MEM[(struct MonoObject *)ref].vtable;
  class = D.37008->klass;
  D.37009 = is_sre_array (class);
  if (D.37009 != 0) goto <D.37010>; else goto <D.37011>;
  <D.37010>:
  {
    struct MonoType * res;
    struct MonoReflectionArrayType * sre_array;
    struct MonoType * base;

    sre_array = ref;
    D.37012 = sre_array->element_type;
    base = mono_reflection_type_get_handle (D.37012);
    D.37013 = base == 0B;
    D.37014 = (long int) D.37013;
    D.37015 = __builtin_expect (D.37014, 0);
    if (D.37015 != 0) goto <D.37016>; else goto <D.37017>;
    <D.37016>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9133, "base");
    <D.37017>:
    D.37018 = sre_array->rank;
    if (D.37018 == 0) goto <D.37019>; else goto <D.37020>;
    <D.37019>:
    D.37021 = mono_class_from_mono_type (base);
    D.37022 = mono_array_class_get (D.37021, 1);
    res = &D.37022->byval_arg;
    goto <D.37023>;
    <D.37020>:
    D.37018 = sre_array->rank;
    D.37024 = (unsigned int) D.37018;
    D.37025 = mono_class_from_mono_type (base);
    D.37026 = mono_bounded_array_class_get (D.37025, D.37024, 1);
    res = &D.37026->byval_arg;
    <D.37023>:
    sre_array->type.type = res;
    D.36995 = res;
    return D.36995;
  }
  <D.37011>:
  D.37027 = is_sre_byref (class);
  if (D.37027 != 0) goto <D.37028>; else goto <D.37029>;
  <D.37028>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_byref;
    struct MonoType * base;

    sre_byref = ref;
    D.37030 = sre_byref->element_type;
    base = mono_reflection_type_get_handle (D.37030);
    D.37031 = base == 0B;
    D.37032 = (long int) D.37031;
    D.37033 = __builtin_expect (D.37032, 0);
    if (D.37033 != 0) goto <D.37034>; else goto <D.37035>;
    <D.37034>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9144, "base");
    <D.37035>:
    D.37036 = mono_class_from_mono_type (base);
    res = &D.37036->this_arg;
    sre_byref->type.type = res;
    D.36995 = res;
    return D.36995;
  }
  <D.37029>:
  D.37037 = is_sre_pointer (class);
  if (D.37037 != 0) goto <D.37038>; else goto <D.37039>;
  <D.37038>:
  {
    struct MonoType * res;
    struct MonoReflectionDerivedType * sre_pointer;
    struct MonoType * base;

    sre_pointer = ref;
    D.37040 = sre_pointer->element_type;
    base = mono_reflection_type_get_handle (D.37040);
    D.37041 = base == 0B;
    D.37042 = (long int) D.37041;
    D.37043 = __builtin_expect (D.37042, 0);
    if (D.37043 != 0) goto <D.37044>; else goto <D.37045>;
    <D.37044>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9152, "base");
    <D.37045>:
    D.37046 = mono_ptr_class_get (base);
    res = &D.37046->byval_arg;
    sre_pointer->type.type = res;
    D.36995 = res;
    return D.36995;
  }
  <D.37039>:
  D.37047 = is_sre_generic_instance (class);
  if (D.37047 != 0) goto <D.37048>; else goto <D.37049>;
  <D.37048>:
  {
    struct MonoType * res;
    struct MonoType * * types;
    struct MonoReflectionGenericClass * gclass;
    int i;
    int count;

    gclass = ref;
    D.37050 = gclass->type_arguments;
    D.37051 = mono_array_length (D.37050);
    count = (int) D.37051;
    D.37052 = (long unsigned int) count;
    D.37053 = D.37052 * 8;
    types = monoeg_malloc0 (D.37053);
    i = 0;
    goto <D.22728>;
    <D.22727>:
    {
      struct MonoReflectionType * t;

      D.37054 = (long unsigned int) i;
      D.37050 = gclass->type_arguments;
      D.37055 = mono_array_addr_with_size (D.37050, 8, D.37054);
      t = MEM[(void * *)D.37055];
      D.37056 = (long unsigned int) i;
      D.37057 = D.37056 * 8;
      D.37058 = types + D.37057;
      D.37059 = mono_reflection_type_get_handle (t);
      *D.37058 = D.37059;
      D.37056 = (long unsigned int) i;
      D.37057 = D.37056 * 8;
      D.37058 = types + D.37057;
      D.37060 = *D.37058;
      if (D.37060 == 0B) goto <D.37061>; else goto <D.37062>;
      <D.37061>:
      monoeg_g_free (types);
      D.36995 = 0B;
      return D.36995;
      <D.37062>:
    }
    i = i + 1;
    <D.22728>:
    if (i < count) goto <D.22727>; else goto <D.22729>;
    <D.22729>:
    D.37063 = gclass->generic_type;
    res = mono_reflection_bind_generic_parameters (D.37063, count, types);
    monoeg_g_free (types);
    D.37064 = res == 0B;
    D.37065 = (long int) D.37064;
    D.37066 = __builtin_expect (D.37065, 0);
    if (D.37066 != 0) goto <D.37067>; else goto <D.37068>;
    <D.37067>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9174, "res");
    <D.37068>:
    gclass->type.type = res;
    D.36995 = res;
    return D.36995;
  }
  <D.37049>:
  D.37008 = MEM[(struct MonoObject *)ref].vtable;
  D.37069 = D.37008->klass;
  D.37070 = &D.37069->byval_arg;
  D.37071 = mono_type_full_name (D.37070);
  monoeg_g_log (0B, 4, "Cannot handle corlib user type %s", D.37071);
  <D.22730>:
  goto <D.22730>;
  D.36995 = 0B;
  return D.36995;
}


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.37073;
  struct MonoException * D.37076;
  union mono_mutex_t * D.37077;
  _Bool D.37080;
  long int D.37081;
  long int D.37082;
  struct MonoImage * D.37085;
  unsigned char D.37086;
  unsigned char D.37087;
  struct MonoGHashTable * D.37091;
  struct MonoGHashTable * D.37094;
  _Bool D.37097;
  long int D.37098;
  long int D.37099;
  struct MonoType * res;
  struct MonoDomain * domain;
  struct MonoClass * class;

  res = mono_reflection_type_get_handle (type);
  D.37073 = MEM[(struct MonoObject *)type].vtable;
  domain = D.37073->domain;
  if (res == 0B) goto <D.37074>; else goto <D.37075>;
  <D.37074>:
  D.37076 = mono_get_exception_argument (0B, "Invalid generic instantiation, one or more arguments are not proper user types");
  mono_raise_exception (D.37076);
  <D.37075>:
  class = mono_class_from_mono_type (res);
  mono_loader_lock ();
  {
    int ret;

    D.37077 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.37077);
    if (ret != 0) goto <D.37078>; else goto <D.37079>;
    <D.37078>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.37079>:
    D.37080 = ret != 0;
    D.37081 = (long int) D.37080;
    D.37082 = __builtin_expect (D.37081, 0);
    if (D.37082 != 0) goto <D.37083>; else goto <D.37084>;
    <D.37083>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9204, "ret == 0");
    <D.37084>:
  }
  D.37085 = class->image;
  D.37086 = BIT_FIELD_REF <*D.37085, 8, 224>;
  D.37087 = D.37086 & 8;
  if (D.37087 == 0) goto <D.37088>; else goto <D.37089>;
  <D.37088>:
  mono_class_setup_supertypes (class);
  goto <D.37090>;
  <D.37089>:
  D.37091 = domain->type_hash;
  if (D.37091 == 0B) goto <D.37092>; else goto <D.37093>;
  <D.37092>:
  D.37094 = mono_g_hash_table_new_type (mono_metadata_type_hash, mono_metadata_type_equal, 2);
  domain->type_hash = D.37094;
  <D.37093>:
  D.37091 = domain->type_hash;
  mono_g_hash_table_insert (D.37091, res, type);
  <D.37090>:
  {
    int ret;

    D.37077 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.37077);
    if (ret != 0) goto <D.37095>; else goto <D.37096>;
    <D.37095>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.37096>:
    D.37097 = ret != 0;
    D.37098 = (long int) D.37097;
    D.37099 = __builtin_expect (D.37098, 0);
    if (D.37099 != 0) goto <D.37100>; else goto <D.37101>;
    <D.37100>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9214, "ret == 0");
    <D.37101>:
  }
  mono_loader_unlock ();
}


mono_class_is_reflection_method_or_constructor (struct MonoClass * class)
{
  gboolean D.37102;
  int iftmp.479;
  int D.37107;
  int D.37109;
  int D.37111;
  int D.37113;

  D.37107 = is_sr_mono_method (class);
  if (D.37107 != 0) goto <D.37104>; else goto <D.37108>;
  <D.37108>:
  D.37109 = is_sr_mono_cmethod (class);
  if (D.37109 != 0) goto <D.37104>; else goto <D.37110>;
  <D.37110>:
  D.37111 = is_sr_mono_generic_method (class);
  if (D.37111 != 0) goto <D.37104>; else goto <D.37112>;
  <D.37112>:
  D.37113 = is_sr_mono_generic_cmethod (class);
  if (D.37113 != 0) goto <D.37104>; else goto <D.37105>;
  <D.37104>:
  iftmp.479 = 1;
  goto <D.37106>;
  <D.37105>:
  iftmp.479 = 0;
  <D.37106>:
  D.37102 = iftmp.479;
  return D.37102;
}


is_sr_mono_generic_method (struct MonoClass * class)
{
  struct MonoClass * cached_class.480;
  gboolean D.37118;
  _Bool D.37119;
  int D.37120;
  int D.22900;
  int iftmp.481;
  int D.22896;
  const char[18] * D.37126;
  unsigned char D.37127;
  int D.37128;
  unsigned char D.37129;
  int D.37130;
  _Bool D.37131;
  _Bool D.37132;
  _Bool D.37133;
  const unsigned char * D.37136;
  unsigned char D.37137;
  int D.37138;
  const unsigned char * D.37139;
  unsigned char D.37140;
  int D.37141;
  _Bool D.37142;
  _Bool D.37143;
  const unsigned char * D.37146;
  unsigned char D.37147;
  int D.37148;
  const unsigned char * D.37149;
  unsigned char D.37150;
  int D.37151;
  _Bool D.37152;
  _Bool D.37153;
  const unsigned char * D.37156;
  unsigned char D.37157;
  int D.37158;
  const unsigned char * D.37159;
  unsigned char D.37160;
  int D.37161;
  const char * D.37163;
  int D.22909;
  int iftmp.482;
  int D.22905;
  const char[18] * D.37169;
  unsigned char D.37170;
  int D.37171;
  unsigned char D.37172;
  int D.37173;
  _Bool D.37174;
  _Bool D.37175;
  _Bool D.37176;
  const unsigned char * D.37179;
  unsigned char D.37180;
  int D.37181;
  const unsigned char * D.37182;
  unsigned char D.37183;
  int D.37184;
  _Bool D.37185;
  _Bool D.37186;
  const unsigned char * D.37189;
  unsigned char D.37190;
  int D.37191;
  const unsigned char * D.37192;
  unsigned char D.37193;
  int D.37194;
  _Bool D.37195;
  _Bool D.37196;
  const unsigned char * D.37199;
  unsigned char D.37200;
  int D.37201;
  const unsigned char * D.37202;
  unsigned char D.37203;
  int D.37204;
  const char * D.37206;

  {
    static struct MonoClass * cached_class;

    cached_class.480 = cached_class;
    if (cached_class.480 != 0B) goto <D.37116>; else goto <D.37117>;
    <D.37116>:
    cached_class.480 = cached_class;
    D.37119 = cached_class.480 == class;
    D.37118 = (gboolean) D.37119;
    return D.37118;
    <D.37117>:
    D.37120 = is_corlib_type (class);
    if (D.37120 != 0) goto <D.37121>; else goto <D.37122>;
    <D.37121>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.37126 = "MonoGenericMethod";
        D.37127 = MEM[(const unsigned char *)D.37126];
        D.37128 = (int) D.37127;
        D.37129 = *__s2;
        D.37130 = (int) D.37129;
        __result = D.37128 - D.37130;
        {
          D.37131 = __s1_len != 0;
          D.37132 = __result == 0;
          D.37133 = D.37131 & D.37132;
          if (D.37133 != 0) goto <D.37134>; else goto <D.37135>;
          <D.37134>:
          D.37136 = &MEM[(void *)"MonoGenericMethod" + 1B];
          D.37137 = *D.37136;
          D.37138 = (int) D.37137;
          D.37139 = __s2 + 1;
          D.37140 = *D.37139;
          D.37141 = (int) D.37140;
          __result = D.37138 - D.37141;
          D.37142 = __s1_len > 1;
          D.37132 = __result == 0;
          D.37143 = D.37142 & D.37132;
          if (D.37143 != 0) goto <D.37144>; else goto <D.37145>;
          <D.37144>:
          D.37146 = &MEM[(void *)"MonoGenericMethod" + 2B];
          D.37147 = *D.37146;
          D.37148 = (int) D.37147;
          D.37149 = __s2 + 2;
          D.37150 = *D.37149;
          D.37151 = (int) D.37150;
          __result = D.37148 - D.37151;
          D.37152 = __s1_len > 2;
          D.37132 = __result == 0;
          D.37153 = D.37152 & D.37132;
          if (D.37153 != 0) goto <D.37154>; else goto <D.37155>;
          <D.37154>:
          D.37156 = &MEM[(void *)"MonoGenericMethod" + 3B];
          D.37157 = *D.37156;
          D.37158 = (int) D.37157;
          D.37159 = __s2 + 3;
          D.37160 = *D.37159;
          D.37161 = (int) D.37160;
          __result = D.37158 - D.37161;
          <D.37155>:
          <D.37145>:
          <D.37135>:
        }
        D.22896 = __result;
      }
      iftmp.481 = D.22896;
      goto <D.37162>;
      <D.37125>:
      D.37163 = class->name;
      iftmp.481 = __builtin_strcmp ("MonoGenericMethod", D.37163);
      <D.37162>:
      D.22900 = iftmp.481;
    }
    if (D.22900 == 0) goto <D.37164>; else goto <D.37165>;
    <D.37164>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37169 = "System.Reflection";
        D.37170 = MEM[(const unsigned char *)D.37169];
        D.37171 = (int) D.37170;
        D.37172 = *__s2;
        D.37173 = (int) D.37172;
        __result = D.37171 - D.37173;
        {
          D.37174 = __s1_len != 0;
          D.37175 = __result == 0;
          D.37176 = D.37174 & D.37175;
          if (D.37176 != 0) goto <D.37177>; else goto <D.37178>;
          <D.37177>:
          D.37179 = &MEM[(void *)"System.Reflection" + 1B];
          D.37180 = *D.37179;
          D.37181 = (int) D.37180;
          D.37182 = __s2 + 1;
          D.37183 = *D.37182;
          D.37184 = (int) D.37183;
          __result = D.37181 - D.37184;
          D.37185 = __s1_len > 1;
          D.37175 = __result == 0;
          D.37186 = D.37185 & D.37175;
          if (D.37186 != 0) goto <D.37187>; else goto <D.37188>;
          <D.37187>:
          D.37189 = &MEM[(void *)"System.Reflection" + 2B];
          D.37190 = *D.37189;
          D.37191 = (int) D.37190;
          D.37192 = __s2 + 2;
          D.37193 = *D.37192;
          D.37194 = (int) D.37193;
          __result = D.37191 - D.37194;
          D.37195 = __s1_len > 2;
          D.37175 = __result == 0;
          D.37196 = D.37195 & D.37175;
          if (D.37196 != 0) goto <D.37197>; else goto <D.37198>;
          <D.37197>:
          D.37199 = &MEM[(void *)"System.Reflection" + 3B];
          D.37200 = *D.37199;
          D.37201 = (int) D.37200;
          D.37202 = __s2 + 3;
          D.37203 = *D.37202;
          D.37204 = (int) D.37203;
          __result = D.37201 - D.37204;
          <D.37198>:
          <D.37188>:
          <D.37178>:
        }
        D.22905 = __result;
      }
      iftmp.482 = D.22905;
      goto <D.37205>;
      <D.37168>:
      D.37206 = class->name_space;
      iftmp.482 = __builtin_strcmp ("System.Reflection", D.37206);
      <D.37205>:
      D.22909 = iftmp.482;
    }
    if (D.22909 == 0) goto <D.37207>; else goto <D.37208>;
    <D.37207>:
    cached_class = class;
    D.37118 = 1;
    return D.37118;
    <D.37208>:
    <D.37165>:
    <D.37122>:
    D.37118 = 0;
    return D.37118;
  }
}


is_sr_mono_generic_cmethod (struct MonoClass * class)
{
  struct MonoClass * cached_class.483;
  gboolean D.37213;
  _Bool D.37214;
  int D.37215;
  int D.22922;
  int iftmp.484;
  int D.22918;
  const char[19] * D.37221;
  unsigned char D.37222;
  int D.37223;
  unsigned char D.37224;
  int D.37225;
  _Bool D.37226;
  _Bool D.37227;
  _Bool D.37228;
  const unsigned char * D.37231;
  unsigned char D.37232;
  int D.37233;
  const unsigned char * D.37234;
  unsigned char D.37235;
  int D.37236;
  _Bool D.37237;
  _Bool D.37238;
  const unsigned char * D.37241;
  unsigned char D.37242;
  int D.37243;
  const unsigned char * D.37244;
  unsigned char D.37245;
  int D.37246;
  _Bool D.37247;
  _Bool D.37248;
  const unsigned char * D.37251;
  unsigned char D.37252;
  int D.37253;
  const unsigned char * D.37254;
  unsigned char D.37255;
  int D.37256;
  const char * D.37258;
  int D.22931;
  int iftmp.485;
  int D.22927;
  const char[18] * D.37264;
  unsigned char D.37265;
  int D.37266;
  unsigned char D.37267;
  int D.37268;
  _Bool D.37269;
  _Bool D.37270;
  _Bool D.37271;
  const unsigned char * D.37274;
  unsigned char D.37275;
  int D.37276;
  const unsigned char * D.37277;
  unsigned char D.37278;
  int D.37279;
  _Bool D.37280;
  _Bool D.37281;
  const unsigned char * D.37284;
  unsigned char D.37285;
  int D.37286;
  const unsigned char * D.37287;
  unsigned char D.37288;
  int D.37289;
  _Bool D.37290;
  _Bool D.37291;
  const unsigned char * D.37294;
  unsigned char D.37295;
  int D.37296;
  const unsigned char * D.37297;
  unsigned char D.37298;
  int D.37299;
  const char * D.37301;

  {
    static struct MonoClass * cached_class;

    cached_class.483 = cached_class;
    if (cached_class.483 != 0B) goto <D.37211>; else goto <D.37212>;
    <D.37211>:
    cached_class.483 = cached_class;
    D.37214 = cached_class.483 == class;
    D.37213 = (gboolean) D.37214;
    return D.37213;
    <D.37212>:
    D.37215 = is_corlib_type (class);
    if (D.37215 != 0) goto <D.37216>; else goto <D.37217>;
    <D.37216>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name;
        D.37221 = "MonoGenericCMethod";
        D.37222 = MEM[(const unsigned char *)D.37221];
        D.37223 = (int) D.37222;
        D.37224 = *__s2;
        D.37225 = (int) D.37224;
        __result = D.37223 - D.37225;
        {
          D.37226 = __s1_len != 0;
          D.37227 = __result == 0;
          D.37228 = D.37226 & D.37227;
          if (D.37228 != 0) goto <D.37229>; else goto <D.37230>;
          <D.37229>:
          D.37231 = &MEM[(void *)"MonoGenericCMethod" + 1B];
          D.37232 = *D.37231;
          D.37233 = (int) D.37232;
          D.37234 = __s2 + 1;
          D.37235 = *D.37234;
          D.37236 = (int) D.37235;
          __result = D.37233 - D.37236;
          D.37237 = __s1_len > 1;
          D.37227 = __result == 0;
          D.37238 = D.37237 & D.37227;
          if (D.37238 != 0) goto <D.37239>; else goto <D.37240>;
          <D.37239>:
          D.37241 = &MEM[(void *)"MonoGenericCMethod" + 2B];
          D.37242 = *D.37241;
          D.37243 = (int) D.37242;
          D.37244 = __s2 + 2;
          D.37245 = *D.37244;
          D.37246 = (int) D.37245;
          __result = D.37243 - D.37246;
          D.37247 = __s1_len > 2;
          D.37227 = __result == 0;
          D.37248 = D.37247 & D.37227;
          if (D.37248 != 0) goto <D.37249>; else goto <D.37250>;
          <D.37249>:
          D.37251 = &MEM[(void *)"MonoGenericCMethod" + 3B];
          D.37252 = *D.37251;
          D.37253 = (int) D.37252;
          D.37254 = __s2 + 3;
          D.37255 = *D.37254;
          D.37256 = (int) D.37255;
          __result = D.37253 - D.37256;
          <D.37250>:
          <D.37240>:
          <D.37230>:
        }
        D.22918 = __result;
      }
      iftmp.484 = D.22918;
      goto <D.37257>;
      <D.37220>:
      D.37258 = class->name;
      iftmp.484 = __builtin_strcmp ("MonoGenericCMethod", D.37258);
      <D.37257>:
      D.22922 = iftmp.484;
    }
    if (D.22922 == 0) goto <D.37259>; else goto <D.37260>;
    <D.37259>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = class->name_space;
        D.37264 = "System.Reflection";
        D.37265 = MEM[(const unsigned char *)D.37264];
        D.37266 = (int) D.37265;
        D.37267 = *__s2;
        D.37268 = (int) D.37267;
        __result = D.37266 - D.37268;
        {
          D.37269 = __s1_len != 0;
          D.37270 = __result == 0;
          D.37271 = D.37269 & D.37270;
          if (D.37271 != 0) goto <D.37272>; else goto <D.37273>;
          <D.37272>:
          D.37274 = &MEM[(void *)"System.Reflection" + 1B];
          D.37275 = *D.37274;
          D.37276 = (int) D.37275;
          D.37277 = __s2 + 1;
          D.37278 = *D.37277;
          D.37279 = (int) D.37278;
          __result = D.37276 - D.37279;
          D.37280 = __s1_len > 1;
          D.37270 = __result == 0;
          D.37281 = D.37280 & D.37270;
          if (D.37281 != 0) goto <D.37282>; else goto <D.37283>;
          <D.37282>:
          D.37284 = &MEM[(void *)"System.Reflection" + 2B];
          D.37285 = *D.37284;
          D.37286 = (int) D.37285;
          D.37287 = __s2 + 2;
          D.37288 = *D.37287;
          D.37289 = (int) D.37288;
          __result = D.37286 - D.37289;
          D.37290 = __s1_len > 2;
          D.37270 = __result == 0;
          D.37291 = D.37290 & D.37270;
          if (D.37291 != 0) goto <D.37292>; else goto <D.37293>;
          <D.37292>:
          D.37294 = &MEM[(void *)"System.Reflection" + 3B];
          D.37295 = *D.37294;
          D.37296 = (int) D.37295;
          D.37297 = __s2 + 3;
          D.37298 = *D.37297;
          D.37299 = (int) D.37298;
          __result = D.37296 - D.37299;
          <D.37293>:
          <D.37283>:
          <D.37273>:
        }
        D.22927 = __result;
      }
      iftmp.485 = D.22927;
      goto <D.37300>;
      <D.37263>:
      D.37301 = class->name_space;
      iftmp.485 = __builtin_strcmp ("System.Reflection", D.37301);
      <D.37300>:
      D.22931 = iftmp.485;
    }
    if (D.22931 == 0) goto <D.37302>; else goto <D.37303>;
    <D.37302>:
    cached_class = class;
    D.37213 = 1;
    return D.37213;
    <D.37303>:
    <D.37260>:
    <D.37217>:
    D.37213 = 0;
    return D.37213;
  }
}


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.23060;
  int iftmp.486;
  int D.23059;
  struct MonoVTable * D.37308;
  struct MonoClass * D.37309;
  const char[12] * D.37310;
  unsigned char D.37311;
  int D.37312;
  unsigned char D.37313;
  int D.37314;
  _Bool D.37315;
  _Bool D.37316;
  _Bool D.37317;
  const unsigned char * D.37320;
  unsigned char D.37321;
  int D.37322;
  const unsigned char * D.37323;
  unsigned char D.37324;
  int D.37325;
  _Bool D.37326;
  _Bool D.37327;
  const unsigned char * D.37330;
  unsigned char D.37331;
  int D.37332;
  const unsigned char * D.37333;
  unsigned char D.37334;
  int D.37335;
  _Bool D.37336;
  _Bool D.37337;
  const unsigned char * D.37340;
  unsigned char D.37341;
  int D.37342;
  const unsigned char * D.37343;
  unsigned char D.37344;
  int D.37345;
  const char * D.37347;
  struct MonoMethod * D.37351;
  long unsigned int D.37352;
  short unsigned int D.37353;
  long unsigned int D.37354;
  _Bool D.37355;
  long int D.37356;
  long int D.37357;
  unsigned int buflen.487;
  long unsigned int D.37361;
  void * buffer.488;
  char * buffer.489;
  char * p.490;
  char * p.491;
  char * p.492;
  char * p.493;
  char * p.494;
  long unsigned int D.37369;
  char * D.37370;
  struct MonoType * D.37371;
  struct MonoAssembly * D.37372;
  unsigned int D.37373;
  long unsigned int D.37376;
  unsigned int D.37377;
  long unsigned int D.37380;
  unsigned int D.37381;
  char * p.495;
  char * p.496;
  char D.37384;
  char * p.497;
  char * p.498;
  unsigned int D.37387;
  char D.37388;
  char * D.37391;
  char * p.499;
  char * p.500;
  char * D.37394;
  void * D.37395;
  char * pname.501;
  struct MonoType * ptype.502;
  long unsigned int D.37398;
  char * D.37401;
  char * p.503;
  char * p.504;
  char * D.37404;
  void * D.37405;
  char * fname.505;
  struct MonoType * ftype.506;
  long unsigned int D.37408;
  long int p.507;
  long int buffer.508;
  long int D.37411;
  long int D.37412;
  _Bool D.37413;
  long int D.37414;
  long int D.37415;
  unsigned int buflen.509;
  long unsigned int D.37419;
  struct MonoClass * D.37420;
  struct MonoDomain * D.37421;
  char * p.510;
  long unsigned int D.37423;
  int D.23084;
  int iftmp.511;
  int D.23083;
  unsigned char D.37427;
  int D.37428;
  _Bool D.37429;
  _Bool D.37430;
  _Bool D.37431;
  const unsigned char * D.37434;
  unsigned char D.37435;
  int D.37436;
  _Bool D.37437;
  _Bool D.37438;
  const unsigned char * D.37441;
  unsigned char D.37442;
  int D.37443;
  _Bool D.37444;
  _Bool D.37445;
  const unsigned char * D.37448;
  unsigned char D.37449;
  int D.37450;
  struct MonoArray * D.37454;
  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.37306>; else goto <D.37307>;
        <D.37306>:
        {
          const unsigned char * __s2;
          int __result;

          D.37308 = ctor->vtable;
          D.37309 = D.37308->klass;
          __s2 = D.37309->name;
          D.37310 = "MonoCMethod";
          D.37311 = MEM[(const unsigned char *)D.37310];
          D.37312 = (int) D.37311;
          D.37313 = *__s2;
          D.37314 = (int) D.37313;
          __result = D.37312 - D.37314;
          {
            D.37315 = __s2_len != 0;
            D.37316 = __result == 0;
            D.37317 = D.37315 & D.37316;
            if (D.37317 != 0) goto <D.37318>; else goto <D.37319>;
            <D.37318>:
            D.37320 = &MEM[(void *)"MonoCMethod" + 1B];
            D.37321 = *D.37320;
            D.37322 = (int) D.37321;
            D.37323 = __s2 + 1;
            D.37324 = *D.37323;
            D.37325 = (int) D.37324;
            __result = D.37322 - D.37325;
            D.37326 = __s2_len > 1;
            D.37316 = __result == 0;
            D.37327 = D.37326 & D.37316;
            if (D.37327 != 0) goto <D.37328>; else goto <D.37329>;
            <D.37328>:
            D.37330 = &MEM[(void *)"MonoCMethod" + 2B];
            D.37331 = *D.37330;
            D.37332 = (int) D.37331;
            D.37333 = __s2 + 2;
            D.37334 = *D.37333;
            D.37335 = (int) D.37334;
            __result = D.37332 - D.37335;
            D.37336 = __s2_len > 2;
            D.37316 = __result == 0;
            D.37337 = D.37336 & D.37316;
            if (D.37337 != 0) goto <D.37338>; else goto <D.37339>;
            <D.37338>:
            D.37340 = &MEM[(void *)"MonoCMethod" + 3B];
            D.37341 = *D.37340;
            D.37342 = (int) D.37341;
            D.37343 = __s2 + 3;
            D.37344 = *D.37343;
            D.37345 = (int) D.37344;
            __result = D.37342 - D.37345;
            <D.37339>:
            <D.37329>:
            <D.37319>:
          }
          D.23059 = __result;
        }
        iftmp.486 = -D.23059;
        goto <D.37346>;
        <D.37307>:
        D.37308 = ctor->vtable;
        D.37309 = D.37308->klass;
        D.37347 = D.37309->name;
        iftmp.486 = __builtin_strcmp (D.37347, "MonoCMethod");
        <D.37346>:
        D.23060 = iftmp.486;
      }
      if (D.23060 != 0) goto <D.37348>; else goto <D.37349>;
      <D.37348>:
      sig = ctor_builder_to_signature (0B, ctor);
      goto <D.37350>;
      <D.37349>:
      D.37351 = MEM[(struct MonoReflectionMethod *)ctor].method;
      sig = mono_method_signature (D.37351);
      <D.37350>:
      D.37352 = mono_array_length (ctorArgs);
      D.37353 = sig->param_count;
      D.37354 = (long unsigned int) D.37353;
      D.37355 = D.37352 != D.37354;
      D.37356 = (long int) D.37355;
      D.37357 = __builtin_expect (D.37356, 0);
      if (D.37357 != 0) goto <D.37358>; else goto <D.37359>;
      <D.37358>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9719, "mono_array_length (ctorArgs) == sig->param_count");
      <D.37359>:
      buflen = 256;
      buflen.487 = buflen;
      D.37361 = (long unsigned int) buflen.487;
      buffer.488 = monoeg_malloc (D.37361);
      buffer = buffer.488;
      buffer.489 = buffer;
      p = buffer.489;
      p.490 = p;
      p.491 = p.490;
      p.492 = p.491 + 1;
      p = p.492;
      *p.491 = 1;
      p.490 = p;
      p.493 = p.490;
      p.494 = p.493 + 1;
      p = p.494;
      *p.493 = 0;
      i = 0;
      goto <D.23062>;
      <D.23061>:
      D.37369 = (long unsigned int) i;
      D.37370 = mono_array_addr_with_size (ctorArgs, 8, D.37369);
      arg = MEM[(struct MonoObject * *)D.37370];
      D.37371 = sig->params[i];
      p.490 = p;
      buffer.489 = buffer;
      D.37372 = assembly->assembly;
      encode_cattr_value (D.37372, buffer.489, p.490, &buffer, &p, &buflen, D.37371, arg, 0B);
      i = i + 1;
      <D.23062>:
      D.37353 = sig->param_count;
      D.37373 = (unsigned int) D.37353;
      if (D.37373 > i) goto <D.23061>; else goto <D.23063>;
      <D.23063>:
      i = 0;
      if (properties != 0B) goto <D.37374>; else goto <D.37375>;
      <D.37374>:
      D.37376 = mono_array_length (properties);
      D.37377 = (unsigned int) D.37376;
      i = D.37377 + i;
      <D.37375>:
      if (fields != 0B) goto <D.37378>; else goto <D.37379>;
      <D.37378>:
      D.37380 = mono_array_length (fields);
      D.37381 = (unsigned int) D.37380;
      i = D.37381 + i;
      <D.37379>:
      p.490 = p;
      p.495 = p.490;
      p.496 = p.495 + 1;
      p = p.496;
      D.37384 = (char) i;
      *p.495 = D.37384;
      p.490 = p;
      p.497 = p.490;
      p.498 = p.497 + 1;
      p = p.498;
      D.37387 = i >> 8;
      D.37388 = (char) D.37387;
      *p.497 = D.37388;
      if (properties != 0B) goto <D.37389>; else goto <D.37390>;
      <D.37389>:
      {
        struct MonoObject * prop;

        i = 0;
        goto <D.23068>;
        <D.23067>:
        {
          struct MonoType * ptype;
          char * pname;

          try
            {
              D.37369 = (long unsigned int) i;
              D.37391 = mono_array_addr_with_size (properties, 8, D.37369);
              prop = MEM[(void * *)D.37391];
              get_prop_name_and_type (prop, &pname, &ptype);
              p.490 = p;
              p.499 = p.490;
              p.500 = p.499 + 1;
              p = p.500;
              *p.499 = 84;
              D.37369 = (long unsigned int) i;
              D.37394 = mono_array_addr_with_size (propValues, 8, D.37369);
              D.37395 = MEM[(void * *)D.37394];
              pname.501 = pname;
              ptype.502 = ptype;
              p.490 = p;
              buffer.489 = buffer;
              encode_named_val (assembly, buffer.489, p.490, &buffer, &p, &buflen, ptype.502, pname.501, D.37395);
              pname.501 = pname;
              monoeg_g_free (pname.501);
            }
          finally
            {
              ptype = {CLOBBER};
              pname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.23068>:
        D.37369 = (long unsigned int) i;
        D.37398 = mono_array_length (properties);
        if (D.37369 < D.37398) goto <D.23067>; else goto <D.23069>;
        <D.23069>:
      }
      <D.37390>:
      if (fields != 0B) goto <D.37399>; else goto <D.37400>;
      <D.37399>:
      {
        struct MonoObject * field;

        i = 0;
        goto <D.23074>;
        <D.23073>:
        {
          struct MonoType * ftype;
          char * fname;

          try
            {
              D.37369 = (long unsigned int) i;
              D.37401 = mono_array_addr_with_size (fields, 8, D.37369);
              field = MEM[(void * *)D.37401];
              get_field_name_and_type (field, &fname, &ftype);
              p.490 = p;
              p.503 = p.490;
              p.504 = p.503 + 1;
              p = p.504;
              *p.503 = 83;
              D.37369 = (long unsigned int) i;
              D.37404 = mono_array_addr_with_size (fieldValues, 8, D.37369);
              D.37405 = MEM[(void * *)D.37404];
              fname.505 = fname;
              ftype.506 = ftype;
              p.490 = p;
              buffer.489 = buffer;
              encode_named_val (assembly, buffer.489, p.490, &buffer, &p, &buflen, ftype.506, fname.505, D.37405);
              fname.505 = fname;
              monoeg_g_free (fname.505);
            }
          finally
            {
              ftype = {CLOBBER};
              fname = {CLOBBER};
            }
        }
        i = i + 1;
        <D.23074>:
        D.37369 = (long unsigned int) i;
        D.37408 = mono_array_length (fields);
        if (D.37369 < D.37408) goto <D.23073>; else goto <D.23075>;
        <D.23075>:
      }
      <D.37400>:
      p.490 = p;
      p.507 = (long int) p.490;
      buffer.489 = buffer;
      buffer.508 = (long int) buffer.489;
      D.37411 = p.507 - buffer.508;
      buflen.487 = buflen;
      D.37412 = (long int) buflen.487;
      D.37413 = D.37411 > D.37412;
      D.37414 = (long int) D.37413;
      D.37415 = __builtin_expect (D.37414, 0);
      if (D.37415 != 0) goto <D.37416>; else goto <D.37417>;
      <D.37416>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9764, "p - buffer <= buflen");
      <D.37417>:
      p.490 = p;
      p.507 = (long int) p.490;
      buffer.489 = buffer;
      buffer.508 = (long int) buffer.489;
      D.37411 = p.507 - buffer.508;
      buflen.509 = (unsigned int) D.37411;
      buflen = buflen.509;
      buflen.487 = buflen;
      D.37419 = (long unsigned int) buflen.487;
      D.37420 = mono_defaults.byte_class;
      D.37421 = mono_domain_get ();
      result = mono_array_new (D.37421, D.37420, D.37419);
      p.510 = mono_array_addr_with_size (result, 1, 0);
      p = p.510;
      buflen.487 = buflen;
      D.37423 = (long unsigned int) buflen.487;
      buffer.489 = buffer;
      p.490 = p;
      memcpy (p.490, buffer.489, D.37423);
      buffer.489 = buffer;
      monoeg_g_free (buffer.489);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.37308 = ctor->vtable;
          D.37309 = D.37308->klass;
          __s2 = D.37309->name;
          D.37310 = "MonoCMethod";
          D.37311 = MEM[(const unsigned char *)D.37310];
          D.37312 = (int) D.37311;
          D.37427 = *__s2;
          D.37428 = (int) D.37427;
          __result = D.37312 - D.37428;
          {
            D.37429 = __s2_len != 0;
            D.37430 = __result == 0;
            D.37431 = D.37429 & D.37430;
            if (D.37431 != 0) goto <D.37432>; else goto <D.37433>;
            <D.37432>:
            D.37320 = &MEM[(void *)"MonoCMethod" + 1B];
            D.37321 = *D.37320;
            D.37322 = (int) D.37321;
            D.37434 = __s2 + 1;
            D.37435 = *D.37434;
            D.37436 = (int) D.37435;
            __result = D.37322 - D.37436;
            D.37437 = __s2_len > 1;
            D.37430 = __result == 0;
            D.37438 = D.37437 & D.37430;
            if (D.37438 != 0) goto <D.37439>; else goto <D.37440>;
            <D.37439>:
            D.37330 = &MEM[(void *)"MonoCMethod" + 2B];
            D.37331 = *D.37330;
            D.37332 = (int) D.37331;
            D.37441 = __s2 + 2;
            D.37442 = *D.37441;
            D.37443 = (int) D.37442;
            __result = D.37332 - D.37443;
            D.37444 = __s2_len > 2;
            D.37430 = __result == 0;
            D.37445 = D.37444 & D.37430;
            if (D.37445 != 0) goto <D.37446>; else goto <D.37447>;
            <D.37446>:
            D.37340 = &MEM[(void *)"MonoCMethod" + 3B];
            D.37341 = *D.37340;
            D.37342 = (int) D.37341;
            D.37448 = __s2 + 3;
            D.37449 = *D.37448;
            D.37450 = (int) D.37449;
            __result = D.37342 - D.37450;
            <D.37447>:
            <D.37440>:
            <D.37433>:
          }
          D.23083 = __result;
        }
        iftmp.511 = -D.23083;
        goto <D.37451>;
        <D.37426>:
        D.37308 = ctor->vtable;
        D.37309 = D.37308->klass;
        D.37347 = D.37309->name;
        iftmp.511 = __builtin_strcmp (D.37347, "MonoCMethod");
        <D.37451>:
        D.23084 = iftmp.511;
      }
      if (D.23084 != 0) goto <D.37452>; else goto <D.37453>;
      <D.37452>:
      monoeg_g_free (sig);
      <D.37453>:
      D.37454 = result;
      return D.37454;
    }
  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.512;
  long int p.513;
  char * buffer.514;
  long int buffer.515;
  long int D.37461;
  long int D.37462;
  unsigned int D.37463;
  long int D.37464;
  unsigned int D.37467;
  long unsigned int D.37468;
  sizetype D.37469;
  char * p.516;
  unsigned char D.37473;
  char * p.517;
  char * p.518;
  char D.37476;
  char * p.519;
  char * p.520;
  char * p.521;
  struct MonoClass * D.37480;
  unsigned char D.37481;
  unsigned char D.37482;
  struct MonoType * D.37485;
  unsigned char D.37486;
  const char * D.37487;
  char * p.522;
  char * p.523;
  long unsigned int D.37492;
  long int D.37493;
  long int D.37494;
  unsigned int D.37497;
  char * p.524;
  long unsigned int D.37499;
  sizetype D.37500;
  char * p.525;
  char * p.526;
  char * p.527;
  struct MonoType * D.37506;
  long unsigned int D.37507;
  long int D.37508;
  long int D.37509;
  unsigned int D.37512;
  char * p.528;
  long unsigned int D.37514;
  sizetype D.37515;
  char * p.529;
  char * p.530;
  char * p.531;
  char * p.532;
  char * p.533;
  char * p.534;
  char * p.535;
  char * p.536;
  char * p.537;
  long unsigned int D.37527;
  char * p.538;
  char * p.539;
  char D.37530;
  char * p.540;
  char * p.541;
  int D.37533;
  char D.37534;
  char * p.542;
  char * p.543;
  int D.37537;
  char D.37538;
  char * p.544;
  char * p.545;
  unsigned int len.546;
  unsigned int D.37542;
  char D.37543;
  struct MonoVTable * D.37544;
  struct MonoClass * D.37545;
  struct MonoClass * D.37550;
  unsigned char D.37552;
  unsigned char D.37553;
  struct MonoType * D.37555;
  sizetype D.37556;
  unsigned char D.37558;
  unsigned char D.37559;
  struct MonoType * D.37562;
  sizetype D.37563;
  long unsigned int D.37564;
  char * D.37565;
  struct MonoObject * D.37566;
  char * p.547;
  char * p.548;
  char * p.549;
  char * p.550;
  struct MonoClass * D.37573;
  struct MonoObject * D.37574;
  char * p.551;
  char * p.552;
  unsigned char D.37579;
  unsigned char D.37580;
  char * p.553;
  char * p.554;
  struct MonoClass * D.37586;
  char * p.555;
  char * p.556;
  unsigned char D.37591;
  char * p.557;
  char * p.558;
  struct MonoClass * D.37596;
  unsigned char D.37597;
  char * p.559;
  char * p.560;
  char * p.561;
  char * p.562;
  char D.37605;
  struct MonoType * D.37606;
  unsigned char D.37607;
  unsigned char D.37608;
  char * p.563;
  char * p.564;
  char D.37613;
  struct MonoType * D.37614;
  long unsigned int D.37615;
  long int D.37616;
  long int D.37617;
  unsigned int D.37620;
  char * p.565;
  long unsigned int D.37622;
  sizetype D.37623;
  char * p.566;
  struct MonoType * D.37625;
  unsigned char D.37626;
  MonoTypeEnum simple_type;
  void handle_enum = <<< error >>>;
  void handle_type = <<< error >>>;

  p.512 = p;
  p.513 = (long int) p.512;
  buffer.514 = buffer;
  buffer.515 = (long int) buffer.514;
  D.37461 = p.513 - buffer.515;
  D.37462 = D.37461 + 10;
  D.37463 = *buflen;
  D.37464 = (long int) D.37463;
  if (D.37462 >= D.37464) goto <D.37465>; else goto <D.37466>;
  <D.37465>:
  {
    char * newbuf;

    D.37463 = *buflen;
    D.37467 = D.37463 * 2;
    *buflen = D.37467;
    D.37463 = *buflen;
    D.37468 = (long unsigned int) D.37463;
    buffer.514 = buffer;
    newbuf = monoeg_realloc (buffer.514, D.37468);
    p.512 = p;
    p.513 = (long int) p.512;
    buffer.514 = buffer;
    buffer.515 = (long int) buffer.514;
    D.37461 = p.513 - buffer.515;
    D.37469 = (sizetype) D.37461;
    p.516 = newbuf + D.37469;
    p = p.516;
    buffer = newbuf;
  }
  <D.37466>:
  if (argval == 0B) goto <D.37471>; else goto <D.37472>;
  <D.37471>:
  argval = arg + 16;
  <D.37472>:
  D.37473 = type->type;
  simple_type = (MonoTypeEnum) D.37473;
  handle_enum:
  switch (simple_type) <default: <D.23012>, case 2: <D.22965>, case 3: <D.22969>, case 4: <D.22967>, case 5: <D.22966>, case 6: <D.22971>, case 7: <D.22970>, case 8: <D.22973>, case 9: <D.22972>, case 10: <D.22977>, case 11: <D.22976>, case 12: <D.22974>, case 13: <D.22975>, case 14: <D.22979>, case 17: <D.22978>, case 18: <D.22983>, case 28: <D.23006>, case 29: <D.22988>>
  <D.22965>:
  <D.22966>:
  <D.22967>:
  p.512 = p;
  p.517 = p.512;
  p.518 = p.517 + 1;
  p = p.518;
  D.37476 = *argval;
  *p.517 = D.37476;
  goto <D.22968>;
  <D.22969>:
  <D.22970>:
  <D.22971>:
  p.512 = p;
  swap_with_size (p.512, argval, 2, 1);
  p.512 = p;
  p.519 = p.512 + 2;
  p = p.519;
  goto <D.22968>;
  <D.22972>:
  <D.22973>:
  <D.22974>:
  p.512 = p;
  swap_with_size (p.512, argval, 4, 1);
  p.512 = p;
  p.520 = p.512 + 4;
  p = p.520;
  goto <D.22968>;
  <D.22975>:
  p.512 = p;
  swap_with_size (p.512, argval, 8, 1);
  p.512 = p;
  p.521 = p.512 + 8;
  p = p.521;
  goto <D.22968>;
  <D.22976>:
  <D.22977>:
  p.512 = p;
  swap_with_size (p.512, argval, 8, 1);
  p.512 = p;
  p.521 = p.512 + 8;
  p = p.521;
  goto <D.22968>;
  <D.22978>:
  D.37480 = type->data.klass;
  D.37481 = BIT_FIELD_REF <*D.37480, 8, 256>;
  D.37482 = D.37481 & 16;
  if (D.37482 != 0) goto <D.37483>; else goto <D.37484>;
  <D.37483>:
  D.37480 = type->data.klass;
  D.37485 = mono_class_enum_basetype (D.37480);
  D.37486 = D.37485->type;
  simple_type = (MonoTypeEnum) D.37486;
  goto handle_enum;
  <D.37484>:
  D.37480 = type->data.klass;
  D.37487 = D.37480->name;
  monoeg_g_log (0B, 16, "generic valutype %s not handled in custom attr value decoding", D.37487);
  goto <D.22968>;
  <D.22979>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37488>; else goto <D.37489>;
    <D.37488>:
    p.512 = p;
    p.522 = p.512;
    p.523 = p.522 + 1;
    p = p.523;
    *p.522 = -1;
    goto <D.22968>;
    <D.37489>:
    str = mono_string_to_utf8 (arg);
    D.37492 = strlen (str);
    slen = (guint32) D.37492;
    p.512 = p;
    p.513 = (long int) p.512;
    buffer.514 = buffer;
    buffer.515 = (long int) buffer.514;
    D.37461 = p.513 - buffer.515;
    D.37462 = D.37461 + 10;
    D.37493 = (long int) slen;
    D.37494 = D.37462 + D.37493;
    D.37463 = *buflen;
    D.37464 = (long int) D.37463;
    if (D.37494 >= D.37464) goto <D.37495>; else goto <D.37496>;
    <D.37495>:
    {
      char * newbuf;

      D.37463 = *buflen;
      D.37467 = D.37463 * 2;
      *buflen = D.37467;
      D.37463 = *buflen;
      D.37497 = D.37463 + slen;
      *buflen = D.37497;
      D.37463 = *buflen;
      D.37468 = (long unsigned int) D.37463;
      buffer.514 = buffer;
      newbuf = monoeg_realloc (buffer.514, D.37468);
      p.512 = p;
      p.513 = (long int) p.512;
      buffer.514 = buffer;
      buffer.515 = (long int) buffer.514;
      D.37461 = p.513 - buffer.515;
      D.37469 = (sizetype) D.37461;
      p.524 = newbuf + D.37469;
      p = p.524;
      buffer = newbuf;
    }
    <D.37496>:
    p.512 = p;
    mono_metadata_encode_value (slen, p.512, &p);
    D.37499 = (long unsigned int) slen;
    p.512 = p;
    memcpy (p.512, str, D.37499);
    p.512 = p;
    D.37500 = (sizetype) slen;
    p.525 = p.512 + D.37500;
    p = p.525;
    monoeg_g_free (str);
    goto <D.22968>;
  }
  <D.22983>:
  {
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37502>; else goto <D.37503>;
    <D.37502>:
    p.512 = p;
    p.526 = p.512;
    p.527 = p.526 + 1;
    p = p.527;
    *p.526 = -1;
    goto <D.22968>;
    <D.37503>:
    handle_type:
    D.37506 = mono_reflection_type_get_handle (arg);
    str = type_get_qualified_name (D.37506, 0B);
    D.37507 = strlen (str);
    slen = (guint32) D.37507;
    p.512 = p;
    p.513 = (long int) p.512;
    buffer.514 = buffer;
    buffer.515 = (long int) buffer.514;
    D.37461 = p.513 - buffer.515;
    D.37462 = D.37461 + 10;
    D.37508 = (long int) slen;
    D.37509 = D.37462 + D.37508;
    D.37463 = *buflen;
    D.37464 = (long int) D.37463;
    if (D.37509 >= D.37464) goto <D.37510>; else goto <D.37511>;
    <D.37510>:
    {
      char * newbuf;

      D.37463 = *buflen;
      D.37467 = D.37463 * 2;
      *buflen = D.37467;
      D.37463 = *buflen;
      D.37512 = D.37463 + slen;
      *buflen = D.37512;
      D.37463 = *buflen;
      D.37468 = (long unsigned int) D.37463;
      buffer.514 = buffer;
      newbuf = monoeg_realloc (buffer.514, D.37468);
      p.512 = p;
      p.513 = (long int) p.512;
      buffer.514 = buffer;
      buffer.515 = (long int) buffer.514;
      D.37461 = p.513 - buffer.515;
      D.37469 = (sizetype) D.37461;
      p.528 = newbuf + D.37469;
      p = p.528;
      buffer = newbuf;
    }
    <D.37511>:
    p.512 = p;
    mono_metadata_encode_value (slen, p.512, &p);
    D.37514 = (long unsigned int) slen;
    p.512 = p;
    memcpy (p.512, str, D.37514);
    p.512 = p;
    D.37515 = (sizetype) slen;
    p.529 = p.512 + D.37515;
    p = p.529;
    monoeg_g_free (str);
    goto <D.22968>;
  }
  <D.22988>:
  {
    int len;
    int i;
    struct MonoClass * eclass;
    struct MonoClass * arg_eclass;

    if (arg == 0B) goto <D.37517>; else goto <D.37518>;
    <D.37517>:
    p.512 = p;
    p.530 = p.512;
    p.531 = p.530 + 1;
    p = p.531;
    *p.530 = -1;
    p.512 = p;
    p.532 = p.512;
    p.533 = p.532 + 1;
    p = p.533;
    *p.532 = -1;
    p.512 = p;
    p.534 = p.512;
    p.535 = p.534 + 1;
    p = p.535;
    *p.534 = -1;
    p.512 = p;
    p.536 = p.512;
    p.537 = p.536 + 1;
    p = p.537;
    *p.536 = -1;
    goto <D.22968>;
    <D.37518>:
    D.37527 = mono_array_length (arg);
    len = (int) D.37527;
    p.512 = p;
    p.538 = p.512;
    p.539 = p.538 + 1;
    p = p.539;
    D.37530 = (char) len;
    *p.538 = D.37530;
    p.512 = p;
    p.540 = p.512;
    p.541 = p.540 + 1;
    p = p.541;
    D.37533 = len >> 8;
    D.37534 = (char) D.37533;
    *p.540 = D.37534;
    p.512 = p;
    p.542 = p.512;
    p.543 = p.542 + 1;
    p = p.543;
    D.37537 = len >> 16;
    D.37538 = (char) D.37537;
    *p.542 = D.37538;
    p.512 = p;
    p.544 = p.512;
    p.545 = p.544 + 1;
    p = p.545;
    len.546 = (unsigned int) len;
    D.37542 = len.546 >> 24;
    D.37543 = (char) D.37542;
    *p.544 = D.37543;
    p.512 = p;
    *retp = p.512;
    buffer.514 = buffer;
    *retbuffer = buffer.514;
    eclass = type->data.klass;
    D.37544 = arg->vtable;
    D.37545 = D.37544->klass;
    arg_eclass = D.37545->element_class;
    if (eclass == 0B) goto <D.37546>; else goto <D.37547>;
    <D.37546>:
    eclass = mono_defaults.object_class;
    <D.37547>:
    D.37550 = mono_defaults.object_class;
    if (D.37550 == eclass) goto <D.37551>; else goto <D.37548>;
    <D.37551>:
    D.37552 = BIT_FIELD_REF <*arg_eclass, 8, 256>;
    D.37553 = D.37552 & 8;
    if (D.37553 != 0) goto <D.37554>; else goto <D.37548>;
    <D.37554>:
    {
      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.22996>;
      <D.22995>:
      D.37555 = &arg_eclass->byval_arg;
      p.512 = p;
      buffer.514 = buffer;
      encode_cattr_value (assembly, buffer.514, p.512, &buffer, &p, buflen, D.37555, 0B, elptr);
      D.37556 = (sizetype) elsize;
      elptr = elptr + D.37556;
      i = i + 1;
      <D.22996>:
      if (i < len) goto <D.22995>; else goto <D.22997>;
      <D.22997>:
    }
    goto <D.37549>;
    <D.37548>:
    D.37558 = BIT_FIELD_REF <*eclass, 8, 256>;
    D.37559 = D.37558 & 8;
    if (D.37559 != 0) goto <D.37560>; else goto <D.37557>;
    <D.37560>:
    D.37552 = BIT_FIELD_REF <*arg_eclass, 8, 256>;
    D.37553 = D.37552 & 8;
    if (D.37553 != 0) goto <D.37561>; else goto <D.37557>;
    <D.37561>:
    {
      char * elptr;
      int elsize;

      elptr = mono_array_addr_with_size (arg, 1, 0);
      elsize = mono_class_array_element_size (eclass);
      i = 0;
      goto <D.23001>;
      <D.23000>:
      D.37562 = &eclass->byval_arg;
      p.512 = p;
      buffer.514 = buffer;
      encode_cattr_value (assembly, buffer.514, p.512, &buffer, &p, buflen, D.37562, 0B, elptr);
      D.37563 = (sizetype) elsize;
      elptr = elptr + D.37563;
      i = i + 1;
      <D.23001>:
      if (i < len) goto <D.23000>; else goto <D.23002>;
      <D.23002>:
    }
    goto <D.23005>;
    <D.37557>:
    i = 0;
    goto <D.23004>;
    <D.23003>:
    D.37564 = (long unsigned int) i;
    D.37565 = mono_array_addr_with_size (arg, 8, D.37564);
    D.37566 = MEM[(struct MonoObject * *)D.37565];
    D.37562 = &eclass->byval_arg;
    p.512 = p;
    buffer.514 = buffer;
    encode_cattr_value (assembly, buffer.514, p.512, &buffer, &p, buflen, D.37562, D.37566, 0B);
    i = i + 1;
    <D.23004>:
    if (i < len) goto <D.23003>; else goto <D.23005>;
    <D.23005>:
    <D.37549>:
    goto <D.22968>;
  }
  <D.23006>:
  {
    struct MonoClass * klass;
    char * str;
    guint32 slen;

    if (arg == 0B) goto <D.37567>; else goto <D.37568>;
    <D.37567>:
    p.512 = p;
    p.547 = p.512;
    p.548 = p.547 + 1;
    p = p.548;
    *p.547 = 14;
    p.512 = p;
    p.549 = p.512;
    p.550 = p.549 + 1;
    p = p.550;
    *p.549 = -1;
    goto <D.22968>;
    <D.37568>:
    D.37544 = arg->vtable;
    klass = D.37544->klass;
    D.37573 = mono_defaults.systemtype_class;
    D.37574 = mono_object_isinst (arg, D.37573);
    if (D.37574 != 0B) goto <D.37575>; else goto <D.37576>;
    <D.37575>:
    p.512 = p;
    p.551 = p.512;
    p.552 = p.551 + 1;
    p = p.552;
    *p.551 = 80;
    goto handle_type;
    <D.37576>:
    D.37579 = BIT_FIELD_REF <*klass, 8, 256>;
    D.37580 = D.37579 & 16;
    if (D.37580 != 0) goto <D.37581>; else goto <D.37582>;
    <D.37581>:
    p.512 = p;
    p.553 = p.512;
    p.554 = p.553 + 1;
    p = p.554;
    *p.553 = 85;
    goto <D.37585>;
    <D.37582>:
    D.37586 = mono_defaults.string_class;
    if (D.37586 == klass) goto <D.37587>; else goto <D.37588>;
    <D.37587>:
    simple_type = 14;
    p.512 = p;
    p.555 = p.512;
    p.556 = p.555 + 1;
    p = p.556;
    *p.555 = 14;
    goto handle_enum;
    <D.37588>:
    D.37591 = klass->rank;
    if (D.37591 == 1) goto <D.37592>; else goto <D.37593>;
    <D.37592>:
    p.512 = p;
    p.557 = p.512;
    p.558 = p.557 + 1;
    p = p.558;
    *p.557 = 29;
    D.37596 = klass->element_class;
    D.37597 = D.37596->byval_arg.type;
    if (D.37597 == 28) goto <D.37598>; else goto <D.37599>;
    <D.37598>:
    p.512 = p;
    p.559 = p.512;
    p.560 = p.559 + 1;
    p = p.560;
    *p.559 = 81;
    goto <D.37602>;
    <D.37599>:
    p.512 = p;
    p.561 = p.512;
    p.562 = p.561 + 1;
    p = p.562;
    D.37596 = klass->element_class;
    D.37597 = D.37596->byval_arg.type;
    D.37605 = (char) D.37597;
    *p.561 = D.37605;
    <D.37602>:
    D.37606 = &klass->byval_arg;
    p.512 = p;
    buffer.514 = buffer;
    encode_cattr_value (assembly, buffer.514, p.512, &buffer, &p, buflen, D.37606, arg, 0B);
    goto <D.22968>;
    <D.37593>:
    D.37607 = klass->byval_arg.type;
    D.37608 = D.37607 + 254;
    if (D.37608 <= 11) goto <D.37609>; else goto <D.37610>;
    <D.37609>:
    p.512 = p;
    p.563 = p.512;
    p.564 = p.563 + 1;
    p = p.564;
    D.37607 = klass->byval_arg.type;
    simple_type = (MonoTypeEnum) D.37607;
    D.37613 = (char) simple_type;
    *p.563 = D.37613;
    goto handle_enum;
    <D.37610>:
    monoeg_g_log (0B, 4, "unhandled type in custom attr");
    <D.23010>:
    goto <D.23010>;
    <D.37585>:
    D.37614 = mono_class_get_type (klass);
    str = type_get_qualified_name (D.37614, 0B);
    D.37615 = strlen (str);
    slen = (guint32) D.37615;
    p.512 = p;
    p.513 = (long int) p.512;
    buffer.514 = buffer;
    buffer.515 = (long int) buffer.514;
    D.37461 = p.513 - buffer.515;
    D.37462 = D.37461 + 10;
    D.37616 = (long int) slen;
    D.37617 = D.37462 + D.37616;
    D.37463 = *buflen;
    D.37464 = (long int) D.37463;
    if (D.37617 >= D.37464) goto <D.37618>; else goto <D.37619>;
    <D.37618>:
    {
      char * newbuf;

      D.37463 = *buflen;
      D.37467 = D.37463 * 2;
      *buflen = D.37467;
      D.37463 = *buflen;
      D.37620 = D.37463 + slen;
      *buflen = D.37620;
      D.37463 = *buflen;
      D.37468 = (long unsigned int) D.37463;
      buffer.514 = buffer;
      newbuf = monoeg_realloc (buffer.514, D.37468);
      p.512 = p;
      p.513 = (long int) p.512;
      buffer.514 = buffer;
      buffer.515 = (long int) buffer.514;
      D.37461 = p.513 - buffer.515;
      D.37469 = (sizetype) D.37461;
      p.565 = newbuf + D.37469;
      p = p.565;
      buffer = newbuf;
    }
    <D.37619>:
    p.512 = p;
    mono_metadata_encode_value (slen, p.512, &p);
    D.37622 = (long unsigned int) slen;
    p.512 = p;
    memcpy (p.512, str, D.37622);
    p.512 = p;
    D.37623 = (sizetype) slen;
    p.566 = p.512 + D.37623;
    p = p.566;
    monoeg_g_free (str);
    D.37625 = mono_class_enum_basetype (klass);
    D.37626 = D.37625->type;
    simple_type = (MonoTypeEnum) D.37626;
    goto handle_enum;
  }
  <D.23012>:
  monoeg_g_log (0B, 4, "type 0x%02x not yet supported in custom attr encoder", simple_type);
  <D.23013>:
  goto <D.23013>;
  <D.22968>:
  p.512 = p;
  *retp = p.512;
  buffer.514 = buffer;
  *retbuffer = buffer.514;
}


swap_with_size (char * dest, const char * val, int len, int nelem)
{
  int D.37627;
  long unsigned int D.37628;

  D.37627 = len * nelem;
  D.37628 = (long unsigned int) D.37627;
  memcpy (dest, val, D.37628);
}


type_get_qualified_name (struct MonoType * type, struct MonoAssembly * ass)
{
  char * D.37631;
  struct MonoImage * D.37632;
  unsigned char D.37635;
  struct MonoGenericClass * D.37639;
  struct MonoGenericContainer * D.37641;
  struct MonoClass * klass;
  struct MonoAssembly * ta;

  klass = mono_class_from_mono_type (type);
  if (klass == 0B) goto <D.37629>; else goto <D.37630>;
  <D.37629>:
  D.37631 = mono_type_get_name_full (type, 1);
  return D.37631;
  <D.37630>:
  D.37632 = klass->image;
  ta = D.37632->assembly;
  D.37635 = ta->dynamic;
  if (D.37635 != 0) goto <D.37633>; else goto <D.37636>;
  <D.37636>:
  if (ta == ass) goto <D.37633>; else goto <D.37634>;
  <D.37633>:
  D.37639 = klass->generic_class;
  if (D.37639 != 0B) goto <D.37637>; else goto <D.37640>;
  <D.37640>:
  D.37641 = klass->generic_container;
  if (D.37641 != 0B) goto <D.37637>; else goto <D.37638>;
  <D.37637>:
  D.37631 = mono_type_get_name_full (type, 2);
  return D.37631;
  <D.37638>:
  D.37631 = mono_type_get_name_full (type, 1);
  return D.37631;
  <D.37634>:
  D.37631 = mono_type_get_name_full (type, 3);
  return D.37631;
}


get_prop_name_and_type (struct MonoObject * prop, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.37643;
  int D.22780;
  int iftmp.567;
  int D.22779;
  const char[16] * D.37647;
  unsigned char D.37648;
  int D.37649;
  unsigned char D.37650;
  int D.37651;
  _Bool D.37652;
  _Bool D.37653;
  _Bool D.37654;
  const unsigned char * D.37657;
  unsigned char D.37658;
  int D.37659;
  const unsigned char * D.37660;
  unsigned char D.37661;
  int D.37662;
  _Bool D.37663;
  _Bool D.37664;
  const unsigned char * D.37667;
  unsigned char D.37668;
  int D.37669;
  const unsigned char * D.37670;
  unsigned char D.37671;
  int D.37672;
  _Bool D.37673;
  _Bool D.37674;
  const unsigned char * D.37677;
  unsigned char D.37678;
  int D.37679;
  const unsigned char * D.37680;
  unsigned char D.37681;
  int D.37682;
  const char * D.37684;
  struct MonoString * D.37687;
  char * D.37688;
  struct MonoObject * D.37689;
  struct MonoType * D.37690;
  struct MonoProperty * D.37692;
  const char * D.37693;
  gchar * D.37694;
  struct MonoMethod * D.37695;
  struct MonoMethodSignature * D.37698;
  struct MonoType * D.37699;
  struct MonoMethod * D.37701;
  struct MonoMethodSignature * D.37702;
  struct MonoMethodSignature * D.37703;
  short unsigned int D.37704;
  int D.37705;
  int D.37706;
  struct MonoType * D.37707;
  struct MonoClass * klass;

  D.37643 = prop->vtable;
  klass = D.37643->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.37647 = "PropertyBuilder";
      D.37648 = MEM[(const unsigned char *)D.37647];
      D.37649 = (int) D.37648;
      D.37650 = *__s2;
      D.37651 = (int) D.37650;
      __result = D.37649 - D.37651;
      {
        D.37652 = __s2_len != 0;
        D.37653 = __result == 0;
        D.37654 = D.37652 & D.37653;
        if (D.37654 != 0) goto <D.37655>; else goto <D.37656>;
        <D.37655>:
        D.37657 = &MEM[(void *)"PropertyBuilder" + 1B];
        D.37658 = *D.37657;
        D.37659 = (int) D.37658;
        D.37660 = __s2 + 1;
        D.37661 = *D.37660;
        D.37662 = (int) D.37661;
        __result = D.37659 - D.37662;
        D.37663 = __s2_len > 1;
        D.37653 = __result == 0;
        D.37664 = D.37663 & D.37653;
        if (D.37664 != 0) goto <D.37665>; else goto <D.37666>;
        <D.37665>:
        D.37667 = &MEM[(void *)"PropertyBuilder" + 2B];
        D.37668 = *D.37667;
        D.37669 = (int) D.37668;
        D.37670 = __s2 + 2;
        D.37671 = *D.37670;
        D.37672 = (int) D.37671;
        __result = D.37669 - D.37672;
        D.37673 = __s2_len > 2;
        D.37653 = __result == 0;
        D.37674 = D.37673 & D.37653;
        if (D.37674 != 0) goto <D.37675>; else goto <D.37676>;
        <D.37675>:
        D.37677 = &MEM[(void *)"PropertyBuilder" + 3B];
        D.37678 = *D.37677;
        D.37679 = (int) D.37678;
        D.37680 = __s2 + 3;
        D.37681 = *D.37680;
        D.37682 = (int) D.37681;
        __result = D.37679 - D.37682;
        <D.37676>:
        <D.37666>:
        <D.37656>:
      }
      D.22779 = __result;
    }
    iftmp.567 = -D.22779;
    goto <D.37683>;
    <D.37646>:
    D.37684 = klass->name;
    iftmp.567 = __builtin_strcmp (D.37684, "PropertyBuilder");
    <D.37683>:
    D.22780 = iftmp.567;
  }
  if (D.22780 == 0) goto <D.37685>; else goto <D.37686>;
  <D.37685>:
  {
    struct MonoReflectionPropertyBuilder * pb;

    pb = prop;
    D.37687 = pb->name;
    D.37688 = mono_string_to_utf8 (D.37687);
    *name = D.37688;
    D.37689 = pb->type;
    D.37690 = mono_reflection_type_get_handle (D.37689);
    *type = D.37690;
  }
  goto <D.37691>;
  <D.37686>:
  {
    struct MonoReflectionProperty * p;

    p = prop;
    D.37692 = p->property;
    D.37693 = D.37692->name;
    D.37694 = monoeg_strdup (D.37693);
    *name = D.37694;
    D.37692 = p->property;
    D.37695 = D.37692->get;
    if (D.37695 != 0B) goto <D.37696>; else goto <D.37697>;
    <D.37696>:
    D.37692 = p->property;
    D.37695 = D.37692->get;
    D.37698 = mono_method_signature (D.37695);
    D.37699 = D.37698->ret;
    *type = D.37699;
    goto <D.37700>;
    <D.37697>:
    D.37692 = p->property;
    D.37701 = D.37692->set;
    D.37702 = mono_method_signature (D.37701);
    D.37692 = p->property;
    D.37701 = D.37692->set;
    D.37703 = mono_method_signature (D.37701);
    D.37704 = D.37703->param_count;
    D.37705 = (int) D.37704;
    D.37706 = D.37705 + -1;
    D.37707 = D.37702->params[D.37706];
    *type = D.37707;
    <D.37700>:
  }
  <D.37691>:
}


get_field_name_and_type (struct MonoObject * field, char * * name, struct MonoType * * type)
{
  struct MonoVTable * D.37708;
  int D.22797;
  int iftmp.568;
  int D.22796;
  const char[13] * D.37712;
  unsigned char D.37713;
  int D.37714;
  unsigned char D.37715;
  int D.37716;
  _Bool D.37717;
  _Bool D.37718;
  _Bool D.37719;
  const unsigned char * D.37722;
  unsigned char D.37723;
  int D.37724;
  const unsigned char * D.37725;
  unsigned char D.37726;
  int D.37727;
  _Bool D.37728;
  _Bool D.37729;
  const unsigned char * D.37732;
  unsigned char D.37733;
  int D.37734;
  const unsigned char * D.37735;
  unsigned char D.37736;
  int D.37737;
  _Bool D.37738;
  _Bool D.37739;
  const unsigned char * D.37742;
  unsigned char D.37743;
  int D.37744;
  const unsigned char * D.37745;
  unsigned char D.37746;
  int D.37747;
  const char * D.37749;
  struct MonoString * D.37752;
  char * D.37753;
  struct MonoObject * D.37754;
  struct MonoType * D.37755;
  struct MonoClassField * D.37757;
  const char * D.37758;
  gchar * D.37759;
  struct MonoType * D.37760;
  struct MonoClass * klass;

  D.37708 = field->vtable;
  klass = D.37708->klass;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = klass->name;
      D.37712 = "FieldBuilder";
      D.37713 = MEM[(const unsigned char *)D.37712];
      D.37714 = (int) D.37713;
      D.37715 = *__s2;
      D.37716 = (int) D.37715;
      __result = D.37714 - D.37716;
      {
        D.37717 = __s2_len != 0;
        D.37718 = __result == 0;
        D.37719 = D.37717 & D.37718;
        if (D.37719 != 0) goto <D.37720>; else goto <D.37721>;
        <D.37720>:
        D.37722 = &MEM[(void *)"FieldBuilder" + 1B];
        D.37723 = *D.37722;
        D.37724 = (int) D.37723;
        D.37725 = __s2 + 1;
        D.37726 = *D.37725;
        D.37727 = (int) D.37726;
        __result = D.37724 - D.37727;
        D.37728 = __s2_len > 1;
        D.37718 = __result == 0;
        D.37729 = D.37728 & D.37718;
        if (D.37729 != 0) goto <D.37730>; else goto <D.37731>;
        <D.37730>:
        D.37732 = &MEM[(void *)"FieldBuilder" + 2B];
        D.37733 = *D.37732;
        D.37734 = (int) D.37733;
        D.37735 = __s2 + 2;
        D.37736 = *D.37735;
        D.37737 = (int) D.37736;
        __result = D.37734 - D.37737;
        D.37738 = __s2_len > 2;
        D.37718 = __result == 0;
        D.37739 = D.37738 & D.37718;
        if (D.37739 != 0) goto <D.37740>; else goto <D.37741>;
        <D.37740>:
        D.37742 = &MEM[(void *)"FieldBuilder" + 3B];
        D.37743 = *D.37742;
        D.37744 = (int) D.37743;
        D.37745 = __s2 + 3;
        D.37746 = *D.37745;
        D.37747 = (int) D.37746;
        __result = D.37744 - D.37747;
        <D.37741>:
        <D.37731>:
        <D.37721>:
      }
      D.22796 = __result;
    }
    iftmp.568 = -D.22796;
    goto <D.37748>;
    <D.37711>:
    D.37749 = klass->name;
    iftmp.568 = __builtin_strcmp (D.37749, "FieldBuilder");
    <D.37748>:
    D.22797 = iftmp.568;
  }
  if (D.22797 == 0) goto <D.37750>; else goto <D.37751>;
  <D.37750>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = field;
    D.37752 = fb->name;
    D.37753 = mono_string_to_utf8 (D.37752);
    *name = D.37753;
    D.37754 = fb->type;
    D.37755 = mono_reflection_type_get_handle (D.37754);
    *type = D.37755;
  }
  goto <D.37756>;
  <D.37751>:
  {
    struct MonoReflectionField * f;

    f = field;
    D.37757 = f->field;
    D.37758 = mono_field_get_name (D.37757);
    D.37759 = monoeg_strdup (D.37758);
    *name = D.37759;
    D.37757 = f->field;
    D.37760 = D.37757->type;
    *type = D.37760;
  }
  <D.37756>:
}


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.37763;
  struct MonoClass * D.37765;
  unsigned char D.37766;
  unsigned char D.37767;
  long unsigned int D.37769;
  struct MonoType * D.37774;
  long unsigned int D.37775;
  long unsigned int D.37776;
  unsigned int D.37777;
  unsigned int len.569;
  unsigned int D.37779;
  char * p.570;
  long int p.571;
  char * buffer.572;
  long int buffer.573;
  long int D.37784;
  long int D.37785;
  long int D.37786;
  long int D.37787;
  unsigned int D.37788;
  long int D.37789;
  unsigned int D.37792;
  unsigned int len.574;
  unsigned int D.37794;
  long unsigned int D.37795;
  sizetype D.37796;
  char * p.575;
  long unsigned int D.37798;
  unsigned int len.576;
  long unsigned int D.37800;
  sizetype D.37801;
  char * p.577;
  struct MonoAssembly * D.37803;
  int len;

  D.37763 = type->type;
  if (D.37763 == 17) goto <D.37764>; else goto <D.37761>;
  <D.37764>:
  D.37765 = type->data.klass;
  D.37766 = BIT_FIELD_REF <*D.37765, 8, 256>;
  D.37767 = D.37766 & 16;
  if (D.37767 != 0) goto <D.37768>; else goto <D.37761>;
  <D.37768>:
  {
    char * str;

    str = type_get_qualified_name (type, 0B);
    D.37769 = strlen (str);
    len = (int) D.37769;
    monoeg_g_free (str);
  }
  goto <D.37762>;
  <D.37761>:
  D.37763 = type->type;
  if (D.37763 == 29) goto <D.37772>; else goto <D.37770>;
  <D.37772>:
  D.37765 = type->data.klass;
  D.37766 = BIT_FIELD_REF <*D.37765, 8, 256>;
  D.37767 = D.37766 & 16;
  if (D.37767 != 0) goto <D.37773>; else goto <D.37770>;
  <D.37773>:
  {
    char * str;

    D.37765 = type->data.klass;
    D.37774 = &D.37765->byval_arg;
    str = type_get_qualified_name (D.37774, 0B);
    D.37775 = strlen (str);
    len = (int) D.37775;
    monoeg_g_free (str);
  }
  goto <D.37771>;
  <D.37770>:
  len = 0;
  <D.37771>:
  <D.37762>:
  D.37776 = strlen (name);
  D.37777 = (unsigned int) D.37776;
  len.569 = (unsigned int) len;
  D.37779 = D.37777 + len.569;
  len = (int) D.37779;
  p.570 = p;
  p.571 = (long int) p.570;
  buffer.572 = buffer;
  buffer.573 = (long int) buffer.572;
  D.37784 = p.571 - buffer.573;
  D.37785 = D.37784 + 20;
  D.37786 = (long int) len;
  D.37787 = D.37785 + D.37786;
  D.37788 = *buflen;
  D.37789 = (long int) D.37788;
  if (D.37787 >= D.37789) goto <D.37790>; else goto <D.37791>;
  <D.37790>:
  {
    char * newbuf;

    D.37788 = *buflen;
    D.37792 = D.37788 * 2;
    *buflen = D.37792;
    D.37788 = *buflen;
    len.574 = (unsigned int) len;
    D.37794 = D.37788 + len.574;
    *buflen = D.37794;
    D.37788 = *buflen;
    D.37795 = (long unsigned int) D.37788;
    buffer.572 = buffer;
    newbuf = monoeg_realloc (buffer.572, D.37795);
    p.570 = p;
    p.571 = (long int) p.570;
    buffer.572 = buffer;
    buffer.573 = (long int) buffer.572;
    D.37784 = p.571 - buffer.573;
    D.37796 = (sizetype) D.37784;
    p.575 = newbuf + D.37796;
    p = p.575;
    buffer = newbuf;
  }
  <D.37791>:
  p.570 = p;
  encode_field_or_prop_type (type, p.570, &p);
  D.37798 = strlen (name);
  len = (int) D.37798;
  p.570 = p;
  len.576 = (unsigned int) len;
  mono_metadata_encode_value (len.576, p.570, &p);
  D.37800 = (long unsigned int) len;
  p.570 = p;
  memcpy (p.570, name, D.37800);
  p.570 = p;
  D.37801 = (sizetype) len;
  p.577 = p.570 + D.37801;
  p = p.577;
  p.570 = p;
  buffer.572 = buffer;
  D.37803 = assembly->assembly;
  encode_cattr_value (D.37803, buffer.572, p.570, &buffer, &p, buflen, type, value, 0B);
  p.570 = p;
  *retp = p.570;
  buffer.572 = buffer;
  *retbuffer = buffer.572;
}


encode_field_or_prop_type (struct MonoType * type, char * p, char * * retp)
{
  unsigned char D.37806;
  struct MonoClass * D.37808;
  unsigned char D.37809;
  unsigned char D.37810;
  long unsigned int D.37812;
  char * p.578;
  char * p.579;
  char * p.580;
  unsigned int slen.581;
  long unsigned int D.37817;
  sizetype D.37818;
  char * p.582;
  char * p.583;
  char * p.584;
  char * p.585;
  char * p.586;
  unsigned int D.37830;
  struct MonoType * D.37833;

  D.37806 = type->type;
  if (D.37806 == 17) goto <D.37807>; else goto <D.37804>;
  <D.37807>:
  D.37808 = type->data.klass;
  D.37809 = BIT_FIELD_REF <*D.37808, 8, 256>;
  D.37810 = D.37809 & 16;
  if (D.37810 != 0) goto <D.37811>; else goto <D.37804>;
  <D.37811>:
  {
    char * str;
    int slen;

    str = type_get_qualified_name (type, 0B);
    D.37812 = strlen (str);
    slen = (int) D.37812;
    p.578 = p;
    p.579 = p.578;
    p.580 = p.579 + 1;
    p = p.580;
    *p.579 = 85;
    p.578 = p;
    slen.581 = (unsigned int) slen;
    mono_metadata_encode_value (slen.581, p.578, &p);
    D.37817 = (long unsigned int) slen;
    p.578 = p;
    memcpy (p.578, str, D.37817);
    p.578 = p;
    D.37818 = (sizetype) slen;
    p.582 = p.578 + D.37818;
    p = p.582;
    monoeg_g_free (str);
  }
  goto <D.37805>;
  <D.37804>:
  D.37806 = type->type;
  if (D.37806 == 28) goto <D.37820>; else goto <D.37821>;
  <D.37820>:
  p.578 = p;
  p.583 = p.578;
  p.584 = p.583 + 1;
  p = p.584;
  *p.583 = 81;
  goto <D.37824>;
  <D.37821>:
  D.37806 = type->type;
  if (D.37806 == 18) goto <D.37825>; else goto <D.37826>;
  <D.37825>:
  p.578 = p;
  p.585 = p.578;
  p.586 = p.585 + 1;
  p = p.586;
  *p.585 = 80;
  goto <D.37829>;
  <D.37826>:
  p.578 = p;
  D.37806 = type->type;
  D.37830 = (unsigned int) D.37806;
  mono_metadata_encode_value (D.37830, p.578, &p);
  D.37806 = type->type;
  if (D.37806 == 29) goto <D.37831>; else goto <D.37832>;
  <D.37831>:
  p.578 = p;
  D.37808 = type->data.klass;
  D.37833 = &D.37808->byval_arg;
  encode_field_or_prop_type (D.37833, p.578, &p);
  <D.37832>:
  <D.37829>:
  <D.37824>:
  <D.37805>:
  p.578 = p;
  *retp = p.578;
}


mono_reflection_setup_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoObject * D.37834;
  struct MonoReflectionType * D.37835;
  int D.23099;
  int iftmp.587;
  int D.23098;
  struct MonoVTable * D.37841;
  struct MonoClass * D.37842;
  const char[12] * D.37843;
  unsigned char D.37844;
  int D.37845;
  unsigned char D.37846;
  int D.37847;
  _Bool D.37848;
  _Bool D.37849;
  _Bool D.37850;
  const unsigned char * D.37853;
  unsigned char D.37854;
  int D.37855;
  const unsigned char * D.37856;
  unsigned char D.37857;
  int D.37858;
  _Bool D.37859;
  _Bool D.37860;
  const unsigned char * D.37863;
  unsigned char D.37864;
  int D.37865;
  const unsigned char * D.37866;
  unsigned char D.37867;
  int D.37868;
  _Bool D.37869;
  _Bool D.37870;
  const unsigned char * D.37873;
  unsigned char D.37874;
  int D.37875;
  const unsigned char * D.37876;
  unsigned char D.37877;
  int D.37878;
  const char * D.37880;
  struct MonoType * D.37883;
  struct MonoType * D.37885;
  struct MonoType * D.37887;
  struct MonoReflectionModuleBuilder * D.37890;
  struct MonoDynamicImage * D.37891;
  struct MonoImage * D.37892;
  struct MonoString * D.37893;
  struct MonoImage * D.37894;
  char * D.37895;
  int D.37896;
  struct MonoString * D.37898;
  char * D.37899;
  int D.37900;
  unsigned int D.37902;
  unsigned int D.37903;
  unsigned int D.37904;
  void * D.37905;
  struct MonoReflectionType * D.37908;
  const char * D.37911;
  const char * D.37912;
  void * D.37914;
  _Bool D.37915;
  long int D.37916;
  long int D.37917;
  long unsigned int D.37920;
  void * D.37921;
  struct MonoGHashTable * D.37922;
  int D.23109;
  int iftmp.588;
  int D.23108;
  const char[7] * D.37929;
  unsigned char D.37930;
  int D.37931;
  unsigned char D.37932;
  int D.37933;
  _Bool D.37934;
  _Bool D.37935;
  _Bool D.37936;
  const unsigned char * D.37939;
  unsigned char D.37940;
  int D.37941;
  const unsigned char * D.37942;
  unsigned char D.37943;
  int D.37944;
  _Bool D.37945;
  _Bool D.37946;
  const unsigned char * D.37949;
  unsigned char D.37950;
  int D.37951;
  const unsigned char * D.37952;
  unsigned char D.37953;
  int D.37954;
  _Bool D.37955;
  _Bool D.37956;
  const unsigned char * D.37959;
  unsigned char D.37960;
  int D.37961;
  const unsigned char * D.37962;
  unsigned char D.37963;
  int D.37964;
  int D.23118;
  int iftmp.589;
  int D.23117;
  const char[7] * D.37971;
  unsigned char D.37972;
  int D.37973;
  unsigned char D.37974;
  int D.37975;
  _Bool D.37976;
  _Bool D.37977;
  _Bool D.37978;
  const unsigned char * D.37981;
  unsigned char D.37982;
  int D.37983;
  const unsigned char * D.37984;
  unsigned char D.37985;
  int D.37986;
  _Bool D.37987;
  _Bool D.37988;
  const unsigned char * D.37991;
  unsigned char D.37992;
  int D.37993;
  const unsigned char * D.37994;
  unsigned char D.37995;
  int D.37996;
  _Bool D.37997;
  _Bool D.37998;
  const unsigned char * D.38001;
  unsigned char D.38002;
  int D.38003;
  const unsigned char * D.38004;
  unsigned char D.38005;
  int D.38006;
  struct MonoClass * D.38010;
  int D.23128;
  int iftmp.590;
  int D.23127;
  const char[10] * D.38018;
  unsigned char D.38019;
  int D.38020;
  unsigned char D.38021;
  int D.38022;
  _Bool D.38023;
  _Bool D.38024;
  _Bool D.38025;
  const unsigned char * D.38028;
  unsigned char D.38029;
  int D.38030;
  const unsigned char * D.38031;
  unsigned char D.38032;
  int D.38033;
  _Bool D.38034;
  _Bool D.38035;
  const unsigned char * D.38038;
  unsigned char D.38039;
  int D.38040;
  const unsigned char * D.38041;
  unsigned char D.38042;
  int D.38043;
  _Bool D.38044;
  _Bool D.38045;
  const unsigned char * D.38048;
  unsigned char D.38049;
  int D.38050;
  const unsigned char * D.38051;
  unsigned char D.38052;
  int D.38053;
  int D.23137;
  int iftmp.591;
  int D.23136;
  unsigned char D.38059;
  int D.38060;
  _Bool D.38061;
  _Bool D.38062;
  _Bool D.38063;
  const unsigned char * D.38066;
  unsigned char D.38067;
  int D.38068;
  _Bool D.38069;
  _Bool D.38070;
  const unsigned char * D.38073;
  unsigned char D.38074;
  int D.38075;
  _Bool D.38076;
  _Bool D.38077;
  const unsigned char * D.38080;
  unsigned char D.38081;
  int D.38082;
  int D.23146;
  int iftmp.592;
  int D.23145;
  unsigned char D.38087;
  int D.38088;
  _Bool D.38089;
  _Bool D.38090;
  _Bool D.38091;
  const unsigned char * D.38094;
  unsigned char D.38095;
  int D.38096;
  _Bool D.38097;
  _Bool D.38098;
  const unsigned char * D.38101;
  unsigned char D.38102;
  int D.38103;
  _Bool D.38104;
  _Bool D.38105;
  const unsigned char * D.38108;
  unsigned char D.38109;
  int D.38110;
  int D.23155;
  int iftmp.593;
  int D.23154;
  unsigned char D.38116;
  int D.38117;
  _Bool D.38118;
  _Bool D.38119;
  _Bool D.38120;
  const unsigned char * D.38123;
  unsigned char D.38124;
  int D.38125;
  _Bool D.38126;
  _Bool D.38127;
  const unsigned char * D.38130;
  unsigned char D.38131;
  int D.38132;
  _Bool D.38133;
  _Bool D.38134;
  const unsigned char * D.38137;
  unsigned char D.38138;
  int D.38139;
  int D.23164;
  int iftmp.594;
  int D.23163;
  const char[5] * D.38144;
  unsigned char D.38145;
  int D.38146;
  unsigned char D.38147;
  int D.38148;
  _Bool D.38149;
  _Bool D.38150;
  _Bool D.38151;
  const unsigned char * D.38154;
  unsigned char D.38155;
  int D.38156;
  const unsigned char * D.38157;
  unsigned char D.38158;
  int D.38159;
  _Bool D.38160;
  _Bool D.38161;
  const unsigned char * D.38164;
  unsigned char D.38165;
  int D.38166;
  const unsigned char * D.38167;
  unsigned char D.38168;
  int D.38169;
  _Bool D.38170;
  _Bool D.38171;
  const unsigned char * D.38174;
  unsigned char D.38175;
  int D.38176;
  const unsigned char * D.38177;
  unsigned char D.38178;
  int D.38179;
  int D.23173;
  int iftmp.595;
  int D.23172;
  unsigned char D.38185;
  int D.38186;
  _Bool D.38187;
  _Bool D.38188;
  _Bool D.38189;
  const unsigned char * D.38192;
  unsigned char D.38193;
  int D.38194;
  _Bool D.38195;
  _Bool D.38196;
  const unsigned char * D.38199;
  unsigned char D.38200;
  int D.38201;
  _Bool D.38202;
  _Bool D.38203;
  const unsigned char * D.38206;
  unsigned char D.38207;
  int D.38208;
  struct MonoType * D.38210;
  struct MonoType * D.38213;
  _Bool D.38214;
  long int D.38215;
  long int D.38216;
  struct MonoType * D.38219;
  struct MonoClass * D.38220;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoClass * parent;
  void failure = <<< error >>>;

  try
    {
      D.37834 = tb->parent;
      D.37835 = mono_reflection_type_resolve_user_types (D.37834);
      tb->parent = D.37835;
      mono_loader_lock ();
      D.37834 = tb->parent;
      if (D.37834 != 0B) goto <D.37836>; else goto <D.37837>;
      <D.37836>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.37834 = tb->parent;
          D.37841 = D.37834->vtable;
          D.37842 = D.37841->klass;
          __s2 = D.37842->name;
          D.37843 = "TypeBuilder";
          D.37844 = MEM[(const unsigned char *)D.37843];
          D.37845 = (int) D.37844;
          D.37846 = *__s2;
          D.37847 = (int) D.37846;
          __result = D.37845 - D.37847;
          {
            D.37848 = __s2_len != 0;
            D.37849 = __result == 0;
            D.37850 = D.37848 & D.37849;
            if (D.37850 != 0) goto <D.37851>; else goto <D.37852>;
            <D.37851>:
            D.37853 = &MEM[(void *)"TypeBuilder" + 1B];
            D.37854 = *D.37853;
            D.37855 = (int) D.37854;
            D.37856 = __s2 + 1;
            D.37857 = *D.37856;
            D.37858 = (int) D.37857;
            __result = D.37855 - D.37858;
            D.37859 = __s2_len > 1;
            D.37849 = __result == 0;
            D.37860 = D.37859 & D.37849;
            if (D.37860 != 0) goto <D.37861>; else goto <D.37862>;
            <D.37861>:
            D.37863 = &MEM[(void *)"TypeBuilder" + 2B];
            D.37864 = *D.37863;
            D.37865 = (int) D.37864;
            D.37866 = __s2 + 2;
            D.37867 = *D.37866;
            D.37868 = (int) D.37867;
            __result = D.37865 - D.37868;
            D.37869 = __s2_len > 2;
            D.37849 = __result == 0;
            D.37870 = D.37869 & D.37849;
            if (D.37870 != 0) goto <D.37871>; else goto <D.37872>;
            <D.37871>:
            D.37873 = &MEM[(void *)"TypeBuilder" + 3B];
            D.37874 = *D.37873;
            D.37875 = (int) D.37874;
            D.37876 = __s2 + 3;
            D.37877 = *D.37876;
            D.37878 = (int) D.37877;
            __result = D.37875 - D.37878;
            <D.37872>:
            <D.37862>:
            <D.37852>:
          }
          D.23098 = __result;
        }
        iftmp.587 = -D.23098;
        goto <D.37879>;
        <D.37840>:
        D.37834 = tb->parent;
        D.37841 = D.37834->vtable;
        D.37842 = D.37841->klass;
        D.37880 = D.37842->name;
        iftmp.587 = __builtin_strcmp (D.37880, "TypeBuilder");
        <D.37879>:
        D.23099 = iftmp.587;
      }
      if (D.23099 == 0) goto <D.37881>; else goto <D.37882>;
      <D.37881>:
      D.37834 = tb->parent;
      D.37883 = mono_reflection_type_get_handle (D.37834);
      parent = D.37883->data.klass;
      goto <D.37884>;
      <D.37882>:
      D.37834 = tb->parent;
      D.37885 = mono_reflection_type_get_handle (D.37834);
      parent = mono_class_from_mono_type (D.37885);
      <D.37884>:
      goto <D.37886>;
      <D.37837>:
      parent = 0B;
      <D.37886>:
      D.37887 = tb->type.type;
      if (D.37887 != 0B) goto <D.37888>; else goto <D.37889>;
      <D.37888>:
      D.37887 = tb->type.type;
      klass = mono_class_from_mono_type (D.37887);
      klass->parent = 0B;
      klass->supertypes = 0B;
      mono_class_setup_parent (klass, parent);
      mono_class_setup_mono_type (klass);
      mono_loader_unlock ();
      return;
      <D.37889>:
      D.37890 = tb->module;
      D.37891 = D.37890->dynamic_image;
      D.37892 = &D.37891->image;
      klass = mono_image_alloc0 (D.37892, 272);
      D.37890 = tb->module;
      D.37891 = D.37890->dynamic_image;
      D.37892 = &D.37891->image;
      klass->image = D.37892;
      klass->inited = 1;
      D.37893 = tb->name;
      D.37894 = klass->image;
      D.37895 = mono_string_to_utf8_image (D.37894, D.37893, &error);
      klass->name = D.37895;
      D.37896 = mono_error_ok (&error);
      if (D.37896 == 0) goto failure; else goto <D.37897>;
      <D.37897>:
      D.37898 = tb->nspace;
      D.37894 = klass->image;
      D.37899 = mono_string_to_utf8_image (D.37894, D.37898, &error);
      klass->name_space = D.37899;
      D.37900 = mono_error_ok (&error);
      if (D.37900 == 0) goto failure; else goto <D.37901>;
      <D.37901>:
      D.37902 = tb->table_idx;
      D.37903 = D.37902 | 33554432;
      klass->type_token = D.37903;
      D.37904 = tb->attrs;
      klass->flags = D.37904;
      mono_profiler_class_event (klass, 0);
      klass->element_class = klass;
      D.37905 = mono_class_get_ref_info (klass);
      if (D.37905 == 0B) goto <D.37906>; else goto <D.37907>;
      <D.37906>:
      mono_class_set_ref_info (klass, tb);
      D.37908 = tb->nesting_type;
      if (D.37908 == 0B) goto <D.37909>; else goto <D.37910>;
      <D.37909>:
      D.37902 = tb->table_idx;
      D.37911 = klass->name;
      D.37912 = klass->name_space;
      D.37894 = klass->image;
      mono_image_add_to_name_cache (D.37894, D.37912, D.37911, D.37902);
      <D.37910>:
      mono_image_append_class_to_reflection_info_set (klass);
      goto <D.37913>;
      <D.37907>:
      D.37914 = mono_class_get_ref_info (klass);
      D.37915 = D.37914 != tb;
      D.37916 = (long int) D.37915;
      D.37917 = __builtin_expect (D.37916, 0);
      if (D.37917 != 0) goto <D.37918>; else goto <D.37919>;
      <D.37918>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9854, "mono_class_get_ref_info (klass) == tb");
      <D.37919>:
      <D.37913>:
      D.37902 = tb->table_idx;
      D.37903 = D.37902 | 33554432;
      D.37920 = (long unsigned int) D.37903;
      D.37921 = (void *) D.37920;
      D.37890 = tb->module;
      D.37891 = D.37890->dynamic_image;
      D.37922 = D.37891->tokens;
      mono_g_hash_table_insert (D.37922, D.37921, tb);
      if (parent != 0B) goto <D.37923>; else goto <D.37924>;
      <D.37923>:
      mono_class_setup_parent (klass, parent);
      goto <D.37925>;
      <D.37924>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37929 = "Object";
          D.37930 = MEM[(const unsigned char *)D.37929];
          D.37931 = (int) D.37930;
          D.37932 = *__s2;
          D.37933 = (int) D.37932;
          __result = D.37931 - D.37933;
          {
            D.37934 = __s2_len != 0;
            D.37935 = __result == 0;
            D.37936 = D.37934 & D.37935;
            if (D.37936 != 0) goto <D.37937>; else goto <D.37938>;
            <D.37937>:
            D.37939 = &MEM[(void *)"Object" + 1B];
            D.37940 = *D.37939;
            D.37941 = (int) D.37940;
            D.37942 = __s2 + 1;
            D.37943 = *D.37942;
            D.37944 = (int) D.37943;
            __result = D.37941 - D.37944;
            D.37945 = __s2_len > 1;
            D.37935 = __result == 0;
            D.37946 = D.37945 & D.37935;
            if (D.37946 != 0) goto <D.37947>; else goto <D.37948>;
            <D.37947>:
            D.37949 = &MEM[(void *)"Object" + 2B];
            D.37950 = *D.37949;
            D.37951 = (int) D.37950;
            D.37952 = __s2 + 2;
            D.37953 = *D.37952;
            D.37954 = (int) D.37953;
            __result = D.37951 - D.37954;
            D.37955 = __s2_len > 2;
            D.37935 = __result == 0;
            D.37956 = D.37955 & D.37935;
            if (D.37956 != 0) goto <D.37957>; else goto <D.37958>;
            <D.37957>:
            D.37959 = &MEM[(void *)"Object" + 3B];
            D.37960 = *D.37959;
            D.37961 = (int) D.37960;
            D.37962 = __s2 + 3;
            D.37963 = *D.37962;
            D.37964 = (int) D.37963;
            __result = D.37961 - D.37964;
            <D.37958>:
            <D.37948>:
            <D.37938>:
          }
          D.23108 = __result;
        }
        iftmp.588 = -D.23108;
        goto <D.37965>;
        <D.37928>:
        D.37911 = klass->name;
        iftmp.588 = __builtin_strcmp (D.37911, "Object");
        <D.37965>:
        D.23109 = iftmp.588;
      }
      if (D.23109 == 0) goto <D.37966>; else goto <D.37967>;
      <D.37966>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37971 = "System";
          D.37972 = MEM[(const unsigned char *)D.37971];
          D.37973 = (int) D.37972;
          D.37974 = *__s2;
          D.37975 = (int) D.37974;
          __result = D.37973 - D.37975;
          {
            D.37976 = __s2_len != 0;
            D.37977 = __result == 0;
            D.37978 = D.37976 & D.37977;
            if (D.37978 != 0) goto <D.37979>; else goto <D.37980>;
            <D.37979>:
            D.37981 = &MEM[(void *)"System" + 1B];
            D.37982 = *D.37981;
            D.37983 = (int) D.37982;
            D.37984 = __s2 + 1;
            D.37985 = *D.37984;
            D.37986 = (int) D.37985;
            __result = D.37983 - D.37986;
            D.37987 = __s2_len > 1;
            D.37977 = __result == 0;
            D.37988 = D.37987 & D.37977;
            if (D.37988 != 0) goto <D.37989>; else goto <D.37990>;
            <D.37989>:
            D.37991 = &MEM[(void *)"System" + 2B];
            D.37992 = *D.37991;
            D.37993 = (int) D.37992;
            D.37994 = __s2 + 2;
            D.37995 = *D.37994;
            D.37996 = (int) D.37995;
            __result = D.37993 - D.37996;
            D.37997 = __s2_len > 2;
            D.37977 = __result == 0;
            D.37998 = D.37997 & D.37977;
            if (D.37998 != 0) goto <D.37999>; else goto <D.38000>;
            <D.37999>:
            D.38001 = &MEM[(void *)"System" + 3B];
            D.38002 = *D.38001;
            D.38003 = (int) D.38002;
            D.38004 = __s2 + 3;
            D.38005 = *D.38004;
            D.38006 = (int) D.38005;
            __result = D.38003 - D.38006;
            <D.38000>:
            <D.37990>:
            <D.37980>:
          }
          D.23117 = __result;
        }
        iftmp.589 = -D.23117;
        goto <D.38007>;
        <D.37970>:
        D.37912 = klass->name_space;
        iftmp.589 = __builtin_strcmp (D.37912, "System");
        <D.38007>:
        D.23118 = iftmp.589;
      }
      if (D.23118 == 0) goto <D.38008>; else goto <D.38009>;
      <D.38008>:
      {
        const char * old_n;

        old_n = klass->name;
        klass->name = "BuildingObject";
        D.38010 = mono_defaults.object_class;
        mono_class_setup_parent (klass, D.38010);
        klass->name = old_n;
      }
      <D.38009>:
      <D.37967>:
      <D.37925>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38018 = "ValueType";
          D.38019 = MEM[(const unsigned char *)D.38018];
          D.38020 = (int) D.38019;
          D.38021 = *__s2;
          D.38022 = (int) D.38021;
          __result = D.38020 - D.38022;
          {
            D.38023 = __s2_len != 0;
            D.38024 = __result == 0;
            D.38025 = D.38023 & D.38024;
            if (D.38025 != 0) goto <D.38026>; else goto <D.38027>;
            <D.38026>:
            D.38028 = &MEM[(void *)"ValueType" + 1B];
            D.38029 = *D.38028;
            D.38030 = (int) D.38029;
            D.38031 = __s2 + 1;
            D.38032 = *D.38031;
            D.38033 = (int) D.38032;
            __result = D.38030 - D.38033;
            D.38034 = __s2_len > 1;
            D.38024 = __result == 0;
            D.38035 = D.38034 & D.38024;
            if (D.38035 != 0) goto <D.38036>; else goto <D.38037>;
            <D.38036>:
            D.38038 = &MEM[(void *)"ValueType" + 2B];
            D.38039 = *D.38038;
            D.38040 = (int) D.38039;
            D.38041 = __s2 + 2;
            D.38042 = *D.38041;
            D.38043 = (int) D.38042;
            __result = D.38040 - D.38043;
            D.38044 = __s2_len > 2;
            D.38024 = __result == 0;
            D.38045 = D.38044 & D.38024;
            if (D.38045 != 0) goto <D.38046>; else goto <D.38047>;
            <D.38046>:
            D.38048 = &MEM[(void *)"ValueType" + 3B];
            D.38049 = *D.38048;
            D.38050 = (int) D.38049;
            D.38051 = __s2 + 3;
            D.38052 = *D.38051;
            D.38053 = (int) D.38052;
            __result = D.38050 - D.38053;
            <D.38047>:
            <D.38037>:
            <D.38027>:
          }
          D.23127 = __result;
        }
        iftmp.590 = -D.23127;
        goto <D.38054>;
        <D.38017>:
        D.37911 = klass->name;
        iftmp.590 = __builtin_strcmp (D.37911, "ValueType");
        <D.38054>:
        D.23128 = iftmp.590;
      }
      if (D.23128 == 0) goto <D.38055>; else goto <D.38011>;
      <D.38055>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37971 = "System";
          D.37972 = MEM[(const unsigned char *)D.37971];
          D.37973 = (int) D.37972;
          D.38059 = *__s2;
          D.38060 = (int) D.38059;
          __result = D.37973 - D.38060;
          {
            D.38061 = __s2_len != 0;
            D.38062 = __result == 0;
            D.38063 = D.38061 & D.38062;
            if (D.38063 != 0) goto <D.38064>; else goto <D.38065>;
            <D.38064>:
            D.37981 = &MEM[(void *)"System" + 1B];
            D.37982 = *D.37981;
            D.37983 = (int) D.37982;
            D.38066 = __s2 + 1;
            D.38067 = *D.38066;
            D.38068 = (int) D.38067;
            __result = D.37983 - D.38068;
            D.38069 = __s2_len > 1;
            D.38062 = __result == 0;
            D.38070 = D.38069 & D.38062;
            if (D.38070 != 0) goto <D.38071>; else goto <D.38072>;
            <D.38071>:
            D.37991 = &MEM[(void *)"System" + 2B];
            D.37992 = *D.37991;
            D.37993 = (int) D.37992;
            D.38073 = __s2 + 2;
            D.38074 = *D.38073;
            D.38075 = (int) D.38074;
            __result = D.37993 - D.38075;
            D.38076 = __s2_len > 2;
            D.38062 = __result == 0;
            D.38077 = D.38076 & D.38062;
            if (D.38077 != 0) goto <D.38078>; else goto <D.38079>;
            <D.38078>:
            D.38001 = &MEM[(void *)"System" + 3B];
            D.38002 = *D.38001;
            D.38003 = (int) D.38002;
            D.38080 = __s2 + 3;
            D.38081 = *D.38080;
            D.38082 = (int) D.38081;
            __result = D.38003 - D.38082;
            <D.38079>:
            <D.38072>:
            <D.38065>:
          }
          D.23136 = __result;
        }
        iftmp.591 = -D.23136;
        goto <D.38083>;
        <D.38058>:
        D.37912 = klass->name_space;
        iftmp.591 = __builtin_strcmp (D.37912, "System");
        <D.38083>:
        D.23137 = iftmp.591;
      }
      if (D.23137 == 0) goto <D.38012>; else goto <D.38011>;
      <D.38011>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.37929 = "Object";
          D.37930 = MEM[(const unsigned char *)D.37929];
          D.37931 = (int) D.37930;
          D.38087 = *__s2;
          D.38088 = (int) D.38087;
          __result = D.37931 - D.38088;
          {
            D.38089 = __s2_len != 0;
            D.38090 = __result == 0;
            D.38091 = D.38089 & D.38090;
            if (D.38091 != 0) goto <D.38092>; else goto <D.38093>;
            <D.38092>:
            D.37939 = &MEM[(void *)"Object" + 1B];
            D.37940 = *D.37939;
            D.37941 = (int) D.37940;
            D.38094 = __s2 + 1;
            D.38095 = *D.38094;
            D.38096 = (int) D.38095;
            __result = D.37941 - D.38096;
            D.38097 = __s2_len > 1;
            D.38090 = __result == 0;
            D.38098 = D.38097 & D.38090;
            if (D.38098 != 0) goto <D.38099>; else goto <D.38100>;
            <D.38099>:
            D.37949 = &MEM[(void *)"Object" + 2B];
            D.37950 = *D.37949;
            D.37951 = (int) D.37950;
            D.38101 = __s2 + 2;
            D.38102 = *D.38101;
            D.38103 = (int) D.38102;
            __result = D.37951 - D.38103;
            D.38104 = __s2_len > 2;
            D.38090 = __result == 0;
            D.38105 = D.38104 & D.38090;
            if (D.38105 != 0) goto <D.38106>; else goto <D.38107>;
            <D.38106>:
            D.37959 = &MEM[(void *)"Object" + 3B];
            D.37960 = *D.37959;
            D.37961 = (int) D.37960;
            D.38108 = __s2 + 3;
            D.38109 = *D.38108;
            D.38110 = (int) D.38109;
            __result = D.37961 - D.38110;
            <D.38107>:
            <D.38100>:
            <D.38093>:
          }
          D.23145 = __result;
        }
        iftmp.592 = -D.23145;
        goto <D.38111>;
        <D.38086>:
        D.37911 = klass->name;
        iftmp.592 = __builtin_strcmp (D.37911, "Object");
        <D.38111>:
        D.23146 = iftmp.592;
      }
      if (D.23146 == 0) goto <D.38112>; else goto <D.38013>;
      <D.38112>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37971 = "System";
          D.37972 = MEM[(const unsigned char *)D.37971];
          D.37973 = (int) D.37972;
          D.38116 = *__s2;
          D.38117 = (int) D.38116;
          __result = D.37973 - D.38117;
          {
            D.38118 = __s2_len != 0;
            D.38119 = __result == 0;
            D.38120 = D.38118 & D.38119;
            if (D.38120 != 0) goto <D.38121>; else goto <D.38122>;
            <D.38121>:
            D.37981 = &MEM[(void *)"System" + 1B];
            D.37982 = *D.37981;
            D.37983 = (int) D.37982;
            D.38123 = __s2 + 1;
            D.38124 = *D.38123;
            D.38125 = (int) D.38124;
            __result = D.37983 - D.38125;
            D.38126 = __s2_len > 1;
            D.38119 = __result == 0;
            D.38127 = D.38126 & D.38119;
            if (D.38127 != 0) goto <D.38128>; else goto <D.38129>;
            <D.38128>:
            D.37991 = &MEM[(void *)"System" + 2B];
            D.37992 = *D.37991;
            D.37993 = (int) D.37992;
            D.38130 = __s2 + 2;
            D.38131 = *D.38130;
            D.38132 = (int) D.38131;
            __result = D.37993 - D.38132;
            D.38133 = __s2_len > 2;
            D.38119 = __result == 0;
            D.38134 = D.38133 & D.38119;
            if (D.38134 != 0) goto <D.38135>; else goto <D.38136>;
            <D.38135>:
            D.38001 = &MEM[(void *)"System" + 3B];
            D.38002 = *D.38001;
            D.38003 = (int) D.38002;
            D.38137 = __s2 + 3;
            D.38138 = *D.38137;
            D.38139 = (int) D.38138;
            __result = D.38003 - D.38139;
            <D.38136>:
            <D.38129>:
            <D.38122>:
          }
          D.23154 = __result;
        }
        iftmp.593 = -D.23154;
        goto <D.38140>;
        <D.38115>:
        D.37912 = klass->name_space;
        iftmp.593 = __builtin_strcmp (D.37912, "System");
        <D.38140>:
        D.23155 = iftmp.593;
      }
      if (D.23155 == 0) goto <D.38012>; else goto <D.38013>;
      <D.38013>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name;
          D.38144 = "Enum";
          D.38145 = MEM[(const unsigned char *)D.38144];
          D.38146 = (int) D.38145;
          D.38147 = *__s2;
          D.38148 = (int) D.38147;
          __result = D.38146 - D.38148;
          {
            D.38149 = __s2_len != 0;
            D.38150 = __result == 0;
            D.38151 = D.38149 & D.38150;
            if (D.38151 != 0) goto <D.38152>; else goto <D.38153>;
            <D.38152>:
            D.38154 = &MEM[(void *)"Enum" + 1B];
            D.38155 = *D.38154;
            D.38156 = (int) D.38155;
            D.38157 = __s2 + 1;
            D.38158 = *D.38157;
            D.38159 = (int) D.38158;
            __result = D.38156 - D.38159;
            D.38160 = __s2_len > 1;
            D.38150 = __result == 0;
            D.38161 = D.38160 & D.38150;
            if (D.38161 != 0) goto <D.38162>; else goto <D.38163>;
            <D.38162>:
            D.38164 = &MEM[(void *)"Enum" + 2B];
            D.38165 = *D.38164;
            D.38166 = (int) D.38165;
            D.38167 = __s2 + 2;
            D.38168 = *D.38167;
            D.38169 = (int) D.38168;
            __result = D.38166 - D.38169;
            D.38170 = __s2_len > 2;
            D.38150 = __result == 0;
            D.38171 = D.38170 & D.38150;
            if (D.38171 != 0) goto <D.38172>; else goto <D.38173>;
            <D.38172>:
            D.38174 = &MEM[(void *)"Enum" + 3B];
            D.38175 = *D.38174;
            D.38176 = (int) D.38175;
            D.38177 = __s2 + 3;
            D.38178 = *D.38177;
            D.38179 = (int) D.38178;
            __result = D.38176 - D.38179;
            <D.38173>:
            <D.38163>:
            <D.38153>:
          }
          D.23163 = __result;
        }
        iftmp.594 = -D.23163;
        goto <D.38180>;
        <D.38143>:
        D.37911 = klass->name;
        iftmp.594 = __builtin_strcmp (D.37911, "Enum");
        <D.38180>:
        D.23164 = iftmp.594;
      }
      if (D.23164 == 0) goto <D.38181>; else goto <D.38014>;
      <D.38181>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = klass->name_space;
          D.37971 = "System";
          D.37972 = MEM[(const unsigned char *)D.37971];
          D.37973 = (int) D.37972;
          D.38185 = *__s2;
          D.38186 = (int) D.38185;
          __result = D.37973 - D.38186;
          {
            D.38187 = __s2_len != 0;
            D.38188 = __result == 0;
            D.38189 = D.38187 & D.38188;
            if (D.38189 != 0) goto <D.38190>; else goto <D.38191>;
            <D.38190>:
            D.37981 = &MEM[(void *)"System" + 1B];
            D.37982 = *D.37981;
            D.37983 = (int) D.37982;
            D.38192 = __s2 + 1;
            D.38193 = *D.38192;
            D.38194 = (int) D.38193;
            __result = D.37983 - D.38194;
            D.38195 = __s2_len > 1;
            D.38188 = __result == 0;
            D.38196 = D.38195 & D.38188;
            if (D.38196 != 0) goto <D.38197>; else goto <D.38198>;
            <D.38197>:
            D.37991 = &MEM[(void *)"System" + 2B];
            D.37992 = *D.37991;
            D.37993 = (int) D.37992;
            D.38199 = __s2 + 2;
            D.38200 = *D.38199;
            D.38201 = (int) D.38200;
            __result = D.37993 - D.38201;
            D.38202 = __s2_len > 2;
            D.38188 = __result == 0;
            D.38203 = D.38202 & D.38188;
            if (D.38203 != 0) goto <D.38204>; else goto <D.38205>;
            <D.38204>:
            D.38001 = &MEM[(void *)"System" + 3B];
            D.38002 = *D.38001;
            D.38003 = (int) D.38002;
            D.38206 = __s2 + 3;
            D.38207 = *D.38206;
            D.38208 = (int) D.38207;
            __result = D.38003 - D.38208;
            <D.38205>:
            <D.38198>:
            <D.38191>:
          }
          D.23172 = __result;
        }
        iftmp.595 = -D.23172;
        goto <D.38209>;
        <D.38184>:
        D.37912 = klass->name_space;
        iftmp.595 = __builtin_strcmp (D.37912, "System");
        <D.38209>:
        D.23173 = iftmp.595;
      }
      if (D.23173 == 0) goto <D.38012>; else goto <D.38014>;
      <D.38012>:
      klass->instance_size = 16;
      klass->size_inited = 1;
      mono_class_setup_vtable_general (klass, 0B, 0, 0B);
      <D.38014>:
      mono_class_setup_mono_type (klass);
      mono_class_setup_supertypes (klass);
      D.38210 = &klass->byval_arg;
      tb->type.type = D.38210;
      D.37908 = tb->nesting_type;
      if (D.37908 != 0B) goto <D.38211>; else goto <D.38212>;
      <D.38211>:
      D.37908 = tb->nesting_type;
      D.38213 = D.37908->type;
      D.38214 = D.38213 == 0B;
      D.38215 = (long int) D.38214;
      D.38216 = __builtin_expect (D.38215, 0);
      if (D.38216 != 0) goto <D.38217>; else goto <D.38218>;
      <D.38217>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9889, "tb->nesting_type->type");
      <D.38218>:
      D.37908 = tb->nesting_type;
      D.38219 = mono_reflection_type_get_handle (D.37908);
      D.38220 = mono_class_from_mono_type (D.38219);
      klass->nested_in = D.38220;
      <D.38212>:
      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.38224;
  int iftmp.596;
  struct MonoArray * D.38226;
  long unsigned int D.38229;
  struct MonoGenericContainer * D.38233;
  int iftmp.597;
  struct MonoGenericContainer * D.38239;
  struct MonoClass * D.38241;
  _Bool D.38242;
  long int D.38243;
  long int D.38244;
  struct MonoImage * D.38247;
  void * D.38248;
  <unnamed-signed:31> D.38249;
  long unsigned int D.38250;
  unsigned int D.38251;
  unsigned int D.38252;
  void * D.38253;
  long unsigned int D.38254;
  char * D.38255;
  struct MonoType * D.38256;
  struct MonoGenericParamFull * D.38257;
  long unsigned int D.38258;
  long unsigned int D.38259;
  struct MonoGenericParamFull * D.38260;
  unsigned int D.38261;
  short unsigned int D.38262;
  struct MonoGenericContainer * D.38263;
  _Bool D.38264;
  long int D.38265;
  long int D.38266;
  struct MonoGenericInst * D.38269;
  struct MonoClass * klass;
  int count;
  int i;

  D.38224 = tb->type.type;
  klass = mono_class_from_mono_type (D.38224);
  D.38226 = tb->generic_params;
  if (D.38226 != 0B) goto <D.38227>; else goto <D.38228>;
  <D.38227>:
  D.38226 = tb->generic_params;
  D.38229 = mono_array_length (D.38226);
  iftmp.596 = (int) D.38229;
  goto <D.38230>;
  <D.38228>:
  iftmp.596 = 0;
  <D.38230>:
  count = iftmp.596;
  D.38233 = klass->generic_container;
  if (D.38233 != 0B) goto <D.38231>; else goto <D.38234>;
  <D.38234>:
  if (count == 0) goto <D.38231>; else goto <D.38232>;
  <D.38231>:
  return;
  <D.38232>:
  D.38239 = tb->generic_container;
  if (D.38239 == 0B) goto <D.38236>; else goto <D.38240>;
  <D.38240>:
  D.38239 = tb->generic_container;
  D.38241 = D.38239->owner.klass;
  if (D.38241 != klass) goto <D.38236>; else goto <D.38237>;
  <D.38236>:
  iftmp.597 = 1;
  goto <D.38238>;
  <D.38237>:
  iftmp.597 = 0;
  <D.38238>:
  D.38242 = iftmp.597 != 0;
  D.38243 = (long int) D.38242;
  D.38244 = __builtin_expect (D.38243, 0);
  if (D.38244 != 0) goto <D.38245>; else goto <D.38246>;
  <D.38245>:
  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.38246>:
  D.38247 = klass->image;
  D.38248 = mono_image_alloc0 (D.38247, 56);
  klass->generic_container = D.38248;
  D.38233 = klass->generic_container;
  D.38233->owner.klass = klass;
  D.38233 = klass->generic_container;
  D.38249 = (<unnamed-signed:31>) count;
  D.38233->type_argc = D.38249;
  D.38233 = klass->generic_container;
  D.38250 = (long unsigned int) count;
  D.38251 = (unsigned int) D.38250;
  D.38252 = D.38251 * 56;
  D.38247 = klass->image;
  D.38253 = mono_image_alloc0 (D.38247, D.38252);
  D.38233->type_params = D.38253;
  klass->is_generic = 1;
  i = 0;
  goto <D.23186>;
  <D.23185>:
  {
    struct MonoReflectionGenericParam * gparam;
    struct MonoGenericParamFull * param;

    D.38254 = (long unsigned int) i;
    D.38226 = tb->generic_params;
    D.38255 = mono_array_addr_with_size (D.38226, 8, D.38254);
    gparam = MEM[(void * *)D.38255];
    D.38256 = mono_reflection_type_get_handle (gparam);
    param = D.38256->data.generic_param;
    D.38233 = klass->generic_container;
    D.38257 = D.38233->type_params;
    D.38258 = (long unsigned int) i;
    D.38259 = D.38258 * 56;
    D.38260 = D.38257 + D.38259;
    *D.38260 = *param;
    D.38233 = klass->generic_container;
    D.38257 = D.38233->type_params;
    D.38258 = (long unsigned int) i;
    D.38259 = D.38258 * 56;
    D.38260 = D.38257 + D.38259;
    D.38233 = klass->generic_container;
    D.38260->param.owner = D.38233;
    D.38233 = klass->generic_container;
    D.38257 = D.38233->type_params;
    D.38258 = (long unsigned int) i;
    D.38259 = D.38258 * 56;
    D.38260 = D.38257 + D.38259;
    D.38260->info.pklass = 0B;
    D.38233 = klass->generic_container;
    D.38257 = D.38233->type_params;
    D.38258 = (long unsigned int) i;
    D.38259 = D.38258 * 56;
    D.38260 = D.38257 + D.38259;
    D.38261 = gparam->attrs;
    D.38262 = (short unsigned int) D.38261;
    D.38260->info.flags = D.38262;
    D.38233 = klass->generic_container;
    D.38257 = D.38233->type_params;
    D.38258 = (long unsigned int) i;
    D.38259 = D.38258 * 56;
    D.38260 = D.38257 + D.38259;
    D.38263 = D.38260->param.owner;
    D.38264 = D.38263 == 0B;
    D.38265 = (long int) D.38264;
    D.38266 = __builtin_expect (D.38265, 0);
    if (D.38266 != 0) goto <D.38267>; else goto <D.38268>;
    <D.38267>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9956, "klass->generic_container->type_params [i].param.owner");
    <D.38268>:
  }
  i = i + 1;
  <D.23186>:
  if (i < count) goto <D.23185>; else goto <D.23187>;
  <D.23187>:
  D.38233 = klass->generic_container;
  D.38233 = klass->generic_container;
  D.38269 = mono_get_shared_generic_inst (D.38233);
  D.38233->context.class_inst = D.38269;
}


mono_reflection_create_internal_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoType * D.38271;
  unsigned char D.38272;
  unsigned char D.38273;
  struct MonoType * D.38276;
  struct MonoArray * D.38279;
  _Bool D.38280;
  long int D.38281;
  long int D.38282;
  long unsigned int D.38285;
  _Bool D.38286;
  long int D.38287;
  long int D.38288;
  char * D.38291;
  struct MonoObject * D.38292;
  struct MonoType * D.38293;
  int D.38294;
  struct MonoClass * D.38297;
  struct MonoClass * D.38298;
  struct MonoClass * D.38301;
  int D.38302;
  struct MonoClass * klass;

  D.38271 = tb->type.type;
  klass = mono_class_from_mono_type (D.38271);
  mono_loader_lock ();
  D.38272 = BIT_FIELD_REF <*klass, 8, 256>;
  D.38273 = D.38272 & 16;
  if (D.38273 != 0) goto <D.38274>; else goto <D.38275>;
  <D.38274>:
  D.38276 = mono_class_enum_basetype (klass);
  if (D.38276 == 0B) goto <D.38277>; else goto <D.38278>;
  <D.38277>:
  {
    struct MonoReflectionFieldBuilder * fb;
    struct MonoClass * ec;
    struct MonoType * enum_basetype;

    D.38279 = tb->fields;
    D.38280 = D.38279 == 0B;
    D.38281 = (long int) D.38280;
    D.38282 = __builtin_expect (D.38281, 0);
    if (D.38282 != 0) goto <D.38283>; else goto <D.38284>;
    <D.38283>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9983, "tb->fields != NULL");
    <D.38284>:
    D.38279 = tb->fields;
    D.38285 = mono_array_length (D.38279);
    D.38286 = D.38285 == 0;
    D.38287 = (long int) D.38286;
    D.38288 = __builtin_expect (D.38287, 0);
    if (D.38288 != 0) goto <D.38289>; else goto <D.38290>;
    <D.38289>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 9984, "mono_array_length (tb->fields) >= 1");
    <D.38290>:
    D.38279 = tb->fields;
    D.38291 = mono_array_addr_with_size (D.38279, 8, 0);
    fb = MEM[(struct MonoReflectionFieldBuilder * *)D.38291];
    D.38292 = fb->type;
    D.38293 = mono_reflection_type_get_handle (D.38292);
    D.38294 = mono_type_is_valid_enum_basetype (D.38293);
    if (D.38294 == 0) goto <D.38295>; else goto <D.38296>;
    <D.38295>:
    mono_loader_unlock ();
    return;
    <D.38296>:
    D.38292 = fb->type;
    enum_basetype = mono_reflection_type_get_handle (D.38292);
    D.38297 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.38297;
    D.38298 = klass->element_class;
    if (D.38298 == 0B) goto <D.38299>; else goto <D.38300>;
    <D.38299>:
    D.38301 = mono_class_from_mono_type (enum_basetype);
    klass->element_class = D.38301;
    <D.38300>:
    ec = default_class_from_mono_type (enum_basetype);
    D.38302 = ec->instance_size;
    klass->instance_size = D.38302;
    klass->size_inited = 1;
    mono_class_setup_vtable_general (klass, 0B, 0, 0B);
  }
  <D.38278>:
  <D.38275>:
  mono_loader_unlock ();
}


default_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.38304;
  int D.38305;
  struct MonoClass * D.38306;

  D.38304 = type->type;
  D.38305 = (int) D.38304;
  switch (D.38305) <default: <D.18813>, case 1: <D.18797>, case 2: <D.18798>, case 3: <D.18799>, case 4: <D.18800>, case 5: <D.18801>, case 6: <D.18802>, case 7: <D.18803>, case 8: <D.18804>, case 9: <D.18805>, case 10: <D.18808>, case 11: <D.18809>, case 12: <D.18810>, case 13: <D.18811>, case 14: <D.18812>, case 24: <D.18806>, case 25: <D.18807>, case 28: <D.18796>>
  <D.18796>:
  D.38306 = mono_defaults.object_class;
  return D.38306;
  <D.18797>:
  D.38306 = mono_defaults.void_class;
  return D.38306;
  <D.18798>:
  D.38306 = mono_defaults.boolean_class;
  return D.38306;
  <D.18799>:
  D.38306 = mono_defaults.char_class;
  return D.38306;
  <D.18800>:
  D.38306 = mono_defaults.sbyte_class;
  return D.38306;
  <D.18801>:
  D.38306 = mono_defaults.byte_class;
  return D.38306;
  <D.18802>:
  D.38306 = mono_defaults.int16_class;
  return D.38306;
  <D.18803>:
  D.38306 = mono_defaults.uint16_class;
  return D.38306;
  <D.18804>:
  D.38306 = mono_defaults.int32_class;
  return D.38306;
  <D.18805>:
  D.38306 = mono_defaults.uint32_class;
  return D.38306;
  <D.18806>:
  D.38306 = mono_defaults.int_class;
  return D.38306;
  <D.18807>:
  D.38306 = mono_defaults.uint_class;
  return D.38306;
  <D.18808>:
  D.38306 = mono_defaults.int64_class;
  return D.38306;
  <D.18809>:
  D.38306 = mono_defaults.uint64_class;
  return D.38306;
  <D.18810>:
  D.38306 = mono_defaults.single_class;
  return D.38306;
  <D.18811>:
  D.38306 = mono_defaults.double_class;
  return D.38306;
  <D.18812>:
  D.38306 = mono_defaults.string_class;
  return D.38306;
  <D.18813>:
  D.38304 = type->type;
  D.38305 = (int) D.38304;
  monoeg_g_log (0B, 16, "default_class_from_mono_type: implement me 0x%02x\n", D.38305);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 616);
  D.38306 = 0B;
  return D.38306;
}


mono_reflection_marshal_as_attribute_from_marshal_spec (struct MonoDomain * domain, struct MonoClass * klass, struct MonoMarshalSpec * spec)
{
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.598;
  struct MonoImage * D.38311;
  struct MonoClass * System_Reflection_Emit_MarshalAsAttribute.599;
  _Bool D.38313;
  long int D.38314;
  long int D.38315;
  <unnamed type> D.38318;
  unsigned int D.38319;
  <unnamed type> D.38320;
  int D.38321;
  short int D.38322;
  char * D.38325;
  struct MonoImage * D.38328;
  struct MonoReflectionType * D.38331;
  struct MonoReflectionType * * D.38332;
  struct MonoString * D.38333;
  struct MonoString * * D.38334;
  char * D.38335;
  struct MonoString * D.38338;
  struct MonoString * * D.38339;
  struct MonoReflectionMarshalAsAttribute * D.38340;
  static struct MonoClass * System_Reflection_Emit_MarshalAsAttribute;
  struct MonoReflectionMarshalAsAttribute * minfo;
  struct MonoType * mtype;

  System_Reflection_Emit_MarshalAsAttribute.598 = System_Reflection_Emit_MarshalAsAttribute;
  if (System_Reflection_Emit_MarshalAsAttribute.598 == 0B) goto <D.38309>; else goto <D.38310>;
  <D.38309>:
  D.38311 = mono_defaults.corlib;
  System_Reflection_Emit_MarshalAsAttribute.599 = mono_class_from_name (D.38311, "System.Runtime.InteropServices", "MarshalAsAttribute");
  System_Reflection_Emit_MarshalAsAttribute = System_Reflection_Emit_MarshalAsAttribute.599;
  System_Reflection_Emit_MarshalAsAttribute.598 = System_Reflection_Emit_MarshalAsAttribute;
  D.38313 = System_Reflection_Emit_MarshalAsAttribute.598 == 0B;
  D.38314 = (long int) D.38313;
  D.38315 = __builtin_expect (D.38314, 0);
  if (D.38315 != 0) goto <D.38316>; else goto <D.38317>;
  <D.38316>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10070, "System_Reflection_Emit_MarshalAsAttribute");
  <D.38317>:
  <D.38310>:
  System_Reflection_Emit_MarshalAsAttribute.598 = System_Reflection_Emit_MarshalAsAttribute;
  minfo = mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute.598);
  D.38318 = spec->native;
  minfo->utype = D.38318;
  D.38319 = minfo->utype;
  switch (D.38319) <default: <D.23220>, case 23: <D.23217>, case 30: <D.23218>, case 42: <D.23215>, case 44: <D.23219>>
  <D.23215>:
  D.38320 = spec->data.array_data.elem_type;
  minfo->array_subtype = D.38320;
  D.38321 = spec->data.array_data.num_elem;
  minfo->size_const = D.38321;
  D.38322 = spec->data.array_data.param_num;
  if (D.38322 != -1) goto <D.38323>; else goto <D.38324>;
  <D.38323>:
  D.38322 = spec->data.array_data.param_num;
  minfo->size_param_index = D.38322;
  <D.38324>:
  goto <D.23216>;
  <D.23217>:
  <D.23218>:
  D.38321 = spec->data.array_data.num_elem;
  minfo->size_const = D.38321;
  goto <D.23216>;
  <D.23219>:
  D.38325 = spec->data.custom_data.custom_name;
  if (D.38325 != 0B) goto <D.38326>; else goto <D.38327>;
  <D.38326>:
  D.38328 = klass->image;
  D.38325 = spec->data.custom_data.custom_name;
  mtype = mono_reflection_type_from_name (D.38325, D.38328);
  if (mtype != 0B) goto <D.38329>; else goto <D.38330>;
  <D.38329>:
  D.38331 = mono_type_get_object (domain, mtype);
  D.38332 = &minfo->marshal_type_ref;
  mono_gc_wbarrier_set_field (minfo, D.38332, D.38331);
  <D.38330>:
  D.38325 = spec->data.custom_data.custom_name;
  D.38333 = mono_string_new (domain, D.38325);
  D.38334 = &minfo->marshal_type;
  mono_gc_wbarrier_set_field (minfo, D.38334, D.38333);
  <D.38327>:
  D.38335 = spec->data.custom_data.cookie;
  if (D.38335 != 0B) goto <D.38336>; else goto <D.38337>;
  <D.38336>:
  D.38335 = spec->data.custom_data.cookie;
  D.38338 = mono_string_new (domain, D.38335);
  D.38339 = &minfo->marshal_cookie;
  mono_gc_wbarrier_set_field (minfo, D.38339, D.38338);
  <D.38337>:
  goto <D.23216>;
  <D.23220>:
  goto <D.23216>;
  <D.23216>:
  D.38340 = minfo;
  return D.38340;
}


mono_reflection_bind_generic_parameters (struct MonoReflectionType * type, int type_argc, struct MonoType * * types)
{
  struct MonoVTable * D.38343;
  struct MonoClass * D.38344;
  int D.38345;
  int D.38349;
  struct MonoVTable * D.38352;
  struct MonoClass * D.38353;
  int D.38354;
  struct MonoGenericContainer * D.38359;
  struct MonoType * D.38362;
  struct MonoGenericContainer * D.38363;
  struct MonoType * D.38366;
  unsigned char D.38367;
  unsigned char D.38368;
  struct MonoClass * klass;
  struct MonoReflectionTypeBuilder * tb;
  gboolean is_dynamic;
  struct MonoDomain * domain;
  struct MonoClass * geninst;

  tb = 0B;
  is_dynamic = 0;
  mono_loader_lock ();
  D.38343 = MEM[(struct MonoObject *)type].vtable;
  domain = D.38343->domain;
  D.38343 = MEM[(struct MonoObject *)type].vtable;
  D.38344 = D.38343->klass;
  D.38345 = is_sre_type_builder (D.38344);
  if (D.38345 != 0) goto <D.38346>; else goto <D.38347>;
  <D.38346>:
  tb = type;
  is_dynamic = 1;
  goto <D.38348>;
  <D.38347>:
  D.38343 = MEM[(struct MonoObject *)type].vtable;
  D.38344 = D.38343->klass;
  D.38349 = is_sre_generic_instance (D.38344);
  if (D.38349 != 0) goto <D.38350>; else goto <D.38351>;
  <D.38350>:
  {
    struct MonoReflectionGenericClass * rgi;
    struct MonoReflectionType * gtd;

    rgi = type;
    gtd = rgi->generic_type;
    D.38352 = MEM[(struct MonoObject *)gtd].vtable;
    D.38353 = D.38352->klass;
    D.38354 = is_sre_type_builder (D.38353);
    if (D.38354 != 0) goto <D.38355>; else goto <D.38356>;
    <D.38355>:
    tb = gtd;
    is_dynamic = 1;
    <D.38356>:
  }
  <D.38351>:
  <D.38348>:
  if (tb != 0B) goto <D.38357>; else goto <D.38358>;
  <D.38357>:
  D.38359 = tb->generic_container;
  if (D.38359 != 0B) goto <D.38360>; else goto <D.38361>;
  <D.38360>:
  mono_reflection_create_generic_class (tb);
  <D.38361>:
  <D.38358>:
  D.38362 = mono_reflection_type_get_handle (type);
  klass = mono_class_from_mono_type (D.38362);
  D.38363 = klass->generic_container;
  if (D.38363 == 0B) goto <D.38364>; else goto <D.38365>;
  <D.38364>:
  mono_loader_unlock ();
  D.38366 = 0B;
  return D.38366;
  <D.38365>:
  D.38367 = BIT_FIELD_REF <*klass, 8, 256>;
  D.38368 = D.38367 & 128;
  if (D.38368 != 0) goto <D.38369>; else goto <D.38370>;
  <D.38369>:
  tb = mono_class_get_ref_info (klass);
  is_dynamic = 1;
  <D.38370>:
  mono_loader_unlock ();
  geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
  D.38366 = &geninst->byval_arg;
  return D.38366;
}


mono_class_bind_generic_parameters (struct MonoClass * klass, int type_argc, struct MonoType * * types, gboolean is_dynamic)
{
  struct MonoGenericContainer * D.38372;
  _Bool D.38373;
  long int D.38374;
  long int D.38375;
  struct MonoClass * D.38378;
  struct MonoGenericClass * gclass;
  struct MonoGenericInst * inst;

  D.38372 = klass->generic_container;
  D.38373 = D.38372 == 0B;
  D.38374 = (long int) D.38373;
  D.38375 = __builtin_expect (D.38374, 0);
  if (D.38375 != 0) goto <D.38376>; else goto <D.38377>;
  <D.38376>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10507, "klass->generic_container");
  <D.38377>:
  inst = mono_metadata_get_generic_inst (type_argc, types);
  gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
  D.38378 = mono_generic_class_get_class (gclass);
  return D.38378;
}


mono_reflection_bind_generic_method_parameters (struct MonoReflectionMethod * rmethod, struct MonoArray * types)
{
  int D.23346;
  int iftmp.600;
  int D.23345;
  struct MonoVTable * D.38383;
  struct MonoClass * D.38384;
  const char[14] * D.38385;
  unsigned char D.38386;
  int D.38387;
  unsigned char D.38388;
  int D.38389;
  _Bool D.38390;
  _Bool D.38391;
  _Bool D.38392;
  const unsigned char * D.38395;
  unsigned char D.38396;
  int D.38397;
  const unsigned char * D.38398;
  unsigned char D.38399;
  int D.38400;
  _Bool D.38401;
  _Bool D.38402;
  const unsigned char * D.38405;
  unsigned char D.38406;
  int D.38407;
  const unsigned char * D.38408;
  unsigned char D.38409;
  int D.38410;
  _Bool D.38411;
  _Bool D.38412;
  const unsigned char * D.38415;
  unsigned char D.38416;
  int D.38417;
  const unsigned char * D.38418;
  unsigned char D.38419;
  int D.38420;
  const char * D.38422;
  struct MonoType * D.38425;
  unsigned char D.38427;
  unsigned char D.38428;
  struct MonoMethodSignature * D.38431;
  short unsigned int D.38432;
  long unsigned int D.38433;
  long unsigned int D.38434;
  struct MonoReflectionMethod * D.38437;
  long unsigned int D.38438;
  long unsigned int D.38439;
  long unsigned int D.38440;
  char * D.38441;
  long unsigned int D.38442;
  long unsigned int D.38443;
  struct MonoType * * D.38444;
  struct MonoType * D.38445;
  struct MonoGenericInst * iftmp.601;
  struct MonoGenericClass * D.38447;
  struct MonoClass * D.38451;
  struct MonoImage * D.38452;
  unsigned char D.38453;
  unsigned char D.38454;
  struct MonoGHashTable * D.38457;
  int D.38458;
  struct MonoException * D.38461;
  struct MonoVTable * D.38462;
  struct MonoDomain * D.38463;
  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.38381>; else goto <D.38382>;
        <D.38381>:
        {
          const unsigned char * __s2;
          int __result;

          D.38383 = rmethod->object.vtable;
          D.38384 = D.38383->klass;
          __s2 = D.38384->name;
          D.38385 = "MethodBuilder";
          D.38386 = MEM[(const unsigned char *)D.38385];
          D.38387 = (int) D.38386;
          D.38388 = *__s2;
          D.38389 = (int) D.38388;
          __result = D.38387 - D.38389;
          {
            D.38390 = __s2_len != 0;
            D.38391 = __result == 0;
            D.38392 = D.38390 & D.38391;
            if (D.38392 != 0) goto <D.38393>; else goto <D.38394>;
            <D.38393>:
            D.38395 = &MEM[(void *)"MethodBuilder" + 1B];
            D.38396 = *D.38395;
            D.38397 = (int) D.38396;
            D.38398 = __s2 + 1;
            D.38399 = *D.38398;
            D.38400 = (int) D.38399;
            __result = D.38397 - D.38400;
            D.38401 = __s2_len > 1;
            D.38391 = __result == 0;
            D.38402 = D.38401 & D.38391;
            if (D.38402 != 0) goto <D.38403>; else goto <D.38404>;
            <D.38403>:
            D.38405 = &MEM[(void *)"MethodBuilder" + 2B];
            D.38406 = *D.38405;
            D.38407 = (int) D.38406;
            D.38408 = __s2 + 2;
            D.38409 = *D.38408;
            D.38410 = (int) D.38409;
            __result = D.38407 - D.38410;
            D.38411 = __s2_len > 2;
            D.38391 = __result == 0;
            D.38412 = D.38411 & D.38391;
            if (D.38412 != 0) goto <D.38413>; else goto <D.38414>;
            <D.38413>:
            D.38415 = &MEM[(void *)"MethodBuilder" + 3B];
            D.38416 = *D.38415;
            D.38417 = (int) D.38416;
            D.38418 = __s2 + 3;
            D.38419 = *D.38418;
            D.38420 = (int) D.38419;
            __result = D.38417 - D.38420;
            <D.38414>:
            <D.38404>:
            <D.38394>:
          }
          D.23345 = __result;
        }
        iftmp.600 = -D.23345;
        goto <D.38421>;
        <D.38382>:
        D.38383 = rmethod->object.vtable;
        D.38384 = D.38383->klass;
        D.38422 = D.38384->name;
        iftmp.600 = __builtin_strcmp (D.38422, "MethodBuilder");
        <D.38421>:
        D.23346 = iftmp.600;
      }
      if (D.23346 == 0) goto <D.38423>; else goto <D.38424>;
      <D.38423>:
      {
        struct MonoReflectionMethodBuilder * mb;
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        mb = 0B;
        mb = rmethod;
        tb = mb->type;
        D.38425 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.38425);
        method = methodbuilder_to_mono_method (klass, mb);
      }
      goto <D.38426>;
      <D.38424>:
      method = rmethod->method;
      <D.38426>:
      klass = method->klass;
      D.38427 = BIT_FIELD_REF <*method, 8, 264>;
      D.38428 = D.38427 & 16;
      if (D.38428 != 0) goto <D.38429>; else goto <D.38430>;
      <D.38429>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.38430>:
      D.38431 = mono_method_signature (method);
      D.38432 = D.38431->generic_param_count;
      count = (int) D.38432;
      D.38433 = (long unsigned int) count;
      D.38434 = mono_array_length (types);
      if (D.38433 != D.38434) goto <D.38435>; else goto <D.38436>;
      <D.38435>:
      D.38437 = 0B;
      return D.38437;
      <D.38436>:
      D.38438 = (long unsigned int) count;
      D.38439 = D.38438 * 8;
      type_argv = monoeg_malloc0 (D.38439);
      i = 0;
      goto <D.23352>;
      <D.23351>:
      {
        struct MonoReflectionType * garg;

        D.38440 = (long unsigned int) i;
        D.38441 = mono_array_addr_with_size (types, 8, D.38440);
        garg = MEM[(void * *)D.38441];
        D.38442 = (long unsigned int) i;
        D.38443 = D.38442 * 8;
        D.38444 = type_argv + D.38443;
        D.38445 = mono_reflection_type_get_handle (garg);
        *D.38444 = D.38445;
      }
      i = i + 1;
      <D.23352>:
      if (i < count) goto <D.23351>; else goto <D.23353>;
      <D.23353>:
      ginst = mono_metadata_get_generic_inst (count, type_argv);
      monoeg_g_free (type_argv);
      D.38447 = klass->generic_class;
      if (D.38447 != 0B) goto <D.38448>; else goto <D.38449>;
      <D.38448>:
      D.38447 = klass->generic_class;
      iftmp.601 = D.38447->context.class_inst;
      goto <D.38450>;
      <D.38449>:
      iftmp.601 = 0B;
      <D.38450>:
      tmp_context.class_inst = iftmp.601;
      tmp_context.method_inst = ginst;
      inflated = mono_class_inflate_generic_method (method, &tmp_context);
      imethod = inflated;
      D.38451 = method->klass;
      D.38452 = D.38451->image;
      D.38453 = BIT_FIELD_REF <*D.38452, 8, 224>;
      D.38454 = D.38453 & 8;
      if (D.38454 != 0) goto <D.38455>; else goto <D.38456>;
      <D.38455>:
      {
        struct MonoDynamicImage * image;

        D.38451 = method->klass;
        image = D.38451->image;
        mono_image_lock (image);
        D.38457 = image->generic_def_objects;
        mono_g_hash_table_insert (D.38457, imethod, rmethod);
        mono_image_unlock (image);
      }
      <D.38456>:
      D.38458 = mono_verifier_is_method_valid_generic_instantiation (inflated);
      if (D.38458 == 0) goto <D.38459>; else goto <D.38460>;
      <D.38459>:
      D.38461 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
      mono_raise_exception (D.38461);
      <D.38460>:
      D.38462 = MEM[(struct MonoObject *)rmethod].vtable;
      D.38463 = D.38462->domain;
      D.38437 = mono_method_get_object (D.38463, inflated, 0B);
      return D.38437;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


mono_reflection_generic_class_initialize (struct MonoReflectionGenericClass * type, struct MonoArray * fields)
{
  unsigned char D.38466;
  _Bool D.38467;
  long int D.38468;
  long int D.38469;
  unsigned char D.38472;
  unsigned char D.38473;
  unsigned int D.38476;
  int iftmp.602;
  long unsigned int D.38482;
  int D.38484;
  long unsigned int D.38485;
  unsigned int D.38486;
  unsigned int D.38487;
  struct MonoImageSet * D.38488;
  void * D.38489;
  unsigned int D.38490;
  void * D.38491;
  void * D.38492;
  long unsigned int D.38493;
  char * D.38494;
  int D.23434;
  int iftmp.603;
  int D.23433;
  struct MonoVTable * D.38498;
  struct MonoClass * D.38499;
  const char[13] * D.38500;
  unsigned char D.38501;
  int D.38502;
  unsigned char D.38503;
  int D.38504;
  _Bool D.38505;
  _Bool D.38506;
  _Bool D.38507;
  const unsigned char * D.38510;
  unsigned char D.38511;
  int D.38512;
  const unsigned char * D.38513;
  unsigned char D.38514;
  int D.38515;
  _Bool D.38516;
  _Bool D.38517;
  const unsigned char * D.38520;
  unsigned char D.38521;
  int D.38522;
  const unsigned char * D.38523;
  unsigned char D.38524;
  int D.38525;
  _Bool D.38526;
  _Bool D.38527;
  const unsigned char * D.38530;
  unsigned char D.38531;
  int D.38532;
  const unsigned char * D.38533;
  unsigned char D.38534;
  int D.38535;
  const char * D.38537;
  int D.23443;
  int iftmp.604;
  int D.23442;
  const char[10] * D.38544;
  unsigned char D.38545;
  int D.38546;
  unsigned char D.38547;
  int D.38548;
  _Bool D.38549;
  _Bool D.38550;
  _Bool D.38551;
  const unsigned char * D.38554;
  unsigned char D.38555;
  int D.38556;
  const unsigned char * D.38557;
  unsigned char D.38558;
  int D.38559;
  _Bool D.38560;
  _Bool D.38561;
  const unsigned char * D.38564;
  unsigned char D.38565;
  int D.38566;
  const unsigned char * D.38567;
  unsigned char D.38568;
  int D.38569;
  _Bool D.38570;
  _Bool D.38571;
  const unsigned char * D.38574;
  unsigned char D.38575;
  int D.38576;
  const unsigned char * D.38577;
  unsigned char D.38578;
  int D.38579;
  struct MonoClassField * D.38584;
  long unsigned int D.38585;
  long unsigned int D.38586;
  struct MonoClassField * D.38587;
  struct MonoGenericContext * D.38588;
  struct MonoType * D.38589;
  struct MonoType * D.38590;
  struct MonoType * * D.38591;
  long unsigned int D.38592;
  struct MonoType * * D.38593;
  int D.38594;
  void * D.38599;
  struct MonoObject * * D.38600;
  char * D.38601;
  struct MonoObject * * D.38602;
  const char * D.38606;
  char * D.38607;
  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.38466 = gtype->type;
  D.38467 = D.38466 != 21;
  D.38468 = (long int) D.38467;
  D.38469 = __builtin_expect (D.38468, 0);
  if (D.38469 != 0) goto <D.38470>; else goto <D.38471>;
  <D.38470>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10682, "gtype->type == MONO_TYPE_GENERICINST");
  <D.38471>:
  gclass = gtype->data.generic_class;
  D.38472 = BIT_FIELD_REF <*gclass, 8, 192>;
  D.38473 = D.38472 & 1;
  if (D.38473 == 0) goto <D.38474>; else goto <D.38475>;
  <D.38474>:
  return;
  <D.38475>:
  dgclass = gclass;
  D.38476 = dgclass->initialized;
  if (D.38476 != 0) goto <D.38477>; else goto <D.38478>;
  <D.38477>:
  return;
  <D.38478>:
  gklass = gclass->container_class;
  mono_class_init (gklass);
  if (fields != 0B) goto <D.38480>; else goto <D.38481>;
  <D.38480>:
  D.38482 = mono_array_length (fields);
  iftmp.602 = (int) D.38482;
  goto <D.38483>;
  <D.38481>:
  iftmp.602 = 0;
  <D.38483>:
  dgclass->count_fields = iftmp.602;
  D.38484 = dgclass->count_fields;
  D.38485 = (long unsigned int) D.38484;
  D.38486 = (unsigned int) D.38485;
  D.38487 = D.38486 * 32;
  D.38488 = gclass->owner;
  D.38489 = mono_image_set_alloc0 (D.38488, D.38487);
  dgclass->fields = D.38489;
  D.38484 = dgclass->count_fields;
  D.38485 = (long unsigned int) D.38484;
  D.38486 = (unsigned int) D.38485;
  D.38490 = D.38486 * 8;
  D.38488 = gclass->owner;
  D.38491 = mono_image_set_alloc0 (D.38488, D.38490);
  dgclass->field_objects = D.38491;
  D.38484 = dgclass->count_fields;
  D.38485 = (long unsigned int) D.38484;
  D.38486 = (unsigned int) D.38485;
  D.38490 = D.38486 * 8;
  D.38488 = gclass->owner;
  D.38492 = mono_image_set_alloc0 (D.38488, D.38490);
  dgclass->field_generic_types = D.38492;
  i = 0;
  goto <D.23445>;
  <D.23444>:
  {
    struct MonoObject * obj;
    struct MonoClassField * field;
    struct MonoClassField * inflated_field;

    D.38493 = (long unsigned int) i;
    D.38494 = mono_array_addr_with_size (fields, 8, D.38493);
    obj = MEM[(void * *)D.38494];
    inflated_field = 0B;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.38498 = obj->vtable;
        D.38499 = D.38498->klass;
        __s2 = D.38499->name;
        D.38500 = "FieldBuilder";
        D.38501 = MEM[(const unsigned char *)D.38500];
        D.38502 = (int) D.38501;
        D.38503 = *__s2;
        D.38504 = (int) D.38503;
        __result = D.38502 - D.38504;
        {
          D.38505 = __s2_len != 0;
          D.38506 = __result == 0;
          D.38507 = D.38505 & D.38506;
          if (D.38507 != 0) goto <D.38508>; else goto <D.38509>;
          <D.38508>:
          D.38510 = &MEM[(void *)"FieldBuilder" + 1B];
          D.38511 = *D.38510;
          D.38512 = (int) D.38511;
          D.38513 = __s2 + 1;
          D.38514 = *D.38513;
          D.38515 = (int) D.38514;
          __result = D.38512 - D.38515;
          D.38516 = __s2_len > 1;
          D.38506 = __result == 0;
          D.38517 = D.38516 & D.38506;
          if (D.38517 != 0) goto <D.38518>; else goto <D.38519>;
          <D.38518>:
          D.38520 = &MEM[(void *)"FieldBuilder" + 2B];
          D.38521 = *D.38520;
          D.38522 = (int) D.38521;
          D.38523 = __s2 + 2;
          D.38524 = *D.38523;
          D.38525 = (int) D.38524;
          __result = D.38522 - D.38525;
          D.38526 = __s2_len > 2;
          D.38506 = __result == 0;
          D.38527 = D.38526 & D.38506;
          if (D.38527 != 0) goto <D.38528>; else goto <D.38529>;
          <D.38528>:
          D.38530 = &MEM[(void *)"FieldBuilder" + 3B];
          D.38531 = *D.38530;
          D.38532 = (int) D.38531;
          D.38533 = __s2 + 3;
          D.38534 = *D.38533;
          D.38535 = (int) D.38534;
          __result = D.38532 - D.38535;
          <D.38529>:
          <D.38519>:
          <D.38509>:
        }
        D.23433 = __result;
      }
      iftmp.603 = -D.23433;
      goto <D.38536>;
      <D.38497>:
      D.38498 = obj->vtable;
      D.38499 = D.38498->klass;
      D.38537 = D.38499->name;
      iftmp.603 = __builtin_strcmp (D.38537, "FieldBuilder");
      <D.38536>:
      D.23434 = iftmp.603;
    }
    if (D.23434 == 0) goto <D.38538>; else goto <D.38539>;
    <D.38538>:
    field = fieldbuilder_to_mono_class_field (klass, obj);
    inflated_field = field;
    goto <D.38540>;
    <D.38539>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        D.38498 = obj->vtable;
        D.38499 = D.38498->klass;
        __s2 = D.38499->name;
        D.38544 = "MonoField";
        D.38545 = MEM[(const unsigned char *)D.38544];
        D.38546 = (int) D.38545;
        D.38547 = *__s2;
        D.38548 = (int) D.38547;
        __result = D.38546 - D.38548;
        {
          D.38549 = __s2_len != 0;
          D.38550 = __result == 0;
          D.38551 = D.38549 & D.38550;
          if (D.38551 != 0) goto <D.38552>; else goto <D.38553>;
          <D.38552>:
          D.38554 = &MEM[(void *)"MonoField" + 1B];
          D.38555 = *D.38554;
          D.38556 = (int) D.38555;
          D.38557 = __s2 + 1;
          D.38558 = *D.38557;
          D.38559 = (int) D.38558;
          __result = D.38556 - D.38559;
          D.38560 = __s2_len > 1;
          D.38550 = __result == 0;
          D.38561 = D.38560 & D.38550;
          if (D.38561 != 0) goto <D.38562>; else goto <D.38563>;
          <D.38562>:
          D.38564 = &MEM[(void *)"MonoField" + 2B];
          D.38565 = *D.38564;
          D.38566 = (int) D.38565;
          D.38567 = __s2 + 2;
          D.38568 = *D.38567;
          D.38569 = (int) D.38568;
          __result = D.38566 - D.38569;
          D.38570 = __s2_len > 2;
          D.38550 = __result == 0;
          D.38571 = D.38570 & D.38550;
          if (D.38571 != 0) goto <D.38572>; else goto <D.38573>;
          <D.38572>:
          D.38574 = &MEM[(void *)"MonoField" + 3B];
          D.38575 = *D.38574;
          D.38576 = (int) D.38575;
          D.38577 = __s2 + 3;
          D.38578 = *D.38577;
          D.38579 = (int) D.38578;
          __result = D.38576 - D.38579;
          <D.38573>:
          <D.38563>:
          <D.38553>:
        }
        D.23442 = __result;
      }
      iftmp.604 = -D.23442;
      goto <D.38580>;
      <D.38543>:
      D.38498 = obj->vtable;
      D.38499 = D.38498->klass;
      D.38537 = D.38499->name;
      iftmp.604 = __builtin_strcmp (D.38537, "MonoField");
      <D.38580>:
      D.23443 = iftmp.604;
    }
    if (D.23443 == 0) goto <D.38581>; else goto <D.38582>;
    <D.38581>:
    field = MEM[(struct MonoReflectionField *)obj].field;
    goto <D.38583>;
    <D.38582>:
    field = 0B;
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 10712);
    <D.38583>:
    <D.38540>:
    D.38584 = dgclass->fields;
    D.38585 = (long unsigned int) i;
    D.38586 = D.38585 * 32;
    D.38587 = D.38584 + D.38586;
    *D.38587 = *field;
    D.38584 = dgclass->fields;
    D.38585 = (long unsigned int) i;
    D.38586 = D.38585 * 32;
    D.38587 = D.38584 + D.38586;
    D.38587->parent = klass;
    D.38584 = dgclass->fields;
    D.38585 = (long unsigned int) i;
    D.38586 = D.38585 * 32;
    D.38587 = D.38584 + D.38586;
    D.38588 = mono_generic_class_get_context (dgclass);
    D.38589 = field->type;
    D.38590 = mono_class_inflate_generic_type (D.38589, D.38588);
    D.38587->type = D.38590;
    D.38591 = dgclass->field_generic_types;
    D.38585 = (long unsigned int) i;
    D.38592 = D.38585 * 8;
    D.38593 = D.38591 + D.38592;
    D.38589 = field->type;
    *D.38593 = D.38589;
    D.38594 = mono_gc_is_moving ();
    if (D.38594 != 0) goto <D.38595>; else goto <D.38596>;
    <D.38595>:
    if (0 != 0) goto <D.38597>; else goto <D.38598>;
    <D.38597>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10720, "sizeof (dgclass->field_objects [i]) == sizeof (MonoObject*)");
    <D.38598>:
    D.38599 = mono_gc_make_root_descr_all_refs (1);
    D.38600 = dgclass->field_objects;
    D.38585 = (long unsigned int) i;
    D.38592 = D.38585 * 8;
    D.38601 = D.38600 + D.38592;
    mono_gc_register_root (D.38601, 8, D.38599);
    <D.38596>:
    D.38600 = dgclass->field_objects;
    D.38585 = (long unsigned int) i;
    D.38592 = D.38585 * 8;
    D.38602 = D.38600 + D.38592;
    *D.38602 = obj;
    if (inflated_field != 0B) goto <D.38603>; else goto <D.38604>;
    <D.38603>:
    monoeg_g_free (inflated_field);
    goto <D.38605>;
    <D.38604>:
    D.38584 = dgclass->fields;
    D.38585 = (long unsigned int) i;
    D.38586 = D.38585 * 32;
    D.38587 = D.38584 + D.38586;
    D.38584 = dgclass->fields;
    D.38585 = (long unsigned int) i;
    D.38586 = D.38585 * 32;
    D.38587 = D.38584 + D.38586;
    D.38606 = D.38587->name;
    D.38488 = gclass->owner;
    D.38607 = mono_image_set_strdup (D.38488, D.38606);
    D.38587->name = D.38607;
    <D.38605>:
  }
  i = i + 1;
  <D.23445>:
  D.38484 = dgclass->count_fields;
  if (D.38484 > i) goto <D.23444>; else goto <D.23446>;
  <D.23446>:
  dgclass->initialized = 1;
}


fieldbuilder_to_mono_class_field (struct MonoClass * klass, struct MonoReflectionFieldBuilder * fb)
{
  struct MonoString * D.38609;
  struct MonoImage * D.38610;
  char * D.38611;
  int D.38612;
  _Bool D.38613;
  long int D.38614;
  long int D.38615;
  unsigned int D.38621;
  struct MonoArray * D.38623;
  struct MonoArray * D.38625;
  struct MonoObject * D.38626;
  struct MonoType * D.38627;
  struct MonoType * D.38628;
  struct MonoType * D.38629;
  short unsigned int D.38630;
  unsigned char D.38631;
  unsigned char D.38632;
  _Bool D.38633;
  long int D.38634;
  long int D.38635;
  struct MonoType * D.38638;
  struct MonoType * D.38639;
  int D.38640;
  struct MonoArray * D.38643;
  struct MonoClassField * D.38644;
  struct MonoClassField * field;
  struct MonoType * custom;
  struct MonoError error;

  try
    {
      field = monoeg_malloc0 (32);
      D.38609 = fb->name;
      D.38610 = klass->image;
      D.38611 = mono_string_to_utf8_image (D.38610, D.38609, &error);
      field->name = D.38611;
      D.38612 = mono_error_ok (&error);
      D.38613 = D.38612 == 0;
      D.38614 = (long int) D.38613;
      D.38615 = __builtin_expect (D.38614, 0);
      if (D.38615 != 0) goto <D.38616>; else goto <D.38617>;
      <D.38616>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10427, "mono_error_ok (&error)");
      <D.38617>:
      D.38621 = fb->attrs;
      if (D.38621 != 0) goto <D.38618>; else goto <D.38622>;
      <D.38622>:
      D.38623 = fb->modreq;
      if (D.38623 != 0B) goto <D.38618>; else goto <D.38624>;
      <D.38624>:
      D.38625 = fb->modopt;
      if (D.38625 != 0B) goto <D.38618>; else goto <D.38619>;
      <D.38618>:
      D.38626 = fb->type;
      D.38627 = mono_reflection_type_get_handle (D.38626);
      D.38628 = mono_metadata_type_dup (0B, D.38627);
      field->type = D.38628;
      D.38629 = field->type;
      D.38621 = fb->attrs;
      D.38630 = (short unsigned int) D.38621;
      D.38629->attrs = D.38630;
      D.38610 = klass->image;
      D.38631 = BIT_FIELD_REF <*D.38610, 8, 224>;
      D.38632 = D.38631 & 8;
      D.38633 = D.38632 == 0;
      D.38634 = (long int) D.38633;
      D.38635 = __builtin_expect (D.38634, 0);
      if (D.38635 != 0) goto <D.38636>; else goto <D.38637>;
      <D.38636>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10432, "klass->image->dynamic");
      <D.38637>:
      D.38625 = fb->modopt;
      D.38623 = fb->modreq;
      D.38629 = field->type;
      D.38610 = klass->image;
      custom = add_custom_modifiers (D.38610, D.38629, D.38623, D.38625);
      D.38629 = field->type;
      monoeg_g_free (D.38629);
      D.38610 = klass->image;
      D.38638 = mono_metadata_type_dup (D.38610, custom);
      field->type = D.38638;
      monoeg_g_free (custom);
      goto <D.38620>;
      <D.38619>:
      D.38626 = fb->type;
      D.38639 = mono_reflection_type_get_handle (D.38626);
      field->type = D.38639;
      <D.38620>:
      D.38640 = fb->offset;
      if (D.38640 != -1) goto <D.38641>; else goto <D.38642>;
      <D.38641>:
      D.38640 = fb->offset;
      field->offset = D.38640;
      <D.38642>:
      field->parent = klass;
      D.38643 = fb->cattrs;
      D.38610 = klass->image;
      mono_save_custom_attrs (D.38610, field, D.38643);
      D.38644 = field;
      return D.38644;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_reflection_free_dynamic_generic_class (struct MonoGenericClass * gclass)
{
  unsigned char D.38647;
  unsigned char D.38648;
  _Bool D.38649;
  long int D.38650;
  long int D.38651;
  struct MonoClassField * D.38654;
  long unsigned int D.38655;
  long unsigned int D.38656;
  struct MonoType * D.38657;
  int D.38658;
  struct MonoObject * * D.38661;
  long unsigned int D.38662;
  char * D.38663;
  int D.38664;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.38647 = BIT_FIELD_REF <*gclass, 8, 192>;
  D.38648 = D.38647 & 1;
  D.38649 = D.38648 == 0;
  D.38650 = (long int) D.38649;
  D.38651 = __builtin_expect (D.38650, 0);
  if (D.38651 != 0) goto <D.38652>; else goto <D.38653>;
  <D.38652>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10739, "gclass->is_dynamic");
  <D.38653>:
  dgclass = gclass;
  i = 0;
  goto <D.23454>;
  <D.23453>:
  {
    struct MonoClassField * field;

    D.38654 = dgclass->fields;
    D.38655 = (long unsigned int) i;
    D.38656 = D.38655 * 32;
    field = D.38654 + D.38656;
    D.38657 = field->type;
    mono_metadata_free_type (D.38657);
    D.38658 = mono_gc_is_moving ();
    if (D.38658 != 0) goto <D.38659>; else goto <D.38660>;
    <D.38659>:
    D.38661 = dgclass->field_objects;
    D.38655 = (long unsigned int) i;
    D.38662 = D.38655 * 8;
    D.38663 = D.38661 + D.38662;
    mono_gc_deregister_root (D.38663);
    <D.38660>:
  }
  i = i + 1;
  <D.23454>:
  D.38664 = dgclass->count_fields;
  if (D.38664 > i) goto <D.23453>; else goto <D.23455>;
  <D.23455>:
}


mono_reflection_get_dynamic_overrides (struct MonoClass * klass, struct MonoMethod * * * overrides, int * num_overrides)
{
  struct MonoImage * D.38665;
  unsigned char D.38666;
  unsigned char D.38667;
  _Bool D.38668;
  long int D.38669;
  long int D.38670;
  void * D.38673;
  int D.23532;
  int iftmp.605;
  int D.23531;
  void * D.38679;
  struct MonoVTable * D.38680;
  struct MonoClass * D.38681;
  const char[12] * D.38682;
  unsigned char D.38683;
  int D.38684;
  unsigned char D.38685;
  int D.38686;
  _Bool D.38687;
  _Bool D.38688;
  _Bool D.38689;
  const unsigned char * D.38692;
  unsigned char D.38693;
  int D.38694;
  const unsigned char * D.38695;
  unsigned char D.38696;
  int D.38697;
  _Bool D.38698;
  _Bool D.38699;
  const unsigned char * D.38702;
  unsigned char D.38703;
  int D.38704;
  const unsigned char * D.38705;
  unsigned char D.38706;
  int D.38707;
  _Bool D.38708;
  _Bool D.38709;
  const unsigned char * D.38712;
  unsigned char D.38713;
  int D.38714;
  const unsigned char * D.38715;
  unsigned char D.38716;
  int D.38717;
  void * D.38719;
  struct MonoVTable * D.38720;
  struct MonoClass * D.38721;
  const char * D.38722;
  _Bool D.38723;
  long int D.38724;
  long int D.38725;
  struct MonoArray * D.38728;
  long unsigned int D.38731;
  char * D.38732;
  struct MonoArray * D.38733;
  long unsigned int D.38736;
  unsigned int D.38737;
  unsigned int onum.606;
  unsigned int D.38739;
  int D.38740;
  int D.38743;
  long unsigned int D.38744;
  long unsigned int D.38745;
  void * D.38746;
  char * D.38747;
  struct MonoArray * D.38748;
  long unsigned int D.38751;
  char * D.38752;
  struct MonoMethod * * D.38753;
  struct MonoMethod * * D.38754;
  struct MonoMethod * D.38755;
  sizetype D.38756;
  sizetype D.38757;
  sizetype D.38758;
  struct MonoMethod * * D.38759;
  struct MonoMethod * D.38760;
  _Bool D.38761;
  long int D.38762;
  long int D.38763;
  long unsigned int D.38766;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int j;
  int onum;
  struct MonoReflectionMethod * m;

  *overrides = 0B;
  *num_overrides = 0;
  D.38665 = klass->image;
  D.38666 = BIT_FIELD_REF <*D.38665, 8, 224>;
  D.38667 = D.38666 & 8;
  D.38668 = D.38667 == 0;
  D.38669 = (long int) D.38668;
  D.38670 = __builtin_expect (D.38669, 0);
  if (D.38670 != 0) goto <D.38671>; else goto <D.38672>;
  <D.38671>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10948, "klass->image->dynamic");
  <D.38672>:
  D.38673 = mono_class_get_ref_info (klass);
  if (D.38673 == 0B) goto <D.38674>; else goto <D.38675>;
  <D.38674>:
  return;
  <D.38675>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.38679 = mono_class_get_ref_info (klass);
      D.38680 = MEM[(struct MonoObject *)D.38679].vtable;
      D.38681 = D.38680->klass;
      __s2 = D.38681->name;
      D.38682 = "TypeBuilder";
      D.38683 = MEM[(const unsigned char *)D.38682];
      D.38684 = (int) D.38683;
      D.38685 = *__s2;
      D.38686 = (int) D.38685;
      __result = D.38684 - D.38686;
      {
        D.38687 = __s2_len != 0;
        D.38688 = __result == 0;
        D.38689 = D.38687 & D.38688;
        if (D.38689 != 0) goto <D.38690>; else goto <D.38691>;
        <D.38690>:
        D.38692 = &MEM[(void *)"TypeBuilder" + 1B];
        D.38693 = *D.38692;
        D.38694 = (int) D.38693;
        D.38695 = __s2 + 1;
        D.38696 = *D.38695;
        D.38697 = (int) D.38696;
        __result = D.38694 - D.38697;
        D.38698 = __s2_len > 1;
        D.38688 = __result == 0;
        D.38699 = D.38698 & D.38688;
        if (D.38699 != 0) goto <D.38700>; else goto <D.38701>;
        <D.38700>:
        D.38702 = &MEM[(void *)"TypeBuilder" + 2B];
        D.38703 = *D.38702;
        D.38704 = (int) D.38703;
        D.38705 = __s2 + 2;
        D.38706 = *D.38705;
        D.38707 = (int) D.38706;
        __result = D.38704 - D.38707;
        D.38708 = __s2_len > 2;
        D.38688 = __result == 0;
        D.38709 = D.38708 & D.38688;
        if (D.38709 != 0) goto <D.38710>; else goto <D.38711>;
        <D.38710>:
        D.38712 = &MEM[(void *)"TypeBuilder" + 3B];
        D.38713 = *D.38712;
        D.38714 = (int) D.38713;
        D.38715 = __s2 + 3;
        D.38716 = *D.38715;
        D.38717 = (int) D.38716;
        __result = D.38714 - D.38717;
        <D.38711>:
        <D.38701>:
        <D.38691>:
      }
      D.23531 = __result;
    }
    iftmp.605 = -D.23531;
    goto <D.38718>;
    <D.38678>:
    D.38719 = mono_class_get_ref_info (klass);
    D.38720 = MEM[(struct MonoObject *)D.38719].vtable;
    D.38721 = D.38720->klass;
    D.38722 = D.38721->name;
    iftmp.605 = __builtin_strcmp (D.38722, "TypeBuilder");
    <D.38718>:
    D.23532 = iftmp.605;
  }
  D.38723 = D.23532 != 0;
  D.38724 = (long int) D.38723;
  D.38725 = __builtin_expect (D.38724, 0);
  if (D.38725 != 0) goto <D.38726>; else goto <D.38727>;
  <D.38726>:
  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.38727>:
  tb = mono_class_get_ref_info (klass);
  onum = 0;
  D.38728 = tb->methods;
  if (D.38728 != 0B) goto <D.38729>; else goto <D.38730>;
  <D.38729>:
  i = 0;
  goto <D.23535>;
  <D.23534>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.38731 = (long unsigned int) i;
    D.38728 = tb->methods;
    D.38732 = mono_array_addr_with_size (D.38728, 8, D.38731);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38732];
    D.38733 = mb->override_methods;
    if (D.38733 != 0B) goto <D.38734>; else goto <D.38735>;
    <D.38734>:
    D.38733 = mb->override_methods;
    D.38736 = mono_array_length (D.38733);
    D.38737 = (unsigned int) D.38736;
    onum.606 = (unsigned int) onum;
    D.38739 = D.38737 + onum.606;
    onum = (int) D.38739;
    <D.38735>:
  }
  i = i + 1;
  <D.23535>:
  D.38740 = tb->num_methods;
  if (D.38740 > i) goto <D.23534>; else goto <D.23536>;
  <D.23536>:
  <D.38730>:
  if (onum != 0) goto <D.38741>; else goto <D.38742>;
  <D.38741>:
  D.38743 = onum * 2;
  D.38744 = (long unsigned int) D.38743;
  D.38745 = D.38744 * 8;
  D.38746 = monoeg_malloc0 (D.38745);
  *overrides = D.38746;
  onum = 0;
  i = 0;
  goto <D.23542>;
  <D.23541>:
  {
    struct MonoReflectionMethodBuilder * mb;

    D.38731 = (long unsigned int) i;
    D.38728 = tb->methods;
    D.38747 = mono_array_addr_with_size (D.38728, 8, D.38731);
    mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38747];
    D.38748 = mb->override_methods;
    if (D.38748 != 0B) goto <D.38749>; else goto <D.38750>;
    <D.38749>:
    j = 0;
    goto <D.23539>;
    <D.23538>:
    D.38751 = (long unsigned int) j;
    D.38748 = mb->override_methods;
    D.38752 = mono_array_addr_with_size (D.38748, 8, D.38751);
    m = MEM[(struct MonoReflectionMethod * *)D.38752];
    D.38753 = *overrides;
    D.38743 = onum * 2;
    D.38744 = (long unsigned int) D.38743;
    D.38745 = D.38744 * 8;
    D.38754 = D.38753 + D.38745;
    D.38755 = mono_reflection_method_get_handle (m);
    *D.38754 = D.38755;
    D.38753 = *overrides;
    D.38743 = onum * 2;
    D.38756 = (sizetype) D.38743;
    D.38757 = D.38756 + 1;
    D.38758 = D.38757 * 8;
    D.38759 = D.38753 + D.38758;
    D.38760 = mb->mhandle;
    *D.38759 = D.38760;
    D.38760 = mb->mhandle;
    D.38761 = D.38760 == 0B;
    D.38762 = (long int) D.38761;
    D.38763 = __builtin_expect (D.38762, 0);
    if (D.38763 != 0) goto <D.38764>; else goto <D.38765>;
    <D.38764>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 10981, "mb->mhandle");
    <D.38765>:
    onum = onum + 1;
    j = j + 1;
    <D.23539>:
    D.38751 = (long unsigned int) j;
    D.38748 = mb->override_methods;
    D.38766 = mono_array_length (D.38748);
    if (D.38751 < D.38766) goto <D.23538>; else goto <D.23540>;
    <D.23540>:
    <D.38750>:
  }
  i = i + 1;
  <D.23542>:
  D.38740 = tb->num_methods;
  if (D.38740 > i) goto <D.23541>; else goto <D.23543>;
  <D.23543>:
  <D.38742>:
  *num_overrides = onum;
}


mono_reflection_method_get_handle (struct MonoObject * method)
{
  struct MonoVTable * D.38768;
  int D.38771;
  int D.38773;
  struct MonoMethod * D.38774;
  int D.38775;
  int D.38778;
  struct MonoArray * D.38781;
  struct MonoReflectionType * D.38785;
  struct MonoObject * D.38786;
  struct MonoVTable * D.38787;
  struct MonoClass * D.38788;
  int D.38789;
  int D.38793;
  char * D.38797;
  const char * D.38798;
  const char * D.38799;
  struct MonoClass * class;

  D.38768 = method->vtable;
  class = D.38768->klass;
  D.38771 = is_sr_mono_method (class);
  if (D.38771 != 0) goto <D.38769>; else goto <D.38772>;
  <D.38772>:
  D.38773 = is_sr_mono_generic_method (class);
  if (D.38773 != 0) goto <D.38769>; else goto <D.38770>;
  <D.38769>:
  {
    struct MonoReflectionMethod * sr_method;

    sr_method = method;
    D.38774 = sr_method->method;
    return D.38774;
  }
  <D.38770>:
  D.38775 = is_sre_method_builder (class);
  if (D.38775 != 0) goto <D.38776>; else goto <D.38777>;
  <D.38776>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = method;
    D.38774 = mb->mhandle;
    return D.38774;
  }
  <D.38777>:
  D.38778 = is_sre_method_on_tb_inst (class);
  if (D.38778 != 0) goto <D.38779>; else goto <D.38780>;
  <D.38779>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;
    struct MonoMethod * result;

    m = method;
    D.38781 = m->method_args;
    if (D.38781 != 0B) goto <D.38782>; else goto <D.38783>;
    <D.38782>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    goto <D.38784>;
    <D.38783>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * mono_method;

      D.38785 = m->inst;
      type = mono_reflection_type_get_handle (D.38785);
      inflated_klass = mono_class_from_mono_type (type);
      D.38786 = m->mb;
      D.38787 = D.38786->vtable;
      D.38788 = D.38787->klass;
      D.38789 = is_sre_method_builder (D.38788);
      if (D.38789 != 0) goto <D.38790>; else goto <D.38791>;
      <D.38790>:
      D.38786 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethodBuilder *)D.38786].mhandle;
      goto <D.38792>;
      <D.38791>:
      D.38786 = m->mb;
      D.38787 = D.38786->vtable;
      D.38788 = D.38787->klass;
      D.38793 = is_sr_mono_method (D.38788);
      if (D.38793 != 0) goto <D.38794>; else goto <D.38795>;
      <D.38794>:
      D.38786 = m->mb;
      mono_method = MEM[(struct MonoReflectionMethod *)D.38786].method;
      goto <D.38796>;
      <D.38795>:
      D.38786 = m->mb;
      D.38787 = D.38786->vtable;
      D.38788 = D.38787->klass;
      D.38797 = mono_type_get_full_name (D.38788);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.38797);
      <D.23512>:
      goto <D.23512>;
      <D.38796>:
      <D.38792>:
      D.38786 = m->mb;
      result = inflate_mono_method (inflated_klass, mono_method, D.38786);
    }
    <D.38784>:
    D.38774 = result;
    return D.38774;
  }
  <D.38780>:
  D.38798 = class->name;
  D.38799 = class->name_space;
  monoeg_g_log (0B, 4, "Can\'t handle methods of type %s:%s", D.38799, D.38798);
  <D.23513>:
  goto <D.23513>;
  D.38774 = 0B;
  return D.38774;
}


mono_reflection_event_builder_get_event_info (struct MonoReflectionTypeBuilder * tb, struct MonoReflectionEventBuilder * eb)
{
  struct MonoType * D.38801;
  unsigned int D.38802;
  struct MonoString * D.38803;
  char * D.38804;
  struct MonoReflectionMethodBuilder * D.38805;
  struct MonoMethod * D.38808;
  struct MonoReflectionMethodBuilder * D.38809;
  struct MonoMethod * D.38812;
  struct MonoReflectionMethodBuilder * D.38813;
  struct MonoMethod * D.38816;
  struct MonoArray * D.38817;
  long unsigned int D.38820;
  long unsigned int D.38821;
  long unsigned int D.38822;
  void * D.38823;
  long unsigned int D.38824;
  char * D.38825;
  struct MonoMethod * * D.38826;
  long unsigned int D.38827;
  long unsigned int D.38828;
  struct MonoMethod * * D.38829;
  struct MonoMethod * D.38830;
  long unsigned int D.38831;
  struct MonoReflectionEvent * D.38832;
  struct MonoVTable * D.38833;
  struct MonoDomain * D.38834;
  struct MonoEvent * event;
  struct MonoClass * klass;

  event = monoeg_malloc0 (56);
  D.38801 = mono_reflection_type_get_handle (tb);
  klass = mono_class_from_mono_type (D.38801);
  event->parent = klass;
  D.38802 = eb->attrs;
  event->attrs = D.38802;
  D.38803 = eb->name;
  D.38804 = mono_string_to_utf8 (D.38803);
  event->name = D.38804;
  D.38805 = eb->add_method;
  if (D.38805 != 0B) goto <D.38806>; else goto <D.38807>;
  <D.38806>:
  D.38805 = eb->add_method;
  D.38808 = D.38805->mhandle;
  event->add = D.38808;
  <D.38807>:
  D.38809 = eb->remove_method;
  if (D.38809 != 0B) goto <D.38810>; else goto <D.38811>;
  <D.38810>:
  D.38809 = eb->remove_method;
  D.38812 = D.38809->mhandle;
  event->remove = D.38812;
  <D.38811>:
  D.38813 = eb->raise_method;
  if (D.38813 != 0B) goto <D.38814>; else goto <D.38815>;
  <D.38814>:
  D.38813 = eb->raise_method;
  D.38816 = D.38813->mhandle;
  event->raise = D.38816;
  <D.38815>:
  D.38817 = eb->other_methods;
  if (D.38817 != 0B) goto <D.38818>; else goto <D.38819>;
  <D.38818>:
  {
    int j;

    D.38817 = eb->other_methods;
    D.38820 = mono_array_length (D.38817);
    D.38821 = D.38820 + 1;
    D.38822 = D.38821 * 8;
    D.38823 = monoeg_malloc0 (D.38822);
    event->other = D.38823;
    j = 0;
    goto <D.23593>;
    <D.23592>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.38824 = (long unsigned int) j;
      D.38817 = eb->other_methods;
      D.38825 = mono_array_addr_with_size (D.38817, 8, D.38824);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.38825];
      D.38826 = event->other;
      D.38827 = (long unsigned int) j;
      D.38828 = D.38827 * 8;
      D.38829 = D.38826 + D.38828;
      D.38830 = mb->mhandle;
      *D.38829 = D.38830;
    }
    j = j + 1;
    <D.23593>:
    D.38824 = (long unsigned int) j;
    D.38817 = eb->other_methods;
    D.38831 = mono_array_length (D.38817);
    if (D.38824 < D.38831) goto <D.23592>; else goto <D.23594>;
    <D.23594>:
  }
  <D.38819>:
  D.38833 = MEM[(struct MonoObject *)tb].vtable;
  D.38834 = D.38833->domain;
  D.38832 = mono_event_get_object (D.38834, klass, event);
  return D.38832;
}


mono_reflection_create_runtime_class (struct MonoReflectionTypeBuilder * tb)
{
  struct MonoVTable * D.38836;
  struct MonoType * D.38837;
  struct MonoObject * D.38838;
  struct MonoReflectionType * D.38839;
  struct MonoArray * D.38840;
  struct MonoArray * D.38841;
  long unsigned int D.38844;
  char * D.38845;
  struct MonoObject * D.38848;
  struct MonoReflectionType * D.38849;
  struct MonoArray * D.38850;
  struct MonoArray * D.38851;
  struct MonoReflectionMarshal * D.38852;
  struct MonoObject * D.38855;
  struct MonoReflectionType * D.38858;
  long unsigned int D.38859;
  struct MonoArray * D.38860;
  char * D.38863;
  struct MonoObject * D.38866;
  struct MonoReflectionType * D.38867;
  struct MonoArray * D.38868;
  struct MonoArray * D.38869;
  struct MonoArray * D.38870;
  struct MonoArray * D.38871;
  long unsigned int D.38874;
  char * D.38875;
  struct MonoArray * D.38876;
  long unsigned int D.38877;
  struct MonoArray * D.38878;
  char * D.38881;
  struct MonoArray * D.38882;
  long unsigned int D.38883;
  long unsigned int D.38884;
  struct MonoArray * D.38885;
  char * D.38888;
  struct MonoArray * D.38891;
  struct MonoArray * D.38892;
  char * D.38895;
  struct MonoArray * D.38896;
  long unsigned int D.38897;
  struct MonoArray * D.38898;
  char * D.38901;
  struct MonoArray * D.38902;
  long unsigned int D.38903;
  long unsigned int D.38904;
  struct MonoArray * D.38905;
  struct MonoImage * D.38906;
  union mono_mutex_t * D.38907;
  _Bool D.38910;
  long int D.38911;
  long int D.38912;
  unsigned char D.38915;
  unsigned char D.38916;
  _Bool D.38921;
  long int D.38922;
  long int D.38923;
  struct MonoReflectionType * D.38926;
  struct MonoType * D.38927;
  struct MonoDomain * D.38928;
  unsigned int D.38929;
  struct MonoClass * D.38930;
  unsigned char D.38931;
  struct MonoArray * D.38934;
  char * D.38937;
  struct MonoClassExt * D.38938;
  struct MonoType * D.38939;
  struct MonoClass * D.38940;
  struct GList * D.38941;
  struct GList * D.38942;
  long unsigned int D.38943;
  unsigned char D.38946;
  unsigned char D.38947;
  int D.38950;
  unsigned char D.38951;
  <unnamed-unsigned:1> D.38952;
  unsigned char D.38953;
  <unnamed-unsigned:1> D.38954;
  unsigned char D.38955;
  unsigned char D.38956;
  <unnamed-unsigned:1> D.38957;
  int D.38959;
  int D.38961;
  int D.38963;
  struct MonoGHashTable * D.38965;
  struct MonoGenericContainer * D.38968;
  _Bool D.38973;
  long int D.38974;
  long int D.38975;
  int D.38980;
  struct MonoString * D.38983;
  struct MonoException * D.38984;
  _Bool D.38985;
  long int D.38986;
  long int D.38987;
  _Bool D.38992;
  long int D.38993;
  long int D.38994;
  struct MonoError error;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoReflectionType * res;
  int i;
  int j;
  void failure = <<< error >>>;

  try
    {
      D.38836 = MEM[(struct MonoObject *)tb].vtable;
      domain = D.38836->domain;
      D.38837 = tb->type.type;
      klass = mono_class_from_mono_type (D.38837);
      D.38838 = tb->parent;
      D.38839 = mono_reflection_type_resolve_user_types (D.38838);
      tb->parent = D.38839;
      D.38840 = tb->interfaces;
      check_array_for_usertypes (D.38840);
      D.38841 = tb->fields;
      if (D.38841 != 0B) goto <D.38842>; else goto <D.38843>;
      <D.38842>:
      i = 0;
      goto <D.23639>;
      <D.23638>:
      {
        struct MonoReflectionFieldBuilder * fb;

        D.38844 = (long unsigned int) i;
        D.38841 = tb->fields;
        D.38845 = mono_array_addr_with_size (D.38841, 8, D.38844);
        fb = MEM[(void * *)D.38845];
        if (fb != 0B) goto <D.38846>; else goto <D.38847>;
        <D.38846>:
        D.38848 = fb->type;
        D.38849 = mono_reflection_type_resolve_user_types (D.38848);
        fb->type = D.38849;
        D.38850 = fb->modreq;
        check_array_for_usertypes (D.38850);
        D.38851 = fb->modopt;
        check_array_for_usertypes (D.38851);
        D.38852 = fb->marshal_info;
        if (D.38852 != 0B) goto <D.38853>; else goto <D.38854>;
        <D.38853>:
        D.38852 = fb->marshal_info;
        D.38855 = D.38852->marshaltyperef;
        if (D.38855 != 0B) goto <D.38856>; else goto <D.38857>;
        <D.38856>:
        D.38852 = fb->marshal_info;
        D.38852 = fb->marshal_info;
        D.38855 = D.38852->marshaltyperef;
        D.38858 = mono_reflection_type_resolve_user_types (D.38855);
        D.38852->marshaltyperef = D.38858;
        <D.38857>:
        <D.38854>:
        <D.38847>:
      }
      i = i + 1;
      <D.23639>:
      D.38844 = (long unsigned int) i;
      D.38841 = tb->fields;
      D.38859 = mono_array_length (D.38841);
      if (D.38844 < D.38859) goto <D.23638>; else goto <D.23640>;
      <D.23640>:
      <D.38843>:
      D.38860 = tb->methods;
      if (D.38860 != 0B) goto <D.38861>; else goto <D.38862>;
      <D.38861>:
      i = 0;
      goto <D.23649>;
      <D.23648>:
      {
        struct MonoReflectionMethodBuilder * mb;

        D.38844 = (long unsigned int) i;
        D.38860 = tb->methods;
        D.38863 = mono_array_addr_with_size (D.38860, 8, D.38844);
        mb = MEM[(void * *)D.38863];
        if (mb != 0B) goto <D.38864>; else goto <D.38865>;
        <D.38864>:
        D.38866 = mb->rtype;
        D.38867 = mono_reflection_type_resolve_user_types (D.38866);
        mb->rtype = D.38867;
        D.38868 = mb->return_modreq;
        check_array_for_usertypes (D.38868);
        D.38869 = mb->return_modopt;
        check_array_for_usertypes (D.38869);
        D.38870 = mb->parameters;
        check_array_for_usertypes (D.38870);
        D.38871 = mb->param_modreq;
        if (D.38871 != 0B) goto <D.38872>; else goto <D.38873>;
        <D.38872>:
        j = 0;
        goto <D.23643>;
        <D.23642>:
        D.38874 = (long unsigned int) j;
        D.38871 = mb->param_modreq;
        D.38875 = mono_array_addr_with_size (D.38871, 8, D.38874);
        D.38876 = MEM[(struct MonoArray * *)D.38875];
        check_array_for_usertypes (D.38876);
        j = j + 1;
        <D.23643>:
        D.38874 = (long unsigned int) j;
        D.38871 = mb->param_modreq;
        D.38877 = mono_array_length (D.38871);
        if (D.38874 < D.38877) goto <D.23642>; else goto <D.23644>;
        <D.23644>:
        <D.38873>:
        D.38878 = mb->param_modopt;
        if (D.38878 != 0B) goto <D.38879>; else goto <D.38880>;
        <D.38879>:
        j = 0;
        goto <D.23646>;
        <D.23645>:
        D.38874 = (long unsigned int) j;
        D.38878 = mb->param_modopt;
        D.38881 = mono_array_addr_with_size (D.38878, 8, D.38874);
        D.38882 = MEM[(struct MonoArray * *)D.38881];
        check_array_for_usertypes (D.38882);
        j = j + 1;
        <D.23646>:
        D.38874 = (long unsigned int) j;
        D.38878 = mb->param_modopt;
        D.38883 = mono_array_length (D.38878);
        if (D.38874 < D.38883) goto <D.23645>; else goto <D.23647>;
        <D.23647>:
        <D.38880>:
        <D.38865>:
      }
      i = i + 1;
      <D.23649>:
      D.38844 = (long unsigned int) i;
      D.38860 = tb->methods;
      D.38884 = mono_array_length (D.38860);
      if (D.38844 < D.38884) goto <D.23648>; else goto <D.23650>;
      <D.23650>:
      <D.38862>:
      D.38885 = tb->ctors;
      if (D.38885 != 0B) goto <D.38886>; else goto <D.38887>;
      <D.38886>:
      i = 0;
      goto <D.23659>;
      <D.23658>:
      {
        struct MonoReflectionCtorBuilder * mb;

        D.38844 = (long unsigned int) i;
        D.38885 = tb->ctors;
        D.38888 = mono_array_addr_with_size (D.38885, 8, D.38844);
        mb = MEM[(void * *)D.38888];
        if (mb != 0B) goto <D.38889>; else goto <D.38890>;
        <D.38889>:
        D.38891 = mb->parameters;
        check_array_for_usertypes (D.38891);
        D.38892 = mb->param_modreq;
        if (D.38892 != 0B) goto <D.38893>; else goto <D.38894>;
        <D.38893>:
        j = 0;
        goto <D.23653>;
        <D.23652>:
        D.38874 = (long unsigned int) j;
        D.38892 = mb->param_modreq;
        D.38895 = mono_array_addr_with_size (D.38892, 8, D.38874);
        D.38896 = MEM[(struct MonoArray * *)D.38895];
        check_array_for_usertypes (D.38896);
        j = j + 1;
        <D.23653>:
        D.38874 = (long unsigned int) j;
        D.38892 = mb->param_modreq;
        D.38897 = mono_array_length (D.38892);
        if (D.38874 < D.38897) goto <D.23652>; else goto <D.23654>;
        <D.23654>:
        <D.38894>:
        D.38898 = mb->param_modopt;
        if (D.38898 != 0B) goto <D.38899>; else goto <D.38900>;
        <D.38899>:
        j = 0;
        goto <D.23656>;
        <D.23655>:
        D.38874 = (long unsigned int) j;
        D.38898 = mb->param_modopt;
        D.38901 = mono_array_addr_with_size (D.38898, 8, D.38874);
        D.38902 = MEM[(struct MonoArray * *)D.38901];
        check_array_for_usertypes (D.38902);
        j = j + 1;
        <D.23656>:
        D.38874 = (long unsigned int) j;
        D.38898 = mb->param_modopt;
        D.38903 = mono_array_length (D.38898);
        if (D.38874 < D.38903) goto <D.23655>; else goto <D.23657>;
        <D.23657>:
        <D.38900>:
        <D.38890>:
      }
      i = i + 1;
      <D.23659>:
      D.38844 = (long unsigned int) i;
      D.38885 = tb->ctors;
      D.38904 = mono_array_length (D.38885);
      if (D.38844 < D.38904) goto <D.23658>; else goto <D.23660>;
      <D.23660>:
      <D.38887>:
      D.38905 = tb->cattrs;
      D.38906 = klass->image;
      mono_save_custom_attrs (D.38906, klass, D.38905);
      mono_loader_lock ();
      {
        int ret;

        D.38907 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.38907);
        if (ret != 0) goto <D.38908>; else goto <D.38909>;
        <D.38908>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.38909>:
        D.38910 = ret != 0;
        D.38911 = (long int) D.38910;
        D.38912 = __builtin_expect (D.38911, 0);
        if (D.38912 != 0) goto <D.38913>; else goto <D.38914>;
        <D.38913>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11312, "ret == 0");
        <D.38914>:
      }
      D.38915 = BIT_FIELD_REF <*klass, 8, 256>;
      D.38916 = D.38915 & 128;
      if (D.38916 != 0) goto <D.38917>; else goto <D.38918>;
      <D.38917>:
      {
        int ret;

        D.38907 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38907);
        if (ret != 0) goto <D.38919>; else goto <D.38920>;
        <D.38919>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38920>:
        D.38921 = ret != 0;
        D.38922 = (long int) D.38921;
        D.38923 = __builtin_expect (D.38922, 0);
        if (D.38923 != 0) goto <D.38924>; else goto <D.38925>;
        <D.38924>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11314, "ret == 0");
        <D.38925>:
      }
      mono_loader_unlock ();
      D.38927 = &klass->byval_arg;
      D.38836 = MEM[(struct MonoObject *)tb].vtable;
      D.38928 = D.38836->domain;
      D.38926 = mono_type_get_object (D.38928, D.38927);
      return D.38926;
      <D.38918>:
      D.38929 = tb->attrs;
      klass->flags = D.38929;
      klass->has_cctor = 1;
      klass->has_finalize = 1;
      klass->has_finalize_inited = 1;
      klass->supertypes = 0B;
      D.38930 = klass->parent;
      mono_class_setup_parent (klass, D.38930);
      mono_class_setup_mono_type (klass);
      D.38915 = BIT_FIELD_REF <*klass, 8, 256>;
      D.38931 = D.38915 & 16;
      if (D.38931 == 0) goto <D.38932>; else goto <D.38933>;
      <D.38932>:
      ensure_runtime_vtable (klass);
      <D.38933>:
      D.38934 = tb->subtypes;
      if (D.38934 != 0B) goto <D.38935>; else goto <D.38936>;
      <D.38935>:
      i = 0;
      goto <D.23665>;
      <D.23664>:
      {
        struct MonoReflectionTypeBuilder * subtb;

        D.38844 = (long unsigned int) i;
        D.38934 = tb->subtypes;
        D.38937 = mono_array_addr_with_size (D.38934, 8, D.38844);
        subtb = MEM[(struct MonoReflectionTypeBuilder * *)D.38937];
        mono_class_alloc_ext (klass);
        D.38938 = klass->ext;
        D.38939 = mono_reflection_type_get_handle (subtb);
        D.38940 = mono_class_from_mono_type (D.38939);
        D.38938 = klass->ext;
        D.38941 = D.38938->nested_classes;
        D.38906 = klass->image;
        D.38942 = g_list_prepend_image (D.38906, D.38941, D.38940);
        D.38938->nested_classes = D.38942;
      }
      i = i + 1;
      <D.23665>:
      D.38844 = (long unsigned int) i;
      D.38934 = tb->subtypes;
      D.38943 = mono_array_length (D.38934);
      if (D.38844 < D.38943) goto <D.23664>; else goto <D.23666>;
      <D.23666>:
      <D.38936>:
      klass->nested_classes_inited = 1;
      D.38930 = klass->parent;
      if (D.38930 != 0B) goto <D.38944>; else goto <D.38945>;
      <D.38944>:
      D.38930 = klass->parent;
      D.38946 = BIT_FIELD_REF <*D.38930, 8, 256>;
      D.38947 = D.38946 & 4;
      if (D.38947 == 0) goto <D.38948>; else goto <D.38949>;
      <D.38948>:
      D.38930 = klass->parent;
      mono_class_init (D.38930);
      <D.38949>:
      D.38930 = klass->parent;
      D.38950 = D.38930->instance_size;
      klass->instance_size = D.38950;
      klass->sizes.class_size = 0;
      D.38930 = klass->parent;
      D.38951 = D.38930->min_align;
      klass->min_align = D.38951;
      D.38952 = klass->has_references;
      D.38953 = (unsigned char) D.38952;
      D.38930 = klass->parent;
      D.38954 = D.38930->has_references;
      D.38955 = (unsigned char) D.38954;
      D.38956 = D.38953 | D.38955;
      D.38957 = (<unnamed-unsigned:1>) D.38956;
      klass->has_references = D.38957;
      goto <D.38958>;
      <D.38945>:
      klass->instance_size = 16;
      klass->min_align = 1;
      <D.38958>:
      typebuilder_setup_fields (klass, &error);
      D.38959 = mono_error_ok (&error);
      if (D.38959 == 0) goto failure; else goto <D.38960>;
      <D.38960>:
      typebuilder_setup_properties (klass, &error);
      D.38961 = mono_error_ok (&error);
      if (D.38961 == 0) goto failure; else goto <D.38962>;
      <D.38962>:
      typebuilder_setup_events (klass, &error);
      D.38963 = mono_error_ok (&error);
      if (D.38963 == 0) goto failure; else goto <D.38964>;
      <D.38964>:
      klass->wastypebuilder = 1;
      D.38965 = domain->type_hash;
      if (D.38965 != 0B) goto <D.38966>; else goto <D.38967>;
      <D.38966>:
      D.38968 = klass->generic_container;
      if (D.38968 != 0B) goto <D.38969>; else goto <D.38970>;
      <D.38969>:
      D.38965 = domain->type_hash;
      mono_g_hash_table_foreach_remove (D.38965, remove_instantiations_of_and_ensure_contents, klass);
      <D.38970>:
      <D.38967>:
      {
        int ret;

        D.38907 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38907);
        if (ret != 0) goto <D.38971>; else goto <D.38972>;
        <D.38971>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38972>:
        D.38973 = ret != 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", 11398, "ret == 0");
        <D.38977>:
      }
      mono_loader_unlock ();
      D.38915 = BIT_FIELD_REF <*klass, 8, 256>;
      D.38931 = D.38915 & 16;
      if (D.38931 != 0) goto <D.38978>; else goto <D.38979>;
      <D.38978>:
      D.38980 = mono_class_is_valid_enum (klass);
      if (D.38980 == 0) goto <D.38981>; else goto <D.38982>;
      <D.38981>:
      mono_class_set_failure (klass, 7, 0B);
      D.38983 = tb->name;
      D.38984 = mono_get_exception_type_load (D.38983, 0B);
      mono_raise_exception (D.38984);
      <D.38982>:
      <D.38979>:
      D.38927 = &klass->byval_arg;
      D.38836 = MEM[(struct MonoObject *)tb].vtable;
      D.38928 = D.38836->domain;
      res = mono_type_get_object (D.38928, D.38927);
      D.38985 = res == tb;
      D.38986 = (long int) D.38985;
      D.38987 = __builtin_expect (D.38986, 0);
      if (D.38987 != 0) goto <D.38988>; else goto <D.38989>;
      <D.38988>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11407, "res != (MonoReflectionType*)tb");
      <D.38989>:
      D.38926 = res;
      return D.38926;
      failure:
      mono_class_set_failure (klass, 7, 0B);
      klass->wastypebuilder = 1;
      {
        int ret;

        D.38907 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.38907);
        if (ret != 0) goto <D.38990>; else goto <D.38991>;
        <D.38990>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.38991>:
        D.38992 = ret != 0;
        D.38993 = (long int) D.38992;
        D.38994 = __builtin_expect (D.38993, 0);
        if (D.38994 != 0) goto <D.38995>; else goto <D.38996>;
        <D.38995>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11414, "ret == 0");
        <D.38996>:
      }
      mono_loader_unlock ();
      mono_error_raise_exception (&error);
      D.38926 = 0B;
      return D.38926;
    }
  finally
    {
      error = {CLOBBER};
    }
}


remove_instantiations_of_and_ensure_contents (void * key, void * value, void * user_data)
{
  unsigned char D.39000;
  struct MonoGenericClass * D.39002;
  struct MonoClass * D.39003;
  struct MonoClass * D.39005;
  gboolean D.39006;
  struct MonoType * type;
  struct MonoClass * klass;

  type = key;
  klass = user_data;
  D.39000 = type->type;
  if (D.39000 == 21) goto <D.39001>; else goto <D.38999>;
  <D.39001>:
  D.39002 = type->data.generic_class;
  D.39003 = D.39002->container_class;
  if (D.39003 == klass) goto <D.39004>; else goto <D.38999>;
  <D.39004>:
  D.39005 = mono_class_from_mono_type (type);
  fix_partial_generic_class (D.39005);
  D.39006 = 1;
  return D.39006;
  <D.38999>:
  D.39006 = 0;
  return D.39006;
}


fix_partial_generic_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.39008;
  unsigned char D.39009;
  unsigned char D.39010;
  struct MonoClass * D.39013;
  struct MonoClass * D.39014;
  struct MonoGenericContext * D.39017;
  struct MonoType * D.39018;
  int D.39019;
  unsigned char D.39025;
  unsigned char D.39026;
  unsigned int D.39029;
  unsigned int D.39032;
  unsigned int D.39033;
  unsigned int D.39036;
  unsigned int D.39037;
  struct MonoImage * D.39038;
  void * D.39039;
  struct MonoMethod * * D.39040;
  long unsigned int D.39041;
  long unsigned int D.39042;
  struct MonoMethod * * D.39043;
  struct MonoGenericContext * D.39044;
  struct MonoMethod * * D.39045;
  struct MonoMethod * * D.39046;
  struct MonoMethod * D.39047;
  struct MonoMethod * D.39048;
  unsigned int i.607;
  short unsigned int D.39050;
  short unsigned int D.39053;
  unsigned int D.39056;
  unsigned int D.39057;
  void * D.39058;
  struct MonoGenericContext * D.39059;
  struct MonoClass * * D.39060;
  struct MonoClass * * D.39061;
  struct MonoClass * D.39062;
  struct MonoType * D.39063;
  struct MonoClass * * D.39064;
  struct MonoClass * * D.39065;
  struct MonoClass * D.39066;
  struct MonoClass * D.39067;
  int D.39068;
  unsigned int D.39069;
  unsigned int D.39070;
  unsigned int D.39073;
  void * D.39074;
  struct MonoClassField * D.39075;
  long unsigned int D.39076;
  struct MonoClassField * D.39077;
  struct MonoClassField * D.39078;
  struct MonoClassField * D.39079;
  struct MonoGenericContext * D.39080;
  struct MonoType * D.39081;
  struct MonoType * D.39082;
  struct MonoClass * gklass;
  struct MonoDynamicGenericClass * dgclass;
  int i;

  D.39008 = klass->generic_class;
  gklass = D.39008->container_class;
  D.39009 = BIT_FIELD_REF <*klass, 8, 256>;
  D.39010 = D.39009 & 128;
  if (D.39010 != 0) goto <D.39011>; else goto <D.39012>;
  <D.39011>:
  return;
  <D.39012>:
  dgclass = klass->generic_class;
  D.39013 = klass->parent;
  D.39014 = gklass->parent;
  if (D.39013 != D.39014) goto <D.39015>; else goto <D.39016>;
  <D.39015>:
  {
    struct MonoError error;
    struct MonoType * parent_type;

    try
      {
        D.39008 = klass->generic_class;
        D.39017 = &D.39008->context;
        D.39014 = gklass->parent;
        D.39018 = &D.39014->byval_arg;
        parent_type = mono_class_inflate_generic_type_checked (D.39018, D.39017, &error);
        D.39019 = mono_error_ok (&error);
        if (D.39019 != 0) goto <D.39020>; else goto <D.39021>;
        <D.39020>:
        {
          struct MonoClass * parent;

          parent = mono_class_from_mono_type (parent_type);
          mono_metadata_free_type (parent_type);
          D.39013 = klass->parent;
          if (D.39013 != parent) goto <D.39022>; else goto <D.39023>;
          <D.39022>:
          klass->supertypes = 0B;
          mono_class_setup_parent (klass, parent);
          <D.39023>:
        }
        goto <D.39024>;
        <D.39021>:
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        D.39025 = BIT_FIELD_REF <*gklass, 8, 256>;
        D.39026 = D.39025 & 128;
        if (D.39026 != 0) goto <D.39027>; else goto <D.39028>;
        <D.39027>:
        klass->wastypebuilder = 1;
        <D.39028>:
        return;
        <D.39024>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.39016>:
  D.39029 = dgclass->initialized;
  if (D.39029 == 0) goto <D.39030>; else goto <D.39031>;
  <D.39030>:
  return;
  <D.39031>:
  D.39032 = klass->method.count;
  D.39033 = gklass->method.count;
  if (D.39032 != D.39033) goto <D.39034>; else goto <D.39035>;
  <D.39034>:
  D.39033 = gklass->method.count;
  klass->method.count = D.39033;
  D.39032 = klass->method.count;
  D.39036 = D.39032 + 1;
  D.39037 = D.39036 * 8;
  D.39038 = klass->image;
  D.39039 = mono_image_alloc (D.39038, D.39037);
  klass->methods = D.39039;
  i = 0;
  goto <D.23466>;
  <D.23465>:
  D.39040 = klass->methods;
  D.39041 = (long unsigned int) i;
  D.39042 = D.39041 * 8;
  D.39043 = D.39040 + D.39042;
  D.39044 = mono_class_get_context (klass);
  D.39045 = gklass->methods;
  D.39041 = (long unsigned int) i;
  D.39042 = D.39041 * 8;
  D.39046 = D.39045 + D.39042;
  D.39047 = *D.39046;
  D.39048 = mono_class_inflate_generic_method_full (D.39047, klass, D.39044);
  *D.39043 = D.39048;
  i = i + 1;
  <D.23466>:
  i.607 = (unsigned int) i;
  D.39032 = klass->method.count;
  if (i.607 < D.39032) goto <D.23465>; else goto <D.23467>;
  <D.23467>:
  <D.39035>:
  D.39050 = klass->interface_count;
  if (D.39050 != 0) goto <D.39051>; else goto <D.39052>;
  <D.39051>:
  D.39050 = klass->interface_count;
  D.39053 = gklass->interface_count;
  if (D.39050 != D.39053) goto <D.39054>; else goto <D.39055>;
  <D.39054>:
  D.39053 = gklass->interface_count;
  klass->interface_count = D.39053;
  D.39053 = gklass->interface_count;
  D.39056 = (unsigned int) D.39053;
  D.39057 = D.39056 * 8;
  D.39038 = klass->image;
  D.39058 = mono_image_alloc (D.39038, D.39057);
  klass->interfaces = D.39058;
  klass->interfaces_packed = 0B;
  i = 0;
  goto <D.23470>;
  <D.23469>:
  {
    struct MonoType * iface_type;

    D.39059 = mono_class_get_context (klass);
    D.39060 = gklass->interfaces;
    D.39041 = (long unsigned int) i;
    D.39042 = D.39041 * 8;
    D.39061 = D.39060 + D.39042;
    D.39062 = *D.39061;
    D.39063 = &D.39062->byval_arg;
    iface_type = mono_class_inflate_generic_type (D.39063, D.39059);
    D.39064 = klass->interfaces;
    D.39041 = (long unsigned int) i;
    D.39042 = D.39041 * 8;
    D.39065 = D.39064 + D.39042;
    D.39066 = mono_class_from_mono_type (iface_type);
    *D.39065 = D.39066;
    mono_metadata_free_type (iface_type);
    D.39064 = klass->interfaces;
    D.39041 = (long unsigned int) i;
    D.39042 = D.39041 * 8;
    D.39065 = D.39064 + D.39042;
    D.39067 = *D.39065;
    ensure_runtime_vtable (D.39067);
  }
  i = i + 1;
  <D.23470>:
  D.39053 = gklass->interface_count;
  D.39068 = (int) D.39053;
  if (D.39068 > i) goto <D.23469>; else goto <D.23471>;
  <D.23471>:
  klass->interfaces_inited = 1;
  <D.39055>:
  <D.39052>:
  D.39069 = klass->field.count;
  D.39070 = gklass->field.count;
  if (D.39069 != D.39070) goto <D.39071>; else goto <D.39072>;
  <D.39071>:
  D.39070 = gklass->field.count;
  klass->field.count = D.39070;
  D.39069 = klass->field.count;
  D.39073 = D.39069 * 32;
  D.39038 = klass->image;
  D.39074 = image_g_malloc0 (D.39038, D.39073);
  klass->fields = D.39074;
  i = 0;
  goto <D.23473>;
  <D.23472>:
  D.39075 = klass->fields;
  D.39041 = (long unsigned int) i;
  D.39076 = D.39041 * 32;
  D.39077 = D.39075 + D.39076;
  D.39078 = gklass->fields;
  D.39041 = (long unsigned int) i;
  D.39076 = D.39041 * 32;
  D.39079 = D.39078 + D.39076;
  *D.39077 = *D.39079;
  D.39075 = klass->fields;
  D.39041 = (long unsigned int) i;
  D.39076 = D.39041 * 32;
  D.39077 = D.39075 + D.39076;
  D.39077->parent = klass;
  D.39075 = klass->fields;
  D.39041 = (long unsigned int) i;
  D.39076 = D.39041 * 32;
  D.39077 = D.39075 + D.39076;
  D.39080 = mono_class_get_context (klass);
  D.39078 = gklass->fields;
  D.39041 = (long unsigned int) i;
  D.39076 = D.39041 * 32;
  D.39079 = D.39078 + D.39076;
  D.39081 = D.39079->type;
  D.39082 = mono_class_inflate_generic_type (D.39081, D.39080);
  D.39077->type = D.39082;
  i = i + 1;
  <D.23473>:
  i.607 = (unsigned int) i;
  D.39069 = klass->field.count;
  if (i.607 < D.39069) goto <D.23472>; else goto <D.23474>;
  <D.23474>:
  <D.39072>:
  D.39025 = BIT_FIELD_REF <*gklass, 8, 256>;
  D.39026 = D.39025 & 128;
  if (D.39026 != 0) goto <D.39083>; else goto <D.39084>;
  <D.39083>:
  klass->wastypebuilder = 1;
  <D.39084>:
  return;
}


check_array_for_usertypes (struct MonoArray * arr)
{
  long unsigned int D.39090;
  char * D.39091;
  long unsigned int D.39092;
  int i;

  if (arr == 0B) goto <D.39088>; else goto <D.39089>;
  <D.39088>:
  return;
  <D.39089>:
  i = 0;
  goto <D.23626>;
  <D.23625>:
  {
    struct MonoReflectionType * __type;

    D.39090 = (long unsigned int) i;
    D.39091 = mono_array_addr_with_size (arr, 8, D.39090);
    __type = MEM[(struct MonoReflectionType * *)D.39091];
    __type = mono_reflection_type_resolve_user_types (__type);
    {
      struct MonoReflectionType * * __p;

      D.39090 = (long unsigned int) i;
      __p = mono_array_addr_with_size (arr, 8, D.39090);
      *__p = __type;
    }
  }
  i = i + 1;
  <D.23626>:
  D.39090 = (long unsigned int) i;
  D.39092 = mono_array_length (arr);
  if (D.39090 < D.39092) goto <D.23625>; else goto <D.23627>;
  <D.23627>:
}


ensure_runtime_vtable (struct MonoClass * klass)
{
  struct MonoImage * D.39097;
  unsigned char D.39098;
  unsigned char D.39099;
  struct MonoGenericClass * D.39102;
  unsigned char D.39103;
  unsigned char D.39104;
  struct MonoClass * D.39105;
  int iftmp.608;
  struct MonoArray * D.39111;
  long unsigned int D.39114;
  int D.39116;
  unsigned int num.609;
  long unsigned int D.39118;
  unsigned int D.39119;
  unsigned int D.39120;
  void * D.39121;
  int iftmp.610;
  long unsigned int D.39125;
  struct MonoMethod * * D.39127;
  long unsigned int D.39128;
  long unsigned int D.39129;
  struct MonoMethod * * D.39130;
  long unsigned int D.39131;
  char * D.39132;
  struct MonoReflectionCtorBuilder * D.39133;
  struct MonoMethod * D.39134;
  int j.611;
  long unsigned int D.39136;
  long unsigned int D.39137;
  struct MonoMethod * * D.39138;
  struct MonoArray * D.39139;
  char * D.39140;
  struct MonoReflectionMethodBuilder * D.39141;
  struct MonoMethod * D.39142;
  struct MonoArray * D.39143;
  long unsigned int D.39146;
  short unsigned int D.39147;
  short unsigned int D.39148;
  unsigned int D.39149;
  unsigned int D.39150;
  void * D.39151;
  char * D.39152;
  void * D.39153;
  struct MonoClass * * D.39154;
  struct MonoClass * * D.39155;
  struct MonoClass * D.39156;
  struct MonoClass * D.39157;
  int D.39158;
  unsigned int D.39162;
  unsigned int D.39163;
  short unsigned int D.39166;
  int D.39167;
  int D.39168;
  int slot_num.612;
  short int D.39172;
  unsigned int i.613;
  unsigned int D.39174;
  struct MonoReflectionTypeBuilder * tb;
  int i;
  int num;
  int j;

  tb = mono_class_get_ref_info (klass);
  D.39097 = klass->image;
  D.39098 = BIT_FIELD_REF <*D.39097, 8, 224>;
  D.39099 = D.39098 & 8;
  if (D.39099 == 0) goto <D.39094>; else goto <D.39100>;
  <D.39100>:
  if (tb == 0B) goto <D.39101>; else goto <D.39095>;
  <D.39101>:
  D.39102 = klass->generic_class;
  if (D.39102 == 0B) goto <D.39094>; else goto <D.39095>;
  <D.39095>:
  D.39103 = BIT_FIELD_REF <*klass, 8, 256>;
  D.39104 = D.39103 & 128;
  if (D.39104 != 0) goto <D.39094>; else goto <D.39096>;
  <D.39094>:
  return;
  <D.39096>:
  D.39105 = klass->parent;
  if (D.39105 != 0B) goto <D.39106>; else goto <D.39107>;
  <D.39106>:
  D.39105 = klass->parent;
  ensure_runtime_vtable (D.39105);
  <D.39107>:
  if (tb != 0B) goto <D.39108>; else goto <D.39109>;
  <D.39108>:
  D.39111 = tb->ctors;
  if (D.39111 != 0B) goto <D.39112>; else goto <D.39113>;
  <D.39112>:
  D.39111 = tb->ctors;
  D.39114 = mono_array_length (D.39111);
  iftmp.608 = (int) D.39114;
  goto <D.39115>;
  <D.39113>:
  iftmp.608 = 0;
  <D.39115>:
  num = iftmp.608;
  D.39116 = tb->num_methods;
  num = D.39116 + num;
  num.609 = (unsigned int) num;
  klass->method.count = num.609;
  D.39118 = (long unsigned int) num;
  D.39119 = (unsigned int) D.39118;
  D.39120 = D.39119 * 8;
  D.39097 = klass->image;
  D.39121 = mono_image_alloc (D.39097, D.39120);
  klass->methods = D.39121;
  D.39111 = tb->ctors;
  if (D.39111 != 0B) goto <D.39123>; else goto <D.39124>;
  <D.39123>:
  D.39111 = tb->ctors;
  D.39125 = mono_array_length (D.39111);
  iftmp.610 = (int) D.39125;
  goto <D.39126>;
  <D.39124>:
  iftmp.610 = 0;
  <D.39126>:
  num = iftmp.610;
  i = 0;
  goto <D.23487>;
  <D.23486>:
  D.39127 = klass->methods;
  D.39128 = (long unsigned int) i;
  D.39129 = D.39128 * 8;
  D.39130 = D.39127 + D.39129;
  D.39131 = (long unsigned int) i;
  D.39111 = tb->ctors;
  D.39132 = mono_array_addr_with_size (D.39111, 8, D.39131);
  D.39133 = MEM[(struct MonoReflectionCtorBuilder * *)D.39132];
  D.39134 = ctorbuilder_to_mono_method (klass, D.39133);
  *D.39130 = D.39134;
  i = i + 1;
  <D.23487>:
  if (i < num) goto <D.23486>; else goto <D.23488>;
  <D.23488>:
  num = tb->num_methods;
  j = i;
  i = 0;
  goto <D.23490>;
  <D.23489>:
  D.39127 = klass->methods;
  j.611 = j;
  j = j.611 + 1;
  D.39136 = (long unsigned int) j.611;
  D.39137 = D.39136 * 8;
  D.39138 = D.39127 + D.39137;
  D.39131 = (long unsigned int) i;
  D.39139 = tb->methods;
  D.39140 = mono_array_addr_with_size (D.39139, 8, D.39131);
  D.39141 = MEM[(struct MonoReflectionMethodBuilder * *)D.39140];
  D.39142 = methodbuilder_to_mono_method (klass, D.39141);
  *D.39138 = D.39142;
  i = i + 1;
  <D.23490>:
  if (i < num) goto <D.23489>; else goto <D.23491>;
  <D.23491>:
  D.39143 = tb->interfaces;
  if (D.39143 != 0B) goto <D.39144>; else goto <D.39145>;
  <D.39144>:
  D.39143 = tb->interfaces;
  D.39146 = mono_array_length (D.39143);
  D.39147 = (short unsigned int) D.39146;
  klass->interface_count = D.39147;
  D.39148 = klass->interface_count;
  D.39149 = (unsigned int) D.39148;
  D.39150 = D.39149 * 8;
  D.39097 = klass->image;
  D.39151 = mono_image_alloc (D.39097, D.39150);
  klass->interfaces = D.39151;
  i = 0;
  goto <D.23494>;
  <D.23493>:
  {
    struct MonoType * iface;

    D.39131 = (long unsigned int) i;
    D.39143 = tb->interfaces;
    D.39152 = mono_array_addr_with_size (D.39143, 8, D.39131);
    D.39153 = MEM[(void * *)D.39152];
    iface = mono_reflection_type_get_handle (D.39153);
    D.39154 = klass->interfaces;
    D.39128 = (long unsigned int) i;
    D.39129 = D.39128 * 8;
    D.39155 = D.39154 + D.39129;
    D.39156 = mono_class_from_mono_type (iface);
    *D.39155 = D.39156;
    D.39154 = klass->interfaces;
    D.39128 = (long unsigned int) i;
    D.39129 = D.39128 * 8;
    D.39155 = D.39154 + D.39129;
    D.39157 = *D.39155;
    ensure_runtime_vtable (D.39157);
  }
  i = i + 1;
  <D.23494>:
  D.39148 = klass->interface_count;
  D.39158 = (int) D.39148;
  if (D.39158 > i) goto <D.23493>; else goto <D.23495>;
  <D.23495>:
  klass->interfaces_inited = 1;
  <D.39145>:
  goto <D.39159>;
  <D.39109>:
  D.39102 = klass->generic_class;
  if (D.39102 != 0B) goto <D.39160>; else goto <D.39161>;
  <D.39160>:
  ensure_generic_class_runtime_vtable (klass);
  <D.39161>:
  <D.39159>:
  D.39162 = klass->flags;
  D.39163 = D.39162 & 32;
  if (D.39163 != 0) goto <D.39164>; else goto <D.39165>;
  <D.39164>:
  {
    int slot_num;

    slot_num = 0;
    i = 0;
    goto <D.23499>;
    <D.23498>:
    {
      struct MonoMethod * im;

      D.39127 = klass->methods;
      D.39128 = (long unsigned int) i;
      D.39129 = D.39128 * 8;
      D.39130 = D.39127 + D.39129;
      im = *D.39130;
      D.39166 = im->flags;
      D.39167 = (int) D.39166;
      D.39168 = D.39167 & 16;
      if (D.39168 == 0) goto <D.39169>; else goto <D.39170>;
      <D.39169>:
      slot_num.612 = slot_num;
      slot_num = slot_num.612 + 1;
      D.39172 = (short int) slot_num.612;
      im->slot = D.39172;
      <D.39170>:
    }
    i = i + 1;
    <D.23499>:
    i.613 = (unsigned int) i;
    D.39174 = klass->method.count;
    if (i.613 < D.39174) goto <D.23498>; else goto <D.23500>;
    <D.23500>:
    klass->interfaces_packed = 0B;
    mono_class_setup_interface_offsets (klass);
    mono_class_setup_interface_id (klass);
  }
  <D.39165>:
}


ensure_generic_class_runtime_vtable (struct MonoClass * klass)
{
  struct MonoGenericClass * D.39176;
  struct MonoClass * gklass;

  D.39176 = klass->generic_class;
  gklass = D.39176->container_class;
  ensure_runtime_vtable (gklass);
  fix_partial_generic_class (klass);
}


typebuilder_setup_fields (struct MonoClass * klass, struct MonoError * error)
{
  int D.39177;
  unsigned int D.39178;
  int D.39179;
  int D.39182;
  unsigned int D.39183;
  unsigned int D.39184;
  const char * D.39187;
  unsigned char D.39188;
  <unnamed-unsigned:4> D.39189;
  int D.39190;
  int D.39191;
  unsigned int D.39192;
  unsigned int D.39195;
  unsigned int D.39196;
  int D.39197;
  unsigned int D.39198;
  void * D.39199;
  struct MonoClassExt * D.39200;
  unsigned int D.39201;
  void * D.39202;
  long unsigned int D.39203;
  struct MonoArray * D.39204;
  char * D.39205;
  struct MonoClassField * D.39206;
  long unsigned int D.39207;
  long unsigned int D.39208;
  struct MonoString * D.39209;
  char * D.39210;
  int D.39211;
  unsigned int D.39214;
  struct MonoObject * D.39217;
  struct MonoType * D.39218;
  struct MonoImage * D.39219;
  struct MonoType * D.39220;
  struct MonoType * D.39221;
  short unsigned int D.39222;
  struct MonoType * D.39224;
  unsigned int D.39225;
  unsigned int D.39230;
  struct MonoFieldDefaultValue * D.39231;
  long unsigned int D.39232;
  struct MonoFieldDefaultValue * D.39233;
  int D.39234;
  struct MonoArray * D.39237;
  unsigned char D.39238;
  unsigned char D.39239;
  short unsigned int D.39242;
  int D.39243;
  int D.39244;
  struct MonoClass * D.39247;
  struct MonoClass * D.39248;
  struct MonoObject * D.39249;
  short unsigned int D.39252;
  MonoTypeEnum * D.39253;
  char * D.39254;
  sizetype D.39255;
  const char * p2.614;
  long int p2.615;
  long int p.616;
  long int D.39259;
  unsigned int D.39260;
  void * D.39261;
  long unsigned int D.39262;
  const char * D.39263;
  unsigned int i.617;
  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.39177 = tb->num_fields;
      D.39178 = (unsigned int) D.39177;
      klass->field.count = D.39178;
      klass->field.first = 0;
      mono_error_init (error);
      D.39179 = tb->class_size;
      if (D.39179 != 0) goto <D.39180>; else goto <D.39181>;
      <D.39180>:
      D.39182 = tb->packing_size;
      D.39183 = (unsigned int) D.39182;
      D.39184 = D.39183 & 4294967280;
      if (D.39184 != 0) goto <D.39185>; else goto <D.39186>;
      <D.39185>:
      {
        char * err_msg;

        D.39182 = tb->packing_size;
        D.39187 = klass->name;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.39187, D.39182);
        mono_class_set_failure (klass, 7, err_msg);
        return;
      }
      <D.39186>:
      D.39182 = tb->packing_size;
      D.39188 = (unsigned char) D.39182;
      D.39189 = (<unnamed-unsigned:4>) D.39188;
      klass->packing_size = D.39189;
      D.39190 = klass->instance_size;
      D.39179 = tb->class_size;
      D.39191 = D.39190 + D.39179;
      real_size = (guint32) D.39191;
      <D.39181>:
      D.39192 = klass->field.count;
      if (D.39192 == 0) goto <D.39193>; else goto <D.39194>;
      <D.39193>:
      D.39190 = klass->instance_size;
      D.39195 = (unsigned int) D.39190;
      D.39196 = MAX_EXPR <D.39195, real_size>;
      D.39197 = (int) D.39196;
      klass->instance_size = D.39197;
      return;
      <D.39194>:
      D.39192 = klass->field.count;
      D.39198 = D.39192 * 32;
      D.39199 = image_g_malloc0 (image, D.39198);
      klass->fields = D.39199;
      mono_class_alloc_ext (klass);
      D.39200 = klass->ext;
      D.39192 = klass->field.count;
      D.39201 = D.39192 * 16;
      D.39202 = image_g_malloc0 (image, D.39201);
      D.39200->field_def_values = D.39202;
      klass->size_inited = 1;
      i = 0;
      goto <D.23565>;
      <D.23564>:
      {
        struct MonoArray * rva_data;

        D.39203 = (long unsigned int) i;
        D.39204 = tb->fields;
        D.39205 = mono_array_addr_with_size (D.39204, 8, D.39203);
        fb = MEM[(void * *)D.39205];
        D.39206 = klass->fields;
        D.39207 = (long unsigned int) i;
        D.39208 = D.39207 * 32;
        field = D.39206 + D.39208;
        D.39209 = fb->name;
        D.39210 = mono_string_to_utf8_image (image, D.39209, error);
        field->name = D.39210;
        D.39211 = mono_error_ok (error);
        if (D.39211 == 0) goto <D.39212>; else goto <D.39213>;
        <D.39212>:
        return;
        <D.39213>:
        D.39214 = fb->attrs;
        if (D.39214 != 0) goto <D.39215>; else goto <D.39216>;
        <D.39215>:
        D.39217 = fb->type;
        D.39218 = mono_reflection_type_get_handle (D.39217);
        D.39219 = klass->image;
        D.39220 = mono_metadata_type_dup (D.39219, D.39218);
        field->type = D.39220;
        D.39221 = field->type;
        D.39214 = fb->attrs;
        D.39222 = (short unsigned int) D.39214;
        D.39221->attrs = D.39222;
        goto <D.39223>;
        <D.39216>:
        D.39217 = fb->type;
        D.39224 = mono_reflection_type_get_handle (D.39217);
        field->type = D.39224;
        <D.39223>:
        D.39214 = fb->attrs;
        D.39225 = D.39214 & 256;
        if (D.39225 != 0) goto <D.39226>; else goto <D.39227>;
        <D.39226>:
        rva_data = fb->rva_data;
        if (rva_data != 0B) goto <D.39228>; else goto <D.39229>;
        <D.39228>:
        {
          char * base;
          size_t size;
          char * data;

          base = mono_array_addr_with_size (rva_data, 1, 0);
          size = mono_array_length (rva_data);
          D.39230 = (unsigned int) size;
          D.39219 = klass->image;
          data = mono_image_alloc (D.39219, D.39230);
          memcpy (data, base, size);
          D.39200 = klass->ext;
          D.39231 = D.39200->field_def_values;
          D.39207 = (long unsigned int) i;
          D.39232 = D.39207 * 16;
          D.39233 = D.39231 + D.39232;
          D.39233->data = data;
        }
        <D.39229>:
        <D.39227>:
        D.39234 = fb->offset;
        if (D.39234 != -1) goto <D.39235>; else goto <D.39236>;
        <D.39235>:
        D.39234 = fb->offset;
        field->offset = D.39234;
        <D.39236>:
        field->parent = klass;
        fb->handle = field;
        D.39237 = fb->cattrs;
        D.39219 = klass->image;
        mono_save_custom_attrs (D.39219, field, D.39237);
        D.39238 = BIT_FIELD_REF <*klass, 8, 256>;
        D.39239 = D.39238 & 16;
        if (D.39239 != 0) goto <D.39240>; else goto <D.39241>;
        <D.39240>:
        D.39221 = field->type;
        D.39242 = D.39221->attrs;
        D.39243 = (int) D.39242;
        D.39244 = D.39243 & 16;
        if (D.39244 == 0) goto <D.39245>; else goto <D.39246>;
        <D.39245>:
        D.39221 = field->type;
        D.39247 = mono_class_from_mono_type (D.39221);
        klass->element_class = D.39247;
        D.39248 = klass->element_class;
        klass->cast_class = D.39248;
        <D.39246>:
        <D.39241>:
        D.39249 = fb->def_value;
        if (D.39249 != 0B) goto <D.39250>; else goto <D.39251>;
        <D.39250>:
        {
          struct MonoDynamicImage * assembly;

          assembly = klass->image;
          D.39221 = field->type;
          D.39221 = field->type;
          D.39242 = D.39221->attrs;
          D.39252 = D.39242 | 32768;
          D.39221->attrs = D.39252;
          D.39200 = klass->ext;
          D.39231 = D.39200->field_def_values;
          D.39207 = (long unsigned int) i;
          D.39232 = D.39207 * 16;
          D.39233 = D.39231 + D.39232;
          D.39253 = &D.39233->def_type;
          D.39249 = fb->def_value;
          idx = encode_constant (assembly, D.39249, D.39253);
          D.39254 = assembly->blob.data;
          D.39255 = (sizetype) idx;
          p = D.39254 + D.39255;
          len = mono_metadata_decode_blob_size (p, &p2);
          p2.614 = p2;
          p2.615 = (long int) p2.614;
          p.616 = (long int) p;
          D.39259 = p2.615 - p.616;
          D.39260 = (unsigned int) D.39259;
          len = D.39260 + len;
          D.39200 = klass->ext;
          D.39231 = D.39200->field_def_values;
          D.39207 = (long unsigned int) i;
          D.39232 = D.39207 * 16;
          D.39233 = D.39231 + D.39232;
          D.39261 = mono_image_alloc (image, len);
          D.39233->data = D.39261;
          D.39262 = (long unsigned int) len;
          D.39200 = klass->ext;
          D.39231 = D.39200->field_def_values;
          D.39207 = (long unsigned int) i;
          D.39232 = D.39207 * 16;
          D.39233 = D.39231 + D.39232;
          D.39263 = D.39233->data;
          memcpy (D.39263, p, D.39262);
        }
        <D.39251>:
      }
      i = i + 1;
      <D.23565>:
      i.617 = (unsigned int) i;
      D.39192 = klass->field.count;
      if (i.617 < D.39192) goto <D.23564>; else goto <D.23566>;
      <D.23566>:
      D.39190 = klass->instance_size;
      D.39195 = (unsigned int) D.39190;
      D.39196 = MAX_EXPR <D.39195, real_size>;
      D.39197 = (int) D.39196;
      klass->instance_size = D.39197;
      mono_class_layout_fields (klass);
    }
  finally
    {
      p2 = {CLOBBER};
    }
}


typebuilder_setup_properties (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.39268;
  void * D.39271;
  guint32 iftmp.618;
  struct MonoArray * D.39273;
  long unsigned int D.39276;
  unsigned int D.39278;
  unsigned int D.39279;
  long unsigned int D.39280;
  char * D.39281;
  long unsigned int D.39282;
  long unsigned int D.39283;
  struct MonoProperty * D.39284;
  unsigned int D.39285;
  struct MonoString * D.39286;
  char * D.39287;
  int D.39288;
  struct MonoReflectionMethodBuilder * D.39291;
  struct MonoMethod * D.39294;
  struct MonoReflectionMethodBuilder * D.39295;
  struct MonoMethod * D.39298;
  struct MonoArray * D.39299;
  void * D.39300;
  struct MonoImage * D.39301;
  struct MonoObject * D.39302;
  struct MonoFieldDefaultValue * D.39305;
  unsigned int D.39308;
  void * D.39309;
  unsigned int D.39310;
  unsigned int D.39311;
  long unsigned int D.39312;
  struct MonoFieldDefaultValue * D.39313;
  MonoTypeEnum * D.39314;
  char * D.39315;
  sizetype D.39316;
  const char * p2.619;
  long int p2.620;
  long int p.621;
  long int D.39320;
  unsigned int D.39321;
  void * D.39322;
  long unsigned int D.39323;
  const char * D.39324;
  unsigned int i.622;
  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.39268 = klass->ext;
  if (D.39268 == 0B) goto <D.39269>; else goto <D.39270>;
  <D.39269>:
  D.39271 = image_g_malloc0 (image, 64);
  klass->ext = D.39271;
  <D.39270>:
  D.39268 = klass->ext;
  D.39273 = tb->properties;
  if (D.39273 != 0B) goto <D.39274>; else goto <D.39275>;
  <D.39274>:
  D.39273 = tb->properties;
  D.39276 = mono_array_length (D.39273);
  iftmp.618 = (guint32) D.39276;
  goto <D.39277>;
  <D.39275>:
  iftmp.618 = 0;
  <D.39277>:
  D.39268->property.count = iftmp.618;
  D.39268 = klass->ext;
  D.39268->property.first = 0;
  D.39268 = klass->ext;
  D.39278 = D.39268->property.count;
  D.39279 = D.39278 * 40;
  properties = image_g_malloc0 (image, D.39279);
  D.39268 = klass->ext;
  D.39268->properties = properties;
  i = 0;
  goto <D.23582>;
  <D.23581>:
  D.39280 = (long unsigned int) i;
  D.39273 = tb->properties;
  D.39281 = mono_array_addr_with_size (D.39273, 8, D.39280);
  pb = MEM[(struct MonoReflectionPropertyBuilder * *)D.39281];
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39284 = properties + D.39283;
  D.39284->parent = klass;
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39284 = properties + D.39283;
  D.39285 = pb->attrs;
  D.39284->attrs = D.39285;
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39284 = properties + D.39283;
  D.39286 = pb->name;
  D.39287 = mono_string_to_utf8_image (image, D.39286, error);
  D.39284->name = D.39287;
  D.39288 = mono_error_ok (error);
  if (D.39288 == 0) goto <D.39289>; else goto <D.39290>;
  <D.39289>:
  return;
  <D.39290>:
  D.39291 = pb->get_method;
  if (D.39291 != 0B) goto <D.39292>; else goto <D.39293>;
  <D.39292>:
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39284 = properties + D.39283;
  D.39291 = pb->get_method;
  D.39294 = D.39291->mhandle;
  D.39284->get = D.39294;
  <D.39293>:
  D.39295 = pb->set_method;
  if (D.39295 != 0B) goto <D.39296>; else goto <D.39297>;
  <D.39296>:
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39284 = properties + D.39283;
  D.39295 = pb->set_method;
  D.39298 = D.39295->mhandle;
  D.39284->set = D.39298;
  <D.39297>:
  D.39299 = pb->cattrs;
  D.39282 = (long unsigned int) i;
  D.39283 = D.39282 * 40;
  D.39300 = properties + D.39283;
  D.39301 = klass->image;
  mono_save_custom_attrs (D.39301, D.39300, D.39299);
  D.39302 = pb->def_value;
  if (D.39302 != 0B) goto <D.39303>; else goto <D.39304>;
  <D.39303>:
  {
    guint32 len;
    guint32 idx;
    const char * p;
    const char * p2;
    struct MonoDynamicImage * assembly;

    try
      {
        assembly = klass->image;
        D.39268 = klass->ext;
        D.39305 = D.39268->prop_def_values;
        if (D.39305 == 0B) goto <D.39306>; else goto <D.39307>;
        <D.39306>:
        D.39268 = klass->ext;
        D.39268 = klass->ext;
        D.39278 = D.39268->property.count;
        D.39308 = D.39278 * 16;
        D.39309 = image_g_malloc0 (image, D.39308);
        D.39268->prop_def_values = D.39309;
        <D.39307>:
        D.39282 = (long unsigned int) i;
        D.39283 = D.39282 * 40;
        D.39284 = properties + D.39283;
        D.39282 = (long unsigned int) i;
        D.39283 = D.39282 * 40;
        D.39284 = properties + D.39283;
        D.39310 = D.39284->attrs;
        D.39311 = D.39310 | 4096;
        D.39284->attrs = D.39311;
        D.39268 = klass->ext;
        D.39305 = D.39268->prop_def_values;
        D.39282 = (long unsigned int) i;
        D.39312 = D.39282 * 16;
        D.39313 = D.39305 + D.39312;
        D.39314 = &D.39313->def_type;
        D.39302 = pb->def_value;
        idx = encode_constant (assembly, D.39302, D.39314);
        D.39315 = assembly->blob.data;
        D.39316 = (sizetype) idx;
        p = D.39315 + D.39316;
        len = mono_metadata_decode_blob_size (p, &p2);
        p2.619 = p2;
        p2.620 = (long int) p2.619;
        p.621 = (long int) p;
        D.39320 = p2.620 - p.621;
        D.39321 = (unsigned int) D.39320;
        len = D.39321 + len;
        D.39268 = klass->ext;
        D.39305 = D.39268->prop_def_values;
        D.39282 = (long unsigned int) i;
        D.39312 = D.39282 * 16;
        D.39313 = D.39305 + D.39312;
        D.39322 = mono_image_alloc (image, len);
        D.39313->data = D.39322;
        D.39323 = (long unsigned int) len;
        D.39268 = klass->ext;
        D.39305 = D.39268->prop_def_values;
        D.39282 = (long unsigned int) i;
        D.39312 = D.39282 * 16;
        D.39313 = D.39305 + D.39312;
        D.39324 = D.39313->data;
        memcpy (D.39324, p, D.39323);
      }
    finally
      {
        p2 = {CLOBBER};
      }
  }
  <D.39304>:
  i = i + 1;
  <D.23582>:
  i.622 = (unsigned int) i;
  D.39268 = klass->ext;
  D.39278 = D.39268->property.count;
  if (i.622 < D.39278) goto <D.23581>; else goto <D.23583>;
  <D.23583>:
}


typebuilder_setup_events (struct MonoClass * klass, struct MonoError * error)
{
  struct MonoClassExt * D.39327;
  void * D.39330;
  guint32 iftmp.623;
  struct MonoArray * D.39332;
  long unsigned int D.39335;
  unsigned int D.39337;
  unsigned int D.39338;
  long unsigned int D.39339;
  char * D.39340;
  long unsigned int D.39341;
  long unsigned int D.39342;
  struct MonoEvent * D.39343;
  unsigned int D.39344;
  struct MonoString * D.39345;
  char * D.39346;
  int D.39347;
  struct MonoReflectionMethodBuilder * D.39350;
  struct MonoMethod * D.39353;
  struct MonoReflectionMethodBuilder * D.39354;
  struct MonoMethod * D.39357;
  struct MonoReflectionMethodBuilder * D.39358;
  struct MonoMethod * D.39361;
  struct MonoArray * D.39362;
  long unsigned int D.39365;
  long unsigned int D.39366;
  unsigned int D.39367;
  unsigned int D.39368;
  void * D.39369;
  long unsigned int D.39370;
  char * D.39371;
  struct MonoMethod * * D.39372;
  long unsigned int D.39373;
  long unsigned int D.39374;
  struct MonoMethod * * D.39375;
  struct MonoMethod * D.39376;
  long unsigned int D.39377;
  struct MonoArray * D.39378;
  void * D.39379;
  struct MonoImage * D.39380;
  unsigned int i.624;
  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.39327 = klass->ext;
  if (D.39327 == 0B) goto <D.39328>; else goto <D.39329>;
  <D.39328>:
  D.39330 = image_g_malloc0 (image, 64);
  klass->ext = D.39330;
  <D.39329>:
  D.39327 = klass->ext;
  D.39332 = tb->events;
  if (D.39332 != 0B) goto <D.39333>; else goto <D.39334>;
  <D.39333>:
  D.39332 = tb->events;
  D.39335 = mono_array_length (D.39332);
  iftmp.623 = (guint32) D.39335;
  goto <D.39336>;
  <D.39334>:
  iftmp.623 = 0;
  <D.39336>:
  D.39327->event.count = iftmp.623;
  D.39327 = klass->ext;
  D.39327->event.first = 0;
  D.39327 = klass->ext;
  D.39337 = D.39327->event.count;
  D.39338 = D.39337 * 56;
  events = image_g_malloc0 (image, D.39338);
  D.39327 = klass->ext;
  D.39327->events = events;
  i = 0;
  goto <D.23610>;
  <D.23609>:
  D.39339 = (long unsigned int) i;
  D.39332 = tb->events;
  D.39340 = mono_array_addr_with_size (D.39332, 8, D.39339);
  eb = MEM[(struct MonoReflectionEventBuilder * *)D.39340];
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39343->parent = klass;
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39344 = eb->attrs;
  D.39343->attrs = D.39344;
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39345 = eb->name;
  D.39346 = mono_string_to_utf8_image (image, D.39345, error);
  D.39343->name = D.39346;
  D.39347 = mono_error_ok (error);
  if (D.39347 == 0) goto <D.39348>; else goto <D.39349>;
  <D.39348>:
  return;
  <D.39349>:
  D.39350 = eb->add_method;
  if (D.39350 != 0B) goto <D.39351>; else goto <D.39352>;
  <D.39351>:
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39350 = eb->add_method;
  D.39353 = D.39350->mhandle;
  D.39343->add = D.39353;
  <D.39352>:
  D.39354 = eb->remove_method;
  if (D.39354 != 0B) goto <D.39355>; else goto <D.39356>;
  <D.39355>:
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39354 = eb->remove_method;
  D.39357 = D.39354->mhandle;
  D.39343->remove = D.39357;
  <D.39356>:
  D.39358 = eb->raise_method;
  if (D.39358 != 0B) goto <D.39359>; else goto <D.39360>;
  <D.39359>:
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39343 = events + D.39342;
  D.39358 = eb->raise_method;
  D.39361 = D.39358->mhandle;
  D.39343->raise = D.39361;
  <D.39360>:
  D.39362 = eb->other_methods;
  if (D.39362 != 0B) goto <D.39363>; else goto <D.39364>;
  <D.39363>:
  {
    int j;

    D.39341 = (long unsigned int) i;
    D.39342 = D.39341 * 56;
    D.39343 = events + D.39342;
    D.39362 = eb->other_methods;
    D.39365 = mono_array_length (D.39362);
    D.39366 = D.39365 + 1;
    D.39367 = (unsigned int) D.39366;
    D.39368 = D.39367 * 8;
    D.39369 = image_g_malloc0 (image, D.39368);
    D.39343->other = D.39369;
    j = 0;
    goto <D.23607>;
    <D.23606>:
    {
      struct MonoReflectionMethodBuilder * mb;

      D.39370 = (long unsigned int) j;
      D.39362 = eb->other_methods;
      D.39371 = mono_array_addr_with_size (D.39362, 8, D.39370);
      mb = MEM[(struct MonoReflectionMethodBuilder * *)D.39371];
      D.39341 = (long unsigned int) i;
      D.39342 = D.39341 * 56;
      D.39343 = events + D.39342;
      D.39372 = D.39343->other;
      D.39373 = (long unsigned int) j;
      D.39374 = D.39373 * 8;
      D.39375 = D.39372 + D.39374;
      D.39376 = mb->mhandle;
      *D.39375 = D.39376;
    }
    j = j + 1;
    <D.23607>:
    D.39370 = (long unsigned int) j;
    D.39362 = eb->other_methods;
    D.39377 = mono_array_length (D.39362);
    if (D.39370 < D.39377) goto <D.23606>; else goto <D.23608>;
    <D.23608>:
  }
  <D.39364>:
  D.39378 = eb->cattrs;
  D.39341 = (long unsigned int) i;
  D.39342 = D.39341 * 56;
  D.39379 = events + D.39342;
  D.39380 = klass->image;
  mono_save_custom_attrs (D.39380, D.39379, D.39378);
  i = i + 1;
  <D.23610>:
  i.624 = (unsigned int) i;
  D.39327 = klass->ext;
  D.39337 = D.39327->event.count;
  if (i.624 < D.39337) goto <D.23609>; else goto <D.23611>;
  <D.23611>:
}


mono_reflection_initialize_generic_parameter (struct MonoReflectionGenericParam * gparam)
{
  struct MonoReflectionTypeBuilder * D.39383;
  struct MonoReflectionModuleBuilder * D.39384;
  struct MonoDynamicImage * D.39385;
  struct MonoString * D.39386;
  char * D.39387;
  int D.39388;
  _Bool D.39389;
  long int D.39390;
  long int D.39391;
  unsigned int D.39394;
  short unsigned int D.39395;
  struct MonoReflectionMethodBuilder * D.39396;
  struct MonoGenericContainer * D.39399;
  struct MonoType * D.39402;
  struct MonoImage * D.39403;
  void * D.39404;
  struct MonoGenericContainer * D.39408;
  struct MonoType * D.39411;
  struct MonoImage * D.39412;
  void * D.39413;
  _Bool D.39414;
  int D.39415;
  struct MonoType * D.39416;
  struct MonoGenericParamFull * param;
  struct MonoImage * image;
  struct MonoClass * pklass;
  struct MonoError error;

  try
    {
      D.39383 = gparam->tbuilder;
      D.39384 = D.39383->module;
      D.39385 = D.39384->dynamic_image;
      image = &D.39385->image;
      param = mono_image_alloc0 (image, 56);
      D.39386 = gparam->name;
      D.39387 = mono_string_to_utf8_image (image, D.39386, &error);
      param->info.name = D.39387;
      D.39388 = mono_error_ok (&error);
      D.39389 = D.39388 == 0;
      D.39390 = (long int) D.39389;
      D.39391 = __builtin_expect (D.39390, 0);
      if (D.39391 != 0) goto <D.39392>; else goto <D.39393>;
      <D.39392>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11435, "mono_error_ok (&error)");
      <D.39393>:
      D.39394 = gparam->index;
      D.39395 = (short unsigned int) D.39394;
      param->param.num = D.39395;
      D.39396 = gparam->mbuilder;
      if (D.39396 != 0B) goto <D.39397>; else goto <D.39398>;
      <D.39397>:
      D.39396 = gparam->mbuilder;
      D.39399 = D.39396->generic_container;
      if (D.39399 == 0B) goto <D.39400>; else goto <D.39401>;
      <D.39400>:
      {
        struct MonoReflectionTypeBuilder * tb;
        struct MonoClass * klass;

        D.39396 = gparam->mbuilder;
        tb = D.39396->type;
        D.39402 = mono_reflection_type_get_handle (tb);
        klass = mono_class_from_mono_type (D.39402);
        D.39396 = gparam->mbuilder;
        D.39403 = klass->image;
        D.39404 = mono_image_alloc0 (D.39403, 56);
        D.39396->generic_container = D.39404;
        D.39396 = gparam->mbuilder;
        D.39399 = D.39396->generic_container;
        D.39399->is_method = -1;
        D.39396 = gparam->mbuilder;
        D.39399 = D.39396->generic_container;
        D.39403 = klass->image;
        D.39399->image = D.39403;
      }
      <D.39401>:
      D.39396 = gparam->mbuilder;
      D.39399 = D.39396->generic_container;
      param->param.owner = D.39399;
      goto <D.39405>;
      <D.39398>:
      D.39383 = gparam->tbuilder;
      if (D.39383 != 0B) goto <D.39406>; else goto <D.39407>;
      <D.39406>:
      D.39383 = gparam->tbuilder;
      D.39408 = D.39383->generic_container;
      if (D.39408 == 0B) goto <D.39409>; else goto <D.39410>;
      <D.39409>:
      {
        struct MonoClass * klass;

        D.39383 = gparam->tbuilder;
        D.39411 = mono_reflection_type_get_handle (D.39383);
        klass = mono_class_from_mono_type (D.39411);
        D.39383 = gparam->tbuilder;
        D.39412 = klass->image;
        D.39413 = mono_image_alloc0 (D.39412, 56);
        D.39383->generic_container = D.39413;
        D.39383 = gparam->tbuilder;
        D.39408 = D.39383->generic_container;
        D.39408->owner.klass = klass;
      }
      <D.39410>:
      D.39383 = gparam->tbuilder;
      D.39408 = D.39383->generic_container;
      param->param.owner = D.39408;
      <D.39407>:
      <D.39405>:
      D.39396 = gparam->mbuilder;
      D.39414 = D.39396 != 0B;
      D.39415 = (int) D.39414;
      pklass = mono_class_from_generic_parameter (param, image, D.39415);
      D.39416 = &pklass->byval_arg;
      gparam->type.type = D.39416;
      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.625;
  guint32 iftmp.626;
  struct MonoArray * D.39422;
  long unsigned int D.39425;
  long unsigned int D.39429;
  char * D.39430;
  char * D.39431;
  long int D.39432;
  char * D.39433;
  long int D.39434;
  long int D.39435;
  long unsigned int D.39436;
  struct MonoClass * D.39437;
  struct MonoDomain * D.39438;
  long unsigned int D.39439;
  char * D.39440;
  struct MonoArray * D.39441;
  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.39418>; else goto <D.39419>;
      <D.39418>:
      iftmp.625 = module->dynamic_image;
      goto <D.39420>;
      <D.39419>:
      iftmp.625 = 0B;
      <D.39420>:
      assembly = iftmp.625;
      D.39422 = sig->arguments;
      if (D.39422 != 0B) goto <D.39423>; else goto <D.39424>;
      <D.39423>:
      D.39422 = sig->arguments;
      D.39425 = mono_array_length (D.39422);
      iftmp.626 = (guint32) D.39425;
      goto <D.39426>;
      <D.39424>:
      iftmp.626 = 0;
      <D.39426>:
      na = iftmp.626;
      D.39422 = sig->arguments;
      check_array_for_usertypes (D.39422);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 7);
      sigbuffer_add_value (&buf, na);
      if (assembly != 0B) goto <D.39427>; else goto <D.39428>;
      <D.39427>:
      i = 0;
      goto <D.23692>;
      <D.23691>:
      {
        struct MonoReflectionType * type;

        D.39429 = (long unsigned int) i;
        D.39422 = sig->arguments;
        D.39430 = mono_array_addr_with_size (D.39422, 8, D.39429);
        type = MEM[(struct MonoReflectionType * *)D.39430];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23692>:
      if (i < na) goto <D.23691>; else goto <D.23693>;
      <D.23693>:
      <D.39428>:
      D.39431 = buf.p;
      D.39432 = (long int) D.39431;
      D.39433 = buf.buf;
      D.39434 = (long int) D.39433;
      D.39435 = D.39432 - D.39434;
      buflen = (guint32) D.39435;
      D.39436 = (long unsigned int) buflen;
      D.39437 = mono_defaults.byte_class;
      D.39438 = mono_domain_get ();
      result = mono_array_new (D.39438, D.39437, D.39436);
      D.39439 = (long unsigned int) buflen;
      D.39433 = buf.buf;
      D.39440 = mono_array_addr_with_size (result, 1, 0);
      memcpy (D.39440, D.39433, D.39439);
      sigbuffer_free (&buf);
      D.39441 = result;
      return D.39441;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_sighelper_get_signature_field (struct MonoReflectionSigHelper * sig)
{
  struct MonoReflectionModuleBuilder * D.39444;
  guint32 iftmp.627;
  struct MonoArray * D.39446;
  long unsigned int D.39449;
  long unsigned int D.39451;
  char * D.39452;
  char * D.39453;
  long int D.39454;
  char * D.39455;
  long int D.39456;
  long int D.39457;
  long unsigned int D.39458;
  struct MonoClass * D.39459;
  struct MonoDomain * D.39460;
  long unsigned int D.39461;
  char * D.39462;
  struct MonoArray * D.39463;
  struct MonoDynamicImage * assembly;
  guint32 na;
  guint32 buflen;
  guint32 i;
  struct MonoArray * result;
  struct SigBuffer buf;

  try
    {
      D.39444 = sig->module;
      assembly = D.39444->dynamic_image;
      D.39446 = sig->arguments;
      if (D.39446 != 0B) goto <D.39447>; else goto <D.39448>;
      <D.39447>:
      D.39446 = sig->arguments;
      D.39449 = mono_array_length (D.39446);
      iftmp.627 = (guint32) D.39449;
      goto <D.39450>;
      <D.39448>:
      iftmp.627 = 0;
      <D.39450>:
      na = iftmp.627;
      D.39446 = sig->arguments;
      check_array_for_usertypes (D.39446);
      sigbuffer_init (&buf, 32);
      sigbuffer_add_value (&buf, 6);
      i = 0;
      goto <D.23705>;
      <D.23704>:
      {
        struct MonoReflectionType * type;

        D.39451 = (long unsigned int) i;
        D.39446 = sig->arguments;
        D.39452 = mono_array_addr_with_size (D.39446, 8, D.39451);
        type = MEM[(struct MonoReflectionType * *)D.39452];
        encode_reflection_type (assembly, type, &buf);
      }
      i = i + 1;
      <D.23705>:
      if (i < na) goto <D.23704>; else goto <D.23706>;
      <D.23706>:
      D.39453 = buf.p;
      D.39454 = (long int) D.39453;
      D.39455 = buf.buf;
      D.39456 = (long int) D.39455;
      D.39457 = D.39454 - D.39456;
      buflen = (guint32) D.39457;
      D.39458 = (long unsigned int) buflen;
      D.39459 = mono_defaults.byte_class;
      D.39460 = mono_domain_get ();
      result = mono_array_new (D.39460, D.39459, D.39458);
      D.39461 = (long unsigned int) buflen;
      D.39455 = buf.buf;
      D.39462 = mono_array_addr_with_size (result, 1, 0);
      memcpy (D.39462, D.39455, D.39461);
      sigbuffer_free (&buf);
      D.39463 = result;
      return D.39463;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


mono_reflection_create_dynamic_method (struct MonoReflectionDynamicMethod * mb)
{
  int D.39466;
  struct MonoException * D.39469;
  struct MonoReferenceQueue * dynamic_method_queue.628;
  int D.39475;
  unsigned int D.39476;
  int D.39477;
  long unsigned int D.39478;
  long unsigned int D.39479;
  void * D.39480;
  long unsigned int D.39481;
  struct MonoArray * D.39482;
  char * D.39483;
  int D.23738;
  int iftmp.629;
  int D.23737;
  struct MonoVTable * D.39487;
  struct MonoClass * D.39488;
  const char[14] * D.39489;
  unsigned char D.39490;
  int D.39491;
  unsigned char D.39492;
  int D.39493;
  _Bool D.39494;
  _Bool D.39495;
  _Bool D.39496;
  const unsigned char * D.39499;
  unsigned char D.39500;
  int D.39501;
  const unsigned char * D.39502;
  unsigned char D.39503;
  int D.39504;
  _Bool D.39505;
  _Bool D.39506;
  const unsigned char * D.39509;
  unsigned char D.39510;
  int D.39511;
  const unsigned char * D.39512;
  unsigned char D.39513;
  int D.39514;
  _Bool D.39515;
  _Bool D.39516;
  const unsigned char * D.39519;
  unsigned char D.39520;
  int D.39521;
  const unsigned char * D.39522;
  unsigned char D.39523;
  int D.39524;
  const char * D.39526;
  struct MonoMethod * D.39529;
  struct GSList * D.39533;
  struct GSList * D.39534;
  struct MonoClass * handle_class.630;
  struct MonoReflectionModule * D.39537;
  struct MonoImage * D.39538;
  <unnamed type> D.39542;
  struct MonoClass * handle_class.631;
  void * * D.39548;
  long unsigned int D.39549;
  long unsigned int D.39550;
  void * * D.39551;
  sizetype D.39552;
  sizetype D.39553;
  sizetype D.39554;
  void * * D.39555;
  struct MonoClass * iftmp.632;
  struct MonoReflectionType * D.39557;
  struct MonoType * D.39560;
  struct MonoDomain * D.39562;
  int D.39563;
  struct MonoMethod * D.39566;
  _Bool D.39567;
  long int D.39568;
  long int D.39569;
  void * * D.39572;
  void * D.39573;
  int D.39576;
  sizetype D.39577;
  sizetype D.39578;
  sizetype D.39579;
  void * * D.39580;
  void * D.39581;
  struct MonoMethod * D.39584;
  unsigned int i.633;
  void * D.39586;
  long int D.39587;
  unsigned int D.39588;
  struct GSList * D.39589;
  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.39466 = mono_runtime_is_shutting_down ();
      if (D.39466 != 0) goto <D.39467>; else goto <D.39468>;
      <D.39467>:
      D.39469 = mono_get_exception_invalid_operation ("");
      mono_raise_exception (D.39469);
      <D.39468>:
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.39470>; else goto <D.39471>;
      <D.39470>:
      mono_loader_lock ();
      queue = dynamic_method_queue;
      if (queue == 0B) goto <D.39472>; else goto <D.39473>;
      <D.39472>:
      dynamic_method_queue.628 = mono_gc_reference_queue_new (free_dynamic_method);
      dynamic_method_queue = dynamic_method_queue.628;
      queue = dynamic_method_queue;
      <D.39473>:
      mono_loader_unlock ();
      <D.39471>:
      sig = dynamic_method_to_signature (mb);
      reflection_methodbuilder_from_dynamic_method (&rmb, mb);
      D.39475 = mb->nrefs;
      D.39476 = (unsigned int) D.39475;
      rmb.nrefs = D.39476;
      D.39475 = mb->nrefs;
      D.39477 = D.39475 + 1;
      D.39478 = (long unsigned int) D.39477;
      D.39479 = D.39478 * 8;
      D.39480 = monoeg_malloc0 (D.39479);
      rmb.refs = D.39480;
      i = 0;
      goto <D.23742>;
      <D.23741>:
      {
        struct MonoClass * handle_class;
        void * ref;
        struct MonoObject * obj;

        try
          {
            D.39481 = (long unsigned int) i;
            D.39482 = mb->refs;
            D.39483 = mono_array_addr_with_size (D.39482, 8, D.39481);
            obj = MEM[(struct MonoObject * *)D.39483];
            {
              size_t __s1_len;
              size_t __s2_len;

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

                D.39487 = obj->vtable;
                D.39488 = D.39487->klass;
                __s2 = D.39488->name;
                D.39489 = "DynamicMethod";
                D.39490 = MEM[(const unsigned char *)D.39489];
                D.39491 = (int) D.39490;
                D.39492 = *__s2;
                D.39493 = (int) D.39492;
                __result = D.39491 - D.39493;
                {
                  D.39494 = __s2_len != 0;
                  D.39495 = __result == 0;
                  D.39496 = D.39494 & D.39495;
                  if (D.39496 != 0) goto <D.39497>; else goto <D.39498>;
                  <D.39497>:
                  D.39499 = &MEM[(void *)"DynamicMethod" + 1B];
                  D.39500 = *D.39499;
                  D.39501 = (int) D.39500;
                  D.39502 = __s2 + 1;
                  D.39503 = *D.39502;
                  D.39504 = (int) D.39503;
                  __result = D.39501 - D.39504;
                  D.39505 = __s2_len > 1;
                  D.39495 = __result == 0;
                  D.39506 = D.39505 & D.39495;
                  if (D.39506 != 0) goto <D.39507>; else goto <D.39508>;
                  <D.39507>:
                  D.39509 = &MEM[(void *)"DynamicMethod" + 2B];
                  D.39510 = *D.39509;
                  D.39511 = (int) D.39510;
                  D.39512 = __s2 + 2;
                  D.39513 = *D.39512;
                  D.39514 = (int) D.39513;
                  __result = D.39511 - D.39514;
                  D.39515 = __s2_len > 2;
                  D.39495 = __result == 0;
                  D.39516 = D.39515 & D.39495;
                  if (D.39516 != 0) goto <D.39517>; else goto <D.39518>;
                  <D.39517>:
                  D.39519 = &MEM[(void *)"DynamicMethod" + 3B];
                  D.39520 = *D.39519;
                  D.39521 = (int) D.39520;
                  D.39522 = __s2 + 3;
                  D.39523 = *D.39522;
                  D.39524 = (int) D.39523;
                  __result = D.39521 - D.39524;
                  <D.39518>:
                  <D.39508>:
                  <D.39498>:
                }
                D.23737 = __result;
              }
              iftmp.629 = -D.23737;
              goto <D.39525>;
              <D.39486>:
              D.39487 = obj->vtable;
              D.39488 = D.39487->klass;
              D.39526 = D.39488->name;
              iftmp.629 = __builtin_strcmp (D.39526, "DynamicMethod");
              <D.39525>:
              D.23738 = iftmp.629;
            }
            if (D.23738 == 0) goto <D.39527>; else goto <D.39528>;
            <D.39527>:
            {
              struct MonoReflectionDynamicMethod * method;

              method = obj;
              D.39529 = method->mhandle;
              if (D.39529 != 0B) goto <D.39530>; else goto <D.39531>;
              <D.39530>:
              ref = method->mhandle;
              goto <D.39532>;
              <D.39531>:
              ref = method;
              D.39533 = method->referenced_by;
              D.39534 = monoeg_g_slist_append (D.39533, mb);
              method->referenced_by = D.39534;
              <D.39532>:
              handle_class.630 = mono_defaults.methodhandle_class;
              handle_class = handle_class.630;
            }
            goto <D.39536>;
            <D.39528>:
            {
              struct MonoException * ex;

              ex = 0B;
              D.39537 = mb->module;
              D.39538 = D.39537->image;
              ref = resolve_object (D.39538, obj, &handle_class, 0B);
              if (ref == 0B) goto <D.39539>; else goto <D.39540>;
              <D.39539>:
              ex = mono_get_exception_type_load (0B, 0B);
              goto <D.39541>;
              <D.39540>:
              D.39542 = mono_security_get_mode ();
              if (D.39542 == 1) goto <D.39543>; else goto <D.39544>;
              <D.39543>:
              handle_class.631 = handle_class;
              ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class.631);
              <D.39544>:
              <D.39541>:
              if (ex != 0B) goto <D.39546>; else goto <D.39547>;
              <D.39546>:
              D.39548 = rmb.refs;
              monoeg_g_free (D.39548);
              mono_raise_exception (ex);
              return;
              <D.39547>:
            }
            <D.39536>:
            D.39548 = rmb.refs;
            D.39549 = (long unsigned int) i;
            D.39550 = D.39549 * 8;
            D.39551 = D.39548 + D.39550;
            *D.39551 = ref;
            D.39548 = rmb.refs;
            D.39552 = (sizetype) i;
            D.39553 = D.39552 + 1;
            D.39554 = D.39553 * 8;
            D.39555 = D.39548 + D.39554;
            handle_class.631 = handle_class;
            *D.39555 = handle_class.631;
          }
        finally
          {
            handle_class = {CLOBBER};
          }
      }
      i = i + 2;
      <D.23742>:
      D.39475 = mb->nrefs;
      if (D.39475 > i) goto <D.23741>; else goto <D.23743>;
      <D.23743>:
      D.39557 = mb->owner;
      if (D.39557 != 0B) goto <D.39558>; else goto <D.39559>;
      <D.39558>:
      D.39557 = mb->owner;
      D.39560 = mono_reflection_type_get_handle (D.39557);
      iftmp.632 = mono_class_from_mono_type (D.39560);
      goto <D.39561>;
      <D.39559>:
      iftmp.632 = mono_defaults.object_class;
      <D.39561>:
      klass = iftmp.632;
      handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
      mb->mhandle = handle;
      release_data = monoeg_malloc (16);
      release_data->handle = handle;
      D.39562 = mono_object_get_domain (mb);
      release_data->domain = D.39562;
      D.39563 = mono_gc_reference_queue_add (queue, mb, release_data);
      if (D.39563 == 0) goto <D.39564>; else goto <D.39565>;
      <D.39564>:
      monoeg_g_free (release_data);
      <D.39565>:
      l = mb->referenced_by;
      goto <D.23751>;
      <D.23750>:
      {
        struct MonoReflectionDynamicMethod * method;
        struct MonoMethodWrapper * wrapper;
        void * * data;

        method = l->data;
        wrapper = method->mhandle;
        D.39566 = method->mhandle;
        D.39567 = D.39566 == 0B;
        D.39568 = (long int) D.39567;
        D.39569 = __builtin_expect (D.39568, 0);
        if (D.39569 != 0) goto <D.39570>; else goto <D.39571>;
        <D.39570>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11637, "method->mhandle");
        <D.39571>:
        data = wrapper->method_data;
        i = 0;
        goto <D.23748>;
        <D.23747>:
        D.39552 = (sizetype) i;
        D.39553 = D.39552 + 1;
        D.39554 = D.39553 * 8;
        D.39572 = data + D.39554;
        D.39573 = *D.39572;
        if (D.39573 == mb) goto <D.39574>; else goto <D.39575>;
        <D.39574>:
        D.39576 = i + 1;
        D.39577 = (sizetype) D.39576;
        D.39578 = D.39577 + 1;
        D.39579 = D.39578 * 8;
        D.39580 = data + D.39579;
        D.39581 = *D.39580;
        handle_class.630 = mono_defaults.methodhandle_class;
        if (D.39581 == handle_class.630) goto <D.39582>; else goto <D.39583>;
        <D.39582>:
        D.39552 = (sizetype) i;
        D.39553 = D.39552 + 1;
        D.39554 = D.39553 * 8;
        D.39572 = data + D.39554;
        D.39584 = mb->mhandle;
        *D.39572 = D.39584;
        <D.39583>:
        <D.39575>:
        i = i + 2;
        <D.23748>:
        i.633 = (unsigned int) i;
        D.39586 = *data;
        D.39587 = (long int) D.39586;
        D.39588 = (unsigned int) D.39587;
        if (i.633 < D.39588) goto <D.23747>; else goto <D.23749>;
        <D.23749>:
      }
      l = l->next;
      <D.23751>:
      if (l != 0B) goto <D.23750>; else goto <D.23752>;
      <D.23752>:
      D.39589 = mb->referenced_by;
      monoeg_g_slist_free (D.39589);
      D.39548 = rmb.refs;
      monoeg_g_free (D.39548);
      mb->ilgen = 0B;
    }
  finally
    {
      rmb = {CLOBBER};
    }
}


free_dynamic_method (void * dynamic_method)
{
  struct MonoMethod * D.39595;
  struct MonoDomain * D.39596;
  struct DynamicMethodReleaseData * data;

  data = dynamic_method;
  D.39595 = data->handle;
  D.39596 = data->domain;
  mono_runtime_free_method (D.39596, D.39595);
  monoeg_g_free (data);
}


dynamic_method_to_signature (struct MonoReflectionDynamicMethod * method)
{
  struct MonoArray * D.39597;
  unsigned int D.39598;
  unsigned int D.39599;
  _Bool D.39600;
  struct MonoType * iftmp.634;
  struct MonoReflectionType * D.39602;
  struct MonoClass * D.39606;
  struct MonoMethodSignature * D.39607;
  struct MonoMethodSignature * sig;

  D.39597 = method->parameters;
  sig = parameters_to_signature (0B, D.39597);
  D.39598 = method->attrs;
  D.39599 = D.39598 & 16;
  D.39600 = D.39599 == 0;
  sig->hasthis = D.39600;
  D.39602 = method->rtype;
  if (D.39602 != 0B) goto <D.39603>; else goto <D.39604>;
  <D.39603>:
  D.39602 = method->rtype;
  iftmp.634 = mono_reflection_type_get_handle (D.39602);
  goto <D.39605>;
  <D.39604>:
  D.39606 = mono_defaults.void_class;
  iftmp.634 = &D.39606->byval_arg;
  <D.39605>:
  sig->ret = iftmp.634;
  sig->generic_param_count = 0;
  D.39607 = sig;
  return D.39607;
}


reflection_methodbuilder_from_dynamic_method (struct ReflectionMethodBuilder * rmb, struct MonoReflectionDynamicMethod * mb)
{
  struct MonoReflectionILGen * D.39609;
  struct MonoReflectionType * D.39610;
  struct MonoArray * D.39611;
  unsigned int D.39612;
  unsigned int D.39613;
  struct MonoReflectionType * D.39614;
  struct MonoString * D.39615;
  unsigned char D.39616;
  unsigned char D.39617;
  struct MonoMethod * D.39618;

  memset (rmb, 0, 208);
  D.39609 = mb->ilgen;
  rmb->ilgen = D.39609;
  D.39610 = mb->rtype;
  rmb->rtype = D.39610;
  D.39611 = mb->parameters;
  rmb->parameters = D.39611;
  rmb->generic_params = 0B;
  rmb->generic_container = 0B;
  rmb->opt_types = 0B;
  rmb->pinfo = 0B;
  D.39612 = mb->attrs;
  rmb->attrs = D.39612;
  rmb->iattrs = 0;
  D.39613 = mb->call_conv;
  rmb->call_conv = D.39613;
  rmb->code = 0B;
  D.39614 = mb->owner;
  rmb->type = D.39614;
  D.39615 = mb->name;
  rmb->name = D.39615;
  rmb->table_idx = 0B;
  D.39616 = mb->init_locals;
  rmb->init_locals = D.39616;
  D.39617 = mb->skip_visibility;
  rmb->skip_visibility = D.39617;
  rmb->return_modreq = 0B;
  rmb->return_modopt = 0B;
  rmb->param_modreq = 0B;
  rmb->param_modopt = 0B;
  rmb->permissions = 0B;
  D.39618 = mb->mhandle;
  rmb->mhandle = D.39618;
  rmb->nrefs = 0;
  rmb->refs = 0B;
}


resolve_object (struct MonoImage * image, struct MonoObject * obj, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  int D.23798;
  int iftmp.635;
  int D.23797;
  struct MonoVTable * D.39622;
  struct MonoClass * D.39623;
  const char[7] * D.39624;
  unsigned char D.39625;
  int D.39626;
  unsigned char D.39627;
  int D.39628;
  _Bool D.39629;
  _Bool D.39630;
  _Bool D.39631;
  const unsigned char * D.39634;
  unsigned char D.39635;
  int D.39636;
  const unsigned char * D.39637;
  unsigned char D.39638;
  int D.39639;
  _Bool D.39640;
  _Bool D.39641;
  const unsigned char * D.39644;
  unsigned char D.39645;
  int D.39646;
  const unsigned char * D.39647;
  unsigned char D.39648;
  int D.39649;
  _Bool D.39650;
  _Bool D.39651;
  const unsigned char * D.39654;
  unsigned char D.39655;
  int D.39656;
  const unsigned char * D.39657;
  unsigned char D.39658;
  int D.39659;
  const char * D.39661;
  struct MonoClass * D.39664;
  _Bool D.39665;
  long int D.39666;
  long int D.39667;
  int D.23807;
  int iftmp.636;
  int D.23806;
  const char[9] * D.39674;
  unsigned char D.39675;
  int D.39676;
  unsigned char D.39677;
  int D.39678;
  _Bool D.39679;
  _Bool D.39680;
  _Bool D.39681;
  const unsigned char * D.39684;
  unsigned char D.39685;
  int D.39686;
  const unsigned char * D.39687;
  unsigned char D.39688;
  int D.39689;
  _Bool D.39690;
  _Bool D.39691;
  const unsigned char * D.39694;
  unsigned char D.39695;
  int D.39696;
  const unsigned char * D.39697;
  unsigned char D.39698;
  int D.39699;
  _Bool D.39700;
  _Bool D.39701;
  const unsigned char * D.39704;
  unsigned char D.39705;
  int D.39706;
  const unsigned char * D.39707;
  unsigned char D.39708;
  int D.39709;
  int D.39713;
  struct MonoException * D.39716;
  struct MonoClass * D.39720;
  int D.23819;
  int iftmp.637;
  int D.23818;
  const char[11] * D.39730;
  unsigned char D.39731;
  int D.39732;
  unsigned char D.39733;
  int D.39734;
  _Bool D.39735;
  _Bool D.39736;
  _Bool D.39737;
  const unsigned char * D.39740;
  unsigned char D.39741;
  int D.39742;
  const unsigned char * D.39743;
  unsigned char D.39744;
  int D.39745;
  _Bool D.39746;
  _Bool D.39747;
  const unsigned char * D.39750;
  unsigned char D.39751;
  int D.39752;
  const unsigned char * D.39753;
  unsigned char D.39754;
  int D.39755;
  _Bool D.39756;
  _Bool D.39757;
  const unsigned char * D.39760;
  unsigned char D.39761;
  int D.39762;
  const unsigned char * D.39763;
  unsigned char D.39764;
  int D.39765;
  int D.23828;
  int iftmp.638;
  int D.23827;
  const char[12] * D.39771;
  unsigned char D.39772;
  int D.39773;
  unsigned char D.39774;
  int D.39775;
  _Bool D.39776;
  _Bool D.39777;
  _Bool D.39778;
  const unsigned char * D.39781;
  unsigned char D.39782;
  int D.39783;
  const unsigned char * D.39784;
  unsigned char D.39785;
  int D.39786;
  _Bool D.39787;
  _Bool D.39788;
  const unsigned char * D.39791;
  unsigned char D.39792;
  int D.39793;
  const unsigned char * D.39794;
  unsigned char D.39795;
  int D.39796;
  _Bool D.39797;
  _Bool D.39798;
  const unsigned char * D.39801;
  unsigned char D.39802;
  int D.39803;
  const unsigned char * D.39804;
  unsigned char D.39805;
  int D.39806;
  int D.23837;
  int iftmp.639;
  int D.23836;
  const char[19] * D.39812;
  unsigned char D.39813;
  int D.39814;
  unsigned char D.39815;
  int D.39816;
  _Bool D.39817;
  _Bool D.39818;
  _Bool D.39819;
  const unsigned char * D.39822;
  unsigned char D.39823;
  int D.39824;
  const unsigned char * D.39825;
  unsigned char D.39826;
  int D.39827;
  _Bool D.39828;
  _Bool D.39829;
  const unsigned char * D.39832;
  unsigned char D.39833;
  int D.39834;
  const unsigned char * D.39835;
  unsigned char D.39836;
  int D.39837;
  _Bool D.39838;
  _Bool D.39839;
  const unsigned char * D.39842;
  unsigned char D.39843;
  int D.39844;
  const unsigned char * D.39845;
  unsigned char D.39846;
  int D.39847;
  int D.23846;
  int iftmp.640;
  int D.23845;
  const char[18] * D.39853;
  unsigned char D.39854;
  int D.39855;
  unsigned char D.39856;
  int D.39857;
  _Bool D.39858;
  _Bool D.39859;
  _Bool D.39860;
  const unsigned char * D.39863;
  unsigned char D.39864;
  int D.39865;
  const unsigned char * D.39866;
  unsigned char D.39867;
  int D.39868;
  _Bool D.39869;
  _Bool D.39870;
  const unsigned char * D.39873;
  unsigned char D.39874;
  int D.39875;
  const unsigned char * D.39876;
  unsigned char D.39877;
  int D.39878;
  _Bool D.39879;
  _Bool D.39880;
  const unsigned char * D.39883;
  unsigned char D.39884;
  int D.39885;
  const unsigned char * D.39886;
  unsigned char D.39887;
  int D.39888;
  struct MonoClass * D.39892;
  int D.23855;
  int iftmp.641;
  int D.23854;
  const char[14] * D.39898;
  unsigned char D.39899;
  int D.39900;
  unsigned char D.39901;
  int D.39902;
  _Bool D.39903;
  _Bool D.39904;
  _Bool D.39905;
  const unsigned char * D.39908;
  unsigned char D.39909;
  int D.39910;
  const unsigned char * D.39911;
  unsigned char D.39912;
  int D.39913;
  _Bool D.39914;
  _Bool D.39915;
  const unsigned char * D.39918;
  unsigned char D.39919;
  int D.39920;
  const unsigned char * D.39921;
  unsigned char D.39922;
  int D.39923;
  _Bool D.39924;
  _Bool D.39925;
  const unsigned char * D.39928;
  unsigned char D.39929;
  int D.39930;
  const unsigned char * D.39931;
  unsigned char D.39932;
  int D.39933;
  struct MonoDomain * D.39939;
  int D.23866;
  int iftmp.642;
  int D.23865;
  const char[19] * D.39946;
  unsigned char D.39947;
  int D.39948;
  unsigned char D.39949;
  int D.39950;
  _Bool D.39951;
  _Bool D.39952;
  _Bool D.39953;
  const unsigned char * D.39956;
  unsigned char D.39957;
  int D.39958;
  const unsigned char * D.39959;
  unsigned char D.39960;
  int D.39961;
  _Bool D.39962;
  _Bool D.39963;
  const unsigned char * D.39966;
  unsigned char D.39967;
  int D.39968;
  const unsigned char * D.39969;
  unsigned char D.39970;
  int D.39971;
  _Bool D.39972;
  _Bool D.39973;
  const unsigned char * D.39976;
  unsigned char D.39977;
  int D.39978;
  const unsigned char * D.39979;
  unsigned char D.39980;
  int D.39981;
  struct MonoDomain * D.39987;
  int D.23877;
  int iftmp.643;
  int D.23876;
  const char[10] * D.39994;
  unsigned char D.39995;
  int D.39996;
  unsigned char D.39997;
  int D.39998;
  _Bool D.39999;
  _Bool D.40000;
  _Bool D.40001;
  const unsigned char * D.40004;
  unsigned char D.40005;
  int D.40006;
  const unsigned char * D.40007;
  unsigned char D.40008;
  int D.40009;
  _Bool D.40010;
  _Bool D.40011;
  const unsigned char * D.40014;
  unsigned char D.40015;
  int D.40016;
  const unsigned char * D.40017;
  unsigned char D.40018;
  int D.40019;
  _Bool D.40020;
  _Bool D.40021;
  const unsigned char * D.40024;
  unsigned char D.40025;
  int D.40026;
  const unsigned char * D.40027;
  unsigned char D.40028;
  int D.40029;
  struct MonoClass * D.40033;
  struct MonoType * D.40036;
  int D.23891;
  const char * D.40037;
  const char * D.40038;
  int iftmp.644;
  int D.23903;
  _Bool D.40045;
  long int D.40046;
  long int D.40047;
  struct MonoClass * D.40051;
  int D.23912;
  int iftmp.645;
  int D.23911;
  const char[13] * D.40058;
  unsigned char D.40059;
  int D.40060;
  unsigned char D.40061;
  int D.40062;
  _Bool D.40063;
  _Bool D.40064;
  _Bool D.40065;
  const unsigned char * D.40068;
  unsigned char D.40069;
  int D.40070;
  const unsigned char * D.40071;
  unsigned char D.40072;
  int D.40073;
  _Bool D.40074;
  _Bool D.40075;
  const unsigned char * D.40078;
  unsigned char D.40079;
  int D.40080;
  const unsigned char * D.40081;
  unsigned char D.40082;
  int D.40083;
  _Bool D.40084;
  _Bool D.40085;
  const unsigned char * D.40088;
  unsigned char D.40089;
  int D.40090;
  const unsigned char * D.40091;
  unsigned char D.40092;
  int D.40093;
  struct MonoDomain * D.40099;
  struct MonoClassField * D.40100;
  struct MonoClass * D.40103;
  struct MonoGenericContainer * D.40104;
  struct MonoType * D.40107;
  const char * D.40108;
  int D.23926;
  int iftmp.646;
  int D.23925;
  const char[12] * D.40115;
  unsigned char D.40116;
  int D.40117;
  unsigned char D.40118;
  int D.40119;
  _Bool D.40120;
  _Bool D.40121;
  _Bool D.40122;
  const unsigned char * D.40125;
  unsigned char D.40126;
  int D.40127;
  const unsigned char * D.40128;
  unsigned char D.40129;
  int D.40130;
  _Bool D.40131;
  _Bool D.40132;
  const unsigned char * D.40135;
  unsigned char D.40136;
  int D.40137;
  const unsigned char * D.40138;
  unsigned char D.40139;
  int D.40140;
  _Bool D.40141;
  _Bool D.40142;
  const unsigned char * D.40145;
  unsigned char D.40146;
  int D.40147;
  const unsigned char * D.40148;
  unsigned char D.40149;
  int D.40150;
  unsigned char D.40154;
  unsigned char D.40155;
  struct MonoDomain * D.40159;
  int D.23938;
  int iftmp.647;
  int D.23937;
  const char[16] * D.40166;
  unsigned char D.40167;
  int D.40168;
  unsigned char D.40169;
  int D.40170;
  _Bool D.40171;
  _Bool D.40172;
  _Bool D.40173;
  const unsigned char * D.40176;
  unsigned char D.40177;
  int D.40178;
  const unsigned char * D.40179;
  unsigned char D.40180;
  int D.40181;
  _Bool D.40182;
  _Bool D.40183;
  const unsigned char * D.40186;
  unsigned char D.40187;
  int D.40188;
  const unsigned char * D.40189;
  unsigned char D.40190;
  int D.40191;
  _Bool D.40192;
  _Bool D.40193;
  const unsigned char * D.40196;
  unsigned char D.40197;
  int D.40198;
  const unsigned char * D.40199;
  unsigned char D.40200;
  int D.40201;
  struct MonoArray * D.40205;
  long unsigned int D.40208;
  unsigned int nargs.648;
  unsigned int D.40211;
  unsigned int D.40212;
  _Bool D.40213;
  unsigned int D.40214;
  _Bool D.40215;
  unsigned int D.40216;
  unsigned char D.40219;
  unsigned char D.40220;
  <unnamed-unsigned:6> D.40221;
  unsigned int D.40223;
  short unsigned int D.40227;
  struct MonoReflectionType * D.40228;
  struct MonoType * D.40229;
  long unsigned int D.40230;
  char * D.40231;
  void * D.40232;
  struct MonoType * D.40233;
  int D.23954;
  int iftmp.649;
  int D.23953;
  const char[14] * D.40238;
  unsigned char D.40239;
  int D.40240;
  unsigned char D.40241;
  int D.40242;
  _Bool D.40243;
  _Bool D.40244;
  _Bool D.40245;
  const unsigned char * D.40248;
  unsigned char D.40249;
  int D.40250;
  const unsigned char * D.40251;
  unsigned char D.40252;
  int D.40253;
  _Bool D.40254;
  _Bool D.40255;
  const unsigned char * D.40258;
  unsigned char D.40259;
  int D.40260;
  const unsigned char * D.40261;
  unsigned char D.40262;
  int D.40263;
  _Bool D.40264;
  _Bool D.40265;
  const unsigned char * D.40268;
  unsigned char D.40269;
  int D.40270;
  const unsigned char * D.40271;
  unsigned char D.40272;
  int D.40273;
  struct MonoMethod * D.40277;
  _Bool D.40278;
  long int D.40279;
  long int D.40280;
  int D.23964;
  int iftmp.650;
  int D.23963;
  const char[28] * D.40287;
  unsigned char D.40288;
  int D.40289;
  unsigned char D.40290;
  int D.40291;
  _Bool D.40292;
  _Bool D.40293;
  _Bool D.40294;
  const unsigned char * D.40297;
  unsigned char D.40298;
  int D.40299;
  const unsigned char * D.40300;
  unsigned char D.40301;
  int D.40302;
  _Bool D.40303;
  _Bool D.40304;
  const unsigned char * D.40307;
  unsigned char D.40308;
  int D.40309;
  const unsigned char * D.40310;
  unsigned char D.40311;
  int D.40312;
  _Bool D.40313;
  _Bool D.40314;
  const unsigned char * D.40317;
  unsigned char D.40318;
  int D.40319;
  const unsigned char * D.40320;
  unsigned char D.40321;
  int D.40322;
  int D.23974;
  int iftmp.651;
  int D.23973;
  const char[17] * D.40332;
  unsigned char D.40333;
  int D.40334;
  unsigned char D.40335;
  int D.40336;
  _Bool D.40337;
  _Bool D.40338;
  _Bool D.40339;
  const unsigned char * D.40342;
  unsigned char D.40343;
  int D.40344;
  const unsigned char * D.40345;
  unsigned char D.40346;
  int D.40347;
  _Bool D.40348;
  _Bool D.40349;
  const unsigned char * D.40352;
  unsigned char D.40353;
  int D.40354;
  const unsigned char * D.40355;
  unsigned char D.40356;
  int D.40357;
  _Bool D.40358;
  _Bool D.40359;
  const unsigned char * D.40362;
  unsigned char D.40363;
  int D.40364;
  const unsigned char * D.40365;
  unsigned char D.40366;
  int D.40367;
  int D.23984;
  int iftmp.652;
  int D.23983;
  const char[23] * D.40377;
  unsigned char D.40378;
  int D.40379;
  unsigned char D.40380;
  int D.40381;
  _Bool D.40382;
  _Bool D.40383;
  _Bool D.40384;
  const unsigned char * D.40387;
  unsigned char D.40388;
  int D.40389;
  const unsigned char * D.40390;
  unsigned char D.40391;
  int D.40392;
  _Bool D.40393;
  _Bool D.40394;
  const unsigned char * D.40397;
  unsigned char D.40398;
  int D.40399;
  const unsigned char * D.40400;
  unsigned char D.40401;
  int D.40402;
  _Bool D.40403;
  _Bool D.40404;
  const unsigned char * D.40407;
  unsigned char D.40408;
  int D.40409;
  const unsigned char * D.40410;
  unsigned char D.40411;
  int D.40412;
  struct MonoObject * D.40416;
  struct MonoVTable * D.40417;
  struct MonoClass * D.40418;
  int D.40419;
  int D.40423;
  char * D.40427;
  struct MonoReflectionGenericClass * D.40428;
  struct MonoType * D.40429;
  const char * D.40430;
  struct MonoClass * D.40431;
  int D.23998;
  int iftmp.653;
  int D.23997;
  const char[29] * D.40438;
  unsigned char D.40439;
  int D.40440;
  unsigned char D.40441;
  int D.40442;
  _Bool D.40443;
  _Bool D.40444;
  _Bool D.40445;
  const unsigned char * D.40448;
  unsigned char D.40449;
  int D.40450;
  const unsigned char * D.40451;
  unsigned char D.40452;
  int D.40453;
  _Bool D.40454;
  _Bool D.40455;
  const unsigned char * D.40458;
  unsigned char D.40459;
  int D.40460;
  const unsigned char * D.40461;
  unsigned char D.40462;
  int D.40463;
  _Bool D.40464;
  _Bool D.40465;
  const unsigned char * D.40468;
  unsigned char D.40469;
  int D.40470;
  const unsigned char * D.40471;
  unsigned char D.40472;
  int D.40473;
  struct MonoReflectionGenericClass * D.40477;
  struct MonoType * D.40478;
  struct MonoObject * D.40479;
  struct MonoVTable * D.40480;
  struct MonoClass * D.40481;
  int D.40482;
  int D.40486;
  char * D.40490;
  int D.24012;
  int iftmp.654;
  int D.24011;
  const char[24] * D.40495;
  unsigned char D.40496;
  int D.40497;
  unsigned char D.40498;
  int D.40499;
  _Bool D.40500;
  _Bool D.40501;
  _Bool D.40502;
  const unsigned char * D.40505;
  unsigned char D.40506;
  int D.40507;
  const unsigned char * D.40508;
  unsigned char D.40509;
  int D.40510;
  _Bool D.40511;
  _Bool D.40512;
  const unsigned char * D.40515;
  unsigned char D.40516;
  int D.40517;
  const unsigned char * D.40518;
  unsigned char D.40519;
  int D.40520;
  _Bool D.40521;
  _Bool D.40522;
  const unsigned char * D.40525;
  unsigned char D.40526;
  int D.40527;
  const unsigned char * D.40528;
  unsigned char D.40529;
  int D.40530;
  struct MonoArray * D.40534;
  struct MonoReflectionType * D.40540;
  struct MonoType * D.40541;
  struct MonoObject * D.40542;
  struct MonoVTable * D.40543;
  struct MonoClass * D.40544;
  int D.40545;
  int D.40549;
  char * D.40553;
  int D.24026;
  int iftmp.655;
  int D.24025;
  const char[16] * D.40558;
  unsigned char D.40559;
  int D.40560;
  unsigned char D.40561;
  int D.40562;
  _Bool D.40563;
  _Bool D.40564;
  _Bool D.40565;
  const unsigned char * D.40568;
  unsigned char D.40569;
  int D.40570;
  const unsigned char * D.40571;
  unsigned char D.40572;
  int D.40573;
  _Bool D.40574;
  _Bool D.40575;
  const unsigned char * D.40578;
  unsigned char D.40579;
  int D.40580;
  const unsigned char * D.40581;
  unsigned char D.40582;
  int D.40583;
  _Bool D.40584;
  _Bool D.40585;
  const unsigned char * D.40588;
  unsigned char D.40589;
  int D.40590;
  const unsigned char * D.40591;
  unsigned char D.40592;
  int D.40593;
  struct MonoReflectionType * D.40597;
  struct MonoString * D.40598;
  int D.24041;
  const char * D.40599;
  _Bool D.40601;
  long int D.40602;
  long int D.40603;
  struct MonoClass * D.40610;
  int D.40611;
  struct MonoClass * D.40613;
  int D.40614;
  struct MonoClass * D.40616;
  int D.40617;
  void * D.40621;
  void * result;

  result = 0B;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39624 = "String";
      D.39625 = MEM[(const unsigned char *)D.39624];
      D.39626 = (int) D.39625;
      D.39627 = *__s2;
      D.39628 = (int) D.39627;
      __result = D.39626 - D.39628;
      {
        D.39629 = __s2_len != 0;
        D.39630 = __result == 0;
        D.39631 = D.39629 & D.39630;
        if (D.39631 != 0) goto <D.39632>; else goto <D.39633>;
        <D.39632>:
        D.39634 = &MEM[(void *)"String" + 1B];
        D.39635 = *D.39634;
        D.39636 = (int) D.39635;
        D.39637 = __s2 + 1;
        D.39638 = *D.39637;
        D.39639 = (int) D.39638;
        __result = D.39636 - D.39639;
        D.39640 = __s2_len > 1;
        D.39630 = __result == 0;
        D.39641 = D.39640 & D.39630;
        if (D.39641 != 0) goto <D.39642>; else goto <D.39643>;
        <D.39642>:
        D.39644 = &MEM[(void *)"String" + 2B];
        D.39645 = *D.39644;
        D.39646 = (int) D.39645;
        D.39647 = __s2 + 2;
        D.39648 = *D.39647;
        D.39649 = (int) D.39648;
        __result = D.39646 - D.39649;
        D.39650 = __s2_len > 2;
        D.39630 = __result == 0;
        D.39651 = D.39650 & D.39630;
        if (D.39651 != 0) goto <D.39652>; else goto <D.39653>;
        <D.39652>:
        D.39654 = &MEM[(void *)"String" + 3B];
        D.39655 = *D.39654;
        D.39656 = (int) D.39655;
        D.39657 = __s2 + 3;
        D.39658 = *D.39657;
        D.39659 = (int) D.39658;
        __result = D.39656 - D.39659;
        <D.39653>:
        <D.39643>:
        <D.39633>:
      }
      D.23797 = __result;
    }
    iftmp.635 = -D.23797;
    goto <D.39660>;
    <D.39621>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.635 = __builtin_strcmp (D.39661, "String");
    <D.39660>:
    D.23798 = iftmp.635;
  }
  if (D.23798 == 0) goto <D.39662>; else goto <D.39663>;
  <D.39662>:
  result = mono_string_intern (obj);
  D.39664 = mono_defaults.string_class;
  *handle_class = D.39664;
  D.39665 = result == 0B;
  D.39666 = (long int) D.39665;
  D.39667 = __builtin_expect (D.39666, 0);
  if (D.39667 != 0) goto <D.39668>; else goto <D.39669>;
  <D.39668>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11751, "result");
  <D.39669>:
  goto <D.39670>;
  <D.39663>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39674 = "MonoType";
      D.39675 = MEM[(const unsigned char *)D.39674];
      D.39676 = (int) D.39675;
      D.39677 = *__s2;
      D.39678 = (int) D.39677;
      __result = D.39676 - D.39678;
      {
        D.39679 = __s2_len != 0;
        D.39680 = __result == 0;
        D.39681 = D.39679 & D.39680;
        if (D.39681 != 0) goto <D.39682>; else goto <D.39683>;
        <D.39682>:
        D.39684 = &MEM[(void *)"MonoType" + 1B];
        D.39685 = *D.39684;
        D.39686 = (int) D.39685;
        D.39687 = __s2 + 1;
        D.39688 = *D.39687;
        D.39689 = (int) D.39688;
        __result = D.39686 - D.39689;
        D.39690 = __s2_len > 1;
        D.39680 = __result == 0;
        D.39691 = D.39690 & D.39680;
        if (D.39691 != 0) goto <D.39692>; else goto <D.39693>;
        <D.39692>:
        D.39694 = &MEM[(void *)"MonoType" + 2B];
        D.39695 = *D.39694;
        D.39696 = (int) D.39695;
        D.39697 = __s2 + 2;
        D.39698 = *D.39697;
        D.39699 = (int) D.39698;
        __result = D.39696 - D.39699;
        D.39700 = __s2_len > 2;
        D.39680 = __result == 0;
        D.39701 = D.39700 & D.39680;
        if (D.39701 != 0) goto <D.39702>; else goto <D.39703>;
        <D.39702>:
        D.39704 = &MEM[(void *)"MonoType" + 3B];
        D.39705 = *D.39704;
        D.39706 = (int) D.39705;
        D.39707 = __s2 + 3;
        D.39708 = *D.39707;
        D.39709 = (int) D.39708;
        __result = D.39706 - D.39709;
        <D.39703>:
        <D.39693>:
        <D.39683>:
      }
      D.23806 = __result;
    }
    iftmp.636 = -D.23806;
    goto <D.39710>;
    <D.39673>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.636 = __builtin_strcmp (D.39661, "MonoType");
    <D.39710>:
    D.23807 = iftmp.636;
  }
  if (D.23807 == 0) goto <D.39711>; else goto <D.39712>;
  <D.39711>:
  {
    struct MonoType * type;
    struct MonoClass * mc;

    type = mono_reflection_type_get_handle (obj);
    mc = mono_class_from_mono_type (type);
    D.39713 = mono_class_init (mc);
    if (D.39713 == 0) goto <D.39714>; else goto <D.39715>;
    <D.39714>:
    D.39716 = mono_class_get_exception_for_failure (mc);
    mono_raise_exception (D.39716);
    <D.39715>:
    if (context != 0B) goto <D.39717>; else goto <D.39718>;
    <D.39717>:
    {
      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.39719>;
    <D.39718>:
    result = mono_class_from_mono_type (type);
    <D.39719>:
    D.39720 = mono_defaults.typehandle_class;
    *handle_class = D.39720;
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.39721>; else goto <D.39722>;
    <D.39721>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11766, "result");
    <D.39722>:
  }
  goto <D.39723>;
  <D.39712>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39730 = "MonoMethod";
      D.39731 = MEM[(const unsigned char *)D.39730];
      D.39732 = (int) D.39731;
      D.39733 = *__s2;
      D.39734 = (int) D.39733;
      __result = D.39732 - D.39734;
      {
        D.39735 = __s2_len != 0;
        D.39736 = __result == 0;
        D.39737 = D.39735 & D.39736;
        if (D.39737 != 0) goto <D.39738>; else goto <D.39739>;
        <D.39738>:
        D.39740 = &MEM[(void *)"MonoMethod" + 1B];
        D.39741 = *D.39740;
        D.39742 = (int) D.39741;
        D.39743 = __s2 + 1;
        D.39744 = *D.39743;
        D.39745 = (int) D.39744;
        __result = D.39742 - D.39745;
        D.39746 = __s2_len > 1;
        D.39736 = __result == 0;
        D.39747 = D.39746 & D.39736;
        if (D.39747 != 0) goto <D.39748>; else goto <D.39749>;
        <D.39748>:
        D.39750 = &MEM[(void *)"MonoMethod" + 2B];
        D.39751 = *D.39750;
        D.39752 = (int) D.39751;
        D.39753 = __s2 + 2;
        D.39754 = *D.39753;
        D.39755 = (int) D.39754;
        __result = D.39752 - D.39755;
        D.39756 = __s2_len > 2;
        D.39736 = __result == 0;
        D.39757 = D.39756 & D.39736;
        if (D.39757 != 0) goto <D.39758>; else goto <D.39759>;
        <D.39758>:
        D.39760 = &MEM[(void *)"MonoMethod" + 3B];
        D.39761 = *D.39760;
        D.39762 = (int) D.39761;
        D.39763 = __s2 + 3;
        D.39764 = *D.39763;
        D.39765 = (int) D.39764;
        __result = D.39762 - D.39765;
        <D.39759>:
        <D.39749>:
        <D.39739>:
      }
      D.23818 = __result;
    }
    iftmp.637 = -D.23818;
    goto <D.39766>;
    <D.39729>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.637 = __builtin_strcmp (D.39661, "MonoMethod");
    <D.39766>:
    D.23819 = iftmp.637;
  }
  if (D.23819 == 0) goto <D.39724>; else goto <D.39767>;
  <D.39767>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39771 = "MonoCMethod";
      D.39772 = MEM[(const unsigned char *)D.39771];
      D.39773 = (int) D.39772;
      D.39774 = *__s2;
      D.39775 = (int) D.39774;
      __result = D.39773 - D.39775;
      {
        D.39776 = __s2_len != 0;
        D.39777 = __result == 0;
        D.39778 = D.39776 & D.39777;
        if (D.39778 != 0) goto <D.39779>; else goto <D.39780>;
        <D.39779>:
        D.39781 = &MEM[(void *)"MonoCMethod" + 1B];
        D.39782 = *D.39781;
        D.39783 = (int) D.39782;
        D.39784 = __s2 + 1;
        D.39785 = *D.39784;
        D.39786 = (int) D.39785;
        __result = D.39783 - D.39786;
        D.39787 = __s2_len > 1;
        D.39777 = __result == 0;
        D.39788 = D.39787 & D.39777;
        if (D.39788 != 0) goto <D.39789>; else goto <D.39790>;
        <D.39789>:
        D.39791 = &MEM[(void *)"MonoCMethod" + 2B];
        D.39792 = *D.39791;
        D.39793 = (int) D.39792;
        D.39794 = __s2 + 2;
        D.39795 = *D.39794;
        D.39796 = (int) D.39795;
        __result = D.39793 - D.39796;
        D.39797 = __s2_len > 2;
        D.39777 = __result == 0;
        D.39798 = D.39797 & D.39777;
        if (D.39798 != 0) goto <D.39799>; else goto <D.39800>;
        <D.39799>:
        D.39801 = &MEM[(void *)"MonoCMethod" + 3B];
        D.39802 = *D.39801;
        D.39803 = (int) D.39802;
        D.39804 = __s2 + 3;
        D.39805 = *D.39804;
        D.39806 = (int) D.39805;
        __result = D.39803 - D.39806;
        <D.39800>:
        <D.39790>:
        <D.39780>:
      }
      D.23827 = __result;
    }
    iftmp.638 = -D.23827;
    goto <D.39807>;
    <D.39770>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.638 = __builtin_strcmp (D.39661, "MonoCMethod");
    <D.39807>:
    D.23828 = iftmp.638;
  }
  if (D.23828 == 0) goto <D.39724>; else goto <D.39808>;
  <D.39808>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39812 = "MonoGenericCMethod";
      D.39813 = MEM[(const unsigned char *)D.39812];
      D.39814 = (int) D.39813;
      D.39815 = *__s2;
      D.39816 = (int) D.39815;
      __result = D.39814 - D.39816;
      {
        D.39817 = __s2_len != 0;
        D.39818 = __result == 0;
        D.39819 = D.39817 & D.39818;
        if (D.39819 != 0) goto <D.39820>; else goto <D.39821>;
        <D.39820>:
        D.39822 = &MEM[(void *)"MonoGenericCMethod" + 1B];
        D.39823 = *D.39822;
        D.39824 = (int) D.39823;
        D.39825 = __s2 + 1;
        D.39826 = *D.39825;
        D.39827 = (int) D.39826;
        __result = D.39824 - D.39827;
        D.39828 = __s2_len > 1;
        D.39818 = __result == 0;
        D.39829 = D.39828 & D.39818;
        if (D.39829 != 0) goto <D.39830>; else goto <D.39831>;
        <D.39830>:
        D.39832 = &MEM[(void *)"MonoGenericCMethod" + 2B];
        D.39833 = *D.39832;
        D.39834 = (int) D.39833;
        D.39835 = __s2 + 2;
        D.39836 = *D.39835;
        D.39837 = (int) D.39836;
        __result = D.39834 - D.39837;
        D.39838 = __s2_len > 2;
        D.39818 = __result == 0;
        D.39839 = D.39838 & D.39818;
        if (D.39839 != 0) goto <D.39840>; else goto <D.39841>;
        <D.39840>:
        D.39842 = &MEM[(void *)"MonoGenericCMethod" + 3B];
        D.39843 = *D.39842;
        D.39844 = (int) D.39843;
        D.39845 = __s2 + 3;
        D.39846 = *D.39845;
        D.39847 = (int) D.39846;
        __result = D.39844 - D.39847;
        <D.39841>:
        <D.39831>:
        <D.39821>:
      }
      D.23836 = __result;
    }
    iftmp.639 = -D.23836;
    goto <D.39848>;
    <D.39811>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.639 = __builtin_strcmp (D.39661, "MonoGenericCMethod");
    <D.39848>:
    D.23837 = iftmp.639;
  }
  if (D.23837 == 0) goto <D.39724>; else goto <D.39849>;
  <D.39849>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39853 = "MonoGenericMethod";
      D.39854 = MEM[(const unsigned char *)D.39853];
      D.39855 = (int) D.39854;
      D.39856 = *__s2;
      D.39857 = (int) D.39856;
      __result = D.39855 - D.39857;
      {
        D.39858 = __s2_len != 0;
        D.39859 = __result == 0;
        D.39860 = D.39858 & D.39859;
        if (D.39860 != 0) goto <D.39861>; else goto <D.39862>;
        <D.39861>:
        D.39863 = &MEM[(void *)"MonoGenericMethod" + 1B];
        D.39864 = *D.39863;
        D.39865 = (int) D.39864;
        D.39866 = __s2 + 1;
        D.39867 = *D.39866;
        D.39868 = (int) D.39867;
        __result = D.39865 - D.39868;
        D.39869 = __s2_len > 1;
        D.39859 = __result == 0;
        D.39870 = D.39869 & D.39859;
        if (D.39870 != 0) goto <D.39871>; else goto <D.39872>;
        <D.39871>:
        D.39873 = &MEM[(void *)"MonoGenericMethod" + 2B];
        D.39874 = *D.39873;
        D.39875 = (int) D.39874;
        D.39876 = __s2 + 2;
        D.39877 = *D.39876;
        D.39878 = (int) D.39877;
        __result = D.39875 - D.39878;
        D.39879 = __s2_len > 2;
        D.39859 = __result == 0;
        D.39880 = D.39879 & D.39859;
        if (D.39880 != 0) goto <D.39881>; else goto <D.39882>;
        <D.39881>:
        D.39883 = &MEM[(void *)"MonoGenericMethod" + 3B];
        D.39884 = *D.39883;
        D.39885 = (int) D.39884;
        D.39886 = __s2 + 3;
        D.39887 = *D.39886;
        D.39888 = (int) D.39887;
        __result = D.39885 - D.39888;
        <D.39882>:
        <D.39872>:
        <D.39862>:
      }
      D.23845 = __result;
    }
    iftmp.640 = -D.23845;
    goto <D.39889>;
    <D.39852>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.640 = __builtin_strcmp (D.39661, "MonoGenericMethod");
    <D.39889>:
    D.23846 = iftmp.640;
  }
  if (D.23846 == 0) goto <D.39724>; else goto <D.39725>;
  <D.39724>:
  result = MEM[(struct MonoReflectionMethod *)obj].method;
  if (context != 0B) goto <D.39890>; else goto <D.39891>;
  <D.39890>:
  result = mono_class_inflate_generic_method (result, context);
  <D.39891>:
  D.39892 = mono_defaults.methodhandle_class;
  *handle_class = D.39892;
  D.39665 = result == 0B;
  D.39666 = (long int) D.39665;
  D.39667 = __builtin_expect (D.39666, 0);
  if (D.39667 != 0) goto <D.39893>; else goto <D.39894>;
  <D.39893>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11775, "result");
  <D.39894>:
  goto <D.39726>;
  <D.39725>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39898 = "MethodBuilder";
      D.39899 = MEM[(const unsigned char *)D.39898];
      D.39900 = (int) D.39899;
      D.39901 = *__s2;
      D.39902 = (int) D.39901;
      __result = D.39900 - D.39902;
      {
        D.39903 = __s2_len != 0;
        D.39904 = __result == 0;
        D.39905 = D.39903 & D.39904;
        if (D.39905 != 0) goto <D.39906>; else goto <D.39907>;
        <D.39906>:
        D.39908 = &MEM[(void *)"MethodBuilder" + 1B];
        D.39909 = *D.39908;
        D.39910 = (int) D.39909;
        D.39911 = __s2 + 1;
        D.39912 = *D.39911;
        D.39913 = (int) D.39912;
        __result = D.39910 - D.39913;
        D.39914 = __s2_len > 1;
        D.39904 = __result == 0;
        D.39915 = D.39914 & D.39904;
        if (D.39915 != 0) goto <D.39916>; else goto <D.39917>;
        <D.39916>:
        D.39918 = &MEM[(void *)"MethodBuilder" + 2B];
        D.39919 = *D.39918;
        D.39920 = (int) D.39919;
        D.39921 = __s2 + 2;
        D.39922 = *D.39921;
        D.39923 = (int) D.39922;
        __result = D.39920 - D.39923;
        D.39924 = __s2_len > 2;
        D.39904 = __result == 0;
        D.39925 = D.39924 & D.39904;
        if (D.39925 != 0) goto <D.39926>; else goto <D.39927>;
        <D.39926>:
        D.39928 = &MEM[(void *)"MethodBuilder" + 3B];
        D.39929 = *D.39928;
        D.39930 = (int) D.39929;
        D.39931 = __s2 + 3;
        D.39932 = *D.39931;
        D.39933 = (int) D.39932;
        __result = D.39930 - D.39933;
        <D.39927>:
        <D.39917>:
        <D.39907>:
      }
      D.23854 = __result;
    }
    iftmp.641 = -D.23854;
    goto <D.39934>;
    <D.39897>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.641 = __builtin_strcmp (D.39661, "MethodBuilder");
    <D.39934>:
    D.23855 = iftmp.641;
  }
  if (D.23855 == 0) goto <D.39935>; else goto <D.39936>;
  <D.39935>:
  {
    struct MonoReflectionMethodBuilder * mb;

    mb = obj;
    result = mb->mhandle;
    if (result == 0B) goto <D.39937>; else goto <D.39938>;
    <D.39937>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = mb->type;
      D.39939 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39939, 0B, tb);
      result = mb->mhandle;
    }
    <D.39938>:
    if (context != 0B) goto <D.39940>; else goto <D.39941>;
    <D.39940>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39941>:
    D.39892 = mono_defaults.methodhandle_class;
    *handle_class = D.39892;
  }
  goto <D.39942>;
  <D.39936>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39946 = "ConstructorBuilder";
      D.39947 = MEM[(const unsigned char *)D.39946];
      D.39948 = (int) D.39947;
      D.39949 = *__s2;
      D.39950 = (int) D.39949;
      __result = D.39948 - D.39950;
      {
        D.39951 = __s2_len != 0;
        D.39952 = __result == 0;
        D.39953 = D.39951 & D.39952;
        if (D.39953 != 0) goto <D.39954>; else goto <D.39955>;
        <D.39954>:
        D.39956 = &MEM[(void *)"ConstructorBuilder" + 1B];
        D.39957 = *D.39956;
        D.39958 = (int) D.39957;
        D.39959 = __s2 + 1;
        D.39960 = *D.39959;
        D.39961 = (int) D.39960;
        __result = D.39958 - D.39961;
        D.39962 = __s2_len > 1;
        D.39952 = __result == 0;
        D.39963 = D.39962 & D.39952;
        if (D.39963 != 0) goto <D.39964>; else goto <D.39965>;
        <D.39964>:
        D.39966 = &MEM[(void *)"ConstructorBuilder" + 2B];
        D.39967 = *D.39966;
        D.39968 = (int) D.39967;
        D.39969 = __s2 + 2;
        D.39970 = *D.39969;
        D.39971 = (int) D.39970;
        __result = D.39968 - D.39971;
        D.39972 = __s2_len > 2;
        D.39952 = __result == 0;
        D.39973 = D.39972 & D.39952;
        if (D.39973 != 0) goto <D.39974>; else goto <D.39975>;
        <D.39974>:
        D.39976 = &MEM[(void *)"ConstructorBuilder" + 3B];
        D.39977 = *D.39976;
        D.39978 = (int) D.39977;
        D.39979 = __s2 + 3;
        D.39980 = *D.39979;
        D.39981 = (int) D.39980;
        __result = D.39978 - D.39981;
        <D.39975>:
        <D.39965>:
        <D.39955>:
      }
      D.23865 = __result;
    }
    iftmp.642 = -D.23865;
    goto <D.39982>;
    <D.39945>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.642 = __builtin_strcmp (D.39661, "ConstructorBuilder");
    <D.39982>:
    D.23866 = iftmp.642;
  }
  if (D.23866 == 0) goto <D.39983>; else goto <D.39984>;
  <D.39983>:
  {
    struct MonoReflectionCtorBuilder * cb;

    cb = obj;
    result = cb->mhandle;
    if (result == 0B) goto <D.39985>; else goto <D.39986>;
    <D.39985>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = cb->type;
      D.39987 = mono_domain_get ();
      mono_domain_try_type_resolve (D.39987, 0B, tb);
      result = cb->mhandle;
    }
    <D.39986>:
    if (context != 0B) goto <D.39988>; else goto <D.39989>;
    <D.39988>:
    result = mono_class_inflate_generic_method (result, context);
    <D.39989>:
    D.39892 = mono_defaults.methodhandle_class;
    *handle_class = D.39892;
  }
  goto <D.39990>;
  <D.39984>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.39994 = "MonoField";
      D.39995 = MEM[(const unsigned char *)D.39994];
      D.39996 = (int) D.39995;
      D.39997 = *__s2;
      D.39998 = (int) D.39997;
      __result = D.39996 - D.39998;
      {
        D.39999 = __s2_len != 0;
        D.40000 = __result == 0;
        D.40001 = D.39999 & D.40000;
        if (D.40001 != 0) goto <D.40002>; else goto <D.40003>;
        <D.40002>:
        D.40004 = &MEM[(void *)"MonoField" + 1B];
        D.40005 = *D.40004;
        D.40006 = (int) D.40005;
        D.40007 = __s2 + 1;
        D.40008 = *D.40007;
        D.40009 = (int) D.40008;
        __result = D.40006 - D.40009;
        D.40010 = __s2_len > 1;
        D.40000 = __result == 0;
        D.40011 = D.40010 & D.40000;
        if (D.40011 != 0) goto <D.40012>; else goto <D.40013>;
        <D.40012>:
        D.40014 = &MEM[(void *)"MonoField" + 2B];
        D.40015 = *D.40014;
        D.40016 = (int) D.40015;
        D.40017 = __s2 + 2;
        D.40018 = *D.40017;
        D.40019 = (int) D.40018;
        __result = D.40016 - D.40019;
        D.40020 = __s2_len > 2;
        D.40000 = __result == 0;
        D.40021 = D.40020 & D.40000;
        if (D.40021 != 0) goto <D.40022>; else goto <D.40023>;
        <D.40022>:
        D.40024 = &MEM[(void *)"MonoField" + 3B];
        D.40025 = *D.40024;
        D.40026 = (int) D.40025;
        D.40027 = __s2 + 3;
        D.40028 = *D.40027;
        D.40029 = (int) D.40028;
        __result = D.40026 - D.40029;
        <D.40023>:
        <D.40013>:
        <D.40003>:
      }
      D.23876 = __result;
    }
    iftmp.643 = -D.23876;
    goto <D.40030>;
    <D.39993>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.643 = __builtin_strcmp (D.39661, "MonoField");
    <D.40030>:
    D.23877 = iftmp.643;
  }
  if (D.23877 == 0) goto <D.40031>; else goto <D.40032>;
  <D.40031>:
  {
    struct MonoClassField * field;

    field = MEM[(struct MonoReflectionField *)obj].field;
    D.40033 = field->parent;
    ensure_complete_type (D.40033);
    if (context != 0B) goto <D.40034>; else goto <D.40035>;
    <D.40034>:
    {
      struct MonoType * inflated;
      struct MonoClass * class;
      struct MonoClassField * inflated_field;
      void * iter;

      try
        {
          D.40033 = field->parent;
          D.40036 = &D.40033->byval_arg;
          inflated = mono_class_inflate_generic_type (D.40036, context);
          class = mono_class_from_mono_type (inflated);
          iter = 0B;
          mono_metadata_free_type (inflated);
          goto <D.23894>;
          <D.23893>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.40037 = inflated_field->name;
            D.40038 = field->name;
            D.23891 = __builtin_strcmp (D.40038, D.40037);
          }
          if (D.23891 == 0) goto <D.23892>; else goto <D.40039>;
          <D.40039>:
          <D.23894>:
          inflated_field = mono_class_get_fields (class, &iter);
          if (inflated_field != 0B) goto <D.23893>; else goto <D.23892>;
          <D.23892>:
          if (inflated_field == 0B) goto <D.40041>; else goto <D.40044>;
          <D.40044>:
          {
            size_t __s1_len;
            size_t __s2_len;

            D.40037 = inflated_field->name;
            D.40038 = field->name;
            D.23903 = __builtin_strcmp (D.40038, D.40037);
          }
          if (D.23903 != 0) goto <D.40041>; else goto <D.40042>;
          <D.40041>:
          iftmp.644 = 1;
          goto <D.40043>;
          <D.40042>:
          iftmp.644 = 0;
          <D.40043>:
          D.40045 = iftmp.644 != 0;
          D.40046 = (long int) D.40045;
          D.40047 = __builtin_expect (D.40046, 0);
          if (D.40047 != 0) goto <D.40048>; else goto <D.40049>;
          <D.40048>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11825, "inflated_field && !strcmp (field->name, inflated_field->name)");
          <D.40049>:
          result = inflated_field;
        }
      finally
        {
          iter = {CLOBBER};
        }
    }
    goto <D.40050>;
    <D.40035>:
    result = field;
    <D.40050>:
    D.40051 = mono_defaults.fieldhandle_class;
    *handle_class = D.40051;
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.40052>; else goto <D.40053>;
    <D.40052>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11831, "result");
    <D.40053>:
  }
  goto <D.40054>;
  <D.40032>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40058 = "FieldBuilder";
      D.40059 = MEM[(const unsigned char *)D.40058];
      D.40060 = (int) D.40059;
      D.40061 = *__s2;
      D.40062 = (int) D.40061;
      __result = D.40060 - D.40062;
      {
        D.40063 = __s2_len != 0;
        D.40064 = __result == 0;
        D.40065 = D.40063 & D.40064;
        if (D.40065 != 0) goto <D.40066>; else goto <D.40067>;
        <D.40066>:
        D.40068 = &MEM[(void *)"FieldBuilder" + 1B];
        D.40069 = *D.40068;
        D.40070 = (int) D.40069;
        D.40071 = __s2 + 1;
        D.40072 = *D.40071;
        D.40073 = (int) D.40072;
        __result = D.40070 - D.40073;
        D.40074 = __s2_len > 1;
        D.40064 = __result == 0;
        D.40075 = D.40074 & D.40064;
        if (D.40075 != 0) goto <D.40076>; else goto <D.40077>;
        <D.40076>:
        D.40078 = &MEM[(void *)"FieldBuilder" + 2B];
        D.40079 = *D.40078;
        D.40080 = (int) D.40079;
        D.40081 = __s2 + 2;
        D.40082 = *D.40081;
        D.40083 = (int) D.40082;
        __result = D.40080 - D.40083;
        D.40084 = __s2_len > 2;
        D.40064 = __result == 0;
        D.40085 = D.40084 & D.40064;
        if (D.40085 != 0) goto <D.40086>; else goto <D.40087>;
        <D.40086>:
        D.40088 = &MEM[(void *)"FieldBuilder" + 3B];
        D.40089 = *D.40088;
        D.40090 = (int) D.40089;
        D.40091 = __s2 + 3;
        D.40092 = *D.40091;
        D.40093 = (int) D.40092;
        __result = D.40090 - D.40093;
        <D.40087>:
        <D.40077>:
        <D.40067>:
      }
      D.23911 = __result;
    }
    iftmp.645 = -D.23911;
    goto <D.40094>;
    <D.40057>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.645 = __builtin_strcmp (D.39661, "FieldBuilder");
    <D.40094>:
    D.23912 = iftmp.645;
  }
  if (D.23912 == 0) goto <D.40095>; else goto <D.40096>;
  <D.40095>:
  {
    struct MonoReflectionFieldBuilder * fb;

    fb = obj;
    result = fb->handle;
    if (result == 0B) goto <D.40097>; else goto <D.40098>;
    <D.40097>:
    {
      struct MonoReflectionTypeBuilder * tb;

      tb = fb->typeb;
      D.40099 = mono_domain_get ();
      mono_domain_try_type_resolve (D.40099, 0B, tb);
      result = fb->handle;
    }
    <D.40098>:
    D.40100 = fb->handle;
    if (D.40100 != 0B) goto <D.40101>; else goto <D.40102>;
    <D.40101>:
    D.40100 = fb->handle;
    D.40103 = D.40100->parent;
    D.40104 = D.40103->generic_container;
    if (D.40104 != 0B) goto <D.40105>; else goto <D.40106>;
    <D.40105>:
    {
      struct MonoClass * klass;
      struct MonoType * type;
      struct MonoClass * inflated;

      D.40100 = fb->handle;
      klass = D.40100->parent;
      D.40107 = &klass->byval_arg;
      type = mono_class_inflate_generic_type (D.40107, context);
      inflated = mono_class_from_mono_type (type);
      D.40100 = fb->handle;
      D.40108 = mono_field_get_name (D.40100);
      result = mono_class_get_field_from_name (inflated, D.40108);
      D.39665 = result == 0B;
      D.39666 = (long int) D.39665;
      D.39667 = __builtin_expect (D.39666, 0);
      if (D.39667 != 0) goto <D.40109>; else goto <D.40110>;
      <D.40109>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11849, "result");
      <D.40110>:
      mono_metadata_free_type (type);
    }
    <D.40106>:
    <D.40102>:
    D.40051 = mono_defaults.fieldhandle_class;
    *handle_class = D.40051;
  }
  goto <D.40111>;
  <D.40096>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40115 = "TypeBuilder";
      D.40116 = MEM[(const unsigned char *)D.40115];
      D.40117 = (int) D.40116;
      D.40118 = *__s2;
      D.40119 = (int) D.40118;
      __result = D.40117 - D.40119;
      {
        D.40120 = __s2_len != 0;
        D.40121 = __result == 0;
        D.40122 = D.40120 & D.40121;
        if (D.40122 != 0) goto <D.40123>; else goto <D.40124>;
        <D.40123>:
        D.40125 = &MEM[(void *)"TypeBuilder" + 1B];
        D.40126 = *D.40125;
        D.40127 = (int) D.40126;
        D.40128 = __s2 + 1;
        D.40129 = *D.40128;
        D.40130 = (int) D.40129;
        __result = D.40127 - D.40130;
        D.40131 = __s2_len > 1;
        D.40121 = __result == 0;
        D.40132 = D.40131 & D.40121;
        if (D.40132 != 0) goto <D.40133>; else goto <D.40134>;
        <D.40133>:
        D.40135 = &MEM[(void *)"TypeBuilder" + 2B];
        D.40136 = *D.40135;
        D.40137 = (int) D.40136;
        D.40138 = __s2 + 2;
        D.40139 = *D.40138;
        D.40140 = (int) D.40139;
        __result = D.40137 - D.40140;
        D.40141 = __s2_len > 2;
        D.40121 = __result == 0;
        D.40142 = D.40141 & D.40121;
        if (D.40142 != 0) goto <D.40143>; else goto <D.40144>;
        <D.40143>:
        D.40145 = &MEM[(void *)"TypeBuilder" + 3B];
        D.40146 = *D.40145;
        D.40147 = (int) D.40146;
        D.40148 = __s2 + 3;
        D.40149 = *D.40148;
        D.40150 = (int) D.40149;
        __result = D.40147 - D.40150;
        <D.40144>:
        <D.40134>:
        <D.40124>:
      }
      D.23925 = __result;
    }
    iftmp.646 = -D.23925;
    goto <D.40151>;
    <D.40114>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.646 = __builtin_strcmp (D.39661, "TypeBuilder");
    <D.40151>:
    D.23926 = iftmp.646;
  }
  if (D.23926 == 0) goto <D.40152>; else goto <D.40153>;
  <D.40152>:
  {
    struct MonoReflectionTypeBuilder * tb;
    struct MonoType * type;
    struct MonoClass * klass;

    tb = obj;
    type = mono_reflection_type_get_handle (tb);
    klass = type->data.klass;
    D.40154 = BIT_FIELD_REF <*klass, 8, 256>;
    D.40155 = D.40154 & 128;
    if (D.40155 != 0) goto <D.40156>; else goto <D.40157>;
    <D.40156>:
    result = klass;
    goto <D.40158>;
    <D.40157>:
    D.40159 = mono_domain_get ();
    mono_domain_try_type_resolve (D.40159, 0B, tb);
    result = type->data.klass;
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.40160>; else goto <D.40161>;
    <D.40160>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11866, "result");
    <D.40161>:
    <D.40158>:
    D.39720 = mono_defaults.typehandle_class;
    *handle_class = D.39720;
  }
  goto <D.40162>;
  <D.40153>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40166 = "SignatureHelper";
      D.40167 = MEM[(const unsigned char *)D.40166];
      D.40168 = (int) D.40167;
      D.40169 = *__s2;
      D.40170 = (int) D.40169;
      __result = D.40168 - D.40170;
      {
        D.40171 = __s2_len != 0;
        D.40172 = __result == 0;
        D.40173 = D.40171 & D.40172;
        if (D.40173 != 0) goto <D.40174>; else goto <D.40175>;
        <D.40174>:
        D.40176 = &MEM[(void *)"SignatureHelper" + 1B];
        D.40177 = *D.40176;
        D.40178 = (int) D.40177;
        D.40179 = __s2 + 1;
        D.40180 = *D.40179;
        D.40181 = (int) D.40180;
        __result = D.40178 - D.40181;
        D.40182 = __s2_len > 1;
        D.40172 = __result == 0;
        D.40183 = D.40182 & D.40172;
        if (D.40183 != 0) goto <D.40184>; else goto <D.40185>;
        <D.40184>:
        D.40186 = &MEM[(void *)"SignatureHelper" + 2B];
        D.40187 = *D.40186;
        D.40188 = (int) D.40187;
        D.40189 = __s2 + 2;
        D.40190 = *D.40189;
        D.40191 = (int) D.40190;
        __result = D.40188 - D.40191;
        D.40192 = __s2_len > 2;
        D.40172 = __result == 0;
        D.40193 = D.40192 & D.40172;
        if (D.40193 != 0) goto <D.40194>; else goto <D.40195>;
        <D.40194>:
        D.40196 = &MEM[(void *)"SignatureHelper" + 3B];
        D.40197 = *D.40196;
        D.40198 = (int) D.40197;
        D.40199 = __s2 + 3;
        D.40200 = *D.40199;
        D.40201 = (int) D.40200;
        __result = D.40198 - D.40201;
        <D.40195>:
        <D.40185>:
        <D.40175>:
      }
      D.23937 = __result;
    }
    iftmp.647 = -D.23937;
    goto <D.40202>;
    <D.40165>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.647 = __builtin_strcmp (D.39661, "SignatureHelper");
    <D.40202>:
    D.23938 = iftmp.647;
  }
  if (D.23938 == 0) goto <D.40203>; else goto <D.40204>;
  <D.40203>:
  {
    struct MonoReflectionSigHelper * helper;
    struct MonoMethodSignature * sig;
    int nargs;
    int i;

    helper = obj;
    D.40205 = helper->arguments;
    if (D.40205 != 0B) goto <D.40206>; else goto <D.40207>;
    <D.40206>:
    D.40205 = helper->arguments;
    D.40208 = mono_array_length (D.40205);
    nargs = (int) D.40208;
    goto <D.40209>;
    <D.40207>:
    nargs = 0;
    <D.40209>:
    nargs.648 = (unsigned int) nargs;
    sig = mono_metadata_signature_alloc (image, nargs.648);
    D.40211 = helper->call_conv;
    D.40212 = D.40211 & 64;
    D.40213 = D.40212 != 0;
    sig->explicit_this = D.40213;
    D.40211 = helper->call_conv;
    D.40214 = D.40211 & 32;
    D.40215 = D.40214 != 0;
    sig->hasthis = D.40215;
    D.40216 = helper->unmanaged_call_conv;
    if (D.40216 != 0) goto <D.40217>; else goto <D.40218>;
    <D.40217>:
    D.40216 = helper->unmanaged_call_conv;
    D.40219 = (unsigned char) D.40216;
    D.40220 = D.40219 + 255;
    D.40221 = (<unnamed-unsigned:6>) D.40220;
    sig->call_convention = D.40221;
    sig->pinvoke = 1;
    goto <D.40222>;
    <D.40218>:
    D.40211 = helper->call_conv;
    D.40223 = D.40211 & 2;
    if (D.40223 != 0) goto <D.40224>; else goto <D.40225>;
    <D.40224>:
    sig->call_convention = 5;
    goto <D.40226>;
    <D.40225>:
    sig->call_convention = 0;
    <D.40226>:
    <D.40222>:
    D.40227 = (short unsigned int) nargs;
    sig->param_count = D.40227;
    D.40228 = helper->return_type;
    D.40229 = D.40228->type;
    sig->ret = D.40229;
    i = 0;
    goto <D.23944>;
    <D.23943>:
    D.40230 = (long unsigned int) i;
    D.40205 = helper->arguments;
    D.40231 = mono_array_addr_with_size (D.40205, 8, D.40230);
    D.40232 = MEM[(void * *)D.40231];
    D.40233 = mono_reflection_type_get_handle (D.40232);
    sig->params[i] = D.40233;
    i = i + 1;
    <D.23944>:
    if (i < nargs) goto <D.23943>; else goto <D.23945>;
    <D.23945>:
    result = sig;
    *handle_class = 0B;
  }
  goto <D.40234>;
  <D.40204>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40238 = "DynamicMethod";
      D.40239 = MEM[(const unsigned char *)D.40238];
      D.40240 = (int) D.40239;
      D.40241 = *__s2;
      D.40242 = (int) D.40241;
      __result = D.40240 - D.40242;
      {
        D.40243 = __s2_len != 0;
        D.40244 = __result == 0;
        D.40245 = D.40243 & D.40244;
        if (D.40245 != 0) goto <D.40246>; else goto <D.40247>;
        <D.40246>:
        D.40248 = &MEM[(void *)"DynamicMethod" + 1B];
        D.40249 = *D.40248;
        D.40250 = (int) D.40249;
        D.40251 = __s2 + 1;
        D.40252 = *D.40251;
        D.40253 = (int) D.40252;
        __result = D.40250 - D.40253;
        D.40254 = __s2_len > 1;
        D.40244 = __result == 0;
        D.40255 = D.40254 & D.40244;
        if (D.40255 != 0) goto <D.40256>; else goto <D.40257>;
        <D.40256>:
        D.40258 = &MEM[(void *)"DynamicMethod" + 2B];
        D.40259 = *D.40258;
        D.40260 = (int) D.40259;
        D.40261 = __s2 + 2;
        D.40262 = *D.40261;
        D.40263 = (int) D.40262;
        __result = D.40260 - D.40263;
        D.40264 = __s2_len > 2;
        D.40244 = __result == 0;
        D.40265 = D.40264 & D.40244;
        if (D.40265 != 0) goto <D.40266>; else goto <D.40267>;
        <D.40266>:
        D.40268 = &MEM[(void *)"DynamicMethod" + 3B];
        D.40269 = *D.40268;
        D.40270 = (int) D.40269;
        D.40271 = __s2 + 3;
        D.40272 = *D.40271;
        D.40273 = (int) D.40272;
        __result = D.40270 - D.40273;
        <D.40267>:
        <D.40257>:
        <D.40247>:
      }
      D.23953 = __result;
    }
    iftmp.649 = -D.23953;
    goto <D.40274>;
    <D.40237>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.649 = __builtin_strcmp (D.39661, "DynamicMethod");
    <D.40274>:
    D.23954 = iftmp.649;
  }
  if (D.23954 == 0) goto <D.40275>; else goto <D.40276>;
  <D.40275>:
  {
    struct MonoReflectionDynamicMethod * method;

    method = obj;
    D.40277 = method->mhandle;
    D.40278 = D.40277 == 0B;
    D.40279 = (long int) D.40278;
    D.40280 = __builtin_expect (D.40279, 0);
    if (D.40280 != 0) goto <D.40281>; else goto <D.40282>;
    <D.40281>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11903, "method->mhandle");
    <D.40282>:
    result = method->mhandle;
    D.39892 = mono_defaults.methodhandle_class;
    *handle_class = D.39892;
  }
  goto <D.40283>;
  <D.40276>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40287 = "GenericTypeParameterBuilder";
      D.40288 = MEM[(const unsigned char *)D.40287];
      D.40289 = (int) D.40288;
      D.40290 = *__s2;
      D.40291 = (int) D.40290;
      __result = D.40289 - D.40291;
      {
        D.40292 = __s2_len != 0;
        D.40293 = __result == 0;
        D.40294 = D.40292 & D.40293;
        if (D.40294 != 0) goto <D.40295>; else goto <D.40296>;
        <D.40295>:
        D.40297 = &MEM[(void *)"GenericTypeParameterBuilder" + 1B];
        D.40298 = *D.40297;
        D.40299 = (int) D.40298;
        D.40300 = __s2 + 1;
        D.40301 = *D.40300;
        D.40302 = (int) D.40301;
        __result = D.40299 - D.40302;
        D.40303 = __s2_len > 1;
        D.40293 = __result == 0;
        D.40304 = D.40303 & D.40293;
        if (D.40304 != 0) goto <D.40305>; else goto <D.40306>;
        <D.40305>:
        D.40307 = &MEM[(void *)"GenericTypeParameterBuilder" + 2B];
        D.40308 = *D.40307;
        D.40309 = (int) D.40308;
        D.40310 = __s2 + 2;
        D.40311 = *D.40310;
        D.40312 = (int) D.40311;
        __result = D.40309 - D.40312;
        D.40313 = __s2_len > 2;
        D.40293 = __result == 0;
        D.40314 = D.40313 & D.40293;
        if (D.40314 != 0) goto <D.40315>; else goto <D.40316>;
        <D.40315>:
        D.40317 = &MEM[(void *)"GenericTypeParameterBuilder" + 3B];
        D.40318 = *D.40317;
        D.40319 = (int) D.40318;
        D.40320 = __s2 + 3;
        D.40321 = *D.40320;
        D.40322 = (int) D.40321;
        __result = D.40319 - D.40322;
        <D.40316>:
        <D.40306>:
        <D.40296>:
      }
      D.23963 = __result;
    }
    iftmp.650 = -D.23963;
    goto <D.40323>;
    <D.40286>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.650 = __builtin_strcmp (D.39661, "GenericTypeParameterBuilder");
    <D.40323>:
    D.23964 = iftmp.650;
  }
  if (D.23964 == 0) goto <D.40324>; else goto <D.40325>;
  <D.40324>:
  {
    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.39720 = mono_defaults.typehandle_class;
    *handle_class = D.39720;
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.40326>; else goto <D.40327>;
    <D.40326>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11911, "result");
    <D.40327>:
    mono_metadata_free_type (type);
  }
  goto <D.40328>;
  <D.40325>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40332 = "MonoGenericClass";
      D.40333 = MEM[(const unsigned char *)D.40332];
      D.40334 = (int) D.40333;
      D.40335 = *__s2;
      D.40336 = (int) D.40335;
      __result = D.40334 - D.40336;
      {
        D.40337 = __s2_len != 0;
        D.40338 = __result == 0;
        D.40339 = D.40337 & D.40338;
        if (D.40339 != 0) goto <D.40340>; else goto <D.40341>;
        <D.40340>:
        D.40342 = &MEM[(void *)"MonoGenericClass" + 1B];
        D.40343 = *D.40342;
        D.40344 = (int) D.40343;
        D.40345 = __s2 + 1;
        D.40346 = *D.40345;
        D.40347 = (int) D.40346;
        __result = D.40344 - D.40347;
        D.40348 = __s2_len > 1;
        D.40338 = __result == 0;
        D.40349 = D.40348 & D.40338;
        if (D.40349 != 0) goto <D.40350>; else goto <D.40351>;
        <D.40350>:
        D.40352 = &MEM[(void *)"MonoGenericClass" + 2B];
        D.40353 = *D.40352;
        D.40354 = (int) D.40353;
        D.40355 = __s2 + 2;
        D.40356 = *D.40355;
        D.40357 = (int) D.40356;
        __result = D.40354 - D.40357;
        D.40358 = __s2_len > 2;
        D.40338 = __result == 0;
        D.40359 = D.40358 & D.40338;
        if (D.40359 != 0) goto <D.40360>; else goto <D.40361>;
        <D.40360>:
        D.40362 = &MEM[(void *)"MonoGenericClass" + 3B];
        D.40363 = *D.40362;
        D.40364 = (int) D.40363;
        D.40365 = __s2 + 3;
        D.40366 = *D.40365;
        D.40367 = (int) D.40366;
        __result = D.40364 - D.40367;
        <D.40361>:
        <D.40351>:
        <D.40341>:
      }
      D.23973 = __result;
    }
    iftmp.651 = -D.23973;
    goto <D.40368>;
    <D.40331>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.651 = __builtin_strcmp (D.39661, "MonoGenericClass");
    <D.40368>:
    D.23974 = iftmp.651;
  }
  if (D.23974 == 0) goto <D.40369>; else goto <D.40370>;
  <D.40369>:
  {
    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.39720 = mono_defaults.typehandle_class;
    *handle_class = D.39720;
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.40371>; else goto <D.40372>;
    <D.40371>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11918, "result");
    <D.40372>:
    mono_metadata_free_type (type);
  }
  goto <D.40373>;
  <D.40370>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40377 = "FieldOnTypeBuilderInst";
      D.40378 = MEM[(const unsigned char *)D.40377];
      D.40379 = (int) D.40378;
      D.40380 = *__s2;
      D.40381 = (int) D.40380;
      __result = D.40379 - D.40381;
      {
        D.40382 = __s2_len != 0;
        D.40383 = __result == 0;
        D.40384 = D.40382 & D.40383;
        if (D.40384 != 0) goto <D.40385>; else goto <D.40386>;
        <D.40385>:
        D.40387 = &MEM[(void *)"FieldOnTypeBuilderInst" + 1B];
        D.40388 = *D.40387;
        D.40389 = (int) D.40388;
        D.40390 = __s2 + 1;
        D.40391 = *D.40390;
        D.40392 = (int) D.40391;
        __result = D.40389 - D.40392;
        D.40393 = __s2_len > 1;
        D.40383 = __result == 0;
        D.40394 = D.40393 & D.40383;
        if (D.40394 != 0) goto <D.40395>; else goto <D.40396>;
        <D.40395>:
        D.40397 = &MEM[(void *)"FieldOnTypeBuilderInst" + 2B];
        D.40398 = *D.40397;
        D.40399 = (int) D.40398;
        D.40400 = __s2 + 2;
        D.40401 = *D.40400;
        D.40402 = (int) D.40401;
        __result = D.40399 - D.40402;
        D.40403 = __s2_len > 2;
        D.40383 = __result == 0;
        D.40404 = D.40403 & D.40383;
        if (D.40404 != 0) goto <D.40405>; else goto <D.40406>;
        <D.40405>:
        D.40407 = &MEM[(void *)"FieldOnTypeBuilderInst" + 3B];
        D.40408 = *D.40407;
        D.40409 = (int) D.40408;
        D.40410 = __s2 + 3;
        D.40411 = *D.40410;
        D.40412 = (int) D.40411;
        __result = D.40409 - D.40412;
        <D.40406>:
        <D.40396>:
        <D.40386>:
      }
      D.23983 = __result;
    }
    iftmp.652 = -D.23983;
    goto <D.40413>;
    <D.40376>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.652 = __builtin_strcmp (D.39661, "FieldOnTypeBuilderInst");
    <D.40413>:
    D.23984 = iftmp.652;
  }
  if (D.23984 == 0) goto <D.40414>; else goto <D.40415>;
  <D.40414>:
  {
    struct MonoReflectionFieldOnTypeBuilderInst * f;
    struct MonoClass * inflated;
    struct MonoType * type;
    struct MonoClassField * field;

    f = obj;
    D.40416 = f->fb;
    D.40417 = D.40416->vtable;
    D.40418 = D.40417->klass;
    D.40419 = is_sre_field_builder (D.40418);
    if (D.40419 != 0) goto <D.40420>; else goto <D.40421>;
    <D.40420>:
    D.40416 = f->fb;
    field = MEM[(struct MonoReflectionFieldBuilder *)D.40416].handle;
    goto <D.40422>;
    <D.40421>:
    D.40416 = f->fb;
    D.40417 = D.40416->vtable;
    D.40418 = D.40417->klass;
    D.40423 = is_sr_mono_field (D.40418);
    if (D.40423 != 0) goto <D.40424>; else goto <D.40425>;
    <D.40424>:
    D.40416 = f->fb;
    field = MEM[(struct MonoReflectionField *)D.40416].field;
    goto <D.40426>;
    <D.40425>:
    D.40416 = f->fb;
    D.40417 = D.40416->vtable;
    D.40418 = D.40417->klass;
    D.40427 = mono_type_get_full_name (D.40418);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a FTBI with base_method of type %s", D.40427);
    <D.23989>:
    goto <D.23989>;
    <D.40426>:
    <D.40422>:
    D.40428 = f->inst;
    D.40429 = mono_reflection_type_get_handle (D.40428);
    type = mono_class_inflate_generic_type (D.40429, context);
    inflated = mono_class_from_mono_type (type);
    D.40430 = mono_field_get_name (field);
    field = mono_class_get_field_from_name (inflated, D.40430);
    result = field;
    D.40431 = field->parent;
    ensure_complete_type (D.40431);
    D.39665 = result == 0B;
    D.39666 = (long int) D.39665;
    D.39667 = __builtin_expect (D.39666, 0);
    if (D.39667 != 0) goto <D.40432>; else goto <D.40433>;
    <D.40432>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11938, "result");
    <D.40433>:
    mono_metadata_free_type (type);
    D.40051 = mono_defaults.fieldhandle_class;
    *handle_class = D.40051;
  }
  goto <D.40434>;
  <D.40415>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40438 = "ConstructorOnTypeBuilderInst";
      D.40439 = MEM[(const unsigned char *)D.40438];
      D.40440 = (int) D.40439;
      D.40441 = *__s2;
      D.40442 = (int) D.40441;
      __result = D.40440 - D.40442;
      {
        D.40443 = __s2_len != 0;
        D.40444 = __result == 0;
        D.40445 = D.40443 & D.40444;
        if (D.40445 != 0) goto <D.40446>; else goto <D.40447>;
        <D.40446>:
        D.40448 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 1B];
        D.40449 = *D.40448;
        D.40450 = (int) D.40449;
        D.40451 = __s2 + 1;
        D.40452 = *D.40451;
        D.40453 = (int) D.40452;
        __result = D.40450 - D.40453;
        D.40454 = __s2_len > 1;
        D.40444 = __result == 0;
        D.40455 = D.40454 & D.40444;
        if (D.40455 != 0) goto <D.40456>; else goto <D.40457>;
        <D.40456>:
        D.40458 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 2B];
        D.40459 = *D.40458;
        D.40460 = (int) D.40459;
        D.40461 = __s2 + 2;
        D.40462 = *D.40461;
        D.40463 = (int) D.40462;
        __result = D.40460 - D.40463;
        D.40464 = __s2_len > 2;
        D.40444 = __result == 0;
        D.40465 = D.40464 & D.40444;
        if (D.40465 != 0) goto <D.40466>; else goto <D.40467>;
        <D.40466>:
        D.40468 = &MEM[(void *)"ConstructorOnTypeBuilderInst" + 3B];
        D.40469 = *D.40468;
        D.40470 = (int) D.40469;
        D.40471 = __s2 + 3;
        D.40472 = *D.40471;
        D.40473 = (int) D.40472;
        __result = D.40470 - D.40473;
        <D.40467>:
        <D.40457>:
        <D.40447>:
      }
      D.23997 = __result;
    }
    iftmp.653 = -D.23997;
    goto <D.40474>;
    <D.40437>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.653 = __builtin_strcmp (D.39661, "ConstructorOnTypeBuilderInst");
    <D.40474>:
    D.23998 = iftmp.653;
  }
  if (D.23998 == 0) goto <D.40475>; else goto <D.40476>;
  <D.40475>:
  {
    struct MonoReflectionCtorOnTypeBuilderInst * c;
    struct MonoType * type;
    struct MonoClass * inflated_klass;
    struct MonoMethod * method;

    c = obj;
    D.40477 = c->inst;
    D.40478 = mono_reflection_type_get_handle (D.40477);
    type = mono_class_inflate_generic_type (D.40478, context);
    inflated_klass = mono_class_from_mono_type (type);
    D.40479 = c->cb;
    D.40480 = D.40479->vtable;
    D.40481 = D.40480->klass;
    D.40482 = is_sre_ctor_builder (D.40481);
    if (D.40482 != 0) goto <D.40483>; else goto <D.40484>;
    <D.40483>:
    D.40479 = c->cb;
    method = MEM[(struct MonoReflectionCtorBuilder *)D.40479].mhandle;
    goto <D.40485>;
    <D.40484>:
    D.40479 = c->cb;
    D.40480 = D.40479->vtable;
    D.40481 = D.40480->klass;
    D.40486 = is_sr_mono_cmethod (D.40481);
    if (D.40486 != 0) goto <D.40487>; else goto <D.40488>;
    <D.40487>:
    D.40479 = c->cb;
    method = MEM[(struct MonoReflectionMethod *)D.40479].method;
    goto <D.40489>;
    <D.40488>:
    D.40479 = c->cb;
    D.40480 = D.40479->vtable;
    D.40481 = D.40480->klass;
    D.40490 = mono_type_get_full_name (D.40481);
    monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a CTBI with base_method of type %s", D.40490);
    <D.24003>:
    goto <D.24003>;
    <D.40489>:
    <D.40485>:
    D.40479 = c->cb;
    result = inflate_mono_method (inflated_klass, method, D.40479);
    D.39892 = mono_defaults.methodhandle_class;
    *handle_class = D.39892;
    mono_metadata_free_type (type);
  }
  goto <D.40491>;
  <D.40476>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40495 = "MethodOnTypeBuilderInst";
      D.40496 = MEM[(const unsigned char *)D.40495];
      D.40497 = (int) D.40496;
      D.40498 = *__s2;
      D.40499 = (int) D.40498;
      __result = D.40497 - D.40499;
      {
        D.40500 = __s2_len != 0;
        D.40501 = __result == 0;
        D.40502 = D.40500 & D.40501;
        if (D.40502 != 0) goto <D.40503>; else goto <D.40504>;
        <D.40503>:
        D.40505 = &MEM[(void *)"MethodOnTypeBuilderInst" + 1B];
        D.40506 = *D.40505;
        D.40507 = (int) D.40506;
        D.40508 = __s2 + 1;
        D.40509 = *D.40508;
        D.40510 = (int) D.40509;
        __result = D.40507 - D.40510;
        D.40511 = __s2_len > 1;
        D.40501 = __result == 0;
        D.40512 = D.40511 & D.40501;
        if (D.40512 != 0) goto <D.40513>; else goto <D.40514>;
        <D.40513>:
        D.40515 = &MEM[(void *)"MethodOnTypeBuilderInst" + 2B];
        D.40516 = *D.40515;
        D.40517 = (int) D.40516;
        D.40518 = __s2 + 2;
        D.40519 = *D.40518;
        D.40520 = (int) D.40519;
        __result = D.40517 - D.40520;
        D.40521 = __s2_len > 2;
        D.40501 = __result == 0;
        D.40522 = D.40521 & D.40501;
        if (D.40522 != 0) goto <D.40523>; else goto <D.40524>;
        <D.40523>:
        D.40525 = &MEM[(void *)"MethodOnTypeBuilderInst" + 3B];
        D.40526 = *D.40525;
        D.40527 = (int) D.40526;
        D.40528 = __s2 + 3;
        D.40529 = *D.40528;
        D.40530 = (int) D.40529;
        __result = D.40527 - D.40530;
        <D.40524>:
        <D.40514>:
        <D.40504>:
      }
      D.24011 = __result;
    }
    iftmp.654 = -D.24011;
    goto <D.40531>;
    <D.40494>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.654 = __builtin_strcmp (D.39661, "MethodOnTypeBuilderInst");
    <D.40531>:
    D.24012 = iftmp.654;
  }
  if (D.24012 == 0) goto <D.40532>; else goto <D.40533>;
  <D.40532>:
  {
    struct MonoReflectionMethodOnTypeBuilderInst * m;

    m = obj;
    D.40534 = m->method_args;
    if (D.40534 != 0B) goto <D.40535>; else goto <D.40536>;
    <D.40535>:
    result = mono_reflection_method_on_tb_inst_get_handle (m);
    if (context != 0B) goto <D.40537>; else goto <D.40538>;
    <D.40537>:
    result = mono_class_inflate_generic_method (result, context);
    <D.40538>:
    goto <D.40539>;
    <D.40536>:
    {
      struct MonoType * type;
      struct MonoClass * inflated_klass;
      struct MonoMethod * method;

      D.40540 = m->inst;
      D.40541 = mono_reflection_type_get_handle (D.40540);
      type = mono_class_inflate_generic_type (D.40541, context);
      inflated_klass = mono_class_from_mono_type (type);
      D.40542 = m->mb;
      D.40543 = D.40542->vtable;
      D.40544 = D.40543->klass;
      D.40545 = is_sre_method_builder (D.40544);
      if (D.40545 != 0) goto <D.40546>; else goto <D.40547>;
      <D.40546>:
      D.40542 = m->mb;
      method = MEM[(struct MonoReflectionMethodBuilder *)D.40542].mhandle;
      goto <D.40548>;
      <D.40547>:
      D.40542 = m->mb;
      D.40543 = D.40542->vtable;
      D.40544 = D.40543->klass;
      D.40549 = is_sr_mono_method (D.40544);
      if (D.40549 != 0) goto <D.40550>; else goto <D.40551>;
      <D.40550>:
      D.40542 = m->mb;
      method = MEM[(struct MonoReflectionMethod *)D.40542].method;
      goto <D.40552>;
      <D.40551>:
      D.40542 = m->mb;
      D.40543 = D.40542->vtable;
      D.40544 = D.40543->klass;
      D.40553 = mono_type_get_full_name (D.40544);
      monoeg_g_log (0B, 4, "resolve_object:: can\'t handle a MTBI with base_method of type %s", D.40553);
      <D.24017>:
      goto <D.24017>;
      <D.40552>:
      <D.40548>:
      D.40542 = m->mb;
      result = inflate_mono_method (inflated_klass, method, D.40542);
      mono_metadata_free_type (type);
    }
    <D.40539>:
    D.39892 = mono_defaults.methodhandle_class;
    *handle_class = D.39892;
  }
  goto <D.40554>;
  <D.40533>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.39622 = obj->vtable;
      D.39623 = D.39622->klass;
      __s2 = D.39623->name;
      D.40558 = "MonoArrayMethod";
      D.40559 = MEM[(const unsigned char *)D.40558];
      D.40560 = (int) D.40559;
      D.40561 = *__s2;
      D.40562 = (int) D.40561;
      __result = D.40560 - D.40562;
      {
        D.40563 = __s2_len != 0;
        D.40564 = __result == 0;
        D.40565 = D.40563 & D.40564;
        if (D.40565 != 0) goto <D.40566>; else goto <D.40567>;
        <D.40566>:
        D.40568 = &MEM[(void *)"MonoArrayMethod" + 1B];
        D.40569 = *D.40568;
        D.40570 = (int) D.40569;
        D.40571 = __s2 + 1;
        D.40572 = *D.40571;
        D.40573 = (int) D.40572;
        __result = D.40570 - D.40573;
        D.40574 = __s2_len > 1;
        D.40564 = __result == 0;
        D.40575 = D.40574 & D.40564;
        if (D.40575 != 0) goto <D.40576>; else goto <D.40577>;
        <D.40576>:
        D.40578 = &MEM[(void *)"MonoArrayMethod" + 2B];
        D.40579 = *D.40578;
        D.40580 = (int) D.40579;
        D.40581 = __s2 + 2;
        D.40582 = *D.40581;
        D.40583 = (int) D.40582;
        __result = D.40580 - D.40583;
        D.40584 = __s2_len > 2;
        D.40564 = __result == 0;
        D.40585 = D.40584 & D.40564;
        if (D.40585 != 0) goto <D.40586>; else goto <D.40587>;
        <D.40586>:
        D.40588 = &MEM[(void *)"MonoArrayMethod" + 3B];
        D.40589 = *D.40588;
        D.40590 = (int) D.40589;
        D.40591 = __s2 + 3;
        D.40592 = *D.40591;
        D.40593 = (int) D.40592;
        __result = D.40590 - D.40593;
        <D.40587>:
        <D.40577>:
        <D.40567>:
      }
      D.24025 = __result;
    }
    iftmp.655 = -D.24025;
    goto <D.40594>;
    <D.40557>:
    D.39622 = obj->vtable;
    D.39623 = D.39622->klass;
    D.39661 = D.39623->name;
    iftmp.655 = __builtin_strcmp (D.39661, "MonoArrayMethod");
    <D.40594>:
    D.24026 = iftmp.655;
  }
  if (D.24026 == 0) goto <D.40595>; else goto <D.40596>;
  <D.40595>:
  {
    struct MonoReflectionArrayMethod * m;
    struct MonoType * mtype;
    struct MonoClass * klass;
    struct MonoMethod * method;
    void * iter;
    char * name;

    try
      {
        m = obj;
        D.40597 = m->parent;
        mtype = mono_reflection_type_get_handle (D.40597);
        klass = mono_class_from_mono_type (mtype);
        D.40598 = m->name;
        name = mono_string_to_utf8 (D.40598);
        iter = 0B;
        goto <D.24044>;
        <D.24043>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.40599 = method->name;
          D.24041 = __builtin_strcmp (D.40599, name);
        }
        if (D.24041 == 0) goto <D.24042>; else goto <D.40600>;
        <D.40600>:
        <D.24044>:
        method = mono_class_get_methods (klass, &iter);
        if (method != 0B) goto <D.24043>; else goto <D.24042>;
        <D.24042>:
        monoeg_g_free (name);
        D.40601 = method == 0B;
        D.40602 = (long int) D.40601;
        D.40603 = __builtin_expect (D.40602, 0);
        if (D.40603 != 0) goto <D.40604>; else goto <D.40605>;
        <D.40604>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12001, "method");
        <D.40605>:
        result = method;
        D.39892 = mono_defaults.methodhandle_class;
        *handle_class = D.39892;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  goto <D.40606>;
  <D.40596>:
  D.40610 = mono_object_get_class (obj);
  D.40611 = is_sre_array (D.40610);
  if (D.40611 != 0) goto <D.40607>; else goto <D.40612>;
  <D.40612>:
  D.40613 = mono_object_get_class (obj);
  D.40614 = is_sre_byref (D.40613);
  if (D.40614 != 0) goto <D.40607>; else goto <D.40615>;
  <D.40615>:
  D.40616 = mono_object_get_class (obj);
  D.40617 = is_sre_pointer (D.40616);
  if (D.40617 != 0) goto <D.40607>; else goto <D.40608>;
  <D.40607>:
  {
    struct MonoReflectionType * ref_type;
    struct MonoType * type;

    ref_type = obj;
    type = mono_reflection_type_get_handle (ref_type);
    if (context != 0B) goto <D.40618>; else goto <D.40619>;
    <D.40618>:
    {
      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.40620>;
    <D.40619>:
    result = mono_class_from_mono_type (type);
    <D.40620>:
    D.39720 = mono_defaults.typehandle_class;
    *handle_class = D.39720;
  }
  goto <D.40609>;
  <D.40608>:
  D.39622 = obj->vtable;
  D.39623 = D.39622->klass;
  D.39661 = D.39623->name;
  monoeg_g_print ("%s\n", D.39661);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12022);
  <D.40609>:
  <D.40606>:
  <D.40554>:
  <D.40491>:
  <D.40434>:
  <D.40373>:
  <D.40328>:
  <D.40283>:
  <D.40234>:
  <D.40162>:
  <D.40111>:
  <D.40054>:
  <D.39990>:
  <D.39942>:
  <D.39726>:
  <D.39723>:
  <D.39670>:
  D.40621 = result;
  return D.40621;
}


ensure_complete_type (struct MonoClass * klass)
{
  struct MonoImage * D.40623;
  unsigned char D.40624;
  unsigned char D.40625;
  unsigned char D.40628;
  unsigned char D.40629;
  void * D.40632;
  struct MonoDomain * D.40635;
  struct MonoGenericClass * D.40636;
  struct MonoType * D.40639;
  struct MonoClass * D.40640;
  <unnamed-unsigned:22> D.40641;
  int D.40642;

  D.40623 = klass->image;
  D.40624 = BIT_FIELD_REF <*D.40623, 8, 224>;
  D.40625 = D.40624 & 8;
  if (D.40625 != 0) goto <D.40626>; else goto <D.40627>;
  <D.40626>:
  D.40628 = BIT_FIELD_REF <*klass, 8, 256>;
  D.40629 = D.40628 & 128;
  if (D.40629 == 0) goto <D.40630>; else goto <D.40631>;
  <D.40630>:
  D.40632 = mono_class_get_ref_info (klass);
  if (D.40632 != 0B) goto <D.40633>; else goto <D.40634>;
  <D.40633>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = mono_class_get_ref_info (klass);
    D.40635 = mono_domain_get ();
    mono_domain_try_type_resolve (D.40635, 0B, tb);
  }
  <D.40634>:
  <D.40631>:
  <D.40627>:
  D.40636 = klass->generic_class;
  if (D.40636 != 0B) goto <D.40637>; else goto <D.40638>;
  <D.40637>:
  {
    struct MonoGenericInst * inst;
    int i;

    D.40636 = klass->generic_class;
    inst = D.40636->context.class_inst;
    i = 0;
    goto <D.23781>;
    <D.23780>:
    D.40639 = inst->type_argv[i];
    D.40640 = mono_class_from_mono_type (D.40639);
    ensure_complete_type (D.40640);
    i = i + 1;
    <D.23781>:
    D.40641 = inst->type_argc;
    D.40642 = (int) D.40641;
    if (D.40642 > i) goto <D.23780>; else goto <D.23782>;
    <D.23782>:
  }
  <D.40638>:
}


mono_reflection_is_valid_dynamic_token (struct MonoDynamicImage * image, guint32 token)
{
  gboolean D.40643;
  long unsigned int D.40644;
  const void * D.40645;
  struct MonoGHashTable * D.40646;
  void * D.40647;
  _Bool D.40648;

  D.40644 = (long unsigned int) token;
  D.40645 = (const void *) D.40644;
  D.40646 = image->tokens;
  D.40647 = mono_g_hash_table_lookup (D.40646, D.40645);
  D.40648 = D.40647 != 0B;
  D.40643 = (gboolean) D.40648;
  return D.40643;
}


mono_reflection_lookup_signature (struct MonoImage * image, struct MonoMethod * method, guint32 token)
{
  unsigned char D.40650;
  unsigned char D.40651;
  _Bool D.40652;
  long int D.40653;
  long int D.40654;
  long unsigned int D.40657;
  const void * D.40658;
  struct GHashTable * D.40659;
  struct MonoMethodSignature * D.40662;
  struct MonoMethodSignature * sig;

  D.40650 = BIT_FIELD_REF <*image, 8, 224>;
  D.40651 = D.40650 & 8;
  D.40652 = D.40651 == 0;
  D.40653 = (long int) D.40652;
  D.40654 = __builtin_expect (D.40653, 0);
  if (D.40654 != 0) goto <D.40655>; else goto <D.40656>;
  <D.40655>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 11672, "image->dynamic");
  <D.40656>:
  D.40657 = (long unsigned int) token;
  D.40658 = (const void *) D.40657;
  D.40659 = MEM[(struct MonoDynamicImage *)image].vararg_aux_hash;
  sig = monoeg_g_hash_table_lookup (D.40659, D.40658);
  if (sig != 0B) goto <D.40660>; else goto <D.40661>;
  <D.40660>:
  D.40662 = sig;
  return D.40662;
  <D.40661>:
  D.40662 = mono_method_signature (method);
  return D.40662;
}


mono_reflection_lookup_dynamic_token (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  long unsigned int D.40664;
  const void * D.40665;
  struct MonoGHashTable * D.40666;
  void * D.40671;
  struct MonoDynamicImage * assembly;
  struct MonoObject * obj;
  struct MonoClass * klass;

  try
    {
      assembly = image;
      mono_loader_lock ();
      D.40664 = (long unsigned int) token;
      D.40665 = (const void *) D.40664;
      D.40666 = assembly->tokens;
      obj = mono_g_hash_table_lookup (D.40666, D.40665);
      mono_loader_unlock ();
      if (obj == 0B) goto <D.40667>; else goto <D.40668>;
      <D.40667>:
      if (valid_token != 0) goto <D.40669>; else goto <D.40670>;
      <D.40669>:
      monoeg_g_log (0B, 4, "Could not find required dynamic token 0x%08x", token);
      <D.23773>:
      goto <D.23773>;
      <D.40670>:
      D.40671 = 0B;
      return D.40671;
      <D.40668>:
      if (handle_class == 0B) goto <D.40672>; else goto <D.40673>;
      <D.40672>:
      handle_class = &klass;
      <D.40673>:
      D.40671 = resolve_object (image, obj, handle_class, context);
      return D.40671;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


mono_declsec_flags_from_method (struct MonoMethod * method)
{
  short unsigned int D.40676;
  int D.40677;
  int D.40678;
  uint32_t D.40681;
  struct MonoClass * D.40682;
  struct MonoImage * D.40683;

  D.40676 = method->flags;
  D.40677 = (int) D.40676;
  D.40678 = D.40677 & 16384;
  if (D.40678 != 0) goto <D.40679>; else goto <D.40680>;
  <D.40679>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.40682 = method->klass;
    D.40683 = D.40682->image;
    D.40681 = mono_declsec_get_flags (D.40683, idx);
    return D.40681;
  }
  <D.40680>:
  D.40681 = 0;
  return D.40681;
}


mono_declsec_get_flags (struct MonoImage * image, guint32 token)
{
  unsigned int D.40685;
  guint32 D.40688;
  unsigned int D.40689;
  unsigned int D.40691;
  unsigned int D.40694;
  <unnamed-unsigned:24> D.40696;
  int D.40697;
  int index;
  struct MonoTableInfo * t;
  guint32 result;
  guint32 action;
  int i;

  D.40685 = mono_metadata_declsec_from_index (image, token);
  index = (int) D.40685;
  t = &image->tables[14];
  result = 0;
  if (index < 0) goto <D.40686>; else goto <D.40687>;
  <D.40686>:
  D.40688 = 0;
  return D.40688;
  <D.40687>:
  i = index;
  goto <D.24061>;
  <D.24060>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.40689 = cols[1];
        if (D.40689 != token) goto <D.24059>; else goto <D.40690>;
        <D.40690>:
        action = cols[0];
        D.40691 = action + 4294967295;
        if (D.40691 <= 17) goto <D.40692>; else goto <D.40693>;
        <D.40692>:
        D.40694 = declsec_flags_map[action];
        result = D.40694 | result;
        goto <D.40695>;
        <D.40693>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "reflection.c", 12239);
        <D.40695>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.24061>:
  D.40696 = t->rows;
  D.40697 = (int) D.40696;
  if (D.40697 > i) goto <D.24060>; else goto <D.24059>;
  <D.24059>:
  D.40688 = result;
  return D.40688;
}


mono_declsec_flags_from_class (struct MonoClass * klass)
{
  unsigned int D.40701;
  unsigned int D.40702;
  struct MonoClassExt * D.40707;
  unsigned int D.40709;
  unsigned int D.40710;
  struct MonoImage * D.40711;
  unsigned int D.40712;
  uint32_t D.40713;

  D.40701 = klass->flags;
  D.40702 = D.40701 & 262144;
  if (D.40702 != 0) goto <D.40703>; else goto <D.40704>;
  <D.40703>:
  D.40707 = klass->ext;
  if (D.40707 == 0B) goto <D.40705>; else goto <D.40708>;
  <D.40708>:
  D.40707 = klass->ext;
  D.40709 = D.40707->declsec_flags;
  if (D.40709 == 0) goto <D.40705>; else goto <D.40706>;
  <D.40705>:
  {
    guint32 idx;

    D.40710 = klass->type_token;
    idx = D.40710 & 16777215;
    idx = idx << 2;
    idx = idx;
    mono_loader_lock ();
    mono_class_alloc_ext (klass);
    mono_loader_unlock ();
    D.40707 = klass->ext;
    D.40711 = klass->image;
    D.40712 = mono_declsec_get_flags (D.40711, idx);
    D.40707->declsec_flags = D.40712;
  }
  <D.40706>:
  D.40707 = klass->ext;
  D.40713 = D.40707->declsec_flags;
  return D.40713;
  <D.40704>:
  D.40713 = 0;
  return D.40713;
}


mono_declsec_flags_from_assembly (struct MonoAssembly * assembly)
{
  uint32_t D.40715;
  struct MonoImage * D.40716;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.40716 = assembly->image;
  D.40715 = mono_declsec_get_flags (D.40716, idx);
  return D.40715;
}


mono_declsec_get_demands (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.40718;
  struct MonoImage * D.40719;
  unsigned int D.40720;
  unsigned int D.40721;
  MonoBoolean D.40724;
  unsigned char D.40725;
  unsigned char D.40726;
  _Bool D.40727;
  _Bool D.40728;
  _Bool D.40729;
  short unsigned int D.40734;
  int D.40735;
  int D.40736;
  unsigned int D.40739;
  unsigned char D.40744;
  guint32 mask;
  MonoBoolean result;
  guint32 flags;

  mask = 135170;
  result = 0;
  D.40718 = method->klass;
  D.40719 = D.40718->image;
  D.40720 = BIT_FIELD_REF <*D.40719, 32, 3392>;
  D.40721 = D.40720 & 16777215;
  if (D.40721 == 0) goto <D.40722>; else goto <D.40723>;
  <D.40722>:
  D.40724 = 0;
  return D.40724;
  <D.40723>:
  D.40725 = BIT_FIELD_REF <*method, 8, 256>;
  D.40726 = D.40725 & 124;
  D.40727 = D.40726 == 24;
  D.40728 = D.40726 == 28;
  D.40729 = D.40727 | D.40728;
  if (D.40729 != 0) goto <D.40730>; else goto <D.40731>;
  <D.40730>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40732>; else goto <D.40733>;
  <D.40732>:
  D.40724 = 0;
  return D.40724;
  <D.40733>:
  <D.40731>:
  D.40734 = method->flags;
  D.40735 = (int) D.40734;
  D.40736 = D.40735 & 16384;
  if (D.40736 != 0) goto <D.40737>; else goto <D.40738>;
  <D.40737>:
  D.40718 = method->klass;
  mono_class_init (D.40718);
  memset (demands, 0, 48);
  result = mono_declsec_get_method_demands_params (method, demands, 2, 13, 18);
  <D.40738>:
  D.40718 = method->klass;
  flags = mono_declsec_flags_from_class (D.40718);
  D.40739 = flags & mask;
  if (D.40739 != 0) goto <D.40740>; else goto <D.40741>;
  <D.40740>:
  if (result == 0) goto <D.40742>; else goto <D.40743>;
  <D.40742>:
  D.40718 = method->klass;
  mono_class_init (D.40718);
  memset (demands, 0, 48);
  <D.40743>:
  D.40718 = method->klass;
  D.40744 = mono_declsec_get_class_demands_params (D.40718, demands, 2, 13, 18);
  result = D.40744 | result;
  <D.40741>:
  D.40724 = result;
  return D.40724;
}


mono_declsec_get_method_demands_params (struct MonoMethod * method, struct MonoDeclSecurityActions * demands, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  MonoBoolean D.40746;
  struct MonoClass * D.40747;
  struct MonoImage * D.40748;
  guint32 idx;

  idx = mono_method_get_index (method);
  idx = idx << 2;
  idx = idx | 1;
  D.40747 = method->klass;
  D.40748 = D.40747->image;
  D.40746 = fill_actions_from_index (D.40748, idx, demands, id_std, id_noncas, id_choice);
  return D.40746;
}


fill_actions_from_index (struct MonoImage * image, guint32 token, struct MonoDeclSecurityActions * actions, guint32 id_std, guint32 id_noncas, guint32 id_choice)
{
  unsigned int D.40750;
  unsigned int D.40751;
  MonoBoolean D.40754;
  unsigned int D.40755;
  char * D.40758;
  unsigned int D.40761;
  const char * blob.656;
  const char * blob.657;
  char * D.40764;
  unsigned int D.40765;
  char * D.40769;
  const char * blob.658;
  const char * blob.659;
  char * D.40774;
  unsigned int D.40775;
  char * D.40779;
  const char * blob.660;
  const char * blob.661;
  char * D.40784;
  unsigned int D.40785;
  <unnamed-unsigned:24> D.40786;
  int D.40787;
  MonoBoolean result;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int index;
  int i;

  try
    {
      result = 0;
      D.40750 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.40750;
      t = &image->tables[14];
      i = index;
      goto <D.24091>;
      <D.24090>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.40751 = cols[1];
      if (D.40751 != token) goto <D.40752>; else goto <D.40753>;
      <D.40752>:
      D.40754 = result;
      return D.40754;
      <D.40753>:
      D.40755 = cols[0];
      if (D.40755 == id_std) goto <D.40756>; else goto <D.40757>;
      <D.40756>:
      D.40758 = actions->demand.blob;
      if (D.40758 == 0B) goto <D.40759>; else goto <D.40760>;
      <D.40759>:
      {
        const char * blob;

        try
          {
            D.40761 = cols[2];
            blob.656 = mono_metadata_blob_heap (image, D.40761);
            blob = blob.656;
            D.40761 = cols[2];
            actions->demand.index = D.40761;
            blob.657 = blob;
            D.40764 = blob.657 + 2;
            actions->demand.blob = D.40764;
            blob.657 = blob;
            D.40765 = mono_metadata_decode_blob_size (blob.657, &blob);
            actions->demand.size = D.40765;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40760>:
      goto <D.40766>;
      <D.40757>:
      D.40755 = cols[0];
      if (D.40755 == id_noncas) goto <D.40767>; else goto <D.40768>;
      <D.40767>:
      D.40769 = actions->noncasdemand.blob;
      if (D.40769 == 0B) goto <D.40770>; else goto <D.40771>;
      <D.40770>:
      {
        const char * blob;

        try
          {
            D.40761 = cols[2];
            blob.658 = mono_metadata_blob_heap (image, D.40761);
            blob = blob.658;
            D.40761 = cols[2];
            actions->noncasdemand.index = D.40761;
            blob.659 = blob;
            D.40774 = blob.659 + 2;
            actions->noncasdemand.blob = D.40774;
            blob.659 = blob;
            D.40775 = mono_metadata_decode_blob_size (blob.659, &blob);
            actions->noncasdemand.size = D.40775;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40771>:
      goto <D.40776>;
      <D.40768>:
      D.40755 = cols[0];
      if (D.40755 == id_choice) goto <D.40777>; else goto <D.40778>;
      <D.40777>:
      D.40779 = actions->demandchoice.blob;
      if (D.40779 == 0B) goto <D.40780>; else goto <D.40781>;
      <D.40780>:
      {
        const char * blob;

        try
          {
            D.40761 = cols[2];
            blob.660 = mono_metadata_blob_heap (image, D.40761);
            blob = blob.660;
            D.40761 = cols[2];
            actions->demandchoice.index = D.40761;
            blob.661 = blob;
            D.40784 = blob.661 + 2;
            actions->demandchoice.blob = D.40784;
            blob.661 = blob;
            D.40785 = mono_metadata_decode_blob_size (blob.661, &blob);
            actions->demandchoice.size = D.40785;
            result = 1;
          }
        finally
          {
            blob = {CLOBBER};
          }
      }
      <D.40781>:
      <D.40778>:
      <D.40776>:
      <D.40766>:
      i = i + 1;
      <D.24091>:
      D.40786 = t->rows;
      D.40787 = (int) D.40786;
      if (D.40787 > i) goto <D.24090>; else goto <D.24092>;
      <D.24092>:
      D.40754 = result;
      return D.40754;
    }
  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.40790;
  MonoBoolean D.40791;
  struct MonoImage * D.40792;
  guint32 idx;

  D.40790 = klass->type_token;
  idx = D.40790 & 16777215;
  idx = idx << 2;
  idx = idx;
  D.40792 = klass->image;
  D.40791 = fill_actions_from_index (D.40792, idx, demands, id_std, id_noncas, id_choice);
  return D.40791;
}


mono_declsec_get_linkdemands (struct MonoMethod * method, struct MonoDeclSecurityActions * klass, struct MonoDeclSecurityActions * cmethod)
{
  struct MonoClass * D.40794;
  struct MonoImage * D.40795;
  unsigned int D.40796;
  unsigned int D.40797;
  MonoBoolean D.40800;
  unsigned char D.40801;
  unsigned char D.40802;
  _Bool D.40803;
  _Bool D.40804;
  _Bool D.40805;
  short unsigned int D.40810;
  int D.40811;
  int D.40812;
  unsigned int D.40815;
  unsigned char D.40818;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.40794 = method->klass;
  D.40795 = D.40794->image;
  D.40796 = BIT_FIELD_REF <*D.40795, 32, 3392>;
  D.40797 = D.40796 & 16777215;
  if (D.40797 == 0) goto <D.40798>; else goto <D.40799>;
  <D.40798>:
  D.40800 = 0;
  return D.40800;
  <D.40799>:
  D.40801 = BIT_FIELD_REF <*method, 8, 256>;
  D.40802 = D.40801 & 124;
  D.40803 = D.40802 == 24;
  D.40804 = D.40802 == 28;
  D.40805 = D.40803 | D.40804;
  if (D.40805 != 0) goto <D.40806>; else goto <D.40807>;
  <D.40806>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40808>; else goto <D.40809>;
  <D.40808>:
  D.40800 = 0;
  return D.40800;
  <D.40809>:
  <D.40807>:
  memset (cmethod, 0, 48);
  memset (klass, 0, 48);
  D.40810 = method->flags;
  D.40811 = (int) D.40810;
  D.40812 = D.40811 & 16384;
  if (D.40812 != 0) goto <D.40813>; else goto <D.40814>;
  <D.40813>:
  D.40794 = method->klass;
  mono_class_init (D.40794);
  result = mono_declsec_get_method_demands_params (method, cmethod, 6, 14, 16);
  <D.40814>:
  D.40794 = method->klass;
  flags = mono_declsec_flags_from_class (D.40794);
  D.40815 = flags & 40992;
  if (D.40815 != 0) goto <D.40816>; else goto <D.40817>;
  <D.40816>:
  D.40794 = method->klass;
  mono_class_init (D.40794);
  D.40794 = method->klass;
  D.40818 = mono_declsec_get_class_demands_params (D.40794, klass, 6, 14, 16);
  result = D.40818 | result;
  <D.40817>:
  D.40800 = result;
  return D.40800;
}


mono_declsec_get_inheritdemands_class (struct MonoClass * klass, struct MonoDeclSecurityActions * demands)
{
  struct MonoImage * D.40820;
  unsigned int D.40821;
  unsigned int D.40822;
  MonoBoolean D.40825;
  unsigned int D.40826;
  unsigned char D.40829;
  MonoBoolean result;
  guint32 flags;

  result = 0;
  D.40820 = klass->image;
  D.40821 = BIT_FIELD_REF <*D.40820, 32, 3392>;
  D.40822 = D.40821 & 16777215;
  if (D.40822 == 0) goto <D.40823>; else goto <D.40824>;
  <D.40823>:
  D.40825 = 0;
  return D.40825;
  <D.40824>:
  flags = mono_declsec_flags_from_class (klass);
  D.40826 = flags & 81984;
  if (D.40826 != 0) goto <D.40827>; else goto <D.40828>;
  <D.40827>:
  mono_class_init (klass);
  memset (demands, 0, 48);
  D.40829 = mono_declsec_get_class_demands_params (klass, demands, 7, 15, 17);
  result = D.40829 | result;
  <D.40828>:
  D.40825 = result;
  return D.40825;
}


mono_declsec_get_inheritdemands_method (struct MonoMethod * method, struct MonoDeclSecurityActions * demands)
{
  struct MonoClass * D.40831;
  struct MonoImage * D.40832;
  unsigned int D.40833;
  unsigned int D.40834;
  MonoBoolean D.40837;
  unsigned char D.40838;
  unsigned char D.40839;
  _Bool D.40840;
  _Bool D.40841;
  _Bool D.40842;
  short unsigned int D.40847;
  int D.40848;
  int D.40849;

  D.40831 = method->klass;
  D.40832 = D.40831->image;
  D.40833 = BIT_FIELD_REF <*D.40832, 32, 3392>;
  D.40834 = D.40833 & 16777215;
  if (D.40834 == 0) goto <D.40835>; else goto <D.40836>;
  <D.40835>:
  D.40837 = 0;
  return D.40837;
  <D.40836>:
  D.40838 = BIT_FIELD_REF <*method, 8, 256>;
  D.40839 = D.40838 & 124;
  D.40840 = D.40839 == 24;
  D.40841 = D.40839 == 28;
  D.40842 = D.40840 | D.40841;
  if (D.40842 != 0) goto <D.40843>; else goto <D.40844>;
  <D.40843>:
  method = mono_marshal_method_from_wrapper (method);
  if (method == 0B) goto <D.40845>; else goto <D.40846>;
  <D.40845>:
  D.40837 = 0;
  return D.40837;
  <D.40846>:
  <D.40844>:
  D.40847 = method->flags;
  D.40848 = (int) D.40847;
  D.40849 = D.40848 & 16384;
  if (D.40849 != 0) goto <D.40850>; else goto <D.40851>;
  <D.40850>:
  D.40831 = method->klass;
  mono_class_init (D.40831);
  memset (demands, 0, 48);
  D.40837 = mono_declsec_get_method_demands_params (method, demands, 7, 15, 17);
  return D.40837;
  <D.40851>:
  D.40837 = 0;
  return D.40837;
}


mono_declsec_get_method_action (struct MonoMethod * method, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  short unsigned int D.40853;
  int D.40854;
  int D.40855;
  MonoBoolean D.40858;
  struct MonoClass * D.40859;
  struct MonoImage * D.40860;

  D.40853 = method->flags;
  D.40854 = (int) D.40853;
  D.40855 = D.40854 & 16384;
  if (D.40855 != 0) goto <D.40856>; else goto <D.40857>;
  <D.40856>:
  {
    guint32 idx;

    idx = mono_method_get_index (method);
    idx = idx << 2;
    idx = idx | 1;
    D.40859 = method->klass;
    D.40860 = D.40859->image;
    D.40858 = get_declsec_action (D.40860, idx, action, entry);
    return D.40858;
  }
  <D.40857>:
  D.40858 = 0;
  return D.40858;
}


get_declsec_action (struct MonoImage * image, guint32 token, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.40862;
  MonoBoolean D.40865;
  unsigned int D.40866;
  unsigned int D.40869;
  unsigned int D.40872;
  const char * metadata.662;
  const char * metadata.663;
  char * D.40875;
  unsigned int D.40876;
  <unnamed-unsigned:24> D.40877;
  int D.40878;
  guint32 cols[3];
  struct MonoTableInfo * t;
  int i;
  int index;

  try
    {
      D.40862 = mono_metadata_declsec_from_index (image, token);
      index = (int) D.40862;
      if (index == -1) goto <D.40863>; else goto <D.40864>;
      <D.40863>:
      D.40865 = 0;
      return D.40865;
      <D.40864>:
      t = &image->tables[14];
      i = index;
      goto <D.24145>;
      <D.24144>:
      mono_metadata_decode_row (t, i, &cols, 3);
      D.40866 = cols[1];
      if (D.40866 != token) goto <D.40867>; else goto <D.40868>;
      <D.40867>:
      D.40865 = 0;
      return D.40865;
      <D.40868>:
      D.40869 = cols[0];
      if (D.40869 == action) goto <D.40870>; else goto <D.40871>;
      <D.40870>:
      {
        const char * metadata;

        try
          {
            D.40872 = cols[2];
            metadata.662 = mono_metadata_blob_heap (image, D.40872);
            metadata = metadata.662;
            metadata.663 = metadata;
            D.40875 = metadata.663 + 2;
            entry->blob = D.40875;
            metadata.663 = metadata;
            D.40876 = mono_metadata_decode_blob_size (metadata.663, &metadata);
            entry->size = D.40876;
            D.40865 = 1;
            return D.40865;
          }
        finally
          {
            metadata = {CLOBBER};
          }
      }
      <D.40871>:
      i = i + 1;
      <D.24145>:
      D.40877 = t->rows;
      D.40878 = (int) D.40877;
      if (D.40878 > i) goto <D.24144>; else goto <D.24146>;
      <D.24146>:
      D.40865 = 0;
      return D.40865;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_declsec_get_class_action (struct MonoClass * klass, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  unsigned int D.40882;
  unsigned int D.40883;
  unsigned int D.40886;
  MonoBoolean D.40887;
  struct MonoImage * D.40888;
  guint32 flags;

  flags = mono_declsec_flags_from_class (klass);
  D.40882 = declsec_flags_map[action];
  D.40883 = D.40882 & flags;
  if (D.40883 != 0) goto <D.40884>; else goto <D.40885>;
  <D.40884>:
  {
    guint32 idx;

    D.40886 = klass->type_token;
    idx = D.40886 & 16777215;
    idx = idx << 2;
    idx = idx;
    D.40888 = klass->image;
    D.40887 = get_declsec_action (D.40888, idx, action, entry);
    return D.40887;
  }
  <D.40885>:
  D.40887 = 0;
  return D.40887;
}


mono_declsec_get_assembly_action (struct MonoAssembly * assembly, guint32 action, struct MonoDeclSecurityEntry * entry)
{
  MonoBoolean D.40890;
  struct MonoImage * D.40891;
  guint32 idx;

  idx = 1;
  idx = idx << 2;
  idx = idx | 2;
  D.40891 = assembly->image;
  D.40890 = get_declsec_action (D.40891, idx, action, entry);
  return D.40890;
}


mono_reflection_call_is_assignable_to (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * System_Reflection_Emit_TypeBuilder.664;
  struct MonoImage * D.40896;
  struct MonoClass * System_Reflection_Emit_TypeBuilder.665;
  _Bool D.40898;
  long int D.40899;
  long int D.40900;
  struct MonoMethod * method.666;
  struct MonoMethod * method.667;
  _Bool D.40907;
  long int D.40908;
  long int D.40909;
  void * D.40912;
  _Bool D.40913;
  long int D.40914;
  long int D.40915;
  int D.24183;
  int iftmp.668;
  int D.24182;
  void * D.40921;
  struct MonoVTable * D.40922;
  struct MonoClass * D.40923;
  const char[12] * D.40924;
  unsigned char D.40925;
  int D.40926;
  unsigned char D.40927;
  int D.40928;
  _Bool D.40929;
  _Bool D.40930;
  _Bool D.40931;
  const unsigned char * D.40934;
  unsigned char D.40935;
  int D.40936;
  const unsigned char * D.40937;
  unsigned char D.40938;
  int D.40939;
  _Bool D.40940;
  _Bool D.40941;
  const unsigned char * D.40944;
  unsigned char D.40945;
  int D.40946;
  const unsigned char * D.40947;
  unsigned char D.40948;
  int D.40949;
  _Bool D.40950;
  _Bool D.40951;
  const unsigned char * D.40954;
  unsigned char D.40955;
  int D.40956;
  const unsigned char * D.40957;
  unsigned char D.40958;
  int D.40959;
  void * D.40961;
  struct MonoVTable * D.40962;
  struct MonoClass * D.40963;
  const char * D.40964;
  _Bool D.40965;
  long int D.40966;
  long int D.40967;
  struct MonoType * D.40970;
  struct MonoDomain * D.40971;
  struct MonoReflectionType * D.40972;
  void * D.40973;
  struct MonoObject * exc.669;
  gboolean D.40977;
  void * D.40978;
  unsigned char D.40979;
  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.664 = System_Reflection_Emit_TypeBuilder;
      if (System_Reflection_Emit_TypeBuilder.664 == 0B) goto <D.40894>; else goto <D.40895>;
      <D.40894>:
      D.40896 = mono_defaults.corlib;
      System_Reflection_Emit_TypeBuilder.665 = mono_class_from_name (D.40896, "System.Reflection.Emit", "TypeBuilder");
      System_Reflection_Emit_TypeBuilder = System_Reflection_Emit_TypeBuilder.665;
      System_Reflection_Emit_TypeBuilder.664 = System_Reflection_Emit_TypeBuilder;
      D.40898 = System_Reflection_Emit_TypeBuilder.664 == 0B;
      D.40899 = (long int) D.40898;
      D.40900 = __builtin_expect (D.40899, 0);
      if (D.40900 != 0) goto <D.40901>; else goto <D.40902>;
      <D.40901>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12621, "System_Reflection_Emit_TypeBuilder");
      <D.40902>:
      <D.40895>:
      method.666 = method;
      if (method.666 == 0B) goto <D.40904>; else goto <D.40905>;
      <D.40904>:
      System_Reflection_Emit_TypeBuilder.664 = System_Reflection_Emit_TypeBuilder;
      method.667 = mono_class_get_method_from_name (System_Reflection_Emit_TypeBuilder.664, "IsAssignableTo", 1);
      method = method.667;
      method.666 = method;
      D.40907 = method.666 == 0B;
      D.40908 = (long int) D.40907;
      D.40909 = __builtin_expect (D.40908, 0);
      if (D.40909 != 0) goto <D.40910>; else goto <D.40911>;
      <D.40910>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12625, "method");
      <D.40911>:
      <D.40905>:
      D.40912 = mono_class_get_ref_info (klass);
      D.40913 = D.40912 == 0B;
      D.40914 = (long int) D.40913;
      D.40915 = __builtin_expect (D.40914, 0);
      if (D.40915 != 0) goto <D.40916>; else goto <D.40917>;
      <D.40916>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12632, "mono_class_get_ref_info (klass)");
      <D.40917>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.40921 = mono_class_get_ref_info (klass);
          D.40922 = MEM[(struct MonoObject *)D.40921].vtable;
          D.40923 = D.40922->klass;
          __s2 = D.40923->name;
          D.40924 = "TypeBuilder";
          D.40925 = MEM[(const unsigned char *)D.40924];
          D.40926 = (int) D.40925;
          D.40927 = *__s2;
          D.40928 = (int) D.40927;
          __result = D.40926 - D.40928;
          {
            D.40929 = __s2_len != 0;
            D.40930 = __result == 0;
            D.40931 = D.40929 & D.40930;
            if (D.40931 != 0) goto <D.40932>; else goto <D.40933>;
            <D.40932>:
            D.40934 = &MEM[(void *)"TypeBuilder" + 1B];
            D.40935 = *D.40934;
            D.40936 = (int) D.40935;
            D.40937 = __s2 + 1;
            D.40938 = *D.40937;
            D.40939 = (int) D.40938;
            __result = D.40936 - D.40939;
            D.40940 = __s2_len > 1;
            D.40930 = __result == 0;
            D.40941 = D.40940 & D.40930;
            if (D.40941 != 0) goto <D.40942>; else goto <D.40943>;
            <D.40942>:
            D.40944 = &MEM[(void *)"TypeBuilder" + 2B];
            D.40945 = *D.40944;
            D.40946 = (int) D.40945;
            D.40947 = __s2 + 2;
            D.40948 = *D.40947;
            D.40949 = (int) D.40948;
            __result = D.40946 - D.40949;
            D.40950 = __s2_len > 2;
            D.40930 = __result == 0;
            D.40951 = D.40950 & D.40930;
            if (D.40951 != 0) goto <D.40952>; else goto <D.40953>;
            <D.40952>:
            D.40954 = &MEM[(void *)"TypeBuilder" + 3B];
            D.40955 = *D.40954;
            D.40956 = (int) D.40955;
            D.40957 = __s2 + 3;
            D.40958 = *D.40957;
            D.40959 = (int) D.40958;
            __result = D.40956 - D.40959;
            <D.40953>:
            <D.40943>:
            <D.40933>:
          }
          D.24182 = __result;
        }
        iftmp.668 = -D.24182;
        goto <D.40960>;
        <D.40920>:
        D.40961 = mono_class_get_ref_info (klass);
        D.40962 = MEM[(struct MonoObject *)D.40961].vtable;
        D.40963 = D.40962->klass;
        D.40964 = D.40963->name;
        iftmp.668 = __builtin_strcmp (D.40964, "TypeBuilder");
        <D.40960>:
        D.24183 = iftmp.668;
      }
      D.40965 = D.24183 != 0;
      D.40966 = (long int) D.40965;
      D.40967 = __builtin_expect (D.40966, 0);
      if (D.40967 != 0) goto <D.40968>; else goto <D.40969>;
      <D.40968>:
      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.40969>:
      D.40970 = &oklass->byval_arg;
      D.40971 = mono_domain_get ();
      D.40972 = mono_type_get_object (D.40971, D.40970);
      params[0] = D.40972;
      D.40973 = mono_class_get_ref_info (klass);
      method.666 = method;
      res = mono_runtime_invoke (method.666, D.40973, &params, &exc);
      exc.669 = exc;
      if (exc.669 != 0B) goto <D.40975>; else goto <D.40976>;
      <D.40975>:
      D.40977 = 0;
      return D.40977;
      <D.40976>:
      D.40978 = mono_object_unbox (res);
      D.40979 = MEM[(MonoBoolean *)D.40978];
      D.40977 = (gboolean) D.40979;
      return D.40977;
    }
  finally
    {
      exc = {CLOBBER};
      params = {CLOBBER};
    }
}


mono_reflection_type_get_type (struct MonoReflectionType * reftype)
{
  _Bool D.40982;
  long int D.40983;
  long int D.40984;
  struct MonoType * D.40987;

  D.40982 = reftype == 0B;
  D.40983 = (long int) D.40982;
  D.40984 = __builtin_expect (D.40983, 0);
  if (D.40984 != 0) goto <D.40985>; else goto <D.40986>;
  <D.40985>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "reflection.c", 12653, "reftype");
  <D.40986>:
  D.40987 = mono_reflection_type_get_handle (reftype);
  return D.40987;
}


