main (int argc, char * * argv)
{
  long unsigned int D.17999;
  long unsigned int D.18000;
  char * * D.18001;
  char * D.18002;
  char D.18003;
  int D.17965;
  int iftmp.0;
  int D.17964;
  const char[7] * D.18009;
  unsigned char D.18010;
  int D.18011;
  unsigned char D.18012;
  int D.18013;
  _Bool D.18014;
  _Bool D.18015;
  _Bool D.18016;
  const unsigned char * D.18019;
  unsigned char D.18020;
  int D.18021;
  const unsigned char * D.18022;
  unsigned char D.18023;
  int D.18024;
  _Bool D.18025;
  _Bool D.18026;
  const unsigned char * D.18029;
  unsigned char D.18030;
  int D.18031;
  const unsigned char * D.18032;
  unsigned char D.18033;
  int D.18034;
  _Bool D.18035;
  _Bool D.18036;
  const unsigned char * D.18039;
  unsigned char D.18040;
  int D.18041;
  const unsigned char * D.18042;
  unsigned char D.18043;
  int D.18044;
  int D.17974;
  int iftmp.1;
  int D.17973;
  const char[9] * D.18052;
  unsigned char D.18053;
  int D.18054;
  unsigned char D.18055;
  int D.18056;
  _Bool D.18057;
  _Bool D.18058;
  _Bool D.18059;
  const unsigned char * D.18062;
  unsigned char D.18063;
  int D.18064;
  const unsigned char * D.18065;
  unsigned char D.18066;
  int D.18067;
  _Bool D.18068;
  _Bool D.18069;
  const unsigned char * D.18072;
  unsigned char D.18073;
  int D.18074;
  const unsigned char * D.18075;
  unsigned char D.18076;
  int D.18077;
  _Bool D.18078;
  _Bool D.18079;
  const unsigned char * D.18082;
  unsigned char D.18083;
  int D.18084;
  const unsigned char * D.18085;
  unsigned char D.18086;
  int D.18087;
  int verify_pe.2;
  int D.17987;
  const char * D.18097;
  unsigned int D.18100;
  unsigned int verify_flags.3;
  unsigned int D.18116;
  int D.18119;
  int verify_code.4;
  int D.18128;
  struct _IO_FILE * stderr.5;
  int dump_data.6;
  unsigned int D.18141;
  unsigned int D.18142;
  struct MonoImage * D.18147;
  int iftmp.7;
  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.17976>;
      <D.17975>:
      D.17999 = (long unsigned int) i;
      D.18000 = D.17999 * 8;
      D.18001 = argv + D.18000;
      D.18002 = *D.18001;
      D.18003 = *D.18002;
      if (D.18003 != 45) goto <D.18004>; else goto <D.18005>;
      <D.18004>:
      D.17999 = (long unsigned int) i;
      D.18000 = D.17999 * 8;
      D.18001 = argv + D.18000;
      file = *D.18001;
      // predicted unlikely by continue predictor.
      goto <D.17956>;
      <D.18005>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.17999 = (long unsigned int) i;
          D.18000 = D.17999 * 8;
          D.18001 = argv + D.18000;
          __s2 = *D.18001;
          D.18009 = "--help";
          D.18010 = MEM[(const unsigned char *)D.18009];
          D.18011 = (int) D.18010;
          D.18012 = *__s2;
          D.18013 = (int) D.18012;
          __result = D.18011 - D.18013;
          {
            D.18014 = __s2_len != 0;
            D.18015 = __result == 0;
            D.18016 = D.18014 & D.18015;
            if (D.18016 != 0) goto <D.18017>; else goto <D.18018>;
            <D.18017>:
            D.18019 = &MEM[(void *)"--help" + 1B];
            D.18020 = *D.18019;
            D.18021 = (int) D.18020;
            D.18022 = __s2 + 1;
            D.18023 = *D.18022;
            D.18024 = (int) D.18023;
            __result = D.18021 - D.18024;
            D.18025 = __s2_len > 1;
            D.18015 = __result == 0;
            D.18026 = D.18025 & D.18015;
            if (D.18026 != 0) goto <D.18027>; else goto <D.18028>;
            <D.18027>:
            D.18029 = &MEM[(void *)"--help" + 2B];
            D.18030 = *D.18029;
            D.18031 = (int) D.18030;
            D.18032 = __s2 + 2;
            D.18033 = *D.18032;
            D.18034 = (int) D.18033;
            __result = D.18031 - D.18034;
            D.18035 = __s2_len > 2;
            D.18015 = __result == 0;
            D.18036 = D.18035 & D.18015;
            if (D.18036 != 0) goto <D.18037>; else goto <D.18038>;
            <D.18037>:
            D.18039 = &MEM[(void *)"--help" + 3B];
            D.18040 = *D.18039;
            D.18041 = (int) D.18040;
            D.18042 = __s2 + 3;
            D.18043 = *D.18042;
            D.18044 = (int) D.18043;
            __result = D.18041 - D.18044;
            <D.18038>:
            <D.18028>:
            <D.18018>:
          }
          D.17964 = __result;
        }
        iftmp.0 = -D.17964;
        goto <D.18045>;
        <D.18008>:
        D.17999 = (long unsigned int) i;
        D.18000 = D.17999 * 8;
        D.18001 = argv + D.18000;
        D.18002 = *D.18001;
        iftmp.0 = __builtin_strcmp (D.18002, "--help");
        <D.18045>:
        D.17965 = iftmp.0;
      }
      if (D.17965 == 0) goto <D.18046>; else goto <D.18047>;
      <D.18046>:
      usage ();
      goto <D.18048>;
      <D.18047>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.17999 = (long unsigned int) i;
          D.18000 = D.17999 * 8;
          D.18001 = argv + D.18000;
          __s2 = *D.18001;
          D.18052 = "--verify";
          D.18053 = MEM[(const unsigned char *)D.18052];
          D.18054 = (int) D.18053;
          D.18055 = *__s2;
          D.18056 = (int) D.18055;
          __result = D.18054 - D.18056;
          {
            D.18057 = __s2_len != 0;
            D.18058 = __result == 0;
            D.18059 = D.18057 & D.18058;
            if (D.18059 != 0) goto <D.18060>; else goto <D.18061>;
            <D.18060>:
            D.18062 = &MEM[(void *)"--verify" + 1B];
            D.18063 = *D.18062;
            D.18064 = (int) D.18063;
            D.18065 = __s2 + 1;
            D.18066 = *D.18065;
            D.18067 = (int) D.18066;
            __result = D.18064 - D.18067;
            D.18068 = __s2_len > 1;
            D.18058 = __result == 0;
            D.18069 = D.18068 & D.18058;
            if (D.18069 != 0) goto <D.18070>; else goto <D.18071>;
            <D.18070>:
            D.18072 = &MEM[(void *)"--verify" + 2B];
            D.18073 = *D.18072;
            D.18074 = (int) D.18073;
            D.18075 = __s2 + 2;
            D.18076 = *D.18075;
            D.18077 = (int) D.18076;
            __result = D.18074 - D.18077;
            D.18078 = __s2_len > 2;
            D.18058 = __result == 0;
            D.18079 = D.18078 & D.18058;
            if (D.18079 != 0) goto <D.18080>; else goto <D.18081>;
            <D.18080>:
            D.18082 = &MEM[(void *)"--verify" + 3B];
            D.18083 = *D.18082;
            D.18084 = (int) D.18083;
            D.18085 = __s2 + 3;
            D.18086 = *D.18085;
            D.18087 = (int) D.18086;
            __result = D.18084 - D.18087;
            <D.18081>:
            <D.18071>:
            <D.18061>:
          }
          D.17973 = __result;
        }
        iftmp.1 = -D.17973;
        goto <D.18088>;
        <D.18051>:
        D.17999 = (long unsigned int) i;
        D.18000 = D.17999 * 8;
        D.18001 = argv + D.18000;
        D.18002 = *D.18001;
        iftmp.1 = __builtin_strcmp (D.18002, "--verify");
        <D.18088>:
        D.17974 = iftmp.1;
      }
      if (D.17974 == 0) goto <D.18089>; else goto <D.18090>;
      <D.18089>:
      verify_pe = 1;
      dump_data = 0;
      i = i + 1;
      D.17999 = (long unsigned int) i;
      D.18000 = D.17999 * 8;
      D.18001 = argv + D.18000;
      flags = *D.18001;
      goto <D.18091>;
      <D.18090>:
      usage ();
      <D.18091>:
      <D.18048>:
      <D.17956>:
      i = i + 1;
      <D.17976>:
      if (i < argc) goto <D.17975>; else goto <D.17977>;
      <D.17977>:
      if (file == 0B) goto <D.18092>; else goto <D.18093>;
      <D.18092>:
      usage ();
      <D.18093>:
      mono_perfcounters_init ();
      mono_metadata_init ();
      mono_images_init ();
      mono_assemblies_init ();
      mono_loader_init ();
      verify_pe.2 = verify_pe;
      if (verify_pe.2 != 0) goto <D.18095>; else goto <D.18096>;
      <D.18095>:
      {
        char * tok;

        tok = strtok (flags, ",");
        verify_metadata = 1;
        verify_code = 0;
        goto <D.17992>;
        <D.17991>:
        i = 0;
        goto <D.17990>;
        <D.17989>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.18097 = flag_desc[i];
          D.17987 = __builtin_strcmp (tok, D.18097);
        }
        if (D.17987 == 0) goto <D.18098>; else goto <D.18099>;
        <D.18098>:
        D.18100 = flag_vals[i];
        if (D.18100 == 8) goto <D.18101>; else goto <D.18102>;
        <D.18101>:
        verify_metadata = 0;
        verify_code = 1;
        goto <D.18103>;
        <D.18102>:
        D.18100 = flag_vals[i];
        if (D.18100 == 7) goto <D.18104>; else goto <D.18105>;
        <D.18104>:
        verify_code = 1;
        goto <D.18106>;
        <D.18105>:
        D.18100 = flag_vals[i];
        if (D.18100 == 9) goto <D.18107>; else goto <D.18108>;
        <D.18107>:
        verify_metadata = 0;
        run_new_metadata_verifier = 1;
        goto <D.18109>;
        <D.18108>:
        D.18100 = flag_vals[i];
        if (D.18100 == 10) goto <D.18110>; else goto <D.18111>;
        <D.18110>:
        verify_partial_md = 1;
        <D.18111>:
        <D.18109>:
        <D.18106>:
        <D.18103>:
        D.18100 = flag_vals[i];
        if (D.18100 == 134217728) goto <D.18112>; else goto <D.18113>;
        <D.18112>:
        verifier_mode = 1;
        goto <D.18114>;
        <D.18113>:
        D.18100 = flag_vals[i];
        verify_flags.3 = (unsigned int) verify_flags;
        D.18116 = D.18100 | verify_flags.3;
        verify_flags = (int) D.18116;
        <D.18114>:
        goto <D.17988>;
        <D.18099>:
        i = i + 1;
        <D.17990>:
        D.18097 = flag_desc[i];
        if (D.18097 != 0B) goto <D.17989>; else goto <D.17988>;
        <D.17988>:
        D.18097 = flag_desc[i];
        if (D.18097 == 0B) goto <D.18117>; else goto <D.18118>;
        <D.18117>:
        monoeg_g_print ("Unknown verify flag %s\n", tok);
        <D.18118>:
        tok = strtok (0B, ",");
        <D.17992>:
        if (tok != 0B) goto <D.17991>; else goto <D.17993>;
        <D.17993>:
        mono_verifier_set_mode (verifier_mode);
      }
      <D.18096>:
      verify_pe.2 = verify_pe;
      D.18119 = verify_pe.2 | run_new_metadata_verifier;
      if (D.18119 != 0) goto <D.18120>; else goto <D.18121>;
      <D.18120>:
      run_new_metadata_verifier = 1;
      <D.18121>:
      if (run_new_metadata_verifier != 0) goto <D.18122>; else goto <D.18123>;
      <D.18122>:
      mono_verifier_set_mode (verifier_mode);
      image_result = verify_image_file (file);
      if (image_result == 1) goto <D.18124>; else goto <D.18126>;
      <D.18126>:
      verify_code.4 = verify_code;
      if (verify_code.4 == 0) goto <D.18124>; else goto <D.18125>;
      <D.18124>:
      D.18128 = image_result;
      return D.18128;
      <D.18125>:
      <D.18123>:
      image = mono_image_open (file, 0B);
      if (image == 0B) goto <D.18129>; else goto <D.18130>;
      <D.18129>:
      stderr.5 = stderr;
      fprintf (stderr.5, "Cannot open image %s\n", file);
      exit (1);
      <D.18130>:
      dump_data.6 = dump_data;
      if (dump_data.6 != 0) goto <D.18133>; else goto <D.18134>;
      <D.18133>:
      dump_dotnet_iinfo (image);
      <D.18134>:
      verify_pe.2 = verify_pe;
      if (verify_pe.2 != 0) goto <D.18135>; else goto <D.18136>;
      <D.18135>:
      {
        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.18137>; else goto <D.18138>;
            <D.18137>:
            image = mono_image_open (file, &status);
            if (image != 0B) goto <D.18139>; else goto <D.18140>;
            <D.18139>:
            D.18141 = BIT_FIELD_REF <*image, 32, 5696>;
            D.18142 = D.18141 & 16777215;
            if (D.18142 == 0) goto <D.18143>; else goto <D.18144>;
            <D.18143>:
            assembly = monoeg_malloc0 (128);
            assembly->in_gac = 0;
            assembly->image = image;
            image->assembly = assembly;
            <D.18144>:
            <D.18140>:
            <D.18138>:
            if (assembly == 0B) goto <D.18145>; else goto <D.18146>;
            <D.18145>:
            monoeg_g_print ("Could not open assembly %s\n", file);
            D.18128 = 4;
            return D.18128;
            <D.18146>:
            D.18147 = assembly->image;
            code_result = dump_verify_info (D.18147, verify_flags);
            if (code_result != 0) goto <D.18149>; else goto <D.18150>;
            <D.18149>:
            iftmp.7 = code_result;
            goto <D.18151>;
            <D.18150>:
            iftmp.7 = image_result;
            <D.18151>:
            D.18128 = iftmp.7;
            return D.18128;
          }
        finally
          {
            status = {CLOBBER};
          }
      }
      <D.18136>:
      mono_image_close (image);
      D.18128 = 0;
      return D.18128;
    }
  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.18155;

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


