main (int argc, char * * argv)
{
  unsigned int i.0;
  unsigned int D.17638;
  char * * D.17639;
  char * D.17640;
  char D.17641;
  int D.17603;
  int iftmp.1;
  int D.17602;
  const char[7] * D.17647;
  unsigned char D.17648;
  int D.17649;
  unsigned char D.17650;
  int D.17651;
  _Bool D.17652;
  _Bool D.17653;
  _Bool D.17654;
  const unsigned char * D.17657;
  unsigned char D.17658;
  int D.17659;
  const unsigned char * D.17660;
  unsigned char D.17661;
  int D.17662;
  _Bool D.17663;
  _Bool D.17664;
  const unsigned char * D.17667;
  unsigned char D.17668;
  int D.17669;
  const unsigned char * D.17670;
  unsigned char D.17671;
  int D.17672;
  _Bool D.17673;
  _Bool D.17674;
  const unsigned char * D.17677;
  unsigned char D.17678;
  int D.17679;
  const unsigned char * D.17680;
  unsigned char D.17681;
  int D.17682;
  int D.17612;
  int iftmp.2;
  int D.17611;
  const char[9] * D.17690;
  unsigned char D.17691;
  int D.17692;
  unsigned char D.17693;
  int D.17694;
  _Bool D.17695;
  _Bool D.17696;
  _Bool D.17697;
  const unsigned char * D.17700;
  unsigned char D.17701;
  int D.17702;
  const unsigned char * D.17703;
  unsigned char D.17704;
  int D.17705;
  _Bool D.17706;
  _Bool D.17707;
  const unsigned char * D.17710;
  unsigned char D.17711;
  int D.17712;
  const unsigned char * D.17713;
  unsigned char D.17714;
  int D.17715;
  _Bool D.17716;
  _Bool D.17717;
  const unsigned char * D.17720;
  unsigned char D.17721;
  int D.17722;
  const unsigned char * D.17723;
  unsigned char D.17724;
  int D.17725;
  int verify_pe.3;
  int D.17625;
  const char * D.17735;
  unsigned int D.17738;
  unsigned int verify_flags.4;
  unsigned int D.17754;
  int D.17757;
  int verify_code.5;
  int D.17766;
  struct _IO_FILE * stderr.6;
  int dump_data.7;
  unsigned int D.17779;
  unsigned int D.17780;
  struct MonoImage * D.17785;
  int iftmp.8;
  int image_result;
  struct MonoImage * image;
  char * file;
  char * flags;
  MiniVerifierMode verifier_mode;
  const char * flag_desc[11];
  guint flag_vals[11];
  int i;
  int verify_flags;
  int run_new_metadata_verifier;

  try
    {
      image_result = 0;
      file = 0B;
      flags = 0B;
      verifier_mode = 2;
      flag_desc[0] = "error";
      flag_desc[1] = "warn";
      flag_desc[2] = "cls";
      flag_desc[3] = "all";
      flag_desc[4] = "code";
      flag_desc[5] = "fail-on-verifiable";
      flag_desc[6] = "non-strict";
      flag_desc[7] = "valid-only";
      flag_desc[8] = "metadata";
      flag_desc[9] = "partial-md";
      flag_desc[10] = 0B;
      flag_vals[0] = 1;
      flag_vals[1] = 2;
      flag_vals[2] = 4;
      flag_vals[3] = 7;
      flag_vals[4] = 8;
      flag_vals[5] = 16;
      flag_vals[6] = 32;
      flag_vals[7] = 134217728;
      flag_vals[8] = 9;
      flag_vals[9] = 10;
      flag_vals[10] = 0;
      verify_flags = 128;
      run_new_metadata_verifier = 0;
      i = 1;
      goto <D.17614>;
      <D.17613>:
      i.0 = (unsigned int) i;
      D.17638 = i.0 * 4;
      D.17639 = argv + D.17638;
      D.17640 = *D.17639;
      D.17641 = *D.17640;
      if (D.17641 != 45) goto <D.17642>; else goto <D.17643>;
      <D.17642>:
      i.0 = (unsigned int) i;
      D.17638 = i.0 * 4;
      D.17639 = argv + D.17638;
      file = *D.17639;
      // predicted unlikely by continue predictor.
      goto <D.17594>;
      <D.17643>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.17645>; else goto <D.17646>;
        <D.17645>:
        {
          const unsigned char * __s2;
          int __result;

          i.0 = (unsigned int) i;
          D.17638 = i.0 * 4;
          D.17639 = argv + D.17638;
          __s2 = *D.17639;
          D.17647 = "--help";
          D.17648 = MEM[(const unsigned char *)D.17647];
          D.17649 = (int) D.17648;
          D.17650 = *__s2;
          D.17651 = (int) D.17650;
          __result = D.17649 - D.17651;
          {
            D.17652 = __s2_len != 0;
            D.17653 = __result == 0;
            D.17654 = D.17652 & D.17653;
            if (D.17654 != 0) goto <D.17655>; else goto <D.17656>;
            <D.17655>:
            D.17657 = &MEM[(void *)"--help" + 1B];
            D.17658 = *D.17657;
            D.17659 = (int) D.17658;
            D.17660 = __s2 + 1;
            D.17661 = *D.17660;
            D.17662 = (int) D.17661;
            __result = D.17659 - D.17662;
            D.17663 = __s2_len > 1;
            D.17653 = __result == 0;
            D.17664 = D.17663 & D.17653;
            if (D.17664 != 0) goto <D.17665>; else goto <D.17666>;
            <D.17665>:
            D.17667 = &MEM[(void *)"--help" + 2B];
            D.17668 = *D.17667;
            D.17669 = (int) D.17668;
            D.17670 = __s2 + 2;
            D.17671 = *D.17670;
            D.17672 = (int) D.17671;
            __result = D.17669 - D.17672;
            D.17673 = __s2_len > 2;
            D.17653 = __result == 0;
            D.17674 = D.17673 & D.17653;
            if (D.17674 != 0) goto <D.17675>; else goto <D.17676>;
            <D.17675>:
            D.17677 = &MEM[(void *)"--help" + 3B];
            D.17678 = *D.17677;
            D.17679 = (int) D.17678;
            D.17680 = __s2 + 3;
            D.17681 = *D.17680;
            D.17682 = (int) D.17681;
            __result = D.17679 - D.17682;
            <D.17676>:
            <D.17666>:
            <D.17656>:
          }
          D.17602 = __result;
        }
        iftmp.1 = -D.17602;
        goto <D.17683>;
        <D.17646>:
        i.0 = (unsigned int) i;
        D.17638 = i.0 * 4;
        D.17639 = argv + D.17638;
        D.17640 = *D.17639;
        iftmp.1 = __builtin_strcmp (D.17640, "--help");
        <D.17683>:
        D.17603 = iftmp.1;
      }
      if (D.17603 == 0) goto <D.17684>; else goto <D.17685>;
      <D.17684>:
      usage ();
      goto <D.17686>;
      <D.17685>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.17688>; else goto <D.17689>;
        <D.17688>:
        {
          const unsigned char * __s2;
          int __result;

          i.0 = (unsigned int) i;
          D.17638 = i.0 * 4;
          D.17639 = argv + D.17638;
          __s2 = *D.17639;
          D.17690 = "--verify";
          D.17691 = MEM[(const unsigned char *)D.17690];
          D.17692 = (int) D.17691;
          D.17693 = *__s2;
          D.17694 = (int) D.17693;
          __result = D.17692 - D.17694;
          {
            D.17695 = __s2_len != 0;
            D.17696 = __result == 0;
            D.17697 = D.17695 & D.17696;
            if (D.17697 != 0) goto <D.17698>; else goto <D.17699>;
            <D.17698>:
            D.17700 = &MEM[(void *)"--verify" + 1B];
            D.17701 = *D.17700;
            D.17702 = (int) D.17701;
            D.17703 = __s2 + 1;
            D.17704 = *D.17703;
            D.17705 = (int) D.17704;
            __result = D.17702 - D.17705;
            D.17706 = __s2_len > 1;
            D.17696 = __result == 0;
            D.17707 = D.17706 & D.17696;
            if (D.17707 != 0) goto <D.17708>; else goto <D.17709>;
            <D.17708>:
            D.17710 = &MEM[(void *)"--verify" + 2B];
            D.17711 = *D.17710;
            D.17712 = (int) D.17711;
            D.17713 = __s2 + 2;
            D.17714 = *D.17713;
            D.17715 = (int) D.17714;
            __result = D.17712 - D.17715;
            D.17716 = __s2_len > 2;
            D.17696 = __result == 0;
            D.17717 = D.17716 & D.17696;
            if (D.17717 != 0) goto <D.17718>; else goto <D.17719>;
            <D.17718>:
            D.17720 = &MEM[(void *)"--verify" + 3B];
            D.17721 = *D.17720;
            D.17722 = (int) D.17721;
            D.17723 = __s2 + 3;
            D.17724 = *D.17723;
            D.17725 = (int) D.17724;
            __result = D.17722 - D.17725;
            <D.17719>:
            <D.17709>:
            <D.17699>:
          }
          D.17611 = __result;
        }
        iftmp.2 = -D.17611;
        goto <D.17726>;
        <D.17689>:
        i.0 = (unsigned int) i;
        D.17638 = i.0 * 4;
        D.17639 = argv + D.17638;
        D.17640 = *D.17639;
        iftmp.2 = __builtin_strcmp (D.17640, "--verify");
        <D.17726>:
        D.17612 = iftmp.2;
      }
      if (D.17612 == 0) goto <D.17727>; else goto <D.17728>;
      <D.17727>:
      verify_pe = 1;
      dump_data = 0;
      i = i + 1;
      i.0 = (unsigned int) i;
      D.17638 = i.0 * 4;
      D.17639 = argv + D.17638;
      flags = *D.17639;
      goto <D.17729>;
      <D.17728>:
      usage ();
      <D.17729>:
      <D.17686>:
      <D.17594>:
      i = i + 1;
      <D.17614>:
      if (i < argc) goto <D.17613>; else goto <D.17615>;
      <D.17615>:
      if (file == 0B) goto <D.17730>; else goto <D.17731>;
      <D.17730>:
      usage ();
      <D.17731>:
      mono_perfcounters_init ();
      mono_metadata_init ();
      mono_images_init ();
      mono_assemblies_init ();
      mono_loader_init ();
      verify_pe.3 = verify_pe;
      if (verify_pe.3 != 0) goto <D.17733>; else goto <D.17734>;
      <D.17733>:
      {
        char * tok;

        tok = strtok (flags, ",");
        verify_metadata = 1;
        verify_code = 0;
        goto <D.17630>;
        <D.17629>:
        i = 0;
        goto <D.17628>;
        <D.17627>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.17735 = flag_desc[i];
          D.17625 = __builtin_strcmp (tok, D.17735);
        }
        if (D.17625 == 0) goto <D.17736>; else goto <D.17737>;
        <D.17736>:
        D.17738 = flag_vals[i];
        if (D.17738 == 8) goto <D.17739>; else goto <D.17740>;
        <D.17739>:
        verify_metadata = 0;
        verify_code = 1;
        goto <D.17741>;
        <D.17740>:
        D.17738 = flag_vals[i];
        if (D.17738 == 7) goto <D.17742>; else goto <D.17743>;
        <D.17742>:
        verify_code = 1;
        goto <D.17744>;
        <D.17743>:
        D.17738 = flag_vals[i];
        if (D.17738 == 9) goto <D.17745>; else goto <D.17746>;
        <D.17745>:
        verify_metadata = 0;
        run_new_metadata_verifier = 1;
        goto <D.17747>;
        <D.17746>:
        D.17738 = flag_vals[i];
        if (D.17738 == 10) goto <D.17748>; else goto <D.17749>;
        <D.17748>:
        verify_partial_md = 1;
        <D.17749>:
        <D.17747>:
        <D.17744>:
        <D.17741>:
        D.17738 = flag_vals[i];
        if (D.17738 == 134217728) goto <D.17750>; else goto <D.17751>;
        <D.17750>:
        verifier_mode = 1;
        goto <D.17752>;
        <D.17751>:
        D.17738 = flag_vals[i];
        verify_flags.4 = (unsigned int) verify_flags;
        D.17754 = D.17738 | verify_flags.4;
        verify_flags = (int) D.17754;
        <D.17752>:
        goto <D.17626>;
        <D.17737>:
        i = i + 1;
        <D.17628>:
        D.17735 = flag_desc[i];
        if (D.17735 != 0B) goto <D.17627>; else goto <D.17626>;
        <D.17626>:
        D.17735 = flag_desc[i];
        if (D.17735 == 0B) goto <D.17755>; else goto <D.17756>;
        <D.17755>:
        monoeg_g_print ("Unknown verify flag %s\n", tok);
        <D.17756>:
        tok = strtok (0B, ",");
        <D.17630>:
        if (tok != 0B) goto <D.17629>; else goto <D.17631>;
        <D.17631>:
        mono_verifier_set_mode (verifier_mode);
      }
      <D.17734>:
      verify_pe.3 = verify_pe;
      D.17757 = verify_pe.3 | run_new_metadata_verifier;
      if (D.17757 != 0) goto <D.17758>; else goto <D.17759>;
      <D.17758>:
      run_new_metadata_verifier = 1;
      <D.17759>:
      if (run_new_metadata_verifier != 0) goto <D.17760>; else goto <D.17761>;
      <D.17760>:
      mono_verifier_set_mode (verifier_mode);
      image_result = verify_image_file (file);
      if (image_result == 1) goto <D.17762>; else goto <D.17764>;
      <D.17764>:
      verify_code.5 = verify_code;
      if (verify_code.5 == 0) goto <D.17762>; else goto <D.17763>;
      <D.17762>:
      D.17766 = image_result;
      return D.17766;
      <D.17763>:
      <D.17761>:
      image = mono_image_open (file, 0B);
      if (image == 0B) goto <D.17767>; else goto <D.17768>;
      <D.17767>:
      stderr.6 = stderr;
      fprintf (stderr.6, "Cannot open image %s\n", file);
      exit (1);
      <D.17768>:
      dump_data.7 = dump_data;
      if (dump_data.7 != 0) goto <D.17771>; else goto <D.17772>;
      <D.17771>:
      dump_dotnet_iinfo (image);
      <D.17772>:
      verify_pe.3 = verify_pe;
      if (verify_pe.3 != 0) goto <D.17773>; else goto <D.17774>;
      <D.17773>:
      {
        struct MonoAssembly * assembly;
        struct MonoImage * image;
        MonoImageOpenStatus status;
        int code_result;

        try
          {
            mono_verifier_set_mode (verifier_mode);
            assembly = mono_assembly_open (file, 0B);
            if (assembly == 0B) goto <D.17775>; else goto <D.17776>;
            <D.17775>:
            image = mono_image_open (file, &status);
            if (image != 0B) goto <D.17777>; else goto <D.17778>;
            <D.17777>:
            D.17779 = BIT_FIELD_REF <*image, 32, 3904>;
            D.17780 = D.17779 & 16777215;
            if (D.17780 == 0) goto <D.17781>; else goto <D.17782>;
            <D.17781>:
            assembly = monoeg_malloc0 (92);
            assembly->in_gac = 0;
            assembly->image = image;
            image->assembly = assembly;
            <D.17782>:
            <D.17778>:
            <D.17776>:
            if (assembly == 0B) goto <D.17783>; else goto <D.17784>;
            <D.17783>:
            monoeg_g_print ("Could not open assembly %s\n", file);
            D.17766 = 4;
            return D.17766;
            <D.17784>:
            D.17785 = assembly->image;
            code_result = dump_verify_info (D.17785, verify_flags);
            if (code_result != 0) goto <D.17787>; else goto <D.17788>;
            <D.17787>:
            iftmp.8 = code_result;
            goto <D.17789>;
            <D.17788>:
            iftmp.8 = image_result;
            <D.17789>:
            D.17766 = iftmp.8;
            return D.17766;
          }
        finally
          {
            status = {CLOBBER};
          }
      }
      <D.17774>:
      mono_image_close (image);
      D.17766 = 0;
      return D.17766;
    }
  finally
    {
      flag_desc = {CLOBBER};
      flag_vals = {CLOBBER};
    }
}


