mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.21469;
  short int D.21470;
  sizetype D.21471;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.21467>; else goto <D.21468>;
  <D.21467>:
  D.21469 = "";
  return D.21469;
  <D.21468>:
  D.21470 = tableidx[table];
  D.21471 = (sizetype) D.21470;
  D.21469 = &tablestr + D.21471;
  return D.21469;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.21473;
  sizetype D.21474;
  int iftmp.1;
  unsigned char D.21476;
  unsigned char D.21477;
  int iftmp.2;
  unsigned char D.21482;
  int iftmp.3;
  unsigned char D.21487;
  _Bool D.21491;
  long int D.21492;
  long int D.21493;
  int iftmp.4;
  <unnamed-unsigned:24> D.21497;
  int D.21498;
  _Bool D.21502;
  long int D.21503;
  long int D.21504;
  int iftmp.5;
  _Bool D.21511;
  long int D.21512;
  long int D.21513;
  int iftmp.6;
  <unnamed-unsigned:24> D.21517;
  int D.21518;
  unsigned int i.7;
  _Bool D.21523;
  long int D.21524;
  long int D.21525;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.21532;
  int D.21533;
  int iftmp.10;
  _Bool D.21542;
  long int D.21543;
  long int D.21544;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.21556;
  int D.21557;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.21576;
  int D.21577;
  int iftmp.16;
  _Bool D.21587;
  long int D.21588;
  long int D.21589;
  int iftmp.17;
  <unnamed-unsigned:24> D.21593;
  int D.21594;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.21607;
  int D.21608;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.21636;
  int D.21637;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.21652;
  _Bool D.21653;
  long int D.21654;
  long int D.21655;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.21679;
  int D.21680;
  int iftmp.32;
  <unnamed-unsigned:24> D.21688;
  int D.21689;
  <unnamed-unsigned:24> D.21690;
  int D.21691;
  <unnamed-unsigned:24> D.21692;
  int D.21693;
  <unnamed-unsigned:24> D.21694;
  int D.21695;
  <unnamed-unsigned:24> D.21696;
  int D.21697;
  <unnamed-unsigned:24> D.21698;
  int D.21699;
  <unnamed-unsigned:24> D.21700;
  int D.21701;
  <unnamed-unsigned:24> D.21702;
  int D.21703;
  <unnamed-unsigned:24> D.21704;
  int D.21705;
  <unnamed-unsigned:24> D.21706;
  int D.21707;
  <unnamed-unsigned:24> D.21708;
  int D.21709;
  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.21755;
  int D.21756;
  unsigned int D.21757;
  sizetype i.44;
  const unsigned char * D.21759;
  unsigned char D.21760;
  int D.21761;
  unsigned int D.21762;
  unsigned int D.21763;
  int D.21764;
  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.21473 = table_description[tableindex];
  D.21474 = (sizetype) D.21473;
  description = &TableSchemas + D.21474;
  i = 0;
  goto <D.19720>;
  <D.19719>:
  switch (code) <default: <D.21754>, case 1: <D.19674>, case 2: <D.19676>, case 3: <D.19677>, case 4: <D.19678>, case 5: <D.19679>, case 6: <D.19680>, case 7: <D.19681>, case 8: <D.19707>, case 9: <D.19708>, case 10: <D.19709>, case 11: <D.19710>, case 12: <D.19711>, case 13: <D.19712>, case 14: <D.19713>, case 15: <D.19714>, case 16: <D.19715>, case 17: <D.19716>, case 18: <D.19717>, case 19: <D.19718>>
  <D.19674>:
  field_size = 4;
  goto <D.19675>;
  <D.19676>:
  field_size = 2;
  goto <D.19675>;
  <D.19677>:
  field_size = 1;
  goto <D.19675>;
  <D.19678>:
  D.21476 = BIT_FIELD_REF <*meta, 8, 136>;
  D.21477 = D.21476 & 4;
  if (D.21477 != 0) goto <D.21478>; else goto <D.21479>;
  <D.21478>:
  iftmp.1 = 4;
  goto <D.21480>;
  <D.21479>:
  iftmp.1 = 2;
  <D.21480>:
  field_size = iftmp.1;
  goto <D.19675>;
  <D.19679>:
  D.21476 = BIT_FIELD_REF <*meta, 8, 136>;
  D.21482 = D.21476 & 1;
  if (D.21482 != 0) goto <D.21483>; else goto <D.21484>;
  <D.21483>:
  iftmp.2 = 4;
  goto <D.21485>;
  <D.21484>:
  iftmp.2 = 2;
  <D.21485>:
  field_size = iftmp.2;
  goto <D.19675>;
  <D.19680>:
  D.21476 = BIT_FIELD_REF <*meta, 8, 136>;
  D.21487 = D.21476 & 2;
  if (D.21487 != 0) goto <D.21488>; else goto <D.21489>;
  <D.21488>:
  iftmp.3 = 4;
  goto <D.21490>;
  <D.21489>:
  iftmp.3 = 2;
  <D.21490>:
  field_size = iftmp.3;
  goto <D.19675>;
  <D.19681>:
  switch (tableindex) <default: <D.19705>, case 2: <D.19702>, case 3: <D.19691>, case 5: <D.19697>, case 6: <D.19694>, case 7: <D.19699>, case 9: <D.19693>, case 15: <D.19685>, case 16: <D.19689>, case 18: <D.19686>, case 19: <D.19687>, case 21: <D.19700>, case 22: <D.19701>, case 24: <D.19696>, case 25: <D.19695>, case 28: <D.19692>, case 29: <D.19690>, case 36: <D.19684>, case 37: <D.19682>, case 39: <D.19688>, case 41: <D.19698>, case 42: <D.19703>, case 44: <D.19704>>
  <D.19682>:
  D.21491 = i != 3;
  D.21492 = (long int) D.21491;
  D.21493 = __builtin_expect (D.21492, 0);
  if (D.21493 != 0) goto <D.21494>; else goto <D.21495>;
  <D.21494>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.21495>:
  D.21497 = meta->tables[35].rows;
  D.21498 = (int) D.21497;
  if (D.21498 <= 65535) goto <D.21499>; else goto <D.21500>;
  <D.21499>:
  iftmp.4 = 2;
  goto <D.21501>;
  <D.21500>:
  iftmp.4 = 4;
  <D.21501>:
  field_size = iftmp.4;
  goto <D.19683>;
  <D.19684>:
  D.21502 = i != 1;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21505>; else goto <D.21506>;
  <D.21505>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.21506>:
  D.21497 = meta->tables[35].rows;
  D.21498 = (int) D.21497;
  if (D.21498 <= 65535) goto <D.21508>; else goto <D.21509>;
  <D.21508>:
  iftmp.5 = 2;
  goto <D.21510>;
  <D.21509>:
  iftmp.5 = 4;
  <D.21510>:
  field_size = iftmp.5;
  goto <D.19683>;
  <D.19685>:
  D.21511 = i != 2;
  D.21512 = (long int) D.21511;
  D.21513 = __builtin_expect (D.21512, 0);
  if (D.21513 != 0) goto <D.21514>; else goto <D.21515>;
  <D.21514>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.21515>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21519>; else goto <D.21520>;
  <D.21519>:
  iftmp.6 = 2;
  goto <D.21521>;
  <D.21520>:
  iftmp.6 = 4;
  <D.21521>:
  field_size = iftmp.6;
  goto <D.19683>;
  <D.19686>:
  i.7 = (unsigned int) i;
  D.21523 = i.7 > 1;
  D.21524 = (long int) D.21523;
  D.21525 = __builtin_expect (D.21524, 0);
  if (D.21525 != 0) goto <D.21526>; else goto <D.21527>;
  <D.21526>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.21527>:
  if (i != 0) goto <D.21529>; else goto <D.21530>;
  <D.21529>:
  D.21532 = meta->tables[20].rows;
  D.21533 = (int) D.21532;
  if (D.21533 <= 65535) goto <D.21534>; else goto <D.21535>;
  <D.21534>:
  iftmp.9 = 2;
  goto <D.21536>;
  <D.21535>:
  iftmp.9 = 4;
  <D.21536>:
  iftmp.8 = iftmp.9;
  goto <D.21537>;
  <D.21530>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21539>; else goto <D.21540>;
  <D.21539>:
  iftmp.10 = 2;
  goto <D.21541>;
  <D.21540>:
  iftmp.10 = 4;
  <D.21541>:
  iftmp.8 = iftmp.10;
  <D.21537>:
  field_size = iftmp.8;
  goto <D.19683>;
  <D.19687>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21545>; else goto <D.21546>;
  <D.21545>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.21546>:
  D.21532 = meta->tables[20].rows;
  D.21533 = (int) D.21532;
  if (D.21533 <= 65535) goto <D.21548>; else goto <D.21549>;
  <D.21548>:
  iftmp.11 = 2;
  goto <D.21550>;
  <D.21549>:
  iftmp.11 = 4;
  <D.21550>:
  field_size = iftmp.11;
  goto <D.19683>;
  <D.19688>:
  D.21502 = i != 1;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21551>; else goto <D.21552>;
  <D.21551>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.21552>:
  field_size = 4;
  goto <D.19683>;
  <D.19689>:
  D.21502 = i != 1;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21553>; else goto <D.21554>;
  <D.21553>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.21554>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  if (D.21557 <= 65535) goto <D.21558>; else goto <D.21559>;
  <D.21558>:
  iftmp.12 = 2;
  goto <D.21560>;
  <D.21559>:
  iftmp.12 = 4;
  <D.21560>:
  field_size = iftmp.12;
  goto <D.19683>;
  <D.19690>:
  D.21502 = i != 1;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21561>; else goto <D.21562>;
  <D.21561>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.21562>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  if (D.21557 <= 65535) goto <D.21564>; else goto <D.21565>;
  <D.21564>:
  iftmp.13 = 2;
  goto <D.21566>;
  <D.21565>:
  iftmp.13 = 4;
  <D.21566>:
  field_size = iftmp.13;
  goto <D.19683>;
  <D.19691>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21567>; else goto <D.21568>;
  <D.21567>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.21568>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  if (D.21557 <= 65535) goto <D.21570>; else goto <D.21571>;
  <D.21570>:
  iftmp.14 = 2;
  goto <D.21572>;
  <D.21571>:
  iftmp.14 = 4;
  <D.21572>:
  field_size = iftmp.14;
  goto <D.19683>;
  <D.19692>:
  D.21491 = i != 3;
  D.21492 = (long int) D.21491;
  D.21493 = __builtin_expect (D.21492, 0);
  if (D.21493 != 0) goto <D.21573>; else goto <D.21574>;
  <D.21573>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.21574>:
  D.21576 = meta->tables[26].rows;
  D.21577 = (int) D.21576;
  if (D.21577 <= 65535) goto <D.21578>; else goto <D.21579>;
  <D.21578>:
  iftmp.15 = 2;
  goto <D.21580>;
  <D.21579>:
  iftmp.15 = 4;
  <D.21580>:
  field_size = iftmp.15;
  goto <D.19683>;
  <D.19693>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21581>; else goto <D.21582>;
  <D.21581>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.21582>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21584>; else goto <D.21585>;
  <D.21584>:
  iftmp.16 = 2;
  goto <D.21586>;
  <D.21585>:
  iftmp.16 = 4;
  <D.21586>:
  field_size = iftmp.16;
  goto <D.19683>;
  <D.19694>:
  D.21587 = i != 5;
  D.21588 = (long int) D.21587;
  D.21589 = __builtin_expect (D.21588, 0);
  if (D.21589 != 0) goto <D.21590>; else goto <D.21591>;
  <D.21590>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.21591>:
  D.21593 = meta->tables[8].rows;
  D.21594 = (int) D.21593;
  if (D.21594 <= 65535) goto <D.21595>; else goto <D.21596>;
  <D.21595>:
  iftmp.17 = 2;
  goto <D.21597>;
  <D.21596>:
  iftmp.17 = 4;
  <D.21597>:
  field_size = iftmp.17;
  goto <D.19683>;
  <D.19695>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21598>; else goto <D.21599>;
  <D.21598>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.21599>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21601>; else goto <D.21602>;
  <D.21601>:
  iftmp.18 = 2;
  goto <D.21603>;
  <D.21602>:
  iftmp.18 = 4;
  <D.21603>:
  field_size = iftmp.18;
  goto <D.19683>;
  <D.19696>:
  D.21502 = i != 1;
  D.21503 = (long int) D.21502;
  D.21504 = __builtin_expect (D.21503, 0);
  if (D.21504 != 0) goto <D.21604>; else goto <D.21605>;
  <D.21604>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.21605>:
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  if (D.21608 <= 65535) goto <D.21609>; else goto <D.21610>;
  <D.21609>:
  iftmp.19 = 2;
  goto <D.21611>;
  <D.21610>:
  iftmp.19 = 4;
  <D.21611>:
  field_size = iftmp.19;
  goto <D.19683>;
  <D.19697>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21612>; else goto <D.21613>;
  <D.21612>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.21613>:
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  if (D.21608 <= 65535) goto <D.21615>; else goto <D.21616>;
  <D.21615>:
  iftmp.20 = 2;
  goto <D.21617>;
  <D.21616>:
  iftmp.20 = 4;
  <D.21617>:
  field_size = iftmp.20;
  goto <D.19683>;
  <D.19698>:
  i.7 = (unsigned int) i;
  D.21523 = i.7 > 1;
  D.21524 = (long int) D.21523;
  D.21525 = __builtin_expect (D.21524, 0);
  if (D.21525 != 0) goto <D.21618>; else goto <D.21619>;
  <D.21618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.21619>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21621>; else goto <D.21622>;
  <D.21621>:
  iftmp.21 = 2;
  goto <D.21623>;
  <D.21622>:
  iftmp.21 = 4;
  <D.21623>:
  field_size = iftmp.21;
  goto <D.19683>;
  <D.19699>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21624>; else goto <D.21625>;
  <D.21624>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.21625>:
  D.21593 = meta->tables[8].rows;
  D.21594 = (int) D.21593;
  if (D.21594 <= 65535) goto <D.21627>; else goto <D.21628>;
  <D.21627>:
  iftmp.22 = 2;
  goto <D.21629>;
  <D.21628>:
  iftmp.22 = 4;
  <D.21629>:
  field_size = iftmp.22;
  goto <D.19683>;
  <D.19700>:
  i.7 = (unsigned int) i;
  D.21523 = i.7 > 1;
  D.21524 = (long int) D.21523;
  D.21525 = __builtin_expect (D.21524, 0);
  if (D.21525 != 0) goto <D.21630>; else goto <D.21631>;
  <D.21630>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.21631>:
  if (i != 0) goto <D.21633>; else goto <D.21634>;
  <D.21633>:
  D.21636 = meta->tables[23].rows;
  D.21637 = (int) D.21636;
  if (D.21637 <= 65535) goto <D.21638>; else goto <D.21639>;
  <D.21638>:
  iftmp.24 = 2;
  goto <D.21640>;
  <D.21639>:
  iftmp.24 = 4;
  <D.21640>:
  iftmp.23 = iftmp.24;
  goto <D.21641>;
  <D.21634>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  if (D.21518 <= 65535) goto <D.21643>; else goto <D.21644>;
  <D.21643>:
  iftmp.25 = 2;
  goto <D.21645>;
  <D.21644>:
  iftmp.25 = 4;
  <D.21645>:
  iftmp.23 = iftmp.25;
  <D.21641>:
  field_size = iftmp.23;
  goto <D.19683>;
  <D.19701>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21646>; else goto <D.21647>;
  <D.21646>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.21647>:
  D.21636 = meta->tables[23].rows;
  D.21637 = (int) D.21636;
  if (D.21637 <= 65535) goto <D.21649>; else goto <D.21650>;
  <D.21649>:
  iftmp.26 = 2;
  goto <D.21651>;
  <D.21650>:
  iftmp.26 = 4;
  <D.21651>:
  field_size = iftmp.26;
  goto <D.19683>;
  <D.19702>:
  i.7 = (unsigned int) i;
  D.21652 = i.7 + 4294967292;
  D.21653 = D.21652 > 1;
  D.21654 = (long int) D.21653;
  D.21655 = __builtin_expect (D.21654, 0);
  if (D.21655 != 0) goto <D.21656>; else goto <D.21657>;
  <D.21656>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.21657>:
  if (i == 4) goto <D.21659>; else goto <D.21660>;
  <D.21659>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  if (D.21557 <= 65535) goto <D.21662>; else goto <D.21663>;
  <D.21662>:
  iftmp.28 = 2;
  goto <D.21664>;
  <D.21663>:
  iftmp.28 = 4;
  <D.21664>:
  iftmp.27 = iftmp.28;
  goto <D.21665>;
  <D.21660>:
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  if (D.21608 <= 65535) goto <D.21667>; else goto <D.21668>;
  <D.21667>:
  iftmp.29 = 2;
  goto <D.21669>;
  <D.21668>:
  iftmp.29 = 4;
  <D.21669>:
  iftmp.27 = iftmp.29;
  <D.21665>:
  field_size = iftmp.27;
  goto <D.19683>;
  <D.19703>:
  D.21511 = i != 2;
  D.21512 = (long int) D.21511;
  D.21513 = __builtin_expect (D.21512, 0);
  if (D.21513 != 0) goto <D.21670>; else goto <D.21671>;
  <D.21670>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.21671>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  n = MAX_EXPR <D.21518, D.21608>;
  if (n <= 32767) goto <D.21673>; else goto <D.21674>;
  <D.21673>:
  iftmp.30 = 2;
  goto <D.21675>;
  <D.21674>:
  iftmp.30 = 4;
  <D.21675>:
  field_size = iftmp.30;
  goto <D.19683>;
  <D.19704>:
  D.21542 = i != 0;
  D.21543 = (long int) D.21542;
  D.21544 = __builtin_expect (D.21543, 0);
  if (D.21544 != 0) goto <D.21676>; else goto <D.21677>;
  <D.21676>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.21677>:
  D.21679 = meta->tables[42].rows;
  D.21680 = (int) D.21679;
  if (D.21680 <= 65535) goto <D.21681>; else goto <D.21682>;
  <D.21681>:
  iftmp.31 = 2;
  goto <D.21683>;
  <D.21682>:
  iftmp.31 = 4;
  <D.21683>:
  field_size = iftmp.31;
  goto <D.19683>;
  <D.19705>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.19706>:
  goto <D.19706>;
  <D.19683>:
  goto <D.19675>;
  <D.19707>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  D.21593 = meta->tables[8].rows;
  D.21594 = (int) D.21593;
  n = MAX_EXPR <D.21557, D.21594>;
  D.21636 = meta->tables[23].rows;
  D.21637 = (int) D.21636;
  n = MAX_EXPR <D.21637, n>;
  if (n <= 16383) goto <D.21685>; else goto <D.21686>;
  <D.21685>:
  iftmp.32 = 2;
  goto <D.21687>;
  <D.21686>:
  iftmp.32 = 4;
  <D.21687>:
  field_size = iftmp.32;
  goto <D.19675>;
  <D.19708>:
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  n = MAX_EXPR <D.21557, D.21608>;
  D.21688 = meta->tables[1].rows;
  D.21689 = (int) D.21688;
  n = MAX_EXPR <D.21689, n>;
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  n = MAX_EXPR <D.21518, n>;
  D.21593 = meta->tables[8].rows;
  D.21594 = (int) D.21593;
  n = MAX_EXPR <D.21594, n>;
  D.21690 = meta->tables[9].rows;
  D.21691 = (int) D.21690;
  n = MAX_EXPR <D.21691, n>;
  D.21692 = meta->tables[10].rows;
  D.21693 = (int) D.21692;
  n = MAX_EXPR <D.21693, n>;
  D.21694 = meta->tables[0].rows;
  D.21695 = (int) D.21694;
  n = MAX_EXPR <D.21695, n>;
  D.21696 = meta->tables[14].rows;
  D.21697 = (int) D.21696;
  n = MAX_EXPR <D.21697, n>;
  D.21636 = meta->tables[23].rows;
  D.21637 = (int) D.21636;
  n = MAX_EXPR <D.21637, n>;
  D.21532 = meta->tables[20].rows;
  D.21533 = (int) D.21532;
  n = MAX_EXPR <D.21533, n>;
  D.21698 = meta->tables[17].rows;
  D.21699 = (int) D.21698;
  n = MAX_EXPR <D.21699, n>;
  D.21576 = meta->tables[26].rows;
  D.21577 = (int) D.21576;
  n = MAX_EXPR <D.21577, n>;
  D.21700 = meta->tables[27].rows;
  D.21701 = (int) D.21700;
  n = MAX_EXPR <D.21701, n>;
  D.21702 = meta->tables[32].rows;
  D.21703 = (int) D.21702;
  n = MAX_EXPR <D.21703, n>;
  D.21497 = meta->tables[35].rows;
  D.21498 = (int) D.21497;
  n = MAX_EXPR <D.21498, n>;
  D.21704 = meta->tables[38].rows;
  D.21705 = (int) D.21704;
  n = MAX_EXPR <D.21705, n>;
  D.21706 = meta->tables[39].rows;
  D.21707 = (int) D.21706;
  n = MAX_EXPR <D.21707, n>;
  D.21708 = meta->tables[40].rows;
  D.21709 = (int) D.21708;
  n = MAX_EXPR <D.21709, n>;
  if (n <= 2047) goto <D.21711>; else goto <D.21712>;
  <D.21711>:
  iftmp.33 = 2;
  goto <D.21713>;
  <D.21712>:
  iftmp.33 = 4;
  <D.21713>:
  field_size = iftmp.33;
  goto <D.19675>;
  <D.19709>:
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  D.21688 = meta->tables[1].rows;
  D.21689 = (int) D.21688;
  n = MAX_EXPR <D.21518, D.21689>;
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  n = MAX_EXPR <D.21608, n>;
  D.21692 = meta->tables[10].rows;
  D.21693 = (int) D.21692;
  n = MAX_EXPR <D.21693, n>;
  if (n <= 8191) goto <D.21715>; else goto <D.21716>;
  <D.21715>:
  iftmp.34 = 2;
  goto <D.21717>;
  <D.21716>:
  iftmp.34 = 4;
  <D.21717>:
  field_size = iftmp.34;
  goto <D.19675>;
  <D.19710>:
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  n = MAX_EXPR <D.21608, D.21518>;
  D.21702 = meta->tables[32].rows;
  D.21703 = (int) D.21702;
  n = MAX_EXPR <D.21703, n>;
  if (n <= 16383) goto <D.21719>; else goto <D.21720>;
  <D.21719>:
  iftmp.35 = 2;
  goto <D.21721>;
  <D.21720>:
  iftmp.35 = 4;
  <D.21721>:
  field_size = iftmp.35;
  goto <D.19675>;
  <D.19711>:
  D.21497 = meta->tables[35].rows;
  D.21498 = (int) D.21497;
  D.21704 = meta->tables[38].rows;
  D.21705 = (int) D.21704;
  n = MAX_EXPR <D.21498, D.21705>;
  D.21706 = meta->tables[39].rows;
  D.21707 = (int) D.21706;
  n = MAX_EXPR <D.21707, n>;
  if (n <= 16383) goto <D.21723>; else goto <D.21724>;
  <D.21723>:
  iftmp.36 = 2;
  goto <D.21725>;
  <D.21724>:
  iftmp.36 = 4;
  <D.21725>:
  field_size = iftmp.36;
  goto <D.19675>;
  <D.19712>:
  D.21593 = meta->tables[8].rows;
  D.21594 = (int) D.21593;
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  n = MAX_EXPR <D.21594, D.21557>;
  if (n <= 32767) goto <D.21727>; else goto <D.21728>;
  <D.21727>:
  iftmp.37 = 2;
  goto <D.21729>;
  <D.21728>:
  iftmp.37 = 4;
  <D.21729>:
  field_size = iftmp.37;
  goto <D.19675>;
  <D.19713>:
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  D.21556 = meta->tables[4].rows;
  D.21557 = (int) D.21556;
  n = MAX_EXPR <D.21608, D.21557>;
  if (n <= 32767) goto <D.21731>; else goto <D.21732>;
  <D.21731>:
  iftmp.38 = 2;
  goto <D.21733>;
  <D.21732>:
  iftmp.38 = 4;
  <D.21733>:
  field_size = iftmp.38;
  goto <D.19675>;
  <D.19714>:
  D.21688 = meta->tables[1].rows;
  D.21689 = (int) D.21688;
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  n = MAX_EXPR <D.21689, D.21518>;
  D.21700 = meta->tables[27].rows;
  D.21701 = (int) D.21700;
  n = MAX_EXPR <D.21701, n>;
  if (n <= 16383) goto <D.21735>; else goto <D.21736>;
  <D.21735>:
  iftmp.39 = 2;
  goto <D.21737>;
  <D.21736>:
  iftmp.39 = 4;
  <D.21737>:
  field_size = iftmp.39;
  goto <D.19675>;
  <D.19715>:
  D.21688 = meta->tables[1].rows;
  D.21689 = (int) D.21688;
  D.21517 = meta->tables[2].rows;
  D.21518 = (int) D.21517;
  n = MAX_EXPR <D.21689, D.21518>;
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  n = MAX_EXPR <D.21608, n>;
  D.21576 = meta->tables[26].rows;
  D.21577 = (int) D.21576;
  n = MAX_EXPR <D.21577, n>;
  D.21700 = meta->tables[27].rows;
  D.21701 = (int) D.21700;
  n = MAX_EXPR <D.21701, n>;
  if (n <= 8191) goto <D.21739>; else goto <D.21740>;
  <D.21739>:
  iftmp.40 = 2;
  goto <D.21741>;
  <D.21740>:
  iftmp.40 = 4;
  <D.21741>:
  field_size = iftmp.40;
  goto <D.19675>;
  <D.19716>:
  D.21692 = meta->tables[10].rows;
  D.21693 = (int) D.21692;
  D.21607 = meta->tables[6].rows;
  D.21608 = (int) D.21607;
  n = MAX_EXPR <D.21693, D.21608>;
  if (n <= 32767) goto <D.21743>; else goto <D.21744>;
  <D.21743>:
  iftmp.41 = 2;
  goto <D.21745>;
  <D.21744>:
  iftmp.41 = 4;
  <D.21745>:
  field_size = iftmp.41;
  goto <D.19675>;
  <D.19717>:
  D.21532 = meta->tables[20].rows;
  D.21533 = (int) D.21532;
  D.21636 = meta->tables[23].rows;
  D.21637 = (int) D.21636;
  n = MAX_EXPR <D.21533, D.21637>;
  if (n <= 32767) goto <D.21747>; else goto <D.21748>;
  <D.21747>:
  iftmp.42 = 2;
  goto <D.21749>;
  <D.21748>:
  iftmp.42 = 4;
  <D.21749>:
  field_size = iftmp.42;
  goto <D.19675>;
  <D.19718>:
  D.21576 = meta->tables[26].rows;
  D.21577 = (int) D.21576;
  D.21694 = meta->tables[0].rows;
  D.21695 = (int) D.21694;
  n = MAX_EXPR <D.21577, D.21695>;
  D.21497 = meta->tables[35].rows;
  D.21498 = (int) D.21497;
  n = MAX_EXPR <D.21498, n>;
  D.21688 = meta->tables[1].rows;
  D.21689 = (int) D.21688;
  n = MAX_EXPR <D.21689, n>;
  if (n <= 16383) goto <D.21751>; else goto <D.21752>;
  <D.21751>:
  iftmp.43 = 2;
  goto <D.21753>;
  <D.21752>:
  iftmp.43 = 4;
  <D.21753>:
  field_size = iftmp.43;
  goto <D.19675>;
  <D.21754>:
  <D.19675>:
  D.21755 = field_size + -1;
  D.21756 = D.21755 << shift;
  D.21757 = (unsigned int) D.21756;
  bitfield = D.21757 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.19720>:
  i.44 = (sizetype) i;
  D.21759 = description + i.44;
  D.21760 = *D.21759;
  code = (int) D.21760;
  if (code != 0) goto <D.19719>; else goto <D.19721>;
  <D.19721>:
  D.21761 = i << 24;
  D.21762 = (unsigned int) D.21761;
  D.21763 = D.21762 | bitfield;
  *result_bitfield = D.21763;
  D.21764 = size;
  return D.21764;
}


mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  unsigned int D.21766;
  unsigned int D.21767;
  guint32 * D.21770;
  int D.21771;
  unsigned char D.21772;
  <unnamed-unsigned:24> D.21773;
  int D.21774;
  unsigned char D.21775;
  int D.21776;
  int D.21777;
  sizetype D.21778;
  int i;
  const char * base;

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

    table = &meta->tables[i];
    D.21766 = BIT_FIELD_REF <*table, 32, 32>;
    D.21767 = D.21766 & 16777215;
    if (D.21767 == 0) goto <D.21768>; else goto <D.21769>;
    <D.21768>:
    // predicted unlikely by continue predictor.
    goto <D.19728>;
    <D.21769>:
    D.21770 = &table->size_bitfield;
    D.21771 = mono_metadata_compute_size (meta, i, D.21770);
    D.21772 = (unsigned char) D.21771;
    table->row_size = D.21772;
    table->base = base;
    D.21773 = table->rows;
    D.21774 = (int) D.21773;
    D.21775 = table->row_size;
    D.21776 = (int) D.21775;
    D.21777 = D.21774 * D.21776;
    D.21778 = (sizetype) D.21777;
    base = base + D.21778;
  }
  <D.19728>:
  i = i + 1;
  <D.19730>:
  if (i <= 44) goto <D.19729>; else goto <D.19731>;
  <D.19731>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.21782;
  int D.21783;
  const char * D.21784;
  const char * D.21785;
  unsigned char D.21786;
  int D.21787;
  int D.21788;
  int D.21789;
  sizetype D.21790;

  if (idx <= 0) goto <D.21779>; else goto <D.21781>;
  <D.21781>:
  D.21782 = meta->tables[table].rows;
  D.21783 = (int) D.21782;
  if (D.21783 < idx) goto <D.21779>; else goto <D.21780>;
  <D.21779>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.21784 = "";
  return D.21784;
  <D.21780>:
  D.21785 = meta->tables[table].base;
  D.21786 = meta->tables[table].row_size;
  D.21787 = (int) D.21786;
  D.21788 = idx + -1;
  D.21789 = D.21787 * D.21788;
  D.21790 = (sizetype) D.21789;
  D.21784 = D.21785 + D.21790;
  return D.21784;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.21792;
  unsigned int D.21793;
  int D.21794;
  int token.45;
  int D.21796;

  D.21793 = token >> 24;
  D.21794 = (int) D.21793;
  token.45 = (int) token;
  D.21796 = token.45 & 16777215;
  D.21792 = mono_metadata_locate (meta, D.21794, D.21796);
  return D.21792;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.21798;
  _Bool D.21799;
  long int D.21800;
  long int D.21801;
  const char * D.21806;
  const char * D.21807;

  D.21798 = meta->heap_strings.size;
  D.21799 = D.21798 <= index;
  D.21800 = (long int) D.21799;
  D.21801 = __builtin_expect (D.21800, 0);
  if (D.21801 != 0) goto <D.21802>; else goto <D.21803>;
  <D.21802>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.21803>:
  D.21798 = meta->heap_strings.size;
  if (D.21798 <= index) goto <D.21804>; else goto <D.21805>;
  <D.21804>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.21806 = "";
  return D.21806;
  <D.21805>:
  D.21807 = meta->heap_strings.data;
  D.21806 = D.21807 + index;
  return D.21806;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.21809;
  _Bool D.21810;
  long int D.21811;
  long int D.21812;
  const char * D.21817;
  const char * D.21818;

  D.21809 = meta->heap_us.size;
  D.21810 = D.21809 <= index;
  D.21811 = (long int) D.21810;
  D.21812 = __builtin_expect (D.21811, 0);
  if (D.21812 != 0) goto <D.21813>; else goto <D.21814>;
  <D.21813>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.21814>:
  D.21809 = meta->heap_us.size;
  if (D.21809 <= index) goto <D.21815>; else goto <D.21816>;
  <D.21815>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.21817 = "";
  return D.21817;
  <D.21816>:
  D.21818 = meta->heap_us.data;
  D.21817 = D.21818 + index;
  return D.21817;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.21820;
  _Bool D.21821;
  long int D.21822;
  long int D.21823;
  const char * D.21828;
  const char * D.21829;

  D.21820 = meta->heap_blob.size;
  D.21821 = D.21820 <= index;
  D.21822 = (long int) D.21821;
  D.21823 = __builtin_expect (D.21822, 0);
  if (D.21823 != 0) goto <D.21824>; else goto <D.21825>;
  <D.21824>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.21825>:
  D.21820 = meta->heap_blob.size;
  if (D.21820 <= index) goto <D.21826>; else goto <D.21827>;
  <D.21826>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.21828 = "";
  return D.21828;
  <D.21827>:
  D.21829 = meta->heap_blob.data;
  D.21828 = D.21829 + index;
  return D.21828;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.21831;
  const char * D.21834;
  const char * D.21835;

  index = index + 4294967295;
  index = index * 16;
  D.21831 = meta->heap_guid.size;
  if (D.21831 <= index) goto <D.21832>; else goto <D.21833>;
  <D.21832>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 933, "index < meta->heap_guid.size");
  D.21834 = "";
  return D.21834;
  <D.21833>:
  D.21835 = meta->heap_guid.data;
  D.21834 = D.21835 + index;
  return D.21834;
}


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.21837;
  <unnamed-unsigned:24> D.21838;
  int D.21839;
  _Bool D.21840;
  long int D.21841;
  long int D.21842;
  _Bool D.21845;
  long int D.21846;
  long int D.21847;
  const char * D.21850;
  unsigned char D.21851;
  int D.21852;
  int D.21853;
  sizetype D.21854;
  _Bool D.21855;
  long int D.21856;
  long int D.21857;
  int D.21860;
  unsigned int D.21861;
  unsigned int D.21862;
  unsigned int D.21863;
  unsigned int i.46;
  unsigned int D.21865;
  guint32 * D.21866;
  char D.21867;
  unsigned int D.21868;
  short unsigned int D.21869;
  unsigned int D.21870;
  unsigned int D.21871;
  sizetype n.47;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.21837 = bitfield >> 24;
  count = (int) D.21837;
  D.21838 = t->rows;
  D.21839 = (int) D.21838;
  D.21840 = D.21839 <= idx;
  D.21841 = (long int) D.21840;
  D.21842 = __builtin_expect (D.21841, 0);
  if (D.21842 != 0) goto <D.21843>; else goto <D.21844>;
  <D.21843>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.21844>:
  D.21845 = idx < 0;
  D.21846 = (long int) D.21845;
  D.21847 = __builtin_expect (D.21846, 0);
  if (D.21847 != 0) goto <D.21848>; else goto <D.21849>;
  <D.21848>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.21849>:
  D.21850 = t->base;
  D.21851 = t->row_size;
  D.21852 = (int) D.21851;
  D.21853 = D.21852 * idx;
  D.21854 = (sizetype) D.21853;
  data = D.21850 + D.21854;
  D.21855 = res_size != count;
  D.21856 = (long int) D.21855;
  D.21857 = __builtin_expect (D.21856, 0);
  if (D.21857 != 0) goto <D.21858>; else goto <D.21859>;
  <D.21858>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.21859>:
  i = 0;
  goto <D.19777>;
  <D.19776>:
  {
    int n;

    D.21860 = i * 2;
    D.21861 = bitfield >> D.21860;
    D.21862 = D.21861 & 3;
    D.21863 = D.21862 + 1;
    n = (int) D.21863;
    switch (n) <default: <D.19775>, case 1: <D.19771>, case 2: <D.19773>, case 4: <D.19774>>
    <D.19771>:
    i.46 = (unsigned int) i;
    D.21865 = i.46 * 4;
    D.21866 = res + D.21865;
    D.21867 = *data;
    D.21868 = (unsigned int) D.21867;
    *D.21866 = D.21868;
    goto <D.19772>;
    <D.19773>:
    i.46 = (unsigned int) i;
    D.21865 = i.46 * 4;
    D.21866 = res + D.21865;
    D.21869 = mono_read16 (data);
    D.21870 = (unsigned int) D.21869;
    *D.21866 = D.21870;
    goto <D.19772>;
    <D.19774>:
    i.46 = (unsigned int) i;
    D.21865 = i.46 * 4;
    D.21866 = res + D.21865;
    D.21871 = mono_read32 (data);
    *D.21866 = D.21871;
    goto <D.19772>;
    <D.19775>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.19772>:
    n.47 = (sizetype) n;
    data = data + n.47;
  }
  i = i + 1;
  <D.19777>:
  if (i < count) goto <D.19776>; else goto <D.19778>;
  <D.19778>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.21873;
  int D.21874;
  _Bool D.21875;
  long int D.21876;
  long int D.21877;
  unsigned int D.21880;
  _Bool D.21881;
  long int D.21882;
  long int D.21883;
  const char * D.21886;
  unsigned char D.21887;
  int D.21888;
  int D.21889;
  sizetype D.21890;
  unsigned int D.21891;
  unsigned int D.21892;
  sizetype n.48;
  int D.21894;
  int D.21895;
  unsigned int D.21896;
  unsigned int D.21897;
  unsigned int D.21898;
  unsigned int i.49;
  uint32_t D.21900;
  char D.21901;
  short unsigned int D.21902;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.21873 = t->rows;
  D.21874 = (int) D.21873;
  D.21875 = D.21874 <= idx;
  D.21876 = (long int) D.21875;
  D.21877 = __builtin_expect (D.21876, 0);
  if (D.21877 != 0) goto <D.21878>; else goto <D.21879>;
  <D.21878>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.21879>:
  D.21880 = bitfield >> 24;
  D.21881 = D.21880 <= col;
  D.21882 = (long int) D.21881;
  D.21883 = __builtin_expect (D.21882, 0);
  if (D.21883 != 0) goto <D.21884>; else goto <D.21885>;
  <D.21884>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.21885>:
  D.21886 = t->base;
  D.21887 = t->row_size;
  D.21888 = (int) D.21887;
  D.21889 = D.21888 * idx;
  D.21890 = (sizetype) D.21889;
  data = D.21886 + D.21890;
  D.21891 = bitfield & 3;
  D.21892 = D.21891 + 1;
  n = (int) D.21892;
  i = 0;
  goto <D.19789>;
  <D.19788>:
  n.48 = (sizetype) n;
  data = data + n.48;
  D.21894 = i + 1;
  D.21895 = D.21894 * 2;
  D.21896 = bitfield >> D.21895;
  D.21897 = D.21896 & 3;
  D.21898 = D.21897 + 1;
  n = (int) D.21898;
  i = i + 1;
  <D.19789>:
  i.49 = (unsigned int) i;
  if (i.49 < col) goto <D.19788>; else goto <D.19790>;
  <D.19790>:
  switch (n) <default: <D.19794>, case 1: <D.19791>, case 2: <D.19792>, case 4: <D.19793>>
  <D.19791>:
  D.21901 = *data;
  D.21900 = (uint32_t) D.21901;
  return D.21900;
  <D.19792>:
  D.21902 = mono_read16 (data);
  D.21900 = (uint32_t) D.21902;
  return D.21900;
  <D.19793>:
  D.21900 = mono_read32 (data);
  return D.21900;
  <D.19794>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.21900 = 0;
  return D.21900;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.21904;
  signed char D.21905;
  unsigned int D.21908;
  int D.21910;
  int D.21911;
  int D.21914;
  int D.21915;
  const unsigned char * D.21916;
  unsigned char D.21917;
  int D.21918;
  int D.21919;
  int D.21921;
  int D.21922;
  int D.21923;
  int D.21924;
  const unsigned char * D.21925;
  unsigned char D.21926;
  int D.21927;
  int D.21928;
  int D.21929;
  const unsigned char * D.21930;
  unsigned char D.21931;
  int D.21932;
  int D.21933;
  uint32_t D.21936;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.21904 = *ptr;
  D.21905 = (signed char) D.21904;
  if (D.21905 >= 0) goto <D.21906>; else goto <D.21907>;
  <D.21906>:
  D.21904 = *ptr;
  D.21908 = (unsigned int) D.21904;
  size = D.21908 & 127;
  ptr = ptr + 1;
  goto <D.21909>;
  <D.21907>:
  D.21904 = *ptr;
  D.21910 = (int) D.21904;
  D.21911 = D.21910 & 64;
  if (D.21911 == 0) goto <D.21912>; else goto <D.21913>;
  <D.21912>:
  D.21904 = *ptr;
  D.21910 = (int) D.21904;
  D.21914 = D.21910 & 63;
  D.21915 = D.21914 << 8;
  D.21916 = ptr + 1;
  D.21917 = *D.21916;
  D.21918 = (int) D.21917;
  D.21919 = D.21915 + D.21918;
  size = (guint32) D.21919;
  ptr = ptr + 2;
  goto <D.21920>;
  <D.21913>:
  D.21904 = *ptr;
  D.21910 = (int) D.21904;
  D.21921 = D.21910 & 31;
  D.21922 = D.21921 << 24;
  D.21916 = ptr + 1;
  D.21917 = *D.21916;
  D.21918 = (int) D.21917;
  D.21923 = D.21918 << 16;
  D.21924 = D.21922 + D.21923;
  D.21925 = ptr + 2;
  D.21926 = *D.21925;
  D.21927 = (int) D.21926;
  D.21928 = D.21927 << 8;
  D.21929 = D.21924 + D.21928;
  D.21930 = ptr + 3;
  D.21931 = *D.21930;
  D.21932 = (int) D.21931;
  D.21933 = D.21929 + D.21932;
  size = (guint32) D.21933;
  ptr = ptr + 4;
  <D.21920>:
  <D.21909>:
  if (rptr != 0B) goto <D.21934>; else goto <D.21935>;
  <D.21934>:
  *rptr = ptr;
  <D.21935>:
  D.21936 = size;
  return D.21936;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.50;
  int D.21942;
  int D.21943;
  int D.21946;
  int D.21947;
  const unsigned char * D.21948;
  unsigned char D.21949;
  int D.21950;
  int D.21951;
  int D.21953;
  int D.21954;
  int D.21955;
  int D.21956;
  const unsigned char * D.21957;
  unsigned char D.21958;
  int D.21959;
  int D.21960;
  int D.21961;
  const unsigned char * D.21962;
  unsigned char D.21963;
  int D.21964;
  int D.21965;
  uint32_t D.21968;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.50 = (signed char) b;
  if (b.50 >= 0) goto <D.21939>; else goto <D.21940>;
  <D.21939>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.21941>;
  <D.21940>:
  D.21942 = (int) b;
  D.21943 = D.21942 & 64;
  if (D.21943 == 0) goto <D.21944>; else goto <D.21945>;
  <D.21944>:
  D.21942 = (int) b;
  D.21946 = D.21942 & 63;
  D.21947 = D.21946 << 8;
  D.21948 = ptr + 1;
  D.21949 = *D.21948;
  D.21950 = (int) D.21949;
  D.21951 = D.21947 | D.21950;
  len = (guint32) D.21951;
  ptr = ptr + 2;
  goto <D.21952>;
  <D.21945>:
  D.21942 = (int) b;
  D.21953 = D.21942 & 31;
  D.21954 = D.21953 << 24;
  D.21948 = ptr + 1;
  D.21949 = *D.21948;
  D.21950 = (int) D.21949;
  D.21955 = D.21950 << 16;
  D.21956 = D.21954 | D.21955;
  D.21957 = ptr + 2;
  D.21958 = *D.21957;
  D.21959 = (int) D.21958;
  D.21960 = D.21959 << 8;
  D.21961 = D.21956 | D.21960;
  D.21962 = ptr + 3;
  D.21963 = *D.21962;
  D.21964 = (int) D.21963;
  D.21965 = D.21961 | D.21964;
  len = (guint32) D.21965;
  ptr = ptr + 4;
  <D.21952>:
  <D.21941>:
  if (rptr != 0B) goto <D.21966>; else goto <D.21967>;
  <D.21966>:
  *rptr = ptr;
  <D.21967>:
  D.21968 = len;
  return D.21968;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.21970;
  unsigned int D.21971;
  int32_t D.21974;
  _Bool D.21981;
  long int D.21982;
  long int D.21983;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.21970 = uval >> 1;
  ival = (gint32) D.21970;
  D.21971 = uval & 1;
  if (D.21971 == 0) goto <D.21972>; else goto <D.21973>;
  <D.21972>:
  D.21974 = ival;
  return D.21974;
  <D.21973>:
  if (ival <= 63) goto <D.21975>; else goto <D.21976>;
  <D.21975>:
  D.21974 = ival + -64;
  return D.21974;
  <D.21976>:
  if (ival <= 8191) goto <D.21977>; else goto <D.21978>;
  <D.21977>:
  D.21974 = ival + -8192;
  return D.21974;
  <D.21978>:
  if (ival <= 268435455) goto <D.21979>; else goto <D.21980>;
  <D.21979>:
  D.21974 = ival + -268435456;
  return D.21974;
  <D.21980>:
  D.21981 = ival > 536870911;
  D.21982 = (long int) D.21981;
  D.21983 = __builtin_expect (D.21982, 0);
  if (D.21983 != 0) goto <D.21984>; else goto <D.21985>;
  <D.21984>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1121, "ival < 0x20000000");
  <D.21985>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.21974 = ival + -536870912;
  return D.21974;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  unsigned char D.21987;
  unsigned char D.21988;
  uint32_t D.21991;
  unsigned int D.21992;
  unsigned int D.21993;
  struct MonoTableInfo * D.21996;
  unsigned int D.21997;
  int D.21998;
  unsigned int D.21999;
  unsigned int D.22000;
  struct MonoTableInfo * D.22003;
  unsigned int D.22004;
  unsigned int D.22005;
  struct MonoTableInfo * D.22008;
  unsigned int D.22009;
  unsigned int D.22010;
  struct MonoTableInfo * D.22013;
  unsigned int D.22014;
  unsigned int D.22015;
  struct MonoTableInfo * D.22018;

  D.21987 = BIT_FIELD_REF <*image, 8, 128>;
  D.21988 = D.21987 & 32;
  if (D.21988 == 0) goto <D.21989>; else goto <D.21990>;
  <D.21989>:
  D.21991 = idx;
  return D.21991;
  <D.21990>:
  switch (table) <default: <D.19824>, case 4: <D.19820>, case 6: <D.19819>, case 8: <D.19823>, case 20: <D.19821>, case 23: <D.19822>>
  <D.19819>:
  D.21992 = BIT_FIELD_REF <*image, 32, 1312>;
  D.21993 = D.21992 & 16777215;
  if (D.21993 != 0) goto <D.21994>; else goto <D.21995>;
  <D.21994>:
  D.21996 = &image->tables[5];
  D.21997 = idx + 4294967295;
  D.21998 = (int) D.21997;
  D.21991 = mono_metadata_decode_row_col (D.21996, D.21998, 0);
  return D.21991;
  <D.21995>:
  D.21991 = idx;
  return D.21991;
  <D.19820>:
  D.21999 = BIT_FIELD_REF <*image, 32, 1120>;
  D.22000 = D.21999 & 16777215;
  if (D.22000 != 0) goto <D.22001>; else goto <D.22002>;
  <D.22001>:
  D.22003 = &image->tables[3];
  D.21997 = idx + 4294967295;
  D.21998 = (int) D.21997;
  D.21991 = mono_metadata_decode_row_col (D.22003, D.21998, 0);
  return D.21991;
  <D.22002>:
  D.21991 = idx;
  return D.21991;
  <D.19821>:
  D.22004 = BIT_FIELD_REF <*image, 32, 2656>;
  D.22005 = D.22004 & 16777215;
  if (D.22005 != 0) goto <D.22006>; else goto <D.22007>;
  <D.22006>:
  D.22008 = &image->tables[19];
  D.21997 = idx + 4294967295;
  D.21998 = (int) D.21997;
  D.21991 = mono_metadata_decode_row_col (D.22008, D.21998, 0);
  return D.21991;
  <D.22007>:
  D.21991 = idx;
  return D.21991;
  <D.19822>:
  D.22009 = BIT_FIELD_REF <*image, 32, 2944>;
  D.22010 = D.22009 & 16777215;
  if (D.22010 != 0) goto <D.22011>; else goto <D.22012>;
  <D.22011>:
  D.22013 = &image->tables[22];
  D.21997 = idx + 4294967295;
  D.21998 = (int) D.21997;
  D.21991 = mono_metadata_decode_row_col (D.22013, D.21998, 0);
  return D.21991;
  <D.22012>:
  D.21991 = idx;
  return D.21991;
  <D.19823>:
  D.22014 = BIT_FIELD_REF <*image, 32, 1504>;
  D.22015 = D.22014 & 16777215;
  if (D.22015 != 0) goto <D.22016>; else goto <D.22017>;
  <D.22016>:
  D.22018 = &image->tables[7];
  D.21997 = idx + 4294967295;
  D.21998 = (int) D.21997;
  D.21991 = mono_metadata_decode_row_col (D.22018, D.21998, 0);
  return D.21991;
  <D.22017>:
  D.21991 = idx;
  return D.21991;
  <D.19824>:
  D.21991 = idx;
  return D.21991;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  unsigned char D.22020;
  unsigned char D.22021;
  int D.22024;
  unsigned int D.22025;
  unsigned int D.22026;
  unsigned int D.22027;
  struct MonoTableInfo * D.22028;

  D.22020 = BIT_FIELD_REF <*image, 8, 128>;
  D.22021 = D.22020 & 32;
  if (D.22021 != 0) goto <D.22022>; else goto <D.22023>;
  <D.22022>:
  D.22024 = idx + 1;
  D.22025 = (unsigned int) D.22024;
  D.22026 = mono_metadata_translate_token_index (image, table, D.22025);
  D.22027 = D.22026 + 4294967295;
  idx = (int) D.22027;
  <D.22023>:
  D.22028 = &image->tables[table];
  mono_metadata_decode_row (D.22028, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  unsigned char D.22029;
  unsigned char D.22030;
  int D.22033;
  unsigned int D.22034;
  unsigned int D.22035;
  unsigned int D.22036;
  uint32_t D.22037;
  struct MonoTableInfo * D.22038;

  D.22029 = BIT_FIELD_REF <*image, 8, 128>;
  D.22030 = D.22029 & 32;
  if (D.22030 != 0) goto <D.22031>; else goto <D.22032>;
  <D.22031>:
  D.22033 = idx + 1;
  D.22034 = (unsigned int) D.22033;
  D.22035 = mono_metadata_translate_token_index (image, table, D.22034);
  D.22036 = D.22035 + 4294967295;
  idx = (int) D.22036;
  <D.22032>:
  D.22038 = &image->tables[table];
  D.22037 = mono_metadata_decode_row_col (D.22038, idx, col);
  return D.22037;
}


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

  ptr.51 = ptr;
  token = mono_metadata_decode_value (ptr.51, &ptr);
  if (rptr != 0B) goto <D.22041>; else goto <D.22042>;
  <D.22041>:
  ptr.51 = ptr;
  *rptr = ptr.51;
  <D.22042>:
  D.22043 = mono_metadata_token_from_dor (token);
  return D.22043;
}


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.22045;
  char D.22046;
  _Bool D.22051;
  const char * D.22052;
  unsigned int D.22053;
  <unnamed-unsigned:31> D.22054;
  int D.22055;
  struct MonoCustomMod local;

  try
    {
      D.22045 = *ptr;
      D.22046 = D.22045 + 225;
      if (D.22046 <= 1) goto <D.22047>; else goto <D.22048>;
      <D.22047>:
      if (dest == 0B) goto <D.22049>; else goto <D.22050>;
      <D.22049>:
      dest = &local;
      <D.22050>:
      D.22045 = *ptr;
      D.22051 = D.22045 == 31;
      dest->required = D.22051;
      D.22052 = ptr + 1;
      D.22053 = mono_metadata_parse_typedef_or_ref (m, D.22052, rptr);
      D.22054 = (<unnamed-unsigned:31>) D.22053;
      dest->token = D.22054;
      D.22055 = 1;
      return D.22055;
      <D.22048>:
      D.22055 = 0;
      return D.22055;
    }
  finally
    {
      local = {CLOBBER};
    }
}


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

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


mono_metadata_parse_array_internal (struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  void * iftmp.52;
  const char * ptr.53;
  struct MonoArrayType * D.22067;
  struct MonoClass * D.22068;
  unsigned int D.22069;
  unsigned char D.22070;
  unsigned int D.22071;
  unsigned char D.22072;
  unsigned char D.22073;
  void * iftmp.54;
  unsigned int D.22079;
  unsigned int D.22080;
  int * D.22082;
  unsigned int i.55;
  unsigned int D.22084;
  int * D.22085;
  unsigned int D.22086;
  int D.22087;
  int D.22088;
  unsigned int D.22089;
  unsigned char D.22090;
  unsigned char D.22091;
  void * iftmp.56;
  unsigned int D.22097;
  unsigned int D.22098;
  int * D.22100;
  int * D.22101;
  int D.22102;
  int D.22103;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.22061>; else goto <D.22062>;
  <D.22061>:
  iftmp.52 = monoeg_malloc0 (16);
  goto <D.22063>;
  <D.22062>:
  iftmp.52 = mono_image_alloc0 (m, 16);
  <D.22063>:
  array = iftmp.52;
  ptr.53 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.53, &ptr);
  if (etype == 0B) goto <D.22065>; else goto <D.22066>;
  <D.22065>:
  D.22067 = 0B;
  return D.22067;
  <D.22066>:
  D.22068 = mono_class_from_mono_type (etype);
  array->eklass = D.22068;
  ptr.53 = ptr;
  D.22069 = mono_metadata_decode_value (ptr.53, &ptr);
  D.22070 = (unsigned char) D.22069;
  array->rank = D.22070;
  ptr.53 = ptr;
  D.22071 = mono_metadata_decode_value (ptr.53, &ptr);
  D.22072 = (unsigned char) D.22071;
  array->numsizes = D.22072;
  D.22073 = array->numsizes;
  if (D.22073 != 0) goto <D.22074>; else goto <D.22075>;
  <D.22074>:
  if (transient != 0) goto <D.22077>; else goto <D.22078>;
  <D.22077>:
  D.22073 = array->numsizes;
  D.22079 = (unsigned int) D.22073;
  D.22080 = D.22079 * 4;
  iftmp.54 = monoeg_malloc0 (D.22080);
  goto <D.22081>;
  <D.22078>:
  D.22073 = array->numsizes;
  D.22079 = (unsigned int) D.22073;
  D.22080 = D.22079 * 4;
  iftmp.54 = mono_image_alloc0 (m, D.22080);
  <D.22081>:
  array->sizes = iftmp.54;
  <D.22075>:
  i = 0;
  goto <D.19862>;
  <D.19861>:
  D.22082 = array->sizes;
  i.55 = (unsigned int) i;
  D.22084 = i.55 * 4;
  D.22085 = D.22082 + D.22084;
  ptr.53 = ptr;
  D.22086 = mono_metadata_decode_value (ptr.53, &ptr);
  D.22087 = (int) D.22086;
  *D.22085 = D.22087;
  i = i + 1;
  <D.19862>:
  D.22073 = array->numsizes;
  D.22088 = (int) D.22073;
  if (D.22088 > i) goto <D.19861>; else goto <D.19863>;
  <D.19863>:
  ptr.53 = ptr;
  D.22089 = mono_metadata_decode_value (ptr.53, &ptr);
  D.22090 = (unsigned char) D.22089;
  array->numlobounds = D.22090;
  D.22091 = array->numlobounds;
  if (D.22091 != 0) goto <D.22092>; else goto <D.22093>;
  <D.22092>:
  if (transient != 0) goto <D.22095>; else goto <D.22096>;
  <D.22095>:
  D.22091 = array->numlobounds;
  D.22097 = (unsigned int) D.22091;
  D.22098 = D.22097 * 4;
  iftmp.56 = monoeg_malloc0 (D.22098);
  goto <D.22099>;
  <D.22096>:
  D.22091 = array->numlobounds;
  D.22097 = (unsigned int) D.22091;
  D.22098 = D.22097 * 4;
  iftmp.56 = mono_image_alloc0 (m, D.22098);
  <D.22099>:
  array->lobounds = iftmp.56;
  <D.22093>:
  i = 0;
  goto <D.19865>;
  <D.19864>:
  D.22100 = array->lobounds;
  i.55 = (unsigned int) i;
  D.22084 = i.55 * 4;
  D.22101 = D.22100 + D.22084;
  ptr.53 = ptr;
  D.22102 = mono_metadata_decode_signed_value (ptr.53, &ptr);
  *D.22101 = D.22102;
  i = i + 1;
  <D.19865>:
  D.22091 = array->numlobounds;
  D.22103 = (int) D.22091;
  if (D.22103 > i) goto <D.19864>; else goto <D.19866>;
  <D.19866>:
  if (rptr != 0B) goto <D.22104>; else goto <D.22105>;
  <D.22104>:
  ptr.53 = ptr;
  *rptr = ptr.53;
  <D.22105>:
  D.22067 = array;
  return D.22067;
}


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

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


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.22109;
  int * D.22110;

  D.22109 = array->sizes;
  monoeg_g_free (D.22109);
  D.22110 = array->lobounds;
  monoeg_g_free (D.22110);
  monoeg_g_free (array);
}


mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.22111;
  unsigned int D.22112;
  <unnamed-unsigned:22> D.22113;
  int D.22114;
  guint D.22115;
  <unnamed-unsigned:1> D.22116;
  int D.22117;
  int D.22118;
  unsigned int D.22119;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.19905>;
  <D.19904>:
  hash = hash * 13;
  D.22111 = ginst->type_argv[i];
  D.22112 = mono_metadata_type_hash (D.22111);
  hash = D.22112 + hash;
  i = i + 1;
  <D.19905>:
  D.22113 = ginst->type_argc;
  D.22114 = (int) D.22113;
  if (D.22114 > i) goto <D.19904>; else goto <D.19906>;
  <D.19906>:
  D.22116 = ginst->is_open;
  D.22117 = (int) D.22116;
  D.22118 = D.22117 << 8;
  D.22119 = (unsigned int) D.22118;
  D.22115 = D.22119 ^ hash;
  return D.22115;
}


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

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


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.22123;
  unsigned int D.22126;
  gboolean D.22131;
  unsigned char D.22136;
  unsigned char D.22137;
  unsigned char D.22138;
  unsigned char D.22139;
  unsigned int D.22141;
  unsigned int D.22142;
  unsigned int D.22143;
  unsigned int D.22144;
  struct MonoType * D.22145;
  struct MonoType * D.22146;
  int D.22147;
  <unnamed-unsigned:22> D.22150;
  int D.22151;
  int i;

  D.22123 = a->id;
  if (D.22123 != 0) goto <D.22124>; else goto <D.22125>;
  <D.22124>:
  D.22126 = b->id;
  if (D.22126 != 0) goto <D.22127>; else goto <D.22128>;
  <D.22127>:
  D.22123 = a->id;
  D.22126 = b->id;
  if (D.22123 == D.22126) goto <D.22129>; else goto <D.22130>;
  <D.22129>:
  D.22131 = 1;
  return D.22131;
  <D.22130>:
  if (signature_only == 0) goto <D.22132>; else goto <D.22133>;
  <D.22132>:
  D.22131 = 0;
  return D.22131;
  <D.22133>:
  <D.22128>:
  <D.22125>:
  D.22136 = BIT_FIELD_REF <*a, 8, 48>;
  D.22137 = BIT_FIELD_REF <*b, 8, 48>;
  D.22138 = D.22136 ^ D.22137;
  D.22139 = D.22138 & 64;
  if (D.22139 != 0) goto <D.22134>; else goto <D.22140>;
  <D.22140>:
  D.22141 = BIT_FIELD_REF <*a, 32, 32>;
  D.22142 = BIT_FIELD_REF <*b, 32, 32>;
  D.22143 = D.22141 ^ D.22142;
  D.22144 = D.22143 & 4194303;
  if (D.22144 != 0) goto <D.22134>; else goto <D.22135>;
  <D.22134>:
  D.22131 = 0;
  return D.22131;
  <D.22135>:
  i = 0;
  goto <D.19914>;
  <D.19913>:
  D.22145 = a->type_argv[i];
  D.22146 = b->type_argv[i];
  D.22147 = do_mono_metadata_type_equal (D.22145, D.22146, signature_only);
  if (D.22147 == 0) goto <D.22148>; else goto <D.22149>;
  <D.22148>:
  D.22131 = 0;
  return D.22131;
  <D.22149>:
  i = i + 1;
  <D.19914>:
  D.22150 = a->type_argc;
  D.22151 = (int) D.22150;
  if (D.22151 > i) goto <D.19913>; else goto <D.19915>;
  <D.19915>:
  D.22131 = 1;
  return D.22131;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.22155;
  unsigned char D.22156;
  unsigned char D.22158;
  unsigned char D.22159;
  unsigned char D.22160;
  unsigned char D.22161;
  gboolean D.22162;
  int D.22163;
  struct MonoClass * D.22164;
  struct MonoClass * D.22165;
  struct MonoType * D.22166;
  struct MonoType * D.22167;
  struct MonoArrayType * D.22168;
  unsigned char D.22169;
  struct MonoArrayType * D.22170;
  unsigned char D.22171;
  struct MonoClass * D.22174;
  struct MonoClass * D.22175;
  struct MonoGenericClass * D.22176;
  struct MonoGenericClass * D.22177;
  struct MonoGenericParam * D.22178;
  struct MonoGenericParam * D.22179;
  struct MonoMethodSignature * D.22180;
  struct MonoMethodSignature * D.22181;

  D.22155 = t1->type;
  D.22156 = t2->type;
  if (D.22155 != D.22156) goto <D.22153>; else goto <D.22157>;
  <D.22157>:
  D.22158 = BIT_FIELD_REF <*t1, 8, 56>;
  D.22159 = BIT_FIELD_REF <*t2, 8, 56>;
  D.22160 = D.22158 ^ D.22159;
  D.22161 = D.22160 & 64;
  if (D.22161 != 0) goto <D.22153>; else goto <D.22154>;
  <D.22153>:
  D.22162 = 0;
  return D.22162;
  <D.22154>:
  D.22155 = t1->type;
  D.22163 = (int) D.22155;
  switch (D.22163) <default: <D.21024>, case 1: <D.20997>, case 2: <D.20998>, case 3: <D.20999>, case 4: <D.21000>, case 5: <D.21001>, case 6: <D.21002>, case 7: <D.21003>, case 8: <D.21004>, case 9: <D.21005>, case 10: <D.21006>, case 11: <D.21007>, case 12: <D.21008>, case 13: <D.21009>, case 14: <D.21010>, case 15: <D.21018>, case 17: <D.21015>, case 18: <D.21016>, case 19: <D.21021>, case 20: <D.21019>, case 21: <D.21020>, case 22: <D.21014>, case 24: <D.21011>, case 25: <D.21012>, case 27: <D.21023>, case 28: <D.21013>, case 29: <D.21017>, case 30: <D.21022>>
  <D.20997>:
  <D.20998>:
  <D.20999>:
  <D.21000>:
  <D.21001>:
  <D.21002>:
  <D.21003>:
  <D.21004>:
  <D.21005>:
  <D.21006>:
  <D.21007>:
  <D.21008>:
  <D.21009>:
  <D.21010>:
  <D.21011>:
  <D.21012>:
  <D.21013>:
  <D.21014>:
  D.22162 = 1;
  return D.22162;
  <D.21015>:
  <D.21016>:
  <D.21017>:
  D.22164 = t1->data.klass;
  D.22165 = t2->data.klass;
  D.22162 = mono_metadata_class_equal (D.22164, D.22165, signature_only);
  return D.22162;
  <D.21018>:
  D.22166 = t1->data.type;
  D.22167 = t2->data.type;
  D.22162 = do_mono_metadata_type_equal (D.22166, D.22167, signature_only);
  return D.22162;
  <D.21019>:
  D.22168 = t1->data.array;
  D.22169 = D.22168->rank;
  D.22170 = t2->data.array;
  D.22171 = D.22170->rank;
  if (D.22169 != D.22171) goto <D.22172>; else goto <D.22173>;
  <D.22172>:
  D.22162 = 0;
  return D.22162;
  <D.22173>:
  D.22168 = t1->data.array;
  D.22174 = D.22168->eklass;
  D.22170 = t2->data.array;
  D.22175 = D.22170->eklass;
  D.22162 = mono_metadata_class_equal (D.22174, D.22175, signature_only);
  return D.22162;
  <D.21020>:
  D.22176 = t1->data.generic_class;
  D.22177 = t2->data.generic_class;
  D.22162 = _mono_metadata_generic_class_equal (D.22176, D.22177, signature_only);
  return D.22162;
  <D.21021>:
  D.22178 = t1->data.generic_param;
  D.22179 = t2->data.generic_param;
  D.22162 = mono_metadata_generic_param_equal (D.22178, D.22179, signature_only);
  return D.22162;
  <D.21022>:
  D.22178 = t1->data.generic_param;
  D.22179 = t2->data.generic_param;
  D.22162 = mono_metadata_generic_param_equal (D.22178, D.22179, signature_only);
  return D.22162;
  <D.21023>:
  D.22180 = t1->data.method;
  D.22181 = t2->data.method;
  D.22162 = mono_metadata_fnptr_equal (D.22180, D.22181, signature_only);
  return D.22162;
  <D.21024>:
  D.22155 = t1->type;
  D.22163 = (int) D.22155;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.22163);
  <D.21025>:
  goto <D.21025>;
  D.22162 = 0;
  return D.22162;
  D.22162 = 0;
  return D.22162;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.22185;
  struct MonoGenericClass * D.22186;
  struct MonoGenericClass * D.22189;
  struct MonoGenericContainer * D.22194;
  struct MonoGenericContainer * D.22197;
  unsigned char D.22202;
  unsigned char D.22205;
  struct MonoGenericParam * D.22208;
  struct MonoGenericParam * D.22209;
  struct MonoClass * D.22220;
  struct MonoClass * D.22221;
  struct MonoType * D.22228;
  struct MonoType * D.22229;

  if (c1 == c2) goto <D.22183>; else goto <D.22184>;
  <D.22183>:
  D.22185 = 1;
  return D.22185;
  <D.22184>:
  D.22186 = c1->generic_class;
  if (D.22186 != 0B) goto <D.22187>; else goto <D.22188>;
  <D.22187>:
  D.22189 = c2->generic_class;
  if (D.22189 != 0B) goto <D.22190>; else goto <D.22191>;
  <D.22190>:
  D.22186 = c1->generic_class;
  D.22189 = c2->generic_class;
  D.22185 = _mono_metadata_generic_class_equal (D.22186, D.22189, signature_only);
  return D.22185;
  <D.22191>:
  <D.22188>:
  D.22186 = c1->generic_class;
  if (D.22186 != 0B) goto <D.22192>; else goto <D.22193>;
  <D.22192>:
  D.22194 = c2->generic_container;
  if (D.22194 != 0B) goto <D.22195>; else goto <D.22196>;
  <D.22195>:
  D.22186 = c1->generic_class;
  D.22185 = _mono_metadata_generic_class_container_equal (D.22186, c2, signature_only);
  return D.22185;
  <D.22196>:
  <D.22193>:
  D.22197 = c1->generic_container;
  if (D.22197 != 0B) goto <D.22198>; else goto <D.22199>;
  <D.22198>:
  D.22189 = c2->generic_class;
  if (D.22189 != 0B) goto <D.22200>; else goto <D.22201>;
  <D.22200>:
  D.22189 = c2->generic_class;
  D.22185 = _mono_metadata_generic_class_container_equal (D.22189, c1, signature_only);
  return D.22185;
  <D.22201>:
  <D.22199>:
  D.22202 = c1->byval_arg.type;
  if (D.22202 == 19) goto <D.22203>; else goto <D.22204>;
  <D.22203>:
  D.22205 = c2->byval_arg.type;
  if (D.22205 == 19) goto <D.22206>; else goto <D.22207>;
  <D.22206>:
  D.22208 = c1->byval_arg.data.generic_param;
  D.22209 = c2->byval_arg.data.generic_param;
  D.22185 = mono_metadata_generic_param_equal (D.22208, D.22209, signature_only);
  return D.22185;
  <D.22207>:
  <D.22204>:
  D.22202 = c1->byval_arg.type;
  if (D.22202 == 30) goto <D.22210>; else goto <D.22211>;
  <D.22210>:
  D.22205 = c2->byval_arg.type;
  if (D.22205 == 30) goto <D.22212>; else goto <D.22213>;
  <D.22212>:
  D.22208 = c1->byval_arg.data.generic_param;
  D.22209 = c2->byval_arg.data.generic_param;
  D.22185 = mono_metadata_generic_param_equal (D.22208, D.22209, signature_only);
  return D.22185;
  <D.22213>:
  <D.22211>:
  if (signature_only != 0) goto <D.22214>; else goto <D.22215>;
  <D.22214>:
  D.22202 = c1->byval_arg.type;
  if (D.22202 == 29) goto <D.22216>; else goto <D.22217>;
  <D.22216>:
  D.22205 = c2->byval_arg.type;
  if (D.22205 == 29) goto <D.22218>; else goto <D.22219>;
  <D.22218>:
  D.22220 = c1->byval_arg.data.klass;
  D.22221 = c2->byval_arg.data.klass;
  D.22185 = mono_metadata_class_equal (D.22220, D.22221, signature_only);
  return D.22185;
  <D.22219>:
  <D.22217>:
  <D.22215>:
  if (signature_only != 0) goto <D.22222>; else goto <D.22223>;
  <D.22222>:
  D.22202 = c1->byval_arg.type;
  if (D.22202 == 20) goto <D.22224>; else goto <D.22225>;
  <D.22224>:
  D.22205 = c2->byval_arg.type;
  if (D.22205 == 20) goto <D.22226>; else goto <D.22227>;
  <D.22226>:
  D.22228 = &c1->byval_arg;
  D.22229 = &c2->byval_arg;
  D.22185 = do_mono_metadata_type_equal (D.22228, D.22229, signature_only);
  return D.22185;
  <D.22227>:
  <D.22225>:
  <D.22223>:
  D.22185 = 0;
  return D.22185;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.22231;
  struct MonoClass * D.22232;
  int D.22233;
  gboolean D.22236;
  int D.22237;
  unsigned char D.22240;
  unsigned char D.22241;
  _Bool D.22242;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.22231 = c2->generic_container;
  i2 = D.22231->context.class_inst;
  D.22232 = g1->container_class;
  D.22233 = mono_metadata_class_equal (D.22232, c2, signature_only);
  if (D.22233 == 0) goto <D.22234>; else goto <D.22235>;
  <D.22234>:
  D.22236 = 0;
  return D.22236;
  <D.22235>:
  D.22237 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.22237 == 0) goto <D.22238>; else goto <D.22239>;
  <D.22238>:
  D.22236 = 0;
  return D.22236;
  <D.22239>:
  D.22240 = BIT_FIELD_REF <*g1, 8, 96>;
  D.22241 = D.22240 & 2;
  D.22242 = D.22241 == 0;
  D.22236 = (gboolean) D.22242;
  return D.22236;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  unsigned char D.22244;
  unsigned char D.22245;
  unsigned char D.22246;
  unsigned char D.22247;
  gboolean D.22250;
  struct MonoClass * D.22251;
  struct MonoClass * D.22252;
  int D.22253;
  int D.22256;
  unsigned char D.22259;
  _Bool D.22260;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.22244 = BIT_FIELD_REF <*g1, 8, 96>;
  D.22245 = BIT_FIELD_REF <*g2, 8, 96>;
  D.22246 = D.22244 ^ D.22245;
  D.22247 = D.22246 & 1;
  if (D.22247 != 0) goto <D.22248>; else goto <D.22249>;
  <D.22248>:
  D.22250 = 0;
  return D.22250;
  <D.22249>:
  D.22251 = g1->container_class;
  D.22252 = g2->container_class;
  D.22253 = mono_metadata_class_equal (D.22251, D.22252, signature_only);
  if (D.22253 == 0) goto <D.22254>; else goto <D.22255>;
  <D.22254>:
  D.22250 = 0;
  return D.22250;
  <D.22255>:
  D.22256 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.22256 == 0) goto <D.22257>; else goto <D.22258>;
  <D.22257>:
  D.22250 = 0;
  return D.22250;
  <D.22258>:
  D.22244 = BIT_FIELD_REF <*g1, 8, 96>;
  D.22245 = BIT_FIELD_REF <*g2, 8, 96>;
  D.22246 = D.22244 ^ D.22245;
  D.22259 = D.22246 & 2;
  D.22260 = D.22259 == 0;
  D.22250 = (gboolean) D.22260;
  return D.22250;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.22264;
  short unsigned int D.22265;
  short unsigned int D.22266;
  short unsigned int D.22269;
  short unsigned int D.22270;
  struct MonoGenericContainer * D.22275;
  struct MonoGenericContainer * D.22276;
  struct MonoImage * D.22280;
  struct MonoImage * D.22281;

  if (p1 == p2) goto <D.22262>; else goto <D.22263>;
  <D.22262>:
  D.22264 = 1;
  return D.22264;
  <D.22263>:
  D.22265 = p1->num;
  D.22266 = p2->num;
  if (D.22265 != D.22266) goto <D.22267>; else goto <D.22268>;
  <D.22267>:
  D.22264 = 0;
  return D.22264;
  <D.22268>:
  D.22269 = p1->serial;
  D.22270 = p2->serial;
  if (D.22269 != D.22270) goto <D.22271>; else goto <D.22272>;
  <D.22271>:
  D.22264 = 0;
  return D.22264;
  <D.22272>:
  D.22275 = p1->owner;
  D.22276 = p2->owner;
  if (D.22275 == D.22276) goto <D.22277>; else goto <D.22278>;
  <D.22277>:
  D.22275 = p1->owner;
  if (D.22275 != 0B) goto <D.22273>; else goto <D.22279>;
  <D.22279>:
  D.22280 = p1->image;
  D.22281 = p2->image;
  if (D.22280 == D.22281) goto <D.22273>; else goto <D.22274>;
  <D.22273>:
  D.22264 = 1;
  return D.22264;
  <D.22274>:
  <D.22278>:
  D.22264 = signature_only;
  return D.22264;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.22285;
  unsigned char D.22286;
  unsigned char D.22287;
  unsigned char D.22288;
  unsigned char D.22289;
  short int D.22292;
  short int D.22293;
  unsigned char D.22296;
  signed char D.22299;
  struct MonoType * D.22302;
  struct MonoType * D.22303;
  int D.22304;
  short unsigned int D.22307;
  short unsigned int D.22308;
  _Bool D.22311;
  _Bool D.22312;
  _Bool D.22313;
  _Bool D.22316;
  int D.22317;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.22283>; else goto <D.22284>;
      <D.22283>:
      D.22285 = 1;
      return D.22285;
      <D.22284>:
      D.22286 = BIT_FIELD_REF <*s1, 8, 80>;
      D.22287 = BIT_FIELD_REF <*s2, 8, 80>;
      D.22288 = D.22286 ^ D.22287;
      D.22289 = D.22288 & 63;
      if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
      <D.22290>:
      D.22285 = 0;
      return D.22285;
      <D.22291>:
      D.22292 = s1->sentinelpos;
      D.22293 = s2->sentinelpos;
      if (D.22292 != D.22293) goto <D.22294>; else goto <D.22295>;
      <D.22294>:
      D.22285 = 0;
      return D.22285;
      <D.22295>:
      D.22286 = BIT_FIELD_REF <*s1, 8, 80>;
      D.22287 = BIT_FIELD_REF <*s2, 8, 80>;
      D.22288 = D.22286 ^ D.22287;
      D.22296 = D.22288 & 64;
      if (D.22296 != 0) goto <D.22297>; else goto <D.22298>;
      <D.22297>:
      D.22285 = 0;
      return D.22285;
      <D.22298>:
      D.22286 = BIT_FIELD_REF <*s1, 8, 80>;
      D.22287 = BIT_FIELD_REF <*s2, 8, 80>;
      D.22288 = D.22286 ^ D.22287;
      D.22299 = (signed char) D.22288;
      if (D.22299 < 0) goto <D.22300>; else goto <D.22301>;
      <D.22300>:
      D.22285 = 0;
      return D.22285;
      <D.22301>:
      D.22302 = s1->ret;
      D.22303 = s2->ret;
      D.22304 = do_mono_metadata_type_equal (D.22302, D.22303, signature_only);
      if (D.22304 == 0) goto <D.22305>; else goto <D.22306>;
      <D.22305>:
      D.22285 = 0;
      return D.22285;
      <D.22306>:
      D.22307 = s1->param_count;
      D.22308 = s2->param_count;
      if (D.22307 != D.22308) goto <D.22309>; else goto <D.22310>;
      <D.22309>:
      D.22285 = 0;
      return D.22285;
      <D.22310>:
      <D.20991>:
      {
        struct MonoType * t1;
        struct MonoType * t2;

        t1 = mono_signature_get_params (s1, &iter1);
        t2 = mono_signature_get_params (s2, &iter2);
        D.22311 = t1 == 0B;
        D.22312 = t2 == 0B;
        D.22313 = D.22311 | D.22312;
        if (D.22313 != 0) goto <D.22314>; else goto <D.22315>;
        <D.22314>:
        D.22316 = t1 == t2;
        D.22285 = (gboolean) D.22316;
        return D.22285;
        <D.22315>:
        D.22317 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.22317 == 0) goto <D.22318>; else goto <D.22319>;
        <D.22318>:
        D.22285 = 0;
        return D.22285;
        <D.22319>:
      }
      goto <D.20991>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


mono_metadata_init ()
{
  struct GHashTable * type_cache.57;
  struct GHashTable * type_cache.58;
  const struct MonoType * D.22324;
  unsigned int i.59;
  int i;

  type_cache.57 = monoeg_g_hash_table_new (mono_type_hash, mono_type_equal);
  type_cache = type_cache.57;
  i = 0;
  goto <D.19938>;
  <D.19937>:
  type_cache.58 = type_cache;
  D.22324 = &builtin_types[i];
  D.22324 = &builtin_types[i];
  monoeg_g_hash_table_insert_replace (type_cache.58, D.22324, D.22324, 0);
  i = i + 1;
  <D.19938>:
  i.59 = (unsigned int) i;
  if (i.59 <= 33) goto <D.19937>; else goto <D.19939>;
  <D.19939>:
}


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.22328;
  unsigned char D.22329;
  unsigned char D.22331;
  unsigned char D.22332;
  unsigned char D.22333;
  unsigned char D.22334;
  short unsigned int D.22336;
  short unsigned int D.22337;
  signed char D.22339;
  gint D.22340;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.22328 = a->type;
  D.22329 = b->type;
  if (D.22328 != D.22329) goto <D.22326>; else goto <D.22330>;
  <D.22330>:
  D.22331 = BIT_FIELD_REF <*a, 8, 56>;
  D.22332 = BIT_FIELD_REF <*b, 8, 56>;
  D.22333 = D.22331 ^ D.22332;
  D.22334 = D.22333 & 64;
  if (D.22334 != 0) goto <D.22326>; else goto <D.22335>;
  <D.22335>:
  D.22336 = a->attrs;
  D.22337 = b->attrs;
  if (D.22336 != D.22337) goto <D.22326>; else goto <D.22338>;
  <D.22338>:
  D.22331 = BIT_FIELD_REF <*a, 8, 56>;
  D.22332 = BIT_FIELD_REF <*b, 8, 56>;
  D.22333 = D.22331 ^ D.22332;
  D.22339 = (signed char) D.22333;
  if (D.22339 < 0) goto <D.22326>; else goto <D.22327>;
  <D.22326>:
  D.22340 = 0;
  return D.22340;
  <D.22327>:
  D.22340 = 1;
  return D.22340;
}


mono_type_hash (const void * data)
{
  unsigned char D.22342;
  guint D.22345;
  struct MonoGenericClass * D.22346;
  int D.22347;
  <unnamed-unsigned:1> D.22348;
  int D.22349;
  int D.22350;
  int D.22351;
  short unsigned int D.22352;
  int D.22353;
  int D.22354;
  int D.22355;
  const struct MonoType * type;

  type = data;
  D.22342 = type->type;
  if (D.22342 == 21) goto <D.22343>; else goto <D.22344>;
  <D.22343>:
  D.22346 = type->data.generic_class;
  D.22345 = mono_generic_class_hash (D.22346);
  return D.22345;
  <D.22344>:
  D.22342 = type->type;
  D.22347 = (int) D.22342;
  D.22348 = type->byref;
  D.22349 = (int) D.22348;
  D.22350 = D.22349 << 8;
  D.22351 = D.22347 | D.22350;
  D.22352 = type->attrs;
  D.22353 = (int) D.22352;
  D.22354 = D.22353 << 9;
  D.22355 = D.22351 | D.22354;
  D.22345 = (guint) D.22355;
  return D.22345;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.22357;
  struct MonoType * D.22358;
  <unnamed-unsigned:1> D.22359;
  unsigned int D.22360;
  const struct MonoGenericContext * D.22361;
  unsigned int D.22362;
  guint D.22363;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.22357 = gclass->container_class;
  D.22358 = &D.22357->byval_arg;
  hash = mono_metadata_type_hash (D.22358);
  hash = hash * 13;
  D.22359 = gclass->is_tb_open;
  D.22360 = (unsigned int) D.22359;
  hash = D.22360 + hash;
  D.22361 = &gclass->context;
  D.22362 = mono_metadata_generic_context_hash (D.22361);
  hash = D.22362 + hash;
  D.22363 = hash;
  return D.22363;
}


mono_metadata_cleanup ()
{
  struct GHashTable * type_cache.60;
  struct GPtrArray * image_sets.61;

  type_cache.60 = type_cache;
  monoeg_g_hash_table_destroy (type_cache.60);
  type_cache = 0B;
  image_sets.61 = image_sets;
  monoeg_g_ptr_array_free (image_sets.61, 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.22367;

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


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.62;
  const char * tmp_ptr.63;
  char D.22371;
  int D.22372;
  const char * tmp_ptr.64;
  unsigned int count.65;
  unsigned int D.22377;
  unsigned int D.22378;
  void * iftmp.66;
  unsigned int size.67;
  unsigned int size.68;
  unsigned char D.22385;
  <unnamed-unsigned:6> D.22386;
  char D.22390;
  int D.22391;
  const char * ptr.69;
  struct MonoCustomMod * D.22393;
  short unsigned int opt_attrs.70;
  unsigned char D.22395;
  <unnamed-unsigned:1> D.22396;
  _Bool D.22397;
  int D.22398;
  struct MonoType * D.22401;
  unsigned char D.22404;
  unsigned char D.22405;
  unsigned char D.22410;
  unsigned char D.22411;
  unsigned int D.22414;
  unsigned int D.22415;
  struct MonoType * iftmp.71;
  unsigned char D.22419;
  struct MonoClass * D.22422;
  struct MonoClass * D.22424;
  struct GHashTable * type_cache.72;
  void * iftmp.73;
  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.62 = ptr;
      tmp_ptr = ptr.62;
      found = 1;
      goto <D.19967>;
      <D.19966>:
      tmp_ptr.63 = tmp_ptr;
      D.22371 = *tmp_ptr.63;
      D.22372 = (int) D.22371;
      switch (D.22372) <default: <D.19965>, case 16: <D.19961>, case 31: <D.19963>, case 32: <D.19964>, case 69: <D.19960>>
      <D.19960>:
      <D.19961>:
      tmp_ptr.63 = tmp_ptr;
      tmp_ptr.64 = tmp_ptr.63 + 1;
      tmp_ptr = tmp_ptr.64;
      goto <D.19962>;
      <D.19963>:
      <D.19964>:
      count = count + 1;
      tmp_ptr.63 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.63, &tmp_ptr);
      goto <D.19962>;
      <D.19965>:
      found = 0;
      <D.19962>:
      <D.19967>:
      if (found != 0) goto <D.19966>; else goto <D.19968>;
      <D.19968>:
      if (count != 0) goto <D.22374>; else goto <D.22375>;
      <D.22374>:
      {
        int size;

        count.65 = (unsigned int) count;
        D.22377 = count.65 + 2;
        D.22378 = D.22377 * 4;
        size = (int) D.22378;
        if (transient != 0) goto <D.22380>; else goto <D.22381>;
        <D.22380>:
        size.67 = (unsigned int) size;
        iftmp.66 = monoeg_malloc0 (size.67);
        goto <D.22383>;
        <D.22381>:
        size.68 = (unsigned int) size;
        iftmp.66 = mono_image_alloc0 (m, size.68);
        <D.22383>:
        type = iftmp.66;
        D.22385 = (unsigned char) count;
        D.22386 = (<unnamed-unsigned:6>) D.22385;
        type->num_mods = D.22386;
        if (count > 64) goto <D.22387>; else goto <D.22388>;
        <D.22387>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.22388>:
      }
      goto <D.22389>;
      <D.22375>:
      type = &stype;
      memset (type, 0, 8);
      <D.22389>:
      found = 1;
      count = 0;
      goto <D.19977>;
      <D.19976>:
      ptr.62 = ptr;
      D.22390 = *ptr.62;
      D.22391 = (int) D.22390;
      switch (D.22391) <default: <D.19975>, case 16: <D.19972>, case 31: <D.19973>, case 32: <D.19974>, case 69: <D.19970>>
      <D.19970>:
      pinned = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.19971>;
      <D.19972>:
      byref = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.19971>;
      <D.19973>:
      <D.19974>:
      D.22393 = &type->modifiers[count];
      ptr.62 = ptr;
      mono_metadata_parse_custom_mod (m, D.22393, ptr.62, &ptr);
      count = count + 1;
      goto <D.19971>;
      <D.19975>:
      found = 0;
      <D.19971>:
      <D.19977>:
      if (found != 0) goto <D.19976>; else goto <D.19978>;
      <D.19978>:
      opt_attrs.70 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.70;
      D.22395 = (unsigned char) byref;
      D.22396 = (<unnamed-unsigned:1>) D.22395;
      type->byref = D.22396;
      D.22397 = pinned != 0;
      type->pinned = D.22397;
      ptr.62 = ptr;
      D.22398 = do_mono_metadata_parse_type (type, m, container, transient, ptr.62, &ptr);
      if (D.22398 == 0) goto <D.22399>; else goto <D.22400>;
      <D.22399>:
      D.22401 = 0B;
      return D.22401;
      <D.22400>:
      if (rptr != 0B) goto <D.22402>; else goto <D.22403>;
      <D.22402>:
      ptr.62 = ptr;
      *rptr = ptr.62;
      <D.22403>:
      D.22404 = BIT_FIELD_REF <*type, 8, 56>;
      D.22405 = D.22404 & 63;
      if (D.22405 == 0) goto <D.22406>; else goto <D.22407>;
      <D.22406>:
      if (transient == 0) goto <D.22408>; else goto <D.22409>;
      <D.22408>:
      D.22410 = type->type;
      D.22411 = D.22410 + 239;
      if (D.22411 <= 1) goto <D.22412>; else goto <D.22413>;
      <D.22412>:
      D.22414 = BIT_FIELD_REF <*type, 32, 32>;
      D.22415 = D.22414 & 2147549183;
      if (D.22415 == 0) goto <D.22416>; else goto <D.22417>;
      <D.22416>:
      {
        struct MonoType * ret;

        D.22404 = BIT_FIELD_REF <*type, 8, 56>;
        D.22419 = D.22404 & 64;
        if (D.22419 != 0) goto <D.22420>; else goto <D.22421>;
        <D.22420>:
        D.22422 = type->data.klass;
        iftmp.71 = &D.22422->this_arg;
        goto <D.22423>;
        <D.22421>:
        D.22422 = type->data.klass;
        iftmp.71 = &D.22422->byval_arg;
        <D.22423>:
        ret = iftmp.71;
        D.22424 = ret->data.klass;
        D.22422 = type->data.klass;
        if (D.22424 == D.22422) goto <D.22425>; else goto <D.22426>;
        <D.22425>:
        D.22401 = ret;
        return D.22401;
        <D.22426>:
      }
      <D.22417>:
      <D.22413>:
      type_cache.72 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.72, type);
      if (cached != 0B) goto <D.22428>; else goto <D.22429>;
      <D.22428>:
      D.22401 = cached;
      return D.22401;
      <D.22429>:
      <D.22409>:
      <D.22407>:
      if (&stype == type) goto <D.22430>; else goto <D.22431>;
      <D.22430>:
      if (transient != 0) goto <D.22433>; else goto <D.22434>;
      <D.22433>:
      iftmp.73 = monoeg_malloc (8);
      goto <D.22435>;
      <D.22434>:
      iftmp.73 = mono_image_alloc (m, 8);
      <D.22435>:
      type = iftmp.73;
      memcpy (type, &stype, 8);
      <D.22431>:
      D.22401 = type;
      return D.22401;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22440;
  int D.22445;
  void * D.22447;
  unsigned int D.22448;

  D.22440 = __builtin_constant_p (__len);
  if (D.22440 != 0) goto <D.22441>; else goto <D.22442>;
  <D.22441>:
  if (__len == 0) goto <D.22443>; else goto <D.22444>;
  <D.22443>:
  D.22445 = __builtin_constant_p (__ch);
  if (D.22445 == 0) goto <D.22438>; else goto <D.22446>;
  <D.22446>:
  if (__ch != 0) goto <D.22438>; else goto <D.22439>;
  <D.22438>:
  __warn_memset_zero_len ();
  D.22447 = __dest;
  return D.22447;
  <D.22439>:
  <D.22444>:
  <D.22442>:
  D.22448 = __builtin_object_size (__dest, 0);
  D.22447 = __builtin___memset_chk (__dest, __ch, __len, D.22448);
  return D.22447;
}


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.74;
  unsigned int D.22451;
  unsigned char D.22452;
  unsigned char D.22453;
  int D.22454;
  gboolean D.22457;
  unsigned char D.22458;
  int D.22459;
  int D.22460;
  struct MonoClass * D.22465;
  struct MonoClass * D.22466;
  struct MonoType * D.22469;
  struct MonoType * D.22470;
  struct MonoMethodSignature * D.22473;
  struct MonoMethodSignature * D.22474;
  struct MonoArrayType * D.22477;
  struct MonoArrayType * D.22478;
  unsigned char D.22483;
  unsigned char D.22484;
  <unnamed type> D.22487;
  struct MonoGenericParam * D.22488;
  struct MonoGenericParam * D.22489;
  char * D.22492;
  gboolean ok;

  ok = 1;
  ptr.74 = ptr;
  D.22451 = mono_metadata_decode_value (ptr.74, &ptr);
  D.22452 = (unsigned char) D.22451;
  type->type = D.22452;
  D.22453 = type->type;
  D.22454 = (int) D.22453;
  switch (D.22454) <default: <D.20531>, case 1: <D.20500>, case 2: <D.20501>, case 3: <D.20502>, case 4: <D.20503>, case 5: <D.20504>, case 6: <D.20505>, case 7: <D.20506>, case 8: <D.20507>, case 9: <D.20508>, case 10: <D.20509>, case 11: <D.20510>, case 12: <D.20511>, case 13: <D.20512>, case 14: <D.20515>, case 15: <D.20525>, case 17: <D.20519>, case 18: <D.20520>, case 19: <D.20529>, case 20: <D.20527>, case 21: <D.20530>, case 22: <D.20517>, case 24: <D.20513>, case 25: <D.20514>, case 27: <D.20526>, case 28: <D.20516>, case 29: <D.20523>, case 30: <D.20528>>
  <D.20500>:
  <D.20501>:
  <D.20502>:
  <D.20503>:
  <D.20504>:
  <D.20505>:
  <D.20506>:
  <D.20507>:
  <D.20508>:
  <D.20509>:
  <D.20510>:
  <D.20511>:
  <D.20512>:
  <D.20513>:
  <D.20514>:
  <D.20515>:
  <D.20516>:
  <D.20517>:
  goto <D.20518>;
  <D.20519>:
  <D.20520>:
  {
    guint32 token;
    struct MonoClass * class;

    ptr.74 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.74, &ptr);
    class = mono_class_get (m, token);
    type->data.klass = class;
    if (class == 0B) goto <D.22455>; else goto <D.22456>;
    <D.22455>:
    D.22457 = 0;
    return D.22457;
    <D.22456>:
    D.22458 = class->byval_arg.type;
    D.22459 = (int) D.22458;
    D.22453 = type->type;
    D.22454 = (int) D.22453;
    D.22460 = compare_type_literals (D.22459, D.22454);
    if (D.22460 == 0) goto <D.22461>; else goto <D.22462>;
    <D.22461>:
    D.22457 = 0;
    return D.22457;
    <D.22462>:
    goto <D.20518>;
  }
  <D.20523>:
  {
    struct MonoType * etype;

    ptr.74 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.74, &ptr);
    if (etype == 0B) goto <D.22463>; else goto <D.22464>;
    <D.22463>:
    D.22457 = 0;
    return D.22457;
    <D.22464>:
    D.22465 = mono_class_from_mono_type (etype);
    type->data.klass = D.22465;
    D.22466 = type->data.klass;
    if (D.22466 == 0B) goto <D.22467>; else goto <D.22468>;
    <D.22467>:
    D.22457 = 0;
    return D.22457;
    <D.22468>:
    goto <D.20518>;
  }
  <D.20525>:
  ptr.74 = ptr;
  D.22469 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.74, &ptr);
  type->data.type = D.22469;
  D.22470 = type->data.type;
  if (D.22470 == 0B) goto <D.22471>; else goto <D.22472>;
  <D.22471>:
  D.22457 = 0;
  return D.22457;
  <D.22472>:
  goto <D.20518>;
  <D.20526>:
  ptr.74 = ptr;
  D.22473 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.74, &ptr);
  type->data.method = D.22473;
  D.22474 = type->data.method;
  if (D.22474 == 0B) goto <D.22475>; else goto <D.22476>;
  <D.22475>:
  D.22457 = 0;
  return D.22457;
  <D.22476>:
  goto <D.20518>;
  <D.20527>:
  ptr.74 = ptr;
  D.22477 = mono_metadata_parse_array_internal (m, container, transient, ptr.74, &ptr);
  type->data.array = D.22477;
  D.22478 = type->data.array;
  if (D.22478 == 0B) goto <D.22479>; else goto <D.22480>;
  <D.22479>:
  D.22457 = 0;
  return D.22457;
  <D.22480>:
  goto <D.20518>;
  <D.20528>:
  if (container != 0B) goto <D.22481>; else goto <D.22482>;
  <D.22481>:
  D.22483 = BIT_FIELD_REF <*container, 8, 152>;
  D.22484 = D.22483 & 128;
  if (D.22484 == 0) goto <D.22485>; else goto <D.22486>;
  <D.22485>:
  D.22457 = 0;
  return D.22457;
  <D.22486>:
  <D.22482>:
  <D.20529>:
  D.22453 = type->type;
  D.22487 = (<unnamed type>) D.22453;
  ptr.74 = ptr;
  D.22488 = mono_metadata_parse_generic_param (m, container, D.22487, ptr.74, &ptr);
  type->data.generic_param = D.22488;
  D.22489 = type->data.generic_param;
  if (D.22489 == 0B) goto <D.22490>; else goto <D.22491>;
  <D.22490>:
  D.22457 = 0;
  return D.22457;
  <D.22491>:
  goto <D.20518>;
  <D.20530>:
  ptr.74 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.74, &ptr);
  goto <D.20518>;
  <D.20531>:
  D.22453 = type->type;
  D.22454 = (int) D.22453;
  D.22492 = m->name;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.22454, D.22492);
  D.22457 = 0;
  return D.22457;
  <D.20518>:
  if (rptr != 0B) goto <D.22493>; else goto <D.22494>;
  <D.22493>:
  ptr.74 = ptr;
  *rptr = ptr.74;
  <D.22494>:
  D.22457 = ok;
  return D.22457;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.22499;
  _Bool D.22502;
  _Bool D.22503;
  _Bool D.22504;
  _Bool D.22507;

  if (class_type == 0) goto <D.22497>; else goto <D.22498>;
  <D.22497>:
  D.22499 = 1;
  return D.22499;
  <D.22498>:
  if (type_type == 18) goto <D.22500>; else goto <D.22501>;
  <D.22500>:
  D.22502 = class_type == 14;
  D.22503 = class_type == 28;
  D.22504 = D.22502 | D.22503;
  if (D.22504 != 0) goto <D.22505>; else goto <D.22506>;
  <D.22505>:
  D.22499 = 1;
  return D.22499;
  <D.22506>:
  <D.22501>:
  D.22507 = class_type == type_type;
  D.22499 = (gboolean) D.22507;
  return D.22499;
}


mono_metadata_parse_generic_param (struct MonoImage * m, struct MonoGenericContainer * generic_container, MonoTypeEnum type, const char * ptr, const char * * rptr)
{
  const char * ptr.75;
  unsigned int D.22510;
  short unsigned int D.22515;
  struct MonoGenericParam * D.22516;
  <unnamed-signed:31> D.22517;
  int D.22518;
  struct MonoGenericParamFull * D.22521;
  unsigned int index.76;
  unsigned int D.22523;
  int index;

  ptr.75 = ptr;
  D.22510 = mono_metadata_decode_value (ptr.75, &ptr);
  index = (int) D.22510;
  if (rptr != 0B) goto <D.22511>; else goto <D.22512>;
  <D.22511>:
  ptr.75 = ptr;
  *rptr = ptr.75;
  <D.22512>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.22513>; else goto <D.22514>;
  <D.22513>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 12);
    D.22515 = (short unsigned int) index;
    param->num = D.22515;
    param->image = m;
    D.22516 = param;
    return D.22516;
  }
  <D.22514>:
  D.22517 = generic_container->type_argc;
  D.22518 = (int) D.22517;
  if (D.22518 <= index) goto <D.22519>; else goto <D.22520>;
  <D.22519>:
  D.22516 = 0B;
  return D.22516;
  <D.22520>:
  D.22521 = generic_container->type_params;
  index.76 = (unsigned int) index;
  D.22523 = index.76 * 32;
  D.22516 = D.22521 + D.22523;
  return D.22516;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.22525;
  struct MonoGenericContainer * D.22528;
  _Bool D.22529;
  _Bool D.22530;
  _Bool D.22531;
  int D.22532;
  _Bool D.22533;
  long int D.22534;
  long int D.22535;
  unsigned char D.22542;
  unsigned char D.22543;
  struct MonoGenericContainer * D.22545;
  gboolean is_var;

  D.22525 = type == 19;
  is_var = (gboolean) D.22525;
  if (gc == 0B) goto <D.22526>; else goto <D.22527>;
  <D.22526>:
  D.22528 = 0B;
  return D.22528;
  <D.22527>:
  D.22529 = is_var == 0;
  D.22530 = type != 30;
  D.22531 = D.22529 & D.22530;
  D.22532 = (int) D.22531;
  D.22533 = D.22532 != 0;
  D.22534 = (long int) D.22533;
  D.22535 = __builtin_expect (D.22534, 0);
  if (D.22535 != 0) goto <D.22536>; else goto <D.22537>;
  <D.22536>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.22537>:
  if (is_var != 0) goto <D.22538>; else goto <D.22539>;
  <D.22538>:
  D.22542 = BIT_FIELD_REF <*gc, 8, 152>;
  D.22543 = D.22542 & 128;
  if (D.22543 != 0) goto <D.22540>; else goto <D.22544>;
  <D.22544>:
  D.22545 = gc->parent;
  if (D.22545 != 0B) goto <D.22540>; else goto <D.22541>;
  <D.22540>:
  D.22528 = gc->parent;
  return D.22528;
  <D.22541>:
  <D.22539>:
  D.22528 = gc;
  return D.22528;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.77;
  gboolean D.22550;
  struct MonoGenericContainer * D.22551;
  unsigned int D.22554;
  struct MonoGenericClass * D.22559;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.77 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.77, &ptr);
  if (gtype == 0B) goto <D.22548>; else goto <D.22549>;
  <D.22548>:
  D.22550 = 0;
  return D.22550;
  <D.22549>:
  gklass = mono_class_from_mono_type (gtype);
  D.22551 = gklass->generic_container;
  if (D.22551 == 0B) goto <D.22552>; else goto <D.22553>;
  <D.22552>:
  D.22550 = 0;
  return D.22550;
  <D.22553>:
  ptr.77 = ptr;
  D.22554 = mono_metadata_decode_value (ptr.77, &ptr);
  count = (int) D.22554;
  ptr.77 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.77, &ptr);
  if (inst == 0B) goto <D.22555>; else goto <D.22556>;
  <D.22555>:
  D.22550 = 0;
  return D.22550;
  <D.22556>:
  if (rptr != 0B) goto <D.22557>; else goto <D.22558>;
  <D.22557>:
  ptr.77 = ptr;
  *rptr = ptr.77;
  <D.22558>:
  D.22559 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.22559;
  D.22550 = 1;
  return D.22550;
}


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

  D.22562 = __builtin_object_size (__dest, 0);
  D.22561 = __builtin___memcpy_chk (__dest, __src, __len, D.22562);
  return D.22561;
}


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

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


mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.22566;
  <unnamed-unsigned:24> D.22567;
  int D.22568;
  <unnamed-unsigned:24> D.22572;
  int D.22573;
  int D.22574;
  unsigned int D.22575;
  int D.22576;
  gboolean D.22579;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.22566 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.22566, 5);
  D.22567 = methodt->rows;
  D.22568 = (int) D.22567;
  if (D.22568 > def) goto <D.22569>; else goto <D.22570>;
  <D.22569>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.22571>;
  <D.22570>:
  D.22572 = m->tables[8].rows;
  D.22573 = (int) D.22572;
  D.22574 = D.22573 + 1;
  lastp = (guint) D.22574;
  <D.22571>:
  i = param_index;
  goto <D.20006>;
  <D.20005>:
  {
    guint32 flags;

    D.22575 = i + 4294967295;
    D.22576 = (int) D.22575;
    flags = mono_metadata_decode_row_col (paramt, D.22576, 0);
    if (flags != 0) goto <D.22577>; else goto <D.22578>;
    <D.22577>:
    D.22579 = 1;
    return D.22579;
    <D.22578>:
  }
  i = i + 1;
  <D.20006>:
  if (i < lastp) goto <D.20005>; else goto <D.20007>;
  <D.20007>:
  D.22579 = 0;
  return D.22579;
}


mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.22581;
  <unnamed-unsigned:24> D.22582;
  int D.22583;
  <unnamed-unsigned:24> D.22587;
  int D.22588;
  int D.22589;
  unsigned int D.22590;
  int D.22591;
  unsigned int D.22592;
  unsigned int param_count.78;
  unsigned int D.22598;
  unsigned int D.22599;
  unsigned int param_count.79;
  unsigned int D.22603;
  int * D.22604;
  int D.22605;
  int * D.22606;
  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.22581 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.22581, 5);
      pattrs = 0B;
      D.22582 = methodt->rows;
      D.22583 = (int) D.22582;
      if (D.22583 > def) goto <D.22584>; else goto <D.22585>;
      <D.22584>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.22586>;
      <D.22585>:
      D.22587 = paramt->rows;
      D.22588 = (int) D.22587;
      D.22589 = D.22588 + 1;
      lastp = (guint) D.22589;
      <D.22586>:
      i = param_index;
      goto <D.20022>;
      <D.20021>:
      D.22590 = i + 4294967295;
      D.22591 = (int) D.22590;
      mono_metadata_decode_row (paramt, D.22591, &cols, 3);
      D.22592 = cols[0];
      if (D.22592 != 0) goto <D.22593>; else goto <D.22594>;
      <D.22593>:
      if (pattrs == 0B) goto <D.22595>; else goto <D.22596>;
      <D.22595>:
      param_count.78 = (unsigned int) param_count;
      D.22598 = param_count.78 * 4;
      pattrs = monoeg_malloc0 (D.22598);
      <D.22596>:
      D.22599 = cols[1];
      param_count.79 = (unsigned int) param_count;
      if (D.22599 >= param_count.79) goto <D.22601>; else goto <D.22602>;
      <D.22601>:
      // predicted unlikely by continue predictor.
      goto <D.20020>;
      <D.22602>:
      D.22599 = cols[1];
      D.22603 = D.22599 * 4;
      D.22604 = pattrs + D.22603;
      D.22592 = cols[0];
      D.22605 = (int) D.22592;
      *D.22604 = D.22605;
      <D.22594>:
      <D.20020>:
      i = i + 1;
      <D.20022>:
      if (i < lastp) goto <D.20021>; else goto <D.20023>;
      <D.20023>:
      D.22606 = pattrs;
      return D.22606;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  unsigned char D.22609;
  unsigned char D.22610;
  struct MonoMethodSignature * D.22613;
  unsigned int D.22614;
  _Bool D.22615;
  long int D.22616;
  long int D.22617;
  const struct MonoTableInfo * D.22620;
  unsigned int D.22621;
  int D.22622;
  const char * ptr.80;
  const char * ptr.81;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.22609 = BIT_FIELD_REF <*image, 8, 128>;
      D.22610 = D.22609 & 8;
      if (D.22610 != 0) goto <D.22611>; else goto <D.22612>;
      <D.22611>:
      D.22613 = mono_lookup_dynamic_token (image, token, 0B);
      return D.22613;
      <D.22612>:
      D.22614 = token >> 24;
      D.22615 = D.22614 != 17;
      D.22616 = (long int) D.22615;
      D.22617 = __builtin_expect (D.22616, 0);
      if (D.22617 != 0) goto <D.22618>; else goto <D.22619>;
      <D.22618>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.22619>:
      D.22620 = tables + 204;
      D.22621 = idx + 4294967295;
      D.22622 = (int) D.22621;
      sig = mono_metadata_decode_row_col (D.22620, D.22622, 0);
      ptr.80 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.80;
      ptr.81 = ptr;
      mono_metadata_decode_blob_size (ptr.81, &ptr);
      ptr.81 = ptr;
      D.22613 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.81, 0B);
      return D.22613;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  unsigned int D.22629;
  unsigned int D.22630;
  short unsigned int D.22631;
  struct MonoMethodSignature * D.22632;
  struct MonoMethodSignature * sig;

  D.22629 = nparams + 3;
  D.22630 = D.22629 * 4;
  sig = mono_image_alloc0 (m, D.22630);
  D.22631 = (short unsigned int) nparams;
  sig->param_count = D.22631;
  sig->sentinelpos = -1;
  D.22632 = sig;
  return D.22632;
}


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

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


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.22636;
  unsigned int D.22637;
  unsigned int D.22638;
  unsigned int D.22639;
  unsigned int sigsize.82;
  unsigned int sigsize.83;
  unsigned int sigsize.84;
  unsigned int sigsize.85;
  struct MonoMethodSignature * D.22650;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.22636 = sig->param_count;
  D.22637 = (unsigned int) D.22636;
  D.22638 = D.22637 + 3;
  D.22639 = D.22638 * 4;
  sigsize = (int) D.22639;
  if (image != 0B) goto <D.22640>; else goto <D.22641>;
  <D.22640>:
  sigsize.82 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.82);
  goto <D.22643>;
  <D.22641>:
  if (mp != 0B) goto <D.22644>; else goto <D.22645>;
  <D.22644>:
  sigsize.83 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.83);
  goto <D.22647>;
  <D.22645>:
  sigsize.84 = (unsigned int) sigsize;
  ret = monoeg_malloc (sigsize.84);
  <D.22647>:
  <D.22643>:
  sigsize.85 = (unsigned int) sigsize;
  memcpy (ret, sig, sigsize.85);
  D.22650 = ret;
  return D.22650;
}


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

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


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

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


mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.22656;
  short unsigned int D.22657;
  unsigned int D.22658;
  unsigned int D.22659;

  D.22657 = sig->param_count;
  D.22658 = (unsigned int) D.22657;
  D.22659 = D.22658 + 3;
  D.22656 = D.22659 * 4;
  return D.22656;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.86;
  char D.22662;
  int D.22663;
  int D.22664;
  int D.22667;
  int D.22670;
  unsigned int D.22673;
  const char * ptr.87;
  unsigned int D.22679;
  int D.22680;
  unsigned char D.22681;
  <unnamed-unsigned:1> D.22682;
  unsigned char D.22683;
  <unnamed-unsigned:1> D.22684;
  unsigned char D.22685;
  <unnamed-unsigned:6> D.22686;
  short unsigned int D.22687;
  short int iftmp.88;
  int D.22693;
  struct MonoType * D.22695;
  struct MonoType * D.22696;
  struct MonoMethodSignature * D.22699;
  unsigned char D.22704;
  unsigned char D.22705;
  char * D.22707;
  short int D.22708;
  short int D.22711;
  short int iftmp.89;
  sizetype i.90;
  sizetype D.22716;
  sizetype D.22717;
  int * D.22718;
  int D.22719;
  struct MonoType * D.22721;
  struct MonoType * D.22722;
  short unsigned int D.22727;
  int D.22728;
  short int D.22735;
  unsigned char D.22736;
  <unnamed-unsigned:1> D.22737;
  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.86 = ptr;
  D.22662 = *ptr.86;
  D.22663 = (int) D.22662;
  D.22664 = D.22663 & 16;
  if (D.22664 != 0) goto <D.22665>; else goto <D.22666>;
  <D.22665>:
  gen_param_count = 1;
  <D.22666>:
  ptr.86 = ptr;
  D.22662 = *ptr.86;
  D.22663 = (int) D.22662;
  D.22667 = D.22663 & 32;
  if (D.22667 != 0) goto <D.22668>; else goto <D.22669>;
  <D.22668>:
  hasthis = 1;
  <D.22669>:
  ptr.86 = ptr;
  D.22662 = *ptr.86;
  D.22663 = (int) D.22662;
  D.22670 = D.22663 & 64;
  if (D.22670 != 0) goto <D.22671>; else goto <D.22672>;
  <D.22671>:
  explicit_this = 1;
  <D.22672>:
  ptr.86 = ptr;
  D.22662 = *ptr.86;
  D.22673 = (unsigned int) D.22662;
  call_convention = D.22673 & 15;
  ptr.86 = ptr;
  ptr.87 = ptr.86 + 1;
  ptr = ptr.87;
  if (gen_param_count != 0) goto <D.22675>; else goto <D.22676>;
  <D.22675>:
  ptr.86 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.86, &ptr);
  <D.22676>:
  ptr.86 = ptr;
  param_count = mono_metadata_decode_value (ptr.86, &ptr);
  if (def != 0) goto <D.22677>; else goto <D.22678>;
  <D.22677>:
  D.22679 = param_count + 1;
  D.22680 = (int) D.22679;
  pattrs = mono_metadata_get_param_attrs (m, def, D.22680);
  <D.22678>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.22681 = (unsigned char) hasthis;
  D.22682 = (<unnamed-unsigned:1>) D.22681;
  method->hasthis = D.22682;
  D.22683 = (unsigned char) explicit_this;
  D.22684 = (<unnamed-unsigned:1>) D.22683;
  method->explicit_this = D.22684;
  D.22685 = (unsigned char) call_convention;
  D.22686 = (<unnamed-unsigned:6>) D.22685;
  method->call_convention = D.22686;
  D.22687 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.22687;
  if (call_convention != 10) goto <D.22688>; else goto <D.22689>;
  <D.22688>:
  if (pattrs != 0B) goto <D.22691>; else goto <D.22692>;
  <D.22691>:
  D.22693 = *pattrs;
  iftmp.88 = (short int) D.22693;
  goto <D.22694>;
  <D.22692>:
  iftmp.88 = 0;
  <D.22694>:
  ptr.86 = ptr;
  D.22695 = mono_metadata_parse_type_full (m, container, 4, iftmp.88, ptr.86, &ptr);
  method->ret = D.22695;
  D.22696 = method->ret;
  if (D.22696 == 0B) goto <D.22697>; else goto <D.22698>;
  <D.22697>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.22699 = 0B;
  return D.22699;
  <D.22698>:
  D.22696 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.22696);
  <D.22689>:
  i = 0;
  goto <D.20080>;
  <D.20079>:
  ptr.86 = ptr;
  D.22662 = *ptr.86;
  if (D.22662 == 65) goto <D.22700>; else goto <D.22701>;
  <D.22700>:
  D.22704 = BIT_FIELD_REF <*method, 8, 80>;
  D.22705 = D.22704 & 63;
  if (D.22705 != 5) goto <D.22702>; else goto <D.22706>;
  <D.22706>:
  if (def != 0) goto <D.22702>; else goto <D.22703>;
  <D.22702>:
  D.22707 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.22707);
  monoeg_g_free (pattrs);
  D.22699 = 0B;
  return D.22699;
  <D.22703>:
  D.22708 = method->sentinelpos;
  if (D.22708 >= 0) goto <D.22709>; else goto <D.22710>;
  <D.22709>:
  D.22707 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.22707);
  monoeg_g_free (pattrs);
  D.22699 = 0B;
  return D.22699;
  <D.22710>:
  D.22711 = (short int) i;
  method->sentinelpos = D.22711;
  ptr.86 = ptr;
  ptr.87 = ptr.86 + 1;
  ptr = ptr.87;
  <D.22701>:
  if (pattrs != 0B) goto <D.22713>; else goto <D.22714>;
  <D.22713>:
  i.90 = (sizetype) i;
  D.22716 = i.90 + 1;
  D.22717 = D.22716 * 4;
  D.22718 = pattrs + D.22717;
  D.22719 = *D.22718;
  iftmp.89 = (short int) D.22719;
  goto <D.22720>;
  <D.22714>:
  iftmp.89 = 0;
  <D.22720>:
  ptr.86 = ptr;
  D.22721 = mono_metadata_parse_type_full (m, container, 3, iftmp.89, ptr.86, &ptr);
  method->params[i] = D.22721;
  D.22722 = method->params[i];
  if (D.22722 == 0B) goto <D.22723>; else goto <D.22724>;
  <D.22723>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.22699 = 0B;
  return D.22699;
  <D.22724>:
  if (is_open == 0) goto <D.22725>; else goto <D.22726>;
  <D.22725>:
  D.22722 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.22722);
  <D.22726>:
  i = i + 1;
  <D.20080>:
  D.22727 = method->param_count;
  D.22728 = (int) D.22727;
  if (D.22728 > i) goto <D.20079>; else goto <D.20081>;
  <D.20081>:
  if (def == 0) goto <D.22729>; else goto <D.22730>;
  <D.22729>:
  D.22704 = BIT_FIELD_REF <*method, 8, 80>;
  D.22705 = D.22704 & 63;
  if (D.22705 == 5) goto <D.22731>; else goto <D.22732>;
  <D.22731>:
  D.22708 = method->sentinelpos;
  if (D.22708 < 0) goto <D.22733>; else goto <D.22734>;
  <D.22733>:
  D.22727 = method->param_count;
  D.22735 = (short int) D.22727;
  method->sentinelpos = D.22735;
  <D.22734>:
  <D.22732>:
  <D.22730>:
  D.22736 = (unsigned char) is_open;
  D.22737 = (<unnamed-unsigned:1>) D.22736;
  method->has_type_parameters = D.22737;
  if (def != 0) goto <D.22738>; else goto <D.22739>;
  <D.22738>:
  D.22704 = BIT_FIELD_REF <*method, 8, 80>;
  D.22705 = D.22704 & 63;
  if (D.22705 == 5) goto <D.22740>; else goto <D.22741>;
  <D.22740>:
  D.22727 = method->param_count;
  D.22735 = (short int) D.22727;
  method->sentinelpos = D.22735;
  <D.22741>:
  <D.22739>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.22742>; else goto <D.22743>;
  <D.22742>:
  ptr.86 = ptr;
  *rptr = ptr.86;
  <D.22743>:
  D.22699 = method;
  return D.22699;
}


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

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


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.22747;
  struct MonoType * D.22750;
  short unsigned int D.22753;
  int D.22754;
  int i;

  D.22747 = sig->ret;
  if (D.22747 != 0B) goto <D.22748>; else goto <D.22749>;
  <D.22748>:
  D.22747 = sig->ret;
  mono_metadata_free_type (D.22747);
  <D.22749>:
  i = 0;
  goto <D.20096>;
  <D.20095>:
  D.22750 = sig->params[i];
  if (D.22750 != 0B) goto <D.22751>; else goto <D.22752>;
  <D.22751>:
  D.22750 = sig->params[i];
  mono_metadata_free_type (D.22750);
  <D.22752>:
  i = i + 1;
  <D.20096>:
  D.22753 = sig->param_count;
  D.22754 = (int) D.22753;
  if (D.22754 > i) goto <D.20095>; else goto <D.20097>;
  <D.20097>:
  monoeg_g_free (sig);
}


mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.22755;
  struct MonoMemPool * D.22758;
  void * D.22759;
  void * res;

  mono_image_set_lock (set);
  D.22755 = set->mempool;
  if (D.22755 == 0B) goto <D.22756>; else goto <D.22757>;
  <D.22756>:
  D.22758 = mono_mempool_new_size (1024);
  set->mempool = D.22758;
  <D.22757>:
  D.22755 = set->mempool;
  res = mono_mempool_alloc (D.22755, size);
  mono_image_set_unlock (set);
  D.22759 = res;
  return D.22759;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.22761;
  _Bool D.22764;
  long int D.22765;
  long int D.22766;

  {
    int ret;

    D.22761 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.22761);
    if (ret != 0) goto <D.22762>; else goto <D.22763>;
    <D.22762>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22763>:
    D.22764 = ret != 0;
    D.22765 = (long int) D.22764;
    D.22766 = __builtin_expect (D.22765, 0);
    if (D.22766 != 0) goto <D.22767>; else goto <D.22768>;
    <D.22767>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.22768>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.22769;
  _Bool D.22772;
  long int D.22773;
  long int D.22774;

  {
    int ret;

    D.22769 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.22769);
    if (ret != 0) goto <D.22770>; else goto <D.22771>;
    <D.22770>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22771>:
    D.22772 = ret != 0;
    D.22773 = (long int) D.22772;
    D.22774 = __builtin_expect (D.22773, 0);
    if (D.22774 != 0) goto <D.22775>; else goto <D.22776>;
    <D.22775>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.22776>:
  }
}


mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.22777;
  struct MonoMemPool * D.22780;
  void * D.22781;
  void * res;

  mono_image_set_lock (set);
  D.22777 = set->mempool;
  if (D.22777 == 0B) goto <D.22778>; else goto <D.22779>;
  <D.22778>:
  D.22780 = mono_mempool_new_size (1024);
  set->mempool = D.22780;
  <D.22779>:
  D.22777 = set->mempool;
  res = mono_mempool_alloc0 (D.22777, size);
  mono_image_set_unlock (set);
  D.22781 = res;
  return D.22781;
}


mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.22783;
  struct MonoMemPool * D.22786;
  char * D.22787;
  char * res;

  mono_image_set_lock (set);
  D.22783 = set->mempool;
  if (D.22783 == 0B) goto <D.22784>; else goto <D.22785>;
  <D.22784>:
  D.22786 = mono_mempool_new_size (1024);
  set->mempool = D.22786;
  <D.22785>:
  D.22783 = set->mempool;
  res = mono_mempool_strdup (D.22783, s);
  mono_image_set_unlock (set);
  D.22787 = res;
  return D.22787;
}


mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.22789;
  struct GSList * D.22790;
  struct GHashTable * D.22791;
  struct GHashTable * D.22792;
  struct GHashTable * D.22793;
  struct GHashTable * D.22794;
  void * D.22795;
  struct GSList * D.22796;
  struct GSList * D.22797;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.22789 = gclass_data.image;
      ginst_data.image = D.22789;
      gclass_data.list = 0B;
      D.22790 = gclass_data.list;
      ginst_data.list = D.22790;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.20344>;
      <D.20343>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.22791 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.22791, steal_gclass_in_image, &gclass_data);
        D.22792 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.22792, steal_ginst_in_image, &ginst_data);
        D.22793 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.22793, inflated_method_in_image, image);
        D.22794 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.22794, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.20344>:
      if (l != 0B) goto <D.20343>; else goto <D.20345>;
      <D.20345>:
      l = ginst_data.list;
      goto <D.20347>;
      <D.20346>:
      D.22795 = l->data;
      free_generic_inst (D.22795);
      l = l->next;
      <D.20347>:
      if (l != 0B) goto <D.20346>; else goto <D.20348>;
      <D.20348>:
      l = gclass_data.list;
      goto <D.20350>;
      <D.20349>:
      D.22795 = l->data;
      free_generic_class (D.22795);
      l = l->next;
      <D.20350>:
      if (l != 0B) goto <D.20349>; else goto <D.20351>;
      <D.20351>:
      D.22796 = ginst_data.list;
      monoeg_g_slist_free (D.22796);
      D.22790 = gclass_data.list;
      monoeg_g_slist_free (D.22790);
      D.22797 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.22797);
      l = set_list;
      goto <D.20354>;
      <D.20353>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.20354>:
      if (l != 0B) goto <D.20353>; else goto <D.20355>;
      <D.20355>:
      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.22798;
  int iftmp.91;
  struct MonoMethodSignature * D.22804;
  int D.22805;
  struct MonoGenericInst * D.22807;
  int D.22809;
  struct MonoGenericInst * D.22810;
  int D.22812;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.22804 = sig->sig;
  D.22805 = signature_in_image (D.22804, image);
  if (D.22805 != 0) goto <D.22800>; else goto <D.22806>;
  <D.22806>:
  D.22807 = sig->context.class_inst;
  if (D.22807 != 0B) goto <D.22808>; else goto <D.22801>;
  <D.22808>:
  D.22807 = sig->context.class_inst;
  D.22809 = ginst_in_image (D.22807, image);
  if (D.22809 != 0) goto <D.22800>; else goto <D.22801>;
  <D.22801>:
  D.22810 = sig->context.method_inst;
  if (D.22810 != 0B) goto <D.22811>; else goto <D.22802>;
  <D.22811>:
  D.22810 = sig->context.method_inst;
  D.22812 = ginst_in_image (D.22810, image);
  if (D.22812 != 0) goto <D.22800>; else goto <D.22802>;
  <D.22800>:
  iftmp.91 = 1;
  goto <D.22803>;
  <D.22802>:
  iftmp.91 = 0;
  <D.22803>:
  D.22798 = iftmp.91;
  return D.22798;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.22814;
  gboolean D.22817;
  struct MonoType * D.22818;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.20128>;
      <D.20127>:
      D.22814 = type_in_image (p, image);
      if (D.22814 != 0) goto <D.22815>; else goto <D.22816>;
      <D.22815>:
      D.22817 = 1;
      return D.22817;
      <D.22816>:
      <D.20128>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.20127>; else goto <D.20129>;
      <D.20129>:
      D.22818 = mono_signature_get_return_type (sig);
      D.22817 = type_in_image (D.22818, image);
      return D.22817;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.22821;
  int D.22822;
  gboolean D.22823;
  struct MonoGenericClass * D.22824;
  struct MonoClass * D.22825;
  struct MonoArrayType * D.22826;
  struct MonoClass * D.22827;
  struct MonoMethodSignature * D.22828;
  struct MonoGenericParam * D.22829;
  unsigned char D.22832;
  signed char D.22833;
  _Bool D.22834;
  long int D.22835;
  long int D.22836;
  struct MonoClass * D.22839;
  struct MonoImage * D.22842;
  _Bool D.22843;
  struct MonoImage * D.22844;
  _Bool D.22845;
  struct MonoImage * D.22846;
  _Bool D.22847;
  unsigned char D.22852;
  signed char D.22853;
  _Bool D.22854;
  long int D.22855;
  long int D.22856;
  struct MonoMethod * D.22859;
  struct MonoImage * D.22862;
  _Bool D.22863;
  struct MonoClass * D.22864;
  struct MonoImage * D.22865;
  _Bool D.22866;
  struct MonoClass * D.22867;
  struct MonoImage * D.22868;
  _Bool D.22869;
  void retry = <<< error >>>;

  retry:
  D.22821 = type->type;
  D.22822 = (int) D.22821;
  switch (D.22822) <default: <D.20156>, case 15: <D.20148>, case 19: <D.20152>, case 20: <D.20150>, case 21: <D.20147>, case 27: <D.20151>, case 29: <D.20149>, case 30: <D.20154>>
  <D.20147>:
  D.22824 = type->data.generic_class;
  D.22823 = gclass_in_image (D.22824, image);
  return D.22823;
  <D.20148>:
  type = type->data.type;
  goto retry;
  <D.20149>:
  D.22825 = type->data.klass;
  type = &D.22825->byval_arg;
  goto retry;
  <D.20150>:
  D.22826 = type->data.array;
  D.22827 = D.22826->eklass;
  type = &D.22827->byval_arg;
  goto retry;
  <D.20151>:
  D.22828 = type->data.method;
  D.22823 = signature_in_image (D.22828, image);
  return D.22823;
  <D.20152>:
  {
    struct MonoGenericContainer * container;

    D.22829 = type->data.generic_param;
    container = D.22829->owner;
    if (container != 0B) goto <D.22830>; else goto <D.22831>;
    <D.22830>:
    D.22832 = BIT_FIELD_REF <*container, 8, 152>;
    D.22833 = (signed char) D.22832;
    D.22834 = D.22833 < 0;
    D.22835 = (long int) D.22834;
    D.22836 = __builtin_expect (D.22835, 0);
    if (D.22836 != 0) goto <D.22837>; else goto <D.22838>;
    <D.22837>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.22838>:
    D.22839 = container->owner.klass;
    if (D.22839 == 0B) goto <D.22840>; else goto <D.22841>;
    <D.22840>:
    D.22842 = container->image;
    D.22843 = D.22842 == image;
    D.22823 = (gboolean) D.22843;
    return D.22823;
    <D.22841>:
    D.22839 = container->owner.klass;
    D.22844 = D.22839->image;
    D.22845 = D.22844 == image;
    D.22823 = (gboolean) D.22845;
    return D.22823;
    <D.22831>:
    D.22829 = type->data.generic_param;
    D.22846 = D.22829->image;
    D.22847 = D.22846 == image;
    D.22823 = (gboolean) D.22847;
    return D.22823;
  }
  <D.20154>:
  {
    struct MonoGenericContainer * container;

    D.22829 = type->data.generic_param;
    container = D.22829->owner;
    D.22829 = type->data.generic_param;
    D.22846 = D.22829->image;
    if (D.22846 == image) goto <D.22848>; else goto <D.22849>;
    <D.22848>:
    D.22823 = 1;
    return D.22823;
    <D.22849>:
    if (container != 0B) goto <D.22850>; else goto <D.22851>;
    <D.22850>:
    D.22852 = BIT_FIELD_REF <*container, 8, 152>;
    D.22853 = (signed char) D.22852;
    D.22854 = D.22853 >= 0;
    D.22855 = (long int) D.22854;
    D.22856 = __builtin_expect (D.22855, 0);
    if (D.22856 != 0) goto <D.22857>; else goto <D.22858>;
    <D.22857>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.22858>:
    D.22859 = container->owner.method;
    if (D.22859 == 0B) goto <D.22860>; else goto <D.22861>;
    <D.22860>:
    D.22862 = container->image;
    D.22863 = D.22862 == image;
    D.22823 = (gboolean) D.22863;
    return D.22823;
    <D.22861>:
    D.22859 = container->owner.method;
    D.22864 = D.22859->klass;
    D.22865 = D.22864->image;
    D.22866 = D.22865 == image;
    D.22823 = (gboolean) D.22866;
    return D.22823;
    <D.22851>:
    D.22829 = type->data.generic_param;
    D.22846 = D.22829->image;
    D.22847 = D.22846 == image;
    D.22823 = (gboolean) D.22847;
    return D.22823;
  }
  <D.20156>:
  D.22867 = mono_class_from_mono_type (type);
  D.22868 = D.22867->image;
  D.22869 = D.22868 == image;
  D.22823 = (gboolean) D.22869;
  return D.22823;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.22871;
  int iftmp.92;
  struct MonoClass * D.22876;
  struct MonoImage * D.22877;
  struct MonoGenericInst * D.22879;
  int D.22880;

  D.22876 = gclass->container_class;
  D.22877 = D.22876->image;
  if (D.22877 == image) goto <D.22873>; else goto <D.22878>;
  <D.22878>:
  D.22879 = gclass->context.class_inst;
  D.22880 = ginst_in_image (D.22879, image);
  if (D.22880 != 0) goto <D.22873>; else goto <D.22874>;
  <D.22873>:
  iftmp.92 = 1;
  goto <D.22875>;
  <D.22874>:
  iftmp.92 = 0;
  <D.22875>:
  D.22871 = iftmp.92;
  return D.22871;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.22882;
  int D.22883;
  gboolean D.22886;
  <unnamed-unsigned:22> D.22887;
  int D.22888;
  int i;

  i = 0;
  goto <D.20136>;
  <D.20135>:
  D.22882 = ginst->type_argv[i];
  D.22883 = type_in_image (D.22882, image);
  if (D.22883 != 0) goto <D.22884>; else goto <D.22885>;
  <D.22884>:
  D.22886 = 1;
  return D.22886;
  <D.22885>:
  i = i + 1;
  <D.20136>:
  D.22887 = ginst->type_argc;
  D.22888 = (int) D.22887;
  if (D.22888 > i) goto <D.20135>; else goto <D.20137>;
  <D.20137>:
  D.22886 = 0;
  return D.22886;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.93;
  struct MonoMethod * D.22896;
  struct MonoClass * D.22897;
  struct MonoImage * D.22898;
  struct MonoGenericInst * D.22900;
  int D.22902;
  struct MonoGenericInst * D.22903;
  int D.22905;
  struct MonoMethodSignature * D.22906;
  struct MonoMethodSignature * D.22908;
  int D.22909;
  _Bool D.22910;
  long int D.22911;
  long int D.22912;
  gboolean D.22915;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.22896 = method->declaring;
  D.22897 = D.22896->klass;
  D.22898 = D.22897->image;
  if (D.22898 != image) goto <D.22899>; else goto <D.22891>;
  <D.22899>:
  D.22900 = method->context.class_inst;
  if (D.22900 == 0B) goto <D.22892>; else goto <D.22901>;
  <D.22901>:
  D.22900 = method->context.class_inst;
  D.22902 = ginst_in_image (D.22900, image);
  if (D.22902 == 0) goto <D.22892>; else goto <D.22891>;
  <D.22892>:
  D.22903 = method->context.method_inst;
  if (D.22903 == 0B) goto <D.22893>; else goto <D.22904>;
  <D.22904>:
  D.22903 = method->context.method_inst;
  D.22905 = ginst_in_image (D.22903, image);
  if (D.22905 == 0) goto <D.22893>; else goto <D.22891>;
  <D.22893>:
  D.22906 = MEM[(struct MonoMethod *)method].signature;
  if (D.22906 == 0B) goto <D.22894>; else goto <D.22907>;
  <D.22907>:
  D.22908 = mono_method_signature (method);
  D.22909 = signature_in_image (D.22908, image);
  if (D.22909 == 0) goto <D.22894>; else goto <D.22891>;
  <D.22894>:
  iftmp.93 = 1;
  goto <D.22895>;
  <D.22891>:
  iftmp.93 = 0;
  <D.22895>:
  D.22910 = iftmp.93 != 0;
  D.22911 = (long int) D.22910;
  D.22912 = __builtin_expect (D.22911, 0);
  if (D.22912 != 0) goto <D.22913>; else goto <D.22914>;
  <D.22913>:
  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.22914>:
  D.22915 = 1;
  return D.22915;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.22917;
  struct GSList * D.22918;
  gboolean D.22919;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.22917 = user_data->list;
  D.22918 = monoeg_g_slist_prepend (D.22917, ginst);
  user_data->list = D.22918;
  D.22919 = 1;
  return D.22919;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.22921;
  int D.22922;
  _Bool D.22923;
  long int D.22924;
  long int D.22925;
  struct GSList * D.22928;
  struct GSList * D.22929;
  gboolean D.22930;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.22921 = user_data->image;
  D.22922 = gclass_in_image (gclass, D.22921);
  D.22923 = D.22922 == 0;
  D.22924 = (long int) D.22923;
  D.22925 = __builtin_expect (D.22924, 0);
  if (D.22925 != 0) goto <D.22926>; else goto <D.22927>;
  <D.22926>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.22927>:
  D.22928 = user_data->list;
  D.22929 = monoeg_g_slist_prepend (D.22928, gclass);
  user_data->list = D.22929;
  D.22930 = 1;
  return D.22930;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.22932;
  <unnamed-unsigned:22> D.22933;
  int D.22934;
  int i;

  i = 0;
  goto <D.20370>;
  <D.20369>:
  D.22932 = ginst->type_argv[i];
  mono_metadata_free_type (D.22932);
  i = i + 1;
  <D.20370>:
  D.22933 = ginst->type_argc;
  D.22934 = (int) D.22933;
  if (D.22934 > i) goto <D.20369>; else goto <D.20371>;
  <D.20371>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  unsigned char D.22935;
  unsigned char D.22936;
  struct MonoClass * D.22939;
  short unsigned int D.22942;

  D.22935 = BIT_FIELD_REF <*gclass, 8, 96>;
  D.22936 = D.22935 & 1;
  if (D.22936 != 0) goto <D.22937>; else goto <D.22938>;
  <D.22937>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.22938>:
  D.22939 = gclass->cached_class;
  if (D.22939 != 0B) goto <D.22940>; else goto <D.22941>;
  <D.22940>:
  D.22939 = gclass->cached_class;
  D.22942 = D.22939->interface_id;
  if (D.22942 != 0) goto <D.22943>; else goto <D.22944>;
  <D.22943>:
  D.22939 = gclass->cached_class;
  mono_unload_interface_id (D.22939);
  <D.22944>:
  <D.22941>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.22945;
  struct GHashTable * D.22946;
  struct GHashTable * D.22947;
  struct GHashTable * D.22948;
  struct MonoImage * * D.22949;
  unsigned int i.94;
  unsigned int D.22951;
  struct MonoImage * * D.22952;
  struct MonoImage * D.22953;
  struct GSList * D.22954;
  struct GSList * D.22955;
  int D.22956;
  struct GPtrArray * image_sets.95;
  struct MonoMemPool * D.22958;
  struct CRITICAL_SECTION * D.22961;
  int i;

  D.22945 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.22945);
  D.22946 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.22946);
  D.22947 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.22947);
  D.22948 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.22948);
  i = 0;
  goto <D.20186>;
  <D.20185>:
  D.22949 = set->images;
  i.94 = (unsigned int) i;
  D.22951 = i.94 * 4;
  D.22952 = D.22949 + D.22951;
  D.22953 = *D.22952;
  D.22949 = set->images;
  i.94 = (unsigned int) i;
  D.22951 = i.94 * 4;
  D.22952 = D.22949 + D.22951;
  D.22953 = *D.22952;
  D.22954 = D.22953->image_sets;
  D.22955 = monoeg_g_slist_remove (D.22954, set);
  D.22953->image_sets = D.22955;
  i = i + 1;
  <D.20186>:
  D.22956 = set->nimages;
  if (D.22956 > i) goto <D.20185>; else goto <D.20187>;
  <D.20187>:
  image_sets.95 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.95, set);
  D.22958 = set->mempool;
  if (D.22958 != 0B) goto <D.22959>; else goto <D.22960>;
  <D.22959>:
  D.22958 = set->mempool;
  mono_mempool_destroy (D.22958);
  <D.22960>:
  D.22949 = set->images;
  monoeg_g_free (D.22949);
  D.22961 = &set->lock;
  DeleteCriticalSection (D.22961);
  monoeg_g_free (set);
}


mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  struct MonoImage * * D.22962;
  int D.22963;
  struct GHashTable * D.22966;
  struct MonoMethodInflated * D.22967;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.22962 = data.images;
      D.22963 = data.nimages;
      set = get_image_set (D.22962, D.22963);
      collect_data_free (&data);
      if (cache != 0) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      D.22966 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.22966, method, method, 0);
      D.22967 = method;
      return D.22967;
      <D.22965>:
      D.22966 = set->gmethod_cache;
      D.22967 = monoeg_g_hash_table_lookup (D.22966, method);
      return D.22967;
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.22971;
  struct MonoClass * D.22972;
  struct MonoImage * D.22973;
  struct MonoGenericInst * D.22974;
  struct MonoGenericInst * D.22977;
  struct MonoClass * D.22980;
  struct MonoImage * D.22981;
  unsigned char D.22982;
  unsigned char D.22983;
  struct MonoMethodSignature * D.22986;
  struct MonoMethod * m;

  m = method->declaring;
  D.22971 = method->declaring;
  D.22972 = D.22971->klass;
  D.22973 = D.22972->image;
  add_image (D.22973, data);
  D.22974 = method->context.class_inst;
  if (D.22974 != 0B) goto <D.22975>; else goto <D.22976>;
  <D.22975>:
  D.22974 = method->context.class_inst;
  collect_ginst_images (D.22974, data);
  <D.22976>:
  D.22977 = method->context.method_inst;
  if (D.22977 != 0B) goto <D.22978>; else goto <D.22979>;
  <D.22978>:
  D.22977 = method->context.method_inst;
  collect_ginst_images (D.22977, data);
  <D.22979>:
  D.22980 = m->klass;
  D.22981 = D.22980->image;
  D.22982 = BIT_FIELD_REF <*D.22981, 8, 128>;
  D.22983 = D.22982 & 8;
  if (D.22983 != 0) goto <D.22984>; else goto <D.22985>;
  <D.22984>:
  D.22986 = mono_method_signature (m);
  collect_signature_images (D.22986, data);
  <D.22985>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.22987;
  unsigned int i.96;
  unsigned int D.22989;
  struct MonoImage * * D.22990;
  struct MonoImage * D.22991;
  int D.22994;
  int D.22995;
  int D.22998;
  int D.22999;
  unsigned int D.23000;
  unsigned int D.23001;
  struct MonoImage * * D.23002;
  int i;

  i = 0;
  goto <D.20234>;
  <D.20233>:
  D.22987 = data->images;
  i.96 = (unsigned int) i;
  D.22989 = i.96 * 4;
  D.22990 = D.22987 + D.22989;
  D.22991 = *D.22990;
  if (D.22991 == image) goto <D.22992>; else goto <D.22993>;
  <D.22992>:
  return;
  <D.22993>:
  i = i + 1;
  <D.20234>:
  D.22994 = data->nimages;
  if (D.22994 > i) goto <D.20233>; else goto <D.20235>;
  <D.20235>:
  D.22994 = data->nimages;
  D.22995 = data->images_len;
  if (D.22994 == D.22995) goto <D.22996>; else goto <D.22997>;
  <D.22996>:
  enlarge_data (data);
  <D.22997>:
  D.22987 = data->images;
  D.22994 = data->nimages;
  D.22998 = D.22994;
  D.22999 = D.22998 + 1;
  data->nimages = D.22999;
  D.23000 = (unsigned int) D.22998;
  D.23001 = D.23000 * 4;
  D.23002 = D.22987 + D.23001;
  *D.23002 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.97;
  int D.23005;
  unsigned int new_len.98;
  unsigned int D.23010;
  struct MonoImage * * D.23011;
  unsigned int D.23012;
  struct MonoImage *[64] * D.23013;
  int new_len;
  struct MonoImage * * d;

  D.23005 = data->images_len;
  if (D.23005 > 15) goto <D.23006>; else goto <D.23007>;
  <D.23006>:
  D.23005 = data->images_len;
  iftmp.97 = D.23005 * 2;
  goto <D.23008>;
  <D.23007>:
  iftmp.97 = 16;
  <D.23008>:
  new_len = iftmp.97;
  new_len.98 = (unsigned int) new_len;
  D.23010 = new_len.98 * 4;
  d = monoeg_malloc (D.23010);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.23011 = data->images;
  D.23005 = data->images_len;
  D.23012 = (unsigned int) D.23005;
  memcpy (d, D.23011, D.23012);
  D.23011 = data->images;
  D.23013 = &data->image_buf;
  if (D.23011 != D.23013) goto <D.23014>; else goto <D.23015>;
  <D.23014>:
  D.23011 = data->images;
  monoeg_g_free (D.23011);
  <D.23015>:
  data->images = d;
  data->images_len = new_len;
}


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

  i = 0;
  goto <D.20245>;
  <D.20244>:
  D.23016 = ginst->type_argv[i];
  collect_type_images (D.23016, data);
  i = i + 1;
  <D.20245>:
  D.23017 = ginst->type_argc;
  D.23018 = (int) D.23017;
  if (D.23018 > i) goto <D.20244>; else goto <D.20246>;
  <D.20246>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.23019;
  int D.23020;
  struct MonoGenericClass * D.23021;
  struct MonoClass * D.23022;
  struct MonoArrayType * D.23023;
  struct MonoClass * D.23024;
  struct MonoGenericParam * D.23025;
  unsigned char D.23028;
  signed char D.23029;
  _Bool D.23030;
  long int D.23031;
  long int D.23032;
  struct MonoClass * D.23035;
  struct MonoImage * D.23038;
  struct MonoImage * D.23040;
  struct MonoImage * D.23042;
  struct MonoMethod * D.23047;
  struct MonoImage * D.23050;
  unsigned char D.23052;
  signed char D.23053;
  _Bool D.23054;
  long int D.23055;
  long int D.23056;
  struct MonoClass * D.23059;
  struct MonoImage * D.23060;
  struct MonoClass * D.23062;
  struct MonoImage * D.23063;
  struct MonoImage * D.23064;
  void retry = <<< error >>>;

  retry:
  D.23019 = type->type;
  D.23020 = (int) D.23019;
  switch (D.23020) <default: <D.20286>, case 15: <D.20276>, case 17: <D.20285>, case 18: <D.20284>, case 19: <D.20280>, case 20: <D.20278>, case 21: <D.20274>, case 27: <D.20279>, case 29: <D.20277>, case 30: <D.20282>>
  <D.20274>:
  D.23021 = type->data.generic_class;
  collect_gclass_images (D.23021, data);
  goto <D.20275>;
  <D.20276>:
  type = type->data.type;
  goto retry;
  <D.20277>:
  D.23022 = type->data.klass;
  type = &D.23022->byval_arg;
  goto retry;
  <D.20278>:
  D.23023 = type->data.array;
  D.23024 = D.23023->eklass;
  type = &D.23024->byval_arg;
  goto retry;
  <D.20279>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.20280>:
  {
    struct MonoGenericContainer * container;

    D.23025 = type->data.generic_param;
    container = D.23025->owner;
    if (container != 0B) goto <D.23026>; else goto <D.23027>;
    <D.23026>:
    D.23028 = BIT_FIELD_REF <*container, 8, 152>;
    D.23029 = (signed char) D.23028;
    D.23030 = D.23029 < 0;
    D.23031 = (long int) D.23030;
    D.23032 = __builtin_expect (D.23031, 0);
    if (D.23032 != 0) goto <D.23033>; else goto <D.23034>;
    <D.23033>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.23034>:
    D.23035 = container->owner.klass;
    if (D.23035 == 0B) goto <D.23036>; else goto <D.23037>;
    <D.23036>:
    D.23038 = container->image;
    add_image (D.23038, data);
    goto <D.23039>;
    <D.23037>:
    D.23035 = container->owner.klass;
    D.23040 = D.23035->image;
    add_image (D.23040, data);
    <D.23039>:
    goto <D.23041>;
    <D.23027>:
    D.23025 = type->data.generic_param;
    D.23042 = D.23025->image;
    add_image (D.23042, data);
    <D.23041>:
  }
  goto <D.20275>;
  <D.20282>:
  {
    struct MonoGenericContainer * container;

    D.23025 = type->data.generic_param;
    container = D.23025->owner;
    D.23025 = type->data.generic_param;
    D.23042 = D.23025->image;
    if (D.23042 != 0B) goto <D.23043>; else goto <D.23044>;
    <D.23043>:
    D.23025 = type->data.generic_param;
    D.23042 = D.23025->image;
    add_image (D.23042, data);
    <D.23044>:
    if (container != 0B) goto <D.23045>; else goto <D.23046>;
    <D.23045>:
    D.23047 = container->owner.method;
    if (D.23047 == 0B) goto <D.23048>; else goto <D.23049>;
    <D.23048>:
    D.23050 = container->image;
    add_image (D.23050, data);
    goto <D.23051>;
    <D.23049>:
    D.23052 = BIT_FIELD_REF <*container, 8, 152>;
    D.23053 = (signed char) D.23052;
    D.23054 = D.23053 >= 0;
    D.23055 = (long int) D.23054;
    D.23056 = __builtin_expect (D.23055, 0);
    if (D.23056 != 0) goto <D.23057>; else goto <D.23058>;
    <D.23057>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.23058>:
    D.23047 = container->owner.method;
    D.23059 = D.23047->klass;
    D.23060 = D.23059->image;
    add_image (D.23060, data);
    <D.23051>:
    goto <D.23061>;
    <D.23046>:
    D.23025 = type->data.generic_param;
    D.23042 = D.23025->image;
    add_image (D.23042, data);
    <D.23061>:
  }
  goto <D.20275>;
  <D.20284>:
  <D.20285>:
  D.23062 = mono_class_from_mono_type (type);
  D.23063 = D.23062->image;
  add_image (D.23063, data);
  goto <D.20275>;
  <D.20286>:
  D.23064 = mono_defaults.corlib;
  add_image (D.23064, data);
  <D.20275>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.23065;
  struct MonoImage * D.23066;
  struct MonoGenericInst * D.23067;

  D.23065 = gclass->container_class;
  D.23066 = D.23065->image;
  add_image (D.23066, data);
  D.23067 = gclass->context.class_inst;
  if (D.23067 != 0B) goto <D.23068>; else goto <D.23069>;
  <D.23068>:
  D.23067 = gclass->context.class_inst;
  collect_ginst_images (D.23067, data);
  <D.23069>:
}


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

  try
    {
      iter = 0B;
      D.23070 = mono_signature_get_return_type (sig);
      collect_type_images (D.23070, data);
      goto <D.20258>;
      <D.20257>:
      collect_type_images (p, data);
      <D.20258>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.20257>; else goto <D.20259>;
      <D.20259>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.99;
  struct GPtrArray * image_sets.100;
  struct MonoImage * D.23077;
  struct MonoImage * D.23078;
  struct MonoImageSet * mscorlib_image_set.101;
  struct MonoImageSet * D.23084;
  struct MonoImage * * D.23091;
  struct MonoImage * D.23092;
  int D.23093;
  struct MonoImage * * D.23096;
  unsigned int k.102;
  unsigned int D.23098;
  struct MonoImage * * D.23099;
  struct MonoImage * D.23100;
  unsigned int j.103;
  unsigned int D.23102;
  struct MonoImage * * D.23103;
  struct MonoImage * D.23104;
  unsigned int nimages.104;
  unsigned int D.23111;
  void * D.23112;
  struct CRITICAL_SECTION * D.23113;
  unsigned int i.105;
  unsigned int D.23115;
  struct MonoImage * * D.23116;
  struct MonoImage * * D.23117;
  struct MonoImage * D.23118;
  struct GHashTable * D.23119;
  struct GHashTable * D.23120;
  struct GHashTable * D.23121;
  struct GHashTable * D.23122;
  struct MonoImage * D.23123;
  struct GSList * D.23124;
  struct GSList * D.23125;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.99 = image_sets;
  if (image_sets.99 == 0B) goto <D.23072>; else goto <D.23073>;
  <D.23072>:
  image_sets.100 = monoeg_g_ptr_array_new ();
  image_sets = image_sets.100;
  <D.23073>:
  if (nimages == 1) goto <D.23075>; else goto <D.23076>;
  <D.23075>:
  D.23077 = *images;
  D.23078 = mono_defaults.corlib;
  if (D.23077 == D.23078) goto <D.23079>; else goto <D.23080>;
  <D.23079>:
  mscorlib_image_set.101 = mscorlib_image_set;
  if (mscorlib_image_set.101 != 0B) goto <D.23082>; else goto <D.23083>;
  <D.23082>:
  D.23084 = mscorlib_image_set;
  return D.23084;
  <D.23083>:
  <D.23080>:
  <D.23076>:
  if (nimages == 0) goto <D.23085>; else goto <D.23086>;
  <D.23085>:
  D.23084 = mscorlib_image_set;
  return D.23084;
  <D.23086>:
  D.23077 = *images;
  D.23078 = mono_defaults.corlib;
  if (D.23077 == D.23078) goto <D.23089>; else goto <D.23087>;
  <D.23089>:
  if (nimages > 1) goto <D.23090>; else goto <D.23087>;
  <D.23090>:
  D.23091 = images + 4;
  D.23092 = *D.23091;
  l = D.23092->image_sets;
  goto <D.23088>;
  <D.23087>:
  D.23077 = *images;
  l = D.23077->image_sets;
  <D.23088>:
  set = 0B;
  goto <D.20174>;
  <D.20173>:
  set = l->data;
  D.23093 = set->nimages;
  if (D.23093 == nimages) goto <D.23094>; else goto <D.23095>;
  <D.23094>:
  j = 0;
  goto <D.20171>;
  <D.20170>:
  k = 0;
  goto <D.20168>;
  <D.20167>:
  D.23096 = set->images;
  k.102 = (unsigned int) k;
  D.23098 = k.102 * 4;
  D.23099 = D.23096 + D.23098;
  D.23100 = *D.23099;
  j.103 = (unsigned int) j;
  D.23102 = j.103 * 4;
  D.23103 = images + D.23102;
  D.23104 = *D.23103;
  if (D.23100 == D.23104) goto <D.20166>; else goto <D.23105>;
  <D.23105>:
  k = k + 1;
  <D.20168>:
  if (k < nimages) goto <D.20167>; else goto <D.20166>;
  <D.20166>:
  if (k == nimages) goto <D.20169>; else goto <D.23106>;
  <D.23106>:
  j = j + 1;
  <D.20171>:
  if (j < nimages) goto <D.20170>; else goto <D.20169>;
  <D.20169>:
  if (j == nimages) goto <D.20172>; else goto <D.23107>;
  <D.23107>:
  <D.23095>:
  l = l->next;
  <D.20174>:
  if (l != 0B) goto <D.20173>; else goto <D.20172>;
  <D.20172>:
  if (l == 0B) goto <D.23108>; else goto <D.23109>;
  <D.23108>:
  set = monoeg_malloc0 (56);
  set->nimages = nimages;
  nimages.104 = (unsigned int) nimages;
  D.23111 = nimages.104 * 4;
  D.23112 = monoeg_malloc0 (D.23111);
  set->images = D.23112;
  D.23113 = &set->lock;
  InitializeCriticalSection (D.23113);
  i = 0;
  goto <D.20176>;
  <D.20175>:
  D.23096 = set->images;
  i.105 = (unsigned int) i;
  D.23115 = i.105 * 4;
  D.23116 = D.23096 + D.23115;
  i.105 = (unsigned int) i;
  D.23115 = i.105 * 4;
  D.23117 = images + D.23115;
  D.23118 = *D.23117;
  *D.23116 = D.23118;
  i = i + 1;
  <D.20176>:
  if (i < nimages) goto <D.20175>; else goto <D.20177>;
  <D.20177>:
  D.23119 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.23119;
  D.23120 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.23120;
  D.23121 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.23121;
  D.23122 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.23122;
  i = 0;
  goto <D.20179>;
  <D.20178>:
  D.23096 = set->images;
  i.105 = (unsigned int) i;
  D.23115 = i.105 * 4;
  D.23116 = D.23096 + D.23115;
  D.23123 = *D.23116;
  D.23096 = set->images;
  i.105 = (unsigned int) i;
  D.23115 = i.105 * 4;
  D.23116 = D.23096 + D.23115;
  D.23123 = *D.23116;
  D.23124 = D.23123->image_sets;
  D.23125 = monoeg_g_slist_prepend (D.23124, set);
  D.23123->image_sets = D.23125;
  i = i + 1;
  <D.20179>:
  if (i < nimages) goto <D.20178>; else goto <D.20180>;
  <D.20180>:
  image_sets.99 = image_sets;
  monoeg_g_ptr_array_add (image_sets.99, set);
  <D.23109>:
  if (nimages == 1) goto <D.23126>; else goto <D.23127>;
  <D.23126>:
  D.23077 = *images;
  D.23078 = mono_defaults.corlib;
  if (D.23077 == D.23078) goto <D.23128>; else goto <D.23129>;
  <D.23128>:
  mscorlib_image_set = set;
  <D.23129>:
  <D.23127>:
  D.23084 = set;
  return D.23084;
}


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

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


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.23132;
  struct MonoMethodSignature * D.23133;
  gboolean D.23136;
  const struct MonoGenericContext * D.23137;
  const struct MonoGenericContext * D.23138;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.23132 = sig1->sig;
  D.23133 = sig2->sig;
  if (D.23132 != D.23133) goto <D.23134>; else goto <D.23135>;
  <D.23134>:
  D.23136 = 0;
  return D.23136;
  <D.23135>:
  D.23137 = &sig1->context;
  D.23138 = &sig2->context;
  D.23136 = mono_metadata_generic_context_equal (D.23137, D.23138);
  return D.23136;
}


inflated_signature_hash (const void * a)
{
  guint D.23140;
  const struct MonoGenericContext * D.23141;
  unsigned int D.23142;
  struct MonoMethodSignature * D.23143;
  unsigned int D.23144;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.23141 = &sig->context;
  D.23142 = mono_metadata_generic_context_hash (D.23141);
  D.23143 = sig->sig;
  D.23144 = mono_aligned_addr_hash (D.23143);
  D.23140 = D.23142 ^ D.23144;
  return D.23140;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.23146;
  short unsigned int D.23149;
  int D.23150;
  int D.23151;
  short unsigned int D.23154;
  unsigned int D.23155;
  unsigned int D.23156;
  int D.23159;
  struct MonoType * D.23164;
  short unsigned int D.23165;
  int D.23166;
  struct MonoExceptionClause * D.23167;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.23146 = method->signature;
  if (D.23146 != 0B) goto <D.23147>; else goto <D.23148>;
  <D.23147>:
  D.23146 = method->signature;
  mono_metadata_free_inflated_signature (D.23146);
  <D.23148>:
  D.23149 = method->flags;
  D.23150 = (int) D.23149;
  D.23151 = D.23150 & 1024;
  if (D.23151 == 0) goto <D.23152>; else goto <D.23153>;
  <D.23152>:
  D.23154 = method->iflags;
  D.23155 = (unsigned int) D.23154;
  D.23156 = D.23155 & 4099;
  if (D.23156 == 0) goto <D.23157>; else goto <D.23158>;
  <D.23157>:
  D.23149 = method->flags;
  D.23150 = (int) D.23149;
  D.23159 = D.23150 & 8192;
  if (D.23159 == 0) goto <D.23160>; else goto <D.23161>;
  <D.23160>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.23162>; else goto <D.23163>;
    <D.23162>:
    i = 0;
    goto <D.20363>;
    <D.20362>:
    D.23164 = header->locals[i];
    mono_metadata_free_type (D.23164);
    i = i + 1;
    <D.20363>:
    D.23165 = header->num_locals;
    D.23166 = (int) D.23165;
    if (D.23166 > i) goto <D.20362>; else goto <D.20364>;
    <D.20364>:
    D.23167 = header->clauses;
    monoeg_g_free (D.23167);
    monoeg_g_free (header);
    <D.23163>:
  }
  <D.23161>:
  <D.23158>:
  <D.23153>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.23168;
  struct MonoMethod * D.23169;
  gboolean D.23172;
  unsigned char D.23173;
  unsigned char D.23174;
  unsigned char D.23175;
  signed char D.23176;
  const struct MonoGenericContext * D.23179;
  const struct MonoGenericContext * D.23180;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.23168 = ma->declaring;
  D.23169 = mb->declaring;
  if (D.23168 != D.23169) goto <D.23170>; else goto <D.23171>;
  <D.23170>:
  D.23172 = 0;
  return D.23172;
  <D.23171>:
  D.23173 = BIT_FIELD_REF <*ma, 8, 168>;
  D.23174 = BIT_FIELD_REF <*mb, 8, 168>;
  D.23175 = D.23173 ^ D.23174;
  D.23176 = (signed char) D.23175;
  if (D.23176 < 0) goto <D.23177>; else goto <D.23178>;
  <D.23177>:
  D.23172 = 0;
  return D.23172;
  <D.23178>:
  D.23179 = &ma->context;
  D.23180 = &mb->context;
  D.23172 = mono_metadata_generic_context_equal (D.23179, D.23180);
  return D.23172;
}


inflated_method_hash (const void * a)
{
  guint D.23182;
  const struct MonoGenericContext * D.23183;
  unsigned int D.23184;
  struct MonoMethod * D.23185;
  unsigned int D.23186;
  unsigned int D.23187;
  <unnamed-unsigned:1> D.23188;
  unsigned int D.23189;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.23183 = &ma->context;
  D.23184 = mono_metadata_generic_context_hash (D.23183);
  D.23185 = ma->declaring;
  D.23186 = mono_aligned_addr_hash (D.23185);
  D.23187 = D.23184 ^ D.23186;
  D.23188 = ma->method.method.is_mb_open;
  D.23189 = (unsigned int) D.23188;
  D.23182 = D.23187 + D.23189;
  return D.23182;
}


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

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


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.23193;
  struct MonoImage *[64] * D.23194;

  D.23193 = data->images;
  D.23194 = &data->image_buf;
  if (D.23193 != D.23194) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  D.23193 = data->images;
  monoeg_g_free (D.23193);
  <D.23196>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.23197;
  struct MonoGenericInst * D.23198;
  struct MonoImage * * D.23199;
  int D.23200;
  struct GHashTable * D.23201;
  struct MonoMethodSignature * D.23204;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.23197 = context->class_inst;
      helper.context.class_inst = D.23197;
      D.23198 = context->method_inst;
      helper.context.method_inst = D.23198;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.23199 = data.images;
      D.23200 = data.nimages;
      set = get_image_set (D.23199, D.23200);
      collect_data_free (&data);
      D.23201 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.23201, &helper);
      if (res == 0B) goto <D.23202>; else goto <D.23203>;
      <D.23202>:
      res = monoeg_malloc0 (12);
      res->sig = sig;
      D.23197 = context->class_inst;
      res->context.class_inst = D.23197;
      D.23198 = context->method_inst;
      res->context.method_inst = D.23198;
      D.23201 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.23201, res, res, 0);
      <D.23203>:
      mono_loader_unlock ();
      D.23204 = res->sig;
      return D.23204;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.23207;
  struct MonoGenericInst * D.23208;
  struct MonoGenericInst * D.23211;

  D.23207 = sig->sig;
  collect_signature_images (D.23207, data);
  D.23208 = sig->context.class_inst;
  if (D.23208 != 0B) goto <D.23209>; else goto <D.23210>;
  <D.23209>:
  D.23208 = sig->context.class_inst;
  collect_ginst_images (D.23208, data);
  <D.23210>:
  D.23211 = sig->context.method_inst;
  if (D.23211 != 0B) goto <D.23212>; else goto <D.23213>;
  <D.23212>:
  D.23211 = sig->context.method_inst;
  collect_ginst_images (D.23211, data);
  <D.23213>:
}


mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  unsigned int type_argc.106;
  unsigned int D.23215;
  unsigned int D.23216;
  unsigned int i.107;
  unsigned int D.23218;
  struct MonoType * * D.23219;
  struct MonoType * D.23220;
  int D.23221;
  _Bool D.23223;
  unsigned int size.108;
  unsigned char D.23225;
  <unnamed-unsigned:1> D.23226;
  <unnamed-unsigned:22> D.23227;
  struct MonoType *[0:] * D.23228;
  unsigned int D.23229;
  struct MonoImage * * D.23230;
  int D.23231;
  struct GHashTable * D.23232;
  unsigned int size.109;
  int next_generic_inst_id.110;
  int next_generic_inst_id.111;
  unsigned int next_generic_inst_id.112;
  struct MonoType * D.23239;
  struct MonoGenericInst * D.23240;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      type_argc.106 = (unsigned int) type_argc;
      D.23215 = type_argc.106 + 2;
      D.23216 = D.23215 * 4;
      size = (int) D.23216;
      i = 0;
      goto <D.20404>;
      <D.20403>:
      i.107 = (unsigned int) i;
      D.23218 = i.107 * 4;
      D.23219 = type_argv + D.23218;
      D.23220 = *D.23219;
      D.23221 = mono_class_is_open_constructed_type (D.23220);
      if (D.23221 != 0) goto <D.20402>; else goto <D.23222>;
      <D.23222>:
      i = i + 1;
      <D.20404>:
      if (i < type_argc) goto <D.20403>; else goto <D.20402>;
      <D.20402>:
      D.23223 = i < type_argc;
      is_open = (gboolean) D.23223;
      size.108 = (unsigned int) size;
      ginst = __builtin_alloca (size.108);
      memset (ginst, 0, 8);
      D.23225 = (unsigned char) is_open;
      D.23226 = (<unnamed-unsigned:1>) D.23225;
      ginst->is_open = D.23226;
      type_argc.106 = (unsigned int) type_argc;
      D.23227 = (<unnamed-unsigned:22>) type_argc.106;
      ginst->type_argc = D.23227;
      D.23228 = &ginst->type_argv;
      type_argc.106 = (unsigned int) type_argc;
      D.23229 = type_argc.106 * 4;
      memcpy (D.23228, type_argv, D.23229);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.23230 = data.images;
      D.23231 = data.nimages;
      set = get_image_set (D.23230, D.23231);
      collect_data_free (&data);
      D.23232 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.23232, ginst);
      if (ginst == 0B) goto <D.23233>; else goto <D.23234>;
      <D.23233>:
      size.109 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.109);
      next_generic_inst_id.110 = next_generic_inst_id;
      next_generic_inst_id.111 = next_generic_inst_id.110 + 1;
      next_generic_inst_id = next_generic_inst_id.111;
      next_generic_inst_id.110 = next_generic_inst_id;
      next_generic_inst_id.112 = (unsigned int) next_generic_inst_id.110;
      ginst->id = next_generic_inst_id.112;
      D.23225 = (unsigned char) is_open;
      D.23226 = (<unnamed-unsigned:1>) D.23225;
      ginst->is_open = D.23226;
      type_argc.106 = (unsigned int) type_argc;
      D.23227 = (<unnamed-unsigned:22>) type_argc.106;
      ginst->type_argc = D.23227;
      i = 0;
      goto <D.20406>;
      <D.20405>:
      i.107 = (unsigned int) i;
      D.23218 = i.107 * 4;
      D.23219 = type_argv + D.23218;
      D.23220 = *D.23219;
      D.23239 = mono_metadata_type_dup (0B, D.23220);
      ginst->type_argv[i] = D.23239;
      i = i + 1;
      <D.20406>:
      if (i < type_argc) goto <D.20405>; else goto <D.20407>;
      <D.20407>:
      D.23232 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.23232, ginst, ginst, 0);
      <D.23234>:
      mono_loader_unlock ();
      D.23240 = ginst;
      return D.23240;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.23243;
  <unnamed-unsigned:1> D.23244;
  unsigned char D.23245;
  <unnamed-unsigned:1> D.23246;
  struct MonoImage * * D.23247;
  int D.23248;
  struct GHashTable * D.23249;
  struct MonoClass * D.23250;
  _Bool D.23251;
  long int D.23252;
  long int D.23253;
  struct MonoGenericClass * D.23258;
  struct MonoGenericContainer * D.23262;
  struct MonoGenericInst * D.23263;
  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.23243 = (unsigned char) is_dynamic;
      D.23244 = (<unnamed-unsigned:1>) D.23243;
      helper.is_dynamic = D.23244;
      D.23245 = (unsigned char) is_tb_open;
      D.23246 = (<unnamed-unsigned:1>) D.23245;
      helper.is_tb_open = D.23246;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.23247 = data.images;
      D.23248 = data.nimages;
      set = get_image_set (D.23247, D.23248);
      collect_data_free (&data);
      D.23249 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.23249, &helper);
      D.23250 = helper.cached_class;
      D.23251 = D.23250 != 0B;
      D.23252 = (long int) D.23251;
      D.23253 = __builtin_expect (D.23252, 0);
      if (D.23253 != 0) goto <D.23254>; else goto <D.23255>;
      <D.23254>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.23255>:
      if (gclass != 0B) goto <D.23256>; else goto <D.23257>;
      <D.23256>:
      mono_loader_unlock ();
      D.23258 = gclass;
      return D.23258;
      <D.23257>:
      if (is_dynamic != 0) goto <D.23259>; else goto <D.23260>;
      <D.23259>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 44);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.23261>;
      <D.23260>:
      gclass = mono_image_set_alloc0 (set, 24);
      <D.23261>:
      D.23245 = (unsigned char) is_tb_open;
      D.23246 = (<unnamed-unsigned:1>) D.23245;
      gclass->is_tb_open = D.23246;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.23262 = container_class->generic_container;
      D.23263 = D.23262->context.class_inst;
      if (D.23263 == inst) goto <D.23264>; else goto <D.23265>;
      <D.23264>:
      if (is_tb_open == 0) goto <D.23266>; else goto <D.23267>;
      <D.23266>:
      gclass->cached_class = container_class;
      <D.23267>:
      <D.23265>:
      D.23249 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.23249, gclass, gclass, 0);
      mono_loader_unlock ();
      D.23258 = gclass;
      return D.23258;
    }
  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.23273;
  unsigned char D.23274;
  <unnamed-signed:31> D.23276;
  int D.23277;
  <unnamed-unsigned:22> D.23278;
  int D.23279;
  gboolean D.23280;
  struct MonoGenericInst * D.23281;
  _Bool D.23282;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.23270>; else goto <D.23272>;
  <D.23272>:
  D.23273 = BIT_FIELD_REF <*container_class, 8, 160>;
  D.23274 = D.23273 & 128;
  if (D.23274 != 0) goto <D.23270>; else goto <D.23275>;
  <D.23275>:
  D.23276 = container->type_argc;
  D.23277 = (int) D.23276;
  D.23278 = inst->type_argc;
  D.23279 = (int) D.23278;
  if (D.23277 != D.23279) goto <D.23270>; else goto <D.23271>;
  <D.23270>:
  D.23280 = 0;
  return D.23280;
  <D.23271>:
  D.23281 = container->context.class_inst;
  D.23282 = D.23281 == inst;
  D.23280 = (gboolean) D.23282;
  return D.23280;
}


mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned char D.23284;
  unsigned char D.23285;
  struct MonoGenericInst * D.23288;
  <unnamed-unsigned:22> D.23289;
  unsigned int D.23290;
  unsigned int D.23291;
  unsigned int i.113;
  unsigned int D.23293;
  struct MonoType * * D.23294;
  struct MonoType * D.23295;
  struct MonoType * D.23296;
  int D.23297;
  int D.23299;
  struct MonoType * D.23300;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.23284 = BIT_FIELD_REF <*ginst, 8, 48>;
  D.23285 = D.23284 & 64;
  if (D.23285 == 0) goto <D.23286>; else goto <D.23287>;
  <D.23286>:
  D.23288 = ginst;
  return D.23288;
  <D.23287>:
  D.23289 = ginst->type_argc;
  D.23290 = (unsigned int) D.23289;
  D.23291 = D.23290 * 4;
  type_argv = monoeg_malloc0 (D.23291);
  i = 0;
  goto <D.20436>;
  <D.20435>:
  i.113 = (unsigned int) i;
  D.23293 = i.113 * 4;
  D.23294 = type_argv + D.23293;
  D.23295 = ginst->type_argv[i];
  D.23296 = mono_class_inflate_generic_type_checked (D.23295, context, error);
  *D.23294 = D.23296;
  D.23297 = mono_error_ok (error);
  if (D.23297 == 0) goto cleanup; else goto <D.23298>;
  <D.23298>:
  count = count + 1;
  i = i + 1;
  <D.20436>:
  D.23289 = ginst->type_argc;
  D.23299 = (int) D.23289;
  if (D.23299 > i) goto <D.20435>; else goto <D.20437>;
  <D.20437>:
  D.23289 = ginst->type_argc;
  D.23299 = (int) D.23289;
  nginst = mono_metadata_get_generic_inst (D.23299, type_argv);
  cleanup:
  i = 0;
  goto <D.20439>;
  <D.20438>:
  i.113 = (unsigned int) i;
  D.23293 = i.113 * 4;
  D.23294 = type_argv + D.23293;
  D.23300 = *D.23294;
  mono_metadata_free_type (D.23300);
  i = i + 1;
  <D.20439>:
  if (i < count) goto <D.20438>; else goto <D.20440>;
  <D.20440>:
  monoeg_g_free (type_argv);
  D.23288 = nginst;
  return D.23288;
}


mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  unsigned int count.114;
  unsigned int D.23303;
  const char * ptr.115;
  struct MonoGenericInst * D.23307;
  unsigned int i.116;
  unsigned int D.23309;
  struct MonoType * * D.23310;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

  count.114 = (unsigned int) count;
  D.23303 = count.114 * 4;
  type_argv = monoeg_malloc0 (D.23303);
  i = 0;
  goto <D.20453>;
  <D.20452>:
  {
    struct MonoType * t;

    ptr.115 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.115, &ptr);
    if (t == 0B) goto <D.23305>; else goto <D.23306>;
    <D.23305>:
    monoeg_g_free (type_argv);
    D.23307 = 0B;
    return D.23307;
    <D.23306>:
    i.116 = (unsigned int) i;
    D.23309 = i.116 * 4;
    D.23310 = type_argv + D.23309;
    *D.23310 = t;
  }
  i = i + 1;
  <D.20453>:
  if (i < count) goto <D.20452>; else goto <D.20454>;
  <D.20454>:
  if (rptr != 0B) goto <D.23311>; else goto <D.23312>;
  <D.23311>:
  ptr.115 = ptr;
  *rptr = ptr.115;
  <D.23312>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.23307 = ginst;
  return D.23307;
}


mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.117;
  struct MonoType * D.23317;
  unsigned char D.23318;
  int D.23319;
  struct MonoClass * D.23320;
  struct MonoType * D.23321;
  struct MonoType * D.23324;
  struct MonoType * cached;

  type_cache.117 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.117, type);
  if (cached != 0B) goto <D.23315>; else goto <D.23316>;
  <D.23315>:
  D.23317 = cached;
  return D.23317;
  <D.23316>:
  D.23318 = type->type;
  D.23319 = (int) D.23318;
  switch (D.23319) <default: <D.23327>, case 17: <D.20485>, case 18: <D.20484>>
  <D.20484>:
  <D.20485>:
  D.23320 = type->data.klass;
  D.23321 = &D.23320->byval_arg;
  if (D.23321 == type) goto <D.23322>; else goto <D.23323>;
  <D.23322>:
  D.23317 = type;
  return D.23317;
  <D.23323>:
  D.23320 = type->data.klass;
  D.23324 = &D.23320->this_arg;
  if (D.23324 == type) goto <D.23325>; else goto <D.23326>;
  <D.23325>:
  D.23317 = type;
  return D.23317;
  <D.23326>:
  goto <D.20486>;
  <D.23327>:
  <D.20486>:
  D.23317 = 0B;
  return D.23317;
}


mono_metadata_free_type (struct MonoType * type)
{
  unsigned char D.23333;
  int D.23334;
  struct MonoClass * D.23335;
  struct MonoType * D.23339;
  struct MonoType * D.23341;
  struct MonoType * D.23342;
  struct MonoMethodSignature * D.23343;
  struct MonoArrayType * D.23344;

  if (type >= &builtin_types) goto <D.23329>; else goto <D.23330>;
  <D.23329>:
  if (type < &MEM[(void *)&builtin_types + 272B]) goto <D.23331>; else goto <D.23332>;
  <D.23331>:
  return;
  <D.23332>:
  <D.23330>:
  D.23333 = type->type;
  D.23334 = (int) D.23333;
  switch (D.23334) <default: <D.23345>, case 14: <D.20536>, case 15: <D.20540>, case 17: <D.20539>, case 18: <D.20538>, case 20: <D.20542>, case 27: <D.20541>, case 28: <D.20535>>
  <D.20535>:
  <D.20536>:
  D.23335 = type->data.klass;
  if (D.23335 == 0B) goto <D.20537>; else goto <D.23336>;
  <D.23336>:
  <D.20538>:
  <D.20539>:
  D.23335 = type->data.klass;
  D.23339 = &D.23335->byval_arg;
  if (D.23339 == type) goto <D.23337>; else goto <D.23340>;
  <D.23340>:
  D.23335 = type->data.klass;
  D.23341 = &D.23335->this_arg;
  if (D.23341 == type) goto <D.23337>; else goto <D.23338>;
  <D.23337>:
  return;
  <D.23338>:
  goto <D.20537>;
  <D.20540>:
  D.23342 = type->data.type;
  mono_metadata_free_type (D.23342);
  goto <D.20537>;
  <D.20541>:
  D.23343 = type->data.method;
  mono_metadata_free_method_signature (D.23343);
  goto <D.20537>;
  <D.20542>:
  D.23344 = type->data.array;
  mono_metadata_free_array (D.23344);
  goto <D.20537>;
  <D.23345>:
  <D.20537>:
  monoeg_g_free (type);
}


mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  unsigned char D.23347;
  unsigned char D.23348;
  short unsigned int D.23351;
  int D.23352;
  int D.23353;
  short unsigned int D.23355;
  unsigned int D.23356;
  unsigned int D.23357;
  int D.23359;
  gboolean D.23360;
  short unsigned int D.23361;
  short unsigned int D.23362;
  unsigned int D.23367;
  <unnamed-unsigned:15> D.23368;
  int D.23369;
  _Bool D.23370;
  int D.23371;
  unsigned int D.23372;
  int D.23373;
  struct MonoClass * D.23374;
  struct MonoTableInfo * D.23375;
  int D.23376;
  int D.23377;
  _Bool D.23380;
  long int D.23381;
  long int D.23382;
  int D.23385;
  unsigned char D.23386;
  unsigned int D.23387;
  unsigned int D.23388;
  int D.23389;
  int D.23390;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.20573>;
  <D.20572>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.20573>:
  D.23347 = BIT_FIELD_REF <*method, 8, 168>;
  D.23348 = D.23347 & 16;
  if (D.23348 != 0) goto <D.20572>; else goto <D.20574>;
  <D.20574>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.23351 = method->flags;
  D.23352 = (int) D.23351;
  D.23353 = D.23352 & 1024;
  if (D.23353 != 0) goto <D.23349>; else goto <D.23354>;
  <D.23354>:
  D.23355 = method->iflags;
  D.23356 = (unsigned int) D.23355;
  D.23357 = D.23356 & 4099;
  if (D.23357 != 0) goto <D.23349>; else goto <D.23358>;
  <D.23358>:
  D.23351 = method->flags;
  D.23352 = (int) D.23351;
  D.23359 = D.23352 & 8192;
  if (D.23359 != 0) goto <D.23349>; else goto <D.23350>;
  <D.23349>:
  D.23360 = 0;
  return D.23360;
  <D.23350>:
  D.23361 = BIT_FIELD_REF <*method, 16, 160>;
  D.23362 = D.23361 & 1148;
  if (D.23362 != 0) goto <D.23363>; else goto <D.23364>;
  <D.23363>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.23365>; else goto <D.23366>;
    <D.23365>:
    D.23360 = 0;
    return D.23360;
    <D.23366>:
    D.23367 = header->code_size;
    summary->code_size = D.23367;
    D.23368 = header->num_clauses;
    D.23369 = (int) D.23368;
    D.23370 = D.23369 > 0;
    D.23371 = (int) D.23370;
    summary->has_clauses = D.23371;
    D.23360 = 1;
    return D.23360;
  }
  <D.23364>:
  D.23372 = method->token;
  D.23373 = (int) D.23372;
  idx = D.23373 & 16777215;
  D.23374 = method->klass;
  img = D.23374->image;
  D.23375 = &img->tables[6];
  D.23376 = idx + -1;
  rva = mono_metadata_decode_row_col (D.23375, D.23376, 0);
  D.23377 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.23377 == 0) goto <D.23378>; else goto <D.23379>;
  <D.23378>:
  D.23360 = 0;
  return D.23360;
  <D.23379>:
  ptr = mono_image_rva_map (img, rva);
  D.23380 = ptr == 0B;
  D.23381 = (long int) D.23380;
  D.23382 = __builtin_expect (D.23381, 0);
  if (D.23382 != 0) goto <D.23383>; else goto <D.23384>;
  <D.23383>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.23384>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.23385 = (int) format;
  switch (D.23385) <default: <D.20579>, case 2: <D.20576>, case 3: <D.20578>>
  <D.20576>:
  ptr = ptr + 1;
  D.23386 = flags >> 2;
  D.23387 = (unsigned int) D.23386;
  summary->code_size = D.23387;
  goto <D.20577>;
  <D.20578>:
  fat_flags = mono_read16 (ptr);
  ptr = ptr + 4;
  D.23388 = mono_read32 (ptr);
  summary->code_size = D.23388;
  D.23389 = (int) fat_flags;
  D.23390 = D.23389 & 8;
  if (D.23390 != 0) goto <D.23391>; else goto <D.23392>;
  <D.23391>:
  summary->has_clauses = 1;
  <D.23392>:
  goto <D.20577>;
  <D.20579>:
  D.23360 = 0;
  return D.23360;
  <D.20577>:
  D.23360 = 1;
  return D.23360;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.23396;
  int D.23397;
  unsigned char D.23398;
  unsigned int D.23399;
  short unsigned int D.23400;
  int D.23401;
  short unsigned int D.23402;
  int D.23403;
  int D.23404;
  int D.23408;
  unsigned int D.23412;
  unsigned int D.23413;
  <unnamed-unsigned:24> D.23416;
  int D.23417;
  unsigned int D.23419;
  int D.23420;
  const char * locals_ptr.118;
  const char * locals_ptr.119;
  unsigned int D.23429;
  char D.23430;
  const char * locals_ptr.120;
  unsigned int D.23434;
  int num_clauses.121;
  unsigned int num_clauses.122;
  unsigned int D.23437;
  unsigned int len.123;
  unsigned int D.23439;
  unsigned int D.23440;
  unsigned int D.23441;
  short unsigned int D.23442;
  struct MonoType * D.23443;
  struct MonoType * D.23444;
  unsigned int D.23448;
  unsigned int D.23449;
  short unsigned int D.23450;
  <unnamed-unsigned:15> D.23451;
  unsigned char D.23452;
  <unnamed-unsigned:1> D.23453;
  short unsigned int D.23456;
  int D.23457;
  short unsigned int D.23458;
  <unnamed-unsigned:15> D.23459;
  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.23394>; else goto <D.23395>;
      <D.23394>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.23396 = 0B;
      return D.23396;
      <D.23395>:
      D.23397 = (int) format;
      switch (D.23397) <default: <D.20602>, case 2: <D.20599>, case 3: <D.20600>>
      <D.20599>:
      mh = monoeg_malloc0 (20);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.23398 = flags >> 2;
      D.23399 = (unsigned int) D.23398;
      mh->code_size = D.23399;
      mh->code = ptr;
      D.23396 = mh;
      return D.23396;
      <D.20600>:
      fat_flags = mono_read16 (ptr);
      ptr = ptr + 2;
      D.23400 = fat_flags >> 12;
      D.23401 = (int) D.23400;
      hsize = D.23401 & 15;
      D.23402 = mono_read16 (ptr);
      max_stack = (guint32) D.23402;
      ptr = ptr + 2;
      code_size = mono_read32 (ptr);
      ptr = ptr + 4;
      local_var_sig_tok = mono_read32 (ptr);
      ptr = ptr + 4;
      D.23403 = (int) fat_flags;
      D.23404 = D.23403 & 16;
      if (D.23404 != 0) goto <D.23405>; else goto <D.23406>;
      <D.23405>:
      init_locals = 1;
      goto <D.23407>;
      <D.23406>:
      init_locals = 0;
      <D.23407>:
      code = ptr;
      D.23403 = (int) fat_flags;
      D.23408 = D.23403 & 8;
      if (D.23408 == 0) goto <D.20601>; else goto <D.23409>;
      <D.23409>:
      ptr = code + code_size;
      goto <D.20601>;
      <D.20602>:
      D.23396 = 0B;
      return D.23396;
      <D.20601>:
      if (local_var_sig_tok != 0) goto <D.23410>; else goto <D.23411>;
      <D.23410>:
      {
        int idx;

        D.23412 = local_var_sig_tok & 16777215;
        D.23413 = D.23412 + 4294967295;
        idx = (int) D.23413;
        D.23416 = t->rows;
        D.23417 = (int) D.23416;
        if (D.23417 <= idx) goto <D.23414>; else goto <D.23418>;
        <D.23418>:
        if (idx < 0) goto <D.23414>; else goto <D.23415>;
        <D.23414>:
        D.23396 = 0B;
        return D.23396;
        <D.23415>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.23419 = cols[0];
        D.23420 = mono_verifier_verify_standalone_signature (m, D.23419, 0B);
        if (D.23420 == 0) goto <D.23421>; else goto <D.23422>;
        <D.23421>:
        D.23396 = 0B;
        return D.23396;
        <D.23422>:
      }
      <D.23411>:
      D.23403 = (int) fat_flags;
      D.23408 = D.23403 & 8;
      if (D.23408 != 0) goto <D.23423>; else goto <D.23424>;
      <D.23423>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.23424>:
      if (local_var_sig_tok != 0) goto <D.23425>; else goto <D.23426>;
      <D.23425>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.23419 = cols[0];
            locals_ptr.118 = mono_metadata_blob_heap (m, D.23419);
            locals_ptr = locals_ptr.118;
            locals_ptr.119 = locals_ptr;
            D.23429 = mono_metadata_decode_blob_size (locals_ptr.119, &locals_ptr);
            bsize = (int) D.23429;
            locals_ptr.119 = locals_ptr;
            D.23430 = *locals_ptr.119;
            if (D.23430 != 7) goto <D.23431>; else goto <D.23432>;
            <D.23431>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.23432>:
            locals_ptr.119 = locals_ptr;
            locals_ptr.120 = locals_ptr.119 + 1;
            locals_ptr = locals_ptr.120;
            locals_ptr.119 = locals_ptr;
            D.23434 = mono_metadata_decode_value (locals_ptr.119, &locals_ptr);
            len = (int) D.23434;
            num_clauses.121 = num_clauses;
            num_clauses.122 = (unsigned int) num_clauses.121;
            D.23437 = num_clauses.122 * 6;
            len.123 = (unsigned int) len;
            D.23439 = D.23437 + len.123;
            D.23440 = D.23439 + 5;
            D.23441 = D.23440 * 4;
            mh = monoeg_malloc0 (D.23441);
            D.23442 = (short unsigned int) len;
            mh->num_locals = D.23442;
            i = 0;
            goto <D.20609>;
            <D.20608>:
            locals_ptr.119 = locals_ptr;
            D.23443 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.119, &locals_ptr);
            mh->locals[i] = D.23443;
            D.23444 = mh->locals[i];
            if (D.23444 == 0B) goto <D.23445>; else goto <D.23446>;
            <D.23445>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.23396 = 0B;
            return D.23396;
            <D.23446>:
            i = i + 1;
            <D.20609>:
            if (i < len) goto <D.20608>; else goto <D.20610>;
            <D.20610>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.23447>;
      <D.23426>:
      num_clauses.121 = num_clauses;
      num_clauses.122 = (unsigned int) num_clauses.121;
      D.23448 = num_clauses.122 * 24;
      D.23449 = D.23448 + 20;
      mh = monoeg_malloc0 (D.23449);
      <D.23447>:
      mh->code = code;
      mh->code_size = code_size;
      D.23450 = (short unsigned int) max_stack;
      D.23451 = (<unnamed-unsigned:15>) D.23450;
      mh->max_stack = D.23451;
      mh->is_transient = 1;
      D.23452 = (unsigned char) init_locals;
      D.23453 = (<unnamed-unsigned:1>) D.23452;
      mh->init_locals = D.23453;
      if (clauses != 0B) goto <D.23454>; else goto <D.23455>;
      <D.23454>:
      {
        struct MonoExceptionClause * clausesp;

        D.23456 = mh->num_locals;
        D.23457 = (int) D.23456;
        clausesp = &mh->locals[D.23457];
        num_clauses.121 = num_clauses;
        num_clauses.122 = (unsigned int) num_clauses.121;
        D.23448 = num_clauses.122 * 24;
        memcpy (clausesp, clauses, D.23448);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.121 = num_clauses;
        D.23458 = (short unsigned int) num_clauses.121;
        D.23459 = (<unnamed-unsigned:15>) D.23458;
        mh->num_clauses = D.23459;
      }
      <D.23455>:
      D.23396 = mh;
      return D.23396;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.23464;
  const unsigned char * D.23467;
  unsigned char D.23468;
  int D.23469;
  int D.23470;
  const unsigned char * D.23471;
  unsigned char D.23472;
  int D.23473;
  int D.23474;
  int D.23475;
  unsigned char D.23476;
  int D.23477;
  int D.23478;
  int D.23480;
  int iftmp.124;
  unsigned int D.23486;
  unsigned int D.23488;
  int D.23489;
  unsigned int D.23490;
  unsigned int D.23491;
  unsigned int i.125;
  unsigned int D.23493;
  unsigned int D.23496;
  const unsigned char * D.23497;
  unsigned int D.23498;
  const unsigned char * D.23499;
  unsigned int D.23500;
  const unsigned char * D.23501;
  unsigned int D.23502;
  const unsigned char * D.23503;
  unsigned int D.23504;
  const unsigned char * D.23505;
  short unsigned int D.23507;
  unsigned int D.23508;
  const unsigned char * D.23509;
  short unsigned int D.23510;
  unsigned int D.23511;
  unsigned char D.23512;
  unsigned int D.23513;
  const unsigned char * D.23514;
  short unsigned int D.23515;
  unsigned int D.23516;
  const unsigned char * D.23517;
  unsigned char D.23518;
  unsigned int D.23519;
  unsigned int D.23520;
  struct MonoClass * iftmp.126;
  signed char sect_data_flags.127;
  sizetype D.23534;
  struct MonoExceptionClause * D.23536;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.20560>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.23464 = (int) sect_data_flags;
  is_fat = D.23464 & 64;
  if (is_fat != 0) goto <D.23465>; else goto <D.23466>;
  <D.23465>:
  D.23467 = ptr + 2;
  D.23468 = *D.23467;
  D.23469 = (int) D.23468;
  D.23470 = D.23469 << 16;
  D.23471 = ptr + 1;
  D.23472 = *D.23471;
  D.23473 = (int) D.23472;
  D.23474 = D.23473 << 8;
  D.23475 = D.23470 | D.23474;
  D.23476 = *ptr;
  D.23477 = (int) D.23476;
  D.23478 = D.23475 | D.23477;
  sect_data_len = (guint32) D.23478;
  ptr = ptr + 3;
  goto <D.23479>;
  <D.23466>:
  D.23476 = *ptr;
  sect_data_len = (guint32) D.23476;
  ptr = ptr + 1;
  <D.23479>:
  D.23464 = (int) sect_data_flags;
  D.23480 = D.23464 & 1;
  if (D.23480 != 0) goto <D.23481>; else goto <D.23482>;
  <D.23481>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.23484>; else goto <D.23485>;
    <D.23484>:
    D.23486 = sect_data_len / 24;
    iftmp.124 = (int) D.23486;
    goto <D.23487>;
    <D.23485>:
    D.23488 = sect_data_len / 12;
    iftmp.124 = (int) D.23488;
    <D.23487>:
    *num_clauses = iftmp.124;
    D.23489 = *num_clauses;
    D.23490 = (unsigned int) D.23489;
    D.23491 = D.23490 * 24;
    clauses = monoeg_malloc0 (D.23491);
    i = 0;
    goto <D.20558>;
    <D.20557>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      i.125 = (unsigned int) i;
      D.23493 = i.125 * 24;
      ec = clauses + D.23493;
      if (is_fat != 0) goto <D.23494>; else goto <D.23495>;
      <D.23494>:
      D.23496 = mono_read32 (p);
      ec->flags = D.23496;
      D.23497 = p + 4;
      D.23498 = mono_read32 (D.23497);
      ec->try_offset = D.23498;
      D.23499 = p + 8;
      D.23500 = mono_read32 (D.23499);
      ec->try_len = D.23500;
      D.23501 = p + 12;
      D.23502 = mono_read32 (D.23501);
      ec->handler_offset = D.23502;
      D.23503 = p + 16;
      D.23504 = mono_read32 (D.23503);
      ec->handler_len = D.23504;
      D.23505 = p + 20;
      tof_value = mono_read32 (D.23505);
      p = p + 24;
      goto <D.23506>;
      <D.23495>:
      D.23507 = mono_read16 (p);
      D.23508 = (unsigned int) D.23507;
      ec->flags = D.23508;
      D.23509 = p + 2;
      D.23510 = mono_read16 (D.23509);
      D.23511 = (unsigned int) D.23510;
      ec->try_offset = D.23511;
      D.23497 = p + 4;
      D.23512 = *D.23497;
      D.23513 = (unsigned int) D.23512;
      ec->try_len = D.23513;
      D.23514 = p + 5;
      D.23515 = mono_read16 (D.23514);
      D.23516 = (unsigned int) D.23515;
      ec->handler_offset = D.23516;
      D.23517 = p + 7;
      D.23518 = *D.23517;
      D.23519 = (unsigned int) D.23518;
      ec->handler_len = D.23519;
      D.23499 = p + 8;
      tof_value = mono_read32 (D.23499);
      p = p + 12;
      <D.23506>:
      D.23520 = ec->flags;
      if (D.23520 == 1) goto <D.23521>; else goto <D.23522>;
      <D.23521>:
      ec->data.filter_offset = tof_value;
      goto <D.23523>;
      <D.23522>:
      D.23520 = ec->flags;
      if (D.23520 == 0) goto <D.23524>; else goto <D.23525>;
      <D.23524>:
      if (tof_value != 0) goto <D.23527>; else goto <D.23528>;
      <D.23527>:
      iftmp.126 = mono_class_get (m, tof_value);
      goto <D.23529>;
      <D.23528>:
      iftmp.126 = 0B;
      <D.23529>:
      ec->data.catch_class = iftmp.126;
      goto <D.23530>;
      <D.23525>:
      ec->data.catch_class = 0B;
      <D.23530>:
      <D.23523>:
    }
    i = i + 1;
    <D.20558>:
    D.23489 = *num_clauses;
    if (D.23489 > i) goto <D.20557>; else goto <D.20559>;
    <D.20559>:
  }
  <D.23482>:
  sect_data_flags.127 = (signed char) sect_data_flags;
  if (sect_data_flags.127 < 0) goto <D.23532>; else goto <D.23533>;
  <D.23532>:
  D.23534 = sect_data_len + 4294967292;
  ptr = ptr + D.23534;
  goto <D.23535>;
  <D.23533>:
  D.23536 = clauses;
  return D.23536;
  <D.23535>:
  goto <D.20560>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.23538;
  const unsigned char * D.23539;
  unsigned int D.23540;
  unsigned int D.23541;

  D.23539 = ptr + 3;
  D.23540 = (unsigned int) D.23539;
  D.23541 = D.23540 & 4294967292;
  D.23538 = (const unsigned char *) D.23541;
  return D.23538;
}


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

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


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  unsigned char D.23545;
  unsigned char D.23546;
  struct MonoType * D.23549;
  short unsigned int D.23550;
  int D.23551;
  int i;

  D.23545 = BIT_FIELD_REF <*mh, 8, 72>;
  D.23546 = D.23545 & 128;
  if (D.23546 != 0) goto <D.23547>; else goto <D.23548>;
  <D.23547>:
  i = 0;
  goto <D.20622>;
  <D.20621>:
  D.23549 = mh->locals[i];
  mono_metadata_free_type (D.23549);
  i = i + 1;
  <D.20622>:
  D.23550 = mh->num_locals;
  D.23551 = (int) D.23550;
  if (D.23551 > i) goto <D.20621>; else goto <D.20623>;
  <D.20623>:
  monoeg_g_free (mh);
  <D.23548>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.23554;
  <unnamed-unsigned:15> D.23557;
  unsigned int D.23558;
  const unsigned char * D.23559;

  if (code_size != 0B) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  D.23554 = header->code_size;
  *code_size = D.23554;
  <D.23553>:
  if (max_stack != 0B) goto <D.23555>; else goto <D.23556>;
  <D.23555>:
  D.23557 = header->max_stack;
  D.23558 = (unsigned int) D.23557;
  *max_stack = D.23558;
  <D.23556>:
  D.23559 = header->code;
  return D.23559;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.23563;
  unsigned int D.23564;
  <unnamed-unsigned:1> D.23567;
  int D.23568;
  struct MonoType * * D.23569;

  if (num_locals != 0B) goto <D.23561>; else goto <D.23562>;
  <D.23561>:
  D.23563 = header->num_locals;
  D.23564 = (unsigned int) D.23563;
  *num_locals = D.23564;
  <D.23562>:
  if (init_locals != 0B) goto <D.23565>; else goto <D.23566>;
  <D.23565>:
  D.23567 = header->init_locals;
  D.23568 = (int) D.23567;
  *init_locals = D.23568;
  <D.23566>:
  D.23569 = &header->locals;
  return D.23569;
}


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

  D.23572 = header->num_clauses;
  D.23571 = (int) D.23572;
  return D.23571;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  short unsigned int D.23577;
  short unsigned int D.23578;
  int D.23579;
  void * D.23580;
  struct MonoExceptionClause * D.23583;
  <unnamed-unsigned:15> D.23584;
  unsigned int D.23585;
  unsigned int D.23586;
  struct MonoExceptionClause * D.23587;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.23574>; else goto <D.23576>;
  <D.23576>:
  D.23577 = BIT_FIELD_REF <*header, 16, 80>;
  D.23578 = D.23577 & 32767;
  if (D.23578 == 0) goto <D.23574>; else goto <D.23575>;
  <D.23574>:
  D.23579 = 0;
  return D.23579;
  <D.23575>:
  D.23580 = *iter;
  if (D.23580 == 0B) goto <D.23581>; else goto <D.23582>;
  <D.23581>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.23579 = 1;
  return D.23579;
  <D.23582>:
  sc = *iter;
  sc = sc + 24;
  D.23583 = header->clauses;
  D.23584 = header->num_clauses;
  D.23585 = (unsigned int) D.23584;
  D.23586 = D.23585 * 24;
  D.23587 = D.23583 + D.23586;
  if (D.23587 > sc) goto <D.23588>; else goto <D.23589>;
  <D.23588>:
  *iter = sc;
  *clause = *sc;
  D.23579 = 1;
  return D.23579;
  <D.23589>:
  D.23579 = 0;
  return D.23579;
}


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

  D.23591 = mono_metadata_parse_type (m, 5, field_flags, ptr, rptr);
  return D.23591;
}


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

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


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

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


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.23597;
  uint32_t D.23600;
  int index.128;
  int D.23602;
  unsigned char D.23603;
  unsigned char D.23604;
  int D.23607;
  unsigned int D.23608;
  int D.23609;
  <unnamed-unsigned:24> D.23610;
  unsigned int D.23611;
  unsigned char D.23612;
  unsigned int D.23613;
  void * D.23614;
  unsigned int D.23617;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.23597 = tdef->base;
      if (D.23597 == 0B) goto <D.23598>; else goto <D.23599>;
      <D.23598>:
      D.23600 = 0;
      return D.23600;
      <D.23599>:
      index.128 = (int) index;
      D.23602 = index.128 & 16777215;
      loc.idx = D.23602;
      loc.col_idx = 4;
      loc.t = tdef;
      D.23603 = BIT_FIELD_REF <*meta, 8, 128>;
      D.23604 = D.23603 & 32;
      if (D.23604 != 0) goto <D.23605>; else goto <D.23606>;
      <D.23605>:
      D.23607 = loc.idx;
      D.23608 = search_ptr_table (meta, 3, D.23607);
      D.23609 = (int) D.23608;
      loc.idx = D.23609;
      <D.23606>:
      D.23597 = tdef->base;
      D.23610 = tdef->rows;
      D.23611 = (unsigned int) D.23610;
      D.23612 = tdef->row_size;
      D.23613 = (unsigned int) D.23612;
      D.23614 = mono_binary_search (&loc, D.23597, D.23611, D.23613, typedef_locator);
      if (D.23614 == 0B) goto <D.23615>; else goto <D.23616>;
      <D.23615>:
      D.23600 = 0;
      return D.23600;
      <D.23616>:
      D.23617 = loc.result;
      D.23600 = D.23617 + 1;
      return D.23600;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  int bb.129;
  struct MonoTableInfo * D.23621;
  const char * D.23622;
  int D.23623;
  int D.23624;
  unsigned char D.23625;
  int D.23626;
  int D.23627;
  unsigned int D.23628;
  int D.23629;
  unsigned int D.23630;
  int D.23633;
  int D.23634;
  <unnamed-unsigned:24> D.23635;
  int D.23636;
  unsigned int typedef_index.130;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.129 = (int) bb;
  D.23621 = loc->t;
  D.23622 = D.23621->base;
  D.23623 = (int) D.23622;
  D.23624 = bb.129 - D.23623;
  D.23621 = loc->t;
  D.23625 = D.23621->row_size;
  D.23626 = (int) D.23625;
  typedef_index = D.23624 / D.23626;
  D.23621 = loc->t;
  D.23627 = loc->col_idx;
  D.23628 = (unsigned int) D.23627;
  col = mono_metadata_decode_row_col (D.23621, typedef_index, D.23628);
  D.23629 = loc->idx;
  D.23630 = (unsigned int) D.23629;
  if (D.23630 < col) goto <D.23631>; else goto <D.23632>;
  <D.23631>:
  D.23633 = -1;
  return D.23633;
  <D.23632>:
  D.23634 = typedef_index + 1;
  D.23621 = loc->t;
  D.23635 = D.23621->rows;
  D.23636 = (int) D.23635;
  if (D.23634 < D.23636) goto <D.23637>; else goto <D.23638>;
  <D.23637>:
  D.23621 = loc->t;
  D.23634 = typedef_index + 1;
  D.23627 = loc->col_idx;
  D.23628 = (unsigned int) D.23627;
  col_next = mono_metadata_decode_row_col (D.23621, D.23634, D.23628);
  D.23629 = loc->idx;
  D.23630 = (unsigned int) D.23629;
  if (D.23630 >= col_next) goto <D.23639>; else goto <D.23640>;
  <D.23639>:
  D.23633 = 1;
  return D.23633;
  <D.23640>:
  if (col == col_next) goto <D.23641>; else goto <D.23642>;
  <D.23641>:
  D.23633 = 1;
  return D.23633;
  <D.23642>:
  <D.23638>:
  typedef_index.130 = (unsigned int) typedef_index;
  loc->result = typedef_index.130;
  D.23633 = 0;
  return D.23633;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.23645;
  unsigned int idx.131;
  <unnamed-unsigned:24> D.23648;
  int D.23649;
  guint32 D.23652;
  int D.23653;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.20704>;
  <D.20703>:
  D.23645 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.131 = (unsigned int) idx;
  if (D.23645 == idx.131) goto <D.20702>; else goto <D.23647>;
  <D.23647>:
  i = i + 1;
  <D.20704>:
  D.23648 = ptrdef->rows;
  D.23649 = (int) D.23648;
  if (D.23649 > i) goto <D.20703>; else goto <D.20702>;
  <D.20702>:
  D.23648 = ptrdef->rows;
  D.23649 = (int) D.23648;
  if (D.23649 > i) goto <D.23650>; else goto <D.23651>;
  <D.23650>:
  D.23653 = i + 1;
  D.23652 = (guint32) D.23653;
  return D.23652;
  <D.23651>:
  D.23652 = (guint32) idx;
  return D.23652;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.23655;
  uint32_t D.23658;
  int index.132;
  int D.23660;
  unsigned char D.23661;
  unsigned char D.23662;
  int D.23665;
  unsigned int D.23666;
  int D.23667;
  <unnamed-unsigned:24> D.23668;
  unsigned int D.23669;
  unsigned char D.23670;
  unsigned int D.23671;
  void * D.23672;
  unsigned int D.23675;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.23655 = tdef->base;
      if (D.23655 == 0B) goto <D.23656>; else goto <D.23657>;
      <D.23656>:
      D.23658 = 0;
      return D.23658;
      <D.23657>:
      index.132 = (int) index;
      D.23660 = index.132 & 16777215;
      loc.idx = D.23660;
      loc.col_idx = 5;
      loc.t = tdef;
      D.23661 = BIT_FIELD_REF <*meta, 8, 128>;
      D.23662 = D.23661 & 32;
      if (D.23662 != 0) goto <D.23663>; else goto <D.23664>;
      <D.23663>:
      D.23665 = loc.idx;
      D.23666 = search_ptr_table (meta, 5, D.23665);
      D.23667 = (int) D.23666;
      loc.idx = D.23667;
      <D.23664>:
      D.23655 = tdef->base;
      D.23668 = tdef->rows;
      D.23669 = (unsigned int) D.23668;
      D.23670 = tdef->row_size;
      D.23671 = (unsigned int) D.23670;
      D.23672 = mono_binary_search (&loc, D.23655, D.23669, D.23671, typedef_locator);
      if (D.23672 == 0B) goto <D.23673>; else goto <D.23674>;
      <D.23673>:
      D.23658 = 0;
      return D.23658;
      <D.23674>:
      D.23675 = loc.result;
      D.23658 = D.23675 + 1;
      return D.23658;
    }
  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.23678;
  gboolean D.23681;
  int index.133;
  int D.23683;
  <unnamed-unsigned:24> D.23684;
  unsigned int D.23685;
  unsigned char D.23686;
  unsigned int D.23687;
  void * D.23688;
  int D.23691;
  unsigned int D.23692;
  unsigned int D.23693;
  int D.23694;
  unsigned int D.23695;
  int pos.134;
  unsigned int D.23698;
  unsigned int D.23699;
  unsigned int D.23701;
  unsigned int D.23704;
  unsigned int D.23705;
  unsigned int D.23708;
  unsigned int D.23709;
  unsigned int D.23712;
  struct MonoClass * * D.23713;
  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.23678 = tdef->base;
      if (D.23678 == 0B) goto <D.23679>; else goto <D.23680>;
      <D.23679>:
      D.23681 = 1;
      return D.23681;
      <D.23680>:
      index.133 = (int) index;
      D.23683 = index.133 & 16777215;
      loc.idx = D.23683;
      loc.col_idx = 0;
      loc.t = tdef;
      D.23678 = tdef->base;
      D.23684 = tdef->rows;
      D.23685 = (unsigned int) D.23684;
      D.23686 = tdef->row_size;
      D.23687 = (unsigned int) D.23686;
      D.23688 = mono_binary_search (&loc, D.23678, D.23685, D.23687, table_locator);
      if (D.23688 == 0B) goto <D.23689>; else goto <D.23690>;
      <D.23689>:
      D.23681 = 1;
      return D.23681;
      <D.23690>:
      start = loc.result;
      goto <D.20733>;
      <D.20732>:
      D.23691 = loc.idx;
      D.23692 = (unsigned int) D.23691;
      D.23693 = start + 4294967295;
      D.23694 = (int) D.23693;
      D.23695 = mono_metadata_decode_row_col (tdef, D.23694, 0);
      if (D.23692 == D.23695) goto <D.23696>; else goto <D.20731>;
      <D.23696>:
      start = start + 4294967295;
      <D.20733>:
      if (start != 0) goto <D.20732>; else goto <D.20731>;
      <D.20731>:
      pos = start;
      goto <D.20736>;
      <D.20735>:
      pos.134 = (int) pos;
      mono_metadata_decode_row (tdef, pos.134, &cols, 2);
      D.23698 = cols[0];
      D.23691 = loc.idx;
      D.23699 = (unsigned int) D.23691;
      if (D.23698 != D.23699) goto <D.20734>; else goto <D.23700>;
      <D.23700>:
      pos = pos + 1;
      <D.20736>:
      D.23684 = tdef->rows;
      D.23701 = (unsigned int) D.23684;
      if (D.23701 > pos) goto <D.20735>; else goto <D.20734>;
      <D.20734>:
      if (heap_alloc_result != 0) goto <D.23702>; else goto <D.23703>;
      <D.23702>:
      D.23704 = pos - start;
      D.23705 = D.23704 * 4;
      result = monoeg_malloc0 (D.23705);
      goto <D.23706>;
      <D.23703>:
      D.23704 = pos - start;
      D.23705 = D.23704 * 4;
      result = mono_image_alloc0 (meta, D.23705);
      <D.23706>:
      pos = start;
      goto <D.20740>;
      <D.20739>:
      {
        struct MonoClass * iface;

        pos.134 = (int) pos;
        mono_metadata_decode_row (tdef, pos.134, &cols, 2);
        D.23698 = cols[0];
        D.23691 = loc.idx;
        D.23699 = (unsigned int) D.23691;
        if (D.23698 != D.23699) goto <D.20738>; else goto <D.23707>;
        <D.23707>:
        D.23708 = cols[1];
        D.23709 = mono_metadata_token_from_dor (D.23708);
        iface = mono_class_get_full (meta, D.23709, context);
        if (iface == 0B) goto <D.23710>; else goto <D.23711>;
        <D.23710>:
        D.23681 = 0;
        return D.23681;
        <D.23711>:
        D.23704 = pos - start;
        D.23712 = D.23704 * 4;
        D.23713 = result + D.23712;
        *D.23713 = iface;
        pos = pos + 1;
      }
      <D.20740>:
      D.23684 = tdef->rows;
      D.23701 = (unsigned int) D.23684;
      if (D.23701 > pos) goto <D.20739>; else goto <D.20738>;
      <D.20738>:
      D.23704 = pos - start;
      *count = D.23704;
      *interfaces = result;
      D.23681 = 1;
      return D.23681;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  int bb.135;
  struct MonoTableInfo * D.23717;
  const char * D.23718;
  int D.23719;
  int D.23720;
  unsigned char D.23721;
  int D.23722;
  int D.23723;
  int table_index.136;
  int D.23725;
  unsigned int D.23726;
  int D.23727;
  unsigned int D.23728;
  int D.23731;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.135 = (int) bb;
  D.23717 = loc->t;
  D.23718 = D.23717->base;
  D.23719 = (int) D.23718;
  D.23720 = bb.135 - D.23719;
  D.23717 = loc->t;
  D.23721 = D.23717->row_size;
  D.23722 = (int) D.23721;
  D.23723 = D.23720 / D.23722;
  table_index = (guint32) D.23723;
  D.23717 = loc->t;
  table_index.136 = (int) table_index;
  D.23725 = loc->col_idx;
  D.23726 = (unsigned int) D.23725;
  col = mono_metadata_decode_row_col (D.23717, table_index.136, D.23726);
  D.23727 = loc->idx;
  D.23728 = (unsigned int) D.23727;
  if (D.23728 == col) goto <D.23729>; else goto <D.23730>;
  <D.23729>:
  loc->result = table_index;
  D.23731 = 0;
  return D.23731;
  <D.23730>:
  D.23727 = loc->idx;
  D.23728 = (unsigned int) D.23727;
  if (D.23728 < col) goto <D.23732>; else goto <D.23733>;
  <D.23732>:
  D.23731 = -1;
  return D.23731;
  <D.23733>:
  D.23731 = 1;
  return D.23731;
}


mono_metadata_interfaces_from_typedef (struct MonoImage * meta, guint32 index, guint * count)
{
  struct MonoClass * * D.23737;
  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.23735>; else goto <D.23736>;
      <D.23735>:
      D.23737 = interfaces;
      return D.23737;
      <D.23736>:
      D.23737 = 0B;
      return D.23737;
    }
  finally
    {
      interfaces = {CLOBBER};
    }
}


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.23740;
  uint32_t D.23743;
  int index.137;
  int D.23745;
  <unnamed-unsigned:24> D.23746;
  unsigned int D.23747;
  unsigned char D.23748;
  unsigned int D.23749;
  void * D.23750;
  unsigned int D.23753;
  int D.23754;
  unsigned int D.23755;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.23740 = tdef->base;
      if (D.23740 == 0B) goto <D.23741>; else goto <D.23742>;
      <D.23741>:
      D.23743 = 0;
      return D.23743;
      <D.23742>:
      index.137 = (int) index;
      D.23745 = index.137 & 16777215;
      loc.idx = D.23745;
      loc.col_idx = 0;
      loc.t = tdef;
      D.23740 = tdef->base;
      D.23746 = tdef->rows;
      D.23747 = (unsigned int) D.23746;
      D.23748 = tdef->row_size;
      D.23749 = (unsigned int) D.23748;
      D.23750 = mono_binary_search (&loc, D.23740, D.23747, D.23749, table_locator);
      if (D.23750 == 0B) goto <D.23751>; else goto <D.23752>;
      <D.23751>:
      D.23743 = 0;
      return D.23743;
      <D.23752>:
      D.23753 = loc.result;
      D.23754 = (int) D.23753;
      D.23755 = mono_metadata_decode_row_col (tdef, D.23754, 1);
      D.23743 = D.23755 | 33554432;
      return D.23743;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.23758;
  uint32_t D.23761;
  unsigned int D.23762;
  int D.23763;
  unsigned int D.23764;
  <unnamed-unsigned:24> D.23766;
  unsigned int D.23767;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.23758 = tdef->base;
  if (D.23758 == 0B) goto <D.23759>; else goto <D.23760>;
  <D.23759>:
  D.23761 = 0;
  return D.23761;
  <D.23760>:
  start = start_index;
  goto <D.20764>;
  <D.20763>:
  D.23762 = start + 4294967295;
  D.23763 = (int) D.23762;
  D.23764 = mono_metadata_decode_row_col (tdef, D.23763, 1);
  if (D.23764 == class_index) goto <D.20762>; else goto <D.23765>;
  <D.23765>:
  start = start + 1;
  <D.20764>:
  D.23766 = tdef->rows;
  D.23767 = (unsigned int) D.23766;
  if (D.23767 >= start) goto <D.20763>; else goto <D.20762>;
  <D.20762>:
  D.23766 = tdef->rows;
  D.23767 = (unsigned int) D.23766;
  if (D.23767 < start) goto <D.23768>; else goto <D.23769>;
  <D.23768>:
  D.23761 = 0;
  return D.23761;
  <D.23769>:
  D.23761 = start;
  return D.23761;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.23771;
  uint32_t D.23774;
  int index.138;
  int D.23776;
  <unnamed-unsigned:24> D.23777;
  unsigned int D.23778;
  unsigned char D.23779;
  unsigned int D.23780;
  void * D.23781;
  unsigned int D.23784;
  int D.23785;
  unsigned int D.23788;
  unsigned int D.23791;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.23771 = tdef->base;
      if (D.23771 == 0B) goto <D.23772>; else goto <D.23773>;
      <D.23772>:
      D.23774 = 0;
      return D.23774;
      <D.23773>:
      index.138 = (int) index;
      D.23776 = index.138 & 16777215;
      loc.idx = D.23776;
      loc.col_idx = 2;
      loc.t = tdef;
      D.23771 = tdef->base;
      D.23777 = tdef->rows;
      D.23778 = (unsigned int) D.23777;
      D.23779 = tdef->row_size;
      D.23780 = (unsigned int) D.23779;
      D.23781 = mono_binary_search (&loc, D.23771, D.23778, D.23780, table_locator);
      if (D.23781 == 0B) goto <D.23782>; else goto <D.23783>;
      <D.23782>:
      D.23774 = 0;
      return D.23774;
      <D.23783>:
      D.23784 = loc.result;
      D.23785 = (int) D.23784;
      mono_metadata_decode_row (tdef, D.23785, &cols, 3);
      if (packing != 0B) goto <D.23786>; else goto <D.23787>;
      <D.23786>:
      D.23788 = cols[0];
      *packing = D.23788;
      <D.23787>:
      if (size != 0B) goto <D.23789>; else goto <D.23790>;
      <D.23789>:
      D.23791 = cols[1];
      *size = D.23791;
      <D.23790>:
      D.23784 = loc.result;
      D.23774 = D.23784 + 1;
      return D.23774;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.23794;
  uint32_t D.23797;
  int index.139;
  <unnamed-unsigned:24> D.23799;
  unsigned int D.23800;
  unsigned char D.23801;
  unsigned int D.23802;
  void * D.23803;
  unsigned int D.23806;
  unsigned int D.23807;
  int D.23809;
  unsigned int D.23810;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.23794 = tdef->base;
      if (D.23794 == 0B) goto <D.23795>; else goto <D.23796>;
      <D.23795>:
      D.23797 = 0;
      return D.23797;
      <D.23796>:
      index.139 = (int) index;
      loc.idx = index.139;
      loc.col_idx = 0;
      loc.t = tdef;
      D.23794 = tdef->base;
      D.23799 = tdef->rows;
      D.23800 = (unsigned int) D.23799;
      D.23801 = tdef->row_size;
      D.23802 = (unsigned int) D.23801;
      D.23803 = mono_binary_search (&loc, D.23794, D.23800, D.23802, table_locator);
      if (D.23803 == 0B) goto <D.23804>; else goto <D.23805>;
      <D.23804>:
      D.23797 = 0;
      return D.23797;
      <D.23805>:
      goto <D.20781>;
      <D.20780>:
      D.23806 = loc.result;
      D.23807 = D.23806 + 4294967295;
      loc.result = D.23807;
      <D.20781>:
      D.23806 = loc.result;
      if (D.23806 != 0) goto <D.23808>; else goto <D.20782>;
      <D.23808>:
      D.23806 = loc.result;
      D.23807 = D.23806 + 4294967295;
      D.23809 = (int) D.23807;
      D.23810 = mono_metadata_decode_row_col (tdef, D.23809, 0);
      if (D.23810 == index) goto <D.20780>; else goto <D.20782>;
      <D.20782>:
      D.23806 = loc.result;
      D.23797 = D.23806 + 1;
      return D.23797;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.23813;
  uint32_t D.23816;
  int index.140;
  <unnamed-unsigned:24> D.23818;
  unsigned int D.23819;
  unsigned char D.23820;
  unsigned int D.23821;
  void * D.23822;
  unsigned int D.23825;
  unsigned int D.23826;
  int D.23828;
  unsigned int D.23829;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.23813 = tdef->base;
      if (D.23813 == 0B) goto <D.23814>; else goto <D.23815>;
      <D.23814>:
      D.23816 = 4294967295;
      return D.23816;
      <D.23815>:
      index.140 = (int) index;
      loc.idx = index.140;
      loc.col_idx = 1;
      loc.t = tdef;
      D.23813 = tdef->base;
      D.23818 = tdef->rows;
      D.23819 = (unsigned int) D.23818;
      D.23820 = tdef->row_size;
      D.23821 = (unsigned int) D.23820;
      D.23822 = mono_binary_search (&loc, D.23813, D.23819, D.23821, declsec_locator);
      if (D.23822 == 0B) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23816 = 4294967295;
      return D.23816;
      <D.23824>:
      goto <D.20790>;
      <D.20789>:
      D.23825 = loc.result;
      D.23826 = D.23825 + 4294967295;
      loc.result = D.23826;
      <D.20790>:
      D.23825 = loc.result;
      if (D.23825 != 0) goto <D.23827>; else goto <D.20791>;
      <D.23827>:
      D.23825 = loc.result;
      D.23826 = D.23825 + 4294967295;
      D.23828 = (int) D.23826;
      D.23829 = mono_metadata_decode_row_col (tdef, D.23828, 1);
      if (D.23829 == index) goto <D.20789>; else goto <D.20791>;
      <D.20791>:
      D.23816 = loc.result;
      return D.23816;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  int bb.141;
  struct MonoTableInfo * D.23833;
  const char * D.23834;
  int D.23835;
  int D.23836;
  unsigned char D.23837;
  int D.23838;
  int D.23839;
  int table_index.142;
  int D.23841;
  unsigned int D.23842;
  int D.23843;
  unsigned int D.23844;
  int D.23847;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.141 = (int) bb;
  D.23833 = loc->t;
  D.23834 = D.23833->base;
  D.23835 = (int) D.23834;
  D.23836 = bb.141 - D.23835;
  D.23833 = loc->t;
  D.23837 = D.23833->row_size;
  D.23838 = (int) D.23837;
  D.23839 = D.23836 / D.23838;
  table_index = (guint32) D.23839;
  D.23833 = loc->t;
  table_index.142 = (int) table_index;
  D.23841 = loc->col_idx;
  D.23842 = (unsigned int) D.23841;
  col = mono_metadata_decode_row_col (D.23833, table_index.142, D.23842);
  D.23843 = loc->idx;
  D.23844 = (unsigned int) D.23843;
  if (D.23844 == col) goto <D.23845>; else goto <D.23846>;
  <D.23845>:
  loc->result = table_index;
  D.23847 = 0;
  return D.23847;
  <D.23846>:
  D.23843 = loc->idx;
  D.23844 = (unsigned int) D.23843;
  if (D.23844 < col) goto <D.23848>; else goto <D.23849>;
  <D.23848>:
  D.23847 = -1;
  return D.23847;
  <D.23849>:
  D.23847 = 1;
  return D.23847;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.23853;
  unsigned char D.23854;
  unsigned char D.23855;
  unsigned char D.23858;
  int D.23859;
  struct MonoClass * D.23860;
  unsigned char D.23861;
  unsigned char D.23862;
  struct MonoType * D.23865;
  struct MonoClass * D.23866;
  unsigned char D.23867;
  unsigned char D.23868;
  unsigned char D.23871;
  struct MonoType * D.23874;
  struct MonoClass * D.23875;

  if (t == 0B) goto <D.23851>; else goto <D.23852>;
  <D.23851>:
  *align = 1;
  D.23853 = 0;
  return D.23853;
  <D.23852>:
  D.23854 = BIT_FIELD_REF <*t, 8, 56>;
  D.23855 = D.23854 & 64;
  if (D.23855 != 0) goto <D.23856>; else goto <D.23857>;
  <D.23856>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 4;
    D.23853 = 4;
    return D.23853;
  }
  <D.23857>:
  D.23858 = t->type;
  D.23859 = (int) D.23858;
  switch (D.23859) <default: <D.20867>, case 1: <D.20799>, case 2: <D.20800>, case 3: <D.20809>, case 4: <D.20804>, case 5: <D.20805>, case 6: <D.20810>, case 7: <D.20811>, case 8: <D.20815>, case 9: <D.20816>, case 10: <D.20824>, case 11: <D.20825>, case 12: <D.20820>, case 13: <D.20829>, case 14: <D.20838>, case 15: <D.20849>, case 17: <D.20846>, case 18: <D.20847>, case 19: <D.20862>, case 20: <D.20851>, case 21: <D.20856>, case 22: <D.20855>, case 24: <D.20833>, case 25: <D.20834>, case 27: <D.20850>, case 28: <D.20842>, case 29: <D.20848>, case 30: <D.20863>>
  {
    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.20799>:
    *align = 1;
    D.23853 = 0;
    return D.23853;
    <D.20800>:
    *align = 1;
    D.23853 = 1;
    return D.23853;
    <D.20804>:
    <D.20805>:
    *align = 1;
    D.23853 = 1;
    return D.23853;
    <D.20809>:
    <D.20810>:
    <D.20811>:
    *align = 2;
    D.23853 = 2;
    return D.23853;
    <D.20815>:
    <D.20816>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20820>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20824>:
    <D.20825>:
    *align = 8;
    D.23853 = 8;
    return D.23853;
    <D.20829>:
    *align = 8;
    D.23853 = 8;
    return D.23853;
    <D.20833>:
    <D.20834>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20838>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20842>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20846>:
    D.23860 = t->data.klass;
    D.23861 = BIT_FIELD_REF <*D.23860, 8, 160>;
    D.23862 = D.23861 & 16;
    if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
    <D.23863>:
    D.23860 = t->data.klass;
    D.23865 = mono_class_enum_basetype (D.23860);
    D.23853 = mono_type_size (D.23865, align);
    return D.23853;
    <D.23864>:
    D.23860 = t->data.klass;
    D.23853 = mono_class_value_size (D.23860, align);
    return D.23853;
    <D.20847>:
    <D.20848>:
    <D.20849>:
    <D.20850>:
    <D.20851>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20855>:
    D.23866 = mono_defaults.typed_reference_class;
    D.23853 = mono_class_value_size (D.23866, align);
    return D.23853;
    <D.20856>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.23867 = BIT_FIELD_REF <*container_class, 8, 160>;
      D.23868 = D.23867 & 8;
      if (D.23868 != 0) goto <D.23869>; else goto <D.23870>;
      <D.23869>:
      D.23867 = BIT_FIELD_REF <*container_class, 8, 160>;
      D.23871 = D.23867 & 16;
      if (D.23871 != 0) goto <D.23872>; else goto <D.23873>;
      <D.23872>:
      D.23874 = mono_class_enum_basetype (container_class);
      D.23853 = mono_type_size (D.23874, align);
      return D.23853;
      <D.23873>:
      D.23875 = mono_class_from_mono_type (t);
      D.23853 = mono_class_value_size (D.23875, align);
      return D.23853;
      <D.23870>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 4;
        D.23853 = 4;
        return D.23853;
      }
    }
    <D.20862>:
    <D.20863>:
    *align = 4;
    D.23853 = 4;
    return D.23853;
    <D.20867>:
    D.23858 = t->type;
    D.23859 = (int) D.23858;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.23859);
    <D.20868>:
    goto <D.20868>;
  }
  D.23853 = 0;
  return D.23853;
}


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

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


mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.23879;
  long int D.23880;
  long int D.23881;
  unsigned char D.23886;
  unsigned char D.23887;
  int D.23890;
  unsigned char D.23891;
  int D.23892;
  _Bool D.23893;
  long int D.23894;
  long int D.23895;
  struct MonoClass * D.23898;
  unsigned char D.23899;
  unsigned char D.23900;
  struct MonoType * D.23903;
  int D.23904;
  int D.23905;
  int D.23906;
  int D.23907;
  int D.23908;
  int D.23909;
  unsigned int stack_slot_size.143;
  unsigned int D.23911;
  int D.23912;
  unsigned int D.23913;
  struct MonoGenericInst * D.23916;
  unsigned char D.23917;
  unsigned char D.23918;
  _Bool D.23919;
  long int D.23920;
  long int D.23921;
  unsigned char D.23924;
  unsigned char D.23925;
  unsigned char D.23928;
  struct MonoType * D.23931;
  struct MonoClass * D.23932;
  int D.23933;
  unsigned int D.23934;
  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 = 4;
      stack_slot_align = 4;
      D.23879 = t == 0B;
      D.23880 = (long int) D.23879;
      D.23881 = __builtin_expect (D.23880, 0);
      if (D.23881 != 0) goto <D.23882>; else goto <D.23883>;
      <D.23882>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.23883>:
      if (align == 0B) goto <D.23884>; else goto <D.23885>;
      <D.23884>:
      align = &tmp;
      <D.23885>:
      D.23886 = BIT_FIELD_REF <*t, 8, 56>;
      D.23887 = D.23886 & 64;
      if (D.23887 != 0) goto <D.23888>; else goto <D.23889>;
      <D.23888>:
      *align = stack_slot_align;
      D.23890 = stack_slot_size;
      return D.23890;
      <D.23889>:
      D.23891 = t->type;
      D.23892 = (int) D.23891;
      switch (D.23892) <default: <D.20923>, case 2: <D.20884>, case 3: <D.20885>, case 4: <D.20886>, case 5: <D.20887>, case 6: <D.20888>, case 7: <D.20889>, case 8: <D.20890>, case 9: <D.20891>, case 10: <D.20908>, case 11: <D.20909>, case 12: <D.20904>, case 13: <D.20913>, case 14: <D.20894>, case 15: <D.20898>, case 17: <D.20917>, case 18: <D.20896>, case 19: <D.20901>, case 20: <D.20900>, case 21: <D.20919>, case 22: <D.20903>, case 24: <D.20892>, case 25: <D.20893>, case 27: <D.20899>, case 28: <D.20895>, case 29: <D.20897>, case 30: <D.20902>>
      {
        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.20884>:
        <D.20885>:
        <D.20886>:
        <D.20887>:
        <D.20888>:
        <D.20889>:
        <D.20890>:
        <D.20891>:
        <D.20892>:
        <D.20893>:
        <D.20894>:
        <D.20895>:
        <D.20896>:
        <D.20897>:
        <D.20898>:
        <D.20899>:
        <D.20900>:
        *align = stack_slot_align;
        D.23890 = stack_slot_size;
        return D.23890;
        <D.20901>:
        <D.20902>:
        D.23893 = allow_open == 0;
        D.23894 = (long int) D.23893;
        D.23895 = __builtin_expect (D.23894, 0);
        if (D.23895 != 0) goto <D.23896>; else goto <D.23897>;
        <D.23896>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.23897>:
        *align = stack_slot_align;
        D.23890 = stack_slot_size;
        return D.23890;
        <D.20903>:
        *align = stack_slot_align;
        D.23890 = stack_slot_size * 3;
        return D.23890;
        <D.20904>:
        *align = 4;
        D.23890 = 4;
        return D.23890;
        <D.20908>:
        <D.20909>:
        *align = 8;
        D.23890 = 8;
        return D.23890;
        <D.20913>:
        *align = 8;
        D.23890 = 8;
        return D.23890;
        <D.20917>:
        {
          guint32 size;

          D.23898 = t->data.klass;
          D.23899 = BIT_FIELD_REF <*D.23898, 8, 160>;
          D.23900 = D.23899 & 16;
          if (D.23900 != 0) goto <D.23901>; else goto <D.23902>;
          <D.23901>:
          D.23898 = t->data.klass;
          D.23903 = mono_class_enum_basetype (D.23898);
          D.23890 = mono_type_stack_size_internal (D.23903, align, allow_open);
          return D.23890;
          <D.23902>:
          D.23898 = t->data.klass;
          D.23904 = mono_class_value_size (D.23898, align);
          size = (guint32) D.23904;
          D.23905 = *align;
          D.23906 = D.23905 + stack_slot_align;
          D.23907 = D.23906 + -1;
          *align = D.23907;
          D.23905 = *align;
          D.23908 = -stack_slot_align;
          D.23909 = D.23905 & D.23908;
          *align = D.23909;
          stack_slot_size.143 = (unsigned int) stack_slot_size;
          D.23911 = stack_slot_size.143 + size;
          size = D.23911 + 4294967295;
          D.23912 = -stack_slot_size;
          D.23913 = (unsigned int) D.23912;
          size = D.23913 & size;
          D.23890 = (int) size;
          return D.23890;
        }
        <D.20919>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.23914>; else goto <D.23915>;
          <D.23914>:
          D.23916 = gclass->context.class_inst;
          D.23917 = BIT_FIELD_REF <*D.23916, 8, 48>;
          D.23918 = D.23917 & 64;
          D.23919 = D.23918 != 0;
          D.23920 = (long int) D.23919;
          D.23921 = __builtin_expect (D.23920, 0);
          if (D.23921 != 0) goto <D.23922>; else goto <D.23923>;
          <D.23922>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.23923>:
          <D.23915>:
          D.23924 = BIT_FIELD_REF <*container_class, 8, 160>;
          D.23925 = D.23924 & 8;
          if (D.23925 != 0) goto <D.23926>; else goto <D.23927>;
          <D.23926>:
          D.23924 = BIT_FIELD_REF <*container_class, 8, 160>;
          D.23928 = D.23924 & 16;
          if (D.23928 != 0) goto <D.23929>; else goto <D.23930>;
          <D.23929>:
          D.23931 = mono_class_enum_basetype (container_class);
          D.23890 = mono_type_stack_size_internal (D.23931, align, allow_open);
          return D.23890;
          <D.23930>:
          {
            guint32 size;

            D.23932 = mono_class_from_mono_type (t);
            D.23933 = mono_class_value_size (D.23932, align);
            size = (guint32) D.23933;
            D.23905 = *align;
            D.23906 = D.23905 + stack_slot_align;
            D.23907 = D.23906 + -1;
            *align = D.23907;
            D.23905 = *align;
            D.23908 = -stack_slot_align;
            D.23909 = D.23905 & D.23908;
            *align = D.23909;
            stack_slot_size.143 = (unsigned int) stack_slot_size;
            D.23934 = stack_slot_size.143 + size;
            size = D.23934 + 4294967295;
            D.23912 = -stack_slot_size;
            D.23913 = (unsigned int) D.23912;
            size = D.23913 & size;
            D.23890 = (int) size;
            return D.23890;
          }
          <D.23927>:
          *align = stack_slot_align;
          D.23890 = stack_slot_size;
          return D.23890;
        }
        <D.20923>:
        D.23891 = t->type;
        D.23892 = (int) D.23891;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.23892);
        <D.20924>:
        goto <D.20924>;
      }
      D.23890 = 0;
      return D.23890;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.23937;
  _Bool D.23938;
  long int D.23939;
  long int D.23940;
  mono_bool D.23943;
  struct MonoGenericClass * D.23944;
  struct MonoClass * D.23945;
  <unnamed-unsigned:1> D.23946;

  D.23937 = type->type;
  D.23938 = D.23937 != 21;
  D.23939 = (long int) D.23938;
  D.23940 = __builtin_expect (D.23939, 0);
  if (D.23940 != 0) goto <D.23941>; else goto <D.23942>;
  <D.23941>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.23942>:
  D.23944 = type->data.generic_class;
  D.23945 = D.23944->container_class;
  D.23946 = D.23945->valuetype;
  D.23943 = (mono_bool) D.23946;
  return D.23943;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.23948;
  struct MonoClass * D.23949;
  <unnamed-unsigned:1> D.23950;

  D.23949 = gclass->container_class;
  D.23950 = D.23949->valuetype;
  D.23948 = (mono_bool) D.23950;
  return D.23948;
}


mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.23952;
  unsigned int D.23955;
  unsigned int D.23956;
  unsigned int D.23957;
  struct MonoGenericInst * D.23958;
  unsigned int D.23961;
  guint D.23962;
  guint hash;

  hash = 3223191271;
  D.23952 = context->class_inst;
  if (D.23952 != 0B) goto <D.23953>; else goto <D.23954>;
  <D.23953>:
  D.23955 = hash << 5;
  D.23956 = D.23955 - hash;
  D.23952 = context->class_inst;
  D.23957 = mono_metadata_generic_inst_hash (D.23952);
  hash = D.23956 ^ D.23957;
  <D.23954>:
  D.23958 = context->method_inst;
  if (D.23958 != 0B) goto <D.23959>; else goto <D.23960>;
  <D.23959>:
  D.23955 = hash << 5;
  D.23956 = D.23955 - hash;
  D.23958 = context->method_inst;
  D.23961 = mono_metadata_generic_inst_hash (D.23958);
  hash = D.23956 ^ D.23961;
  <D.23960>:
  D.23962 = hash;
  return D.23962;
}


mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.23964;
  int iftmp.144;
  struct MonoGenericInst * D.23968;
  struct MonoGenericInst * D.23969;
  struct MonoGenericInst * D.23971;
  struct MonoGenericInst * D.23972;

  D.23968 = g1->class_inst;
  D.23969 = g2->class_inst;
  if (D.23968 == D.23969) goto <D.23970>; else goto <D.23966>;
  <D.23970>:
  D.23971 = g1->method_inst;
  D.23972 = g2->method_inst;
  if (D.23971 == D.23972) goto <D.23973>; else goto <D.23966>;
  <D.23973>:
  iftmp.144 = 1;
  goto <D.23967>;
  <D.23966>:
  iftmp.144 = 0;
  <D.23967>:
  D.23964 = iftmp.144;
  return D.23964;
}


mono_metadata_str_hash (const void * v1)
{
  char D.23975;
  unsigned int D.23978;
  unsigned int D.23979;
  unsigned int D.23980;
  char * p.145;
  char D.23982;
  guint D.23983;
  char * p;
  guint hash;

  p = v1;
  D.23975 = *p;
  hash = (guint) D.23975;
  goto <D.20959>;
  <D.20958>:
  D.23975 = *p;
  if (D.23975 != 0) goto <D.23976>; else goto <D.23977>;
  <D.23976>:
  D.23978 = hash << 5;
  D.23979 = D.23978 - hash;
  D.23975 = *p;
  D.23980 = (unsigned int) D.23975;
  hash = D.23979 + D.23980;
  <D.23977>:
  <D.20959>:
  p.145 = p;
  p = p.145 + 1;
  D.23982 = *p.145;
  if (D.23982 != 0) goto <D.20958>; else goto <D.20960>;
  <D.20960>:
  D.23983 = hash;
  return D.23983;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.23985;
  <unnamed-unsigned:1> D.23986;
  int D.23987;
  int D.23988;
  unsigned int D.23989;
  int D.23990;
  struct MonoImage * D.23991;
  unsigned char D.23992;
  unsigned char D.23993;
  unsigned int D.23996;
  const char * D.23997;
  unsigned int D.23998;
  unsigned int D.23999;
  unsigned int D.24000;
  unsigned int D.24001;
  struct MonoType * D.24002;
  unsigned int D.24003;
  struct MonoArrayType * D.24004;
  struct MonoClass * D.24005;
  struct MonoType * D.24006;
  unsigned int D.24007;
  struct MonoGenericClass * D.24008;
  unsigned int D.24009;
  guint hash;

  D.23985 = t1->type;
  hash = (guint) D.23985;
  D.23986 = t1->byref;
  D.23987 = (int) D.23986;
  D.23988 = D.23987 << 6;
  D.23989 = (unsigned int) D.23988;
  hash = D.23989 | hash;
  D.23985 = t1->type;
  D.23990 = (int) D.23985;
  switch (D.23990) <default: <D.24010>, case 15: <D.20969>, case 17: <D.20965>, case 18: <D.20966>, case 20: <D.20970>, case 21: <D.20971>, case 29: <D.20967>>
  <D.20965>:
  <D.20966>:
  <D.20967>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.23991 = class->image;
    D.23992 = BIT_FIELD_REF <*D.23991, 8, 128>;
    D.23993 = D.23992 & 8;
    if (D.23993 != 0) goto <D.23994>; else goto <D.23995>;
    <D.23994>:
    D.23986 = t1->byref;
    D.23987 = (int) D.23986;
    D.23988 = D.23987 << 6;
    D.23989 = (unsigned int) D.23988;
    D.23997 = class->name;
    D.23998 = mono_metadata_str_hash (D.23997);
    D.23996 = D.23989 | D.23998;
    return D.23996;
    <D.23995>:
    D.23999 = hash << 5;
    D.24000 = D.23999 - hash;
    D.23997 = class->name;
    D.24001 = mono_metadata_str_hash (D.23997);
    D.23996 = D.24000 ^ D.24001;
    return D.23996;
  }
  <D.20969>:
  D.23999 = hash << 5;
  D.24000 = D.23999 - hash;
  D.24002 = t1->data.type;
  D.24003 = mono_metadata_type_hash (D.24002);
  D.23996 = D.24000 ^ D.24003;
  return D.23996;
  <D.20970>:
  D.23999 = hash << 5;
  D.24000 = D.23999 - hash;
  D.24004 = t1->data.array;
  D.24005 = D.24004->eklass;
  D.24006 = &D.24005->byval_arg;
  D.24007 = mono_metadata_type_hash (D.24006);
  D.23996 = D.24000 ^ D.24007;
  return D.23996;
  <D.20971>:
  D.23999 = hash << 5;
  D.24000 = D.23999 - hash;
  D.24008 = t1->data.generic_class;
  D.24009 = mono_generic_class_hash (D.24008);
  D.23996 = D.24000 ^ D.24009;
  return D.23996;
  <D.24010>:
  D.23996 = hash;
  return D.23996;
}


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

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


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

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


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  unsigned char D.24018;
  unsigned char D.24019;
  unsigned char D.24020;
  unsigned char D.24021;
  short unsigned int D.24023;
  short unsigned int D.24024;
  mono_bool D.24025;
  short unsigned int D.24026;
  short unsigned int D.24027;
  int D.24030;
  int D.24033;
  struct MonoType * D.24034;
  struct MonoType * D.24035;
  int D.24036;
  int i;

  D.24018 = BIT_FIELD_REF <*sig1, 8, 80>;
  D.24019 = BIT_FIELD_REF <*sig2, 8, 80>;
  D.24020 = D.24018 ^ D.24019;
  D.24021 = D.24020 & 64;
  if (D.24021 != 0) goto <D.24016>; else goto <D.24022>;
  <D.24022>:
  D.24023 = sig1->param_count;
  D.24024 = sig2->param_count;
  if (D.24023 != D.24024) goto <D.24016>; else goto <D.24017>;
  <D.24016>:
  D.24025 = 0;
  return D.24025;
  <D.24017>:
  D.24026 = sig1->generic_param_count;
  D.24027 = sig2->generic_param_count;
  if (D.24026 != D.24027) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  D.24025 = 0;
  return D.24025;
  <D.24029>:
  i = 0;
  goto <D.21043>;
  <D.21042>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.24030 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.24030 == 0) goto <D.24031>; else goto <D.24032>;
    <D.24031>:
    D.24025 = 0;
    return D.24025;
    <D.24032>:
  }
  i = i + 1;
  <D.21043>:
  D.24023 = sig1->param_count;
  D.24033 = (int) D.24023;
  if (D.24033 > i) goto <D.21042>; else goto <D.21044>;
  <D.21044>:
  D.24034 = sig1->ret;
  D.24035 = sig2->ret;
  D.24036 = do_mono_metadata_type_equal (D.24034, D.24035, 1);
  if (D.24036 == 0) goto <D.24037>; else goto <D.24038>;
  <D.24037>:
  D.24025 = 0;
  return D.24025;
  <D.24038>:
  D.24025 = 1;
  return D.24025;
}


mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  unsigned char D.24040;
  unsigned char D.24041;
  <unnamed-unsigned:6> D.24044;
  unsigned int D.24045;
  unsigned int D.24046;
  unsigned int sizeof_o.146;
  unsigned int D.24048;
  void * iftmp.147;
  unsigned int sizeof_o.148;
  unsigned int sizeof_o.149;
  unsigned int sizeof_o.150;
  unsigned char D.24056;
  struct MonoType * D.24059;
  struct MonoType * D.24060;
  struct MonoArrayType * D.24064;
  struct MonoArrayType * D.24065;
  struct MonoMethodSignature * D.24069;
  struct MonoMethodSignature * D.24070;
  struct MonoType * D.24071;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 8;
  D.24040 = BIT_FIELD_REF <*o, 8, 56>;
  D.24041 = D.24040 & 63;
  if (D.24041 != 0) goto <D.24042>; else goto <D.24043>;
  <D.24042>:
  D.24044 = o->num_mods;
  D.24045 = (unsigned int) D.24044;
  D.24046 = D.24045 * 4;
  sizeof_o.146 = (unsigned int) sizeof_o;
  D.24048 = D.24046 + sizeof_o.146;
  sizeof_o = (int) D.24048;
  <D.24043>:
  if (image != 0B) goto <D.24050>; else goto <D.24051>;
  <D.24050>:
  sizeof_o.148 = (unsigned int) sizeof_o;
  iftmp.147 = mono_image_alloc0 (image, sizeof_o.148);
  goto <D.24053>;
  <D.24051>:
  sizeof_o.149 = (unsigned int) sizeof_o;
  iftmp.147 = monoeg_malloc (sizeof_o.149);
  <D.24053>:
  r = iftmp.147;
  sizeof_o.150 = (unsigned int) sizeof_o;
  memcpy (r, o, sizeof_o.150);
  D.24056 = o->type;
  if (D.24056 == 15) goto <D.24057>; else goto <D.24058>;
  <D.24057>:
  D.24059 = o->data.type;
  D.24060 = mono_metadata_type_dup (image, D.24059);
  r->data.type = D.24060;
  goto <D.24061>;
  <D.24058>:
  D.24056 = o->type;
  if (D.24056 == 20) goto <D.24062>; else goto <D.24063>;
  <D.24062>:
  D.24064 = o->data.array;
  D.24065 = mono_dup_array_type (image, D.24064);
  r->data.array = D.24065;
  goto <D.24066>;
  <D.24063>:
  D.24056 = o->type;
  if (D.24056 == 27) goto <D.24067>; else goto <D.24068>;
  <D.24067>:
  D.24069 = o->data.method;
  D.24070 = mono_metadata_signature_deep_dup (image, D.24069);
  r->data.method = D.24070;
  <D.24068>:
  <D.24066>:
  <D.24061>:
  D.24071 = r;
  return D.24071;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.24073;
  unsigned char D.24074;
  unsigned int D.24075;
  unsigned int D.24076;
  struct MonoType * D.24077;
  unsigned int D.24078;
  short unsigned int D.24079;
  unsigned int D.24080;
  unsigned int D.24081;
  guint i;
  guint res;

  D.24073 = sig->ret;
  D.24074 = D.24073->type;
  res = (guint) D.24074;
  i = 0;
  goto <D.21057>;
  <D.21056>:
  D.24075 = res << 5;
  D.24076 = D.24075 - res;
  D.24077 = sig->params[i];
  D.24078 = mono_type_hash (D.24077);
  res = D.24076 + D.24078;
  i = i + 1;
  <D.21057>:
  D.24079 = sig->param_count;
  D.24080 = (unsigned int) D.24079;
  if (D.24080 > i) goto <D.21056>; else goto <D.21058>;
  <D.21058>:
  D.24081 = res;
  return D.24081;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.151;
  char D.24086;
  unsigned int D.24090;
  char D.24091;
  char D.24092;
  char * D.24093;
  unsigned int D.24095;
  char D.24096;
  char D.24097;
  unsigned int D.24098;
  char D.24099;
  char * D.24100;
  char * D.24101;
  char * p;

  p = buf;
  if (value <= 127) goto <D.24083>; else goto <D.24084>;
  <D.24083>:
  p.151 = p;
  p = p.151 + 1;
  D.24086 = (char) value;
  *p.151 = D.24086;
  goto <D.24087>;
  <D.24084>:
  if (value <= 16383) goto <D.24088>; else goto <D.24089>;
  <D.24088>:
  D.24090 = value >> 8;
  D.24091 = (char) D.24090;
  D.24092 = D.24091 | 128;
  *p = D.24092;
  D.24093 = p + 1;
  D.24086 = (char) value;
  *D.24093 = D.24086;
  p = p + 2;
  goto <D.24094>;
  <D.24089>:
  D.24095 = value >> 24;
  D.24096 = (char) D.24095;
  D.24097 = D.24096 | 192;
  *p = D.24097;
  D.24093 = p + 1;
  D.24098 = value >> 16;
  D.24099 = (char) D.24098;
  *D.24093 = D.24099;
  D.24100 = p + 2;
  D.24090 = value >> 8;
  D.24091 = (char) D.24090;
  *D.24100 = D.24091;
  D.24101 = p + 3;
  D.24086 = (char) value;
  *D.24101 = D.24086;
  p = p + 4;
  <D.24094>:
  <D.24087>:
  if (endbuf != 0B) goto <D.24102>; else goto <D.24103>;
  <D.24102>:
  *endbuf = p;
  <D.24103>:
}


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.24104;
  int D.24105;
  unsigned char D.24106;
  unsigned char D.24107;
  int D.24110;
  unsigned int D.24111;
  int D.24112;
  const char * D.24117;
  <unnamed-unsigned:24> D.24119;
  unsigned int D.24120;
  unsigned char D.24121;
  unsigned int D.24122;
  void * D.24123;
  unsigned int D.24125;
  int D.24126;
  unsigned int D.24127;
  void * D.24133;
  unsigned int D.24135;
  struct MonoImage * iftmp.152;
  struct MonoMarshalSpec * D.24144;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.24104 = index + 1;
      D.24105 = (int) D.24104;
      loc.idx = D.24105;
      D.24106 = BIT_FIELD_REF <*meta, 8, 128>;
      D.24107 = D.24106 & 32;
      if (D.24107 != 0) goto <D.24108>; else goto <D.24109>;
      <D.24108>:
      D.24110 = loc.idx;
      D.24111 = search_ptr_table (meta, 3, D.24110);
      D.24112 = (int) D.24111;
      loc.idx = D.24112;
      <D.24109>:
      if (offset != 0B) goto <D.24113>; else goto <D.24114>;
      <D.24113>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.24117 = tdef->base;
      if (D.24117 != 0B) goto <D.24118>; else goto <D.24115>;
      <D.24118>:
      D.24117 = tdef->base;
      D.24119 = tdef->rows;
      D.24120 = (unsigned int) D.24119;
      D.24121 = tdef->row_size;
      D.24122 = (unsigned int) D.24121;
      D.24123 = mono_binary_search (&loc, D.24117, D.24120, D.24122, table_locator);
      if (D.24123 != 0B) goto <D.24124>; else goto <D.24115>;
      <D.24124>:
      D.24125 = loc.result;
      D.24126 = (int) D.24125;
      D.24127 = mono_metadata_decode_row_col (tdef, D.24126, 0);
      *offset = D.24127;
      goto <D.24116>;
      <D.24115>:
      *offset = 4294967295;
      <D.24116>:
      <D.24114>:
      if (rva != 0B) goto <D.24128>; else goto <D.24129>;
      <D.24128>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.24117 = tdef->base;
      if (D.24117 != 0B) goto <D.24132>; else goto <D.24130>;
      <D.24132>:
      D.24117 = tdef->base;
      D.24119 = tdef->rows;
      D.24120 = (unsigned int) D.24119;
      D.24121 = tdef->row_size;
      D.24122 = (unsigned int) D.24121;
      D.24133 = mono_binary_search (&loc, D.24117, D.24120, D.24122, table_locator);
      if (D.24133 != 0B) goto <D.24134>; else goto <D.24130>;
      <D.24134>:
      D.24125 = loc.result;
      D.24126 = (int) D.24125;
      D.24135 = mono_metadata_decode_row_col (tdef, D.24126, 0);
      *rva = D.24135;
      goto <D.24131>;
      <D.24130>:
      *rva = 0;
      <D.24131>:
      <D.24129>:
      if (marshal_spec != 0B) goto <D.24136>; else goto <D.24137>;
      <D.24136>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.24138>; else goto <D.24139>;
        <D.24138>:
        if (alloc_from_image != 0) goto <D.24141>; else goto <D.24142>;
        <D.24141>:
        iftmp.152 = meta;
        goto <D.24143>;
        <D.24142>:
        iftmp.152 = 0B;
        <D.24143>:
        D.24144 = mono_metadata_parse_marshal_spec_full (iftmp.152, p);
        *marshal_spec = D.24144;
        <D.24139>:
      }
      <D.24137>:
    }
  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.24145;
  uint32_t D.24146;
  int index.153;
  <unnamed-unsigned:24> D.24150;
  unsigned int D.24151;
  unsigned int D.24154;
  int D.24155;
  unsigned int D.24156;
  const char * D.24159;
  unsigned int D.24162;
  unsigned char D.24163;
  unsigned int D.24164;
  void * D.24165;
  unsigned int D.24168;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.24145 = token >> 24;
      switch (D.24145) <default: <D.21102>, case 4: <D.21098>, case 8: <D.21100>, case 23: <D.21101>>
      <D.21098>:
      index = index;
      goto <D.21099>;
      <D.21100>:
      index = index | 1;
      goto <D.21099>;
      <D.21101>:
      index = index | 2;
      goto <D.21099>;
      <D.21102>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.24146 = 0;
      return D.24146;
      <D.21099>:
      index.153 = (int) index;
      loc.idx = index.153;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.24148>; else goto <D.24149>;
      <D.24148>:
      D.24150 = tdef->rows;
      D.24151 = (unsigned int) D.24150;
      if (D.24151 > hint) goto <D.24152>; else goto <D.24153>;
      <D.24152>:
      D.24154 = hint + 4294967295;
      D.24155 = (int) D.24154;
      D.24156 = mono_metadata_decode_row_col (tdef, D.24155, 2);
      if (D.24156 == index) goto <D.24157>; else goto <D.24158>;
      <D.24157>:
      D.24146 = hint;
      return D.24146;
      <D.24158>:
      <D.24153>:
      <D.24149>:
      D.24159 = tdef->base;
      if (D.24159 != 0B) goto <D.24160>; else goto <D.24161>;
      <D.24160>:
      D.24159 = tdef->base;
      D.24150 = tdef->rows;
      D.24162 = (unsigned int) D.24150;
      D.24163 = tdef->row_size;
      D.24164 = (unsigned int) D.24163;
      D.24165 = mono_binary_search (&loc, D.24159, D.24162, D.24164, table_locator);
      if (D.24165 != 0B) goto <D.24166>; else goto <D.24167>;
      <D.24166>:
      D.24168 = loc.result;
      D.24146 = D.24168 + 1;
      return D.24146;
      <D.24167>:
      <D.24161>:
      D.24146 = 0;
      return D.24146;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.24171;
  uint32_t D.24174;
  unsigned int D.24175;
  int D.24176;
  <unnamed-unsigned:24> D.24177;
  unsigned int D.24178;
  unsigned char D.24179;
  unsigned int D.24180;
  void * D.24181;
  unsigned int D.24184;
  int D.24185;
  unsigned int D.24186;
  unsigned int D.24187;
  int D.24190;
  unsigned int D.24191;
  <unnamed-unsigned:24> D.24193;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.24171 = tdef->base;
      if (D.24171 == 0B) goto <D.24172>; else goto <D.24173>;
      <D.24172>:
      D.24174 = 0;
      return D.24174;
      <D.24173>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.24175 = index + 1;
      D.24176 = (int) D.24175;
      loc.idx = D.24176;
      D.24171 = tdef->base;
      D.24177 = tdef->rows;
      D.24178 = (unsigned int) D.24177;
      D.24179 = tdef->row_size;
      D.24180 = (unsigned int) D.24179;
      D.24181 = mono_binary_search (&loc, D.24171, D.24178, D.24180, table_locator);
      if (D.24181 == 0B) goto <D.24182>; else goto <D.24183>;
      <D.24182>:
      D.24174 = 0;
      return D.24174;
      <D.24183>:
      D.24184 = loc.result;
      D.24185 = (int) D.24184;
      start = mono_metadata_decode_row_col (tdef, D.24185, 1);
      D.24184 = loc.result;
      D.24186 = D.24184 + 1;
      D.24177 = tdef->rows;
      D.24187 = (unsigned int) D.24177;
      if (D.24186 < D.24187) goto <D.24188>; else goto <D.24189>;
      <D.24188>:
      D.24184 = loc.result;
      D.24186 = D.24184 + 1;
      D.24190 = (int) D.24186;
      D.24191 = mono_metadata_decode_row_col (tdef, D.24190, 1);
      end = D.24191 + 4294967295;
      goto <D.24192>;
      <D.24189>:
      D.24193 = meta->tables[20].rows;
      end = (guint32) D.24193;
      <D.24192>:
      *end_idx = end;
      D.24174 = start + 4294967295;
      return D.24174;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.24196;
  uint32_t D.24199;
  unsigned char D.24200;
  unsigned char D.24201;
  unsigned int D.24204;
  int D.24205;
  unsigned int D.24206;
  unsigned int D.24207;
  int D.24208;
  <unnamed-unsigned:24> D.24209;
  unsigned int D.24210;
  unsigned char D.24211;
  unsigned int D.24212;
  void * D.24213;
  int D.24216;
  unsigned int D.24217;
  unsigned int D.24218;
  int D.24219;
  unsigned int D.24220;
  int end.154;
  unsigned int D.24223;
  unsigned int D.24224;
  unsigned int D.24226;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.24196 = msemt->base;
      if (D.24196 == 0B) goto <D.24197>; else goto <D.24198>;
      <D.24197>:
      D.24199 = 0;
      return D.24199;
      <D.24198>:
      D.24200 = BIT_FIELD_REF <*meta, 8, 128>;
      D.24201 = D.24200 & 32;
      if (D.24201 != 0) goto <D.24202>; else goto <D.24203>;
      <D.24202>:
      D.24204 = index + 1;
      D.24205 = (int) D.24204;
      D.24206 = search_ptr_table (meta, 19, D.24205);
      index = D.24206 + 4294967295;
      <D.24203>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.24204 = index + 1;
      D.24207 = D.24204 << 1;
      D.24208 = (int) D.24207;
      loc.idx = D.24208;
      D.24196 = msemt->base;
      D.24209 = msemt->rows;
      D.24210 = (unsigned int) D.24209;
      D.24211 = msemt->row_size;
      D.24212 = (unsigned int) D.24211;
      D.24213 = mono_binary_search (&loc, D.24196, D.24210, D.24212, table_locator);
      if (D.24213 == 0B) goto <D.24214>; else goto <D.24215>;
      <D.24214>:
      D.24199 = 0;
      return D.24199;
      <D.24215>:
      start = loc.result;
      goto <D.21124>;
      <D.21123>:
      D.24216 = loc.idx;
      D.24217 = (unsigned int) D.24216;
      D.24218 = start + 4294967295;
      D.24219 = (int) D.24218;
      D.24220 = mono_metadata_decode_row_col (msemt, D.24219, 2);
      if (D.24217 == D.24220) goto <D.24221>; else goto <D.21122>;
      <D.24221>:
      start = start + 4294967295;
      <D.21124>:
      if (start != 0) goto <D.21123>; else goto <D.21122>;
      <D.21122>:
      end = start + 1;
      goto <D.21127>;
      <D.21126>:
      end.154 = (int) end;
      mono_metadata_decode_row (msemt, end.154, &cols, 3);
      D.24223 = cols[2];
      D.24216 = loc.idx;
      D.24224 = (unsigned int) D.24216;
      if (D.24223 != D.24224) goto <D.21125>; else goto <D.24225>;
      <D.24225>:
      end = end + 1;
      <D.21127>:
      D.24209 = msemt->rows;
      D.24226 = (unsigned int) D.24209;
      if (D.24226 > end) goto <D.21126>; else goto <D.21125>;
      <D.21125>:
      *end_idx = end;
      D.24199 = start;
      return D.24199;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.24229;
  uint32_t D.24232;
  unsigned int D.24233;
  int D.24234;
  <unnamed-unsigned:24> D.24235;
  unsigned int D.24236;
  unsigned char D.24237;
  unsigned int D.24238;
  void * D.24239;
  unsigned int D.24242;
  int D.24243;
  unsigned int D.24244;
  unsigned int D.24245;
  int D.24248;
  unsigned int D.24249;
  <unnamed-unsigned:24> D.24251;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[21];
      *end_idx = 0;
      D.24229 = tdef->base;
      if (D.24229 == 0B) goto <D.24230>; else goto <D.24231>;
      <D.24230>:
      D.24232 = 0;
      return D.24232;
      <D.24231>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.24233 = index + 1;
      D.24234 = (int) D.24233;
      loc.idx = D.24234;
      D.24229 = tdef->base;
      D.24235 = tdef->rows;
      D.24236 = (unsigned int) D.24235;
      D.24237 = tdef->row_size;
      D.24238 = (unsigned int) D.24237;
      D.24239 = mono_binary_search (&loc, D.24229, D.24236, D.24238, table_locator);
      if (D.24239 == 0B) goto <D.24240>; else goto <D.24241>;
      <D.24240>:
      D.24232 = 0;
      return D.24232;
      <D.24241>:
      D.24242 = loc.result;
      D.24243 = (int) D.24242;
      start = mono_metadata_decode_row_col (tdef, D.24243, 1);
      D.24242 = loc.result;
      D.24244 = D.24242 + 1;
      D.24235 = tdef->rows;
      D.24245 = (unsigned int) D.24235;
      if (D.24244 < D.24245) goto <D.24246>; else goto <D.24247>;
      <D.24246>:
      D.24242 = loc.result;
      D.24244 = D.24242 + 1;
      D.24248 = (int) D.24244;
      D.24249 = mono_metadata_decode_row_col (tdef, D.24248, 1);
      end = D.24249 + 4294967295;
      goto <D.24250>;
      <D.24247>:
      D.24251 = meta->tables[23].rows;
      end = (guint32) D.24251;
      <D.24250>:
      *end_idx = end;
      D.24232 = start + 4294967295;
      return D.24232;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.24254;
  uint32_t D.24257;
  unsigned char D.24258;
  unsigned char D.24259;
  unsigned int D.24262;
  int D.24263;
  unsigned int D.24264;
  unsigned int D.24265;
  unsigned int D.24266;
  int D.24267;
  <unnamed-unsigned:24> D.24268;
  unsigned int D.24269;
  unsigned char D.24270;
  unsigned int D.24271;
  void * D.24272;
  int D.24275;
  unsigned int D.24276;
  unsigned int D.24277;
  int D.24278;
  unsigned int D.24279;
  int end.155;
  unsigned int D.24282;
  unsigned int D.24283;
  unsigned int D.24285;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.24254 = msemt->base;
      if (D.24254 == 0B) goto <D.24255>; else goto <D.24256>;
      <D.24255>:
      D.24257 = 0;
      return D.24257;
      <D.24256>:
      D.24258 = BIT_FIELD_REF <*meta, 8, 128>;
      D.24259 = D.24258 & 32;
      if (D.24259 != 0) goto <D.24260>; else goto <D.24261>;
      <D.24260>:
      D.24262 = index + 1;
      D.24263 = (int) D.24262;
      D.24264 = search_ptr_table (meta, 22, D.24263);
      index = D.24264 + 4294967295;
      <D.24261>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.24262 = index + 1;
      D.24265 = D.24262 << 1;
      D.24266 = D.24265 | 1;
      D.24267 = (int) D.24266;
      loc.idx = D.24267;
      D.24254 = msemt->base;
      D.24268 = msemt->rows;
      D.24269 = (unsigned int) D.24268;
      D.24270 = msemt->row_size;
      D.24271 = (unsigned int) D.24270;
      D.24272 = mono_binary_search (&loc, D.24254, D.24269, D.24271, table_locator);
      if (D.24272 == 0B) goto <D.24273>; else goto <D.24274>;
      <D.24273>:
      D.24257 = 0;
      return D.24257;
      <D.24274>:
      start = loc.result;
      goto <D.21149>;
      <D.21148>:
      D.24275 = loc.idx;
      D.24276 = (unsigned int) D.24275;
      D.24277 = start + 4294967295;
      D.24278 = (int) D.24277;
      D.24279 = mono_metadata_decode_row_col (msemt, D.24278, 2);
      if (D.24276 == D.24279) goto <D.24280>; else goto <D.21147>;
      <D.24280>:
      start = start + 4294967295;
      <D.21149>:
      if (start != 0) goto <D.21148>; else goto <D.21147>;
      <D.21147>:
      end = start + 1;
      goto <D.21152>;
      <D.21151>:
      end.155 = (int) end;
      mono_metadata_decode_row (msemt, end.155, &cols, 3);
      D.24282 = cols[2];
      D.24275 = loc.idx;
      D.24283 = (unsigned int) D.24275;
      if (D.24282 != D.24283) goto <D.21150>; else goto <D.24284>;
      <D.24284>:
      end = end + 1;
      <D.21152>:
      D.24268 = msemt->rows;
      D.24285 = (unsigned int) D.24268;
      if (D.24285 > end) goto <D.21151>; else goto <D.21150>;
      <D.21150>:
      *end_idx = end;
      D.24257 = start;
      return D.24257;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.24288;
  uint32_t D.24291;
  unsigned int D.24292;
  unsigned int D.24293;
  unsigned int D.24294;
  int D.24295;
  <unnamed-unsigned:24> D.24296;
  unsigned int D.24297;
  unsigned char D.24298;
  unsigned int D.24299;
  void * D.24300;
  unsigned int D.24303;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.24288 = tdef->base;
      if (D.24288 == 0B) goto <D.24289>; else goto <D.24290>;
      <D.24289>:
      D.24291 = 0;
      return D.24291;
      <D.24290>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.24292 = method_idx + 1;
      D.24293 = D.24292 << 1;
      D.24294 = D.24293 | 1;
      D.24295 = (int) D.24294;
      loc.idx = D.24295;
      D.24288 = tdef->base;
      D.24296 = tdef->rows;
      D.24297 = (unsigned int) D.24296;
      D.24298 = tdef->row_size;
      D.24299 = (unsigned int) D.24298;
      D.24300 = mono_binary_search (&loc, D.24288, D.24297, D.24299, table_locator);
      if (D.24300 == 0B) goto <D.24301>; else goto <D.24302>;
      <D.24301>:
      D.24291 = 0;
      return D.24291;
      <D.24302>:
      D.24303 = loc.result;
      D.24291 = D.24303 + 1;
      return D.24291;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  struct GHashTable * D.24306;
  const void * type_spec.156;
  struct MonoType * D.24310;
  unsigned int D.24311;
  int D.24312;
  unsigned int D.24313;
  const char * ptr.157;
  int D.24315;
  const char * ptr.158;
  void * type_spec.159;
  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.24306 = image->typespec_cache;
      type_spec.156 = (const void *) type_spec;
      type = monoeg_g_hash_table_lookup (D.24306, type_spec.156);
      if (type != 0B) goto <D.24308>; else goto <D.24309>;
      <D.24308>:
      mono_loader_unlock ();
      D.24310 = type;
      return D.24310;
      <D.24309>:
      t = &image->tables[27];
      D.24311 = idx + 4294967295;
      D.24312 = (int) D.24311;
      mono_metadata_decode_row (t, D.24312, &cols, 1);
      D.24313 = cols[0];
      ptr.157 = mono_metadata_blob_heap (image, D.24313);
      ptr = ptr.157;
      D.24313 = cols[0];
      D.24315 = mono_verifier_verify_typespec_signature (image, D.24313, type_spec, 0B);
      if (D.24315 == 0) goto <D.24316>; else goto <D.24317>;
      <D.24316>:
      mono_loader_unlock ();
      D.24310 = 0B;
      return D.24310;
      <D.24317>:
      ptr.158 = ptr;
      len = mono_metadata_decode_value (ptr.158, &ptr);
      ptr.158 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.158, &ptr);
      if (type == 0B) goto <D.24319>; else goto <D.24320>;
      <D.24319>:
      mono_loader_unlock ();
      D.24310 = 0B;
      return D.24310;
      <D.24320>:
      D.24306 = image->typespec_cache;
      type_spec.156 = (const void *) type_spec;
      type2 = monoeg_g_hash_table_lookup (D.24306, type_spec.156);
      if (type2 != 0B) goto <D.24321>; else goto <D.24322>;
      <D.24321>:
      mono_loader_unlock ();
      D.24310 = type2;
      return D.24310;
      <D.24322>:
      type2 = mono_metadata_type_dup (image, type);
      D.24306 = image->typespec_cache;
      type_spec.159 = (void *) type_spec;
      monoeg_g_hash_table_insert_replace (D.24306, type_spec.159, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.24310 = type2;
      return D.24310;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.160;
  unsigned int D.24332;
  const char * ptr.161;
  const char * ptr.162;
  char D.24335;
  <unnamed type> D.24336;
  <unnamed type> D.24337;
  int ptr.163;
  int start.164;
  int D.24342;
  const char * ptr.165;
  const char * ptr.166;
  char D.24347;
  <unnamed type> D.24348;
  unsigned int D.24351;
  short int D.24352;
  unsigned int D.24355;
  int D.24356;
  unsigned int D.24359;
  short int D.24360;
  unsigned int D.24365;
  int D.24366;
  unsigned int D.24371;
  int D.24372;
  unsigned int D.24375;
  sizetype len.167;
  const char * ptr.168;
  unsigned int D.24378;
  unsigned int D.24379;
  unsigned int len.169;
  char * D.24381;
  unsigned int D.24382;
  char * D.24383;
  const char * ptr.170;
  const char * ptr.171;
  char D.24390;
  <unnamed type> D.24391;
  const char * ptr.172;
  const char * ptr.173;
  char D.24396;
  int D.24397;
  struct MonoMarshalSpec * D.24398;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.24328>; else goto <D.24329>;
  <D.24328>:
  res = mono_image_alloc0 (image, 16);
  goto <D.24330>;
  <D.24329>:
  res = monoeg_malloc0 (16);
  <D.24330>:
  ptr.160 = ptr;
  D.24332 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.24332;
  ptr.160 = ptr;
  ptr.161 = ptr.160;
  ptr.162 = ptr.161 + 1;
  ptr = ptr.162;
  D.24335 = *ptr.161;
  D.24336 = (<unnamed type>) D.24335;
  res->native = D.24336;
  D.24337 = res->native;
  if (D.24337 == 42) goto <D.24338>; else goto <D.24339>;
  <D.24338>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24343>; else goto <D.24344>;
  <D.24343>:
  ptr.160 = ptr;
  ptr.165 = ptr.160;
  ptr.166 = ptr.165 + 1;
  ptr = ptr.166;
  D.24347 = *ptr.165;
  D.24348 = (<unnamed type>) D.24347;
  res->data.array_data.elem_type = D.24348;
  <D.24344>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24349>; else goto <D.24350>;
  <D.24349>:
  ptr.160 = ptr;
  D.24351 = mono_metadata_decode_value (ptr.160, &ptr);
  D.24352 = (short int) D.24351;
  res->data.array_data.param_num = D.24352;
  <D.24350>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24353>; else goto <D.24354>;
  <D.24353>:
  ptr.160 = ptr;
  D.24355 = mono_metadata_decode_value (ptr.160, &ptr);
  D.24356 = (int) D.24355;
  res->data.array_data.num_elem = D.24356;
  <D.24354>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24357>; else goto <D.24358>;
  <D.24357>:
  ptr.160 = ptr;
  D.24359 = mono_metadata_decode_value (ptr.160, &ptr);
  D.24360 = (short int) D.24359;
  res->data.array_data.elem_mult = D.24360;
  <D.24358>:
  <D.24339>:
  D.24337 = res->native;
  if (D.24337 == 23) goto <D.24361>; else goto <D.24362>;
  <D.24361>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24363>; else goto <D.24364>;
  <D.24363>:
  ptr.160 = ptr;
  D.24365 = mono_metadata_decode_value (ptr.160, &ptr);
  D.24366 = (int) D.24365;
  res->data.array_data.num_elem = D.24366;
  <D.24364>:
  <D.24362>:
  D.24337 = res->native;
  if (D.24337 == 30) goto <D.24367>; else goto <D.24368>;
  <D.24367>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24369>; else goto <D.24370>;
  <D.24369>:
  ptr.160 = ptr;
  D.24371 = mono_metadata_decode_value (ptr.160, &ptr);
  D.24372 = (int) D.24371;
  res->data.array_data.num_elem = D.24372;
  <D.24370>:
  <D.24368>:
  D.24337 = res->native;
  if (D.24337 == 44) goto <D.24373>; else goto <D.24374>;
  <D.24373>:
  ptr.160 = ptr;
  D.24375 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.24375;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.24378 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.24378;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.24379 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.24379;
  ptr.160 = ptr;
  len.169 = (unsigned int) len;
  D.24381 = mono_image_strndup (image, ptr.160, len.169);
  res->data.custom_data.custom_name = D.24381;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.24382 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.24382;
  ptr.160 = ptr;
  len.169 = (unsigned int) len;
  D.24383 = mono_image_strndup (image, ptr.160, len.169);
  res->data.custom_data.cookie = D.24383;
  <D.24374>:
  D.24337 = res->native;
  if (D.24337 == 29) goto <D.24384>; else goto <D.24385>;
  <D.24384>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24386>; else goto <D.24387>;
  <D.24386>:
  ptr.160 = ptr;
  ptr.170 = ptr.160;
  ptr.171 = ptr.170 + 1;
  ptr = ptr.171;
  D.24390 = *ptr.170;
  D.24391 = (<unnamed type>) D.24390;
  res->data.safearray_data.elem_type = D.24391;
  <D.24387>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.24342 = ptr.163 - start.164;
  if (D.24342 <= len) goto <D.24392>; else goto <D.24393>;
  <D.24392>:
  ptr.160 = ptr;
  ptr.172 = ptr.160;
  ptr.173 = ptr.172 + 1;
  ptr = ptr.173;
  D.24396 = *ptr.172;
  D.24397 = (int) D.24396;
  res->data.safearray_data.num_elem = D.24397;
  <D.24393>:
  <D.24385>:
  D.24398 = res;
  return D.24398;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.24402;
  unsigned int D.24403;
  char * D.24404;
  char * res;

  if (image == 0B) goto <D.24400>; else goto <D.24401>;
  <D.24400>:
  D.24402 = monoeg_g_strndup (data, len);
  return D.24402;
  <D.24401>:
  D.24403 = len + 1;
  res = mono_image_alloc (image, D.24403);
  memcpy (res, data, len);
  D.24404 = res + len;
  *D.24404 = 0;
  D.24402 = res;
  return D.24402;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.24406;
  char * D.24409;
  char * D.24410;

  D.24406 = spec->native;
  if (D.24406 == 44) goto <D.24407>; else goto <D.24408>;
  <D.24407>:
  D.24409 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.24409);
  D.24410 = spec->data.custom_data.cookie;
  monoeg_g_free (D.24410);
  <D.24408>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.24411;
  unsigned char D.24414;
  unsigned char D.24415;
  uint32_t D.24418;
  <unnamed type> D.24421;
  uint32_t iftmp.174;
  struct MonoClass * D.24435;
  unsigned char D.24436;
  unsigned char D.24437;
  struct MonoType * D.24440;
  unsigned char D.24441;
  struct MonoClass * D.24442;
  struct MonoClass * D.24449;
  struct MonoClass * D.24450;
  struct MonoClass * D.24459;
  struct MonoClass * D.24461;
  struct MonoClass * D.24463;
  struct MonoClass * D.24470;
  struct MonoGenericClass * D.24475;
  struct MonoClass * D.24476;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.24411 = type->type;
      t = (int) D.24411;
      if (conv == 0B) goto <D.24412>; else goto <D.24413>;
      <D.24412>:
      conv = &dummy_conv;
      <D.24413>:
      *conv = 0;
      D.24414 = BIT_FIELD_REF <*type, 8, 56>;
      D.24415 = D.24414 & 64;
      if (D.24415 != 0) goto <D.24416>; else goto <D.24417>;
      <D.24416>:
      D.24418 = 32;
      return D.24418;
      <D.24417>:
      handle_enum:
      switch (t) <default: <D.21256>, case 2: <D.21200>, case 3: <D.21207>, case 4: <D.21212>, case 5: <D.21213>, case 6: <D.21214>, case 7: <D.21215>, case 8: <D.21216>, case 9: <D.21217>, case 10: <D.21218>, case 11: <D.21219>, case 12: <D.21220>, case 13: <D.21221>, case 14: <D.21222>, case 15: <D.21232>, case 17: <D.21233>, case 18: <D.21243>, case 20: <D.21235>, case 21: <D.21254>, case 22: <D.21255>, case 24: <D.21241>, case 25: <D.21242>, case 27: <D.21253>, case 28: <D.21244>, case 29: <D.21234>>
      <D.21200>:
      if (mspec != 0B) goto <D.24419>; else goto <D.24420>;
      <D.24419>:
      D.24421 = mspec->native;
      switch (D.24421) <default: <D.21205>, case 2: <D.21202>, case 3: <D.21203>, case 4: <D.21204>, case 37: <D.21201>>
      <D.21201>:
      *conv = 1;
      D.24418 = 37;
      return D.24418;
      <D.21202>:
      *conv = 2;
      D.24418 = 2;
      return D.24418;
      <D.21203>:
      <D.21204>:
      D.24418 = mspec->native;
      return D.24418;
      <D.21205>:
      D.24421 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.24421);
      <D.21206>:
      goto <D.21206>;
      <D.24420>:
      *conv = 2;
      D.24418 = 2;
      return D.24418;
      <D.21207>:
      if (mspec != 0B) goto <D.24422>; else goto <D.24423>;
      <D.24422>:
      D.24421 = mspec->native;
      switch (D.24421) <default: <D.21210>, case 4: <D.21209>, case 6: <D.21208>>
      <D.21208>:
      <D.21209>:
      D.24418 = mspec->native;
      return D.24418;
      <D.21210>:
      D.24421 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.24421);
      <D.21211>:
      goto <D.21211>;
      <D.24423>:
      if (unicode != 0) goto <D.24425>; else goto <D.24426>;
      <D.24425>:
      iftmp.174 = 6;
      goto <D.24427>;
      <D.24426>:
      iftmp.174 = 4;
      <D.24427>:
      D.24418 = iftmp.174;
      return D.24418;
      <D.21212>:
      D.24418 = 3;
      return D.24418;
      <D.21213>:
      D.24418 = 4;
      return D.24418;
      <D.21214>:
      D.24418 = 5;
      return D.24418;
      <D.21215>:
      D.24418 = 6;
      return D.24418;
      <D.21216>:
      D.24418 = 7;
      return D.24418;
      <D.21217>:
      D.24418 = 8;
      return D.24418;
      <D.21218>:
      D.24418 = 9;
      return D.24418;
      <D.21219>:
      D.24418 = 10;
      return D.24418;
      <D.21220>:
      D.24418 = 11;
      return D.24418;
      <D.21221>:
      D.24418 = 12;
      return D.24418;
      <D.21222>:
      if (mspec != 0B) goto <D.24428>; else goto <D.24429>;
      <D.24428>:
      D.24421 = mspec->native;
      switch (D.24421) <default: <D.21230>, case 19: <D.21223>, case 20: <D.21224>, case 21: <D.21225>, case 22: <D.21226>, case 23: <D.21229>, case 35: <D.21227>, case 36: <D.21228>>
      <D.21223>:
      *conv = 3;
      D.24418 = 19;
      return D.24418;
      <D.21224>:
      *conv = 4;
      D.24418 = 20;
      return D.24418;
      <D.21225>:
      *conv = 7;
      D.24418 = 21;
      return D.24418;
      <D.21226>:
      *conv = 9;
      D.24418 = 22;
      return D.24418;
      <D.21227>:
      *conv = 10;
      D.24418 = 35;
      return D.24418;
      <D.21228>:
      *conv = 11;
      D.24418 = 36;
      return D.24418;
      <D.21229>:
      if (unicode != 0) goto <D.24430>; else goto <D.24431>;
      <D.24430>:
      *conv = 13;
      goto <D.24432>;
      <D.24431>:
      *conv = 12;
      <D.24432>:
      D.24418 = 23;
      return D.24418;
      <D.21230>:
      D.24421 = 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.24421);
      <D.21231>:
      goto <D.21231>;
      <D.24429>:
      if (unicode != 0) goto <D.24433>; else goto <D.24434>;
      <D.24433>:
      *conv = 7;
      D.24418 = 21;
      return D.24418;
      <D.24434>:
      *conv = 4;
      D.24418 = 20;
      return D.24418;
      <D.21232>:
      D.24418 = 32;
      return D.24418;
      <D.21233>:
      D.24435 = type->data.klass;
      D.24436 = BIT_FIELD_REF <*D.24435, 8, 160>;
      D.24437 = D.24436 & 16;
      if (D.24437 != 0) goto <D.24438>; else goto <D.24439>;
      <D.24438>:
      D.24435 = type->data.klass;
      D.24440 = mono_class_enum_basetype (D.24435);
      D.24441 = D.24440->type;
      t = (int) D.24441;
      goto handle_enum;
      <D.24439>:
      D.24435 = type->data.klass;
      D.24442 = mono_defaults.handleref_class;
      if (D.24435 == D.24442) goto <D.24443>; else goto <D.24444>;
      <D.24443>:
      *conv = 34;
      D.24418 = 31;
      return D.24418;
      <D.24444>:
      D.24418 = 27;
      return D.24418;
      <D.21234>:
      <D.21235>:
      if (mspec != 0B) goto <D.24445>; else goto <D.24446>;
      <D.24445>:
      D.24421 = mspec->native;
      switch (D.24421) <default: <D.21239>, case 29: <D.21237>, case 30: <D.21236>, case 42: <D.21238>>
      <D.21236>:
      D.24435 = type->data.klass;
      D.24449 = D.24435->element_class;
      D.24450 = mono_defaults.char_class;
      if (D.24449 == D.24450) goto <D.24451>; else goto <D.24447>;
      <D.24451>:
      if (unicode == 0) goto <D.24452>; else goto <D.24447>;
      <D.24452>:
      *conv = 21;
      goto <D.24448>;
      <D.24447>:
      *conv = 20;
      <D.24448>:
      D.24418 = 30;
      return D.24418;
      <D.21237>:
      *conv = 22;
      D.24418 = 29;
      return D.24418;
      <D.21238>:
      *conv = 23;
      D.24418 = 42;
      return D.24418;
      <D.21239>:
      D.24421 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.24421);
      <D.21240>:
      goto <D.21240>;
      <D.24446>:
      *conv = 23;
      D.24418 = 42;
      return D.24418;
      <D.21241>:
      D.24418 = 31;
      return D.24418;
      <D.21242>:
      D.24418 = 32;
      return D.24418;
      <D.21243>:
      <D.21244>:
      if (mspec != 0B) goto <D.24453>; else goto <D.24454>;
      <D.24453>:
      D.24421 = mspec->native;
      switch (D.24421) <default: <D.21251>, case 25: <D.21249>, case 26: <D.21248>, case 27: <D.21245>, case 28: <D.21247>, case 38: <D.21250>, case 44: <D.21246>>
      <D.21245>:
      D.24418 = 27;
      return D.24418;
      <D.21246>:
      D.24418 = 44;
      return D.24418;
      <D.21247>:
      *conv = 25;
      D.24418 = 28;
      return D.24418;
      <D.21248>:
      *conv = 26;
      D.24418 = 26;
      return D.24418;
      <D.21249>:
      *conv = 27;
      D.24418 = 25;
      return D.24418;
      <D.21250>:
      if (t == 18) goto <D.24457>; else goto <D.24458>;
      <D.24457>:
      D.24435 = type->data.klass;
      D.24459 = mono_defaults.multicastdelegate_class;
      if (D.24435 == D.24459) goto <D.24455>; else goto <D.24460>;
      <D.24460>:
      D.24435 = type->data.klass;
      D.24461 = mono_defaults.delegate_class;
      if (D.24435 == D.24461) goto <D.24455>; else goto <D.24462>;
      <D.24462>:
      D.24435 = type->data.klass;
      D.24463 = D.24435->parent;
      D.24459 = mono_defaults.multicastdelegate_class;
      if (D.24463 == D.24459) goto <D.24455>; else goto <D.24456>;
      <D.24455>:
      *conv = 29;
      D.24418 = 38;
      return D.24418;
      <D.24456>:
      <D.24458>:
      <D.21251>:
      D.24421 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.24421);
      <D.21252>:
      goto <D.21252>;
      <D.24454>:
      if (t == 18) goto <D.24466>; else goto <D.24467>;
      <D.24466>:
      D.24435 = type->data.klass;
      D.24459 = mono_defaults.multicastdelegate_class;
      if (D.24435 == D.24459) goto <D.24464>; else goto <D.24468>;
      <D.24468>:
      D.24435 = type->data.klass;
      D.24461 = mono_defaults.delegate_class;
      if (D.24435 == D.24461) goto <D.24464>; else goto <D.24469>;
      <D.24469>:
      D.24435 = type->data.klass;
      D.24463 = D.24435->parent;
      D.24459 = mono_defaults.multicastdelegate_class;
      if (D.24463 == D.24459) goto <D.24464>; else goto <D.24465>;
      <D.24464>:
      *conv = 29;
      D.24418 = 38;
      return D.24418;
      <D.24465>:
      <D.24467>:
      D.24470 = mono_defaults.safehandle_class;
      if (D.24470 != 0B) goto <D.24471>; else goto <D.24472>;
      <D.24471>:
      D.24435 = type->data.klass;
      D.24470 = mono_defaults.safehandle_class;
      if (D.24435 == D.24470) goto <D.24473>; else goto <D.24474>;
      <D.24473>:
      *conv = 33;
      D.24418 = 31;
      return D.24418;
      <D.24474>:
      <D.24472>:
      *conv = 28;
      D.24418 = 27;
      return D.24418;
      <D.21253>:
      D.24418 = 38;
      return D.24418;
      <D.21254>:
      D.24475 = type->data.generic_class;
      D.24476 = D.24475->container_class;
      type = &D.24476->byval_arg;
      D.24411 = type->type;
      t = (int) D.24411;
      goto handle_enum;
      <D.21255>:
      <D.21256>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.21257>:
      goto <D.21257>;
      D.24418 = 80;
      return D.24418;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.24479;
  const char * D.24482;
  unsigned int D.24483;
  unsigned int D.24484;
  _Bool D.24485;
  int D.24486;
  unsigned int D.24487;
  unsigned int D.24488;
  int D.24489;
  <unnamed-unsigned:24> D.24490;
  unsigned int D.24491;
  unsigned char D.24492;
  unsigned int D.24493;
  void * D.24494;
  unsigned int D.24497;
  int D.24498;
  unsigned int D.24499;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.24479 = tdef->base;
      if (D.24479 == 0B) goto <D.24480>; else goto <D.24481>;
      <D.24480>:
      D.24482 = 0B;
      return D.24482;
      <D.24481>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.24483 = idx + 1;
      D.24484 = D.24483 << 1;
      D.24485 = is_field == 0;
      D.24486 = (int) D.24485;
      D.24487 = (unsigned int) D.24486;
      D.24488 = D.24484 | D.24487;
      D.24489 = (int) D.24488;
      loc.idx = D.24489;
      D.24479 = tdef->base;
      D.24490 = tdef->rows;
      D.24491 = (unsigned int) D.24490;
      D.24492 = tdef->row_size;
      D.24493 = (unsigned int) D.24492;
      D.24494 = mono_binary_search (&loc, D.24479, D.24491, D.24493, table_locator);
      if (D.24494 == 0B) goto <D.24495>; else goto <D.24496>;
      <D.24495>:
      D.24482 = 0B;
      return D.24482;
      <D.24496>:
      D.24497 = loc.result;
      D.24498 = (int) D.24497;
      D.24499 = mono_metadata_decode_row_col (tdef, D.24498, 1);
      D.24482 = mono_metadata_blob_heap (meta, D.24499);
      return D.24482;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.24502;
  struct MonoMethod * D.24503;
  unsigned int D.24504;
  unsigned int D.24505;
  guint32 idx;

  idx = tok >> 1;
  D.24502 = tok & 1;
  switch (D.24502) <default: <D.24506>, case 0: <D.21271>, case 1: <D.21272>>
  <D.21271>:
  D.24504 = idx | 100663296;
  D.24503 = mono_get_method_full (m, D.24504, 0B, context);
  return D.24503;
  <D.21272>:
  D.24505 = idx | 167772160;
  D.24503 = mono_get_method_full (m, D.24505, 0B, context);
  return D.24503;
  <D.24506>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.24503 = 0B;
  return D.24503;
}


mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.24510;
  gboolean D.24513;
  int type_token.175;
  int D.24515;
  <unnamed-unsigned:24> D.24516;
  unsigned int D.24517;
  unsigned char D.24518;
  unsigned int D.24519;
  void * D.24520;
  int D.24523;
  unsigned int D.24524;
  unsigned int D.24525;
  int D.24526;
  unsigned int D.24527;
  int end.176;
  unsigned int D.24530;
  unsigned int D.24532;
  unsigned int D.24533;
  unsigned int num.177;
  unsigned int D.24535;
  unsigned int i.178;
  unsigned int D.24537;
  int D.24538;
  int D.24541;
  unsigned int D.24542;
  unsigned int i.179;
  unsigned int D.24546;
  struct MonoMethod * * D.24547;
  unsigned int D.24548;
  sizetype i.180;
  sizetype D.24552;
  sizetype D.24553;
  struct MonoMethod * * D.24554;
  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.24508>; else goto <D.24509>;
      <D.24508>:
      *num_overrides = 0;
      <D.24509>:
      D.24510 = tdef->base;
      if (D.24510 == 0B) goto <D.24511>; else goto <D.24512>;
      <D.24511>:
      D.24513 = 1;
      return D.24513;
      <D.24512>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.175 = (int) type_token;
      D.24515 = type_token.175 & 16777215;
      loc.idx = D.24515;
      D.24510 = tdef->base;
      D.24516 = tdef->rows;
      D.24517 = (unsigned int) D.24516;
      D.24518 = tdef->row_size;
      D.24519 = (unsigned int) D.24518;
      D.24520 = mono_binary_search (&loc, D.24510, D.24517, D.24519, table_locator);
      if (D.24520 == 0B) goto <D.24521>; else goto <D.24522>;
      <D.24521>:
      D.24513 = 1;
      return D.24513;
      <D.24522>:
      start = loc.result;
      end = start + 1;
      goto <D.21292>;
      <D.21291>:
      D.24523 = loc.idx;
      D.24524 = (unsigned int) D.24523;
      D.24525 = start + 4294967295;
      D.24526 = (int) D.24525;
      D.24527 = mono_metadata_decode_row_col (tdef, D.24526, 0);
      if (D.24524 == D.24527) goto <D.24528>; else goto <D.21290>;
      <D.24528>:
      start = start + 4294967295;
      <D.21292>:
      if (start != 0) goto <D.21291>; else goto <D.21290>;
      <D.21290>:
      goto <D.21295>;
      <D.21294>:
      D.24523 = loc.idx;
      D.24524 = (unsigned int) D.24523;
      end.176 = (int) end;
      D.24530 = mono_metadata_decode_row_col (tdef, end.176, 0);
      if (D.24524 == D.24530) goto <D.24531>; else goto <D.21293>;
      <D.24531>:
      end = end + 1;
      <D.21295>:
      D.24516 = tdef->rows;
      D.24532 = (unsigned int) D.24516;
      if (D.24532 > end) goto <D.21294>; else goto <D.21293>;
      <D.21293>:
      D.24533 = end - start;
      num = (gint32) D.24533;
      num.177 = (unsigned int) num;
      D.24535 = num.177 * 8;
      result = monoeg_malloc (D.24535);
      i = 0;
      goto <D.21299>;
      <D.21298>:
      {
        struct MonoMethod * method;

        i.178 = (unsigned int) i;
        D.24537 = start + i.178;
        D.24538 = mono_verifier_verify_methodimpl_row (image, D.24537, &error);
        if (D.24538 == 0) goto <D.24539>; else goto <D.24540>;
        <D.24539>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.21297>;
        <D.24540>:
        i.178 = (unsigned int) i;
        D.24537 = start + i.178;
        D.24541 = (int) D.24537;
        mono_metadata_decode_row (tdef, D.24541, &cols, 3);
        D.24542 = cols[2];
        method = method_from_method_def_or_ref (image, D.24542, generic_context);
        if (method == 0B) goto <D.24543>; else goto <D.24544>;
        <D.24543>:
        ok = 0;
        <D.24544>:
        i.179 = (unsigned int) i;
        D.24546 = i.179 * 8;
        D.24547 = result + D.24546;
        *D.24547 = method;
        D.24548 = cols[1];
        method = method_from_method_def_or_ref (image, D.24548, generic_context);
        if (method == 0B) goto <D.24549>; else goto <D.24550>;
        <D.24549>:
        ok = 0;
        <D.24550>:
        i.180 = (sizetype) i;
        D.24552 = i.180 * 8;
        D.24553 = D.24552 + 4;
        D.24554 = result + D.24553;
        *D.24554 = method;
      }
      i = i + 1;
      <D.21299>:
      if (i < num) goto <D.21298>; else goto <D.21297>;
      <D.21297>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.24555>; else goto <D.24556>;
      <D.24555>:
      *num_overrides = num;
      <D.24556>:
      D.24513 = ok;
      return D.24513;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.24559;
  const guint8 * D.24560;
  unsigned char D.24561;
  int D.24562;
  const guint8 * D.24563;
  unsigned char D.24564;
  int D.24565;
  const guint8 * D.24566;
  unsigned char D.24567;
  int D.24568;
  unsigned char D.24569;
  int D.24570;
  const guint8 * D.24571;
  unsigned char D.24572;
  int D.24573;
  const guint8 * D.24574;
  unsigned char D.24575;
  int D.24576;
  const guint8 * D.24577;
  unsigned char D.24578;
  int D.24579;
  const guint8 * D.24580;
  unsigned char D.24581;
  int D.24582;
  const guint8 * D.24583;
  unsigned char D.24584;
  int D.24585;
  const guint8 * D.24586;
  unsigned char D.24587;
  int D.24588;
  const guint8 * D.24589;
  unsigned char D.24590;
  int D.24591;
  const guint8 * D.24592;
  unsigned char D.24593;
  int D.24594;
  const guint8 * D.24595;
  unsigned char D.24596;
  int D.24597;
  const guint8 * D.24598;
  unsigned char D.24599;
  int D.24600;
  const guint8 * D.24601;
  unsigned char D.24602;
  int D.24603;
  const guint8 * D.24604;
  unsigned char D.24605;
  int D.24606;

  D.24560 = guid + 3;
  D.24561 = *D.24560;
  D.24562 = (int) D.24561;
  D.24563 = guid + 2;
  D.24564 = *D.24563;
  D.24565 = (int) D.24564;
  D.24566 = guid + 1;
  D.24567 = *D.24566;
  D.24568 = (int) D.24567;
  D.24569 = *guid;
  D.24570 = (int) D.24569;
  D.24571 = guid + 5;
  D.24572 = *D.24571;
  D.24573 = (int) D.24572;
  D.24574 = guid + 4;
  D.24575 = *D.24574;
  D.24576 = (int) D.24575;
  D.24577 = guid + 7;
  D.24578 = *D.24577;
  D.24579 = (int) D.24578;
  D.24580 = guid + 6;
  D.24581 = *D.24580;
  D.24582 = (int) D.24581;
  D.24583 = guid + 8;
  D.24584 = *D.24583;
  D.24585 = (int) D.24584;
  D.24586 = guid + 9;
  D.24587 = *D.24586;
  D.24588 = (int) D.24587;
  D.24589 = guid + 10;
  D.24590 = *D.24589;
  D.24591 = (int) D.24590;
  D.24592 = guid + 11;
  D.24593 = *D.24592;
  D.24594 = (int) D.24593;
  D.24595 = guid + 12;
  D.24596 = *D.24595;
  D.24597 = (int) D.24596;
  D.24598 = guid + 13;
  D.24599 = *D.24598;
  D.24600 = (int) D.24599;
  D.24601 = guid + 14;
  D.24602 = *D.24601;
  D.24603 = (int) D.24602;
  D.24604 = guid + 15;
  D.24605 = *D.24604;
  D.24606 = (int) D.24605;
  D.24559 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.24562, D.24565, D.24568, D.24570, D.24573, D.24576, D.24579, D.24582, D.24585, D.24588, D.24591, D.24594, D.24597, D.24600, D.24603, D.24606);
  return D.24559;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.24608;
  long int D.24609;
  long int D.24610;
  const char * D.24613;
  guint32 D.24616;
  unsigned int D.24617;
  unsigned int D.24624;
  unsigned int D.24625;
  unsigned int D.24626;
  unsigned int D.24627;
  int D.24628;
  <unnamed-unsigned:24> D.24629;
  unsigned int D.24630;
  unsigned char D.24631;
  unsigned int D.24632;
  void * D.24633;
  unsigned int D.24636;
  unsigned int D.24637;
  int D.24639;
  unsigned int D.24640;
  int D.24641;
  unsigned int D.24642;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.24608 = owner == 0B;
      D.24609 = (long int) D.24608;
      D.24610 = __builtin_expect (D.24609, 0);
      if (D.24610 != 0) goto <D.24611>; else goto <D.24612>;
      <D.24611>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.24612>:
      D.24613 = tdef->base;
      if (D.24613 == 0B) goto <D.24614>; else goto <D.24615>;
      <D.24614>:
      D.24616 = 0;
      return D.24616;
      <D.24615>:
      D.24617 = token >> 24;
      if (D.24617 == 2) goto <D.24618>; else goto <D.24619>;
      <D.24618>:
      *owner = 0;
      goto <D.24620>;
      <D.24619>:
      D.24617 = token >> 24;
      if (D.24617 == 6) goto <D.24621>; else goto <D.24622>;
      <D.24621>:
      *owner = 1;
      goto <D.24623>;
      <D.24622>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.21332>:
      goto <D.21332>;
      D.24616 = 0;
      return D.24616;
      <D.24623>:
      <D.24620>:
      D.24624 = *owner;
      D.24625 = token & 16777215;
      D.24626 = D.24625 << 1;
      D.24627 = D.24624 | D.24626;
      *owner = D.24627;
      D.24624 = *owner;
      D.24628 = (int) D.24624;
      loc.idx = D.24628;
      loc.col_idx = 2;
      loc.t = tdef;
      D.24613 = tdef->base;
      D.24629 = tdef->rows;
      D.24630 = (unsigned int) D.24629;
      D.24631 = tdef->row_size;
      D.24632 = (unsigned int) D.24631;
      D.24633 = mono_binary_search (&loc, D.24613, D.24630, D.24632, table_locator);
      if (D.24633 == 0B) goto <D.24634>; else goto <D.24635>;
      <D.24634>:
      D.24616 = 0;
      return D.24616;
      <D.24635>:
      goto <D.21334>;
      <D.21333>:
      D.24636 = loc.result;
      D.24637 = D.24636 + 4294967295;
      loc.result = D.24637;
      <D.21334>:
      D.24636 = loc.result;
      if (D.24636 != 0) goto <D.24638>; else goto <D.21335>;
      <D.24638>:
      D.24636 = loc.result;
      D.24637 = D.24636 + 4294967295;
      D.24639 = (int) D.24637;
      D.24640 = mono_metadata_decode_row_col (tdef, D.24639, 2);
      D.24641 = loc.idx;
      D.24642 = (unsigned int) D.24641;
      if (D.24640 == D.24642) goto <D.21333>; else goto <D.21335>;
      <D.21335>:
      D.24636 = loc.result;
      D.24616 = D.24636 + 1;
      return D.24616;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


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

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


mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.24651;
  unsigned int D.24652;
  int D.24653;
  struct MonoGenericParamFull * D.24654;
  unsigned int D.24655;
  struct MonoGenericParamFull * D.24656;
  struct MonoClass * * * D.24657;
  int D.24658;
  <unnamed-signed:31> D.24661;
  unsigned int D.24662;
  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.24649>; else goto <D.24650>;
      <D.24649>:
      D.24651 = 1;
      return D.24651;
      <D.24650>:
      i = 0;
      goto <D.21350>;
      <D.21349>:
      D.24652 = start_row + i;
      D.24653 = (int) D.24652;
      D.24654 = container->type_params;
      D.24655 = i * 32;
      D.24656 = D.24654 + D.24655;
      D.24657 = &D.24656->info.constraints;
      D.24658 = get_constraints (image, D.24653, D.24657, container);
      if (D.24658 == 0) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      D.24651 = 0;
      return D.24651;
      <D.24660>:
      i = i + 1;
      <D.21350>:
      D.24661 = container->type_argc;
      D.24662 = (unsigned int) D.24661;
      if (D.24662 > i) goto <D.21349>; else goto <D.21351>;
      <D.21351>:
      D.24651 = 1;
      return D.24651;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.181;
  unsigned int D.24666;
  unsigned int owner.182;
  unsigned int D.24670;
  gboolean D.24673;
  <unnamed-unsigned:24> D.24676;
  unsigned int D.24677;
  unsigned int D.24680;
  unsigned int D.24681;
  unsigned int D.24682;
  struct MonoClass * * D.24683;
  void * D.24684;
  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.21321>;
      <D.21320>:
      i.181 = (int) i;
      mono_metadata_decode_row (tdef, i.181, &cols, 2);
      D.24666 = cols[0];
      owner.182 = (unsigned int) owner;
      if (D.24666 == owner.182) goto <D.24668>; else goto <D.24669>;
      <D.24668>:
      D.24670 = cols[1];
      token = mono_metadata_token_from_dor (D.24670);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.24671>; else goto <D.24672>;
      <D.24671>:
      monoeg_g_slist_free (cons);
      D.24673 = 0;
      return D.24673;
      <D.24672>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.24674>;
      <D.24669>:
      if (found != 0) goto <D.21319>; else goto <D.24675>;
      <D.24675>:
      <D.24674>:
      i = i + 1;
      <D.21321>:
      D.24676 = tdef->rows;
      D.24677 = (unsigned int) D.24676;
      if (D.24677 > i) goto <D.21320>; else goto <D.21319>;
      <D.21319>:
      if (found == 0) goto <D.24678>; else goto <D.24679>;
      <D.24678>:
      D.24673 = 1;
      return D.24673;
      <D.24679>:
      D.24680 = found + 1;
      D.24681 = D.24680 * 4;
      res = mono_image_alloc0 (image, D.24681);
      i = 0;
      tmp = cons;
      goto <D.21323>;
      <D.21322>:
      D.24682 = i * 4;
      D.24683 = res + D.24682;
      D.24684 = tmp->data;
      *D.24683 = D.24684;
      i = i + 1;
      tmp = tmp->next;
      <D.21323>:
      if (i < found) goto <D.21322>; else goto <D.21324>;
      <D.21324>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.24673 = 1;
      return D.24673;
    }
  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.24689;
  unsigned int D.24690;
  int D.24691;
  unsigned int D.24692;
  sizetype D.24693;
  sizetype D.24694;
  struct MonoGenericParamFull * D.24695;
  unsigned int D.24696;
  short unsigned int D.24697;
  unsigned int D.24698;
  unsigned int D.24699;
  short unsigned int D.24700;
  unsigned int D.24701;
  const char * D.24702;
  short unsigned int D.24703;
  unsigned int D.24704;
  unsigned int D.24705;
  <unnamed-unsigned:24> D.24708;
  unsigned int D.24709;
  unsigned int D.24711;
  unsigned int owner.183;
  int n.184;
  <unnamed-signed:31> D.24714;
  void * D.24715;
  struct MonoGenericParamFull * D.24716;
  unsigned int D.24717;
  int iftmp.185;
  struct MonoGenericContainer * D.24723;
  unsigned char D.24725;
  unsigned char D.24726;
  _Bool D.24728;
  long int D.24729;
  long int D.24730;
  struct MonoGenericInst * iftmp.186;
  struct MonoGenericInst * D.24739;
  struct MonoGenericInst * D.24741;
  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.24687>; else goto <D.24688>;
      <D.24687>:
      D.24689 = 0B;
      return D.24689;
      <D.24688>:
      D.24690 = i + 4294967295;
      D.24691 = (int) D.24690;
      mono_metadata_decode_row (tdef, D.24691, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 28);
      container->image = image;
      <D.21371>:
      n = n + 1;
      D.24692 = n * 32;
      params = monoeg_realloc (params, D.24692);
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      memset (D.24695, 0, 32);
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24695->param.owner = container;
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24696 = cols[0];
      D.24697 = (short unsigned int) D.24696;
      D.24695->param.num = D.24697;
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24698 = i | 704643072;
      D.24695->info.token = D.24698;
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24699 = cols[1];
      D.24700 = (short unsigned int) D.24699;
      D.24695->info.flags = D.24700;
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24701 = cols[3];
      D.24702 = mono_metadata_string_heap (image, D.24701);
      D.24695->info.name = D.24702;
      D.24693 = n + 134217727;
      D.24694 = D.24693 * 32;
      D.24695 = params + D.24694;
      D.24703 = D.24695->param.num;
      D.24704 = (unsigned int) D.24703;
      D.24705 = n + 4294967295;
      if (D.24704 != D.24705) goto <D.24706>; else goto <D.24707>;
      <D.24706>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.24707>:
      i = i + 1;
      D.24708 = tdef->rows;
      D.24709 = (unsigned int) D.24708;
      if (i > D.24709) goto <D.21370>; else goto <D.24710>;
      <D.24710>:
      D.24690 = i + 4294967295;
      D.24691 = (int) D.24690;
      mono_metadata_decode_row (tdef, D.24691, &cols, 4);
      D.24711 = cols[2];
      owner.183 = owner;
      if (D.24711 == owner.183) goto <D.21371>; else goto <D.21370>;
      <D.21370>:
      n.184 = (int) n;
      D.24714 = (<unnamed-signed:31>) n.184;
      container->type_argc = D.24714;
      D.24692 = n * 32;
      D.24715 = mono_image_alloc0 (image, D.24692);
      container->type_params = D.24715;
      D.24716 = container->type_params;
      D.24692 = n * 32;
      memcpy (D.24716, params, D.24692);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.24717 = token >> 24;
      if (D.24717 == 6) goto <D.24718>; else goto <D.24719>;
      <D.24718>:
      container->is_method = -1;
      <D.24719>:
      D.24723 = container->parent;
      if (D.24723 != 0B) goto <D.24724>; else goto <D.24721>;
      <D.24724>:
      D.24725 = BIT_FIELD_REF <*container, 8, 152>;
      D.24726 = D.24725 & 128;
      if (D.24726 == 0) goto <D.24727>; else goto <D.24721>;
      <D.24727>:
      iftmp.185 = 1;
      goto <D.24722>;
      <D.24721>:
      iftmp.185 = 0;
      <D.24722>:
      D.24728 = iftmp.185 != 0;
      D.24729 = (long int) D.24728;
      D.24730 = __builtin_expect (D.24729, 0);
      if (D.24730 != 0) goto <D.24731>; else goto <D.24732>;
      <D.24731>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.24732>:
      context = &container->context;
      D.24725 = BIT_FIELD_REF <*container, 8, 152>;
      D.24726 = D.24725 & 128;
      if (D.24726 != 0) goto <D.24733>; else goto <D.24734>;
      <D.24733>:
      D.24723 = container->parent;
      if (D.24723 != 0B) goto <D.24736>; else goto <D.24737>;
      <D.24736>:
      D.24723 = container->parent;
      iftmp.186 = D.24723->context.class_inst;
      goto <D.24738>;
      <D.24737>:
      iftmp.186 = 0B;
      <D.24738>:
      context->class_inst = iftmp.186;
      D.24739 = mono_get_shared_generic_inst (container);
      context->method_inst = D.24739;
      goto <D.24740>;
      <D.24734>:
      D.24741 = mono_get_shared_generic_inst (container);
      context->class_inst = D.24741;
      <D.24740>:
      D.24689 = container;
      return D.24689;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.24744;
  unsigned int D.24745;
  unsigned int D.24746;
  unsigned int D.24747;
  unsigned int i.187;
  unsigned int D.24749;
  unsigned char iftmp.188;
  unsigned char D.24751;
  unsigned char D.24752;
  struct MonoGenericParamFull * D.24756;
  unsigned int D.24757;
  struct MonoGenericParam * D.24758;
  unsigned int D.24759;
  struct MonoType * * D.24760;
  int D.24761;
  struct MonoGenericInst * D.24762;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.24744 = container->type_argc;
  D.24745 = (unsigned int) D.24744;
  D.24746 = D.24745 * 4;
  type_argv = monoeg_malloc0 (D.24746);
  D.24744 = container->type_argc;
  D.24745 = (unsigned int) D.24744;
  D.24747 = D.24745 * 8;
  helper = monoeg_malloc0 (D.24747);
  i = 0;
  goto <D.21381>;
  <D.21380>:
  {
    struct MonoType * t;

    i.187 = (unsigned int) i;
    D.24749 = i.187 * 8;
    t = helper + D.24749;
    D.24751 = BIT_FIELD_REF <*container, 8, 152>;
    D.24752 = D.24751 & 128;
    if (D.24752 != 0) goto <D.24753>; else goto <D.24754>;
    <D.24753>:
    iftmp.188 = 30;
    goto <D.24755>;
    <D.24754>:
    iftmp.188 = 19;
    <D.24755>:
    t->type = iftmp.188;
    D.24756 = container->type_params;
    i.187 = (unsigned int) i;
    D.24757 = i.187 * 32;
    D.24758 = D.24756 + D.24757;
    t->data.generic_param = D.24758;
    i.187 = (unsigned int) i;
    D.24759 = i.187 * 4;
    D.24760 = type_argv + D.24759;
    *D.24760 = t;
  }
  i = i + 1;
  <D.21381>:
  D.24744 = container->type_argc;
  D.24761 = (int) D.24744;
  if (D.24761 > i) goto <D.21380>; else goto <D.21382>;
  <D.21382>:
  D.24744 = container->type_argc;
  D.24761 = (int) D.24744;
  nginst = mono_metadata_get_generic_inst (D.24761, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.24762 = nginst;
  return D.24762;
}


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

  D.24765 = type->byref;
  D.24764 = (mono_bool) D.24765;
  return D.24764;
}


mono_type_get_type (struct MonoType * type)
{
  int D.24767;
  unsigned char D.24768;

  D.24768 = type->type;
  D.24767 = (int) D.24768;
  return D.24767;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.24770;
  _Bool D.24771;
  long int D.24772;
  long int D.24773;
  struct MonoMethodSignature * D.24776;

  D.24770 = type->type;
  D.24771 = D.24770 != 27;
  D.24772 = (long int) D.24771;
  D.24773 = __builtin_expect (D.24772, 0);
  if (D.24773 != 0) goto <D.24774>; else goto <D.24775>;
  <D.24774>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.24775>:
  D.24776 = type->data.method;
  return D.24776;
}


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

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


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

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


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.24782;
  _Bool D.24783;
  long int D.24784;
  long int D.24785;
  struct MonoType * D.24788;

  D.24782 = type->type;
  D.24783 = D.24782 != 15;
  D.24784 = (long int) D.24783;
  D.24785 = __builtin_expect (D.24784, 0);
  if (D.24785 != 0) goto <D.24786>; else goto <D.24787>;
  <D.24786>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.24787>:
  D.24788 = type->data.type;
  return D.24788;
}


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

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


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.24792;
  int iftmp.189;
  unsigned char D.24798;
  unsigned char D.24799;
  unsigned char D.24801;
  struct MonoClass * D.24803;
  unsigned char D.24804;
  unsigned char D.24805;
  struct MonoGenericClass * D.24808;
  int D.24809;
  struct MonoClass * D.24811;
  unsigned char D.24812;
  unsigned char D.24813;

  D.24798 = BIT_FIELD_REF <*type, 8, 56>;
  D.24799 = D.24798 & 64;
  if (D.24799 == 0) goto <D.24800>; else goto <D.24794>;
  <D.24800>:
  D.24801 = type->type;
  if (D.24801 == 17) goto <D.24802>; else goto <D.24795>;
  <D.24802>:
  D.24803 = type->data.klass;
  D.24804 = BIT_FIELD_REF <*D.24803, 8, 160>;
  D.24805 = D.24804 & 16;
  if (D.24805 == 0) goto <D.24796>; else goto <D.24795>;
  <D.24795>:
  D.24801 = type->type;
  if (D.24801 == 22) goto <D.24796>; else goto <D.24806>;
  <D.24806>:
  D.24801 = type->type;
  if (D.24801 == 21) goto <D.24807>; else goto <D.24794>;
  <D.24807>:
  D.24808 = type->data.generic_class;
  D.24809 = mono_metadata_generic_class_is_valuetype (D.24808);
  if (D.24809 != 0) goto <D.24810>; else goto <D.24794>;
  <D.24810>:
  D.24808 = type->data.generic_class;
  D.24811 = D.24808->container_class;
  D.24812 = BIT_FIELD_REF <*D.24811, 8, 160>;
  D.24813 = D.24812 & 16;
  if (D.24813 == 0) goto <D.24796>; else goto <D.24794>;
  <D.24796>:
  iftmp.189 = 1;
  goto <D.24797>;
  <D.24794>:
  iftmp.189 = 0;
  <D.24797>:
  D.24792 = iftmp.189;
  return D.24792;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.24815;
  int iftmp.190;
  short unsigned int D.24820;
  short unsigned int D.24821;

  if (type != 0B) goto <D.24819>; else goto <D.24817>;
  <D.24819>:
  D.24820 = BIT_FIELD_REF <*type, 16, 48>;
  D.24821 = D.24820 & 16639;
  if (D.24821 == 1) goto <D.24822>; else goto <D.24817>;
  <D.24822>:
  iftmp.190 = 1;
  goto <D.24818>;
  <D.24817>:
  iftmp.190 = 0;
  <D.24818>:
  D.24815 = iftmp.190;
  return D.24815;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.24824;
  int iftmp.191;
  unsigned char D.24830;
  unsigned char D.24831;
  unsigned char D.24833;

  if (type != 0B) goto <D.24829>; else goto <D.24826>;
  <D.24829>:
  D.24830 = BIT_FIELD_REF <*type, 8, 56>;
  D.24831 = D.24830 & 64;
  if (D.24831 != 0) goto <D.24827>; else goto <D.24832>;
  <D.24832>:
  D.24833 = type->type;
  if (D.24833 == 24) goto <D.24827>; else goto <D.24834>;
  <D.24834>:
  D.24833 = type->type;
  if (D.24833 == 14) goto <D.24827>; else goto <D.24835>;
  <D.24835>:
  D.24833 = type->type;
  if (D.24833 == 29) goto <D.24827>; else goto <D.24836>;
  <D.24836>:
  D.24833 = type->type;
  if (D.24833 == 18) goto <D.24827>; else goto <D.24837>;
  <D.24837>:
  D.24833 = type->type;
  if (D.24833 == 25) goto <D.24827>; else goto <D.24838>;
  <D.24838>:
  D.24833 = type->type;
  if (D.24833 == 28) goto <D.24827>; else goto <D.24839>;
  <D.24839>:
  D.24833 = type->type;
  if (D.24833 == 20) goto <D.24827>; else goto <D.24840>;
  <D.24840>:
  D.24833 = type->type;
  if (D.24833 == 15) goto <D.24827>; else goto <D.24841>;
  <D.24841>:
  D.24833 = type->type;
  if (D.24833 == 27) goto <D.24827>; else goto <D.24826>;
  <D.24827>:
  iftmp.191 = 1;
  goto <D.24828>;
  <D.24826>:
  iftmp.191 = 0;
  <D.24828>:
  D.24824 = iftmp.191;
  return D.24824;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.24843;
  int iftmp.192;
  unsigned char D.24849;
  _Bool D.24850;
  _Bool D.24851;
  _Bool D.24852;
  unsigned char D.24854;
  struct MonoGenericClass * D.24859;
  int D.24860;

  if (type != 0B) goto <D.24848>; else goto <D.24845>;
  <D.24848>:
  D.24849 = type->type;
  D.24850 = D.24849 == 14;
  D.24851 = D.24849 == 29;
  D.24852 = D.24850 | D.24851;
  if (D.24852 != 0) goto <D.24846>; else goto <D.24853>;
  <D.24853>:
  D.24854 = type->type;
  if (D.24854 == 18) goto <D.24846>; else goto <D.24855>;
  <D.24855>:
  D.24854 = type->type;
  if (D.24854 == 28) goto <D.24846>; else goto <D.24856>;
  <D.24856>:
  D.24854 = type->type;
  if (D.24854 == 20) goto <D.24846>; else goto <D.24857>;
  <D.24857>:
  D.24854 = type->type;
  if (D.24854 == 21) goto <D.24858>; else goto <D.24845>;
  <D.24858>:
  D.24859 = type->data.generic_class;
  D.24860 = mono_metadata_generic_class_is_valuetype (D.24859);
  if (D.24860 == 0) goto <D.24846>; else goto <D.24845>;
  <D.24846>:
  iftmp.192 = 1;
  goto <D.24847>;
  <D.24845>:
  iftmp.192 = 0;
  <D.24847>:
  D.24843 = iftmp.192;
  return D.24843;
}


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

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


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.24866;
  void * D.24867;
  short unsigned int D.24870;
  struct MonoType * * D.24873;
  int D.24874;
  struct MonoType * * D.24875;
  struct MonoType * * type;

  if (iter == 0B) goto <D.24864>; else goto <D.24865>;
  <D.24864>:
  D.24866 = 0B;
  return D.24866;
  <D.24865>:
  D.24867 = *iter;
  if (D.24867 == 0B) goto <D.24868>; else goto <D.24869>;
  <D.24868>:
  D.24870 = sig->param_count;
  if (D.24870 != 0) goto <D.24871>; else goto <D.24872>;
  <D.24871>:
  D.24873 = &sig->params[0];
  *iter = D.24873;
  D.24866 = sig->params[0];
  return D.24866;
  <D.24872>:
  D.24866 = 0B;
  return D.24866;
  <D.24869>:
  type = *iter;
  type = type + 4;
  D.24870 = sig->param_count;
  D.24874 = (int) D.24870;
  D.24875 = &sig->params[D.24874];
  if (D.24875 > type) goto <D.24876>; else goto <D.24877>;
  <D.24876>:
  *iter = type;
  D.24866 = *type;
  return D.24866;
  <D.24877>:
  D.24866 = 0B;
  return D.24866;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.24879;
  short unsigned int D.24880;

  D.24880 = sig->param_count;
  D.24879 = (uint32_t) D.24880;
  return D.24879;
}


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

  D.24883 = sig->call_convention;
  D.24882 = (uint32_t) D.24883;
  return D.24882;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.24885;
  short int D.24886;

  D.24886 = sig->sentinelpos;
  D.24885 = (int) D.24886;
  return D.24885;
}


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

  D.24889 = sig->hasthis;
  D.24888 = (mono_bool) D.24889;
  return D.24888;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.193;
  short unsigned int D.24896;
  int D.24897;
  _Bool D.24898;
  long int D.24899;
  long int D.24900;
  mono_bool D.24903;
  struct MonoType * D.24904;
  short unsigned int D.24905;
  int D.24906;
  int D.24907;
  _Bool D.24908;

  if (param_num < 0) goto <D.24892>; else goto <D.24895>;
  <D.24895>:
  D.24896 = sig->param_count;
  D.24897 = (int) D.24896;
  if (D.24897 <= param_num) goto <D.24892>; else goto <D.24893>;
  <D.24892>:
  iftmp.193 = 1;
  goto <D.24894>;
  <D.24893>:
  iftmp.193 = 0;
  <D.24894>:
  D.24898 = iftmp.193 != 0;
  D.24899 = (long int) D.24898;
  D.24900 = __builtin_expect (D.24899, 0);
  if (D.24900 != 0) goto <D.24901>; else goto <D.24902>;
  <D.24901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.24902>:
  D.24904 = sig->params[param_num];
  D.24905 = D.24904->attrs;
  D.24906 = (int) D.24905;
  D.24907 = D.24906 & 2;
  D.24908 = D.24907 != 0;
  D.24903 = (mono_bool) D.24908;
  return D.24903;
}


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

  D.24911 = sig->explicit_this;
  D.24910 = (mono_bool) D.24911;
  return D.24910;
}


mono_aligned_addr_hash (const void * ptr)
{
  guint D.24913;
  unsigned int ptr.194;

  ptr.194 = (unsigned int) ptr;
  D.24913 = ptr.194 >> 3;
  return D.24913;
}


mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.24916;
  struct MonoGenericClass * D.24917;
  struct MonoClassField * D.24920;
  int field.195;
  struct MonoClassField * D.24922;
  int D.24923;
  int D.24924;
  struct MonoClassField * D.24925;
  unsigned int offset.196;
  unsigned int D.24927;
  struct MonoClass * gtd;
  int offset;

  D.24916 = field->parent;
  D.24917 = D.24916->generic_class;
  if (D.24917 == 0B) goto <D.24918>; else goto <D.24919>;
  <D.24918>:
  D.24920 = field;
  return D.24920;
  <D.24919>:
  D.24916 = field->parent;
  D.24917 = D.24916->generic_class;
  gtd = D.24917->container_class;
  field.195 = (int) field;
  D.24916 = field->parent;
  D.24922 = D.24916->fields;
  D.24923 = (int) D.24922;
  D.24924 = field.195 - D.24923;
  offset = D.24924 /[ex] 16;
  D.24925 = gtd->fields;
  offset.196 = (unsigned int) offset;
  D.24927 = offset.196 * 16;
  D.24920 = D.24925 + D.24927;
  return D.24920;
}


mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.24929;
  struct MonoGenericClass * D.24930;
  struct MonoEvent * D.24933;
  int event.197;
  struct MonoClassExt * D.24935;
  struct MonoEvent * D.24936;
  int D.24937;
  int D.24938;
  struct MonoClassExt * D.24939;
  struct MonoEvent * D.24940;
  unsigned int offset.198;
  unsigned int D.24942;
  struct MonoClass * gtd;
  int offset;

  D.24929 = event->parent;
  D.24930 = D.24929->generic_class;
  if (D.24930 == 0B) goto <D.24931>; else goto <D.24932>;
  <D.24931>:
  D.24933 = event;
  return D.24933;
  <D.24932>:
  D.24929 = event->parent;
  D.24930 = D.24929->generic_class;
  gtd = D.24930->container_class;
  event.197 = (int) event;
  D.24929 = event->parent;
  D.24935 = D.24929->ext;
  D.24936 = D.24935->events;
  D.24937 = (int) D.24936;
  D.24938 = event.197 - D.24937;
  offset = D.24938 /[ex] 28;
  D.24939 = gtd->ext;
  D.24940 = D.24939->events;
  offset.198 = (unsigned int) offset;
  D.24942 = offset.198 * 28;
  D.24933 = D.24940 + D.24942;
  return D.24933;
}


mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.24944;
  struct MonoGenericClass * D.24945;
  struct MonoProperty * D.24948;
  int property.199;
  struct MonoClassExt * D.24950;
  struct MonoProperty * D.24951;
  int D.24952;
  int D.24953;
  struct MonoClassExt * D.24954;
  struct MonoProperty * D.24955;
  unsigned int offset.200;
  unsigned int D.24957;
  struct MonoClass * gtd;
  int offset;

  D.24944 = property->parent;
  D.24945 = D.24944->generic_class;
  if (D.24945 == 0B) goto <D.24946>; else goto <D.24947>;
  <D.24946>:
  D.24948 = property;
  return D.24948;
  <D.24947>:
  D.24944 = property->parent;
  D.24945 = D.24944->generic_class;
  gtd = D.24945->container_class;
  property.199 = (int) property;
  D.24944 = property->parent;
  D.24950 = D.24944->ext;
  D.24951 = D.24950->properties;
  D.24952 = (int) D.24951;
  D.24953 = property.199 - D.24952;
  offset = D.24953 /[ex] 20;
  D.24954 = gtd->ext;
  D.24955 = D.24954->properties;
  offset.200 = (unsigned int) offset;
  D.24957 = offset.200 * 20;
  D.24948 = D.24955 + D.24957;
  return D.24948;
}