mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.18884;
  short int D.18885;
  sizetype D.18886;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.18882>; else goto <D.18883>;
  <D.18882>:
  D.18884 = "";
  return D.18884;
  <D.18883>:
  D.18885 = tableidx[table];
  D.18886 = (sizetype) D.18885;
  D.18884 = &tablestr + D.18886;
  return D.18884;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.18888;
  sizetype D.18889;
  int iftmp.1;
  unsigned int D.18891;
  unsigned int D.18892;
  int iftmp.2;
  unsigned int D.18897;
  int iftmp.3;
  unsigned int D.18902;
  _Bool D.18906;
  long int D.18907;
  long int D.18908;
  int iftmp.4;
  <unnamed-unsigned:24> D.18912;
  int D.18913;
  _Bool D.18917;
  long int D.18918;
  long int D.18919;
  int iftmp.5;
  _Bool D.18926;
  long int D.18927;
  long int D.18928;
  int iftmp.6;
  <unnamed-unsigned:24> D.18932;
  int D.18933;
  unsigned int i.7;
  _Bool D.18938;
  long int D.18939;
  long int D.18940;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.18947;
  int D.18948;
  int iftmp.10;
  _Bool D.18957;
  long int D.18958;
  long int D.18959;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.18971;
  int D.18972;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.18991;
  int D.18992;
  int iftmp.16;
  _Bool D.19002;
  long int D.19003;
  long int D.19004;
  int iftmp.17;
  <unnamed-unsigned:24> D.19008;
  int D.19009;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.19022;
  int D.19023;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.19051;
  int D.19052;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.19067;
  _Bool D.19068;
  long int D.19069;
  long int D.19070;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.19094;
  int D.19095;
  int iftmp.32;
  <unnamed-unsigned:24> D.19103;
  int D.19104;
  <unnamed-unsigned:24> D.19105;
  int D.19106;
  <unnamed-unsigned:24> D.19107;
  int D.19108;
  <unnamed-unsigned:24> D.19109;
  int D.19110;
  <unnamed-unsigned:24> D.19111;
  int D.19112;
  <unnamed-unsigned:24> D.19113;
  int D.19114;
  <unnamed-unsigned:24> D.19115;
  int D.19116;
  <unnamed-unsigned:24> D.19117;
  int D.19118;
  <unnamed-unsigned:24> D.19119;
  int D.19120;
  <unnamed-unsigned:24> D.19121;
  int D.19122;
  <unnamed-unsigned:24> D.19123;
  int D.19124;
  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.19170;
  int D.19171;
  unsigned int D.19172;
  sizetype i.44;
  const unsigned char * D.19174;
  unsigned char D.19175;
  int D.19176;
  unsigned int D.19177;
  unsigned int D.19178;
  int D.19179;
  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.18888 = table_description[tableindex];
  D.18889 = (sizetype) D.18888;
  description = &TableSchemas + D.18889;
  i = 0;
  goto <D.17137>;
  <D.17136>:
  switch (code) <default: <D.19169>, case 1: <D.17091>, case 2: <D.17093>, case 3: <D.17094>, case 4: <D.17095>, case 5: <D.17096>, case 6: <D.17097>, case 7: <D.17098>, case 8: <D.17124>, case 9: <D.17125>, case 10: <D.17126>, case 11: <D.17127>, case 12: <D.17128>, case 13: <D.17129>, case 14: <D.17130>, case 15: <D.17131>, case 16: <D.17132>, case 17: <D.17133>, case 18: <D.17134>, case 19: <D.17135>>
  <D.17091>:
  field_size = 4;
  goto <D.17092>;
  <D.17093>:
  field_size = 2;
  goto <D.17092>;
  <D.17094>:
  field_size = 1;
  goto <D.17092>;
  <D.17095>:
  D.18891 = BIT_FIELD_REF <*meta, 32, 128>;
  D.18892 = D.18891 & 1024;
  if (D.18892 != 0) goto <D.18893>; else goto <D.18894>;
  <D.18893>:
  iftmp.1 = 4;
  goto <D.18895>;
  <D.18894>:
  iftmp.1 = 2;
  <D.18895>:
  field_size = iftmp.1;
  goto <D.17092>;
  <D.17096>:
  D.18891 = BIT_FIELD_REF <*meta, 32, 128>;
  D.18897 = D.18891 & 256;
  if (D.18897 != 0) goto <D.18898>; else goto <D.18899>;
  <D.18898>:
  iftmp.2 = 4;
  goto <D.18900>;
  <D.18899>:
  iftmp.2 = 2;
  <D.18900>:
  field_size = iftmp.2;
  goto <D.17092>;
  <D.17097>:
  D.18891 = BIT_FIELD_REF <*meta, 32, 128>;
  D.18902 = D.18891 & 512;
  if (D.18902 != 0) goto <D.18903>; else goto <D.18904>;
  <D.18903>:
  iftmp.3 = 4;
  goto <D.18905>;
  <D.18904>:
  iftmp.3 = 2;
  <D.18905>:
  field_size = iftmp.3;
  goto <D.17092>;
  <D.17098>:
  switch (tableindex) <default: <D.17122>, case 2: <D.17119>, case 3: <D.17108>, case 5: <D.17114>, case 6: <D.17111>, case 7: <D.17116>, case 9: <D.17110>, case 15: <D.17102>, case 16: <D.17106>, case 18: <D.17103>, case 19: <D.17104>, case 21: <D.17117>, case 22: <D.17118>, case 24: <D.17113>, case 25: <D.17112>, case 28: <D.17109>, case 29: <D.17107>, case 36: <D.17101>, case 37: <D.17099>, case 39: <D.17105>, case 41: <D.17115>, case 42: <D.17120>, case 44: <D.17121>>
  <D.17099>:
  D.18906 = i != 3;
  D.18907 = (long int) D.18906;
  D.18908 = __builtin_expect (D.18907, 0);
  if (D.18908 != 0) goto <D.18909>; else goto <D.18910>;
  <D.18909>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.18910>:
  D.18912 = meta->tables[35].rows;
  D.18913 = (int) D.18912;
  if (D.18913 <= 65535) goto <D.18914>; else goto <D.18915>;
  <D.18914>:
  iftmp.4 = 2;
  goto <D.18916>;
  <D.18915>:
  iftmp.4 = 4;
  <D.18916>:
  field_size = iftmp.4;
  goto <D.17100>;
  <D.17101>:
  D.18917 = i != 1;
  D.18918 = (long int) D.18917;
  D.18919 = __builtin_expect (D.18918, 0);
  if (D.18919 != 0) goto <D.18920>; else goto <D.18921>;
  <D.18920>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.18921>:
  D.18912 = meta->tables[35].rows;
  D.18913 = (int) D.18912;
  if (D.18913 <= 65535) goto <D.18923>; else goto <D.18924>;
  <D.18923>:
  iftmp.5 = 2;
  goto <D.18925>;
  <D.18924>:
  iftmp.5 = 4;
  <D.18925>:
  field_size = iftmp.5;
  goto <D.17100>;
  <D.17102>:
  D.18926 = i != 2;
  D.18927 = (long int) D.18926;
  D.18928 = __builtin_expect (D.18927, 0);
  if (D.18928 != 0) goto <D.18929>; else goto <D.18930>;
  <D.18929>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.18930>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.18934>; else goto <D.18935>;
  <D.18934>:
  iftmp.6 = 2;
  goto <D.18936>;
  <D.18935>:
  iftmp.6 = 4;
  <D.18936>:
  field_size = iftmp.6;
  goto <D.17100>;
  <D.17103>:
  i.7 = (unsigned int) i;
  D.18938 = i.7 > 1;
  D.18939 = (long int) D.18938;
  D.18940 = __builtin_expect (D.18939, 0);
  if (D.18940 != 0) goto <D.18941>; else goto <D.18942>;
  <D.18941>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.18942>:
  if (i != 0) goto <D.18944>; else goto <D.18945>;
  <D.18944>:
  D.18947 = meta->tables[20].rows;
  D.18948 = (int) D.18947;
  if (D.18948 <= 65535) goto <D.18949>; else goto <D.18950>;
  <D.18949>:
  iftmp.9 = 2;
  goto <D.18951>;
  <D.18950>:
  iftmp.9 = 4;
  <D.18951>:
  iftmp.8 = iftmp.9;
  goto <D.18952>;
  <D.18945>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.18954>; else goto <D.18955>;
  <D.18954>:
  iftmp.10 = 2;
  goto <D.18956>;
  <D.18955>:
  iftmp.10 = 4;
  <D.18956>:
  iftmp.8 = iftmp.10;
  <D.18952>:
  field_size = iftmp.8;
  goto <D.17100>;
  <D.17104>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.18960>; else goto <D.18961>;
  <D.18960>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.18961>:
  D.18947 = meta->tables[20].rows;
  D.18948 = (int) D.18947;
  if (D.18948 <= 65535) goto <D.18963>; else goto <D.18964>;
  <D.18963>:
  iftmp.11 = 2;
  goto <D.18965>;
  <D.18964>:
  iftmp.11 = 4;
  <D.18965>:
  field_size = iftmp.11;
  goto <D.17100>;
  <D.17105>:
  D.18917 = i != 1;
  D.18918 = (long int) D.18917;
  D.18919 = __builtin_expect (D.18918, 0);
  if (D.18919 != 0) goto <D.18966>; else goto <D.18967>;
  <D.18966>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.18967>:
  field_size = 4;
  goto <D.17100>;
  <D.17106>:
  D.18917 = i != 1;
  D.18918 = (long int) D.18917;
  D.18919 = __builtin_expect (D.18918, 0);
  if (D.18919 != 0) goto <D.18968>; else goto <D.18969>;
  <D.18968>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.18969>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  if (D.18972 <= 65535) goto <D.18973>; else goto <D.18974>;
  <D.18973>:
  iftmp.12 = 2;
  goto <D.18975>;
  <D.18974>:
  iftmp.12 = 4;
  <D.18975>:
  field_size = iftmp.12;
  goto <D.17100>;
  <D.17107>:
  D.18917 = i != 1;
  D.18918 = (long int) D.18917;
  D.18919 = __builtin_expect (D.18918, 0);
  if (D.18919 != 0) goto <D.18976>; else goto <D.18977>;
  <D.18976>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.18977>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  if (D.18972 <= 65535) goto <D.18979>; else goto <D.18980>;
  <D.18979>:
  iftmp.13 = 2;
  goto <D.18981>;
  <D.18980>:
  iftmp.13 = 4;
  <D.18981>:
  field_size = iftmp.13;
  goto <D.17100>;
  <D.17108>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.18982>; else goto <D.18983>;
  <D.18982>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.18983>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  if (D.18972 <= 65535) goto <D.18985>; else goto <D.18986>;
  <D.18985>:
  iftmp.14 = 2;
  goto <D.18987>;
  <D.18986>:
  iftmp.14 = 4;
  <D.18987>:
  field_size = iftmp.14;
  goto <D.17100>;
  <D.17109>:
  D.18906 = i != 3;
  D.18907 = (long int) D.18906;
  D.18908 = __builtin_expect (D.18907, 0);
  if (D.18908 != 0) goto <D.18988>; else goto <D.18989>;
  <D.18988>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.18989>:
  D.18991 = meta->tables[26].rows;
  D.18992 = (int) D.18991;
  if (D.18992 <= 65535) goto <D.18993>; else goto <D.18994>;
  <D.18993>:
  iftmp.15 = 2;
  goto <D.18995>;
  <D.18994>:
  iftmp.15 = 4;
  <D.18995>:
  field_size = iftmp.15;
  goto <D.17100>;
  <D.17110>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.18996>; else goto <D.18997>;
  <D.18996>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.18997>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.18999>; else goto <D.19000>;
  <D.18999>:
  iftmp.16 = 2;
  goto <D.19001>;
  <D.19000>:
  iftmp.16 = 4;
  <D.19001>:
  field_size = iftmp.16;
  goto <D.17100>;
  <D.17111>:
  D.19002 = i != 5;
  D.19003 = (long int) D.19002;
  D.19004 = __builtin_expect (D.19003, 0);
  if (D.19004 != 0) goto <D.19005>; else goto <D.19006>;
  <D.19005>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.19006>:
  D.19008 = meta->tables[8].rows;
  D.19009 = (int) D.19008;
  if (D.19009 <= 65535) goto <D.19010>; else goto <D.19011>;
  <D.19010>:
  iftmp.17 = 2;
  goto <D.19012>;
  <D.19011>:
  iftmp.17 = 4;
  <D.19012>:
  field_size = iftmp.17;
  goto <D.17100>;
  <D.17112>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.19013>; else goto <D.19014>;
  <D.19013>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.19014>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.19016>; else goto <D.19017>;
  <D.19016>:
  iftmp.18 = 2;
  goto <D.19018>;
  <D.19017>:
  iftmp.18 = 4;
  <D.19018>:
  field_size = iftmp.18;
  goto <D.17100>;
  <D.17113>:
  D.18917 = i != 1;
  D.18918 = (long int) D.18917;
  D.18919 = __builtin_expect (D.18918, 0);
  if (D.18919 != 0) goto <D.19019>; else goto <D.19020>;
  <D.19019>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.19020>:
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  if (D.19023 <= 65535) goto <D.19024>; else goto <D.19025>;
  <D.19024>:
  iftmp.19 = 2;
  goto <D.19026>;
  <D.19025>:
  iftmp.19 = 4;
  <D.19026>:
  field_size = iftmp.19;
  goto <D.17100>;
  <D.17114>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.19027>; else goto <D.19028>;
  <D.19027>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.19028>:
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  if (D.19023 <= 65535) goto <D.19030>; else goto <D.19031>;
  <D.19030>:
  iftmp.20 = 2;
  goto <D.19032>;
  <D.19031>:
  iftmp.20 = 4;
  <D.19032>:
  field_size = iftmp.20;
  goto <D.17100>;
  <D.17115>:
  i.7 = (unsigned int) i;
  D.18938 = i.7 > 1;
  D.18939 = (long int) D.18938;
  D.18940 = __builtin_expect (D.18939, 0);
  if (D.18940 != 0) goto <D.19033>; else goto <D.19034>;
  <D.19033>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.19034>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.19036>; else goto <D.19037>;
  <D.19036>:
  iftmp.21 = 2;
  goto <D.19038>;
  <D.19037>:
  iftmp.21 = 4;
  <D.19038>:
  field_size = iftmp.21;
  goto <D.17100>;
  <D.17116>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.19039>; else goto <D.19040>;
  <D.19039>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.19040>:
  D.19008 = meta->tables[8].rows;
  D.19009 = (int) D.19008;
  if (D.19009 <= 65535) goto <D.19042>; else goto <D.19043>;
  <D.19042>:
  iftmp.22 = 2;
  goto <D.19044>;
  <D.19043>:
  iftmp.22 = 4;
  <D.19044>:
  field_size = iftmp.22;
  goto <D.17100>;
  <D.17117>:
  i.7 = (unsigned int) i;
  D.18938 = i.7 > 1;
  D.18939 = (long int) D.18938;
  D.18940 = __builtin_expect (D.18939, 0);
  if (D.18940 != 0) goto <D.19045>; else goto <D.19046>;
  <D.19045>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.19046>:
  if (i != 0) goto <D.19048>; else goto <D.19049>;
  <D.19048>:
  D.19051 = meta->tables[23].rows;
  D.19052 = (int) D.19051;
  if (D.19052 <= 65535) goto <D.19053>; else goto <D.19054>;
  <D.19053>:
  iftmp.24 = 2;
  goto <D.19055>;
  <D.19054>:
  iftmp.24 = 4;
  <D.19055>:
  iftmp.23 = iftmp.24;
  goto <D.19056>;
  <D.19049>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  if (D.18933 <= 65535) goto <D.19058>; else goto <D.19059>;
  <D.19058>:
  iftmp.25 = 2;
  goto <D.19060>;
  <D.19059>:
  iftmp.25 = 4;
  <D.19060>:
  iftmp.23 = iftmp.25;
  <D.19056>:
  field_size = iftmp.23;
  goto <D.17100>;
  <D.17118>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.19061>; else goto <D.19062>;
  <D.19061>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.19062>:
  D.19051 = meta->tables[23].rows;
  D.19052 = (int) D.19051;
  if (D.19052 <= 65535) goto <D.19064>; else goto <D.19065>;
  <D.19064>:
  iftmp.26 = 2;
  goto <D.19066>;
  <D.19065>:
  iftmp.26 = 4;
  <D.19066>:
  field_size = iftmp.26;
  goto <D.17100>;
  <D.17119>:
  i.7 = (unsigned int) i;
  D.19067 = i.7 + 4294967292;
  D.19068 = D.19067 > 1;
  D.19069 = (long int) D.19068;
  D.19070 = __builtin_expect (D.19069, 0);
  if (D.19070 != 0) goto <D.19071>; else goto <D.19072>;
  <D.19071>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.19072>:
  if (i == 4) goto <D.19074>; else goto <D.19075>;
  <D.19074>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  if (D.18972 <= 65535) goto <D.19077>; else goto <D.19078>;
  <D.19077>:
  iftmp.28 = 2;
  goto <D.19079>;
  <D.19078>:
  iftmp.28 = 4;
  <D.19079>:
  iftmp.27 = iftmp.28;
  goto <D.19080>;
  <D.19075>:
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  if (D.19023 <= 65535) goto <D.19082>; else goto <D.19083>;
  <D.19082>:
  iftmp.29 = 2;
  goto <D.19084>;
  <D.19083>:
  iftmp.29 = 4;
  <D.19084>:
  iftmp.27 = iftmp.29;
  <D.19080>:
  field_size = iftmp.27;
  goto <D.17100>;
  <D.17120>:
  D.18926 = i != 2;
  D.18927 = (long int) D.18926;
  D.18928 = __builtin_expect (D.18927, 0);
  if (D.18928 != 0) goto <D.19085>; else goto <D.19086>;
  <D.19085>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.19086>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  n = MAX_EXPR <D.18933, D.19023>;
  if (n <= 32767) goto <D.19088>; else goto <D.19089>;
  <D.19088>:
  iftmp.30 = 2;
  goto <D.19090>;
  <D.19089>:
  iftmp.30 = 4;
  <D.19090>:
  field_size = iftmp.30;
  goto <D.17100>;
  <D.17121>:
  D.18957 = i != 0;
  D.18958 = (long int) D.18957;
  D.18959 = __builtin_expect (D.18958, 0);
  if (D.18959 != 0) goto <D.19091>; else goto <D.19092>;
  <D.19091>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.19092>:
  D.19094 = meta->tables[42].rows;
  D.19095 = (int) D.19094;
  if (D.19095 <= 65535) goto <D.19096>; else goto <D.19097>;
  <D.19096>:
  iftmp.31 = 2;
  goto <D.19098>;
  <D.19097>:
  iftmp.31 = 4;
  <D.19098>:
  field_size = iftmp.31;
  goto <D.17100>;
  <D.17122>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.17123>:
  goto <D.17123>;
  <D.17100>:
  goto <D.17092>;
  <D.17124>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  D.19008 = meta->tables[8].rows;
  D.19009 = (int) D.19008;
  n = MAX_EXPR <D.18972, D.19009>;
  D.19051 = meta->tables[23].rows;
  D.19052 = (int) D.19051;
  n = MAX_EXPR <D.19052, n>;
  if (n <= 16383) goto <D.19100>; else goto <D.19101>;
  <D.19100>:
  iftmp.32 = 2;
  goto <D.19102>;
  <D.19101>:
  iftmp.32 = 4;
  <D.19102>:
  field_size = iftmp.32;
  goto <D.17092>;
  <D.17125>:
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  n = MAX_EXPR <D.18972, D.19023>;
  D.19103 = meta->tables[1].rows;
  D.19104 = (int) D.19103;
  n = MAX_EXPR <D.19104, n>;
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  n = MAX_EXPR <D.18933, n>;
  D.19008 = meta->tables[8].rows;
  D.19009 = (int) D.19008;
  n = MAX_EXPR <D.19009, n>;
  D.19105 = meta->tables[9].rows;
  D.19106 = (int) D.19105;
  n = MAX_EXPR <D.19106, n>;
  D.19107 = meta->tables[10].rows;
  D.19108 = (int) D.19107;
  n = MAX_EXPR <D.19108, n>;
  D.19109 = meta->tables[0].rows;
  D.19110 = (int) D.19109;
  n = MAX_EXPR <D.19110, n>;
  D.19111 = meta->tables[14].rows;
  D.19112 = (int) D.19111;
  n = MAX_EXPR <D.19112, n>;
  D.19051 = meta->tables[23].rows;
  D.19052 = (int) D.19051;
  n = MAX_EXPR <D.19052, n>;
  D.18947 = meta->tables[20].rows;
  D.18948 = (int) D.18947;
  n = MAX_EXPR <D.18948, n>;
  D.19113 = meta->tables[17].rows;
  D.19114 = (int) D.19113;
  n = MAX_EXPR <D.19114, n>;
  D.18991 = meta->tables[26].rows;
  D.18992 = (int) D.18991;
  n = MAX_EXPR <D.18992, n>;
  D.19115 = meta->tables[27].rows;
  D.19116 = (int) D.19115;
  n = MAX_EXPR <D.19116, n>;
  D.19117 = meta->tables[32].rows;
  D.19118 = (int) D.19117;
  n = MAX_EXPR <D.19118, n>;
  D.18912 = meta->tables[35].rows;
  D.18913 = (int) D.18912;
  n = MAX_EXPR <D.18913, n>;
  D.19119 = meta->tables[38].rows;
  D.19120 = (int) D.19119;
  n = MAX_EXPR <D.19120, n>;
  D.19121 = meta->tables[39].rows;
  D.19122 = (int) D.19121;
  n = MAX_EXPR <D.19122, n>;
  D.19123 = meta->tables[40].rows;
  D.19124 = (int) D.19123;
  n = MAX_EXPR <D.19124, n>;
  if (n <= 2047) goto <D.19126>; else goto <D.19127>;
  <D.19126>:
  iftmp.33 = 2;
  goto <D.19128>;
  <D.19127>:
  iftmp.33 = 4;
  <D.19128>:
  field_size = iftmp.33;
  goto <D.17092>;
  <D.17126>:
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  D.19103 = meta->tables[1].rows;
  D.19104 = (int) D.19103;
  n = MAX_EXPR <D.18933, D.19104>;
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  n = MAX_EXPR <D.19023, n>;
  D.19107 = meta->tables[10].rows;
  D.19108 = (int) D.19107;
  n = MAX_EXPR <D.19108, n>;
  if (n <= 8191) goto <D.19130>; else goto <D.19131>;
  <D.19130>:
  iftmp.34 = 2;
  goto <D.19132>;
  <D.19131>:
  iftmp.34 = 4;
  <D.19132>:
  field_size = iftmp.34;
  goto <D.17092>;
  <D.17127>:
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  n = MAX_EXPR <D.19023, D.18933>;
  D.19117 = meta->tables[32].rows;
  D.19118 = (int) D.19117;
  n = MAX_EXPR <D.19118, n>;
  if (n <= 16383) goto <D.19134>; else goto <D.19135>;
  <D.19134>:
  iftmp.35 = 2;
  goto <D.19136>;
  <D.19135>:
  iftmp.35 = 4;
  <D.19136>:
  field_size = iftmp.35;
  goto <D.17092>;
  <D.17128>:
  D.18912 = meta->tables[35].rows;
  D.18913 = (int) D.18912;
  D.19119 = meta->tables[38].rows;
  D.19120 = (int) D.19119;
  n = MAX_EXPR <D.18913, D.19120>;
  D.19121 = meta->tables[39].rows;
  D.19122 = (int) D.19121;
  n = MAX_EXPR <D.19122, n>;
  if (n <= 16383) goto <D.19138>; else goto <D.19139>;
  <D.19138>:
  iftmp.36 = 2;
  goto <D.19140>;
  <D.19139>:
  iftmp.36 = 4;
  <D.19140>:
  field_size = iftmp.36;
  goto <D.17092>;
  <D.17129>:
  D.19008 = meta->tables[8].rows;
  D.19009 = (int) D.19008;
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  n = MAX_EXPR <D.19009, D.18972>;
  if (n <= 32767) goto <D.19142>; else goto <D.19143>;
  <D.19142>:
  iftmp.37 = 2;
  goto <D.19144>;
  <D.19143>:
  iftmp.37 = 4;
  <D.19144>:
  field_size = iftmp.37;
  goto <D.17092>;
  <D.17130>:
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  D.18971 = meta->tables[4].rows;
  D.18972 = (int) D.18971;
  n = MAX_EXPR <D.19023, D.18972>;
  if (n <= 32767) goto <D.19146>; else goto <D.19147>;
  <D.19146>:
  iftmp.38 = 2;
  goto <D.19148>;
  <D.19147>:
  iftmp.38 = 4;
  <D.19148>:
  field_size = iftmp.38;
  goto <D.17092>;
  <D.17131>:
  D.19103 = meta->tables[1].rows;
  D.19104 = (int) D.19103;
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  n = MAX_EXPR <D.19104, D.18933>;
  D.19115 = meta->tables[27].rows;
  D.19116 = (int) D.19115;
  n = MAX_EXPR <D.19116, n>;
  if (n <= 16383) goto <D.19150>; else goto <D.19151>;
  <D.19150>:
  iftmp.39 = 2;
  goto <D.19152>;
  <D.19151>:
  iftmp.39 = 4;
  <D.19152>:
  field_size = iftmp.39;
  goto <D.17092>;
  <D.17132>:
  D.19103 = meta->tables[1].rows;
  D.19104 = (int) D.19103;
  D.18932 = meta->tables[2].rows;
  D.18933 = (int) D.18932;
  n = MAX_EXPR <D.19104, D.18933>;
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  n = MAX_EXPR <D.19023, n>;
  D.18991 = meta->tables[26].rows;
  D.18992 = (int) D.18991;
  n = MAX_EXPR <D.18992, n>;
  D.19115 = meta->tables[27].rows;
  D.19116 = (int) D.19115;
  n = MAX_EXPR <D.19116, n>;
  if (n <= 8191) goto <D.19154>; else goto <D.19155>;
  <D.19154>:
  iftmp.40 = 2;
  goto <D.19156>;
  <D.19155>:
  iftmp.40 = 4;
  <D.19156>:
  field_size = iftmp.40;
  goto <D.17092>;
  <D.17133>:
  D.19107 = meta->tables[10].rows;
  D.19108 = (int) D.19107;
  D.19022 = meta->tables[6].rows;
  D.19023 = (int) D.19022;
  n = MAX_EXPR <D.19108, D.19023>;
  if (n <= 32767) goto <D.19158>; else goto <D.19159>;
  <D.19158>:
  iftmp.41 = 2;
  goto <D.19160>;
  <D.19159>:
  iftmp.41 = 4;
  <D.19160>:
  field_size = iftmp.41;
  goto <D.17092>;
  <D.17134>:
  D.18947 = meta->tables[20].rows;
  D.18948 = (int) D.18947;
  D.19051 = meta->tables[23].rows;
  D.19052 = (int) D.19051;
  n = MAX_EXPR <D.18948, D.19052>;
  if (n <= 32767) goto <D.19162>; else goto <D.19163>;
  <D.19162>:
  iftmp.42 = 2;
  goto <D.19164>;
  <D.19163>:
  iftmp.42 = 4;
  <D.19164>:
  field_size = iftmp.42;
  goto <D.17092>;
  <D.17135>:
  D.18991 = meta->tables[26].rows;
  D.18992 = (int) D.18991;
  D.19109 = meta->tables[0].rows;
  D.19110 = (int) D.19109;
  n = MAX_EXPR <D.18992, D.19110>;
  D.18912 = meta->tables[35].rows;
  D.18913 = (int) D.18912;
  n = MAX_EXPR <D.18913, n>;
  D.19103 = meta->tables[1].rows;
  D.19104 = (int) D.19103;
  n = MAX_EXPR <D.19104, n>;
  if (n <= 16383) goto <D.19166>; else goto <D.19167>;
  <D.19166>:
  iftmp.43 = 2;
  goto <D.19168>;
  <D.19167>:
  iftmp.43 = 4;
  <D.19168>:
  field_size = iftmp.43;
  goto <D.17092>;
  <D.19169>:
  <D.17092>:
  D.19170 = field_size + -1;
  D.19171 = D.19170 << shift;
  D.19172 = (unsigned int) D.19171;
  bitfield = D.19172 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.17137>:
  i.44 = (sizetype) i;
  D.19174 = description + i.44;
  D.19175 = *D.19174;
  code = (int) D.19175;
  if (code != 0) goto <D.17136>; else goto <D.17138>;
  <D.17138>:
  D.19176 = i << 24;
  D.19177 = (unsigned int) D.19176;
  D.19178 = D.19177 | bitfield;
  *result_bitfield = D.19178;
  D.19179 = size;
  return D.19179;
}


mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  unsigned int D.19181;
  unsigned int D.19182;
  guint32 * D.19185;
  int D.19186;
  unsigned char D.19187;
  <unnamed-unsigned:24> D.19188;
  int D.19189;
  unsigned char D.19190;
  int D.19191;
  int D.19192;
  sizetype D.19193;
  int i;
  const char * base;

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

    table = &meta->tables[i];
    D.19181 = BIT_FIELD_REF <*table, 32, 32>;
    D.19182 = D.19181 & 16777215;
    if (D.19182 == 0) goto <D.19183>; else goto <D.19184>;
    <D.19183>:
    // predicted unlikely by continue predictor.
    goto <D.17145>;
    <D.19184>:
    D.19185 = &table->size_bitfield;
    D.19186 = mono_metadata_compute_size (meta, i, D.19185);
    D.19187 = (unsigned char) D.19186;
    table->row_size = D.19187;
    table->base = base;
    D.19188 = table->rows;
    D.19189 = (int) D.19188;
    D.19190 = table->row_size;
    D.19191 = (int) D.19190;
    D.19192 = D.19189 * D.19191;
    D.19193 = (sizetype) D.19192;
    base = base + D.19193;
  }
  <D.17145>:
  i = i + 1;
  <D.17147>:
  if (i <= 44) goto <D.17146>; else goto <D.17148>;
  <D.17148>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.19197;
  int D.19198;
  const char * D.19199;
  const char * D.19200;
  unsigned char D.19201;
  int D.19202;
  int D.19203;
  int D.19204;
  sizetype D.19205;

  if (idx <= 0) goto <D.19194>; else goto <D.19196>;
  <D.19196>:
  D.19197 = meta->tables[table].rows;
  D.19198 = (int) D.19197;
  if (D.19198 < idx) goto <D.19194>; else goto <D.19195>;
  <D.19194>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.19199 = "";
  return D.19199;
  <D.19195>:
  D.19200 = meta->tables[table].base;
  D.19201 = meta->tables[table].row_size;
  D.19202 = (int) D.19201;
  D.19203 = idx + -1;
  D.19204 = D.19202 * D.19203;
  D.19205 = (sizetype) D.19204;
  D.19199 = D.19200 + D.19205;
  return D.19199;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.19207;
  unsigned int D.19208;
  int D.19209;
  int token.45;
  int D.19211;

  D.19208 = token >> 24;
  D.19209 = (int) D.19208;
  token.45 = (int) token;
  D.19211 = token.45 & 16777215;
  D.19207 = mono_metadata_locate (meta, D.19209, D.19211);
  return D.19207;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19213;
  _Bool D.19214;
  long int D.19215;
  long int D.19216;
  const char * D.19221;
  const char * D.19222;

  D.19213 = meta->heap_strings.size;
  D.19214 = D.19213 <= index;
  D.19215 = (long int) D.19214;
  D.19216 = __builtin_expect (D.19215, 0);
  if (D.19216 != 0) goto <D.19217>; else goto <D.19218>;
  <D.19217>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.19218>:
  D.19213 = meta->heap_strings.size;
  if (D.19213 <= index) goto <D.19219>; else goto <D.19220>;
  <D.19219>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.19221 = "";
  return D.19221;
  <D.19220>:
  D.19222 = meta->heap_strings.data;
  D.19221 = D.19222 + index;
  return D.19221;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19224;
  _Bool D.19225;
  long int D.19226;
  long int D.19227;
  const char * D.19232;
  const char * D.19233;

  D.19224 = meta->heap_us.size;
  D.19225 = D.19224 <= index;
  D.19226 = (long int) D.19225;
  D.19227 = __builtin_expect (D.19226, 0);
  if (D.19227 != 0) goto <D.19228>; else goto <D.19229>;
  <D.19228>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.19229>:
  D.19224 = meta->heap_us.size;
  if (D.19224 <= index) goto <D.19230>; else goto <D.19231>;
  <D.19230>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.19232 = "";
  return D.19232;
  <D.19231>:
  D.19233 = meta->heap_us.data;
  D.19232 = D.19233 + index;
  return D.19232;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19235;
  _Bool D.19236;
  long int D.19237;
  long int D.19238;
  const char * D.19243;
  const char * D.19244;

  D.19235 = meta->heap_blob.size;
  D.19236 = D.19235 <= index;
  D.19237 = (long int) D.19236;
  D.19238 = __builtin_expect (D.19237, 0);
  if (D.19238 != 0) goto <D.19239>; else goto <D.19240>;
  <D.19239>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.19240>:
  D.19235 = meta->heap_blob.size;
  if (D.19235 <= index) goto <D.19241>; else goto <D.19242>;
  <D.19241>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.19243 = "";
  return D.19243;
  <D.19242>:
  D.19244 = meta->heap_blob.data;
  D.19243 = D.19244 + index;
  return D.19243;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.19246;
  const char * D.19249;
  const char * D.19250;

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


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.19252;
  <unnamed-unsigned:24> D.19253;
  int D.19254;
  _Bool D.19255;
  long int D.19256;
  long int D.19257;
  _Bool D.19260;
  long int D.19261;
  long int D.19262;
  const char * D.19265;
  unsigned char D.19266;
  int D.19267;
  int D.19268;
  sizetype D.19269;
  _Bool D.19270;
  long int D.19271;
  long int D.19272;
  int D.19275;
  unsigned int D.19276;
  unsigned int D.19277;
  unsigned int D.19278;
  unsigned int i.46;
  unsigned int D.19280;
  guint32 * D.19281;
  char D.19282;
  unsigned int D.19283;
  short unsigned int D.19284;
  unsigned int D.19285;
  unsigned int D.19286;
  sizetype n.47;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.19252 = bitfield >> 24;
  count = (int) D.19252;
  D.19253 = t->rows;
  D.19254 = (int) D.19253;
  D.19255 = D.19254 <= idx;
  D.19256 = (long int) D.19255;
  D.19257 = __builtin_expect (D.19256, 0);
  if (D.19257 != 0) goto <D.19258>; else goto <D.19259>;
  <D.19258>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.19259>:
  D.19260 = idx < 0;
  D.19261 = (long int) D.19260;
  D.19262 = __builtin_expect (D.19261, 0);
  if (D.19262 != 0) goto <D.19263>; else goto <D.19264>;
  <D.19263>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.19264>:
  D.19265 = t->base;
  D.19266 = t->row_size;
  D.19267 = (int) D.19266;
  D.19268 = D.19267 * idx;
  D.19269 = (sizetype) D.19268;
  data = D.19265 + D.19269;
  D.19270 = res_size != count;
  D.19271 = (long int) D.19270;
  D.19272 = __builtin_expect (D.19271, 0);
  if (D.19272 != 0) goto <D.19273>; else goto <D.19274>;
  <D.19273>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.19274>:
  i = 0;
  goto <D.17194>;
  <D.17193>:
  {
    int n;

    D.19275 = i * 2;
    D.19276 = bitfield >> D.19275;
    D.19277 = D.19276 & 3;
    D.19278 = D.19277 + 1;
    n = (int) D.19278;
    switch (n) <default: <D.17192>, case 1: <D.17188>, case 2: <D.17190>, case 4: <D.17191>>
    <D.17188>:
    i.46 = (unsigned int) i;
    D.19280 = i.46 * 4;
    D.19281 = res + D.19280;
    D.19282 = *data;
    D.19283 = (unsigned int) D.19282;
    *D.19281 = D.19283;
    goto <D.17189>;
    <D.17190>:
    i.46 = (unsigned int) i;
    D.19280 = i.46 * 4;
    D.19281 = res + D.19280;
    D.19284 = mono_read16 (data);
    D.19285 = (unsigned int) D.19284;
    *D.19281 = D.19285;
    goto <D.17189>;
    <D.17191>:
    i.46 = (unsigned int) i;
    D.19280 = i.46 * 4;
    D.19281 = res + D.19280;
    D.19286 = mono_read32 (data);
    *D.19281 = D.19286;
    goto <D.17189>;
    <D.17192>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.17189>:
    n.47 = (sizetype) n;
    data = data + n.47;
  }
  i = i + 1;
  <D.17194>:
  if (i < count) goto <D.17193>; else goto <D.17195>;
  <D.17195>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.19288;
  int D.19289;
  _Bool D.19290;
  long int D.19291;
  long int D.19292;
  unsigned int D.19295;
  _Bool D.19296;
  long int D.19297;
  long int D.19298;
  const char * D.19301;
  unsigned char D.19302;
  int D.19303;
  int D.19304;
  sizetype D.19305;
  unsigned int D.19306;
  unsigned int D.19307;
  sizetype n.48;
  int D.19309;
  int D.19310;
  unsigned int D.19311;
  unsigned int D.19312;
  unsigned int D.19313;
  unsigned int i.49;
  uint32_t D.19315;
  char D.19316;
  short unsigned int D.19317;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.19288 = t->rows;
  D.19289 = (int) D.19288;
  D.19290 = D.19289 <= idx;
  D.19291 = (long int) D.19290;
  D.19292 = __builtin_expect (D.19291, 0);
  if (D.19292 != 0) goto <D.19293>; else goto <D.19294>;
  <D.19293>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.19294>:
  D.19295 = bitfield >> 24;
  D.19296 = D.19295 <= col;
  D.19297 = (long int) D.19296;
  D.19298 = __builtin_expect (D.19297, 0);
  if (D.19298 != 0) goto <D.19299>; else goto <D.19300>;
  <D.19299>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.19300>:
  D.19301 = t->base;
  D.19302 = t->row_size;
  D.19303 = (int) D.19302;
  D.19304 = D.19303 * idx;
  D.19305 = (sizetype) D.19304;
  data = D.19301 + D.19305;
  D.19306 = bitfield & 3;
  D.19307 = D.19306 + 1;
  n = (int) D.19307;
  i = 0;
  goto <D.17206>;
  <D.17205>:
  n.48 = (sizetype) n;
  data = data + n.48;
  D.19309 = i + 1;
  D.19310 = D.19309 * 2;
  D.19311 = bitfield >> D.19310;
  D.19312 = D.19311 & 3;
  D.19313 = D.19312 + 1;
  n = (int) D.19313;
  i = i + 1;
  <D.17206>:
  i.49 = (unsigned int) i;
  if (i.49 < col) goto <D.17205>; else goto <D.17207>;
  <D.17207>:
  switch (n) <default: <D.17211>, case 1: <D.17208>, case 2: <D.17209>, case 4: <D.17210>>
  <D.17208>:
  D.19316 = *data;
  D.19315 = (uint32_t) D.19316;
  return D.19315;
  <D.17209>:
  D.19317 = mono_read16 (data);
  D.19315 = (uint32_t) D.19317;
  return D.19315;
  <D.17210>:
  D.19315 = mono_read32 (data);
  return D.19315;
  <D.17211>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.19315 = 0;
  return D.19315;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.19319;
  signed char D.19320;
  unsigned int D.19323;
  int D.19325;
  int D.19326;
  int D.19329;
  int D.19330;
  const unsigned char * D.19331;
  unsigned char D.19332;
  int D.19333;
  int D.19334;
  int D.19336;
  int D.19337;
  int D.19338;
  int D.19339;
  const unsigned char * D.19340;
  unsigned char D.19341;
  int D.19342;
  int D.19343;
  int D.19344;
  const unsigned char * D.19345;
  unsigned char D.19346;
  int D.19347;
  int D.19348;
  uint32_t D.19351;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.19319 = *ptr;
  D.19320 = (signed char) D.19319;
  if (D.19320 >= 0) goto <D.19321>; else goto <D.19322>;
  <D.19321>:
  D.19319 = *ptr;
  D.19323 = (unsigned int) D.19319;
  size = D.19323 & 127;
  ptr = ptr + 1;
  goto <D.19324>;
  <D.19322>:
  D.19319 = *ptr;
  D.19325 = (int) D.19319;
  D.19326 = D.19325 & 64;
  if (D.19326 == 0) goto <D.19327>; else goto <D.19328>;
  <D.19327>:
  D.19319 = *ptr;
  D.19325 = (int) D.19319;
  D.19329 = D.19325 & 63;
  D.19330 = D.19329 << 8;
  D.19331 = ptr + 1;
  D.19332 = *D.19331;
  D.19333 = (int) D.19332;
  D.19334 = D.19330 + D.19333;
  size = (guint32) D.19334;
  ptr = ptr + 2;
  goto <D.19335>;
  <D.19328>:
  D.19319 = *ptr;
  D.19325 = (int) D.19319;
  D.19336 = D.19325 & 31;
  D.19337 = D.19336 << 24;
  D.19331 = ptr + 1;
  D.19332 = *D.19331;
  D.19333 = (int) D.19332;
  D.19338 = D.19333 << 16;
  D.19339 = D.19337 + D.19338;
  D.19340 = ptr + 2;
  D.19341 = *D.19340;
  D.19342 = (int) D.19341;
  D.19343 = D.19342 << 8;
  D.19344 = D.19339 + D.19343;
  D.19345 = ptr + 3;
  D.19346 = *D.19345;
  D.19347 = (int) D.19346;
  D.19348 = D.19344 + D.19347;
  size = (guint32) D.19348;
  ptr = ptr + 4;
  <D.19335>:
  <D.19324>:
  if (rptr != 0B) goto <D.19349>; else goto <D.19350>;
  <D.19349>:
  *rptr = ptr;
  <D.19350>:
  D.19351 = size;
  return D.19351;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.50;
  int D.19357;
  int D.19358;
  int D.19361;
  int D.19362;
  const unsigned char * D.19363;
  unsigned char D.19364;
  int D.19365;
  int D.19366;
  int D.19368;
  int D.19369;
  int D.19370;
  int D.19371;
  const unsigned char * D.19372;
  unsigned char D.19373;
  int D.19374;
  int D.19375;
  int D.19376;
  const unsigned char * D.19377;
  unsigned char D.19378;
  int D.19379;
  int D.19380;
  uint32_t D.19383;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.50 = (signed char) b;
  if (b.50 >= 0) goto <D.19354>; else goto <D.19355>;
  <D.19354>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.19356>;
  <D.19355>:
  D.19357 = (int) b;
  D.19358 = D.19357 & 64;
  if (D.19358 == 0) goto <D.19359>; else goto <D.19360>;
  <D.19359>:
  D.19357 = (int) b;
  D.19361 = D.19357 & 63;
  D.19362 = D.19361 << 8;
  D.19363 = ptr + 1;
  D.19364 = *D.19363;
  D.19365 = (int) D.19364;
  D.19366 = D.19362 | D.19365;
  len = (guint32) D.19366;
  ptr = ptr + 2;
  goto <D.19367>;
  <D.19360>:
  D.19357 = (int) b;
  D.19368 = D.19357 & 31;
  D.19369 = D.19368 << 24;
  D.19363 = ptr + 1;
  D.19364 = *D.19363;
  D.19365 = (int) D.19364;
  D.19370 = D.19365 << 16;
  D.19371 = D.19369 | D.19370;
  D.19372 = ptr + 2;
  D.19373 = *D.19372;
  D.19374 = (int) D.19373;
  D.19375 = D.19374 << 8;
  D.19376 = D.19371 | D.19375;
  D.19377 = ptr + 3;
  D.19378 = *D.19377;
  D.19379 = (int) D.19378;
  D.19380 = D.19376 | D.19379;
  len = (guint32) D.19380;
  ptr = ptr + 4;
  <D.19367>:
  <D.19356>:
  if (rptr != 0B) goto <D.19381>; else goto <D.19382>;
  <D.19381>:
  *rptr = ptr;
  <D.19382>:
  D.19383 = len;
  return D.19383;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.19385;
  unsigned int D.19386;
  int32_t D.19389;
  _Bool D.19396;
  long int D.19397;
  long int D.19398;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.19385 = uval >> 1;
  ival = (gint32) D.19385;
  D.19386 = uval & 1;
  if (D.19386 == 0) goto <D.19387>; else goto <D.19388>;
  <D.19387>:
  D.19389 = ival;
  return D.19389;
  <D.19388>:
  if (ival <= 63) goto <D.19390>; else goto <D.19391>;
  <D.19390>:
  D.19389 = ival + -64;
  return D.19389;
  <D.19391>:
  if (ival <= 8191) goto <D.19392>; else goto <D.19393>;
  <D.19392>:
  D.19389 = ival + -8192;
  return D.19389;
  <D.19393>:
  if (ival <= 268435455) goto <D.19394>; else goto <D.19395>;
  <D.19394>:
  D.19389 = ival + -268435456;
  return D.19389;
  <D.19395>:
  D.19396 = ival > 536870911;
  D.19397 = (long int) D.19396;
  D.19398 = __builtin_expect (D.19397, 0);
  if (D.19398 != 0) goto <D.19399>; else goto <D.19400>;
  <D.19399>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1121, "ival < 0x20000000");
  <D.19400>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.19389 = ival + -536870912;
  return D.19389;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  unsigned int D.19402;
  unsigned int D.19403;
  uint32_t D.19406;
  unsigned int D.19407;
  unsigned int D.19408;
  struct MonoTableInfo * D.19411;
  unsigned int D.19412;
  int D.19413;
  unsigned int D.19414;
  unsigned int D.19415;
  struct MonoTableInfo * D.19418;
  unsigned int D.19419;
  unsigned int D.19420;
  struct MonoTableInfo * D.19423;
  unsigned int D.19424;
  unsigned int D.19425;
  struct MonoTableInfo * D.19428;
  unsigned int D.19429;
  unsigned int D.19430;
  struct MonoTableInfo * D.19433;

  D.19402 = BIT_FIELD_REF <*image, 32, 128>;
  D.19403 = D.19402 & 32;
  if (D.19403 == 0) goto <D.19404>; else goto <D.19405>;
  <D.19404>:
  D.19406 = idx;
  return D.19406;
  <D.19405>:
  switch (table) <default: <D.17241>, case 4: <D.17237>, case 6: <D.17236>, case 8: <D.17240>, case 20: <D.17238>, case 23: <D.17239>>
  <D.17236>:
  D.19407 = BIT_FIELD_REF <*image, 32, 1312>;
  D.19408 = D.19407 & 16777215;
  if (D.19408 != 0) goto <D.19409>; else goto <D.19410>;
  <D.19409>:
  D.19411 = &image->tables[5];
  D.19412 = idx + 4294967295;
  D.19413 = (int) D.19412;
  D.19406 = mono_metadata_decode_row_col (D.19411, D.19413, 0);
  return D.19406;
  <D.19410>:
  D.19406 = idx;
  return D.19406;
  <D.17237>:
  D.19414 = BIT_FIELD_REF <*image, 32, 1120>;
  D.19415 = D.19414 & 16777215;
  if (D.19415 != 0) goto <D.19416>; else goto <D.19417>;
  <D.19416>:
  D.19418 = &image->tables[3];
  D.19412 = idx + 4294967295;
  D.19413 = (int) D.19412;
  D.19406 = mono_metadata_decode_row_col (D.19418, D.19413, 0);
  return D.19406;
  <D.19417>:
  D.19406 = idx;
  return D.19406;
  <D.17238>:
  D.19419 = BIT_FIELD_REF <*image, 32, 2656>;
  D.19420 = D.19419 & 16777215;
  if (D.19420 != 0) goto <D.19421>; else goto <D.19422>;
  <D.19421>:
  D.19423 = &image->tables[19];
  D.19412 = idx + 4294967295;
  D.19413 = (int) D.19412;
  D.19406 = mono_metadata_decode_row_col (D.19423, D.19413, 0);
  return D.19406;
  <D.19422>:
  D.19406 = idx;
  return D.19406;
  <D.17239>:
  D.19424 = BIT_FIELD_REF <*image, 32, 2944>;
  D.19425 = D.19424 & 16777215;
  if (D.19425 != 0) goto <D.19426>; else goto <D.19427>;
  <D.19426>:
  D.19428 = &image->tables[22];
  D.19412 = idx + 4294967295;
  D.19413 = (int) D.19412;
  D.19406 = mono_metadata_decode_row_col (D.19428, D.19413, 0);
  return D.19406;
  <D.19427>:
  D.19406 = idx;
  return D.19406;
  <D.17240>:
  D.19429 = BIT_FIELD_REF <*image, 32, 1504>;
  D.19430 = D.19429 & 16777215;
  if (D.19430 != 0) goto <D.19431>; else goto <D.19432>;
  <D.19431>:
  D.19433 = &image->tables[7];
  D.19412 = idx + 4294967295;
  D.19413 = (int) D.19412;
  D.19406 = mono_metadata_decode_row_col (D.19433, D.19413, 0);
  return D.19406;
  <D.19432>:
  D.19406 = idx;
  return D.19406;
  <D.17241>:
  D.19406 = idx;
  return D.19406;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  unsigned int D.19435;
  unsigned int D.19436;
  int D.19439;
  unsigned int D.19440;
  unsigned int D.19441;
  unsigned int D.19442;
  struct MonoTableInfo * D.19443;

  D.19435 = BIT_FIELD_REF <*image, 32, 128>;
  D.19436 = D.19435 & 32;
  if (D.19436 != 0) goto <D.19437>; else goto <D.19438>;
  <D.19437>:
  D.19439 = idx + 1;
  D.19440 = (unsigned int) D.19439;
  D.19441 = mono_metadata_translate_token_index (image, table, D.19440);
  D.19442 = D.19441 + 4294967295;
  idx = (int) D.19442;
  <D.19438>:
  D.19443 = &image->tables[table];
  mono_metadata_decode_row (D.19443, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  unsigned int D.19444;
  unsigned int D.19445;
  int D.19448;
  unsigned int D.19449;
  unsigned int D.19450;
  unsigned int D.19451;
  uint32_t D.19452;
  struct MonoTableInfo * D.19453;

  D.19444 = BIT_FIELD_REF <*image, 32, 128>;
  D.19445 = D.19444 & 32;
  if (D.19445 != 0) goto <D.19446>; else goto <D.19447>;
  <D.19446>:
  D.19448 = idx + 1;
  D.19449 = (unsigned int) D.19448;
  D.19450 = mono_metadata_translate_token_index (image, table, D.19449);
  D.19451 = D.19450 + 4294967295;
  idx = (int) D.19451;
  <D.19447>:
  D.19453 = &image->tables[table];
  D.19452 = mono_metadata_decode_row_col (D.19453, idx, col);
  return D.19452;
}


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

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


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.19460;
  unsigned char D.19461;
  unsigned char D.19462;
  _Bool D.19467;
  const char * D.19468;
  unsigned int D.19469;
  <unnamed-unsigned:31> D.19470;
  int D.19471;
  struct MonoCustomMod local;

  try
    {
      D.19460 = *ptr;
      D.19461 = (unsigned char) D.19460;
      D.19462 = D.19461 + 225;
      if (D.19462 <= 1) goto <D.19463>; else goto <D.19464>;
      <D.19463>:
      if (dest == 0B) goto <D.19465>; else goto <D.19466>;
      <D.19465>:
      dest = &local;
      <D.19466>:
      D.19460 = *ptr;
      D.19467 = D.19460 == 31;
      dest->required = D.19467;
      D.19468 = ptr + 1;
      D.19469 = mono_metadata_parse_typedef_or_ref (m, D.19468, rptr);
      D.19470 = (<unnamed-unsigned:31>) D.19469;
      dest->token = D.19470;
      D.19471 = 1;
      return D.19471;
      <D.19464>:
      D.19471 = 0;
      return D.19471;
    }
  finally
    {
      local = {CLOBBER};
    }
}


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

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


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.19483;
  struct MonoClass * D.19484;
  unsigned int D.19485;
  unsigned char D.19486;
  unsigned int D.19487;
  unsigned char D.19488;
  unsigned char D.19489;
  void * iftmp.54;
  unsigned int D.19495;
  unsigned int D.19496;
  int * D.19498;
  unsigned int i.55;
  unsigned int D.19500;
  int * D.19501;
  unsigned int D.19502;
  int D.19503;
  int D.19504;
  unsigned int D.19505;
  unsigned char D.19506;
  unsigned char D.19507;
  void * iftmp.56;
  unsigned int D.19513;
  unsigned int D.19514;
  int * D.19516;
  int * D.19517;
  int D.19518;
  int D.19519;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.19477>; else goto <D.19478>;
  <D.19477>:
  iftmp.52 = monoeg_malloc0 (16);
  goto <D.19479>;
  <D.19478>:
  iftmp.52 = mono_image_alloc0 (m, 16);
  <D.19479>:
  array = iftmp.52;
  ptr.53 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.53, &ptr);
  if (etype == 0B) goto <D.19481>; else goto <D.19482>;
  <D.19481>:
  D.19483 = 0B;
  return D.19483;
  <D.19482>:
  D.19484 = mono_class_from_mono_type (etype);
  array->eklass = D.19484;
  ptr.53 = ptr;
  D.19485 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19486 = (unsigned char) D.19485;
  array->rank = D.19486;
  ptr.53 = ptr;
  D.19487 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19488 = (unsigned char) D.19487;
  array->numsizes = D.19488;
  D.19489 = array->numsizes;
  if (D.19489 != 0) goto <D.19490>; else goto <D.19491>;
  <D.19490>:
  if (transient != 0) goto <D.19493>; else goto <D.19494>;
  <D.19493>:
  D.19489 = array->numsizes;
  D.19495 = (unsigned int) D.19489;
  D.19496 = D.19495 * 4;
  iftmp.54 = monoeg_malloc0 (D.19496);
  goto <D.19497>;
  <D.19494>:
  D.19489 = array->numsizes;
  D.19495 = (unsigned int) D.19489;
  D.19496 = D.19495 * 4;
  iftmp.54 = mono_image_alloc0 (m, D.19496);
  <D.19497>:
  array->sizes = iftmp.54;
  <D.19491>:
  i = 0;
  goto <D.17279>;
  <D.17278>:
  D.19498 = array->sizes;
  i.55 = (unsigned int) i;
  D.19500 = i.55 * 4;
  D.19501 = D.19498 + D.19500;
  ptr.53 = ptr;
  D.19502 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19503 = (int) D.19502;
  *D.19501 = D.19503;
  i = i + 1;
  <D.17279>:
  D.19489 = array->numsizes;
  D.19504 = (int) D.19489;
  if (D.19504 > i) goto <D.17278>; else goto <D.17280>;
  <D.17280>:
  ptr.53 = ptr;
  D.19505 = mono_metadata_decode_value (ptr.53, &ptr);
  D.19506 = (unsigned char) D.19505;
  array->numlobounds = D.19506;
  D.19507 = array->numlobounds;
  if (D.19507 != 0) goto <D.19508>; else goto <D.19509>;
  <D.19508>:
  if (transient != 0) goto <D.19511>; else goto <D.19512>;
  <D.19511>:
  D.19507 = array->numlobounds;
  D.19513 = (unsigned int) D.19507;
  D.19514 = D.19513 * 4;
  iftmp.56 = monoeg_malloc0 (D.19514);
  goto <D.19515>;
  <D.19512>:
  D.19507 = array->numlobounds;
  D.19513 = (unsigned int) D.19507;
  D.19514 = D.19513 * 4;
  iftmp.56 = mono_image_alloc0 (m, D.19514);
  <D.19515>:
  array->lobounds = iftmp.56;
  <D.19509>:
  i = 0;
  goto <D.17282>;
  <D.17281>:
  D.19516 = array->lobounds;
  i.55 = (unsigned int) i;
  D.19500 = i.55 * 4;
  D.19517 = D.19516 + D.19500;
  ptr.53 = ptr;
  D.19518 = mono_metadata_decode_signed_value (ptr.53, &ptr);
  *D.19517 = D.19518;
  i = i + 1;
  <D.17282>:
  D.19507 = array->numlobounds;
  D.19519 = (int) D.19507;
  if (D.19519 > i) goto <D.17281>; else goto <D.17283>;
  <D.17283>:
  if (rptr != 0B) goto <D.19520>; else goto <D.19521>;
  <D.19520>:
  ptr.53 = ptr;
  *rptr = ptr.53;
  <D.19521>:
  D.19483 = array;
  return D.19483;
}


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

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


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.19525;
  int * D.19526;

  D.19525 = array->sizes;
  monoeg_g_free (D.19525);
  D.19526 = array->lobounds;
  monoeg_g_free (D.19526);
  monoeg_g_free (array);
}


mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.19527;
  unsigned int D.19528;
  <unnamed-unsigned:22> D.19529;
  int D.19530;
  guint D.19531;
  <unnamed-unsigned:1> D.19532;
  int D.19533;
  int D.19534;
  unsigned int D.19535;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.17322>;
  <D.17321>:
  hash = hash * 13;
  D.19527 = ginst->type_argv[i];
  D.19528 = mono_metadata_type_hash (D.19527);
  hash = D.19528 + hash;
  i = i + 1;
  <D.17322>:
  D.19529 = ginst->type_argc;
  D.19530 = (int) D.19529;
  if (D.19530 > i) goto <D.17321>; else goto <D.17323>;
  <D.17323>:
  D.19532 = ginst->is_open;
  D.19533 = (int) D.19532;
  D.19534 = D.19533 << 8;
  D.19535 = (unsigned int) D.19534;
  D.19531 = D.19535 ^ hash;
  return D.19531;
}


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

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


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.19539;
  unsigned int D.19542;
  gboolean D.19547;
  unsigned int D.19550;
  unsigned int D.19551;
  unsigned int D.19552;
  unsigned int D.19553;
  struct MonoType * D.19556;
  struct MonoType * D.19557;
  int D.19558;
  <unnamed-unsigned:22> D.19561;
  int D.19562;
  int i;

  D.19539 = a->id;
  if (D.19539 != 0) goto <D.19540>; else goto <D.19541>;
  <D.19540>:
  D.19542 = b->id;
  if (D.19542 != 0) goto <D.19543>; else goto <D.19544>;
  <D.19543>:
  D.19539 = a->id;
  D.19542 = b->id;
  if (D.19539 == D.19542) goto <D.19545>; else goto <D.19546>;
  <D.19545>:
  D.19547 = 1;
  return D.19547;
  <D.19546>:
  if (signature_only == 0) goto <D.19548>; else goto <D.19549>;
  <D.19548>:
  D.19547 = 0;
  return D.19547;
  <D.19549>:
  <D.19544>:
  <D.19541>:
  D.19550 = BIT_FIELD_REF <*a, 32, 32>;
  D.19551 = BIT_FIELD_REF <*b, 32, 32>;
  D.19552 = D.19550 ^ D.19551;
  D.19553 = D.19552 & 8388607;
  if (D.19553 != 0) goto <D.19554>; else goto <D.19555>;
  <D.19554>:
  D.19547 = 0;
  return D.19547;
  <D.19555>:
  i = 0;
  goto <D.17331>;
  <D.17330>:
  D.19556 = a->type_argv[i];
  D.19557 = b->type_argv[i];
  D.19558 = do_mono_metadata_type_equal (D.19556, D.19557, signature_only);
  if (D.19558 == 0) goto <D.19559>; else goto <D.19560>;
  <D.19559>:
  D.19547 = 0;
  return D.19547;
  <D.19560>:
  i = i + 1;
  <D.17331>:
  D.19561 = a->type_argc;
  D.19562 = (int) D.19561;
  if (D.19562 > i) goto <D.17330>; else goto <D.17332>;
  <D.17332>:
  D.19547 = 1;
  return D.19547;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.19566;
  unsigned char D.19567;
  unsigned int D.19569;
  unsigned int D.19570;
  unsigned int D.19571;
  unsigned int D.19572;
  gboolean D.19573;
  int D.19574;
  struct MonoClass * D.19575;
  struct MonoClass * D.19576;
  struct MonoType * D.19577;
  struct MonoType * D.19578;
  struct MonoArrayType * D.19579;
  unsigned char D.19580;
  struct MonoArrayType * D.19581;
  unsigned char D.19582;
  struct MonoClass * D.19585;
  struct MonoClass * D.19586;
  struct MonoGenericClass * D.19587;
  struct MonoGenericClass * D.19588;
  struct MonoGenericParam * D.19589;
  struct MonoGenericParam * D.19590;
  struct MonoMethodSignature * D.19591;
  struct MonoMethodSignature * D.19592;

  D.19566 = t1->type;
  D.19567 = t2->type;
  if (D.19566 != D.19567) goto <D.19564>; else goto <D.19568>;
  <D.19568>:
  D.19569 = BIT_FIELD_REF <*t1, 32, 32>;
  D.19570 = BIT_FIELD_REF <*t2, 32, 32>;
  D.19571 = D.19569 ^ D.19570;
  D.19572 = D.19571 & 1073741824;
  if (D.19572 != 0) goto <D.19564>; else goto <D.19565>;
  <D.19564>:
  D.19573 = 0;
  return D.19573;
  <D.19565>:
  D.19566 = t1->type;
  D.19574 = (int) D.19566;
  switch (D.19574) <default: <D.18441>, case 1: <D.18414>, case 2: <D.18415>, case 3: <D.18416>, case 4: <D.18417>, case 5: <D.18418>, case 6: <D.18419>, case 7: <D.18420>, case 8: <D.18421>, case 9: <D.18422>, case 10: <D.18423>, case 11: <D.18424>, case 12: <D.18425>, case 13: <D.18426>, case 14: <D.18427>, case 15: <D.18435>, case 17: <D.18432>, case 18: <D.18433>, case 19: <D.18438>, case 20: <D.18436>, case 21: <D.18437>, case 22: <D.18431>, case 24: <D.18428>, case 25: <D.18429>, case 27: <D.18440>, case 28: <D.18430>, case 29: <D.18434>, case 30: <D.18439>>
  <D.18414>:
  <D.18415>:
  <D.18416>:
  <D.18417>:
  <D.18418>:
  <D.18419>:
  <D.18420>:
  <D.18421>:
  <D.18422>:
  <D.18423>:
  <D.18424>:
  <D.18425>:
  <D.18426>:
  <D.18427>:
  <D.18428>:
  <D.18429>:
  <D.18430>:
  <D.18431>:
  D.19573 = 1;
  return D.19573;
  <D.18432>:
  <D.18433>:
  <D.18434>:
  D.19575 = t1->data.klass;
  D.19576 = t2->data.klass;
  D.19573 = mono_metadata_class_equal (D.19575, D.19576, signature_only);
  return D.19573;
  <D.18435>:
  D.19577 = t1->data.type;
  D.19578 = t2->data.type;
  D.19573 = do_mono_metadata_type_equal (D.19577, D.19578, signature_only);
  return D.19573;
  <D.18436>:
  D.19579 = t1->data.array;
  D.19580 = D.19579->rank;
  D.19581 = t2->data.array;
  D.19582 = D.19581->rank;
  if (D.19580 != D.19582) goto <D.19583>; else goto <D.19584>;
  <D.19583>:
  D.19573 = 0;
  return D.19573;
  <D.19584>:
  D.19579 = t1->data.array;
  D.19585 = D.19579->eklass;
  D.19581 = t2->data.array;
  D.19586 = D.19581->eklass;
  D.19573 = mono_metadata_class_equal (D.19585, D.19586, signature_only);
  return D.19573;
  <D.18437>:
  D.19587 = t1->data.generic_class;
  D.19588 = t2->data.generic_class;
  D.19573 = _mono_metadata_generic_class_equal (D.19587, D.19588, signature_only);
  return D.19573;
  <D.18438>:
  D.19589 = t1->data.generic_param;
  D.19590 = t2->data.generic_param;
  D.19573 = mono_metadata_generic_param_equal (D.19589, D.19590, signature_only);
  return D.19573;
  <D.18439>:
  D.19589 = t1->data.generic_param;
  D.19590 = t2->data.generic_param;
  D.19573 = mono_metadata_generic_param_equal (D.19589, D.19590, signature_only);
  return D.19573;
  <D.18440>:
  D.19591 = t1->data.method;
  D.19592 = t2->data.method;
  D.19573 = mono_metadata_fnptr_equal (D.19591, D.19592, signature_only);
  return D.19573;
  <D.18441>:
  D.19566 = t1->type;
  D.19574 = (int) D.19566;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.19574);
  <D.18442>:
  goto <D.18442>;
  D.19573 = 0;
  return D.19573;
  D.19573 = 0;
  return D.19573;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.19596;
  struct MonoGenericClass * D.19597;
  struct MonoGenericClass * D.19600;
  struct MonoGenericContainer * D.19605;
  struct MonoGenericContainer * D.19608;
  unsigned char D.19613;
  unsigned char D.19616;
  struct MonoGenericParam * D.19619;
  struct MonoGenericParam * D.19620;
  struct MonoClass * D.19631;
  struct MonoClass * D.19632;
  struct MonoType * D.19639;
  struct MonoType * D.19640;

  if (c1 == c2) goto <D.19594>; else goto <D.19595>;
  <D.19594>:
  D.19596 = 1;
  return D.19596;
  <D.19595>:
  D.19597 = c1->generic_class;
  if (D.19597 != 0B) goto <D.19598>; else goto <D.19599>;
  <D.19598>:
  D.19600 = c2->generic_class;
  if (D.19600 != 0B) goto <D.19601>; else goto <D.19602>;
  <D.19601>:
  D.19597 = c1->generic_class;
  D.19600 = c2->generic_class;
  D.19596 = _mono_metadata_generic_class_equal (D.19597, D.19600, signature_only);
  return D.19596;
  <D.19602>:
  <D.19599>:
  D.19597 = c1->generic_class;
  if (D.19597 != 0B) goto <D.19603>; else goto <D.19604>;
  <D.19603>:
  D.19605 = c2->generic_container;
  if (D.19605 != 0B) goto <D.19606>; else goto <D.19607>;
  <D.19606>:
  D.19597 = c1->generic_class;
  D.19596 = _mono_metadata_generic_class_container_equal (D.19597, c2, signature_only);
  return D.19596;
  <D.19607>:
  <D.19604>:
  D.19608 = c1->generic_container;
  if (D.19608 != 0B) goto <D.19609>; else goto <D.19610>;
  <D.19609>:
  D.19600 = c2->generic_class;
  if (D.19600 != 0B) goto <D.19611>; else goto <D.19612>;
  <D.19611>:
  D.19600 = c2->generic_class;
  D.19596 = _mono_metadata_generic_class_container_equal (D.19600, c1, signature_only);
  return D.19596;
  <D.19612>:
  <D.19610>:
  D.19613 = c1->byval_arg.type;
  if (D.19613 == 19) goto <D.19614>; else goto <D.19615>;
  <D.19614>:
  D.19616 = c2->byval_arg.type;
  if (D.19616 == 19) goto <D.19617>; else goto <D.19618>;
  <D.19617>:
  D.19619 = c1->byval_arg.data.generic_param;
  D.19620 = c2->byval_arg.data.generic_param;
  D.19596 = mono_metadata_generic_param_equal (D.19619, D.19620, signature_only);
  return D.19596;
  <D.19618>:
  <D.19615>:
  D.19613 = c1->byval_arg.type;
  if (D.19613 == 30) goto <D.19621>; else goto <D.19622>;
  <D.19621>:
  D.19616 = c2->byval_arg.type;
  if (D.19616 == 30) goto <D.19623>; else goto <D.19624>;
  <D.19623>:
  D.19619 = c1->byval_arg.data.generic_param;
  D.19620 = c2->byval_arg.data.generic_param;
  D.19596 = mono_metadata_generic_param_equal (D.19619, D.19620, signature_only);
  return D.19596;
  <D.19624>:
  <D.19622>:
  if (signature_only != 0) goto <D.19625>; else goto <D.19626>;
  <D.19625>:
  D.19613 = c1->byval_arg.type;
  if (D.19613 == 29) goto <D.19627>; else goto <D.19628>;
  <D.19627>:
  D.19616 = c2->byval_arg.type;
  if (D.19616 == 29) goto <D.19629>; else goto <D.19630>;
  <D.19629>:
  D.19631 = c1->byval_arg.data.klass;
  D.19632 = c2->byval_arg.data.klass;
  D.19596 = mono_metadata_class_equal (D.19631, D.19632, signature_only);
  return D.19596;
  <D.19630>:
  <D.19628>:
  <D.19626>:
  if (signature_only != 0) goto <D.19633>; else goto <D.19634>;
  <D.19633>:
  D.19613 = c1->byval_arg.type;
  if (D.19613 == 20) goto <D.19635>; else goto <D.19636>;
  <D.19635>:
  D.19616 = c2->byval_arg.type;
  if (D.19616 == 20) goto <D.19637>; else goto <D.19638>;
  <D.19637>:
  D.19639 = &c1->byval_arg;
  D.19640 = &c2->byval_arg;
  D.19596 = do_mono_metadata_type_equal (D.19639, D.19640, signature_only);
  return D.19596;
  <D.19638>:
  <D.19636>:
  <D.19634>:
  D.19596 = 0;
  return D.19596;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.19642;
  struct MonoClass * D.19643;
  int D.19644;
  gboolean D.19647;
  int D.19648;
  unsigned int D.19651;
  unsigned int D.19652;
  _Bool D.19653;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.19642 = c2->generic_container;
  i2 = D.19642->context.class_inst;
  D.19643 = g1->container_class;
  D.19644 = mono_metadata_class_equal (D.19643, c2, signature_only);
  if (D.19644 == 0) goto <D.19645>; else goto <D.19646>;
  <D.19645>:
  D.19647 = 0;
  return D.19647;
  <D.19646>:
  D.19648 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.19648 == 0) goto <D.19649>; else goto <D.19650>;
  <D.19649>:
  D.19647 = 0;
  return D.19647;
  <D.19650>:
  D.19651 = BIT_FIELD_REF <*g1, 32, 96>;
  D.19652 = D.19651 & 2;
  D.19653 = D.19652 == 0;
  D.19647 = (gboolean) D.19653;
  return D.19647;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  unsigned int D.19655;
  unsigned int D.19656;
  unsigned int D.19657;
  unsigned int D.19658;
  gboolean D.19661;
  struct MonoClass * D.19662;
  struct MonoClass * D.19663;
  int D.19664;
  int D.19667;
  unsigned int D.19670;
  _Bool D.19671;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.19655 = BIT_FIELD_REF <*g1, 32, 96>;
  D.19656 = BIT_FIELD_REF <*g2, 32, 96>;
  D.19657 = D.19655 ^ D.19656;
  D.19658 = D.19657 & 1;
  if (D.19658 != 0) goto <D.19659>; else goto <D.19660>;
  <D.19659>:
  D.19661 = 0;
  return D.19661;
  <D.19660>:
  D.19662 = g1->container_class;
  D.19663 = g2->container_class;
  D.19664 = mono_metadata_class_equal (D.19662, D.19663, signature_only);
  if (D.19664 == 0) goto <D.19665>; else goto <D.19666>;
  <D.19665>:
  D.19661 = 0;
  return D.19661;
  <D.19666>:
  D.19667 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.19667 == 0) goto <D.19668>; else goto <D.19669>;
  <D.19668>:
  D.19661 = 0;
  return D.19661;
  <D.19669>:
  D.19655 = BIT_FIELD_REF <*g1, 32, 96>;
  D.19656 = BIT_FIELD_REF <*g2, 32, 96>;
  D.19657 = D.19655 ^ D.19656;
  D.19670 = D.19657 & 2;
  D.19671 = D.19670 == 0;
  D.19661 = (gboolean) D.19671;
  return D.19661;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.19675;
  short unsigned int D.19676;
  short unsigned int D.19677;
  short unsigned int D.19680;
  short unsigned int D.19681;
  struct MonoGenericContainer * D.19686;
  struct MonoGenericContainer * D.19687;
  struct MonoImage * D.19691;
  struct MonoImage * D.19692;

  if (p1 == p2) goto <D.19673>; else goto <D.19674>;
  <D.19673>:
  D.19675 = 1;
  return D.19675;
  <D.19674>:
  D.19676 = p1->num;
  D.19677 = p2->num;
  if (D.19676 != D.19677) goto <D.19678>; else goto <D.19679>;
  <D.19678>:
  D.19675 = 0;
  return D.19675;
  <D.19679>:
  D.19680 = p1->serial;
  D.19681 = p2->serial;
  if (D.19680 != D.19681) goto <D.19682>; else goto <D.19683>;
  <D.19682>:
  D.19675 = 0;
  return D.19675;
  <D.19683>:
  D.19686 = p1->owner;
  D.19687 = p2->owner;
  if (D.19686 == D.19687) goto <D.19688>; else goto <D.19689>;
  <D.19688>:
  D.19686 = p1->owner;
  if (D.19686 != 0B) goto <D.19684>; else goto <D.19690>;
  <D.19690>:
  D.19691 = p1->image;
  D.19692 = p2->image;
  if (D.19691 == D.19692) goto <D.19684>; else goto <D.19685>;
  <D.19684>:
  D.19675 = 1;
  return D.19675;
  <D.19685>:
  <D.19689>:
  D.19675 = signature_only;
  return D.19675;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.19696;
  unsigned int D.19697;
  unsigned int D.19698;
  unsigned int D.19699;
  unsigned int D.19700;
  short int D.19703;
  short int D.19704;
  unsigned int D.19707;
  unsigned int D.19710;
  struct MonoType * D.19713;
  struct MonoType * D.19714;
  int D.19715;
  short unsigned int D.19718;
  short unsigned int D.19719;
  _Bool D.19725;
  int D.19726;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.19694>; else goto <D.19695>;
      <D.19694>:
      D.19696 = 1;
      return D.19696;
      <D.19695>:
      D.19697 = BIT_FIELD_REF <*s1, 32, 64>;
      D.19698 = BIT_FIELD_REF <*s2, 32, 64>;
      D.19699 = D.19697 ^ D.19698;
      D.19700 = D.19699 & 4128768;
      if (D.19700 != 0) goto <D.19701>; else goto <D.19702>;
      <D.19701>:
      D.19696 = 0;
      return D.19696;
      <D.19702>:
      D.19703 = s1->sentinelpos;
      D.19704 = s2->sentinelpos;
      if (D.19703 != D.19704) goto <D.19705>; else goto <D.19706>;
      <D.19705>:
      D.19696 = 0;
      return D.19696;
      <D.19706>:
      D.19697 = BIT_FIELD_REF <*s1, 32, 64>;
      D.19698 = BIT_FIELD_REF <*s2, 32, 64>;
      D.19699 = D.19697 ^ D.19698;
      D.19707 = D.19699 & 4194304;
      if (D.19707 != 0) goto <D.19708>; else goto <D.19709>;
      <D.19708>:
      D.19696 = 0;
      return D.19696;
      <D.19709>:
      D.19697 = BIT_FIELD_REF <*s1, 32, 64>;
      D.19698 = BIT_FIELD_REF <*s2, 32, 64>;
      D.19699 = D.19697 ^ D.19698;
      D.19710 = D.19699 & 8388608;
      if (D.19710 != 0) goto <D.19711>; else goto <D.19712>;
      <D.19711>:
      D.19696 = 0;
      return D.19696;
      <D.19712>:
      D.19713 = s1->ret;
      D.19714 = s2->ret;
      D.19715 = do_mono_metadata_type_equal (D.19713, D.19714, signature_only);
      if (D.19715 == 0) goto <D.19716>; else goto <D.19717>;
      <D.19716>:
      D.19696 = 0;
      return D.19696;
      <D.19717>:
      D.19718 = s1->param_count;
      D.19719 = s2->param_count;
      if (D.19718 != D.19719) goto <D.19720>; else goto <D.19721>;
      <D.19720>:
      D.19696 = 0;
      return D.19696;
      <D.19721>:
      <D.18408>:
      {
        struct MonoType * t1;
        struct MonoType * t2;

        t1 = mono_signature_get_params (s1, &iter1);
        t2 = mono_signature_get_params (s2, &iter2);
        if (t1 == 0B) goto <D.19722>; else goto <D.19724>;
        <D.19724>:
        if (t2 == 0B) goto <D.19722>; else goto <D.19723>;
        <D.19722>:
        D.19725 = t1 == t2;
        D.19696 = (gboolean) D.19725;
        return D.19696;
        <D.19723>:
        D.19726 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.19726 == 0) goto <D.19727>; else goto <D.19728>;
        <D.19727>:
        D.19696 = 0;
        return D.19696;
        <D.19728>:
      }
      goto <D.18408>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


mono_metadata_init ()
{
  struct GHashTable * type_cache.57;
  struct GHashTable * type_cache.58;
  const struct MonoType * D.19733;
  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.17355>;
  <D.17354>:
  type_cache.58 = type_cache;
  D.19733 = &builtin_types[i];
  D.19733 = &builtin_types[i];
  monoeg_g_hash_table_insert_replace (type_cache.58, D.19733, D.19733, 0);
  i = i + 1;
  <D.17355>:
  i.59 = (unsigned int) i;
  if (i.59 <= 33) goto <D.17354>; else goto <D.17356>;
  <D.17356>:
}


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.19737;
  unsigned char D.19738;
  unsigned int D.19740;
  unsigned int D.19741;
  unsigned int D.19742;
  unsigned int D.19743;
  short unsigned int D.19745;
  short unsigned int D.19746;
  signed int D.19748;
  gint D.19749;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.19737 = a->type;
  D.19738 = b->type;
  if (D.19737 != D.19738) goto <D.19735>; else goto <D.19739>;
  <D.19739>:
  D.19740 = BIT_FIELD_REF <*a, 32, 32>;
  D.19741 = BIT_FIELD_REF <*b, 32, 32>;
  D.19742 = D.19740 ^ D.19741;
  D.19743 = D.19742 & 1073741824;
  if (D.19743 != 0) goto <D.19735>; else goto <D.19744>;
  <D.19744>:
  D.19745 = a->attrs;
  D.19746 = b->attrs;
  if (D.19745 != D.19746) goto <D.19735>; else goto <D.19747>;
  <D.19747>:
  D.19740 = BIT_FIELD_REF <*a, 32, 32>;
  D.19741 = BIT_FIELD_REF <*b, 32, 32>;
  D.19742 = D.19740 ^ D.19741;
  D.19748 = (signed int) D.19742;
  if (D.19748 < 0) goto <D.19735>; else goto <D.19736>;
  <D.19735>:
  D.19749 = 0;
  return D.19749;
  <D.19736>:
  D.19749 = 1;
  return D.19749;
}


mono_type_hash (const void * data)
{
  unsigned char D.19751;
  guint D.19754;
  struct MonoGenericClass * D.19755;
  int D.19756;
  <unnamed-unsigned:1> D.19757;
  int D.19758;
  int D.19759;
  int D.19760;
  short unsigned int D.19761;
  int D.19762;
  int D.19763;
  int D.19764;
  const struct MonoType * type;

  type = data;
  D.19751 = type->type;
  if (D.19751 == 21) goto <D.19752>; else goto <D.19753>;
  <D.19752>:
  D.19755 = type->data.generic_class;
  D.19754 = mono_generic_class_hash (D.19755);
  return D.19754;
  <D.19753>:
  D.19751 = type->type;
  D.19756 = (int) D.19751;
  D.19757 = type->byref;
  D.19758 = (int) D.19757;
  D.19759 = D.19758 << 8;
  D.19760 = D.19756 | D.19759;
  D.19761 = type->attrs;
  D.19762 = (int) D.19761;
  D.19763 = D.19762 << 9;
  D.19764 = D.19760 | D.19763;
  D.19754 = (guint) D.19764;
  return D.19754;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.19766;
  struct MonoType * D.19767;
  <unnamed-unsigned:1> D.19768;
  unsigned int D.19769;
  const struct MonoGenericContext * D.19770;
  unsigned int D.19771;
  guint D.19772;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.19766 = gclass->container_class;
  D.19767 = &D.19766->byval_arg;
  hash = mono_metadata_type_hash (D.19767);
  hash = hash * 13;
  D.19768 = gclass->is_tb_open;
  D.19769 = (unsigned int) D.19768;
  hash = D.19769 + hash;
  D.19770 = &gclass->context;
  D.19771 = mono_metadata_generic_context_hash (D.19770);
  hash = D.19771 + hash;
  D.19772 = hash;
  return D.19772;
}


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.19776;
  int D.19777;

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


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.19781;
  int D.19782;
  const char * tmp_ptr.64;
  unsigned int count.65;
  unsigned int D.19787;
  unsigned int D.19788;
  void * iftmp.66;
  unsigned int size.67;
  unsigned int size.68;
  unsigned char D.19795;
  <unnamed-unsigned:6> D.19796;
  char D.19800;
  int D.19801;
  const char * ptr.69;
  struct MonoCustomMod * D.19803;
  short unsigned int opt_attrs.70;
  unsigned char D.19805;
  <unnamed-unsigned:1> D.19806;
  _Bool D.19807;
  int D.19808;
  struct MonoType * D.19811;
  unsigned int D.19814;
  unsigned int D.19815;
  unsigned char D.19820;
  unsigned char D.19821;
  unsigned int D.19824;
  struct MonoType * iftmp.71;
  unsigned int D.19828;
  struct MonoClass * D.19831;
  struct MonoClass * D.19833;
  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.17384>;
      <D.17383>:
      tmp_ptr.63 = tmp_ptr;
      D.19781 = *tmp_ptr.63;
      D.19782 = (int) D.19781;
      switch (D.19782) <default: <D.17382>, case 16: <D.17378>, case 31: <D.17380>, case 32: <D.17381>, case 69: <D.17377>>
      <D.17377>:
      <D.17378>:
      tmp_ptr.63 = tmp_ptr;
      tmp_ptr.64 = tmp_ptr.63 + 1;
      tmp_ptr = tmp_ptr.64;
      goto <D.17379>;
      <D.17380>:
      <D.17381>:
      count = count + 1;
      tmp_ptr.63 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.63, &tmp_ptr);
      goto <D.17379>;
      <D.17382>:
      found = 0;
      <D.17379>:
      <D.17384>:
      if (found != 0) goto <D.17383>; else goto <D.17385>;
      <D.17385>:
      if (count != 0) goto <D.19784>; else goto <D.19785>;
      <D.19784>:
      {
        int size;

        count.65 = (unsigned int) count;
        D.19787 = count.65 + 2;
        D.19788 = D.19787 * 4;
        size = (int) D.19788;
        if (transient != 0) goto <D.19790>; else goto <D.19791>;
        <D.19790>:
        size.67 = (unsigned int) size;
        iftmp.66 = monoeg_malloc0 (size.67);
        goto <D.19793>;
        <D.19791>:
        size.68 = (unsigned int) size;
        iftmp.66 = mono_image_alloc0 (m, size.68);
        <D.19793>:
        type = iftmp.66;
        D.19795 = (unsigned char) count;
        D.19796 = (<unnamed-unsigned:6>) D.19795;
        type->num_mods = D.19796;
        if (count > 64) goto <D.19797>; else goto <D.19798>;
        <D.19797>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.19798>:
      }
      goto <D.19799>;
      <D.19785>:
      type = &stype;
      memset (type, 0, 8);
      <D.19799>:
      found = 1;
      count = 0;
      goto <D.17394>;
      <D.17393>:
      ptr.62 = ptr;
      D.19800 = *ptr.62;
      D.19801 = (int) D.19800;
      switch (D.19801) <default: <D.17392>, case 16: <D.17389>, case 31: <D.17390>, case 32: <D.17391>, case 69: <D.17387>>
      <D.17387>:
      pinned = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.17388>;
      <D.17389>:
      byref = 1;
      ptr.62 = ptr;
      ptr.69 = ptr.62 + 1;
      ptr = ptr.69;
      goto <D.17388>;
      <D.17390>:
      <D.17391>:
      D.19803 = &type->modifiers[count];
      ptr.62 = ptr;
      mono_metadata_parse_custom_mod (m, D.19803, ptr.62, &ptr);
      count = count + 1;
      goto <D.17388>;
      <D.17392>:
      found = 0;
      <D.17388>:
      <D.17394>:
      if (found != 0) goto <D.17393>; else goto <D.17395>;
      <D.17395>:
      opt_attrs.70 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.70;
      D.19805 = (unsigned char) byref;
      D.19806 = (<unnamed-unsigned:1>) D.19805;
      type->byref = D.19806;
      D.19807 = pinned != 0;
      type->pinned = D.19807;
      ptr.62 = ptr;
      D.19808 = do_mono_metadata_parse_type (type, m, container, transient, ptr.62, &ptr);
      if (D.19808 == 0) goto <D.19809>; else goto <D.19810>;
      <D.19809>:
      D.19811 = 0B;
      return D.19811;
      <D.19810>:
      if (rptr != 0B) goto <D.19812>; else goto <D.19813>;
      <D.19812>:
      ptr.62 = ptr;
      *rptr = ptr.62;
      <D.19813>:
      D.19814 = BIT_FIELD_REF <*type, 32, 32>;
      D.19815 = D.19814 & 1056964608;
      if (D.19815 == 0) goto <D.19816>; else goto <D.19817>;
      <D.19816>:
      if (transient == 0) goto <D.19818>; else goto <D.19819>;
      <D.19818>:
      D.19820 = type->type;
      D.19821 = D.19820 + 239;
      if (D.19821 <= 1) goto <D.19822>; else goto <D.19823>;
      <D.19822>:
      D.19814 = BIT_FIELD_REF <*type, 32, 32>;
      D.19824 = D.19814 & 2147549183;
      if (D.19824 == 0) goto <D.19825>; else goto <D.19826>;
      <D.19825>:
      {
        struct MonoType * ret;

        D.19814 = BIT_FIELD_REF <*type, 32, 32>;
        D.19828 = D.19814 & 1073741824;
        if (D.19828 != 0) goto <D.19829>; else goto <D.19830>;
        <D.19829>:
        D.19831 = type->data.klass;
        iftmp.71 = &D.19831->this_arg;
        goto <D.19832>;
        <D.19830>:
        D.19831 = type->data.klass;
        iftmp.71 = &D.19831->byval_arg;
        <D.19832>:
        ret = iftmp.71;
        D.19833 = ret->data.klass;
        D.19831 = type->data.klass;
        if (D.19833 == D.19831) goto <D.19834>; else goto <D.19835>;
        <D.19834>:
        D.19811 = ret;
        return D.19811;
        <D.19835>:
      }
      <D.19826>:
      <D.19823>:
      type_cache.72 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.72, type);
      if (cached != 0B) goto <D.19837>; else goto <D.19838>;
      <D.19837>:
      D.19811 = cached;
      return D.19811;
      <D.19838>:
      <D.19819>:
      <D.19817>:
      if (&stype == type) goto <D.19839>; else goto <D.19840>;
      <D.19839>:
      if (transient != 0) goto <D.19842>; else goto <D.19843>;
      <D.19842>:
      iftmp.73 = monoeg_malloc (8);
      goto <D.19844>;
      <D.19843>:
      iftmp.73 = mono_image_alloc (m, 8);
      <D.19844>:
      type = iftmp.73;
      memcpy (type, &stype, 8);
      <D.19840>:
      D.19811 = type;
      return D.19811;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.19849;
  int D.19854;
  void * D.19856;
  unsigned int D.19857;

  D.19849 = __builtin_constant_p (__len);
  if (D.19849 != 0) goto <D.19850>; else goto <D.19851>;
  <D.19850>:
  if (__len == 0) goto <D.19852>; else goto <D.19853>;
  <D.19852>:
  D.19854 = __builtin_constant_p (__ch);
  if (D.19854 == 0) goto <D.19847>; else goto <D.19855>;
  <D.19855>:
  if (__ch != 0) goto <D.19847>; else goto <D.19848>;
  <D.19847>:
  __warn_memset_zero_len ();
  D.19856 = __dest;
  return D.19856;
  <D.19848>:
  <D.19853>:
  <D.19851>:
  D.19857 = __builtin_object_size (__dest, 0);
  D.19856 = __builtin___memset_chk (__dest, __ch, __len, D.19857);
  return D.19856;
}


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.19860;
  unsigned char D.19861;
  unsigned char D.19862;
  int D.19863;
  gboolean D.19866;
  unsigned char D.19867;
  int D.19868;
  int D.19869;
  struct MonoClass * D.19874;
  struct MonoClass * D.19875;
  struct MonoType * D.19878;
  struct MonoType * D.19879;
  struct MonoMethodSignature * D.19882;
  struct MonoMethodSignature * D.19883;
  struct MonoArrayType * D.19886;
  struct MonoArrayType * D.19887;
  unsigned int D.19892;
  unsigned int D.19893;
  <unnamed type> D.19896;
  struct MonoGenericParam * D.19897;
  struct MonoGenericParam * D.19898;
  char * D.19901;
  gboolean ok;

  ok = 1;
  ptr.74 = ptr;
  D.19860 = mono_metadata_decode_value (ptr.74, &ptr);
  D.19861 = (unsigned char) D.19860;
  type->type = D.19861;
  D.19862 = type->type;
  D.19863 = (int) D.19862;
  switch (D.19863) <default: <D.17948>, case 1: <D.17917>, case 2: <D.17918>, case 3: <D.17919>, case 4: <D.17920>, case 5: <D.17921>, case 6: <D.17922>, case 7: <D.17923>, case 8: <D.17924>, case 9: <D.17925>, case 10: <D.17926>, case 11: <D.17927>, case 12: <D.17928>, case 13: <D.17929>, case 14: <D.17932>, case 15: <D.17942>, case 17: <D.17936>, case 18: <D.17937>, case 19: <D.17946>, case 20: <D.17944>, case 21: <D.17947>, case 22: <D.17934>, case 24: <D.17930>, case 25: <D.17931>, case 27: <D.17943>, case 28: <D.17933>, case 29: <D.17940>, case 30: <D.17945>>
  <D.17917>:
  <D.17918>:
  <D.17919>:
  <D.17920>:
  <D.17921>:
  <D.17922>:
  <D.17923>:
  <D.17924>:
  <D.17925>:
  <D.17926>:
  <D.17927>:
  <D.17928>:
  <D.17929>:
  <D.17930>:
  <D.17931>:
  <D.17932>:
  <D.17933>:
  <D.17934>:
  goto <D.17935>;
  <D.17936>:
  <D.17937>:
  {
    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.19864>; else goto <D.19865>;
    <D.19864>:
    D.19866 = 0;
    return D.19866;
    <D.19865>:
    D.19867 = class->byval_arg.type;
    D.19868 = (int) D.19867;
    D.19862 = type->type;
    D.19863 = (int) D.19862;
    D.19869 = compare_type_literals (D.19868, D.19863);
    if (D.19869 == 0) goto <D.19870>; else goto <D.19871>;
    <D.19870>:
    D.19866 = 0;
    return D.19866;
    <D.19871>:
    goto <D.17935>;
  }
  <D.17940>:
  {
    struct MonoType * etype;

    ptr.74 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.74, &ptr);
    if (etype == 0B) goto <D.19872>; else goto <D.19873>;
    <D.19872>:
    D.19866 = 0;
    return D.19866;
    <D.19873>:
    D.19874 = mono_class_from_mono_type (etype);
    type->data.klass = D.19874;
    D.19875 = type->data.klass;
    if (D.19875 == 0B) goto <D.19876>; else goto <D.19877>;
    <D.19876>:
    D.19866 = 0;
    return D.19866;
    <D.19877>:
    goto <D.17935>;
  }
  <D.17942>:
  ptr.74 = ptr;
  D.19878 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.74, &ptr);
  type->data.type = D.19878;
  D.19879 = type->data.type;
  if (D.19879 == 0B) goto <D.19880>; else goto <D.19881>;
  <D.19880>:
  D.19866 = 0;
  return D.19866;
  <D.19881>:
  goto <D.17935>;
  <D.17943>:
  ptr.74 = ptr;
  D.19882 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.74, &ptr);
  type->data.method = D.19882;
  D.19883 = type->data.method;
  if (D.19883 == 0B) goto <D.19884>; else goto <D.19885>;
  <D.19884>:
  D.19866 = 0;
  return D.19866;
  <D.19885>:
  goto <D.17935>;
  <D.17944>:
  ptr.74 = ptr;
  D.19886 = mono_metadata_parse_array_internal (m, container, transient, ptr.74, &ptr);
  type->data.array = D.19886;
  D.19887 = type->data.array;
  if (D.19887 == 0B) goto <D.19888>; else goto <D.19889>;
  <D.19888>:
  D.19866 = 0;
  return D.19866;
  <D.19889>:
  goto <D.17935>;
  <D.17945>:
  if (container != 0B) goto <D.19890>; else goto <D.19891>;
  <D.19890>:
  D.19892 = BIT_FIELD_REF <*container, 32, 128>;
  D.19893 = D.19892 & 2147483648;
  if (D.19893 == 0) goto <D.19894>; else goto <D.19895>;
  <D.19894>:
  D.19866 = 0;
  return D.19866;
  <D.19895>:
  <D.19891>:
  <D.17946>:
  D.19862 = type->type;
  D.19896 = (<unnamed type>) D.19862;
  ptr.74 = ptr;
  D.19897 = mono_metadata_parse_generic_param (m, container, D.19896, ptr.74, &ptr);
  type->data.generic_param = D.19897;
  D.19898 = type->data.generic_param;
  if (D.19898 == 0B) goto <D.19899>; else goto <D.19900>;
  <D.19899>:
  D.19866 = 0;
  return D.19866;
  <D.19900>:
  goto <D.17935>;
  <D.17947>:
  ptr.74 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.74, &ptr);
  goto <D.17935>;
  <D.17948>:
  D.19862 = type->type;
  D.19863 = (int) D.19862;
  D.19901 = m->name;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.19863, D.19901);
  D.19866 = 0;
  return D.19866;
  <D.17935>:
  if (rptr != 0B) goto <D.19902>; else goto <D.19903>;
  <D.19902>:
  ptr.74 = ptr;
  *rptr = ptr.74;
  <D.19903>:
  D.19866 = ok;
  return D.19866;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.19908;
  _Bool D.19914;

  if (class_type == 0) goto <D.19906>; else goto <D.19907>;
  <D.19906>:
  D.19908 = 1;
  return D.19908;
  <D.19907>:
  if (type_type == 18) goto <D.19911>; else goto <D.19912>;
  <D.19911>:
  if (class_type == 14) goto <D.19909>; else goto <D.19913>;
  <D.19913>:
  if (class_type == 28) goto <D.19909>; else goto <D.19910>;
  <D.19909>:
  D.19908 = 1;
  return D.19908;
  <D.19910>:
  <D.19912>:
  D.19914 = class_type == type_type;
  D.19908 = (gboolean) D.19914;
  return D.19908;
}


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.19917;
  short unsigned int D.19922;
  struct MonoGenericParam * D.19923;
  <unnamed-signed:31> D.19924;
  int D.19925;
  struct MonoGenericParamFull * D.19928;
  unsigned int index.76;
  unsigned int D.19930;
  int index;

  ptr.75 = ptr;
  D.19917 = mono_metadata_decode_value (ptr.75, &ptr);
  index = (int) D.19917;
  if (rptr != 0B) goto <D.19918>; else goto <D.19919>;
  <D.19918>:
  ptr.75 = ptr;
  *rptr = ptr.75;
  <D.19919>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.19920>; else goto <D.19921>;
  <D.19920>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 12);
    D.19922 = (short unsigned int) index;
    param->num = D.19922;
    param->image = m;
    D.19923 = param;
    return D.19923;
  }
  <D.19921>:
  D.19924 = generic_container->type_argc;
  D.19925 = (int) D.19924;
  if (D.19925 <= index) goto <D.19926>; else goto <D.19927>;
  <D.19926>:
  D.19923 = 0B;
  return D.19923;
  <D.19927>:
  D.19928 = generic_container->type_params;
  index.76 = (unsigned int) index;
  D.19930 = index.76 * 32;
  D.19923 = D.19928 + D.19930;
  return D.19923;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.19932;
  struct MonoGenericContainer * D.19935;
  int iftmp.77;
  _Bool D.19941;
  long int D.19942;
  long int D.19943;
  unsigned int D.19950;
  unsigned int D.19951;
  struct MonoGenericContainer * D.19953;
  gboolean is_var;

  D.19932 = type == 19;
  is_var = (gboolean) D.19932;
  if (gc == 0B) goto <D.19933>; else goto <D.19934>;
  <D.19933>:
  D.19935 = 0B;
  return D.19935;
  <D.19934>:
  if (is_var == 0) goto <D.19939>; else goto <D.19937>;
  <D.19939>:
  if (type != 30) goto <D.19940>; else goto <D.19937>;
  <D.19940>:
  iftmp.77 = 1;
  goto <D.19938>;
  <D.19937>:
  iftmp.77 = 0;
  <D.19938>:
  D.19941 = iftmp.77 != 0;
  D.19942 = (long int) D.19941;
  D.19943 = __builtin_expect (D.19942, 0);
  if (D.19943 != 0) goto <D.19944>; else goto <D.19945>;
  <D.19944>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.19945>:
  if (is_var != 0) goto <D.19946>; else goto <D.19947>;
  <D.19946>:
  D.19950 = BIT_FIELD_REF <*gc, 32, 128>;
  D.19951 = D.19950 & 2147483648;
  if (D.19951 != 0) goto <D.19948>; else goto <D.19952>;
  <D.19952>:
  D.19953 = gc->parent;
  if (D.19953 != 0B) goto <D.19948>; else goto <D.19949>;
  <D.19948>:
  D.19935 = gc->parent;
  return D.19935;
  <D.19949>:
  <D.19947>:
  D.19935 = gc;
  return D.19935;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.78;
  gboolean D.19958;
  struct MonoGenericContainer * D.19959;
  unsigned int D.19962;
  struct MonoGenericClass * D.19967;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.78 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.78, &ptr);
  if (gtype == 0B) goto <D.19956>; else goto <D.19957>;
  <D.19956>:
  D.19958 = 0;
  return D.19958;
  <D.19957>:
  gklass = mono_class_from_mono_type (gtype);
  D.19959 = gklass->generic_container;
  if (D.19959 == 0B) goto <D.19960>; else goto <D.19961>;
  <D.19960>:
  D.19958 = 0;
  return D.19958;
  <D.19961>:
  ptr.78 = ptr;
  D.19962 = mono_metadata_decode_value (ptr.78, &ptr);
  count = (int) D.19962;
  ptr.78 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.78, &ptr);
  if (inst == 0B) goto <D.19963>; else goto <D.19964>;
  <D.19963>:
  D.19958 = 0;
  return D.19958;
  <D.19964>:
  if (rptr != 0B) goto <D.19965>; else goto <D.19966>;
  <D.19965>:
  ptr.78 = ptr;
  *rptr = ptr.78;
  <D.19966>:
  D.19967 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.19967;
  D.19958 = 1;
  return D.19958;
}


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

  D.19970 = __builtin_object_size (__dest, 0);
  D.19969 = __builtin___memcpy_chk (__dest, __src, __len, D.19970);
  return D.19969;
}


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

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


mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.19975;
  <unnamed-unsigned:24> D.19976;
  int D.19977;
  <unnamed-unsigned:24> D.19981;
  int D.19982;
  int D.19983;
  unsigned int D.19984;
  int D.19985;
  gboolean D.19988;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.19975 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.19975, 5);
  D.19976 = methodt->rows;
  D.19977 = (int) D.19976;
  if (D.19977 > def) goto <D.19978>; else goto <D.19979>;
  <D.19978>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.19980>;
  <D.19979>:
  D.19981 = m->tables[8].rows;
  D.19982 = (int) D.19981;
  D.19983 = D.19982 + 1;
  lastp = (guint) D.19983;
  <D.19980>:
  i = param_index;
  goto <D.17423>;
  <D.17422>:
  {
    guint32 flags;

    D.19984 = i + 4294967295;
    D.19985 = (int) D.19984;
    flags = mono_metadata_decode_row_col (paramt, D.19985, 0);
    if (flags != 0) goto <D.19986>; else goto <D.19987>;
    <D.19986>:
    D.19988 = 1;
    return D.19988;
    <D.19987>:
  }
  i = i + 1;
  <D.17423>:
  if (i < lastp) goto <D.17422>; else goto <D.17424>;
  <D.17424>:
  D.19988 = 0;
  return D.19988;
}


mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.19990;
  <unnamed-unsigned:24> D.19991;
  int D.19992;
  <unnamed-unsigned:24> D.19996;
  int D.19997;
  int D.19998;
  unsigned int D.19999;
  int D.20000;
  unsigned int D.20001;
  unsigned int param_count.79;
  unsigned int D.20007;
  unsigned int D.20008;
  unsigned int param_count.80;
  unsigned int D.20012;
  int * D.20013;
  int D.20014;
  int * D.20015;
  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.19990 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.19990, 5);
      pattrs = 0B;
      D.19991 = methodt->rows;
      D.19992 = (int) D.19991;
      if (D.19992 > def) goto <D.19993>; else goto <D.19994>;
      <D.19993>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.19995>;
      <D.19994>:
      D.19996 = paramt->rows;
      D.19997 = (int) D.19996;
      D.19998 = D.19997 + 1;
      lastp = (guint) D.19998;
      <D.19995>:
      i = param_index;
      goto <D.17439>;
      <D.17438>:
      D.19999 = i + 4294967295;
      D.20000 = (int) D.19999;
      mono_metadata_decode_row (paramt, D.20000, &cols, 3);
      D.20001 = cols[0];
      if (D.20001 != 0) goto <D.20002>; else goto <D.20003>;
      <D.20002>:
      if (pattrs == 0B) goto <D.20004>; else goto <D.20005>;
      <D.20004>:
      param_count.79 = (unsigned int) param_count;
      D.20007 = param_count.79 * 4;
      pattrs = monoeg_malloc0 (D.20007);
      <D.20005>:
      D.20008 = cols[1];
      param_count.80 = (unsigned int) param_count;
      if (D.20008 >= param_count.80) goto <D.20010>; else goto <D.20011>;
      <D.20010>:
      // predicted unlikely by continue predictor.
      goto <D.17437>;
      <D.20011>:
      D.20008 = cols[1];
      D.20012 = D.20008 * 4;
      D.20013 = pattrs + D.20012;
      D.20001 = cols[0];
      D.20014 = (int) D.20001;
      *D.20013 = D.20014;
      <D.20003>:
      <D.17437>:
      i = i + 1;
      <D.17439>:
      if (i < lastp) goto <D.17438>; else goto <D.17440>;
      <D.17440>:
      D.20015 = pattrs;
      return D.20015;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  unsigned int D.20018;
  unsigned int D.20019;
  struct MonoMethodSignature * D.20022;
  unsigned int D.20023;
  _Bool D.20024;
  long int D.20025;
  long int D.20026;
  const struct MonoTableInfo * D.20029;
  unsigned int D.20030;
  int D.20031;
  const char * ptr.81;
  const char * ptr.82;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.20018 = BIT_FIELD_REF <*image, 32, 128>;
      D.20019 = D.20018 & 8;
      if (D.20019 != 0) goto <D.20020>; else goto <D.20021>;
      <D.20020>:
      D.20022 = mono_lookup_dynamic_token (image, token, 0B);
      return D.20022;
      <D.20021>:
      D.20023 = token >> 24;
      D.20024 = D.20023 != 17;
      D.20025 = (long int) D.20024;
      D.20026 = __builtin_expect (D.20025, 0);
      if (D.20026 != 0) goto <D.20027>; else goto <D.20028>;
      <D.20027>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.20028>:
      D.20029 = tables + 204;
      D.20030 = idx + 4294967295;
      D.20031 = (int) D.20030;
      sig = mono_metadata_decode_row_col (D.20029, D.20031, 0);
      ptr.81 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.81;
      ptr.82 = ptr;
      mono_metadata_decode_blob_size (ptr.82, &ptr);
      ptr.82 = ptr;
      D.20022 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.82, 0B);
      return D.20022;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  unsigned int D.20038;
  unsigned int D.20039;
  short unsigned int D.20040;
  struct MonoMethodSignature * D.20041;
  struct MonoMethodSignature * sig;

  D.20038 = nparams + 3;
  D.20039 = D.20038 * 4;
  sig = mono_image_alloc0 (m, D.20039);
  D.20040 = (short unsigned int) nparams;
  sig->param_count = D.20040;
  sig->sentinelpos = -1;
  D.20041 = sig;
  return D.20041;
}


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

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


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.20045;
  unsigned int D.20046;
  unsigned int D.20047;
  unsigned int D.20048;
  unsigned int sigsize.83;
  unsigned int sigsize.84;
  unsigned int sigsize.85;
  unsigned int sigsize.86;
  struct MonoMethodSignature * D.20059;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.20045 = sig->param_count;
  D.20046 = (unsigned int) D.20045;
  D.20047 = D.20046 + 3;
  D.20048 = D.20047 * 4;
  sigsize = (int) D.20048;
  if (image != 0B) goto <D.20049>; else goto <D.20050>;
  <D.20049>:
  sigsize.83 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.83);
  goto <D.20052>;
  <D.20050>:
  if (mp != 0B) goto <D.20053>; else goto <D.20054>;
  <D.20053>:
  sigsize.84 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.84);
  goto <D.20056>;
  <D.20054>:
  sigsize.85 = (unsigned int) sigsize;
  ret = monoeg_malloc (sigsize.85);
  <D.20056>:
  <D.20052>:
  sigsize.86 = (unsigned int) sigsize;
  memcpy (ret, sig, sigsize.86);
  D.20059 = ret;
  return D.20059;
}


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

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


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

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


mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.20065;
  short unsigned int D.20066;
  unsigned int D.20067;
  unsigned int D.20068;

  D.20066 = sig->param_count;
  D.20067 = (unsigned int) D.20066;
  D.20068 = D.20067 + 3;
  D.20065 = D.20068 * 4;
  return D.20065;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.87;
  char D.20071;
  unsigned char D.20072;
  int D.20073;
  int D.20074;
  int D.20077;
  int D.20080;
  unsigned int D.20083;
  const char * ptr.88;
  unsigned int D.20089;
  int D.20090;
  unsigned char D.20091;
  <unnamed-unsigned:1> D.20092;
  unsigned char D.20093;
  <unnamed-unsigned:1> D.20094;
  unsigned char D.20095;
  <unnamed-unsigned:6> D.20096;
  short unsigned int D.20097;
  int iftmp.89;
  int D.20103;
  short int D.20104;
  struct MonoType * D.20106;
  struct MonoType * D.20107;
  struct MonoMethodSignature * D.20110;
  unsigned int D.20115;
  unsigned int D.20116;
  char * D.20118;
  short int D.20119;
  short int D.20122;
  int iftmp.90;
  sizetype i.91;
  sizetype D.20127;
  sizetype D.20128;
  int * D.20129;
  int D.20130;
  short int D.20131;
  struct MonoType * D.20133;
  struct MonoType * D.20134;
  short unsigned int D.20139;
  int D.20140;
  short int D.20147;
  unsigned char D.20148;
  <unnamed-unsigned:1> D.20149;
  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.87 = ptr;
  D.20071 = *ptr.87;
  D.20072 = (unsigned char) D.20071;
  D.20073 = (int) D.20072;
  D.20074 = D.20073 & 16;
  if (D.20074 != 0) goto <D.20075>; else goto <D.20076>;
  <D.20075>:
  gen_param_count = 1;
  <D.20076>:
  ptr.87 = ptr;
  D.20071 = *ptr.87;
  D.20072 = (unsigned char) D.20071;
  D.20073 = (int) D.20072;
  D.20077 = D.20073 & 32;
  if (D.20077 != 0) goto <D.20078>; else goto <D.20079>;
  <D.20078>:
  hasthis = 1;
  <D.20079>:
  ptr.87 = ptr;
  D.20071 = *ptr.87;
  D.20072 = (unsigned char) D.20071;
  D.20073 = (int) D.20072;
  D.20080 = D.20073 & 64;
  if (D.20080 != 0) goto <D.20081>; else goto <D.20082>;
  <D.20081>:
  explicit_this = 1;
  <D.20082>:
  ptr.87 = ptr;
  D.20071 = *ptr.87;
  D.20072 = (unsigned char) D.20071;
  D.20083 = (unsigned int) D.20072;
  call_convention = D.20083 & 15;
  ptr.87 = ptr;
  ptr.88 = ptr.87 + 1;
  ptr = ptr.88;
  if (gen_param_count != 0) goto <D.20085>; else goto <D.20086>;
  <D.20085>:
  ptr.87 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.87, &ptr);
  <D.20086>:
  ptr.87 = ptr;
  param_count = mono_metadata_decode_value (ptr.87, &ptr);
  if (def != 0) goto <D.20087>; else goto <D.20088>;
  <D.20087>:
  D.20089 = param_count + 1;
  D.20090 = (int) D.20089;
  pattrs = mono_metadata_get_param_attrs (m, def, D.20090);
  <D.20088>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.20091 = (unsigned char) hasthis;
  D.20092 = (<unnamed-unsigned:1>) D.20091;
  method->hasthis = D.20092;
  D.20093 = (unsigned char) explicit_this;
  D.20094 = (<unnamed-unsigned:1>) D.20093;
  method->explicit_this = D.20094;
  D.20095 = (unsigned char) call_convention;
  D.20096 = (<unnamed-unsigned:6>) D.20095;
  method->call_convention = D.20096;
  D.20097 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.20097;
  if (call_convention != 10) goto <D.20098>; else goto <D.20099>;
  <D.20098>:
  if (pattrs != 0B) goto <D.20101>; else goto <D.20102>;
  <D.20101>:
  D.20103 = *pattrs;
  D.20104 = (short int) D.20103;
  iftmp.89 = (int) D.20104;
  goto <D.20105>;
  <D.20102>:
  iftmp.89 = 0;
  <D.20105>:
  ptr.87 = ptr;
  D.20106 = mono_metadata_parse_type_full (m, container, 4, iftmp.89, ptr.87, &ptr);
  method->ret = D.20106;
  D.20107 = method->ret;
  if (D.20107 == 0B) goto <D.20108>; else goto <D.20109>;
  <D.20108>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20110 = 0B;
  return D.20110;
  <D.20109>:
  D.20107 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.20107);
  <D.20099>:
  i = 0;
  goto <D.17497>;
  <D.17496>:
  ptr.87 = ptr;
  D.20071 = *ptr.87;
  if (D.20071 == 65) goto <D.20111>; else goto <D.20112>;
  <D.20111>:
  D.20115 = BIT_FIELD_REF <*method, 32, 64>;
  D.20116 = D.20115 & 4128768;
  if (D.20116 != 327680) goto <D.20113>; else goto <D.20117>;
  <D.20117>:
  if (def != 0) goto <D.20113>; else goto <D.20114>;
  <D.20113>:
  D.20118 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.20118);
  monoeg_g_free (pattrs);
  D.20110 = 0B;
  return D.20110;
  <D.20114>:
  D.20119 = method->sentinelpos;
  if (D.20119 >= 0) goto <D.20120>; else goto <D.20121>;
  <D.20120>:
  D.20118 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.20118);
  monoeg_g_free (pattrs);
  D.20110 = 0B;
  return D.20110;
  <D.20121>:
  D.20122 = (short int) i;
  method->sentinelpos = D.20122;
  ptr.87 = ptr;
  ptr.88 = ptr.87 + 1;
  ptr = ptr.88;
  <D.20112>:
  if (pattrs != 0B) goto <D.20124>; else goto <D.20125>;
  <D.20124>:
  i.91 = (sizetype) i;
  D.20127 = i.91 + 1;
  D.20128 = D.20127 * 4;
  D.20129 = pattrs + D.20128;
  D.20130 = *D.20129;
  D.20131 = (short int) D.20130;
  iftmp.90 = (int) D.20131;
  goto <D.20132>;
  <D.20125>:
  iftmp.90 = 0;
  <D.20132>:
  ptr.87 = ptr;
  D.20133 = mono_metadata_parse_type_full (m, container, 3, iftmp.90, ptr.87, &ptr);
  method->params[i] = D.20133;
  D.20134 = method->params[i];
  if (D.20134 == 0B) goto <D.20135>; else goto <D.20136>;
  <D.20135>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.20110 = 0B;
  return D.20110;
  <D.20136>:
  if (is_open == 0) goto <D.20137>; else goto <D.20138>;
  <D.20137>:
  D.20134 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.20134);
  <D.20138>:
  i = i + 1;
  <D.17497>:
  D.20139 = method->param_count;
  D.20140 = (int) D.20139;
  if (D.20140 > i) goto <D.17496>; else goto <D.17498>;
  <D.17498>:
  if (def == 0) goto <D.20141>; else goto <D.20142>;
  <D.20141>:
  D.20115 = BIT_FIELD_REF <*method, 32, 64>;
  D.20116 = D.20115 & 4128768;
  if (D.20116 == 327680) goto <D.20143>; else goto <D.20144>;
  <D.20143>:
  D.20119 = method->sentinelpos;
  if (D.20119 < 0) goto <D.20145>; else goto <D.20146>;
  <D.20145>:
  D.20139 = method->param_count;
  D.20147 = (short int) D.20139;
  method->sentinelpos = D.20147;
  <D.20146>:
  <D.20144>:
  <D.20142>:
  D.20148 = (unsigned char) is_open;
  D.20149 = (<unnamed-unsigned:1>) D.20148;
  method->has_type_parameters = D.20149;
  if (def != 0) goto <D.20150>; else goto <D.20151>;
  <D.20150>:
  D.20115 = BIT_FIELD_REF <*method, 32, 64>;
  D.20116 = D.20115 & 4128768;
  if (D.20116 == 327680) goto <D.20152>; else goto <D.20153>;
  <D.20152>:
  D.20139 = method->param_count;
  D.20147 = (short int) D.20139;
  method->sentinelpos = D.20147;
  <D.20153>:
  <D.20151>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.20154>; else goto <D.20155>;
  <D.20154>:
  ptr.87 = ptr;
  *rptr = ptr.87;
  <D.20155>:
  D.20110 = method;
  return D.20110;
}


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

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


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.20159;
  struct MonoType * D.20162;
  short unsigned int D.20165;
  int D.20166;
  int i;

  D.20159 = sig->ret;
  if (D.20159 != 0B) goto <D.20160>; else goto <D.20161>;
  <D.20160>:
  D.20159 = sig->ret;
  mono_metadata_free_type (D.20159);
  <D.20161>:
  i = 0;
  goto <D.17513>;
  <D.17512>:
  D.20162 = sig->params[i];
  if (D.20162 != 0B) goto <D.20163>; else goto <D.20164>;
  <D.20163>:
  D.20162 = sig->params[i];
  mono_metadata_free_type (D.20162);
  <D.20164>:
  i = i + 1;
  <D.17513>:
  D.20165 = sig->param_count;
  D.20166 = (int) D.20165;
  if (D.20166 > i) goto <D.17512>; else goto <D.17514>;
  <D.17514>:
  monoeg_g_free (sig);
}


mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20167;
  struct MonoMemPool * D.20170;
  void * D.20171;
  void * res;

  mono_image_set_lock (set);
  D.20167 = set->mempool;
  if (D.20167 == 0B) goto <D.20168>; else goto <D.20169>;
  <D.20168>:
  D.20170 = mono_mempool_new_size (1024);
  set->mempool = D.20170;
  <D.20169>:
  D.20167 = set->mempool;
  res = mono_mempool_alloc (D.20167, size);
  mono_image_set_unlock (set);
  D.20171 = res;
  return D.20171;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20173;
  _Bool D.20176;
  long int D.20177;
  long int D.20178;

  {
    int ret;

    D.20173 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.20173);
    if (ret != 0) goto <D.20174>; else goto <D.20175>;
    <D.20174>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20175>:
    D.20176 = ret != 0;
    D.20177 = (long int) D.20176;
    D.20178 = __builtin_expect (D.20177, 0);
    if (D.20178 != 0) goto <D.20179>; else goto <D.20180>;
    <D.20179>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.20180>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.20181;
  _Bool D.20184;
  long int D.20185;
  long int D.20186;

  {
    int ret;

    D.20181 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.20181);
    if (ret != 0) goto <D.20182>; else goto <D.20183>;
    <D.20182>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20183>:
    D.20184 = ret != 0;
    D.20185 = (long int) D.20184;
    D.20186 = __builtin_expect (D.20185, 0);
    if (D.20186 != 0) goto <D.20187>; else goto <D.20188>;
    <D.20187>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.20188>:
  }
}


mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.20189;
  struct MonoMemPool * D.20192;
  void * D.20193;
  void * res;

  mono_image_set_lock (set);
  D.20189 = set->mempool;
  if (D.20189 == 0B) goto <D.20190>; else goto <D.20191>;
  <D.20190>:
  D.20192 = mono_mempool_new_size (1024);
  set->mempool = D.20192;
  <D.20191>:
  D.20189 = set->mempool;
  res = mono_mempool_alloc0 (D.20189, size);
  mono_image_set_unlock (set);
  D.20193 = res;
  return D.20193;
}


mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.20195;
  struct MonoMemPool * D.20198;
  char * D.20199;
  char * res;

  mono_image_set_lock (set);
  D.20195 = set->mempool;
  if (D.20195 == 0B) goto <D.20196>; else goto <D.20197>;
  <D.20196>:
  D.20198 = mono_mempool_new_size (1024);
  set->mempool = D.20198;
  <D.20197>:
  D.20195 = set->mempool;
  res = mono_mempool_strdup (D.20195, s);
  mono_image_set_unlock (set);
  D.20199 = res;
  return D.20199;
}


mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.20201;
  struct GSList * D.20202;
  struct GHashTable * D.20203;
  struct GHashTable * D.20204;
  struct GHashTable * D.20205;
  struct GHashTable * D.20206;
  void * D.20207;
  struct GSList * D.20208;
  struct GSList * D.20209;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.20201 = gclass_data.image;
      ginst_data.image = D.20201;
      gclass_data.list = 0B;
      D.20202 = gclass_data.list;
      ginst_data.list = D.20202;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.17761>;
      <D.17760>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.20203 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.20203, steal_gclass_in_image, &gclass_data);
        D.20204 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.20204, steal_ginst_in_image, &ginst_data);
        D.20205 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.20205, inflated_method_in_image, image);
        D.20206 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.20206, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.17761>:
      if (l != 0B) goto <D.17760>; else goto <D.17762>;
      <D.17762>:
      l = ginst_data.list;
      goto <D.17764>;
      <D.17763>:
      D.20207 = l->data;
      free_generic_inst (D.20207);
      l = l->next;
      <D.17764>:
      if (l != 0B) goto <D.17763>; else goto <D.17765>;
      <D.17765>:
      l = gclass_data.list;
      goto <D.17767>;
      <D.17766>:
      D.20207 = l->data;
      free_generic_class (D.20207);
      l = l->next;
      <D.17767>:
      if (l != 0B) goto <D.17766>; else goto <D.17768>;
      <D.17768>:
      D.20208 = ginst_data.list;
      monoeg_g_slist_free (D.20208);
      D.20202 = gclass_data.list;
      monoeg_g_slist_free (D.20202);
      D.20209 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.20209);
      l = set_list;
      goto <D.17771>;
      <D.17770>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.17771>:
      if (l != 0B) goto <D.17770>; else goto <D.17772>;
      <D.17772>:
      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.20210;
  int iftmp.92;
  struct MonoMethodSignature * D.20216;
  int D.20217;
  struct MonoGenericInst * D.20219;
  int D.20221;
  struct MonoGenericInst * D.20222;
  int D.20224;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.20216 = sig->sig;
  D.20217 = signature_in_image (D.20216, image);
  if (D.20217 != 0) goto <D.20212>; else goto <D.20218>;
  <D.20218>:
  D.20219 = sig->context.class_inst;
  if (D.20219 != 0B) goto <D.20220>; else goto <D.20213>;
  <D.20220>:
  D.20219 = sig->context.class_inst;
  D.20221 = ginst_in_image (D.20219, image);
  if (D.20221 != 0) goto <D.20212>; else goto <D.20213>;
  <D.20213>:
  D.20222 = sig->context.method_inst;
  if (D.20222 != 0B) goto <D.20223>; else goto <D.20214>;
  <D.20223>:
  D.20222 = sig->context.method_inst;
  D.20224 = ginst_in_image (D.20222, image);
  if (D.20224 != 0) goto <D.20212>; else goto <D.20214>;
  <D.20212>:
  iftmp.92 = 1;
  goto <D.20215>;
  <D.20214>:
  iftmp.92 = 0;
  <D.20215>:
  D.20210 = iftmp.92;
  return D.20210;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.20226;
  gboolean D.20229;
  struct MonoType * D.20230;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.17545>;
      <D.17544>:
      D.20226 = type_in_image (p, image);
      if (D.20226 != 0) goto <D.20227>; else goto <D.20228>;
      <D.20227>:
      D.20229 = 1;
      return D.20229;
      <D.20228>:
      <D.17545>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.17544>; else goto <D.17546>;
      <D.17546>:
      D.20230 = mono_signature_get_return_type (sig);
      D.20229 = type_in_image (D.20230, image);
      return D.20229;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.20233;
  int D.20234;
  gboolean D.20235;
  struct MonoGenericClass * D.20236;
  struct MonoClass * D.20237;
  struct MonoArrayType * D.20238;
  struct MonoClass * D.20239;
  struct MonoMethodSignature * D.20240;
  struct MonoGenericParam * D.20241;
  unsigned int D.20244;
  signed int D.20245;
  _Bool D.20246;
  long int D.20247;
  long int D.20248;
  struct MonoClass * D.20251;
  struct MonoImage * D.20254;
  _Bool D.20255;
  struct MonoImage * D.20256;
  _Bool D.20257;
  struct MonoImage * D.20258;
  _Bool D.20259;
  unsigned int D.20264;
  signed int D.20265;
  _Bool D.20266;
  long int D.20267;
  long int D.20268;
  struct MonoMethod * D.20271;
  struct MonoImage * D.20274;
  _Bool D.20275;
  struct MonoClass * D.20276;
  struct MonoImage * D.20277;
  _Bool D.20278;
  struct MonoClass * D.20279;
  struct MonoImage * D.20280;
  _Bool D.20281;
  void retry = <<< error >>>;

  retry:
  D.20233 = type->type;
  D.20234 = (int) D.20233;
  switch (D.20234) <default: <D.17573>, case 15: <D.17565>, case 19: <D.17569>, case 20: <D.17567>, case 21: <D.17564>, case 27: <D.17568>, case 29: <D.17566>, case 30: <D.17571>>
  <D.17564>:
  D.20236 = type->data.generic_class;
  D.20235 = gclass_in_image (D.20236, image);
  return D.20235;
  <D.17565>:
  type = type->data.type;
  goto retry;
  <D.17566>:
  D.20237 = type->data.klass;
  type = &D.20237->byval_arg;
  goto retry;
  <D.17567>:
  D.20238 = type->data.array;
  D.20239 = D.20238->eklass;
  type = &D.20239->byval_arg;
  goto retry;
  <D.17568>:
  D.20240 = type->data.method;
  D.20235 = signature_in_image (D.20240, image);
  return D.20235;
  <D.17569>:
  {
    struct MonoGenericContainer * container;

    D.20241 = type->data.generic_param;
    container = D.20241->owner;
    if (container != 0B) goto <D.20242>; else goto <D.20243>;
    <D.20242>:
    D.20244 = BIT_FIELD_REF <*container, 32, 128>;
    D.20245 = (signed int) D.20244;
    D.20246 = D.20245 < 0;
    D.20247 = (long int) D.20246;
    D.20248 = __builtin_expect (D.20247, 0);
    if (D.20248 != 0) goto <D.20249>; else goto <D.20250>;
    <D.20249>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.20250>:
    D.20251 = container->owner.klass;
    if (D.20251 == 0B) goto <D.20252>; else goto <D.20253>;
    <D.20252>:
    D.20254 = container->image;
    D.20255 = D.20254 == image;
    D.20235 = (gboolean) D.20255;
    return D.20235;
    <D.20253>:
    D.20251 = container->owner.klass;
    D.20256 = D.20251->image;
    D.20257 = D.20256 == image;
    D.20235 = (gboolean) D.20257;
    return D.20235;
    <D.20243>:
    D.20241 = type->data.generic_param;
    D.20258 = D.20241->image;
    D.20259 = D.20258 == image;
    D.20235 = (gboolean) D.20259;
    return D.20235;
  }
  <D.17571>:
  {
    struct MonoGenericContainer * container;

    D.20241 = type->data.generic_param;
    container = D.20241->owner;
    D.20241 = type->data.generic_param;
    D.20258 = D.20241->image;
    if (D.20258 == image) goto <D.20260>; else goto <D.20261>;
    <D.20260>:
    D.20235 = 1;
    return D.20235;
    <D.20261>:
    if (container != 0B) goto <D.20262>; else goto <D.20263>;
    <D.20262>:
    D.20264 = BIT_FIELD_REF <*container, 32, 128>;
    D.20265 = (signed int) D.20264;
    D.20266 = D.20265 >= 0;
    D.20267 = (long int) D.20266;
    D.20268 = __builtin_expect (D.20267, 0);
    if (D.20268 != 0) goto <D.20269>; else goto <D.20270>;
    <D.20269>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.20270>:
    D.20271 = container->owner.method;
    if (D.20271 == 0B) goto <D.20272>; else goto <D.20273>;
    <D.20272>:
    D.20274 = container->image;
    D.20275 = D.20274 == image;
    D.20235 = (gboolean) D.20275;
    return D.20235;
    <D.20273>:
    D.20271 = container->owner.method;
    D.20276 = D.20271->klass;
    D.20277 = D.20276->image;
    D.20278 = D.20277 == image;
    D.20235 = (gboolean) D.20278;
    return D.20235;
    <D.20263>:
    D.20241 = type->data.generic_param;
    D.20258 = D.20241->image;
    D.20259 = D.20258 == image;
    D.20235 = (gboolean) D.20259;
    return D.20235;
  }
  <D.17573>:
  D.20279 = mono_class_from_mono_type (type);
  D.20280 = D.20279->image;
  D.20281 = D.20280 == image;
  D.20235 = (gboolean) D.20281;
  return D.20235;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.20283;
  int iftmp.93;
  struct MonoClass * D.20288;
  struct MonoImage * D.20289;
  struct MonoGenericInst * D.20291;
  int D.20292;

  D.20288 = gclass->container_class;
  D.20289 = D.20288->image;
  if (D.20289 == image) goto <D.20285>; else goto <D.20290>;
  <D.20290>:
  D.20291 = gclass->context.class_inst;
  D.20292 = ginst_in_image (D.20291, image);
  if (D.20292 != 0) goto <D.20285>; else goto <D.20286>;
  <D.20285>:
  iftmp.93 = 1;
  goto <D.20287>;
  <D.20286>:
  iftmp.93 = 0;
  <D.20287>:
  D.20283 = iftmp.93;
  return D.20283;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.20294;
  int D.20295;
  gboolean D.20298;
  <unnamed-unsigned:22> D.20299;
  int D.20300;
  int i;

  i = 0;
  goto <D.17553>;
  <D.17552>:
  D.20294 = ginst->type_argv[i];
  D.20295 = type_in_image (D.20294, image);
  if (D.20295 != 0) goto <D.20296>; else goto <D.20297>;
  <D.20296>:
  D.20298 = 1;
  return D.20298;
  <D.20297>:
  i = i + 1;
  <D.17553>:
  D.20299 = ginst->type_argc;
  D.20300 = (int) D.20299;
  if (D.20300 > i) goto <D.17552>; else goto <D.17554>;
  <D.17554>:
  D.20298 = 0;
  return D.20298;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.94;
  struct MonoMethod * D.20308;
  struct MonoClass * D.20309;
  struct MonoImage * D.20310;
  struct MonoGenericInst * D.20312;
  int D.20314;
  struct MonoGenericInst * D.20315;
  int D.20317;
  struct MonoMethodSignature * D.20318;
  struct MonoMethodSignature * D.20320;
  int D.20321;
  _Bool D.20322;
  long int D.20323;
  long int D.20324;
  gboolean D.20327;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.20308 = method->declaring;
  D.20309 = D.20308->klass;
  D.20310 = D.20309->image;
  if (D.20310 != image) goto <D.20311>; else goto <D.20303>;
  <D.20311>:
  D.20312 = method->context.class_inst;
  if (D.20312 == 0B) goto <D.20304>; else goto <D.20313>;
  <D.20313>:
  D.20312 = method->context.class_inst;
  D.20314 = ginst_in_image (D.20312, image);
  if (D.20314 == 0) goto <D.20304>; else goto <D.20303>;
  <D.20304>:
  D.20315 = method->context.method_inst;
  if (D.20315 == 0B) goto <D.20305>; else goto <D.20316>;
  <D.20316>:
  D.20315 = method->context.method_inst;
  D.20317 = ginst_in_image (D.20315, image);
  if (D.20317 == 0) goto <D.20305>; else goto <D.20303>;
  <D.20305>:
  D.20318 = MEM[(struct MonoMethod *)method].signature;
  if (D.20318 == 0B) goto <D.20306>; else goto <D.20319>;
  <D.20319>:
  D.20320 = mono_method_signature (method);
  D.20321 = signature_in_image (D.20320, image);
  if (D.20321 == 0) goto <D.20306>; else goto <D.20303>;
  <D.20306>:
  iftmp.94 = 1;
  goto <D.20307>;
  <D.20303>:
  iftmp.94 = 0;
  <D.20307>:
  D.20322 = iftmp.94 != 0;
  D.20323 = (long int) D.20322;
  D.20324 = __builtin_expect (D.20323, 0);
  if (D.20324 != 0) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  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.20326>:
  D.20327 = 1;
  return D.20327;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.20329;
  struct GSList * D.20330;
  gboolean D.20331;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.20329 = user_data->list;
  D.20330 = monoeg_g_slist_prepend (D.20329, ginst);
  user_data->list = D.20330;
  D.20331 = 1;
  return D.20331;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.20333;
  int D.20334;
  _Bool D.20335;
  long int D.20336;
  long int D.20337;
  struct GSList * D.20340;
  struct GSList * D.20341;
  gboolean D.20342;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.20333 = user_data->image;
  D.20334 = gclass_in_image (gclass, D.20333);
  D.20335 = D.20334 == 0;
  D.20336 = (long int) D.20335;
  D.20337 = __builtin_expect (D.20336, 0);
  if (D.20337 != 0) goto <D.20338>; else goto <D.20339>;
  <D.20338>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.20339>:
  D.20340 = user_data->list;
  D.20341 = monoeg_g_slist_prepend (D.20340, gclass);
  user_data->list = D.20341;
  D.20342 = 1;
  return D.20342;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.20344;
  <unnamed-unsigned:22> D.20345;
  int D.20346;
  int i;

  i = 0;
  goto <D.17787>;
  <D.17786>:
  D.20344 = ginst->type_argv[i];
  mono_metadata_free_type (D.20344);
  i = i + 1;
  <D.17787>:
  D.20345 = ginst->type_argc;
  D.20346 = (int) D.20345;
  if (D.20346 > i) goto <D.17786>; else goto <D.17788>;
  <D.17788>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  unsigned int D.20347;
  unsigned int D.20348;
  struct MonoClass * D.20351;
  short unsigned int D.20354;

  D.20347 = BIT_FIELD_REF <*gclass, 32, 96>;
  D.20348 = D.20347 & 1;
  if (D.20348 != 0) goto <D.20349>; else goto <D.20350>;
  <D.20349>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.20350>:
  D.20351 = gclass->cached_class;
  if (D.20351 != 0B) goto <D.20352>; else goto <D.20353>;
  <D.20352>:
  D.20351 = gclass->cached_class;
  D.20354 = D.20351->interface_id;
  if (D.20354 != 0) goto <D.20355>; else goto <D.20356>;
  <D.20355>:
  D.20351 = gclass->cached_class;
  mono_unload_interface_id (D.20351);
  <D.20356>:
  <D.20353>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.20357;
  struct GHashTable * D.20358;
  struct GHashTable * D.20359;
  struct GHashTable * D.20360;
  struct MonoImage * * D.20361;
  unsigned int i.95;
  unsigned int D.20363;
  struct MonoImage * * D.20364;
  struct MonoImage * D.20365;
  struct GSList * D.20366;
  struct GSList * D.20367;
  int D.20368;
  struct GPtrArray * image_sets.96;
  struct MonoMemPool * D.20370;
  struct CRITICAL_SECTION * D.20373;
  int i;

  D.20357 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.20357);
  D.20358 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.20358);
  D.20359 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.20359);
  D.20360 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.20360);
  i = 0;
  goto <D.17603>;
  <D.17602>:
  D.20361 = set->images;
  i.95 = (unsigned int) i;
  D.20363 = i.95 * 4;
  D.20364 = D.20361 + D.20363;
  D.20365 = *D.20364;
  D.20361 = set->images;
  i.95 = (unsigned int) i;
  D.20363 = i.95 * 4;
  D.20364 = D.20361 + D.20363;
  D.20365 = *D.20364;
  D.20366 = D.20365->image_sets;
  D.20367 = monoeg_g_slist_remove (D.20366, set);
  D.20365->image_sets = D.20367;
  i = i + 1;
  <D.17603>:
  D.20368 = set->nimages;
  if (D.20368 > i) goto <D.17602>; else goto <D.17604>;
  <D.17604>:
  image_sets.96 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.96, set);
  D.20370 = set->mempool;
  if (D.20370 != 0B) goto <D.20371>; else goto <D.20372>;
  <D.20371>:
  D.20370 = set->mempool;
  mono_mempool_destroy (D.20370);
  <D.20372>:
  D.20361 = set->images;
  monoeg_g_free (D.20361);
  D.20373 = &set->lock;
  DeleteCriticalSection (D.20373);
  monoeg_g_free (set);
}


mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  struct MonoImage * * D.20374;
  int D.20375;
  struct GHashTable * D.20378;
  struct MonoMethodInflated * D.20379;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.20374 = data.images;
      D.20375 = data.nimages;
      set = get_image_set (D.20374, D.20375);
      collect_data_free (&data);
      if (cache != 0) goto <D.20376>; else goto <D.20377>;
      <D.20376>:
      D.20378 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.20378, method, method, 0);
      D.20379 = method;
      return D.20379;
      <D.20377>:
      D.20378 = set->gmethod_cache;
      D.20379 = monoeg_g_hash_table_lookup (D.20378, method);
      return D.20379;
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.20383;
  struct MonoClass * D.20384;
  struct MonoImage * D.20385;
  struct MonoGenericInst * D.20386;
  struct MonoGenericInst * D.20389;
  struct MonoClass * D.20392;
  struct MonoImage * D.20393;
  unsigned int D.20394;
  unsigned int D.20395;
  struct MonoMethodSignature * D.20398;
  struct MonoMethod * m;

  m = method->declaring;
  D.20383 = method->declaring;
  D.20384 = D.20383->klass;
  D.20385 = D.20384->image;
  add_image (D.20385, data);
  D.20386 = method->context.class_inst;
  if (D.20386 != 0B) goto <D.20387>; else goto <D.20388>;
  <D.20387>:
  D.20386 = method->context.class_inst;
  collect_ginst_images (D.20386, data);
  <D.20388>:
  D.20389 = method->context.method_inst;
  if (D.20389 != 0B) goto <D.20390>; else goto <D.20391>;
  <D.20390>:
  D.20389 = method->context.method_inst;
  collect_ginst_images (D.20389, data);
  <D.20391>:
  D.20392 = m->klass;
  D.20393 = D.20392->image;
  D.20394 = BIT_FIELD_REF <*D.20393, 32, 128>;
  D.20395 = D.20394 & 8;
  if (D.20395 != 0) goto <D.20396>; else goto <D.20397>;
  <D.20396>:
  D.20398 = mono_method_signature (m);
  collect_signature_images (D.20398, data);
  <D.20397>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.20399;
  unsigned int i.97;
  unsigned int D.20401;
  struct MonoImage * * D.20402;
  struct MonoImage * D.20403;
  int D.20406;
  int D.20407;
  int D.20410;
  int D.20411;
  unsigned int D.20412;
  unsigned int D.20413;
  struct MonoImage * * D.20414;
  int i;

  i = 0;
  goto <D.17651>;
  <D.17650>:
  D.20399 = data->images;
  i.97 = (unsigned int) i;
  D.20401 = i.97 * 4;
  D.20402 = D.20399 + D.20401;
  D.20403 = *D.20402;
  if (D.20403 == image) goto <D.20404>; else goto <D.20405>;
  <D.20404>:
  return;
  <D.20405>:
  i = i + 1;
  <D.17651>:
  D.20406 = data->nimages;
  if (D.20406 > i) goto <D.17650>; else goto <D.17652>;
  <D.17652>:
  D.20406 = data->nimages;
  D.20407 = data->images_len;
  if (D.20406 == D.20407) goto <D.20408>; else goto <D.20409>;
  <D.20408>:
  enlarge_data (data);
  <D.20409>:
  D.20399 = data->images;
  D.20406 = data->nimages;
  D.20410 = D.20406;
  D.20411 = D.20410 + 1;
  data->nimages = D.20411;
  D.20412 = (unsigned int) D.20410;
  D.20413 = D.20412 * 4;
  D.20414 = D.20399 + D.20413;
  *D.20414 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.98;
  int D.20417;
  unsigned int new_len.99;
  unsigned int D.20422;
  struct MonoImage * * D.20423;
  unsigned int D.20424;
  struct MonoImage *[64] * D.20425;
  int new_len;
  struct MonoImage * * d;

  D.20417 = data->images_len;
  if (D.20417 > 15) goto <D.20418>; else goto <D.20419>;
  <D.20418>:
  D.20417 = data->images_len;
  iftmp.98 = D.20417 * 2;
  goto <D.20420>;
  <D.20419>:
  iftmp.98 = 16;
  <D.20420>:
  new_len = iftmp.98;
  new_len.99 = (unsigned int) new_len;
  D.20422 = new_len.99 * 4;
  d = monoeg_malloc (D.20422);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.20423 = data->images;
  D.20417 = data->images_len;
  D.20424 = (unsigned int) D.20417;
  memcpy (d, D.20423, D.20424);
  D.20423 = data->images;
  D.20425 = &data->image_buf;
  if (D.20423 != D.20425) goto <D.20426>; else goto <D.20427>;
  <D.20426>:
  D.20423 = data->images;
  monoeg_g_free (D.20423);
  <D.20427>:
  data->images = d;
  data->images_len = new_len;
}


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

  i = 0;
  goto <D.17662>;
  <D.17661>:
  D.20428 = ginst->type_argv[i];
  collect_type_images (D.20428, data);
  i = i + 1;
  <D.17662>:
  D.20429 = ginst->type_argc;
  D.20430 = (int) D.20429;
  if (D.20430 > i) goto <D.17661>; else goto <D.17663>;
  <D.17663>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.20431;
  int D.20432;
  struct MonoGenericClass * D.20433;
  struct MonoClass * D.20434;
  struct MonoArrayType * D.20435;
  struct MonoClass * D.20436;
  struct MonoGenericParam * D.20437;
  unsigned int D.20440;
  signed int D.20441;
  _Bool D.20442;
  long int D.20443;
  long int D.20444;
  struct MonoClass * D.20447;
  struct MonoImage * D.20450;
  struct MonoImage * D.20452;
  struct MonoImage * D.20454;
  struct MonoMethod * D.20459;
  struct MonoImage * D.20462;
  unsigned int D.20464;
  signed int D.20465;
  _Bool D.20466;
  long int D.20467;
  long int D.20468;
  struct MonoClass * D.20471;
  struct MonoImage * D.20472;
  struct MonoClass * D.20474;
  struct MonoImage * D.20475;
  struct MonoImage * D.20476;
  void retry = <<< error >>>;

  retry:
  D.20431 = type->type;
  D.20432 = (int) D.20431;
  switch (D.20432) <default: <D.17703>, case 15: <D.17693>, case 17: <D.17702>, case 18: <D.17701>, case 19: <D.17697>, case 20: <D.17695>, case 21: <D.17691>, case 27: <D.17696>, case 29: <D.17694>, case 30: <D.17699>>
  <D.17691>:
  D.20433 = type->data.generic_class;
  collect_gclass_images (D.20433, data);
  goto <D.17692>;
  <D.17693>:
  type = type->data.type;
  goto retry;
  <D.17694>:
  D.20434 = type->data.klass;
  type = &D.20434->byval_arg;
  goto retry;
  <D.17695>:
  D.20435 = type->data.array;
  D.20436 = D.20435->eklass;
  type = &D.20436->byval_arg;
  goto retry;
  <D.17696>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.17697>:
  {
    struct MonoGenericContainer * container;

    D.20437 = type->data.generic_param;
    container = D.20437->owner;
    if (container != 0B) goto <D.20438>; else goto <D.20439>;
    <D.20438>:
    D.20440 = BIT_FIELD_REF <*container, 32, 128>;
    D.20441 = (signed int) D.20440;
    D.20442 = D.20441 < 0;
    D.20443 = (long int) D.20442;
    D.20444 = __builtin_expect (D.20443, 0);
    if (D.20444 != 0) goto <D.20445>; else goto <D.20446>;
    <D.20445>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.20446>:
    D.20447 = container->owner.klass;
    if (D.20447 == 0B) goto <D.20448>; else goto <D.20449>;
    <D.20448>:
    D.20450 = container->image;
    add_image (D.20450, data);
    goto <D.20451>;
    <D.20449>:
    D.20447 = container->owner.klass;
    D.20452 = D.20447->image;
    add_image (D.20452, data);
    <D.20451>:
    goto <D.20453>;
    <D.20439>:
    D.20437 = type->data.generic_param;
    D.20454 = D.20437->image;
    add_image (D.20454, data);
    <D.20453>:
  }
  goto <D.17692>;
  <D.17699>:
  {
    struct MonoGenericContainer * container;

    D.20437 = type->data.generic_param;
    container = D.20437->owner;
    D.20437 = type->data.generic_param;
    D.20454 = D.20437->image;
    if (D.20454 != 0B) goto <D.20455>; else goto <D.20456>;
    <D.20455>:
    D.20437 = type->data.generic_param;
    D.20454 = D.20437->image;
    add_image (D.20454, data);
    <D.20456>:
    if (container != 0B) goto <D.20457>; else goto <D.20458>;
    <D.20457>:
    D.20459 = container->owner.method;
    if (D.20459 == 0B) goto <D.20460>; else goto <D.20461>;
    <D.20460>:
    D.20462 = container->image;
    add_image (D.20462, data);
    goto <D.20463>;
    <D.20461>:
    D.20464 = BIT_FIELD_REF <*container, 32, 128>;
    D.20465 = (signed int) D.20464;
    D.20466 = D.20465 >= 0;
    D.20467 = (long int) D.20466;
    D.20468 = __builtin_expect (D.20467, 0);
    if (D.20468 != 0) goto <D.20469>; else goto <D.20470>;
    <D.20469>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.20470>:
    D.20459 = container->owner.method;
    D.20471 = D.20459->klass;
    D.20472 = D.20471->image;
    add_image (D.20472, data);
    <D.20463>:
    goto <D.20473>;
    <D.20458>:
    D.20437 = type->data.generic_param;
    D.20454 = D.20437->image;
    add_image (D.20454, data);
    <D.20473>:
  }
  goto <D.17692>;
  <D.17701>:
  <D.17702>:
  D.20474 = mono_class_from_mono_type (type);
  D.20475 = D.20474->image;
  add_image (D.20475, data);
  goto <D.17692>;
  <D.17703>:
  D.20476 = mono_defaults.corlib;
  add_image (D.20476, data);
  <D.17692>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.20477;
  struct MonoImage * D.20478;
  struct MonoGenericInst * D.20479;

  D.20477 = gclass->container_class;
  D.20478 = D.20477->image;
  add_image (D.20478, data);
  D.20479 = gclass->context.class_inst;
  if (D.20479 != 0B) goto <D.20480>; else goto <D.20481>;
  <D.20480>:
  D.20479 = gclass->context.class_inst;
  collect_ginst_images (D.20479, data);
  <D.20481>:
}


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

  try
    {
      iter = 0B;
      D.20482 = mono_signature_get_return_type (sig);
      collect_type_images (D.20482, data);
      goto <D.17675>;
      <D.17674>:
      collect_type_images (p, data);
      <D.17675>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.17674>; else goto <D.17676>;
      <D.17676>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.100;
  struct GPtrArray * image_sets.101;
  struct MonoImage * D.20489;
  struct MonoImage * D.20490;
  struct MonoImageSet * mscorlib_image_set.102;
  struct MonoImageSet * D.20496;
  struct MonoImage * * D.20503;
  struct MonoImage * D.20504;
  int D.20505;
  struct MonoImage * * D.20508;
  unsigned int k.103;
  unsigned int D.20510;
  struct MonoImage * * D.20511;
  struct MonoImage * D.20512;
  unsigned int j.104;
  unsigned int D.20514;
  struct MonoImage * * D.20515;
  struct MonoImage * D.20516;
  unsigned int nimages.105;
  unsigned int D.20523;
  void * D.20524;
  struct CRITICAL_SECTION * D.20525;
  unsigned int i.106;
  unsigned int D.20527;
  struct MonoImage * * D.20528;
  struct MonoImage * * D.20529;
  struct MonoImage * D.20530;
  struct GHashTable * D.20531;
  struct GHashTable * D.20532;
  struct GHashTable * D.20533;
  struct GHashTable * D.20534;
  struct MonoImage * D.20535;
  struct GSList * D.20536;
  struct GSList * D.20537;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.100 = image_sets;
  if (image_sets.100 == 0B) goto <D.20484>; else goto <D.20485>;
  <D.20484>:
  image_sets.101 = monoeg_g_ptr_array_new ();
  image_sets = image_sets.101;
  <D.20485>:
  if (nimages == 1) goto <D.20487>; else goto <D.20488>;
  <D.20487>:
  D.20489 = *images;
  D.20490 = mono_defaults.corlib;
  if (D.20489 == D.20490) goto <D.20491>; else goto <D.20492>;
  <D.20491>:
  mscorlib_image_set.102 = mscorlib_image_set;
  if (mscorlib_image_set.102 != 0B) goto <D.20494>; else goto <D.20495>;
  <D.20494>:
  D.20496 = mscorlib_image_set;
  return D.20496;
  <D.20495>:
  <D.20492>:
  <D.20488>:
  if (nimages == 0) goto <D.20497>; else goto <D.20498>;
  <D.20497>:
  D.20496 = mscorlib_image_set;
  return D.20496;
  <D.20498>:
  D.20489 = *images;
  D.20490 = mono_defaults.corlib;
  if (D.20489 == D.20490) goto <D.20501>; else goto <D.20499>;
  <D.20501>:
  if (nimages > 1) goto <D.20502>; else goto <D.20499>;
  <D.20502>:
  D.20503 = images + 4;
  D.20504 = *D.20503;
  l = D.20504->image_sets;
  goto <D.20500>;
  <D.20499>:
  D.20489 = *images;
  l = D.20489->image_sets;
  <D.20500>:
  set = 0B;
  goto <D.17591>;
  <D.17590>:
  set = l->data;
  D.20505 = set->nimages;
  if (D.20505 == nimages) goto <D.20506>; else goto <D.20507>;
  <D.20506>:
  j = 0;
  goto <D.17588>;
  <D.17587>:
  k = 0;
  goto <D.17585>;
  <D.17584>:
  D.20508 = set->images;
  k.103 = (unsigned int) k;
  D.20510 = k.103 * 4;
  D.20511 = D.20508 + D.20510;
  D.20512 = *D.20511;
  j.104 = (unsigned int) j;
  D.20514 = j.104 * 4;
  D.20515 = images + D.20514;
  D.20516 = *D.20515;
  if (D.20512 == D.20516) goto <D.17583>; else goto <D.20517>;
  <D.20517>:
  k = k + 1;
  <D.17585>:
  if (k < nimages) goto <D.17584>; else goto <D.17583>;
  <D.17583>:
  if (k == nimages) goto <D.17586>; else goto <D.20518>;
  <D.20518>:
  j = j + 1;
  <D.17588>:
  if (j < nimages) goto <D.17587>; else goto <D.17586>;
  <D.17586>:
  if (j == nimages) goto <D.17589>; else goto <D.20519>;
  <D.20519>:
  <D.20507>:
  l = l->next;
  <D.17591>:
  if (l != 0B) goto <D.17590>; else goto <D.17589>;
  <D.17589>:
  if (l == 0B) goto <D.20520>; else goto <D.20521>;
  <D.20520>:
  set = monoeg_malloc0 (56);
  set->nimages = nimages;
  nimages.105 = (unsigned int) nimages;
  D.20523 = nimages.105 * 4;
  D.20524 = monoeg_malloc0 (D.20523);
  set->images = D.20524;
  D.20525 = &set->lock;
  InitializeCriticalSection (D.20525);
  i = 0;
  goto <D.17593>;
  <D.17592>:
  D.20508 = set->images;
  i.106 = (unsigned int) i;
  D.20527 = i.106 * 4;
  D.20528 = D.20508 + D.20527;
  i.106 = (unsigned int) i;
  D.20527 = i.106 * 4;
  D.20529 = images + D.20527;
  D.20530 = *D.20529;
  *D.20528 = D.20530;
  i = i + 1;
  <D.17593>:
  if (i < nimages) goto <D.17592>; else goto <D.17594>;
  <D.17594>:
  D.20531 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.20531;
  D.20532 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.20532;
  D.20533 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.20533;
  D.20534 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.20534;
  i = 0;
  goto <D.17596>;
  <D.17595>:
  D.20508 = set->images;
  i.106 = (unsigned int) i;
  D.20527 = i.106 * 4;
  D.20528 = D.20508 + D.20527;
  D.20535 = *D.20528;
  D.20508 = set->images;
  i.106 = (unsigned int) i;
  D.20527 = i.106 * 4;
  D.20528 = D.20508 + D.20527;
  D.20535 = *D.20528;
  D.20536 = D.20535->image_sets;
  D.20537 = monoeg_g_slist_prepend (D.20536, set);
  D.20535->image_sets = D.20537;
  i = i + 1;
  <D.17596>:
  if (i < nimages) goto <D.17595>; else goto <D.17597>;
  <D.17597>:
  image_sets.100 = image_sets;
  monoeg_g_ptr_array_add (image_sets.100, set);
  <D.20521>:
  if (nimages == 1) goto <D.20538>; else goto <D.20539>;
  <D.20538>:
  D.20489 = *images;
  D.20490 = mono_defaults.corlib;
  if (D.20489 == D.20490) goto <D.20540>; else goto <D.20541>;
  <D.20540>:
  mscorlib_image_set = set;
  <D.20541>:
  <D.20539>:
  D.20496 = set;
  return D.20496;
}


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

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


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.20544;
  struct MonoMethodSignature * D.20545;
  gboolean D.20548;
  const struct MonoGenericContext * D.20549;
  const struct MonoGenericContext * D.20550;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.20544 = sig1->sig;
  D.20545 = sig2->sig;
  if (D.20544 != D.20545) goto <D.20546>; else goto <D.20547>;
  <D.20546>:
  D.20548 = 0;
  return D.20548;
  <D.20547>:
  D.20549 = &sig1->context;
  D.20550 = &sig2->context;
  D.20548 = mono_metadata_generic_context_equal (D.20549, D.20550);
  return D.20548;
}


inflated_signature_hash (const void * a)
{
  guint D.20552;
  const struct MonoGenericContext * D.20553;
  unsigned int D.20554;
  struct MonoMethodSignature * D.20555;
  unsigned int D.20556;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.20553 = &sig->context;
  D.20554 = mono_metadata_generic_context_hash (D.20553);
  D.20555 = sig->sig;
  D.20556 = mono_aligned_addr_hash (D.20555);
  D.20552 = D.20554 ^ D.20556;
  return D.20552;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.20558;
  short unsigned int D.20561;
  int D.20562;
  int D.20563;
  short unsigned int D.20566;
  unsigned int D.20567;
  unsigned int D.20568;
  int D.20571;
  struct MonoType * D.20576;
  short unsigned int D.20577;
  int D.20578;
  struct MonoExceptionClause * D.20579;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.20558 = method->signature;
  if (D.20558 != 0B) goto <D.20559>; else goto <D.20560>;
  <D.20559>:
  D.20558 = method->signature;
  mono_metadata_free_inflated_signature (D.20558);
  <D.20560>:
  D.20561 = method->flags;
  D.20562 = (int) D.20561;
  D.20563 = D.20562 & 1024;
  if (D.20563 == 0) goto <D.20564>; else goto <D.20565>;
  <D.20564>:
  D.20566 = method->iflags;
  D.20567 = (unsigned int) D.20566;
  D.20568 = D.20567 & 4099;
  if (D.20568 == 0) goto <D.20569>; else goto <D.20570>;
  <D.20569>:
  D.20561 = method->flags;
  D.20562 = (int) D.20561;
  D.20571 = D.20562 & 8192;
  if (D.20571 == 0) goto <D.20572>; else goto <D.20573>;
  <D.20572>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.20574>; else goto <D.20575>;
    <D.20574>:
    i = 0;
    goto <D.17780>;
    <D.17779>:
    D.20576 = header->locals[i];
    mono_metadata_free_type (D.20576);
    i = i + 1;
    <D.17780>:
    D.20577 = header->num_locals;
    D.20578 = (int) D.20577;
    if (D.20578 > i) goto <D.17779>; else goto <D.17781>;
    <D.17781>:
    D.20579 = header->clauses;
    monoeg_g_free (D.20579);
    monoeg_g_free (header);
    <D.20575>:
  }
  <D.20573>:
  <D.20570>:
  <D.20565>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.20580;
  struct MonoMethod * D.20581;
  gboolean D.20584;
  unsigned int D.20585;
  unsigned int D.20586;
  unsigned int D.20587;
  unsigned int D.20588;
  const struct MonoGenericContext * D.20591;
  const struct MonoGenericContext * D.20592;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.20580 = ma->declaring;
  D.20581 = mb->declaring;
  if (D.20580 != D.20581) goto <D.20582>; else goto <D.20583>;
  <D.20582>:
  D.20584 = 0;
  return D.20584;
  <D.20583>:
  D.20585 = BIT_FIELD_REF <*ma, 32, 160>;
  D.20586 = BIT_FIELD_REF <*mb, 32, 160>;
  D.20587 = D.20585 ^ D.20586;
  D.20588 = D.20587 & 32768;
  if (D.20588 != 0) goto <D.20589>; else goto <D.20590>;
  <D.20589>:
  D.20584 = 0;
  return D.20584;
  <D.20590>:
  D.20591 = &ma->context;
  D.20592 = &mb->context;
  D.20584 = mono_metadata_generic_context_equal (D.20591, D.20592);
  return D.20584;
}


inflated_method_hash (const void * a)
{
  guint D.20594;
  const struct MonoGenericContext * D.20595;
  unsigned int D.20596;
  struct MonoMethod * D.20597;
  unsigned int D.20598;
  unsigned int D.20599;
  <unnamed-unsigned:1> D.20600;
  unsigned int D.20601;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.20595 = &ma->context;
  D.20596 = mono_metadata_generic_context_hash (D.20595);
  D.20597 = ma->declaring;
  D.20598 = mono_aligned_addr_hash (D.20597);
  D.20599 = D.20596 ^ D.20598;
  D.20600 = ma->method.method.is_mb_open;
  D.20601 = (unsigned int) D.20600;
  D.20594 = D.20599 + D.20601;
  return D.20594;
}


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

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


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.20605;
  struct MonoImage *[64] * D.20606;

  D.20605 = data->images;
  D.20606 = &data->image_buf;
  if (D.20605 != D.20606) goto <D.20607>; else goto <D.20608>;
  <D.20607>:
  D.20605 = data->images;
  monoeg_g_free (D.20605);
  <D.20608>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.20609;
  struct MonoGenericInst * D.20610;
  struct MonoImage * * D.20611;
  int D.20612;
  struct GHashTable * D.20613;
  struct MonoMethodSignature * D.20616;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.20609 = context->class_inst;
      helper.context.class_inst = D.20609;
      D.20610 = context->method_inst;
      helper.context.method_inst = D.20610;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.20611 = data.images;
      D.20612 = data.nimages;
      set = get_image_set (D.20611, D.20612);
      collect_data_free (&data);
      D.20613 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.20613, &helper);
      if (res == 0B) goto <D.20614>; else goto <D.20615>;
      <D.20614>:
      res = monoeg_malloc0 (12);
      res->sig = sig;
      D.20609 = context->class_inst;
      res->context.class_inst = D.20609;
      D.20610 = context->method_inst;
      res->context.method_inst = D.20610;
      D.20613 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.20613, res, res, 0);
      <D.20615>:
      mono_loader_unlock ();
      D.20616 = res->sig;
      return D.20616;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.20619;
  struct MonoGenericInst * D.20620;
  struct MonoGenericInst * D.20623;

  D.20619 = sig->sig;
  collect_signature_images (D.20619, data);
  D.20620 = sig->context.class_inst;
  if (D.20620 != 0B) goto <D.20621>; else goto <D.20622>;
  <D.20621>:
  D.20620 = sig->context.class_inst;
  collect_ginst_images (D.20620, data);
  <D.20622>:
  D.20623 = sig->context.method_inst;
  if (D.20623 != 0B) goto <D.20624>; else goto <D.20625>;
  <D.20624>:
  D.20623 = sig->context.method_inst;
  collect_ginst_images (D.20623, data);
  <D.20625>:
}


mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  unsigned int type_argc.107;
  unsigned int D.20627;
  unsigned int D.20628;
  unsigned int i.108;
  unsigned int D.20630;
  struct MonoType * * D.20631;
  struct MonoType * D.20632;
  int D.20633;
  _Bool D.20635;
  unsigned int size.109;
  unsigned char D.20637;
  <unnamed-unsigned:1> D.20638;
  <unnamed-unsigned:22> D.20639;
  struct MonoType *[0:] * D.20640;
  unsigned int D.20641;
  struct MonoImage * * D.20642;
  int D.20643;
  struct GHashTable * D.20644;
  unsigned int size.110;
  int next_generic_inst_id.111;
  int next_generic_inst_id.112;
  unsigned int next_generic_inst_id.113;
  struct MonoType * D.20651;
  struct MonoGenericInst * D.20652;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      type_argc.107 = (unsigned int) type_argc;
      D.20627 = type_argc.107 + 2;
      D.20628 = D.20627 * 4;
      size = (int) D.20628;
      i = 0;
      goto <D.17821>;
      <D.17820>:
      i.108 = (unsigned int) i;
      D.20630 = i.108 * 4;
      D.20631 = type_argv + D.20630;
      D.20632 = *D.20631;
      D.20633 = mono_class_is_open_constructed_type (D.20632);
      if (D.20633 != 0) goto <D.17819>; else goto <D.20634>;
      <D.20634>:
      i = i + 1;
      <D.17821>:
      if (i < type_argc) goto <D.17820>; else goto <D.17819>;
      <D.17819>:
      D.20635 = i < type_argc;
      is_open = (gboolean) D.20635;
      size.109 = (unsigned int) size;
      ginst = __builtin_alloca (size.109);
      memset (ginst, 0, 8);
      D.20637 = (unsigned char) is_open;
      D.20638 = (<unnamed-unsigned:1>) D.20637;
      ginst->is_open = D.20638;
      type_argc.107 = (unsigned int) type_argc;
      D.20639 = (<unnamed-unsigned:22>) type_argc.107;
      ginst->type_argc = D.20639;
      D.20640 = &ginst->type_argv;
      type_argc.107 = (unsigned int) type_argc;
      D.20641 = type_argc.107 * 4;
      memcpy (D.20640, type_argv, D.20641);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.20642 = data.images;
      D.20643 = data.nimages;
      set = get_image_set (D.20642, D.20643);
      collect_data_free (&data);
      D.20644 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.20644, ginst);
      if (ginst == 0B) goto <D.20645>; else goto <D.20646>;
      <D.20645>:
      size.110 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.110);
      next_generic_inst_id.111 = next_generic_inst_id;
      next_generic_inst_id.112 = next_generic_inst_id.111 + 1;
      next_generic_inst_id = next_generic_inst_id.112;
      next_generic_inst_id.111 = next_generic_inst_id;
      next_generic_inst_id.113 = (unsigned int) next_generic_inst_id.111;
      ginst->id = next_generic_inst_id.113;
      D.20637 = (unsigned char) is_open;
      D.20638 = (<unnamed-unsigned:1>) D.20637;
      ginst->is_open = D.20638;
      type_argc.107 = (unsigned int) type_argc;
      D.20639 = (<unnamed-unsigned:22>) type_argc.107;
      ginst->type_argc = D.20639;
      i = 0;
      goto <D.17823>;
      <D.17822>:
      i.108 = (unsigned int) i;
      D.20630 = i.108 * 4;
      D.20631 = type_argv + D.20630;
      D.20632 = *D.20631;
      D.20651 = mono_metadata_type_dup (0B, D.20632);
      ginst->type_argv[i] = D.20651;
      i = i + 1;
      <D.17823>:
      if (i < type_argc) goto <D.17822>; else goto <D.17824>;
      <D.17824>:
      D.20644 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.20644, ginst, ginst, 0);
      <D.20646>:
      mono_loader_unlock ();
      D.20652 = ginst;
      return D.20652;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.20655;
  <unnamed-unsigned:1> D.20656;
  unsigned char D.20657;
  <unnamed-unsigned:1> D.20658;
  struct MonoImage * * D.20659;
  int D.20660;
  struct GHashTable * D.20661;
  struct MonoClass * D.20662;
  _Bool D.20663;
  long int D.20664;
  long int D.20665;
  struct MonoGenericClass * D.20670;
  struct MonoGenericContainer * D.20674;
  struct MonoGenericInst * D.20675;
  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.20655 = (unsigned char) is_dynamic;
      D.20656 = (<unnamed-unsigned:1>) D.20655;
      helper.is_dynamic = D.20656;
      D.20657 = (unsigned char) is_tb_open;
      D.20658 = (<unnamed-unsigned:1>) D.20657;
      helper.is_tb_open = D.20658;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.20659 = data.images;
      D.20660 = data.nimages;
      set = get_image_set (D.20659, D.20660);
      collect_data_free (&data);
      D.20661 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.20661, &helper);
      D.20662 = helper.cached_class;
      D.20663 = D.20662 != 0B;
      D.20664 = (long int) D.20663;
      D.20665 = __builtin_expect (D.20664, 0);
      if (D.20665 != 0) goto <D.20666>; else goto <D.20667>;
      <D.20666>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.20667>:
      if (gclass != 0B) goto <D.20668>; else goto <D.20669>;
      <D.20668>:
      mono_loader_unlock ();
      D.20670 = gclass;
      return D.20670;
      <D.20669>:
      if (is_dynamic != 0) goto <D.20671>; else goto <D.20672>;
      <D.20671>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 44);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.20673>;
      <D.20672>:
      gclass = mono_image_set_alloc0 (set, 24);
      <D.20673>:
      D.20657 = (unsigned char) is_tb_open;
      D.20658 = (<unnamed-unsigned:1>) D.20657;
      gclass->is_tb_open = D.20658;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.20674 = container_class->generic_container;
      D.20675 = D.20674->context.class_inst;
      if (D.20675 == inst) goto <D.20676>; else goto <D.20677>;
      <D.20676>:
      if (is_tb_open == 0) goto <D.20678>; else goto <D.20679>;
      <D.20678>:
      gclass->cached_class = container_class;
      <D.20679>:
      <D.20677>:
      D.20661 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.20661, gclass, gclass, 0);
      mono_loader_unlock ();
      D.20670 = gclass;
      return D.20670;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_metadata_is_type_builder_generic_type_definition (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned int D.20685;
  unsigned int D.20686;
  <unnamed-signed:31> D.20688;
  int D.20689;
  <unnamed-unsigned:22> D.20690;
  int D.20691;
  gboolean D.20692;
  struct MonoGenericInst * D.20693;
  _Bool D.20694;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.20682>; else goto <D.20684>;
  <D.20684>:
  D.20685 = BIT_FIELD_REF <*container_class, 32, 160>;
  D.20686 = D.20685 & 128;
  if (D.20686 != 0) goto <D.20682>; else goto <D.20687>;
  <D.20687>:
  D.20688 = container->type_argc;
  D.20689 = (int) D.20688;
  D.20690 = inst->type_argc;
  D.20691 = (int) D.20690;
  if (D.20689 != D.20691) goto <D.20682>; else goto <D.20683>;
  <D.20682>:
  D.20692 = 0;
  return D.20692;
  <D.20683>:
  D.20693 = container->context.class_inst;
  D.20694 = D.20693 == inst;
  D.20692 = (gboolean) D.20694;
  return D.20692;
}


mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned int D.20696;
  unsigned int D.20697;
  struct MonoGenericInst * D.20700;
  <unnamed-unsigned:22> D.20701;
  unsigned int D.20702;
  unsigned int D.20703;
  unsigned int i.114;
  unsigned int D.20705;
  struct MonoType * * D.20706;
  struct MonoType * D.20707;
  struct MonoType * D.20708;
  int D.20709;
  int D.20711;
  struct MonoType * D.20712;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.20696 = BIT_FIELD_REF <*ginst, 32, 32>;
  D.20697 = D.20696 & 4194304;
  if (D.20697 == 0) goto <D.20698>; else goto <D.20699>;
  <D.20698>:
  D.20700 = ginst;
  return D.20700;
  <D.20699>:
  D.20701 = ginst->type_argc;
  D.20702 = (unsigned int) D.20701;
  D.20703 = D.20702 * 4;
  type_argv = monoeg_malloc0 (D.20703);
  i = 0;
  goto <D.17853>;
  <D.17852>:
  i.114 = (unsigned int) i;
  D.20705 = i.114 * 4;
  D.20706 = type_argv + D.20705;
  D.20707 = ginst->type_argv[i];
  D.20708 = mono_class_inflate_generic_type_checked (D.20707, context, error);
  *D.20706 = D.20708;
  D.20709 = mono_error_ok (error);
  if (D.20709 == 0) goto cleanup; else goto <D.20710>;
  <D.20710>:
  count = count + 1;
  i = i + 1;
  <D.17853>:
  D.20701 = ginst->type_argc;
  D.20711 = (int) D.20701;
  if (D.20711 > i) goto <D.17852>; else goto <D.17854>;
  <D.17854>:
  D.20701 = ginst->type_argc;
  D.20711 = (int) D.20701;
  nginst = mono_metadata_get_generic_inst (D.20711, type_argv);
  cleanup:
  i = 0;
  goto <D.17856>;
  <D.17855>:
  i.114 = (unsigned int) i;
  D.20705 = i.114 * 4;
  D.20706 = type_argv + D.20705;
  D.20712 = *D.20706;
  mono_metadata_free_type (D.20712);
  i = i + 1;
  <D.17856>:
  if (i < count) goto <D.17855>; else goto <D.17857>;
  <D.17857>:
  monoeg_g_free (type_argv);
  D.20700 = nginst;
  return D.20700;
}


mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  unsigned int count.115;
  unsigned int D.20715;
  const char * ptr.116;
  struct MonoGenericInst * D.20719;
  unsigned int i.117;
  unsigned int D.20721;
  struct MonoType * * D.20722;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

  count.115 = (unsigned int) count;
  D.20715 = count.115 * 4;
  type_argv = monoeg_malloc0 (D.20715);
  i = 0;
  goto <D.17870>;
  <D.17869>:
  {
    struct MonoType * t;

    ptr.116 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.116, &ptr);
    if (t == 0B) goto <D.20717>; else goto <D.20718>;
    <D.20717>:
    monoeg_g_free (type_argv);
    D.20719 = 0B;
    return D.20719;
    <D.20718>:
    i.117 = (unsigned int) i;
    D.20721 = i.117 * 4;
    D.20722 = type_argv + D.20721;
    *D.20722 = t;
  }
  i = i + 1;
  <D.17870>:
  if (i < count) goto <D.17869>; else goto <D.17871>;
  <D.17871>:
  if (rptr != 0B) goto <D.20723>; else goto <D.20724>;
  <D.20723>:
  ptr.116 = ptr;
  *rptr = ptr.116;
  <D.20724>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.20719 = ginst;
  return D.20719;
}


mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.118;
  struct MonoType * D.20729;
  unsigned char D.20730;
  int D.20731;
  struct MonoClass * D.20732;
  struct MonoType * D.20733;
  struct MonoType * D.20736;
  struct MonoType * cached;

  type_cache.118 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.118, type);
  if (cached != 0B) goto <D.20727>; else goto <D.20728>;
  <D.20727>:
  D.20729 = cached;
  return D.20729;
  <D.20728>:
  D.20730 = type->type;
  D.20731 = (int) D.20730;
  switch (D.20731) <default: <D.20739>, case 17: <D.17902>, case 18: <D.17901>>
  <D.17901>:
  <D.17902>:
  D.20732 = type->data.klass;
  D.20733 = &D.20732->byval_arg;
  if (D.20733 == type) goto <D.20734>; else goto <D.20735>;
  <D.20734>:
  D.20729 = type;
  return D.20729;
  <D.20735>:
  D.20732 = type->data.klass;
  D.20736 = &D.20732->this_arg;
  if (D.20736 == type) goto <D.20737>; else goto <D.20738>;
  <D.20737>:
  D.20729 = type;
  return D.20729;
  <D.20738>:
  goto <D.17903>;
  <D.20739>:
  <D.17903>:
  D.20729 = 0B;
  return D.20729;
}


mono_metadata_free_type (struct MonoType * type)
{
  unsigned char D.20745;
  int D.20746;
  struct MonoClass * D.20747;
  struct MonoType * D.20751;
  struct MonoType * D.20753;
  struct MonoType * D.20754;
  struct MonoMethodSignature * D.20755;
  struct MonoArrayType * D.20756;

  if (type >= &builtin_types) goto <D.20741>; else goto <D.20742>;
  <D.20741>:
  if (type < &MEM[(void *)&builtin_types + 272B]) goto <D.20743>; else goto <D.20744>;
  <D.20743>:
  return;
  <D.20744>:
  <D.20742>:
  D.20745 = type->type;
  D.20746 = (int) D.20745;
  switch (D.20746) <default: <D.20757>, case 14: <D.17953>, case 15: <D.17957>, case 17: <D.17956>, case 18: <D.17955>, case 20: <D.17959>, case 27: <D.17958>, case 28: <D.17952>>
  <D.17952>:
  <D.17953>:
  D.20747 = type->data.klass;
  if (D.20747 == 0B) goto <D.17954>; else goto <D.20748>;
  <D.20748>:
  <D.17955>:
  <D.17956>:
  D.20747 = type->data.klass;
  D.20751 = &D.20747->byval_arg;
  if (D.20751 == type) goto <D.20749>; else goto <D.20752>;
  <D.20752>:
  D.20747 = type->data.klass;
  D.20753 = &D.20747->this_arg;
  if (D.20753 == type) goto <D.20749>; else goto <D.20750>;
  <D.20749>:
  return;
  <D.20750>:
  goto <D.17954>;
  <D.17957>:
  D.20754 = type->data.type;
  mono_metadata_free_type (D.20754);
  goto <D.17954>;
  <D.17958>:
  D.20755 = type->data.method;
  mono_metadata_free_method_signature (D.20755);
  goto <D.17954>;
  <D.17959>:
  D.20756 = type->data.array;
  mono_metadata_free_array (D.20756);
  goto <D.17954>;
  <D.20757>:
  <D.17954>:
  monoeg_g_free (type);
}


mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  unsigned int D.20759;
  unsigned int D.20760;
  short unsigned int D.20763;
  int D.20764;
  int D.20765;
  short unsigned int D.20767;
  unsigned int D.20768;
  unsigned int D.20769;
  int D.20771;
  gboolean D.20772;
  unsigned int D.20773;
  unsigned int D.20778;
  <unnamed-unsigned:15> D.20779;
  int D.20780;
  _Bool D.20781;
  int D.20782;
  unsigned int D.20783;
  int D.20784;
  struct MonoClass * D.20785;
  struct MonoTableInfo * D.20786;
  int D.20787;
  int D.20788;
  _Bool D.20791;
  long int D.20792;
  long int D.20793;
  int D.20796;
  unsigned char D.20797;
  unsigned int D.20798;
  unsigned int D.20799;
  int D.20800;
  int D.20801;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.17990>;
  <D.17989>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.17990>:
  D.20759 = BIT_FIELD_REF <*method, 32, 160>;
  D.20760 = D.20759 & 4096;
  if (D.20760 != 0) goto <D.17989>; else goto <D.17991>;
  <D.17991>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.20763 = method->flags;
  D.20764 = (int) D.20763;
  D.20765 = D.20764 & 1024;
  if (D.20765 != 0) goto <D.20761>; else goto <D.20766>;
  <D.20766>:
  D.20767 = method->iflags;
  D.20768 = (unsigned int) D.20767;
  D.20769 = D.20768 & 4099;
  if (D.20769 != 0) goto <D.20761>; else goto <D.20770>;
  <D.20770>:
  D.20763 = method->flags;
  D.20764 = (int) D.20763;
  D.20771 = D.20764 & 8192;
  if (D.20771 != 0) goto <D.20761>; else goto <D.20762>;
  <D.20761>:
  D.20772 = 0;
  return D.20772;
  <D.20762>:
  D.20759 = BIT_FIELD_REF <*method, 32, 160>;
  D.20773 = D.20759 & 1148;
  if (D.20773 != 0) goto <D.20774>; else goto <D.20775>;
  <D.20774>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.20776>; else goto <D.20777>;
    <D.20776>:
    D.20772 = 0;
    return D.20772;
    <D.20777>:
    D.20778 = header->code_size;
    summary->code_size = D.20778;
    D.20779 = header->num_clauses;
    D.20780 = (int) D.20779;
    D.20781 = D.20780 > 0;
    D.20782 = (int) D.20781;
    summary->has_clauses = D.20782;
    D.20772 = 1;
    return D.20772;
  }
  <D.20775>:
  D.20783 = method->token;
  D.20784 = (int) D.20783;
  idx = D.20784 & 16777215;
  D.20785 = method->klass;
  img = D.20785->image;
  D.20786 = &img->tables[6];
  D.20787 = idx + -1;
  rva = mono_metadata_decode_row_col (D.20786, D.20787, 0);
  D.20788 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.20788 == 0) goto <D.20789>; else goto <D.20790>;
  <D.20789>:
  D.20772 = 0;
  return D.20772;
  <D.20790>:
  ptr = mono_image_rva_map (img, rva);
  D.20791 = ptr == 0B;
  D.20792 = (long int) D.20791;
  D.20793 = __builtin_expect (D.20792, 0);
  if (D.20793 != 0) goto <D.20794>; else goto <D.20795>;
  <D.20794>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.20795>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.20796 = (int) format;
  switch (D.20796) <default: <D.17996>, case 2: <D.17993>, case 3: <D.17995>>
  <D.17993>:
  ptr = ptr + 1;
  D.20797 = flags >> 2;
  D.20798 = (unsigned int) D.20797;
  summary->code_size = D.20798;
  goto <D.17994>;
  <D.17995>:
  fat_flags = mono_read16 (ptr);
  ptr = ptr + 4;
  D.20799 = mono_read32 (ptr);
  summary->code_size = D.20799;
  D.20800 = (int) fat_flags;
  D.20801 = D.20800 & 8;
  if (D.20801 != 0) goto <D.20802>; else goto <D.20803>;
  <D.20802>:
  summary->has_clauses = 1;
  <D.20803>:
  goto <D.17994>;
  <D.17996>:
  D.20772 = 0;
  return D.20772;
  <D.17994>:
  D.20772 = 1;
  return D.20772;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.20807;
  int D.20808;
  unsigned char D.20809;
  unsigned int D.20810;
  short unsigned int D.20811;
  int D.20812;
  short unsigned int D.20813;
  int D.20814;
  int D.20815;
  int D.20819;
  unsigned int D.20823;
  unsigned int D.20824;
  <unnamed-unsigned:24> D.20827;
  int D.20828;
  unsigned int D.20830;
  int D.20831;
  const char * locals_ptr.119;
  const char * locals_ptr.120;
  unsigned int D.20840;
  char D.20841;
  const char * locals_ptr.121;
  unsigned int D.20845;
  int num_clauses.122;
  unsigned int num_clauses.123;
  unsigned int D.20848;
  unsigned int len.124;
  unsigned int D.20850;
  unsigned int D.20851;
  unsigned int D.20852;
  short unsigned int D.20853;
  struct MonoType * D.20854;
  struct MonoType * D.20855;
  unsigned int D.20859;
  unsigned int D.20860;
  short unsigned int D.20861;
  <unnamed-unsigned:15> D.20862;
  unsigned char D.20863;
  <unnamed-unsigned:1> D.20864;
  short unsigned int D.20867;
  int D.20868;
  short unsigned int D.20869;
  <unnamed-unsigned:15> D.20870;
  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.20805>; else goto <D.20806>;
      <D.20805>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.20807 = 0B;
      return D.20807;
      <D.20806>:
      D.20808 = (int) format;
      switch (D.20808) <default: <D.18019>, case 2: <D.18016>, case 3: <D.18017>>
      <D.18016>:
      mh = monoeg_malloc0 (20);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.20809 = flags >> 2;
      D.20810 = (unsigned int) D.20809;
      mh->code_size = D.20810;
      mh->code = ptr;
      D.20807 = mh;
      return D.20807;
      <D.18017>:
      fat_flags = mono_read16 (ptr);
      ptr = ptr + 2;
      D.20811 = fat_flags >> 12;
      D.20812 = (int) D.20811;
      hsize = D.20812 & 15;
      D.20813 = mono_read16 (ptr);
      max_stack = (guint32) D.20813;
      ptr = ptr + 2;
      code_size = mono_read32 (ptr);
      ptr = ptr + 4;
      local_var_sig_tok = mono_read32 (ptr);
      ptr = ptr + 4;
      D.20814 = (int) fat_flags;
      D.20815 = D.20814 & 16;
      if (D.20815 != 0) goto <D.20816>; else goto <D.20817>;
      <D.20816>:
      init_locals = 1;
      goto <D.20818>;
      <D.20817>:
      init_locals = 0;
      <D.20818>:
      code = ptr;
      D.20814 = (int) fat_flags;
      D.20819 = D.20814 & 8;
      if (D.20819 == 0) goto <D.18018>; else goto <D.20820>;
      <D.20820>:
      ptr = code + code_size;
      goto <D.18018>;
      <D.18019>:
      D.20807 = 0B;
      return D.20807;
      <D.18018>:
      if (local_var_sig_tok != 0) goto <D.20821>; else goto <D.20822>;
      <D.20821>:
      {
        int idx;

        D.20823 = local_var_sig_tok & 16777215;
        D.20824 = D.20823 + 4294967295;
        idx = (int) D.20824;
        D.20827 = t->rows;
        D.20828 = (int) D.20827;
        if (D.20828 <= idx) goto <D.20825>; else goto <D.20829>;
        <D.20829>:
        if (idx < 0) goto <D.20825>; else goto <D.20826>;
        <D.20825>:
        D.20807 = 0B;
        return D.20807;
        <D.20826>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.20830 = cols[0];
        D.20831 = mono_verifier_verify_standalone_signature (m, D.20830, 0B);
        if (D.20831 == 0) goto <D.20832>; else goto <D.20833>;
        <D.20832>:
        D.20807 = 0B;
        return D.20807;
        <D.20833>:
      }
      <D.20822>:
      D.20814 = (int) fat_flags;
      D.20819 = D.20814 & 8;
      if (D.20819 != 0) goto <D.20834>; else goto <D.20835>;
      <D.20834>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.20835>:
      if (local_var_sig_tok != 0) goto <D.20836>; else goto <D.20837>;
      <D.20836>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.20830 = cols[0];
            locals_ptr.119 = mono_metadata_blob_heap (m, D.20830);
            locals_ptr = locals_ptr.119;
            locals_ptr.120 = locals_ptr;
            D.20840 = mono_metadata_decode_blob_size (locals_ptr.120, &locals_ptr);
            bsize = (int) D.20840;
            locals_ptr.120 = locals_ptr;
            D.20841 = *locals_ptr.120;
            if (D.20841 != 7) goto <D.20842>; else goto <D.20843>;
            <D.20842>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.20843>:
            locals_ptr.120 = locals_ptr;
            locals_ptr.121 = locals_ptr.120 + 1;
            locals_ptr = locals_ptr.121;
            locals_ptr.120 = locals_ptr;
            D.20845 = mono_metadata_decode_value (locals_ptr.120, &locals_ptr);
            len = (int) D.20845;
            num_clauses.122 = num_clauses;
            num_clauses.123 = (unsigned int) num_clauses.122;
            D.20848 = num_clauses.123 * 6;
            len.124 = (unsigned int) len;
            D.20850 = D.20848 + len.124;
            D.20851 = D.20850 + 5;
            D.20852 = D.20851 * 4;
            mh = monoeg_malloc0 (D.20852);
            D.20853 = (short unsigned int) len;
            mh->num_locals = D.20853;
            i = 0;
            goto <D.18026>;
            <D.18025>:
            locals_ptr.120 = locals_ptr;
            D.20854 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.120, &locals_ptr);
            mh->locals[i] = D.20854;
            D.20855 = mh->locals[i];
            if (D.20855 == 0B) goto <D.20856>; else goto <D.20857>;
            <D.20856>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.20807 = 0B;
            return D.20807;
            <D.20857>:
            i = i + 1;
            <D.18026>:
            if (i < len) goto <D.18025>; else goto <D.18027>;
            <D.18027>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.20858>;
      <D.20837>:
      num_clauses.122 = num_clauses;
      num_clauses.123 = (unsigned int) num_clauses.122;
      D.20859 = num_clauses.123 * 24;
      D.20860 = D.20859 + 20;
      mh = monoeg_malloc0 (D.20860);
      <D.20858>:
      mh->code = code;
      mh->code_size = code_size;
      D.20861 = (short unsigned int) max_stack;
      D.20862 = (<unnamed-unsigned:15>) D.20861;
      mh->max_stack = D.20862;
      mh->is_transient = 1;
      D.20863 = (unsigned char) init_locals;
      D.20864 = (<unnamed-unsigned:1>) D.20863;
      mh->init_locals = D.20864;
      if (clauses != 0B) goto <D.20865>; else goto <D.20866>;
      <D.20865>:
      {
        struct MonoExceptionClause * clausesp;

        D.20867 = mh->num_locals;
        D.20868 = (int) D.20867;
        clausesp = &mh->locals[D.20868];
        num_clauses.122 = num_clauses;
        num_clauses.123 = (unsigned int) num_clauses.122;
        D.20859 = num_clauses.123 * 24;
        memcpy (clausesp, clauses, D.20859);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.122 = num_clauses;
        D.20869 = (short unsigned int) num_clauses.122;
        D.20870 = (<unnamed-unsigned:15>) D.20869;
        mh->num_clauses = D.20870;
      }
      <D.20866>:
      D.20807 = mh;
      return D.20807;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.20875;
  const unsigned char * D.20878;
  unsigned char D.20879;
  int D.20880;
  int D.20881;
  const unsigned char * D.20882;
  unsigned char D.20883;
  int D.20884;
  int D.20885;
  int D.20886;
  unsigned char D.20887;
  int D.20888;
  int D.20889;
  int D.20891;
  int iftmp.125;
  unsigned int D.20897;
  unsigned int D.20899;
  int D.20900;
  unsigned int D.20901;
  unsigned int D.20902;
  unsigned int i.126;
  unsigned int D.20904;
  unsigned int D.20907;
  const unsigned char * D.20908;
  unsigned int D.20909;
  const unsigned char * D.20910;
  unsigned int D.20911;
  const unsigned char * D.20912;
  unsigned int D.20913;
  const unsigned char * D.20914;
  unsigned int D.20915;
  const unsigned char * D.20916;
  short unsigned int D.20918;
  unsigned int D.20919;
  const unsigned char * D.20920;
  short unsigned int D.20921;
  unsigned int D.20922;
  unsigned char D.20923;
  unsigned int D.20924;
  const unsigned char * D.20925;
  short unsigned int D.20926;
  unsigned int D.20927;
  const unsigned char * D.20928;
  unsigned char D.20929;
  unsigned int D.20930;
  unsigned int D.20931;
  struct MonoClass * iftmp.127;
  signed char sect_data_flags.128;
  sizetype D.20945;
  struct MonoExceptionClause * D.20947;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.17977>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.20875 = (int) sect_data_flags;
  is_fat = D.20875 & 64;
  if (is_fat != 0) goto <D.20876>; else goto <D.20877>;
  <D.20876>:
  D.20878 = ptr + 2;
  D.20879 = *D.20878;
  D.20880 = (int) D.20879;
  D.20881 = D.20880 << 16;
  D.20882 = ptr + 1;
  D.20883 = *D.20882;
  D.20884 = (int) D.20883;
  D.20885 = D.20884 << 8;
  D.20886 = D.20881 | D.20885;
  D.20887 = *ptr;
  D.20888 = (int) D.20887;
  D.20889 = D.20886 | D.20888;
  sect_data_len = (guint32) D.20889;
  ptr = ptr + 3;
  goto <D.20890>;
  <D.20877>:
  D.20887 = *ptr;
  sect_data_len = (guint32) D.20887;
  ptr = ptr + 1;
  <D.20890>:
  D.20875 = (int) sect_data_flags;
  D.20891 = D.20875 & 1;
  if (D.20891 != 0) goto <D.20892>; else goto <D.20893>;
  <D.20892>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.20895>; else goto <D.20896>;
    <D.20895>:
    D.20897 = sect_data_len / 24;
    iftmp.125 = (int) D.20897;
    goto <D.20898>;
    <D.20896>:
    D.20899 = sect_data_len / 12;
    iftmp.125 = (int) D.20899;
    <D.20898>:
    *num_clauses = iftmp.125;
    D.20900 = *num_clauses;
    D.20901 = (unsigned int) D.20900;
    D.20902 = D.20901 * 24;
    clauses = monoeg_malloc0 (D.20902);
    i = 0;
    goto <D.17975>;
    <D.17974>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      i.126 = (unsigned int) i;
      D.20904 = i.126 * 24;
      ec = clauses + D.20904;
      if (is_fat != 0) goto <D.20905>; else goto <D.20906>;
      <D.20905>:
      D.20907 = mono_read32 (p);
      ec->flags = D.20907;
      D.20908 = p + 4;
      D.20909 = mono_read32 (D.20908);
      ec->try_offset = D.20909;
      D.20910 = p + 8;
      D.20911 = mono_read32 (D.20910);
      ec->try_len = D.20911;
      D.20912 = p + 12;
      D.20913 = mono_read32 (D.20912);
      ec->handler_offset = D.20913;
      D.20914 = p + 16;
      D.20915 = mono_read32 (D.20914);
      ec->handler_len = D.20915;
      D.20916 = p + 20;
      tof_value = mono_read32 (D.20916);
      p = p + 24;
      goto <D.20917>;
      <D.20906>:
      D.20918 = mono_read16 (p);
      D.20919 = (unsigned int) D.20918;
      ec->flags = D.20919;
      D.20920 = p + 2;
      D.20921 = mono_read16 (D.20920);
      D.20922 = (unsigned int) D.20921;
      ec->try_offset = D.20922;
      D.20908 = p + 4;
      D.20923 = *D.20908;
      D.20924 = (unsigned int) D.20923;
      ec->try_len = D.20924;
      D.20925 = p + 5;
      D.20926 = mono_read16 (D.20925);
      D.20927 = (unsigned int) D.20926;
      ec->handler_offset = D.20927;
      D.20928 = p + 7;
      D.20929 = *D.20928;
      D.20930 = (unsigned int) D.20929;
      ec->handler_len = D.20930;
      D.20910 = p + 8;
      tof_value = mono_read32 (D.20910);
      p = p + 12;
      <D.20917>:
      D.20931 = ec->flags;
      if (D.20931 == 1) goto <D.20932>; else goto <D.20933>;
      <D.20932>:
      ec->data.filter_offset = tof_value;
      goto <D.20934>;
      <D.20933>:
      D.20931 = ec->flags;
      if (D.20931 == 0) goto <D.20935>; else goto <D.20936>;
      <D.20935>:
      if (tof_value != 0) goto <D.20938>; else goto <D.20939>;
      <D.20938>:
      iftmp.127 = mono_class_get (m, tof_value);
      goto <D.20940>;
      <D.20939>:
      iftmp.127 = 0B;
      <D.20940>:
      ec->data.catch_class = iftmp.127;
      goto <D.20941>;
      <D.20936>:
      ec->data.catch_class = 0B;
      <D.20941>:
      <D.20934>:
    }
    i = i + 1;
    <D.17975>:
    D.20900 = *num_clauses;
    if (D.20900 > i) goto <D.17974>; else goto <D.17976>;
    <D.17976>:
  }
  <D.20893>:
  sect_data_flags.128 = (signed char) sect_data_flags;
  if (sect_data_flags.128 < 0) goto <D.20943>; else goto <D.20944>;
  <D.20943>:
  D.20945 = sect_data_len + 4294967292;
  ptr = ptr + D.20945;
  goto <D.20946>;
  <D.20944>:
  D.20947 = clauses;
  return D.20947;
  <D.20946>:
  goto <D.17977>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.20949;
  const unsigned char * D.20950;
  unsigned int D.20951;
  unsigned int D.20952;

  D.20950 = ptr + 3;
  D.20951 = (unsigned int) D.20950;
  D.20952 = D.20951 & 4294967292;
  D.20949 = (const unsigned char *) D.20952;
  return D.20949;
}


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

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


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  unsigned int D.20956;
  unsigned int D.20957;
  struct MonoType * D.20960;
  short unsigned int D.20961;
  int D.20962;
  int i;

  D.20956 = BIT_FIELD_REF <*mh, 32, 64>;
  D.20957 = D.20956 & 32768;
  if (D.20957 != 0) goto <D.20958>; else goto <D.20959>;
  <D.20958>:
  i = 0;
  goto <D.18039>;
  <D.18038>:
  D.20960 = mh->locals[i];
  mono_metadata_free_type (D.20960);
  i = i + 1;
  <D.18039>:
  D.20961 = mh->num_locals;
  D.20962 = (int) D.20961;
  if (D.20962 > i) goto <D.18038>; else goto <D.18040>;
  <D.18040>:
  monoeg_g_free (mh);
  <D.20959>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.20965;
  <unnamed-unsigned:15> D.20968;
  unsigned int D.20969;
  const unsigned char * D.20970;

  if (code_size != 0B) goto <D.20963>; else goto <D.20964>;
  <D.20963>:
  D.20965 = header->code_size;
  *code_size = D.20965;
  <D.20964>:
  if (max_stack != 0B) goto <D.20966>; else goto <D.20967>;
  <D.20966>:
  D.20968 = header->max_stack;
  D.20969 = (unsigned int) D.20968;
  *max_stack = D.20969;
  <D.20967>:
  D.20970 = header->code;
  return D.20970;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.20974;
  unsigned int D.20975;
  <unnamed-unsigned:1> D.20978;
  int D.20979;
  struct MonoType * * D.20980;

  if (num_locals != 0B) goto <D.20972>; else goto <D.20973>;
  <D.20972>:
  D.20974 = header->num_locals;
  D.20975 = (unsigned int) D.20974;
  *num_locals = D.20975;
  <D.20973>:
  if (init_locals != 0B) goto <D.20976>; else goto <D.20977>;
  <D.20976>:
  D.20978 = header->init_locals;
  D.20979 = (int) D.20978;
  *init_locals = D.20979;
  <D.20977>:
  D.20980 = &header->locals;
  return D.20980;
}


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

  D.20983 = header->num_clauses;
  D.20982 = (int) D.20983;
  return D.20982;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  unsigned int D.20988;
  unsigned int D.20989;
  int D.20990;
  void * D.20991;
  struct MonoExceptionClause * D.20994;
  <unnamed-unsigned:15> D.20995;
  unsigned int D.20996;
  unsigned int D.20997;
  struct MonoExceptionClause * D.20998;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.20985>; else goto <D.20987>;
  <D.20987>:
  D.20988 = BIT_FIELD_REF <*header, 32, 64>;
  D.20989 = D.20988 & 2147418112;
  if (D.20989 == 0) goto <D.20985>; else goto <D.20986>;
  <D.20985>:
  D.20990 = 0;
  return D.20990;
  <D.20986>:
  D.20991 = *iter;
  if (D.20991 == 0B) goto <D.20992>; else goto <D.20993>;
  <D.20992>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.20990 = 1;
  return D.20990;
  <D.20993>:
  sc = *iter;
  sc = sc + 24;
  D.20994 = header->clauses;
  D.20995 = header->num_clauses;
  D.20996 = (unsigned int) D.20995;
  D.20997 = D.20996 * 24;
  D.20998 = D.20994 + D.20997;
  if (D.20998 > sc) goto <D.20999>; else goto <D.21000>;
  <D.20999>:
  *iter = sc;
  *clause = *sc;
  D.20990 = 1;
  return D.20990;
  <D.21000>:
  D.20990 = 0;
  return D.20990;
}


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

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


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

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


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

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


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.21009;
  uint32_t D.21012;
  int index.129;
  int D.21014;
  unsigned int D.21015;
  unsigned int D.21016;
  int D.21019;
  unsigned int D.21020;
  int D.21021;
  <unnamed-unsigned:24> D.21022;
  unsigned int D.21023;
  unsigned char D.21024;
  unsigned int D.21025;
  void * D.21026;
  unsigned int D.21029;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21009 = tdef->base;
      if (D.21009 == 0B) goto <D.21010>; else goto <D.21011>;
      <D.21010>:
      D.21012 = 0;
      return D.21012;
      <D.21011>:
      index.129 = (int) index;
      D.21014 = index.129 & 16777215;
      loc.idx = D.21014;
      loc.col_idx = 4;
      loc.t = tdef;
      D.21015 = BIT_FIELD_REF <*meta, 32, 128>;
      D.21016 = D.21015 & 32;
      if (D.21016 != 0) goto <D.21017>; else goto <D.21018>;
      <D.21017>:
      D.21019 = loc.idx;
      D.21020 = search_ptr_table (meta, 3, D.21019);
      D.21021 = (int) D.21020;
      loc.idx = D.21021;
      <D.21018>:
      D.21009 = tdef->base;
      D.21022 = tdef->rows;
      D.21023 = (unsigned int) D.21022;
      D.21024 = tdef->row_size;
      D.21025 = (unsigned int) D.21024;
      D.21026 = mono_binary_search (&loc, D.21009, D.21023, D.21025, typedef_locator);
      if (D.21026 == 0B) goto <D.21027>; else goto <D.21028>;
      <D.21027>:
      D.21012 = 0;
      return D.21012;
      <D.21028>:
      D.21029 = loc.result;
      D.21012 = D.21029 + 1;
      return D.21012;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  int bb.130;
  struct MonoTableInfo * D.21033;
  const char * D.21034;
  int D.21035;
  int D.21036;
  unsigned char D.21037;
  int D.21038;
  int D.21039;
  unsigned int D.21040;
  int D.21041;
  unsigned int D.21042;
  int D.21045;
  int D.21046;
  <unnamed-unsigned:24> D.21047;
  int D.21048;
  unsigned int typedef_index.131;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.130 = (int) bb;
  D.21033 = loc->t;
  D.21034 = D.21033->base;
  D.21035 = (int) D.21034;
  D.21036 = bb.130 - D.21035;
  D.21033 = loc->t;
  D.21037 = D.21033->row_size;
  D.21038 = (int) D.21037;
  typedef_index = D.21036 / D.21038;
  D.21033 = loc->t;
  D.21039 = loc->col_idx;
  D.21040 = (unsigned int) D.21039;
  col = mono_metadata_decode_row_col (D.21033, typedef_index, D.21040);
  D.21041 = loc->idx;
  D.21042 = (unsigned int) D.21041;
  if (D.21042 < col) goto <D.21043>; else goto <D.21044>;
  <D.21043>:
  D.21045 = -1;
  return D.21045;
  <D.21044>:
  D.21046 = typedef_index + 1;
  D.21033 = loc->t;
  D.21047 = D.21033->rows;
  D.21048 = (int) D.21047;
  if (D.21046 < D.21048) goto <D.21049>; else goto <D.21050>;
  <D.21049>:
  D.21033 = loc->t;
  D.21046 = typedef_index + 1;
  D.21039 = loc->col_idx;
  D.21040 = (unsigned int) D.21039;
  col_next = mono_metadata_decode_row_col (D.21033, D.21046, D.21040);
  D.21041 = loc->idx;
  D.21042 = (unsigned int) D.21041;
  if (D.21042 >= col_next) goto <D.21051>; else goto <D.21052>;
  <D.21051>:
  D.21045 = 1;
  return D.21045;
  <D.21052>:
  if (col == col_next) goto <D.21053>; else goto <D.21054>;
  <D.21053>:
  D.21045 = 1;
  return D.21045;
  <D.21054>:
  <D.21050>:
  typedef_index.131 = (unsigned int) typedef_index;
  loc->result = typedef_index.131;
  D.21045 = 0;
  return D.21045;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.21057;
  unsigned int idx.132;
  <unnamed-unsigned:24> D.21060;
  int D.21061;
  guint32 D.21064;
  int D.21065;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.18121>;
  <D.18120>:
  D.21057 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.132 = (unsigned int) idx;
  if (D.21057 == idx.132) goto <D.18119>; else goto <D.21059>;
  <D.21059>:
  i = i + 1;
  <D.18121>:
  D.21060 = ptrdef->rows;
  D.21061 = (int) D.21060;
  if (D.21061 > i) goto <D.18120>; else goto <D.18119>;
  <D.18119>:
  D.21060 = ptrdef->rows;
  D.21061 = (int) D.21060;
  if (D.21061 > i) goto <D.21062>; else goto <D.21063>;
  <D.21062>:
  D.21065 = i + 1;
  D.21064 = (guint32) D.21065;
  return D.21064;
  <D.21063>:
  D.21064 = (guint32) idx;
  return D.21064;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.21067;
  uint32_t D.21070;
  int index.133;
  int D.21072;
  unsigned int D.21073;
  unsigned int D.21074;
  int D.21077;
  unsigned int D.21078;
  int D.21079;
  <unnamed-unsigned:24> D.21080;
  unsigned int D.21081;
  unsigned char D.21082;
  unsigned int D.21083;
  void * D.21084;
  unsigned int D.21087;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21067 = tdef->base;
      if (D.21067 == 0B) goto <D.21068>; else goto <D.21069>;
      <D.21068>:
      D.21070 = 0;
      return D.21070;
      <D.21069>:
      index.133 = (int) index;
      D.21072 = index.133 & 16777215;
      loc.idx = D.21072;
      loc.col_idx = 5;
      loc.t = tdef;
      D.21073 = BIT_FIELD_REF <*meta, 32, 128>;
      D.21074 = D.21073 & 32;
      if (D.21074 != 0) goto <D.21075>; else goto <D.21076>;
      <D.21075>:
      D.21077 = loc.idx;
      D.21078 = search_ptr_table (meta, 5, D.21077);
      D.21079 = (int) D.21078;
      loc.idx = D.21079;
      <D.21076>:
      D.21067 = tdef->base;
      D.21080 = tdef->rows;
      D.21081 = (unsigned int) D.21080;
      D.21082 = tdef->row_size;
      D.21083 = (unsigned int) D.21082;
      D.21084 = mono_binary_search (&loc, D.21067, D.21081, D.21083, typedef_locator);
      if (D.21084 == 0B) goto <D.21085>; else goto <D.21086>;
      <D.21085>:
      D.21070 = 0;
      return D.21070;
      <D.21086>:
      D.21087 = loc.result;
      D.21070 = D.21087 + 1;
      return D.21070;
    }
  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.21090;
  gboolean D.21093;
  int index.134;
  int D.21095;
  <unnamed-unsigned:24> D.21096;
  unsigned int D.21097;
  unsigned char D.21098;
  unsigned int D.21099;
  void * D.21100;
  int D.21103;
  unsigned int D.21104;
  unsigned int D.21105;
  int D.21106;
  unsigned int D.21107;
  int pos.135;
  unsigned int D.21110;
  unsigned int D.21111;
  unsigned int D.21113;
  unsigned int D.21116;
  unsigned int D.21117;
  unsigned int D.21120;
  unsigned int D.21121;
  unsigned int D.21124;
  struct MonoClass * * D.21125;
  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.21090 = tdef->base;
      if (D.21090 == 0B) goto <D.21091>; else goto <D.21092>;
      <D.21091>:
      D.21093 = 1;
      return D.21093;
      <D.21092>:
      index.134 = (int) index;
      D.21095 = index.134 & 16777215;
      loc.idx = D.21095;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21090 = tdef->base;
      D.21096 = tdef->rows;
      D.21097 = (unsigned int) D.21096;
      D.21098 = tdef->row_size;
      D.21099 = (unsigned int) D.21098;
      D.21100 = mono_binary_search (&loc, D.21090, D.21097, D.21099, table_locator);
      if (D.21100 == 0B) goto <D.21101>; else goto <D.21102>;
      <D.21101>:
      D.21093 = 1;
      return D.21093;
      <D.21102>:
      start = loc.result;
      goto <D.18150>;
      <D.18149>:
      D.21103 = loc.idx;
      D.21104 = (unsigned int) D.21103;
      D.21105 = start + 4294967295;
      D.21106 = (int) D.21105;
      D.21107 = mono_metadata_decode_row_col (tdef, D.21106, 0);
      if (D.21104 == D.21107) goto <D.21108>; else goto <D.18148>;
      <D.21108>:
      start = start + 4294967295;
      <D.18150>:
      if (start != 0) goto <D.18149>; else goto <D.18148>;
      <D.18148>:
      pos = start;
      goto <D.18153>;
      <D.18152>:
      pos.135 = (int) pos;
      mono_metadata_decode_row (tdef, pos.135, &cols, 2);
      D.21110 = cols[0];
      D.21103 = loc.idx;
      D.21111 = (unsigned int) D.21103;
      if (D.21110 != D.21111) goto <D.18151>; else goto <D.21112>;
      <D.21112>:
      pos = pos + 1;
      <D.18153>:
      D.21096 = tdef->rows;
      D.21113 = (unsigned int) D.21096;
      if (D.21113 > pos) goto <D.18152>; else goto <D.18151>;
      <D.18151>:
      if (heap_alloc_result != 0) goto <D.21114>; else goto <D.21115>;
      <D.21114>:
      D.21116 = pos - start;
      D.21117 = D.21116 * 4;
      result = monoeg_malloc0 (D.21117);
      goto <D.21118>;
      <D.21115>:
      D.21116 = pos - start;
      D.21117 = D.21116 * 4;
      result = mono_image_alloc0 (meta, D.21117);
      <D.21118>:
      pos = start;
      goto <D.18157>;
      <D.18156>:
      {
        struct MonoClass * iface;

        pos.135 = (int) pos;
        mono_metadata_decode_row (tdef, pos.135, &cols, 2);
        D.21110 = cols[0];
        D.21103 = loc.idx;
        D.21111 = (unsigned int) D.21103;
        if (D.21110 != D.21111) goto <D.18155>; else goto <D.21119>;
        <D.21119>:
        D.21120 = cols[1];
        D.21121 = mono_metadata_token_from_dor (D.21120);
        iface = mono_class_get_full (meta, D.21121, context);
        if (iface == 0B) goto <D.21122>; else goto <D.21123>;
        <D.21122>:
        D.21093 = 0;
        return D.21093;
        <D.21123>:
        D.21116 = pos - start;
        D.21124 = D.21116 * 4;
        D.21125 = result + D.21124;
        *D.21125 = iface;
        pos = pos + 1;
      }
      <D.18157>:
      D.21096 = tdef->rows;
      D.21113 = (unsigned int) D.21096;
      if (D.21113 > pos) goto <D.18156>; else goto <D.18155>;
      <D.18155>:
      D.21116 = pos - start;
      *count = D.21116;
      *interfaces = result;
      D.21093 = 1;
      return D.21093;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  int bb.136;
  struct MonoTableInfo * D.21129;
  const char * D.21130;
  int D.21131;
  int D.21132;
  unsigned char D.21133;
  int D.21134;
  int D.21135;
  int table_index.137;
  int D.21137;
  unsigned int D.21138;
  int D.21139;
  unsigned int D.21140;
  int D.21143;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.136 = (int) bb;
  D.21129 = loc->t;
  D.21130 = D.21129->base;
  D.21131 = (int) D.21130;
  D.21132 = bb.136 - D.21131;
  D.21129 = loc->t;
  D.21133 = D.21129->row_size;
  D.21134 = (int) D.21133;
  D.21135 = D.21132 / D.21134;
  table_index = (guint32) D.21135;
  D.21129 = loc->t;
  table_index.137 = (int) table_index;
  D.21137 = loc->col_idx;
  D.21138 = (unsigned int) D.21137;
  col = mono_metadata_decode_row_col (D.21129, table_index.137, D.21138);
  D.21139 = loc->idx;
  D.21140 = (unsigned int) D.21139;
  if (D.21140 == col) goto <D.21141>; else goto <D.21142>;
  <D.21141>:
  loc->result = table_index;
  D.21143 = 0;
  return D.21143;
  <D.21142>:
  D.21139 = loc->idx;
  D.21140 = (unsigned int) D.21139;
  if (D.21140 < col) goto <D.21144>; else goto <D.21145>;
  <D.21144>:
  D.21143 = -1;
  return D.21143;
  <D.21145>:
  D.21143 = 1;
  return D.21143;
}


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


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.21152;
  uint32_t D.21155;
  int index.138;
  int D.21157;
  <unnamed-unsigned:24> D.21158;
  unsigned int D.21159;
  unsigned char D.21160;
  unsigned int D.21161;
  void * D.21162;
  unsigned int D.21165;
  int D.21166;
  unsigned int D.21167;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.21152 = tdef->base;
      if (D.21152 == 0B) goto <D.21153>; else goto <D.21154>;
      <D.21153>:
      D.21155 = 0;
      return D.21155;
      <D.21154>:
      index.138 = (int) index;
      D.21157 = index.138 & 16777215;
      loc.idx = D.21157;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21152 = tdef->base;
      D.21158 = tdef->rows;
      D.21159 = (unsigned int) D.21158;
      D.21160 = tdef->row_size;
      D.21161 = (unsigned int) D.21160;
      D.21162 = mono_binary_search (&loc, D.21152, D.21159, D.21161, table_locator);
      if (D.21162 == 0B) goto <D.21163>; else goto <D.21164>;
      <D.21163>:
      D.21155 = 0;
      return D.21155;
      <D.21164>:
      D.21165 = loc.result;
      D.21166 = (int) D.21165;
      D.21167 = mono_metadata_decode_row_col (tdef, D.21166, 1);
      D.21155 = D.21167 | 33554432;
      return D.21155;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.21170;
  uint32_t D.21173;
  unsigned int D.21174;
  int D.21175;
  unsigned int D.21176;
  <unnamed-unsigned:24> D.21178;
  unsigned int D.21179;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.21170 = tdef->base;
  if (D.21170 == 0B) goto <D.21171>; else goto <D.21172>;
  <D.21171>:
  D.21173 = 0;
  return D.21173;
  <D.21172>:
  start = start_index;
  goto <D.18181>;
  <D.18180>:
  D.21174 = start + 4294967295;
  D.21175 = (int) D.21174;
  D.21176 = mono_metadata_decode_row_col (tdef, D.21175, 1);
  if (D.21176 == class_index) goto <D.18179>; else goto <D.21177>;
  <D.21177>:
  start = start + 1;
  <D.18181>:
  D.21178 = tdef->rows;
  D.21179 = (unsigned int) D.21178;
  if (D.21179 >= start) goto <D.18180>; else goto <D.18179>;
  <D.18179>:
  D.21178 = tdef->rows;
  D.21179 = (unsigned int) D.21178;
  if (D.21179 < start) goto <D.21180>; else goto <D.21181>;
  <D.21180>:
  D.21173 = 0;
  return D.21173;
  <D.21181>:
  D.21173 = start;
  return D.21173;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.21183;
  uint32_t D.21186;
  int index.139;
  int D.21188;
  <unnamed-unsigned:24> D.21189;
  unsigned int D.21190;
  unsigned char D.21191;
  unsigned int D.21192;
  void * D.21193;
  unsigned int D.21196;
  int D.21197;
  unsigned int D.21200;
  unsigned int D.21203;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.21183 = tdef->base;
      if (D.21183 == 0B) goto <D.21184>; else goto <D.21185>;
      <D.21184>:
      D.21186 = 0;
      return D.21186;
      <D.21185>:
      index.139 = (int) index;
      D.21188 = index.139 & 16777215;
      loc.idx = D.21188;
      loc.col_idx = 2;
      loc.t = tdef;
      D.21183 = tdef->base;
      D.21189 = tdef->rows;
      D.21190 = (unsigned int) D.21189;
      D.21191 = tdef->row_size;
      D.21192 = (unsigned int) D.21191;
      D.21193 = mono_binary_search (&loc, D.21183, D.21190, D.21192, table_locator);
      if (D.21193 == 0B) goto <D.21194>; else goto <D.21195>;
      <D.21194>:
      D.21186 = 0;
      return D.21186;
      <D.21195>:
      D.21196 = loc.result;
      D.21197 = (int) D.21196;
      mono_metadata_decode_row (tdef, D.21197, &cols, 3);
      if (packing != 0B) goto <D.21198>; else goto <D.21199>;
      <D.21198>:
      D.21200 = cols[0];
      *packing = D.21200;
      <D.21199>:
      if (size != 0B) goto <D.21201>; else goto <D.21202>;
      <D.21201>:
      D.21203 = cols[1];
      *size = D.21203;
      <D.21202>:
      D.21196 = loc.result;
      D.21186 = D.21196 + 1;
      return D.21186;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21206;
  uint32_t D.21209;
  int index.140;
  <unnamed-unsigned:24> D.21211;
  unsigned int D.21212;
  unsigned char D.21213;
  unsigned int D.21214;
  void * D.21215;
  unsigned int D.21218;
  unsigned int D.21219;
  int D.21221;
  unsigned int D.21222;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.21206 = tdef->base;
      if (D.21206 == 0B) goto <D.21207>; else goto <D.21208>;
      <D.21207>:
      D.21209 = 0;
      return D.21209;
      <D.21208>:
      index.140 = (int) index;
      loc.idx = index.140;
      loc.col_idx = 0;
      loc.t = tdef;
      D.21206 = tdef->base;
      D.21211 = tdef->rows;
      D.21212 = (unsigned int) D.21211;
      D.21213 = tdef->row_size;
      D.21214 = (unsigned int) D.21213;
      D.21215 = mono_binary_search (&loc, D.21206, D.21212, D.21214, table_locator);
      if (D.21215 == 0B) goto <D.21216>; else goto <D.21217>;
      <D.21216>:
      D.21209 = 0;
      return D.21209;
      <D.21217>:
      goto <D.18198>;
      <D.18197>:
      D.21218 = loc.result;
      D.21219 = D.21218 + 4294967295;
      loc.result = D.21219;
      <D.18198>:
      D.21218 = loc.result;
      if (D.21218 != 0) goto <D.21220>; else goto <D.18199>;
      <D.21220>:
      D.21218 = loc.result;
      D.21219 = D.21218 + 4294967295;
      D.21221 = (int) D.21219;
      D.21222 = mono_metadata_decode_row_col (tdef, D.21221, 0);
      if (D.21222 == index) goto <D.18197>; else goto <D.18199>;
      <D.18199>:
      D.21218 = loc.result;
      D.21209 = D.21218 + 1;
      return D.21209;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.21225;
  uint32_t D.21228;
  int index.141;
  <unnamed-unsigned:24> D.21230;
  unsigned int D.21231;
  unsigned char D.21232;
  unsigned int D.21233;
  void * D.21234;
  unsigned int D.21237;
  unsigned int D.21238;
  int D.21240;
  unsigned int D.21241;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.21225 = tdef->base;
      if (D.21225 == 0B) goto <D.21226>; else goto <D.21227>;
      <D.21226>:
      D.21228 = 4294967295;
      return D.21228;
      <D.21227>:
      index.141 = (int) index;
      loc.idx = index.141;
      loc.col_idx = 1;
      loc.t = tdef;
      D.21225 = tdef->base;
      D.21230 = tdef->rows;
      D.21231 = (unsigned int) D.21230;
      D.21232 = tdef->row_size;
      D.21233 = (unsigned int) D.21232;
      D.21234 = mono_binary_search (&loc, D.21225, D.21231, D.21233, declsec_locator);
      if (D.21234 == 0B) goto <D.21235>; else goto <D.21236>;
      <D.21235>:
      D.21228 = 4294967295;
      return D.21228;
      <D.21236>:
      goto <D.18207>;
      <D.18206>:
      D.21237 = loc.result;
      D.21238 = D.21237 + 4294967295;
      loc.result = D.21238;
      <D.18207>:
      D.21237 = loc.result;
      if (D.21237 != 0) goto <D.21239>; else goto <D.18208>;
      <D.21239>:
      D.21237 = loc.result;
      D.21238 = D.21237 + 4294967295;
      D.21240 = (int) D.21238;
      D.21241 = mono_metadata_decode_row_col (tdef, D.21240, 1);
      if (D.21241 == index) goto <D.18206>; else goto <D.18208>;
      <D.18208>:
      D.21228 = loc.result;
      return D.21228;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  int bb.142;
  struct MonoTableInfo * D.21245;
  const char * D.21246;
  int D.21247;
  int D.21248;
  unsigned char D.21249;
  int D.21250;
  int D.21251;
  int table_index.143;
  int D.21253;
  unsigned int D.21254;
  int D.21255;
  unsigned int D.21256;
  int D.21259;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.142 = (int) bb;
  D.21245 = loc->t;
  D.21246 = D.21245->base;
  D.21247 = (int) D.21246;
  D.21248 = bb.142 - D.21247;
  D.21245 = loc->t;
  D.21249 = D.21245->row_size;
  D.21250 = (int) D.21249;
  D.21251 = D.21248 / D.21250;
  table_index = (guint32) D.21251;
  D.21245 = loc->t;
  table_index.143 = (int) table_index;
  D.21253 = loc->col_idx;
  D.21254 = (unsigned int) D.21253;
  col = mono_metadata_decode_row_col (D.21245, table_index.143, D.21254);
  D.21255 = loc->idx;
  D.21256 = (unsigned int) D.21255;
  if (D.21256 == col) goto <D.21257>; else goto <D.21258>;
  <D.21257>:
  loc->result = table_index;
  D.21259 = 0;
  return D.21259;
  <D.21258>:
  D.21255 = loc->idx;
  D.21256 = (unsigned int) D.21255;
  if (D.21256 < col) goto <D.21260>; else goto <D.21261>;
  <D.21260>:
  D.21259 = -1;
  return D.21259;
  <D.21261>:
  D.21259 = 1;
  return D.21259;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.21265;
  unsigned int D.21266;
  unsigned int D.21267;
  unsigned char D.21270;
  int D.21271;
  struct MonoClass * D.21272;
  unsigned int D.21273;
  unsigned int D.21274;
  struct MonoType * D.21277;
  struct MonoClass * D.21278;
  unsigned int D.21279;
  unsigned int D.21280;
  unsigned int D.21283;
  struct MonoType * D.21286;
  struct MonoClass * D.21287;

  if (t == 0B) goto <D.21263>; else goto <D.21264>;
  <D.21263>:
  *align = 1;
  D.21265 = 0;
  return D.21265;
  <D.21264>:
  D.21266 = BIT_FIELD_REF <*t, 32, 32>;
  D.21267 = D.21266 & 1073741824;
  if (D.21267 != 0) goto <D.21268>; else goto <D.21269>;
  <D.21268>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 4;
    D.21265 = 4;
    return D.21265;
  }
  <D.21269>:
  D.21270 = t->type;
  D.21271 = (int) D.21270;
  switch (D.21271) <default: <D.18284>, case 1: <D.18216>, case 2: <D.18217>, case 3: <D.18226>, case 4: <D.18221>, case 5: <D.18222>, case 6: <D.18227>, case 7: <D.18228>, case 8: <D.18232>, case 9: <D.18233>, case 10: <D.18241>, case 11: <D.18242>, case 12: <D.18237>, case 13: <D.18246>, case 14: <D.18255>, case 15: <D.18266>, case 17: <D.18263>, case 18: <D.18264>, case 19: <D.18279>, case 20: <D.18268>, case 21: <D.18273>, case 22: <D.18272>, case 24: <D.18250>, case 25: <D.18251>, case 27: <D.18267>, case 28: <D.18259>, case 29: <D.18265>, case 30: <D.18280>>
  {
    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.18216>:
    *align = 1;
    D.21265 = 0;
    return D.21265;
    <D.18217>:
    *align = 1;
    D.21265 = 1;
    return D.21265;
    <D.18221>:
    <D.18222>:
    *align = 1;
    D.21265 = 1;
    return D.21265;
    <D.18226>:
    <D.18227>:
    <D.18228>:
    *align = 2;
    D.21265 = 2;
    return D.21265;
    <D.18232>:
    <D.18233>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18237>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18241>:
    <D.18242>:
    *align = 8;
    D.21265 = 8;
    return D.21265;
    <D.18246>:
    *align = 8;
    D.21265 = 8;
    return D.21265;
    <D.18250>:
    <D.18251>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18255>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18259>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18263>:
    D.21272 = t->data.klass;
    D.21273 = BIT_FIELD_REF <*D.21272, 32, 160>;
    D.21274 = D.21273 & 16;
    if (D.21274 != 0) goto <D.21275>; else goto <D.21276>;
    <D.21275>:
    D.21272 = t->data.klass;
    D.21277 = mono_class_enum_basetype (D.21272);
    D.21265 = mono_type_size (D.21277, align);
    return D.21265;
    <D.21276>:
    D.21272 = t->data.klass;
    D.21265 = mono_class_value_size (D.21272, align);
    return D.21265;
    <D.18264>:
    <D.18265>:
    <D.18266>:
    <D.18267>:
    <D.18268>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18272>:
    D.21278 = mono_defaults.typed_reference_class;
    D.21265 = mono_class_value_size (D.21278, align);
    return D.21265;
    <D.18273>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.21279 = BIT_FIELD_REF <*container_class, 32, 160>;
      D.21280 = D.21279 & 8;
      if (D.21280 != 0) goto <D.21281>; else goto <D.21282>;
      <D.21281>:
      D.21279 = BIT_FIELD_REF <*container_class, 32, 160>;
      D.21283 = D.21279 & 16;
      if (D.21283 != 0) goto <D.21284>; else goto <D.21285>;
      <D.21284>:
      D.21286 = mono_class_enum_basetype (container_class);
      D.21265 = mono_type_size (D.21286, align);
      return D.21265;
      <D.21285>:
      D.21287 = mono_class_from_mono_type (t);
      D.21265 = mono_class_value_size (D.21287, align);
      return D.21265;
      <D.21282>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 4;
        D.21265 = 4;
        return D.21265;
      }
    }
    <D.18279>:
    <D.18280>:
    *align = 4;
    D.21265 = 4;
    return D.21265;
    <D.18284>:
    D.21270 = t->type;
    D.21271 = (int) D.21270;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.21271);
    <D.18285>:
    goto <D.18285>;
  }
  D.21265 = 0;
  return D.21265;
}


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

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


mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.21291;
  long int D.21292;
  long int D.21293;
  unsigned int D.21298;
  unsigned int D.21299;
  int D.21302;
  unsigned char D.21303;
  int D.21304;
  _Bool D.21305;
  long int D.21306;
  long int D.21307;
  struct MonoClass * D.21310;
  unsigned int D.21311;
  unsigned int D.21312;
  struct MonoType * D.21315;
  int D.21316;
  int D.21317;
  int D.21318;
  int D.21319;
  int D.21320;
  int D.21321;
  unsigned int stack_slot_size.144;
  unsigned int D.21323;
  int D.21324;
  unsigned int D.21325;
  struct MonoGenericInst * D.21328;
  unsigned int D.21329;
  unsigned int D.21330;
  _Bool D.21331;
  long int D.21332;
  long int D.21333;
  unsigned int D.21336;
  unsigned int D.21337;
  unsigned int D.21340;
  struct MonoType * D.21343;
  struct MonoClass * D.21344;
  int D.21345;
  unsigned int D.21346;
  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.21291 = t == 0B;
      D.21292 = (long int) D.21291;
      D.21293 = __builtin_expect (D.21292, 0);
      if (D.21293 != 0) goto <D.21294>; else goto <D.21295>;
      <D.21294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.21295>:
      if (align == 0B) goto <D.21296>; else goto <D.21297>;
      <D.21296>:
      align = &tmp;
      <D.21297>:
      D.21298 = BIT_FIELD_REF <*t, 32, 32>;
      D.21299 = D.21298 & 1073741824;
      if (D.21299 != 0) goto <D.21300>; else goto <D.21301>;
      <D.21300>:
      *align = stack_slot_align;
      D.21302 = stack_slot_size;
      return D.21302;
      <D.21301>:
      D.21303 = t->type;
      D.21304 = (int) D.21303;
      switch (D.21304) <default: <D.18340>, case 2: <D.18301>, case 3: <D.18302>, case 4: <D.18303>, case 5: <D.18304>, case 6: <D.18305>, case 7: <D.18306>, case 8: <D.18307>, case 9: <D.18308>, case 10: <D.18325>, case 11: <D.18326>, case 12: <D.18321>, case 13: <D.18330>, case 14: <D.18311>, case 15: <D.18315>, case 17: <D.18334>, case 18: <D.18313>, case 19: <D.18318>, case 20: <D.18317>, case 21: <D.18336>, case 22: <D.18320>, case 24: <D.18309>, case 25: <D.18310>, case 27: <D.18316>, case 28: <D.18312>, case 29: <D.18314>, case 30: <D.18319>>
      {
        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.18301>:
        <D.18302>:
        <D.18303>:
        <D.18304>:
        <D.18305>:
        <D.18306>:
        <D.18307>:
        <D.18308>:
        <D.18309>:
        <D.18310>:
        <D.18311>:
        <D.18312>:
        <D.18313>:
        <D.18314>:
        <D.18315>:
        <D.18316>:
        <D.18317>:
        *align = stack_slot_align;
        D.21302 = stack_slot_size;
        return D.21302;
        <D.18318>:
        <D.18319>:
        D.21305 = allow_open == 0;
        D.21306 = (long int) D.21305;
        D.21307 = __builtin_expect (D.21306, 0);
        if (D.21307 != 0) goto <D.21308>; else goto <D.21309>;
        <D.21308>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.21309>:
        *align = stack_slot_align;
        D.21302 = stack_slot_size;
        return D.21302;
        <D.18320>:
        *align = stack_slot_align;
        D.21302 = stack_slot_size * 3;
        return D.21302;
        <D.18321>:
        *align = 4;
        D.21302 = 4;
        return D.21302;
        <D.18325>:
        <D.18326>:
        *align = 8;
        D.21302 = 8;
        return D.21302;
        <D.18330>:
        *align = 8;
        D.21302 = 8;
        return D.21302;
        <D.18334>:
        {
          guint32 size;

          D.21310 = t->data.klass;
          D.21311 = BIT_FIELD_REF <*D.21310, 32, 160>;
          D.21312 = D.21311 & 16;
          if (D.21312 != 0) goto <D.21313>; else goto <D.21314>;
          <D.21313>:
          D.21310 = t->data.klass;
          D.21315 = mono_class_enum_basetype (D.21310);
          D.21302 = mono_type_stack_size_internal (D.21315, align, allow_open);
          return D.21302;
          <D.21314>:
          D.21310 = t->data.klass;
          D.21316 = mono_class_value_size (D.21310, align);
          size = (guint32) D.21316;
          D.21317 = *align;
          D.21318 = D.21317 + stack_slot_align;
          D.21319 = D.21318 + -1;
          *align = D.21319;
          D.21317 = *align;
          D.21320 = -stack_slot_align;
          D.21321 = D.21317 & D.21320;
          *align = D.21321;
          stack_slot_size.144 = (unsigned int) stack_slot_size;
          D.21323 = stack_slot_size.144 + size;
          size = D.21323 + 4294967295;
          D.21324 = -stack_slot_size;
          D.21325 = (unsigned int) D.21324;
          size = D.21325 & size;
          D.21302 = (int) size;
          return D.21302;
        }
        <D.18336>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.21326>; else goto <D.21327>;
          <D.21326>:
          D.21328 = gclass->context.class_inst;
          D.21329 = BIT_FIELD_REF <*D.21328, 32, 32>;
          D.21330 = D.21329 & 4194304;
          D.21331 = D.21330 != 0;
          D.21332 = (long int) D.21331;
          D.21333 = __builtin_expect (D.21332, 0);
          if (D.21333 != 0) goto <D.21334>; else goto <D.21335>;
          <D.21334>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.21335>:
          <D.21327>:
          D.21336 = BIT_FIELD_REF <*container_class, 32, 160>;
          D.21337 = D.21336 & 8;
          if (D.21337 != 0) goto <D.21338>; else goto <D.21339>;
          <D.21338>:
          D.21336 = BIT_FIELD_REF <*container_class, 32, 160>;
          D.21340 = D.21336 & 16;
          if (D.21340 != 0) goto <D.21341>; else goto <D.21342>;
          <D.21341>:
          D.21343 = mono_class_enum_basetype (container_class);
          D.21302 = mono_type_stack_size_internal (D.21343, align, allow_open);
          return D.21302;
          <D.21342>:
          {
            guint32 size;

            D.21344 = mono_class_from_mono_type (t);
            D.21345 = mono_class_value_size (D.21344, align);
            size = (guint32) D.21345;
            D.21317 = *align;
            D.21318 = D.21317 + stack_slot_align;
            D.21319 = D.21318 + -1;
            *align = D.21319;
            D.21317 = *align;
            D.21320 = -stack_slot_align;
            D.21321 = D.21317 & D.21320;
            *align = D.21321;
            stack_slot_size.144 = (unsigned int) stack_slot_size;
            D.21346 = stack_slot_size.144 + size;
            size = D.21346 + 4294967295;
            D.21324 = -stack_slot_size;
            D.21325 = (unsigned int) D.21324;
            size = D.21325 & size;
            D.21302 = (int) size;
            return D.21302;
          }
          <D.21339>:
          *align = stack_slot_align;
          D.21302 = stack_slot_size;
          return D.21302;
        }
        <D.18340>:
        D.21303 = t->type;
        D.21304 = (int) D.21303;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.21304);
        <D.18341>:
        goto <D.18341>;
      }
      D.21302 = 0;
      return D.21302;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.21349;
  _Bool D.21350;
  long int D.21351;
  long int D.21352;
  mono_bool D.21355;
  struct MonoGenericClass * D.21356;
  struct MonoClass * D.21357;
  <unnamed-unsigned:1> D.21358;

  D.21349 = type->type;
  D.21350 = D.21349 != 21;
  D.21351 = (long int) D.21350;
  D.21352 = __builtin_expect (D.21351, 0);
  if (D.21352 != 0) goto <D.21353>; else goto <D.21354>;
  <D.21353>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.21354>:
  D.21356 = type->data.generic_class;
  D.21357 = D.21356->container_class;
  D.21358 = D.21357->valuetype;
  D.21355 = (mono_bool) D.21358;
  return D.21355;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.21360;
  struct MonoClass * D.21361;
  <unnamed-unsigned:1> D.21362;

  D.21361 = gclass->container_class;
  D.21362 = D.21361->valuetype;
  D.21360 = (mono_bool) D.21362;
  return D.21360;
}


mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21364;
  unsigned int D.21367;
  unsigned int D.21368;
  unsigned int D.21369;
  struct MonoGenericInst * D.21370;
  unsigned int D.21373;
  guint D.21374;
  guint hash;

  hash = 3223191271;
  D.21364 = context->class_inst;
  if (D.21364 != 0B) goto <D.21365>; else goto <D.21366>;
  <D.21365>:
  D.21367 = hash << 5;
  D.21368 = D.21367 - hash;
  D.21364 = context->class_inst;
  D.21369 = mono_metadata_generic_inst_hash (D.21364);
  hash = D.21368 ^ D.21369;
  <D.21366>:
  D.21370 = context->method_inst;
  if (D.21370 != 0B) goto <D.21371>; else goto <D.21372>;
  <D.21371>:
  D.21367 = hash << 5;
  D.21368 = D.21367 - hash;
  D.21370 = context->method_inst;
  D.21373 = mono_metadata_generic_inst_hash (D.21370);
  hash = D.21368 ^ D.21373;
  <D.21372>:
  D.21374 = hash;
  return D.21374;
}


mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.21376;
  int iftmp.145;
  struct MonoGenericInst * D.21380;
  struct MonoGenericInst * D.21381;
  struct MonoGenericInst * D.21383;
  struct MonoGenericInst * D.21384;

  D.21380 = g1->class_inst;
  D.21381 = g2->class_inst;
  if (D.21380 == D.21381) goto <D.21382>; else goto <D.21378>;
  <D.21382>:
  D.21383 = g1->method_inst;
  D.21384 = g2->method_inst;
  if (D.21383 == D.21384) goto <D.21385>; else goto <D.21378>;
  <D.21385>:
  iftmp.145 = 1;
  goto <D.21379>;
  <D.21378>:
  iftmp.145 = 0;
  <D.21379>:
  D.21376 = iftmp.145;
  return D.21376;
}


mono_metadata_str_hash (const void * v1)
{
  char D.21387;
  unsigned int D.21390;
  unsigned int D.21391;
  unsigned int D.21392;
  char * p.146;
  char D.21394;
  guint D.21395;
  char * p;
  guint hash;

  p = v1;
  D.21387 = *p;
  hash = (guint) D.21387;
  goto <D.18376>;
  <D.18375>:
  D.21387 = *p;
  if (D.21387 != 0) goto <D.21388>; else goto <D.21389>;
  <D.21388>:
  D.21390 = hash << 5;
  D.21391 = D.21390 - hash;
  D.21387 = *p;
  D.21392 = (unsigned int) D.21387;
  hash = D.21391 + D.21392;
  <D.21389>:
  <D.18376>:
  p.146 = p;
  p = p.146 + 1;
  D.21394 = *p.146;
  if (D.21394 != 0) goto <D.18375>; else goto <D.18377>;
  <D.18377>:
  D.21395 = hash;
  return D.21395;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.21397;
  <unnamed-unsigned:1> D.21398;
  int D.21399;
  int D.21400;
  unsigned int D.21401;
  int D.21402;
  struct MonoImage * D.21403;
  unsigned int D.21404;
  unsigned int D.21405;
  unsigned int D.21408;
  const char * D.21409;
  unsigned int D.21410;
  unsigned int D.21411;
  unsigned int D.21412;
  unsigned int D.21413;
  struct MonoType * D.21414;
  unsigned int D.21415;
  struct MonoArrayType * D.21416;
  struct MonoClass * D.21417;
  struct MonoType * D.21418;
  unsigned int D.21419;
  struct MonoGenericClass * D.21420;
  unsigned int D.21421;
  guint hash;

  D.21397 = t1->type;
  hash = (guint) D.21397;
  D.21398 = t1->byref;
  D.21399 = (int) D.21398;
  D.21400 = D.21399 << 6;
  D.21401 = (unsigned int) D.21400;
  hash = D.21401 | hash;
  D.21397 = t1->type;
  D.21402 = (int) D.21397;
  switch (D.21402) <default: <D.21422>, case 15: <D.18386>, case 17: <D.18382>, case 18: <D.18383>, case 20: <D.18387>, case 21: <D.18388>, case 29: <D.18384>>
  <D.18382>:
  <D.18383>:
  <D.18384>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.21403 = class->image;
    D.21404 = BIT_FIELD_REF <*D.21403, 32, 128>;
    D.21405 = D.21404 & 8;
    if (D.21405 != 0) goto <D.21406>; else goto <D.21407>;
    <D.21406>:
    D.21398 = t1->byref;
    D.21399 = (int) D.21398;
    D.21400 = D.21399 << 6;
    D.21401 = (unsigned int) D.21400;
    D.21409 = class->name;
    D.21410 = mono_metadata_str_hash (D.21409);
    D.21408 = D.21401 | D.21410;
    return D.21408;
    <D.21407>:
    D.21411 = hash << 5;
    D.21412 = D.21411 - hash;
    D.21409 = class->name;
    D.21413 = mono_metadata_str_hash (D.21409);
    D.21408 = D.21412 ^ D.21413;
    return D.21408;
  }
  <D.18386>:
  D.21411 = hash << 5;
  D.21412 = D.21411 - hash;
  D.21414 = t1->data.type;
  D.21415 = mono_metadata_type_hash (D.21414);
  D.21408 = D.21412 ^ D.21415;
  return D.21408;
  <D.18387>:
  D.21411 = hash << 5;
  D.21412 = D.21411 - hash;
  D.21416 = t1->data.array;
  D.21417 = D.21416->eklass;
  D.21418 = &D.21417->byval_arg;
  D.21419 = mono_metadata_type_hash (D.21418);
  D.21408 = D.21412 ^ D.21419;
  return D.21408;
  <D.18388>:
  D.21411 = hash << 5;
  D.21412 = D.21411 - hash;
  D.21420 = t1->data.generic_class;
  D.21421 = mono_generic_class_hash (D.21420);
  D.21408 = D.21412 ^ D.21421;
  return D.21408;
  <D.21422>:
  D.21408 = hash;
  return D.21408;
}


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

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


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

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


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  unsigned int D.21430;
  unsigned int D.21431;
  unsigned int D.21432;
  unsigned int D.21433;
  short unsigned int D.21435;
  short unsigned int D.21436;
  mono_bool D.21437;
  short unsigned int D.21438;
  short unsigned int D.21439;
  int D.21442;
  int D.21445;
  struct MonoType * D.21446;
  struct MonoType * D.21447;
  int D.21448;
  int i;

  D.21430 = BIT_FIELD_REF <*sig1, 32, 64>;
  D.21431 = BIT_FIELD_REF <*sig2, 32, 64>;
  D.21432 = D.21430 ^ D.21431;
  D.21433 = D.21432 & 4194304;
  if (D.21433 != 0) goto <D.21428>; else goto <D.21434>;
  <D.21434>:
  D.21435 = sig1->param_count;
  D.21436 = sig2->param_count;
  if (D.21435 != D.21436) goto <D.21428>; else goto <D.21429>;
  <D.21428>:
  D.21437 = 0;
  return D.21437;
  <D.21429>:
  D.21438 = sig1->generic_param_count;
  D.21439 = sig2->generic_param_count;
  if (D.21438 != D.21439) goto <D.21440>; else goto <D.21441>;
  <D.21440>:
  D.21437 = 0;
  return D.21437;
  <D.21441>:
  i = 0;
  goto <D.18460>;
  <D.18459>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.21442 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.21442 == 0) goto <D.21443>; else goto <D.21444>;
    <D.21443>:
    D.21437 = 0;
    return D.21437;
    <D.21444>:
  }
  i = i + 1;
  <D.18460>:
  D.21435 = sig1->param_count;
  D.21445 = (int) D.21435;
  if (D.21445 > i) goto <D.18459>; else goto <D.18461>;
  <D.18461>:
  D.21446 = sig1->ret;
  D.21447 = sig2->ret;
  D.21448 = do_mono_metadata_type_equal (D.21446, D.21447, 1);
  if (D.21448 == 0) goto <D.21449>; else goto <D.21450>;
  <D.21449>:
  D.21437 = 0;
  return D.21437;
  <D.21450>:
  D.21437 = 1;
  return D.21437;
}


mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  unsigned int D.21452;
  unsigned int D.21453;
  <unnamed-unsigned:6> D.21456;
  unsigned int D.21457;
  unsigned int D.21458;
  unsigned int sizeof_o.147;
  unsigned int D.21460;
  void * iftmp.148;
  unsigned int sizeof_o.149;
  unsigned int sizeof_o.150;
  unsigned int sizeof_o.151;
  unsigned char D.21468;
  struct MonoType * D.21471;
  struct MonoType * D.21472;
  struct MonoArrayType * D.21476;
  struct MonoArrayType * D.21477;
  struct MonoMethodSignature * D.21481;
  struct MonoMethodSignature * D.21482;
  struct MonoType * D.21483;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 8;
  D.21452 = BIT_FIELD_REF <*o, 32, 32>;
  D.21453 = D.21452 & 1056964608;
  if (D.21453 != 0) goto <D.21454>; else goto <D.21455>;
  <D.21454>:
  D.21456 = o->num_mods;
  D.21457 = (unsigned int) D.21456;
  D.21458 = D.21457 * 4;
  sizeof_o.147 = (unsigned int) sizeof_o;
  D.21460 = D.21458 + sizeof_o.147;
  sizeof_o = (int) D.21460;
  <D.21455>:
  if (image != 0B) goto <D.21462>; else goto <D.21463>;
  <D.21462>:
  sizeof_o.149 = (unsigned int) sizeof_o;
  iftmp.148 = mono_image_alloc0 (image, sizeof_o.149);
  goto <D.21465>;
  <D.21463>:
  sizeof_o.150 = (unsigned int) sizeof_o;
  iftmp.148 = monoeg_malloc (sizeof_o.150);
  <D.21465>:
  r = iftmp.148;
  sizeof_o.151 = (unsigned int) sizeof_o;
  memcpy (r, o, sizeof_o.151);
  D.21468 = o->type;
  if (D.21468 == 15) goto <D.21469>; else goto <D.21470>;
  <D.21469>:
  D.21471 = o->data.type;
  D.21472 = mono_metadata_type_dup (image, D.21471);
  r->data.type = D.21472;
  goto <D.21473>;
  <D.21470>:
  D.21468 = o->type;
  if (D.21468 == 20) goto <D.21474>; else goto <D.21475>;
  <D.21474>:
  D.21476 = o->data.array;
  D.21477 = mono_dup_array_type (image, D.21476);
  r->data.array = D.21477;
  goto <D.21478>;
  <D.21475>:
  D.21468 = o->type;
  if (D.21468 == 27) goto <D.21479>; else goto <D.21480>;
  <D.21479>:
  D.21481 = o->data.method;
  D.21482 = mono_metadata_signature_deep_dup (image, D.21481);
  r->data.method = D.21482;
  <D.21480>:
  <D.21478>:
  <D.21473>:
  D.21483 = r;
  return D.21483;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.21485;
  unsigned char D.21486;
  unsigned int D.21487;
  unsigned int D.21488;
  struct MonoType * D.21489;
  unsigned int D.21490;
  short unsigned int D.21491;
  unsigned int D.21492;
  unsigned int D.21493;
  guint i;
  guint res;

  D.21485 = sig->ret;
  D.21486 = D.21485->type;
  res = (guint) D.21486;
  i = 0;
  goto <D.18474>;
  <D.18473>:
  D.21487 = res << 5;
  D.21488 = D.21487 - res;
  D.21489 = sig->params[i];
  D.21490 = mono_type_hash (D.21489);
  res = D.21488 + D.21490;
  i = i + 1;
  <D.18474>:
  D.21491 = sig->param_count;
  D.21492 = (unsigned int) D.21491;
  if (D.21492 > i) goto <D.18473>; else goto <D.18475>;
  <D.18475>:
  D.21493 = res;
  return D.21493;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.152;
  char D.21498;
  unsigned int D.21502;
  unsigned char D.21503;
  unsigned char D.21504;
  char D.21505;
  char * D.21506;
  char D.21507;
  unsigned int D.21509;
  unsigned char D.21510;
  unsigned char D.21511;
  char D.21512;
  unsigned int D.21513;
  char D.21514;
  char * D.21515;
  char D.21516;
  char * D.21517;
  char * p;

  p = buf;
  if (value <= 127) goto <D.21495>; else goto <D.21496>;
  <D.21495>:
  p.152 = p;
  p = p.152 + 1;
  D.21498 = (char) value;
  *p.152 = D.21498;
  goto <D.21499>;
  <D.21496>:
  if (value <= 16383) goto <D.21500>; else goto <D.21501>;
  <D.21500>:
  D.21502 = value >> 8;
  D.21503 = (unsigned char) D.21502;
  D.21504 = D.21503 | 128;
  D.21505 = (char) D.21504;
  *p = D.21505;
  D.21506 = p + 1;
  D.21507 = (char) value;
  *D.21506 = D.21507;
  p = p + 2;
  goto <D.21508>;
  <D.21501>:
  D.21509 = value >> 24;
  D.21510 = (unsigned char) D.21509;
  D.21511 = D.21510 | 192;
  D.21512 = (char) D.21511;
  *p = D.21512;
  D.21506 = p + 1;
  D.21513 = value >> 16;
  D.21514 = (char) D.21513;
  *D.21506 = D.21514;
  D.21515 = p + 2;
  D.21502 = value >> 8;
  D.21516 = (char) D.21502;
  *D.21515 = D.21516;
  D.21517 = p + 3;
  D.21507 = (char) value;
  *D.21517 = D.21507;
  p = p + 4;
  <D.21508>:
  <D.21499>:
  if (endbuf != 0B) goto <D.21518>; else goto <D.21519>;
  <D.21518>:
  *endbuf = p;
  <D.21519>:
}


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.21520;
  int D.21521;
  unsigned int D.21522;
  unsigned int D.21523;
  int D.21526;
  unsigned int D.21527;
  int D.21528;
  const char * D.21533;
  <unnamed-unsigned:24> D.21535;
  unsigned int D.21536;
  unsigned char D.21537;
  unsigned int D.21538;
  void * D.21539;
  unsigned int D.21541;
  int D.21542;
  unsigned int D.21543;
  void * D.21549;
  unsigned int D.21551;
  struct MonoImage * iftmp.153;
  struct MonoMarshalSpec * D.21560;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.21520 = index + 1;
      D.21521 = (int) D.21520;
      loc.idx = D.21521;
      D.21522 = BIT_FIELD_REF <*meta, 32, 128>;
      D.21523 = D.21522 & 32;
      if (D.21523 != 0) goto <D.21524>; else goto <D.21525>;
      <D.21524>:
      D.21526 = loc.idx;
      D.21527 = search_ptr_table (meta, 3, D.21526);
      D.21528 = (int) D.21527;
      loc.idx = D.21528;
      <D.21525>:
      if (offset != 0B) goto <D.21529>; else goto <D.21530>;
      <D.21529>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21533 = tdef->base;
      if (D.21533 != 0B) goto <D.21534>; else goto <D.21531>;
      <D.21534>:
      D.21533 = tdef->base;
      D.21535 = tdef->rows;
      D.21536 = (unsigned int) D.21535;
      D.21537 = tdef->row_size;
      D.21538 = (unsigned int) D.21537;
      D.21539 = mono_binary_search (&loc, D.21533, D.21536, D.21538, table_locator);
      if (D.21539 != 0B) goto <D.21540>; else goto <D.21531>;
      <D.21540>:
      D.21541 = loc.result;
      D.21542 = (int) D.21541;
      D.21543 = mono_metadata_decode_row_col (tdef, D.21542, 0);
      *offset = D.21543;
      goto <D.21532>;
      <D.21531>:
      *offset = 4294967295;
      <D.21532>:
      <D.21530>:
      if (rva != 0B) goto <D.21544>; else goto <D.21545>;
      <D.21544>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.21533 = tdef->base;
      if (D.21533 != 0B) goto <D.21548>; else goto <D.21546>;
      <D.21548>:
      D.21533 = tdef->base;
      D.21535 = tdef->rows;
      D.21536 = (unsigned int) D.21535;
      D.21537 = tdef->row_size;
      D.21538 = (unsigned int) D.21537;
      D.21549 = mono_binary_search (&loc, D.21533, D.21536, D.21538, table_locator);
      if (D.21549 != 0B) goto <D.21550>; else goto <D.21546>;
      <D.21550>:
      D.21541 = loc.result;
      D.21542 = (int) D.21541;
      D.21551 = mono_metadata_decode_row_col (tdef, D.21542, 0);
      *rva = D.21551;
      goto <D.21547>;
      <D.21546>:
      *rva = 0;
      <D.21547>:
      <D.21545>:
      if (marshal_spec != 0B) goto <D.21552>; else goto <D.21553>;
      <D.21552>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.21554>; else goto <D.21555>;
        <D.21554>:
        if (alloc_from_image != 0) goto <D.21557>; else goto <D.21558>;
        <D.21557>:
        iftmp.153 = meta;
        goto <D.21559>;
        <D.21558>:
        iftmp.153 = 0B;
        <D.21559>:
        D.21560 = mono_metadata_parse_marshal_spec_full (iftmp.153, p);
        *marshal_spec = D.21560;
        <D.21555>:
      }
      <D.21553>:
    }
  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.21561;
  uint32_t D.21562;
  int index.154;
  <unnamed-unsigned:24> D.21566;
  unsigned int D.21567;
  unsigned int D.21570;
  int D.21571;
  unsigned int D.21572;
  const char * D.21575;
  unsigned int D.21578;
  unsigned char D.21579;
  unsigned int D.21580;
  void * D.21581;
  unsigned int D.21584;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.21561 = token >> 24;
      switch (D.21561) <default: <D.18519>, case 4: <D.18515>, case 8: <D.18517>, case 23: <D.18518>>
      <D.18515>:
      index = index;
      goto <D.18516>;
      <D.18517>:
      index = index | 1;
      goto <D.18516>;
      <D.18518>:
      index = index | 2;
      goto <D.18516>;
      <D.18519>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.21562 = 0;
      return D.21562;
      <D.18516>:
      index.154 = (int) index;
      loc.idx = index.154;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.21564>; else goto <D.21565>;
      <D.21564>:
      D.21566 = tdef->rows;
      D.21567 = (unsigned int) D.21566;
      if (D.21567 > hint) goto <D.21568>; else goto <D.21569>;
      <D.21568>:
      D.21570 = hint + 4294967295;
      D.21571 = (int) D.21570;
      D.21572 = mono_metadata_decode_row_col (tdef, D.21571, 2);
      if (D.21572 == index) goto <D.21573>; else goto <D.21574>;
      <D.21573>:
      D.21562 = hint;
      return D.21562;
      <D.21574>:
      <D.21569>:
      <D.21565>:
      D.21575 = tdef->base;
      if (D.21575 != 0B) goto <D.21576>; else goto <D.21577>;
      <D.21576>:
      D.21575 = tdef->base;
      D.21566 = tdef->rows;
      D.21578 = (unsigned int) D.21566;
      D.21579 = tdef->row_size;
      D.21580 = (unsigned int) D.21579;
      D.21581 = mono_binary_search (&loc, D.21575, D.21578, D.21580, table_locator);
      if (D.21581 != 0B) goto <D.21582>; else goto <D.21583>;
      <D.21582>:
      D.21584 = loc.result;
      D.21562 = D.21584 + 1;
      return D.21562;
      <D.21583>:
      <D.21577>:
      D.21562 = 0;
      return D.21562;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21587;
  uint32_t D.21590;
  unsigned int D.21591;
  int D.21592;
  <unnamed-unsigned:24> D.21593;
  unsigned int D.21594;
  unsigned char D.21595;
  unsigned int D.21596;
  void * D.21597;
  unsigned int D.21600;
  int D.21601;
  unsigned int D.21602;
  unsigned int D.21603;
  int D.21606;
  unsigned int D.21607;
  <unnamed-unsigned:24> D.21609;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.21587 = tdef->base;
      if (D.21587 == 0B) goto <D.21588>; else goto <D.21589>;
      <D.21588>:
      D.21590 = 0;
      return D.21590;
      <D.21589>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21591 = index + 1;
      D.21592 = (int) D.21591;
      loc.idx = D.21592;
      D.21587 = tdef->base;
      D.21593 = tdef->rows;
      D.21594 = (unsigned int) D.21593;
      D.21595 = tdef->row_size;
      D.21596 = (unsigned int) D.21595;
      D.21597 = mono_binary_search (&loc, D.21587, D.21594, D.21596, table_locator);
      if (D.21597 == 0B) goto <D.21598>; else goto <D.21599>;
      <D.21598>:
      D.21590 = 0;
      return D.21590;
      <D.21599>:
      D.21600 = loc.result;
      D.21601 = (int) D.21600;
      start = mono_metadata_decode_row_col (tdef, D.21601, 1);
      D.21600 = loc.result;
      D.21602 = D.21600 + 1;
      D.21593 = tdef->rows;
      D.21603 = (unsigned int) D.21593;
      if (D.21602 < D.21603) goto <D.21604>; else goto <D.21605>;
      <D.21604>:
      D.21600 = loc.result;
      D.21602 = D.21600 + 1;
      D.21606 = (int) D.21602;
      D.21607 = mono_metadata_decode_row_col (tdef, D.21606, 1);
      end = D.21607 + 4294967295;
      goto <D.21608>;
      <D.21605>:
      D.21609 = meta->tables[20].rows;
      end = (guint32) D.21609;
      <D.21608>:
      *end_idx = end;
      D.21590 = start + 4294967295;
      return D.21590;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21612;
  uint32_t D.21615;
  unsigned int D.21616;
  unsigned int D.21617;
  unsigned int D.21620;
  int D.21621;
  unsigned int D.21622;
  unsigned int D.21623;
  int D.21624;
  <unnamed-unsigned:24> D.21625;
  unsigned int D.21626;
  unsigned char D.21627;
  unsigned int D.21628;
  void * D.21629;
  int D.21632;
  unsigned int D.21633;
  unsigned int D.21634;
  int D.21635;
  unsigned int D.21636;
  int end.155;
  unsigned int D.21639;
  unsigned int D.21640;
  unsigned int D.21642;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.21612 = msemt->base;
      if (D.21612 == 0B) goto <D.21613>; else goto <D.21614>;
      <D.21613>:
      D.21615 = 0;
      return D.21615;
      <D.21614>:
      D.21616 = BIT_FIELD_REF <*meta, 32, 128>;
      D.21617 = D.21616 & 32;
      if (D.21617 != 0) goto <D.21618>; else goto <D.21619>;
      <D.21618>:
      D.21620 = index + 1;
      D.21621 = (int) D.21620;
      D.21622 = search_ptr_table (meta, 19, D.21621);
      index = D.21622 + 4294967295;
      <D.21619>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.21620 = index + 1;
      D.21623 = D.21620 << 1;
      D.21624 = (int) D.21623;
      loc.idx = D.21624;
      D.21612 = msemt->base;
      D.21625 = msemt->rows;
      D.21626 = (unsigned int) D.21625;
      D.21627 = msemt->row_size;
      D.21628 = (unsigned int) D.21627;
      D.21629 = mono_binary_search (&loc, D.21612, D.21626, D.21628, table_locator);
      if (D.21629 == 0B) goto <D.21630>; else goto <D.21631>;
      <D.21630>:
      D.21615 = 0;
      return D.21615;
      <D.21631>:
      start = loc.result;
      goto <D.18541>;
      <D.18540>:
      D.21632 = loc.idx;
      D.21633 = (unsigned int) D.21632;
      D.21634 = start + 4294967295;
      D.21635 = (int) D.21634;
      D.21636 = mono_metadata_decode_row_col (msemt, D.21635, 2);
      if (D.21633 == D.21636) goto <D.21637>; else goto <D.18539>;
      <D.21637>:
      start = start + 4294967295;
      <D.18541>:
      if (start != 0) goto <D.18540>; else goto <D.18539>;
      <D.18539>:
      end = start + 1;
      goto <D.18544>;
      <D.18543>:
      end.155 = (int) end;
      mono_metadata_decode_row (msemt, end.155, &cols, 3);
      D.21639 = cols[2];
      D.21632 = loc.idx;
      D.21640 = (unsigned int) D.21632;
      if (D.21639 != D.21640) goto <D.18542>; else goto <D.21641>;
      <D.21641>:
      end = end + 1;
      <D.18544>:
      D.21625 = msemt->rows;
      D.21642 = (unsigned int) D.21625;
      if (D.21642 > end) goto <D.18543>; else goto <D.18542>;
      <D.18542>:
      *end_idx = end;
      D.21615 = start;
      return D.21615;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21645;
  uint32_t D.21648;
  unsigned int D.21649;
  int D.21650;
  <unnamed-unsigned:24> D.21651;
  unsigned int D.21652;
  unsigned char D.21653;
  unsigned int D.21654;
  void * D.21655;
  unsigned int D.21658;
  int D.21659;
  unsigned int D.21660;
  unsigned int D.21661;
  int D.21664;
  unsigned int D.21665;
  <unnamed-unsigned:24> D.21667;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[21];
      *end_idx = 0;
      D.21645 = tdef->base;
      if (D.21645 == 0B) goto <D.21646>; else goto <D.21647>;
      <D.21646>:
      D.21648 = 0;
      return D.21648;
      <D.21647>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21649 = index + 1;
      D.21650 = (int) D.21649;
      loc.idx = D.21650;
      D.21645 = tdef->base;
      D.21651 = tdef->rows;
      D.21652 = (unsigned int) D.21651;
      D.21653 = tdef->row_size;
      D.21654 = (unsigned int) D.21653;
      D.21655 = mono_binary_search (&loc, D.21645, D.21652, D.21654, table_locator);
      if (D.21655 == 0B) goto <D.21656>; else goto <D.21657>;
      <D.21656>:
      D.21648 = 0;
      return D.21648;
      <D.21657>:
      D.21658 = loc.result;
      D.21659 = (int) D.21658;
      start = mono_metadata_decode_row_col (tdef, D.21659, 1);
      D.21658 = loc.result;
      D.21660 = D.21658 + 1;
      D.21651 = tdef->rows;
      D.21661 = (unsigned int) D.21651;
      if (D.21660 < D.21661) goto <D.21662>; else goto <D.21663>;
      <D.21662>:
      D.21658 = loc.result;
      D.21660 = D.21658 + 1;
      D.21664 = (int) D.21660;
      D.21665 = mono_metadata_decode_row_col (tdef, D.21664, 1);
      end = D.21665 + 4294967295;
      goto <D.21666>;
      <D.21663>:
      D.21667 = meta->tables[23].rows;
      end = (guint32) D.21667;
      <D.21666>:
      *end_idx = end;
      D.21648 = start + 4294967295;
      return D.21648;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.21670;
  uint32_t D.21673;
  unsigned int D.21674;
  unsigned int D.21675;
  unsigned int D.21678;
  int D.21679;
  unsigned int D.21680;
  unsigned int D.21681;
  unsigned int D.21682;
  int D.21683;
  <unnamed-unsigned:24> D.21684;
  unsigned int D.21685;
  unsigned char D.21686;
  unsigned int D.21687;
  void * D.21688;
  int D.21691;
  unsigned int D.21692;
  unsigned int D.21693;
  int D.21694;
  unsigned int D.21695;
  int end.156;
  unsigned int D.21698;
  unsigned int D.21699;
  unsigned int D.21701;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.21670 = msemt->base;
      if (D.21670 == 0B) goto <D.21671>; else goto <D.21672>;
      <D.21671>:
      D.21673 = 0;
      return D.21673;
      <D.21672>:
      D.21674 = BIT_FIELD_REF <*meta, 32, 128>;
      D.21675 = D.21674 & 32;
      if (D.21675 != 0) goto <D.21676>; else goto <D.21677>;
      <D.21676>:
      D.21678 = index + 1;
      D.21679 = (int) D.21678;
      D.21680 = search_ptr_table (meta, 22, D.21679);
      index = D.21680 + 4294967295;
      <D.21677>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.21678 = index + 1;
      D.21681 = D.21678 << 1;
      D.21682 = D.21681 | 1;
      D.21683 = (int) D.21682;
      loc.idx = D.21683;
      D.21670 = msemt->base;
      D.21684 = msemt->rows;
      D.21685 = (unsigned int) D.21684;
      D.21686 = msemt->row_size;
      D.21687 = (unsigned int) D.21686;
      D.21688 = mono_binary_search (&loc, D.21670, D.21685, D.21687, table_locator);
      if (D.21688 == 0B) goto <D.21689>; else goto <D.21690>;
      <D.21689>:
      D.21673 = 0;
      return D.21673;
      <D.21690>:
      start = loc.result;
      goto <D.18566>;
      <D.18565>:
      D.21691 = loc.idx;
      D.21692 = (unsigned int) D.21691;
      D.21693 = start + 4294967295;
      D.21694 = (int) D.21693;
      D.21695 = mono_metadata_decode_row_col (msemt, D.21694, 2);
      if (D.21692 == D.21695) goto <D.21696>; else goto <D.18564>;
      <D.21696>:
      start = start + 4294967295;
      <D.18566>:
      if (start != 0) goto <D.18565>; else goto <D.18564>;
      <D.18564>:
      end = start + 1;
      goto <D.18569>;
      <D.18568>:
      end.156 = (int) end;
      mono_metadata_decode_row (msemt, end.156, &cols, 3);
      D.21698 = cols[2];
      D.21691 = loc.idx;
      D.21699 = (unsigned int) D.21691;
      if (D.21698 != D.21699) goto <D.18567>; else goto <D.21700>;
      <D.21700>:
      end = end + 1;
      <D.18569>:
      D.21684 = msemt->rows;
      D.21701 = (unsigned int) D.21684;
      if (D.21701 > end) goto <D.18568>; else goto <D.18567>;
      <D.18567>:
      *end_idx = end;
      D.21673 = start;
      return D.21673;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.21704;
  uint32_t D.21707;
  unsigned int D.21708;
  unsigned int D.21709;
  unsigned int D.21710;
  int D.21711;
  <unnamed-unsigned:24> D.21712;
  unsigned int D.21713;
  unsigned char D.21714;
  unsigned int D.21715;
  void * D.21716;
  unsigned int D.21719;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.21704 = tdef->base;
      if (D.21704 == 0B) goto <D.21705>; else goto <D.21706>;
      <D.21705>:
      D.21707 = 0;
      return D.21707;
      <D.21706>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.21708 = method_idx + 1;
      D.21709 = D.21708 << 1;
      D.21710 = D.21709 | 1;
      D.21711 = (int) D.21710;
      loc.idx = D.21711;
      D.21704 = tdef->base;
      D.21712 = tdef->rows;
      D.21713 = (unsigned int) D.21712;
      D.21714 = tdef->row_size;
      D.21715 = (unsigned int) D.21714;
      D.21716 = mono_binary_search (&loc, D.21704, D.21713, D.21715, table_locator);
      if (D.21716 == 0B) goto <D.21717>; else goto <D.21718>;
      <D.21717>:
      D.21707 = 0;
      return D.21707;
      <D.21718>:
      D.21719 = loc.result;
      D.21707 = D.21719 + 1;
      return D.21707;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  struct GHashTable * D.21722;
  const void * type_spec.157;
  struct MonoType * D.21726;
  unsigned int D.21727;
  int D.21728;
  unsigned int D.21729;
  const char * ptr.158;
  int D.21731;
  const char * ptr.159;
  void * type_spec.160;
  guint32 idx;
  struct MonoTableInfo * t;
  guint32 cols[1];
  const char * ptr;
  guint32 len;
  struct MonoType * type;
  struct MonoType * type2;

  try
    {
      idx = type_spec & 16777215;
      mono_loader_lock ();
      D.21722 = image->typespec_cache;
      type_spec.157 = (const void *) type_spec;
      type = monoeg_g_hash_table_lookup (D.21722, type_spec.157);
      if (type != 0B) goto <D.21724>; else goto <D.21725>;
      <D.21724>:
      mono_loader_unlock ();
      D.21726 = type;
      return D.21726;
      <D.21725>:
      t = &image->tables[27];
      D.21727 = idx + 4294967295;
      D.21728 = (int) D.21727;
      mono_metadata_decode_row (t, D.21728, &cols, 1);
      D.21729 = cols[0];
      ptr.158 = mono_metadata_blob_heap (image, D.21729);
      ptr = ptr.158;
      D.21729 = cols[0];
      D.21731 = mono_verifier_verify_typespec_signature (image, D.21729, type_spec, 0B);
      if (D.21731 == 0) goto <D.21732>; else goto <D.21733>;
      <D.21732>:
      mono_loader_unlock ();
      D.21726 = 0B;
      return D.21726;
      <D.21733>:
      ptr.159 = ptr;
      len = mono_metadata_decode_value (ptr.159, &ptr);
      ptr.159 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.159, &ptr);
      if (type == 0B) goto <D.21735>; else goto <D.21736>;
      <D.21735>:
      mono_loader_unlock ();
      D.21726 = 0B;
      return D.21726;
      <D.21736>:
      D.21722 = image->typespec_cache;
      type_spec.157 = (const void *) type_spec;
      type2 = monoeg_g_hash_table_lookup (D.21722, type_spec.157);
      if (type2 != 0B) goto <D.21737>; else goto <D.21738>;
      <D.21737>:
      mono_loader_unlock ();
      D.21726 = type2;
      return D.21726;
      <D.21738>:
      type2 = mono_metadata_type_dup (image, type);
      D.21722 = image->typespec_cache;
      type_spec.160 = (void *) type_spec;
      monoeg_g_hash_table_insert_replace (D.21722, type_spec.160, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.21726 = type2;
      return D.21726;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.161;
  unsigned int D.21748;
  const char * ptr.162;
  const char * ptr.163;
  char D.21751;
  <unnamed type> D.21752;
  <unnamed type> D.21753;
  int ptr.164;
  int start.165;
  int D.21758;
  const char * ptr.166;
  const char * ptr.167;
  char D.21763;
  <unnamed type> D.21764;
  unsigned int D.21767;
  short int D.21768;
  unsigned int D.21771;
  int D.21772;
  unsigned int D.21775;
  short int D.21776;
  unsigned int D.21781;
  int D.21782;
  unsigned int D.21787;
  int D.21788;
  unsigned int D.21791;
  sizetype len.168;
  const char * ptr.169;
  unsigned int D.21794;
  unsigned int D.21795;
  unsigned int len.170;
  char * D.21797;
  unsigned int D.21798;
  char * D.21799;
  const char * ptr.171;
  const char * ptr.172;
  char D.21806;
  <unnamed type> D.21807;
  const char * ptr.173;
  const char * ptr.174;
  char D.21812;
  int D.21813;
  struct MonoMarshalSpec * D.21814;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.21744>; else goto <D.21745>;
  <D.21744>:
  res = mono_image_alloc0 (image, 16);
  goto <D.21746>;
  <D.21745>:
  res = monoeg_malloc0 (16);
  <D.21746>:
  ptr.161 = ptr;
  D.21748 = mono_metadata_decode_value (ptr.161, &ptr);
  len = (int) D.21748;
  ptr.161 = ptr;
  ptr.162 = ptr.161;
  ptr.163 = ptr.162 + 1;
  ptr = ptr.163;
  D.21751 = *ptr.162;
  D.21752 = (<unnamed type>) D.21751;
  res->native = D.21752;
  D.21753 = res->native;
  if (D.21753 == 42) goto <D.21754>; else goto <D.21755>;
  <D.21754>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21759>; else goto <D.21760>;
  <D.21759>:
  ptr.161 = ptr;
  ptr.166 = ptr.161;
  ptr.167 = ptr.166 + 1;
  ptr = ptr.167;
  D.21763 = *ptr.166;
  D.21764 = (<unnamed type>) D.21763;
  res->data.array_data.elem_type = D.21764;
  <D.21760>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21765>; else goto <D.21766>;
  <D.21765>:
  ptr.161 = ptr;
  D.21767 = mono_metadata_decode_value (ptr.161, &ptr);
  D.21768 = (short int) D.21767;
  res->data.array_data.param_num = D.21768;
  <D.21766>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21769>; else goto <D.21770>;
  <D.21769>:
  ptr.161 = ptr;
  D.21771 = mono_metadata_decode_value (ptr.161, &ptr);
  D.21772 = (int) D.21771;
  res->data.array_data.num_elem = D.21772;
  <D.21770>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21773>; else goto <D.21774>;
  <D.21773>:
  ptr.161 = ptr;
  D.21775 = mono_metadata_decode_value (ptr.161, &ptr);
  D.21776 = (short int) D.21775;
  res->data.array_data.elem_mult = D.21776;
  <D.21774>:
  <D.21755>:
  D.21753 = res->native;
  if (D.21753 == 23) goto <D.21777>; else goto <D.21778>;
  <D.21777>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21779>; else goto <D.21780>;
  <D.21779>:
  ptr.161 = ptr;
  D.21781 = mono_metadata_decode_value (ptr.161, &ptr);
  D.21782 = (int) D.21781;
  res->data.array_data.num_elem = D.21782;
  <D.21780>:
  <D.21778>:
  D.21753 = res->native;
  if (D.21753 == 30) goto <D.21783>; else goto <D.21784>;
  <D.21783>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21785>; else goto <D.21786>;
  <D.21785>:
  ptr.161 = ptr;
  D.21787 = mono_metadata_decode_value (ptr.161, &ptr);
  D.21788 = (int) D.21787;
  res->data.array_data.num_elem = D.21788;
  <D.21786>:
  <D.21784>:
  D.21753 = res->native;
  if (D.21753 == 44) goto <D.21789>; else goto <D.21790>;
  <D.21789>:
  ptr.161 = ptr;
  D.21791 = mono_metadata_decode_value (ptr.161, &ptr);
  len = (int) D.21791;
  ptr.161 = ptr;
  len.168 = (sizetype) len;
  ptr.169 = ptr.161 + len.168;
  ptr = ptr.169;
  ptr.161 = ptr;
  D.21794 = mono_metadata_decode_value (ptr.161, &ptr);
  len = (int) D.21794;
  ptr.161 = ptr;
  len.168 = (sizetype) len;
  ptr.169 = ptr.161 + len.168;
  ptr = ptr.169;
  ptr.161 = ptr;
  D.21795 = mono_metadata_decode_value (ptr.161, &ptr);
  len = (int) D.21795;
  ptr.161 = ptr;
  len.170 = (unsigned int) len;
  D.21797 = mono_image_strndup (image, ptr.161, len.170);
  res->data.custom_data.custom_name = D.21797;
  ptr.161 = ptr;
  len.168 = (sizetype) len;
  ptr.169 = ptr.161 + len.168;
  ptr = ptr.169;
  ptr.161 = ptr;
  D.21798 = mono_metadata_decode_value (ptr.161, &ptr);
  len = (int) D.21798;
  ptr.161 = ptr;
  len.170 = (unsigned int) len;
  D.21799 = mono_image_strndup (image, ptr.161, len.170);
  res->data.custom_data.cookie = D.21799;
  <D.21790>:
  D.21753 = res->native;
  if (D.21753 == 29) goto <D.21800>; else goto <D.21801>;
  <D.21800>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21802>; else goto <D.21803>;
  <D.21802>:
  ptr.161 = ptr;
  ptr.171 = ptr.161;
  ptr.172 = ptr.171 + 1;
  ptr = ptr.172;
  D.21806 = *ptr.171;
  D.21807 = (<unnamed type>) D.21806;
  res->data.safearray_data.elem_type = D.21807;
  <D.21803>:
  ptr.161 = ptr;
  ptr.164 = (int) ptr.161;
  start.165 = (int) start;
  D.21758 = ptr.164 - start.165;
  if (D.21758 <= len) goto <D.21808>; else goto <D.21809>;
  <D.21808>:
  ptr.161 = ptr;
  ptr.173 = ptr.161;
  ptr.174 = ptr.173 + 1;
  ptr = ptr.174;
  D.21812 = *ptr.173;
  D.21813 = (int) D.21812;
  res->data.safearray_data.num_elem = D.21813;
  <D.21809>:
  <D.21801>:
  D.21814 = res;
  return D.21814;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.21818;
  unsigned int D.21819;
  char * D.21820;
  char * res;

  if (image == 0B) goto <D.21816>; else goto <D.21817>;
  <D.21816>:
  D.21818 = monoeg_g_strndup (data, len);
  return D.21818;
  <D.21817>:
  D.21819 = len + 1;
  res = mono_image_alloc (image, D.21819);
  memcpy (res, data, len);
  D.21820 = res + len;
  *D.21820 = 0;
  D.21818 = res;
  return D.21818;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.21822;
  char * D.21825;
  char * D.21826;

  D.21822 = spec->native;
  if (D.21822 == 44) goto <D.21823>; else goto <D.21824>;
  <D.21823>:
  D.21825 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.21825);
  D.21826 = spec->data.custom_data.cookie;
  monoeg_g_free (D.21826);
  <D.21824>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.21827;
  unsigned int D.21830;
  unsigned int D.21831;
  uint32_t D.21834;
  <unnamed type> D.21837;
  uint32_t iftmp.175;
  struct MonoClass * D.21851;
  unsigned int D.21852;
  unsigned int D.21853;
  struct MonoType * D.21856;
  unsigned char D.21857;
  struct MonoClass * D.21858;
  struct MonoClass * D.21865;
  struct MonoClass * D.21866;
  struct MonoClass * D.21875;
  struct MonoClass * D.21877;
  struct MonoClass * D.21879;
  struct MonoClass * D.21886;
  struct MonoGenericClass * D.21891;
  struct MonoClass * D.21892;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.21827 = type->type;
      t = (int) D.21827;
      if (conv == 0B) goto <D.21828>; else goto <D.21829>;
      <D.21828>:
      conv = &dummy_conv;
      <D.21829>:
      *conv = 0;
      D.21830 = BIT_FIELD_REF <*type, 32, 32>;
      D.21831 = D.21830 & 1073741824;
      if (D.21831 != 0) goto <D.21832>; else goto <D.21833>;
      <D.21832>:
      D.21834 = 32;
      return D.21834;
      <D.21833>:
      handle_enum:
      switch (t) <default: <D.18673>, case 2: <D.18617>, case 3: <D.18624>, case 4: <D.18629>, case 5: <D.18630>, case 6: <D.18631>, case 7: <D.18632>, case 8: <D.18633>, case 9: <D.18634>, case 10: <D.18635>, case 11: <D.18636>, case 12: <D.18637>, case 13: <D.18638>, case 14: <D.18639>, case 15: <D.18649>, case 17: <D.18650>, case 18: <D.18660>, case 20: <D.18652>, case 21: <D.18671>, case 22: <D.18672>, case 24: <D.18658>, case 25: <D.18659>, case 27: <D.18670>, case 28: <D.18661>, case 29: <D.18651>>
      <D.18617>:
      if (mspec != 0B) goto <D.21835>; else goto <D.21836>;
      <D.21835>:
      D.21837 = mspec->native;
      switch (D.21837) <default: <D.18622>, case 2: <D.18619>, case 3: <D.18620>, case 4: <D.18621>, case 37: <D.18618>>
      <D.18618>:
      *conv = 1;
      D.21834 = 37;
      return D.21834;
      <D.18619>:
      *conv = 2;
      D.21834 = 2;
      return D.21834;
      <D.18620>:
      <D.18621>:
      D.21834 = mspec->native;
      return D.21834;
      <D.18622>:
      D.21837 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.21837);
      <D.18623>:
      goto <D.18623>;
      <D.21836>:
      *conv = 2;
      D.21834 = 2;
      return D.21834;
      <D.18624>:
      if (mspec != 0B) goto <D.21838>; else goto <D.21839>;
      <D.21838>:
      D.21837 = mspec->native;
      switch (D.21837) <default: <D.18627>, case 4: <D.18626>, case 6: <D.18625>>
      <D.18625>:
      <D.18626>:
      D.21834 = mspec->native;
      return D.21834;
      <D.18627>:
      D.21837 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.21837);
      <D.18628>:
      goto <D.18628>;
      <D.21839>:
      if (unicode != 0) goto <D.21841>; else goto <D.21842>;
      <D.21841>:
      iftmp.175 = 6;
      goto <D.21843>;
      <D.21842>:
      iftmp.175 = 4;
      <D.21843>:
      D.21834 = iftmp.175;
      return D.21834;
      <D.18629>:
      D.21834 = 3;
      return D.21834;
      <D.18630>:
      D.21834 = 4;
      return D.21834;
      <D.18631>:
      D.21834 = 5;
      return D.21834;
      <D.18632>:
      D.21834 = 6;
      return D.21834;
      <D.18633>:
      D.21834 = 7;
      return D.21834;
      <D.18634>:
      D.21834 = 8;
      return D.21834;
      <D.18635>:
      D.21834 = 9;
      return D.21834;
      <D.18636>:
      D.21834 = 10;
      return D.21834;
      <D.18637>:
      D.21834 = 11;
      return D.21834;
      <D.18638>:
      D.21834 = 12;
      return D.21834;
      <D.18639>:
      if (mspec != 0B) goto <D.21844>; else goto <D.21845>;
      <D.21844>:
      D.21837 = mspec->native;
      switch (D.21837) <default: <D.18647>, case 19: <D.18640>, case 20: <D.18641>, case 21: <D.18642>, case 22: <D.18643>, case 23: <D.18646>, case 35: <D.18644>, case 36: <D.18645>>
      <D.18640>:
      *conv = 3;
      D.21834 = 19;
      return D.21834;
      <D.18641>:
      *conv = 4;
      D.21834 = 20;
      return D.21834;
      <D.18642>:
      *conv = 7;
      D.21834 = 21;
      return D.21834;
      <D.18643>:
      *conv = 9;
      D.21834 = 22;
      return D.21834;
      <D.18644>:
      *conv = 10;
      D.21834 = 35;
      return D.21834;
      <D.18645>:
      *conv = 11;
      D.21834 = 36;
      return D.21834;
      <D.18646>:
      if (unicode != 0) goto <D.21846>; else goto <D.21847>;
      <D.21846>:
      *conv = 13;
      goto <D.21848>;
      <D.21847>:
      *conv = 12;
      <D.21848>:
      D.21834 = 23;
      return D.21834;
      <D.18647>:
      D.21837 = 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.21837);
      <D.18648>:
      goto <D.18648>;
      <D.21845>:
      if (unicode != 0) goto <D.21849>; else goto <D.21850>;
      <D.21849>:
      *conv = 7;
      D.21834 = 21;
      return D.21834;
      <D.21850>:
      *conv = 4;
      D.21834 = 20;
      return D.21834;
      <D.18649>:
      D.21834 = 32;
      return D.21834;
      <D.18650>:
      D.21851 = type->data.klass;
      D.21852 = BIT_FIELD_REF <*D.21851, 32, 160>;
      D.21853 = D.21852 & 16;
      if (D.21853 != 0) goto <D.21854>; else goto <D.21855>;
      <D.21854>:
      D.21851 = type->data.klass;
      D.21856 = mono_class_enum_basetype (D.21851);
      D.21857 = D.21856->type;
      t = (int) D.21857;
      goto handle_enum;
      <D.21855>:
      D.21851 = type->data.klass;
      D.21858 = mono_defaults.handleref_class;
      if (D.21851 == D.21858) goto <D.21859>; else goto <D.21860>;
      <D.21859>:
      *conv = 34;
      D.21834 = 31;
      return D.21834;
      <D.21860>:
      D.21834 = 27;
      return D.21834;
      <D.18651>:
      <D.18652>:
      if (mspec != 0B) goto <D.21861>; else goto <D.21862>;
      <D.21861>:
      D.21837 = mspec->native;
      switch (D.21837) <default: <D.18656>, case 29: <D.18654>, case 30: <D.18653>, case 42: <D.18655>>
      <D.18653>:
      D.21851 = type->data.klass;
      D.21865 = D.21851->element_class;
      D.21866 = mono_defaults.char_class;
      if (D.21865 == D.21866) goto <D.21867>; else goto <D.21863>;
      <D.21867>:
      if (unicode == 0) goto <D.21868>; else goto <D.21863>;
      <D.21868>:
      *conv = 21;
      goto <D.21864>;
      <D.21863>:
      *conv = 20;
      <D.21864>:
      D.21834 = 30;
      return D.21834;
      <D.18654>:
      *conv = 22;
      D.21834 = 29;
      return D.21834;
      <D.18655>:
      *conv = 23;
      D.21834 = 42;
      return D.21834;
      <D.18656>:
      D.21837 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.21837);
      <D.18657>:
      goto <D.18657>;
      <D.21862>:
      *conv = 23;
      D.21834 = 42;
      return D.21834;
      <D.18658>:
      D.21834 = 31;
      return D.21834;
      <D.18659>:
      D.21834 = 32;
      return D.21834;
      <D.18660>:
      <D.18661>:
      if (mspec != 0B) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      D.21837 = mspec->native;
      switch (D.21837) <default: <D.18668>, case 25: <D.18666>, case 26: <D.18665>, case 27: <D.18662>, case 28: <D.18664>, case 38: <D.18667>, case 44: <D.18663>>
      <D.18662>:
      D.21834 = 27;
      return D.21834;
      <D.18663>:
      D.21834 = 44;
      return D.21834;
      <D.18664>:
      *conv = 25;
      D.21834 = 28;
      return D.21834;
      <D.18665>:
      *conv = 26;
      D.21834 = 26;
      return D.21834;
      <D.18666>:
      *conv = 27;
      D.21834 = 25;
      return D.21834;
      <D.18667>:
      if (t == 18) goto <D.21873>; else goto <D.21874>;
      <D.21873>:
      D.21851 = type->data.klass;
      D.21875 = mono_defaults.multicastdelegate_class;
      if (D.21851 == D.21875) goto <D.21871>; else goto <D.21876>;
      <D.21876>:
      D.21851 = type->data.klass;
      D.21877 = mono_defaults.delegate_class;
      if (D.21851 == D.21877) goto <D.21871>; else goto <D.21878>;
      <D.21878>:
      D.21851 = type->data.klass;
      D.21879 = D.21851->parent;
      D.21875 = mono_defaults.multicastdelegate_class;
      if (D.21879 == D.21875) goto <D.21871>; else goto <D.21872>;
      <D.21871>:
      *conv = 29;
      D.21834 = 38;
      return D.21834;
      <D.21872>:
      <D.21874>:
      <D.18668>:
      D.21837 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.21837);
      <D.18669>:
      goto <D.18669>;
      <D.21870>:
      if (t == 18) goto <D.21882>; else goto <D.21883>;
      <D.21882>:
      D.21851 = type->data.klass;
      D.21875 = mono_defaults.multicastdelegate_class;
      if (D.21851 == D.21875) goto <D.21880>; else goto <D.21884>;
      <D.21884>:
      D.21851 = type->data.klass;
      D.21877 = mono_defaults.delegate_class;
      if (D.21851 == D.21877) goto <D.21880>; else goto <D.21885>;
      <D.21885>:
      D.21851 = type->data.klass;
      D.21879 = D.21851->parent;
      D.21875 = mono_defaults.multicastdelegate_class;
      if (D.21879 == D.21875) goto <D.21880>; else goto <D.21881>;
      <D.21880>:
      *conv = 29;
      D.21834 = 38;
      return D.21834;
      <D.21881>:
      <D.21883>:
      D.21886 = mono_defaults.safehandle_class;
      if (D.21886 != 0B) goto <D.21887>; else goto <D.21888>;
      <D.21887>:
      D.21851 = type->data.klass;
      D.21886 = mono_defaults.safehandle_class;
      if (D.21851 == D.21886) goto <D.21889>; else goto <D.21890>;
      <D.21889>:
      *conv = 33;
      D.21834 = 31;
      return D.21834;
      <D.21890>:
      <D.21888>:
      *conv = 28;
      D.21834 = 27;
      return D.21834;
      <D.18670>:
      D.21834 = 38;
      return D.21834;
      <D.18671>:
      D.21891 = type->data.generic_class;
      D.21892 = D.21891->container_class;
      type = &D.21892->byval_arg;
      D.21827 = type->type;
      t = (int) D.21827;
      goto handle_enum;
      <D.18672>:
      <D.18673>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.18674>:
      goto <D.18674>;
      D.21834 = 80;
      return D.21834;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.21895;
  const char * D.21898;
  unsigned int D.21899;
  unsigned int D.21900;
  _Bool D.21901;
  int D.21902;
  unsigned int D.21903;
  unsigned int D.21904;
  int D.21905;
  <unnamed-unsigned:24> D.21906;
  unsigned int D.21907;
  unsigned char D.21908;
  unsigned int D.21909;
  void * D.21910;
  unsigned int D.21913;
  int D.21914;
  unsigned int D.21915;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.21895 = tdef->base;
      if (D.21895 == 0B) goto <D.21896>; else goto <D.21897>;
      <D.21896>:
      D.21898 = 0B;
      return D.21898;
      <D.21897>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.21899 = idx + 1;
      D.21900 = D.21899 << 1;
      D.21901 = is_field == 0;
      D.21902 = (int) D.21901;
      D.21903 = (unsigned int) D.21902;
      D.21904 = D.21900 | D.21903;
      D.21905 = (int) D.21904;
      loc.idx = D.21905;
      D.21895 = tdef->base;
      D.21906 = tdef->rows;
      D.21907 = (unsigned int) D.21906;
      D.21908 = tdef->row_size;
      D.21909 = (unsigned int) D.21908;
      D.21910 = mono_binary_search (&loc, D.21895, D.21907, D.21909, table_locator);
      if (D.21910 == 0B) goto <D.21911>; else goto <D.21912>;
      <D.21911>:
      D.21898 = 0B;
      return D.21898;
      <D.21912>:
      D.21913 = loc.result;
      D.21914 = (int) D.21913;
      D.21915 = mono_metadata_decode_row_col (tdef, D.21914, 1);
      D.21898 = mono_metadata_blob_heap (meta, D.21915);
      return D.21898;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.21918;
  struct MonoMethod * D.21919;
  unsigned int D.21920;
  unsigned int D.21921;
  guint32 idx;

  idx = tok >> 1;
  D.21918 = tok & 1;
  switch (D.21918) <default: <D.21922>, case 0: <D.18688>, case 1: <D.18689>>
  <D.18688>:
  D.21920 = idx | 100663296;
  D.21919 = mono_get_method_full (m, D.21920, 0B, context);
  return D.21919;
  <D.18689>:
  D.21921 = idx | 167772160;
  D.21919 = mono_get_method_full (m, D.21921, 0B, context);
  return D.21919;
  <D.21922>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.21919 = 0B;
  return D.21919;
}


mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.21926;
  gboolean D.21929;
  int type_token.176;
  int D.21931;
  <unnamed-unsigned:24> D.21932;
  unsigned int D.21933;
  unsigned char D.21934;
  unsigned int D.21935;
  void * D.21936;
  int D.21939;
  unsigned int D.21940;
  unsigned int D.21941;
  int D.21942;
  unsigned int D.21943;
  int end.177;
  unsigned int D.21946;
  unsigned int D.21948;
  unsigned int D.21949;
  unsigned int num.178;
  unsigned int D.21951;
  unsigned int i.179;
  unsigned int D.21953;
  int D.21954;
  int D.21957;
  unsigned int D.21958;
  unsigned int i.180;
  unsigned int D.21962;
  struct MonoMethod * * D.21963;
  unsigned int D.21964;
  sizetype i.181;
  sizetype D.21968;
  sizetype D.21969;
  struct MonoMethod * * D.21970;
  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.21924>; else goto <D.21925>;
      <D.21924>:
      *num_overrides = 0;
      <D.21925>:
      D.21926 = tdef->base;
      if (D.21926 == 0B) goto <D.21927>; else goto <D.21928>;
      <D.21927>:
      D.21929 = 1;
      return D.21929;
      <D.21928>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.176 = (int) type_token;
      D.21931 = type_token.176 & 16777215;
      loc.idx = D.21931;
      D.21926 = tdef->base;
      D.21932 = tdef->rows;
      D.21933 = (unsigned int) D.21932;
      D.21934 = tdef->row_size;
      D.21935 = (unsigned int) D.21934;
      D.21936 = mono_binary_search (&loc, D.21926, D.21933, D.21935, table_locator);
      if (D.21936 == 0B) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      D.21929 = 1;
      return D.21929;
      <D.21938>:
      start = loc.result;
      end = start + 1;
      goto <D.18709>;
      <D.18708>:
      D.21939 = loc.idx;
      D.21940 = (unsigned int) D.21939;
      D.21941 = start + 4294967295;
      D.21942 = (int) D.21941;
      D.21943 = mono_metadata_decode_row_col (tdef, D.21942, 0);
      if (D.21940 == D.21943) goto <D.21944>; else goto <D.18707>;
      <D.21944>:
      start = start + 4294967295;
      <D.18709>:
      if (start != 0) goto <D.18708>; else goto <D.18707>;
      <D.18707>:
      goto <D.18712>;
      <D.18711>:
      D.21939 = loc.idx;
      D.21940 = (unsigned int) D.21939;
      end.177 = (int) end;
      D.21946 = mono_metadata_decode_row_col (tdef, end.177, 0);
      if (D.21940 == D.21946) goto <D.21947>; else goto <D.18710>;
      <D.21947>:
      end = end + 1;
      <D.18712>:
      D.21932 = tdef->rows;
      D.21948 = (unsigned int) D.21932;
      if (D.21948 > end) goto <D.18711>; else goto <D.18710>;
      <D.18710>:
      D.21949 = end - start;
      num = (gint32) D.21949;
      num.178 = (unsigned int) num;
      D.21951 = num.178 * 8;
      result = monoeg_malloc (D.21951);
      i = 0;
      goto <D.18716>;
      <D.18715>:
      {
        struct MonoMethod * method;

        i.179 = (unsigned int) i;
        D.21953 = start + i.179;
        D.21954 = mono_verifier_verify_methodimpl_row (image, D.21953, &error);
        if (D.21954 == 0) goto <D.21955>; else goto <D.21956>;
        <D.21955>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.18714>;
        <D.21956>:
        i.179 = (unsigned int) i;
        D.21953 = start + i.179;
        D.21957 = (int) D.21953;
        mono_metadata_decode_row (tdef, D.21957, &cols, 3);
        D.21958 = cols[2];
        method = method_from_method_def_or_ref (image, D.21958, generic_context);
        if (method == 0B) goto <D.21959>; else goto <D.21960>;
        <D.21959>:
        ok = 0;
        <D.21960>:
        i.180 = (unsigned int) i;
        D.21962 = i.180 * 8;
        D.21963 = result + D.21962;
        *D.21963 = method;
        D.21964 = cols[1];
        method = method_from_method_def_or_ref (image, D.21964, generic_context);
        if (method == 0B) goto <D.21965>; else goto <D.21966>;
        <D.21965>:
        ok = 0;
        <D.21966>:
        i.181 = (sizetype) i;
        D.21968 = i.181 * 8;
        D.21969 = D.21968 + 4;
        D.21970 = result + D.21969;
        *D.21970 = method;
      }
      i = i + 1;
      <D.18716>:
      if (i < num) goto <D.18715>; else goto <D.18714>;
      <D.18714>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.21971>; else goto <D.21972>;
      <D.21971>:
      *num_overrides = num;
      <D.21972>:
      D.21929 = ok;
      return D.21929;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.21975;
  const guint8 * D.21976;
  unsigned char D.21977;
  int D.21978;
  const guint8 * D.21979;
  unsigned char D.21980;
  int D.21981;
  const guint8 * D.21982;
  unsigned char D.21983;
  int D.21984;
  unsigned char D.21985;
  int D.21986;
  const guint8 * D.21987;
  unsigned char D.21988;
  int D.21989;
  const guint8 * D.21990;
  unsigned char D.21991;
  int D.21992;
  const guint8 * D.21993;
  unsigned char D.21994;
  int D.21995;
  const guint8 * D.21996;
  unsigned char D.21997;
  int D.21998;
  const guint8 * D.21999;
  unsigned char D.22000;
  int D.22001;
  const guint8 * D.22002;
  unsigned char D.22003;
  int D.22004;
  const guint8 * D.22005;
  unsigned char D.22006;
  int D.22007;
  const guint8 * D.22008;
  unsigned char D.22009;
  int D.22010;
  const guint8 * D.22011;
  unsigned char D.22012;
  int D.22013;
  const guint8 * D.22014;
  unsigned char D.22015;
  int D.22016;
  const guint8 * D.22017;
  unsigned char D.22018;
  int D.22019;
  const guint8 * D.22020;
  unsigned char D.22021;
  int D.22022;

  D.21976 = guid + 3;
  D.21977 = *D.21976;
  D.21978 = (int) D.21977;
  D.21979 = guid + 2;
  D.21980 = *D.21979;
  D.21981 = (int) D.21980;
  D.21982 = guid + 1;
  D.21983 = *D.21982;
  D.21984 = (int) D.21983;
  D.21985 = *guid;
  D.21986 = (int) D.21985;
  D.21987 = guid + 5;
  D.21988 = *D.21987;
  D.21989 = (int) D.21988;
  D.21990 = guid + 4;
  D.21991 = *D.21990;
  D.21992 = (int) D.21991;
  D.21993 = guid + 7;
  D.21994 = *D.21993;
  D.21995 = (int) D.21994;
  D.21996 = guid + 6;
  D.21997 = *D.21996;
  D.21998 = (int) D.21997;
  D.21999 = guid + 8;
  D.22000 = *D.21999;
  D.22001 = (int) D.22000;
  D.22002 = guid + 9;
  D.22003 = *D.22002;
  D.22004 = (int) D.22003;
  D.22005 = guid + 10;
  D.22006 = *D.22005;
  D.22007 = (int) D.22006;
  D.22008 = guid + 11;
  D.22009 = *D.22008;
  D.22010 = (int) D.22009;
  D.22011 = guid + 12;
  D.22012 = *D.22011;
  D.22013 = (int) D.22012;
  D.22014 = guid + 13;
  D.22015 = *D.22014;
  D.22016 = (int) D.22015;
  D.22017 = guid + 14;
  D.22018 = *D.22017;
  D.22019 = (int) D.22018;
  D.22020 = guid + 15;
  D.22021 = *D.22020;
  D.22022 = (int) D.22021;
  D.21975 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.21978, D.21981, D.21984, D.21986, D.21989, D.21992, D.21995, D.21998, D.22001, D.22004, D.22007, D.22010, D.22013, D.22016, D.22019, D.22022);
  return D.21975;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.22024;
  long int D.22025;
  long int D.22026;
  const char * D.22029;
  guint32 D.22032;
  unsigned int D.22033;
  unsigned int D.22040;
  unsigned int D.22041;
  unsigned int D.22042;
  unsigned int D.22043;
  int D.22044;
  <unnamed-unsigned:24> D.22045;
  unsigned int D.22046;
  unsigned char D.22047;
  unsigned int D.22048;
  void * D.22049;
  unsigned int D.22052;
  unsigned int D.22053;
  int D.22055;
  unsigned int D.22056;
  int D.22057;
  unsigned int D.22058;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.22024 = owner == 0B;
      D.22025 = (long int) D.22024;
      D.22026 = __builtin_expect (D.22025, 0);
      if (D.22026 != 0) goto <D.22027>; else goto <D.22028>;
      <D.22027>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.22028>:
      D.22029 = tdef->base;
      if (D.22029 == 0B) goto <D.22030>; else goto <D.22031>;
      <D.22030>:
      D.22032 = 0;
      return D.22032;
      <D.22031>:
      D.22033 = token >> 24;
      if (D.22033 == 2) goto <D.22034>; else goto <D.22035>;
      <D.22034>:
      *owner = 0;
      goto <D.22036>;
      <D.22035>:
      D.22033 = token >> 24;
      if (D.22033 == 6) goto <D.22037>; else goto <D.22038>;
      <D.22037>:
      *owner = 1;
      goto <D.22039>;
      <D.22038>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.18749>:
      goto <D.18749>;
      D.22032 = 0;
      return D.22032;
      <D.22039>:
      <D.22036>:
      D.22040 = *owner;
      D.22041 = token & 16777215;
      D.22042 = D.22041 << 1;
      D.22043 = D.22040 | D.22042;
      *owner = D.22043;
      D.22040 = *owner;
      D.22044 = (int) D.22040;
      loc.idx = D.22044;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22029 = tdef->base;
      D.22045 = tdef->rows;
      D.22046 = (unsigned int) D.22045;
      D.22047 = tdef->row_size;
      D.22048 = (unsigned int) D.22047;
      D.22049 = mono_binary_search (&loc, D.22029, D.22046, D.22048, table_locator);
      if (D.22049 == 0B) goto <D.22050>; else goto <D.22051>;
      <D.22050>:
      D.22032 = 0;
      return D.22032;
      <D.22051>:
      goto <D.18751>;
      <D.18750>:
      D.22052 = loc.result;
      D.22053 = D.22052 + 4294967295;
      loc.result = D.22053;
      <D.18751>:
      D.22052 = loc.result;
      if (D.22052 != 0) goto <D.22054>; else goto <D.18752>;
      <D.22054>:
      D.22052 = loc.result;
      D.22053 = D.22052 + 4294967295;
      D.22055 = (int) D.22053;
      D.22056 = mono_metadata_decode_row_col (tdef, D.22055, 2);
      D.22057 = loc.idx;
      D.22058 = (unsigned int) D.22057;
      if (D.22056 == D.22058) goto <D.18750>; else goto <D.18752>;
      <D.18752>:
      D.22052 = loc.result;
      D.22032 = D.22052 + 1;
      return D.22032;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


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

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


mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.22067;
  unsigned int D.22068;
  int D.22069;
  struct MonoGenericParamFull * D.22070;
  unsigned int D.22071;
  struct MonoGenericParamFull * D.22072;
  struct MonoClass * * * D.22073;
  int D.22074;
  <unnamed-signed:31> D.22077;
  unsigned int D.22078;
  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.22065>; else goto <D.22066>;
      <D.22065>:
      D.22067 = 1;
      return D.22067;
      <D.22066>:
      i = 0;
      goto <D.18767>;
      <D.18766>:
      D.22068 = start_row + i;
      D.22069 = (int) D.22068;
      D.22070 = container->type_params;
      D.22071 = i * 32;
      D.22072 = D.22070 + D.22071;
      D.22073 = &D.22072->info.constraints;
      D.22074 = get_constraints (image, D.22069, D.22073, container);
      if (D.22074 == 0) goto <D.22075>; else goto <D.22076>;
      <D.22075>:
      D.22067 = 0;
      return D.22067;
      <D.22076>:
      i = i + 1;
      <D.18767>:
      D.22077 = container->type_argc;
      D.22078 = (unsigned int) D.22077;
      if (D.22078 > i) goto <D.18766>; else goto <D.18768>;
      <D.18768>:
      D.22067 = 1;
      return D.22067;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.182;
  unsigned int D.22082;
  unsigned int owner.183;
  unsigned int D.22086;
  gboolean D.22089;
  <unnamed-unsigned:24> D.22092;
  unsigned int D.22093;
  unsigned int D.22096;
  unsigned int D.22097;
  unsigned int D.22098;
  struct MonoClass * * D.22099;
  void * D.22100;
  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.18738>;
      <D.18737>:
      i.182 = (int) i;
      mono_metadata_decode_row (tdef, i.182, &cols, 2);
      D.22082 = cols[0];
      owner.183 = (unsigned int) owner;
      if (D.22082 == owner.183) goto <D.22084>; else goto <D.22085>;
      <D.22084>:
      D.22086 = cols[1];
      token = mono_metadata_token_from_dor (D.22086);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.22087>; else goto <D.22088>;
      <D.22087>:
      monoeg_g_slist_free (cons);
      D.22089 = 0;
      return D.22089;
      <D.22088>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.22090>;
      <D.22085>:
      if (found != 0) goto <D.18736>; else goto <D.22091>;
      <D.22091>:
      <D.22090>:
      i = i + 1;
      <D.18738>:
      D.22092 = tdef->rows;
      D.22093 = (unsigned int) D.22092;
      if (D.22093 > i) goto <D.18737>; else goto <D.18736>;
      <D.18736>:
      if (found == 0) goto <D.22094>; else goto <D.22095>;
      <D.22094>:
      D.22089 = 1;
      return D.22089;
      <D.22095>:
      D.22096 = found + 1;
      D.22097 = D.22096 * 4;
      res = mono_image_alloc0 (image, D.22097);
      i = 0;
      tmp = cons;
      goto <D.18740>;
      <D.18739>:
      D.22098 = i * 4;
      D.22099 = res + D.22098;
      D.22100 = tmp->data;
      *D.22099 = D.22100;
      i = i + 1;
      tmp = tmp->next;
      <D.18740>:
      if (i < found) goto <D.18739>; else goto <D.18741>;
      <D.18741>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.22089 = 1;
      return D.22089;
    }
  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.22105;
  unsigned int D.22106;
  int D.22107;
  unsigned int D.22108;
  sizetype D.22109;
  sizetype D.22110;
  struct MonoGenericParamFull * D.22111;
  unsigned int D.22112;
  short unsigned int D.22113;
  unsigned int D.22114;
  unsigned int D.22115;
  short unsigned int D.22116;
  unsigned int D.22117;
  const char * D.22118;
  short unsigned int D.22119;
  unsigned int D.22120;
  unsigned int D.22121;
  <unnamed-unsigned:24> D.22124;
  unsigned int D.22125;
  unsigned int D.22127;
  unsigned int owner.184;
  int n.185;
  <unnamed-signed:31> D.22130;
  void * D.22131;
  struct MonoGenericParamFull * D.22132;
  unsigned int D.22133;
  int iftmp.186;
  struct MonoGenericContainer * D.22139;
  unsigned int D.22141;
  unsigned int D.22142;
  _Bool D.22144;
  long int D.22145;
  long int D.22146;
  struct MonoGenericInst * iftmp.187;
  struct MonoGenericInst * D.22155;
  struct MonoGenericInst * D.22157;
  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.22103>; else goto <D.22104>;
      <D.22103>:
      D.22105 = 0B;
      return D.22105;
      <D.22104>:
      D.22106 = i + 4294967295;
      D.22107 = (int) D.22106;
      mono_metadata_decode_row (tdef, D.22107, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 28);
      container->image = image;
      <D.18788>:
      n = n + 1;
      D.22108 = n * 32;
      params = monoeg_realloc (params, D.22108);
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      memset (D.22111, 0, 32);
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22111->param.owner = container;
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22112 = cols[0];
      D.22113 = (short unsigned int) D.22112;
      D.22111->param.num = D.22113;
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22114 = i | 704643072;
      D.22111->info.token = D.22114;
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22115 = cols[1];
      D.22116 = (short unsigned int) D.22115;
      D.22111->info.flags = D.22116;
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22117 = cols[3];
      D.22118 = mono_metadata_string_heap (image, D.22117);
      D.22111->info.name = D.22118;
      D.22109 = n + 134217727;
      D.22110 = D.22109 * 32;
      D.22111 = params + D.22110;
      D.22119 = D.22111->param.num;
      D.22120 = (unsigned int) D.22119;
      D.22121 = n + 4294967295;
      if (D.22120 != D.22121) goto <D.22122>; else goto <D.22123>;
      <D.22122>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.22123>:
      i = i + 1;
      D.22124 = tdef->rows;
      D.22125 = (unsigned int) D.22124;
      if (i > D.22125) goto <D.18787>; else goto <D.22126>;
      <D.22126>:
      D.22106 = i + 4294967295;
      D.22107 = (int) D.22106;
      mono_metadata_decode_row (tdef, D.22107, &cols, 4);
      D.22127 = cols[2];
      owner.184 = owner;
      if (D.22127 == owner.184) goto <D.18788>; else goto <D.18787>;
      <D.18787>:
      n.185 = (int) n;
      D.22130 = (<unnamed-signed:31>) n.185;
      container->type_argc = D.22130;
      D.22108 = n * 32;
      D.22131 = mono_image_alloc0 (image, D.22108);
      container->type_params = D.22131;
      D.22132 = container->type_params;
      D.22108 = n * 32;
      memcpy (D.22132, params, D.22108);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.22133 = token >> 24;
      if (D.22133 == 6) goto <D.22134>; else goto <D.22135>;
      <D.22134>:
      container->is_method = -1;
      <D.22135>:
      D.22139 = container->parent;
      if (D.22139 != 0B) goto <D.22140>; else goto <D.22137>;
      <D.22140>:
      D.22141 = BIT_FIELD_REF <*container, 32, 128>;
      D.22142 = D.22141 & 2147483648;
      if (D.22142 == 0) goto <D.22143>; else goto <D.22137>;
      <D.22143>:
      iftmp.186 = 1;
      goto <D.22138>;
      <D.22137>:
      iftmp.186 = 0;
      <D.22138>:
      D.22144 = iftmp.186 != 0;
      D.22145 = (long int) D.22144;
      D.22146 = __builtin_expect (D.22145, 0);
      if (D.22146 != 0) goto <D.22147>; else goto <D.22148>;
      <D.22147>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.22148>:
      context = &container->context;
      D.22141 = BIT_FIELD_REF <*container, 32, 128>;
      D.22142 = D.22141 & 2147483648;
      if (D.22142 != 0) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      D.22139 = container->parent;
      if (D.22139 != 0B) goto <D.22152>; else goto <D.22153>;
      <D.22152>:
      D.22139 = container->parent;
      iftmp.187 = D.22139->context.class_inst;
      goto <D.22154>;
      <D.22153>:
      iftmp.187 = 0B;
      <D.22154>:
      context->class_inst = iftmp.187;
      D.22155 = mono_get_shared_generic_inst (container);
      context->method_inst = D.22155;
      goto <D.22156>;
      <D.22150>:
      D.22157 = mono_get_shared_generic_inst (container);
      context->class_inst = D.22157;
      <D.22156>:
      D.22105 = container;
      return D.22105;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.22160;
  unsigned int D.22161;
  unsigned int D.22162;
  unsigned int D.22163;
  unsigned int i.188;
  unsigned int D.22165;
  unsigned char iftmp.189;
  unsigned int D.22167;
  unsigned int D.22168;
  struct MonoGenericParamFull * D.22172;
  unsigned int D.22173;
  struct MonoGenericParam * D.22174;
  unsigned int D.22175;
  struct MonoType * * D.22176;
  int D.22177;
  struct MonoGenericInst * D.22178;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.22160 = container->type_argc;
  D.22161 = (unsigned int) D.22160;
  D.22162 = D.22161 * 4;
  type_argv = monoeg_malloc0 (D.22162);
  D.22160 = container->type_argc;
  D.22161 = (unsigned int) D.22160;
  D.22163 = D.22161 * 8;
  helper = monoeg_malloc0 (D.22163);
  i = 0;
  goto <D.18798>;
  <D.18797>:
  {
    struct MonoType * t;

    i.188 = (unsigned int) i;
    D.22165 = i.188 * 8;
    t = helper + D.22165;
    D.22167 = BIT_FIELD_REF <*container, 32, 128>;
    D.22168 = D.22167 & 2147483648;
    if (D.22168 != 0) goto <D.22169>; else goto <D.22170>;
    <D.22169>:
    iftmp.189 = 30;
    goto <D.22171>;
    <D.22170>:
    iftmp.189 = 19;
    <D.22171>:
    t->type = iftmp.189;
    D.22172 = container->type_params;
    i.188 = (unsigned int) i;
    D.22173 = i.188 * 32;
    D.22174 = D.22172 + D.22173;
    t->data.generic_param = D.22174;
    i.188 = (unsigned int) i;
    D.22175 = i.188 * 4;
    D.22176 = type_argv + D.22175;
    *D.22176 = t;
  }
  i = i + 1;
  <D.18798>:
  D.22160 = container->type_argc;
  D.22177 = (int) D.22160;
  if (D.22177 > i) goto <D.18797>; else goto <D.18799>;
  <D.18799>:
  D.22160 = container->type_argc;
  D.22177 = (int) D.22160;
  nginst = mono_metadata_get_generic_inst (D.22177, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.22178 = nginst;
  return D.22178;
}


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

  D.22181 = type->byref;
  D.22180 = (mono_bool) D.22181;
  return D.22180;
}


mono_type_get_type (struct MonoType * type)
{
  int D.22183;
  unsigned char D.22184;

  D.22184 = type->type;
  D.22183 = (int) D.22184;
  return D.22183;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.22186;
  _Bool D.22187;
  long int D.22188;
  long int D.22189;
  struct MonoMethodSignature * D.22192;

  D.22186 = type->type;
  D.22187 = D.22186 != 27;
  D.22188 = (long int) D.22187;
  D.22189 = __builtin_expect (D.22188, 0);
  if (D.22189 != 0) goto <D.22190>; else goto <D.22191>;
  <D.22190>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.22191>:
  D.22192 = type->data.method;
  return D.22192;
}


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

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


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

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


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.22198;
  _Bool D.22199;
  long int D.22200;
  long int D.22201;
  struct MonoType * D.22204;

  D.22198 = type->type;
  D.22199 = D.22198 != 15;
  D.22200 = (long int) D.22199;
  D.22201 = __builtin_expect (D.22200, 0);
  if (D.22201 != 0) goto <D.22202>; else goto <D.22203>;
  <D.22202>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.22203>:
  D.22204 = type->data.type;
  return D.22204;
}


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

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


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.22208;
  int iftmp.190;
  unsigned int D.22214;
  unsigned int D.22215;
  unsigned char D.22217;
  struct MonoClass * D.22219;
  unsigned int D.22220;
  unsigned int D.22221;
  struct MonoGenericClass * D.22224;
  int D.22225;
  struct MonoClass * D.22227;
  unsigned int D.22228;
  unsigned int D.22229;

  D.22214 = BIT_FIELD_REF <*type, 32, 32>;
  D.22215 = D.22214 & 1073741824;
  if (D.22215 == 0) goto <D.22216>; else goto <D.22210>;
  <D.22216>:
  D.22217 = type->type;
  if (D.22217 == 17) goto <D.22218>; else goto <D.22211>;
  <D.22218>:
  D.22219 = type->data.klass;
  D.22220 = BIT_FIELD_REF <*D.22219, 32, 160>;
  D.22221 = D.22220 & 16;
  if (D.22221 == 0) goto <D.22212>; else goto <D.22211>;
  <D.22211>:
  D.22217 = type->type;
  if (D.22217 == 22) goto <D.22212>; else goto <D.22222>;
  <D.22222>:
  D.22217 = type->type;
  if (D.22217 == 21) goto <D.22223>; else goto <D.22210>;
  <D.22223>:
  D.22224 = type->data.generic_class;
  D.22225 = mono_metadata_generic_class_is_valuetype (D.22224);
  if (D.22225 != 0) goto <D.22226>; else goto <D.22210>;
  <D.22226>:
  D.22224 = type->data.generic_class;
  D.22227 = D.22224->container_class;
  D.22228 = BIT_FIELD_REF <*D.22227, 32, 160>;
  D.22229 = D.22228 & 16;
  if (D.22229 == 0) goto <D.22212>; else goto <D.22210>;
  <D.22212>:
  iftmp.190 = 1;
  goto <D.22213>;
  <D.22210>:
  iftmp.190 = 0;
  <D.22213>:
  D.22208 = iftmp.190;
  return D.22208;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.22231;
  int iftmp.191;
  unsigned int D.22236;
  unsigned int D.22237;

  if (type != 0B) goto <D.22235>; else goto <D.22233>;
  <D.22235>:
  D.22236 = BIT_FIELD_REF <*type, 32, 32>;
  D.22237 = D.22236 & 1090453504;
  if (D.22237 == 65536) goto <D.22238>; else goto <D.22233>;
  <D.22238>:
  iftmp.191 = 1;
  goto <D.22234>;
  <D.22233>:
  iftmp.191 = 0;
  <D.22234>:
  D.22231 = iftmp.191;
  return D.22231;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.22240;
  int iftmp.192;
  unsigned int D.22246;
  unsigned int D.22247;
  unsigned char D.22249;

  if (type != 0B) goto <D.22245>; else goto <D.22242>;
  <D.22245>:
  D.22246 = BIT_FIELD_REF <*type, 32, 32>;
  D.22247 = D.22246 & 1073741824;
  if (D.22247 != 0) goto <D.22243>; else goto <D.22248>;
  <D.22248>:
  D.22249 = type->type;
  if (D.22249 == 24) goto <D.22243>; else goto <D.22250>;
  <D.22250>:
  D.22249 = type->type;
  if (D.22249 == 14) goto <D.22243>; else goto <D.22251>;
  <D.22251>:
  D.22249 = type->type;
  if (D.22249 == 29) goto <D.22243>; else goto <D.22252>;
  <D.22252>:
  D.22249 = type->type;
  if (D.22249 == 18) goto <D.22243>; else goto <D.22253>;
  <D.22253>:
  D.22249 = type->type;
  if (D.22249 == 25) goto <D.22243>; else goto <D.22254>;
  <D.22254>:
  D.22249 = type->type;
  if (D.22249 == 28) goto <D.22243>; else goto <D.22255>;
  <D.22255>:
  D.22249 = type->type;
  if (D.22249 == 20) goto <D.22243>; else goto <D.22256>;
  <D.22256>:
  D.22249 = type->type;
  if (D.22249 == 15) goto <D.22243>; else goto <D.22257>;
  <D.22257>:
  D.22249 = type->type;
  if (D.22249 == 27) goto <D.22243>; else goto <D.22242>;
  <D.22243>:
  iftmp.192 = 1;
  goto <D.22244>;
  <D.22242>:
  iftmp.192 = 0;
  <D.22244>:
  D.22240 = iftmp.192;
  return D.22240;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.22259;
  int iftmp.193;
  unsigned char D.22265;
  struct MonoGenericClass * D.22272;
  int D.22273;

  if (type != 0B) goto <D.22264>; else goto <D.22261>;
  <D.22264>:
  D.22265 = type->type;
  if (D.22265 == 14) goto <D.22262>; else goto <D.22266>;
  <D.22266>:
  D.22265 = type->type;
  if (D.22265 == 29) goto <D.22262>; else goto <D.22267>;
  <D.22267>:
  D.22265 = type->type;
  if (D.22265 == 18) goto <D.22262>; else goto <D.22268>;
  <D.22268>:
  D.22265 = type->type;
  if (D.22265 == 28) goto <D.22262>; else goto <D.22269>;
  <D.22269>:
  D.22265 = type->type;
  if (D.22265 == 20) goto <D.22262>; else goto <D.22270>;
  <D.22270>:
  D.22265 = type->type;
  if (D.22265 == 21) goto <D.22271>; else goto <D.22261>;
  <D.22271>:
  D.22272 = type->data.generic_class;
  D.22273 = mono_metadata_generic_class_is_valuetype (D.22272);
  if (D.22273 == 0) goto <D.22262>; else goto <D.22261>;
  <D.22262>:
  iftmp.193 = 1;
  goto <D.22263>;
  <D.22261>:
  iftmp.193 = 0;
  <D.22263>:
  D.22259 = iftmp.193;
  return D.22259;
}


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

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


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.22279;
  void * D.22280;
  short unsigned int D.22283;
  struct MonoType * * D.22286;
  int D.22287;
  struct MonoType * * D.22288;
  struct MonoType * * type;

  if (iter == 0B) goto <D.22277>; else goto <D.22278>;
  <D.22277>:
  D.22279 = 0B;
  return D.22279;
  <D.22278>:
  D.22280 = *iter;
  if (D.22280 == 0B) goto <D.22281>; else goto <D.22282>;
  <D.22281>:
  D.22283 = sig->param_count;
  if (D.22283 != 0) goto <D.22284>; else goto <D.22285>;
  <D.22284>:
  D.22286 = &sig->params[0];
  *iter = D.22286;
  D.22279 = sig->params[0];
  return D.22279;
  <D.22285>:
  D.22279 = 0B;
  return D.22279;
  <D.22282>:
  type = *iter;
  type = type + 4;
  D.22283 = sig->param_count;
  D.22287 = (int) D.22283;
  D.22288 = &sig->params[D.22287];
  if (D.22288 > type) goto <D.22289>; else goto <D.22290>;
  <D.22289>:
  *iter = type;
  D.22279 = *type;
  return D.22279;
  <D.22290>:
  D.22279 = 0B;
  return D.22279;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.22292;
  short unsigned int D.22293;

  D.22293 = sig->param_count;
  D.22292 = (uint32_t) D.22293;
  return D.22292;
}


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

  D.22296 = sig->call_convention;
  D.22295 = (uint32_t) D.22296;
  return D.22295;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.22298;
  short int D.22299;

  D.22299 = sig->sentinelpos;
  D.22298 = (int) D.22299;
  return D.22298;
}


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

  D.22302 = sig->hasthis;
  D.22301 = (mono_bool) D.22302;
  return D.22301;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.194;
  short unsigned int D.22309;
  int D.22310;
  _Bool D.22311;
  long int D.22312;
  long int D.22313;
  mono_bool D.22316;
  struct MonoType * D.22317;
  short unsigned int D.22318;
  int D.22319;
  int D.22320;
  _Bool D.22321;

  if (param_num < 0) goto <D.22305>; else goto <D.22308>;
  <D.22308>:
  D.22309 = sig->param_count;
  D.22310 = (int) D.22309;
  if (D.22310 <= param_num) goto <D.22305>; else goto <D.22306>;
  <D.22305>:
  iftmp.194 = 1;
  goto <D.22307>;
  <D.22306>:
  iftmp.194 = 0;
  <D.22307>:
  D.22311 = iftmp.194 != 0;
  D.22312 = (long int) D.22311;
  D.22313 = __builtin_expect (D.22312, 0);
  if (D.22313 != 0) goto <D.22314>; else goto <D.22315>;
  <D.22314>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.22315>:
  D.22317 = sig->params[param_num];
  D.22318 = D.22317->attrs;
  D.22319 = (int) D.22318;
  D.22320 = D.22319 & 2;
  D.22321 = D.22320 != 0;
  D.22316 = (mono_bool) D.22321;
  return D.22316;
}


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

  D.22324 = sig->explicit_this;
  D.22323 = (mono_bool) D.22324;
  return D.22323;
}


mono_aligned_addr_hash (const void * ptr)
{
  guint D.22326;
  unsigned int ptr.195;

  ptr.195 = (unsigned int) ptr;
  D.22326 = ptr.195 >> 3;
  return D.22326;
}


mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.22329;
  struct MonoGenericClass * D.22330;
  struct MonoClassField * D.22333;
  int field.196;
  struct MonoClassField * D.22335;
  int D.22336;
  int D.22337;
  struct MonoClassField * D.22338;
  unsigned int offset.197;
  unsigned int D.22340;
  struct MonoClass * gtd;
  int offset;

  D.22329 = field->parent;
  D.22330 = D.22329->generic_class;
  if (D.22330 == 0B) goto <D.22331>; else goto <D.22332>;
  <D.22331>:
  D.22333 = field;
  return D.22333;
  <D.22332>:
  D.22329 = field->parent;
  D.22330 = D.22329->generic_class;
  gtd = D.22330->container_class;
  field.196 = (int) field;
  D.22329 = field->parent;
  D.22335 = D.22329->fields;
  D.22336 = (int) D.22335;
  D.22337 = field.196 - D.22336;
  offset = D.22337 /[ex] 16;
  D.22338 = gtd->fields;
  offset.197 = (unsigned int) offset;
  D.22340 = offset.197 * 16;
  D.22333 = D.22338 + D.22340;
  return D.22333;
}


mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.22342;
  struct MonoGenericClass * D.22343;
  struct MonoEvent * D.22346;
  int event.198;
  struct MonoClassExt * D.22348;
  struct MonoEvent * D.22349;
  int D.22350;
  int D.22351;
  struct MonoClassExt * D.22352;
  struct MonoEvent * D.22353;
  unsigned int offset.199;
  unsigned int D.22355;
  struct MonoClass * gtd;
  int offset;

  D.22342 = event->parent;
  D.22343 = D.22342->generic_class;
  if (D.22343 == 0B) goto <D.22344>; else goto <D.22345>;
  <D.22344>:
  D.22346 = event;
  return D.22346;
  <D.22345>:
  D.22342 = event->parent;
  D.22343 = D.22342->generic_class;
  gtd = D.22343->container_class;
  event.198 = (int) event;
  D.22342 = event->parent;
  D.22348 = D.22342->ext;
  D.22349 = D.22348->events;
  D.22350 = (int) D.22349;
  D.22351 = event.198 - D.22350;
  offset = D.22351 /[ex] 28;
  D.22352 = gtd->ext;
  D.22353 = D.22352->events;
  offset.199 = (unsigned int) offset;
  D.22355 = offset.199 * 28;
  D.22346 = D.22353 + D.22355;
  return D.22346;
}


mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.22357;
  struct MonoGenericClass * D.22358;
  struct MonoProperty * D.22361;
  int property.200;
  struct MonoClassExt * D.22363;
  struct MonoProperty * D.22364;
  int D.22365;
  int D.22366;
  struct MonoClassExt * D.22367;
  struct MonoProperty * D.22368;
  unsigned int offset.201;
  unsigned int D.22370;
  struct MonoClass * gtd;
  int offset;

  D.22357 = property->parent;
  D.22358 = D.22357->generic_class;
  if (D.22358 == 0B) goto <D.22359>; else goto <D.22360>;
  <D.22359>:
  D.22361 = property;
  return D.22361;
  <D.22360>:
  D.22357 = property->parent;
  D.22358 = D.22357->generic_class;
  gtd = D.22358->container_class;
  property.200 = (int) property;
  D.22357 = property->parent;
  D.22363 = D.22357->ext;
  D.22364 = D.22363->properties;
  D.22365 = (int) D.22364;
  D.22366 = property.200 - D.22365;
  offset = D.22366 /[ex] 20;
  D.22367 = gtd->ext;
  D.22368 = D.22367->properties;
  offset.201 = (unsigned int) offset;
  D.22370 = offset.201 * 20;
  D.22361 = D.22368 + D.22370;
  return D.22361;
}