main (int argc, char * * argv)
{
  long unsigned int D.18128;
  long unsigned int D.18129;
  char * * D.18130;
  char * D.18131;
  char D.18132;
  int D.18135;
  int D.18139;
  int verify_pe.0;
  const char * D.18148;
  int D.18149;
  unsigned int D.18152;
  unsigned int verify_flags.1;
  unsigned int D.18168;
  int verify_code.2;
  int D.18180;
  struct _IO_FILE * stderr.3;
  int dump_data.4;
  long unsigned int D.18193;
  long unsigned int D.18194;
  struct MonoImage * D.18199;
  int iftmp.5;

  {
    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.18102>;
        <D.18101>:
        D.18128 = (long unsigned int) i;
        D.18129 = D.18128 * 8;
        D.18130 = argv + D.18129;
        D.18131 = *D.18130;
        D.18132 = *D.18131;
        if (D.18132 != 45) goto <D.18133>; else goto <D.18134>;
        <D.18133>:
        D.18128 = (long unsigned int) i;
        D.18129 = D.18128 * 8;
        D.18130 = argv + D.18129;
        file = *D.18130;
        // predicted unlikely by continue predictor.
        goto <D.18100>;
        <D.18134>:
        D.18128 = (long unsigned int) i;
        D.18129 = D.18128 * 8;
        D.18130 = argv + D.18129;
        D.18131 = *D.18130;
        D.18135 = strcmp (D.18131, "--help");
        if (D.18135 == 0) goto <D.18136>; else goto <D.18137>;
        <D.18136>:
        usage ();
        goto <D.18138>;
        <D.18137>:
        D.18128 = (long unsigned int) i;
        D.18129 = D.18128 * 8;
        D.18130 = argv + D.18129;
        D.18131 = *D.18130;
        D.18139 = strcmp (D.18131, "--verify");
        if (D.18139 == 0) goto <D.18140>; else goto <D.18141>;
        <D.18140>:
        verify_pe = 1;
        dump_data = 0;
        i = i + 1;
        D.18128 = (long unsigned int) i;
        D.18129 = D.18128 * 8;
        D.18130 = argv + D.18129;
        flags = *D.18130;
        goto <D.18142>;
        <D.18141>:
        usage ();
        <D.18142>:
        <D.18138>:
        <D.18100>:
        i = i + 1;
        <D.18102>:
        if (i < argc) goto <D.18101>; else goto <D.18103>;
        <D.18103>:
        if (file == 0B) goto <D.18143>; else goto <D.18144>;
        <D.18143>:
        usage ();
        <D.18144>:
        mono_perfcounters_init ();
        mono_metadata_init ();
        mono_images_init ();
        mono_assemblies_init ();
        mono_loader_init ();
        verify_pe.0 = verify_pe;
        if (verify_pe.0 != 0) goto <D.18146>; else goto <D.18147>;
        <D.18146>:
        {
          char * tok;

          tok = strtok (flags, ",");
          verify_metadata = 1;
          verify_code = 0;
          goto <D.18109>;
          <D.18108>:
          i = 0;
          goto <D.18107>;
          <D.18106>:
          D.18148 = flag_desc[i];
          D.18149 = strcmp (tok, D.18148);
          if (D.18149 == 0) goto <D.18150>; else goto <D.18151>;
          <D.18150>:
          D.18152 = flag_vals[i];
          if (D.18152 == 8) goto <D.18153>; else goto <D.18154>;
          <D.18153>:
          verify_metadata = 0;
          verify_code = 1;
          goto <D.18155>;
          <D.18154>:
          D.18152 = flag_vals[i];
          if (D.18152 == 7) goto <D.18156>; else goto <D.18157>;
          <D.18156>:
          verify_code = 1;
          goto <D.18158>;
          <D.18157>:
          D.18152 = flag_vals[i];
          if (D.18152 == 9) goto <D.18159>; else goto <D.18160>;
          <D.18159>:
          verify_metadata = 0;
          run_new_metadata_verifier = 1;
          goto <D.18161>;
          <D.18160>:
          D.18152 = flag_vals[i];
          if (D.18152 == 10) goto <D.18162>; else goto <D.18163>;
          <D.18162>:
          verify_partial_md = 1;
          <D.18163>:
          <D.18161>:
          <D.18158>:
          <D.18155>:
          D.18152 = flag_vals[i];
          if (D.18152 == 134217728) goto <D.18164>; else goto <D.18165>;
          <D.18164>:
          verifier_mode = 1;
          goto <D.18166>;
          <D.18165>:
          D.18152 = flag_vals[i];
          verify_flags.1 = (unsigned int) verify_flags;
          D.18168 = D.18152 | verify_flags.1;
          verify_flags = (int) D.18168;
          <D.18166>:
          goto <D.18105>;
          <D.18151>:
          i = i + 1;
          <D.18107>:
          D.18148 = flag_desc[i];
          if (D.18148 != 0B) goto <D.18106>; else goto <D.18105>;
          <D.18105>:
          D.18148 = flag_desc[i];
          if (D.18148 == 0B) goto <D.18169>; else goto <D.18170>;
          <D.18169>:
          monoeg_g_print ("Unknown verify flag %s\n", tok);
          <D.18170>:
          tok = strtok (0B, ",");
          <D.18109>:
          if (tok != 0B) goto <D.18108>; else goto <D.18110>;
          <D.18110>:
          mono_verifier_set_mode (verifier_mode);
        }
        <D.18147>:
        verify_pe.0 = verify_pe;
        if (verify_pe.0 != 0) goto <D.18171>; else goto <D.18173>;
        <D.18173>:
        if (run_new_metadata_verifier != 0) goto <D.18171>; else goto <D.18172>;
        <D.18171>:
        run_new_metadata_verifier = 1;
        <D.18172>:
        if (run_new_metadata_verifier != 0) goto <D.18174>; else goto <D.18175>;
        <D.18174>:
        mono_verifier_set_mode (verifier_mode);
        image_result = verify_image_file (file);
        if (image_result == 1) goto <D.18176>; else goto <D.18178>;
        <D.18178>:
        verify_code.2 = verify_code;
        if (verify_code.2 == 0) goto <D.18176>; else goto <D.18177>;
        <D.18176>:
        D.18180 = image_result;
        return D.18180;
        <D.18177>:
        <D.18175>:
        image = mono_image_open (file, 0B);
        if (image == 0B) goto <D.18181>; else goto <D.18182>;
        <D.18181>:
        stderr.3 = stderr;
        fprintf (stderr.3, "Cannot open image %s\n", file);
        exit (1);
        <D.18182>:
        dump_data.4 = dump_data;
        if (dump_data.4 != 0) goto <D.18185>; else goto <D.18186>;
        <D.18185>:
        dump_dotnet_iinfo (image);
        <D.18186>:
        verify_pe.0 = verify_pe;
        if (verify_pe.0 != 0) goto <D.18187>; else goto <D.18188>;
        <D.18187>:
        {
          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.18189>; else goto <D.18190>;
              <D.18189>:
              image = mono_image_open (file, &status);
              if (image != 0B) goto <D.18191>; else goto <D.18192>;
              <D.18191>:
              D.18193 = BIT_FIELD_REF <*image, 64, 5696>;
              D.18194 = D.18193 & 18446742974197923840;
              if (D.18194 == 0) goto <D.18195>; else goto <D.18196>;
              <D.18195>:
              assembly = monoeg_malloc0 (128);
              assembly->in_gac = 0;
              assembly->image = image;
              image->assembly = assembly;
              <D.18196>:
              <D.18192>:
              <D.18190>:
              if (assembly == 0B) goto <D.18197>; else goto <D.18198>;
              <D.18197>:
              monoeg_g_print ("Could not open assembly %s\n", file);
              D.18180 = 4;
              return D.18180;
              <D.18198>:
              D.18199 = assembly->image;
              code_result = dump_verify_info (D.18199, verify_flags);
              if (code_result != 0) goto <D.18201>; else goto <D.18202>;
              <D.18201>:
              iftmp.5 = code_result;
              goto <D.18203>;
              <D.18202>:
              iftmp.5 = image_result;
              <D.18203>:
              D.18180 = iftmp.5;
              return D.18180;
            }
          finally
            {
              status = {CLOBBER};
            }
        }
        <D.18188>:
        mono_image_close (image);
        D.18180 = 0;
        return D.18180;
      }
    finally
      {
        flag_desc = {CLOBBER};
        flag_vals = {CLOBBER};
      }
  }
  D.18180 = 0;
  return D.18180;
}


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


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.18207;

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


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.6;
  int iftmp.7;
  int D.18217;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.18210>; else goto <D.18211>;
  <D.18210>:
  if (__ret == 1) goto <D.18213>; else goto <D.18214>;
  <D.18213>:
  iftmp.7 = -1;
  goto <D.18215>;
  <D.18214>:
  iftmp.7 = 1;
  <D.18215>:
  iftmp.6 = iftmp.7;
  goto <D.18216>;
  <D.18211>:
  iftmp.6 = 0;
  <D.18216>:
  __ret = iftmp.6;
  D.18217 = __ret;
  return D.18217;
}