verify_image_file (const char * fname)
{
  int D.18159;
  int D.18160;
  int D.18162;
  int D.18165;
  int D.18167;
  int D.18170;
  struct MonoAssemblyName * D.18172;
  char * D.18173;
  int verify_partial_md.8;
  int D.18177;
  int D.18179;
  unsigned char D.18184;
  struct MonoLoaderError * D.18186;
  const char * D.18187;
  const char * D.18188;
  struct MonoLoaderError * D.18192;
  <unnamed-unsigned:24> D.18193;
  int D.18194;
  char * D.18197;
  <unnamed type> D.18198;
  const char * D.18199;
  struct GSList * errors.9;
  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.18157>; else goto <D.18158>;
      <D.18157>:
      printf ("Could not open %s\n", fname);
      D.18159 = 1;
      return D.18159;
      <D.18158>:
      D.18160 = mono_verifier_verify_pe_data (image, &errors);
      if (D.18160 == 0) goto invalid_image; else goto <D.18161>;
      <D.18161>:
      D.18162 = mono_image_load_pe_data (image);
      if (D.18162 == 0) goto <D.18163>; else goto <D.18164>;
      <D.18163>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.18159 = 1;
      return D.18159;
      <D.18164>:
      D.18165 = mono_verifier_verify_cli_data (image, &errors);
      if (D.18165 == 0) goto invalid_image; else goto <D.18166>;
      <D.18166>:
      D.18167 = mono_image_load_cli_data (image);
      if (D.18167 == 0) goto <D.18168>; else goto <D.18169>;
      <D.18168>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.18159 = 1;
      return D.18159;
      <D.18169>:
      D.18170 = mono_verifier_verify_table_data (image, &errors);
      if (D.18170 == 0) goto invalid_image; else goto <D.18171>;
      <D.18171>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (128);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.18172 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.18172);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.18173 = image->version;
      mono_init_version ("pedump", D.18173);
      mono_install_assembly_preload_hook (pedump_preload, 0B);
      mono_marshal_init ();
      verify_partial_md.8 = verify_partial_md;
      if (verify_partial_md.8 == 0) goto <D.18175>; else goto <D.18176>;
      <D.18175>:
      D.18177 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.18177 == 0) goto invalid_image; else goto <D.18178>;
      <D.18178>:
      <D.18176>:
      table = &image->tables[2];
      i = 1;
      goto <D.17891>;
      <D.17890>:
      {
        guint32 token;
        struct MonoClass * class;

        D.18179 = i | 33554432;
        token = (guint32) D.18179;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.18180>; else goto <D.18181>;
        <D.18180>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.17889>;
        <D.18181>:
        mono_class_init (class);
        D.18184 = class->exception_type;
        if (D.18184 != 0) goto <D.18182>; else goto <D.18185>;
        <D.18185>:
        D.18186 = mono_loader_get_last_error ();
        if (D.18186 != 0B) goto <D.18182>; else goto <D.18183>;
        <D.18182>:
        D.18187 = class->name;
        D.18188 = class->name_space;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18188, D.18187);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18183>:
        mono_class_setup_vtable (class);
        D.18184 = class->exception_type;
        if (D.18184 != 0) goto <D.18189>; else goto <D.18191>;
        <D.18191>:
        D.18192 = mono_loader_get_last_error ();
        if (D.18192 != 0B) goto <D.18189>; else goto <D.18190>;
        <D.18189>:
        D.18187 = class->name;
        D.18188 = class->name_space;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18188, D.18187);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18190>:
      }
      <D.17889>:
      i = i + 1;
      <D.17891>:
      D.18193 = table->rows;
      D.18194 = (int) D.18193;
      if (D.18194 >= i) goto <D.17890>; else goto <D.17892>;
      <D.17892>:
      if (count != 0) goto <D.18195>; else goto <D.18196>;
      <D.18195>:
      D.18159 = 5;
      return D.18159;
      <D.18196>:
      D.18159 = 0;
      return D.18159;
      invalid_image:
      tmp = errors;
      goto <D.17895>;
      <D.17894>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.18197 = info->message;
        D.18198 = info->status;
        D.18199 = desc[D.18198];
        monoeg_g_print ("%s: %s\n", D.18199, D.18197);
        D.18198 = info->status;
        if (D.18198 == 1) goto <D.18200>; else goto <D.18201>;
        <D.18200>:
        count = count + 1;
        <D.18201>:
      }
      tmp = tmp->next;
      <D.17895>:
      if (tmp != 0B) goto <D.17894>; else goto <D.17896>;
      <D.17896>:
      errors.9 = errors;
      mono_free_verify_list (errors.9);
      if (count != 0) goto <D.18203>; else goto <D.18204>;
      <D.18203>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18204>:
      D.18159 = 1;
      return D.18159;
    }
  finally
    {
      errors = {CLOBBER};
      status = {CLOBBER};
      desc = {CLOBBER};
    }
}