usage ()
{
  printf ("Usage is: pedump [--verify error,warn,cls,all,code,fail-on-verifiable,non-strict,valid-only,metadata] file.exe\n");
  exit (1);
}


printf (const char * restrict __fmt)
{
  int D.17793;

  D.17793 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.17793;
}


verify_image_file (const char * fname)
{
  int D.17797;
  int D.17798;
  int D.17800;
  int D.17803;
  int D.17805;
  int D.17808;
  struct MonoAssemblyName * D.17810;
  char * D.17811;
  int verify_partial_md.9;
  int D.17815;
  int D.17817;
  unsigned char D.17822;
  struct MonoLoaderError * D.17824;
  const char * D.17825;
  const char * D.17826;
  struct MonoLoaderError * D.17830;
  <unnamed-unsigned:24> D.17831;
  int D.17832;
  char * D.17835;
  <unnamed type> D.17836;
  const char * D.17837;
  struct GSList * errors.10;
  struct GSList * errors;
  struct GSList * tmp;
  struct MonoImage * image;
  struct MonoTableInfo * table;
  struct MonoAssembly * assembly;
  MonoImageOpenStatus status;
  int i;
  int count;
  const char * desc[9];
  void invalid_image = <<< error >>>;

  try
    {
      errors = 0B;
      count = 0;
      desc[0] = "Ok";
      desc[1] = "Error";
      desc[2] = "Warning";
      desc[3] = 0B;
      desc[4] = "CLS";
      desc[5] = 0B;
      desc[6] = 0B;
      desc[7] = 0B;
      desc[8] = "Not Verifiable";
      image = mono_image_open_raw (fname, &status);
      if (image == 0B) goto <D.17795>; else goto <D.17796>;
      <D.17795>:
      printf ("Could not open %s\n", fname);
      D.17797 = 1;
      return D.17797;
      <D.17796>:
      D.17798 = mono_verifier_verify_pe_data (image, &errors);
      if (D.17798 == 0) goto invalid_image; else goto <D.17799>;
      <D.17799>:
      D.17800 = mono_image_load_pe_data (image);
      if (D.17800 == 0) goto <D.17801>; else goto <D.17802>;
      <D.17801>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.17797 = 1;
      return D.17797;
      <D.17802>:
      D.17803 = mono_verifier_verify_cli_data (image, &errors);
      if (D.17803 == 0) goto invalid_image; else goto <D.17804>;
      <D.17804>:
      D.17805 = mono_image_load_cli_data (image);
      if (D.17805 == 0) goto <D.17806>; else goto <D.17807>;
      <D.17806>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.17797 = 1;
      return D.17797;
      <D.17807>:
      D.17808 = mono_verifier_verify_table_data (image, &errors);
      if (D.17808 == 0) goto invalid_image; else goto <D.17809>;
      <D.17809>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (92);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.17810 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.17810);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.17811 = image->version;
      mono_init_version ("pedump", D.17811);
      mono_install_assembly_preload_hook (pedump_preload, 0B);
      mono_marshal_init ();
      verify_partial_md.9 = verify_partial_md;
      if (verify_partial_md.9 == 0) goto <D.17813>; else goto <D.17814>;
      <D.17813>:
      D.17815 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.17815 == 0) goto invalid_image; else goto <D.17816>;
      <D.17816>:
      <D.17814>:
      table = &image->tables[2];
      i = 1;
      goto <D.17529>;
      <D.17528>:
      {
        guint32 token;
        struct MonoClass * class;

        D.17817 = i | 33554432;
        token = (guint32) D.17817;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.17818>; else goto <D.17819>;
        <D.17818>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.17527>;
        <D.17819>:
        mono_class_init (class);
        D.17822 = class->exception_type;
        if (D.17822 != 0) goto <D.17820>; else goto <D.17823>;
        <D.17823>:
        D.17824 = mono_loader_get_last_error ();
        if (D.17824 != 0B) goto <D.17820>; else goto <D.17821>;
        <D.17820>:
        D.17825 = class->name;
        D.17826 = class->name_space;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.17826, D.17825);
        mono_loader_clear_error ();
        count = count + 1;
        <D.17821>:
        mono_class_setup_vtable (class);
        D.17822 = class->exception_type;
        if (D.17822 != 0) goto <D.17827>; else goto <D.17829>;
        <D.17829>:
        D.17830 = mono_loader_get_last_error ();
        if (D.17830 != 0B) goto <D.17827>; else goto <D.17828>;
        <D.17827>:
        D.17825 = class->name;
        D.17826 = class->name_space;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.17826, D.17825);
        mono_loader_clear_error ();
        count = count + 1;
        <D.17828>:
      }
      <D.17527>:
      i = i + 1;
      <D.17529>:
      D.17831 = table->rows;
      D.17832 = (int) D.17831;
      if (D.17832 >= i) goto <D.17528>; else goto <D.17530>;
      <D.17530>:
      if (count != 0) goto <D.17833>; else goto <D.17834>;
      <D.17833>:
      D.17797 = 5;
      return D.17797;
      <D.17834>:
      D.17797 = 0;
      return D.17797;
      invalid_image:
      tmp = errors;
      goto <D.17533>;
      <D.17532>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.17835 = info->message;
        D.17836 = info->status;
        D.17837 = desc[D.17836];
        monoeg_g_print ("%s: %s\n", D.17837, D.17835);
        D.17836 = info->status;
        if (D.17836 == 1) goto <D.17838>; else goto <D.17839>;
        <D.17838>:
        count = count + 1;
        <D.17839>:
      }
      tmp = tmp->next;
      <D.17533>:
      if (tmp != 0B) goto <D.17532>; else goto <D.17534>;
      <D.17534>:
      errors.10 = errors;
      mono_free_verify_list (errors.10);
      if (count != 0) goto <D.17841>; else goto <D.17842>;
      <D.17841>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.17842>:
      D.17797 = 1;
      return D.17797;
    }
  finally
    {
      errors = {CLOBBER};
      status = {CLOBBER};
      desc = {CLOBBER};
    }
}


