dump_table_assembly (struct MonoImage * m)
{
  struct FILE * output.0;
  long unsigned int D.15461;
  long unsigned int D.15462;
  unsigned int D.15465;
  const char * D.15466;
  unsigned int D.15467;
  unsigned int D.15468;
  unsigned int D.15469;
  unsigned int D.15470;
  unsigned int D.15471;
  unsigned int D.15472;
  unsigned int D.15473;
  const char * ptr.1;
  const char * ptr.2;
  unsigned int D.15476;
  unsigned int D.15480;
  const char * D.15481;
  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.15461 = BIT_FIELD_REF <*t, 64, 64>;
      D.15462 = D.15461 & 16777215;
      if (D.15462 == 0) goto <D.15463>; else goto <D.15464>;
      <D.15463>:
      return;
      <D.15464>:
      mono_metadata_decode_row (t, 0, &cols, 9);
      output.0 = output;
      D.15465 = cols[7];
      D.15466 = mono_metadata_string_heap (m, D.15465);
      fprintf (output.0, "Name:          %s\n", D.15466);
      output.0 = output;
      D.15467 = cols[0];
      fprintf (output.0, "Hash Algoritm: 0x%08x\n", D.15467);
      output.0 = output;
      D.15468 = cols[1];
      D.15469 = cols[2];
      D.15470 = cols[3];
      D.15471 = cols[4];
      fprintf (output.0, "Version:       %d.%d.%d.%d\n", D.15468, D.15469, D.15470, D.15471);
      output.0 = output;
      D.15472 = cols[5];
      fprintf (output.0, "Flags:         0x%08x\n", D.15472);
      output.0 = output;
      D.15473 = cols[6];
      fprintf (output.0, "PublicKey:     BlobPtr (0x%08x)\n", D.15473);
      D.15473 = cols[6];
      ptr.1 = mono_metadata_blob_heap (m, D.15473);
      ptr = ptr.1;
      ptr.2 = ptr;
      D.15476 = mono_metadata_decode_value (ptr.2, &ptr);
      len = (int) D.15476;
      if (len > 0) goto <D.15477>; else goto <D.15478>;
      <D.15477>:
      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.15479>;
      <D.15478>:
      output.0 = output;
      fprintf (output.0, "\tZero sized public key\n");
      <D.15479>:
      output.0 = output;
      D.15480 = cols[8];
      D.15481 = mono_metadata_string_heap (m, D.15480);
      fprintf (output.0, "Culture:       %s\n", D.15481);
      output.0 = output;
      fprintf (output.0, "\n");
    }
  finally
    {
      cols = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

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


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

  t = &m->tables[1];
  output.3 = output;
  fprintf (output.3, "Typeref Table\n");
  i = 1;
  goto <D.14897>;
  <D.14896>:
  {
    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.14897>:
  D.15488 = t->rows;
  D.15489 = (int) D.15488;
  if (D.15489 >= i) goto <D.14896>; else goto <D.14898>;
  <D.14898>:
  output.3 = output;
  fprintf (output.3, "\n");
}


dump_table_typedef (struct MonoImage * m)
{
  struct FILE * output.4;
  struct MonoTableInfo * D.15491;
  int D.15492;
  unsigned int D.15493;
  unsigned int D.15494;
  unsigned int D.15495;
  unsigned int D.15496;
  <unnamed-unsigned:24> D.15497;
  int D.15498;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        s = get_typedef (m, i);
        D.15491 = &m->tables[2];
        D.15492 = i + -1;
        mono_metadata_decode_row (D.15491, D.15492, &cols, 6);
        output.4 = output;
        D.15493 = cols[4];
        D.15494 = cols[5];
        D.15495 = cols[0];
        D.15496 = cols[3];
        fprintf (output.4, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i, s, D.15493, D.15494, D.15495, D.15496);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14907>:
  D.15497 = t->rows;
  D.15498 = (int) D.15497;
  if (D.15498 >= i) goto <D.14906>; else goto <D.14908>;
  <D.14908>:
  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.15501;
  int D.15502;
  struct MonoTableInfo * t;
  int i;

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


dump_table_assemblyref (struct MonoImage * m)
{
  struct FILE * output.7;
  int D.15504;
  unsigned int D.15505;
  unsigned int D.15506;
  unsigned int D.15507;
  unsigned int D.15508;
  unsigned int D.15509;
  const char * D.15510;
  unsigned int D.15511;
  unsigned int D.15512;
  const char * ptr.8;
  const char * ptr.9;
  unsigned int D.15515;
  <unnamed-unsigned:24> D.15519;
  int D.15520;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        output.7 = output;
        D.15504 = i + 1;
        D.15505 = cols[0];
        D.15506 = cols[1];
        D.15507 = cols[2];
        D.15508 = cols[3];
        D.15509 = cols[6];
        D.15510 = mono_metadata_string_heap (m, D.15509);
        fprintf (output.7, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", D.15504, D.15505, D.15506, D.15507, D.15508, D.15510);
        output.7 = output;
        D.15511 = cols[4];
        fprintf (output.7, "\tFlags=0x%08x\n", D.15511);
        D.15512 = cols[5];
        ptr.8 = mono_metadata_blob_heap (m, D.15512);
        ptr = ptr.8;
        ptr.9 = ptr;
        D.15515 = mono_metadata_decode_value (ptr.9, &ptr);
        len = (int) D.15515;
        if (len > 0) goto <D.15516>; else goto <D.15517>;
        <D.15516>:
        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.15518>;
        <D.15517>:
        output.7 = output;
        fprintf (output.7, "\tZero sized public key\n");
        <D.15518>:
      }
    finally
      {
        ptr = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14927>:
  D.15519 = t->rows;
  D.15520 = (int) D.15519;
  if (D.15520 > i) goto <D.14926>; else goto <D.14928>;
  <D.14928>:
  output.7 = output;
  fprintf (output.7, "\n");
}


dump_table_param (struct MonoImage * m)
{
  struct FILE * output.10;
  int D.15522;
  unsigned int D.15523;
  unsigned int D.15524;
  unsigned int D.15525;
  const char * D.15526;
  <unnamed-unsigned:24> D.15527;
  int D.15528;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        output.10 = output;
        D.15522 = i + 1;
        D.15523 = cols[0];
        D.15524 = cols[1];
        D.15525 = cols[2];
        D.15526 = mono_metadata_string_heap (m, D.15525);
        fprintf (output.10, "%d: 0x%04x %d %s\n", D.15522, D.15523, D.15524, D.15526);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14936>:
  D.15527 = t->rows;
  D.15528 = (int) D.15527;
  if (D.15528 > i) goto <D.14935>; else goto <D.14937>;
  <D.14937>:
  output.10 = output;
  fprintf (output.10, "\n");
}


dump_table_field (struct MonoImage * m)
{
  struct FILE * output.11;
  <unnamed-unsigned:24> D.15530;
  int D.15531;
  <unnamed-unsigned:24> D.15532;
  int D.15533;
  unsigned int i.12;
  int D.15536;
  int D.15539;
  unsigned int D.15540;
  const char * D.15541;
  unsigned int D.15542;
  const char * D.15543;
  int D.15544;
  unsigned int D.15545;
  unsigned int D.15546;
  unsigned int D.15547;
  const char * D.15548;
  <unnamed-unsigned:24> D.15549;
  int D.15550;
  int D.15553;
  unsigned int D.15554;
  unsigned int i.13;
  unsigned int D.15558;
  <unnamed-unsigned:24> D.15559;
  int D.15560;
  int D.15563;
  unsigned int D.15564;
  unsigned int D.15567;
  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.15530 = t->rows;
  D.15531 = (int) D.15530;
  fprintf (output.11, "Field Table (1..%d)\n", D.15531);
  current_type = 1;
  offset_row = current_type;
  rva_row = offset_row;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.14958>;
  <D.14957>:
  {
    guint32 cols[3];
    char * sig;
    char * flags;

    try
      {
        goto <D.14955>;
        <D.14954>:
        current_type = current_type + 1;
        <D.14955>:
        D.15532 = td->rows;
        D.15533 = (int) D.15532;
        if (D.15533 >= current_type) goto <D.15534>; else goto <D.14956>;
        <D.15534>:
        i.12 = (unsigned int) i;
        D.15536 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.15536, 4);
        if (i.12 >= last_m) goto <D.14954>; else goto <D.14956>;
        <D.14956>:
        i.12 = (unsigned int) i;
        if (i.12 == first_m) goto <D.15537>; else goto <D.15538>;
        <D.15537>:
        output.11 = output;
        D.15539 = current_type + -2;
        D.15540 = mono_metadata_decode_row_col (td, D.15539, 2);
        D.15541 = mono_metadata_string_heap (m, D.15540);
        D.15539 = current_type + -2;
        D.15542 = mono_metadata_decode_row_col (td, D.15539, 1);
        D.15543 = mono_metadata_string_heap (m, D.15542);
        fprintf (output.11, "########## %s.%s\n", D.15541, D.15543);
        first_m = last_m;
        <D.15538>:
        D.15544 = i + -1;
        mono_metadata_decode_row (t, D.15544, &cols, 3);
        D.15545 = cols[2];
        sig = get_field_signature (m, D.15545, 0B);
        D.15546 = cols[0];
        flags = field_flags (D.15546);
        output.11 = output;
        D.15547 = cols[1];
        D.15548 = mono_metadata_string_heap (m, D.15547);
        fprintf (output.11, "%d: %s %s: %s\n", i, sig, D.15548, flags);
        monoeg_g_free (sig);
        monoeg_g_free (flags);
        D.15549 = fl->rows;
        D.15550 = (int) D.15549;
        if (D.15550 >= offset_row) goto <D.15551>; else goto <D.15552>;
        <D.15551>:
        D.15553 = offset_row + -1;
        D.15554 = mono_metadata_decode_row_col (fl, D.15553, 1);
        i.13 = (unsigned int) i;
        if (D.15554 == i.13) goto <D.15556>; else goto <D.15557>;
        <D.15556>:
        output.11 = output;
        D.15553 = offset_row + -1;
        D.15558 = mono_metadata_decode_row_col (fl, D.15553, 0);
        fprintf (output.11, "\texplicit offset: %d\n", D.15558);
        offset_row = offset_row + 1;
        <D.15557>:
        <D.15552>:
        D.15559 = rva->rows;
        D.15560 = (int) D.15559;
        if (D.15560 >= rva_row) goto <D.15561>; else goto <D.15562>;
        <D.15561>:
        D.15563 = rva_row + -1;
        D.15564 = mono_metadata_decode_row_col (rva, D.15563, 1);
        i.13 = (unsigned int) i;
        if (D.15564 == i.13) goto <D.15565>; else goto <D.15566>;
        <D.15565>:
        output.11 = output;
        D.15563 = rva_row + -1;
        D.15567 = mono_metadata_decode_row_col (rva, D.15563, 0);
        fprintf (output.11, "\trva: %d\n", D.15567);
        rva_row = rva_row + 1;
        <D.15566>:
        <D.15562>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14958>:
  D.15530 = t->rows;
  D.15531 = (int) D.15530;
  if (D.15531 >= i) goto <D.14957>; else goto <D.14959>;
  <D.14959>:
  output.11 = output;
  fprintf (output.11, "\n");
}


dump_table_memberref (struct MonoImage * m)
{
  struct FILE * output.14;
  <unnamed-unsigned:24> D.15569;
  int D.15570;
  unsigned int D.15571;
  int D.15572;
  unsigned int D.15573;
  unsigned int D.15574;
  const char * D.15575;
  const char * D.15576;
  unsigned int idx.15;
  const char * D.15578;
  unsigned int D.15579;
  const char * blob.16;
  const char * blob.17;
  char D.15582;
  int D.15586;
  const char * D.15587;
  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.15569 = t->rows;
      D.15570 = (int) D.15569;
      fprintf (output.14, "MemberRef Table (1..%d)\n", D.15570);
      i = 0;
      goto <D.14982>;
      <D.14981>:
      {
        guint32 cols[3];

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            D.15571 = cols[0];
            D.15572 = (int) D.15571;
            kind = D.15572 & 7;
            D.15571 = cols[0];
            D.15573 = D.15571 >> 3;
            idx = (int) D.15573;
            x = monoeg_strdup ("UNHANDLED CASE");
            switch (kind) <default: <D.14979>, case 0: <D.14973>, case 1: <D.14975>, case 2: <D.14976>, case 3: <D.14977>, case 4: <D.14978>>
            <D.14973>:
            ks = "TypeDef";
            xx = get_typedef (m, idx);
            D.15574 = cols[1];
            D.15575 = mono_metadata_string_heap (m, D.15574);
            x = monoeg_g_strconcat (xx, ".", D.15575, 0B);
            monoeg_g_free (xx);
            goto <D.14974>;
            <D.14975>:
            ks = "TypeRef";
            xx = get_typeref (m, idx);
            D.15574 = cols[1];
            D.15576 = mono_metadata_string_heap (m, D.15574);
            x = monoeg_g_strconcat (xx, ".", D.15576, 0B);
            monoeg_g_free (xx);
            goto <D.14974>;
            <D.14976>:
            ks = "ModuleRef";
            goto <D.14974>;
            <D.14977>:
            ks = "MethodDef";
            idx.15 = (unsigned int) idx;
            x = get_methoddef (m, idx.15);
            goto <D.14974>;
            <D.14978>:
            ks = "TypeSpec";
            idx.15 = (unsigned int) idx;
            xx = get_typespec (m, idx.15, 0, 0B);
            D.15574 = cols[1];
            D.15578 = mono_metadata_string_heap (m, D.15574);
            x = monoeg_g_strconcat (xx, ".", D.15578, 0B);
            monoeg_g_free (xx);
            goto <D.14974>;
            <D.14979>:
            monoeg_g_log (0B, 4, "Unknown tag: %d\n", kind);
            <D.14980>:
            goto <D.14980>;
            <D.14974>:
            D.15579 = cols[2];
            blob.16 = mono_metadata_blob_heap (m, D.15579);
            blob = blob.16;
            blob.17 = blob;
            mono_metadata_decode_blob_size (blob.17, &blob);
            blob.17 = blob;
            D.15582 = *blob.17;
            if (D.15582 == 6) goto <D.15583>; else goto <D.15584>;
            <D.15583>:
            D.15579 = cols[2];
            sig = get_field_signature (m, D.15579, 0B);
            goto <D.15585>;
            <D.15584>:
            D.15579 = cols[2];
            sig = get_methodref_signature (m, D.15579, 0B);
            <D.15585>:
            output.14 = output;
            D.15586 = i + 1;
            D.15574 = cols[1];
            D.15587 = mono_metadata_string_heap (m, D.15574);
            if (x != 0B) goto <D.15589>; else goto <D.15590>;
            <D.15589>:
            iftmp.18 = x;
            goto <D.15591>;
            <D.15590>:
            iftmp.18 = "";
            <D.15591>:
            fprintf (output.14, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n", D.15586, ks, idx, D.15587, iftmp.18, sig);
            if (x != 0B) goto <D.15592>; else goto <D.15593>;
            <D.15592>:
            monoeg_g_free (x);
            <D.15593>:
            monoeg_g_free (sig);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.14982>:
      D.15569 = t->rows;
      D.15570 = (int) D.15569;
      if (D.15570 > i) goto <D.14981>; else goto <D.14983>;
      <D.14983>:
    }
  finally
    {
      blob = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.15594>; else goto <D.15595>;
  <D.15594>:
  D.15596 = __strdup (str);
  return D.15596;
  <D.15595>:
  D.15596 = 0B;
  return D.15596;
}


dump_table_class_layout (struct MonoImage * m)
{
  struct FILE * output.19;
  <unnamed-unsigned:24> D.15599;
  int D.15600;
  int D.15601;
  unsigned int D.15602;
  unsigned int D.15603;
  unsigned int D.15604;
  int D.15605;
  char * D.15606;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        output.19 = output;
        D.15601 = i + 1;
        D.15602 = cols[0];
        D.15603 = cols[1];
        D.15604 = cols[2];
        D.15605 = (int) D.15604;
        D.15606 = get_typedef (m, D.15605);
        fprintf (output.19, "%d: PackingSize=%d  ClassSize=%d  Parent=%s\n", D.15601, D.15602, D.15603, D.15606);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.14991>:
  D.15599 = t->rows;
  D.15600 = (int) D.15599;
  if (D.15600 > i) goto <D.14990>; else goto <D.14992>;
  <D.14992>:
}


dump_table_constant (struct MonoImage * m)
{
  struct FILE * output.20;
  <unnamed-unsigned:24> D.15613;
  int D.15614;
  unsigned int D.15615;
  unsigned int D.15616;
  int D.15617;
  unsigned int D.15618;
  unsigned int D.15619;
  unsigned int D.15620;
  char * D.15621;
  struct MonoTableInfo * t;
  int i;
  const char * desc[4];

  try
    {
      t = &m->tables[11];
      desc = *.LC4;
      output.20 = output;
      D.15613 = t->rows;
      D.15614 = (int) D.15613;
      fprintf (output.20, "Constant Table (1..%d)\n", D.15614);
      i = 0;
      goto <D.15002>;
      <D.15001>:
      {
        guint32 cols[4];
        const char * parent;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 4);
            D.15615 = cols[2];
            D.15616 = D.15615 & 3;
            parent = desc[D.15616];
            output.20 = output;
            D.15617 = i + 1;
            D.15615 = cols[2];
            D.15618 = D.15615 >> 2;
            D.15619 = cols[0];
            D.15620 = cols[3];
            D.15621 = get_constant (m, D.15619, D.15620);
            fprintf (output.20, "%d: Parent= %s: %d %s\n", D.15617, parent, D.15618, D.15621);
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      i = i + 1;
      <D.15002>:
      D.15613 = t->rows;
      D.15614 = (int) D.15613;
      if (D.15614 > i) goto <D.15001>; else goto <D.15003>;
      <D.15003>:
    }
  finally
    {
      desc = {CLOBBER};
    }
}


dump_table_property_map (struct MonoImage * m)
{
  struct FILE * output.21;
  <unnamed-unsigned:24> D.15623;
  int D.15624;
  unsigned int D.15625;
  int D.15626;
  int D.15627;
  unsigned int D.15628;
  struct MonoTableInfo * t;
  int i;
  char * s;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 2);
        D.15625 = cols[0];
        D.15626 = (int) D.15625;
        s = get_typedef (m, D.15626);
        output.21 = output;
        D.15627 = i + 1;
        D.15625 = cols[0];
        D.15628 = cols[1];
        fprintf (output.21, "%d: %s (%d) %d\n", D.15627, s, D.15625, D.15628);
        monoeg_g_free (s);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15012>:
  D.15623 = t->rows;
  D.15624 = (int) D.15623;
  if (D.15624 > i) goto <D.15011>; else goto <D.15013>;
  <D.15013>:
}


dump_table_property (struct MonoImage * m)
{
  struct FILE * output.22;
  <unnamed-unsigned:24> D.15630;
  int D.15631;
  unsigned int D.15632;
  int D.15633;
  int D.15636;
  int D.15639;
  unsigned int D.15642;
  const char * ptr.23;
  const char * ptr.24;
  unsigned int D.15645;
  char D.15646;
  int D.15651;
  const char * ptr.25;
  unsigned int D.15653;
  const char * ptr.26;
  int D.15655;
  char * type.27;
  unsigned int D.15657;
  const char * D.15658;
  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.15630 = t->rows;
      D.15631 = (int) D.15630;
      fprintf (output.22, "Property Table (1..%d)\n", D.15631);
      i = 0;
      goto <D.15031>;
      <D.15030>:
      {
        guint32 cols[3];
        char * type;
        int bsize;
        int prop_flags;

        try
          {
            mono_metadata_decode_row (t, i, &cols, 3);
            flags[0] = 0;
            D.15632 = cols[0];
            prop_flags = (int) D.15632;
            D.15633 = prop_flags & 512;
            if (D.15633 != 0) goto <D.15634>; else goto <D.15635>;
            <D.15634>:
            strcat (&flags, "special ");
            <D.15635>:
            D.15636 = prop_flags & 1024;
            if (D.15636 != 0) goto <D.15637>; else goto <D.15638>;
            <D.15637>:
            strcat (&flags, "runtime ");
            <D.15638>:
            D.15639 = prop_flags & 4096;
            if (D.15639 != 0) goto <D.15640>; else goto <D.15641>;
            <D.15640>:
            strcat (&flags, "hasdefault ");
            <D.15641>:
            D.15642 = cols[2];
            ptr.23 = mono_metadata_blob_heap (m, D.15642);
            ptr = ptr.23;
            ptr.24 = ptr;
            D.15645 = mono_metadata_decode_blob_size (ptr.24, &ptr);
            bsize = (int) D.15645;
            ptr.24 = ptr;
            D.15646 = *ptr.24;
            if (D.15646 != 40) goto <D.15647>; else goto <D.15648>;
            <D.15647>:
            ptr.24 = ptr;
            D.15646 = *ptr.24;
            if (D.15646 != 8) goto <D.15649>; else goto <D.15650>;
            <D.15649>:
            ptr.24 = ptr;
            D.15646 = *ptr.24;
            D.15651 = (int) D.15646;
            monoeg_g_log (0B, 16, "incorrect signature in propert blob: 0x%x", D.15651);
            <D.15650>:
            <D.15648>:
            ptr.24 = ptr;
            ptr.25 = ptr.24 + 1;
            ptr = ptr.25;
            ptr.24 = ptr;
            D.15653 = mono_metadata_decode_value (ptr.24, &ptr);
            pcount = (int) D.15653;
            ptr.24 = ptr;
            ptr.26 = get_type (m, ptr.24, &type, 0, 0B);
            ptr = ptr.26;
            output.22 = output;
            D.15655 = i + 1;
            type.27 = type;
            D.15657 = cols[1];
            D.15658 = mono_metadata_string_heap (m, D.15657);
            fprintf (output.22, "%d: %s %s (", D.15655, type.27, D.15658);
            type.27 = type;
            monoeg_g_free (type.27);
            j = 0;
            goto <D.15028>;
            <D.15027>:
            ptr.24 = ptr;
            ptr.28 = get_param (m, ptr.24, &type, 0B);
            ptr = ptr.28;
            output.22 = output;
            if (j > 0) goto <D.15661>; else goto <D.15662>;
            <D.15661>:
            iftmp.29 = ", ";
            goto <D.15663>;
            <D.15662>:
            iftmp.29 = "";
            <D.15663>:
            type.27 = type;
            fprintf (output.22, "%s%s", iftmp.29, type.27);
            type.27 = type;
            monoeg_g_free (type.27);
            j = j + 1;
            <D.15028>:
            if (j < pcount) goto <D.15027>; else goto <D.15029>;
            <D.15029>:
            output.22 = output;
            fprintf (output.22, ") %s\n", &flags);
          }
        finally
          {
            cols = {CLOBBER};
            type = {CLOBBER};
          }
      }
      i = i + 1;
      <D.15031>:
      D.15630 = t->rows;
      D.15631 = (int) D.15630;
      if (D.15631 > i) goto <D.15030>; else goto <D.15032>;
      <D.15032>:
    }
  finally
    {
      ptr = {CLOBBER};
      flags = {CLOBBER};
    }
}


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

  D.15665 = __builtin_object_size (__dest, 1);
  D.15664 = __builtin___strcat_chk (__dest, __src, D.15665);
  return D.15664;
}


dump_table_event (struct MonoImage * m)
{
  struct FILE * output.30;
  <unnamed-unsigned:24> D.15668;
  int D.15669;
  unsigned int D.15670;
  unsigned int D.15671;
  int D.15672;
  const char * iftmp.31;
  unsigned int D.15674;
  unsigned int D.15675;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15670 = cols[1];
        name = mono_metadata_string_heap (m, D.15670);
        D.15671 = cols[2];
        type = get_typedef_or_ref (m, D.15671, 0B);
        output.30 = output;
        D.15672 = i + 1;
        D.15674 = cols[0];
        D.15675 = D.15674 & 512;
        if (D.15675 != 0) goto <D.15676>; else goto <D.15677>;
        <D.15676>:
        iftmp.31 = "specialname ";
        goto <D.15678>;
        <D.15677>:
        iftmp.31 = "";
        <D.15678>:
        fprintf (output.30, "%d: %s %s %s\n", D.15672, type, name, iftmp.31);
        monoeg_g_free (type);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15042>:
  D.15668 = t->rows;
  D.15669 = (int) D.15668;
  if (D.15669 > i) goto <D.15041>; else goto <D.15043>;
  <D.15043>:
}


dump_table_file (struct MonoImage * m)
{
  struct FILE * output.32;
  <unnamed-unsigned:24> D.15680;
  int D.15681;
  unsigned int D.15682;
  int D.15683;
  const char * iftmp.33;
  unsigned int D.15685;
  unsigned int D.15686;
  unsigned int D.15690;
  const char * hash.34;
  const char * hash.35;
  unsigned int D.15693;
  const char * iftmp.36;
  sizetype D.15698;
  const char * D.15699;
  char D.15700;
  int D.15701;
  struct MonoTableInfo * t;
  int i;
  int j;
  int len;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 3);
        D.15682 = cols[1];
        name = mono_metadata_string_heap (m, D.15682);
        output.32 = output;
        D.15683 = i + 1;
        D.15685 = cols[0];
        D.15686 = D.15685 & 1;
        if (D.15686 != 0) goto <D.15687>; else goto <D.15688>;
        <D.15687>:
        iftmp.33 = "nometadata";
        goto <D.15689>;
        <D.15688>:
        iftmp.33 = "containsmetadata";
        <D.15689>:
        fprintf (output.32, "%d: %s %s [", D.15683, name, iftmp.33);
        D.15690 = cols[2];
        hash.34 = mono_metadata_blob_heap (m, D.15690);
        hash = hash.34;
        hash.35 = hash;
        D.15693 = mono_metadata_decode_blob_size (hash.35, &hash);
        len = (int) D.15693;
        j = 0;
        goto <D.15055>;
        <D.15054>:
        output.32 = output;
        if (j != 0) goto <D.15695>; else goto <D.15696>;
        <D.15695>:
        iftmp.36 = " ";
        goto <D.15697>;
        <D.15696>:
        iftmp.36 = "";
        <D.15697>:
        hash.35 = hash;
        D.15698 = (sizetype) j;
        D.15699 = hash.35 + D.15698;
        D.15700 = *D.15699;
        D.15701 = (int) D.15700;
        fprintf (output.32, "%s%02X", iftmp.36, D.15701);
        j = j + 1;
        <D.15055>:
        if (j < len) goto <D.15054>; else goto <D.15056>;
        <D.15056>:
        output.32 = output;
        fprintf (output.32, "]\n");
      }
    finally
      {
        cols = {CLOBBER};
        hash = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15058>:
  D.15680 = t->rows;
  D.15681 = (int) D.15680;
  if (D.15681 > i) goto <D.15057>; else goto <D.15059>;
  <D.15059>:
}


dump_table_manifest (struct MonoImage * m)
{
  struct FILE * output.37;
  <unnamed-unsigned:24> D.15703;
  int D.15704;
  unsigned int D.15705;
  unsigned int D.15706;
  unsigned int D.15707;
  int D.15708;
  unsigned int D.15709;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 4);
        D.15705 = cols[2];
        name = mono_metadata_string_heap (m, D.15705);
        D.15706 = cols[1];
        mf = get_manifest_flags (D.15706);
        D.15707 = cols[3];
        impl = get_manifest_implementation (m, D.15707);
        output.37 = output;
        D.15708 = i + 1;
        D.15709 = cols[0];
        fprintf (output.37, "%d: %s \'%s\' at offset %u in %s\n", D.15708, mf, name, D.15709, impl);
        monoeg_g_free (impl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15087>:
  D.15703 = t->rows;
  D.15704 = (int) D.15703;
  if (D.15704 > i) goto <D.15086>; else goto <D.15088>;
  <D.15088>:
}


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

  mf = mf & 3;
  switch (mf) <default: <D.15076>, case 1: <D.15074>, case 2: <D.15075>>
  <D.15074>:
  D.15710 = "public";
  return D.15710;
  <D.15075>:
  D.15710 = "private";
  return D.15710;
  <D.15076>:
  D.15710 = "";
  return D.15710;
}


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

  table = "";
  if (idx == 0) goto <D.15712>; else goto <D.15713>;
  <D.15712>:
  D.15714 = monoeg_strdup ("current module");
  return D.15714;
  <D.15713>:
  row = idx >> 2;
  D.15715 = idx & 3;
  switch (D.15715) <default: <D.15070>, case 0: <D.15066>, case 1: <D.15068>, case 2: <D.15069>>
  <D.15066>:
  table = "file";
  goto <D.15067>;
  <D.15068>:
  table = "assemblyref";
  goto <D.15067>;
  <D.15069>:
  table = "exportedtype";
  goto <D.15067>;
  <D.15070>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dump.c", 475);
  <D.15067>:
  D.15714 = monoeg_g_strdup_printf ("%s %d", table, row);
  return D.15714;
}


