main (int argc, char * * argv)
{
  unsigned int i.0;
  unsigned int D.20207;
  char * * D.20208;
  char * D.20209;
  char D.20210;
  int D.20158;
  int iftmp.1;
  int D.20157;
  const char[7] * D.20216;
  unsigned char D.20217;
  int D.20218;
  unsigned char D.20219;
  int D.20220;
  _Bool D.20221;
  _Bool D.20222;
  _Bool D.20223;
  const unsigned char * D.20226;
  unsigned char D.20227;
  int D.20228;
  const unsigned char * D.20229;
  unsigned char D.20230;
  int D.20231;
  _Bool D.20232;
  _Bool D.20233;
  const unsigned char * D.20236;
  unsigned char D.20237;
  int D.20238;
  const unsigned char * D.20239;
  unsigned char D.20240;
  int D.20241;
  _Bool D.20242;
  _Bool D.20243;
  const unsigned char * D.20246;
  unsigned char D.20247;
  int D.20248;
  const unsigned char * D.20249;
  unsigned char D.20250;
  int D.20251;
  int D.20167;
  int iftmp.2;
  int D.20166;
  const char[9] * D.20259;
  unsigned char D.20260;
  int D.20261;
  unsigned char D.20262;
  int D.20263;
  _Bool D.20264;
  _Bool D.20265;
  _Bool D.20266;
  const unsigned char * D.20269;
  unsigned char D.20270;
  int D.20271;
  const unsigned char * D.20272;
  unsigned char D.20273;
  int D.20274;
  _Bool D.20275;
  _Bool D.20276;
  const unsigned char * D.20279;
  unsigned char D.20280;
  int D.20281;
  const unsigned char * D.20282;
  unsigned char D.20283;
  int D.20284;
  _Bool D.20285;
  _Bool D.20286;
  const unsigned char * D.20289;
  unsigned char D.20290;
  int D.20291;
  const unsigned char * D.20292;
  unsigned char D.20293;
  int D.20294;
  int verify_pe.3;
  int D.20180;
  const char * D.20304;
  unsigned int D.20307;
  unsigned int verify_flags.4;
  unsigned int D.20323;
  int D.20326;
  int verify_code.5;
  int D.20335;
  struct _IO_FILE * stderr.6;
  int dump_data.7;
  unsigned int D.20348;
  unsigned int D.20349;
  struct MonoImage * D.20354;
  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.20169>;
      <D.20168>:
      i.0 = (unsigned int) i;
      D.20207 = i.0 * 4;
      D.20208 = argv + D.20207;
      D.20209 = *D.20208;
      D.20210 = *D.20209;
      if (D.20210 != 45) goto <D.20211>; else goto <D.20212>;
      <D.20211>:
      i.0 = (unsigned int) i;
      D.20207 = i.0 * 4;
      D.20208 = argv + D.20207;
      file = *D.20208;
      // predicted unlikely by continue predictor.
      goto <D.20149>;
      <D.20212>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          i.0 = (unsigned int) i;
          D.20207 = i.0 * 4;
          D.20208 = argv + D.20207;
          __s2 = *D.20208;
          D.20216 = "--help";
          D.20217 = MEM[(const unsigned char *)D.20216];
          D.20218 = (int) D.20217;
          D.20219 = *__s2;
          D.20220 = (int) D.20219;
          __result = D.20218 - D.20220;
          {
            D.20221 = __s2_len != 0;
            D.20222 = __result == 0;
            D.20223 = D.20221 & D.20222;
            if (D.20223 != 0) goto <D.20224>; else goto <D.20225>;
            <D.20224>:
            D.20226 = &MEM[(void *)"--help" + 1B];
            D.20227 = *D.20226;
            D.20228 = (int) D.20227;
            D.20229 = __s2 + 1;
            D.20230 = *D.20229;
            D.20231 = (int) D.20230;
            __result = D.20228 - D.20231;
            D.20232 = __s2_len > 1;
            D.20222 = __result == 0;
            D.20233 = D.20232 & D.20222;
            if (D.20233 != 0) goto <D.20234>; else goto <D.20235>;
            <D.20234>:
            D.20236 = &MEM[(void *)"--help" + 2B];
            D.20237 = *D.20236;
            D.20238 = (int) D.20237;
            D.20239 = __s2 + 2;
            D.20240 = *D.20239;
            D.20241 = (int) D.20240;
            __result = D.20238 - D.20241;
            D.20242 = __s2_len > 2;
            D.20222 = __result == 0;
            D.20243 = D.20242 & D.20222;
            if (D.20243 != 0) goto <D.20244>; else goto <D.20245>;
            <D.20244>:
            D.20246 = &MEM[(void *)"--help" + 3B];
            D.20247 = *D.20246;
            D.20248 = (int) D.20247;
            D.20249 = __s2 + 3;
            D.20250 = *D.20249;
            D.20251 = (int) D.20250;
            __result = D.20248 - D.20251;
            <D.20245>:
            <D.20235>:
            <D.20225>:
          }
          D.20157 = __result;
        }
        iftmp.1 = -D.20157;
        goto <D.20252>;
        <D.20215>:
        i.0 = (unsigned int) i;
        D.20207 = i.0 * 4;
        D.20208 = argv + D.20207;
        D.20209 = *D.20208;
        iftmp.1 = __builtin_strcmp (D.20209, "--help");
        <D.20252>:
        D.20158 = iftmp.1;
      }
      if (D.20158 == 0) goto <D.20253>; else goto <D.20254>;
      <D.20253>:
      usage ();
      goto <D.20255>;
      <D.20254>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          i.0 = (unsigned int) i;
          D.20207 = i.0 * 4;
          D.20208 = argv + D.20207;
          __s2 = *D.20208;
          D.20259 = "--verify";
          D.20260 = MEM[(const unsigned char *)D.20259];
          D.20261 = (int) D.20260;
          D.20262 = *__s2;
          D.20263 = (int) D.20262;
          __result = D.20261 - D.20263;
          {
            D.20264 = __s2_len != 0;
            D.20265 = __result == 0;
            D.20266 = D.20264 & D.20265;
            if (D.20266 != 0) goto <D.20267>; else goto <D.20268>;
            <D.20267>:
            D.20269 = &MEM[(void *)"--verify" + 1B];
            D.20270 = *D.20269;
            D.20271 = (int) D.20270;
            D.20272 = __s2 + 1;
            D.20273 = *D.20272;
            D.20274 = (int) D.20273;
            __result = D.20271 - D.20274;
            D.20275 = __s2_len > 1;
            D.20265 = __result == 0;
            D.20276 = D.20275 & D.20265;
            if (D.20276 != 0) goto <D.20277>; else goto <D.20278>;
            <D.20277>:
            D.20279 = &MEM[(void *)"--verify" + 2B];
            D.20280 = *D.20279;
            D.20281 = (int) D.20280;
            D.20282 = __s2 + 2;
            D.20283 = *D.20282;
            D.20284 = (int) D.20283;
            __result = D.20281 - D.20284;
            D.20285 = __s2_len > 2;
            D.20265 = __result == 0;
            D.20286 = D.20285 & D.20265;
            if (D.20286 != 0) goto <D.20287>; else goto <D.20288>;
            <D.20287>:
            D.20289 = &MEM[(void *)"--verify" + 3B];
            D.20290 = *D.20289;
            D.20291 = (int) D.20290;
            D.20292 = __s2 + 3;
            D.20293 = *D.20292;
            D.20294 = (int) D.20293;
            __result = D.20291 - D.20294;
            <D.20288>:
            <D.20278>:
            <D.20268>:
          }
          D.20166 = __result;
        }
        iftmp.2 = -D.20166;
        goto <D.20295>;
        <D.20258>:
        i.0 = (unsigned int) i;
        D.20207 = i.0 * 4;
        D.20208 = argv + D.20207;
        D.20209 = *D.20208;
        iftmp.2 = __builtin_strcmp (D.20209, "--verify");
        <D.20295>:
        D.20167 = iftmp.2;
      }
      if (D.20167 == 0) goto <D.20296>; else goto <D.20297>;
      <D.20296>:
      verify_pe = 1;
      dump_data = 0;
      i = i + 1;
      i.0 = (unsigned int) i;
      D.20207 = i.0 * 4;
      D.20208 = argv + D.20207;
      flags = *D.20208;
      goto <D.20298>;
      <D.20297>:
      usage ();
      <D.20298>:
      <D.20255>:
      <D.20149>:
      i = i + 1;
      <D.20169>:
      if (i < argc) goto <D.20168>; else goto <D.20170>;
      <D.20170>:
      if (file == 0B) goto <D.20299>; else goto <D.20300>;
      <D.20299>:
      usage ();
      <D.20300>:
      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.20302>; else goto <D.20303>;
      <D.20302>:
      {
        char * tok;

        tok = strtok (flags, ",");
        verify_metadata = 1;
        verify_code = 0;
        goto <D.20185>;
        <D.20184>:
        i = 0;
        goto <D.20183>;
        <D.20182>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.20304 = flag_desc[i];
          D.20180 = __builtin_strcmp (tok, D.20304);
        }
        if (D.20180 == 0) goto <D.20305>; else goto <D.20306>;
        <D.20305>:
        D.20307 = flag_vals[i];
        if (D.20307 == 8) goto <D.20308>; else goto <D.20309>;
        <D.20308>:
        verify_metadata = 0;
        verify_code = 1;
        goto <D.20310>;
        <D.20309>:
        D.20307 = flag_vals[i];
        if (D.20307 == 7) goto <D.20311>; else goto <D.20312>;
        <D.20311>:
        verify_code = 1;
        goto <D.20313>;
        <D.20312>:
        D.20307 = flag_vals[i];
        if (D.20307 == 9) goto <D.20314>; else goto <D.20315>;
        <D.20314>:
        verify_metadata = 0;
        run_new_metadata_verifier = 1;
        goto <D.20316>;
        <D.20315>:
        D.20307 = flag_vals[i];
        if (D.20307 == 10) goto <D.20317>; else goto <D.20318>;
        <D.20317>:
        verify_partial_md = 1;
        <D.20318>:
        <D.20316>:
        <D.20313>:
        <D.20310>:
        D.20307 = flag_vals[i];
        if (D.20307 == 134217728) goto <D.20319>; else goto <D.20320>;
        <D.20319>:
        verifier_mode = 1;
        goto <D.20321>;
        <D.20320>:
        D.20307 = flag_vals[i];
        verify_flags.4 = (unsigned int) verify_flags;
        D.20323 = D.20307 | verify_flags.4;
        verify_flags = (int) D.20323;
        <D.20321>:
        goto <D.20181>;
        <D.20306>:
        i = i + 1;
        <D.20183>:
        D.20304 = flag_desc[i];
        if (D.20304 != 0B) goto <D.20182>; else goto <D.20181>;
        <D.20181>:
        D.20304 = flag_desc[i];
        if (D.20304 == 0B) goto <D.20324>; else goto <D.20325>;
        <D.20324>:
        monoeg_g_print ("Unknown verify flag %s\n", tok);
        <D.20325>:
        tok = strtok (0B, ",");
        <D.20185>:
        if (tok != 0B) goto <D.20184>; else goto <D.20186>;
        <D.20186>:
        mono_verifier_set_mode (verifier_mode);
      }
      <D.20303>:
      verify_pe.3 = verify_pe;
      D.20326 = verify_pe.3 | run_new_metadata_verifier;
      if (D.20326 != 0) goto <D.20327>; else goto <D.20328>;
      <D.20327>:
      run_new_metadata_verifier = 1;
      <D.20328>:
      if (run_new_metadata_verifier != 0) goto <D.20329>; else goto <D.20330>;
      <D.20329>:
      mono_verifier_set_mode (verifier_mode);
      image_result = verify_image_file (file);
      if (image_result == 1) goto <D.20331>; else goto <D.20333>;
      <D.20333>:
      verify_code.5 = verify_code;
      if (verify_code.5 == 0) goto <D.20331>; else goto <D.20332>;
      <D.20331>:
      D.20335 = image_result;
      return D.20335;
      <D.20332>:
      <D.20330>:
      image = mono_image_open (file, 0B);
      if (image == 0B) goto <D.20336>; else goto <D.20337>;
      <D.20336>:
      stderr.6 = stderr;
      fprintf (stderr.6, "Cannot open image %s\n", file);
      exit (1);
      <D.20337>:
      dump_data.7 = dump_data;
      if (dump_data.7 != 0) goto <D.20340>; else goto <D.20341>;
      <D.20340>:
      dump_dotnet_iinfo (image);
      <D.20341>:
      verify_pe.3 = verify_pe;
      if (verify_pe.3 != 0) goto <D.20342>; else goto <D.20343>;
      <D.20342>:
      {
        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.20344>; else goto <D.20345>;
            <D.20344>:
            image = mono_image_open (file, &status);
            if (image != 0B) goto <D.20346>; else goto <D.20347>;
            <D.20346>:
            D.20348 = BIT_FIELD_REF <*image, 32, 3904>;
            D.20349 = D.20348 & 16777215;
            if (D.20349 == 0) goto <D.20350>; else goto <D.20351>;
            <D.20350>:
            assembly = monoeg_malloc0 (92);
            assembly->in_gac = 0;
            assembly->image = image;
            image->assembly = assembly;
            <D.20351>:
            <D.20347>:
            <D.20345>:
            if (assembly == 0B) goto <D.20352>; else goto <D.20353>;
            <D.20352>:
            monoeg_g_print ("Could not open assembly %s\n", file);
            D.20335 = 4;
            return D.20335;
            <D.20353>:
            D.20354 = assembly->image;
            code_result = dump_verify_info (D.20354, verify_flags);
            if (code_result != 0) goto <D.20356>; else goto <D.20357>;
            <D.20356>:
            iftmp.8 = code_result;
            goto <D.20358>;
            <D.20357>:
            iftmp.8 = image_result;
            <D.20358>:
            D.20335 = iftmp.8;
            return D.20335;
          }
        finally
          {
            status = {CLOBBER};
          }
      }
      <D.20343>:
      mono_image_close (image);
      D.20335 = 0;
      return D.20335;
    }
  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.20362;

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