pedump_preload (struct MonoAssemblyName * aname, gchar * * assemblies_path, void * user_data)
{
  gchar * D.17847;
  const char * D.17850;
  const char * D.17851;
  struct MonoAssembly * D.17852;
  struct MonoAssembly * result;
  gboolean refonly;

  result = 0B;
  refonly = (gboolean) user_data;
  if (assemblies_path != 0B) goto <D.17845>; else goto <D.17846>;
  <D.17845>:
  D.17847 = *assemblies_path;
  if (D.17847 != 0B) goto <D.17848>; else goto <D.17849>;
  <D.17848>:
  D.17850 = aname->name;
  D.17851 = aname->culture;
  result = real_load (assemblies_path, D.17851, D.17850, refonly);
  <D.17849>:
  <D.17846>:
  D.17852 = result;
  return D.17852;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.17858;
  unsigned int D.17859;
  gchar * D.17860;
  char D.17861;
  sizetype len.11;
  sizetype D.17865;
  gchar * D.17866;
  int D.17867;
  int D.17869;
  int D.17871;
  int D.17873;
  struct MonoAssembly * D.17875;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.17854>; else goto <D.17857>;
      <D.17857>:
      D.17858 = *culture;
      if (D.17858 == 0) goto <D.17854>; else goto <D.17855>;
      <D.17854>:
      local_culture = "";
      goto <D.17856>;
      <D.17855>:
      local_culture = culture;
      <D.17856>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.17859 = strlen (filename);
      len = (gint) D.17859;
      path = search_path;
      goto <D.17558>;
      <D.17557>:
      D.17860 = *path;
      D.17861 = *D.17860;
      if (D.17861 == 0) goto <D.17862>; else goto <D.17863>;
      <D.17862>:
      // predicted unlikely by continue predictor.
      goto <D.17555>;
      <D.17863>:
      len.11 = (sizetype) len;
      D.17865 = len.11 + 4294967292;
      D.17866 = filename + D.17865;
      strcpy (D.17866, ".dll");
      D.17860 = *path;
      D.17867 = try_load_from (&result, D.17860, local_culture, "", filename, refonly);
      if (D.17867 != 0) goto <D.17556>; else goto <D.17868>;
      <D.17868>:
      len.11 = (sizetype) len;
      D.17865 = len.11 + 4294967292;
      D.17866 = filename + D.17865;
      strcpy (D.17866, ".exe");
      D.17860 = *path;
      D.17869 = try_load_from (&result, D.17860, local_culture, "", filename, refonly);
      if (D.17869 != 0) goto <D.17556>; else goto <D.17870>;
      <D.17870>:
      len.11 = (sizetype) len;
      D.17865 = len.11 + 4294967292;
      D.17866 = filename + D.17865;
      strcpy (D.17866, ".dll");
      D.17860 = *path;
      D.17871 = try_load_from (&result, D.17860, local_culture, name, filename, refonly);
      if (D.17871 != 0) goto <D.17556>; else goto <D.17872>;
      <D.17872>:
      len.11 = (sizetype) len;
      D.17865 = len.11 + 4294967292;
      D.17866 = filename + D.17865;
      strcpy (D.17866, ".exe");
      D.17860 = *path;
      D.17873 = try_load_from (&result, D.17860, local_culture, name, filename, refonly);
      if (D.17873 != 0) goto <D.17556>; else goto <D.17874>;
      <D.17874>:
      <D.17555>:
      path = path + 4;
      <D.17558>:
      D.17860 = *path;
      if (D.17860 != 0B) goto <D.17557>; else goto <D.17556>;
      <D.17556>:
      monoeg_g_free (filename);
      D.17875 = result;
      return D.17875;
    }
  finally
    {
      result = {CLOBBER};
    }
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.17878;
  unsigned int D.17879;

  D.17879 = __builtin_object_size (__dest, 1);
  D.17878 = __builtin___strcpy_chk (__dest, __src, D.17879);
  return D.17878;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.17881;
  struct MonoAssembly * D.17884;
  gboolean D.17885;
  struct MonoAssembly * D.17886;
  _Bool D.17887;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.17881 = monoeg_g_file_test (fullpath, 1);
  if (D.17881 != 0) goto <D.17882>; else goto <D.17883>;
  <D.17882>:
  D.17884 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.17884;
  <D.17883>:
  monoeg_g_free (fullpath);
  D.17886 = *assembly;
  D.17887 = D.17886 != 0B;
  D.17885 = (gboolean) D.17887;
  return D.17885;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.17889;
  int D.17890;
  struct MonoAssembly * D.17893;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.17578>;
  <D.17577>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.17889 = &ass->aname;
    D.17890 = mono_assembly_names_equal (aname, D.17889);
    if (D.17890 != 0) goto <D.17891>; else goto <D.17892>;
    <D.17891>:
    D.17893 = ass;
    return D.17893;
    <D.17892>:
  }
  tmp = tmp->next;
  <D.17578>:
  if (tmp != 0B) goto <D.17577>; else goto <D.17579>;
  <D.17579>:
  D.17893 = 0B;
  return D.17893;
}


