mono_meta_table_name (int table)
{
  unsigned int table.0;
  const char * D.19806;
  short int D.19807;
  sizetype D.19808;

  table.0 = (unsigned int) table;
  if (table.0 > 44) goto <D.19804>; else goto <D.19805>;
  <D.19804>:
  D.19806 = "";
  return D.19806;
  <D.19805>:
  D.19807 = tableidx[table];
  D.19808 = (sizetype) D.19807;
  D.19806 = &tablestr + D.19808;
  return D.19806;
}


mono_metadata_compute_size (struct MonoImage * meta, int tableindex, guint32 * result_bitfield)
{
  unsigned char D.19810;
  sizetype D.19811;
  int iftmp.1;
  long unsigned int D.19813;
  long unsigned int D.19814;
  int iftmp.2;
  long unsigned int D.19819;
  int iftmp.3;
  long unsigned int D.19824;
  _Bool D.19828;
  long int D.19829;
  long int D.19830;
  int iftmp.4;
  <unnamed-unsigned:24> D.19834;
  int D.19835;
  _Bool D.19839;
  long int D.19840;
  long int D.19841;
  int iftmp.5;
  _Bool D.19848;
  long int D.19849;
  long int D.19850;
  int iftmp.6;
  <unnamed-unsigned:24> D.19854;
  int D.19855;
  unsigned int i.7;
  _Bool D.19860;
  long int D.19861;
  long int D.19862;
  int iftmp.8;
  int iftmp.9;
  <unnamed-unsigned:24> D.19869;
  int D.19870;
  int iftmp.10;
  _Bool D.19879;
  long int D.19880;
  long int D.19881;
  int iftmp.11;
  int iftmp.12;
  <unnamed-unsigned:24> D.19893;
  int D.19894;
  int iftmp.13;
  int iftmp.14;
  int iftmp.15;
  <unnamed-unsigned:24> D.19913;
  int D.19914;
  int iftmp.16;
  _Bool D.19924;
  long int D.19925;
  long int D.19926;
  int iftmp.17;
  <unnamed-unsigned:24> D.19930;
  int D.19931;
  int iftmp.18;
  int iftmp.19;
  <unnamed-unsigned:24> D.19944;
  int D.19945;
  int iftmp.20;
  int iftmp.21;
  int iftmp.22;
  int iftmp.23;
  int iftmp.24;
  <unnamed-unsigned:24> D.19973;
  int D.19974;
  int iftmp.25;
  int iftmp.26;
  unsigned int D.19989;
  _Bool D.19990;
  long int D.19991;
  long int D.19992;
  int iftmp.27;
  int iftmp.28;
  int iftmp.29;
  int iftmp.30;
  int iftmp.31;
  <unnamed-unsigned:24> D.20016;
  int D.20017;
  int iftmp.32;
  <unnamed-unsigned:24> D.20025;
  int D.20026;
  <unnamed-unsigned:24> D.20027;
  int D.20028;
  <unnamed-unsigned:24> D.20029;
  int D.20030;
  <unnamed-unsigned:24> D.20031;
  int D.20032;
  <unnamed-unsigned:24> D.20033;
  int D.20034;
  <unnamed-unsigned:24> D.20035;
  int D.20036;
  <unnamed-unsigned:24> D.20037;
  int D.20038;
  <unnamed-unsigned:24> D.20039;
  int D.20040;
  <unnamed-unsigned:24> D.20041;
  int D.20042;
  <unnamed-unsigned:24> D.20043;
  int D.20044;
  <unnamed-unsigned:24> D.20045;
  int D.20046;
  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.20092;
  int D.20093;
  unsigned int D.20094;
  sizetype D.20095;
  const unsigned char * D.20096;
  unsigned char D.20097;
  int D.20098;
  unsigned int D.20099;
  unsigned int D.20100;
  int D.20101;
  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.19810 = table_description[tableindex];
  D.19811 = (sizetype) D.19810;
  description = &TableSchemas + D.19811;
  i = 0;
  goto <D.18059>;
  <D.18058>:
  switch (code) <default: <D.20091>, case 1: <D.18013>, case 2: <D.18015>, case 3: <D.18016>, case 4: <D.18017>, case 5: <D.18018>, case 6: <D.18019>, case 7: <D.18020>, case 8: <D.18046>, case 9: <D.18047>, case 10: <D.18048>, case 11: <D.18049>, case 12: <D.18050>, case 13: <D.18051>, case 14: <D.18052>, case 15: <D.18053>, case 16: <D.18054>, case 17: <D.18055>, case 18: <D.18056>, case 19: <D.18057>>
  <D.18013>:
  field_size = 4;
  goto <D.18014>;
  <D.18015>:
  field_size = 2;
  goto <D.18014>;
  <D.18016>:
  field_size = 1;
  goto <D.18014>;
  <D.18017>:
  D.19813 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19814 = D.19813 & 4398046511104;
  if (D.19814 != 0) goto <D.19815>; else goto <D.19816>;
  <D.19815>:
  iftmp.1 = 4;
  goto <D.19817>;
  <D.19816>:
  iftmp.1 = 2;
  <D.19817>:
  field_size = iftmp.1;
  goto <D.18014>;
  <D.18018>:
  D.19813 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19819 = D.19813 & 1099511627776;
  if (D.19819 != 0) goto <D.19820>; else goto <D.19821>;
  <D.19820>:
  iftmp.2 = 4;
  goto <D.19822>;
  <D.19821>:
  iftmp.2 = 2;
  <D.19822>:
  field_size = iftmp.2;
  goto <D.18014>;
  <D.18019>:
  D.19813 = BIT_FIELD_REF <*meta, 64, 192>;
  D.19824 = D.19813 & 2199023255552;
  if (D.19824 != 0) goto <D.19825>; else goto <D.19826>;
  <D.19825>:
  iftmp.3 = 4;
  goto <D.19827>;
  <D.19826>:
  iftmp.3 = 2;
  <D.19827>:
  field_size = iftmp.3;
  goto <D.18014>;
  <D.18020>:
  switch (tableindex) <default: <D.18044>, case 2: <D.18041>, case 3: <D.18030>, case 5: <D.18036>, case 6: <D.18033>, case 7: <D.18038>, case 9: <D.18032>, case 15: <D.18024>, case 16: <D.18028>, case 18: <D.18025>, case 19: <D.18026>, case 21: <D.18039>, case 22: <D.18040>, case 24: <D.18035>, case 25: <D.18034>, case 28: <D.18031>, case 29: <D.18029>, case 36: <D.18023>, case 37: <D.18021>, case 39: <D.18027>, case 41: <D.18037>, case 42: <D.18042>, case 44: <D.18043>>
  <D.18021>:
  D.19828 = i != 3;
  D.19829 = (long int) D.19828;
  D.19830 = __builtin_expect (D.19829, 0);
  if (D.19830 != 0) goto <D.19831>; else goto <D.19832>;
  <D.19831>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 537, "i == 3");
  <D.19832>:
  D.19834 = meta->tables[35].rows;
  D.19835 = (int) D.19834;
  if (D.19835 <= 65535) goto <D.19836>; else goto <D.19837>;
  <D.19836>:
  iftmp.4 = 2;
  goto <D.19838>;
  <D.19837>:
  iftmp.4 = 4;
  <D.19838>:
  field_size = iftmp.4;
  goto <D.18022>;
  <D.18023>:
  D.19839 = i != 1;
  D.19840 = (long int) D.19839;
  D.19841 = __builtin_expect (D.19840, 0);
  if (D.19841 != 0) goto <D.19842>; else goto <D.19843>;
  <D.19842>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 540, "i == 1");
  <D.19843>:
  D.19834 = meta->tables[35].rows;
  D.19835 = (int) D.19834;
  if (D.19835 <= 65535) goto <D.19845>; else goto <D.19846>;
  <D.19845>:
  iftmp.5 = 2;
  goto <D.19847>;
  <D.19846>:
  iftmp.5 = 4;
  <D.19847>:
  field_size = iftmp.5;
  goto <D.18022>;
  <D.18024>:
  D.19848 = i != 2;
  D.19849 = (long int) D.19848;
  D.19850 = __builtin_expect (D.19849, 0);
  if (D.19850 != 0) goto <D.19851>; else goto <D.19852>;
  <D.19851>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 543, "i == 2");
  <D.19852>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19856>; else goto <D.19857>;
  <D.19856>:
  iftmp.6 = 2;
  goto <D.19858>;
  <D.19857>:
  iftmp.6 = 4;
  <D.19858>:
  field_size = iftmp.6;
  goto <D.18022>;
  <D.18025>:
  i.7 = (unsigned int) i;
  D.19860 = i.7 > 1;
  D.19861 = (long int) D.19860;
  D.19862 = __builtin_expect (D.19861, 0);
  if (D.19862 != 0) goto <D.19863>; else goto <D.19864>;
  <D.19863>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 546, "i == 0 || i == 1");
  <D.19864>:
  if (i != 0) goto <D.19866>; else goto <D.19867>;
  <D.19866>:
  D.19869 = meta->tables[20].rows;
  D.19870 = (int) D.19869;
  if (D.19870 <= 65535) goto <D.19871>; else goto <D.19872>;
  <D.19871>:
  iftmp.9 = 2;
  goto <D.19873>;
  <D.19872>:
  iftmp.9 = 4;
  <D.19873>:
  iftmp.8 = iftmp.9;
  goto <D.19874>;
  <D.19867>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19876>; else goto <D.19877>;
  <D.19876>:
  iftmp.10 = 2;
  goto <D.19878>;
  <D.19877>:
  iftmp.10 = 4;
  <D.19878>:
  iftmp.8 = iftmp.10;
  <D.19874>:
  field_size = iftmp.8;
  goto <D.18022>;
  <D.18026>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19882>; else goto <D.19883>;
  <D.19882>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 551, "i == 0");
  <D.19883>:
  D.19869 = meta->tables[20].rows;
  D.19870 = (int) D.19869;
  if (D.19870 <= 65535) goto <D.19885>; else goto <D.19886>;
  <D.19885>:
  iftmp.11 = 2;
  goto <D.19887>;
  <D.19886>:
  iftmp.11 = 4;
  <D.19887>:
  field_size = iftmp.11;
  goto <D.18022>;
  <D.18027>:
  D.19839 = i != 1;
  D.19840 = (long int) D.19839;
  D.19841 = __builtin_expect (D.19840, 0);
  if (D.19841 != 0) goto <D.19888>; else goto <D.19889>;
  <D.19888>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 554, "i == 1");
  <D.19889>:
  field_size = 4;
  goto <D.18022>;
  <D.18028>:
  D.19839 = i != 1;
  D.19840 = (long int) D.19839;
  D.19841 = __builtin_expect (D.19840, 0);
  if (D.19841 != 0) goto <D.19890>; else goto <D.19891>;
  <D.19890>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 558, "i == 1");
  <D.19891>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  if (D.19894 <= 65535) goto <D.19895>; else goto <D.19896>;
  <D.19895>:
  iftmp.12 = 2;
  goto <D.19897>;
  <D.19896>:
  iftmp.12 = 4;
  <D.19897>:
  field_size = iftmp.12;
  goto <D.18022>;
  <D.18029>:
  D.19839 = i != 1;
  D.19840 = (long int) D.19839;
  D.19841 = __builtin_expect (D.19840, 0);
  if (D.19841 != 0) goto <D.19898>; else goto <D.19899>;
  <D.19898>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 561, "i == 1");
  <D.19899>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  if (D.19894 <= 65535) goto <D.19901>; else goto <D.19902>;
  <D.19901>:
  iftmp.13 = 2;
  goto <D.19903>;
  <D.19902>:
  iftmp.13 = 4;
  <D.19903>:
  field_size = iftmp.13;
  goto <D.18022>;
  <D.18030>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19904>; else goto <D.19905>;
  <D.19904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 564, "i == 0");
  <D.19905>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  if (D.19894 <= 65535) goto <D.19907>; else goto <D.19908>;
  <D.19907>:
  iftmp.14 = 2;
  goto <D.19909>;
  <D.19908>:
  iftmp.14 = 4;
  <D.19909>:
  field_size = iftmp.14;
  goto <D.18022>;
  <D.18031>:
  D.19828 = i != 3;
  D.19829 = (long int) D.19828;
  D.19830 = __builtin_expect (D.19829, 0);
  if (D.19830 != 0) goto <D.19910>; else goto <D.19911>;
  <D.19910>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 567, "i == 3");
  <D.19911>:
  D.19913 = meta->tables[26].rows;
  D.19914 = (int) D.19913;
  if (D.19914 <= 65535) goto <D.19915>; else goto <D.19916>;
  <D.19915>:
  iftmp.15 = 2;
  goto <D.19917>;
  <D.19916>:
  iftmp.15 = 4;
  <D.19917>:
  field_size = iftmp.15;
  goto <D.18022>;
  <D.18032>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19918>; else goto <D.19919>;
  <D.19918>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 570, "i == 0");
  <D.19919>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19921>; else goto <D.19922>;
  <D.19921>:
  iftmp.16 = 2;
  goto <D.19923>;
  <D.19922>:
  iftmp.16 = 4;
  <D.19923>:
  field_size = iftmp.16;
  goto <D.18022>;
  <D.18033>:
  D.19924 = i != 5;
  D.19925 = (long int) D.19924;
  D.19926 = __builtin_expect (D.19925, 0);
  if (D.19926 != 0) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 573, "i == 5");
  <D.19928>:
  D.19930 = meta->tables[8].rows;
  D.19931 = (int) D.19930;
  if (D.19931 <= 65535) goto <D.19932>; else goto <D.19933>;
  <D.19932>:
  iftmp.17 = 2;
  goto <D.19934>;
  <D.19933>:
  iftmp.17 = 4;
  <D.19934>:
  field_size = iftmp.17;
  goto <D.18022>;
  <D.18034>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19935>; else goto <D.19936>;
  <D.19935>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 576, "i == 0");
  <D.19936>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19938>; else goto <D.19939>;
  <D.19938>:
  iftmp.18 = 2;
  goto <D.19940>;
  <D.19939>:
  iftmp.18 = 4;
  <D.19940>:
  field_size = iftmp.18;
  goto <D.18022>;
  <D.18035>:
  D.19839 = i != 1;
  D.19840 = (long int) D.19839;
  D.19841 = __builtin_expect (D.19840, 0);
  if (D.19841 != 0) goto <D.19941>; else goto <D.19942>;
  <D.19941>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 579, "i == 1");
  <D.19942>:
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  if (D.19945 <= 65535) goto <D.19946>; else goto <D.19947>;
  <D.19946>:
  iftmp.19 = 2;
  goto <D.19948>;
  <D.19947>:
  iftmp.19 = 4;
  <D.19948>:
  field_size = iftmp.19;
  goto <D.18022>;
  <D.18036>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19949>; else goto <D.19950>;
  <D.19949>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 582, "i == 0");
  <D.19950>:
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  if (D.19945 <= 65535) goto <D.19952>; else goto <D.19953>;
  <D.19952>:
  iftmp.20 = 2;
  goto <D.19954>;
  <D.19953>:
  iftmp.20 = 4;
  <D.19954>:
  field_size = iftmp.20;
  goto <D.18022>;
  <D.18037>:
  i.7 = (unsigned int) i;
  D.19860 = i.7 > 1;
  D.19861 = (long int) D.19860;
  D.19862 = __builtin_expect (D.19861, 0);
  if (D.19862 != 0) goto <D.19955>; else goto <D.19956>;
  <D.19955>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 585, "i == 0 || i == 1");
  <D.19956>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19958>; else goto <D.19959>;
  <D.19958>:
  iftmp.21 = 2;
  goto <D.19960>;
  <D.19959>:
  iftmp.21 = 4;
  <D.19960>:
  field_size = iftmp.21;
  goto <D.18022>;
  <D.18038>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19961>; else goto <D.19962>;
  <D.19961>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 588, "i == 0");
  <D.19962>:
  D.19930 = meta->tables[8].rows;
  D.19931 = (int) D.19930;
  if (D.19931 <= 65535) goto <D.19964>; else goto <D.19965>;
  <D.19964>:
  iftmp.22 = 2;
  goto <D.19966>;
  <D.19965>:
  iftmp.22 = 4;
  <D.19966>:
  field_size = iftmp.22;
  goto <D.18022>;
  <D.18039>:
  i.7 = (unsigned int) i;
  D.19860 = i.7 > 1;
  D.19861 = (long int) D.19860;
  D.19862 = __builtin_expect (D.19861, 0);
  if (D.19862 != 0) goto <D.19967>; else goto <D.19968>;
  <D.19967>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 591, "i == 0 || i == 1");
  <D.19968>:
  if (i != 0) goto <D.19970>; else goto <D.19971>;
  <D.19970>:
  D.19973 = meta->tables[23].rows;
  D.19974 = (int) D.19973;
  if (D.19974 <= 65535) goto <D.19975>; else goto <D.19976>;
  <D.19975>:
  iftmp.24 = 2;
  goto <D.19977>;
  <D.19976>:
  iftmp.24 = 4;
  <D.19977>:
  iftmp.23 = iftmp.24;
  goto <D.19978>;
  <D.19971>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  if (D.19855 <= 65535) goto <D.19980>; else goto <D.19981>;
  <D.19980>:
  iftmp.25 = 2;
  goto <D.19982>;
  <D.19981>:
  iftmp.25 = 4;
  <D.19982>:
  iftmp.23 = iftmp.25;
  <D.19978>:
  field_size = iftmp.23;
  goto <D.18022>;
  <D.18040>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.19983>; else goto <D.19984>;
  <D.19983>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 596, "i == 0");
  <D.19984>:
  D.19973 = meta->tables[23].rows;
  D.19974 = (int) D.19973;
  if (D.19974 <= 65535) goto <D.19986>; else goto <D.19987>;
  <D.19986>:
  iftmp.26 = 2;
  goto <D.19988>;
  <D.19987>:
  iftmp.26 = 4;
  <D.19988>:
  field_size = iftmp.26;
  goto <D.18022>;
  <D.18041>:
  i.7 = (unsigned int) i;
  D.19989 = i.7 + 4294967292;
  D.19990 = D.19989 > 1;
  D.19991 = (long int) D.19990;
  D.19992 = __builtin_expect (D.19991, 0);
  if (D.19992 != 0) goto <D.19993>; else goto <D.19994>;
  <D.19993>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 599, "i == 4 || i == 5");
  <D.19994>:
  if (i == 4) goto <D.19996>; else goto <D.19997>;
  <D.19996>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  if (D.19894 <= 65535) goto <D.19999>; else goto <D.20000>;
  <D.19999>:
  iftmp.28 = 2;
  goto <D.20001>;
  <D.20000>:
  iftmp.28 = 4;
  <D.20001>:
  iftmp.27 = iftmp.28;
  goto <D.20002>;
  <D.19997>:
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  if (D.19945 <= 65535) goto <D.20004>; else goto <D.20005>;
  <D.20004>:
  iftmp.29 = 2;
  goto <D.20006>;
  <D.20005>:
  iftmp.29 = 4;
  <D.20006>:
  iftmp.27 = iftmp.29;
  <D.20002>:
  field_size = iftmp.27;
  goto <D.18022>;
  <D.18042>:
  D.19848 = i != 2;
  D.19849 = (long int) D.19848;
  D.19850 = __builtin_expect (D.19849, 0);
  if (D.19850 != 0) goto <D.20007>; else goto <D.20008>;
  <D.20007>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 604, "i == 2");
  <D.20008>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  n = MAX_EXPR <D.19855, D.19945>;
  if (n <= 32767) goto <D.20010>; else goto <D.20011>;
  <D.20010>:
  iftmp.30 = 2;
  goto <D.20012>;
  <D.20011>:
  iftmp.30 = 4;
  <D.20012>:
  field_size = iftmp.30;
  goto <D.18022>;
  <D.18043>:
  D.19879 = i != 0;
  D.19880 = (long int) D.19879;
  D.19881 = __builtin_expect (D.19880, 0);
  if (D.19881 != 0) goto <D.20013>; else goto <D.20014>;
  <D.20013>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 610, "i == 0");
  <D.20014>:
  D.20016 = meta->tables[42].rows;
  D.20017 = (int) D.20016;
  if (D.20017 <= 65535) goto <D.20018>; else goto <D.20019>;
  <D.20018>:
  iftmp.31 = 2;
  goto <D.20020>;
  <D.20019>:
  iftmp.31 = 4;
  <D.20020>:
  field_size = iftmp.31;
  goto <D.18022>;
  <D.18044>:
  monoeg_g_log (0B, 4, "Can\'t handle MONO_MT_TABLE_IDX for table %d element %d", tableindex, i);
  <D.18045>:
  goto <D.18045>;
  <D.18022>:
  goto <D.18014>;
  <D.18046>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  D.19930 = meta->tables[8].rows;
  D.19931 = (int) D.19930;
  n = MAX_EXPR <D.19894, D.19931>;
  D.19973 = meta->tables[23].rows;
  D.19974 = (int) D.19973;
  n = MAX_EXPR <D.19974, n>;
  if (n <= 16383) goto <D.20022>; else goto <D.20023>;
  <D.20022>:
  iftmp.32 = 2;
  goto <D.20024>;
  <D.20023>:
  iftmp.32 = 4;
  <D.20024>:
  field_size = iftmp.32;
  goto <D.18014>;
  <D.18047>:
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  n = MAX_EXPR <D.19894, D.19945>;
  D.20025 = meta->tables[1].rows;
  D.20026 = (int) D.20025;
  n = MAX_EXPR <D.20026, n>;
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  n = MAX_EXPR <D.19855, n>;
  D.19930 = meta->tables[8].rows;
  D.19931 = (int) D.19930;
  n = MAX_EXPR <D.19931, n>;
  D.20027 = meta->tables[9].rows;
  D.20028 = (int) D.20027;
  n = MAX_EXPR <D.20028, n>;
  D.20029 = meta->tables[10].rows;
  D.20030 = (int) D.20029;
  n = MAX_EXPR <D.20030, n>;
  D.20031 = meta->tables[0].rows;
  D.20032 = (int) D.20031;
  n = MAX_EXPR <D.20032, n>;
  D.20033 = meta->tables[14].rows;
  D.20034 = (int) D.20033;
  n = MAX_EXPR <D.20034, n>;
  D.19973 = meta->tables[23].rows;
  D.19974 = (int) D.19973;
  n = MAX_EXPR <D.19974, n>;
  D.19869 = meta->tables[20].rows;
  D.19870 = (int) D.19869;
  n = MAX_EXPR <D.19870, n>;
  D.20035 = meta->tables[17].rows;
  D.20036 = (int) D.20035;
  n = MAX_EXPR <D.20036, n>;
  D.19913 = meta->tables[26].rows;
  D.19914 = (int) D.19913;
  n = MAX_EXPR <D.19914, n>;
  D.20037 = meta->tables[27].rows;
  D.20038 = (int) D.20037;
  n = MAX_EXPR <D.20038, n>;
  D.20039 = meta->tables[32].rows;
  D.20040 = (int) D.20039;
  n = MAX_EXPR <D.20040, n>;
  D.19834 = meta->tables[35].rows;
  D.19835 = (int) D.19834;
  n = MAX_EXPR <D.19835, n>;
  D.20041 = meta->tables[38].rows;
  D.20042 = (int) D.20041;
  n = MAX_EXPR <D.20042, n>;
  D.20043 = meta->tables[39].rows;
  D.20044 = (int) D.20043;
  n = MAX_EXPR <D.20044, n>;
  D.20045 = meta->tables[40].rows;
  D.20046 = (int) D.20045;
  n = MAX_EXPR <D.20046, n>;
  if (n <= 2047) goto <D.20048>; else goto <D.20049>;
  <D.20048>:
  iftmp.33 = 2;
  goto <D.20050>;
  <D.20049>:
  iftmp.33 = 4;
  <D.20050>:
  field_size = iftmp.33;
  goto <D.18014>;
  <D.18048>:
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  D.20025 = meta->tables[1].rows;
  D.20026 = (int) D.20025;
  n = MAX_EXPR <D.19855, D.20026>;
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  n = MAX_EXPR <D.19945, n>;
  D.20029 = meta->tables[10].rows;
  D.20030 = (int) D.20029;
  n = MAX_EXPR <D.20030, n>;
  if (n <= 8191) goto <D.20052>; else goto <D.20053>;
  <D.20052>:
  iftmp.34 = 2;
  goto <D.20054>;
  <D.20053>:
  iftmp.34 = 4;
  <D.20054>:
  field_size = iftmp.34;
  goto <D.18014>;
  <D.18049>:
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  n = MAX_EXPR <D.19945, D.19855>;
  D.20039 = meta->tables[32].rows;
  D.20040 = (int) D.20039;
  n = MAX_EXPR <D.20040, n>;
  if (n <= 16383) goto <D.20056>; else goto <D.20057>;
  <D.20056>:
  iftmp.35 = 2;
  goto <D.20058>;
  <D.20057>:
  iftmp.35 = 4;
  <D.20058>:
  field_size = iftmp.35;
  goto <D.18014>;
  <D.18050>:
  D.19834 = meta->tables[35].rows;
  D.19835 = (int) D.19834;
  D.20041 = meta->tables[38].rows;
  D.20042 = (int) D.20041;
  n = MAX_EXPR <D.19835, D.20042>;
  D.20043 = meta->tables[39].rows;
  D.20044 = (int) D.20043;
  n = MAX_EXPR <D.20044, n>;
  if (n <= 16383) goto <D.20060>; else goto <D.20061>;
  <D.20060>:
  iftmp.36 = 2;
  goto <D.20062>;
  <D.20061>:
  iftmp.36 = 4;
  <D.20062>:
  field_size = iftmp.36;
  goto <D.18014>;
  <D.18051>:
  D.19930 = meta->tables[8].rows;
  D.19931 = (int) D.19930;
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  n = MAX_EXPR <D.19931, D.19894>;
  if (n <= 32767) goto <D.20064>; else goto <D.20065>;
  <D.20064>:
  iftmp.37 = 2;
  goto <D.20066>;
  <D.20065>:
  iftmp.37 = 4;
  <D.20066>:
  field_size = iftmp.37;
  goto <D.18014>;
  <D.18052>:
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  D.19893 = meta->tables[4].rows;
  D.19894 = (int) D.19893;
  n = MAX_EXPR <D.19945, D.19894>;
  if (n <= 32767) goto <D.20068>; else goto <D.20069>;
  <D.20068>:
  iftmp.38 = 2;
  goto <D.20070>;
  <D.20069>:
  iftmp.38 = 4;
  <D.20070>:
  field_size = iftmp.38;
  goto <D.18014>;
  <D.18053>:
  D.20025 = meta->tables[1].rows;
  D.20026 = (int) D.20025;
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  n = MAX_EXPR <D.20026, D.19855>;
  D.20037 = meta->tables[27].rows;
  D.20038 = (int) D.20037;
  n = MAX_EXPR <D.20038, n>;
  if (n <= 16383) goto <D.20072>; else goto <D.20073>;
  <D.20072>:
  iftmp.39 = 2;
  goto <D.20074>;
  <D.20073>:
  iftmp.39 = 4;
  <D.20074>:
  field_size = iftmp.39;
  goto <D.18014>;
  <D.18054>:
  D.20025 = meta->tables[1].rows;
  D.20026 = (int) D.20025;
  D.19854 = meta->tables[2].rows;
  D.19855 = (int) D.19854;
  n = MAX_EXPR <D.20026, D.19855>;
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  n = MAX_EXPR <D.19945, n>;
  D.19913 = meta->tables[26].rows;
  D.19914 = (int) D.19913;
  n = MAX_EXPR <D.19914, n>;
  D.20037 = meta->tables[27].rows;
  D.20038 = (int) D.20037;
  n = MAX_EXPR <D.20038, n>;
  if (n <= 8191) goto <D.20076>; else goto <D.20077>;
  <D.20076>:
  iftmp.40 = 2;
  goto <D.20078>;
  <D.20077>:
  iftmp.40 = 4;
  <D.20078>:
  field_size = iftmp.40;
  goto <D.18014>;
  <D.18055>:
  D.20029 = meta->tables[10].rows;
  D.20030 = (int) D.20029;
  D.19944 = meta->tables[6].rows;
  D.19945 = (int) D.19944;
  n = MAX_EXPR <D.20030, D.19945>;
  if (n <= 32767) goto <D.20080>; else goto <D.20081>;
  <D.20080>:
  iftmp.41 = 2;
  goto <D.20082>;
  <D.20081>:
  iftmp.41 = 4;
  <D.20082>:
  field_size = iftmp.41;
  goto <D.18014>;
  <D.18056>:
  D.19869 = meta->tables[20].rows;
  D.19870 = (int) D.19869;
  D.19973 = meta->tables[23].rows;
  D.19974 = (int) D.19973;
  n = MAX_EXPR <D.19870, D.19974>;
  if (n <= 32767) goto <D.20084>; else goto <D.20085>;
  <D.20084>:
  iftmp.42 = 2;
  goto <D.20086>;
  <D.20085>:
  iftmp.42 = 4;
  <D.20086>:
  field_size = iftmp.42;
  goto <D.18014>;
  <D.18057>:
  D.19913 = meta->tables[26].rows;
  D.19914 = (int) D.19913;
  D.20031 = meta->tables[0].rows;
  D.20032 = (int) D.20031;
  n = MAX_EXPR <D.19914, D.20032>;
  D.19834 = meta->tables[35].rows;
  D.19835 = (int) D.19834;
  n = MAX_EXPR <D.19835, n>;
  D.20025 = meta->tables[1].rows;
  D.20026 = (int) D.20025;
  n = MAX_EXPR <D.20026, n>;
  if (n <= 16383) goto <D.20088>; else goto <D.20089>;
  <D.20088>:
  iftmp.43 = 2;
  goto <D.20090>;
  <D.20089>:
  iftmp.43 = 4;
  <D.20090>:
  field_size = iftmp.43;
  goto <D.18014>;
  <D.20091>:
  <D.18014>:
  D.20092 = field_size + -1;
  D.20093 = D.20092 << shift;
  D.20094 = (unsigned int) D.20093;
  bitfield = D.20094 | bitfield;
  shift = shift + 2;
  size = size + field_size;
  i = i + 1;
  <D.18059>:
  D.20095 = (sizetype) i;
  D.20096 = description + D.20095;
  D.20097 = *D.20096;
  code = (int) D.20097;
  if (code != 0) goto <D.18058>; else goto <D.18060>;
  <D.18060>:
  D.20098 = i << 24;
  D.20099 = (unsigned int) D.20098;
  D.20100 = D.20099 | bitfield;
  *result_bitfield = D.20100;
  D.20101 = size;
  return D.20101;
}


mono_metadata_compute_table_bases (struct MonoImage * meta)
{
  long unsigned int D.20103;
  long unsigned int D.20104;
  guint32 * D.20107;
  int D.20108;
  unsigned char D.20109;
  <unnamed-unsigned:24> D.20110;
  int D.20111;
  unsigned char D.20112;
  int D.20113;
  int D.20114;
  sizetype D.20115;
  int i;
  const char * base;

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

    table = &meta->tables[i];
    D.20103 = BIT_FIELD_REF <*table, 64, 64>;
    D.20104 = D.20103 & 16777215;
    if (D.20104 == 0) goto <D.20105>; else goto <D.20106>;
    <D.20105>:
    // predicted unlikely by continue predictor.
    goto <D.18067>;
    <D.20106>:
    D.20107 = &table->size_bitfield;
    D.20108 = mono_metadata_compute_size (meta, i, D.20107);
    D.20109 = (unsigned char) D.20108;
    table->row_size = D.20109;
    table->base = base;
    D.20110 = table->rows;
    D.20111 = (int) D.20110;
    D.20112 = table->row_size;
    D.20113 = (int) D.20112;
    D.20114 = D.20111 * D.20113;
    D.20115 = (sizetype) D.20114;
    base = base + D.20115;
  }
  <D.18067>:
  i = i + 1;
  <D.18069>:
  if (i <= 44) goto <D.18068>; else goto <D.18070>;
  <D.18070>:
}


mono_metadata_locate (struct MonoImage * meta, int table, int idx)
{
  <unnamed-unsigned:24> D.20119;
  int D.20120;
  const char * D.20121;
  const char * D.20122;
  unsigned char D.20123;
  int D.20124;
  int D.20125;
  int D.20126;
  sizetype D.20127;

  if (idx <= 0) goto <D.20116>; else goto <D.20118>;
  <D.20118>:
  D.20119 = meta->tables[table].rows;
  D.20120 = (int) D.20119;
  if (D.20120 < idx) goto <D.20116>; else goto <D.20117>;
  <D.20116>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 857, "idx > 0 && idx <= meta->tables [table].rows");
  D.20121 = "";
  return D.20121;
  <D.20117>:
  D.20122 = meta->tables[table].base;
  D.20123 = meta->tables[table].row_size;
  D.20124 = (int) D.20123;
  D.20125 = idx + -1;
  D.20126 = D.20124 * D.20125;
  D.20127 = (sizetype) D.20126;
  D.20121 = D.20122 + D.20127;
  return D.20121;
}


mono_metadata_locate_token (struct MonoImage * meta, guint32 token)
{
  const char * D.20129;
  unsigned int D.20130;
  int D.20131;
  int token.44;
  int D.20133;

  D.20130 = token >> 24;
  D.20131 = (int) D.20130;
  token.44 = (int) token;
  D.20133 = token.44 & 16777215;
  D.20129 = mono_metadata_locate (meta, D.20131, D.20133);
  return D.20129;
}


mono_metadata_string_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.20135;
  _Bool D.20136;
  long int D.20137;
  long int D.20138;
  const char * D.20143;
  const char * D.20144;
  sizetype D.20145;

  D.20135 = meta->heap_strings.size;
  D.20136 = D.20135 <= index;
  D.20137 = (long int) D.20136;
  D.20138 = __builtin_expect (D.20137, 0);
  if (D.20138 != 0) goto <D.20139>; else goto <D.20140>;
  <D.20139>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 886, "index < meta->heap_strings.size");
  <D.20140>:
  D.20135 = meta->heap_strings.size;
  if (D.20135 <= index) goto <D.20141>; else goto <D.20142>;
  <D.20141>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 887, "index < meta->heap_strings.size");
  D.20143 = "";
  return D.20143;
  <D.20142>:
  D.20144 = meta->heap_strings.data;
  D.20145 = (sizetype) index;
  D.20143 = D.20144 + D.20145;
  return D.20143;
}


mono_metadata_user_string (struct MonoImage * meta, guint32 index)
{
  unsigned int D.20147;
  _Bool D.20148;
  long int D.20149;
  long int D.20150;
  const char * D.20155;
  const char * D.20156;
  sizetype D.20157;

  D.20147 = meta->heap_us.size;
  D.20148 = D.20147 <= index;
  D.20149 = (long int) D.20148;
  D.20150 = __builtin_expect (D.20149, 0);
  if (D.20150 != 0) goto <D.20151>; else goto <D.20152>;
  <D.20151>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 901, "index < meta->heap_us.size");
  <D.20152>:
  D.20147 = meta->heap_us.size;
  if (D.20147 <= index) goto <D.20153>; else goto <D.20154>;
  <D.20153>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 902, "index < meta->heap_us.size");
  D.20155 = "";
  return D.20155;
  <D.20154>:
  D.20156 = meta->heap_us.data;
  D.20157 = (sizetype) index;
  D.20155 = D.20156 + D.20157;
  return D.20155;
}


mono_metadata_blob_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.20159;
  _Bool D.20160;
  long int D.20161;
  long int D.20162;
  const char * D.20167;
  const char * D.20168;
  sizetype D.20169;

  D.20159 = meta->heap_blob.size;
  D.20160 = D.20159 <= index;
  D.20161 = (long int) D.20160;
  D.20162 = __builtin_expect (D.20161, 0);
  if (D.20162 != 0) goto <D.20163>; else goto <D.20164>;
  <D.20163>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 916, "index < meta->heap_blob.size");
  <D.20164>:
  D.20159 = meta->heap_blob.size;
  if (D.20159 <= index) goto <D.20165>; else goto <D.20166>;
  <D.20165>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 917, "index < meta->heap_blob.size");
  D.20167 = "";
  return D.20167;
  <D.20166>:
  D.20168 = meta->heap_blob.data;
  D.20169 = (sizetype) index;
  D.20167 = D.20168 + D.20169;
  return D.20167;
}


mono_metadata_guid_heap (struct MonoImage * meta, guint32 index)
{
  unsigned int D.20171;
  const char * D.20174;
  const char * D.20175;
  sizetype D.20176;

  index = index + 4294967295;
  index = index * 16;
  D.20171 = meta->heap_guid.size;
  if (D.20171 <= index) goto <D.20172>; else goto <D.20173>;
  <D.20172>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 933, "index < meta->heap_guid.size");
  D.20174 = "";
  return D.20174;
  <D.20173>:
  D.20175 = meta->heap_guid.data;
  D.20176 = (sizetype) index;
  D.20174 = D.20175 + D.20176;
  return D.20174;
}


mono_metadata_decode_row (const struct MonoTableInfo * t, int idx, guint32 * res, int res_size)
{
  unsigned int D.20178;
  <unnamed-unsigned:24> D.20179;
  int D.20180;
  _Bool D.20181;
  long int D.20182;
  long int D.20183;
  _Bool D.20186;
  long int D.20187;
  long int D.20188;
  const char * D.20191;
  unsigned char D.20192;
  int D.20193;
  int D.20194;
  sizetype D.20195;
  _Bool D.20196;
  long int D.20197;
  long int D.20198;
  int D.20201;
  unsigned int D.20202;
  unsigned int D.20203;
  unsigned int D.20204;
  long unsigned int D.20205;
  long unsigned int D.20206;
  guint32 * D.20207;
  char D.20208;
  unsigned int D.20209;
  short unsigned int D.20210;
  unsigned int D.20211;
  unsigned int D.20212;
  sizetype D.20213;
  guint32 bitfield;
  int i;
  int count;
  const char * data;

  bitfield = t->size_bitfield;
  D.20178 = bitfield >> 24;
  count = (int) D.20178;
  D.20179 = t->rows;
  D.20180 = (int) D.20179;
  D.20181 = D.20180 <= idx;
  D.20182 = (long int) D.20181;
  D.20183 = __builtin_expect (D.20182, 0);
  if (D.20183 != 0) goto <D.20184>; else goto <D.20185>;
  <D.20184>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 963, "idx < t->rows");
  <D.20185>:
  D.20186 = idx < 0;
  D.20187 = (long int) D.20186;
  D.20188 = __builtin_expect (D.20187, 0);
  if (D.20188 != 0) goto <D.20189>; else goto <D.20190>;
  <D.20189>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 964, "idx >= 0");
  <D.20190>:
  D.20191 = t->base;
  D.20192 = t->row_size;
  D.20193 = (int) D.20192;
  D.20194 = D.20193 * idx;
  D.20195 = (sizetype) D.20194;
  data = D.20191 + D.20195;
  D.20196 = res_size != count;
  D.20197 = (long int) D.20196;
  D.20198 = __builtin_expect (D.20197, 0);
  if (D.20198 != 0) goto <D.20199>; else goto <D.20200>;
  <D.20199>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 967, "res_size == count");
  <D.20200>:
  i = 0;
  goto <D.18116>;
  <D.18115>:
  {
    int n;

    D.20201 = i * 2;
    D.20202 = bitfield >> D.20201;
    D.20203 = D.20202 & 3;
    D.20204 = D.20203 + 1;
    n = (int) D.20204;
    switch (n) <default: <D.18114>, case 1: <D.18110>, case 2: <D.18112>, case 4: <D.18113>>
    <D.18110>:
    D.20205 = (long unsigned int) i;
    D.20206 = D.20205 * 4;
    D.20207 = res + D.20206;
    D.20208 = *data;
    D.20209 = (unsigned int) D.20208;
    *D.20207 = D.20209;
    goto <D.18111>;
    <D.18112>:
    D.20205 = (long unsigned int) i;
    D.20206 = D.20205 * 4;
    D.20207 = res + D.20206;
    D.20210 = MEM[(const guint16 *)data];
    D.20211 = (unsigned int) D.20210;
    *D.20207 = D.20211;
    goto <D.18111>;
    <D.18113>:
    D.20205 = (long unsigned int) i;
    D.20206 = D.20205 * 4;
    D.20207 = res + D.20206;
    D.20212 = MEM[(const guint32 *)data];
    *D.20207 = D.20212;
    goto <D.18111>;
    <D.18114>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 980);
    <D.18111>:
    D.20213 = (sizetype) n;
    data = data + D.20213;
  }
  i = i + 1;
  <D.18116>:
  if (i < count) goto <D.18115>; else goto <D.18117>;
  <D.18117>:
}


mono_metadata_decode_row_col (const struct MonoTableInfo * t, int idx, guint col)
{
  <unnamed-unsigned:24> D.20214;
  int D.20215;
  _Bool D.20216;
  long int D.20217;
  long int D.20218;
  unsigned int D.20221;
  _Bool D.20222;
  long int D.20223;
  long int D.20224;
  const char * D.20227;
  unsigned char D.20228;
  int D.20229;
  int D.20230;
  sizetype D.20231;
  unsigned int D.20232;
  unsigned int D.20233;
  sizetype D.20234;
  int D.20235;
  int D.20236;
  unsigned int D.20237;
  unsigned int D.20238;
  unsigned int D.20239;
  unsigned int i.45;
  uint32_t D.20241;
  char D.20242;
  short unsigned int D.20243;
  guint32 bitfield;
  int i;
  register const char * data;
  register int n;

  bitfield = t->size_bitfield;
  D.20214 = t->rows;
  D.20215 = (int) D.20214;
  D.20216 = D.20215 <= idx;
  D.20217 = (long int) D.20216;
  D.20218 = __builtin_expect (D.20217, 0);
  if (D.20218 != 0) goto <D.20219>; else goto <D.20220>;
  <D.20219>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1003, "idx < t->rows");
  <D.20220>:
  D.20221 = bitfield >> 24;
  D.20222 = D.20221 <= col;
  D.20223 = (long int) D.20222;
  D.20224 = __builtin_expect (D.20223, 0);
  if (D.20224 != 0) goto <D.20225>; else goto <D.20226>;
  <D.20225>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1004, "col < mono_metadata_table_count (bitfield)");
  <D.20226>:
  D.20227 = t->base;
  D.20228 = t->row_size;
  D.20229 = (int) D.20228;
  D.20230 = D.20229 * idx;
  D.20231 = (sizetype) D.20230;
  data = D.20227 + D.20231;
  D.20232 = bitfield & 3;
  D.20233 = D.20232 + 1;
  n = (int) D.20233;
  i = 0;
  goto <D.18128>;
  <D.18127>:
  D.20234 = (sizetype) n;
  data = data + D.20234;
  D.20235 = i + 1;
  D.20236 = D.20235 * 2;
  D.20237 = bitfield >> D.20236;
  D.20238 = D.20237 & 3;
  D.20239 = D.20238 + 1;
  n = (int) D.20239;
  i = i + 1;
  <D.18128>:
  i.45 = (unsigned int) i;
  if (i.45 < col) goto <D.18127>; else goto <D.18129>;
  <D.18129>:
  switch (n) <default: <D.18133>, case 1: <D.18130>, case 2: <D.18131>, case 4: <D.18132>>
  <D.18130>:
  D.20242 = *data;
  D.20241 = (uint32_t) D.20242;
  return D.20241;
  <D.18131>:
  D.20243 = MEM[(const guint16 *)data];
  D.20241 = (uint32_t) D.20243;
  return D.20241;
  <D.18132>:
  D.20241 = MEM[(const guint32 *)data];
  return D.20241;
  <D.18133>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 1020);
  D.20241 = 0;
  return D.20241;
}


mono_metadata_decode_blob_size (const char * xptr, const char * * rptr)
{
  unsigned char D.20245;
  signed char D.20246;
  unsigned int D.20249;
  int D.20251;
  int D.20252;
  int D.20255;
  int D.20256;
  const unsigned char * D.20257;
  unsigned char D.20258;
  int D.20259;
  int D.20260;
  int D.20262;
  int D.20263;
  int D.20264;
  int D.20265;
  const unsigned char * D.20266;
  unsigned char D.20267;
  int D.20268;
  int D.20269;
  int D.20270;
  const unsigned char * D.20271;
  unsigned char D.20272;
  int D.20273;
  int D.20274;
  uint32_t D.20277;
  const unsigned char * ptr;
  guint32 size;

  ptr = xptr;
  D.20245 = *ptr;
  D.20246 = (signed char) D.20245;
  if (D.20246 >= 0) goto <D.20247>; else goto <D.20248>;
  <D.20247>:
  D.20245 = *ptr;
  D.20249 = (unsigned int) D.20245;
  size = D.20249 & 127;
  ptr = ptr + 1;
  goto <D.20250>;
  <D.20248>:
  D.20245 = *ptr;
  D.20251 = (int) D.20245;
  D.20252 = D.20251 & 64;
  if (D.20252 == 0) goto <D.20253>; else goto <D.20254>;
  <D.20253>:
  D.20245 = *ptr;
  D.20251 = (int) D.20245;
  D.20255 = D.20251 & 63;
  D.20256 = D.20255 << 8;
  D.20257 = ptr + 1;
  D.20258 = *D.20257;
  D.20259 = (int) D.20258;
  D.20260 = D.20256 + D.20259;
  size = (guint32) D.20260;
  ptr = ptr + 2;
  goto <D.20261>;
  <D.20254>:
  D.20245 = *ptr;
  D.20251 = (int) D.20245;
  D.20262 = D.20251 & 31;
  D.20263 = D.20262 << 24;
  D.20257 = ptr + 1;
  D.20258 = *D.20257;
  D.20259 = (int) D.20258;
  D.20264 = D.20259 << 16;
  D.20265 = D.20263 + D.20264;
  D.20266 = ptr + 2;
  D.20267 = *D.20266;
  D.20268 = (int) D.20267;
  D.20269 = D.20268 << 8;
  D.20270 = D.20265 + D.20269;
  D.20271 = ptr + 3;
  D.20272 = *D.20271;
  D.20273 = (int) D.20272;
  D.20274 = D.20270 + D.20273;
  size = (guint32) D.20274;
  ptr = ptr + 4;
  <D.20261>:
  <D.20250>:
  if (rptr != 0B) goto <D.20275>; else goto <D.20276>;
  <D.20275>:
  *rptr = ptr;
  <D.20276>:
  D.20277 = size;
  return D.20277;
}


mono_metadata_decode_value (const char * _ptr, const char * * rptr)
{
  signed char b.46;
  int D.20283;
  int D.20284;
  int D.20287;
  int D.20288;
  const unsigned char * D.20289;
  unsigned char D.20290;
  int D.20291;
  int D.20292;
  int D.20294;
  int D.20295;
  int D.20296;
  int D.20297;
  const unsigned char * D.20298;
  unsigned char D.20299;
  int D.20300;
  int D.20301;
  int D.20302;
  const unsigned char * D.20303;
  unsigned char D.20304;
  int D.20305;
  int D.20306;
  uint32_t D.20309;
  const unsigned char * ptr;
  unsigned char b;
  guint32 len;

  ptr = _ptr;
  b = *ptr;
  b.46 = (signed char) b;
  if (b.46 >= 0) goto <D.20280>; else goto <D.20281>;
  <D.20280>:
  len = (guint32) b;
  ptr = ptr + 1;
  goto <D.20282>;
  <D.20281>:
  D.20283 = (int) b;
  D.20284 = D.20283 & 64;
  if (D.20284 == 0) goto <D.20285>; else goto <D.20286>;
  <D.20285>:
  D.20283 = (int) b;
  D.20287 = D.20283 & 63;
  D.20288 = D.20287 << 8;
  D.20289 = ptr + 1;
  D.20290 = *D.20289;
  D.20291 = (int) D.20290;
  D.20292 = D.20288 | D.20291;
  len = (guint32) D.20292;
  ptr = ptr + 2;
  goto <D.20293>;
  <D.20286>:
  D.20283 = (int) b;
  D.20294 = D.20283 & 31;
  D.20295 = D.20294 << 24;
  D.20289 = ptr + 1;
  D.20290 = *D.20289;
  D.20291 = (int) D.20290;
  D.20296 = D.20291 << 16;
  D.20297 = D.20295 | D.20296;
  D.20298 = ptr + 2;
  D.20299 = *D.20298;
  D.20300 = (int) D.20299;
  D.20301 = D.20300 << 8;
  D.20302 = D.20297 | D.20301;
  D.20303 = ptr + 3;
  D.20304 = *D.20303;
  D.20305 = (int) D.20304;
  D.20306 = D.20302 | D.20305;
  len = (guint32) D.20306;
  ptr = ptr + 4;
  <D.20293>:
  <D.20282>:
  if (rptr != 0B) goto <D.20307>; else goto <D.20308>;
  <D.20307>:
  *rptr = ptr;
  <D.20308>:
  D.20309 = len;
  return D.20309;
}


mono_metadata_decode_signed_value (const char * ptr, const char * * rptr)
{
  unsigned int D.20311;
  unsigned int D.20312;
  int32_t D.20315;
  _Bool D.20322;
  long int D.20323;
  long int D.20324;
  guint32 uval;
  gint32 ival;

  uval = mono_metadata_decode_value (ptr, rptr);
  D.20311 = uval >> 1;
  ival = (gint32) D.20311;
  D.20312 = uval & 1;
  if (D.20312 == 0) goto <D.20313>; else goto <D.20314>;
  <D.20313>:
  D.20315 = ival;
  return D.20315;
  <D.20314>:
  if (ival <= 63) goto <D.20316>; else goto <D.20317>;
  <D.20316>:
  D.20315 = ival + -64;
  return D.20315;
  <D.20317>:
  if (ival <= 8191) goto <D.20318>; else goto <D.20319>;
  <D.20318>:
  D.20315 = ival + -8192;
  return D.20315;
  <D.20319>:
  if (ival <= 268435455) goto <D.20320>; else goto <D.20321>;
  <D.20320>:
  D.20315 = ival + -268435456;
  return D.20315;
  <D.20321>:
  D.20322 = ival > 536870911;
  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", 1121, "ival < 0x20000000");
  <D.20326>:
  monoeg_g_log (0B, 16, "compressed signed value appears to use 29 bits for compressed representation: %x (raw: %8x)", ival, uval);
  D.20315 = ival + -536870912;
  return D.20315;
}


mono_metadata_translate_token_index (struct MonoImage * image, int table, guint32 idx)
{
  long unsigned int D.20328;
  long unsigned int D.20329;
  uint32_t D.20332;
  long unsigned int D.20333;
  long unsigned int D.20334;
  struct MonoTableInfo * D.20337;
  unsigned int D.20338;
  int D.20339;
  long unsigned int D.20340;
  long unsigned int D.20341;
  struct MonoTableInfo * D.20344;
  long unsigned int D.20345;
  long unsigned int D.20346;
  struct MonoTableInfo * D.20349;
  long unsigned int D.20350;
  long unsigned int D.20351;
  struct MonoTableInfo * D.20354;
  long unsigned int D.20355;
  long unsigned int D.20356;
  struct MonoTableInfo * D.20359;

  D.20328 = BIT_FIELD_REF <*image, 64, 192>;
  D.20329 = D.20328 & 137438953472;
  if (D.20329 == 0) goto <D.20330>; else goto <D.20331>;
  <D.20330>:
  D.20332 = idx;
  return D.20332;
  <D.20331>:
  switch (table) <default: <D.18163>, case 4: <D.18159>, case 6: <D.18158>, case 8: <D.18162>, case 20: <D.18160>, case 23: <D.18161>>
  <D.18158>:
  D.20333 = BIT_FIELD_REF <*image, 64, 2240>;
  D.20334 = D.20333 & 16777215;
  if (D.20334 != 0) goto <D.20335>; else goto <D.20336>;
  <D.20335>:
  D.20337 = &image->tables[5];
  D.20338 = idx + 4294967295;
  D.20339 = (int) D.20338;
  D.20332 = mono_metadata_decode_row_col (D.20337, D.20339, 0);
  return D.20332;
  <D.20336>:
  D.20332 = idx;
  return D.20332;
  <D.18159>:
  D.20340 = BIT_FIELD_REF <*image, 64, 1984>;
  D.20341 = D.20340 & 16777215;
  if (D.20341 != 0) goto <D.20342>; else goto <D.20343>;
  <D.20342>:
  D.20344 = &image->tables[3];
  D.20338 = idx + 4294967295;
  D.20339 = (int) D.20338;
  D.20332 = mono_metadata_decode_row_col (D.20344, D.20339, 0);
  return D.20332;
  <D.20343>:
  D.20332 = idx;
  return D.20332;
  <D.18160>:
  D.20345 = BIT_FIELD_REF <*image, 64, 4032>;
  D.20346 = D.20345 & 16777215;
  if (D.20346 != 0) goto <D.20347>; else goto <D.20348>;
  <D.20347>:
  D.20349 = &image->tables[19];
  D.20338 = idx + 4294967295;
  D.20339 = (int) D.20338;
  D.20332 = mono_metadata_decode_row_col (D.20349, D.20339, 0);
  return D.20332;
  <D.20348>:
  D.20332 = idx;
  return D.20332;
  <D.18161>:
  D.20350 = BIT_FIELD_REF <*image, 64, 4416>;
  D.20351 = D.20350 & 16777215;
  if (D.20351 != 0) goto <D.20352>; else goto <D.20353>;
  <D.20352>:
  D.20354 = &image->tables[22];
  D.20338 = idx + 4294967295;
  D.20339 = (int) D.20338;
  D.20332 = mono_metadata_decode_row_col (D.20354, D.20339, 0);
  return D.20332;
  <D.20353>:
  D.20332 = idx;
  return D.20332;
  <D.18162>:
  D.20355 = BIT_FIELD_REF <*image, 64, 2496>;
  D.20356 = D.20355 & 16777215;
  if (D.20356 != 0) goto <D.20357>; else goto <D.20358>;
  <D.20357>:
  D.20359 = &image->tables[7];
  D.20338 = idx + 4294967295;
  D.20339 = (int) D.20338;
  D.20332 = mono_metadata_decode_row_col (D.20359, D.20339, 0);
  return D.20332;
  <D.20358>:
  D.20332 = idx;
  return D.20332;
  <D.18163>:
  D.20332 = idx;
  return D.20332;
}


mono_metadata_decode_table_row (struct MonoImage * image, int table, int idx, guint32 * res, int res_size)
{
  long unsigned int D.20361;
  long unsigned int D.20362;
  int D.20365;
  unsigned int D.20366;
  unsigned int D.20367;
  unsigned int D.20368;
  struct MonoTableInfo * D.20369;

  D.20361 = BIT_FIELD_REF <*image, 64, 192>;
  D.20362 = D.20361 & 137438953472;
  if (D.20362 != 0) goto <D.20363>; else goto <D.20364>;
  <D.20363>:
  D.20365 = idx + 1;
  D.20366 = (unsigned int) D.20365;
  D.20367 = mono_metadata_translate_token_index (image, table, D.20366);
  D.20368 = D.20367 + 4294967295;
  idx = (int) D.20368;
  <D.20364>:
  D.20369 = &image->tables[table];
  mono_metadata_decode_row (D.20369, idx, res, res_size);
}


mono_metadata_decode_table_row_col (struct MonoImage * image, int table, int idx, guint col)
{
  long unsigned int D.20370;
  long unsigned int D.20371;
  int D.20374;
  unsigned int D.20375;
  unsigned int D.20376;
  unsigned int D.20377;
  uint32_t D.20378;
  struct MonoTableInfo * D.20379;

  D.20370 = BIT_FIELD_REF <*image, 64, 192>;
  D.20371 = D.20370 & 137438953472;
  if (D.20371 != 0) goto <D.20372>; else goto <D.20373>;
  <D.20372>:
  D.20374 = idx + 1;
  D.20375 = (unsigned int) D.20374;
  D.20376 = mono_metadata_translate_token_index (image, table, D.20375);
  D.20377 = D.20376 + 4294967295;
  idx = (int) D.20377;
  <D.20373>:
  D.20379 = &image->tables[table];
  D.20378 = mono_metadata_decode_row_col (D.20379, idx, col);
  return D.20378;
}


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

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


mono_metadata_parse_custom_mod (struct MonoImage * m, struct MonoCustomMod * dest, const char * ptr, const char * * rptr)
{
  char D.20386;
  char D.20387;
  _Bool D.20392;
  const char * D.20393;
  unsigned int D.20394;
  <unnamed-unsigned:31> D.20395;
  int D.20396;
  struct MonoCustomMod local;

  try
    {
      D.20386 = *ptr;
      D.20387 = D.20386 + 225;
      if (D.20387 <= 1) goto <D.20388>; else goto <D.20389>;
      <D.20388>:
      if (dest == 0B) goto <D.20390>; else goto <D.20391>;
      <D.20390>:
      dest = &local;
      <D.20391>:
      D.20386 = *ptr;
      D.20392 = D.20386 == 31;
      dest->required = D.20392;
      D.20393 = ptr + 1;
      D.20394 = mono_metadata_parse_typedef_or_ref (m, D.20393, rptr);
      D.20395 = (<unnamed-unsigned:31>) D.20394;
      dest->token = D.20395;
      D.20396 = 1;
      return D.20396;
      <D.20389>:
      D.20396 = 0;
      return D.20396;
    }
  finally
    {
      local = {CLOBBER};
    }
}


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

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


mono_metadata_parse_array_internal (struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  void * iftmp.48;
  const char * ptr.49;
  struct MonoArrayType * D.20408;
  struct MonoClass * D.20409;
  unsigned int D.20410;
  unsigned char D.20411;
  unsigned int D.20412;
  unsigned char D.20413;
  unsigned char D.20414;
  void * iftmp.50;
  long unsigned int D.20420;
  long unsigned int D.20421;
  unsigned int D.20423;
  unsigned int D.20424;
  int * D.20425;
  long unsigned int D.20426;
  long unsigned int D.20427;
  int * D.20428;
  unsigned int D.20429;
  int D.20430;
  int D.20431;
  unsigned int D.20432;
  unsigned char D.20433;
  unsigned char D.20434;
  void * iftmp.51;
  long unsigned int D.20440;
  long unsigned int D.20441;
  unsigned int D.20443;
  unsigned int D.20444;
  int * D.20445;
  int * D.20446;
  int D.20447;
  int D.20448;
  int i;
  struct MonoArrayType * array;
  struct MonoType * etype;

  if (transient != 0) goto <D.20402>; else goto <D.20403>;
  <D.20402>:
  iftmp.48 = monoeg_malloc0 (32);
  goto <D.20404>;
  <D.20403>:
  iftmp.48 = mono_image_alloc0 (m, 32);
  <D.20404>:
  array = iftmp.48;
  ptr.49 = ptr;
  etype = mono_metadata_parse_type_full (m, container, 0, 0, ptr.49, &ptr);
  if (etype == 0B) goto <D.20406>; else goto <D.20407>;
  <D.20406>:
  D.20408 = 0B;
  return D.20408;
  <D.20407>:
  D.20409 = mono_class_from_mono_type (etype);
  array->eklass = D.20409;
  ptr.49 = ptr;
  D.20410 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20411 = (unsigned char) D.20410;
  array->rank = D.20411;
  ptr.49 = ptr;
  D.20412 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20413 = (unsigned char) D.20412;
  array->numsizes = D.20413;
  D.20414 = array->numsizes;
  if (D.20414 != 0) goto <D.20415>; else goto <D.20416>;
  <D.20415>:
  if (transient != 0) goto <D.20418>; else goto <D.20419>;
  <D.20418>:
  D.20414 = array->numsizes;
  D.20420 = (long unsigned int) D.20414;
  D.20421 = D.20420 * 4;
  iftmp.50 = monoeg_malloc0 (D.20421);
  goto <D.20422>;
  <D.20419>:
  D.20414 = array->numsizes;
  D.20423 = (unsigned int) D.20414;
  D.20424 = D.20423 * 4;
  iftmp.50 = mono_image_alloc0 (m, D.20424);
  <D.20422>:
  array->sizes = iftmp.50;
  <D.20416>:
  i = 0;
  goto <D.18201>;
  <D.18200>:
  D.20425 = array->sizes;
  D.20426 = (long unsigned int) i;
  D.20427 = D.20426 * 4;
  D.20428 = D.20425 + D.20427;
  ptr.49 = ptr;
  D.20429 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20430 = (int) D.20429;
  *D.20428 = D.20430;
  i = i + 1;
  <D.18201>:
  D.20414 = array->numsizes;
  D.20431 = (int) D.20414;
  if (D.20431 > i) goto <D.18200>; else goto <D.18202>;
  <D.18202>:
  ptr.49 = ptr;
  D.20432 = mono_metadata_decode_value (ptr.49, &ptr);
  D.20433 = (unsigned char) D.20432;
  array->numlobounds = D.20433;
  D.20434 = array->numlobounds;
  if (D.20434 != 0) goto <D.20435>; else goto <D.20436>;
  <D.20435>:
  if (transient != 0) goto <D.20438>; else goto <D.20439>;
  <D.20438>:
  D.20434 = array->numlobounds;
  D.20440 = (long unsigned int) D.20434;
  D.20441 = D.20440 * 4;
  iftmp.51 = monoeg_malloc0 (D.20441);
  goto <D.20442>;
  <D.20439>:
  D.20434 = array->numlobounds;
  D.20443 = (unsigned int) D.20434;
  D.20444 = D.20443 * 4;
  iftmp.51 = mono_image_alloc0 (m, D.20444);
  <D.20442>:
  array->lobounds = iftmp.51;
  <D.20436>:
  i = 0;
  goto <D.18204>;
  <D.18203>:
  D.20445 = array->lobounds;
  D.20426 = (long unsigned int) i;
  D.20427 = D.20426 * 4;
  D.20446 = D.20445 + D.20427;
  ptr.49 = ptr;
  D.20447 = mono_metadata_decode_signed_value (ptr.49, &ptr);
  *D.20446 = D.20447;
  i = i + 1;
  <D.18204>:
  D.20434 = array->numlobounds;
  D.20448 = (int) D.20434;
  if (D.20448 > i) goto <D.18203>; else goto <D.18205>;
  <D.18205>:
  if (rptr != 0B) goto <D.20449>; else goto <D.20450>;
  <D.20449>:
  ptr.49 = ptr;
  *rptr = ptr.49;
  <D.20450>:
  D.20408 = array;
  return D.20408;
}


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

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


mono_metadata_free_array (struct MonoArrayType * array)
{
  int * D.20454;
  int * D.20455;

  D.20454 = array->sizes;
  monoeg_g_free (D.20454);
  D.20455 = array->lobounds;
  monoeg_g_free (D.20455);
  monoeg_g_free (array);
}


mono_metadata_generic_inst_hash (const void * data)
{
  struct MonoType * D.20456;
  unsigned int D.20457;
  <unnamed-unsigned:22> D.20458;
  int D.20459;
  guint D.20460;
  <unnamed-unsigned:1> D.20461;
  int D.20462;
  int D.20463;
  unsigned int D.20464;
  const struct MonoGenericInst * ginst;
  guint hash;
  int i;

  ginst = data;
  hash = 0;
  i = 0;
  goto <D.18244>;
  <D.18243>:
  hash = hash * 13;
  D.20456 = ginst->type_argv[i];
  D.20457 = mono_metadata_type_hash (D.20456);
  hash = D.20457 + hash;
  i = i + 1;
  <D.18244>:
  D.20458 = ginst->type_argc;
  D.20459 = (int) D.20458;
  if (D.20459 > i) goto <D.18243>; else goto <D.18245>;
  <D.18245>:
  D.20461 = ginst->is_open;
  D.20462 = (int) D.20461;
  D.20463 = D.20462 << 8;
  D.20464 = (unsigned int) D.20463;
  D.20460 = D.20464 ^ hash;
  return D.20460;
}


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

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


mono_generic_inst_equal_full (const struct MonoGenericInst * a, const struct MonoGenericInst * b, gboolean signature_only)
{
  unsigned int D.20468;
  unsigned int D.20471;
  gboolean D.20476;
  long unsigned int D.20479;
  long unsigned int D.20480;
  long unsigned int D.20481;
  long unsigned int D.20482;
  struct MonoType * D.20485;
  struct MonoType * D.20486;
  int D.20487;
  <unnamed-unsigned:22> D.20490;
  int D.20491;
  int i;

  D.20468 = a->id;
  if (D.20468 != 0) goto <D.20469>; else goto <D.20470>;
  <D.20469>:
  D.20471 = b->id;
  if (D.20471 != 0) goto <D.20472>; else goto <D.20473>;
  <D.20472>:
  D.20468 = a->id;
  D.20471 = b->id;
  if (D.20468 == D.20471) goto <D.20474>; else goto <D.20475>;
  <D.20474>:
  D.20476 = 1;
  return D.20476;
  <D.20475>:
  if (signature_only == 0) goto <D.20477>; else goto <D.20478>;
  <D.20477>:
  D.20476 = 0;
  return D.20476;
  <D.20478>:
  <D.20473>:
  <D.20470>:
  D.20479 = BIT_FIELD_REF <*a, 64, 0>;
  D.20480 = BIT_FIELD_REF <*b, 64, 0>;
  D.20481 = D.20479 ^ D.20480;
  D.20482 = D.20481 & 36028792723996672;
  if (D.20482 != 0) goto <D.20483>; else goto <D.20484>;
  <D.20483>:
  D.20476 = 0;
  return D.20476;
  <D.20484>:
  i = 0;
  goto <D.18253>;
  <D.18252>:
  D.20485 = a->type_argv[i];
  D.20486 = b->type_argv[i];
  D.20487 = do_mono_metadata_type_equal (D.20485, D.20486, signature_only);
  if (D.20487 == 0) goto <D.20488>; else goto <D.20489>;
  <D.20488>:
  D.20476 = 0;
  return D.20476;
  <D.20489>:
  i = i + 1;
  <D.18253>:
  D.20490 = a->type_argc;
  D.20491 = (int) D.20490;
  if (D.20491 > i) goto <D.18252>; else goto <D.18254>;
  <D.18254>:
  D.20476 = 1;
  return D.20476;
}


do_mono_metadata_type_equal (struct MonoType * t1, struct MonoType * t2, gboolean signature_only)
{
  unsigned char D.20495;
  unsigned char D.20496;
  long unsigned int D.20498;
  long unsigned int D.20499;
  long unsigned int D.20500;
  long unsigned int D.20501;
  gboolean D.20502;
  int D.20503;
  struct MonoClass * D.20504;
  struct MonoClass * D.20505;
  struct MonoType * D.20506;
  struct MonoType * D.20507;
  struct MonoArrayType * D.20508;
  unsigned char D.20509;
  struct MonoArrayType * D.20510;
  unsigned char D.20511;
  struct MonoClass * D.20514;
  struct MonoClass * D.20515;
  struct MonoGenericClass * D.20516;
  struct MonoGenericClass * D.20517;
  struct MonoGenericParam * D.20518;
  struct MonoGenericParam * D.20519;
  struct MonoMethodSignature * D.20520;
  struct MonoMethodSignature * D.20521;

  D.20495 = t1->type;
  D.20496 = t2->type;
  if (D.20495 != D.20496) goto <D.20493>; else goto <D.20497>;
  <D.20497>:
  D.20498 = BIT_FIELD_REF <*t1, 64, 64>;
  D.20499 = BIT_FIELD_REF <*t2, 64, 64>;
  D.20500 = D.20498 ^ D.20499;
  D.20501 = D.20500 & 1073741824;
  if (D.20501 != 0) goto <D.20493>; else goto <D.20494>;
  <D.20493>:
  D.20502 = 0;
  return D.20502;
  <D.20494>:
  D.20495 = t1->type;
  D.20503 = (int) D.20495;
  switch (D.20503) <default: <D.19363>, case 1: <D.19336>, case 2: <D.19337>, case 3: <D.19338>, case 4: <D.19339>, case 5: <D.19340>, case 6: <D.19341>, case 7: <D.19342>, case 8: <D.19343>, case 9: <D.19344>, case 10: <D.19345>, case 11: <D.19346>, case 12: <D.19347>, case 13: <D.19348>, case 14: <D.19349>, case 15: <D.19357>, case 17: <D.19354>, case 18: <D.19355>, case 19: <D.19360>, case 20: <D.19358>, case 21: <D.19359>, case 22: <D.19353>, case 24: <D.19350>, case 25: <D.19351>, case 27: <D.19362>, case 28: <D.19352>, case 29: <D.19356>, case 30: <D.19361>>
  <D.19336>:
  <D.19337>:
  <D.19338>:
  <D.19339>:
  <D.19340>:
  <D.19341>:
  <D.19342>:
  <D.19343>:
  <D.19344>:
  <D.19345>:
  <D.19346>:
  <D.19347>:
  <D.19348>:
  <D.19349>:
  <D.19350>:
  <D.19351>:
  <D.19352>:
  <D.19353>:
  D.20502 = 1;
  return D.20502;
  <D.19354>:
  <D.19355>:
  <D.19356>:
  D.20504 = t1->data.klass;
  D.20505 = t2->data.klass;
  D.20502 = mono_metadata_class_equal (D.20504, D.20505, signature_only);
  return D.20502;
  <D.19357>:
  D.20506 = t1->data.type;
  D.20507 = t2->data.type;
  D.20502 = do_mono_metadata_type_equal (D.20506, D.20507, signature_only);
  return D.20502;
  <D.19358>:
  D.20508 = t1->data.array;
  D.20509 = D.20508->rank;
  D.20510 = t2->data.array;
  D.20511 = D.20510->rank;
  if (D.20509 != D.20511) goto <D.20512>; else goto <D.20513>;
  <D.20512>:
  D.20502 = 0;
  return D.20502;
  <D.20513>:
  D.20508 = t1->data.array;
  D.20514 = D.20508->eklass;
  D.20510 = t2->data.array;
  D.20515 = D.20510->eklass;
  D.20502 = mono_metadata_class_equal (D.20514, D.20515, signature_only);
  return D.20502;
  <D.19359>:
  D.20516 = t1->data.generic_class;
  D.20517 = t2->data.generic_class;
  D.20502 = _mono_metadata_generic_class_equal (D.20516, D.20517, signature_only);
  return D.20502;
  <D.19360>:
  D.20518 = t1->data.generic_param;
  D.20519 = t2->data.generic_param;
  D.20502 = mono_metadata_generic_param_equal (D.20518, D.20519, signature_only);
  return D.20502;
  <D.19361>:
  D.20518 = t1->data.generic_param;
  D.20519 = t2->data.generic_param;
  D.20502 = mono_metadata_generic_param_equal (D.20518, D.20519, signature_only);
  return D.20502;
  <D.19362>:
  D.20520 = t1->data.method;
  D.20521 = t2->data.method;
  D.20502 = mono_metadata_fnptr_equal (D.20520, D.20521, signature_only);
  return D.20502;
  <D.19363>:
  D.20495 = t1->type;
  D.20503 = (int) D.20495;
  monoeg_g_log (0B, 4, "implement type compare for %0x!", D.20503);
  <D.19364>:
  goto <D.19364>;
  D.20502 = 0;
  return D.20502;
  D.20502 = 0;
  return D.20502;
}


mono_metadata_class_equal (struct MonoClass * c1, struct MonoClass * c2, gboolean signature_only)
{
  gboolean D.20525;
  struct MonoGenericClass * D.20526;
  struct MonoGenericClass * D.20529;
  struct MonoGenericContainer * D.20534;
  struct MonoGenericContainer * D.20537;
  unsigned char D.20542;
  unsigned char D.20545;
  struct MonoGenericParam * D.20548;
  struct MonoGenericParam * D.20549;
  struct MonoClass * D.20560;
  struct MonoClass * D.20561;
  struct MonoType * D.20568;
  struct MonoType * D.20569;

  if (c1 == c2) goto <D.20523>; else goto <D.20524>;
  <D.20523>:
  D.20525 = 1;
  return D.20525;
  <D.20524>:
  D.20526 = c1->generic_class;
  if (D.20526 != 0B) goto <D.20527>; else goto <D.20528>;
  <D.20527>:
  D.20529 = c2->generic_class;
  if (D.20529 != 0B) goto <D.20530>; else goto <D.20531>;
  <D.20530>:
  D.20526 = c1->generic_class;
  D.20529 = c2->generic_class;
  D.20525 = _mono_metadata_generic_class_equal (D.20526, D.20529, signature_only);
  return D.20525;
  <D.20531>:
  <D.20528>:
  D.20526 = c1->generic_class;
  if (D.20526 != 0B) goto <D.20532>; else goto <D.20533>;
  <D.20532>:
  D.20534 = c2->generic_container;
  if (D.20534 != 0B) goto <D.20535>; else goto <D.20536>;
  <D.20535>:
  D.20526 = c1->generic_class;
  D.20525 = _mono_metadata_generic_class_container_equal (D.20526, c2, signature_only);
  return D.20525;
  <D.20536>:
  <D.20533>:
  D.20537 = c1->generic_container;
  if (D.20537 != 0B) goto <D.20538>; else goto <D.20539>;
  <D.20538>:
  D.20529 = c2->generic_class;
  if (D.20529 != 0B) goto <D.20540>; else goto <D.20541>;
  <D.20540>:
  D.20529 = c2->generic_class;
  D.20525 = _mono_metadata_generic_class_container_equal (D.20529, c1, signature_only);
  return D.20525;
  <D.20541>:
  <D.20539>:
  D.20542 = c1->byval_arg.type;
  if (D.20542 == 19) goto <D.20543>; else goto <D.20544>;
  <D.20543>:
  D.20545 = c2->byval_arg.type;
  if (D.20545 == 19) goto <D.20546>; else goto <D.20547>;
  <D.20546>:
  D.20548 = c1->byval_arg.data.generic_param;
  D.20549 = c2->byval_arg.data.generic_param;
  D.20525 = mono_metadata_generic_param_equal (D.20548, D.20549, signature_only);
  return D.20525;
  <D.20547>:
  <D.20544>:
  D.20542 = c1->byval_arg.type;
  if (D.20542 == 30) goto <D.20550>; else goto <D.20551>;
  <D.20550>:
  D.20545 = c2->byval_arg.type;
  if (D.20545 == 30) goto <D.20552>; else goto <D.20553>;
  <D.20552>:
  D.20548 = c1->byval_arg.data.generic_param;
  D.20549 = c2->byval_arg.data.generic_param;
  D.20525 = mono_metadata_generic_param_equal (D.20548, D.20549, signature_only);
  return D.20525;
  <D.20553>:
  <D.20551>:
  if (signature_only != 0) goto <D.20554>; else goto <D.20555>;
  <D.20554>:
  D.20542 = c1->byval_arg.type;
  if (D.20542 == 29) goto <D.20556>; else goto <D.20557>;
  <D.20556>:
  D.20545 = c2->byval_arg.type;
  if (D.20545 == 29) goto <D.20558>; else goto <D.20559>;
  <D.20558>:
  D.20560 = c1->byval_arg.data.klass;
  D.20561 = c2->byval_arg.data.klass;
  D.20525 = mono_metadata_class_equal (D.20560, D.20561, signature_only);
  return D.20525;
  <D.20559>:
  <D.20557>:
  <D.20555>:
  if (signature_only != 0) goto <D.20562>; else goto <D.20563>;
  <D.20562>:
  D.20542 = c1->byval_arg.type;
  if (D.20542 == 20) goto <D.20564>; else goto <D.20565>;
  <D.20564>:
  D.20545 = c2->byval_arg.type;
  if (D.20545 == 20) goto <D.20566>; else goto <D.20567>;
  <D.20566>:
  D.20568 = &c1->byval_arg;
  D.20569 = &c2->byval_arg;
  D.20525 = do_mono_metadata_type_equal (D.20568, D.20569, signature_only);
  return D.20525;
  <D.20567>:
  <D.20565>:
  <D.20563>:
  D.20525 = 0;
  return D.20525;
}


_mono_metadata_generic_class_container_equal (const struct MonoGenericClass * g1, struct MonoClass * c2, gboolean signature_only)
{
  struct MonoGenericContainer * D.20571;
  struct MonoClass * D.20572;
  int D.20573;
  gboolean D.20576;
  int D.20577;
  long unsigned int D.20580;
  long unsigned int D.20581;
  _Bool D.20582;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  D.20571 = c2->generic_container;
  i2 = D.20571->context.class_inst;
  D.20572 = g1->container_class;
  D.20573 = mono_metadata_class_equal (D.20572, c2, signature_only);
  if (D.20573 == 0) goto <D.20574>; else goto <D.20575>;
  <D.20574>:
  D.20576 = 0;
  return D.20576;
  <D.20575>:
  D.20577 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20577 == 0) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  D.20576 = 0;
  return D.20576;
  <D.20579>:
  D.20580 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20581 = D.20580 & 2;
  D.20582 = D.20581 == 0;
  D.20576 = (gboolean) D.20582;
  return D.20576;
}


_mono_metadata_generic_class_equal (const struct MonoGenericClass * g1, const struct MonoGenericClass * g2, gboolean signature_only)
{
  long unsigned int D.20584;
  long unsigned int D.20585;
  long unsigned int D.20586;
  long unsigned int D.20587;
  gboolean D.20590;
  struct MonoClass * D.20591;
  struct MonoClass * D.20592;
  int D.20593;
  int D.20596;
  long unsigned int D.20599;
  _Bool D.20600;
  struct MonoGenericInst * i1;
  struct MonoGenericInst * i2;

  i1 = g1->context.class_inst;
  i2 = g2->context.class_inst;
  D.20584 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20585 = BIT_FIELD_REF <*g2, 64, 192>;
  D.20586 = D.20584 ^ D.20585;
  D.20587 = D.20586 & 1;
  if (D.20587 != 0) goto <D.20588>; else goto <D.20589>;
  <D.20588>:
  D.20590 = 0;
  return D.20590;
  <D.20589>:
  D.20591 = g1->container_class;
  D.20592 = g2->container_class;
  D.20593 = mono_metadata_class_equal (D.20591, D.20592, signature_only);
  if (D.20593 == 0) goto <D.20594>; else goto <D.20595>;
  <D.20594>:
  D.20590 = 0;
  return D.20590;
  <D.20595>:
  D.20596 = mono_generic_inst_equal_full (i1, i2, signature_only);
  if (D.20596 == 0) goto <D.20597>; else goto <D.20598>;
  <D.20597>:
  D.20590 = 0;
  return D.20590;
  <D.20598>:
  D.20584 = BIT_FIELD_REF <*g1, 64, 192>;
  D.20585 = BIT_FIELD_REF <*g2, 64, 192>;
  D.20586 = D.20584 ^ D.20585;
  D.20599 = D.20586 & 2;
  D.20600 = D.20599 == 0;
  D.20590 = (gboolean) D.20600;
  return D.20590;
}


mono_metadata_generic_param_equal (struct MonoGenericParam * p1, struct MonoGenericParam * p2, gboolean signature_only)
{
  gboolean D.20604;
  short unsigned int D.20605;
  short unsigned int D.20606;
  short unsigned int D.20609;
  short unsigned int D.20610;
  struct MonoGenericContainer * D.20615;
  struct MonoGenericContainer * D.20616;
  struct MonoImage * D.20620;
  struct MonoImage * D.20621;

  if (p1 == p2) goto <D.20602>; else goto <D.20603>;
  <D.20602>:
  D.20604 = 1;
  return D.20604;
  <D.20603>:
  D.20605 = p1->num;
  D.20606 = p2->num;
  if (D.20605 != D.20606) goto <D.20607>; else goto <D.20608>;
  <D.20607>:
  D.20604 = 0;
  return D.20604;
  <D.20608>:
  D.20609 = p1->serial;
  D.20610 = p2->serial;
  if (D.20609 != D.20610) goto <D.20611>; else goto <D.20612>;
  <D.20611>:
  D.20604 = 0;
  return D.20604;
  <D.20612>:
  D.20615 = p1->owner;
  D.20616 = p2->owner;
  if (D.20615 == D.20616) goto <D.20617>; else goto <D.20618>;
  <D.20617>:
  D.20615 = p1->owner;
  if (D.20615 != 0B) goto <D.20613>; else goto <D.20619>;
  <D.20619>:
  D.20620 = p1->image;
  D.20621 = p2->image;
  if (D.20620 == D.20621) goto <D.20613>; else goto <D.20614>;
  <D.20613>:
  D.20604 = 1;
  return D.20604;
  <D.20614>:
  <D.20618>:
  D.20604 = signature_only;
  return D.20604;
}


mono_metadata_fnptr_equal (struct MonoMethodSignature * s1, struct MonoMethodSignature * s2, gboolean signature_only)
{
  gboolean D.20625;
  long unsigned int D.20626;
  long unsigned int D.20627;
  long unsigned int D.20628;
  long unsigned int D.20629;
  short int D.20632;
  short int D.20633;
  long unsigned int D.20636;
  long unsigned int D.20639;
  struct MonoType * D.20642;
  struct MonoType * D.20643;
  int D.20644;
  short unsigned int D.20647;
  short unsigned int D.20648;
  _Bool D.20654;
  int D.20655;
  void * iter1;
  void * iter2;

  try
    {
      iter1 = 0B;
      iter2 = 0B;
      if (s1 == s2) goto <D.20623>; else goto <D.20624>;
      <D.20623>:
      D.20625 = 1;
      return D.20625;
      <D.20624>:
      D.20626 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20627 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20628 = D.20626 ^ D.20627;
      D.20629 = D.20628 & 17732923532771328;
      if (D.20629 != 0) goto <D.20630>; else goto <D.20631>;
      <D.20630>:
      D.20625 = 0;
      return D.20625;
      <D.20631>:
      D.20632 = s1->sentinelpos;
      D.20633 = s2->sentinelpos;
      if (D.20632 != D.20633) goto <D.20634>; else goto <D.20635>;
      <D.20634>:
      D.20625 = 0;
      return D.20625;
      <D.20635>:
      D.20626 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20627 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20628 = D.20626 ^ D.20627;
      D.20636 = D.20628 & 18014398509481984;
      if (D.20636 != 0) goto <D.20637>; else goto <D.20638>;
      <D.20637>:
      D.20625 = 0;
      return D.20625;
      <D.20638>:
      D.20626 = BIT_FIELD_REF <*s1, 64, 64>;
      D.20627 = BIT_FIELD_REF <*s2, 64, 64>;
      D.20628 = D.20626 ^ D.20627;
      D.20639 = D.20628 & 36028797018963968;
      if (D.20639 != 0) goto <D.20640>; else goto <D.20641>;
      <D.20640>:
      D.20625 = 0;
      return D.20625;
      <D.20641>:
      D.20642 = s1->ret;
      D.20643 = s2->ret;
      D.20644 = do_mono_metadata_type_equal (D.20642, D.20643, signature_only);
      if (D.20644 == 0) goto <D.20645>; else goto <D.20646>;
      <D.20645>:
      D.20625 = 0;
      return D.20625;
      <D.20646>:
      D.20647 = s1->param_count;
      D.20648 = s2->param_count;
      if (D.20647 != D.20648) goto <D.20649>; else goto <D.20650>;
      <D.20649>:
      D.20625 = 0;
      return D.20625;
      <D.20650>:
      <D.19330>:
      {
        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.20651>; else goto <D.20653>;
        <D.20653>:
        if (t2 == 0B) goto <D.20651>; else goto <D.20652>;
        <D.20651>:
        D.20654 = t1 == t2;
        D.20625 = (gboolean) D.20654;
        return D.20625;
        <D.20652>:
        D.20655 = do_mono_metadata_type_equal (t1, t2, signature_only);
        if (D.20655 == 0) goto <D.20656>; else goto <D.20657>;
        <D.20656>:
        D.20625 = 0;
        return D.20625;
        <D.20657>:
      }
      goto <D.19330>;
    }
  finally
    {
      iter1 = {CLOBBER};
      iter2 = {CLOBBER};
    }
}


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

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


mono_type_equal (const void * ka, const void * kb)
{
  unsigned char D.20666;
  unsigned char D.20667;
  long unsigned int D.20669;
  long unsigned int D.20670;
  long unsigned int D.20671;
  long unsigned int D.20672;
  short unsigned int D.20674;
  short unsigned int D.20675;
  long unsigned int D.20677;
  gint D.20678;
  const struct MonoType * a;
  const struct MonoType * b;

  a = ka;
  b = kb;
  D.20666 = a->type;
  D.20667 = b->type;
  if (D.20666 != D.20667) goto <D.20664>; else goto <D.20668>;
  <D.20668>:
  D.20669 = BIT_FIELD_REF <*a, 64, 64>;
  D.20670 = BIT_FIELD_REF <*b, 64, 64>;
  D.20671 = D.20669 ^ D.20670;
  D.20672 = D.20671 & 1073741824;
  if (D.20672 != 0) goto <D.20664>; else goto <D.20673>;
  <D.20673>:
  D.20674 = a->attrs;
  D.20675 = b->attrs;
  if (D.20674 != D.20675) goto <D.20664>; else goto <D.20676>;
  <D.20676>:
  D.20669 = BIT_FIELD_REF <*a, 64, 64>;
  D.20670 = BIT_FIELD_REF <*b, 64, 64>;
  D.20671 = D.20669 ^ D.20670;
  D.20677 = D.20671 & 2147483648;
  if (D.20677 != 0) goto <D.20664>; else goto <D.20665>;
  <D.20664>:
  D.20678 = 0;
  return D.20678;
  <D.20665>:
  D.20678 = 1;
  return D.20678;
}


mono_type_hash (const void * data)
{
  unsigned char D.20680;
  guint D.20683;
  struct MonoGenericClass * D.20684;
  int D.20685;
  <unnamed-unsigned:1> D.20686;
  int D.20687;
  int D.20688;
  int D.20689;
  short unsigned int D.20690;
  int D.20691;
  int D.20692;
  int D.20693;
  const struct MonoType * type;

  type = data;
  D.20680 = type->type;
  if (D.20680 == 21) goto <D.20681>; else goto <D.20682>;
  <D.20681>:
  D.20684 = type->data.generic_class;
  D.20683 = mono_generic_class_hash (D.20684);
  return D.20683;
  <D.20682>:
  D.20680 = type->type;
  D.20685 = (int) D.20680;
  D.20686 = type->byref;
  D.20687 = (int) D.20686;
  D.20688 = D.20687 << 8;
  D.20689 = D.20685 | D.20688;
  D.20690 = type->attrs;
  D.20691 = (int) D.20690;
  D.20692 = D.20691 << 9;
  D.20693 = D.20689 | D.20692;
  D.20683 = (guint) D.20693;
  return D.20683;
}


mono_generic_class_hash (const void * data)
{
  struct MonoClass * D.20695;
  struct MonoType * D.20696;
  <unnamed-unsigned:1> D.20697;
  unsigned int D.20698;
  const struct MonoGenericContext * D.20699;
  unsigned int D.20700;
  guint D.20701;
  const struct MonoGenericClass * gclass;
  guint hash;

  gclass = data;
  D.20695 = gclass->container_class;
  D.20696 = &D.20695->byval_arg;
  hash = mono_metadata_type_hash (D.20696);
  hash = hash * 13;
  D.20697 = gclass->is_tb_open;
  D.20698 = (unsigned int) D.20697;
  hash = D.20698 + hash;
  D.20699 = &gclass->context;
  D.20700 = mono_metadata_generic_context_hash (D.20699);
  hash = D.20700 + hash;
  D.20701 = hash;
  return D.20701;
}


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

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


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

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


mono_metadata_parse_type_internal (struct MonoImage * m, struct MonoGenericContainer * container, MonoParseTypeMode mode, short int opt_attrs, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.57;
  const char * tmp_ptr.58;
  char D.20709;
  int D.20710;
  const char * tmp_ptr.59;
  long unsigned int D.20714;
  long unsigned int D.20715;
  unsigned int D.20716;
  unsigned int D.20717;
  void * iftmp.60;
  long unsigned int D.20721;
  unsigned int size.61;
  unsigned char D.20724;
  <unnamed-unsigned:6> D.20725;
  char D.20729;
  int D.20730;
  const char * ptr.62;
  struct MonoCustomMod * D.20732;
  short unsigned int opt_attrs.63;
  unsigned char D.20734;
  <unnamed-unsigned:1> D.20735;
  _Bool D.20736;
  int D.20737;
  struct MonoType * D.20740;
  long unsigned int D.20743;
  long unsigned int D.20744;
  unsigned char D.20749;
  unsigned char D.20750;
  long unsigned int D.20753;
  struct MonoType * iftmp.64;
  long unsigned int D.20757;
  struct MonoClass * D.20760;
  struct MonoClass * D.20762;
  struct GHashTable * type_cache.65;
  void * iftmp.66;
  struct MonoType * type;
  struct MonoType * cached;
  struct MonoType stype;
  gboolean byref;
  gboolean pinned;
  const char * tmp_ptr;
  int count;
  gboolean found;

  try
    {
      byref = 0;
      pinned = 0;
      count = 0;
      ptr.57 = ptr;
      tmp_ptr = ptr.57;
      found = 1;
      goto <D.18306>;
      <D.18305>:
      tmp_ptr.58 = tmp_ptr;
      D.20709 = *tmp_ptr.58;
      D.20710 = (int) D.20709;
      switch (D.20710) <default: <D.18304>, case 16: <D.18300>, case 31: <D.18302>, case 32: <D.18303>, case 69: <D.18299>>
      <D.18299>:
      <D.18300>:
      tmp_ptr.58 = tmp_ptr;
      tmp_ptr.59 = tmp_ptr.58 + 1;
      tmp_ptr = tmp_ptr.59;
      goto <D.18301>;
      <D.18302>:
      <D.18303>:
      count = count + 1;
      tmp_ptr.58 = tmp_ptr;
      mono_metadata_parse_custom_mod (m, 0B, tmp_ptr.58, &tmp_ptr);
      goto <D.18301>;
      <D.18304>:
      found = 0;
      <D.18301>:
      <D.18306>:
      if (found != 0) goto <D.18305>; else goto <D.18307>;
      <D.18307>:
      if (count != 0) goto <D.20712>; else goto <D.20713>;
      <D.20712>:
      {
        int size;

        D.20714 = (long unsigned int) count;
        D.20715 = D.20714 + 3;
        D.20716 = (unsigned int) D.20715;
        D.20717 = D.20716 * 4;
        size = (int) D.20717;
        if (transient != 0) goto <D.20719>; else goto <D.20720>;
        <D.20719>:
        D.20721 = (long unsigned int) size;
        iftmp.60 = monoeg_malloc0 (D.20721);
        goto <D.20722>;
        <D.20720>:
        size.61 = (unsigned int) size;
        iftmp.60 = mono_image_alloc0 (m, size.61);
        <D.20722>:
        type = iftmp.60;
        D.20724 = (unsigned char) count;
        D.20725 = (<unnamed-unsigned:6>) D.20724;
        type->num_mods = D.20725;
        if (count > 64) goto <D.20726>; else goto <D.20727>;
        <D.20726>:
        monoeg_g_log (0B, 16, "got more than 64 modifiers in type");
        <D.20727>:
      }
      goto <D.20728>;
      <D.20713>:
      type = &stype;
      memset (type, 0, 12);
      <D.20728>:
      found = 1;
      count = 0;
      goto <D.18316>;
      <D.18315>:
      ptr.57 = ptr;
      D.20729 = *ptr.57;
      D.20730 = (int) D.20729;
      switch (D.20730) <default: <D.18314>, case 16: <D.18311>, case 31: <D.18312>, case 32: <D.18313>, case 69: <D.18309>>
      <D.18309>:
      pinned = 1;
      ptr.57 = ptr;
      ptr.62 = ptr.57 + 1;
      ptr = ptr.62;
      goto <D.18310>;
      <D.18311>:
      byref = 1;
      ptr.57 = ptr;
      ptr.62 = ptr.57 + 1;
      ptr = ptr.62;
      goto <D.18310>;
      <D.18312>:
      <D.18313>:
      D.20732 = &type->modifiers[count];
      ptr.57 = ptr;
      mono_metadata_parse_custom_mod (m, D.20732, ptr.57, &ptr);
      count = count + 1;
      goto <D.18310>;
      <D.18314>:
      found = 0;
      <D.18310>:
      <D.18316>:
      if (found != 0) goto <D.18315>; else goto <D.18317>;
      <D.18317>:
      opt_attrs.63 = (short unsigned int) opt_attrs;
      type->attrs = opt_attrs.63;
      D.20734 = (unsigned char) byref;
      D.20735 = (<unnamed-unsigned:1>) D.20734;
      type->byref = D.20735;
      D.20736 = pinned != 0;
      type->pinned = D.20736;
      ptr.57 = ptr;
      D.20737 = do_mono_metadata_parse_type (type, m, container, transient, ptr.57, &ptr);
      if (D.20737 == 0) goto <D.20738>; else goto <D.20739>;
      <D.20738>:
      D.20740 = 0B;
      return D.20740;
      <D.20739>:
      if (rptr != 0B) goto <D.20741>; else goto <D.20742>;
      <D.20741>:
      ptr.57 = ptr;
      *rptr = ptr.57;
      <D.20742>:
      D.20743 = BIT_FIELD_REF <*type, 64, 64>;
      D.20744 = D.20743 & 1056964608;
      if (D.20744 == 0) goto <D.20745>; else goto <D.20746>;
      <D.20745>:
      if (transient == 0) goto <D.20747>; else goto <D.20748>;
      <D.20747>:
      D.20749 = type->type;
      D.20750 = D.20749 + 239;
      if (D.20750 <= 1) goto <D.20751>; else goto <D.20752>;
      <D.20751>:
      D.20743 = BIT_FIELD_REF <*type, 64, 64>;
      D.20753 = D.20743 & 2147549183;
      if (D.20753 == 0) goto <D.20754>; else goto <D.20755>;
      <D.20754>:
      {
        struct MonoType * ret;

        D.20743 = BIT_FIELD_REF <*type, 64, 64>;
        D.20757 = D.20743 & 1073741824;
        if (D.20757 != 0) goto <D.20758>; else goto <D.20759>;
        <D.20758>:
        D.20760 = type->data.klass;
        iftmp.64 = &D.20760->this_arg;
        goto <D.20761>;
        <D.20759>:
        D.20760 = type->data.klass;
        iftmp.64 = &D.20760->byval_arg;
        <D.20761>:
        ret = iftmp.64;
        D.20762 = ret->data.klass;
        D.20760 = type->data.klass;
        if (D.20762 == D.20760) goto <D.20763>; else goto <D.20764>;
        <D.20763>:
        D.20740 = ret;
        return D.20740;
        <D.20764>:
      }
      <D.20755>:
      <D.20752>:
      type_cache.65 = type_cache;
      cached = monoeg_g_hash_table_lookup (type_cache.65, type);
      if (cached != 0B) goto <D.20766>; else goto <D.20767>;
      <D.20766>:
      D.20740 = cached;
      return D.20740;
      <D.20767>:
      <D.20748>:
      <D.20746>:
      if (&stype == type) goto <D.20768>; else goto <D.20769>;
      <D.20768>:
      if (transient != 0) goto <D.20771>; else goto <D.20772>;
      <D.20771>:
      iftmp.66 = monoeg_malloc (12);
      goto <D.20773>;
      <D.20772>:
      iftmp.66 = mono_image_alloc (m, 12);
      <D.20773>:
      type = iftmp.66;
      memcpy (type, &stype, 12);
      <D.20769>:
      D.20740 = type;
      return D.20740;
    }
  finally
    {
      stype = {CLOBBER};
      tmp_ptr = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20778;
  int D.20783;
  void * D.20785;
  long unsigned int D.20786;

  D.20778 = __builtin_constant_p (__len);
  if (D.20778 != 0) goto <D.20779>; else goto <D.20780>;
  <D.20779>:
  if (__len == 0) goto <D.20781>; else goto <D.20782>;
  <D.20781>:
  D.20783 = __builtin_constant_p (__ch);
  if (D.20783 == 0) goto <D.20776>; else goto <D.20784>;
  <D.20784>:
  if (__ch != 0) goto <D.20776>; else goto <D.20777>;
  <D.20776>:
  __warn_memset_zero_len ();
  D.20785 = __dest;
  return D.20785;
  <D.20777>:
  <D.20782>:
  <D.20780>:
  D.20786 = __builtin_object_size (__dest, 0);
  D.20785 = __builtin___memset_chk (__dest, __ch, __len, D.20786);
  return D.20785;
}


do_mono_metadata_parse_type (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, gboolean transient, const char * ptr, const char * * rptr)
{
  const char * ptr.67;
  unsigned int D.20789;
  unsigned char D.20790;
  unsigned char D.20791;
  int D.20792;
  gboolean D.20795;
  unsigned char D.20796;
  int D.20797;
  int D.20798;
  struct MonoClass * D.20803;
  struct MonoClass * D.20804;
  struct MonoType * D.20807;
  struct MonoType * D.20808;
  struct MonoMethodSignature * D.20811;
  struct MonoMethodSignature * D.20812;
  struct MonoArrayType * D.20815;
  struct MonoArrayType * D.20816;
  long unsigned int D.20821;
  long unsigned int D.20822;
  <unnamed type> D.20825;
  struct MonoGenericParam * D.20826;
  struct MonoGenericParam * D.20827;
  char * D.20830;
  gboolean ok;

  ok = 1;
  ptr.67 = ptr;
  D.20789 = mono_metadata_decode_value (ptr.67, &ptr);
  D.20790 = (unsigned char) D.20789;
  type->type = D.20790;
  D.20791 = type->type;
  D.20792 = (int) D.20791;
  switch (D.20792) <default: <D.18870>, case 1: <D.18839>, case 2: <D.18840>, case 3: <D.18841>, case 4: <D.18842>, case 5: <D.18843>, case 6: <D.18844>, case 7: <D.18845>, case 8: <D.18846>, case 9: <D.18847>, case 10: <D.18848>, case 11: <D.18849>, case 12: <D.18850>, case 13: <D.18851>, case 14: <D.18854>, case 15: <D.18864>, case 17: <D.18858>, case 18: <D.18859>, case 19: <D.18868>, case 20: <D.18866>, case 21: <D.18869>, case 22: <D.18856>, case 24: <D.18852>, case 25: <D.18853>, case 27: <D.18865>, case 28: <D.18855>, case 29: <D.18862>, case 30: <D.18867>>
  <D.18839>:
  <D.18840>:
  <D.18841>:
  <D.18842>:
  <D.18843>:
  <D.18844>:
  <D.18845>:
  <D.18846>:
  <D.18847>:
  <D.18848>:
  <D.18849>:
  <D.18850>:
  <D.18851>:
  <D.18852>:
  <D.18853>:
  <D.18854>:
  <D.18855>:
  <D.18856>:
  goto <D.18857>;
  <D.18858>:
  <D.18859>:
  {
    guint32 token;
    struct MonoClass * class;

    ptr.67 = ptr;
    token = mono_metadata_parse_typedef_or_ref (m, ptr.67, &ptr);
    class = mono_class_get (m, token);
    type->data.klass = class;
    if (class == 0B) goto <D.20793>; else goto <D.20794>;
    <D.20793>:
    D.20795 = 0;
    return D.20795;
    <D.20794>:
    D.20796 = class->byval_arg.type;
    D.20797 = (int) D.20796;
    D.20791 = type->type;
    D.20792 = (int) D.20791;
    D.20798 = compare_type_literals (D.20797, D.20792);
    if (D.20798 == 0) goto <D.20799>; else goto <D.20800>;
    <D.20799>:
    D.20795 = 0;
    return D.20795;
    <D.20800>:
    goto <D.18857>;
  }
  <D.18862>:
  {
    struct MonoType * etype;

    ptr.67 = ptr;
    etype = mono_metadata_parse_type_full (m, container, 1, 0, ptr.67, &ptr);
    if (etype == 0B) goto <D.20801>; else goto <D.20802>;
    <D.20801>:
    D.20795 = 0;
    return D.20795;
    <D.20802>:
    D.20803 = mono_class_from_mono_type (etype);
    type->data.klass = D.20803;
    D.20804 = type->data.klass;
    if (D.20804 == 0B) goto <D.20805>; else goto <D.20806>;
    <D.20805>:
    D.20795 = 0;
    return D.20795;
    <D.20806>:
    goto <D.18857>;
  }
  <D.18864>:
  ptr.67 = ptr;
  D.20807 = mono_metadata_parse_type_internal (m, container, 1, 0, transient, ptr.67, &ptr);
  type->data.type = D.20807;
  D.20808 = type->data.type;
  if (D.20808 == 0B) goto <D.20809>; else goto <D.20810>;
  <D.20809>:
  D.20795 = 0;
  return D.20795;
  <D.20810>:
  goto <D.18857>;
  <D.18865>:
  ptr.67 = ptr;
  D.20811 = mono_metadata_parse_method_signature_full (m, container, 0, ptr.67, &ptr);
  type->data.method = D.20811;
  D.20812 = type->data.method;
  if (D.20812 == 0B) goto <D.20813>; else goto <D.20814>;
  <D.20813>:
  D.20795 = 0;
  return D.20795;
  <D.20814>:
  goto <D.18857>;
  <D.18866>:
  ptr.67 = ptr;
  D.20815 = mono_metadata_parse_array_internal (m, container, transient, ptr.67, &ptr);
  type->data.array = D.20815;
  D.20816 = type->data.array;
  if (D.20816 == 0B) goto <D.20817>; else goto <D.20818>;
  <D.20817>:
  D.20795 = 0;
  return D.20795;
  <D.20818>:
  goto <D.18857>;
  <D.18867>:
  if (container != 0B) goto <D.20819>; else goto <D.20820>;
  <D.20819>:
  D.20821 = BIT_FIELD_REF <*container, 64, 256>;
  D.20822 = D.20821 & 2147483648;
  if (D.20822 == 0) goto <D.20823>; else goto <D.20824>;
  <D.20823>:
  D.20795 = 0;
  return D.20795;
  <D.20824>:
  <D.20820>:
  <D.18868>:
  D.20791 = type->type;
  D.20825 = (<unnamed type>) D.20791;
  ptr.67 = ptr;
  D.20826 = mono_metadata_parse_generic_param (m, container, D.20825, ptr.67, &ptr);
  type->data.generic_param = D.20826;
  D.20827 = type->data.generic_param;
  if (D.20827 == 0B) goto <D.20828>; else goto <D.20829>;
  <D.20828>:
  D.20795 = 0;
  return D.20795;
  <D.20829>:
  goto <D.18857>;
  <D.18869>:
  ptr.67 = ptr;
  ok = do_mono_metadata_parse_generic_class (type, m, container, ptr.67, &ptr);
  goto <D.18857>;
  <D.18870>:
  D.20791 = type->type;
  D.20792 = (int) D.20791;
  D.20830 = m->name;
  monoeg_g_log (0B, 16, "type 0x%02x not handled in do_mono_metadata_parse_type on image %s", D.20792, D.20830);
  D.20795 = 0;
  return D.20795;
  <D.18857>:
  if (rptr != 0B) goto <D.20831>; else goto <D.20832>;
  <D.20831>:
  ptr.67 = ptr;
  *rptr = ptr.67;
  <D.20832>:
  D.20795 = ok;
  return D.20795;
}


compare_type_literals (int class_type, int type_type)
{
  gboolean D.20837;
  _Bool D.20843;

  if (class_type == 0) goto <D.20835>; else goto <D.20836>;
  <D.20835>:
  D.20837 = 1;
  return D.20837;
  <D.20836>:
  if (type_type == 18) goto <D.20840>; else goto <D.20841>;
  <D.20840>:
  if (class_type == 14) goto <D.20838>; else goto <D.20842>;
  <D.20842>:
  if (class_type == 28) goto <D.20838>; else goto <D.20839>;
  <D.20838>:
  D.20837 = 1;
  return D.20837;
  <D.20839>:
  <D.20841>:
  D.20843 = class_type == type_type;
  D.20837 = (gboolean) D.20843;
  return D.20837;
}


mono_metadata_parse_generic_param (struct MonoImage * m, struct MonoGenericContainer * generic_container, MonoTypeEnum type, const char * ptr, const char * * rptr)
{
  const char * ptr.68;
  unsigned int D.20846;
  short unsigned int D.20851;
  struct MonoGenericParam * D.20852;
  <unnamed-signed:31> D.20853;
  int D.20854;
  struct MonoGenericParamFull * D.20857;
  long unsigned int D.20858;
  long unsigned int D.20859;
  int index;

  ptr.68 = ptr;
  D.20846 = mono_metadata_decode_value (ptr.68, &ptr);
  index = (int) D.20846;
  if (rptr != 0B) goto <D.20847>; else goto <D.20848>;
  <D.20847>:
  ptr.68 = ptr;
  *rptr = ptr.68;
  <D.20848>:
  generic_container = select_container (generic_container, type);
  if (generic_container == 0B) goto <D.20849>; else goto <D.20850>;
  <D.20849>:
  {
    struct MonoGenericParam * param;

    param = mono_image_alloc0 (m, 24);
    D.20851 = (short unsigned int) index;
    param->num = D.20851;
    param->image = m;
    D.20852 = param;
    return D.20852;
  }
  <D.20850>:
  D.20853 = generic_container->type_argc;
  D.20854 = (int) D.20853;
  if (D.20854 <= index) goto <D.20855>; else goto <D.20856>;
  <D.20855>:
  D.20852 = 0B;
  return D.20852;
  <D.20856>:
  D.20857 = generic_container->type_params;
  D.20858 = (long unsigned int) index;
  D.20859 = D.20858 * 56;
  D.20852 = D.20857 + D.20859;
  return D.20852;
}


select_container (struct MonoGenericContainer * gc, MonoTypeEnum type)
{
  _Bool D.20861;
  struct MonoGenericContainer * D.20864;
  int iftmp.69;
  _Bool D.20870;
  long int D.20871;
  long int D.20872;
  long unsigned int D.20879;
  long unsigned int D.20880;
  struct MonoGenericContainer * D.20882;
  gboolean is_var;

  D.20861 = type == 19;
  is_var = (gboolean) D.20861;
  if (gc == 0B) goto <D.20862>; else goto <D.20863>;
  <D.20862>:
  D.20864 = 0B;
  return D.20864;
  <D.20863>:
  if (is_var == 0) goto <D.20868>; else goto <D.20866>;
  <D.20868>:
  if (type != 30) goto <D.20869>; else goto <D.20866>;
  <D.20869>:
  iftmp.69 = 1;
  goto <D.20867>;
  <D.20866>:
  iftmp.69 = 0;
  <D.20867>:
  D.20870 = iftmp.69 != 0;
  D.20871 = (long int) D.20870;
  D.20872 = __builtin_expect (D.20871, 0);
  if (D.20872 != 0) goto <D.20873>; else goto <D.20874>;
  <D.20873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3020, "is_var || type == MONO_TYPE_MVAR");
  <D.20874>:
  if (is_var != 0) goto <D.20875>; else goto <D.20876>;
  <D.20875>:
  D.20879 = BIT_FIELD_REF <*gc, 64, 256>;
  D.20880 = D.20879 & 2147483648;
  if (D.20880 != 0) goto <D.20877>; else goto <D.20881>;
  <D.20881>:
  D.20882 = gc->parent;
  if (D.20882 != 0B) goto <D.20877>; else goto <D.20878>;
  <D.20877>:
  D.20864 = gc->parent;
  return D.20864;
  <D.20878>:
  <D.20876>:
  D.20864 = gc;
  return D.20864;
}


do_mono_metadata_parse_generic_class (struct MonoType * type, struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr, const char * * rptr)
{
  const char * ptr.70;
  gboolean D.20887;
  struct MonoGenericContainer * D.20888;
  unsigned int D.20891;
  struct MonoGenericClass * D.20896;
  struct MonoGenericInst * inst;
  struct MonoClass * gklass;
  struct MonoType * gtype;
  int count;

  ptr.70 = ptr;
  gtype = mono_metadata_parse_type (m, 0, 0, ptr.70, &ptr);
  if (gtype == 0B) goto <D.20885>; else goto <D.20886>;
  <D.20885>:
  D.20887 = 0;
  return D.20887;
  <D.20886>:
  gklass = mono_class_from_mono_type (gtype);
  D.20888 = gklass->generic_container;
  if (D.20888 == 0B) goto <D.20889>; else goto <D.20890>;
  <D.20889>:
  D.20887 = 0;
  return D.20887;
  <D.20890>:
  ptr.70 = ptr;
  D.20891 = mono_metadata_decode_value (ptr.70, &ptr);
  count = (int) D.20891;
  ptr.70 = ptr;
  inst = mono_metadata_parse_generic_inst (m, container, count, ptr.70, &ptr);
  if (inst == 0B) goto <D.20892>; else goto <D.20893>;
  <D.20892>:
  D.20887 = 0;
  return D.20887;
  <D.20893>:
  if (rptr != 0B) goto <D.20894>; else goto <D.20895>;
  <D.20894>:
  ptr.70 = ptr;
  *rptr = ptr.70;
  <D.20895>:
  D.20896 = mono_metadata_lookup_generic_class (gklass, inst, 0);
  type->data.generic_class = D.20896;
  D.20887 = 1;
  return D.20887;
}


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

  D.20899 = __builtin_object_size (__dest, 0);
  D.20898 = __builtin___memcpy_chk (__dest, __src, __len, D.20899);
  return D.20898;
}


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

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


mono_metadata_method_has_param_attrs (struct MonoImage * m, int def)
{
  int D.20903;
  <unnamed-unsigned:24> D.20904;
  int D.20905;
  <unnamed-unsigned:24> D.20909;
  int D.20910;
  int D.20911;
  unsigned int D.20912;
  int D.20913;
  gboolean D.20916;
  struct MonoTableInfo * paramt;
  struct MonoTableInfo * methodt;
  guint lastp;
  guint i;
  guint param_index;

  paramt = &m->tables[8];
  methodt = &m->tables[6];
  D.20903 = def + -1;
  param_index = mono_metadata_decode_row_col (methodt, D.20903, 5);
  D.20904 = methodt->rows;
  D.20905 = (int) D.20904;
  if (D.20905 > def) goto <D.20906>; else goto <D.20907>;
  <D.20906>:
  lastp = mono_metadata_decode_row_col (methodt, def, 5);
  goto <D.20908>;
  <D.20907>:
  D.20909 = m->tables[8].rows;
  D.20910 = (int) D.20909;
  D.20911 = D.20910 + 1;
  lastp = (guint) D.20911;
  <D.20908>:
  i = param_index;
  goto <D.18345>;
  <D.18344>:
  {
    guint32 flags;

    D.20912 = i + 4294967295;
    D.20913 = (int) D.20912;
    flags = mono_metadata_decode_row_col (paramt, D.20913, 0);
    if (flags != 0) goto <D.20914>; else goto <D.20915>;
    <D.20914>:
    D.20916 = 1;
    return D.20916;
    <D.20915>:
  }
  i = i + 1;
  <D.18345>:
  if (i < lastp) goto <D.18344>; else goto <D.18346>;
  <D.18346>:
  D.20916 = 0;
  return D.20916;
}


mono_metadata_get_param_attrs (struct MonoImage * m, int def, int param_count)
{
  int D.20918;
  <unnamed-unsigned:24> D.20919;
  int D.20920;
  <unnamed-unsigned:24> D.20924;
  int D.20925;
  int D.20926;
  unsigned int D.20927;
  int D.20928;
  unsigned int D.20929;
  long unsigned int D.20934;
  long unsigned int D.20935;
  unsigned int D.20936;
  unsigned int param_count.71;
  long unsigned int D.20940;
  long unsigned int D.20941;
  int * D.20942;
  int D.20943;
  int * D.20944;
  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.20918 = def + -1;
      param_index = mono_metadata_decode_row_col (methodt, D.20918, 5);
      pattrs = 0B;
      D.20919 = methodt->rows;
      D.20920 = (int) D.20919;
      if (D.20920 > def) goto <D.20921>; else goto <D.20922>;
      <D.20921>:
      lastp = mono_metadata_decode_row_col (methodt, def, 5);
      goto <D.20923>;
      <D.20922>:
      D.20924 = paramt->rows;
      D.20925 = (int) D.20924;
      D.20926 = D.20925 + 1;
      lastp = (guint) D.20926;
      <D.20923>:
      i = param_index;
      goto <D.18361>;
      <D.18360>:
      D.20927 = i + 4294967295;
      D.20928 = (int) D.20927;
      mono_metadata_decode_row (paramt, D.20928, &cols, 3);
      D.20929 = cols[0];
      if (D.20929 != 0) goto <D.20930>; else goto <D.20931>;
      <D.20930>:
      if (pattrs == 0B) goto <D.20932>; else goto <D.20933>;
      <D.20932>:
      D.20934 = (long unsigned int) param_count;
      D.20935 = D.20934 * 4;
      pattrs = monoeg_malloc0 (D.20935);
      <D.20933>:
      D.20936 = cols[1];
      param_count.71 = (unsigned int) param_count;
      if (D.20936 >= param_count.71) goto <D.20938>; else goto <D.20939>;
      <D.20938>:
      // predicted unlikely by continue predictor.
      goto <D.18359>;
      <D.20939>:
      D.20936 = cols[1];
      D.20940 = (long unsigned int) D.20936;
      D.20941 = D.20940 * 4;
      D.20942 = pattrs + D.20941;
      D.20929 = cols[0];
      D.20943 = (int) D.20929;
      *D.20942 = D.20943;
      <D.20931>:
      <D.18359>:
      i = i + 1;
      <D.18361>:
      if (i < lastp) goto <D.18360>; else goto <D.18362>;
      <D.18362>:
      D.20944 = pattrs;
      return D.20944;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_metadata_parse_signature_full (struct MonoImage * image, struct MonoGenericContainer * generic_container, guint32 token)
{
  long unsigned int D.20947;
  long unsigned int D.20948;
  struct MonoMethodSignature * D.20951;
  unsigned int D.20952;
  _Bool D.20953;
  long int D.20954;
  long int D.20955;
  const struct MonoTableInfo * D.20958;
  unsigned int D.20959;
  int D.20960;
  const char * ptr.72;
  const char * ptr.73;
  struct MonoTableInfo * tables;
  guint32 idx;
  guint32 sig;
  const char * ptr;

  try
    {
      tables = &image->tables;
      idx = token & 16777215;
      D.20947 = BIT_FIELD_REF <*image, 64, 192>;
      D.20948 = D.20947 & 34359738368;
      if (D.20948 != 0) goto <D.20949>; else goto <D.20950>;
      <D.20949>:
      D.20951 = mono_lookup_dynamic_token (image, token, 0B);
      return D.20951;
      <D.20950>:
      D.20952 = token >> 24;
      D.20953 = D.20952 != 17;
      D.20954 = (long int) D.20953;
      D.20955 = __builtin_expect (D.20954, 0);
      if (D.20955 != 0) goto <D.20956>; else goto <D.20957>;
      <D.20956>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 1764, "mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG");
      <D.20957>:
      D.20958 = tables + 272;
      D.20959 = idx + 4294967295;
      D.20960 = (int) D.20959;
      sig = mono_metadata_decode_row_col (D.20958, D.20960, 0);
      ptr.72 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.72;
      ptr.73 = ptr;
      mono_metadata_decode_blob_size (ptr.73, &ptr);
      ptr.73 = ptr;
      D.20951 = mono_metadata_parse_method_signature_full (image, generic_container, 0, ptr.73, 0B);
      return D.20951;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_signature_alloc (struct MonoImage * m, guint32 nparams)
{
  int nparams.74;
  long unsigned int D.20968;
  long unsigned int D.20969;
  unsigned int D.20970;
  unsigned int D.20971;
  short unsigned int D.20972;
  struct MonoMethodSignature * D.20973;
  struct MonoMethodSignature * sig;

  nparams.74 = (int) nparams;
  D.20968 = (long unsigned int) nparams.74;
  D.20969 = D.20968 + 2;
  D.20970 = (unsigned int) D.20969;
  D.20971 = D.20970 * 8;
  sig = mono_image_alloc0 (m, D.20971);
  D.20972 = (short unsigned int) nparams;
  sig->param_count = D.20972;
  sig->sentinelpos = -1;
  D.20973 = sig;
  return D.20973;
}


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

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


mono_metadata_signature_dup_internal (struct MonoImage * image, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  short unsigned int D.20977;
  long unsigned int D.20978;
  long unsigned int D.20979;
  unsigned int D.20980;
  unsigned int D.20981;
  unsigned int sigsize.75;
  unsigned int sigsize.76;
  long unsigned int D.20990;
  long unsigned int D.20991;
  struct MonoMethodSignature * D.20992;
  int sigsize;
  struct MonoMethodSignature * ret;

  D.20977 = sig->param_count;
  D.20978 = (long unsigned int) D.20977;
  D.20979 = D.20978 + 2;
  D.20980 = (unsigned int) D.20979;
  D.20981 = D.20980 * 8;
  sigsize = (int) D.20981;
  if (image != 0B) goto <D.20982>; else goto <D.20983>;
  <D.20982>:
  sigsize.75 = (unsigned int) sigsize;
  ret = mono_image_alloc (image, sigsize.75);
  goto <D.20985>;
  <D.20983>:
  if (mp != 0B) goto <D.20986>; else goto <D.20987>;
  <D.20986>:
  sigsize.76 = (unsigned int) sigsize;
  ret = mono_mempool_alloc (mp, sigsize.76);
  goto <D.20989>;
  <D.20987>:
  D.20990 = (long unsigned int) sigsize;
  ret = monoeg_malloc (D.20990);
  <D.20989>:
  <D.20985>:
  D.20991 = (long unsigned int) sigsize;
  memcpy (ret, sig, D.20991);
  D.20992 = ret;
  return D.20992;
}


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

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


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

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


mono_metadata_signature_size (struct MonoMethodSignature * sig)
{
  guint32 D.20998;
  short unsigned int D.20999;
  long unsigned int D.21000;
  long unsigned int D.21001;
  unsigned int D.21002;

  D.20999 = sig->param_count;
  D.21000 = (long unsigned int) D.20999;
  D.21001 = D.21000 + 2;
  D.21002 = (unsigned int) D.21001;
  D.20998 = D.21002 * 8;
  return D.20998;
}


mono_metadata_parse_method_signature_full (struct MonoImage * m, struct MonoGenericContainer * container, int def, const char * ptr, const char * * rptr)
{
  const char * ptr.77;
  char D.21005;
  int D.21006;
  int D.21007;
  int D.21010;
  int D.21013;
  unsigned int D.21016;
  const char * ptr.78;
  unsigned int D.21022;
  int D.21023;
  unsigned char D.21024;
  <unnamed-unsigned:1> D.21025;
  unsigned char D.21026;
  <unnamed-unsigned:1> D.21027;
  unsigned char D.21028;
  <unnamed-unsigned:6> D.21029;
  short unsigned int D.21030;
  short int iftmp.79;
  int D.21036;
  struct MonoType * D.21038;
  struct MonoType * D.21039;
  struct MonoMethodSignature * D.21042;
  long unsigned int D.21047;
  long unsigned int D.21048;
  char * D.21050;
  short int D.21051;
  short int D.21054;
  short int iftmp.80;
  sizetype D.21058;
  sizetype D.21059;
  sizetype D.21060;
  int * D.21061;
  int D.21062;
  struct MonoType * D.21064;
  struct MonoType * D.21065;
  short unsigned int D.21070;
  int D.21071;
  short int D.21078;
  unsigned char D.21079;
  <unnamed-unsigned:1> D.21080;
  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.77 = ptr;
  D.21005 = *ptr.77;
  D.21006 = (int) D.21005;
  D.21007 = D.21006 & 16;
  if (D.21007 != 0) goto <D.21008>; else goto <D.21009>;
  <D.21008>:
  gen_param_count = 1;
  <D.21009>:
  ptr.77 = ptr;
  D.21005 = *ptr.77;
  D.21006 = (int) D.21005;
  D.21010 = D.21006 & 32;
  if (D.21010 != 0) goto <D.21011>; else goto <D.21012>;
  <D.21011>:
  hasthis = 1;
  <D.21012>:
  ptr.77 = ptr;
  D.21005 = *ptr.77;
  D.21006 = (int) D.21005;
  D.21013 = D.21006 & 64;
  if (D.21013 != 0) goto <D.21014>; else goto <D.21015>;
  <D.21014>:
  explicit_this = 1;
  <D.21015>:
  ptr.77 = ptr;
  D.21005 = *ptr.77;
  D.21016 = (unsigned int) D.21005;
  call_convention = D.21016 & 15;
  ptr.77 = ptr;
  ptr.78 = ptr.77 + 1;
  ptr = ptr.78;
  if (gen_param_count != 0) goto <D.21018>; else goto <D.21019>;
  <D.21018>:
  ptr.77 = ptr;
  gen_param_count = mono_metadata_decode_value (ptr.77, &ptr);
  <D.21019>:
  ptr.77 = ptr;
  param_count = mono_metadata_decode_value (ptr.77, &ptr);
  if (def != 0) goto <D.21020>; else goto <D.21021>;
  <D.21020>:
  D.21022 = param_count + 1;
  D.21023 = (int) D.21022;
  pattrs = mono_metadata_get_param_attrs (m, def, D.21023);
  <D.21021>:
  method = mono_metadata_signature_alloc (m, param_count);
  D.21024 = (unsigned char) hasthis;
  D.21025 = (<unnamed-unsigned:1>) D.21024;
  method->hasthis = D.21025;
  D.21026 = (unsigned char) explicit_this;
  D.21027 = (<unnamed-unsigned:1>) D.21026;
  method->explicit_this = D.21027;
  D.21028 = (unsigned char) call_convention;
  D.21029 = (<unnamed-unsigned:6>) D.21028;
  method->call_convention = D.21029;
  D.21030 = (short unsigned int) gen_param_count;
  method->generic_param_count = D.21030;
  if (call_convention != 10) goto <D.21031>; else goto <D.21032>;
  <D.21031>:
  if (pattrs != 0B) goto <D.21034>; else goto <D.21035>;
  <D.21034>:
  D.21036 = *pattrs;
  iftmp.79 = (short int) D.21036;
  goto <D.21037>;
  <D.21035>:
  iftmp.79 = 0;
  <D.21037>:
  ptr.77 = ptr;
  D.21038 = mono_metadata_parse_type_full (m, container, 4, iftmp.79, ptr.77, &ptr);
  method->ret = D.21038;
  D.21039 = method->ret;
  if (D.21039 == 0B) goto <D.21040>; else goto <D.21041>;
  <D.21040>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.21042 = 0B;
  return D.21042;
  <D.21041>:
  D.21039 = method->ret;
  is_open = mono_class_is_open_constructed_type (D.21039);
  <D.21032>:
  i = 0;
  goto <D.18419>;
  <D.18418>:
  ptr.77 = ptr;
  D.21005 = *ptr.77;
  if (D.21005 == 65) goto <D.21043>; else goto <D.21044>;
  <D.21043>:
  D.21047 = BIT_FIELD_REF <*method, 64, 64>;
  D.21048 = D.21047 & 17732923532771328;
  if (D.21048 != 1407374883553280) goto <D.21045>; else goto <D.21049>;
  <D.21049>:
  if (def != 0) goto <D.21045>; else goto <D.21046>;
  <D.21045>:
  D.21050 = m->name;
  monoeg_g_log (0B, 16, "found sentinel for methoddef or no vararg method 0x%08x on image %s", def, D.21050);
  monoeg_g_free (pattrs);
  D.21042 = 0B;
  return D.21042;
  <D.21046>:
  D.21051 = method->sentinelpos;
  if (D.21051 >= 0) goto <D.21052>; else goto <D.21053>;
  <D.21052>:
  D.21050 = m->name;
  monoeg_g_log (0B, 16, "found sentinel twice in the same signature for method 0x%08x on image %s", def, D.21050);
  monoeg_g_free (pattrs);
  D.21042 = 0B;
  return D.21042;
  <D.21053>:
  D.21054 = (short int) i;
  method->sentinelpos = D.21054;
  ptr.77 = ptr;
  ptr.78 = ptr.77 + 1;
  ptr = ptr.78;
  <D.21044>:
  if (pattrs != 0B) goto <D.21056>; else goto <D.21057>;
  <D.21056>:
  D.21058 = (sizetype) i;
  D.21059 = D.21058 + 1;
  D.21060 = D.21059 * 4;
  D.21061 = pattrs + D.21060;
  D.21062 = *D.21061;
  iftmp.80 = (short int) D.21062;
  goto <D.21063>;
  <D.21057>:
  iftmp.80 = 0;
  <D.21063>:
  ptr.77 = ptr;
  D.21064 = mono_metadata_parse_type_full (m, container, 3, iftmp.80, ptr.77, &ptr);
  method->params[i] = D.21064;
  D.21065 = method->params[i];
  if (D.21065 == 0B) goto <D.21066>; else goto <D.21067>;
  <D.21066>:
  mono_metadata_free_method_signature (method);
  monoeg_g_free (pattrs);
  D.21042 = 0B;
  return D.21042;
  <D.21067>:
  if (is_open == 0) goto <D.21068>; else goto <D.21069>;
  <D.21068>:
  D.21065 = method->params[i];
  is_open = mono_class_is_open_constructed_type (D.21065);
  <D.21069>:
  i = i + 1;
  <D.18419>:
  D.21070 = method->param_count;
  D.21071 = (int) D.21070;
  if (D.21071 > i) goto <D.18418>; else goto <D.18420>;
  <D.18420>:
  if (def == 0) goto <D.21072>; else goto <D.21073>;
  <D.21072>:
  D.21047 = BIT_FIELD_REF <*method, 64, 64>;
  D.21048 = D.21047 & 17732923532771328;
  if (D.21048 == 1407374883553280) goto <D.21074>; else goto <D.21075>;
  <D.21074>:
  D.21051 = method->sentinelpos;
  if (D.21051 < 0) goto <D.21076>; else goto <D.21077>;
  <D.21076>:
  D.21070 = method->param_count;
  D.21078 = (short int) D.21070;
  method->sentinelpos = D.21078;
  <D.21077>:
  <D.21075>:
  <D.21073>:
  D.21079 = (unsigned char) is_open;
  D.21080 = (<unnamed-unsigned:1>) D.21079;
  method->has_type_parameters = D.21080;
  if (def != 0) goto <D.21081>; else goto <D.21082>;
  <D.21081>:
  D.21047 = BIT_FIELD_REF <*method, 64, 64>;
  D.21048 = D.21047 & 17732923532771328;
  if (D.21048 == 1407374883553280) goto <D.21083>; else goto <D.21084>;
  <D.21083>:
  D.21070 = method->param_count;
  D.21078 = (short int) D.21070;
  method->sentinelpos = D.21078;
  <D.21084>:
  <D.21082>:
  monoeg_g_free (pattrs);
  if (rptr != 0B) goto <D.21085>; else goto <D.21086>;
  <D.21085>:
  ptr.77 = ptr;
  *rptr = ptr.77;
  <D.21086>:
  D.21042 = method;
  return D.21042;
}


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

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


mono_metadata_free_method_signature (struct MonoMethodSignature * sig)
{

}


mono_metadata_free_inflated_signature (struct MonoMethodSignature * sig)
{
  struct MonoType * D.21090;
  struct MonoType * D.21093;
  short unsigned int D.21096;
  int D.21097;
  int i;

  D.21090 = sig->ret;
  if (D.21090 != 0B) goto <D.21091>; else goto <D.21092>;
  <D.21091>:
  D.21090 = sig->ret;
  mono_metadata_free_type (D.21090);
  <D.21092>:
  i = 0;
  goto <D.18435>;
  <D.18434>:
  D.21093 = sig->params[i];
  if (D.21093 != 0B) goto <D.21094>; else goto <D.21095>;
  <D.21094>:
  D.21093 = sig->params[i];
  mono_metadata_free_type (D.21093);
  <D.21095>:
  i = i + 1;
  <D.18435>:
  D.21096 = sig->param_count;
  D.21097 = (int) D.21096;
  if (D.21097 > i) goto <D.18434>; else goto <D.18436>;
  <D.18436>:
  monoeg_g_free (sig);
}


mono_image_set_alloc (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.21098;
  struct MonoMemPool * D.21101;
  void * D.21102;
  void * res;

  mono_image_set_lock (set);
  D.21098 = set->mempool;
  if (D.21098 == 0B) goto <D.21099>; else goto <D.21100>;
  <D.21099>:
  D.21101 = mono_mempool_new_size (1024);
  set->mempool = D.21101;
  <D.21100>:
  D.21098 = set->mempool;
  res = mono_mempool_alloc (D.21098, size);
  mono_image_set_unlock (set);
  D.21102 = res;
  return D.21102;
}


mono_image_set_lock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.21104;
  _Bool D.21107;
  long int D.21108;
  long int D.21109;

  {
    int ret;

    D.21104 = &set->lock.mutex;
    ret = pthread_mutex_lock (D.21104);
    if (ret != 0) goto <D.21105>; else goto <D.21106>;
    <D.21105>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21106>:
    D.21107 = ret != 0;
    D.21108 = (long int) D.21107;
    D.21109 = __builtin_expect (D.21108, 0);
    if (D.21109 != 0) goto <D.21110>; else goto <D.21111>;
    <D.21110>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2283, "ret == 0");
    <D.21111>:
  }
}


mono_image_set_unlock (struct MonoImageSet * set)
{
  union mono_mutex_t * D.21112;
  _Bool D.21115;
  long int D.21116;
  long int D.21117;

  {
    int ret;

    D.21112 = &set->lock.mutex;
    ret = pthread_mutex_unlock (D.21112);
    if (ret != 0) goto <D.21113>; else goto <D.21114>;
    <D.21113>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21114>:
    D.21115 = ret != 0;
    D.21116 = (long int) D.21115;
    D.21117 = __builtin_expect (D.21116, 0);
    if (D.21117 != 0) goto <D.21118>; else goto <D.21119>;
    <D.21118>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2289, "ret == 0");
    <D.21119>:
  }
}


mono_image_set_alloc0 (struct MonoImageSet * set, guint size)
{
  struct MonoMemPool * D.21120;
  struct MonoMemPool * D.21123;
  void * D.21124;
  void * res;

  mono_image_set_lock (set);
  D.21120 = set->mempool;
  if (D.21120 == 0B) goto <D.21121>; else goto <D.21122>;
  <D.21121>:
  D.21123 = mono_mempool_new_size (1024);
  set->mempool = D.21123;
  <D.21122>:
  D.21120 = set->mempool;
  res = mono_mempool_alloc0 (D.21120, size);
  mono_image_set_unlock (set);
  D.21124 = res;
  return D.21124;
}


mono_image_set_strdup (struct MonoImageSet * set, const char * s)
{
  struct MonoMemPool * D.21126;
  struct MonoMemPool * D.21129;
  char * D.21130;
  char * res;

  mono_image_set_lock (set);
  D.21126 = set->mempool;
  if (D.21126 == 0B) goto <D.21127>; else goto <D.21128>;
  <D.21127>:
  D.21129 = mono_mempool_new_size (1024);
  set->mempool = D.21129;
  <D.21128>:
  D.21126 = set->mempool;
  res = mono_mempool_strdup (D.21126, s);
  mono_image_set_unlock (set);
  D.21130 = res;
  return D.21130;
}


mono_metadata_clean_for_image (struct MonoImage * image)
{
  struct MonoImage * D.21132;
  struct GSList * D.21133;
  struct GHashTable * D.21134;
  struct GHashTable * D.21135;
  struct GHashTable * D.21136;
  struct GHashTable * D.21137;
  void * D.21138;
  struct GSList * D.21139;
  struct GSList * D.21140;
  struct CleanForImageUserData ginst_data;
  struct CleanForImageUserData gclass_data;
  struct GSList * l;
  struct GSList * set_list;

  try
    {
      gclass_data.image = image;
      D.21132 = gclass_data.image;
      ginst_data.image = D.21132;
      gclass_data.list = 0B;
      D.21133 = gclass_data.list;
      ginst_data.list = D.21133;
      mono_loader_lock ();
      l = image->image_sets;
      goto <D.18683>;
      <D.18682>:
      {
        struct MonoImageSet * set;

        set = l->data;
        D.21134 = set->gclass_cache;
        monoeg_g_hash_table_foreach_steal (D.21134, steal_gclass_in_image, &gclass_data);
        D.21135 = set->ginst_cache;
        monoeg_g_hash_table_foreach_steal (D.21135, steal_ginst_in_image, &ginst_data);
        D.21136 = set->gmethod_cache;
        monoeg_g_hash_table_foreach_remove (D.21136, inflated_method_in_image, image);
        D.21137 = set->gsignature_cache;
        monoeg_g_hash_table_foreach_remove (D.21137, inflated_signature_in_image, image);
      }
      l = l->next;
      <D.18683>:
      if (l != 0B) goto <D.18682>; else goto <D.18684>;
      <D.18684>:
      l = ginst_data.list;
      goto <D.18686>;
      <D.18685>:
      D.21138 = l->data;
      free_generic_inst (D.21138);
      l = l->next;
      <D.18686>:
      if (l != 0B) goto <D.18685>; else goto <D.18687>;
      <D.18687>:
      l = gclass_data.list;
      goto <D.18689>;
      <D.18688>:
      D.21138 = l->data;
      free_generic_class (D.21138);
      l = l->next;
      <D.18689>:
      if (l != 0B) goto <D.18688>; else goto <D.18690>;
      <D.18690>:
      D.21139 = ginst_data.list;
      monoeg_g_slist_free (D.21139);
      D.21133 = gclass_data.list;
      monoeg_g_slist_free (D.21133);
      D.21140 = image->image_sets;
      set_list = monoeg_g_slist_copy (D.21140);
      l = set_list;
      goto <D.18693>;
      <D.18692>:
      {
        struct MonoImageSet * set;

        set = l->data;
        delete_image_set (set);
      }
      l = l->next;
      <D.18693>:
      if (l != 0B) goto <D.18692>; else goto <D.18694>;
      <D.18694>:
      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.21141;
  int iftmp.81;
  struct MonoMethodSignature * D.21147;
  int D.21148;
  struct MonoGenericInst * D.21150;
  int D.21152;
  struct MonoGenericInst * D.21153;
  int D.21155;
  struct MonoImage * image;
  struct MonoInflatedMethodSignature * sig;

  image = data;
  sig = key;
  D.21147 = sig->sig;
  D.21148 = signature_in_image (D.21147, image);
  if (D.21148 != 0) goto <D.21143>; else goto <D.21149>;
  <D.21149>:
  D.21150 = sig->context.class_inst;
  if (D.21150 != 0B) goto <D.21151>; else goto <D.21144>;
  <D.21151>:
  D.21150 = sig->context.class_inst;
  D.21152 = ginst_in_image (D.21150, image);
  if (D.21152 != 0) goto <D.21143>; else goto <D.21144>;
  <D.21144>:
  D.21153 = sig->context.method_inst;
  if (D.21153 != 0B) goto <D.21154>; else goto <D.21145>;
  <D.21154>:
  D.21153 = sig->context.method_inst;
  D.21155 = ginst_in_image (D.21153, image);
  if (D.21155 != 0) goto <D.21143>; else goto <D.21145>;
  <D.21143>:
  iftmp.81 = 1;
  goto <D.21146>;
  <D.21145>:
  iftmp.81 = 0;
  <D.21146>:
  D.21141 = iftmp.81;
  return D.21141;
}


signature_in_image (struct MonoMethodSignature * sig, struct MonoImage * image)
{
  int D.21157;
  gboolean D.21160;
  struct MonoType * D.21161;
  void * iter;
  struct MonoType * p;

  try
    {
      iter = 0B;
      goto <D.18467>;
      <D.18466>:
      D.21157 = type_in_image (p, image);
      if (D.21157 != 0) goto <D.21158>; else goto <D.21159>;
      <D.21158>:
      D.21160 = 1;
      return D.21160;
      <D.21159>:
      <D.18467>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.18466>; else goto <D.18468>;
      <D.18468>:
      D.21161 = mono_signature_get_return_type (sig);
      D.21160 = type_in_image (D.21161, image);
      return D.21160;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


type_in_image (struct MonoType * type, struct MonoImage * image)
{
  unsigned char D.21164;
  int D.21165;
  gboolean D.21166;
  struct MonoGenericClass * D.21167;
  struct MonoClass * D.21168;
  struct MonoArrayType * D.21169;
  struct MonoClass * D.21170;
  struct MonoMethodSignature * D.21171;
  struct MonoGenericParam * D.21172;
  long unsigned int D.21175;
  long unsigned int D.21176;
  _Bool D.21177;
  long int D.21178;
  long int D.21179;
  struct MonoClass * D.21182;
  struct MonoImage * D.21185;
  _Bool D.21186;
  struct MonoImage * D.21187;
  _Bool D.21188;
  struct MonoImage * D.21189;
  _Bool D.21190;
  long unsigned int D.21195;
  long unsigned int D.21196;
  _Bool D.21197;
  long int D.21198;
  long int D.21199;
  struct MonoMethod * D.21202;
  struct MonoImage * D.21205;
  _Bool D.21206;
  struct MonoClass * D.21207;
  struct MonoImage * D.21208;
  _Bool D.21209;
  struct MonoClass * D.21210;
  struct MonoImage * D.21211;
  _Bool D.21212;
  void retry = <<< error >>>;

  retry:
  D.21164 = type->type;
  D.21165 = (int) D.21164;
  switch (D.21165) <default: <D.18495>, case 15: <D.18487>, case 19: <D.18491>, case 20: <D.18489>, case 21: <D.18486>, case 27: <D.18490>, case 29: <D.18488>, case 30: <D.18493>>
  <D.18486>:
  D.21167 = type->data.generic_class;
  D.21166 = gclass_in_image (D.21167, image);
  return D.21166;
  <D.18487>:
  type = type->data.type;
  goto retry;
  <D.18488>:
  D.21168 = type->data.klass;
  type = &D.21168->byval_arg;
  goto retry;
  <D.18489>:
  D.21169 = type->data.array;
  D.21170 = D.21169->eklass;
  type = &D.21170->byval_arg;
  goto retry;
  <D.18490>:
  D.21171 = type->data.method;
  D.21166 = signature_in_image (D.21171, image);
  return D.21166;
  <D.18491>:
  {
    struct MonoGenericContainer * container;

    D.21172 = type->data.generic_param;
    container = D.21172->owner;
    if (container != 0B) goto <D.21173>; else goto <D.21174>;
    <D.21173>:
    D.21175 = BIT_FIELD_REF <*container, 64, 256>;
    D.21176 = D.21175 & 2147483648;
    D.21177 = D.21176 != 0;
    D.21178 = (long int) D.21177;
    D.21179 = __builtin_expect (D.21178, 0);
    if (D.21179 != 0) goto <D.21180>; else goto <D.21181>;
    <D.21180>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2144, "!container->is_method");
    <D.21181>:
    D.21182 = container->owner.klass;
    if (D.21182 == 0B) goto <D.21183>; else goto <D.21184>;
    <D.21183>:
    D.21185 = container->image;
    D.21186 = D.21185 == image;
    D.21166 = (gboolean) D.21186;
    return D.21166;
    <D.21184>:
    D.21182 = container->owner.klass;
    D.21187 = D.21182->image;
    D.21188 = D.21187 == image;
    D.21166 = (gboolean) D.21188;
    return D.21166;
    <D.21174>:
    D.21172 = type->data.generic_param;
    D.21189 = D.21172->image;
    D.21190 = D.21189 == image;
    D.21166 = (gboolean) D.21190;
    return D.21166;
  }
  <D.18493>:
  {
    struct MonoGenericContainer * container;

    D.21172 = type->data.generic_param;
    container = D.21172->owner;
    D.21172 = type->data.generic_param;
    D.21189 = D.21172->image;
    if (D.21189 == image) goto <D.21191>; else goto <D.21192>;
    <D.21191>:
    D.21166 = 1;
    return D.21166;
    <D.21192>:
    if (container != 0B) goto <D.21193>; else goto <D.21194>;
    <D.21193>:
    D.21195 = BIT_FIELD_REF <*container, 64, 256>;
    D.21196 = D.21195 & 2147483648;
    D.21197 = D.21196 == 0;
    D.21198 = (long int) D.21197;
    D.21199 = __builtin_expect (D.21198, 0);
    if (D.21199 != 0) goto <D.21200>; else goto <D.21201>;
    <D.21200>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2169, "container->is_method");
    <D.21201>:
    D.21202 = container->owner.method;
    if (D.21202 == 0B) goto <D.21203>; else goto <D.21204>;
    <D.21203>:
    D.21205 = container->image;
    D.21206 = D.21205 == image;
    D.21166 = (gboolean) D.21206;
    return D.21166;
    <D.21204>:
    D.21202 = container->owner.method;
    D.21207 = D.21202->klass;
    D.21208 = D.21207->image;
    D.21209 = D.21208 == image;
    D.21166 = (gboolean) D.21209;
    return D.21166;
    <D.21194>:
    D.21172 = type->data.generic_param;
    D.21189 = D.21172->image;
    D.21190 = D.21189 == image;
    D.21166 = (gboolean) D.21190;
    return D.21166;
  }
  <D.18495>:
  D.21210 = mono_class_from_mono_type (type);
  D.21211 = D.21210->image;
  D.21212 = D.21211 == image;
  D.21166 = (gboolean) D.21212;
  return D.21166;
}


gclass_in_image (struct MonoGenericClass * gclass, struct MonoImage * image)
{
  gboolean D.21214;
  int iftmp.82;
  struct MonoClass * D.21219;
  struct MonoImage * D.21220;
  struct MonoGenericInst * D.21222;
  int D.21223;

  D.21219 = gclass->container_class;
  D.21220 = D.21219->image;
  if (D.21220 == image) goto <D.21216>; else goto <D.21221>;
  <D.21221>:
  D.21222 = gclass->context.class_inst;
  D.21223 = ginst_in_image (D.21222, image);
  if (D.21223 != 0) goto <D.21216>; else goto <D.21217>;
  <D.21216>:
  iftmp.82 = 1;
  goto <D.21218>;
  <D.21217>:
  iftmp.82 = 0;
  <D.21218>:
  D.21214 = iftmp.82;
  return D.21214;
}


ginst_in_image (struct MonoGenericInst * ginst, struct MonoImage * image)
{
  struct MonoType * D.21225;
  int D.21226;
  gboolean D.21229;
  <unnamed-unsigned:22> D.21230;
  int D.21231;
  int i;

  i = 0;
  goto <D.18475>;
  <D.18474>:
  D.21225 = ginst->type_argv[i];
  D.21226 = type_in_image (D.21225, image);
  if (D.21226 != 0) goto <D.21227>; else goto <D.21228>;
  <D.21227>:
  D.21229 = 1;
  return D.21229;
  <D.21228>:
  i = i + 1;
  <D.18475>:
  D.21230 = ginst->type_argc;
  D.21231 = (int) D.21230;
  if (D.21231 > i) goto <D.18474>; else goto <D.18476>;
  <D.18476>:
  D.21229 = 0;
  return D.21229;
}


inflated_method_in_image (void * key, void * value, void * data)
{
  int iftmp.83;
  struct MonoMethod * D.21239;
  struct MonoClass * D.21240;
  struct MonoImage * D.21241;
  struct MonoGenericInst * D.21243;
  int D.21245;
  struct MonoGenericInst * D.21246;
  int D.21248;
  struct MonoMethodSignature * D.21249;
  struct MonoMethodSignature * D.21251;
  int D.21252;
  _Bool D.21253;
  long int D.21254;
  long int D.21255;
  gboolean D.21258;
  struct MonoImage * image;
  struct MonoMethodInflated * method;

  image = data;
  method = key;
  D.21239 = method->declaring;
  D.21240 = D.21239->klass;
  D.21241 = D.21240->image;
  if (D.21241 != image) goto <D.21242>; else goto <D.21234>;
  <D.21242>:
  D.21243 = method->context.class_inst;
  if (D.21243 == 0B) goto <D.21235>; else goto <D.21244>;
  <D.21244>:
  D.21243 = method->context.class_inst;
  D.21245 = ginst_in_image (D.21243, image);
  if (D.21245 == 0) goto <D.21235>; else goto <D.21234>;
  <D.21235>:
  D.21246 = method->context.method_inst;
  if (D.21246 == 0B) goto <D.21236>; else goto <D.21247>;
  <D.21247>:
  D.21246 = method->context.method_inst;
  D.21248 = ginst_in_image (D.21246, image);
  if (D.21248 == 0) goto <D.21236>; else goto <D.21234>;
  <D.21236>:
  D.21249 = MEM[(struct MonoMethod *)method].signature;
  if (D.21249 == 0B) goto <D.21237>; else goto <D.21250>;
  <D.21250>:
  D.21251 = mono_method_signature (method);
  D.21252 = signature_in_image (D.21251, image);
  if (D.21252 == 0) goto <D.21237>; else goto <D.21234>;
  <D.21237>:
  iftmp.83 = 1;
  goto <D.21238>;
  <D.21234>:
  iftmp.83 = 0;
  <D.21238>:
  D.21253 = iftmp.83 != 0;
  D.21254 = (long int) D.21253;
  D.21255 = __builtin_expect (D.21254, 0);
  if (D.21255 != 0) goto <D.21256>; else goto <D.21257>;
  <D.21256>:
  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.21257>:
  D.21258 = 1;
  return D.21258;
}


steal_ginst_in_image (void * key, void * value, void * data)
{
  struct GSList * D.21260;
  struct GSList * D.21261;
  gboolean D.21262;
  struct MonoGenericInst * ginst;
  struct CleanForImageUserData * user_data;

  ginst = key;
  user_data = data;
  D.21260 = user_data->list;
  D.21261 = monoeg_g_slist_prepend (D.21260, ginst);
  user_data->list = D.21261;
  D.21262 = 1;
  return D.21262;
}


steal_gclass_in_image (void * key, void * value, void * data)
{
  struct MonoImage * D.21264;
  int D.21265;
  _Bool D.21266;
  long int D.21267;
  long int D.21268;
  struct GSList * D.21271;
  struct GSList * D.21272;
  gboolean D.21273;
  struct MonoGenericClass * gclass;
  struct CleanForImageUserData * user_data;

  gclass = key;
  user_data = data;
  D.21264 = user_data->image;
  D.21265 = gclass_in_image (gclass, D.21264);
  D.21266 = D.21265 == 0;
  D.21267 = (long int) D.21266;
  D.21268 = __builtin_expect (D.21267, 0);
  if (D.21268 != 0) goto <D.21269>; else goto <D.21270>;
  <D.21269>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2530, "gclass_in_image (gclass, user_data->image)");
  <D.21270>:
  D.21271 = user_data->list;
  D.21272 = monoeg_g_slist_prepend (D.21271, gclass);
  user_data->list = D.21272;
  D.21273 = 1;
  return D.21273;
}


free_generic_inst (struct MonoGenericInst * ginst)
{
  struct MonoType * D.21275;
  <unnamed-unsigned:22> D.21276;
  int D.21277;
  int i;

  i = 0;
  goto <D.18709>;
  <D.18708>:
  D.21275 = ginst->type_argv[i];
  mono_metadata_free_type (D.21275);
  i = i + 1;
  <D.18709>:
  D.21276 = ginst->type_argc;
  D.21277 = (int) D.21276;
  if (D.21277 > i) goto <D.18708>; else goto <D.18710>;
  <D.18710>:
}


free_generic_class (struct MonoGenericClass * gclass)
{
  long unsigned int D.21278;
  long unsigned int D.21279;
  struct MonoClass * D.21282;
  short unsigned int D.21285;

  D.21278 = BIT_FIELD_REF <*gclass, 64, 192>;
  D.21279 = D.21278 & 1;
  if (D.21279 != 0) goto <D.21280>; else goto <D.21281>;
  <D.21280>:
  mono_reflection_free_dynamic_generic_class (gclass);
  <D.21281>:
  D.21282 = gclass->cached_class;
  if (D.21282 != 0B) goto <D.21283>; else goto <D.21284>;
  <D.21283>:
  D.21282 = gclass->cached_class;
  D.21285 = D.21282->interface_id;
  if (D.21285 != 0) goto <D.21286>; else goto <D.21287>;
  <D.21286>:
  D.21282 = gclass->cached_class;
  mono_unload_interface_id (D.21282);
  <D.21287>:
  <D.21284>:
}


delete_image_set (struct MonoImageSet * set)
{
  struct GHashTable * D.21288;
  struct GHashTable * D.21289;
  struct GHashTable * D.21290;
  struct GHashTable * D.21291;
  struct MonoImage * * D.21292;
  long unsigned int D.21293;
  long unsigned int D.21294;
  struct MonoImage * * D.21295;
  struct MonoImage * D.21296;
  struct GSList * D.21297;
  struct GSList * D.21298;
  int D.21299;
  struct GPtrArray * image_sets.84;
  struct MonoMemPool * D.21301;
  struct CRITICAL_SECTION * D.21304;
  int i;

  D.21288 = set->gclass_cache;
  monoeg_g_hash_table_destroy (D.21288);
  D.21289 = set->ginst_cache;
  monoeg_g_hash_table_destroy (D.21289);
  D.21290 = set->gmethod_cache;
  monoeg_g_hash_table_destroy (D.21290);
  D.21291 = set->gsignature_cache;
  monoeg_g_hash_table_destroy (D.21291);
  i = 0;
  goto <D.18525>;
  <D.18524>:
  D.21292 = set->images;
  D.21293 = (long unsigned int) i;
  D.21294 = D.21293 * 8;
  D.21295 = D.21292 + D.21294;
  D.21296 = *D.21295;
  D.21292 = set->images;
  D.21293 = (long unsigned int) i;
  D.21294 = D.21293 * 8;
  D.21295 = D.21292 + D.21294;
  D.21296 = *D.21295;
  D.21297 = D.21296->image_sets;
  D.21298 = monoeg_g_slist_remove (D.21297, set);
  D.21296->image_sets = D.21298;
  i = i + 1;
  <D.18525>:
  D.21299 = set->nimages;
  if (D.21299 > i) goto <D.18524>; else goto <D.18526>;
  <D.18526>:
  image_sets.84 = image_sets;
  monoeg_g_ptr_array_remove (image_sets.84, set);
  D.21301 = set->mempool;
  if (D.21301 != 0B) goto <D.21302>; else goto <D.21303>;
  <D.21302>:
  D.21301 = set->mempool;
  mono_mempool_destroy (D.21301);
  <D.21303>:
  D.21292 = set->images;
  monoeg_g_free (D.21292);
  D.21304 = &set->lock;
  DeleteCriticalSection (D.21304);
  monoeg_g_free (set);
}


mono_method_inflated_lookup (struct MonoMethodInflated * method, gboolean cache)
{
  struct MonoImage * * D.21305;
  int D.21306;
  struct GHashTable * D.21309;
  struct MonoMethodInflated * D.21310;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      collect_data_init (&data);
      collect_method_images (method, &data);
      D.21305 = data.images;
      D.21306 = data.nimages;
      set = get_image_set (D.21305, D.21306);
      collect_data_free (&data);
      if (cache != 0) goto <D.21307>; else goto <D.21308>;
      <D.21307>:
      D.21309 = set->gmethod_cache;
      monoeg_g_hash_table_insert_replace (D.21309, method, method, 0);
      D.21310 = method;
      return D.21310;
      <D.21308>:
      D.21309 = set->gmethod_cache;
      D.21310 = monoeg_g_hash_table_lookup (D.21309, method);
      return D.21310;
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


collect_method_images (struct MonoMethodInflated * method, struct CollectData * data)
{
  struct MonoMethod * D.21314;
  struct MonoClass * D.21315;
  struct MonoImage * D.21316;
  struct MonoGenericInst * D.21317;
  struct MonoGenericInst * D.21320;
  struct MonoClass * D.21323;
  struct MonoImage * D.21324;
  long unsigned int D.21325;
  long unsigned int D.21326;
  struct MonoMethodSignature * D.21329;
  struct MonoMethod * m;

  m = method->declaring;
  D.21314 = method->declaring;
  D.21315 = D.21314->klass;
  D.21316 = D.21315->image;
  add_image (D.21316, data);
  D.21317 = method->context.class_inst;
  if (D.21317 != 0B) goto <D.21318>; else goto <D.21319>;
  <D.21318>:
  D.21317 = method->context.class_inst;
  collect_ginst_images (D.21317, data);
  <D.21319>:
  D.21320 = method->context.method_inst;
  if (D.21320 != 0B) goto <D.21321>; else goto <D.21322>;
  <D.21321>:
  D.21320 = method->context.method_inst;
  collect_ginst_images (D.21320, data);
  <D.21322>:
  D.21323 = m->klass;
  D.21324 = D.21323->image;
  D.21325 = BIT_FIELD_REF <*D.21324, 64, 192>;
  D.21326 = D.21325 & 34359738368;
  if (D.21326 != 0) goto <D.21327>; else goto <D.21328>;
  <D.21327>:
  D.21329 = mono_method_signature (m);
  collect_signature_images (D.21329, data);
  <D.21328>:
}


add_image (struct MonoImage * image, struct CollectData * data)
{
  struct MonoImage * * D.21330;
  long unsigned int D.21331;
  long unsigned int D.21332;
  struct MonoImage * * D.21333;
  struct MonoImage * D.21334;
  int D.21337;
  int D.21338;
  int D.21341;
  int D.21342;
  long unsigned int D.21343;
  long unsigned int D.21344;
  struct MonoImage * * D.21345;
  int i;

  i = 0;
  goto <D.18573>;
  <D.18572>:
  D.21330 = data->images;
  D.21331 = (long unsigned int) i;
  D.21332 = D.21331 * 8;
  D.21333 = D.21330 + D.21332;
  D.21334 = *D.21333;
  if (D.21334 == image) goto <D.21335>; else goto <D.21336>;
  <D.21335>:
  return;
  <D.21336>:
  i = i + 1;
  <D.18573>:
  D.21337 = data->nimages;
  if (D.21337 > i) goto <D.18572>; else goto <D.18574>;
  <D.18574>:
  D.21337 = data->nimages;
  D.21338 = data->images_len;
  if (D.21337 == D.21338) goto <D.21339>; else goto <D.21340>;
  <D.21339>:
  enlarge_data (data);
  <D.21340>:
  D.21330 = data->images;
  D.21337 = data->nimages;
  D.21341 = D.21337;
  D.21342 = D.21341 + 1;
  data->nimages = D.21342;
  D.21343 = (long unsigned int) D.21341;
  D.21344 = D.21343 * 8;
  D.21345 = D.21330 + D.21344;
  *D.21345 = image;
}


enlarge_data (struct CollectData * data)
{
  int iftmp.85;
  int D.21348;
  long unsigned int D.21352;
  long unsigned int D.21353;
  struct MonoImage * * D.21354;
  long unsigned int D.21355;
  struct MonoImage *[64] * D.21356;
  int new_len;
  struct MonoImage * * d;

  D.21348 = data->images_len;
  if (D.21348 > 15) goto <D.21349>; else goto <D.21350>;
  <D.21349>:
  D.21348 = data->images_len;
  iftmp.85 = D.21348 * 2;
  goto <D.21351>;
  <D.21350>:
  iftmp.85 = 16;
  <D.21351>:
  new_len = iftmp.85;
  D.21352 = (long unsigned int) new_len;
  D.21353 = D.21352 * 8;
  d = monoeg_malloc (D.21353);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2365);
  D.21354 = data->images;
  D.21348 = data->images_len;
  D.21355 = (long unsigned int) D.21348;
  memcpy (d, D.21354, D.21355);
  D.21354 = data->images;
  D.21356 = &data->image_buf;
  if (D.21354 != D.21356) goto <D.21357>; else goto <D.21358>;
  <D.21357>:
  D.21354 = data->images;
  monoeg_g_free (D.21354);
  <D.21358>:
  data->images = d;
  data->images_len = new_len;
}


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

  i = 0;
  goto <D.18584>;
  <D.18583>:
  D.21359 = ginst->type_argv[i];
  collect_type_images (D.21359, data);
  i = i + 1;
  <D.18584>:
  D.21360 = ginst->type_argc;
  D.21361 = (int) D.21360;
  if (D.21361 > i) goto <D.18583>; else goto <D.18585>;
  <D.18585>:
}


collect_type_images (struct MonoType * type, struct CollectData * data)
{
  unsigned char D.21362;
  int D.21363;
  struct MonoGenericClass * D.21364;
  struct MonoClass * D.21365;
  struct MonoArrayType * D.21366;
  struct MonoClass * D.21367;
  struct MonoGenericParam * D.21368;
  long unsigned int D.21371;
  long unsigned int D.21372;
  _Bool D.21373;
  long int D.21374;
  long int D.21375;
  struct MonoClass * D.21378;
  struct MonoImage * D.21381;
  struct MonoImage * D.21383;
  struct MonoImage * D.21385;
  struct MonoMethod * D.21390;
  struct MonoImage * D.21393;
  long unsigned int D.21395;
  long unsigned int D.21396;
  _Bool D.21397;
  long int D.21398;
  long int D.21399;
  struct MonoClass * D.21402;
  struct MonoImage * D.21403;
  struct MonoClass * D.21405;
  struct MonoImage * D.21406;
  struct MonoImage * D.21407;
  void retry = <<< error >>>;

  retry:
  D.21362 = type->type;
  D.21363 = (int) D.21362;
  switch (D.21363) <default: <D.18625>, case 15: <D.18615>, case 17: <D.18624>, case 18: <D.18623>, case 19: <D.18619>, case 20: <D.18617>, case 21: <D.18613>, case 27: <D.18618>, case 29: <D.18616>, case 30: <D.18621>>
  <D.18613>:
  D.21364 = type->data.generic_class;
  collect_gclass_images (D.21364, data);
  goto <D.18614>;
  <D.18615>:
  type = type->data.type;
  goto retry;
  <D.18616>:
  D.21365 = type->data.klass;
  type = &D.21365->byval_arg;
  goto retry;
  <D.18617>:
  D.21366 = type->data.array;
  D.21367 = D.21366->eklass;
  type = &D.21367->byval_arg;
  goto retry;
  <D.18618>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 2467);
  <D.18619>:
  {
    struct MonoGenericContainer * container;

    D.21368 = type->data.generic_param;
    container = D.21368->owner;
    if (container != 0B) goto <D.21369>; else goto <D.21370>;
    <D.21369>:
    D.21371 = BIT_FIELD_REF <*container, 64, 256>;
    D.21372 = D.21371 & 2147483648;
    D.21373 = D.21372 != 0;
    D.21374 = (long int) D.21373;
    D.21375 = __builtin_expect (D.21374, 0);
    if (D.21375 != 0) goto <D.21376>; else goto <D.21377>;
    <D.21376>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2471, "!container->is_method");
    <D.21377>:
    D.21378 = container->owner.klass;
    if (D.21378 == 0B) goto <D.21379>; else goto <D.21380>;
    <D.21379>:
    D.21381 = container->image;
    add_image (D.21381, data);
    goto <D.21382>;
    <D.21380>:
    D.21378 = container->owner.klass;
    D.21383 = D.21378->image;
    add_image (D.21383, data);
    <D.21382>:
    goto <D.21384>;
    <D.21370>:
    D.21368 = type->data.generic_param;
    D.21385 = D.21368->image;
    add_image (D.21385, data);
    <D.21384>:
  }
  goto <D.18614>;
  <D.18621>:
  {
    struct MonoGenericContainer * container;

    D.21368 = type->data.generic_param;
    container = D.21368->owner;
    D.21368 = type->data.generic_param;
    D.21385 = D.21368->image;
    if (D.21385 != 0B) goto <D.21386>; else goto <D.21387>;
    <D.21386>:
    D.21368 = type->data.generic_param;
    D.21385 = D.21368->image;
    add_image (D.21385, data);
    <D.21387>:
    if (container != 0B) goto <D.21388>; else goto <D.21389>;
    <D.21388>:
    D.21390 = container->owner.method;
    if (D.21390 == 0B) goto <D.21391>; else goto <D.21392>;
    <D.21391>:
    D.21393 = container->image;
    add_image (D.21393, data);
    goto <D.21394>;
    <D.21392>:
    D.21395 = BIT_FIELD_REF <*container, 64, 256>;
    D.21396 = D.21395 & 2147483648;
    D.21397 = D.21396 == 0;
    D.21398 = (long int) D.21397;
    D.21399 = __builtin_expect (D.21398, 0);
    if (D.21399 != 0) goto <D.21400>; else goto <D.21401>;
    <D.21400>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2502, "container->is_method");
    <D.21401>:
    D.21390 = container->owner.method;
    D.21402 = D.21390->klass;
    D.21403 = D.21402->image;
    add_image (D.21403, data);
    <D.21394>:
    goto <D.21404>;
    <D.21389>:
    D.21368 = type->data.generic_param;
    D.21385 = D.21368->image;
    add_image (D.21385, data);
    <D.21404>:
  }
  goto <D.18614>;
  <D.18623>:
  <D.18624>:
  D.21405 = mono_class_from_mono_type (type);
  D.21406 = D.21405->image;
  add_image (D.21406, data);
  goto <D.18614>;
  <D.18625>:
  D.21407 = mono_defaults.corlib;
  add_image (D.21407, data);
  <D.18614>:
}


collect_gclass_images (struct MonoGenericClass * gclass, struct CollectData * data)
{
  struct MonoClass * D.21408;
  struct MonoImage * D.21409;
  struct MonoGenericInst * D.21410;

  D.21408 = gclass->container_class;
  D.21409 = D.21408->image;
  add_image (D.21409, data);
  D.21410 = gclass->context.class_inst;
  if (D.21410 != 0B) goto <D.21411>; else goto <D.21412>;
  <D.21411>:
  D.21410 = gclass->context.class_inst;
  collect_ginst_images (D.21410, data);
  <D.21412>:
}


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

  try
    {
      iter = 0B;
      D.21413 = mono_signature_get_return_type (sig);
      collect_type_images (D.21413, data);
      goto <D.18597>;
      <D.18596>:
      collect_type_images (p, data);
      <D.18597>:
      p = mono_signature_get_params (sig, &iter);
      if (p != 0B) goto <D.18596>; else goto <D.18598>;
      <D.18598>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_image_set (struct MonoImage * * images, int nimages)
{
  struct GPtrArray * image_sets.86;
  struct GPtrArray * image_sets.87;
  struct MonoImage * D.21420;
  struct MonoImage * D.21421;
  struct MonoImageSet * mscorlib_image_set.88;
  struct MonoImageSet * D.21427;
  struct MonoImage * * D.21434;
  struct MonoImage * D.21435;
  int D.21436;
  struct MonoImage * * D.21439;
  long unsigned int D.21440;
  long unsigned int D.21441;
  struct MonoImage * * D.21442;
  struct MonoImage * D.21443;
  long unsigned int D.21444;
  long unsigned int D.21445;
  struct MonoImage * * D.21446;
  struct MonoImage * D.21447;
  long unsigned int D.21453;
  long unsigned int D.21454;
  void * D.21455;
  struct CRITICAL_SECTION * D.21456;
  long unsigned int D.21457;
  long unsigned int D.21458;
  struct MonoImage * * D.21459;
  struct MonoImage * * D.21460;
  struct MonoImage * D.21461;
  struct GHashTable * D.21462;
  struct GHashTable * D.21463;
  struct GHashTable * D.21464;
  struct GHashTable * D.21465;
  struct MonoImage * D.21466;
  struct GSList * D.21467;
  struct GSList * D.21468;
  int i;
  int j;
  int k;
  struct MonoImageSet * set;
  struct GSList * l;

  image_sets.86 = image_sets;
  if (image_sets.86 == 0B) goto <D.21415>; else goto <D.21416>;
  <D.21415>:
  image_sets.87 = monoeg_g_ptr_array_new ();
  image_sets = image_sets.87;
  <D.21416>:
  if (nimages == 1) goto <D.21418>; else goto <D.21419>;
  <D.21418>:
  D.21420 = *images;
  D.21421 = mono_defaults.corlib;
  if (D.21420 == D.21421) goto <D.21422>; else goto <D.21423>;
  <D.21422>:
  mscorlib_image_set.88 = mscorlib_image_set;
  if (mscorlib_image_set.88 != 0B) goto <D.21425>; else goto <D.21426>;
  <D.21425>:
  D.21427 = mscorlib_image_set;
  return D.21427;
  <D.21426>:
  <D.21423>:
  <D.21419>:
  if (nimages == 0) goto <D.21428>; else goto <D.21429>;
  <D.21428>:
  D.21427 = mscorlib_image_set;
  return D.21427;
  <D.21429>:
  D.21420 = *images;
  D.21421 = mono_defaults.corlib;
  if (D.21420 == D.21421) goto <D.21432>; else goto <D.21430>;
  <D.21432>:
  if (nimages > 1) goto <D.21433>; else goto <D.21430>;
  <D.21433>:
  D.21434 = images + 8;
  D.21435 = *D.21434;
  l = D.21435->image_sets;
  goto <D.21431>;
  <D.21430>:
  D.21420 = *images;
  l = D.21420->image_sets;
  <D.21431>:
  set = 0B;
  goto <D.18513>;
  <D.18512>:
  set = l->data;
  D.21436 = set->nimages;
  if (D.21436 == nimages) goto <D.21437>; else goto <D.21438>;
  <D.21437>:
  j = 0;
  goto <D.18510>;
  <D.18509>:
  k = 0;
  goto <D.18507>;
  <D.18506>:
  D.21439 = set->images;
  D.21440 = (long unsigned int) k;
  D.21441 = D.21440 * 8;
  D.21442 = D.21439 + D.21441;
  D.21443 = *D.21442;
  D.21444 = (long unsigned int) j;
  D.21445 = D.21444 * 8;
  D.21446 = images + D.21445;
  D.21447 = *D.21446;
  if (D.21443 == D.21447) goto <D.18505>; else goto <D.21448>;
  <D.21448>:
  k = k + 1;
  <D.18507>:
  if (k < nimages) goto <D.18506>; else goto <D.18505>;
  <D.18505>:
  if (k == nimages) goto <D.18508>; else goto <D.21449>;
  <D.21449>:
  j = j + 1;
  <D.18510>:
  if (j < nimages) goto <D.18509>; else goto <D.18508>;
  <D.18508>:
  if (j == nimages) goto <D.18511>; else goto <D.21450>;
  <D.21450>:
  <D.21438>:
  l = l->next;
  <D.18513>:
  if (l != 0B) goto <D.18512>; else goto <D.18511>;
  <D.18511>:
  if (l == 0B) goto <D.21451>; else goto <D.21452>;
  <D.21451>:
  set = monoeg_malloc0 (104);
  set->nimages = nimages;
  D.21453 = (long unsigned int) nimages;
  D.21454 = D.21453 * 8;
  D.21455 = monoeg_malloc0 (D.21454);
  set->images = D.21455;
  D.21456 = &set->lock;
  InitializeCriticalSection (D.21456);
  i = 0;
  goto <D.18515>;
  <D.18514>:
  D.21439 = set->images;
  D.21457 = (long unsigned int) i;
  D.21458 = D.21457 * 8;
  D.21459 = D.21439 + D.21458;
  D.21457 = (long unsigned int) i;
  D.21458 = D.21457 * 8;
  D.21460 = images + D.21458;
  D.21461 = *D.21460;
  *D.21459 = D.21461;
  i = i + 1;
  <D.18515>:
  if (i < nimages) goto <D.18514>; else goto <D.18516>;
  <D.18516>:
  D.21462 = monoeg_g_hash_table_new_full (mono_generic_class_hash, mono_generic_class_equal, 0B, free_generic_class);
  set->gclass_cache = D.21462;
  D.21463 = monoeg_g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, 0B, free_generic_inst);
  set->ginst_cache = D.21463;
  D.21464 = monoeg_g_hash_table_new_full (inflated_method_hash, inflated_method_equal, 0B, free_inflated_method);
  set->gmethod_cache = D.21464;
  D.21465 = monoeg_g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, 0B, free_inflated_signature);
  set->gsignature_cache = D.21465;
  i = 0;
  goto <D.18518>;
  <D.18517>:
  D.21439 = set->images;
  D.21457 = (long unsigned int) i;
  D.21458 = D.21457 * 8;
  D.21459 = D.21439 + D.21458;
  D.21466 = *D.21459;
  D.21439 = set->images;
  D.21457 = (long unsigned int) i;
  D.21458 = D.21457 * 8;
  D.21459 = D.21439 + D.21458;
  D.21466 = *D.21459;
  D.21467 = D.21466->image_sets;
  D.21468 = monoeg_g_slist_prepend (D.21467, set);
  D.21466->image_sets = D.21468;
  i = i + 1;
  <D.18518>:
  if (i < nimages) goto <D.18517>; else goto <D.18519>;
  <D.18519>:
  image_sets.86 = image_sets;
  monoeg_g_ptr_array_add (image_sets.86, set);
  <D.21452>:
  if (nimages == 1) goto <D.21469>; else goto <D.21470>;
  <D.21469>:
  D.21420 = *images;
  D.21421 = mono_defaults.corlib;
  if (D.21420 == D.21421) goto <D.21471>; else goto <D.21472>;
  <D.21471>:
  mscorlib_image_set = set;
  <D.21472>:
  <D.21470>:
  D.21427 = set;
  return D.21427;
}


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

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


inflated_signature_equal (const void * a, const void * b)
{
  struct MonoMethodSignature * D.21475;
  struct MonoMethodSignature * D.21476;
  gboolean D.21479;
  const struct MonoGenericContext * D.21480;
  const struct MonoGenericContext * D.21481;
  const struct MonoInflatedMethodSignature * sig1;
  const struct MonoInflatedMethodSignature * sig2;

  sig1 = a;
  sig2 = b;
  D.21475 = sig1->sig;
  D.21476 = sig2->sig;
  if (D.21475 != D.21476) goto <D.21477>; else goto <D.21478>;
  <D.21477>:
  D.21479 = 0;
  return D.21479;
  <D.21478>:
  D.21480 = &sig1->context;
  D.21481 = &sig2->context;
  D.21479 = mono_metadata_generic_context_equal (D.21480, D.21481);
  return D.21479;
}


inflated_signature_hash (const void * a)
{
  guint D.21483;
  const struct MonoGenericContext * D.21484;
  unsigned int D.21485;
  struct MonoMethodSignature * D.21486;
  unsigned int D.21487;
  const struct MonoInflatedMethodSignature * sig;

  sig = a;
  D.21484 = &sig->context;
  D.21485 = mono_metadata_generic_context_hash (D.21484);
  D.21486 = sig->sig;
  D.21487 = mono_aligned_addr_hash (D.21486);
  D.21483 = D.21485 ^ D.21487;
  return D.21483;
}


free_inflated_method (struct MonoMethodInflated * imethod)
{
  struct MonoMethodSignature * D.21489;
  short unsigned int D.21492;
  int D.21493;
  int D.21494;
  short unsigned int D.21497;
  unsigned int D.21498;
  unsigned int D.21499;
  int D.21502;
  struct MonoType * D.21507;
  short unsigned int D.21508;
  int D.21509;
  struct MonoExceptionClause * D.21510;
  int i;
  struct MonoMethod * method;

  method = imethod;
  mono_marshal_free_inflated_wrappers (method);
  D.21489 = method->signature;
  if (D.21489 != 0B) goto <D.21490>; else goto <D.21491>;
  <D.21490>:
  D.21489 = method->signature;
  mono_metadata_free_inflated_signature (D.21489);
  <D.21491>:
  D.21492 = method->flags;
  D.21493 = (int) D.21492;
  D.21494 = D.21493 & 1024;
  if (D.21494 == 0) goto <D.21495>; else goto <D.21496>;
  <D.21495>:
  D.21497 = method->iflags;
  D.21498 = (unsigned int) D.21497;
  D.21499 = D.21498 & 4099;
  if (D.21499 == 0) goto <D.21500>; else goto <D.21501>;
  <D.21500>:
  D.21492 = method->flags;
  D.21493 = (int) D.21492;
  D.21502 = D.21493 & 8192;
  if (D.21502 == 0) goto <D.21503>; else goto <D.21504>;
  <D.21503>:
  {
    struct MonoMethodHeader * header;

    header = imethod->header;
    if (header != 0B) goto <D.21505>; else goto <D.21506>;
    <D.21505>:
    i = 0;
    goto <D.18702>;
    <D.18701>:
    D.21507 = header->locals[i];
    mono_metadata_free_type (D.21507);
    i = i + 1;
    <D.18702>:
    D.21508 = header->num_locals;
    D.21509 = (int) D.21508;
    if (D.21509 > i) goto <D.18701>; else goto <D.18703>;
    <D.18703>:
    D.21510 = header->clauses;
    monoeg_g_free (D.21510);
    monoeg_g_free (header);
    <D.21506>:
  }
  <D.21504>:
  <D.21501>:
  <D.21496>:
  monoeg_g_free (method);
}


inflated_method_equal (const void * a, const void * b)
{
  struct MonoMethod * D.21511;
  struct MonoMethod * D.21512;
  gboolean D.21515;
  long unsigned int D.21516;
  long unsigned int D.21517;
  long unsigned int D.21518;
  long unsigned int D.21519;
  const struct MonoGenericContext * D.21522;
  const struct MonoGenericContext * D.21523;
  const struct MonoMethodInflated * ma;
  const struct MonoMethodInflated * mb;

  ma = a;
  mb = b;
  D.21511 = ma->declaring;
  D.21512 = mb->declaring;
  if (D.21511 != D.21512) goto <D.21513>; else goto <D.21514>;
  <D.21513>:
  D.21515 = 0;
  return D.21515;
  <D.21514>:
  D.21516 = BIT_FIELD_REF <*ma, 64, 256>;
  D.21517 = BIT_FIELD_REF <*mb, 64, 256>;
  D.21518 = D.21516 ^ D.21517;
  D.21519 = D.21518 & 32768;
  if (D.21519 != 0) goto <D.21520>; else goto <D.21521>;
  <D.21520>:
  D.21515 = 0;
  return D.21515;
  <D.21521>:
  D.21522 = &ma->context;
  D.21523 = &mb->context;
  D.21515 = mono_metadata_generic_context_equal (D.21522, D.21523);
  return D.21515;
}


inflated_method_hash (const void * a)
{
  guint D.21525;
  const struct MonoGenericContext * D.21526;
  unsigned int D.21527;
  struct MonoMethod * D.21528;
  unsigned int D.21529;
  unsigned int D.21530;
  <unnamed-unsigned:1> D.21531;
  unsigned int D.21532;
  const struct MonoMethodInflated * ma;

  ma = a;
  D.21526 = &ma->context;
  D.21527 = mono_metadata_generic_context_hash (D.21526);
  D.21528 = ma->declaring;
  D.21529 = mono_aligned_addr_hash (D.21528);
  D.21530 = D.21527 ^ D.21529;
  D.21531 = ma->method.method.is_mb_open;
  D.21532 = (unsigned int) D.21531;
  D.21525 = D.21530 + D.21532;
  return D.21525;
}


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

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


collect_data_free (struct CollectData * data)
{
  struct MonoImage * * D.21536;
  struct MonoImage *[64] * D.21537;

  D.21536 = data->images;
  D.21537 = &data->image_buf;
  if (D.21536 != D.21537) goto <D.21538>; else goto <D.21539>;
  <D.21538>:
  D.21536 = data->images;
  monoeg_g_free (D.21536);
  <D.21539>:
}


mono_metadata_get_inflated_signature (struct MonoMethodSignature * sig, struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.21540;
  struct MonoGenericInst * D.21541;
  struct MonoImage * * D.21542;
  int D.21543;
  struct GHashTable * D.21544;
  struct MonoMethodSignature * D.21547;
  struct MonoInflatedMethodSignature helper;
  struct MonoInflatedMethodSignature * res;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      mono_loader_lock ();
      helper.sig = sig;
      D.21540 = context->class_inst;
      helper.context.class_inst = D.21540;
      D.21541 = context->method_inst;
      helper.context.method_inst = D.21541;
      collect_data_init (&data);
      collect_inflated_signature_images (&helper, &data);
      D.21542 = data.images;
      D.21543 = data.nimages;
      set = get_image_set (D.21542, D.21543);
      collect_data_free (&data);
      D.21544 = set->gsignature_cache;
      res = monoeg_g_hash_table_lookup (D.21544, &helper);
      if (res == 0B) goto <D.21545>; else goto <D.21546>;
      <D.21545>:
      res = monoeg_malloc0 (24);
      res->sig = sig;
      D.21540 = context->class_inst;
      res->context.class_inst = D.21540;
      D.21541 = context->method_inst;
      res->context.method_inst = D.21541;
      D.21544 = set->gsignature_cache;
      monoeg_g_hash_table_insert_replace (D.21544, res, res, 0);
      <D.21546>:
      mono_loader_unlock ();
      D.21547 = res->sig;
      return D.21547;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


collect_inflated_signature_images (struct MonoInflatedMethodSignature * sig, struct CollectData * data)
{
  struct MonoMethodSignature * D.21550;
  struct MonoGenericInst * D.21551;
  struct MonoGenericInst * D.21554;

  D.21550 = sig->sig;
  collect_signature_images (D.21550, data);
  D.21551 = sig->context.class_inst;
  if (D.21551 != 0B) goto <D.21552>; else goto <D.21553>;
  <D.21552>:
  D.21551 = sig->context.class_inst;
  collect_ginst_images (D.21551, data);
  <D.21553>:
  D.21554 = sig->context.method_inst;
  if (D.21554 != 0B) goto <D.21555>; else goto <D.21556>;
  <D.21555>:
  D.21554 = sig->context.method_inst;
  collect_ginst_images (D.21554, data);
  <D.21556>:
}


mono_metadata_get_generic_inst (int type_argc, struct MonoType * * type_argv)
{
  long unsigned int D.21557;
  long unsigned int D.21558;
  unsigned int D.21559;
  unsigned int D.21560;
  long unsigned int D.21561;
  long unsigned int D.21562;
  struct MonoType * * D.21563;
  struct MonoType * D.21564;
  int D.21565;
  _Bool D.21567;
  long unsigned int D.21568;
  unsigned char D.21569;
  <unnamed-unsigned:1> D.21570;
  unsigned int type_argc.89;
  <unnamed-unsigned:22> D.21572;
  struct MonoType *[0:] * D.21573;
  long unsigned int D.21574;
  struct MonoImage * * D.21575;
  int D.21576;
  struct GHashTable * D.21577;
  unsigned int size.90;
  int next_generic_inst_id.91;
  int next_generic_inst_id.92;
  unsigned int next_generic_inst_id.93;
  struct MonoType * D.21584;
  struct MonoGenericInst * D.21585;
  struct MonoGenericInst * ginst;
  gboolean is_open;
  int i;
  int size;
  struct CollectData data;
  struct MonoImageSet * set;

  try
    {
      D.21557 = (long unsigned int) type_argc;
      D.21558 = D.21557 + 1;
      D.21559 = (unsigned int) D.21558;
      D.21560 = D.21559 * 8;
      size = (int) D.21560;
      i = 0;
      goto <D.18743>;
      <D.18742>:
      D.21561 = (long unsigned int) i;
      D.21562 = D.21561 * 8;
      D.21563 = type_argv + D.21562;
      D.21564 = *D.21563;
      D.21565 = mono_class_is_open_constructed_type (D.21564);
      if (D.21565 != 0) goto <D.18741>; else goto <D.21566>;
      <D.21566>:
      i = i + 1;
      <D.18743>:
      if (i < type_argc) goto <D.18742>; else goto <D.18741>;
      <D.18741>:
      D.21567 = i < type_argc;
      is_open = (gboolean) D.21567;
      D.21568 = (long unsigned int) size;
      ginst = __builtin_alloca (D.21568);
      memset (ginst, 0, 8);
      D.21569 = (unsigned char) is_open;
      D.21570 = (<unnamed-unsigned:1>) D.21569;
      ginst->is_open = D.21570;
      type_argc.89 = (unsigned int) type_argc;
      D.21572 = (<unnamed-unsigned:22>) type_argc.89;
      ginst->type_argc = D.21572;
      D.21573 = &ginst->type_argv;
      D.21557 = (long unsigned int) type_argc;
      D.21574 = D.21557 * 8;
      memcpy (D.21573, type_argv, D.21574);
      mono_loader_lock ();
      collect_data_init (&data);
      collect_ginst_images (ginst, &data);
      D.21575 = data.images;
      D.21576 = data.nimages;
      set = get_image_set (D.21575, D.21576);
      collect_data_free (&data);
      D.21577 = set->ginst_cache;
      ginst = monoeg_g_hash_table_lookup (D.21577, ginst);
      if (ginst == 0B) goto <D.21578>; else goto <D.21579>;
      <D.21578>:
      size.90 = (unsigned int) size;
      ginst = mono_image_set_alloc0 (set, size.90);
      next_generic_inst_id.91 = next_generic_inst_id;
      next_generic_inst_id.92 = next_generic_inst_id.91 + 1;
      next_generic_inst_id = next_generic_inst_id.92;
      next_generic_inst_id.91 = next_generic_inst_id;
      next_generic_inst_id.93 = (unsigned int) next_generic_inst_id.91;
      ginst->id = next_generic_inst_id.93;
      D.21569 = (unsigned char) is_open;
      D.21570 = (<unnamed-unsigned:1>) D.21569;
      ginst->is_open = D.21570;
      type_argc.89 = (unsigned int) type_argc;
      D.21572 = (<unnamed-unsigned:22>) type_argc.89;
      ginst->type_argc = D.21572;
      i = 0;
      goto <D.18745>;
      <D.18744>:
      D.21561 = (long unsigned int) i;
      D.21562 = D.21561 * 8;
      D.21563 = type_argv + D.21562;
      D.21564 = *D.21563;
      D.21584 = mono_metadata_type_dup (0B, D.21564);
      ginst->type_argv[i] = D.21584;
      i = i + 1;
      <D.18745>:
      if (i < type_argc) goto <D.18744>; else goto <D.18746>;
      <D.18746>:
      D.21577 = set->ginst_cache;
      monoeg_g_hash_table_insert_replace (D.21577, ginst, ginst, 0);
      <D.21579>:
      mono_loader_unlock ();
      D.21585 = ginst;
      return D.21585;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_metadata_lookup_generic_class (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  unsigned char D.21588;
  <unnamed-unsigned:1> D.21589;
  unsigned char D.21590;
  <unnamed-unsigned:1> D.21591;
  struct MonoImage * * D.21592;
  int D.21593;
  struct GHashTable * D.21594;
  struct MonoClass * D.21595;
  _Bool D.21596;
  long int D.21597;
  long int D.21598;
  struct MonoGenericClass * D.21603;
  struct MonoGenericContainer * D.21607;
  struct MonoGenericInst * D.21608;
  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.21588 = (unsigned char) is_dynamic;
      D.21589 = (<unnamed-unsigned:1>) D.21588;
      helper.is_dynamic = D.21589;
      D.21590 = (unsigned char) is_tb_open;
      D.21591 = (<unnamed-unsigned:1>) D.21590;
      helper.is_tb_open = D.21591;
      helper.cached_class = 0B;
      mono_loader_lock ();
      collect_data_init (&data);
      collect_gclass_images (&helper, &data);
      D.21592 = data.images;
      D.21593 = data.nimages;
      set = get_image_set (D.21592, D.21593);
      collect_data_free (&data);
      D.21594 = set->gclass_cache;
      gclass = monoeg_g_hash_table_lookup (D.21594, &helper);
      D.21595 = helper.cached_class;
      D.21596 = D.21595 != 0B;
      D.21597 = (long int) D.21596;
      D.21598 = __builtin_expect (D.21597, 0);
      if (D.21598 != 0) goto <D.21599>; else goto <D.21600>;
      <D.21599>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 2881, "!helper.cached_class");
      <D.21600>:
      if (gclass != 0B) goto <D.21601>; else goto <D.21602>;
      <D.21601>:
      mono_loader_unlock ();
      D.21603 = gclass;
      return D.21603;
      <D.21602>:
      if (is_dynamic != 0) goto <D.21604>; else goto <D.21605>;
      <D.21604>:
      {
        struct MonoDynamicGenericClass * dgclass;

        dgclass = mono_image_set_alloc0 (set, 88);
        gclass = &dgclass->generic_class;
        gclass->is_dynamic = 1;
      }
      goto <D.21606>;
      <D.21605>:
      gclass = mono_image_set_alloc0 (set, 48);
      <D.21606>:
      D.21590 = (unsigned char) is_tb_open;
      D.21591 = (<unnamed-unsigned:1>) D.21590;
      gclass->is_tb_open = D.21591;
      gclass->container_class = container_class;
      gclass->context.class_inst = inst;
      gclass->context.method_inst = 0B;
      gclass->owner = set;
      D.21607 = container_class->generic_container;
      D.21608 = D.21607->context.class_inst;
      if (D.21608 == inst) goto <D.21609>; else goto <D.21610>;
      <D.21609>:
      if (is_tb_open == 0) goto <D.21611>; else goto <D.21612>;
      <D.21611>:
      gclass->cached_class = container_class;
      <D.21612>:
      <D.21610>:
      D.21594 = set->gclass_cache;
      monoeg_g_hash_table_insert_replace (D.21594, gclass, gclass, 0);
      mono_loader_unlock ();
      D.21603 = gclass;
      return D.21603;
    }
  finally
    {
      helper = {CLOBBER};
      data = {CLOBBER};
    }
}


mono_metadata_is_type_builder_generic_type_definition (struct MonoClass * container_class, struct MonoGenericInst * inst, gboolean is_dynamic)
{
  long unsigned int D.21618;
  long unsigned int D.21619;
  <unnamed-signed:31> D.21621;
  int D.21622;
  <unnamed-unsigned:22> D.21623;
  int D.21624;
  gboolean D.21625;
  struct MonoGenericInst * D.21626;
  _Bool D.21627;
  struct MonoGenericContainer * container;

  container = container_class->generic_container;
  if (is_dynamic == 0) goto <D.21615>; else goto <D.21617>;
  <D.21617>:
  D.21618 = BIT_FIELD_REF <*container_class, 64, 256>;
  D.21619 = D.21618 & 128;
  if (D.21619 != 0) goto <D.21615>; else goto <D.21620>;
  <D.21620>:
  D.21621 = container->type_argc;
  D.21622 = (int) D.21621;
  D.21623 = inst->type_argc;
  D.21624 = (int) D.21623;
  if (D.21622 != D.21624) goto <D.21615>; else goto <D.21616>;
  <D.21615>:
  D.21625 = 0;
  return D.21625;
  <D.21616>:
  D.21626 = container->context.class_inst;
  D.21627 = D.21626 == inst;
  D.21625 = (gboolean) D.21627;
  return D.21625;
}


mono_metadata_inflate_generic_inst (struct MonoGenericInst * ginst, struct MonoGenericContext * context, struct MonoError * error)
{
  long unsigned int D.21629;
  long unsigned int D.21630;
  struct MonoGenericInst * D.21633;
  <unnamed-unsigned:22> D.21634;
  long unsigned int D.21635;
  long unsigned int D.21636;
  long unsigned int D.21637;
  long unsigned int D.21638;
  struct MonoType * * D.21639;
  struct MonoType * D.21640;
  struct MonoType * D.21641;
  int D.21642;
  int D.21644;
  struct MonoType * D.21645;
  struct MonoType * * type_argv;
  struct MonoGenericInst * nginst;
  int i;
  int count;
  void cleanup = <<< error >>>;

  nginst = 0B;
  count = 0;
  mono_error_init (error);
  D.21629 = BIT_FIELD_REF <*ginst, 64, 0>;
  D.21630 = D.21629 & 18014398509481984;
  if (D.21630 == 0) goto <D.21631>; else goto <D.21632>;
  <D.21631>:
  D.21633 = ginst;
  return D.21633;
  <D.21632>:
  D.21634 = ginst->type_argc;
  D.21635 = (long unsigned int) D.21634;
  D.21636 = D.21635 * 8;
  type_argv = monoeg_malloc0 (D.21636);
  i = 0;
  goto <D.18775>;
  <D.18774>:
  D.21637 = (long unsigned int) i;
  D.21638 = D.21637 * 8;
  D.21639 = type_argv + D.21638;
  D.21640 = ginst->type_argv[i];
  D.21641 = mono_class_inflate_generic_type_checked (D.21640, context, error);
  *D.21639 = D.21641;
  D.21642 = mono_error_ok (error);
  if (D.21642 == 0) goto cleanup; else goto <D.21643>;
  <D.21643>:
  count = count + 1;
  i = i + 1;
  <D.18775>:
  D.21634 = ginst->type_argc;
  D.21644 = (int) D.21634;
  if (D.21644 > i) goto <D.18774>; else goto <D.18776>;
  <D.18776>:
  D.21634 = ginst->type_argc;
  D.21644 = (int) D.21634;
  nginst = mono_metadata_get_generic_inst (D.21644, type_argv);
  cleanup:
  i = 0;
  goto <D.18778>;
  <D.18777>:
  D.21637 = (long unsigned int) i;
  D.21638 = D.21637 * 8;
  D.21639 = type_argv + D.21638;
  D.21645 = *D.21639;
  mono_metadata_free_type (D.21645);
  i = i + 1;
  <D.18778>:
  if (i < count) goto <D.18777>; else goto <D.18779>;
  <D.18779>:
  monoeg_g_free (type_argv);
  D.21633 = nginst;
  return D.21633;
}


mono_metadata_parse_generic_inst (struct MonoImage * m, struct MonoGenericContainer * container, int count, const char * ptr, const char * * rptr)
{
  long unsigned int D.21647;
  long unsigned int D.21648;
  const char * ptr.94;
  struct MonoGenericInst * D.21652;
  long unsigned int D.21653;
  long unsigned int D.21654;
  struct MonoType * * D.21655;
  struct MonoType * * type_argv;
  struct MonoGenericInst * ginst;
  int i;

  D.21647 = (long unsigned int) count;
  D.21648 = D.21647 * 8;
  type_argv = monoeg_malloc0 (D.21648);
  i = 0;
  goto <D.18792>;
  <D.18791>:
  {
    struct MonoType * t;

    ptr.94 = ptr;
    t = mono_metadata_parse_type_full (m, container, 0, 0, ptr.94, &ptr);
    if (t == 0B) goto <D.21650>; else goto <D.21651>;
    <D.21650>:
    monoeg_g_free (type_argv);
    D.21652 = 0B;
    return D.21652;
    <D.21651>:
    D.21653 = (long unsigned int) i;
    D.21654 = D.21653 * 8;
    D.21655 = type_argv + D.21654;
    *D.21655 = t;
  }
  i = i + 1;
  <D.18792>:
  if (i < count) goto <D.18791>; else goto <D.18793>;
  <D.18793>:
  if (rptr != 0B) goto <D.21656>; else goto <D.21657>;
  <D.21656>:
  ptr.94 = ptr;
  *rptr = ptr.94;
  <D.21657>:
  ginst = mono_metadata_get_generic_inst (count, type_argv);
  monoeg_g_free (type_argv);
  D.21652 = ginst;
  return D.21652;
}


mono_metadata_get_shared_type (struct MonoType * type)
{
  struct GHashTable * type_cache.95;
  struct MonoType * D.21662;
  unsigned char D.21663;
  int D.21664;
  struct MonoClass * D.21665;
  struct MonoType * D.21666;
  struct MonoType * D.21669;
  struct MonoType * cached;

  type_cache.95 = type_cache;
  cached = monoeg_g_hash_table_lookup (type_cache.95, type);
  if (cached != 0B) goto <D.21660>; else goto <D.21661>;
  <D.21660>:
  D.21662 = cached;
  return D.21662;
  <D.21661>:
  D.21663 = type->type;
  D.21664 = (int) D.21663;
  switch (D.21664) <default: <D.21672>, case 17: <D.18824>, case 18: <D.18823>>
  <D.18823>:
  <D.18824>:
  D.21665 = type->data.klass;
  D.21666 = &D.21665->byval_arg;
  if (D.21666 == type) goto <D.21667>; else goto <D.21668>;
  <D.21667>:
  D.21662 = type;
  return D.21662;
  <D.21668>:
  D.21665 = type->data.klass;
  D.21669 = &D.21665->this_arg;
  if (D.21669 == type) goto <D.21670>; else goto <D.21671>;
  <D.21670>:
  D.21662 = type;
  return D.21662;
  <D.21671>:
  goto <D.18825>;
  <D.21672>:
  <D.18825>:
  D.21662 = 0B;
  return D.21662;
}


mono_metadata_free_type (struct MonoType * type)
{
  unsigned char D.21678;
  int D.21679;
  struct MonoClass * D.21680;
  struct MonoType * D.21684;
  struct MonoType * D.21686;
  struct MonoType * D.21687;
  struct MonoMethodSignature * D.21688;
  struct MonoArrayType * D.21689;

  if (type >= &builtin_types) goto <D.21674>; else goto <D.21675>;
  <D.21674>:
  if (type < &MEM[(void *)&builtin_types + 544B]) goto <D.21676>; else goto <D.21677>;
  <D.21676>:
  return;
  <D.21677>:
  <D.21675>:
  D.21678 = type->type;
  D.21679 = (int) D.21678;
  switch (D.21679) <default: <D.21690>, case 14: <D.18875>, case 15: <D.18879>, case 17: <D.18878>, case 18: <D.18877>, case 20: <D.18881>, case 27: <D.18880>, case 28: <D.18874>>
  <D.18874>:
  <D.18875>:
  D.21680 = type->data.klass;
  if (D.21680 == 0B) goto <D.18876>; else goto <D.21681>;
  <D.21681>:
  <D.18877>:
  <D.18878>:
  D.21680 = type->data.klass;
  D.21684 = &D.21680->byval_arg;
  if (D.21684 == type) goto <D.21682>; else goto <D.21685>;
  <D.21685>:
  D.21680 = type->data.klass;
  D.21686 = &D.21680->this_arg;
  if (D.21686 == type) goto <D.21682>; else goto <D.21683>;
  <D.21682>:
  return;
  <D.21683>:
  goto <D.18876>;
  <D.18879>:
  D.21687 = type->data.type;
  mono_metadata_free_type (D.21687);
  goto <D.18876>;
  <D.18880>:
  D.21688 = type->data.method;
  mono_metadata_free_method_signature (D.21688);
  goto <D.18876>;
  <D.18881>:
  D.21689 = type->data.array;
  mono_metadata_free_array (D.21689);
  goto <D.18876>;
  <D.21690>:
  <D.18876>:
  monoeg_g_free (type);
}


mono_method_get_header_summary (struct MonoMethod * method, struct MonoMethodHeaderSummary * summary)
{
  long unsigned int D.21692;
  long unsigned int D.21693;
  short unsigned int D.21696;
  int D.21697;
  int D.21698;
  short unsigned int D.21700;
  unsigned int D.21701;
  unsigned int D.21702;
  int D.21704;
  gboolean D.21705;
  long unsigned int D.21706;
  unsigned int D.21711;
  <unnamed-unsigned:15> D.21712;
  int D.21713;
  _Bool D.21714;
  int D.21715;
  unsigned int D.21716;
  int D.21717;
  struct MonoClass * D.21718;
  struct MonoTableInfo * D.21719;
  int D.21720;
  int D.21721;
  _Bool D.21724;
  long int D.21725;
  long int D.21726;
  int D.21729;
  unsigned char D.21730;
  unsigned int D.21731;
  unsigned int D.21732;
  int D.21733;
  int D.21734;
  int idx;
  guint32 rva;
  struct MonoImage * img;
  const char * ptr;
  unsigned char flags;
  unsigned char format;
  guint16 fat_flags;

  goto <D.18912>;
  <D.18911>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.18912>:
  D.21692 = BIT_FIELD_REF <*method, 64, 256>;
  D.21693 = D.21692 & 4096;
  if (D.21693 != 0) goto <D.18911>; else goto <D.18913>;
  <D.18913>:
  summary->code_size = 0;
  summary->has_clauses = 0;
  D.21696 = method->flags;
  D.21697 = (int) D.21696;
  D.21698 = D.21697 & 1024;
  if (D.21698 != 0) goto <D.21694>; else goto <D.21699>;
  <D.21699>:
  D.21700 = method->iflags;
  D.21701 = (unsigned int) D.21700;
  D.21702 = D.21701 & 4099;
  if (D.21702 != 0) goto <D.21694>; else goto <D.21703>;
  <D.21703>:
  D.21696 = method->flags;
  D.21697 = (int) D.21696;
  D.21704 = D.21697 & 8192;
  if (D.21704 != 0) goto <D.21694>; else goto <D.21695>;
  <D.21694>:
  D.21705 = 0;
  return D.21705;
  <D.21695>:
  D.21692 = BIT_FIELD_REF <*method, 64, 256>;
  D.21706 = D.21692 & 1148;
  if (D.21706 != 0) goto <D.21707>; else goto <D.21708>;
  <D.21707>:
  {
    struct MonoMethodHeader * header;

    header = MEM[(struct MonoMethodWrapper *)method].header;
    if (header == 0B) goto <D.21709>; else goto <D.21710>;
    <D.21709>:
    D.21705 = 0;
    return D.21705;
    <D.21710>:
    D.21711 = header->code_size;
    summary->code_size = D.21711;
    D.21712 = header->num_clauses;
    D.21713 = (int) D.21712;
    D.21714 = D.21713 > 0;
    D.21715 = (int) D.21714;
    summary->has_clauses = D.21715;
    D.21705 = 1;
    return D.21705;
  }
  <D.21708>:
  D.21716 = method->token;
  D.21717 = (int) D.21716;
  idx = D.21717 & 16777215;
  D.21718 = method->klass;
  img = D.21718->image;
  D.21719 = &img->tables[6];
  D.21720 = idx + -1;
  rva = mono_metadata_decode_row_col (D.21719, D.21720, 0);
  D.21721 = mono_verifier_verify_method_header (img, rva, 0B);
  if (D.21721 == 0) goto <D.21722>; else goto <D.21723>;
  <D.21722>:
  D.21705 = 0;
  return D.21705;
  <D.21723>:
  ptr = mono_image_rva_map (img, rva);
  D.21724 = ptr == 0B;
  D.21725 = (long int) D.21724;
  D.21726 = __builtin_expect (D.21725, 0);
  if (D.21726 != 0) goto <D.21727>; else goto <D.21728>;
  <D.21727>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 3408, "ptr");
  <D.21728>:
  flags = MEM[(const unsigned char *)ptr];
  format = flags & 3;
  D.21729 = (int) format;
  switch (D.21729) <default: <D.18918>, case 2: <D.18915>, case 3: <D.18917>>
  <D.18915>:
  ptr = ptr + 1;
  D.21730 = flags >> 2;
  D.21731 = (unsigned int) D.21730;
  summary->code_size = D.21731;
  goto <D.18916>;
  <D.18917>:
  fat_flags = MEM[(const guint16 *)ptr];
  ptr = ptr + 4;
  D.21732 = MEM[(const guint32 *)ptr];
  summary->code_size = D.21732;
  D.21733 = (int) fat_flags;
  D.21734 = D.21733 & 8;
  if (D.21734 != 0) goto <D.21735>; else goto <D.21736>;
  <D.21735>:
  summary->has_clauses = 1;
  <D.21736>:
  goto <D.18916>;
  <D.18918>:
  D.21705 = 0;
  return D.21705;
  <D.18916>:
  D.21705 = 1;
  return D.21705;
}


mono_metadata_parse_mh_full (struct MonoImage * m, struct MonoGenericContainer * container, const char * ptr)
{
  struct MonoMethodHeader * D.21740;
  int D.21741;
  unsigned char D.21742;
  unsigned int D.21743;
  short unsigned int D.21744;
  int D.21745;
  short unsigned int D.21746;
  int D.21747;
  int D.21748;
  int D.21752;
  sizetype D.21754;
  unsigned int D.21757;
  unsigned int D.21758;
  <unnamed-unsigned:24> D.21761;
  int D.21762;
  unsigned int D.21764;
  int D.21765;
  const char * locals_ptr.96;
  const char * locals_ptr.97;
  unsigned int D.21774;
  char D.21775;
  const char * locals_ptr.98;
  unsigned int D.21779;
  long unsigned int D.21780;
  int num_clauses.99;
  long unsigned int D.21782;
  long unsigned int D.21783;
  long unsigned int D.21784;
  long unsigned int D.21785;
  long unsigned int D.21786;
  short unsigned int D.21787;
  struct MonoType * D.21788;
  struct MonoType * D.21789;
  long unsigned int D.21793;
  long unsigned int D.21794;
  short unsigned int D.21795;
  <unnamed-unsigned:15> D.21796;
  unsigned char D.21797;
  <unnamed-unsigned:1> D.21798;
  short unsigned int D.21801;
  int D.21802;
  long unsigned int D.21803;
  short unsigned int D.21804;
  <unnamed-unsigned:15> D.21805;
  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.21738>; else goto <D.21739>;
      <D.21738>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "metadata.c", 3459, "ptr != NULL");
      D.21740 = 0B;
      return D.21740;
      <D.21739>:
      D.21741 = (int) format;
      switch (D.21741) <default: <D.18941>, case 2: <D.18938>, case 3: <D.18939>>
      <D.18938>:
      mh = monoeg_malloc0 (32);
      ptr = ptr + 1;
      mh->max_stack = 8;
      mh->is_transient = 1;
      local_var_sig_tok = 0;
      D.21742 = flags >> 2;
      D.21743 = (unsigned int) D.21742;
      mh->code_size = D.21743;
      mh->code = ptr;
      D.21740 = mh;
      return D.21740;
      <D.18939>:
      fat_flags = MEM[(const guint16 *)ptr];
      ptr = ptr + 2;
      D.21744 = fat_flags >> 12;
      D.21745 = (int) D.21744;
      hsize = D.21745 & 15;
      D.21746 = MEM[(const guint16 *)ptr];
      max_stack = (guint32) D.21746;
      ptr = ptr + 2;
      code_size = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      local_var_sig_tok = MEM[(const guint32 *)ptr];
      ptr = ptr + 4;
      D.21747 = (int) fat_flags;
      D.21748 = D.21747 & 16;
      if (D.21748 != 0) goto <D.21749>; else goto <D.21750>;
      <D.21749>:
      init_locals = 1;
      goto <D.21751>;
      <D.21750>:
      init_locals = 0;
      <D.21751>:
      code = ptr;
      D.21747 = (int) fat_flags;
      D.21752 = D.21747 & 8;
      if (D.21752 == 0) goto <D.18940>; else goto <D.21753>;
      <D.21753>:
      D.21754 = (sizetype) code_size;
      ptr = code + D.21754;
      goto <D.18940>;
      <D.18941>:
      D.21740 = 0B;
      return D.21740;
      <D.18940>:
      if (local_var_sig_tok != 0) goto <D.21755>; else goto <D.21756>;
      <D.21755>:
      {
        int idx;

        D.21757 = local_var_sig_tok & 16777215;
        D.21758 = D.21757 + 4294967295;
        idx = (int) D.21758;
        D.21761 = t->rows;
        D.21762 = (int) D.21761;
        if (D.21762 <= idx) goto <D.21759>; else goto <D.21763>;
        <D.21763>:
        if (idx < 0) goto <D.21759>; else goto <D.21760>;
        <D.21759>:
        D.21740 = 0B;
        return D.21740;
        <D.21760>:
        mono_metadata_decode_row (t, idx, &cols, 1);
        D.21764 = cols[0];
        D.21765 = mono_verifier_verify_standalone_signature (m, D.21764, 0B);
        if (D.21765 == 0) goto <D.21766>; else goto <D.21767>;
        <D.21766>:
        D.21740 = 0B;
        return D.21740;
        <D.21767>:
      }
      <D.21756>:
      D.21747 = (int) fat_flags;
      D.21752 = D.21747 & 8;
      if (D.21752 != 0) goto <D.21768>; else goto <D.21769>;
      <D.21768>:
      clauses = parse_section_data (m, &num_clauses, ptr);
      <D.21769>:
      if (local_var_sig_tok != 0) goto <D.21770>; else goto <D.21771>;
      <D.21770>:
      {
        const char * locals_ptr;
        int len;
        int i;
        int bsize;

        try
          {
            len = 0;
            D.21764 = cols[0];
            locals_ptr.96 = mono_metadata_blob_heap (m, D.21764);
            locals_ptr = locals_ptr.96;
            locals_ptr.97 = locals_ptr;
            D.21774 = mono_metadata_decode_blob_size (locals_ptr.97, &locals_ptr);
            bsize = (int) D.21774;
            locals_ptr.97 = locals_ptr;
            D.21775 = *locals_ptr.97;
            if (D.21775 != 7) goto <D.21776>; else goto <D.21777>;
            <D.21776>:
            monoeg_g_log (0B, 16, "wrong signature for locals blob");
            <D.21777>:
            locals_ptr.97 = locals_ptr;
            locals_ptr.98 = locals_ptr.97 + 1;
            locals_ptr = locals_ptr.98;
            locals_ptr.97 = locals_ptr;
            D.21779 = mono_metadata_decode_value (locals_ptr.97, &locals_ptr);
            len = (int) D.21779;
            D.21780 = (long unsigned int) len;
            num_clauses.99 = num_clauses;
            D.21782 = (long unsigned int) num_clauses.99;
            D.21783 = D.21782 * 4;
            D.21784 = D.21780 + D.21783;
            D.21785 = D.21784 + 4;
            D.21786 = D.21785 * 8;
            mh = monoeg_malloc0 (D.21786);
            D.21787 = (short unsigned int) len;
            mh->num_locals = D.21787;
            i = 0;
            goto <D.18948>;
            <D.18947>:
            locals_ptr.97 = locals_ptr;
            D.21788 = mono_metadata_parse_type_internal (m, container, 2, 0, 1, locals_ptr.97, &locals_ptr);
            mh->locals[i] = D.21788;
            D.21789 = mh->locals[i];
            if (D.21789 == 0B) goto <D.21790>; else goto <D.21791>;
            <D.21790>:
            monoeg_g_free (clauses);
            monoeg_g_free (mh);
            D.21740 = 0B;
            return D.21740;
            <D.21791>:
            i = i + 1;
            <D.18948>:
            if (i < len) goto <D.18947>; else goto <D.18949>;
            <D.18949>:
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      goto <D.21792>;
      <D.21771>:
      num_clauses.99 = num_clauses;
      D.21782 = (long unsigned int) num_clauses.99;
      D.21793 = D.21782 + 1;
      D.21794 = D.21793 * 32;
      mh = monoeg_malloc0 (D.21794);
      <D.21792>:
      mh->code = code;
      mh->code_size = code_size;
      D.21795 = (short unsigned int) max_stack;
      D.21796 = (<unnamed-unsigned:15>) D.21795;
      mh->max_stack = D.21796;
      mh->is_transient = 1;
      D.21797 = (unsigned char) init_locals;
      D.21798 = (<unnamed-unsigned:1>) D.21797;
      mh->init_locals = D.21798;
      if (clauses != 0B) goto <D.21799>; else goto <D.21800>;
      <D.21799>:
      {
        struct MonoExceptionClause * clausesp;

        D.21801 = mh->num_locals;
        D.21802 = (int) D.21801;
        clausesp = &mh->locals[D.21802];
        num_clauses.99 = num_clauses;
        D.21782 = (long unsigned int) num_clauses.99;
        D.21803 = D.21782 * 32;
        memcpy (clausesp, clauses, D.21803);
        monoeg_g_free (clauses);
        mh->clauses = clausesp;
        num_clauses.99 = num_clauses;
        D.21804 = (short unsigned int) num_clauses.99;
        D.21805 = (<unnamed-unsigned:15>) D.21804;
        mh->num_clauses = D.21805;
      }
      <D.21800>:
      D.21740 = mh;
      return D.21740;
    }
  finally
    {
      num_clauses = {CLOBBER};
      cols = {CLOBBER};
    }
}


parse_section_data (struct MonoImage * m, int * num_clauses, const unsigned char * ptr)
{
  int D.21810;
  const unsigned char * D.21813;
  unsigned char D.21814;
  int D.21815;
  int D.21816;
  const unsigned char * D.21817;
  unsigned char D.21818;
  int D.21819;
  int D.21820;
  int D.21821;
  unsigned char D.21822;
  int D.21823;
  int D.21824;
  int D.21826;
  int iftmp.100;
  unsigned int D.21832;
  unsigned int D.21834;
  int D.21835;
  long unsigned int D.21836;
  long unsigned int D.21837;
  long unsigned int D.21838;
  long unsigned int D.21839;
  unsigned int D.21842;
  unsigned int D.21843;
  unsigned int D.21844;
  unsigned int D.21845;
  unsigned int D.21846;
  short unsigned int D.21848;
  unsigned int D.21849;
  const guint16 * D.21850;
  short unsigned int D.21851;
  unsigned int D.21852;
  const unsigned char * D.21853;
  unsigned char D.21854;
  unsigned int D.21855;
  const guint16 * D.21856;
  short unsigned int D.21857;
  unsigned int D.21858;
  const unsigned char * D.21859;
  unsigned char D.21860;
  unsigned int D.21861;
  unsigned int D.21862;
  struct MonoClass * iftmp.101;
  signed char sect_data_flags.102;
  unsigned int D.21876;
  sizetype D.21877;
  struct MonoExceptionClause * D.21879;
  unsigned char sect_data_flags;
  const unsigned char * sptr;
  int is_fat;
  guint32 sect_data_len;
  struct MonoExceptionClause * clauses;

  clauses = 0B;
  <D.18899>:
  ptr = dword_align (ptr);
  sptr = ptr;
  sect_data_flags = *ptr;
  ptr = ptr + 1;
  D.21810 = (int) sect_data_flags;
  is_fat = D.21810 & 64;
  if (is_fat != 0) goto <D.21811>; else goto <D.21812>;
  <D.21811>:
  D.21813 = ptr + 2;
  D.21814 = *D.21813;
  D.21815 = (int) D.21814;
  D.21816 = D.21815 << 16;
  D.21817 = ptr + 1;
  D.21818 = *D.21817;
  D.21819 = (int) D.21818;
  D.21820 = D.21819 << 8;
  D.21821 = D.21816 | D.21820;
  D.21822 = *ptr;
  D.21823 = (int) D.21822;
  D.21824 = D.21821 | D.21823;
  sect_data_len = (guint32) D.21824;
  ptr = ptr + 3;
  goto <D.21825>;
  <D.21812>:
  D.21822 = *ptr;
  sect_data_len = (guint32) D.21822;
  ptr = ptr + 1;
  <D.21825>:
  D.21810 = (int) sect_data_flags;
  D.21826 = D.21810 & 1;
  if (D.21826 != 0) goto <D.21827>; else goto <D.21828>;
  <D.21827>:
  {
    const unsigned char * p;
    int i;

    p = dword_align (ptr);
    if (is_fat != 0) goto <D.21830>; else goto <D.21831>;
    <D.21830>:
    D.21832 = sect_data_len / 24;
    iftmp.100 = (int) D.21832;
    goto <D.21833>;
    <D.21831>:
    D.21834 = sect_data_len / 12;
    iftmp.100 = (int) D.21834;
    <D.21833>:
    *num_clauses = iftmp.100;
    D.21835 = *num_clauses;
    D.21836 = (long unsigned int) D.21835;
    D.21837 = D.21836 * 32;
    clauses = monoeg_malloc0 (D.21837);
    i = 0;
    goto <D.18897>;
    <D.18896>:
    {
      struct MonoExceptionClause * ec;
      guint32 tof_value;

      D.21838 = (long unsigned int) i;
      D.21839 = D.21838 * 32;
      ec = clauses + D.21839;
      if (is_fat != 0) goto <D.21840>; else goto <D.21841>;
      <D.21840>:
      D.21842 = MEM[(const guint32 *)p];
      ec->flags = D.21842;
      D.21843 = MEM[(const guint32 *)p + 4B];
      ec->try_offset = D.21843;
      D.21844 = MEM[(const guint32 *)p + 8B];
      ec->try_len = D.21844;
      D.21845 = MEM[(const guint32 *)p + 12B];
      ec->handler_offset = D.21845;
      D.21846 = MEM[(const guint32 *)p + 16B];
      ec->handler_len = D.21846;
      tof_value = MEM[(const guint32 *)p + 20B];
      p = p + 24;
      goto <D.21847>;
      <D.21841>:
      D.21848 = MEM[(const guint16 *)p];
      D.21849 = (unsigned int) D.21848;
      ec->flags = D.21849;
      D.21850 = p + 2;
      D.21851 = *D.21850;
      D.21852 = (unsigned int) D.21851;
      ec->try_offset = D.21852;
      D.21853 = p + 4;
      D.21854 = *D.21853;
      D.21855 = (unsigned int) D.21854;
      ec->try_len = D.21855;
      D.21856 = p + 5;
      D.21857 = *D.21856;
      D.21858 = (unsigned int) D.21857;
      ec->handler_offset = D.21858;
      D.21859 = p + 7;
      D.21860 = *D.21859;
      D.21861 = (unsigned int) D.21860;
      ec->handler_len = D.21861;
      tof_value = MEM[(const guint32 *)p + 8B];
      p = p + 12;
      <D.21847>:
      D.21862 = ec->flags;
      if (D.21862 == 1) goto <D.21863>; else goto <D.21864>;
      <D.21863>:
      ec->data.filter_offset = tof_value;
      goto <D.21865>;
      <D.21864>:
      D.21862 = ec->flags;
      if (D.21862 == 0) goto <D.21866>; else goto <D.21867>;
      <D.21866>:
      if (tof_value != 0) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      iftmp.101 = mono_class_get (m, tof_value);
      goto <D.21871>;
      <D.21870>:
      iftmp.101 = 0B;
      <D.21871>:
      ec->data.catch_class = iftmp.101;
      goto <D.21872>;
      <D.21867>:
      ec->data.catch_class = 0B;
      <D.21872>:
      <D.21865>:
    }
    i = i + 1;
    <D.18897>:
    D.21835 = *num_clauses;
    if (D.21835 > i) goto <D.18896>; else goto <D.18898>;
    <D.18898>:
  }
  <D.21828>:
  sect_data_flags.102 = (signed char) sect_data_flags;
  if (sect_data_flags.102 < 0) goto <D.21874>; else goto <D.21875>;
  <D.21874>:
  D.21876 = sect_data_len + 4294967292;
  D.21877 = (sizetype) D.21876;
  ptr = ptr + D.21877;
  goto <D.21878>;
  <D.21875>:
  D.21879 = clauses;
  return D.21879;
  <D.21878>:
  goto <D.18899>;
}


dword_align (const unsigned char * ptr)
{
  const unsigned char * D.21881;
  const unsigned char * D.21882;
  long unsigned int D.21883;
  long unsigned int D.21884;

  D.21882 = ptr + 3;
  D.21883 = (long unsigned int) D.21882;
  D.21884 = D.21883 & 18446744073709551612;
  D.21881 = (const unsigned char *) D.21884;
  return D.21881;
}


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

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


mono_metadata_free_mh (struct MonoMethodHeader * mh)
{
  long unsigned int D.21888;
  long unsigned int D.21889;
  struct MonoType * D.21892;
  short unsigned int D.21893;
  int D.21894;
  int i;

  D.21888 = BIT_FIELD_REF <*mh, 64, 64>;
  D.21889 = D.21888 & 140737488355328;
  if (D.21889 != 0) goto <D.21890>; else goto <D.21891>;
  <D.21890>:
  i = 0;
  goto <D.18961>;
  <D.18960>:
  D.21892 = mh->locals[i];
  mono_metadata_free_type (D.21892);
  i = i + 1;
  <D.18961>:
  D.21893 = mh->num_locals;
  D.21894 = (int) D.21893;
  if (D.21894 > i) goto <D.18960>; else goto <D.18962>;
  <D.18962>:
  monoeg_g_free (mh);
  <D.21891>:
}


mono_method_header_get_code (struct MonoMethodHeader * header, guint32 * code_size, guint32 * max_stack)
{
  unsigned int D.21897;
  <unnamed-unsigned:15> D.21900;
  unsigned int D.21901;
  const unsigned char * D.21902;

  if (code_size != 0B) goto <D.21895>; else goto <D.21896>;
  <D.21895>:
  D.21897 = header->code_size;
  *code_size = D.21897;
  <D.21896>:
  if (max_stack != 0B) goto <D.21898>; else goto <D.21899>;
  <D.21898>:
  D.21900 = header->max_stack;
  D.21901 = (unsigned int) D.21900;
  *max_stack = D.21901;
  <D.21899>:
  D.21902 = header->code;
  return D.21902;
}


mono_method_header_get_locals (struct MonoMethodHeader * header, guint32 * num_locals, gboolean * init_locals)
{
  short unsigned int D.21906;
  unsigned int D.21907;
  <unnamed-unsigned:1> D.21910;
  int D.21911;
  struct MonoType * * D.21912;

  if (num_locals != 0B) goto <D.21904>; else goto <D.21905>;
  <D.21904>:
  D.21906 = header->num_locals;
  D.21907 = (unsigned int) D.21906;
  *num_locals = D.21907;
  <D.21905>:
  if (init_locals != 0B) goto <D.21908>; else goto <D.21909>;
  <D.21908>:
  D.21910 = header->init_locals;
  D.21911 = (int) D.21910;
  *init_locals = D.21911;
  <D.21909>:
  D.21912 = &header->locals;
  return D.21912;
}


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

  D.21915 = header->num_clauses;
  D.21914 = (int) D.21915;
  return D.21914;
}


mono_method_header_get_clauses (struct MonoMethodHeader * header, struct MonoMethod * method, void * * iter, struct MonoExceptionClause * clause)
{
  long unsigned int D.21920;
  long unsigned int D.21921;
  int D.21922;
  void * D.21923;
  struct MonoExceptionClause * D.21926;
  <unnamed-unsigned:15> D.21927;
  long unsigned int D.21928;
  long unsigned int D.21929;
  struct MonoExceptionClause * D.21930;
  struct MonoExceptionClause * sc;

  if (iter == 0B) goto <D.21917>; else goto <D.21919>;
  <D.21919>:
  D.21920 = BIT_FIELD_REF <*header, 64, 64>;
  D.21921 = D.21920 & 9223090561878065152;
  if (D.21921 == 0) goto <D.21917>; else goto <D.21918>;
  <D.21917>:
  D.21922 = 0;
  return D.21922;
  <D.21918>:
  D.21923 = *iter;
  if (D.21923 == 0B) goto <D.21924>; else goto <D.21925>;
  <D.21924>:
  sc = header->clauses;
  *iter = sc;
  *clause = *sc;
  D.21922 = 1;
  return D.21922;
  <D.21925>:
  sc = *iter;
  sc = sc + 32;
  D.21926 = header->clauses;
  D.21927 = header->num_clauses;
  D.21928 = (long unsigned int) D.21927;
  D.21929 = D.21928 * 32;
  D.21930 = D.21926 + D.21929;
  if (D.21930 > sc) goto <D.21931>; else goto <D.21932>;
  <D.21931>:
  *iter = sc;
  *clause = *sc;
  D.21922 = 1;
  return D.21922;
  <D.21932>:
  D.21922 = 0;
  return D.21922;
}


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

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


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

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


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

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


mono_metadata_typedef_from_field (struct MonoImage * meta, guint32 index)
{
  const char * D.21940;
  uint32_t D.21943;
  int index.103;
  int D.21945;
  long unsigned int D.21946;
  long unsigned int D.21947;
  int D.21950;
  unsigned int D.21951;
  int D.21952;
  <unnamed-unsigned:24> D.21953;
  long unsigned int D.21954;
  unsigned char D.21955;
  long unsigned int D.21956;
  void * D.21957;
  unsigned int D.21960;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21940 = tdef->base;
      if (D.21940 == 0B) goto <D.21941>; else goto <D.21942>;
      <D.21941>:
      D.21943 = 0;
      return D.21943;
      <D.21942>:
      index.103 = (int) index;
      D.21945 = index.103 & 16777215;
      loc.idx = D.21945;
      loc.col_idx = 4;
      loc.t = tdef;
      D.21946 = BIT_FIELD_REF <*meta, 64, 192>;
      D.21947 = D.21946 & 137438953472;
      if (D.21947 != 0) goto <D.21948>; else goto <D.21949>;
      <D.21948>:
      D.21950 = loc.idx;
      D.21951 = search_ptr_table (meta, 3, D.21950);
      D.21952 = (int) D.21951;
      loc.idx = D.21952;
      <D.21949>:
      D.21940 = tdef->base;
      D.21953 = tdef->rows;
      D.21954 = (long unsigned int) D.21953;
      D.21955 = tdef->row_size;
      D.21956 = (long unsigned int) D.21955;
      D.21957 = mono_binary_search (&loc, D.21940, D.21954, D.21956, typedef_locator);
      if (D.21957 == 0B) goto <D.21958>; else goto <D.21959>;
      <D.21958>:
      D.21943 = 0;
      return D.21943;
      <D.21959>:
      D.21960 = loc.result;
      D.21943 = D.21960 + 1;
      return D.21943;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


typedef_locator (const void * a, const void * b)
{
  long int bb.104;
  struct MonoTableInfo * D.21964;
  const char * D.21965;
  long int D.21966;
  long int D.21967;
  unsigned char D.21968;
  long int D.21969;
  long int D.21970;
  int D.21971;
  unsigned int D.21972;
  int D.21973;
  unsigned int D.21974;
  int D.21977;
  int D.21978;
  <unnamed-unsigned:24> D.21979;
  int D.21980;
  unsigned int typedef_index.105;
  struct locator_t * loc;
  const char * bb;
  int typedef_index;
  guint32 col;
  guint32 col_next;

  loc = a;
  bb = b;
  bb.104 = (long int) bb;
  D.21964 = loc->t;
  D.21965 = D.21964->base;
  D.21966 = (long int) D.21965;
  D.21967 = bb.104 - D.21966;
  D.21964 = loc->t;
  D.21968 = D.21964->row_size;
  D.21969 = (long int) D.21968;
  D.21970 = D.21967 / D.21969;
  typedef_index = (int) D.21970;
  D.21964 = loc->t;
  D.21971 = loc->col_idx;
  D.21972 = (unsigned int) D.21971;
  col = mono_metadata_decode_row_col (D.21964, typedef_index, D.21972);
  D.21973 = loc->idx;
  D.21974 = (unsigned int) D.21973;
  if (D.21974 < col) goto <D.21975>; else goto <D.21976>;
  <D.21975>:
  D.21977 = -1;
  return D.21977;
  <D.21976>:
  D.21978 = typedef_index + 1;
  D.21964 = loc->t;
  D.21979 = D.21964->rows;
  D.21980 = (int) D.21979;
  if (D.21978 < D.21980) goto <D.21981>; else goto <D.21982>;
  <D.21981>:
  D.21964 = loc->t;
  D.21978 = typedef_index + 1;
  D.21971 = loc->col_idx;
  D.21972 = (unsigned int) D.21971;
  col_next = mono_metadata_decode_row_col (D.21964, D.21978, D.21972);
  D.21973 = loc->idx;
  D.21974 = (unsigned int) D.21973;
  if (D.21974 >= col_next) goto <D.21983>; else goto <D.21984>;
  <D.21983>:
  D.21977 = 1;
  return D.21977;
  <D.21984>:
  if (col == col_next) goto <D.21985>; else goto <D.21986>;
  <D.21985>:
  D.21977 = 1;
  return D.21977;
  <D.21986>:
  <D.21982>:
  typedef_index.105 = (unsigned int) typedef_index;
  loc->result = typedef_index.105;
  D.21977 = 0;
  return D.21977;
}


search_ptr_table (struct MonoImage * image, int table, int idx)
{
  unsigned int D.21989;
  unsigned int idx.106;
  <unnamed-unsigned:24> D.21992;
  int D.21993;
  guint32 D.21996;
  int D.21997;
  struct MonoTableInfo * ptrdef;
  int i;

  ptrdef = &image->tables[table];
  i = 0;
  goto <D.19043>;
  <D.19042>:
  D.21989 = mono_metadata_decode_row_col (ptrdef, i, 0);
  idx.106 = (unsigned int) idx;
  if (D.21989 == idx.106) goto <D.19041>; else goto <D.21991>;
  <D.21991>:
  i = i + 1;
  <D.19043>:
  D.21992 = ptrdef->rows;
  D.21993 = (int) D.21992;
  if (D.21993 > i) goto <D.19042>; else goto <D.19041>;
  <D.19041>:
  D.21992 = ptrdef->rows;
  D.21993 = (int) D.21992;
  if (D.21993 > i) goto <D.21994>; else goto <D.21995>;
  <D.21994>:
  D.21997 = i + 1;
  D.21996 = (guint32) D.21997;
  return D.21996;
  <D.21995>:
  D.21996 = (guint32) idx;
  return D.21996;
}


mono_metadata_typedef_from_method (struct MonoImage * meta, guint32 index)
{
  const char * D.21999;
  uint32_t D.22002;
  int index.107;
  int D.22004;
  long unsigned int D.22005;
  long unsigned int D.22006;
  int D.22009;
  unsigned int D.22010;
  int D.22011;
  <unnamed-unsigned:24> D.22012;
  long unsigned int D.22013;
  unsigned char D.22014;
  long unsigned int D.22015;
  void * D.22016;
  unsigned int D.22019;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[2];
      D.21999 = tdef->base;
      if (D.21999 == 0B) goto <D.22000>; else goto <D.22001>;
      <D.22000>:
      D.22002 = 0;
      return D.22002;
      <D.22001>:
      index.107 = (int) index;
      D.22004 = index.107 & 16777215;
      loc.idx = D.22004;
      loc.col_idx = 5;
      loc.t = tdef;
      D.22005 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22006 = D.22005 & 137438953472;
      if (D.22006 != 0) goto <D.22007>; else goto <D.22008>;
      <D.22007>:
      D.22009 = loc.idx;
      D.22010 = search_ptr_table (meta, 5, D.22009);
      D.22011 = (int) D.22010;
      loc.idx = D.22011;
      <D.22008>:
      D.21999 = tdef->base;
      D.22012 = tdef->rows;
      D.22013 = (long unsigned int) D.22012;
      D.22014 = tdef->row_size;
      D.22015 = (long unsigned int) D.22014;
      D.22016 = mono_binary_search (&loc, D.21999, D.22013, D.22015, typedef_locator);
      if (D.22016 == 0B) goto <D.22017>; else goto <D.22018>;
      <D.22017>:
      D.22002 = 0;
      return D.22002;
      <D.22018>:
      D.22019 = loc.result;
      D.22002 = D.22019 + 1;
      return D.22002;
    }
  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.22022;
  gboolean D.22025;
  int index.108;
  int D.22027;
  <unnamed-unsigned:24> D.22028;
  long unsigned int D.22029;
  unsigned char D.22030;
  long unsigned int D.22031;
  void * D.22032;
  int D.22035;
  unsigned int D.22036;
  unsigned int D.22037;
  int D.22038;
  unsigned int D.22039;
  int pos.109;
  unsigned int D.22042;
  unsigned int D.22043;
  unsigned int D.22045;
  unsigned int D.22048;
  long unsigned int D.22049;
  long unsigned int D.22050;
  unsigned int D.22052;
  unsigned int D.22054;
  unsigned int D.22055;
  struct MonoClass * * D.22058;
  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.22022 = tdef->base;
      if (D.22022 == 0B) goto <D.22023>; else goto <D.22024>;
      <D.22023>:
      D.22025 = 1;
      return D.22025;
      <D.22024>:
      index.108 = (int) index;
      D.22027 = index.108 & 16777215;
      loc.idx = D.22027;
      loc.col_idx = 0;
      loc.t = tdef;
      D.22022 = tdef->base;
      D.22028 = tdef->rows;
      D.22029 = (long unsigned int) D.22028;
      D.22030 = tdef->row_size;
      D.22031 = (long unsigned int) D.22030;
      D.22032 = mono_binary_search (&loc, D.22022, D.22029, D.22031, table_locator);
      if (D.22032 == 0B) goto <D.22033>; else goto <D.22034>;
      <D.22033>:
      D.22025 = 1;
      return D.22025;
      <D.22034>:
      start = loc.result;
      goto <D.19072>;
      <D.19071>:
      D.22035 = loc.idx;
      D.22036 = (unsigned int) D.22035;
      D.22037 = start + 4294967295;
      D.22038 = (int) D.22037;
      D.22039 = mono_metadata_decode_row_col (tdef, D.22038, 0);
      if (D.22036 == D.22039) goto <D.22040>; else goto <D.19070>;
      <D.22040>:
      start = start + 4294967295;
      <D.19072>:
      if (start != 0) goto <D.19071>; else goto <D.19070>;
      <D.19070>:
      pos = start;
      goto <D.19075>;
      <D.19074>:
      pos.109 = (int) pos;
      mono_metadata_decode_row (tdef, pos.109, &cols, 2);
      D.22042 = cols[0];
      D.22035 = loc.idx;
      D.22043 = (unsigned int) D.22035;
      if (D.22042 != D.22043) goto <D.19073>; else goto <D.22044>;
      <D.22044>:
      pos = pos + 1;
      <D.19075>:
      D.22028 = tdef->rows;
      D.22045 = (unsigned int) D.22028;
      if (D.22045 > pos) goto <D.19074>; else goto <D.19073>;
      <D.19073>:
      if (heap_alloc_result != 0) goto <D.22046>; else goto <D.22047>;
      <D.22046>:
      D.22048 = pos - start;
      D.22049 = (long unsigned int) D.22048;
      D.22050 = D.22049 * 8;
      result = monoeg_malloc0 (D.22050);
      goto <D.22051>;
      <D.22047>:
      D.22048 = pos - start;
      D.22052 = D.22048 * 8;
      result = mono_image_alloc0 (meta, D.22052);
      <D.22051>:
      pos = start;
      goto <D.19079>;
      <D.19078>:
      {
        struct MonoClass * iface;

        pos.109 = (int) pos;
        mono_metadata_decode_row (tdef, pos.109, &cols, 2);
        D.22042 = cols[0];
        D.22035 = loc.idx;
        D.22043 = (unsigned int) D.22035;
        if (D.22042 != D.22043) goto <D.19077>; else goto <D.22053>;
        <D.22053>:
        D.22054 = cols[1];
        D.22055 = mono_metadata_token_from_dor (D.22054);
        iface = mono_class_get_full (meta, D.22055, context);
        if (iface == 0B) goto <D.22056>; else goto <D.22057>;
        <D.22056>:
        D.22025 = 0;
        return D.22025;
        <D.22057>:
        D.22048 = pos - start;
        D.22049 = (long unsigned int) D.22048;
        D.22050 = D.22049 * 8;
        D.22058 = result + D.22050;
        *D.22058 = iface;
        pos = pos + 1;
      }
      <D.19079>:
      D.22028 = tdef->rows;
      D.22045 = (unsigned int) D.22028;
      if (D.22045 > pos) goto <D.19078>; else goto <D.19077>;
      <D.19077>:
      D.22048 = pos - start;
      *count = D.22048;
      *interfaces = result;
      D.22025 = 1;
      return D.22025;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


table_locator (const void * a, const void * b)
{
  long int bb.110;
  struct MonoTableInfo * D.22062;
  const char * D.22063;
  long int D.22064;
  long int D.22065;
  unsigned char D.22066;
  long int D.22067;
  long int D.22068;
  int table_index.111;
  int D.22070;
  unsigned int D.22071;
  int D.22072;
  unsigned int D.22073;
  int D.22076;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.110 = (long int) bb;
  D.22062 = loc->t;
  D.22063 = D.22062->base;
  D.22064 = (long int) D.22063;
  D.22065 = bb.110 - D.22064;
  D.22062 = loc->t;
  D.22066 = D.22062->row_size;
  D.22067 = (long int) D.22066;
  D.22068 = D.22065 / D.22067;
  table_index = (guint32) D.22068;
  D.22062 = loc->t;
  table_index.111 = (int) table_index;
  D.22070 = loc->col_idx;
  D.22071 = (unsigned int) D.22070;
  col = mono_metadata_decode_row_col (D.22062, table_index.111, D.22071);
  D.22072 = loc->idx;
  D.22073 = (unsigned int) D.22072;
  if (D.22073 == col) goto <D.22074>; else goto <D.22075>;
  <D.22074>:
  loc->result = table_index;
  D.22076 = 0;
  return D.22076;
  <D.22075>:
  D.22072 = loc->idx;
  D.22073 = (unsigned int) D.22072;
  if (D.22073 < col) goto <D.22077>; else goto <D.22078>;
  <D.22077>:
  D.22076 = -1;
  return D.22076;
  <D.22078>:
  D.22076 = 1;
  return D.22076;
}


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


mono_metadata_nested_in_typedef (struct MonoImage * meta, guint32 index)
{
  const char * D.22085;
  uint32_t D.22088;
  int index.112;
  int D.22090;
  <unnamed-unsigned:24> D.22091;
  long unsigned int D.22092;
  unsigned char D.22093;
  long unsigned int D.22094;
  void * D.22095;
  unsigned int D.22098;
  int D.22099;
  unsigned int D.22100;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[41];
      D.22085 = tdef->base;
      if (D.22085 == 0B) goto <D.22086>; else goto <D.22087>;
      <D.22086>:
      D.22088 = 0;
      return D.22088;
      <D.22087>:
      index.112 = (int) index;
      D.22090 = index.112 & 16777215;
      loc.idx = D.22090;
      loc.col_idx = 0;
      loc.t = tdef;
      D.22085 = tdef->base;
      D.22091 = tdef->rows;
      D.22092 = (long unsigned int) D.22091;
      D.22093 = tdef->row_size;
      D.22094 = (long unsigned int) D.22093;
      D.22095 = mono_binary_search (&loc, D.22085, D.22092, D.22094, table_locator);
      if (D.22095 == 0B) goto <D.22096>; else goto <D.22097>;
      <D.22096>:
      D.22088 = 0;
      return D.22088;
      <D.22097>:
      D.22098 = loc.result;
      D.22099 = (int) D.22098;
      D.22100 = mono_metadata_decode_row_col (tdef, D.22099, 1);
      D.22088 = D.22100 | 33554432;
      return D.22088;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_nesting_typedef (struct MonoImage * meta, guint32 index, guint32 start_index)
{
  const char * D.22103;
  uint32_t D.22106;
  unsigned int D.22107;
  int D.22108;
  unsigned int D.22109;
  <unnamed-unsigned:24> D.22111;
  unsigned int D.22112;
  struct MonoTableInfo * tdef;
  guint32 start;
  guint32 class_index;

  tdef = &meta->tables[41];
  class_index = index & 16777215;
  D.22103 = tdef->base;
  if (D.22103 == 0B) goto <D.22104>; else goto <D.22105>;
  <D.22104>:
  D.22106 = 0;
  return D.22106;
  <D.22105>:
  start = start_index;
  goto <D.19103>;
  <D.19102>:
  D.22107 = start + 4294967295;
  D.22108 = (int) D.22107;
  D.22109 = mono_metadata_decode_row_col (tdef, D.22108, 1);
  if (D.22109 == class_index) goto <D.19101>; else goto <D.22110>;
  <D.22110>:
  start = start + 1;
  <D.19103>:
  D.22111 = tdef->rows;
  D.22112 = (unsigned int) D.22111;
  if (D.22112 >= start) goto <D.19102>; else goto <D.19101>;
  <D.19101>:
  D.22111 = tdef->rows;
  D.22112 = (unsigned int) D.22111;
  if (D.22112 < start) goto <D.22113>; else goto <D.22114>;
  <D.22113>:
  D.22106 = 0;
  return D.22106;
  <D.22114>:
  D.22106 = start;
  return D.22106;
}


mono_metadata_packing_from_typedef (struct MonoImage * meta, guint32 index, guint32 * packing, guint32 * size)
{
  const char * D.22116;
  uint32_t D.22119;
  int index.113;
  int D.22121;
  <unnamed-unsigned:24> D.22122;
  long unsigned int D.22123;
  unsigned char D.22124;
  long unsigned int D.22125;
  void * D.22126;
  unsigned int D.22129;
  int D.22130;
  unsigned int D.22133;
  unsigned int D.22136;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 cols[3];

  try
    {
      tdef = &meta->tables[15];
      D.22116 = tdef->base;
      if (D.22116 == 0B) goto <D.22117>; else goto <D.22118>;
      <D.22117>:
      D.22119 = 0;
      return D.22119;
      <D.22118>:
      index.113 = (int) index;
      D.22121 = index.113 & 16777215;
      loc.idx = D.22121;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22116 = tdef->base;
      D.22122 = tdef->rows;
      D.22123 = (long unsigned int) D.22122;
      D.22124 = tdef->row_size;
      D.22125 = (long unsigned int) D.22124;
      D.22126 = mono_binary_search (&loc, D.22116, D.22123, D.22125, table_locator);
      if (D.22126 == 0B) goto <D.22127>; else goto <D.22128>;
      <D.22127>:
      D.22119 = 0;
      return D.22119;
      <D.22128>:
      D.22129 = loc.result;
      D.22130 = (int) D.22129;
      mono_metadata_decode_row (tdef, D.22130, &cols, 3);
      if (packing != 0B) goto <D.22131>; else goto <D.22132>;
      <D.22131>:
      D.22133 = cols[0];
      *packing = D.22133;
      <D.22132>:
      if (size != 0B) goto <D.22134>; else goto <D.22135>;
      <D.22134>:
      D.22136 = cols[1];
      *size = D.22136;
      <D.22135>:
      D.22129 = loc.result;
      D.22119 = D.22129 + 1;
      return D.22119;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_custom_attrs_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.22139;
  uint32_t D.22142;
  int index.114;
  <unnamed-unsigned:24> D.22144;
  long unsigned int D.22145;
  unsigned char D.22146;
  long unsigned int D.22147;
  void * D.22148;
  unsigned int D.22151;
  unsigned int D.22152;
  int D.22154;
  unsigned int D.22155;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[12];
      D.22139 = tdef->base;
      if (D.22139 == 0B) goto <D.22140>; else goto <D.22141>;
      <D.22140>:
      D.22142 = 0;
      return D.22142;
      <D.22141>:
      index.114 = (int) index;
      loc.idx = index.114;
      loc.col_idx = 0;
      loc.t = tdef;
      D.22139 = tdef->base;
      D.22144 = tdef->rows;
      D.22145 = (long unsigned int) D.22144;
      D.22146 = tdef->row_size;
      D.22147 = (long unsigned int) D.22146;
      D.22148 = mono_binary_search (&loc, D.22139, D.22145, D.22147, table_locator);
      if (D.22148 == 0B) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      D.22142 = 0;
      return D.22142;
      <D.22150>:
      goto <D.19120>;
      <D.19119>:
      D.22151 = loc.result;
      D.22152 = D.22151 + 4294967295;
      loc.result = D.22152;
      <D.19120>:
      D.22151 = loc.result;
      if (D.22151 != 0) goto <D.22153>; else goto <D.19121>;
      <D.22153>:
      D.22151 = loc.result;
      D.22152 = D.22151 + 4294967295;
      D.22154 = (int) D.22152;
      D.22155 = mono_metadata_decode_row_col (tdef, D.22154, 0);
      if (D.22155 == index) goto <D.19119>; else goto <D.19121>;
      <D.19121>:
      D.22151 = loc.result;
      D.22142 = D.22151 + 1;
      return D.22142;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_declsec_from_index (struct MonoImage * meta, guint32 index)
{
  const char * D.22158;
  uint32_t D.22161;
  int index.115;
  <unnamed-unsigned:24> D.22163;
  long unsigned int D.22164;
  unsigned char D.22165;
  long unsigned int D.22166;
  void * D.22167;
  unsigned int D.22170;
  unsigned int D.22171;
  int D.22173;
  unsigned int D.22174;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &meta->tables[14];
      D.22158 = tdef->base;
      if (D.22158 == 0B) goto <D.22159>; else goto <D.22160>;
      <D.22159>:
      D.22161 = 4294967295;
      return D.22161;
      <D.22160>:
      index.115 = (int) index;
      loc.idx = index.115;
      loc.col_idx = 1;
      loc.t = tdef;
      D.22158 = tdef->base;
      D.22163 = tdef->rows;
      D.22164 = (long unsigned int) D.22163;
      D.22165 = tdef->row_size;
      D.22166 = (long unsigned int) D.22165;
      D.22167 = mono_binary_search (&loc, D.22158, D.22164, D.22166, declsec_locator);
      if (D.22167 == 0B) goto <D.22168>; else goto <D.22169>;
      <D.22168>:
      D.22161 = 4294967295;
      return D.22161;
      <D.22169>:
      goto <D.19129>;
      <D.19128>:
      D.22170 = loc.result;
      D.22171 = D.22170 + 4294967295;
      loc.result = D.22171;
      <D.19129>:
      D.22170 = loc.result;
      if (D.22170 != 0) goto <D.22172>; else goto <D.19130>;
      <D.22172>:
      D.22170 = loc.result;
      D.22171 = D.22170 + 4294967295;
      D.22173 = (int) D.22171;
      D.22174 = mono_metadata_decode_row_col (tdef, D.22173, 1);
      if (D.22174 == index) goto <D.19128>; else goto <D.19130>;
      <D.19130>:
      D.22161 = loc.result;
      return D.22161;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


declsec_locator (const void * a, const void * b)
{
  long int bb.116;
  struct MonoTableInfo * D.22178;
  const char * D.22179;
  long int D.22180;
  long int D.22181;
  unsigned char D.22182;
  long int D.22183;
  long int D.22184;
  int table_index.117;
  int D.22186;
  unsigned int D.22187;
  int D.22188;
  unsigned int D.22189;
  int D.22192;
  struct locator_t * loc;
  const char * bb;
  guint32 table_index;
  guint32 col;

  loc = a;
  bb = b;
  bb.116 = (long int) bb;
  D.22178 = loc->t;
  D.22179 = D.22178->base;
  D.22180 = (long int) D.22179;
  D.22181 = bb.116 - D.22180;
  D.22178 = loc->t;
  D.22182 = D.22178->row_size;
  D.22183 = (long int) D.22182;
  D.22184 = D.22181 / D.22183;
  table_index = (guint32) D.22184;
  D.22178 = loc->t;
  table_index.117 = (int) table_index;
  D.22186 = loc->col_idx;
  D.22187 = (unsigned int) D.22186;
  col = mono_metadata_decode_row_col (D.22178, table_index.117, D.22187);
  D.22188 = loc->idx;
  D.22189 = (unsigned int) D.22188;
  if (D.22189 == col) goto <D.22190>; else goto <D.22191>;
  <D.22190>:
  loc->result = table_index;
  D.22192 = 0;
  return D.22192;
  <D.22191>:
  D.22188 = loc->idx;
  D.22189 = (unsigned int) D.22188;
  if (D.22189 < col) goto <D.22193>; else goto <D.22194>;
  <D.22193>:
  D.22192 = -1;
  return D.22192;
  <D.22194>:
  D.22192 = 1;
  return D.22192;
}


mono_type_size (struct MonoType * t, int * align)
{
  int D.22198;
  long unsigned int D.22199;
  long unsigned int D.22200;
  unsigned char D.22203;
  int D.22204;
  struct MonoClass * D.22205;
  long unsigned int D.22206;
  long unsigned int D.22207;
  struct MonoType * D.22210;
  struct MonoClass * D.22211;
  long unsigned int D.22212;
  long unsigned int D.22213;
  long unsigned int D.22216;
  struct MonoType * D.22219;
  struct MonoClass * D.22220;

  if (t == 0B) goto <D.22196>; else goto <D.22197>;
  <D.22196>:
  *align = 1;
  D.22198 = 0;
  return D.22198;
  <D.22197>:
  D.22199 = BIT_FIELD_REF <*t, 64, 64>;
  D.22200 = D.22199 & 1073741824;
  if (D.22200 != 0) goto <D.22201>; else goto <D.22202>;
  <D.22201>:
  {
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    *align = 8;
    D.22198 = 8;
    return D.22198;
  }
  <D.22202>:
  D.22203 = t->type;
  D.22204 = (int) D.22203;
  switch (D.22204) <default: <D.19206>, case 1: <D.19138>, case 2: <D.19139>, case 3: <D.19148>, case 4: <D.19143>, case 5: <D.19144>, case 6: <D.19149>, case 7: <D.19150>, case 8: <D.19154>, case 9: <D.19155>, case 10: <D.19163>, case 11: <D.19164>, case 12: <D.19159>, case 13: <D.19168>, case 14: <D.19177>, case 15: <D.19188>, case 17: <D.19185>, case 18: <D.19186>, case 19: <D.19201>, case 20: <D.19190>, case 21: <D.19195>, case 22: <D.19194>, case 24: <D.19172>, case 25: <D.19173>, case 27: <D.19189>, case 28: <D.19181>, case 29: <D.19187>, case 30: <D.19202>>
  {
    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.19138>:
    *align = 1;
    D.22198 = 0;
    return D.22198;
    <D.19139>:
    *align = 1;
    D.22198 = 1;
    return D.22198;
    <D.19143>:
    <D.19144>:
    *align = 1;
    D.22198 = 1;
    return D.22198;
    <D.19148>:
    <D.19149>:
    <D.19150>:
    *align = 2;
    D.22198 = 2;
    return D.22198;
    <D.19154>:
    <D.19155>:
    *align = 4;
    D.22198 = 4;
    return D.22198;
    <D.19159>:
    *align = 4;
    D.22198 = 4;
    return D.22198;
    <D.19163>:
    <D.19164>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19168>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19172>:
    <D.19173>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19177>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19181>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19185>:
    D.22205 = t->data.klass;
    D.22206 = BIT_FIELD_REF <*D.22205, 64, 256>;
    D.22207 = D.22206 & 16;
    if (D.22207 != 0) goto <D.22208>; else goto <D.22209>;
    <D.22208>:
    D.22205 = t->data.klass;
    D.22210 = mono_class_enum_basetype (D.22205);
    D.22198 = mono_type_size (D.22210, align);
    return D.22198;
    <D.22209>:
    D.22205 = t->data.klass;
    D.22198 = mono_class_value_size (D.22205, align);
    return D.22198;
    <D.19186>:
    <D.19187>:
    <D.19188>:
    <D.19189>:
    <D.19190>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19194>:
    D.22211 = mono_defaults.typed_reference_class;
    D.22198 = mono_class_value_size (D.22211, align);
    return D.22198;
    <D.19195>:
    {
      struct MonoGenericClass * gclass;
      struct MonoClass * container_class;

      gclass = t->data.generic_class;
      container_class = gclass->container_class;
      D.22212 = BIT_FIELD_REF <*container_class, 64, 256>;
      D.22213 = D.22212 & 8;
      if (D.22213 != 0) goto <D.22214>; else goto <D.22215>;
      <D.22214>:
      D.22212 = BIT_FIELD_REF <*container_class, 64, 256>;
      D.22216 = D.22212 & 16;
      if (D.22216 != 0) goto <D.22217>; else goto <D.22218>;
      <D.22217>:
      D.22219 = mono_class_enum_basetype (container_class);
      D.22198 = mono_type_size (D.22219, align);
      return D.22198;
      <D.22218>:
      D.22220 = mono_class_from_mono_type (t);
      D.22198 = mono_class_value_size (D.22220, align);
      return D.22198;
      <D.22215>:
      {
        typedef struct 
      {
        char c;
        void * x;
      } struct struct 
      {
        char c;
        void * x;
      };

        *align = 8;
        D.22198 = 8;
        return D.22198;
      }
    }
    <D.19201>:
    <D.19202>:
    *align = 8;
    D.22198 = 8;
    return D.22198;
    <D.19206>:
    D.22203 = t->type;
    D.22204 = (int) D.22203;
    monoeg_g_log (0B, 4, "mono_type_size: type 0x%02x unknown", D.22204);
    <D.19207>:
    goto <D.19207>;
  }
  D.22198 = 0;
  return D.22198;
}


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

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


mono_type_stack_size_internal (struct MonoType * t, int * align, gboolean allow_open)
{
  _Bool D.22224;
  long int D.22225;
  long int D.22226;
  long unsigned int D.22231;
  long unsigned int D.22232;
  int D.22235;
  unsigned char D.22236;
  int D.22237;
  _Bool D.22238;
  long int D.22239;
  long int D.22240;
  struct MonoClass * D.22243;
  long unsigned int D.22244;
  long unsigned int D.22245;
  struct MonoType * D.22248;
  int D.22249;
  int D.22250;
  int D.22251;
  int D.22252;
  int D.22253;
  int D.22254;
  unsigned int stack_slot_size.118;
  unsigned int D.22256;
  int D.22257;
  unsigned int D.22258;
  struct MonoGenericInst * D.22261;
  long unsigned int D.22262;
  long unsigned int D.22263;
  _Bool D.22264;
  long int D.22265;
  long int D.22266;
  long unsigned int D.22269;
  long unsigned int D.22270;
  long unsigned int D.22273;
  struct MonoType * D.22276;
  struct MonoClass * D.22277;
  int D.22278;
  unsigned int D.22279;
  int tmp;
  int stack_slot_size;
  int stack_slot_align;
  typedef struct 
{
  char c;
  void * x;
} struct struct 
{
  char c;
  void * x;
};

  try
    {
      stack_slot_size = 8;
      stack_slot_align = 8;
      D.22224 = t == 0B;
      D.22225 = (long int) D.22224;
      D.22226 = __builtin_expect (D.22225, 0);
      if (D.22226 != 0) goto <D.22227>; else goto <D.22228>;
      <D.22227>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4376, "t != NULL");
      <D.22228>:
      if (align == 0B) goto <D.22229>; else goto <D.22230>;
      <D.22229>:
      align = &tmp;
      <D.22230>:
      D.22231 = BIT_FIELD_REF <*t, 64, 64>;
      D.22232 = D.22231 & 1073741824;
      if (D.22232 != 0) goto <D.22233>; else goto <D.22234>;
      <D.22233>:
      *align = stack_slot_align;
      D.22235 = stack_slot_size;
      return D.22235;
      <D.22234>:
      D.22236 = t->type;
      D.22237 = (int) D.22236;
      switch (D.22237) <default: <D.19262>, case 2: <D.19223>, case 3: <D.19224>, case 4: <D.19225>, case 5: <D.19226>, case 6: <D.19227>, case 7: <D.19228>, case 8: <D.19229>, case 9: <D.19230>, case 10: <D.19247>, case 11: <D.19248>, case 12: <D.19243>, case 13: <D.19252>, case 14: <D.19233>, case 15: <D.19237>, case 17: <D.19256>, case 18: <D.19235>, case 19: <D.19240>, case 20: <D.19239>, case 21: <D.19258>, case 22: <D.19242>, case 24: <D.19231>, case 25: <D.19232>, case 27: <D.19238>, case 28: <D.19234>, case 29: <D.19236>, case 30: <D.19241>>
      {
        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.19223>:
        <D.19224>:
        <D.19225>:
        <D.19226>:
        <D.19227>:
        <D.19228>:
        <D.19229>:
        <D.19230>:
        <D.19231>:
        <D.19232>:
        <D.19233>:
        <D.19234>:
        <D.19235>:
        <D.19236>:
        <D.19237>:
        <D.19238>:
        <D.19239>:
        *align = stack_slot_align;
        D.22235 = stack_slot_size;
        return D.22235;
        <D.19240>:
        <D.19241>:
        D.22238 = allow_open == 0;
        D.22239 = (long int) D.22238;
        D.22240 = __builtin_expect (D.22239, 0);
        if (D.22240 != 0) goto <D.22241>; else goto <D.22242>;
        <D.22241>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4408, "allow_open");
        <D.22242>:
        *align = stack_slot_align;
        D.22235 = stack_slot_size;
        return D.22235;
        <D.19242>:
        *align = stack_slot_align;
        D.22235 = stack_slot_size * 3;
        return D.22235;
        <D.19243>:
        *align = 4;
        D.22235 = 4;
        return D.22235;
        <D.19247>:
        <D.19248>:
        *align = 8;
        D.22235 = 8;
        return D.22235;
        <D.19252>:
        *align = 8;
        D.22235 = 8;
        return D.22235;
        <D.19256>:
        {
          guint32 size;

          D.22243 = t->data.klass;
          D.22244 = BIT_FIELD_REF <*D.22243, 64, 256>;
          D.22245 = D.22244 & 16;
          if (D.22245 != 0) goto <D.22246>; else goto <D.22247>;
          <D.22246>:
          D.22243 = t->data.klass;
          D.22248 = mono_class_enum_basetype (D.22243);
          D.22235 = mono_type_stack_size_internal (D.22248, align, allow_open);
          return D.22235;
          <D.22247>:
          D.22243 = t->data.klass;
          D.22249 = mono_class_value_size (D.22243, align);
          size = (guint32) D.22249;
          D.22250 = *align;
          D.22251 = D.22250 + stack_slot_align;
          D.22252 = D.22251 + -1;
          *align = D.22252;
          D.22250 = *align;
          D.22253 = -stack_slot_align;
          D.22254 = D.22250 & D.22253;
          *align = D.22254;
          stack_slot_size.118 = (unsigned int) stack_slot_size;
          D.22256 = stack_slot_size.118 + size;
          size = D.22256 + 4294967295;
          D.22257 = -stack_slot_size;
          D.22258 = (unsigned int) D.22257;
          size = D.22258 & size;
          D.22235 = (int) size;
          return D.22235;
        }
        <D.19258>:
        {
          struct MonoGenericClass * gclass;
          struct MonoClass * container_class;

          gclass = t->data.generic_class;
          container_class = gclass->container_class;
          if (allow_open == 0) goto <D.22259>; else goto <D.22260>;
          <D.22259>:
          D.22261 = gclass->context.class_inst;
          D.22262 = BIT_FIELD_REF <*D.22261, 64, 0>;
          D.22263 = D.22262 & 18014398509481984;
          D.22264 = D.22263 != 0;
          D.22265 = (long int) D.22264;
          D.22266 = __builtin_expect (D.22265, 0);
          if (D.22266 != 0) goto <D.22267>; else goto <D.22268>;
          <D.22267>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4446, "!gclass->context.class_inst->is_open");
          <D.22268>:
          <D.22260>:
          D.22269 = BIT_FIELD_REF <*container_class, 64, 256>;
          D.22270 = D.22269 & 8;
          if (D.22270 != 0) goto <D.22271>; else goto <D.22272>;
          <D.22271>:
          D.22269 = BIT_FIELD_REF <*container_class, 64, 256>;
          D.22273 = D.22269 & 16;
          if (D.22273 != 0) goto <D.22274>; else goto <D.22275>;
          <D.22274>:
          D.22276 = mono_class_enum_basetype (container_class);
          D.22235 = mono_type_stack_size_internal (D.22276, align, allow_open);
          return D.22235;
          <D.22275>:
          {
            guint32 size;

            D.22277 = mono_class_from_mono_type (t);
            D.22278 = mono_class_value_size (D.22277, align);
            size = (guint32) D.22278;
            D.22250 = *align;
            D.22251 = D.22250 + stack_slot_align;
            D.22252 = D.22251 + -1;
            *align = D.22252;
            D.22250 = *align;
            D.22253 = -stack_slot_align;
            D.22254 = D.22250 & D.22253;
            *align = D.22254;
            stack_slot_size.118 = (unsigned int) stack_slot_size;
            D.22279 = stack_slot_size.118 + size;
            size = D.22279 + 4294967295;
            D.22257 = -stack_slot_size;
            D.22258 = (unsigned int) D.22257;
            size = D.22258 & size;
            D.22235 = (int) size;
            return D.22235;
          }
          <D.22272>:
          *align = stack_slot_align;
          D.22235 = stack_slot_size;
          return D.22235;
        }
        <D.19262>:
        D.22236 = t->type;
        D.22237 = (int) D.22236;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.22237);
        <D.19263>:
        goto <D.19263>;
      }
      D.22235 = 0;
      return D.22235;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


mono_type_generic_inst_is_valuetype (struct MonoType * type)
{
  unsigned char D.22282;
  _Bool D.22283;
  long int D.22284;
  long int D.22285;
  mono_bool D.22288;
  struct MonoGenericClass * D.22289;
  struct MonoClass * D.22290;
  <unnamed-unsigned:1> D.22291;

  D.22282 = type->type;
  D.22283 = D.22282 != 21;
  D.22284 = (long int) D.22283;
  D.22285 = __builtin_expect (D.22284, 0);
  if (D.22285 != 0) goto <D.22286>; else goto <D.22287>;
  <D.22286>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 4476, "type->type == MONO_TYPE_GENERICINST");
  <D.22287>:
  D.22289 = type->data.generic_class;
  D.22290 = D.22289->container_class;
  D.22291 = D.22290->valuetype;
  D.22288 = (mono_bool) D.22291;
  return D.22288;
}


mono_metadata_generic_class_is_valuetype (struct MonoGenericClass * gclass)
{
  mono_bool D.22293;
  struct MonoClass * D.22294;
  <unnamed-unsigned:1> D.22295;

  D.22294 = gclass->container_class;
  D.22295 = D.22294->valuetype;
  D.22293 = (mono_bool) D.22295;
  return D.22293;
}


mono_metadata_generic_context_hash (const struct MonoGenericContext * context)
{
  struct MonoGenericInst * D.22297;
  unsigned int D.22300;
  unsigned int D.22301;
  unsigned int D.22302;
  struct MonoGenericInst * D.22303;
  unsigned int D.22306;
  guint D.22307;
  guint hash;

  hash = 3223191271;
  D.22297 = context->class_inst;
  if (D.22297 != 0B) goto <D.22298>; else goto <D.22299>;
  <D.22298>:
  D.22300 = hash << 5;
  D.22301 = D.22300 - hash;
  D.22297 = context->class_inst;
  D.22302 = mono_metadata_generic_inst_hash (D.22297);
  hash = D.22301 ^ D.22302;
  <D.22299>:
  D.22303 = context->method_inst;
  if (D.22303 != 0B) goto <D.22304>; else goto <D.22305>;
  <D.22304>:
  D.22300 = hash << 5;
  D.22301 = D.22300 - hash;
  D.22303 = context->method_inst;
  D.22306 = mono_metadata_generic_inst_hash (D.22303);
  hash = D.22301 ^ D.22306;
  <D.22305>:
  D.22307 = hash;
  return D.22307;
}


mono_metadata_generic_context_equal (const struct MonoGenericContext * g1, const struct MonoGenericContext * g2)
{
  gboolean D.22309;
  int iftmp.119;
  struct MonoGenericInst * D.22313;
  struct MonoGenericInst * D.22314;
  struct MonoGenericInst * D.22316;
  struct MonoGenericInst * D.22317;

  D.22313 = g1->class_inst;
  D.22314 = g2->class_inst;
  if (D.22313 == D.22314) goto <D.22315>; else goto <D.22311>;
  <D.22315>:
  D.22316 = g1->method_inst;
  D.22317 = g2->method_inst;
  if (D.22316 == D.22317) goto <D.22318>; else goto <D.22311>;
  <D.22318>:
  iftmp.119 = 1;
  goto <D.22312>;
  <D.22311>:
  iftmp.119 = 0;
  <D.22312>:
  D.22309 = iftmp.119;
  return D.22309;
}


mono_metadata_str_hash (const void * v1)
{
  char D.22320;
  unsigned int D.22323;
  unsigned int D.22324;
  unsigned int D.22325;
  char * p.120;
  char D.22327;
  guint D.22328;
  char * p;
  guint hash;

  p = v1;
  D.22320 = *p;
  hash = (guint) D.22320;
  goto <D.19298>;
  <D.19297>:
  D.22320 = *p;
  if (D.22320 != 0) goto <D.22321>; else goto <D.22322>;
  <D.22321>:
  D.22323 = hash << 5;
  D.22324 = D.22323 - hash;
  D.22320 = *p;
  D.22325 = (unsigned int) D.22320;
  hash = D.22324 + D.22325;
  <D.22322>:
  <D.19298>:
  p.120 = p;
  p = p.120 + 1;
  D.22327 = *p.120;
  if (D.22327 != 0) goto <D.19297>; else goto <D.19299>;
  <D.19299>:
  D.22328 = hash;
  return D.22328;
}


mono_metadata_type_hash (struct MonoType * t1)
{
  unsigned char D.22330;
  <unnamed-unsigned:1> D.22331;
  int D.22332;
  int D.22333;
  unsigned int D.22334;
  int D.22335;
  struct MonoImage * D.22336;
  long unsigned int D.22337;
  long unsigned int D.22338;
  unsigned int D.22341;
  const char * D.22342;
  unsigned int D.22343;
  unsigned int D.22344;
  unsigned int D.22345;
  unsigned int D.22346;
  struct MonoType * D.22347;
  unsigned int D.22348;
  struct MonoArrayType * D.22349;
  struct MonoClass * D.22350;
  struct MonoType * D.22351;
  unsigned int D.22352;
  struct MonoGenericClass * D.22353;
  unsigned int D.22354;
  guint hash;

  D.22330 = t1->type;
  hash = (guint) D.22330;
  D.22331 = t1->byref;
  D.22332 = (int) D.22331;
  D.22333 = D.22332 << 6;
  D.22334 = (unsigned int) D.22333;
  hash = D.22334 | hash;
  D.22330 = t1->type;
  D.22335 = (int) D.22330;
  switch (D.22335) <default: <D.22355>, case 15: <D.19308>, case 17: <D.19304>, case 18: <D.19305>, case 20: <D.19309>, case 21: <D.19310>, case 29: <D.19306>>
  <D.19304>:
  <D.19305>:
  <D.19306>:
  {
    struct MonoClass * class;

    class = t1->data.klass;
    D.22336 = class->image;
    D.22337 = BIT_FIELD_REF <*D.22336, 64, 192>;
    D.22338 = D.22337 & 34359738368;
    if (D.22338 != 0) goto <D.22339>; else goto <D.22340>;
    <D.22339>:
    D.22331 = t1->byref;
    D.22332 = (int) D.22331;
    D.22333 = D.22332 << 6;
    D.22334 = (unsigned int) D.22333;
    D.22342 = class->name;
    D.22343 = mono_metadata_str_hash (D.22342);
    D.22341 = D.22334 | D.22343;
    return D.22341;
    <D.22340>:
    D.22344 = hash << 5;
    D.22345 = D.22344 - hash;
    D.22342 = class->name;
    D.22346 = mono_metadata_str_hash (D.22342);
    D.22341 = D.22345 ^ D.22346;
    return D.22341;
  }
  <D.19308>:
  D.22344 = hash << 5;
  D.22345 = D.22344 - hash;
  D.22347 = t1->data.type;
  D.22348 = mono_metadata_type_hash (D.22347);
  D.22341 = D.22345 ^ D.22348;
  return D.22341;
  <D.19309>:
  D.22344 = hash << 5;
  D.22345 = D.22344 - hash;
  D.22349 = t1->data.array;
  D.22350 = D.22349->eklass;
  D.22351 = &D.22350->byval_arg;
  D.22352 = mono_metadata_type_hash (D.22351);
  D.22341 = D.22345 ^ D.22352;
  return D.22341;
  <D.19310>:
  D.22344 = hash << 5;
  D.22345 = D.22344 - hash;
  D.22353 = t1->data.generic_class;
  D.22354 = mono_generic_class_hash (D.22353);
  D.22341 = D.22345 ^ D.22354;
  return D.22341;
  <D.22355>:
  D.22341 = hash;
  return D.22341;
}


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

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


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

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


mono_metadata_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  long unsigned int D.22363;
  long unsigned int D.22364;
  long unsigned int D.22365;
  long unsigned int D.22366;
  short unsigned int D.22368;
  short unsigned int D.22369;
  mono_bool D.22370;
  short unsigned int D.22371;
  short unsigned int D.22372;
  int D.22375;
  int D.22378;
  struct MonoType * D.22379;
  struct MonoType * D.22380;
  int D.22381;
  int i;

  D.22363 = BIT_FIELD_REF <*sig1, 64, 64>;
  D.22364 = BIT_FIELD_REF <*sig2, 64, 64>;
  D.22365 = D.22363 ^ D.22364;
  D.22366 = D.22365 & 18014398509481984;
  if (D.22366 != 0) goto <D.22361>; else goto <D.22367>;
  <D.22367>:
  D.22368 = sig1->param_count;
  D.22369 = sig2->param_count;
  if (D.22368 != D.22369) goto <D.22361>; else goto <D.22362>;
  <D.22361>:
  D.22370 = 0;
  return D.22370;
  <D.22362>:
  D.22371 = sig1->generic_param_count;
  D.22372 = sig2->generic_param_count;
  if (D.22371 != D.22372) goto <D.22373>; else goto <D.22374>;
  <D.22373>:
  D.22370 = 0;
  return D.22370;
  <D.22374>:
  i = 0;
  goto <D.19382>;
  <D.19381>:
  {
    struct MonoType * p1;
    struct MonoType * p2;

    p1 = sig1->params[i];
    p2 = sig2->params[i];
    D.22375 = do_mono_metadata_type_equal (p1, p2, 1);
    if (D.22375 == 0) goto <D.22376>; else goto <D.22377>;
    <D.22376>:
    D.22370 = 0;
    return D.22370;
    <D.22377>:
  }
  i = i + 1;
  <D.19382>:
  D.22368 = sig1->param_count;
  D.22378 = (int) D.22368;
  if (D.22378 > i) goto <D.19381>; else goto <D.19383>;
  <D.19383>:
  D.22379 = sig1->ret;
  D.22380 = sig2->ret;
  D.22381 = do_mono_metadata_type_equal (D.22379, D.22380, 1);
  if (D.22381 == 0) goto <D.22382>; else goto <D.22383>;
  <D.22382>:
  D.22370 = 0;
  return D.22370;
  <D.22383>:
  D.22370 = 1;
  return D.22370;
}


mono_metadata_type_dup (struct MonoImage * image, const struct MonoType * o)
{
  long unsigned int D.22385;
  long unsigned int D.22386;
  <unnamed-unsigned:6> D.22389;
  unsigned int D.22390;
  unsigned int D.22391;
  unsigned int sizeof_o.121;
  unsigned int D.22393;
  void * iftmp.122;
  unsigned int sizeof_o.123;
  long unsigned int D.22399;
  long unsigned int D.22400;
  unsigned char D.22401;
  struct MonoType * D.22404;
  struct MonoType * D.22405;
  struct MonoArrayType * D.22409;
  struct MonoArrayType * D.22410;
  struct MonoMethodSignature * D.22414;
  struct MonoMethodSignature * D.22415;
  struct MonoType * D.22416;
  struct MonoType * r;
  int sizeof_o;

  r = 0B;
  sizeof_o = 12;
  D.22385 = BIT_FIELD_REF <*o, 64, 64>;
  D.22386 = D.22385 & 1056964608;
  if (D.22386 != 0) goto <D.22387>; else goto <D.22388>;
  <D.22387>:
  D.22389 = o->num_mods;
  D.22390 = (unsigned int) D.22389;
  D.22391 = D.22390 * 4;
  sizeof_o.121 = (unsigned int) sizeof_o;
  D.22393 = D.22391 + sizeof_o.121;
  sizeof_o = (int) D.22393;
  <D.22388>:
  if (image != 0B) goto <D.22395>; else goto <D.22396>;
  <D.22395>:
  sizeof_o.123 = (unsigned int) sizeof_o;
  iftmp.122 = mono_image_alloc0 (image, sizeof_o.123);
  goto <D.22398>;
  <D.22396>:
  D.22399 = (long unsigned int) sizeof_o;
  iftmp.122 = monoeg_malloc (D.22399);
  <D.22398>:
  r = iftmp.122;
  D.22400 = (long unsigned int) sizeof_o;
  memcpy (r, o, D.22400);
  D.22401 = o->type;
  if (D.22401 == 15) goto <D.22402>; else goto <D.22403>;
  <D.22402>:
  D.22404 = o->data.type;
  D.22405 = mono_metadata_type_dup (image, D.22404);
  r->data.type = D.22405;
  goto <D.22406>;
  <D.22403>:
  D.22401 = o->type;
  if (D.22401 == 20) goto <D.22407>; else goto <D.22408>;
  <D.22407>:
  D.22409 = o->data.array;
  D.22410 = mono_dup_array_type (image, D.22409);
  r->data.array = D.22410;
  goto <D.22411>;
  <D.22408>:
  D.22401 = o->type;
  if (D.22401 == 27) goto <D.22412>; else goto <D.22413>;
  <D.22412>:
  D.22414 = o->data.method;
  D.22415 = mono_metadata_signature_deep_dup (image, D.22414);
  r->data.method = D.22415;
  <D.22413>:
  <D.22411>:
  <D.22406>:
  D.22416 = r;
  return D.22416;
}


mono_signature_hash (struct MonoMethodSignature * sig)
{
  struct MonoType * D.22418;
  unsigned char D.22419;
  unsigned int D.22420;
  unsigned int D.22421;
  struct MonoType * D.22422;
  unsigned int D.22423;
  short unsigned int D.22424;
  unsigned int D.22425;
  unsigned int D.22426;
  guint i;
  guint res;

  D.22418 = sig->ret;
  D.22419 = D.22418->type;
  res = (guint) D.22419;
  i = 0;
  goto <D.19396>;
  <D.19395>:
  D.22420 = res << 5;
  D.22421 = D.22420 - res;
  D.22422 = sig->params[i];
  D.22423 = mono_type_hash (D.22422);
  res = D.22421 + D.22423;
  i = i + 1;
  <D.19396>:
  D.22424 = sig->param_count;
  D.22425 = (unsigned int) D.22424;
  if (D.22425 > i) goto <D.19395>; else goto <D.19397>;
  <D.19397>:
  D.22426 = res;
  return D.22426;
}


mono_metadata_encode_value (guint32 value, char * buf, char * * endbuf)
{
  char * p.124;
  char D.22431;
  unsigned int D.22435;
  char D.22436;
  char D.22437;
  char * D.22438;
  unsigned int D.22440;
  char D.22441;
  char D.22442;
  unsigned int D.22443;
  char D.22444;
  char * D.22445;
  char * D.22446;
  char * p;

  p = buf;
  if (value <= 127) goto <D.22428>; else goto <D.22429>;
  <D.22428>:
  p.124 = p;
  p = p.124 + 1;
  D.22431 = (char) value;
  *p.124 = D.22431;
  goto <D.22432>;
  <D.22429>:
  if (value <= 16383) goto <D.22433>; else goto <D.22434>;
  <D.22433>:
  D.22435 = value >> 8;
  D.22436 = (char) D.22435;
  D.22437 = D.22436 | 128;
  *p = D.22437;
  D.22438 = p + 1;
  D.22431 = (char) value;
  *D.22438 = D.22431;
  p = p + 2;
  goto <D.22439>;
  <D.22434>:
  D.22440 = value >> 24;
  D.22441 = (char) D.22440;
  D.22442 = D.22441 | 192;
  *p = D.22442;
  D.22438 = p + 1;
  D.22443 = value >> 16;
  D.22444 = (char) D.22443;
  *D.22438 = D.22444;
  D.22445 = p + 2;
  D.22435 = value >> 8;
  D.22436 = (char) D.22435;
  *D.22445 = D.22436;
  D.22446 = p + 3;
  D.22431 = (char) value;
  *D.22446 = D.22431;
  p = p + 4;
  <D.22439>:
  <D.22432>:
  if (endbuf != 0B) goto <D.22447>; else goto <D.22448>;
  <D.22447>:
  *endbuf = p;
  <D.22448>:
}


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.22449;
  int D.22450;
  long unsigned int D.22451;
  long unsigned int D.22452;
  int D.22455;
  unsigned int D.22456;
  int D.22457;
  const char * D.22462;
  <unnamed-unsigned:24> D.22464;
  long unsigned int D.22465;
  unsigned char D.22466;
  long unsigned int D.22467;
  void * D.22468;
  unsigned int D.22470;
  int D.22471;
  unsigned int D.22472;
  void * D.22478;
  unsigned int D.22480;
  struct MonoImage * iftmp.125;
  struct MonoMarshalSpec * D.22489;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      D.22449 = index + 1;
      D.22450 = (int) D.22449;
      loc.idx = D.22450;
      D.22451 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22452 = D.22451 & 137438953472;
      if (D.22452 != 0) goto <D.22453>; else goto <D.22454>;
      <D.22453>:
      D.22455 = loc.idx;
      D.22456 = search_ptr_table (meta, 3, D.22455);
      D.22457 = (int) D.22456;
      loc.idx = D.22457;
      <D.22454>:
      if (offset != 0B) goto <D.22458>; else goto <D.22459>;
      <D.22458>:
      tdef = &meta->tables[16];
      loc.col_idx = 1;
      loc.t = tdef;
      D.22462 = tdef->base;
      if (D.22462 != 0B) goto <D.22463>; else goto <D.22460>;
      <D.22463>:
      D.22462 = tdef->base;
      D.22464 = tdef->rows;
      D.22465 = (long unsigned int) D.22464;
      D.22466 = tdef->row_size;
      D.22467 = (long unsigned int) D.22466;
      D.22468 = mono_binary_search (&loc, D.22462, D.22465, D.22467, table_locator);
      if (D.22468 != 0B) goto <D.22469>; else goto <D.22460>;
      <D.22469>:
      D.22470 = loc.result;
      D.22471 = (int) D.22470;
      D.22472 = mono_metadata_decode_row_col (tdef, D.22471, 0);
      *offset = D.22472;
      goto <D.22461>;
      <D.22460>:
      *offset = 4294967295;
      <D.22461>:
      <D.22459>:
      if (rva != 0B) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      tdef = &meta->tables[29];
      loc.col_idx = 1;
      loc.t = tdef;
      D.22462 = tdef->base;
      if (D.22462 != 0B) goto <D.22477>; else goto <D.22475>;
      <D.22477>:
      D.22462 = tdef->base;
      D.22464 = tdef->rows;
      D.22465 = (long unsigned int) D.22464;
      D.22466 = tdef->row_size;
      D.22467 = (long unsigned int) D.22466;
      D.22478 = mono_binary_search (&loc, D.22462, D.22465, D.22467, table_locator);
      if (D.22478 != 0B) goto <D.22479>; else goto <D.22475>;
      <D.22479>:
      D.22470 = loc.result;
      D.22471 = (int) D.22470;
      D.22480 = mono_metadata_decode_row_col (tdef, D.22471, 0);
      *rva = D.22480;
      goto <D.22476>;
      <D.22475>:
      *rva = 0;
      <D.22476>:
      <D.22474>:
      if (marshal_spec != 0B) goto <D.22481>; else goto <D.22482>;
      <D.22481>:
      {
        const char * p;

        p = mono_metadata_get_marshal_info (meta, index, 1);
        if (p != 0B) goto <D.22483>; else goto <D.22484>;
        <D.22483>:
        if (alloc_from_image != 0) goto <D.22486>; else goto <D.22487>;
        <D.22486>:
        iftmp.125 = meta;
        goto <D.22488>;
        <D.22487>:
        iftmp.125 = 0B;
        <D.22488>:
        D.22489 = mono_metadata_parse_marshal_spec_full (iftmp.125, p);
        *marshal_spec = D.22489;
        <D.22484>:
      }
      <D.22482>:
    }
  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.22490;
  uint32_t D.22491;
  int index.126;
  <unnamed-unsigned:24> D.22495;
  unsigned int D.22496;
  unsigned int D.22499;
  int D.22500;
  unsigned int D.22501;
  const char * D.22504;
  long unsigned int D.22507;
  unsigned char D.22508;
  long unsigned int D.22509;
  void * D.22510;
  unsigned int D.22513;
  struct MonoTableInfo * tdef;
  struct locator_t loc;
  guint32 index;

  try
    {
      index = token & 16777215;
      tdef = &meta->tables[11];
      index = index << 2;
      D.22490 = token >> 24;
      switch (D.22490) <default: <D.19441>, case 4: <D.19437>, case 8: <D.19439>, case 23: <D.19440>>
      <D.19437>:
      index = index;
      goto <D.19438>;
      <D.19439>:
      index = index | 1;
      goto <D.19438>;
      <D.19440>:
      index = index | 2;
      goto <D.19438>;
      <D.19441>:
      monoeg_g_log (0B, 16, "Not a valid token for the constant table: 0x%08x", token);
      D.22491 = 0;
      return D.22491;
      <D.19438>:
      index.126 = (int) index;
      loc.idx = index.126;
      loc.col_idx = 2;
      loc.t = tdef;
      if (hint != 0) goto <D.22493>; else goto <D.22494>;
      <D.22493>:
      D.22495 = tdef->rows;
      D.22496 = (unsigned int) D.22495;
      if (D.22496 > hint) goto <D.22497>; else goto <D.22498>;
      <D.22497>:
      D.22499 = hint + 4294967295;
      D.22500 = (int) D.22499;
      D.22501 = mono_metadata_decode_row_col (tdef, D.22500, 2);
      if (D.22501 == index) goto <D.22502>; else goto <D.22503>;
      <D.22502>:
      D.22491 = hint;
      return D.22491;
      <D.22503>:
      <D.22498>:
      <D.22494>:
      D.22504 = tdef->base;
      if (D.22504 != 0B) goto <D.22505>; else goto <D.22506>;
      <D.22505>:
      D.22504 = tdef->base;
      D.22495 = tdef->rows;
      D.22507 = (long unsigned int) D.22495;
      D.22508 = tdef->row_size;
      D.22509 = (long unsigned int) D.22508;
      D.22510 = mono_binary_search (&loc, D.22504, D.22507, D.22509, table_locator);
      if (D.22510 != 0B) goto <D.22511>; else goto <D.22512>;
      <D.22511>:
      D.22513 = loc.result;
      D.22491 = D.22513 + 1;
      return D.22491;
      <D.22512>:
      <D.22506>:
      D.22491 = 0;
      return D.22491;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_events_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22516;
  uint32_t D.22519;
  unsigned int D.22520;
  int D.22521;
  <unnamed-unsigned:24> D.22522;
  long unsigned int D.22523;
  unsigned char D.22524;
  long unsigned int D.22525;
  void * D.22526;
  unsigned int D.22529;
  int D.22530;
  unsigned int D.22531;
  unsigned int D.22532;
  int D.22535;
  unsigned int D.22536;
  <unnamed-unsigned:24> D.22538;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[18];
      *end_idx = 0;
      D.22516 = tdef->base;
      if (D.22516 == 0B) goto <D.22517>; else goto <D.22518>;
      <D.22517>:
      D.22519 = 0;
      return D.22519;
      <D.22518>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22520 = index + 1;
      D.22521 = (int) D.22520;
      loc.idx = D.22521;
      D.22516 = tdef->base;
      D.22522 = tdef->rows;
      D.22523 = (long unsigned int) D.22522;
      D.22524 = tdef->row_size;
      D.22525 = (long unsigned int) D.22524;
      D.22526 = mono_binary_search (&loc, D.22516, D.22523, D.22525, table_locator);
      if (D.22526 == 0B) goto <D.22527>; else goto <D.22528>;
      <D.22527>:
      D.22519 = 0;
      return D.22519;
      <D.22528>:
      D.22529 = loc.result;
      D.22530 = (int) D.22529;
      start = mono_metadata_decode_row_col (tdef, D.22530, 1);
      D.22529 = loc.result;
      D.22531 = D.22529 + 1;
      D.22522 = tdef->rows;
      D.22532 = (unsigned int) D.22522;
      if (D.22531 < D.22532) goto <D.22533>; else goto <D.22534>;
      <D.22533>:
      D.22529 = loc.result;
      D.22531 = D.22529 + 1;
      D.22535 = (int) D.22531;
      D.22536 = mono_metadata_decode_row_col (tdef, D.22535, 1);
      end = D.22536 + 4294967295;
      goto <D.22537>;
      <D.22534>:
      D.22538 = meta->tables[20].rows;
      end = (guint32) D.22538;
      <D.22537>:
      *end_idx = end;
      D.22519 = start + 4294967295;
      return D.22519;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_metadata_methods_from_event (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22541;
  uint32_t D.22544;
  long unsigned int D.22545;
  long unsigned int D.22546;
  unsigned int D.22549;
  int D.22550;
  unsigned int D.22551;
  unsigned int D.22552;
  int D.22553;
  <unnamed-unsigned:24> D.22554;
  long unsigned int D.22555;
  unsigned char D.22556;
  long unsigned int D.22557;
  void * D.22558;
  int D.22561;
  unsigned int D.22562;
  unsigned int D.22563;
  int D.22564;
  unsigned int D.22565;
  int end.127;
  unsigned int D.22568;
  unsigned int D.22569;
  unsigned int D.22571;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22541 = msemt->base;
      if (D.22541 == 0B) goto <D.22542>; else goto <D.22543>;
      <D.22542>:
      D.22544 = 0;
      return D.22544;
      <D.22543>:
      D.22545 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22546 = D.22545 & 137438953472;
      if (D.22546 != 0) goto <D.22547>; else goto <D.22548>;
      <D.22547>:
      D.22549 = index + 1;
      D.22550 = (int) D.22549;
      D.22551 = search_ptr_table (meta, 19, D.22550);
      index = D.22551 + 4294967295;
      <D.22548>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22549 = index + 1;
      D.22552 = D.22549 << 1;
      D.22553 = (int) D.22552;
      loc.idx = D.22553;
      D.22541 = msemt->base;
      D.22554 = msemt->rows;
      D.22555 = (long unsigned int) D.22554;
      D.22556 = msemt->row_size;
      D.22557 = (long unsigned int) D.22556;
      D.22558 = mono_binary_search (&loc, D.22541, D.22555, D.22557, table_locator);
      if (D.22558 == 0B) goto <D.22559>; else goto <D.22560>;
      <D.22559>:
      D.22544 = 0;
      return D.22544;
      <D.22560>:
      start = loc.result;
      goto <D.19463>;
      <D.19462>:
      D.22561 = loc.idx;
      D.22562 = (unsigned int) D.22561;
      D.22563 = start + 4294967295;
      D.22564 = (int) D.22563;
      D.22565 = mono_metadata_decode_row_col (msemt, D.22564, 2);
      if (D.22562 == D.22565) goto <D.22566>; else goto <D.19461>;
      <D.22566>:
      start = start + 4294967295;
      <D.19463>:
      if (start != 0) goto <D.19462>; else goto <D.19461>;
      <D.19461>:
      end = start + 1;
      goto <D.19466>;
      <D.19465>:
      end.127 = (int) end;
      mono_metadata_decode_row (msemt, end.127, &cols, 3);
      D.22568 = cols[2];
      D.22561 = loc.idx;
      D.22569 = (unsigned int) D.22561;
      if (D.22568 != D.22569) goto <D.19464>; else goto <D.22570>;
      <D.22570>:
      end = end + 1;
      <D.19466>:
      D.22554 = msemt->rows;
      D.22571 = (unsigned int) D.22554;
      if (D.22571 > end) goto <D.19465>; else goto <D.19464>;
      <D.19464>:
      *end_idx = end;
      D.22544 = start;
      return D.22544;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_properties_from_typedef (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22574;
  uint32_t D.22577;
  unsigned int D.22578;
  int D.22579;
  <unnamed-unsigned:24> D.22580;
  long unsigned int D.22581;
  unsigned char D.22582;
  long unsigned int D.22583;
  void * D.22584;
  unsigned int D.22587;
  int D.22588;
  unsigned int D.22589;
  unsigned int D.22590;
  int D.22593;
  unsigned int D.22594;
  <unnamed-unsigned:24> D.22596;
  struct locator_t loc;
  guint32 start;
  guint32 end;
  struct MonoTableInfo * tdef;

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


mono_metadata_methods_from_property (struct MonoImage * meta, guint32 index, guint * end_idx)
{
  const char * D.22599;
  uint32_t D.22602;
  long unsigned int D.22603;
  long unsigned int D.22604;
  unsigned int D.22607;
  int D.22608;
  unsigned int D.22609;
  unsigned int D.22610;
  unsigned int D.22611;
  int D.22612;
  <unnamed-unsigned:24> D.22613;
  long unsigned int D.22614;
  unsigned char D.22615;
  long unsigned int D.22616;
  void * D.22617;
  int D.22620;
  unsigned int D.22621;
  unsigned int D.22622;
  int D.22623;
  unsigned int D.22624;
  int end.128;
  unsigned int D.22627;
  unsigned int D.22628;
  unsigned int D.22630;
  struct locator_t loc;
  guint start;
  guint end;
  guint32 cols[3];
  struct MonoTableInfo * msemt;

  try
    {
      msemt = &meta->tables[24];
      *end_idx = 0;
      D.22599 = msemt->base;
      if (D.22599 == 0B) goto <D.22600>; else goto <D.22601>;
      <D.22600>:
      D.22602 = 0;
      return D.22602;
      <D.22601>:
      D.22603 = BIT_FIELD_REF <*meta, 64, 192>;
      D.22604 = D.22603 & 137438953472;
      if (D.22604 != 0) goto <D.22605>; else goto <D.22606>;
      <D.22605>:
      D.22607 = index + 1;
      D.22608 = (int) D.22607;
      D.22609 = search_ptr_table (meta, 22, D.22608);
      index = D.22609 + 4294967295;
      <D.22606>:
      loc.t = msemt;
      loc.col_idx = 2;
      D.22607 = index + 1;
      D.22610 = D.22607 << 1;
      D.22611 = D.22610 | 1;
      D.22612 = (int) D.22611;
      loc.idx = D.22612;
      D.22599 = msemt->base;
      D.22613 = msemt->rows;
      D.22614 = (long unsigned int) D.22613;
      D.22615 = msemt->row_size;
      D.22616 = (long unsigned int) D.22615;
      D.22617 = mono_binary_search (&loc, D.22599, D.22614, D.22616, table_locator);
      if (D.22617 == 0B) goto <D.22618>; else goto <D.22619>;
      <D.22618>:
      D.22602 = 0;
      return D.22602;
      <D.22619>:
      start = loc.result;
      goto <D.19488>;
      <D.19487>:
      D.22620 = loc.idx;
      D.22621 = (unsigned int) D.22620;
      D.22622 = start + 4294967295;
      D.22623 = (int) D.22622;
      D.22624 = mono_metadata_decode_row_col (msemt, D.22623, 2);
      if (D.22621 == D.22624) goto <D.22625>; else goto <D.19486>;
      <D.22625>:
      start = start + 4294967295;
      <D.19488>:
      if (start != 0) goto <D.19487>; else goto <D.19486>;
      <D.19486>:
      end = start + 1;
      goto <D.19491>;
      <D.19490>:
      end.128 = (int) end;
      mono_metadata_decode_row (msemt, end.128, &cols, 3);
      D.22627 = cols[2];
      D.22620 = loc.idx;
      D.22628 = (unsigned int) D.22620;
      if (D.22627 != D.22628) goto <D.19489>; else goto <D.22629>;
      <D.22629>:
      end = end + 1;
      <D.19491>:
      D.22613 = msemt->rows;
      D.22630 = (unsigned int) D.22613;
      if (D.22630 > end) goto <D.19490>; else goto <D.19489>;
      <D.19489>:
      *end_idx = end;
      D.22602 = start;
      return D.22602;
    }
  finally
    {
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_metadata_implmap_from_method (struct MonoImage * meta, guint32 method_idx)
{
  const char * D.22633;
  uint32_t D.22636;
  unsigned int D.22637;
  unsigned int D.22638;
  unsigned int D.22639;
  int D.22640;
  <unnamed-unsigned:24> D.22641;
  long unsigned int D.22642;
  unsigned char D.22643;
  long unsigned int D.22644;
  void * D.22645;
  unsigned int D.22648;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[28];
      D.22633 = tdef->base;
      if (D.22633 == 0B) goto <D.22634>; else goto <D.22635>;
      <D.22634>:
      D.22636 = 0;
      return D.22636;
      <D.22635>:
      loc.t = tdef;
      loc.col_idx = 1;
      D.22637 = method_idx + 1;
      D.22638 = D.22637 << 1;
      D.22639 = D.22638 | 1;
      D.22640 = (int) D.22639;
      loc.idx = D.22640;
      D.22633 = tdef->base;
      D.22641 = tdef->rows;
      D.22642 = (long unsigned int) D.22641;
      D.22643 = tdef->row_size;
      D.22644 = (long unsigned int) D.22643;
      D.22645 = mono_binary_search (&loc, D.22633, D.22642, D.22644, table_locator);
      if (D.22645 == 0B) goto <D.22646>; else goto <D.22647>;
      <D.22646>:
      D.22636 = 0;
      return D.22636;
      <D.22647>:
      D.22648 = loc.result;
      D.22636 = D.22648 + 1;
      return D.22636;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


mono_type_create_from_typespec (struct MonoImage * image, guint32 type_spec)
{
  struct GHashTable * D.22651;
  long unsigned int D.22652;
  const void * D.22653;
  struct MonoType * D.22656;
  unsigned int D.22657;
  int D.22658;
  unsigned int D.22659;
  const char * ptr.129;
  int D.22661;
  const char * ptr.130;
  void * D.22669;
  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.22651 = image->typespec_cache;
      D.22652 = (long unsigned int) type_spec;
      D.22653 = (const void *) D.22652;
      type = monoeg_g_hash_table_lookup (D.22651, D.22653);
      if (type != 0B) goto <D.22654>; else goto <D.22655>;
      <D.22654>:
      mono_loader_unlock ();
      D.22656 = type;
      return D.22656;
      <D.22655>:
      t = &image->tables[27];
      D.22657 = idx + 4294967295;
      D.22658 = (int) D.22657;
      mono_metadata_decode_row (t, D.22658, &cols, 1);
      D.22659 = cols[0];
      ptr.129 = mono_metadata_blob_heap (image, D.22659);
      ptr = ptr.129;
      D.22659 = cols[0];
      D.22661 = mono_verifier_verify_typespec_signature (image, D.22659, type_spec, 0B);
      if (D.22661 == 0) goto <D.22662>; else goto <D.22663>;
      <D.22662>:
      mono_loader_unlock ();
      D.22656 = 0B;
      return D.22656;
      <D.22663>:
      ptr.130 = ptr;
      len = mono_metadata_decode_value (ptr.130, &ptr);
      ptr.130 = ptr;
      type = mono_metadata_parse_type_internal (image, 0B, 0, 0, 1, ptr.130, &ptr);
      if (type == 0B) goto <D.22665>; else goto <D.22666>;
      <D.22665>:
      mono_loader_unlock ();
      D.22656 = 0B;
      return D.22656;
      <D.22666>:
      D.22651 = image->typespec_cache;
      D.22652 = (long unsigned int) type_spec;
      D.22653 = (const void *) D.22652;
      type2 = monoeg_g_hash_table_lookup (D.22651, D.22653);
      if (type2 != 0B) goto <D.22667>; else goto <D.22668>;
      <D.22667>:
      mono_loader_unlock ();
      D.22656 = type2;
      return D.22656;
      <D.22668>:
      type2 = mono_metadata_type_dup (image, type);
      D.22651 = image->typespec_cache;
      D.22652 = (long unsigned int) type_spec;
      D.22669 = (void *) D.22652;
      monoeg_g_hash_table_insert_replace (D.22651, D.22669, type2, 0);
      mono_metadata_free_type (type);
      mono_loader_unlock ();
      D.22656 = type2;
      return D.22656;
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


mono_metadata_parse_marshal_spec_full (struct MonoImage * image, const char * ptr)
{
  const char * ptr.131;
  unsigned int D.22678;
  const char * ptr.132;
  const char * ptr.133;
  char D.22681;
  <unnamed type> D.22682;
  <unnamed type> D.22683;
  long int ptr.134;
  long int start.135;
  long int D.22688;
  long int D.22689;
  const char * ptr.136;
  const char * ptr.137;
  char D.22694;
  <unnamed type> D.22695;
  unsigned int D.22698;
  short int D.22699;
  unsigned int D.22702;
  int D.22703;
  unsigned int D.22706;
  short int D.22707;
  unsigned int D.22712;
  int D.22713;
  unsigned int D.22718;
  int D.22719;
  unsigned int D.22722;
  sizetype D.22723;
  const char * ptr.138;
  unsigned int D.22725;
  unsigned int D.22726;
  unsigned int len.139;
  char * D.22728;
  unsigned int D.22729;
  char * D.22730;
  const char * ptr.140;
  const char * ptr.141;
  char D.22737;
  <unnamed type> D.22738;
  const char * ptr.142;
  const char * ptr.143;
  char D.22743;
  int D.22744;
  struct MonoMarshalSpec * D.22745;
  struct MonoMarshalSpec * res;
  int len;
  const char * start;

  start = ptr;
  if (image != 0B) goto <D.22674>; else goto <D.22675>;
  <D.22674>:
  res = mono_image_alloc0 (image, 24);
  goto <D.22676>;
  <D.22675>:
  res = monoeg_malloc0 (24);
  <D.22676>:
  ptr.131 = ptr;
  D.22678 = mono_metadata_decode_value (ptr.131, &ptr);
  len = (int) D.22678;
  ptr.131 = ptr;
  ptr.132 = ptr.131;
  ptr.133 = ptr.132 + 1;
  ptr = ptr.133;
  D.22681 = *ptr.132;
  D.22682 = (<unnamed type>) D.22681;
  res->native = D.22682;
  D.22683 = res->native;
  if (D.22683 == 42) goto <D.22684>; else goto <D.22685>;
  <D.22684>:
  res->data.array_data.param_num = -1;
  res->data.array_data.num_elem = -1;
  res->data.array_data.elem_mult = -1;
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22690>; else goto <D.22691>;
  <D.22690>:
  ptr.131 = ptr;
  ptr.136 = ptr.131;
  ptr.137 = ptr.136 + 1;
  ptr = ptr.137;
  D.22694 = *ptr.136;
  D.22695 = (<unnamed type>) D.22694;
  res->data.array_data.elem_type = D.22695;
  <D.22691>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22696>; else goto <D.22697>;
  <D.22696>:
  ptr.131 = ptr;
  D.22698 = mono_metadata_decode_value (ptr.131, &ptr);
  D.22699 = (short int) D.22698;
  res->data.array_data.param_num = D.22699;
  <D.22697>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22700>; else goto <D.22701>;
  <D.22700>:
  ptr.131 = ptr;
  D.22702 = mono_metadata_decode_value (ptr.131, &ptr);
  D.22703 = (int) D.22702;
  res->data.array_data.num_elem = D.22703;
  <D.22701>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22704>; else goto <D.22705>;
  <D.22704>:
  ptr.131 = ptr;
  D.22706 = mono_metadata_decode_value (ptr.131, &ptr);
  D.22707 = (short int) D.22706;
  res->data.array_data.elem_mult = D.22707;
  <D.22705>:
  <D.22685>:
  D.22683 = res->native;
  if (D.22683 == 23) goto <D.22708>; else goto <D.22709>;
  <D.22708>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22710>; else goto <D.22711>;
  <D.22710>:
  ptr.131 = ptr;
  D.22712 = mono_metadata_decode_value (ptr.131, &ptr);
  D.22713 = (int) D.22712;
  res->data.array_data.num_elem = D.22713;
  <D.22711>:
  <D.22709>:
  D.22683 = res->native;
  if (D.22683 == 30) goto <D.22714>; else goto <D.22715>;
  <D.22714>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22716>; else goto <D.22717>;
  <D.22716>:
  ptr.131 = ptr;
  D.22718 = mono_metadata_decode_value (ptr.131, &ptr);
  D.22719 = (int) D.22718;
  res->data.array_data.num_elem = D.22719;
  <D.22717>:
  <D.22715>:
  D.22683 = res->native;
  if (D.22683 == 44) goto <D.22720>; else goto <D.22721>;
  <D.22720>:
  ptr.131 = ptr;
  D.22722 = mono_metadata_decode_value (ptr.131, &ptr);
  len = (int) D.22722;
  ptr.131 = ptr;
  D.22723 = (sizetype) len;
  ptr.138 = ptr.131 + D.22723;
  ptr = ptr.138;
  ptr.131 = ptr;
  D.22725 = mono_metadata_decode_value (ptr.131, &ptr);
  len = (int) D.22725;
  ptr.131 = ptr;
  D.22723 = (sizetype) len;
  ptr.138 = ptr.131 + D.22723;
  ptr = ptr.138;
  ptr.131 = ptr;
  D.22726 = mono_metadata_decode_value (ptr.131, &ptr);
  len = (int) D.22726;
  ptr.131 = ptr;
  len.139 = (unsigned int) len;
  D.22728 = mono_image_strndup (image, ptr.131, len.139);
  res->data.custom_data.custom_name = D.22728;
  ptr.131 = ptr;
  D.22723 = (sizetype) len;
  ptr.138 = ptr.131 + D.22723;
  ptr = ptr.138;
  ptr.131 = ptr;
  D.22729 = mono_metadata_decode_value (ptr.131, &ptr);
  len = (int) D.22729;
  ptr.131 = ptr;
  len.139 = (unsigned int) len;
  D.22730 = mono_image_strndup (image, ptr.131, len.139);
  res->data.custom_data.cookie = D.22730;
  <D.22721>:
  D.22683 = res->native;
  if (D.22683 == 29) goto <D.22731>; else goto <D.22732>;
  <D.22731>:
  res->data.safearray_data.elem_type = 0;
  res->data.safearray_data.num_elem = 0;
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22733>; else goto <D.22734>;
  <D.22733>:
  ptr.131 = ptr;
  ptr.140 = ptr.131;
  ptr.141 = ptr.140 + 1;
  ptr = ptr.141;
  D.22737 = *ptr.140;
  D.22738 = (<unnamed type>) D.22737;
  res->data.safearray_data.elem_type = D.22738;
  <D.22734>:
  ptr.131 = ptr;
  ptr.134 = (long int) ptr.131;
  start.135 = (long int) start;
  D.22688 = ptr.134 - start.135;
  D.22689 = (long int) len;
  if (D.22688 <= D.22689) goto <D.22739>; else goto <D.22740>;
  <D.22739>:
  ptr.131 = ptr;
  ptr.142 = ptr.131;
  ptr.143 = ptr.142 + 1;
  ptr = ptr.143;
  D.22743 = *ptr.142;
  D.22744 = (int) D.22743;
  res->data.safearray_data.num_elem = D.22744;
  <D.22740>:
  <D.22732>:
  D.22745 = res;
  return D.22745;
}


mono_image_strndup (struct MonoImage * image, const char * data, guint len)
{
  char * D.22749;
  long unsigned int D.22750;
  unsigned int D.22751;
  long unsigned int D.22752;
  sizetype D.22753;
  char * D.22754;
  char * res;

  if (image == 0B) goto <D.22747>; else goto <D.22748>;
  <D.22747>:
  D.22750 = (long unsigned int) len;
  D.22749 = monoeg_g_strndup (data, D.22750);
  return D.22749;
  <D.22748>:
  D.22751 = len + 1;
  res = mono_image_alloc (image, D.22751);
  D.22752 = (long unsigned int) len;
  memcpy (res, data, D.22752);
  D.22753 = (sizetype) len;
  D.22754 = res + D.22753;
  *D.22754 = 0;
  D.22749 = res;
  return D.22749;
}


mono_metadata_free_marshal_spec (struct MonoMarshalSpec * spec)
{
  <unnamed type> D.22756;
  char * D.22759;
  char * D.22760;

  D.22756 = spec->native;
  if (D.22756 == 44) goto <D.22757>; else goto <D.22758>;
  <D.22757>:
  D.22759 = spec->data.custom_data.custom_name;
  monoeg_g_free (D.22759);
  D.22760 = spec->data.custom_data.cookie;
  monoeg_g_free (D.22760);
  <D.22758>:
  monoeg_g_free (spec);
}


mono_type_to_unmanaged (struct MonoType * type, struct MonoMarshalSpec * mspec, gboolean as_field, gboolean unicode, MonoMarshalConv * conv)
{
  unsigned char D.22761;
  long unsigned int D.22764;
  long unsigned int D.22765;
  uint32_t D.22768;
  <unnamed type> D.22771;
  uint32_t iftmp.144;
  struct MonoClass * D.22785;
  long unsigned int D.22786;
  long unsigned int D.22787;
  struct MonoType * D.22790;
  unsigned char D.22791;
  struct MonoClass * D.22792;
  struct MonoClass * D.22799;
  struct MonoClass * D.22800;
  struct MonoClass * D.22809;
  struct MonoClass * D.22811;
  struct MonoClass * D.22813;
  struct MonoClass * D.22820;
  struct MonoGenericClass * D.22825;
  struct MonoClass * D.22826;
  MonoMarshalConv dummy_conv;
  int t;
  void handle_enum = <<< error >>>;

  try
    {
      D.22761 = type->type;
      t = (int) D.22761;
      if (conv == 0B) goto <D.22762>; else goto <D.22763>;
      <D.22762>:
      conv = &dummy_conv;
      <D.22763>:
      *conv = 0;
      D.22764 = BIT_FIELD_REF <*type, 64, 64>;
      D.22765 = D.22764 & 1073741824;
      if (D.22765 != 0) goto <D.22766>; else goto <D.22767>;
      <D.22766>:
      D.22768 = 32;
      return D.22768;
      <D.22767>:
      handle_enum:
      switch (t) <default: <D.19595>, case 2: <D.19539>, case 3: <D.19546>, case 4: <D.19551>, case 5: <D.19552>, case 6: <D.19553>, case 7: <D.19554>, case 8: <D.19555>, case 9: <D.19556>, case 10: <D.19557>, case 11: <D.19558>, case 12: <D.19559>, case 13: <D.19560>, case 14: <D.19561>, case 15: <D.19571>, case 17: <D.19572>, case 18: <D.19582>, case 20: <D.19574>, case 21: <D.19593>, case 22: <D.19594>, case 24: <D.19580>, case 25: <D.19581>, case 27: <D.19592>, case 28: <D.19583>, case 29: <D.19573>>
      <D.19539>:
      if (mspec != 0B) goto <D.22769>; else goto <D.22770>;
      <D.22769>:
      D.22771 = mspec->native;
      switch (D.22771) <default: <D.19544>, case 2: <D.19541>, case 3: <D.19542>, case 4: <D.19543>, case 37: <D.19540>>
      <D.19540>:
      *conv = 1;
      D.22768 = 37;
      return D.22768;
      <D.19541>:
      *conv = 2;
      D.22768 = 2;
      return D.22768;
      <D.19542>:
      <D.19543>:
      D.22768 = mspec->native;
      return D.22768;
      <D.19544>:
      D.22771 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal bool to native type %02x", D.22771);
      <D.19545>:
      goto <D.19545>;
      <D.22770>:
      *conv = 2;
      D.22768 = 2;
      return D.22768;
      <D.19546>:
      if (mspec != 0B) goto <D.22772>; else goto <D.22773>;
      <D.22772>:
      D.22771 = mspec->native;
      switch (D.22771) <default: <D.19549>, case 4: <D.19548>, case 6: <D.19547>>
      <D.19547>:
      <D.19548>:
      D.22768 = mspec->native;
      return D.22768;
      <D.19549>:
      D.22771 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal char to native type %02x", D.22771);
      <D.19550>:
      goto <D.19550>;
      <D.22773>:
      if (unicode != 0) goto <D.22775>; else goto <D.22776>;
      <D.22775>:
      iftmp.144 = 6;
      goto <D.22777>;
      <D.22776>:
      iftmp.144 = 4;
      <D.22777>:
      D.22768 = iftmp.144;
      return D.22768;
      <D.19551>:
      D.22768 = 3;
      return D.22768;
      <D.19552>:
      D.22768 = 4;
      return D.22768;
      <D.19553>:
      D.22768 = 5;
      return D.22768;
      <D.19554>:
      D.22768 = 6;
      return D.22768;
      <D.19555>:
      D.22768 = 7;
      return D.22768;
      <D.19556>:
      D.22768 = 8;
      return D.22768;
      <D.19557>:
      D.22768 = 9;
      return D.22768;
      <D.19558>:
      D.22768 = 10;
      return D.22768;
      <D.19559>:
      D.22768 = 11;
      return D.22768;
      <D.19560>:
      D.22768 = 12;
      return D.22768;
      <D.19561>:
      if (mspec != 0B) goto <D.22778>; else goto <D.22779>;
      <D.22778>:
      D.22771 = mspec->native;
      switch (D.22771) <default: <D.19569>, case 19: <D.19562>, case 20: <D.19563>, case 21: <D.19564>, case 22: <D.19565>, case 23: <D.19568>, case 35: <D.19566>, case 36: <D.19567>>
      <D.19562>:
      *conv = 3;
      D.22768 = 19;
      return D.22768;
      <D.19563>:
      *conv = 4;
      D.22768 = 20;
      return D.22768;
      <D.19564>:
      *conv = 7;
      D.22768 = 21;
      return D.22768;
      <D.19565>:
      *conv = 9;
      D.22768 = 22;
      return D.22768;
      <D.19566>:
      *conv = 10;
      D.22768 = 35;
      return D.22768;
      <D.19567>:
      *conv = 11;
      D.22768 = 36;
      return D.22768;
      <D.19568>:
      if (unicode != 0) goto <D.22780>; else goto <D.22781>;
      <D.22780>:
      *conv = 13;
      goto <D.22782>;
      <D.22781>:
      *conv = 12;
      <D.22782>:
      D.22768 = 23;
      return D.22768;
      <D.19569>:
      D.22771 = 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.22771);
      <D.19570>:
      goto <D.19570>;
      <D.22779>:
      if (unicode != 0) goto <D.22783>; else goto <D.22784>;
      <D.22783>:
      *conv = 7;
      D.22768 = 21;
      return D.22768;
      <D.22784>:
      *conv = 4;
      D.22768 = 20;
      return D.22768;
      <D.19571>:
      D.22768 = 32;
      return D.22768;
      <D.19572>:
      D.22785 = type->data.klass;
      D.22786 = BIT_FIELD_REF <*D.22785, 64, 256>;
      D.22787 = D.22786 & 16;
      if (D.22787 != 0) goto <D.22788>; else goto <D.22789>;
      <D.22788>:
      D.22785 = type->data.klass;
      D.22790 = mono_class_enum_basetype (D.22785);
      D.22791 = D.22790->type;
      t = (int) D.22791;
      goto handle_enum;
      <D.22789>:
      D.22785 = type->data.klass;
      D.22792 = mono_defaults.handleref_class;
      if (D.22785 == D.22792) goto <D.22793>; else goto <D.22794>;
      <D.22793>:
      *conv = 34;
      D.22768 = 31;
      return D.22768;
      <D.22794>:
      D.22768 = 27;
      return D.22768;
      <D.19573>:
      <D.19574>:
      if (mspec != 0B) goto <D.22795>; else goto <D.22796>;
      <D.22795>:
      D.22771 = mspec->native;
      switch (D.22771) <default: <D.19578>, case 29: <D.19576>, case 30: <D.19575>, case 42: <D.19577>>
      <D.19575>:
      D.22785 = type->data.klass;
      D.22799 = D.22785->element_class;
      D.22800 = mono_defaults.char_class;
      if (D.22799 == D.22800) goto <D.22801>; else goto <D.22797>;
      <D.22801>:
      if (unicode == 0) goto <D.22802>; else goto <D.22797>;
      <D.22802>:
      *conv = 21;
      goto <D.22798>;
      <D.22797>:
      *conv = 20;
      <D.22798>:
      D.22768 = 30;
      return D.22768;
      <D.19576>:
      *conv = 22;
      D.22768 = 29;
      return D.22768;
      <D.19577>:
      *conv = 23;
      D.22768 = 42;
      return D.22768;
      <D.19578>:
      D.22771 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal array as native type %02x", D.22771);
      <D.19579>:
      goto <D.19579>;
      <D.22796>:
      *conv = 23;
      D.22768 = 42;
      return D.22768;
      <D.19580>:
      D.22768 = 31;
      return D.22768;
      <D.19581>:
      D.22768 = 32;
      return D.22768;
      <D.19582>:
      <D.19583>:
      if (mspec != 0B) goto <D.22803>; else goto <D.22804>;
      <D.22803>:
      D.22771 = mspec->native;
      switch (D.22771) <default: <D.19590>, case 25: <D.19588>, case 26: <D.19587>, case 27: <D.19584>, case 28: <D.19586>, case 38: <D.19589>, case 44: <D.19585>>
      <D.19584>:
      D.22768 = 27;
      return D.22768;
      <D.19585>:
      D.22768 = 44;
      return D.22768;
      <D.19586>:
      *conv = 25;
      D.22768 = 28;
      return D.22768;
      <D.19587>:
      *conv = 26;
      D.22768 = 26;
      return D.22768;
      <D.19588>:
      *conv = 27;
      D.22768 = 25;
      return D.22768;
      <D.19589>:
      if (t == 18) goto <D.22807>; else goto <D.22808>;
      <D.22807>:
      D.22785 = type->data.klass;
      D.22809 = mono_defaults.multicastdelegate_class;
      if (D.22785 == D.22809) goto <D.22805>; else goto <D.22810>;
      <D.22810>:
      D.22785 = type->data.klass;
      D.22811 = mono_defaults.delegate_class;
      if (D.22785 == D.22811) goto <D.22805>; else goto <D.22812>;
      <D.22812>:
      D.22785 = type->data.klass;
      D.22813 = D.22785->parent;
      D.22809 = mono_defaults.multicastdelegate_class;
      if (D.22813 == D.22809) goto <D.22805>; else goto <D.22806>;
      <D.22805>:
      *conv = 29;
      D.22768 = 38;
      return D.22768;
      <D.22806>:
      <D.22808>:
      <D.19590>:
      D.22771 = mspec->native;
      monoeg_g_log (0B, 4, "cant marshal object as native type %02x", D.22771);
      <D.19591>:
      goto <D.19591>;
      <D.22804>:
      if (t == 18) goto <D.22816>; else goto <D.22817>;
      <D.22816>:
      D.22785 = type->data.klass;
      D.22809 = mono_defaults.multicastdelegate_class;
      if (D.22785 == D.22809) goto <D.22814>; else goto <D.22818>;
      <D.22818>:
      D.22785 = type->data.klass;
      D.22811 = mono_defaults.delegate_class;
      if (D.22785 == D.22811) goto <D.22814>; else goto <D.22819>;
      <D.22819>:
      D.22785 = type->data.klass;
      D.22813 = D.22785->parent;
      D.22809 = mono_defaults.multicastdelegate_class;
      if (D.22813 == D.22809) goto <D.22814>; else goto <D.22815>;
      <D.22814>:
      *conv = 29;
      D.22768 = 38;
      return D.22768;
      <D.22815>:
      <D.22817>:
      D.22820 = mono_defaults.safehandle_class;
      if (D.22820 != 0B) goto <D.22821>; else goto <D.22822>;
      <D.22821>:
      D.22785 = type->data.klass;
      D.22820 = mono_defaults.safehandle_class;
      if (D.22785 == D.22820) goto <D.22823>; else goto <D.22824>;
      <D.22823>:
      *conv = 33;
      D.22768 = 31;
      return D.22768;
      <D.22824>:
      <D.22822>:
      *conv = 28;
      D.22768 = 27;
      return D.22768;
      <D.19592>:
      D.22768 = 38;
      return D.22768;
      <D.19593>:
      D.22825 = type->data.generic_class;
      D.22826 = D.22825->container_class;
      type = &D.22826->byval_arg;
      D.22761 = type->type;
      t = (int) D.22761;
      goto handle_enum;
      <D.19594>:
      <D.19595>:
      monoeg_g_log (0B, 4, "type 0x%02x not handled in marshal", t);
      <D.19596>:
      goto <D.19596>;
      D.22768 = 80;
      return D.22768;
    }
  finally
    {
      dummy_conv = {CLOBBER};
    }
}


mono_metadata_get_marshal_info (struct MonoImage * meta, guint32 idx, gboolean is_field)
{
  const char * D.22829;
  const char * D.22832;
  unsigned int D.22833;
  unsigned int D.22834;
  _Bool D.22835;
  int D.22836;
  unsigned int D.22837;
  unsigned int D.22838;
  int D.22839;
  <unnamed-unsigned:24> D.22840;
  long unsigned int D.22841;
  unsigned char D.22842;
  long unsigned int D.22843;
  void * D.22844;
  unsigned int D.22847;
  int D.22848;
  unsigned int D.22849;
  struct locator_t loc;
  struct MonoTableInfo * tdef;

  try
    {
      tdef = &meta->tables[13];
      D.22829 = tdef->base;
      if (D.22829 == 0B) goto <D.22830>; else goto <D.22831>;
      <D.22830>:
      D.22832 = 0B;
      return D.22832;
      <D.22831>:
      loc.t = tdef;
      loc.col_idx = 0;
      D.22833 = idx + 1;
      D.22834 = D.22833 << 1;
      D.22835 = is_field == 0;
      D.22836 = (int) D.22835;
      D.22837 = (unsigned int) D.22836;
      D.22838 = D.22834 | D.22837;
      D.22839 = (int) D.22838;
      loc.idx = D.22839;
      D.22829 = tdef->base;
      D.22840 = tdef->rows;
      D.22841 = (long unsigned int) D.22840;
      D.22842 = tdef->row_size;
      D.22843 = (long unsigned int) D.22842;
      D.22844 = mono_binary_search (&loc, D.22829, D.22841, D.22843, table_locator);
      if (D.22844 == 0B) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      D.22832 = 0B;
      return D.22832;
      <D.22846>:
      D.22847 = loc.result;
      D.22848 = (int) D.22847;
      D.22849 = mono_metadata_decode_row_col (tdef, D.22848, 1);
      D.22832 = mono_metadata_blob_heap (meta, D.22849);
      return D.22832;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


method_from_method_def_or_ref (struct MonoImage * m, guint32 tok, struct MonoGenericContext * context)
{
  unsigned int D.22852;
  struct MonoMethod * D.22853;
  unsigned int D.22854;
  unsigned int D.22855;
  guint32 idx;

  idx = tok >> 1;
  D.22852 = tok & 1;
  switch (D.22852) <default: <D.22856>, case 0: <D.19610>, case 1: <D.19611>>
  <D.19610>:
  D.22854 = idx | 100663296;
  D.22853 = mono_get_method_full (m, D.22854, 0B, context);
  return D.22853;
  <D.19611>:
  D.22855 = idx | 167772160;
  D.22853 = mono_get_method_full (m, D.22855, 0B, context);
  return D.22853;
  <D.22856>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata.c", 5613);
  D.22853 = 0B;
  return D.22853;
}


mono_class_get_overrides_full (struct MonoImage * image, guint32 type_token, struct MonoMethod * * * overrides, gint32 * num_overrides, struct MonoGenericContext * generic_context)
{
  const char * D.22860;
  gboolean D.22863;
  int type_token.145;
  int D.22865;
  <unnamed-unsigned:24> D.22866;
  long unsigned int D.22867;
  unsigned char D.22868;
  long unsigned int D.22869;
  void * D.22870;
  int D.22873;
  unsigned int D.22874;
  unsigned int D.22875;
  int D.22876;
  unsigned int D.22877;
  int end.146;
  unsigned int D.22880;
  unsigned int D.22882;
  unsigned int D.22883;
  int D.22884;
  long unsigned int D.22885;
  long unsigned int D.22886;
  unsigned int i.147;
  unsigned int D.22888;
  int D.22889;
  int D.22892;
  unsigned int D.22893;
  int D.22896;
  long unsigned int D.22897;
  long unsigned int D.22898;
  struct MonoMethod * * D.22899;
  unsigned int D.22900;
  sizetype D.22903;
  sizetype D.22904;
  sizetype D.22905;
  struct MonoMethod * * D.22906;
  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.22858>; else goto <D.22859>;
      <D.22858>:
      *num_overrides = 0;
      <D.22859>:
      D.22860 = tdef->base;
      if (D.22860 == 0B) goto <D.22861>; else goto <D.22862>;
      <D.22861>:
      D.22863 = 1;
      return D.22863;
      <D.22862>:
      loc.t = tdef;
      loc.col_idx = 0;
      type_token.145 = (int) type_token;
      D.22865 = type_token.145 & 16777215;
      loc.idx = D.22865;
      D.22860 = tdef->base;
      D.22866 = tdef->rows;
      D.22867 = (long unsigned int) D.22866;
      D.22868 = tdef->row_size;
      D.22869 = (long unsigned int) D.22868;
      D.22870 = mono_binary_search (&loc, D.22860, D.22867, D.22869, table_locator);
      if (D.22870 == 0B) goto <D.22871>; else goto <D.22872>;
      <D.22871>:
      D.22863 = 1;
      return D.22863;
      <D.22872>:
      start = loc.result;
      end = start + 1;
      goto <D.19631>;
      <D.19630>:
      D.22873 = loc.idx;
      D.22874 = (unsigned int) D.22873;
      D.22875 = start + 4294967295;
      D.22876 = (int) D.22875;
      D.22877 = mono_metadata_decode_row_col (tdef, D.22876, 0);
      if (D.22874 == D.22877) goto <D.22878>; else goto <D.19629>;
      <D.22878>:
      start = start + 4294967295;
      <D.19631>:
      if (start != 0) goto <D.19630>; else goto <D.19629>;
      <D.19629>:
      goto <D.19634>;
      <D.19633>:
      D.22873 = loc.idx;
      D.22874 = (unsigned int) D.22873;
      end.146 = (int) end;
      D.22880 = mono_metadata_decode_row_col (tdef, end.146, 0);
      if (D.22874 == D.22880) goto <D.22881>; else goto <D.19632>;
      <D.22881>:
      end = end + 1;
      <D.19634>:
      D.22866 = tdef->rows;
      D.22882 = (unsigned int) D.22866;
      if (D.22882 > end) goto <D.19633>; else goto <D.19632>;
      <D.19632>:
      D.22883 = end - start;
      num = (gint32) D.22883;
      D.22884 = num * 2;
      D.22885 = (long unsigned int) D.22884;
      D.22886 = D.22885 * 8;
      result = monoeg_malloc (D.22886);
      i = 0;
      goto <D.19638>;
      <D.19637>:
      {
        struct MonoMethod * method;

        i.147 = (unsigned int) i;
        D.22888 = start + i.147;
        D.22889 = mono_verifier_verify_methodimpl_row (image, D.22888, &error);
        if (D.22889 == 0) goto <D.22890>; else goto <D.22891>;
        <D.22890>:
        mono_error_cleanup (&error);
        ok = 0;
        goto <D.19636>;
        <D.22891>:
        i.147 = (unsigned int) i;
        D.22888 = start + i.147;
        D.22892 = (int) D.22888;
        mono_metadata_decode_row (tdef, D.22892, &cols, 3);
        D.22893 = cols[2];
        method = method_from_method_def_or_ref (image, D.22893, generic_context);
        if (method == 0B) goto <D.22894>; else goto <D.22895>;
        <D.22894>:
        ok = 0;
        <D.22895>:
        D.22896 = i * 2;
        D.22897 = (long unsigned int) D.22896;
        D.22898 = D.22897 * 8;
        D.22899 = result + D.22898;
        *D.22899 = method;
        D.22900 = cols[1];
        method = method_from_method_def_or_ref (image, D.22900, generic_context);
        if (method == 0B) goto <D.22901>; else goto <D.22902>;
        <D.22901>:
        ok = 0;
        <D.22902>:
        D.22896 = i * 2;
        D.22903 = (sizetype) D.22896;
        D.22904 = D.22903 + 1;
        D.22905 = D.22904 * 8;
        D.22906 = result + D.22905;
        *D.22906 = method;
      }
      i = i + 1;
      <D.19638>:
      if (i < num) goto <D.19637>; else goto <D.19636>;
      <D.19636>:
      *overrides = result;
      if (num_overrides != 0B) goto <D.22907>; else goto <D.22908>;
      <D.22907>:
      *num_overrides = num;
      <D.22908>:
      D.22863 = ok;
      return D.22863;
    }
  finally
    {
      error = {CLOBBER};
      loc = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_guid_to_string (const guint8 * guid)
{
  char * D.22911;
  const guint8 * D.22912;
  unsigned char D.22913;
  int D.22914;
  const guint8 * D.22915;
  unsigned char D.22916;
  int D.22917;
  const guint8 * D.22918;
  unsigned char D.22919;
  int D.22920;
  unsigned char D.22921;
  int D.22922;
  const guint8 * D.22923;
  unsigned char D.22924;
  int D.22925;
  const guint8 * D.22926;
  unsigned char D.22927;
  int D.22928;
  const guint8 * D.22929;
  unsigned char D.22930;
  int D.22931;
  const guint8 * D.22932;
  unsigned char D.22933;
  int D.22934;
  const guint8 * D.22935;
  unsigned char D.22936;
  int D.22937;
  const guint8 * D.22938;
  unsigned char D.22939;
  int D.22940;
  const guint8 * D.22941;
  unsigned char D.22942;
  int D.22943;
  const guint8 * D.22944;
  unsigned char D.22945;
  int D.22946;
  const guint8 * D.22947;
  unsigned char D.22948;
  int D.22949;
  const guint8 * D.22950;
  unsigned char D.22951;
  int D.22952;
  const guint8 * D.22953;
  unsigned char D.22954;
  int D.22955;
  const guint8 * D.22956;
  unsigned char D.22957;
  int D.22958;

  D.22912 = guid + 3;
  D.22913 = *D.22912;
  D.22914 = (int) D.22913;
  D.22915 = guid + 2;
  D.22916 = *D.22915;
  D.22917 = (int) D.22916;
  D.22918 = guid + 1;
  D.22919 = *D.22918;
  D.22920 = (int) D.22919;
  D.22921 = *guid;
  D.22922 = (int) D.22921;
  D.22923 = guid + 5;
  D.22924 = *D.22923;
  D.22925 = (int) D.22924;
  D.22926 = guid + 4;
  D.22927 = *D.22926;
  D.22928 = (int) D.22927;
  D.22929 = guid + 7;
  D.22930 = *D.22929;
  D.22931 = (int) D.22930;
  D.22932 = guid + 6;
  D.22933 = *D.22932;
  D.22934 = (int) D.22933;
  D.22935 = guid + 8;
  D.22936 = *D.22935;
  D.22937 = (int) D.22936;
  D.22938 = guid + 9;
  D.22939 = *D.22938;
  D.22940 = (int) D.22939;
  D.22941 = guid + 10;
  D.22942 = *D.22941;
  D.22943 = (int) D.22942;
  D.22944 = guid + 11;
  D.22945 = *D.22944;
  D.22946 = (int) D.22945;
  D.22947 = guid + 12;
  D.22948 = *D.22947;
  D.22949 = (int) D.22948;
  D.22950 = guid + 13;
  D.22951 = *D.22950;
  D.22952 = (int) D.22951;
  D.22953 = guid + 14;
  D.22954 = *D.22953;
  D.22955 = (int) D.22954;
  D.22956 = guid + 15;
  D.22957 = *D.22956;
  D.22958 = (int) D.22957;
  D.22911 = monoeg_g_strdup_printf ("%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", D.22914, D.22917, D.22920, D.22922, D.22925, D.22928, D.22931, D.22934, D.22937, D.22940, D.22943, D.22946, D.22949, D.22952, D.22955, D.22958);
  return D.22911;
}


mono_metadata_get_generic_param_row (struct MonoImage * image, guint32 token, guint32 * owner)
{
  _Bool D.22960;
  long int D.22961;
  long int D.22962;
  const char * D.22965;
  guint32 D.22968;
  unsigned int D.22969;
  unsigned int D.22976;
  unsigned int D.22977;
  unsigned int D.22978;
  unsigned int D.22979;
  int D.22980;
  <unnamed-unsigned:24> D.22981;
  long unsigned int D.22982;
  unsigned char D.22983;
  long unsigned int D.22984;
  void * D.22985;
  unsigned int D.22988;
  unsigned int D.22989;
  int D.22991;
  unsigned int D.22992;
  int D.22993;
  unsigned int D.22994;
  struct MonoTableInfo * tdef;
  struct locator_t loc;

  try
    {
      tdef = &image->tables[42];
      D.22960 = owner == 0B;
      D.22961 = (long int) D.22960;
      D.22962 = __builtin_expect (D.22961, 0);
      if (D.22962 != 0) goto <D.22963>; else goto <D.22964>;
      <D.22963>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5771, "owner");
      <D.22964>:
      D.22965 = tdef->base;
      if (D.22965 == 0B) goto <D.22966>; else goto <D.22967>;
      <D.22966>:
      D.22968 = 0;
      return D.22968;
      <D.22967>:
      D.22969 = token >> 24;
      if (D.22969 == 2) goto <D.22970>; else goto <D.22971>;
      <D.22970>:
      *owner = 0;
      goto <D.22972>;
      <D.22971>:
      D.22969 = token >> 24;
      if (D.22969 == 6) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      *owner = 1;
      goto <D.22975>;
      <D.22974>:
      monoeg_g_log (0B, 4, "wrong token %x to get_generic_param_row", token);
      <D.19671>:
      goto <D.19671>;
      D.22968 = 0;
      return D.22968;
      <D.22975>:
      <D.22972>:
      D.22976 = *owner;
      D.22977 = token & 16777215;
      D.22978 = D.22977 << 1;
      D.22979 = D.22976 | D.22978;
      *owner = D.22979;
      D.22976 = *owner;
      D.22980 = (int) D.22976;
      loc.idx = D.22980;
      loc.col_idx = 2;
      loc.t = tdef;
      D.22965 = tdef->base;
      D.22981 = tdef->rows;
      D.22982 = (long unsigned int) D.22981;
      D.22983 = tdef->row_size;
      D.22984 = (long unsigned int) D.22983;
      D.22985 = mono_binary_search (&loc, D.22965, D.22982, D.22984, table_locator);
      if (D.22985 == 0B) goto <D.22986>; else goto <D.22987>;
      <D.22986>:
      D.22968 = 0;
      return D.22968;
      <D.22987>:
      goto <D.19673>;
      <D.19672>:
      D.22988 = loc.result;
      D.22989 = D.22988 + 4294967295;
      loc.result = D.22989;
      <D.19673>:
      D.22988 = loc.result;
      if (D.22988 != 0) goto <D.22990>; else goto <D.19674>;
      <D.22990>:
      D.22988 = loc.result;
      D.22989 = D.22988 + 4294967295;
      D.22991 = (int) D.22989;
      D.22992 = mono_metadata_decode_row_col (tdef, D.22991, 2);
      D.22993 = loc.idx;
      D.22994 = (unsigned int) D.22993;
      if (D.22992 == D.22994) goto <D.19672>; else goto <D.19674>;
      <D.19674>:
      D.22988 = loc.result;
      D.22968 = D.22988 + 1;
      return D.22968;
    }
  finally
    {
      loc = {CLOBBER};
    }
}


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

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


mono_metadata_load_generic_param_constraints_full (struct MonoImage * image, guint32 token, struct MonoGenericContainer * container)
{
  gboolean D.23003;
  unsigned int D.23004;
  int D.23005;
  struct MonoGenericParamFull * D.23006;
  long unsigned int D.23007;
  long unsigned int D.23008;
  struct MonoGenericParamFull * D.23009;
  struct MonoClass * * * D.23010;
  int D.23011;
  <unnamed-signed:31> D.23014;
  unsigned int D.23015;
  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.23001>; else goto <D.23002>;
      <D.23001>:
      D.23003 = 1;
      return D.23003;
      <D.23002>:
      i = 0;
      goto <D.19689>;
      <D.19688>:
      D.23004 = start_row + i;
      D.23005 = (int) D.23004;
      D.23006 = container->type_params;
      D.23007 = (long unsigned int) i;
      D.23008 = D.23007 * 56;
      D.23009 = D.23006 + D.23008;
      D.23010 = &D.23009->info.constraints;
      D.23011 = get_constraints (image, D.23005, D.23010, container);
      if (D.23011 == 0) goto <D.23012>; else goto <D.23013>;
      <D.23012>:
      D.23003 = 0;
      return D.23003;
      <D.23013>:
      i = i + 1;
      <D.19689>:
      D.23014 = container->type_argc;
      D.23015 = (unsigned int) D.23014;
      if (D.23015 > i) goto <D.19688>; else goto <D.19690>;
      <D.19690>:
      D.23003 = 1;
      return D.23003;
    }
  finally
    {
      owner = {CLOBBER};
    }
}


get_constraints (struct MonoImage * image, int owner, struct MonoClass * * * constraints, struct MonoGenericContainer * container)
{
  int i.148;
  unsigned int D.23019;
  unsigned int owner.149;
  unsigned int D.23023;
  gboolean D.23026;
  <unnamed-unsigned:24> D.23029;
  unsigned int D.23030;
  unsigned int D.23033;
  unsigned int D.23034;
  long unsigned int D.23035;
  long unsigned int D.23036;
  struct MonoClass * * D.23037;
  void * D.23038;
  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.19660>;
      <D.19659>:
      i.148 = (int) i;
      mono_metadata_decode_row (tdef, i.148, &cols, 2);
      D.23019 = cols[0];
      owner.149 = (unsigned int) owner;
      if (D.23019 == owner.149) goto <D.23021>; else goto <D.23022>;
      <D.23021>:
      D.23023 = cols[1];
      token = mono_metadata_token_from_dor (D.23023);
      klass = mono_class_get_full (image, token, context);
      if (klass == 0B) goto <D.23024>; else goto <D.23025>;
      <D.23024>:
      monoeg_g_slist_free (cons);
      D.23026 = 0;
      return D.23026;
      <D.23025>:
      cons = monoeg_g_slist_append (cons, klass);
      found = found + 1;
      goto <D.23027>;
      <D.23022>:
      if (found != 0) goto <D.19658>; else goto <D.23028>;
      <D.23028>:
      <D.23027>:
      i = i + 1;
      <D.19660>:
      D.23029 = tdef->rows;
      D.23030 = (unsigned int) D.23029;
      if (D.23030 > i) goto <D.19659>; else goto <D.19658>;
      <D.19658>:
      if (found == 0) goto <D.23031>; else goto <D.23032>;
      <D.23031>:
      D.23026 = 1;
      return D.23026;
      <D.23032>:
      D.23033 = found + 1;
      D.23034 = D.23033 * 8;
      res = mono_image_alloc0 (image, D.23034);
      i = 0;
      tmp = cons;
      goto <D.19662>;
      <D.19661>:
      D.23035 = (long unsigned int) i;
      D.23036 = D.23035 * 8;
      D.23037 = res + D.23036;
      D.23038 = tmp->data;
      *D.23037 = D.23038;
      i = i + 1;
      tmp = tmp->next;
      <D.19662>:
      if (i < found) goto <D.19661>; else goto <D.19663>;
      <D.19663>:
      monoeg_g_slist_free (cons);
      *constraints = res;
      D.23026 = 1;
      return D.23026;
    }
  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.23043;
  unsigned int D.23044;
  int D.23045;
  long unsigned int D.23046;
  long unsigned int D.23047;
  unsigned int D.23048;
  long unsigned int D.23049;
  long unsigned int D.23050;
  void * D.23051;
  struct MonoGenericParamFull * D.23052;
  unsigned int D.23053;
  short unsigned int D.23054;
  unsigned int D.23055;
  unsigned int D.23056;
  short unsigned int D.23057;
  unsigned int D.23058;
  const char * D.23059;
  short unsigned int D.23060;
  unsigned int D.23061;
  <unnamed-unsigned:24> D.23064;
  unsigned int D.23065;
  unsigned int D.23067;
  unsigned int owner.150;
  int n.151;
  <unnamed-signed:31> D.23070;
  unsigned int D.23071;
  void * D.23072;
  struct MonoGenericParamFull * D.23073;
  unsigned int D.23074;
  int iftmp.152;
  struct MonoGenericContainer * D.23080;
  long unsigned int D.23082;
  long unsigned int D.23083;
  _Bool D.23085;
  long int D.23086;
  long int D.23087;
  struct MonoGenericInst * iftmp.153;
  struct MonoGenericInst * D.23096;
  struct MonoGenericInst * D.23098;
  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.23041>; else goto <D.23042>;
      <D.23041>:
      D.23043 = 0B;
      return D.23043;
      <D.23042>:
      D.23044 = i + 4294967295;
      D.23045 = (int) D.23044;
      mono_metadata_decode_row (tdef, D.23045, &cols, 4);
      params = 0B;
      n = 0;
      container = mono_image_alloc0 (image, 56);
      container->image = image;
      <D.19710>:
      n = n + 1;
      D.23046 = (long unsigned int) n;
      D.23047 = D.23046 * 56;
      params = monoeg_realloc (params, D.23047);
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23051 = params + D.23050;
      memset (D.23051, 0, 56);
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23052->param.owner = container;
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23053 = cols[0];
      D.23054 = (short unsigned int) D.23053;
      D.23052->param.num = D.23054;
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23055 = i | 704643072;
      D.23052->info.token = D.23055;
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23056 = cols[1];
      D.23057 = (short unsigned int) D.23056;
      D.23052->info.flags = D.23057;
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23058 = cols[3];
      D.23059 = mono_metadata_string_heap (image, D.23058);
      D.23052->info.name = D.23059;
      D.23048 = n + 4294967295;
      D.23049 = (long unsigned int) D.23048;
      D.23050 = D.23049 * 56;
      D.23052 = params + D.23050;
      D.23060 = D.23052->param.num;
      D.23061 = (unsigned int) D.23060;
      D.23048 = n + 4294967295;
      if (D.23061 != D.23048) goto <D.23062>; else goto <D.23063>;
      <D.23062>:
      monoeg_g_log (0B, 16, "GenericParam table unsorted or hole in generic param sequence: token %d", i);
      <D.23063>:
      i = i + 1;
      D.23064 = tdef->rows;
      D.23065 = (unsigned int) D.23064;
      if (i > D.23065) goto <D.19709>; else goto <D.23066>;
      <D.23066>:
      D.23044 = i + 4294967295;
      D.23045 = (int) D.23044;
      mono_metadata_decode_row (tdef, D.23045, &cols, 4);
      D.23067 = cols[2];
      owner.150 = owner;
      if (D.23067 == owner.150) goto <D.19710>; else goto <D.19709>;
      <D.19709>:
      n.151 = (int) n;
      D.23070 = (<unnamed-signed:31>) n.151;
      container->type_argc = D.23070;
      D.23071 = n * 56;
      D.23072 = mono_image_alloc0 (image, D.23071);
      container->type_params = D.23072;
      D.23073 = container->type_params;
      D.23046 = (long unsigned int) n;
      D.23047 = D.23046 * 56;
      memcpy (D.23073, params, D.23047);
      monoeg_g_free (params);
      container->parent = parent_container;
      D.23074 = token >> 24;
      if (D.23074 == 6) goto <D.23075>; else goto <D.23076>;
      <D.23075>:
      container->is_method = -1;
      <D.23076>:
      D.23080 = container->parent;
      if (D.23080 != 0B) goto <D.23081>; else goto <D.23078>;
      <D.23081>:
      D.23082 = BIT_FIELD_REF <*container, 64, 256>;
      D.23083 = D.23082 & 2147483648;
      if (D.23083 == 0) goto <D.23084>; else goto <D.23078>;
      <D.23084>:
      iftmp.152 = 1;
      goto <D.23079>;
      <D.23078>:
      iftmp.152 = 0;
      <D.23079>:
      D.23085 = iftmp.152 != 0;
      D.23086 = (long int) D.23085;
      D.23087 = __builtin_expect (D.23086, 0);
      if (D.23087 != 0) goto <D.23088>; else goto <D.23089>;
      <D.23088>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5903, "container->parent == NULL || container->is_method");
      <D.23089>:
      context = &container->context;
      D.23082 = BIT_FIELD_REF <*container, 64, 256>;
      D.23083 = D.23082 & 2147483648;
      if (D.23083 != 0) goto <D.23090>; else goto <D.23091>;
      <D.23090>:
      D.23080 = container->parent;
      if (D.23080 != 0B) goto <D.23093>; else goto <D.23094>;
      <D.23093>:
      D.23080 = container->parent;
      iftmp.153 = D.23080->context.class_inst;
      goto <D.23095>;
      <D.23094>:
      iftmp.153 = 0B;
      <D.23095>:
      context->class_inst = iftmp.153;
      D.23096 = mono_get_shared_generic_inst (container);
      context->method_inst = D.23096;
      goto <D.23097>;
      <D.23091>:
      D.23098 = mono_get_shared_generic_inst (container);
      context->class_inst = D.23098;
      <D.23097>:
      D.23043 = container;
      return D.23043;
    }
  finally
    {
      cols = {CLOBBER};
      owner = {CLOBBER};
    }
}


mono_get_shared_generic_inst (struct MonoGenericContainer * container)
{
  <unnamed-signed:31> D.23101;
  long unsigned int D.23102;
  long unsigned int D.23103;
  long unsigned int D.23104;
  long unsigned int D.23105;
  long unsigned int D.23106;
  unsigned char iftmp.154;
  long unsigned int D.23108;
  long unsigned int D.23109;
  struct MonoGenericParamFull * D.23113;
  long unsigned int D.23114;
  struct MonoGenericParam * D.23115;
  long unsigned int D.23116;
  struct MonoType * * D.23117;
  int D.23118;
  struct MonoGenericInst * D.23119;
  struct MonoType * * type_argv;
  struct MonoType * helper;
  struct MonoGenericInst * nginst;
  int i;

  D.23101 = container->type_argc;
  D.23102 = (long unsigned int) D.23101;
  D.23103 = D.23102 * 8;
  type_argv = monoeg_malloc0 (D.23103);
  D.23101 = container->type_argc;
  D.23102 = (long unsigned int) D.23101;
  D.23104 = D.23102 * 16;
  helper = monoeg_malloc0 (D.23104);
  i = 0;
  goto <D.19720>;
  <D.19719>:
  {
    struct MonoType * t;

    D.23105 = (long unsigned int) i;
    D.23106 = D.23105 * 16;
    t = helper + D.23106;
    D.23108 = BIT_FIELD_REF <*container, 64, 256>;
    D.23109 = D.23108 & 2147483648;
    if (D.23109 != 0) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    iftmp.154 = 30;
    goto <D.23112>;
    <D.23111>:
    iftmp.154 = 19;
    <D.23112>:
    t->type = iftmp.154;
    D.23113 = container->type_params;
    D.23105 = (long unsigned int) i;
    D.23114 = D.23105 * 56;
    D.23115 = D.23113 + D.23114;
    t->data.generic_param = D.23115;
    D.23105 = (long unsigned int) i;
    D.23116 = D.23105 * 8;
    D.23117 = type_argv + D.23116;
    *D.23117 = t;
  }
  i = i + 1;
  <D.19720>:
  D.23101 = container->type_argc;
  D.23118 = (int) D.23101;
  if (D.23118 > i) goto <D.19719>; else goto <D.19721>;
  <D.19721>:
  D.23101 = container->type_argc;
  D.23118 = (int) D.23101;
  nginst = mono_metadata_get_generic_inst (D.23118, type_argv);
  monoeg_g_free (type_argv);
  monoeg_g_free (helper);
  D.23119 = nginst;
  return D.23119;
}


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

  D.23122 = type->byref;
  D.23121 = (mono_bool) D.23122;
  return D.23121;
}


mono_type_get_type (struct MonoType * type)
{
  int D.23124;
  unsigned char D.23125;

  D.23125 = type->type;
  D.23124 = (int) D.23125;
  return D.23124;
}


mono_type_get_signature (struct MonoType * type)
{
  unsigned char D.23127;
  _Bool D.23128;
  long int D.23129;
  long int D.23130;
  struct MonoMethodSignature * D.23133;

  D.23127 = type->type;
  D.23128 = D.23127 != 27;
  D.23129 = (long int) D.23128;
  D.23130 = __builtin_expect (D.23129, 0);
  if (D.23130 != 0) goto <D.23131>; else goto <D.23132>;
  <D.23131>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 5982, "type->type == MONO_TYPE_FNPTR");
  <D.23132>:
  D.23133 = type->data.method;
  return D.23133;
}


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

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


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

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


mono_type_get_ptr_type (struct MonoType * type)
{
  unsigned char D.23139;
  _Bool D.23140;
  long int D.23141;
  long int D.23142;
  struct MonoType * D.23145;

  D.23139 = type->type;
  D.23140 = D.23139 != 15;
  D.23141 = (long int) D.23140;
  D.23142 = __builtin_expect (D.23141, 0);
  if (D.23142 != 0) goto <D.23143>; else goto <D.23144>;
  <D.23143>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6032, "type->type == MONO_TYPE_PTR");
  <D.23144>:
  D.23145 = type->data.type;
  return D.23145;
}


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

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


mono_type_is_struct (struct MonoType * type)
{
  mono_bool D.23149;
  int iftmp.155;
  long unsigned int D.23155;
  long unsigned int D.23156;
  unsigned char D.23158;
  struct MonoClass * D.23160;
  long unsigned int D.23161;
  long unsigned int D.23162;
  struct MonoGenericClass * D.23165;
  int D.23166;
  struct MonoClass * D.23168;
  long unsigned int D.23169;
  long unsigned int D.23170;

  D.23155 = BIT_FIELD_REF <*type, 64, 64>;
  D.23156 = D.23155 & 1073741824;
  if (D.23156 == 0) goto <D.23157>; else goto <D.23151>;
  <D.23157>:
  D.23158 = type->type;
  if (D.23158 == 17) goto <D.23159>; else goto <D.23152>;
  <D.23159>:
  D.23160 = type->data.klass;
  D.23161 = BIT_FIELD_REF <*D.23160, 64, 256>;
  D.23162 = D.23161 & 16;
  if (D.23162 == 0) goto <D.23153>; else goto <D.23152>;
  <D.23152>:
  D.23158 = type->type;
  if (D.23158 == 22) goto <D.23153>; else goto <D.23163>;
  <D.23163>:
  D.23158 = type->type;
  if (D.23158 == 21) goto <D.23164>; else goto <D.23151>;
  <D.23164>:
  D.23165 = type->data.generic_class;
  D.23166 = mono_metadata_generic_class_is_valuetype (D.23165);
  if (D.23166 != 0) goto <D.23167>; else goto <D.23151>;
  <D.23167>:
  D.23165 = type->data.generic_class;
  D.23168 = D.23165->container_class;
  D.23169 = BIT_FIELD_REF <*D.23168, 64, 256>;
  D.23170 = D.23169 & 16;
  if (D.23170 == 0) goto <D.23153>; else goto <D.23151>;
  <D.23153>:
  iftmp.155 = 1;
  goto <D.23154>;
  <D.23151>:
  iftmp.155 = 0;
  <D.23154>:
  D.23149 = iftmp.155;
  return D.23149;
}


mono_type_is_void (struct MonoType * type)
{
  mono_bool D.23172;
  int iftmp.156;
  long unsigned int D.23177;
  long unsigned int D.23178;

  if (type != 0B) goto <D.23176>; else goto <D.23174>;
  <D.23176>:
  D.23177 = BIT_FIELD_REF <*type, 64, 64>;
  D.23178 = D.23177 & 1090453504;
  if (D.23178 == 65536) goto <D.23179>; else goto <D.23174>;
  <D.23179>:
  iftmp.156 = 1;
  goto <D.23175>;
  <D.23174>:
  iftmp.156 = 0;
  <D.23175>:
  D.23172 = iftmp.156;
  return D.23172;
}


mono_type_is_pointer (struct MonoType * type)
{
  mono_bool D.23181;
  int iftmp.157;
  long unsigned int D.23187;
  long unsigned int D.23188;
  unsigned char D.23190;

  if (type != 0B) goto <D.23186>; else goto <D.23183>;
  <D.23186>:
  D.23187 = BIT_FIELD_REF <*type, 64, 64>;
  D.23188 = D.23187 & 1073741824;
  if (D.23188 != 0) goto <D.23184>; else goto <D.23189>;
  <D.23189>:
  D.23190 = type->type;
  if (D.23190 == 24) goto <D.23184>; else goto <D.23191>;
  <D.23191>:
  D.23190 = type->type;
  if (D.23190 == 14) goto <D.23184>; else goto <D.23192>;
  <D.23192>:
  D.23190 = type->type;
  if (D.23190 == 29) goto <D.23184>; else goto <D.23193>;
  <D.23193>:
  D.23190 = type->type;
  if (D.23190 == 18) goto <D.23184>; else goto <D.23194>;
  <D.23194>:
  D.23190 = type->type;
  if (D.23190 == 25) goto <D.23184>; else goto <D.23195>;
  <D.23195>:
  D.23190 = type->type;
  if (D.23190 == 28) goto <D.23184>; else goto <D.23196>;
  <D.23196>:
  D.23190 = type->type;
  if (D.23190 == 20) goto <D.23184>; else goto <D.23197>;
  <D.23197>:
  D.23190 = type->type;
  if (D.23190 == 15) goto <D.23184>; else goto <D.23198>;
  <D.23198>:
  D.23190 = type->type;
  if (D.23190 == 27) goto <D.23184>; else goto <D.23183>;
  <D.23184>:
  iftmp.157 = 1;
  goto <D.23185>;
  <D.23183>:
  iftmp.157 = 0;
  <D.23185>:
  D.23181 = iftmp.157;
  return D.23181;
}


mono_type_is_reference (struct MonoType * type)
{
  mono_bool D.23200;
  int iftmp.158;
  unsigned char D.23206;
  struct MonoGenericClass * D.23213;
  int D.23214;

  if (type != 0B) goto <D.23205>; else goto <D.23202>;
  <D.23205>:
  D.23206 = type->type;
  if (D.23206 == 14) goto <D.23203>; else goto <D.23207>;
  <D.23207>:
  D.23206 = type->type;
  if (D.23206 == 29) goto <D.23203>; else goto <D.23208>;
  <D.23208>:
  D.23206 = type->type;
  if (D.23206 == 18) goto <D.23203>; else goto <D.23209>;
  <D.23209>:
  D.23206 = type->type;
  if (D.23206 == 28) goto <D.23203>; else goto <D.23210>;
  <D.23210>:
  D.23206 = type->type;
  if (D.23206 == 20) goto <D.23203>; else goto <D.23211>;
  <D.23211>:
  D.23206 = type->type;
  if (D.23206 == 21) goto <D.23212>; else goto <D.23202>;
  <D.23212>:
  D.23213 = type->data.generic_class;
  D.23214 = mono_metadata_generic_class_is_valuetype (D.23213);
  if (D.23214 == 0) goto <D.23203>; else goto <D.23202>;
  <D.23203>:
  iftmp.158 = 1;
  goto <D.23204>;
  <D.23202>:
  iftmp.158 = 0;
  <D.23204>:
  D.23200 = iftmp.158;
  return D.23200;
}


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

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


mono_signature_get_params (struct MonoMethodSignature * sig, void * * iter)
{
  struct MonoType * D.23220;
  void * D.23221;
  short unsigned int D.23224;
  struct MonoType * * D.23227;
  int D.23228;
  struct MonoType * * D.23229;
  struct MonoType * * type;

  if (iter == 0B) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  D.23220 = 0B;
  return D.23220;
  <D.23219>:
  D.23221 = *iter;
  if (D.23221 == 0B) goto <D.23222>; else goto <D.23223>;
  <D.23222>:
  D.23224 = sig->param_count;
  if (D.23224 != 0) goto <D.23225>; else goto <D.23226>;
  <D.23225>:
  D.23227 = &sig->params[0];
  *iter = D.23227;
  D.23220 = sig->params[0];
  return D.23220;
  <D.23226>:
  D.23220 = 0B;
  return D.23220;
  <D.23223>:
  type = *iter;
  type = type + 8;
  D.23224 = sig->param_count;
  D.23228 = (int) D.23224;
  D.23229 = &sig->params[D.23228];
  if (D.23229 > type) goto <D.23230>; else goto <D.23231>;
  <D.23230>:
  *iter = type;
  D.23220 = *type;
  return D.23220;
  <D.23231>:
  D.23220 = 0B;
  return D.23220;
}


mono_signature_get_param_count (struct MonoMethodSignature * sig)
{
  uint32_t D.23233;
  short unsigned int D.23234;

  D.23234 = sig->param_count;
  D.23233 = (uint32_t) D.23234;
  return D.23233;
}


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

  D.23237 = sig->call_convention;
  D.23236 = (uint32_t) D.23237;
  return D.23236;
}


mono_signature_vararg_start (struct MonoMethodSignature * sig)
{
  int D.23239;
  short int D.23240;

  D.23240 = sig->sentinelpos;
  D.23239 = (int) D.23240;
  return D.23239;
}


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

  D.23243 = sig->hasthis;
  D.23242 = (mono_bool) D.23243;
  return D.23242;
}


mono_signature_param_is_out (struct MonoMethodSignature * sig, int param_num)
{
  int iftmp.159;
  short unsigned int D.23250;
  int D.23251;
  _Bool D.23252;
  long int D.23253;
  long int D.23254;
  mono_bool D.23257;
  struct MonoType * D.23258;
  short unsigned int D.23259;
  int D.23260;
  int D.23261;
  _Bool D.23262;

  if (param_num < 0) goto <D.23246>; else goto <D.23249>;
  <D.23249>:
  D.23250 = sig->param_count;
  D.23251 = (int) D.23250;
  if (D.23251 <= param_num) goto <D.23246>; else goto <D.23247>;
  <D.23246>:
  iftmp.159 = 1;
  goto <D.23248>;
  <D.23247>:
  iftmp.159 = 0;
  <D.23248>:
  D.23252 = iftmp.159 != 0;
  D.23253 = (long int) D.23252;
  D.23254 = __builtin_expect (D.23253, 0);
  if (D.23254 != 0) goto <D.23255>; else goto <D.23256>;
  <D.23255>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata.c", 6215, "param_num >= 0 && param_num < sig->param_count");
  <D.23256>:
  D.23258 = sig->params[param_num];
  D.23259 = D.23258->attrs;
  D.23260 = (int) D.23259;
  D.23261 = D.23260 & 2;
  D.23262 = D.23261 != 0;
  D.23257 = (mono_bool) D.23262;
  return D.23257;
}


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

  D.23265 = sig->explicit_this;
  D.23264 = (mono_bool) D.23265;
  return D.23264;
}


mono_aligned_addr_hash (const void * ptr)
{
  guint D.23267;
  long int ptr.160;
  unsigned int D.23269;

  ptr.160 = (long int) ptr;
  D.23269 = (unsigned int) ptr.160;
  D.23267 = D.23269 >> 3;
  return D.23267;
}


mono_metadata_get_corresponding_field_from_generic_type_definition (struct MonoClassField * field)
{
  struct MonoClass * D.23271;
  struct MonoGenericClass * D.23272;
  struct MonoClassField * D.23275;
  long int field.161;
  struct MonoClassField * D.23277;
  long int D.23278;
  long int D.23279;
  long int D.23280;
  struct MonoClassField * D.23281;
  long unsigned int D.23282;
  long unsigned int D.23283;
  struct MonoClass * gtd;
  int offset;

  D.23271 = field->parent;
  D.23272 = D.23271->generic_class;
  if (D.23272 == 0B) goto <D.23273>; else goto <D.23274>;
  <D.23273>:
  D.23275 = field;
  return D.23275;
  <D.23274>:
  D.23271 = field->parent;
  D.23272 = D.23271->generic_class;
  gtd = D.23272->container_class;
  field.161 = (long int) field;
  D.23271 = field->parent;
  D.23277 = D.23271->fields;
  D.23278 = (long int) D.23277;
  D.23279 = field.161 - D.23278;
  D.23280 = D.23279 /[ex] 32;
  offset = (int) D.23280;
  D.23281 = gtd->fields;
  D.23282 = (long unsigned int) offset;
  D.23283 = D.23282 * 32;
  D.23275 = D.23281 + D.23283;
  return D.23275;
}


mono_metadata_get_corresponding_event_from_generic_type_definition (struct MonoEvent * event)
{
  struct MonoClass * D.23285;
  struct MonoGenericClass * D.23286;
  struct MonoEvent * D.23289;
  long int event.162;
  struct MonoClassExt * D.23291;
  struct MonoEvent * D.23292;
  long int D.23293;
  long int D.23294;
  long int D.23295;
  struct MonoClassExt * D.23296;
  struct MonoEvent * D.23297;
  long unsigned int D.23298;
  long unsigned int D.23299;
  struct MonoClass * gtd;
  int offset;

  D.23285 = event->parent;
  D.23286 = D.23285->generic_class;
  if (D.23286 == 0B) goto <D.23287>; else goto <D.23288>;
  <D.23287>:
  D.23289 = event;
  return D.23289;
  <D.23288>:
  D.23285 = event->parent;
  D.23286 = D.23285->generic_class;
  gtd = D.23286->container_class;
  event.162 = (long int) event;
  D.23285 = event->parent;
  D.23291 = D.23285->ext;
  D.23292 = D.23291->events;
  D.23293 = (long int) D.23292;
  D.23294 = event.162 - D.23293;
  D.23295 = D.23294 /[ex] 56;
  offset = (int) D.23295;
  D.23296 = gtd->ext;
  D.23297 = D.23296->events;
  D.23298 = (long unsigned int) offset;
  D.23299 = D.23298 * 56;
  D.23289 = D.23297 + D.23299;
  return D.23289;
}


mono_metadata_get_corresponding_property_from_generic_type_definition (struct MonoProperty * property)
{
  struct MonoClass * D.23301;
  struct MonoGenericClass * D.23302;
  struct MonoProperty * D.23305;
  long int property.163;
  struct MonoClassExt * D.23307;
  struct MonoProperty * D.23308;
  long int D.23309;
  long int D.23310;
  long int D.23311;
  struct MonoClassExt * D.23312;
  struct MonoProperty * D.23313;
  long unsigned int D.23314;
  long unsigned int D.23315;
  struct MonoClass * gtd;
  int offset;

  D.23301 = property->parent;
  D.23302 = D.23301->generic_class;
  if (D.23302 == 0B) goto <D.23303>; else goto <D.23304>;
  <D.23303>:
  D.23305 = property;
  return D.23305;
  <D.23304>:
  D.23301 = property->parent;
  D.23302 = D.23301->generic_class;
  gtd = D.23302->container_class;
  property.163 = (long int) property;
  D.23301 = property->parent;
  D.23307 = D.23301->ext;
  D.23308 = D.23307->properties;
  D.23309 = (long int) D.23308;
  D.23310 = property.163 - D.23309;
  D.23311 = D.23310 /[ex] 40;
  offset = (int) D.23311;
  D.23312 = gtd->ext;
  D.23313 = D.23312->properties;
  D.23314 = (long unsigned int) offset;
  D.23315 = D.23314 * 40;
  D.23305 = D.23313 + D.23315;
  return D.23305;
}