dump_table_assembly (struct MonoImage * m)
{
  struct FILE * output.0;
  unsigned int D.14608;
  unsigned int D.14609;
  unsigned int D.14612;
  const char * D.14613;
  unsigned int D.14614;
  unsigned int D.14615;
  unsigned int D.14616;
  unsigned int D.14617;
  unsigned int D.14618;
  unsigned int D.14619;
  unsigned int D.14620;
  const char * ptr.1;
  const char * ptr.2;
  unsigned int D.14623;
  unsigned int D.14627;
  const char * D.14628;
  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.14608 = BIT_FIELD_REF <*t, 32, 32>;
      D.14609 = D.14608 & 16777215;
      if (D.14609 == 0) goto <D.14610>; else goto <D.14611>;
      <D.14610>:
      return;
      <D.14611>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      output.0 = output;
      D.14612 = cols[7];
      D.14613 = mono_metadata_string_heap (m, D.14612);
      fprintf (output.0, "Name:          %s\n", D.14613);
      output.0 = output;
      D.14614 = cols[0];
      fprintf (output.0, "Hash Algoritm: 0x%08x\n", D.14614);
      output.0 = output;
      D.14615 = cols[1];
      D.14616 = cols[2];
      D.14617 = cols[3];
      D.14618 = cols[4];
      fprintf (output.0, "Version:       %d.%d.%d.%d\n", D.14615, D.14616, D.14617, D.14618);
      output.0 = output;
      D.14619 = cols[5];
      fprintf (output.0, "Flags:         0x%08x\n", D.14619);
      output.0 = output;
      D.14620 = cols[6];
      fprintf (output.0, "PublicKey:     BlobPtr (0x%08x)\n", D.14620);
      D.14620 = cols[6];
      ptr.1 = mono_metadata_blob_heap (m, D.14620);
      ptr = ptr.1;
      ptr.2 = ptr;
      D.14623 = mono_metadata_decode_value (ptr.2, &ptr);
      len = (int) D.14623;
      if (len > 0) goto <D.14624>; else goto <D.14625>;
      <D.14624>:
      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.14626>;
      <D.14625>:
      output.0 = output;
      fprintf (output.0, "\tZero sized public key\n");
      <D.14626>:
      output.0 = output;
      D.14627 = cols[8];
      D.14628 = mono_metadata_string_heap (m, D.14627);
      fprintf (output.0, "Culture:       %s\n", D.14628);
      output.0 = output;
      fprintf (output.0, "\n");
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


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

  t = &m->tables[1];
  output.3 = output;
  fprintf (output.3, "Typeref Table\n");
  i = 1;
  goto <D.14044>;
  <D.14043>:
  {
    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.14044>:
  D.14635 = t->rows;
  D.14636 = (int) D.14635;
  if (D.14636 >= i) goto <D.14043>; else goto <D.14045>;
  <D.14045>:
  output.3 = output;
  fprintf (output.3, "\n");
}


dump_table_typedef (struct MonoImage * m)
{
  struct FILE * output.4;
  struct MonoTableInfo * D.14638;
  int D.14639;
  unsigned int D.14640;
  unsigned int D.14641;
  unsigned int D.14642;
  unsigned int D.14643;
  <unnamed-unsigned:24> D.14644;
  int D.14645;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        s = get_typedef (m, i);
        D.14638 = &m->tables[2];
        D.14639 = i + -1;
        mono_metadata_decode_row (D.14638, D.14639, &cols, 6);
        output.4 = output;
        D.14640 = cols[4];
        D.14641 = cols[5];
        D.14642 = cols[0];
        D.14643 = cols[3];
        fprintf (output.4, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i, s, D.14640, D.14641, D.14642, D.14643);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14054>:
  D.14644 = t->rows;
  D.14645 = (int) D.14644;
  if (D.14645 >= i) goto <D.14053>; else goto <D.14055>;
  <D.14055>:
  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.14648;
  int D.14649;
  struct MonoTableInfo * t;
  int i;

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


dump_table_assemblyref (struct MonoImage * m)
{
  struct FILE * output.7;
  int D.14651;
  unsigned int D.14652;
  unsigned int D.14653;
  unsigned int D.14654;
  unsigned int D.14655;
  unsigned int D.14656;
  const char * D.14657;
  unsigned int D.14658;
  unsigned int D.14659;
  const char * ptr.8;
  const char * ptr.9;
  unsigned int D.14662;
  <unnamed-unsigned:24> D.14666;
  int D.14667;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        output.7 = output;
        D.14651 = i + 1;
        D.14652 = cols[0];
        D.14653 = cols[1];
        D.14654 = cols[2];
        D.14655 = cols[3];
        D.14656 = cols[6];
        D.14657 = mono_metadata_string_heap (m, D.14656);
        fprintf (output.7, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", D.14651, D.14652, D.14653, D.14654, D.14655, D.14657);
        output.7 = output;
        D.14658 = cols[4];
        fprintf (output.7, "\tFlags=0x%08x\n", D.14658);
        D.14659 = cols[5];
        ptr.8 = mono_metadata_blob_heap (m, D.14659);
        ptr = ptr.8;
        ptr.9 = ptr;
        D.14662 = mono_metadata_decode_value (ptr.9, &ptr);
        len = (int) D.14662;
        if (len > 0) goto <D.14663>; else goto <D.14664>;
        <D.14663>:
        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.14665>;
        <D.14664>:
        output.7 = output;
        fprintf (output.7, "\tZero sized public key\n");
        <D.14665>:
      }
    finally
      {
        ptr = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14074>:
  D.14666 = t->rows;
  D.14667 = (int) D.14666;
  if (D.14667 > i) goto <D.14073>; else goto <D.14075>;
  <D.14075>:
  output.7 = output;
  fprintf (output.7, "\n");
}


dump_table_param (struct MonoImage * m)
{
  struct FILE * output.10;
  int D.14669;
  unsigned int D.14670;
  unsigned int D.14671;
  unsigned int D.14672;
  const char * D.14673;
  <unnamed-unsigned:24> D.14674;
  int D.14675;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        output.10 = output;
        D.14669 = i + 1;
        D.14670 = cols[0];
        D.14671 = cols[1];
        D.14672 = cols[2];
        D.14673 = mono_metadata_string_heap (m, D.14672);
        fprintf (output.10, "%d: 0x%04x %d %s\n", D.14669, D.14670, D.14671, D.14673);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14083>:
  D.14674 = t->rows;
  D.14675 = (int) D.14674;
  if (D.14675 > i) goto <D.14082>; else goto <D.14084>;
  <D.14084>:
  output.10 = output;
  fprintf (output.10, "\n");
}


dump_table_field (struct MonoImage * m)
{
  struct FILE * output.11;
  <unnamed-unsigned:24> D.14677;
  int D.14678;
  <unnamed-unsigned:24> D.14679;
  int D.14680;
  unsigned int i.12;
  int D.14683;
  int D.14686;
  unsigned int D.14687;
  const char * D.14688;
  unsigned int D.14689;
  const char * D.14690;
  int D.14691;
  unsigned int D.14692;
  unsigned int D.14693;
  unsigned int D.14694;
  const char * D.14695;
  <unnamed-unsigned:24> D.14696;
  int D.14697;
  int D.14700;
  unsigned int D.14701;
  unsigned int i.13;
  unsigned int D.14705;
  <unnamed-unsigned:24> D.14706;
  int D.14707;
  int D.14710;
  unsigned int D.14711;
  unsigned int D.14714;
  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];
  output.11 = output;
  D.14677 = t->rows;
  D.14678 = (int) D.14677;
  fprintf (output.11, "Field Table (1..%d)\n", D.14678);
  current_type = 1;
  offset_row = current_type;
  rva_row = offset_row;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14105>;
  <D.14104>:
  {
    guint32 cols[3];
    char * sig;
    char * flags;

    try
      {
        goto <D.14102>;
        <D.14101>:
        current_type = current_type + 1;
        <D.14102>:
        D.14679 = td->rows;
        D.14680 = (int) D.14679;
        if (D.14680 >= current_type) goto <D.14681>; else goto <D.14103>;
        <D.14681>:
        i.12 = (unsigned int) i;
        D.14683 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.14683, 4);
        if (i.12 >= last_m) goto <D.14101>; else goto <D.14103>;
        <D.14103>:
        i.12 = (unsigned int) i;
        if (i.12 == first_m) goto <D.14684>; else goto <D.14685>;
        <D.14684>:
        output.11 = output;
        D.14686 = current_type + -2;
        D.14687 = mono_metadata_decode_row_col (td, D.14686, 2);
        D.14688 = mono_metadata_string_heap (m, D.14687);
        D.14686 = current_type + -2;
        D.14689 = mono_metadata_decode_row_col (td, D.14686, 1);
        D.14690 = mono_metadata_string_heap (m, D.14689);
        fprintf (output.11, "########## %s.%s\n", D.14688, D.14690);
        first_m = last_m;
        <D.14685>:
        D.14691 = i + -1;
        mono_metadata_decode_row (t, D.14691, &cols, 3);
        D.14692 = cols[2];
        sig = get_field_signature (m, D.14692, 0B);
        D.14693 = cols[0];
        flags = field_flags (D.14693);
        output.11 = output;
        D.14694 = cols[1];
        D.14695 = mono_metadata_string_heap (m, D.14694);
        fprintf (output.11, "%d: %s %s: %s\n", i, sig, D.14695, flags);
        monoeg_g_free (sig);
        monoeg_g_free (flags);
        D.14696 = fl->rows;
        D.14697 = (int) D.14696;
        if (D.14697 >= offset_row) goto <D.14698>; else goto <D.14699>;
        <D.14698>:
        D.14700 = offset_row + -1;
        D.14701 = mono_metadata_decode_row_col (fl, D.14700, 1);
        i.13 = (unsigned int) i;
        if (D.14701 == i.13) goto <D.14703>; else goto <D.14704>;
        <D.14703>:
        output.11 = output;
        D.14700 = offset_row + -1;
        D.14705 = mono_metadata_decode_row_col (fl, D.14700, 0);
        fprintf (output.11, "\texplicit offset: %d\n", D.14705);
        offset_row = offset_row + 1;
        <D.14704>:
        <D.14699>:
        D.14706 = rva->rows;
        D.14707 = (int) D.14706;
        if (D.14707 >= rva_row) goto <D.14708>; else goto <D.14709>;
        <D.14708>:
        D.14710 = rva_row + -1;
        D.14711 = mono_metadata_decode_row_col (rva, D.14710, 1);
        i.13 = (unsigned int) i;
        if (D.14711 == i.13) goto <D.14712>; else goto <D.14713>;
        <D.14712>:
        output.11 = output;
        D.14710 = rva_row + -1;
        D.14714 = mono_metadata_decode_row_col (rva, D.14710, 0);
        fprintf (output.11, "\trva: %d\n", D.14714);
        rva_row = rva_row + 1;
        <D.14713>:
        <D.14709>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14105>:
  D.14677 = t->rows;
  D.14678 = (int) D.14677;
  if (D.14678 >= i) goto <D.14104>; else goto <D.14106>;
  <D.14106>:
  output.11 = output;
  fprintf (output.11, "\n");
}


dump_table_memberref (struct MonoImage * m)
{
  struct FILE * output.14;
  <unnamed-unsigned:24> D.14716;
  int D.14717;
  unsigned int D.14718;
  int D.14719;
  unsigned int D.14720;
  unsigned int D.14721;
  const char * D.14722;
  const char * D.14723;
  unsigned int idx.15;
  const char * D.14725;
  unsigned int D.14726;
  const char * blob.16;
  const char * blob.17;
  char D.14729;
  int D.14733;
  const char * D.14734;
  const char * iftmp.18;
  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;
      output.14 = output;
      D.14716 = t->rows;
      D.14717 = (int) D.14716;
      fprintf (output.14, "MemberRef Table (1..%d)\n", D.14717);
      i = 0;
      goto <D.14129>;
      <D.14128>:
      {
        guint32 cols[3];

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            D.14718 = cols[0];
            D.14719 = (int) D.14718;
            kind = D.14719 & 7;
            D.14718 = cols[0];
            D.14720 = D.14718 >> 3;
            idx = (int) D.14720;
            x = monoeg_strdup ("UNHANDLED CASE");
            switch (kind) <default: <D.14126>, case 0: <D.14120>, case 1: <D.14122>, case 2: <D.14123>, case 3: <D.14124>, case 4: <D.14125>>
            <D.14120>:
            ks = "TypeDef";
            xx = get_typedef (m, idx);
            D.14721 = cols[1];
            D.14722 = mono_metadata_string_heap (m, D.14721);
            x = monoeg_g_strconcat (xx, ".", D.14722, 0B);
            monoeg_g_free (xx);
            goto <D.14121>;
            <D.14122>:
            ks = "TypeRef";
            xx = get_typeref (m, idx);
            D.14721 = cols[1];
            D.14723 = mono_metadata_string_heap (m, D.14721);
            x = monoeg_g_strconcat (xx, ".", D.14723, 0B);
            monoeg_g_free (xx);
            goto <D.14121>;
            <D.14123>:
            ks = "ModuleRef";
            goto <D.14121>;
            <D.14124>:
            ks = "MethodDef";
            idx.15 = (unsigned int) idx;
            x = get_methoddef (m, idx.15);
            goto <D.14121>;
            <D.14125>:
            ks = "TypeSpec";
            idx.15 = (unsigned int) idx;
            xx = get_typespec (m, idx.15, 0, 0B);
            D.14721 = cols[1];
            D.14725 = mono_metadata_string_heap (m, D.14721);
            x = monoeg_g_strconcat (xx, ".", D.14725, 0B);
            monoeg_g_free (xx);
            goto <D.14121>;
            <D.14126>:
            monoeg_g_log (0B, 4, "Unknown tag: %d\n", kind);
            <D.14127>:
            goto <D.14127>;
            <D.14121>:
            D.14726 = cols[2];
            blob.16 = mono_metadata_blob_heap (m, D.14726);
            blob = blob.16;
            blob.17 = blob;
            mono_metadata_decode_blob_size (blob.17, &blob);
            blob.17 = blob;
            D.14729 = *blob.17;
            if (D.14729 == 6) goto <D.14730>; else goto <D.14731>;
            <D.14730>:
            D.14726 = cols[2];
            sig = get_field_signature (m, D.14726, 0B);
            goto <D.14732>;
            <D.14731>:
            D.14726 = cols[2];
            sig = get_methodref_signature (m, D.14726, 0B);
            <D.14732>:
            output.14 = output;
            D.14733 = i + 1;
            D.14721 = cols[1];
            D.14734 = mono_metadata_string_heap (m, D.14721);
            if (x != 0B) goto <D.14736>; else goto <D.14737>;
            <D.14736>:
            iftmp.18 = x;
            goto <D.14738>;
            <D.14737>:
            iftmp.18 = "";
            <D.14738>:
            fprintf (output.14, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n", D.14733, ks, idx, D.14734, iftmp.18, sig);
            if (x != 0B) goto <D.14739>; else goto <D.14740>;
            <D.14739>:
            monoeg_g_free (x);
            <D.14740>:
            monoeg_g_free (sig);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14129>:
      D.14716 = t->rows;
      D.14717 = (int) D.14716;
      if (D.14717 > i) goto <D.14128>; else goto <D.14130>;
      <D.14130>:
    }
  finally
    {
      blob = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.14741>; else goto <D.14742>;
  <D.14741>:
  D.14743 = __strdup (str);
  return D.14743;
  <D.14742>:
  D.14743 = 0B;
  return D.14743;
}


dump_table_class_layout (struct MonoImage * m)
{
  struct FILE * output.19;
  <unnamed-unsigned:24> D.14746;
  int D.14747;
  int D.14748;
  unsigned int D.14749;
  unsigned int D.14750;
  unsigned int D.14751;
  int D.14752;
  char * D.14753;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        output.19 = output;
        D.14748 = i + 1;
        D.14749 = cols[0];
        D.14750 = cols[1];
        D.14751 = cols[2];
        D.14752 = (int) D.14751;
        D.14753 = get_typedef (m, D.14752);
        fprintf (output.19, "%d: PackingSize=%d  ClassSize=%d  Parent=%s\n", D.14748, D.14749, D.14750, D.14753);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14138>:
  D.14746 = t->rows;
  D.14747 = (int) D.14746;
  if (D.14747 > i) goto <D.14137>; else goto <D.14139>;
  <D.14139>:
}


dump_table_constant (struct MonoImage * m)
{
  struct FILE * output.20;
  <unnamed-unsigned:24> D.14755;
  int D.14756;
  unsigned int D.14757;
  unsigned int D.14758;
  int D.14759;
  unsigned int D.14760;
  unsigned int D.14761;
  unsigned int D.14762;
  char * D.14763;
  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] = "";
      output.20 = output;
      D.14755 = t->rows;
      D.14756 = (int) D.14755;
      fprintf (output.20, "Constant Table (1..%d)\n", D.14756);
      i = 0;
      goto <D.14149>;
      <D.14148>:
      {
        guint32 cols[4];
        const char * parent;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 4);
            D.14757 = cols[2];
            D.14758 = D.14757 & 3;
            parent = desc[D.14758];
            output.20 = output;
            D.14759 = i + 1;
            D.14757 = cols[2];
            D.14760 = D.14757 >> 2;
            D.14761 = cols[0];
            D.14762 = cols[3];
            D.14763 = get_constant (m, D.14761, D.14762);
            fprintf (output.20, "%d: Parent= %s: %d %s\n", D.14759, parent, D.14760, D.14763);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14149>:
      D.14755 = t->rows;
      D.14756 = (int) D.14755;
      if (D.14756 > i) goto <D.14148>; else goto <D.14150>;
      <D.14150>:
    }
  finally
    {
      desc = {CLOBBER};
    }
}


dump_table_property_map (struct MonoImage * m)
{
  struct FILE * output.21;
  <unnamed-unsigned:24> D.14765;
  int D.14766;
  unsigned int D.14767;
  int D.14768;
  int D.14769;
  unsigned int D.14770;
  struct MonoTableInfo * t;
  int i;
  char * s;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 2);
        D.14767 = cols[0];
        D.14768 = (int) D.14767;
        s = get_typedef (m, D.14768);
        output.21 = output;
        D.14769 = i + 1;
        D.14767 = cols[0];
        D.14770 = cols[1];
        fprintf (output.21, "%d: %s (%d) %d\n", D.14769, s, D.14767, D.14770);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14159>:
  D.14765 = t->rows;
  D.14766 = (int) D.14765;
  if (D.14766 > i) goto <D.14158>; else goto <D.14160>;
  <D.14160>:
}


dump_table_property (struct MonoImage * m)
{
  struct FILE * output.22;
  <unnamed-unsigned:24> D.14772;
  int D.14773;
  unsigned int D.14774;
  int D.14775;
  int D.14778;
  int D.14781;
  unsigned int D.14784;
  const char * ptr.23;
  const char * ptr.24;
  unsigned int D.14787;
  char D.14788;
  int D.14793;
  const char * ptr.25;
  unsigned int D.14795;
  const char * ptr.26;
  int D.14797;
  char * type.27;
  unsigned int D.14799;
  const char * D.14800;
  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];
      output.22 = output;
      D.14772 = t->rows;
      D.14773 = (int) D.14772;
      fprintf (output.22, "Property Table (1..%d)\n", D.14773);
      i = 0;
      goto <D.14178>;
      <D.14177>:
      {
        guint32 cols[3];
        char * type;
        int bsize;
        int prop_flags;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            flags[0] = 0;
            D.14774 = cols[0];
            prop_flags = (int) D.14774;
            D.14775 = prop_flags & 512;
            if (D.14775 != 0) goto <D.14776>; else goto <D.14777>;
            <D.14776>:
            strcat (&flags, "special ");
            <D.14777>:
            D.14778 = prop_flags & 1024;
            if (D.14778 != 0) goto <D.14779>; else goto <D.14780>;
            <D.14779>:
            strcat (&flags, "runtime ");
            <D.14780>:
            D.14781 = prop_flags & 4096;
            if (D.14781 != 0) goto <D.14782>; else goto <D.14783>;
            <D.14782>:
            strcat (&flags, "hasdefault ");
            <D.14783>:
            D.14784 = cols[2];
            ptr.23 = mono_metadata_blob_heap (m, D.14784);
            ptr = ptr.23;
            ptr.24 = ptr;
            D.14787 = mono_metadata_decode_blob_size (ptr.24, &ptr);
            bsize = (int) D.14787;
            ptr.24 = ptr;
            D.14788 = *ptr.24;
            if (D.14788 != 40) goto <D.14789>; else goto <D.14790>;
            <D.14789>:
            ptr.24 = ptr;
            D.14788 = *ptr.24;
            if (D.14788 != 8) goto <D.14791>; else goto <D.14792>;
            <D.14791>:
            ptr.24 = ptr;
            D.14788 = *ptr.24;
            D.14793 = (int) D.14788;
            monoeg_g_log (0B, 16, "incorrect signature in propert blob: 0x%x", D.14793);
            <D.14792>:
            <D.14790>:
            ptr.24 = ptr;
            ptr.25 = ptr.24 + 1;
            ptr = ptr.25;
            ptr.24 = ptr;
            D.14795 = mono_metadata_decode_value (ptr.24, &ptr);
            pcount = (int) D.14795;
            ptr.24 = ptr;
            ptr.26 = get_type (m, ptr.24, &type, 0, 0B);
            ptr = ptr.26;
            output.22 = output;
            D.14797 = i + 1;
            type.27 = type;
            D.14799 = cols[1];
            D.14800 = mono_metadata_string_heap (m, D.14799);
            fprintf (output.22, "%d: %s %s (", D.14797, type.27, D.14800);
            type.27 = type;
            monoeg_g_free (type.27);
            j = 0;
            goto <D.14175>;
            <D.14174>:
            ptr.24 = ptr;
            ptr.28 = get_param (m, ptr.24, &type, 0B);
            ptr = ptr.28;
            output.22 = output;
            if (j > 0) goto <D.14803>; else goto <D.14804>;
            <D.14803>:
            iftmp.29 = ", ";
            goto <D.14805>;
            <D.14804>:
            iftmp.29 = "";
            <D.14805>:
            type.27 = type;
            fprintf (output.22, "%s%s", iftmp.29, type.27);
            type.27 = type;
            monoeg_g_free (type.27);
            j = j + 1;
            <D.14175>:
            if (j < pcount) goto <D.14174>; else goto <D.14176>;
            <D.14176>:
            output.22 = output;
            fprintf (output.22, ") %s\n", &flags);
          }
        finally
          {
            cols = {CLOBBER};
            type = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14178>:
      D.14772 = t->rows;
      D.14773 = (int) D.14772;
      if (D.14773 > i) goto <D.14177>; else goto <D.14179>;
      <D.14179>:
    }
  finally
    {
      ptr = {CLOBBER};
      flags = {CLOBBER};
    }
}


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

  D.14807 = __builtin_object_size (__dest, 1);
  D.14806 = __builtin___strcat_chk (__dest, __src, D.14807);
  return D.14806;
}