pedump_assembly_load_hook (struct MonoAssembly * assembly, void * user_data)
{
  struct GList * loaded_assemblies.12;
  struct GList * loaded_assemblies.13;

  loaded_assemblies.12 = loaded_assemblies;
  loaded_assemblies.13 = monoeg_g_list_prepend (loaded_assemblies.12, assembly);
  loaded_assemblies = loaded_assemblies.13;
}


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

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.17899;
  struct MonoCLIHeader * D.17900;
  unsigned int D.17901;
  struct MonoCLIImageInfo * iinfo;

  iinfo = image->image_info;
  D.17899 = &iinfo->cli_header;
  dump_dotnet_header (D.17899);
  dump_sections (iinfo);
  D.17900 = &iinfo->cli_cli_header;
  dump_cli_header (D.17900);
  dump_strong_name (image);
  dump_public_key (image);
  dump_metadata (image);
  D.17901 = iinfo->cli_cli_header.ch_entry_point;
  dump_methoddef (image, D.17901);
}


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.17902;
  struct MonoPEHeader * D.17903;
  struct MonoPEHeaderNT * D.17904;
  struct MonoPEDatadir * D.17905;

  D.17902 = &header->coff;
  dump_coff_header (D.17902);
  D.17903 = &header->pe;
  dump_pe_header (D.17903);
  D.17904 = &header->nt;
  dump_nt_header (D.17904);
  D.17905 = &header->datadir;
  dump_datadir (D.17905);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.17906;
  int D.17907;
  short unsigned int D.17908;
  int D.17909;
  unsigned int D.17910;
  unsigned int D.17911;
  unsigned int D.17912;
  short unsigned int D.17913;
  int D.17914;
  short unsigned int D.17915;
  int D.17916;

  printf ("\nCOFF Header:\n");
  D.17906 = coff->coff_machine;
  D.17907 = (int) D.17906;
  hex16 ("                Machine", D.17907);
  D.17908 = coff->coff_sections;
  D.17909 = (int) D.17908;
  hex16 ("               Sections", D.17909);
  D.17910 = coff->coff_time;
  hex32 ("             Time stamp", D.17910);
  D.17911 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.17911);
  D.17912 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.17912);
  D.17913 = coff->coff_opt_header_size;
  D.17914 = (int) D.17913;
  hex16 ("   Optional Header Size", D.17914);
  D.17915 = coff->coff_attributes;
  D.17916 = (int) D.17915;
  hex16 ("   \tCharacteristics", D.17916);
}


