dump_table_assembly (struct MonoImage * m)
{
  struct FILE * output.0;
  unsigned int D.14693;
  unsigned int D.14694;
  unsigned int D.14697;
  const char * D.14698;
  unsigned int D.14699;
  unsigned int D.14700;
  unsigned int D.14701;
  unsigned int D.14702;
  unsigned int D.14703;
  unsigned int D.14704;
  unsigned int D.14705;
  const char * ptr.1;
  const char * ptr.2;
  unsigned int D.14708;
  unsigned int D.14712;
  const char * D.14713;
  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.14693 = BIT_FIELD_REF <*t, 32, 32>;
      D.14694 = D.14693 & 16777215;
      if (D.14694 == 0) goto <D.14695>; else goto <D.14696>;
      <D.14695>:
      return;
      <D.14696>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      D.14697 = cols[7];
      D.14698 = mono_metadata_string_heap (m, D.14697);
      output.0 = output;
      fprintf (output.0, "Name:          %s\n", D.14698);
      D.14699 = cols[0];
      output.0 = output;
      fprintf (output.0, "Hash Algoritm: 0x%08x\n", D.14699);
      D.14700 = cols[4];
      D.14701 = cols[3];
      D.14702 = cols[2];
      D.14703 = cols[1];
      output.0 = output;
      fprintf (output.0, "Version:       %d.%d.%d.%d\n", D.14703, D.14702, D.14701, D.14700);
      D.14704 = cols[5];
      output.0 = output;
      fprintf (output.0, "Flags:         0x%08x\n", D.14704);
      D.14705 = cols[6];
      output.0 = output;
      fprintf (output.0, "PublicKey:     BlobPtr (0x%08x)\n", D.14705);
      D.14705 = cols[6];
      ptr.1 = mono_metadata_blob_heap (m, D.14705);
      ptr = ptr.1;
      ptr.2 = ptr;
      D.14708 = mono_metadata_decode_value (ptr.2, &ptr);
      len = (int) D.14708;
      if (len > 0) goto <D.14709>; else goto <D.14710>;
      <D.14709>:
      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.14711>;
      <D.14710>:
      output.0 = output;
      fprintf (output.0, "\tZero sized public key\n");
      <D.14711>:
      D.14712 = cols[8];
      D.14713 = mono_metadata_string_heap (m, D.14712);
      output.0 = output;
      fprintf (output.0, "Culture:       %s\n", D.14713);
      output.0 = output;
      fprintf (output.0, "\n");
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


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

  t = &m->tables[1];
  output.3 = output;
  fprintf (output.3, "Typeref Table\n");
  i = 1;
  goto <D.14129>;
  <D.14128>:
  {
    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.14129>:
  D.14720 = t->rows;
  D.14721 = (int) D.14720;
  if (D.14721 >= i) goto <D.14128>; else goto <D.14130>;
  <D.14130>:
  output.3 = output;
  fprintf (output.3, "\n");
}


dump_table_typedef (struct MonoImage * m)
{
  struct FILE * output.4;
  int D.14723;
  struct MonoTableInfo * D.14724;
  unsigned int D.14725;
  unsigned int D.14726;
  unsigned int D.14727;
  unsigned int D.14728;
  <unnamed-unsigned:24> D.14729;
  int D.14730;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        s = get_typedef (m, i);
        D.14723 = i + -1;
        D.14724 = &m->tables[2];
        mono_metadata_decode_row (D.14724, D.14723, &cols, 6);
        D.14725 = cols[3];
        D.14726 = cols[0];
        D.14727 = cols[5];
        D.14728 = cols[4];
        output.4 = output;
        fprintf (output.4, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i, s, D.14728, D.14727, D.14726, D.14725);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14139>:
  D.14729 = t->rows;
  D.14730 = (int) D.14729;
  if (D.14730 >= i) goto <D.14138>; else goto <D.14140>;
  <D.14140>:
  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.14733;
  int D.14734;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[27];
  output.5 = output;
  fprintf (output.5, "Typespec Table\n");
  i = 1;
  goto <D.14148>;
  <D.14147>:
  {
    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.14148>:
  D.14733 = t->rows;
  D.14734 = (int) D.14733;
  if (D.14734 >= i) goto <D.14147>; else goto <D.14149>;
  <D.14149>:
  output.5 = output;
  fprintf (output.5, "\n");
}


dump_table_assemblyref (struct MonoImage * m)
{
  struct FILE * output.7;
  unsigned int D.14736;
  const char * D.14737;
  unsigned int D.14738;
  unsigned int D.14739;
  unsigned int D.14740;
  unsigned int D.14741;
  int D.14742;
  unsigned int D.14743;
  unsigned int D.14744;
  const char * ptr.8;
  const char * ptr.9;
  unsigned int D.14747;
  <unnamed-unsigned:24> D.14751;
  int D.14752;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        D.14736 = cols[6];
        D.14737 = mono_metadata_string_heap (m, D.14736);
        D.14738 = cols[3];
        D.14739 = cols[2];
        D.14740 = cols[1];
        D.14741 = cols[0];
        D.14742 = i + 1;
        output.7 = output;
        fprintf (output.7, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", D.14742, D.14741, D.14740, D.14739, D.14738, D.14737);
        D.14743 = cols[4];
        output.7 = output;
        fprintf (output.7, "\tFlags=0x%08x\n", D.14743);
        D.14744 = cols[5];
        ptr.8 = mono_metadata_blob_heap (m, D.14744);
        ptr = ptr.8;
        ptr.9 = ptr;
        D.14747 = mono_metadata_decode_value (ptr.9, &ptr);
        len = (int) D.14747;
        if (len > 0) goto <D.14748>; else goto <D.14749>;
        <D.14748>:
        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.14750>;
        <D.14749>:
        output.7 = output;
        fprintf (output.7, "\tZero sized public key\n");
        <D.14750>:
      }
    finally
      {
        ptr = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14159>:
  D.14751 = t->rows;
  D.14752 = (int) D.14751;
  if (D.14752 > i) goto <D.14158>; else goto <D.14160>;
  <D.14160>:
  output.7 = output;
  fprintf (output.7, "\n");
}


dump_table_param (struct MonoImage * m)
{
  struct FILE * output.10;
  unsigned int D.14754;
  const char * D.14755;
  unsigned int D.14756;
  unsigned int D.14757;
  int D.14758;
  <unnamed-unsigned:24> D.14759;
  int D.14760;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14754 = cols[2];
        D.14755 = mono_metadata_string_heap (m, D.14754);
        D.14756 = cols[1];
        D.14757 = cols[0];
        D.14758 = i + 1;
        output.10 = output;
        fprintf (output.10, "%d: 0x%04x %d %s\n", D.14758, D.14757, D.14756, D.14755);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14168>:
  D.14759 = t->rows;
  D.14760 = (int) D.14759;
  if (D.14760 > i) goto <D.14167>; else goto <D.14169>;
  <D.14169>:
  output.10 = output;
  fprintf (output.10, "\n");
}


dump_table_field (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14761;
  int D.14762;
  struct FILE * output.11;
  <unnamed-unsigned:24> D.14764;
  int D.14765;
  unsigned int i.12;
  int D.14768;
  int D.14771;
  unsigned int D.14772;
  const char * D.14773;
  unsigned int D.14774;
  const char * D.14775;
  int D.14776;
  unsigned int D.14777;
  unsigned int D.14778;
  unsigned int D.14779;
  const char * D.14780;
  <unnamed-unsigned:24> D.14781;
  int D.14782;
  int D.14785;
  unsigned int D.14786;
  unsigned int i.13;
  unsigned int D.14790;
  <unnamed-unsigned:24> D.14791;
  int D.14792;
  int D.14795;
  unsigned int D.14796;
  unsigned int D.14799;
  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.14761 = t->rows;
  D.14762 = (int) D.14761;
  output.11 = output;
  fprintf (output.11, "Field Table (1..%d)\n", D.14762);
  current_type = 1;
  offset_row = current_type;
  rva_row = offset_row;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14190>;
  <D.14189>:
  {
    guint32 cols[3];
    char * sig;
    char * flags;

    try
      {
        goto <D.14187>;
        <D.14186>:
        current_type = current_type + 1;
        <D.14187>:
        D.14764 = td->rows;
        D.14765 = (int) D.14764;
        if (D.14765 >= current_type) goto <D.14766>; else goto <D.14188>;
        <D.14766>:
        i.12 = (unsigned int) i;
        D.14768 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.14768, 4);
        if (i.12 >= last_m) goto <D.14186>; else goto <D.14188>;
        <D.14188>:
        i.12 = (unsigned int) i;
        if (i.12 == first_m) goto <D.14769>; else goto <D.14770>;
        <D.14769>:
        D.14771 = current_type + -2;
        D.14772 = mono_metadata_decode_row_col (td, D.14771, 1);
        D.14773 = mono_metadata_string_heap (m, D.14772);
        D.14771 = current_type + -2;
        D.14774 = mono_metadata_decode_row_col (td, D.14771, 2);
        D.14775 = mono_metadata_string_heap (m, D.14774);
        output.11 = output;
        fprintf (output.11, "########## %s.%s\n", D.14775, D.14773);
        first_m = last_m;
        <D.14770>:
        D.14776 = i + -1;
        mono_metadata_decode_row (t, D.14776, &cols, 3);
        D.14777 = cols[2];
        sig = get_field_signature (m, D.14777, 0B);
        D.14778 = cols[0];
        flags = field_flags (D.14778);
        D.14779 = cols[1];
        D.14780 = mono_metadata_string_heap (m, D.14779);
        output.11 = output;
        fprintf (output.11, "%d: %s %s: %s\n", i, sig, D.14780, flags);
        monoeg_g_free (sig);
        monoeg_g_free (flags);
        D.14781 = fl->rows;
        D.14782 = (int) D.14781;
        if (D.14782 >= offset_row) goto <D.14783>; else goto <D.14784>;
        <D.14783>:
        D.14785 = offset_row + -1;
        D.14786 = mono_metadata_decode_row_col (fl, D.14785, 1);
        i.13 = (unsigned int) i;
        if (D.14786 == i.13) goto <D.14788>; else goto <D.14789>;
        <D.14788>:
        D.14785 = offset_row + -1;
        D.14790 = mono_metadata_decode_row_col (fl, D.14785, 0);
        output.11 = output;
        fprintf (output.11, "\texplicit offset: %d\n", D.14790);
        offset_row = offset_row + 1;
        <D.14789>:
        <D.14784>:
        D.14791 = rva->rows;
        D.14792 = (int) D.14791;
        if (D.14792 >= rva_row) goto <D.14793>; else goto <D.14794>;
        <D.14793>:
        D.14795 = rva_row + -1;
        D.14796 = mono_metadata_decode_row_col (rva, D.14795, 1);
        i.13 = (unsigned int) i;
        if (D.14796 == i.13) goto <D.14797>; else goto <D.14798>;
        <D.14797>:
        D.14795 = rva_row + -1;
        D.14799 = mono_metadata_decode_row_col (rva, D.14795, 0);
        output.11 = output;
        fprintf (output.11, "\trva: %d\n", D.14799);
        rva_row = rva_row + 1;
        <D.14798>:
        <D.14794>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14190>:
  D.14761 = t->rows;
  D.14762 = (int) D.14761;
  if (D.14762 >= i) goto <D.14189>; else goto <D.14191>;
  <D.14191>:
  output.11 = output;
  fprintf (output.11, "\n");
}


dump_table_memberref (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14800;
  int D.14801;
  struct FILE * output.14;
  unsigned int D.14803;
  int D.14804;
  unsigned int D.14805;
  unsigned int D.14806;
  const char * D.14807;
  const char * D.14808;
  unsigned int idx.15;
  const char * D.14810;
  unsigned int D.14811;
  const char * blob.16;
  const char * blob.17;
  char D.14814;
  const char * iftmp.18;
  const char * D.14822;
  int D.14823;
  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.14800 = t->rows;
      D.14801 = (int) D.14800;
      output.14 = output;
      fprintf (output.14, "MemberRef Table (1..%d)\n", D.14801);
      i = 0;
      goto <D.14214>;
      <D.14213>:
      {
        guint32 cols[3];

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            D.14803 = cols[0];
            D.14804 = (int) D.14803;
            kind = D.14804 & 7;
            D.14803 = cols[0];
            D.14805 = D.14803 >> 3;
            idx = (int) D.14805;
            x = monoeg_strdup ("UNHANDLED CASE");
            switch (kind) <default: <D.14211>, case 0: <D.14205>, case 1: <D.14207>, case 2: <D.14208>, case 3: <D.14209>, case 4: <D.14210>>
            <D.14205>:
            ks = "TypeDef";
            xx = get_typedef (m, idx);
            D.14806 = cols[1];
            D.14807 = mono_metadata_string_heap (m, D.14806);
            x = monoeg_g_strconcat (xx, ".", D.14807, 0B);
            monoeg_g_free (xx);
            goto <D.14206>;
            <D.14207>:
            ks = "TypeRef";
            xx = get_typeref (m, idx);
            D.14806 = cols[1];
            D.14808 = mono_metadata_string_heap (m, D.14806);
            x = monoeg_g_strconcat (xx, ".", D.14808, 0B);
            monoeg_g_free (xx);
            goto <D.14206>;
            <D.14208>:
            ks = "ModuleRef";
            goto <D.14206>;
            <D.14209>:
            ks = "MethodDef";
            idx.15 = (unsigned int) idx;
            x = get_methoddef (m, idx.15);
            goto <D.14206>;
            <D.14210>:
            ks = "TypeSpec";
            idx.15 = (unsigned int) idx;
            xx = get_typespec (m, idx.15, 0, 0B);
            D.14806 = cols[1];
            D.14810 = mono_metadata_string_heap (m, D.14806);
            x = monoeg_g_strconcat (xx, ".", D.14810, 0B);
            monoeg_g_free (xx);
            goto <D.14206>;
            <D.14211>:
            monoeg_g_log (0B, 4, "Unknown tag: %d\n", kind);
            <D.14212>:
            goto <D.14212>;
            <D.14206>:
            D.14811 = cols[2];
            blob.16 = mono_metadata_blob_heap (m, D.14811);
            blob = blob.16;
            blob.17 = blob;
            mono_metadata_decode_blob_size (blob.17, &blob);
            blob.17 = blob;
            D.14814 = *blob.17;
            if (D.14814 == 6) goto <D.14815>; else goto <D.14816>;
            <D.14815>:
            D.14811 = cols[2];
            sig = get_field_signature (m, D.14811, 0B);
            goto <D.14817>;
            <D.14816>:
            D.14811 = cols[2];
            sig = get_methodref_signature (m, D.14811, 0B);
            <D.14817>:
            if (x != 0B) goto <D.14819>; else goto <D.14820>;
            <D.14819>:
            iftmp.18 = x;
            goto <D.14821>;
            <D.14820>:
            iftmp.18 = "";
            <D.14821>:
            D.14806 = cols[1];
            D.14822 = mono_metadata_string_heap (m, D.14806);
            D.14823 = i + 1;
            output.14 = output;
            fprintf (output.14, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n", D.14823, ks, idx, D.14822, iftmp.18, sig);
            if (x != 0B) goto <D.14824>; else goto <D.14825>;
            <D.14824>:
            monoeg_g_free (x);
            <D.14825>:
            monoeg_g_free (sig);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14214>:
      D.14800 = t->rows;
      D.14801 = (int) D.14800;
      if (D.14801 > i) goto <D.14213>; else goto <D.14215>;
      <D.14215>:
    }
  finally
    {
      blob = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.14826>; else goto <D.14827>;
  <D.14826>:
  D.14828 = __strdup (str);
  return D.14828;
  <D.14827>:
  D.14828 = 0B;
  return D.14828;
}


dump_table_class_layout (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14830;
  int D.14831;
  struct FILE * output.19;
  unsigned int D.14833;
  int D.14834;
  char * D.14835;
  unsigned int D.14836;
  unsigned int D.14837;
  int D.14838;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14833 = cols[2];
        D.14834 = (int) D.14833;
        D.14835 = get_typedef (m, D.14834);
        D.14836 = cols[1];
        D.14837 = cols[0];
        D.14838 = i + 1;
        output.19 = output;
        fprintf (output.19, "%d: PackingSize=%d  ClassSize=%d  Parent=%s\n", D.14838, D.14837, D.14836, D.14835);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14223>:
  D.14830 = t->rows;
  D.14831 = (int) D.14830;
  if (D.14831 > i) goto <D.14222>; else goto <D.14224>;
  <D.14224>:
}


dump_table_constant (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14839;
  int D.14840;
  struct FILE * output.20;
  unsigned int D.14842;
  unsigned int D.14843;
  unsigned int D.14844;
  unsigned int D.14845;
  char * D.14846;
  unsigned int D.14847;
  int D.14848;
  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.14839 = t->rows;
      D.14840 = (int) D.14839;
      output.20 = output;
      fprintf (output.20, "Constant Table (1..%d)\n", D.14840);
      i = 0;
      goto <D.14234>;
      <D.14233>:
      {
        guint32 cols[4];
        const char * parent;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 4);
            D.14842 = cols[2];
            D.14843 = D.14842 & 3;
            parent = desc[D.14843];
            D.14844 = cols[3];
            D.14845 = cols[0];
            D.14846 = get_constant (m, D.14845, D.14844);
            D.14842 = cols[2];
            D.14847 = D.14842 >> 2;
            D.14848 = i + 1;
            output.20 = output;
            fprintf (output.20, "%d: Parent= %s: %d %s\n", D.14848, parent, D.14847, D.14846);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14234>:
      D.14839 = t->rows;
      D.14840 = (int) D.14839;
      if (D.14840 > i) goto <D.14233>; else goto <D.14235>;
      <D.14235>:
    }
  finally
    {
      desc = {CLOBBER};
    }
}


dump_table_property_map (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14849;
  int D.14850;
  struct FILE * output.21;
  unsigned int D.14852;
  int D.14853;
  unsigned int D.14854;
  int D.14855;
  struct MonoTableInfo * t;
  int i;
  char * s;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 2);
        D.14852 = cols[0];
        D.14853 = (int) D.14852;
        s = get_typedef (m, D.14853);
        D.14854 = cols[1];
        D.14852 = cols[0];
        D.14855 = i + 1;
        output.21 = output;
        fprintf (output.21, "%d: %s (%d) %d\n", D.14855, s, D.14852, D.14854);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14244>:
  D.14849 = t->rows;
  D.14850 = (int) D.14849;
  if (D.14850 > i) goto <D.14243>; else goto <D.14245>;
  <D.14245>:
}


dump_table_property (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14856;
  int D.14857;
  struct FILE * output.22;
  unsigned int D.14859;
  int D.14860;
  int D.14863;
  int D.14866;
  unsigned int D.14869;
  const char * ptr.23;
  const char * ptr.24;
  unsigned int D.14872;
  char D.14873;
  _Bool D.14874;
  _Bool D.14875;
  _Bool D.14876;
  int D.14879;
  const char * ptr.25;
  unsigned int D.14881;
  const char * ptr.26;
  unsigned int D.14883;
  const char * D.14884;
  char * type.27;
  int D.14886;
  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.14856 = t->rows;
      D.14857 = (int) D.14856;
      output.22 = output;
      fprintf (output.22, "Property Table (1..%d)\n", D.14857);
      i = 0;
      goto <D.14263>;
      <D.14262>:
      {
        guint32 cols[3];
        char * type;
        int bsize;
        int prop_flags;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            flags[0] = 0;
            D.14859 = cols[0];
            prop_flags = (int) D.14859;
            D.14860 = prop_flags & 512;
            if (D.14860 != 0) goto <D.14861>; else goto <D.14862>;
            <D.14861>:
            strcat (&flags, "special ");
            <D.14862>:
            D.14863 = prop_flags & 1024;
            if (D.14863 != 0) goto <D.14864>; else goto <D.14865>;
            <D.14864>:
            strcat (&flags, "runtime ");
            <D.14865>:
            D.14866 = prop_flags & 4096;
            if (D.14866 != 0) goto <D.14867>; else goto <D.14868>;
            <D.14867>:
            strcat (&flags, "hasdefault ");
            <D.14868>:
            D.14869 = cols[2];
            ptr.23 = mono_metadata_blob_heap (m, D.14869);
            ptr = ptr.23;
            ptr.24 = ptr;
            D.14872 = mono_metadata_decode_blob_size (ptr.24, &ptr);
            bsize = (int) D.14872;
            ptr.24 = ptr;
            D.14873 = *ptr.24;
            D.14874 = D.14873 != 40;
            ptr.24 = ptr;
            D.14873 = *ptr.24;
            D.14875 = D.14873 != 8;
            D.14876 = D.14874 & D.14875;
            if (D.14876 != 0) goto <D.14877>; else goto <D.14878>;
            <D.14877>:
            ptr.24 = ptr;
            D.14873 = *ptr.24;
            D.14879 = (int) D.14873;
            monoeg_g_log (0B, 16, "incorrect signature in propert blob: 0x%x", D.14879);
            <D.14878>:
            ptr.24 = ptr;
            ptr.25 = ptr.24 + 1;
            ptr = ptr.25;
            ptr.24 = ptr;
            D.14881 = mono_metadata_decode_value (ptr.24, &ptr);
            pcount = (int) D.14881;
            ptr.24 = ptr;
            ptr.26 = get_type (m, ptr.24, &type, 0, 0B);
            ptr = ptr.26;
            D.14883 = cols[1];
            D.14884 = mono_metadata_string_heap (m, D.14883);
            type.27 = type;
            D.14886 = i + 1;
            output.22 = output;
            fprintf (output.22, "%d: %s %s (", D.14886, type.27, D.14884);
            type.27 = type;
            monoeg_g_free (type.27);
            j = 0;
            goto <D.14260>;
            <D.14259>:
            ptr.24 = ptr;
            ptr.28 = get_param (m, ptr.24, &type, 0B);
            ptr = ptr.28;
            type.27 = type;
            if (j > 0) goto <D.14889>; else goto <D.14890>;
            <D.14889>:
            iftmp.29 = ", ";
            goto <D.14891>;
            <D.14890>:
            iftmp.29 = "";
            <D.14891>:
            output.22 = output;
            fprintf (output.22, "%s%s", iftmp.29, type.27);
            type.27 = type;
            monoeg_g_free (type.27);
            j = j + 1;
            <D.14260>:
            if (j < pcount) goto <D.14259>; else goto <D.14261>;
            <D.14261>:
            output.22 = output;
            fprintf (output.22, ") %s\n", &flags);
          }
        finally
          {
            cols = {CLOBBER};
            type = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14263>:
      D.14856 = t->rows;
      D.14857 = (int) D.14856;
      if (D.14857 > i) goto <D.14262>; else goto <D.14264>;
      <D.14264>:
    }
  finally
    {
      ptr = {CLOBBER};
      flags = {CLOBBER};
    }
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.14892;
  unsigned int D.14893;

  D.14893 = __builtin_object_size (__dest, 1);
  D.14892 = __builtin___strcat_chk (__dest, __src, D.14893);
  return D.14892;
}


dump_table_event (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14895;
  int D.14896;
  struct FILE * output.30;
  unsigned int D.14898;
  unsigned int D.14899;
  const char * iftmp.31;
  unsigned int D.14901;
  unsigned int D.14902;
  int D.14906;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14898 = cols[1];
        name = mono_metadata_string_heap (m, D.14898);
        D.14899 = cols[2];
        type = get_typedef_or_ref (m, D.14899, 0B);
        D.14901 = cols[0];
        D.14902 = D.14901 & 512;
        if (D.14902 != 0) goto <D.14903>; else goto <D.14904>;
        <D.14903>:
        iftmp.31 = "specialname ";
        goto <D.14905>;
        <D.14904>:
        iftmp.31 = "";
        <D.14905>:
        D.14906 = i + 1;
        output.30 = output;
        fprintf (output.30, "%d: %s %s %s\n", D.14906, type, name, iftmp.31);
        monoeg_g_free (type);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14274>:
  D.14895 = t->rows;
  D.14896 = (int) D.14895;
  if (D.14896 > i) goto <D.14273>; else goto <D.14275>;
  <D.14275>:
}


dump_table_file (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14907;
  int D.14908;
  struct FILE * output.32;
  unsigned int D.14910;
  const char * iftmp.33;
  unsigned int D.14912;
  unsigned int D.14913;
  int D.14917;
  unsigned int D.14918;
  const char * hash.34;
  const char * hash.35;
  unsigned int D.14921;
  sizetype j.36;
  const char * D.14923;
  char D.14924;
  int D.14925;
  int D.14926;
  const char * iftmp.37;
  struct MonoTableInfo * t;
  int i;
  int j;
  int len;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14910 = cols[1];
        name = mono_metadata_string_heap (m, D.14910);
        D.14912 = cols[0];
        D.14913 = D.14912 & 1;
        if (D.14913 != 0) goto <D.14914>; else goto <D.14915>;
        <D.14914>:
        iftmp.33 = "nometadata";
        goto <D.14916>;
        <D.14915>:
        iftmp.33 = "containsmetadata";
        <D.14916>:
        D.14917 = i + 1;
        output.32 = output;
        fprintf (output.32, "%d: %s %s [", D.14917, name, iftmp.33);
        D.14918 = cols[2];
        hash.34 = mono_metadata_blob_heap (m, D.14918);
        hash = hash.34;
        hash.35 = hash;
        D.14921 = mono_metadata_decode_blob_size (hash.35, &hash);
        len = (int) D.14921;
        j = 0;
        goto <D.14287>;
        <D.14286>:
        hash.35 = hash;
        j.36 = (sizetype) j;
        D.14923 = hash.35 + j.36;
        D.14924 = *D.14923;
        D.14925 = (int) D.14924;
        D.14926 = D.14925 & 255;
        if (j != 0) goto <D.14928>; else goto <D.14929>;
        <D.14928>:
        iftmp.37 = " ";
        goto <D.14930>;
        <D.14929>:
        iftmp.37 = "";
        <D.14930>:
        output.32 = output;
        fprintf (output.32, "%s%02X", iftmp.37, D.14926);
        j = j + 1;
        <D.14287>:
        if (j < len) goto <D.14286>; else goto <D.14288>;
        <D.14288>:
        output.32 = output;
        fprintf (output.32, "]\n");
      }
    finally
      {
        cols = {CLOBBER};
        hash = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14290>:
  D.14907 = t->rows;
  D.14908 = (int) D.14907;
  if (D.14908 > i) goto <D.14289>; else goto <D.14291>;
  <D.14291>:
}


dump_table_manifest (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14931;
  int D.14932;
  struct FILE * output.38;
  unsigned int D.14934;
  unsigned int D.14935;
  unsigned int D.14936;
  unsigned int D.14937;
  int D.14938;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 4);
        D.14934 = cols[2];
        name = mono_metadata_string_heap (m, D.14934);
        D.14935 = cols[1];
        mf = get_manifest_flags (D.14935);
        D.14936 = cols[3];
        impl = get_manifest_implementation (m, D.14936);
        D.14937 = cols[0];
        D.14938 = i + 1;
        output.38 = output;
        fprintf (output.38, "%d: %s \'%s\' at offset %u in %s\n", D.14938, mf, name, D.14937, impl);
        monoeg_g_free (impl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14319>:
  D.14931 = t->rows;
  D.14932 = (int) D.14931;
  if (D.14932 > i) goto <D.14318>; else goto <D.14320>;
  <D.14320>:
}


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

  mf = mf & 3;
  switch (mf) <default: <D.14308>, case 1: <D.14306>, case 2: <D.14307>>
  <D.14306>:
  D.14939 = "public";
  return D.14939;
  <D.14307>:
  D.14939 = "private";
  return D.14939;
  <D.14308>:
  D.14939 = "";
  return D.14939;
}


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

  table = "";
  if (idx == 0) goto <D.14941>; else goto <D.14942>;
  <D.14941>:
  D.14943 = monoeg_strdup ("current module");
  return D.14943;
  <D.14942>:
  row = idx >> 2;
  D.14944 = idx & 3;
  switch (D.14944) <default: <D.14302>, case 0: <D.14298>, case 1: <D.14300>, case 2: <D.14301>>
  <D.14298>:
  table = "file";
  goto <D.14299>;
  <D.14300>:
  table = "assemblyref";
  goto <D.14299>;
  <D.14301>:
  table = "exportedtype";
  goto <D.14299>;
  <D.14302>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dump.c", 475);
  <D.14299>:
  D.14943 = monoeg_g_strdup_printf ("%s %d", table, row);
  return D.14943;
}


dump_table_moduleref (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14946;
  int D.14947;
  struct FILE * output.39;
  unsigned int D.14949;
  int D.14950;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 1);
        D.14949 = cols[0];
        name = mono_metadata_string_heap (m, D.14949);
        D.14950 = i + 1;
        output.39 = output;
        fprintf (output.39, "%d: %s\n", D.14950, name);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14329>:
  D.14946 = t->rows;
  D.14947 = (int) D.14946;
  if (D.14947 > i) goto <D.14328>; else goto <D.14330>;
  <D.14330>:
}


dump_table_module (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14951;
  int D.14952;
  struct FILE * output.40;
  unsigned int D.14954;
  unsigned int D.14955;
  int D.14956;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 5);
        D.14954 = cols[1];
        name = mono_metadata_string_heap (m, D.14954);
        D.14955 = cols[2];
        guid = get_guid (m, D.14955);
        D.14955 = cols[2];
        D.14956 = i + 1;
        output.40 = output;
        fprintf (output.40, "%d: %s %d %s\n", D.14956, name, D.14955, guid);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14340>:
  D.14951 = t->rows;
  D.14952 = (int) D.14951;
  if (D.14952 > i) goto <D.14339>; else goto <D.14341>;
  <D.14341>:
}


