dump_table_assembly (struct MonoImage * m)
{
  struct FILE * output.0;
  unsigned int D.14939;
  unsigned int D.14940;
  unsigned int D.14943;
  const char * D.14944;
  unsigned int D.14945;
  unsigned int D.14946;
  unsigned int D.14947;
  unsigned int D.14948;
  unsigned int D.14949;
  unsigned int D.14950;
  unsigned int D.14951;
  const char * ptr.1;
  const char * ptr.2;
  unsigned int D.14954;
  unsigned int D.14958;
  const char * D.14959;
  struct MonoTableInfo * t;
  guint32 cols[9];
  const char * ptr;
  int len;

  try
    {
      t = &m->tables[32];
      output.0 = output;
      fprintf (output.0, "Assembly Table\n");
      D.14939 = BIT_FIELD_REF <*t, 32, 64>;
      D.14940 = D.14939 & 16777215;
      if (D.14940 == 0) goto <D.14941>; else goto <D.14942>;
      <D.14941>:
      return;
      <D.14942>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      D.14943 = cols[7];
      D.14944 = mono_metadata_string_heap (m, D.14943);
      output.0 = output;
      fprintf (output.0, "Name:          %s\n", D.14944);
      D.14945 = cols[0];
      output.0 = output;
      fprintf (output.0, "Hash Algoritm: 0x%08x\n", D.14945);
      D.14946 = cols[4];
      D.14947 = cols[3];
      D.14948 = cols[2];
      D.14949 = cols[1];
      output.0 = output;
      fprintf (output.0, "Version:       %d.%d.%d.%d\n", D.14949, D.14948, D.14947, D.14946);
      D.14950 = cols[5];
      output.0 = output;
      fprintf (output.0, "Flags:         0x%08x\n", D.14950);
      D.14951 = cols[6];
      output.0 = output;
      fprintf (output.0, "PublicKey:     BlobPtr (0x%08x)\n", D.14951);
      D.14951 = cols[6];
      ptr.1 = mono_metadata_blob_heap (m, D.14951);
      ptr = ptr.1;
      ptr.2 = ptr;
      D.14954 = mono_metadata_decode_value (ptr.2, &ptr);
      len = (int) D.14954;
      if (len > 0) goto <D.14955>; else goto <D.14956>;
      <D.14955>:
      output.0 = output;
      fprintf (output.0, "\tDump:");
      ptr.2 = ptr;
      hex_dump (ptr.2, 0, len);
      output.0 = output;
      fprintf (output.0, "\n");
      goto <D.14957>;
      <D.14956>:
      output.0 = output;
      fprintf (output.0, "\tZero sized public key\n");
      <D.14957>:
      D.14958 = cols[8];
      D.14959 = mono_metadata_string_heap (m, D.14958);
      output.0 = output;
      fprintf (output.0, "Culture:       %s\n", D.14959);
      output.0 = output;
      fprintf (output.0, "\n");
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.14963;

  D.14963 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.14963;
}


dump_table_typeref (struct MonoImage * m)
{
  struct FILE * output.3;
  <unnamed-unsigned:24> D.14966;
  int D.14967;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[1];
  output.3 = output;
  fprintf (output.3, "Typeref Table\n");
  i = 1;
  goto <D.14375>;
  <D.14374>:
  {
    char * s;

    s = get_typeref (m, i);
    output.3 = output;
    fprintf (output.3, "%d: %s\n", i, s);
    monoeg_g_free (s);
  }
  i = i + 1;
  <D.14375>:
  D.14966 = t->rows;
  D.14967 = (int) D.14966;
  if (D.14967 >= i) goto <D.14374>; else goto <D.14376>;
  <D.14376>:
  output.3 = output;
  fprintf (output.3, "\n");
}


dump_table_typedef (struct MonoImage * m)
{
  struct FILE * output.4;
  int D.14969;
  struct MonoTableInfo * D.14970;
  unsigned int D.14971;
  unsigned int D.14972;
  unsigned int D.14973;
  unsigned int D.14974;
  <unnamed-unsigned:24> D.14975;
  int D.14976;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[2];
  output.4 = output;
  fprintf (output.4, "Typedef Table\n");
  i = 1;
  goto <D.14385>;
  <D.14384>:
  {
    char * s;
    guint32 cols[6];

    try
      {
        s = get_typedef (m, i);
        D.14969 = i + -1;
        D.14970 = &m->tables[2];
        mono_metadata_decode_row (D.14970, D.14969, &cols, 6);
        D.14971 = cols[3];
        D.14972 = cols[0];
        D.14973 = cols[5];
        D.14974 = cols[4];
        output.4 = output;
        fprintf (output.4, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i, s, D.14974, D.14973, D.14972, D.14971);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14385>:
  D.14975 = t->rows;
  D.14976 = (int) D.14975;
  if (D.14976 >= i) goto <D.14384>; else goto <D.14386>;
  <D.14386>:
  output.4 = output;
  fprintf (output.4, "\n");
}


dump_table_typespec (struct MonoImage * m)
{
  struct FILE * output.5;
  unsigned int i.6;
  <unnamed-unsigned:24> D.14979;
  int D.14980;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[27];
  output.5 = output;
  fprintf (output.5, "Typespec Table\n");
  i = 1;
  goto <D.14394>;
  <D.14393>:
  {
    char * typespec;

    i.6 = (unsigned int) i;
    typespec = get_typespec (m, i.6, 1, 0B);
    output.5 = output;
    fprintf (output.5, "%d: %s\n", i, typespec);
    monoeg_g_free (typespec);
  }
  i = i + 1;
  <D.14394>:
  D.14979 = t->rows;
  D.14980 = (int) D.14979;
  if (D.14980 >= i) goto <D.14393>; else goto <D.14395>;
  <D.14395>:
  output.5 = output;
  fprintf (output.5, "\n");
}


dump_table_assemblyref (struct MonoImage * m)
{
  struct FILE * output.7;
  unsigned int D.14982;
  const char * D.14983;
  unsigned int D.14984;
  unsigned int D.14985;
  unsigned int D.14986;
  unsigned int D.14987;
  int D.14988;
  unsigned int D.14989;
  unsigned int D.14990;
  const char * ptr.8;
  const char * ptr.9;
  unsigned int D.14993;
  <unnamed-unsigned:24> D.14997;
  int D.14998;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[35];
  output.7 = output;
  fprintf (output.7, "AssemblyRef Table\n");
  i = 0;
  goto <D.14405>;
  <D.14404>:
  {
    const char * ptr;
    int len;
    guint32 cols[9];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        D.14982 = cols[6];
        D.14983 = mono_metadata_string_heap (m, D.14982);
        D.14984 = cols[3];
        D.14985 = cols[2];
        D.14986 = cols[1];
        D.14987 = cols[0];
        D.14988 = i + 1;
        output.7 = output;
        fprintf (output.7, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", D.14988, D.14987, D.14986, D.14985, D.14984, D.14983);
        D.14989 = cols[4];
        output.7 = output;
        fprintf (output.7, "\tFlags=0x%08x\n", D.14989);
        D.14990 = cols[5];
        ptr.8 = mono_metadata_blob_heap (m, D.14990);
        ptr = ptr.8;
        ptr.9 = ptr;
        D.14993 = mono_metadata_decode_value (ptr.9, &ptr);
        len = (int) D.14993;
        if (len > 0) goto <D.14994>; else goto <D.14995>;
        <D.14994>:
        output.7 = output;
        fprintf (output.7, "\tPublic Key:");
        ptr.9 = ptr;
        hex_dump (ptr.9, 0, len);
        output.7 = output;
        fprintf (output.7, "\n");
        goto <D.14996>;
        <D.14995>:
        output.7 = output;
        fprintf (output.7, "\tZero sized public key\n");
        <D.14996>:
      }
    finally
      {
        ptr = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14405>:
  D.14997 = t->rows;
  D.14998 = (int) D.14997;
  if (D.14998 > i) goto <D.14404>; else goto <D.14406>;
  <D.14406>:
  output.7 = output;
  fprintf (output.7, "\n");
}


dump_table_param (struct MonoImage * m)
{
  struct FILE * output.10;
  unsigned int D.15000;
  const char * D.15001;
  unsigned int D.15002;
  unsigned int D.15003;
  int D.15004;
  <unnamed-unsigned:24> D.15005;
  int D.15006;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[8];
  output.10 = output;
  fprintf (output.10, "Param Table\n");
  i = 0;
  goto <D.14414>;
  <D.14413>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15000 = cols[2];
        D.15001 = mono_metadata_string_heap (m, D.15000);
        D.15002 = cols[1];
        D.15003 = cols[0];
        D.15004 = i + 1;
        output.10 = output;
        fprintf (output.10, "%d: 0x%04x %d %s\n", D.15004, D.15003, D.15002, D.15001);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14414>:
  D.15005 = t->rows;
  D.15006 = (int) D.15005;
  if (D.15006 > i) goto <D.14413>; else goto <D.14415>;
  <D.14415>:
  output.10 = output;
  fprintf (output.10, "\n");
}


dump_table_field (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15007;
  int D.15008;
  struct FILE * output.11;
  <unnamed-unsigned:24> D.15010;
  int D.15011;
  unsigned int i.12;
  int D.15014;
  int D.15017;
  unsigned int D.15018;
  const char * D.15019;
  unsigned int D.15020;
  const char * D.15021;
  int D.15022;
  unsigned int D.15023;
  unsigned int D.15024;
  unsigned int D.15025;
  const char * D.15026;
  <unnamed-unsigned:24> D.15027;
  int D.15028;
  int D.15031;
  unsigned int D.15032;
  unsigned int i.13;
  unsigned int D.15036;
  <unnamed-unsigned:24> D.15037;
  int D.15038;
  int D.15041;
  unsigned int D.15042;
  unsigned int D.15045;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  struct MonoTableInfo * fl;
  struct MonoTableInfo * rva;
  int i;
  int current_type;
  int offset_row;
  int rva_row;
  guint32 first_m;
  guint32 last_m;

  t = &m->tables[4];
  td = &m->tables[2];
  fl = &m->tables[16];
  rva = &m->tables[29];
  D.15007 = t->rows;
  D.15008 = (int) D.15007;
  output.11 = output;
  fprintf (output.11, "Field Table (1..%d)\n", D.15008);
  current_type = 1;
  offset_row = current_type;
  rva_row = offset_row;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14436>;
  <D.14435>:
  {
    guint32 cols[3];
    char * sig;
    char * flags;

    try
      {
        goto <D.14433>;
        <D.14432>:
        current_type = current_type + 1;
        <D.14433>:
        D.15010 = td->rows;
        D.15011 = (int) D.15010;
        if (D.15011 >= current_type) goto <D.15012>; else goto <D.14434>;
        <D.15012>:
        i.12 = (unsigned int) i;
        D.15014 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.15014, 4);
        if (i.12 >= last_m) goto <D.14432>; else goto <D.14434>;
        <D.14434>:
        i.12 = (unsigned int) i;
        if (i.12 == first_m) goto <D.15015>; else goto <D.15016>;
        <D.15015>:
        D.15017 = current_type + -2;
        D.15018 = mono_metadata_decode_row_col (td, D.15017, 1);
        D.15019 = mono_metadata_string_heap (m, D.15018);
        D.15017 = current_type + -2;
        D.15020 = mono_metadata_decode_row_col (td, D.15017, 2);
        D.15021 = mono_metadata_string_heap (m, D.15020);
        output.11 = output;
        fprintf (output.11, "########## %s.%s\n", D.15021, D.15019);
        first_m = last_m;
        <D.15016>:
        D.15022 = i + -1;
        mono_metadata_decode_row (t, D.15022, &cols, 3);
        D.15023 = cols[2];
        sig = get_field_signature (m, D.15023, 0B);
        D.15024 = cols[0];
        flags = field_flags (D.15024);
        D.15025 = cols[1];
        D.15026 = mono_metadata_string_heap (m, D.15025);
        output.11 = output;
        fprintf (output.11, "%d: %s %s: %s\n", i, sig, D.15026, flags);
        monoeg_g_free (sig);
        monoeg_g_free (flags);
        D.15027 = fl->rows;
        D.15028 = (int) D.15027;
        if (D.15028 >= offset_row) goto <D.15029>; else goto <D.15030>;
        <D.15029>:
        D.15031 = offset_row + -1;
        D.15032 = mono_metadata_decode_row_col (fl, D.15031, 1);
        i.13 = (unsigned int) i;
        if (D.15032 == i.13) goto <D.15034>; else goto <D.15035>;
        <D.15034>:
        D.15031 = offset_row + -1;
        D.15036 = mono_metadata_decode_row_col (fl, D.15031, 0);
        output.11 = output;
        fprintf (output.11, "\texplicit offset: %d\n", D.15036);
        offset_row = offset_row + 1;
        <D.15035>:
        <D.15030>:
        D.15037 = rva->rows;
        D.15038 = (int) D.15037;
        if (D.15038 >= rva_row) goto <D.15039>; else goto <D.15040>;
        <D.15039>:
        D.15041 = rva_row + -1;
        D.15042 = mono_metadata_decode_row_col (rva, D.15041, 1);
        i.13 = (unsigned int) i;
        if (D.15042 == i.13) goto <D.15043>; else goto <D.15044>;
        <D.15043>:
        D.15041 = rva_row + -1;
        D.15045 = mono_metadata_decode_row_col (rva, D.15041, 0);
        output.11 = output;
        fprintf (output.11, "\trva: %d\n", D.15045);
        rva_row = rva_row + 1;
        <D.15044>:
        <D.15040>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14436>:
  D.15007 = t->rows;
  D.15008 = (int) D.15007;
  if (D.15008 >= i) goto <D.14435>; else goto <D.14437>;
  <D.14437>:
  output.11 = output;
  fprintf (output.11, "\n");
}


dump_table_memberref (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15046;
  int D.15047;
  struct FILE * output.14;
  unsigned int D.15049;
  int D.15050;
  unsigned int D.15051;
  unsigned int D.15052;
  const char * D.15053;
  const char * D.15054;
  unsigned int idx.15;
  const char * D.15056;
  unsigned int D.15057;
  const char * blob.16;
  const char * blob.17;
  char D.15060;
  const char * iftmp.18;
  const char * D.15068;
  int D.15069;
  struct MonoTableInfo * t;
  int i;
  int kind;
  int idx;
  char * x;
  char * xx;
  char * sig;
  const char * blob;
  const char * ks;

  try
    {
      t = &m->tables[10];
      ks = 0B;
      D.15046 = t->rows;
      D.15047 = (int) D.15046;
      output.14 = output;
      fprintf (output.14, "MemberRef Table (1..%d)\n", D.15047);
      i = 0;
      goto <D.14460>;
      <D.14459>:
      {
        guint32 cols[3];

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            D.15049 = cols[0];
            D.15050 = (int) D.15049;
            kind = D.15050 & 7;
            D.15049 = cols[0];
            D.15051 = D.15049 >> 3;
            idx = (int) D.15051;
            x = monoeg_strdup ("UNHANDLED CASE");
            switch (kind) <default: <D.14457>, case 0: <D.14451>, case 1: <D.14453>, case 2: <D.14454>, case 3: <D.14455>, case 4: <D.14456>>
            <D.14451>:
            ks = "TypeDef";
            xx = get_typedef (m, idx);
            D.15052 = cols[1];
            D.15053 = mono_metadata_string_heap (m, D.15052);
            x = monoeg_g_strconcat (xx, ".", D.15053, 0B);
            monoeg_g_free (xx);
            goto <D.14452>;
            <D.14453>:
            ks = "TypeRef";
            xx = get_typeref (m, idx);
            D.15052 = cols[1];
            D.15054 = mono_metadata_string_heap (m, D.15052);
            x = monoeg_g_strconcat (xx, ".", D.15054, 0B);
            monoeg_g_free (xx);
            goto <D.14452>;
            <D.14454>:
            ks = "ModuleRef";
            goto <D.14452>;
            <D.14455>:
            ks = "MethodDef";
            idx.15 = (unsigned int) idx;
            x = get_methoddef (m, idx.15);
            goto <D.14452>;
            <D.14456>:
            ks = "TypeSpec";
            idx.15 = (unsigned int) idx;
            xx = get_typespec (m, idx.15, 0, 0B);
            D.15052 = cols[1];
            D.15056 = mono_metadata_string_heap (m, D.15052);
            x = monoeg_g_strconcat (xx, ".", D.15056, 0B);
            monoeg_g_free (xx);
            goto <D.14452>;
            <D.14457>:
            monoeg_g_log (0B, 4, "Unknown tag: %d\n", kind);
            <D.14458>:
            goto <D.14458>;
            <D.14452>:
            D.15057 = cols[2];
            blob.16 = mono_metadata_blob_heap (m, D.15057);
            blob = blob.16;
            blob.17 = blob;
            mono_metadata_decode_blob_size (blob.17, &blob);
            blob.17 = blob;
            D.15060 = *blob.17;
            if (D.15060 == 6) goto <D.15061>; else goto <D.15062>;
            <D.15061>:
            D.15057 = cols[2];
            sig = get_field_signature (m, D.15057, 0B);
            goto <D.15063>;
            <D.15062>:
            D.15057 = cols[2];
            sig = get_methodref_signature (m, D.15057, 0B);
            <D.15063>:
            if (x != 0B) goto <D.15065>; else goto <D.15066>;
            <D.15065>:
            iftmp.18 = x;
            goto <D.15067>;
            <D.15066>:
            iftmp.18 = "";
            <D.15067>:
            D.15052 = cols[1];
            D.15068 = mono_metadata_string_heap (m, D.15052);
            D.15069 = i + 1;
            output.14 = output;
            fprintf (output.14, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n", D.15069, ks, idx, D.15068, iftmp.18, sig);
            if (x != 0B) goto <D.15070>; else goto <D.15071>;
            <D.15070>:
            monoeg_g_free (x);
            <D.15071>:
            monoeg_g_free (sig);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14460>:
      D.15046 = t->rows;
      D.15047 = (int) D.15046;
      if (D.15047 > i) goto <D.14459>; else goto <D.14461>;
      <D.14461>:
    }
  finally
    {
      blob = {CLOBBER};
    }
}


monoeg_strdup (const gchar * str)
{
  gchar * D.15074;

  if (str != 0B) goto <D.15072>; else goto <D.15073>;
  <D.15072>:
  D.15074 = __strdup (str);
  return D.15074;
  <D.15073>:
  D.15074 = 0B;
  return D.15074;
}


dump_table_class_layout (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15076;
  int D.15077;
  struct FILE * output.19;
  unsigned int D.15079;
  int D.15080;
  char * D.15081;
  unsigned int D.15082;
  unsigned int D.15083;
  int D.15084;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[15];
  D.15076 = t->rows;
  D.15077 = (int) D.15076;
  output.19 = output;
  fprintf (output.19, "ClassLayout Table (1..%d)\n", D.15077);
  i = 0;
  goto <D.14469>;
  <D.14468>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15079 = cols[2];
        D.15080 = (int) D.15079;
        D.15081 = get_typedef (m, D.15080);
        D.15082 = cols[1];
        D.15083 = cols[0];
        D.15084 = i + 1;
        output.19 = output;
        fprintf (output.19, "%d: PackingSize=%d  ClassSize=%d  Parent=%s\n", D.15084, D.15083, D.15082, D.15081);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14469>:
  D.15076 = t->rows;
  D.15077 = (int) D.15076;
  if (D.15077 > i) goto <D.14468>; else goto <D.14470>;
  <D.14470>:
}


dump_table_constant (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15085;
  int D.15086;
  struct FILE * output.20;
  unsigned int D.15088;
  unsigned int D.15089;
  unsigned int D.15090;
  unsigned int D.15091;
  char * D.15092;
  unsigned int D.15093;
  int D.15094;
  struct MonoTableInfo * t;
  int i;
  const char * desc[4];

  try
    {
      t = &m->tables[11];
      desc[0] = "Field";
      desc[1] = "Param";
      desc[2] = "Property";
      desc[3] = "";
      D.15085 = t->rows;
      D.15086 = (int) D.15085;
      output.20 = output;
      fprintf (output.20, "Constant Table (1..%d)\n", D.15086);
      i = 0;
      goto <D.14480>;
      <D.14479>:
      {
        guint32 cols[4];
        const char * parent;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 4);
            D.15088 = cols[2];
            D.15089 = D.15088 & 3;
            parent = desc[D.15089];
            D.15090 = cols[3];
            D.15091 = cols[0];
            D.15092 = get_constant (m, D.15091, D.15090);
            D.15088 = cols[2];
            D.15093 = D.15088 >> 2;
            D.15094 = i + 1;
            output.20 = output;
            fprintf (output.20, "%d: Parent= %s: %d %s\n", D.15094, parent, D.15093, D.15092);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14480>:
      D.15085 = t->rows;
      D.15086 = (int) D.15085;
      if (D.15086 > i) goto <D.14479>; else goto <D.14481>;
      <D.14481>:
    }
  finally
    {
      desc = {CLOBBER};
    }
}


dump_table_property_map (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15095;
  int D.15096;
  struct FILE * output.21;
  unsigned int D.15098;
  int D.15099;
  unsigned int D.15100;
  int D.15101;
  struct MonoTableInfo * t;
  int i;
  char * s;

  t = &m->tables[21];
  D.15095 = t->rows;
  D.15096 = (int) D.15095;
  output.21 = output;
  fprintf (output.21, "Property Map Table (1..%d)\n", D.15096);
  i = 0;
  goto <D.14490>;
  <D.14489>:
  {
    guint32 cols[2];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 2);
        D.15098 = cols[0];
        D.15099 = (int) D.15098;
        s = get_typedef (m, D.15099);
        D.15100 = cols[1];
        D.15098 = cols[0];
        D.15101 = i + 1;
        output.21 = output;
        fprintf (output.21, "%d: %s (%d) %d\n", D.15101, s, D.15098, D.15100);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14490>:
  D.15095 = t->rows;
  D.15096 = (int) D.15095;
  if (D.15096 > i) goto <D.14489>; else goto <D.14491>;
  <D.14491>:
}


dump_table_property (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15102;
  int D.15103;
  struct FILE * output.22;
  unsigned int D.15105;
  int D.15106;
  int D.15109;
  int D.15112;
  unsigned int D.15115;
  const char * ptr.23;
  const char * ptr.24;
  unsigned int D.15118;
  char D.15119;
  _Bool D.15120;
  _Bool D.15121;
  _Bool D.15122;
  int D.15125;
  const char * ptr.25;
  unsigned int D.15127;
  const char * ptr.26;
  unsigned int D.15129;
  const char * D.15130;
  char * type.27;
  int D.15132;
  const char * ptr.28;
  const char * iftmp.29;
  struct MonoTableInfo * t;
  int i;
  int j;
  int pcount;
  const char * ptr;
  char flags[128];

  try
    {
      t = &m->tables[23];
      D.15102 = t->rows;
      D.15103 = (int) D.15102;
      output.22 = output;
      fprintf (output.22, "Property Table (1..%d)\n", D.15103);
      i = 0;
      goto <D.14509>;
      <D.14508>:
      {
        guint32 cols[3];
        char * type;
        int bsize;
        int prop_flags;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            flags[0] = 0;
            D.15105 = cols[0];
            prop_flags = (int) D.15105;
            D.15106 = prop_flags & 512;
            if (D.15106 != 0) goto <D.15107>; else goto <D.15108>;
            <D.15107>:
            strcat (&flags, "special ");
            <D.15108>:
            D.15109 = prop_flags & 1024;
            if (D.15109 != 0) goto <D.15110>; else goto <D.15111>;
            <D.15110>:
            strcat (&flags, "runtime ");
            <D.15111>:
            D.15112 = prop_flags & 4096;
            if (D.15112 != 0) goto <D.15113>; else goto <D.15114>;
            <D.15113>:
            strcat (&flags, "hasdefault ");
            <D.15114>:
            D.15115 = cols[2];
            ptr.23 = mono_metadata_blob_heap (m, D.15115);
            ptr = ptr.23;
            ptr.24 = ptr;
            D.15118 = mono_metadata_decode_blob_size (ptr.24, &ptr);
            bsize = (int) D.15118;
            ptr.24 = ptr;
            D.15119 = *ptr.24;
            D.15120 = D.15119 != 40;
            ptr.24 = ptr;
            D.15119 = *ptr.24;
            D.15121 = D.15119 != 8;
            D.15122 = D.15120 & D.15121;
            if (D.15122 != 0) goto <D.15123>; else goto <D.15124>;
            <D.15123>:
            ptr.24 = ptr;
            D.15119 = *ptr.24;
            D.15125 = (int) D.15119;
            monoeg_g_log (0B, 16, "incorrect signature in propert blob: 0x%x", D.15125);
            <D.15124>:
            ptr.24 = ptr;
            ptr.25 = ptr.24 + 1;
            ptr = ptr.25;
            ptr.24 = ptr;
            D.15127 = mono_metadata_decode_value (ptr.24, &ptr);
            pcount = (int) D.15127;
            ptr.24 = ptr;
            ptr.26 = get_type (m, ptr.24, &type, 0, 0B);
            ptr = ptr.26;
            D.15129 = cols[1];
            D.15130 = mono_metadata_string_heap (m, D.15129);
            type.27 = type;
            D.15132 = i + 1;
            output.22 = output;
            fprintf (output.22, "%d: %s %s (", D.15132, type.27, D.15130);
            type.27 = type;
            monoeg_g_free (type.27);
            j = 0;
            goto <D.14506>;
            <D.14505>:
            ptr.24 = ptr;
            ptr.28 = get_param (m, ptr.24, &type, 0B);
            ptr = ptr.28;
            type.27 = type;
            if (j > 0) goto <D.15135>; else goto <D.15136>;
            <D.15135>:
            iftmp.29 = ", ";
            goto <D.15137>;
            <D.15136>:
            iftmp.29 = "";
            <D.15137>:
            output.22 = output;
            fprintf (output.22, "%s%s", iftmp.29, type.27);
            type.27 = type;
            monoeg_g_free (type.27);
            j = j + 1;
            <D.14506>:
            if (j < pcount) goto <D.14505>; else goto <D.14507>;
            <D.14507>:
            output.22 = output;
            fprintf (output.22, ") %s\n", &flags);
          }
        finally
          {
            cols = {CLOBBER};
            type = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14509>:
      D.15102 = t->rows;
      D.15103 = (int) D.15102;
      if (D.15103 > i) goto <D.14508>; else goto <D.14510>;
      <D.14510>:
    }
  finally
    {
      ptr = {CLOBBER};
      flags = {CLOBBER};
    }
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.15138;
  long unsigned int D.15139;

  D.15139 = __builtin_object_size (__dest, 1);
  D.15138 = __builtin___strcat_chk (__dest, __src, D.15139);
  return D.15138;
}


dump_table_event (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15141;
  int D.15142;
  struct FILE * output.30;
  unsigned int D.15144;
  unsigned int D.15145;
  const char * iftmp.31;
  unsigned int D.15147;
  unsigned int D.15148;
  int D.15152;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[20];
  D.15141 = t->rows;
  D.15142 = (int) D.15141;
  output.30 = output;
  fprintf (output.30, "Event Table (1..%d)\n", D.15142);
  i = 0;
  goto <D.14520>;
  <D.14519>:
  {
    guint32 cols[3];
    const char * name;
    char * type;

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15144 = cols[1];
        name = mono_metadata_string_heap (m, D.15144);
        D.15145 = cols[2];
        type = get_typedef_or_ref (m, D.15145, 0B);
        D.15147 = cols[0];
        D.15148 = D.15147 & 512;
        if (D.15148 != 0) goto <D.15149>; else goto <D.15150>;
        <D.15149>:
        iftmp.31 = "specialname ";
        goto <D.15151>;
        <D.15150>:
        iftmp.31 = "";
        <D.15151>:
        D.15152 = i + 1;
        output.30 = output;
        fprintf (output.30, "%d: %s %s %s\n", D.15152, type, name, iftmp.31);
        monoeg_g_free (type);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14520>:
  D.15141 = t->rows;
  D.15142 = (int) D.15141;
  if (D.15142 > i) goto <D.14519>; else goto <D.14521>;
  <D.14521>:
}


dump_table_file (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15153;
  int D.15154;
  struct FILE * output.32;
  unsigned int D.15156;
  const char * iftmp.33;
  unsigned int D.15158;
  unsigned int D.15159;
  int D.15163;
  unsigned int D.15164;
  const char * hash.34;
  const char * hash.35;
  unsigned int D.15167;
  sizetype D.15168;
  const char * D.15169;
  char D.15170;
  int D.15171;
  int D.15172;
  const char * iftmp.36;
  struct MonoTableInfo * t;
  int i;
  int j;
  int len;

  t = &m->tables[38];
  D.15153 = t->rows;
  D.15154 = (int) D.15153;
  output.32 = output;
  fprintf (output.32, "File Table (1..%d)\n", D.15154);
  i = 0;
  goto <D.14536>;
  <D.14535>:
  {
    guint32 cols[3];
    const char * name;
    const char * hash;

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15156 = cols[1];
        name = mono_metadata_string_heap (m, D.15156);
        D.15158 = cols[0];
        D.15159 = D.15158 & 1;
        if (D.15159 != 0) goto <D.15160>; else goto <D.15161>;
        <D.15160>:
        iftmp.33 = "nometadata";
        goto <D.15162>;
        <D.15161>:
        iftmp.33 = "containsmetadata";
        <D.15162>:
        D.15163 = i + 1;
        output.32 = output;
        fprintf (output.32, "%d: %s %s [", D.15163, name, iftmp.33);
        D.15164 = cols[2];
        hash.34 = mono_metadata_blob_heap (m, D.15164);
        hash = hash.34;
        hash.35 = hash;
        D.15167 = mono_metadata_decode_blob_size (hash.35, &hash);
        len = (int) D.15167;
        j = 0;
        goto <D.14533>;
        <D.14532>:
        hash.35 = hash;
        D.15168 = (sizetype) j;
        D.15169 = hash.35 + D.15168;
        D.15170 = *D.15169;
        D.15171 = (int) D.15170;
        D.15172 = D.15171 & 255;
        if (j != 0) goto <D.15174>; else goto <D.15175>;
        <D.15174>:
        iftmp.36 = " ";
        goto <D.15176>;
        <D.15175>:
        iftmp.36 = "";
        <D.15176>:
        output.32 = output;
        fprintf (output.32, "%s%02X", iftmp.36, D.15172);
        j = j + 1;
        <D.14533>:
        if (j < len) goto <D.14532>; else goto <D.14534>;
        <D.14534>:
        output.32 = output;
        fprintf (output.32, "]\n");
      }
    finally
      {
        cols = {CLOBBER};
        hash = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14536>:
  D.15153 = t->rows;
  D.15154 = (int) D.15153;
  if (D.15154 > i) goto <D.14535>; else goto <D.14537>;
  <D.14537>:
}


dump_table_manifest (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15177;
  int D.15178;
  struct FILE * output.37;
  unsigned int D.15180;
  unsigned int D.15181;
  unsigned int D.15182;
  unsigned int D.15183;
  int D.15184;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[40];
  D.15177 = t->rows;
  D.15178 = (int) D.15177;
  output.37 = output;
  fprintf (output.37, "Manifestresource Table (1..%d)\n", D.15178);
  i = 0;
  goto <D.14565>;
  <D.14564>:
  {
    guint32 cols[4];
    const char * name;
    const char * mf;
    char * impl;

    try
      {
        mono_metadata_decode_row (t, i, &cols, 4);
        D.15180 = cols[2];
        name = mono_metadata_string_heap (m, D.15180);
        D.15181 = cols[1];
        mf = get_manifest_flags (D.15181);
        D.15182 = cols[3];
        impl = get_manifest_implementation (m, D.15182);
        D.15183 = cols[0];
        D.15184 = i + 1;
        output.37 = output;
        fprintf (output.37, "%d: %s \'%s\' at offset %u in %s\n", D.15184, mf, name, D.15183, impl);
        monoeg_g_free (impl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14565>:
  D.15177 = t->rows;
  D.15178 = (int) D.15177;
  if (D.15178 > i) goto <D.14564>; else goto <D.14566>;
  <D.14566>:
}


get_manifest_flags (guint32 mf)
{
  const char * D.15185;

  mf = mf & 3;
  switch (mf) <default: <D.14554>, case 1: <D.14552>, case 2: <D.14553>>
  <D.14552>:
  D.15185 = "public";
  return D.15185;
  <D.14553>:
  D.15185 = "private";
  return D.15185;
  <D.14554>:
  D.15185 = "";
  return D.15185;
}


get_manifest_implementation (struct MonoImage * m, guint32 idx)
{
  char * D.15189;
  unsigned int D.15190;
  guint32 row;
  const char * table;

  table = "";
  if (idx == 0) goto <D.15187>; else goto <D.15188>;
  <D.15187>:
  D.15189 = monoeg_strdup ("current module");
  return D.15189;
  <D.15188>:
  row = idx >> 2;
  D.15190 = idx & 3;
  switch (D.15190) <default: <D.14548>, case 0: <D.14544>, case 1: <D.14546>, case 2: <D.14547>>
  <D.14544>:
  table = "file";
  goto <D.14545>;
  <D.14546>:
  table = "assemblyref";
  goto <D.14545>;
  <D.14547>:
  table = "exportedtype";
  goto <D.14545>;
  <D.14548>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dump.c", 475);
  <D.14545>:
  D.15189 = monoeg_g_strdup_printf ("%s %d", table, row);
  return D.15189;
}


dump_table_moduleref (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15192;
  int D.15193;
  struct FILE * output.38;
  unsigned int D.15195;
  int D.15196;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[26];
  D.15192 = t->rows;
  D.15193 = (int) D.15192;
  output.38 = output;
  fprintf (output.38, "ModuleRef Table (1..%d)\n", D.15193);
  i = 0;
  goto <D.14575>;
  <D.14574>:
  {
    guint32 cols[1];
    const char * name;

    try
      {
        mono_metadata_decode_row (t, i, &cols, 1);
        D.15195 = cols[0];
        name = mono_metadata_string_heap (m, D.15195);
        D.15196 = i + 1;
        output.38 = output;
        fprintf (output.38, "%d: %s\n", D.15196, name);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14575>:
  D.15192 = t->rows;
  D.15193 = (int) D.15192;
  if (D.15193 > i) goto <D.14574>; else goto <D.14576>;
  <D.14576>:
}


dump_table_module (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15197;
  int D.15198;
  struct FILE * output.39;
  unsigned int D.15200;
  unsigned int D.15201;
  int D.15202;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[0];
  D.15197 = t->rows;
  D.15198 = (int) D.15197;
  output.39 = output;
  fprintf (output.39, "Module Table (1..%d)\n", D.15198);
  i = 0;
  goto <D.14586>;
  <D.14585>:
  {
    guint32 cols[5];
    const char * name;
    char * guid;

    try
      {
        mono_metadata_decode_row (t, i, &cols, 5);
        D.15200 = cols[1];
        name = mono_metadata_string_heap (m, D.15200);
        D.15201 = cols[2];
        guid = get_guid (m, D.15201);
        D.15201 = cols[2];
        D.15202 = i + 1;
        output.39 = output;
        fprintf (output.39, "%d: %s %d %s\n", D.15202, name, D.15201, guid);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14586>:
  D.15197 = t->rows;
  D.15198 = (int) D.15197;
  if (D.15198 > i) goto <D.14585>; else goto <D.14587>;
  <D.14587>:
}


dump_table_method (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15203;
  int D.15204;
  struct FILE * output.40;
  <unnamed-unsigned:24> D.15206;
  int D.15207;
  unsigned int i.41;
  int D.15210;
  int D.15213;
  unsigned int D.15214;
  const char * D.15215;
  unsigned int D.15216;
  const char * D.15217;
  int D.15218;
  unsigned int D.15219;
  int D.15222;
  unsigned int D.15223;
  int D.15226;
  unsigned int D.15227;
  const char * sigblob.42;
  const char * sigblob.43;
  struct MonoGenericContainer * iftmp.44;
  struct MonoGenericContainer * iftmp.45;
  unsigned int D.15238;
  unsigned int D.15239;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  int i;
  int current_type;
  guint32 first_m;
  guint32 last_m;
  struct MonoGenericContainer * type_container;
  struct MonoGenericContainer * method_container;

  t = &m->tables[6];
  td = &m->tables[2];
  type_container = 0B;
  method_container = 0B;
  D.15203 = t->rows;
  D.15204 = (int) D.15203;
  output.40 = output;
  fprintf (output.40, "Method Table (1..%d)\n", D.15204);
  current_type = 1;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14608>;
  <D.14607>:
  {
    guint32 cols[6];
    char * sig;
    char * impl_flags;
    const char * sigblob;
    struct MonoMethodSignature * method;

    try
      {
        goto <D.14605>;
        <D.14604>:
        current_type = current_type + 1;
        <D.14605>:
        D.15206 = td->rows;
        D.15207 = (int) D.15206;
        if (D.15207 >= current_type) goto <D.15208>; else goto <D.14606>;
        <D.15208>:
        i.41 = (unsigned int) i;
        D.15210 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.15210, 5);
        if (i.41 >= last_m) goto <D.14604>; else goto <D.14606>;
        <D.14606>:
        i.41 = (unsigned int) i;
        if (i.41 == first_m) goto <D.15211>; else goto <D.15212>;
        <D.15211>:
        D.15213 = current_type + -2;
        D.15214 = mono_metadata_decode_row_col (td, D.15213, 1);
        D.15215 = mono_metadata_string_heap (m, D.15214);
        D.15213 = current_type + -2;
        D.15216 = mono_metadata_decode_row_col (td, D.15213, 2);
        D.15217 = mono_metadata_string_heap (m, D.15216);
        output.40 = output;
        fprintf (output.40, "########## %s.%s\n", D.15217, D.15215);
        first_m = last_m;
        D.15210 = current_type + -1;
        D.15218 = D.15210 | 33554432;
        D.15219 = (unsigned int) D.15218;
        type_container = mono_metadata_load_generic_params (m, D.15219, 0B);
        if (type_container != 0B) goto <D.15220>; else goto <D.15221>;
        <D.15220>:
        D.15210 = current_type + -1;
        D.15218 = D.15210 | 33554432;
        D.15219 = (unsigned int) D.15218;
        mono_metadata_load_generic_param_constraints (m, D.15219, type_container);
        <D.15221>:
        <D.15212>:
        D.15222 = i | 100663296;
        D.15223 = (unsigned int) D.15222;
        method_container = mono_metadata_load_generic_params (m, D.15223, type_container);
        if (method_container != 0B) goto <D.15224>; else goto <D.15225>;
        <D.15224>:
        D.15222 = i | 100663296;
        D.15223 = (unsigned int) D.15222;
        mono_metadata_load_generic_param_constraints (m, D.15223, method_container);
        <D.15225>:
        D.15226 = i + -1;
        mono_metadata_decode_table_row (m, 6, D.15226, &cols, 6);
        D.15227 = cols[4];
        sigblob.42 = mono_metadata_blob_heap (m, D.15227);
        sigblob = sigblob.42;
        sigblob.43 = sigblob;
        mono_metadata_decode_blob_size (sigblob.43, &sigblob);
        sigblob.43 = sigblob;
        if (method_container != 0B) goto <D.15231>; else goto <D.15232>;
        <D.15231>:
        iftmp.44 = method_container;
        goto <D.15233>;
        <D.15232>:
        iftmp.44 = type_container;
        <D.15233>:
        method = mono_metadata_parse_method_signature_full (m, iftmp.44, i, sigblob.43, &sigblob);
        if (method_container != 0B) goto <D.15235>; else goto <D.15236>;
        <D.15235>:
        iftmp.45 = method_container;
        goto <D.15237>;
        <D.15236>:
        iftmp.45 = type_container;
        <D.15237>:
        sig = dis_stringify_method_signature (m, method, i, iftmp.45, 0);
        D.15238 = cols[1];
        impl_flags = get_method_impl_flags (D.15238);
        D.15239 = cols[5];
        output.40 = output;
        fprintf (output.40, "%d: %s (param: %d impl_flags: %s)\n", i, sig, D.15239, impl_flags);
        monoeg_g_free (sig);
        monoeg_g_free (impl_flags);
        mono_metadata_free_method_signature (method);
      }
    finally
      {
        cols = {CLOBBER};
        sigblob = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14608>:
  D.15203 = t->rows;
  D.15204 = (int) D.15203;
  if (D.15204 >= i) goto <D.14607>; else goto <D.14609>;
  <D.14609>:
}


dump_table_implmap (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15240;
  int D.15241;
  struct FILE * output.46;
  int D.15243;
  unsigned int D.15244;
  unsigned int D.15245;
  unsigned int D.15246;
  unsigned int D.15247;
  unsigned int D.15248;
  int D.15249;
  unsigned int D.15250;
  const char * D.15251;
  unsigned int D.15252;
  const char * D.15253;
  unsigned int D.15254;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  int i;

  t = &m->tables[28];
  td = &m->tables[26];
  D.15240 = t->rows;
  D.15241 = (int) D.15240;
  output.46 = output;
  fprintf (output.46, "ImplMap Table (1..%d)\n", D.15241);
  i = 1;
  goto <D.14619>;
  <D.14618>:
  {
    guint32 cols[4];
    char * method;

    try
      {
        D.15243 = i + -1;
        mono_metadata_decode_row (t, D.15243, &cols, 4);
        D.15244 = cols[1];
        D.15245 = D.15244 >> 1;
        D.15246 = D.15245 | 100663296;
        method = get_method (m, D.15246, 0B);
        D.15247 = cols[3];
        D.15248 = D.15247 + 4294967295;
        D.15249 = (int) D.15248;
        D.15250 = mono_metadata_decode_row_col (td, D.15249, 0);
        D.15251 = mono_metadata_string_heap (m, D.15250);
        D.15252 = cols[2];
        D.15253 = mono_metadata_string_heap (m, D.15252);
        D.15254 = cols[0];
        output.46 = output;
        fprintf (output.46, "%d: %s %d (%s %s)\n", i, method, D.15254, D.15253, D.15251);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14619>:
  D.15240 = t->rows;
  D.15241 = (int) D.15240;
  if (D.15241 >= i) goto <D.14618>; else goto <D.14620>;
  <D.14620>:
}


dump_table_fieldrva (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15255;
  int D.15256;
  struct FILE * output.47;
  int D.15258;
  unsigned int D.15259;
  unsigned int D.15260;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[29];
  D.15255 = t->rows;
  D.15256 = (int) D.15255;
  output.47 = output;
  fprintf (output.47, "FieldRVA Table (1..%d)\n", D.15256);
  i = 1;
  goto <D.14628>;
  <D.14627>:
  {
    guint32 cols[2];

    try
      {
        D.15258 = i + -1;
        mono_metadata_decode_row (t, D.15258, &cols, 2);
        D.15259 = cols[0];
        D.15260 = cols[1];
        output.47 = output;
        fprintf (output.47, "%d: Field %d: %x\n", i, D.15260, D.15259);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14628>:
  D.15255 = t->rows;
  D.15256 = (int) D.15255;
  if (D.15256 >= i) goto <D.14627>; else goto <D.14629>;
  <D.14629>:
}


dump_table_methodimpl (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15261;
  int D.15262;
  struct FILE * output.48;
  int D.15264;
  unsigned int D.15265;
  int D.15266;
  unsigned int D.15267;
  unsigned int D.15268;
  unsigned int D.15269;
  unsigned int D.15270;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[25];
  D.15261 = t->rows;
  D.15262 = (int) D.15261;
  output.48 = output;
  fprintf (output.48, "MethodImpl Table (1..%d)\n", D.15262);
  i = 1;
  goto <D.14640>;
  <D.14639>:
  {
    guint32 cols[3];
    char * class;
    char * impl;
    char * decl;

    try
      {
        D.15264 = i + -1;
        mono_metadata_decode_row (t, D.15264, &cols, 3);
        D.15265 = cols[0];
        D.15266 = (int) D.15265;
        class = get_typedef (m, D.15266);
        D.15267 = cols[1];
        D.15268 = method_dor_to_token (D.15267);
        impl = get_method (m, D.15268, 0B);
        D.15269 = cols[2];
        D.15270 = method_dor_to_token (D.15269);
        decl = get_method (m, D.15270, 0B);
        output.48 = output;
        fprintf (output.48, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i, class, decl, impl);
        monoeg_g_free (class);
        monoeg_g_free (impl);
        monoeg_g_free (decl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14640>:
  D.15261 = t->rows;
  D.15262 = (int) D.15261;
  if (D.15262 >= i) goto <D.14639>; else goto <D.14641>;
  <D.14641>:
}


dump_table_methodsem (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15271;
  int D.15272;
  struct FILE * output.49;
  int D.15274;
  unsigned int D.15275;
  unsigned int D.15276;
  int D.15277;
  unsigned int D.15278;
  const char * iftmp.50;
  unsigned int D.15283;
  unsigned int D.15284;
  struct MonoTableInfo * t;
  int i;
  int is_property;
  int index;
  const char * semantics;

  t = &m->tables[24];
  D.15271 = t->rows;
  D.15272 = (int) D.15271;
  output.49 = output;
  fprintf (output.49, "Method Semantics Table (1..%d)\n", D.15272);
  i = 1;
  goto <D.14653>;
  <D.14652>:
  {
    guint32 cols[3];

    try
      {
        D.15274 = i + -1;
        mono_metadata_decode_row (t, D.15274, &cols, 3);
        D.15275 = cols[0];
        semantics = flags (D.15275, &semantics_map);
        D.15276 = cols[2];
        D.15277 = (int) D.15276;
        is_property = D.15277 & 1;
        D.15276 = cols[2];
        D.15278 = D.15276 >> 1;
        index = (int) D.15278;
        if (is_property != 0) goto <D.15280>; else goto <D.15281>;
        <D.15280>:
        iftmp.50 = "property";
        goto <D.15282>;
        <D.15281>:
        iftmp.50 = "event";
        <D.15282>:
        D.15283 = cols[1];
        D.15284 = D.15283 + 4294967295;
        D.15276 = cols[2];
        output.49 = output;
        fprintf (output.49, "%d: [%d] %s method: %d %s %d\n", i, D.15276, semantics, D.15284, iftmp.50, index);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14653>:
  D.15271 = t->rows;
  D.15272 = (int) D.15271;
  if (D.15272 >= i) goto <D.14652>; else goto <D.14654>;
  <D.14654>:
}


dump_table_interfaceimpl (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15285;
  int D.15286;
  struct FILE * output.51;
  int D.15288;
  unsigned int D.15289;
  char * D.15290;
  unsigned int D.15291;
  int D.15292;
  char * D.15293;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[9];
  D.15285 = t->rows;
  D.15286 = (int) D.15285;
  output.51 = output;
  fprintf (output.51, "Interface Implementation Table (1..%d)\n", D.15286);
  i = 1;
  goto <D.14662>;
  <D.14661>:
  {
    guint32 cols[2];

    try
      {
        D.15288 = i + -1;
        mono_metadata_decode_row (t, D.15288, &cols, 2);
        D.15289 = cols[1];
        D.15290 = get_typedef_or_ref (m, D.15289, 0B);
        D.15291 = cols[0];
        D.15292 = (int) D.15291;
        D.15293 = get_typedef (m, D.15292);
        output.51 = output;
        fprintf (output.51, "%d: %s implements %s\n", i, D.15293, D.15290);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14662>:
  D.15285 = t->rows;
  D.15286 = (int) D.15285;
  if (D.15286 >= i) goto <D.14661>; else goto <D.14663>;
  <D.14663>:
}


dump_table_customattr (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15294;
  int D.15295;
  struct FILE * output.52;
  int D.15297;
  unsigned int D.15298;
  unsigned int D.15299;
  unsigned int D.15300;
  unsigned int D.15301;
  const char * D.15302;
  struct MonoMethodSignature * D.15303;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[12];
  D.15294 = t->rows;
  D.15295 = (int) D.15294;
  output.52 = output;
  fprintf (output.52, "Custom Attributes Table (1..%d)\n", D.15295);
  i = 1;
  goto <D.14751>;
  <D.14750>:
  {
    guint32 cols[3];
    guint32 mtoken;
    char * desc;
    char * method;
    char * params;
    struct MonoMethod * meth;

    try
      {
        D.15297 = i + -1;
        mono_metadata_decode_row (t, D.15297, &cols, 3);
        D.15298 = cols[0];
        desc = has_cattr_get_table (m, D.15298);
        D.15299 = cols[1];
        mtoken = D.15299 >> 3;
        D.15299 = cols[1];
        D.15300 = D.15299 & 7;
        switch (D.15300) <default: <D.14749>, case 2: <D.14746>, case 3: <D.14748>>
        <D.14746>:
        mtoken = mtoken | 100663296;
        goto <D.14747>;
        <D.14748>:
        mtoken = mtoken | 167772160;
        goto <D.14747>;
        <D.14749>:
        D.15299 = cols[1];
        monoeg_g_log (0B, 16, "Unknown table for custom attr type %08x", D.15299);
        goto <D.14747>;
        <D.14747>:
        method = get_method (m, mtoken, 0B);
        meth = mono_get_method (m, mtoken, 0B);
        D.15301 = cols[2];
        D.15302 = mono_metadata_blob_heap (m, D.15301);
        D.15303 = mono_method_signature (meth);
        params = custom_attr_params (m, D.15303, D.15302);
        output.52 = output;
        fprintf (output.52, "%d: %s: %s [%s]\n", i, desc, method, params);
        monoeg_g_free (desc);
        monoeg_g_free (method);
        monoeg_g_free (params);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14751>:
  D.15294 = t->rows;
  D.15295 = (int) D.15294;
  if (D.15295 >= i) goto <D.14750>; else goto <D.14752>;
  <D.14752>:
}


has_cattr_get_table (struct MonoImage * m, guint32 val)
{
  char * D.15304;
  guint32 t;
  guint32 index;
  const char * table;

  t = val & 31;
  index = val >> 5;
  switch (t) <default: <D.14692>, case 0: <D.14671>, case 1: <D.14673>, case 2: <D.14674>, case 3: <D.14675>, case 4: <D.14676>, case 5: <D.14677>, case 6: <D.14678>, case 7: <D.14679>, case 8: <D.14680>, case 9: <D.14681>, case 10: <D.14682>, case 11: <D.14683>, case 12: <D.14684>, case 13: <D.14685>, case 14: <D.14686>, case 15: <D.14687>, case 16: <D.14688>, case 17: <D.14689>, case 18: <D.14690>, case 19: <D.14691>>
  <D.14671>:
  table = "MethodDef";
  goto <D.14672>;
  <D.14673>:
  table = "FieldDef";
  goto <D.14672>;
  <D.14674>:
  table = "TypeRef";
  goto <D.14672>;
  <D.14675>:
  table = "TypeDef";
  goto <D.14672>;
  <D.14676>:
  table = "Param";
  goto <D.14672>;
  <D.14677>:
  table = "InterfaceImpl";
  goto <D.14672>;
  <D.14678>:
  table = "MemberRef";
  goto <D.14672>;
  <D.14679>:
  table = "Module";
  goto <D.14672>;
  <D.14680>:
  table = "DeclSecurity?";
  goto <D.14672>;
  <D.14681>:
  table = "Property";
  goto <D.14672>;
  <D.14682>:
  table = "Event";
  goto <D.14672>;
  <D.14683>:
  table = "StandAloneSignature";
  goto <D.14672>;
  <D.14684>:
  table = "ModuleRef";
  goto <D.14672>;
  <D.14685>:
  table = "TypeSpec";
  goto <D.14672>;
  <D.14686>:
  table = "Assembly";
  goto <D.14672>;
  <D.14687>:
  table = "AssemblyRef";
  goto <D.14672>;
  <D.14688>:
  table = "File";
  goto <D.14672>;
  <D.14689>:
  table = "ExportedType";
  goto <D.14672>;
  <D.14690>:
  table = "Manifest";
  goto <D.14672>;
  <D.14691>:
  table = "GenericParam";
  goto <D.14672>;
  <D.14692>:
  table = "Unknown";
  goto <D.14672>;
  <D.14672>:
  D.15304 = monoeg_g_strdup_printf ("%s: %d", table, index);
  return D.15304;
}


custom_attr_params (struct MonoImage * m, struct MonoMethodSignature * sig, const char * value)
{
  const char * p.53;
  unsigned int D.15307;
  short unsigned int D.15311;
  char * D.15312;
  const char * p.54;
  struct MonoType * D.15316;
  unsigned char D.15317;
  char D.15318;
  unsigned int D.15319;
  const char * p.55;
  int D.15321;
  const char * iftmp.56;
  int D.15326;
  short int D.15327;
  int D.15328;
  unsigned int D.15329;
  const char * p.57;
  int D.15331;
  long unsigned int D.15332;
  long long int D.15333;
  const char * p.58;
  float val.59;
  float val.60;
  double D.15337;
  int D.15344;
  double val.61;
  double val.62;
  int D.15356;
  struct MonoClass * D.15360;
  int D.15361;
  struct MonoType * D.15364;
  unsigned char D.15365;
  unsigned int D.15368;
  sizetype D.15369;
  const char * p.63;
  int D.15371;
  short unsigned int D.15372;
  int D.15373;
  long int value.64;
  long int p.65;
  long int D.15378;
  unsigned int D.15379;
  unsigned int len.66;
  unsigned int D.15381;
  unsigned int D.15382;
  sizetype D.15383;
  const char * D.15384;
  char D.15385;
  int D.15386;
  int D.15387;
  int len;
  int i;
  int slen;
  int type;
  struct GString * res;
  char * s;
  const char * p;
  void handle_enum = <<< error >>>;

  try
    {
      p = value;
      p.53 = p;
      D.15307 = mono_metadata_decode_value (p.53, &p);
      len = (int) D.15307;
      if (len <= 1) goto <D.15308>; else goto <D.15310>;
      <D.15310>:
      p.53 = p;
      D.15311 = MEM[(const guint16 *)p.53];
      if (D.15311 != 1) goto <D.15308>; else goto <D.15309>;
      <D.15308>:
      D.15312 = monoeg_strdup ("");
      return D.15312;
      <D.15309>:
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      res = monoeg_g_string_new ("");
      i = 0;
      goto <D.14730>;
      <D.14729>:
      if (i != 0) goto <D.15314>; else goto <D.15315>;
      <D.15314>:
      monoeg_g_string_append (res, ", ");
      <D.15315>:
      D.15316 = sig->params[i];
      D.15317 = D.15316->type;
      type = (int) D.15317;
      handle_enum:
      switch (type) <default: <D.14728>, case 2: <D.14709>, case 3: <D.14710>, case 4: <D.14708>, case 5: <D.14706>, case 6: <D.14712>, case 7: <D.14711>, case 8: <D.14714>, case 9: <D.14713>, case 10: <D.14716>, case 11: <D.14715>, case 12: <D.14717>, case 13: <D.14721>, case 14: <D.14727>, case 17: <D.14725>, case 18: <D.14726>>
      <D.14706>:
      p.53 = p;
      D.15318 = *p.53;
      D.15319 = (unsigned int) D.15318;
      monoeg_g_string_append_printf (res, "%d", D.15319);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.14707>;
      <D.14708>:
      p.53 = p;
      D.15318 = *p.53;
      D.15321 = (int) D.15318;
      monoeg_g_string_append_printf (res, "%d", D.15321);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.14707>;
      <D.14709>:
      p.53 = p;
      D.15318 = *p.53;
      if (D.15318 != 0) goto <D.15323>; else goto <D.15324>;
      <D.15323>:
      iftmp.56 = "true";
      goto <D.15325>;
      <D.15324>:
      iftmp.56 = "false";
      <D.15325>:
      monoeg_g_string_append_printf (res, "%s", iftmp.56);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.14707>;
      <D.14710>:
      p.53 = p;
      D.15311 = MEM[(const guint16 *)p.53];
      D.15326 = (int) D.15311;
      monoeg_g_string_append_printf (res, "\'%c\'", D.15326);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.14707>;
      <D.14711>:
      p.53 = p;
      D.15311 = MEM[(const guint16 *)p.53];
      D.15326 = (int) D.15311;
      monoeg_g_string_append_printf (res, "%d", D.15326);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.14707>;
      <D.14712>:
      p.53 = p;
      D.15311 = MEM[(const guint16 *)p.53];
      D.15327 = (short int) D.15311;
      D.15328 = (int) D.15327;
      monoeg_g_string_append_printf (res, "%d", D.15328);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.14707>;
      <D.14713>:
      p.53 = p;
      D.15329 = MEM[(const guint32 *)p.53];
      monoeg_g_string_append_printf (res, "%d", D.15329);
      p.53 = p;
      p.57 = p.53 + 4;
      p = p.57;
      goto <D.14707>;
      <D.14714>:
      p.53 = p;
      D.15329 = MEM[(const guint32 *)p.53];
      D.15331 = (int) D.15329;
      monoeg_g_string_append_printf (res, "%d", D.15331);
      p.53 = p;
      p.57 = p.53 + 4;
      p = p.57;
      goto <D.14707>;
      <D.14715>:
      p.53 = p;
      D.15332 = MEM[(const guint64 *)p.53];
      D.15333 = (long long int) D.15332;
      monoeg_g_string_append_printf (res, "%lld", D.15333);
      p.53 = p;
      p.58 = p.53 + 8;
      p = p.58;
      goto <D.14707>;
      <D.14716>:
      p.53 = p;
      D.15332 = MEM[(const guint64 *)p.53];
      D.15333 = (long long int) D.15332;
      monoeg_g_string_append_printf (res, "%lld", D.15333);
      p.53 = p;
      p.58 = p.53 + 8;
      p = p.58;
      goto <D.14707>;
      <D.14717>:
      {
        float val;
        int inf;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  p.53 = p;
                  D.15329 = MEM[(const guint32 *)p.53];
                  mf.ival = D.15329;
                  val.59 = mf.fval;
                  val = val.59;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.60 = val;
            D.15337 = (double) val.60;
            inf = dis_isinf (D.15337);
            if (inf == -1) goto <D.15338>; else goto <D.15339>;
            <D.15338>:
            monoeg_g_string_append_printf (res, "(00 00 80 ff)");
            goto <D.15340>;
            <D.15339>:
            if (inf == 1) goto <D.15341>; else goto <D.15342>;
            <D.15341>:
            monoeg_g_string_append_printf (res, "(00 00 80 7f)");
            goto <D.15343>;
            <D.15342>:
            val.60 = val;
            D.15337 = (double) val.60;
            D.15344 = dis_isnan (D.15337);
            if (D.15344 != 0) goto <D.15345>; else goto <D.15346>;
            <D.15345>:
            monoeg_g_string_append_printf (res, "(00 00 c0 ff)");
            goto <D.15347>;
            <D.15346>:
            val.60 = val;
            D.15337 = (double) val.60;
            monoeg_g_string_append_printf (res, "%g", D.15337);
            <D.15347>:
            <D.15343>:
            <D.15340>:
            p.53 = p;
            p.57 = p.53 + 4;
            p = p.57;
            goto <D.14707>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14721>:
      {
        double val;
        int inf;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  p.53 = p;
                  D.15332 = MEM[(const guint64 *)p.53];
                  mf.ival = D.15332;
                  val.61 = mf.fval;
                  val = val.61;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.62 = val;
            inf = dis_isinf (val.62);
            if (inf == -1) goto <D.15350>; else goto <D.15351>;
            <D.15350>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 ff)");
            goto <D.15352>;
            <D.15351>:
            if (inf == 1) goto <D.15353>; else goto <D.15354>;
            <D.15353>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 7f)");
            goto <D.15355>;
            <D.15354>:
            val.62 = val;
            D.15356 = __isnan (val.62);
            if (D.15356 != 0) goto <D.15357>; else goto <D.15358>;
            <D.15357>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f8 ff)");
            goto <D.15359>;
            <D.15358>:
            val.62 = val;
            monoeg_g_string_append_printf (res, "%g", val.62);
            <D.15359>:
            <D.15355>:
            <D.15352>:
            p.53 = p;
            p.58 = p.53 + 8;
            p = p.58;
            goto <D.14707>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14725>:
      D.15316 = sig->params[i];
      D.15360 = D.15316->data.klass;
      D.15361 = mono_class_is_enum (D.15360);
      if (D.15361 != 0) goto <D.15362>; else goto <D.15363>;
      <D.15362>:
      D.15316 = sig->params[i];
      D.15360 = D.15316->data.klass;
      D.15364 = mono_class_enum_basetype (D.15360);
      D.15365 = D.15364->type;
      type = (int) D.15365;
      goto handle_enum;
      <D.15363>:
      monoeg_g_log (0B, 16, "generic valutype not handled in custom attr value decoding");
      goto <D.14707>;
      <D.14726>:
      <D.14727>:
      p.53 = p;
      D.15318 = *p.53;
      if (D.15318 == -1) goto <D.15366>; else goto <D.15367>;
      <D.15366>:
      monoeg_g_string_append (res, "null");
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.14707>;
      <D.15367>:
      p.53 = p;
      D.15368 = mono_metadata_decode_value (p.53, &p);
      slen = (int) D.15368;
      monoeg_g_string_append_c (res, 34);
      p.53 = p;
      monoeg_g_string_append (res, p.53);
      monoeg_g_string_append_c (res, 34);
      p.53 = p;
      D.15369 = (sizetype) slen;
      p.63 = p.53 + D.15369;
      p = p.63;
      goto <D.14707>;
      <D.14728>:
      D.15316 = sig->params[i];
      D.15317 = D.15316->type;
      D.15371 = (int) D.15317;
      monoeg_g_log (0B, 16, "Type %02x not handled in custom attr value decoding", D.15371);
      goto <D.14707>;
      <D.14707>:
      i = i + 1;
      <D.14730>:
      D.15372 = sig->param_count;
      D.15373 = (int) D.15372;
      if (D.15373 > i) goto <D.14729>; else goto <D.14731>;
      <D.14731>:
      p.53 = p;
      D.15311 = MEM[(const guint16 *)p.53];
      slen = (int) D.15311;
      if (slen != 0) goto <D.15374>; else goto <D.15375>;
      <D.15374>:
      monoeg_g_string_append_printf (res, " %d named args: (", slen);
      value.64 = (long int) value;
      p.53 = p;
      p.65 = (long int) p.53;
      D.15378 = value.64 - p.65;
      D.15379 = (unsigned int) D.15378;
      len.66 = (unsigned int) len;
      D.15381 = D.15379 + len.66;
      D.15382 = D.15381 + 1;
      slen = (int) D.15382;
      i = 0;
      goto <D.14733>;
      <D.14732>:
      p.53 = p;
      D.15383 = (sizetype) i;
      D.15384 = p.53 + D.15383;
      D.15385 = *D.15384;
      D.15386 = (int) D.15385;
      D.15387 = D.15386 & 255;
      monoeg_g_string_append_printf (res, " %02X", D.15387);
      i = i + 1;
      <D.14733>:
      if (i < slen) goto <D.14732>; else goto <D.14734>;
      <D.14734>:
      monoeg_g_string_append_c (res, 41);
      <D.15375>:
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.15312 = s;
      return D.15312;
    }
  finally
    {
      p = {CLOBBER};
    }
}


dump_table_nestedclass (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15392;
  int D.15393;
  struct FILE * output.67;
  int D.15395;
  unsigned int D.15396;
  int D.15397;
  unsigned int D.15398;
  int D.15399;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  char * nested;
  char * nesting;

  try
    {
      t = &m->tables[41];
      D.15392 = t->rows;
      D.15393 = (int) D.15392;
      output.67 = output;
      fprintf (output.67, "NestedClass Table (1..%d)\n", D.15393);
      i = 1;
      goto <D.14762>;
      <D.14761>:
      D.15395 = i + -1;
      mono_metadata_decode_row (t, D.15395, &cols, 2);
      D.15396 = cols[0];
      D.15397 = (int) D.15396;
      nested = get_typedef (m, D.15397);
      D.15398 = cols[1];
      D.15399 = (int) D.15398;
      nesting = get_typedef (m, D.15399);
      D.15398 = cols[1];
      D.15396 = cols[0];
      output.67 = output;
      fprintf (output.67, "%d: %d %d: %s in %s\n", i, D.15396, D.15398, nested, nesting);
      monoeg_g_free (nested);
      monoeg_g_free (nesting);
      i = i + 1;
      <D.14762>:
      D.15392 = t->rows;
      D.15393 = (int) D.15392;
      if (D.15393 >= i) goto <D.14761>; else goto <D.14763>;
      <D.14763>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_exported (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15400;
  int D.15401;
  struct FILE * output.68;
  int D.15403;
  unsigned int D.15404;
  unsigned int D.15405;
  unsigned int D.15406;
  const char * iftmp.69;
  char D.15408;
  struct MonoTableInfo * t;
  guint32 cols[5];
  int i;
  const char * name;
  const char * nspace;
  char * impl;
  guint32 index;
  guint32 flags;

  try
    {
      t = &m->tables[39];
      D.15400 = t->rows;
      D.15401 = (int) D.15400;
      output.68 = output;
      fprintf (output.68, "ExportedType Table (1..%d)\n", D.15401);
      i = 1;
      goto <D.14776>;
      <D.14775>:
      D.15403 = i + -1;
      mono_metadata_decode_row (t, D.15403, &cols, 5);
      D.15404 = cols[2];
      name = mono_metadata_string_heap (m, D.15404);
      D.15405 = cols[3];
      nspace = mono_metadata_string_heap (m, D.15405);
      D.15406 = cols[4];
      impl = get_manifest_implementation (m, D.15406);
      index = cols[1];
      flags = cols[0];
      D.15408 = *nspace;
      if (D.15408 != 0) goto <D.15409>; else goto <D.15410>;
      <D.15409>:
      iftmp.69 = ".";
      goto <D.15411>;
      <D.15410>:
      iftmp.69 = "";
      <D.15411>:
      output.68 = output;
      fprintf (output.68, "%d: %s%s%s is in %s, index=%x, flags=0x%x\n", i, nspace, iftmp.69, name, impl, index, flags);
      monoeg_g_free (impl);
      i = i + 1;
      <D.14776>:
      D.15400 = t->rows;
      D.15401 = (int) D.15400;
      if (D.15401 >= i) goto <D.14775>; else goto <D.14777>;
      <D.14777>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_field_marshal (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15412;
  int D.15413;
  struct FILE * output.70;
  int D.15415;
  unsigned int D.15416;
  unsigned int D.15417;
  unsigned int D.15418;
  _Bool D.15419;
  unsigned int D.15420;
  const char * iftmp.71;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  int is_field;
  int idx;
  const char * blob;
  char * native;

  try
    {
      t = &m->tables[13];
      D.15412 = t->rows;
      D.15413 = (int) D.15412;
      output.70 = output;
      fprintf (output.70, "FieldMarshal Table (1..%d)\n", D.15413);
      i = 1;
      goto <D.14798>;
      <D.14797>:
      D.15415 = i + -1;
      mono_metadata_decode_row (t, D.15415, &cols, 2);
      D.15416 = cols[1];
      blob = mono_metadata_blob_heap (m, D.15416);
      native = get_marshal_info (m, blob);
      D.15417 = cols[0];
      D.15418 = D.15417 & 1;
      D.15419 = D.15418 == 0;
      is_field = (int) D.15419;
      D.15417 = cols[0];
      D.15420 = D.15417 >> 1;
      idx = (int) D.15420;
      if (is_field != 0) goto <D.15422>; else goto <D.15423>;
      <D.15422>:
      iftmp.71 = "Field";
      goto <D.15424>;
      <D.15423>:
      iftmp.71 = "Param";
      <D.15424>:
      D.15417 = cols[0];
      output.70 = output;
      fprintf (output.70, "%d: (0x%04x) %s %d: %s\n", i, D.15417, iftmp.71, idx, native);
      output.70 = output;
      fprintf (output.70, "\tblob encoding: ");
      dump_blob (m, blob);
      output.70 = output;
      fprintf (output.70, "\n");
      monoeg_g_free (native);
      i = i + 1;
      <D.14798>:
      D.15412 = t->rows;
      D.15413 = (int) D.15412;
      if (D.15413 >= i) goto <D.14797>; else goto <D.14799>;
      <D.14799>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_blob (struct MonoImage * m, const char * blob)
{
  const char * blob.72;
  unsigned int D.15426;
  sizetype D.15427;
  const char * D.15428;
  char D.15429;
  int D.15430;
  int D.15431;
  struct FILE * output.73;
  int j;
  int bsize;

  blob.72 = blob;
  D.15426 = mono_metadata_decode_blob_size (blob.72, &blob);
  bsize = (int) D.15426;
  j = 0;
  goto <D.14785>;
  <D.14784>:
  blob.72 = blob;
  D.15427 = (sizetype) j;
  D.15428 = blob.72 + D.15427;
  D.15429 = *D.15428;
  D.15430 = (int) D.15429;
  D.15431 = D.15430 & 255;
  output.73 = output;
  fprintf (output.73, "%02x ", D.15431);
  j = j + 1;
  <D.14785>:
  if (j < bsize) goto <D.14784>; else goto <D.14786>;
  <D.14786>:
}


dump_table_declsec (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15433;
  int D.15434;
  struct FILE * output.74;
  int D.15436;
  unsigned int D.15437;
  const char * blob.75;
  const char * blob.76;
  unsigned int D.15440;
  unsigned int D.15441;
  int D.15442;
  const char * iftmp.77;
  unsigned int D.15447;
  unsigned int D.15448;
  const char * D.15449;
  char D.15452;
  sizetype D.15456;
  const char * D.15457;
  char D.15458;
  int D.15459;
  unsigned int len.78;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int i;
  int len;
  guint32 idx;
  const char * blob;
  const char * action;
  const char * parent[4];

  try
    {
      t = &m->tables[14];
      parent[0] = "TypeDef";
      parent[1] = "MethodDef";
      parent[2] = "Assembly";
      parent[3] = "";
      D.15433 = t->rows;
      D.15434 = (int) D.15433;
      output.74 = output;
      fprintf (output.74, "DeclSecurity Table (1..%d)\n", D.15434);
      i = 1;
      goto <D.14837>;
      <D.14836>:
      D.15436 = i + -1;
      mono_metadata_decode_row (t, D.15436, &cols, 3);
      D.15437 = cols[2];
      blob.75 = mono_metadata_blob_heap (m, D.15437);
      blob = blob.75;
      blob.76 = blob;
      D.15440 = mono_metadata_decode_blob_size (blob.76, &blob);
      len = (int) D.15440;
      D.15441 = cols[0];
      D.15442 = (int) D.15441;
      action = get_security_action (D.15442);
      idx = cols[1];
      if (len != 0) goto <D.15444>; else goto <D.15445>;
      <D.15444>:
      iftmp.77 = ":\n\t";
      goto <D.15446>;
      <D.15445>:
      iftmp.77 = "\n";
      <D.15446>:
      D.15447 = idx >> 2;
      D.15448 = idx & 3;
      D.15449 = parent[D.15448];
      output.74 = output;
      fprintf (output.74, "%d: %s on %s %d%s", i, action, D.15449, D.15447, iftmp.77);
      if (len == 0) goto <D.15450>; else goto <D.15451>;
      <D.15450>:
      // predicted unlikely by continue predictor.
      goto <D.14831>;
      <D.15451>:
      blob.76 = blob;
      D.15452 = *blob.76;
      if (D.15452 == 46) goto <D.15453>; else goto <D.15454>;
      <D.15453>:
      {
        char * declsec;

        blob.76 = blob;
        declsec = dump_declsec_entry20 (m, blob.76, "\t");
        output.74 = output;
        fprintf (output.74, "%s", declsec);
        monoeg_g_free (declsec);
      }
      goto <D.15455>;
      <D.15454>:
      idx = 0;
      goto <D.14834>;
      <D.14833>:
      blob.76 = blob;
      D.15456 = (sizetype) idx;
      D.15457 = blob.76 + D.15456;
      D.15458 = *D.15457;
      D.15459 = (int) D.15458;
      output.74 = output;
      fprintf (output.74, "%c", D.15459);
      idx = idx + 1;
      <D.14834>:
      len.78 = (unsigned int) len;
      if (len.78 > idx) goto <D.14833>; else goto <D.14835>;
      <D.14835>:
      <D.15455>:
      output.74 = output;
      fprintf (output.74, "\n");
      <D.14831>:
      i = i + 1;
      <D.14837>:
      D.15433 = t->rows;
      D.15434 = (int) D.15433;
      if (D.15434 >= i) goto <D.14836>; else goto <D.14838>;
      <D.14838>:
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
      parent = {CLOBBER};
    }
}


get_security_action (int val)
{
  const char * D.15461;
  static char buf[32];

  switch (val) <default: <D.14819>, case 2: <D.14804>, case 3: <D.14805>, case 4: <D.14806>, case 5: <D.14807>, case 6: <D.14808>, case 7: <D.14809>, case 8: <D.14810>, case 9: <D.14811>, case 10: <D.14812>, case 13: <D.14813>, case 14: <D.14814>, case 15: <D.14815>, case 16: <D.14816>, case 17: <D.14817>, case 18: <D.14818>>
  <D.14804>:
  D.15461 = "Demand";
  return D.15461;
  <D.14805>:
  D.15461 = "Assert";
  return D.15461;
  <D.14806>:
  D.15461 = "Deny";
  return D.15461;
  <D.14807>:
  D.15461 = "PermitOnly";
  return D.15461;
  <D.14808>:
  D.15461 = "LinkDemand";
  return D.15461;
  <D.14809>:
  D.15461 = "InheritanceDemand";
  return D.15461;
  <D.14810>:
  D.15461 = "RequestMinimum";
  return D.15461;
  <D.14811>:
  D.15461 = "RequestOptional";
  return D.15461;
  <D.14812>:
  D.15461 = "RequestRefuse";
  return D.15461;
  <D.14813>:
  D.15461 = "NonCasDemand";
  return D.15461;
  <D.14814>:
  D.15461 = "NonCasLinkDemand";
  return D.15461;
  <D.14815>:
  D.15461 = "NonCasInheritance";
  return D.15461;
  <D.14816>:
  D.15461 = "LinkDemandChoice";
  return D.15461;
  <D.14817>:
  D.15461 = "InheritanceDemandChoice";
  return D.15461;
  <D.14818>:
  D.15461 = "DemandChoice";
  return D.15461;
  <D.14819>:
  monoeg_g_snprintf (&buf, 32, "0x%04X", val);
  D.15461 = &buf;
  return D.15461;
}


dump_table_genericpar (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15463;
  int D.15464;
  struct FILE * output.79;
  int D.15466;
  unsigned int D.15467;
  unsigned int D.15468;
  const char * D.15469;
  unsigned int D.15470;
  unsigned int D.15471;
  struct MonoTableInfo * t;
  guint32 cols[4];
  int i;

  try
    {
      t = &m->tables[42];
      D.15463 = t->rows;
      D.15464 = (int) D.15463;
      output.79 = output;
      fprintf (output.79, "GenericParameters (1..%d)\n", D.15464);
      i = 1;
      goto <D.14847>;
      <D.14846>:
      {
        char * sig;

        D.15466 = i + -1;
        mono_metadata_decode_row (t, D.15466, &cols, 4);
        D.15467 = cols[2];
        sig = monoeg_g_strdup_printf ("%x", D.15467);
        D.15468 = cols[3];
        D.15469 = mono_metadata_string_heap (m, D.15468);
        D.15470 = cols[1];
        D.15471 = cols[0];
        output.79 = output;
        fprintf (output.79, "%d: %d, flags=%d, owner=%s %s\n", i, D.15471, D.15470, sig, D.15469);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14847>:
      D.15463 = t->rows;
      D.15464 = (int) D.15463;
      if (D.15464 >= i) goto <D.14846>; else goto <D.14848>;
      <D.14848>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_methodspec (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15472;
  int D.15473;
  struct FILE * output.80;
  int D.15475;
  int D.15476;
  unsigned int D.15477;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

  try
    {
      t = &m->tables[43];
      D.15472 = t->rows;
      D.15473 = (int) D.15472;
      output.80 = output;
      fprintf (output.80, "MethodSpec (1..%d)\n", D.15473);
      i = 1;
      goto <D.14859>;
      <D.14858>:
      {
        char * sig;
        char * method;
        guint32 token;

        D.15475 = i + -1;
        mono_metadata_decode_row (t, D.15475, &cols, 2);
        D.15476 = i | 721420288;
        token = (guint32) D.15476;
        method = get_method (m, token, 0B);
        D.15477 = cols[1];
        sig = get_method_type_param (m, D.15477, 0B);
        output.80 = output;
        fprintf (output.80, "%d: %s, %s\n", i, method, sig);
        monoeg_g_free (sig);
        monoeg_g_free (method);
      }
      i = i + 1;
      <D.14859>:
      D.15472 = t->rows;
      D.15473 = (int) D.15472;
      if (D.15473 >= i) goto <D.14858>; else goto <D.14860>;
      <D.14860>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_parconstraint (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15478;
  int D.15479;
  struct FILE * output.81;
  int D.15481;
  unsigned int D.15482;
  unsigned int D.15483;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

  try
    {
      t = &m->tables[44];
      D.15478 = t->rows;
      D.15479 = (int) D.15478;
      output.81 = output;
      fprintf (output.81, "Generic Param Constraint (1..%d)\n", D.15479);
      i = 1;
      goto <D.14869>;
      <D.14868>:
      {
        char * sig;

        D.15481 = i + -1;
        mono_metadata_decode_row (t, D.15481, &cols, 2);
        D.15482 = cols[1];
        sig = monoeg_g_strdup_printf ("%x", D.15482);
        D.15483 = cols[0];
        output.81 = output;
        fprintf (output.81, "%d: gen-par=%d, Constraint=%s\n", i, D.15483, sig);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14869>:
      D.15478 = t->rows;
      D.15479 = (int) D.15478;
      if (D.15479 >= i) goto <D.14868>; else goto <D.14870>;
      <D.14870>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_stream_blob (struct MonoImage * m)
{
  struct FILE * output.82;
  unsigned int i.83;
  unsigned int D.15488;
  unsigned int D.15492;
  const char * D.15495;
  sizetype D.15496;
  const char * D.15497;
  char D.15498;
  int D.15499;
  int D.15500;
  unsigned int i.84;
  unsigned int D.15502;
  int i;

  output.82 = output;
  fprintf (output.82, "Blob heap contents\n");
  i = 0;
  goto <D.14876>;
  <D.14875>:
  if (i > 0) goto <D.15485>; else goto <D.15486>;
  <D.15485>:
  i.83 = (unsigned int) i;
  D.15488 = i.83 & 15;
  if (D.15488 == 0) goto <D.15489>; else goto <D.15490>;
  <D.15489>:
  output.82 = output;
  fprintf (output.82, "\n");
  goto <D.15491>;
  <D.15490>:
  i.83 = (unsigned int) i;
  D.15492 = i.83 & 7;
  if (D.15492 == 0) goto <D.15493>; else goto <D.15494>;
  <D.15493>:
  output.82 = output;
  fprintf (output.82, "- ");
  <D.15494>:
  <D.15491>:
  <D.15486>:
  D.15495 = m->heap_blob.data;
  D.15496 = (sizetype) i;
  D.15497 = D.15495 + D.15496;
  D.15498 = *D.15497;
  D.15499 = (int) D.15498;
  D.15500 = D.15499 & 255;
  output.82 = output;
  fprintf (output.82, "%02x ", D.15500);
  i = i + 1;
  <D.14876>:
  i.84 = (unsigned int) i;
  D.15502 = m->heap_blob.size;
  if (i.84 < D.15502) goto <D.14875>; else goto <D.14877>;
  <D.14877>:
  output.82 = output;
  fprintf (output.82, "\n");
}


dump_stream_strings (struct MonoImage * m)
{
  struct FILE * output.85;
  long unsigned int D.15504;
  unsigned int D.15505;
  unsigned int D.15506;
  unsigned int D.15507;
  guint32 i;

  output.85 = output;
  fprintf (output.85, "Strings heap contents\n");
  i = 0;
  goto <D.14884>;
  <D.14883>:
  {
    const char * str;

    str = mono_metadata_string_heap (m, i);
    output.85 = output;
    fprintf (output.85, "%02x: \"%s\"\n", i, str);
    D.15504 = strlen (str);
    D.15505 = (unsigned int) D.15504;
    D.15506 = D.15505 + i;
    i = D.15506 + 1;
  }
  <D.14884>:
  D.15507 = m->heap_strings.size;
  if (D.15507 > i) goto <D.14883>; else goto <D.14885>;
  <D.14885>:
}


dump_stream_us (struct MonoImage * m)
{
  struct FILE * output.86;
  const char * us_ptr.87;
  const char * us_ptr.88;
  unsigned int D.15511;
  unsigned int len.89;
  unsigned int D.15513;
  unsigned int D.15514;
  guint32 i;

  output.86 = output;
  fprintf (output.86, "User Strings heap contents\n");
  i = 0;
  goto <D.14894>;
  <D.14893>:
  {
    const char * us_ptr;
    int len;
    char * str;

    try
      {
        us_ptr.87 = mono_metadata_user_string (m, i);
        us_ptr = us_ptr.87;
        us_ptr.88 = us_ptr;
        D.15511 = mono_metadata_decode_blob_size (us_ptr.88, &us_ptr);
        len = (int) D.15511;
        us_ptr.88 = us_ptr;
        str = get_encoded_user_string_or_bytearray (us_ptr.88, len);
        output.86 = output;
        fprintf (output.86, "%02x: %s\n", i, str);
        monoeg_g_free (str);
        len.89 = (unsigned int) len;
        D.15513 = len.89 + i;
        i = D.15513 + 1;
      }
    finally
      {
        us_ptr = {CLOBBER};
      }
  }
  <D.14894>:
  D.15514 = m->heap_us.size;
  if (D.15514 > i) goto <D.14893>; else goto <D.14895>;
  <D.14895>:
}


dump_table_standalonesig (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15515;
  int D.15516;
  struct FILE * output.90;
  int D.15518;
  unsigned int D.15519;
  const char * locals_ptr.91;
  const char * locals_ptr.92;
  unsigned int D.15522;
  sizetype D.15523;
  const char * D.15524;
  char D.15525;
  int D.15526;
  int D.15527;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

  try
    {
      t = &m->tables[17];
      D.15515 = t->rows;
      D.15516 = (int) D.15515;
      output.90 = output;
      fprintf (output.90, "Stand alone signature (1..%d)\n", D.15516);
      i = 1;
      goto <D.14909>;
      <D.14908>:
      {
        const char * locals_ptr;
        int j;
        int bsize;

        try
          {
            D.15518 = i + -1;
            mono_metadata_decode_row (t, D.15518, &cols, 1);
            D.15519 = cols[0];
            locals_ptr.91 = mono_metadata_blob_heap (m, D.15519);
            locals_ptr = locals_ptr.91;
            locals_ptr.92 = locals_ptr;
            D.15522 = mono_metadata_decode_blob_size (locals_ptr.92, &locals_ptr);
            bsize = (int) D.15522;
            D.15519 = cols[0];
            output.90 = output;
            fprintf (output.90, "%d: blob[0x%x] = ", i, D.15519);
            j = 0;
            goto <D.14906>;
            <D.14905>:
            locals_ptr.92 = locals_ptr;
            D.15523 = (sizetype) j;
            D.15524 = locals_ptr.92 + D.15523;
            D.15525 = *D.15524;
            D.15526 = (int) D.15525;
            D.15527 = D.15526 & 255;
            output.90 = output;
            fprintf (output.90, "%02x ", D.15527);
            j = j + 1;
            <D.14906>:
            if (j < bsize) goto <D.14905>; else goto <D.14907>;
            <D.14907>:
            output.90 = output;
            fprintf (output.90, "\n");
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14909>:
      D.15515 = t->rows;
      D.15516 = (int) D.15515;
      if (D.15516 >= i) goto <D.14908>; else goto <D.14910>;
      <D.14910>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_methodptr (struct MonoImage * m)
{
  dump_table_ptr (m, 5, "Method Ptr");
}


dump_table_ptr (struct MonoImage * m, int table, const char * name)
{
  <unnamed-unsigned:24> D.15528;
  int D.15529;
  struct FILE * output.93;
  int D.15531;
  unsigned int D.15532;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

  try
    {
      t = &m->tables[table];
      D.15528 = t->rows;
      D.15529 = (int) D.15528;
      output.93 = output;
      fprintf (output.93, "%s (1..%d)\n", name, D.15529);
      i = 1;
      goto <D.14920>;
      <D.14919>:
      D.15531 = i + -1;
      mono_metadata_decode_row (t, D.15531, &cols, 1);
      D.15532 = cols[0];
      output.93 = output;
      fprintf (output.93, "%d: %d\n", i, D.15532);
      i = i + 1;
      <D.14920>:
      D.15528 = t->rows;
      D.15529 = (int) D.15528;
      if (D.15529 >= i) goto <D.14919>; else goto <D.14921>;
      <D.14921>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_fieldptr (struct MonoImage * m)
{
  dump_table_ptr (m, 3, "Field Ptr");
}


dump_table_paramptr (struct MonoImage * m)
{
  dump_table_ptr (m, 7, "Param Ptr");
}


dump_table_eventptr (struct MonoImage * m)
{
  dump_table_ptr (m, 19, "Event Ptr");
}


dump_table_propertyptr (struct MonoImage * m)
{
  dump_table_ptr (m, 22, "Property Ptr");
}