hex32 (const char * label, guint32 x)
{
  printf ("\t%s: 0x%08x\n", label, x);
}


hex16 (const char * label, guint16 x)
{
  int D.17917;

  D.17917 = (int) x;
  printf ("\t%s: 0x%04x\n", label, D.17917);
}


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.17918;
  int D.17919;
  unsigned char D.17920;
  int D.17921;
  unsigned char D.17922;
  int D.17923;
  unsigned int D.17924;
  unsigned int D.17925;
  unsigned int D.17926;
  unsigned int D.17927;
  unsigned int D.17928;
  unsigned int D.17929;

  printf ("\nPE Header:\n");
  D.17918 = pe->pe_magic;
  D.17919 = (int) D.17918;
  hex16 ("         Magic (0x010b)", D.17919);
  D.17920 = pe->pe_major;
  D.17921 = (int) D.17920;
  hex8 ("             LMajor (6)", D.17921);
  D.17922 = pe->pe_minor;
  D.17923 = (int) D.17922;
  hex8 ("             LMinor (0)", D.17923);
  D.17924 = pe->pe_code_size;
  hex32 ("              Code Size", D.17924);
  D.17925 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.17925);
  D.17926 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.17926);
  D.17927 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.17927);
  D.17928 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.17928);
  D.17929 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.17929);
  printf ("\n");
}


hex8 (const char * label, unsigned char x)
{
  int D.17930;

  D.17930 = (int) x;
  printf ("\t%s: 0x%02x\n", label, D.17930);
}


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.17931;
  unsigned int D.17932;
  unsigned int D.17933;
  short unsigned int D.17934;
  int D.17935;
  short unsigned int D.17936;
  int D.17937;
  short unsigned int D.17938;
  int D.17939;
  short unsigned int D.17940;
  int D.17941;
  short unsigned int D.17942;
  int D.17943;
  short unsigned int D.17944;
  int D.17945;
  unsigned int D.17946;
  unsigned int D.17947;
  unsigned int D.17948;
  unsigned int D.17949;
  short unsigned int D.17950;
  int D.17951;
  short unsigned int D.17952;
  int D.17953;
  unsigned int D.17954;
  unsigned int D.17955;
  unsigned int D.17956;
  unsigned int D.17957;
  unsigned int D.17958;
  unsigned int D.17959;

  printf ("\nNT Header:\n");
  D.17931 = nt->pe_image_base;
  hex32 ("   Image Base (0x400000)", D.17931);
  D.17932 = nt->pe_section_align;
  hex32 ("Section Alignment (8192)", D.17932);
  D.17933 = nt->pe_file_alignment;
  hex32 ("   File Align (512/4096)", D.17933);
  D.17934 = nt->pe_os_major;
  D.17935 = (int) D.17934;
  hex16 ("            OS Major (4)", D.17935);
  D.17936 = nt->pe_os_minor;
  D.17937 = (int) D.17936;
  hex16 ("            OS Minor (0)", D.17937);
  D.17938 = nt->pe_user_major;
  D.17939 = (int) D.17938;
  hex16 ("  \t  User Major (0)", D.17939);
  D.17940 = nt->pe_user_minor;
  D.17941 = (int) D.17940;
  hex16 ("  \t  User Minor (0)", D.17941);
  D.17942 = nt->pe_subsys_major;
  D.17943 = (int) D.17942;
  hex16 ("  \tSubsys major (4)", D.17943);
  D.17944 = nt->pe_subsys_minor;
  D.17945 = (int) D.17944;
  hex16 ("  \tSubsys minor (0)", D.17945);
  D.17946 = nt->pe_reserved_1;
  hex32 (" \t       Reserverd", D.17946);
  D.17947 = nt->pe_image_size;
  hex32 (" \t      Image Size", D.17947);
  D.17948 = nt->pe_header_size;
  hex32 (" \t     Header Size", D.17948);
  D.17949 = nt->pe_checksum;
  hex32 ("            Checksum (0)", D.17949);
  D.17950 = nt->pe_subsys_required;
  D.17951 = (int) D.17950;
  hex16 ("               Subsystem", D.17951);
  D.17952 = nt->pe_dll_flags;
  D.17953 = (int) D.17952;
  hex16 ("           DLL Flags (0)", D.17953);
  D.17954 = nt->pe_stack_reserve;
  hex32 (" Stack Reserve Size (1M)", D.17954);
  D.17955 = nt->pe_stack_commit;
  hex32 ("Stack commit Size (4096)", D.17955);
  D.17956 = nt->pe_heap_reserve;
  hex32 ("  Heap Reserve Size (1M)", D.17956);
  D.17957 = nt->pe_heap_commit;
  hex32 (" Heap Commit Size (4096)", D.17957);
  D.17958 = nt->pe_loader_flags;
  hex32 ("      Loader flags (0x1)", D.17958);
  D.17959 = nt->pe_data_dir_count;
  hex32 ("   Data Directories (16)", D.17959);
}


