main (int argc, char * * argv)
{
  long unsigned int D.18545;
  long unsigned int D.18546;
  char * * D.18547;
  char * D.18548;
  char D.18549;
  int D.18499;
  int iftmp.0;
  int D.18498;
  const char[7] * D.18555;
  unsigned char D.18556;
  int D.18557;
  unsigned char D.18558;
  int D.18559;
  const unsigned char * D.18564;
  unsigned char D.18565;
  int D.18566;
  const unsigned char * D.18567;
  unsigned char D.18568;
  int D.18569;
  const unsigned char * D.18574;
  unsigned char D.18575;
  int D.18576;
  const unsigned char * D.18577;
  unsigned char D.18578;
  int D.18579;
  const unsigned char * D.18584;
  unsigned char D.18585;
  int D.18586;
  const unsigned char * D.18587;
  unsigned char D.18588;
  int D.18589;
  int D.18508;
  int iftmp.1;
  int D.18507;
  const char[9] * D.18597;
  unsigned char D.18598;
  int D.18599;
  unsigned char D.18600;
  int D.18601;
  const unsigned char * D.18606;
  unsigned char D.18607;
  int D.18608;
  const unsigned char * D.18609;
  unsigned char D.18610;
  int D.18611;
  const unsigned char * D.18616;
  unsigned char D.18617;
  int D.18618;
  const unsigned char * D.18619;
  unsigned char D.18620;
  int D.18621;
  const unsigned char * D.18626;
  unsigned char D.18627;
  int D.18628;
  const unsigned char * D.18629;
  unsigned char D.18630;
  int D.18631;
  int verify_pe.2;
  int D.18521;
  const char * D.18641;
  unsigned int D.18644;
  unsigned int verify_flags.3;
  unsigned int D.18660;
  int D.18663;
  int verify_code.4;
  int D.18672;
  struct _IO_FILE * stderr.5;
  int dump_data.6;
  long unsigned int D.18685;
  long unsigned int D.18686;
  struct MonoImage * D.18691;
  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 = *.LC10;
      flag_vals = *.LC11;
      verify_flags = 128;
      run_new_metadata_verifier = 0;
      i = 1;
      goto <D.18510>;
      <D.18509>:
      D.18545 = (long unsigned int) i;
      D.18546 = D.18545 * 8;
      D.18547 = argv + D.18546;
      D.18548 = *D.18547;
      D.18549 = *D.18548;
      if (D.18549 != 45) goto <D.18550>; else goto <D.18551>;
      <D.18550>:
      D.18545 = (long unsigned int) i;
      D.18546 = D.18545 * 8;
      D.18547 = argv + D.18546;
      file = *D.18547;
      // predicted unlikely by continue predictor.
      goto <D.18490>;
      <D.18551>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.18545 = (long unsigned int) i;
          D.18546 = D.18545 * 8;
          D.18547 = argv + D.18546;
          __s2 = *D.18547;
          D.18555 = "--help";
          D.18556 = MEM[(const unsigned char *)D.18555];
          D.18557 = (int) D.18556;
          D.18558 = *__s2;
          D.18559 = (int) D.18558;
          __result = D.18557 - D.18559;
          {
            if (__s2_len != 0) goto <D.18560>; else goto <D.18561>;
            <D.18560>:
            if (__result == 0) goto <D.18562>; else goto <D.18563>;
            <D.18562>:
            D.18564 = &MEM[(void *)"--help" + 1B];
            D.18565 = *D.18564;
            D.18566 = (int) D.18565;
            D.18567 = __s2 + 1;
            D.18568 = *D.18567;
            D.18569 = (int) D.18568;
            __result = D.18566 - D.18569;
            if (__s2_len > 1) goto <D.18570>; else goto <D.18571>;
            <D.18570>:
            if (__result == 0) goto <D.18572>; else goto <D.18573>;
            <D.18572>:
            D.18574 = &MEM[(void *)"--help" + 2B];
            D.18575 = *D.18574;
            D.18576 = (int) D.18575;
            D.18577 = __s2 + 2;
            D.18578 = *D.18577;
            D.18579 = (int) D.18578;
            __result = D.18576 - D.18579;
            if (__s2_len > 2) goto <D.18580>; else goto <D.18581>;
            <D.18580>:
            if (__result == 0) goto <D.18582>; else goto <D.18583>;
            <D.18582>:
            D.18584 = &MEM[(void *)"--help" + 3B];
            D.18585 = *D.18584;
            D.18586 = (int) D.18585;
            D.18587 = __s2 + 3;
            D.18588 = *D.18587;
            D.18589 = (int) D.18588;
            __result = D.18586 - D.18589;
            <D.18583>:
            <D.18581>:
            <D.18573>:
            <D.18571>:
            <D.18563>:
            <D.18561>:
          }
          D.18498 = __result;
        }
        iftmp.0 = -D.18498;
        goto <D.18590>;
        <D.18554>:
        D.18545 = (long unsigned int) i;
        D.18546 = D.18545 * 8;
        D.18547 = argv + D.18546;
        D.18548 = *D.18547;
        iftmp.0 = __builtin_strcmp (D.18548, "--help");
        <D.18590>:
        D.18499 = iftmp.0;
      }
      if (D.18499 == 0) goto <D.18591>; else goto <D.18592>;
      <D.18591>:
      usage ();
      goto <D.18593>;
      <D.18592>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.18545 = (long unsigned int) i;
          D.18546 = D.18545 * 8;
          D.18547 = argv + D.18546;
          __s2 = *D.18547;
          D.18597 = "--verify";
          D.18598 = MEM[(const unsigned char *)D.18597];
          D.18599 = (int) D.18598;
          D.18600 = *__s2;
          D.18601 = (int) D.18600;
          __result = D.18599 - D.18601;
          {
            if (__s2_len != 0) goto <D.18602>; else goto <D.18603>;
            <D.18602>:
            if (__result == 0) goto <D.18604>; else goto <D.18605>;
            <D.18604>:
            D.18606 = &MEM[(void *)"--verify" + 1B];
            D.18607 = *D.18606;
            D.18608 = (int) D.18607;
            D.18609 = __s2 + 1;
            D.18610 = *D.18609;
            D.18611 = (int) D.18610;
            __result = D.18608 - D.18611;
            if (__s2_len > 1) goto <D.18612>; else goto <D.18613>;
            <D.18612>:
            if (__result == 0) goto <D.18614>; else goto <D.18615>;
            <D.18614>:
            D.18616 = &MEM[(void *)"--verify" + 2B];
            D.18617 = *D.18616;
            D.18618 = (int) D.18617;
            D.18619 = __s2 + 2;
            D.18620 = *D.18619;
            D.18621 = (int) D.18620;
            __result = D.18618 - D.18621;
            if (__s2_len > 2) goto <D.18622>; else goto <D.18623>;
            <D.18622>:
            if (__result == 0) goto <D.18624>; else goto <D.18625>;
            <D.18624>:
            D.18626 = &MEM[(void *)"--verify" + 3B];
            D.18627 = *D.18626;
            D.18628 = (int) D.18627;
            D.18629 = __s2 + 3;
            D.18630 = *D.18629;
            D.18631 = (int) D.18630;
            __result = D.18628 - D.18631;
            <D.18625>:
            <D.18623>:
            <D.18615>:
            <D.18613>:
            <D.18605>:
            <D.18603>:
          }
          D.18507 = __result;
        }
        iftmp.1 = -D.18507;
        goto <D.18632>;
        <D.18596>:
        D.18545 = (long unsigned int) i;
        D.18546 = D.18545 * 8;
        D.18547 = argv + D.18546;
        D.18548 = *D.18547;
        iftmp.1 = __builtin_strcmp (D.18548, "--verify");
        <D.18632>:
        D.18508 = iftmp.1;
      }
      if (D.18508 == 0) goto <D.18633>; else goto <D.18634>;
      <D.18633>:
      verify_pe = 1;
      dump_data = 0;
      i = i + 1;
      D.18545 = (long unsigned int) i;
      D.18546 = D.18545 * 8;
      D.18547 = argv + D.18546;
      flags = *D.18547;
      goto <D.18635>;
      <D.18634>:
      usage ();
      <D.18635>:
      <D.18593>:
      <D.18490>:
      i = i + 1;
      <D.18510>:
      if (i < argc) goto <D.18509>; else goto <D.18511>;
      <D.18511>:
      if (file == 0B) goto <D.18636>; else goto <D.18637>;
      <D.18636>:
      usage ();
      <D.18637>:
      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.18639>; else goto <D.18640>;
      <D.18639>:
      {
        char * tok;

        tok = strtok (flags, ",");
        verify_metadata = 1;
        verify_code = 0;
        goto <D.18526>;
        <D.18525>:
        i = 0;
        goto <D.18524>;
        <D.18523>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.18641 = flag_desc[i];
          D.18521 = __builtin_strcmp (tok, D.18641);
        }
        if (D.18521 == 0) goto <D.18642>; else goto <D.18643>;
        <D.18642>:
        D.18644 = flag_vals[i];
        if (D.18644 == 8) goto <D.18645>; else goto <D.18646>;
        <D.18645>:
        verify_metadata = 0;
        verify_code = 1;
        goto <D.18647>;
        <D.18646>:
        D.18644 = flag_vals[i];
        if (D.18644 == 7) goto <D.18648>; else goto <D.18649>;
        <D.18648>:
        verify_code = 1;
        goto <D.18650>;
        <D.18649>:
        D.18644 = flag_vals[i];
        if (D.18644 == 9) goto <D.18651>; else goto <D.18652>;
        <D.18651>:
        verify_metadata = 0;
        run_new_metadata_verifier = 1;
        goto <D.18653>;
        <D.18652>:
        D.18644 = flag_vals[i];
        if (D.18644 == 10) goto <D.18654>; else goto <D.18655>;
        <D.18654>:
        verify_partial_md = 1;
        <D.18655>:
        <D.18653>:
        <D.18650>:
        <D.18647>:
        D.18644 = flag_vals[i];
        if (D.18644 == 134217728) goto <D.18656>; else goto <D.18657>;
        <D.18656>:
        verifier_mode = 1;
        goto <D.18658>;
        <D.18657>:
        D.18644 = flag_vals[i];
        verify_flags.3 = (unsigned int) verify_flags;
        D.18660 = D.18644 | verify_flags.3;
        verify_flags = (int) D.18660;
        <D.18658>:
        goto <D.18522>;
        <D.18643>:
        i = i + 1;
        <D.18524>:
        D.18641 = flag_desc[i];
        if (D.18641 != 0B) goto <D.18523>; else goto <D.18522>;
        <D.18522>:
        D.18641 = flag_desc[i];
        if (D.18641 == 0B) goto <D.18661>; else goto <D.18662>;
        <D.18661>:
        monoeg_g_print ("Unknown verify flag %s\n", tok);
        <D.18662>:
        tok = strtok (0B, ",");
        <D.18526>:
        if (tok != 0B) goto <D.18525>; else goto <D.18527>;
        <D.18527>:
        mono_verifier_set_mode (verifier_mode);
      }
      <D.18640>:
      verify_pe.2 = verify_pe;
      D.18663 = verify_pe.2 | run_new_metadata_verifier;
      if (D.18663 != 0) goto <D.18664>; else goto <D.18665>;
      <D.18664>:
      run_new_metadata_verifier = 1;
      <D.18665>:
      if (run_new_metadata_verifier != 0) goto <D.18666>; else goto <D.18667>;
      <D.18666>:
      mono_verifier_set_mode (verifier_mode);
      image_result = verify_image_file (file);
      if (image_result == 1) goto <D.18668>; else goto <D.18670>;
      <D.18670>:
      verify_code.4 = verify_code;
      if (verify_code.4 == 0) goto <D.18668>; else goto <D.18669>;
      <D.18668>:
      D.18672 = image_result;
      return D.18672;
      <D.18669>:
      <D.18667>:
      image = mono_image_open (file, 0B);
      if (image == 0B) goto <D.18673>; else goto <D.18674>;
      <D.18673>:
      stderr.5 = stderr;
      fprintf (stderr.5, "Cannot open image %s\n", file);
      exit (1);
      <D.18674>:
      dump_data.6 = dump_data;
      if (dump_data.6 != 0) goto <D.18677>; else goto <D.18678>;
      <D.18677>:
      dump_dotnet_iinfo (image);
      <D.18678>:
      verify_pe.2 = verify_pe;
      if (verify_pe.2 != 0) goto <D.18679>; else goto <D.18680>;
      <D.18679>:
      {
        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.18681>; else goto <D.18682>;
            <D.18681>:
            image = mono_image_open (file, &status);
            if (image != 0B) goto <D.18683>; else goto <D.18684>;
            <D.18683>:
            D.18685 = BIT_FIELD_REF <*image, 64, 5696>;
            D.18686 = D.18685 & 16777215;
            if (D.18686 == 0) goto <D.18687>; else goto <D.18688>;
            <D.18687>:
            assembly = monoeg_malloc0 (128);
            assembly->in_gac = 0;
            assembly->image = image;
            image->assembly = assembly;
            <D.18688>:
            <D.18684>:
            <D.18682>:
            if (assembly == 0B) goto <D.18689>; else goto <D.18690>;
            <D.18689>:
            monoeg_g_print ("Could not open assembly %s\n", file);
            D.18672 = 4;
            return D.18672;
            <D.18690>:
            D.18691 = assembly->image;
            code_result = dump_verify_info (D.18691, verify_flags);
            if (code_result != 0) goto <D.18693>; else goto <D.18694>;
            <D.18693>:
            iftmp.7 = code_result;
            goto <D.18695>;
            <D.18694>:
            iftmp.7 = image_result;
            <D.18695>:
            D.18672 = iftmp.7;
            return D.18672;
          }
        finally
          {
            status = {CLOBBER};
          }
      }
      <D.18680>:
      mono_image_close (image);
      D.18672 = 0;
      return D.18672;
    }
  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.18699;

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