verify_image_file (const char * fname)
{
  int D.18227;
  int D.18228;
  int D.18230;
  int D.18233;
  int D.18235;
  int D.18238;
  struct MonoAssemblyName * D.18240;
  char * D.18241;
  int verify_partial_md.8;
  int D.18245;
  int D.18247;
  unsigned char D.18252;
  struct MonoLoaderError * D.18254;
  const char * D.18255;
  const char * D.18256;
  struct MonoLoaderError * D.18260;
  <unnamed-unsigned:24> D.18261;
  int D.18262;
  <unnamed type> D.18265;
  const char * D.18266;
  char * D.18267;
  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.18225>; else goto <D.18226>;
      <D.18225>:
      printf ("Could not open %s\n", fname);
      D.18227 = 1;
      return D.18227;
      <D.18226>:
      D.18228 = mono_verifier_verify_pe_data (image, &errors);
      if (D.18228 == 0) goto invalid_image; else goto <D.18229>;
      <D.18229>:
      D.18230 = mono_image_load_pe_data (image);
      if (D.18230 == 0) goto <D.18231>; else goto <D.18232>;
      <D.18231>:
      printf ("Could not load pe data for assembly %s\n", fname);
      D.18227 = 1;
      return D.18227;
      <D.18232>:
      D.18233 = mono_verifier_verify_cli_data (image, &errors);
      if (D.18233 == 0) goto invalid_image; else goto <D.18234>;
      <D.18234>:
      D.18235 = mono_image_load_cli_data (image);
      if (D.18235 == 0) goto <D.18236>; else goto <D.18237>;
      <D.18236>:
      printf ("Could not load cli data for assembly %s\n", fname);
      D.18227 = 1;
      return D.18227;
      <D.18237>:
      D.18238 = mono_verifier_verify_table_data (image, &errors);
      if (D.18238 == 0) goto invalid_image; else goto <D.18239>;
      <D.18239>:
      mono_image_load_names (image);
      assembly = monoeg_malloc0 (128);
      assembly->in_gac = 0;
      assembly->image = image;
      image->assembly = assembly;
      D.18240 = &assembly->aname;
      mono_assembly_fill_assembly_name (image, D.18240);
      mono_install_assembly_load_hook (pedump_assembly_load_hook, 0B);
      mono_install_assembly_search_hook (pedump_assembly_search_hook, 0B);
      D.18241 = image->version;
      mono_init_version ("pedump", D.18241);
      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.18243>; else goto <D.18244>;
      <D.18243>:
      D.18245 = mono_verifier_verify_full_table_data (image, &errors);
      if (D.18245 == 0) goto invalid_image; else goto <D.18246>;
      <D.18246>:
      <D.18244>:
      table = &image->tables[2];
      i = 1;
      goto <D.18035>;
      <D.18034>:
      {
        guint32 token;
        struct MonoClass * class;

        D.18247 = i | 33554432;
        token = (guint32) D.18247;
        class = mono_class_get (image, token);
        if (class == 0B) goto <D.18248>; else goto <D.18249>;
        <D.18248>:
        printf ("Could not load class with token %x\n", token);
        // predicted unlikely by continue predictor.
        goto <D.18033>;
        <D.18249>:
        mono_class_init (class);
        D.18252 = class->exception_type;
        if (D.18252 != 0) goto <D.18250>; else goto <D.18253>;
        <D.18253>:
        D.18254 = mono_loader_get_last_error ();
        if (D.18254 != 0B) goto <D.18250>; else goto <D.18251>;
        <D.18250>:
        D.18255 = class->name_space;
        D.18256 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18255, D.18256);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18251>:
        mono_class_setup_vtable (class);
        D.18252 = class->exception_type;
        if (D.18252 != 0) goto <D.18257>; else goto <D.18259>;
        <D.18259>:
        D.18260 = mono_loader_get_last_error ();
        if (D.18260 != 0B) goto <D.18257>; else goto <D.18258>;
        <D.18257>:
        D.18255 = class->name_space;
        D.18256 = class->name;
        printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token, D.18255, D.18256);
        mono_loader_clear_error ();
        count = count + 1;
        <D.18258>:
      }
      <D.18033>:
      i = i + 1;
      <D.18035>:
      D.18261 = table->rows;
      D.18262 = (int) D.18261;
      if (D.18262 >= i) goto <D.18034>; else goto <D.18036>;
      <D.18036>:
      if (count != 0) goto <D.18263>; else goto <D.18264>;
      <D.18263>:
      D.18227 = 5;
      return D.18227;
      <D.18264>:
      D.18227 = 0;
      return D.18227;
      invalid_image:
      tmp = errors;
      goto <D.18039>;
      <D.18038>:
      {
        struct MonoVerifyInfo * info;

        info = tmp->data;
        D.18265 = info->status;
        D.18266 = desc[D.18265];
        D.18267 = info->message;
        monoeg_g_print ("%s: %s\n", D.18266, D.18267);
        D.18265 = info->status;
        if (D.18265 == 1) goto <D.18268>; else goto <D.18269>;
        <D.18268>:
        count = count + 1;
        <D.18269>:
      }
      tmp = tmp->next;
      <D.18039>:
      if (tmp != 0B) goto <D.18038>; else goto <D.18040>;
      <D.18040>:
      errors.9 = errors;
      mono_free_verify_list (errors.9);
      if (count != 0) goto <D.18271>; else goto <D.18272>;
      <D.18271>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18272>:
      D.18227 = 1;
      return D.18227;
    }
  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.18278;
  const char * D.18281;
  const char * D.18282;
  struct MonoAssembly * D.18283;
  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.18276>; else goto <D.18277>;
  <D.18276>:
  D.18278 = *assemblies_path;
  if (D.18278 != 0B) goto <D.18279>; else goto <D.18280>;
  <D.18279>:
  D.18281 = aname->culture;
  D.18282 = aname->name;
  result = real_load (assemblies_path, D.18281, D.18282, refonly);
  <D.18280>:
  <D.18277>:
  D.18283 = result;
  return D.18283;
}