dump_datadir (struct MonoPEDatadir * dd)
{
  printf ("\nData directories:\n");
  dent ("     Export Table", dd->pe_export_table);
  dent ("     Import Table", dd->pe_import_table);
  dent ("   Resource Table", dd->pe_resource_table);
  dent ("  Exception Table", dd->pe_exception_table);
  dent ("Certificate Table", dd->pe_certificate_table);
  dent ("      Reloc Table", dd->pe_reloc_table);
  dent ("            Debug", dd->pe_debug);
  dent ("        Copyright", dd->pe_copyright);
  dent ("       Global Ptr", dd->pe_global_ptr);
  dent ("        TLS Table", dd->pe_tls_table);
  dent ("Load Config Table", dd->pe_load_config_table);
  dent ("     Bound Import", dd->pe_bound_import);
  dent ("              IAT", dd->pe_iat);
  dent ("Delay Import Desc", dd->pe_delay_import_desc);
  dent ("       CLI Header", dd->pe_cli_header);
}


dent (const char * label, struct MonoPEDirEntry de)
{
  unsigned int D.17960;
  unsigned int D.17961;

  D.17960 = de.size;
  D.17961 = de.rva;
  printf ("\t%s: 0x%08x [0x%08x]\n", label, D.17961, D.17960);
}


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.17962;
  struct MonoSectionTable * D.17963;
  unsigned int i.14;
  unsigned int D.17965;
  struct MonoSectionTable * D.17966;
  const int top;
  int i;

  D.17962 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.17962;
  i = 0;
  goto <D.17453>;
  <D.17452>:
  D.17963 = iinfo->cli_section_tables;
  i.14 = (unsigned int) i;
  D.17965 = i.14 * 40;
  D.17966 = D.17963 + D.17965;
  dump_section_table (D.17966);
  i = i + 1;
  <D.17453>:
  if (i < top) goto <D.17452>; else goto <D.17454>;
  <D.17454>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.17967;
  unsigned int D.17968;
  unsigned int D.17969;
  unsigned int D.17970;
  unsigned int D.17971;
  unsigned int D.17972;
  unsigned int D.17973;
  short unsigned int D.17974;
  int D.17975;
  short unsigned int D.17976;
  int D.17977;
  const char * iftmp.15;
  signed int flags.16;
  const char * iftmp.17;
  unsigned int D.17984;
  const char * iftmp.18;
  unsigned int D.17989;
  const char * iftmp.19;
  unsigned int D.17994;
  const char * iftmp.20;
  unsigned int D.17999;
  const char * iftmp.21;
  unsigned int D.18004;
  const char * iftmp.22;
  unsigned int D.18009;
  const char * iftmp.23;
  unsigned int D.18014;
  const char * iftmp.24;
  unsigned int D.18019;
  const char * iftmp.25;
  unsigned int D.18024;
  guint32 flags;

  flags = st->st_flags;
  D.17967 = &st->st_name;
  printf ("\n\tName: %s\n", D.17967);
  D.17968 = st->st_virtual_size;
  hex32 ("   Virtual Size", D.17968);
  D.17969 = st->st_virtual_address;
  hex32 ("Virtual Address", D.17969);
  D.17970 = st->st_raw_data_size;
  hex32 ("  Raw Data Size", D.17970);
  D.17971 = st->st_raw_data_ptr;
  hex32 ("   Raw Data Ptr", D.17971);
  D.17972 = st->st_reloc_ptr;
  hex32 ("      Reloc Ptr", D.17972);
  D.17973 = st->st_lineno_ptr;
  hex32 ("     LineNo Ptr", D.17973);
  D.17974 = st->st_reloc_count;
  D.17975 = (int) D.17974;
  hex16 ("    Reloc Count", D.17975);
  D.17976 = st->st_line_count;
  D.17977 = (int) D.17976;
  hex16 ("     Line Count", D.17977);
  flags.16 = (signed int) flags;
  if (flags.16 < 0) goto <D.17980>; else goto <D.17981>;
  <D.17980>:
  iftmp.15 = "write";
  goto <D.17982>;
  <D.17981>:
  iftmp.15 = "";
  <D.17982>:
  D.17984 = flags & 1073741824;
  if (D.17984 != 0) goto <D.17985>; else goto <D.17986>;
  <D.17985>:
  iftmp.17 = "read, ";
  goto <D.17987>;
  <D.17986>:
  iftmp.17 = "";
  <D.17987>:
  D.17989 = flags & 536870912;
  if (D.17989 != 0) goto <D.17990>; else goto <D.17991>;
  <D.17990>:
  iftmp.18 = "exec, ";
  goto <D.17992>;
  <D.17991>:
  iftmp.18 = "";
  <D.17992>:
  D.17994 = flags & 268435456;
  if (D.17994 != 0) goto <D.17995>; else goto <D.17996>;
  <D.17995>:
  iftmp.19 = "shared, ";
  goto <D.17997>;
  <D.17996>:
  iftmp.19 = "";
  <D.17997>:
  D.17999 = flags & 134217728;
  if (D.17999 != 0) goto <D.18000>; else goto <D.18001>;
  <D.18000>:
  iftmp.20 = "nopage, ";
  goto <D.18002>;
  <D.18001>:
  iftmp.20 = "";
  <D.18002>:
  D.18004 = flags & 67108864;
  if (D.18004 != 0) goto <D.18005>; else goto <D.18006>;
  <D.18005>:
  iftmp.21 = "nocache, ";
  goto <D.18007>;
  <D.18006>:
  iftmp.21 = "";
  <D.18007>:
  D.18009 = flags & 33554432;
  if (D.18009 != 0) goto <D.18010>; else goto <D.18011>;
  <D.18010>:
  iftmp.22 = "discard, ";
  goto <D.18012>;
  <D.18011>:
  iftmp.22 = "";
  <D.18012>:
  D.18014 = flags & 128;
  if (D.18014 != 0) goto <D.18015>; else goto <D.18016>;
  <D.18015>:
  iftmp.23 = "bss, ";
  goto <D.18017>;
  <D.18016>:
  iftmp.23 = "";
  <D.18017>:
  D.18019 = flags & 64;
  if (D.18019 != 0) goto <D.18020>; else goto <D.18021>;
  <D.18020>:
  iftmp.24 = "data, ";
  goto <D.18022>;
  <D.18021>:
  iftmp.24 = "";
  <D.18022>:
  D.18024 = flags & 32;
  if (D.18024 != 0) goto <D.18025>; else goto <D.18026>;
  <D.18025>:
  iftmp.25 = "code, ";
  goto <D.18027>;
  <D.18026>:
  iftmp.25 = "";
  <D.18027>:
  printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n", iftmp.25, iftmp.24, iftmp.23, iftmp.22, iftmp.21, iftmp.20, iftmp.19, iftmp.18, iftmp.17, iftmp.15);
}