dump_table_event (struct MonoImage * m)
{
  struct FILE * output.30;
  <unnamed-unsigned:24> D.14810;
  int D.14811;
  unsigned int D.14812;
  unsigned int D.14813;
  int D.14814;
  const char * iftmp.31;
  unsigned int D.14816;
  unsigned int D.14817;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14812 = cols[1];
        name = mono_metadata_string_heap (m, D.14812);
        D.14813 = cols[2];
        type = get_typedef_or_ref (m, D.14813, 0B);
        output.30 = output;
        D.14814 = i + 1;
        D.14816 = cols[0];
        D.14817 = D.14816 & 512;
        if (D.14817 != 0) goto <D.14818>; else goto <D.14819>;
        <D.14818>:
        iftmp.31 = "specialname ";
        goto <D.14820>;
        <D.14819>:
        iftmp.31 = "";
        <D.14820>:
        fprintf (output.30, "%d: %s %s %s\n", D.14814, type, name, iftmp.31);
        monoeg_g_free (type);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14189>:
  D.14810 = t->rows;
  D.14811 = (int) D.14810;
  if (D.14811 > i) goto <D.14188>; else goto <D.14190>;
  <D.14190>:
}


dump_table_file (struct MonoImage * m)
{
  struct FILE * output.32;
  <unnamed-unsigned:24> D.14822;
  int D.14823;
  unsigned int D.14824;
  int D.14825;
  const char * iftmp.33;
  unsigned int D.14827;
  unsigned int D.14828;
  unsigned int D.14832;
  const char * hash.34;
  const char * hash.35;
  unsigned int D.14835;
  const char * iftmp.36;
  sizetype j.37;
  const char * D.14841;
  char D.14842;
  int D.14843;
  int D.14844;
  struct MonoTableInfo * t;
  int i;
  int j;
  int len;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.14824 = cols[1];
        name = mono_metadata_string_heap (m, D.14824);
        output.32 = output;
        D.14825 = i + 1;
        D.14827 = cols[0];
        D.14828 = D.14827 & 1;
        if (D.14828 != 0) goto <D.14829>; else goto <D.14830>;
        <D.14829>:
        iftmp.33 = "nometadata";
        goto <D.14831>;
        <D.14830>:
        iftmp.33 = "containsmetadata";
        <D.14831>:
        fprintf (output.32, "%d: %s %s [", D.14825, name, iftmp.33);
        D.14832 = cols[2];
        hash.34 = mono_metadata_blob_heap (m, D.14832);
        hash = hash.34;
        hash.35 = hash;
        D.14835 = mono_metadata_decode_blob_size (hash.35, &hash);
        len = (int) D.14835;
        j = 0;
        goto <D.14202>;
        <D.14201>:
        output.32 = output;
        if (j != 0) goto <D.14837>; else goto <D.14838>;
        <D.14837>:
        iftmp.36 = " ";
        goto <D.14839>;
        <D.14838>:
        iftmp.36 = "";
        <D.14839>:
        hash.35 = hash;
        j.37 = (sizetype) j;
        D.14841 = hash.35 + j.37;
        D.14842 = *D.14841;
        D.14843 = (int) D.14842;
        D.14844 = D.14843 & 255;
        fprintf (output.32, "%s%02X", iftmp.36, D.14844);
        j = j + 1;
        <D.14202>:
        if (j < len) goto <D.14201>; else goto <D.14203>;
        <D.14203>:
        output.32 = output;
        fprintf (output.32, "]\n");
      }
    finally
      {
        cols = {CLOBBER};
        hash = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14205>:
  D.14822 = t->rows;
  D.14823 = (int) D.14822;
  if (D.14823 > i) goto <D.14204>; else goto <D.14206>;
  <D.14206>:
}


