mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.19276;
  short int D.19277;
  sizetype D.19278;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.19274>; else goto <D.19275>;
  <D.19274>:
  D.19276 = "";
  return D.19276;
  <D.19275>:
  D.19277 = tableidx[table];
  D.19278 = (sizetype) D.19277;
  D.19276 = &tablestr + D.19278;
  return D.19276;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.19280;
  sizetype D.19281;
  int iftmp.1;
  unsigned char D.19283;
  unsigned char D.19284;
  int iftmp.2;
  unsigned char D.19289;
  int iftmp.3;
  unsigned char D.19294;
  _Bool D.19298;
  long int D.19299;
  long int D.19300;
  int iftmp.4;
  <unnamed-unsigned:24> D.19304;
  int D.19305;
  _Bool D.19309;
  long int D.19310;
  long int D.19311;
  int iftmp.5;
  _Bool D.19318;
  long int D.19319;
  long int D.19320;
  int iftmp.6;
  <unnamed-unsigned:24> D.19324;
  int D.19325;
  unsigned int i.7;
  _Bool D.19330;
  long int D.19331;
  long int D.19332;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.19339;
  int D.19340;
  int iftmp.10;
  _Bool D.19349;
  long int D.19350;
  long int D.19351;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.19363;
  int D.19364;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.19383;
  int D.19384;
  int iftmp.16;
  _Bool D.19394;
  long int D.19395;
  long int D.19396;
  int iftmp.17;
  <unnamed-unsigned:24> D.19400;
  int D.19401;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.19414;
  int D.19415;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.19443;
  int D.19444;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.19459;
  _Bool D.19460;
  long int D.19461;
  long int D.19462;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.19486;
  int D.19487;
  int iftmp.32;
  <unnamed-unsigned:24> D.19495;
  int D.19496;
  <unnamed-unsigned:24> D.19497;
  int D.19498;
  <unnamed-unsigned:24> D.19499;
  int D.19500;
  <unnamed-unsigned:24> D.19501;
  int D.19502;
  <unnamed-unsigned:24> D.19503;
  int D.19504;
  <unnamed-unsigned:24> D.19505;
  int D.19506;
  <unnamed-unsigned:24> D.19507;
  int D.19508;
  <unnamed-unsigned:24> D.19509;
  int D.19510;
  <unnamed-unsigned:24> D.19511;
  int D.19512;
  <unnamed-unsigned:24> D.19513;
  int D.19514;
  <unnamed-unsigned:24> D.19515;
  int D.19516;
  int iftmp.33;
  int iftmp.34;
  int iftmp.35;
  int iftmp.36;
  int iftmp.37;
  int iftmp.38;
  int iftmp.39;
  int iftmp.40;
  int iftmp.41;
  int iftmp.42;
  int iftmp.43;
  int D.19562;
  int D.19563;
  unsigned int D.19564;
  sizetype D.19565;
  const unsigned char * D.19566;
  unsigned char D.19567;
  int D.19568;
  unsigned int D.19569;
  unsigned int D.19570;
  int D.19571;
  guint32 bitfield;
  int size;
  int field_size;
  int i;
  int n;
  int code;
  int shift;
  const unsigned char * description;

  bitfield = 0;
  size = 0;
  field_size = 0;
  shift = 0;
  D.19280 = table_description[tableindex];
  D.19281 = (sizetype) D.19280;
  description = &TableSchemas + D.19281;
  i = 0;
  goto <D.17529>;
  <D.17528>:
  switch (code) <default: <D.19561>, case 1: <D.17483>, case 2: <D.17485>, case 3: <D.17486>, case 4: <D.17487>, case 5: <D.17488>, case 6: <D.17489>, case 7: <D.17490>, case 8: <D.17516>, case 9: <D.17517>, case 10: <D.17518>, case 11: <D.17519>, case 12: <D.17520>, case 13: <D.17521>, case 14: <D.17522>, case 15: <D.17523>, case 16: <D.17524>, case 17: <D.17525>, case 18: <D.17526>, case 19: <D.17527>>
  <D.17483>:
  field_size = 4;
  goto <D.17484>;
  <D.17485>:
  field_size = 2;
  goto <D.17484>;
  <D.17486>:
  field_size = 1;
  goto <D.17484>;
  <D.17487>:
  D.19283 = BIT_FIELD_REF <*meta, 8, 232>;
  D.19284 = D.19283 & 4;
  if (D.19284 != 0) goto <D.19285>; else goto <D.19286>;
  <D.19285>:
  iftmp.1 = 4;
  goto <D.19287>;
  <D.19286>:
  iftmp.1 = 2;
  <D.19287>:
  field_size = iftmp.1;
  goto <D.17484>;
  <D.17488>:
  D.19283 = BIT_FIELD_REF <*meta, 8, 232>;
  D.19289 = D.19283 & 1;
  if (D.19289 != 0) goto <D.19290>; else goto <D.19291>;
  <D.19290>:
  iftmp.2 = 4;
  goto <D.19292>;
  <D.19291>:
  iftmp.2 = 2;
  <D.19292>:
  field_size = iftmp.2;
  goto <D.17484>;
  <D.17489>:
  D.19283 = BIT_FIELD_REF <*meta, 8, 232>;
  D.19294 = D.19283 & 2;
  if (D.19294 != 0) goto <D.19295>; else goto <D.19296>;
  <D.19295>:
  iftmp.3 = 4;
  goto <D.19297>;
  <D.19296>:
  iftmp.3 = 2;
  <D.19297>:
  field_size = iftmp.3;
  goto <D.17484>;
  <D.17490>:
  switch (tableindex) <default: <D.17514>, case 2: <D.17511>, case 3: <D.17500>, case 5: <D.17506>, case 6: <D.17503>, case 7: <D.17508>, case 9: <D.17502>, case 15: <D.17494>, case 16: <D.17498>, case 18: <D.17495>, case 19: <D.17496>, case 21: <D.17509>, case 22: <D.17510>, case 24: <D.17505>, case 25: <D.17504>, case 28: <D.17501>, case 29: <D.17499>, case 36: <D.17493>, case 37: <D.17491>, case 39: <D.17497>, case 41: <D.17507>, case 42: <D.17512>, case 44: <D.17513>>
  <D.17491>:
  D.19298 = i != 3;
  D.19299 = (long int) D.19298;
  D.19300 = __builtin_expect (D.19299, 0);
  if (D.19300 != 0) goto <D.19301>; else goto <D.19302>;
  <D.19301>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.19302>:
  D.19304 = meta->tables[35].rows;
  D.19305 = (int) D.19304;
  if (D.19305 <= 65535) goto <D.19306>; else goto <D.19307>;
  <D.19306>:
  iftmp.4 = 2;
  goto <D.19308>;
  <D.19307>:
  iftmp.4 = 4;
  <D.19308>:
  field_size = iftmp.4;
  goto <D.17492>;
  <D.17493>:
  D.19309 = i != 1;
  D.19310 = (long int) D.19309;
  D.19311 = __builtin_expect (D.19310, 0);
  if (D.19311 != 0) goto <D.19312>; else goto <D.19313>;
  <D.19312>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.19313>:
  D.19304 = meta->tables[35].rows;
  D.19305 = (int) D.19304;
  if (D.19305 <= 65535) goto <D.19315>; else goto <D.19316>;
  <D.19315>:
  iftmp.5 = 2;
  goto <D.19317>;
  <D.19316>:
  iftmp.5 = 4;
  <D.19317>:
  field_size = iftmp.5;
  goto <D.17492>;
  <D.17494>:
  D.19318 = i != 2;
  D.19319 = (long int) D.19318;
  D.19320 = __builtin_expect (D.19319, 0);
  if (D.19320 != 0) goto <D.19321>; else goto <D.19322>;
  <D.19321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.19322>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19326>; else goto <D.19327>;
  <D.19326>:
  iftmp.6 = 2;
  goto <D.19328>;
  <D.19327>:
  iftmp.6 = 4;
  <D.19328>:
  field_size = iftmp.6;
  goto <D.17492>;
  <D.17495>:
  i.7 = (unsigned int) i;
  D.19330 = i.7 > 1;
  D.19331 = (long int) D.19330;
  D.19332 = __builtin_expect (D.19331, 0);
  if (D.19332 != 0) goto <D.19333>; else goto <D.19334>;
  <D.19333>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.19334>:
  if (i != 0) goto <D.19336>; else goto <D.19337>;
  <D.19336>:
  D.19339 = meta->tables[20].rows;
  D.19340 = (int) D.19339;
  if (D.19340 <= 65535) goto <D.19341>; else goto <D.19342>;
  <D.19341>:
  iftmp.9 = 2;
  goto <D.19343>;
  <D.19342>:
  iftmp.9 = 4;
  <D.19343>:
  iftmp.8 = iftmp.9;
  goto <D.19344>;
  <D.19337>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19346>; else goto <D.19347>;
  <D.19346>:
  iftmp.10 = 2;
  goto <D.19348>;
  <D.19347>:
  iftmp.10 = 4;
  <D.19348>:
  iftmp.8 = iftmp.10;
  <D.19344>:
  field_size = iftmp.8;
  goto <D.17492>;
  <D.17496>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
  <D.19352>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.19353>:
  D.19339 = meta->tables[20].rows;
  D.19340 = (int) D.19339;
  if (D.19340 <= 65535) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  iftmp.11 = 2;
  goto <D.19357>;
  <D.19356>:
  iftmp.11 = 4;
  <D.19357>:
  field_size = iftmp.11;
  goto <D.17492>;
  <D.17497>:
  D.19309 = i != 1;
  D.19310 = (long int) D.19309;
  D.19311 = __builtin_expect (D.19310, 0);
  if (D.19311 != 0) goto <D.19358>; else goto <D.19359>;
  <D.19358>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.19359>:
  field_size = 4;
  goto <D.17492>;
  <D.17498>:
  D.19309 = i != 1;
  D.19310 = (long int) D.19309;
  D.19311 = __builtin_expect (D.19310, 0);
  if (D.19311 != 0) goto <D.19360>; else goto <D.19361>;
  <D.19360>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.19361>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  if (D.19364 <= 65535) goto <D.19365>; else goto <D.19366>;
  <D.19365>:
  iftmp.12 = 2;
  goto <D.19367>;
  <D.19366>:
  iftmp.12 = 4;
  <D.19367>:
  field_size = iftmp.12;
  goto <D.17492>;
  <D.17499>:
  D.19309 = i != 1;
  D.19310 = (long int) D.19309;
  D.19311 = __builtin_expect (D.19310, 0);
  if (D.19311 != 0) goto <D.19368>; else goto <D.19369>;
  <D.19368>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.19369>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  if (D.19364 <= 65535) goto <D.19371>; else goto <D.19372>;
  <D.19371>:
  iftmp.13 = 2;
  goto <D.19373>;
  <D.19372>:
  iftmp.13 = 4;
  <D.19373>:
  field_size = iftmp.13;
  goto <D.17492>;
  <D.17500>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19374>; else goto <D.19375>;
  <D.19374>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.19375>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  if (D.19364 <= 65535) goto <D.19377>; else goto <D.19378>;
  <D.19377>:
  iftmp.14 = 2;
  goto <D.19379>;
  <D.19378>:
  iftmp.14 = 4;
  <D.19379>:
  field_size = iftmp.14;
  goto <D.17492>;
  <D.17501>:
  D.19298 = i != 3;
  D.19299 = (long int) D.19298;
  D.19300 = __builtin_expect (D.19299, 0);
  if (D.19300 != 0) goto <D.19380>; else goto <D.19381>;
  <D.19380>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.19381>:
  D.19383 = meta->tables[26].rows;
  D.19384 = (int) D.19383;
  if (D.19384 <= 65535) goto <D.19385>; else goto <D.19386>;
  <D.19385>:
  iftmp.15 = 2;
  goto <D.19387>;
  <D.19386>:
  iftmp.15 = 4;
  <D.19387>:
  field_size = iftmp.15;
  goto <D.17492>;
  <D.17502>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19388>; else goto <D.19389>;
  <D.19388>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.19389>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19391>; else goto <D.19392>;
  <D.19391>:
  iftmp.16 = 2;
  goto <D.19393>;
  <D.19392>:
  iftmp.16 = 4;
  <D.19393>:
  field_size = iftmp.16;
  goto <D.17492>;
  <D.17503>:
  D.19394 = i != 5;
  D.19395 = (long int) D.19394;
  D.19396 = __builtin_expect (D.19395, 0);
  if (D.19396 != 0) goto <D.19397>; else goto <D.19398>;
  <D.19397>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.19398>:
  D.19400 = meta->tables[8].rows;
  D.19401 = (int) D.19400;
  if (D.19401 <= 65535) goto <D.19402>; else goto <D.19403>;
  <D.19402>:
  iftmp.17 = 2;
  goto <D.19404>;
  <D.19403>:
  iftmp.17 = 4;
  <D.19404>:
  field_size = iftmp.17;
  goto <D.17492>;
  <D.17504>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19405>; else goto <D.19406>;
  <D.19405>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.19406>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19408>; else goto <D.19409>;
  <D.19408>:
  iftmp.18 = 2;
  goto <D.19410>;
  <D.19409>:
  iftmp.18 = 4;
  <D.19410>:
  field_size = iftmp.18;
  goto <D.17492>;
  <D.17505>:
  D.19309 = i != 1;
  D.19310 = (long int) D.19309;
  D.19311 = __builtin_expect (D.19310, 0);
  if (D.19311 != 0) goto <D.19411>; else goto <D.19412>;
  <D.19411>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.19412>:
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  if (D.19415 <= 65535) goto <D.19416>; else goto <D.19417>;
  <D.19416>:
  iftmp.19 = 2;
  goto <D.19418>;
  <D.19417>:
  iftmp.19 = 4;
  <D.19418>:
  field_size = iftmp.19;
  goto <D.17492>;
  <D.17506>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19419>; else goto <D.19420>;
  <D.19419>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.19420>:
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  if (D.19415 <= 65535) goto <D.19422>; else goto <D.19423>;
  <D.19422>:
  iftmp.20 = 2;
  goto <D.19424>;
  <D.19423>:
  iftmp.20 = 4;
  <D.19424>:
  field_size = iftmp.20;
  goto <D.17492>;
  <D.17507>:
  i.7 = (unsigned int) i;
  D.19330 = i.7 > 1;
  D.19331 = (long int) D.19330;
  D.19332 = __builtin_expect (D.19331, 0);
  if (D.19332 != 0) goto <D.19425>; else goto <D.19426>;
  <D.19425>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.19426>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19428>; else goto <D.19429>;
  <D.19428>:
  iftmp.21 = 2;
  goto <D.19430>;
  <D.19429>:
  iftmp.21 = 4;
  <D.19430>:
  field_size = iftmp.21;
  goto <D.17492>;
  <D.17508>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19431>; else goto <D.19432>;
  <D.19431>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.19432>:
  D.19400 = meta->tables[8].rows;
  D.19401 = (int) D.19400;
  if (D.19401 <= 65535) goto <D.19434>; else goto <D.19435>;
  <D.19434>:
  iftmp.22 = 2;
  goto <D.19436>;
  <D.19435>:
  iftmp.22 = 4;
  <D.19436>:
  field_size = iftmp.22;
  goto <D.17492>;
  <D.17509>:
  i.7 = (unsigned int) i;
  D.19330 = i.7 > 1;
  D.19331 = (long int) D.19330;
  D.19332 = __builtin_expect (D.19331, 0);
  if (D.19332 != 0) goto <D.19437>; else goto <D.19438>;
  <D.19437>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.19438>:
  if (i != 0) goto <D.19440>; else goto <D.19441>;
  <D.19440>:
  D.19443 = meta->tables[23].rows;
  D.19444 = (int) D.19443;
  if (D.19444 <= 65535) goto <D.19445>; else goto <D.19446>;
  <D.19445>:
  iftmp.24 = 2;
  goto <D.19447>;
  <D.19446>:
  iftmp.24 = 4;
  <D.19447>:
  iftmp.23 = iftmp.24;
  goto <D.19448>;
  <D.19441>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  if (D.19325 <= 65535) goto <D.19450>; else goto <D.19451>;
  <D.19450>:
  iftmp.25 = 2;
  goto <D.19452>;
  <D.19451>:
  iftmp.25 = 4;
  <D.19452>:
  iftmp.23 = iftmp.25;
  <D.19448>:
  field_size = iftmp.23;
  goto <D.17492>;
  <D.17510>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19453>; else goto <D.19454>;
  <D.19453>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.19454>:
  D.19443 = meta->tables[23].rows;
  D.19444 = (int) D.19443;
  if (D.19444 <= 65535) goto <D.19456>; else goto <D.19457>;
  <D.19456>:
  iftmp.26 = 2;
  goto <D.19458>;
  <D.19457>:
  iftmp.26 = 4;
  <D.19458>:
  field_size = iftmp.26;
  goto <D.17492>;
  <D.17511>:
  i.7 = (unsigned int) i;
  D.19459 = i.7 + 4294967292;
  D.19460 = D.19459 > 1;
  D.19461 = (long int) D.19460;
  D.19462 = __builtin_expect (D.19461, 0);
  if (D.19462 != 0) goto <D.19463>; else goto <D.19464>;
  <D.19463>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.19464>:
  if (i == 4) goto <D.19466>; else goto <D.19467>;
  <D.19466>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  if (D.19364 <= 65535) goto <D.19469>; else goto <D.19470>;
  <D.19469>:
  iftmp.28 = 2;
  goto <D.19471>;
  <D.19470>:
  iftmp.28 = 4;
  <D.19471>:
  iftmp.27 = iftmp.28;
  goto <D.19472>;
  <D.19467>:
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  if (D.19415 <= 65535) goto <D.19474>; else goto <D.19475>;
  <D.19474>:
  iftmp.29 = 2;
  goto <D.19476>;
  <D.19475>:
  iftmp.29 = 4;
  <D.19476>:
  iftmp.27 = iftmp.29;
  <D.19472>:
  field_size = iftmp.27;
  goto <D.17492>;
  <D.17512>:
  D.19318 = i != 2;
  D.19319 = (long int) D.19318;
  D.19320 = __builtin_expect (D.19319, 0);
  if (D.19320 != 0) goto <D.19477>; else goto <D.19478>;
  <D.19477>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.19478>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  n = MAX_EXPR <D.19325, D.19415>;
  if (n <= 32767) goto <D.19480>; else goto <D.19481>;
  <D.19480>:
  iftmp.30 = 2;
  goto <D.19482>;
  <D.19481>:
  iftmp.30 = 4;
  <D.19482>:
  field_size = iftmp.30;
  goto <D.17492>;
  <D.17513>:
  D.19349 = i != 0;
  D.19350 = (long int) D.19349;
  D.19351 = __builtin_expect (D.19350, 0);
  if (D.19351 != 0) goto <D.19483>; else goto <D.19484>;
  <D.19483>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.19484>:
  D.19486 = meta->tables[42].rows;
  D.19487 = (int) D.19486;
  if (D.19487 <= 65535) goto <D.19488>; else goto <D.19489>;
  <D.19488>:
  iftmp.31 = 2;
  goto <D.19490>;
  <D.19489>:
  iftmp.31 = 4;
  <D.19490>:
  field_size = iftmp.31;
  goto <D.17492>;
  <D.17514>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.17515>:
  goto <D.17515>;
  <D.17492>:
  goto <D.17484>;
  <D.17516>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  D.19400 = meta->tables[8].rows;
  D.19401 = (int) D.19400;
  n = MAX_EXPR <D.19364, D.19401>;
  D.19443 = meta->tables[23].rows;
  D.19444 = (int) D.19443;
  n = MAX_EXPR <D.19444, n>;
  if (n <= 16383) goto <D.19492>; else goto <D.19493>;
  <D.19492>:
  iftmp.32 = 2;
  goto <D.19494>;
  <D.19493>:
  iftmp.32 = 4;
  <D.19494>:
  field_size = iftmp.32;
  goto <D.17484>;
  <D.17517>:
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  n = MAX_EXPR <D.19364, D.19415>;
  D.19495 = meta->tables[1].rows;
  D.19496 = (int) D.19495;
  n = MAX_EXPR <D.19496, n>;
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  n = MAX_EXPR <D.19325, n>;
  D.19400 = meta->tables[8].rows;
  D.19401 = (int) D.19400;
  n = MAX_EXPR <D.19401, n>;
  D.19497 = meta->tables[9].rows;
  D.19498 = (int) D.19497;
  n = MAX_EXPR <D.19498, n>;
  D.19499 = meta->tables[10].rows;
  D.19500 = (int) D.19499;
  n = MAX_EXPR <D.19500, n>;
  D.19501 = meta->tables[0].rows;
  D.19502 = (int) D.19501;
  n = MAX_EXPR <D.19502, n>;
  D.19503 = meta->tables[14].rows;
  D.19504 = (int) D.19503;
  n = MAX_EXPR <D.19504, n>;
  D.19443 = meta->tables[23].rows;
  D.19444 = (int) D.19443;
  n = MAX_EXPR <D.19444, n>;
  D.19339 = meta->tables[20].rows;
  D.19340 = (int) D.19339;
  n = MAX_EXPR <D.19340, n>;
  D.19505 = meta->tables[17].rows;
  D.19506 = (int) D.19505;
  n = MAX_EXPR <D.19506, n>;
  D.19383 = meta->tables[26].rows;
  D.19384 = (int) D.19383;
  n = MAX_EXPR <D.19384, n>;
  D.19507 = meta->tables[27].rows;
  D.19508 = (int) D.19507;
  n = MAX_EXPR <D.19508, n>;
  D.19509 = meta->tables[32].rows;
  D.19510 = (int) D.19509;
  n = MAX_EXPR <D.19510, n>;
  D.19304 = meta->tables[35].rows;
  D.19305 = (int) D.19304;
  n = MAX_EXPR <D.19305, n>;
  D.19511 = meta->tables[38].rows;
  D.19512 = (int) D.19511;
  n = MAX_EXPR <D.19512, n>;
  D.19513 = meta->tables[39].rows;
  D.19514 = (int) D.19513;
  n = MAX_EXPR <D.19514, n>;
  D.19515 = meta->tables[40].rows;
  D.19516 = (int) D.19515;
  n = MAX_EXPR <D.19516, n>;
  if (n <= 2047) goto <D.19518>; else goto <D.19519>;
  <D.19518>:
  iftmp.33 = 2;
  goto <D.19520>;
  <D.19519>:
  iftmp.33 = 4;
  <D.19520>:
  field_size = iftmp.33;
  goto <D.17484>;
  <D.17518>:
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  D.19495 = meta->tables[1].rows;
  D.19496 = (int) D.19495;
  n = MAX_EXPR <D.19325, D.19496>;
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  n = MAX_EXPR <D.19415, n>;
  D.19499 = meta->tables[10].rows;
  D.19500 = (int) D.19499;
  n = MAX_EXPR <D.19500, n>;
  if (n <= 8191) goto <D.19522>; else goto <D.19523>;
  <D.19522>:
  iftmp.34 = 2;
  goto <D.19524>;
  <D.19523>:
  iftmp.34 = 4;
  <D.19524>:
  field_size = iftmp.34;
  goto <D.17484>;
  <D.17519>:
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  n = MAX_EXPR <D.19415, D.19325>;
  D.19509 = meta->tables[32].rows;
  D.19510 = (int) D.19509;
  n = MAX_EXPR <D.19510, n>;
  if (n <= 16383) goto <D.19526>; else goto <D.19527>;
  <D.19526>:
  iftmp.35 = 2;
  goto <D.19528>;
  <D.19527>:
  iftmp.35 = 4;
  <D.19528>:
  field_size = iftmp.35;
  goto <D.17484>;
  <D.17520>:
  D.19304 = meta->tables[35].rows;
  D.19305 = (int) D.19304;
  D.19511 = meta->tables[38].rows;
  D.19512 = (int) D.19511;
  n = MAX_EXPR <D.19305, D.19512>;
  D.19513 = meta->tables[39].rows;
  D.19514 = (int) D.19513;
  n = MAX_EXPR <D.19514, n>;
  if (n <= 16383) goto <D.19530>; else goto <D.19531>;
  <D.19530>:
  iftmp.36 = 2;
  goto <D.19532>;
  <D.19531>:
  iftmp.36 = 4;
  <D.19532>:
  field_size = iftmp.36;
  goto <D.17484>;
  <D.17521>:
  D.19400 = meta->tables[8].rows;
  D.19401 = (int) D.19400;
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  n = MAX_EXPR <D.19401, D.19364>;
  if (n <= 32767) goto <D.19534>; else goto <D.19535>;
  <D.19534>:
  iftmp.37 = 2;
  goto <D.19536>;
  <D.19535>:
  iftmp.37 = 4;
  <D.19536>:
  field_size = iftmp.37;
  goto <D.17484>;
  <D.17522>:
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  D.19363 = meta->tables[4].rows;
  D.19364 = (int) D.19363;
  n = MAX_EXPR <D.19415, D.19364>;
  if (n <= 32767) goto <D.19538>; else goto <D.19539>;
  <D.19538>:
  iftmp.38 = 2;
  goto <D.19540>;
  <D.19539>:
  iftmp.38 = 4;
  <D.19540>:
  field_size = iftmp.38;
  goto <D.17484>;
  <D.17523>:
  D.19495 = meta->tables[1].rows;
  D.19496 = (int) D.19495;
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  n = MAX_EXPR <D.19496, D.19325>;
  D.19507 = meta->tables[27].rows;
  D.19508 = (int) D.19507;
  n = MAX_EXPR <D.19508, n>;
  if (n <= 16383) goto <D.19542>; else goto <D.19543>;
  <D.19542>:
  iftmp.39 = 2;
  goto <D.19544>;
  <D.19543>:
  iftmp.39 = 4;
  <D.19544>:
  field_size = iftmp.39;
  goto <D.17484>;
  <D.17524>:
  D.19495 = meta->tables[1].rows;
  D.19496 = (int) D.19495;
  D.19324 = meta->tables[2].rows;
  D.19325 = (int) D.19324;
  n = MAX_EXPR <D.19496, D.19325>;
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  n = MAX_EXPR <D.19415, n>;
  D.19383 = meta->tables[26].rows;
  D.19384 = (int) D.19383;
  n = MAX_EXPR <D.19384, n>;
  D.19507 = meta->tables[27].rows;
  D.19508 = (int) D.19507;
  n = MAX_EXPR <D.19508, n>;
  if (n <= 8191) goto <D.19546>; else goto <D.19547>;
  <D.19546>:
  iftmp.40 = 2;
  goto <D.19548>;
  <D.19547>:
  iftmp.40 = 4;
  <D.19548>:
  field_size = iftmp.40;
  goto <D.17484>;
  <D.17525>:
  D.19499 = meta->tables[10].rows;
  D.19500 = (int) D.19499;
  D.19414 = meta->tables[6].rows;
  D.19415 = (int) D.19414;
  n = MAX_EXPR <D.19500, D.19415>;
  if (n <= 32767) goto <D.19550>; else goto <D.19551>;
  <D.19550>:
  iftmp.41 = 2;
  goto <D.19552>;
  <D.19551>:
  iftmp.41 = 4;
  <D.19552>:
  field_size = iftmp.41;
  goto <D.17484>;
  <D.17526>:
  D.19339 = meta->tables[20].rows;
  D.19340 = (int) D.19339;
  D.19443 = meta->tables[23].rows;
  D.19444 = (int) D.19443;
  n = MAX_EXPR <D.19340, D.19444>;
  if (n <= 32767) goto <D.19554>; else goto <D.19555>;
  <D.19554>:
  iftmp.42 = 2;
  goto <D.19556>;
  <D.19555>:
  iftmp.42 = 4;
  <D.19556>:
  field_size = iftmp.42;
  goto <D.17484>;
  <D.17527>:
  D.19383 = meta->tables[26].rows;
  D.19384 = (int) D.19383;
  D.19501 = meta->tables[0].rows;
  D.19502 = (int) D.19501;
  n = MAX_EXPR <D.19384, D.19502>;
  D.19304 = meta->tables[35].rows;
  D.19305 = (int) D.19304;
  n = MAX_EXPR <D.19305, n>;
  D.19495 = meta->tables[1].rows;
  D.19496 = (int) D.19495;
  n = MAX_EXPR <D.19496, n>;
  if (n <= 16383) goto <D.19558>; else goto <D.19559>;
  <D.19558>:
  iftmp.43 = 2;
  goto <D.19560>;
  <D.19559>:
  iftmp.43 = 4;
  <D.19560>:
  field_size = iftmp.43;
  goto <D.17484>;
  <D.19561>:
  <D.17484>:
  D.19562 = field_size + -1;
  D.19563 = D.19562 << shift;
  D.19564 = (unsigned int) D.19563;
  bitfield = D.19564 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.17529>:
  D.19565 = (sizetype) i;
  D.19566 = description + D.19565;
  D.19567 = *D.19566;
  code = (int) D.19567;
  if (code != 0) goto <D.17528>; else goto <D.17530>;
  <D.17530>:
  D.19568 = i << 24;
  D.19569 = (unsigned int) D.19568;
  D.19570 = D.19569 | bitfield;
  *result_bitfield = D.19570;
  D.19571 = size;
  return D.19571;
}


mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  unsigned int D.19573;
  unsigned int D.19574;
  guint32 * D.19577;
  int D.19578;
  unsigned char D.19579;
  <unnamed-unsigned:24> D.19580;
  int D.19581;
  unsigned char D.19582;
  int D.19583;
  int D.19584;
  sizetype D.19585;
  int i;
  const char * base;

  base = meta->tables_base;
  i = 0;
  goto <D.17539>;
  <D.17538>:
  {
    struct MonoTableInfo * table;

    table = &meta->tables[i];
    D.19573 = BIT_FIELD_REF <*table, 32, 64>;
    D.19574 = D.19573 & 16777215;
    if (D.19574 == 0) goto <D.19575>; else goto <D.19576>;
    <D.19575>:
    // predicted unlikely by continue predictor.
    goto <D.17537>;
    <D.19576>:
    D.19577 = &table->size_bitfield;
    D.19578 = mono_metadata_compute_size (meta, i, D.19577);
    D.19579 = (unsigned char) D.19578;
    table->row_size = D.19579;
    table->base = base;
    D.19580 = table->rows;
    D.19581 = (int) D.19580;
    D.19582 = table->row_size;
    D.19583 = (int) D.19582;
    D.19584 = D.19581 * D.19583;
    D.19585 = (sizetype) D.19584;
    base = base + D.19585;
  }
  <D.17537>:
  i = i + 1;
  <D.17539>:
  if (i <= 44) goto <D.17538>; else goto <D.17540>;
  <D.17540>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.19589;
  int D.19590;
  const char * D.19591;
  const char * D.19592;
  unsigned char D.19593;
  int D.19594;
  int D.19595;
  int D.19596;
  sizetype D.19597;

  if (idx <= 0) goto <D.19586>; else goto <D.19588>;
  <D.19588>:
  D.19589 = meta->tables[table].rows;
  D.19590 = (int) D.19589;
  if (D.19590 < idx) goto <D.19586>; else goto <D.19587>;
  <D.19586>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.19591 = "";
  return D.19591;
  <D.19587>:
  D.19592 = meta->tables[table].base;
  D.19593 = meta->tables[table].row_size;
  D.19594 = (int) D.19593;
  D.19595 = idx + -1;
  D.19596 = D.19594 * D.19595;
  D.19597 = (sizetype) D.19596;
  D.19591 = D.19592 + D.19597;
  return D.19591;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.19599;
  int token.44;
  int D.19601;
  unsigned int D.19602;
  int D.19603;

  token.44 = (int) token;
  D.19601 = token.44 & 16777215;
  D.19602 = token >> 24;
  D.19603 = (int) D.19602;
  D.19599 = mono_metadata_locate (meta, D.19603, D.19601);
  return D.19599;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19605;
  _Bool D.19606;
  long int D.19607;
  long int D.19608;
  const char * D.19613;
  const char * D.19614;
  sizetype D.19615;

  D.19605 = meta->heap_strings.size;
  D.19606 = D.19605 <= index;
  D.19607 = (long int) D.19606;
  D.19608 = __builtin_expect (D.19607, 0);
  if (D.19608 != 0) goto <D.19609>; else goto <D.19610>;
  <D.19609>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.19610>:
  D.19605 = meta->heap_strings.size;
  if (D.19605 <= index) goto <D.19611>; else goto <D.19612>;
  <D.19611>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.19613 = "";
  return D.19613;
  <D.19612>:
  D.19614 = meta->heap_strings.data;
  D.19615 = (sizetype) index;
  D.19613 = D.19614 + D.19615;
  return D.19613;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19617;
  _Bool D.19618;
  long int D.19619;
  long int D.19620;
  const char * D.19625;
  const char * D.19626;
  sizetype D.19627;

  D.19617 = meta->heap_us.size;
  D.19618 = D.19617 <= index;
  D.19619 = (long int) D.19618;
  D.19620 = __builtin_expect (D.19619, 0);
  if (D.19620 != 0) goto <D.19621>; else goto <D.19622>;
  <D.19621>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.19622>:
  D.19617 = meta->heap_us.size;
  if (D.19617 <= index) goto <D.19623>; else goto <D.19624>;
  <D.19623>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.19625 = "";
  return D.19625;
  <D.19624>:
  D.19626 = meta->heap_us.data;
  D.19627 = (sizetype) index;
  D.19625 = D.19626 + D.19627;
  return D.19625;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19629;
  _Bool D.19630;
  long int D.19631;
  long int D.19632;
  const char * D.19637;
  const char * D.19638;
  sizetype D.19639;

  D.19629 = meta->heap_blob.size;
  D.19630 = D.19629 <= index;
  D.19631 = (long int) D.19630;
  D.19632 = __builtin_expect (D.19631, 0);
  if (D.19632 != 0) goto <D.19633>; else goto <D.19634>;
  <D.19633>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.19634>:
  D.19629 = meta->heap_blob.size;
  if (D.19629 <= index) goto <D.19635>; else goto <D.19636>;
  <D.19635>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.19637 = "";
  return D.19637;
  <D.19636>:
  D.19638 = meta->heap_blob.data;
  D.19639 = (sizetype) index;
  D.19637 = D.19638 + D.19639;
  return D.19637;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19641;
  const char * D.19644;
  const char * D.19645;
  sizetype D.19646;

  index = index + 4294967295;
  index = index * 16;
  D.19641 = meta->heap_guid.size;
  if (D.19641 <= index) goto <D.19642>; else goto <D.19643>;
  <D.19642>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 933, "index < meta->heap_guid.size");
  D.19644 = "";
  return D.19644;
  <D.19643>:
  D.19645 = meta->heap_guid.data;
  D.19646 = (sizetype) index;
  D.19644 = D.19645 + D.19646;
  return D.19644;
}


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.19648;
  <unnamed-unsigned:24> D.19649;
  int D.19650;
  _Bool D.19651;
  long int D.19652;
  long int D.19653;
  _Bool D.19656;
  long int D.19657;
  long int D.19658;
  const char * D.19661;
  unsigned char D.19662;
  int D.19663;
  int D.19664;
  sizetype D.19665;
  _Bool D.19666;
  long int D.19667;
  long int D.19668;
  int D.19671;
  unsigned int D.19672;
  unsigned int D.19673;
  unsigned int D.19674;
  long unsigned int D.19675;
  long unsigned int D.19676;
  guint32 * D.19677;
  char D.19678;
  unsigned int D.19679;
  short unsigned int D.19680;
  unsigned int D.19681;
  unsigned int D.19682;
  sizetype D.19683;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.19648 = bitfield >> 24;
  count = (int) D.19648;
  D.19649 = t->rows;
  D.19650 = (int) D.19649;
  D.19651 = D.19650 <= idx;
  D.19652 = (long int) D.19651;
  D.19653 = __builtin_expect (D.19652, 0);
  if (D.19653 != 0) goto <D.19654>; else goto <D.19655>;
  <D.19654>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.19655>:
  D.19656 = idx < 0;
  D.19657 = (long int) D.19656;
  D.19658 = __builtin_expect (D.19657, 0);
  if (D.19658 != 0) goto <D.19659>; else goto <D.19660>;
  <D.19659>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.19660>:
  D.19661 = t->base;
  D.19662 = t->row_size;
  D.19663 = (int) D.19662;
  D.19664 = D.19663 * idx;
  D.19665 = (sizetype) D.19664;
  data = D.19661 + D.19665;
  D.19666 = res_size != count;
  D.19667 = (long int) D.19666;
  D.19668 = __builtin_expect (D.19667, 0);
  if (D.19668 != 0) goto <D.19669>; else goto <D.19670>;
  <D.19669>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.19670>:
  i = 0;
  goto <D.17586>;
  <D.17585>:
  {
    int n;

    D.19671 = i * 2;
    D.19672 = bitfield >> D.19671;
    D.19673 = D.19672 & 3;
    D.19674 = D.19673 + 1;
    n = (int) D.19674;
    switch (n) <default: <D.17584>, case 1: <D.17580>, case 2: <D.17582>, case 4: <D.17583>>
    <D.17580>:
    D.19675 = (long unsigned int) i;
    D.19676 = D.19675 * 4;
    D.19677 = res + D.19676;
    D.19678 = *data;
    D.19679 = (unsigned int) D.19678;
    *D.19677 = D.19679;
    goto <D.17581>;
    <D.17582>:
    D.19675 = (long unsigned int) i;
    D.19676 = D.19675 * 4;
    D.19677 = res + D.19676;
    D.19680 = MEM[(const guint16 *)data];
    D.19681 = (unsigned int) D.19680;
    *D.19677 = D.19681;
    goto <D.17581>;
    <D.17583>:
    D.19675 = (long unsigned int) i;
    D.19676 = D.19675 * 4;
    D.19677 = res + D.19676;
    D.19682 = MEM[(const guint32 *)data];
    *D.19677 = D.19682;
    goto <D.17581>;
    <D.17584>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.17581>:
    D.19683 = (sizetype) n;
    data = data + D.19683;
  }
  i = i + 1;
  <D.17586>:
  if (i < count) goto <D.17585>; else goto <D.17587>;
  <D.17587>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.19684;
  int D.19685;
  _Bool D.19686;
  long int D.19687;
  long int D.19688;
  unsigned int D.19691;
  _Bool D.19692;
  long int D.19693;
  long int D.19694;
  const char * D.19697;
  unsigned char D.19698;
  int D.19699;
  int D.19700;
  sizetype D.19701;
  unsigned int D.19702;
  unsigned int D.19703;
  sizetype D.19704;
  int D.19705;
  int D.19706;
  unsigned int D.19707;
  unsigned int D.19708;
  unsigned int D.19709;
  unsigned int i.45;
  uint32_t D.19711;
  char D.19712;
  short unsigned int D.19713;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.19684 = t->rows;
  D.19685 = (int) D.19684;
  D.19686 = D.19685 <= idx;
  D.19687 = (long int) D.19686;
  D.19688 = __builtin_expect (D.19687, 0);
  if (D.19688 != 0) goto <D.19689>; else goto <D.19690>;
  <D.19689>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.19690>:
  D.19691 = bitfield >> 24;
  D.19692 = D.19691 <= col;
  D.19693 = (long int) D.19692;
  D.19694 = __builtin_expect (D.19693, 0);
  if (D.19694 != 0) goto <D.19695>; else goto <D.19696>;
  <D.19695>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.19696>:
  D.19697 = t->base;
  D.19698 = t->row_size;
  D.19699 = (int) D.19698;
  D.19700 = D.19699 * idx;
  D.19701 = (sizetype) D.19700;
  data = D.19697 + D.19701;
  D.19702 = bitfield & 3;
  D.19703 = D.19702 + 1;
  n = (int) D.19703;
  i = 0;
  goto <D.17598>;
  <D.17597>:
  D.19704 = (sizetype) n;
  data = data + D.19704;
  D.19705 = i + 1;
  D.19706 = D.19705 * 2;
  D.19707 = bitfield >> D.19706;
  D.19708 = D.19707 & 3;
  D.19709 = D.19708 + 1;
  n = (int) D.19709;
  i = i + 1;
  <D.17598>:
  i.45 = (unsigned int) i;
  if (i.45 < col) goto <D.17597>; else goto <D.17599>;
  <D.17599>:
  switch (n) <default: <D.17603>, case 1: <D.17600>, case 2: <D.17601>, case 4: <D.17602>>
  <D.17600>:
  D.19712 = *data;
  D.19711 = (uint32_t) D.19712;
  return D.19711;
  <D.17601>:
  D.19713 = MEM[(const guint16 *)data];
  D.19711 = (uint32_t) D.19713;
  return D.19711;
  <D.17602>:
  D.19711 = MEM[(const guint32 *)data];
  return D.19711;
  <D.17603>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.19711 = 0;
  return D.19711;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.19715;
  signed char D.19716;
  unsigned int D.19719;
  int D.19721;
  int D.19722;
  int D.19725;
  int D.19726;
  const unsigned char * D.19727;
  unsigned char D.19728;
  int D.19729;
  int D.19730;
  int D.19732;
  int D.19733;
  int D.19734;
  int D.19735;
  const unsigned char * D.19736;
  unsigned char D.19737;
  int D.19738;
  int D.19739;
  int D.19740;
  const unsigned char * D.19741;
  unsigned char D.19742;
  int D.19743;
  int D.19744;
  uint32_t D.19747;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.19715 = *ptr;
  D.19716 = (signed char) D.19715;
  if (D.19716 >= 0) goto <D.19717>; else goto <D.19718>;
  <D.19717>:
  D.19715 = *ptr;
  D.19719 = (unsigned int) D.19715;
  size = D.19719 & 127;
  ptr = ptr + 1;
  goto <D.19720>;
  <D.19718>:
  D.19715 = *ptr;
  D.19721 = (int) D.19715;
  D.19722 = D.19721 & 64;
  if (D.19722 == 0) goto <D.19723>; else goto <D.19724>;
  <D.19723>:
  D.19715 = *ptr;
  D.19721 = (int) D.19715;
  D.19725 = D.19721 & 63;
  D.19726 = D.19725 << 8;
  D.19727 = ptr + 1;
  D.19728 = *D.19727;
  D.19729 = (int) D.19728;
  D.19730 = D.19726 + D.19729;
  size = (guint32) D.19730;
  ptr = ptr + 2;
  goto <D.19731>;
  <D.19724>:
  D.19715 = *ptr;
  D.19721 = (int) D.19715;
  D.19732 = D.19721 & 31;
  D.19733 = D.19732 << 24;
  D.19727 = ptr + 1;
  D.19728 = *D.19727;
  D.19729 = (int) D.19728;
  D.19734 = D.19729 << 16;
  D.19735 = D.19733 + D.19734;
  D.19736 = ptr + 2;
  D.19737 = *D.19736;
  D.19738 = (int) D.19737;
  D.19739 = D.19738 << 8;
  D.19740 = D.19735 + D.19739;
  D.19741 = ptr + 3;
  D.19742 = *D.19741;
  D.19743 = (int) D.19742;
  D.19744 = D.19740 + D.19743;
  size = (guint32) D.19744;
  ptr = ptr + 4;
  <D.19731>:
  <D.19720>:
  if (rptr != 0B) goto <D.19745>; else goto <D.19746>;
  <D.19745>:
  *rptr = ptr;
  <D.19746>:
  D.19747 = size;
  return D.19747;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.46;
  int D.19753;
  int D.19754;
  int D.19757;
  int D.19758;
  const unsigned char * D.19759;
  unsigned char D.19760;
  int D.19761;
  int D.19762;
  int D.19764;
  int D.19765;
  int D.19766;
  int D.19767;
  const unsigned char * D.19768;
  unsigned char D.19769;
  int D.19770;
  int D.19771;
  int D.19772;
  const unsigned char * D.19773;
  unsigned char D.19774;
  int D.19775;
  int D.19776;
  uint32_t D.19779;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.46 = (signed char) b;
  if (b.46 >= 0) goto <D.19750>; else goto <D.19751>;
  <D.19750>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.19752>;
  <D.19751>:
  D.19753 = (int) b;
  D.19754 = D.19753 & 64;
  if (D.19754 == 0) goto <D.19755>; else goto <D.19756>;
  <D.19755>:
  D.19753 = (int) b;
  D.19757 = D.19753 & 63;
  D.19758 = D.19757 << 8;
  D.19759 = ptr + 1;
  D.19760 = *D.19759;
  D.19761 = (int) D.19760;
  D.19762 = D.19758 | D.19761;
  len = (guint32) D.19762;
  ptr = ptr + 2;
  goto <D.19763>;
  <D.19756>:
  D.19753 = (int) b;
  D.19764 = D.19753 & 31;
  D.19765 = D.19764 << 24;
  D.19759 = ptr + 1;
  D.19760 = *D.19759;
  D.19761 = (int) D.19760;
  D.19766 = D.19761 << 16;
  D.19767 = D.19765 | D.19766;
  D.19768 = ptr + 2;
  D.19769 = *D.19768;
  D.19770 = (int) D.19769;
  D.19771 = D.19770 << 8;
  D.19772 = D.19767 | D.19771;
  D.19773 = ptr + 3;
  D.19774 = *D.19773;
  D.19775 = (int) D.19774;
  D.19776 = D.19772 | D.19775;
  len = (guint32) D.19776;
  ptr = ptr + 4;
  <D.19763>:
  <D.19752>:
  if (rptr != 0B) goto <D.19777>; else goto <D.19778>;
  <D.19777>:
  *rptr = ptr;
  <D.19778>:
  D.19779 = len;
  return D.19779;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.19781;
  unsigned int D.19782;
  int32_t D.19785;
  _Bool D.19792;
  long int D.19793;
  long int D.19794;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.19781 = uval >> 1;
  ival = (gint32) D.19781;
  D.19782 = uval & 1;
  if (D.19782 == 0) goto <D.19783>; else goto <D.19784>;
  <D.19783>:
  D.19785 = ival;
  return D.19785;
  <D.19784>:
  if (ival <= 63) goto <D.19786>; else goto <D.19787>;
  <D.19786>:
  D.19785 = ival + -64;
  return D.19785;
  <D.19787>:
  if (ival <= 8191) goto <D.19788>; else goto <D.19789>;
  <D.19788>:
  D.19785 = ival + -8192;
  return D.19785;
  <D.19789>:
  if (ival <= 268435455) goto <D.19790>; else goto <D.19791>;
  <D.19790>:
  D.19785 = ival + -268435456;
  return D.19785;
  <D.19791>:
  D.19792 = ival > 536870911;
  D.19793 = (long int) D.19792;
  D.19794 = __builtin_expect (D.19793, 0);
  if (D.19794 != 0) goto <D.19795>; else goto <D.19796>;
  <D.19795>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1121, "ival < 0x20000000");
  <D.19796>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.19785 = ival + -536870912;
  return D.19785;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  unsigned char D.19798;
  unsigned char D.19799;
  uint32_t D.19802;
  unsigned int D.19803;
  unsigned int D.19804;
  unsigned int D.19807;
  int D.19808;
  struct MonoTableInfo * D.19809;
  unsigned int D.19810;
  unsigned int D.19811;
  struct MonoTableInfo * D.19814;
  unsigned int D.19815;
  unsigned int D.19816;
  struct MonoTableInfo * D.19819;
  unsigned int D.19820;
  unsigned int D.19821;
  struct MonoTableInfo * D.19824;
  unsigned int D.19825;
  unsigned int D.19826;
  struct MonoTableInfo * D.19829;

  D.19798 = BIT_FIELD_REF <*image, 8, 224>;
  D.19799 = D.19798 & 32;
  if (D.19799 == 0) goto <D.19800>; else goto <D.19801>;
  <D.19800>:
  D.19802 = idx;
  return D.19802;
  <D.19801>:
  switch (table) <default: <D.17633>, case 4: <D.17629>, case 6: <D.17628>, case 8: <D.17632>, case 20: <D.17630>, case 23: <D.17631>>
  <D.17628>:
  D.19803 = BIT_FIELD_REF <*image, 32, 2240>;
  D.19804 = D.19803 & 16777215;
  if (D.19804 != 0) goto <D.19805>; else goto <D.19806>;
  <D.19805>:
  D.19807 = idx + 4294967295;
  D.19808 = (int) D.19807;
  D.19809 = &image->tables[5];
  D.19802 = mono_metadata_decode_row_col (D.19809, D.19808, 0);
  return D.19802;
  <D.19806>:
  D.19802 = idx;
  return D.19802;
  <D.17629>:
  D.19810 = BIT_FIELD_REF <*image, 32, 1984>;
  D.19811 = D.19810 & 16777215;
  if (D.19811 != 0) goto <D.19812>; else goto <D.19813>;
  <D.19812>:
  D.19807 = idx + 4294967295;
  D.19808 = (int) D.19807;
  D.19814 = &image->tables[3];
  D.19802 = mono_metadata_decode_row_col (D.19814, D.19808, 0);
  return D.19802;
  <D.19813>:
  D.19802 = idx;
  return D.19802;
  <D.17630>:
  D.19815 = BIT_FIELD_REF <*image, 32, 4032>;
  D.19816 = D.19815 & 16777215;
  if (D.19816 != 0) goto <D.19817>; else goto <D.19818>;
  <D.19817>:
  D.19807 = idx + 4294967295;
  D.19808 = (int) D.19807;
  D.19819 = &image->tables[19];
  D.19802 = mono_metadata_decode_row_col (D.19819, D.19808, 0);
  return D.19802;
  <D.19818>:
  D.19802 = idx;
  return D.19802;
  <D.17631>:
  D.19820 = BIT_FIELD_REF <*image, 32, 4416>;
  D.19821 = D.19820 & 16777215;
  if (D.19821 != 0) goto <D.19822>; else goto <D.19823>;
  <D.19822>:
  D.19807 = idx + 4294967295;
  D.19808 = (int) D.19807;
  D.19824 = &image->tables[22];
  D.19802 = mono_metadata_decode_row_col (D.19824, D.19808, 0);
  return D.19802;
  <D.19823>:
  D.19802 = idx;
  return D.19802;
  <D.17632>:
  D.19825 = BIT_FIELD_REF <*image, 32, 2496>;
  D.19826 = D.19825 & 16777215;
  if (D.19826 != 0) goto <D.19827>; else goto <D.19828>;
  <D.19827>:
  D.19807 = idx + 4294967295;
  D.19808 = (int) D.19807;
  D.19829 = &image->tables[7];
  D.19802 = mono_metadata_decode_row_col (D.19829, D.19808, 0);
  return D.19802;
  <D.19828>:
  D.19802 = idx;
  return D.19802;
  <D.17633>:
  D.19802 = idx;
  return D.19802;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  unsigned char D.19831;
  unsigned char D.19832;
  int D.19835;
  unsigned int D.19836;
  unsigned int D.19837;
  unsigned int D.19838;
  struct MonoTableInfo * D.19839;

  D.19831 = BIT_FIELD_REF <*image, 8, 224>;
  D.19832 = D.19831 & 32;
  if (D.19832 != 0) goto <D.19833>; else goto <D.19834>;
  <D.19833>:
  D.19835 = idx + 1;
  D.19836 = (unsigned int) D.19835;
  D.19837 = mono_metadata_translate_token_index (image, table, D.19836);
  D.19838 = D.19837 + 4294967295;
  idx = (int) D.19838;
  <D.19834>:
  D.19839 = &image->tables[table];
  mono_metadata_decode_row (D.19839, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  unsigned char D.19840;
  unsigned char D.19841;
  int D.19844;
  unsigned int D.19845;
  unsigned int D.19846;
  unsigned int D.19847;
  uint32_t D.19848;
  struct MonoTableInfo * D.19849;

  D.19840 = BIT_FIELD_REF <*image, 8, 224>;
  D.19841 = D.19840 & 32;
  if (D.19841 != 0) goto <D.19842>; else goto <D.19843>;
  <D.19842>:
  D.19844 = idx + 1;
  D.19845 = (unsigned int) D.19844;
  D.19846 = mono_metadata_translate_token_index (image, table, D.19845);
  D.19847 = D.19846 + 4294967295;
  idx = (int) D.19847;
  <D.19843>:
  D.19849 = &image->tables[table];
  D.19848 = mono_metadata_decode_row_col (D.19849, idx, col);
  return D.19848;
}


mono_metadata_parse_typedef_or_ref (struct MonoImage * m, const char * ptr, const char * * rptr)
{
  const char * ptr.47;
  uint32_t D.19854;
  guint32 token;

  ptr.47 = ptr;
  token = mono_metadata_decode_value (ptr.47, &ptr);
  if (rptr != 0B) goto <D.19852>; else goto <D.19853>;
  <D.19852>:
  ptr.47 = ptr;
  *rptr = ptr.47;
  <D.19853>:
  D.19854 = mono_metadata_token_from_dor (token);
  return D.19854;
}


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.19856;
  unsigned char D.19857;
  unsigned char D.19858;
  _Bool D.19863;
  const char * D.19864;
  unsigned int D.19865;
  <unnamed-unsigned:31> D.19866;
  int D.19867;
  struct MonoCustomMod local;

  try
    {
      D.19856 = *ptr;
      D.19857 = (unsigned char) D.19856;
      D.19858 = D.19857 + 225;
      if (D.19858 <= 1) goto <D.19859>; else goto <D.19860>;
      <D.19859>:
      if (dest == 0B) goto <D.19861>; else goto <D.19862>;
      <D.19861>:
      dest = &local;
      <D.19862>:
      D.19856 = *ptr;
      D.19863 = D.19856 == 31;
      dest->required = D.19863;
      D.19864 = ptr + 1;
      D.19865 = mono_metadata_parse_typedef_or_ref (m, D.19864, rptr);
      D.19866 = (<unnamed-unsigned:31>) D.19865;
      dest->token = D.19866;
      D.19867 = 1;
      return D.19867;
      <D.19860>:
      D.19867 = 0;
      return D.19867;
    }
  finally
    {
      local = {CLOBBER};
    }
}


mono_metadata_parse_array_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  struct MonoArrayType * D.19870;

  D.19870 = mono_metadata_parse_array_internal (m, container, 0, ptr, rptr);
  return D.19870;
}


mono_metadata_parse_array_internal (struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  void * iftmp.48;
  const char * ptr.49;
  struct MonoArrayType * D.19879;
  struct MonoClass * D.19880;
  unsigned int D.19881;
  unsigned char D.19882;
  unsigned int D.19883;
  unsigned char D.19884;
  unsigned char D.19885;
  void * iftmp.50;
  long unsigned int D.19891;
  long unsigned int D.19892;
  unsigned int D.19894;
  unsigned int D.19895;
  int * D.19896;
  long unsigned int D.19897;
  long unsigned int D.19898;
  int * D.19899;
  unsigned int D.19900;
  int D.19901;
  int D.19902;
  unsigned int D.19903;
  unsigned char D.19904;
  unsigned char D.19905;
  void * iftmp.51;
  long unsigned int D.19911;
  long unsigned int D.19912;
  unsigned int D.19914;
  unsigned int D.19915;
  int * D.19916;
  int * D.19917;
  int D.19918;
  int D.19919;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.19873>; else goto <D.19874>;
  <D.19873>:
  iftmp.48 = monoeg_malloc0 (32);
  goto <D.19875>;
  <D.19874>:
  iftmp.48 = mono_image_alloc0 (m, 32);
  <D.19875>:
  array = iftmp.48;
  ptr.49 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.49, &ptr);
  if (etype == 0B) goto <D.19877>; else goto <D.19878>;
  <D.19877>:
  D.19879 = 0B;
  return D.19879;
  <D.19878>:
  D.19880 = mono_class_from_mono_type (etype);
  array->eklass = D.19880;
  ptr.49 = ptr;
  D.19881 = mono_metadata_decode_value (ptr.49, &ptr);
  D.19882 = (unsigned char) D.19881;
  array->rank = D.19882;
  ptr.49 = ptr;
  D.19883 = mono_metadata_decode_value (ptr.49, &ptr);
  D.19884 = (unsigned char) D.19883;
  array->numsizes = D.19884;
  D.19885 = array->numsizes;
  if (D.19885 != 0) goto <D.19886>; else goto <D.19887>;
  <D.19886>:
  if (transient != 0) goto <D.19889>; else goto <D.19890>;
  <D.19889>:
  D.19885 = array->numsizes;
  D.19891 = (long unsigned int) D.19885;
  D.19892 = D.19891 * 4;
  iftmp.50 = monoeg_malloc0 (D.19892);
  goto <D.19893>;
  <D.19890>:
  D.19885 = array->numsizes;
  D.19894 = (unsigned int) D.19885;
  D.19895 = D.19894 * 4;
  iftmp.50 = mono_image_alloc0 (m, D.19895);
  <D.19893>:
  array->sizes = iftmp.50;
  <D.19887>:
  i = 0;
  goto <D.17671>;
  <D.17670>:
  D.19896 = array->sizes;
  D.19897 = (long unsigned int) i;
  D.19898 = D.19897 * 4;
  D.19899 = D.19896 + D.19898;
  ptr.49 = ptr;
  D.19900 = mono_metadata_decode_value (ptr.49, &ptr);
  D.19901 = (int) D.19900;
  *D.19899 = D.19901;
  i = i + 1;
  <D.17671>:
  D.19885 = array->numsizes;
  D.19902 = (int) D.19885;
  if (D.19902 > i) goto <D.17670>; else goto <D.17672>;
  <D.17672>:
  ptr.49 = ptr;
  D.19903 = mono_metadata_decode_value (ptr.49, &ptr);
  D.19904 = (unsigned char) D.19903;
  array->numlobounds = D.19904;
  D.19905 = array->numlobounds;
  if (D.19905 != 0) goto <D.19906>; else goto <D.19907>;
  <D.19906>:
  if (transient != 0) goto <D.19909>; else goto <D.19910>;
  <D.19909>:
  D.19905 = array->numlobounds;
  D.19911 = (long unsigned int) D.19905;
  D.19912 = D.19911 * 4;
  iftmp.51 = monoeg_malloc0 (D.19912);
  goto <D.19913>;
  <D.19910>:
  D.19905 = array->numlobounds;
  D.19914 = (unsigned int) D.19905;
  D.19915 = D.19914 * 4;
  iftmp.51 = mono_image_alloc0 (m, D.19915);
  <D.19913>:
  array->lobounds = iftmp.51;
  <D.19907>:
  i = 0;
  goto <D.17674>;
  <D.17673>:
  D.19916 = array->lobounds;
  D.19897 = (long unsigned int) i;
  D.19898 = D.19897 * 4;
  D.19917 = D.19916 + D.19898;
  ptr.49 = ptr;
  D.19918 = mono_metadata_decode_signed_value (ptr.49, &ptr);
  *D.19917 = D.19918;
  i = i + 1;
  <D.17674>:
  D.19905 = array->numlobounds;
  D.19919 = (int) D.19905;
  if (D.19919 > i) goto <D.17673>; else goto <D.17675>;
  <D.17675>:
  if (rptr != 0B) goto <D.19920>; else goto <D.19921>;
  <D.19920>:
  ptr.49 = ptr;
  *rptr = ptr.49;
  <D.19921>:
  D.19879 = array;
  return D.19879;
}


mono_metadata_parse_array (struct MonoImage * m, const char * ptr, const char * * rptr)
{
  struct MonoArrayType * D.19923;

  D.19923 = mono_metadata_parse_array_full (m, 0B, ptr, rptr);
  return D.19923;
}


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.19925;
  int * D.19926;

  D.19925 = array->sizes;
  monoeg_g_free (D.19925);
  D.19926 = array->lobounds;
  monoeg_g_free (D.19926);
  monoeg_g_free (array);
}


mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.19927;
  unsigned int D.19928;
  <unnamed-unsigned:22> D.19929;
  int D.19930;
  guint D.19931;
  <unnamed-unsigned:1> D.19932;
  int D.19933;
  int D.19934;
  unsigned int D.19935;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.17714>;
  <D.17713>:
  hash = hash * 13;
  D.19927 = ginst->type_argv[i];
  D.19928 = mono_metadata_type_hash (D.19927);
  hash = D.19928 + hash;
  i = i + 1;
  <D.17714>:
  D.19929 = ginst->type_argc;
  D.19930 = (int) D.19929;
  if (D.19930 > i) goto <D.17713>; else goto <D.17715>;
  <D.17715>:
  D.19932 = ginst->is_open;
  D.19933 = (int) D.19932;
  D.19934 = D.19933 << 8;
  D.19935 = (unsigned int) D.19934;
  D.19931 = D.19935 ^ hash;
  return D.19931;
}


mono_metadata_generic_inst_equal (const void * ka, const void * kb)
{
  gboolean D.19937;
  const struct MonoGenericInst * a;
  const struct MonoGenericInst * b;

  a = ka;
  b = kb;
  D.19937 = mono_generic_inst_equal_full (a, b, 0);
  return D.19937;
}


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.19939;
  unsigned int D.19942;
  gboolean D.19947;
  unsigned char D.19952;
  unsigned char D.19953;
  unsigned char D.19954;
  unsigned char D.19955;
  unsigned int D.19957;
  unsigned int D.19958;
  unsigned int D.19959;
  unsigned int D.19960;
  struct MonoType * D.19961;
  struct MonoType * D.19962;
  int D.19963;
  <unnamed-unsigned:22> D.19966;
  int D.19967;
  int i;

  D.19939 = a->id;
  if (D.19939 != 0) goto <D.19940>; else goto <D.19941>;
  <D.19940>:
  D.19942 = b->id;
  if (D.19942 != 0) goto <D.19943>; else goto <D.19944>;
  <D.19943>:
  D.19939 = a->id;
  D.19942 = b->id;
  if (D.19939 == D.19942) goto <D.19945>; else goto <D.19946>;
  <D.19945>:
  D.19947 = 1;
  return D.19947;
  <D.19946>:
  if (signature_only == 0) goto <D.19948>; else goto <D.19949>;
  <D.19948>:
  D.19947 = 0;
  return D.19947;
  <D.19949>:
  <D.19944>:
  <D.19941>:
  D.19952 = BIT_FIELD_REF <*a, 8, 48>;
  D.19953 = BIT_FIELD_REF <*b, 8, 48>;
  D.19954 = D.19952 ^ D.19953;
  D.19955 = D.19954 & 64;
  if (D.19955 != 0) goto <D.19950>; else goto <D.19956>;
  <D.19956>:
  D.19957 = BIT_FIELD_REF <*a, 32, 32>;
  D.19958 = BIT_FIELD_REF <*b, 32, 32>;
  D.19959 = D.19957 ^ D.19958;
  D.19960 = D.19959 & 4194303;
  if (D.19960 != 0) goto <D.19950>; else goto <D.19951>;
  <D.19950>:
  D.19947 = 0;
  return D.19947;
  <D.19951>:
  i = 0;
  goto <D.17723>;
  <D.17722>:
  D.19961 = b->type_argv[i];
  D.19962 = a->type_argv[i];
  D.19963 = do_mono_metadata_type_equal (D.19962, D.19961, signature_only);
  if (D.19963 == 0) goto <D.19964>; else goto <D.19965>;
  <D.19964>:
  D.19947 = 0;
  return D.19947;
  <D.19965>:
  i = i + 1;
  <D.17723>:
  D.19966 = a->type_argc;
  D.19967 = (int) D.19966;
  if (D.19967 > i) goto <D.17722>; else goto <D.17724>;
  <D.17724>:
  D.19947 = 1;
  return D.19947;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.19971;
  unsigned char D.19972;
  unsigned char D.19974;
  unsigned char D.19975;
  unsigned char D.19976;
  unsigned char D.19977;
  gboolean D.19978;
  int D.19979;
  struct MonoClass * D.19980;
  struct MonoClass * D.19981;
  struct MonoType * D.19982;
  struct MonoType * D.19983;
  struct MonoArrayType * D.19984;
  unsigned char D.19985;
  struct MonoArrayType * D.19986;
  unsigned char D.19987;
  struct MonoClass * D.19990;
  struct MonoClass * D.19991;
  struct MonoGenericClass * D.19992;
  struct MonoGenericClass * D.19993;
  struct MonoGenericParam * D.19994;
  struct MonoGenericParam * D.19995;
  struct MonoMethodSignature * D.19996;
  struct MonoMethodSignature * D.19997;

  D.19971 = t1->type;
  D.19972 = t2->type;
  if (D.19971 != D.19972) goto <D.19969>; else goto <D.19973>;
  <D.19973>:
  D.19974 = BIT_FIELD_REF <*t1, 8, 88>;
  D.19975 = BIT_FIELD_REF <*t2, 8, 88>;
  D.19976 = D.19974 ^ D.19975;
  D.19977 = D.19976 & 64;
  if (D.19977 != 0) goto <D.19969>; else goto <D.19970>;
  <D.19969>:
  D.19978 = 0;
  return D.19978;
  <D.19970>:
  D.19971 = t1->type;
  D.19979 = (int) D.19971;
  switch (D.19979) <default: <D.18833>, case 1: <D.18806>, case 2: <D.18807>, case 3: <D.18808>, case 4: <D.18809>, case 5: <D.18810>, case 6: <D.18811>, case 7: <D.18812>, case 8: <D.18813>, case 9: <D.18814>, case 10: <D.18815>, case 11: <D.18816>, case 12: <D.18817>, case 13: <D.18818>, case 14: <D.18819>, case 15: <D.18827>, case 17: <D.18824>, case 18: <D.18825>, case 19: <D.18830>, case 20: <D.18828>, case 21: <D.18829>, case 22: <D.18823>, case 24: <D.18820>, case 25: <D.18821>, case 27: <D.18832>, case 28: <D.18822>, case 29: <D.18826>, case 30: <D.18831>>
  <D.18806>:
  <D.18807>:
  <D.18808>:
  <D.18809>:
  <D.18810>:
  <D.18811>:
  <D.18812>:
  <D.18813>:
  <D.18814>:
  <D.18815>:
  <D.18816>:
  <D.18817>:
  <D.18818>:
  <D.18819>:
  <D.18820>:
  <D.18821>:
  <D.18822>:
  <D.18823>:
  D.19978 = 1;
  return D.19978;
  <D.18824>:
  <D.18825>:
  <D.18826>:
  D.19980 = t2->data.klass;
  D.19981 = t1->data.klass;
  D.19978 = mono_metadata_class_equal (D.19981, D.19980, signature_only);
  return D.19978;
  <D.18827>:
  D.19982 = t2->data.type;
  D.19983 = t1->data.type;
  D.19978 = do_mono_metadata_type_equal (D.19983, D.19982, signature_only);
  return D.19978;
  <D.18828>:
  D.19984 = t1->data.array;
  D.19985 = D.19984->rank;
  D.19986 = t2->data.array;
  D.19987 = D.19986->rank;
  if (D.19985 != D.19987) goto <D.19988>; else goto <D.19989>;
  <D.19988>:
  D.19978 = 0;
  return D.19978;
  <D.19989>:
  D.19986 = t2->data.array;
  D.19990 = D.19986->eklass;
  D.19984 = t1->data.array;
  D.19991 = D.19984->eklass;
  D.19978 = mono_metadata_class_equal (D.19991, D.19990, signature_only);
  return D.19978;
  <D.18829>:
  D.19992 = t2->data.generic_class;
  D.19993 = t1->data.generic_class;
  D.19978 = _mono_metadata_generic_class_equal (D.19993, D.19992, signature_only);
  return D.19978;
  <D.18830>:
  D.19994 = t2->data.generic_param;
  D.19995 = t1->data.generic_param;
  D.19978 = mono_metadata_generic_param_equal (D.19995, D.19994, signature_only);
  return D.19978;
  <D.18831>:
  D.19994 = t2->data.generic_param;
  D.19995 = t1->data.generic_param;
  D.19978 = mono_metadata_generic_param_equal (D.19995, D.19994, signature_only);
  return D.19978;
  <D.18832>:
  D.19996 = t2->data.method;
  D.19997 = t1->data.method;
  D.19978 = mono_metadata_fnptr_equal (D.19997, D.19996, signature_only);
  return D.19978;
  <D.18833>:
  D.19971 = t1->type;
  D.19979 = (int) D.19971;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.19979);
  <D.18834>:
  goto <D.18834>;
  D.19978 = 0;
  return D.19978;
  D.19978 = 0;
  return D.19978;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.20001;
  struct MonoGenericClass * D.20002;
  struct MonoGenericClass * D.20005;
  struct MonoGenericContainer * D.20010;
  struct MonoGenericContainer * D.20013;
  unsigned char D.20018;
  unsigned char D.20021;
  struct MonoGenericParam * D.20024;
  struct MonoGenericParam * D.20025;
  struct MonoClass * D.20036;
  struct MonoClass * D.20037;
  struct MonoType * D.20044;
  struct MonoType * D.20045;

  if (c1 == c2) goto <D.19999>; else goto <D.20000>;
  <D.19999>:
  D.20001 = 1;
  return D.20001;
  <D.20000>:
  D.20002 = c1->generic_class;
  if (D.20002 != 0B) goto <D.20003>; else goto <D.20004>;
  <D.20003>:
  D.20005 = c2->generic_class;
  if (D.20005 != 0B) goto <D.20006>; else goto <D.20007>;
  <D.20006>:
  D.20005 = c2->generic_class;
  D.20002 = c1->generic_class;
  D.20001 = _mono_metadata_generic_class_equal (D.20002, D.20005, signature_only);
  return D.20001;
  <D.20007>:
  <D.20004>:
  D.20002 = c1->generic_class;
  if (D.20002 != 0B) goto <D.20008>; else goto <D.20009>;
  <D.20008>:
  D.20010 = c2->generic_container;
  if (D.20010 != 0B) goto <D.20011>; else goto <D.20012>;
  <D.20011>:
  D.20002 = c1->generic_class;
  D.20001 = _mono_metadata_generic_class_container_equal (D.20002, c2, signature_only);
  return D.20001;
  <D.20012>:
  <D.20009>:
  D.20013 = c1->generic_container;
  if (D.20013 != 0B) goto <D.20014>; else goto <D.20015>;
  <D.20014>:
  D.20005 = c2->generic_class;
  if (D.20005 != 0B) goto <D.20016>; else goto <D.20017>;
  <D.20016>:
  D.20005 = c2->generic_class;
  D.20001 = _mono_metadata_generic_class_container_equal (D.20005, c1, signature_only);
  return D.20001;
  <D.20017>:
  <D.20015>:
  D.20018 = c1->byval_arg.type;
  if (D.20018 == 19) goto <D.20019>; else goto <D.20020>;
  <D.20019>:
  D.20021 = c2->byval_arg.type;
  if (D.20021 == 19) goto <D.20022>; else goto <D.20023>;
  <D.20022>:
  D.20024 = c2->byval_arg.data.generic_param;
  D.20025 = c1->byval_arg.data.generic_param;
  D.20001 = mono_metadata_generic_param_equal (D.20025, D.20024, signature_only);
  return D.20001;
  <D.20023>:
  <D.20020>:
  D.20018 = c1->byval_arg.type;
  if (D.20018 == 30) goto <D.20026>; else goto <D.20027>;
  <D.20026>:
  D.20021 = c2->byval_arg.type;
  if (D.20021 == 30) goto <D.20028>; else goto <D.20029>;
  <D.20028>:
  D.20024 = c2->byval_arg.data.generic_param;
  D.20025 = c1->byval_arg.data.generic_param;
  D.20001 = mono_metadata_generic_param_equal (D.20025, D.20024, signature_only);
  return D.20001;
  <D.20029>:
  <D.20027>:
  if (signature_only != 0) goto <D.20030>; else goto <D.20031>;
  <D.20030>:
  D.20018 = c1->byval_arg.type;
  if (D.20018 == 29) goto <D.20032>; else goto <D.20033>;
  <D.20032>:
  D.20021 = c2->byval_arg.type;
  if (D.20021 == 29) goto <D.20034>; else goto <D.20035>;
  <D.20034>:
  D.20036 = c2->byval_arg.data.klass;
  D.20037 = c1->byval_arg.data.klass;
  D.20001 = mono_metadata_class_equal (D.20037, D.20036, signature_only);
  return D.20001;
  <D.20035>:
  <D.20033>:
  <D.20031>:
  if (signature_only != 0) goto <D.20038>; else goto <D.20039>;
  <D.20038>:
  D.20018 = c1->byval_arg.type;
  if (D.20018 == 20) goto <D.20040>; else goto <D.20041>;
  <D.20040>:
  D.20021 = c2->byval_arg.type;
  if (D.20021 == 20) goto <D.20042>; else goto <D.20043>;
  <D.20042>:
  D.20044 = &c2->byval_arg;
  D.20045 = &c1->byval_arg;
  D.20001 = do_mono_metadata_type_equal (D.20045, D.20044, signature_only);
  return D.20001;
  <D.20043>:
  <D.20041>:
  <D.20039>:
  D.20001 = 0;
  return D.20001;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.20047;
  struct MonoClass * D.20048;
  int D.20049;
  gboolean D.20052;
  int D.20053;
  unsigned char D.20056;
  unsigned char D.20057;
  _Bool D.20058;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.20047 = c2->generic_container;
  i2 = D.20047->context.class_inst;
  D.20048 = g1->container_class;
  D.20049 = mono_metadata_class_equal (D.20048, c2, signature_only);
  if (D.20049 == 0) goto <D.20050>; else goto <D.20051>;
  <D.20050>:
  D.20052 = 0;
  return D.20052;
  <D.20051>:
  D.20053 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20053 == 0) goto <D.20054>; else goto <D.20055>;
  <D.20054>:
  D.20052 = 0;
  return D.20052;
  <D.20055>:
  D.20056 = BIT_FIELD_REF <*g1, 8, 192>;
  D.20057 = D.20056 & 2;
  D.20058 = D.20057 == 0;
  D.20052 = (gboolean) D.20058;
  return D.20052;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  unsigned char D.20060;
  unsigned char D.20061;
  unsigned char D.20062;
  unsigned char D.20063;
  gboolean D.20066;
  struct MonoClass * D.20067;
  struct MonoClass * D.20068;
  int D.20069;
  int D.20072;
  unsigned char D.20075;
  _Bool D.20076;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.20060 = BIT_FIELD_REF <*g1, 8, 192>;
  D.20061 = BIT_FIELD_REF <*g2, 8, 192>;
  D.20062 = D.20060 ^ D.20061;
  D.20063 = D.20062 & 1;
  if (D.20063 != 0) goto <D.20064>; else goto <D.20065>;
  <D.20064>:
  D.20066 = 0;
  return D.20066;
  <D.20065>:
  D.20067 = g2->container_class;
  D.20068 = g1->container_class;
  D.20069 = mono_metadata_class_equal (D.20068, D.20067, signature_only);
  if (D.20069 == 0) goto <D.20070>; else goto <D.20071>;
  <D.20070>:
  D.20066 = 0;
  return D.20066;
  <D.20071>:
  D.20072 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20072 == 0) goto <D.20073>; else goto <D.20074>;
  <D.20073>:
  D.20066 = 0;
  return D.20066;
  <D.20074>:
  D.20060 = BIT_FIELD_REF <*g1, 8, 192>;
  D.20061 = BIT_FIELD_REF <*g2, 8, 192>;
  D.20062 = D.20060 ^ D.20061;
  D.20075 = D.20062 & 2;
  D.20076 = D.20075 == 0;
  D.20066 = (gboolean) D.20076;
  return D.20066;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.20080;
  short unsigned int D.20081;
  short unsigned int D.20082;
  short unsigned int D.20085;
  short unsigned int D.20086;
  struct MonoGenericContainer * D.20091;
  struct MonoGenericContainer * D.20092;
  struct MonoImage * D.20096;
  struct MonoImage * D.20097;

  if (p1 == p2) goto <D.20078>; else goto <D.20079>;
  <D.20078>:
  D.20080 = 1;
  return D.20080;
  <D.20079>:
  D.20081 = p1->num;
  D.20082 = p2->num;
  if (D.20081 != D.20082) goto <D.20083>; else goto <D.20084>;
  <D.20083>:
  D.20080 = 0;
  return D.20080;
  <D.20084>:
  D.20085 = p1->serial;
  D.20086 = p2->serial;
  if (D.20085 != D.20086) goto <D.20087>; else goto <D.20088>;
  <D.20087>:
  D.20080 = 0;
  return D.20080;
  <D.20088>:
  D.20091 = p1->owner;
  D.20092 = p2->owner;
  if (D.20091 == D.20092) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  D.20091 = p1->owner;
  if (D.20091 != 0B) goto <D.20089>; else goto <D.20095>;
  <D.20095>:
  D.20096 = p1->image;
  D.20097 = p2->image;
  if (D.20096 == D.20097) goto <D.20089>; else goto <D.20090>;
  <D.20089>:
  D.20080 = 1;
  return D.20080;
  <D.20090>:
  <D.20094>:
  D.20080 = signature_only;
  return D.20080;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.20101;
  unsigned char D.20102;
  unsigned char D.20103;
  unsigned char D.20104;
  unsigned char D.20105;
  short int D.20108;
  short int D.20109;
  unsigned char D.20112;
  signed char D.20115;
  struct MonoType * D.20118;
  struct MonoType * D.20119;
  int D.20120;
  short unsigned int D.20123;
  short unsigned int D.20124;
  _Bool D.20127;
  _Bool D.20128;
  _Bool D.20129;
  _Bool D.20132;
  int D.20133;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.20099>; else goto <D.20100>;
      <D.20099>:
      D.20101 = 1;
      return D.20101;
      <D.20100>:
      D.20102 = BIT_FIELD_REF <*s1, 8, 112>;
      D.20103 = BIT_FIELD_REF <*s2, 8, 112>;
      D.20104 = D.20102 ^ D.20103;
      D.20105 = D.20104 & 63;
      if (D.20105 != 0) goto <D.20106>; else goto <D.20107>;
      <D.20106>:
      D.20101 = 0;
      return D.20101;
      <D.20107>:
      D.20108 = s1->sentinelpos;
      D.20109 = s2->sentinelpos;
      if (D.20108 != D.20109) goto <D.20110>; else goto <D.20111>;
      <D.20110>:
      D.20101 = 0;
      return D.20101;
      <D.20111>:
      D.20102 = BIT_FIELD_REF <*s1, 8, 112>;
      D.20103 = BIT_FIELD_REF <*s2, 8, 112>;
      D.20104 = D.20102 ^ D.20103;
      D.20112 = D.20104 & 64;
      if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
      <D.20113>:
      D.20101 = 0;
      return D.20101;
      <D.20114>:
      D.20102 = BIT_FIELD_REF <*s1, 8, 112>;
      D.20103 = BIT_FIELD_REF <*s2, 8, 112>;
      D.20104 = D.20102 ^ D.20103;
      D.20115 = (signed char) D.20104;
      if (D.20115 < 0) goto <D.20116>; else goto <D.20117>;
      <D.20116>:
      D.20101 = 0;
      return D.20101;
      <D.20117>:
      D.20118 = s2->ret;
      D.20119 = s1->ret;
      D.20120 = do_mono_metadata_type_equal (D.20119, D.20118, signature_only);
      if (D.20120 == 0) goto <D.20121>; else goto <D.20122>;
      <D.20121>:
      D.20101 = 0;
      return D.20101;
      <D.20122>:
      D.20123 = s1->param_count;
      D.20124 = s2->param_count;
      if (D.20123 != D.20124) goto <D.20125>; else goto <D.20126>;
      <D.20125>:
      D.20101 = 0;
      return D.20101;
      <D.20126>:
      <D.18800>:
      {
        struct MonoType * t1;
        struct MonoType * t2;

        t1 = mono_signature_get_params (s1, &iter1);
        t2 = mono_signature_get_params (s2, &iter2);
        D.20127 = t1 == 0B;
        D.20128 = t2 == 0B;
        D.20129 = D.20127 | D.20128;
        if (D.20129 != 0) goto <D.20130>; else goto <D.20131>;
        <D.20130>:
        D.20132 = t1 == t2;
        D.20101 = (gboolean) D.20132;
        return D.20101;
        <D.20131>:
        D.20133 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.20133 == 0) goto <D.20134>; else goto <D.20135>;
        <D.20134>:
        D.20101 = 0;
        return D.20101;
        <D.20135>:
      }
      goto <D.18800>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


mono_metadata_init ()
{
  struct GHashTable * type_cache.52;
  const struct MonoType * D.20139;
  struct GHashTable * type_cache.53;
  unsigned int i.54;
  int i;

  type_cache.52 = monoeg_g_hash_table_new (mono_type_hash, mono_type_equal);
  type_cache = type_cache.52;
  i = 0;
  goto <D.17747>;
  <D.17746>:
  D.20139 = &builtin_types[i];
  D.20139 = &builtin_types[i];
  type_cache.53 = type_cache;
  monoeg_g_hash_table_insert_replace (type_cache.53, D.20139, D.20139, 0);
  i = i + 1;
  <D.17747>:
  i.54 = (unsigned int) i;
  if (i.54 <= 33) goto <D.17746>; else goto <D.17748>;
  <D.17748>:
}


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.20144;
  unsigned char D.20145;
  unsigned char D.20147;
  unsigned char D.20148;
  unsigned char D.20149;
  unsigned char D.20150;
  short unsigned int D.20152;
  short unsigned int D.20153;
  signed char D.20155;
  gint D.20156;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.20144 = a->type;
  D.20145 = b->type;
  if (D.20144 != D.20145) goto <D.20142>; else goto <D.20146>;
  <D.20146>:
  D.20147 = BIT_FIELD_REF <*a, 8, 88>;
  D.20148 = BIT_FIELD_REF <*b, 8, 88>;
  D.20149 = D.20147 ^ D.20148;
  D.20150 = D.20149 & 64;
  if (D.20150 != 0) goto <D.20142>; else goto <D.20151>;
  <D.20151>:
  D.20152 = a->attrs;
  D.20153 = b->attrs;
  if (D.20152 != D.20153) goto <D.20142>; else goto <D.20154>;
  <D.20154>:
  D.20147 = BIT_FIELD_REF <*a, 8, 88>;
  D.20148 = BIT_FIELD_REF <*b, 8, 88>;
  D.20149 = D.20147 ^ D.20148;
  D.20155 = (signed char) D.20149;
  if (D.20155 < 0) goto <D.20142>; else goto <D.20143>;
  <D.20142>:
  D.20156 = 0;
  return D.20156;
  <D.20143>:
  D.20156 = 1;
  return D.20156;
}


mono_type_hash (const void * data)
{
  unsigned char D.20158;
  guint D.20161;
  struct MonoGenericClass * D.20162;
  int D.20163;
  <unnamed-unsigned:1> D.20164;
  int D.20165;
  int D.20166;
  int D.20167;
  short unsigned int D.20168;
  int D.20169;
  int D.20170;
  int D.20171;
  const struct MonoType * type;

  type = data;
  D.20158 = type->type;
  if (D.20158 == 21) goto <D.20159>; else goto <D.20160>;
  <D.20159>:
  D.20162 = type->data.generic_class;
  D.20161 = mono_generic_class_hash (D.20162);
  return D.20161;
  <D.20160>:
  D.20158 = type->type;
  D.20163 = (int) D.20158;
  D.20164 = type->byref;
  D.20165 = (int) D.20164;
  D.20166 = D.20165 << 8;
  D.20167 = D.20163 | D.20166;
  D.20168 = type->attrs;
  D.20169 = (int) D.20168;
  D.20170 = D.20169 << 9;
  D.20171 = D.20167 | D.20170;
  D.20161 = (guint) D.20171;
  return D.20161;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.20173;
  struct MonoType * D.20174;
  <unnamed-unsigned:1> D.20175;
  unsigned int D.20176;
  const struct MonoGenericContext * D.20177;
  unsigned int D.20178;
  guint D.20179;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.20173 = gclass->container_class;
  D.20174 = &D.20173->byval_arg;
  hash = mono_metadata_type_hash (D.20174);
  hash = hash * 13;
  D.20175 = gclass->is_tb_open;
  D.20176 = (unsigned int) D.20175;
  hash = D.20176 + hash;
  D.20177 = &gclass->context;
  D.20178 = mono_metadata_generic_context_hash (D.20177);
  hash = D.20178 + hash;
  D.20179 = hash;
  return D.20179;
}


mono_metadata_cleanup ()
{
  struct GHashTable * type_cache.55;
  struct GPtrArray * image_sets.56;

  type_cache.55 = type_cache;
  monoeg_g_hash_table_destroy (type_cache.55);
  type_cache = 0B;
  image_sets.56 = image_sets;
  monoeg_g_ptr_array_free (image_sets.56, 1);
  image_sets = 0B;
}


mono_metadata_parse_type_full (struct MonoImage * m, struct MonoGenericContainer * container, MonoParseTypeMode mode, short int opt_attrs, const char * ptr, const char * * rptr)
{
  struct MonoType * D.20183;
  int D.20184;

  D.20184 = (int) opt_attrs;
  D.20183 = mono_metadata_parse_type_internal (m, container, mode, D.20184, 0, ptr, rptr);
  return D.20183;
}


mono_metadata_parse_type_internal (struct MonoImage * m, struct MonoGenericContainer * container, MonoParseTypeMode mode, short int opt_attrs, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.57;
  const char * tmp_ptr.58;
  char D.20188;
  int D.20189;
  const char * tmp_ptr.59;
  long unsigned int D.20193;
  long unsigned int D.20194;
  unsigned int D.20195;
  unsigned int D.20196;
  void * iftmp.60;
  long unsigned int D.20200;
  unsigned int size.61;
  unsigned char D.20203;
  <unnamed-unsigned:6> D.20204;
  char D.20208;
  int D.20209;
  const char * ptr.62;
  struct MonoCustomMod * D.20211;
  short unsigned int opt_attrs.63;
  unsigned char D.20213;
  <unnamed-unsigned:1> D.20214;
  _Bool D.20215;
  int D.20216;
  struct MonoType * D.20219;
  unsigned char D.20222;
  unsigned char D.20223;
  unsigned char D.20228;
  unsigned char D.20229;
  unsigned int D.20232;
  unsigned int D.20233;
  struct MonoType * iftmp.64;
  unsigned char D.20237;
  struct MonoClass * D.20240;
  struct MonoClass * D.20242;
  struct GHashTable * type_cache.65;
  void * iftmp.66;
  struct MonoType * type;
  struct MonoType * cached;
  struct MonoType stype;
  gboolean byref;
  gboolean pinned;
  const char * tmp_ptr;
  int count;
  gboolean found;

  try
    {
      byref = 0;
      pinned = 0;
      count = 0;
      ptr.57 = ptr;
      tmp_ptr = ptr.57;
      found = 1;
      goto <D.17776>;
      <D.17775>:
      tmp_ptr.58 = tmp_ptr;
      D.20188 = *tmp_ptr.58;
      D.20189 = (int) D.20188;
      switch (D.20189) <default: <D.17774>, case 16: <D.17770>, case 31: <D.17772>, case 32: <D.17773>, case 69: <D.17769>>
      <D.17769>:
      <D.17770>:
      tmp_ptr.58 = tmp_ptr;
      tmp_ptr.59 = tmp_ptr.58 + 1;
      tmp_ptr = tmp_ptr.59;
      goto <D.17771>;
      <D.17772>:
      <D.17773>:
      count = count + 1;
      tmp_ptr.58 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.58, &tmp_ptr);
      goto <D.17771>;
      <D.17774>:
      found = 0;
      <D.17771>:
      <D.17776>:
      if (found != 0) goto <D.17775>; else goto <D.17777>;
      <D.17777>:
      if (count != 0) goto <D.20191>; else goto <D.20192>;
      <D.20191>:
      {
        int size;

        D.20193 = (long unsigned int) count;
        D.20194 = D.20193 + 3;
        D.20195 = (unsigned int) D.20194;
        D.20196 = D.20195 * 4;
        size = (int) D.20196;
        if (transient != 0) goto <D.20198>; else goto <D.20199>;
        <D.20198>:
        D.20200 = (long unsigned int) size;
        iftmp.60 = monoeg_malloc0 (D.20200);
        goto <D.20201>;
        <D.20199>:
        size.61 = (unsigned int) size;
        iftmp.60 = mono_image_alloc0 (m, size.61);
        <D.20201>:
        type = iftmp.60;
        D.20203 = (unsigned char) count;
        D.20204 = (<unnamed-unsigned:6>) D.20203;
        type->num_mods = D.20204;
        if (count > 64) goto <D.20205>; else goto <D.20206>;
        <D.20205>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.20206>:
      }
      goto <D.20207>;
      <D.20192>:
      type = &stype;
      memset (type, 0, 12);
      <D.20207>:
      found = 1;
      count = 0;
      goto <D.17786>;
      <D.17785>:
      ptr.57 = ptr;
      D.20208 = *ptr.57;
      D.20209 = (int) D.20208;
      switch (D.20209) <default: <D.17784>, case 16: <D.17781>, case 31: <D.17782>, case 32: <D.17783>, case 69: <D.17779>>
      <D.17779>:
      pinned = 1;
      ptr.57 = ptr;
      ptr.62 = ptr.57 + 1;
      ptr = ptr.62;
      goto <D.17780>;
      <D.17781>:
      byref = 1;
      ptr.57 = ptr;
      ptr.62 = ptr.57 + 1;
      ptr = ptr.62;
      goto <D.17780>;
      <D.17782>:
      <D.17783>:
      ptr.57 = ptr;
      D.20211 = &type->modifiers[count];
      mono_metadata_parse_custom_mod (m, D.20211, ptr.57, &ptr);
      count = count + 1;
      goto <D.17780>;
      <D.17784>:
      found = 0;
      <D.17780>:
      <D.17786>:
      if (found != 0) goto <D.17785>; else goto <D.17787>;
      <D.17787>:
      opt_attrs.63 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.63;
      D.20213 = (unsigned char) byref;
      D.20214 = (<unnamed-unsigned:1>) D.20213;
      type->byref = D.20214;
      D.20215 = pinned != 0;
      type->pinned = D.20215;
      ptr.57 = ptr;
      D.20216 = do_mono_metadata_parse_type (type, m, container, transient, ptr.57, &ptr);
      if (D.20216 == 0) goto <D.20217>; else goto <D.20218>;
      <D.20217>:
      D.20219 = 0B;
      return D.20219;
      <D.20218>:
      if (rptr != 0B) goto <D.20220>; else goto <D.20221>;
      <D.20220>:
      ptr.57 = ptr;
      *rptr = ptr.57;
      <D.20221>:
      D.20222 = BIT_FIELD_REF <*type, 8, 88>;
      D.20223 = D.20222 & 63;
      if (D.20223 == 0) goto <D.20224>; else goto <D.20225>;
      <D.20224>:
      if (transient == 0) goto <D.20226>; else goto <D.20227>;
      <D.20226>:
      D.20228 = type->type;
      D.20229 = D.20228 + 239;
      if (D.20229 <= 1) goto <D.20230>; else goto <D.20231>;
      <D.20230>:
      D.20232 = BIT_FIELD_REF <*type, 32, 64>;
      D.20233 = D.20232 & 2147549183;
      if (D.20233 == 0) goto <D.20234>; else goto <D.20235>;
      <D.20234>:
      {
        struct MonoType * ret;

        D.20222 = BIT_FIELD_REF <*type, 8, 88>;
        D.20237 = D.20222 & 64;
        if (D.20237 != 0) goto <D.20238>; else goto <D.20239>;
        <D.20238>:
        D.20240 = type->data.klass;
        iftmp.64 = &D.20240->this_arg;
        goto <D.20241>;
        <D.20239>:
        D.20240 = type->data.klass;
        iftmp.64 = &D.20240->byval_arg;
        <D.20241>:
        ret = iftmp.64;
        D.20242 = ret->data.klass;
        D.20240 = type->data.klass;
        if (D.20242 == D.20240) goto <D.20243>; else goto <D.20244>;
        <D.20243>:
        D.20219 = ret;
        return D.20219;
        <D.20244>:
      }
      <D.20235>:
      <D.20231>:
      type_cache.65 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.65, type);
      if (cached != 0B) goto <D.20246>; else goto <D.20247>;
      <D.20246>:
      D.20219 = cached;
      return D.20219;
      <D.20247>:
      <D.20227>:
      <D.20225>:
      if (&stype == type) goto <D.20248>; else goto <D.20249>;
      <D.20248>:
      if (transient != 0) goto <D.20251>; else goto <D.20252>;
      <D.20251>:
      iftmp.66 = monoeg_malloc (12);
      goto <D.20253>;
      <D.20252>:
      iftmp.66 = mono_image_alloc (m, 12);
      <D.20253>:
      type = iftmp.66;
      memcpy (type, &stype, 12);
      <D.20249>:
      D.20219 = type;
      return D.20219;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20258;
  int D.20263;
  void * D.20265;
  long unsigned int D.20266;

  D.20258 = __builtin_constant_p (__len);
  if (D.20258 != 0) goto <D.20259>; else goto <D.20260>;
  <D.20259>:
  if (__len == 0) goto <D.20261>; else goto <D.20262>;
  <D.20261>:
  D.20263 = __builtin_constant_p (__ch);
  if (D.20263 == 0) goto <D.20256>; else goto <D.20264>;
  <D.20264>:
  if (__ch != 0) goto <D.20256>; else goto <D.20257>;
  <D.20256>:
  __warn_memset_zero_len ();
  D.20265 = __dest;
  return D.20265;
  <D.20257>:
  <D.20262>:
  <D.20260>:
  D.20266 = __builtin_object_size (__dest, 0);
  D.20265 = __builtin___memset_chk (__dest, __ch, __len, D.20266);
  return D.20265;
}


do_mono_metadata_parse_type (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.67;
  unsigned int D.20269;
  unsigned char D.20270;
  unsigned char D.20271;
  int D.20272;
  gboolean D.20275;
  unsigned char D.20276;
  int D.20277;
  int D.20278;
  struct MonoClass * D.20283;
  struct MonoClass * D.20284;
  struct MonoType * D.20287;
  struct MonoType * D.20288;
  struct MonoMethodSignature * D.20291;
  struct MonoMethodSignature * D.20292;
  struct MonoArrayType * D.20295;
  struct MonoArrayType * D.20296;
  unsigned char D.20301;
  unsigned char D.20302;
  <unnamed type> D.20305;
  struct MonoGenericParam * D.20306;
  struct MonoGenericParam * D.20307;
  char * D.20310;
  gboolean ok;

  ok = 1;
  ptr.67 = ptr;
  D.20269 = mono_metadata_decode_value (ptr.67, &ptr);
  D.20270 = (unsigned char) D.20269;
  type->type = D.20270;
  D.20271 = type->type;
  D.20272 = (int) D.20271;
  switch (D.20272) <default: <D.18340>, case 1: <D.18309>, case 2: <D.18310>, case 3: <D.18311>, case 4: <D.18312>, case 5: <D.18313>, case 6: <D.18314>, case 7: <D.18315>, case 8: <D.18316>, case 9: <D.18317>, case 10: <D.18318>, case 11: <D.18319>, case 12: <D.18320>, case 13: <D.18321>, case 14: <D.18324>, case 15: <D.18334>, case 17: <D.18328>, case 18: <D.18329>, case 19: <D.18338>, case 20: <D.18336>, case 21: <D.18339>, case 22: <D.18326>, case 24: <D.18322>, case 25: <D.18323>, case 27: <D.18335>, case 28: <D.18325>, case 29: <D.18332>, case 30: <D.18337>>
  <D.18309>:
  <D.18310>:
  <D.18311>:
  <D.18312>:
  <D.18313>:
  <D.18314>:
  <D.18315>:
  <D.18316>:
  <D.18317>:
  <D.18318>:
  <D.18319>:
  <D.18320>:
  <D.18321>:
  <D.18322>:
  <D.18323>:
  <D.18324>:
  <D.18325>:
  <D.18326>:
  goto <D.18327>;
  <D.18328>:
  <D.18329>:
  {
    guint32 token;
    struct MonoClass * class;

    ptr.67 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.67, &ptr);
    class = mono_class_get (m, token);
    type->data.klass = class;
    if (class == 0B) goto <D.20273>; else goto <D.20274>;
    <D.20273>:
    D.20275 = 0;
    return D.20275;
    <D.20274>:
    D.20271 = type->type;
    D.20272 = (int) D.20271;
    D.20276 = class->byval_arg.type;
    D.20277 = (int) D.20276;
    D.20278 = compare_type_literals (D.20277, D.20272);
    if (D.20278 == 0) goto <D.20279>; else goto <D.20280>;
    <D.20279>:
    D.20275 = 0;
    return D.20275;
    <D.20280>:
    goto <D.18327>;
  }
  <D.18332>:
  {
    struct MonoType * etype;

    ptr.67 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.67, &ptr);
    if (etype == 0B) goto <D.20281>; else goto <D.20282>;
    <D.20281>:
    D.20275 = 0;
    return D.20275;
    <D.20282>:
    D.20283 = mono_class_from_mono_type (etype);
    type->data.klass = D.20283;
    D.20284 = type->data.klass;
    if (D.20284 == 0B) goto <D.20285>; else goto <D.20286>;
    <D.20285>:
    D.20275 = 0;
    return D.20275;
    <D.20286>:
    goto <D.18327>;
  }
  <D.18334>:
  ptr.67 = ptr;
  D.20287 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.67, &ptr);
  type->data.type = D.20287;
  D.20288 = type->data.type;
  if (D.20288 == 0B) goto <D.20289>; else goto <D.20290>;
  <D.20289>:
  D.20275 = 0;
  return D.20275;
  <D.20290>:
  goto <D.18327>;
  <D.18335>:
  ptr.67 = ptr;
  D.20291 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.67, &ptr);
  type->data.method = D.20291;
  D.20292 = type->data.method;
  if (D.20292 == 0B) goto <D.20293>; else goto <D.20294>;
  <D.20293>:
  D.20275 = 0;
  return D.20275;
  <D.20294>:
  goto <D.18327>;
  <D.18336>:
  ptr.67 = ptr;
  D.20295 = mono_metadata_parse_array_internal (m, container, transient, ptr.67, &ptr);
  type->data.array = D.20295;
  D.20296 = type->data.array;
  if (D.20296 == 0B) goto <D.20297>; else goto <D.20298>;
  <D.20297>:
  D.20275 = 0;
  return D.20275;
  <D.20298>:
  goto <D.18327>;
  <D.18337>:
  if (container != 0B) goto <D.20299>; else goto <D.20300>;
  <D.20299>:
  D.20301 = BIT_FIELD_REF <*container, 8, 280>;
  D.20302 = D.20301 & 128;
  if (D.20302 == 0) goto <D.20303>; else goto <D.20304>;
  <D.20303>:
  D.20275 = 0;
  return D.20275;
  <D.20304>:
  <D.20300>:
  <D.18338>:
  ptr.67 = ptr;
  D.20271 = type->type;
  D.20305 = (<unnamed type>) D.20271;
  D.20306 = mono_metadata_parse_generic_param (m, container, D.20305, ptr.67, &ptr);
  type->data.generic_param = D.20306;
  D.20307 = type->data.generic_param;
  if (D.20307 == 0B) goto <D.20308>; else goto <D.20309>;
  <D.20308>:
  D.20275 = 0;
  return D.20275;
  <D.20309>:
  goto <D.18327>;
  <D.18339>:
  ptr.67 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.67, &ptr);
  goto <D.18327>;
  <D.18340>:
  D.20310 = m->name;
  D.20271 = type->type;
  D.20272 = (int) D.20271;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.20272, D.20310);
  D.20275 = 0;
  return D.20275;
  <D.18327>:
  if (rptr != 0B) goto <D.20311>; else goto <D.20312>;
  <D.20311>:
  ptr.67 = ptr;
  *rptr = ptr.67;
  <D.20312>:
  D.20275 = ok;
  return D.20275;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.20317;
  _Bool D.20320;
  _Bool D.20321;
  _Bool D.20322;
  _Bool D.20325;

  if (class_type == 0) goto <D.20315>; else goto <D.20316>;
  <D.20315>:
  D.20317 = 1;
  return D.20317;
  <D.20316>:
  if (type_type == 18) goto <D.20318>; else goto <D.20319>;
  <D.20318>:
  D.20320 = class_type == 14;
  D.20321 = class_type == 28;
  D.20322 = D.20320 | D.20321;
  if (D.20322 != 0) goto <D.20323>; else goto <D.20324>;
  <D.20323>:
  D.20317 = 1;
  return D.20317;
  <D.20324>:
  <D.20319>:
  D.20325 = class_type == type_type;
  D.20317 = (gboolean) D.20325;
  return D.20317;
}


mono_metadata_parse_generic_param (struct MonoImage * m, struct MonoGenericContainer * generic_container, MonoTypeEnum type, const char * ptr, const char * * rptr)
{
  const char * ptr.68;
  unsigned int D.20328;
  short unsigned int D.20333;
  struct MonoGenericParam * D.20334;
  <unnamed-signed:31> D.20335;
  int D.20336;
  struct MonoGenericParamFull * D.20339;
  long unsigned int D.20340;
  long unsigned int D.20341;
  int index;

  ptr.68 = ptr;
  D.20328 = mono_metadata_decode_value (ptr.68, &ptr);
  index = (int) D.20328;
  if (rptr != 0B) goto <D.20329>; else goto <D.20330>;
  <D.20329>:
  ptr.68 = ptr;
  *rptr = ptr.68;
  <D.20330>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.20331>; else goto <D.20332>;
  <D.20331>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 24);
    D.20333 = (short unsigned int) index;
    param->num = D.20333;
    param->image = m;
    D.20334 = param;
    return D.20334;
  }
  <D.20332>:
  D.20335 = generic_container->type_argc;
  D.20336 = (int) D.20335;
  if (D.20336 <= index) goto <D.20337>; else goto <D.20338>;
  <D.20337>:
  D.20334 = 0B;
  return D.20334;
  <D.20338>:
  D.20339 = generic_container->type_params;
  D.20340 = (long unsigned int) index;
  D.20341 = D.20340 * 56;
  D.20334 = D.20339 + D.20341;
  return D.20334;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.20343;
  struct MonoGenericContainer * D.20346;
  _Bool D.20347;
  _Bool D.20348;
  _Bool D.20349;
  int D.20350;
  _Bool D.20351;
  long int D.20352;
  long int D.20353;
  unsigned char D.20360;
  unsigned char D.20361;
  struct MonoGenericContainer * D.20363;
  gboolean is_var;

  D.20343 = type == 19;
  is_var = (gboolean) D.20343;
  if (gc == 0B) goto <D.20344>; else goto <D.20345>;
  <D.20344>:
  D.20346 = 0B;
  return D.20346;
  <D.20345>:
  D.20347 = is_var == 0;
  D.20348 = type != 30;
  D.20349 = D.20347 & D.20348;
  D.20350 = (int) D.20349;
  D.20351 = D.20350 != 0;
  D.20352 = (long int) D.20351;
  D.20353 = __builtin_expect (D.20352, 0);
  if (D.20353 != 0) goto <D.20354>; else goto <D.20355>;
  <D.20354>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.20355>:
  if (is_var != 0) goto <D.20356>; else goto <D.20357>;
  <D.20356>:
  D.20360 = BIT_FIELD_REF <*gc, 8, 280>;
  D.20361 = D.20360 & 128;
  if (D.20361 != 0) goto <D.20358>; else goto <D.20362>;
  <D.20362>:
  D.20363 = gc->parent;
  if (D.20363 != 0B) goto <D.20358>; else goto <D.20359>;
  <D.20358>:
  D.20346 = gc->parent;
  return D.20346;
  <D.20359>:
  <D.20357>:
  D.20346 = gc;
  return D.20346;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.69;
  gboolean D.20368;
  struct MonoGenericContainer * D.20369;
  unsigned int D.20372;
  struct MonoGenericClass * D.20377;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.69 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.69, &ptr);
  if (gtype == 0B) goto <D.20366>; else goto <D.20367>;
  <D.20366>:
  D.20368 = 0;
  return D.20368;
  <D.20367>:
  gklass = mono_class_from_mono_type (gtype);
  D.20369 = gklass->generic_container;
  if (D.20369 == 0B) goto <D.20370>; else goto <D.20371>;
  <D.20370>:
  D.20368 = 0;
  return D.20368;
  <D.20371>:
  ptr.69 = ptr;
  D.20372 = mono_metadata_decode_value (ptr.69, &ptr);
  count = (int) D.20372;
  ptr.69 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.69, &ptr);
  if (inst == 0B) goto <D.20373>; else goto <D.20374>;
  <D.20373>:
  D.20368 = 0;
  return D.20368;
  <D.20374>:
  if (rptr != 0B) goto <D.20375>; else goto <D.20376>;
  <D.20375>:
  ptr.69 = ptr;
  *rptr = ptr.69;
  <D.20376>:
  D.20377 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.20377;
  D.20368 = 1;
  return D.20368;
}


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

  D.20380 = __builtin_object_size (__dest, 0);
  D.20379 = __builtin___memcpy_chk (__dest, __src, __len, D.20380);
  return D.20379;
}


mono_metadata_parse_type (struct MonoImage * m, MonoParseTypeMode mode, short int opt_attrs, const char * ptr, const char * * rptr)
{
  struct MonoType * D.20382;
  int D.20383;

  D.20383 = (int) opt_attrs;
  D.20382 = mono_metadata_parse_type_full (m, 0B, mode, D.20383, ptr, rptr);
  return D.20382;
}


mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.20385;
  <unnamed-unsigned:24> D.20386;
  int D.20387;
  <unnamed-unsigned:24> D.20391;
  int D.20392;
  int D.20393;
  unsigned int D.20394;
  int D.20395;
  gboolean D.20398;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.20385 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.20385, 5);
  D.20386 = methodt->rows;
  D.20387 = (int) D.20386;
  if (D.20387 > def) goto <D.20388>; else goto <D.20389>;
  <D.20388>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.20390>;
  <D.20389>:
  D.20391 = m->tables[8].rows;
  D.20392 = (int) D.20391;
  D.20393 = D.20392 + 1;
  lastp = (guint) D.20393;
  <D.20390>:
  i = param_index;
  goto <D.17815>;
  <D.17814>:
  {
    guint32 flags;

    D.20394 = i + 4294967295;
    D.20395 = (int) D.20394;
    flags = mono_metadata_decode_row_col (paramt, D.20395, 0);
    if (flags != 0) goto <D.20396>; else goto <D.20397>;
    <D.20396>:
    D.20398 = 1;
    return D.20398;
    <D.20397>:
  }
  i = i + 1;
  <D.17815>:
  if (i < lastp) goto <D.17814>; else goto <D.17816>;
  <D.17816>:
  D.20398 = 0;
  return D.20398;
}


mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.20400;
  <unnamed-unsigned:24> D.20401;
  int D.20402;
  <unnamed-unsigned:24> D.20406;
  int D.20407;
  int D.20408;
  unsigned int D.20409;
  int D.20410;
  unsigned int D.20411;
  long unsigned int D.20416;
  long unsigned int D.20417;
  unsigned int D.20418;
  unsigned int param_count.70;
  long unsigned int D.20422;
  long unsigned int D.20423;
  int * D.20424;
  int D.20425;
  int * D.20426;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint32 cols[3];
  guint lastp;
  guint i;
  guint param_index;
  int * pattrs;

  try
    {
      paramt = &m->tables[8];
      methodt = &m->tables[6];
      D.20400 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.20400, 5);
      pattrs = 0B;
      D.20401 = methodt->rows;
      D.20402 = (int) D.20401;
      if (D.20402 > def) goto <D.20403>; else goto <D.20404>;
      <D.20403>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.20405>;
      <D.20404>:
      D.20406 = paramt->rows;
      D.20407 = (int) D.20406;
      D.20408 = D.20407 + 1;
      lastp = (guint) D.20408;
      <D.20405>:
      i = param_index;
      goto <D.17831>;
      <D.17830>:
      D.20409 = i + 4294967295;
      D.20410 = (int) D.20409;
      mono_metadata_decode_row (paramt, D.20410, &cols, 3);
      D.20411 = cols[0];
      if (D.20411 != 0) goto <D.20412>; else goto <D.20413>;
      <D.20412>:
      if (pattrs == 0B) goto <D.20414>; else goto <D.20415>;
      <D.20414>:
      D.20416 = (long unsigned int) param_count;
      D.20417 = D.20416 * 4;
      pattrs = monoeg_malloc0 (D.20417);
      <D.20415>:
      D.20418 = cols[1];
      param_count.70 = (unsigned int) param_count;
      if (D.20418 >= param_count.70) goto <D.20420>; else goto <D.20421>;
      <D.20420>:
      // predicted unlikely by continue predictor.
      goto <D.17829>;
      <D.20421>:
      D.20418 = cols[1];
      D.20422 = (long unsigned int) D.20418;
      D.20423 = D.20422 * 4;
      D.20424 = pattrs + D.20423;
      D.20411 = cols[0];
      D.20425 = (int) D.20411;
      *D.20424 = D.20425;
      <D.20413>:
      <D.17829>:
      i = i + 1;
      <D.17831>:
      if (i < lastp) goto <D.17830>; else goto <D.17832>;
      <D.17832>:
      D.20426 = pattrs;
      return D.20426;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  unsigned char D.20429;
  unsigned char D.20430;
  struct MonoMethodSignature * D.20433;
  unsigned int D.20434;
  _Bool D.20435;
  long int D.20436;
  long int D.20437;
  unsigned int D.20440;
  int D.20441;
  const struct MonoTableInfo * D.20442;
  const char * ptr.71;
  const char * ptr.72;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.20429 = BIT_FIELD_REF <*image, 8, 224>;
      D.20430 = D.20429 & 8;
      if (D.20430 != 0) goto <D.20431>; else goto <D.20432>;
      <D.20431>:
      D.20433 = mono_lookup_dynamic_token (image, token, 0B);
      return D.20433;
      <D.20432>:
      D.20434 = token >> 24;
      D.20435 = D.20434 != 17;
      D.20436 = (long int) D.20435;
      D.20437 = __builtin_expect (D.20436, 0);
      if (D.20437 != 0) goto <D.20438>; else goto <D.20439>;
      <D.20438>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.20439>:
      D.20440 = idx + 4294967295;
      D.20441 = (int) D.20440;
      D.20442 = tables + 272;
      sig = mono_metadata_decode_row_col (D.20442, D.20441, 0);
      ptr.71 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.71;
      ptr.72 = ptr;
      mono_metadata_decode_blob_size (ptr.72, &ptr);
      ptr.72 = ptr;
      D.20433 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.72, 0B);
      return D.20433;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


mono_metadata_parse_signature (struct MonoImage * image, guint32 token)
{
  struct MonoMethodSignature * D.20447;

  D.20447 = mono_metadata_parse_signature_full (image, 0B, token);
  return D.20447;
}


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  int nparams.73;
  long unsigned int D.20450;
  long unsigned int D.20451;
  unsigned int D.20452;
  unsigned int D.20453;
  short unsigned int D.20454;
  struct MonoMethodSignature * D.20455;
  struct MonoMethodSignature * sig;

  nparams.73 = (int) nparams;
  D.20450 = (long unsigned int) nparams.73;
  D.20451 = D.20450 + 2;
  D.20452 = (unsigned int) D.20451;
  D.20453 = D.20452 * 8;
  sig = mono_image_alloc0 (m, D.20453);
  D.20454 = (short unsigned int) nparams;
  sig->param_count = D.20454;
  sig->sentinelpos = -1;
  D.20455 = sig;
  return D.20455;
}


mono_metadata_signature_dup_full (struct MonoImage * image, struct MonoMethodSignature * sig)
{
  struct MonoMethodSignature * D.20457;

  D.20457 = mono_metadata_signature_dup_internal (image, 0B, sig);
  return D.20457;
}


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.20459;
  long unsigned int D.20460;
  long unsigned int D.20461;
  unsigned int D.20462;
  unsigned int D.20463;
  unsigned int sigsize.74;
  unsigned int sigsize.75;
  long unsigned int D.20472;
  long unsigned int D.20473;
  struct MonoMethodSignature * D.20474;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.20459 = sig->param_count;
  D.20460 = (long unsigned int) D.20459;
  D.20461 = D.20460 + 2;
  D.20462 = (unsigned int) D.20461;
  D.20463 = D.20462 * 8;
  sigsize = (int) D.20463;
  if (image != 0B) goto <D.20464>; else goto <D.20465>;
  <D.20464>:
  sigsize.74 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.74);
  goto <D.20467>;
  <D.20465>:
  if (mp != 0B) goto <D.20468>; else goto <D.20469>;
  <D.20468>:
  sigsize.75 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.75);
  goto <D.20471>;
  <D.20469>:
  D.20472 = (long unsigned int) sigsize;
  ret = monoeg_malloc (D.20472);
  <D.20471>:
  <D.20467>:
  D.20473 = (long unsigned int) sigsize;
  memcpy (ret, sig, D.20473);
  D.20474 = ret;
  return D.20474;
}


mono_metadata_signature_dup_mempool (struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  struct MonoMethodSignature * D.20476;

  D.20476 = mono_metadata_signature_dup_internal (0B, mp, sig);
  return D.20476;
}


mono_metadata_signature_dup (struct MonoMethodSignature * sig)
{
  struct MonoMethodSignature * D.20478;

  D.20478 = mono_metadata_signature_dup_full (0B, sig);
  return D.20478;
}


mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.20480;
  short unsigned int D.20481;
  long unsigned int D.20482;
  long unsigned int D.20483;
  unsigned int D.20484;

  D.20481 = sig->param_count;
  D.20482 = (long unsigned int) D.20481;
  D.20483 = D.20482 + 2;
  D.20484 = (unsigned int) D.20483;
  D.20480 = D.20484 * 8;
  return D.20480;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.76;
  char D.20487;
  int D.20488;
  int D.20489;
  int D.20492;
  int D.20495;
  unsigned int D.20498;
  const char * ptr.77;
  unsigned int D.20504;
  int D.20505;
  unsigned char D.20506;
  <unnamed-unsigned:1> D.20507;
  unsigned char D.20508;
  <unnamed-unsigned:1> D.20509;
  unsigned char D.20510;
  <unnamed-unsigned:6> D.20511;
  short unsigned int D.20512;
  int iftmp.78;
  int D.20518;
  short int D.20519;
  struct MonoType * D.20521;
  struct MonoType * D.20522;
  struct MonoMethodSignature * D.20525;
  unsigned char D.20530;
  unsigned char D.20531;
  char * D.20533;
  short int D.20534;
  short int D.20537;
  int iftmp.79;
  sizetype D.20541;
  sizetype D.20542;
  sizetype D.20543;
  int * D.20544;
  int D.20545;
  short int D.20546;
  struct MonoType * D.20548;
  struct MonoType * D.20549;
  short unsigned int D.20554;
  int D.20555;
  short int D.20562;
  unsigned char D.20563;
  <unnamed-unsigned:1> D.20564;
  struct MonoMethodSignature * method;
  int i;
  int * pattrs;
  guint32 hasthis;
  guint32 explicit_this;
  guint32 call_convention;
  guint32 param_count;
  guint32 gen_param_count;
  gboolean is_open;

  pattrs = 0B;
  hasthis = 0;
  explicit_this = 0;
  gen_param_count = 0;
  is_open = 0;
  ptr.76 = ptr;
  D.20487 = *ptr.76;
  D.20488 = (int) D.20487;
  D.20489 = D.20488 & 16;
  if (D.20489 != 0) goto <D.20490>; else goto <D.20491>;
  <D.20490>:
  gen_param_count = 1;
  <D.20491>:
  ptr.76 = ptr;
  D.20487 = *ptr.76;
  D.20488 = (int) D.20487;
  D.20492 = D.20488 & 32;
  if (D.20492 != 0) goto <D.20493>; else goto <D.20494>;
  <D.20493>:
  hasthis = 1;
  <D.20494>:
  ptr.76 = ptr;
  D.20487 = *ptr.76;
  D.20488 = (int) D.20487;
  D.20495 = D.20488 & 64;
  if (D.20495 != 0) goto <D.20496>; else goto <D.20497>;
  <D.20496>:
  explicit_this = 1;
  <D.20497>:
  ptr.76 = ptr;
  D.20487 = *ptr.76;
  D.20498 = (unsigned int) D.20487;
  call_convention = D.20498 & 15;
  ptr.76 = ptr;
  ptr.77 = ptr.76 + 1;
  ptr = ptr.77;
  if (gen_param_count != 0) goto <D.20500>; else goto <D.20501>;
  <D.20500>:
  ptr.76 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.76, &ptr);
  <D.20501>:
  ptr.76 = ptr;
  param_count = mono_metadata_decode_value (ptr.76, &ptr);
  if (def != 0) goto <D.20502>; else goto <D.20503>;
  <D.20502>:
  D.20504 = param_count + 1;
  D.20505 = (int) D.20504;
  pattrs = mono_metadata_get_param_attrs (m, def, D.20505);
  <D.20503>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.20506 = (unsigned char) hasthis;
  D.20507 = (<unnamed-unsigned:1>) D.20506;
  method->hasthis = D.20507;
  D.20508 = (unsigned char) explicit_this;
  D.20509 = (<unnamed-unsigned:1>) D.20508;
  method->explicit_this = D.20509;
  D.20510 = (unsigned char) call_convention;
  D.20511 = (<unnamed-unsigned:6>) D.20510;
  method->call_convention = D.20511;
  D.20512 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.20512;
  if (call_convention != 10) goto <D.20513>; else goto <D.20514>;
  <D.20513>:
  ptr.76 = ptr;
  if (pattrs != 0B) goto <D.20516>; else goto <D.20517>;
  <D.20516>:
  D.20518 = *pattrs;
  D.20519 = (short int) D.20518;
  iftmp.78 = (int) D.20519;
  goto <D.20520>;
  <D.20517>:
  iftmp.78 = 0;
  <D.20520>:
  D.20521 = mono_metadata_parse_type_full (m, container, 4, iftmp.78, ptr.76, &ptr);
  method->ret = D.20521;
  D.20522 = method->ret;
  if (D.20522 == 0B) goto <D.20523>; else goto <D.20524>;
  <D.20523>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20525 = 0B;
  return D.20525;
  <D.20524>:
  D.20522 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.20522);
  <D.20514>:
  i = 0;
  goto <D.17889>;
  <D.17888>:
  ptr.76 = ptr;
  D.20487 = *ptr.76;
  if (D.20487 == 65) goto <D.20526>; else goto <D.20527>;
  <D.20526>:
  D.20530 = BIT_FIELD_REF <*method, 8, 112>;
  D.20531 = D.20530 & 63;
  if (D.20531 != 5) goto <D.20528>; else goto <D.20532>;
  <D.20532>:
  if (def != 0) goto <D.20528>; else goto <D.20529>;
  <D.20528>:
  D.20533 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.20533);
  monoeg_g_free (pattrs);
  D.20525 = 0B;
  return D.20525;
  <D.20529>:
  D.20534 = method->sentinelpos;
  if (D.20534 >= 0) goto <D.20535>; else goto <D.20536>;
  <D.20535>:
  D.20533 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.20533);
  monoeg_g_free (pattrs);
  D.20525 = 0B;
  return D.20525;
  <D.20536>:
  D.20537 = (short int) i;
  method->sentinelpos = D.20537;
  ptr.76 = ptr;
  ptr.77 = ptr.76 + 1;
  ptr = ptr.77;
  <D.20527>:
  ptr.76 = ptr;
  if (pattrs != 0B) goto <D.20539>; else goto <D.20540>;
  <D.20539>:
  D.20541 = (sizetype) i;
  D.20542 = D.20541 + 1;
  D.20543 = D.20542 * 4;
  D.20544 = pattrs + D.20543;
  D.20545 = *D.20544;
  D.20546 = (short int) D.20545;
  iftmp.79 = (int) D.20546;
  goto <D.20547>;
  <D.20540>:
  iftmp.79 = 0;
  <D.20547>:
  D.20548 = mono_metadata_parse_type_full (m, container, 3, iftmp.79, ptr.76, &ptr);
  method->params[i] = D.20548;
  D.20549 = method->params[i];
  if (D.20549 == 0B) goto <D.20550>; else goto <D.20551>;
  <D.20550>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20525 = 0B;
  return D.20525;
  <D.20551>:
  if (is_open == 0) goto <D.20552>; else goto <D.20553>;
  <D.20552>:
  D.20549 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.20549);
  <D.20553>:
  i = i + 1;
  <D.17889>:
  D.20554 = method->param_count;
  D.20555 = (int) D.20554;
  if (D.20555 > i) goto <D.17888>; else goto <D.17890>;
  <D.17890>:
  if (def == 0) goto <D.20556>; else goto <D.20557>;
  <D.20556>:
  D.20530 = BIT_FIELD_REF <*method, 8, 112>;
  D.20531 = D.20530 & 63;
  if (D.20531 == 5) goto <D.20558>; else goto <D.20559>;
  <D.20558>:
  D.20534 = method->sentinelpos;
  if (D.20534 < 0) goto <D.20560>; else goto <D.20561>;
  <D.20560>:
  D.20554 = method->param_count;
  D.20562 = (short int) D.20554;
  method->sentinelpos = D.20562;
  <D.20561>:
  <D.20559>:
  <D.20557>:
  D.20563 = (unsigned char) is_open;
  D.20564 = (<unnamed-unsigned:1>) D.20563;
  method->has_type_parameters = D.20564;
  if (def != 0) goto <D.20565>; else goto <D.20566>;
  <D.20565>:
  D.20530 = BIT_FIELD_REF <*method, 8, 112>;
  D.20531 = D.20530 & 63;
  if (D.20531 == 5) goto <D.20567>; else goto <D.20568>;
  <D.20567>:
  D.20554 = method->param_count;
  D.20562 = (short int) D.20554;
  method->sentinelpos = D.20562;
  <D.20568>:
  <D.20566>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.20569>; else goto <D.20570>;
  <D.20569>:
  ptr.76 = ptr;
  *rptr = ptr.76;
  <D.20570>:
  D.20525 = method;
  return D.20525;
}


mono_metadata_parse_method_signature (struct MonoImage * m, int def, const char * ptr, const char * * rptr)
{
  struct MonoMethodSignature * D.20572;

  D.20572 = mono_metadata_parse_method_signature_full (m, 0B, def, ptr, rptr);
  return D.20572;
}


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.20574;
  struct MonoType * D.20577;
  short unsigned int D.20580;
  int D.20581;
  int i;

  D.20574 = sig->ret;
  if (D.20574 != 0B) goto <D.20575>; else goto <D.20576>;
  <D.20575>:
  D.20574 = sig->ret;
  mono_metadata_free_type (D.20574);
  <D.20576>:
  i = 0;
  goto <D.17905>;
  <D.17904>:
  D.20577 = sig->params[i];
  if (D.20577 != 0B) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  D.20577 = sig->params[i];
  mono_metadata_free_type (D.20577);
  <D.20579>:
  i = i + 1;
  <D.17905>:
  D.20580 = sig->param_count;
  D.20581 = (int) D.20580;
  if (D.20581 > i) goto <D.17904>; else goto <D.17906>;
  <D.17906>:
  monoeg_g_free (sig);
}


mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20582;
  struct MonoMemPool * D.20585;
  void * D.20586;
  void * res;

  mono_image_set_lock (set);
  D.20582 = set->mempool;
  if (D.20582 == 0B) goto <D.20583>; else goto <D.20584>;
  <D.20583>:
  D.20585 = mono_mempool_new_size (1024);
  set->mempool = D.20585;
  <D.20584>:
  D.20582 = set->mempool;
  res = mono_mempool_alloc (D.20582, size);
  mono_image_set_unlock (set);
  D.20586 = res;
  return D.20586;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20588;
  _Bool D.20591;
  long int D.20592;
  long int D.20593;

  {
    int ret;

    D.20588 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.20588);
    if (ret != 0) goto <D.20589>; else goto <D.20590>;
    <D.20589>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20590>:
    D.20591 = ret != 0;
    D.20592 = (long int) D.20591;
    D.20593 = __builtin_expect (D.20592, 0);
    if (D.20593 != 0) goto <D.20594>; else goto <D.20595>;
    <D.20594>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.20595>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20596;
  _Bool D.20599;
  long int D.20600;
  long int D.20601;

  {
    int ret;

    D.20596 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.20596);
    if (ret != 0) goto <D.20597>; else goto <D.20598>;
    <D.20597>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20598>:
    D.20599 = ret != 0;
    D.20600 = (long int) D.20599;
    D.20601 = __builtin_expect (D.20600, 0);
    if (D.20601 != 0) goto <D.20602>; else goto <D.20603>;
    <D.20602>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.20603>:
  }
}


mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20604;
  struct MonoMemPool * D.20607;
  void * D.20608;
  void * res;

  mono_image_set_lock (set);
  D.20604 = set->mempool;
  if (D.20604 == 0B) goto <D.20605>; else goto <D.20606>;
  <D.20605>:
  D.20607 = mono_mempool_new_size (1024);
  set->mempool = D.20607;
  <D.20606>:
  D.20604 = set->mempool;
  res = mono_mempool_alloc0 (D.20604, size);
  mono_image_set_unlock (set);
  D.20608 = res;
  return D.20608;
}


mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.20610;
  struct MonoMemPool * D.20613;
  char * D.20614;
  char * res;

  mono_image_set_lock (set);
  D.20610 = set->mempool;
  if (D.20610 == 0B) goto <D.20611>; else goto <D.20612>;
  <D.20611>:
  D.20613 = mono_mempool_new_size (1024);
  set->mempool = D.20613;
  <D.20612>:
  D.20610 = set->mempool;
  res = mono_mempool_strdup (D.20610, s);
  mono_image_set_unlock (set);
  D.20614 = res;
  return D.20614;
}


mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.20616;
  struct GSList * D.20617;
  struct GHashTable * D.20618;
  struct GHashTable * D.20619;
  struct GHashTable * D.20620;
  struct GHashTable * D.20621;
  void * D.20622;
  struct GSList * D.20623;
  struct GSList * D.20624;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.20616 = gclass_data.image;
      ginst_data.image = D.20616;
      gclass_data.list = 0B;
      D.20617 = gclass_data.list;
      ginst_data.list = D.20617;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.18153>;
      <D.18152>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.20618 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.20618, steal_gclass_in_image, &gclass_data);
        D.20619 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.20619, steal_ginst_in_image, &ginst_data);
        D.20620 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.20620, inflated_method_in_image, image);
        D.20621 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.20621, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.18153>:
      if (l != 0B) goto <D.18152>; else goto <D.18154>;
      <D.18154>:
      l = ginst_data.list;
      goto <D.18156>;
      <D.18155>:
      D.20622 = l->data;
      free_generic_inst (D.20622);
      l = l->next;
      <D.18156>:
      if (l != 0B) goto <D.18155>; else goto <D.18157>;
      <D.18157>:
      l = gclass_data.list;
      goto <D.18159>;
      <D.18158>:
      D.20622 = l->data;
      free_generic_class (D.20622);
      l = l->next;
      <D.18159>:
      if (l != 0B) goto <D.18158>; else goto <D.18160>;
      <D.18160>:
      D.20623 = ginst_data.list;
      monoeg_g_slist_free (D.20623);
      D.20617 = gclass_data.list;
      monoeg_g_slist_free (D.20617);
      D.20624 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.20624);
      l = set_list;
      goto <D.18163>;
      <D.18162>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.18163>:
      if (l != 0B) goto <D.18162>; else goto <D.18164>;
      <D.18164>:
      monoeg_g_slist_free (set_list);
      mono_loader_unlock ();
    }
  finally
    {
      ginst_data = {CLOBBER};
      gclass_data = {CLOBBER};
    }
}


inflated_signature_in_image (void * key, void * value, void * data)
{
  gboolean D.20625;
  int iftmp.80;
  struct MonoMethodSignature * D.20631;
  int D.20632;
  struct MonoGenericInst * D.20634;
  int D.20636;
  struct MonoGenericInst * D.20637;
  int D.20639;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.20631 = sig->sig;
  D.20632 = signature_in_image (D.20631, image);
  if (D.20632 != 0) goto <D.20627>; else goto <D.20633>;
  <D.20633>:
  D.20634 = sig->context.class_inst;
  if (D.20634 != 0B) goto <D.20635>; else goto <D.20628>;
  <D.20635>:
  D.20634 = sig->context.class_inst;
  D.20636 = ginst_in_image (D.20634, image);
  if (D.20636 != 0) goto <D.20627>; else goto <D.20628>;
  <D.20628>:
  D.20637 = sig->context.method_inst;
  if (D.20637 != 0B) goto <D.20638>; else goto <D.20629>;
  <D.20638>:
  D.20637 = sig->context.method_inst;
  D.20639 = ginst_in_image (D.20637, image);
  if (D.20639 != 0) goto <D.20627>; else goto <D.20629>;
  <D.20627>:
  iftmp.80 = 1;
  goto <D.20630>;
  <D.20629>:
  iftmp.80 = 0;
  <D.20630>:
  D.20625 = iftmp.80;
  return D.20625;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.20641;
  gboolean D.20644;
  struct MonoType * D.20645;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.17937>;
      <D.17936>:
      D.20641 = type_in_image (p, image);
      if (D.20641 != 0) goto <D.20642>; else goto <D.20643>;
      <D.20642>:
      D.20644 = 1;
      return D.20644;
      <D.20643>:
      <D.17937>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.17936>; else goto <D.17938>;
      <D.17938>:
      D.20645 = mono_signature_get_return_type (sig);
      D.20644 = type_in_image (D.20645, image);
      return D.20644;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.20648;
  int D.20649;
  gboolean D.20650;
  struct MonoGenericClass * D.20651;
  struct MonoClass * D.20652;
  struct MonoArrayType * D.20653;
  struct MonoClass * D.20654;
  struct MonoMethodSignature * D.20655;
  struct MonoGenericParam * D.20656;
  unsigned char D.20659;
  signed char D.20660;
  _Bool D.20661;
  long int D.20662;
  long int D.20663;
  struct MonoClass * D.20666;
  struct MonoImage * D.20669;
  _Bool D.20670;
  struct MonoImage * D.20671;
  _Bool D.20672;
  struct MonoImage * D.20673;
  _Bool D.20674;
  unsigned char D.20679;
  signed char D.20680;
  _Bool D.20681;
  long int D.20682;
  long int D.20683;
  struct MonoMethod * D.20686;
  struct MonoImage * D.20689;
  _Bool D.20690;
  struct MonoClass * D.20691;
  struct MonoImage * D.20692;
  _Bool D.20693;
  struct MonoClass * D.20694;
  struct MonoImage * D.20695;
  _Bool D.20696;
  void retry = <<< error >>>;

  retry:
  D.20648 = type->type;
  D.20649 = (int) D.20648;
  switch (D.20649) <default: <D.17965>, case 15: <D.17957>, case 19: <D.17961>, case 20: <D.17959>, case 21: <D.17956>, case 27: <D.17960>, case 29: <D.17958>, case 30: <D.17963>>
  <D.17956>:
  D.20651 = type->data.generic_class;
  D.20650 = gclass_in_image (D.20651, image);
  return D.20650;
  <D.17957>:
  type = type->data.type;
  goto retry;
  <D.17958>:
  D.20652 = type->data.klass;
  type = &D.20652->byval_arg;
  goto retry;
  <D.17959>:
  D.20653 = type->data.array;
  D.20654 = D.20653->eklass;
  type = &D.20654->byval_arg;
  goto retry;
  <D.17960>:
  D.20655 = type->data.method;
  D.20650 = signature_in_image (D.20655, image);
  return D.20650;
  <D.17961>:
  {
    struct MonoGenericContainer * container;

    D.20656 = type->data.generic_param;
    container = D.20656->owner;
    if (container != 0B) goto <D.20657>; else goto <D.20658>;
    <D.20657>:
    D.20659 = BIT_FIELD_REF <*container, 8, 280>;
    D.20660 = (signed char) D.20659;
    D.20661 = D.20660 < 0;
    D.20662 = (long int) D.20661;
    D.20663 = __builtin_expect (D.20662, 0);
    if (D.20663 != 0) goto <D.20664>; else goto <D.20665>;
    <D.20664>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.20665>:
    D.20666 = container->owner.klass;
    if (D.20666 == 0B) goto <D.20667>; else goto <D.20668>;
    <D.20667>:
    D.20669 = container->image;
    D.20670 = D.20669 == image;
    D.20650 = (gboolean) D.20670;
    return D.20650;
    <D.20668>:
    D.20666 = container->owner.klass;
    D.20671 = D.20666->image;
    D.20672 = D.20671 == image;
    D.20650 = (gboolean) D.20672;
    return D.20650;
    <D.20658>:
    D.20656 = type->data.generic_param;
    D.20673 = D.20656->image;
    D.20674 = D.20673 == image;
    D.20650 = (gboolean) D.20674;
    return D.20650;
  }
  <D.17963>:
  {
    struct MonoGenericContainer * container;

    D.20656 = type->data.generic_param;
    container = D.20656->owner;
    D.20656 = type->data.generic_param;
    D.20673 = D.20656->image;
    if (D.20673 == image) goto <D.20675>; else goto <D.20676>;
    <D.20675>:
    D.20650 = 1;
    return D.20650;
    <D.20676>:
    if (container != 0B) goto <D.20677>; else goto <D.20678>;
    <D.20677>:
    D.20679 = BIT_FIELD_REF <*container, 8, 280>;
    D.20680 = (signed char) D.20679;
    D.20681 = D.20680 >= 0;
    D.20682 = (long int) D.20681;
    D.20683 = __builtin_expect (D.20682, 0);
    if (D.20683 != 0) goto <D.20684>; else goto <D.20685>;
    <D.20684>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.20685>:
    D.20686 = container->owner.method;
    if (D.20686 == 0B) goto <D.20687>; else goto <D.20688>;
    <D.20687>:
    D.20689 = container->image;
    D.20690 = D.20689 == image;
    D.20650 = (gboolean) D.20690;
    return D.20650;
    <D.20688>:
    D.20686 = container->owner.method;
    D.20691 = D.20686->klass;
    D.20692 = D.20691->image;
    D.20693 = D.20692 == image;
    D.20650 = (gboolean) D.20693;
    return D.20650;
    <D.20678>:
    D.20656 = type->data.generic_param;
    D.20673 = D.20656->image;
    D.20674 = D.20673 == image;
    D.20650 = (gboolean) D.20674;
    return D.20650;
  }
  <D.17965>:
  D.20694 = mono_class_from_mono_type (type);
  D.20695 = D.20694->image;
  D.20696 = D.20695 == image;
  D.20650 = (gboolean) D.20696;
  return D.20650;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.20698;
  int iftmp.81;
  struct MonoClass * D.20703;
  struct MonoImage * D.20704;
  struct MonoGenericInst * D.20706;
  int D.20707;

  D.20703 = gclass->container_class;
  D.20704 = D.20703->image;
  if (D.20704 == image) goto <D.20700>; else goto <D.20705>;
  <D.20705>:
  D.20706 = gclass->context.class_inst;
  D.20707 = ginst_in_image (D.20706, image);
  if (D.20707 != 0) goto <D.20700>; else goto <D.20701>;
  <D.20700>:
  iftmp.81 = 1;
  goto <D.20702>;
  <D.20701>:
  iftmp.81 = 0;
  <D.20702>:
  D.20698 = iftmp.81;
  return D.20698;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.20709;
  int D.20710;
  gboolean D.20713;
  <unnamed-unsigned:22> D.20714;
  int D.20715;
  int i;

  i = 0;
  goto <D.17945>;
  <D.17944>:
  D.20709 = ginst->type_argv[i];
  D.20710 = type_in_image (D.20709, image);
  if (D.20710 != 0) goto <D.20711>; else goto <D.20712>;
  <D.20711>:
  D.20713 = 1;
  return D.20713;
  <D.20712>:
  i = i + 1;
  <D.17945>:
  D.20714 = ginst->type_argc;
  D.20715 = (int) D.20714;
  if (D.20715 > i) goto <D.17944>; else goto <D.17946>;
  <D.17946>:
  D.20713 = 0;
  return D.20713;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.82;
  struct MonoMethod * D.20723;
  struct MonoClass * D.20724;
  struct MonoImage * D.20725;
  struct MonoGenericInst * D.20727;
  int D.20729;
  struct MonoGenericInst * D.20730;
  int D.20732;
  struct MonoMethodSignature * D.20733;
  struct MonoMethodSignature * D.20735;
  int D.20736;
  _Bool D.20737;
  long int D.20738;
  long int D.20739;
  gboolean D.20742;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.20723 = method->declaring;
  D.20724 = D.20723->klass;
  D.20725 = D.20724->image;
  if (D.20725 != image) goto <D.20726>; else goto <D.20718>;
  <D.20726>:
  D.20727 = method->context.class_inst;
  if (D.20727 == 0B) goto <D.20719>; else goto <D.20728>;
  <D.20728>:
  D.20727 = method->context.class_inst;
  D.20729 = ginst_in_image (D.20727, image);
  if (D.20729 == 0) goto <D.20719>; else goto <D.20718>;
  <D.20719>:
  D.20730 = method->context.method_inst;
  if (D.20730 == 0B) goto <D.20720>; else goto <D.20731>;
  <D.20731>:
  D.20730 = method->context.method_inst;
  D.20732 = ginst_in_image (D.20730, image);
  if (D.20732 == 0) goto <D.20720>; else goto <D.20718>;
  <D.20720>:
  D.20733 = MEM[(struct MonoMethod *)method].signature;
  if (D.20733 == 0B) goto <D.20721>; else goto <D.20734>;
  <D.20734>:
  D.20735 = mono_method_signature (method);
  D.20736 = signature_in_image (D.20735, image);
  if (D.20736 == 0) goto <D.20721>; else goto <D.20718>;
  <D.20721>:
  iftmp.82 = 1;
  goto <D.20722>;
  <D.20718>:
  iftmp.82 = 0;
  <D.20722>:
  D.20737 = iftmp.82 != 0;
  D.20738 = (long int) D.20737;
  D.20739 = __builtin_expect (D.20738, 0);
  if (D.20739 != 0) goto <D.20740>; else goto <D.20741>;
  <D.20740>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2559, "method->declaring->klass->image == image || (method->context.class_inst && ginst_in_image (method->context.class_inst, image)) || (method->context.method_inst && ginst_in_image (method->context.method_inst, image)) || (((MonoMethod*)method)->signature && signature_in_image (mono_method_signature ((MonoMethod*)method), image))");
  <D.20741>:
  D.20742 = 1;
  return D.20742;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.20744;
  struct GSList * D.20745;
  gboolean D.20746;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.20744 = user_data->list;
  D.20745 = monoeg_g_slist_prepend (D.20744, ginst);
  user_data->list = D.20745;
  D.20746 = 1;
  return D.20746;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.20748;
  int D.20749;
  _Bool D.20750;
  long int D.20751;
  long int D.20752;
  struct GSList * D.20755;
  struct GSList * D.20756;
  gboolean D.20757;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.20748 = user_data->image;
  D.20749 = gclass_in_image (gclass, D.20748);
  D.20750 = D.20749 == 0;
  D.20751 = (long int) D.20750;
  D.20752 = __builtin_expect (D.20751, 0);
  if (D.20752 != 0) goto <D.20753>; else goto <D.20754>;
  <D.20753>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.20754>:
  D.20755 = user_data->list;
  D.20756 = monoeg_g_slist_prepend (D.20755, gclass);
  user_data->list = D.20756;
  D.20757 = 1;
  return D.20757;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.20759;
  <unnamed-unsigned:22> D.20760;
  int D.20761;
  int i;

  i = 0;
  goto <D.18179>;
  <D.18178>:
  D.20759 = ginst->type_argv[i];
  mono_metadata_free_type (D.20759);
  i = i + 1;
  <D.18179>:
  D.20760 = ginst->type_argc;
  D.20761 = (int) D.20760;
  if (D.20761 > i) goto <D.18178>; else goto <D.18180>;
  <D.18180>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  unsigned char D.20762;
  unsigned char D.20763;
  struct MonoClass * D.20766;
  short unsigned int D.20769;

  D.20762 = BIT_FIELD_REF <*gclass, 8, 192>;
  D.20763 = D.20762 & 1;
  if (D.20763 != 0) goto <D.20764>; else goto <D.20765>;
  <D.20764>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.20765>:
  D.20766 = gclass->cached_class;
  if (D.20766 != 0B) goto <D.20767>; else goto <D.20768>;
  <D.20767>:
  D.20766 = gclass->cached_class;
  D.20769 = D.20766->interface_id;
  if (D.20769 != 0) goto <D.20770>; else goto <D.20771>;
  <D.20770>:
  D.20766 = gclass->cached_class;
  mono_unload_interface_id (D.20766);
  <D.20771>:
  <D.20768>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.20772;
  struct GHashTable * D.20773;
  struct GHashTable * D.20774;
  struct GHashTable * D.20775;
  struct MonoImage * * D.20776;
  long unsigned int D.20777;
  long unsigned int D.20778;
  struct MonoImage * * D.20779;
  struct MonoImage * D.20780;
  struct GSList * D.20781;
  struct GSList * D.20782;
  int D.20783;
  struct GPtrArray * image_sets.83;
  struct MonoMemPool * D.20785;
  struct CRITICAL_SECTION * D.20788;
  int i;

  D.20772 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.20772);
  D.20773 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.20773);
  D.20774 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.20774);
  D.20775 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.20775);
  i = 0;
  goto <D.17995>;
  <D.17994>:
  D.20776 = set->images;
  D.20777 = (long unsigned int) i;
  D.20778 = D.20777 * 8;
  D.20779 = D.20776 + D.20778;
  D.20780 = *D.20779;
  D.20776 = set->images;
  D.20777 = (long unsigned int) i;
  D.20778 = D.20777 * 8;
  D.20779 = D.20776 + D.20778;
  D.20780 = *D.20779;
  D.20781 = D.20780->image_sets;
  D.20782 = monoeg_g_slist_remove (D.20781, set);
  D.20780->image_sets = D.20782;
  i = i + 1;
  <D.17995>:
  D.20783 = set->nimages;
  if (D.20783 > i) goto <D.17994>; else goto <D.17996>;
  <D.17996>:
  image_sets.83 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.83, set);
  D.20785 = set->mempool;
  if (D.20785 != 0B) goto <D.20786>; else goto <D.20787>;
  <D.20786>:
  D.20785 = set->mempool;
  mono_mempool_destroy (D.20785);
  <D.20787>:
  D.20776 = set->images;
  monoeg_g_free (D.20776);
  D.20788 = &set->lock;
  DeleteCriticalSection (D.20788);
  monoeg_g_free (set);
}


mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  int D.20789;
  struct MonoImage * * D.20790;
  struct GHashTable * D.20793;
  struct MonoMethodInflated * D.20794;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.20789 = data.nimages;
      D.20790 = data.images;
      set = get_image_set (D.20790, D.20789);
      collect_data_free (&data);
      if (cache != 0) goto <D.20791>; else goto <D.20792>;
      <D.20791>:
      D.20793 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.20793, method, method, 0);
      D.20794 = method;
      return D.20794;
      <D.20792>:
      D.20793 = set->gmethod_cache;
      D.20794 = monoeg_g_hash_table_lookup (D.20793, method);
      return D.20794;
    }
  finally
    {
      data = {CLOBBER};
    }
}


collect_data_init (struct CollectData * data)
{
  struct MonoImage *[64] * D.20797;

  D.20797 = &data->image_buf;
  data->images = D.20797;
  data->images_len = 64;
  data->nimages = 0;
}


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.20798;
  struct MonoClass * D.20799;
  struct MonoImage * D.20800;
  struct MonoGenericInst * D.20801;
  struct MonoGenericInst * D.20804;
  struct MonoClass * D.20807;
  struct MonoImage * D.20808;
  unsigned char D.20809;
  unsigned char D.20810;
  struct MonoMethodSignature * D.20813;
  struct MonoMethod * m;

  m = method->declaring;
  D.20798 = method->declaring;
  D.20799 = D.20798->klass;
  D.20800 = D.20799->image;
  add_image (D.20800, data);
  D.20801 = method->context.class_inst;
  if (D.20801 != 0B) goto <D.20802>; else goto <D.20803>;
  <D.20802>:
  D.20801 = method->context.class_inst;
  collect_ginst_images (D.20801, data);
  <D.20803>:
  D.20804 = method->context.method_inst;
  if (D.20804 != 0B) goto <D.20805>; else goto <D.20806>;
  <D.20805>:
  D.20804 = method->context.method_inst;
  collect_ginst_images (D.20804, data);
  <D.20806>:
  D.20807 = m->klass;
  D.20808 = D.20807->image;
  D.20809 = BIT_FIELD_REF <*D.20808, 8, 224>;
  D.20810 = D.20809 & 8;
  if (D.20810 != 0) goto <D.20811>; else goto <D.20812>;
  <D.20811>:
  D.20813 = mono_method_signature (m);
  collect_signature_images (D.20813, data);
  <D.20812>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.20814;
  long unsigned int D.20815;
  long unsigned int D.20816;
  struct MonoImage * * D.20817;
  struct MonoImage * D.20818;
  int D.20821;
  int D.20822;
  int D.20825;
  int D.20826;
  long unsigned int D.20827;
  long unsigned int D.20828;
  struct MonoImage * * D.20829;
  int i;

  i = 0;
  goto <D.18043>;
  <D.18042>:
  D.20814 = data->images;
  D.20815 = (long unsigned int) i;
  D.20816 = D.20815 * 8;
  D.20817 = D.20814 + D.20816;
  D.20818 = *D.20817;
  if (D.20818 == image) goto <D.20819>; else goto <D.20820>;
  <D.20819>:
  return;
  <D.20820>:
  i = i + 1;
  <D.18043>:
  D.20821 = data->nimages;
  if (D.20821 > i) goto <D.18042>; else goto <D.18044>;
  <D.18044>:
  D.20821 = data->nimages;
  D.20822 = data->images_len;
  if (D.20821 == D.20822) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  enlarge_data (data);
  <D.20824>:
  D.20814 = data->images;
  D.20821 = data->nimages;
  D.20825 = D.20821;
  D.20826 = D.20825 + 1;
  data->nimages = D.20826;
  D.20827 = (long unsigned int) D.20825;
  D.20828 = D.20827 * 8;
  D.20829 = D.20814 + D.20828;
  *D.20829 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.84;
  int D.20832;
  long unsigned int D.20836;
  long unsigned int D.20837;
  long unsigned int D.20838;
  struct MonoImage * * D.20839;
  struct MonoImage *[64] * D.20840;
  int new_len;
  struct MonoImage * * d;

  D.20832 = data->images_len;
  if (D.20832 > 15) goto <D.20833>; else goto <D.20834>;
  <D.20833>:
  D.20832 = data->images_len;
  iftmp.84 = D.20832 * 2;
  goto <D.20835>;
  <D.20834>:
  iftmp.84 = 16;
  <D.20835>:
  new_len = iftmp.84;
  D.20836 = (long unsigned int) new_len;
  D.20837 = D.20836 * 8;
  d = monoeg_malloc (D.20837);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.20832 = data->images_len;
  D.20838 = (long unsigned int) D.20832;
  D.20839 = data->images;
  memcpy (d, D.20839, D.20838);
  D.20839 = data->images;
  D.20840 = &data->image_buf;
  if (D.20839 != D.20840) goto <D.20841>; else goto <D.20842>;
  <D.20841>:
  D.20839 = data->images;
  monoeg_g_free (D.20839);
  <D.20842>:
  data->images = d;
  data->images_len = new_len;
}


collect_ginst_images (struct MonoGenericInst * ginst, struct CollectData * data)
{
  struct MonoType * D.20843;
  <unnamed-unsigned:22> D.20844;
  int D.20845;
  int i;

  i = 0;
  goto <D.18054>;
  <D.18053>:
  D.20843 = ginst->type_argv[i];
  collect_type_images (D.20843, data);
  i = i + 1;
  <D.18054>:
  D.20844 = ginst->type_argc;
  D.20845 = (int) D.20844;
  if (D.20845 > i) goto <D.18053>; else goto <D.18055>;
  <D.18055>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.20846;
  int D.20847;
  struct MonoGenericClass * D.20848;
  struct MonoClass * D.20849;
  struct MonoArrayType * D.20850;
  struct MonoClass * D.20851;
  struct MonoGenericParam * D.20852;
  unsigned char D.20855;
  signed char D.20856;
  _Bool D.20857;
  long int D.20858;
  long int D.20859;
  struct MonoClass * D.20862;
  struct MonoImage * D.20865;
  struct MonoImage * D.20867;
  struct MonoImage * D.20869;
  struct MonoMethod * D.20874;
  struct MonoImage * D.20877;
  unsigned char D.20879;
  signed char D.20880;
  _Bool D.20881;
  long int D.20882;
  long int D.20883;
  struct MonoClass * D.20886;
  struct MonoImage * D.20887;
  struct MonoClass * D.20889;
  struct MonoImage * D.20890;
  struct MonoImage * D.20891;
  void retry = <<< error >>>;

  retry:
  D.20846 = type->type;
  D.20847 = (int) D.20846;
  switch (D.20847) <default: <D.18095>, case 15: <D.18085>, case 17: <D.18094>, case 18: <D.18093>, case 19: <D.18089>, case 20: <D.18087>, case 21: <D.18083>, case 27: <D.18088>, case 29: <D.18086>, case 30: <D.18091>>
  <D.18083>:
  D.20848 = type->data.generic_class;
  collect_gclass_images (D.20848, data);
  goto <D.18084>;
  <D.18085>:
  type = type->data.type;
  goto retry;
  <D.18086>:
  D.20849 = type->data.klass;
  type = &D.20849->byval_arg;
  goto retry;
  <D.18087>:
  D.20850 = type->data.array;
  D.20851 = D.20850->eklass;
  type = &D.20851->byval_arg;
  goto retry;
  <D.18088>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.18089>:
  {
    struct MonoGenericContainer * container;

    D.20852 = type->data.generic_param;
    container = D.20852->owner;
    if (container != 0B) goto <D.20853>; else goto <D.20854>;
    <D.20853>:
    D.20855 = BIT_FIELD_REF <*container, 8, 280>;
    D.20856 = (signed char) D.20855;
    D.20857 = D.20856 < 0;
    D.20858 = (long int) D.20857;
    D.20859 = __builtin_expect (D.20858, 0);
    if (D.20859 != 0) goto <D.20860>; else goto <D.20861>;
    <D.20860>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.20861>:
    D.20862 = container->owner.klass;
    if (D.20862 == 0B) goto <D.20863>; else goto <D.20864>;
    <D.20863>:
    D.20865 = container->image;
    add_image (D.20865, data);
    goto <D.20866>;
    <D.20864>:
    D.20862 = container->owner.klass;
    D.20867 = D.20862->image;
    add_image (D.20867, data);
    <D.20866>:
    goto <D.20868>;
    <D.20854>:
    D.20852 = type->data.generic_param;
    D.20869 = D.20852->image;
    add_image (D.20869, data);
    <D.20868>:
  }
  goto <D.18084>;
  <D.18091>:
  {
    struct MonoGenericContainer * container;

    D.20852 = type->data.generic_param;
    container = D.20852->owner;
    D.20852 = type->data.generic_param;
    D.20869 = D.20852->image;
    if (D.20869 != 0B) goto <D.20870>; else goto <D.20871>;
    <D.20870>:
    D.20852 = type->data.generic_param;
    D.20869 = D.20852->image;
    add_image (D.20869, data);
    <D.20871>:
    if (container != 0B) goto <D.20872>; else goto <D.20873>;
    <D.20872>:
    D.20874 = container->owner.method;
    if (D.20874 == 0B) goto <D.20875>; else goto <D.20876>;
    <D.20875>:
    D.20877 = container->image;
    add_image (D.20877, data);
    goto <D.20878>;
    <D.20876>:
    D.20879 = BIT_FIELD_REF <*container, 8, 280>;
    D.20880 = (signed char) D.20879;
    D.20881 = D.20880 >= 0;
    D.20882 = (long int) D.20881;
    D.20883 = __builtin_expect (D.20882, 0);
    if (D.20883 != 0) goto <D.20884>; else goto <D.20885>;
    <D.20884>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.20885>:
    D.20874 = container->owner.method;
    D.20886 = D.20874->klass;
    D.20887 = D.20886->image;
    add_image (D.20887, data);
    <D.20878>:
    goto <D.20888>;
    <D.20873>:
    D.20852 = type->data.generic_param;
    D.20869 = D.20852->image;
    add_image (D.20869, data);
    <D.20888>:
  }
  goto <D.18084>;
  <D.18093>:
  <D.18094>:
  D.20889 = mono_class_from_mono_type (type);
  D.20890 = D.20889->image;
  add_image (D.20890, data);
  goto <D.18084>;
  <D.18095>:
  D.20891 = mono_defaults.corlib;
  add_image (D.20891, data);
  <D.18084>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.20892;
  struct MonoImage * D.20893;
  struct MonoGenericInst * D.20894;

  D.20892 = gclass->container_class;
  D.20893 = D.20892->image;
  add_image (D.20893, data);
  D.20894 = gclass->context.class_inst;
  if (D.20894 != 0B) goto <D.20895>; else goto <D.20896>;
  <D.20895>:
  D.20894 = gclass->context.class_inst;
  collect_ginst_images (D.20894, data);
  <D.20896>:
}


collect_signature_images (struct MonoMethodSignature * sig, struct CollectData * data)
{
  struct MonoType * D.20897;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      D.20897 = mono_signature_get_return_type (sig);
      collect_type_images (D.20897, data);
      goto <D.18067>;
      <D.18066>:
      collect_type_images (p, data);
      <D.18067>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.18066>; else goto <D.18068>;
      <D.18068>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.85;
  struct GPtrArray * image_sets.86;
  struct MonoImage * D.20904;
  struct MonoImage * D.20905;
  struct MonoImageSet * mscorlib_image_set.87;
  struct MonoImageSet * D.20911;
  struct MonoImage * * D.20918;
  struct MonoImage * D.20919;
  int D.20920;
  struct MonoImage * * D.20923;
  long unsigned int D.20924;
  long unsigned int D.20925;
  struct MonoImage * * D.20926;
  struct MonoImage * D.20927;
  long unsigned int D.20928;
  long unsigned int D.20929;
  struct MonoImage * * D.20930;
  struct MonoImage * D.20931;
  long unsigned int D.20937;
  long unsigned int D.20938;
  void * D.20939;
  struct CRITICAL_SECTION * D.20940;
  long unsigned int D.20941;
  long unsigned int D.20942;
  struct MonoImage * * D.20943;
  struct MonoImage * * D.20944;
  struct MonoImage * D.20945;
  struct GHashTable * D.20946;
  struct GHashTable * D.20947;
  struct GHashTable * D.20948;
  struct GHashTable * D.20949;
  struct MonoImage * D.20950;
  struct GSList * D.20951;
  struct GSList * D.20952;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.85 = image_sets;
  if (image_sets.85 == 0B) goto <D.20899>; else goto <D.20900>;
  <D.20899>:
  image_sets.86 = monoeg_g_ptr_array_new ();
  image_sets = image_sets.86;
  <D.20900>:
  if (nimages == 1) goto <D.20902>; else goto <D.20903>;
  <D.20902>:
  D.20904 = *images;
  D.20905 = mono_defaults.corlib;
  if (D.20904 == D.20905) goto <D.20906>; else goto <D.20907>;
  <D.20906>:
  mscorlib_image_set.87 = mscorlib_image_set;
  if (mscorlib_image_set.87 != 0B) goto <D.20909>; else goto <D.20910>;
  <D.20909>:
  D.20911 = mscorlib_image_set;
  return D.20911;
  <D.20910>:
  <D.20907>:
  <D.20903>:
  if (nimages == 0) goto <D.20912>; else goto <D.20913>;
  <D.20912>:
  D.20911 = mscorlib_image_set;
  return D.20911;
  <D.20913>:
  D.20904 = *images;
  D.20905 = mono_defaults.corlib;
  if (D.20904 == D.20905) goto <D.20916>; else goto <D.20914>;
  <D.20916>:
  if (nimages > 1) goto <D.20917>; else goto <D.20914>;
  <D.20917>:
  D.20918 = images + 8;
  D.20919 = *D.20918;
  l = D.20919->image_sets;
  goto <D.20915>;
  <D.20914>:
  D.20904 = *images;
  l = D.20904->image_sets;
  <D.20915>:
  set = 0B;
  goto <D.17983>;
  <D.17982>:
  set = l->data;
  D.20920 = set->nimages;
  if (D.20920 == nimages) goto <D.20921>; else goto <D.20922>;
  <D.20921>:
  j = 0;
  goto <D.17980>;
  <D.17979>:
  k = 0;
  goto <D.17977>;
  <D.17976>:
  D.20923 = set->images;
  D.20924 = (long unsigned int) k;
  D.20925 = D.20924 * 8;
  D.20926 = D.20923 + D.20925;
  D.20927 = *D.20926;
  D.20928 = (long unsigned int) j;
  D.20929 = D.20928 * 8;
  D.20930 = images + D.20929;
  D.20931 = *D.20930;
  if (D.20927 == D.20931) goto <D.17975>; else goto <D.20932>;
  <D.20932>:
  k = k + 1;
  <D.17977>:
  if (k < nimages) goto <D.17976>; else goto <D.17975>;
  <D.17975>:
  if (k == nimages) goto <D.17978>; else goto <D.20933>;
  <D.20933>:
  j = j + 1;
  <D.17980>:
  if (j < nimages) goto <D.17979>; else goto <D.17978>;
  <D.17978>:
  if (j == nimages) goto <D.17981>; else goto <D.20934>;
  <D.20934>:
  <D.20922>:
  l = l->next;
  <D.17983>:
  if (l != 0B) goto <D.17982>; else goto <D.17981>;
  <D.17981>:
  if (l == 0B) goto <D.20935>; else goto <D.20936>;
  <D.20935>:
  set = monoeg_malloc0 (104);
  set->nimages = nimages;
  D.20937 = (long unsigned int) nimages;
  D.20938 = D.20937 * 8;
  D.20939 = monoeg_malloc0 (D.20938);
  set->images = D.20939;
  D.20940 = &set->lock;
  InitializeCriticalSection (D.20940);
  i = 0;
  goto <D.17985>;
  <D.17984>:
  D.20923 = set->images;
  D.20941 = (long unsigned int) i;
  D.20942 = D.20941 * 8;
  D.20943 = D.20923 + D.20942;
  D.20941 = (long unsigned int) i;
  D.20942 = D.20941 * 8;
  D.20944 = images + D.20942;
  D.20945 = *D.20944;
  *D.20943 = D.20945;
  i = i + 1;
  <D.17985>:
  if (i < nimages) goto <D.17984>; else goto <D.17986>;
  <D.17986>:
  D.20946 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.20946;
  D.20947 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.20947;
  D.20948 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.20948;
  D.20949 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.20949;
  i = 0;
  goto <D.17988>;
  <D.17987>:
  D.20923 = set->images;
  D.20941 = (long unsigned int) i;
  D.20942 = D.20941 * 8;
  D.20943 = D.20923 + D.20942;
  D.20950 = *D.20943;
  D.20923 = set->images;
  D.20941 = (long unsigned int) i;
  D.20942 = D.20941 * 8;
  D.20943 = D.20923 + D.20942;
  D.20950 = *D.20943;
  D.20951 = D.20950->image_sets;
  D.20952 = monoeg_g_slist_prepend (D.20951, set);
  D.20950->image_sets = D.20952;
  i = i + 1;
  <D.17988>:
  if (i < nimages) goto <D.17987>; else goto <D.17989>;
  <D.17989>:
  image_sets.85 = image_sets;
  monoeg_g_ptr_array_add (image_sets.85, set);
  <D.20936>:
  if (nimages == 1) goto <D.20953>; else goto <D.20954>;
  <D.20953>:
  D.20904 = *images;
  D.20905 = mono_defaults.corlib;
  if (D.20904 == D.20905) goto <D.20955>; else goto <D.20956>;
  <D.20955>:
  mscorlib_image_set = set;
  <D.20956>:
  <D.20954>:
  D.20911 = set;
  return D.20911;
}


free_inflated_signature (struct MonoInflatedMethodSignature * sig)
{
  struct MonoMethodSignature * D.20958;

  D.20958 = sig->sig;
  mono_metadata_free_inflated_signature (D.20958);
  monoeg_g_free (sig);
}


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.20959;
  struct MonoMethodSignature * D.20960;
  gboolean D.20963;
  const struct MonoGenericContext * D.20964;
  const struct MonoGenericContext * D.20965;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.20959 = sig1->sig;
  D.20960 = sig2->sig;
  if (D.20959 != D.20960) goto <D.20961>; else goto <D.20962>;
  <D.20961>:
  D.20963 = 0;
  return D.20963;
  <D.20962>:
  D.20964 = &sig2->context;
  D.20965 = &sig1->context;
  D.20963 = mono_metadata_generic_context_equal (D.20965, D.20964);
  return D.20963;
}


inflated_signature_hash (const void * a)
{
  guint D.20967;
  const struct MonoGenericContext * D.20968;
  unsigned int D.20969;
  struct MonoMethodSignature * D.20970;
  unsigned int D.20971;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.20968 = &sig->context;
  D.20969 = mono_metadata_generic_context_hash (D.20968);
  D.20970 = sig->sig;
  D.20971 = mono_aligned_addr_hash (D.20970);
  D.20967 = D.20969 ^ D.20971;
  return D.20967;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.20973;
  short unsigned int D.20976;
  int D.20977;
  int D.20978;
  short unsigned int D.20981;
  unsigned int D.20982;
  unsigned int D.20983;
  int D.20986;
  struct MonoType * D.20991;
  short unsigned int D.20992;
  int D.20993;
  struct MonoExceptionClause * D.20994;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.20973 = method->signature;
  if (D.20973 != 0B) goto <D.20974>; else goto <D.20975>;
  <D.20974>:
  D.20973 = method->signature;
  mono_metadata_free_inflated_signature (D.20973);
  <D.20975>:
  D.20976 = method->flags;
  D.20977 = (int) D.20976;
  D.20978 = D.20977 & 1024;
  if (D.20978 == 0) goto <D.20979>; else goto <D.20980>;
  <D.20979>:
  D.20981 = method->iflags;
  D.20982 = (unsigned int) D.20981;
  D.20983 = D.20982 & 4099;
  if (D.20983 == 0) goto <D.20984>; else goto <D.20985>;
  <D.20984>:
  D.20976 = method->flags;
  D.20977 = (int) D.20976;
  D.20986 = D.20977 & 8192;
  if (D.20986 == 0) goto <D.20987>; else goto <D.20988>;
  <D.20987>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.20989>; else goto <D.20990>;
    <D.20989>:
    i = 0;
    goto <D.18172>;
    <D.18171>:
    D.20991 = header->locals[i];
    mono_metadata_free_type (D.20991);
    i = i + 1;
    <D.18172>:
    D.20992 = header->num_locals;
    D.20993 = (int) D.20992;
    if (D.20993 > i) goto <D.18171>; else goto <D.18173>;
    <D.18173>:
    D.20994 = header->clauses;
    monoeg_g_free (D.20994);
    monoeg_g_free (header);
    <D.20990>:
  }
  <D.20988>:
  <D.20985>:
  <D.20980>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.20995;
  struct MonoMethod * D.20996;
  gboolean D.20999;
  unsigned char D.21000;
  unsigned char D.21001;
  unsigned char D.21002;
  signed char D.21003;
  const struct MonoGenericContext * D.21006;
  const struct MonoGenericContext * D.21007;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.20995 = ma->declaring;
  D.20996 = mb->declaring;
  if (D.20995 != D.20996) goto <D.20997>; else goto <D.20998>;
  <D.20997>:
  D.20999 = 0;
  return D.20999;
  <D.20998>:
  D.21000 = BIT_FIELD_REF <*ma, 8, 264>;
  D.21001 = BIT_FIELD_REF <*mb, 8, 264>;
  D.21002 = D.21000 ^ D.21001;
  D.21003 = (signed char) D.21002;
  if (D.21003 < 0) goto <D.21004>; else goto <D.21005>;
  <D.21004>:
  D.20999 = 0;
  return D.20999;
  <D.21005>:
  D.21006 = &mb->context;
  D.21007 = &ma->context;
  D.20999 = mono_metadata_generic_context_equal (D.21007, D.21006);
  return D.20999;
}


inflated_method_hash (const void * a)
{
  guint D.21009;
  const struct MonoGenericContext * D.21010;
  unsigned int D.21011;
  struct MonoMethod * D.21012;
  unsigned int D.21013;
  unsigned int D.21014;
  <unnamed-unsigned:1> D.21015;
  unsigned int D.21016;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.21010 = &ma->context;
  D.21011 = mono_metadata_generic_context_hash (D.21010);
  D.21012 = ma->declaring;
  D.21013 = mono_aligned_addr_hash (D.21012);
  D.21014 = D.21011 ^ D.21013;
  D.21015 = ma->method.method.is_mb_open;
  D.21016 = (unsigned int) D.21015;
  D.21009 = D.21014 + D.21016;
  return D.21009;
}


mono_generic_class_equal (const void * ka, const void * kb)
{
  gboolean D.21018;
  const struct MonoGenericClass * a;
  const struct MonoGenericClass * b;

  a = ka;
  b = kb;
  D.21018 = _mono_metadata_generic_class_equal (a, b, 0);
  return D.21018;
}


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.21020;
  struct MonoImage *[64] * D.21021;

  D.21020 = data->images;
  D.21021 = &data->image_buf;
  if (D.21020 != D.21021) goto <D.21022>; else goto <D.21023>;
  <D.21022>:
  D.21020 = data->images;
  monoeg_g_free (D.21020);
  <D.21023>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21024;
  struct MonoGenericInst * D.21025;
  int D.21026;
  struct MonoImage * * D.21027;
  struct GHashTable * D.21028;
  struct MonoMethodSignature * D.21031;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.21024 = context->class_inst;
      helper.context.class_inst = D.21024;
      D.21025 = context->method_inst;
      helper.context.method_inst = D.21025;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.21026 = data.nimages;
      D.21027 = data.images;
      set = get_image_set (D.21027, D.21026);
      collect_data_free (&data);
      D.21028 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.21028, &helper);
      if (res == 0B) goto <D.21029>; else goto <D.21030>;
      <D.21029>:
      res = monoeg_malloc0 (24);
      res->sig = sig;
      D.21024 = context->class_inst;
      res->context.class_inst = D.21024;
      D.21025 = context->method_inst;
      res->context.method_inst = D.21025;
      D.21028 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.21028, res, res, 0);
      <D.21030>:
      mono_loader_unlock ();
      D.21031 = res->sig;
      return D.21031;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.21034;
  struct MonoGenericInst * D.21035;
  struct MonoGenericInst * D.21038;

  D.21034 = sig->sig;
  collect_signature_images (D.21034, data);
  D.21035 = sig->context.class_inst;
  if (D.21035 != 0B) goto <D.21036>; else goto <D.21037>;
  <D.21036>:
  D.21035 = sig->context.class_inst;
  collect_ginst_images (D.21035, data);
  <D.21037>:
  D.21038 = sig->context.method_inst;
  if (D.21038 != 0B) goto <D.21039>; else goto <D.21040>;
  <D.21039>:
  D.21038 = sig->context.method_inst;
  collect_ginst_images (D.21038, data);
  <D.21040>:
}


mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  long unsigned int D.21041;
  long unsigned int D.21042;
  unsigned int D.21043;
  unsigned int D.21044;
  long unsigned int D.21045;
  long unsigned int D.21046;
  struct MonoType * * D.21047;
  struct MonoType * D.21048;
  int D.21049;
  _Bool D.21051;
  long unsigned int D.21052;
  unsigned char D.21053;
  <unnamed-unsigned:1> D.21054;
  unsigned int type_argc.88;
  <unnamed-unsigned:22> D.21056;
  long unsigned int D.21057;
  struct MonoType *[0:] * D.21058;
  int D.21059;
  struct MonoImage * * D.21060;
  struct GHashTable * D.21061;
  unsigned int size.89;
  int next_generic_inst_id.90;
  int next_generic_inst_id.91;
  unsigned int next_generic_inst_id.92;
  struct MonoType * D.21068;
  struct MonoGenericInst * D.21069;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      D.21041 = (long unsigned int) type_argc;
      D.21042 = D.21041 + 1;
      D.21043 = (unsigned int) D.21042;
      D.21044 = D.21043 * 8;
      size = (int) D.21044;
      i = 0;
      goto <D.18213>;
      <D.18212>:
      D.21045 = (long unsigned int) i;
      D.21046 = D.21045 * 8;
      D.21047 = type_argv + D.21046;
      D.21048 = *D.21047;
      D.21049 = mono_class_is_open_constructed_type (D.21048);
      if (D.21049 != 0) goto <D.18211>; else goto <D.21050>;
      <D.21050>:
      i = i + 1;
      <D.18213>:
      if (i < type_argc) goto <D.18212>; else goto <D.18211>;
      <D.18211>:
      D.21051 = i < type_argc;
      is_open = (gboolean) D.21051;
      D.21052 = (long unsigned int) size;
      ginst = __builtin_alloca (D.21052);
      memset (ginst, 0, 8);
      D.21053 = (unsigned char) is_open;
      D.21054 = (<unnamed-unsigned:1>) D.21053;
      ginst->is_open = D.21054;
      type_argc.88 = (unsigned int) type_argc;
      D.21056 = (<unnamed-unsigned:22>) type_argc.88;
      ginst->type_argc = D.21056;
      D.21041 = (long unsigned int) type_argc;
      D.21057 = D.21041 * 8;
      D.21058 = &ginst->type_argv;
      memcpy (D.21058, type_argv, D.21057);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.21059 = data.nimages;
      D.21060 = data.images;
      set = get_image_set (D.21060, D.21059);
      collect_data_free (&data);
      D.21061 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.21061, ginst);
      if (ginst == 0B) goto <D.21062>; else goto <D.21063>;
      <D.21062>:
      size.89 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.89);
      next_generic_inst_id.90 = next_generic_inst_id;
      next_generic_inst_id.91 = next_generic_inst_id.90 + 1;
      next_generic_inst_id = next_generic_inst_id.91;
      next_generic_inst_id.90 = next_generic_inst_id;
      next_generic_inst_id.92 = (unsigned int) next_generic_inst_id.90;
      ginst->id = next_generic_inst_id.92;
      D.21053 = (unsigned char) is_open;
      D.21054 = (<unnamed-unsigned:1>) D.21053;
      ginst->is_open = D.21054;
      type_argc.88 = (unsigned int) type_argc;
      D.21056 = (<unnamed-unsigned:22>) type_argc.88;
      ginst->type_argc = D.21056;
      i = 0;
      goto <D.18215>;
      <D.18214>:
      D.21045 = (long unsigned int) i;
      D.21046 = D.21045 * 8;
      D.21047 = type_argv + D.21046;
      D.21048 = *D.21047;
      D.21068 = mono_metadata_type_dup (0B, D.21048);
      ginst->type_argv[i] = D.21068;
      i = i + 1;
      <D.18215>:
      if (i < type_argc) goto <D.18214>; else goto <D.18216>;
      <D.18216>:
      D.21061 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.21061, ginst, ginst, 0);
      <D.21063>:
      mono_loader_unlock ();
      D.21069 = ginst;
      return D.21069;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.21072;
  <unnamed-unsigned:1> D.21073;
  unsigned char D.21074;
  <unnamed-unsigned:1> D.21075;
  int D.21076;
  struct MonoImage * * D.21077;
  struct GHashTable * D.21078;
  struct MonoClass * D.21079;
  _Bool D.21080;
  long int D.21081;
  long int D.21082;
  struct MonoGenericClass * D.21087;
  struct MonoGenericContainer * D.21091;
  struct MonoGenericInst * D.21092;
  struct MonoGenericClass * gclass;
  struct MonoGenericClass helper;
  gboolean is_tb_open;
  struct MonoImageSet * set;
  struct CollectData data;

  try
    {
      is_tb_open = mono_metadata_is_type_builder_generic_type_definition (container_class, inst, is_dynamic);
      helper.container_class = container_class;
      helper.context.class_inst = inst;
      helper.context.method_inst = 0B;
      D.21072 = (unsigned char) is_dynamic;
      D.21073 = (<unnamed-unsigned:1>) D.21072;
      helper.is_dynamic = D.21073;
      D.21074 = (unsigned char) is_tb_open;
      D.21075 = (<unnamed-unsigned:1>) D.21074;
      helper.is_tb_open = D.21075;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.21076 = data.nimages;
      D.21077 = data.images;
      set = get_image_set (D.21077, D.21076);
      collect_data_free (&data);
      D.21078 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.21078, &helper);
      D.21079 = helper.cached_class;
      D.21080 = D.21079 != 0B;
      D.21081 = (long int) D.21080;
      D.21082 = __builtin_expect (D.21081, 0);
      if (D.21082 != 0) goto <D.21083>; else goto <D.21084>;
      <D.21083>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.21084>:
      if (gclass != 0B) goto <D.21085>; else goto <D.21086>;
      <D.21085>:
      mono_loader_unlock ();
      D.21087 = gclass;
      return D.21087;
      <D.21086>:
      if (is_dynamic != 0) goto <D.21088>; else goto <D.21089>;
      <D.21088>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 88);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.21090>;
      <D.21089>:
      gclass = mono_image_set_alloc0 (set, 48);
      <D.21090>:
      D.21074 = (unsigned char) is_tb_open;
      D.21075 = (<unnamed-unsigned:1>) D.21074;
      gclass->is_tb_open = D.21075;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.21091 = container_class->generic_container;
      D.21092 = D.21091->context.class_inst;
      if (D.21092 == inst) goto <D.21093>; else goto <D.21094>;
      <D.21093>:
      if (is_tb_open == 0) goto <D.21095>; else goto <D.21096>;
      <D.21095>:
      gclass->cached_class = container_class;
      <D.21096>:
      <D.21094>:
      D.21078 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.21078, gclass, gclass, 0);
      mono_loader_unlock ();
      D.21087 = gclass;
      return D.21087;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_metadata_is_type_builder_generic_type_definition (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.21102;
  unsigned char D.21103;
  <unnamed-signed:31> D.21105;
  int D.21106;
  <unnamed-unsigned:22> D.21107;
  int D.21108;
  gboolean D.21109;
  struct MonoGenericInst * D.21110;
  _Bool D.21111;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.21099>; else goto <D.21101>;
  <D.21101>:
  D.21102 = BIT_FIELD_REF <*container_class, 8, 256>;
  D.21103 = D.21102 & 128;
  if (D.21103 != 0) goto <D.21099>; else goto <D.21104>;
  <D.21104>:
  D.21105 = container->type_argc;
  D.21106 = (int) D.21105;
  D.21107 = inst->type_argc;
  D.21108 = (int) D.21107;
  if (D.21106 != D.21108) goto <D.21099>; else goto <D.21100>;
  <D.21099>:
  D.21109 = 0;
  return D.21109;
  <D.21100>:
  D.21110 = container->context.class_inst;
  D.21111 = D.21110 == inst;
  D.21109 = (gboolean) D.21111;
  return D.21109;
}


mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned char D.21113;
  unsigned char D.21114;
  struct MonoGenericInst * D.21117;
  <unnamed-unsigned:22> D.21118;
  long unsigned int D.21119;
  long unsigned int D.21120;
  long unsigned int D.21121;
  long unsigned int D.21122;
  struct MonoType * * D.21123;
  struct MonoType * D.21124;
  struct MonoType * D.21125;
  int D.21126;
  int D.21128;
  struct MonoType * D.21129;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.21113 = BIT_FIELD_REF <*ginst, 8, 48>;
  D.21114 = D.21113 & 64;
  if (D.21114 == 0) goto <D.21115>; else goto <D.21116>;
  <D.21115>:
  D.21117 = ginst;
  return D.21117;
  <D.21116>:
  D.21118 = ginst->type_argc;
  D.21119 = (long unsigned int) D.21118;
  D.21120 = D.21119 * 8;
  type_argv = monoeg_malloc0 (D.21120);
  i = 0;
  goto <D.18245>;
  <D.18244>:
  D.21121 = (long unsigned int) i;
  D.21122 = D.21121 * 8;
  D.21123 = type_argv + D.21122;
  D.21124 = ginst->type_argv[i];
  D.21125 = mono_class_inflate_generic_type_checked (D.21124, context, error);
  *D.21123 = D.21125;
  D.21126 = mono_error_ok (error);
  if (D.21126 == 0) goto cleanup; else goto <D.21127>;
  <D.21127>:
  count = count + 1;
  i = i + 1;
  <D.18245>:
  D.21118 = ginst->type_argc;
  D.21128 = (int) D.21118;
  if (D.21128 > i) goto <D.18244>; else goto <D.18246>;
  <D.18246>:
  D.21118 = ginst->type_argc;
  D.21128 = (int) D.21118;
  nginst = mono_metadata_get_generic_inst (D.21128, type_argv);
  cleanup:
  i = 0;
  goto <D.18248>;
  <D.18247>:
  D.21121 = (long unsigned int) i;
  D.21122 = D.21121 * 8;
  D.21123 = type_argv + D.21122;
  D.21129 = *D.21123;
  mono_metadata_free_type (D.21129);
  i = i + 1;
  <D.18248>:
  if (i < count) goto <D.18247>; else goto <D.18249>;
  <D.18249>:
  monoeg_g_free (type_argv);
  D.21117 = nginst;
  return D.21117;
}


mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  long unsigned int D.21131;
  long unsigned int D.21132;
  const char * ptr.93;
  struct MonoGenericInst * D.21136;
  long unsigned int D.21137;
  long unsigned int D.21138;
  struct MonoType * * D.21139;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

  D.21131 = (long unsigned int) count;
  D.21132 = D.21131 * 8;
  type_argv = monoeg_malloc0 (D.21132);
  i = 0;
  goto <D.18262>;
  <D.18261>:
  {
    struct MonoType * t;

    ptr.93 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.93, &ptr);
    if (t == 0B) goto <D.21134>; else goto <D.21135>;
    <D.21134>:
    monoeg_g_free (type_argv);
    D.21136 = 0B;
    return D.21136;
    <D.21135>:
    D.21137 = (long unsigned int) i;
    D.21138 = D.21137 * 8;
    D.21139 = type_argv + D.21138;
    *D.21139 = t;
  }
  i = i + 1;
  <D.18262>:
  if (i < count) goto <D.18261>; else goto <D.18263>;
  <D.18263>:
  if (rptr != 0B) goto <D.21140>; else goto <D.21141>;
  <D.21140>:
  ptr.93 = ptr;
  *rptr = ptr.93;
  <D.21141>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.21136 = ginst;
  return D.21136;
}


mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.94;
  struct MonoType * D.21146;
  unsigned char D.21147;
  int D.21148;
  struct MonoClass * D.21149;
  struct MonoType * D.21150;
  struct MonoType * D.21153;
  struct MonoType * cached;

  type_cache.94 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.94, type);
  if (cached != 0B) goto <D.21144>; else goto <D.21145>;
  <D.21144>:
  D.21146 = cached;
  return D.21146;
  <D.21145>:
  D.21147 = type->type;
  D.21148 = (int) D.21147;
  switch (D.21148) <default: <D.21156>, case 17: <D.18294>, case 18: <D.18293>>
  <D.18293>:
  <D.18294>:
  D.21149 = type->data.klass;
  D.21150 = &D.21149->byval_arg;
  if (D.21150 == type) goto <D.21151>; else goto <D.21152>;
  <D.21151>:
  D.21146 = type;
  return D.21146;
  <D.21152>:
  D.21149 = type->data.klass;
  D.21153 = &D.21149->this_arg;
  if (D.21153 == type) goto <D.21154>; else goto <D.21155>;
  <D.21154>:
  D.21146 = type;
  return D.21146;
  <D.21155>:
  goto <D.18295>;
  <D.21156>:
  <D.18295>:
  D.21146 = 0B;
  return D.21146;
}


mono_metadata_free_type (struct MonoType * type)
{
  unsigned char D.21162;
  int D.21163;
  struct MonoClass * D.21164;
  struct MonoType * D.21168;
  struct MonoType * D.21170;
  struct MonoType * D.21171;
  struct MonoMethodSignature * D.21172;
  struct MonoArrayType * D.21173;

  if (type >= &builtin_types) goto <D.21158>; else goto <D.21159>;
  <D.21158>:
  if (type < &MEM[(void *)&builtin_types + 544B]) goto <D.21160>; else goto <D.21161>;
  <D.21160>:
  return;
  <D.21161>:
  <D.21159>:
  D.21162 = type->type;
  D.21163 = (int) D.21162;
  switch (D.21163) <default: <D.21174>, case 14: <D.18345>, case 15: <D.18349>, case 17: <D.18348>, case 18: <D.18347>, case 20: <D.18351>, case 27: <D.18350>, case 28: <D.18344>>
  <D.18344>:
  <D.18345>:
  D.21164 = type->data.klass;
  if (D.21164 == 0B) goto <D.18346>; else goto <D.21165>;
  <D.21165>:
  <D.18347>:
  <D.18348>:
  D.21164 = type->data.klass;
  D.21168 = &D.21164->byval_arg;
  if (D.21168 == type) goto <D.21166>; else goto <D.21169>;
  <D.21169>:
  D.21164 = type->data.klass;
  D.21170 = &D.21164->this_arg;
  if (D.21170 == type) goto <D.21166>; else goto <D.21167>;
  <D.21166>:
  return;
  <D.21167>:
  goto <D.18346>;
  <D.18349>:
  D.21171 = type->data.type;
  mono_metadata_free_type (D.21171);
  goto <D.18346>;
  <D.18350>:
  D.21172 = type->data.method;
  mono_metadata_free_method_signature (D.21172);
  goto <D.18346>;
  <D.18351>:
  D.21173 = type->data.array;
  mono_metadata_free_array (D.21173);
  goto <D.18346>;
  <D.21174>:
  <D.18346>:
  monoeg_g_free (type);
}


mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  unsigned char D.21176;
  unsigned char D.21177;
  short unsigned int D.21180;
  int D.21181;
  int D.21182;
  short unsigned int D.21184;
  unsigned int D.21185;
  unsigned int D.21186;
  int D.21188;
  gboolean D.21189;
  short unsigned int D.21190;
  short unsigned int D.21191;
  unsigned int D.21196;
  <unnamed-unsigned:15> D.21197;
  int D.21198;
  _Bool D.21199;
  int D.21200;
  unsigned int D.21201;
  int D.21202;
  struct MonoClass * D.21203;
  int D.21204;
  struct MonoTableInfo * D.21205;
  int D.21206;
  _Bool D.21209;
  long int D.21210;
  long int D.21211;
  int D.21214;
  unsigned char D.21215;
  unsigned int D.21216;
  unsigned int D.21217;
  int D.21218;
  int D.21219;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.18382>;
  <D.18381>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.18382>:
  D.21176 = BIT_FIELD_REF <*method, 8, 264>;
  D.21177 = D.21176 & 16;
  if (D.21177 != 0) goto <D.18381>; else goto <D.18383>;
  <D.18383>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.21180 = method->flags;
  D.21181 = (int) D.21180;
  D.21182 = D.21181 & 1024;
  if (D.21182 != 0) goto <D.21178>; else goto <D.21183>;
  <D.21183>:
  D.21184 = method->iflags;
  D.21185 = (unsigned int) D.21184;
  D.21186 = D.21185 & 4099;
  if (D.21186 != 0) goto <D.21178>; else goto <D.21187>;
  <D.21187>:
  D.21180 = method->flags;
  D.21181 = (int) D.21180;
  D.21188 = D.21181 & 8192;
  if (D.21188 != 0) goto <D.21178>; else goto <D.21179>;
  <D.21178>:
  D.21189 = 0;
  return D.21189;
  <D.21179>:
  D.21190 = BIT_FIELD_REF <*method, 16, 256>;
  D.21191 = D.21190 & 1148;
  if (D.21191 != 0) goto <D.21192>; else goto <D.21193>;
  <D.21192>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.21194>; else goto <D.21195>;
    <D.21194>:
    D.21189 = 0;
    return D.21189;
    <D.21195>:
    D.21196 = header->code_size;
    summary->code_size = D.21196;
    D.21197 = header->num_clauses;
    D.21198 = (int) D.21197;
    D.21199 = D.21198 > 0;
    D.21200 = (int) D.21199;
    summary->has_clauses = D.21200;
    D.21189 = 1;
    return D.21189;
  }
  <D.21193>:
  D.21201 = method->token;
  D.21202 = (int) D.21201;
  idx = D.21202 & 16777215;
  D.21203 = method->klass;
  img = D.21203->image;
  D.21204 = idx + -1;
  D.21205 = &img->tables[6];
  rva = mono_metadata_decode_row_col (D.21205, D.21204, 0);
  D.21206 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.21206 == 0) goto <D.21207>; else goto <D.21208>;
  <D.21207>:
  D.21189 = 0;
  return D.21189;
  <D.21208>:
  ptr = mono_image_rva_map (img, rva);
  D.21209 = ptr == 0B;
  D.21210 = (long int) D.21209;
  D.21211 = __builtin_expect (D.21210, 0);
  if (D.21211 != 0) goto <D.21212>; else goto <D.21213>;
  <D.21212>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.21213>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.21214 = (int) format;
  switch (D.21214) <default: <D.18388>, case 2: <D.18385>, case 3: <D.18387>>
  <D.18385>:
  ptr = ptr + 1;
  D.21215 = flags >> 2;
  D.21216 = (unsigned int) D.21215;
  summary->code_size = D.21216;
  goto <D.18386>;
  <D.18387>:
  fat_flags = MEM[(const guint16 *)ptr];
  ptr = ptr + 4;
  D.21217 = MEM[(const guint32 *)ptr];
  summary->code_size = D.21217;
  D.21218 = (int) fat_flags;
  D.21219 = D.21218 & 8;
  if (D.21219 != 0) goto <D.21220>; else goto <D.21221>;
  <D.21220>:
  summary->has_clauses = 1;
  <D.21221>:
  goto <D.18386>;
  <D.18388>:
  D.21189 = 0;
  return D.21189;
  <D.18386>:
  D.21189 = 1;
  return D.21189;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.21225;
  int D.21226;
  unsigned char D.21227;
  unsigned int D.21228;
  short unsigned int D.21229;
  int D.21230;
  short unsigned int D.21231;
  int D.21232;
  int D.21233;
  int D.21237;
  sizetype D.21239;
  unsigned int D.21242;
  unsigned int D.21243;
  <unnamed-unsigned:24> D.21246;
  int D.21247;
  unsigned int D.21249;
  int D.21250;
  const char * locals_ptr.95;
  const char * locals_ptr.96;
  unsigned int D.21259;
  char D.21260;
  const char * locals_ptr.97;
  unsigned int D.21264;
  long unsigned int D.21265;
  int num_clauses.98;
  long unsigned int D.21267;
  long unsigned int D.21268;
  long unsigned int D.21269;
  long unsigned int D.21270;
  long unsigned int D.21271;
  short unsigned int D.21272;
  struct MonoType * D.21273;
  struct MonoType * D.21274;
  long unsigned int D.21278;
  long unsigned int D.21279;
  short unsigned int D.21280;
  <unnamed-unsigned:15> D.21281;
  unsigned char D.21282;
  <unnamed-unsigned:1> D.21283;
  short unsigned int D.21286;
  int D.21287;
  long unsigned int D.21288;
  short unsigned int D.21289;
  <unnamed-unsigned:15> D.21290;
  struct MonoMethodHeader * mh;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;
  guint32 local_var_sig_tok;
  guint32 max_stack;
  guint32 code_size;
  guint32 init_locals;
  const unsigned char * code;
  struct MonoExceptionClause * clauses;
  int hsize;
  int num_clauses;
  struct MonoTableInfo * t;
  guint32 cols[1];

  try
    {
      flags = MEM[(const unsigned char *)ptr];
      format = flags & 3;
      clauses = 0B;
      num_clauses = 0;
      t = &m->tables[17];
      if (ptr == 0B) goto <D.21223>; else goto <D.21224>;
      <D.21223>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.21225 = 0B;
      return D.21225;
      <D.21224>:
      D.21226 = (int) format;
      switch (D.21226) <default: <D.18411>, case 2: <D.18408>, case 3: <D.18409>>
      <D.18408>:
      mh = monoeg_malloc0 (32);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.21227 = flags >> 2;
      D.21228 = (unsigned int) D.21227;
      mh->code_size = D.21228;
      mh->code = ptr;
      D.21225 = mh;
      return D.21225;
      <D.18409>:
      fat_flags = MEM[(const guint16 *)ptr];
      ptr = ptr + 2;
      D.21229 = fat_flags >> 12;
      D.21230 = (int) D.21229;
      hsize = D.21230 & 15;
      D.21231 = MEM[(const guint16 *)ptr];
      max_stack = (guint32) D.21231;
      ptr = ptr + 2;
      code_size = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      local_var_sig_tok = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      D.21232 = (int) fat_flags;
      D.21233 = D.21232 & 16;
      if (D.21233 != 0) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      init_locals = 1;
      goto <D.21236>;
      <D.21235>:
      init_locals = 0;
      <D.21236>:
      code = ptr;
      D.21232 = (int) fat_flags;
      D.21237 = D.21232 & 8;
      if (D.21237 == 0) goto <D.18410>; else goto <D.21238>;
      <D.21238>:
      D.21239 = (sizetype) code_size;
      ptr = code + D.21239;
      goto <D.18410>;
      <D.18411>:
      D.21225 = 0B;
      return D.21225;
      <D.18410>:
      if (local_var_sig_tok != 0) goto <D.21240>; else goto <D.21241>;
      <D.21240>:
      {
        int idx;

        D.21242 = local_var_sig_tok & 16777215;
        D.21243 = D.21242 + 4294967295;
        idx = (int) D.21243;
        D.21246 = t->rows;
        D.21247 = (int) D.21246;
        if (D.21247 <= idx) goto <D.21244>; else goto <D.21248>;
        <D.21248>:
        if (idx < 0) goto <D.21244>; else goto <D.21245>;
        <D.21244>:
        D.21225 = 0B;
        return D.21225;
        <D.21245>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.21249 = cols[0];
        D.21250 = mono_verifier_verify_standalone_signature (m, D.21249, 0B);
        if (D.21250 == 0) goto <D.21251>; else goto <D.21252>;
        <D.21251>:
        D.21225 = 0B;
        return D.21225;
        <D.21252>:
      }
      <D.21241>:
      D.21232 = (int) fat_flags;
      D.21237 = D.21232 & 8;
      if (D.21237 != 0) goto <D.21253>; else goto <D.21254>;
      <D.21253>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.21254>:
      if (local_var_sig_tok != 0) goto <D.21255>; else goto <D.21256>;
      <D.21255>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.21249 = cols[0];
            locals_ptr.95 = mono_metadata_blob_heap (m, D.21249);
            locals_ptr = locals_ptr.95;
            locals_ptr.96 = locals_ptr;
            D.21259 = mono_metadata_decode_blob_size (locals_ptr.96, &locals_ptr);
            bsize = (int) D.21259;
            locals_ptr.96 = locals_ptr;
            D.21260 = *locals_ptr.96;
            if (D.21260 != 7) goto <D.21261>; else goto <D.21262>;
            <D.21261>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.21262>:
            locals_ptr.96 = locals_ptr;
            locals_ptr.97 = locals_ptr.96 + 1;
            locals_ptr = locals_ptr.97;
            locals_ptr.96 = locals_ptr;
            D.21264 = mono_metadata_decode_value (locals_ptr.96, &locals_ptr);
            len = (int) D.21264;
            D.21265 = (long unsigned int) len;
            num_clauses.98 = num_clauses;
            D.21267 = (long unsigned int) num_clauses.98;
            D.21268 = D.21267 * 4;
            D.21269 = D.21265 + D.21268;
            D.21270 = D.21269 + 4;
            D.21271 = D.21270 * 8;
            mh = monoeg_malloc0 (D.21271);
            D.21272 = (short unsigned int) len;
            mh->num_locals = D.21272;
            i = 0;
            goto <D.18418>;
            <D.18417>:
            locals_ptr.96 = locals_ptr;
            D.21273 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.96, &locals_ptr);
            mh->locals[i] = D.21273;
            D.21274 = mh->locals[i];
            if (D.21274 == 0B) goto <D.21275>; else goto <D.21276>;
            <D.21275>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.21225 = 0B;
            return D.21225;
            <D.21276>:
            i = i + 1;
            <D.18418>:
            if (i < len) goto <D.18417>; else goto <D.18419>;
            <D.18419>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.21277>;
      <D.21256>:
      num_clauses.98 = num_clauses;
      D.21267 = (long unsigned int) num_clauses.98;
      D.21278 = D.21267 + 1;
      D.21279 = D.21278 * 32;
      mh = monoeg_malloc0 (D.21279);
      <D.21277>:
      mh->code = code;
      mh->code_size = code_size;
      D.21280 = (short unsigned int) max_stack;
      D.21281 = (<unnamed-unsigned:15>) D.21280;
      mh->max_stack = D.21281;
      mh->is_transient = 1;
      D.21282 = (unsigned char) init_locals;
      D.21283 = (<unnamed-unsigned:1>) D.21282;
      mh->init_locals = D.21283;
      if (clauses != 0B) goto <D.21284>; else goto <D.21285>;
      <D.21284>:
      {
        struct MonoExceptionClause * clausesp;

        D.21286 = mh->num_locals;
        D.21287 = (int) D.21286;
        clausesp = &mh->locals[D.21287];
        num_clauses.98 = num_clauses;
        D.21267 = (long unsigned int) num_clauses.98;
        D.21288 = D.21267 * 32;
        memcpy (clausesp, clauses, D.21288);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.98 = num_clauses;
        D.21289 = (short unsigned int) num_clauses.98;
        D.21290 = (<unnamed-unsigned:15>) D.21289;
        mh->num_clauses = D.21290;
      }
      <D.21285>:
      D.21225 = mh;
      return D.21225;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.21295;
  const unsigned char * D.21298;
  unsigned char D.21299;
  int D.21300;
  int D.21301;
  const unsigned char * D.21302;
  unsigned char D.21303;
  int D.21304;
  int D.21305;
  int D.21306;
  unsigned char D.21307;
  int D.21308;
  int D.21309;
  int D.21311;
  int iftmp.99;
  unsigned int D.21317;
  unsigned int D.21319;
  int D.21320;
  long unsigned int D.21321;
  long unsigned int D.21322;
  long unsigned int D.21323;
  long unsigned int D.21324;
  unsigned int D.21327;
  unsigned int D.21328;
  unsigned int D.21329;
  unsigned int D.21330;
  unsigned int D.21331;
  short unsigned int D.21333;
  unsigned int D.21334;
  const guint16 * D.21335;
  short unsigned int D.21336;
  unsigned int D.21337;
  const unsigned char * D.21338;
  unsigned char D.21339;
  unsigned int D.21340;
  const guint16 * D.21341;
  short unsigned int D.21342;
  unsigned int D.21343;
  const unsigned char * D.21344;
  unsigned char D.21345;
  unsigned int D.21346;
  unsigned int D.21347;
  struct MonoClass * iftmp.100;
  signed char sect_data_flags.101;
  unsigned int D.21361;
  sizetype D.21362;
  struct MonoExceptionClause * D.21364;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.18369>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.21295 = (int) sect_data_flags;
  is_fat = D.21295 & 64;
  if (is_fat != 0) goto <D.21296>; else goto <D.21297>;
  <D.21296>:
  D.21298 = ptr + 2;
  D.21299 = *D.21298;
  D.21300 = (int) D.21299;
  D.21301 = D.21300 << 16;
  D.21302 = ptr + 1;
  D.21303 = *D.21302;
  D.21304 = (int) D.21303;
  D.21305 = D.21304 << 8;
  D.21306 = D.21301 | D.21305;
  D.21307 = *ptr;
  D.21308 = (int) D.21307;
  D.21309 = D.21306 | D.21308;
  sect_data_len = (guint32) D.21309;
  ptr = ptr + 3;
  goto <D.21310>;
  <D.21297>:
  D.21307 = *ptr;
  sect_data_len = (guint32) D.21307;
  ptr = ptr + 1;
  <D.21310>:
  D.21295 = (int) sect_data_flags;
  D.21311 = D.21295 & 1;
  if (D.21311 != 0) goto <D.21312>; else goto <D.21313>;
  <D.21312>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.21315>; else goto <D.21316>;
    <D.21315>:
    D.21317 = sect_data_len / 24;
    iftmp.99 = (int) D.21317;
    goto <D.21318>;
    <D.21316>:
    D.21319 = sect_data_len / 12;
    iftmp.99 = (int) D.21319;
    <D.21318>:
    *num_clauses = iftmp.99;
    D.21320 = *num_clauses;
    D.21321 = (long unsigned int) D.21320;
    D.21322 = D.21321 * 32;
    clauses = monoeg_malloc0 (D.21322);
    i = 0;
    goto <D.18367>;
    <D.18366>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      D.21323 = (long unsigned int) i;
      D.21324 = D.21323 * 32;
      ec = clauses + D.21324;
      if (is_fat != 0) goto <D.21325>; else goto <D.21326>;
      <D.21325>:
      D.21327 = MEM[(const guint32 *)p];
      ec->flags = D.21327;
      D.21328 = MEM[(const guint32 *)p + 4B];
      ec->try_offset = D.21328;
      D.21329 = MEM[(const guint32 *)p + 8B];
      ec->try_len = D.21329;
      D.21330 = MEM[(const guint32 *)p + 12B];
      ec->handler_offset = D.21330;
      D.21331 = MEM[(const guint32 *)p + 16B];
      ec->handler_len = D.21331;
      tof_value = MEM[(const guint32 *)p + 20B];
      p = p + 24;
      goto <D.21332>;
      <D.21326>:
      D.21333 = MEM[(const guint16 *)p];
      D.21334 = (unsigned int) D.21333;
      ec->flags = D.21334;
      D.21335 = p + 2;
      D.21336 = *D.21335;
      D.21337 = (unsigned int) D.21336;
      ec->try_offset = D.21337;
      D.21338 = p + 4;
      D.21339 = *D.21338;
      D.21340 = (unsigned int) D.21339;
      ec->try_len = D.21340;
      D.21341 = p + 5;
      D.21342 = *D.21341;
      D.21343 = (unsigned int) D.21342;
      ec->handler_offset = D.21343;
      D.21344 = p + 7;
      D.21345 = *D.21344;
      D.21346 = (unsigned int) D.21345;
      ec->handler_len = D.21346;
      tof_value = MEM[(const guint32 *)p + 8B];
      p = p + 12;
      <D.21332>:
      D.21347 = ec->flags;
      if (D.21347 == 1) goto <D.21348>; else goto <D.21349>;
      <D.21348>:
      ec->data.filter_offset = tof_value;
      goto <D.21350>;
      <D.21349>:
      D.21347 = ec->flags;
      if (D.21347 == 0) goto <D.21351>; else goto <D.21352>;
      <D.21351>:
      if (tof_value != 0) goto <D.21354>; else goto <D.21355>;
      <D.21354>:
      iftmp.100 = mono_class_get (m, tof_value);
      goto <D.21356>;
      <D.21355>:
      iftmp.100 = 0B;
      <D.21356>:
      ec->data.catch_class = iftmp.100;
      goto <D.21357>;
      <D.21352>:
      ec->data.catch_class = 0B;
      <D.21357>:
      <D.21350>:
    }
    i = i + 1;
    <D.18367>:
    D.21320 = *num_clauses;
    if (D.21320 > i) goto <D.18366>; else goto <D.18368>;
    <D.18368>:
  }
  <D.21313>:
  sect_data_flags.101 = (signed char) sect_data_flags;
  if (sect_data_flags.101 < 0) goto <D.21359>; else goto <D.21360>;
  <D.21359>:
  D.21361 = sect_data_len + 4294967292;
  D.21362 = (sizetype) D.21361;
  ptr = ptr + D.21362;
  goto <D.21363>;
  <D.21360>:
  D.21364 = clauses;
  return D.21364;
  <D.21363>:
  goto <D.18369>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.21366;
  const unsigned char * D.21367;
  long unsigned int D.21368;
  long unsigned int D.21369;

  D.21367 = ptr + 3;
  D.21368 = (long unsigned int) D.21367;
  D.21369 = D.21368 & 18446744073709551612;
  D.21366 = (const unsigned char *) D.21369;
  return D.21366;
}


mono_metadata_parse_mh (struct MonoImage * m, const char * ptr)
{
  struct MonoMethodHeader * D.21371;
  struct MonoMethodHeader * res;

  mono_loader_lock ();
  res = mono_metadata_parse_mh_full (m, 0B, ptr);
  mono_loader_unlock ();
  D.21371 = res;
  return D.21371;
}


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  unsigned char D.21373;
  unsigned char D.21374;
  struct MonoType * D.21377;
  short unsigned int D.21378;
  int D.21379;
  int i;

  D.21373 = BIT_FIELD_REF <*mh, 8, 104>;
  D.21374 = D.21373 & 128;
  if (D.21374 != 0) goto <D.21375>; else goto <D.21376>;
  <D.21375>:
  i = 0;
  goto <D.18431>;
  <D.18430>:
  D.21377 = mh->locals[i];
  mono_metadata_free_type (D.21377);
  i = i + 1;
  <D.18431>:
  D.21378 = mh->num_locals;
  D.21379 = (int) D.21378;
  if (D.21379 > i) goto <D.18430>; else goto <D.18432>;
  <D.18432>:
  monoeg_g_free (mh);
  <D.21376>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.21382;
  <unnamed-unsigned:15> D.21385;
  unsigned int D.21386;
  const unsigned char * D.21387;

  if (code_size != 0B) goto <D.21380>; else goto <D.21381>;
  <D.21380>:
  D.21382 = header->code_size;
  *code_size = D.21382;
  <D.21381>:
  if (max_stack != 0B) goto <D.21383>; else goto <D.21384>;
  <D.21383>:
  D.21385 = header->max_stack;
  D.21386 = (unsigned int) D.21385;
  *max_stack = D.21386;
  <D.21384>:
  D.21387 = header->code;
  return D.21387;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.21391;
  unsigned int D.21392;
  <unnamed-unsigned:1> D.21395;
  int D.21396;
  struct MonoType * * D.21397;

  if (num_locals != 0B) goto <D.21389>; else goto <D.21390>;
  <D.21389>:
  D.21391 = header->num_locals;
  D.21392 = (unsigned int) D.21391;
  *num_locals = D.21392;
  <D.21390>:
  if (init_locals != 0B) goto <D.21393>; else goto <D.21394>;
  <D.21393>:
  D.21395 = header->init_locals;
  D.21396 = (int) D.21395;
  *init_locals = D.21396;
  <D.21394>:
  D.21397 = &header->locals;
  return D.21397;
}


mono_method_header_get_num_clauses (struct MonoMethodHeader * header)
{
  int D.21399;
  <unnamed-unsigned:15> D.21400;

  D.21400 = header->num_clauses;
  D.21399 = (int) D.21400;
  return D.21399;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  short unsigned int D.21405;
  short unsigned int D.21406;
  int D.21407;
  void * D.21408;
  struct MonoExceptionClause * D.21411;
  <unnamed-unsigned:15> D.21412;
  long unsigned int D.21413;
  long unsigned int D.21414;
  struct MonoExceptionClause * D.21415;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.21402>; else goto <D.21404>;
  <D.21404>:
  D.21405 = BIT_FIELD_REF <*header, 16, 112>;
  D.21406 = D.21405 & 32767;
  if (D.21406 == 0) goto <D.21402>; else goto <D.21403>;
  <D.21402>:
  D.21407 = 0;
  return D.21407;
  <D.21403>:
  D.21408 = *iter;
  if (D.21408 == 0B) goto <D.21409>; else goto <D.21410>;
  <D.21409>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.21407 = 1;
  return D.21407;
  <D.21410>:
  sc = *iter;
  sc = sc + 32;
  D.21411 = header->clauses;
  D.21412 = header->num_clauses;
  D.21413 = (long unsigned int) D.21412;
  D.21414 = D.21413 * 32;
  D.21415 = D.21411 + D.21414;
  if (D.21415 > sc) goto <D.21416>; else goto <D.21417>;
  <D.21416>:
  *iter = sc;
  *clause = *sc;
  D.21407 = 1;
  return D.21407;
  <D.21417>:
  D.21407 = 0;
  return D.21407;
}


mono_metadata_parse_field_type (struct MonoImage * m, short int field_flags, const char * ptr, const char * * rptr)
{
  struct MonoType * D.21419;
  int D.21420;

  D.21420 = (int) field_flags;
  D.21419 = mono_metadata_parse_type (m, 5, D.21420, ptr, rptr);
  return D.21419;
}


mono_metadata_parse_param (struct MonoImage * m, const char * ptr, const char * * rptr)
{
  struct MonoType * D.21422;

  D.21422 = mono_metadata_parse_type (m, 3, 0, ptr, rptr);
  return D.21422;
}


mono_metadata_token_from_dor (guint32 dor_index)
{
  uint32_t D.21424;
  guint32 table;
  guint32 idx;

  table = dor_index & 3;
  idx = dor_index >> 2;
  switch (table) <default: <D.18472>, case 0: <D.18469>, case 1: <D.18470>, case 2: <D.18471>>
  <D.18469>:
  D.21424 = idx | 33554432;
  return D.21424;
  <D.18470>:
  D.21424 = idx | 16777216;
  return D.21424;
  <D.18471>:
  D.21424 = idx | 452984832;
  return D.21424;
  <D.18472>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 3753);
  D.21424 = 0;
  return D.21424;
}


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.21426;
  uint32_t D.21429;
  int index.102;
  int D.21431;
  unsigned char D.21432;
  unsigned char D.21433;
  int D.21436;
  unsigned int D.21437;
  int D.21438;
  unsigned char D.21439;
  long unsigned int D.21440;
  <unnamed-unsigned:24> D.21441;
  long unsigned int D.21442;
  void * D.21443;
  unsigned int D.21446;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21426 = tdef->base;
      if (D.21426 == 0B) goto <D.21427>; else goto <D.21428>;
      <D.21427>:
      D.21429 = 0;
      return D.21429;
      <D.21428>:
      index.102 = (int) index;
      D.21431 = index.102 & 16777215;
      loc.idx = D.21431;
      loc.col_idx = 4;
      loc.t = tdef;
      D.21432 = BIT_FIELD_REF <*meta, 8, 224>;
      D.21433 = D.21432 & 32;
      if (D.21433 != 0) goto <D.21434>; else goto <D.21435>;
      <D.21434>:
      D.21436 = loc.idx;
      D.21437 = search_ptr_table (meta, 3, D.21436);
      D.21438 = (int) D.21437;
      loc.idx = D.21438;
      <D.21435>:
      D.21439 = tdef->row_size;
      D.21440 = (long unsigned int) D.21439;
      D.21441 = tdef->rows;
      D.21442 = (long unsigned int) D.21441;
      D.21426 = tdef->base;
      D.21443 = mono_binary_search (&loc, D.21426, D.21442, D.21440, typedef_locator);
      if (D.21443 == 0B) goto <D.21444>; else goto <D.21445>;
      <D.21444>:
      D.21429 = 0;
      return D.21429;
      <D.21445>:
      D.21446 = loc.result;
      D.21429 = D.21446 + 1;
      return D.21429;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  long int bb.103;
  struct MonoTableInfo * D.21450;
  const char * D.21451;
  long int D.21452;
  long int D.21453;
  unsigned char D.21454;
  long int D.21455;
  long int D.21456;
  int D.21457;
  unsigned int D.21458;
  int D.21459;
  unsigned int D.21460;
  int D.21463;
  int D.21464;
  <unnamed-unsigned:24> D.21465;
  int D.21466;
  unsigned int typedef_index.104;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.103 = (long int) bb;
  D.21450 = loc->t;
  D.21451 = D.21450->base;
  D.21452 = (long int) D.21451;
  D.21453 = bb.103 - D.21452;
  D.21450 = loc->t;
  D.21454 = D.21450->row_size;
  D.21455 = (long int) D.21454;
  D.21456 = D.21453 / D.21455;
  typedef_index = (int) D.21456;
  D.21457 = loc->col_idx;
  D.21458 = (unsigned int) D.21457;
  D.21450 = loc->t;
  col = mono_metadata_decode_row_col (D.21450, typedef_index, D.21458);
  D.21459 = loc->idx;
  D.21460 = (unsigned int) D.21459;
  if (D.21460 < col) goto <D.21461>; else goto <D.21462>;
  <D.21461>:
  D.21463 = -1;
  return D.21463;
  <D.21462>:
  D.21464 = typedef_index + 1;
  D.21450 = loc->t;
  D.21465 = D.21450->rows;
  D.21466 = (int) D.21465;
  if (D.21464 < D.21466) goto <D.21467>; else goto <D.21468>;
  <D.21467>:
  D.21457 = loc->col_idx;
  D.21458 = (unsigned int) D.21457;
  D.21464 = typedef_index + 1;
  D.21450 = loc->t;
  col_next = mono_metadata_decode_row_col (D.21450, D.21464, D.21458);
  D.21459 = loc->idx;
  D.21460 = (unsigned int) D.21459;
  if (D.21460 >= col_next) goto <D.21469>; else goto <D.21470>;
  <D.21469>:
  D.21463 = 1;
  return D.21463;
  <D.21470>:
  if (col == col_next) goto <D.21471>; else goto <D.21472>;
  <D.21471>:
  D.21463 = 1;
  return D.21463;
  <D.21472>:
  <D.21468>:
  typedef_index.104 = (unsigned int) typedef_index;
  loc->result = typedef_index.104;
  D.21463 = 0;
  return D.21463;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.21475;
  unsigned int idx.105;
  <unnamed-unsigned:24> D.21478;
  int D.21479;
  guint32 D.21482;
  int D.21483;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.18513>;
  <D.18512>:
  D.21475 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.105 = (unsigned int) idx;
  if (D.21475 == idx.105) goto <D.18511>; else goto <D.21477>;
  <D.21477>:
  i = i + 1;
  <D.18513>:
  D.21478 = ptrdef->rows;
  D.21479 = (int) D.21478;
  if (D.21479 > i) goto <D.18512>; else goto <D.18511>;
  <D.18511>:
  D.21478 = ptrdef->rows;
  D.21479 = (int) D.21478;
  if (D.21479 > i) goto <D.21480>; else goto <D.21481>;
  <D.21480>:
  D.21483 = i + 1;
  D.21482 = (guint32) D.21483;
  return D.21482;
  <D.21481>:
  D.21482 = (guint32) idx;
  return D.21482;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.21485;
  uint32_t D.21488;
  int index.106;
  int D.21490;
  unsigned char D.21491;
  unsigned char D.21492;
  int D.21495;
  unsigned int D.21496;
  int D.21497;
  unsigned char D.21498;
  long unsigned int D.21499;
  <unnamed-unsigned:24> D.21500;
  long unsigned int D.21501;
  void * D.21502;
  unsigned int D.21505;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21485 = tdef->base;
      if (D.21485 == 0B) goto <D.21486>; else goto <D.21487>;
      <D.21486>:
      D.21488 = 0;
      return D.21488;
      <D.21487>:
      index.106 = (int) index;
      D.21490 = index.106 & 16777215;
      loc.idx = D.21490;
      loc.col_idx = 5;
      loc.t = tdef;
      D.21491 = BIT_FIELD_REF <*meta, 8, 224>;
      D.21492 = D.21491 & 32;
      if (D.21492 != 0) goto <D.21493>; else goto <D.21494>;
      <D.21493>:
      D.21495 = loc.idx;
      D.21496 = search_ptr_table (meta, 5, D.21495);
      D.21497 = (int) D.21496;
      loc.idx = D.21497;
      <D.21494>:
      D.21498 = tdef->row_size;
      D.21499 = (long unsigned int) D.21498;
      D.21500 = tdef->rows;
      D.21501 = (long unsigned int) D.21500;
      D.21485 = tdef->base;
      D.21502 = mono_binary_search (&loc, D.21485, D.21501, D.21499, typedef_locator);
      if (D.21502 == 0B) goto <D.21503>; else goto <D.21504>;
      <D.21503>:
      D.21488 = 0;
      return D.21488;
      <D.21504>:
      D.21505 = loc.result;
      D.21488 = D.21505 + 1;
      return D.21488;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_interfaces_from_typedef_full (struct MonoImage * meta, guint32 index, struct MonoClass * * * interfaces, guint * count, gboolean heap_alloc_result, struct MonoGenericContext * context)
{
  const char * D.21508;
  gboolean D.21511;
  int index.107;
  int D.21513;
  unsigned char D.21514;
  long unsigned int D.21515;
  <unnamed-unsigned:24> D.21516;
  long unsigned int D.21517;
  void * D.21518;
  int D.21521;
  unsigned int D.21522;
  unsigned int D.21523;
  int D.21524;
  unsigned int D.21525;
  int pos.108;
  unsigned int D.21528;
  unsigned int D.21529;
  unsigned int D.21531;
  unsigned int D.21534;
  long unsigned int D.21535;
  long unsigned int D.21536;
  unsigned int D.21538;
  unsigned int D.21540;
  unsigned int D.21541;
  struct MonoClass * * D.21544;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 start;
  guint32 pos;
  guint32 cols[2];
  struct MonoClass * * result;

  try
    {
      tdef = &meta->tables[9];
      *interfaces = 0B;
      *count = 0;
      D.21508 = tdef->base;
      if (D.21508 == 0B) goto <D.21509>; else goto <D.21510>;
      <D.21509>:
      D.21511 = 1;
      return D.21511;
      <D.21510>:
      index.107 = (int) index;
      D.21513 = index.107 & 16777215;
      loc.idx = D.21513;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21514 = tdef->row_size;
      D.21515 = (long unsigned int) D.21514;
      D.21516 = tdef->rows;
      D.21517 = (long unsigned int) D.21516;
      D.21508 = tdef->base;
      D.21518 = mono_binary_search (&loc, D.21508, D.21517, D.21515, table_locator);
      if (D.21518 == 0B) goto <D.21519>; else goto <D.21520>;
      <D.21519>:
      D.21511 = 1;
      return D.21511;
      <D.21520>:
      start = loc.result;
      goto <D.18542>;
      <D.18541>:
      D.21521 = loc.idx;
      D.21522 = (unsigned int) D.21521;
      D.21523 = start + 4294967295;
      D.21524 = (int) D.21523;
      D.21525 = mono_metadata_decode_row_col (tdef, D.21524, 0);
      if (D.21522 == D.21525) goto <D.21526>; else goto <D.18540>;
      <D.21526>:
      start = start + 4294967295;
      <D.18542>:
      if (start != 0) goto <D.18541>; else goto <D.18540>;
      <D.18540>:
      pos = start;
      goto <D.18545>;
      <D.18544>:
      pos.108 = (int) pos;
      mono_metadata_decode_row (tdef, pos.108, &cols, 2);
      D.21528 = cols[0];
      D.21521 = loc.idx;
      D.21529 = (unsigned int) D.21521;
      if (D.21528 != D.21529) goto <D.18543>; else goto <D.21530>;
      <D.21530>:
      pos = pos + 1;
      <D.18545>:
      D.21516 = tdef->rows;
      D.21531 = (unsigned int) D.21516;
      if (D.21531 > pos) goto <D.18544>; else goto <D.18543>;
      <D.18543>:
      if (heap_alloc_result != 0) goto <D.21532>; else goto <D.21533>;
      <D.21532>:
      D.21534 = pos - start;
      D.21535 = (long unsigned int) D.21534;
      D.21536 = D.21535 * 8;
      result = monoeg_malloc0 (D.21536);
      goto <D.21537>;
      <D.21533>:
      D.21534 = pos - start;
      D.21538 = D.21534 * 8;
      result = mono_image_alloc0 (meta, D.21538);
      <D.21537>:
      pos = start;
      goto <D.18549>;
      <D.18548>:
      {
        struct MonoClass * iface;

        pos.108 = (int) pos;
        mono_metadata_decode_row (tdef, pos.108, &cols, 2);
        D.21528 = cols[0];
        D.21521 = loc.idx;
        D.21529 = (unsigned int) D.21521;
        if (D.21528 != D.21529) goto <D.18547>; else goto <D.21539>;
        <D.21539>:
        D.21540 = cols[1];
        D.21541 = mono_metadata_token_from_dor (D.21540);
        iface = mono_class_get_full (meta, D.21541, context);
        if (iface == 0B) goto <D.21542>; else goto <D.21543>;
        <D.21542>:
        D.21511 = 0;
        return D.21511;
        <D.21543>:
        D.21534 = pos - start;
        D.21535 = (long unsigned int) D.21534;
        D.21536 = D.21535 * 8;
        D.21544 = result + D.21536;
        *D.21544 = iface;
        pos = pos + 1;
      }
      <D.18549>:
      D.21516 = tdef->rows;
      D.21531 = (unsigned int) D.21516;
      if (D.21531 > pos) goto <D.18548>; else goto <D.18547>;
      <D.18547>:
      D.21534 = pos - start;
      *count = D.21534;
      *interfaces = result;
      D.21511 = 1;
      return D.21511;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  long int bb.109;
  struct MonoTableInfo * D.21548;
  const char * D.21549;
  long int D.21550;
  long int D.21551;
  unsigned char D.21552;
  long int D.21553;
  long int D.21554;
  int D.21555;
  unsigned int D.21556;
  int table_index.110;
  int D.21558;
  unsigned int D.21559;
  int D.21562;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.109 = (long int) bb;
  D.21548 = loc->t;
  D.21549 = D.21548->base;
  D.21550 = (long int) D.21549;
  D.21551 = bb.109 - D.21550;
  D.21548 = loc->t;
  D.21552 = D.21548->row_size;
  D.21553 = (long int) D.21552;
  D.21554 = D.21551 / D.21553;
  table_index = (guint32) D.21554;
  D.21555 = loc->col_idx;
  D.21556 = (unsigned int) D.21555;
  table_index.110 = (int) table_index;
  D.21548 = loc->t;
  col = mono_metadata_decode_row_col (D.21548, table_index.110, D.21556);
  D.21558 = loc->idx;
  D.21559 = (unsigned int) D.21558;
  if (D.21559 == col) goto <D.21560>; else goto <D.21561>;
  <D.21560>:
  loc->result = table_index;
  D.21562 = 0;
  return D.21562;
  <D.21561>:
  D.21558 = loc->idx;
  D.21559 = (unsigned int) D.21558;
  if (D.21559 < col) goto <D.21563>; else goto <D.21564>;
  <D.21563>:
  D.21562 = -1;
  return D.21562;
  <D.21564>:
  D.21562 = 1;
  return D.21562;
}


mono_metadata_interfaces_from_typedef (struct MonoImage * meta, guint32 index, guint * count)
{
  struct MonoClass * * D.21568;
  struct MonoClass * * interfaces;
  gboolean rv;

  try
    {
      mono_loader_lock ();
      rv = mono_metadata_interfaces_from_typedef_full (meta, index, &interfaces, count, 1, 0B);
      mono_loader_unlock ();
      if (rv != 0) goto <D.21566>; else goto <D.21567>;
      <D.21566>:
      D.21568 = interfaces;
      return D.21568;
      <D.21567>:
      D.21568 = 0B;
      return D.21568;
    }
  finally
    {
      interfaces = {CLOBBER};
    }
}


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.21571;
  uint32_t D.21574;
  int index.111;
  int D.21576;
  unsigned char D.21577;
  long unsigned int D.21578;
  <unnamed-unsigned:24> D.21579;
  long unsigned int D.21580;
  void * D.21581;
  unsigned int D.21584;
  int D.21585;
  unsigned int D.21586;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.21571 = tdef->base;
      if (D.21571 == 0B) goto <D.21572>; else goto <D.21573>;
      <D.21572>:
      D.21574 = 0;
      return D.21574;
      <D.21573>:
      index.111 = (int) index;
      D.21576 = index.111 & 16777215;
      loc.idx = D.21576;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21577 = tdef->row_size;
      D.21578 = (long unsigned int) D.21577;
      D.21579 = tdef->rows;
      D.21580 = (long unsigned int) D.21579;
      D.21571 = tdef->base;
      D.21581 = mono_binary_search (&loc, D.21571, D.21580, D.21578, table_locator);
      if (D.21581 == 0B) goto <D.21582>; else goto <D.21583>;
      <D.21582>:
      D.21574 = 0;
      return D.21574;
      <D.21583>:
      D.21584 = loc.result;
      D.21585 = (int) D.21584;
      D.21586 = mono_metadata_decode_row_col (tdef, D.21585, 1);
      D.21574 = D.21586 | 33554432;
      return D.21574;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.21589;
  uint32_t D.21592;
  unsigned int D.21593;
  int D.21594;
  unsigned int D.21595;
  <unnamed-unsigned:24> D.21597;
  unsigned int D.21598;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.21589 = tdef->base;
  if (D.21589 == 0B) goto <D.21590>; else goto <D.21591>;
  <D.21590>:
  D.21592 = 0;
  return D.21592;
  <D.21591>:
  start = start_index;
  goto <D.18573>;
  <D.18572>:
  D.21593 = start + 4294967295;
  D.21594 = (int) D.21593;
  D.21595 = mono_metadata_decode_row_col (tdef, D.21594, 1);
  if (D.21595 == class_index) goto <D.18571>; else goto <D.21596>;
  <D.21596>:
  start = start + 1;
  <D.18573>:
  D.21597 = tdef->rows;
  D.21598 = (unsigned int) D.21597;
  if (D.21598 >= start) goto <D.18572>; else goto <D.18571>;
  <D.18571>:
  D.21597 = tdef->rows;
  D.21598 = (unsigned int) D.21597;
  if (D.21598 < start) goto <D.21599>; else goto <D.21600>;
  <D.21599>:
  D.21592 = 0;
  return D.21592;
  <D.21600>:
  D.21592 = start;
  return D.21592;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.21602;
  uint32_t D.21605;
  int index.112;
  int D.21607;
  unsigned char D.21608;
  long unsigned int D.21609;
  <unnamed-unsigned:24> D.21610;
  long unsigned int D.21611;
  void * D.21612;
  unsigned int D.21615;
  int D.21616;
  unsigned int D.21619;
  unsigned int D.21622;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.21602 = tdef->base;
      if (D.21602 == 0B) goto <D.21603>; else goto <D.21604>;
      <D.21603>:
      D.21605 = 0;
      return D.21605;
      <D.21604>:
      index.112 = (int) index;
      D.21607 = index.112 & 16777215;
      loc.idx = D.21607;
      loc.col_idx = 2;
      loc.t = tdef;
      D.21608 = tdef->row_size;
      D.21609 = (long unsigned int) D.21608;
      D.21610 = tdef->rows;
      D.21611 = (long unsigned int) D.21610;
      D.21602 = tdef->base;
      D.21612 = mono_binary_search (&loc, D.21602, D.21611, D.21609, table_locator);
      if (D.21612 == 0B) goto <D.21613>; else goto <D.21614>;
      <D.21613>:
      D.21605 = 0;
      return D.21605;
      <D.21614>:
      D.21615 = loc.result;
      D.21616 = (int) D.21615;
      mono_metadata_decode_row (tdef, D.21616, &cols, 3);
      if (packing != 0B) goto <D.21617>; else goto <D.21618>;
      <D.21617>:
      D.21619 = cols[0];
      *packing = D.21619;
      <D.21618>:
      if (size != 0B) goto <D.21620>; else goto <D.21621>;
      <D.21620>:
      D.21622 = cols[1];
      *size = D.21622;
      <D.21621>:
      D.21615 = loc.result;
      D.21605 = D.21615 + 1;
      return D.21605;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21625;
  uint32_t D.21628;
  int index.113;
  unsigned char D.21630;
  long unsigned int D.21631;
  <unnamed-unsigned:24> D.21632;
  long unsigned int D.21633;
  void * D.21634;
  unsigned int D.21637;
  unsigned int D.21638;
  int D.21640;
  unsigned int D.21641;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.21625 = tdef->base;
      if (D.21625 == 0B) goto <D.21626>; else goto <D.21627>;
      <D.21626>:
      D.21628 = 0;
      return D.21628;
      <D.21627>:
      index.113 = (int) index;
      loc.idx = index.113;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21630 = tdef->row_size;
      D.21631 = (long unsigned int) D.21630;
      D.21632 = tdef->rows;
      D.21633 = (long unsigned int) D.21632;
      D.21625 = tdef->base;
      D.21634 = mono_binary_search (&loc, D.21625, D.21633, D.21631, table_locator);
      if (D.21634 == 0B) goto <D.21635>; else goto <D.21636>;
      <D.21635>:
      D.21628 = 0;
      return D.21628;
      <D.21636>:
      goto <D.18590>;
      <D.18589>:
      D.21637 = loc.result;
      D.21638 = D.21637 + 4294967295;
      loc.result = D.21638;
      <D.18590>:
      D.21637 = loc.result;
      if (D.21637 != 0) goto <D.21639>; else goto <D.18591>;
      <D.21639>:
      D.21637 = loc.result;
      D.21638 = D.21637 + 4294967295;
      D.21640 = (int) D.21638;
      D.21641 = mono_metadata_decode_row_col (tdef, D.21640, 0);
      if (D.21641 == index) goto <D.18589>; else goto <D.18591>;
      <D.18591>:
      D.21637 = loc.result;
      D.21628 = D.21637 + 1;
      return D.21628;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21644;
  uint32_t D.21647;
  int index.114;
  unsigned char D.21649;
  long unsigned int D.21650;
  <unnamed-unsigned:24> D.21651;
  long unsigned int D.21652;
  void * D.21653;
  unsigned int D.21656;
  unsigned int D.21657;
  int D.21659;
  unsigned int D.21660;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.21644 = tdef->base;
      if (D.21644 == 0B) goto <D.21645>; else goto <D.21646>;
      <D.21645>:
      D.21647 = 4294967295;
      return D.21647;
      <D.21646>:
      index.114 = (int) index;
      loc.idx = index.114;
      loc.col_idx = 1;
      loc.t = tdef;
      D.21649 = tdef->row_size;
      D.21650 = (long unsigned int) D.21649;
      D.21651 = tdef->rows;
      D.21652 = (long unsigned int) D.21651;
      D.21644 = tdef->base;
      D.21653 = mono_binary_search (&loc, D.21644, D.21652, D.21650, declsec_locator);
      if (D.21653 == 0B) goto <D.21654>; else goto <D.21655>;
      <D.21654>:
      D.21647 = 4294967295;
      return D.21647;
      <D.21655>:
      goto <D.18599>;
      <D.18598>:
      D.21656 = loc.result;
      D.21657 = D.21656 + 4294967295;
      loc.result = D.21657;
      <D.18599>:
      D.21656 = loc.result;
      if (D.21656 != 0) goto <D.21658>; else goto <D.18600>;
      <D.21658>:
      D.21656 = loc.result;
      D.21657 = D.21656 + 4294967295;
      D.21659 = (int) D.21657;
      D.21660 = mono_metadata_decode_row_col (tdef, D.21659, 1);
      if (D.21660 == index) goto <D.18598>; else goto <D.18600>;
      <D.18600>:
      D.21647 = loc.result;
      return D.21647;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  long int bb.115;
  struct MonoTableInfo * D.21664;
  const char * D.21665;
  long int D.21666;
  long int D.21667;
  unsigned char D.21668;
  long int D.21669;
  long int D.21670;
  int D.21671;
  unsigned int D.21672;
  int table_index.116;
  int D.21674;
  unsigned int D.21675;
  int D.21678;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.115 = (long int) bb;
  D.21664 = loc->t;
  D.21665 = D.21664->base;
  D.21666 = (long int) D.21665;
  D.21667 = bb.115 - D.21666;
  D.21664 = loc->t;
  D.21668 = D.21664->row_size;
  D.21669 = (long int) D.21668;
  D.21670 = D.21667 / D.21669;
  table_index = (guint32) D.21670;
  D.21671 = loc->col_idx;
  D.21672 = (unsigned int) D.21671;
  table_index.116 = (int) table_index;
  D.21664 = loc->t;
  col = mono_metadata_decode_row_col (D.21664, table_index.116, D.21672);
  D.21674 = loc->idx;
  D.21675 = (unsigned int) D.21674;
  if (D.21675 == col) goto <D.21676>; else goto <D.21677>;
  <D.21676>:
  loc->result = table_index;
  D.21678 = 0;
  return D.21678;
  <D.21677>:
  D.21674 = loc->idx;
  D.21675 = (unsigned int) D.21674;
  if (D.21675 < col) goto <D.21679>; else goto <D.21680>;
  <D.21679>:
  D.21678 = -1;
  return D.21678;
  <D.21680>:
  D.21678 = 1;
  return D.21678;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.21684;
  unsigned char D.21685;
  unsigned char D.21686;
  unsigned char D.21689;
  int D.21690;
  struct MonoClass * D.21691;
  unsigned char D.21692;
  unsigned char D.21693;
  struct MonoType * D.21696;
  struct MonoClass * D.21697;
  unsigned char D.21698;
  unsigned char D.21699;
  unsigned char D.21702;
  struct MonoType * D.21705;
  struct MonoClass * D.21706;

  if (t == 0B) goto <D.21682>; else goto <D.21683>;
  <D.21682>:
  *align = 1;
  D.21684 = 0;
  return D.21684;
  <D.21683>:
  D.21685 = BIT_FIELD_REF <*t, 8, 88>;
  D.21686 = D.21685 & 64;
  if (D.21686 != 0) goto <D.21687>; else goto <D.21688>;
  <D.21687>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 8;
    D.21684 = 8;
    return D.21684;
  }
  <D.21688>:
  D.21689 = t->type;
  D.21690 = (int) D.21689;
  switch (D.21690) <default: <D.18676>, case 1: <D.18608>, case 2: <D.18609>, case 3: <D.18618>, case 4: <D.18613>, case 5: <D.18614>, case 6: <D.18619>, case 7: <D.18620>, case 8: <D.18624>, case 9: <D.18625>, case 10: <D.18633>, case 11: <D.18634>, case 12: <D.18629>, case 13: <D.18638>, case 14: <D.18647>, case 15: <D.18658>, case 17: <D.18655>, case 18: <D.18656>, case 19: <D.18671>, case 20: <D.18660>, case 21: <D.18665>, case 22: <D.18664>, case 24: <D.18642>, case 25: <D.18643>, case 27: <D.18659>, case 28: <D.18651>, case 29: <D.18657>, case 30: <D.18672>>
  {
    typedef struct 
  {
    char c;
    gint8 x;
  } struct struct 
  {
    char c;
    gint8 x;
  };
    typedef struct 
  {
    char c;
    gint8 x;
  } struct struct 
  {
    char c;
    gint8 x;
  };
    typedef struct 
  {
    char c;
    gint16 x;
  } struct struct 
  {
    char c;
    gint16 x;
  };
    typedef struct 
  {
    char c;
    gint32 x;
  } struct struct 
  {
    char c;
    gint32 x;
  };
    typedef struct 
  {
    char c;
    float x;
  } struct struct 
  {
    char c;
    float x;
  };
    typedef struct 
  {
    char c;
    gint64 x;
  } struct struct 
  {
    char c;
    gint64 x;
  };
    typedef struct 
  {
    char c;
    double x;
  } struct struct 
  {
    char c;
    double x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    <D.18608>:
    *align = 1;
    D.21684 = 0;
    return D.21684;
    <D.18609>:
    *align = 1;
    D.21684 = 1;
    return D.21684;
    <D.18613>:
    <D.18614>:
    *align = 1;
    D.21684 = 1;
    return D.21684;
    <D.18618>:
    <D.18619>:
    <D.18620>:
    *align = 2;
    D.21684 = 2;
    return D.21684;
    <D.18624>:
    <D.18625>:
    *align = 4;
    D.21684 = 4;
    return D.21684;
    <D.18629>:
    *align = 4;
    D.21684 = 4;
    return D.21684;
    <D.18633>:
    <D.18634>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18638>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18642>:
    <D.18643>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18647>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18651>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18655>:
    D.21691 = t->data.klass;
    D.21692 = BIT_FIELD_REF <*D.21691, 8, 256>;
    D.21693 = D.21692 & 16;
    if (D.21693 != 0) goto <D.21694>; else goto <D.21695>;
    <D.21694>:
    D.21691 = t->data.klass;
    D.21696 = mono_class_enum_basetype (D.21691);
    D.21684 = mono_type_size (D.21696, align);
    return D.21684;
    <D.21695>:
    D.21691 = t->data.klass;
    D.21684 = mono_class_value_size (D.21691, align);
    return D.21684;
    <D.18656>:
    <D.18657>:
    <D.18658>:
    <D.18659>:
    <D.18660>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18664>:
    D.21697 = mono_defaults.typed_reference_class;
    D.21684 = mono_class_value_size (D.21697, align);
    return D.21684;
    <D.18665>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.21698 = BIT_FIELD_REF <*container_class, 8, 256>;
      D.21699 = D.21698 & 8;
      if (D.21699 != 0) goto <D.21700>; else goto <D.21701>;
      <D.21700>:
      D.21698 = BIT_FIELD_REF <*container_class, 8, 256>;
      D.21702 = D.21698 & 16;
      if (D.21702 != 0) goto <D.21703>; else goto <D.21704>;
      <D.21703>:
      D.21705 = mono_class_enum_basetype (container_class);
      D.21684 = mono_type_size (D.21705, align);
      return D.21684;
      <D.21704>:
      D.21706 = mono_class_from_mono_type (t);
      D.21684 = mono_class_value_size (D.21706, align);
      return D.21684;
      <D.21701>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 8;
        D.21684 = 8;
        return D.21684;
      }
    }
    <D.18671>:
    <D.18672>:
    *align = 8;
    D.21684 = 8;
    return D.21684;
    <D.18676>:
    D.21689 = t->type;
    D.21690 = (int) D.21689;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.21690);
    <D.18677>:
    goto <D.18677>;
  }
  D.21684 = 0;
  return D.21684;
}


mono_type_stack_size (struct MonoType * t, int * align)
{
  int D.21708;

  D.21708 = mono_type_stack_size_internal (t, align, 0);
  return D.21708;
}


mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.21710;
  long int D.21711;
  long int D.21712;
  unsigned char D.21717;
  unsigned char D.21718;
  int D.21721;
  unsigned char D.21722;
  int D.21723;
  _Bool D.21724;
  long int D.21725;
  long int D.21726;
  struct MonoClass * D.21729;
  unsigned char D.21730;
  unsigned char D.21731;
  struct MonoType * D.21734;
  int D.21735;
  int D.21736;
  int D.21737;
  int D.21738;
  int D.21739;
  int D.21740;
  unsigned int stack_slot_size.117;
  unsigned int D.21742;
  int D.21743;
  unsigned int D.21744;
  struct MonoGenericInst * D.21747;
  unsigned char D.21748;
  unsigned char D.21749;
  _Bool D.21750;
  long int D.21751;
  long int D.21752;
  unsigned char D.21755;
  unsigned char D.21756;
  unsigned char D.21759;
  struct MonoType * D.21762;
  struct MonoClass * D.21763;
  int D.21764;
  unsigned int D.21765;
  int tmp;
  int stack_slot_size;
  int stack_slot_align;
  typedef struct 
{
  char c;
  void * x;
} struct struct 
{
  char c;
  void * x;
};

  try
    {
      stack_slot_size = 8;
      stack_slot_align = 8;
      D.21710 = t == 0B;
      D.21711 = (long int) D.21710;
      D.21712 = __builtin_expect (D.21711, 0);
      if (D.21712 != 0) goto <D.21713>; else goto <D.21714>;
      <D.21713>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.21714>:
      if (align == 0B) goto <D.21715>; else goto <D.21716>;
      <D.21715>:
      align = &tmp;
      <D.21716>:
      D.21717 = BIT_FIELD_REF <*t, 8, 88>;
      D.21718 = D.21717 & 64;
      if (D.21718 != 0) goto <D.21719>; else goto <D.21720>;
      <D.21719>:
      *align = stack_slot_align;
      D.21721 = stack_slot_size;
      return D.21721;
      <D.21720>:
      D.21722 = t->type;
      D.21723 = (int) D.21722;
      switch (D.21723) <default: <D.18732>, case 2: <D.18693>, case 3: <D.18694>, case 4: <D.18695>, case 5: <D.18696>, case 6: <D.18697>, case 7: <D.18698>, case 8: <D.18699>, case 9: <D.18700>, case 10: <D.18717>, case 11: <D.18718>, case 12: <D.18713>, case 13: <D.18722>, case 14: <D.18703>, case 15: <D.18707>, case 17: <D.18726>, case 18: <D.18705>, case 19: <D.18710>, case 20: <D.18709>, case 21: <D.18728>, case 22: <D.18712>, case 24: <D.18701>, case 25: <D.18702>, case 27: <D.18708>, case 28: <D.18704>, case 29: <D.18706>, case 30: <D.18711>>
      {
        typedef struct 
      {
        char c;
        float x;
      } struct struct 
      {
        char c;
        float x;
      };
        typedef struct 
      {
        char c;
        gint64 x;
      } struct struct 
      {
        char c;
        gint64 x;
      };
        typedef struct 
      {
        char c;
        double x;
      } struct struct 
      {
        char c;
        double x;
      };

        <D.18693>:
        <D.18694>:
        <D.18695>:
        <D.18696>:
        <D.18697>:
        <D.18698>:
        <D.18699>:
        <D.18700>:
        <D.18701>:
        <D.18702>:
        <D.18703>:
        <D.18704>:
        <D.18705>:
        <D.18706>:
        <D.18707>:
        <D.18708>:
        <D.18709>:
        *align = stack_slot_align;
        D.21721 = stack_slot_size;
        return D.21721;
        <D.18710>:
        <D.18711>:
        D.21724 = allow_open == 0;
        D.21725 = (long int) D.21724;
        D.21726 = __builtin_expect (D.21725, 0);
        if (D.21726 != 0) goto <D.21727>; else goto <D.21728>;
        <D.21727>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.21728>:
        *align = stack_slot_align;
        D.21721 = stack_slot_size;
        return D.21721;
        <D.18712>:
        *align = stack_slot_align;
        D.21721 = stack_slot_size * 3;
        return D.21721;
        <D.18713>:
        *align = 4;
        D.21721 = 4;
        return D.21721;
        <D.18717>:
        <D.18718>:
        *align = 8;
        D.21721 = 8;
        return D.21721;
        <D.18722>:
        *align = 8;
        D.21721 = 8;
        return D.21721;
        <D.18726>:
        {
          guint32 size;

          D.21729 = t->data.klass;
          D.21730 = BIT_FIELD_REF <*D.21729, 8, 256>;
          D.21731 = D.21730 & 16;
          if (D.21731 != 0) goto <D.21732>; else goto <D.21733>;
          <D.21732>:
          D.21729 = t->data.klass;
          D.21734 = mono_class_enum_basetype (D.21729);
          D.21721 = mono_type_stack_size_internal (D.21734, align, allow_open);
          return D.21721;
          <D.21733>:
          D.21729 = t->data.klass;
          D.21735 = mono_class_value_size (D.21729, align);
          size = (guint32) D.21735;
          D.21736 = *align;
          D.21737 = D.21736 + stack_slot_align;
          D.21738 = D.21737 + -1;
          *align = D.21738;
          D.21736 = *align;
          D.21739 = -stack_slot_align;
          D.21740 = D.21736 & D.21739;
          *align = D.21740;
          stack_slot_size.117 = (unsigned int) stack_slot_size;
          D.21742 = stack_slot_size.117 + size;
          size = D.21742 + 4294967295;
          D.21743 = -stack_slot_size;
          D.21744 = (unsigned int) D.21743;
          size = D.21744 & size;
          D.21721 = (int) size;
          return D.21721;
        }
        <D.18728>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.21745>; else goto <D.21746>;
          <D.21745>:
          D.21747 = gclass->context.class_inst;
          D.21748 = BIT_FIELD_REF <*D.21747, 8, 48>;
          D.21749 = D.21748 & 64;
          D.21750 = D.21749 != 0;
          D.21751 = (long int) D.21750;
          D.21752 = __builtin_expect (D.21751, 0);
          if (D.21752 != 0) goto <D.21753>; else goto <D.21754>;
          <D.21753>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.21754>:
          <D.21746>:
          D.21755 = BIT_FIELD_REF <*container_class, 8, 256>;
          D.21756 = D.21755 & 8;
          if (D.21756 != 0) goto <D.21757>; else goto <D.21758>;
          <D.21757>:
          D.21755 = BIT_FIELD_REF <*container_class, 8, 256>;
          D.21759 = D.21755 & 16;
          if (D.21759 != 0) goto <D.21760>; else goto <D.21761>;
          <D.21760>:
          D.21762 = mono_class_enum_basetype (container_class);
          D.21721 = mono_type_stack_size_internal (D.21762, align, allow_open);
          return D.21721;
          <D.21761>:
          {
            guint32 size;

            D.21763 = mono_class_from_mono_type (t);
            D.21764 = mono_class_value_size (D.21763, align);
            size = (guint32) D.21764;
            D.21736 = *align;
            D.21737 = D.21736 + stack_slot_align;
            D.21738 = D.21737 + -1;
            *align = D.21738;
            D.21736 = *align;
            D.21739 = -stack_slot_align;
            D.21740 = D.21736 & D.21739;
            *align = D.21740;
            stack_slot_size.117 = (unsigned int) stack_slot_size;
            D.21765 = stack_slot_size.117 + size;
            size = D.21765 + 4294967295;
            D.21743 = -stack_slot_size;
            D.21744 = (unsigned int) D.21743;
            size = D.21744 & size;
            D.21721 = (int) size;
            return D.21721;
          }
          <D.21758>:
          *align = stack_slot_align;
          D.21721 = stack_slot_size;
          return D.21721;
        }
        <D.18732>:
        D.21722 = t->type;
        D.21723 = (int) D.21722;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.21723);
        <D.18733>:
        goto <D.18733>;
      }
      D.21721 = 0;
      return D.21721;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.21768;
  _Bool D.21769;
  long int D.21770;
  long int D.21771;
  mono_bool D.21774;
  struct MonoGenericClass * D.21775;
  struct MonoClass * D.21776;
  <unnamed-unsigned:1> D.21777;

  D.21768 = type->type;
  D.21769 = D.21768 != 21;
  D.21770 = (long int) D.21769;
  D.21771 = __builtin_expect (D.21770, 0);
  if (D.21771 != 0) goto <D.21772>; else goto <D.21773>;
  <D.21772>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.21773>:
  D.21775 = type->data.generic_class;
  D.21776 = D.21775->container_class;
  D.21777 = D.21776->valuetype;
  D.21774 = (mono_bool) D.21777;
  return D.21774;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.21779;
  struct MonoClass * D.21780;
  <unnamed-unsigned:1> D.21781;

  D.21780 = gclass->container_class;
  D.21781 = D.21780->valuetype;
  D.21779 = (mono_bool) D.21781;
  return D.21779;
}


mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21783;
  unsigned int D.21786;
  unsigned int D.21787;
  unsigned int D.21788;
  struct MonoGenericInst * D.21789;
  unsigned int D.21792;
  guint D.21793;
  guint hash;

  hash = 3223191271;
  D.21783 = context->class_inst;
  if (D.21783 != 0B) goto <D.21784>; else goto <D.21785>;
  <D.21784>:
  D.21786 = hash << 5;
  D.21787 = D.21786 - hash;
  D.21783 = context->class_inst;
  D.21788 = mono_metadata_generic_inst_hash (D.21783);
  hash = D.21787 ^ D.21788;
  <D.21785>:
  D.21789 = context->method_inst;
  if (D.21789 != 0B) goto <D.21790>; else goto <D.21791>;
  <D.21790>:
  D.21786 = hash << 5;
  D.21787 = D.21786 - hash;
  D.21789 = context->method_inst;
  D.21792 = mono_metadata_generic_inst_hash (D.21789);
  hash = D.21787 ^ D.21792;
  <D.21791>:
  D.21793 = hash;
  return D.21793;
}


mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.21795;
  int iftmp.118;
  struct MonoGenericInst * D.21799;
  struct MonoGenericInst * D.21800;
  struct MonoGenericInst * D.21802;
  struct MonoGenericInst * D.21803;

  D.21799 = g1->class_inst;
  D.21800 = g2->class_inst;
  if (D.21799 == D.21800) goto <D.21801>; else goto <D.21797>;
  <D.21801>:
  D.21802 = g1->method_inst;
  D.21803 = g2->method_inst;
  if (D.21802 == D.21803) goto <D.21804>; else goto <D.21797>;
  <D.21804>:
  iftmp.118 = 1;
  goto <D.21798>;
  <D.21797>:
  iftmp.118 = 0;
  <D.21798>:
  D.21795 = iftmp.118;
  return D.21795;
}


mono_metadata_str_hash (const void * v1)
{
  char D.21806;
  unsigned int D.21809;
  unsigned int D.21810;
  unsigned int D.21811;
  char * p.119;
  char D.21813;
  guint D.21814;
  char * p;
  guint hash;

  p = v1;
  D.21806 = *p;
  hash = (guint) D.21806;
  goto <D.18768>;
  <D.18767>:
  D.21806 = *p;
  if (D.21806 != 0) goto <D.21807>; else goto <D.21808>;
  <D.21807>:
  D.21809 = hash << 5;
  D.21810 = D.21809 - hash;
  D.21806 = *p;
  D.21811 = (unsigned int) D.21806;
  hash = D.21810 + D.21811;
  <D.21808>:
  <D.18768>:
  p.119 = p;
  p = p.119 + 1;
  D.21813 = *p.119;
  if (D.21813 != 0) goto <D.18767>; else goto <D.18769>;
  <D.18769>:
  D.21814 = hash;
  return D.21814;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.21816;
  <unnamed-unsigned:1> D.21817;
  int D.21818;
  int D.21819;
  unsigned int D.21820;
  int D.21821;
  struct MonoImage * D.21822;
  unsigned char D.21823;
  unsigned char D.21824;
  unsigned int D.21827;
  const char * D.21828;
  unsigned int D.21829;
  unsigned int D.21830;
  unsigned int D.21831;
  unsigned int D.21832;
  struct MonoType * D.21833;
  unsigned int D.21834;
  struct MonoArrayType * D.21835;
  struct MonoClass * D.21836;
  struct MonoType * D.21837;
  unsigned int D.21838;
  struct MonoGenericClass * D.21839;
  unsigned int D.21840;
  guint hash;

  D.21816 = t1->type;
  hash = (guint) D.21816;
  D.21817 = t1->byref;
  D.21818 = (int) D.21817;
  D.21819 = D.21818 << 6;
  D.21820 = (unsigned int) D.21819;
  hash = D.21820 | hash;
  D.21816 = t1->type;
  D.21821 = (int) D.21816;
  switch (D.21821) <default: <D.21841>, case 15: <D.18778>, case 17: <D.18774>, case 18: <D.18775>, case 20: <D.18779>, case 21: <D.18780>, case 29: <D.18776>>
  <D.18774>:
  <D.18775>:
  <D.18776>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.21822 = class->image;
    D.21823 = BIT_FIELD_REF <*D.21822, 8, 224>;
    D.21824 = D.21823 & 8;
    if (D.21824 != 0) goto <D.21825>; else goto <D.21826>;
    <D.21825>:
    D.21817 = t1->byref;
    D.21818 = (int) D.21817;
    D.21819 = D.21818 << 6;
    D.21820 = (unsigned int) D.21819;
    D.21828 = class->name;
    D.21829 = mono_metadata_str_hash (D.21828);
    D.21827 = D.21820 | D.21829;
    return D.21827;
    <D.21826>:
    D.21830 = hash << 5;
    D.21831 = D.21830 - hash;
    D.21828 = class->name;
    D.21832 = mono_metadata_str_hash (D.21828);
    D.21827 = D.21831 ^ D.21832;
    return D.21827;
  }
  <D.18778>:
  D.21830 = hash << 5;
  D.21831 = D.21830 - hash;
  D.21833 = t1->data.type;
  D.21834 = mono_metadata_type_hash (D.21833);
  D.21827 = D.21831 ^ D.21834;
  return D.21827;
  <D.18779>:
  D.21830 = hash << 5;
  D.21831 = D.21830 - hash;
  D.21835 = t1->data.array;
  D.21836 = D.21835->eklass;
  D.21837 = &D.21836->byval_arg;
  D.21838 = mono_metadata_type_hash (D.21837);
  D.21827 = D.21831 ^ D.21838;
  return D.21827;
  <D.18780>:
  D.21830 = hash << 5;
  D.21831 = D.21830 - hash;
  D.21839 = t1->data.generic_class;
  D.21840 = mono_generic_class_hash (D.21839);
  D.21827 = D.21831 ^ D.21840;
  return D.21827;
  <D.21841>:
  D.21827 = hash;
  return D.21827;
}


mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2)
{
  mono_bool D.21843;

  D.21843 = do_mono_metadata_type_equal (t1, t2, 0);
  return D.21843;
}


mono_metadata_type_equal_full (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  gboolean D.21845;

  D.21845 = do_mono_metadata_type_equal (t1, t2, signature_only);
  return D.21845;
}


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  unsigned char D.21849;
  unsigned char D.21850;
  unsigned char D.21851;
  unsigned char D.21852;
  short unsigned int D.21854;
  short unsigned int D.21855;
  mono_bool D.21856;
  short unsigned int D.21857;
  short unsigned int D.21858;
  int D.21861;
  int D.21864;
  struct MonoType * D.21865;
  struct MonoType * D.21866;
  int D.21867;
  int i;

  D.21849 = BIT_FIELD_REF <*sig1, 8, 112>;
  D.21850 = BIT_FIELD_REF <*sig2, 8, 112>;
  D.21851 = D.21849 ^ D.21850;
  D.21852 = D.21851 & 64;
  if (D.21852 != 0) goto <D.21847>; else goto <D.21853>;
  <D.21853>:
  D.21854 = sig1->param_count;
  D.21855 = sig2->param_count;
  if (D.21854 != D.21855) goto <D.21847>; else goto <D.21848>;
  <D.21847>:
  D.21856 = 0;
  return D.21856;
  <D.21848>:
  D.21857 = sig1->generic_param_count;
  D.21858 = sig2->generic_param_count;
  if (D.21857 != D.21858) goto <D.21859>; else goto <D.21860>;
  <D.21859>:
  D.21856 = 0;
  return D.21856;
  <D.21860>:
  i = 0;
  goto <D.18852>;
  <D.18851>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.21861 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.21861 == 0) goto <D.21862>; else goto <D.21863>;
    <D.21862>:
    D.21856 = 0;
    return D.21856;
    <D.21863>:
  }
  i = i + 1;
  <D.18852>:
  D.21854 = sig1->param_count;
  D.21864 = (int) D.21854;
  if (D.21864 > i) goto <D.18851>; else goto <D.18853>;
  <D.18853>:
  D.21865 = sig2->ret;
  D.21866 = sig1->ret;
  D.21867 = do_mono_metadata_type_equal (D.21866, D.21865, 1);
  if (D.21867 == 0) goto <D.21868>; else goto <D.21869>;
  <D.21868>:
  D.21856 = 0;
  return D.21856;
  <D.21869>:
  D.21856 = 1;
  return D.21856;
}


mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  unsigned char D.21871;
  unsigned char D.21872;
  <unnamed-unsigned:6> D.21875;
  unsigned int D.21876;
  unsigned int D.21877;
  unsigned int sizeof_o.120;
  unsigned int D.21879;
  void * iftmp.121;
  unsigned int sizeof_o.122;
  long unsigned int D.21885;
  long unsigned int D.21886;
  unsigned char D.21887;
  struct MonoType * D.21890;
  struct MonoType * D.21891;
  struct MonoArrayType * D.21895;
  struct MonoArrayType * D.21896;
  struct MonoMethodSignature * D.21900;
  struct MonoMethodSignature * D.21901;
  struct MonoType * D.21902;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 12;
  D.21871 = BIT_FIELD_REF <*o, 8, 88>;
  D.21872 = D.21871 & 63;
  if (D.21872 != 0) goto <D.21873>; else goto <D.21874>;
  <D.21873>:
  D.21875 = o->num_mods;
  D.21876 = (unsigned int) D.21875;
  D.21877 = D.21876 * 4;
  sizeof_o.120 = (unsigned int) sizeof_o;
  D.21879 = D.21877 + sizeof_o.120;
  sizeof_o = (int) D.21879;
  <D.21874>:
  if (image != 0B) goto <D.21881>; else goto <D.21882>;
  <D.21881>:
  sizeof_o.122 = (unsigned int) sizeof_o;
  iftmp.121 = mono_image_alloc0 (image, sizeof_o.122);
  goto <D.21884>;
  <D.21882>:
  D.21885 = (long unsigned int) sizeof_o;
  iftmp.121 = monoeg_malloc (D.21885);
  <D.21884>:
  r = iftmp.121;
  D.21886 = (long unsigned int) sizeof_o;
  memcpy (r, o, D.21886);
  D.21887 = o->type;
  if (D.21887 == 15) goto <D.21888>; else goto <D.21889>;
  <D.21888>:
  D.21890 = o->data.type;
  D.21891 = mono_metadata_type_dup (image, D.21890);
  r->data.type = D.21891;
  goto <D.21892>;
  <D.21889>:
  D.21887 = o->type;
  if (D.21887 == 20) goto <D.21893>; else goto <D.21894>;
  <D.21893>:
  D.21895 = o->data.array;
  D.21896 = mono_dup_array_type (image, D.21895);
  r->data.array = D.21896;
  goto <D.21897>;
  <D.21894>:
  D.21887 = o->type;
  if (D.21887 == 27) goto <D.21898>; else goto <D.21899>;
  <D.21898>:
  D.21900 = o->data.method;
  D.21901 = mono_metadata_signature_deep_dup (image, D.21900);
  r->data.method = D.21901;
  <D.21899>:
  <D.21897>:
  <D.21892>:
  D.21902 = r;
  return D.21902;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.21904;
  unsigned char D.21905;
  unsigned int D.21906;
  unsigned int D.21907;
  struct MonoType * D.21908;
  unsigned int D.21909;
  short unsigned int D.21910;
  unsigned int D.21911;
  unsigned int D.21912;
  guint i;
  guint res;

  D.21904 = sig->ret;
  D.21905 = D.21904->type;
  res = (guint) D.21905;
  i = 0;
  goto <D.18866>;
  <D.18865>:
  D.21906 = res << 5;
  D.21907 = D.21906 - res;
  D.21908 = sig->params[i];
  D.21909 = mono_type_hash (D.21908);
  res = D.21907 + D.21909;
  i = i + 1;
  <D.18866>:
  D.21910 = sig->param_count;
  D.21911 = (unsigned int) D.21910;
  if (D.21911 > i) goto <D.18865>; else goto <D.18867>;
  <D.18867>:
  D.21912 = res;
  return D.21912;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.123;
  char D.21917;
  unsigned int D.21921;
  unsigned char D.21922;
  unsigned char D.21923;
  char D.21924;
  char * D.21925;
  char D.21926;
  unsigned int D.21928;
  unsigned char D.21929;
  unsigned char D.21930;
  char D.21931;
  unsigned int D.21932;
  char D.21933;
  char * D.21934;
  char D.21935;
  char * D.21936;
  char * p;

  p = buf;
  if (value <= 127) goto <D.21914>; else goto <D.21915>;
  <D.21914>:
  p.123 = p;
  p = p.123 + 1;
  D.21917 = (char) value;
  *p.123 = D.21917;
  goto <D.21918>;
  <D.21915>:
  if (value <= 16383) goto <D.21919>; else goto <D.21920>;
  <D.21919>:
  D.21921 = value >> 8;
  D.21922 = (unsigned char) D.21921;
  D.21923 = D.21922 | 128;
  D.21924 = (char) D.21923;
  *p = D.21924;
  D.21925 = p + 1;
  D.21926 = (char) value;
  *D.21925 = D.21926;
  p = p + 2;
  goto <D.21927>;
  <D.21920>:
  D.21928 = value >> 24;
  D.21929 = (unsigned char) D.21928;
  D.21930 = D.21929 | 192;
  D.21931 = (char) D.21930;
  *p = D.21931;
  D.21925 = p + 1;
  D.21932 = value >> 16;
  D.21933 = (char) D.21932;
  *D.21925 = D.21933;
  D.21934 = p + 2;
  D.21921 = value >> 8;
  D.21935 = (char) D.21921;
  *D.21934 = D.21935;
  D.21936 = p + 3;
  D.21926 = (char) value;
  *D.21936 = D.21926;
  p = p + 4;
  <D.21927>:
  <D.21918>:
  if (endbuf != 0B) goto <D.21937>; else goto <D.21938>;
  <D.21937>:
  *endbuf = p;
  <D.21938>:
}


mono_metadata_field_info (struct MonoImage * meta, guint32 index, guint32 * offset, guint32 * rva, struct MonoMarshalSpec * * marshal_spec)
{
  mono_metadata_field_info_full (meta, index, offset, rva, marshal_spec, 0);
}


mono_metadata_field_info_full (struct MonoImage * meta, guint32 index, guint32 * offset, guint32 * rva, struct MonoMarshalSpec * * marshal_spec, gboolean alloc_from_image)
{
  unsigned int D.21939;
  int D.21940;
  unsigned char D.21941;
  unsigned char D.21942;
  int D.21945;
  unsigned int D.21946;
  int D.21947;
  const char * D.21952;
  unsigned char D.21954;
  long unsigned int D.21955;
  <unnamed-unsigned:24> D.21956;
  long unsigned int D.21957;
  void * D.21958;
  unsigned int D.21960;
  int D.21961;
  unsigned int D.21962;
  void * D.21968;
  unsigned int D.21970;
  struct MonoImage * iftmp.124;
  struct MonoMarshalSpec * D.21979;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.21939 = index + 1;
      D.21940 = (int) D.21939;
      loc.idx = D.21940;
      D.21941 = BIT_FIELD_REF <*meta, 8, 224>;
      D.21942 = D.21941 & 32;
      if (D.21942 != 0) goto <D.21943>; else goto <D.21944>;
      <D.21943>:
      D.21945 = loc.idx;
      D.21946 = search_ptr_table (meta, 3, D.21945);
      D.21947 = (int) D.21946;
      loc.idx = D.21947;
      <D.21944>:
      if (offset != 0B) goto <D.21948>; else goto <D.21949>;
      <D.21948>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21952 = tdef->base;
      if (D.21952 != 0B) goto <D.21953>; else goto <D.21950>;
      <D.21953>:
      D.21954 = tdef->row_size;
      D.21955 = (long unsigned int) D.21954;
      D.21956 = tdef->rows;
      D.21957 = (long unsigned int) D.21956;
      D.21952 = tdef->base;
      D.21958 = mono_binary_search (&loc, D.21952, D.21957, D.21955, table_locator);
      if (D.21958 != 0B) goto <D.21959>; else goto <D.21950>;
      <D.21959>:
      D.21960 = loc.result;
      D.21961 = (int) D.21960;
      D.21962 = mono_metadata_decode_row_col (tdef, D.21961, 0);
      *offset = D.21962;
      goto <D.21951>;
      <D.21950>:
      *offset = 4294967295;
      <D.21951>:
      <D.21949>:
      if (rva != 0B) goto <D.21963>; else goto <D.21964>;
      <D.21963>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21952 = tdef->base;
      if (D.21952 != 0B) goto <D.21967>; else goto <D.21965>;
      <D.21967>:
      D.21954 = tdef->row_size;
      D.21955 = (long unsigned int) D.21954;
      D.21956 = tdef->rows;
      D.21957 = (long unsigned int) D.21956;
      D.21952 = tdef->base;
      D.21968 = mono_binary_search (&loc, D.21952, D.21957, D.21955, table_locator);
      if (D.21968 != 0B) goto <D.21969>; else goto <D.21965>;
      <D.21969>:
      D.21960 = loc.result;
      D.21961 = (int) D.21960;
      D.21970 = mono_metadata_decode_row_col (tdef, D.21961, 0);
      *rva = D.21970;
      goto <D.21966>;
      <D.21965>:
      *rva = 0;
      <D.21966>:
      <D.21964>:
      if (marshal_spec != 0B) goto <D.21971>; else goto <D.21972>;
      <D.21971>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.21973>; else goto <D.21974>;
        <D.21973>:
        if (alloc_from_image != 0) goto <D.21976>; else goto <D.21977>;
        <D.21976>:
        iftmp.124 = meta;
        goto <D.21978>;
        <D.21977>:
        iftmp.124 = 0B;
        <D.21978>:
        D.21979 = mono_metadata_parse_marshal_spec_full (iftmp.124, p);
        *marshal_spec = D.21979;
        <D.21974>:
      }
      <D.21972>:
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_field_info_with_mempool (struct MonoImage * meta, guint32 index, guint32 * offset, guint32 * rva, struct MonoMarshalSpec * * marshal_spec)
{
  mono_metadata_field_info_full (meta, index, offset, rva, marshal_spec, 1);
}


mono_metadata_get_constant_index (struct MonoImage * meta, guint32 token, guint32 hint)
{
  unsigned int D.21980;
  uint32_t D.21981;
  int index.125;
  <unnamed-unsigned:24> D.21985;
  unsigned int D.21986;
  unsigned int D.21989;
  int D.21990;
  unsigned int D.21991;
  const char * D.21994;
  unsigned char D.21997;
  long unsigned int D.21998;
  long unsigned int D.21999;
  void * D.22000;
  unsigned int D.22003;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.21980 = token >> 24;
      switch (D.21980) <default: <D.18911>, case 4: <D.18907>, case 8: <D.18909>, case 23: <D.18910>>
      <D.18907>:
      index = index;
      goto <D.18908>;
      <D.18909>:
      index = index | 1;
      goto <D.18908>;
      <D.18910>:
      index = index | 2;
      goto <D.18908>;
      <D.18911>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.21981 = 0;
      return D.21981;
      <D.18908>:
      index.125 = (int) index;
      loc.idx = index.125;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.21983>; else goto <D.21984>;
      <D.21983>:
      D.21985 = tdef->rows;
      D.21986 = (unsigned int) D.21985;
      if (D.21986 > hint) goto <D.21987>; else goto <D.21988>;
      <D.21987>:
      D.21989 = hint + 4294967295;
      D.21990 = (int) D.21989;
      D.21991 = mono_metadata_decode_row_col (tdef, D.21990, 2);
      if (D.21991 == index) goto <D.21992>; else goto <D.21993>;
      <D.21992>:
      D.21981 = hint;
      return D.21981;
      <D.21993>:
      <D.21988>:
      <D.21984>:
      D.21994 = tdef->base;
      if (D.21994 != 0B) goto <D.21995>; else goto <D.21996>;
      <D.21995>:
      D.21997 = tdef->row_size;
      D.21998 = (long unsigned int) D.21997;
      D.21985 = tdef->rows;
      D.21999 = (long unsigned int) D.21985;
      D.21994 = tdef->base;
      D.22000 = mono_binary_search (&loc, D.21994, D.21999, D.21998, table_locator);
      if (D.22000 != 0B) goto <D.22001>; else goto <D.22002>;
      <D.22001>:
      D.22003 = loc.result;
      D.21981 = D.22003 + 1;
      return D.21981;
      <D.22002>:
      <D.21996>:
      D.21981 = 0;
      return D.21981;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22006;
  uint32_t D.22009;
  unsigned int D.22010;
  int D.22011;
  unsigned char D.22012;
  long unsigned int D.22013;
  <unnamed-unsigned:24> D.22014;
  long unsigned int D.22015;
  void * D.22016;
  unsigned int D.22019;
  int D.22020;
  unsigned int D.22021;
  unsigned int D.22022;
  int D.22025;
  unsigned int D.22026;
  <unnamed-unsigned:24> D.22028;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.22006 = tdef->base;
      if (D.22006 == 0B) goto <D.22007>; else goto <D.22008>;
      <D.22007>:
      D.22009 = 0;
      return D.22009;
      <D.22008>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22010 = index + 1;
      D.22011 = (int) D.22010;
      loc.idx = D.22011;
      D.22012 = tdef->row_size;
      D.22013 = (long unsigned int) D.22012;
      D.22014 = tdef->rows;
      D.22015 = (long unsigned int) D.22014;
      D.22006 = tdef->base;
      D.22016 = mono_binary_search (&loc, D.22006, D.22015, D.22013, table_locator);
      if (D.22016 == 0B) goto <D.22017>; else goto <D.22018>;
      <D.22017>:
      D.22009 = 0;
      return D.22009;
      <D.22018>:
      D.22019 = loc.result;
      D.22020 = (int) D.22019;
      start = mono_metadata_decode_row_col (tdef, D.22020, 1);
      D.22019 = loc.result;
      D.22021 = D.22019 + 1;
      D.22014 = tdef->rows;
      D.22022 = (unsigned int) D.22014;
      if (D.22021 < D.22022) goto <D.22023>; else goto <D.22024>;
      <D.22023>:
      D.22019 = loc.result;
      D.22021 = D.22019 + 1;
      D.22025 = (int) D.22021;
      D.22026 = mono_metadata_decode_row_col (tdef, D.22025, 1);
      end = D.22026 + 4294967295;
      goto <D.22027>;
      <D.22024>:
      D.22028 = meta->tables[20].rows;
      end = (guint32) D.22028;
      <D.22027>:
      *end_idx = end;
      D.22009 = start + 4294967295;
      return D.22009;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22031;
  uint32_t D.22034;
  unsigned char D.22035;
  unsigned char D.22036;
  unsigned int D.22039;
  int D.22040;
  unsigned int D.22041;
  unsigned int D.22042;
  int D.22043;
  unsigned char D.22044;
  long unsigned int D.22045;
  <unnamed-unsigned:24> D.22046;
  long unsigned int D.22047;
  void * D.22048;
  int D.22051;
  unsigned int D.22052;
  unsigned int D.22053;
  int D.22054;
  unsigned int D.22055;
  int end.126;
  unsigned int D.22058;
  unsigned int D.22059;
  unsigned int D.22061;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22031 = msemt->base;
      if (D.22031 == 0B) goto <D.22032>; else goto <D.22033>;
      <D.22032>:
      D.22034 = 0;
      return D.22034;
      <D.22033>:
      D.22035 = BIT_FIELD_REF <*meta, 8, 224>;
      D.22036 = D.22035 & 32;
      if (D.22036 != 0) goto <D.22037>; else goto <D.22038>;
      <D.22037>:
      D.22039 = index + 1;
      D.22040 = (int) D.22039;
      D.22041 = search_ptr_table (meta, 19, D.22040);
      index = D.22041 + 4294967295;
      <D.22038>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22039 = index + 1;
      D.22042 = D.22039 << 1;
      D.22043 = (int) D.22042;
      loc.idx = D.22043;
      D.22044 = msemt->row_size;
      D.22045 = (long unsigned int) D.22044;
      D.22046 = msemt->rows;
      D.22047 = (long unsigned int) D.22046;
      D.22031 = msemt->base;
      D.22048 = mono_binary_search (&loc, D.22031, D.22047, D.22045, table_locator);
      if (D.22048 == 0B) goto <D.22049>; else goto <D.22050>;
      <D.22049>:
      D.22034 = 0;
      return D.22034;
      <D.22050>:
      start = loc.result;
      goto <D.18933>;
      <D.18932>:
      D.22051 = loc.idx;
      D.22052 = (unsigned int) D.22051;
      D.22053 = start + 4294967295;
      D.22054 = (int) D.22053;
      D.22055 = mono_metadata_decode_row_col (msemt, D.22054, 2);
      if (D.22052 == D.22055) goto <D.22056>; else goto <D.18931>;
      <D.22056>:
      start = start + 4294967295;
      <D.18933>:
      if (start != 0) goto <D.18932>; else goto <D.18931>;
      <D.18931>:
      end = start + 1;
      goto <D.18936>;
      <D.18935>:
      end.126 = (int) end;
      mono_metadata_decode_row (msemt, end.126, &cols, 3);
      D.22058 = cols[2];
      D.22051 = loc.idx;
      D.22059 = (unsigned int) D.22051;
      if (D.22058 != D.22059) goto <D.18934>; else goto <D.22060>;
      <D.22060>:
      end = end + 1;
      <D.18936>:
      D.22046 = msemt->rows;
      D.22061 = (unsigned int) D.22046;
      if (D.22061 > end) goto <D.18935>; else goto <D.18934>;
      <D.18934>:
      *end_idx = end;
      D.22034 = start;
      return D.22034;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22064;
  uint32_t D.22067;
  unsigned int D.22068;
  int D.22069;
  unsigned char D.22070;
  long unsigned int D.22071;
  <unnamed-unsigned:24> D.22072;
  long unsigned int D.22073;
  void * D.22074;
  unsigned int D.22077;
  int D.22078;
  unsigned int D.22079;
  unsigned int D.22080;
  int D.22083;
  unsigned int D.22084;
  <unnamed-unsigned:24> D.22086;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[21];
      *end_idx = 0;
      D.22064 = tdef->base;
      if (D.22064 == 0B) goto <D.22065>; else goto <D.22066>;
      <D.22065>:
      D.22067 = 0;
      return D.22067;
      <D.22066>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22068 = index + 1;
      D.22069 = (int) D.22068;
      loc.idx = D.22069;
      D.22070 = tdef->row_size;
      D.22071 = (long unsigned int) D.22070;
      D.22072 = tdef->rows;
      D.22073 = (long unsigned int) D.22072;
      D.22064 = tdef->base;
      D.22074 = mono_binary_search (&loc, D.22064, D.22073, D.22071, table_locator);
      if (D.22074 == 0B) goto <D.22075>; else goto <D.22076>;
      <D.22075>:
      D.22067 = 0;
      return D.22067;
      <D.22076>:
      D.22077 = loc.result;
      D.22078 = (int) D.22077;
      start = mono_metadata_decode_row_col (tdef, D.22078, 1);
      D.22077 = loc.result;
      D.22079 = D.22077 + 1;
      D.22072 = tdef->rows;
      D.22080 = (unsigned int) D.22072;
      if (D.22079 < D.22080) goto <D.22081>; else goto <D.22082>;
      <D.22081>:
      D.22077 = loc.result;
      D.22079 = D.22077 + 1;
      D.22083 = (int) D.22079;
      D.22084 = mono_metadata_decode_row_col (tdef, D.22083, 1);
      end = D.22084 + 4294967295;
      goto <D.22085>;
      <D.22082>:
      D.22086 = meta->tables[23].rows;
      end = (guint32) D.22086;
      <D.22085>:
      *end_idx = end;
      D.22067 = start + 4294967295;
      return D.22067;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22089;
  uint32_t D.22092;
  unsigned char D.22093;
  unsigned char D.22094;
  unsigned int D.22097;
  int D.22098;
  unsigned int D.22099;
  unsigned int D.22100;
  unsigned int D.22101;
  int D.22102;
  unsigned char D.22103;
  long unsigned int D.22104;
  <unnamed-unsigned:24> D.22105;
  long unsigned int D.22106;
  void * D.22107;
  int D.22110;
  unsigned int D.22111;
  unsigned int D.22112;
  int D.22113;
  unsigned int D.22114;
  int end.127;
  unsigned int D.22117;
  unsigned int D.22118;
  unsigned int D.22120;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22089 = msemt->base;
      if (D.22089 == 0B) goto <D.22090>; else goto <D.22091>;
      <D.22090>:
      D.22092 = 0;
      return D.22092;
      <D.22091>:
      D.22093 = BIT_FIELD_REF <*meta, 8, 224>;
      D.22094 = D.22093 & 32;
      if (D.22094 != 0) goto <D.22095>; else goto <D.22096>;
      <D.22095>:
      D.22097 = index + 1;
      D.22098 = (int) D.22097;
      D.22099 = search_ptr_table (meta, 22, D.22098);
      index = D.22099 + 4294967295;
      <D.22096>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22097 = index + 1;
      D.22100 = D.22097 << 1;
      D.22101 = D.22100 | 1;
      D.22102 = (int) D.22101;
      loc.idx = D.22102;
      D.22103 = msemt->row_size;
      D.22104 = (long unsigned int) D.22103;
      D.22105 = msemt->rows;
      D.22106 = (long unsigned int) D.22105;
      D.22089 = msemt->base;
      D.22107 = mono_binary_search (&loc, D.22089, D.22106, D.22104, table_locator);
      if (D.22107 == 0B) goto <D.22108>; else goto <D.22109>;
      <D.22108>:
      D.22092 = 0;
      return D.22092;
      <D.22109>:
      start = loc.result;
      goto <D.18958>;
      <D.18957>:
      D.22110 = loc.idx;
      D.22111 = (unsigned int) D.22110;
      D.22112 = start + 4294967295;
      D.22113 = (int) D.22112;
      D.22114 = mono_metadata_decode_row_col (msemt, D.22113, 2);
      if (D.22111 == D.22114) goto <D.22115>; else goto <D.18956>;
      <D.22115>:
      start = start + 4294967295;
      <D.18958>:
      if (start != 0) goto <D.18957>; else goto <D.18956>;
      <D.18956>:
      end = start + 1;
      goto <D.18961>;
      <D.18960>:
      end.127 = (int) end;
      mono_metadata_decode_row (msemt, end.127, &cols, 3);
      D.22117 = cols[2];
      D.22110 = loc.idx;
      D.22118 = (unsigned int) D.22110;
      if (D.22117 != D.22118) goto <D.18959>; else goto <D.22119>;
      <D.22119>:
      end = end + 1;
      <D.18961>:
      D.22105 = msemt->rows;
      D.22120 = (unsigned int) D.22105;
      if (D.22120 > end) goto <D.18960>; else goto <D.18959>;
      <D.18959>:
      *end_idx = end;
      D.22092 = start;
      return D.22092;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.22123;
  uint32_t D.22126;
  unsigned int D.22127;
  unsigned int D.22128;
  unsigned int D.22129;
  int D.22130;
  unsigned char D.22131;
  long unsigned int D.22132;
  <unnamed-unsigned:24> D.22133;
  long unsigned int D.22134;
  void * D.22135;
  unsigned int D.22138;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.22123 = tdef->base;
      if (D.22123 == 0B) goto <D.22124>; else goto <D.22125>;
      <D.22124>:
      D.22126 = 0;
      return D.22126;
      <D.22125>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.22127 = method_idx + 1;
      D.22128 = D.22127 << 1;
      D.22129 = D.22128 | 1;
      D.22130 = (int) D.22129;
      loc.idx = D.22130;
      D.22131 = tdef->row_size;
      D.22132 = (long unsigned int) D.22131;
      D.22133 = tdef->rows;
      D.22134 = (long unsigned int) D.22133;
      D.22123 = tdef->base;
      D.22135 = mono_binary_search (&loc, D.22123, D.22134, D.22132, table_locator);
      if (D.22135 == 0B) goto <D.22136>; else goto <D.22137>;
      <D.22136>:
      D.22126 = 0;
      return D.22126;
      <D.22137>:
      D.22138 = loc.result;
      D.22126 = D.22138 + 1;
      return D.22126;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  long unsigned int D.22141;
  const void * D.22142;
  struct GHashTable * D.22143;
  struct MonoType * D.22146;
  unsigned int D.22147;
  int D.22148;
  unsigned int D.22149;
  const char * ptr.128;
  int D.22151;
  const char * ptr.129;
  void * D.22159;
  guint32 idx;
  struct MonoTableInfo * t;
  guint32 cols[1];
  const char * ptr;
  guint32 len;
  struct MonoType * type;
  struct MonoType * type2;

  try
    {
      idx = type_spec & 16777215;
      mono_loader_lock ();
      D.22141 = (long unsigned int) type_spec;
      D.22142 = (const void *) D.22141;
      D.22143 = image->typespec_cache;
      type = monoeg_g_hash_table_lookup (D.22143, D.22142);
      if (type != 0B) goto <D.22144>; else goto <D.22145>;
      <D.22144>:
      mono_loader_unlock ();
      D.22146 = type;
      return D.22146;
      <D.22145>:
      t = &image->tables[27];
      D.22147 = idx + 4294967295;
      D.22148 = (int) D.22147;
      mono_metadata_decode_row (t, D.22148, &cols, 1);
      D.22149 = cols[0];
      ptr.128 = mono_metadata_blob_heap (image, D.22149);
      ptr = ptr.128;
      D.22149 = cols[0];
      D.22151 = mono_verifier_verify_typespec_signature (image, D.22149, type_spec, 0B);
      if (D.22151 == 0) goto <D.22152>; else goto <D.22153>;
      <D.22152>:
      mono_loader_unlock ();
      D.22146 = 0B;
      return D.22146;
      <D.22153>:
      ptr.129 = ptr;
      len = mono_metadata_decode_value (ptr.129, &ptr);
      ptr.129 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.129, &ptr);
      if (type == 0B) goto <D.22155>; else goto <D.22156>;
      <D.22155>:
      mono_loader_unlock ();
      D.22146 = 0B;
      return D.22146;
      <D.22156>:
      D.22141 = (long unsigned int) type_spec;
      D.22142 = (const void *) D.22141;
      D.22143 = image->typespec_cache;
      type2 = monoeg_g_hash_table_lookup (D.22143, D.22142);
      if (type2 != 0B) goto <D.22157>; else goto <D.22158>;
      <D.22157>:
      mono_loader_unlock ();
      D.22146 = type2;
      return D.22146;
      <D.22158>:
      type2 = mono_metadata_type_dup (image, type);
      D.22141 = (long unsigned int) type_spec;
      D.22159 = (void *) D.22141;
      D.22143 = image->typespec_cache;
      monoeg_g_hash_table_insert_replace (D.22143, D.22159, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.22146 = type2;
      return D.22146;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_metadata_parse_marshal_spec (struct MonoImage * image, const char * ptr)
{
  struct MonoMarshalSpec * D.22162;

  D.22162 = mono_metadata_parse_marshal_spec_full (0B, ptr);
  return D.22162;
}


mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.130;
  unsigned int D.22168;
  const char * ptr.131;
  const char * ptr.132;
  char D.22171;
  <unnamed type> D.22172;
  <unnamed type> D.22173;
  long int ptr.133;
  long int start.134;
  long int D.22178;
  long int D.22179;
  const char * ptr.135;
  const char * ptr.136;
  char D.22184;
  <unnamed type> D.22185;
  unsigned int D.22188;
  short int D.22189;
  unsigned int D.22192;
  int D.22193;
  unsigned int D.22196;
  short int D.22197;
  unsigned int D.22202;
  int D.22203;
  unsigned int D.22208;
  int D.22209;
  unsigned int D.22212;
  sizetype D.22213;
  const char * ptr.137;
  unsigned int D.22215;
  unsigned int D.22216;
  unsigned int len.138;
  char * D.22218;
  unsigned int D.22219;
  char * D.22220;
  const char * ptr.139;
  const char * ptr.140;
  char D.22227;
  <unnamed type> D.22228;
  const char * ptr.141;
  const char * ptr.142;
  char D.22233;
  int D.22234;
  struct MonoMarshalSpec * D.22235;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.22164>; else goto <D.22165>;
  <D.22164>:
  res = mono_image_alloc0 (image, 24);
  goto <D.22166>;
  <D.22165>:
  res = monoeg_malloc0 (24);
  <D.22166>:
  ptr.130 = ptr;
  D.22168 = mono_metadata_decode_value (ptr.130, &ptr);
  len = (int) D.22168;
  ptr.130 = ptr;
  ptr.131 = ptr.130;
  ptr.132 = ptr.131 + 1;
  ptr = ptr.132;
  D.22171 = *ptr.131;
  D.22172 = (<unnamed type>) D.22171;
  res->native = D.22172;
  D.22173 = res->native;
  if (D.22173 == 42) goto <D.22174>; else goto <D.22175>;
  <D.22174>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22180>; else goto <D.22181>;
  <D.22180>:
  ptr.130 = ptr;
  ptr.135 = ptr.130;
  ptr.136 = ptr.135 + 1;
  ptr = ptr.136;
  D.22184 = *ptr.135;
  D.22185 = (<unnamed type>) D.22184;
  res->data.array_data.elem_type = D.22185;
  <D.22181>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22186>; else goto <D.22187>;
  <D.22186>:
  ptr.130 = ptr;
  D.22188 = mono_metadata_decode_value (ptr.130, &ptr);
  D.22189 = (short int) D.22188;
  res->data.array_data.param_num = D.22189;
  <D.22187>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22190>; else goto <D.22191>;
  <D.22190>:
  ptr.130 = ptr;
  D.22192 = mono_metadata_decode_value (ptr.130, &ptr);
  D.22193 = (int) D.22192;
  res->data.array_data.num_elem = D.22193;
  <D.22191>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22194>; else goto <D.22195>;
  <D.22194>:
  ptr.130 = ptr;
  D.22196 = mono_metadata_decode_value (ptr.130, &ptr);
  D.22197 = (short int) D.22196;
  res->data.array_data.elem_mult = D.22197;
  <D.22195>:
  <D.22175>:
  D.22173 = res->native;
  if (D.22173 == 23) goto <D.22198>; else goto <D.22199>;
  <D.22198>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22200>; else goto <D.22201>;
  <D.22200>:
  ptr.130 = ptr;
  D.22202 = mono_metadata_decode_value (ptr.130, &ptr);
  D.22203 = (int) D.22202;
  res->data.array_data.num_elem = D.22203;
  <D.22201>:
  <D.22199>:
  D.22173 = res->native;
  if (D.22173 == 30) goto <D.22204>; else goto <D.22205>;
  <D.22204>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22206>; else goto <D.22207>;
  <D.22206>:
  ptr.130 = ptr;
  D.22208 = mono_metadata_decode_value (ptr.130, &ptr);
  D.22209 = (int) D.22208;
  res->data.array_data.num_elem = D.22209;
  <D.22207>:
  <D.22205>:
  D.22173 = res->native;
  if (D.22173 == 44) goto <D.22210>; else goto <D.22211>;
  <D.22210>:
  ptr.130 = ptr;
  D.22212 = mono_metadata_decode_value (ptr.130, &ptr);
  len = (int) D.22212;
  ptr.130 = ptr;
  D.22213 = (sizetype) len;
  ptr.137 = ptr.130 + D.22213;
  ptr = ptr.137;
  ptr.130 = ptr;
  D.22215 = mono_metadata_decode_value (ptr.130, &ptr);
  len = (int) D.22215;
  ptr.130 = ptr;
  D.22213 = (sizetype) len;
  ptr.137 = ptr.130 + D.22213;
  ptr = ptr.137;
  ptr.130 = ptr;
  D.22216 = mono_metadata_decode_value (ptr.130, &ptr);
  len = (int) D.22216;
  len.138 = (unsigned int) len;
  ptr.130 = ptr;
  D.22218 = mono_image_strndup (image, ptr.130, len.138);
  res->data.custom_data.custom_name = D.22218;
  ptr.130 = ptr;
  D.22213 = (sizetype) len;
  ptr.137 = ptr.130 + D.22213;
  ptr = ptr.137;
  ptr.130 = ptr;
  D.22219 = mono_metadata_decode_value (ptr.130, &ptr);
  len = (int) D.22219;
  len.138 = (unsigned int) len;
  ptr.130 = ptr;
  D.22220 = mono_image_strndup (image, ptr.130, len.138);
  res->data.custom_data.cookie = D.22220;
  <D.22211>:
  D.22173 = res->native;
  if (D.22173 == 29) goto <D.22221>; else goto <D.22222>;
  <D.22221>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22223>; else goto <D.22224>;
  <D.22223>:
  ptr.130 = ptr;
  ptr.139 = ptr.130;
  ptr.140 = ptr.139 + 1;
  ptr = ptr.140;
  D.22227 = *ptr.139;
  D.22228 = (<unnamed type>) D.22227;
  res->data.safearray_data.elem_type = D.22228;
  <D.22224>:
  ptr.130 = ptr;
  ptr.133 = (long int) ptr.130;
  start.134 = (long int) start;
  D.22178 = ptr.133 - start.134;
  D.22179 = (long int) len;
  if (D.22178 <= D.22179) goto <D.22229>; else goto <D.22230>;
  <D.22229>:
  ptr.130 = ptr;
  ptr.141 = ptr.130;
  ptr.142 = ptr.141 + 1;
  ptr = ptr.142;
  D.22233 = *ptr.141;
  D.22234 = (int) D.22233;
  res->data.safearray_data.num_elem = D.22234;
  <D.22230>:
  <D.22222>:
  D.22235 = res;
  return D.22235;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.22239;
  long unsigned int D.22240;
  unsigned int D.22241;
  long unsigned int D.22242;
  sizetype D.22243;
  char * D.22244;
  char * res;

  if (image == 0B) goto <D.22237>; else goto <D.22238>;
  <D.22237>:
  D.22240 = (long unsigned int) len;
  D.22239 = monoeg_g_strndup (data, D.22240);
  return D.22239;
  <D.22238>:
  D.22241 = len + 1;
  res = mono_image_alloc (image, D.22241);
  D.22242 = (long unsigned int) len;
  memcpy (res, data, D.22242);
  D.22243 = (sizetype) len;
  D.22244 = res + D.22243;
  *D.22244 = 0;
  D.22239 = res;
  return D.22239;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.22246;
  char * D.22249;
  char * D.22250;

  D.22246 = spec->native;
  if (D.22246 == 44) goto <D.22247>; else goto <D.22248>;
  <D.22247>:
  D.22249 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.22249);
  D.22250 = spec->data.custom_data.cookie;
  monoeg_g_free (D.22250);
  <D.22248>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.22251;
  unsigned char D.22254;
  unsigned char D.22255;
  uint32_t D.22258;
  <unnamed type> D.22261;
  uint32_t iftmp.143;
  struct MonoClass * D.22275;
  unsigned char D.22276;
  unsigned char D.22277;
  struct MonoType * D.22280;
  unsigned char D.22281;
  struct MonoClass * D.22282;
  struct MonoClass * D.22289;
  struct MonoClass * D.22290;
  struct MonoClass * D.22299;
  struct MonoClass * D.22301;
  struct MonoClass * D.22303;
  struct MonoClass * D.22310;
  struct MonoGenericClass * D.22315;
  struct MonoClass * D.22316;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.22251 = type->type;
      t = (int) D.22251;
      if (conv == 0B) goto <D.22252>; else goto <D.22253>;
      <D.22252>:
      conv = &dummy_conv;
      <D.22253>:
      *conv = 0;
      D.22254 = BIT_FIELD_REF <*type, 8, 88>;
      D.22255 = D.22254 & 64;
      if (D.22255 != 0) goto <D.22256>; else goto <D.22257>;
      <D.22256>:
      D.22258 = 32;
      return D.22258;
      <D.22257>:
      handle_enum:
      switch (t) <default: <D.19065>, case 2: <D.19009>, case 3: <D.19016>, case 4: <D.19021>, case 5: <D.19022>, case 6: <D.19023>, case 7: <D.19024>, case 8: <D.19025>, case 9: <D.19026>, case 10: <D.19027>, case 11: <D.19028>, case 12: <D.19029>, case 13: <D.19030>, case 14: <D.19031>, case 15: <D.19041>, case 17: <D.19042>, case 18: <D.19052>, case 20: <D.19044>, case 21: <D.19063>, case 22: <D.19064>, case 24: <D.19050>, case 25: <D.19051>, case 27: <D.19062>, case 28: <D.19053>, case 29: <D.19043>>
      <D.19009>:
      if (mspec != 0B) goto <D.22259>; else goto <D.22260>;
      <D.22259>:
      D.22261 = mspec->native;
      switch (D.22261) <default: <D.19014>, case 2: <D.19011>, case 3: <D.19012>, case 4: <D.19013>, case 37: <D.19010>>
      <D.19010>:
      *conv = 1;
      D.22258 = 37;
      return D.22258;
      <D.19011>:
      *conv = 2;
      D.22258 = 2;
      return D.22258;
      <D.19012>:
      <D.19013>:
      D.22258 = mspec->native;
      return D.22258;
      <D.19014>:
      D.22261 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.22261);
      <D.19015>:
      goto <D.19015>;
      <D.22260>:
      *conv = 2;
      D.22258 = 2;
      return D.22258;
      <D.19016>:
      if (mspec != 0B) goto <D.22262>; else goto <D.22263>;
      <D.22262>:
      D.22261 = mspec->native;
      switch (D.22261) <default: <D.19019>, case 4: <D.19018>, case 6: <D.19017>>
      <D.19017>:
      <D.19018>:
      D.22258 = mspec->native;
      return D.22258;
      <D.19019>:
      D.22261 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.22261);
      <D.19020>:
      goto <D.19020>;
      <D.22263>:
      if (unicode != 0) goto <D.22265>; else goto <D.22266>;
      <D.22265>:
      iftmp.143 = 6;
      goto <D.22267>;
      <D.22266>:
      iftmp.143 = 4;
      <D.22267>:
      D.22258 = iftmp.143;
      return D.22258;
      <D.19021>:
      D.22258 = 3;
      return D.22258;
      <D.19022>:
      D.22258 = 4;
      return D.22258;
      <D.19023>:
      D.22258 = 5;
      return D.22258;
      <D.19024>:
      D.22258 = 6;
      return D.22258;
      <D.19025>:
      D.22258 = 7;
      return D.22258;
      <D.19026>:
      D.22258 = 8;
      return D.22258;
      <D.19027>:
      D.22258 = 9;
      return D.22258;
      <D.19028>:
      D.22258 = 10;
      return D.22258;
      <D.19029>:
      D.22258 = 11;
      return D.22258;
      <D.19030>:
      D.22258 = 12;
      return D.22258;
      <D.19031>:
      if (mspec != 0B) goto <D.22268>; else goto <D.22269>;
      <D.22268>:
      D.22261 = mspec->native;
      switch (D.22261) <default: <D.19039>, case 19: <D.19032>, case 20: <D.19033>, case 21: <D.19034>, case 22: <D.19035>, case 23: <D.19038>, case 35: <D.19036>, case 36: <D.19037>>
      <D.19032>:
      *conv = 3;
      D.22258 = 19;
      return D.22258;
      <D.19033>:
      *conv = 4;
      D.22258 = 20;
      return D.22258;
      <D.19034>:
      *conv = 7;
      D.22258 = 21;
      return D.22258;
      <D.19035>:
      *conv = 9;
      D.22258 = 22;
      return D.22258;
      <D.19036>:
      *conv = 10;
      D.22258 = 35;
      return D.22258;
      <D.19037>:
      *conv = 11;
      D.22258 = 36;
      return D.22258;
      <D.19038>:
      if (unicode != 0) goto <D.22270>; else goto <D.22271>;
      <D.22270>:
      *conv = 13;
      goto <D.22272>;
      <D.22271>:
      *conv = 12;
      <D.22272>:
      D.22258 = 23;
      return D.22258;
      <D.19039>:
      D.22261 = mspec->native;
      monoeg_g_log (0B, 4, "Can not marshal string to native type \'%02x\': Invalid managed/unmanaged type combination (String fields must be paired with LPStr, LPWStr, BStr or ByValTStr).", D.22261);
      <D.19040>:
      goto <D.19040>;
      <D.22269>:
      if (unicode != 0) goto <D.22273>; else goto <D.22274>;
      <D.22273>:
      *conv = 7;
      D.22258 = 21;
      return D.22258;
      <D.22274>:
      *conv = 4;
      D.22258 = 20;
      return D.22258;
      <D.19041>:
      D.22258 = 32;
      return D.22258;
      <D.19042>:
      D.22275 = type->data.klass;
      D.22276 = BIT_FIELD_REF <*D.22275, 8, 256>;
      D.22277 = D.22276 & 16;
      if (D.22277 != 0) goto <D.22278>; else goto <D.22279>;
      <D.22278>:
      D.22275 = type->data.klass;
      D.22280 = mono_class_enum_basetype (D.22275);
      D.22281 = D.22280->type;
      t = (int) D.22281;
      goto handle_enum;
      <D.22279>:
      D.22275 = type->data.klass;
      D.22282 = mono_defaults.handleref_class;
      if (D.22275 == D.22282) goto <D.22283>; else goto <D.22284>;
      <D.22283>:
      *conv = 34;
      D.22258 = 31;
      return D.22258;
      <D.22284>:
      D.22258 = 27;
      return D.22258;
      <D.19043>:
      <D.19044>:
      if (mspec != 0B) goto <D.22285>; else goto <D.22286>;
      <D.22285>:
      D.22261 = mspec->native;
      switch (D.22261) <default: <D.19048>, case 29: <D.19046>, case 30: <D.19045>, case 42: <D.19047>>
      <D.19045>:
      D.22275 = type->data.klass;
      D.22289 = D.22275->element_class;
      D.22290 = mono_defaults.char_class;
      if (D.22289 == D.22290) goto <D.22291>; else goto <D.22287>;
      <D.22291>:
      if (unicode == 0) goto <D.22292>; else goto <D.22287>;
      <D.22292>:
      *conv = 21;
      goto <D.22288>;
      <D.22287>:
      *conv = 20;
      <D.22288>:
      D.22258 = 30;
      return D.22258;
      <D.19046>:
      *conv = 22;
      D.22258 = 29;
      return D.22258;
      <D.19047>:
      *conv = 23;
      D.22258 = 42;
      return D.22258;
      <D.19048>:
      D.22261 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.22261);
      <D.19049>:
      goto <D.19049>;
      <D.22286>:
      *conv = 23;
      D.22258 = 42;
      return D.22258;
      <D.19050>:
      D.22258 = 31;
      return D.22258;
      <D.19051>:
      D.22258 = 32;
      return D.22258;
      <D.19052>:
      <D.19053>:
      if (mspec != 0B) goto <D.22293>; else goto <D.22294>;
      <D.22293>:
      D.22261 = mspec->native;
      switch (D.22261) <default: <D.19060>, case 25: <D.19058>, case 26: <D.19057>, case 27: <D.19054>, case 28: <D.19056>, case 38: <D.19059>, case 44: <D.19055>>
      <D.19054>:
      D.22258 = 27;
      return D.22258;
      <D.19055>:
      D.22258 = 44;
      return D.22258;
      <D.19056>:
      *conv = 25;
      D.22258 = 28;
      return D.22258;
      <D.19057>:
      *conv = 26;
      D.22258 = 26;
      return D.22258;
      <D.19058>:
      *conv = 27;
      D.22258 = 25;
      return D.22258;
      <D.19059>:
      if (t == 18) goto <D.22297>; else goto <D.22298>;
      <D.22297>:
      D.22275 = type->data.klass;
      D.22299 = mono_defaults.multicastdelegate_class;
      if (D.22275 == D.22299) goto <D.22295>; else goto <D.22300>;
      <D.22300>:
      D.22275 = type->data.klass;
      D.22301 = mono_defaults.delegate_class;
      if (D.22275 == D.22301) goto <D.22295>; else goto <D.22302>;
      <D.22302>:
      D.22275 = type->data.klass;
      D.22303 = D.22275->parent;
      D.22299 = mono_defaults.multicastdelegate_class;
      if (D.22303 == D.22299) goto <D.22295>; else goto <D.22296>;
      <D.22295>:
      *conv = 29;
      D.22258 = 38;
      return D.22258;
      <D.22296>:
      <D.22298>:
      <D.19060>:
      D.22261 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.22261);
      <D.19061>:
      goto <D.19061>;
      <D.22294>:
      if (t == 18) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      D.22275 = type->data.klass;
      D.22299 = mono_defaults.multicastdelegate_class;
      if (D.22275 == D.22299) goto <D.22304>; else goto <D.22308>;
      <D.22308>:
      D.22275 = type->data.klass;
      D.22301 = mono_defaults.delegate_class;
      if (D.22275 == D.22301) goto <D.22304>; else goto <D.22309>;
      <D.22309>:
      D.22275 = type->data.klass;
      D.22303 = D.22275->parent;
      D.22299 = mono_defaults.multicastdelegate_class;
      if (D.22303 == D.22299) goto <D.22304>; else goto <D.22305>;
      <D.22304>:
      *conv = 29;
      D.22258 = 38;
      return D.22258;
      <D.22305>:
      <D.22307>:
      D.22310 = mono_defaults.safehandle_class;
      if (D.22310 != 0B) goto <D.22311>; else goto <D.22312>;
      <D.22311>:
      D.22275 = type->data.klass;
      D.22310 = mono_defaults.safehandle_class;
      if (D.22275 == D.22310) goto <D.22313>; else goto <D.22314>;
      <D.22313>:
      *conv = 33;
      D.22258 = 31;
      return D.22258;
      <D.22314>:
      <D.22312>:
      *conv = 28;
      D.22258 = 27;
      return D.22258;
      <D.19062>:
      D.22258 = 38;
      return D.22258;
      <D.19063>:
      D.22315 = type->data.generic_class;
      D.22316 = D.22315->container_class;
      type = &D.22316->byval_arg;
      D.22251 = type->type;
      t = (int) D.22251;
      goto handle_enum;
      <D.19064>:
      <D.19065>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.19066>:
      goto <D.19066>;
      D.22258 = 80;
      return D.22258;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.22319;
  const char * D.22322;
  unsigned int D.22323;
  unsigned int D.22324;
  _Bool D.22325;
  int D.22326;
  unsigned int D.22327;
  unsigned int D.22328;
  int D.22329;
  unsigned char D.22330;
  long unsigned int D.22331;
  <unnamed-unsigned:24> D.22332;
  long unsigned int D.22333;
  void * D.22334;
  unsigned int D.22337;
  int D.22338;
  unsigned int D.22339;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.22319 = tdef->base;
      if (D.22319 == 0B) goto <D.22320>; else goto <D.22321>;
      <D.22320>:
      D.22322 = 0B;
      return D.22322;
      <D.22321>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22323 = idx + 1;
      D.22324 = D.22323 << 1;
      D.22325 = is_field == 0;
      D.22326 = (int) D.22325;
      D.22327 = (unsigned int) D.22326;
      D.22328 = D.22324 | D.22327;
      D.22329 = (int) D.22328;
      loc.idx = D.22329;
      D.22330 = tdef->row_size;
      D.22331 = (long unsigned int) D.22330;
      D.22332 = tdef->rows;
      D.22333 = (long unsigned int) D.22332;
      D.22319 = tdef->base;
      D.22334 = mono_binary_search (&loc, D.22319, D.22333, D.22331, table_locator);
      if (D.22334 == 0B) goto <D.22335>; else goto <D.22336>;
      <D.22335>:
      D.22322 = 0B;
      return D.22322;
      <D.22336>:
      D.22337 = loc.result;
      D.22338 = (int) D.22337;
      D.22339 = mono_metadata_decode_row_col (tdef, D.22338, 1);
      D.22322 = mono_metadata_blob_heap (meta, D.22339);
      return D.22322;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.22342;
  struct MonoMethod * D.22343;
  unsigned int D.22344;
  unsigned int D.22345;
  guint32 idx;

  idx = tok >> 1;
  D.22342 = tok & 1;
  switch (D.22342) <default: <D.22346>, case 0: <D.19080>, case 1: <D.19081>>
  <D.19080>:
  D.22344 = idx | 100663296;
  D.22343 = mono_get_method_full (m, D.22344, 0B, context);
  return D.22343;
  <D.19081>:
  D.22345 = idx | 167772160;
  D.22343 = mono_get_method_full (m, D.22345, 0B, context);
  return D.22343;
  <D.22346>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.22343 = 0B;
  return D.22343;
}


mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.22350;
  gboolean D.22353;
  int type_token.144;
  int D.22355;
  unsigned char D.22356;
  long unsigned int D.22357;
  <unnamed-unsigned:24> D.22358;
  long unsigned int D.22359;
  void * D.22360;
  int D.22363;
  unsigned int D.22364;
  unsigned int D.22365;
  int D.22366;
  unsigned int D.22367;
  int end.145;
  unsigned int D.22370;
  unsigned int D.22372;
  unsigned int D.22373;
  int D.22374;
  long unsigned int D.22375;
  long unsigned int D.22376;
  unsigned int i.146;
  unsigned int D.22378;
  int D.22379;
  int D.22382;
  unsigned int D.22383;
  int D.22386;
  long unsigned int D.22387;
  long unsigned int D.22388;
  struct MonoMethod * * D.22389;
  unsigned int D.22390;
  sizetype D.22393;
  sizetype D.22394;
  sizetype D.22395;
  struct MonoMethod * * D.22396;
  struct MonoError error;
  struct locator_t loc;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 end;
  gint32 i;
  gint32 num;
  guint32 cols[3];
  struct MonoMethod * * result;
  gint32 ok;

  try
    {
      tdef = &image->tables[25];
      ok = 1;
      *overrides = 0B;
      if (num_overrides != 0B) goto <D.22348>; else goto <D.22349>;
      <D.22348>:
      *num_overrides = 0;
      <D.22349>:
      D.22350 = tdef->base;
      if (D.22350 == 0B) goto <D.22351>; else goto <D.22352>;
      <D.22351>:
      D.22353 = 1;
      return D.22353;
      <D.22352>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.144 = (int) type_token;
      D.22355 = type_token.144 & 16777215;
      loc.idx = D.22355;
      D.22356 = tdef->row_size;
      D.22357 = (long unsigned int) D.22356;
      D.22358 = tdef->rows;
      D.22359 = (long unsigned int) D.22358;
      D.22350 = tdef->base;
      D.22360 = mono_binary_search (&loc, D.22350, D.22359, D.22357, table_locator);
      if (D.22360 == 0B) goto <D.22361>; else goto <D.22362>;
      <D.22361>:
      D.22353 = 1;
      return D.22353;
      <D.22362>:
      start = loc.result;
      end = start + 1;
      goto <D.19101>;
      <D.19100>:
      D.22363 = loc.idx;
      D.22364 = (unsigned int) D.22363;
      D.22365 = start + 4294967295;
      D.22366 = (int) D.22365;
      D.22367 = mono_metadata_decode_row_col (tdef, D.22366, 0);
      if (D.22364 == D.22367) goto <D.22368>; else goto <D.19099>;
      <D.22368>:
      start = start + 4294967295;
      <D.19101>:
      if (start != 0) goto <D.19100>; else goto <D.19099>;
      <D.19099>:
      goto <D.19104>;
      <D.19103>:
      D.22363 = loc.idx;
      D.22364 = (unsigned int) D.22363;
      end.145 = (int) end;
      D.22370 = mono_metadata_decode_row_col (tdef, end.145, 0);
      if (D.22364 == D.22370) goto <D.22371>; else goto <D.19102>;
      <D.22371>:
      end = end + 1;
      <D.19104>:
      D.22358 = tdef->rows;
      D.22372 = (unsigned int) D.22358;
      if (D.22372 > end) goto <D.19103>; else goto <D.19102>;
      <D.19102>:
      D.22373 = end - start;
      num = (gint32) D.22373;
      D.22374 = num * 2;
      D.22375 = (long unsigned int) D.22374;
      D.22376 = D.22375 * 8;
      result = monoeg_malloc (D.22376);
      i = 0;
      goto <D.19108>;
      <D.19107>:
      {
        struct MonoMethod * method;

        i.146 = (unsigned int) i;
        D.22378 = start + i.146;
        D.22379 = mono_verifier_verify_methodimpl_row (image, D.22378, &error);
        if (D.22379 == 0) goto <D.22380>; else goto <D.22381>;
        <D.22380>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.19106>;
        <D.22381>:
        i.146 = (unsigned int) i;
        D.22378 = start + i.146;
        D.22382 = (int) D.22378;
        mono_metadata_decode_row (tdef, D.22382, &cols, 3);
        D.22383 = cols[2];
        method = method_from_method_def_or_ref (image, D.22383, generic_context);
        if (method == 0B) goto <D.22384>; else goto <D.22385>;
        <D.22384>:
        ok = 0;
        <D.22385>:
        D.22386 = i * 2;
        D.22387 = (long unsigned int) D.22386;
        D.22388 = D.22387 * 8;
        D.22389 = result + D.22388;
        *D.22389 = method;
        D.22390 = cols[1];
        method = method_from_method_def_or_ref (image, D.22390, generic_context);
        if (method == 0B) goto <D.22391>; else goto <D.22392>;
        <D.22391>:
        ok = 0;
        <D.22392>:
        D.22386 = i * 2;
        D.22393 = (sizetype) D.22386;
        D.22394 = D.22393 + 1;
        D.22395 = D.22394 * 8;
        D.22396 = result + D.22395;
        *D.22396 = method;
      }
      i = i + 1;
      <D.19108>:
      if (i < num) goto <D.19107>; else goto <D.19106>;
      <D.19106>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.22397>; else goto <D.22398>;
      <D.22397>:
      *num_overrides = num;
      <D.22398>:
      D.22353 = ok;
      return D.22353;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.22401;
  const guint8 * D.22402;
  unsigned char D.22403;
  int D.22404;
  const guint8 * D.22405;
  unsigned char D.22406;
  int D.22407;
  const guint8 * D.22408;
  unsigned char D.22409;
  int D.22410;
  const guint8 * D.22411;
  unsigned char D.22412;
  int D.22413;
  const guint8 * D.22414;
  unsigned char D.22415;
  int D.22416;
  const guint8 * D.22417;
  unsigned char D.22418;
  int D.22419;
  const guint8 * D.22420;
  unsigned char D.22421;
  int D.22422;
  const guint8 * D.22423;
  unsigned char D.22424;
  int D.22425;
  const guint8 * D.22426;
  unsigned char D.22427;
  int D.22428;
  const guint8 * D.22429;
  unsigned char D.22430;
  int D.22431;
  const guint8 * D.22432;
  unsigned char D.22433;
  int D.22434;
  const guint8 * D.22435;
  unsigned char D.22436;
  int D.22437;
  unsigned char D.22438;
  int D.22439;
  const guint8 * D.22440;
  unsigned char D.22441;
  int D.22442;
  const guint8 * D.22443;
  unsigned char D.22444;
  int D.22445;
  const guint8 * D.22446;
  unsigned char D.22447;
  int D.22448;

  D.22402 = guid + 15;
  D.22403 = *D.22402;
  D.22404 = (int) D.22403;
  D.22405 = guid + 14;
  D.22406 = *D.22405;
  D.22407 = (int) D.22406;
  D.22408 = guid + 13;
  D.22409 = *D.22408;
  D.22410 = (int) D.22409;
  D.22411 = guid + 12;
  D.22412 = *D.22411;
  D.22413 = (int) D.22412;
  D.22414 = guid + 11;
  D.22415 = *D.22414;
  D.22416 = (int) D.22415;
  D.22417 = guid + 10;
  D.22418 = *D.22417;
  D.22419 = (int) D.22418;
  D.22420 = guid + 9;
  D.22421 = *D.22420;
  D.22422 = (int) D.22421;
  D.22423 = guid + 8;
  D.22424 = *D.22423;
  D.22425 = (int) D.22424;
  D.22426 = guid + 6;
  D.22427 = *D.22426;
  D.22428 = (int) D.22427;
  D.22429 = guid + 7;
  D.22430 = *D.22429;
  D.22431 = (int) D.22430;
  D.22432 = guid + 4;
  D.22433 = *D.22432;
  D.22434 = (int) D.22433;
  D.22435 = guid + 5;
  D.22436 = *D.22435;
  D.22437 = (int) D.22436;
  D.22438 = *guid;
  D.22439 = (int) D.22438;
  D.22440 = guid + 1;
  D.22441 = *D.22440;
  D.22442 = (int) D.22441;
  D.22443 = guid + 2;
  D.22444 = *D.22443;
  D.22445 = (int) D.22444;
  D.22446 = guid + 3;
  D.22447 = *D.22446;
  D.22448 = (int) D.22447;
  D.22401 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.22448, D.22445, D.22442, D.22439, D.22437, D.22434, D.22431, D.22428, D.22425, D.22422, D.22419, D.22416, D.22413, D.22410, D.22407, D.22404);
  return D.22401;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.22450;
  long int D.22451;
  long int D.22452;
  const char * D.22455;
  guint32 D.22458;
  unsigned int D.22459;
  unsigned int D.22466;
  unsigned int D.22467;
  unsigned int D.22468;
  unsigned int D.22469;
  int D.22470;
  unsigned char D.22471;
  long unsigned int D.22472;
  <unnamed-unsigned:24> D.22473;
  long unsigned int D.22474;
  void * D.22475;
  unsigned int D.22478;
  unsigned int D.22479;
  int D.22481;
  unsigned int D.22482;
  int D.22483;
  unsigned int D.22484;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.22450 = owner == 0B;
      D.22451 = (long int) D.22450;
      D.22452 = __builtin_expect (D.22451, 0);
      if (D.22452 != 0) goto <D.22453>; else goto <D.22454>;
      <D.22453>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.22454>:
      D.22455 = tdef->base;
      if (D.22455 == 0B) goto <D.22456>; else goto <D.22457>;
      <D.22456>:
      D.22458 = 0;
      return D.22458;
      <D.22457>:
      D.22459 = token >> 24;
      if (D.22459 == 2) goto <D.22460>; else goto <D.22461>;
      <D.22460>:
      *owner = 0;
      goto <D.22462>;
      <D.22461>:
      D.22459 = token >> 24;
      if (D.22459 == 6) goto <D.22463>; else goto <D.22464>;
      <D.22463>:
      *owner = 1;
      goto <D.22465>;
      <D.22464>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.19141>:
      goto <D.19141>;
      D.22458 = 0;
      return D.22458;
      <D.22465>:
      <D.22462>:
      D.22466 = *owner;
      D.22467 = token & 16777215;
      D.22468 = D.22467 << 1;
      D.22469 = D.22466 | D.22468;
      *owner = D.22469;
      D.22466 = *owner;
      D.22470 = (int) D.22466;
      loc.idx = D.22470;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22471 = tdef->row_size;
      D.22472 = (long unsigned int) D.22471;
      D.22473 = tdef->rows;
      D.22474 = (long unsigned int) D.22473;
      D.22455 = tdef->base;
      D.22475 = mono_binary_search (&loc, D.22455, D.22474, D.22472, table_locator);
      if (D.22475 == 0B) goto <D.22476>; else goto <D.22477>;
      <D.22476>:
      D.22458 = 0;
      return D.22458;
      <D.22477>:
      goto <D.19143>;
      <D.19142>:
      D.22478 = loc.result;
      D.22479 = D.22478 + 4294967295;
      loc.result = D.22479;
      <D.19143>:
      D.22478 = loc.result;
      if (D.22478 != 0) goto <D.22480>; else goto <D.19144>;
      <D.22480>:
      D.22478 = loc.result;
      D.22479 = D.22478 + 4294967295;
      D.22481 = (int) D.22479;
      D.22482 = mono_metadata_decode_row_col (tdef, D.22481, 2);
      D.22483 = loc.idx;
      D.22484 = (unsigned int) D.22483;
      if (D.22482 == D.22484) goto <D.19142>; else goto <D.19144>;
      <D.19144>:
      D.22478 = loc.result;
      D.22458 = D.22478 + 1;
      return D.22458;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_has_generic_params (struct MonoImage * image, guint32 token)
{
  gboolean D.22487;
  unsigned int D.22488;
  guint32 owner;

  try
    {
      D.22488 = mono_metadata_get_generic_param_row (image, token, &owner);
      D.22487 = (gboolean) D.22488;
      return D.22487;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.22493;
  struct MonoGenericParamFull * D.22494;
  long unsigned int D.22495;
  long unsigned int D.22496;
  struct MonoGenericParamFull * D.22497;
  struct MonoClass * * * D.22498;
  unsigned int D.22499;
  int D.22500;
  int D.22501;
  <unnamed-signed:31> D.22504;
  unsigned int D.22505;
  guint32 start_row;
  guint32 i;
  guint32 owner;

  try
    {
      start_row = mono_metadata_get_generic_param_row (image, token, &owner);
      if (start_row == 0) goto <D.22491>; else goto <D.22492>;
      <D.22491>:
      D.22493 = 1;
      return D.22493;
      <D.22492>:
      i = 0;
      goto <D.19159>;
      <D.19158>:
      D.22494 = container->type_params;
      D.22495 = (long unsigned int) i;
      D.22496 = D.22495 * 56;
      D.22497 = D.22494 + D.22496;
      D.22498 = &D.22497->info.constraints;
      D.22499 = start_row + i;
      D.22500 = (int) D.22499;
      D.22501 = get_constraints (image, D.22500, D.22498, container);
      if (D.22501 == 0) goto <D.22502>; else goto <D.22503>;
      <D.22502>:
      D.22493 = 0;
      return D.22493;
      <D.22503>:
      i = i + 1;
      <D.19159>:
      D.22504 = container->type_argc;
      D.22505 = (unsigned int) D.22504;
      if (D.22505 > i) goto <D.19158>; else goto <D.19160>;
      <D.19160>:
      D.22493 = 1;
      return D.22493;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.147;
  unsigned int D.22509;
  unsigned int owner.148;
  unsigned int D.22513;
  gboolean D.22516;
  <unnamed-unsigned:24> D.22519;
  unsigned int D.22520;
  unsigned int D.22523;
  unsigned int D.22524;
  long unsigned int D.22525;
  long unsigned int D.22526;
  struct MonoClass * * D.22527;
  void * D.22528;
  struct MonoTableInfo * tdef;
  guint32 cols[2];
  guint32 i;
  guint32 token;
  guint32 found;
  struct MonoClass * klass;
  struct MonoClass * * res;
  struct GSList * cons;
  struct GSList * tmp;
  struct MonoGenericContext * context;

  try
    {
      tdef = &image->tables[44];
      cons = 0B;
      context = &container->context;
      *constraints = 0B;
      found = 0;
      i = 0;
      goto <D.19130>;
      <D.19129>:
      i.147 = (int) i;
      mono_metadata_decode_row (tdef, i.147, &cols, 2);
      D.22509 = cols[0];
      owner.148 = (unsigned int) owner;
      if (D.22509 == owner.148) goto <D.22511>; else goto <D.22512>;
      <D.22511>:
      D.22513 = cols[1];
      token = mono_metadata_token_from_dor (D.22513);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.22514>; else goto <D.22515>;
      <D.22514>:
      monoeg_g_slist_free (cons);
      D.22516 = 0;
      return D.22516;
      <D.22515>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.22517>;
      <D.22512>:
      if (found != 0) goto <D.19128>; else goto <D.22518>;
      <D.22518>:
      <D.22517>:
      i = i + 1;
      <D.19130>:
      D.22519 = tdef->rows;
      D.22520 = (unsigned int) D.22519;
      if (D.22520 > i) goto <D.19129>; else goto <D.19128>;
      <D.19128>:
      if (found == 0) goto <D.22521>; else goto <D.22522>;
      <D.22521>:
      D.22516 = 1;
      return D.22516;
      <D.22522>:
      D.22523 = found + 1;
      D.22524 = D.22523 * 8;
      res = mono_image_alloc0 (image, D.22524);
      i = 0;
      tmp = cons;
      goto <D.19132>;
      <D.19131>:
      D.22525 = (long unsigned int) i;
      D.22526 = D.22525 * 8;
      D.22527 = res + D.22526;
      D.22528 = tmp->data;
      *D.22527 = D.22528;
      i = i + 1;
      tmp = tmp->next;
      <D.19132>:
      if (i < found) goto <D.19131>; else goto <D.19133>;
      <D.19133>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.22516 = 1;
      return D.22516;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_load_generic_param_constraints (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  mono_metadata_load_generic_param_constraints_full (image, token, container);
}


mono_metadata_load_generic_params (struct MonoImage * image, guint32 token, struct MonoGenericContainer * parent_container)
{
  struct MonoGenericContainer * D.22533;
  unsigned int D.22534;
  int D.22535;
  long unsigned int D.22536;
  long unsigned int D.22537;
  unsigned int D.22538;
  long unsigned int D.22539;
  long unsigned int D.22540;
  void * D.22541;
  struct MonoGenericParamFull * D.22542;
  unsigned int D.22543;
  short unsigned int D.22544;
  unsigned int D.22545;
  unsigned int D.22546;
  short unsigned int D.22547;
  unsigned int D.22548;
  const char * D.22549;
  short unsigned int D.22550;
  unsigned int D.22551;
  <unnamed-unsigned:24> D.22554;
  unsigned int D.22555;
  unsigned int D.22557;
  unsigned int owner.149;
  int n.150;
  <unnamed-signed:31> D.22560;
  unsigned int D.22561;
  void * D.22562;
  struct MonoGenericParamFull * D.22563;
  unsigned int D.22564;
  int iftmp.151;
  struct MonoGenericContainer * D.22570;
  unsigned char D.22572;
  unsigned char D.22573;
  _Bool D.22575;
  long int D.22576;
  long int D.22577;
  struct MonoGenericInst * iftmp.152;
  struct MonoGenericInst * D.22586;
  struct MonoGenericInst * D.22588;
  struct MonoTableInfo * tdef;
  guint32 cols[4];
  guint32 i;
  guint32 owner;
  guint32 n;
  struct MonoGenericContainer * container;
  struct MonoGenericParamFull * params;
  struct MonoGenericContext * context;

  try
    {
      tdef = &image->tables[42];
      owner = 0;
      i = mono_metadata_get_generic_param_row (image, token, &owner);
      if (i == 0) goto <D.22531>; else goto <D.22532>;
      <D.22531>:
      D.22533 = 0B;
      return D.22533;
      <D.22532>:
      D.22534 = i + 4294967295;
      D.22535 = (int) D.22534;
      mono_metadata_decode_row (tdef, D.22535, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 56);
      container->image = image;
      <D.19180>:
      n = n + 1;
      D.22536 = (long unsigned int) n;
      D.22537 = D.22536 * 56;
      params = monoeg_realloc (params, D.22537);
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22541 = params + D.22540;
      memset (D.22541, 0, 56);
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22542->param.owner = container;
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22543 = cols[0];
      D.22544 = (short unsigned int) D.22543;
      D.22542->param.num = D.22544;
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22545 = i | 704643072;
      D.22542->info.token = D.22545;
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22546 = cols[1];
      D.22547 = (short unsigned int) D.22546;
      D.22542->info.flags = D.22547;
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22548 = cols[3];
      D.22549 = mono_metadata_string_heap (image, D.22548);
      D.22542->info.name = D.22549;
      D.22538 = n + 4294967295;
      D.22539 = (long unsigned int) D.22538;
      D.22540 = D.22539 * 56;
      D.22542 = params + D.22540;
      D.22550 = D.22542->param.num;
      D.22551 = (unsigned int) D.22550;
      D.22538 = n + 4294967295;
      if (D.22551 != D.22538) goto <D.22552>; else goto <D.22553>;
      <D.22552>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.22553>:
      i = i + 1;
      D.22554 = tdef->rows;
      D.22555 = (unsigned int) D.22554;
      if (i > D.22555) goto <D.19179>; else goto <D.22556>;
      <D.22556>:
      D.22534 = i + 4294967295;
      D.22535 = (int) D.22534;
      mono_metadata_decode_row (tdef, D.22535, &cols, 4);
      D.22557 = cols[2];
      owner.149 = owner;
      if (D.22557 == owner.149) goto <D.19180>; else goto <D.19179>;
      <D.19179>:
      n.150 = (int) n;
      D.22560 = (<unnamed-signed:31>) n.150;
      container->type_argc = D.22560;
      D.22561 = n * 56;
      D.22562 = mono_image_alloc0 (image, D.22561);
      container->type_params = D.22562;
      D.22536 = (long unsigned int) n;
      D.22537 = D.22536 * 56;
      D.22563 = container->type_params;
      memcpy (D.22563, params, D.22537);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.22564 = token >> 24;
      if (D.22564 == 6) goto <D.22565>; else goto <D.22566>;
      <D.22565>:
      container->is_method = -1;
      <D.22566>:
      D.22570 = container->parent;
      if (D.22570 != 0B) goto <D.22571>; else goto <D.22568>;
      <D.22571>:
      D.22572 = BIT_FIELD_REF <*container, 8, 280>;
      D.22573 = D.22572 & 128;
      if (D.22573 == 0) goto <D.22574>; else goto <D.22568>;
      <D.22574>:
      iftmp.151 = 1;
      goto <D.22569>;
      <D.22568>:
      iftmp.151 = 0;
      <D.22569>:
      D.22575 = iftmp.151 != 0;
      D.22576 = (long int) D.22575;
      D.22577 = __builtin_expect (D.22576, 0);
      if (D.22577 != 0) goto <D.22578>; else goto <D.22579>;
      <D.22578>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.22579>:
      context = &container->context;
      D.22572 = BIT_FIELD_REF <*container, 8, 280>;
      D.22573 = D.22572 & 128;
      if (D.22573 != 0) goto <D.22580>; else goto <D.22581>;
      <D.22580>:
      D.22570 = container->parent;
      if (D.22570 != 0B) goto <D.22583>; else goto <D.22584>;
      <D.22583>:
      D.22570 = container->parent;
      iftmp.152 = D.22570->context.class_inst;
      goto <D.22585>;
      <D.22584>:
      iftmp.152 = 0B;
      <D.22585>:
      context->class_inst = iftmp.152;
      D.22586 = mono_get_shared_generic_inst (container);
      context->method_inst = D.22586;
      goto <D.22587>;
      <D.22581>:
      D.22588 = mono_get_shared_generic_inst (container);
      context->class_inst = D.22588;
      <D.22587>:
      D.22533 = container;
      return D.22533;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.22591;
  long unsigned int D.22592;
  long unsigned int D.22593;
  long unsigned int D.22594;
  long unsigned int D.22595;
  long unsigned int D.22596;
  unsigned char iftmp.153;
  unsigned char D.22598;
  unsigned char D.22599;
  struct MonoGenericParamFull * D.22603;
  long unsigned int D.22604;
  struct MonoGenericParam * D.22605;
  long unsigned int D.22606;
  struct MonoType * * D.22607;
  int D.22608;
  struct MonoGenericInst * D.22609;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.22591 = container->type_argc;
  D.22592 = (long unsigned int) D.22591;
  D.22593 = D.22592 * 8;
  type_argv = monoeg_malloc0 (D.22593);
  D.22591 = container->type_argc;
  D.22592 = (long unsigned int) D.22591;
  D.22594 = D.22592 * 16;
  helper = monoeg_malloc0 (D.22594);
  i = 0;
  goto <D.19190>;
  <D.19189>:
  {
    struct MonoType * t;

    D.22595 = (long unsigned int) i;
    D.22596 = D.22595 * 16;
    t = helper + D.22596;
    D.22598 = BIT_FIELD_REF <*container, 8, 280>;
    D.22599 = D.22598 & 128;
    if (D.22599 != 0) goto <D.22600>; else goto <D.22601>;
    <D.22600>:
    iftmp.153 = 30;
    goto <D.22602>;
    <D.22601>:
    iftmp.153 = 19;
    <D.22602>:
    t->type = iftmp.153;
    D.22603 = container->type_params;
    D.22595 = (long unsigned int) i;
    D.22604 = D.22595 * 56;
    D.22605 = D.22603 + D.22604;
    t->data.generic_param = D.22605;
    D.22595 = (long unsigned int) i;
    D.22606 = D.22595 * 8;
    D.22607 = type_argv + D.22606;
    *D.22607 = t;
  }
  i = i + 1;
  <D.19190>:
  D.22591 = container->type_argc;
  D.22608 = (int) D.22591;
  if (D.22608 > i) goto <D.19189>; else goto <D.19191>;
  <D.19191>:
  D.22591 = container->type_argc;
  D.22608 = (int) D.22591;
  nginst = mono_metadata_get_generic_inst (D.22608, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.22609 = nginst;
  return D.22609;
}


mono_type_is_byref (struct MonoType * type)
{
  mono_bool D.22611;
  <unnamed-unsigned:1> D.22612;

  D.22612 = type->byref;
  D.22611 = (mono_bool) D.22612;
  return D.22611;
}


mono_type_get_type (struct MonoType * type)
{
  int D.22614;
  unsigned char D.22615;

  D.22615 = type->type;
  D.22614 = (int) D.22615;
  return D.22614;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.22617;
  _Bool D.22618;
  long int D.22619;
  long int D.22620;
  struct MonoMethodSignature * D.22623;

  D.22617 = type->type;
  D.22618 = D.22617 != 27;
  D.22619 = (long int) D.22618;
  D.22620 = __builtin_expect (D.22619, 0);
  if (D.22620 != 0) goto <D.22621>; else goto <D.22622>;
  <D.22621>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.22622>:
  D.22623 = type->data.method;
  return D.22623;
}


mono_type_get_class (struct MonoType * type)
{
  struct MonoClass * D.22625;

  D.22625 = type->data.klass;
  return D.22625;
}


mono_type_get_array_type (struct MonoType * type)
{
  struct MonoArrayType * D.22627;

  D.22627 = type->data.array;
  return D.22627;
}


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.22629;
  _Bool D.22630;
  long int D.22631;
  long int D.22632;
  struct MonoType * D.22635;

  D.22629 = type->type;
  D.22630 = D.22629 != 15;
  D.22631 = (long int) D.22630;
  D.22632 = __builtin_expect (D.22631, 0);
  if (D.22632 != 0) goto <D.22633>; else goto <D.22634>;
  <D.22633>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.22634>:
  D.22635 = type->data.type;
  return D.22635;
}


mono_type_get_modifiers (struct MonoType * type, gboolean * is_required, void * * iter)
{
  struct MonoClass * D.22637;

  D.22637 = 0B;
  return D.22637;
}


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.22639;
  int iftmp.154;
  unsigned char D.22645;
  unsigned char D.22646;
  unsigned char D.22648;
  struct MonoClass * D.22650;
  unsigned char D.22651;
  unsigned char D.22652;
  struct MonoGenericClass * D.22655;
  int D.22656;
  struct MonoClass * D.22658;
  unsigned char D.22659;
  unsigned char D.22660;

  D.22645 = BIT_FIELD_REF <*type, 8, 88>;
  D.22646 = D.22645 & 64;
  if (D.22646 == 0) goto <D.22647>; else goto <D.22641>;
  <D.22647>:
  D.22648 = type->type;
  if (D.22648 == 17) goto <D.22649>; else goto <D.22642>;
  <D.22649>:
  D.22650 = type->data.klass;
  D.22651 = BIT_FIELD_REF <*D.22650, 8, 256>;
  D.22652 = D.22651 & 16;
  if (D.22652 == 0) goto <D.22643>; else goto <D.22642>;
  <D.22642>:
  D.22648 = type->type;
  if (D.22648 == 22) goto <D.22643>; else goto <D.22653>;
  <D.22653>:
  D.22648 = type->type;
  if (D.22648 == 21) goto <D.22654>; else goto <D.22641>;
  <D.22654>:
  D.22655 = type->data.generic_class;
  D.22656 = mono_metadata_generic_class_is_valuetype (D.22655);
  if (D.22656 != 0) goto <D.22657>; else goto <D.22641>;
  <D.22657>:
  D.22655 = type->data.generic_class;
  D.22658 = D.22655->container_class;
  D.22659 = BIT_FIELD_REF <*D.22658, 8, 256>;
  D.22660 = D.22659 & 16;
  if (D.22660 == 0) goto <D.22643>; else goto <D.22641>;
  <D.22643>:
  iftmp.154 = 1;
  goto <D.22644>;
  <D.22641>:
  iftmp.154 = 0;
  <D.22644>:
  D.22639 = iftmp.154;
  return D.22639;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.22662;
  int iftmp.155;
  short unsigned int D.22667;
  short unsigned int D.22668;

  if (type != 0B) goto <D.22666>; else goto <D.22664>;
  <D.22666>:
  D.22667 = BIT_FIELD_REF <*type, 16, 80>;
  D.22668 = D.22667 & 16639;
  if (D.22668 == 1) goto <D.22669>; else goto <D.22664>;
  <D.22669>:
  iftmp.155 = 1;
  goto <D.22665>;
  <D.22664>:
  iftmp.155 = 0;
  <D.22665>:
  D.22662 = iftmp.155;
  return D.22662;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.22671;
  int iftmp.156;
  unsigned char D.22677;
  unsigned char D.22678;
  unsigned char D.22680;

  if (type != 0B) goto <D.22676>; else goto <D.22673>;
  <D.22676>:
  D.22677 = BIT_FIELD_REF <*type, 8, 88>;
  D.22678 = D.22677 & 64;
  if (D.22678 != 0) goto <D.22674>; else goto <D.22679>;
  <D.22679>:
  D.22680 = type->type;
  if (D.22680 == 24) goto <D.22674>; else goto <D.22681>;
  <D.22681>:
  D.22680 = type->type;
  if (D.22680 == 14) goto <D.22674>; else goto <D.22682>;
  <D.22682>:
  D.22680 = type->type;
  if (D.22680 == 29) goto <D.22674>; else goto <D.22683>;
  <D.22683>:
  D.22680 = type->type;
  if (D.22680 == 18) goto <D.22674>; else goto <D.22684>;
  <D.22684>:
  D.22680 = type->type;
  if (D.22680 == 25) goto <D.22674>; else goto <D.22685>;
  <D.22685>:
  D.22680 = type->type;
  if (D.22680 == 28) goto <D.22674>; else goto <D.22686>;
  <D.22686>:
  D.22680 = type->type;
  if (D.22680 == 20) goto <D.22674>; else goto <D.22687>;
  <D.22687>:
  D.22680 = type->type;
  if (D.22680 == 15) goto <D.22674>; else goto <D.22688>;
  <D.22688>:
  D.22680 = type->type;
  if (D.22680 == 27) goto <D.22674>; else goto <D.22673>;
  <D.22674>:
  iftmp.156 = 1;
  goto <D.22675>;
  <D.22673>:
  iftmp.156 = 0;
  <D.22675>:
  D.22671 = iftmp.156;
  return D.22671;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.22690;
  int iftmp.157;
  unsigned char D.22696;
  _Bool D.22697;
  _Bool D.22698;
  _Bool D.22699;
  unsigned char D.22701;
  struct MonoGenericClass * D.22706;
  int D.22707;

  if (type != 0B) goto <D.22695>; else goto <D.22692>;
  <D.22695>:
  D.22696 = type->type;
  D.22697 = D.22696 == 14;
  D.22698 = D.22696 == 29;
  D.22699 = D.22697 | D.22698;
  if (D.22699 != 0) goto <D.22693>; else goto <D.22700>;
  <D.22700>:
  D.22701 = type->type;
  if (D.22701 == 18) goto <D.22693>; else goto <D.22702>;
  <D.22702>:
  D.22701 = type->type;
  if (D.22701 == 28) goto <D.22693>; else goto <D.22703>;
  <D.22703>:
  D.22701 = type->type;
  if (D.22701 == 20) goto <D.22693>; else goto <D.22704>;
  <D.22704>:
  D.22701 = type->type;
  if (D.22701 == 21) goto <D.22705>; else goto <D.22692>;
  <D.22705>:
  D.22706 = type->data.generic_class;
  D.22707 = mono_metadata_generic_class_is_valuetype (D.22706);
  if (D.22707 == 0) goto <D.22693>; else goto <D.22692>;
  <D.22693>:
  iftmp.157 = 1;
  goto <D.22694>;
  <D.22692>:
  iftmp.157 = 0;
  <D.22694>:
  D.22690 = iftmp.157;
  return D.22690;
}


mono_signature_get_return_type (struct MonoMethodSignature * sig)
{
  struct MonoType * D.22709;

  D.22709 = sig->ret;
  return D.22709;
}


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.22713;
  void * D.22714;
  short unsigned int D.22717;
  struct MonoType * * D.22720;
  int D.22721;
  struct MonoType * * D.22722;
  struct MonoType * * type;

  if (iter == 0B) goto <D.22711>; else goto <D.22712>;
  <D.22711>:
  D.22713 = 0B;
  return D.22713;
  <D.22712>:
  D.22714 = *iter;
  if (D.22714 == 0B) goto <D.22715>; else goto <D.22716>;
  <D.22715>:
  D.22717 = sig->param_count;
  if (D.22717 != 0) goto <D.22718>; else goto <D.22719>;
  <D.22718>:
  D.22720 = &sig->params[0];
  *iter = D.22720;
  D.22713 = sig->params[0];
  return D.22713;
  <D.22719>:
  D.22713 = 0B;
  return D.22713;
  <D.22716>:
  type = *iter;
  type = type + 8;
  D.22717 = sig->param_count;
  D.22721 = (int) D.22717;
  D.22722 = &sig->params[D.22721];
  if (D.22722 > type) goto <D.22723>; else goto <D.22724>;
  <D.22723>:
  *iter = type;
  D.22713 = *type;
  return D.22713;
  <D.22724>:
  D.22713 = 0B;
  return D.22713;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.22726;
  short unsigned int D.22727;

  D.22727 = sig->param_count;
  D.22726 = (uint32_t) D.22727;
  return D.22726;
}


mono_signature_get_call_conv (struct MonoMethodSignature * sig)
{
  uint32_t D.22729;
  <unnamed-unsigned:6> D.22730;

  D.22730 = sig->call_convention;
  D.22729 = (uint32_t) D.22730;
  return D.22729;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.22732;
  short int D.22733;

  D.22733 = sig->sentinelpos;
  D.22732 = (int) D.22733;
  return D.22732;
}


mono_signature_is_instance (struct MonoMethodSignature * sig)
{
  mono_bool D.22735;
  <unnamed-unsigned:1> D.22736;

  D.22736 = sig->hasthis;
  D.22735 = (mono_bool) D.22736;
  return D.22735;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.158;
  short unsigned int D.22743;
  int D.22744;
  _Bool D.22745;
  long int D.22746;
  long int D.22747;
  mono_bool D.22750;
  struct MonoType * D.22751;
  short unsigned int D.22752;
  int D.22753;
  int D.22754;
  _Bool D.22755;

  if (param_num < 0) goto <D.22739>; else goto <D.22742>;
  <D.22742>:
  D.22743 = sig->param_count;
  D.22744 = (int) D.22743;
  if (D.22744 <= param_num) goto <D.22739>; else goto <D.22740>;
  <D.22739>:
  iftmp.158 = 1;
  goto <D.22741>;
  <D.22740>:
  iftmp.158 = 0;
  <D.22741>:
  D.22745 = iftmp.158 != 0;
  D.22746 = (long int) D.22745;
  D.22747 = __builtin_expect (D.22746, 0);
  if (D.22747 != 0) goto <D.22748>; else goto <D.22749>;
  <D.22748>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.22749>:
  D.22751 = sig->params[param_num];
  D.22752 = D.22751->attrs;
  D.22753 = (int) D.22752;
  D.22754 = D.22753 & 2;
  D.22755 = D.22754 != 0;
  D.22750 = (mono_bool) D.22755;
  return D.22750;
}


mono_signature_explicit_this (struct MonoMethodSignature * sig)
{
  mono_bool D.22757;
  <unnamed-unsigned:1> D.22758;

  D.22758 = sig->explicit_this;
  D.22757 = (mono_bool) D.22758;
  return D.22757;
}


mono_aligned_addr_hash (const void * ptr)
{
  guint D.22760;
  long int ptr.159;
  unsigned int D.22762;

  ptr.159 = (long int) ptr;
  D.22762 = (unsigned int) ptr.159;
  D.22760 = D.22762 >> 3;
  return D.22760;
}


mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.22764;
  struct MonoGenericClass * D.22765;
  struct MonoClassField * D.22768;
  long int field.160;
  struct MonoClassField * D.22770;
  long int D.22771;
  long int D.22772;
  long int D.22773;
  struct MonoClassField * D.22774;
  long unsigned int D.22775;
  long unsigned int D.22776;
  struct MonoClass * gtd;
  int offset;

  D.22764 = field->parent;
  D.22765 = D.22764->generic_class;
  if (D.22765 == 0B) goto <D.22766>; else goto <D.22767>;
  <D.22766>:
  D.22768 = field;
  return D.22768;
  <D.22767>:
  D.22764 = field->parent;
  D.22765 = D.22764->generic_class;
  gtd = D.22765->container_class;
  field.160 = (long int) field;
  D.22764 = field->parent;
  D.22770 = D.22764->fields;
  D.22771 = (long int) D.22770;
  D.22772 = field.160 - D.22771;
  D.22773 = D.22772 /[ex] 32;
  offset = (int) D.22773;
  D.22774 = gtd->fields;
  D.22775 = (long unsigned int) offset;
  D.22776 = D.22775 * 32;
  D.22768 = D.22774 + D.22776;
  return D.22768;
}


mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.22778;
  struct MonoGenericClass * D.22779;
  struct MonoEvent * D.22782;
  long int event.161;
  struct MonoClassExt * D.22784;
  struct MonoEvent * D.22785;
  long int D.22786;
  long int D.22787;
  long int D.22788;
  struct MonoClassExt * D.22789;
  struct MonoEvent * D.22790;
  long unsigned int D.22791;
  long unsigned int D.22792;
  struct MonoClass * gtd;
  int offset;

  D.22778 = event->parent;
  D.22779 = D.22778->generic_class;
  if (D.22779 == 0B) goto <D.22780>; else goto <D.22781>;
  <D.22780>:
  D.22782 = event;
  return D.22782;
  <D.22781>:
  D.22778 = event->parent;
  D.22779 = D.22778->generic_class;
  gtd = D.22779->container_class;
  event.161 = (long int) event;
  D.22778 = event->parent;
  D.22784 = D.22778->ext;
  D.22785 = D.22784->events;
  D.22786 = (long int) D.22785;
  D.22787 = event.161 - D.22786;
  D.22788 = D.22787 /[ex] 56;
  offset = (int) D.22788;
  D.22789 = gtd->ext;
  D.22790 = D.22789->events;
  D.22791 = (long unsigned int) offset;
  D.22792 = D.22791 * 56;
  D.22782 = D.22790 + D.22792;
  return D.22782;
}


mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.22794;
  struct MonoGenericClass * D.22795;
  struct MonoProperty * D.22798;
  long int property.162;
  struct MonoClassExt * D.22800;
  struct MonoProperty * D.22801;
  long int D.22802;
  long int D.22803;
  long int D.22804;
  struct MonoClassExt * D.22805;
  struct MonoProperty * D.22806;
  long unsigned int D.22807;
  long unsigned int D.22808;
  struct MonoClass * gtd;
  int offset;

  D.22794 = property->parent;
  D.22795 = D.22794->generic_class;
  if (D.22795 == 0B) goto <D.22796>; else goto <D.22797>;
  <D.22796>:
  D.22798 = property;
  return D.22798;
  <D.22797>:
  D.22794 = property->parent;
  D.22795 = D.22794->generic_class;
  gtd = D.22795->container_class;
  property.162 = (long int) property;
  D.22794 = property->parent;
  D.22800 = D.22794->ext;
  D.22801 = D.22800->properties;
  D.22802 = (long int) D.22801;
  D.22803 = property.162 - D.22802;
  D.22804 = D.22803 /[ex] 40;
  offset = (int) D.22804;
  D.22805 = gtd->ext;
  D.22806 = D.22805->properties;
  D.22807 = (long unsigned int) offset;
  D.22808 = D.22807 * 40;
  D.22798 = D.22806 + D.22808;
  return D.22798;
}