dump_cli_header (struct MonoCLIHeader * ch)
{
  unsigned int D.18028;
  short unsigned int D.18029;
  int D.18030;
  short unsigned int D.18031;
  int D.18032;
  const char * iftmp.26;
  unsigned int D.18034;
  unsigned int D.18035;
  const char * iftmp.27;
  unsigned int D.18040;
  const char * iftmp.28;
  unsigned int D.18045;
  const char * iftmp.29;
  unsigned int D.18050;
  unsigned int D.18054;

  printf ("\n");
  D.18028 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.18028);
  D.18029 = ch->ch_runtime_minor;
  D.18030 = (int) D.18029;
  D.18031 = ch->ch_runtime_major;
  D.18032 = (int) D.18031;
  printf ("         Runtime required: %d.%d\n", D.18032, D.18030);
  D.18034 = ch->ch_flags;
  D.18035 = D.18034 & 8;
  if (D.18035 != 0) goto <D.18036>; else goto <D.18037>;
  <D.18036>:
  iftmp.26 = "strongnamesigned";
  goto <D.18038>;
  <D.18037>:
  iftmp.26 = "notsigned";
  <D.18038>:
  D.18034 = ch->ch_flags;
  D.18040 = D.18034 & 65536;
  if (D.18040 != 0) goto <D.18041>; else goto <D.18042>;
  <D.18041>:
  iftmp.27 = "trackdebug";
  goto <D.18043>;
  <D.18042>:
  iftmp.27 = "no-trackdebug";
  <D.18043>:
  D.18034 = ch->ch_flags;
  D.18045 = D.18034 & 2;
  if (D.18045 != 0) goto <D.18046>; else goto <D.18047>;
  <D.18046>:
  iftmp.28 = "32bits";
  goto <D.18048>;
  <D.18047>:
  iftmp.28 = "32/64";
  <D.18048>:
  D.18034 = ch->ch_flags;
  D.18050 = D.18034 & 1;
  if (D.18050 != 0) goto <D.18051>; else goto <D.18052>;
  <D.18051>:
  iftmp.29 = "ilonly";
  goto <D.18053>;
  <D.18052>:
  iftmp.29 = "contains native";
  <D.18053>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.29, iftmp.28, iftmp.27, iftmp.26);
  dent ("         Metadata", ch->ch_metadata);
  D.18054 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.18054);
  dent ("     Resources at", ch->ch_resources);
  dent ("   Strong Name at", ch->ch_strong_name);
  dent ("  Code Manager at", ch->ch_code_manager_table);
  dent ("  VTableFixups at", ch->ch_vtable_fixups);
  dent ("     EAT jumps at", ch->ch_export_address_table_jumps);
}


dump_strong_name (struct MonoImage * m)
{
  unsigned int size.30;
  guint32 size;
  const char * p;

  try
    {
      p = mono_image_get_strong_name (m, &size);
      size.30 = size;
      dump_blob ("\nStrong name:", p, size.30);
    }
  finally
    {
      size = {CLOBBER};
    }
}


dump_blob (const char * desc, const char * p, guint32 size)
{
  unsigned int i.31;
  unsigned int D.18059;
  sizetype i.32;
  const char * D.18063;
  char D.18064;
  int D.18065;
  int D.18066;
  unsigned int i.33;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.18056>; else goto <D.18057>;
  <D.18056>:
  printf (" none\n");
  return;
  <D.18057>:
  i = 0;
  goto <D.17425>;
  <D.17424>:
  i.31 = (unsigned int) i;
  D.18059 = i.31 & 15;
  if (D.18059 == 0) goto <D.18060>; else goto <D.18061>;
  <D.18060>:
  printf ("\n\t");
  <D.18061>:
  i.32 = (sizetype) i;
  D.18063 = p + i.32;
  D.18064 = *D.18063;
  D.18065 = (int) D.18064;
  D.18066 = D.18065 & 255;
  printf (" %02X", D.18066);
  i = i + 1;
  <D.17425>:
  i.33 = (unsigned int) i;
  if (i.33 < size) goto <D.17424>; else goto <D.17426>;
  <D.17426>:
  printf ("\n");
}


dump_public_key (struct MonoImage * m)
{
  unsigned int size.34;
  guint32 size;
  const char * p;

  try
    {
      p = mono_image_get_public_key (m, &size);
      size.34 = size;
      dump_blob ("\nPublic key:", p, size.34);
    }
  finally
    {
      size = {CLOBBER};
    }
}