pedump_preload (struct MonoAssemblyName * aname, gchar * * assemblies_path, void * user_data)
{
  long int user_data.10;
  gchar * D.18210;
  const char * D.18213;
  const char * D.18214;
  struct MonoAssembly * D.18215;
  struct MonoAssembly * result;
  gboolean refonly;

  result = 0B;
  user_data.10 = (long int) user_data;
  refonly = (gboolean) user_data.10;
  if (assemblies_path != 0B) goto <D.18208>; else goto <D.18209>;
  <D.18208>:
  D.18210 = *assemblies_path;
  if (D.18210 != 0B) goto <D.18211>; else goto <D.18212>;
  <D.18211>:
  D.18213 = aname->name;
  D.18214 = aname->culture;
  result = real_load (assemblies_path, D.18214, D.18213, refonly);
  <D.18212>:
  <D.18209>:
  D.18215 = result;
  return D.18215;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.18221;
  long unsigned int D.18222;
  gchar * D.18223;
  char D.18224;
  sizetype D.18227;
  sizetype D.18228;
  gchar * D.18229;
  int D.18230;
  int D.18232;
  int D.18234;
  int D.18236;
  struct MonoAssembly * D.18238;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.18217>; else goto <D.18220>;
      <D.18220>:
      D.18221 = *culture;
      if (D.18221 == 0) goto <D.18217>; else goto <D.18218>;
      <D.18217>:
      local_culture = "";
      goto <D.18219>;
      <D.18218>:
      local_culture = culture;
      <D.18219>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.18222 = strlen (filename);
      len = (gint) D.18222;
      path = search_path;
      goto <D.17920>;
      <D.17919>:
      D.18223 = *path;
      D.18224 = *D.18223;
      if (D.18224 == 0) goto <D.18225>; else goto <D.18226>;
      <D.18225>:
      // predicted unlikely by continue predictor.
      goto <D.17917>;
      <D.18226>:
      D.18227 = (sizetype) len;
      D.18228 = D.18227 + 18446744073709551612;
      D.18229 = filename + D.18228;
      strcpy (D.18229, ".dll");
      D.18223 = *path;
      D.18230 = try_load_from (&result, D.18223, local_culture, "", filename, refonly);
      if (D.18230 != 0) goto <D.17918>; else goto <D.18231>;
      <D.18231>:
      D.18227 = (sizetype) len;
      D.18228 = D.18227 + 18446744073709551612;
      D.18229 = filename + D.18228;
      strcpy (D.18229, ".exe");
      D.18223 = *path;
      D.18232 = try_load_from (&result, D.18223, local_culture, "", filename, refonly);
      if (D.18232 != 0) goto <D.17918>; else goto <D.18233>;
      <D.18233>:
      D.18227 = (sizetype) len;
      D.18228 = D.18227 + 18446744073709551612;
      D.18229 = filename + D.18228;
      strcpy (D.18229, ".dll");
      D.18223 = *path;
      D.18234 = try_load_from (&result, D.18223, local_culture, name, filename, refonly);
      if (D.18234 != 0) goto <D.17918>; else goto <D.18235>;
      <D.18235>:
      D.18227 = (sizetype) len;
      D.18228 = D.18227 + 18446744073709551612;
      D.18229 = filename + D.18228;
      strcpy (D.18229, ".exe");
      D.18223 = *path;
      D.18236 = try_load_from (&result, D.18223, local_culture, name, filename, refonly);
      if (D.18236 != 0) goto <D.17918>; else goto <D.18237>;
      <D.18237>:
      <D.17917>:
      path = path + 8;
      <D.17920>:
      D.18223 = *path;
      if (D.18223 != 0B) goto <D.17919>; else goto <D.17918>;
      <D.17918>:
      monoeg_g_free (filename);
      D.18238 = result;
      return D.18238;
    }
  finally
    {
      result = {CLOBBER};
    }
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.18241;
  long unsigned int D.18242;

  D.18242 = __builtin_object_size (__dest, 1);
  D.18241 = __builtin___strcpy_chk (__dest, __src, D.18242);
  return D.18241;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.18244;
  struct MonoAssembly * D.18247;
  gboolean D.18248;
  struct MonoAssembly * D.18249;
  _Bool D.18250;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.18244 = monoeg_g_file_test (fullpath, 1);
  if (D.18244 != 0) goto <D.18245>; else goto <D.18246>;
  <D.18245>:
  D.18247 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.18247;
  <D.18246>:
  monoeg_g_free (fullpath);
  D.18249 = *assembly;
  D.18250 = D.18249 != 0B;
  D.18248 = (gboolean) D.18250;
  return D.18248;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.18252;
  int D.18253;
  struct MonoAssembly * D.18256;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.17940>;
  <D.17939>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.18252 = &ass->aname;
    D.18253 = mono_assembly_names_equal (aname, D.18252);
    if (D.18253 != 0) goto <D.18254>; else goto <D.18255>;
    <D.18254>:
    D.18256 = ass;
    return D.18256;
    <D.18255>:
  }
  tmp = tmp->next;
  <D.17940>:
  if (tmp != 0B) goto <D.17939>; else goto <D.17941>;
  <D.17941>:
  D.18256 = 0B;
  return D.18256;
}


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

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


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

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.18262;
  struct MonoCLIHeader * D.18263;
  unsigned int D.18264;
  struct MonoCLIImageInfo * iinfo;

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


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.18265;
  struct MonoPEHeader * D.18266;
  struct MonoPEHeaderNT * D.18267;
  struct MonoPEDatadir * D.18268;

  D.18265 = &header->coff;
  dump_coff_header (D.18265);
  D.18266 = &header->pe;
  dump_pe_header (D.18266);
  D.18267 = &header->nt;
  dump_nt_header (D.18267);
  D.18268 = &header->datadir;
  dump_datadir (D.18268);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.18269;
  int D.18270;
  short unsigned int D.18271;
  int D.18272;
  unsigned int D.18273;
  unsigned int D.18274;
  unsigned int D.18275;
  short unsigned int D.18276;
  int D.18277;
  short unsigned int D.18278;
  int D.18279;

  printf ("\nCOFF Header:\n");
  D.18269 = coff->coff_machine;
  D.18270 = (int) D.18269;
  hex16 ("                Machine", D.18270);
  D.18271 = coff->coff_sections;
  D.18272 = (int) D.18271;
  hex16 ("               Sections", D.18272);
  D.18273 = coff->coff_time;
  hex32 ("             Time stamp", D.18273);
  D.18274 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.18274);
  D.18275 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.18275);
  D.18276 = coff->coff_opt_header_size;
  D.18277 = (int) D.18276;
  hex16 ("   Optional Header Size", D.18277);
  D.18278 = coff->coff_attributes;
  D.18279 = (int) D.18278;
  hex16 ("   \tCharacteristics", D.18279);
}


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


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

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


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.18281;
  int D.18282;
  unsigned char D.18283;
  int D.18284;
  unsigned char D.18285;
  int D.18286;
  unsigned int D.18287;
  unsigned int D.18288;
  unsigned int D.18289;
  unsigned int D.18290;
  unsigned int D.18291;
  unsigned int D.18292;

  printf ("\nPE Header:\n");
  D.18281 = pe->pe_magic;
  D.18282 = (int) D.18281;
  hex16 ("         Magic (0x010b)", D.18282);
  D.18283 = pe->pe_major;
  D.18284 = (int) D.18283;
  hex8 ("             LMajor (6)", D.18284);
  D.18285 = pe->pe_minor;
  D.18286 = (int) D.18285;
  hex8 ("             LMinor (0)", D.18286);
  D.18287 = pe->pe_code_size;
  hex32 ("              Code Size", D.18287);
  D.18288 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.18288);
  D.18289 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.18289);
  D.18290 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.18290);
  D.18291 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.18291);
  D.18292 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.18292);
  printf ("\n");
}


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

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


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.18294;
  unsigned int D.18295;
  unsigned int D.18296;
  short unsigned int D.18297;
  int D.18298;
  short unsigned int D.18299;
  int D.18300;
  short unsigned int D.18301;
  int D.18302;
  short unsigned int D.18303;
  int D.18304;
  short unsigned int D.18305;
  int D.18306;
  short unsigned int D.18307;
  int D.18308;
  unsigned int D.18309;
  unsigned int D.18310;
  unsigned int D.18311;
  unsigned int D.18312;
  short unsigned int D.18313;
  int D.18314;
  short unsigned int D.18315;
  int D.18316;
  unsigned int D.18317;
  unsigned int D.18318;
  unsigned int D.18319;
  unsigned int D.18320;
  unsigned int D.18321;
  unsigned int D.18322;

  printf ("\nNT Header:\n");
  D.18294 = nt->pe_image_base;
  hex32 ("   Image Base (0x400000)", D.18294);
  D.18295 = nt->pe_section_align;
  hex32 ("Section Alignment (8192)", D.18295);
  D.18296 = nt->pe_file_alignment;
  hex32 ("   File Align (512/4096)", D.18296);
  D.18297 = nt->pe_os_major;
  D.18298 = (int) D.18297;
  hex16 ("            OS Major (4)", D.18298);
  D.18299 = nt->pe_os_minor;
  D.18300 = (int) D.18299;
  hex16 ("            OS Minor (0)", D.18300);
  D.18301 = nt->pe_user_major;
  D.18302 = (int) D.18301;
  hex16 ("  \t  User Major (0)", D.18302);
  D.18303 = nt->pe_user_minor;
  D.18304 = (int) D.18303;
  hex16 ("  \t  User Minor (0)", D.18304);
  D.18305 = nt->pe_subsys_major;
  D.18306 = (int) D.18305;
  hex16 ("  \tSubsys major (4)", D.18306);
  D.18307 = nt->pe_subsys_minor;
  D.18308 = (int) D.18307;
  hex16 ("  \tSubsys minor (0)", D.18308);
  D.18309 = nt->pe_reserved_1;
  hex32 (" \t       Reserverd", D.18309);
  D.18310 = nt->pe_image_size;
  hex32 (" \t      Image Size", D.18310);
  D.18311 = nt->pe_header_size;
  hex32 (" \t     Header Size", D.18311);
  D.18312 = nt->pe_checksum;
  hex32 ("            Checksum (0)", D.18312);
  D.18313 = nt->pe_subsys_required;
  D.18314 = (int) D.18313;
  hex16 ("               Subsystem", D.18314);
  D.18315 = nt->pe_dll_flags;
  D.18316 = (int) D.18315;
  hex16 ("           DLL Flags (0)", D.18316);
  D.18317 = nt->pe_stack_reserve;
  hex32 (" Stack Reserve Size (1M)", D.18317);
  D.18318 = nt->pe_stack_commit;
  hex32 ("Stack commit Size (4096)", D.18318);
  D.18319 = nt->pe_heap_reserve;
  hex32 ("  Heap Reserve Size (1M)", D.18319);
  D.18320 = nt->pe_heap_commit;
  hex32 (" Heap Commit Size (4096)", D.18320);
  D.18321 = nt->pe_loader_flags;
  hex32 ("      Loader flags (0x1)", D.18321);
  D.18322 = nt->pe_data_dir_count;
  hex32 ("   Data Directories (16)", D.18322);
}


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.18323;
  unsigned int D.18324;

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


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.18325;
  struct MonoSectionTable * D.18326;
  long unsigned int D.18327;
  long unsigned int D.18328;
  struct MonoSectionTable * D.18329;
  const int top;
  int i;

  D.18325 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.18325;
  i = 0;
  goto <D.17815>;
  <D.17814>:
  D.18326 = iinfo->cli_section_tables;
  D.18327 = (long unsigned int) i;
  D.18328 = D.18327 * 40;
  D.18329 = D.18326 + D.18328;
  dump_section_table (D.18329);
  i = i + 1;
  <D.17815>:
  if (i < top) goto <D.17814>; else goto <D.17816>;
  <D.17816>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.18330;
  unsigned int D.18331;
  unsigned int D.18332;
  unsigned int D.18333;
  unsigned int D.18334;
  unsigned int D.18335;
  unsigned int D.18336;
  short unsigned int D.18337;
  int D.18338;
  short unsigned int D.18339;
  int D.18340;
  const char * iftmp.13;
  signed int flags.14;
  const char * iftmp.15;
  unsigned int D.18347;
  const char * iftmp.16;
  unsigned int D.18352;
  const char * iftmp.17;
  unsigned int D.18357;
  const char * iftmp.18;
  unsigned int D.18362;
  const char * iftmp.19;
  unsigned int D.18367;
  const char * iftmp.20;
  unsigned int D.18372;
  const char * iftmp.21;
  unsigned int D.18377;
  const char * iftmp.22;
  unsigned int D.18382;
  const char * iftmp.23;
  unsigned int D.18387;
  guint32 flags;

  flags = st->st_flags;
  D.18330 = &st->st_name;
  printf ("\n\tName: %s\n", D.18330);
  D.18331 = st->st_virtual_size;
  hex32 ("   Virtual Size", D.18331);
  D.18332 = st->st_virtual_address;
  hex32 ("Virtual Address", D.18332);
  D.18333 = st->st_raw_data_size;
  hex32 ("  Raw Data Size", D.18333);
  D.18334 = st->st_raw_data_ptr;
  hex32 ("   Raw Data Ptr", D.18334);
  D.18335 = st->st_reloc_ptr;
  hex32 ("      Reloc Ptr", D.18335);
  D.18336 = st->st_lineno_ptr;
  hex32 ("     LineNo Ptr", D.18336);
  D.18337 = st->st_reloc_count;
  D.18338 = (int) D.18337;
  hex16 ("    Reloc Count", D.18338);
  D.18339 = st->st_line_count;
  D.18340 = (int) D.18339;
  hex16 ("     Line Count", D.18340);
  flags.14 = (signed int) flags;
  if (flags.14 < 0) goto <D.18343>; else goto <D.18344>;
  <D.18343>:
  iftmp.13 = "write";
  goto <D.18345>;
  <D.18344>:
  iftmp.13 = "";
  <D.18345>:
  D.18347 = flags & 1073741824;
  if (D.18347 != 0) goto <D.18348>; else goto <D.18349>;
  <D.18348>:
  iftmp.15 = "read, ";
  goto <D.18350>;
  <D.18349>:
  iftmp.15 = "";
  <D.18350>:
  D.18352 = flags & 536870912;
  if (D.18352 != 0) goto <D.18353>; else goto <D.18354>;
  <D.18353>:
  iftmp.16 = "exec, ";
  goto <D.18355>;
  <D.18354>:
  iftmp.16 = "";
  <D.18355>:
  D.18357 = flags & 268435456;
  if (D.18357 != 0) goto <D.18358>; else goto <D.18359>;
  <D.18358>:
  iftmp.17 = "shared, ";
  goto <D.18360>;
  <D.18359>:
  iftmp.17 = "";
  <D.18360>:
  D.18362 = flags & 134217728;
  if (D.18362 != 0) goto <D.18363>; else goto <D.18364>;
  <D.18363>:
  iftmp.18 = "nopage, ";
  goto <D.18365>;
  <D.18364>:
  iftmp.18 = "";
  <D.18365>:
  D.18367 = flags & 67108864;
  if (D.18367 != 0) goto <D.18368>; else goto <D.18369>;
  <D.18368>:
  iftmp.19 = "nocache, ";
  goto <D.18370>;
  <D.18369>:
  iftmp.19 = "";
  <D.18370>:
  D.18372 = flags & 33554432;
  if (D.18372 != 0) goto <D.18373>; else goto <D.18374>;
  <D.18373>:
  iftmp.20 = "discard, ";
  goto <D.18375>;
  <D.18374>:
  iftmp.20 = "";
  <D.18375>:
  D.18377 = flags & 128;
  if (D.18377 != 0) goto <D.18378>; else goto <D.18379>;
  <D.18378>:
  iftmp.21 = "bss, ";
  goto <D.18380>;
  <D.18379>:
  iftmp.21 = "";
  <D.18380>:
  D.18382 = flags & 64;
  if (D.18382 != 0) goto <D.18383>; else goto <D.18384>;
  <D.18383>:
  iftmp.22 = "data, ";
  goto <D.18385>;
  <D.18384>:
  iftmp.22 = "";
  <D.18385>:
  D.18387 = flags & 32;
  if (D.18387 != 0) goto <D.18388>; else goto <D.18389>;
  <D.18388>:
  iftmp.23 = "code, ";
  goto <D.18390>;
  <D.18389>:
  iftmp.23 = "";
  <D.18390>:
  printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n", iftmp.23, iftmp.22, iftmp.21, iftmp.20, iftmp.19, iftmp.18, iftmp.17, iftmp.16, iftmp.15, iftmp.13);
}


