main (int argc, char * * argv)
{
  unsigned int i.0;
  unsigned int D.17624;
  char * * D.17625;
  char * D.17626;
  char D.17627;
  int D.17577;
  int iftmp.1;
  int D.17576;
  const char[7] * D.17633;
  unsigned char D.17634;
  int D.17635;
  unsigned char D.17636;
  int D.17637;
  const unsigned char * D.17642;
  unsigned char D.17643;
  int D.17644;
  const unsigned char * D.17645;
  unsigned char D.17646;
  int D.17647;
  const unsigned char * D.17652;
  unsigned char D.17653;
  int D.17654;
  const unsigned char * D.17655;
  unsigned char D.17656;
  int D.17657;
  const unsigned char * D.17662;
  unsigned char D.17663;
  int D.17664;
  const unsigned char * D.17665;
  unsigned char D.17666;
  int D.17667;
  int D.17586;
  int iftmp.2;
  int D.17585;
  const char[9] * D.17675;
  unsigned char D.17676;
  int D.17677;
  unsigned char D.17678;
  int D.17679;
  const unsigned char * D.17684;
  unsigned char D.17685;
  int D.17686;
  const unsigned char * D.17687;
  unsigned char D.17688;
  int D.17689;
  const unsigned char * D.17694;
  unsigned char D.17695;
  int D.17696;
  const unsigned char * D.17697;
  unsigned char D.17698;
  int D.17699;
  const unsigned char * D.17704;
  unsigned char D.17705;
  int D.17706;
  const unsigned char * D.17707;
  unsigned char D.17708;
  int D.17709;
  int verify_pe.3;
  int D.17599;
  const char * D.17719;
  unsigned int D.17722;
  unsigned int verify_flags.4;
  unsigned int D.17738;
  int verify_code.5;
  int D.17750;
  struct _IO_FILE * stderr.6;
  int dump_data.7;
  unsigned int D.17763;
  unsigned int D.17764;
  struct MonoImage * D.17769;
  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 = *$LC10;
      flag_vals = *$LC11;
      verify_flags = 128;
      run_new_metadata_verifier = 0;
      i = 1;
      goto <D.17588>;
      <D.17587>:
      i.0 = (unsigned int) i;
      D.17624 = i.0 * 4;
      D.17625 = argv + D.17624;
      D.17626 = *D.17625;
      D.17627 = *D.17626;
      if (D.17627 != 45) goto <D.17628>; else goto <D.17629>;
      <D.17628>:
      i.0 = (unsigned int) i;
      D.17624 = i.0 * 4;
      D.17625 = argv + D.17624;
      file = *D.17625;
      // predicted unlikely by continue predictor.
      goto <D.17568>;
      <D.17629>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          i.0 = (unsigned int) i;
          D.17624 = i.0 * 4;
          D.17625 = argv + D.17624;
          __s2 = *D.17625;
          D.17633 = "--help";
          D.17634 = MEM[(const unsigned char *)D.17633];
          D.17635 = (int) D.17634;
          D.17636 = *__s2;
          D.17637 = (int) D.17636;
          __result = D.17635 - D.17637;
          {
            if (__s2_len != 0) goto <D.17638>; else goto <D.17639>;
            <D.17638>:
            if (__result == 0) goto <D.17640>; else goto <D.17641>;
            <D.17640>:
            D.17642 = &MEM[(void *)"--help" + 1B];
            D.17643 = *D.17642;
            D.17644 = (int) D.17643;
            D.17645 = __s2 + 1;
            D.17646 = *D.17645;
            D.17647 = (int) D.17646;
            __result = D.17644 - D.17647;
            if (__s2_len > 1) goto <D.17648>; else goto <D.17649>;
            <D.17648>:
            if (__result == 0) goto <D.17650>; else goto <D.17651>;
            <D.17650>:
            D.17652 = &MEM[(void *)"--help" + 2B];
            D.17653 = *D.17652;
            D.17654 = (int) D.17653;
            D.17655 = __s2 + 2;
            D.17656 = *D.17655;
            D.17657 = (int) D.17656;
            __result = D.17654 - D.17657;
            if (__s2_len > 2) goto <D.17658>; else goto <D.17659>;
            <D.17658>:
            if (__result == 0) goto <D.17660>; else goto <D.17661>;
            <D.17660>:
            D.17662 = &MEM[(void *)"--help" + 3B];
            D.17663 = *D.17662;
            D.17664 = (int) D.17663;
            D.17665 = __s2 + 3;
            D.17666 = *D.17665;
            D.17667 = (int) D.17666;
            __result = D.17664 - D.17667;
            <D.17661>:
            <D.17659>:
            <D.17651>:
            <D.17649>:
            <D.17641>:
            <D.17639>:
          }
          D.17576 = __result;
        }
        iftmp.1 = -D.17576;
        goto <D.17668>;
        <D.17632>:
        i.0 = (unsigned int) i;
        D.17624 = i.0 * 4;
        D.17625 = argv + D.17624;
        D.17626 = *D.17625;
        iftmp.1 = __builtin_strcmp (D.17626, "--help");
        <D.17668>:
        D.17577 = iftmp.1;
      }
      if (D.17577 == 0) goto <D.17669>; else goto <D.17670>;
      <D.17669>:
      usage ();
      goto <D.17671>;
      <D.17670>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          i.0 = (unsigned int) i;
          D.17624 = i.0 * 4;
          D.17625 = argv + D.17624;
          __s2 = *D.17625;
          D.17675 = "--verify";
          D.17676 = MEM[(const unsigned char *)D.17675];
          D.17677 = (int) D.17676;
          D.17678 = *__s2;
          D.17679 = (int) D.17678;
          __result = D.17677 - D.17679;
          {
            if (__s2_len != 0) goto <D.17680>; else goto <D.17681>;
            <D.17680>:
            if (__result == 0) goto <D.17682>; else goto <D.17683>;
            <D.17682>:
            D.17684 = &MEM[(void *)"--verify" + 1B];
            D.17685 = *D.17684;
            D.17686 = (int) D.17685;
            D.17687 = __s2 + 1;
            D.17688 = *D.17687;
            D.17689 = (int) D.17688;
            __result = D.17686 - D.17689;
            if (__s2_len > 1) goto <D.17690>; else goto <D.17691>;
            <D.17690>:
            if (__result == 0) goto <D.17692>; else goto <D.17693>;
            <D.17692>:
            D.17694 = &MEM[(void *)"--verify" + 2B];
            D.17695 = *D.17694;
            D.17696 = (int) D.17695;
            D.17697 = __s2 + 2;
            D.17698 = *D.17697;
            D.17699 = (int) D.17698;
            __result = D.17696 - D.17699;
            if (__s2_len > 2) goto <D.17700>; else goto <D.17701>;
            <D.17700>:
            if (__result == 0) goto <D.17702>; else goto <D.17703>;
            <D.17702>:
            D.17704 = &MEM[(void *)"--verify" + 3B];
            D.17705 = *D.17704;
            D.17706 = (int) D.17705;
            D.17707 = __s2 + 3;
            D.17708 = *D.17707;
            D.17709 = (int) D.17708;
            __result = D.17706 - D.17709;
            <D.17703>:
            <D.17701>:
            <D.17693>:
            <D.17691>:
            <D.17683>:
            <D.17681>:
          }
          D.17585 = __result;
        }
        iftmp.2 = -D.17585;
        goto <D.17710>;
        <D.17674>:
        i.0 = (unsigned int) i;
        D.17624 = i.0 * 4;
        D.17625 = argv + D.17624;
        D.17626 = *D.17625;
        iftmp.2 = __builtin_strcmp (D.17626, "--verify");
        <D.17710>:
        D.17586 = iftmp.2;
      }
      if (D.17586 == 0) goto <D.17711>; else goto <D.17712>;
      <D.17711>:
      verify_pe = 1;
      dump_data = 0;
      i = i + 1;
      i.0 = (unsigned int) i;
      D.17624 = i.0 * 4;
      D.17625 = argv + D.17624;
      flags = *D.17625;
      goto <D.17713>;
      <D.17712>:
      usage ();
      <D.17713>:
      <D.17671>:
      <D.17568>:
      i = i + 1;
      <D.17588>:
      if (i < argc) goto <D.17587>; else goto <D.17589>;
      <D.17589>:
      if (file == 0B) goto <D.17714>; else goto <D.17715>;
      <D.17714>:
      usage ();
      <D.17715>:
      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.17717>; else goto <D.17718>;
      <D.17717>:
      {
        char * tok;

        tok = strtok (flags, ",");
        verify_metadata = 1;
        verify_code = 0;
        goto <D.17604>;
        <D.17603>:
        i = 0;
        goto <D.17602>;
        <D.17601>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.17719 = flag_desc[i];
          D.17599 = __builtin_strcmp (tok, D.17719);
        }
        if (D.17599 == 0) goto <D.17720>; else goto <D.17721>;
        <D.17720>:
        D.17722 = flag_vals[i];
        if (D.17722 == 8) goto <D.17723>; else goto <D.17724>;
        <D.17723>:
        verify_metadata = 0;
        verify_code = 1;
        goto <D.17725>;
        <D.17724>:
        D.17722 = flag_vals[i];
        if (D.17722 == 7) goto <D.17726>; else goto <D.17727>;
        <D.17726>:
        verify_code = 1;
        goto <D.17728>;
        <D.17727>:
        D.17722 = flag_vals[i];
        if (D.17722 == 9) goto <D.17729>; else goto <D.17730>;
        <D.17729>:
        verify_metadata = 0;
        run_new_metadata_verifier = 1;
        goto <D.17731>;
        <D.17730>:
        D.17722 = flag_vals[i];
        if (D.17722 == 10) goto <D.17732>; else goto <D.17733>;
        <D.17732>:
        verify_partial_md = 1;
        <D.17733>:
        <D.17731>:
        <D.17728>:
        <D.17725>:
        D.17722 = flag_vals[i];
        if (D.17722 == 134217728) goto <D.17734>; else goto <D.17735>;
        <D.17734>:
        verifier_mode = 1;
        goto <D.17736>;
        <D.17735>:
        D.17722 = flag_vals[i];
        verify_flags.4 = (unsigned int) verify_flags;
        D.17738 = D.17722 | verify_flags.4;
        verify_flags = (int) D.17738;
        <D.17736>:
        goto <D.17600>;
        <D.17721>:
        i = i + 1;
        <D.17602>:
        D.17719 = flag_desc[i];
        if (D.17719 != 0B) goto <D.17601>; else goto <D.17600>;
        <D.17600>:
        D.17719 = flag_desc[i];
        if (D.17719 == 0B) goto <D.17739>; else goto <D.17740>;
        <D.17739>:
        monoeg_g_print ("Unknown verify flag %s\n", tok);
        <D.17740>:
        tok = strtok (0B, ",");
        <D.17604>:
        if (tok != 0B) goto <D.17603>; else goto <D.17605>;
        <D.17605>:
        mono_verifier_set_mode (verifier_mode);
      }
      <D.17718>:
      verify_pe.3 = verify_pe;
      if (verify_pe.3 != 0) goto <D.17741>; else goto <D.17743>;
      <D.17743>:
      if (run_new_metadata_verifier != 0) goto <D.17741>; else goto <D.17742>;
      <D.17741>:
      run_new_metadata_verifier = 1;
      <D.17742>:
      if (run_new_metadata_verifier != 0) goto <D.17744>; else goto <D.17745>;
      <D.17744>:
      mono_verifier_set_mode (verifier_mode);
      image_result = verify_image_file (file);
      if (image_result == 1) goto <D.17746>; else goto <D.17748>;
      <D.17748>:
      verify_code.5 = verify_code;
      if (verify_code.5 == 0) goto <D.17746>; else goto <D.17747>;
      <D.17746>:
      D.17750 = image_result;
      return D.17750;
      <D.17747>:
      <D.17745>:
      image = mono_image_open (file, 0B);
      if (image == 0B) goto <D.17751>; else goto <D.17752>;
      <D.17751>:
      stderr.6 = stderr;
      fprintf (stderr.6, "Cannot open image %s\n", file);
      exit (1);
      <D.17752>:
      dump_data.7 = dump_data;
      if (dump_data.7 != 0) goto <D.17755>; else goto <D.17756>;
      <D.17755>:
      dump_dotnet_iinfo (image);
      <D.17756>:
      verify_pe.3 = verify_pe;
      if (verify_pe.3 != 0) goto <D.17757>; else goto <D.17758>;
      <D.17757>:
      {
        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.17759>; else goto <D.17760>;
            <D.17759>:
            image = mono_image_open (file, &status);
            if (image != 0B) goto <D.17761>; else goto <D.17762>;
            <D.17761>:
            D.17763 = BIT_FIELD_REF <*image, 32, 3904>;
            D.17764 = D.17763 & 16777215;
            if (D.17764 == 0) goto <D.17765>; else goto <D.17766>;
            <D.17765>:
            assembly = monoeg_malloc0 (92);
            assembly->in_gac = 0;
            assembly->image = image;
            image->assembly = assembly;
            <D.17766>:
            <D.17762>:
            <D.17760>:
            if (assembly == 0B) goto <D.17767>; else goto <D.17768>;
            <D.17767>:
            monoeg_g_print ("Could not open assembly %s\n", file);
            D.17750 = 4;
            return D.17750;
            <D.17768>:
            D.17769 = assembly->image;
            code_result = dump_verify_info (D.17769, verify_flags);
            if (code_result != 0) goto <D.17771>; else goto <D.17772>;
            <D.17771>:
            iftmp.8 = code_result;
            goto <D.17773>;
            <D.17772>:
            iftmp.8 = image_result;
            <D.17773>:
            D.17750 = iftmp.8;
            return D.17750;
          }
        finally
          {
            status = {CLOBBER};
          }
      }
      <D.17758>:
      mono_image_close (image);
      D.17750 = 0;
      return D.17750;
    }
  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.17777;

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