dump_table_manifest (struct MonoImage * m)
{
  struct FILE * output.38;
  <unnamed-unsigned:24> D.14846;
  int D.14847;
  unsigned int D.14848;
  unsigned int D.14849;
  unsigned int D.14850;
  int D.14851;
  unsigned int D.14852;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 4);
        D.14848 = cols[2];
        name = mono_metadata_string_heap (m, D.14848);
        D.14849 = cols[1];
        mf = get_manifest_flags (D.14849);
        D.14850 = cols[3];
        impl = get_manifest_implementation (m, D.14850);
        output.38 = output;
        D.14851 = i + 1;
        D.14852 = cols[0];
        fprintf (output.38, "%d: %s \'%s\' at offset %u in %s\n", D.14851, mf, name, D.14852, impl);
        monoeg_g_free (impl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14234>:
  D.14846 = t->rows;
  D.14847 = (int) D.14846;
  if (D.14847 > i) goto <D.14233>; else goto <D.14235>;
  <D.14235>:
}


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

  mf = mf & 3;
  switch (mf) <default: <D.14223>, case 1: <D.14221>, case 2: <D.14222>>
  <D.14221>:
  D.14853 = "public";
  return D.14853;
  <D.14222>:
  D.14853 = "private";
  return D.14853;
  <D.14223>:
  D.14853 = "";
  return D.14853;
}


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

  table = "";
  if (idx == 0) goto <D.14855>; else goto <D.14856>;
  <D.14855>:
  D.14857 = monoeg_strdup ("current module");
  return D.14857;
  <D.14856>:
  row = idx >> 2;
  D.14858 = idx & 3;
  switch (D.14858) <default: <D.14217>, case 0: <D.14213>, case 1: <D.14215>, case 2: <D.14216>>
  <D.14213>:
  table = "file";
  goto <D.14214>;
  <D.14215>:
  table = "assemblyref";
  goto <D.14214>;
  <D.14216>:
  table = "exportedtype";
  goto <D.14214>;
  <D.14217>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dump.c", 475);
  <D.14214>:
  D.14857 = monoeg_g_strdup_printf ("%s %d", table, row);
  return D.14857;
}