verify_image_file (const char * fname)
{
  int D.18709;
  int D.18710;
  int D.18712;
  int D.18715;
  int D.18717;
  int D.18720;
  struct MonoAssemblyName * D.18722;
  char * D.18723;
  int verify_partial_md.8;
  int D.18727;
  int D.18729;
  unsigned char D.18734;
  struct MonoLoaderError * D.18736;
  const char * D.18737;
  const char * D.18738;
  struct MonoLoaderError * D.18742;
  <unnamed-unsigned:24> D.18743;
  int D.18744;
  <unnamed type> D.18747;
  const char * D.18748;
  char * D.18749;
  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 = *.LC17;
      image = mono_image_open_raw (fname, &status);
      if (image == 0B) goto <D.18707>; else goto <D.18708>;
      <D.18707>:
      printf ("Could not open %s\n", fname);
      D.18709 = 1;
      return D.18709;
      <D.18708>:
      D.18710 = mono_verifier_verify_pe_data (image, &errors);
      if (D.18710 == 0) goto invalid_image; else goto <D.18711>;
      <D.18711>:
      D.18712 = mono_image_load_pe_data (image);
      if (D.18712 == 0) goto <D.18713>; else goto <D.18714>;
      <D.18713>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.18709 = 1;
      return D.18709;
      <D.18714>:
      D.18715 = mono_verifier_verify_cli_data (image, &errors);
      if (D.18715 == 0) goto invalid_image; else goto <D.18716>;
      <D.18716>:
      D.18717 = mono_image_load_cli_data (image);
      if (D.18717 == 0) goto <D.18718>; else goto <D.18719>;
      <D.18718>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.18709 = 1;
      return D.18709;
      <D.18719>:
      D.18720 = mono_verifier_verify_table_data (image, &errors);
      if (D.18720 == 0) goto invalid_image; else goto <D.18721>;
      <D.18721>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (128);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.18722 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.18722);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.18723 = image->version;
      mono_init_version ("pedump", D.18723);
      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.18725>; else goto <D.18726>;
      <D.18725>:
      D.18727 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.18727 == 0) goto invalid_image; else goto <D.18728>;
      <D.18728>:
      <D.18726>:
      table = &image->tables[2];
      i = 1;
      goto <D.18425>;
      <D.18424>:
      {
        guint32 token;
        struct MonoClass * class;

        D.18729 = i | 33554432;
        token = (guint32) D.18729;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.18730>; else goto <D.18731>;
        <D.18730>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.18423>;
        <D.18731>:
        mono_class_init (class);
        D.18734 = class->exception_type;
        if (D.18734 != 0) goto <D.18732>; else goto <D.18735>;
        <D.18735>:
        D.18736 = mono_loader_get_last_error ();
        if (D.18736 != 0B) goto <D.18732>; else goto <D.18733>;
        <D.18732>:
        D.18737 = class->name_space;
        D.18738 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18737, D.18738);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18733>:
        mono_class_setup_vtable (class);
        D.18734 = class->exception_type;
        if (D.18734 != 0) goto <D.18739>; else goto <D.18741>;
        <D.18741>:
        D.18742 = mono_loader_get_last_error ();
        if (D.18742 != 0B) goto <D.18739>; else goto <D.18740>;
        <D.18739>:
        D.18737 = class->name_space;
        D.18738 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18737, D.18738);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18740>:
      }
      <D.18423>:
      i = i + 1;
      <D.18425>:
      D.18743 = table->rows;
      D.18744 = (int) D.18743;
      if (D.18744 >= i) goto <D.18424>; else goto <D.18426>;
      <D.18426>:
      if (count != 0) goto <D.18745>; else goto <D.18746>;
      <D.18745>:
      D.18709 = 5;
      return D.18709;
      <D.18746>:
      D.18709 = 0;
      return D.18709;
      invalid_image:
      tmp = errors;
      goto <D.18429>;
      <D.18428>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.18747 = info->status;
        D.18748 = desc[D.18747];
        D.18749 = info->message;
        monoeg_g_print ("%s: %s\n", D.18748, D.18749);
        D.18747 = info->status;
        if (D.18747 == 1) goto <D.18750>; else goto <D.18751>;
        <D.18750>:
        count = count + 1;
        <D.18751>:
      }
      tmp = tmp->next;
      <D.18429>:
      if (tmp != 0B) goto <D.18428>; else goto <D.18430>;
      <D.18430>:
      errors.9 = errors;
      mono_free_verify_list (errors.9);
      if (count != 0) goto <D.18753>; else goto <D.18754>;
      <D.18753>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18754>:
      D.18709 = 1;
      return D.18709;
    }
  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.18760;
  const char * D.18763;
  const char * D.18764;
  struct MonoAssembly * D.18765;
  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.18758>; else goto <D.18759>;
  <D.18758>:
  D.18760 = *assemblies_path;
  if (D.18760 != 0B) goto <D.18761>; else goto <D.18762>;
  <D.18761>:
  D.18763 = aname->culture;
  D.18764 = aname->name;
  result = real_load (assemblies_path, D.18763, D.18764, refonly);
  <D.18762>:
  <D.18759>:
  D.18765 = result;
  return D.18765;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.18771;
  long unsigned int D.18772;
  gchar * D.18773;
  char D.18774;
  sizetype D.18777;
  sizetype D.18778;
  gchar * D.18779;
  int D.18780;
  int D.18782;
  int D.18784;
  int D.18786;
  struct MonoAssembly * D.18788;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.18767>; else goto <D.18770>;
      <D.18770>:
      D.18771 = *culture;
      if (D.18771 == 0) goto <D.18767>; else goto <D.18768>;
      <D.18767>:
      local_culture = "";
      goto <D.18769>;
      <D.18768>:
      local_culture = culture;
      <D.18769>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.18772 = strlen (filename);
      len = (gint) D.18772;
      path = search_path;
      goto <D.18454>;
      <D.18453>:
      D.18773 = *path;
      D.18774 = *D.18773;
      if (D.18774 == 0) goto <D.18775>; else goto <D.18776>;
      <D.18775>:
      // predicted unlikely by continue predictor.
      goto <D.18451>;
      <D.18776>:
      D.18777 = (sizetype) len;
      D.18778 = D.18777 + 18446744073709551612;
      D.18779 = filename + D.18778;
      strcpy (D.18779, ".dll");
      D.18773 = *path;
      D.18780 = try_load_from (&result, D.18773, local_culture, "", filename, refonly);
      if (D.18780 != 0) goto <D.18452>; else goto <D.18781>;
      <D.18781>:
      D.18777 = (sizetype) len;
      D.18778 = D.18777 + 18446744073709551612;
      D.18779 = filename + D.18778;
      strcpy (D.18779, ".exe");
      D.18773 = *path;
      D.18782 = try_load_from (&result, D.18773, local_culture, "", filename, refonly);
      if (D.18782 != 0) goto <D.18452>; else goto <D.18783>;
      <D.18783>:
      D.18777 = (sizetype) len;
      D.18778 = D.18777 + 18446744073709551612;
      D.18779 = filename + D.18778;
      strcpy (D.18779, ".dll");
      D.18773 = *path;
      D.18784 = try_load_from (&result, D.18773, local_culture, name, filename, refonly);
      if (D.18784 != 0) goto <D.18452>; else goto <D.18785>;
      <D.18785>:
      D.18777 = (sizetype) len;
      D.18778 = D.18777 + 18446744073709551612;
      D.18779 = filename + D.18778;
      strcpy (D.18779, ".exe");
      D.18773 = *path;
      D.18786 = try_load_from (&result, D.18773, local_culture, name, filename, refonly);
      if (D.18786 != 0) goto <D.18452>; else goto <D.18787>;
      <D.18787>:
      <D.18451>:
      path = path + 8;
      <D.18454>:
      D.18773 = *path;
      if (D.18773 != 0B) goto <D.18453>; else goto <D.18452>;
      <D.18452>:
      monoeg_g_free (filename);
      D.18788 = result;
      return D.18788;
    }
  finally
    {
      result = {CLOBBER};
    }
}


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

  D.18792 = __builtin_object_size (__dest, 1);
  D.18791 = __builtin___strcpy_chk (__dest, __src, D.18792);
  return D.18791;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.18794;
  struct MonoAssembly * D.18797;
  gboolean D.18798;
  struct MonoAssembly * D.18799;
  _Bool D.18800;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.18794 = monoeg_g_file_test (fullpath, 1);
  if (D.18794 != 0) goto <D.18795>; else goto <D.18796>;
  <D.18795>:
  D.18797 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.18797;
  <D.18796>:
  monoeg_g_free (fullpath);
  D.18799 = *assembly;
  D.18800 = D.18799 != 0B;
  D.18798 = (gboolean) D.18800;
  return D.18798;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.18802;
  int D.18803;
  struct MonoAssembly * D.18806;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.18474>;
  <D.18473>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.18802 = &ass->aname;
    D.18803 = mono_assembly_names_equal (aname, D.18802);
    if (D.18803 != 0) goto <D.18804>; else goto <D.18805>;
    <D.18804>:
    D.18806 = ass;
    return D.18806;
    <D.18805>:
  }
  tmp = tmp->next;
  <D.18474>:
  if (tmp != 0B) goto <D.18473>; else goto <D.18475>;
  <D.18475>:
  D.18806 = 0B;
  return D.18806;
}


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

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.18812;
  struct MonoCLIHeader * D.18813;
  unsigned int D.18814;
  struct MonoCLIImageInfo * iinfo;

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


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.18815;
  struct MonoPEHeader * D.18816;
  struct MonoPEHeaderNT * D.18817;
  struct MonoPEDatadir * D.18818;

  D.18815 = &header->coff;
  dump_coff_header (D.18815);
  D.18816 = &header->pe;
  dump_pe_header (D.18816);
  D.18817 = &header->nt;
  dump_nt_header (D.18817);
  D.18818 = &header->datadir;
  dump_datadir (D.18818);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.18819;
  short unsigned int D.18820;
  unsigned int D.18821;
  unsigned int D.18822;
  unsigned int D.18823;
  short unsigned int D.18824;
  short unsigned int D.18825;

  printf ("\nCOFF Header:\n");
  D.18819 = coff->coff_machine;
  hex16 ("                Machine", D.18819);
  D.18820 = coff->coff_sections;
  hex16 ("               Sections", D.18820);
  D.18821 = coff->coff_time;
  hex32 ("             Time stamp", D.18821);
  D.18822 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.18822);
  D.18823 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.18823);
  D.18824 = coff->coff_opt_header_size;
  hex16 ("   Optional Header Size", D.18824);
  D.18825 = coff->coff_attributes;
  hex16 ("   \tCharacteristics", D.18825);
}


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


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

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


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.18827;
  unsigned char D.18828;
  unsigned char D.18829;
  unsigned int D.18830;
  unsigned int D.18831;
  unsigned int D.18832;
  unsigned int D.18833;
  unsigned int D.18834;
  unsigned int D.18835;

  printf ("\nPE Header:\n");
  D.18827 = pe->pe_magic;
  hex16 ("         Magic (0x010b)", D.18827);
  D.18828 = pe->pe_major;
  hex8 ("             LMajor (6)", D.18828);
  D.18829 = pe->pe_minor;
  hex8 ("             LMinor (0)", D.18829);
  D.18830 = pe->pe_code_size;
  hex32 ("              Code Size", D.18830);
  D.18831 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.18831);
  D.18832 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.18832);
  D.18833 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.18833);
  D.18834 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.18834);
  D.18835 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.18835);
  printf ("\n");
}


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

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


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.18837;
  unsigned int D.18838;
  unsigned int D.18839;
  short unsigned int D.18840;
  short unsigned int D.18841;
  short unsigned int D.18842;
  short unsigned int D.18843;
  short unsigned int D.18844;
  short unsigned int D.18845;
  unsigned int D.18846;
  unsigned int D.18847;
  unsigned int D.18848;
  unsigned int D.18849;
  short unsigned int D.18850;
  short unsigned int D.18851;
  unsigned int D.18852;
  unsigned int D.18853;
  unsigned int D.18854;
  unsigned int D.18855;
  unsigned int D.18856;
  unsigned int D.18857;

  printf ("\nNT Header:\n");
  D.18837 = nt->pe_image_base;
  hex32 ("   Image Base (0x400000)", D.18837);
  D.18838 = nt->pe_section_align;
  hex32 ("Section Alignment (8192)", D.18838);
  D.18839 = nt->pe_file_alignment;
  hex32 ("   File Align (512/4096)", D.18839);
  D.18840 = nt->pe_os_major;
  hex16 ("            OS Major (4)", D.18840);
  D.18841 = nt->pe_os_minor;
  hex16 ("            OS Minor (0)", D.18841);
  D.18842 = nt->pe_user_major;
  hex16 ("  \t  User Major (0)", D.18842);
  D.18843 = nt->pe_user_minor;
  hex16 ("  \t  User Minor (0)", D.18843);
  D.18844 = nt->pe_subsys_major;
  hex16 ("  \tSubsys major (4)", D.18844);
  D.18845 = nt->pe_subsys_minor;
  hex16 ("  \tSubsys minor (0)", D.18845);
  D.18846 = nt->pe_reserved_1;
  hex32 (" \t       Reserverd", D.18846);
  D.18847 = nt->pe_image_size;
  hex32 (" \t      Image Size", D.18847);
  D.18848 = nt->pe_header_size;
  hex32 (" \t     Header Size", D.18848);
  D.18849 = nt->pe_checksum;
  hex32 ("            Checksum (0)", D.18849);
  D.18850 = nt->pe_subsys_required;
  hex16 ("               Subsystem", D.18850);
  D.18851 = nt->pe_dll_flags;
  hex16 ("           DLL Flags (0)", D.18851);
  D.18852 = nt->pe_stack_reserve;
  hex32 (" Stack Reserve Size (1M)", D.18852);
  D.18853 = nt->pe_stack_commit;
  hex32 ("Stack commit Size (4096)", D.18853);
  D.18854 = nt->pe_heap_reserve;
  hex32 ("  Heap Reserve Size (1M)", D.18854);
  D.18855 = nt->pe_heap_commit;
  hex32 (" Heap Commit Size (4096)", D.18855);
  D.18856 = nt->pe_loader_flags;
  hex32 ("      Loader flags (0x1)", D.18856);
  D.18857 = nt->pe_data_dir_count;
  hex32 ("   Data Directories (16)", D.18857);
}


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.18858;
  unsigned int D.18859;

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


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.18860;
  struct MonoSectionTable * D.18861;
  long unsigned int D.18862;
  long unsigned int D.18863;
  struct MonoSectionTable * D.18864;
  const int top;
  int i;

  D.18860 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.18860;
  i = 0;
  goto <D.18349>;
  <D.18348>:
  D.18861 = iinfo->cli_section_tables;
  D.18862 = (long unsigned int) i;
  D.18863 = D.18862 * 40;
  D.18864 = D.18861 + D.18863;
  dump_section_table (D.18864);
  i = i + 1;
  <D.18349>:
  if (i < top) goto <D.18348>; else goto <D.18350>;
  <D.18350>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.18865;
  unsigned int D.18866;
  unsigned int D.18867;
  unsigned int D.18868;
  unsigned int D.18869;
  unsigned int D.18870;
  unsigned int D.18871;
  short unsigned int D.18872;
  short unsigned int D.18873;
  const char * iftmp.13;
  unsigned int D.18875;
  const char * iftmp.14;
  unsigned int D.18880;
  const char * iftmp.15;
  unsigned int D.18885;
  const char * iftmp.16;
  unsigned int D.18890;
  const char * iftmp.17;
  unsigned int D.18895;
  const char * iftmp.18;
  unsigned int D.18900;
  const char * iftmp.19;
  unsigned int D.18905;
  const char * iftmp.20;
  unsigned int D.18910;
  const char * iftmp.21;
  unsigned int D.18915;
  const char * iftmp.22;
  signed int flags.23;
  guint32 flags;

  flags = st->st_flags;
  D.18865 = &st->st_name;
  printf ("\n\tName: %s\n", D.18865);
  D.18866 = st->st_virtual_size;
  hex32 ("   Virtual Size", D.18866);
  D.18867 = st->st_virtual_address;
  hex32 ("Virtual Address", D.18867);
  D.18868 = st->st_raw_data_size;
  hex32 ("  Raw Data Size", D.18868);
  D.18869 = st->st_raw_data_ptr;
  hex32 ("   Raw Data Ptr", D.18869);
  D.18870 = st->st_reloc_ptr;
  hex32 ("      Reloc Ptr", D.18870);
  D.18871 = st->st_lineno_ptr;
  hex32 ("     LineNo Ptr", D.18871);
  D.18872 = st->st_reloc_count;
  hex16 ("    Reloc Count", D.18872);
  D.18873 = st->st_line_count;
  hex16 ("     Line Count", D.18873);
  D.18875 = flags & 32;
  if (D.18875 != 0) goto <D.18876>; else goto <D.18877>;
  <D.18876>:
  iftmp.13 = "code, ";
  goto <D.18878>;
  <D.18877>:
  iftmp.13 = "";
  <D.18878>:
  D.18880 = flags & 64;
  if (D.18880 != 0) goto <D.18881>; else goto <D.18882>;
  <D.18881>:
  iftmp.14 = "data, ";
  goto <D.18883>;
  <D.18882>:
  iftmp.14 = "";
  <D.18883>:
  D.18885 = flags & 128;
  if (D.18885 != 0) goto <D.18886>; else goto <D.18887>;
  <D.18886>:
  iftmp.15 = "bss, ";
  goto <D.18888>;
  <D.18887>:
  iftmp.15 = "";
  <D.18888>:
  D.18890 = flags & 33554432;
  if (D.18890 != 0) goto <D.18891>; else goto <D.18892>;
  <D.18891>:
  iftmp.16 = "discard, ";
  goto <D.18893>;
  <D.18892>:
  iftmp.16 = "";
  <D.18893>:
  D.18895 = flags & 67108864;
  if (D.18895 != 0) goto <D.18896>; else goto <D.18897>;
  <D.18896>:
  iftmp.17 = "nocache, ";
  goto <D.18898>;
  <D.18897>:
  iftmp.17 = "";
  <D.18898>:
  D.18900 = flags & 134217728;
  if (D.18900 != 0) goto <D.18901>; else goto <D.18902>;
  <D.18901>:
  iftmp.18 = "nopage, ";
  goto <D.18903>;
  <D.18902>:
  iftmp.18 = "";
  <D.18903>:
  D.18905 = flags & 268435456;
  if (D.18905 != 0) goto <D.18906>; else goto <D.18907>;
  <D.18906>:
  iftmp.19 = "shared, ";
  goto <D.18908>;
  <D.18907>:
  iftmp.19 = "";
  <D.18908>:
  D.18910 = flags & 536870912;
  if (D.18910 != 0) goto <D.18911>; else goto <D.18912>;
  <D.18911>:
  iftmp.20 = "exec, ";
  goto <D.18913>;
  <D.18912>:
  iftmp.20 = "";
  <D.18913>:
  D.18915 = flags & 1073741824;
  if (D.18915 != 0) goto <D.18916>; else goto <D.18917>;
  <D.18916>:
  iftmp.21 = "read, ";
  goto <D.18918>;
  <D.18917>:
  iftmp.21 = "";
  <D.18918>:
  flags.23 = (signed int) flags;
  if (flags.23 < 0) goto <D.18921>; else goto <D.18922>;
  <D.18921>:
  iftmp.22 = "write";
  goto <D.18923>;
  <D.18922>:
  iftmp.22 = "";
  <D.18923>:
  printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n", iftmp.13, iftmp.14, iftmp.15, iftmp.16, iftmp.17, iftmp.18, iftmp.19, iftmp.20, iftmp.21, iftmp.22);
}