verify_image_file (const char * fname)
{
  int D.17787;
  int D.17788;
  int D.17790;
  int D.17793;
  int D.17795;
  int D.17798;
  struct MonoAssemblyName * D.17800;
  char * D.17801;
  int verify_partial_md.9;
  int D.17805;
  int D.17807;
  unsigned char D.17812;
  struct MonoLoaderError * D.17814;
  const char * D.17815;
  const char * D.17816;
  struct MonoLoaderError * D.17820;
  <unnamed-unsigned:24> D.17821;
  int D.17822;
  <unnamed type> D.17825;
  const char * D.17826;
  char * D.17827;
  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 = *$LC17;
      image = mono_image_open_raw (fname, &status);
      if (image == 0B) goto <D.17785>; else goto <D.17786>;
      <D.17785>:
      printf ("Could not open %s\n", fname);
      D.17787 = 1;
      return D.17787;
      <D.17786>:
      D.17788 = mono_verifier_verify_pe_data (image, &errors);
      if (D.17788 == 0) goto invalid_image; else goto <D.17789>;
      <D.17789>:
      D.17790 = mono_image_load_pe_data (image);
      if (D.17790 == 0) goto <D.17791>; else goto <D.17792>;
      <D.17791>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.17787 = 1;
      return D.17787;
      <D.17792>:
      D.17793 = mono_verifier_verify_cli_data (image, &errors);
      if (D.17793 == 0) goto invalid_image; else goto <D.17794>;
      <D.17794>:
      D.17795 = mono_image_load_cli_data (image);
      if (D.17795 == 0) goto <D.17796>; else goto <D.17797>;
      <D.17796>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.17787 = 1;
      return D.17787;
      <D.17797>:
      D.17798 = mono_verifier_verify_table_data (image, &errors);
      if (D.17798 == 0) goto invalid_image; else goto <D.17799>;
      <D.17799>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (92);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.17800 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.17800);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.17801 = image->version;
      mono_init_version ("pedump", D.17801);
      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.17803>; else goto <D.17804>;
      <D.17803>:
      D.17805 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.17805 == 0) goto invalid_image; else goto <D.17806>;
      <D.17806>:
      <D.17804>:
      table = &image->tables[2];
      i = 1;
      goto <D.17503>;
      <D.17502>:
      {
        guint32 token;
        struct MonoClass * class;

        D.17807 = i | 33554432;
        token = (guint32) D.17807;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.17808>; else goto <D.17809>;
        <D.17808>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.17501>;
        <D.17809>:
        mono_class_init (class);
        D.17812 = class->exception_type;
        if (D.17812 != 0) goto <D.17810>; else goto <D.17813>;
        <D.17813>:
        D.17814 = mono_loader_get_last_error ();
        if (D.17814 != 0B) goto <D.17810>; else goto <D.17811>;
        <D.17810>:
        D.17815 = class->name_space;
        D.17816 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.17815, D.17816);
        mono_loader_clear_error ();
        count = count + 1;
        <D.17811>:
        mono_class_setup_vtable (class);
        D.17812 = class->exception_type;
        if (D.17812 != 0) goto <D.17817>; else goto <D.17819>;
        <D.17819>:
        D.17820 = mono_loader_get_last_error ();
        if (D.17820 != 0B) goto <D.17817>; else goto <D.17818>;
        <D.17817>:
        D.17815 = class->name_space;
        D.17816 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.17815, D.17816);
        mono_loader_clear_error ();
        count = count + 1;
        <D.17818>:
      }
      <D.17501>:
      i = i + 1;
      <D.17503>:
      D.17821 = table->rows;
      D.17822 = (int) D.17821;
      if (D.17822 >= i) goto <D.17502>; else goto <D.17504>;
      <D.17504>:
      if (count != 0) goto <D.17823>; else goto <D.17824>;
      <D.17823>:
      D.17787 = 5;
      return D.17787;
      <D.17824>:
      D.17787 = 0;
      return D.17787;
      invalid_image:
      tmp = errors;
      goto <D.17507>;
      <D.17506>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.17825 = info->status;
        D.17826 = desc[D.17825];
        D.17827 = info->message;
        monoeg_g_print ("%s: %s\n", D.17826, D.17827);
        D.17825 = info->status;
        if (D.17825 == 1) goto <D.17828>; else goto <D.17829>;
        <D.17828>:
        count = count + 1;
        <D.17829>:
      }
      tmp = tmp->next;
      <D.17507>:
      if (tmp != 0B) goto <D.17506>; else goto <D.17508>;
      <D.17508>:
      errors.10 = errors;
      mono_free_verify_list (errors.10);
      if (count != 0) goto <D.17831>; else goto <D.17832>;
      <D.17831>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.17832>:
      D.17787 = 1;
      return D.17787;
    }
  finally
    {
      errors = {CLOBBER};
      status = {CLOBBER};
      desc = {CLOBBER};
    }
}