dump_table_moduleref (struct MonoImage * m)
{
  struct FILE * output.39;
  <unnamed-unsigned:24> D.14861;
  int D.14862;
  unsigned int D.14863;
  int D.14864;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 1);
        D.14863 = cols[0];
        name = mono_metadata_string_heap (m, D.14863);
        output.39 = output;
        D.14864 = i + 1;
        fprintf (output.39, "%d: %s\n", D.14864, name);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14244>:
  D.14861 = t->rows;
  D.14862 = (int) D.14861;
  if (D.14862 > i) goto <D.14243>; else goto <D.14245>;
  <D.14245>:
}


dump_table_module (struct MonoImage * m)
{
  struct FILE * output.40;
  <unnamed-unsigned:24> D.14866;
  int D.14867;
  unsigned int D.14868;
  unsigned int D.14869;
  int D.14870;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 5);
        D.14868 = cols[1];
        name = mono_metadata_string_heap (m, D.14868);
        D.14869 = cols[2];
        guid = get_guid (m, D.14869);
        output.40 = output;
        D.14870 = i + 1;
        D.14869 = cols[2];
        fprintf (output.40, "%d: %s %d %s\n", D.14870, name, D.14869, guid);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14255>:
  D.14866 = t->rows;
  D.14867 = (int) D.14866;
  if (D.14867 > i) goto <D.14254>; else goto <D.14256>;
  <D.14256>:
}