dump_cli_header (struct MonoCLIHeader * ch)
{
  unsigned int D.18391;
  short unsigned int D.18392;
  int D.18393;
  short unsigned int D.18394;
  int D.18395;
  const char * iftmp.24;
  unsigned int D.18397;
  unsigned int D.18398;
  const char * iftmp.25;
  unsigned int D.18403;
  const char * iftmp.26;
  unsigned int D.18408;
  const char * iftmp.27;
  unsigned int D.18413;
  unsigned int D.18417;

  printf ("\n");
  D.18391 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.18391);
  D.18392 = ch->ch_runtime_minor;
  D.18393 = (int) D.18392;
  D.18394 = ch->ch_runtime_major;
  D.18395 = (int) D.18394;
  printf ("         Runtime required: %d.%d\n", D.18395, D.18393);
  D.18397 = ch->ch_flags;
  D.18398 = D.18397 & 8;
  if (D.18398 != 0) goto <D.18399>; else goto <D.18400>;
  <D.18399>:
  iftmp.24 = "strongnamesigned";
  goto <D.18401>;
  <D.18400>:
  iftmp.24 = "notsigned";
  <D.18401>:
  D.18397 = ch->ch_flags;
  D.18403 = D.18397 & 65536;
  if (D.18403 != 0) goto <D.18404>; else goto <D.18405>;
  <D.18404>:
  iftmp.25 = "trackdebug";
  goto <D.18406>;
  <D.18405>:
  iftmp.25 = "no-trackdebug";
  <D.18406>:
  D.18397 = ch->ch_flags;
  D.18408 = D.18397 & 2;
  if (D.18408 != 0) goto <D.18409>; else goto <D.18410>;
  <D.18409>:
  iftmp.26 = "32bits";
  goto <D.18411>;
  <D.18410>:
  iftmp.26 = "32/64";
  <D.18411>:
  D.18397 = ch->ch_flags;
  D.18413 = D.18397 & 1;
  if (D.18413 != 0) goto <D.18414>; else goto <D.18415>;
  <D.18414>:
  iftmp.27 = "ilonly";
  goto <D.18416>;
  <D.18415>:
  iftmp.27 = "contains native";
  <D.18416>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.27, iftmp.26, iftmp.25, iftmp.24);
  dent ("         Metadata", ch->ch_metadata);
  D.18417 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.18417);
  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.28;
  guint32 size;
  const char * p;

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