pedump_preload (struct MonoAssemblyName * aname, gchar * * assemblies_path, void * user_data)
{
  gchar * D.17837;
  const char * D.17840;
  const char * D.17841;
  struct MonoAssembly * D.17842;
  struct MonoAssembly * result;
  gboolean refonly;

  result = 0B;
  refonly = (gboolean) user_data;
  if (assemblies_path != 0B) goto <D.17835>; else goto <D.17836>;
  <D.17835>:
  D.17837 = *assemblies_path;
  if (D.17837 != 0B) goto <D.17838>; else goto <D.17839>;
  <D.17838>:
  D.17840 = aname->culture;
  D.17841 = aname->name;
  result = real_load (assemblies_path, D.17840, D.17841, refonly);
  <D.17839>:
  <D.17836>:
  D.17842 = result;
  return D.17842;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.17848;
  unsigned int D.17849;
  gchar * D.17850;
  char D.17851;
  sizetype len.11;
  sizetype D.17855;
  gchar * D.17856;
  int D.17857;
  int D.17859;
  int D.17861;
  int D.17863;
  struct MonoAssembly * D.17865;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.17844>; else goto <D.17847>;
      <D.17847>:
      D.17848 = *culture;
      if (D.17848 == 0) goto <D.17844>; else goto <D.17845>;
      <D.17844>:
      local_culture = "";
      goto <D.17846>;
      <D.17845>:
      local_culture = culture;
      <D.17846>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.17849 = strlen (filename);
      len = (gint) D.17849;
      path = search_path;
      goto <D.17532>;
      <D.17531>:
      D.17850 = *path;
      D.17851 = *D.17850;
      if (D.17851 == 0) goto <D.17852>; else goto <D.17853>;
      <D.17852>:
      // predicted unlikely by continue predictor.
      goto <D.17529>;
      <D.17853>:
      len.11 = (sizetype) len;
      D.17855 = len.11 + 4294967292;
      D.17856 = filename + D.17855;
      strcpy (D.17856, ".dll");
      D.17850 = *path;
      D.17857 = try_load_from (&result, D.17850, local_culture, "", filename, refonly);
      if (D.17857 != 0) goto <D.17530>; else goto <D.17858>;
      <D.17858>:
      len.11 = (sizetype) len;
      D.17855 = len.11 + 4294967292;
      D.17856 = filename + D.17855;
      strcpy (D.17856, ".exe");
      D.17850 = *path;
      D.17859 = try_load_from (&result, D.17850, local_culture, "", filename, refonly);
      if (D.17859 != 0) goto <D.17530>; else goto <D.17860>;
      <D.17860>:
      len.11 = (sizetype) len;
      D.17855 = len.11 + 4294967292;
      D.17856 = filename + D.17855;
      strcpy (D.17856, ".dll");
      D.17850 = *path;
      D.17861 = try_load_from (&result, D.17850, local_culture, name, filename, refonly);
      if (D.17861 != 0) goto <D.17530>; else goto <D.17862>;
      <D.17862>:
      len.11 = (sizetype) len;
      D.17855 = len.11 + 4294967292;
      D.17856 = filename + D.17855;
      strcpy (D.17856, ".exe");
      D.17850 = *path;
      D.17863 = try_load_from (&result, D.17850, local_culture, name, filename, refonly);
      if (D.17863 != 0) goto <D.17530>; else goto <D.17864>;
      <D.17864>:
      <D.17529>:
      path = path + 4;
      <D.17532>:
      D.17850 = *path;
      if (D.17850 != 0B) goto <D.17531>; else goto <D.17530>;
      <D.17530>:
      monoeg_g_free (filename);
      D.17865 = result;
      return D.17865;
    }
  finally
    {
      result = {CLOBBER};
    }
}


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

  D.17869 = __builtin_object_size (__dest, 1);
  D.17868 = __builtin___strcpy_chk (__dest, __src, D.17869);
  return D.17868;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.17871;
  struct MonoAssembly * D.17874;
  gboolean D.17875;
  struct MonoAssembly * D.17876;
  _Bool D.17877;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.17871 = monoeg_g_file_test (fullpath, 1);
  if (D.17871 != 0) goto <D.17872>; else goto <D.17873>;
  <D.17872>:
  D.17874 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.17874;
  <D.17873>:
  monoeg_g_free (fullpath);
  D.17876 = *assembly;
  D.17877 = D.17876 != 0B;
  D.17875 = (gboolean) D.17877;
  return D.17875;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.17879;
  int D.17880;
  struct MonoAssembly * D.17883;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.17552>;
  <D.17551>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.17879 = &ass->aname;
    D.17880 = mono_assembly_names_equal (aname, D.17879);
    if (D.17880 != 0) goto <D.17881>; else goto <D.17882>;
    <D.17881>:
    D.17883 = ass;
    return D.17883;
    <D.17882>:
  }
  tmp = tmp->next;
  <D.17552>:
  if (tmp != 0B) goto <D.17551>; else goto <D.17553>;
  <D.17553>:
  D.17883 = 0B;
  return D.17883;
}


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.17887;

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.17889;
  struct MonoCLIHeader * D.17890;
  unsigned int D.17891;
  struct MonoCLIImageInfo * iinfo;

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


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.17892;
  struct MonoPEHeader * D.17893;
  struct MonoPEHeaderNT * D.17894;
  struct MonoPEDatadir * D.17895;

  D.17892 = &header->coff;
  dump_coff_header (D.17892);
  D.17893 = &header->pe;
  dump_pe_header (D.17893);
  D.17894 = &header->nt;
  dump_nt_header (D.17894);
  D.17895 = &header->datadir;
  dump_datadir (D.17895);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.17896;
  int D.17897;
  short unsigned int D.17898;
  int D.17899;
  unsigned int D.17900;
  unsigned int D.17901;
  unsigned int D.17902;
  short unsigned int D.17903;
  int D.17904;
  short unsigned int D.17905;
  int D.17906;

  printf ("\nCOFF Header:\n");
  D.17896 = coff->coff_machine;
  D.17897 = (int) D.17896;
  hex16 ("                Machine", D.17897);
  D.17898 = coff->coff_sections;
  D.17899 = (int) D.17898;
  hex16 ("               Sections", D.17899);
  D.17900 = coff->coff_time;
  hex32 ("             Time stamp", D.17900);
  D.17901 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.17901);
  D.17902 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.17902);
  D.17903 = coff->coff_opt_header_size;
  D.17904 = (int) D.17903;
  hex16 ("   Optional Header Size", D.17904);
  D.17905 = coff->coff_attributes;
  D.17906 = (int) D.17905;
  hex16 ("   \tCharacteristics", D.17906);
}


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


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

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


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.17908;
  int D.17909;
  unsigned char D.17910;
  int D.17911;
  unsigned char D.17912;
  int D.17913;
  unsigned int D.17914;
  unsigned int D.17915;
  unsigned int D.17916;
  unsigned int D.17917;
  unsigned int D.17918;
  unsigned int D.17919;

  printf ("\nPE Header:\n");
  D.17908 = pe->pe_magic;
  D.17909 = (int) D.17908;
  hex16 ("         Magic (0x010b)", D.17909);
  D.17910 = pe->pe_major;
  D.17911 = (int) D.17910;
  hex8 ("             LMajor (6)", D.17911);
  D.17912 = pe->pe_minor;
  D.17913 = (int) D.17912;
  hex8 ("             LMinor (0)", D.17913);
  D.17914 = pe->pe_code_size;
  hex32 ("              Code Size", D.17914);
  D.17915 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.17915);
  D.17916 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.17916);
  D.17917 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.17917);
  D.17918 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.17918);
  D.17919 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.17919);
  printf ("\n");
}


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

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


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.17921;
  unsigned int D.17922;
  unsigned int D.17923;
  short unsigned int D.17924;
  int D.17925;
  short unsigned int D.17926;
  int D.17927;
  short unsigned int D.17928;
  int D.17929;
  short unsigned int D.17930;
  int D.17931;
  short unsigned int D.17932;
  int D.17933;
  short unsigned int D.17934;
  int D.17935;
  unsigned int D.17936;
  unsigned int D.17937;
  unsigned int D.17938;
  unsigned int D.17939;
  short unsigned int D.17940;
  int D.17941;
  short unsigned int D.17942;
  int D.17943;
  unsigned int D.17944;
  unsigned int D.17945;
  unsigned int D.17946;
  unsigned int D.17947;
  unsigned int D.17948;
  unsigned int D.17949;

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


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.17950;
  unsigned int D.17951;

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


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.17952;
  struct MonoSectionTable * D.17953;
  unsigned int i.14;
  unsigned int D.17955;
  struct MonoSectionTable * D.17956;
  const int top;
  int i;

  D.17952 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.17952;
  i = 0;
  goto <D.17427>;
  <D.17426>:
  D.17953 = iinfo->cli_section_tables;
  i.14 = (unsigned int) i;
  D.17955 = i.14 * 40;
  D.17956 = D.17953 + D.17955;
  dump_section_table (D.17956);
  i = i + 1;
  <D.17427>:
  if (i < top) goto <D.17426>; else goto <D.17428>;
  <D.17428>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.17957;
  unsigned int D.17958;
  unsigned int D.17959;
  unsigned int D.17960;
  unsigned int D.17961;
  unsigned int D.17962;
  unsigned int D.17963;
  short unsigned int D.17964;
  int D.17965;
  short unsigned int D.17966;
  int D.17967;
  const char * iftmp.15;
  unsigned int D.17969;
  const char * iftmp.16;
  unsigned int D.17974;
  const char * iftmp.17;
  unsigned int D.17979;
  const char * iftmp.18;
  unsigned int D.17984;
  const char * iftmp.19;
  unsigned int D.17989;
  const char * iftmp.20;
  unsigned int D.17994;
  const char * iftmp.21;
  unsigned int D.17999;
  const char * iftmp.22;
  unsigned int D.18004;
  const char * iftmp.23;
  unsigned int D.18009;
  const char * iftmp.24;
  signed int flags.25;
  guint32 flags;

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