dump_table_method (struct MonoImage * m)
{
  struct FILE * output.41;
  <unnamed-unsigned:24> D.14872;
  int D.14873;
  <unnamed-unsigned:24> D.14874;
  int D.14875;
  unsigned int i.42;
  int D.14878;
  int D.14881;
  unsigned int D.14882;
  const char * D.14883;
  unsigned int D.14884;
  const char * D.14885;
  int D.14886;
  unsigned int D.14887;
  int D.14890;
  unsigned int D.14891;
  int D.14894;
  unsigned int D.14895;
  const char * sigblob.43;
  const char * sigblob.44;
  struct MonoGenericContainer * iftmp.45;
  struct MonoGenericContainer * iftmp.46;
  unsigned int D.14906;
  unsigned int D.14907;
  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;
  output.41 = output;
  D.14872 = t->rows;
  D.14873 = (int) D.14872;
  fprintf (output.41, "Method Table (1..%d)\n", D.14873);
  current_type = 1;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14277>;
  <D.14276>:
  {
    guint32 cols[6];
    char * sig;
    char * impl_flags;
    const char * sigblob;
    struct MonoMethodSignature * method;

    try
      {
        goto <D.14274>;
        <D.14273>:
        current_type = current_type + 1;
        <D.14274>:
        D.14874 = td->rows;
        D.14875 = (int) D.14874;
        if (D.14875 >= current_type) goto <D.14876>; else goto <D.14275>;
        <D.14876>:
        i.42 = (unsigned int) i;
        D.14878 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.14878, 5);
        if (i.42 >= last_m) goto <D.14273>; else goto <D.14275>;
        <D.14275>:
        i.42 = (unsigned int) i;
        if (i.42 == first_m) goto <D.14879>; else goto <D.14880>;
        <D.14879>:
        output.41 = output;
        D.14881 = current_type + -2;
        D.14882 = mono_metadata_decode_row_col (td, D.14881, 2);
        D.14883 = mono_metadata_string_heap (m, D.14882);
        D.14881 = current_type + -2;
        D.14884 = mono_metadata_decode_row_col (td, D.14881, 1);
        D.14885 = mono_metadata_string_heap (m, D.14884);
        fprintf (output.41, "########## %s.%s\n", D.14883, D.14885);
        first_m = last_m;
        D.14878 = current_type + -1;
        D.14886 = D.14878 | 33554432;
        D.14887 = (unsigned int) D.14886;
        type_container = mono_metadata_load_generic_params (m, D.14887, 0B);
        if (type_container != 0B) goto <D.14888>; else goto <D.14889>;
        <D.14888>:
        D.14878 = current_type + -1;
        D.14886 = D.14878 | 33554432;
        D.14887 = (unsigned int) D.14886;
        mono_metadata_load_generic_param_constraints (m, D.14887, type_container);
        <D.14889>:
        <D.14880>:
        D.14890 = i | 100663296;
        D.14891 = (unsigned int) D.14890;
        method_container = mono_metadata_load_generic_params (m, D.14891, type_container);
        if (method_container != 0B) goto <D.14892>; else goto <D.14893>;
        <D.14892>:
        D.14890 = i | 100663296;
        D.14891 = (unsigned int) D.14890;
        mono_metadata_load_generic_param_constraints (m, D.14891, method_container);
        <D.14893>:
        D.14894 = i + -1;
        mono_metadata_decode_table_row (m, 6, D.14894, &cols, 6);
        D.14895 = cols[4];
        sigblob.43 = mono_metadata_blob_heap (m, D.14895);
        sigblob = sigblob.43;
        sigblob.44 = sigblob;
        mono_metadata_decode_blob_size (sigblob.44, &sigblob);
        if (method_container != 0B) goto <D.14899>; else goto <D.14900>;
        <D.14899>:
        iftmp.45 = method_container;
        goto <D.14901>;
        <D.14900>:
        iftmp.45 = type_container;
        <D.14901>:
        sigblob.44 = sigblob;
        method = mono_metadata_parse_method_signature_full (m, iftmp.45, i, sigblob.44, &sigblob);
        if (method_container != 0B) goto <D.14903>; else goto <D.14904>;
        <D.14903>:
        iftmp.46 = method_container;
        goto <D.14905>;
        <D.14904>:
        iftmp.46 = type_container;
        <D.14905>:
        sig = dis_stringify_method_signature (m, method, i, iftmp.46, 0);
        D.14906 = cols[1];
        impl_flags = get_method_impl_flags (D.14906);
        output.41 = output;
        D.14907 = cols[5];
        fprintf (output.41, "%d: %s (param: %d impl_flags: %s)\n", i, sig, D.14907, 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.14277>:
  D.14872 = t->rows;
  D.14873 = (int) D.14872;
  if (D.14873 >= i) goto <D.14276>; else goto <D.14278>;
  <D.14278>:
}


dump_table_implmap (struct MonoImage * m)
{
  struct FILE * output.47;
  <unnamed-unsigned:24> D.14909;
  int D.14910;
  int D.14911;
  unsigned int D.14912;
  unsigned int D.14913;
  unsigned int D.14914;
  unsigned int D.14915;
  unsigned int D.14916;
  const char * D.14917;
  unsigned int D.14918;
  unsigned int D.14919;
  int D.14920;
  unsigned int D.14921;
  const char * D.14922;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  int i;

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

    try
      {
        D.14911 = i + -1;
        mono_metadata_decode_row (t, D.14911, &cols, 4);
        D.14912 = cols[1];
        D.14913 = D.14912 >> 1;
        D.14914 = D.14913 | 100663296;
        method = get_method (m, D.14914, 0B);
        output.47 = output;
        D.14915 = cols[0];
        D.14916 = cols[2];
        D.14917 = mono_metadata_string_heap (m, D.14916);
        D.14918 = cols[3];
        D.14919 = D.14918 + 4294967295;
        D.14920 = (int) D.14919;
        D.14921 = mono_metadata_decode_row_col (td, D.14920, 0);
        D.14922 = mono_metadata_string_heap (m, D.14921);
        fprintf (output.47, "%d: %s %d (%s %s)\n", i, method, D.14915, D.14917, D.14922);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14288>:
  D.14909 = t->rows;
  D.14910 = (int) D.14909;
  if (D.14910 >= i) goto <D.14287>; else goto <D.14289>;
  <D.14289>:
}


dump_table_fieldrva (struct MonoImage * m)
{
  struct FILE * output.48;
  <unnamed-unsigned:24> D.14924;
  int D.14925;
  int D.14926;
  unsigned int D.14927;
  unsigned int D.14928;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.14926 = i + -1;
        mono_metadata_decode_row (t, D.14926, &cols, 2);
        output.48 = output;
        D.14927 = cols[1];
        D.14928 = cols[0];
        fprintf (output.48, "%d: Field %d: %x\n", i, D.14927, D.14928);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14297>:
  D.14924 = t->rows;
  D.14925 = (int) D.14924;
  if (D.14925 >= i) goto <D.14296>; else goto <D.14298>;
  <D.14298>:
}


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

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

    try
      {
        D.14932 = i + -1;
        mono_metadata_decode_row (t, D.14932, &cols, 3);
        D.14933 = cols[0];
        D.14934 = (int) D.14933;
        class = get_typedef (m, D.14934);
        D.14935 = cols[1];
        D.14936 = method_dor_to_token (D.14935);
        impl = get_method (m, D.14936, 0B);
        D.14937 = cols[2];
        D.14938 = method_dor_to_token (D.14937);
        decl = get_method (m, D.14938, 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.14309>:
  D.14930 = t->rows;
  D.14931 = (int) D.14930;
  if (D.14931 >= i) goto <D.14308>; else goto <D.14310>;
  <D.14310>:
}


dump_table_methodsem (struct MonoImage * m)
{
  struct FILE * output.50;
  <unnamed-unsigned:24> D.14940;
  int D.14941;
  int D.14942;
  unsigned int D.14943;
  unsigned int D.14944;
  int D.14945;
  unsigned int D.14946;
  unsigned int D.14947;
  unsigned int D.14948;
  const char * iftmp.51;
  struct MonoTableInfo * t;
  int i;
  int is_property;
  int index;
  const char * semantics;

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

    try
      {
        D.14942 = i + -1;
        mono_metadata_decode_row (t, D.14942, &cols, 3);
        D.14943 = cols[0];
        semantics = flags (D.14943, &semantics_map);
        D.14944 = cols[2];
        D.14945 = (int) D.14944;
        is_property = D.14945 & 1;
        D.14944 = cols[2];
        D.14946 = D.14944 >> 1;
        index = (int) D.14946;
        output.50 = output;
        D.14944 = cols[2];
        D.14947 = cols[1];
        D.14948 = D.14947 + 4294967295;
        if (is_property != 0) goto <D.14950>; else goto <D.14951>;
        <D.14950>:
        iftmp.51 = "property";
        goto <D.14952>;
        <D.14951>:
        iftmp.51 = "event";
        <D.14952>:
        fprintf (output.50, "%d: [%d] %s method: %d %s %d\n", i, D.14944, semantics, D.14948, iftmp.51, index);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14322>:
  D.14940 = t->rows;
  D.14941 = (int) D.14940;
  if (D.14941 >= i) goto <D.14321>; else goto <D.14323>;
  <D.14323>:
}


dump_table_interfaceimpl (struct MonoImage * m)
{
  struct FILE * output.52;
  <unnamed-unsigned:24> D.14954;
  int D.14955;
  int D.14956;
  unsigned int D.14957;
  int D.14958;
  char * D.14959;
  unsigned int D.14960;
  char * D.14961;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.14956 = i + -1;
        mono_metadata_decode_row (t, D.14956, &cols, 2);
        output.52 = output;
        D.14957 = cols[0];
        D.14958 = (int) D.14957;
        D.14959 = get_typedef (m, D.14958);
        D.14960 = cols[1];
        D.14961 = get_typedef_or_ref (m, D.14960, 0B);
        fprintf (output.52, "%d: %s implements %s\n", i, D.14959, D.14961);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14331>:
  D.14954 = t->rows;
  D.14955 = (int) D.14954;
  if (D.14955 >= i) goto <D.14330>; else goto <D.14332>;
  <D.14332>:
}


dump_table_customattr (struct MonoImage * m)
{
  struct FILE * output.53;
  <unnamed-unsigned:24> D.14963;
  int D.14964;
  int D.14965;
  unsigned int D.14966;
  unsigned int D.14967;
  unsigned int D.14968;
  struct MonoMethodSignature * D.14969;
  unsigned int D.14970;
  const char * D.14971;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.14965 = i + -1;
        mono_metadata_decode_row (t, D.14965, &cols, 3);
        D.14966 = cols[0];
        desc = has_cattr_get_table (m, D.14966);
        D.14967 = cols[1];
        mtoken = D.14967 >> 3;
        D.14967 = cols[1];
        D.14968 = D.14967 & 7;
        switch (D.14968) <default: <D.14418>, case 2: <D.14415>, case 3: <D.14417>>
        <D.14415>:
        mtoken = mtoken | 100663296;
        goto <D.14416>;
        <D.14417>:
        mtoken = mtoken | 167772160;
        goto <D.14416>;
        <D.14418>:
        D.14967 = cols[1];
        monoeg_g_log (0B, 16, "Unknown table for custom attr type %08x", D.14967);
        goto <D.14416>;
        <D.14416>:
        method = get_method (m, mtoken, 0B);
        meth = mono_get_method (m, mtoken, 0B);
        D.14969 = mono_method_signature (meth);
        D.14970 = cols[2];
        D.14971 = mono_metadata_blob_heap (m, D.14970);
        params = custom_attr_params (m, D.14969, D.14971);
        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.14420>:
  D.14963 = t->rows;
  D.14964 = (int) D.14963;
  if (D.14964 >= i) goto <D.14419>; else goto <D.14421>;
  <D.14421>:
}


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

  t = val & 31;
  index = val >> 5;
  switch (t) <default: <D.14361>, case 0: <D.14340>, case 1: <D.14342>, case 2: <D.14343>, case 3: <D.14344>, case 4: <D.14345>, case 5: <D.14346>, case 6: <D.14347>, case 7: <D.14348>, case 8: <D.14349>, case 9: <D.14350>, case 10: <D.14351>, case 11: <D.14352>, case 12: <D.14353>, case 13: <D.14354>, case 14: <D.14355>, case 15: <D.14356>, case 16: <D.14357>, case 17: <D.14358>, case 18: <D.14359>, case 19: <D.14360>>
  <D.14340>:
  table = "MethodDef";
  goto <D.14341>;
  <D.14342>:
  table = "FieldDef";
  goto <D.14341>;
  <D.14343>:
  table = "TypeRef";
  goto <D.14341>;
  <D.14344>:
  table = "TypeDef";
  goto <D.14341>;
  <D.14345>:
  table = "Param";
  goto <D.14341>;
  <D.14346>:
  table = "InterfaceImpl";
  goto <D.14341>;
  <D.14347>:
  table = "MemberRef";
  goto <D.14341>;
  <D.14348>:
  table = "Module";
  goto <D.14341>;
  <D.14349>:
  table = "DeclSecurity?";
  goto <D.14341>;
  <D.14350>:
  table = "Property";
  goto <D.14341>;
  <D.14351>:
  table = "Event";
  goto <D.14341>;
  <D.14352>:
  table = "StandAloneSignature";
  goto <D.14341>;
  <D.14353>:
  table = "ModuleRef";
  goto <D.14341>;
  <D.14354>:
  table = "TypeSpec";
  goto <D.14341>;
  <D.14355>:
  table = "Assembly";
  goto <D.14341>;
  <D.14356>:
  table = "AssemblyRef";
  goto <D.14341>;
  <D.14357>:
  table = "File";
  goto <D.14341>;
  <D.14358>:
  table = "ExportedType";
  goto <D.14341>;
  <D.14359>:
  table = "Manifest";
  goto <D.14341>;
  <D.14360>:
  table = "GenericParam";
  goto <D.14341>;
  <D.14361>:
  table = "Unknown";
  goto <D.14341>;
  <D.14341>:
  D.14972 = monoeg_g_strdup_printf ("%s: %d", table, index);
  return D.14972;
}


custom_attr_params (struct MonoImage * m, struct MonoMethodSignature * sig, const char * value)
{
  const char * p.54;
  unsigned int D.14975;
  short unsigned int D.14979;
  char * D.14980;
  const char * p.55;
  struct MonoType * D.14984;
  unsigned char D.14985;
  char D.14986;
  unsigned int D.14987;
  const char * p.56;
  int D.14989;
  const char * iftmp.57;
  short unsigned int D.14994;
  int D.14995;
  short unsigned int D.14996;
  int D.14997;
  short unsigned int D.14998;
  short int D.14999;
  int D.15000;
  unsigned int D.15001;
  const char * p.58;
  unsigned int D.15003;
  int D.15004;
  long long unsigned int D.15005;
  long long int D.15006;
  const char * p.59;
  long long unsigned int D.15008;
  long long int D.15009;
  unsigned int D.15010;
  float val.60;
  float val.61;
  double D.15013;
  int D.15020;
  long long unsigned int D.15024;
  double val.62;
  double val.63;
  int D.15033;
  struct MonoClass * D.15037;
  int D.15038;
  struct MonoType * D.15041;
  unsigned char D.15042;
  unsigned int D.15045;
  sizetype slen.64;
  const char * p.65;
  int D.15048;
  short unsigned int D.15049;
  int D.15050;
  short unsigned int D.15051;
  int value.66;
  int p.67;
  int D.15056;
  int D.15057;
  sizetype i.68;
  const char * D.15059;
  char D.15060;
  int D.15061;
  int D.15062;
  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.14975 = mono_metadata_decode_value (p.54, &p);
      len = (int) D.14975;
      if (len <= 1) goto <D.14976>; else goto <D.14978>;
      <D.14978>:
      p.54 = p;
      D.14979 = mono_read16 (p.54);
      if (D.14979 != 1) goto <D.14976>; else goto <D.14977>;
      <D.14976>:
      D.14980 = monoeg_strdup ("");
      return D.14980;
      <D.14977>:
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      res = monoeg_g_string_new ("");
      i = 0;
      goto <D.14399>;
      <D.14398>:
      if (i != 0) goto <D.14982>; else goto <D.14983>;
      <D.14982>:
      monoeg_g_string_append (res, ", ");
      <D.14983>:
      D.14984 = sig->params[i];
      D.14985 = D.14984->type;
      type = (int) D.14985;
      handle_enum:
      switch (type) <default: <D.14397>, case 2: <D.14378>, case 3: <D.14379>, case 4: <D.14377>, case 5: <D.14375>, case 6: <D.14381>, case 7: <D.14380>, case 8: <D.14383>, case 9: <D.14382>, case 10: <D.14385>, case 11: <D.14384>, case 12: <D.14386>, case 13: <D.14390>, case 14: <D.14396>, case 17: <D.14394>, case 18: <D.14395>>
      <D.14375>:
      p.54 = p;
      D.14986 = *p.54;
      D.14987 = (unsigned int) D.14986;
      monoeg_g_string_append_printf (res, "%d", D.14987);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14376>;
      <D.14377>:
      p.54 = p;
      D.14986 = *p.54;
      D.14989 = (int) D.14986;
      monoeg_g_string_append_printf (res, "%d", D.14989);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14376>;
      <D.14378>:
      p.54 = p;
      D.14986 = *p.54;
      if (D.14986 != 0) goto <D.14991>; else goto <D.14992>;
      <D.14991>:
      iftmp.57 = "true";
      goto <D.14993>;
      <D.14992>:
      iftmp.57 = "false";
      <D.14993>:
      monoeg_g_string_append_printf (res, "%s", iftmp.57);
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14376>;
      <D.14379>:
      p.54 = p;
      D.14994 = mono_read16 (p.54);
      D.14995 = (int) D.14994;
      monoeg_g_string_append_printf (res, "\'%c\'", D.14995);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14376>;
      <D.14380>:
      p.54 = p;
      D.14996 = mono_read16 (p.54);
      D.14997 = (int) D.14996;
      monoeg_g_string_append_printf (res, "%d", D.14997);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14376>;
      <D.14381>:
      p.54 = p;
      D.14998 = mono_read16 (p.54);
      D.14999 = (short int) D.14998;
      D.15000 = (int) D.14999;
      monoeg_g_string_append_printf (res, "%d", D.15000);
      p.54 = p;
      p.55 = p.54 + 2;
      p = p.55;
      goto <D.14376>;
      <D.14382>:
      p.54 = p;
      D.15001 = mono_read32 (p.54);
      monoeg_g_string_append_printf (res, "%d", D.15001);
      p.54 = p;
      p.58 = p.54 + 4;
      p = p.58;
      goto <D.14376>;
      <D.14383>:
      p.54 = p;
      D.15003 = mono_read32 (p.54);
      D.15004 = (int) D.15003;
      monoeg_g_string_append_printf (res, "%d", D.15004);
      p.54 = p;
      p.58 = p.54 + 4;
      p = p.58;
      goto <D.14376>;
      <D.14384>:
      p.54 = p;
      D.15005 = mono_read64 (p.54);
      D.15006 = (long long int) D.15005;
      monoeg_g_string_append_printf (res, "%lld", D.15006);
      p.54 = p;
      p.59 = p.54 + 8;
      p = p.59;
      goto <D.14376>;
      <D.14385>:
      p.54 = p;
      D.15008 = mono_read64 (p.54);
      D.15009 = (long long int) D.15008;
      monoeg_g_string_append_printf (res, "%lld", D.15009);
      p.54 = p;
      p.59 = p.54 + 8;
      p = p.59;
      goto <D.14376>;
      <D.14386>:
      {
        float val;
        int inf;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  p.54 = p;
                  D.15010 = mono_read32 (p.54);
                  mf.ival = D.15010;
                  val.60 = mf.fval;
                  val = val.60;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.61 = val;
            D.15013 = (double) val.61;
            inf = dis_isinf (D.15013);
            if (inf == -1) goto <D.15014>; else goto <D.15015>;
            <D.15014>:
            monoeg_g_string_append_printf (res, "(00 00 80 ff)");
            goto <D.15016>;
            <D.15015>:
            if (inf == 1) goto <D.15017>; else goto <D.15018>;
            <D.15017>:
            monoeg_g_string_append_printf (res, "(00 00 80 7f)");
            goto <D.15019>;
            <D.15018>:
            val.61 = val;
            D.15013 = (double) val.61;
            D.15020 = dis_isnan (D.15013);
            if (D.15020 != 0) goto <D.15021>; else goto <D.15022>;
            <D.15021>:
            monoeg_g_string_append_printf (res, "(00 00 c0 ff)");
            goto <D.15023>;
            <D.15022>:
            val.61 = val;
            D.15013 = (double) val.61;
            monoeg_g_string_append_printf (res, "%g", D.15013);
            <D.15023>:
            <D.15019>:
            <D.15016>:
            p.54 = p;
            p.58 = p.54 + 4;
            p = p.58;
            goto <D.14376>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14390>:
      {
        double val;
        int inf;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  p.54 = p;
                  D.15024 = mono_read64 (p.54);
                  mf.ival = D.15024;
                  val.62 = mf.fval;
                  val = val.62;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.63 = val;
            inf = dis_isinf (val.63);
            if (inf == -1) goto <D.15027>; else goto <D.15028>;
            <D.15027>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 ff)");
            goto <D.15029>;
            <D.15028>:
            if (inf == 1) goto <D.15030>; else goto <D.15031>;
            <D.15030>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 7f)");
            goto <D.15032>;
            <D.15031>:
            val.63 = val;
            D.15033 = __isnan (val.63);
            if (D.15033 != 0) goto <D.15034>; else goto <D.15035>;
            <D.15034>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f8 ff)");
            goto <D.15036>;
            <D.15035>:
            val.63 = val;
            monoeg_g_string_append_printf (res, "%g", val.63);
            <D.15036>:
            <D.15032>:
            <D.15029>:
            p.54 = p;
            p.59 = p.54 + 8;
            p = p.59;
            goto <D.14376>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.14394>:
      D.14984 = sig->params[i];
      D.15037 = D.14984->data.klass;
      D.15038 = mono_class_is_enum (D.15037);
      if (D.15038 != 0) goto <D.15039>; else goto <D.15040>;
      <D.15039>:
      D.14984 = sig->params[i];
      D.15037 = D.14984->data.klass;
      D.15041 = mono_class_enum_basetype (D.15037);
      D.15042 = D.15041->type;
      type = (int) D.15042;
      goto handle_enum;
      <D.15040>:
      monoeg_g_log (0B, 16, "generic valutype not handled in custom attr value decoding");
      goto <D.14376>;
      <D.14395>:
      <D.14396>:
      p.54 = p;
      D.14986 = *p.54;
      if (D.14986 == -1) goto <D.15043>; else goto <D.15044>;
      <D.15043>:
      monoeg_g_string_append (res, "null");
      p.54 = p;
      p.56 = p.54 + 1;
      p = p.56;
      goto <D.14376>;
      <D.15044>:
      p.54 = p;
      D.15045 = mono_metadata_decode_value (p.54, &p);
      slen = (int) D.15045;
      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.14376>;
      <D.14397>:
      D.14984 = sig->params[i];
      D.14985 = D.14984->type;
      D.15048 = (int) D.14985;
      monoeg_g_log (0B, 16, "Type %02x not handled in custom attr value decoding", D.15048);
      goto <D.14376>;
      <D.14376>:
      i = i + 1;
      <D.14399>:
      D.15049 = sig->param_count;
      D.15050 = (int) D.15049;
      if (D.15050 > i) goto <D.14398>; else goto <D.14400>;
      <D.14400>:
      p.54 = p;
      D.15051 = mono_read16 (p.54);
      slen = (int) D.15051;
      if (slen != 0) goto <D.15052>; else goto <D.15053>;
      <D.15052>:
      monoeg_g_string_append_printf (res, " %d named args: (", slen);
      value.66 = (int) value;
      p.54 = p;
      p.67 = (int) p.54;
      D.15056 = value.66 - p.67;
      D.15057 = D.15056 + len;
      slen = D.15057 + 1;
      i = 0;
      goto <D.14402>;
      <D.14401>:
      p.54 = p;
      i.68 = (sizetype) i;
      D.15059 = p.54 + i.68;
      D.15060 = *D.15059;
      D.15061 = (int) D.15060;
      D.15062 = D.15061 & 255;
      monoeg_g_string_append_printf (res, " %02X", D.15062);
      i = i + 1;
      <D.14402>:
      if (i < slen) goto <D.14401>; else goto <D.14403>;
      <D.14403>:
      monoeg_g_string_append_c (res, 41);
      <D.15053>:
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.14980 = s;
      return D.14980;
    }
  finally
    {
      p = {CLOBBER};
    }
}


dump_table_nestedclass (struct MonoImage * m)
{
  struct FILE * output.69;
  <unnamed-unsigned:24> D.15068;
  int D.15069;
  int D.15070;
  unsigned int D.15071;
  int D.15072;
  unsigned int D.15073;
  int D.15074;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  char * nested;
  char * nesting;

  try
    {
      t = &m->tables[41];
      output.69 = output;
      D.15068 = t->rows;
      D.15069 = (int) D.15068;
      fprintf (output.69, "NestedClass Table (1..%d)\n", D.15069);
      i = 1;
      goto <D.14431>;
      <D.14430>:
      D.15070 = i + -1;
      mono_metadata_decode_row (t, D.15070, &cols, 2);
      D.15071 = cols[0];
      D.15072 = (int) D.15071;
      nested = get_typedef (m, D.15072);
      D.15073 = cols[1];
      D.15074 = (int) D.15073;
      nesting = get_typedef (m, D.15074);
      output.69 = output;
      D.15071 = cols[0];
      D.15073 = cols[1];
      fprintf (output.69, "%d: %d %d: %s in %s\n", i, D.15071, D.15073, nested, nesting);
      monoeg_g_free (nested);
      monoeg_g_free (nesting);
      i = i + 1;
      <D.14431>:
      D.15068 = t->rows;
      D.15069 = (int) D.15068;
      if (D.15069 >= i) goto <D.14430>; else goto <D.14432>;
      <D.14432>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_exported (struct MonoImage * m)
{
  struct FILE * output.70;
  <unnamed-unsigned:24> D.15076;
  int D.15077;
  int D.15078;
  unsigned int D.15079;
  unsigned int D.15080;
  unsigned int D.15081;
  const char * iftmp.71;
  char D.15083;
  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];
      output.70 = output;
      D.15076 = t->rows;
      D.15077 = (int) D.15076;
      fprintf (output.70, "ExportedType Table (1..%d)\n", D.15077);
      i = 1;
      goto <D.14445>;
      <D.14444>:
      D.15078 = i + -1;
      mono_metadata_decode_row (t, D.15078, &cols, 5);
      D.15079 = cols[2];
      name = mono_metadata_string_heap (m, D.15079);
      D.15080 = cols[3];
      nspace = mono_metadata_string_heap (m, D.15080);
      D.15081 = cols[4];
      impl = get_manifest_implementation (m, D.15081);
      index = cols[1];
      flags = cols[0];
      output.70 = output;
      D.15083 = *nspace;
      if (D.15083 != 0) goto <D.15084>; else goto <D.15085>;
      <D.15084>:
      iftmp.71 = ".";
      goto <D.15086>;
      <D.15085>:
      iftmp.71 = "";
      <D.15086>:
      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.14445>:
      D.15076 = t->rows;
      D.15077 = (int) D.15076;
      if (D.15077 >= i) goto <D.14444>; else goto <D.14446>;
      <D.14446>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_field_marshal (struct MonoImage * m)
{
  struct FILE * output.72;
  <unnamed-unsigned:24> D.15088;
  int D.15089;
  int D.15090;
  unsigned int D.15091;
  unsigned int D.15092;
  unsigned int D.15093;
  _Bool D.15094;
  unsigned int D.15095;
  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];
      output.72 = output;
      D.15088 = t->rows;
      D.15089 = (int) D.15088;
      fprintf (output.72, "FieldMarshal Table (1..%d)\n", D.15089);
      i = 1;
      goto <D.14467>;
      <D.14466>:
      D.15090 = i + -1;
      mono_metadata_decode_row (t, D.15090, &cols, 2);
      D.15091 = cols[1];
      blob = mono_metadata_blob_heap (m, D.15091);
      native = get_marshal_info (m, blob);
      D.15092 = cols[0];
      D.15093 = D.15092 & 1;
      D.15094 = D.15093 == 0;
      is_field = (int) D.15094;
      D.15092 = cols[0];
      D.15095 = D.15092 >> 1;
      idx = (int) D.15095;
      output.72 = output;
      D.15092 = cols[0];
      if (is_field != 0) goto <D.15097>; else goto <D.15098>;
      <D.15097>:
      iftmp.73 = "Field";
      goto <D.15099>;
      <D.15098>:
      iftmp.73 = "Param";
      <D.15099>:
      fprintf (output.72, "%d: (0x%04x) %s %d: %s\n", i, D.15092, 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.14467>:
      D.15088 = t->rows;
      D.15089 = (int) D.15088;
      if (D.15089 >= i) goto <D.14466>; else goto <D.14468>;
      <D.14468>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_blob (struct MonoImage * m, const char * blob)
{
  const char * blob.74;
  unsigned int D.15101;
  struct FILE * output.75;
  sizetype j.76;
  const char * D.15104;
  char D.15105;
  int D.15106;
  int D.15107;
  int j;
  int bsize;

  blob.74 = blob;
  D.15101 = mono_metadata_decode_blob_size (blob.74, &blob);
  bsize = (int) D.15101;
  j = 0;
  goto <D.14454>;
  <D.14453>:
  output.75 = output;
  blob.74 = blob;
  j.76 = (sizetype) j;
  D.15104 = blob.74 + j.76;
  D.15105 = *D.15104;
  D.15106 = (int) D.15105;
  D.15107 = D.15106 & 255;
  fprintf (output.75, "%02x ", D.15107);
  j = j + 1;
  <D.14454>:
  if (j < bsize) goto <D.14453>; else goto <D.14455>;
  <D.14455>:
}


dump_table_declsec (struct MonoImage * m)
{
  struct FILE * output.77;
  <unnamed-unsigned:24> D.15109;
  int D.15110;
  int D.15111;
  unsigned int D.15112;
  const char * blob.78;
  const char * blob.79;
  unsigned int D.15115;
  unsigned int D.15116;
  int D.15117;
  unsigned int D.15118;
  const char * D.15119;
  unsigned int D.15120;
  const char * iftmp.80;
  char D.15127;
  const char * D.15131;
  char D.15132;
  int D.15133;
  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] = "";
      output.77 = output;
      D.15109 = t->rows;
      D.15110 = (int) D.15109;
      fprintf (output.77, "DeclSecurity Table (1..%d)\n", D.15110);
      i = 1;
      goto <D.14506>;
      <D.14505>:
      D.15111 = i + -1;
      mono_metadata_decode_row (t, D.15111, &cols, 3);
      D.15112 = cols[2];
      blob.78 = mono_metadata_blob_heap (m, D.15112);
      blob = blob.78;
      blob.79 = blob;
      D.15115 = mono_metadata_decode_blob_size (blob.79, &blob);
      len = (int) D.15115;
      D.15116 = cols[0];
      D.15117 = (int) D.15116;
      action = get_security_action (D.15117);
      idx = cols[1];
      output.77 = output;
      D.15118 = idx & 3;
      D.15119 = parent[D.15118];
      D.15120 = idx >> 2;
      if (len != 0) goto <D.15122>; else goto <D.15123>;
      <D.15122>:
      iftmp.80 = ":\n\t";
      goto <D.15124>;
      <D.15123>:
      iftmp.80 = "\n";
      <D.15124>:
      fprintf (output.77, "%d: %s on %s %d%s", i, action, D.15119, D.15120, iftmp.80);
      if (len == 0) goto <D.15125>; else goto <D.15126>;
      <D.15125>:
      // predicted unlikely by continue predictor.
      goto <D.14500>;
      <D.15126>:
      blob.79 = blob;
      D.15127 = *blob.79;
      if (D.15127 == 46) goto <D.15128>; else goto <D.15129>;
      <D.15128>:
      {
        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.15130>;
      <D.15129>:
      idx = 0;
      goto <D.14503>;
      <D.14502>:
      output.77 = output;
      blob.79 = blob;
      D.15131 = blob.79 + idx;
      D.15132 = *D.15131;
      D.15133 = (int) D.15132;
      fprintf (output.77, "%c", D.15133);
      idx = idx + 1;
      <D.14503>:
      len.81 = (unsigned int) len;
      if (len.81 > idx) goto <D.14502>; else goto <D.14504>;
      <D.14504>:
      <D.15130>:
      output.77 = output;
      fprintf (output.77, "\n");
      <D.14500>:
      i = i + 1;
      <D.14506>:
      D.15109 = t->rows;
      D.15110 = (int) D.15109;
      if (D.15110 >= i) goto <D.14505>; else goto <D.14507>;
      <D.14507>:
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
      parent = {CLOBBER};
    }
}


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

  switch (val) <default: <D.14488>, case 2: <D.14473>, case 3: <D.14474>, case 4: <D.14475>, case 5: <D.14476>, case 6: <D.14477>, case 7: <D.14478>, case 8: <D.14479>, case 9: <D.14480>, case 10: <D.14481>, case 13: <D.14482>, case 14: <D.14483>, case 15: <D.14484>, case 16: <D.14485>, case 17: <D.14486>, case 18: <D.14487>>
  <D.14473>:
  D.15135 = "Demand";
  return D.15135;
  <D.14474>:
  D.15135 = "Assert";
  return D.15135;
  <D.14475>:
  D.15135 = "Deny";
  return D.15135;
  <D.14476>:
  D.15135 = "PermitOnly";
  return D.15135;
  <D.14477>:
  D.15135 = "LinkDemand";
  return D.15135;
  <D.14478>:
  D.15135 = "InheritanceDemand";
  return D.15135;
  <D.14479>:
  D.15135 = "RequestMinimum";
  return D.15135;
  <D.14480>:
  D.15135 = "RequestOptional";
  return D.15135;
  <D.14481>:
  D.15135 = "RequestRefuse";
  return D.15135;
  <D.14482>:
  D.15135 = "NonCasDemand";
  return D.15135;
  <D.14483>:
  D.15135 = "NonCasLinkDemand";
  return D.15135;
  <D.14484>:
  D.15135 = "NonCasInheritance";
  return D.15135;
  <D.14485>:
  D.15135 = "LinkDemandChoice";
  return D.15135;
  <D.14486>:
  D.15135 = "InheritanceDemandChoice";
  return D.15135;
  <D.14487>:
  D.15135 = "DemandChoice";
  return D.15135;
  <D.14488>:
  monoeg_g_snprintf (&buf, 32, "0x%04X", val);
  D.15135 = &buf;
  return D.15135;
}


dump_table_genericpar (struct MonoImage * m)
{
  struct FILE * output.82;
  <unnamed-unsigned:24> D.15138;
  int D.15139;
  int D.15140;
  unsigned int D.15141;
  unsigned int D.15142;
  unsigned int D.15143;
  unsigned int D.15144;
  const char * D.15145;
  struct MonoTableInfo * t;
  guint32 cols[4];
  int i;

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

        D.15140 = i + -1;
        mono_metadata_decode_row (t, D.15140, &cols, 4);
        D.15141 = cols[2];
        sig = monoeg_g_strdup_printf ("%x", D.15141);
        output.82 = output;
        D.15142 = cols[0];
        D.15143 = cols[1];
        D.15144 = cols[3];
        D.15145 = mono_metadata_string_heap (m, D.15144);
        fprintf (output.82, "%d: %d, flags=%d, owner=%s %s\n", i, D.15142, D.15143, sig, D.15145);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14516>:
      D.15138 = t->rows;
      D.15139 = (int) D.15138;
      if (D.15139 >= i) goto <D.14515>; else goto <D.14517>;
      <D.14517>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_methodspec (struct MonoImage * m)
{
  struct FILE * output.83;
  <unnamed-unsigned:24> D.15147;
  int D.15148;
  int D.15149;
  int D.15150;
  unsigned int D.15151;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

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

        D.15149 = i + -1;
        mono_metadata_decode_row (t, D.15149, &cols, 2);
        D.15150 = i | 721420288;
        token = (guint32) D.15150;
        method = get_method (m, token, 0B);
        D.15151 = cols[1];
        sig = get_method_type_param (m, D.15151, 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.14528>:
      D.15147 = t->rows;
      D.15148 = (int) D.15147;
      if (D.15148 >= i) goto <D.14527>; else goto <D.14529>;
      <D.14529>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_parconstraint (struct MonoImage * m)
{
  struct FILE * output.84;
  <unnamed-unsigned:24> D.15153;
  int D.15154;
  int D.15155;
  unsigned int D.15156;
  unsigned int D.15157;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

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

        D.15155 = i + -1;
        mono_metadata_decode_row (t, D.15155, &cols, 2);
        D.15156 = cols[1];
        sig = monoeg_g_strdup_printf ("%x", D.15156);
        output.84 = output;
        D.15157 = cols[0];
        fprintf (output.84, "%d: gen-par=%d, Constraint=%s\n", i, D.15157, sig);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.14538>:
      D.15153 = t->rows;
      D.15154 = (int) D.15153;
      if (D.15154 >= i) goto <D.14537>; else goto <D.14539>;
      <D.14539>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_stream_blob (struct MonoImage * m)
{
  struct FILE * output.85;
  unsigned int i.86;
  unsigned int D.15162;
  unsigned int D.15166;
  const char * D.15169;
  sizetype i.87;
  const char * D.15171;
  char D.15172;
  int D.15173;
  int D.15174;
  unsigned int i.88;
  unsigned int D.15176;
  int i;

  output.85 = output;
  fprintf (output.85, "Blob heap contents\n");
  i = 0;
  goto <D.14545>;
  <D.14544>:
  if (i > 0) goto <D.15159>; else goto <D.15160>;
  <D.15159>:
  i.86 = (unsigned int) i;
  D.15162 = i.86 & 15;
  if (D.15162 == 0) goto <D.15163>; else goto <D.15164>;
  <D.15163>:
  output.85 = output;
  fprintf (output.85, "\n");
  goto <D.15165>;
  <D.15164>:
  i.86 = (unsigned int) i;
  D.15166 = i.86 & 7;
  if (D.15166 == 0) goto <D.15167>; else goto <D.15168>;
  <D.15167>:
  output.85 = output;
  fprintf (output.85, "- ");
  <D.15168>:
  <D.15165>:
  <D.15160>:
  output.85 = output;
  D.15169 = m->heap_blob.data;
  i.87 = (sizetype) i;
  D.15171 = D.15169 + i.87;
  D.15172 = *D.15171;
  D.15173 = (int) D.15172;
  D.15174 = D.15173 & 255;
  fprintf (output.85, "%02x ", D.15174);
  i = i + 1;
  <D.14545>:
  i.88 = (unsigned int) i;
  D.15176 = m->heap_blob.size;
  if (i.88 < D.15176) goto <D.14544>; else goto <D.14546>;
  <D.14546>:
  output.85 = output;
  fprintf (output.85, "\n");
}


dump_stream_strings (struct MonoImage * m)
{
  struct FILE * output.89;
  unsigned int D.15178;
  unsigned int D.15179;
  unsigned int D.15180;
  guint32 i;

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

    str = mono_metadata_string_heap (m, i);
    output.89 = output;
    fprintf (output.89, "%02x: \"%s\"\n", i, str);
    D.15178 = strlen (str);
    D.15179 = D.15178 + i;
    i = D.15179 + 1;
  }
  <D.14553>:
  D.15180 = m->heap_strings.size;
  if (D.15180 > i) goto <D.14552>; else goto <D.14554>;
  <D.14554>:
}


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

  output.90 = output;
  fprintf (output.90, "User Strings heap contents\n");
  i = 0;
  goto <D.14563>;
  <D.14562>:
  {
    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.15184 = mono_metadata_decode_blob_size (us_ptr.92, &us_ptr);
        len = (int) D.15184;
        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.15186 = len.93 + i;
        i = D.15186 + 1;
      }
    finally
      {
        us_ptr = {CLOBBER};
      }
  }
  <D.14563>:
  D.15187 = m->heap_us.size;
  if (D.15187 > i) goto <D.14562>; else goto <D.14564>;
  <D.14564>:
}


dump_table_standalonesig (struct MonoImage * m)
{
  struct FILE * output.94;
  <unnamed-unsigned:24> D.15189;
  int D.15190;
  int D.15191;
  unsigned int D.15192;
  const char * locals_ptr.95;
  const char * locals_ptr.96;
  unsigned int D.15195;
  sizetype j.97;
  const char * D.15197;
  char D.15198;
  int D.15199;
  int D.15200;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

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

        try
          {
            D.15191 = i + -1;
            mono_metadata_decode_row (t, D.15191, &cols, 1);
            D.15192 = cols[0];
            locals_ptr.95 = mono_metadata_blob_heap (m, D.15192);
            locals_ptr = locals_ptr.95;
            locals_ptr.96 = locals_ptr;
            D.15195 = mono_metadata_decode_blob_size (locals_ptr.96, &locals_ptr);
            bsize = (int) D.15195;
            output.94 = output;
            D.15192 = cols[0];
            fprintf (output.94, "%d: blob[0x%x] = ", i, D.15192);
            j = 0;
            goto <D.14575>;
            <D.14574>:
            output.94 = output;
            locals_ptr.96 = locals_ptr;
            j.97 = (sizetype) j;
            D.15197 = locals_ptr.96 + j.97;
            D.15198 = *D.15197;
            D.15199 = (int) D.15198;
            D.15200 = D.15199 & 255;
            fprintf (output.94, "%02x ", D.15200);
            j = j + 1;
            <D.14575>:
            if (j < bsize) goto <D.14574>; else goto <D.14576>;
            <D.14576>:
            output.94 = output;
            fprintf (output.94, "\n");
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14578>:
      D.15189 = t->rows;
      D.15190 = (int) D.15189;
      if (D.15190 >= i) goto <D.14577>; else goto <D.14579>;
      <D.14579>:
    }
  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)
{
  struct FILE * output.98;
  <unnamed-unsigned:24> D.15202;
  int D.15203;
  int D.15204;
  unsigned int D.15205;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

  try
    {
      t = &m->tables[table];
      output.98 = output;
      D.15202 = t->rows;
      D.15203 = (int) D.15202;
      fprintf (output.98, "%s (1..%d)\n", name, D.15203);
      i = 1;
      goto <D.14589>;
      <D.14588>:
      D.15204 = i + -1;
      mono_metadata_decode_row (t, D.15204, &cols, 1);
      output.98 = output;
      D.15205 = cols[0];
      fprintf (output.98, "%d: %d\n", i, D.15205);
      i = i + 1;
      <D.14589>:
      D.15202 = t->rows;
      D.15203 = (int) D.15202;
      if (D.15203 >= i) goto <D.14588>; else goto <D.14590>;
      <D.14590>:
    }
  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");
}