verify_image_file (const char * fname)
{
  int D.20372;
  int D.20373;
  int D.20375;
  int D.20378;
  int D.20380;
  int D.20383;
  struct MonoAssemblyName * D.20385;
  char * D.20386;
  int verify_partial_md.9;
  int D.20390;
  int D.20392;
  unsigned char D.20397;
  struct MonoLoaderError * D.20399;
  const char * D.20400;
  const char * D.20401;
  struct MonoLoaderError * D.20405;
  <unnamed-unsigned:24> D.20406;
  int D.20407;
  <unnamed type> D.20410;
  const char * D.20411;
  char * D.20412;
  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.20370>; else goto <D.20371>;
      <D.20370>:
      printf ("Could not open %s\n", fname);
      D.20372 = 1;
      return D.20372;
      <D.20371>:
      D.20373 = mono_verifier_verify_pe_data (image, &errors);
      if (D.20373 == 0) goto invalid_image; else goto <D.20374>;
      <D.20374>:
      D.20375 = mono_image_load_pe_data (image);
      if (D.20375 == 0) goto <D.20376>; else goto <D.20377>;
      <D.20376>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.20372 = 1;
      return D.20372;
      <D.20377>:
      D.20378 = mono_verifier_verify_cli_data (image, &errors);
      if (D.20378 == 0) goto invalid_image; else goto <D.20379>;
      <D.20379>:
      D.20380 = mono_image_load_cli_data (image);
      if (D.20380 == 0) goto <D.20381>; else goto <D.20382>;
      <D.20381>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.20372 = 1;
      return D.20372;
      <D.20382>:
      D.20383 = mono_verifier_verify_table_data (image, &errors);
      if (D.20383 == 0) goto invalid_image; else goto <D.20384>;
      <D.20384>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (92);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.20385 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.20385);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.20386 = image->version;
      mono_init_version ("pedump", D.20386);
      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.20388>; else goto <D.20389>;
      <D.20388>:
      D.20390 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.20390 == 0) goto invalid_image; else goto <D.20391>;
      <D.20391>:
      <D.20389>:
      table = &image->tables[2];
      i = 1;
      goto <D.20084>;
      <D.20083>:
      {
        guint32 token;
        struct MonoClass * class;

        D.20392 = i | 33554432;
        token = (guint32) D.20392;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.20393>; else goto <D.20394>;
        <D.20393>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.20082>;
        <D.20394>:
        mono_class_init (class);
        D.20397 = class->exception_type;
        if (D.20397 != 0) goto <D.20395>; else goto <D.20398>;
        <D.20398>:
        D.20399 = mono_loader_get_last_error ();
        if (D.20399 != 0B) goto <D.20395>; else goto <D.20396>;
        <D.20395>:
        D.20400 = class->name_space;
        D.20401 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.20400, D.20401);
        mono_loader_clear_error ();
        count = count + 1;
        <D.20396>:
        mono_class_setup_vtable (class);
        D.20397 = class->exception_type;
        if (D.20397 != 0) goto <D.20402>; else goto <D.20404>;
        <D.20404>:
        D.20405 = mono_loader_get_last_error ();
        if (D.20405 != 0B) goto <D.20402>; else goto <D.20403>;
        <D.20402>:
        D.20400 = class->name_space;
        D.20401 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.20400, D.20401);
        mono_loader_clear_error ();
        count = count + 1;
        <D.20403>:
      }
      <D.20082>:
      i = i + 1;
      <D.20084>:
      D.20406 = table->rows;
      D.20407 = (int) D.20406;
      if (D.20407 >= i) goto <D.20083>; else goto <D.20085>;
      <D.20085>:
      if (count != 0) goto <D.20408>; else goto <D.20409>;
      <D.20408>:
      D.20372 = 5;
      return D.20372;
      <D.20409>:
      D.20372 = 0;
      return D.20372;
      invalid_image:
      tmp = errors;
      goto <D.20088>;
      <D.20087>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.20410 = info->status;
        D.20411 = desc[D.20410];
        D.20412 = info->message;
        monoeg_g_print ("%s: %s\n", D.20411, D.20412);
        D.20410 = info->status;
        if (D.20410 == 1) goto <D.20413>; else goto <D.20414>;
        <D.20413>:
        count = count + 1;
        <D.20414>:
      }
      tmp = tmp->next;
      <D.20088>:
      if (tmp != 0B) goto <D.20087>; else goto <D.20089>;
      <D.20089>:
      errors.10 = errors;
      mono_free_verify_list (errors.10);
      if (count != 0) goto <D.20416>; else goto <D.20417>;
      <D.20416>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.20417>:
      D.20372 = 1;
      return D.20372;
    }
  finally
    {
      errors = {CLOBBER};
      status = {CLOBBER};
      desc = {CLOBBER};
    }
}