dump_metadata (struct MonoImage * meta)
{
  <unnamed-unsigned:24> D.18070;
  const char * D.18073;
  int D.18074;
  char * D.18075;
  int D.18076;
  int D.18077;
  unsigned int D.18078;
  unsigned char D.18079;
  int D.18080;
  int D.18081;
  const char * D.18082;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.17475>;
  <D.17474>:
  D.18070 = meta->tables[table].rows;
  if (D.18070 == 0) goto <D.18071>; else goto <D.18072>;
  <D.18071>:
  // predicted unlikely by continue predictor.
  goto <D.17473>;
  <D.18072>:
  D.18073 = meta->tables[table].base;
  D.18074 = (int) D.18073;
  D.18075 = meta->raw_data;
  D.18076 = (int) D.18075;
  D.18077 = D.18074 - D.18076;
  D.18078 = (unsigned int) D.18077;
  D.18079 = meta->tables[table].row_size;
  D.18080 = (int) D.18079;
  D.18070 = meta->tables[table].rows;
  D.18081 = (int) D.18070;
  D.18082 = mono_meta_table_name (table);
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.18082, D.18081, D.18080, D.18078);
  <D.17473>:
  table = table + 1;
  <D.17475>:
  if (table <= 44) goto <D.17474>; else goto <D.17476>;
  <D.17476>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.18083;
  int D.18084;
  short int D.18085;
  int D.18086;
  char * D.18087;

  printf ("\nMetadata header:\n");
  D.18083 = meta->md_version_minor;
  D.18084 = (int) D.18083;
  D.18085 = meta->md_version_major;
  D.18086 = (int) D.18085;
  printf ("           Version: %d.%d\n", D.18086, D.18084);
  D.18087 = meta->version;
  printf ("    Version string: %s\n", D.18087);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.18088;
  struct MonoStreamHeader * D.18089;
  struct MonoStreamHeader * D.18090;
  struct MonoStreamHeader * D.18091;
  struct MonoStreamHeader * D.18092;

  printf ("\nMetadata pointers:\n");
  D.18088 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.18088);
  D.18089 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.18089);
  D.18090 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.18090);
  D.18091 = &meta->heap_us;
  dsh ("\tUser string", meta, D.18091);
  D.18092 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.18092);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  unsigned int D.18093;
  const char * D.18094;
  const char * D.18095;
  int D.18096;
  char * D.18097;
  int D.18098;
  int D.18099;
  int D.18100;
  int D.18101;

  D.18093 = sh->size;
  D.18093 = sh->size;
  D.18094 = sh->data;
  D.18093 = sh->size;
  D.18095 = D.18094 + D.18093;
  D.18096 = (int) D.18095;
  D.18097 = meta->raw_metadata;
  D.18098 = (int) D.18097;
  D.18099 = D.18096 - D.18098;
  D.18094 = sh->data;
  D.18100 = (int) D.18094;
  D.18097 = meta->raw_metadata;
  D.18098 = (int) D.18097;
  D.18101 = D.18100 - D.18098;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.18101, D.18099, D.18093, D.18093);
}


dump_methoddef (struct MonoImage * metadata, guint32 token)
{
  unsigned int D.18104;
  const char * loc;

  if (token == 0) goto <D.18102>; else goto <D.18103>;
  <D.18102>:
  return;
  <D.18103>:
  loc = mono_metadata_locate_token (metadata, token);
  D.18104 = MEM[(const guint32 *)loc];
  printf ("RVA for Entry Point: 0x%08x\n", D.18104);
}


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.35;
  int D.18109;
  int D.18110;
  unsigned int D.18111;
  struct MonoType * D.18116;
  struct MonoMethodSignature * D.18117;
  const char * D.18120;
  struct MonoMethodSignature * D.18122;
  const char * D.18123;
  char * D.18124;
  <unnamed type> D.18125;
  const char * D.18126;
  <unnamed-unsigned:24> D.18133;
  int D.18134;
  int D.18137;
  struct GSList * errors;
  struct GSList * tmp;
  int count;
  int verifiable;
  const char * desc[9];

  try
    {
      count = 0;
      verifiable = 0;
      desc[0] = "Ok";
      desc[1] = "Error";
      desc[2] = "Warning";
      desc[3] = 0B;
      desc[4] = "CLS";
      desc[5] = 0B;
      desc[6] = 0B;
      desc[7] = 0B;
      desc[8] = "Not Verifiable";
      verify_code.35 = verify_code;
      if (verify_code.35 != 0) goto <D.18107>; else goto <D.18108>;
      <D.18107>:
      {
        int i;
        struct MonoTableInfo * m;

        m = &image->tables[6];
        i = 0;
        goto <D.17507>;
        <D.17506>:
        {
          struct MonoMethod * method;

          mono_loader_clear_error ();
          D.18109 = i + 1;
          D.18110 = D.18109 | 100663296;
          D.18111 = (unsigned int) D.18110;
          method = mono_get_method (image, D.18111, 0B);
          if (method == 0B) goto <D.18112>; else goto <D.18113>;
          <D.18112>:
          D.18109 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.18109);
          // predicted unlikely by continue predictor.
          goto <D.17498>;
          <D.18113>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.18114>; else goto <D.18115>;
          <D.18114>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.18116 = &klass->byval_arg;
            name = mono_type_full_name (D.18116);
            D.18117 = mono_method_signature (method);
            if (D.18117 == 0B) goto <D.18118>; else goto <D.18119>;
            <D.18118>:
            D.18120 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.18120);
            goto <D.18121>;
            <D.18119>:
            {
              char * sig;

              D.18122 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.18122, 0);
              D.18123 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.18123, sig);
              monoeg_g_free (sig);
            }
            <D.18121>:
            monoeg_g_free (name);
          }
          <D.18115>:
          tmp = errors;
          goto <D.17504>;
          <D.17503>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.18124 = info->message;
            D.18125 = info->status;
            D.18126 = desc[D.18125];
            monoeg_g_print ("%s: %s\n", D.18126, D.18124);
            D.18125 = info->status;
            if (D.18125 == 1) goto <D.18127>; else goto <D.18128>;
            <D.18127>:
            count = count + 1;
            verifiable = 3;
            <D.18128>:
            D.18125 = info->status;
            if (D.18125 == 8) goto <D.18129>; else goto <D.18130>;
            <D.18129>:
            if (verifiable <= 1) goto <D.18131>; else goto <D.18132>;
            <D.18131>:
            verifiable = 2;
            <D.18132>:
            <D.18130>:
          }
          tmp = tmp->next;
          <D.17504>:
          if (tmp != 0B) goto <D.17503>; else goto <D.17505>;
          <D.17505>:
          mono_free_verify_list (errors);
        }
        <D.17498>:
        i = i + 1;
        <D.17507>:
        D.18133 = m->rows;
        D.18134 = (int) D.18133;
        if (D.18134 > i) goto <D.17506>; else goto <D.17508>;
        <D.17508>:
      }
      <D.18108>:
      if (count != 0) goto <D.18135>; else goto <D.18136>;
      <D.18135>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18136>:
      D.18137 = verifiable;
      return D.18137;
    }
  finally
    {
      desc = {CLOBBER};
    }
}