dump_table_moduleref (struct MonoImage * m)
{
  struct FILE * output.38;
  <unnamed-unsigned:24> D.15718;
  int D.15719;
  unsigned int D.15720;
  int D.15721;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 1);
        D.15720 = cols[0];
        name = mono_metadata_string_heap (m, D.15720);
        output.38 = output;
        D.15721 = i + 1;
        fprintf (output.38, "%d: %s\n", D.15721, name);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15097>:
  D.15718 = t->rows;
  D.15719 = (int) D.15718;
  if (D.15719 > i) goto <D.15096>; else goto <D.15098>;
  <D.15098>:
}


dump_table_module (struct MonoImage * m)
{
  struct FILE * output.39;
  <unnamed-unsigned:24> D.15723;
  int D.15724;
  unsigned int D.15725;
  unsigned int D.15726;
  int D.15727;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        mono_metadata_decode_row (t, i, &cols, 5);
        D.15725 = cols[1];
        name = mono_metadata_string_heap (m, D.15725);
        D.15726 = cols[2];
        guid = get_guid (m, D.15726);
        output.39 = output;
        D.15727 = i + 1;
        D.15726 = cols[2];
        fprintf (output.39, "%d: %s %d %s\n", D.15727, name, D.15726, guid);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15108>:
  D.15723 = t->rows;
  D.15724 = (int) D.15723;
  if (D.15724 > i) goto <D.15107>; else goto <D.15109>;
  <D.15109>:
}