dump_cli_header (struct MonoCLIHeader * ch)
{
  unsigned int D.18018;
  short unsigned int D.18019;
  int D.18020;
  short unsigned int D.18021;
  int D.18022;
  const char * iftmp.26;
  unsigned int D.18024;
  unsigned int D.18025;
  const char * iftmp.27;
  unsigned int D.18030;
  const char * iftmp.28;
  unsigned int D.18035;
  const char * iftmp.29;
  unsigned int D.18040;
  unsigned int D.18044;

  printf ("\n");
  D.18018 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.18018);
  D.18019 = ch->ch_runtime_major;
  D.18020 = (int) D.18019;
  D.18021 = ch->ch_runtime_minor;
  D.18022 = (int) D.18021;
  printf ("         Runtime required: %d.%d\n", D.18020, D.18022);
  D.18024 = ch->ch_flags;
  D.18025 = D.18024 & 1;
  if (D.18025 != 0) goto <D.18026>; else goto <D.18027>;
  <D.18026>:
  iftmp.26 = "ilonly";
  goto <D.18028>;
  <D.18027>:
  iftmp.26 = "contains native";
  <D.18028>:
  D.18024 = ch->ch_flags;
  D.18030 = D.18024 & 2;
  if (D.18030 != 0) goto <D.18031>; else goto <D.18032>;
  <D.18031>:
  iftmp.27 = "32bits";
  goto <D.18033>;
  <D.18032>:
  iftmp.27 = "32/64";
  <D.18033>:
  D.18024 = ch->ch_flags;
  D.18035 = D.18024 & 65536;
  if (D.18035 != 0) goto <D.18036>; else goto <D.18037>;
  <D.18036>:
  iftmp.28 = "trackdebug";
  goto <D.18038>;
  <D.18037>:
  iftmp.28 = "no-trackdebug";
  <D.18038>:
  D.18024 = ch->ch_flags;
  D.18040 = D.18024 & 8;
  if (D.18040 != 0) goto <D.18041>; else goto <D.18042>;
  <D.18041>:
  iftmp.29 = "strongnamesigned";
  goto <D.18043>;
  <D.18042>:
  iftmp.29 = "notsigned";
  <D.18043>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.26, iftmp.27, iftmp.28, iftmp.29);
  dent ("         Metadata", ch->ch_metadata);
  D.18044 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.18044);
  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.18049;
  sizetype i.32;
  const char * D.18053;
  char D.18054;
  int D.18055;
  int D.18056;
  unsigned int i.33;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.18046>; else goto <D.18047>;
  <D.18046>:
  printf (" none\n");
  return;
  <D.18047>:
  i = 0;
  goto <D.17399>;
  <D.17398>:
  i.31 = (unsigned int) i;
  D.18049 = i.31 & 15;
  if (D.18049 == 0) goto <D.18050>; else goto <D.18051>;
  <D.18050>:
  printf ("\n\t");
  <D.18051>:
  i.32 = (sizetype) i;
  D.18053 = p + i.32;
  D.18054 = *D.18053;
  D.18055 = (int) D.18054;
  D.18056 = D.18055 & 255;
  printf (" %02X", D.18056);
  i = i + 1;
  <D.17399>:
  i.33 = (unsigned int) i;
  if (i.33 < size) goto <D.17398>; else goto <D.17400>;
  <D.17400>:
  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.18060;
  const char * D.18063;
  int D.18064;
  unsigned char D.18065;
  int D.18066;
  const char * D.18067;
  int D.18068;
  char * D.18069;
  int D.18070;
  int D.18071;
  unsigned int D.18072;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.17449>;
  <D.17448>:
  D.18060 = meta->tables[table].rows;
  if (D.18060 == 0) goto <D.18061>; else goto <D.18062>;
  <D.18061>:
  // predicted unlikely by continue predictor.
  goto <D.17447>;
  <D.18062>:
  D.18063 = mono_meta_table_name (table);
  D.18060 = meta->tables[table].rows;
  D.18064 = (int) D.18060;
  D.18065 = meta->tables[table].row_size;
  D.18066 = (int) D.18065;
  D.18067 = meta->tables[table].base;
  D.18068 = (int) D.18067;
  D.18069 = meta->raw_data;
  D.18070 = (int) D.18069;
  D.18071 = D.18068 - D.18070;
  D.18072 = (unsigned int) D.18071;
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.18063, D.18064, D.18066, D.18072);
  <D.17447>:
  table = table + 1;
  <D.17449>:
  if (table <= 44) goto <D.17448>; else goto <D.17450>;
  <D.17450>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.18073;
  int D.18074;
  short int D.18075;
  int D.18076;
  char * D.18077;

  printf ("\nMetadata header:\n");
  D.18073 = meta->md_version_major;
  D.18074 = (int) D.18073;
  D.18075 = meta->md_version_minor;
  D.18076 = (int) D.18075;
  printf ("           Version: %d.%d\n", D.18074, D.18076);
  D.18077 = meta->version;
  printf ("    Version string: %s\n", D.18077);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.18078;
  struct MonoStreamHeader * D.18079;
  struct MonoStreamHeader * D.18080;
  struct MonoStreamHeader * D.18081;
  struct MonoStreamHeader * D.18082;

  printf ("\nMetadata pointers:\n");
  D.18078 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.18078);
  D.18079 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.18079);
  D.18080 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.18080);
  D.18081 = &meta->heap_us;
  dsh ("\tUser string", meta, D.18081);
  D.18082 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.18082);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  const char * D.18083;
  int D.18084;
  char * D.18085;
  int D.18086;
  int D.18087;
  unsigned int D.18088;
  const char * D.18089;
  int D.18090;
  int D.18091;

  D.18083 = sh->data;
  D.18084 = (int) D.18083;
  D.18085 = meta->raw_metadata;
  D.18086 = (int) D.18085;
  D.18087 = D.18084 - D.18086;
  D.18083 = sh->data;
  D.18088 = sh->size;
  D.18089 = D.18083 + D.18088;
  D.18090 = (int) D.18089;
  D.18085 = meta->raw_metadata;
  D.18086 = (int) D.18085;
  D.18091 = D.18090 - D.18086;
  D.18088 = sh->size;
  D.18088 = sh->size;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.18087, D.18091, D.18088, D.18088);
}


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

  if (token == 0) goto <D.18092>; else goto <D.18093>;
  <D.18092>:
  return;
  <D.18093>:
  loc = mono_metadata_locate_token (metadata, token);
  D.18094 = mono_read32 (loc);
  printf ("RVA for Entry Point: 0x%08x\n", D.18094);
}


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.35;
  int D.18100;
  int D.18101;
  unsigned int D.18102;
  struct MonoType * D.18107;
  struct MonoMethodSignature * D.18108;
  const char * D.18111;
  struct MonoMethodSignature * D.18113;
  const char * D.18114;
  <unnamed type> D.18115;
  const char * D.18116;
  char * D.18117;
  <unnamed-unsigned:24> D.18124;
  int D.18125;
  int D.18128;
  struct GSList * errors;
  struct GSList * tmp;
  int count;
  int verifiable;
  const char * desc[9];

  try
    {
      count = 0;
      verifiable = 0;
      desc = *$LC18;
      verify_code.35 = verify_code;
      if (verify_code.35 != 0) goto <D.18098>; else goto <D.18099>;
      <D.18098>:
      {
        int i;
        struct MonoTableInfo * m;

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

          mono_loader_clear_error ();
          D.18100 = i + 1;
          D.18101 = D.18100 | 100663296;
          D.18102 = (unsigned int) D.18101;
          method = mono_get_method (image, D.18102, 0B);
          if (method == 0B) goto <D.18103>; else goto <D.18104>;
          <D.18103>:
          D.18100 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.18100);
          // predicted unlikely by continue predictor.
          goto <D.17472>;
          <D.18104>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.18105>; else goto <D.18106>;
          <D.18105>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.18107 = &klass->byval_arg;
            name = mono_type_full_name (D.18107);
            D.18108 = mono_method_signature (method);
            if (D.18108 == 0B) goto <D.18109>; else goto <D.18110>;
            <D.18109>:
            D.18111 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.18111);
            goto <D.18112>;
            <D.18110>:
            {
              char * sig;

              D.18113 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.18113, 0);
              D.18114 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.18114, sig);
              monoeg_g_free (sig);
            }
            <D.18112>:
            monoeg_g_free (name);
          }
          <D.18106>:
          tmp = errors;
          goto <D.17478>;
          <D.17477>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.18115 = info->status;
            D.18116 = desc[D.18115];
            D.18117 = info->message;
            monoeg_g_print ("%s: %s\n", D.18116, D.18117);
            D.18115 = info->status;
            if (D.18115 == 1) goto <D.18118>; else goto <D.18119>;
            <D.18118>:
            count = count + 1;
            verifiable = 3;
            <D.18119>:
            D.18115 = info->status;
            if (D.18115 == 8) goto <D.18120>; else goto <D.18121>;
            <D.18120>:
            if (verifiable <= 1) goto <D.18122>; else goto <D.18123>;
            <D.18122>:
            verifiable = 2;
            <D.18123>:
            <D.18121>:
          }
          tmp = tmp->next;
          <D.17478>:
          if (tmp != 0B) goto <D.17477>; else goto <D.17479>;
          <D.17479>:
          mono_free_verify_list (errors);
        }
        <D.17472>:
        i = i + 1;
        <D.17481>:
        D.18124 = m->rows;
        D.18125 = (int) D.18124;
        if (D.18125 > i) goto <D.17480>; else goto <D.17482>;
        <D.17482>:
      }
      <D.18099>:
      if (count != 0) goto <D.18126>; else goto <D.18127>;
      <D.18126>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18127>:
      D.18128 = verifiable;
      return D.18128;
    }
  finally
    {
      desc = {CLOBBER};
    }
}