dump_blob (const char * desc, const char * p, guint32 size)
{
  unsigned int i.29;
  unsigned int D.18422;
  sizetype D.18425;
  const char * D.18426;
  char D.18427;
  int D.18428;
  int D.18429;
  unsigned int i.30;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.18419>; else goto <D.18420>;
  <D.18419>:
  printf (" none\n");
  return;
  <D.18420>:
  i = 0;
  goto <D.17787>;
  <D.17786>:
  i.29 = (unsigned int) i;
  D.18422 = i.29 & 15;
  if (D.18422 == 0) goto <D.18423>; else goto <D.18424>;
  <D.18423>:
  printf ("\n\t");
  <D.18424>:
  D.18425 = (sizetype) i;
  D.18426 = p + D.18425;
  D.18427 = *D.18426;
  D.18428 = (int) D.18427;
  D.18429 = D.18428 & 255;
  printf (" %02X", D.18429);
  i = i + 1;
  <D.17787>:
  i.30 = (unsigned int) i;
  if (i.30 < size) goto <D.17786>; else goto <D.17788>;
  <D.17788>:
  printf ("\n");
}


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

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


dump_metadata (struct MonoImage * meta)
{
  <unnamed-unsigned:24> D.18433;
  const char * D.18436;
  long int D.18437;
  char * D.18438;
  long int D.18439;
  long int D.18440;
  unsigned int D.18441;
  unsigned char D.18442;
  int D.18443;
  int D.18444;
  const char * D.18445;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.17837>;
  <D.17836>:
  D.18433 = meta->tables[table].rows;
  if (D.18433 == 0) goto <D.18434>; else goto <D.18435>;
  <D.18434>:
  // predicted unlikely by continue predictor.
  goto <D.17835>;
  <D.18435>:
  D.18436 = meta->tables[table].base;
  D.18437 = (long int) D.18436;
  D.18438 = meta->raw_data;
  D.18439 = (long int) D.18438;
  D.18440 = D.18437 - D.18439;
  D.18441 = (unsigned int) D.18440;
  D.18442 = meta->tables[table].row_size;
  D.18443 = (int) D.18442;
  D.18433 = meta->tables[table].rows;
  D.18444 = (int) D.18433;
  D.18445 = mono_meta_table_name (table);
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.18445, D.18444, D.18443, D.18441);
  <D.17835>:
  table = table + 1;
  <D.17837>:
  if (table <= 44) goto <D.17836>; else goto <D.17838>;
  <D.17838>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.18446;
  int D.18447;
  short int D.18448;
  int D.18449;
  char * D.18450;

  printf ("\nMetadata header:\n");
  D.18446 = meta->md_version_minor;
  D.18447 = (int) D.18446;
  D.18448 = meta->md_version_major;
  D.18449 = (int) D.18448;
  printf ("           Version: %d.%d\n", D.18449, D.18447);
  D.18450 = meta->version;
  printf ("    Version string: %s\n", D.18450);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.18451;
  struct MonoStreamHeader * D.18452;
  struct MonoStreamHeader * D.18453;
  struct MonoStreamHeader * D.18454;
  struct MonoStreamHeader * D.18455;

  printf ("\nMetadata pointers:\n");
  D.18451 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.18451);
  D.18452 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.18452);
  D.18453 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.18453);
  D.18454 = &meta->heap_us;
  dsh ("\tUser string", meta, D.18454);
  D.18455 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.18455);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  unsigned int D.18456;
  const char * D.18457;
  sizetype D.18458;
  const char * D.18459;
  long int D.18460;
  char * D.18461;
  long int D.18462;
  long int D.18463;
  int D.18464;
  long int D.18465;
  long int D.18466;
  int D.18467;

  D.18456 = sh->size;
  D.18456 = sh->size;
  D.18457 = sh->data;
  D.18456 = sh->size;
  D.18458 = (sizetype) D.18456;
  D.18459 = D.18457 + D.18458;
  D.18460 = (long int) D.18459;
  D.18461 = meta->raw_metadata;
  D.18462 = (long int) D.18461;
  D.18463 = D.18460 - D.18462;
  D.18464 = (int) D.18463;
  D.18457 = sh->data;
  D.18465 = (long int) D.18457;
  D.18461 = meta->raw_metadata;
  D.18462 = (long int) D.18461;
  D.18466 = D.18465 - D.18462;
  D.18467 = (int) D.18466;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.18467, D.18464, D.18456, D.18456);
}


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

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


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.32;
  int D.18475;
  int D.18476;
  unsigned int D.18477;
  struct MonoType * D.18482;
  struct MonoMethodSignature * D.18483;
  const char * D.18486;
  struct MonoMethodSignature * D.18488;
  const char * D.18489;
  char * D.18490;
  <unnamed type> D.18491;
  const char * D.18492;
  <unnamed-unsigned:24> D.18499;
  int D.18500;
  int D.18503;
  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.32 = verify_code;
      if (verify_code.32 != 0) goto <D.18473>; else goto <D.18474>;
      <D.18473>:
      {
        int i;
        struct MonoTableInfo * m;

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

          mono_loader_clear_error ();
          D.18475 = i + 1;
          D.18476 = D.18475 | 100663296;
          D.18477 = (unsigned int) D.18476;
          method = mono_get_method (image, D.18477, 0B);
          if (method == 0B) goto <D.18478>; else goto <D.18479>;
          <D.18478>:
          D.18475 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.18475);
          // predicted unlikely by continue predictor.
          goto <D.17860>;
          <D.18479>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.18480>; else goto <D.18481>;
          <D.18480>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.18482 = &klass->byval_arg;
            name = mono_type_full_name (D.18482);
            D.18483 = mono_method_signature (method);
            if (D.18483 == 0B) goto <D.18484>; else goto <D.18485>;
            <D.18484>:
            D.18486 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.18486);
            goto <D.18487>;
            <D.18485>:
            {
              char * sig;

              D.18488 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.18488, 0);
              D.18489 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.18489, sig);
              monoeg_g_free (sig);
            }
            <D.18487>:
            monoeg_g_free (name);
          }
          <D.18481>:
          tmp = errors;
          goto <D.17866>;
          <D.17865>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.18490 = info->message;
            D.18491 = info->status;
            D.18492 = desc[D.18491];
            monoeg_g_print ("%s: %s\n", D.18492, D.18490);
            D.18491 = info->status;
            if (D.18491 == 1) goto <D.18493>; else goto <D.18494>;
            <D.18493>:
            count = count + 1;
            verifiable = 3;
            <D.18494>:
            D.18491 = info->status;
            if (D.18491 == 8) goto <D.18495>; else goto <D.18496>;
            <D.18495>:
            if (verifiable <= 1) goto <D.18497>; else goto <D.18498>;
            <D.18497>:
            verifiable = 2;
            <D.18498>:
            <D.18496>:
          }
          tmp = tmp->next;
          <D.17866>:
          if (tmp != 0B) goto <D.17865>; else goto <D.17867>;
          <D.17867>:
          mono_free_verify_list (errors);
        }
        <D.17860>:
        i = i + 1;
        <D.17869>:
        D.18499 = m->rows;
        D.18500 = (int) D.18499;
        if (D.18500 > i) goto <D.17868>; else goto <D.17870>;
        <D.17870>:
      }
      <D.18474>:
      if (count != 0) goto <D.18501>; else goto <D.18502>;
      <D.18501>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18502>:
      D.18503 = verifiable;
      return D.18503;
    }
  finally
    {
      desc = {CLOBBER};
    }
}