dump_table_method (struct MonoImage * m)
{
  struct FILE * output.40;
  <unnamed-unsigned:24> D.15729;
  int D.15730;
  <unnamed-unsigned:24> D.15731;
  int D.15732;
  unsigned int i.41;
  int D.15735;
  int D.15738;
  unsigned int D.15739;
  const char * D.15740;
  unsigned int D.15741;
  const char * D.15742;
  int D.15743;
  unsigned int D.15744;
  int D.15747;
  unsigned int D.15748;
  int D.15751;
  unsigned int D.15752;
  const char * sigblob.42;
  const char * sigblob.43;
  struct MonoGenericContainer * iftmp.44;
  struct MonoGenericContainer * iftmp.45;
  unsigned int D.15763;
  unsigned int D.15764;
  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.40 = output;
  D.15729 = t->rows;
  D.15730 = (int) D.15729;
  fprintf (output.40, "Method Table (1..%d)\n", D.15730);
  current_type = 1;
  first_m = 1;
  last_m = first_m;
  i = 1;
  goto <D.15130>;
  <D.15129>:
  {
    guint32 cols[6];
    char * sig;
    char * impl_flags;
    const char * sigblob;
    struct MonoMethodSignature * method;

    try
      {
        goto <D.15127>;
        <D.15126>:
        current_type = current_type + 1;
        <D.15127>:
        D.15731 = td->rows;
        D.15732 = (int) D.15731;
        if (D.15732 >= current_type) goto <D.15733>; else goto <D.15128>;
        <D.15733>:
        i.41 = (unsigned int) i;
        D.15735 = current_type + -1;
        last_m = mono_metadata_decode_row_col (td, D.15735, 5);
        if (i.41 >= last_m) goto <D.15126>; else goto <D.15128>;
        <D.15128>:
        i.41 = (unsigned int) i;
        if (i.41 == first_m) goto <D.15736>; else goto <D.15737>;
        <D.15736>:
        output.40 = output;
        D.15738 = current_type + -2;
        D.15739 = mono_metadata_decode_row_col (td, D.15738, 2);
        D.15740 = mono_metadata_string_heap (m, D.15739);
        D.15738 = current_type + -2;
        D.15741 = mono_metadata_decode_row_col (td, D.15738, 1);
        D.15742 = mono_metadata_string_heap (m, D.15741);
        fprintf (output.40, "########## %s.%s\n", D.15740, D.15742);
        first_m = last_m;
        D.15735 = current_type + -1;
        D.15743 = D.15735 | 33554432;
        D.15744 = (unsigned int) D.15743;
        type_container = mono_metadata_load_generic_params (m, D.15744, 0B);
        if (type_container != 0B) goto <D.15745>; else goto <D.15746>;
        <D.15745>:
        D.15735 = current_type + -1;
        D.15743 = D.15735 | 33554432;
        D.15744 = (unsigned int) D.15743;
        mono_metadata_load_generic_param_constraints (m, D.15744, type_container);
        <D.15746>:
        <D.15737>:
        D.15747 = i | 100663296;
        D.15748 = (unsigned int) D.15747;
        method_container = mono_metadata_load_generic_params (m, D.15748, type_container);
        if (method_container != 0B) goto <D.15749>; else goto <D.15750>;
        <D.15749>:
        D.15747 = i | 100663296;
        D.15748 = (unsigned int) D.15747;
        mono_metadata_load_generic_param_constraints (m, D.15748, method_container);
        <D.15750>:
        D.15751 = i + -1;
        mono_metadata_decode_table_row (m, 6, D.15751, &cols, 6);
        D.15752 = cols[4];
        sigblob.42 = mono_metadata_blob_heap (m, D.15752);
        sigblob = sigblob.42;
        sigblob.43 = sigblob;
        mono_metadata_decode_blob_size (sigblob.43, &sigblob);
        if (method_container != 0B) goto <D.15756>; else goto <D.15757>;
        <D.15756>:
        iftmp.44 = method_container;
        goto <D.15758>;
        <D.15757>:
        iftmp.44 = type_container;
        <D.15758>:
        sigblob.43 = sigblob;
        method = mono_metadata_parse_method_signature_full (m, iftmp.44, i, sigblob.43, &sigblob);
        if (method_container != 0B) goto <D.15760>; else goto <D.15761>;
        <D.15760>:
        iftmp.45 = method_container;
        goto <D.15762>;
        <D.15761>:
        iftmp.45 = type_container;
        <D.15762>:
        sig = dis_stringify_method_signature (m, method, i, iftmp.45, 0);
        D.15763 = cols[1];
        impl_flags = get_method_impl_flags (D.15763);
        output.40 = output;
        D.15764 = cols[5];
        fprintf (output.40, "%d: %s (param: %d impl_flags: %s)\n", i, sig, D.15764, 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.15130>:
  D.15729 = t->rows;
  D.15730 = (int) D.15729;
  if (D.15730 >= i) goto <D.15129>; else goto <D.15131>;
  <D.15131>:
}


dump_table_implmap (struct MonoImage * m)
{
  struct FILE * output.46;
  <unnamed-unsigned:24> D.15766;
  int D.15767;
  int D.15768;
  unsigned int D.15769;
  unsigned int D.15770;
  unsigned int D.15771;
  unsigned int D.15772;
  unsigned int D.15773;
  const char * D.15774;
  unsigned int D.15775;
  unsigned int D.15776;
  int D.15777;
  unsigned int D.15778;
  const char * D.15779;
  struct MonoTableInfo * t;
  struct MonoTableInfo * td;
  int i;

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

    try
      {
        D.15768 = i + -1;
        mono_metadata_decode_row (t, D.15768, &cols, 4);
        D.15769 = cols[1];
        D.15770 = D.15769 >> 1;
        D.15771 = D.15770 | 100663296;
        method = get_method (m, D.15771, 0B);
        output.46 = output;
        D.15772 = cols[0];
        D.15773 = cols[2];
        D.15774 = mono_metadata_string_heap (m, D.15773);
        D.15775 = cols[3];
        D.15776 = D.15775 + 4294967295;
        D.15777 = (int) D.15776;
        D.15778 = mono_metadata_decode_row_col (td, D.15777, 0);
        D.15779 = mono_metadata_string_heap (m, D.15778);
        fprintf (output.46, "%d: %s %d (%s %s)\n", i, method, D.15772, D.15774, D.15779);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15141>:
  D.15766 = t->rows;
  D.15767 = (int) D.15766;
  if (D.15767 >= i) goto <D.15140>; else goto <D.15142>;
  <D.15142>:
}


dump_table_fieldrva (struct MonoImage * m)
{
  struct FILE * output.47;
  <unnamed-unsigned:24> D.15781;
  int D.15782;
  int D.15783;
  unsigned int D.15784;
  unsigned int D.15785;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15783 = i + -1;
        mono_metadata_decode_row (t, D.15783, &cols, 2);
        output.47 = output;
        D.15784 = cols[1];
        D.15785 = cols[0];
        fprintf (output.47, "%d: Field %d: %x\n", i, D.15784, D.15785);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15150>:
  D.15781 = t->rows;
  D.15782 = (int) D.15781;
  if (D.15782 >= i) goto <D.15149>; else goto <D.15151>;
  <D.15151>:
}


dump_table_methodimpl (struct MonoImage * m)
{
  struct FILE * output.48;
  <unnamed-unsigned:24> D.15787;
  int D.15788;
  int D.15789;
  unsigned int D.15790;
  int D.15791;
  unsigned int D.15792;
  unsigned int D.15793;
  unsigned int D.15794;
  unsigned int D.15795;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15789 = i + -1;
        mono_metadata_decode_row (t, D.15789, &cols, 3);
        D.15790 = cols[0];
        D.15791 = (int) D.15790;
        class = get_typedef (m, D.15791);
        D.15792 = cols[1];
        D.15793 = method_dor_to_token (D.15792);
        impl = get_method (m, D.15793, 0B);
        D.15794 = cols[2];
        D.15795 = method_dor_to_token (D.15794);
        decl = get_method (m, D.15795, 0B);
        output.48 = output;
        fprintf (output.48, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i, class, decl, impl);
        monoeg_g_free (class);
        monoeg_g_free (impl);
        monoeg_g_free (decl);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15162>:
  D.15787 = t->rows;
  D.15788 = (int) D.15787;
  if (D.15788 >= i) goto <D.15161>; else goto <D.15163>;
  <D.15163>:
}


dump_table_methodsem (struct MonoImage * m)
{
  struct FILE * output.49;
  <unnamed-unsigned:24> D.15797;
  int D.15798;
  int D.15799;
  unsigned int D.15800;
  unsigned int D.15801;
  int D.15802;
  unsigned int D.15803;
  unsigned int D.15804;
  unsigned int D.15805;
  const char * iftmp.50;
  struct MonoTableInfo * t;
  int i;
  int is_property;
  int index;
  const char * semantics;

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

    try
      {
        D.15799 = i + -1;
        mono_metadata_decode_row (t, D.15799, &cols, 3);
        D.15800 = cols[0];
        semantics = flags (D.15800, &semantics_map);
        D.15801 = cols[2];
        D.15802 = (int) D.15801;
        is_property = D.15802 & 1;
        D.15801 = cols[2];
        D.15803 = D.15801 >> 1;
        index = (int) D.15803;
        output.49 = output;
        D.15801 = cols[2];
        D.15804 = cols[1];
        D.15805 = D.15804 + 4294967295;
        if (is_property != 0) goto <D.15807>; else goto <D.15808>;
        <D.15807>:
        iftmp.50 = "property";
        goto <D.15809>;
        <D.15808>:
        iftmp.50 = "event";
        <D.15809>:
        fprintf (output.49, "%d: [%d] %s method: %d %s %d\n", i, D.15801, semantics, D.15805, iftmp.50, index);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15175>:
  D.15797 = t->rows;
  D.15798 = (int) D.15797;
  if (D.15798 >= i) goto <D.15174>; else goto <D.15176>;
  <D.15176>:
}


dump_table_interfaceimpl (struct MonoImage * m)
{
  struct FILE * output.51;
  <unnamed-unsigned:24> D.15811;
  int D.15812;
  int D.15813;
  unsigned int D.15814;
  int D.15815;
  char * D.15816;
  unsigned int D.15817;
  char * D.15818;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15813 = i + -1;
        mono_metadata_decode_row (t, D.15813, &cols, 2);
        output.51 = output;
        D.15814 = cols[0];
        D.15815 = (int) D.15814;
        D.15816 = get_typedef (m, D.15815);
        D.15817 = cols[1];
        D.15818 = get_typedef_or_ref (m, D.15817, 0B);
        fprintf (output.51, "%d: %s implements %s\n", i, D.15816, D.15818);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15184>:
  D.15811 = t->rows;
  D.15812 = (int) D.15811;
  if (D.15812 >= i) goto <D.15183>; else goto <D.15185>;
  <D.15185>:
}


dump_table_customattr (struct MonoImage * m)
{
  struct FILE * output.52;
  <unnamed-unsigned:24> D.15820;
  int D.15821;
  int D.15822;
  unsigned int D.15823;
  unsigned int D.15824;
  unsigned int D.15825;
  struct MonoMethodSignature * D.15826;
  unsigned int D.15827;
  const char * D.15828;
  struct MonoTableInfo * t;
  int i;

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

    try
      {
        D.15822 = i + -1;
        mono_metadata_decode_row (t, D.15822, &cols, 3);
        D.15823 = cols[0];
        desc = has_cattr_get_table (m, D.15823);
        D.15824 = cols[1];
        mtoken = D.15824 >> 3;
        D.15824 = cols[1];
        D.15825 = D.15824 & 7;
        switch (D.15825) <default: <D.15271>, case 2: <D.15268>, case 3: <D.15270>>
        <D.15268>:
        mtoken = mtoken | 100663296;
        goto <D.15269>;
        <D.15270>:
        mtoken = mtoken | 167772160;
        goto <D.15269>;
        <D.15271>:
        D.15824 = cols[1];
        monoeg_g_log (0B, 16, "Unknown table for custom attr type %08x", D.15824);
        goto <D.15269>;
        <D.15269>:
        method = get_method (m, mtoken, 0B);
        meth = mono_get_method (m, mtoken, 0B);
        D.15826 = mono_method_signature (meth);
        D.15827 = cols[2];
        D.15828 = mono_metadata_blob_heap (m, D.15827);
        params = custom_attr_params (m, D.15826, D.15828);
        output.52 = output;
        fprintf (output.52, "%d: %s: %s [%s]\n", i, desc, method, params);
        monoeg_g_free (desc);
        monoeg_g_free (method);
        monoeg_g_free (params);
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.15273>:
  D.15820 = t->rows;
  D.15821 = (int) D.15820;
  if (D.15821 >= i) goto <D.15272>; else goto <D.15274>;
  <D.15274>:
}


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

  t = val & 31;
  index = val >> 5;
  switch (t) <default: <D.15214>, case 0: <D.15193>, case 1: <D.15195>, case 2: <D.15196>, case 3: <D.15197>, case 4: <D.15198>, case 5: <D.15199>, case 6: <D.15200>, case 7: <D.15201>, case 8: <D.15202>, case 9: <D.15203>, case 10: <D.15204>, case 11: <D.15205>, case 12: <D.15206>, case 13: <D.15207>, case 14: <D.15208>, case 15: <D.15209>, case 16: <D.15210>, case 17: <D.15211>, case 18: <D.15212>, case 19: <D.15213>>
  <D.15193>:
  table = "MethodDef";
  goto <D.15194>;
  <D.15195>:
  table = "FieldDef";
  goto <D.15194>;
  <D.15196>:
  table = "TypeRef";
  goto <D.15194>;
  <D.15197>:
  table = "TypeDef";
  goto <D.15194>;
  <D.15198>:
  table = "Param";
  goto <D.15194>;
  <D.15199>:
  table = "InterfaceImpl";
  goto <D.15194>;
  <D.15200>:
  table = "MemberRef";
  goto <D.15194>;
  <D.15201>:
  table = "Module";
  goto <D.15194>;
  <D.15202>:
  table = "DeclSecurity?";
  goto <D.15194>;
  <D.15203>:
  table = "Property";
  goto <D.15194>;
  <D.15204>:
  table = "Event";
  goto <D.15194>;
  <D.15205>:
  table = "StandAloneSignature";
  goto <D.15194>;
  <D.15206>:
  table = "ModuleRef";
  goto <D.15194>;
  <D.15207>:
  table = "TypeSpec";
  goto <D.15194>;
  <D.15208>:
  table = "Assembly";
  goto <D.15194>;
  <D.15209>:
  table = "AssemblyRef";
  goto <D.15194>;
  <D.15210>:
  table = "File";
  goto <D.15194>;
  <D.15211>:
  table = "ExportedType";
  goto <D.15194>;
  <D.15212>:
  table = "Manifest";
  goto <D.15194>;
  <D.15213>:
  table = "GenericParam";
  goto <D.15194>;
  <D.15214>:
  table = "Unknown";
  goto <D.15194>;
  <D.15194>:
  D.15829 = monoeg_g_strdup_printf ("%s: %d", table, index);
  return D.15829;
}


custom_attr_params (struct MonoImage * m, struct MonoMethodSignature * sig, const char * value)
{
  const char * p.53;
  unsigned int D.15832;
  short unsigned int D.15836;
  char * D.15837;
  const char * p.54;
  struct MonoType * D.15841;
  unsigned char D.15842;
  char D.15843;
  unsigned int D.15844;
  const char * p.55;
  int D.15846;
  const char * iftmp.56;
  int D.15851;
  short int D.15852;
  int D.15853;
  unsigned int D.15854;
  const char * p.57;
  int D.15856;
  long unsigned int D.15857;
  long long int D.15858;
  const char * p.58;
  float val.59;
  float val.60;
  double D.15862;
  int D.15869;
  double val.61;
  double val.62;
  int D.15881;
  struct MonoClass * D.15885;
  int D.15886;
  struct MonoType * D.15889;
  unsigned char D.15890;
  unsigned int D.15893;
  sizetype D.15894;
  const char * p.63;
  int D.15896;
  short unsigned int D.15897;
  int D.15898;
  long int value.64;
  long int p.65;
  long int D.15903;
  unsigned int D.15904;
  unsigned int len.66;
  unsigned int D.15906;
  unsigned int D.15907;
  sizetype D.15908;
  const char * D.15909;
  char D.15910;
  int D.15911;
  int len;
  int i;
  int slen;
  int type;
  struct GString * res;
  char * s;
  const char * p;
  void handle_enum = <<< error >>>;

  try
    {
      p = value;
      p.53 = p;
      D.15832 = mono_metadata_decode_value (p.53, &p);
      len = (int) D.15832;
      if (len <= 1) goto <D.15833>; else goto <D.15835>;
      <D.15835>:
      p.53 = p;
      D.15836 = MEM[(const guint16 *)p.53];
      if (D.15836 != 1) goto <D.15833>; else goto <D.15834>;
      <D.15833>:
      D.15837 = monoeg_strdup ("");
      return D.15837;
      <D.15834>:
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      res = monoeg_g_string_new ("");
      i = 0;
      goto <D.15252>;
      <D.15251>:
      if (i != 0) goto <D.15839>; else goto <D.15840>;
      <D.15839>:
      monoeg_g_string_append (res, ", ");
      <D.15840>:
      D.15841 = sig->params[i];
      D.15842 = D.15841->type;
      type = (int) D.15842;
      handle_enum:
      switch (type) <default: <D.15250>, case 2: <D.15231>, case 3: <D.15232>, case 4: <D.15230>, case 5: <D.15228>, case 6: <D.15234>, case 7: <D.15233>, case 8: <D.15236>, case 9: <D.15235>, case 10: <D.15238>, case 11: <D.15237>, case 12: <D.15239>, case 13: <D.15243>, case 14: <D.15249>, case 17: <D.15247>, case 18: <D.15248>>
      <D.15228>:
      p.53 = p;
      D.15843 = *p.53;
      D.15844 = (unsigned int) D.15843;
      monoeg_g_string_append_printf (res, "%d", D.15844);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.15229>;
      <D.15230>:
      p.53 = p;
      D.15843 = *p.53;
      D.15846 = (int) D.15843;
      monoeg_g_string_append_printf (res, "%d", D.15846);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.15229>;
      <D.15231>:
      p.53 = p;
      D.15843 = *p.53;
      if (D.15843 != 0) goto <D.15848>; else goto <D.15849>;
      <D.15848>:
      iftmp.56 = "true";
      goto <D.15850>;
      <D.15849>:
      iftmp.56 = "false";
      <D.15850>:
      monoeg_g_string_append_printf (res, "%s", iftmp.56);
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.15229>;
      <D.15232>:
      p.53 = p;
      D.15836 = MEM[(const guint16 *)p.53];
      D.15851 = (int) D.15836;
      monoeg_g_string_append_printf (res, "\'%c\'", D.15851);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.15229>;
      <D.15233>:
      p.53 = p;
      D.15836 = MEM[(const guint16 *)p.53];
      D.15851 = (int) D.15836;
      monoeg_g_string_append_printf (res, "%d", D.15851);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.15229>;
      <D.15234>:
      p.53 = p;
      D.15836 = MEM[(const guint16 *)p.53];
      D.15852 = (short int) D.15836;
      D.15853 = (int) D.15852;
      monoeg_g_string_append_printf (res, "%d", D.15853);
      p.53 = p;
      p.54 = p.53 + 2;
      p = p.54;
      goto <D.15229>;
      <D.15235>:
      p.53 = p;
      D.15854 = MEM[(const guint32 *)p.53];
      monoeg_g_string_append_printf (res, "%d", D.15854);
      p.53 = p;
      p.57 = p.53 + 4;
      p = p.57;
      goto <D.15229>;
      <D.15236>:
      p.53 = p;
      D.15854 = MEM[(const guint32 *)p.53];
      D.15856 = (int) D.15854;
      monoeg_g_string_append_printf (res, "%d", D.15856);
      p.53 = p;
      p.57 = p.53 + 4;
      p = p.57;
      goto <D.15229>;
      <D.15237>:
      p.53 = p;
      D.15857 = MEM[(const guint64 *)p.53];
      D.15858 = (long long int) D.15857;
      monoeg_g_string_append_printf (res, "%lld", D.15858);
      p.53 = p;
      p.58 = p.53 + 8;
      p = p.58;
      goto <D.15229>;
      <D.15238>:
      p.53 = p;
      D.15857 = MEM[(const guint64 *)p.53];
      D.15858 = (long long int) D.15857;
      monoeg_g_string_append_printf (res, "%lld", D.15858);
      p.53 = p;
      p.58 = p.53 + 8;
      p = p.58;
      goto <D.15229>;
      <D.15239>:
      {
        float val;
        int inf;

        try
          {
            {
              union mono_rfloat mf;

              try
                {
                  p.53 = p;
                  D.15854 = MEM[(const guint32 *)p.53];
                  mf.ival = D.15854;
                  val.59 = mf.fval;
                  val = val.59;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.60 = val;
            D.15862 = (double) val.60;
            inf = dis_isinf (D.15862);
            if (inf == -1) goto <D.15863>; else goto <D.15864>;
            <D.15863>:
            monoeg_g_string_append_printf (res, "(00 00 80 ff)");
            goto <D.15865>;
            <D.15864>:
            if (inf == 1) goto <D.15866>; else goto <D.15867>;
            <D.15866>:
            monoeg_g_string_append_printf (res, "(00 00 80 7f)");
            goto <D.15868>;
            <D.15867>:
            val.60 = val;
            D.15862 = (double) val.60;
            D.15869 = dis_isnan (D.15862);
            if (D.15869 != 0) goto <D.15870>; else goto <D.15871>;
            <D.15870>:
            monoeg_g_string_append_printf (res, "(00 00 c0 ff)");
            goto <D.15872>;
            <D.15871>:
            val.60 = val;
            D.15862 = (double) val.60;
            monoeg_g_string_append_printf (res, "%g", D.15862);
            <D.15872>:
            <D.15868>:
            <D.15865>:
            p.53 = p;
            p.57 = p.53 + 4;
            p = p.57;
            goto <D.15229>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.15243>:
      {
        double val;
        int inf;

        try
          {
            {
              union mono_rdouble mf;

              try
                {
                  p.53 = p;
                  D.15857 = MEM[(const guint64 *)p.53];
                  mf.ival = D.15857;
                  val.61 = mf.fval;
                  val = val.61;
                }
              finally
                {
                  mf = {CLOBBER};
                }
            }
            val.62 = val;
            inf = dis_isinf (val.62);
            if (inf == -1) goto <D.15875>; else goto <D.15876>;
            <D.15875>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 ff)");
            goto <D.15877>;
            <D.15876>:
            if (inf == 1) goto <D.15878>; else goto <D.15879>;
            <D.15878>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f0 7f)");
            goto <D.15880>;
            <D.15879>:
            val.62 = val;
            D.15881 = __isnan (val.62);
            if (D.15881 != 0) goto <D.15882>; else goto <D.15883>;
            <D.15882>:
            monoeg_g_string_append_printf (res, "(00 00 00 00 00 00 f8 ff)");
            goto <D.15884>;
            <D.15883>:
            val.62 = val;
            monoeg_g_string_append_printf (res, "%g", val.62);
            <D.15884>:
            <D.15880>:
            <D.15877>:
            p.53 = p;
            p.58 = p.53 + 8;
            p = p.58;
            goto <D.15229>;
          }
        finally
          {
            val = {CLOBBER};
          }
      }
      <D.15247>:
      D.15841 = sig->params[i];
      D.15885 = D.15841->data.klass;
      D.15886 = mono_class_is_enum (D.15885);
      if (D.15886 != 0) goto <D.15887>; else goto <D.15888>;
      <D.15887>:
      D.15841 = sig->params[i];
      D.15885 = D.15841->data.klass;
      D.15889 = mono_class_enum_basetype (D.15885);
      D.15890 = D.15889->type;
      type = (int) D.15890;
      goto handle_enum;
      <D.15888>:
      monoeg_g_log (0B, 16, "generic valutype not handled in custom attr value decoding");
      goto <D.15229>;
      <D.15248>:
      <D.15249>:
      p.53 = p;
      D.15843 = *p.53;
      if (D.15843 == 255) goto <D.15891>; else goto <D.15892>;
      <D.15891>:
      monoeg_g_string_append (res, "null");
      p.53 = p;
      p.55 = p.53 + 1;
      p = p.55;
      goto <D.15229>;
      <D.15892>:
      p.53 = p;
      D.15893 = mono_metadata_decode_value (p.53, &p);
      slen = (int) D.15893;
      monoeg_g_string_append_c (res, 34);
      p.53 = p;
      monoeg_g_string_append (res, p.53);
      monoeg_g_string_append_c (res, 34);
      p.53 = p;
      D.15894 = (sizetype) slen;
      p.63 = p.53 + D.15894;
      p = p.63;
      goto <D.15229>;
      <D.15250>:
      D.15841 = sig->params[i];
      D.15842 = D.15841->type;
      D.15896 = (int) D.15842;
      monoeg_g_log (0B, 16, "Type %02x not handled in custom attr value decoding", D.15896);
      goto <D.15229>;
      <D.15229>:
      i = i + 1;
      <D.15252>:
      D.15897 = sig->param_count;
      D.15898 = (int) D.15897;
      if (D.15898 > i) goto <D.15251>; else goto <D.15253>;
      <D.15253>:
      p.53 = p;
      D.15836 = MEM[(const guint16 *)p.53];
      slen = (int) D.15836;
      if (slen != 0) goto <D.15899>; else goto <D.15900>;
      <D.15899>:
      monoeg_g_string_append_printf (res, " %d named args: (", slen);
      value.64 = (long int) value;
      p.53 = p;
      p.65 = (long int) p.53;
      D.15903 = value.64 - p.65;
      D.15904 = (unsigned int) D.15903;
      len.66 = (unsigned int) len;
      D.15906 = D.15904 + len.66;
      D.15907 = D.15906 + 1;
      slen = (int) D.15907;
      i = 0;
      goto <D.15255>;
      <D.15254>:
      p.53 = p;
      D.15908 = (sizetype) i;
      D.15909 = p.53 + D.15908;
      D.15910 = *D.15909;
      D.15911 = (int) D.15910;
      monoeg_g_string_append_printf (res, " %02X", D.15911);
      i = i + 1;
      <D.15255>:
      if (i < slen) goto <D.15254>; else goto <D.15256>;
      <D.15256>:
      monoeg_g_string_append_c (res, 41);
      <D.15900>:
      s = res->str;
      monoeg_g_string_free (res, 0);
      D.15837 = s;
      return D.15837;
    }
  finally
    {
      p = {CLOBBER};
    }
}


dump_table_nestedclass (struct MonoImage * m)
{
  struct FILE * output.67;
  <unnamed-unsigned:24> D.15917;
  int D.15918;
  int D.15919;
  unsigned int D.15920;
  int D.15921;
  unsigned int D.15922;
  int D.15923;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  char * nested;
  char * nesting;

  try
    {
      t = &m->tables[41];
      output.67 = output;
      D.15917 = t->rows;
      D.15918 = (int) D.15917;
      fprintf (output.67, "NestedClass Table (1..%d)\n", D.15918);
      i = 1;
      goto <D.15284>;
      <D.15283>:
      D.15919 = i + -1;
      mono_metadata_decode_row (t, D.15919, &cols, 2);
      D.15920 = cols[0];
      D.15921 = (int) D.15920;
      nested = get_typedef (m, D.15921);
      D.15922 = cols[1];
      D.15923 = (int) D.15922;
      nesting = get_typedef (m, D.15923);
      output.67 = output;
      D.15920 = cols[0];
      D.15922 = cols[1];
      fprintf (output.67, "%d: %d %d: %s in %s\n", i, D.15920, D.15922, nested, nesting);
      monoeg_g_free (nested);
      monoeg_g_free (nesting);
      i = i + 1;
      <D.15284>:
      D.15917 = t->rows;
      D.15918 = (int) D.15917;
      if (D.15918 >= i) goto <D.15283>; else goto <D.15285>;
      <D.15285>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_exported (struct MonoImage * m)
{
  struct FILE * output.68;
  <unnamed-unsigned:24> D.15925;
  int D.15926;
  int D.15927;
  unsigned int D.15928;
  unsigned int D.15929;
  unsigned int D.15930;
  const char * iftmp.69;
  char D.15932;
  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.68 = output;
      D.15925 = t->rows;
      D.15926 = (int) D.15925;
      fprintf (output.68, "ExportedType Table (1..%d)\n", D.15926);
      i = 1;
      goto <D.15298>;
      <D.15297>:
      D.15927 = i + -1;
      mono_metadata_decode_row (t, D.15927, &cols, 5);
      D.15928 = cols[2];
      name = mono_metadata_string_heap (m, D.15928);
      D.15929 = cols[3];
      nspace = mono_metadata_string_heap (m, D.15929);
      D.15930 = cols[4];
      impl = get_manifest_implementation (m, D.15930);
      index = cols[1];
      flags = cols[0];
      output.68 = output;
      D.15932 = *nspace;
      if (D.15932 != 0) goto <D.15933>; else goto <D.15934>;
      <D.15933>:
      iftmp.69 = ".";
      goto <D.15935>;
      <D.15934>:
      iftmp.69 = "";
      <D.15935>:
      fprintf (output.68, "%d: %s%s%s is in %s, index=%x, flags=0x%x\n", i, nspace, iftmp.69, name, impl, index, flags);
      monoeg_g_free (impl);
      i = i + 1;
      <D.15298>:
      D.15925 = t->rows;
      D.15926 = (int) D.15925;
      if (D.15926 >= i) goto <D.15297>; else goto <D.15299>;
      <D.15299>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_field_marshal (struct MonoImage * m)
{
  struct FILE * output.70;
  <unnamed-unsigned:24> D.15937;
  int D.15938;
  int D.15939;
  unsigned int D.15940;
  unsigned int D.15941;
  unsigned int D.15942;
  _Bool D.15943;
  unsigned int D.15944;
  const char * iftmp.71;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;
  int is_field;
  int idx;
  const char * blob;
  char * native;

  try
    {
      t = &m->tables[13];
      output.70 = output;
      D.15937 = t->rows;
      D.15938 = (int) D.15937;
      fprintf (output.70, "FieldMarshal Table (1..%d)\n", D.15938);
      i = 1;
      goto <D.15320>;
      <D.15319>:
      D.15939 = i + -1;
      mono_metadata_decode_row (t, D.15939, &cols, 2);
      D.15940 = cols[1];
      blob = mono_metadata_blob_heap (m, D.15940);
      native = get_marshal_info (m, blob);
      D.15941 = cols[0];
      D.15942 = D.15941 & 1;
      D.15943 = D.15942 == 0;
      is_field = (int) D.15943;
      D.15941 = cols[0];
      D.15944 = D.15941 >> 1;
      idx = (int) D.15944;
      output.70 = output;
      D.15941 = cols[0];
      if (is_field != 0) goto <D.15946>; else goto <D.15947>;
      <D.15946>:
      iftmp.71 = "Field";
      goto <D.15948>;
      <D.15947>:
      iftmp.71 = "Param";
      <D.15948>:
      fprintf (output.70, "%d: (0x%04x) %s %d: %s\n", i, D.15941, iftmp.71, idx, native);
      output.70 = output;
      fprintf (output.70, "\tblob encoding: ");
      dump_blob (m, blob);
      output.70 = output;
      fprintf (output.70, "\n");
      monoeg_g_free (native);
      i = i + 1;
      <D.15320>:
      D.15937 = t->rows;
      D.15938 = (int) D.15937;
      if (D.15938 >= i) goto <D.15319>; else goto <D.15321>;
      <D.15321>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_blob (struct MonoImage * m, const char * blob)
{
  const char * blob.72;
  unsigned int D.15950;
  struct FILE * output.73;
  sizetype D.15952;
  const char * D.15953;
  char D.15954;
  int D.15955;
  int j;
  int bsize;

  blob.72 = blob;
  D.15950 = mono_metadata_decode_blob_size (blob.72, &blob);
  bsize = (int) D.15950;
  j = 0;
  goto <D.15307>;
  <D.15306>:
  output.73 = output;
  blob.72 = blob;
  D.15952 = (sizetype) j;
  D.15953 = blob.72 + D.15952;
  D.15954 = *D.15953;
  D.15955 = (int) D.15954;
  fprintf (output.73, "%02x ", D.15955);
  j = j + 1;
  <D.15307>:
  if (j < bsize) goto <D.15306>; else goto <D.15308>;
  <D.15308>:
}


dump_table_declsec (struct MonoImage * m)
{
  struct FILE * output.74;
  <unnamed-unsigned:24> D.15961;
  int D.15962;
  int D.15963;
  unsigned int D.15964;
  const char * blob.75;
  const char * blob.76;
  unsigned int D.15967;
  unsigned int D.15968;
  int D.15969;
  unsigned int D.15970;
  const char * D.15971;
  unsigned int D.15972;
  const char * iftmp.77;
  char D.15979;
  sizetype D.15983;
  const char * D.15984;
  char D.15985;
  int D.15986;
  unsigned int len.78;
  struct MonoTableInfo * t;
  guint32 cols[3];
  int i;
  int len;
  guint32 idx;
  const char * blob;
  const char * action;
  const char * parent[4];

  try
    {
      t = &m->tables[14];
      parent = *.LC8;
      output.74 = output;
      D.15961 = t->rows;
      D.15962 = (int) D.15961;
      fprintf (output.74, "DeclSecurity Table (1..%d)\n", D.15962);
      i = 1;
      goto <D.15359>;
      <D.15358>:
      D.15963 = i + -1;
      mono_metadata_decode_row (t, D.15963, &cols, 3);
      D.15964 = cols[2];
      blob.75 = mono_metadata_blob_heap (m, D.15964);
      blob = blob.75;
      blob.76 = blob;
      D.15967 = mono_metadata_decode_blob_size (blob.76, &blob);
      len = (int) D.15967;
      D.15968 = cols[0];
      D.15969 = (int) D.15968;
      action = get_security_action (D.15969);
      idx = cols[1];
      output.74 = output;
      D.15970 = idx & 3;
      D.15971 = parent[D.15970];
      D.15972 = idx >> 2;
      if (len != 0) goto <D.15974>; else goto <D.15975>;
      <D.15974>:
      iftmp.77 = ":\n\t";
      goto <D.15976>;
      <D.15975>:
      iftmp.77 = "\n";
      <D.15976>:
      fprintf (output.74, "%d: %s on %s %d%s", i, action, D.15971, D.15972, iftmp.77);
      if (len == 0) goto <D.15977>; else goto <D.15978>;
      <D.15977>:
      // predicted unlikely by continue predictor.
      goto <D.15353>;
      <D.15978>:
      blob.76 = blob;
      D.15979 = *blob.76;
      if (D.15979 == 46) goto <D.15980>; else goto <D.15981>;
      <D.15980>:
      {
        char * declsec;

        blob.76 = blob;
        declsec = dump_declsec_entry20 (m, blob.76, "\t");
        output.74 = output;
        fprintf (output.74, "%s", declsec);
        monoeg_g_free (declsec);
      }
      goto <D.15982>;
      <D.15981>:
      idx = 0;
      goto <D.15356>;
      <D.15355>:
      output.74 = output;
      blob.76 = blob;
      D.15983 = (sizetype) idx;
      D.15984 = blob.76 + D.15983;
      D.15985 = *D.15984;
      D.15986 = (int) D.15985;
      fprintf (output.74, "%c", D.15986);
      idx = idx + 1;
      <D.15356>:
      len.78 = (unsigned int) len;
      if (len.78 > idx) goto <D.15355>; else goto <D.15357>;
      <D.15357>:
      <D.15982>:
      output.74 = output;
      fprintf (output.74, "\n");
      <D.15353>:
      i = i + 1;
      <D.15359>:
      D.15961 = t->rows;
      D.15962 = (int) D.15961;
      if (D.15962 >= i) goto <D.15358>; else goto <D.15360>;
      <D.15360>:
    }
  finally
    {
      cols = {CLOBBER};
      blob = {CLOBBER};
      parent = {CLOBBER};
    }
}


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

  switch (val) <default: <D.15341>, case 2: <D.15326>, case 3: <D.15327>, case 4: <D.15328>, case 5: <D.15329>, case 6: <D.15330>, case 7: <D.15331>, case 8: <D.15332>, case 9: <D.15333>, case 10: <D.15334>, case 13: <D.15335>, case 14: <D.15336>, case 15: <D.15337>, case 16: <D.15338>, case 17: <D.15339>, case 18: <D.15340>>
  <D.15326>:
  D.15988 = "Demand";
  return D.15988;
  <D.15327>:
  D.15988 = "Assert";
  return D.15988;
  <D.15328>:
  D.15988 = "Deny";
  return D.15988;
  <D.15329>:
  D.15988 = "PermitOnly";
  return D.15988;
  <D.15330>:
  D.15988 = "LinkDemand";
  return D.15988;
  <D.15331>:
  D.15988 = "InheritanceDemand";
  return D.15988;
  <D.15332>:
  D.15988 = "RequestMinimum";
  return D.15988;
  <D.15333>:
  D.15988 = "RequestOptional";
  return D.15988;
  <D.15334>:
  D.15988 = "RequestRefuse";
  return D.15988;
  <D.15335>:
  D.15988 = "NonCasDemand";
  return D.15988;
  <D.15336>:
  D.15988 = "NonCasLinkDemand";
  return D.15988;
  <D.15337>:
  D.15988 = "NonCasInheritance";
  return D.15988;
  <D.15338>:
  D.15988 = "LinkDemandChoice";
  return D.15988;
  <D.15339>:
  D.15988 = "InheritanceDemandChoice";
  return D.15988;
  <D.15340>:
  D.15988 = "DemandChoice";
  return D.15988;
  <D.15341>:
  monoeg_g_snprintf (&buf, 32, "0x%04X", val);
  D.15988 = &buf;
  return D.15988;
}


dump_table_genericpar (struct MonoImage * m)
{
  struct FILE * output.79;
  <unnamed-unsigned:24> D.15991;
  int D.15992;
  int D.15993;
  unsigned int D.15994;
  unsigned int D.15995;
  unsigned int D.15996;
  unsigned int D.15997;
  const char * D.15998;
  struct MonoTableInfo * t;
  guint32 cols[4];
  int i;

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

        D.15993 = i + -1;
        mono_metadata_decode_row (t, D.15993, &cols, 4);
        D.15994 = cols[2];
        sig = monoeg_g_strdup_printf ("%x", D.15994);
        output.79 = output;
        D.15995 = cols[0];
        D.15996 = cols[1];
        D.15997 = cols[3];
        D.15998 = mono_metadata_string_heap (m, D.15997);
        fprintf (output.79, "%d: %d, flags=%d, owner=%s %s\n", i, D.15995, D.15996, sig, D.15998);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.15369>:
      D.15991 = t->rows;
      D.15992 = (int) D.15991;
      if (D.15992 >= i) goto <D.15368>; else goto <D.15370>;
      <D.15370>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_methodspec (struct MonoImage * m)
{
  struct FILE * output.80;
  <unnamed-unsigned:24> D.16000;
  int D.16001;
  int D.16002;
  int D.16003;
  unsigned int D.16004;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

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

        D.16002 = i + -1;
        mono_metadata_decode_row (t, D.16002, &cols, 2);
        D.16003 = i | 721420288;
        token = (guint32) D.16003;
        method = get_method (m, token, 0B);
        D.16004 = cols[1];
        sig = get_method_type_param (m, D.16004, 0B);
        output.80 = output;
        fprintf (output.80, "%d: %s, %s\n", i, method, sig);
        monoeg_g_free (sig);
        monoeg_g_free (method);
      }
      i = i + 1;
      <D.15381>:
      D.16000 = t->rows;
      D.16001 = (int) D.16000;
      if (D.16001 >= i) goto <D.15380>; else goto <D.15382>;
      <D.15382>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_table_parconstraint (struct MonoImage * m)
{
  struct FILE * output.81;
  <unnamed-unsigned:24> D.16006;
  int D.16007;
  int D.16008;
  unsigned int D.16009;
  unsigned int D.16010;
  struct MonoTableInfo * t;
  guint32 cols[2];
  int i;

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

        D.16008 = i + -1;
        mono_metadata_decode_row (t, D.16008, &cols, 2);
        D.16009 = cols[1];
        sig = monoeg_g_strdup_printf ("%x", D.16009);
        output.81 = output;
        D.16010 = cols[0];
        fprintf (output.81, "%d: gen-par=%d, Constraint=%s\n", i, D.16010, sig);
        monoeg_g_free (sig);
      }
      i = i + 1;
      <D.15391>:
      D.16006 = t->rows;
      D.16007 = (int) D.16006;
      if (D.16007 >= i) goto <D.15390>; else goto <D.15392>;
      <D.15392>:
    }
  finally
    {
      cols = {CLOBBER};
    }
}


dump_stream_blob (struct MonoImage * m)
{
  struct FILE * output.82;
  unsigned int i.83;
  unsigned int D.16015;
  unsigned int D.16019;
  const char * D.16022;
  sizetype D.16023;
  const char * D.16024;
  char D.16025;
  int D.16026;
  unsigned int i.84;
  unsigned int D.16028;
  int i;

  output.82 = output;
  fprintf (output.82, "Blob heap contents\n");
  i = 0;
  goto <D.15398>;
  <D.15397>:
  if (i > 0) goto <D.16012>; else goto <D.16013>;
  <D.16012>:
  i.83 = (unsigned int) i;
  D.16015 = i.83 & 15;
  if (D.16015 == 0) goto <D.16016>; else goto <D.16017>;
  <D.16016>:
  output.82 = output;
  fprintf (output.82, "\n");
  goto <D.16018>;
  <D.16017>:
  i.83 = (unsigned int) i;
  D.16019 = i.83 & 7;
  if (D.16019 == 0) goto <D.16020>; else goto <D.16021>;
  <D.16020>:
  output.82 = output;
  fprintf (output.82, "- ");
  <D.16021>:
  <D.16018>:
  <D.16013>:
  output.82 = output;
  D.16022 = m->heap_blob.data;
  D.16023 = (sizetype) i;
  D.16024 = D.16022 + D.16023;
  D.16025 = *D.16024;
  D.16026 = (int) D.16025;
  fprintf (output.82, "%02x ", D.16026);
  i = i + 1;
  <D.15398>:
  i.84 = (unsigned int) i;
  D.16028 = m->heap_blob.size;
  if (i.84 < D.16028) goto <D.15397>; else goto <D.15399>;
  <D.15399>:
  output.82 = output;
  fprintf (output.82, "\n");
}


dump_stream_strings (struct MonoImage * m)
{
  struct FILE * output.85;
  long unsigned int D.16030;
  unsigned int D.16031;
  unsigned int D.16032;
  unsigned int D.16033;
  guint32 i;

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

    str = mono_metadata_string_heap (m, i);
    output.85 = output;
    fprintf (output.85, "%02x: \"%s\"\n", i, str);
    D.16030 = strlen (str);
    D.16031 = (unsigned int) D.16030;
    D.16032 = D.16031 + i;
    i = D.16032 + 1;
  }
  <D.15406>:
  D.16033 = m->heap_strings.size;
  if (D.16033 > i) goto <D.15405>; else goto <D.15407>;
  <D.15407>:
}


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

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

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


dump_table_standalonesig (struct MonoImage * m)
{
  struct FILE * output.90;
  <unnamed-unsigned:24> D.16042;
  int D.16043;
  int D.16044;
  unsigned int D.16045;
  const char * locals_ptr.91;
  const char * locals_ptr.92;
  unsigned int D.16048;
  sizetype D.16049;
  const char * D.16050;
  char D.16051;
  int D.16052;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

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

        try
          {
            D.16044 = i + -1;
            mono_metadata_decode_row (t, D.16044, &cols, 1);
            D.16045 = cols[0];
            locals_ptr.91 = mono_metadata_blob_heap (m, D.16045);
            locals_ptr = locals_ptr.91;
            locals_ptr.92 = locals_ptr;
            D.16048 = mono_metadata_decode_blob_size (locals_ptr.92, &locals_ptr);
            bsize = (int) D.16048;
            output.90 = output;
            D.16045 = cols[0];
            fprintf (output.90, "%d: blob[0x%x] = ", i, D.16045);
            j = 0;
            goto <D.15428>;
            <D.15427>:
            output.90 = output;
            locals_ptr.92 = locals_ptr;
            D.16049 = (sizetype) j;
            D.16050 = locals_ptr.92 + D.16049;
            D.16051 = *D.16050;
            D.16052 = (int) D.16051;
            fprintf (output.90, "%02x ", D.16052);
            j = j + 1;
            <D.15428>:
            if (j < bsize) goto <D.15427>; else goto <D.15429>;
            <D.15429>:
            output.90 = output;
            fprintf (output.90, "\n");
          }
        finally
          {
            locals_ptr = {CLOBBER};
          }
      }
      i = i + 1;
      <D.15431>:
      D.16042 = t->rows;
      D.16043 = (int) D.16042;
      if (D.16043 >= i) goto <D.15430>; else goto <D.15432>;
      <D.15432>:
    }
  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.93;
  <unnamed-unsigned:24> D.16054;
  int D.16055;
  int D.16056;
  unsigned int D.16057;
  struct MonoTableInfo * t;
  guint32 cols[1];
  int i;

  try
    {
      t = &m->tables[table];
      output.93 = output;
      D.16054 = t->rows;
      D.16055 = (int) D.16054;
      fprintf (output.93, "%s (1..%d)\n", name, D.16055);
      i = 1;
      goto <D.15442>;
      <D.15441>:
      D.16056 = i + -1;
      mono_metadata_decode_row (t, D.16056, &cols, 1);
      output.93 = output;
      D.16057 = cols[0];
      fprintf (output.93, "%d: %d\n", i, D.16057);
      i = i + 1;
      <D.15442>:
      D.16054 = t->rows;
      D.16055 = (int) D.16054;
      if (D.16055 >= i) goto <D.15441>; else goto <D.15443>;
      <D.15443>:
    }
  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");
}