dump_table_method (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14957;
  int D.14958;
  struct FILE * output.41;
  <unnamed-unsigned:24> D.14960;
  int D.14961;
  unsigned int i.42;
  int D.14964;
  int D.14967;
  unsigned int D.14968;
  const char * D.14969;
  unsigned int D.14970;
  const char * D.14971;
  int D.14972;
  unsigned int D.14973;
  int D.14976;
  unsigned int D.14977;
  int D.14980;
  unsigned int D.14981;
  const char * sigblob.43;
  const char * sigblob.44;
  struct MonoGenericContainer * iftmp.45;
  struct MonoGenericContainer * iftmp.46;
  unsigned int D.14992;
  unsigned int D.14993;
  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.14957 = t->rows;
  D.14958 = (int) D.14957;
  output.41 = output;
  fprintf (output.41, "Method Table (1..%d)\n", D.14958);
  current_type = 1;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14362>;
  <D.14361>:
  {
    guint32 cols[6];
    char * sig;
    char * impl_flags;
    const char * sigblob;
    struct MonoMethodSignature * method;

    try
      {
        goto <D.14359>;
        <D.14358>:
        current_type = current_type + 1;
        <D.14359>:
        D.14960 = td->rows;
        D.14961 = (int) D.14960;
        if (D.14961 >= current_type) goto <D.14962>; else goto <D.14360>;
        <D.14962>:
        i.42 = (unsigned int) i;
        D.14964 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.14964, 5);
        if (i.42 >= last_m) goto <D.14358>; else goto <D.14360>;
        <D.14360>:
        i.42 = (unsigned int) i;
        if (i.42 == first_m) goto <D.14965>; else goto <D.14966>;
        <D.14965>:
        D.14967 = current_type + -2;
        D.14968 = mono_metadata_decode_row_col (td, D.14967, 1);
        D.14969 = mono_metadata_string_heap (m, D.14968);
        D.14967 = current_type + -2;
        D.14970 = mono_metadata_decode_row_col (td, D.14967, 2);
        D.14971 = mono_metadata_string_heap (m, D.14970);
        output.41 = output;
        fprintf (output.41, "########## %s.%s\n", D.14971, D.14969);
        first_m = last_m;
        D.14964 = current_type + -1;
        D.14972 = D.14964 | 33554432;
        D.14973 = (unsigned int) D.14972;
        type_container = mono_metadata_load_generic_params (m, D.14973, 0B);
        if (type_container != 0B) goto <D.14974>; else goto <D.14975>;
        <D.14974>:
        D.14964 = current_type + -1;
        D.14972 = D.14964 | 33554432;
        D.14973 = (unsigned int) D.14972;
        mono_metadata_load_generic_param_constraints (m, D.14973, type_container);
        <D.14975>:
        <D.14966>:
        D.14976 = i | 100663296;
        D.14977 = (unsigned int) D.14976;
        method_container = mono_metadata_load_generic_params (m, D.14977, type_container);
        if (method_container != 0B) goto <D.14978>; else goto <D.14979>;
        <D.14978>:
        D.14976 = i | 100663296;
        D.14977 = (unsigned int) D.14976;
        mono_metadata_load_generic_param_constraints (m, D.14977, method_container);
        <D.14979>:
        D.14980 = i + -1;
        mono_metadata_decode_table_row (m, 6, D.14980, &cols, 6);
        D.14981 = cols[4];
        sigblob.43 = mono_metadata_blob_heap (m, D.14981);
        sigblob = sigblob.43;
        sigblob.44 = sigblob;
        mono_metadata_decode_blob_size (sigblob.44, &sigblob);
        sigblob.44 = sigblob;
        if (method_container != 0B) goto <D.14985>; else goto <D.14986>;
        <D.14985>:
        iftmp.45 = method_container;
        goto <D.14987>;
        <D.14986>:
        iftmp.45 = type_container;
        <D.14987>:
        method = mono_metadata_parse_method_signature_full (m, iftmp.45, i, sigblob.44, &sigblob);
        if (method_container != 0B) goto <D.14989>; else goto <D.14990>;
        <D.14989>:
        iftmp.46 = method_container;
        goto <D.14991>;
        <D.14990>:
        iftmp.46 = type_container;
        <D.14991>:
        sig = dis_stringify_method_signature (m, method, i, iftmp.46, 0);
        D.14992 = cols[1];
        impl_flags = get_method_impl_flags (D.14992);
        D.14993 = cols[5];
        output.41 = output;
        fprintf (output.41, "%d: %s (param: %d impl_flags: %s)\n", i, sig, D.14993, 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.14362>:
  D.14957 = t->rows;
  D.14958 = (int) D.14957;
  if (D.14958 >= i) goto <D.14361>; else goto <D.14363>;
  <D.14363>:
}


dump_table_implmap (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.14994;
  int D.14995;
  struct FILE * output.47;
  int D.14997;
  unsigned int D.14998;
  unsigned int D.14999;
  unsigned int D.15000;
  unsigned int D.15001;
  unsigned int D.15002;
  int D.15003;
  unsigned int D.15004;
  const char * D.15005;
  unsigned int D.15006;
  const char * D.15007;
  unsigned int D.15008;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  int i;

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

    try
      {
        D.14997 = i + -1;
        mono_metadata_decode_row (t, D.14997, &cols, 4);
        D.14998 = cols[1];
        D.14999 = D.14998 >> 1;
        D.15000 = D.14999 | 100663296;
        method = get_method (m, D.15000, 0B);
        D.15001 = cols[3];
        D.15002 = D.15001 + 4294967295;
        D.15003 = (int) D.15002;
        D.15004 = mono_metadata_decode_row_col (td, D.15003, 0);
        D.15005 = mono_metadata_string_heap (m, D.15004);
        D.15006 = cols[2];
        D.15007 = mono_metadata_string_heap (m, D.15006);
        D.15008 = cols[0];
        output.47 = output;
        fprintf (output.47, "%d: %s %d (%s %s)\n", i, method, D.15008, D.15007, D.15005);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14373>:
  D.14994 = t->rows;
  D.14995 = (int) D.14994;
  if (D.14995 >= i) goto <D.14372>; else goto <D.14374>;
  <D.14374>:
}


dump_table_fieldrva (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15009;
  int D.15010;
  struct FILE * output.48;
  int D.15012;
  unsigned int D.15013;
  unsigned int D.15014;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[29];
  D.15009 = t->rows;
  D.15010 = (int) D.15009;
  output.48 = output;
  fprintf (output.48, "FieldRVA Table (1..%d)\n", D.15010);
  i = 1;
  goto <D.14382>;
  <D.14381>:
  {
    guint32 cols[2];

    try
      {
        D.15012 = i + -1;
        mono_metadata_decode_row (t, D.15012, &cols, 2);
        D.15013 = cols[0];
        D.15014 = cols[1];
        output.48 = output;
        fprintf (output.48, "%d: Field %d: %x\n", i, D.15014, D.15013);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14382>:
  D.15009 = t->rows;
  D.15010 = (int) D.15009;
  if (D.15010 >= i) goto <D.14381>; else goto <D.14383>;
  <D.14383>:
}


dump_table_methodimpl (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15015;
  int D.15016;
  struct FILE * output.49;
  int D.15018;
  unsigned int D.15019;
  int D.15020;
  unsigned int D.15021;
  unsigned int D.15022;
  unsigned int D.15023;
  unsigned int D.15024;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15018 = i + -1;
        mono_metadata_decode_row (t, D.15018, &cols, 3);
        D.15019 = cols[0];
        D.15020 = (int) D.15019;
        class = get_typedef (m, D.15020);
        D.15021 = cols[1];
        D.15022 = method_dor_to_token (D.15021);
        impl = get_method (m, D.15022, 0B);
        D.15023 = cols[2];
        D.15024 = method_dor_to_token (D.15023);
        decl = get_method (m, D.15024, 0B);
        output.49 = output;
        fprintf (output.49, "%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.14394>:
  D.15015 = t->rows;
  D.15016 = (int) D.15015;
  if (D.15016 >= i) goto <D.14393>; else goto <D.14395>;
  <D.14395>:
}


dump_table_methodsem (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15025;
  int D.15026;
  struct FILE * output.50;
  int D.15028;
  unsigned int D.15029;
  unsigned int D.15030;
  int D.15031;
  unsigned int D.15032;
  const char * iftmp.51;
  unsigned int D.15037;
  unsigned int D.15038;
  struct MonoTableInfo * t;
  int i;
  int is_property;
  int index;
  const char * semantics;

  t = &m->tables[24];
  D.15025 = t->rows;
  D.15026 = (int) D.15025;
  output.50 = output;
  fprintf (output.50, "Method Semantics Table (1..%d)\n", D.15026);
  i = 1;
  goto <D.14407>;
  <D.14406>:
  {
    guint32 cols[3];

    try
      {
        D.15028 = i + -1;
        mono_metadata_decode_row (t, D.15028, &cols, 3);
        D.15029 = cols[0];
        semantics = flags (D.15029, &semantics_map);
        D.15030 = cols[2];
        D.15031 = (int) D.15030;
        is_property = D.15031 & 1;
        D.15030 = cols[2];
        D.15032 = D.15030 >> 1;
        index = (int) D.15032;
        if (is_property != 0) goto <D.15034>; else goto <D.15035>;
        <D.15034>:
        iftmp.51 = "property";
        goto <D.15036>;
        <D.15035>:
        iftmp.51 = "event";
        <D.15036>:
        D.15037 = cols[1];
        D.15038 = D.15037 + 4294967295;
        D.15030 = cols[2];
        output.50 = output;
        fprintf (output.50, "%d: [%d] %s method: %d %s %d\n", i, D.15030, semantics, D.15038, iftmp.51, index);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14407>:
  D.15025 = t->rows;
  D.15026 = (int) D.15025;
  if (D.15026 >= i) goto <D.14406>; else goto <D.14408>;
  <D.14408>:
}


dump_table_interfaceimpl (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15039;
  int D.15040;
  struct FILE * output.52;
  int D.15042;
  unsigned int D.15043;
  char * D.15044;
  unsigned int D.15045;
  int D.15046;
  char * D.15047;
  struct MonoTableInfo * t;
  int i;

  t = &m->tables[9];
  D.15039 = t->rows;
  D.15040 = (int) D.15039;
  output.52 = output;
  fprintf (output.52, "Interface Implementation Table (1..%d)\n", D.15040);
  i = 1;
  goto <D.14416>;
  <D.14415>:
  {
    guint32 cols[2];

    try
      {
        D.15042 = i + -1;
        mono_metadata_decode_row (t, D.15042, &cols, 2);
        D.15043 = cols[1];
        D.15044 = get_typedef_or_ref (m, D.15043, 0B);
        D.15045 = cols[0];
        D.15046 = (int) D.15045;
        D.15047 = get_typedef (m, D.15046);
        output.52 = output;
        fprintf (output.52, "%d: %s implements %s\n", i, D.15047, D.15044);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14416>:
  D.15039 = t->rows;
  D.15040 = (int) D.15039;
  if (D.15040 >= i) goto <D.14415>; else goto <D.14417>;
  <D.14417>:
}


dump_table_customattr (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15048;
  int D.15049;
  struct FILE * output.53;
  int D.15051;
  unsigned int D.15052;
  unsigned int D.15053;
  unsigned int D.15054;
  unsigned int D.15055;
  const char * D.15056;
  struct MonoMethodSignature * D.15057;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15051 = i + -1;
        mono_metadata_decode_row (t, D.15051, &cols, 3);
        D.15052 = cols[0];
        desc = has_cattr_get_table (m, D.15052);
        D.15053 = cols[1];
        mtoken = D.15053 >> 3;
        D.15053 = cols[1];
        D.15054 = D.15053 & 7;
        switch (D.15054) <default: <D.14503>, case 2: <D.14500>, case 3: <D.14502>>
        <D.14500>:
        mtoken = mtoken | 100663296;
        goto <D.14501>;
        <D.14502>:
        mtoken = mtoken | 167772160;
        goto <D.14501>;
        <D.14503>:
        D.15053 = cols[1];
        monoeg_g_log (0B, 16, "Unknown table for custom attr type %08x", D.15053);
        goto <D.14501>;
        <D.14501>:
        method = get_method (m, mtoken, 0B);
        meth = mono_get_method (m, mtoken, 0B);
        D.15055 = cols[2];
        D.15056 = mono_metadata_blob_heap (m, D.15055);
        D.15057 = mono_method_signature (meth);
        params = custom_attr_params (m, D.15057, D.15056);
        output.53 = output;
        fprintf (output.53, "%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.14505>:
  D.15048 = t->rows;
  D.15049 = (int) D.15048;
  if (D.15049 >= i) goto <D.14504>; else goto <D.14506>;
  <D.14506>:
}


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

  t = val & 31;
  index = val >> 5;
  switch (t) <default: <D.14446>, case 0: <D.14425>, case 1: <D.14427>, case 2: <D.14428>, case 3: <D.14429>, case 4: <D.14430>, case 5: <D.14431>, case 6: <D.14432>, case 7: <D.14433>, case 8: <D.14434>, case 9: <D.14435>, case 10: <D.14436>, case 11: <D.14437>, case 12: <D.14438>, case 13: <D.14439>, case 14: <D.14440>, case 15: <D.14441>, case 16: <D.14442>, case 17: <D.14443>, case 18: <D.14444>, case 19: <D.14445>>
  <D.14425>:
  table = "MethodDef";
  goto <D.14426>;
  <D.14427>:
  table = "FieldDef";
  goto <D.14426>;
  <D.14428>:
  table = "TypeRef";
  goto <D.14426>;
  <D.14429>:
  table = "TypeDef";
  goto <D.14426>;
  <D.14430>:
  table = "Param";
  goto <D.14426>;
  <D.14431>:
  table = "InterfaceImpl";
  goto <D.14426>;
  <D.14432>:
  table = "MemberRef";
  goto <D.14426>;
  <D.14433>:
  table = "Module";
  goto <D.14426>;
  <D.14434>:
  table = "DeclSecurity?";
  goto <D.14426>;
  <D.14435>:
  table = "Property";
  goto <D.14426>;
  <D.14436>:
  table = "Event";
  goto <D.14426>;
  <D.14437>:
  table = "StandAloneSignature";
  goto <D.14426>;
  <D.14438>:
  table = "ModuleRef";
  goto <D.14426>;
  <D.14439>:
  table = "TypeSpec";
  goto <D.14426>;
  <D.14440>:
  table = "Assembly";
  goto <D.14426>;
  <D.14441>:
  table = "AssemblyRef";
  goto <D.14426>;
  <D.14442>:
  table = "File";
  goto <D.14426>;
  <D.14443>:
  table = "ExportedType";
  goto <D.14426>;
  <D.14444>:
  table = "Manifest";
  goto <D.14426>;
  <D.14445>:
  table = "GenericParam";
  goto <D.14426>;
  <D.14446>:
  table = "Unknown";
  goto <D.14426>;
  <D.14426>:
  D.15058 = monoeg_g_strdup_printf ("%s: %d", table, index);
  return D.15058;
}


custom_attr_params (struct MonoImage * m, struct MonoMethodSignature * sig, const char * value)
{
  const char * p.54;
  unsigned int D.15061;
  short unsigned int D.15065;
  char * D.15066;
  const char * p.55;
  struct MonoType * D.15070;
  unsigned char D.15071;
  char D.15072;
  unsigned int D.15073;
  const char * p.56;
  int D.15075;
  const char * iftmp.57;
  int D.15080;
  short int D.15081;
  int D.15082;
  unsigned int D.15083;
  const char * p.58;
  int D.15085;
  long long unsigned int D.15086;
  long long int D.15087;
  const char * p.59;
  float val.60;
  float val.61;
  double D.15091;
  int D.15098;
  double val.62;
  double val.63;
  int D.15110;
  struct MonoClass * D.15114;
  int D.15115;
  struct MonoType * D.15118;
  unsigned char D.15119;
  unsigned int D.15122;
  sizetype slen.64;
  const char * p.65;
  int D.15125;
  short unsigned int D.15126;
  int D.15127;
  int value.66;
  int p.67;
  int D.15132;
  int D.15133;
  sizetype i.68;
  const char * D.15135;
  char D.15136;
  int D.15137;
  int D.15138;
  int len;
  int i;
  int slen;
  int type;
  struct GString * res;
  char * s;
  const char * p;
  void handle_enum = <<< error >>>;

  try
    {
      p = value;
      p.54 = p;
      D.15061 = mono_metadata_decode_value (p.54, &p);
      len = (int) D.15061;
      if (len <= 1) goto <D.15062>; else goto <D.15064>;
      <D.15064>:
      p.54 = p;
      D.15065 = MEM[(const guint16 *)p.54];
      if (D.15065 != 1) goto <D.15062>; else goto <D.15063>;
      <D.15062>:
      D.15066 = monoeg_strdup ("");
      return D.15066;
      <D.15063>:
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      res = monoeg_g_string_new ("");
      i = 0;
      goto <D.14484>;
      <D.14483>:
      if (i != 0) goto <D.15068>; else goto <D.15069>;
      <D.15068>:
      monoeg_g_string_append (res, ", ");
      <D.15069>:
      D.15070 = sig->params[i];
      D.15071 = D.15070->type;
      type = (int) D.15071;
      handle_enum:
      switch (type) <default: <D.14482>, case 2: <D.14463>, case 3: <D.14464>, case 4: <D.14462>, case 5: <D.14460>, case 6: <D.14466>, case 7: <D.14465>, case 8: <D.14468>, case 9: <D.14467>, case 10: <D.14470>, case 11: <D.14469>, case 12: <D.14471>, case 13: <D.14475>, case 14: <D.14481>, case 17: <D.14479>, case 18: <D.14480>>
      <D.14460>:
      p.54 = p;
      D.15072 = *p.54;
      D.15073 = (unsigned int) D.15072;
      monoeg_g_string_append_printf (res, "%d", D.15073);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14461>;
      <D.14462>:
      p.54 = p;
      D.15072 = *p.54;
      D.15075 = (int) D.15072;
      monoeg_g_string_append_printf (res, "%d", D.15075);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14461>;
      <D.14463>:
      p.54 = p;
      D.15072 = *p.54;
      if (D.15072 != 0) goto <D.15077>; else goto <D.15078>;
      <D.15077>:
      iftmp.57 = "true";
      goto <D.15079>;
      <D.15078>:
      iftmp.57 = "false";
      <D.15079>:
      monoeg_g_string_append_printf (res, "%s", iftmp.57);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14461>;
      <D.14464>:
      p.54 = p;
      D.15065 = MEM[(const guint16 *)p.54];
      D.15080 = (int) D.15065;
      monoeg_g_string_append_printf (res, "\'%c\'", D.15080);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14461>;
      <D.14465>:
      p.54 = p;
      D.15065 = MEM[(const guint16 *)p.54];
      D.15080 = (int) D.15065;
      monoeg_g_string_append_printf (res, "%d", D.15080);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14461>;
      <D.14466>:
      p.54 = p;
      D.15065 = MEM[(const guint16 *)p.54];
      D.15081 = (short int) D.15065;
      D.15082 = (int) D.15081;
      monoeg_g_string_append_printf (res, "%d", D.15082);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14461>;
      <D.14467>:
      p.54 = p;
      D.15083 = MEM[(const guint32 *)p.54];
      monoeg_g_string_append_printf (res, "%d", D.15083);
      p.54 = p;
      p.58 = p.54 + 4;
      p = p.58;
      goto <D.14461>;
      <D.14468>:
      p.54 = p;
      D.15083 = MEM[(const guint32 *)p.54];
      D.15085 = (int) D.15083;
      monoeg_g_string_append_printf (res, "%d", D.15085);
      p.54 = p;
      p.58 = p.54 + 4;
      p = p.58;
      goto <D.14461>;
      <D.14469>:
      p.54 = p;
      D.15086 = MEM[(const guint64 *)p.54];
      D.15087 = (long long int) D.15086;
      monoeg_g_string_append_printf (res, "%lld", D.15087);
      p.54 = p;
      p.59 = p.54 + 8;
      p = p.59;
      goto <D.14461>;
      <D.14470>:
      p.54 = p;
      D.15086 = MEM[(const guint64 *)p.54];
      D.15087 = (long long int) D.15086;
      monoeg_g_string_append_printf (res, "%lld", D.15087);
      p.54 = p;
      p.59 = p.54 + 8;
      p = p.59;
      goto <D.14461>;
      <D.14471>:
      {
        float val;
        int inf;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  p.54 = p;
                  D.15083 = MEM[(const guint32 *)p.54];
                  mf.ival = D.15083;
                  val.60 = mf.fval;
                  val = val.60;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.61 = val;
            D.15091 = (double) val.61;
            inf = dis_isinf (D.15091);
            if (inf == -1) goto <D.15092>; else goto <D.15093>;
            <D.15092>:
            monoeg_g_string_append_printf (res, "(00 00 80 ff)");
            goto <D.15094>;
            <D.15093>:
            if (inf == 1) goto <D.15095>; else goto <D.15096>;
            <D.15095>:
            monoeg_g_string_append_printf (res, "(00 00 80 7f)");
            goto <D.15097>;
            <D.15096>:
            val.61 = val;
            D.15091 = (double) val.61;
            D.15098 = dis_isnan (D.15091);
            if (D.15098 != 0) goto <D.15099>; else goto <D.15100>;
            <D.15099>:
            monoeg_g_string_append_printf (res, "(00 00 c0 ff)");
            goto <D.15101>;
            <D.15100>:
            val.61 = val;
            D.15091 = (double) val.61;
            monoeg_g_string_append_printf (res, "%g", D.15091);
            <D.15101>:
            <D.15097>:
            <D.15094>:
            p.54 = p;
            p.58 = p.54 + 4;
            p = p.58;
            goto <D.14461>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14475>:
      {
        double val;
        int inf;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  p.54 = p;
                  D.15086 = MEM[(const guint64 *)p.54];
                  mf.ival = D.15086;
                  val.62 = mf.fval;
                  val = val.62;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.63 = val;
            inf = dis_isinf (val.63);
            if (inf == -1) goto <D.15104>; else goto <D.15105>;
            <D.15104>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 ff)");
            goto <D.15106>;
            <D.15105>:
            if (inf == 1) goto <D.15107>; else goto <D.15108>;
            <D.15107>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 7f)");
            goto <D.15109>;
            <D.15108>:
            val.63 = val;
            D.15110 = __isnan (val.63);
            if (D.15110 != 0) goto <D.15111>; else goto <D.15112>;
            <D.15111>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f8 ff)");
            goto <D.15113>;
            <D.15112>:
            val.63 = val;
            monoeg_g_string_append_printf (res, "%g", val.63);
            <D.15113>:
            <D.15109>:
            <D.15106>:
            p.54 = p;
            p.59 = p.54 + 8;
            p = p.59;
            goto <D.14461>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14479>:
      D.15070 = sig->params[i];
      D.15114 = D.15070->data.klass;
      D.15115 = mono_class_is_enum (D.15114);
      if (D.15115 != 0) goto <D.15116>; else goto <D.15117>;
      <D.15116>:
      D.15070 = sig->params[i];
      D.15114 = D.15070->data.klass;
      D.15118 = mono_class_enum_basetype (D.15114);
      D.15119 = D.15118->type;
      type = (int) D.15119;
      goto handle_enum;
      <D.15117>:
      monoeg_g_log (0B, 16, "generic valutype not handled in custom attr value decoding");
      goto <D.14461>;
      <D.14480>:
      <D.14481>:
      p.54 = p;
      D.15072 = *p.54;
      if (D.15072 == -1) goto <D.15120>; else goto <D.15121>;
      <D.15120>:
      monoeg_g_string_append (res, "null");
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14461>;
      <D.15121>:
      p.54 = p;
      D.15122 = mono_metadata_decode_value (p.54, &p);
      slen = (int) D.15122;
      monoeg_g_string_append_c (res, 34);
      p.54 = p;
      monoeg_g_string_append (res, p.54);
      monoeg_g_string_append_c (res, 34);
      p.54 = p;
      slen.64 = (sizetype) slen;
      p.65 = p.54 + slen.64;
      p = p.65;
      goto <D.14461>;
      <D.14482>:
      D.15070 = sig->params[i];
      D.15071 = D.15070->type;
      D.15125 = (int) D.15071;
      monoeg_g_log (0B, 16, "Type %02x not handled in custom attr value decoding", D.15125);
      goto <D.14461>;
      <D.14461>:
      i = i + 1;
      <D.14484>:
      D.15126 = sig->param_count;
      D.15127 = (int) D.15126;
      if (D.15127 > i) goto <D.14483>; else goto <D.14485>;
      <D.14485>:
      p.54 = p;
      D.15065 = MEM[(const guint16 *)p.54];
      slen = (int) D.15065;
      if (slen != 0) goto <D.15128>; else goto <D.15129>;
      <D.15128>:
      monoeg_g_string_append_printf (res, " %d named args: (", slen);
      value.66 = (int) value;
      p.54 = p;
      p.67 = (int) p.54;
      D.15132 = value.66 - p.67;
      D.15133 = D.15132 + len;
      slen = D.15133 + 1;
      i = 0;
      goto <D.14487>;
      <D.14486>:
      p.54 = p;
      i.68 = (sizetype) i;
      D.15135 = p.54 + i.68;
      D.15136 = *D.15135;
      D.15137 = (int) D.15136;
      D.15138 = D.15137 & 255;
      monoeg_g_string_append_printf (res, " %02X", D.15138);
      i = i + 1;
      <D.14487>:
      if (i < slen) goto <D.14486>; else goto <D.14488>;
      <D.14488>:
      monoeg_g_string_append_c (res, 41);
      <D.15129>:
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.15066 = s;
      return D.15066;
    }
  finally
    {
      p = {CLOBBER};
    }
}


dump_table_nestedclass (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15143;
  int D.15144;
  struct FILE * output.69;
  int D.15146;
  unsigned int D.15147;
  int D.15148;
  unsigned int D.15149;
  int D.15150;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  char * nested;
  char * nesting;

  try
    {
      t = &m->tables[41];
      D.15143 = t->rows;
      D.15144 = (int) D.15143;
      output.69 = output;
      fprintf (output.69, "NestedClass Table (1..%d)\n", D.15144);
      i = 1;
      goto <D.14516>;
      <D.14515>:
      D.15146 = i + -1;
      mono_metadata_decode_row (t, D.15146, &cols, 2);
      D.15147 = cols[0];
      D.15148 = (int) D.15147;
      nested = get_typedef (m, D.15148);
      D.15149 = cols[1];
      D.15150 = (int) D.15149;
      nesting = get_typedef (m, D.15150);
      D.15149 = cols[1];
      D.15147 = cols[0];
      output.69 = output;
      fprintf (output.69, "%d: %d %d: %s in %s\n", i, D.15147, D.15149, nested, nesting);
      monoeg_g_free (nested);
      monoeg_g_free (nesting);
      i = i + 1;
      <D.14516>:
      D.15143 = t->rows;
      D.15144 = (int) D.15143;
      if (D.15144 >= i) goto <D.14515>; else goto <D.14517>;
      <D.14517>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_exported (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15151;
  int D.15152;
  struct FILE * output.70;
  int D.15154;
  unsigned int D.15155;
  unsigned int D.15156;
  unsigned int D.15157;
  const char * iftmp.71;
  char D.15159;
  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.15151 = t->rows;
      D.15152 = (int) D.15151;
      output.70 = output;
      fprintf (output.70, "ExportedType Table (1..%d)\n", D.15152);
      i = 1;
      goto <D.14530>;
      <D.14529>:
      D.15154 = i + -1;
      mono_metadata_decode_row (t, D.15154, &cols, 5);
      D.15155 = cols[2];
      name = mono_metadata_string_heap (m, D.15155);
      D.15156 = cols[3];
      nspace = mono_metadata_string_heap (m, D.15156);
      D.15157 = cols[4];
      impl = get_manifest_implementation (m, D.15157);
      index = cols[1];
      flags = cols[0];
      D.15159 = *nspace;
      if (D.15159 != 0) goto <D.15160>; else goto <D.15161>;
      <D.15160>:
      iftmp.71 = ".";
      goto <D.15162>;
      <D.15161>:
      iftmp.71 = "";
      <D.15162>:
      output.70 = output;
      fprintf (output.70, "%d: %s%s%s is in %s, index=%x, flags=0x%x\n", i, nspace, iftmp.71, name, impl, index, flags);
      monoeg_g_free (impl);
      i = i + 1;
      <D.14530>:
      D.15151 = t->rows;
      D.15152 = (int) D.15151;
      if (D.15152 >= i) goto <D.14529>; else goto <D.14531>;
      <D.14531>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_field_marshal (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15163;
  int D.15164;
  struct FILE * output.72;
  int D.15166;
  unsigned int D.15167;
  unsigned int D.15168;
  unsigned int D.15169;
  _Bool D.15170;
  unsigned int D.15171;
  const char * iftmp.73;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  int is_field;
  int idx;
  const char * blob;
  char * native;

  try
    {
      t = &m->tables[13];
      D.15163 = t->rows;
      D.15164 = (int) D.15163;
      output.72 = output;
      fprintf (output.72, "FieldMarshal Table (1..%d)\n", D.15164);
      i = 1;
      goto <D.14552>;
      <D.14551>:
      D.15166 = i + -1;
      mono_metadata_decode_row (t, D.15166, &cols, 2);
      D.15167 = cols[1];
      blob = mono_metadata_blob_heap (m, D.15167);
      native = get_marshal_info (m, blob);
      D.15168 = cols[0];
      D.15169 = D.15168 & 1;
      D.15170 = D.15169 == 0;
      is_field = (int) D.15170;
      D.15168 = cols[0];
      D.15171 = D.15168 >> 1;
      idx = (int) D.15171;
      if (is_field != 0) goto <D.15173>; else goto <D.15174>;
      <D.15173>:
      iftmp.73 = "Field";
      goto <D.15175>;
      <D.15174>:
      iftmp.73 = "Param";
      <D.15175>:
      D.15168 = cols[0];
      output.72 = output;
      fprintf (output.72, "%d: (0x%04x) %s %d: %s\n", i, D.15168, iftmp.73, idx, native);
      output.72 = output;
      fprintf (output.72, "\tblob encoding: ");
      dump_blob (m, blob);
      output.72 = output;
      fprintf (output.72, "\n");
      monoeg_g_free (native);
      i = i + 1;
      <D.14552>:
      D.15163 = t->rows;
      D.15164 = (int) D.15163;
      if (D.15164 >= i) goto <D.14551>; else goto <D.14553>;
      <D.14553>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_blob (struct MonoImage * m, const char * blob)
{
  const char * blob.74;
  unsigned int D.15177;
  sizetype j.75;
  const char * D.15179;
  char D.15180;
  int D.15181;
  int D.15182;
  struct FILE * output.76;
  int j;
  int bsize;

  blob.74 = blob;
  D.15177 = mono_metadata_decode_blob_size (blob.74, &blob);
  bsize = (int) D.15177;
  j = 0;
  goto <D.14539>;
  <D.14538>:
  blob.74 = blob;
  j.75 = (sizetype) j;
  D.15179 = blob.74 + j.75;
  D.15180 = *D.15179;
  D.15181 = (int) D.15180;
  D.15182 = D.15181 & 255;
  output.76 = output;
  fprintf (output.76, "%02x ", D.15182);
  j = j + 1;
  <D.14539>:
  if (j < bsize) goto <D.14538>; else goto <D.14540>;
  <D.14540>:
}


dump_table_declsec (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15184;
  int D.15185;
  struct FILE * output.77;
  int D.15187;
  unsigned int D.15188;
  const char * blob.78;
  const char * blob.79;
  unsigned int D.15191;
  unsigned int D.15192;
  int D.15193;
  const char * iftmp.80;
  unsigned int D.15198;
  unsigned int D.15199;
  const char * D.15200;
  char D.15203;
  const char * D.15207;
  char D.15208;
  int D.15209;
  unsigned int len.81;
  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.15184 = t->rows;
      D.15185 = (int) D.15184;
      output.77 = output;
      fprintf (output.77, "DeclSecurity Table (1..%d)\n", D.15185);
      i = 1;
      goto <D.14591>;
      <D.14590>:
      D.15187 = i + -1;
      mono_metadata_decode_row (t, D.15187, &cols, 3);
      D.15188 = cols[2];
      blob.78 = mono_metadata_blob_heap (m, D.15188);
      blob = blob.78;
      blob.79 = blob;
      D.15191 = mono_metadata_decode_blob_size (blob.79, &blob);
      len = (int) D.15191;
      D.15192 = cols[0];
      D.15193 = (int) D.15192;
      action = get_security_action (D.15193);
      idx = cols[1];
      if (len != 0) goto <D.15195>; else goto <D.15196>;
      <D.15195>:
      iftmp.80 = ":\n\t";
      goto <D.15197>;
      <D.15196>:
      iftmp.80 = "\n";
      <D.15197>:
      D.15198 = idx >> 2;
      D.15199 = idx & 3;
      D.15200 = parent[D.15199];
      output.77 = output;
      fprintf (output.77, "%d: %s on %s %d%s", i, action, D.15200, D.15198, iftmp.80);
      if (len == 0) goto <D.15201>; else goto <D.15202>;
      <D.15201>:
      // predicted unlikely by continue predictor.
      goto <D.14585>;
      <D.15202>:
      blob.79 = blob;
      D.15203 = *blob.79;
      if (D.15203 == 46) goto <D.15204>; else goto <D.15205>;
      <D.15204>:
      {
        char * declsec;

        blob.79 = blob;
        declsec = dump_declsec_entry20 (m, blob.79, "\t");
        output.77 = output;
        fprintf (output.77, "%s", declsec);
        monoeg_g_free (declsec);
      }
      goto <D.15206>;
      <D.15205>:
      idx = 0;
      goto <D.14588>;
      <D.14587>:
      blob.79 = blob;
      D.15207 = blob.79 + idx;
      D.15208 = *D.15207;
      D.15209 = (int) D.15208;
      output.77 = output;
      fprintf (output.77, "%c", D.15209);
      idx = idx + 1;
      <D.14588>:
      len.81 = (unsigned int) len;
      if (len.81 > idx) goto <D.14587>; else goto <D.14589>;
      <D.14589>:
      <D.15206>:
      output.77 = output;
      fprintf (output.77, "\n");
      <D.14585>:
      i = i + 1;
      <D.14591>:
      D.15184 = t->rows;
      D.15185 = (int) D.15184;
      if (D.15185 >= i) goto <D.14590>; else goto <D.14592>;
      <D.14592>:
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
      parent = {CLOBBER};
    }
}


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

  switch (val) <default: <D.14573>, case 2: <D.14558>, case 3: <D.14559>, case 4: <D.14560>, case 5: <D.14561>, case 6: <D.14562>, case 7: <D.14563>, case 8: <D.14564>, case 9: <D.14565>, case 10: <D.14566>, case 13: <D.14567>, case 14: <D.14568>, case 15: <D.14569>, case 16: <D.14570>, case 17: <D.14571>, case 18: <D.14572>>
  <D.14558>:
  D.15211 = "Demand";
  return D.15211;
  <D.14559>:
  D.15211 = "Assert";
  return D.15211;
  <D.14560>:
  D.15211 = "Deny";
  return D.15211;
  <D.14561>:
  D.15211 = "PermitOnly";
  return D.15211;
  <D.14562>:
  D.15211 = "LinkDemand";
  return D.15211;
  <D.14563>:
  D.15211 = "InheritanceDemand";
  return D.15211;
  <D.14564>:
  D.15211 = "RequestMinimum";
  return D.15211;
  <D.14565>:
  D.15211 = "RequestOptional";
  return D.15211;
  <D.14566>:
  D.15211 = "RequestRefuse";
  return D.15211;
  <D.14567>:
  D.15211 = "NonCasDemand";
  return D.15211;
  <D.14568>:
  D.15211 = "NonCasLinkDemand";
  return D.15211;
  <D.14569>:
  D.15211 = "NonCasInheritance";
  return D.15211;
  <D.14570>:
  D.15211 = "LinkDemandChoice";
  return D.15211;
  <D.14571>:
  D.15211 = "InheritanceDemandChoice";
  return D.15211;
  <D.14572>:
  D.15211 = "DemandChoice";
  return D.15211;
  <D.14573>:
  monoeg_g_snprintf (&buf, 32, "0x%04X", val);
  D.15211 = &buf;
  return D.15211;
}


dump_table_genericpar (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15213;
  int D.15214;
  struct FILE * output.82;
  int D.15216;
  unsigned int D.15217;
  unsigned int D.15218;
  const char * D.15219;
  unsigned int D.15220;
  unsigned int D.15221;
  struct MonoTableInfo * t;
  guint32 cols[4];
  int i;

  try
    {
      t = &m->tables[42];
      D.15213 = t->rows;
      D.15214 = (int) D.15213;
      output.82 = output;
      fprintf (output.82, "GenericParameters (1..%d)\n", D.15214);
      i = 1;
      goto <D.14601>;
      <D.14600>:
      {
        char * sig;

        D.15216 = i + -1;
        mono_metadata_decode_row (t, D.15216, &cols, 4);
        D.15217 = cols[2];
        sig = monoeg_g_strdup_printf ("%x", D.15217);
        D.15218 = cols[3];
        D.15219 = mono_metadata_string_heap (m, D.15218);
        D.15220 = cols[1];
        D.15221 = cols[0];
        output.82 = output;
        fprintf (output.82, "%d: %d, flags=%d, owner=%s %s\n", i, D.15221, D.15220, sig, D.15219);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14601>:
      D.15213 = t->rows;
      D.15214 = (int) D.15213;
      if (D.15214 >= i) goto <D.14600>; else goto <D.14602>;
      <D.14602>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_methodspec (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15222;
  int D.15223;
  struct FILE * output.83;
  int D.15225;
  int D.15226;
  unsigned int D.15227;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

  try
    {
      t = &m->tables[43];
      D.15222 = t->rows;
      D.15223 = (int) D.15222;
      output.83 = output;
      fprintf (output.83, "MethodSpec (1..%d)\n", D.15223);
      i = 1;
      goto <D.14613>;
      <D.14612>:
      {
        char * sig;
        char * method;
        guint32 token;

        D.15225 = i + -1;
        mono_metadata_decode_row (t, D.15225, &cols, 2);
        D.15226 = i | 721420288;
        token = (guint32) D.15226;
        method = get_method (m, token, 0B);
        D.15227 = cols[1];
        sig = get_method_type_param (m, D.15227, 0B);
        output.83 = output;
        fprintf (output.83, "%d: %s, %s\n", i, method, sig);
        monoeg_g_free (sig);
        monoeg_g_free (method);
      }
      i = i + 1;
      <D.14613>:
      D.15222 = t->rows;
      D.15223 = (int) D.15222;
      if (D.15223 >= i) goto <D.14612>; else goto <D.14614>;
      <D.14614>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_parconstraint (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15228;
  int D.15229;
  struct FILE * output.84;
  int D.15231;
  unsigned int D.15232;
  unsigned int D.15233;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

  try
    {
      t = &m->tables[44];
      D.15228 = t->rows;
      D.15229 = (int) D.15228;
      output.84 = output;
      fprintf (output.84, "Generic Param Constraint (1..%d)\n", D.15229);
      i = 1;
      goto <D.14623>;
      <D.14622>:
      {
        char * sig;

        D.15231 = i + -1;
        mono_metadata_decode_row (t, D.15231, &cols, 2);
        D.15232 = cols[1];
        sig = monoeg_g_strdup_printf ("%x", D.15232);
        D.15233 = cols[0];
        output.84 = output;
        fprintf (output.84, "%d: gen-par=%d, Constraint=%s\n", i, D.15233, sig);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14623>:
      D.15228 = t->rows;
      D.15229 = (int) D.15228;
      if (D.15229 >= i) goto <D.14622>; else goto <D.14624>;
      <D.14624>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_stream_blob (struct MonoImage * m)
{
  struct FILE * output.85;
  unsigned int i.86;
  unsigned int D.15238;
  unsigned int D.15242;
  const char * D.15245;
  sizetype i.87;
  const char * D.15247;
  char D.15248;
  int D.15249;
  int D.15250;
  unsigned int i.88;
  unsigned int D.15252;
  int i;

  output.85 = output;
  fprintf (output.85, "Blob heap contents\n");
  i = 0;
  goto <D.14630>;
  <D.14629>:
  if (i > 0) goto <D.15235>; else goto <D.15236>;
  <D.15235>:
  i.86 = (unsigned int) i;
  D.15238 = i.86 & 15;
  if (D.15238 == 0) goto <D.15239>; else goto <D.15240>;
  <D.15239>:
  output.85 = output;
  fprintf (output.85, "\n");
  goto <D.15241>;
  <D.15240>:
  i.86 = (unsigned int) i;
  D.15242 = i.86 & 7;
  if (D.15242 == 0) goto <D.15243>; else goto <D.15244>;
  <D.15243>:
  output.85 = output;
  fprintf (output.85, "- ");
  <D.15244>:
  <D.15241>:
  <D.15236>:
  D.15245 = m->heap_blob.data;
  i.87 = (sizetype) i;
  D.15247 = D.15245 + i.87;
  D.15248 = *D.15247;
  D.15249 = (int) D.15248;
  D.15250 = D.15249 & 255;
  output.85 = output;
  fprintf (output.85, "%02x ", D.15250);
  i = i + 1;
  <D.14630>:
  i.88 = (unsigned int) i;
  D.15252 = m->heap_blob.size;
  if (i.88 < D.15252) goto <D.14629>; else goto <D.14631>;
  <D.14631>:
  output.85 = output;
  fprintf (output.85, "\n");
}


dump_stream_strings (struct MonoImage * m)
{
  struct FILE * output.89;
  unsigned int D.15254;
  unsigned int D.15255;
  unsigned int D.15256;
  guint32 i;

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

    str = mono_metadata_string_heap (m, i);
    output.89 = output;
    fprintf (output.89, "%02x: \"%s\"\n", i, str);
    D.15254 = strlen (str);
    D.15255 = D.15254 + i;
    i = D.15255 + 1;
  }
  <D.14638>:
  D.15256 = m->heap_strings.size;
  if (D.15256 > i) goto <D.14637>; else goto <D.14639>;
  <D.14639>:
}


dump_stream_us (struct MonoImage * m)
{
  struct FILE * output.90;
  const char * us_ptr.91;
  const char * us_ptr.92;
  unsigned int D.15260;
  unsigned int len.93;
  unsigned int D.15262;
  unsigned int D.15263;
  guint32 i;

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

    try
      {
        us_ptr.91 = mono_metadata_user_string (m, i);
        us_ptr = us_ptr.91;
        us_ptr.92 = us_ptr;
        D.15260 = mono_metadata_decode_blob_size (us_ptr.92, &us_ptr);
        len = (int) D.15260;
        us_ptr.92 = us_ptr;
        str = get_encoded_user_string_or_bytearray (us_ptr.92, len);
        output.90 = output;
        fprintf (output.90, "%02x: %s\n", i, str);
        monoeg_g_free (str);
        len.93 = (unsigned int) len;
        D.15262 = len.93 + i;
        i = D.15262 + 1;
      }
    finally
      {
        us_ptr = {CLOBBER};
      }
  }
  <D.14648>:
  D.15263 = m->heap_us.size;
  if (D.15263 > i) goto <D.14647>; else goto <D.14649>;
  <D.14649>:
}


dump_table_standalonesig (struct MonoImage * m)
{
  <unnamed-unsigned:24> D.15264;
  int D.15265;
  struct FILE * output.94;
  int D.15267;
  unsigned int D.15268;
  const char * locals_ptr.95;
  const char * locals_ptr.96;
  unsigned int D.15271;
  sizetype j.97;
  const char * D.15273;
  char D.15274;
  int D.15275;
  int D.15276;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

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

        try
          {
            D.15267 = i + -1;
            mono_metadata_decode_row (t, D.15267, &cols, 1);
            D.15268 = cols[0];
            locals_ptr.95 = mono_metadata_blob_heap (m, D.15268);
            locals_ptr = locals_ptr.95;
            locals_ptr.96 = locals_ptr;
            D.15271 = mono_metadata_decode_blob_size (locals_ptr.96, &locals_ptr);
            bsize = (int) D.15271;
            D.15268 = cols[0];
            output.94 = output;
            fprintf (output.94, "%d: blob[0x%x] = ", i, D.15268);
            j = 0;
            goto <D.14660>;
            <D.14659>:
            locals_ptr.96 = locals_ptr;
            j.97 = (sizetype) j;
            D.15273 = locals_ptr.96 + j.97;
            D.15274 = *D.15273;
            D.15275 = (int) D.15274;
            D.15276 = D.15275 & 255;
            output.94 = output;
            fprintf (output.94, "%02x ", D.15276);
            j = j + 1;
            <D.14660>:
            if (j < bsize) goto <D.14659>; else goto <D.14661>;
            <D.14661>:
            output.94 = output;
            fprintf (output.94, "\n");
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14663>:
      D.15264 = t->rows;
      D.15265 = (int) D.15264;
      if (D.15265 >= i) goto <D.14662>; else goto <D.14664>;
      <D.14664>:
    }
  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.15277;
  int D.15278;
  struct FILE * output.98;
  int D.15280;
  unsigned int D.15281;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

  try
    {
      t = &m->tables[table];
      D.15277 = t->rows;
      D.15278 = (int) D.15277;
      output.98 = output;
      fprintf (output.98, "%s (1..%d)\n", name, D.15278);
      i = 1;
      goto <D.14674>;
      <D.14673>:
      D.15280 = i + -1;
      mono_metadata_decode_row (t, D.15280, &cols, 1);
      D.15281 = cols[0];
      output.98 = output;
      fprintf (output.98, "%d: %d\n", i, D.15281);
      i = i + 1;
      <D.14674>:
      D.15277 = t->rows;
      D.15278 = (int) D.15277;
      if (D.15278 >= i) goto <D.14673>; else goto <D.14675>;
      <D.14675>:
    }
  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");
}