dump_cli_header (struct MonoCLIHeader * ch)
{
  unsigned int D.18924;
  short unsigned int D.18925;
  int D.18926;
  short unsigned int D.18927;
  int D.18928;
  const char * iftmp.24;
  unsigned int D.18930;
  unsigned int D.18931;
  const char * iftmp.25;
  unsigned int D.18936;
  const char * iftmp.26;
  unsigned int D.18941;
  const char * iftmp.27;
  unsigned int D.18946;
  unsigned int D.18950;

  printf ("\n");
  D.18924 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.18924);
  D.18925 = ch->ch_runtime_major;
  D.18926 = (int) D.18925;
  D.18927 = ch->ch_runtime_minor;
  D.18928 = (int) D.18927;
  printf ("         Runtime required: %d.%d\n", D.18926, D.18928);
  D.18930 = ch->ch_flags;
  D.18931 = D.18930 & 1;
  if (D.18931 != 0) goto <D.18932>; else goto <D.18933>;
  <D.18932>:
  iftmp.24 = "ilonly";
  goto <D.18934>;
  <D.18933>:
  iftmp.24 = "contains native";
  <D.18934>:
  D.18930 = ch->ch_flags;
  D.18936 = D.18930 & 2;
  if (D.18936 != 0) goto <D.18937>; else goto <D.18938>;
  <D.18937>:
  iftmp.25 = "32bits";
  goto <D.18939>;
  <D.18938>:
  iftmp.25 = "32/64";
  <D.18939>:
  D.18930 = ch->ch_flags;
  D.18941 = D.18930 & 65536;
  if (D.18941 != 0) goto <D.18942>; else goto <D.18943>;
  <D.18942>:
  iftmp.26 = "trackdebug";
  goto <D.18944>;
  <D.18943>:
  iftmp.26 = "no-trackdebug";
  <D.18944>:
  D.18930 = ch->ch_flags;
  D.18946 = D.18930 & 8;
  if (D.18946 != 0) goto <D.18947>; else goto <D.18948>;
  <D.18947>:
  iftmp.27 = "strongnamesigned";
  goto <D.18949>;
  <D.18948>:
  iftmp.27 = "notsigned";
  <D.18949>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.24, iftmp.25, iftmp.26, iftmp.27);
  dent ("         Metadata", ch->ch_metadata);
  D.18950 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.18950);
  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.18955;
  sizetype D.18958;
  const char * D.18959;
  char D.18960;
  int D.18961;
  unsigned int i.30;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.18952>; else goto <D.18953>;
  <D.18952>:
  printf (" none\n");
  return;
  <D.18953>:
  i = 0;
  goto <D.18321>;
  <D.18320>:
  i.29 = (unsigned int) i;
  D.18955 = i.29 & 15;
  if (D.18955 == 0) goto <D.18956>; else goto <D.18957>;
  <D.18956>:
  printf ("\n\t");
  <D.18957>:
  D.18958 = (sizetype) i;
  D.18959 = p + D.18958;
  D.18960 = *D.18959;
  D.18961 = (int) D.18960;
  printf (" %02X", D.18961);
  i = i + 1;
  <D.18321>:
  i.30 = (unsigned int) i;
  if (i.30 < size) goto <D.18320>; else goto <D.18322>;
  <D.18322>:
  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.18965;
  const char * D.18968;
  int D.18969;
  unsigned char D.18970;
  int D.18971;
  const char * D.18972;
  long int D.18973;
  char * D.18974;
  long int D.18975;
  long int D.18976;
  unsigned int D.18977;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.18371>;
  <D.18370>:
  D.18965 = meta->tables[table].rows;
  if (D.18965 == 0) goto <D.18966>; else goto <D.18967>;
  <D.18966>:
  // predicted unlikely by continue predictor.
  goto <D.18369>;
  <D.18967>:
  D.18968 = mono_meta_table_name (table);
  D.18965 = meta->tables[table].rows;
  D.18969 = (int) D.18965;
  D.18970 = meta->tables[table].row_size;
  D.18971 = (int) D.18970;
  D.18972 = meta->tables[table].base;
  D.18973 = (long int) D.18972;
  D.18974 = meta->raw_data;
  D.18975 = (long int) D.18974;
  D.18976 = D.18973 - D.18975;
  D.18977 = (unsigned int) D.18976;
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.18968, D.18969, D.18971, D.18977);
  <D.18369>:
  table = table + 1;
  <D.18371>:
  if (table <= 44) goto <D.18370>; else goto <D.18372>;
  <D.18372>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.18978;
  int D.18979;
  short int D.18980;
  int D.18981;
  char * D.18982;

  printf ("\nMetadata header:\n");
  D.18978 = meta->md_version_major;
  D.18979 = (int) D.18978;
  D.18980 = meta->md_version_minor;
  D.18981 = (int) D.18980;
  printf ("           Version: %d.%d\n", D.18979, D.18981);
  D.18982 = meta->version;
  printf ("    Version string: %s\n", D.18982);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.18983;
  struct MonoStreamHeader * D.18984;
  struct MonoStreamHeader * D.18985;
  struct MonoStreamHeader * D.18986;
  struct MonoStreamHeader * D.18987;

  printf ("\nMetadata pointers:\n");
  D.18983 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.18983);
  D.18984 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.18984);
  D.18985 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.18985);
  D.18986 = &meta->heap_us;
  dsh ("\tUser string", meta, D.18986);
  D.18987 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.18987);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  const char * D.18988;
  long int D.18989;
  char * D.18990;
  long int D.18991;
  long int D.18992;
  int D.18993;
  unsigned int D.18994;
  sizetype D.18995;
  const char * D.18996;
  long int D.18997;
  long int D.18998;
  int D.18999;

  D.18988 = sh->data;
  D.18989 = (long int) D.18988;
  D.18990 = meta->raw_metadata;
  D.18991 = (long int) D.18990;
  D.18992 = D.18989 - D.18991;
  D.18993 = (int) D.18992;
  D.18988 = sh->data;
  D.18994 = sh->size;
  D.18995 = (sizetype) D.18994;
  D.18996 = D.18988 + D.18995;
  D.18997 = (long int) D.18996;
  D.18990 = meta->raw_metadata;
  D.18991 = (long int) D.18990;
  D.18998 = D.18997 - D.18991;
  D.18999 = (int) D.18998;
  D.18994 = sh->size;
  D.18994 = sh->size;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.18993, D.18999, D.18994, D.18994);
}


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

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


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.32;
  int D.19008;
  int D.19009;
  unsigned int D.19010;
  struct MonoType * D.19015;
  struct MonoMethodSignature * D.19016;
  const char * D.19019;
  struct MonoMethodSignature * D.19021;
  const char * D.19022;
  <unnamed type> D.19023;
  const char * D.19024;
  char * D.19025;
  <unnamed-unsigned:24> D.19032;
  int D.19033;
  int D.19036;
  struct GSList * errors;
  struct GSList * tmp;
  int count;
  int verifiable;
  const char * desc[9];

  try
    {
      count = 0;
      verifiable = 0;
      desc = *.LC18;
      verify_code.32 = verify_code;
      if (verify_code.32 != 0) goto <D.19006>; else goto <D.19007>;
      <D.19006>:
      {
        int i;
        struct MonoTableInfo * m;

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

          mono_loader_clear_error ();
          D.19008 = i + 1;
          D.19009 = D.19008 | 100663296;
          D.19010 = (unsigned int) D.19009;
          method = mono_get_method (image, D.19010, 0B);
          if (method == 0B) goto <D.19011>; else goto <D.19012>;
          <D.19011>:
          D.19008 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.19008);
          // predicted unlikely by continue predictor.
          goto <D.18394>;
          <D.19012>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.19013>; else goto <D.19014>;
          <D.19013>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.19015 = &klass->byval_arg;
            name = mono_type_full_name (D.19015);
            D.19016 = mono_method_signature (method);
            if (D.19016 == 0B) goto <D.19017>; else goto <D.19018>;
            <D.19017>:
            D.19019 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.19019);
            goto <D.19020>;
            <D.19018>:
            {
              char * sig;

              D.19021 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.19021, 0);
              D.19022 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.19022, sig);
              monoeg_g_free (sig);
            }
            <D.19020>:
            monoeg_g_free (name);
          }
          <D.19014>:
          tmp = errors;
          goto <D.18400>;
          <D.18399>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.19023 = info->status;
            D.19024 = desc[D.19023];
            D.19025 = info->message;
            monoeg_g_print ("%s: %s\n", D.19024, D.19025);
            D.19023 = info->status;
            if (D.19023 == 1) goto <D.19026>; else goto <D.19027>;
            <D.19026>:
            count = count + 1;
            verifiable = 3;
            <D.19027>:
            D.19023 = info->status;
            if (D.19023 == 8) goto <D.19028>; else goto <D.19029>;
            <D.19028>:
            if (verifiable <= 1) goto <D.19030>; else goto <D.19031>;
            <D.19030>:
            verifiable = 2;
            <D.19031>:
            <D.19029>:
          }
          tmp = tmp->next;
          <D.18400>:
          if (tmp != 0B) goto <D.18399>; else goto <D.18401>;
          <D.18401>:
          mono_free_verify_list (errors);
        }
        <D.18394>:
        i = i + 1;
        <D.18403>:
        D.19032 = m->rows;
        D.19033 = (int) D.19032;
        if (D.19033 > i) goto <D.18402>; else goto <D.18404>;
        <D.18404>:
      }
      <D.19007>:
      if (count != 0) goto <D.19034>; else goto <D.19035>;
      <D.19034>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.19035>:
      D.19036 = verifiable;
      return D.19036;
    }
  finally
    {
      desc = {CLOBBER};
    }
}