__attribute__((visibility ("hidden")))
mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.19420;
  short int D.19421;
  sizetype D.19422;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.19418>; else goto <D.19419>;
  <D.19418>:
  D.19420 = "";
  return D.19420;
  <D.19419>:
  D.19421 = tableidx[table];
  D.19422 = (sizetype) D.19421;
  D.19420 = &tablestr + D.19422;
  return D.19420;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.19424;
  sizetype D.19425;
  int iftmp.1;
  long unsigned int D.19427;
  long unsigned int D.19428;
  int iftmp.2;
  long unsigned int D.19433;
  int iftmp.3;
  long unsigned int D.19438;
  _Bool D.19442;
  long int D.19443;
  long int D.19444;
  int iftmp.4;
  <unnamed-unsigned:24> D.19448;
  int D.19449;
  _Bool D.19453;
  long int D.19454;
  long int D.19455;
  int iftmp.5;
  _Bool D.19462;
  long int D.19463;
  long int D.19464;
  int iftmp.6;
  <unnamed-unsigned:24> D.19468;
  int D.19469;
  unsigned int i.7;
  _Bool D.19474;
  long int D.19475;
  long int D.19476;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.19483;
  int D.19484;
  int iftmp.10;
  _Bool D.19493;
  long int D.19494;
  long int D.19495;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.19507;
  int D.19508;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.19527;
  int D.19528;
  int iftmp.16;
  _Bool D.19538;
  long int D.19539;
  long int D.19540;
  int iftmp.17;
  <unnamed-unsigned:24> D.19544;
  int D.19545;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.19558;
  int D.19559;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.19587;
  int D.19588;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.19603;
  _Bool D.19604;
  long int D.19605;
  long int D.19606;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.19630;
  int D.19631;
  int iftmp.32;
  <unnamed-unsigned:24> D.19639;
  int D.19640;
  <unnamed-unsigned:24> D.19641;
  int D.19642;
  <unnamed-unsigned:24> D.19643;
  int D.19644;
  <unnamed-unsigned:24> D.19645;
  int D.19646;
  <unnamed-unsigned:24> D.19647;
  int D.19648;
  <unnamed-unsigned:24> D.19649;
  int D.19650;
  <unnamed-unsigned:24> D.19651;
  int D.19652;
  <unnamed-unsigned:24> D.19653;
  int D.19654;
  <unnamed-unsigned:24> D.19655;
  int D.19656;
  <unnamed-unsigned:24> D.19657;
  int D.19658;
  <unnamed-unsigned:24> D.19659;
  int D.19660;
  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.19706;
  int D.19707;
  unsigned int D.19708;
  sizetype D.19709;
  const unsigned char * D.19710;
  unsigned char D.19711;
  int D.19712;
  unsigned int D.19713;
  unsigned int D.19714;
  int D.19715;
  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.19424 = table_description[tableindex];
  D.19425 = (sizetype) D.19424;
  description = &TableSchemas + D.19425;
  i = 0;
  goto <D.17673>;
  <D.17672>:
  switch (code) <default: <D.19705>, case 1: <D.17627>, case 2: <D.17629>, case 3: <D.17630>, case 4: <D.17631>, case 5: <D.17632>, case 6: <D.17633>, case 7: <D.17634>, case 8: <D.17660>, case 9: <D.17661>, case 10: <D.17662>, case 11: <D.17663>, case 12: <D.17664>, case 13: <D.17665>, case 14: <D.17666>, case 15: <D.17667>, case 16: <D.17668>, case 17: <D.17669>, case 18: <D.17670>, case 19: <D.17671>>
  <D.17627>:
  field_size = 4;
  goto <D.17628>;
  <D.17629>:
  field_size = 2;
  goto <D.17628>;
  <D.17630>:
  field_size = 1;
  goto <D.17628>;
  <D.17631>:
  D.19427 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19428 = D.19427 & 2097152;
  if (D.19428 != 0) goto <D.19429>; else goto <D.19430>;
  <D.19429>:
  iftmp.1 = 4;
  goto <D.19431>;
  <D.19430>:
  iftmp.1 = 2;
  <D.19431>:
  field_size = iftmp.1;
  goto <D.17628>;
  <D.17632>:
  D.19427 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19433 = D.19427 & 8388608;
  if (D.19433 != 0) goto <D.19434>; else goto <D.19435>;
  <D.19434>:
  iftmp.2 = 4;
  goto <D.19436>;
  <D.19435>:
  iftmp.2 = 2;
  <D.19436>:
  field_size = iftmp.2;
  goto <D.17628>;
  <D.17633>:
  D.19427 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19438 = D.19427 & 4194304;
  if (D.19438 != 0) goto <D.19439>; else goto <D.19440>;
  <D.19439>:
  iftmp.3 = 4;
  goto <D.19441>;
  <D.19440>:
  iftmp.3 = 2;
  <D.19441>:
  field_size = iftmp.3;
  goto <D.17628>;
  <D.17634>:
  switch (tableindex) <default: <D.17658>, case 2: <D.17655>, case 3: <D.17644>, case 5: <D.17650>, case 6: <D.17647>, case 7: <D.17652>, case 9: <D.17646>, case 15: <D.17638>, case 16: <D.17642>, case 18: <D.17639>, case 19: <D.17640>, case 21: <D.17653>, case 22: <D.17654>, case 24: <D.17649>, case 25: <D.17648>, case 28: <D.17645>, case 29: <D.17643>, case 36: <D.17637>, case 37: <D.17635>, case 39: <D.17641>, case 41: <D.17651>, case 42: <D.17656>, case 44: <D.17657>>
  <D.17635>:
  D.19442 = i != 3;
  D.19443 = (long int) D.19442;
  D.19444 = __builtin_expect (D.19443, 0);
  if (D.19444 != 0) goto <D.19445>; else goto <D.19446>;
  <D.19445>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.19446>:
  D.19448 = meta->tables[35].rows;
  D.19449 = (int) D.19448;
  if (D.19449 <= 65535) goto <D.19450>; else goto <D.19451>;
  <D.19450>:
  iftmp.4 = 2;
  goto <D.19452>;
  <D.19451>:
  iftmp.4 = 4;
  <D.19452>:
  field_size = iftmp.4;
  goto <D.17636>;
  <D.17637>:
  D.19453 = i != 1;
  D.19454 = (long int) D.19453;
  D.19455 = __builtin_expect (D.19454, 0);
  if (D.19455 != 0) goto <D.19456>; else goto <D.19457>;
  <D.19456>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.19457>:
  D.19448 = meta->tables[35].rows;
  D.19449 = (int) D.19448;
  if (D.19449 <= 65535) goto <D.19459>; else goto <D.19460>;
  <D.19459>:
  iftmp.5 = 2;
  goto <D.19461>;
  <D.19460>:
  iftmp.5 = 4;
  <D.19461>:
  field_size = iftmp.5;
  goto <D.17636>;
  <D.17638>:
  D.19462 = i != 2;
  D.19463 = (long int) D.19462;
  D.19464 = __builtin_expect (D.19463, 0);
  if (D.19464 != 0) goto <D.19465>; else goto <D.19466>;
  <D.19465>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.19466>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19470>; else goto <D.19471>;
  <D.19470>:
  iftmp.6 = 2;
  goto <D.19472>;
  <D.19471>:
  iftmp.6 = 4;
  <D.19472>:
  field_size = iftmp.6;
  goto <D.17636>;
  <D.17639>:
  i.7 = (unsigned int) i;
  D.19474 = i.7 > 1;
  D.19475 = (long int) D.19474;
  D.19476 = __builtin_expect (D.19475, 0);
  if (D.19476 != 0) goto <D.19477>; else goto <D.19478>;
  <D.19477>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.19478>:
  if (i != 0) goto <D.19480>; else goto <D.19481>;
  <D.19480>:
  D.19483 = meta->tables[20].rows;
  D.19484 = (int) D.19483;
  if (D.19484 <= 65535) goto <D.19485>; else goto <D.19486>;
  <D.19485>:
  iftmp.9 = 2;
  goto <D.19487>;
  <D.19486>:
  iftmp.9 = 4;
  <D.19487>:
  iftmp.8 = iftmp.9;
  goto <D.19488>;
  <D.19481>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19490>; else goto <D.19491>;
  <D.19490>:
  iftmp.10 = 2;
  goto <D.19492>;
  <D.19491>:
  iftmp.10 = 4;
  <D.19492>:
  iftmp.8 = iftmp.10;
  <D.19488>:
  field_size = iftmp.8;
  goto <D.17636>;
  <D.17640>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19496>; else goto <D.19497>;
  <D.19496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.19497>:
  D.19483 = meta->tables[20].rows;
  D.19484 = (int) D.19483;
  if (D.19484 <= 65535) goto <D.19499>; else goto <D.19500>;
  <D.19499>:
  iftmp.11 = 2;
  goto <D.19501>;
  <D.19500>:
  iftmp.11 = 4;
  <D.19501>:
  field_size = iftmp.11;
  goto <D.17636>;
  <D.17641>:
  D.19453 = i != 1;
  D.19454 = (long int) D.19453;
  D.19455 = __builtin_expect (D.19454, 0);
  if (D.19455 != 0) goto <D.19502>; else goto <D.19503>;
  <D.19502>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.19503>:
  field_size = 4;
  goto <D.17636>;
  <D.17642>:
  D.19453 = i != 1;
  D.19454 = (long int) D.19453;
  D.19455 = __builtin_expect (D.19454, 0);
  if (D.19455 != 0) goto <D.19504>; else goto <D.19505>;
  <D.19504>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.19505>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  if (D.19508 <= 65535) goto <D.19509>; else goto <D.19510>;
  <D.19509>:
  iftmp.12 = 2;
  goto <D.19511>;
  <D.19510>:
  iftmp.12 = 4;
  <D.19511>:
  field_size = iftmp.12;
  goto <D.17636>;
  <D.17643>:
  D.19453 = i != 1;
  D.19454 = (long int) D.19453;
  D.19455 = __builtin_expect (D.19454, 0);
  if (D.19455 != 0) goto <D.19512>; else goto <D.19513>;
  <D.19512>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.19513>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  if (D.19508 <= 65535) goto <D.19515>; else goto <D.19516>;
  <D.19515>:
  iftmp.13 = 2;
  goto <D.19517>;
  <D.19516>:
  iftmp.13 = 4;
  <D.19517>:
  field_size = iftmp.13;
  goto <D.17636>;
  <D.17644>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19518>; else goto <D.19519>;
  <D.19518>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.19519>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  if (D.19508 <= 65535) goto <D.19521>; else goto <D.19522>;
  <D.19521>:
  iftmp.14 = 2;
  goto <D.19523>;
  <D.19522>:
  iftmp.14 = 4;
  <D.19523>:
  field_size = iftmp.14;
  goto <D.17636>;
  <D.17645>:
  D.19442 = i != 3;
  D.19443 = (long int) D.19442;
  D.19444 = __builtin_expect (D.19443, 0);
  if (D.19444 != 0) goto <D.19524>; else goto <D.19525>;
  <D.19524>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.19525>:
  D.19527 = meta->tables[26].rows;
  D.19528 = (int) D.19527;
  if (D.19528 <= 65535) goto <D.19529>; else goto <D.19530>;
  <D.19529>:
  iftmp.15 = 2;
  goto <D.19531>;
  <D.19530>:
  iftmp.15 = 4;
  <D.19531>:
  field_size = iftmp.15;
  goto <D.17636>;
  <D.17646>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19532>; else goto <D.19533>;
  <D.19532>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.19533>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19535>; else goto <D.19536>;
  <D.19535>:
  iftmp.16 = 2;
  goto <D.19537>;
  <D.19536>:
  iftmp.16 = 4;
  <D.19537>:
  field_size = iftmp.16;
  goto <D.17636>;
  <D.17647>:
  D.19538 = i != 5;
  D.19539 = (long int) D.19538;
  D.19540 = __builtin_expect (D.19539, 0);
  if (D.19540 != 0) goto <D.19541>; else goto <D.19542>;
  <D.19541>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.19542>:
  D.19544 = meta->tables[8].rows;
  D.19545 = (int) D.19544;
  if (D.19545 <= 65535) goto <D.19546>; else goto <D.19547>;
  <D.19546>:
  iftmp.17 = 2;
  goto <D.19548>;
  <D.19547>:
  iftmp.17 = 4;
  <D.19548>:
  field_size = iftmp.17;
  goto <D.17636>;
  <D.17648>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19549>; else goto <D.19550>;
  <D.19549>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.19550>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19552>; else goto <D.19553>;
  <D.19552>:
  iftmp.18 = 2;
  goto <D.19554>;
  <D.19553>:
  iftmp.18 = 4;
  <D.19554>:
  field_size = iftmp.18;
  goto <D.17636>;
  <D.17649>:
  D.19453 = i != 1;
  D.19454 = (long int) D.19453;
  D.19455 = __builtin_expect (D.19454, 0);
  if (D.19455 != 0) goto <D.19555>; else goto <D.19556>;
  <D.19555>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.19556>:
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  if (D.19559 <= 65535) goto <D.19560>; else goto <D.19561>;
  <D.19560>:
  iftmp.19 = 2;
  goto <D.19562>;
  <D.19561>:
  iftmp.19 = 4;
  <D.19562>:
  field_size = iftmp.19;
  goto <D.17636>;
  <D.17650>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19563>; else goto <D.19564>;
  <D.19563>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.19564>:
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  if (D.19559 <= 65535) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  iftmp.20 = 2;
  goto <D.19568>;
  <D.19567>:
  iftmp.20 = 4;
  <D.19568>:
  field_size = iftmp.20;
  goto <D.17636>;
  <D.17651>:
  i.7 = (unsigned int) i;
  D.19474 = i.7 > 1;
  D.19475 = (long int) D.19474;
  D.19476 = __builtin_expect (D.19475, 0);
  if (D.19476 != 0) goto <D.19569>; else goto <D.19570>;
  <D.19569>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.19570>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19572>; else goto <D.19573>;
  <D.19572>:
  iftmp.21 = 2;
  goto <D.19574>;
  <D.19573>:
  iftmp.21 = 4;
  <D.19574>:
  field_size = iftmp.21;
  goto <D.17636>;
  <D.17652>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19575>; else goto <D.19576>;
  <D.19575>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.19576>:
  D.19544 = meta->tables[8].rows;
  D.19545 = (int) D.19544;
  if (D.19545 <= 65535) goto <D.19578>; else goto <D.19579>;
  <D.19578>:
  iftmp.22 = 2;
  goto <D.19580>;
  <D.19579>:
  iftmp.22 = 4;
  <D.19580>:
  field_size = iftmp.22;
  goto <D.17636>;
  <D.17653>:
  i.7 = (unsigned int) i;
  D.19474 = i.7 > 1;
  D.19475 = (long int) D.19474;
  D.19476 = __builtin_expect (D.19475, 0);
  if (D.19476 != 0) goto <D.19581>; else goto <D.19582>;
  <D.19581>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.19582>:
  if (i != 0) goto <D.19584>; else goto <D.19585>;
  <D.19584>:
  D.19587 = meta->tables[23].rows;
  D.19588 = (int) D.19587;
  if (D.19588 <= 65535) goto <D.19589>; else goto <D.19590>;
  <D.19589>:
  iftmp.24 = 2;
  goto <D.19591>;
  <D.19590>:
  iftmp.24 = 4;
  <D.19591>:
  iftmp.23 = iftmp.24;
  goto <D.19592>;
  <D.19585>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  if (D.19469 <= 65535) goto <D.19594>; else goto <D.19595>;
  <D.19594>:
  iftmp.25 = 2;
  goto <D.19596>;
  <D.19595>:
  iftmp.25 = 4;
  <D.19596>:
  iftmp.23 = iftmp.25;
  <D.19592>:
  field_size = iftmp.23;
  goto <D.17636>;
  <D.17654>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19597>; else goto <D.19598>;
  <D.19597>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.19598>:
  D.19587 = meta->tables[23].rows;
  D.19588 = (int) D.19587;
  if (D.19588 <= 65535) goto <D.19600>; else goto <D.19601>;
  <D.19600>:
  iftmp.26 = 2;
  goto <D.19602>;
  <D.19601>:
  iftmp.26 = 4;
  <D.19602>:
  field_size = iftmp.26;
  goto <D.17636>;
  <D.17655>:
  i.7 = (unsigned int) i;
  D.19603 = i.7 + 4294967292;
  D.19604 = D.19603 > 1;
  D.19605 = (long int) D.19604;
  D.19606 = __builtin_expect (D.19605, 0);
  if (D.19606 != 0) goto <D.19607>; else goto <D.19608>;
  <D.19607>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.19608>:
  if (i == 4) goto <D.19610>; else goto <D.19611>;
  <D.19610>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  if (D.19508 <= 65535) goto <D.19613>; else goto <D.19614>;
  <D.19613>:
  iftmp.28 = 2;
  goto <D.19615>;
  <D.19614>:
  iftmp.28 = 4;
  <D.19615>:
  iftmp.27 = iftmp.28;
  goto <D.19616>;
  <D.19611>:
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  if (D.19559 <= 65535) goto <D.19618>; else goto <D.19619>;
  <D.19618>:
  iftmp.29 = 2;
  goto <D.19620>;
  <D.19619>:
  iftmp.29 = 4;
  <D.19620>:
  iftmp.27 = iftmp.29;
  <D.19616>:
  field_size = iftmp.27;
  goto <D.17636>;
  <D.17656>:
  D.19462 = i != 2;
  D.19463 = (long int) D.19462;
  D.19464 = __builtin_expect (D.19463, 0);
  if (D.19464 != 0) goto <D.19621>; else goto <D.19622>;
  <D.19621>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.19622>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  n = MAX_EXPR <D.19469, D.19559>;
  if (n <= 32767) goto <D.19624>; else goto <D.19625>;
  <D.19624>:
  iftmp.30 = 2;
  goto <D.19626>;
  <D.19625>:
  iftmp.30 = 4;
  <D.19626>:
  field_size = iftmp.30;
  goto <D.17636>;
  <D.17657>:
  D.19493 = i != 0;
  D.19494 = (long int) D.19493;
  D.19495 = __builtin_expect (D.19494, 0);
  if (D.19495 != 0) goto <D.19627>; else goto <D.19628>;
  <D.19627>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.19628>:
  D.19630 = meta->tables[42].rows;
  D.19631 = (int) D.19630;
  if (D.19631 <= 65535) goto <D.19632>; else goto <D.19633>;
  <D.19632>:
  iftmp.31 = 2;
  goto <D.19634>;
  <D.19633>:
  iftmp.31 = 4;
  <D.19634>:
  field_size = iftmp.31;
  goto <D.17636>;
  <D.17658>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.17659>:
  goto <D.17659>;
  <D.17636>:
  goto <D.17628>;
  <D.17660>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  D.19544 = meta->tables[8].rows;
  D.19545 = (int) D.19544;
  n = MAX_EXPR <D.19508, D.19545>;
  D.19587 = meta->tables[23].rows;
  D.19588 = (int) D.19587;
  n = MAX_EXPR <D.19588, n>;
  if (n <= 16383) goto <D.19636>; else goto <D.19637>;
  <D.19636>:
  iftmp.32 = 2;
  goto <D.19638>;
  <D.19637>:
  iftmp.32 = 4;
  <D.19638>:
  field_size = iftmp.32;
  goto <D.17628>;
  <D.17661>:
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  n = MAX_EXPR <D.19508, D.19559>;
  D.19639 = meta->tables[1].rows;
  D.19640 = (int) D.19639;
  n = MAX_EXPR <D.19640, n>;
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  n = MAX_EXPR <D.19469, n>;
  D.19544 = meta->tables[8].rows;
  D.19545 = (int) D.19544;
  n = MAX_EXPR <D.19545, n>;
  D.19641 = meta->tables[9].rows;
  D.19642 = (int) D.19641;
  n = MAX_EXPR <D.19642, n>;
  D.19643 = meta->tables[10].rows;
  D.19644 = (int) D.19643;
  n = MAX_EXPR <D.19644, n>;
  D.19645 = meta->tables[0].rows;
  D.19646 = (int) D.19645;
  n = MAX_EXPR <D.19646, n>;
  D.19647 = meta->tables[14].rows;
  D.19648 = (int) D.19647;
  n = MAX_EXPR <D.19648, n>;
  D.19587 = meta->tables[23].rows;
  D.19588 = (int) D.19587;
  n = MAX_EXPR <D.19588, n>;
  D.19483 = meta->tables[20].rows;
  D.19484 = (int) D.19483;
  n = MAX_EXPR <D.19484, n>;
  D.19649 = meta->tables[17].rows;
  D.19650 = (int) D.19649;
  n = MAX_EXPR <D.19650, n>;
  D.19527 = meta->tables[26].rows;
  D.19528 = (int) D.19527;
  n = MAX_EXPR <D.19528, n>;
  D.19651 = meta->tables[27].rows;
  D.19652 = (int) D.19651;
  n = MAX_EXPR <D.19652, n>;
  D.19653 = meta->tables[32].rows;
  D.19654 = (int) D.19653;
  n = MAX_EXPR <D.19654, n>;
  D.19448 = meta->tables[35].rows;
  D.19449 = (int) D.19448;
  n = MAX_EXPR <D.19449, n>;
  D.19655 = meta->tables[38].rows;
  D.19656 = (int) D.19655;
  n = MAX_EXPR <D.19656, n>;
  D.19657 = meta->tables[39].rows;
  D.19658 = (int) D.19657;
  n = MAX_EXPR <D.19658, n>;
  D.19659 = meta->tables[40].rows;
  D.19660 = (int) D.19659;
  n = MAX_EXPR <D.19660, n>;
  if (n <= 2047) goto <D.19662>; else goto <D.19663>;
  <D.19662>:
  iftmp.33 = 2;
  goto <D.19664>;
  <D.19663>:
  iftmp.33 = 4;
  <D.19664>:
  field_size = iftmp.33;
  goto <D.17628>;
  <D.17662>:
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  D.19639 = meta->tables[1].rows;
  D.19640 = (int) D.19639;
  n = MAX_EXPR <D.19469, D.19640>;
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  n = MAX_EXPR <D.19559, n>;
  D.19643 = meta->tables[10].rows;
  D.19644 = (int) D.19643;
  n = MAX_EXPR <D.19644, n>;
  if (n <= 8191) goto <D.19666>; else goto <D.19667>;
  <D.19666>:
  iftmp.34 = 2;
  goto <D.19668>;
  <D.19667>:
  iftmp.34 = 4;
  <D.19668>:
  field_size = iftmp.34;
  goto <D.17628>;
  <D.17663>:
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  n = MAX_EXPR <D.19559, D.19469>;
  D.19653 = meta->tables[32].rows;
  D.19654 = (int) D.19653;
  n = MAX_EXPR <D.19654, n>;
  if (n <= 16383) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  iftmp.35 = 2;
  goto <D.19672>;
  <D.19671>:
  iftmp.35 = 4;
  <D.19672>:
  field_size = iftmp.35;
  goto <D.17628>;
  <D.17664>:
  D.19448 = meta->tables[35].rows;
  D.19449 = (int) D.19448;
  D.19655 = meta->tables[38].rows;
  D.19656 = (int) D.19655;
  n = MAX_EXPR <D.19449, D.19656>;
  D.19657 = meta->tables[39].rows;
  D.19658 = (int) D.19657;
  n = MAX_EXPR <D.19658, n>;
  if (n <= 16383) goto <D.19674>; else goto <D.19675>;
  <D.19674>:
  iftmp.36 = 2;
  goto <D.19676>;
  <D.19675>:
  iftmp.36 = 4;
  <D.19676>:
  field_size = iftmp.36;
  goto <D.17628>;
  <D.17665>:
  D.19544 = meta->tables[8].rows;
  D.19545 = (int) D.19544;
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  n = MAX_EXPR <D.19545, D.19508>;
  if (n <= 32767) goto <D.19678>; else goto <D.19679>;
  <D.19678>:
  iftmp.37 = 2;
  goto <D.19680>;
  <D.19679>:
  iftmp.37 = 4;
  <D.19680>:
  field_size = iftmp.37;
  goto <D.17628>;
  <D.17666>:
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  D.19507 = meta->tables[4].rows;
  D.19508 = (int) D.19507;
  n = MAX_EXPR <D.19559, D.19508>;
  if (n <= 32767) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  iftmp.38 = 2;
  goto <D.19684>;
  <D.19683>:
  iftmp.38 = 4;
  <D.19684>:
  field_size = iftmp.38;
  goto <D.17628>;
  <D.17667>:
  D.19639 = meta->tables[1].rows;
  D.19640 = (int) D.19639;
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  n = MAX_EXPR <D.19640, D.19469>;
  D.19651 = meta->tables[27].rows;
  D.19652 = (int) D.19651;
  n = MAX_EXPR <D.19652, n>;
  if (n <= 16383) goto <D.19686>; else goto <D.19687>;
  <D.19686>:
  iftmp.39 = 2;
  goto <D.19688>;
  <D.19687>:
  iftmp.39 = 4;
  <D.19688>:
  field_size = iftmp.39;
  goto <D.17628>;
  <D.17668>:
  D.19639 = meta->tables[1].rows;
  D.19640 = (int) D.19639;
  D.19468 = meta->tables[2].rows;
  D.19469 = (int) D.19468;
  n = MAX_EXPR <D.19640, D.19469>;
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  n = MAX_EXPR <D.19559, n>;
  D.19527 = meta->tables[26].rows;
  D.19528 = (int) D.19527;
  n = MAX_EXPR <D.19528, n>;
  D.19651 = meta->tables[27].rows;
  D.19652 = (int) D.19651;
  n = MAX_EXPR <D.19652, n>;
  if (n <= 8191) goto <D.19690>; else goto <D.19691>;
  <D.19690>:
  iftmp.40 = 2;
  goto <D.19692>;
  <D.19691>:
  iftmp.40 = 4;
  <D.19692>:
  field_size = iftmp.40;
  goto <D.17628>;
  <D.17669>:
  D.19643 = meta->tables[10].rows;
  D.19644 = (int) D.19643;
  D.19558 = meta->tables[6].rows;
  D.19559 = (int) D.19558;
  n = MAX_EXPR <D.19644, D.19559>;
  if (n <= 32767) goto <D.19694>; else goto <D.19695>;
  <D.19694>:
  iftmp.41 = 2;
  goto <D.19696>;
  <D.19695>:
  iftmp.41 = 4;
  <D.19696>:
  field_size = iftmp.41;
  goto <D.17628>;
  <D.17670>:
  D.19483 = meta->tables[20].rows;
  D.19484 = (int) D.19483;
  D.19587 = meta->tables[23].rows;
  D.19588 = (int) D.19587;
  n = MAX_EXPR <D.19484, D.19588>;
  if (n <= 32767) goto <D.19698>; else goto <D.19699>;
  <D.19698>:
  iftmp.42 = 2;
  goto <D.19700>;
  <D.19699>:
  iftmp.42 = 4;
  <D.19700>:
  field_size = iftmp.42;
  goto <D.17628>;
  <D.17671>:
  D.19527 = meta->tables[26].rows;
  D.19528 = (int) D.19527;
  D.19645 = meta->tables[0].rows;
  D.19646 = (int) D.19645;
  n = MAX_EXPR <D.19528, D.19646>;
  D.19448 = meta->tables[35].rows;
  D.19449 = (int) D.19448;
  n = MAX_EXPR <D.19449, n>;
  D.19639 = meta->tables[1].rows;
  D.19640 = (int) D.19639;
  n = MAX_EXPR <D.19640, n>;
  if (n <= 16383) goto <D.19702>; else goto <D.19703>;
  <D.19702>:
  iftmp.43 = 2;
  goto <D.19704>;
  <D.19703>:
  iftmp.43 = 4;
  <D.19704>:
  field_size = iftmp.43;
  goto <D.17628>;
  <D.19705>:
  <D.17628>:
  D.19706 = field_size + -1;
  D.19707 = D.19706 << shift;
  D.19708 = (unsigned int) D.19707;
  bitfield = D.19708 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.17673>:
  D.19709 = (sizetype) i;
  D.19710 = description + D.19709;
  D.19711 = *D.19710;
  code = (int) D.19711;
  if (code != 0) goto <D.17672>; else goto <D.17674>;
  <D.17674>:
  D.19712 = i << 24;
  D.19713 = (unsigned int) D.19712;
  D.19714 = D.19713 | bitfield;
  *result_bitfield = D.19714;
  D.19715 = size;
  return D.19715;
}


__attribute__((visibility ("hidden")))
mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  long unsigned int D.19717;
  long unsigned int D.19718;
  guint32 * D.19721;
  int D.19722;
  unsigned char D.19723;
  <unnamed-unsigned:24> D.19724;
  int D.19725;
  unsigned char D.19726;
  int D.19727;
  int D.19728;
  sizetype D.19729;
  int i;
  const char * base;

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

    table = &meta->tables[i];
    D.19717 = BIT_FIELD_REF <*table, 64, 64>;
    D.19718 = D.19717 & 18446742974197923840;
    if (D.19718 == 0) goto <D.19719>; else goto <D.19720>;
    <D.19719>:
    // predicted unlikely by continue predictor.
    goto <D.17681>;
    <D.19720>:
    D.19721 = &table->size_bitfield;
    D.19722 = mono_metadata_compute_size (meta, i, D.19721);
    D.19723 = (unsigned char) D.19722;
    table->row_size = D.19723;
    table->base = base;
    D.19724 = table->rows;
    D.19725 = (int) D.19724;
    D.19726 = table->row_size;
    D.19727 = (int) D.19726;
    D.19728 = D.19725 * D.19727;
    D.19729 = (sizetype) D.19728;
    base = base + D.19729;
  }
  <D.17681>:
  i = i + 1;
  <D.17683>:
  if (i <= 44) goto <D.17682>; else goto <D.17684>;
  <D.17684>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.19733;
  int D.19734;
  const char * D.19735;
  const char * D.19736;
  unsigned char D.19737;
  int D.19738;
  int D.19739;
  int D.19740;
  sizetype D.19741;

  if (idx <= 0) goto <D.19730>; else goto <D.19732>;
  <D.19732>:
  D.19733 = meta->tables[table].rows;
  D.19734 = (int) D.19733;
  if (D.19734 < idx) goto <D.19730>; else goto <D.19731>;
  <D.19730>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.19735 = "";
  return D.19735;
  <D.19731>:
  D.19736 = meta->tables[table].base;
  D.19737 = meta->tables[table].row_size;
  D.19738 = (int) D.19737;
  D.19739 = idx + -1;
  D.19740 = D.19738 * D.19739;
  D.19741 = (sizetype) D.19740;
  D.19735 = D.19736 + D.19741;
  return D.19735;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.19743;
  unsigned int D.19744;
  int D.19745;
  int token.44;
  int D.19747;

  D.19744 = token >> 24;
  D.19745 = (int) D.19744;
  token.44 = (int) token;
  D.19747 = token.44 & 16777215;
  D.19743 = mono_metadata_locate (meta, D.19745, D.19747);
  return D.19743;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19749;
  _Bool D.19750;
  long int D.19751;
  long int D.19752;
  const char * D.19757;
  const char * D.19758;
  sizetype D.19759;

  D.19749 = meta->heap_strings.size;
  D.19750 = D.19749 <= index;
  D.19751 = (long int) D.19750;
  D.19752 = __builtin_expect (D.19751, 0);
  if (D.19752 != 0) goto <D.19753>; else goto <D.19754>;
  <D.19753>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.19754>:
  D.19749 = meta->heap_strings.size;
  if (D.19749 <= index) goto <D.19755>; else goto <D.19756>;
  <D.19755>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.19757 = "";
  return D.19757;
  <D.19756>:
  D.19758 = meta->heap_strings.data;
  D.19759 = (sizetype) index;
  D.19757 = D.19758 + D.19759;
  return D.19757;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19761;
  _Bool D.19762;
  long int D.19763;
  long int D.19764;
  const char * D.19769;
  const char * D.19770;
  sizetype D.19771;

  D.19761 = meta->heap_us.size;
  D.19762 = D.19761 <= index;
  D.19763 = (long int) D.19762;
  D.19764 = __builtin_expect (D.19763, 0);
  if (D.19764 != 0) goto <D.19765>; else goto <D.19766>;
  <D.19765>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.19766>:
  D.19761 = meta->heap_us.size;
  if (D.19761 <= index) goto <D.19767>; else goto <D.19768>;
  <D.19767>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.19769 = "";
  return D.19769;
  <D.19768>:
  D.19770 = meta->heap_us.data;
  D.19771 = (sizetype) index;
  D.19769 = D.19770 + D.19771;
  return D.19769;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19773;
  _Bool D.19774;
  long int D.19775;
  long int D.19776;
  const char * D.19781;
  const char * D.19782;
  sizetype D.19783;

  D.19773 = meta->heap_blob.size;
  D.19774 = D.19773 <= index;
  D.19775 = (long int) D.19774;
  D.19776 = __builtin_expect (D.19775, 0);
  if (D.19776 != 0) goto <D.19777>; else goto <D.19778>;
  <D.19777>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.19778>:
  D.19773 = meta->heap_blob.size;
  if (D.19773 <= index) goto <D.19779>; else goto <D.19780>;
  <D.19779>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.19781 = "";
  return D.19781;
  <D.19780>:
  D.19782 = meta->heap_blob.data;
  D.19783 = (sizetype) index;
  D.19781 = D.19782 + D.19783;
  return D.19781;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19785;
  const char * D.19788;
  const char * D.19789;
  sizetype D.19790;

  index = index + 4294967295;
  index = index * 16;
  D.19785 = meta->heap_guid.size;
  if (D.19785 <= index) goto <D.19786>; else goto <D.19787>;
  <D.19786>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 933, "index < meta->heap_guid.size");
  D.19788 = "";
  return D.19788;
  <D.19787>:
  D.19789 = meta->heap_guid.data;
  D.19790 = (sizetype) index;
  D.19788 = D.19789 + D.19790;
  return D.19788;
}


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.19792;
  <unnamed-unsigned:24> D.19793;
  int D.19794;
  _Bool D.19795;
  long int D.19796;
  long int D.19797;
  _Bool D.19800;
  long int D.19801;
  long int D.19802;
  const char * D.19805;
  unsigned char D.19806;
  int D.19807;
  int D.19808;
  sizetype D.19809;
  _Bool D.19810;
  long int D.19811;
  long int D.19812;
  int D.19815;
  unsigned int D.19816;
  unsigned int D.19817;
  unsigned int D.19818;
  long unsigned int D.19819;
  long unsigned int D.19820;
  guint32 * D.19821;
  char D.19822;
  unsigned int D.19823;
  short unsigned int D.19824;
  short unsigned int D.19825;
  int D.19826;
  int D.19827;
  int D.19828;
  int D.19829;
  int D.19830;
  unsigned int D.19831;
  unsigned int D.19832;
  unsigned int D.19833;
  unsigned int D.19834;
  unsigned int D.19835;
  unsigned int D.19836;
  unsigned int D.19837;
  unsigned int D.19838;
  unsigned int D.19839;
  unsigned int D.19840;
  unsigned int D.19841;
  sizetype D.19842;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.19792 = bitfield >> 24;
  count = (int) D.19792;
  D.19793 = t->rows;
  D.19794 = (int) D.19793;
  D.19795 = D.19794 <= idx;
  D.19796 = (long int) D.19795;
  D.19797 = __builtin_expect (D.19796, 0);
  if (D.19797 != 0) goto <D.19798>; else goto <D.19799>;
  <D.19798>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.19799>:
  D.19800 = idx < 0;
  D.19801 = (long int) D.19800;
  D.19802 = __builtin_expect (D.19801, 0);
  if (D.19802 != 0) goto <D.19803>; else goto <D.19804>;
  <D.19803>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.19804>:
  D.19805 = t->base;
  D.19806 = t->row_size;
  D.19807 = (int) D.19806;
  D.19808 = D.19807 * idx;
  D.19809 = (sizetype) D.19808;
  data = D.19805 + D.19809;
  D.19810 = res_size != count;
  D.19811 = (long int) D.19810;
  D.19812 = __builtin_expect (D.19811, 0);
  if (D.19812 != 0) goto <D.19813>; else goto <D.19814>;
  <D.19813>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.19814>:
  i = 0;
  goto <D.17730>;
  <D.17729>:
  {
    int n;

    D.19815 = i * 2;
    D.19816 = bitfield >> D.19815;
    D.19817 = D.19816 & 3;
    D.19818 = D.19817 + 1;
    n = (int) D.19818;
    switch (n) <default: <D.17728>, case 1: <D.17724>, case 2: <D.17726>, case 4: <D.17727>>
    <D.17724>:
    D.19819 = (long unsigned int) i;
    D.19820 = D.19819 * 4;
    D.19821 = res + D.19820;
    D.19822 = *data;
    D.19823 = (unsigned int) D.19822;
    *D.19821 = D.19823;
    goto <D.17725>;
    <D.17726>:
    D.19819 = (long unsigned int) i;
    D.19820 = D.19819 * 4;
    D.19821 = res + D.19820;
    D.19824 = MEM[(const guint16 *)data];
    D.19825 = D.19824 >> 8;
    D.19826 = (int) D.19825;
    D.19824 = MEM[(const guint16 *)data];
    D.19827 = (int) D.19824;
    D.19828 = D.19827 << 8;
    D.19829 = D.19828 & 65535;
    D.19830 = D.19826 | D.19829;
    D.19831 = (unsigned int) D.19830;
    *D.19821 = D.19831;
    goto <D.17725>;
    <D.17727>:
    D.19819 = (long unsigned int) i;
    D.19820 = D.19819 * 4;
    D.19821 = res + D.19820;
    D.19832 = MEM[(const guint32 *)data];
    D.19833 = D.19832 << 24;
    D.19832 = MEM[(const guint32 *)data];
    D.19834 = D.19832 >> 8;
    D.19835 = D.19834 & 65280;
    D.19836 = D.19833 | D.19835;
    D.19832 = MEM[(const guint32 *)data];
    D.19837 = D.19832 << 8;
    D.19838 = D.19837 & 16711680;
    D.19839 = D.19836 | D.19838;
    D.19832 = MEM[(const guint32 *)data];
    D.19840 = D.19832 >> 24;
    D.19841 = D.19839 | D.19840;
    *D.19821 = D.19841;
    goto <D.17725>;
    <D.17728>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.17725>:
    D.19842 = (sizetype) n;
    data = data + D.19842;
  }
  i = i + 1;
  <D.17730>:
  if (i < count) goto <D.17729>; else goto <D.17731>;
  <D.17731>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.19843;
  int D.19844;
  _Bool D.19845;
  long int D.19846;
  long int D.19847;
  unsigned int D.19850;
  _Bool D.19851;
  long int D.19852;
  long int D.19853;
  const char * D.19856;
  unsigned char D.19857;
  int D.19858;
  int D.19859;
  sizetype D.19860;
  unsigned int D.19861;
  unsigned int D.19862;
  sizetype D.19863;
  int D.19864;
  int D.19865;
  unsigned int D.19866;
  unsigned int D.19867;
  unsigned int D.19868;
  unsigned int i.45;
  uint32_t D.19870;
  char D.19871;
  short unsigned int D.19872;
  short unsigned int D.19873;
  int D.19874;
  int D.19875;
  int D.19876;
  int D.19877;
  int D.19878;
  unsigned int D.19879;
  unsigned int D.19880;
  unsigned int D.19881;
  unsigned int D.19882;
  unsigned int D.19883;
  unsigned int D.19884;
  unsigned int D.19885;
  unsigned int D.19886;
  unsigned int D.19887;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.19843 = t->rows;
  D.19844 = (int) D.19843;
  D.19845 = D.19844 <= idx;
  D.19846 = (long int) D.19845;
  D.19847 = __builtin_expect (D.19846, 0);
  if (D.19847 != 0) goto <D.19848>; else goto <D.19849>;
  <D.19848>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.19849>:
  D.19850 = bitfield >> 24;
  D.19851 = D.19850 <= col;
  D.19852 = (long int) D.19851;
  D.19853 = __builtin_expect (D.19852, 0);
  if (D.19853 != 0) goto <D.19854>; else goto <D.19855>;
  <D.19854>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.19855>:
  D.19856 = t->base;
  D.19857 = t->row_size;
  D.19858 = (int) D.19857;
  D.19859 = D.19858 * idx;
  D.19860 = (sizetype) D.19859;
  data = D.19856 + D.19860;
  D.19861 = bitfield & 3;
  D.19862 = D.19861 + 1;
  n = (int) D.19862;
  i = 0;
  goto <D.17742>;
  <D.17741>:
  D.19863 = (sizetype) n;
  data = data + D.19863;
  D.19864 = i + 1;
  D.19865 = D.19864 * 2;
  D.19866 = bitfield >> D.19865;
  D.19867 = D.19866 & 3;
  D.19868 = D.19867 + 1;
  n = (int) D.19868;
  i = i + 1;
  <D.17742>:
  i.45 = (unsigned int) i;
  if (i.45 < col) goto <D.17741>; else goto <D.17743>;
  <D.17743>:
  switch (n) <default: <D.17747>, case 1: <D.17744>, case 2: <D.17745>, case 4: <D.17746>>
  <D.17744>:
  D.19871 = *data;
  D.19870 = (uint32_t) D.19871;
  return D.19870;
  <D.17745>:
  D.19872 = MEM[(const guint16 *)data];
  D.19873 = D.19872 >> 8;
  D.19874 = (int) D.19873;
  D.19872 = MEM[(const guint16 *)data];
  D.19875 = (int) D.19872;
  D.19876 = D.19875 << 8;
  D.19877 = D.19876 & 65535;
  D.19878 = D.19874 | D.19877;
  D.19870 = (uint32_t) D.19878;
  return D.19870;
  <D.17746>:
  D.19879 = MEM[(const guint32 *)data];
  D.19880 = D.19879 << 24;
  D.19879 = MEM[(const guint32 *)data];
  D.19881 = D.19879 >> 8;
  D.19882 = D.19881 & 65280;
  D.19883 = D.19880 | D.19882;
  D.19879 = MEM[(const guint32 *)data];
  D.19884 = D.19879 << 8;
  D.19885 = D.19884 & 16711680;
  D.19886 = D.19883 | D.19885;
  D.19879 = MEM[(const guint32 *)data];
  D.19887 = D.19879 >> 24;
  D.19870 = D.19886 | D.19887;
  return D.19870;
  <D.17747>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.19870 = 0;
  return D.19870;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.19889;
  signed char D.19890;
  unsigned int D.19893;
  int D.19895;
  int D.19896;
  int D.19899;
  int D.19900;
  const unsigned char * D.19901;
  unsigned char D.19902;
  int D.19903;
  int D.19904;
  int D.19906;
  int D.19907;
  int D.19908;
  int D.19909;
  const unsigned char * D.19910;
  unsigned char D.19911;
  int D.19912;
  int D.19913;
  int D.19914;
  const unsigned char * D.19915;
  unsigned char D.19916;
  int D.19917;
  int D.19918;
  uint32_t D.19921;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.19889 = *ptr;
  D.19890 = (signed char) D.19889;
  if (D.19890 >= 0) goto <D.19891>; else goto <D.19892>;
  <D.19891>:
  D.19889 = *ptr;
  D.19893 = (unsigned int) D.19889;
  size = D.19893 & 127;
  ptr = ptr + 1;
  goto <D.19894>;
  <D.19892>:
  D.19889 = *ptr;
  D.19895 = (int) D.19889;
  D.19896 = D.19895 & 64;
  if (D.19896 == 0) goto <D.19897>; else goto <D.19898>;
  <D.19897>:
  D.19889 = *ptr;
  D.19895 = (int) D.19889;
  D.19899 = D.19895 << 8;
  D.19900 = D.19899 & 16128;
  D.19901 = ptr + 1;
  D.19902 = *D.19901;
  D.19903 = (int) D.19902;
  D.19904 = D.19900 + D.19903;
  size = (guint32) D.19904;
  ptr = ptr + 2;
  goto <D.19905>;
  <D.19898>:
  D.19889 = *ptr;
  D.19895 = (int) D.19889;
  D.19906 = D.19895 << 24;
  D.19907 = D.19906 & 520093696;
  D.19901 = ptr + 1;
  D.19902 = *D.19901;
  D.19903 = (int) D.19902;
  D.19908 = D.19903 << 16;
  D.19909 = D.19907 + D.19908;
  D.19910 = ptr + 2;
  D.19911 = *D.19910;
  D.19912 = (int) D.19911;
  D.19913 = D.19912 << 8;
  D.19914 = D.19909 + D.19913;
  D.19915 = ptr + 3;
  D.19916 = *D.19915;
  D.19917 = (int) D.19916;
  D.19918 = D.19914 + D.19917;
  size = (guint32) D.19918;
  ptr = ptr + 4;
  <D.19905>:
  <D.19894>:
  if (rptr != 0B) goto <D.19919>; else goto <D.19920>;
  <D.19919>:
  *rptr = ptr;
  <D.19920>:
  D.19921 = size;
  return D.19921;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.46;
  int D.19927;
  int D.19928;
  int D.19931;
  int D.19932;
  const unsigned char * D.19933;
  unsigned char D.19934;
  int D.19935;
  int D.19936;
  int D.19938;
  int D.19939;
  int D.19940;
  int D.19941;
  const unsigned char * D.19942;
  unsigned char D.19943;
  int D.19944;
  int D.19945;
  int D.19946;
  const unsigned char * D.19947;
  unsigned char D.19948;
  int D.19949;
  int D.19950;
  uint32_t D.19953;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.46 = (signed char) b;
  if (b.46 >= 0) goto <D.19924>; else goto <D.19925>;
  <D.19924>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.19926>;
  <D.19925>:
  D.19927 = (int) b;
  D.19928 = D.19927 & 64;
  if (D.19928 == 0) goto <D.19929>; else goto <D.19930>;
  <D.19929>:
  D.19927 = (int) b;
  D.19931 = D.19927 << 8;
  D.19932 = D.19931 & 16128;
  D.19933 = ptr + 1;
  D.19934 = *D.19933;
  D.19935 = (int) D.19934;
  D.19936 = D.19932 | D.19935;
  len = (guint32) D.19936;
  ptr = ptr + 2;
  goto <D.19937>;
  <D.19930>:
  D.19927 = (int) b;
  D.19938 = D.19927 << 24;
  D.19939 = D.19938 & 520093696;
  D.19933 = ptr + 1;
  D.19934 = *D.19933;
  D.19935 = (int) D.19934;
  D.19940 = D.19935 << 16;
  D.19941 = D.19939 | D.19940;
  D.19942 = ptr + 2;
  D.19943 = *D.19942;
  D.19944 = (int) D.19943;
  D.19945 = D.19944 << 8;
  D.19946 = D.19941 | D.19945;
  D.19947 = ptr + 3;
  D.19948 = *D.19947;
  D.19949 = (int) D.19948;
  D.19950 = D.19946 | D.19949;
  len = (guint32) D.19950;
  ptr = ptr + 4;
  <D.19937>:
  <D.19926>:
  if (rptr != 0B) goto <D.19951>; else goto <D.19952>;
  <D.19951>:
  *rptr = ptr;
  <D.19952>:
  D.19953 = len;
  return D.19953;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.19955;
  unsigned int D.19956;
  int32_t D.19959;
  _Bool D.19966;
  long int D.19967;
  long int D.19968;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.19955 = uval >> 1;
  ival = (gint32) D.19955;
  D.19956 = uval & 1;
  if (D.19956 == 0) goto <D.19957>; else goto <D.19958>;
  <D.19957>:
  D.19959 = ival;
  return D.19959;
  <D.19958>:
  if (ival <= 63) goto <D.19960>; else goto <D.19961>;
  <D.19960>:
  D.19959 = ival + -64;
  return D.19959;
  <D.19961>:
  if (ival <= 8191) goto <D.19962>; else goto <D.19963>;
  <D.19962>:
  D.19959 = ival + -8192;
  return D.19959;
  <D.19963>:
  if (ival <= 268435455) goto <D.19964>; else goto <D.19965>;
  <D.19964>:
  D.19959 = ival + -268435456;
  return D.19959;
  <D.19965>:
  D.19966 = ival > 536870911;
  D.19967 = (long int) D.19966;
  D.19968 = __builtin_expect (D.19967, 0);
  if (D.19968 != 0) goto <D.19969>; else goto <D.19970>;
  <D.19969>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1121, "ival < 0x20000000");
  <D.19970>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.19959 = ival + -536870912;
  return D.19959;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  long unsigned int D.19972;
  long unsigned int D.19973;
  uint32_t D.19976;
  long unsigned int D.19977;
  long unsigned int D.19978;
  struct MonoTableInfo * D.19981;
  unsigned int D.19982;
  int D.19983;
  long unsigned int D.19984;
  long unsigned int D.19985;
  struct MonoTableInfo * D.19988;
  long unsigned int D.19989;
  long unsigned int D.19990;
  struct MonoTableInfo * D.19993;
  long unsigned int D.19994;
  long unsigned int D.19995;
  struct MonoTableInfo * D.19998;
  long unsigned int D.19999;
  long unsigned int D.20000;
  struct MonoTableInfo * D.20003;

  D.19972 = BIT_FIELD_REF <*image, 64, 192>;
  D.19973 = D.19972 & 67108864;
  if (D.19973 == 0) goto <D.19974>; else goto <D.19975>;
  <D.19974>:
  D.19976 = idx;
  return D.19976;
  <D.19975>:
  switch (table) <default: <D.17777>, case 4: <D.17773>, case 6: <D.17772>, case 8: <D.17776>, case 20: <D.17774>, case 23: <D.17775>>
  <D.17772>:
  D.19977 = BIT_FIELD_REF <*image, 64, 2240>;
  D.19978 = D.19977 & 18446742974197923840;
  if (D.19978 != 0) goto <D.19979>; else goto <D.19980>;
  <D.19979>:
  D.19981 = &image->tables[5];
  D.19982 = idx + 4294967295;
  D.19983 = (int) D.19982;
  D.19976 = mono_metadata_decode_row_col (D.19981, D.19983, 0);
  return D.19976;
  <D.19980>:
  D.19976 = idx;
  return D.19976;
  <D.17773>:
  D.19984 = BIT_FIELD_REF <*image, 64, 1984>;
  D.19985 = D.19984 & 18446742974197923840;
  if (D.19985 != 0) goto <D.19986>; else goto <D.19987>;
  <D.19986>:
  D.19988 = &image->tables[3];
  D.19982 = idx + 4294967295;
  D.19983 = (int) D.19982;
  D.19976 = mono_metadata_decode_row_col (D.19988, D.19983, 0);
  return D.19976;
  <D.19987>:
  D.19976 = idx;
  return D.19976;
  <D.17774>:
  D.19989 = BIT_FIELD_REF <*image, 64, 4032>;
  D.19990 = D.19989 & 18446742974197923840;
  if (D.19990 != 0) goto <D.19991>; else goto <D.19992>;
  <D.19991>:
  D.19993 = &image->tables[19];
  D.19982 = idx + 4294967295;
  D.19983 = (int) D.19982;
  D.19976 = mono_metadata_decode_row_col (D.19993, D.19983, 0);
  return D.19976;
  <D.19992>:
  D.19976 = idx;
  return D.19976;
  <D.17775>:
  D.19994 = BIT_FIELD_REF <*image, 64, 4416>;
  D.19995 = D.19994 & 18446742974197923840;
  if (D.19995 != 0) goto <D.19996>; else goto <D.19997>;
  <D.19996>:
  D.19998 = &image->tables[22];
  D.19982 = idx + 4294967295;
  D.19983 = (int) D.19982;
  D.19976 = mono_metadata_decode_row_col (D.19998, D.19983, 0);
  return D.19976;
  <D.19997>:
  D.19976 = idx;
  return D.19976;
  <D.17776>:
  D.19999 = BIT_FIELD_REF <*image, 64, 2496>;
  D.20000 = D.19999 & 18446742974197923840;
  if (D.20000 != 0) goto <D.20001>; else goto <D.20002>;
  <D.20001>:
  D.20003 = &image->tables[7];
  D.19982 = idx + 4294967295;
  D.19983 = (int) D.19982;
  D.19976 = mono_metadata_decode_row_col (D.20003, D.19983, 0);
  return D.19976;
  <D.20002>:
  D.19976 = idx;
  return D.19976;
  <D.17777>:
  D.19976 = idx;
  return D.19976;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  long unsigned int D.20005;
  long unsigned int D.20006;
  int D.20009;
  unsigned int D.20010;
  unsigned int D.20011;
  unsigned int D.20012;
  struct MonoTableInfo * D.20013;

  D.20005 = BIT_FIELD_REF <*image, 64, 192>;
  D.20006 = D.20005 & 67108864;
  if (D.20006 != 0) goto <D.20007>; else goto <D.20008>;
  <D.20007>:
  D.20009 = idx + 1;
  D.20010 = (unsigned int) D.20009;
  D.20011 = mono_metadata_translate_token_index (image, table, D.20010);
  D.20012 = D.20011 + 4294967295;
  idx = (int) D.20012;
  <D.20008>:
  D.20013 = &image->tables[table];
  mono_metadata_decode_row (D.20013, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  long unsigned int D.20014;
  long unsigned int D.20015;
  int D.20018;
  unsigned int D.20019;
  unsigned int D.20020;
  unsigned int D.20021;
  uint32_t D.20022;
  struct MonoTableInfo * D.20023;

  D.20014 = BIT_FIELD_REF <*image, 64, 192>;
  D.20015 = D.20014 & 67108864;
  if (D.20015 != 0) goto <D.20016>; else goto <D.20017>;
  <D.20016>:
  D.20018 = idx + 1;
  D.20019 = (unsigned int) D.20018;
  D.20020 = mono_metadata_translate_token_index (image, table, D.20019);
  D.20021 = D.20020 + 4294967295;
  idx = (int) D.20021;
  <D.20017>:
  D.20023 = &image->tables[table];
  D.20022 = mono_metadata_decode_row_col (D.20023, idx, col);
  return D.20022;
}


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

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


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.20030;
  char D.20031;
  _Bool D.20036;
  const char * D.20037;
  unsigned int D.20038;
  <unnamed-unsigned:31> D.20039;
  int D.20040;
  struct MonoCustomMod local;

  try
    {
      D.20030 = *ptr;
      D.20031 = D.20030 + 225;
      if (D.20031 <= 1) goto <D.20032>; else goto <D.20033>;
      <D.20032>:
      if (dest == 0B) goto <D.20034>; else goto <D.20035>;
      <D.20034>:
      dest = &local;
      <D.20035>:
      D.20030 = *ptr;
      D.20036 = D.20030 == 31;
      dest->required = D.20036;
      D.20037 = ptr + 1;
      D.20038 = mono_metadata_parse_typedef_or_ref (m, D.20037, rptr);
      D.20039 = (<unnamed-unsigned:31>) D.20038;
      dest->token = D.20039;
      D.20040 = 1;
      return D.20040;
      <D.20033>:
      D.20040 = 0;
      return D.20040;
    }
  finally
    {
      local = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_metadata_parse_array_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  struct MonoArrayType * D.20043;

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


mono_metadata_parse_array_internal (struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  void * iftmp.48;
  const char * ptr.49;
  struct MonoArrayType * D.20052;
  struct MonoClass * D.20053;
  unsigned int D.20054;
  unsigned char D.20055;
  unsigned int D.20056;
  unsigned char D.20057;
  unsigned char D.20058;
  void * iftmp.50;
  long unsigned int D.20064;
  long unsigned int D.20065;
  unsigned int D.20067;
  unsigned int D.20068;
  int * D.20069;
  long unsigned int D.20070;
  long unsigned int D.20071;
  int * D.20072;
  unsigned int D.20073;
  int D.20074;
  int D.20075;
  unsigned int D.20076;
  unsigned char D.20077;
  unsigned char D.20078;
  void * iftmp.51;
  long unsigned int D.20084;
  long unsigned int D.20085;
  unsigned int D.20087;
  unsigned int D.20088;
  int * D.20089;
  int * D.20090;
  int D.20091;
  int D.20092;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.20046>; else goto <D.20047>;
  <D.20046>:
  iftmp.48 = monoeg_malloc0 (32);
  goto <D.20048>;
  <D.20047>:
  iftmp.48 = mono_image_alloc0 (m, 32);
  <D.20048>:
  array = iftmp.48;
  ptr.49 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.49, &ptr);
  if (etype == 0B) goto <D.20050>; else goto <D.20051>;
  <D.20050>:
  D.20052 = 0B;
  return D.20052;
  <D.20051>:
  D.20053 = mono_class_from_mono_type (etype);
  array->eklass = D.20053;
  ptr.49 = ptr;
  D.20054 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20055 = (unsigned char) D.20054;
  array->rank = D.20055;
  ptr.49 = ptr;
  D.20056 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20057 = (unsigned char) D.20056;
  array->numsizes = D.20057;
  D.20058 = array->numsizes;
  if (D.20058 != 0) goto <D.20059>; else goto <D.20060>;
  <D.20059>:
  if (transient != 0) goto <D.20062>; else goto <D.20063>;
  <D.20062>:
  D.20058 = array->numsizes;
  D.20064 = (long unsigned int) D.20058;
  D.20065 = D.20064 * 4;
  iftmp.50 = monoeg_malloc0 (D.20065);
  goto <D.20066>;
  <D.20063>:
  D.20058 = array->numsizes;
  D.20067 = (unsigned int) D.20058;
  D.20068 = D.20067 * 4;
  iftmp.50 = mono_image_alloc0 (m, D.20068);
  <D.20066>:
  array->sizes = iftmp.50;
  <D.20060>:
  i = 0;
  goto <D.17815>;
  <D.17814>:
  D.20069 = array->sizes;
  D.20070 = (long unsigned int) i;
  D.20071 = D.20070 * 4;
  D.20072 = D.20069 + D.20071;
  ptr.49 = ptr;
  D.20073 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20074 = (int) D.20073;
  *D.20072 = D.20074;
  i = i + 1;
  <D.17815>:
  D.20058 = array->numsizes;
  D.20075 = (int) D.20058;
  if (D.20075 > i) goto <D.17814>; else goto <D.17816>;
  <D.17816>:
  ptr.49 = ptr;
  D.20076 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20077 = (unsigned char) D.20076;
  array->numlobounds = D.20077;
  D.20078 = array->numlobounds;
  if (D.20078 != 0) goto <D.20079>; else goto <D.20080>;
  <D.20079>:
  if (transient != 0) goto <D.20082>; else goto <D.20083>;
  <D.20082>:
  D.20078 = array->numlobounds;
  D.20084 = (long unsigned int) D.20078;
  D.20085 = D.20084 * 4;
  iftmp.51 = monoeg_malloc0 (D.20085);
  goto <D.20086>;
  <D.20083>:
  D.20078 = array->numlobounds;
  D.20087 = (unsigned int) D.20078;
  D.20088 = D.20087 * 4;
  iftmp.51 = mono_image_alloc0 (m, D.20088);
  <D.20086>:
  array->lobounds = iftmp.51;
  <D.20080>:
  i = 0;
  goto <D.17818>;
  <D.17817>:
  D.20089 = array->lobounds;
  D.20070 = (long unsigned int) i;
  D.20071 = D.20070 * 4;
  D.20090 = D.20089 + D.20071;
  ptr.49 = ptr;
  D.20091 = mono_metadata_decode_signed_value (ptr.49, &ptr);
  *D.20090 = D.20091;
  i = i + 1;
  <D.17818>:
  D.20078 = array->numlobounds;
  D.20092 = (int) D.20078;
  if (D.20092 > i) goto <D.17817>; else goto <D.17819>;
  <D.17819>:
  if (rptr != 0B) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  ptr.49 = ptr;
  *rptr = ptr.49;
  <D.20094>:
  D.20052 = array;
  return D.20052;
}


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

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


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.20098;
  int * D.20099;

  D.20098 = array->sizes;
  monoeg_g_free (D.20098);
  D.20099 = array->lobounds;
  monoeg_g_free (D.20099);
  monoeg_g_free (array);
}


__attribute__((visibility ("hidden")))
mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.20100;
  unsigned int D.20101;
  <unnamed-unsigned:22> D.20102;
  int D.20103;
  guint D.20104;
  <unnamed-unsigned:1> D.20105;
  int D.20106;
  int D.20107;
  unsigned int D.20108;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.17858>;
  <D.17857>:
  hash = hash * 13;
  D.20100 = ginst->type_argv[i];
  D.20101 = mono_metadata_type_hash (D.20100);
  hash = D.20101 + hash;
  i = i + 1;
  <D.17858>:
  D.20102 = ginst->type_argc;
  D.20103 = (int) D.20102;
  if (D.20103 > i) goto <D.17857>; else goto <D.17859>;
  <D.17859>:
  D.20105 = ginst->is_open;
  D.20106 = (int) D.20105;
  D.20107 = D.20106 << 8;
  D.20108 = (unsigned int) D.20107;
  D.20104 = D.20108 ^ hash;
  return D.20104;
}


__attribute__((visibility ("hidden")))
mono_metadata_generic_inst_equal (const void * ka, const void * kb)
{
  gboolean D.20110;
  const struct MonoGenericInst * a;
  const struct MonoGenericInst * b;

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


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.20112;
  unsigned int D.20115;
  gboolean D.20120;
  long unsigned int D.20123;
  long unsigned int D.20124;
  long unsigned int D.20125;
  long unsigned int D.20126;
  struct MonoType * D.20129;
  struct MonoType * D.20130;
  int D.20131;
  <unnamed-unsigned:22> D.20134;
  int D.20135;
  int i;

  D.20112 = a->id;
  if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
  <D.20113>:
  D.20115 = b->id;
  if (D.20115 != 0) goto <D.20116>; else goto <D.20117>;
  <D.20116>:
  D.20112 = a->id;
  D.20115 = b->id;
  if (D.20112 == D.20115) goto <D.20118>; else goto <D.20119>;
  <D.20118>:
  D.20120 = 1;
  return D.20120;
  <D.20119>:
  if (signature_only == 0) goto <D.20121>; else goto <D.20122>;
  <D.20121>:
  D.20120 = 0;
  return D.20120;
  <D.20122>:
  <D.20117>:
  <D.20114>:
  D.20123 = BIT_FIELD_REF <*a, 64, 0>;
  D.20124 = BIT_FIELD_REF <*b, 64, 0>;
  D.20125 = D.20123 ^ D.20124;
  D.20126 = D.20125 & 4294966784;
  if (D.20126 != 0) goto <D.20127>; else goto <D.20128>;
  <D.20127>:
  D.20120 = 0;
  return D.20120;
  <D.20128>:
  i = 0;
  goto <D.17867>;
  <D.17866>:
  D.20129 = a->type_argv[i];
  D.20130 = b->type_argv[i];
  D.20131 = do_mono_metadata_type_equal (D.20129, D.20130, signature_only);
  if (D.20131 == 0) goto <D.20132>; else goto <D.20133>;
  <D.20132>:
  D.20120 = 0;
  return D.20120;
  <D.20133>:
  i = i + 1;
  <D.17867>:
  D.20134 = a->type_argc;
  D.20135 = (int) D.20134;
  if (D.20135 > i) goto <D.17866>; else goto <D.17868>;
  <D.17868>:
  D.20120 = 1;
  return D.20120;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.20139;
  unsigned char D.20140;
  long unsigned int D.20142;
  long unsigned int D.20143;
  long unsigned int D.20144;
  long unsigned int D.20145;
  gboolean D.20146;
  int D.20147;
  struct MonoClass * D.20148;
  struct MonoClass * D.20149;
  struct MonoType * D.20150;
  struct MonoType * D.20151;
  struct MonoArrayType * D.20152;
  unsigned char D.20153;
  struct MonoArrayType * D.20154;
  unsigned char D.20155;
  struct MonoClass * D.20158;
  struct MonoClass * D.20159;
  struct MonoGenericClass * D.20160;
  struct MonoGenericClass * D.20161;
  struct MonoGenericParam * D.20162;
  struct MonoGenericParam * D.20163;
  struct MonoMethodSignature * D.20164;
  struct MonoMethodSignature * D.20165;

  D.20139 = t1->type;
  D.20140 = t2->type;
  if (D.20139 != D.20140) goto <D.20137>; else goto <D.20141>;
  <D.20141>:
  D.20142 = BIT_FIELD_REF <*t1, 64, 64>;
  D.20143 = BIT_FIELD_REF <*t2, 64, 64>;
  D.20144 = D.20142 ^ D.20143;
  D.20145 = D.20144 & 8589934592;
  if (D.20145 != 0) goto <D.20137>; else goto <D.20138>;
  <D.20137>:
  D.20146 = 0;
  return D.20146;
  <D.20138>:
  D.20139 = t1->type;
  D.20147 = (int) D.20139;
  switch (D.20147) <default: <D.18977>, case 1: <D.18950>, case 2: <D.18951>, case 3: <D.18952>, case 4: <D.18953>, case 5: <D.18954>, case 6: <D.18955>, case 7: <D.18956>, case 8: <D.18957>, case 9: <D.18958>, case 10: <D.18959>, case 11: <D.18960>, case 12: <D.18961>, case 13: <D.18962>, case 14: <D.18963>, case 15: <D.18971>, case 17: <D.18968>, case 18: <D.18969>, case 19: <D.18974>, case 20: <D.18972>, case 21: <D.18973>, case 22: <D.18967>, case 24: <D.18964>, case 25: <D.18965>, case 27: <D.18976>, case 28: <D.18966>, case 29: <D.18970>, case 30: <D.18975>>
  <D.18950>:
  <D.18951>:
  <D.18952>:
  <D.18953>:
  <D.18954>:
  <D.18955>:
  <D.18956>:
  <D.18957>:
  <D.18958>:
  <D.18959>:
  <D.18960>:
  <D.18961>:
  <D.18962>:
  <D.18963>:
  <D.18964>:
  <D.18965>:
  <D.18966>:
  <D.18967>:
  D.20146 = 1;
  return D.20146;
  <D.18968>:
  <D.18969>:
  <D.18970>:
  D.20148 = t1->data.klass;
  D.20149 = t2->data.klass;
  D.20146 = mono_metadata_class_equal (D.20148, D.20149, signature_only);
  return D.20146;
  <D.18971>:
  D.20150 = t1->data.type;
  D.20151 = t2->data.type;
  D.20146 = do_mono_metadata_type_equal (D.20150, D.20151, signature_only);
  return D.20146;
  <D.18972>:
  D.20152 = t1->data.array;
  D.20153 = D.20152->rank;
  D.20154 = t2->data.array;
  D.20155 = D.20154->rank;
  if (D.20153 != D.20155) goto <D.20156>; else goto <D.20157>;
  <D.20156>:
  D.20146 = 0;
  return D.20146;
  <D.20157>:
  D.20152 = t1->data.array;
  D.20158 = D.20152->eklass;
  D.20154 = t2->data.array;
  D.20159 = D.20154->eklass;
  D.20146 = mono_metadata_class_equal (D.20158, D.20159, signature_only);
  return D.20146;
  <D.18973>:
  D.20160 = t1->data.generic_class;
  D.20161 = t2->data.generic_class;
  D.20146 = _mono_metadata_generic_class_equal (D.20160, D.20161, signature_only);
  return D.20146;
  <D.18974>:
  D.20162 = t1->data.generic_param;
  D.20163 = t2->data.generic_param;
  D.20146 = mono_metadata_generic_param_equal (D.20162, D.20163, signature_only);
  return D.20146;
  <D.18975>:
  D.20162 = t1->data.generic_param;
  D.20163 = t2->data.generic_param;
  D.20146 = mono_metadata_generic_param_equal (D.20162, D.20163, signature_only);
  return D.20146;
  <D.18976>:
  D.20164 = t1->data.method;
  D.20165 = t2->data.method;
  D.20146 = mono_metadata_fnptr_equal (D.20164, D.20165, signature_only);
  return D.20146;
  <D.18977>:
  D.20139 = t1->type;
  D.20147 = (int) D.20139;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.20147);
  <D.18978>:
  goto <D.18978>;
  D.20146 = 0;
  return D.20146;
  D.20146 = 0;
  return D.20146;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.20169;
  struct MonoGenericClass * D.20170;
  struct MonoGenericClass * D.20173;
  struct MonoGenericContainer * D.20178;
  struct MonoGenericContainer * D.20181;
  unsigned char D.20186;
  unsigned char D.20189;
  struct MonoGenericParam * D.20192;
  struct MonoGenericParam * D.20193;
  struct MonoClass * D.20204;
  struct MonoClass * D.20205;
  struct MonoType * D.20212;
  struct MonoType * D.20213;

  if (c1 == c2) goto <D.20167>; else goto <D.20168>;
  <D.20167>:
  D.20169 = 1;
  return D.20169;
  <D.20168>:
  D.20170 = c1->generic_class;
  if (D.20170 != 0B) goto <D.20171>; else goto <D.20172>;
  <D.20171>:
  D.20173 = c2->generic_class;
  if (D.20173 != 0B) goto <D.20174>; else goto <D.20175>;
  <D.20174>:
  D.20170 = c1->generic_class;
  D.20173 = c2->generic_class;
  D.20169 = _mono_metadata_generic_class_equal (D.20170, D.20173, signature_only);
  return D.20169;
  <D.20175>:
  <D.20172>:
  D.20170 = c1->generic_class;
  if (D.20170 != 0B) goto <D.20176>; else goto <D.20177>;
  <D.20176>:
  D.20178 = c2->generic_container;
  if (D.20178 != 0B) goto <D.20179>; else goto <D.20180>;
  <D.20179>:
  D.20170 = c1->generic_class;
  D.20169 = _mono_metadata_generic_class_container_equal (D.20170, c2, signature_only);
  return D.20169;
  <D.20180>:
  <D.20177>:
  D.20181 = c1->generic_container;
  if (D.20181 != 0B) goto <D.20182>; else goto <D.20183>;
  <D.20182>:
  D.20173 = c2->generic_class;
  if (D.20173 != 0B) goto <D.20184>; else goto <D.20185>;
  <D.20184>:
  D.20173 = c2->generic_class;
  D.20169 = _mono_metadata_generic_class_container_equal (D.20173, c1, signature_only);
  return D.20169;
  <D.20185>:
  <D.20183>:
  D.20186 = c1->byval_arg.type;
  if (D.20186 == 19) goto <D.20187>; else goto <D.20188>;
  <D.20187>:
  D.20189 = c2->byval_arg.type;
  if (D.20189 == 19) goto <D.20190>; else goto <D.20191>;
  <D.20190>:
  D.20192 = c1->byval_arg.data.generic_param;
  D.20193 = c2->byval_arg.data.generic_param;
  D.20169 = mono_metadata_generic_param_equal (D.20192, D.20193, signature_only);
  return D.20169;
  <D.20191>:
  <D.20188>:
  D.20186 = c1->byval_arg.type;
  if (D.20186 == 30) goto <D.20194>; else goto <D.20195>;
  <D.20194>:
  D.20189 = c2->byval_arg.type;
  if (D.20189 == 30) goto <D.20196>; else goto <D.20197>;
  <D.20196>:
  D.20192 = c1->byval_arg.data.generic_param;
  D.20193 = c2->byval_arg.data.generic_param;
  D.20169 = mono_metadata_generic_param_equal (D.20192, D.20193, signature_only);
  return D.20169;
  <D.20197>:
  <D.20195>:
  if (signature_only != 0) goto <D.20198>; else goto <D.20199>;
  <D.20198>:
  D.20186 = c1->byval_arg.type;
  if (D.20186 == 29) goto <D.20200>; else goto <D.20201>;
  <D.20200>:
  D.20189 = c2->byval_arg.type;
  if (D.20189 == 29) goto <D.20202>; else goto <D.20203>;
  <D.20202>:
  D.20204 = c1->byval_arg.data.klass;
  D.20205 = c2->byval_arg.data.klass;
  D.20169 = mono_metadata_class_equal (D.20204, D.20205, signature_only);
  return D.20169;
  <D.20203>:
  <D.20201>:
  <D.20199>:
  if (signature_only != 0) goto <D.20206>; else goto <D.20207>;
  <D.20206>:
  D.20186 = c1->byval_arg.type;
  if (D.20186 == 20) goto <D.20208>; else goto <D.20209>;
  <D.20208>:
  D.20189 = c2->byval_arg.type;
  if (D.20189 == 20) goto <D.20210>; else goto <D.20211>;
  <D.20210>:
  D.20212 = &c1->byval_arg;
  D.20213 = &c2->byval_arg;
  D.20169 = do_mono_metadata_type_equal (D.20212, D.20213, signature_only);
  return D.20169;
  <D.20211>:
  <D.20209>:
  <D.20207>:
  D.20169 = 0;
  return D.20169;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.20215;
  struct MonoClass * D.20216;
  int D.20217;
  gboolean D.20220;
  int D.20221;
  long unsigned int D.20224;
  long unsigned int D.20225;
  _Bool D.20226;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.20215 = c2->generic_container;
  i2 = D.20215->context.class_inst;
  D.20216 = g1->container_class;
  D.20217 = mono_metadata_class_equal (D.20216, c2, signature_only);
  if (D.20217 == 0) goto <D.20218>; else goto <D.20219>;
  <D.20218>:
  D.20220 = 0;
  return D.20220;
  <D.20219>:
  D.20221 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20221 == 0) goto <D.20222>; else goto <D.20223>;
  <D.20222>:
  D.20220 = 0;
  return D.20220;
  <D.20223>:
  D.20224 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20225 = D.20224 & 4611686018427387904;
  D.20226 = D.20225 == 0;
  D.20220 = (gboolean) D.20226;
  return D.20220;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  long unsigned int D.20228;
  long unsigned int D.20229;
  long unsigned int D.20230;
  signed long D.20231;
  gboolean D.20234;
  struct MonoClass * D.20235;
  struct MonoClass * D.20236;
  int D.20237;
  int D.20240;
  long unsigned int D.20243;
  _Bool D.20244;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.20228 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20229 = BIT_FIELD_REF <*g2, 64, 192>;
  D.20230 = D.20228 ^ D.20229;
  D.20231 = (signed long) D.20230;
  if (D.20231 < 0) goto <D.20232>; else goto <D.20233>;
  <D.20232>:
  D.20234 = 0;
  return D.20234;
  <D.20233>:
  D.20235 = g1->container_class;
  D.20236 = g2->container_class;
  D.20237 = mono_metadata_class_equal (D.20235, D.20236, signature_only);
  if (D.20237 == 0) goto <D.20238>; else goto <D.20239>;
  <D.20238>:
  D.20234 = 0;
  return D.20234;
  <D.20239>:
  D.20240 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20240 == 0) goto <D.20241>; else goto <D.20242>;
  <D.20241>:
  D.20234 = 0;
  return D.20234;
  <D.20242>:
  D.20228 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20229 = BIT_FIELD_REF <*g2, 64, 192>;
  D.20230 = D.20228 ^ D.20229;
  D.20243 = D.20230 & 4611686018427387904;
  D.20244 = D.20243 == 0;
  D.20234 = (gboolean) D.20244;
  return D.20234;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.20248;
  short unsigned int D.20249;
  short unsigned int D.20250;
  short unsigned int D.20253;
  short unsigned int D.20254;
  struct MonoGenericContainer * D.20259;
  struct MonoGenericContainer * D.20260;
  struct MonoImage * D.20264;
  struct MonoImage * D.20265;

  if (p1 == p2) goto <D.20246>; else goto <D.20247>;
  <D.20246>:
  D.20248 = 1;
  return D.20248;
  <D.20247>:
  D.20249 = p1->num;
  D.20250 = p2->num;
  if (D.20249 != D.20250) goto <D.20251>; else goto <D.20252>;
  <D.20251>:
  D.20248 = 0;
  return D.20248;
  <D.20252>:
  D.20253 = p1->serial;
  D.20254 = p2->serial;
  if (D.20253 != D.20254) goto <D.20255>; else goto <D.20256>;
  <D.20255>:
  D.20248 = 0;
  return D.20248;
  <D.20256>:
  D.20259 = p1->owner;
  D.20260 = p2->owner;
  if (D.20259 == D.20260) goto <D.20261>; else goto <D.20262>;
  <D.20261>:
  D.20259 = p1->owner;
  if (D.20259 != 0B) goto <D.20257>; else goto <D.20263>;
  <D.20263>:
  D.20264 = p1->image;
  D.20265 = p2->image;
  if (D.20264 == D.20265) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  D.20248 = 1;
  return D.20248;
  <D.20258>:
  <D.20262>:
  D.20248 = signature_only;
  return D.20248;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.20269;
  long unsigned int D.20270;
  long unsigned int D.20271;
  long unsigned int D.20272;
  long unsigned int D.20273;
  short int D.20276;
  short int D.20277;
  long unsigned int D.20280;
  long unsigned int D.20283;
  struct MonoType * D.20286;
  struct MonoType * D.20287;
  int D.20288;
  short unsigned int D.20291;
  short unsigned int D.20292;
  _Bool D.20298;
  int D.20299;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.20267>; else goto <D.20268>;
      <D.20267>:
      D.20269 = 1;
      return D.20269;
      <D.20268>:
      D.20270 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20271 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20272 = D.20270 ^ D.20271;
      D.20273 = D.20272 & 64512;
      if (D.20273 != 0) goto <D.20274>; else goto <D.20275>;
      <D.20274>:
      D.20269 = 0;
      return D.20269;
      <D.20275>:
      D.20276 = s1->sentinelpos;
      D.20277 = s2->sentinelpos;
      if (D.20276 != D.20277) goto <D.20278>; else goto <D.20279>;
      <D.20278>:
      D.20269 = 0;
      return D.20269;
      <D.20279>:
      D.20270 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20271 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20272 = D.20270 ^ D.20271;
      D.20280 = D.20272 & 512;
      if (D.20280 != 0) goto <D.20281>; else goto <D.20282>;
      <D.20281>:
      D.20269 = 0;
      return D.20269;
      <D.20282>:
      D.20270 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20271 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20272 = D.20270 ^ D.20271;
      D.20283 = D.20272 & 256;
      if (D.20283 != 0) goto <D.20284>; else goto <D.20285>;
      <D.20284>:
      D.20269 = 0;
      return D.20269;
      <D.20285>:
      D.20286 = s1->ret;
      D.20287 = s2->ret;
      D.20288 = do_mono_metadata_type_equal (D.20286, D.20287, signature_only);
      if (D.20288 == 0) goto <D.20289>; else goto <D.20290>;
      <D.20289>:
      D.20269 = 0;
      return D.20269;
      <D.20290>:
      D.20291 = s1->param_count;
      D.20292 = s2->param_count;
      if (D.20291 != D.20292) goto <D.20293>; else goto <D.20294>;
      <D.20293>:
      D.20269 = 0;
      return D.20269;
      <D.20294>:
      <D.18944>:
      {
        struct MonoType * t1;
        struct MonoType * t2;

        t1 = mono_signature_get_params (s1, &iter1);
        t2 = mono_signature_get_params (s2, &iter2);
        if (t1 == 0B) goto <D.20295>; else goto <D.20297>;
        <D.20297>:
        if (t2 == 0B) goto <D.20295>; else goto <D.20296>;
        <D.20295>:
        D.20298 = t1 == t2;
        D.20269 = (gboolean) D.20298;
        return D.20269;
        <D.20296>:
        D.20299 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.20299 == 0) goto <D.20300>; else goto <D.20301>;
        <D.20300>:
        D.20269 = 0;
        return D.20269;
        <D.20301>:
      }
      goto <D.18944>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


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

  D.20304 = monoeg_g_hash_table_new (mono_type_hash, mono_type_equal);
  type_cache = D.20304;
  i = 0;
  goto <D.17891>;
  <D.17890>:
  type_cache.52 = type_cache;
  D.20306 = &builtin_types[i];
  D.20306 = &builtin_types[i];
  monoeg_g_hash_table_insert_replace (type_cache.52, D.20306, D.20306, 0);
  i = i + 1;
  <D.17891>:
  i.53 = (unsigned int) i;
  if (i.53 <= 33) goto <D.17890>; else goto <D.17892>;
  <D.17892>:
}


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.20310;
  unsigned char D.20311;
  long unsigned int D.20313;
  long unsigned int D.20314;
  long unsigned int D.20315;
  long unsigned int D.20316;
  short unsigned int D.20318;
  short unsigned int D.20319;
  long unsigned int D.20321;
  gint D.20322;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.20310 = a->type;
  D.20311 = b->type;
  if (D.20310 != D.20311) goto <D.20308>; else goto <D.20312>;
  <D.20312>:
  D.20313 = BIT_FIELD_REF <*a, 64, 64>;
  D.20314 = BIT_FIELD_REF <*b, 64, 64>;
  D.20315 = D.20313 ^ D.20314;
  D.20316 = D.20315 & 8589934592;
  if (D.20316 != 0) goto <D.20308>; else goto <D.20317>;
  <D.20317>:
  D.20318 = a->attrs;
  D.20319 = b->attrs;
  if (D.20318 != D.20319) goto <D.20308>; else goto <D.20320>;
  <D.20320>:
  D.20313 = BIT_FIELD_REF <*a, 64, 64>;
  D.20314 = BIT_FIELD_REF <*b, 64, 64>;
  D.20315 = D.20313 ^ D.20314;
  D.20321 = D.20315 & 4294967296;
  if (D.20321 != 0) goto <D.20308>; else goto <D.20309>;
  <D.20308>:
  D.20322 = 0;
  return D.20322;
  <D.20309>:
  D.20322 = 1;
  return D.20322;
}


mono_type_hash (const void * data)
{
  unsigned char D.20324;
  guint D.20327;
  struct MonoGenericClass * D.20328;
  int D.20329;
  <unnamed-unsigned:1> D.20330;
  int D.20331;
  int D.20332;
  int D.20333;
  short unsigned int D.20334;
  int D.20335;
  int D.20336;
  int D.20337;
  const struct MonoType * type;

  type = data;
  D.20324 = type->type;
  if (D.20324 == 21) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  D.20328 = type->data.generic_class;
  D.20327 = mono_generic_class_hash (D.20328);
  return D.20327;
  <D.20326>:
  D.20324 = type->type;
  D.20329 = (int) D.20324;
  D.20330 = type->byref;
  D.20331 = (int) D.20330;
  D.20332 = D.20331 << 8;
  D.20333 = D.20329 | D.20332;
  D.20334 = type->attrs;
  D.20335 = (int) D.20334;
  D.20336 = D.20335 << 9;
  D.20337 = D.20333 | D.20336;
  D.20327 = (guint) D.20337;
  return D.20327;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.20339;
  struct MonoType * D.20340;
  <unnamed-unsigned:1> D.20341;
  unsigned int D.20342;
  const struct MonoGenericContext * D.20343;
  unsigned int D.20344;
  guint D.20345;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.20339 = gclass->container_class;
  D.20340 = &D.20339->byval_arg;
  hash = mono_metadata_type_hash (D.20340);
  hash = hash * 13;
  D.20341 = gclass->is_tb_open;
  D.20342 = (unsigned int) D.20341;
  hash = D.20342 + hash;
  D.20343 = &gclass->context;
  D.20344 = mono_metadata_generic_context_hash (D.20343);
  hash = D.20344 + hash;
  D.20345 = hash;
  return D.20345;
}


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

  type_cache.54 = type_cache;
  monoeg_g_hash_table_destroy (type_cache.54);
  type_cache = 0B;
  image_sets.55 = image_sets;
  monoeg_g_ptr_array_free (image_sets.55, 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.20349;

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


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.56;
  const char * tmp_ptr.57;
  char D.20353;
  int D.20354;
  const char * tmp_ptr.58;
  long unsigned int D.20358;
  long unsigned int D.20359;
  unsigned int D.20360;
  unsigned int D.20361;
  void * iftmp.59;
  long unsigned int D.20365;
  unsigned int size.60;
  unsigned char D.20368;
  <unnamed-unsigned:6> D.20369;
  char D.20373;
  int D.20374;
  const char * ptr.61;
  struct MonoCustomMod * D.20376;
  short unsigned int opt_attrs.62;
  unsigned char D.20378;
  <unnamed-unsigned:1> D.20379;
  _Bool D.20380;
  int D.20381;
  struct MonoType * D.20384;
  long unsigned int D.20387;
  long unsigned int D.20388;
  unsigned char D.20393;
  unsigned char D.20394;
  long unsigned int D.20397;
  struct MonoType * iftmp.63;
  long unsigned int D.20401;
  struct MonoClass * D.20404;
  struct MonoClass * D.20406;
  struct GHashTable * type_cache.64;
  void * iftmp.65;
  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.56 = ptr;
      tmp_ptr = ptr.56;
      found = 1;
      goto <D.17920>;
      <D.17919>:
      tmp_ptr.57 = tmp_ptr;
      D.20353 = *tmp_ptr.57;
      D.20354 = (int) D.20353;
      switch (D.20354) <default: <D.17918>, case 16: <D.17914>, case 31: <D.17916>, case 32: <D.17917>, case 69: <D.17913>>
      <D.17913>:
      <D.17914>:
      tmp_ptr.57 = tmp_ptr;
      tmp_ptr.58 = tmp_ptr.57 + 1;
      tmp_ptr = tmp_ptr.58;
      goto <D.17915>;
      <D.17916>:
      <D.17917>:
      count = count + 1;
      tmp_ptr.57 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.57, &tmp_ptr);
      goto <D.17915>;
      <D.17918>:
      found = 0;
      <D.17915>:
      <D.17920>:
      if (found != 0) goto <D.17919>; else goto <D.17921>;
      <D.17921>:
      if (count != 0) goto <D.20356>; else goto <D.20357>;
      <D.20356>:
      {
        int size;

        D.20358 = (long unsigned int) count;
        D.20359 = D.20358 + 3;
        D.20360 = (unsigned int) D.20359;
        D.20361 = D.20360 * 4;
        size = (int) D.20361;
        if (transient != 0) goto <D.20363>; else goto <D.20364>;
        <D.20363>:
        D.20365 = (long unsigned int) size;
        iftmp.59 = monoeg_malloc0 (D.20365);
        goto <D.20366>;
        <D.20364>:
        size.60 = (unsigned int) size;
        iftmp.59 = mono_image_alloc0 (m, size.60);
        <D.20366>:
        type = iftmp.59;
        D.20368 = (unsigned char) count;
        D.20369 = (<unnamed-unsigned:6>) D.20368;
        type->num_mods = D.20369;
        if (count > 64) goto <D.20370>; else goto <D.20371>;
        <D.20370>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.20371>:
      }
      goto <D.20372>;
      <D.20357>:
      type = &stype;
      memset (type, 0, 12);
      <D.20372>:
      found = 1;
      count = 0;
      goto <D.17930>;
      <D.17929>:
      ptr.56 = ptr;
      D.20373 = *ptr.56;
      D.20374 = (int) D.20373;
      switch (D.20374) <default: <D.17928>, case 16: <D.17925>, case 31: <D.17926>, case 32: <D.17927>, case 69: <D.17923>>
      <D.17923>:
      pinned = 1;
      ptr.56 = ptr;
      ptr.61 = ptr.56 + 1;
      ptr = ptr.61;
      goto <D.17924>;
      <D.17925>:
      byref = 1;
      ptr.56 = ptr;
      ptr.61 = ptr.56 + 1;
      ptr = ptr.61;
      goto <D.17924>;
      <D.17926>:
      <D.17927>:
      D.20376 = &type->modifiers[count];
      ptr.56 = ptr;
      mono_metadata_parse_custom_mod (m, D.20376, ptr.56, &ptr);
      count = count + 1;
      goto <D.17924>;
      <D.17928>:
      found = 0;
      <D.17924>:
      <D.17930>:
      if (found != 0) goto <D.17929>; else goto <D.17931>;
      <D.17931>:
      opt_attrs.62 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.62;
      D.20378 = (unsigned char) byref;
      D.20379 = (<unnamed-unsigned:1>) D.20378;
      type->byref = D.20379;
      D.20380 = pinned != 0;
      type->pinned = D.20380;
      ptr.56 = ptr;
      D.20381 = do_mono_metadata_parse_type (type, m, container, transient, ptr.56, &ptr);
      if (D.20381 == 0) goto <D.20382>; else goto <D.20383>;
      <D.20382>:
      D.20384 = 0B;
      return D.20384;
      <D.20383>:
      if (rptr != 0B) goto <D.20385>; else goto <D.20386>;
      <D.20385>:
      ptr.56 = ptr;
      *rptr = ptr.56;
      <D.20386>:
      D.20387 = BIT_FIELD_REF <*type, 64, 64>;
      D.20388 = D.20387 & 1082331758592;
      if (D.20388 == 0) goto <D.20389>; else goto <D.20390>;
      <D.20389>:
      if (transient == 0) goto <D.20391>; else goto <D.20392>;
      <D.20391>:
      D.20393 = type->type;
      D.20394 = D.20393 + 239;
      if (D.20394 <= 1) goto <D.20395>; else goto <D.20396>;
      <D.20395>:
      D.20387 = BIT_FIELD_REF <*type, 64, 64>;
      D.20397 = D.20387 & 18446462603027808256;
      if (D.20397 == 0) goto <D.20398>; else goto <D.20399>;
      <D.20398>:
      {
        struct MonoType * ret;

        D.20387 = BIT_FIELD_REF <*type, 64, 64>;
        D.20401 = D.20387 & 8589934592;
        if (D.20401 != 0) goto <D.20402>; else goto <D.20403>;
        <D.20402>:
        D.20404 = type->data.klass;
        iftmp.63 = &D.20404->this_arg;
        goto <D.20405>;
        <D.20403>:
        D.20404 = type->data.klass;
        iftmp.63 = &D.20404->byval_arg;
        <D.20405>:
        ret = iftmp.63;
        D.20406 = ret->data.klass;
        D.20404 = type->data.klass;
        if (D.20406 == D.20404) goto <D.20407>; else goto <D.20408>;
        <D.20407>:
        D.20384 = ret;
        return D.20384;
        <D.20408>:
      }
      <D.20399>:
      <D.20396>:
      type_cache.64 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.64, type);
      if (cached != 0B) goto <D.20410>; else goto <D.20411>;
      <D.20410>:
      D.20384 = cached;
      return D.20384;
      <D.20411>:
      <D.20392>:
      <D.20390>:
      if (&stype == type) goto <D.20412>; else goto <D.20413>;
      <D.20412>:
      if (transient != 0) goto <D.20415>; else goto <D.20416>;
      <D.20415>:
      iftmp.65 = monoeg_malloc (12);
      goto <D.20417>;
      <D.20416>:
      iftmp.65 = mono_image_alloc (m, 12);
      <D.20417>:
      type = iftmp.65;
      memcpy (type, &stype, 12);
      <D.20413>:
      D.20384 = type;
      return D.20384;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.20420;
  long unsigned int D.20421;

  D.20421 = __builtin_object_size (__dest, 0);
  D.20420 = __builtin___memset_chk (__dest, __ch, __len, D.20421);
  return D.20420;
}


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.66;
  unsigned int D.20424;
  unsigned char D.20425;
  unsigned char D.20426;
  int D.20427;
  gboolean D.20430;
  unsigned char D.20431;
  int D.20432;
  int D.20433;
  struct MonoClass * D.20438;
  struct MonoClass * D.20439;
  struct MonoType * D.20442;
  struct MonoType * D.20443;
  struct MonoMethodSignature * D.20446;
  struct MonoMethodSignature * D.20447;
  struct MonoArrayType * D.20450;
  struct MonoArrayType * D.20451;
  long unsigned int D.20456;
  long unsigned int D.20457;
  <unnamed type> D.20460;
  struct MonoGenericParam * D.20461;
  struct MonoGenericParam * D.20462;
  char * D.20465;
  gboolean ok;

  ok = 1;
  ptr.66 = ptr;
  D.20424 = mono_metadata_decode_value (ptr.66, &ptr);
  D.20425 = (unsigned char) D.20424;
  type->type = D.20425;
  D.20426 = type->type;
  D.20427 = (int) D.20426;
  switch (D.20427) <default: <D.18484>, case 1: <D.18453>, case 2: <D.18454>, case 3: <D.18455>, case 4: <D.18456>, case 5: <D.18457>, case 6: <D.18458>, case 7: <D.18459>, case 8: <D.18460>, case 9: <D.18461>, case 10: <D.18462>, case 11: <D.18463>, case 12: <D.18464>, case 13: <D.18465>, case 14: <D.18468>, case 15: <D.18478>, case 17: <D.18472>, case 18: <D.18473>, case 19: <D.18482>, case 20: <D.18480>, case 21: <D.18483>, case 22: <D.18470>, case 24: <D.18466>, case 25: <D.18467>, case 27: <D.18479>, case 28: <D.18469>, case 29: <D.18476>, case 30: <D.18481>>
  <D.18453>:
  <D.18454>:
  <D.18455>:
  <D.18456>:
  <D.18457>:
  <D.18458>:
  <D.18459>:
  <D.18460>:
  <D.18461>:
  <D.18462>:
  <D.18463>:
  <D.18464>:
  <D.18465>:
  <D.18466>:
  <D.18467>:
  <D.18468>:
  <D.18469>:
  <D.18470>:
  goto <D.18471>;
  <D.18472>:
  <D.18473>:
  {
    guint32 token;
    struct MonoClass * class;

    ptr.66 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.66, &ptr);
    class = mono_class_get (m, token);
    type->data.klass = class;
    if (class == 0B) goto <D.20428>; else goto <D.20429>;
    <D.20428>:
    D.20430 = 0;
    return D.20430;
    <D.20429>:
    D.20431 = class->byval_arg.type;
    D.20432 = (int) D.20431;
    D.20426 = type->type;
    D.20427 = (int) D.20426;
    D.20433 = compare_type_literals (D.20432, D.20427);
    if (D.20433 == 0) goto <D.20434>; else goto <D.20435>;
    <D.20434>:
    D.20430 = 0;
    return D.20430;
    <D.20435>:
    goto <D.18471>;
  }
  <D.18476>:
  {
    struct MonoType * etype;

    ptr.66 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.66, &ptr);
    if (etype == 0B) goto <D.20436>; else goto <D.20437>;
    <D.20436>:
    D.20430 = 0;
    return D.20430;
    <D.20437>:
    D.20438 = mono_class_from_mono_type (etype);
    type->data.klass = D.20438;
    D.20439 = type->data.klass;
    if (D.20439 == 0B) goto <D.20440>; else goto <D.20441>;
    <D.20440>:
    D.20430 = 0;
    return D.20430;
    <D.20441>:
    goto <D.18471>;
  }
  <D.18478>:
  ptr.66 = ptr;
  D.20442 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.66, &ptr);
  type->data.type = D.20442;
  D.20443 = type->data.type;
  if (D.20443 == 0B) goto <D.20444>; else goto <D.20445>;
  <D.20444>:
  D.20430 = 0;
  return D.20430;
  <D.20445>:
  goto <D.18471>;
  <D.18479>:
  ptr.66 = ptr;
  D.20446 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.66, &ptr);
  type->data.method = D.20446;
  D.20447 = type->data.method;
  if (D.20447 == 0B) goto <D.20448>; else goto <D.20449>;
  <D.20448>:
  D.20430 = 0;
  return D.20430;
  <D.20449>:
  goto <D.18471>;
  <D.18480>:
  ptr.66 = ptr;
  D.20450 = mono_metadata_parse_array_internal (m, container, transient, ptr.66, &ptr);
  type->data.array = D.20450;
  D.20451 = type->data.array;
  if (D.20451 == 0B) goto <D.20452>; else goto <D.20453>;
  <D.20452>:
  D.20430 = 0;
  return D.20430;
  <D.20453>:
  goto <D.18471>;
  <D.18481>:
  if (container != 0B) goto <D.20454>; else goto <D.20455>;
  <D.20454>:
  D.20456 = BIT_FIELD_REF <*container, 64, 256>;
  D.20457 = D.20456 & 4294967296;
  if (D.20457 == 0) goto <D.20458>; else goto <D.20459>;
  <D.20458>:
  D.20430 = 0;
  return D.20430;
  <D.20459>:
  <D.20455>:
  <D.18482>:
  D.20426 = type->type;
  D.20460 = (<unnamed type>) D.20426;
  ptr.66 = ptr;
  D.20461 = mono_metadata_parse_generic_param (m, container, D.20460, ptr.66, &ptr);
  type->data.generic_param = D.20461;
  D.20462 = type->data.generic_param;
  if (D.20462 == 0B) goto <D.20463>; else goto <D.20464>;
  <D.20463>:
  D.20430 = 0;
  return D.20430;
  <D.20464>:
  goto <D.18471>;
  <D.18483>:
  ptr.66 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.66, &ptr);
  goto <D.18471>;
  <D.18484>:
  D.20426 = type->type;
  D.20427 = (int) D.20426;
  D.20465 = m->name;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.20427, D.20465);
  D.20430 = 0;
  return D.20430;
  <D.18471>:
  if (rptr != 0B) goto <D.20466>; else goto <D.20467>;
  <D.20466>:
  ptr.66 = ptr;
  *rptr = ptr.66;
  <D.20467>:
  D.20430 = ok;
  return D.20430;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.20472;
  _Bool D.20478;

  if (class_type == 0) goto <D.20470>; else goto <D.20471>;
  <D.20470>:
  D.20472 = 1;
  return D.20472;
  <D.20471>:
  if (type_type == 18) goto <D.20475>; else goto <D.20476>;
  <D.20475>:
  if (class_type == 14) goto <D.20473>; else goto <D.20477>;
  <D.20477>:
  if (class_type == 28) goto <D.20473>; else goto <D.20474>;
  <D.20473>:
  D.20472 = 1;
  return D.20472;
  <D.20474>:
  <D.20476>:
  D.20478 = class_type == type_type;
  D.20472 = (gboolean) D.20478;
  return D.20472;
}


mono_metadata_parse_generic_param (struct MonoImage * m, struct MonoGenericContainer * generic_container, MonoTypeEnum type, const char * ptr, const char * * rptr)
{
  const char * ptr.67;
  unsigned int D.20481;
  short unsigned int D.20486;
  struct MonoGenericParam * D.20487;
  <unnamed-signed:31> D.20488;
  int D.20489;
  struct MonoGenericParamFull * D.20492;
  long unsigned int D.20493;
  long unsigned int D.20494;
  int index;

  ptr.67 = ptr;
  D.20481 = mono_metadata_decode_value (ptr.67, &ptr);
  index = (int) D.20481;
  if (rptr != 0B) goto <D.20482>; else goto <D.20483>;
  <D.20482>:
  ptr.67 = ptr;
  *rptr = ptr.67;
  <D.20483>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.20484>; else goto <D.20485>;
  <D.20484>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 24);
    D.20486 = (short unsigned int) index;
    param->num = D.20486;
    param->image = m;
    D.20487 = param;
    return D.20487;
  }
  <D.20485>:
  D.20488 = generic_container->type_argc;
  D.20489 = (int) D.20488;
  if (D.20489 <= index) goto <D.20490>; else goto <D.20491>;
  <D.20490>:
  D.20487 = 0B;
  return D.20487;
  <D.20491>:
  D.20492 = generic_container->type_params;
  D.20493 = (long unsigned int) index;
  D.20494 = D.20493 * 56;
  D.20487 = D.20492 + D.20494;
  return D.20487;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.20496;
  struct MonoGenericContainer * D.20499;
  int iftmp.68;
  _Bool D.20505;
  long int D.20506;
  long int D.20507;
  long unsigned int D.20514;
  long unsigned int D.20515;
  struct MonoGenericContainer * D.20517;
  gboolean is_var;

  D.20496 = type == 19;
  is_var = (gboolean) D.20496;
  if (gc == 0B) goto <D.20497>; else goto <D.20498>;
  <D.20497>:
  D.20499 = 0B;
  return D.20499;
  <D.20498>:
  if (is_var == 0) goto <D.20503>; else goto <D.20501>;
  <D.20503>:
  if (type != 30) goto <D.20504>; else goto <D.20501>;
  <D.20504>:
  iftmp.68 = 1;
  goto <D.20502>;
  <D.20501>:
  iftmp.68 = 0;
  <D.20502>:
  D.20505 = iftmp.68 != 0;
  D.20506 = (long int) D.20505;
  D.20507 = __builtin_expect (D.20506, 0);
  if (D.20507 != 0) goto <D.20508>; else goto <D.20509>;
  <D.20508>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.20509>:
  if (is_var != 0) goto <D.20510>; else goto <D.20511>;
  <D.20510>:
  D.20514 = BIT_FIELD_REF <*gc, 64, 256>;
  D.20515 = D.20514 & 4294967296;
  if (D.20515 != 0) goto <D.20512>; else goto <D.20516>;
  <D.20516>:
  D.20517 = gc->parent;
  if (D.20517 != 0B) goto <D.20512>; else goto <D.20513>;
  <D.20512>:
  D.20499 = gc->parent;
  return D.20499;
  <D.20513>:
  <D.20511>:
  D.20499 = gc;
  return D.20499;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.69;
  gboolean D.20522;
  struct MonoGenericContainer * D.20523;
  unsigned int D.20526;
  struct MonoGenericClass * D.20531;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.69 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.69, &ptr);
  if (gtype == 0B) goto <D.20520>; else goto <D.20521>;
  <D.20520>:
  D.20522 = 0;
  return D.20522;
  <D.20521>:
  gklass = mono_class_from_mono_type (gtype);
  D.20523 = gklass->generic_container;
  if (D.20523 == 0B) goto <D.20524>; else goto <D.20525>;
  <D.20524>:
  D.20522 = 0;
  return D.20522;
  <D.20525>:
  ptr.69 = ptr;
  D.20526 = mono_metadata_decode_value (ptr.69, &ptr);
  count = (int) D.20526;
  ptr.69 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.69, &ptr);
  if (inst == 0B) goto <D.20527>; else goto <D.20528>;
  <D.20527>:
  D.20522 = 0;
  return D.20522;
  <D.20528>:
  if (rptr != 0B) goto <D.20529>; else goto <D.20530>;
  <D.20529>:
  ptr.69 = ptr;
  *rptr = ptr.69;
  <D.20530>:
  D.20531 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.20531;
  D.20522 = 1;
  return D.20522;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.20533;
  long unsigned int D.20534;

  D.20534 = __builtin_object_size (__dest, 0);
  D.20533 = __builtin___memcpy_chk (__dest, __src, __len, D.20534);
  return D.20533;
}


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

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


__attribute__((visibility ("hidden")))
mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.20538;
  <unnamed-unsigned:24> D.20539;
  int D.20540;
  <unnamed-unsigned:24> D.20544;
  int D.20545;
  int D.20546;
  unsigned int D.20547;
  int D.20548;
  gboolean D.20551;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.20538 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.20538, 5);
  D.20539 = methodt->rows;
  D.20540 = (int) D.20539;
  if (D.20540 > def) goto <D.20541>; else goto <D.20542>;
  <D.20541>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.20543>;
  <D.20542>:
  D.20544 = m->tables[8].rows;
  D.20545 = (int) D.20544;
  D.20546 = D.20545 + 1;
  lastp = (guint) D.20546;
  <D.20543>:
  i = param_index;
  goto <D.17959>;
  <D.17958>:
  {
    guint32 flags;

    D.20547 = i + 4294967295;
    D.20548 = (int) D.20547;
    flags = mono_metadata_decode_row_col (paramt, D.20548, 0);
    if (flags != 0) goto <D.20549>; else goto <D.20550>;
    <D.20549>:
    D.20551 = 1;
    return D.20551;
    <D.20550>:
  }
  i = i + 1;
  <D.17959>:
  if (i < lastp) goto <D.17958>; else goto <D.17960>;
  <D.17960>:
  D.20551 = 0;
  return D.20551;
}


__attribute__((visibility ("hidden")))
mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.20553;
  <unnamed-unsigned:24> D.20554;
  int D.20555;
  <unnamed-unsigned:24> D.20559;
  int D.20560;
  int D.20561;
  unsigned int D.20562;
  int D.20563;
  unsigned int D.20564;
  long unsigned int D.20569;
  long unsigned int D.20570;
  unsigned int D.20571;
  unsigned int param_count.70;
  long unsigned int D.20575;
  long unsigned int D.20576;
  int * D.20577;
  int D.20578;
  int * D.20579;
  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.20553 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.20553, 5);
      pattrs = 0B;
      D.20554 = methodt->rows;
      D.20555 = (int) D.20554;
      if (D.20555 > def) goto <D.20556>; else goto <D.20557>;
      <D.20556>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.20558>;
      <D.20557>:
      D.20559 = paramt->rows;
      D.20560 = (int) D.20559;
      D.20561 = D.20560 + 1;
      lastp = (guint) D.20561;
      <D.20558>:
      i = param_index;
      goto <D.17975>;
      <D.17974>:
      D.20562 = i + 4294967295;
      D.20563 = (int) D.20562;
      mono_metadata_decode_row (paramt, D.20563, &cols, 3);
      D.20564 = cols[0];
      if (D.20564 != 0) goto <D.20565>; else goto <D.20566>;
      <D.20565>:
      if (pattrs == 0B) goto <D.20567>; else goto <D.20568>;
      <D.20567>:
      D.20569 = (long unsigned int) param_count;
      D.20570 = D.20569 * 4;
      pattrs = monoeg_malloc0 (D.20570);
      <D.20568>:
      D.20571 = cols[1];
      param_count.70 = (unsigned int) param_count;
      if (D.20571 >= param_count.70) goto <D.20573>; else goto <D.20574>;
      <D.20573>:
      // predicted unlikely by continue predictor.
      goto <D.17973>;
      <D.20574>:
      D.20571 = cols[1];
      D.20575 = (long unsigned int) D.20571;
      D.20576 = D.20575 * 4;
      D.20577 = pattrs + D.20576;
      D.20564 = cols[0];
      D.20578 = (int) D.20564;
      *D.20577 = D.20578;
      <D.20566>:
      <D.17973>:
      i = i + 1;
      <D.17975>:
      if (i < lastp) goto <D.17974>; else goto <D.17976>;
      <D.17976>:
      D.20579 = pattrs;
      return D.20579;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  long unsigned int D.20582;
  long unsigned int D.20583;
  struct MonoMethodSignature * D.20586;
  unsigned int D.20587;
  _Bool D.20588;
  long int D.20589;
  long int D.20590;
  struct MonoTableInfo * D.20593;
  unsigned int D.20594;
  int D.20595;
  const char * ptr.71;
  const char * ptr.72;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.20582 = BIT_FIELD_REF <*image, 64, 192>;
      D.20583 = D.20582 & 268435456;
      if (D.20583 != 0) goto <D.20584>; else goto <D.20585>;
      <D.20584>:
      D.20586 = mono_lookup_dynamic_token (image, token, 0B);
      return D.20586;
      <D.20585>:
      D.20587 = token >> 24;
      D.20588 = D.20587 != 17;
      D.20589 = (long int) D.20588;
      D.20590 = __builtin_expect (D.20589, 0);
      if (D.20590 != 0) goto <D.20591>; else goto <D.20592>;
      <D.20591>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.20592>:
      D.20593 = tables + 272;
      D.20594 = idx + 4294967295;
      D.20595 = (int) D.20594;
      sig = mono_metadata_decode_row_col (D.20593, D.20595, 0);
      ptr.71 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.71;
      ptr.72 = ptr;
      mono_metadata_decode_blob_size (ptr.72, &ptr);
      ptr.72 = ptr;
      D.20586 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.72, 0B);
      return D.20586;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  int nparams.73;
  long unsigned int D.20603;
  long unsigned int D.20604;
  unsigned int D.20605;
  unsigned int D.20606;
  short unsigned int D.20607;
  struct MonoMethodSignature * D.20608;
  struct MonoMethodSignature * sig;

  nparams.73 = (int) nparams;
  D.20603 = (long unsigned int) nparams.73;
  D.20604 = D.20603 + 2;
  D.20605 = (unsigned int) D.20604;
  D.20606 = D.20605 * 8;
  sig = mono_image_alloc0 (m, D.20606);
  D.20607 = (short unsigned int) nparams;
  sig->param_count = D.20607;
  sig->sentinelpos = -1;
  D.20608 = sig;
  return D.20608;
}


__attribute__((visibility ("hidden")))
mono_metadata_signature_dup_full (struct MonoImage * image, struct MonoMethodSignature * sig)
{
  struct MonoMethodSignature * D.20610;

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


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.20612;
  long unsigned int D.20613;
  long unsigned int D.20614;
  unsigned int D.20615;
  unsigned int D.20616;
  unsigned int sigsize.74;
  unsigned int sigsize.75;
  long unsigned int D.20625;
  long unsigned int D.20626;
  struct MonoMethodSignature * D.20627;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.20612 = sig->param_count;
  D.20613 = (long unsigned int) D.20612;
  D.20614 = D.20613 + 2;
  D.20615 = (unsigned int) D.20614;
  D.20616 = D.20615 * 8;
  sigsize = (int) D.20616;
  if (image != 0B) goto <D.20617>; else goto <D.20618>;
  <D.20617>:
  sigsize.74 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.74);
  goto <D.20620>;
  <D.20618>:
  if (mp != 0B) goto <D.20621>; else goto <D.20622>;
  <D.20621>:
  sigsize.75 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.75);
  goto <D.20624>;
  <D.20622>:
  D.20625 = (long unsigned int) sigsize;
  ret = monoeg_malloc (D.20625);
  <D.20624>:
  <D.20620>:
  D.20626 = (long unsigned int) sigsize;
  memcpy (ret, sig, D.20626);
  D.20627 = ret;
  return D.20627;
}


__attribute__((visibility ("hidden")))
mono_metadata_signature_dup_mempool (struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  struct MonoMethodSignature * D.20629;

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


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

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


__attribute__((visibility ("hidden")))
mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.20633;
  short unsigned int D.20634;
  long unsigned int D.20635;
  long unsigned int D.20636;
  unsigned int D.20637;

  D.20634 = sig->param_count;
  D.20635 = (long unsigned int) D.20634;
  D.20636 = D.20635 + 2;
  D.20637 = (unsigned int) D.20636;
  D.20633 = D.20637 * 8;
  return D.20633;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.76;
  char D.20640;
  int D.20641;
  int D.20642;
  int D.20645;
  int D.20648;
  unsigned int D.20651;
  const char * ptr.77;
  unsigned int D.20657;
  int D.20658;
  unsigned char D.20659;
  <unnamed-unsigned:1> D.20660;
  unsigned char D.20661;
  <unnamed-unsigned:1> D.20662;
  unsigned char D.20663;
  <unnamed-unsigned:6> D.20664;
  short unsigned int D.20665;
  short int iftmp.78;
  int D.20671;
  struct MonoType * D.20673;
  struct MonoType * D.20674;
  struct MonoMethodSignature * D.20677;
  long unsigned int D.20682;
  long unsigned int D.20683;
  char * D.20685;
  short int D.20686;
  short int D.20689;
  short int iftmp.79;
  sizetype D.20693;
  sizetype D.20694;
  sizetype D.20695;
  int * D.20696;
  int D.20697;
  struct MonoType * D.20699;
  struct MonoType * D.20700;
  short unsigned int D.20705;
  int D.20706;
  short int D.20713;
  unsigned char D.20714;
  <unnamed-unsigned:1> D.20715;
  struct MonoMethodSignature * method;
  int i;
  int * pattrs;
  guint32 hasthis;
  guint32 explicit_this;
  guint32 call_convention;
  guint32 param_count;
  guint32 gen_param_count;
  gboolean is_open;

  pattrs = 0B;
  hasthis = 0;
  explicit_this = 0;
  gen_param_count = 0;
  is_open = 0;
  ptr.76 = ptr;
  D.20640 = *ptr.76;
  D.20641 = (int) D.20640;
  D.20642 = D.20641 & 16;
  if (D.20642 != 0) goto <D.20643>; else goto <D.20644>;
  <D.20643>:
  gen_param_count = 1;
  <D.20644>:
  ptr.76 = ptr;
  D.20640 = *ptr.76;
  D.20641 = (int) D.20640;
  D.20645 = D.20641 & 32;
  if (D.20645 != 0) goto <D.20646>; else goto <D.20647>;
  <D.20646>:
  hasthis = 1;
  <D.20647>:
  ptr.76 = ptr;
  D.20640 = *ptr.76;
  D.20641 = (int) D.20640;
  D.20648 = D.20641 & 64;
  if (D.20648 != 0) goto <D.20649>; else goto <D.20650>;
  <D.20649>:
  explicit_this = 1;
  <D.20650>:
  ptr.76 = ptr;
  D.20640 = *ptr.76;
  D.20651 = (unsigned int) D.20640;
  call_convention = D.20651 & 15;
  ptr.76 = ptr;
  ptr.77 = ptr.76 + 1;
  ptr = ptr.77;
  if (gen_param_count != 0) goto <D.20653>; else goto <D.20654>;
  <D.20653>:
  ptr.76 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.76, &ptr);
  <D.20654>:
  ptr.76 = ptr;
  param_count = mono_metadata_decode_value (ptr.76, &ptr);
  if (def != 0) goto <D.20655>; else goto <D.20656>;
  <D.20655>:
  D.20657 = param_count + 1;
  D.20658 = (int) D.20657;
  pattrs = mono_metadata_get_param_attrs (m, def, D.20658);
  <D.20656>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.20659 = (unsigned char) hasthis;
  D.20660 = (<unnamed-unsigned:1>) D.20659;
  method->hasthis = D.20660;
  D.20661 = (unsigned char) explicit_this;
  D.20662 = (<unnamed-unsigned:1>) D.20661;
  method->explicit_this = D.20662;
  D.20663 = (unsigned char) call_convention;
  D.20664 = (<unnamed-unsigned:6>) D.20663;
  method->call_convention = D.20664;
  D.20665 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.20665;
  if (call_convention != 10) goto <D.20666>; else goto <D.20667>;
  <D.20666>:
  if (pattrs != 0B) goto <D.20669>; else goto <D.20670>;
  <D.20669>:
  D.20671 = *pattrs;
  iftmp.78 = (short int) D.20671;
  goto <D.20672>;
  <D.20670>:
  iftmp.78 = 0;
  <D.20672>:
  ptr.76 = ptr;
  D.20673 = mono_metadata_parse_type_full (m, container, 4, iftmp.78, ptr.76, &ptr);
  method->ret = D.20673;
  D.20674 = method->ret;
  if (D.20674 == 0B) goto <D.20675>; else goto <D.20676>;
  <D.20675>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20677 = 0B;
  return D.20677;
  <D.20676>:
  D.20674 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.20674);
  <D.20667>:
  i = 0;
  goto <D.18033>;
  <D.18032>:
  ptr.76 = ptr;
  D.20640 = *ptr.76;
  if (D.20640 == 65) goto <D.20678>; else goto <D.20679>;
  <D.20678>:
  D.20682 = BIT_FIELD_REF <*method, 64, 64>;
  D.20683 = D.20682 & 64512;
  if (D.20683 != 5120) goto <D.20680>; else goto <D.20684>;
  <D.20684>:
  if (def != 0) goto <D.20680>; else goto <D.20681>;
  <D.20680>:
  D.20685 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.20685);
  monoeg_g_free (pattrs);
  D.20677 = 0B;
  return D.20677;
  <D.20681>:
  D.20686 = method->sentinelpos;
  if (D.20686 >= 0) goto <D.20687>; else goto <D.20688>;
  <D.20687>:
  D.20685 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.20685);
  monoeg_g_free (pattrs);
  D.20677 = 0B;
  return D.20677;
  <D.20688>:
  D.20689 = (short int) i;
  method->sentinelpos = D.20689;
  ptr.76 = ptr;
  ptr.77 = ptr.76 + 1;
  ptr = ptr.77;
  <D.20679>:
  if (pattrs != 0B) goto <D.20691>; else goto <D.20692>;
  <D.20691>:
  D.20693 = (sizetype) i;
  D.20694 = D.20693 + 1;
  D.20695 = D.20694 * 4;
  D.20696 = pattrs + D.20695;
  D.20697 = *D.20696;
  iftmp.79 = (short int) D.20697;
  goto <D.20698>;
  <D.20692>:
  iftmp.79 = 0;
  <D.20698>:
  ptr.76 = ptr;
  D.20699 = mono_metadata_parse_type_full (m, container, 3, iftmp.79, ptr.76, &ptr);
  method->params[i] = D.20699;
  D.20700 = method->params[i];
  if (D.20700 == 0B) goto <D.20701>; else goto <D.20702>;
  <D.20701>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20677 = 0B;
  return D.20677;
  <D.20702>:
  if (is_open == 0) goto <D.20703>; else goto <D.20704>;
  <D.20703>:
  D.20700 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.20700);
  <D.20704>:
  i = i + 1;
  <D.18033>:
  D.20705 = method->param_count;
  D.20706 = (int) D.20705;
  if (D.20706 > i) goto <D.18032>; else goto <D.18034>;
  <D.18034>:
  if (def == 0) goto <D.20707>; else goto <D.20708>;
  <D.20707>:
  D.20682 = BIT_FIELD_REF <*method, 64, 64>;
  D.20683 = D.20682 & 64512;
  if (D.20683 == 5120) goto <D.20709>; else goto <D.20710>;
  <D.20709>:
  D.20686 = method->sentinelpos;
  if (D.20686 < 0) goto <D.20711>; else goto <D.20712>;
  <D.20711>:
  D.20705 = method->param_count;
  D.20713 = (short int) D.20705;
  method->sentinelpos = D.20713;
  <D.20712>:
  <D.20710>:
  <D.20708>:
  D.20714 = (unsigned char) is_open;
  D.20715 = (<unnamed-unsigned:1>) D.20714;
  method->has_type_parameters = D.20715;
  if (def != 0) goto <D.20716>; else goto <D.20717>;
  <D.20716>:
  D.20682 = BIT_FIELD_REF <*method, 64, 64>;
  D.20683 = D.20682 & 64512;
  if (D.20683 == 5120) goto <D.20718>; else goto <D.20719>;
  <D.20718>:
  D.20705 = method->param_count;
  D.20713 = (short int) D.20705;
  method->sentinelpos = D.20713;
  <D.20719>:
  <D.20717>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.20720>; else goto <D.20721>;
  <D.20720>:
  ptr.76 = ptr;
  *rptr = ptr.76;
  <D.20721>:
  D.20677 = method;
  return D.20677;
}


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

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


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.20725;
  struct MonoType * D.20728;
  short unsigned int D.20731;
  int D.20732;
  int i;

  D.20725 = sig->ret;
  if (D.20725 != 0B) goto <D.20726>; else goto <D.20727>;
  <D.20726>:
  D.20725 = sig->ret;
  mono_metadata_free_type (D.20725);
  <D.20727>:
  i = 0;
  goto <D.18049>;
  <D.18048>:
  D.20728 = sig->params[i];
  if (D.20728 != 0B) goto <D.20729>; else goto <D.20730>;
  <D.20729>:
  D.20728 = sig->params[i];
  mono_metadata_free_type (D.20728);
  <D.20730>:
  i = i + 1;
  <D.18049>:
  D.20731 = sig->param_count;
  D.20732 = (int) D.20731;
  if (D.20732 > i) goto <D.18048>; else goto <D.18050>;
  <D.18050>:
  monoeg_g_free (sig);
}


__attribute__((visibility ("hidden")))
mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20733;
  struct MonoMemPool * D.20736;
  void * D.20737;
  void * res;

  mono_image_set_lock (set);
  D.20733 = set->mempool;
  if (D.20733 == 0B) goto <D.20734>; else goto <D.20735>;
  <D.20734>:
  D.20736 = mono_mempool_new_size (1024);
  set->mempool = D.20736;
  <D.20735>:
  D.20733 = set->mempool;
  res = mono_mempool_alloc (D.20733, size);
  mono_image_set_unlock (set);
  D.20737 = res;
  return D.20737;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20739;
  _Bool D.20742;
  long int D.20743;
  long int D.20744;

  {
    int ret;

    D.20739 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.20739);
    if (ret != 0) goto <D.20740>; else goto <D.20741>;
    <D.20740>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20741>:
    D.20742 = ret != 0;
    D.20743 = (long int) D.20742;
    D.20744 = __builtin_expect (D.20743, 0);
    if (D.20744 != 0) goto <D.20745>; else goto <D.20746>;
    <D.20745>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.20746>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20747;
  _Bool D.20750;
  long int D.20751;
  long int D.20752;

  {
    int ret;

    D.20747 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.20747);
    if (ret != 0) goto <D.20748>; else goto <D.20749>;
    <D.20748>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20749>:
    D.20750 = ret != 0;
    D.20751 = (long int) D.20750;
    D.20752 = __builtin_expect (D.20751, 0);
    if (D.20752 != 0) goto <D.20753>; else goto <D.20754>;
    <D.20753>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.20754>:
  }
}


__attribute__((visibility ("hidden")))
mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20755;
  struct MonoMemPool * D.20758;
  void * D.20759;
  void * res;

  mono_image_set_lock (set);
  D.20755 = set->mempool;
  if (D.20755 == 0B) goto <D.20756>; else goto <D.20757>;
  <D.20756>:
  D.20758 = mono_mempool_new_size (1024);
  set->mempool = D.20758;
  <D.20757>:
  D.20755 = set->mempool;
  res = mono_mempool_alloc0 (D.20755, size);
  mono_image_set_unlock (set);
  D.20759 = res;
  return D.20759;
}


__attribute__((visibility ("hidden")))
mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.20761;
  struct MonoMemPool * D.20764;
  char * D.20765;
  char * res;

  mono_image_set_lock (set);
  D.20761 = set->mempool;
  if (D.20761 == 0B) goto <D.20762>; else goto <D.20763>;
  <D.20762>:
  D.20764 = mono_mempool_new_size (1024);
  set->mempool = D.20764;
  <D.20763>:
  D.20761 = set->mempool;
  res = mono_mempool_strdup (D.20761, s);
  mono_image_set_unlock (set);
  D.20765 = res;
  return D.20765;
}


__attribute__((visibility ("hidden")))
mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.20767;
  struct GSList * D.20768;
  struct GHashTable * D.20769;
  struct GHashTable * D.20770;
  struct GHashTable * D.20771;
  struct GHashTable * D.20772;
  void * D.20773;
  struct GSList * D.20774;
  struct GSList * D.20775;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.20767 = gclass_data.image;
      ginst_data.image = D.20767;
      gclass_data.list = 0B;
      D.20768 = gclass_data.list;
      ginst_data.list = D.20768;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.18297>;
      <D.18296>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.20769 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.20769, steal_gclass_in_image, &gclass_data);
        D.20770 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.20770, steal_ginst_in_image, &ginst_data);
        D.20771 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.20771, inflated_method_in_image, image);
        D.20772 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.20772, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.18297>:
      if (l != 0B) goto <D.18296>; else goto <D.18298>;
      <D.18298>:
      l = ginst_data.list;
      goto <D.18300>;
      <D.18299>:
      D.20773 = l->data;
      free_generic_inst (D.20773);
      l = l->next;
      <D.18300>:
      if (l != 0B) goto <D.18299>; else goto <D.18301>;
      <D.18301>:
      l = gclass_data.list;
      goto <D.18303>;
      <D.18302>:
      D.20773 = l->data;
      free_generic_class (D.20773);
      l = l->next;
      <D.18303>:
      if (l != 0B) goto <D.18302>; else goto <D.18304>;
      <D.18304>:
      D.20774 = ginst_data.list;
      monoeg_g_slist_free (D.20774);
      D.20768 = gclass_data.list;
      monoeg_g_slist_free (D.20768);
      D.20775 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.20775);
      l = set_list;
      goto <D.18307>;
      <D.18306>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.18307>:
      if (l != 0B) goto <D.18306>; else goto <D.18308>;
      <D.18308>:
      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.20776;
  int iftmp.80;
  struct MonoMethodSignature * D.20782;
  int D.20783;
  struct MonoGenericInst * D.20785;
  int D.20787;
  struct MonoGenericInst * D.20788;
  int D.20790;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.20782 = sig->sig;
  D.20783 = signature_in_image (D.20782, image);
  if (D.20783 != 0) goto <D.20778>; else goto <D.20784>;
  <D.20784>:
  D.20785 = sig->context.class_inst;
  if (D.20785 != 0B) goto <D.20786>; else goto <D.20779>;
  <D.20786>:
  D.20785 = sig->context.class_inst;
  D.20787 = ginst_in_image (D.20785, image);
  if (D.20787 != 0) goto <D.20778>; else goto <D.20779>;
  <D.20779>:
  D.20788 = sig->context.method_inst;
  if (D.20788 != 0B) goto <D.20789>; else goto <D.20780>;
  <D.20789>:
  D.20788 = sig->context.method_inst;
  D.20790 = ginst_in_image (D.20788, image);
  if (D.20790 != 0) goto <D.20778>; else goto <D.20780>;
  <D.20778>:
  iftmp.80 = 1;
  goto <D.20781>;
  <D.20780>:
  iftmp.80 = 0;
  <D.20781>:
  D.20776 = iftmp.80;
  return D.20776;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.20792;
  gboolean D.20795;
  struct MonoType * D.20796;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.18081>;
      <D.18080>:
      D.20792 = type_in_image (p, image);
      if (D.20792 != 0) goto <D.20793>; else goto <D.20794>;
      <D.20793>:
      D.20795 = 1;
      return D.20795;
      <D.20794>:
      <D.18081>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.18080>; else goto <D.18082>;
      <D.18082>:
      D.20796 = mono_signature_get_return_type (sig);
      D.20795 = type_in_image (D.20796, image);
      return D.20795;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.20799;
  int D.20800;
  gboolean D.20801;
  struct MonoGenericClass * D.20802;
  struct MonoClass * D.20803;
  struct MonoArrayType * D.20804;
  struct MonoClass * D.20805;
  struct MonoMethodSignature * D.20806;
  struct MonoGenericParam * D.20807;
  long unsigned int D.20810;
  long unsigned int D.20811;
  _Bool D.20812;
  long int D.20813;
  long int D.20814;
  struct MonoClass * D.20817;
  struct MonoImage * D.20820;
  _Bool D.20821;
  struct MonoImage * D.20822;
  _Bool D.20823;
  struct MonoImage * D.20824;
  _Bool D.20825;
  long unsigned int D.20830;
  long unsigned int D.20831;
  _Bool D.20832;
  long int D.20833;
  long int D.20834;
  struct MonoMethod * D.20837;
  struct MonoImage * D.20840;
  _Bool D.20841;
  struct MonoClass * D.20842;
  struct MonoImage * D.20843;
  _Bool D.20844;
  struct MonoClass * D.20845;
  struct MonoImage * D.20846;
  _Bool D.20847;
  void retry = <<< error >>>;

  retry:
  D.20799 = type->type;
  D.20800 = (int) D.20799;
  switch (D.20800) <default: <D.18109>, case 15: <D.18101>, case 19: <D.18105>, case 20: <D.18103>, case 21: <D.18100>, case 27: <D.18104>, case 29: <D.18102>, case 30: <D.18107>>
  <D.18100>:
  D.20802 = type->data.generic_class;
  D.20801 = gclass_in_image (D.20802, image);
  return D.20801;
  <D.18101>:
  type = type->data.type;
  goto retry;
  <D.18102>:
  D.20803 = type->data.klass;
  type = &D.20803->byval_arg;
  goto retry;
  <D.18103>:
  D.20804 = type->data.array;
  D.20805 = D.20804->eklass;
  type = &D.20805->byval_arg;
  goto retry;
  <D.18104>:
  D.20806 = type->data.method;
  D.20801 = signature_in_image (D.20806, image);
  return D.20801;
  <D.18105>:
  {
    struct MonoGenericContainer * container;

    D.20807 = type->data.generic_param;
    container = D.20807->owner;
    if (container != 0B) goto <D.20808>; else goto <D.20809>;
    <D.20808>:
    D.20810 = BIT_FIELD_REF <*container, 64, 256>;
    D.20811 = D.20810 & 4294967296;
    D.20812 = D.20811 != 0;
    D.20813 = (long int) D.20812;
    D.20814 = __builtin_expect (D.20813, 0);
    if (D.20814 != 0) goto <D.20815>; else goto <D.20816>;
    <D.20815>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.20816>:
    D.20817 = container->owner.klass;
    if (D.20817 == 0B) goto <D.20818>; else goto <D.20819>;
    <D.20818>:
    D.20820 = container->image;
    D.20821 = D.20820 == image;
    D.20801 = (gboolean) D.20821;
    return D.20801;
    <D.20819>:
    D.20817 = container->owner.klass;
    D.20822 = D.20817->image;
    D.20823 = D.20822 == image;
    D.20801 = (gboolean) D.20823;
    return D.20801;
    <D.20809>:
    D.20807 = type->data.generic_param;
    D.20824 = D.20807->image;
    D.20825 = D.20824 == image;
    D.20801 = (gboolean) D.20825;
    return D.20801;
  }
  <D.18107>:
  {
    struct MonoGenericContainer * container;

    D.20807 = type->data.generic_param;
    container = D.20807->owner;
    D.20807 = type->data.generic_param;
    D.20824 = D.20807->image;
    if (D.20824 == image) goto <D.20826>; else goto <D.20827>;
    <D.20826>:
    D.20801 = 1;
    return D.20801;
    <D.20827>:
    if (container != 0B) goto <D.20828>; else goto <D.20829>;
    <D.20828>:
    D.20830 = BIT_FIELD_REF <*container, 64, 256>;
    D.20831 = D.20830 & 4294967296;
    D.20832 = D.20831 == 0;
    D.20833 = (long int) D.20832;
    D.20834 = __builtin_expect (D.20833, 0);
    if (D.20834 != 0) goto <D.20835>; else goto <D.20836>;
    <D.20835>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.20836>:
    D.20837 = container->owner.method;
    if (D.20837 == 0B) goto <D.20838>; else goto <D.20839>;
    <D.20838>:
    D.20840 = container->image;
    D.20841 = D.20840 == image;
    D.20801 = (gboolean) D.20841;
    return D.20801;
    <D.20839>:
    D.20837 = container->owner.method;
    D.20842 = D.20837->klass;
    D.20843 = D.20842->image;
    D.20844 = D.20843 == image;
    D.20801 = (gboolean) D.20844;
    return D.20801;
    <D.20829>:
    D.20807 = type->data.generic_param;
    D.20824 = D.20807->image;
    D.20825 = D.20824 == image;
    D.20801 = (gboolean) D.20825;
    return D.20801;
  }
  <D.18109>:
  D.20845 = mono_class_from_mono_type (type);
  D.20846 = D.20845->image;
  D.20847 = D.20846 == image;
  D.20801 = (gboolean) D.20847;
  return D.20801;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.20849;
  int iftmp.81;
  struct MonoClass * D.20854;
  struct MonoImage * D.20855;
  struct MonoGenericInst * D.20857;
  int D.20858;

  D.20854 = gclass->container_class;
  D.20855 = D.20854->image;
  if (D.20855 == image) goto <D.20851>; else goto <D.20856>;
  <D.20856>:
  D.20857 = gclass->context.class_inst;
  D.20858 = ginst_in_image (D.20857, image);
  if (D.20858 != 0) goto <D.20851>; else goto <D.20852>;
  <D.20851>:
  iftmp.81 = 1;
  goto <D.20853>;
  <D.20852>:
  iftmp.81 = 0;
  <D.20853>:
  D.20849 = iftmp.81;
  return D.20849;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.20860;
  int D.20861;
  gboolean D.20864;
  <unnamed-unsigned:22> D.20865;
  int D.20866;
  int i;

  i = 0;
  goto <D.18089>;
  <D.18088>:
  D.20860 = ginst->type_argv[i];
  D.20861 = type_in_image (D.20860, image);
  if (D.20861 != 0) goto <D.20862>; else goto <D.20863>;
  <D.20862>:
  D.20864 = 1;
  return D.20864;
  <D.20863>:
  i = i + 1;
  <D.18089>:
  D.20865 = ginst->type_argc;
  D.20866 = (int) D.20865;
  if (D.20866 > i) goto <D.18088>; else goto <D.18090>;
  <D.18090>:
  D.20864 = 0;
  return D.20864;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.82;
  struct MonoMethod * D.20874;
  struct MonoClass * D.20875;
  struct MonoImage * D.20876;
  struct MonoGenericInst * D.20878;
  int D.20880;
  struct MonoGenericInst * D.20881;
  int D.20883;
  struct MonoMethodSignature * D.20884;
  struct MonoMethodSignature * D.20886;
  int D.20887;
  _Bool D.20888;
  long int D.20889;
  long int D.20890;
  gboolean D.20893;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.20874 = method->declaring;
  D.20875 = D.20874->klass;
  D.20876 = D.20875->image;
  if (D.20876 != image) goto <D.20877>; else goto <D.20869>;
  <D.20877>:
  D.20878 = method->context.class_inst;
  if (D.20878 == 0B) goto <D.20870>; else goto <D.20879>;
  <D.20879>:
  D.20878 = method->context.class_inst;
  D.20880 = ginst_in_image (D.20878, image);
  if (D.20880 == 0) goto <D.20870>; else goto <D.20869>;
  <D.20870>:
  D.20881 = method->context.method_inst;
  if (D.20881 == 0B) goto <D.20871>; else goto <D.20882>;
  <D.20882>:
  D.20881 = method->context.method_inst;
  D.20883 = ginst_in_image (D.20881, image);
  if (D.20883 == 0) goto <D.20871>; else goto <D.20869>;
  <D.20871>:
  D.20884 = MEM[(struct MonoMethod *)method].signature;
  if (D.20884 == 0B) goto <D.20872>; else goto <D.20885>;
  <D.20885>:
  D.20886 = mono_method_signature (method);
  D.20887 = signature_in_image (D.20886, image);
  if (D.20887 == 0) goto <D.20872>; else goto <D.20869>;
  <D.20872>:
  iftmp.82 = 1;
  goto <D.20873>;
  <D.20869>:
  iftmp.82 = 0;
  <D.20873>:
  D.20888 = iftmp.82 != 0;
  D.20889 = (long int) D.20888;
  D.20890 = __builtin_expect (D.20889, 0);
  if (D.20890 != 0) goto <D.20891>; else goto <D.20892>;
  <D.20891>:
  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.20892>:
  D.20893 = 1;
  return D.20893;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.20895;
  struct GSList * D.20896;
  gboolean D.20897;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.20895 = user_data->list;
  D.20896 = monoeg_g_slist_prepend (D.20895, ginst);
  user_data->list = D.20896;
  D.20897 = 1;
  return D.20897;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.20899;
  int D.20900;
  _Bool D.20901;
  long int D.20902;
  long int D.20903;
  struct GSList * D.20906;
  struct GSList * D.20907;
  gboolean D.20908;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.20899 = user_data->image;
  D.20900 = gclass_in_image (gclass, D.20899);
  D.20901 = D.20900 == 0;
  D.20902 = (long int) D.20901;
  D.20903 = __builtin_expect (D.20902, 0);
  if (D.20903 != 0) goto <D.20904>; else goto <D.20905>;
  <D.20904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.20905>:
  D.20906 = user_data->list;
  D.20907 = monoeg_g_slist_prepend (D.20906, gclass);
  user_data->list = D.20907;
  D.20908 = 1;
  return D.20908;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.20910;
  <unnamed-unsigned:22> D.20911;
  int D.20912;
  int i;

  i = 0;
  goto <D.18323>;
  <D.18322>:
  D.20910 = ginst->type_argv[i];
  mono_metadata_free_type (D.20910);
  i = i + 1;
  <D.18323>:
  D.20911 = ginst->type_argc;
  D.20912 = (int) D.20911;
  if (D.20912 > i) goto <D.18322>; else goto <D.18324>;
  <D.18324>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  long unsigned int D.20913;
  long unsigned int D.20914;
  struct MonoClass * D.20917;
  short unsigned int D.20920;

  D.20913 = BIT_FIELD_REF <*gclass, 64, 192>;
  D.20914 = D.20913 & 9223372036854775808;
  if (D.20914 != 0) goto <D.20915>; else goto <D.20916>;
  <D.20915>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.20916>:
  D.20917 = gclass->cached_class;
  if (D.20917 != 0B) goto <D.20918>; else goto <D.20919>;
  <D.20918>:
  D.20917 = gclass->cached_class;
  D.20920 = D.20917->interface_id;
  if (D.20920 != 0) goto <D.20921>; else goto <D.20922>;
  <D.20921>:
  D.20917 = gclass->cached_class;
  mono_unload_interface_id (D.20917);
  <D.20922>:
  <D.20919>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.20923;
  struct GHashTable * D.20924;
  struct GHashTable * D.20925;
  struct GHashTable * D.20926;
  struct MonoImage * * D.20927;
  long unsigned int D.20928;
  long unsigned int D.20929;
  struct MonoImage * * D.20930;
  struct MonoImage * D.20931;
  struct GSList * D.20932;
  struct GSList * D.20933;
  int D.20934;
  struct GPtrArray * image_sets.83;
  struct MonoMemPool * D.20936;
  struct CRITICAL_SECTION * D.20939;
  int i;

  D.20923 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.20923);
  D.20924 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.20924);
  D.20925 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.20925);
  D.20926 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.20926);
  i = 0;
  goto <D.18139>;
  <D.18138>:
  D.20927 = set->images;
  D.20928 = (long unsigned int) i;
  D.20929 = D.20928 * 8;
  D.20930 = D.20927 + D.20929;
  D.20931 = *D.20930;
  D.20927 = set->images;
  D.20928 = (long unsigned int) i;
  D.20929 = D.20928 * 8;
  D.20930 = D.20927 + D.20929;
  D.20931 = *D.20930;
  D.20932 = D.20931->image_sets;
  D.20933 = monoeg_g_slist_remove (D.20932, set);
  D.20931->image_sets = D.20933;
  i = i + 1;
  <D.18139>:
  D.20934 = set->nimages;
  if (D.20934 > i) goto <D.18138>; else goto <D.18140>;
  <D.18140>:
  image_sets.83 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.83, set);
  D.20936 = set->mempool;
  if (D.20936 != 0B) goto <D.20937>; else goto <D.20938>;
  <D.20937>:
  D.20936 = set->mempool;
  mono_mempool_destroy (D.20936);
  <D.20938>:
  D.20927 = set->images;
  monoeg_g_free (D.20927);
  D.20939 = &set->lock;
  DeleteCriticalSection (D.20939);
  monoeg_g_free (set);
}


__attribute__((visibility ("hidden")))
mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  struct MonoImage * * D.20940;
  int D.20941;
  struct GHashTable * D.20944;
  struct MonoMethodInflated * D.20945;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.20940 = data.images;
      D.20941 = data.nimages;
      set = get_image_set (D.20940, D.20941);
      collect_data_free (&data);
      if (cache != 0) goto <D.20942>; else goto <D.20943>;
      <D.20942>:
      D.20944 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.20944, method, method, 0);
      D.20945 = method;
      return D.20945;
      <D.20943>:
      D.20944 = set->gmethod_cache;
      D.20945 = monoeg_g_hash_table_lookup (D.20944, method);
      return D.20945;
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.20949;
  struct MonoClass * D.20950;
  struct MonoImage * D.20951;
  struct MonoGenericInst * D.20952;
  struct MonoGenericInst * D.20955;
  struct MonoClass * D.20958;
  struct MonoImage * D.20959;
  long unsigned int D.20960;
  long unsigned int D.20961;
  struct MonoMethodSignature * D.20964;
  struct MonoMethod * m;

  m = method->declaring;
  D.20949 = method->declaring;
  D.20950 = D.20949->klass;
  D.20951 = D.20950->image;
  add_image (D.20951, data);
  D.20952 = method->context.class_inst;
  if (D.20952 != 0B) goto <D.20953>; else goto <D.20954>;
  <D.20953>:
  D.20952 = method->context.class_inst;
  collect_ginst_images (D.20952, data);
  <D.20954>:
  D.20955 = method->context.method_inst;
  if (D.20955 != 0B) goto <D.20956>; else goto <D.20957>;
  <D.20956>:
  D.20955 = method->context.method_inst;
  collect_ginst_images (D.20955, data);
  <D.20957>:
  D.20958 = m->klass;
  D.20959 = D.20958->image;
  D.20960 = BIT_FIELD_REF <*D.20959, 64, 192>;
  D.20961 = D.20960 & 268435456;
  if (D.20961 != 0) goto <D.20962>; else goto <D.20963>;
  <D.20962>:
  D.20964 = mono_method_signature (m);
  collect_signature_images (D.20964, data);
  <D.20963>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.20965;
  long unsigned int D.20966;
  long unsigned int D.20967;
  struct MonoImage * * D.20968;
  struct MonoImage * D.20969;
  int D.20972;
  int D.20973;
  int D.20976;
  int D.20977;
  long unsigned int D.20978;
  long unsigned int D.20979;
  struct MonoImage * * D.20980;
  int i;

  i = 0;
  goto <D.18187>;
  <D.18186>:
  D.20965 = data->images;
  D.20966 = (long unsigned int) i;
  D.20967 = D.20966 * 8;
  D.20968 = D.20965 + D.20967;
  D.20969 = *D.20968;
  if (D.20969 == image) goto <D.20970>; else goto <D.20971>;
  <D.20970>:
  return;
  <D.20971>:
  i = i + 1;
  <D.18187>:
  D.20972 = data->nimages;
  if (D.20972 > i) goto <D.18186>; else goto <D.18188>;
  <D.18188>:
  D.20972 = data->nimages;
  D.20973 = data->images_len;
  if (D.20972 == D.20973) goto <D.20974>; else goto <D.20975>;
  <D.20974>:
  enlarge_data (data);
  <D.20975>:
  D.20965 = data->images;
  D.20972 = data->nimages;
  D.20976 = D.20972;
  D.20977 = D.20976 + 1;
  data->nimages = D.20977;
  D.20978 = (long unsigned int) D.20976;
  D.20979 = D.20978 * 8;
  D.20980 = D.20965 + D.20979;
  *D.20980 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.84;
  int D.20983;
  long unsigned int D.20987;
  long unsigned int D.20988;
  struct MonoImage * * D.20989;
  long unsigned int D.20990;
  struct MonoImage *[64] * D.20991;
  int new_len;
  struct MonoImage * * d;

  D.20983 = data->images_len;
  if (D.20983 > 15) goto <D.20984>; else goto <D.20985>;
  <D.20984>:
  D.20983 = data->images_len;
  iftmp.84 = D.20983 * 2;
  goto <D.20986>;
  <D.20985>:
  iftmp.84 = 16;
  <D.20986>:
  new_len = iftmp.84;
  D.20987 = (long unsigned int) new_len;
  D.20988 = D.20987 * 8;
  d = monoeg_malloc (D.20988);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.20989 = data->images;
  D.20983 = data->images_len;
  D.20990 = (long unsigned int) D.20983;
  memcpy (d, D.20989, D.20990);
  D.20989 = data->images;
  D.20991 = &data->image_buf;
  if (D.20989 != D.20991) goto <D.20992>; else goto <D.20993>;
  <D.20992>:
  D.20989 = data->images;
  monoeg_g_free (D.20989);
  <D.20993>:
  data->images = d;
  data->images_len = new_len;
}


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

  i = 0;
  goto <D.18198>;
  <D.18197>:
  D.20994 = ginst->type_argv[i];
  collect_type_images (D.20994, data);
  i = i + 1;
  <D.18198>:
  D.20995 = ginst->type_argc;
  D.20996 = (int) D.20995;
  if (D.20996 > i) goto <D.18197>; else goto <D.18199>;
  <D.18199>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.20997;
  int D.20998;
  struct MonoGenericClass * D.20999;
  struct MonoClass * D.21000;
  struct MonoArrayType * D.21001;
  struct MonoClass * D.21002;
  struct MonoGenericParam * D.21003;
  long unsigned int D.21006;
  long unsigned int D.21007;
  _Bool D.21008;
  long int D.21009;
  long int D.21010;
  struct MonoClass * D.21013;
  struct MonoImage * D.21016;
  struct MonoImage * D.21018;
  struct MonoImage * D.21020;
  struct MonoMethod * D.21025;
  struct MonoImage * D.21028;
  long unsigned int D.21030;
  long unsigned int D.21031;
  _Bool D.21032;
  long int D.21033;
  long int D.21034;
  struct MonoClass * D.21037;
  struct MonoImage * D.21038;
  struct MonoClass * D.21040;
  struct MonoImage * D.21041;
  struct MonoImage * D.21042;
  void retry = <<< error >>>;

  retry:
  D.20997 = type->type;
  D.20998 = (int) D.20997;
  switch (D.20998) <default: <D.18239>, case 15: <D.18229>, case 17: <D.18238>, case 18: <D.18237>, case 19: <D.18233>, case 20: <D.18231>, case 21: <D.18227>, case 27: <D.18232>, case 29: <D.18230>, case 30: <D.18235>>
  <D.18227>:
  D.20999 = type->data.generic_class;
  collect_gclass_images (D.20999, data);
  goto <D.18228>;
  <D.18229>:
  type = type->data.type;
  goto retry;
  <D.18230>:
  D.21000 = type->data.klass;
  type = &D.21000->byval_arg;
  goto retry;
  <D.18231>:
  D.21001 = type->data.array;
  D.21002 = D.21001->eklass;
  type = &D.21002->byval_arg;
  goto retry;
  <D.18232>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.18233>:
  {
    struct MonoGenericContainer * container;

    D.21003 = type->data.generic_param;
    container = D.21003->owner;
    if (container != 0B) goto <D.21004>; else goto <D.21005>;
    <D.21004>:
    D.21006 = BIT_FIELD_REF <*container, 64, 256>;
    D.21007 = D.21006 & 4294967296;
    D.21008 = D.21007 != 0;
    D.21009 = (long int) D.21008;
    D.21010 = __builtin_expect (D.21009, 0);
    if (D.21010 != 0) goto <D.21011>; else goto <D.21012>;
    <D.21011>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.21012>:
    D.21013 = container->owner.klass;
    if (D.21013 == 0B) goto <D.21014>; else goto <D.21015>;
    <D.21014>:
    D.21016 = container->image;
    add_image (D.21016, data);
    goto <D.21017>;
    <D.21015>:
    D.21013 = container->owner.klass;
    D.21018 = D.21013->image;
    add_image (D.21018, data);
    <D.21017>:
    goto <D.21019>;
    <D.21005>:
    D.21003 = type->data.generic_param;
    D.21020 = D.21003->image;
    add_image (D.21020, data);
    <D.21019>:
  }
  goto <D.18228>;
  <D.18235>:
  {
    struct MonoGenericContainer * container;

    D.21003 = type->data.generic_param;
    container = D.21003->owner;
    D.21003 = type->data.generic_param;
    D.21020 = D.21003->image;
    if (D.21020 != 0B) goto <D.21021>; else goto <D.21022>;
    <D.21021>:
    D.21003 = type->data.generic_param;
    D.21020 = D.21003->image;
    add_image (D.21020, data);
    <D.21022>:
    if (container != 0B) goto <D.21023>; else goto <D.21024>;
    <D.21023>:
    D.21025 = container->owner.method;
    if (D.21025 == 0B) goto <D.21026>; else goto <D.21027>;
    <D.21026>:
    D.21028 = container->image;
    add_image (D.21028, data);
    goto <D.21029>;
    <D.21027>:
    D.21030 = BIT_FIELD_REF <*container, 64, 256>;
    D.21031 = D.21030 & 4294967296;
    D.21032 = D.21031 == 0;
    D.21033 = (long int) D.21032;
    D.21034 = __builtin_expect (D.21033, 0);
    if (D.21034 != 0) goto <D.21035>; else goto <D.21036>;
    <D.21035>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.21036>:
    D.21025 = container->owner.method;
    D.21037 = D.21025->klass;
    D.21038 = D.21037->image;
    add_image (D.21038, data);
    <D.21029>:
    goto <D.21039>;
    <D.21024>:
    D.21003 = type->data.generic_param;
    D.21020 = D.21003->image;
    add_image (D.21020, data);
    <D.21039>:
  }
  goto <D.18228>;
  <D.18237>:
  <D.18238>:
  D.21040 = mono_class_from_mono_type (type);
  D.21041 = D.21040->image;
  add_image (D.21041, data);
  goto <D.18228>;
  <D.18239>:
  D.21042 = mono_defaults.corlib;
  add_image (D.21042, data);
  <D.18228>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.21043;
  struct MonoImage * D.21044;
  struct MonoGenericInst * D.21045;

  D.21043 = gclass->container_class;
  D.21044 = D.21043->image;
  add_image (D.21044, data);
  D.21045 = gclass->context.class_inst;
  if (D.21045 != 0B) goto <D.21046>; else goto <D.21047>;
  <D.21046>:
  D.21045 = gclass->context.class_inst;
  collect_ginst_images (D.21045, data);
  <D.21047>:
}


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

  try
    {
      iter = 0B;
      D.21048 = mono_signature_get_return_type (sig);
      collect_type_images (D.21048, data);
      goto <D.18211>;
      <D.18210>:
      collect_type_images (p, data);
      <D.18211>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.18210>; else goto <D.18212>;
      <D.18212>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.85;
  struct GPtrArray * D.21052;
  struct MonoImage * D.21055;
  struct MonoImage * D.21056;
  struct MonoImageSet * mscorlib_image_set.86;
  struct MonoImageSet * D.21062;
  struct MonoImage * * D.21069;
  struct MonoImage * D.21070;
  int D.21071;
  struct MonoImage * * D.21074;
  long unsigned int D.21075;
  long unsigned int D.21076;
  struct MonoImage * * D.21077;
  struct MonoImage * D.21078;
  long unsigned int D.21079;
  long unsigned int D.21080;
  struct MonoImage * * D.21081;
  struct MonoImage * D.21082;
  long unsigned int D.21088;
  long unsigned int D.21089;
  void * D.21090;
  struct CRITICAL_SECTION * D.21091;
  long unsigned int D.21092;
  long unsigned int D.21093;
  struct MonoImage * * D.21094;
  struct MonoImage * * D.21095;
  struct MonoImage * D.21096;
  struct GHashTable * D.21097;
  struct GHashTable * D.21098;
  struct GHashTable * D.21099;
  struct GHashTable * D.21100;
  struct MonoImage * D.21101;
  struct GSList * D.21102;
  struct GSList * D.21103;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.85 = image_sets;
  if (image_sets.85 == 0B) goto <D.21050>; else goto <D.21051>;
  <D.21050>:
  D.21052 = monoeg_g_ptr_array_new ();
  image_sets = D.21052;
  <D.21051>:
  if (nimages == 1) goto <D.21053>; else goto <D.21054>;
  <D.21053>:
  D.21055 = *images;
  D.21056 = mono_defaults.corlib;
  if (D.21055 == D.21056) goto <D.21057>; else goto <D.21058>;
  <D.21057>:
  mscorlib_image_set.86 = mscorlib_image_set;
  if (mscorlib_image_set.86 != 0B) goto <D.21060>; else goto <D.21061>;
  <D.21060>:
  D.21062 = mscorlib_image_set;
  return D.21062;
  <D.21061>:
  <D.21058>:
  <D.21054>:
  if (nimages == 0) goto <D.21063>; else goto <D.21064>;
  <D.21063>:
  D.21062 = mscorlib_image_set;
  return D.21062;
  <D.21064>:
  D.21055 = *images;
  D.21056 = mono_defaults.corlib;
  if (D.21055 == D.21056) goto <D.21067>; else goto <D.21065>;
  <D.21067>:
  if (nimages > 1) goto <D.21068>; else goto <D.21065>;
  <D.21068>:
  D.21069 = images + 8;
  D.21070 = *D.21069;
  l = D.21070->image_sets;
  goto <D.21066>;
  <D.21065>:
  D.21055 = *images;
  l = D.21055->image_sets;
  <D.21066>:
  set = 0B;
  goto <D.18127>;
  <D.18126>:
  set = l->data;
  D.21071 = set->nimages;
  if (D.21071 == nimages) goto <D.21072>; else goto <D.21073>;
  <D.21072>:
  j = 0;
  goto <D.18124>;
  <D.18123>:
  k = 0;
  goto <D.18121>;
  <D.18120>:
  D.21074 = set->images;
  D.21075 = (long unsigned int) k;
  D.21076 = D.21075 * 8;
  D.21077 = D.21074 + D.21076;
  D.21078 = *D.21077;
  D.21079 = (long unsigned int) j;
  D.21080 = D.21079 * 8;
  D.21081 = images + D.21080;
  D.21082 = *D.21081;
  if (D.21078 == D.21082) goto <D.18119>; else goto <D.21083>;
  <D.21083>:
  k = k + 1;
  <D.18121>:
  if (k < nimages) goto <D.18120>; else goto <D.18119>;
  <D.18119>:
  if (k == nimages) goto <D.18122>; else goto <D.21084>;
  <D.21084>:
  j = j + 1;
  <D.18124>:
  if (j < nimages) goto <D.18123>; else goto <D.18122>;
  <D.18122>:
  if (j == nimages) goto <D.18125>; else goto <D.21085>;
  <D.21085>:
  <D.21073>:
  l = l->next;
  <D.18127>:
  if (l != 0B) goto <D.18126>; else goto <D.18125>;
  <D.18125>:
  if (l == 0B) goto <D.21086>; else goto <D.21087>;
  <D.21086>:
  set = monoeg_malloc0 (104);
  set->nimages = nimages;
  D.21088 = (long unsigned int) nimages;
  D.21089 = D.21088 * 8;
  D.21090 = monoeg_malloc0 (D.21089);
  set->images = D.21090;
  D.21091 = &set->lock;
  InitializeCriticalSection (D.21091);
  i = 0;
  goto <D.18129>;
  <D.18128>:
  D.21074 = set->images;
  D.21092 = (long unsigned int) i;
  D.21093 = D.21092 * 8;
  D.21094 = D.21074 + D.21093;
  D.21092 = (long unsigned int) i;
  D.21093 = D.21092 * 8;
  D.21095 = images + D.21093;
  D.21096 = *D.21095;
  *D.21094 = D.21096;
  i = i + 1;
  <D.18129>:
  if (i < nimages) goto <D.18128>; else goto <D.18130>;
  <D.18130>:
  D.21097 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.21097;
  D.21098 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.21098;
  D.21099 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.21099;
  D.21100 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.21100;
  i = 0;
  goto <D.18132>;
  <D.18131>:
  D.21074 = set->images;
  D.21092 = (long unsigned int) i;
  D.21093 = D.21092 * 8;
  D.21094 = D.21074 + D.21093;
  D.21101 = *D.21094;
  D.21074 = set->images;
  D.21092 = (long unsigned int) i;
  D.21093 = D.21092 * 8;
  D.21094 = D.21074 + D.21093;
  D.21101 = *D.21094;
  D.21102 = D.21101->image_sets;
  D.21103 = monoeg_g_slist_prepend (D.21102, set);
  D.21101->image_sets = D.21103;
  i = i + 1;
  <D.18132>:
  if (i < nimages) goto <D.18131>; else goto <D.18133>;
  <D.18133>:
  image_sets.85 = image_sets;
  monoeg_g_ptr_array_add (image_sets.85, set);
  <D.21087>:
  if (nimages == 1) goto <D.21104>; else goto <D.21105>;
  <D.21104>:
  D.21055 = *images;
  D.21056 = mono_defaults.corlib;
  if (D.21055 == D.21056) goto <D.21106>; else goto <D.21107>;
  <D.21106>:
  mscorlib_image_set = set;
  <D.21107>:
  <D.21105>:
  D.21062 = set;
  return D.21062;
}


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

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


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.21110;
  struct MonoMethodSignature * D.21111;
  gboolean D.21114;
  const struct MonoGenericContext * D.21115;
  const struct MonoGenericContext * D.21116;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.21110 = sig1->sig;
  D.21111 = sig2->sig;
  if (D.21110 != D.21111) goto <D.21112>; else goto <D.21113>;
  <D.21112>:
  D.21114 = 0;
  return D.21114;
  <D.21113>:
  D.21115 = &sig1->context;
  D.21116 = &sig2->context;
  D.21114 = mono_metadata_generic_context_equal (D.21115, D.21116);
  return D.21114;
}


inflated_signature_hash (const void * a)
{
  guint D.21118;
  const struct MonoGenericContext * D.21119;
  unsigned int D.21120;
  struct MonoMethodSignature * D.21121;
  unsigned int D.21122;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.21119 = &sig->context;
  D.21120 = mono_metadata_generic_context_hash (D.21119);
  D.21121 = sig->sig;
  D.21122 = mono_aligned_addr_hash (D.21121);
  D.21118 = D.21120 ^ D.21122;
  return D.21118;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.21124;
  short unsigned int D.21127;
  int D.21128;
  int D.21129;
  short unsigned int D.21132;
  unsigned int D.21133;
  unsigned int D.21134;
  int D.21137;
  struct MonoType * D.21142;
  short unsigned int D.21143;
  int D.21144;
  struct MonoExceptionClause * D.21145;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.21124 = method->signature;
  if (D.21124 != 0B) goto <D.21125>; else goto <D.21126>;
  <D.21125>:
  D.21124 = method->signature;
  mono_metadata_free_inflated_signature (D.21124);
  <D.21126>:
  D.21127 = method->flags;
  D.21128 = (int) D.21127;
  D.21129 = D.21128 & 1024;
  if (D.21129 == 0) goto <D.21130>; else goto <D.21131>;
  <D.21130>:
  D.21132 = method->iflags;
  D.21133 = (unsigned int) D.21132;
  D.21134 = D.21133 & 4099;
  if (D.21134 == 0) goto <D.21135>; else goto <D.21136>;
  <D.21135>:
  D.21127 = method->flags;
  D.21128 = (int) D.21127;
  D.21137 = D.21128 & 8192;
  if (D.21137 == 0) goto <D.21138>; else goto <D.21139>;
  <D.21138>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.21140>; else goto <D.21141>;
    <D.21140>:
    i = 0;
    goto <D.18316>;
    <D.18315>:
    D.21142 = header->locals[i];
    mono_metadata_free_type (D.21142);
    i = i + 1;
    <D.18316>:
    D.21143 = header->num_locals;
    D.21144 = (int) D.21143;
    if (D.21144 > i) goto <D.18315>; else goto <D.18317>;
    <D.18317>:
    D.21145 = header->clauses;
    monoeg_g_free (D.21145);
    monoeg_g_free (header);
    <D.21141>:
  }
  <D.21139>:
  <D.21136>:
  <D.21131>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.21146;
  struct MonoMethod * D.21147;
  gboolean D.21150;
  long unsigned int D.21151;
  long unsigned int D.21152;
  long unsigned int D.21153;
  long unsigned int D.21154;
  const struct MonoGenericContext * D.21157;
  const struct MonoGenericContext * D.21158;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.21146 = ma->declaring;
  D.21147 = mb->declaring;
  if (D.21146 != D.21147) goto <D.21148>; else goto <D.21149>;
  <D.21148>:
  D.21150 = 0;
  return D.21150;
  <D.21149>:
  D.21151 = BIT_FIELD_REF <MEM[(void *)ma], 64, 256>;
  D.21152 = BIT_FIELD_REF <MEM[(void *)mb], 64, 256>;
  D.21153 = D.21151 ^ D.21152;
  D.21154 = D.21153 & 281474976710656;
  if (D.21154 != 0) goto <D.21155>; else goto <D.21156>;
  <D.21155>:
  D.21150 = 0;
  return D.21150;
  <D.21156>:
  D.21157 = &ma->context;
  D.21158 = &mb->context;
  D.21150 = mono_metadata_generic_context_equal (D.21157, D.21158);
  return D.21150;
}


inflated_method_hash (const void * a)
{
  guint D.21160;
  const struct MonoGenericContext * D.21161;
  unsigned int D.21162;
  struct MonoMethod * D.21163;
  unsigned int D.21164;
  unsigned int D.21165;
  <unnamed-unsigned:1> D.21166;
  unsigned int D.21167;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.21161 = &ma->context;
  D.21162 = mono_metadata_generic_context_hash (D.21161);
  D.21163 = ma->declaring;
  D.21164 = mono_aligned_addr_hash (D.21163);
  D.21165 = D.21162 ^ D.21164;
  D.21166 = ma->method.method.is_mb_open;
  D.21167 = (unsigned int) D.21166;
  D.21160 = D.21165 + D.21167;
  return D.21160;
}


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

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


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.21171;
  struct MonoImage *[64] * D.21172;

  D.21171 = data->images;
  D.21172 = &data->image_buf;
  if (D.21171 != D.21172) goto <D.21173>; else goto <D.21174>;
  <D.21173>:
  D.21171 = data->images;
  monoeg_g_free (D.21171);
  <D.21174>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21175;
  struct MonoGenericInst * D.21176;
  struct MonoImage * * D.21177;
  int D.21178;
  struct GHashTable * D.21179;
  struct MonoMethodSignature * D.21182;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.21175 = context->class_inst;
      helper.context.class_inst = D.21175;
      D.21176 = context->method_inst;
      helper.context.method_inst = D.21176;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.21177 = data.images;
      D.21178 = data.nimages;
      set = get_image_set (D.21177, D.21178);
      collect_data_free (&data);
      D.21179 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.21179, &helper);
      if (res == 0B) goto <D.21180>; else goto <D.21181>;
      <D.21180>:
      res = monoeg_malloc0 (24);
      res->sig = sig;
      D.21175 = context->class_inst;
      res->context.class_inst = D.21175;
      D.21176 = context->method_inst;
      res->context.method_inst = D.21176;
      D.21179 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.21179, res, res, 0);
      <D.21181>:
      mono_loader_unlock ();
      D.21182 = res->sig;
      return D.21182;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.21185;
  struct MonoGenericInst * D.21186;
  struct MonoGenericInst * D.21189;

  D.21185 = sig->sig;
  collect_signature_images (D.21185, data);
  D.21186 = sig->context.class_inst;
  if (D.21186 != 0B) goto <D.21187>; else goto <D.21188>;
  <D.21187>:
  D.21186 = sig->context.class_inst;
  collect_ginst_images (D.21186, data);
  <D.21188>:
  D.21189 = sig->context.method_inst;
  if (D.21189 != 0B) goto <D.21190>; else goto <D.21191>;
  <D.21190>:
  D.21189 = sig->context.method_inst;
  collect_ginst_images (D.21189, data);
  <D.21191>:
}


__attribute__((visibility ("hidden")))
mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  long unsigned int D.21192;
  long unsigned int D.21193;
  unsigned int D.21194;
  unsigned int D.21195;
  long unsigned int D.21196;
  long unsigned int D.21197;
  struct MonoType * * D.21198;
  struct MonoType * D.21199;
  int D.21200;
  _Bool D.21202;
  long unsigned int D.21203;
  unsigned char D.21204;
  <unnamed-unsigned:1> D.21205;
  unsigned int type_argc.87;
  <unnamed-unsigned:22> D.21207;
  struct MonoType *[0:] * D.21208;
  long unsigned int D.21209;
  struct MonoImage * * D.21210;
  int D.21211;
  struct GHashTable * D.21212;
  unsigned int size.88;
  int next_generic_inst_id.89;
  int D.21217;
  unsigned int next_generic_inst_id.90;
  struct MonoType * D.21219;
  struct MonoGenericInst * D.21220;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      D.21192 = (long unsigned int) type_argc;
      D.21193 = D.21192 + 1;
      D.21194 = (unsigned int) D.21193;
      D.21195 = D.21194 * 8;
      size = (int) D.21195;
      i = 0;
      goto <D.18357>;
      <D.18356>:
      D.21196 = (long unsigned int) i;
      D.21197 = D.21196 * 8;
      D.21198 = type_argv + D.21197;
      D.21199 = *D.21198;
      D.21200 = mono_class_is_open_constructed_type (D.21199);
      if (D.21200 != 0) goto <D.18355>; else goto <D.21201>;
      <D.21201>:
      i = i + 1;
      <D.18357>:
      if (i < type_argc) goto <D.18356>; else goto <D.18355>;
      <D.18355>:
      D.21202 = i < type_argc;
      is_open = (gboolean) D.21202;
      D.21203 = (long unsigned int) size;
      ginst = __builtin_alloca (D.21203);
      memset (ginst, 0, 8);
      D.21204 = (unsigned char) is_open;
      D.21205 = (<unnamed-unsigned:1>) D.21204;
      ginst->is_open = D.21205;
      type_argc.87 = (unsigned int) type_argc;
      D.21207 = (<unnamed-unsigned:22>) type_argc.87;
      ginst->type_argc = D.21207;
      D.21208 = &ginst->type_argv;
      D.21192 = (long unsigned int) type_argc;
      D.21209 = D.21192 * 8;
      memcpy (D.21208, type_argv, D.21209);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.21210 = data.images;
      D.21211 = data.nimages;
      set = get_image_set (D.21210, D.21211);
      collect_data_free (&data);
      D.21212 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.21212, ginst);
      if (ginst == 0B) goto <D.21213>; else goto <D.21214>;
      <D.21213>:
      size.88 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.88);
      next_generic_inst_id.89 = next_generic_inst_id;
      D.21217 = next_generic_inst_id.89 + 1;
      next_generic_inst_id = D.21217;
      next_generic_inst_id.89 = next_generic_inst_id;
      next_generic_inst_id.90 = (unsigned int) next_generic_inst_id.89;
      ginst->id = next_generic_inst_id.90;
      D.21204 = (unsigned char) is_open;
      D.21205 = (<unnamed-unsigned:1>) D.21204;
      ginst->is_open = D.21205;
      type_argc.87 = (unsigned int) type_argc;
      D.21207 = (<unnamed-unsigned:22>) type_argc.87;
      ginst->type_argc = D.21207;
      i = 0;
      goto <D.18359>;
      <D.18358>:
      D.21196 = (long unsigned int) i;
      D.21197 = D.21196 * 8;
      D.21198 = type_argv + D.21197;
      D.21199 = *D.21198;
      D.21219 = mono_metadata_type_dup (0B, D.21199);
      ginst->type_argv[i] = D.21219;
      i = i + 1;
      <D.18359>:
      if (i < type_argc) goto <D.18358>; else goto <D.18360>;
      <D.18360>:
      D.21212 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.21212, ginst, ginst, 0);
      <D.21214>:
      mono_loader_unlock ();
      D.21220 = ginst;
      return D.21220;
    }
  finally
    {
      data = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.21223;
  <unnamed-unsigned:1> D.21224;
  unsigned char D.21225;
  <unnamed-unsigned:1> D.21226;
  struct MonoImage * * D.21227;
  int D.21228;
  struct GHashTable * D.21229;
  struct MonoClass * D.21230;
  _Bool D.21231;
  long int D.21232;
  long int D.21233;
  struct MonoGenericClass * D.21238;
  struct MonoGenericContainer * D.21242;
  struct MonoGenericInst * D.21243;
  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.21223 = (unsigned char) is_dynamic;
      D.21224 = (<unnamed-unsigned:1>) D.21223;
      helper.is_dynamic = D.21224;
      D.21225 = (unsigned char) is_tb_open;
      D.21226 = (<unnamed-unsigned:1>) D.21225;
      helper.is_tb_open = D.21226;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.21227 = data.images;
      D.21228 = data.nimages;
      set = get_image_set (D.21227, D.21228);
      collect_data_free (&data);
      D.21229 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.21229, &helper);
      D.21230 = helper.cached_class;
      D.21231 = D.21230 != 0B;
      D.21232 = (long int) D.21231;
      D.21233 = __builtin_expect (D.21232, 0);
      if (D.21233 != 0) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.21235>:
      if (gclass != 0B) goto <D.21236>; else goto <D.21237>;
      <D.21236>:
      mono_loader_unlock ();
      D.21238 = gclass;
      return D.21238;
      <D.21237>:
      if (is_dynamic != 0) goto <D.21239>; else goto <D.21240>;
      <D.21239>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 88);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.21241>;
      <D.21240>:
      gclass = mono_image_set_alloc0 (set, 48);
      <D.21241>:
      D.21225 = (unsigned char) is_tb_open;
      D.21226 = (<unnamed-unsigned:1>) D.21225;
      gclass->is_tb_open = D.21226;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.21242 = container_class->generic_container;
      D.21243 = D.21242->context.class_inst;
      if (D.21243 == inst) goto <D.21244>; else goto <D.21245>;
      <D.21244>:
      if (is_tb_open == 0) goto <D.21246>; else goto <D.21247>;
      <D.21246>:
      gclass->cached_class = container_class;
      <D.21247>:
      <D.21245>:
      D.21229 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.21229, gclass, gclass, 0);
      mono_loader_unlock ();
      D.21238 = gclass;
      return D.21238;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_metadata_is_type_builder_generic_type_definition (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  long unsigned int D.21253;
  long unsigned int D.21254;
  <unnamed-signed:31> D.21256;
  int D.21257;
  <unnamed-unsigned:22> D.21258;
  int D.21259;
  gboolean D.21260;
  struct MonoGenericInst * D.21261;
  _Bool D.21262;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.21250>; else goto <D.21252>;
  <D.21252>:
  D.21253 = BIT_FIELD_REF <*container_class, 64, 256>;
  D.21254 = D.21253 & 72057594037927936;
  if (D.21254 != 0) goto <D.21250>; else goto <D.21255>;
  <D.21255>:
  D.21256 = container->type_argc;
  D.21257 = (int) D.21256;
  D.21258 = inst->type_argc;
  D.21259 = (int) D.21258;
  if (D.21257 != D.21259) goto <D.21250>; else goto <D.21251>;
  <D.21250>:
  D.21260 = 0;
  return D.21260;
  <D.21251>:
  D.21261 = container->context.class_inst;
  D.21262 = D.21261 == inst;
  D.21260 = (gboolean) D.21262;
  return D.21260;
}


__attribute__((visibility ("hidden")))
mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  long unsigned int D.21264;
  long unsigned int D.21265;
  struct MonoGenericInst * D.21268;
  <unnamed-unsigned:22> D.21269;
  long unsigned int D.21270;
  long unsigned int D.21271;
  long unsigned int D.21272;
  long unsigned int D.21273;
  struct MonoType * * D.21274;
  struct MonoType * D.21275;
  struct MonoType * D.21276;
  int D.21277;
  int D.21279;
  struct MonoType * D.21280;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.21264 = BIT_FIELD_REF <*ginst, 64, 0>;
  D.21265 = D.21264 & 512;
  if (D.21265 == 0) goto <D.21266>; else goto <D.21267>;
  <D.21266>:
  D.21268 = ginst;
  return D.21268;
  <D.21267>:
  D.21269 = ginst->type_argc;
  D.21270 = (long unsigned int) D.21269;
  D.21271 = D.21270 * 8;
  type_argv = monoeg_malloc0 (D.21271);
  i = 0;
  goto <D.18389>;
  <D.18388>:
  D.21272 = (long unsigned int) i;
  D.21273 = D.21272 * 8;
  D.21274 = type_argv + D.21273;
  D.21275 = ginst->type_argv[i];
  D.21276 = mono_class_inflate_generic_type_checked (D.21275, context, error);
  *D.21274 = D.21276;
  D.21277 = mono_error_ok (error);
  if (D.21277 == 0) goto cleanup; else goto <D.21278>;
  <D.21278>:
  count = count + 1;
  i = i + 1;
  <D.18389>:
  D.21269 = ginst->type_argc;
  D.21279 = (int) D.21269;
  if (D.21279 > i) goto <D.18388>; else goto <D.18390>;
  <D.18390>:
  D.21269 = ginst->type_argc;
  D.21279 = (int) D.21269;
  nginst = mono_metadata_get_generic_inst (D.21279, type_argv);
  cleanup:
  i = 0;
  goto <D.18392>;
  <D.18391>:
  D.21272 = (long unsigned int) i;
  D.21273 = D.21272 * 8;
  D.21274 = type_argv + D.21273;
  D.21280 = *D.21274;
  mono_metadata_free_type (D.21280);
  i = i + 1;
  <D.18392>:
  if (i < count) goto <D.18391>; else goto <D.18393>;
  <D.18393>:
  monoeg_g_free (type_argv);
  D.21268 = nginst;
  return D.21268;
}


__attribute__((visibility ("hidden")))
mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  long unsigned int D.21282;
  long unsigned int D.21283;
  const char * ptr.91;
  struct MonoGenericInst * D.21287;
  long unsigned int D.21288;
  long unsigned int D.21289;
  struct MonoType * * D.21290;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

  D.21282 = (long unsigned int) count;
  D.21283 = D.21282 * 8;
  type_argv = monoeg_malloc0 (D.21283);
  i = 0;
  goto <D.18406>;
  <D.18405>:
  {
    struct MonoType * t;

    ptr.91 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.91, &ptr);
    if (t == 0B) goto <D.21285>; else goto <D.21286>;
    <D.21285>:
    monoeg_g_free (type_argv);
    D.21287 = 0B;
    return D.21287;
    <D.21286>:
    D.21288 = (long unsigned int) i;
    D.21289 = D.21288 * 8;
    D.21290 = type_argv + D.21289;
    *D.21290 = t;
  }
  i = i + 1;
  <D.18406>:
  if (i < count) goto <D.18405>; else goto <D.18407>;
  <D.18407>:
  if (rptr != 0B) goto <D.21291>; else goto <D.21292>;
  <D.21291>:
  ptr.91 = ptr;
  *rptr = ptr.91;
  <D.21292>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.21287 = ginst;
  return D.21287;
}


__attribute__((visibility ("hidden")))
mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.92;
  struct MonoType * D.21297;
  unsigned char D.21298;
  int D.21299;
  struct MonoClass * D.21300;
  struct MonoType * D.21301;
  struct MonoType * D.21304;
  struct MonoType * cached;

  type_cache.92 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.92, type);
  if (cached != 0B) goto <D.21295>; else goto <D.21296>;
  <D.21295>:
  D.21297 = cached;
  return D.21297;
  <D.21296>:
  D.21298 = type->type;
  D.21299 = (int) D.21298;
  switch (D.21299) <default: <D.21307>, case 17: <D.18438>, case 18: <D.18437>>
  <D.18437>:
  <D.18438>:
  D.21300 = type->data.klass;
  D.21301 = &D.21300->byval_arg;
  if (D.21301 == type) goto <D.21302>; else goto <D.21303>;
  <D.21302>:
  D.21297 = type;
  return D.21297;
  <D.21303>:
  D.21300 = type->data.klass;
  D.21304 = &D.21300->this_arg;
  if (D.21304 == type) goto <D.21305>; else goto <D.21306>;
  <D.21305>:
  D.21297 = type;
  return D.21297;
  <D.21306>:
  goto <D.18439>;
  <D.21307>:
  <D.18439>:
  D.21297 = 0B;
  return D.21297;
}


mono_metadata_free_type (struct MonoType * type)
{
  const struct _MonoType * D.21311;
  unsigned char D.21314;
  int D.21315;
  struct MonoClass * D.21316;
  struct MonoType * D.21320;
  struct MonoType * D.21322;
  struct MonoType * D.21323;
  struct MonoMethodSignature * D.21324;
  struct MonoArrayType * D.21325;

  if (type >= &builtin_types) goto <D.21309>; else goto <D.21310>;
  <D.21309>:
  D.21311 = &builtin_types + 544;
  if (type < D.21311) goto <D.21312>; else goto <D.21313>;
  <D.21312>:
  return;
  <D.21313>:
  <D.21310>:
  D.21314 = type->type;
  D.21315 = (int) D.21314;
  switch (D.21315) <default: <D.21326>, case 14: <D.18489>, case 15: <D.18493>, case 17: <D.18492>, case 18: <D.18491>, case 20: <D.18495>, case 27: <D.18494>, case 28: <D.18488>>
  <D.18488>:
  <D.18489>:
  D.21316 = type->data.klass;
  if (D.21316 == 0B) goto <D.18490>; else goto <D.21317>;
  <D.21317>:
  <D.18491>:
  <D.18492>:
  D.21316 = type->data.klass;
  D.21320 = &D.21316->byval_arg;
  if (D.21320 == type) goto <D.21318>; else goto <D.21321>;
  <D.21321>:
  D.21316 = type->data.klass;
  D.21322 = &D.21316->this_arg;
  if (D.21322 == type) goto <D.21318>; else goto <D.21319>;
  <D.21318>:
  return;
  <D.21319>:
  goto <D.18490>;
  <D.18493>:
  D.21323 = type->data.type;
  mono_metadata_free_type (D.21323);
  goto <D.18490>;
  <D.18494>:
  D.21324 = type->data.method;
  mono_metadata_free_method_signature (D.21324);
  goto <D.18490>;
  <D.18495>:
  D.21325 = type->data.array;
  mono_metadata_free_array (D.21325);
  goto <D.18490>;
  <D.21326>:
  <D.18490>:
  monoeg_g_free (type);
}


__attribute__((visibility ("hidden")))
mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  long unsigned int D.21328;
  long unsigned int D.21329;
  short unsigned int D.21332;
  int D.21333;
  int D.21334;
  short unsigned int D.21336;
  unsigned int D.21337;
  unsigned int D.21338;
  int D.21340;
  gboolean D.21341;
  long unsigned int D.21342;
  unsigned int D.21347;
  <unnamed-unsigned:15> D.21348;
  int D.21349;
  _Bool D.21350;
  int D.21351;
  unsigned int D.21352;
  int D.21353;
  struct MonoClass * D.21354;
  struct MonoTableInfo * D.21355;
  int D.21356;
  int D.21357;
  _Bool D.21360;
  long int D.21361;
  long int D.21362;
  int D.21365;
  unsigned char D.21366;
  unsigned int D.21367;
  short unsigned int D.21368;
  short unsigned int D.21369;
  signed short D.21370;
  int D.21371;
  int D.21372;
  signed short D.21373;
  signed short D.21374;
  unsigned int D.21375;
  unsigned int D.21376;
  unsigned int D.21377;
  unsigned int D.21378;
  unsigned int D.21379;
  unsigned int D.21380;
  unsigned int D.21381;
  unsigned int D.21382;
  unsigned int D.21383;
  unsigned int D.21384;
  int D.21385;
  int D.21386;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.18526>;
  <D.18525>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.18526>:
  D.21328 = BIT_FIELD_REF <*method, 64, 256>;
  D.21329 = D.21328 & 2251799813685248;
  if (D.21329 != 0) goto <D.18525>; else goto <D.18527>;
  <D.18527>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.21332 = method->flags;
  D.21333 = (int) D.21332;
  D.21334 = D.21333 & 1024;
  if (D.21334 != 0) goto <D.21330>; else goto <D.21335>;
  <D.21335>:
  D.21336 = method->iflags;
  D.21337 = (unsigned int) D.21336;
  D.21338 = D.21337 & 4099;
  if (D.21338 != 0) goto <D.21330>; else goto <D.21339>;
  <D.21339>:
  D.21332 = method->flags;
  D.21333 = (int) D.21332;
  D.21340 = D.21333 & 8192;
  if (D.21340 != 0) goto <D.21330>; else goto <D.21331>;
  <D.21330>:
  D.21341 = 0;
  return D.21341;
  <D.21331>:
  D.21328 = BIT_FIELD_REF <*method, 64, 256>;
  D.21342 = D.21328 & 4476578029606273024;
  if (D.21342 != 0) goto <D.21343>; else goto <D.21344>;
  <D.21343>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.21345>; else goto <D.21346>;
    <D.21345>:
    D.21341 = 0;
    return D.21341;
    <D.21346>:
    D.21347 = header->code_size;
    summary->code_size = D.21347;
    D.21348 = header->num_clauses;
    D.21349 = (int) D.21348;
    D.21350 = D.21349 > 0;
    D.21351 = (int) D.21350;
    summary->has_clauses = D.21351;
    D.21341 = 1;
    return D.21341;
  }
  <D.21344>:
  D.21352 = method->token;
  D.21353 = (int) D.21352;
  idx = D.21353 & 16777215;
  D.21354 = method->klass;
  img = D.21354->image;
  D.21355 = &img->tables[6];
  D.21356 = idx + -1;
  rva = mono_metadata_decode_row_col (D.21355, D.21356, 0);
  D.21357 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.21357 == 0) goto <D.21358>; else goto <D.21359>;
  <D.21358>:
  D.21341 = 0;
  return D.21341;
  <D.21359>:
  ptr = mono_image_rva_map (img, rva);
  D.21360 = ptr == 0B;
  D.21361 = (long int) D.21360;
  D.21362 = __builtin_expect (D.21361, 0);
  if (D.21362 != 0) goto <D.21363>; else goto <D.21364>;
  <D.21363>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.21364>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.21365 = (int) format;
  switch (D.21365) <default: <D.18532>, case 2: <D.18529>, case 3: <D.18531>>
  <D.18529>:
  ptr = ptr + 1;
  D.21366 = flags >> 2;
  D.21367 = (unsigned int) D.21366;
  summary->code_size = D.21367;
  goto <D.18530>;
  <D.18531>:
  D.21368 = MEM[(const guint16 *)ptr];
  D.21369 = D.21368 >> 8;
  D.21370 = (signed short) D.21369;
  D.21368 = MEM[(const guint16 *)ptr];
  D.21371 = (int) D.21368;
  D.21372 = D.21371 << 8;
  D.21373 = (signed short) D.21372;
  D.21374 = D.21370 | D.21373;
  fat_flags = (guint16) D.21374;
  ptr = ptr + 4;
  D.21375 = MEM[(const guint32 *)ptr];
  D.21376 = D.21375 << 24;
  D.21375 = MEM[(const guint32 *)ptr];
  D.21377 = D.21375 >> 8;
  D.21378 = D.21377 & 65280;
  D.21379 = D.21376 | D.21378;
  D.21375 = MEM[(const guint32 *)ptr];
  D.21380 = D.21375 << 8;
  D.21381 = D.21380 & 16711680;
  D.21382 = D.21379 | D.21381;
  D.21375 = MEM[(const guint32 *)ptr];
  D.21383 = D.21375 >> 24;
  D.21384 = D.21382 | D.21383;
  summary->code_size = D.21384;
  D.21385 = (int) fat_flags;
  D.21386 = D.21385 & 8;
  if (D.21386 != 0) goto <D.21387>; else goto <D.21388>;
  <D.21387>:
  summary->has_clauses = 1;
  <D.21388>:
  goto <D.18530>;
  <D.18532>:
  D.21341 = 0;
  return D.21341;
  <D.18530>:
  D.21341 = 1;
  return D.21341;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.21392;
  int D.21393;
  unsigned char D.21394;
  unsigned int D.21395;
  short unsigned int D.21396;
  short unsigned int D.21397;
  signed short D.21398;
  int D.21399;
  int D.21400;
  signed short D.21401;
  signed short D.21402;
  short unsigned int D.21403;
  int D.21404;
  int D.21405;
  int D.21406;
  int D.21407;
  unsigned int D.21408;
  unsigned int D.21409;
  unsigned int D.21410;
  unsigned int D.21411;
  unsigned int D.21412;
  unsigned int D.21413;
  unsigned int D.21414;
  unsigned int D.21415;
  unsigned int D.21416;
  int D.21417;
  int D.21418;
  int D.21422;
  sizetype D.21424;
  unsigned int D.21427;
  unsigned int D.21428;
  <unnamed-unsigned:24> D.21431;
  int D.21432;
  unsigned int D.21434;
  int D.21435;
  const char * locals_ptr.93;
  const char * locals_ptr.94;
  unsigned int D.21444;
  char D.21445;
  const char * locals_ptr.95;
  unsigned int D.21449;
  long unsigned int D.21450;
  int num_clauses.96;
  long unsigned int D.21452;
  long unsigned int D.21453;
  long unsigned int D.21454;
  long unsigned int D.21455;
  long unsigned int D.21456;
  short unsigned int D.21457;
  struct MonoType * D.21458;
  struct MonoType * D.21459;
  long unsigned int D.21463;
  long unsigned int D.21464;
  short unsigned int D.21465;
  <unnamed-unsigned:15> D.21466;
  unsigned char D.21467;
  <unnamed-unsigned:1> D.21468;
  short unsigned int D.21471;
  int D.21472;
  long unsigned int D.21473;
  short unsigned int D.21474;
  <unnamed-unsigned:15> D.21475;
  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.21390>; else goto <D.21391>;
      <D.21390>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.21392 = 0B;
      return D.21392;
      <D.21391>:
      D.21393 = (int) format;
      switch (D.21393) <default: <D.18555>, case 2: <D.18552>, case 3: <D.18553>>
      <D.18552>:
      mh = monoeg_malloc0 (32);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.21394 = flags >> 2;
      D.21395 = (unsigned int) D.21394;
      mh->code_size = D.21395;
      mh->code = ptr;
      D.21392 = mh;
      return D.21392;
      <D.18553>:
      D.21396 = MEM[(const guint16 *)ptr];
      D.21397 = D.21396 >> 8;
      D.21398 = (signed short) D.21397;
      D.21396 = MEM[(const guint16 *)ptr];
      D.21399 = (int) D.21396;
      D.21400 = D.21399 << 8;
      D.21401 = (signed short) D.21400;
      D.21402 = D.21398 | D.21401;
      fat_flags = (guint16) D.21402;
      ptr = ptr + 2;
      D.21403 = fat_flags >> 12;
      D.21404 = (int) D.21403;
      hsize = D.21404 & 15;
      D.21396 = MEM[(const guint16 *)ptr];
      D.21397 = D.21396 >> 8;
      D.21405 = (int) D.21397;
      D.21396 = MEM[(const guint16 *)ptr];
      D.21399 = (int) D.21396;
      D.21400 = D.21399 << 8;
      D.21406 = D.21400 & 65535;
      D.21407 = D.21405 | D.21406;
      max_stack = (guint32) D.21407;
      ptr = ptr + 2;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21409 = D.21408 << 24;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21410 = D.21408 >> 8;
      D.21411 = D.21410 & 65280;
      D.21412 = D.21409 | D.21411;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21413 = D.21408 << 8;
      D.21414 = D.21413 & 16711680;
      D.21415 = D.21412 | D.21414;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21416 = D.21408 >> 24;
      code_size = D.21415 | D.21416;
      ptr = ptr + 4;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21409 = D.21408 << 24;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21410 = D.21408 >> 8;
      D.21411 = D.21410 & 65280;
      D.21412 = D.21409 | D.21411;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21413 = D.21408 << 8;
      D.21414 = D.21413 & 16711680;
      D.21415 = D.21412 | D.21414;
      D.21408 = MEM[(const guint32 *)ptr];
      D.21416 = D.21408 >> 24;
      local_var_sig_tok = D.21415 | D.21416;
      ptr = ptr + 4;
      D.21417 = (int) fat_flags;
      D.21418 = D.21417 & 16;
      if (D.21418 != 0) goto <D.21419>; else goto <D.21420>;
      <D.21419>:
      init_locals = 1;
      goto <D.21421>;
      <D.21420>:
      init_locals = 0;
      <D.21421>:
      code = ptr;
      D.21417 = (int) fat_flags;
      D.21422 = D.21417 & 8;
      if (D.21422 == 0) goto <D.18554>; else goto <D.21423>;
      <D.21423>:
      D.21424 = (sizetype) code_size;
      ptr = code + D.21424;
      goto <D.18554>;
      <D.18555>:
      D.21392 = 0B;
      return D.21392;
      <D.18554>:
      if (local_var_sig_tok != 0) goto <D.21425>; else goto <D.21426>;
      <D.21425>:
      {
        int idx;

        D.21427 = local_var_sig_tok & 16777215;
        D.21428 = D.21427 + 4294967295;
        idx = (int) D.21428;
        D.21431 = t->rows;
        D.21432 = (int) D.21431;
        if (D.21432 <= idx) goto <D.21429>; else goto <D.21433>;
        <D.21433>:
        if (idx < 0) goto <D.21429>; else goto <D.21430>;
        <D.21429>:
        D.21392 = 0B;
        return D.21392;
        <D.21430>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.21434 = cols[0];
        D.21435 = mono_verifier_verify_standalone_signature (m, D.21434, 0B);
        if (D.21435 == 0) goto <D.21436>; else goto <D.21437>;
        <D.21436>:
        D.21392 = 0B;
        return D.21392;
        <D.21437>:
      }
      <D.21426>:
      D.21417 = (int) fat_flags;
      D.21422 = D.21417 & 8;
      if (D.21422 != 0) goto <D.21438>; else goto <D.21439>;
      <D.21438>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.21439>:
      if (local_var_sig_tok != 0) goto <D.21440>; else goto <D.21441>;
      <D.21440>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.21434 = cols[0];
            locals_ptr.93 = mono_metadata_blob_heap (m, D.21434);
            locals_ptr = locals_ptr.93;
            locals_ptr.94 = locals_ptr;
            D.21444 = mono_metadata_decode_blob_size (locals_ptr.94, &locals_ptr);
            bsize = (int) D.21444;
            locals_ptr.94 = locals_ptr;
            D.21445 = *locals_ptr.94;
            if (D.21445 != 7) goto <D.21446>; else goto <D.21447>;
            <D.21446>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.21447>:
            locals_ptr.94 = locals_ptr;
            locals_ptr.95 = locals_ptr.94 + 1;
            locals_ptr = locals_ptr.95;
            locals_ptr.94 = locals_ptr;
            D.21449 = mono_metadata_decode_value (locals_ptr.94, &locals_ptr);
            len = (int) D.21449;
            D.21450 = (long unsigned int) len;
            num_clauses.96 = num_clauses;
            D.21452 = (long unsigned int) num_clauses.96;
            D.21453 = D.21452 * 4;
            D.21454 = D.21450 + D.21453;
            D.21455 = D.21454 + 4;
            D.21456 = D.21455 * 8;
            mh = monoeg_malloc0 (D.21456);
            D.21457 = (short unsigned int) len;
            mh->num_locals = D.21457;
            i = 0;
            goto <D.18562>;
            <D.18561>:
            locals_ptr.94 = locals_ptr;
            D.21458 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.94, &locals_ptr);
            mh->locals[i] = D.21458;
            D.21459 = mh->locals[i];
            if (D.21459 == 0B) goto <D.21460>; else goto <D.21461>;
            <D.21460>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.21392 = 0B;
            return D.21392;
            <D.21461>:
            i = i + 1;
            <D.18562>:
            if (i < len) goto <D.18561>; else goto <D.18563>;
            <D.18563>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.21462>;
      <D.21441>:
      num_clauses.96 = num_clauses;
      D.21452 = (long unsigned int) num_clauses.96;
      D.21463 = D.21452 + 1;
      D.21464 = D.21463 * 32;
      mh = monoeg_malloc0 (D.21464);
      <D.21462>:
      mh->code = code;
      mh->code_size = code_size;
      D.21465 = (short unsigned int) max_stack;
      D.21466 = (<unnamed-unsigned:15>) D.21465;
      mh->max_stack = D.21466;
      mh->is_transient = 1;
      D.21467 = (unsigned char) init_locals;
      D.21468 = (<unnamed-unsigned:1>) D.21467;
      mh->init_locals = D.21468;
      if (clauses != 0B) goto <D.21469>; else goto <D.21470>;
      <D.21469>:
      {
        struct MonoExceptionClause * clausesp;

        D.21471 = mh->num_locals;
        D.21472 = (int) D.21471;
        clausesp = &mh->locals[D.21472];
        num_clauses.96 = num_clauses;
        D.21452 = (long unsigned int) num_clauses.96;
        D.21473 = D.21452 * 32;
        memcpy (clausesp, clauses, D.21473);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.96 = num_clauses;
        D.21474 = (short unsigned int) num_clauses.96;
        D.21475 = (<unnamed-unsigned:15>) D.21474;
        mh->num_clauses = D.21475;
      }
      <D.21470>:
      D.21392 = mh;
      return D.21392;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.21480;
  const unsigned char * D.21483;
  unsigned char D.21484;
  int D.21485;
  int D.21486;
  const unsigned char * D.21487;
  unsigned char D.21488;
  int D.21489;
  int D.21490;
  int D.21491;
  unsigned char D.21492;
  int D.21493;
  int D.21494;
  int D.21496;
  int iftmp.97;
  unsigned int D.21502;
  unsigned int D.21504;
  int D.21505;
  long unsigned int D.21506;
  long unsigned int D.21507;
  long unsigned int D.21508;
  long unsigned int D.21509;
  unsigned int D.21512;
  unsigned int D.21513;
  unsigned int D.21514;
  unsigned int D.21515;
  unsigned int D.21516;
  unsigned int D.21517;
  unsigned int D.21518;
  unsigned int D.21519;
  unsigned int D.21520;
  unsigned int D.21521;
  const unsigned char * D.21522;
  unsigned int D.21523;
  unsigned int D.21524;
  unsigned int D.21525;
  unsigned int D.21526;
  unsigned int D.21527;
  unsigned int D.21528;
  unsigned int D.21529;
  unsigned int D.21530;
  unsigned int D.21531;
  unsigned int D.21532;
  const unsigned char * D.21533;
  unsigned int D.21534;
  unsigned int D.21535;
  unsigned int D.21536;
  unsigned int D.21537;
  unsigned int D.21538;
  unsigned int D.21539;
  unsigned int D.21540;
  unsigned int D.21541;
  unsigned int D.21542;
  unsigned int D.21543;
  const unsigned char * D.21544;
  unsigned int D.21545;
  unsigned int D.21546;
  unsigned int D.21547;
  unsigned int D.21548;
  unsigned int D.21549;
  unsigned int D.21550;
  unsigned int D.21551;
  unsigned int D.21552;
  unsigned int D.21553;
  unsigned int D.21554;
  const unsigned char * D.21555;
  unsigned int D.21556;
  unsigned int D.21557;
  unsigned int D.21558;
  unsigned int D.21559;
  unsigned int D.21560;
  unsigned int D.21561;
  unsigned int D.21562;
  unsigned int D.21563;
  unsigned int D.21564;
  unsigned int D.21565;
  const unsigned char * D.21566;
  unsigned int D.21567;
  unsigned int D.21568;
  unsigned int D.21569;
  unsigned int D.21570;
  unsigned int D.21571;
  unsigned int D.21572;
  unsigned int D.21573;
  unsigned int D.21574;
  unsigned int D.21575;
  short unsigned int D.21577;
  short unsigned int D.21578;
  int D.21579;
  int D.21580;
  int D.21581;
  int D.21582;
  int D.21583;
  unsigned int D.21584;
  const unsigned char * D.21585;
  short unsigned int D.21586;
  short unsigned int D.21587;
  int D.21588;
  int D.21589;
  int D.21590;
  int D.21591;
  int D.21592;
  unsigned int D.21593;
  unsigned char D.21594;
  unsigned int D.21595;
  const unsigned char * D.21596;
  short unsigned int D.21597;
  short unsigned int D.21598;
  int D.21599;
  int D.21600;
  int D.21601;
  int D.21602;
  int D.21603;
  unsigned int D.21604;
  const unsigned char * D.21605;
  unsigned char D.21606;
  unsigned int D.21607;
  unsigned int D.21608;
  struct MonoClass * iftmp.98;
  signed char sect_data_flags.99;
  unsigned int D.21622;
  sizetype D.21623;
  struct MonoExceptionClause * D.21625;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.18513>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.21480 = (int) sect_data_flags;
  is_fat = D.21480 & 64;
  if (is_fat != 0) goto <D.21481>; else goto <D.21482>;
  <D.21481>:
  D.21483 = ptr + 2;
  D.21484 = *D.21483;
  D.21485 = (int) D.21484;
  D.21486 = D.21485 << 16;
  D.21487 = ptr + 1;
  D.21488 = *D.21487;
  D.21489 = (int) D.21488;
  D.21490 = D.21489 << 8;
  D.21491 = D.21486 | D.21490;
  D.21492 = *ptr;
  D.21493 = (int) D.21492;
  D.21494 = D.21491 | D.21493;
  sect_data_len = (guint32) D.21494;
  ptr = ptr + 3;
  goto <D.21495>;
  <D.21482>:
  D.21492 = *ptr;
  sect_data_len = (guint32) D.21492;
  ptr = ptr + 1;
  <D.21495>:
  D.21480 = (int) sect_data_flags;
  D.21496 = D.21480 & 1;
  if (D.21496 != 0) goto <D.21497>; else goto <D.21498>;
  <D.21497>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.21500>; else goto <D.21501>;
    <D.21500>:
    D.21502 = sect_data_len / 24;
    iftmp.97 = (int) D.21502;
    goto <D.21503>;
    <D.21501>:
    D.21504 = sect_data_len / 12;
    iftmp.97 = (int) D.21504;
    <D.21503>:
    *num_clauses = iftmp.97;
    D.21505 = *num_clauses;
    D.21506 = (long unsigned int) D.21505;
    D.21507 = D.21506 * 32;
    clauses = monoeg_malloc0 (D.21507);
    i = 0;
    goto <D.18511>;
    <D.18510>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      D.21508 = (long unsigned int) i;
      D.21509 = D.21508 * 32;
      ec = clauses + D.21509;
      if (is_fat != 0) goto <D.21510>; else goto <D.21511>;
      <D.21510>:
      D.21512 = MEM[(const guint32 *)p];
      D.21513 = D.21512 << 24;
      D.21512 = MEM[(const guint32 *)p];
      D.21514 = D.21512 >> 8;
      D.21515 = D.21514 & 65280;
      D.21516 = D.21513 | D.21515;
      D.21512 = MEM[(const guint32 *)p];
      D.21517 = D.21512 << 8;
      D.21518 = D.21517 & 16711680;
      D.21519 = D.21516 | D.21518;
      D.21512 = MEM[(const guint32 *)p];
      D.21520 = D.21512 >> 24;
      D.21521 = D.21519 | D.21520;
      ec->flags = D.21521;
      D.21522 = p + 4;
      D.21523 = MEM[(const guint32 *)D.21522];
      D.21524 = D.21523 << 24;
      D.21522 = p + 4;
      D.21523 = MEM[(const guint32 *)D.21522];
      D.21525 = D.21523 >> 8;
      D.21526 = D.21525 & 65280;
      D.21527 = D.21524 | D.21526;
      D.21522 = p + 4;
      D.21523 = MEM[(const guint32 *)D.21522];
      D.21528 = D.21523 << 8;
      D.21529 = D.21528 & 16711680;
      D.21530 = D.21527 | D.21529;
      D.21522 = p + 4;
      D.21523 = MEM[(const guint32 *)D.21522];
      D.21531 = D.21523 >> 24;
      D.21532 = D.21530 | D.21531;
      ec->try_offset = D.21532;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21535 = D.21534 << 24;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21536 = D.21534 >> 8;
      D.21537 = D.21536 & 65280;
      D.21538 = D.21535 | D.21537;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21539 = D.21534 << 8;
      D.21540 = D.21539 & 16711680;
      D.21541 = D.21538 | D.21540;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21542 = D.21534 >> 24;
      D.21543 = D.21541 | D.21542;
      ec->try_len = D.21543;
      D.21544 = p + 12;
      D.21545 = MEM[(const guint32 *)D.21544];
      D.21546 = D.21545 << 24;
      D.21544 = p + 12;
      D.21545 = MEM[(const guint32 *)D.21544];
      D.21547 = D.21545 >> 8;
      D.21548 = D.21547 & 65280;
      D.21549 = D.21546 | D.21548;
      D.21544 = p + 12;
      D.21545 = MEM[(const guint32 *)D.21544];
      D.21550 = D.21545 << 8;
      D.21551 = D.21550 & 16711680;
      D.21552 = D.21549 | D.21551;
      D.21544 = p + 12;
      D.21545 = MEM[(const guint32 *)D.21544];
      D.21553 = D.21545 >> 24;
      D.21554 = D.21552 | D.21553;
      ec->handler_offset = D.21554;
      D.21555 = p + 16;
      D.21556 = MEM[(const guint32 *)D.21555];
      D.21557 = D.21556 << 24;
      D.21555 = p + 16;
      D.21556 = MEM[(const guint32 *)D.21555];
      D.21558 = D.21556 >> 8;
      D.21559 = D.21558 & 65280;
      D.21560 = D.21557 | D.21559;
      D.21555 = p + 16;
      D.21556 = MEM[(const guint32 *)D.21555];
      D.21561 = D.21556 << 8;
      D.21562 = D.21561 & 16711680;
      D.21563 = D.21560 | D.21562;
      D.21555 = p + 16;
      D.21556 = MEM[(const guint32 *)D.21555];
      D.21564 = D.21556 >> 24;
      D.21565 = D.21563 | D.21564;
      ec->handler_len = D.21565;
      D.21566 = p + 20;
      D.21567 = MEM[(const guint32 *)D.21566];
      D.21568 = D.21567 << 24;
      D.21566 = p + 20;
      D.21567 = MEM[(const guint32 *)D.21566];
      D.21569 = D.21567 >> 8;
      D.21570 = D.21569 & 65280;
      D.21571 = D.21568 | D.21570;
      D.21566 = p + 20;
      D.21567 = MEM[(const guint32 *)D.21566];
      D.21572 = D.21567 << 8;
      D.21573 = D.21572 & 16711680;
      D.21574 = D.21571 | D.21573;
      D.21566 = p + 20;
      D.21567 = MEM[(const guint32 *)D.21566];
      D.21575 = D.21567 >> 24;
      tof_value = D.21574 | D.21575;
      p = p + 24;
      goto <D.21576>;
      <D.21511>:
      D.21577 = MEM[(const guint16 *)p];
      D.21578 = D.21577 >> 8;
      D.21579 = (int) D.21578;
      D.21577 = MEM[(const guint16 *)p];
      D.21580 = (int) D.21577;
      D.21581 = D.21580 << 8;
      D.21582 = D.21581 & 65535;
      D.21583 = D.21579 | D.21582;
      D.21584 = (unsigned int) D.21583;
      ec->flags = D.21584;
      D.21585 = p + 2;
      D.21586 = MEM[(const guint16 *)D.21585];
      D.21587 = D.21586 >> 8;
      D.21588 = (int) D.21587;
      D.21585 = p + 2;
      D.21586 = MEM[(const guint16 *)D.21585];
      D.21589 = (int) D.21586;
      D.21590 = D.21589 << 8;
      D.21591 = D.21590 & 65535;
      D.21592 = D.21588 | D.21591;
      D.21593 = (unsigned int) D.21592;
      ec->try_offset = D.21593;
      D.21522 = p + 4;
      D.21594 = *D.21522;
      D.21595 = (unsigned int) D.21594;
      ec->try_len = D.21595;
      D.21596 = p + 5;
      D.21597 = MEM[(const guint16 *)D.21596];
      D.21598 = D.21597 >> 8;
      D.21599 = (int) D.21598;
      D.21596 = p + 5;
      D.21597 = MEM[(const guint16 *)D.21596];
      D.21600 = (int) D.21597;
      D.21601 = D.21600 << 8;
      D.21602 = D.21601 & 65535;
      D.21603 = D.21599 | D.21602;
      D.21604 = (unsigned int) D.21603;
      ec->handler_offset = D.21604;
      D.21605 = p + 7;
      D.21606 = *D.21605;
      D.21607 = (unsigned int) D.21606;
      ec->handler_len = D.21607;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21535 = D.21534 << 24;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21536 = D.21534 >> 8;
      D.21537 = D.21536 & 65280;
      D.21538 = D.21535 | D.21537;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21539 = D.21534 << 8;
      D.21540 = D.21539 & 16711680;
      D.21541 = D.21538 | D.21540;
      D.21533 = p + 8;
      D.21534 = MEM[(const guint32 *)D.21533];
      D.21542 = D.21534 >> 24;
      tof_value = D.21541 | D.21542;
      p = p + 12;
      <D.21576>:
      D.21608 = ec->flags;
      if (D.21608 == 1) goto <D.21609>; else goto <D.21610>;
      <D.21609>:
      ec->data.filter_offset = tof_value;
      goto <D.21611>;
      <D.21610>:
      D.21608 = ec->flags;
      if (D.21608 == 0) goto <D.21612>; else goto <D.21613>;
      <D.21612>:
      if (tof_value != 0) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      iftmp.98 = mono_class_get (m, tof_value);
      goto <D.21617>;
      <D.21616>:
      iftmp.98 = 0B;
      <D.21617>:
      ec->data.catch_class = iftmp.98;
      goto <D.21618>;
      <D.21613>:
      ec->data.catch_class = 0B;
      <D.21618>:
      <D.21611>:
    }
    i = i + 1;
    <D.18511>:
    D.21505 = *num_clauses;
    if (D.21505 > i) goto <D.18510>; else goto <D.18512>;
    <D.18512>:
  }
  <D.21498>:
  sect_data_flags.99 = (signed char) sect_data_flags;
  if (sect_data_flags.99 < 0) goto <D.21620>; else goto <D.21621>;
  <D.21620>:
  D.21622 = sect_data_len + 4294967292;
  D.21623 = (sizetype) D.21622;
  ptr = ptr + D.21623;
  goto <D.21624>;
  <D.21621>:
  D.21625 = clauses;
  return D.21625;
  <D.21624>:
  goto <D.18513>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.21627;
  const unsigned char * D.21628;
  long unsigned int D.21629;
  long unsigned int D.21630;

  D.21628 = ptr + 3;
  D.21629 = (long unsigned int) D.21628;
  D.21630 = D.21629 & 18446744073709551612;
  D.21627 = (const unsigned char *) D.21630;
  return D.21627;
}


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

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


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  long unsigned int D.21634;
  long unsigned int D.21635;
  struct MonoType * D.21638;
  short unsigned int D.21639;
  int D.21640;
  int i;

  D.21634 = BIT_FIELD_REF <*mh, 64, 64>;
  D.21635 = D.21634 & 65536;
  if (D.21635 != 0) goto <D.21636>; else goto <D.21637>;
  <D.21636>:
  i = 0;
  goto <D.18575>;
  <D.18574>:
  D.21638 = mh->locals[i];
  mono_metadata_free_type (D.21638);
  i = i + 1;
  <D.18575>:
  D.21639 = mh->num_locals;
  D.21640 = (int) D.21639;
  if (D.21640 > i) goto <D.18574>; else goto <D.18576>;
  <D.18576>:
  monoeg_g_free (mh);
  <D.21637>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.21643;
  <unnamed-unsigned:15> D.21646;
  unsigned int D.21647;
  const unsigned char * D.21648;

  if (code_size != 0B) goto <D.21641>; else goto <D.21642>;
  <D.21641>:
  D.21643 = header->code_size;
  *code_size = D.21643;
  <D.21642>:
  if (max_stack != 0B) goto <D.21644>; else goto <D.21645>;
  <D.21644>:
  D.21646 = header->max_stack;
  D.21647 = (unsigned int) D.21646;
  *max_stack = D.21647;
  <D.21645>:
  D.21648 = header->code;
  return D.21648;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.21652;
  unsigned int D.21653;
  <unnamed-unsigned:1> D.21656;
  int D.21657;
  struct MonoType * * D.21658;

  if (num_locals != 0B) goto <D.21650>; else goto <D.21651>;
  <D.21650>:
  D.21652 = header->num_locals;
  D.21653 = (unsigned int) D.21652;
  *num_locals = D.21653;
  <D.21651>:
  if (init_locals != 0B) goto <D.21654>; else goto <D.21655>;
  <D.21654>:
  D.21656 = header->init_locals;
  D.21657 = (int) D.21656;
  *init_locals = D.21657;
  <D.21655>:
  D.21658 = &header->locals;
  return D.21658;
}


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

  D.21661 = header->num_clauses;
  D.21660 = (int) D.21661;
  return D.21660;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  long unsigned int D.21666;
  long unsigned int D.21667;
  int D.21668;
  void * D.21669;
  struct MonoExceptionClause * D.21672;
  <unnamed-unsigned:15> D.21673;
  long unsigned int D.21674;
  long unsigned int D.21675;
  struct MonoExceptionClause * D.21676;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.21663>; else goto <D.21665>;
  <D.21665>:
  D.21666 = BIT_FIELD_REF <*header, 64, 64>;
  D.21667 = D.21666 & 65534;
  if (D.21667 == 0) goto <D.21663>; else goto <D.21664>;
  <D.21663>:
  D.21668 = 0;
  return D.21668;
  <D.21664>:
  D.21669 = *iter;
  if (D.21669 == 0B) goto <D.21670>; else goto <D.21671>;
  <D.21670>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.21668 = 1;
  return D.21668;
  <D.21671>:
  sc = *iter;
  sc = sc + 32;
  D.21672 = header->clauses;
  D.21673 = header->num_clauses;
  D.21674 = (long unsigned int) D.21673;
  D.21675 = D.21674 * 32;
  D.21676 = D.21672 + D.21675;
  if (D.21676 > sc) goto <D.21677>; else goto <D.21678>;
  <D.21677>:
  *iter = sc;
  *clause = *sc;
  D.21668 = 1;
  return D.21668;
  <D.21678>:
  D.21668 = 0;
  return D.21668;
}


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

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


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

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


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

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


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.21686;
  uint32_t D.21689;
  int index.100;
  int D.21691;
  long unsigned int D.21692;
  long unsigned int D.21693;
  int D.21696;
  unsigned int D.21697;
  int D.21698;
  <unnamed-unsigned:24> D.21699;
  long unsigned int D.21700;
  unsigned char D.21701;
  long unsigned int D.21702;
  void * D.21703;
  unsigned int D.21706;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21686 = tdef->base;
      if (D.21686 == 0B) goto <D.21687>; else goto <D.21688>;
      <D.21687>:
      D.21689 = 0;
      return D.21689;
      <D.21688>:
      index.100 = (int) index;
      D.21691 = index.100 & 16777215;
      loc.idx = D.21691;
      loc.col_idx = 4;
      loc.t = tdef;
      D.21692 = BIT_FIELD_REF <*meta, 64, 192>;
      D.21693 = D.21692 & 67108864;
      if (D.21693 != 0) goto <D.21694>; else goto <D.21695>;
      <D.21694>:
      D.21696 = loc.idx;
      D.21697 = search_ptr_table (meta, 3, D.21696);
      D.21698 = (int) D.21697;
      loc.idx = D.21698;
      <D.21695>:
      D.21686 = tdef->base;
      D.21699 = tdef->rows;
      D.21700 = (long unsigned int) D.21699;
      D.21701 = tdef->row_size;
      D.21702 = (long unsigned int) D.21701;
      D.21703 = mono_binary_search (&loc, D.21686, D.21700, D.21702, typedef_locator);
      if (D.21703 == 0B) goto <D.21704>; else goto <D.21705>;
      <D.21704>:
      D.21689 = 0;
      return D.21689;
      <D.21705>:
      D.21706 = loc.result;
      D.21689 = D.21706 + 1;
      return D.21689;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  long int bb.101;
  struct MonoTableInfo * D.21710;
  const char * D.21711;
  long int D.21712;
  long int D.21713;
  unsigned char D.21714;
  long int D.21715;
  long int D.21716;
  int D.21717;
  unsigned int D.21718;
  int D.21719;
  unsigned int D.21720;
  int D.21723;
  int D.21724;
  <unnamed-unsigned:24> D.21725;
  int D.21726;
  unsigned int typedef_index.102;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.101 = (long int) bb;
  D.21710 = loc->t;
  D.21711 = D.21710->base;
  D.21712 = (long int) D.21711;
  D.21713 = bb.101 - D.21712;
  D.21710 = loc->t;
  D.21714 = D.21710->row_size;
  D.21715 = (long int) D.21714;
  D.21716 = D.21713 / D.21715;
  typedef_index = (int) D.21716;
  D.21710 = loc->t;
  D.21717 = loc->col_idx;
  D.21718 = (unsigned int) D.21717;
  col = mono_metadata_decode_row_col (D.21710, typedef_index, D.21718);
  D.21719 = loc->idx;
  D.21720 = (unsigned int) D.21719;
  if (D.21720 < col) goto <D.21721>; else goto <D.21722>;
  <D.21721>:
  D.21723 = -1;
  return D.21723;
  <D.21722>:
  D.21724 = typedef_index + 1;
  D.21710 = loc->t;
  D.21725 = D.21710->rows;
  D.21726 = (int) D.21725;
  if (D.21724 < D.21726) goto <D.21727>; else goto <D.21728>;
  <D.21727>:
  D.21710 = loc->t;
  D.21724 = typedef_index + 1;
  D.21717 = loc->col_idx;
  D.21718 = (unsigned int) D.21717;
  col_next = mono_metadata_decode_row_col (D.21710, D.21724, D.21718);
  D.21719 = loc->idx;
  D.21720 = (unsigned int) D.21719;
  if (D.21720 >= col_next) goto <D.21729>; else goto <D.21730>;
  <D.21729>:
  D.21723 = 1;
  return D.21723;
  <D.21730>:
  if (col == col_next) goto <D.21731>; else goto <D.21732>;
  <D.21731>:
  D.21723 = 1;
  return D.21723;
  <D.21732>:
  <D.21728>:
  typedef_index.102 = (unsigned int) typedef_index;
  loc->result = typedef_index.102;
  D.21723 = 0;
  return D.21723;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.21735;
  unsigned int idx.103;
  <unnamed-unsigned:24> D.21738;
  int D.21739;
  guint32 D.21742;
  int D.21743;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.18657>;
  <D.18656>:
  D.21735 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.103 = (unsigned int) idx;
  if (D.21735 == idx.103) goto <D.18655>; else goto <D.21737>;
  <D.21737>:
  i = i + 1;
  <D.18657>:
  D.21738 = ptrdef->rows;
  D.21739 = (int) D.21738;
  if (D.21739 > i) goto <D.18656>; else goto <D.18655>;
  <D.18655>:
  D.21738 = ptrdef->rows;
  D.21739 = (int) D.21738;
  if (D.21739 > i) goto <D.21740>; else goto <D.21741>;
  <D.21740>:
  D.21743 = i + 1;
  D.21742 = (guint32) D.21743;
  return D.21742;
  <D.21741>:
  D.21742 = (guint32) idx;
  return D.21742;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.21745;
  uint32_t D.21748;
  int index.104;
  int D.21750;
  long unsigned int D.21751;
  long unsigned int D.21752;
  int D.21755;
  unsigned int D.21756;
  int D.21757;
  <unnamed-unsigned:24> D.21758;
  long unsigned int D.21759;
  unsigned char D.21760;
  long unsigned int D.21761;
  void * D.21762;
  unsigned int D.21765;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21745 = tdef->base;
      if (D.21745 == 0B) goto <D.21746>; else goto <D.21747>;
      <D.21746>:
      D.21748 = 0;
      return D.21748;
      <D.21747>:
      index.104 = (int) index;
      D.21750 = index.104 & 16777215;
      loc.idx = D.21750;
      loc.col_idx = 5;
      loc.t = tdef;
      D.21751 = BIT_FIELD_REF <*meta, 64, 192>;
      D.21752 = D.21751 & 67108864;
      if (D.21752 != 0) goto <D.21753>; else goto <D.21754>;
      <D.21753>:
      D.21755 = loc.idx;
      D.21756 = search_ptr_table (meta, 5, D.21755);
      D.21757 = (int) D.21756;
      loc.idx = D.21757;
      <D.21754>:
      D.21745 = tdef->base;
      D.21758 = tdef->rows;
      D.21759 = (long unsigned int) D.21758;
      D.21760 = tdef->row_size;
      D.21761 = (long unsigned int) D.21760;
      D.21762 = mono_binary_search (&loc, D.21745, D.21759, D.21761, typedef_locator);
      if (D.21762 == 0B) goto <D.21763>; else goto <D.21764>;
      <D.21763>:
      D.21748 = 0;
      return D.21748;
      <D.21764>:
      D.21765 = loc.result;
      D.21748 = D.21765 + 1;
      return D.21748;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
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.21768;
  gboolean D.21771;
  int index.105;
  int D.21773;
  <unnamed-unsigned:24> D.21774;
  long unsigned int D.21775;
  unsigned char D.21776;
  long unsigned int D.21777;
  void * D.21778;
  int D.21781;
  unsigned int D.21782;
  unsigned int D.21783;
  int D.21784;
  unsigned int D.21785;
  int pos.106;
  unsigned int D.21788;
  unsigned int D.21789;
  unsigned int D.21791;
  unsigned int D.21794;
  long unsigned int D.21795;
  long unsigned int D.21796;
  unsigned int D.21798;
  unsigned int D.21800;
  unsigned int D.21801;
  struct MonoClass * * D.21804;
  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.21768 = tdef->base;
      if (D.21768 == 0B) goto <D.21769>; else goto <D.21770>;
      <D.21769>:
      D.21771 = 1;
      return D.21771;
      <D.21770>:
      index.105 = (int) index;
      D.21773 = index.105 & 16777215;
      loc.idx = D.21773;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21768 = tdef->base;
      D.21774 = tdef->rows;
      D.21775 = (long unsigned int) D.21774;
      D.21776 = tdef->row_size;
      D.21777 = (long unsigned int) D.21776;
      D.21778 = mono_binary_search (&loc, D.21768, D.21775, D.21777, table_locator);
      if (D.21778 == 0B) goto <D.21779>; else goto <D.21780>;
      <D.21779>:
      D.21771 = 1;
      return D.21771;
      <D.21780>:
      start = loc.result;
      goto <D.18686>;
      <D.18685>:
      D.21781 = loc.idx;
      D.21782 = (unsigned int) D.21781;
      D.21783 = start + 4294967295;
      D.21784 = (int) D.21783;
      D.21785 = mono_metadata_decode_row_col (tdef, D.21784, 0);
      if (D.21782 == D.21785) goto <D.21786>; else goto <D.18684>;
      <D.21786>:
      start = start + 4294967295;
      <D.18686>:
      if (start != 0) goto <D.18685>; else goto <D.18684>;
      <D.18684>:
      pos = start;
      goto <D.18689>;
      <D.18688>:
      pos.106 = (int) pos;
      mono_metadata_decode_row (tdef, pos.106, &cols, 2);
      D.21788 = cols[0];
      D.21781 = loc.idx;
      D.21789 = (unsigned int) D.21781;
      if (D.21788 != D.21789) goto <D.18687>; else goto <D.21790>;
      <D.21790>:
      pos = pos + 1;
      <D.18689>:
      D.21774 = tdef->rows;
      D.21791 = (unsigned int) D.21774;
      if (D.21791 > pos) goto <D.18688>; else goto <D.18687>;
      <D.18687>:
      if (heap_alloc_result != 0) goto <D.21792>; else goto <D.21793>;
      <D.21792>:
      D.21794 = pos - start;
      D.21795 = (long unsigned int) D.21794;
      D.21796 = D.21795 * 8;
      result = monoeg_malloc0 (D.21796);
      goto <D.21797>;
      <D.21793>:
      D.21794 = pos - start;
      D.21798 = D.21794 * 8;
      result = mono_image_alloc0 (meta, D.21798);
      <D.21797>:
      pos = start;
      goto <D.18693>;
      <D.18692>:
      {
        struct MonoClass * iface;

        pos.106 = (int) pos;
        mono_metadata_decode_row (tdef, pos.106, &cols, 2);
        D.21788 = cols[0];
        D.21781 = loc.idx;
        D.21789 = (unsigned int) D.21781;
        if (D.21788 != D.21789) goto <D.18691>; else goto <D.21799>;
        <D.21799>:
        D.21800 = cols[1];
        D.21801 = mono_metadata_token_from_dor (D.21800);
        iface = mono_class_get_full (meta, D.21801, context);
        if (iface == 0B) goto <D.21802>; else goto <D.21803>;
        <D.21802>:
        D.21771 = 0;
        return D.21771;
        <D.21803>:
        D.21794 = pos - start;
        D.21795 = (long unsigned int) D.21794;
        D.21796 = D.21795 * 8;
        D.21804 = result + D.21796;
        *D.21804 = iface;
        pos = pos + 1;
      }
      <D.18693>:
      D.21774 = tdef->rows;
      D.21791 = (unsigned int) D.21774;
      if (D.21791 > pos) goto <D.18692>; else goto <D.18691>;
      <D.18691>:
      D.21794 = pos - start;
      *count = D.21794;
      *interfaces = result;
      D.21771 = 1;
      return D.21771;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  long int bb.107;
  struct MonoTableInfo * D.21808;
  const char * D.21809;
  long int D.21810;
  long int D.21811;
  unsigned char D.21812;
  long int D.21813;
  long int D.21814;
  int table_index.108;
  int D.21816;
  unsigned int D.21817;
  int D.21818;
  unsigned int D.21819;
  int D.21822;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.107 = (long int) bb;
  D.21808 = loc->t;
  D.21809 = D.21808->base;
  D.21810 = (long int) D.21809;
  D.21811 = bb.107 - D.21810;
  D.21808 = loc->t;
  D.21812 = D.21808->row_size;
  D.21813 = (long int) D.21812;
  D.21814 = D.21811 / D.21813;
  table_index = (guint32) D.21814;
  D.21808 = loc->t;
  table_index.108 = (int) table_index;
  D.21816 = loc->col_idx;
  D.21817 = (unsigned int) D.21816;
  col = mono_metadata_decode_row_col (D.21808, table_index.108, D.21817);
  D.21818 = loc->idx;
  D.21819 = (unsigned int) D.21818;
  if (D.21819 == col) goto <D.21820>; else goto <D.21821>;
  <D.21820>:
  loc->result = table_index;
  D.21822 = 0;
  return D.21822;
  <D.21821>:
  D.21818 = loc->idx;
  D.21819 = (unsigned int) D.21818;
  if (D.21819 < col) goto <D.21823>; else goto <D.21824>;
  <D.21823>:
  D.21822 = -1;
  return D.21822;
  <D.21824>:
  D.21822 = 1;
  return D.21822;
}


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


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.21831;
  uint32_t D.21834;
  int index.109;
  int D.21836;
  <unnamed-unsigned:24> D.21837;
  long unsigned int D.21838;
  unsigned char D.21839;
  long unsigned int D.21840;
  void * D.21841;
  unsigned int D.21844;
  int D.21845;
  unsigned int D.21846;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.21831 = tdef->base;
      if (D.21831 == 0B) goto <D.21832>; else goto <D.21833>;
      <D.21832>:
      D.21834 = 0;
      return D.21834;
      <D.21833>:
      index.109 = (int) index;
      D.21836 = index.109 & 16777215;
      loc.idx = D.21836;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21831 = tdef->base;
      D.21837 = tdef->rows;
      D.21838 = (long unsigned int) D.21837;
      D.21839 = tdef->row_size;
      D.21840 = (long unsigned int) D.21839;
      D.21841 = mono_binary_search (&loc, D.21831, D.21838, D.21840, table_locator);
      if (D.21841 == 0B) goto <D.21842>; else goto <D.21843>;
      <D.21842>:
      D.21834 = 0;
      return D.21834;
      <D.21843>:
      D.21844 = loc.result;
      D.21845 = (int) D.21844;
      D.21846 = mono_metadata_decode_row_col (tdef, D.21845, 1);
      D.21834 = D.21846 | 33554432;
      return D.21834;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.21849;
  uint32_t D.21852;
  unsigned int D.21853;
  int D.21854;
  unsigned int D.21855;
  <unnamed-unsigned:24> D.21857;
  unsigned int D.21858;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.21849 = tdef->base;
  if (D.21849 == 0B) goto <D.21850>; else goto <D.21851>;
  <D.21850>:
  D.21852 = 0;
  return D.21852;
  <D.21851>:
  start = start_index;
  goto <D.18717>;
  <D.18716>:
  D.21853 = start + 4294967295;
  D.21854 = (int) D.21853;
  D.21855 = mono_metadata_decode_row_col (tdef, D.21854, 1);
  if (D.21855 == class_index) goto <D.18715>; else goto <D.21856>;
  <D.21856>:
  start = start + 1;
  <D.18717>:
  D.21857 = tdef->rows;
  D.21858 = (unsigned int) D.21857;
  if (D.21858 >= start) goto <D.18716>; else goto <D.18715>;
  <D.18715>:
  D.21857 = tdef->rows;
  D.21858 = (unsigned int) D.21857;
  if (D.21858 < start) goto <D.21859>; else goto <D.21860>;
  <D.21859>:
  D.21852 = 0;
  return D.21852;
  <D.21860>:
  D.21852 = start;
  return D.21852;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.21862;
  uint32_t D.21865;
  int index.110;
  int D.21867;
  <unnamed-unsigned:24> D.21868;
  long unsigned int D.21869;
  unsigned char D.21870;
  long unsigned int D.21871;
  void * D.21872;
  unsigned int D.21875;
  int D.21876;
  unsigned int D.21879;
  unsigned int D.21882;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.21862 = tdef->base;
      if (D.21862 == 0B) goto <D.21863>; else goto <D.21864>;
      <D.21863>:
      D.21865 = 0;
      return D.21865;
      <D.21864>:
      index.110 = (int) index;
      D.21867 = index.110 & 16777215;
      loc.idx = D.21867;
      loc.col_idx = 2;
      loc.t = tdef;
      D.21862 = tdef->base;
      D.21868 = tdef->rows;
      D.21869 = (long unsigned int) D.21868;
      D.21870 = tdef->row_size;
      D.21871 = (long unsigned int) D.21870;
      D.21872 = mono_binary_search (&loc, D.21862, D.21869, D.21871, table_locator);
      if (D.21872 == 0B) goto <D.21873>; else goto <D.21874>;
      <D.21873>:
      D.21865 = 0;
      return D.21865;
      <D.21874>:
      D.21875 = loc.result;
      D.21876 = (int) D.21875;
      mono_metadata_decode_row (tdef, D.21876, &cols, 3);
      if (packing != 0B) goto <D.21877>; else goto <D.21878>;
      <D.21877>:
      D.21879 = cols[0];
      *packing = D.21879;
      <D.21878>:
      if (size != 0B) goto <D.21880>; else goto <D.21881>;
      <D.21880>:
      D.21882 = cols[1];
      *size = D.21882;
      <D.21881>:
      D.21875 = loc.result;
      D.21865 = D.21875 + 1;
      return D.21865;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21885;
  uint32_t D.21888;
  int index.111;
  <unnamed-unsigned:24> D.21890;
  long unsigned int D.21891;
  unsigned char D.21892;
  long unsigned int D.21893;
  void * D.21894;
  unsigned int D.21897;
  unsigned int D.21898;
  int D.21900;
  unsigned int D.21901;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.21885 = tdef->base;
      if (D.21885 == 0B) goto <D.21886>; else goto <D.21887>;
      <D.21886>:
      D.21888 = 0;
      return D.21888;
      <D.21887>:
      index.111 = (int) index;
      loc.idx = index.111;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21885 = tdef->base;
      D.21890 = tdef->rows;
      D.21891 = (long unsigned int) D.21890;
      D.21892 = tdef->row_size;
      D.21893 = (long unsigned int) D.21892;
      D.21894 = mono_binary_search (&loc, D.21885, D.21891, D.21893, table_locator);
      if (D.21894 == 0B) goto <D.21895>; else goto <D.21896>;
      <D.21895>:
      D.21888 = 0;
      return D.21888;
      <D.21896>:
      goto <D.18734>;
      <D.18733>:
      D.21897 = loc.result;
      D.21898 = D.21897 + 4294967295;
      loc.result = D.21898;
      <D.18734>:
      D.21897 = loc.result;
      if (D.21897 != 0) goto <D.21899>; else goto <D.18735>;
      <D.21899>:
      D.21897 = loc.result;
      D.21898 = D.21897 + 4294967295;
      D.21900 = (int) D.21898;
      D.21901 = mono_metadata_decode_row_col (tdef, D.21900, 0);
      if (D.21901 == index) goto <D.18733>; else goto <D.18735>;
      <D.18735>:
      D.21897 = loc.result;
      D.21888 = D.21897 + 1;
      return D.21888;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21904;
  uint32_t D.21907;
  int index.112;
  <unnamed-unsigned:24> D.21909;
  long unsigned int D.21910;
  unsigned char D.21911;
  long unsigned int D.21912;
  void * D.21913;
  unsigned int D.21916;
  unsigned int D.21917;
  int D.21919;
  unsigned int D.21920;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.21904 = tdef->base;
      if (D.21904 == 0B) goto <D.21905>; else goto <D.21906>;
      <D.21905>:
      D.21907 = 4294967295;
      return D.21907;
      <D.21906>:
      index.112 = (int) index;
      loc.idx = index.112;
      loc.col_idx = 1;
      loc.t = tdef;
      D.21904 = tdef->base;
      D.21909 = tdef->rows;
      D.21910 = (long unsigned int) D.21909;
      D.21911 = tdef->row_size;
      D.21912 = (long unsigned int) D.21911;
      D.21913 = mono_binary_search (&loc, D.21904, D.21910, D.21912, declsec_locator);
      if (D.21913 == 0B) goto <D.21914>; else goto <D.21915>;
      <D.21914>:
      D.21907 = 4294967295;
      return D.21907;
      <D.21915>:
      goto <D.18743>;
      <D.18742>:
      D.21916 = loc.result;
      D.21917 = D.21916 + 4294967295;
      loc.result = D.21917;
      <D.18743>:
      D.21916 = loc.result;
      if (D.21916 != 0) goto <D.21918>; else goto <D.18744>;
      <D.21918>:
      D.21916 = loc.result;
      D.21917 = D.21916 + 4294967295;
      D.21919 = (int) D.21917;
      D.21920 = mono_metadata_decode_row_col (tdef, D.21919, 1);
      if (D.21920 == index) goto <D.18742>; else goto <D.18744>;
      <D.18744>:
      D.21907 = loc.result;
      return D.21907;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  long int bb.113;
  struct MonoTableInfo * D.21924;
  const char * D.21925;
  long int D.21926;
  long int D.21927;
  unsigned char D.21928;
  long int D.21929;
  long int D.21930;
  int table_index.114;
  int D.21932;
  unsigned int D.21933;
  int D.21934;
  unsigned int D.21935;
  int D.21938;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.113 = (long int) bb;
  D.21924 = loc->t;
  D.21925 = D.21924->base;
  D.21926 = (long int) D.21925;
  D.21927 = bb.113 - D.21926;
  D.21924 = loc->t;
  D.21928 = D.21924->row_size;
  D.21929 = (long int) D.21928;
  D.21930 = D.21927 / D.21929;
  table_index = (guint32) D.21930;
  D.21924 = loc->t;
  table_index.114 = (int) table_index;
  D.21932 = loc->col_idx;
  D.21933 = (unsigned int) D.21932;
  col = mono_metadata_decode_row_col (D.21924, table_index.114, D.21933);
  D.21934 = loc->idx;
  D.21935 = (unsigned int) D.21934;
  if (D.21935 == col) goto <D.21936>; else goto <D.21937>;
  <D.21936>:
  loc->result = table_index;
  D.21938 = 0;
  return D.21938;
  <D.21937>:
  D.21934 = loc->idx;
  D.21935 = (unsigned int) D.21934;
  if (D.21935 < col) goto <D.21939>; else goto <D.21940>;
  <D.21939>:
  D.21938 = -1;
  return D.21938;
  <D.21940>:
  D.21938 = 1;
  return D.21938;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.21944;
  long unsigned int D.21945;
  long unsigned int D.21946;
  unsigned char D.21949;
  int D.21950;
  struct MonoClass * D.21951;
  long unsigned int D.21952;
  long unsigned int D.21953;
  struct MonoType * D.21956;
  struct MonoClass * D.21957;
  long unsigned int D.21958;
  long unsigned int D.21959;
  long unsigned int D.21962;
  struct MonoType * D.21965;
  struct MonoClass * D.21966;

  if (t == 0B) goto <D.21942>; else goto <D.21943>;
  <D.21942>:
  *align = 1;
  D.21944 = 0;
  return D.21944;
  <D.21943>:
  D.21945 = BIT_FIELD_REF <*t, 64, 64>;
  D.21946 = D.21945 & 8589934592;
  if (D.21946 != 0) goto <D.21947>; else goto <D.21948>;
  <D.21947>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 8;
    D.21944 = 8;
    return D.21944;
  }
  <D.21948>:
  D.21949 = t->type;
  D.21950 = (int) D.21949;
  switch (D.21950) <default: <D.18820>, case 1: <D.18752>, case 2: <D.18753>, case 3: <D.18762>, case 4: <D.18757>, case 5: <D.18758>, case 6: <D.18763>, case 7: <D.18764>, case 8: <D.18768>, case 9: <D.18769>, case 10: <D.18777>, case 11: <D.18778>, case 12: <D.18773>, case 13: <D.18782>, case 14: <D.18791>, case 15: <D.18802>, case 17: <D.18799>, case 18: <D.18800>, case 19: <D.18815>, case 20: <D.18804>, case 21: <D.18809>, case 22: <D.18808>, case 24: <D.18786>, case 25: <D.18787>, case 27: <D.18803>, case 28: <D.18795>, case 29: <D.18801>, case 30: <D.18816>>
  {
    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.18752>:
    *align = 1;
    D.21944 = 0;
    return D.21944;
    <D.18753>:
    *align = 1;
    D.21944 = 1;
    return D.21944;
    <D.18757>:
    <D.18758>:
    *align = 1;
    D.21944 = 1;
    return D.21944;
    <D.18762>:
    <D.18763>:
    <D.18764>:
    *align = 2;
    D.21944 = 2;
    return D.21944;
    <D.18768>:
    <D.18769>:
    *align = 4;
    D.21944 = 4;
    return D.21944;
    <D.18773>:
    *align = 4;
    D.21944 = 4;
    return D.21944;
    <D.18777>:
    <D.18778>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18782>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18786>:
    <D.18787>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18791>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18795>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18799>:
    D.21951 = t->data.klass;
    D.21952 = BIT_FIELD_REF <*D.21951, 64, 256>;
    D.21953 = D.21952 & 576460752303423488;
    if (D.21953 != 0) goto <D.21954>; else goto <D.21955>;
    <D.21954>:
    D.21951 = t->data.klass;
    D.21956 = mono_class_enum_basetype (D.21951);
    D.21944 = mono_type_size (D.21956, align);
    return D.21944;
    <D.21955>:
    D.21951 = t->data.klass;
    D.21944 = mono_class_value_size (D.21951, align);
    return D.21944;
    <D.18800>:
    <D.18801>:
    <D.18802>:
    <D.18803>:
    <D.18804>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18808>:
    D.21957 = mono_defaults.typed_reference_class;
    D.21944 = mono_class_value_size (D.21957, align);
    return D.21944;
    <D.18809>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.21958 = BIT_FIELD_REF <*container_class, 64, 256>;
      D.21959 = D.21958 & 1152921504606846976;
      if (D.21959 != 0) goto <D.21960>; else goto <D.21961>;
      <D.21960>:
      D.21958 = BIT_FIELD_REF <*container_class, 64, 256>;
      D.21962 = D.21958 & 576460752303423488;
      if (D.21962 != 0) goto <D.21963>; else goto <D.21964>;
      <D.21963>:
      D.21965 = mono_class_enum_basetype (container_class);
      D.21944 = mono_type_size (D.21965, align);
      return D.21944;
      <D.21964>:
      D.21966 = mono_class_from_mono_type (t);
      D.21944 = mono_class_value_size (D.21966, align);
      return D.21944;
      <D.21961>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 8;
        D.21944 = 8;
        return D.21944;
      }
    }
    <D.18815>:
    <D.18816>:
    *align = 8;
    D.21944 = 8;
    return D.21944;
    <D.18820>:
    D.21949 = t->type;
    D.21950 = (int) D.21949;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.21950);
    <D.18821>:
    goto <D.18821>;
  }
  D.21944 = 0;
  return D.21944;
}


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

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


__attribute__((visibility ("hidden")))
mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.21970;
  long int D.21971;
  long int D.21972;
  long unsigned int D.21977;
  long unsigned int D.21978;
  int D.21981;
  unsigned char D.21982;
  int D.21983;
  _Bool D.21984;
  long int D.21985;
  long int D.21986;
  struct MonoClass * D.21989;
  long unsigned int D.21990;
  long unsigned int D.21991;
  struct MonoType * D.21994;
  int D.21995;
  int D.21996;
  int D.21997;
  int D.21998;
  int D.21999;
  int D.22000;
  unsigned int stack_slot_size.115;
  unsigned int D.22002;
  int D.22003;
  unsigned int D.22004;
  struct MonoGenericInst * D.22007;
  long unsigned int D.22008;
  long unsigned int D.22009;
  _Bool D.22010;
  long int D.22011;
  long int D.22012;
  long unsigned int D.22015;
  long unsigned int D.22016;
  long unsigned int D.22019;
  struct MonoType * D.22022;
  struct MonoClass * D.22023;
  int D.22024;
  unsigned int D.22025;
  int tmp;
  int stack_slot_size;
  int stack_slot_align;
  typedef struct 
{
  char c;
  void * x;
} struct struct 
{
  char c;
  void * x;
};

  try
    {
      stack_slot_size = 8;
      stack_slot_align = 8;
      D.21970 = t == 0B;
      D.21971 = (long int) D.21970;
      D.21972 = __builtin_expect (D.21971, 0);
      if (D.21972 != 0) goto <D.21973>; else goto <D.21974>;
      <D.21973>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.21974>:
      if (align == 0B) goto <D.21975>; else goto <D.21976>;
      <D.21975>:
      align = &tmp;
      <D.21976>:
      D.21977 = BIT_FIELD_REF <*t, 64, 64>;
      D.21978 = D.21977 & 8589934592;
      if (D.21978 != 0) goto <D.21979>; else goto <D.21980>;
      <D.21979>:
      *align = stack_slot_align;
      D.21981 = stack_slot_size;
      return D.21981;
      <D.21980>:
      D.21982 = t->type;
      D.21983 = (int) D.21982;
      switch (D.21983) <default: <D.18876>, case 2: <D.18837>, case 3: <D.18838>, case 4: <D.18839>, case 5: <D.18840>, case 6: <D.18841>, case 7: <D.18842>, case 8: <D.18843>, case 9: <D.18844>, case 10: <D.18861>, case 11: <D.18862>, case 12: <D.18857>, case 13: <D.18866>, case 14: <D.18847>, case 15: <D.18851>, case 17: <D.18870>, case 18: <D.18849>, case 19: <D.18854>, case 20: <D.18853>, case 21: <D.18872>, case 22: <D.18856>, case 24: <D.18845>, case 25: <D.18846>, case 27: <D.18852>, case 28: <D.18848>, case 29: <D.18850>, case 30: <D.18855>>
      {
        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.18837>:
        <D.18838>:
        <D.18839>:
        <D.18840>:
        <D.18841>:
        <D.18842>:
        <D.18843>:
        <D.18844>:
        <D.18845>:
        <D.18846>:
        <D.18847>:
        <D.18848>:
        <D.18849>:
        <D.18850>:
        <D.18851>:
        <D.18852>:
        <D.18853>:
        *align = stack_slot_align;
        D.21981 = stack_slot_size;
        return D.21981;
        <D.18854>:
        <D.18855>:
        D.21984 = allow_open == 0;
        D.21985 = (long int) D.21984;
        D.21986 = __builtin_expect (D.21985, 0);
        if (D.21986 != 0) goto <D.21987>; else goto <D.21988>;
        <D.21987>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.21988>:
        *align = stack_slot_align;
        D.21981 = stack_slot_size;
        return D.21981;
        <D.18856>:
        *align = stack_slot_align;
        D.21981 = stack_slot_size * 3;
        return D.21981;
        <D.18857>:
        *align = 4;
        D.21981 = 4;
        return D.21981;
        <D.18861>:
        <D.18862>:
        *align = 8;
        D.21981 = 8;
        return D.21981;
        <D.18866>:
        *align = 8;
        D.21981 = 8;
        return D.21981;
        <D.18870>:
        {
          guint32 size;

          D.21989 = t->data.klass;
          D.21990 = BIT_FIELD_REF <*D.21989, 64, 256>;
          D.21991 = D.21990 & 576460752303423488;
          if (D.21991 != 0) goto <D.21992>; else goto <D.21993>;
          <D.21992>:
          D.21989 = t->data.klass;
          D.21994 = mono_class_enum_basetype (D.21989);
          D.21981 = mono_type_stack_size_internal (D.21994, align, allow_open);
          return D.21981;
          <D.21993>:
          D.21989 = t->data.klass;
          D.21995 = mono_class_value_size (D.21989, align);
          size = (guint32) D.21995;
          D.21996 = *align;
          D.21997 = D.21996 + stack_slot_align;
          D.21998 = D.21997 + -1;
          *align = D.21998;
          D.21996 = *align;
          D.21999 = -stack_slot_align;
          D.22000 = D.21996 & D.21999;
          *align = D.22000;
          stack_slot_size.115 = (unsigned int) stack_slot_size;
          D.22002 = stack_slot_size.115 + size;
          size = D.22002 + 4294967295;
          D.22003 = -stack_slot_size;
          D.22004 = (unsigned int) D.22003;
          size = D.22004 & size;
          D.21981 = (int) size;
          return D.21981;
        }
        <D.18872>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.22005>; else goto <D.22006>;
          <D.22005>:
          D.22007 = gclass->context.class_inst;
          D.22008 = BIT_FIELD_REF <*D.22007, 64, 0>;
          D.22009 = D.22008 & 512;
          D.22010 = D.22009 != 0;
          D.22011 = (long int) D.22010;
          D.22012 = __builtin_expect (D.22011, 0);
          if (D.22012 != 0) goto <D.22013>; else goto <D.22014>;
          <D.22013>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.22014>:
          <D.22006>:
          D.22015 = BIT_FIELD_REF <*container_class, 64, 256>;
          D.22016 = D.22015 & 1152921504606846976;
          if (D.22016 != 0) goto <D.22017>; else goto <D.22018>;
          <D.22017>:
          D.22015 = BIT_FIELD_REF <*container_class, 64, 256>;
          D.22019 = D.22015 & 576460752303423488;
          if (D.22019 != 0) goto <D.22020>; else goto <D.22021>;
          <D.22020>:
          D.22022 = mono_class_enum_basetype (container_class);
          D.21981 = mono_type_stack_size_internal (D.22022, align, allow_open);
          return D.21981;
          <D.22021>:
          {
            guint32 size;

            D.22023 = mono_class_from_mono_type (t);
            D.22024 = mono_class_value_size (D.22023, align);
            size = (guint32) D.22024;
            D.21996 = *align;
            D.21997 = D.21996 + stack_slot_align;
            D.21998 = D.21997 + -1;
            *align = D.21998;
            D.21996 = *align;
            D.21999 = -stack_slot_align;
            D.22000 = D.21996 & D.21999;
            *align = D.22000;
            stack_slot_size.115 = (unsigned int) stack_slot_size;
            D.22025 = stack_slot_size.115 + size;
            size = D.22025 + 4294967295;
            D.22003 = -stack_slot_size;
            D.22004 = (unsigned int) D.22003;
            size = D.22004 & size;
            D.21981 = (int) size;
            return D.21981;
          }
          <D.22018>:
          *align = stack_slot_align;
          D.21981 = stack_slot_size;
          return D.21981;
        }
        <D.18876>:
        D.21982 = t->type;
        D.21983 = (int) D.21982;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.21983);
        <D.18877>:
        goto <D.18877>;
      }
      D.21981 = 0;
      return D.21981;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.22028;
  _Bool D.22029;
  long int D.22030;
  long int D.22031;
  mono_bool D.22034;
  struct MonoGenericClass * D.22035;
  struct MonoClass * D.22036;
  <unnamed-unsigned:1> D.22037;

  D.22028 = type->type;
  D.22029 = D.22028 != 21;
  D.22030 = (long int) D.22029;
  D.22031 = __builtin_expect (D.22030, 0);
  if (D.22031 != 0) goto <D.22032>; else goto <D.22033>;
  <D.22032>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.22033>:
  D.22035 = type->data.generic_class;
  D.22036 = D.22035->container_class;
  D.22037 = D.22036->valuetype;
  D.22034 = (mono_bool) D.22037;
  return D.22034;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.22039;
  struct MonoClass * D.22040;
  <unnamed-unsigned:1> D.22041;

  D.22040 = gclass->container_class;
  D.22041 = D.22040->valuetype;
  D.22039 = (mono_bool) D.22041;
  return D.22039;
}


__attribute__((visibility ("hidden")))
mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.22043;
  unsigned int D.22046;
  unsigned int D.22047;
  unsigned int D.22048;
  struct MonoGenericInst * D.22049;
  unsigned int D.22052;
  guint D.22053;
  guint hash;

  hash = 3223191271;
  D.22043 = context->class_inst;
  if (D.22043 != 0B) goto <D.22044>; else goto <D.22045>;
  <D.22044>:
  D.22046 = hash << 5;
  D.22047 = D.22046 - hash;
  D.22043 = context->class_inst;
  D.22048 = mono_metadata_generic_inst_hash (D.22043);
  hash = D.22047 ^ D.22048;
  <D.22045>:
  D.22049 = context->method_inst;
  if (D.22049 != 0B) goto <D.22050>; else goto <D.22051>;
  <D.22050>:
  D.22046 = hash << 5;
  D.22047 = D.22046 - hash;
  D.22049 = context->method_inst;
  D.22052 = mono_metadata_generic_inst_hash (D.22049);
  hash = D.22047 ^ D.22052;
  <D.22051>:
  D.22053 = hash;
  return D.22053;
}


__attribute__((visibility ("hidden")))
mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.22055;
  int iftmp.116;
  struct MonoGenericInst * D.22059;
  struct MonoGenericInst * D.22060;
  struct MonoGenericInst * D.22062;
  struct MonoGenericInst * D.22063;

  D.22059 = g1->class_inst;
  D.22060 = g2->class_inst;
  if (D.22059 == D.22060) goto <D.22061>; else goto <D.22057>;
  <D.22061>:
  D.22062 = g1->method_inst;
  D.22063 = g2->method_inst;
  if (D.22062 == D.22063) goto <D.22064>; else goto <D.22057>;
  <D.22064>:
  iftmp.116 = 1;
  goto <D.22058>;
  <D.22057>:
  iftmp.116 = 0;
  <D.22058>:
  D.22055 = iftmp.116;
  return D.22055;
}


__attribute__((visibility ("hidden")))
mono_metadata_str_hash (const void * v1)
{
  char D.22066;
  unsigned int D.22069;
  unsigned int D.22070;
  unsigned int D.22071;
  char * p.117;
  char D.22073;
  guint D.22074;
  char * p;
  guint hash;

  p = v1;
  D.22066 = *p;
  hash = (guint) D.22066;
  goto <D.18912>;
  <D.18911>:
  D.22066 = *p;
  if (D.22066 != 0) goto <D.22067>; else goto <D.22068>;
  <D.22067>:
  D.22069 = hash << 5;
  D.22070 = D.22069 - hash;
  D.22066 = *p;
  D.22071 = (unsigned int) D.22066;
  hash = D.22070 + D.22071;
  <D.22068>:
  <D.18912>:
  p.117 = p;
  p = p.117 + 1;
  D.22073 = *p.117;
  if (D.22073 != 0) goto <D.18911>; else goto <D.18913>;
  <D.18913>:
  D.22074 = hash;
  return D.22074;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.22076;
  <unnamed-unsigned:1> D.22077;
  int D.22078;
  int D.22079;
  unsigned int D.22080;
  int D.22081;
  struct MonoImage * D.22082;
  long unsigned int D.22083;
  long unsigned int D.22084;
  unsigned int D.22087;
  const char * D.22088;
  unsigned int D.22089;
  unsigned int D.22090;
  unsigned int D.22091;
  unsigned int D.22092;
  struct MonoType * D.22093;
  unsigned int D.22094;
  struct MonoArrayType * D.22095;
  struct MonoClass * D.22096;
  struct MonoType * D.22097;
  unsigned int D.22098;
  struct MonoGenericClass * D.22099;
  unsigned int D.22100;
  guint hash;

  D.22076 = t1->type;
  hash = (guint) D.22076;
  D.22077 = t1->byref;
  D.22078 = (int) D.22077;
  D.22079 = D.22078 << 6;
  D.22080 = (unsigned int) D.22079;
  hash = D.22080 | hash;
  D.22076 = t1->type;
  D.22081 = (int) D.22076;
  switch (D.22081) <default: <D.22101>, case 15: <D.18922>, case 17: <D.18918>, case 18: <D.18919>, case 20: <D.18923>, case 21: <D.18924>, case 29: <D.18920>>
  <D.18918>:
  <D.18919>:
  <D.18920>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.22082 = class->image;
    D.22083 = BIT_FIELD_REF <*D.22082, 64, 192>;
    D.22084 = D.22083 & 268435456;
    if (D.22084 != 0) goto <D.22085>; else goto <D.22086>;
    <D.22085>:
    D.22077 = t1->byref;
    D.22078 = (int) D.22077;
    D.22079 = D.22078 << 6;
    D.22080 = (unsigned int) D.22079;
    D.22088 = class->name;
    D.22089 = mono_metadata_str_hash (D.22088);
    D.22087 = D.22080 | D.22089;
    return D.22087;
    <D.22086>:
    D.22090 = hash << 5;
    D.22091 = D.22090 - hash;
    D.22088 = class->name;
    D.22092 = mono_metadata_str_hash (D.22088);
    D.22087 = D.22091 ^ D.22092;
    return D.22087;
  }
  <D.18922>:
  D.22090 = hash << 5;
  D.22091 = D.22090 - hash;
  D.22093 = t1->data.type;
  D.22094 = mono_metadata_type_hash (D.22093);
  D.22087 = D.22091 ^ D.22094;
  return D.22087;
  <D.18923>:
  D.22090 = hash << 5;
  D.22091 = D.22090 - hash;
  D.22095 = t1->data.array;
  D.22096 = D.22095->eklass;
  D.22097 = &D.22096->byval_arg;
  D.22098 = mono_metadata_type_hash (D.22097);
  D.22087 = D.22091 ^ D.22098;
  return D.22087;
  <D.18924>:
  D.22090 = hash << 5;
  D.22091 = D.22090 - hash;
  D.22099 = t1->data.generic_class;
  D.22100 = mono_generic_class_hash (D.22099);
  D.22087 = D.22091 ^ D.22100;
  return D.22087;
  <D.22101>:
  D.22087 = hash;
  return D.22087;
}


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

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


__attribute__((visibility ("hidden")))
mono_metadata_type_equal_full (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  gboolean D.22105;

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


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  long unsigned int D.22109;
  long unsigned int D.22110;
  long unsigned int D.22111;
  long unsigned int D.22112;
  short unsigned int D.22114;
  short unsigned int D.22115;
  mono_bool D.22116;
  short unsigned int D.22117;
  short unsigned int D.22118;
  int D.22121;
  int D.22124;
  struct MonoType * D.22125;
  struct MonoType * D.22126;
  int D.22127;
  int i;

  D.22109 = BIT_FIELD_REF <*sig1, 64, 64>;
  D.22110 = BIT_FIELD_REF <*sig2, 64, 64>;
  D.22111 = D.22109 ^ D.22110;
  D.22112 = D.22111 & 512;
  if (D.22112 != 0) goto <D.22107>; else goto <D.22113>;
  <D.22113>:
  D.22114 = sig1->param_count;
  D.22115 = sig2->param_count;
  if (D.22114 != D.22115) goto <D.22107>; else goto <D.22108>;
  <D.22107>:
  D.22116 = 0;
  return D.22116;
  <D.22108>:
  D.22117 = sig1->generic_param_count;
  D.22118 = sig2->generic_param_count;
  if (D.22117 != D.22118) goto <D.22119>; else goto <D.22120>;
  <D.22119>:
  D.22116 = 0;
  return D.22116;
  <D.22120>:
  i = 0;
  goto <D.18996>;
  <D.18995>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.22121 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.22121 == 0) goto <D.22122>; else goto <D.22123>;
    <D.22122>:
    D.22116 = 0;
    return D.22116;
    <D.22123>:
  }
  i = i + 1;
  <D.18996>:
  D.22114 = sig1->param_count;
  D.22124 = (int) D.22114;
  if (D.22124 > i) goto <D.18995>; else goto <D.18997>;
  <D.18997>:
  D.22125 = sig1->ret;
  D.22126 = sig2->ret;
  D.22127 = do_mono_metadata_type_equal (D.22125, D.22126, 1);
  if (D.22127 == 0) goto <D.22128>; else goto <D.22129>;
  <D.22128>:
  D.22116 = 0;
  return D.22116;
  <D.22129>:
  D.22116 = 1;
  return D.22116;
}


__attribute__((visibility ("hidden")))
mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  long unsigned int D.22131;
  long unsigned int D.22132;
  <unnamed-unsigned:6> D.22135;
  unsigned int D.22136;
  unsigned int D.22137;
  unsigned int sizeof_o.118;
  unsigned int D.22139;
  void * iftmp.119;
  unsigned int sizeof_o.120;
  long unsigned int D.22145;
  long unsigned int D.22146;
  unsigned char D.22147;
  struct MonoType * D.22150;
  struct MonoType * D.22151;
  struct MonoArrayType * D.22155;
  struct MonoArrayType * D.22156;
  struct MonoMethodSignature * D.22160;
  struct MonoMethodSignature * D.22161;
  struct MonoType * D.22162;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 12;
  D.22131 = BIT_FIELD_REF <*o, 64, 64>;
  D.22132 = D.22131 & 1082331758592;
  if (D.22132 != 0) goto <D.22133>; else goto <D.22134>;
  <D.22133>:
  D.22135 = o->num_mods;
  D.22136 = (unsigned int) D.22135;
  D.22137 = D.22136 * 4;
  sizeof_o.118 = (unsigned int) sizeof_o;
  D.22139 = D.22137 + sizeof_o.118;
  sizeof_o = (int) D.22139;
  <D.22134>:
  if (image != 0B) goto <D.22141>; else goto <D.22142>;
  <D.22141>:
  sizeof_o.120 = (unsigned int) sizeof_o;
  iftmp.119 = mono_image_alloc0 (image, sizeof_o.120);
  goto <D.22144>;
  <D.22142>:
  D.22145 = (long unsigned int) sizeof_o;
  iftmp.119 = monoeg_malloc (D.22145);
  <D.22144>:
  r = iftmp.119;
  D.22146 = (long unsigned int) sizeof_o;
  memcpy (r, o, D.22146);
  D.22147 = o->type;
  if (D.22147 == 15) goto <D.22148>; else goto <D.22149>;
  <D.22148>:
  D.22150 = o->data.type;
  D.22151 = mono_metadata_type_dup (image, D.22150);
  r->data.type = D.22151;
  goto <D.22152>;
  <D.22149>:
  D.22147 = o->type;
  if (D.22147 == 20) goto <D.22153>; else goto <D.22154>;
  <D.22153>:
  D.22155 = o->data.array;
  D.22156 = mono_dup_array_type (image, D.22155);
  r->data.array = D.22156;
  goto <D.22157>;
  <D.22154>:
  D.22147 = o->type;
  if (D.22147 == 27) goto <D.22158>; else goto <D.22159>;
  <D.22158>:
  D.22160 = o->data.method;
  D.22161 = mono_metadata_signature_deep_dup (image, D.22160);
  r->data.method = D.22161;
  <D.22159>:
  <D.22157>:
  <D.22152>:
  D.22162 = r;
  return D.22162;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.22164;
  unsigned char D.22165;
  unsigned int D.22166;
  unsigned int D.22167;
  struct MonoType * D.22168;
  unsigned int D.22169;
  short unsigned int D.22170;
  unsigned int D.22171;
  unsigned int D.22172;
  guint i;
  guint res;

  D.22164 = sig->ret;
  D.22165 = D.22164->type;
  res = (guint) D.22165;
  i = 0;
  goto <D.19010>;
  <D.19009>:
  D.22166 = res << 5;
  D.22167 = D.22166 - res;
  D.22168 = sig->params[i];
  D.22169 = mono_type_hash (D.22168);
  res = D.22167 + D.22169;
  i = i + 1;
  <D.19010>:
  D.22170 = sig->param_count;
  D.22171 = (unsigned int) D.22170;
  if (D.22171 > i) goto <D.19009>; else goto <D.19011>;
  <D.19011>:
  D.22172 = res;
  return D.22172;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.121;
  char D.22177;
  unsigned int D.22181;
  char D.22182;
  char D.22183;
  char * D.22184;
  unsigned int D.22186;
  char D.22187;
  char D.22188;
  unsigned int D.22189;
  char D.22190;
  char * D.22191;
  char * D.22192;
  char * p;

  p = buf;
  if (value <= 127) goto <D.22174>; else goto <D.22175>;
  <D.22174>:
  p.121 = p;
  p = p.121 + 1;
  D.22177 = (char) value;
  *p.121 = D.22177;
  goto <D.22178>;
  <D.22175>:
  if (value <= 16383) goto <D.22179>; else goto <D.22180>;
  <D.22179>:
  D.22181 = value >> 8;
  D.22182 = (char) D.22181;
  D.22183 = D.22182 | 128;
  *p = D.22183;
  D.22184 = p + 1;
  D.22177 = (char) value;
  *D.22184 = D.22177;
  p = p + 2;
  goto <D.22185>;
  <D.22180>:
  D.22186 = value >> 24;
  D.22187 = (char) D.22186;
  D.22188 = D.22187 | 192;
  *p = D.22188;
  D.22184 = p + 1;
  D.22189 = value >> 16;
  D.22190 = (char) D.22189;
  *D.22184 = D.22190;
  D.22191 = p + 2;
  D.22181 = value >> 8;
  D.22182 = (char) D.22181;
  *D.22191 = D.22182;
  D.22192 = p + 3;
  D.22177 = (char) value;
  *D.22192 = D.22177;
  p = p + 4;
  <D.22185>:
  <D.22178>:
  if (endbuf != 0B) goto <D.22193>; else goto <D.22194>;
  <D.22193>:
  *endbuf = p;
  <D.22194>:
}


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.22195;
  int D.22196;
  long unsigned int D.22197;
  long unsigned int D.22198;
  int D.22201;
  unsigned int D.22202;
  int D.22203;
  const char * D.22208;
  <unnamed-unsigned:24> D.22210;
  long unsigned int D.22211;
  unsigned char D.22212;
  long unsigned int D.22213;
  void * D.22214;
  unsigned int D.22216;
  int D.22217;
  unsigned int D.22218;
  void * D.22224;
  unsigned int D.22226;
  struct MonoImage * iftmp.122;
  struct MonoMarshalSpec * D.22235;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.22195 = index + 1;
      D.22196 = (int) D.22195;
      loc.idx = D.22196;
      D.22197 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22198 = D.22197 & 67108864;
      if (D.22198 != 0) goto <D.22199>; else goto <D.22200>;
      <D.22199>:
      D.22201 = loc.idx;
      D.22202 = search_ptr_table (meta, 3, D.22201);
      D.22203 = (int) D.22202;
      loc.idx = D.22203;
      <D.22200>:
      if (offset != 0B) goto <D.22204>; else goto <D.22205>;
      <D.22204>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.22208 = tdef->base;
      if (D.22208 != 0B) goto <D.22209>; else goto <D.22206>;
      <D.22209>:
      D.22208 = tdef->base;
      D.22210 = tdef->rows;
      D.22211 = (long unsigned int) D.22210;
      D.22212 = tdef->row_size;
      D.22213 = (long unsigned int) D.22212;
      D.22214 = mono_binary_search (&loc, D.22208, D.22211, D.22213, table_locator);
      if (D.22214 != 0B) goto <D.22215>; else goto <D.22206>;
      <D.22215>:
      D.22216 = loc.result;
      D.22217 = (int) D.22216;
      D.22218 = mono_metadata_decode_row_col (tdef, D.22217, 0);
      *offset = D.22218;
      goto <D.22207>;
      <D.22206>:
      *offset = 4294967295;
      <D.22207>:
      <D.22205>:
      if (rva != 0B) goto <D.22219>; else goto <D.22220>;
      <D.22219>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.22208 = tdef->base;
      if (D.22208 != 0B) goto <D.22223>; else goto <D.22221>;
      <D.22223>:
      D.22208 = tdef->base;
      D.22210 = tdef->rows;
      D.22211 = (long unsigned int) D.22210;
      D.22212 = tdef->row_size;
      D.22213 = (long unsigned int) D.22212;
      D.22224 = mono_binary_search (&loc, D.22208, D.22211, D.22213, table_locator);
      if (D.22224 != 0B) goto <D.22225>; else goto <D.22221>;
      <D.22225>:
      D.22216 = loc.result;
      D.22217 = (int) D.22216;
      D.22226 = mono_metadata_decode_row_col (tdef, D.22217, 0);
      *rva = D.22226;
      goto <D.22222>;
      <D.22221>:
      *rva = 0;
      <D.22222>:
      <D.22220>:
      if (marshal_spec != 0B) goto <D.22227>; else goto <D.22228>;
      <D.22227>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.22229>; else goto <D.22230>;
        <D.22229>:
        if (alloc_from_image != 0) goto <D.22232>; else goto <D.22233>;
        <D.22232>:
        iftmp.122 = meta;
        goto <D.22234>;
        <D.22233>:
        iftmp.122 = 0B;
        <D.22234>:
        D.22235 = mono_metadata_parse_marshal_spec_full (iftmp.122, p);
        *marshal_spec = D.22235;
        <D.22230>:
      }
      <D.22228>:
    }
  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.22236;
  uint32_t D.22237;
  int index.123;
  <unnamed-unsigned:24> D.22241;
  unsigned int D.22242;
  unsigned int D.22245;
  int D.22246;
  unsigned int D.22247;
  const char * D.22250;
  long unsigned int D.22253;
  unsigned char D.22254;
  long unsigned int D.22255;
  void * D.22256;
  unsigned int D.22259;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.22236 = token >> 24;
      switch (D.22236) <default: <D.19055>, case 4: <D.19051>, case 8: <D.19053>, case 23: <D.19054>>
      <D.19051>:
      index = index;
      goto <D.19052>;
      <D.19053>:
      index = index | 1;
      goto <D.19052>;
      <D.19054>:
      index = index | 2;
      goto <D.19052>;
      <D.19055>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.22237 = 0;
      return D.22237;
      <D.19052>:
      index.123 = (int) index;
      loc.idx = index.123;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.22239>; else goto <D.22240>;
      <D.22239>:
      D.22241 = tdef->rows;
      D.22242 = (unsigned int) D.22241;
      if (D.22242 > hint) goto <D.22243>; else goto <D.22244>;
      <D.22243>:
      D.22245 = hint + 4294967295;
      D.22246 = (int) D.22245;
      D.22247 = mono_metadata_decode_row_col (tdef, D.22246, 2);
      if (D.22247 == index) goto <D.22248>; else goto <D.22249>;
      <D.22248>:
      D.22237 = hint;
      return D.22237;
      <D.22249>:
      <D.22244>:
      <D.22240>:
      D.22250 = tdef->base;
      if (D.22250 != 0B) goto <D.22251>; else goto <D.22252>;
      <D.22251>:
      D.22250 = tdef->base;
      D.22241 = tdef->rows;
      D.22253 = (long unsigned int) D.22241;
      D.22254 = tdef->row_size;
      D.22255 = (long unsigned int) D.22254;
      D.22256 = mono_binary_search (&loc, D.22250, D.22253, D.22255, table_locator);
      if (D.22256 != 0B) goto <D.22257>; else goto <D.22258>;
      <D.22257>:
      D.22259 = loc.result;
      D.22237 = D.22259 + 1;
      return D.22237;
      <D.22258>:
      <D.22252>:
      D.22237 = 0;
      return D.22237;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22262;
  uint32_t D.22265;
  unsigned int D.22266;
  int D.22267;
  <unnamed-unsigned:24> D.22268;
  long unsigned int D.22269;
  unsigned char D.22270;
  long unsigned int D.22271;
  void * D.22272;
  unsigned int D.22275;
  int D.22276;
  unsigned int D.22277;
  unsigned int D.22278;
  int D.22281;
  unsigned int D.22282;
  <unnamed-unsigned:24> D.22284;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.22262 = tdef->base;
      if (D.22262 == 0B) goto <D.22263>; else goto <D.22264>;
      <D.22263>:
      D.22265 = 0;
      return D.22265;
      <D.22264>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22266 = index + 1;
      D.22267 = (int) D.22266;
      loc.idx = D.22267;
      D.22262 = tdef->base;
      D.22268 = tdef->rows;
      D.22269 = (long unsigned int) D.22268;
      D.22270 = tdef->row_size;
      D.22271 = (long unsigned int) D.22270;
      D.22272 = mono_binary_search (&loc, D.22262, D.22269, D.22271, table_locator);
      if (D.22272 == 0B) goto <D.22273>; else goto <D.22274>;
      <D.22273>:
      D.22265 = 0;
      return D.22265;
      <D.22274>:
      D.22275 = loc.result;
      D.22276 = (int) D.22275;
      start = mono_metadata_decode_row_col (tdef, D.22276, 1);
      D.22275 = loc.result;
      D.22277 = D.22275 + 1;
      D.22268 = tdef->rows;
      D.22278 = (unsigned int) D.22268;
      if (D.22277 < D.22278) goto <D.22279>; else goto <D.22280>;
      <D.22279>:
      D.22275 = loc.result;
      D.22277 = D.22275 + 1;
      D.22281 = (int) D.22277;
      D.22282 = mono_metadata_decode_row_col (tdef, D.22281, 1);
      end = D.22282 + 4294967295;
      goto <D.22283>;
      <D.22280>:
      D.22284 = meta->tables[20].rows;
      end = (guint32) D.22284;
      <D.22283>:
      *end_idx = end;
      D.22265 = start + 4294967295;
      return D.22265;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22287;
  uint32_t D.22290;
  long unsigned int D.22291;
  long unsigned int D.22292;
  unsigned int D.22295;
  int D.22296;
  unsigned int D.22297;
  unsigned int D.22298;
  int D.22299;
  <unnamed-unsigned:24> D.22300;
  long unsigned int D.22301;
  unsigned char D.22302;
  long unsigned int D.22303;
  void * D.22304;
  int D.22307;
  unsigned int D.22308;
  unsigned int D.22309;
  int D.22310;
  unsigned int D.22311;
  int end.124;
  unsigned int D.22314;
  unsigned int D.22315;
  unsigned int D.22317;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22287 = msemt->base;
      if (D.22287 == 0B) goto <D.22288>; else goto <D.22289>;
      <D.22288>:
      D.22290 = 0;
      return D.22290;
      <D.22289>:
      D.22291 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22292 = D.22291 & 67108864;
      if (D.22292 != 0) goto <D.22293>; else goto <D.22294>;
      <D.22293>:
      D.22295 = index + 1;
      D.22296 = (int) D.22295;
      D.22297 = search_ptr_table (meta, 19, D.22296);
      index = D.22297 + 4294967295;
      <D.22294>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22295 = index + 1;
      D.22298 = D.22295 << 1;
      D.22299 = (int) D.22298;
      loc.idx = D.22299;
      D.22287 = msemt->base;
      D.22300 = msemt->rows;
      D.22301 = (long unsigned int) D.22300;
      D.22302 = msemt->row_size;
      D.22303 = (long unsigned int) D.22302;
      D.22304 = mono_binary_search (&loc, D.22287, D.22301, D.22303, table_locator);
      if (D.22304 == 0B) goto <D.22305>; else goto <D.22306>;
      <D.22305>:
      D.22290 = 0;
      return D.22290;
      <D.22306>:
      start = loc.result;
      goto <D.19077>;
      <D.19076>:
      D.22307 = loc.idx;
      D.22308 = (unsigned int) D.22307;
      D.22309 = start + 4294967295;
      D.22310 = (int) D.22309;
      D.22311 = mono_metadata_decode_row_col (msemt, D.22310, 2);
      if (D.22308 == D.22311) goto <D.22312>; else goto <D.19075>;
      <D.22312>:
      start = start + 4294967295;
      <D.19077>:
      if (start != 0) goto <D.19076>; else goto <D.19075>;
      <D.19075>:
      end = start + 1;
      goto <D.19080>;
      <D.19079>:
      end.124 = (int) end;
      mono_metadata_decode_row (msemt, end.124, &cols, 3);
      D.22314 = cols[2];
      D.22307 = loc.idx;
      D.22315 = (unsigned int) D.22307;
      if (D.22314 != D.22315) goto <D.19078>; else goto <D.22316>;
      <D.22316>:
      end = end + 1;
      <D.19080>:
      D.22300 = msemt->rows;
      D.22317 = (unsigned int) D.22300;
      if (D.22317 > end) goto <D.19079>; else goto <D.19078>;
      <D.19078>:
      *end_idx = end;
      D.22290 = start;
      return D.22290;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22320;
  uint32_t D.22323;
  unsigned int D.22324;
  int D.22325;
  <unnamed-unsigned:24> D.22326;
  long unsigned int D.22327;
  unsigned char D.22328;
  long unsigned int D.22329;
  void * D.22330;
  unsigned int D.22333;
  int D.22334;
  unsigned int D.22335;
  unsigned int D.22336;
  int D.22339;
  unsigned int D.22340;
  <unnamed-unsigned:24> D.22342;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[21];
      *end_idx = 0;
      D.22320 = tdef->base;
      if (D.22320 == 0B) goto <D.22321>; else goto <D.22322>;
      <D.22321>:
      D.22323 = 0;
      return D.22323;
      <D.22322>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22324 = index + 1;
      D.22325 = (int) D.22324;
      loc.idx = D.22325;
      D.22320 = tdef->base;
      D.22326 = tdef->rows;
      D.22327 = (long unsigned int) D.22326;
      D.22328 = tdef->row_size;
      D.22329 = (long unsigned int) D.22328;
      D.22330 = mono_binary_search (&loc, D.22320, D.22327, D.22329, table_locator);
      if (D.22330 == 0B) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      D.22323 = 0;
      return D.22323;
      <D.22332>:
      D.22333 = loc.result;
      D.22334 = (int) D.22333;
      start = mono_metadata_decode_row_col (tdef, D.22334, 1);
      D.22333 = loc.result;
      D.22335 = D.22333 + 1;
      D.22326 = tdef->rows;
      D.22336 = (unsigned int) D.22326;
      if (D.22335 < D.22336) goto <D.22337>; else goto <D.22338>;
      <D.22337>:
      D.22333 = loc.result;
      D.22335 = D.22333 + 1;
      D.22339 = (int) D.22335;
      D.22340 = mono_metadata_decode_row_col (tdef, D.22339, 1);
      end = D.22340 + 4294967295;
      goto <D.22341>;
      <D.22338>:
      D.22342 = meta->tables[23].rows;
      end = (guint32) D.22342;
      <D.22341>:
      *end_idx = end;
      D.22323 = start + 4294967295;
      return D.22323;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22345;
  uint32_t D.22348;
  long unsigned int D.22349;
  long unsigned int D.22350;
  unsigned int D.22353;
  int D.22354;
  unsigned int D.22355;
  unsigned int D.22356;
  unsigned int D.22357;
  int D.22358;
  <unnamed-unsigned:24> D.22359;
  long unsigned int D.22360;
  unsigned char D.22361;
  long unsigned int D.22362;
  void * D.22363;
  int D.22366;
  unsigned int D.22367;
  unsigned int D.22368;
  int D.22369;
  unsigned int D.22370;
  int end.125;
  unsigned int D.22373;
  unsigned int D.22374;
  unsigned int D.22376;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22345 = msemt->base;
      if (D.22345 == 0B) goto <D.22346>; else goto <D.22347>;
      <D.22346>:
      D.22348 = 0;
      return D.22348;
      <D.22347>:
      D.22349 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22350 = D.22349 & 67108864;
      if (D.22350 != 0) goto <D.22351>; else goto <D.22352>;
      <D.22351>:
      D.22353 = index + 1;
      D.22354 = (int) D.22353;
      D.22355 = search_ptr_table (meta, 22, D.22354);
      index = D.22355 + 4294967295;
      <D.22352>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22353 = index + 1;
      D.22356 = D.22353 << 1;
      D.22357 = D.22356 | 1;
      D.22358 = (int) D.22357;
      loc.idx = D.22358;
      D.22345 = msemt->base;
      D.22359 = msemt->rows;
      D.22360 = (long unsigned int) D.22359;
      D.22361 = msemt->row_size;
      D.22362 = (long unsigned int) D.22361;
      D.22363 = mono_binary_search (&loc, D.22345, D.22360, D.22362, table_locator);
      if (D.22363 == 0B) goto <D.22364>; else goto <D.22365>;
      <D.22364>:
      D.22348 = 0;
      return D.22348;
      <D.22365>:
      start = loc.result;
      goto <D.19102>;
      <D.19101>:
      D.22366 = loc.idx;
      D.22367 = (unsigned int) D.22366;
      D.22368 = start + 4294967295;
      D.22369 = (int) D.22368;
      D.22370 = mono_metadata_decode_row_col (msemt, D.22369, 2);
      if (D.22367 == D.22370) goto <D.22371>; else goto <D.19100>;
      <D.22371>:
      start = start + 4294967295;
      <D.19102>:
      if (start != 0) goto <D.19101>; else goto <D.19100>;
      <D.19100>:
      end = start + 1;
      goto <D.19105>;
      <D.19104>:
      end.125 = (int) end;
      mono_metadata_decode_row (msemt, end.125, &cols, 3);
      D.22373 = cols[2];
      D.22366 = loc.idx;
      D.22374 = (unsigned int) D.22366;
      if (D.22373 != D.22374) goto <D.19103>; else goto <D.22375>;
      <D.22375>:
      end = end + 1;
      <D.19105>:
      D.22359 = msemt->rows;
      D.22376 = (unsigned int) D.22359;
      if (D.22376 > end) goto <D.19104>; else goto <D.19103>;
      <D.19103>:
      *end_idx = end;
      D.22348 = start;
      return D.22348;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.22379;
  uint32_t D.22382;
  unsigned int D.22383;
  unsigned int D.22384;
  unsigned int D.22385;
  int D.22386;
  <unnamed-unsigned:24> D.22387;
  long unsigned int D.22388;
  unsigned char D.22389;
  long unsigned int D.22390;
  void * D.22391;
  unsigned int D.22394;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.22379 = tdef->base;
      if (D.22379 == 0B) goto <D.22380>; else goto <D.22381>;
      <D.22380>:
      D.22382 = 0;
      return D.22382;
      <D.22381>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.22383 = method_idx + 1;
      D.22384 = D.22383 << 1;
      D.22385 = D.22384 | 1;
      D.22386 = (int) D.22385;
      loc.idx = D.22386;
      D.22379 = tdef->base;
      D.22387 = tdef->rows;
      D.22388 = (long unsigned int) D.22387;
      D.22389 = tdef->row_size;
      D.22390 = (long unsigned int) D.22389;
      D.22391 = mono_binary_search (&loc, D.22379, D.22388, D.22390, table_locator);
      if (D.22391 == 0B) goto <D.22392>; else goto <D.22393>;
      <D.22392>:
      D.22382 = 0;
      return D.22382;
      <D.22393>:
      D.22394 = loc.result;
      D.22382 = D.22394 + 1;
      return D.22382;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  struct GHashTable * D.22397;
  long unsigned int D.22398;
  const void * D.22399;
  struct MonoType * D.22402;
  unsigned int D.22403;
  int D.22404;
  unsigned int D.22405;
  const char * ptr.126;
  int D.22407;
  const char * ptr.127;
  void * D.22415;
  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.22397 = image->typespec_cache;
      D.22398 = (long unsigned int) type_spec;
      D.22399 = (const void *) D.22398;
      type = monoeg_g_hash_table_lookup (D.22397, D.22399);
      if (type != 0B) goto <D.22400>; else goto <D.22401>;
      <D.22400>:
      mono_loader_unlock ();
      D.22402 = type;
      return D.22402;
      <D.22401>:
      t = &image->tables[27];
      D.22403 = idx + 4294967295;
      D.22404 = (int) D.22403;
      mono_metadata_decode_row (t, D.22404, &cols, 1);
      D.22405 = cols[0];
      ptr.126 = mono_metadata_blob_heap (image, D.22405);
      ptr = ptr.126;
      D.22405 = cols[0];
      D.22407 = mono_verifier_verify_typespec_signature (image, D.22405, type_spec, 0B);
      if (D.22407 == 0) goto <D.22408>; else goto <D.22409>;
      <D.22408>:
      mono_loader_unlock ();
      D.22402 = 0B;
      return D.22402;
      <D.22409>:
      ptr.127 = ptr;
      len = mono_metadata_decode_value (ptr.127, &ptr);
      ptr.127 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.127, &ptr);
      if (type == 0B) goto <D.22411>; else goto <D.22412>;
      <D.22411>:
      mono_loader_unlock ();
      D.22402 = 0B;
      return D.22402;
      <D.22412>:
      D.22397 = image->typespec_cache;
      D.22398 = (long unsigned int) type_spec;
      D.22399 = (const void *) D.22398;
      type2 = monoeg_g_hash_table_lookup (D.22397, D.22399);
      if (type2 != 0B) goto <D.22413>; else goto <D.22414>;
      <D.22413>:
      mono_loader_unlock ();
      D.22402 = type2;
      return D.22402;
      <D.22414>:
      type2 = mono_metadata_type_dup (image, type);
      D.22397 = image->typespec_cache;
      D.22398 = (long unsigned int) type_spec;
      D.22415 = (void *) D.22398;
      monoeg_g_hash_table_insert_replace (D.22397, D.22415, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.22402 = type2;
      return D.22402;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


__attribute__((visibility ("hidden")))
mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.128;
  unsigned int D.22424;
  const char * ptr.129;
  const char * ptr.130;
  char D.22427;
  <unnamed type> D.22428;
  <unnamed type> D.22429;
  long int ptr.131;
  long int start.132;
  long int D.22434;
  long int D.22435;
  const char * ptr.133;
  const char * ptr.134;
  char D.22440;
  <unnamed type> D.22441;
  unsigned int D.22444;
  short int D.22445;
  unsigned int D.22448;
  int D.22449;
  unsigned int D.22452;
  short int D.22453;
  unsigned int D.22458;
  int D.22459;
  unsigned int D.22464;
  int D.22465;
  unsigned int D.22468;
  sizetype D.22469;
  const char * ptr.135;
  unsigned int D.22471;
  unsigned int D.22472;
  unsigned int len.136;
  char * D.22474;
  unsigned int D.22475;
  char * D.22476;
  const char * ptr.137;
  const char * ptr.138;
  char D.22483;
  <unnamed type> D.22484;
  const char * ptr.139;
  const char * ptr.140;
  char D.22489;
  int D.22490;
  struct MonoMarshalSpec * D.22491;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.22420>; else goto <D.22421>;
  <D.22420>:
  res = mono_image_alloc0 (image, 24);
  goto <D.22422>;
  <D.22421>:
  res = monoeg_malloc0 (24);
  <D.22422>:
  ptr.128 = ptr;
  D.22424 = mono_metadata_decode_value (ptr.128, &ptr);
  len = (int) D.22424;
  ptr.128 = ptr;
  ptr.129 = ptr.128;
  ptr.130 = ptr.129 + 1;
  ptr = ptr.130;
  D.22427 = *ptr.129;
  D.22428 = (<unnamed type>) D.22427;
  res->native = D.22428;
  D.22429 = res->native;
  if (D.22429 == 42) goto <D.22430>; else goto <D.22431>;
  <D.22430>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22436>; else goto <D.22437>;
  <D.22436>:
  ptr.128 = ptr;
  ptr.133 = ptr.128;
  ptr.134 = ptr.133 + 1;
  ptr = ptr.134;
  D.22440 = *ptr.133;
  D.22441 = (<unnamed type>) D.22440;
  res->data.array_data.elem_type = D.22441;
  <D.22437>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22442>; else goto <D.22443>;
  <D.22442>:
  ptr.128 = ptr;
  D.22444 = mono_metadata_decode_value (ptr.128, &ptr);
  D.22445 = (short int) D.22444;
  res->data.array_data.param_num = D.22445;
  <D.22443>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22446>; else goto <D.22447>;
  <D.22446>:
  ptr.128 = ptr;
  D.22448 = mono_metadata_decode_value (ptr.128, &ptr);
  D.22449 = (int) D.22448;
  res->data.array_data.num_elem = D.22449;
  <D.22447>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22450>; else goto <D.22451>;
  <D.22450>:
  ptr.128 = ptr;
  D.22452 = mono_metadata_decode_value (ptr.128, &ptr);
  D.22453 = (short int) D.22452;
  res->data.array_data.elem_mult = D.22453;
  <D.22451>:
  <D.22431>:
  D.22429 = res->native;
  if (D.22429 == 23) goto <D.22454>; else goto <D.22455>;
  <D.22454>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22456>; else goto <D.22457>;
  <D.22456>:
  ptr.128 = ptr;
  D.22458 = mono_metadata_decode_value (ptr.128, &ptr);
  D.22459 = (int) D.22458;
  res->data.array_data.num_elem = D.22459;
  <D.22457>:
  <D.22455>:
  D.22429 = res->native;
  if (D.22429 == 30) goto <D.22460>; else goto <D.22461>;
  <D.22460>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22462>; else goto <D.22463>;
  <D.22462>:
  ptr.128 = ptr;
  D.22464 = mono_metadata_decode_value (ptr.128, &ptr);
  D.22465 = (int) D.22464;
  res->data.array_data.num_elem = D.22465;
  <D.22463>:
  <D.22461>:
  D.22429 = res->native;
  if (D.22429 == 44) goto <D.22466>; else goto <D.22467>;
  <D.22466>:
  ptr.128 = ptr;
  D.22468 = mono_metadata_decode_value (ptr.128, &ptr);
  len = (int) D.22468;
  ptr.128 = ptr;
  D.22469 = (sizetype) len;
  ptr.135 = ptr.128 + D.22469;
  ptr = ptr.135;
  ptr.128 = ptr;
  D.22471 = mono_metadata_decode_value (ptr.128, &ptr);
  len = (int) D.22471;
  ptr.128 = ptr;
  D.22469 = (sizetype) len;
  ptr.135 = ptr.128 + D.22469;
  ptr = ptr.135;
  ptr.128 = ptr;
  D.22472 = mono_metadata_decode_value (ptr.128, &ptr);
  len = (int) D.22472;
  ptr.128 = ptr;
  len.136 = (unsigned int) len;
  D.22474 = mono_image_strndup (image, ptr.128, len.136);
  res->data.custom_data.custom_name = D.22474;
  ptr.128 = ptr;
  D.22469 = (sizetype) len;
  ptr.135 = ptr.128 + D.22469;
  ptr = ptr.135;
  ptr.128 = ptr;
  D.22475 = mono_metadata_decode_value (ptr.128, &ptr);
  len = (int) D.22475;
  ptr.128 = ptr;
  len.136 = (unsigned int) len;
  D.22476 = mono_image_strndup (image, ptr.128, len.136);
  res->data.custom_data.cookie = D.22476;
  <D.22467>:
  D.22429 = res->native;
  if (D.22429 == 29) goto <D.22477>; else goto <D.22478>;
  <D.22477>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22479>; else goto <D.22480>;
  <D.22479>:
  ptr.128 = ptr;
  ptr.137 = ptr.128;
  ptr.138 = ptr.137 + 1;
  ptr = ptr.138;
  D.22483 = *ptr.137;
  D.22484 = (<unnamed type>) D.22483;
  res->data.safearray_data.elem_type = D.22484;
  <D.22480>:
  ptr.128 = ptr;
  ptr.131 = (long int) ptr.128;
  start.132 = (long int) start;
  D.22434 = ptr.131 - start.132;
  D.22435 = (long int) len;
  if (D.22434 <= D.22435) goto <D.22485>; else goto <D.22486>;
  <D.22485>:
  ptr.128 = ptr;
  ptr.139 = ptr.128;
  ptr.140 = ptr.139 + 1;
  ptr = ptr.140;
  D.22489 = *ptr.139;
  D.22490 = (int) D.22489;
  res->data.safearray_data.num_elem = D.22490;
  <D.22486>:
  <D.22478>:
  D.22491 = res;
  return D.22491;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.22495;
  long unsigned int D.22496;
  unsigned int D.22497;
  long unsigned int D.22498;
  sizetype D.22499;
  char * D.22500;
  char * res;

  if (image == 0B) goto <D.22493>; else goto <D.22494>;
  <D.22493>:
  D.22496 = (long unsigned int) len;
  D.22495 = monoeg_g_strndup (data, D.22496);
  return D.22495;
  <D.22494>:
  D.22497 = len + 1;
  res = mono_image_alloc (image, D.22497);
  D.22498 = (long unsigned int) len;
  memcpy (res, data, D.22498);
  D.22499 = (sizetype) len;
  D.22500 = res + D.22499;
  *D.22500 = 0;
  D.22495 = res;
  return D.22495;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.22502;
  char * D.22505;
  char * D.22506;

  D.22502 = spec->native;
  if (D.22502 == 44) goto <D.22503>; else goto <D.22504>;
  <D.22503>:
  D.22505 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.22505);
  D.22506 = spec->data.custom_data.cookie;
  monoeg_g_free (D.22506);
  <D.22504>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.22507;
  long unsigned int D.22510;
  long unsigned int D.22511;
  uint32_t D.22514;
  <unnamed type> D.22517;
  uint32_t iftmp.141;
  struct MonoClass * D.22531;
  long unsigned int D.22532;
  long unsigned int D.22533;
  struct MonoType * D.22536;
  unsigned char D.22537;
  struct MonoClass * D.22538;
  struct MonoClass * D.22545;
  struct MonoClass * D.22546;
  struct MonoClass * D.22555;
  struct MonoClass * D.22557;
  struct MonoClass * D.22559;
  struct MonoClass * D.22566;
  struct MonoGenericClass * D.22571;
  struct MonoClass * D.22572;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.22507 = type->type;
      t = (int) D.22507;
      if (conv == 0B) goto <D.22508>; else goto <D.22509>;
      <D.22508>:
      conv = &dummy_conv;
      <D.22509>:
      *conv = 0;
      D.22510 = BIT_FIELD_REF <*type, 64, 64>;
      D.22511 = D.22510 & 8589934592;
      if (D.22511 != 0) goto <D.22512>; else goto <D.22513>;
      <D.22512>:
      D.22514 = 32;
      return D.22514;
      <D.22513>:
      handle_enum:
      switch (t) <default: <D.19209>, case 2: <D.19153>, case 3: <D.19160>, case 4: <D.19165>, case 5: <D.19166>, case 6: <D.19167>, case 7: <D.19168>, case 8: <D.19169>, case 9: <D.19170>, case 10: <D.19171>, case 11: <D.19172>, case 12: <D.19173>, case 13: <D.19174>, case 14: <D.19175>, case 15: <D.19185>, case 17: <D.19186>, case 18: <D.19196>, case 20: <D.19188>, case 21: <D.19207>, case 22: <D.19208>, case 24: <D.19194>, case 25: <D.19195>, case 27: <D.19206>, case 28: <D.19197>, case 29: <D.19187>>
      <D.19153>:
      if (mspec != 0B) goto <D.22515>; else goto <D.22516>;
      <D.22515>:
      D.22517 = mspec->native;
      switch (D.22517) <default: <D.19158>, case 2: <D.19155>, case 3: <D.19156>, case 4: <D.19157>, case 37: <D.19154>>
      <D.19154>:
      *conv = 1;
      D.22514 = 37;
      return D.22514;
      <D.19155>:
      *conv = 2;
      D.22514 = 2;
      return D.22514;
      <D.19156>:
      <D.19157>:
      D.22514 = mspec->native;
      return D.22514;
      <D.19158>:
      D.22517 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.22517);
      <D.19159>:
      goto <D.19159>;
      <D.22516>:
      *conv = 2;
      D.22514 = 2;
      return D.22514;
      <D.19160>:
      if (mspec != 0B) goto <D.22518>; else goto <D.22519>;
      <D.22518>:
      D.22517 = mspec->native;
      switch (D.22517) <default: <D.19163>, case 4: <D.19162>, case 6: <D.19161>>
      <D.19161>:
      <D.19162>:
      D.22514 = mspec->native;
      return D.22514;
      <D.19163>:
      D.22517 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.22517);
      <D.19164>:
      goto <D.19164>;
      <D.22519>:
      if (unicode != 0) goto <D.22521>; else goto <D.22522>;
      <D.22521>:
      iftmp.141 = 6;
      goto <D.22523>;
      <D.22522>:
      iftmp.141 = 4;
      <D.22523>:
      D.22514 = iftmp.141;
      return D.22514;
      <D.19165>:
      D.22514 = 3;
      return D.22514;
      <D.19166>:
      D.22514 = 4;
      return D.22514;
      <D.19167>:
      D.22514 = 5;
      return D.22514;
      <D.19168>:
      D.22514 = 6;
      return D.22514;
      <D.19169>:
      D.22514 = 7;
      return D.22514;
      <D.19170>:
      D.22514 = 8;
      return D.22514;
      <D.19171>:
      D.22514 = 9;
      return D.22514;
      <D.19172>:
      D.22514 = 10;
      return D.22514;
      <D.19173>:
      D.22514 = 11;
      return D.22514;
      <D.19174>:
      D.22514 = 12;
      return D.22514;
      <D.19175>:
      if (mspec != 0B) goto <D.22524>; else goto <D.22525>;
      <D.22524>:
      D.22517 = mspec->native;
      switch (D.22517) <default: <D.19183>, case 19: <D.19176>, case 20: <D.19177>, case 21: <D.19178>, case 22: <D.19179>, case 23: <D.19182>, case 35: <D.19180>, case 36: <D.19181>>
      <D.19176>:
      *conv = 3;
      D.22514 = 19;
      return D.22514;
      <D.19177>:
      *conv = 4;
      D.22514 = 20;
      return D.22514;
      <D.19178>:
      *conv = 7;
      D.22514 = 21;
      return D.22514;
      <D.19179>:
      *conv = 9;
      D.22514 = 22;
      return D.22514;
      <D.19180>:
      *conv = 10;
      D.22514 = 35;
      return D.22514;
      <D.19181>:
      *conv = 11;
      D.22514 = 36;
      return D.22514;
      <D.19182>:
      if (unicode != 0) goto <D.22526>; else goto <D.22527>;
      <D.22526>:
      *conv = 13;
      goto <D.22528>;
      <D.22527>:
      *conv = 12;
      <D.22528>:
      D.22514 = 23;
      return D.22514;
      <D.19183>:
      D.22517 = 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.22517);
      <D.19184>:
      goto <D.19184>;
      <D.22525>:
      if (unicode != 0) goto <D.22529>; else goto <D.22530>;
      <D.22529>:
      *conv = 7;
      D.22514 = 21;
      return D.22514;
      <D.22530>:
      *conv = 4;
      D.22514 = 20;
      return D.22514;
      <D.19185>:
      D.22514 = 32;
      return D.22514;
      <D.19186>:
      D.22531 = type->data.klass;
      D.22532 = BIT_FIELD_REF <*D.22531, 64, 256>;
      D.22533 = D.22532 & 576460752303423488;
      if (D.22533 != 0) goto <D.22534>; else goto <D.22535>;
      <D.22534>:
      D.22531 = type->data.klass;
      D.22536 = mono_class_enum_basetype (D.22531);
      D.22537 = D.22536->type;
      t = (int) D.22537;
      goto handle_enum;
      <D.22535>:
      D.22531 = type->data.klass;
      D.22538 = mono_defaults.handleref_class;
      if (D.22531 == D.22538) goto <D.22539>; else goto <D.22540>;
      <D.22539>:
      *conv = 34;
      D.22514 = 31;
      return D.22514;
      <D.22540>:
      D.22514 = 27;
      return D.22514;
      <D.19187>:
      <D.19188>:
      if (mspec != 0B) goto <D.22541>; else goto <D.22542>;
      <D.22541>:
      D.22517 = mspec->native;
      switch (D.22517) <default: <D.19192>, case 29: <D.19190>, case 30: <D.19189>, case 42: <D.19191>>
      <D.19189>:
      D.22531 = type->data.klass;
      D.22545 = D.22531->element_class;
      D.22546 = mono_defaults.char_class;
      if (D.22545 == D.22546) goto <D.22547>; else goto <D.22543>;
      <D.22547>:
      if (unicode == 0) goto <D.22548>; else goto <D.22543>;
      <D.22548>:
      *conv = 21;
      goto <D.22544>;
      <D.22543>:
      *conv = 20;
      <D.22544>:
      D.22514 = 30;
      return D.22514;
      <D.19190>:
      *conv = 22;
      D.22514 = 29;
      return D.22514;
      <D.19191>:
      *conv = 23;
      D.22514 = 42;
      return D.22514;
      <D.19192>:
      D.22517 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.22517);
      <D.19193>:
      goto <D.19193>;
      <D.22542>:
      *conv = 23;
      D.22514 = 42;
      return D.22514;
      <D.19194>:
      D.22514 = 31;
      return D.22514;
      <D.19195>:
      D.22514 = 32;
      return D.22514;
      <D.19196>:
      <D.19197>:
      if (mspec != 0B) goto <D.22549>; else goto <D.22550>;
      <D.22549>:
      D.22517 = mspec->native;
      switch (D.22517) <default: <D.19204>, case 25: <D.19202>, case 26: <D.19201>, case 27: <D.19198>, case 28: <D.19200>, case 38: <D.19203>, case 44: <D.19199>>
      <D.19198>:
      D.22514 = 27;
      return D.22514;
      <D.19199>:
      D.22514 = 44;
      return D.22514;
      <D.19200>:
      *conv = 25;
      D.22514 = 28;
      return D.22514;
      <D.19201>:
      *conv = 26;
      D.22514 = 26;
      return D.22514;
      <D.19202>:
      *conv = 27;
      D.22514 = 25;
      return D.22514;
      <D.19203>:
      if (t == 18) goto <D.22553>; else goto <D.22554>;
      <D.22553>:
      D.22531 = type->data.klass;
      D.22555 = mono_defaults.multicastdelegate_class;
      if (D.22531 == D.22555) goto <D.22551>; else goto <D.22556>;
      <D.22556>:
      D.22531 = type->data.klass;
      D.22557 = mono_defaults.delegate_class;
      if (D.22531 == D.22557) goto <D.22551>; else goto <D.22558>;
      <D.22558>:
      D.22531 = type->data.klass;
      D.22559 = D.22531->parent;
      D.22555 = mono_defaults.multicastdelegate_class;
      if (D.22559 == D.22555) goto <D.22551>; else goto <D.22552>;
      <D.22551>:
      *conv = 29;
      D.22514 = 38;
      return D.22514;
      <D.22552>:
      <D.22554>:
      <D.19204>:
      D.22517 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.22517);
      <D.19205>:
      goto <D.19205>;
      <D.22550>:
      if (t == 18) goto <D.22562>; else goto <D.22563>;
      <D.22562>:
      D.22531 = type->data.klass;
      D.22555 = mono_defaults.multicastdelegate_class;
      if (D.22531 == D.22555) goto <D.22560>; else goto <D.22564>;
      <D.22564>:
      D.22531 = type->data.klass;
      D.22557 = mono_defaults.delegate_class;
      if (D.22531 == D.22557) goto <D.22560>; else goto <D.22565>;
      <D.22565>:
      D.22531 = type->data.klass;
      D.22559 = D.22531->parent;
      D.22555 = mono_defaults.multicastdelegate_class;
      if (D.22559 == D.22555) goto <D.22560>; else goto <D.22561>;
      <D.22560>:
      *conv = 29;
      D.22514 = 38;
      return D.22514;
      <D.22561>:
      <D.22563>:
      D.22566 = mono_defaults.safehandle_class;
      if (D.22566 != 0B) goto <D.22567>; else goto <D.22568>;
      <D.22567>:
      D.22531 = type->data.klass;
      D.22566 = mono_defaults.safehandle_class;
      if (D.22531 == D.22566) goto <D.22569>; else goto <D.22570>;
      <D.22569>:
      *conv = 33;
      D.22514 = 31;
      return D.22514;
      <D.22570>:
      <D.22568>:
      *conv = 28;
      D.22514 = 27;
      return D.22514;
      <D.19206>:
      D.22514 = 38;
      return D.22514;
      <D.19207>:
      D.22571 = type->data.generic_class;
      D.22572 = D.22571->container_class;
      type = &D.22572->byval_arg;
      D.22507 = type->type;
      t = (int) D.22507;
      goto handle_enum;
      <D.19208>:
      <D.19209>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.19210>:
      goto <D.19210>;
      D.22514 = 80;
      return D.22514;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.22575;
  const char * D.22578;
  unsigned int D.22579;
  unsigned int D.22580;
  _Bool D.22581;
  int D.22582;
  unsigned int D.22583;
  unsigned int D.22584;
  int D.22585;
  <unnamed-unsigned:24> D.22586;
  long unsigned int D.22587;
  unsigned char D.22588;
  long unsigned int D.22589;
  void * D.22590;
  unsigned int D.22593;
  int D.22594;
  unsigned int D.22595;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.22575 = tdef->base;
      if (D.22575 == 0B) goto <D.22576>; else goto <D.22577>;
      <D.22576>:
      D.22578 = 0B;
      return D.22578;
      <D.22577>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22579 = idx + 1;
      D.22580 = D.22579 << 1;
      D.22581 = is_field == 0;
      D.22582 = (int) D.22581;
      D.22583 = (unsigned int) D.22582;
      D.22584 = D.22580 | D.22583;
      D.22585 = (int) D.22584;
      loc.idx = D.22585;
      D.22575 = tdef->base;
      D.22586 = tdef->rows;
      D.22587 = (long unsigned int) D.22586;
      D.22588 = tdef->row_size;
      D.22589 = (long unsigned int) D.22588;
      D.22590 = mono_binary_search (&loc, D.22575, D.22587, D.22589, table_locator);
      if (D.22590 == 0B) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      D.22578 = 0B;
      return D.22578;
      <D.22592>:
      D.22593 = loc.result;
      D.22594 = (int) D.22593;
      D.22595 = mono_metadata_decode_row_col (tdef, D.22594, 1);
      D.22578 = mono_metadata_blob_heap (meta, D.22595);
      return D.22578;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.22598;
  struct MonoMethod * D.22599;
  unsigned int D.22600;
  unsigned int D.22601;
  guint32 idx;

  idx = tok >> 1;
  D.22598 = tok & 1;
  switch (D.22598) <default: <D.22602>, case 0: <D.19224>, case 1: <D.19225>>
  <D.19224>:
  D.22600 = idx | 100663296;
  D.22599 = mono_get_method_full (m, D.22600, 0B, context);
  return D.22599;
  <D.19225>:
  D.22601 = idx | 167772160;
  D.22599 = mono_get_method_full (m, D.22601, 0B, context);
  return D.22599;
  <D.22602>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.22599 = 0B;
  return D.22599;
}


__attribute__((visibility ("hidden")))
mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.22606;
  gboolean D.22609;
  int type_token.142;
  int D.22611;
  <unnamed-unsigned:24> D.22612;
  long unsigned int D.22613;
  unsigned char D.22614;
  long unsigned int D.22615;
  void * D.22616;
  int D.22619;
  unsigned int D.22620;
  unsigned int D.22621;
  int D.22622;
  unsigned int D.22623;
  int end.143;
  unsigned int D.22626;
  unsigned int D.22628;
  unsigned int D.22629;
  int D.22630;
  long unsigned int D.22631;
  long unsigned int D.22632;
  unsigned int i.144;
  unsigned int D.22634;
  int D.22635;
  int D.22638;
  unsigned int D.22639;
  int D.22642;
  long unsigned int D.22643;
  long unsigned int D.22644;
  struct MonoMethod * * D.22645;
  unsigned int D.22646;
  sizetype D.22649;
  sizetype D.22650;
  sizetype D.22651;
  struct MonoMethod * * D.22652;
  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.22604>; else goto <D.22605>;
      <D.22604>:
      *num_overrides = 0;
      <D.22605>:
      D.22606 = tdef->base;
      if (D.22606 == 0B) goto <D.22607>; else goto <D.22608>;
      <D.22607>:
      D.22609 = 1;
      return D.22609;
      <D.22608>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.142 = (int) type_token;
      D.22611 = type_token.142 & 16777215;
      loc.idx = D.22611;
      D.22606 = tdef->base;
      D.22612 = tdef->rows;
      D.22613 = (long unsigned int) D.22612;
      D.22614 = tdef->row_size;
      D.22615 = (long unsigned int) D.22614;
      D.22616 = mono_binary_search (&loc, D.22606, D.22613, D.22615, table_locator);
      if (D.22616 == 0B) goto <D.22617>; else goto <D.22618>;
      <D.22617>:
      D.22609 = 1;
      return D.22609;
      <D.22618>:
      start = loc.result;
      end = start + 1;
      goto <D.19245>;
      <D.19244>:
      D.22619 = loc.idx;
      D.22620 = (unsigned int) D.22619;
      D.22621 = start + 4294967295;
      D.22622 = (int) D.22621;
      D.22623 = mono_metadata_decode_row_col (tdef, D.22622, 0);
      if (D.22620 == D.22623) goto <D.22624>; else goto <D.19243>;
      <D.22624>:
      start = start + 4294967295;
      <D.19245>:
      if (start != 0) goto <D.19244>; else goto <D.19243>;
      <D.19243>:
      goto <D.19248>;
      <D.19247>:
      D.22619 = loc.idx;
      D.22620 = (unsigned int) D.22619;
      end.143 = (int) end;
      D.22626 = mono_metadata_decode_row_col (tdef, end.143, 0);
      if (D.22620 == D.22626) goto <D.22627>; else goto <D.19246>;
      <D.22627>:
      end = end + 1;
      <D.19248>:
      D.22612 = tdef->rows;
      D.22628 = (unsigned int) D.22612;
      if (D.22628 > end) goto <D.19247>; else goto <D.19246>;
      <D.19246>:
      D.22629 = end - start;
      num = (gint32) D.22629;
      D.22630 = num * 2;
      D.22631 = (long unsigned int) D.22630;
      D.22632 = D.22631 * 8;
      result = monoeg_malloc (D.22632);
      i = 0;
      goto <D.19252>;
      <D.19251>:
      {
        struct MonoMethod * method;

        i.144 = (unsigned int) i;
        D.22634 = start + i.144;
        D.22635 = mono_verifier_verify_methodimpl_row (image, D.22634, &error);
        if (D.22635 == 0) goto <D.22636>; else goto <D.22637>;
        <D.22636>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.19250>;
        <D.22637>:
        i.144 = (unsigned int) i;
        D.22634 = start + i.144;
        D.22638 = (int) D.22634;
        mono_metadata_decode_row (tdef, D.22638, &cols, 3);
        D.22639 = cols[2];
        method = method_from_method_def_or_ref (image, D.22639, generic_context);
        if (method == 0B) goto <D.22640>; else goto <D.22641>;
        <D.22640>:
        ok = 0;
        <D.22641>:
        D.22642 = i * 2;
        D.22643 = (long unsigned int) D.22642;
        D.22644 = D.22643 * 8;
        D.22645 = result + D.22644;
        *D.22645 = method;
        D.22646 = cols[1];
        method = method_from_method_def_or_ref (image, D.22646, generic_context);
        if (method == 0B) goto <D.22647>; else goto <D.22648>;
        <D.22647>:
        ok = 0;
        <D.22648>:
        D.22642 = i * 2;
        D.22649 = (sizetype) D.22642;
        D.22650 = D.22649 + 1;
        D.22651 = D.22650 * 8;
        D.22652 = result + D.22651;
        *D.22652 = method;
      }
      i = i + 1;
      <D.19252>:
      if (i < num) goto <D.19251>; else goto <D.19250>;
      <D.19250>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.22653>; else goto <D.22654>;
      <D.22653>:
      *num_overrides = num;
      <D.22654>:
      D.22609 = ok;
      return D.22609;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.22657;
  const guint8 * D.22658;
  unsigned char D.22659;
  int D.22660;
  const guint8 * D.22661;
  unsigned char D.22662;
  int D.22663;
  const guint8 * D.22664;
  unsigned char D.22665;
  int D.22666;
  unsigned char D.22667;
  int D.22668;
  const guint8 * D.22669;
  unsigned char D.22670;
  int D.22671;
  const guint8 * D.22672;
  unsigned char D.22673;
  int D.22674;
  const guint8 * D.22675;
  unsigned char D.22676;
  int D.22677;
  const guint8 * D.22678;
  unsigned char D.22679;
  int D.22680;
  const guint8 * D.22681;
  unsigned char D.22682;
  int D.22683;
  const guint8 * D.22684;
  unsigned char D.22685;
  int D.22686;
  const guint8 * D.22687;
  unsigned char D.22688;
  int D.22689;
  const guint8 * D.22690;
  unsigned char D.22691;
  int D.22692;
  const guint8 * D.22693;
  unsigned char D.22694;
  int D.22695;
  const guint8 * D.22696;
  unsigned char D.22697;
  int D.22698;
  const guint8 * D.22699;
  unsigned char D.22700;
  int D.22701;
  const guint8 * D.22702;
  unsigned char D.22703;
  int D.22704;

  D.22658 = guid + 3;
  D.22659 = *D.22658;
  D.22660 = (int) D.22659;
  D.22661 = guid + 2;
  D.22662 = *D.22661;
  D.22663 = (int) D.22662;
  D.22664 = guid + 1;
  D.22665 = *D.22664;
  D.22666 = (int) D.22665;
  D.22667 = *guid;
  D.22668 = (int) D.22667;
  D.22669 = guid + 5;
  D.22670 = *D.22669;
  D.22671 = (int) D.22670;
  D.22672 = guid + 4;
  D.22673 = *D.22672;
  D.22674 = (int) D.22673;
  D.22675 = guid + 7;
  D.22676 = *D.22675;
  D.22677 = (int) D.22676;
  D.22678 = guid + 6;
  D.22679 = *D.22678;
  D.22680 = (int) D.22679;
  D.22681 = guid + 8;
  D.22682 = *D.22681;
  D.22683 = (int) D.22682;
  D.22684 = guid + 9;
  D.22685 = *D.22684;
  D.22686 = (int) D.22685;
  D.22687 = guid + 10;
  D.22688 = *D.22687;
  D.22689 = (int) D.22688;
  D.22690 = guid + 11;
  D.22691 = *D.22690;
  D.22692 = (int) D.22691;
  D.22693 = guid + 12;
  D.22694 = *D.22693;
  D.22695 = (int) D.22694;
  D.22696 = guid + 13;
  D.22697 = *D.22696;
  D.22698 = (int) D.22697;
  D.22699 = guid + 14;
  D.22700 = *D.22699;
  D.22701 = (int) D.22700;
  D.22702 = guid + 15;
  D.22703 = *D.22702;
  D.22704 = (int) D.22703;
  D.22657 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.22660, D.22663, D.22666, D.22668, D.22671, D.22674, D.22677, D.22680, D.22683, D.22686, D.22689, D.22692, D.22695, D.22698, D.22701, D.22704);
  return D.22657;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.22706;
  long int D.22707;
  long int D.22708;
  const char * D.22711;
  guint32 D.22714;
  unsigned int D.22715;
  unsigned int D.22722;
  unsigned int D.22723;
  unsigned int D.22724;
  unsigned int D.22725;
  int D.22726;
  <unnamed-unsigned:24> D.22727;
  long unsigned int D.22728;
  unsigned char D.22729;
  long unsigned int D.22730;
  void * D.22731;
  unsigned int D.22734;
  unsigned int D.22735;
  int D.22737;
  unsigned int D.22738;
  int D.22739;
  unsigned int D.22740;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.22706 = owner == 0B;
      D.22707 = (long int) D.22706;
      D.22708 = __builtin_expect (D.22707, 0);
      if (D.22708 != 0) goto <D.22709>; else goto <D.22710>;
      <D.22709>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.22710>:
      D.22711 = tdef->base;
      if (D.22711 == 0B) goto <D.22712>; else goto <D.22713>;
      <D.22712>:
      D.22714 = 0;
      return D.22714;
      <D.22713>:
      D.22715 = token >> 24;
      if (D.22715 == 2) goto <D.22716>; else goto <D.22717>;
      <D.22716>:
      *owner = 0;
      goto <D.22718>;
      <D.22717>:
      D.22715 = token >> 24;
      if (D.22715 == 6) goto <D.22719>; else goto <D.22720>;
      <D.22719>:
      *owner = 1;
      goto <D.22721>;
      <D.22720>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.19285>:
      goto <D.19285>;
      D.22714 = 0;
      return D.22714;
      <D.22721>:
      <D.22718>:
      D.22722 = *owner;
      D.22723 = token << 1;
      D.22724 = D.22723 & 33554430;
      D.22725 = D.22722 | D.22724;
      *owner = D.22725;
      D.22722 = *owner;
      D.22726 = (int) D.22722;
      loc.idx = D.22726;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22711 = tdef->base;
      D.22727 = tdef->rows;
      D.22728 = (long unsigned int) D.22727;
      D.22729 = tdef->row_size;
      D.22730 = (long unsigned int) D.22729;
      D.22731 = mono_binary_search (&loc, D.22711, D.22728, D.22730, table_locator);
      if (D.22731 == 0B) goto <D.22732>; else goto <D.22733>;
      <D.22732>:
      D.22714 = 0;
      return D.22714;
      <D.22733>:
      goto <D.19287>;
      <D.19286>:
      D.22734 = loc.result;
      D.22735 = D.22734 + 4294967295;
      loc.result = D.22735;
      <D.19287>:
      D.22734 = loc.result;
      if (D.22734 != 0) goto <D.22736>; else goto <D.19288>;
      <D.22736>:
      D.22734 = loc.result;
      D.22735 = D.22734 + 4294967295;
      D.22737 = (int) D.22735;
      D.22738 = mono_metadata_decode_row_col (tdef, D.22737, 2);
      D.22739 = loc.idx;
      D.22740 = (unsigned int) D.22739;
      if (D.22738 == D.22740) goto <D.19286>; else goto <D.19288>;
      <D.19288>:
      D.22734 = loc.result;
      D.22714 = D.22734 + 1;
      return D.22714;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_metadata_has_generic_params (struct MonoImage * image, guint32 token)
{
  gboolean D.22743;
  unsigned int D.22744;
  guint32 owner;

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


__attribute__((visibility ("hidden")))
mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.22749;
  unsigned int D.22750;
  int D.22751;
  struct MonoGenericParamFull * D.22752;
  long unsigned int D.22753;
  long unsigned int D.22754;
  struct MonoGenericParamFull * D.22755;
  struct MonoClass * * * D.22756;
  int D.22757;
  <unnamed-signed:31> D.22760;
  unsigned int D.22761;
  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.22747>; else goto <D.22748>;
      <D.22747>:
      D.22749 = 1;
      return D.22749;
      <D.22748>:
      i = 0;
      goto <D.19303>;
      <D.19302>:
      D.22750 = start_row + i;
      D.22751 = (int) D.22750;
      D.22752 = container->type_params;
      D.22753 = (long unsigned int) i;
      D.22754 = D.22753 * 56;
      D.22755 = D.22752 + D.22754;
      D.22756 = &D.22755->info.constraints;
      D.22757 = get_constraints (image, D.22751, D.22756, container);
      if (D.22757 == 0) goto <D.22758>; else goto <D.22759>;
      <D.22758>:
      D.22749 = 0;
      return D.22749;
      <D.22759>:
      i = i + 1;
      <D.19303>:
      D.22760 = container->type_argc;
      D.22761 = (unsigned int) D.22760;
      if (D.22761 > i) goto <D.19302>; else goto <D.19304>;
      <D.19304>:
      D.22749 = 1;
      return D.22749;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.145;
  unsigned int D.22765;
  unsigned int owner.146;
  unsigned int D.22769;
  gboolean D.22772;
  <unnamed-unsigned:24> D.22775;
  unsigned int D.22776;
  unsigned int D.22779;
  unsigned int D.22780;
  long unsigned int D.22781;
  long unsigned int D.22782;
  struct MonoClass * * D.22783;
  void * D.22784;
  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.19274>;
      <D.19273>:
      i.145 = (int) i;
      mono_metadata_decode_row (tdef, i.145, &cols, 2);
      D.22765 = cols[0];
      owner.146 = (unsigned int) owner;
      if (D.22765 == owner.146) goto <D.22767>; else goto <D.22768>;
      <D.22767>:
      D.22769 = cols[1];
      token = mono_metadata_token_from_dor (D.22769);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.22770>; else goto <D.22771>;
      <D.22770>:
      monoeg_g_slist_free (cons);
      D.22772 = 0;
      return D.22772;
      <D.22771>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.22773>;
      <D.22768>:
      if (found != 0) goto <D.19272>; else goto <D.22774>;
      <D.22774>:
      <D.22773>:
      i = i + 1;
      <D.19274>:
      D.22775 = tdef->rows;
      D.22776 = (unsigned int) D.22775;
      if (D.22776 > i) goto <D.19273>; else goto <D.19272>;
      <D.19272>:
      if (found == 0) goto <D.22777>; else goto <D.22778>;
      <D.22777>:
      D.22772 = 1;
      return D.22772;
      <D.22778>:
      D.22779 = found + 1;
      D.22780 = D.22779 * 8;
      res = mono_image_alloc0 (image, D.22780);
      i = 0;
      tmp = cons;
      goto <D.19276>;
      <D.19275>:
      D.22781 = (long unsigned int) i;
      D.22782 = D.22781 * 8;
      D.22783 = res + D.22782;
      D.22784 = tmp->data;
      *D.22783 = D.22784;
      i = i + 1;
      tmp = tmp->next;
      <D.19276>:
      if (i < found) goto <D.19275>; else goto <D.19277>;
      <D.19277>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.22772 = 1;
      return D.22772;
    }
  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.22789;
  unsigned int D.22790;
  int D.22791;
  long unsigned int D.22792;
  long unsigned int D.22793;
  unsigned int D.22794;
  long unsigned int D.22795;
  long unsigned int D.22796;
  struct MonoGenericParamFull * D.22797;
  unsigned int D.22798;
  short unsigned int D.22799;
  unsigned int D.22800;
  unsigned int D.22801;
  short unsigned int D.22802;
  unsigned int D.22803;
  const char * D.22804;
  short unsigned int D.22805;
  unsigned int D.22806;
  <unnamed-unsigned:24> D.22809;
  unsigned int D.22810;
  unsigned int D.22812;
  unsigned int owner.147;
  int n.148;
  <unnamed-signed:31> D.22815;
  unsigned int D.22816;
  void * D.22817;
  struct MonoGenericParamFull * D.22818;
  unsigned int D.22819;
  int iftmp.149;
  struct MonoGenericContainer * D.22825;
  long unsigned int D.22827;
  long unsigned int D.22828;
  _Bool D.22830;
  long int D.22831;
  long int D.22832;
  struct MonoGenericInst * iftmp.150;
  struct MonoGenericInst * D.22841;
  struct MonoGenericInst * D.22843;
  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.22787>; else goto <D.22788>;
      <D.22787>:
      D.22789 = 0B;
      return D.22789;
      <D.22788>:
      D.22790 = i + 4294967295;
      D.22791 = (int) D.22790;
      mono_metadata_decode_row (tdef, D.22791, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 56);
      container->image = image;
      <D.19324>:
      n = n + 1;
      D.22792 = (long unsigned int) n;
      D.22793 = D.22792 * 56;
      params = monoeg_realloc (params, D.22793);
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      memset (D.22797, 0, 56);
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22797->param.owner = container;
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22798 = cols[0];
      D.22799 = (short unsigned int) D.22798;
      D.22797->param.num = D.22799;
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22800 = i | 704643072;
      D.22797->info.token = D.22800;
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22801 = cols[1];
      D.22802 = (short unsigned int) D.22801;
      D.22797->info.flags = D.22802;
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22803 = cols[3];
      D.22804 = mono_metadata_string_heap (image, D.22803);
      D.22797->info.name = D.22804;
      D.22794 = n + 4294967295;
      D.22795 = (long unsigned int) D.22794;
      D.22796 = D.22795 * 56;
      D.22797 = params + D.22796;
      D.22805 = D.22797->param.num;
      D.22806 = (unsigned int) D.22805;
      D.22794 = n + 4294967295;
      if (D.22806 != D.22794) goto <D.22807>; else goto <D.22808>;
      <D.22807>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.22808>:
      i = i + 1;
      D.22809 = tdef->rows;
      D.22810 = (unsigned int) D.22809;
      if (i > D.22810) goto <D.19323>; else goto <D.22811>;
      <D.22811>:
      D.22790 = i + 4294967295;
      D.22791 = (int) D.22790;
      mono_metadata_decode_row (tdef, D.22791, &cols, 4);
      D.22812 = cols[2];
      owner.147 = owner;
      if (D.22812 == owner.147) goto <D.19324>; else goto <D.19323>;
      <D.19323>:
      n.148 = (int) n;
      D.22815 = (<unnamed-signed:31>) n.148;
      container->type_argc = D.22815;
      D.22816 = n * 56;
      D.22817 = mono_image_alloc0 (image, D.22816);
      container->type_params = D.22817;
      D.22818 = container->type_params;
      D.22792 = (long unsigned int) n;
      D.22793 = D.22792 * 56;
      memcpy (D.22818, params, D.22793);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.22819 = token >> 24;
      if (D.22819 == 6) goto <D.22820>; else goto <D.22821>;
      <D.22820>:
      container->is_method = -1;
      <D.22821>:
      D.22825 = container->parent;
      if (D.22825 != 0B) goto <D.22826>; else goto <D.22823>;
      <D.22826>:
      D.22827 = BIT_FIELD_REF <*container, 64, 256>;
      D.22828 = D.22827 & 4294967296;
      if (D.22828 == 0) goto <D.22829>; else goto <D.22823>;
      <D.22829>:
      iftmp.149 = 1;
      goto <D.22824>;
      <D.22823>:
      iftmp.149 = 0;
      <D.22824>:
      D.22830 = iftmp.149 != 0;
      D.22831 = (long int) D.22830;
      D.22832 = __builtin_expect (D.22831, 0);
      if (D.22832 != 0) goto <D.22833>; else goto <D.22834>;
      <D.22833>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.22834>:
      context = &container->context;
      D.22827 = BIT_FIELD_REF <*container, 64, 256>;
      D.22828 = D.22827 & 4294967296;
      if (D.22828 != 0) goto <D.22835>; else goto <D.22836>;
      <D.22835>:
      D.22825 = container->parent;
      if (D.22825 != 0B) goto <D.22838>; else goto <D.22839>;
      <D.22838>:
      D.22825 = container->parent;
      iftmp.150 = D.22825->context.class_inst;
      goto <D.22840>;
      <D.22839>:
      iftmp.150 = 0B;
      <D.22840>:
      context->class_inst = iftmp.150;
      D.22841 = mono_get_shared_generic_inst (container);
      context->method_inst = D.22841;
      goto <D.22842>;
      <D.22836>:
      D.22843 = mono_get_shared_generic_inst (container);
      context->class_inst = D.22843;
      <D.22842>:
      D.22789 = container;
      return D.22789;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.22846;
  long unsigned int D.22847;
  long unsigned int D.22848;
  long unsigned int D.22849;
  long unsigned int D.22850;
  long unsigned int D.22851;
  unsigned char iftmp.151;
  long unsigned int D.22853;
  long unsigned int D.22854;
  struct MonoGenericParamFull * D.22858;
  long unsigned int D.22859;
  struct MonoGenericParamFull * D.22860;
  long unsigned int D.22861;
  struct MonoType * * D.22862;
  int D.22863;
  struct MonoGenericInst * D.22864;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.22846 = container->type_argc;
  D.22847 = (long unsigned int) D.22846;
  D.22848 = D.22847 * 8;
  type_argv = monoeg_malloc0 (D.22848);
  D.22846 = container->type_argc;
  D.22847 = (long unsigned int) D.22846;
  D.22849 = D.22847 * 16;
  helper = monoeg_malloc0 (D.22849);
  i = 0;
  goto <D.19334>;
  <D.19333>:
  {
    struct MonoType * t;

    D.22850 = (long unsigned int) i;
    D.22851 = D.22850 * 16;
    t = helper + D.22851;
    D.22853 = BIT_FIELD_REF <*container, 64, 256>;
    D.22854 = D.22853 & 4294967296;
    if (D.22854 != 0) goto <D.22855>; else goto <D.22856>;
    <D.22855>:
    iftmp.151 = 30;
    goto <D.22857>;
    <D.22856>:
    iftmp.151 = 19;
    <D.22857>:
    t->type = iftmp.151;
    D.22858 = container->type_params;
    D.22850 = (long unsigned int) i;
    D.22859 = D.22850 * 56;
    D.22860 = D.22858 + D.22859;
    t->data.generic_param = D.22860;
    D.22850 = (long unsigned int) i;
    D.22861 = D.22850 * 8;
    D.22862 = type_argv + D.22861;
    *D.22862 = t;
  }
  i = i + 1;
  <D.19334>:
  D.22846 = container->type_argc;
  D.22863 = (int) D.22846;
  if (D.22863 > i) goto <D.19333>; else goto <D.19335>;
  <D.19335>:
  D.22846 = container->type_argc;
  D.22863 = (int) D.22846;
  nginst = mono_metadata_get_generic_inst (D.22863, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.22864 = nginst;
  return D.22864;
}


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

  D.22867 = type->byref;
  D.22866 = (mono_bool) D.22867;
  return D.22866;
}


mono_type_get_type (struct MonoType * type)
{
  int D.22869;
  unsigned char D.22870;

  D.22870 = type->type;
  D.22869 = (int) D.22870;
  return D.22869;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.22872;
  _Bool D.22873;
  long int D.22874;
  long int D.22875;
  struct MonoMethodSignature * D.22878;

  D.22872 = type->type;
  D.22873 = D.22872 != 27;
  D.22874 = (long int) D.22873;
  D.22875 = __builtin_expect (D.22874, 0);
  if (D.22875 != 0) goto <D.22876>; else goto <D.22877>;
  <D.22876>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.22877>:
  D.22878 = type->data.method;
  return D.22878;
}


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

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


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

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


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.22884;
  _Bool D.22885;
  long int D.22886;
  long int D.22887;
  struct MonoType * D.22890;

  D.22884 = type->type;
  D.22885 = D.22884 != 15;
  D.22886 = (long int) D.22885;
  D.22887 = __builtin_expect (D.22886, 0);
  if (D.22887 != 0) goto <D.22888>; else goto <D.22889>;
  <D.22888>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.22889>:
  D.22890 = type->data.type;
  return D.22890;
}


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

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


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.22894;
  int iftmp.152;
  long unsigned int D.22900;
  long unsigned int D.22901;
  unsigned char D.22903;
  struct MonoClass * D.22905;
  long unsigned int D.22906;
  long unsigned int D.22907;
  struct MonoGenericClass * D.22910;
  int D.22911;
  struct MonoClass * D.22913;
  long unsigned int D.22914;
  long unsigned int D.22915;

  D.22900 = BIT_FIELD_REF <*type, 64, 64>;
  D.22901 = D.22900 & 8589934592;
  if (D.22901 == 0) goto <D.22902>; else goto <D.22896>;
  <D.22902>:
  D.22903 = type->type;
  if (D.22903 == 17) goto <D.22904>; else goto <D.22897>;
  <D.22904>:
  D.22905 = type->data.klass;
  D.22906 = BIT_FIELD_REF <*D.22905, 64, 256>;
  D.22907 = D.22906 & 576460752303423488;
  if (D.22907 == 0) goto <D.22898>; else goto <D.22897>;
  <D.22897>:
  D.22903 = type->type;
  if (D.22903 == 22) goto <D.22898>; else goto <D.22908>;
  <D.22908>:
  D.22903 = type->type;
  if (D.22903 == 21) goto <D.22909>; else goto <D.22896>;
  <D.22909>:
  D.22910 = type->data.generic_class;
  D.22911 = mono_metadata_generic_class_is_valuetype (D.22910);
  if (D.22911 != 0) goto <D.22912>; else goto <D.22896>;
  <D.22912>:
  D.22910 = type->data.generic_class;
  D.22913 = D.22910->container_class;
  D.22914 = BIT_FIELD_REF <*D.22913, 64, 256>;
  D.22915 = D.22914 & 576460752303423488;
  if (D.22915 == 0) goto <D.22898>; else goto <D.22896>;
  <D.22898>:
  iftmp.152 = 1;
  goto <D.22899>;
  <D.22896>:
  iftmp.152 = 0;
  <D.22899>:
  D.22894 = iftmp.152;
  return D.22894;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.22917;
  int iftmp.153;
  long unsigned int D.22922;
  long unsigned int D.22923;

  if (type != 0B) goto <D.22921>; else goto <D.22919>;
  <D.22921>:
  D.22922 = BIT_FIELD_REF <*type, 64, 64>;
  D.22923 = D.22922 & 280384055017472;
  if (D.22923 == 1099511627776) goto <D.22924>; else goto <D.22919>;
  <D.22924>:
  iftmp.153 = 1;
  goto <D.22920>;
  <D.22919>:
  iftmp.153 = 0;
  <D.22920>:
  D.22917 = iftmp.153;
  return D.22917;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.22926;
  int iftmp.154;
  long unsigned int D.22932;
  long unsigned int D.22933;
  unsigned char D.22935;

  if (type != 0B) goto <D.22931>; else goto <D.22928>;
  <D.22931>:
  D.22932 = BIT_FIELD_REF <*type, 64, 64>;
  D.22933 = D.22932 & 8589934592;
  if (D.22933 != 0) goto <D.22929>; else goto <D.22934>;
  <D.22934>:
  D.22935 = type->type;
  if (D.22935 == 24) goto <D.22929>; else goto <D.22936>;
  <D.22936>:
  D.22935 = type->type;
  if (D.22935 == 14) goto <D.22929>; else goto <D.22937>;
  <D.22937>:
  D.22935 = type->type;
  if (D.22935 == 29) goto <D.22929>; else goto <D.22938>;
  <D.22938>:
  D.22935 = type->type;
  if (D.22935 == 18) goto <D.22929>; else goto <D.22939>;
  <D.22939>:
  D.22935 = type->type;
  if (D.22935 == 25) goto <D.22929>; else goto <D.22940>;
  <D.22940>:
  D.22935 = type->type;
  if (D.22935 == 28) goto <D.22929>; else goto <D.22941>;
  <D.22941>:
  D.22935 = type->type;
  if (D.22935 == 20) goto <D.22929>; else goto <D.22942>;
  <D.22942>:
  D.22935 = type->type;
  if (D.22935 == 15) goto <D.22929>; else goto <D.22943>;
  <D.22943>:
  D.22935 = type->type;
  if (D.22935 == 27) goto <D.22929>; else goto <D.22928>;
  <D.22929>:
  iftmp.154 = 1;
  goto <D.22930>;
  <D.22928>:
  iftmp.154 = 0;
  <D.22930>:
  D.22926 = iftmp.154;
  return D.22926;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.22945;
  int iftmp.155;
  unsigned char D.22951;
  struct MonoGenericClass * D.22958;
  int D.22959;

  if (type != 0B) goto <D.22950>; else goto <D.22947>;
  <D.22950>:
  D.22951 = type->type;
  if (D.22951 == 14) goto <D.22948>; else goto <D.22952>;
  <D.22952>:
  D.22951 = type->type;
  if (D.22951 == 29) goto <D.22948>; else goto <D.22953>;
  <D.22953>:
  D.22951 = type->type;
  if (D.22951 == 18) goto <D.22948>; else goto <D.22954>;
  <D.22954>:
  D.22951 = type->type;
  if (D.22951 == 28) goto <D.22948>; else goto <D.22955>;
  <D.22955>:
  D.22951 = type->type;
  if (D.22951 == 20) goto <D.22948>; else goto <D.22956>;
  <D.22956>:
  D.22951 = type->type;
  if (D.22951 == 21) goto <D.22957>; else goto <D.22947>;
  <D.22957>:
  D.22958 = type->data.generic_class;
  D.22959 = mono_metadata_generic_class_is_valuetype (D.22958);
  if (D.22959 == 0) goto <D.22948>; else goto <D.22947>;
  <D.22948>:
  iftmp.155 = 1;
  goto <D.22949>;
  <D.22947>:
  iftmp.155 = 0;
  <D.22949>:
  D.22945 = iftmp.155;
  return D.22945;
}


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

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


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.22965;
  void * D.22966;
  short unsigned int D.22969;
  struct MonoType * * D.22972;
  int D.22973;
  struct MonoType * * D.22974;
  struct MonoType * * type;

  if (iter == 0B) goto <D.22963>; else goto <D.22964>;
  <D.22963>:
  D.22965 = 0B;
  return D.22965;
  <D.22964>:
  D.22966 = *iter;
  if (D.22966 == 0B) goto <D.22967>; else goto <D.22968>;
  <D.22967>:
  D.22969 = sig->param_count;
  if (D.22969 != 0) goto <D.22970>; else goto <D.22971>;
  <D.22970>:
  D.22972 = &sig->params[0];
  *iter = D.22972;
  D.22965 = sig->params[0];
  return D.22965;
  <D.22971>:
  D.22965 = 0B;
  return D.22965;
  <D.22968>:
  type = *iter;
  type = type + 8;
  D.22969 = sig->param_count;
  D.22973 = (int) D.22969;
  D.22974 = &sig->params[D.22973];
  if (D.22974 > type) goto <D.22975>; else goto <D.22976>;
  <D.22975>:
  *iter = type;
  D.22965 = *type;
  return D.22965;
  <D.22976>:
  D.22965 = 0B;
  return D.22965;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.22978;
  short unsigned int D.22979;

  D.22979 = sig->param_count;
  D.22978 = (uint32_t) D.22979;
  return D.22978;
}


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

  D.22982 = sig->call_convention;
  D.22981 = (uint32_t) D.22982;
  return D.22981;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.22984;
  short int D.22985;

  D.22985 = sig->sentinelpos;
  D.22984 = (int) D.22985;
  return D.22984;
}


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

  D.22988 = sig->hasthis;
  D.22987 = (mono_bool) D.22988;
  return D.22987;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.156;
  short unsigned int D.22995;
  int D.22996;
  _Bool D.22997;
  long int D.22998;
  long int D.22999;
  mono_bool D.23002;
  struct MonoType * D.23003;
  short unsigned int D.23004;
  int D.23005;
  int D.23006;
  _Bool D.23007;

  if (param_num < 0) goto <D.22991>; else goto <D.22994>;
  <D.22994>:
  D.22995 = sig->param_count;
  D.22996 = (int) D.22995;
  if (D.22996 <= param_num) goto <D.22991>; else goto <D.22992>;
  <D.22991>:
  iftmp.156 = 1;
  goto <D.22993>;
  <D.22992>:
  iftmp.156 = 0;
  <D.22993>:
  D.22997 = iftmp.156 != 0;
  D.22998 = (long int) D.22997;
  D.22999 = __builtin_expect (D.22998, 0);
  if (D.22999 != 0) goto <D.23000>; else goto <D.23001>;
  <D.23000>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.23001>:
  D.23003 = sig->params[param_num];
  D.23004 = D.23003->attrs;
  D.23005 = (int) D.23004;
  D.23006 = D.23005 & 2;
  D.23007 = D.23006 != 0;
  D.23002 = (mono_bool) D.23007;
  return D.23002;
}


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

  D.23010 = sig->explicit_this;
  D.23009 = (mono_bool) D.23010;
  return D.23009;
}


__attribute__((visibility ("hidden")))
mono_aligned_addr_hash (const void * ptr)
{
  guint D.23012;
  long int ptr.157;
  unsigned int D.23014;

  ptr.157 = (long int) ptr;
  D.23014 = (unsigned int) ptr.157;
  D.23012 = D.23014 >> 3;
  return D.23012;
}


__attribute__((visibility ("hidden")))
mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.23016;
  struct MonoGenericClass * D.23017;
  struct MonoClassField * D.23020;
  long int field.158;
  struct MonoClassField * D.23022;
  long int D.23023;
  long int D.23024;
  long int D.23025;
  struct MonoClassField * D.23026;
  long unsigned int D.23027;
  long unsigned int D.23028;
  struct MonoClass * gtd;
  int offset;

  D.23016 = field->parent;
  D.23017 = D.23016->generic_class;
  if (D.23017 == 0B) goto <D.23018>; else goto <D.23019>;
  <D.23018>:
  D.23020 = field;
  return D.23020;
  <D.23019>:
  D.23016 = field->parent;
  D.23017 = D.23016->generic_class;
  gtd = D.23017->container_class;
  field.158 = (long int) field;
  D.23016 = field->parent;
  D.23022 = D.23016->fields;
  D.23023 = (long int) D.23022;
  D.23024 = field.158 - D.23023;
  D.23025 = D.23024 /[ex] 32;
  offset = (int) D.23025;
  D.23026 = gtd->fields;
  D.23027 = (long unsigned int) offset;
  D.23028 = D.23027 * 32;
  D.23020 = D.23026 + D.23028;
  return D.23020;
}


__attribute__((visibility ("hidden")))
mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.23030;
  struct MonoGenericClass * D.23031;
  struct MonoEvent * D.23034;
  long int event.159;
  struct MonoClassExt * D.23036;
  struct MonoEvent * D.23037;
  long int D.23038;
  long int D.23039;
  long int D.23040;
  struct MonoClassExt * D.23041;
  struct MonoEvent * D.23042;
  long unsigned int D.23043;
  long unsigned int D.23044;
  struct MonoClass * gtd;
  int offset;

  D.23030 = event->parent;
  D.23031 = D.23030->generic_class;
  if (D.23031 == 0B) goto <D.23032>; else goto <D.23033>;
  <D.23032>:
  D.23034 = event;
  return D.23034;
  <D.23033>:
  D.23030 = event->parent;
  D.23031 = D.23030->generic_class;
  gtd = D.23031->container_class;
  event.159 = (long int) event;
  D.23030 = event->parent;
  D.23036 = D.23030->ext;
  D.23037 = D.23036->events;
  D.23038 = (long int) D.23037;
  D.23039 = event.159 - D.23038;
  D.23040 = D.23039 /[ex] 56;
  offset = (int) D.23040;
  D.23041 = gtd->ext;
  D.23042 = D.23041->events;
  D.23043 = (long unsigned int) offset;
  D.23044 = D.23043 * 56;
  D.23034 = D.23042 + D.23044;
  return D.23034;
}


__attribute__((visibility ("hidden")))
mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.23046;
  struct MonoGenericClass * D.23047;
  struct MonoProperty * D.23050;
  long int property.160;
  struct MonoClassExt * D.23052;
  struct MonoProperty * D.23053;
  long int D.23054;
  long int D.23055;
  long int D.23056;
  struct MonoClassExt * D.23057;
  struct MonoProperty * D.23058;
  long unsigned int D.23059;
  long unsigned int D.23060;
  struct MonoClass * gtd;
  int offset;

  D.23046 = property->parent;
  D.23047 = D.23046->generic_class;
  if (D.23047 == 0B) goto <D.23048>; else goto <D.23049>;
  <D.23048>:
  D.23050 = property;
  return D.23050;
  <D.23049>:
  D.23046 = property->parent;
  D.23047 = D.23046->generic_class;
  gtd = D.23047->container_class;
  property.160 = (long int) property;
  D.23046 = property->parent;
  D.23052 = D.23046->ext;
  D.23053 = D.23052->properties;
  D.23054 = (long int) D.23053;
  D.23055 = property.160 - D.23054;
  D.23056 = D.23055 /[ex] 40;
  offset = (int) D.23056;
  D.23057 = gtd->ext;
  D.23058 = D.23057->properties;
  D.23059 = (long unsigned int) offset;
  D.23060 = D.23059 * 40;
  D.23050 = D.23058 + D.23060;
  return D.23050;
}