mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.18912;
  short int D.18913;
  sizetype D.18914;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.18910>; else goto <D.18911>;
  <D.18910>:
  D.18912 = "";
  return D.18912;
  <D.18911>:
  D.18913 = tableidx[table];
  D.18914 = (sizetype) D.18913;
  D.18912 = &tablestr + D.18914;
  return D.18912;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.18916;
  sizetype D.18917;
  int iftmp.1;
  unsigned char D.18919;
  unsigned char D.18920;
  int iftmp.2;
  unsigned char D.18925;
  int iftmp.3;
  unsigned char D.18930;
  _Bool D.18934;
  long int D.18935;
  long int D.18936;
  int iftmp.4;
  <unnamed-unsigned:24> D.18940;
  int D.18941;
  _Bool D.18945;
  long int D.18946;
  long int D.18947;
  int iftmp.5;
  _Bool D.18954;
  long int D.18955;
  long int D.18956;
  int iftmp.6;
  <unnamed-unsigned:24> D.18960;
  int D.18961;
  unsigned int i.7;
  _Bool D.18966;
  long int D.18967;
  long int D.18968;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.18975;
  int D.18976;
  int iftmp.10;
  _Bool D.18985;
  long int D.18986;
  long int D.18987;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.18999;
  int D.19000;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.19019;
  int D.19020;
  int iftmp.16;
  _Bool D.19030;
  long int D.19031;
  long int D.19032;
  int iftmp.17;
  <unnamed-unsigned:24> D.19036;
  int D.19037;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.19050;
  int D.19051;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.19079;
  int D.19080;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.19095;
  _Bool D.19096;
  long int D.19097;
  long int D.19098;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.19122;
  int D.19123;
  int iftmp.32;
  <unnamed-unsigned:24> D.19131;
  int D.19132;
  <unnamed-unsigned:24> D.19133;
  int D.19134;
  <unnamed-unsigned:24> D.19135;
  int D.19136;
  <unnamed-unsigned:24> D.19137;
  int D.19138;
  <unnamed-unsigned:24> D.19139;
  int D.19140;
  <unnamed-unsigned:24> D.19141;
  int D.19142;
  <unnamed-unsigned:24> D.19143;
  int D.19144;
  <unnamed-unsigned:24> D.19145;
  int D.19146;
  <unnamed-unsigned:24> D.19147;
  int D.19148;
  <unnamed-unsigned:24> D.19149;
  int D.19150;
  <unnamed-unsigned:24> D.19151;
  int D.19152;
  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.19198;
  int D.19199;
  unsigned int D.19200;
  sizetype i.44;
  const unsigned char * D.19202;
  unsigned char D.19203;
  int D.19204;
  unsigned int D.19205;
  unsigned int D.19206;
  int D.19207;
  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.18916 = table_description[tableindex];
  D.18917 = (sizetype) D.18916;
  description = &TableSchemas + D.18917;
  i = 0;
  goto <D.17165>;
  <D.17164>:
  switch (code) <default: <D.19197>, case 1: <D.17119>, case 2: <D.17121>, case 3: <D.17122>, case 4: <D.17123>, case 5: <D.17124>, case 6: <D.17125>, case 7: <D.17126>, case 8: <D.17152>, case 9: <D.17153>, case 10: <D.17154>, case 11: <D.17155>, case 12: <D.17156>, case 13: <D.17157>, case 14: <D.17158>, case 15: <D.17159>, case 16: <D.17160>, case 17: <D.17161>, case 18: <D.17162>, case 19: <D.17163>>
  <D.17119>:
  field_size = 4;
  goto <D.17120>;
  <D.17121>:
  field_size = 2;
  goto <D.17120>;
  <D.17122>:
  field_size = 1;
  goto <D.17120>;
  <D.17123>:
  D.18919 = BIT_FIELD_REF <*meta, 8, 136>;
  D.18920 = D.18919 & 4;
  if (D.18920 != 0) goto <D.18921>; else goto <D.18922>;
  <D.18921>:
  iftmp.1 = 4;
  goto <D.18923>;
  <D.18922>:
  iftmp.1 = 2;
  <D.18923>:
  field_size = iftmp.1;
  goto <D.17120>;
  <D.17124>:
  D.18919 = BIT_FIELD_REF <*meta, 8, 136>;
  D.18925 = D.18919 & 1;
  if (D.18925 != 0) goto <D.18926>; else goto <D.18927>;
  <D.18926>:
  iftmp.2 = 4;
  goto <D.18928>;
  <D.18927>:
  iftmp.2 = 2;
  <D.18928>:
  field_size = iftmp.2;
  goto <D.17120>;
  <D.17125>:
  D.18919 = BIT_FIELD_REF <*meta, 8, 136>;
  D.18930 = D.18919 & 2;
  if (D.18930 != 0) goto <D.18931>; else goto <D.18932>;
  <D.18931>:
  iftmp.3 = 4;
  goto <D.18933>;
  <D.18932>:
  iftmp.3 = 2;
  <D.18933>:
  field_size = iftmp.3;
  goto <D.17120>;
  <D.17126>:
  switch (tableindex) <default: <D.17150>, case 2: <D.17147>, case 3: <D.17136>, case 5: <D.17142>, case 6: <D.17139>, case 7: <D.17144>, case 9: <D.17138>, case 15: <D.17130>, case 16: <D.17134>, case 18: <D.17131>, case 19: <D.17132>, case 21: <D.17145>, case 22: <D.17146>, case 24: <D.17141>, case 25: <D.17140>, case 28: <D.17137>, case 29: <D.17135>, case 36: <D.17129>, case 37: <D.17127>, case 39: <D.17133>, case 41: <D.17143>, case 42: <D.17148>, case 44: <D.17149>>
  <D.17127>:
  D.18934 = i != 3;
  D.18935 = (long int) D.18934;
  D.18936 = __builtin_expect (D.18935, 0);
  if (D.18936 != 0) goto <D.18937>; else goto <D.18938>;
  <D.18937>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.18938>:
  D.18940 = meta->tables[35].rows;
  D.18941 = (int) D.18940;
  if (D.18941 <= 65535) goto <D.18942>; else goto <D.18943>;
  <D.18942>:
  iftmp.4 = 2;
  goto <D.18944>;
  <D.18943>:
  iftmp.4 = 4;
  <D.18944>:
  field_size = iftmp.4;
  goto <D.17128>;
  <D.17129>:
  D.18945 = i != 1;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.18948>; else goto <D.18949>;
  <D.18948>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.18949>:
  D.18940 = meta->tables[35].rows;
  D.18941 = (int) D.18940;
  if (D.18941 <= 65535) goto <D.18951>; else goto <D.18952>;
  <D.18951>:
  iftmp.5 = 2;
  goto <D.18953>;
  <D.18952>:
  iftmp.5 = 4;
  <D.18953>:
  field_size = iftmp.5;
  goto <D.17128>;
  <D.17130>:
  D.18954 = i != 2;
  D.18955 = (long int) D.18954;
  D.18956 = __builtin_expect (D.18955, 0);
  if (D.18956 != 0) goto <D.18957>; else goto <D.18958>;
  <D.18957>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.18958>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.18962>; else goto <D.18963>;
  <D.18962>:
  iftmp.6 = 2;
  goto <D.18964>;
  <D.18963>:
  iftmp.6 = 4;
  <D.18964>:
  field_size = iftmp.6;
  goto <D.17128>;
  <D.17131>:
  i.7 = (unsigned int) i;
  D.18966 = i.7 > 1;
  D.18967 = (long int) D.18966;
  D.18968 = __builtin_expect (D.18967, 0);
  if (D.18968 != 0) goto <D.18969>; else goto <D.18970>;
  <D.18969>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.18970>:
  if (i != 0) goto <D.18972>; else goto <D.18973>;
  <D.18972>:
  D.18975 = meta->tables[20].rows;
  D.18976 = (int) D.18975;
  if (D.18976 <= 65535) goto <D.18977>; else goto <D.18978>;
  <D.18977>:
  iftmp.9 = 2;
  goto <D.18979>;
  <D.18978>:
  iftmp.9 = 4;
  <D.18979>:
  iftmp.8 = iftmp.9;
  goto <D.18980>;
  <D.18973>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.18982>; else goto <D.18983>;
  <D.18982>:
  iftmp.10 = 2;
  goto <D.18984>;
  <D.18983>:
  iftmp.10 = 4;
  <D.18984>:
  iftmp.8 = iftmp.10;
  <D.18980>:
  field_size = iftmp.8;
  goto <D.17128>;
  <D.17132>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.18988>; else goto <D.18989>;
  <D.18988>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.18989>:
  D.18975 = meta->tables[20].rows;
  D.18976 = (int) D.18975;
  if (D.18976 <= 65535) goto <D.18991>; else goto <D.18992>;
  <D.18991>:
  iftmp.11 = 2;
  goto <D.18993>;
  <D.18992>:
  iftmp.11 = 4;
  <D.18993>:
  field_size = iftmp.11;
  goto <D.17128>;
  <D.17133>:
  D.18945 = i != 1;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.18994>; else goto <D.18995>;
  <D.18994>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.18995>:
  field_size = 4;
  goto <D.17128>;
  <D.17134>:
  D.18945 = i != 1;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.18996>; else goto <D.18997>;
  <D.18996>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.18997>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  if (D.19000 <= 65535) goto <D.19001>; else goto <D.19002>;
  <D.19001>:
  iftmp.12 = 2;
  goto <D.19003>;
  <D.19002>:
  iftmp.12 = 4;
  <D.19003>:
  field_size = iftmp.12;
  goto <D.17128>;
  <D.17135>:
  D.18945 = i != 1;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.19004>; else goto <D.19005>;
  <D.19004>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.19005>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  if (D.19000 <= 65535) goto <D.19007>; else goto <D.19008>;
  <D.19007>:
  iftmp.13 = 2;
  goto <D.19009>;
  <D.19008>:
  iftmp.13 = 4;
  <D.19009>:
  field_size = iftmp.13;
  goto <D.17128>;
  <D.17136>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19010>; else goto <D.19011>;
  <D.19010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.19011>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  if (D.19000 <= 65535) goto <D.19013>; else goto <D.19014>;
  <D.19013>:
  iftmp.14 = 2;
  goto <D.19015>;
  <D.19014>:
  iftmp.14 = 4;
  <D.19015>:
  field_size = iftmp.14;
  goto <D.17128>;
  <D.17137>:
  D.18934 = i != 3;
  D.18935 = (long int) D.18934;
  D.18936 = __builtin_expect (D.18935, 0);
  if (D.18936 != 0) goto <D.19016>; else goto <D.19017>;
  <D.19016>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.19017>:
  D.19019 = meta->tables[26].rows;
  D.19020 = (int) D.19019;
  if (D.19020 <= 65535) goto <D.19021>; else goto <D.19022>;
  <D.19021>:
  iftmp.15 = 2;
  goto <D.19023>;
  <D.19022>:
  iftmp.15 = 4;
  <D.19023>:
  field_size = iftmp.15;
  goto <D.17128>;
  <D.17138>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19024>; else goto <D.19025>;
  <D.19024>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.19025>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.19027>; else goto <D.19028>;
  <D.19027>:
  iftmp.16 = 2;
  goto <D.19029>;
  <D.19028>:
  iftmp.16 = 4;
  <D.19029>:
  field_size = iftmp.16;
  goto <D.17128>;
  <D.17139>:
  D.19030 = i != 5;
  D.19031 = (long int) D.19030;
  D.19032 = __builtin_expect (D.19031, 0);
  if (D.19032 != 0) goto <D.19033>; else goto <D.19034>;
  <D.19033>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.19034>:
  D.19036 = meta->tables[8].rows;
  D.19037 = (int) D.19036;
  if (D.19037 <= 65535) goto <D.19038>; else goto <D.19039>;
  <D.19038>:
  iftmp.17 = 2;
  goto <D.19040>;
  <D.19039>:
  iftmp.17 = 4;
  <D.19040>:
  field_size = iftmp.17;
  goto <D.17128>;
  <D.17140>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19041>; else goto <D.19042>;
  <D.19041>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.19042>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.19044>; else goto <D.19045>;
  <D.19044>:
  iftmp.18 = 2;
  goto <D.19046>;
  <D.19045>:
  iftmp.18 = 4;
  <D.19046>:
  field_size = iftmp.18;
  goto <D.17128>;
  <D.17141>:
  D.18945 = i != 1;
  D.18946 = (long int) D.18945;
  D.18947 = __builtin_expect (D.18946, 0);
  if (D.18947 != 0) goto <D.19047>; else goto <D.19048>;
  <D.19047>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.19048>:
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  if (D.19051 <= 65535) goto <D.19052>; else goto <D.19053>;
  <D.19052>:
  iftmp.19 = 2;
  goto <D.19054>;
  <D.19053>:
  iftmp.19 = 4;
  <D.19054>:
  field_size = iftmp.19;
  goto <D.17128>;
  <D.17142>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19055>; else goto <D.19056>;
  <D.19055>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.19056>:
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  if (D.19051 <= 65535) goto <D.19058>; else goto <D.19059>;
  <D.19058>:
  iftmp.20 = 2;
  goto <D.19060>;
  <D.19059>:
  iftmp.20 = 4;
  <D.19060>:
  field_size = iftmp.20;
  goto <D.17128>;
  <D.17143>:
  i.7 = (unsigned int) i;
  D.18966 = i.7 > 1;
  D.18967 = (long int) D.18966;
  D.18968 = __builtin_expect (D.18967, 0);
  if (D.18968 != 0) goto <D.19061>; else goto <D.19062>;
  <D.19061>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.19062>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.19064>; else goto <D.19065>;
  <D.19064>:
  iftmp.21 = 2;
  goto <D.19066>;
  <D.19065>:
  iftmp.21 = 4;
  <D.19066>:
  field_size = iftmp.21;
  goto <D.17128>;
  <D.17144>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19067>; else goto <D.19068>;
  <D.19067>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.19068>:
  D.19036 = meta->tables[8].rows;
  D.19037 = (int) D.19036;
  if (D.19037 <= 65535) goto <D.19070>; else goto <D.19071>;
  <D.19070>:
  iftmp.22 = 2;
  goto <D.19072>;
  <D.19071>:
  iftmp.22 = 4;
  <D.19072>:
  field_size = iftmp.22;
  goto <D.17128>;
  <D.17145>:
  i.7 = (unsigned int) i;
  D.18966 = i.7 > 1;
  D.18967 = (long int) D.18966;
  D.18968 = __builtin_expect (D.18967, 0);
  if (D.18968 != 0) goto <D.19073>; else goto <D.19074>;
  <D.19073>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.19074>:
  if (i != 0) goto <D.19076>; else goto <D.19077>;
  <D.19076>:
  D.19079 = meta->tables[23].rows;
  D.19080 = (int) D.19079;
  if (D.19080 <= 65535) goto <D.19081>; else goto <D.19082>;
  <D.19081>:
  iftmp.24 = 2;
  goto <D.19083>;
  <D.19082>:
  iftmp.24 = 4;
  <D.19083>:
  iftmp.23 = iftmp.24;
  goto <D.19084>;
  <D.19077>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  if (D.18961 <= 65535) goto <D.19086>; else goto <D.19087>;
  <D.19086>:
  iftmp.25 = 2;
  goto <D.19088>;
  <D.19087>:
  iftmp.25 = 4;
  <D.19088>:
  iftmp.23 = iftmp.25;
  <D.19084>:
  field_size = iftmp.23;
  goto <D.17128>;
  <D.17146>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19089>; else goto <D.19090>;
  <D.19089>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.19090>:
  D.19079 = meta->tables[23].rows;
  D.19080 = (int) D.19079;
  if (D.19080 <= 65535) goto <D.19092>; else goto <D.19093>;
  <D.19092>:
  iftmp.26 = 2;
  goto <D.19094>;
  <D.19093>:
  iftmp.26 = 4;
  <D.19094>:
  field_size = iftmp.26;
  goto <D.17128>;
  <D.17147>:
  i.7 = (unsigned int) i;
  D.19095 = i.7 + 4294967292;
  D.19096 = D.19095 > 1;
  D.19097 = (long int) D.19096;
  D.19098 = __builtin_expect (D.19097, 0);
  if (D.19098 != 0) goto <D.19099>; else goto <D.19100>;
  <D.19099>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.19100>:
  if (i == 4) goto <D.19102>; else goto <D.19103>;
  <D.19102>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  if (D.19000 <= 65535) goto <D.19105>; else goto <D.19106>;
  <D.19105>:
  iftmp.28 = 2;
  goto <D.19107>;
  <D.19106>:
  iftmp.28 = 4;
  <D.19107>:
  iftmp.27 = iftmp.28;
  goto <D.19108>;
  <D.19103>:
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  if (D.19051 <= 65535) goto <D.19110>; else goto <D.19111>;
  <D.19110>:
  iftmp.29 = 2;
  goto <D.19112>;
  <D.19111>:
  iftmp.29 = 4;
  <D.19112>:
  iftmp.27 = iftmp.29;
  <D.19108>:
  field_size = iftmp.27;
  goto <D.17128>;
  <D.17148>:
  D.18954 = i != 2;
  D.18955 = (long int) D.18954;
  D.18956 = __builtin_expect (D.18955, 0);
  if (D.18956 != 0) goto <D.19113>; else goto <D.19114>;
  <D.19113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.19114>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  n = MAX_EXPR <D.18961, D.19051>;
  if (n <= 32767) goto <D.19116>; else goto <D.19117>;
  <D.19116>:
  iftmp.30 = 2;
  goto <D.19118>;
  <D.19117>:
  iftmp.30 = 4;
  <D.19118>:
  field_size = iftmp.30;
  goto <D.17128>;
  <D.17149>:
  D.18985 = i != 0;
  D.18986 = (long int) D.18985;
  D.18987 = __builtin_expect (D.18986, 0);
  if (D.18987 != 0) goto <D.19119>; else goto <D.19120>;
  <D.19119>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.19120>:
  D.19122 = meta->tables[42].rows;
  D.19123 = (int) D.19122;
  if (D.19123 <= 65535) goto <D.19124>; else goto <D.19125>;
  <D.19124>:
  iftmp.31 = 2;
  goto <D.19126>;
  <D.19125>:
  iftmp.31 = 4;
  <D.19126>:
  field_size = iftmp.31;
  goto <D.17128>;
  <D.17150>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.17151>:
  goto <D.17151>;
  <D.17128>:
  goto <D.17120>;
  <D.17152>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  D.19036 = meta->tables[8].rows;
  D.19037 = (int) D.19036;
  n = MAX_EXPR <D.19000, D.19037>;
  D.19079 = meta->tables[23].rows;
  D.19080 = (int) D.19079;
  n = MAX_EXPR <D.19080, n>;
  if (n <= 16383) goto <D.19128>; else goto <D.19129>;
  <D.19128>:
  iftmp.32 = 2;
  goto <D.19130>;
  <D.19129>:
  iftmp.32 = 4;
  <D.19130>:
  field_size = iftmp.32;
  goto <D.17120>;
  <D.17153>:
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  n = MAX_EXPR <D.19000, D.19051>;
  D.19131 = meta->tables[1].rows;
  D.19132 = (int) D.19131;
  n = MAX_EXPR <D.19132, n>;
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  n = MAX_EXPR <D.18961, n>;
  D.19036 = meta->tables[8].rows;
  D.19037 = (int) D.19036;
  n = MAX_EXPR <D.19037, n>;
  D.19133 = meta->tables[9].rows;
  D.19134 = (int) D.19133;
  n = MAX_EXPR <D.19134, n>;
  D.19135 = meta->tables[10].rows;
  D.19136 = (int) D.19135;
  n = MAX_EXPR <D.19136, n>;
  D.19137 = meta->tables[0].rows;
  D.19138 = (int) D.19137;
  n = MAX_EXPR <D.19138, n>;
  D.19139 = meta->tables[14].rows;
  D.19140 = (int) D.19139;
  n = MAX_EXPR <D.19140, n>;
  D.19079 = meta->tables[23].rows;
  D.19080 = (int) D.19079;
  n = MAX_EXPR <D.19080, n>;
  D.18975 = meta->tables[20].rows;
  D.18976 = (int) D.18975;
  n = MAX_EXPR <D.18976, n>;
  D.19141 = meta->tables[17].rows;
  D.19142 = (int) D.19141;
  n = MAX_EXPR <D.19142, n>;
  D.19019 = meta->tables[26].rows;
  D.19020 = (int) D.19019;
  n = MAX_EXPR <D.19020, n>;
  D.19143 = meta->tables[27].rows;
  D.19144 = (int) D.19143;
  n = MAX_EXPR <D.19144, n>;
  D.19145 = meta->tables[32].rows;
  D.19146 = (int) D.19145;
  n = MAX_EXPR <D.19146, n>;
  D.18940 = meta->tables[35].rows;
  D.18941 = (int) D.18940;
  n = MAX_EXPR <D.18941, n>;
  D.19147 = meta->tables[38].rows;
  D.19148 = (int) D.19147;
  n = MAX_EXPR <D.19148, n>;
  D.19149 = meta->tables[39].rows;
  D.19150 = (int) D.19149;
  n = MAX_EXPR <D.19150, n>;
  D.19151 = meta->tables[40].rows;
  D.19152 = (int) D.19151;
  n = MAX_EXPR <D.19152, n>;
  if (n <= 2047) goto <D.19154>; else goto <D.19155>;
  <D.19154>:
  iftmp.33 = 2;
  goto <D.19156>;
  <D.19155>:
  iftmp.33 = 4;
  <D.19156>:
  field_size = iftmp.33;
  goto <D.17120>;
  <D.17154>:
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  D.19131 = meta->tables[1].rows;
  D.19132 = (int) D.19131;
  n = MAX_EXPR <D.18961, D.19132>;
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  n = MAX_EXPR <D.19051, n>;
  D.19135 = meta->tables[10].rows;
  D.19136 = (int) D.19135;
  n = MAX_EXPR <D.19136, n>;
  if (n <= 8191) goto <D.19158>; else goto <D.19159>;
  <D.19158>:
  iftmp.34 = 2;
  goto <D.19160>;
  <D.19159>:
  iftmp.34 = 4;
  <D.19160>:
  field_size = iftmp.34;
  goto <D.17120>;
  <D.17155>:
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  n = MAX_EXPR <D.19051, D.18961>;
  D.19145 = meta->tables[32].rows;
  D.19146 = (int) D.19145;
  n = MAX_EXPR <D.19146, n>;
  if (n <= 16383) goto <D.19162>; else goto <D.19163>;
  <D.19162>:
  iftmp.35 = 2;
  goto <D.19164>;
  <D.19163>:
  iftmp.35 = 4;
  <D.19164>:
  field_size = iftmp.35;
  goto <D.17120>;
  <D.17156>:
  D.18940 = meta->tables[35].rows;
  D.18941 = (int) D.18940;
  D.19147 = meta->tables[38].rows;
  D.19148 = (int) D.19147;
  n = MAX_EXPR <D.18941, D.19148>;
  D.19149 = meta->tables[39].rows;
  D.19150 = (int) D.19149;
  n = MAX_EXPR <D.19150, n>;
  if (n <= 16383) goto <D.19166>; else goto <D.19167>;
  <D.19166>:
  iftmp.36 = 2;
  goto <D.19168>;
  <D.19167>:
  iftmp.36 = 4;
  <D.19168>:
  field_size = iftmp.36;
  goto <D.17120>;
  <D.17157>:
  D.19036 = meta->tables[8].rows;
  D.19037 = (int) D.19036;
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  n = MAX_EXPR <D.19037, D.19000>;
  if (n <= 32767) goto <D.19170>; else goto <D.19171>;
  <D.19170>:
  iftmp.37 = 2;
  goto <D.19172>;
  <D.19171>:
  iftmp.37 = 4;
  <D.19172>:
  field_size = iftmp.37;
  goto <D.17120>;
  <D.17158>:
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  D.18999 = meta->tables[4].rows;
  D.19000 = (int) D.18999;
  n = MAX_EXPR <D.19051, D.19000>;
  if (n <= 32767) goto <D.19174>; else goto <D.19175>;
  <D.19174>:
  iftmp.38 = 2;
  goto <D.19176>;
  <D.19175>:
  iftmp.38 = 4;
  <D.19176>:
  field_size = iftmp.38;
  goto <D.17120>;
  <D.17159>:
  D.19131 = meta->tables[1].rows;
  D.19132 = (int) D.19131;
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  n = MAX_EXPR <D.19132, D.18961>;
  D.19143 = meta->tables[27].rows;
  D.19144 = (int) D.19143;
  n = MAX_EXPR <D.19144, n>;
  if (n <= 16383) goto <D.19178>; else goto <D.19179>;
  <D.19178>:
  iftmp.39 = 2;
  goto <D.19180>;
  <D.19179>:
  iftmp.39 = 4;
  <D.19180>:
  field_size = iftmp.39;
  goto <D.17120>;
  <D.17160>:
  D.19131 = meta->tables[1].rows;
  D.19132 = (int) D.19131;
  D.18960 = meta->tables[2].rows;
  D.18961 = (int) D.18960;
  n = MAX_EXPR <D.19132, D.18961>;
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  n = MAX_EXPR <D.19051, n>;
  D.19019 = meta->tables[26].rows;
  D.19020 = (int) D.19019;
  n = MAX_EXPR <D.19020, n>;
  D.19143 = meta->tables[27].rows;
  D.19144 = (int) D.19143;
  n = MAX_EXPR <D.19144, n>;
  if (n <= 8191) goto <D.19182>; else goto <D.19183>;
  <D.19182>:
  iftmp.40 = 2;
  goto <D.19184>;
  <D.19183>:
  iftmp.40 = 4;
  <D.19184>:
  field_size = iftmp.40;
  goto <D.17120>;
  <D.17161>:
  D.19135 = meta->tables[10].rows;
  D.19136 = (int) D.19135;
  D.19050 = meta->tables[6].rows;
  D.19051 = (int) D.19050;
  n = MAX_EXPR <D.19136, D.19051>;
  if (n <= 32767) goto <D.19186>; else goto <D.19187>;
  <D.19186>:
  iftmp.41 = 2;
  goto <D.19188>;
  <D.19187>:
  iftmp.41 = 4;
  <D.19188>:
  field_size = iftmp.41;
  goto <D.17120>;
  <D.17162>:
  D.18975 = meta->tables[20].rows;
  D.18976 = (int) D.18975;
  D.19079 = meta->tables[23].rows;
  D.19080 = (int) D.19079;
  n = MAX_EXPR <D.18976, D.19080>;
  if (n <= 32767) goto <D.19190>; else goto <D.19191>;
  <D.19190>:
  iftmp.42 = 2;
  goto <D.19192>;
  <D.19191>:
  iftmp.42 = 4;
  <D.19192>:
  field_size = iftmp.42;
  goto <D.17120>;
  <D.17163>:
  D.19019 = meta->tables[26].rows;
  D.19020 = (int) D.19019;
  D.19137 = meta->tables[0].rows;
  D.19138 = (int) D.19137;
  n = MAX_EXPR <D.19020, D.19138>;
  D.18940 = meta->tables[35].rows;
  D.18941 = (int) D.18940;
  n = MAX_EXPR <D.18941, n>;
  D.19131 = meta->tables[1].rows;
  D.19132 = (int) D.19131;
  n = MAX_EXPR <D.19132, n>;
  if (n <= 16383) goto <D.19194>; else goto <D.19195>;
  <D.19194>:
  iftmp.43 = 2;
  goto <D.19196>;
  <D.19195>:
  iftmp.43 = 4;
  <D.19196>:
  field_size = iftmp.43;
  goto <D.17120>;
  <D.19197>:
  <D.17120>:
  D.19198 = field_size + -1;
  D.19199 = D.19198 << shift;
  D.19200 = (unsigned int) D.19199;
  bitfield = D.19200 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.17165>:
  i.44 = (sizetype) i;
  D.19202 = description + i.44;
  D.19203 = *D.19202;
  code = (int) D.19203;
  if (code != 0) goto <D.17164>; else goto <D.17166>;
  <D.17166>:
  D.19204 = i << 24;
  D.19205 = (unsigned int) D.19204;
  D.19206 = D.19205 | bitfield;
  *result_bitfield = D.19206;
  D.19207 = size;
  return D.19207;
}


mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  unsigned int D.19209;
  unsigned int D.19210;
  guint32 * D.19213;
  int D.19214;
  unsigned char D.19215;
  <unnamed-unsigned:24> D.19216;
  int D.19217;
  unsigned char D.19218;
  int D.19219;
  int D.19220;
  sizetype D.19221;
  int i;
  const char * base;

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

    table = &meta->tables[i];
    D.19209 = BIT_FIELD_REF <*table, 32, 32>;
    D.19210 = D.19209 & 16777215;
    if (D.19210 == 0) goto <D.19211>; else goto <D.19212>;
    <D.19211>:
    // predicted unlikely by continue predictor.
    goto <D.17173>;
    <D.19212>:
    D.19213 = &table->size_bitfield;
    D.19214 = mono_metadata_compute_size (meta, i, D.19213);
    D.19215 = (unsigned char) D.19214;
    table->row_size = D.19215;
    table->base = base;
    D.19216 = table->rows;
    D.19217 = (int) D.19216;
    D.19218 = table->row_size;
    D.19219 = (int) D.19218;
    D.19220 = D.19217 * D.19219;
    D.19221 = (sizetype) D.19220;
    base = base + D.19221;
  }
  <D.17173>:
  i = i + 1;
  <D.17175>:
  if (i <= 44) goto <D.17174>; else goto <D.17176>;
  <D.17176>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.19225;
  int D.19226;
  const char * D.19227;
  const char * D.19228;
  unsigned char D.19229;
  int D.19230;
  int D.19231;
  int D.19232;
  sizetype D.19233;

  if (idx <= 0) goto <D.19222>; else goto <D.19224>;
  <D.19224>:
  D.19225 = meta->tables[table].rows;
  D.19226 = (int) D.19225;
  if (D.19226 < idx) goto <D.19222>; else goto <D.19223>;
  <D.19222>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.19227 = "";
  return D.19227;
  <D.19223>:
  D.19228 = meta->tables[table].base;
  D.19229 = meta->tables[table].row_size;
  D.19230 = (int) D.19229;
  D.19231 = idx + -1;
  D.19232 = D.19230 * D.19231;
  D.19233 = (sizetype) D.19232;
  D.19227 = D.19228 + D.19233;
  return D.19227;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.19235;
  int token.45;
  int D.19237;
  unsigned int D.19238;
  int D.19239;

  token.45 = (int) token;
  D.19237 = token.45 & 16777215;
  D.19238 = token >> 24;
  D.19239 = (int) D.19238;
  D.19235 = mono_metadata_locate (meta, D.19239, D.19237);
  return D.19235;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19241;
  _Bool D.19242;
  long int D.19243;
  long int D.19244;
  const char * D.19249;
  const char * D.19250;

  D.19241 = meta->heap_strings.size;
  D.19242 = D.19241 <= index;
  D.19243 = (long int) D.19242;
  D.19244 = __builtin_expect (D.19243, 0);
  if (D.19244 != 0) goto <D.19245>; else goto <D.19246>;
  <D.19245>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.19246>:
  D.19241 = meta->heap_strings.size;
  if (D.19241 <= index) goto <D.19247>; else goto <D.19248>;
  <D.19247>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.19249 = "";
  return D.19249;
  <D.19248>:
  D.19250 = meta->heap_strings.data;
  D.19249 = D.19250 + index;
  return D.19249;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19252;
  _Bool D.19253;
  long int D.19254;
  long int D.19255;
  const char * D.19260;
  const char * D.19261;

  D.19252 = meta->heap_us.size;
  D.19253 = D.19252 <= index;
  D.19254 = (long int) D.19253;
  D.19255 = __builtin_expect (D.19254, 0);
  if (D.19255 != 0) goto <D.19256>; else goto <D.19257>;
  <D.19256>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.19257>:
  D.19252 = meta->heap_us.size;
  if (D.19252 <= index) goto <D.19258>; else goto <D.19259>;
  <D.19258>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.19260 = "";
  return D.19260;
  <D.19259>:
  D.19261 = meta->heap_us.data;
  D.19260 = D.19261 + index;
  return D.19260;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19263;
  _Bool D.19264;
  long int D.19265;
  long int D.19266;
  const char * D.19271;
  const char * D.19272;

  D.19263 = meta->heap_blob.size;
  D.19264 = D.19263 <= index;
  D.19265 = (long int) D.19264;
  D.19266 = __builtin_expect (D.19265, 0);
  if (D.19266 != 0) goto <D.19267>; else goto <D.19268>;
  <D.19267>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.19268>:
  D.19263 = meta->heap_blob.size;
  if (D.19263 <= index) goto <D.19269>; else goto <D.19270>;
  <D.19269>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.19271 = "";
  return D.19271;
  <D.19270>:
  D.19272 = meta->heap_blob.data;
  D.19271 = D.19272 + index;
  return D.19271;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19274;
  const char * D.19277;
  const char * D.19278;

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


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.19280;
  <unnamed-unsigned:24> D.19281;
  int D.19282;
  _Bool D.19283;
  long int D.19284;
  long int D.19285;
  _Bool D.19288;
  long int D.19289;
  long int D.19290;
  const char * D.19293;
  unsigned char D.19294;
  int D.19295;
  int D.19296;
  sizetype D.19297;
  _Bool D.19298;
  long int D.19299;
  long int D.19300;
  int D.19303;
  unsigned int D.19304;
  unsigned int D.19305;
  unsigned int D.19306;
  unsigned int i.46;
  unsigned int D.19308;
  guint32 * D.19309;
  char D.19310;
  unsigned int D.19311;
  short unsigned int D.19312;
  unsigned int D.19313;
  unsigned int D.19314;
  sizetype n.47;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.19280 = bitfield >> 24;
  count = (int) D.19280;
  D.19281 = t->rows;
  D.19282 = (int) D.19281;
  D.19283 = D.19282 <= idx;
  D.19284 = (long int) D.19283;
  D.19285 = __builtin_expect (D.19284, 0);
  if (D.19285 != 0) goto <D.19286>; else goto <D.19287>;
  <D.19286>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.19287>:
  D.19288 = idx < 0;
  D.19289 = (long int) D.19288;
  D.19290 = __builtin_expect (D.19289, 0);
  if (D.19290 != 0) goto <D.19291>; else goto <D.19292>;
  <D.19291>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.19292>:
  D.19293 = t->base;
  D.19294 = t->row_size;
  D.19295 = (int) D.19294;
  D.19296 = D.19295 * idx;
  D.19297 = (sizetype) D.19296;
  data = D.19293 + D.19297;
  D.19298 = res_size != count;
  D.19299 = (long int) D.19298;
  D.19300 = __builtin_expect (D.19299, 0);
  if (D.19300 != 0) goto <D.19301>; else goto <D.19302>;
  <D.19301>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.19302>:
  i = 0;
  goto <D.17222>;
  <D.17221>:
  {
    int n;

    D.19303 = i * 2;
    D.19304 = bitfield >> D.19303;
    D.19305 = D.19304 & 3;
    D.19306 = D.19305 + 1;
    n = (int) D.19306;
    switch (n) <default: <D.17220>, case 1: <D.17216>, case 2: <D.17218>, case 4: <D.17219>>
    <D.17216>:
    i.46 = (unsigned int) i;
    D.19308 = i.46 * 4;
    D.19309 = res + D.19308;
    D.19310 = *data;
    D.19311 = (unsigned int) D.19310;
    *D.19309 = D.19311;
    goto <D.17217>;
    <D.17218>:
    i.46 = (unsigned int) i;
    D.19308 = i.46 * 4;
    D.19309 = res + D.19308;
    D.19312 = MEM[(const guint16 *)data];
    D.19313 = (unsigned int) D.19312;
    *D.19309 = D.19313;
    goto <D.17217>;
    <D.17219>:
    i.46 = (unsigned int) i;
    D.19308 = i.46 * 4;
    D.19309 = res + D.19308;
    D.19314 = MEM[(const guint32 *)data];
    *D.19309 = D.19314;
    goto <D.17217>;
    <D.17220>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.17217>:
    n.47 = (sizetype) n;
    data = data + n.47;
  }
  i = i + 1;
  <D.17222>:
  if (i < count) goto <D.17221>; else goto <D.17223>;
  <D.17223>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.19316;
  int D.19317;
  _Bool D.19318;
  long int D.19319;
  long int D.19320;
  unsigned int D.19323;
  _Bool D.19324;
  long int D.19325;
  long int D.19326;
  const char * D.19329;
  unsigned char D.19330;
  int D.19331;
  int D.19332;
  sizetype D.19333;
  unsigned int D.19334;
  unsigned int D.19335;
  sizetype n.48;
  int D.19337;
  int D.19338;
  unsigned int D.19339;
  unsigned int D.19340;
  unsigned int D.19341;
  unsigned int i.49;
  uint32_t D.19343;
  char D.19344;
  short unsigned int D.19345;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.19316 = t->rows;
  D.19317 = (int) D.19316;
  D.19318 = D.19317 <= idx;
  D.19319 = (long int) D.19318;
  D.19320 = __builtin_expect (D.19319, 0);
  if (D.19320 != 0) goto <D.19321>; else goto <D.19322>;
  <D.19321>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.19322>:
  D.19323 = bitfield >> 24;
  D.19324 = D.19323 <= col;
  D.19325 = (long int) D.19324;
  D.19326 = __builtin_expect (D.19325, 0);
  if (D.19326 != 0) goto <D.19327>; else goto <D.19328>;
  <D.19327>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.19328>:
  D.19329 = t->base;
  D.19330 = t->row_size;
  D.19331 = (int) D.19330;
  D.19332 = D.19331 * idx;
  D.19333 = (sizetype) D.19332;
  data = D.19329 + D.19333;
  D.19334 = bitfield & 3;
  D.19335 = D.19334 + 1;
  n = (int) D.19335;
  i = 0;
  goto <D.17234>;
  <D.17233>:
  n.48 = (sizetype) n;
  data = data + n.48;
  D.19337 = i + 1;
  D.19338 = D.19337 * 2;
  D.19339 = bitfield >> D.19338;
  D.19340 = D.19339 & 3;
  D.19341 = D.19340 + 1;
  n = (int) D.19341;
  i = i + 1;
  <D.17234>:
  i.49 = (unsigned int) i;
  if (i.49 < col) goto <D.17233>; else goto <D.17235>;
  <D.17235>:
  switch (n) <default: <D.17239>, case 1: <D.17236>, case 2: <D.17237>, case 4: <D.17238>>
  <D.17236>:
  D.19344 = *data;
  D.19343 = (uint32_t) D.19344;
  return D.19343;
  <D.17237>:
  D.19345 = MEM[(const guint16 *)data];
  D.19343 = (uint32_t) D.19345;
  return D.19343;
  <D.17238>:
  D.19343 = MEM[(const guint32 *)data];
  return D.19343;
  <D.17239>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.19343 = 0;
  return D.19343;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.19347;
  signed char D.19348;
  unsigned int D.19351;
  int D.19353;
  int D.19354;
  int D.19357;
  int D.19358;
  const unsigned char * D.19359;
  unsigned char D.19360;
  int D.19361;
  int D.19362;
  int D.19364;
  int D.19365;
  int D.19366;
  int D.19367;
  const unsigned char * D.19368;
  unsigned char D.19369;
  int D.19370;
  int D.19371;
  int D.19372;
  const unsigned char * D.19373;
  unsigned char D.19374;
  int D.19375;
  int D.19376;
  uint32_t D.19379;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.19347 = *ptr;
  D.19348 = (signed char) D.19347;
  if (D.19348 >= 0) goto <D.19349>; else goto <D.19350>;
  <D.19349>:
  D.19347 = *ptr;
  D.19351 = (unsigned int) D.19347;
  size = D.19351 & 127;
  ptr = ptr + 1;
  goto <D.19352>;
  <D.19350>:
  D.19347 = *ptr;
  D.19353 = (int) D.19347;
  D.19354 = D.19353 & 64;
  if (D.19354 == 0) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  D.19347 = *ptr;
  D.19353 = (int) D.19347;
  D.19357 = D.19353 & 63;
  D.19358 = D.19357 << 8;
  D.19359 = ptr + 1;
  D.19360 = *D.19359;
  D.19361 = (int) D.19360;
  D.19362 = D.19358 + D.19361;
  size = (guint32) D.19362;
  ptr = ptr + 2;
  goto <D.19363>;
  <D.19356>:
  D.19347 = *ptr;
  D.19353 = (int) D.19347;
  D.19364 = D.19353 & 31;
  D.19365 = D.19364 << 24;
  D.19359 = ptr + 1;
  D.19360 = *D.19359;
  D.19361 = (int) D.19360;
  D.19366 = D.19361 << 16;
  D.19367 = D.19365 + D.19366;
  D.19368 = ptr + 2;
  D.19369 = *D.19368;
  D.19370 = (int) D.19369;
  D.19371 = D.19370 << 8;
  D.19372 = D.19367 + D.19371;
  D.19373 = ptr + 3;
  D.19374 = *D.19373;
  D.19375 = (int) D.19374;
  D.19376 = D.19372 + D.19375;
  size = (guint32) D.19376;
  ptr = ptr + 4;
  <D.19363>:
  <D.19352>:
  if (rptr != 0B) goto <D.19377>; else goto <D.19378>;
  <D.19377>:
  *rptr = ptr;
  <D.19378>:
  D.19379 = size;
  return D.19379;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.50;
  int D.19385;
  int D.19386;
  int D.19389;
  int D.19390;
  const unsigned char * D.19391;
  unsigned char D.19392;
  int D.19393;
  int D.19394;
  int D.19396;
  int D.19397;
  int D.19398;
  int D.19399;
  const unsigned char * D.19400;
  unsigned char D.19401;
  int D.19402;
  int D.19403;
  int D.19404;
  const unsigned char * D.19405;
  unsigned char D.19406;
  int D.19407;
  int D.19408;
  uint32_t D.19411;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.50 = (signed char) b;
  if (b.50 >= 0) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.19384>;
  <D.19383>:
  D.19385 = (int) b;
  D.19386 = D.19385 & 64;
  if (D.19386 == 0) goto <D.19387>; else goto <D.19388>;
  <D.19387>:
  D.19385 = (int) b;
  D.19389 = D.19385 & 63;
  D.19390 = D.19389 << 8;
  D.19391 = ptr + 1;
  D.19392 = *D.19391;
  D.19393 = (int) D.19392;
  D.19394 = D.19390 | D.19393;
  len = (guint32) D.19394;
  ptr = ptr + 2;
  goto <D.19395>;
  <D.19388>:
  D.19385 = (int) b;
  D.19396 = D.19385 & 31;
  D.19397 = D.19396 << 24;
  D.19391 = ptr + 1;
  D.19392 = *D.19391;
  D.19393 = (int) D.19392;
  D.19398 = D.19393 << 16;
  D.19399 = D.19397 | D.19398;
  D.19400 = ptr + 2;
  D.19401 = *D.19400;
  D.19402 = (int) D.19401;
  D.19403 = D.19402 << 8;
  D.19404 = D.19399 | D.19403;
  D.19405 = ptr + 3;
  D.19406 = *D.19405;
  D.19407 = (int) D.19406;
  D.19408 = D.19404 | D.19407;
  len = (guint32) D.19408;
  ptr = ptr + 4;
  <D.19395>:
  <D.19384>:
  if (rptr != 0B) goto <D.19409>; else goto <D.19410>;
  <D.19409>:
  *rptr = ptr;
  <D.19410>:
  D.19411 = len;
  return D.19411;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.19413;
  unsigned int D.19414;
  int32_t D.19417;
  _Bool D.19424;
  long int D.19425;
  long int D.19426;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.19413 = uval >> 1;
  ival = (gint32) D.19413;
  D.19414 = uval & 1;
  if (D.19414 == 0) goto <D.19415>; else goto <D.19416>;
  <D.19415>:
  D.19417 = ival;
  return D.19417;
  <D.19416>:
  if (ival <= 63) goto <D.19418>; else goto <D.19419>;
  <D.19418>:
  D.19417 = ival + -64;
  return D.19417;
  <D.19419>:
  if (ival <= 8191) goto <D.19420>; else goto <D.19421>;
  <D.19420>:
  D.19417 = ival + -8192;
  return D.19417;
  <D.19421>:
  if (ival <= 268435455) goto <D.19422>; else goto <D.19423>;
  <D.19422>:
  D.19417 = ival + -268435456;
  return D.19417;
  <D.19423>:
  D.19424 = ival > 536870911;
  D.19425 = (long int) D.19424;
  D.19426 = __builtin_expect (D.19425, 0);
  if (D.19426 != 0) goto <D.19427>; else goto <D.19428>;
  <D.19427>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1121, "ival < 0x20000000");
  <D.19428>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.19417 = ival + -536870912;
  return D.19417;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  unsigned char D.19430;
  unsigned char D.19431;
  uint32_t D.19434;
  unsigned int D.19435;
  unsigned int D.19436;
  unsigned int D.19439;
  int D.19440;
  struct MonoTableInfo * D.19441;
  unsigned int D.19442;
  unsigned int D.19443;
  struct MonoTableInfo * D.19446;
  unsigned int D.19447;
  unsigned int D.19448;
  struct MonoTableInfo * D.19451;
  unsigned int D.19452;
  unsigned int D.19453;
  struct MonoTableInfo * D.19456;
  unsigned int D.19457;
  unsigned int D.19458;
  struct MonoTableInfo * D.19461;

  D.19430 = BIT_FIELD_REF <*image, 8, 128>;
  D.19431 = D.19430 & 32;
  if (D.19431 == 0) goto <D.19432>; else goto <D.19433>;
  <D.19432>:
  D.19434 = idx;
  return D.19434;
  <D.19433>:
  switch (table) <default: <D.17269>, case 4: <D.17265>, case 6: <D.17264>, case 8: <D.17268>, case 20: <D.17266>, case 23: <D.17267>>
  <D.17264>:
  D.19435 = BIT_FIELD_REF <*image, 32, 1312>;
  D.19436 = D.19435 & 16777215;
  if (D.19436 != 0) goto <D.19437>; else goto <D.19438>;
  <D.19437>:
  D.19439 = idx + 4294967295;
  D.19440 = (int) D.19439;
  D.19441 = &image->tables[5];
  D.19434 = mono_metadata_decode_row_col (D.19441, D.19440, 0);
  return D.19434;
  <D.19438>:
  D.19434 = idx;
  return D.19434;
  <D.17265>:
  D.19442 = BIT_FIELD_REF <*image, 32, 1120>;
  D.19443 = D.19442 & 16777215;
  if (D.19443 != 0) goto <D.19444>; else goto <D.19445>;
  <D.19444>:
  D.19439 = idx + 4294967295;
  D.19440 = (int) D.19439;
  D.19446 = &image->tables[3];
  D.19434 = mono_metadata_decode_row_col (D.19446, D.19440, 0);
  return D.19434;
  <D.19445>:
  D.19434 = idx;
  return D.19434;
  <D.17266>:
  D.19447 = BIT_FIELD_REF <*image, 32, 2656>;
  D.19448 = D.19447 & 16777215;
  if (D.19448 != 0) goto <D.19449>; else goto <D.19450>;
  <D.19449>:
  D.19439 = idx + 4294967295;
  D.19440 = (int) D.19439;
  D.19451 = &image->tables[19];
  D.19434 = mono_metadata_decode_row_col (D.19451, D.19440, 0);
  return D.19434;
  <D.19450>:
  D.19434 = idx;
  return D.19434;
  <D.17267>:
  D.19452 = BIT_FIELD_REF <*image, 32, 2944>;
  D.19453 = D.19452 & 16777215;
  if (D.19453 != 0) goto <D.19454>; else goto <D.19455>;
  <D.19454>:
  D.19439 = idx + 4294967295;
  D.19440 = (int) D.19439;
  D.19456 = &image->tables[22];
  D.19434 = mono_metadata_decode_row_col (D.19456, D.19440, 0);
  return D.19434;
  <D.19455>:
  D.19434 = idx;
  return D.19434;
  <D.17268>:
  D.19457 = BIT_FIELD_REF <*image, 32, 1504>;
  D.19458 = D.19457 & 16777215;
  if (D.19458 != 0) goto <D.19459>; else goto <D.19460>;
  <D.19459>:
  D.19439 = idx + 4294967295;
  D.19440 = (int) D.19439;
  D.19461 = &image->tables[7];
  D.19434 = mono_metadata_decode_row_col (D.19461, D.19440, 0);
  return D.19434;
  <D.19460>:
  D.19434 = idx;
  return D.19434;
  <D.17269>:
  D.19434 = idx;
  return D.19434;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  unsigned char D.19463;
  unsigned char D.19464;
  int D.19467;
  unsigned int D.19468;
  unsigned int D.19469;
  unsigned int D.19470;
  struct MonoTableInfo * D.19471;

  D.19463 = BIT_FIELD_REF <*image, 8, 128>;
  D.19464 = D.19463 & 32;
  if (D.19464 != 0) goto <D.19465>; else goto <D.19466>;
  <D.19465>:
  D.19467 = idx + 1;
  D.19468 = (unsigned int) D.19467;
  D.19469 = mono_metadata_translate_token_index (image, table, D.19468);
  D.19470 = D.19469 + 4294967295;
  idx = (int) D.19470;
  <D.19466>:
  D.19471 = &image->tables[table];
  mono_metadata_decode_row (D.19471, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  unsigned char D.19472;
  unsigned char D.19473;
  int D.19476;
  unsigned int D.19477;
  unsigned int D.19478;
  unsigned int D.19479;
  uint32_t D.19480;
  struct MonoTableInfo * D.19481;

  D.19472 = BIT_FIELD_REF <*image, 8, 128>;
  D.19473 = D.19472 & 32;
  if (D.19473 != 0) goto <D.19474>; else goto <D.19475>;
  <D.19474>:
  D.19476 = idx + 1;
  D.19477 = (unsigned int) D.19476;
  D.19478 = mono_metadata_translate_token_index (image, table, D.19477);
  D.19479 = D.19478 + 4294967295;
  idx = (int) D.19479;
  <D.19475>:
  D.19481 = &image->tables[table];
  D.19480 = mono_metadata_decode_row_col (D.19481, idx, col);
  return D.19480;
}


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

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


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.19488;
  unsigned char D.19489;
  unsigned char D.19490;
  _Bool D.19495;
  const char * D.19496;
  unsigned int D.19497;
  <unnamed-unsigned:31> D.19498;
  int D.19499;
  struct MonoCustomMod local;

  try
    {
      D.19488 = *ptr;
      D.19489 = (unsigned char) D.19488;
      D.19490 = D.19489 + 225;
      if (D.19490 <= 1) goto <D.19491>; else goto <D.19492>;
      <D.19491>:
      if (dest == 0B) goto <D.19493>; else goto <D.19494>;
      <D.19493>:
      dest = &local;
      <D.19494>:
      D.19488 = *ptr;
      D.19495 = D.19488 == 31;
      dest->required = D.19495;
      D.19496 = ptr + 1;
      D.19497 = mono_metadata_parse_typedef_or_ref (m, D.19496, rptr);
      D.19498 = (<unnamed-unsigned:31>) D.19497;
      dest->token = D.19498;
      D.19499 = 1;
      return D.19499;
      <D.19492>:
      D.19499 = 0;
      return D.19499;
    }
  finally
    {
      local = {CLOBBER};
    }
}


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

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


mono_metadata_parse_array_internal (struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  void * iftmp.52;
  const char * ptr.53;
  struct MonoArrayType * D.19511;
  struct MonoClass * D.19512;
  unsigned int D.19513;
  unsigned char D.19514;
  unsigned int D.19515;
  unsigned char D.19516;
  unsigned char D.19517;
  void * iftmp.54;
  unsigned int D.19523;
  unsigned int D.19524;
  int * D.19526;
  unsigned int i.55;
  unsigned int D.19528;
  int * D.19529;
  unsigned int D.19530;
  int D.19531;
  int D.19532;
  unsigned int D.19533;
  unsigned char D.19534;
  unsigned char D.19535;
  void * iftmp.56;
  unsigned int D.19541;
  unsigned int D.19542;
  int * D.19544;
  int * D.19545;
  int D.19546;
  int D.19547;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.19505>; else goto <D.19506>;
  <D.19505>:
  iftmp.52 = monoeg_malloc0 (16);
  goto <D.19507>;
  <D.19506>:
  iftmp.52 = mono_image_alloc0 (m, 16);
  <D.19507>:
  array = iftmp.52;
  ptr.53 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.53, &ptr);
  if (etype == 0B) goto <D.19509>; else goto <D.19510>;
  <D.19509>:
  D.19511 = 0B;
  return D.19511;
  <D.19510>:
  D.19512 = mono_class_from_mono_type (etype);
  array->eklass = D.19512;
  ptr.53 = ptr;
  D.19513 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19514 = (unsigned char) D.19513;
  array->rank = D.19514;
  ptr.53 = ptr;
  D.19515 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19516 = (unsigned char) D.19515;
  array->numsizes = D.19516;
  D.19517 = array->numsizes;
  if (D.19517 != 0) goto <D.19518>; else goto <D.19519>;
  <D.19518>:
  if (transient != 0) goto <D.19521>; else goto <D.19522>;
  <D.19521>:
  D.19517 = array->numsizes;
  D.19523 = (unsigned int) D.19517;
  D.19524 = D.19523 * 4;
  iftmp.54 = monoeg_malloc0 (D.19524);
  goto <D.19525>;
  <D.19522>:
  D.19517 = array->numsizes;
  D.19523 = (unsigned int) D.19517;
  D.19524 = D.19523 * 4;
  iftmp.54 = mono_image_alloc0 (m, D.19524);
  <D.19525>:
  array->sizes = iftmp.54;
  <D.19519>:
  i = 0;
  goto <D.17307>;
  <D.17306>:
  D.19526 = array->sizes;
  i.55 = (unsigned int) i;
  D.19528 = i.55 * 4;
  D.19529 = D.19526 + D.19528;
  ptr.53 = ptr;
  D.19530 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19531 = (int) D.19530;
  *D.19529 = D.19531;
  i = i + 1;
  <D.17307>:
  D.19517 = array->numsizes;
  D.19532 = (int) D.19517;
  if (D.19532 > i) goto <D.17306>; else goto <D.17308>;
  <D.17308>:
  ptr.53 = ptr;
  D.19533 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19534 = (unsigned char) D.19533;
  array->numlobounds = D.19534;
  D.19535 = array->numlobounds;
  if (D.19535 != 0) goto <D.19536>; else goto <D.19537>;
  <D.19536>:
  if (transient != 0) goto <D.19539>; else goto <D.19540>;
  <D.19539>:
  D.19535 = array->numlobounds;
  D.19541 = (unsigned int) D.19535;
  D.19542 = D.19541 * 4;
  iftmp.56 = monoeg_malloc0 (D.19542);
  goto <D.19543>;
  <D.19540>:
  D.19535 = array->numlobounds;
  D.19541 = (unsigned int) D.19535;
  D.19542 = D.19541 * 4;
  iftmp.56 = mono_image_alloc0 (m, D.19542);
  <D.19543>:
  array->lobounds = iftmp.56;
  <D.19537>:
  i = 0;
  goto <D.17310>;
  <D.17309>:
  D.19544 = array->lobounds;
  i.55 = (unsigned int) i;
  D.19528 = i.55 * 4;
  D.19545 = D.19544 + D.19528;
  ptr.53 = ptr;
  D.19546 = mono_metadata_decode_signed_value (ptr.53, &ptr);
  *D.19545 = D.19546;
  i = i + 1;
  <D.17310>:
  D.19535 = array->numlobounds;
  D.19547 = (int) D.19535;
  if (D.19547 > i) goto <D.17309>; else goto <D.17311>;
  <D.17311>:
  if (rptr != 0B) goto <D.19548>; else goto <D.19549>;
  <D.19548>:
  ptr.53 = ptr;
  *rptr = ptr.53;
  <D.19549>:
  D.19511 = array;
  return D.19511;
}


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

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


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.19553;
  int * D.19554;

  D.19553 = array->sizes;
  monoeg_g_free (D.19553);
  D.19554 = array->lobounds;
  monoeg_g_free (D.19554);
  monoeg_g_free (array);
}


mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.19555;
  unsigned int D.19556;
  <unnamed-unsigned:22> D.19557;
  int D.19558;
  guint D.19559;
  <unnamed-unsigned:1> D.19560;
  int D.19561;
  int D.19562;
  unsigned int D.19563;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.17350>;
  <D.17349>:
  hash = hash * 13;
  D.19555 = ginst->type_argv[i];
  D.19556 = mono_metadata_type_hash (D.19555);
  hash = D.19556 + hash;
  i = i + 1;
  <D.17350>:
  D.19557 = ginst->type_argc;
  D.19558 = (int) D.19557;
  if (D.19558 > i) goto <D.17349>; else goto <D.17351>;
  <D.17351>:
  D.19560 = ginst->is_open;
  D.19561 = (int) D.19560;
  D.19562 = D.19561 << 8;
  D.19563 = (unsigned int) D.19562;
  D.19559 = D.19563 ^ hash;
  return D.19559;
}


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

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


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.19567;
  unsigned int D.19570;
  gboolean D.19575;
  unsigned char D.19580;
  unsigned char D.19581;
  unsigned char D.19582;
  unsigned char D.19583;
  unsigned int D.19585;
  unsigned int D.19586;
  unsigned int D.19587;
  unsigned int D.19588;
  struct MonoType * D.19589;
  struct MonoType * D.19590;
  int D.19591;
  <unnamed-unsigned:22> D.19594;
  int D.19595;
  int i;

  D.19567 = a->id;
  if (D.19567 != 0) goto <D.19568>; else goto <D.19569>;
  <D.19568>:
  D.19570 = b->id;
  if (D.19570 != 0) goto <D.19571>; else goto <D.19572>;
  <D.19571>:
  D.19567 = a->id;
  D.19570 = b->id;
  if (D.19567 == D.19570) goto <D.19573>; else goto <D.19574>;
  <D.19573>:
  D.19575 = 1;
  return D.19575;
  <D.19574>:
  if (signature_only == 0) goto <D.19576>; else goto <D.19577>;
  <D.19576>:
  D.19575 = 0;
  return D.19575;
  <D.19577>:
  <D.19572>:
  <D.19569>:
  D.19580 = BIT_FIELD_REF <*a, 8, 48>;
  D.19581 = BIT_FIELD_REF <*b, 8, 48>;
  D.19582 = D.19580 ^ D.19581;
  D.19583 = D.19582 & 64;
  if (D.19583 != 0) goto <D.19578>; else goto <D.19584>;
  <D.19584>:
  D.19585 = BIT_FIELD_REF <*a, 32, 32>;
  D.19586 = BIT_FIELD_REF <*b, 32, 32>;
  D.19587 = D.19585 ^ D.19586;
  D.19588 = D.19587 & 4194303;
  if (D.19588 != 0) goto <D.19578>; else goto <D.19579>;
  <D.19578>:
  D.19575 = 0;
  return D.19575;
  <D.19579>:
  i = 0;
  goto <D.17359>;
  <D.17358>:
  D.19589 = b->type_argv[i];
  D.19590 = a->type_argv[i];
  D.19591 = do_mono_metadata_type_equal (D.19590, D.19589, signature_only);
  if (D.19591 == 0) goto <D.19592>; else goto <D.19593>;
  <D.19592>:
  D.19575 = 0;
  return D.19575;
  <D.19593>:
  i = i + 1;
  <D.17359>:
  D.19594 = a->type_argc;
  D.19595 = (int) D.19594;
  if (D.19595 > i) goto <D.17358>; else goto <D.17360>;
  <D.17360>:
  D.19575 = 1;
  return D.19575;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.19599;
  unsigned char D.19600;
  unsigned char D.19602;
  unsigned char D.19603;
  unsigned char D.19604;
  unsigned char D.19605;
  gboolean D.19606;
  int D.19607;
  struct MonoClass * D.19608;
  struct MonoClass * D.19609;
  struct MonoType * D.19610;
  struct MonoType * D.19611;
  struct MonoArrayType * D.19612;
  unsigned char D.19613;
  struct MonoArrayType * D.19614;
  unsigned char D.19615;
  struct MonoClass * D.19618;
  struct MonoClass * D.19619;
  struct MonoGenericClass * D.19620;
  struct MonoGenericClass * D.19621;
  struct MonoGenericParam * D.19622;
  struct MonoGenericParam * D.19623;
  struct MonoMethodSignature * D.19624;
  struct MonoMethodSignature * D.19625;

  D.19599 = t1->type;
  D.19600 = t2->type;
  if (D.19599 != D.19600) goto <D.19597>; else goto <D.19601>;
  <D.19601>:
  D.19602 = BIT_FIELD_REF <*t1, 8, 56>;
  D.19603 = BIT_FIELD_REF <*t2, 8, 56>;
  D.19604 = D.19602 ^ D.19603;
  D.19605 = D.19604 & 64;
  if (D.19605 != 0) goto <D.19597>; else goto <D.19598>;
  <D.19597>:
  D.19606 = 0;
  return D.19606;
  <D.19598>:
  D.19599 = t1->type;
  D.19607 = (int) D.19599;
  switch (D.19607) <default: <D.18469>, case 1: <D.18442>, case 2: <D.18443>, case 3: <D.18444>, case 4: <D.18445>, case 5: <D.18446>, case 6: <D.18447>, case 7: <D.18448>, case 8: <D.18449>, case 9: <D.18450>, case 10: <D.18451>, case 11: <D.18452>, case 12: <D.18453>, case 13: <D.18454>, case 14: <D.18455>, case 15: <D.18463>, case 17: <D.18460>, case 18: <D.18461>, case 19: <D.18466>, case 20: <D.18464>, case 21: <D.18465>, case 22: <D.18459>, case 24: <D.18456>, case 25: <D.18457>, case 27: <D.18468>, case 28: <D.18458>, case 29: <D.18462>, case 30: <D.18467>>
  <D.18442>:
  <D.18443>:
  <D.18444>:
  <D.18445>:
  <D.18446>:
  <D.18447>:
  <D.18448>:
  <D.18449>:
  <D.18450>:
  <D.18451>:
  <D.18452>:
  <D.18453>:
  <D.18454>:
  <D.18455>:
  <D.18456>:
  <D.18457>:
  <D.18458>:
  <D.18459>:
  D.19606 = 1;
  return D.19606;
  <D.18460>:
  <D.18461>:
  <D.18462>:
  D.19608 = t2->data.klass;
  D.19609 = t1->data.klass;
  D.19606 = mono_metadata_class_equal (D.19609, D.19608, signature_only);
  return D.19606;
  <D.18463>:
  D.19610 = t2->data.type;
  D.19611 = t1->data.type;
  D.19606 = do_mono_metadata_type_equal (D.19611, D.19610, signature_only);
  return D.19606;
  <D.18464>:
  D.19612 = t1->data.array;
  D.19613 = D.19612->rank;
  D.19614 = t2->data.array;
  D.19615 = D.19614->rank;
  if (D.19613 != D.19615) goto <D.19616>; else goto <D.19617>;
  <D.19616>:
  D.19606 = 0;
  return D.19606;
  <D.19617>:
  D.19614 = t2->data.array;
  D.19618 = D.19614->eklass;
  D.19612 = t1->data.array;
  D.19619 = D.19612->eklass;
  D.19606 = mono_metadata_class_equal (D.19619, D.19618, signature_only);
  return D.19606;
  <D.18465>:
  D.19620 = t2->data.generic_class;
  D.19621 = t1->data.generic_class;
  D.19606 = _mono_metadata_generic_class_equal (D.19621, D.19620, signature_only);
  return D.19606;
  <D.18466>:
  D.19622 = t2->data.generic_param;
  D.19623 = t1->data.generic_param;
  D.19606 = mono_metadata_generic_param_equal (D.19623, D.19622, signature_only);
  return D.19606;
  <D.18467>:
  D.19622 = t2->data.generic_param;
  D.19623 = t1->data.generic_param;
  D.19606 = mono_metadata_generic_param_equal (D.19623, D.19622, signature_only);
  return D.19606;
  <D.18468>:
  D.19624 = t2->data.method;
  D.19625 = t1->data.method;
  D.19606 = mono_metadata_fnptr_equal (D.19625, D.19624, signature_only);
  return D.19606;
  <D.18469>:
  D.19599 = t1->type;
  D.19607 = (int) D.19599;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.19607);
  <D.18470>:
  goto <D.18470>;
  D.19606 = 0;
  return D.19606;
  D.19606 = 0;
  return D.19606;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.19629;
  struct MonoGenericClass * D.19630;
  struct MonoGenericClass * D.19633;
  struct MonoGenericContainer * D.19638;
  struct MonoGenericContainer * D.19641;
  unsigned char D.19646;
  unsigned char D.19649;
  struct MonoGenericParam * D.19652;
  struct MonoGenericParam * D.19653;
  struct MonoClass * D.19664;
  struct MonoClass * D.19665;
  struct MonoType * D.19672;
  struct MonoType * D.19673;

  if (c1 == c2) goto <D.19627>; else goto <D.19628>;
  <D.19627>:
  D.19629 = 1;
  return D.19629;
  <D.19628>:
  D.19630 = c1->generic_class;
  if (D.19630 != 0B) goto <D.19631>; else goto <D.19632>;
  <D.19631>:
  D.19633 = c2->generic_class;
  if (D.19633 != 0B) goto <D.19634>; else goto <D.19635>;
  <D.19634>:
  D.19633 = c2->generic_class;
  D.19630 = c1->generic_class;
  D.19629 = _mono_metadata_generic_class_equal (D.19630, D.19633, signature_only);
  return D.19629;
  <D.19635>:
  <D.19632>:
  D.19630 = c1->generic_class;
  if (D.19630 != 0B) goto <D.19636>; else goto <D.19637>;
  <D.19636>:
  D.19638 = c2->generic_container;
  if (D.19638 != 0B) goto <D.19639>; else goto <D.19640>;
  <D.19639>:
  D.19630 = c1->generic_class;
  D.19629 = _mono_metadata_generic_class_container_equal (D.19630, c2, signature_only);
  return D.19629;
  <D.19640>:
  <D.19637>:
  D.19641 = c1->generic_container;
  if (D.19641 != 0B) goto <D.19642>; else goto <D.19643>;
  <D.19642>:
  D.19633 = c2->generic_class;
  if (D.19633 != 0B) goto <D.19644>; else goto <D.19645>;
  <D.19644>:
  D.19633 = c2->generic_class;
  D.19629 = _mono_metadata_generic_class_container_equal (D.19633, c1, signature_only);
  return D.19629;
  <D.19645>:
  <D.19643>:
  D.19646 = c1->byval_arg.type;
  if (D.19646 == 19) goto <D.19647>; else goto <D.19648>;
  <D.19647>:
  D.19649 = c2->byval_arg.type;
  if (D.19649 == 19) goto <D.19650>; else goto <D.19651>;
  <D.19650>:
  D.19652 = c2->byval_arg.data.generic_param;
  D.19653 = c1->byval_arg.data.generic_param;
  D.19629 = mono_metadata_generic_param_equal (D.19653, D.19652, signature_only);
  return D.19629;
  <D.19651>:
  <D.19648>:
  D.19646 = c1->byval_arg.type;
  if (D.19646 == 30) goto <D.19654>; else goto <D.19655>;
  <D.19654>:
  D.19649 = c2->byval_arg.type;
  if (D.19649 == 30) goto <D.19656>; else goto <D.19657>;
  <D.19656>:
  D.19652 = c2->byval_arg.data.generic_param;
  D.19653 = c1->byval_arg.data.generic_param;
  D.19629 = mono_metadata_generic_param_equal (D.19653, D.19652, signature_only);
  return D.19629;
  <D.19657>:
  <D.19655>:
  if (signature_only != 0) goto <D.19658>; else goto <D.19659>;
  <D.19658>:
  D.19646 = c1->byval_arg.type;
  if (D.19646 == 29) goto <D.19660>; else goto <D.19661>;
  <D.19660>:
  D.19649 = c2->byval_arg.type;
  if (D.19649 == 29) goto <D.19662>; else goto <D.19663>;
  <D.19662>:
  D.19664 = c2->byval_arg.data.klass;
  D.19665 = c1->byval_arg.data.klass;
  D.19629 = mono_metadata_class_equal (D.19665, D.19664, signature_only);
  return D.19629;
  <D.19663>:
  <D.19661>:
  <D.19659>:
  if (signature_only != 0) goto <D.19666>; else goto <D.19667>;
  <D.19666>:
  D.19646 = c1->byval_arg.type;
  if (D.19646 == 20) goto <D.19668>; else goto <D.19669>;
  <D.19668>:
  D.19649 = c2->byval_arg.type;
  if (D.19649 == 20) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  D.19672 = &c2->byval_arg;
  D.19673 = &c1->byval_arg;
  D.19629 = do_mono_metadata_type_equal (D.19673, D.19672, signature_only);
  return D.19629;
  <D.19671>:
  <D.19669>:
  <D.19667>:
  D.19629 = 0;
  return D.19629;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.19675;
  struct MonoClass * D.19676;
  int D.19677;
  gboolean D.19680;
  int D.19681;
  unsigned char D.19684;
  unsigned char D.19685;
  _Bool D.19686;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.19675 = c2->generic_container;
  i2 = D.19675->context.class_inst;
  D.19676 = g1->container_class;
  D.19677 = mono_metadata_class_equal (D.19676, c2, signature_only);
  if (D.19677 == 0) goto <D.19678>; else goto <D.19679>;
  <D.19678>:
  D.19680 = 0;
  return D.19680;
  <D.19679>:
  D.19681 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.19681 == 0) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  D.19680 = 0;
  return D.19680;
  <D.19683>:
  D.19684 = BIT_FIELD_REF <*g1, 8, 96>;
  D.19685 = D.19684 & 2;
  D.19686 = D.19685 == 0;
  D.19680 = (gboolean) D.19686;
  return D.19680;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  unsigned char D.19688;
  unsigned char D.19689;
  unsigned char D.19690;
  unsigned char D.19691;
  gboolean D.19694;
  struct MonoClass * D.19695;
  struct MonoClass * D.19696;
  int D.19697;
  int D.19700;
  unsigned char D.19703;
  _Bool D.19704;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.19688 = BIT_FIELD_REF <*g1, 8, 96>;
  D.19689 = BIT_FIELD_REF <*g2, 8, 96>;
  D.19690 = D.19688 ^ D.19689;
  D.19691 = D.19690 & 1;
  if (D.19691 != 0) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  D.19694 = 0;
  return D.19694;
  <D.19693>:
  D.19695 = g2->container_class;
  D.19696 = g1->container_class;
  D.19697 = mono_metadata_class_equal (D.19696, D.19695, signature_only);
  if (D.19697 == 0) goto <D.19698>; else goto <D.19699>;
  <D.19698>:
  D.19694 = 0;
  return D.19694;
  <D.19699>:
  D.19700 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.19700 == 0) goto <D.19701>; else goto <D.19702>;
  <D.19701>:
  D.19694 = 0;
  return D.19694;
  <D.19702>:
  D.19688 = BIT_FIELD_REF <*g1, 8, 96>;
  D.19689 = BIT_FIELD_REF <*g2, 8, 96>;
  D.19690 = D.19688 ^ D.19689;
  D.19703 = D.19690 & 2;
  D.19704 = D.19703 == 0;
  D.19694 = (gboolean) D.19704;
  return D.19694;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.19708;
  short unsigned int D.19709;
  short unsigned int D.19710;
  short unsigned int D.19713;
  short unsigned int D.19714;
  struct MonoGenericContainer * D.19719;
  struct MonoGenericContainer * D.19720;
  struct MonoImage * D.19724;
  struct MonoImage * D.19725;

  if (p1 == p2) goto <D.19706>; else goto <D.19707>;
  <D.19706>:
  D.19708 = 1;
  return D.19708;
  <D.19707>:
  D.19709 = p1->num;
  D.19710 = p2->num;
  if (D.19709 != D.19710) goto <D.19711>; else goto <D.19712>;
  <D.19711>:
  D.19708 = 0;
  return D.19708;
  <D.19712>:
  D.19713 = p1->serial;
  D.19714 = p2->serial;
  if (D.19713 != D.19714) goto <D.19715>; else goto <D.19716>;
  <D.19715>:
  D.19708 = 0;
  return D.19708;
  <D.19716>:
  D.19719 = p1->owner;
  D.19720 = p2->owner;
  if (D.19719 == D.19720) goto <D.19721>; else goto <D.19722>;
  <D.19721>:
  D.19719 = p1->owner;
  if (D.19719 != 0B) goto <D.19717>; else goto <D.19723>;
  <D.19723>:
  D.19724 = p1->image;
  D.19725 = p2->image;
  if (D.19724 == D.19725) goto <D.19717>; else goto <D.19718>;
  <D.19717>:
  D.19708 = 1;
  return D.19708;
  <D.19718>:
  <D.19722>:
  D.19708 = signature_only;
  return D.19708;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.19729;
  unsigned char D.19730;
  unsigned char D.19731;
  unsigned char D.19732;
  unsigned char D.19733;
  short int D.19736;
  short int D.19737;
  unsigned char D.19740;
  signed char D.19743;
  struct MonoType * D.19746;
  struct MonoType * D.19747;
  int D.19748;
  short unsigned int D.19751;
  short unsigned int D.19752;
  _Bool D.19755;
  _Bool D.19756;
  _Bool D.19757;
  _Bool D.19760;
  int D.19761;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.19727>; else goto <D.19728>;
      <D.19727>:
      D.19729 = 1;
      return D.19729;
      <D.19728>:
      D.19730 = BIT_FIELD_REF <*s1, 8, 80>;
      D.19731 = BIT_FIELD_REF <*s2, 8, 80>;
      D.19732 = D.19730 ^ D.19731;
      D.19733 = D.19732 & 63;
      if (D.19733 != 0) goto <D.19734>; else goto <D.19735>;
      <D.19734>:
      D.19729 = 0;
      return D.19729;
      <D.19735>:
      D.19736 = s1->sentinelpos;
      D.19737 = s2->sentinelpos;
      if (D.19736 != D.19737) goto <D.19738>; else goto <D.19739>;
      <D.19738>:
      D.19729 = 0;
      return D.19729;
      <D.19739>:
      D.19730 = BIT_FIELD_REF <*s1, 8, 80>;
      D.19731 = BIT_FIELD_REF <*s2, 8, 80>;
      D.19732 = D.19730 ^ D.19731;
      D.19740 = D.19732 & 64;
      if (D.19740 != 0) goto <D.19741>; else goto <D.19742>;
      <D.19741>:
      D.19729 = 0;
      return D.19729;
      <D.19742>:
      D.19730 = BIT_FIELD_REF <*s1, 8, 80>;
      D.19731 = BIT_FIELD_REF <*s2, 8, 80>;
      D.19732 = D.19730 ^ D.19731;
      D.19743 = (signed char) D.19732;
      if (D.19743 < 0) goto <D.19744>; else goto <D.19745>;
      <D.19744>:
      D.19729 = 0;
      return D.19729;
      <D.19745>:
      D.19746 = s2->ret;
      D.19747 = s1->ret;
      D.19748 = do_mono_metadata_type_equal (D.19747, D.19746, signature_only);
      if (D.19748 == 0) goto <D.19749>; else goto <D.19750>;
      <D.19749>:
      D.19729 = 0;
      return D.19729;
      <D.19750>:
      D.19751 = s1->param_count;
      D.19752 = s2->param_count;
      if (D.19751 != D.19752) goto <D.19753>; else goto <D.19754>;
      <D.19753>:
      D.19729 = 0;
      return D.19729;
      <D.19754>:
      <D.18436>:
      {
        struct MonoType * t1;
        struct MonoType * t2;

        t1 = mono_signature_get_params (s1, &iter1);
        t2 = mono_signature_get_params (s2, &iter2);
        D.19755 = t1 == 0B;
        D.19756 = t2 == 0B;
        D.19757 = D.19755 | D.19756;
        if (D.19757 != 0) goto <D.19758>; else goto <D.19759>;
        <D.19758>:
        D.19760 = t1 == t2;
        D.19729 = (gboolean) D.19760;
        return D.19729;
        <D.19759>:
        D.19761 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.19761 == 0) goto <D.19762>; else goto <D.19763>;
        <D.19762>:
        D.19729 = 0;
        return D.19729;
        <D.19763>:
      }
      goto <D.18436>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


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

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


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.19772;
  unsigned char D.19773;
  unsigned char D.19775;
  unsigned char D.19776;
  unsigned char D.19777;
  unsigned char D.19778;
  short unsigned int D.19780;
  short unsigned int D.19781;
  signed char D.19783;
  gint D.19784;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.19772 = a->type;
  D.19773 = b->type;
  if (D.19772 != D.19773) goto <D.19770>; else goto <D.19774>;
  <D.19774>:
  D.19775 = BIT_FIELD_REF <*a, 8, 56>;
  D.19776 = BIT_FIELD_REF <*b, 8, 56>;
  D.19777 = D.19775 ^ D.19776;
  D.19778 = D.19777 & 64;
  if (D.19778 != 0) goto <D.19770>; else goto <D.19779>;
  <D.19779>:
  D.19780 = a->attrs;
  D.19781 = b->attrs;
  if (D.19780 != D.19781) goto <D.19770>; else goto <D.19782>;
  <D.19782>:
  D.19775 = BIT_FIELD_REF <*a, 8, 56>;
  D.19776 = BIT_FIELD_REF <*b, 8, 56>;
  D.19777 = D.19775 ^ D.19776;
  D.19783 = (signed char) D.19777;
  if (D.19783 < 0) goto <D.19770>; else goto <D.19771>;
  <D.19770>:
  D.19784 = 0;
  return D.19784;
  <D.19771>:
  D.19784 = 1;
  return D.19784;
}


mono_type_hash (const void * data)
{
  unsigned char D.19786;
  guint D.19789;
  struct MonoGenericClass * D.19790;
  int D.19791;
  <unnamed-unsigned:1> D.19792;
  int D.19793;
  int D.19794;
  int D.19795;
  short unsigned int D.19796;
  int D.19797;
  int D.19798;
  int D.19799;
  const struct MonoType * type;

  type = data;
  D.19786 = type->type;
  if (D.19786 == 21) goto <D.19787>; else goto <D.19788>;
  <D.19787>:
  D.19790 = type->data.generic_class;
  D.19789 = mono_generic_class_hash (D.19790);
  return D.19789;
  <D.19788>:
  D.19786 = type->type;
  D.19791 = (int) D.19786;
  D.19792 = type->byref;
  D.19793 = (int) D.19792;
  D.19794 = D.19793 << 8;
  D.19795 = D.19791 | D.19794;
  D.19796 = type->attrs;
  D.19797 = (int) D.19796;
  D.19798 = D.19797 << 9;
  D.19799 = D.19795 | D.19798;
  D.19789 = (guint) D.19799;
  return D.19789;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.19801;
  struct MonoType * D.19802;
  <unnamed-unsigned:1> D.19803;
  unsigned int D.19804;
  const struct MonoGenericContext * D.19805;
  unsigned int D.19806;
  guint D.19807;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.19801 = gclass->container_class;
  D.19802 = &D.19801->byval_arg;
  hash = mono_metadata_type_hash (D.19802);
  hash = hash * 13;
  D.19803 = gclass->is_tb_open;
  D.19804 = (unsigned int) D.19803;
  hash = D.19804 + hash;
  D.19805 = &gclass->context;
  D.19806 = mono_metadata_generic_context_hash (D.19805);
  hash = D.19806 + hash;
  D.19807 = hash;
  return D.19807;
}


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

  type_cache.60 = type_cache;
  monoeg_g_hash_table_destroy (type_cache.60);
  type_cache = 0B;
  image_sets.61 = image_sets;
  monoeg_g_ptr_array_free (image_sets.61, 1);
  image_sets = 0B;
}


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

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


mono_metadata_parse_type_internal (struct MonoImage * m, struct MonoGenericContainer * container, MonoParseTypeMode mode, short int opt_attrs, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.62;
  const char * tmp_ptr.63;
  char D.19816;
  int D.19817;
  const char * tmp_ptr.64;
  unsigned int count.65;
  unsigned int D.19822;
  unsigned int D.19823;
  void * iftmp.66;
  unsigned int size.67;
  unsigned int size.68;
  unsigned char D.19830;
  <unnamed-unsigned:6> D.19831;
  char D.19835;
  int D.19836;
  const char * ptr.69;
  struct MonoCustomMod * D.19838;
  short unsigned int opt_attrs.70;
  unsigned char D.19840;
  <unnamed-unsigned:1> D.19841;
  _Bool D.19842;
  int D.19843;
  struct MonoType * D.19846;
  unsigned char D.19849;
  unsigned char D.19850;
  unsigned char D.19855;
  unsigned char D.19856;
  unsigned int D.19859;
  unsigned int D.19860;
  struct MonoType * iftmp.71;
  unsigned char D.19864;
  struct MonoClass * D.19867;
  struct MonoClass * D.19869;
  struct GHashTable * type_cache.72;
  void * iftmp.73;
  struct MonoType * type;
  struct MonoType * cached;
  struct MonoType stype;
  gboolean byref;
  gboolean pinned;
  const char * tmp_ptr;
  int count;
  gboolean found;

  try
    {
      byref = 0;
      pinned = 0;
      count = 0;
      ptr.62 = ptr;
      tmp_ptr = ptr.62;
      found = 1;
      goto <D.17412>;
      <D.17411>:
      tmp_ptr.63 = tmp_ptr;
      D.19816 = *tmp_ptr.63;
      D.19817 = (int) D.19816;
      switch (D.19817) <default: <D.17410>, case 16: <D.17406>, case 31: <D.17408>, case 32: <D.17409>, case 69: <D.17405>>
      <D.17405>:
      <D.17406>:
      tmp_ptr.63 = tmp_ptr;
      tmp_ptr.64 = tmp_ptr.63 + 1;
      tmp_ptr = tmp_ptr.64;
      goto <D.17407>;
      <D.17408>:
      <D.17409>:
      count = count + 1;
      tmp_ptr.63 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.63, &tmp_ptr);
      goto <D.17407>;
      <D.17410>:
      found = 0;
      <D.17407>:
      <D.17412>:
      if (found != 0) goto <D.17411>; else goto <D.17413>;
      <D.17413>:
      if (count != 0) goto <D.19819>; else goto <D.19820>;
      <D.19819>:
      {
        int size;

        count.65 = (unsigned int) count;
        D.19822 = count.65 + 2;
        D.19823 = D.19822 * 4;
        size = (int) D.19823;
        if (transient != 0) goto <D.19825>; else goto <D.19826>;
        <D.19825>:
        size.67 = (unsigned int) size;
        iftmp.66 = monoeg_malloc0 (size.67);
        goto <D.19828>;
        <D.19826>:
        size.68 = (unsigned int) size;
        iftmp.66 = mono_image_alloc0 (m, size.68);
        <D.19828>:
        type = iftmp.66;
        D.19830 = (unsigned char) count;
        D.19831 = (<unnamed-unsigned:6>) D.19830;
        type->num_mods = D.19831;
        if (count > 64) goto <D.19832>; else goto <D.19833>;
        <D.19832>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.19833>:
      }
      goto <D.19834>;
      <D.19820>:
      type = &stype;
      memset (type, 0, 8);
      <D.19834>:
      found = 1;
      count = 0;
      goto <D.17422>;
      <D.17421>:
      ptr.62 = ptr;
      D.19835 = *ptr.62;
      D.19836 = (int) D.19835;
      switch (D.19836) <default: <D.17420>, case 16: <D.17417>, case 31: <D.17418>, case 32: <D.17419>, case 69: <D.17415>>
      <D.17415>:
      pinned = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.17416>;
      <D.17417>:
      byref = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.17416>;
      <D.17418>:
      <D.17419>:
      ptr.62 = ptr;
      D.19838 = &type->modifiers[count];
      mono_metadata_parse_custom_mod (m, D.19838, ptr.62, &ptr);
      count = count + 1;
      goto <D.17416>;
      <D.17420>:
      found = 0;
      <D.17416>:
      <D.17422>:
      if (found != 0) goto <D.17421>; else goto <D.17423>;
      <D.17423>:
      opt_attrs.70 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.70;
      D.19840 = (unsigned char) byref;
      D.19841 = (<unnamed-unsigned:1>) D.19840;
      type->byref = D.19841;
      D.19842 = pinned != 0;
      type->pinned = D.19842;
      ptr.62 = ptr;
      D.19843 = do_mono_metadata_parse_type (type, m, container, transient, ptr.62, &ptr);
      if (D.19843 == 0) goto <D.19844>; else goto <D.19845>;
      <D.19844>:
      D.19846 = 0B;
      return D.19846;
      <D.19845>:
      if (rptr != 0B) goto <D.19847>; else goto <D.19848>;
      <D.19847>:
      ptr.62 = ptr;
      *rptr = ptr.62;
      <D.19848>:
      D.19849 = BIT_FIELD_REF <*type, 8, 56>;
      D.19850 = D.19849 & 63;
      if (D.19850 == 0) goto <D.19851>; else goto <D.19852>;
      <D.19851>:
      if (transient == 0) goto <D.19853>; else goto <D.19854>;
      <D.19853>:
      D.19855 = type->type;
      D.19856 = D.19855 + 239;
      if (D.19856 <= 1) goto <D.19857>; else goto <D.19858>;
      <D.19857>:
      D.19859 = BIT_FIELD_REF <*type, 32, 32>;
      D.19860 = D.19859 & 2147549183;
      if (D.19860 == 0) goto <D.19861>; else goto <D.19862>;
      <D.19861>:
      {
        struct MonoType * ret;

        D.19849 = BIT_FIELD_REF <*type, 8, 56>;
        D.19864 = D.19849 & 64;
        if (D.19864 != 0) goto <D.19865>; else goto <D.19866>;
        <D.19865>:
        D.19867 = type->data.klass;
        iftmp.71 = &D.19867->this_arg;
        goto <D.19868>;
        <D.19866>:
        D.19867 = type->data.klass;
        iftmp.71 = &D.19867->byval_arg;
        <D.19868>:
        ret = iftmp.71;
        D.19869 = ret->data.klass;
        D.19867 = type->data.klass;
        if (D.19869 == D.19867) goto <D.19870>; else goto <D.19871>;
        <D.19870>:
        D.19846 = ret;
        return D.19846;
        <D.19871>:
      }
      <D.19862>:
      <D.19858>:
      type_cache.72 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.72, type);
      if (cached != 0B) goto <D.19873>; else goto <D.19874>;
      <D.19873>:
      D.19846 = cached;
      return D.19846;
      <D.19874>:
      <D.19854>:
      <D.19852>:
      if (&stype == type) goto <D.19875>; else goto <D.19876>;
      <D.19875>:
      if (transient != 0) goto <D.19878>; else goto <D.19879>;
      <D.19878>:
      iftmp.73 = monoeg_malloc (8);
      goto <D.19880>;
      <D.19879>:
      iftmp.73 = mono_image_alloc (m, 8);
      <D.19880>:
      type = iftmp.73;
      memcpy (type, &stype, 8);
      <D.19876>:
      D.19846 = type;
      return D.19846;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.19885;
  int D.19890;
  void * D.19892;
  unsigned int D.19893;

  D.19885 = __builtin_constant_p (__len);
  if (D.19885 != 0) goto <D.19886>; else goto <D.19887>;
  <D.19886>:
  if (__len == 0) goto <D.19888>; else goto <D.19889>;
  <D.19888>:
  D.19890 = __builtin_constant_p (__ch);
  if (D.19890 == 0) goto <D.19883>; else goto <D.19891>;
  <D.19891>:
  if (__ch != 0) goto <D.19883>; else goto <D.19884>;
  <D.19883>:
  __warn_memset_zero_len ();
  D.19892 = __dest;
  return D.19892;
  <D.19884>:
  <D.19889>:
  <D.19887>:
  D.19893 = __builtin_object_size (__dest, 0);
  D.19892 = __builtin___memset_chk (__dest, __ch, __len, D.19893);
  return D.19892;
}


do_mono_metadata_parse_type (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.74;
  unsigned int D.19896;
  unsigned char D.19897;
  unsigned char D.19898;
  int D.19899;
  gboolean D.19902;
  unsigned char D.19903;
  int D.19904;
  int D.19905;
  struct MonoClass * D.19910;
  struct MonoClass * D.19911;
  struct MonoType * D.19914;
  struct MonoType * D.19915;
  struct MonoMethodSignature * D.19918;
  struct MonoMethodSignature * D.19919;
  struct MonoArrayType * D.19922;
  struct MonoArrayType * D.19923;
  unsigned char D.19928;
  unsigned char D.19929;
  <unnamed type> D.19932;
  struct MonoGenericParam * D.19933;
  struct MonoGenericParam * D.19934;
  char * D.19937;
  gboolean ok;

  ok = 1;
  ptr.74 = ptr;
  D.19896 = mono_metadata_decode_value (ptr.74, &ptr);
  D.19897 = (unsigned char) D.19896;
  type->type = D.19897;
  D.19898 = type->type;
  D.19899 = (int) D.19898;
  switch (D.19899) <default: <D.17976>, case 1: <D.17945>, case 2: <D.17946>, case 3: <D.17947>, case 4: <D.17948>, case 5: <D.17949>, case 6: <D.17950>, case 7: <D.17951>, case 8: <D.17952>, case 9: <D.17953>, case 10: <D.17954>, case 11: <D.17955>, case 12: <D.17956>, case 13: <D.17957>, case 14: <D.17960>, case 15: <D.17970>, case 17: <D.17964>, case 18: <D.17965>, case 19: <D.17974>, case 20: <D.17972>, case 21: <D.17975>, case 22: <D.17962>, case 24: <D.17958>, case 25: <D.17959>, case 27: <D.17971>, case 28: <D.17961>, case 29: <D.17968>, case 30: <D.17973>>
  <D.17945>:
  <D.17946>:
  <D.17947>:
  <D.17948>:
  <D.17949>:
  <D.17950>:
  <D.17951>:
  <D.17952>:
  <D.17953>:
  <D.17954>:
  <D.17955>:
  <D.17956>:
  <D.17957>:
  <D.17958>:
  <D.17959>:
  <D.17960>:
  <D.17961>:
  <D.17962>:
  goto <D.17963>;
  <D.17964>:
  <D.17965>:
  {
    guint32 token;
    struct MonoClass * class;

    ptr.74 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.74, &ptr);
    class = mono_class_get (m, token);
    type->data.klass = class;
    if (class == 0B) goto <D.19900>; else goto <D.19901>;
    <D.19900>:
    D.19902 = 0;
    return D.19902;
    <D.19901>:
    D.19898 = type->type;
    D.19899 = (int) D.19898;
    D.19903 = class->byval_arg.type;
    D.19904 = (int) D.19903;
    D.19905 = compare_type_literals (D.19904, D.19899);
    if (D.19905 == 0) goto <D.19906>; else goto <D.19907>;
    <D.19906>:
    D.19902 = 0;
    return D.19902;
    <D.19907>:
    goto <D.17963>;
  }
  <D.17968>:
  {
    struct MonoType * etype;

    ptr.74 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.74, &ptr);
    if (etype == 0B) goto <D.19908>; else goto <D.19909>;
    <D.19908>:
    D.19902 = 0;
    return D.19902;
    <D.19909>:
    D.19910 = mono_class_from_mono_type (etype);
    type->data.klass = D.19910;
    D.19911 = type->data.klass;
    if (D.19911 == 0B) goto <D.19912>; else goto <D.19913>;
    <D.19912>:
    D.19902 = 0;
    return D.19902;
    <D.19913>:
    goto <D.17963>;
  }
  <D.17970>:
  ptr.74 = ptr;
  D.19914 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.74, &ptr);
  type->data.type = D.19914;
  D.19915 = type->data.type;
  if (D.19915 == 0B) goto <D.19916>; else goto <D.19917>;
  <D.19916>:
  D.19902 = 0;
  return D.19902;
  <D.19917>:
  goto <D.17963>;
  <D.17971>:
  ptr.74 = ptr;
  D.19918 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.74, &ptr);
  type->data.method = D.19918;
  D.19919 = type->data.method;
  if (D.19919 == 0B) goto <D.19920>; else goto <D.19921>;
  <D.19920>:
  D.19902 = 0;
  return D.19902;
  <D.19921>:
  goto <D.17963>;
  <D.17972>:
  ptr.74 = ptr;
  D.19922 = mono_metadata_parse_array_internal (m, container, transient, ptr.74, &ptr);
  type->data.array = D.19922;
  D.19923 = type->data.array;
  if (D.19923 == 0B) goto <D.19924>; else goto <D.19925>;
  <D.19924>:
  D.19902 = 0;
  return D.19902;
  <D.19925>:
  goto <D.17963>;
  <D.17973>:
  if (container != 0B) goto <D.19926>; else goto <D.19927>;
  <D.19926>:
  D.19928 = BIT_FIELD_REF <*container, 8, 152>;
  D.19929 = D.19928 & 128;
  if (D.19929 == 0) goto <D.19930>; else goto <D.19931>;
  <D.19930>:
  D.19902 = 0;
  return D.19902;
  <D.19931>:
  <D.19927>:
  <D.17974>:
  ptr.74 = ptr;
  D.19898 = type->type;
  D.19932 = (<unnamed type>) D.19898;
  D.19933 = mono_metadata_parse_generic_param (m, container, D.19932, ptr.74, &ptr);
  type->data.generic_param = D.19933;
  D.19934 = type->data.generic_param;
  if (D.19934 == 0B) goto <D.19935>; else goto <D.19936>;
  <D.19935>:
  D.19902 = 0;
  return D.19902;
  <D.19936>:
  goto <D.17963>;
  <D.17975>:
  ptr.74 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.74, &ptr);
  goto <D.17963>;
  <D.17976>:
  D.19937 = m->name;
  D.19898 = type->type;
  D.19899 = (int) D.19898;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.19899, D.19937);
  D.19902 = 0;
  return D.19902;
  <D.17963>:
  if (rptr != 0B) goto <D.19938>; else goto <D.19939>;
  <D.19938>:
  ptr.74 = ptr;
  *rptr = ptr.74;
  <D.19939>:
  D.19902 = ok;
  return D.19902;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.19944;
  _Bool D.19947;
  _Bool D.19948;
  _Bool D.19949;
  _Bool D.19952;

  if (class_type == 0) goto <D.19942>; else goto <D.19943>;
  <D.19942>:
  D.19944 = 1;
  return D.19944;
  <D.19943>:
  if (type_type == 18) goto <D.19945>; else goto <D.19946>;
  <D.19945>:
  D.19947 = class_type == 14;
  D.19948 = class_type == 28;
  D.19949 = D.19947 | D.19948;
  if (D.19949 != 0) goto <D.19950>; else goto <D.19951>;
  <D.19950>:
  D.19944 = 1;
  return D.19944;
  <D.19951>:
  <D.19946>:
  D.19952 = class_type == type_type;
  D.19944 = (gboolean) D.19952;
  return D.19944;
}


mono_metadata_parse_generic_param (struct MonoImage * m, struct MonoGenericContainer * generic_container, MonoTypeEnum type, const char * ptr, const char * * rptr)
{
  const char * ptr.75;
  unsigned int D.19955;
  short unsigned int D.19960;
  struct MonoGenericParam * D.19961;
  <unnamed-signed:31> D.19962;
  int D.19963;
  struct MonoGenericParamFull * D.19966;
  unsigned int index.76;
  unsigned int D.19968;
  int index;

  ptr.75 = ptr;
  D.19955 = mono_metadata_decode_value (ptr.75, &ptr);
  index = (int) D.19955;
  if (rptr != 0B) goto <D.19956>; else goto <D.19957>;
  <D.19956>:
  ptr.75 = ptr;
  *rptr = ptr.75;
  <D.19957>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.19958>; else goto <D.19959>;
  <D.19958>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 12);
    D.19960 = (short unsigned int) index;
    param->num = D.19960;
    param->image = m;
    D.19961 = param;
    return D.19961;
  }
  <D.19959>:
  D.19962 = generic_container->type_argc;
  D.19963 = (int) D.19962;
  if (D.19963 <= index) goto <D.19964>; else goto <D.19965>;
  <D.19964>:
  D.19961 = 0B;
  return D.19961;
  <D.19965>:
  D.19966 = generic_container->type_params;
  index.76 = (unsigned int) index;
  D.19968 = index.76 * 32;
  D.19961 = D.19966 + D.19968;
  return D.19961;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.19970;
  struct MonoGenericContainer * D.19973;
  _Bool D.19974;
  _Bool D.19975;
  _Bool D.19976;
  int D.19977;
  _Bool D.19978;
  long int D.19979;
  long int D.19980;
  unsigned char D.19987;
  unsigned char D.19988;
  struct MonoGenericContainer * D.19990;
  gboolean is_var;

  D.19970 = type == 19;
  is_var = (gboolean) D.19970;
  if (gc == 0B) goto <D.19971>; else goto <D.19972>;
  <D.19971>:
  D.19973 = 0B;
  return D.19973;
  <D.19972>:
  D.19974 = is_var == 0;
  D.19975 = type != 30;
  D.19976 = D.19974 & D.19975;
  D.19977 = (int) D.19976;
  D.19978 = D.19977 != 0;
  D.19979 = (long int) D.19978;
  D.19980 = __builtin_expect (D.19979, 0);
  if (D.19980 != 0) goto <D.19981>; else goto <D.19982>;
  <D.19981>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.19982>:
  if (is_var != 0) goto <D.19983>; else goto <D.19984>;
  <D.19983>:
  D.19987 = BIT_FIELD_REF <*gc, 8, 152>;
  D.19988 = D.19987 & 128;
  if (D.19988 != 0) goto <D.19985>; else goto <D.19989>;
  <D.19989>:
  D.19990 = gc->parent;
  if (D.19990 != 0B) goto <D.19985>; else goto <D.19986>;
  <D.19985>:
  D.19973 = gc->parent;
  return D.19973;
  <D.19986>:
  <D.19984>:
  D.19973 = gc;
  return D.19973;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.77;
  gboolean D.19995;
  struct MonoGenericContainer * D.19996;
  unsigned int D.19999;
  struct MonoGenericClass * D.20004;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.77 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.77, &ptr);
  if (gtype == 0B) goto <D.19993>; else goto <D.19994>;
  <D.19993>:
  D.19995 = 0;
  return D.19995;
  <D.19994>:
  gklass = mono_class_from_mono_type (gtype);
  D.19996 = gklass->generic_container;
  if (D.19996 == 0B) goto <D.19997>; else goto <D.19998>;
  <D.19997>:
  D.19995 = 0;
  return D.19995;
  <D.19998>:
  ptr.77 = ptr;
  D.19999 = mono_metadata_decode_value (ptr.77, &ptr);
  count = (int) D.19999;
  ptr.77 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.77, &ptr);
  if (inst == 0B) goto <D.20000>; else goto <D.20001>;
  <D.20000>:
  D.19995 = 0;
  return D.19995;
  <D.20001>:
  if (rptr != 0B) goto <D.20002>; else goto <D.20003>;
  <D.20002>:
  ptr.77 = ptr;
  *rptr = ptr.77;
  <D.20003>:
  D.20004 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.20004;
  D.19995 = 1;
  return D.19995;
}


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

  D.20007 = __builtin_object_size (__dest, 0);
  D.20006 = __builtin___memcpy_chk (__dest, __src, __len, D.20007);
  return D.20006;
}


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

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


mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.20012;
  <unnamed-unsigned:24> D.20013;
  int D.20014;
  <unnamed-unsigned:24> D.20018;
  int D.20019;
  int D.20020;
  unsigned int D.20021;
  int D.20022;
  gboolean D.20025;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.20012 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.20012, 5);
  D.20013 = methodt->rows;
  D.20014 = (int) D.20013;
  if (D.20014 > def) goto <D.20015>; else goto <D.20016>;
  <D.20015>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.20017>;
  <D.20016>:
  D.20018 = m->tables[8].rows;
  D.20019 = (int) D.20018;
  D.20020 = D.20019 + 1;
  lastp = (guint) D.20020;
  <D.20017>:
  i = param_index;
  goto <D.17451>;
  <D.17450>:
  {
    guint32 flags;

    D.20021 = i + 4294967295;
    D.20022 = (int) D.20021;
    flags = mono_metadata_decode_row_col (paramt, D.20022, 0);
    if (flags != 0) goto <D.20023>; else goto <D.20024>;
    <D.20023>:
    D.20025 = 1;
    return D.20025;
    <D.20024>:
  }
  i = i + 1;
  <D.17451>:
  if (i < lastp) goto <D.17450>; else goto <D.17452>;
  <D.17452>:
  D.20025 = 0;
  return D.20025;
}


mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.20027;
  <unnamed-unsigned:24> D.20028;
  int D.20029;
  <unnamed-unsigned:24> D.20033;
  int D.20034;
  int D.20035;
  unsigned int D.20036;
  int D.20037;
  unsigned int D.20038;
  unsigned int param_count.78;
  unsigned int D.20044;
  unsigned int D.20045;
  unsigned int param_count.79;
  unsigned int D.20049;
  int * D.20050;
  int D.20051;
  int * D.20052;
  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.20027 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.20027, 5);
      pattrs = 0B;
      D.20028 = methodt->rows;
      D.20029 = (int) D.20028;
      if (D.20029 > def) goto <D.20030>; else goto <D.20031>;
      <D.20030>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.20032>;
      <D.20031>:
      D.20033 = paramt->rows;
      D.20034 = (int) D.20033;
      D.20035 = D.20034 + 1;
      lastp = (guint) D.20035;
      <D.20032>:
      i = param_index;
      goto <D.17467>;
      <D.17466>:
      D.20036 = i + 4294967295;
      D.20037 = (int) D.20036;
      mono_metadata_decode_row (paramt, D.20037, &cols, 3);
      D.20038 = cols[0];
      if (D.20038 != 0) goto <D.20039>; else goto <D.20040>;
      <D.20039>:
      if (pattrs == 0B) goto <D.20041>; else goto <D.20042>;
      <D.20041>:
      param_count.78 = (unsigned int) param_count;
      D.20044 = param_count.78 * 4;
      pattrs = monoeg_malloc0 (D.20044);
      <D.20042>:
      D.20045 = cols[1];
      param_count.79 = (unsigned int) param_count;
      if (D.20045 >= param_count.79) goto <D.20047>; else goto <D.20048>;
      <D.20047>:
      // predicted unlikely by continue predictor.
      goto <D.17465>;
      <D.20048>:
      D.20045 = cols[1];
      D.20049 = D.20045 * 4;
      D.20050 = pattrs + D.20049;
      D.20038 = cols[0];
      D.20051 = (int) D.20038;
      *D.20050 = D.20051;
      <D.20040>:
      <D.17465>:
      i = i + 1;
      <D.17467>:
      if (i < lastp) goto <D.17466>; else goto <D.17468>;
      <D.17468>:
      D.20052 = pattrs;
      return D.20052;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  unsigned char D.20055;
  unsigned char D.20056;
  struct MonoMethodSignature * D.20059;
  unsigned int D.20060;
  _Bool D.20061;
  long int D.20062;
  long int D.20063;
  unsigned int D.20066;
  int D.20067;
  const struct MonoTableInfo * D.20068;
  const char * ptr.80;
  const char * ptr.81;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.20055 = BIT_FIELD_REF <*image, 8, 128>;
      D.20056 = D.20055 & 8;
      if (D.20056 != 0) goto <D.20057>; else goto <D.20058>;
      <D.20057>:
      D.20059 = mono_lookup_dynamic_token (image, token, 0B);
      return D.20059;
      <D.20058>:
      D.20060 = token >> 24;
      D.20061 = D.20060 != 17;
      D.20062 = (long int) D.20061;
      D.20063 = __builtin_expect (D.20062, 0);
      if (D.20063 != 0) goto <D.20064>; else goto <D.20065>;
      <D.20064>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.20065>:
      D.20066 = idx + 4294967295;
      D.20067 = (int) D.20066;
      D.20068 = tables + 204;
      sig = mono_metadata_decode_row_col (D.20068, D.20067, 0);
      ptr.80 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.80;
      ptr.81 = ptr;
      mono_metadata_decode_blob_size (ptr.81, &ptr);
      ptr.81 = ptr;
      D.20059 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.81, 0B);
      return D.20059;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  unsigned int D.20075;
  unsigned int D.20076;
  short unsigned int D.20077;
  struct MonoMethodSignature * D.20078;
  struct MonoMethodSignature * sig;

  D.20075 = nparams + 3;
  D.20076 = D.20075 * 4;
  sig = mono_image_alloc0 (m, D.20076);
  D.20077 = (short unsigned int) nparams;
  sig->param_count = D.20077;
  sig->sentinelpos = -1;
  D.20078 = sig;
  return D.20078;
}


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

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


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.20082;
  unsigned int D.20083;
  unsigned int D.20084;
  unsigned int D.20085;
  unsigned int sigsize.82;
  unsigned int sigsize.83;
  unsigned int sigsize.84;
  unsigned int sigsize.85;
  struct MonoMethodSignature * D.20096;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.20082 = sig->param_count;
  D.20083 = (unsigned int) D.20082;
  D.20084 = D.20083 + 3;
  D.20085 = D.20084 * 4;
  sigsize = (int) D.20085;
  if (image != 0B) goto <D.20086>; else goto <D.20087>;
  <D.20086>:
  sigsize.82 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.82);
  goto <D.20089>;
  <D.20087>:
  if (mp != 0B) goto <D.20090>; else goto <D.20091>;
  <D.20090>:
  sigsize.83 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.83);
  goto <D.20093>;
  <D.20091>:
  sigsize.84 = (unsigned int) sigsize;
  ret = monoeg_malloc (sigsize.84);
  <D.20093>:
  <D.20089>:
  sigsize.85 = (unsigned int) sigsize;
  memcpy (ret, sig, sigsize.85);
  D.20096 = ret;
  return D.20096;
}


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

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


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

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


mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.20102;
  short unsigned int D.20103;
  unsigned int D.20104;
  unsigned int D.20105;

  D.20103 = sig->param_count;
  D.20104 = (unsigned int) D.20103;
  D.20105 = D.20104 + 3;
  D.20102 = D.20105 * 4;
  return D.20102;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.86;
  char D.20108;
  int D.20109;
  int D.20110;
  int D.20113;
  int D.20116;
  unsigned int D.20119;
  const char * ptr.87;
  unsigned int D.20125;
  int D.20126;
  unsigned char D.20127;
  <unnamed-unsigned:1> D.20128;
  unsigned char D.20129;
  <unnamed-unsigned:1> D.20130;
  unsigned char D.20131;
  <unnamed-unsigned:6> D.20132;
  short unsigned int D.20133;
  int iftmp.88;
  int D.20139;
  short int D.20140;
  struct MonoType * D.20142;
  struct MonoType * D.20143;
  struct MonoMethodSignature * D.20146;
  unsigned char D.20151;
  unsigned char D.20152;
  char * D.20154;
  short int D.20155;
  short int D.20158;
  int iftmp.89;
  sizetype i.90;
  sizetype D.20163;
  sizetype D.20164;
  int * D.20165;
  int D.20166;
  short int D.20167;
  struct MonoType * D.20169;
  struct MonoType * D.20170;
  short unsigned int D.20175;
  int D.20176;
  short int D.20183;
  unsigned char D.20184;
  <unnamed-unsigned:1> D.20185;
  struct MonoMethodSignature * method;
  int i;
  int * pattrs;
  guint32 hasthis;
  guint32 explicit_this;
  guint32 call_convention;
  guint32 param_count;
  guint32 gen_param_count;
  gboolean is_open;

  pattrs = 0B;
  hasthis = 0;
  explicit_this = 0;
  gen_param_count = 0;
  is_open = 0;
  ptr.86 = ptr;
  D.20108 = *ptr.86;
  D.20109 = (int) D.20108;
  D.20110 = D.20109 & 16;
  if (D.20110 != 0) goto <D.20111>; else goto <D.20112>;
  <D.20111>:
  gen_param_count = 1;
  <D.20112>:
  ptr.86 = ptr;
  D.20108 = *ptr.86;
  D.20109 = (int) D.20108;
  D.20113 = D.20109 & 32;
  if (D.20113 != 0) goto <D.20114>; else goto <D.20115>;
  <D.20114>:
  hasthis = 1;
  <D.20115>:
  ptr.86 = ptr;
  D.20108 = *ptr.86;
  D.20109 = (int) D.20108;
  D.20116 = D.20109 & 64;
  if (D.20116 != 0) goto <D.20117>; else goto <D.20118>;
  <D.20117>:
  explicit_this = 1;
  <D.20118>:
  ptr.86 = ptr;
  D.20108 = *ptr.86;
  D.20119 = (unsigned int) D.20108;
  call_convention = D.20119 & 15;
  ptr.86 = ptr;
  ptr.87 = ptr.86 + 1;
  ptr = ptr.87;
  if (gen_param_count != 0) goto <D.20121>; else goto <D.20122>;
  <D.20121>:
  ptr.86 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.86, &ptr);
  <D.20122>:
  ptr.86 = ptr;
  param_count = mono_metadata_decode_value (ptr.86, &ptr);
  if (def != 0) goto <D.20123>; else goto <D.20124>;
  <D.20123>:
  D.20125 = param_count + 1;
  D.20126 = (int) D.20125;
  pattrs = mono_metadata_get_param_attrs (m, def, D.20126);
  <D.20124>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.20127 = (unsigned char) hasthis;
  D.20128 = (<unnamed-unsigned:1>) D.20127;
  method->hasthis = D.20128;
  D.20129 = (unsigned char) explicit_this;
  D.20130 = (<unnamed-unsigned:1>) D.20129;
  method->explicit_this = D.20130;
  D.20131 = (unsigned char) call_convention;
  D.20132 = (<unnamed-unsigned:6>) D.20131;
  method->call_convention = D.20132;
  D.20133 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.20133;
  if (call_convention != 10) goto <D.20134>; else goto <D.20135>;
  <D.20134>:
  ptr.86 = ptr;
  if (pattrs != 0B) goto <D.20137>; else goto <D.20138>;
  <D.20137>:
  D.20139 = *pattrs;
  D.20140 = (short int) D.20139;
  iftmp.88 = (int) D.20140;
  goto <D.20141>;
  <D.20138>:
  iftmp.88 = 0;
  <D.20141>:
  D.20142 = mono_metadata_parse_type_full (m, container, 4, iftmp.88, ptr.86, &ptr);
  method->ret = D.20142;
  D.20143 = method->ret;
  if (D.20143 == 0B) goto <D.20144>; else goto <D.20145>;
  <D.20144>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20146 = 0B;
  return D.20146;
  <D.20145>:
  D.20143 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.20143);
  <D.20135>:
  i = 0;
  goto <D.17525>;
  <D.17524>:
  ptr.86 = ptr;
  D.20108 = *ptr.86;
  if (D.20108 == 65) goto <D.20147>; else goto <D.20148>;
  <D.20147>:
  D.20151 = BIT_FIELD_REF <*method, 8, 80>;
  D.20152 = D.20151 & 63;
  if (D.20152 != 5) goto <D.20149>; else goto <D.20153>;
  <D.20153>:
  if (def != 0) goto <D.20149>; else goto <D.20150>;
  <D.20149>:
  D.20154 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.20154);
  monoeg_g_free (pattrs);
  D.20146 = 0B;
  return D.20146;
  <D.20150>:
  D.20155 = method->sentinelpos;
  if (D.20155 >= 0) goto <D.20156>; else goto <D.20157>;
  <D.20156>:
  D.20154 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.20154);
  monoeg_g_free (pattrs);
  D.20146 = 0B;
  return D.20146;
  <D.20157>:
  D.20158 = (short int) i;
  method->sentinelpos = D.20158;
  ptr.86 = ptr;
  ptr.87 = ptr.86 + 1;
  ptr = ptr.87;
  <D.20148>:
  ptr.86 = ptr;
  if (pattrs != 0B) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  i.90 = (sizetype) i;
  D.20163 = i.90 + 1;
  D.20164 = D.20163 * 4;
  D.20165 = pattrs + D.20164;
  D.20166 = *D.20165;
  D.20167 = (short int) D.20166;
  iftmp.89 = (int) D.20167;
  goto <D.20168>;
  <D.20161>:
  iftmp.89 = 0;
  <D.20168>:
  D.20169 = mono_metadata_parse_type_full (m, container, 3, iftmp.89, ptr.86, &ptr);
  method->params[i] = D.20169;
  D.20170 = method->params[i];
  if (D.20170 == 0B) goto <D.20171>; else goto <D.20172>;
  <D.20171>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20146 = 0B;
  return D.20146;
  <D.20172>:
  if (is_open == 0) goto <D.20173>; else goto <D.20174>;
  <D.20173>:
  D.20170 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.20170);
  <D.20174>:
  i = i + 1;
  <D.17525>:
  D.20175 = method->param_count;
  D.20176 = (int) D.20175;
  if (D.20176 > i) goto <D.17524>; else goto <D.17526>;
  <D.17526>:
  if (def == 0) goto <D.20177>; else goto <D.20178>;
  <D.20177>:
  D.20151 = BIT_FIELD_REF <*method, 8, 80>;
  D.20152 = D.20151 & 63;
  if (D.20152 == 5) goto <D.20179>; else goto <D.20180>;
  <D.20179>:
  D.20155 = method->sentinelpos;
  if (D.20155 < 0) goto <D.20181>; else goto <D.20182>;
  <D.20181>:
  D.20175 = method->param_count;
  D.20183 = (short int) D.20175;
  method->sentinelpos = D.20183;
  <D.20182>:
  <D.20180>:
  <D.20178>:
  D.20184 = (unsigned char) is_open;
  D.20185 = (<unnamed-unsigned:1>) D.20184;
  method->has_type_parameters = D.20185;
  if (def != 0) goto <D.20186>; else goto <D.20187>;
  <D.20186>:
  D.20151 = BIT_FIELD_REF <*method, 8, 80>;
  D.20152 = D.20151 & 63;
  if (D.20152 == 5) goto <D.20188>; else goto <D.20189>;
  <D.20188>:
  D.20175 = method->param_count;
  D.20183 = (short int) D.20175;
  method->sentinelpos = D.20183;
  <D.20189>:
  <D.20187>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.20190>; else goto <D.20191>;
  <D.20190>:
  ptr.86 = ptr;
  *rptr = ptr.86;
  <D.20191>:
  D.20146 = method;
  return D.20146;
}


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

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


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.20195;
  struct MonoType * D.20198;
  short unsigned int D.20201;
  int D.20202;
  int i;

  D.20195 = sig->ret;
  if (D.20195 != 0B) goto <D.20196>; else goto <D.20197>;
  <D.20196>:
  D.20195 = sig->ret;
  mono_metadata_free_type (D.20195);
  <D.20197>:
  i = 0;
  goto <D.17541>;
  <D.17540>:
  D.20198 = sig->params[i];
  if (D.20198 != 0B) goto <D.20199>; else goto <D.20200>;
  <D.20199>:
  D.20198 = sig->params[i];
  mono_metadata_free_type (D.20198);
  <D.20200>:
  i = i + 1;
  <D.17541>:
  D.20201 = sig->param_count;
  D.20202 = (int) D.20201;
  if (D.20202 > i) goto <D.17540>; else goto <D.17542>;
  <D.17542>:
  monoeg_g_free (sig);
}


mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20203;
  struct MonoMemPool * D.20206;
  void * D.20207;
  void * res;

  mono_image_set_lock (set);
  D.20203 = set->mempool;
  if (D.20203 == 0B) goto <D.20204>; else goto <D.20205>;
  <D.20204>:
  D.20206 = mono_mempool_new_size (1024);
  set->mempool = D.20206;
  <D.20205>:
  D.20203 = set->mempool;
  res = mono_mempool_alloc (D.20203, size);
  mono_image_set_unlock (set);
  D.20207 = res;
  return D.20207;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20209;
  _Bool D.20212;
  long int D.20213;
  long int D.20214;

  {
    int ret;

    D.20209 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.20209);
    if (ret != 0) goto <D.20210>; else goto <D.20211>;
    <D.20210>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20211>:
    D.20212 = ret != 0;
    D.20213 = (long int) D.20212;
    D.20214 = __builtin_expect (D.20213, 0);
    if (D.20214 != 0) goto <D.20215>; else goto <D.20216>;
    <D.20215>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.20216>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20217;
  _Bool D.20220;
  long int D.20221;
  long int D.20222;

  {
    int ret;

    D.20217 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.20217);
    if (ret != 0) goto <D.20218>; else goto <D.20219>;
    <D.20218>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20219>:
    D.20220 = ret != 0;
    D.20221 = (long int) D.20220;
    D.20222 = __builtin_expect (D.20221, 0);
    if (D.20222 != 0) goto <D.20223>; else goto <D.20224>;
    <D.20223>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.20224>:
  }
}


mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20225;
  struct MonoMemPool * D.20228;
  void * D.20229;
  void * res;

  mono_image_set_lock (set);
  D.20225 = set->mempool;
  if (D.20225 == 0B) goto <D.20226>; else goto <D.20227>;
  <D.20226>:
  D.20228 = mono_mempool_new_size (1024);
  set->mempool = D.20228;
  <D.20227>:
  D.20225 = set->mempool;
  res = mono_mempool_alloc0 (D.20225, size);
  mono_image_set_unlock (set);
  D.20229 = res;
  return D.20229;
}


mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.20231;
  struct MonoMemPool * D.20234;
  char * D.20235;
  char * res;

  mono_image_set_lock (set);
  D.20231 = set->mempool;
  if (D.20231 == 0B) goto <D.20232>; else goto <D.20233>;
  <D.20232>:
  D.20234 = mono_mempool_new_size (1024);
  set->mempool = D.20234;
  <D.20233>:
  D.20231 = set->mempool;
  res = mono_mempool_strdup (D.20231, s);
  mono_image_set_unlock (set);
  D.20235 = res;
  return D.20235;
}


mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.20237;
  struct GSList * D.20238;
  struct GHashTable * D.20239;
  struct GHashTable * D.20240;
  struct GHashTable * D.20241;
  struct GHashTable * D.20242;
  void * D.20243;
  struct GSList * D.20244;
  struct GSList * D.20245;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.20237 = gclass_data.image;
      ginst_data.image = D.20237;
      gclass_data.list = 0B;
      D.20238 = gclass_data.list;
      ginst_data.list = D.20238;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.17789>;
      <D.17788>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.20239 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.20239, steal_gclass_in_image, &gclass_data);
        D.20240 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.20240, steal_ginst_in_image, &ginst_data);
        D.20241 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.20241, inflated_method_in_image, image);
        D.20242 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.20242, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.17789>:
      if (l != 0B) goto <D.17788>; else goto <D.17790>;
      <D.17790>:
      l = ginst_data.list;
      goto <D.17792>;
      <D.17791>:
      D.20243 = l->data;
      free_generic_inst (D.20243);
      l = l->next;
      <D.17792>:
      if (l != 0B) goto <D.17791>; else goto <D.17793>;
      <D.17793>:
      l = gclass_data.list;
      goto <D.17795>;
      <D.17794>:
      D.20243 = l->data;
      free_generic_class (D.20243);
      l = l->next;
      <D.17795>:
      if (l != 0B) goto <D.17794>; else goto <D.17796>;
      <D.17796>:
      D.20244 = ginst_data.list;
      monoeg_g_slist_free (D.20244);
      D.20238 = gclass_data.list;
      monoeg_g_slist_free (D.20238);
      D.20245 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.20245);
      l = set_list;
      goto <D.17799>;
      <D.17798>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.17799>:
      if (l != 0B) goto <D.17798>; else goto <D.17800>;
      <D.17800>:
      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.20246;
  int iftmp.91;
  struct MonoMethodSignature * D.20252;
  int D.20253;
  struct MonoGenericInst * D.20255;
  int D.20257;
  struct MonoGenericInst * D.20258;
  int D.20260;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.20252 = sig->sig;
  D.20253 = signature_in_image (D.20252, image);
  if (D.20253 != 0) goto <D.20248>; else goto <D.20254>;
  <D.20254>:
  D.20255 = sig->context.class_inst;
  if (D.20255 != 0B) goto <D.20256>; else goto <D.20249>;
  <D.20256>:
  D.20255 = sig->context.class_inst;
  D.20257 = ginst_in_image (D.20255, image);
  if (D.20257 != 0) goto <D.20248>; else goto <D.20249>;
  <D.20249>:
  D.20258 = sig->context.method_inst;
  if (D.20258 != 0B) goto <D.20259>; else goto <D.20250>;
  <D.20259>:
  D.20258 = sig->context.method_inst;
  D.20260 = ginst_in_image (D.20258, image);
  if (D.20260 != 0) goto <D.20248>; else goto <D.20250>;
  <D.20248>:
  iftmp.91 = 1;
  goto <D.20251>;
  <D.20250>:
  iftmp.91 = 0;
  <D.20251>:
  D.20246 = iftmp.91;
  return D.20246;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.20262;
  gboolean D.20265;
  struct MonoType * D.20266;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.17573>;
      <D.17572>:
      D.20262 = type_in_image (p, image);
      if (D.20262 != 0) goto <D.20263>; else goto <D.20264>;
      <D.20263>:
      D.20265 = 1;
      return D.20265;
      <D.20264>:
      <D.17573>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.17572>; else goto <D.17574>;
      <D.17574>:
      D.20266 = mono_signature_get_return_type (sig);
      D.20265 = type_in_image (D.20266, image);
      return D.20265;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.20269;
  int D.20270;
  gboolean D.20271;
  struct MonoGenericClass * D.20272;
  struct MonoClass * D.20273;
  struct MonoArrayType * D.20274;
  struct MonoClass * D.20275;
  struct MonoMethodSignature * D.20276;
  struct MonoGenericParam * D.20277;
  unsigned char D.20280;
  signed char D.20281;
  _Bool D.20282;
  long int D.20283;
  long int D.20284;
  struct MonoClass * D.20287;
  struct MonoImage * D.20290;
  _Bool D.20291;
  struct MonoImage * D.20292;
  _Bool D.20293;
  struct MonoImage * D.20294;
  _Bool D.20295;
  unsigned char D.20300;
  signed char D.20301;
  _Bool D.20302;
  long int D.20303;
  long int D.20304;
  struct MonoMethod * D.20307;
  struct MonoImage * D.20310;
  _Bool D.20311;
  struct MonoClass * D.20312;
  struct MonoImage * D.20313;
  _Bool D.20314;
  struct MonoClass * D.20315;
  struct MonoImage * D.20316;
  _Bool D.20317;
  void retry = <<< error >>>;

  retry:
  D.20269 = type->type;
  D.20270 = (int) D.20269;
  switch (D.20270) <default: <D.17601>, case 15: <D.17593>, case 19: <D.17597>, case 20: <D.17595>, case 21: <D.17592>, case 27: <D.17596>, case 29: <D.17594>, case 30: <D.17599>>
  <D.17592>:
  D.20272 = type->data.generic_class;
  D.20271 = gclass_in_image (D.20272, image);
  return D.20271;
  <D.17593>:
  type = type->data.type;
  goto retry;
  <D.17594>:
  D.20273 = type->data.klass;
  type = &D.20273->byval_arg;
  goto retry;
  <D.17595>:
  D.20274 = type->data.array;
  D.20275 = D.20274->eklass;
  type = &D.20275->byval_arg;
  goto retry;
  <D.17596>:
  D.20276 = type->data.method;
  D.20271 = signature_in_image (D.20276, image);
  return D.20271;
  <D.17597>:
  {
    struct MonoGenericContainer * container;

    D.20277 = type->data.generic_param;
    container = D.20277->owner;
    if (container != 0B) goto <D.20278>; else goto <D.20279>;
    <D.20278>:
    D.20280 = BIT_FIELD_REF <*container, 8, 152>;
    D.20281 = (signed char) D.20280;
    D.20282 = D.20281 < 0;
    D.20283 = (long int) D.20282;
    D.20284 = __builtin_expect (D.20283, 0);
    if (D.20284 != 0) goto <D.20285>; else goto <D.20286>;
    <D.20285>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.20286>:
    D.20287 = container->owner.klass;
    if (D.20287 == 0B) goto <D.20288>; else goto <D.20289>;
    <D.20288>:
    D.20290 = container->image;
    D.20291 = D.20290 == image;
    D.20271 = (gboolean) D.20291;
    return D.20271;
    <D.20289>:
    D.20287 = container->owner.klass;
    D.20292 = D.20287->image;
    D.20293 = D.20292 == image;
    D.20271 = (gboolean) D.20293;
    return D.20271;
    <D.20279>:
    D.20277 = type->data.generic_param;
    D.20294 = D.20277->image;
    D.20295 = D.20294 == image;
    D.20271 = (gboolean) D.20295;
    return D.20271;
  }
  <D.17599>:
  {
    struct MonoGenericContainer * container;

    D.20277 = type->data.generic_param;
    container = D.20277->owner;
    D.20277 = type->data.generic_param;
    D.20294 = D.20277->image;
    if (D.20294 == image) goto <D.20296>; else goto <D.20297>;
    <D.20296>:
    D.20271 = 1;
    return D.20271;
    <D.20297>:
    if (container != 0B) goto <D.20298>; else goto <D.20299>;
    <D.20298>:
    D.20300 = BIT_FIELD_REF <*container, 8, 152>;
    D.20301 = (signed char) D.20300;
    D.20302 = D.20301 >= 0;
    D.20303 = (long int) D.20302;
    D.20304 = __builtin_expect (D.20303, 0);
    if (D.20304 != 0) goto <D.20305>; else goto <D.20306>;
    <D.20305>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.20306>:
    D.20307 = container->owner.method;
    if (D.20307 == 0B) goto <D.20308>; else goto <D.20309>;
    <D.20308>:
    D.20310 = container->image;
    D.20311 = D.20310 == image;
    D.20271 = (gboolean) D.20311;
    return D.20271;
    <D.20309>:
    D.20307 = container->owner.method;
    D.20312 = D.20307->klass;
    D.20313 = D.20312->image;
    D.20314 = D.20313 == image;
    D.20271 = (gboolean) D.20314;
    return D.20271;
    <D.20299>:
    D.20277 = type->data.generic_param;
    D.20294 = D.20277->image;
    D.20295 = D.20294 == image;
    D.20271 = (gboolean) D.20295;
    return D.20271;
  }
  <D.17601>:
  D.20315 = mono_class_from_mono_type (type);
  D.20316 = D.20315->image;
  D.20317 = D.20316 == image;
  D.20271 = (gboolean) D.20317;
  return D.20271;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.20319;
  int iftmp.92;
  struct MonoClass * D.20324;
  struct MonoImage * D.20325;
  struct MonoGenericInst * D.20327;
  int D.20328;

  D.20324 = gclass->container_class;
  D.20325 = D.20324->image;
  if (D.20325 == image) goto <D.20321>; else goto <D.20326>;
  <D.20326>:
  D.20327 = gclass->context.class_inst;
  D.20328 = ginst_in_image (D.20327, image);
  if (D.20328 != 0) goto <D.20321>; else goto <D.20322>;
  <D.20321>:
  iftmp.92 = 1;
  goto <D.20323>;
  <D.20322>:
  iftmp.92 = 0;
  <D.20323>:
  D.20319 = iftmp.92;
  return D.20319;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.20330;
  int D.20331;
  gboolean D.20334;
  <unnamed-unsigned:22> D.20335;
  int D.20336;
  int i;

  i = 0;
  goto <D.17581>;
  <D.17580>:
  D.20330 = ginst->type_argv[i];
  D.20331 = type_in_image (D.20330, image);
  if (D.20331 != 0) goto <D.20332>; else goto <D.20333>;
  <D.20332>:
  D.20334 = 1;
  return D.20334;
  <D.20333>:
  i = i + 1;
  <D.17581>:
  D.20335 = ginst->type_argc;
  D.20336 = (int) D.20335;
  if (D.20336 > i) goto <D.17580>; else goto <D.17582>;
  <D.17582>:
  D.20334 = 0;
  return D.20334;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.93;
  struct MonoMethod * D.20344;
  struct MonoClass * D.20345;
  struct MonoImage * D.20346;
  struct MonoGenericInst * D.20348;
  int D.20350;
  struct MonoGenericInst * D.20351;
  int D.20353;
  struct MonoMethodSignature * D.20354;
  struct MonoMethodSignature * D.20356;
  int D.20357;
  _Bool D.20358;
  long int D.20359;
  long int D.20360;
  gboolean D.20363;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.20344 = method->declaring;
  D.20345 = D.20344->klass;
  D.20346 = D.20345->image;
  if (D.20346 != image) goto <D.20347>; else goto <D.20339>;
  <D.20347>:
  D.20348 = method->context.class_inst;
  if (D.20348 == 0B) goto <D.20340>; else goto <D.20349>;
  <D.20349>:
  D.20348 = method->context.class_inst;
  D.20350 = ginst_in_image (D.20348, image);
  if (D.20350 == 0) goto <D.20340>; else goto <D.20339>;
  <D.20340>:
  D.20351 = method->context.method_inst;
  if (D.20351 == 0B) goto <D.20341>; else goto <D.20352>;
  <D.20352>:
  D.20351 = method->context.method_inst;
  D.20353 = ginst_in_image (D.20351, image);
  if (D.20353 == 0) goto <D.20341>; else goto <D.20339>;
  <D.20341>:
  D.20354 = MEM[(struct MonoMethod *)method].signature;
  if (D.20354 == 0B) goto <D.20342>; else goto <D.20355>;
  <D.20355>:
  D.20356 = mono_method_signature (method);
  D.20357 = signature_in_image (D.20356, image);
  if (D.20357 == 0) goto <D.20342>; else goto <D.20339>;
  <D.20342>:
  iftmp.93 = 1;
  goto <D.20343>;
  <D.20339>:
  iftmp.93 = 0;
  <D.20343>:
  D.20358 = iftmp.93 != 0;
  D.20359 = (long int) D.20358;
  D.20360 = __builtin_expect (D.20359, 0);
  if (D.20360 != 0) goto <D.20361>; else goto <D.20362>;
  <D.20361>:
  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.20362>:
  D.20363 = 1;
  return D.20363;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.20365;
  struct GSList * D.20366;
  gboolean D.20367;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.20365 = user_data->list;
  D.20366 = monoeg_g_slist_prepend (D.20365, ginst);
  user_data->list = D.20366;
  D.20367 = 1;
  return D.20367;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.20369;
  int D.20370;
  _Bool D.20371;
  long int D.20372;
  long int D.20373;
  struct GSList * D.20376;
  struct GSList * D.20377;
  gboolean D.20378;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.20369 = user_data->image;
  D.20370 = gclass_in_image (gclass, D.20369);
  D.20371 = D.20370 == 0;
  D.20372 = (long int) D.20371;
  D.20373 = __builtin_expect (D.20372, 0);
  if (D.20373 != 0) goto <D.20374>; else goto <D.20375>;
  <D.20374>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.20375>:
  D.20376 = user_data->list;
  D.20377 = monoeg_g_slist_prepend (D.20376, gclass);
  user_data->list = D.20377;
  D.20378 = 1;
  return D.20378;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.20380;
  <unnamed-unsigned:22> D.20381;
  int D.20382;
  int i;

  i = 0;
  goto <D.17815>;
  <D.17814>:
  D.20380 = ginst->type_argv[i];
  mono_metadata_free_type (D.20380);
  i = i + 1;
  <D.17815>:
  D.20381 = ginst->type_argc;
  D.20382 = (int) D.20381;
  if (D.20382 > i) goto <D.17814>; else goto <D.17816>;
  <D.17816>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  unsigned char D.20383;
  unsigned char D.20384;
  struct MonoClass * D.20387;
  short unsigned int D.20390;

  D.20383 = BIT_FIELD_REF <*gclass, 8, 96>;
  D.20384 = D.20383 & 1;
  if (D.20384 != 0) goto <D.20385>; else goto <D.20386>;
  <D.20385>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.20386>:
  D.20387 = gclass->cached_class;
  if (D.20387 != 0B) goto <D.20388>; else goto <D.20389>;
  <D.20388>:
  D.20387 = gclass->cached_class;
  D.20390 = D.20387->interface_id;
  if (D.20390 != 0) goto <D.20391>; else goto <D.20392>;
  <D.20391>:
  D.20387 = gclass->cached_class;
  mono_unload_interface_id (D.20387);
  <D.20392>:
  <D.20389>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.20393;
  struct GHashTable * D.20394;
  struct GHashTable * D.20395;
  struct GHashTable * D.20396;
  struct MonoImage * * D.20397;
  unsigned int i.94;
  unsigned int D.20399;
  struct MonoImage * * D.20400;
  struct MonoImage * D.20401;
  struct GSList * D.20402;
  struct GSList * D.20403;
  int D.20404;
  struct GPtrArray * image_sets.95;
  struct MonoMemPool * D.20406;
  struct CRITICAL_SECTION * D.20409;
  int i;

  D.20393 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.20393);
  D.20394 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.20394);
  D.20395 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.20395);
  D.20396 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.20396);
  i = 0;
  goto <D.17631>;
  <D.17630>:
  D.20397 = set->images;
  i.94 = (unsigned int) i;
  D.20399 = i.94 * 4;
  D.20400 = D.20397 + D.20399;
  D.20401 = *D.20400;
  D.20397 = set->images;
  i.94 = (unsigned int) i;
  D.20399 = i.94 * 4;
  D.20400 = D.20397 + D.20399;
  D.20401 = *D.20400;
  D.20402 = D.20401->image_sets;
  D.20403 = monoeg_g_slist_remove (D.20402, set);
  D.20401->image_sets = D.20403;
  i = i + 1;
  <D.17631>:
  D.20404 = set->nimages;
  if (D.20404 > i) goto <D.17630>; else goto <D.17632>;
  <D.17632>:
  image_sets.95 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.95, set);
  D.20406 = set->mempool;
  if (D.20406 != 0B) goto <D.20407>; else goto <D.20408>;
  <D.20407>:
  D.20406 = set->mempool;
  mono_mempool_destroy (D.20406);
  <D.20408>:
  D.20397 = set->images;
  monoeg_g_free (D.20397);
  D.20409 = &set->lock;
  DeleteCriticalSection (D.20409);
  monoeg_g_free (set);
}


mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  int D.20410;
  struct MonoImage * * D.20411;
  struct GHashTable * D.20414;
  struct MonoMethodInflated * D.20415;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.20410 = data.nimages;
      D.20411 = data.images;
      set = get_image_set (D.20411, D.20410);
      collect_data_free (&data);
      if (cache != 0) goto <D.20412>; else goto <D.20413>;
      <D.20412>:
      D.20414 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.20414, method, method, 0);
      D.20415 = method;
      return D.20415;
      <D.20413>:
      D.20414 = set->gmethod_cache;
      D.20415 = monoeg_g_hash_table_lookup (D.20414, method);
      return D.20415;
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.20419;
  struct MonoClass * D.20420;
  struct MonoImage * D.20421;
  struct MonoGenericInst * D.20422;
  struct MonoGenericInst * D.20425;
  struct MonoClass * D.20428;
  struct MonoImage * D.20429;
  unsigned char D.20430;
  unsigned char D.20431;
  struct MonoMethodSignature * D.20434;
  struct MonoMethod * m;

  m = method->declaring;
  D.20419 = method->declaring;
  D.20420 = D.20419->klass;
  D.20421 = D.20420->image;
  add_image (D.20421, data);
  D.20422 = method->context.class_inst;
  if (D.20422 != 0B) goto <D.20423>; else goto <D.20424>;
  <D.20423>:
  D.20422 = method->context.class_inst;
  collect_ginst_images (D.20422, data);
  <D.20424>:
  D.20425 = method->context.method_inst;
  if (D.20425 != 0B) goto <D.20426>; else goto <D.20427>;
  <D.20426>:
  D.20425 = method->context.method_inst;
  collect_ginst_images (D.20425, data);
  <D.20427>:
  D.20428 = m->klass;
  D.20429 = D.20428->image;
  D.20430 = BIT_FIELD_REF <*D.20429, 8, 128>;
  D.20431 = D.20430 & 8;
  if (D.20431 != 0) goto <D.20432>; else goto <D.20433>;
  <D.20432>:
  D.20434 = mono_method_signature (m);
  collect_signature_images (D.20434, data);
  <D.20433>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.20435;
  unsigned int i.96;
  unsigned int D.20437;
  struct MonoImage * * D.20438;
  struct MonoImage * D.20439;
  int D.20442;
  int D.20443;
  int D.20446;
  int D.20447;
  unsigned int D.20448;
  unsigned int D.20449;
  struct MonoImage * * D.20450;
  int i;

  i = 0;
  goto <D.17679>;
  <D.17678>:
  D.20435 = data->images;
  i.96 = (unsigned int) i;
  D.20437 = i.96 * 4;
  D.20438 = D.20435 + D.20437;
  D.20439 = *D.20438;
  if (D.20439 == image) goto <D.20440>; else goto <D.20441>;
  <D.20440>:
  return;
  <D.20441>:
  i = i + 1;
  <D.17679>:
  D.20442 = data->nimages;
  if (D.20442 > i) goto <D.17678>; else goto <D.17680>;
  <D.17680>:
  D.20442 = data->nimages;
  D.20443 = data->images_len;
  if (D.20442 == D.20443) goto <D.20444>; else goto <D.20445>;
  <D.20444>:
  enlarge_data (data);
  <D.20445>:
  D.20435 = data->images;
  D.20442 = data->nimages;
  D.20446 = D.20442;
  D.20447 = D.20446 + 1;
  data->nimages = D.20447;
  D.20448 = (unsigned int) D.20446;
  D.20449 = D.20448 * 4;
  D.20450 = D.20435 + D.20449;
  *D.20450 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.97;
  int D.20453;
  unsigned int new_len.98;
  unsigned int D.20458;
  unsigned int D.20459;
  struct MonoImage * * D.20460;
  struct MonoImage *[64] * D.20461;
  int new_len;
  struct MonoImage * * d;

  D.20453 = data->images_len;
  if (D.20453 > 15) goto <D.20454>; else goto <D.20455>;
  <D.20454>:
  D.20453 = data->images_len;
  iftmp.97 = D.20453 * 2;
  goto <D.20456>;
  <D.20455>:
  iftmp.97 = 16;
  <D.20456>:
  new_len = iftmp.97;
  new_len.98 = (unsigned int) new_len;
  D.20458 = new_len.98 * 4;
  d = monoeg_malloc (D.20458);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.20453 = data->images_len;
  D.20459 = (unsigned int) D.20453;
  D.20460 = data->images;
  memcpy (d, D.20460, D.20459);
  D.20460 = data->images;
  D.20461 = &data->image_buf;
  if (D.20460 != D.20461) goto <D.20462>; else goto <D.20463>;
  <D.20462>:
  D.20460 = data->images;
  monoeg_g_free (D.20460);
  <D.20463>:
  data->images = d;
  data->images_len = new_len;
}


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

  i = 0;
  goto <D.17690>;
  <D.17689>:
  D.20464 = ginst->type_argv[i];
  collect_type_images (D.20464, data);
  i = i + 1;
  <D.17690>:
  D.20465 = ginst->type_argc;
  D.20466 = (int) D.20465;
  if (D.20466 > i) goto <D.17689>; else goto <D.17691>;
  <D.17691>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.20467;
  int D.20468;
  struct MonoGenericClass * D.20469;
  struct MonoClass * D.20470;
  struct MonoArrayType * D.20471;
  struct MonoClass * D.20472;
  struct MonoGenericParam * D.20473;
  unsigned char D.20476;
  signed char D.20477;
  _Bool D.20478;
  long int D.20479;
  long int D.20480;
  struct MonoClass * D.20483;
  struct MonoImage * D.20486;
  struct MonoImage * D.20488;
  struct MonoImage * D.20490;
  struct MonoMethod * D.20495;
  struct MonoImage * D.20498;
  unsigned char D.20500;
  signed char D.20501;
  _Bool D.20502;
  long int D.20503;
  long int D.20504;
  struct MonoClass * D.20507;
  struct MonoImage * D.20508;
  struct MonoClass * D.20510;
  struct MonoImage * D.20511;
  struct MonoImage * D.20512;
  void retry = <<< error >>>;

  retry:
  D.20467 = type->type;
  D.20468 = (int) D.20467;
  switch (D.20468) <default: <D.17731>, case 15: <D.17721>, case 17: <D.17730>, case 18: <D.17729>, case 19: <D.17725>, case 20: <D.17723>, case 21: <D.17719>, case 27: <D.17724>, case 29: <D.17722>, case 30: <D.17727>>
  <D.17719>:
  D.20469 = type->data.generic_class;
  collect_gclass_images (D.20469, data);
  goto <D.17720>;
  <D.17721>:
  type = type->data.type;
  goto retry;
  <D.17722>:
  D.20470 = type->data.klass;
  type = &D.20470->byval_arg;
  goto retry;
  <D.17723>:
  D.20471 = type->data.array;
  D.20472 = D.20471->eklass;
  type = &D.20472->byval_arg;
  goto retry;
  <D.17724>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.17725>:
  {
    struct MonoGenericContainer * container;

    D.20473 = type->data.generic_param;
    container = D.20473->owner;
    if (container != 0B) goto <D.20474>; else goto <D.20475>;
    <D.20474>:
    D.20476 = BIT_FIELD_REF <*container, 8, 152>;
    D.20477 = (signed char) D.20476;
    D.20478 = D.20477 < 0;
    D.20479 = (long int) D.20478;
    D.20480 = __builtin_expect (D.20479, 0);
    if (D.20480 != 0) goto <D.20481>; else goto <D.20482>;
    <D.20481>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.20482>:
    D.20483 = container->owner.klass;
    if (D.20483 == 0B) goto <D.20484>; else goto <D.20485>;
    <D.20484>:
    D.20486 = container->image;
    add_image (D.20486, data);
    goto <D.20487>;
    <D.20485>:
    D.20483 = container->owner.klass;
    D.20488 = D.20483->image;
    add_image (D.20488, data);
    <D.20487>:
    goto <D.20489>;
    <D.20475>:
    D.20473 = type->data.generic_param;
    D.20490 = D.20473->image;
    add_image (D.20490, data);
    <D.20489>:
  }
  goto <D.17720>;
  <D.17727>:
  {
    struct MonoGenericContainer * container;

    D.20473 = type->data.generic_param;
    container = D.20473->owner;
    D.20473 = type->data.generic_param;
    D.20490 = D.20473->image;
    if (D.20490 != 0B) goto <D.20491>; else goto <D.20492>;
    <D.20491>:
    D.20473 = type->data.generic_param;
    D.20490 = D.20473->image;
    add_image (D.20490, data);
    <D.20492>:
    if (container != 0B) goto <D.20493>; else goto <D.20494>;
    <D.20493>:
    D.20495 = container->owner.method;
    if (D.20495 == 0B) goto <D.20496>; else goto <D.20497>;
    <D.20496>:
    D.20498 = container->image;
    add_image (D.20498, data);
    goto <D.20499>;
    <D.20497>:
    D.20500 = BIT_FIELD_REF <*container, 8, 152>;
    D.20501 = (signed char) D.20500;
    D.20502 = D.20501 >= 0;
    D.20503 = (long int) D.20502;
    D.20504 = __builtin_expect (D.20503, 0);
    if (D.20504 != 0) goto <D.20505>; else goto <D.20506>;
    <D.20505>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.20506>:
    D.20495 = container->owner.method;
    D.20507 = D.20495->klass;
    D.20508 = D.20507->image;
    add_image (D.20508, data);
    <D.20499>:
    goto <D.20509>;
    <D.20494>:
    D.20473 = type->data.generic_param;
    D.20490 = D.20473->image;
    add_image (D.20490, data);
    <D.20509>:
  }
  goto <D.17720>;
  <D.17729>:
  <D.17730>:
  D.20510 = mono_class_from_mono_type (type);
  D.20511 = D.20510->image;
  add_image (D.20511, data);
  goto <D.17720>;
  <D.17731>:
  D.20512 = mono_defaults.corlib;
  add_image (D.20512, data);
  <D.17720>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.20513;
  struct MonoImage * D.20514;
  struct MonoGenericInst * D.20515;

  D.20513 = gclass->container_class;
  D.20514 = D.20513->image;
  add_image (D.20514, data);
  D.20515 = gclass->context.class_inst;
  if (D.20515 != 0B) goto <D.20516>; else goto <D.20517>;
  <D.20516>:
  D.20515 = gclass->context.class_inst;
  collect_ginst_images (D.20515, data);
  <D.20517>:
}


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

  try
    {
      iter = 0B;
      D.20518 = mono_signature_get_return_type (sig);
      collect_type_images (D.20518, data);
      goto <D.17703>;
      <D.17702>:
      collect_type_images (p, data);
      <D.17703>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.17702>; else goto <D.17704>;
      <D.17704>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.99;
  struct GPtrArray * image_sets.100;
  struct MonoImage * D.20525;
  struct MonoImage * D.20526;
  struct MonoImageSet * mscorlib_image_set.101;
  struct MonoImageSet * D.20532;
  struct MonoImage * * D.20539;
  struct MonoImage * D.20540;
  int D.20541;
  struct MonoImage * * D.20544;
  unsigned int k.102;
  unsigned int D.20546;
  struct MonoImage * * D.20547;
  struct MonoImage * D.20548;
  unsigned int j.103;
  unsigned int D.20550;
  struct MonoImage * * D.20551;
  struct MonoImage * D.20552;
  unsigned int nimages.104;
  unsigned int D.20559;
  void * D.20560;
  struct CRITICAL_SECTION * D.20561;
  unsigned int i.105;
  unsigned int D.20563;
  struct MonoImage * * D.20564;
  struct MonoImage * * D.20565;
  struct MonoImage * D.20566;
  struct GHashTable * D.20567;
  struct GHashTable * D.20568;
  struct GHashTable * D.20569;
  struct GHashTable * D.20570;
  struct MonoImage * D.20571;
  struct GSList * D.20572;
  struct GSList * D.20573;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.99 = image_sets;
  if (image_sets.99 == 0B) goto <D.20520>; else goto <D.20521>;
  <D.20520>:
  image_sets.100 = monoeg_g_ptr_array_new ();
  image_sets = image_sets.100;
  <D.20521>:
  if (nimages == 1) goto <D.20523>; else goto <D.20524>;
  <D.20523>:
  D.20525 = *images;
  D.20526 = mono_defaults.corlib;
  if (D.20525 == D.20526) goto <D.20527>; else goto <D.20528>;
  <D.20527>:
  mscorlib_image_set.101 = mscorlib_image_set;
  if (mscorlib_image_set.101 != 0B) goto <D.20530>; else goto <D.20531>;
  <D.20530>:
  D.20532 = mscorlib_image_set;
  return D.20532;
  <D.20531>:
  <D.20528>:
  <D.20524>:
  if (nimages == 0) goto <D.20533>; else goto <D.20534>;
  <D.20533>:
  D.20532 = mscorlib_image_set;
  return D.20532;
  <D.20534>:
  D.20525 = *images;
  D.20526 = mono_defaults.corlib;
  if (D.20525 == D.20526) goto <D.20537>; else goto <D.20535>;
  <D.20537>:
  if (nimages > 1) goto <D.20538>; else goto <D.20535>;
  <D.20538>:
  D.20539 = images + 4;
  D.20540 = *D.20539;
  l = D.20540->image_sets;
  goto <D.20536>;
  <D.20535>:
  D.20525 = *images;
  l = D.20525->image_sets;
  <D.20536>:
  set = 0B;
  goto <D.17619>;
  <D.17618>:
  set = l->data;
  D.20541 = set->nimages;
  if (D.20541 == nimages) goto <D.20542>; else goto <D.20543>;
  <D.20542>:
  j = 0;
  goto <D.17616>;
  <D.17615>:
  k = 0;
  goto <D.17613>;
  <D.17612>:
  D.20544 = set->images;
  k.102 = (unsigned int) k;
  D.20546 = k.102 * 4;
  D.20547 = D.20544 + D.20546;
  D.20548 = *D.20547;
  j.103 = (unsigned int) j;
  D.20550 = j.103 * 4;
  D.20551 = images + D.20550;
  D.20552 = *D.20551;
  if (D.20548 == D.20552) goto <D.17611>; else goto <D.20553>;
  <D.20553>:
  k = k + 1;
  <D.17613>:
  if (k < nimages) goto <D.17612>; else goto <D.17611>;
  <D.17611>:
  if (k == nimages) goto <D.17614>; else goto <D.20554>;
  <D.20554>:
  j = j + 1;
  <D.17616>:
  if (j < nimages) goto <D.17615>; else goto <D.17614>;
  <D.17614>:
  if (j == nimages) goto <D.17617>; else goto <D.20555>;
  <D.20555>:
  <D.20543>:
  l = l->next;
  <D.17619>:
  if (l != 0B) goto <D.17618>; else goto <D.17617>;
  <D.17617>:
  if (l == 0B) goto <D.20556>; else goto <D.20557>;
  <D.20556>:
  set = monoeg_malloc0 (56);
  set->nimages = nimages;
  nimages.104 = (unsigned int) nimages;
  D.20559 = nimages.104 * 4;
  D.20560 = monoeg_malloc0 (D.20559);
  set->images = D.20560;
  D.20561 = &set->lock;
  InitializeCriticalSection (D.20561);
  i = 0;
  goto <D.17621>;
  <D.17620>:
  D.20544 = set->images;
  i.105 = (unsigned int) i;
  D.20563 = i.105 * 4;
  D.20564 = D.20544 + D.20563;
  i.105 = (unsigned int) i;
  D.20563 = i.105 * 4;
  D.20565 = images + D.20563;
  D.20566 = *D.20565;
  *D.20564 = D.20566;
  i = i + 1;
  <D.17621>:
  if (i < nimages) goto <D.17620>; else goto <D.17622>;
  <D.17622>:
  D.20567 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.20567;
  D.20568 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.20568;
  D.20569 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.20569;
  D.20570 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.20570;
  i = 0;
  goto <D.17624>;
  <D.17623>:
  D.20544 = set->images;
  i.105 = (unsigned int) i;
  D.20563 = i.105 * 4;
  D.20564 = D.20544 + D.20563;
  D.20571 = *D.20564;
  D.20544 = set->images;
  i.105 = (unsigned int) i;
  D.20563 = i.105 * 4;
  D.20564 = D.20544 + D.20563;
  D.20571 = *D.20564;
  D.20572 = D.20571->image_sets;
  D.20573 = monoeg_g_slist_prepend (D.20572, set);
  D.20571->image_sets = D.20573;
  i = i + 1;
  <D.17624>:
  if (i < nimages) goto <D.17623>; else goto <D.17625>;
  <D.17625>:
  image_sets.99 = image_sets;
  monoeg_g_ptr_array_add (image_sets.99, set);
  <D.20557>:
  if (nimages == 1) goto <D.20574>; else goto <D.20575>;
  <D.20574>:
  D.20525 = *images;
  D.20526 = mono_defaults.corlib;
  if (D.20525 == D.20526) goto <D.20576>; else goto <D.20577>;
  <D.20576>:
  mscorlib_image_set = set;
  <D.20577>:
  <D.20575>:
  D.20532 = set;
  return D.20532;
}


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

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


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.20580;
  struct MonoMethodSignature * D.20581;
  gboolean D.20584;
  const struct MonoGenericContext * D.20585;
  const struct MonoGenericContext * D.20586;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.20580 = sig1->sig;
  D.20581 = sig2->sig;
  if (D.20580 != D.20581) goto <D.20582>; else goto <D.20583>;
  <D.20582>:
  D.20584 = 0;
  return D.20584;
  <D.20583>:
  D.20585 = &sig2->context;
  D.20586 = &sig1->context;
  D.20584 = mono_metadata_generic_context_equal (D.20586, D.20585);
  return D.20584;
}


inflated_signature_hash (const void * a)
{
  guint D.20588;
  const struct MonoGenericContext * D.20589;
  unsigned int D.20590;
  struct MonoMethodSignature * D.20591;
  unsigned int D.20592;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.20589 = &sig->context;
  D.20590 = mono_metadata_generic_context_hash (D.20589);
  D.20591 = sig->sig;
  D.20592 = mono_aligned_addr_hash (D.20591);
  D.20588 = D.20590 ^ D.20592;
  return D.20588;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.20594;
  short unsigned int D.20597;
  int D.20598;
  int D.20599;
  short unsigned int D.20602;
  unsigned int D.20603;
  unsigned int D.20604;
  int D.20607;
  struct MonoType * D.20612;
  short unsigned int D.20613;
  int D.20614;
  struct MonoExceptionClause * D.20615;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.20594 = method->signature;
  if (D.20594 != 0B) goto <D.20595>; else goto <D.20596>;
  <D.20595>:
  D.20594 = method->signature;
  mono_metadata_free_inflated_signature (D.20594);
  <D.20596>:
  D.20597 = method->flags;
  D.20598 = (int) D.20597;
  D.20599 = D.20598 & 1024;
  if (D.20599 == 0) goto <D.20600>; else goto <D.20601>;
  <D.20600>:
  D.20602 = method->iflags;
  D.20603 = (unsigned int) D.20602;
  D.20604 = D.20603 & 4099;
  if (D.20604 == 0) goto <D.20605>; else goto <D.20606>;
  <D.20605>:
  D.20597 = method->flags;
  D.20598 = (int) D.20597;
  D.20607 = D.20598 & 8192;
  if (D.20607 == 0) goto <D.20608>; else goto <D.20609>;
  <D.20608>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.20610>; else goto <D.20611>;
    <D.20610>:
    i = 0;
    goto <D.17808>;
    <D.17807>:
    D.20612 = header->locals[i];
    mono_metadata_free_type (D.20612);
    i = i + 1;
    <D.17808>:
    D.20613 = header->num_locals;
    D.20614 = (int) D.20613;
    if (D.20614 > i) goto <D.17807>; else goto <D.17809>;
    <D.17809>:
    D.20615 = header->clauses;
    monoeg_g_free (D.20615);
    monoeg_g_free (header);
    <D.20611>:
  }
  <D.20609>:
  <D.20606>:
  <D.20601>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.20616;
  struct MonoMethod * D.20617;
  gboolean D.20620;
  unsigned char D.20621;
  unsigned char D.20622;
  unsigned char D.20623;
  signed char D.20624;
  const struct MonoGenericContext * D.20627;
  const struct MonoGenericContext * D.20628;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.20616 = ma->declaring;
  D.20617 = mb->declaring;
  if (D.20616 != D.20617) goto <D.20618>; else goto <D.20619>;
  <D.20618>:
  D.20620 = 0;
  return D.20620;
  <D.20619>:
  D.20621 = BIT_FIELD_REF <*ma, 8, 168>;
  D.20622 = BIT_FIELD_REF <*mb, 8, 168>;
  D.20623 = D.20621 ^ D.20622;
  D.20624 = (signed char) D.20623;
  if (D.20624 < 0) goto <D.20625>; else goto <D.20626>;
  <D.20625>:
  D.20620 = 0;
  return D.20620;
  <D.20626>:
  D.20627 = &mb->context;
  D.20628 = &ma->context;
  D.20620 = mono_metadata_generic_context_equal (D.20628, D.20627);
  return D.20620;
}


inflated_method_hash (const void * a)
{
  guint D.20630;
  const struct MonoGenericContext * D.20631;
  unsigned int D.20632;
  struct MonoMethod * D.20633;
  unsigned int D.20634;
  unsigned int D.20635;
  <unnamed-unsigned:1> D.20636;
  unsigned int D.20637;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.20631 = &ma->context;
  D.20632 = mono_metadata_generic_context_hash (D.20631);
  D.20633 = ma->declaring;
  D.20634 = mono_aligned_addr_hash (D.20633);
  D.20635 = D.20632 ^ D.20634;
  D.20636 = ma->method.method.is_mb_open;
  D.20637 = (unsigned int) D.20636;
  D.20630 = D.20635 + D.20637;
  return D.20630;
}


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

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


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.20641;
  struct MonoImage *[64] * D.20642;

  D.20641 = data->images;
  D.20642 = &data->image_buf;
  if (D.20641 != D.20642) goto <D.20643>; else goto <D.20644>;
  <D.20643>:
  D.20641 = data->images;
  monoeg_g_free (D.20641);
  <D.20644>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.20645;
  struct MonoGenericInst * D.20646;
  int D.20647;
  struct MonoImage * * D.20648;
  struct GHashTable * D.20649;
  struct MonoMethodSignature * D.20652;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.20645 = context->class_inst;
      helper.context.class_inst = D.20645;
      D.20646 = context->method_inst;
      helper.context.method_inst = D.20646;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.20647 = data.nimages;
      D.20648 = data.images;
      set = get_image_set (D.20648, D.20647);
      collect_data_free (&data);
      D.20649 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.20649, &helper);
      if (res == 0B) goto <D.20650>; else goto <D.20651>;
      <D.20650>:
      res = monoeg_malloc0 (12);
      res->sig = sig;
      D.20645 = context->class_inst;
      res->context.class_inst = D.20645;
      D.20646 = context->method_inst;
      res->context.method_inst = D.20646;
      D.20649 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.20649, res, res, 0);
      <D.20651>:
      mono_loader_unlock ();
      D.20652 = res->sig;
      return D.20652;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.20655;
  struct MonoGenericInst * D.20656;
  struct MonoGenericInst * D.20659;

  D.20655 = sig->sig;
  collect_signature_images (D.20655, data);
  D.20656 = sig->context.class_inst;
  if (D.20656 != 0B) goto <D.20657>; else goto <D.20658>;
  <D.20657>:
  D.20656 = sig->context.class_inst;
  collect_ginst_images (D.20656, data);
  <D.20658>:
  D.20659 = sig->context.method_inst;
  if (D.20659 != 0B) goto <D.20660>; else goto <D.20661>;
  <D.20660>:
  D.20659 = sig->context.method_inst;
  collect_ginst_images (D.20659, data);
  <D.20661>:
}


mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  unsigned int type_argc.106;
  unsigned int D.20663;
  unsigned int D.20664;
  unsigned int i.107;
  unsigned int D.20666;
  struct MonoType * * D.20667;
  struct MonoType * D.20668;
  int D.20669;
  _Bool D.20671;
  unsigned int size.108;
  unsigned char D.20673;
  <unnamed-unsigned:1> D.20674;
  <unnamed-unsigned:22> D.20675;
  unsigned int D.20676;
  struct MonoType *[0:] * D.20677;
  int D.20678;
  struct MonoImage * * D.20679;
  struct GHashTable * D.20680;
  unsigned int size.109;
  int next_generic_inst_id.110;
  int next_generic_inst_id.111;
  unsigned int next_generic_inst_id.112;
  struct MonoType * D.20687;
  struct MonoGenericInst * D.20688;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      type_argc.106 = (unsigned int) type_argc;
      D.20663 = type_argc.106 + 2;
      D.20664 = D.20663 * 4;
      size = (int) D.20664;
      i = 0;
      goto <D.17849>;
      <D.17848>:
      i.107 = (unsigned int) i;
      D.20666 = i.107 * 4;
      D.20667 = type_argv + D.20666;
      D.20668 = *D.20667;
      D.20669 = mono_class_is_open_constructed_type (D.20668);
      if (D.20669 != 0) goto <D.17847>; else goto <D.20670>;
      <D.20670>:
      i = i + 1;
      <D.17849>:
      if (i < type_argc) goto <D.17848>; else goto <D.17847>;
      <D.17847>:
      D.20671 = i < type_argc;
      is_open = (gboolean) D.20671;
      size.108 = (unsigned int) size;
      ginst = __builtin_alloca (size.108);
      memset (ginst, 0, 8);
      D.20673 = (unsigned char) is_open;
      D.20674 = (<unnamed-unsigned:1>) D.20673;
      ginst->is_open = D.20674;
      type_argc.106 = (unsigned int) type_argc;
      D.20675 = (<unnamed-unsigned:22>) type_argc.106;
      ginst->type_argc = D.20675;
      type_argc.106 = (unsigned int) type_argc;
      D.20676 = type_argc.106 * 4;
      D.20677 = &ginst->type_argv;
      memcpy (D.20677, type_argv, D.20676);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.20678 = data.nimages;
      D.20679 = data.images;
      set = get_image_set (D.20679, D.20678);
      collect_data_free (&data);
      D.20680 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.20680, ginst);
      if (ginst == 0B) goto <D.20681>; else goto <D.20682>;
      <D.20681>:
      size.109 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.109);
      next_generic_inst_id.110 = next_generic_inst_id;
      next_generic_inst_id.111 = next_generic_inst_id.110 + 1;
      next_generic_inst_id = next_generic_inst_id.111;
      next_generic_inst_id.110 = next_generic_inst_id;
      next_generic_inst_id.112 = (unsigned int) next_generic_inst_id.110;
      ginst->id = next_generic_inst_id.112;
      D.20673 = (unsigned char) is_open;
      D.20674 = (<unnamed-unsigned:1>) D.20673;
      ginst->is_open = D.20674;
      type_argc.106 = (unsigned int) type_argc;
      D.20675 = (<unnamed-unsigned:22>) type_argc.106;
      ginst->type_argc = D.20675;
      i = 0;
      goto <D.17851>;
      <D.17850>:
      i.107 = (unsigned int) i;
      D.20666 = i.107 * 4;
      D.20667 = type_argv + D.20666;
      D.20668 = *D.20667;
      D.20687 = mono_metadata_type_dup (0B, D.20668);
      ginst->type_argv[i] = D.20687;
      i = i + 1;
      <D.17851>:
      if (i < type_argc) goto <D.17850>; else goto <D.17852>;
      <D.17852>:
      D.20680 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.20680, ginst, ginst, 0);
      <D.20682>:
      mono_loader_unlock ();
      D.20688 = ginst;
      return D.20688;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.20691;
  <unnamed-unsigned:1> D.20692;
  unsigned char D.20693;
  <unnamed-unsigned:1> D.20694;
  int D.20695;
  struct MonoImage * * D.20696;
  struct GHashTable * D.20697;
  struct MonoClass * D.20698;
  _Bool D.20699;
  long int D.20700;
  long int D.20701;
  struct MonoGenericClass * D.20706;
  struct MonoGenericContainer * D.20710;
  struct MonoGenericInst * D.20711;
  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.20691 = (unsigned char) is_dynamic;
      D.20692 = (<unnamed-unsigned:1>) D.20691;
      helper.is_dynamic = D.20692;
      D.20693 = (unsigned char) is_tb_open;
      D.20694 = (<unnamed-unsigned:1>) D.20693;
      helper.is_tb_open = D.20694;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.20695 = data.nimages;
      D.20696 = data.images;
      set = get_image_set (D.20696, D.20695);
      collect_data_free (&data);
      D.20697 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.20697, &helper);
      D.20698 = helper.cached_class;
      D.20699 = D.20698 != 0B;
      D.20700 = (long int) D.20699;
      D.20701 = __builtin_expect (D.20700, 0);
      if (D.20701 != 0) goto <D.20702>; else goto <D.20703>;
      <D.20702>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.20703>:
      if (gclass != 0B) goto <D.20704>; else goto <D.20705>;
      <D.20704>:
      mono_loader_unlock ();
      D.20706 = gclass;
      return D.20706;
      <D.20705>:
      if (is_dynamic != 0) goto <D.20707>; else goto <D.20708>;
      <D.20707>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 44);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.20709>;
      <D.20708>:
      gclass = mono_image_set_alloc0 (set, 24);
      <D.20709>:
      D.20693 = (unsigned char) is_tb_open;
      D.20694 = (<unnamed-unsigned:1>) D.20693;
      gclass->is_tb_open = D.20694;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.20710 = container_class->generic_container;
      D.20711 = D.20710->context.class_inst;
      if (D.20711 == inst) goto <D.20712>; else goto <D.20713>;
      <D.20712>:
      if (is_tb_open == 0) goto <D.20714>; else goto <D.20715>;
      <D.20714>:
      gclass->cached_class = container_class;
      <D.20715>:
      <D.20713>:
      D.20697 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.20697, gclass, gclass, 0);
      mono_loader_unlock ();
      D.20706 = gclass;
      return D.20706;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_metadata_is_type_builder_generic_type_definition (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.20721;
  unsigned char D.20722;
  <unnamed-signed:31> D.20724;
  int D.20725;
  <unnamed-unsigned:22> D.20726;
  int D.20727;
  gboolean D.20728;
  struct MonoGenericInst * D.20729;
  _Bool D.20730;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.20718>; else goto <D.20720>;
  <D.20720>:
  D.20721 = BIT_FIELD_REF <*container_class, 8, 160>;
  D.20722 = D.20721 & 128;
  if (D.20722 != 0) goto <D.20718>; else goto <D.20723>;
  <D.20723>:
  D.20724 = container->type_argc;
  D.20725 = (int) D.20724;
  D.20726 = inst->type_argc;
  D.20727 = (int) D.20726;
  if (D.20725 != D.20727) goto <D.20718>; else goto <D.20719>;
  <D.20718>:
  D.20728 = 0;
  return D.20728;
  <D.20719>:
  D.20729 = container->context.class_inst;
  D.20730 = D.20729 == inst;
  D.20728 = (gboolean) D.20730;
  return D.20728;
}


mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned char D.20732;
  unsigned char D.20733;
  struct MonoGenericInst * D.20736;
  <unnamed-unsigned:22> D.20737;
  unsigned int D.20738;
  unsigned int D.20739;
  unsigned int i.113;
  unsigned int D.20741;
  struct MonoType * * D.20742;
  struct MonoType * D.20743;
  struct MonoType * D.20744;
  int D.20745;
  int D.20747;
  struct MonoType * D.20748;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.20732 = BIT_FIELD_REF <*ginst, 8, 48>;
  D.20733 = D.20732 & 64;
  if (D.20733 == 0) goto <D.20734>; else goto <D.20735>;
  <D.20734>:
  D.20736 = ginst;
  return D.20736;
  <D.20735>:
  D.20737 = ginst->type_argc;
  D.20738 = (unsigned int) D.20737;
  D.20739 = D.20738 * 4;
  type_argv = monoeg_malloc0 (D.20739);
  i = 0;
  goto <D.17881>;
  <D.17880>:
  i.113 = (unsigned int) i;
  D.20741 = i.113 * 4;
  D.20742 = type_argv + D.20741;
  D.20743 = ginst->type_argv[i];
  D.20744 = mono_class_inflate_generic_type_checked (D.20743, context, error);
  *D.20742 = D.20744;
  D.20745 = mono_error_ok (error);
  if (D.20745 == 0) goto cleanup; else goto <D.20746>;
  <D.20746>:
  count = count + 1;
  i = i + 1;
  <D.17881>:
  D.20737 = ginst->type_argc;
  D.20747 = (int) D.20737;
  if (D.20747 > i) goto <D.17880>; else goto <D.17882>;
  <D.17882>:
  D.20737 = ginst->type_argc;
  D.20747 = (int) D.20737;
  nginst = mono_metadata_get_generic_inst (D.20747, type_argv);
  cleanup:
  i = 0;
  goto <D.17884>;
  <D.17883>:
  i.113 = (unsigned int) i;
  D.20741 = i.113 * 4;
  D.20742 = type_argv + D.20741;
  D.20748 = *D.20742;
  mono_metadata_free_type (D.20748);
  i = i + 1;
  <D.17884>:
  if (i < count) goto <D.17883>; else goto <D.17885>;
  <D.17885>:
  monoeg_g_free (type_argv);
  D.20736 = nginst;
  return D.20736;
}


mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  unsigned int count.114;
  unsigned int D.20751;
  const char * ptr.115;
  struct MonoGenericInst * D.20755;
  unsigned int i.116;
  unsigned int D.20757;
  struct MonoType * * D.20758;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

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

    ptr.115 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.115, &ptr);
    if (t == 0B) goto <D.20753>; else goto <D.20754>;
    <D.20753>:
    monoeg_g_free (type_argv);
    D.20755 = 0B;
    return D.20755;
    <D.20754>:
    i.116 = (unsigned int) i;
    D.20757 = i.116 * 4;
    D.20758 = type_argv + D.20757;
    *D.20758 = t;
  }
  i = i + 1;
  <D.17898>:
  if (i < count) goto <D.17897>; else goto <D.17899>;
  <D.17899>:
  if (rptr != 0B) goto <D.20759>; else goto <D.20760>;
  <D.20759>:
  ptr.115 = ptr;
  *rptr = ptr.115;
  <D.20760>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.20755 = ginst;
  return D.20755;
}


mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.117;
  struct MonoType * D.20765;
  unsigned char D.20766;
  int D.20767;
  struct MonoClass * D.20768;
  struct MonoType * D.20769;
  struct MonoType * D.20772;
  struct MonoType * cached;

  type_cache.117 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.117, type);
  if (cached != 0B) goto <D.20763>; else goto <D.20764>;
  <D.20763>:
  D.20765 = cached;
  return D.20765;
  <D.20764>:
  D.20766 = type->type;
  D.20767 = (int) D.20766;
  switch (D.20767) <default: <D.20775>, case 17: <D.17930>, case 18: <D.17929>>
  <D.17929>:
  <D.17930>:
  D.20768 = type->data.klass;
  D.20769 = &D.20768->byval_arg;
  if (D.20769 == type) goto <D.20770>; else goto <D.20771>;
  <D.20770>:
  D.20765 = type;
  return D.20765;
  <D.20771>:
  D.20768 = type->data.klass;
  D.20772 = &D.20768->this_arg;
  if (D.20772 == type) goto <D.20773>; else goto <D.20774>;
  <D.20773>:
  D.20765 = type;
  return D.20765;
  <D.20774>:
  goto <D.17931>;
  <D.20775>:
  <D.17931>:
  D.20765 = 0B;
  return D.20765;
}


mono_metadata_free_type (struct MonoType * type)
{
  unsigned char D.20781;
  int D.20782;
  struct MonoClass * D.20783;
  struct MonoType * D.20787;
  struct MonoType * D.20789;
  struct MonoType * D.20790;
  struct MonoMethodSignature * D.20791;
  struct MonoArrayType * D.20792;

  if (type >= &builtin_types) goto <D.20777>; else goto <D.20778>;
  <D.20777>:
  if (type < &MEM[(void *)&builtin_types + 272B]) goto <D.20779>; else goto <D.20780>;
  <D.20779>:
  return;
  <D.20780>:
  <D.20778>:
  D.20781 = type->type;
  D.20782 = (int) D.20781;
  switch (D.20782) <default: <D.20793>, case 14: <D.17981>, case 15: <D.17985>, case 17: <D.17984>, case 18: <D.17983>, case 20: <D.17987>, case 27: <D.17986>, case 28: <D.17980>>
  <D.17980>:
  <D.17981>:
  D.20783 = type->data.klass;
  if (D.20783 == 0B) goto <D.17982>; else goto <D.20784>;
  <D.20784>:
  <D.17983>:
  <D.17984>:
  D.20783 = type->data.klass;
  D.20787 = &D.20783->byval_arg;
  if (D.20787 == type) goto <D.20785>; else goto <D.20788>;
  <D.20788>:
  D.20783 = type->data.klass;
  D.20789 = &D.20783->this_arg;
  if (D.20789 == type) goto <D.20785>; else goto <D.20786>;
  <D.20785>:
  return;
  <D.20786>:
  goto <D.17982>;
  <D.17985>:
  D.20790 = type->data.type;
  mono_metadata_free_type (D.20790);
  goto <D.17982>;
  <D.17986>:
  D.20791 = type->data.method;
  mono_metadata_free_method_signature (D.20791);
  goto <D.17982>;
  <D.17987>:
  D.20792 = type->data.array;
  mono_metadata_free_array (D.20792);
  goto <D.17982>;
  <D.20793>:
  <D.17982>:
  monoeg_g_free (type);
}


mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  unsigned char D.20795;
  unsigned char D.20796;
  short unsigned int D.20799;
  int D.20800;
  int D.20801;
  short unsigned int D.20803;
  unsigned int D.20804;
  unsigned int D.20805;
  int D.20807;
  gboolean D.20808;
  short unsigned int D.20809;
  short unsigned int D.20810;
  unsigned int D.20815;
  <unnamed-unsigned:15> D.20816;
  int D.20817;
  _Bool D.20818;
  int D.20819;
  unsigned int D.20820;
  int D.20821;
  struct MonoClass * D.20822;
  int D.20823;
  struct MonoTableInfo * D.20824;
  int D.20825;
  _Bool D.20828;
  long int D.20829;
  long int D.20830;
  int D.20833;
  unsigned char D.20834;
  unsigned int D.20835;
  unsigned int D.20836;
  int D.20837;
  int D.20838;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.18018>;
  <D.18017>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.18018>:
  D.20795 = BIT_FIELD_REF <*method, 8, 168>;
  D.20796 = D.20795 & 16;
  if (D.20796 != 0) goto <D.18017>; else goto <D.18019>;
  <D.18019>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.20799 = method->flags;
  D.20800 = (int) D.20799;
  D.20801 = D.20800 & 1024;
  if (D.20801 != 0) goto <D.20797>; else goto <D.20802>;
  <D.20802>:
  D.20803 = method->iflags;
  D.20804 = (unsigned int) D.20803;
  D.20805 = D.20804 & 4099;
  if (D.20805 != 0) goto <D.20797>; else goto <D.20806>;
  <D.20806>:
  D.20799 = method->flags;
  D.20800 = (int) D.20799;
  D.20807 = D.20800 & 8192;
  if (D.20807 != 0) goto <D.20797>; else goto <D.20798>;
  <D.20797>:
  D.20808 = 0;
  return D.20808;
  <D.20798>:
  D.20809 = BIT_FIELD_REF <*method, 16, 160>;
  D.20810 = D.20809 & 1148;
  if (D.20810 != 0) goto <D.20811>; else goto <D.20812>;
  <D.20811>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.20813>; else goto <D.20814>;
    <D.20813>:
    D.20808 = 0;
    return D.20808;
    <D.20814>:
    D.20815 = header->code_size;
    summary->code_size = D.20815;
    D.20816 = header->num_clauses;
    D.20817 = (int) D.20816;
    D.20818 = D.20817 > 0;
    D.20819 = (int) D.20818;
    summary->has_clauses = D.20819;
    D.20808 = 1;
    return D.20808;
  }
  <D.20812>:
  D.20820 = method->token;
  D.20821 = (int) D.20820;
  idx = D.20821 & 16777215;
  D.20822 = method->klass;
  img = D.20822->image;
  D.20823 = idx + -1;
  D.20824 = &img->tables[6];
  rva = mono_metadata_decode_row_col (D.20824, D.20823, 0);
  D.20825 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.20825 == 0) goto <D.20826>; else goto <D.20827>;
  <D.20826>:
  D.20808 = 0;
  return D.20808;
  <D.20827>:
  ptr = mono_image_rva_map (img, rva);
  D.20828 = ptr == 0B;
  D.20829 = (long int) D.20828;
  D.20830 = __builtin_expect (D.20829, 0);
  if (D.20830 != 0) goto <D.20831>; else goto <D.20832>;
  <D.20831>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.20832>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.20833 = (int) format;
  switch (D.20833) <default: <D.18024>, case 2: <D.18021>, case 3: <D.18023>>
  <D.18021>:
  ptr = ptr + 1;
  D.20834 = flags >> 2;
  D.20835 = (unsigned int) D.20834;
  summary->code_size = D.20835;
  goto <D.18022>;
  <D.18023>:
  fat_flags = MEM[(const guint16 *)ptr];
  ptr = ptr + 4;
  D.20836 = MEM[(const guint32 *)ptr];
  summary->code_size = D.20836;
  D.20837 = (int) fat_flags;
  D.20838 = D.20837 & 8;
  if (D.20838 != 0) goto <D.20839>; else goto <D.20840>;
  <D.20839>:
  summary->has_clauses = 1;
  <D.20840>:
  goto <D.18022>;
  <D.18024>:
  D.20808 = 0;
  return D.20808;
  <D.18022>:
  D.20808 = 1;
  return D.20808;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.20844;
  int D.20845;
  unsigned char D.20846;
  unsigned int D.20847;
  short unsigned int D.20848;
  int D.20849;
  short unsigned int D.20850;
  int D.20851;
  int D.20852;
  int D.20856;
  unsigned int D.20860;
  unsigned int D.20861;
  <unnamed-unsigned:24> D.20864;
  int D.20865;
  unsigned int D.20867;
  int D.20868;
  const char * locals_ptr.118;
  const char * locals_ptr.119;
  unsigned int D.20877;
  char D.20878;
  const char * locals_ptr.120;
  unsigned int D.20882;
  int num_clauses.121;
  unsigned int num_clauses.122;
  unsigned int D.20885;
  unsigned int len.123;
  unsigned int D.20887;
  unsigned int D.20888;
  unsigned int D.20889;
  short unsigned int D.20890;
  struct MonoType * D.20891;
  struct MonoType * D.20892;
  unsigned int D.20896;
  unsigned int D.20897;
  short unsigned int D.20898;
  <unnamed-unsigned:15> D.20899;
  unsigned char D.20900;
  <unnamed-unsigned:1> D.20901;
  short unsigned int D.20904;
  int D.20905;
  short unsigned int D.20906;
  <unnamed-unsigned:15> D.20907;
  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.20842>; else goto <D.20843>;
      <D.20842>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.20844 = 0B;
      return D.20844;
      <D.20843>:
      D.20845 = (int) format;
      switch (D.20845) <default: <D.18047>, case 2: <D.18044>, case 3: <D.18045>>
      <D.18044>:
      mh = monoeg_malloc0 (20);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.20846 = flags >> 2;
      D.20847 = (unsigned int) D.20846;
      mh->code_size = D.20847;
      mh->code = ptr;
      D.20844 = mh;
      return D.20844;
      <D.18045>:
      fat_flags = MEM[(const guint16 *)ptr];
      ptr = ptr + 2;
      D.20848 = fat_flags >> 12;
      D.20849 = (int) D.20848;
      hsize = D.20849 & 15;
      D.20850 = MEM[(const guint16 *)ptr];
      max_stack = (guint32) D.20850;
      ptr = ptr + 2;
      code_size = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      local_var_sig_tok = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      D.20851 = (int) fat_flags;
      D.20852 = D.20851 & 16;
      if (D.20852 != 0) goto <D.20853>; else goto <D.20854>;
      <D.20853>:
      init_locals = 1;
      goto <D.20855>;
      <D.20854>:
      init_locals = 0;
      <D.20855>:
      code = ptr;
      D.20851 = (int) fat_flags;
      D.20856 = D.20851 & 8;
      if (D.20856 == 0) goto <D.18046>; else goto <D.20857>;
      <D.20857>:
      ptr = code + code_size;
      goto <D.18046>;
      <D.18047>:
      D.20844 = 0B;
      return D.20844;
      <D.18046>:
      if (local_var_sig_tok != 0) goto <D.20858>; else goto <D.20859>;
      <D.20858>:
      {
        int idx;

        D.20860 = local_var_sig_tok & 16777215;
        D.20861 = D.20860 + 4294967295;
        idx = (int) D.20861;
        D.20864 = t->rows;
        D.20865 = (int) D.20864;
        if (D.20865 <= idx) goto <D.20862>; else goto <D.20866>;
        <D.20866>:
        if (idx < 0) goto <D.20862>; else goto <D.20863>;
        <D.20862>:
        D.20844 = 0B;
        return D.20844;
        <D.20863>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.20867 = cols[0];
        D.20868 = mono_verifier_verify_standalone_signature (m, D.20867, 0B);
        if (D.20868 == 0) goto <D.20869>; else goto <D.20870>;
        <D.20869>:
        D.20844 = 0B;
        return D.20844;
        <D.20870>:
      }
      <D.20859>:
      D.20851 = (int) fat_flags;
      D.20856 = D.20851 & 8;
      if (D.20856 != 0) goto <D.20871>; else goto <D.20872>;
      <D.20871>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.20872>:
      if (local_var_sig_tok != 0) goto <D.20873>; else goto <D.20874>;
      <D.20873>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.20867 = cols[0];
            locals_ptr.118 = mono_metadata_blob_heap (m, D.20867);
            locals_ptr = locals_ptr.118;
            locals_ptr.119 = locals_ptr;
            D.20877 = mono_metadata_decode_blob_size (locals_ptr.119, &locals_ptr);
            bsize = (int) D.20877;
            locals_ptr.119 = locals_ptr;
            D.20878 = *locals_ptr.119;
            if (D.20878 != 7) goto <D.20879>; else goto <D.20880>;
            <D.20879>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.20880>:
            locals_ptr.119 = locals_ptr;
            locals_ptr.120 = locals_ptr.119 + 1;
            locals_ptr = locals_ptr.120;
            locals_ptr.119 = locals_ptr;
            D.20882 = mono_metadata_decode_value (locals_ptr.119, &locals_ptr);
            len = (int) D.20882;
            num_clauses.121 = num_clauses;
            num_clauses.122 = (unsigned int) num_clauses.121;
            D.20885 = num_clauses.122 * 6;
            len.123 = (unsigned int) len;
            D.20887 = D.20885 + len.123;
            D.20888 = D.20887 + 5;
            D.20889 = D.20888 * 4;
            mh = monoeg_malloc0 (D.20889);
            D.20890 = (short unsigned int) len;
            mh->num_locals = D.20890;
            i = 0;
            goto <D.18054>;
            <D.18053>:
            locals_ptr.119 = locals_ptr;
            D.20891 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.119, &locals_ptr);
            mh->locals[i] = D.20891;
            D.20892 = mh->locals[i];
            if (D.20892 == 0B) goto <D.20893>; else goto <D.20894>;
            <D.20893>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.20844 = 0B;
            return D.20844;
            <D.20894>:
            i = i + 1;
            <D.18054>:
            if (i < len) goto <D.18053>; else goto <D.18055>;
            <D.18055>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.20895>;
      <D.20874>:
      num_clauses.121 = num_clauses;
      num_clauses.122 = (unsigned int) num_clauses.121;
      D.20896 = num_clauses.122 * 24;
      D.20897 = D.20896 + 20;
      mh = monoeg_malloc0 (D.20897);
      <D.20895>:
      mh->code = code;
      mh->code_size = code_size;
      D.20898 = (short unsigned int) max_stack;
      D.20899 = (<unnamed-unsigned:15>) D.20898;
      mh->max_stack = D.20899;
      mh->is_transient = 1;
      D.20900 = (unsigned char) init_locals;
      D.20901 = (<unnamed-unsigned:1>) D.20900;
      mh->init_locals = D.20901;
      if (clauses != 0B) goto <D.20902>; else goto <D.20903>;
      <D.20902>:
      {
        struct MonoExceptionClause * clausesp;

        D.20904 = mh->num_locals;
        D.20905 = (int) D.20904;
        clausesp = &mh->locals[D.20905];
        num_clauses.121 = num_clauses;
        num_clauses.122 = (unsigned int) num_clauses.121;
        D.20896 = num_clauses.122 * 24;
        memcpy (clausesp, clauses, D.20896);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.121 = num_clauses;
        D.20906 = (short unsigned int) num_clauses.121;
        D.20907 = (<unnamed-unsigned:15>) D.20906;
        mh->num_clauses = D.20907;
      }
      <D.20903>:
      D.20844 = mh;
      return D.20844;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.20912;
  const unsigned char * D.20915;
  unsigned char D.20916;
  int D.20917;
  int D.20918;
  const unsigned char * D.20919;
  unsigned char D.20920;
  int D.20921;
  int D.20922;
  int D.20923;
  unsigned char D.20924;
  int D.20925;
  int D.20926;
  int D.20928;
  int iftmp.124;
  unsigned int D.20934;
  unsigned int D.20936;
  int D.20937;
  unsigned int D.20938;
  unsigned int D.20939;
  unsigned int i.125;
  unsigned int D.20941;
  unsigned int D.20944;
  unsigned int D.20945;
  unsigned int D.20946;
  unsigned int D.20947;
  unsigned int D.20948;
  short unsigned int D.20950;
  unsigned int D.20951;
  const guint16 * D.20952;
  short unsigned int D.20953;
  unsigned int D.20954;
  const unsigned char * D.20955;
  unsigned char D.20956;
  unsigned int D.20957;
  const guint16 * D.20958;
  short unsigned int D.20959;
  unsigned int D.20960;
  const unsigned char * D.20961;
  unsigned char D.20962;
  unsigned int D.20963;
  unsigned int D.20964;
  struct MonoClass * iftmp.126;
  signed char sect_data_flags.127;
  sizetype D.20978;
  struct MonoExceptionClause * D.20980;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.18005>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.20912 = (int) sect_data_flags;
  is_fat = D.20912 & 64;
  if (is_fat != 0) goto <D.20913>; else goto <D.20914>;
  <D.20913>:
  D.20915 = ptr + 2;
  D.20916 = *D.20915;
  D.20917 = (int) D.20916;
  D.20918 = D.20917 << 16;
  D.20919 = ptr + 1;
  D.20920 = *D.20919;
  D.20921 = (int) D.20920;
  D.20922 = D.20921 << 8;
  D.20923 = D.20918 | D.20922;
  D.20924 = *ptr;
  D.20925 = (int) D.20924;
  D.20926 = D.20923 | D.20925;
  sect_data_len = (guint32) D.20926;
  ptr = ptr + 3;
  goto <D.20927>;
  <D.20914>:
  D.20924 = *ptr;
  sect_data_len = (guint32) D.20924;
  ptr = ptr + 1;
  <D.20927>:
  D.20912 = (int) sect_data_flags;
  D.20928 = D.20912 & 1;
  if (D.20928 != 0) goto <D.20929>; else goto <D.20930>;
  <D.20929>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.20932>; else goto <D.20933>;
    <D.20932>:
    D.20934 = sect_data_len / 24;
    iftmp.124 = (int) D.20934;
    goto <D.20935>;
    <D.20933>:
    D.20936 = sect_data_len / 12;
    iftmp.124 = (int) D.20936;
    <D.20935>:
    *num_clauses = iftmp.124;
    D.20937 = *num_clauses;
    D.20938 = (unsigned int) D.20937;
    D.20939 = D.20938 * 24;
    clauses = monoeg_malloc0 (D.20939);
    i = 0;
    goto <D.18003>;
    <D.18002>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      i.125 = (unsigned int) i;
      D.20941 = i.125 * 24;
      ec = clauses + D.20941;
      if (is_fat != 0) goto <D.20942>; else goto <D.20943>;
      <D.20942>:
      D.20944 = MEM[(const guint32 *)p];
      ec->flags = D.20944;
      D.20945 = MEM[(const guint32 *)p + 4B];
      ec->try_offset = D.20945;
      D.20946 = MEM[(const guint32 *)p + 8B];
      ec->try_len = D.20946;
      D.20947 = MEM[(const guint32 *)p + 12B];
      ec->handler_offset = D.20947;
      D.20948 = MEM[(const guint32 *)p + 16B];
      ec->handler_len = D.20948;
      tof_value = MEM[(const guint32 *)p + 20B];
      p = p + 24;
      goto <D.20949>;
      <D.20943>:
      D.20950 = MEM[(const guint16 *)p];
      D.20951 = (unsigned int) D.20950;
      ec->flags = D.20951;
      D.20952 = p + 2;
      D.20953 = *D.20952;
      D.20954 = (unsigned int) D.20953;
      ec->try_offset = D.20954;
      D.20955 = p + 4;
      D.20956 = *D.20955;
      D.20957 = (unsigned int) D.20956;
      ec->try_len = D.20957;
      D.20958 = p + 5;
      D.20959 = *D.20958;
      D.20960 = (unsigned int) D.20959;
      ec->handler_offset = D.20960;
      D.20961 = p + 7;
      D.20962 = *D.20961;
      D.20963 = (unsigned int) D.20962;
      ec->handler_len = D.20963;
      tof_value = MEM[(const guint32 *)p + 8B];
      p = p + 12;
      <D.20949>:
      D.20964 = ec->flags;
      if (D.20964 == 1) goto <D.20965>; else goto <D.20966>;
      <D.20965>:
      ec->data.filter_offset = tof_value;
      goto <D.20967>;
      <D.20966>:
      D.20964 = ec->flags;
      if (D.20964 == 0) goto <D.20968>; else goto <D.20969>;
      <D.20968>:
      if (tof_value != 0) goto <D.20971>; else goto <D.20972>;
      <D.20971>:
      iftmp.126 = mono_class_get (m, tof_value);
      goto <D.20973>;
      <D.20972>:
      iftmp.126 = 0B;
      <D.20973>:
      ec->data.catch_class = iftmp.126;
      goto <D.20974>;
      <D.20969>:
      ec->data.catch_class = 0B;
      <D.20974>:
      <D.20967>:
    }
    i = i + 1;
    <D.18003>:
    D.20937 = *num_clauses;
    if (D.20937 > i) goto <D.18002>; else goto <D.18004>;
    <D.18004>:
  }
  <D.20930>:
  sect_data_flags.127 = (signed char) sect_data_flags;
  if (sect_data_flags.127 < 0) goto <D.20976>; else goto <D.20977>;
  <D.20976>:
  D.20978 = sect_data_len + 4294967292;
  ptr = ptr + D.20978;
  goto <D.20979>;
  <D.20977>:
  D.20980 = clauses;
  return D.20980;
  <D.20979>:
  goto <D.18005>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.20982;
  const unsigned char * D.20983;
  unsigned int D.20984;
  unsigned int D.20985;

  D.20983 = ptr + 3;
  D.20984 = (unsigned int) D.20983;
  D.20985 = D.20984 & 4294967292;
  D.20982 = (const unsigned char *) D.20985;
  return D.20982;
}


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

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


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  unsigned char D.20989;
  unsigned char D.20990;
  struct MonoType * D.20993;
  short unsigned int D.20994;
  int D.20995;
  int i;

  D.20989 = BIT_FIELD_REF <*mh, 8, 72>;
  D.20990 = D.20989 & 128;
  if (D.20990 != 0) goto <D.20991>; else goto <D.20992>;
  <D.20991>:
  i = 0;
  goto <D.18067>;
  <D.18066>:
  D.20993 = mh->locals[i];
  mono_metadata_free_type (D.20993);
  i = i + 1;
  <D.18067>:
  D.20994 = mh->num_locals;
  D.20995 = (int) D.20994;
  if (D.20995 > i) goto <D.18066>; else goto <D.18068>;
  <D.18068>:
  monoeg_g_free (mh);
  <D.20992>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.20998;
  <unnamed-unsigned:15> D.21001;
  unsigned int D.21002;
  const unsigned char * D.21003;

  if (code_size != 0B) goto <D.20996>; else goto <D.20997>;
  <D.20996>:
  D.20998 = header->code_size;
  *code_size = D.20998;
  <D.20997>:
  if (max_stack != 0B) goto <D.20999>; else goto <D.21000>;
  <D.20999>:
  D.21001 = header->max_stack;
  D.21002 = (unsigned int) D.21001;
  *max_stack = D.21002;
  <D.21000>:
  D.21003 = header->code;
  return D.21003;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.21007;
  unsigned int D.21008;
  <unnamed-unsigned:1> D.21011;
  int D.21012;
  struct MonoType * * D.21013;

  if (num_locals != 0B) goto <D.21005>; else goto <D.21006>;
  <D.21005>:
  D.21007 = header->num_locals;
  D.21008 = (unsigned int) D.21007;
  *num_locals = D.21008;
  <D.21006>:
  if (init_locals != 0B) goto <D.21009>; else goto <D.21010>;
  <D.21009>:
  D.21011 = header->init_locals;
  D.21012 = (int) D.21011;
  *init_locals = D.21012;
  <D.21010>:
  D.21013 = &header->locals;
  return D.21013;
}


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

  D.21016 = header->num_clauses;
  D.21015 = (int) D.21016;
  return D.21015;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  short unsigned int D.21021;
  short unsigned int D.21022;
  int D.21023;
  void * D.21024;
  struct MonoExceptionClause * D.21027;
  <unnamed-unsigned:15> D.21028;
  unsigned int D.21029;
  unsigned int D.21030;
  struct MonoExceptionClause * D.21031;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.21018>; else goto <D.21020>;
  <D.21020>:
  D.21021 = BIT_FIELD_REF <*header, 16, 80>;
  D.21022 = D.21021 & 32767;
  if (D.21022 == 0) goto <D.21018>; else goto <D.21019>;
  <D.21018>:
  D.21023 = 0;
  return D.21023;
  <D.21019>:
  D.21024 = *iter;
  if (D.21024 == 0B) goto <D.21025>; else goto <D.21026>;
  <D.21025>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.21023 = 1;
  return D.21023;
  <D.21026>:
  sc = *iter;
  sc = sc + 24;
  D.21027 = header->clauses;
  D.21028 = header->num_clauses;
  D.21029 = (unsigned int) D.21028;
  D.21030 = D.21029 * 24;
  D.21031 = D.21027 + D.21030;
  if (D.21031 > sc) goto <D.21032>; else goto <D.21033>;
  <D.21032>:
  *iter = sc;
  *clause = *sc;
  D.21023 = 1;
  return D.21023;
  <D.21033>:
  D.21023 = 0;
  return D.21023;
}


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

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


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

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


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

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


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.21042;
  uint32_t D.21045;
  int index.128;
  int D.21047;
  unsigned char D.21048;
  unsigned char D.21049;
  int D.21052;
  unsigned int D.21053;
  int D.21054;
  unsigned char D.21055;
  unsigned int D.21056;
  <unnamed-unsigned:24> D.21057;
  unsigned int D.21058;
  void * D.21059;
  unsigned int D.21062;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21042 = tdef->base;
      if (D.21042 == 0B) goto <D.21043>; else goto <D.21044>;
      <D.21043>:
      D.21045 = 0;
      return D.21045;
      <D.21044>:
      index.128 = (int) index;
      D.21047 = index.128 & 16777215;
      loc.idx = D.21047;
      loc.col_idx = 4;
      loc.t = tdef;
      D.21048 = BIT_FIELD_REF <*meta, 8, 128>;
      D.21049 = D.21048 & 32;
      if (D.21049 != 0) goto <D.21050>; else goto <D.21051>;
      <D.21050>:
      D.21052 = loc.idx;
      D.21053 = search_ptr_table (meta, 3, D.21052);
      D.21054 = (int) D.21053;
      loc.idx = D.21054;
      <D.21051>:
      D.21055 = tdef->row_size;
      D.21056 = (unsigned int) D.21055;
      D.21057 = tdef->rows;
      D.21058 = (unsigned int) D.21057;
      D.21042 = tdef->base;
      D.21059 = mono_binary_search (&loc, D.21042, D.21058, D.21056, typedef_locator);
      if (D.21059 == 0B) goto <D.21060>; else goto <D.21061>;
      <D.21060>:
      D.21045 = 0;
      return D.21045;
      <D.21061>:
      D.21062 = loc.result;
      D.21045 = D.21062 + 1;
      return D.21045;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  int bb.129;
  struct MonoTableInfo * D.21066;
  const char * D.21067;
  int D.21068;
  int D.21069;
  unsigned char D.21070;
  int D.21071;
  int D.21072;
  unsigned int D.21073;
  int D.21074;
  unsigned int D.21075;
  int D.21078;
  int D.21079;
  <unnamed-unsigned:24> D.21080;
  int D.21081;
  unsigned int typedef_index.130;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.129 = (int) bb;
  D.21066 = loc->t;
  D.21067 = D.21066->base;
  D.21068 = (int) D.21067;
  D.21069 = bb.129 - D.21068;
  D.21066 = loc->t;
  D.21070 = D.21066->row_size;
  D.21071 = (int) D.21070;
  typedef_index = D.21069 / D.21071;
  D.21072 = loc->col_idx;
  D.21073 = (unsigned int) D.21072;
  D.21066 = loc->t;
  col = mono_metadata_decode_row_col (D.21066, typedef_index, D.21073);
  D.21074 = loc->idx;
  D.21075 = (unsigned int) D.21074;
  if (D.21075 < col) goto <D.21076>; else goto <D.21077>;
  <D.21076>:
  D.21078 = -1;
  return D.21078;
  <D.21077>:
  D.21079 = typedef_index + 1;
  D.21066 = loc->t;
  D.21080 = D.21066->rows;
  D.21081 = (int) D.21080;
  if (D.21079 < D.21081) goto <D.21082>; else goto <D.21083>;
  <D.21082>:
  D.21072 = loc->col_idx;
  D.21073 = (unsigned int) D.21072;
  D.21079 = typedef_index + 1;
  D.21066 = loc->t;
  col_next = mono_metadata_decode_row_col (D.21066, D.21079, D.21073);
  D.21074 = loc->idx;
  D.21075 = (unsigned int) D.21074;
  if (D.21075 >= col_next) goto <D.21084>; else goto <D.21085>;
  <D.21084>:
  D.21078 = 1;
  return D.21078;
  <D.21085>:
  if (col == col_next) goto <D.21086>; else goto <D.21087>;
  <D.21086>:
  D.21078 = 1;
  return D.21078;
  <D.21087>:
  <D.21083>:
  typedef_index.130 = (unsigned int) typedef_index;
  loc->result = typedef_index.130;
  D.21078 = 0;
  return D.21078;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.21090;
  unsigned int idx.131;
  <unnamed-unsigned:24> D.21093;
  int D.21094;
  guint32 D.21097;
  int D.21098;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.18149>;
  <D.18148>:
  D.21090 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.131 = (unsigned int) idx;
  if (D.21090 == idx.131) goto <D.18147>; else goto <D.21092>;
  <D.21092>:
  i = i + 1;
  <D.18149>:
  D.21093 = ptrdef->rows;
  D.21094 = (int) D.21093;
  if (D.21094 > i) goto <D.18148>; else goto <D.18147>;
  <D.18147>:
  D.21093 = ptrdef->rows;
  D.21094 = (int) D.21093;
  if (D.21094 > i) goto <D.21095>; else goto <D.21096>;
  <D.21095>:
  D.21098 = i + 1;
  D.21097 = (guint32) D.21098;
  return D.21097;
  <D.21096>:
  D.21097 = (guint32) idx;
  return D.21097;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.21100;
  uint32_t D.21103;
  int index.132;
  int D.21105;
  unsigned char D.21106;
  unsigned char D.21107;
  int D.21110;
  unsigned int D.21111;
  int D.21112;
  unsigned char D.21113;
  unsigned int D.21114;
  <unnamed-unsigned:24> D.21115;
  unsigned int D.21116;
  void * D.21117;
  unsigned int D.21120;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21100 = tdef->base;
      if (D.21100 == 0B) goto <D.21101>; else goto <D.21102>;
      <D.21101>:
      D.21103 = 0;
      return D.21103;
      <D.21102>:
      index.132 = (int) index;
      D.21105 = index.132 & 16777215;
      loc.idx = D.21105;
      loc.col_idx = 5;
      loc.t = tdef;
      D.21106 = BIT_FIELD_REF <*meta, 8, 128>;
      D.21107 = D.21106 & 32;
      if (D.21107 != 0) goto <D.21108>; else goto <D.21109>;
      <D.21108>:
      D.21110 = loc.idx;
      D.21111 = search_ptr_table (meta, 5, D.21110);
      D.21112 = (int) D.21111;
      loc.idx = D.21112;
      <D.21109>:
      D.21113 = tdef->row_size;
      D.21114 = (unsigned int) D.21113;
      D.21115 = tdef->rows;
      D.21116 = (unsigned int) D.21115;
      D.21100 = tdef->base;
      D.21117 = mono_binary_search (&loc, D.21100, D.21116, D.21114, typedef_locator);
      if (D.21117 == 0B) goto <D.21118>; else goto <D.21119>;
      <D.21118>:
      D.21103 = 0;
      return D.21103;
      <D.21119>:
      D.21120 = loc.result;
      D.21103 = D.21120 + 1;
      return D.21103;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_interfaces_from_typedef_full (struct MonoImage * meta, guint32 index, struct MonoClass * * * interfaces, guint * count, gboolean heap_alloc_result, struct MonoGenericContext * context)
{
  const char * D.21123;
  gboolean D.21126;
  int index.133;
  int D.21128;
  unsigned char D.21129;
  unsigned int D.21130;
  <unnamed-unsigned:24> D.21131;
  unsigned int D.21132;
  void * D.21133;
  int D.21136;
  unsigned int D.21137;
  unsigned int D.21138;
  int D.21139;
  unsigned int D.21140;
  int pos.134;
  unsigned int D.21143;
  unsigned int D.21144;
  unsigned int D.21146;
  unsigned int D.21149;
  unsigned int D.21150;
  unsigned int D.21153;
  unsigned int D.21154;
  unsigned int D.21157;
  struct MonoClass * * D.21158;
  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.21123 = tdef->base;
      if (D.21123 == 0B) goto <D.21124>; else goto <D.21125>;
      <D.21124>:
      D.21126 = 1;
      return D.21126;
      <D.21125>:
      index.133 = (int) index;
      D.21128 = index.133 & 16777215;
      loc.idx = D.21128;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21129 = tdef->row_size;
      D.21130 = (unsigned int) D.21129;
      D.21131 = tdef->rows;
      D.21132 = (unsigned int) D.21131;
      D.21123 = tdef->base;
      D.21133 = mono_binary_search (&loc, D.21123, D.21132, D.21130, table_locator);
      if (D.21133 == 0B) goto <D.21134>; else goto <D.21135>;
      <D.21134>:
      D.21126 = 1;
      return D.21126;
      <D.21135>:
      start = loc.result;
      goto <D.18178>;
      <D.18177>:
      D.21136 = loc.idx;
      D.21137 = (unsigned int) D.21136;
      D.21138 = start + 4294967295;
      D.21139 = (int) D.21138;
      D.21140 = mono_metadata_decode_row_col (tdef, D.21139, 0);
      if (D.21137 == D.21140) goto <D.21141>; else goto <D.18176>;
      <D.21141>:
      start = start + 4294967295;
      <D.18178>:
      if (start != 0) goto <D.18177>; else goto <D.18176>;
      <D.18176>:
      pos = start;
      goto <D.18181>;
      <D.18180>:
      pos.134 = (int) pos;
      mono_metadata_decode_row (tdef, pos.134, &cols, 2);
      D.21143 = cols[0];
      D.21136 = loc.idx;
      D.21144 = (unsigned int) D.21136;
      if (D.21143 != D.21144) goto <D.18179>; else goto <D.21145>;
      <D.21145>:
      pos = pos + 1;
      <D.18181>:
      D.21131 = tdef->rows;
      D.21146 = (unsigned int) D.21131;
      if (D.21146 > pos) goto <D.18180>; else goto <D.18179>;
      <D.18179>:
      if (heap_alloc_result != 0) goto <D.21147>; else goto <D.21148>;
      <D.21147>:
      D.21149 = pos - start;
      D.21150 = D.21149 * 4;
      result = monoeg_malloc0 (D.21150);
      goto <D.21151>;
      <D.21148>:
      D.21149 = pos - start;
      D.21150 = D.21149 * 4;
      result = mono_image_alloc0 (meta, D.21150);
      <D.21151>:
      pos = start;
      goto <D.18185>;
      <D.18184>:
      {
        struct MonoClass * iface;

        pos.134 = (int) pos;
        mono_metadata_decode_row (tdef, pos.134, &cols, 2);
        D.21143 = cols[0];
        D.21136 = loc.idx;
        D.21144 = (unsigned int) D.21136;
        if (D.21143 != D.21144) goto <D.18183>; else goto <D.21152>;
        <D.21152>:
        D.21153 = cols[1];
        D.21154 = mono_metadata_token_from_dor (D.21153);
        iface = mono_class_get_full (meta, D.21154, context);
        if (iface == 0B) goto <D.21155>; else goto <D.21156>;
        <D.21155>:
        D.21126 = 0;
        return D.21126;
        <D.21156>:
        D.21149 = pos - start;
        D.21157 = D.21149 * 4;
        D.21158 = result + D.21157;
        *D.21158 = iface;
        pos = pos + 1;
      }
      <D.18185>:
      D.21131 = tdef->rows;
      D.21146 = (unsigned int) D.21131;
      if (D.21146 > pos) goto <D.18184>; else goto <D.18183>;
      <D.18183>:
      D.21149 = pos - start;
      *count = D.21149;
      *interfaces = result;
      D.21126 = 1;
      return D.21126;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  int bb.135;
  struct MonoTableInfo * D.21162;
  const char * D.21163;
  int D.21164;
  int D.21165;
  unsigned char D.21166;
  int D.21167;
  int D.21168;
  int D.21169;
  unsigned int D.21170;
  int table_index.136;
  int D.21172;
  unsigned int D.21173;
  int D.21176;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.135 = (int) bb;
  D.21162 = loc->t;
  D.21163 = D.21162->base;
  D.21164 = (int) D.21163;
  D.21165 = bb.135 - D.21164;
  D.21162 = loc->t;
  D.21166 = D.21162->row_size;
  D.21167 = (int) D.21166;
  D.21168 = D.21165 / D.21167;
  table_index = (guint32) D.21168;
  D.21169 = loc->col_idx;
  D.21170 = (unsigned int) D.21169;
  table_index.136 = (int) table_index;
  D.21162 = loc->t;
  col = mono_metadata_decode_row_col (D.21162, table_index.136, D.21170);
  D.21172 = loc->idx;
  D.21173 = (unsigned int) D.21172;
  if (D.21173 == col) goto <D.21174>; else goto <D.21175>;
  <D.21174>:
  loc->result = table_index;
  D.21176 = 0;
  return D.21176;
  <D.21175>:
  D.21172 = loc->idx;
  D.21173 = (unsigned int) D.21172;
  if (D.21173 < col) goto <D.21177>; else goto <D.21178>;
  <D.21177>:
  D.21176 = -1;
  return D.21176;
  <D.21178>:
  D.21176 = 1;
  return D.21176;
}


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


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.21185;
  uint32_t D.21188;
  int index.137;
  int D.21190;
  unsigned char D.21191;
  unsigned int D.21192;
  <unnamed-unsigned:24> D.21193;
  unsigned int D.21194;
  void * D.21195;
  unsigned int D.21198;
  int D.21199;
  unsigned int D.21200;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.21185 = tdef->base;
      if (D.21185 == 0B) goto <D.21186>; else goto <D.21187>;
      <D.21186>:
      D.21188 = 0;
      return D.21188;
      <D.21187>:
      index.137 = (int) index;
      D.21190 = index.137 & 16777215;
      loc.idx = D.21190;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21191 = tdef->row_size;
      D.21192 = (unsigned int) D.21191;
      D.21193 = tdef->rows;
      D.21194 = (unsigned int) D.21193;
      D.21185 = tdef->base;
      D.21195 = mono_binary_search (&loc, D.21185, D.21194, D.21192, table_locator);
      if (D.21195 == 0B) goto <D.21196>; else goto <D.21197>;
      <D.21196>:
      D.21188 = 0;
      return D.21188;
      <D.21197>:
      D.21198 = loc.result;
      D.21199 = (int) D.21198;
      D.21200 = mono_metadata_decode_row_col (tdef, D.21199, 1);
      D.21188 = D.21200 | 33554432;
      return D.21188;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.21203;
  uint32_t D.21206;
  unsigned int D.21207;
  int D.21208;
  unsigned int D.21209;
  <unnamed-unsigned:24> D.21211;
  unsigned int D.21212;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.21203 = tdef->base;
  if (D.21203 == 0B) goto <D.21204>; else goto <D.21205>;
  <D.21204>:
  D.21206 = 0;
  return D.21206;
  <D.21205>:
  start = start_index;
  goto <D.18209>;
  <D.18208>:
  D.21207 = start + 4294967295;
  D.21208 = (int) D.21207;
  D.21209 = mono_metadata_decode_row_col (tdef, D.21208, 1);
  if (D.21209 == class_index) goto <D.18207>; else goto <D.21210>;
  <D.21210>:
  start = start + 1;
  <D.18209>:
  D.21211 = tdef->rows;
  D.21212 = (unsigned int) D.21211;
  if (D.21212 >= start) goto <D.18208>; else goto <D.18207>;
  <D.18207>:
  D.21211 = tdef->rows;
  D.21212 = (unsigned int) D.21211;
  if (D.21212 < start) goto <D.21213>; else goto <D.21214>;
  <D.21213>:
  D.21206 = 0;
  return D.21206;
  <D.21214>:
  D.21206 = start;
  return D.21206;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.21216;
  uint32_t D.21219;
  int index.138;
  int D.21221;
  unsigned char D.21222;
  unsigned int D.21223;
  <unnamed-unsigned:24> D.21224;
  unsigned int D.21225;
  void * D.21226;
  unsigned int D.21229;
  int D.21230;
  unsigned int D.21233;
  unsigned int D.21236;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.21216 = tdef->base;
      if (D.21216 == 0B) goto <D.21217>; else goto <D.21218>;
      <D.21217>:
      D.21219 = 0;
      return D.21219;
      <D.21218>:
      index.138 = (int) index;
      D.21221 = index.138 & 16777215;
      loc.idx = D.21221;
      loc.col_idx = 2;
      loc.t = tdef;
      D.21222 = tdef->row_size;
      D.21223 = (unsigned int) D.21222;
      D.21224 = tdef->rows;
      D.21225 = (unsigned int) D.21224;
      D.21216 = tdef->base;
      D.21226 = mono_binary_search (&loc, D.21216, D.21225, D.21223, table_locator);
      if (D.21226 == 0B) goto <D.21227>; else goto <D.21228>;
      <D.21227>:
      D.21219 = 0;
      return D.21219;
      <D.21228>:
      D.21229 = loc.result;
      D.21230 = (int) D.21229;
      mono_metadata_decode_row (tdef, D.21230, &cols, 3);
      if (packing != 0B) goto <D.21231>; else goto <D.21232>;
      <D.21231>:
      D.21233 = cols[0];
      *packing = D.21233;
      <D.21232>:
      if (size != 0B) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      D.21236 = cols[1];
      *size = D.21236;
      <D.21235>:
      D.21229 = loc.result;
      D.21219 = D.21229 + 1;
      return D.21219;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21239;
  uint32_t D.21242;
  int index.139;
  unsigned char D.21244;
  unsigned int D.21245;
  <unnamed-unsigned:24> D.21246;
  unsigned int D.21247;
  void * D.21248;
  unsigned int D.21251;
  unsigned int D.21252;
  int D.21254;
  unsigned int D.21255;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.21239 = tdef->base;
      if (D.21239 == 0B) goto <D.21240>; else goto <D.21241>;
      <D.21240>:
      D.21242 = 0;
      return D.21242;
      <D.21241>:
      index.139 = (int) index;
      loc.idx = index.139;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21244 = tdef->row_size;
      D.21245 = (unsigned int) D.21244;
      D.21246 = tdef->rows;
      D.21247 = (unsigned int) D.21246;
      D.21239 = tdef->base;
      D.21248 = mono_binary_search (&loc, D.21239, D.21247, D.21245, table_locator);
      if (D.21248 == 0B) goto <D.21249>; else goto <D.21250>;
      <D.21249>:
      D.21242 = 0;
      return D.21242;
      <D.21250>:
      goto <D.18226>;
      <D.18225>:
      D.21251 = loc.result;
      D.21252 = D.21251 + 4294967295;
      loc.result = D.21252;
      <D.18226>:
      D.21251 = loc.result;
      if (D.21251 != 0) goto <D.21253>; else goto <D.18227>;
      <D.21253>:
      D.21251 = loc.result;
      D.21252 = D.21251 + 4294967295;
      D.21254 = (int) D.21252;
      D.21255 = mono_metadata_decode_row_col (tdef, D.21254, 0);
      if (D.21255 == index) goto <D.18225>; else goto <D.18227>;
      <D.18227>:
      D.21251 = loc.result;
      D.21242 = D.21251 + 1;
      return D.21242;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21258;
  uint32_t D.21261;
  int index.140;
  unsigned char D.21263;
  unsigned int D.21264;
  <unnamed-unsigned:24> D.21265;
  unsigned int D.21266;
  void * D.21267;
  unsigned int D.21270;
  unsigned int D.21271;
  int D.21273;
  unsigned int D.21274;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.21258 = tdef->base;
      if (D.21258 == 0B) goto <D.21259>; else goto <D.21260>;
      <D.21259>:
      D.21261 = 4294967295;
      return D.21261;
      <D.21260>:
      index.140 = (int) index;
      loc.idx = index.140;
      loc.col_idx = 1;
      loc.t = tdef;
      D.21263 = tdef->row_size;
      D.21264 = (unsigned int) D.21263;
      D.21265 = tdef->rows;
      D.21266 = (unsigned int) D.21265;
      D.21258 = tdef->base;
      D.21267 = mono_binary_search (&loc, D.21258, D.21266, D.21264, declsec_locator);
      if (D.21267 == 0B) goto <D.21268>; else goto <D.21269>;
      <D.21268>:
      D.21261 = 4294967295;
      return D.21261;
      <D.21269>:
      goto <D.18235>;
      <D.18234>:
      D.21270 = loc.result;
      D.21271 = D.21270 + 4294967295;
      loc.result = D.21271;
      <D.18235>:
      D.21270 = loc.result;
      if (D.21270 != 0) goto <D.21272>; else goto <D.18236>;
      <D.21272>:
      D.21270 = loc.result;
      D.21271 = D.21270 + 4294967295;
      D.21273 = (int) D.21271;
      D.21274 = mono_metadata_decode_row_col (tdef, D.21273, 1);
      if (D.21274 == index) goto <D.18234>; else goto <D.18236>;
      <D.18236>:
      D.21261 = loc.result;
      return D.21261;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  int bb.141;
  struct MonoTableInfo * D.21278;
  const char * D.21279;
  int D.21280;
  int D.21281;
  unsigned char D.21282;
  int D.21283;
  int D.21284;
  int D.21285;
  unsigned int D.21286;
  int table_index.142;
  int D.21288;
  unsigned int D.21289;
  int D.21292;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.141 = (int) bb;
  D.21278 = loc->t;
  D.21279 = D.21278->base;
  D.21280 = (int) D.21279;
  D.21281 = bb.141 - D.21280;
  D.21278 = loc->t;
  D.21282 = D.21278->row_size;
  D.21283 = (int) D.21282;
  D.21284 = D.21281 / D.21283;
  table_index = (guint32) D.21284;
  D.21285 = loc->col_idx;
  D.21286 = (unsigned int) D.21285;
  table_index.142 = (int) table_index;
  D.21278 = loc->t;
  col = mono_metadata_decode_row_col (D.21278, table_index.142, D.21286);
  D.21288 = loc->idx;
  D.21289 = (unsigned int) D.21288;
  if (D.21289 == col) goto <D.21290>; else goto <D.21291>;
  <D.21290>:
  loc->result = table_index;
  D.21292 = 0;
  return D.21292;
  <D.21291>:
  D.21288 = loc->idx;
  D.21289 = (unsigned int) D.21288;
  if (D.21289 < col) goto <D.21293>; else goto <D.21294>;
  <D.21293>:
  D.21292 = -1;
  return D.21292;
  <D.21294>:
  D.21292 = 1;
  return D.21292;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.21298;
  unsigned char D.21299;
  unsigned char D.21300;
  unsigned char D.21303;
  int D.21304;
  struct MonoClass * D.21305;
  unsigned char D.21306;
  unsigned char D.21307;
  struct MonoType * D.21310;
  struct MonoClass * D.21311;
  unsigned char D.21312;
  unsigned char D.21313;
  unsigned char D.21316;
  struct MonoType * D.21319;
  struct MonoClass * D.21320;

  if (t == 0B) goto <D.21296>; else goto <D.21297>;
  <D.21296>:
  *align = 1;
  D.21298 = 0;
  return D.21298;
  <D.21297>:
  D.21299 = BIT_FIELD_REF <*t, 8, 56>;
  D.21300 = D.21299 & 64;
  if (D.21300 != 0) goto <D.21301>; else goto <D.21302>;
  <D.21301>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 4;
    D.21298 = 4;
    return D.21298;
  }
  <D.21302>:
  D.21303 = t->type;
  D.21304 = (int) D.21303;
  switch (D.21304) <default: <D.18312>, case 1: <D.18244>, case 2: <D.18245>, case 3: <D.18254>, case 4: <D.18249>, case 5: <D.18250>, case 6: <D.18255>, case 7: <D.18256>, case 8: <D.18260>, case 9: <D.18261>, case 10: <D.18269>, case 11: <D.18270>, case 12: <D.18265>, case 13: <D.18274>, case 14: <D.18283>, case 15: <D.18294>, case 17: <D.18291>, case 18: <D.18292>, case 19: <D.18307>, case 20: <D.18296>, case 21: <D.18301>, case 22: <D.18300>, case 24: <D.18278>, case 25: <D.18279>, case 27: <D.18295>, case 28: <D.18287>, case 29: <D.18293>, case 30: <D.18308>>
  {
    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.18244>:
    *align = 1;
    D.21298 = 0;
    return D.21298;
    <D.18245>:
    *align = 1;
    D.21298 = 1;
    return D.21298;
    <D.18249>:
    <D.18250>:
    *align = 1;
    D.21298 = 1;
    return D.21298;
    <D.18254>:
    <D.18255>:
    <D.18256>:
    *align = 2;
    D.21298 = 2;
    return D.21298;
    <D.18260>:
    <D.18261>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18265>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18269>:
    <D.18270>:
    *align = 4;
    D.21298 = 8;
    return D.21298;
    <D.18274>:
    *align = 4;
    D.21298 = 8;
    return D.21298;
    <D.18278>:
    <D.18279>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18283>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18287>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18291>:
    D.21305 = t->data.klass;
    D.21306 = BIT_FIELD_REF <*D.21305, 8, 160>;
    D.21307 = D.21306 & 16;
    if (D.21307 != 0) goto <D.21308>; else goto <D.21309>;
    <D.21308>:
    D.21305 = t->data.klass;
    D.21310 = mono_class_enum_basetype (D.21305);
    D.21298 = mono_type_size (D.21310, align);
    return D.21298;
    <D.21309>:
    D.21305 = t->data.klass;
    D.21298 = mono_class_value_size (D.21305, align);
    return D.21298;
    <D.18292>:
    <D.18293>:
    <D.18294>:
    <D.18295>:
    <D.18296>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18300>:
    D.21311 = mono_defaults.typed_reference_class;
    D.21298 = mono_class_value_size (D.21311, align);
    return D.21298;
    <D.18301>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.21312 = BIT_FIELD_REF <*container_class, 8, 160>;
      D.21313 = D.21312 & 8;
      if (D.21313 != 0) goto <D.21314>; else goto <D.21315>;
      <D.21314>:
      D.21312 = BIT_FIELD_REF <*container_class, 8, 160>;
      D.21316 = D.21312 & 16;
      if (D.21316 != 0) goto <D.21317>; else goto <D.21318>;
      <D.21317>:
      D.21319 = mono_class_enum_basetype (container_class);
      D.21298 = mono_type_size (D.21319, align);
      return D.21298;
      <D.21318>:
      D.21320 = mono_class_from_mono_type (t);
      D.21298 = mono_class_value_size (D.21320, align);
      return D.21298;
      <D.21315>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 4;
        D.21298 = 4;
        return D.21298;
      }
    }
    <D.18307>:
    <D.18308>:
    *align = 4;
    D.21298 = 4;
    return D.21298;
    <D.18312>:
    D.21303 = t->type;
    D.21304 = (int) D.21303;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.21304);
    <D.18313>:
    goto <D.18313>;
  }
  D.21298 = 0;
  return D.21298;
}


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

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


mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.21324;
  long int D.21325;
  long int D.21326;
  unsigned char D.21331;
  unsigned char D.21332;
  int D.21335;
  unsigned char D.21336;
  int D.21337;
  _Bool D.21338;
  long int D.21339;
  long int D.21340;
  struct MonoClass * D.21343;
  unsigned char D.21344;
  unsigned char D.21345;
  struct MonoType * D.21348;
  int D.21349;
  int D.21350;
  int D.21351;
  int D.21352;
  int D.21353;
  int D.21354;
  unsigned int stack_slot_size.143;
  unsigned int D.21356;
  int D.21357;
  unsigned int D.21358;
  struct MonoGenericInst * D.21361;
  unsigned char D.21362;
  unsigned char D.21363;
  _Bool D.21364;
  long int D.21365;
  long int D.21366;
  unsigned char D.21369;
  unsigned char D.21370;
  unsigned char D.21373;
  struct MonoType * D.21376;
  struct MonoClass * D.21377;
  int D.21378;
  unsigned int D.21379;
  int tmp;
  int stack_slot_size;
  int stack_slot_align;
  typedef struct 
{
  char c;
  void * x;
} struct struct 
{
  char c;
  void * x;
};

  try
    {
      stack_slot_size = 4;
      stack_slot_align = 4;
      D.21324 = t == 0B;
      D.21325 = (long int) D.21324;
      D.21326 = __builtin_expect (D.21325, 0);
      if (D.21326 != 0) goto <D.21327>; else goto <D.21328>;
      <D.21327>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.21328>:
      if (align == 0B) goto <D.21329>; else goto <D.21330>;
      <D.21329>:
      align = &tmp;
      <D.21330>:
      D.21331 = BIT_FIELD_REF <*t, 8, 56>;
      D.21332 = D.21331 & 64;
      if (D.21332 != 0) goto <D.21333>; else goto <D.21334>;
      <D.21333>:
      *align = stack_slot_align;
      D.21335 = stack_slot_size;
      return D.21335;
      <D.21334>:
      D.21336 = t->type;
      D.21337 = (int) D.21336;
      switch (D.21337) <default: <D.18368>, case 2: <D.18329>, case 3: <D.18330>, case 4: <D.18331>, case 5: <D.18332>, case 6: <D.18333>, case 7: <D.18334>, case 8: <D.18335>, case 9: <D.18336>, case 10: <D.18353>, case 11: <D.18354>, case 12: <D.18349>, case 13: <D.18358>, case 14: <D.18339>, case 15: <D.18343>, case 17: <D.18362>, case 18: <D.18341>, case 19: <D.18346>, case 20: <D.18345>, case 21: <D.18364>, case 22: <D.18348>, case 24: <D.18337>, case 25: <D.18338>, case 27: <D.18344>, case 28: <D.18340>, case 29: <D.18342>, case 30: <D.18347>>
      {
        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.18329>:
        <D.18330>:
        <D.18331>:
        <D.18332>:
        <D.18333>:
        <D.18334>:
        <D.18335>:
        <D.18336>:
        <D.18337>:
        <D.18338>:
        <D.18339>:
        <D.18340>:
        <D.18341>:
        <D.18342>:
        <D.18343>:
        <D.18344>:
        <D.18345>:
        *align = stack_slot_align;
        D.21335 = stack_slot_size;
        return D.21335;
        <D.18346>:
        <D.18347>:
        D.21338 = allow_open == 0;
        D.21339 = (long int) D.21338;
        D.21340 = __builtin_expect (D.21339, 0);
        if (D.21340 != 0) goto <D.21341>; else goto <D.21342>;
        <D.21341>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.21342>:
        *align = stack_slot_align;
        D.21335 = stack_slot_size;
        return D.21335;
        <D.18348>:
        *align = stack_slot_align;
        D.21335 = stack_slot_size * 3;
        return D.21335;
        <D.18349>:
        *align = 4;
        D.21335 = 4;
        return D.21335;
        <D.18353>:
        <D.18354>:
        *align = 4;
        D.21335 = 8;
        return D.21335;
        <D.18358>:
        *align = 4;
        D.21335 = 8;
        return D.21335;
        <D.18362>:
        {
          guint32 size;

          D.21343 = t->data.klass;
          D.21344 = BIT_FIELD_REF <*D.21343, 8, 160>;
          D.21345 = D.21344 & 16;
          if (D.21345 != 0) goto <D.21346>; else goto <D.21347>;
          <D.21346>:
          D.21343 = t->data.klass;
          D.21348 = mono_class_enum_basetype (D.21343);
          D.21335 = mono_type_stack_size_internal (D.21348, align, allow_open);
          return D.21335;
          <D.21347>:
          D.21343 = t->data.klass;
          D.21349 = mono_class_value_size (D.21343, align);
          size = (guint32) D.21349;
          D.21350 = *align;
          D.21351 = D.21350 + stack_slot_align;
          D.21352 = D.21351 + -1;
          *align = D.21352;
          D.21350 = *align;
          D.21353 = -stack_slot_align;
          D.21354 = D.21350 & D.21353;
          *align = D.21354;
          stack_slot_size.143 = (unsigned int) stack_slot_size;
          D.21356 = stack_slot_size.143 + size;
          size = D.21356 + 4294967295;
          D.21357 = -stack_slot_size;
          D.21358 = (unsigned int) D.21357;
          size = D.21358 & size;
          D.21335 = (int) size;
          return D.21335;
        }
        <D.18364>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.21359>; else goto <D.21360>;
          <D.21359>:
          D.21361 = gclass->context.class_inst;
          D.21362 = BIT_FIELD_REF <*D.21361, 8, 48>;
          D.21363 = D.21362 & 64;
          D.21364 = D.21363 != 0;
          D.21365 = (long int) D.21364;
          D.21366 = __builtin_expect (D.21365, 0);
          if (D.21366 != 0) goto <D.21367>; else goto <D.21368>;
          <D.21367>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.21368>:
          <D.21360>:
          D.21369 = BIT_FIELD_REF <*container_class, 8, 160>;
          D.21370 = D.21369 & 8;
          if (D.21370 != 0) goto <D.21371>; else goto <D.21372>;
          <D.21371>:
          D.21369 = BIT_FIELD_REF <*container_class, 8, 160>;
          D.21373 = D.21369 & 16;
          if (D.21373 != 0) goto <D.21374>; else goto <D.21375>;
          <D.21374>:
          D.21376 = mono_class_enum_basetype (container_class);
          D.21335 = mono_type_stack_size_internal (D.21376, align, allow_open);
          return D.21335;
          <D.21375>:
          {
            guint32 size;

            D.21377 = mono_class_from_mono_type (t);
            D.21378 = mono_class_value_size (D.21377, align);
            size = (guint32) D.21378;
            D.21350 = *align;
            D.21351 = D.21350 + stack_slot_align;
            D.21352 = D.21351 + -1;
            *align = D.21352;
            D.21350 = *align;
            D.21353 = -stack_slot_align;
            D.21354 = D.21350 & D.21353;
            *align = D.21354;
            stack_slot_size.143 = (unsigned int) stack_slot_size;
            D.21379 = stack_slot_size.143 + size;
            size = D.21379 + 4294967295;
            D.21357 = -stack_slot_size;
            D.21358 = (unsigned int) D.21357;
            size = D.21358 & size;
            D.21335 = (int) size;
            return D.21335;
          }
          <D.21372>:
          *align = stack_slot_align;
          D.21335 = stack_slot_size;
          return D.21335;
        }
        <D.18368>:
        D.21336 = t->type;
        D.21337 = (int) D.21336;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.21337);
        <D.18369>:
        goto <D.18369>;
      }
      D.21335 = 0;
      return D.21335;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.21382;
  _Bool D.21383;
  long int D.21384;
  long int D.21385;
  mono_bool D.21388;
  struct MonoGenericClass * D.21389;
  struct MonoClass * D.21390;
  <unnamed-unsigned:1> D.21391;

  D.21382 = type->type;
  D.21383 = D.21382 != 21;
  D.21384 = (long int) D.21383;
  D.21385 = __builtin_expect (D.21384, 0);
  if (D.21385 != 0) goto <D.21386>; else goto <D.21387>;
  <D.21386>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.21387>:
  D.21389 = type->data.generic_class;
  D.21390 = D.21389->container_class;
  D.21391 = D.21390->valuetype;
  D.21388 = (mono_bool) D.21391;
  return D.21388;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.21393;
  struct MonoClass * D.21394;
  <unnamed-unsigned:1> D.21395;

  D.21394 = gclass->container_class;
  D.21395 = D.21394->valuetype;
  D.21393 = (mono_bool) D.21395;
  return D.21393;
}


mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21397;
  unsigned int D.21400;
  unsigned int D.21401;
  unsigned int D.21402;
  struct MonoGenericInst * D.21403;
  unsigned int D.21406;
  guint D.21407;
  guint hash;

  hash = 3223191271;
  D.21397 = context->class_inst;
  if (D.21397 != 0B) goto <D.21398>; else goto <D.21399>;
  <D.21398>:
  D.21400 = hash << 5;
  D.21401 = D.21400 - hash;
  D.21397 = context->class_inst;
  D.21402 = mono_metadata_generic_inst_hash (D.21397);
  hash = D.21401 ^ D.21402;
  <D.21399>:
  D.21403 = context->method_inst;
  if (D.21403 != 0B) goto <D.21404>; else goto <D.21405>;
  <D.21404>:
  D.21400 = hash << 5;
  D.21401 = D.21400 - hash;
  D.21403 = context->method_inst;
  D.21406 = mono_metadata_generic_inst_hash (D.21403);
  hash = D.21401 ^ D.21406;
  <D.21405>:
  D.21407 = hash;
  return D.21407;
}


mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.21409;
  int iftmp.144;
  struct MonoGenericInst * D.21413;
  struct MonoGenericInst * D.21414;
  struct MonoGenericInst * D.21416;
  struct MonoGenericInst * D.21417;

  D.21413 = g1->class_inst;
  D.21414 = g2->class_inst;
  if (D.21413 == D.21414) goto <D.21415>; else goto <D.21411>;
  <D.21415>:
  D.21416 = g1->method_inst;
  D.21417 = g2->method_inst;
  if (D.21416 == D.21417) goto <D.21418>; else goto <D.21411>;
  <D.21418>:
  iftmp.144 = 1;
  goto <D.21412>;
  <D.21411>:
  iftmp.144 = 0;
  <D.21412>:
  D.21409 = iftmp.144;
  return D.21409;
}


mono_metadata_str_hash (const void * v1)
{
  char D.21420;
  unsigned int D.21423;
  unsigned int D.21424;
  unsigned int D.21425;
  char * p.145;
  char D.21427;
  guint D.21428;
  char * p;
  guint hash;

  p = v1;
  D.21420 = *p;
  hash = (guint) D.21420;
  goto <D.18404>;
  <D.18403>:
  D.21420 = *p;
  if (D.21420 != 0) goto <D.21421>; else goto <D.21422>;
  <D.21421>:
  D.21423 = hash << 5;
  D.21424 = D.21423 - hash;
  D.21420 = *p;
  D.21425 = (unsigned int) D.21420;
  hash = D.21424 + D.21425;
  <D.21422>:
  <D.18404>:
  p.145 = p;
  p = p.145 + 1;
  D.21427 = *p.145;
  if (D.21427 != 0) goto <D.18403>; else goto <D.18405>;
  <D.18405>:
  D.21428 = hash;
  return D.21428;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.21430;
  <unnamed-unsigned:1> D.21431;
  int D.21432;
  int D.21433;
  unsigned int D.21434;
  int D.21435;
  struct MonoImage * D.21436;
  unsigned char D.21437;
  unsigned char D.21438;
  unsigned int D.21441;
  const char * D.21442;
  unsigned int D.21443;
  unsigned int D.21444;
  unsigned int D.21445;
  unsigned int D.21446;
  struct MonoType * D.21447;
  unsigned int D.21448;
  struct MonoArrayType * D.21449;
  struct MonoClass * D.21450;
  struct MonoType * D.21451;
  unsigned int D.21452;
  struct MonoGenericClass * D.21453;
  unsigned int D.21454;
  guint hash;

  D.21430 = t1->type;
  hash = (guint) D.21430;
  D.21431 = t1->byref;
  D.21432 = (int) D.21431;
  D.21433 = D.21432 << 6;
  D.21434 = (unsigned int) D.21433;
  hash = D.21434 | hash;
  D.21430 = t1->type;
  D.21435 = (int) D.21430;
  switch (D.21435) <default: <D.21455>, case 15: <D.18414>, case 17: <D.18410>, case 18: <D.18411>, case 20: <D.18415>, case 21: <D.18416>, case 29: <D.18412>>
  <D.18410>:
  <D.18411>:
  <D.18412>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.21436 = class->image;
    D.21437 = BIT_FIELD_REF <*D.21436, 8, 128>;
    D.21438 = D.21437 & 8;
    if (D.21438 != 0) goto <D.21439>; else goto <D.21440>;
    <D.21439>:
    D.21431 = t1->byref;
    D.21432 = (int) D.21431;
    D.21433 = D.21432 << 6;
    D.21434 = (unsigned int) D.21433;
    D.21442 = class->name;
    D.21443 = mono_metadata_str_hash (D.21442);
    D.21441 = D.21434 | D.21443;
    return D.21441;
    <D.21440>:
    D.21444 = hash << 5;
    D.21445 = D.21444 - hash;
    D.21442 = class->name;
    D.21446 = mono_metadata_str_hash (D.21442);
    D.21441 = D.21445 ^ D.21446;
    return D.21441;
  }
  <D.18414>:
  D.21444 = hash << 5;
  D.21445 = D.21444 - hash;
  D.21447 = t1->data.type;
  D.21448 = mono_metadata_type_hash (D.21447);
  D.21441 = D.21445 ^ D.21448;
  return D.21441;
  <D.18415>:
  D.21444 = hash << 5;
  D.21445 = D.21444 - hash;
  D.21449 = t1->data.array;
  D.21450 = D.21449->eklass;
  D.21451 = &D.21450->byval_arg;
  D.21452 = mono_metadata_type_hash (D.21451);
  D.21441 = D.21445 ^ D.21452;
  return D.21441;
  <D.18416>:
  D.21444 = hash << 5;
  D.21445 = D.21444 - hash;
  D.21453 = t1->data.generic_class;
  D.21454 = mono_generic_class_hash (D.21453);
  D.21441 = D.21445 ^ D.21454;
  return D.21441;
  <D.21455>:
  D.21441 = hash;
  return D.21441;
}


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

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


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

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


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  unsigned char D.21463;
  unsigned char D.21464;
  unsigned char D.21465;
  unsigned char D.21466;
  short unsigned int D.21468;
  short unsigned int D.21469;
  mono_bool D.21470;
  short unsigned int D.21471;
  short unsigned int D.21472;
  int D.21475;
  int D.21478;
  struct MonoType * D.21479;
  struct MonoType * D.21480;
  int D.21481;
  int i;

  D.21463 = BIT_FIELD_REF <*sig1, 8, 80>;
  D.21464 = BIT_FIELD_REF <*sig2, 8, 80>;
  D.21465 = D.21463 ^ D.21464;
  D.21466 = D.21465 & 64;
  if (D.21466 != 0) goto <D.21461>; else goto <D.21467>;
  <D.21467>:
  D.21468 = sig1->param_count;
  D.21469 = sig2->param_count;
  if (D.21468 != D.21469) goto <D.21461>; else goto <D.21462>;
  <D.21461>:
  D.21470 = 0;
  return D.21470;
  <D.21462>:
  D.21471 = sig1->generic_param_count;
  D.21472 = sig2->generic_param_count;
  if (D.21471 != D.21472) goto <D.21473>; else goto <D.21474>;
  <D.21473>:
  D.21470 = 0;
  return D.21470;
  <D.21474>:
  i = 0;
  goto <D.18488>;
  <D.18487>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.21475 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.21475 == 0) goto <D.21476>; else goto <D.21477>;
    <D.21476>:
    D.21470 = 0;
    return D.21470;
    <D.21477>:
  }
  i = i + 1;
  <D.18488>:
  D.21468 = sig1->param_count;
  D.21478 = (int) D.21468;
  if (D.21478 > i) goto <D.18487>; else goto <D.18489>;
  <D.18489>:
  D.21479 = sig2->ret;
  D.21480 = sig1->ret;
  D.21481 = do_mono_metadata_type_equal (D.21480, D.21479, 1);
  if (D.21481 == 0) goto <D.21482>; else goto <D.21483>;
  <D.21482>:
  D.21470 = 0;
  return D.21470;
  <D.21483>:
  D.21470 = 1;
  return D.21470;
}


mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  unsigned char D.21485;
  unsigned char D.21486;
  <unnamed-unsigned:6> D.21489;
  unsigned int D.21490;
  unsigned int D.21491;
  unsigned int sizeof_o.146;
  unsigned int D.21493;
  void * iftmp.147;
  unsigned int sizeof_o.148;
  unsigned int sizeof_o.149;
  unsigned int sizeof_o.150;
  unsigned char D.21501;
  struct MonoType * D.21504;
  struct MonoType * D.21505;
  struct MonoArrayType * D.21509;
  struct MonoArrayType * D.21510;
  struct MonoMethodSignature * D.21514;
  struct MonoMethodSignature * D.21515;
  struct MonoType * D.21516;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 8;
  D.21485 = BIT_FIELD_REF <*o, 8, 56>;
  D.21486 = D.21485 & 63;
  if (D.21486 != 0) goto <D.21487>; else goto <D.21488>;
  <D.21487>:
  D.21489 = o->num_mods;
  D.21490 = (unsigned int) D.21489;
  D.21491 = D.21490 * 4;
  sizeof_o.146 = (unsigned int) sizeof_o;
  D.21493 = D.21491 + sizeof_o.146;
  sizeof_o = (int) D.21493;
  <D.21488>:
  if (image != 0B) goto <D.21495>; else goto <D.21496>;
  <D.21495>:
  sizeof_o.148 = (unsigned int) sizeof_o;
  iftmp.147 = mono_image_alloc0 (image, sizeof_o.148);
  goto <D.21498>;
  <D.21496>:
  sizeof_o.149 = (unsigned int) sizeof_o;
  iftmp.147 = monoeg_malloc (sizeof_o.149);
  <D.21498>:
  r = iftmp.147;
  sizeof_o.150 = (unsigned int) sizeof_o;
  memcpy (r, o, sizeof_o.150);
  D.21501 = o->type;
  if (D.21501 == 15) goto <D.21502>; else goto <D.21503>;
  <D.21502>:
  D.21504 = o->data.type;
  D.21505 = mono_metadata_type_dup (image, D.21504);
  r->data.type = D.21505;
  goto <D.21506>;
  <D.21503>:
  D.21501 = o->type;
  if (D.21501 == 20) goto <D.21507>; else goto <D.21508>;
  <D.21507>:
  D.21509 = o->data.array;
  D.21510 = mono_dup_array_type (image, D.21509);
  r->data.array = D.21510;
  goto <D.21511>;
  <D.21508>:
  D.21501 = o->type;
  if (D.21501 == 27) goto <D.21512>; else goto <D.21513>;
  <D.21512>:
  D.21514 = o->data.method;
  D.21515 = mono_metadata_signature_deep_dup (image, D.21514);
  r->data.method = D.21515;
  <D.21513>:
  <D.21511>:
  <D.21506>:
  D.21516 = r;
  return D.21516;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.21518;
  unsigned char D.21519;
  unsigned int D.21520;
  unsigned int D.21521;
  struct MonoType * D.21522;
  unsigned int D.21523;
  short unsigned int D.21524;
  unsigned int D.21525;
  unsigned int D.21526;
  guint i;
  guint res;

  D.21518 = sig->ret;
  D.21519 = D.21518->type;
  res = (guint) D.21519;
  i = 0;
  goto <D.18502>;
  <D.18501>:
  D.21520 = res << 5;
  D.21521 = D.21520 - res;
  D.21522 = sig->params[i];
  D.21523 = mono_type_hash (D.21522);
  res = D.21521 + D.21523;
  i = i + 1;
  <D.18502>:
  D.21524 = sig->param_count;
  D.21525 = (unsigned int) D.21524;
  if (D.21525 > i) goto <D.18501>; else goto <D.18503>;
  <D.18503>:
  D.21526 = res;
  return D.21526;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.151;
  char D.21531;
  unsigned int D.21535;
  unsigned char D.21536;
  unsigned char D.21537;
  char D.21538;
  char * D.21539;
  char D.21540;
  unsigned int D.21542;
  unsigned char D.21543;
  unsigned char D.21544;
  char D.21545;
  unsigned int D.21546;
  char D.21547;
  char * D.21548;
  char D.21549;
  char * D.21550;
  char * p;

  p = buf;
  if (value <= 127) goto <D.21528>; else goto <D.21529>;
  <D.21528>:
  p.151 = p;
  p = p.151 + 1;
  D.21531 = (char) value;
  *p.151 = D.21531;
  goto <D.21532>;
  <D.21529>:
  if (value <= 16383) goto <D.21533>; else goto <D.21534>;
  <D.21533>:
  D.21535 = value >> 8;
  D.21536 = (unsigned char) D.21535;
  D.21537 = D.21536 | 128;
  D.21538 = (char) D.21537;
  *p = D.21538;
  D.21539 = p + 1;
  D.21540 = (char) value;
  *D.21539 = D.21540;
  p = p + 2;
  goto <D.21541>;
  <D.21534>:
  D.21542 = value >> 24;
  D.21543 = (unsigned char) D.21542;
  D.21544 = D.21543 | 192;
  D.21545 = (char) D.21544;
  *p = D.21545;
  D.21539 = p + 1;
  D.21546 = value >> 16;
  D.21547 = (char) D.21546;
  *D.21539 = D.21547;
  D.21548 = p + 2;
  D.21535 = value >> 8;
  D.21549 = (char) D.21535;
  *D.21548 = D.21549;
  D.21550 = p + 3;
  D.21540 = (char) value;
  *D.21550 = D.21540;
  p = p + 4;
  <D.21541>:
  <D.21532>:
  if (endbuf != 0B) goto <D.21551>; else goto <D.21552>;
  <D.21551>:
  *endbuf = p;
  <D.21552>:
}


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.21553;
  int D.21554;
  unsigned char D.21555;
  unsigned char D.21556;
  int D.21559;
  unsigned int D.21560;
  int D.21561;
  const char * D.21566;
  unsigned char D.21568;
  unsigned int D.21569;
  <unnamed-unsigned:24> D.21570;
  unsigned int D.21571;
  void * D.21572;
  unsigned int D.21574;
  int D.21575;
  unsigned int D.21576;
  void * D.21582;
  unsigned int D.21584;
  struct MonoImage * iftmp.152;
  struct MonoMarshalSpec * D.21593;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.21553 = index + 1;
      D.21554 = (int) D.21553;
      loc.idx = D.21554;
      D.21555 = BIT_FIELD_REF <*meta, 8, 128>;
      D.21556 = D.21555 & 32;
      if (D.21556 != 0) goto <D.21557>; else goto <D.21558>;
      <D.21557>:
      D.21559 = loc.idx;
      D.21560 = search_ptr_table (meta, 3, D.21559);
      D.21561 = (int) D.21560;
      loc.idx = D.21561;
      <D.21558>:
      if (offset != 0B) goto <D.21562>; else goto <D.21563>;
      <D.21562>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21566 = tdef->base;
      if (D.21566 != 0B) goto <D.21567>; else goto <D.21564>;
      <D.21567>:
      D.21568 = tdef->row_size;
      D.21569 = (unsigned int) D.21568;
      D.21570 = tdef->rows;
      D.21571 = (unsigned int) D.21570;
      D.21566 = tdef->base;
      D.21572 = mono_binary_search (&loc, D.21566, D.21571, D.21569, table_locator);
      if (D.21572 != 0B) goto <D.21573>; else goto <D.21564>;
      <D.21573>:
      D.21574 = loc.result;
      D.21575 = (int) D.21574;
      D.21576 = mono_metadata_decode_row_col (tdef, D.21575, 0);
      *offset = D.21576;
      goto <D.21565>;
      <D.21564>:
      *offset = 4294967295;
      <D.21565>:
      <D.21563>:
      if (rva != 0B) goto <D.21577>; else goto <D.21578>;
      <D.21577>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21566 = tdef->base;
      if (D.21566 != 0B) goto <D.21581>; else goto <D.21579>;
      <D.21581>:
      D.21568 = tdef->row_size;
      D.21569 = (unsigned int) D.21568;
      D.21570 = tdef->rows;
      D.21571 = (unsigned int) D.21570;
      D.21566 = tdef->base;
      D.21582 = mono_binary_search (&loc, D.21566, D.21571, D.21569, table_locator);
      if (D.21582 != 0B) goto <D.21583>; else goto <D.21579>;
      <D.21583>:
      D.21574 = loc.result;
      D.21575 = (int) D.21574;
      D.21584 = mono_metadata_decode_row_col (tdef, D.21575, 0);
      *rva = D.21584;
      goto <D.21580>;
      <D.21579>:
      *rva = 0;
      <D.21580>:
      <D.21578>:
      if (marshal_spec != 0B) goto <D.21585>; else goto <D.21586>;
      <D.21585>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.21587>; else goto <D.21588>;
        <D.21587>:
        if (alloc_from_image != 0) goto <D.21590>; else goto <D.21591>;
        <D.21590>:
        iftmp.152 = meta;
        goto <D.21592>;
        <D.21591>:
        iftmp.152 = 0B;
        <D.21592>:
        D.21593 = mono_metadata_parse_marshal_spec_full (iftmp.152, p);
        *marshal_spec = D.21593;
        <D.21588>:
      }
      <D.21586>:
    }
  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.21594;
  uint32_t D.21595;
  int index.153;
  <unnamed-unsigned:24> D.21599;
  unsigned int D.21600;
  unsigned int D.21603;
  int D.21604;
  unsigned int D.21605;
  const char * D.21608;
  unsigned char D.21611;
  unsigned int D.21612;
  unsigned int D.21613;
  void * D.21614;
  unsigned int D.21617;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.21594 = token >> 24;
      switch (D.21594) <default: <D.18547>, case 4: <D.18543>, case 8: <D.18545>, case 23: <D.18546>>
      <D.18543>:
      index = index;
      goto <D.18544>;
      <D.18545>:
      index = index | 1;
      goto <D.18544>;
      <D.18546>:
      index = index | 2;
      goto <D.18544>;
      <D.18547>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.21595 = 0;
      return D.21595;
      <D.18544>:
      index.153 = (int) index;
      loc.idx = index.153;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.21597>; else goto <D.21598>;
      <D.21597>:
      D.21599 = tdef->rows;
      D.21600 = (unsigned int) D.21599;
      if (D.21600 > hint) goto <D.21601>; else goto <D.21602>;
      <D.21601>:
      D.21603 = hint + 4294967295;
      D.21604 = (int) D.21603;
      D.21605 = mono_metadata_decode_row_col (tdef, D.21604, 2);
      if (D.21605 == index) goto <D.21606>; else goto <D.21607>;
      <D.21606>:
      D.21595 = hint;
      return D.21595;
      <D.21607>:
      <D.21602>:
      <D.21598>:
      D.21608 = tdef->base;
      if (D.21608 != 0B) goto <D.21609>; else goto <D.21610>;
      <D.21609>:
      D.21611 = tdef->row_size;
      D.21612 = (unsigned int) D.21611;
      D.21599 = tdef->rows;
      D.21613 = (unsigned int) D.21599;
      D.21608 = tdef->base;
      D.21614 = mono_binary_search (&loc, D.21608, D.21613, D.21612, table_locator);
      if (D.21614 != 0B) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      D.21617 = loc.result;
      D.21595 = D.21617 + 1;
      return D.21595;
      <D.21616>:
      <D.21610>:
      D.21595 = 0;
      return D.21595;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21620;
  uint32_t D.21623;
  unsigned int D.21624;
  int D.21625;
  unsigned char D.21626;
  unsigned int D.21627;
  <unnamed-unsigned:24> D.21628;
  unsigned int D.21629;
  void * D.21630;
  unsigned int D.21633;
  int D.21634;
  unsigned int D.21635;
  unsigned int D.21636;
  int D.21639;
  unsigned int D.21640;
  <unnamed-unsigned:24> D.21642;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.21620 = tdef->base;
      if (D.21620 == 0B) goto <D.21621>; else goto <D.21622>;
      <D.21621>:
      D.21623 = 0;
      return D.21623;
      <D.21622>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21624 = index + 1;
      D.21625 = (int) D.21624;
      loc.idx = D.21625;
      D.21626 = tdef->row_size;
      D.21627 = (unsigned int) D.21626;
      D.21628 = tdef->rows;
      D.21629 = (unsigned int) D.21628;
      D.21620 = tdef->base;
      D.21630 = mono_binary_search (&loc, D.21620, D.21629, D.21627, table_locator);
      if (D.21630 == 0B) goto <D.21631>; else goto <D.21632>;
      <D.21631>:
      D.21623 = 0;
      return D.21623;
      <D.21632>:
      D.21633 = loc.result;
      D.21634 = (int) D.21633;
      start = mono_metadata_decode_row_col (tdef, D.21634, 1);
      D.21633 = loc.result;
      D.21635 = D.21633 + 1;
      D.21628 = tdef->rows;
      D.21636 = (unsigned int) D.21628;
      if (D.21635 < D.21636) goto <D.21637>; else goto <D.21638>;
      <D.21637>:
      D.21633 = loc.result;
      D.21635 = D.21633 + 1;
      D.21639 = (int) D.21635;
      D.21640 = mono_metadata_decode_row_col (tdef, D.21639, 1);
      end = D.21640 + 4294967295;
      goto <D.21641>;
      <D.21638>:
      D.21642 = meta->tables[20].rows;
      end = (guint32) D.21642;
      <D.21641>:
      *end_idx = end;
      D.21623 = start + 4294967295;
      return D.21623;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21645;
  uint32_t D.21648;
  unsigned char D.21649;
  unsigned char D.21650;
  unsigned int D.21653;
  int D.21654;
  unsigned int D.21655;
  unsigned int D.21656;
  int D.21657;
  unsigned char D.21658;
  unsigned int D.21659;
  <unnamed-unsigned:24> D.21660;
  unsigned int D.21661;
  void * D.21662;
  int D.21665;
  unsigned int D.21666;
  unsigned int D.21667;
  int D.21668;
  unsigned int D.21669;
  int end.154;
  unsigned int D.21672;
  unsigned int D.21673;
  unsigned int D.21675;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.21645 = msemt->base;
      if (D.21645 == 0B) goto <D.21646>; else goto <D.21647>;
      <D.21646>:
      D.21648 = 0;
      return D.21648;
      <D.21647>:
      D.21649 = BIT_FIELD_REF <*meta, 8, 128>;
      D.21650 = D.21649 & 32;
      if (D.21650 != 0) goto <D.21651>; else goto <D.21652>;
      <D.21651>:
      D.21653 = index + 1;
      D.21654 = (int) D.21653;
      D.21655 = search_ptr_table (meta, 19, D.21654);
      index = D.21655 + 4294967295;
      <D.21652>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.21653 = index + 1;
      D.21656 = D.21653 << 1;
      D.21657 = (int) D.21656;
      loc.idx = D.21657;
      D.21658 = msemt->row_size;
      D.21659 = (unsigned int) D.21658;
      D.21660 = msemt->rows;
      D.21661 = (unsigned int) D.21660;
      D.21645 = msemt->base;
      D.21662 = mono_binary_search (&loc, D.21645, D.21661, D.21659, table_locator);
      if (D.21662 == 0B) goto <D.21663>; else goto <D.21664>;
      <D.21663>:
      D.21648 = 0;
      return D.21648;
      <D.21664>:
      start = loc.result;
      goto <D.18569>;
      <D.18568>:
      D.21665 = loc.idx;
      D.21666 = (unsigned int) D.21665;
      D.21667 = start + 4294967295;
      D.21668 = (int) D.21667;
      D.21669 = mono_metadata_decode_row_col (msemt, D.21668, 2);
      if (D.21666 == D.21669) goto <D.21670>; else goto <D.18567>;
      <D.21670>:
      start = start + 4294967295;
      <D.18569>:
      if (start != 0) goto <D.18568>; else goto <D.18567>;
      <D.18567>:
      end = start + 1;
      goto <D.18572>;
      <D.18571>:
      end.154 = (int) end;
      mono_metadata_decode_row (msemt, end.154, &cols, 3);
      D.21672 = cols[2];
      D.21665 = loc.idx;
      D.21673 = (unsigned int) D.21665;
      if (D.21672 != D.21673) goto <D.18570>; else goto <D.21674>;
      <D.21674>:
      end = end + 1;
      <D.18572>:
      D.21660 = msemt->rows;
      D.21675 = (unsigned int) D.21660;
      if (D.21675 > end) goto <D.18571>; else goto <D.18570>;
      <D.18570>:
      *end_idx = end;
      D.21648 = start;
      return D.21648;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21678;
  uint32_t D.21681;
  unsigned int D.21682;
  int D.21683;
  unsigned char D.21684;
  unsigned int D.21685;
  <unnamed-unsigned:24> D.21686;
  unsigned int D.21687;
  void * D.21688;
  unsigned int D.21691;
  int D.21692;
  unsigned int D.21693;
  unsigned int D.21694;
  int D.21697;
  unsigned int D.21698;
  <unnamed-unsigned:24> D.21700;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[21];
      *end_idx = 0;
      D.21678 = tdef->base;
      if (D.21678 == 0B) goto <D.21679>; else goto <D.21680>;
      <D.21679>:
      D.21681 = 0;
      return D.21681;
      <D.21680>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21682 = index + 1;
      D.21683 = (int) D.21682;
      loc.idx = D.21683;
      D.21684 = tdef->row_size;
      D.21685 = (unsigned int) D.21684;
      D.21686 = tdef->rows;
      D.21687 = (unsigned int) D.21686;
      D.21678 = tdef->base;
      D.21688 = mono_binary_search (&loc, D.21678, D.21687, D.21685, table_locator);
      if (D.21688 == 0B) goto <D.21689>; else goto <D.21690>;
      <D.21689>:
      D.21681 = 0;
      return D.21681;
      <D.21690>:
      D.21691 = loc.result;
      D.21692 = (int) D.21691;
      start = mono_metadata_decode_row_col (tdef, D.21692, 1);
      D.21691 = loc.result;
      D.21693 = D.21691 + 1;
      D.21686 = tdef->rows;
      D.21694 = (unsigned int) D.21686;
      if (D.21693 < D.21694) goto <D.21695>; else goto <D.21696>;
      <D.21695>:
      D.21691 = loc.result;
      D.21693 = D.21691 + 1;
      D.21697 = (int) D.21693;
      D.21698 = mono_metadata_decode_row_col (tdef, D.21697, 1);
      end = D.21698 + 4294967295;
      goto <D.21699>;
      <D.21696>:
      D.21700 = meta->tables[23].rows;
      end = (guint32) D.21700;
      <D.21699>:
      *end_idx = end;
      D.21681 = start + 4294967295;
      return D.21681;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21703;
  uint32_t D.21706;
  unsigned char D.21707;
  unsigned char D.21708;
  unsigned int D.21711;
  int D.21712;
  unsigned int D.21713;
  unsigned int D.21714;
  unsigned int D.21715;
  int D.21716;
  unsigned char D.21717;
  unsigned int D.21718;
  <unnamed-unsigned:24> D.21719;
  unsigned int D.21720;
  void * D.21721;
  int D.21724;
  unsigned int D.21725;
  unsigned int D.21726;
  int D.21727;
  unsigned int D.21728;
  int end.155;
  unsigned int D.21731;
  unsigned int D.21732;
  unsigned int D.21734;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.21703 = msemt->base;
      if (D.21703 == 0B) goto <D.21704>; else goto <D.21705>;
      <D.21704>:
      D.21706 = 0;
      return D.21706;
      <D.21705>:
      D.21707 = BIT_FIELD_REF <*meta, 8, 128>;
      D.21708 = D.21707 & 32;
      if (D.21708 != 0) goto <D.21709>; else goto <D.21710>;
      <D.21709>:
      D.21711 = index + 1;
      D.21712 = (int) D.21711;
      D.21713 = search_ptr_table (meta, 22, D.21712);
      index = D.21713 + 4294967295;
      <D.21710>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.21711 = index + 1;
      D.21714 = D.21711 << 1;
      D.21715 = D.21714 | 1;
      D.21716 = (int) D.21715;
      loc.idx = D.21716;
      D.21717 = msemt->row_size;
      D.21718 = (unsigned int) D.21717;
      D.21719 = msemt->rows;
      D.21720 = (unsigned int) D.21719;
      D.21703 = msemt->base;
      D.21721 = mono_binary_search (&loc, D.21703, D.21720, D.21718, table_locator);
      if (D.21721 == 0B) goto <D.21722>; else goto <D.21723>;
      <D.21722>:
      D.21706 = 0;
      return D.21706;
      <D.21723>:
      start = loc.result;
      goto <D.18594>;
      <D.18593>:
      D.21724 = loc.idx;
      D.21725 = (unsigned int) D.21724;
      D.21726 = start + 4294967295;
      D.21727 = (int) D.21726;
      D.21728 = mono_metadata_decode_row_col (msemt, D.21727, 2);
      if (D.21725 == D.21728) goto <D.21729>; else goto <D.18592>;
      <D.21729>:
      start = start + 4294967295;
      <D.18594>:
      if (start != 0) goto <D.18593>; else goto <D.18592>;
      <D.18592>:
      end = start + 1;
      goto <D.18597>;
      <D.18596>:
      end.155 = (int) end;
      mono_metadata_decode_row (msemt, end.155, &cols, 3);
      D.21731 = cols[2];
      D.21724 = loc.idx;
      D.21732 = (unsigned int) D.21724;
      if (D.21731 != D.21732) goto <D.18595>; else goto <D.21733>;
      <D.21733>:
      end = end + 1;
      <D.18597>:
      D.21719 = msemt->rows;
      D.21734 = (unsigned int) D.21719;
      if (D.21734 > end) goto <D.18596>; else goto <D.18595>;
      <D.18595>:
      *end_idx = end;
      D.21706 = start;
      return D.21706;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.21737;
  uint32_t D.21740;
  unsigned int D.21741;
  unsigned int D.21742;
  unsigned int D.21743;
  int D.21744;
  unsigned char D.21745;
  unsigned int D.21746;
  <unnamed-unsigned:24> D.21747;
  unsigned int D.21748;
  void * D.21749;
  unsigned int D.21752;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.21737 = tdef->base;
      if (D.21737 == 0B) goto <D.21738>; else goto <D.21739>;
      <D.21738>:
      D.21740 = 0;
      return D.21740;
      <D.21739>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.21741 = method_idx + 1;
      D.21742 = D.21741 << 1;
      D.21743 = D.21742 | 1;
      D.21744 = (int) D.21743;
      loc.idx = D.21744;
      D.21745 = tdef->row_size;
      D.21746 = (unsigned int) D.21745;
      D.21747 = tdef->rows;
      D.21748 = (unsigned int) D.21747;
      D.21737 = tdef->base;
      D.21749 = mono_binary_search (&loc, D.21737, D.21748, D.21746, table_locator);
      if (D.21749 == 0B) goto <D.21750>; else goto <D.21751>;
      <D.21750>:
      D.21740 = 0;
      return D.21740;
      <D.21751>:
      D.21752 = loc.result;
      D.21740 = D.21752 + 1;
      return D.21740;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  const void * type_spec.156;
  struct GHashTable * D.21756;
  struct MonoType * D.21759;
  unsigned int D.21760;
  int D.21761;
  unsigned int D.21762;
  const char * ptr.157;
  int D.21764;
  const char * ptr.158;
  void * type_spec.159;
  guint32 idx;
  struct MonoTableInfo * t;
  guint32 cols[1];
  const char * ptr;
  guint32 len;
  struct MonoType * type;
  struct MonoType * type2;

  try
    {
      idx = type_spec & 16777215;
      mono_loader_lock ();
      type_spec.156 = (const void *) type_spec;
      D.21756 = image->typespec_cache;
      type = monoeg_g_hash_table_lookup (D.21756, type_spec.156);
      if (type != 0B) goto <D.21757>; else goto <D.21758>;
      <D.21757>:
      mono_loader_unlock ();
      D.21759 = type;
      return D.21759;
      <D.21758>:
      t = &image->tables[27];
      D.21760 = idx + 4294967295;
      D.21761 = (int) D.21760;
      mono_metadata_decode_row (t, D.21761, &cols, 1);
      D.21762 = cols[0];
      ptr.157 = mono_metadata_blob_heap (image, D.21762);
      ptr = ptr.157;
      D.21762 = cols[0];
      D.21764 = mono_verifier_verify_typespec_signature (image, D.21762, type_spec, 0B);
      if (D.21764 == 0) goto <D.21765>; else goto <D.21766>;
      <D.21765>:
      mono_loader_unlock ();
      D.21759 = 0B;
      return D.21759;
      <D.21766>:
      ptr.158 = ptr;
      len = mono_metadata_decode_value (ptr.158, &ptr);
      ptr.158 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.158, &ptr);
      if (type == 0B) goto <D.21768>; else goto <D.21769>;
      <D.21768>:
      mono_loader_unlock ();
      D.21759 = 0B;
      return D.21759;
      <D.21769>:
      type_spec.156 = (const void *) type_spec;
      D.21756 = image->typespec_cache;
      type2 = monoeg_g_hash_table_lookup (D.21756, type_spec.156);
      if (type2 != 0B) goto <D.21770>; else goto <D.21771>;
      <D.21770>:
      mono_loader_unlock ();
      D.21759 = type2;
      return D.21759;
      <D.21771>:
      type2 = mono_metadata_type_dup (image, type);
      type_spec.159 = (void *) type_spec;
      D.21756 = image->typespec_cache;
      monoeg_g_hash_table_insert_replace (D.21756, type_spec.159, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.21759 = type2;
      return D.21759;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.160;
  unsigned int D.21781;
  const char * ptr.161;
  const char * ptr.162;
  char D.21784;
  <unnamed type> D.21785;
  <unnamed type> D.21786;
  int ptr.163;
  int start.164;
  int D.21791;
  const char * ptr.165;
  const char * ptr.166;
  char D.21796;
  <unnamed type> D.21797;
  unsigned int D.21800;
  short int D.21801;
  unsigned int D.21804;
  int D.21805;
  unsigned int D.21808;
  short int D.21809;
  unsigned int D.21814;
  int D.21815;
  unsigned int D.21820;
  int D.21821;
  unsigned int D.21824;
  sizetype len.167;
  const char * ptr.168;
  unsigned int D.21827;
  unsigned int D.21828;
  unsigned int len.169;
  char * D.21830;
  unsigned int D.21831;
  char * D.21832;
  const char * ptr.170;
  const char * ptr.171;
  char D.21839;
  <unnamed type> D.21840;
  const char * ptr.172;
  const char * ptr.173;
  char D.21845;
  int D.21846;
  struct MonoMarshalSpec * D.21847;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.21777>; else goto <D.21778>;
  <D.21777>:
  res = mono_image_alloc0 (image, 16);
  goto <D.21779>;
  <D.21778>:
  res = monoeg_malloc0 (16);
  <D.21779>:
  ptr.160 = ptr;
  D.21781 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.21781;
  ptr.160 = ptr;
  ptr.161 = ptr.160;
  ptr.162 = ptr.161 + 1;
  ptr = ptr.162;
  D.21784 = *ptr.161;
  D.21785 = (<unnamed type>) D.21784;
  res->native = D.21785;
  D.21786 = res->native;
  if (D.21786 == 42) goto <D.21787>; else goto <D.21788>;
  <D.21787>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21792>; else goto <D.21793>;
  <D.21792>:
  ptr.160 = ptr;
  ptr.165 = ptr.160;
  ptr.166 = ptr.165 + 1;
  ptr = ptr.166;
  D.21796 = *ptr.165;
  D.21797 = (<unnamed type>) D.21796;
  res->data.array_data.elem_type = D.21797;
  <D.21793>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21798>; else goto <D.21799>;
  <D.21798>:
  ptr.160 = ptr;
  D.21800 = mono_metadata_decode_value (ptr.160, &ptr);
  D.21801 = (short int) D.21800;
  res->data.array_data.param_num = D.21801;
  <D.21799>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21802>; else goto <D.21803>;
  <D.21802>:
  ptr.160 = ptr;
  D.21804 = mono_metadata_decode_value (ptr.160, &ptr);
  D.21805 = (int) D.21804;
  res->data.array_data.num_elem = D.21805;
  <D.21803>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21806>; else goto <D.21807>;
  <D.21806>:
  ptr.160 = ptr;
  D.21808 = mono_metadata_decode_value (ptr.160, &ptr);
  D.21809 = (short int) D.21808;
  res->data.array_data.elem_mult = D.21809;
  <D.21807>:
  <D.21788>:
  D.21786 = res->native;
  if (D.21786 == 23) goto <D.21810>; else goto <D.21811>;
  <D.21810>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21812>; else goto <D.21813>;
  <D.21812>:
  ptr.160 = ptr;
  D.21814 = mono_metadata_decode_value (ptr.160, &ptr);
  D.21815 = (int) D.21814;
  res->data.array_data.num_elem = D.21815;
  <D.21813>:
  <D.21811>:
  D.21786 = res->native;
  if (D.21786 == 30) goto <D.21816>; else goto <D.21817>;
  <D.21816>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21818>; else goto <D.21819>;
  <D.21818>:
  ptr.160 = ptr;
  D.21820 = mono_metadata_decode_value (ptr.160, &ptr);
  D.21821 = (int) D.21820;
  res->data.array_data.num_elem = D.21821;
  <D.21819>:
  <D.21817>:
  D.21786 = res->native;
  if (D.21786 == 44) goto <D.21822>; else goto <D.21823>;
  <D.21822>:
  ptr.160 = ptr;
  D.21824 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.21824;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.21827 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.21827;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.21828 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.21828;
  len.169 = (unsigned int) len;
  ptr.160 = ptr;
  D.21830 = mono_image_strndup (image, ptr.160, len.169);
  res->data.custom_data.custom_name = D.21830;
  ptr.160 = ptr;
  len.167 = (sizetype) len;
  ptr.168 = ptr.160 + len.167;
  ptr = ptr.168;
  ptr.160 = ptr;
  D.21831 = mono_metadata_decode_value (ptr.160, &ptr);
  len = (int) D.21831;
  len.169 = (unsigned int) len;
  ptr.160 = ptr;
  D.21832 = mono_image_strndup (image, ptr.160, len.169);
  res->data.custom_data.cookie = D.21832;
  <D.21823>:
  D.21786 = res->native;
  if (D.21786 == 29) goto <D.21833>; else goto <D.21834>;
  <D.21833>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21835>; else goto <D.21836>;
  <D.21835>:
  ptr.160 = ptr;
  ptr.170 = ptr.160;
  ptr.171 = ptr.170 + 1;
  ptr = ptr.171;
  D.21839 = *ptr.170;
  D.21840 = (<unnamed type>) D.21839;
  res->data.safearray_data.elem_type = D.21840;
  <D.21836>:
  ptr.160 = ptr;
  ptr.163 = (int) ptr.160;
  start.164 = (int) start;
  D.21791 = ptr.163 - start.164;
  if (D.21791 <= len) goto <D.21841>; else goto <D.21842>;
  <D.21841>:
  ptr.160 = ptr;
  ptr.172 = ptr.160;
  ptr.173 = ptr.172 + 1;
  ptr = ptr.173;
  D.21845 = *ptr.172;
  D.21846 = (int) D.21845;
  res->data.safearray_data.num_elem = D.21846;
  <D.21842>:
  <D.21834>:
  D.21847 = res;
  return D.21847;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.21851;
  unsigned int D.21852;
  char * D.21853;
  char * res;

  if (image == 0B) goto <D.21849>; else goto <D.21850>;
  <D.21849>:
  D.21851 = monoeg_g_strndup (data, len);
  return D.21851;
  <D.21850>:
  D.21852 = len + 1;
  res = mono_image_alloc (image, D.21852);
  memcpy (res, data, len);
  D.21853 = res + len;
  *D.21853 = 0;
  D.21851 = res;
  return D.21851;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.21855;
  char * D.21858;
  char * D.21859;

  D.21855 = spec->native;
  if (D.21855 == 44) goto <D.21856>; else goto <D.21857>;
  <D.21856>:
  D.21858 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.21858);
  D.21859 = spec->data.custom_data.cookie;
  monoeg_g_free (D.21859);
  <D.21857>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.21860;
  unsigned char D.21863;
  unsigned char D.21864;
  uint32_t D.21867;
  <unnamed type> D.21870;
  uint32_t iftmp.174;
  struct MonoClass * D.21884;
  unsigned char D.21885;
  unsigned char D.21886;
  struct MonoType * D.21889;
  unsigned char D.21890;
  struct MonoClass * D.21891;
  struct MonoClass * D.21898;
  struct MonoClass * D.21899;
  struct MonoClass * D.21908;
  struct MonoClass * D.21910;
  struct MonoClass * D.21912;
  struct MonoClass * D.21919;
  struct MonoGenericClass * D.21924;
  struct MonoClass * D.21925;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.21860 = type->type;
      t = (int) D.21860;
      if (conv == 0B) goto <D.21861>; else goto <D.21862>;
      <D.21861>:
      conv = &dummy_conv;
      <D.21862>:
      *conv = 0;
      D.21863 = BIT_FIELD_REF <*type, 8, 56>;
      D.21864 = D.21863 & 64;
      if (D.21864 != 0) goto <D.21865>; else goto <D.21866>;
      <D.21865>:
      D.21867 = 32;
      return D.21867;
      <D.21866>:
      handle_enum:
      switch (t) <default: <D.18701>, case 2: <D.18645>, case 3: <D.18652>, case 4: <D.18657>, case 5: <D.18658>, case 6: <D.18659>, case 7: <D.18660>, case 8: <D.18661>, case 9: <D.18662>, case 10: <D.18663>, case 11: <D.18664>, case 12: <D.18665>, case 13: <D.18666>, case 14: <D.18667>, case 15: <D.18677>, case 17: <D.18678>, case 18: <D.18688>, case 20: <D.18680>, case 21: <D.18699>, case 22: <D.18700>, case 24: <D.18686>, case 25: <D.18687>, case 27: <D.18698>, case 28: <D.18689>, case 29: <D.18679>>
      <D.18645>:
      if (mspec != 0B) goto <D.21868>; else goto <D.21869>;
      <D.21868>:
      D.21870 = mspec->native;
      switch (D.21870) <default: <D.18650>, case 2: <D.18647>, case 3: <D.18648>, case 4: <D.18649>, case 37: <D.18646>>
      <D.18646>:
      *conv = 1;
      D.21867 = 37;
      return D.21867;
      <D.18647>:
      *conv = 2;
      D.21867 = 2;
      return D.21867;
      <D.18648>:
      <D.18649>:
      D.21867 = mspec->native;
      return D.21867;
      <D.18650>:
      D.21870 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.21870);
      <D.18651>:
      goto <D.18651>;
      <D.21869>:
      *conv = 2;
      D.21867 = 2;
      return D.21867;
      <D.18652>:
      if (mspec != 0B) goto <D.21871>; else goto <D.21872>;
      <D.21871>:
      D.21870 = mspec->native;
      switch (D.21870) <default: <D.18655>, case 4: <D.18654>, case 6: <D.18653>>
      <D.18653>:
      <D.18654>:
      D.21867 = mspec->native;
      return D.21867;
      <D.18655>:
      D.21870 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.21870);
      <D.18656>:
      goto <D.18656>;
      <D.21872>:
      if (unicode != 0) goto <D.21874>; else goto <D.21875>;
      <D.21874>:
      iftmp.174 = 6;
      goto <D.21876>;
      <D.21875>:
      iftmp.174 = 4;
      <D.21876>:
      D.21867 = iftmp.174;
      return D.21867;
      <D.18657>:
      D.21867 = 3;
      return D.21867;
      <D.18658>:
      D.21867 = 4;
      return D.21867;
      <D.18659>:
      D.21867 = 5;
      return D.21867;
      <D.18660>:
      D.21867 = 6;
      return D.21867;
      <D.18661>:
      D.21867 = 7;
      return D.21867;
      <D.18662>:
      D.21867 = 8;
      return D.21867;
      <D.18663>:
      D.21867 = 9;
      return D.21867;
      <D.18664>:
      D.21867 = 10;
      return D.21867;
      <D.18665>:
      D.21867 = 11;
      return D.21867;
      <D.18666>:
      D.21867 = 12;
      return D.21867;
      <D.18667>:
      if (mspec != 0B) goto <D.21877>; else goto <D.21878>;
      <D.21877>:
      D.21870 = mspec->native;
      switch (D.21870) <default: <D.18675>, case 19: <D.18668>, case 20: <D.18669>, case 21: <D.18670>, case 22: <D.18671>, case 23: <D.18674>, case 35: <D.18672>, case 36: <D.18673>>
      <D.18668>:
      *conv = 3;
      D.21867 = 19;
      return D.21867;
      <D.18669>:
      *conv = 4;
      D.21867 = 20;
      return D.21867;
      <D.18670>:
      *conv = 7;
      D.21867 = 21;
      return D.21867;
      <D.18671>:
      *conv = 9;
      D.21867 = 22;
      return D.21867;
      <D.18672>:
      *conv = 10;
      D.21867 = 35;
      return D.21867;
      <D.18673>:
      *conv = 11;
      D.21867 = 36;
      return D.21867;
      <D.18674>:
      if (unicode != 0) goto <D.21879>; else goto <D.21880>;
      <D.21879>:
      *conv = 13;
      goto <D.21881>;
      <D.21880>:
      *conv = 12;
      <D.21881>:
      D.21867 = 23;
      return D.21867;
      <D.18675>:
      D.21870 = 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.21870);
      <D.18676>:
      goto <D.18676>;
      <D.21878>:
      if (unicode != 0) goto <D.21882>; else goto <D.21883>;
      <D.21882>:
      *conv = 7;
      D.21867 = 21;
      return D.21867;
      <D.21883>:
      *conv = 4;
      D.21867 = 20;
      return D.21867;
      <D.18677>:
      D.21867 = 32;
      return D.21867;
      <D.18678>:
      D.21884 = type->data.klass;
      D.21885 = BIT_FIELD_REF <*D.21884, 8, 160>;
      D.21886 = D.21885 & 16;
      if (D.21886 != 0) goto <D.21887>; else goto <D.21888>;
      <D.21887>:
      D.21884 = type->data.klass;
      D.21889 = mono_class_enum_basetype (D.21884);
      D.21890 = D.21889->type;
      t = (int) D.21890;
      goto handle_enum;
      <D.21888>:
      D.21884 = type->data.klass;
      D.21891 = mono_defaults.handleref_class;
      if (D.21884 == D.21891) goto <D.21892>; else goto <D.21893>;
      <D.21892>:
      *conv = 34;
      D.21867 = 31;
      return D.21867;
      <D.21893>:
      D.21867 = 27;
      return D.21867;
      <D.18679>:
      <D.18680>:
      if (mspec != 0B) goto <D.21894>; else goto <D.21895>;
      <D.21894>:
      D.21870 = mspec->native;
      switch (D.21870) <default: <D.18684>, case 29: <D.18682>, case 30: <D.18681>, case 42: <D.18683>>
      <D.18681>:
      D.21884 = type->data.klass;
      D.21898 = D.21884->element_class;
      D.21899 = mono_defaults.char_class;
      if (D.21898 == D.21899) goto <D.21900>; else goto <D.21896>;
      <D.21900>:
      if (unicode == 0) goto <D.21901>; else goto <D.21896>;
      <D.21901>:
      *conv = 21;
      goto <D.21897>;
      <D.21896>:
      *conv = 20;
      <D.21897>:
      D.21867 = 30;
      return D.21867;
      <D.18682>:
      *conv = 22;
      D.21867 = 29;
      return D.21867;
      <D.18683>:
      *conv = 23;
      D.21867 = 42;
      return D.21867;
      <D.18684>:
      D.21870 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.21870);
      <D.18685>:
      goto <D.18685>;
      <D.21895>:
      *conv = 23;
      D.21867 = 42;
      return D.21867;
      <D.18686>:
      D.21867 = 31;
      return D.21867;
      <D.18687>:
      D.21867 = 32;
      return D.21867;
      <D.18688>:
      <D.18689>:
      if (mspec != 0B) goto <D.21902>; else goto <D.21903>;
      <D.21902>:
      D.21870 = mspec->native;
      switch (D.21870) <default: <D.18696>, case 25: <D.18694>, case 26: <D.18693>, case 27: <D.18690>, case 28: <D.18692>, case 38: <D.18695>, case 44: <D.18691>>
      <D.18690>:
      D.21867 = 27;
      return D.21867;
      <D.18691>:
      D.21867 = 44;
      return D.21867;
      <D.18692>:
      *conv = 25;
      D.21867 = 28;
      return D.21867;
      <D.18693>:
      *conv = 26;
      D.21867 = 26;
      return D.21867;
      <D.18694>:
      *conv = 27;
      D.21867 = 25;
      return D.21867;
      <D.18695>:
      if (t == 18) goto <D.21906>; else goto <D.21907>;
      <D.21906>:
      D.21884 = type->data.klass;
      D.21908 = mono_defaults.multicastdelegate_class;
      if (D.21884 == D.21908) goto <D.21904>; else goto <D.21909>;
      <D.21909>:
      D.21884 = type->data.klass;
      D.21910 = mono_defaults.delegate_class;
      if (D.21884 == D.21910) goto <D.21904>; else goto <D.21911>;
      <D.21911>:
      D.21884 = type->data.klass;
      D.21912 = D.21884->parent;
      D.21908 = mono_defaults.multicastdelegate_class;
      if (D.21912 == D.21908) goto <D.21904>; else goto <D.21905>;
      <D.21904>:
      *conv = 29;
      D.21867 = 38;
      return D.21867;
      <D.21905>:
      <D.21907>:
      <D.18696>:
      D.21870 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.21870);
      <D.18697>:
      goto <D.18697>;
      <D.21903>:
      if (t == 18) goto <D.21915>; else goto <D.21916>;
      <D.21915>:
      D.21884 = type->data.klass;
      D.21908 = mono_defaults.multicastdelegate_class;
      if (D.21884 == D.21908) goto <D.21913>; else goto <D.21917>;
      <D.21917>:
      D.21884 = type->data.klass;
      D.21910 = mono_defaults.delegate_class;
      if (D.21884 == D.21910) goto <D.21913>; else goto <D.21918>;
      <D.21918>:
      D.21884 = type->data.klass;
      D.21912 = D.21884->parent;
      D.21908 = mono_defaults.multicastdelegate_class;
      if (D.21912 == D.21908) goto <D.21913>; else goto <D.21914>;
      <D.21913>:
      *conv = 29;
      D.21867 = 38;
      return D.21867;
      <D.21914>:
      <D.21916>:
      D.21919 = mono_defaults.safehandle_class;
      if (D.21919 != 0B) goto <D.21920>; else goto <D.21921>;
      <D.21920>:
      D.21884 = type->data.klass;
      D.21919 = mono_defaults.safehandle_class;
      if (D.21884 == D.21919) goto <D.21922>; else goto <D.21923>;
      <D.21922>:
      *conv = 33;
      D.21867 = 31;
      return D.21867;
      <D.21923>:
      <D.21921>:
      *conv = 28;
      D.21867 = 27;
      return D.21867;
      <D.18698>:
      D.21867 = 38;
      return D.21867;
      <D.18699>:
      D.21924 = type->data.generic_class;
      D.21925 = D.21924->container_class;
      type = &D.21925->byval_arg;
      D.21860 = type->type;
      t = (int) D.21860;
      goto handle_enum;
      <D.18700>:
      <D.18701>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.18702>:
      goto <D.18702>;
      D.21867 = 80;
      return D.21867;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.21928;
  const char * D.21931;
  unsigned int D.21932;
  unsigned int D.21933;
  _Bool D.21934;
  int D.21935;
  unsigned int D.21936;
  unsigned int D.21937;
  int D.21938;
  unsigned char D.21939;
  unsigned int D.21940;
  <unnamed-unsigned:24> D.21941;
  unsigned int D.21942;
  void * D.21943;
  unsigned int D.21946;
  int D.21947;
  unsigned int D.21948;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.21928 = tdef->base;
      if (D.21928 == 0B) goto <D.21929>; else goto <D.21930>;
      <D.21929>:
      D.21931 = 0B;
      return D.21931;
      <D.21930>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21932 = idx + 1;
      D.21933 = D.21932 << 1;
      D.21934 = is_field == 0;
      D.21935 = (int) D.21934;
      D.21936 = (unsigned int) D.21935;
      D.21937 = D.21933 | D.21936;
      D.21938 = (int) D.21937;
      loc.idx = D.21938;
      D.21939 = tdef->row_size;
      D.21940 = (unsigned int) D.21939;
      D.21941 = tdef->rows;
      D.21942 = (unsigned int) D.21941;
      D.21928 = tdef->base;
      D.21943 = mono_binary_search (&loc, D.21928, D.21942, D.21940, table_locator);
      if (D.21943 == 0B) goto <D.21944>; else goto <D.21945>;
      <D.21944>:
      D.21931 = 0B;
      return D.21931;
      <D.21945>:
      D.21946 = loc.result;
      D.21947 = (int) D.21946;
      D.21948 = mono_metadata_decode_row_col (tdef, D.21947, 1);
      D.21931 = mono_metadata_blob_heap (meta, D.21948);
      return D.21931;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.21951;
  struct MonoMethod * D.21952;
  unsigned int D.21953;
  unsigned int D.21954;
  guint32 idx;

  idx = tok >> 1;
  D.21951 = tok & 1;
  switch (D.21951) <default: <D.21955>, case 0: <D.18716>, case 1: <D.18717>>
  <D.18716>:
  D.21953 = idx | 100663296;
  D.21952 = mono_get_method_full (m, D.21953, 0B, context);
  return D.21952;
  <D.18717>:
  D.21954 = idx | 167772160;
  D.21952 = mono_get_method_full (m, D.21954, 0B, context);
  return D.21952;
  <D.21955>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.21952 = 0B;
  return D.21952;
}


mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.21959;
  gboolean D.21962;
  int type_token.175;
  int D.21964;
  unsigned char D.21965;
  unsigned int D.21966;
  <unnamed-unsigned:24> D.21967;
  unsigned int D.21968;
  void * D.21969;
  int D.21972;
  unsigned int D.21973;
  unsigned int D.21974;
  int D.21975;
  unsigned int D.21976;
  int end.176;
  unsigned int D.21979;
  unsigned int D.21981;
  unsigned int D.21982;
  unsigned int num.177;
  unsigned int D.21984;
  unsigned int i.178;
  unsigned int D.21986;
  int D.21987;
  int D.21990;
  unsigned int D.21991;
  unsigned int i.179;
  unsigned int D.21995;
  struct MonoMethod * * D.21996;
  unsigned int D.21997;
  sizetype i.180;
  sizetype D.22001;
  sizetype D.22002;
  struct MonoMethod * * D.22003;
  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.21957>; else goto <D.21958>;
      <D.21957>:
      *num_overrides = 0;
      <D.21958>:
      D.21959 = tdef->base;
      if (D.21959 == 0B) goto <D.21960>; else goto <D.21961>;
      <D.21960>:
      D.21962 = 1;
      return D.21962;
      <D.21961>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.175 = (int) type_token;
      D.21964 = type_token.175 & 16777215;
      loc.idx = D.21964;
      D.21965 = tdef->row_size;
      D.21966 = (unsigned int) D.21965;
      D.21967 = tdef->rows;
      D.21968 = (unsigned int) D.21967;
      D.21959 = tdef->base;
      D.21969 = mono_binary_search (&loc, D.21959, D.21968, D.21966, table_locator);
      if (D.21969 == 0B) goto <D.21970>; else goto <D.21971>;
      <D.21970>:
      D.21962 = 1;
      return D.21962;
      <D.21971>:
      start = loc.result;
      end = start + 1;
      goto <D.18737>;
      <D.18736>:
      D.21972 = loc.idx;
      D.21973 = (unsigned int) D.21972;
      D.21974 = start + 4294967295;
      D.21975 = (int) D.21974;
      D.21976 = mono_metadata_decode_row_col (tdef, D.21975, 0);
      if (D.21973 == D.21976) goto <D.21977>; else goto <D.18735>;
      <D.21977>:
      start = start + 4294967295;
      <D.18737>:
      if (start != 0) goto <D.18736>; else goto <D.18735>;
      <D.18735>:
      goto <D.18740>;
      <D.18739>:
      D.21972 = loc.idx;
      D.21973 = (unsigned int) D.21972;
      end.176 = (int) end;
      D.21979 = mono_metadata_decode_row_col (tdef, end.176, 0);
      if (D.21973 == D.21979) goto <D.21980>; else goto <D.18738>;
      <D.21980>:
      end = end + 1;
      <D.18740>:
      D.21967 = tdef->rows;
      D.21981 = (unsigned int) D.21967;
      if (D.21981 > end) goto <D.18739>; else goto <D.18738>;
      <D.18738>:
      D.21982 = end - start;
      num = (gint32) D.21982;
      num.177 = (unsigned int) num;
      D.21984 = num.177 * 8;
      result = monoeg_malloc (D.21984);
      i = 0;
      goto <D.18744>;
      <D.18743>:
      {
        struct MonoMethod * method;

        i.178 = (unsigned int) i;
        D.21986 = start + i.178;
        D.21987 = mono_verifier_verify_methodimpl_row (image, D.21986, &error);
        if (D.21987 == 0) goto <D.21988>; else goto <D.21989>;
        <D.21988>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.18742>;
        <D.21989>:
        i.178 = (unsigned int) i;
        D.21986 = start + i.178;
        D.21990 = (int) D.21986;
        mono_metadata_decode_row (tdef, D.21990, &cols, 3);
        D.21991 = cols[2];
        method = method_from_method_def_or_ref (image, D.21991, generic_context);
        if (method == 0B) goto <D.21992>; else goto <D.21993>;
        <D.21992>:
        ok = 0;
        <D.21993>:
        i.179 = (unsigned int) i;
        D.21995 = i.179 * 8;
        D.21996 = result + D.21995;
        *D.21996 = method;
        D.21997 = cols[1];
        method = method_from_method_def_or_ref (image, D.21997, generic_context);
        if (method == 0B) goto <D.21998>; else goto <D.21999>;
        <D.21998>:
        ok = 0;
        <D.21999>:
        i.180 = (sizetype) i;
        D.22001 = i.180 * 8;
        D.22002 = D.22001 + 4;
        D.22003 = result + D.22002;
        *D.22003 = method;
      }
      i = i + 1;
      <D.18744>:
      if (i < num) goto <D.18743>; else goto <D.18742>;
      <D.18742>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.22004>; else goto <D.22005>;
      <D.22004>:
      *num_overrides = num;
      <D.22005>:
      D.21962 = ok;
      return D.21962;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.22008;
  const guint8 * D.22009;
  unsigned char D.22010;
  int D.22011;
  const guint8 * D.22012;
  unsigned char D.22013;
  int D.22014;
  const guint8 * D.22015;
  unsigned char D.22016;
  int D.22017;
  const guint8 * D.22018;
  unsigned char D.22019;
  int D.22020;
  const guint8 * D.22021;
  unsigned char D.22022;
  int D.22023;
  const guint8 * D.22024;
  unsigned char D.22025;
  int D.22026;
  const guint8 * D.22027;
  unsigned char D.22028;
  int D.22029;
  const guint8 * D.22030;
  unsigned char D.22031;
  int D.22032;
  const guint8 * D.22033;
  unsigned char D.22034;
  int D.22035;
  const guint8 * D.22036;
  unsigned char D.22037;
  int D.22038;
  const guint8 * D.22039;
  unsigned char D.22040;
  int D.22041;
  const guint8 * D.22042;
  unsigned char D.22043;
  int D.22044;
  unsigned char D.22045;
  int D.22046;
  const guint8 * D.22047;
  unsigned char D.22048;
  int D.22049;
  const guint8 * D.22050;
  unsigned char D.22051;
  int D.22052;
  const guint8 * D.22053;
  unsigned char D.22054;
  int D.22055;

  D.22009 = guid + 15;
  D.22010 = *D.22009;
  D.22011 = (int) D.22010;
  D.22012 = guid + 14;
  D.22013 = *D.22012;
  D.22014 = (int) D.22013;
  D.22015 = guid + 13;
  D.22016 = *D.22015;
  D.22017 = (int) D.22016;
  D.22018 = guid + 12;
  D.22019 = *D.22018;
  D.22020 = (int) D.22019;
  D.22021 = guid + 11;
  D.22022 = *D.22021;
  D.22023 = (int) D.22022;
  D.22024 = guid + 10;
  D.22025 = *D.22024;
  D.22026 = (int) D.22025;
  D.22027 = guid + 9;
  D.22028 = *D.22027;
  D.22029 = (int) D.22028;
  D.22030 = guid + 8;
  D.22031 = *D.22030;
  D.22032 = (int) D.22031;
  D.22033 = guid + 6;
  D.22034 = *D.22033;
  D.22035 = (int) D.22034;
  D.22036 = guid + 7;
  D.22037 = *D.22036;
  D.22038 = (int) D.22037;
  D.22039 = guid + 4;
  D.22040 = *D.22039;
  D.22041 = (int) D.22040;
  D.22042 = guid + 5;
  D.22043 = *D.22042;
  D.22044 = (int) D.22043;
  D.22045 = *guid;
  D.22046 = (int) D.22045;
  D.22047 = guid + 1;
  D.22048 = *D.22047;
  D.22049 = (int) D.22048;
  D.22050 = guid + 2;
  D.22051 = *D.22050;
  D.22052 = (int) D.22051;
  D.22053 = guid + 3;
  D.22054 = *D.22053;
  D.22055 = (int) D.22054;
  D.22008 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.22055, D.22052, D.22049, D.22046, D.22044, D.22041, D.22038, D.22035, D.22032, D.22029, D.22026, D.22023, D.22020, D.22017, D.22014, D.22011);
  return D.22008;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.22057;
  long int D.22058;
  long int D.22059;
  const char * D.22062;
  guint32 D.22065;
  unsigned int D.22066;
  unsigned int D.22073;
  unsigned int D.22074;
  unsigned int D.22075;
  unsigned int D.22076;
  int D.22077;
  unsigned char D.22078;
  unsigned int D.22079;
  <unnamed-unsigned:24> D.22080;
  unsigned int D.22081;
  void * D.22082;
  unsigned int D.22085;
  unsigned int D.22086;
  int D.22088;
  unsigned int D.22089;
  int D.22090;
  unsigned int D.22091;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.22057 = owner == 0B;
      D.22058 = (long int) D.22057;
      D.22059 = __builtin_expect (D.22058, 0);
      if (D.22059 != 0) goto <D.22060>; else goto <D.22061>;
      <D.22060>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.22061>:
      D.22062 = tdef->base;
      if (D.22062 == 0B) goto <D.22063>; else goto <D.22064>;
      <D.22063>:
      D.22065 = 0;
      return D.22065;
      <D.22064>:
      D.22066 = token >> 24;
      if (D.22066 == 2) goto <D.22067>; else goto <D.22068>;
      <D.22067>:
      *owner = 0;
      goto <D.22069>;
      <D.22068>:
      D.22066 = token >> 24;
      if (D.22066 == 6) goto <D.22070>; else goto <D.22071>;
      <D.22070>:
      *owner = 1;
      goto <D.22072>;
      <D.22071>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.18777>:
      goto <D.18777>;
      D.22065 = 0;
      return D.22065;
      <D.22072>:
      <D.22069>:
      D.22073 = *owner;
      D.22074 = token & 16777215;
      D.22075 = D.22074 << 1;
      D.22076 = D.22073 | D.22075;
      *owner = D.22076;
      D.22073 = *owner;
      D.22077 = (int) D.22073;
      loc.idx = D.22077;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22078 = tdef->row_size;
      D.22079 = (unsigned int) D.22078;
      D.22080 = tdef->rows;
      D.22081 = (unsigned int) D.22080;
      D.22062 = tdef->base;
      D.22082 = mono_binary_search (&loc, D.22062, D.22081, D.22079, table_locator);
      if (D.22082 == 0B) goto <D.22083>; else goto <D.22084>;
      <D.22083>:
      D.22065 = 0;
      return D.22065;
      <D.22084>:
      goto <D.18779>;
      <D.18778>:
      D.22085 = loc.result;
      D.22086 = D.22085 + 4294967295;
      loc.result = D.22086;
      <D.18779>:
      D.22085 = loc.result;
      if (D.22085 != 0) goto <D.22087>; else goto <D.18780>;
      <D.22087>:
      D.22085 = loc.result;
      D.22086 = D.22085 + 4294967295;
      D.22088 = (int) D.22086;
      D.22089 = mono_metadata_decode_row_col (tdef, D.22088, 2);
      D.22090 = loc.idx;
      D.22091 = (unsigned int) D.22090;
      if (D.22089 == D.22091) goto <D.18778>; else goto <D.18780>;
      <D.18780>:
      D.22085 = loc.result;
      D.22065 = D.22085 + 1;
      return D.22065;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


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

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


mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.22100;
  struct MonoGenericParamFull * D.22101;
  unsigned int D.22102;
  struct MonoGenericParamFull * D.22103;
  struct MonoClass * * * D.22104;
  unsigned int D.22105;
  int D.22106;
  int D.22107;
  <unnamed-signed:31> D.22110;
  unsigned int D.22111;
  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.22098>; else goto <D.22099>;
      <D.22098>:
      D.22100 = 1;
      return D.22100;
      <D.22099>:
      i = 0;
      goto <D.18795>;
      <D.18794>:
      D.22101 = container->type_params;
      D.22102 = i * 32;
      D.22103 = D.22101 + D.22102;
      D.22104 = &D.22103->info.constraints;
      D.22105 = start_row + i;
      D.22106 = (int) D.22105;
      D.22107 = get_constraints (image, D.22106, D.22104, container);
      if (D.22107 == 0) goto <D.22108>; else goto <D.22109>;
      <D.22108>:
      D.22100 = 0;
      return D.22100;
      <D.22109>:
      i = i + 1;
      <D.18795>:
      D.22110 = container->type_argc;
      D.22111 = (unsigned int) D.22110;
      if (D.22111 > i) goto <D.18794>; else goto <D.18796>;
      <D.18796>:
      D.22100 = 1;
      return D.22100;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.181;
  unsigned int D.22115;
  unsigned int owner.182;
  unsigned int D.22119;
  gboolean D.22122;
  <unnamed-unsigned:24> D.22125;
  unsigned int D.22126;
  unsigned int D.22129;
  unsigned int D.22130;
  unsigned int D.22131;
  struct MonoClass * * D.22132;
  void * D.22133;
  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.18766>;
      <D.18765>:
      i.181 = (int) i;
      mono_metadata_decode_row (tdef, i.181, &cols, 2);
      D.22115 = cols[0];
      owner.182 = (unsigned int) owner;
      if (D.22115 == owner.182) goto <D.22117>; else goto <D.22118>;
      <D.22117>:
      D.22119 = cols[1];
      token = mono_metadata_token_from_dor (D.22119);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.22120>; else goto <D.22121>;
      <D.22120>:
      monoeg_g_slist_free (cons);
      D.22122 = 0;
      return D.22122;
      <D.22121>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.22123>;
      <D.22118>:
      if (found != 0) goto <D.18764>; else goto <D.22124>;
      <D.22124>:
      <D.22123>:
      i = i + 1;
      <D.18766>:
      D.22125 = tdef->rows;
      D.22126 = (unsigned int) D.22125;
      if (D.22126 > i) goto <D.18765>; else goto <D.18764>;
      <D.18764>:
      if (found == 0) goto <D.22127>; else goto <D.22128>;
      <D.22127>:
      D.22122 = 1;
      return D.22122;
      <D.22128>:
      D.22129 = found + 1;
      D.22130 = D.22129 * 4;
      res = mono_image_alloc0 (image, D.22130);
      i = 0;
      tmp = cons;
      goto <D.18768>;
      <D.18767>:
      D.22131 = i * 4;
      D.22132 = res + D.22131;
      D.22133 = tmp->data;
      *D.22132 = D.22133;
      i = i + 1;
      tmp = tmp->next;
      <D.18768>:
      if (i < found) goto <D.18767>; else goto <D.18769>;
      <D.18769>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.22122 = 1;
      return D.22122;
    }
  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.22138;
  unsigned int D.22139;
  int D.22140;
  unsigned int D.22141;
  sizetype D.22142;
  sizetype D.22143;
  struct MonoGenericParamFull * D.22144;
  unsigned int D.22145;
  short unsigned int D.22146;
  unsigned int D.22147;
  unsigned int D.22148;
  short unsigned int D.22149;
  unsigned int D.22150;
  const char * D.22151;
  short unsigned int D.22152;
  unsigned int D.22153;
  unsigned int D.22154;
  <unnamed-unsigned:24> D.22157;
  unsigned int D.22158;
  unsigned int D.22160;
  unsigned int owner.183;
  int n.184;
  <unnamed-signed:31> D.22163;
  void * D.22164;
  struct MonoGenericParamFull * D.22165;
  unsigned int D.22166;
  int iftmp.185;
  struct MonoGenericContainer * D.22172;
  unsigned char D.22174;
  unsigned char D.22175;
  _Bool D.22177;
  long int D.22178;
  long int D.22179;
  struct MonoGenericInst * iftmp.186;
  struct MonoGenericInst * D.22188;
  struct MonoGenericInst * D.22190;
  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.22136>; else goto <D.22137>;
      <D.22136>:
      D.22138 = 0B;
      return D.22138;
      <D.22137>:
      D.22139 = i + 4294967295;
      D.22140 = (int) D.22139;
      mono_metadata_decode_row (tdef, D.22140, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 28);
      container->image = image;
      <D.18816>:
      n = n + 1;
      D.22141 = n * 32;
      params = monoeg_realloc (params, D.22141);
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      memset (D.22144, 0, 32);
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22144->param.owner = container;
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22145 = cols[0];
      D.22146 = (short unsigned int) D.22145;
      D.22144->param.num = D.22146;
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22147 = i | 704643072;
      D.22144->info.token = D.22147;
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22148 = cols[1];
      D.22149 = (short unsigned int) D.22148;
      D.22144->info.flags = D.22149;
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22150 = cols[3];
      D.22151 = mono_metadata_string_heap (image, D.22150);
      D.22144->info.name = D.22151;
      D.22142 = n + 134217727;
      D.22143 = D.22142 * 32;
      D.22144 = params + D.22143;
      D.22152 = D.22144->param.num;
      D.22153 = (unsigned int) D.22152;
      D.22154 = n + 4294967295;
      if (D.22153 != D.22154) goto <D.22155>; else goto <D.22156>;
      <D.22155>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.22156>:
      i = i + 1;
      D.22157 = tdef->rows;
      D.22158 = (unsigned int) D.22157;
      if (i > D.22158) goto <D.18815>; else goto <D.22159>;
      <D.22159>:
      D.22139 = i + 4294967295;
      D.22140 = (int) D.22139;
      mono_metadata_decode_row (tdef, D.22140, &cols, 4);
      D.22160 = cols[2];
      owner.183 = owner;
      if (D.22160 == owner.183) goto <D.18816>; else goto <D.18815>;
      <D.18815>:
      n.184 = (int) n;
      D.22163 = (<unnamed-signed:31>) n.184;
      container->type_argc = D.22163;
      D.22141 = n * 32;
      D.22164 = mono_image_alloc0 (image, D.22141);
      container->type_params = D.22164;
      D.22141 = n * 32;
      D.22165 = container->type_params;
      memcpy (D.22165, params, D.22141);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.22166 = token >> 24;
      if (D.22166 == 6) goto <D.22167>; else goto <D.22168>;
      <D.22167>:
      container->is_method = -1;
      <D.22168>:
      D.22172 = container->parent;
      if (D.22172 != 0B) goto <D.22173>; else goto <D.22170>;
      <D.22173>:
      D.22174 = BIT_FIELD_REF <*container, 8, 152>;
      D.22175 = D.22174 & 128;
      if (D.22175 == 0) goto <D.22176>; else goto <D.22170>;
      <D.22176>:
      iftmp.185 = 1;
      goto <D.22171>;
      <D.22170>:
      iftmp.185 = 0;
      <D.22171>:
      D.22177 = iftmp.185 != 0;
      D.22178 = (long int) D.22177;
      D.22179 = __builtin_expect (D.22178, 0);
      if (D.22179 != 0) goto <D.22180>; else goto <D.22181>;
      <D.22180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.22181>:
      context = &container->context;
      D.22174 = BIT_FIELD_REF <*container, 8, 152>;
      D.22175 = D.22174 & 128;
      if (D.22175 != 0) goto <D.22182>; else goto <D.22183>;
      <D.22182>:
      D.22172 = container->parent;
      if (D.22172 != 0B) goto <D.22185>; else goto <D.22186>;
      <D.22185>:
      D.22172 = container->parent;
      iftmp.186 = D.22172->context.class_inst;
      goto <D.22187>;
      <D.22186>:
      iftmp.186 = 0B;
      <D.22187>:
      context->class_inst = iftmp.186;
      D.22188 = mono_get_shared_generic_inst (container);
      context->method_inst = D.22188;
      goto <D.22189>;
      <D.22183>:
      D.22190 = mono_get_shared_generic_inst (container);
      context->class_inst = D.22190;
      <D.22189>:
      D.22138 = container;
      return D.22138;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.22193;
  unsigned int D.22194;
  unsigned int D.22195;
  unsigned int D.22196;
  unsigned int i.187;
  unsigned int D.22198;
  unsigned char iftmp.188;
  unsigned char D.22200;
  unsigned char D.22201;
  struct MonoGenericParamFull * D.22205;
  unsigned int D.22206;
  struct MonoGenericParam * D.22207;
  unsigned int D.22208;
  struct MonoType * * D.22209;
  int D.22210;
  struct MonoGenericInst * D.22211;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.22193 = container->type_argc;
  D.22194 = (unsigned int) D.22193;
  D.22195 = D.22194 * 4;
  type_argv = monoeg_malloc0 (D.22195);
  D.22193 = container->type_argc;
  D.22194 = (unsigned int) D.22193;
  D.22196 = D.22194 * 8;
  helper = monoeg_malloc0 (D.22196);
  i = 0;
  goto <D.18826>;
  <D.18825>:
  {
    struct MonoType * t;

    i.187 = (unsigned int) i;
    D.22198 = i.187 * 8;
    t = helper + D.22198;
    D.22200 = BIT_FIELD_REF <*container, 8, 152>;
    D.22201 = D.22200 & 128;
    if (D.22201 != 0) goto <D.22202>; else goto <D.22203>;
    <D.22202>:
    iftmp.188 = 30;
    goto <D.22204>;
    <D.22203>:
    iftmp.188 = 19;
    <D.22204>:
    t->type = iftmp.188;
    D.22205 = container->type_params;
    i.187 = (unsigned int) i;
    D.22206 = i.187 * 32;
    D.22207 = D.22205 + D.22206;
    t->data.generic_param = D.22207;
    i.187 = (unsigned int) i;
    D.22208 = i.187 * 4;
    D.22209 = type_argv + D.22208;
    *D.22209 = t;
  }
  i = i + 1;
  <D.18826>:
  D.22193 = container->type_argc;
  D.22210 = (int) D.22193;
  if (D.22210 > i) goto <D.18825>; else goto <D.18827>;
  <D.18827>:
  D.22193 = container->type_argc;
  D.22210 = (int) D.22193;
  nginst = mono_metadata_get_generic_inst (D.22210, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.22211 = nginst;
  return D.22211;
}


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

  D.22214 = type->byref;
  D.22213 = (mono_bool) D.22214;
  return D.22213;
}


mono_type_get_type (struct MonoType * type)
{
  int D.22216;
  unsigned char D.22217;

  D.22217 = type->type;
  D.22216 = (int) D.22217;
  return D.22216;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.22219;
  _Bool D.22220;
  long int D.22221;
  long int D.22222;
  struct MonoMethodSignature * D.22225;

  D.22219 = type->type;
  D.22220 = D.22219 != 27;
  D.22221 = (long int) D.22220;
  D.22222 = __builtin_expect (D.22221, 0);
  if (D.22222 != 0) goto <D.22223>; else goto <D.22224>;
  <D.22223>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.22224>:
  D.22225 = type->data.method;
  return D.22225;
}


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

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


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

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


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.22231;
  _Bool D.22232;
  long int D.22233;
  long int D.22234;
  struct MonoType * D.22237;

  D.22231 = type->type;
  D.22232 = D.22231 != 15;
  D.22233 = (long int) D.22232;
  D.22234 = __builtin_expect (D.22233, 0);
  if (D.22234 != 0) goto <D.22235>; else goto <D.22236>;
  <D.22235>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.22236>:
  D.22237 = type->data.type;
  return D.22237;
}


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

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


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.22241;
  int iftmp.189;
  unsigned char D.22247;
  unsigned char D.22248;
  unsigned char D.22250;
  struct MonoClass * D.22252;
  unsigned char D.22253;
  unsigned char D.22254;
  struct MonoGenericClass * D.22257;
  int D.22258;
  struct MonoClass * D.22260;
  unsigned char D.22261;
  unsigned char D.22262;

  D.22247 = BIT_FIELD_REF <*type, 8, 56>;
  D.22248 = D.22247 & 64;
  if (D.22248 == 0) goto <D.22249>; else goto <D.22243>;
  <D.22249>:
  D.22250 = type->type;
  if (D.22250 == 17) goto <D.22251>; else goto <D.22244>;
  <D.22251>:
  D.22252 = type->data.klass;
  D.22253 = BIT_FIELD_REF <*D.22252, 8, 160>;
  D.22254 = D.22253 & 16;
  if (D.22254 == 0) goto <D.22245>; else goto <D.22244>;
  <D.22244>:
  D.22250 = type->type;
  if (D.22250 == 22) goto <D.22245>; else goto <D.22255>;
  <D.22255>:
  D.22250 = type->type;
  if (D.22250 == 21) goto <D.22256>; else goto <D.22243>;
  <D.22256>:
  D.22257 = type->data.generic_class;
  D.22258 = mono_metadata_generic_class_is_valuetype (D.22257);
  if (D.22258 != 0) goto <D.22259>; else goto <D.22243>;
  <D.22259>:
  D.22257 = type->data.generic_class;
  D.22260 = D.22257->container_class;
  D.22261 = BIT_FIELD_REF <*D.22260, 8, 160>;
  D.22262 = D.22261 & 16;
  if (D.22262 == 0) goto <D.22245>; else goto <D.22243>;
  <D.22245>:
  iftmp.189 = 1;
  goto <D.22246>;
  <D.22243>:
  iftmp.189 = 0;
  <D.22246>:
  D.22241 = iftmp.189;
  return D.22241;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.22264;
  int iftmp.190;
  short unsigned int D.22269;
  short unsigned int D.22270;

  if (type != 0B) goto <D.22268>; else goto <D.22266>;
  <D.22268>:
  D.22269 = BIT_FIELD_REF <*type, 16, 48>;
  D.22270 = D.22269 & 16639;
  if (D.22270 == 1) goto <D.22271>; else goto <D.22266>;
  <D.22271>:
  iftmp.190 = 1;
  goto <D.22267>;
  <D.22266>:
  iftmp.190 = 0;
  <D.22267>:
  D.22264 = iftmp.190;
  return D.22264;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.22273;
  int iftmp.191;
  unsigned char D.22279;
  unsigned char D.22280;
  unsigned char D.22282;

  if (type != 0B) goto <D.22278>; else goto <D.22275>;
  <D.22278>:
  D.22279 = BIT_FIELD_REF <*type, 8, 56>;
  D.22280 = D.22279 & 64;
  if (D.22280 != 0) goto <D.22276>; else goto <D.22281>;
  <D.22281>:
  D.22282 = type->type;
  if (D.22282 == 24) goto <D.22276>; else goto <D.22283>;
  <D.22283>:
  D.22282 = type->type;
  if (D.22282 == 14) goto <D.22276>; else goto <D.22284>;
  <D.22284>:
  D.22282 = type->type;
  if (D.22282 == 29) goto <D.22276>; else goto <D.22285>;
  <D.22285>:
  D.22282 = type->type;
  if (D.22282 == 18) goto <D.22276>; else goto <D.22286>;
  <D.22286>:
  D.22282 = type->type;
  if (D.22282 == 25) goto <D.22276>; else goto <D.22287>;
  <D.22287>:
  D.22282 = type->type;
  if (D.22282 == 28) goto <D.22276>; else goto <D.22288>;
  <D.22288>:
  D.22282 = type->type;
  if (D.22282 == 20) goto <D.22276>; else goto <D.22289>;
  <D.22289>:
  D.22282 = type->type;
  if (D.22282 == 15) goto <D.22276>; else goto <D.22290>;
  <D.22290>:
  D.22282 = type->type;
  if (D.22282 == 27) goto <D.22276>; else goto <D.22275>;
  <D.22276>:
  iftmp.191 = 1;
  goto <D.22277>;
  <D.22275>:
  iftmp.191 = 0;
  <D.22277>:
  D.22273 = iftmp.191;
  return D.22273;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.22292;
  int iftmp.192;
  unsigned char D.22298;
  _Bool D.22299;
  _Bool D.22300;
  _Bool D.22301;
  unsigned char D.22303;
  struct MonoGenericClass * D.22308;
  int D.22309;

  if (type != 0B) goto <D.22297>; else goto <D.22294>;
  <D.22297>:
  D.22298 = type->type;
  D.22299 = D.22298 == 14;
  D.22300 = D.22298 == 29;
  D.22301 = D.22299 | D.22300;
  if (D.22301 != 0) goto <D.22295>; else goto <D.22302>;
  <D.22302>:
  D.22303 = type->type;
  if (D.22303 == 18) goto <D.22295>; else goto <D.22304>;
  <D.22304>:
  D.22303 = type->type;
  if (D.22303 == 28) goto <D.22295>; else goto <D.22305>;
  <D.22305>:
  D.22303 = type->type;
  if (D.22303 == 20) goto <D.22295>; else goto <D.22306>;
  <D.22306>:
  D.22303 = type->type;
  if (D.22303 == 21) goto <D.22307>; else goto <D.22294>;
  <D.22307>:
  D.22308 = type->data.generic_class;
  D.22309 = mono_metadata_generic_class_is_valuetype (D.22308);
  if (D.22309 == 0) goto <D.22295>; else goto <D.22294>;
  <D.22295>:
  iftmp.192 = 1;
  goto <D.22296>;
  <D.22294>:
  iftmp.192 = 0;
  <D.22296>:
  D.22292 = iftmp.192;
  return D.22292;
}


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

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


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.22315;
  void * D.22316;
  short unsigned int D.22319;
  struct MonoType * * D.22322;
  int D.22323;
  struct MonoType * * D.22324;
  struct MonoType * * type;

  if (iter == 0B) goto <D.22313>; else goto <D.22314>;
  <D.22313>:
  D.22315 = 0B;
  return D.22315;
  <D.22314>:
  D.22316 = *iter;
  if (D.22316 == 0B) goto <D.22317>; else goto <D.22318>;
  <D.22317>:
  D.22319 = sig->param_count;
  if (D.22319 != 0) goto <D.22320>; else goto <D.22321>;
  <D.22320>:
  D.22322 = &sig->params[0];
  *iter = D.22322;
  D.22315 = sig->params[0];
  return D.22315;
  <D.22321>:
  D.22315 = 0B;
  return D.22315;
  <D.22318>:
  type = *iter;
  type = type + 4;
  D.22319 = sig->param_count;
  D.22323 = (int) D.22319;
  D.22324 = &sig->params[D.22323];
  if (D.22324 > type) goto <D.22325>; else goto <D.22326>;
  <D.22325>:
  *iter = type;
  D.22315 = *type;
  return D.22315;
  <D.22326>:
  D.22315 = 0B;
  return D.22315;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.22328;
  short unsigned int D.22329;

  D.22329 = sig->param_count;
  D.22328 = (uint32_t) D.22329;
  return D.22328;
}


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

  D.22332 = sig->call_convention;
  D.22331 = (uint32_t) D.22332;
  return D.22331;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.22334;
  short int D.22335;

  D.22335 = sig->sentinelpos;
  D.22334 = (int) D.22335;
  return D.22334;
}


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

  D.22338 = sig->hasthis;
  D.22337 = (mono_bool) D.22338;
  return D.22337;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.193;
  short unsigned int D.22345;
  int D.22346;
  _Bool D.22347;
  long int D.22348;
  long int D.22349;
  mono_bool D.22352;
  struct MonoType * D.22353;
  short unsigned int D.22354;
  int D.22355;
  int D.22356;
  _Bool D.22357;

  if (param_num < 0) goto <D.22341>; else goto <D.22344>;
  <D.22344>:
  D.22345 = sig->param_count;
  D.22346 = (int) D.22345;
  if (D.22346 <= param_num) goto <D.22341>; else goto <D.22342>;
  <D.22341>:
  iftmp.193 = 1;
  goto <D.22343>;
  <D.22342>:
  iftmp.193 = 0;
  <D.22343>:
  D.22347 = iftmp.193 != 0;
  D.22348 = (long int) D.22347;
  D.22349 = __builtin_expect (D.22348, 0);
  if (D.22349 != 0) goto <D.22350>; else goto <D.22351>;
  <D.22350>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.22351>:
  D.22353 = sig->params[param_num];
  D.22354 = D.22353->attrs;
  D.22355 = (int) D.22354;
  D.22356 = D.22355 & 2;
  D.22357 = D.22356 != 0;
  D.22352 = (mono_bool) D.22357;
  return D.22352;
}


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

  D.22360 = sig->explicit_this;
  D.22359 = (mono_bool) D.22360;
  return D.22359;
}


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

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


mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.22365;
  struct MonoGenericClass * D.22366;
  struct MonoClassField * D.22369;
  int field.195;
  struct MonoClassField * D.22371;
  int D.22372;
  int D.22373;
  struct MonoClassField * D.22374;
  unsigned int offset.196;
  unsigned int D.22376;
  struct MonoClass * gtd;
  int offset;

  D.22365 = field->parent;
  D.22366 = D.22365->generic_class;
  if (D.22366 == 0B) goto <D.22367>; else goto <D.22368>;
  <D.22367>:
  D.22369 = field;
  return D.22369;
  <D.22368>:
  D.22365 = field->parent;
  D.22366 = D.22365->generic_class;
  gtd = D.22366->container_class;
  field.195 = (int) field;
  D.22365 = field->parent;
  D.22371 = D.22365->fields;
  D.22372 = (int) D.22371;
  D.22373 = field.195 - D.22372;
  offset = D.22373 /[ex] 16;
  D.22374 = gtd->fields;
  offset.196 = (unsigned int) offset;
  D.22376 = offset.196 * 16;
  D.22369 = D.22374 + D.22376;
  return D.22369;
}


mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.22378;
  struct MonoGenericClass * D.22379;
  struct MonoEvent * D.22382;
  int event.197;
  struct MonoClassExt * D.22384;
  struct MonoEvent * D.22385;
  int D.22386;
  int D.22387;
  struct MonoClassExt * D.22388;
  struct MonoEvent * D.22389;
  unsigned int offset.198;
  unsigned int D.22391;
  struct MonoClass * gtd;
  int offset;

  D.22378 = event->parent;
  D.22379 = D.22378->generic_class;
  if (D.22379 == 0B) goto <D.22380>; else goto <D.22381>;
  <D.22380>:
  D.22382 = event;
  return D.22382;
  <D.22381>:
  D.22378 = event->parent;
  D.22379 = D.22378->generic_class;
  gtd = D.22379->container_class;
  event.197 = (int) event;
  D.22378 = event->parent;
  D.22384 = D.22378->ext;
  D.22385 = D.22384->events;
  D.22386 = (int) D.22385;
  D.22387 = event.197 - D.22386;
  offset = D.22387 /[ex] 28;
  D.22388 = gtd->ext;
  D.22389 = D.22388->events;
  offset.198 = (unsigned int) offset;
  D.22391 = offset.198 * 28;
  D.22382 = D.22389 + D.22391;
  return D.22382;
}


mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.22393;
  struct MonoGenericClass * D.22394;
  struct MonoProperty * D.22397;
  int property.199;
  struct MonoClassExt * D.22399;
  struct MonoProperty * D.22400;
  int D.22401;
  int D.22402;
  struct MonoClassExt * D.22403;
  struct MonoProperty * D.22404;
  unsigned int offset.200;
  unsigned int D.22406;
  struct MonoClass * gtd;
  int offset;

  D.22393 = property->parent;
  D.22394 = D.22393->generic_class;
  if (D.22394 == 0B) goto <D.22395>; else goto <D.22396>;
  <D.22395>:
  D.22397 = property;
  return D.22397;
  <D.22396>:
  D.22393 = property->parent;
  D.22394 = D.22393->generic_class;
  gtd = D.22394->container_class;
  property.199 = (int) property;
  D.22393 = property->parent;
  D.22399 = D.22393->ext;
  D.22400 = D.22399->properties;
  D.22401 = (int) D.22400;
  D.22402 = property.199 - D.22401;
  offset = D.22402 /[ex] 20;
  D.22403 = gtd->ext;
  D.22404 = D.22403->properties;
  offset.200 = (unsigned int) offset;
  D.22406 = offset.200 * 20;
  D.22397 = D.22404 + D.22406;
  return D.22397;
}