pedump_preload (struct MonoAssemblyName * aname, gchar * * assemblies_path, void * user_data)
{
  gchar * D.20422;
  const char * D.20425;
  const char * D.20426;
  struct MonoAssembly * D.20427;
  struct MonoAssembly * result;
  gboolean refonly;

  result = 0B;
  refonly = (gboolean) user_data;
  if (assemblies_path != 0B) goto <D.20420>; else goto <D.20421>;
  <D.20420>:
  D.20422 = *assemblies_path;
  if (D.20422 != 0B) goto <D.20423>; else goto <D.20424>;
  <D.20423>:
  D.20425 = aname->culture;
  D.20426 = aname->name;
  result = real_load (assemblies_path, D.20425, D.20426, refonly);
  <D.20424>:
  <D.20421>:
  D.20427 = result;
  return D.20427;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.20433;
  unsigned int D.20434;
  gchar * D.20435;
  char D.20436;
  sizetype len.11;
  sizetype D.20440;
  gchar * D.20441;
  int D.20442;
  int D.20444;
  int D.20446;
  int D.20448;
  struct MonoAssembly * D.20450;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.20429>; else goto <D.20432>;
      <D.20432>:
      D.20433 = *culture;
      if (D.20433 == 0) goto <D.20429>; else goto <D.20430>;
      <D.20429>:
      local_culture = "";
      goto <D.20431>;
      <D.20430>:
      local_culture = culture;
      <D.20431>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.20434 = strlen (filename);
      len = (gint) D.20434;
      path = search_path;
      goto <D.20113>;
      <D.20112>:
      D.20435 = *path;
      D.20436 = *D.20435;
      if (D.20436 == 0) goto <D.20437>; else goto <D.20438>;
      <D.20437>:
      // predicted unlikely by continue predictor.
      goto <D.20110>;
      <D.20438>:
      len.11 = (sizetype) len;
      D.20440 = len.11 + 4294967292;
      D.20441 = filename + D.20440;
      strcpy (D.20441, ".dll");
      D.20435 = *path;
      D.20442 = try_load_from (&result, D.20435, local_culture, "", filename, refonly);
      if (D.20442 != 0) goto <D.20111>; else goto <D.20443>;
      <D.20443>:
      len.11 = (sizetype) len;
      D.20440 = len.11 + 4294967292;
      D.20441 = filename + D.20440;
      strcpy (D.20441, ".exe");
      D.20435 = *path;
      D.20444 = try_load_from (&result, D.20435, local_culture, "", filename, refonly);
      if (D.20444 != 0) goto <D.20111>; else goto <D.20445>;
      <D.20445>:
      len.11 = (sizetype) len;
      D.20440 = len.11 + 4294967292;
      D.20441 = filename + D.20440;
      strcpy (D.20441, ".dll");
      D.20435 = *path;
      D.20446 = try_load_from (&result, D.20435, local_culture, name, filename, refonly);
      if (D.20446 != 0) goto <D.20111>; else goto <D.20447>;
      <D.20447>:
      len.11 = (sizetype) len;
      D.20440 = len.11 + 4294967292;
      D.20441 = filename + D.20440;
      strcpy (D.20441, ".exe");
      D.20435 = *path;
      D.20448 = try_load_from (&result, D.20435, local_culture, name, filename, refonly);
      if (D.20448 != 0) goto <D.20111>; else goto <D.20449>;
      <D.20449>:
      <D.20110>:
      path = path + 4;
      <D.20113>:
      D.20435 = *path;
      if (D.20435 != 0B) goto <D.20112>; else goto <D.20111>;
      <D.20111>:
      monoeg_g_free (filename);
      D.20450 = result;
      return D.20450;
    }
  finally
    {
      result = {CLOBBER};
    }
}


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

  D.20454 = __builtin_object_size (__dest, 1);
  D.20453 = __builtin___strcpy_chk (__dest, __src, D.20454);
  return D.20453;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.20456;
  struct MonoAssembly * D.20459;
  gboolean D.20460;
  struct MonoAssembly * D.20461;
  _Bool D.20462;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.20456 = monoeg_g_file_test (fullpath, 1);
  if (D.20456 != 0) goto <D.20457>; else goto <D.20458>;
  <D.20457>:
  D.20459 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.20459;
  <D.20458>:
  monoeg_g_free (fullpath);
  D.20461 = *assembly;
  D.20462 = D.20461 != 0B;
  D.20460 = (gboolean) D.20462;
  return D.20460;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.20464;
  int D.20465;
  struct MonoAssembly * D.20468;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.20133>;
  <D.20132>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.20464 = &ass->aname;
    D.20465 = mono_assembly_names_equal (aname, D.20464);
    if (D.20465 != 0) goto <D.20466>; else goto <D.20467>;
    <D.20466>:
    D.20468 = ass;
    return D.20468;
    <D.20467>:
  }
  tmp = tmp->next;
  <D.20133>:
  if (tmp != 0B) goto <D.20132>; else goto <D.20134>;
  <D.20134>:
  D.20468 = 0B;
  return D.20468;
}


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

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.20474;
  struct MonoCLIHeader * D.20475;
  unsigned int D.20476;
  struct MonoCLIImageInfo * iinfo;

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


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.20477;
  struct MonoPEHeader * D.20478;
  struct MonoPEHeaderNT * D.20479;
  struct MonoPEDatadir * D.20480;

  D.20477 = &header->coff;
  dump_coff_header (D.20477);
  D.20478 = &header->pe;
  dump_pe_header (D.20478);
  D.20479 = &header->nt;
  dump_nt_header (D.20479);
  D.20480 = &header->datadir;
  dump_datadir (D.20480);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.20481;
  short unsigned int D.20482;
  unsigned int D.20483;
  unsigned int D.20484;
  unsigned int D.20485;
  short unsigned int D.20486;
  short unsigned int D.20487;

  printf ("\nCOFF Header:\n");
  D.20481 = coff->coff_machine;
  hex16 ("                Machine", D.20481);
  D.20482 = coff->coff_sections;
  hex16 ("               Sections", D.20482);
  D.20483 = coff->coff_time;
  hex32 ("             Time stamp", D.20483);
  D.20484 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.20484);
  D.20485 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.20485);
  D.20486 = coff->coff_opt_header_size;
  hex16 ("   Optional Header Size", D.20486);
  D.20487 = coff->coff_attributes;
  hex16 ("   \tCharacteristics", D.20487);
}


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


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

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


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.20489;
  unsigned char D.20490;
  unsigned char D.20491;
  unsigned int D.20492;
  unsigned int D.20493;
  unsigned int D.20494;
  unsigned int D.20495;
  unsigned int D.20496;
  unsigned int D.20497;

  printf ("\nPE Header:\n");
  D.20489 = pe->pe_magic;
  hex16 ("         Magic (0x010b)", D.20489);
  D.20490 = pe->pe_major;
  hex8 ("             LMajor (6)", D.20490);
  D.20491 = pe->pe_minor;
  hex8 ("             LMinor (0)", D.20491);
  D.20492 = pe->pe_code_size;
  hex32 ("              Code Size", D.20492);
  D.20493 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.20493);
  D.20494 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.20494);
  D.20495 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.20495);
  D.20496 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.20496);
  D.20497 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.20497);
  printf ("\n");
}


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

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


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.20499;
  unsigned int D.20500;
  unsigned int D.20501;
  short unsigned int D.20502;
  short unsigned int D.20503;
  short unsigned int D.20504;
  short unsigned int D.20505;
  short unsigned int D.20506;
  short unsigned int D.20507;
  unsigned int D.20508;
  unsigned int D.20509;
  unsigned int D.20510;
  unsigned int D.20511;
  short unsigned int D.20512;
  short unsigned int D.20513;
  unsigned int D.20514;
  unsigned int D.20515;
  unsigned int D.20516;
  unsigned int D.20517;
  unsigned int D.20518;
  unsigned int D.20519;

  printf ("\nNT Header:\n");
  D.20499 = nt->pe_image_base;
  hex32 ("   Image Base (0x400000)", D.20499);
  D.20500 = nt->pe_section_align;
  hex32 ("Section Alignment (8192)", D.20500);
  D.20501 = nt->pe_file_alignment;
  hex32 ("   File Align (512/4096)", D.20501);
  D.20502 = nt->pe_os_major;
  hex16 ("            OS Major (4)", D.20502);
  D.20503 = nt->pe_os_minor;
  hex16 ("            OS Minor (0)", D.20503);
  D.20504 = nt->pe_user_major;
  hex16 ("  \t  User Major (0)", D.20504);
  D.20505 = nt->pe_user_minor;
  hex16 ("  \t  User Minor (0)", D.20505);
  D.20506 = nt->pe_subsys_major;
  hex16 ("  \tSubsys major (4)", D.20506);
  D.20507 = nt->pe_subsys_minor;
  hex16 ("  \tSubsys minor (0)", D.20507);
  D.20508 = nt->pe_reserved_1;
  hex32 (" \t       Reserverd", D.20508);
  D.20509 = nt->pe_image_size;
  hex32 (" \t      Image Size", D.20509);
  D.20510 = nt->pe_header_size;
  hex32 (" \t     Header Size", D.20510);
  D.20511 = nt->pe_checksum;
  hex32 ("            Checksum (0)", D.20511);
  D.20512 = nt->pe_subsys_required;
  hex16 ("               Subsystem", D.20512);
  D.20513 = nt->pe_dll_flags;
  hex16 ("           DLL Flags (0)", D.20513);
  D.20514 = nt->pe_stack_reserve;
  hex32 (" Stack Reserve Size (1M)", D.20514);
  D.20515 = nt->pe_stack_commit;
  hex32 ("Stack commit Size (4096)", D.20515);
  D.20516 = nt->pe_heap_reserve;
  hex32 ("  Heap Reserve Size (1M)", D.20516);
  D.20517 = nt->pe_heap_commit;
  hex32 (" Heap Commit Size (4096)", D.20517);
  D.20518 = nt->pe_loader_flags;
  hex32 ("      Loader flags (0x1)", D.20518);
  D.20519 = nt->pe_data_dir_count;
  hex32 ("   Data Directories (16)", D.20519);
}


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.20520;
  unsigned int D.20521;

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


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.20522;
  struct MonoSectionTable * D.20523;
  unsigned int i.14;
  unsigned int D.20525;
  struct MonoSectionTable * D.20526;
  const int top;
  int i;

  D.20522 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.20522;
  i = 0;
  goto <D.20008>;
  <D.20007>:
  D.20523 = iinfo->cli_section_tables;
  i.14 = (unsigned int) i;
  D.20525 = i.14 * 40;
  D.20526 = D.20523 + D.20525;
  dump_section_table (D.20526);
  i = i + 1;
  <D.20008>:
  if (i < top) goto <D.20007>; else goto <D.20009>;
  <D.20009>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.20527;
  unsigned int D.20528;
  unsigned int D.20529;
  unsigned int D.20530;
  unsigned int D.20531;
  unsigned int D.20532;
  unsigned int D.20533;
  short unsigned int D.20534;
  short unsigned int D.20535;
  const char * iftmp.15;
  unsigned int D.20537;
  const char * iftmp.16;
  unsigned int D.20542;
  const char * iftmp.17;
  unsigned int D.20547;
  const char * iftmp.18;
  unsigned int D.20552;
  const char * iftmp.19;
  unsigned int D.20557;
  const char * iftmp.20;
  unsigned int D.20562;
  const char * iftmp.21;
  unsigned int D.20567;
  const char * iftmp.22;
  unsigned int D.20572;
  const char * iftmp.23;
  unsigned int D.20577;
  const char * iftmp.24;
  signed int flags.25;
  guint32 flags;

  flags = st->st_flags;
  D.20527 = &st->st_name;
  printf ("\n\tName: %s\n", D.20527);
  D.20528 = st->st_virtual_size;
  hex32 ("   Virtual Size", D.20528);
  D.20529 = st->st_virtual_address;
  hex32 ("Virtual Address", D.20529);
  D.20530 = st->st_raw_data_size;
  hex32 ("  Raw Data Size", D.20530);
  D.20531 = st->st_raw_data_ptr;
  hex32 ("   Raw Data Ptr", D.20531);
  D.20532 = st->st_reloc_ptr;
  hex32 ("      Reloc Ptr", D.20532);
  D.20533 = st->st_lineno_ptr;
  hex32 ("     LineNo Ptr", D.20533);
  D.20534 = st->st_reloc_count;
  hex16 ("    Reloc Count", D.20534);
  D.20535 = st->st_line_count;
  hex16 ("     Line Count", D.20535);
  D.20537 = flags & 32;
  if (D.20537 != 0) goto <D.20538>; else goto <D.20539>;
  <D.20538>:
  iftmp.15 = "code, ";
  goto <D.20540>;
  <D.20539>:
  iftmp.15 = "";
  <D.20540>:
  D.20542 = flags & 64;
  if (D.20542 != 0) goto <D.20543>; else goto <D.20544>;
  <D.20543>:
  iftmp.16 = "data, ";
  goto <D.20545>;
  <D.20544>:
  iftmp.16 = "";
  <D.20545>:
  D.20547 = flags & 128;
  if (D.20547 != 0) goto <D.20548>; else goto <D.20549>;
  <D.20548>:
  iftmp.17 = "bss, ";
  goto <D.20550>;
  <D.20549>:
  iftmp.17 = "";
  <D.20550>:
  D.20552 = flags & 33554432;
  if (D.20552 != 0) goto <D.20553>; else goto <D.20554>;
  <D.20553>:
  iftmp.18 = "discard, ";
  goto <D.20555>;
  <D.20554>:
  iftmp.18 = "";
  <D.20555>:
  D.20557 = flags & 67108864;
  if (D.20557 != 0) goto <D.20558>; else goto <D.20559>;
  <D.20558>:
  iftmp.19 = "nocache, ";
  goto <D.20560>;
  <D.20559>:
  iftmp.19 = "";
  <D.20560>:
  D.20562 = flags & 134217728;
  if (D.20562 != 0) goto <D.20563>; else goto <D.20564>;
  <D.20563>:
  iftmp.20 = "nopage, ";
  goto <D.20565>;
  <D.20564>:
  iftmp.20 = "";
  <D.20565>:
  D.20567 = flags & 268435456;
  if (D.20567 != 0) goto <D.20568>; else goto <D.20569>;
  <D.20568>:
  iftmp.21 = "shared, ";
  goto <D.20570>;
  <D.20569>:
  iftmp.21 = "";
  <D.20570>:
  D.20572 = flags & 536870912;
  if (D.20572 != 0) goto <D.20573>; else goto <D.20574>;
  <D.20573>:
  iftmp.22 = "exec, ";
  goto <D.20575>;
  <D.20574>:
  iftmp.22 = "";
  <D.20575>:
  D.20577 = flags & 1073741824;
  if (D.20577 != 0) goto <D.20578>; else goto <D.20579>;
  <D.20578>:
  iftmp.23 = "read, ";
  goto <D.20580>;
  <D.20579>:
  iftmp.23 = "";
  <D.20580>:
  flags.25 = (signed int) flags;
  if (flags.25 < 0) goto <D.20583>; else goto <D.20584>;
  <D.20583>:
  iftmp.24 = "write";
  goto <D.20585>;
  <D.20584>:
  iftmp.24 = "";
  <D.20585>:
  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.20586;
  short unsigned int D.20587;
  int D.20588;
  short unsigned int D.20589;
  int D.20590;
  const char * iftmp.26;
  unsigned int D.20592;
  unsigned int D.20593;
  const char * iftmp.27;
  unsigned int D.20598;
  const char * iftmp.28;
  unsigned int D.20603;
  const char * iftmp.29;
  unsigned int D.20608;
  unsigned int D.20612;

  printf ("\n");
  D.20586 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.20586);
  D.20587 = ch->ch_runtime_major;
  D.20588 = (int) D.20587;
  D.20589 = ch->ch_runtime_minor;
  D.20590 = (int) D.20589;
  printf ("         Runtime required: %d.%d\n", D.20588, D.20590);
  D.20592 = ch->ch_flags;
  D.20593 = D.20592 & 1;
  if (D.20593 != 0) goto <D.20594>; else goto <D.20595>;
  <D.20594>:
  iftmp.26 = "ilonly";
  goto <D.20596>;
  <D.20595>:
  iftmp.26 = "contains native";
  <D.20596>:
  D.20592 = ch->ch_flags;
  D.20598 = D.20592 & 2;
  if (D.20598 != 0) goto <D.20599>; else goto <D.20600>;
  <D.20599>:
  iftmp.27 = "32bits";
  goto <D.20601>;
  <D.20600>:
  iftmp.27 = "32/64";
  <D.20601>:
  D.20592 = ch->ch_flags;
  D.20603 = D.20592 & 65536;
  if (D.20603 != 0) goto <D.20604>; else goto <D.20605>;
  <D.20604>:
  iftmp.28 = "trackdebug";
  goto <D.20606>;
  <D.20605>:
  iftmp.28 = "no-trackdebug";
  <D.20606>:
  D.20592 = ch->ch_flags;
  D.20608 = D.20592 & 8;
  if (D.20608 != 0) goto <D.20609>; else goto <D.20610>;
  <D.20609>:
  iftmp.29 = "strongnamesigned";
  goto <D.20611>;
  <D.20610>:
  iftmp.29 = "notsigned";
  <D.20611>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.26, iftmp.27, iftmp.28, iftmp.29);
  dent ("         Metadata", ch->ch_metadata);
  D.20612 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.20612);
  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.20617;
  sizetype i.32;
  const char * D.20621;
  char D.20622;
  int D.20623;
  unsigned int i.33;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.20614>; else goto <D.20615>;
  <D.20614>:
  printf (" none\n");
  return;
  <D.20615>:
  i = 0;
  goto <D.19980>;
  <D.19979>:
  i.31 = (unsigned int) i;
  D.20617 = i.31 & 15;
  if (D.20617 == 0) goto <D.20618>; else goto <D.20619>;
  <D.20618>:
  printf ("\n\t");
  <D.20619>:
  i.32 = (sizetype) i;
  D.20621 = p + i.32;
  D.20622 = *D.20621;
  D.20623 = (int) D.20622;
  printf (" %02X", D.20623);
  i = i + 1;
  <D.19980>:
  i.33 = (unsigned int) i;
  if (i.33 < size) goto <D.19979>; else goto <D.19981>;
  <D.19981>:
  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.20627;
  const char * D.20630;
  int D.20631;
  unsigned char D.20632;
  int D.20633;
  const char * D.20634;
  int D.20635;
  char * D.20636;
  int D.20637;
  int D.20638;
  unsigned int D.20639;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.20030>;
  <D.20029>:
  D.20627 = meta->tables[table].rows;
  if (D.20627 == 0) goto <D.20628>; else goto <D.20629>;
  <D.20628>:
  // predicted unlikely by continue predictor.
  goto <D.20028>;
  <D.20629>:
  D.20630 = mono_meta_table_name (table);
  D.20627 = meta->tables[table].rows;
  D.20631 = (int) D.20627;
  D.20632 = meta->tables[table].row_size;
  D.20633 = (int) D.20632;
  D.20634 = meta->tables[table].base;
  D.20635 = (int) D.20634;
  D.20636 = meta->raw_data;
  D.20637 = (int) D.20636;
  D.20638 = D.20635 - D.20637;
  D.20639 = (unsigned int) D.20638;
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.20630, D.20631, D.20633, D.20639);
  <D.20028>:
  table = table + 1;
  <D.20030>:
  if (table <= 44) goto <D.20029>; else goto <D.20031>;
  <D.20031>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.20640;
  int D.20641;
  short int D.20642;
  int D.20643;
  char * D.20644;

  printf ("\nMetadata header:\n");
  D.20640 = meta->md_version_major;
  D.20641 = (int) D.20640;
  D.20642 = meta->md_version_minor;
  D.20643 = (int) D.20642;
  printf ("           Version: %d.%d\n", D.20641, D.20643);
  D.20644 = meta->version;
  printf ("    Version string: %s\n", D.20644);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.20645;
  struct MonoStreamHeader * D.20646;
  struct MonoStreamHeader * D.20647;
  struct MonoStreamHeader * D.20648;
  struct MonoStreamHeader * D.20649;

  printf ("\nMetadata pointers:\n");
  D.20645 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.20645);
  D.20646 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.20646);
  D.20647 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.20647);
  D.20648 = &meta->heap_us;
  dsh ("\tUser string", meta, D.20648);
  D.20649 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.20649);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  const char * D.20650;
  int D.20651;
  char * D.20652;
  int D.20653;
  int D.20654;
  unsigned int D.20655;
  const char * D.20656;
  int D.20657;
  int D.20658;

  D.20650 = sh->data;
  D.20651 = (int) D.20650;
  D.20652 = meta->raw_metadata;
  D.20653 = (int) D.20652;
  D.20654 = D.20651 - D.20653;
  D.20650 = sh->data;
  D.20655 = sh->size;
  D.20656 = D.20650 + D.20655;
  D.20657 = (int) D.20656;
  D.20652 = meta->raw_metadata;
  D.20653 = (int) D.20652;
  D.20658 = D.20657 - D.20653;
  D.20655 = sh->size;
  D.20655 = sh->size;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.20654, D.20658, D.20655, D.20655);
}


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

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


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.35;
  int D.20667;
  int D.20668;
  unsigned int D.20669;
  struct MonoType * D.20674;
  struct MonoMethodSignature * D.20675;
  const char * D.20678;
  struct MonoMethodSignature * D.20680;
  const char * D.20681;
  <unnamed type> D.20682;
  const char * D.20683;
  char * D.20684;
  <unnamed-unsigned:24> D.20691;
  int D.20692;
  int D.20695;
  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.20665>; else goto <D.20666>;
      <D.20665>:
      {
        int i;
        struct MonoTableInfo * m;

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

          mono_loader_clear_error ();
          D.20667 = i + 1;
          D.20668 = D.20667 | 100663296;
          D.20669 = (unsigned int) D.20668;
          method = mono_get_method (image, D.20669, 0B);
          if (method == 0B) goto <D.20670>; else goto <D.20671>;
          <D.20670>:
          D.20667 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.20667);
          // predicted unlikely by continue predictor.
          goto <D.20053>;
          <D.20671>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.20672>; else goto <D.20673>;
          <D.20672>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.20674 = &klass->byval_arg;
            name = mono_type_full_name (D.20674);
            D.20675 = mono_method_signature (method);
            if (D.20675 == 0B) goto <D.20676>; else goto <D.20677>;
            <D.20676>:
            D.20678 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.20678);
            goto <D.20679>;
            <D.20677>:
            {
              char * sig;

              D.20680 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.20680, 0);
              D.20681 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.20681, sig);
              monoeg_g_free (sig);
            }
            <D.20679>:
            monoeg_g_free (name);
          }
          <D.20673>:
          tmp = errors;
          goto <D.20059>;
          <D.20058>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.20682 = info->status;
            D.20683 = desc[D.20682];
            D.20684 = info->message;
            monoeg_g_print ("%s: %s\n", D.20683, D.20684);
            D.20682 = info->status;
            if (D.20682 == 1) goto <D.20685>; else goto <D.20686>;
            <D.20685>:
            count = count + 1;
            verifiable = 3;
            <D.20686>:
            D.20682 = info->status;
            if (D.20682 == 8) goto <D.20687>; else goto <D.20688>;
            <D.20687>:
            if (verifiable <= 1) goto <D.20689>; else goto <D.20690>;
            <D.20689>:
            verifiable = 2;
            <D.20690>:
            <D.20688>:
          }
          tmp = tmp->next;
          <D.20059>:
          if (tmp != 0B) goto <D.20058>; else goto <D.20060>;
          <D.20060>:
          mono_free_verify_list (errors);
        }
        <D.20053>:
        i = i + 1;
        <D.20062>:
        D.20691 = m->rows;
        D.20692 = (int) D.20691;
        if (D.20692 > i) goto <D.20061>; else goto <D.20063>;
        <D.20063>:
      }
      <D.20666>:
      if (count != 0) goto <D.20693>; else goto <D.20694>;
      <D.20693>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.20694>:
      D.20695 = verifiable;
      return D.20695;
    }
  finally
    {
      desc = {CLOBBER};
    }
}