real_load (gchar * * search_path, const gchar * culture, const gchar * name, gboolean refonly)
{
  char D.18289;
  long unsigned int D.18290;
  gchar * D.18291;
  char D.18292;
  sizetype D.18295;
  sizetype D.18296;
  gchar * D.18297;
  int D.18298;
  int D.18300;
  int D.18302;
  int D.18304;
  struct MonoAssembly * D.18306;
  struct MonoAssembly * result;
  gchar * * path;
  gchar * filename;
  const gchar * local_culture;
  gint len;

  try
    {
      result = 0B;
      if (culture == 0B) goto <D.18285>; else goto <D.18288>;
      <D.18288>:
      D.18289 = *culture;
      if (D.18289 == 0) goto <D.18285>; else goto <D.18286>;
      <D.18285>:
      local_culture = "";
      goto <D.18287>;
      <D.18286>:
      local_culture = culture;
      <D.18287>:
      filename = monoeg_g_strconcat (name, ".dll", 0B);
      D.18290 = __strlen_g (filename);
      len = (gint) D.18290;
      path = search_path;
      goto <D.18064>;
      <D.18063>:
      D.18291 = *path;
      D.18292 = *D.18291;
      if (D.18292 == 0) goto <D.18293>; else goto <D.18294>;
      <D.18293>:
      // predicted unlikely by continue predictor.
      goto <D.18061>;
      <D.18294>:
      D.18295 = (sizetype) len;
      D.18296 = D.18295 + 18446744073709551612;
      D.18297 = filename + D.18296;
      strcpy (D.18297, ".dll");
      D.18291 = *path;
      D.18298 = try_load_from (&result, D.18291, local_culture, "", filename, refonly);
      if (D.18298 != 0) goto <D.18062>; else goto <D.18299>;
      <D.18299>:
      D.18295 = (sizetype) len;
      D.18296 = D.18295 + 18446744073709551612;
      D.18297 = filename + D.18296;
      strcpy (D.18297, ".exe");
      D.18291 = *path;
      D.18300 = try_load_from (&result, D.18291, local_culture, "", filename, refonly);
      if (D.18300 != 0) goto <D.18062>; else goto <D.18301>;
      <D.18301>:
      D.18295 = (sizetype) len;
      D.18296 = D.18295 + 18446744073709551612;
      D.18297 = filename + D.18296;
      strcpy (D.18297, ".dll");
      D.18291 = *path;
      D.18302 = try_load_from (&result, D.18291, local_culture, name, filename, refonly);
      if (D.18302 != 0) goto <D.18062>; else goto <D.18303>;
      <D.18303>:
      D.18295 = (sizetype) len;
      D.18296 = D.18295 + 18446744073709551612;
      D.18297 = filename + D.18296;
      strcpy (D.18297, ".exe");
      D.18291 = *path;
      D.18304 = try_load_from (&result, D.18291, local_culture, name, filename, refonly);
      if (D.18304 != 0) goto <D.18062>; else goto <D.18305>;
      <D.18305>:
      <D.18061>:
      path = path + 8;
      <D.18064>:
      D.18291 = *path;
      if (D.18291 != 0B) goto <D.18063>; else goto <D.18062>;
      <D.18062>:
      monoeg_g_free (filename);
      D.18306 = result;
      return D.18306;
    }
  finally
    {
      result = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.18309;
  long int __ptr.11;
  long int __str.12;
  long int D.18312;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.11 = (long int) __ptr;
  __str.12 = (long int) __str;
  D.18312 = __ptr.11 - __str.12;
  D.18309 = (size_t) D.18312;
  return D.18309;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.18314;
  long unsigned int D.18315;

  D.18315 = __builtin_object_size (__dest, 1);
  D.18314 = __builtin___strcpy_chk (__dest, __src, D.18315);
  return D.18314;
}


try_load_from (struct MonoAssembly * * assembly, const gchar * path1, const gchar * path2, const gchar * path3, const gchar * path4, gboolean refonly)
{
  int D.18317;
  struct MonoAssembly * D.18320;
  gboolean D.18321;
  struct MonoAssembly * D.18322;
  _Bool D.18323;
  gchar * fullpath;

  *assembly = 0B;
  fullpath = monoeg_g_build_path ("/", path1, path2, path3, path4, 0B);
  D.18317 = monoeg_g_file_test (fullpath, 1);
  if (D.18317 != 0) goto <D.18318>; else goto <D.18319>;
  <D.18318>:
  D.18320 = mono_assembly_open_full (fullpath, 0B, refonly);
  *assembly = D.18320;
  <D.18319>:
  monoeg_g_free (fullpath);
  D.18322 = *assembly;
  D.18323 = D.18322 != 0B;
  D.18321 = (gboolean) D.18323;
  return D.18321;
}


pedump_assembly_search_hook (struct MonoAssemblyName * aname, void * user_data)
{
  struct MonoAssemblyName * D.18325;
  int D.18326;
  struct MonoAssembly * D.18329;
  struct GList * tmp;

  tmp = loaded_assemblies;
  goto <D.18084>;
  <D.18083>:
  {
    struct MonoAssembly * ass;

    ass = tmp->data;
    D.18325 = &ass->aname;
    D.18326 = mono_assembly_names_equal (aname, D.18325);
    if (D.18326 != 0) goto <D.18327>; else goto <D.18328>;
    <D.18327>:
    D.18329 = ass;
    return D.18329;
    <D.18328>:
  }
  tmp = tmp->next;
  <D.18084>:
  if (tmp != 0B) goto <D.18083>; else goto <D.18085>;
  <D.18085>:
  D.18329 = 0B;
  return D.18329;
}


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

  loaded_assemblies.13 = loaded_assemblies;
  D.18332 = monoeg_g_list_prepend (loaded_assemblies.13, assembly);
  loaded_assemblies = D.18332;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.18333;

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


dump_dotnet_iinfo (struct MonoImage * image)
{
  struct MonoDotNetHeader * D.18335;
  struct MonoCLIHeader * D.18336;
  unsigned int D.18337;
  struct MonoCLIImageInfo * iinfo;

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


dump_dotnet_header (struct MonoDotNetHeader * header)
{
  struct MonoCOFFHeader * D.18338;
  struct MonoPEHeader * D.18339;
  struct MonoPEHeaderNT * D.18340;
  struct MonoPEDatadir * D.18341;

  D.18338 = &header->coff;
  dump_coff_header (D.18338);
  D.18339 = &header->pe;
  dump_pe_header (D.18339);
  D.18340 = &header->nt;
  dump_nt_header (D.18340);
  D.18341 = &header->datadir;
  dump_datadir (D.18341);
}


dump_coff_header (struct MonoCOFFHeader * coff)
{
  short unsigned int D.18342;
  short unsigned int D.18343;
  unsigned int D.18344;
  unsigned int D.18345;
  unsigned int D.18346;
  short unsigned int D.18347;
  short unsigned int D.18348;

  printf ("\nCOFF Header:\n");
  D.18342 = coff->coff_machine;
  hex16 ("                Machine", D.18342);
  D.18343 = coff->coff_sections;
  hex16 ("               Sections", D.18343);
  D.18344 = coff->coff_time;
  hex32 ("             Time stamp", D.18344);
  D.18345 = coff->coff_symptr;
  hex32 ("Pointer to Symbol Table", D.18345);
  D.18346 = coff->coff_symcount;
  hex32 ("   \t   Symbol Count", D.18346);
  D.18347 = coff->coff_opt_header_size;
  hex16 ("   Optional Header Size", D.18347);
  D.18348 = coff->coff_attributes;
  hex16 ("   \tCharacteristics", D.18348);
}


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


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

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


dump_pe_header (struct MonoPEHeader * pe)
{
  short unsigned int D.18350;
  unsigned char D.18351;
  unsigned char D.18352;
  unsigned int D.18353;
  unsigned int D.18354;
  unsigned int D.18355;
  unsigned int D.18356;
  unsigned int D.18357;
  unsigned int D.18358;

  printf ("\nPE Header:\n");
  D.18350 = pe->pe_magic;
  hex16 ("         Magic (0x010b)", D.18350);
  D.18351 = pe->pe_major;
  hex8 ("             LMajor (6)", D.18351);
  D.18352 = pe->pe_minor;
  hex8 ("             LMinor (0)", D.18352);
  D.18353 = pe->pe_code_size;
  hex32 ("              Code Size", D.18353);
  D.18354 = pe->pe_data_size;
  hex32 ("  Initialized Data Size", D.18354);
  D.18355 = pe->pe_uninit_data_size;
  hex32 ("Uninitialized Data Size", D.18355);
  D.18356 = pe->pe_rva_entry_point;
  hex32 ("        Entry Point RVA", D.18356);
  D.18357 = pe->pe_rva_code_base;
  hex32 (" \t  Code Base RVA", D.18357);
  D.18358 = pe->pe_rva_data_base;
  hex32 ("\t  Data Base RVA", D.18358);
  printf ("\n");
}


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

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


dump_nt_header (struct MonoPEHeaderNT * nt)
{
  unsigned int D.18360;
  unsigned int D.18361;
  unsigned int D.18362;
  short unsigned int D.18363;
  short unsigned int D.18364;
  short unsigned int D.18365;
  short unsigned int D.18366;
  short unsigned int D.18367;
  short unsigned int D.18368;
  unsigned int D.18369;
  unsigned int D.18370;
  unsigned int D.18371;
  unsigned int D.18372;
  short unsigned int D.18373;
  short unsigned int D.18374;
  unsigned int D.18375;
  unsigned int D.18376;
  unsigned int D.18377;
  unsigned int D.18378;
  unsigned int D.18379;
  unsigned int D.18380;

  printf ("\nNT Header:\n");
  D.18360 = nt->pe_image_base;
  hex32 ("   Image Base (0x400000)", D.18360);
  D.18361 = nt->pe_section_align;
  hex32 ("Section Alignment (8192)", D.18361);
  D.18362 = nt->pe_file_alignment;
  hex32 ("   File Align (512/4096)", D.18362);
  D.18363 = nt->pe_os_major;
  hex16 ("            OS Major (4)", D.18363);
  D.18364 = nt->pe_os_minor;
  hex16 ("            OS Minor (0)", D.18364);
  D.18365 = nt->pe_user_major;
  hex16 ("  \t  User Major (0)", D.18365);
  D.18366 = nt->pe_user_minor;
  hex16 ("  \t  User Minor (0)", D.18366);
  D.18367 = nt->pe_subsys_major;
  hex16 ("  \tSubsys major (4)", D.18367);
  D.18368 = nt->pe_subsys_minor;
  hex16 ("  \tSubsys minor (0)", D.18368);
  D.18369 = nt->pe_reserved_1;
  hex32 (" \t       Reserverd", D.18369);
  D.18370 = nt->pe_image_size;
  hex32 (" \t      Image Size", D.18370);
  D.18371 = nt->pe_header_size;
  hex32 (" \t     Header Size", D.18371);
  D.18372 = nt->pe_checksum;
  hex32 ("            Checksum (0)", D.18372);
  D.18373 = nt->pe_subsys_required;
  hex16 ("               Subsystem", D.18373);
  D.18374 = nt->pe_dll_flags;
  hex16 ("           DLL Flags (0)", D.18374);
  D.18375 = nt->pe_stack_reserve;
  hex32 (" Stack Reserve Size (1M)", D.18375);
  D.18376 = nt->pe_stack_commit;
  hex32 ("Stack commit Size (4096)", D.18376);
  D.18377 = nt->pe_heap_reserve;
  hex32 ("  Heap Reserve Size (1M)", D.18377);
  D.18378 = nt->pe_heap_commit;
  hex32 (" Heap Commit Size (4096)", D.18378);
  D.18379 = nt->pe_loader_flags;
  hex32 ("      Loader flags (0x1)", D.18379);
  D.18380 = nt->pe_data_dir_count;
  hex32 ("   Data Directories (16)", D.18380);
}


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.18381;
  unsigned int D.18382;

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


dump_sections (struct MonoCLIImageInfo * iinfo)
{
  short unsigned int D.18383;
  struct MonoSectionTable * D.18384;
  long unsigned int D.18385;
  long unsigned int D.18386;
  struct MonoSectionTable * D.18387;
  const int top;
  int i;

  D.18383 = iinfo->cli_header.coff.coff_sections;
  top = (const int) D.18383;
  i = 0;
  goto <D.17959>;
  <D.17958>:
  D.18384 = iinfo->cli_section_tables;
  D.18385 = (long unsigned int) i;
  D.18386 = D.18385 * 40;
  D.18387 = D.18384 + D.18386;
  dump_section_table (D.18387);
  i = i + 1;
  <D.17959>:
  if (i < top) goto <D.17958>; else goto <D.17960>;
  <D.17960>:
}


dump_section_table (struct MonoSectionTable * st)
{
  char[8] * D.18388;
  unsigned int D.18389;
  unsigned int D.18390;
  unsigned int D.18391;
  unsigned int D.18392;
  unsigned int D.18393;
  unsigned int D.18394;
  short unsigned int D.18395;
  short unsigned int D.18396;
  const char * iftmp.14;
  unsigned int D.18398;
  const char * iftmp.15;
  unsigned int D.18403;
  const char * iftmp.16;
  unsigned int D.18408;
  const char * iftmp.17;
  unsigned int D.18413;
  const char * iftmp.18;
  unsigned int D.18418;
  const char * iftmp.19;
  unsigned int D.18423;
  const char * iftmp.20;
  unsigned int D.18428;
  const char * iftmp.21;
  unsigned int D.18433;
  const char * iftmp.22;
  unsigned int D.18438;
  const char * iftmp.23;
  signed int flags.24;
  guint32 flags;

  flags = st->st_flags;
  D.18388 = &st->st_name;
  printf ("\n\tName: %s\n", D.18388);
  D.18389 = st->st_virtual_size;
  hex32 ("   Virtual Size", D.18389);
  D.18390 = st->st_virtual_address;
  hex32 ("Virtual Address", D.18390);
  D.18391 = st->st_raw_data_size;
  hex32 ("  Raw Data Size", D.18391);
  D.18392 = st->st_raw_data_ptr;
  hex32 ("   Raw Data Ptr", D.18392);
  D.18393 = st->st_reloc_ptr;
  hex32 ("      Reloc Ptr", D.18393);
  D.18394 = st->st_lineno_ptr;
  hex32 ("     LineNo Ptr", D.18394);
  D.18395 = st->st_reloc_count;
  hex16 ("    Reloc Count", D.18395);
  D.18396 = st->st_line_count;
  hex16 ("     Line Count", D.18396);
  D.18398 = flags & 32;
  if (D.18398 != 0) goto <D.18399>; else goto <D.18400>;
  <D.18399>:
  iftmp.14 = "code, ";
  goto <D.18401>;
  <D.18400>:
  iftmp.14 = "";
  <D.18401>:
  D.18403 = flags & 64;
  if (D.18403 != 0) goto <D.18404>; else goto <D.18405>;
  <D.18404>:
  iftmp.15 = "data, ";
  goto <D.18406>;
  <D.18405>:
  iftmp.15 = "";
  <D.18406>:
  D.18408 = flags & 128;
  if (D.18408 != 0) goto <D.18409>; else goto <D.18410>;
  <D.18409>:
  iftmp.16 = "bss, ";
  goto <D.18411>;
  <D.18410>:
  iftmp.16 = "";
  <D.18411>:
  D.18413 = flags & 33554432;
  if (D.18413 != 0) goto <D.18414>; else goto <D.18415>;
  <D.18414>:
  iftmp.17 = "discard, ";
  goto <D.18416>;
  <D.18415>:
  iftmp.17 = "";
  <D.18416>:
  D.18418 = flags & 67108864;
  if (D.18418 != 0) goto <D.18419>; else goto <D.18420>;
  <D.18419>:
  iftmp.18 = "nocache, ";
  goto <D.18421>;
  <D.18420>:
  iftmp.18 = "";
  <D.18421>:
  D.18423 = flags & 134217728;
  if (D.18423 != 0) goto <D.18424>; else goto <D.18425>;
  <D.18424>:
  iftmp.19 = "nopage, ";
  goto <D.18426>;
  <D.18425>:
  iftmp.19 = "";
  <D.18426>:
  D.18428 = flags & 268435456;
  if (D.18428 != 0) goto <D.18429>; else goto <D.18430>;
  <D.18429>:
  iftmp.20 = "shared, ";
  goto <D.18431>;
  <D.18430>:
  iftmp.20 = "";
  <D.18431>:
  D.18433 = flags & 536870912;
  if (D.18433 != 0) goto <D.18434>; else goto <D.18435>;
  <D.18434>:
  iftmp.21 = "exec, ";
  goto <D.18436>;
  <D.18435>:
  iftmp.21 = "";
  <D.18436>:
  D.18438 = flags & 1073741824;
  if (D.18438 != 0) goto <D.18439>; else goto <D.18440>;
  <D.18439>:
  iftmp.22 = "read, ";
  goto <D.18441>;
  <D.18440>:
  iftmp.22 = "";
  <D.18441>:
  flags.24 = (signed int) flags;
  if (flags.24 < 0) goto <D.18444>; else goto <D.18445>;
  <D.18444>:
  iftmp.23 = "write";
  goto <D.18446>;
  <D.18445>:
  iftmp.23 = "";
  <D.18446>:
  printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n", iftmp.14, iftmp.15, iftmp.16, iftmp.17, iftmp.18, iftmp.19, iftmp.20, iftmp.21, iftmp.22, iftmp.23);
}


dump_cli_header (struct MonoCLIHeader * ch)
{
  unsigned int D.18447;
  short unsigned int D.18448;
  int D.18449;
  short unsigned int D.18450;
  int D.18451;
  const char * iftmp.25;
  unsigned int D.18453;
  unsigned int D.18454;
  const char * iftmp.26;
  unsigned int D.18459;
  const char * iftmp.27;
  unsigned int D.18464;
  const char * iftmp.28;
  unsigned int D.18469;
  unsigned int D.18473;

  printf ("\n");
  D.18447 = ch->ch_size;
  printf ("          CLI header size: %d\n", D.18447);
  D.18448 = ch->ch_runtime_major;
  D.18449 = (int) D.18448;
  D.18450 = ch->ch_runtime_minor;
  D.18451 = (int) D.18450;
  printf ("         Runtime required: %d.%d\n", D.18449, D.18451);
  D.18453 = ch->ch_flags;
  D.18454 = D.18453 & 1;
  if (D.18454 != 0) goto <D.18455>; else goto <D.18456>;
  <D.18455>:
  iftmp.25 = "ilonly";
  goto <D.18457>;
  <D.18456>:
  iftmp.25 = "contains native";
  <D.18457>:
  D.18453 = ch->ch_flags;
  D.18459 = D.18453 & 2;
  if (D.18459 != 0) goto <D.18460>; else goto <D.18461>;
  <D.18460>:
  iftmp.26 = "32bits";
  goto <D.18462>;
  <D.18461>:
  iftmp.26 = "32/64";
  <D.18462>:
  D.18453 = ch->ch_flags;
  D.18464 = D.18453 & 65536;
  if (D.18464 != 0) goto <D.18465>; else goto <D.18466>;
  <D.18465>:
  iftmp.27 = "trackdebug";
  goto <D.18467>;
  <D.18466>:
  iftmp.27 = "no-trackdebug";
  <D.18467>:
  D.18453 = ch->ch_flags;
  D.18469 = D.18453 & 8;
  if (D.18469 != 0) goto <D.18470>; else goto <D.18471>;
  <D.18470>:
  iftmp.28 = "strongnamesigned";
  goto <D.18472>;
  <D.18471>:
  iftmp.28 = "notsigned";
  <D.18472>:
  printf ("                    Flags: %s, %s, %s, %s\n", iftmp.25, iftmp.26, iftmp.27, iftmp.28);
  dent ("         Metadata", ch->ch_metadata);
  D.18473 = ch->ch_entry_point;
  hex32 ("Entry Point Token", D.18473);
  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.29;
  guint32 size;
  const char * p;

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


dump_blob (const char * desc, const char * p, guint32 size)
{
  unsigned int i.30;
  unsigned int D.18478;
  sizetype D.18481;
  const char * D.18482;
  char D.18483;
  int D.18484;
  unsigned int i.31;
  int i;

  printf ("%s", desc);
  if (p == 0B) goto <D.18475>; else goto <D.18476>;
  <D.18475>:
  printf (" none\n");
  return;
  <D.18476>:
  i = 0;
  goto <D.17931>;
  <D.17930>:
  i.30 = (unsigned int) i;
  D.18478 = i.30 & 15;
  if (D.18478 == 0) goto <D.18479>; else goto <D.18480>;
  <D.18479>:
  printf ("\n\t");
  <D.18480>:
  D.18481 = (sizetype) i;
  D.18482 = p + D.18481;
  D.18483 = *D.18482;
  D.18484 = (int) D.18483;
  printf (" %02X", D.18484);
  i = i + 1;
  <D.17931>:
  i.31 = (unsigned int) i;
  if (i.31 < size) goto <D.17930>; else goto <D.17932>;
  <D.17932>:
  printf ("\n");
}


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

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


dump_metadata (struct MonoImage * meta)
{
  <unnamed-unsigned:24> D.18488;
  const char * D.18491;
  int D.18492;
  unsigned char D.18493;
  int D.18494;
  const char * D.18495;
  long int D.18496;
  char * D.18497;
  long int D.18498;
  long int D.18499;
  unsigned int D.18500;
  int table;

  dump_metadata_header (meta);
  dump_metadata_ptrs (meta);
  printf ("Rows:\n");
  table = 0;
  goto <D.17981>;
  <D.17980>:
  D.18488 = meta->tables[table].rows;
  if (D.18488 == 0) goto <D.18489>; else goto <D.18490>;
  <D.18489>:
  // predicted unlikely by continue predictor.
  goto <D.17979>;
  <D.18490>:
  D.18491 = mono_meta_table_name (table);
  D.18488 = meta->tables[table].rows;
  D.18492 = (int) D.18488;
  D.18493 = meta->tables[table].row_size;
  D.18494 = (int) D.18493;
  D.18495 = meta->tables[table].base;
  D.18496 = (long int) D.18495;
  D.18497 = meta->raw_data;
  D.18498 = (long int) D.18497;
  D.18499 = D.18496 - D.18498;
  D.18500 = (unsigned int) D.18499;
  printf ("Table %s: %d records (%d bytes, at %x)\n", D.18491, D.18492, D.18494, D.18500);
  <D.17979>:
  table = table + 1;
  <D.17981>:
  if (table <= 44) goto <D.17980>; else goto <D.17982>;
  <D.17982>:
}


dump_metadata_header (struct MonoImage * meta)
{
  short int D.18501;
  int D.18502;
  short int D.18503;
  int D.18504;
  char * D.18505;

  printf ("\nMetadata header:\n");
  D.18501 = meta->md_version_major;
  D.18502 = (int) D.18501;
  D.18503 = meta->md_version_minor;
  D.18504 = (int) D.18503;
  printf ("           Version: %d.%d\n", D.18502, D.18504);
  D.18505 = meta->version;
  printf ("    Version string: %s\n", D.18505);
}


dump_metadata_ptrs (struct MonoImage * meta)
{
  struct MonoStreamHeader * D.18506;
  struct MonoStreamHeader * D.18507;
  struct MonoStreamHeader * D.18508;
  struct MonoStreamHeader * D.18509;
  struct MonoStreamHeader * D.18510;

  printf ("\nMetadata pointers:\n");
  D.18506 = &meta->heap_tables;
  dsh ("\tTables (#~)", meta, D.18506);
  D.18507 = &meta->heap_strings;
  dsh ("\t    Strings", meta, D.18507);
  D.18508 = &meta->heap_blob;
  dsh ("\t       Blob", meta, D.18508);
  D.18509 = &meta->heap_us;
  dsh ("\tUser string", meta, D.18509);
  D.18510 = &meta->heap_guid;
  dsh ("\t       GUID", meta, D.18510);
}


dsh (const char * label, struct MonoImage * meta, struct MonoStreamHeader * sh)
{
  const char * D.18511;
  long int D.18512;
  char * D.18513;
  long int D.18514;
  long int D.18515;
  int D.18516;
  unsigned int D.18517;
  sizetype D.18518;
  const char * D.18519;
  long int D.18520;
  long int D.18521;
  int D.18522;

  D.18511 = sh->data;
  D.18512 = (long int) D.18511;
  D.18513 = meta->raw_metadata;
  D.18514 = (long int) D.18513;
  D.18515 = D.18512 - D.18514;
  D.18516 = (int) D.18515;
  D.18511 = sh->data;
  D.18517 = sh->size;
  D.18518 = (sizetype) D.18517;
  D.18519 = D.18511 + D.18518;
  D.18520 = (long int) D.18519;
  D.18513 = meta->raw_metadata;
  D.18514 = (long int) D.18513;
  D.18521 = D.18520 - D.18514;
  D.18522 = (int) D.18521;
  D.18517 = sh->size;
  D.18517 = sh->size;
  printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n", label, D.18516, D.18522, D.18517, D.18517);
}


dump_methoddef (struct MonoImage * metadata, guint32 token)
{
  unsigned int D.18525;
  unsigned int D.18526;
  unsigned int D.18527;
  unsigned int D.18528;
  unsigned int D.18529;
  unsigned int D.18530;
  unsigned int D.18531;
  unsigned int D.18532;
  unsigned int D.18533;
  unsigned int D.18534;
  const char * loc;

  if (token == 0) goto <D.18523>; else goto <D.18524>;
  <D.18523>:
  return;
  <D.18524>:
  loc = mono_metadata_locate_token (metadata, token);
  D.18525 = MEM[(const guint32 *)loc];
  D.18526 = D.18525 << 24;
  D.18525 = MEM[(const guint32 *)loc];
  D.18527 = D.18525 >> 8;
  D.18528 = D.18527 & 65280;
  D.18529 = D.18526 | D.18528;
  D.18525 = MEM[(const guint32 *)loc];
  D.18530 = D.18525 << 8;
  D.18531 = D.18530 & 16711680;
  D.18532 = D.18529 | D.18531;
  D.18525 = MEM[(const guint32 *)loc];
  D.18533 = D.18525 >> 24;
  D.18534 = D.18532 | D.18533;
  printf ("RVA for Entry Point: 0x%08x\n", D.18534);
}


dump_verify_info (struct MonoImage * image, int flags)
{
  int verify_code.33;
  int D.18540;
  int D.18541;
  unsigned int D.18542;
  struct MonoType * D.18547;
  struct MonoMethodSignature * D.18548;
  const char * D.18551;
  struct MonoMethodSignature * D.18553;
  const char * D.18554;
  <unnamed type> D.18555;
  const char * D.18556;
  char * D.18557;
  <unnamed-unsigned:24> D.18564;
  int D.18565;
  int D.18568;
  struct GSList * errors;
  struct GSList * tmp;
  int count;
  int verifiable;
  const char * desc[9];

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

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

          mono_loader_clear_error ();
          D.18540 = i + 1;
          D.18541 = D.18540 | 100663296;
          D.18542 = (unsigned int) D.18541;
          method = mono_get_method (image, D.18542, 0B);
          if (method == 0B) goto <D.18543>; else goto <D.18544>;
          <D.18543>:
          D.18540 = i + 1;
          monoeg_g_print ("Warning: Cannot lookup method with token 0x%08x\n", D.18540);
          // predicted unlikely by continue predictor.
          goto <D.18004>;
          <D.18544>:
          errors = mono_method_verify (method, flags);
          if (errors != 0B) goto <D.18545>; else goto <D.18546>;
          <D.18545>:
          {
            struct MonoClass * klass;
            char * name;

            klass = mono_method_get_class (method);
            D.18547 = &klass->byval_arg;
            name = mono_type_full_name (D.18547);
            D.18548 = mono_method_signature (method);
            if (D.18548 == 0B) goto <D.18549>; else goto <D.18550>;
            <D.18549>:
            D.18551 = mono_method_get_name (method);
            monoeg_g_print ("In method: %s::%s(ERROR)\n", name, D.18551);
            goto <D.18552>;
            <D.18550>:
            {
              char * sig;

              D.18553 = mono_method_signature (method);
              sig = mono_signature_get_desc (D.18553, 0);
              D.18554 = mono_method_get_name (method);
              monoeg_g_print ("In method: %s::%s(%s)\n", name, D.18554, sig);
              monoeg_g_free (sig);
            }
            <D.18552>:
            monoeg_g_free (name);
          }
          <D.18546>:
          tmp = errors;
          goto <D.18010>;
          <D.18009>:
          {
            struct MonoVerifyInfo * info;

            info = tmp->data;
            D.18555 = info->status;
            D.18556 = desc[D.18555];
            D.18557 = info->message;
            monoeg_g_print ("%s: %s\n", D.18556, D.18557);
            D.18555 = info->status;
            if (D.18555 == 1) goto <D.18558>; else goto <D.18559>;
            <D.18558>:
            count = count + 1;
            verifiable = 3;
            <D.18559>:
            D.18555 = info->status;
            if (D.18555 == 8) goto <D.18560>; else goto <D.18561>;
            <D.18560>:
            if (verifiable <= 1) goto <D.18562>; else goto <D.18563>;
            <D.18562>:
            verifiable = 2;
            <D.18563>:
            <D.18561>:
          }
          tmp = tmp->next;
          <D.18010>:
          if (tmp != 0B) goto <D.18009>; else goto <D.18011>;
          <D.18011>:
          mono_free_verify_list (errors);
        }
        <D.18004>:
        i = i + 1;
        <D.18013>:
        D.18564 = m->rows;
        D.18565 = (int) D.18564;
        if (D.18565 > i) goto <D.18012>; else goto <D.18014>;
        <D.18014>:
      }
      <D.18539>:
      if (count != 0) goto <D.18566>; else goto <D.18567>;
      <D.18566>:
      monoeg_g_print ("Error count: %d\n", count);
      <D.18567>:
      D.18568 = verifiable;
      return D.18568;
    }
  finally
    {
      desc = {CLOBBER};
    }
}