mono_verifier_verify_pe_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.21824;
  gboolean D.21827;
  _Bool D.21828;
  int D.21829;
  int D.21830;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.21824 = mono_verifier_is_enabled_for_image (image);
      if (D.21824 == 0) goto <D.21825>; else goto <D.21826>;
      <D.21825>:
      D.21827 = 1;
      return D.21827;
      <D.21826>:
      D.21828 = error_list != 0B;
      D.21829 = (int) D.21828;
      init_verify_context (&ctx, image, D.21829);
      ctx.stage = 0;
      verify_msdos_header (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21831>;
      <D.21831>:
      verify_pe_header (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21832>;
      <D.21832>:
      verify_pe_optional_header (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21833>;
      <D.21833>:
      load_section_table (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21834>;
      <D.21834>:
      load_data_directories (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21835>;
      <D.21835>:
      verify_import_table (&ctx);
      D.21830 = ctx.valid;
      if (D.21830 == 0) goto cleanup; else goto <D.21836>;
      <D.21836>:
      verify_resources_table (&ctx);
      cleanup:
      D.21827 = cleanup_context (&ctx, error_list);
      return D.21827;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


init_verify_context (struct VerifyContext * ctx, struct MonoImage * image, gboolean report_error)
{
  unsigned int D.21839;
  char * D.21840;

  memset (ctx, 0, 276);
  ctx->image = image;
  ctx->report_error = report_error;
  ctx->report_warning = 0;
  ctx->valid = 1;
  D.21839 = image->raw_data_len;
  ctx->size = D.21839;
  D.21840 = image->raw_data;
  ctx->data = D.21840;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21843;
  int D.21848;
  void * D.21850;
  unsigned int D.21851;

  D.21843 = __builtin_constant_p (__len);
  if (D.21843 != 0) goto <D.21844>; else goto <D.21845>;
  <D.21844>:
  if (__len == 0) goto <D.21846>; else goto <D.21847>;
  <D.21846>:
  D.21848 = __builtin_constant_p (__ch);
  if (D.21848 == 0) goto <D.21841>; else goto <D.21849>;
  <D.21849>:
  if (__ch != 0) goto <D.21841>; else goto <D.21842>;
  <D.21841>:
  __warn_memset_zero_len ();
  D.21850 = __dest;
  return D.21850;
  <D.21842>:
  <D.21847>:
  <D.21845>:
  D.21851 = __builtin_object_size (__dest, 0);
  D.21850 = __builtin___memset_chk (__dest, __ch, __len, D.21851);
  return D.21850;
}


verify_msdos_header (struct VerifyContext * ctx)
{
  unsigned int D.21853;
  int D.21856;
  gchar * D.21859;
  struct GSList * D.21860;
  struct GSList * D.21861;
  const char * D.21864;
  char D.21865;
  const char * D.21867;
  char D.21868;
  gchar * D.21871;
  struct GSList * D.21872;
  unsigned int D.21873;
  gchar * D.21878;
  struct GSList * D.21879;
  guint32 lfanew;

  D.21853 = ctx->size;
  if (D.21853 <= 127) goto <D.21854>; else goto <D.21855>;
  <D.21854>:
  D.21856 = ctx->report_error;
  if (D.21856 != 0) goto <D.21857>; else goto <D.21858>;
  <D.21857>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21859 = monoeg_strdup ("Not enough space for the MS-DOS header");
    vinfo->info.message = D.21859;
    vinfo->exception_type = 3;
    D.21860 = ctx->errors;
    D.21861 = monoeg_g_slist_prepend (D.21860, vinfo);
    ctx->errors = D.21861;
  }
  <D.21858>:
  ctx->valid = 0;
  return;
  <D.21855>:
  D.21864 = ctx->data;
  D.21865 = *D.21864;
  if (D.21865 != 77) goto <D.21862>; else goto <D.21866>;
  <D.21866>:
  D.21864 = ctx->data;
  D.21867 = D.21864 + 1;
  D.21868 = *D.21867;
  if (D.21868 != 90) goto <D.21862>; else goto <D.21863>;
  <D.21862>:
  D.21856 = ctx->report_error;
  if (D.21856 != 0) goto <D.21869>; else goto <D.21870>;
  <D.21869>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21871 = monoeg_strdup ("Invalid MS-DOS watermark");
    vinfo->info.message = D.21871;
    vinfo->exception_type = 3;
    D.21860 = ctx->errors;
    D.21872 = monoeg_g_slist_prepend (D.21860, vinfo);
    ctx->errors = D.21872;
  }
  <D.21870>:
  ctx->valid = 0;
  return;
  <D.21863>:
  lfanew = pe_signature_offset (ctx);
  D.21853 = ctx->size;
  D.21873 = D.21853 + 4294967292;
  if (D.21873 < lfanew) goto <D.21874>; else goto <D.21875>;
  <D.21874>:
  D.21856 = ctx->report_error;
  if (D.21856 != 0) goto <D.21876>; else goto <D.21877>;
  <D.21876>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21878 = monoeg_strdup ("MS-DOS lfanew offset points to outside of the file");
    vinfo->info.message = D.21878;
    vinfo->exception_type = 3;
    D.21860 = ctx->errors;
    D.21879 = monoeg_g_slist_prepend (D.21860, vinfo);
    ctx->errors = D.21879;
  }
  <D.21877>:
  ctx->valid = 0;
  return;
  <D.21875>:
}


pe_signature_offset (struct VerifyContext * ctx)
{
  guint32 D.21881;
  const char * D.21882;
  const unsigned char * D.21883;

  D.21882 = ctx->data;
  D.21883 = D.21882 + 60;
  D.21881 = mono_read32 (D.21883);
  return D.21881;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.21887;

  if (str != 0B) goto <D.21885>; else goto <D.21886>;
  <D.21885>:
  D.21887 = __strdup (str);
  return D.21887;
  <D.21886>:
  D.21887 = 0B;
  return D.21887;
}


verify_pe_header (struct VerifyContext * ctx)
{
  const char * D.21889;
  char D.21892;
  const char * D.21894;
  char D.21895;
  const char * D.21897;
  char D.21898;
  const char * D.21900;
  char D.21901;
  int D.21902;
  gchar * D.21905;
  struct GSList * D.21906;
  struct GSList * D.21907;
  unsigned int D.21908;
  unsigned int D.21909;
  gchar * D.21914;
  struct GSList * D.21915;
  short unsigned int D.21916;
  gchar * D.21921;
  struct GSList * D.21922;
  guint32 offset;
  const char * pe_header;

  offset = pe_signature_offset (ctx);
  D.21889 = ctx->data;
  pe_header = D.21889 + offset;
  D.21892 = *pe_header;
  if (D.21892 != 80) goto <D.21890>; else goto <D.21893>;
  <D.21893>:
  D.21894 = pe_header + 1;
  D.21895 = *D.21894;
  if (D.21895 != 69) goto <D.21890>; else goto <D.21896>;
  <D.21896>:
  D.21897 = pe_header + 2;
  D.21898 = *D.21897;
  if (D.21898 != 0) goto <D.21890>; else goto <D.21899>;
  <D.21899>:
  D.21900 = pe_header + 3;
  D.21901 = *D.21900;
  if (D.21901 != 0) goto <D.21890>; else goto <D.21891>;
  <D.21890>:
  D.21902 = ctx->report_error;
  if (D.21902 != 0) goto <D.21903>; else goto <D.21904>;
  <D.21903>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21905 = monoeg_strdup ("Invalid PE header watermark");
    vinfo->info.message = D.21905;
    vinfo->exception_type = 3;
    D.21906 = ctx->errors;
    D.21907 = monoeg_g_slist_prepend (D.21906, vinfo);
    ctx->errors = D.21907;
  }
  <D.21904>:
  ctx->valid = 0;
  return;
  <D.21891>:
  pe_header = pe_header + 4;
  offset = offset + 4;
  D.21908 = ctx->size;
  D.21909 = D.21908 + 4294967276;
  if (D.21909 < offset) goto <D.21910>; else goto <D.21911>;
  <D.21910>:
  D.21902 = ctx->report_error;
  if (D.21902 != 0) goto <D.21912>; else goto <D.21913>;
  <D.21912>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21914 = monoeg_strdup ("File with truncated pe header");
    vinfo->info.message = D.21914;
    vinfo->exception_type = 3;
    D.21906 = ctx->errors;
    D.21915 = monoeg_g_slist_prepend (D.21906, vinfo);
    ctx->errors = D.21915;
  }
  <D.21913>:
  ctx->valid = 0;
  return;
  <D.21911>:
  D.21916 = mono_read16 (pe_header);
  if (D.21916 != 332) goto <D.21917>; else goto <D.21918>;
  <D.21917>:
  D.21902 = ctx->report_error;
  if (D.21902 != 0) goto <D.21919>; else goto <D.21920>;
  <D.21919>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21921 = monoeg_strdup ("Invalid PE header Machine value");
    vinfo->info.message = D.21921;
    vinfo->exception_type = 3;
    D.21906 = ctx->errors;
    D.21922 = monoeg_g_slist_prepend (D.21906, vinfo);
    ctx->errors = D.21922;
  }
  <D.21920>:
  ctx->valid = 0;
  return;
  <D.21918>:
}


verify_pe_optional_header (struct VerifyContext * ctx)
{
  const char * D.21924;
  const unsigned char * D.21925;
  short unsigned int D.21926;
  int D.21929;
  gchar * D.21932;
  struct GSList * D.21933;
  struct GSList * D.21934;
  unsigned int D.21937;
  unsigned int D.21938;
  gchar * D.21942;
  struct GSList * D.21943;
  short unsigned int D.21944;
  gchar * D.21951;
  struct GSList * D.21952;
  const unsigned char * D.21953;
  unsigned int D.21954;
  unsigned int D.21959;
  gchar * D.21960;
  struct GSList * D.21961;
  const unsigned char * D.21962;
  _Bool D.21963;
  _Bool D.21964;
  _Bool D.21965;
  gchar * D.21970;
  struct GSList * D.21971;
  const unsigned char * D.21972;
  unsigned int D.21973;
  unsigned int D.21978;
  gchar * D.21979;
  struct GSList * D.21980;
  short unsigned int D.21982;
  gchar * D.21987;
  struct GSList * D.21988;
  short unsigned int D.21991;
  int D.21992;
  gchar * D.21993;
  struct GSList * D.21994;
  guint32 offset;
  guint32 header_size;
  guint32 file_alignment;
  const char * pe_header;
  const char * pe_optional_header;

  offset = pe_header_offset (ctx);
  D.21924 = ctx->data;
  pe_header = D.21924 + offset;
  pe_optional_header = pe_header + 20;
  D.21925 = pe_header + 16;
  D.21926 = mono_read16 (D.21925);
  header_size = (guint32) D.21926;
  offset = offset + 20;
  if (header_size <= 1) goto <D.21927>; else goto <D.21928>;
  <D.21927>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21930>; else goto <D.21931>;
  <D.21930>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21932 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.21932;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21934 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21934;
  }
  <D.21931>:
  ctx->valid = 0;
  return;
  <D.21928>:
  D.21937 = ctx->size;
  D.21938 = D.21937 - header_size;
  if (D.21938 < offset) goto <D.21935>; else goto <D.21939>;
  <D.21939>:
  D.21937 = ctx->size;
  if (D.21937 < header_size) goto <D.21935>; else goto <D.21936>;
  <D.21935>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21940>; else goto <D.21941>;
  <D.21940>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21942 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.21942;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21943 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21943;
  }
  <D.21941>:
  ctx->valid = 0;
  return;
  <D.21936>:
  D.21944 = mono_read16 (pe_optional_header);
  if (D.21944 == 267) goto <D.21945>; else goto <D.21946>;
  <D.21945>:
  if (header_size != 224) goto <D.21947>; else goto <D.21948>;
  <D.21947>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21949>; else goto <D.21950>;
  <D.21949>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21951 = monoeg_g_strdup_printf ("Invalid optional header size %d", header_size);
    vinfo->info.message = D.21951;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21952 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21952;
  }
  <D.21950>:
  ctx->valid = 0;
  return;
  <D.21948>:
  D.21953 = pe_optional_header + 32;
  D.21954 = mono_read32 (D.21953);
  if (D.21954 != 8192) goto <D.21955>; else goto <D.21956>;
  <D.21955>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21957>; else goto <D.21958>;
  <D.21957>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21953 = pe_optional_header + 32;
    D.21959 = mono_read32 (D.21953);
    D.21960 = monoeg_g_strdup_printf ("Invalid Section Aligmnent %x", D.21959);
    vinfo->info.message = D.21960;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21961 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21961;
  }
  <D.21958>:
  ctx->valid = 0;
  return;
  <D.21956>:
  D.21962 = pe_optional_header + 36;
  file_alignment = mono_read32 (D.21962);
  D.21963 = file_alignment != 512;
  D.21964 = file_alignment != 4096;
  D.21965 = D.21963 & D.21964;
  if (D.21965 != 0) goto <D.21966>; else goto <D.21967>;
  <D.21966>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21968>; else goto <D.21969>;
  <D.21968>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21970 = monoeg_g_strdup_printf ("Invalid file Aligmnent %x", file_alignment);
    vinfo->info.message = D.21970;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21971 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21971;
  }
  <D.21969>:
  ctx->valid = 0;
  return;
  <D.21967>:
  D.21972 = pe_optional_header + 92;
  D.21973 = mono_read32 (D.21972);
  if (D.21973 > 16) goto <D.21974>; else goto <D.21975>;
  <D.21974>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21976>; else goto <D.21977>;
  <D.21976>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21972 = pe_optional_header + 92;
    D.21978 = mono_read32 (D.21972);
    D.21979 = monoeg_g_strdup_printf ("Too many data directories %x", D.21978);
    vinfo->info.message = D.21979;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21980 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21980;
  }
  <D.21977>:
  ctx->valid = 0;
  return;
  <D.21975>:
  goto <D.21981>;
  <D.21946>:
  D.21982 = mono_read16 (pe_optional_header);
  if (D.21982 == 523) goto <D.21983>; else goto <D.21984>;
  <D.21983>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21985>; else goto <D.21986>;
  <D.21985>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21987 = monoeg_strdup ("Metadata verifier doesn\'t handle PE32+");
    vinfo->info.message = D.21987;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21988 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21988;
  }
  <D.21986>:
  ctx->valid = 0;
  return;
  <D.21984>:
  D.21929 = ctx->report_error;
  if (D.21929 != 0) goto <D.21989>; else goto <D.21990>;
  <D.21989>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.21991 = mono_read16 (pe_optional_header);
    D.21992 = (int) D.21991;
    D.21993 = monoeg_g_strdup_printf ("Invalid optional header magic %d", D.21992);
    vinfo->info.message = D.21993;
    vinfo->exception_type = 3;
    D.21933 = ctx->errors;
    D.21994 = monoeg_g_slist_prepend (D.21933, vinfo);
    ctx->errors = D.21994;
  }
  <D.21990>:
  ctx->valid = 0;
  return;
  <D.21981>:
}


pe_header_offset (struct VerifyContext * ctx)
{
  guint32 D.21996;
  const char * D.21997;
  const unsigned char * D.21998;
  unsigned int D.21999;

  D.21997 = ctx->data;
  D.21998 = D.21997 + 60;
  D.21999 = mono_read32 (D.21998);
  D.21996 = D.21999 + 4;
  return D.21996;
}


load_section_table (struct VerifyContext * ctx)
{
  const char * D.22001;
  const unsigned char * D.22002;
  short unsigned int D.22003;
  unsigned int D.22004;
  unsigned int D.22005;
  int D.22006;
  int D.22007;
  unsigned int D.22008;
  unsigned int D.22009;
  unsigned int D.22010;
  int D.22013;
  gchar * D.22016;
  struct GSList * D.22017;
  struct GSList * D.22018;
  unsigned int D.22019;
  unsigned int D.22020;
  void * D.22021;
  unsigned int i.0;
  unsigned int D.22023;
  struct SectionHeader * D.22024;
  const unsigned char * D.22025;
  unsigned int D.22026;
  const unsigned char * D.22027;
  unsigned int D.22028;
  const unsigned char * D.22029;
  unsigned int D.22030;
  const unsigned char * D.22031;
  unsigned int D.22032;
  const unsigned char * D.22033;
  short unsigned int D.22034;
  unsigned int D.22035;
  gchar * D.22040;
  struct GSList * D.22041;
  gchar * D.22046;
  struct GSList * D.22047;
  unsigned int D.22048;
  unsigned int D.22049;
  gchar * D.22054;
  struct GSList * D.22055;
  const unsigned char * D.22056;
  gchar * D.22061;
  struct GSList * D.22062;
  gchar * D.22067;
  struct GSList * D.22068;
  unsigned int D.22071;
  short unsigned int D.22073;
  gchar * D.22076;
  struct GSList * D.22077;
  const unsigned char * D.22078;
  unsigned int D.22082;
  gchar * D.22085;
  struct GSList * D.22086;
  int i;
  struct SectionHeader * sections;
  guint32 offset;
  const char * ptr;
  guint16 num_sections;

  offset = pe_header_offset (ctx);
  D.22001 = ctx->data;
  ptr = D.22001 + offset;
  D.22002 = ptr + 2;
  D.22003 = mono_read16 (D.22002);
  D.22004 = (unsigned int) D.22003;
  ctx->section_count = D.22004;
  D.22005 = ctx->section_count;
  num_sections = (guint16) D.22005;
  offset = offset + 244;
  ptr = ptr + 244;
  D.22006 = (int) num_sections;
  D.22007 = D.22006 * 40;
  D.22008 = (unsigned int) D.22007;
  D.22009 = ctx->size;
  D.22010 = D.22009 - offset;
  if (D.22008 > D.22010) goto <D.22011>; else goto <D.22012>;
  <D.22011>:
  D.22013 = ctx->report_error;
  if (D.22013 != 0) goto <D.22014>; else goto <D.22015>;
  <D.22014>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.22016 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.22016;
    vinfo->exception_type = 3;
    D.22017 = ctx->errors;
    D.22018 = monoeg_g_slist_prepend (D.22017, vinfo);
    ctx->errors = D.22018;
  }
  <D.22015>:
  ctx->valid = 0;
  return;
  <D.22012>:
  D.22019 = (unsigned int) num_sections;
  D.22020 = D.22019 * 20;
  D.22021 = monoeg_malloc0 (D.22020);
  ctx->sections = D.22021;
  sections = ctx->sections;
  i = 0;
  goto <D.20011>;
  <D.20010>:
  i.0 = (unsigned int) i;
  D.22023 = i.0 * 20;
  D.22024 = sections + D.22023;
  D.22025 = ptr + 8;
  D.22026 = mono_read32 (D.22025);
  D.22024->size = D.22026;
  i.0 = (unsigned int) i;
  D.22023 = i.0 * 20;
  D.22024 = sections + D.22023;
  D.22027 = ptr + 12;
  D.22028 = mono_read32 (D.22027);
  D.22024->baseRVA = D.22028;
  i.0 = (unsigned int) i;
  D.22023 = i.0 * 20;
  D.22024 = sections + D.22023;
  D.22029 = ptr + 20;
  D.22030 = mono_read32 (D.22029);
  D.22024->baseOffset = D.22030;
  i.0 = (unsigned int) i;
  D.22023 = i.0 * 20;
  D.22024 = sections + D.22023;
  D.22031 = ptr + 24;
  D.22032 = mono_read32 (D.22031);
  D.22024->rellocationsRVA = D.22032;
  i.0 = (unsigned int) i;
  D.22023 = i.0 * 20;
  D.22024 = sections + D.22023;
  D.22033 = ptr + 32;
  D.22034 = mono_read16 (D.22033);
  D.22024->numberOfRelocations = D.22034;
  ptr = ptr + 40;
  i = i + 1;
  <D.20011>:
  D.22006 = (int) num_sections;
  if (D.22006 > i) goto <D.20010>; else goto <D.20012>;
  <D.20012>:
  D.22001 = ctx->data;
  ptr = D.22001 + offset;
  i = 0;
  goto <D.20023>;
  <D.20022>:
  {
    guint32 raw_size;
    guint32 flags;

    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22035 = D.22024->baseOffset;
    if (D.22035 == 0) goto <D.22036>; else goto <D.22037>;
    <D.22036>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22038>; else goto <D.22039>;
    <D.22038>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22040 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with intialized data only");
      vinfo->info.message = D.22040;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22041 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22041;
    }
    <D.22039>:
    ctx->valid = 0;
    return;
    <D.22037>:
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22035 = D.22024->baseOffset;
    D.22009 = ctx->size;
    if (D.22035 >= D.22009) goto <D.22042>; else goto <D.22043>;
    <D.22042>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22044>; else goto <D.22045>;
    <D.22044>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      i.0 = (unsigned int) i;
      D.22023 = i.0 * 20;
      D.22024 = sections + D.22023;
      D.22035 = D.22024->baseOffset;
      D.22046 = monoeg_g_strdup_printf ("Invalid PointerToRawData %x points beyond EOF", D.22035);
      vinfo->info.message = D.22046;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22047 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22047;
    }
    <D.22045>:
    ctx->valid = 0;
    return;
    <D.22043>:
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22048 = D.22024->size;
    D.22009 = ctx->size;
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22035 = D.22024->baseOffset;
    D.22049 = D.22009 - D.22035;
    if (D.22048 > D.22049) goto <D.22050>; else goto <D.22051>;
    <D.22050>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22052>; else goto <D.22053>;
    <D.22052>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22054 = monoeg_strdup ("Invalid VirtualSize points beyond EOF");
      vinfo->info.message = D.22054;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22055 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22055;
    }
    <D.22053>:
    ctx->valid = 0;
    return;
    <D.22051>:
    D.22056 = ptr + 16;
    raw_size = mono_read32 (D.22056);
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22048 = D.22024->size;
    if (D.22048 > raw_size) goto <D.22057>; else goto <D.22058>;
    <D.22057>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22059>; else goto <D.22060>;
    <D.22059>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22061 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with SizeOfRawData < VirtualSize");
      vinfo->info.message = D.22061;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22062 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22062;
    }
    <D.22060>:
    ctx->valid = 0;
    return;
    <D.22058>:
    D.22009 = ctx->size;
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22035 = D.22024->baseOffset;
    D.22049 = D.22009 - D.22035;
    if (D.22049 < raw_size) goto <D.22063>; else goto <D.22064>;
    <D.22063>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22065>; else goto <D.22066>;
    <D.22065>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22067 = monoeg_g_strdup_printf ("Invalid SizeOfRawData %x points beyond EOF", raw_size);
      vinfo->info.message = D.22067;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22068 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22068;
    }
    <D.22066>:
    ctx->valid = 0;
    return;
    <D.22064>:
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22071 = D.22024->rellocationsRVA;
    if (D.22071 != 0) goto <D.22069>; else goto <D.22072>;
    <D.22072>:
    i.0 = (unsigned int) i;
    D.22023 = i.0 * 20;
    D.22024 = sections + D.22023;
    D.22073 = D.22024->numberOfRelocations;
    if (D.22073 != 0) goto <D.22069>; else goto <D.22070>;
    <D.22069>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22074>; else goto <D.22075>;
    <D.22074>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22076 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t handle section relocation");
      vinfo->info.message = D.22076;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22077 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22077;
    }
    <D.22075>:
    ctx->valid = 0;
    return;
    <D.22070>:
    D.22078 = ptr + 36;
    flags = mono_read32 (D.22078);
    if (flags == 0) goto <D.22079>; else goto <D.22081>;
    <D.22081>:
    D.22082 = flags & 33554207;
    if (D.22082 != 0) goto <D.22079>; else goto <D.22080>;
    <D.22079>:
    D.22013 = ctx->report_error;
    if (D.22013 != 0) goto <D.22083>; else goto <D.22084>;
    <D.22083>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22085 = monoeg_g_strdup_printf ("Invalid section flags %x", flags);
      vinfo->info.message = D.22085;
      vinfo->exception_type = 3;
      D.22017 = ctx->errors;
      D.22086 = monoeg_g_slist_prepend (D.22017, vinfo);
      ctx->errors = D.22086;
    }
    <D.22084>:
    ctx->valid = 0;
    return;
    <D.22080>:
    ptr = ptr + 40;
  }
  i = i + 1;
  <D.20023>:
  D.22006 = (int) num_sections;
  if (D.22006 > i) goto <D.20022>; else goto <D.20024>;
  <D.20024>:
}


load_data_directories (struct VerifyContext * ctx)
{
  unsigned int D.22088;
  const char * D.22089;
  const unsigned char * D.22090;
  unsigned int D.22093;
  int D.22096;
  int D.22099;
  gchar * D.22102;
  struct GSList * D.22103;
  struct GSList * D.22104;
  int D.22107;
  gchar * D.22112;
  struct GSList * D.22113;
  unsigned int D.22114;
  guint32 offset;
  const char * ptr;
  int i;

  D.22088 = pe_header_offset (ctx);
  offset = D.22088 + 116;
  D.22089 = ctx->data;
  ptr = D.22089 + offset;
  i = 0;
  goto <D.20040>;
  <D.20039>:
  {
    guint32 rva;
    guint32 size;

    rva = mono_read32 (ptr);
    D.22090 = ptr + 4;
    size = mono_read32 (D.22090);
    if (i == 4) goto <D.22091>; else goto <D.22092>;
    <D.22091>:
    ptr = ptr + 8;
    // predicted unlikely by continue predictor.
    goto <D.20036>;
    <D.22092>:
    D.22093 = rva | size;
    if (D.22093 != 0) goto <D.22094>; else goto <D.22095>;
    <D.22094>:
    D.22096 = is_valid_data_directory (i);
    if (D.22096 == 0) goto <D.22097>; else goto <D.22098>;
    <D.22097>:
    D.22099 = ctx->report_error;
    if (D.22099 != 0) goto <D.22100>; else goto <D.22101>;
    <D.22100>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22102 = monoeg_g_strdup_printf ("Invalid data directory %d", i);
      vinfo->info.message = D.22102;
      vinfo->exception_type = 3;
      D.22103 = ctx->errors;
      D.22104 = monoeg_g_slist_prepend (D.22103, vinfo);
      ctx->errors = D.22104;
    }
    <D.22101>:
    ctx->valid = 0;
    return;
    <D.22098>:
    <D.22095>:
    if (rva != 0) goto <D.22105>; else goto <D.22106>;
    <D.22105>:
    D.22107 = bounds_check_virtual_address (ctx, rva, size);
    if (D.22107 == 0) goto <D.22108>; else goto <D.22109>;
    <D.22108>:
    D.22099 = ctx->report_error;
    if (D.22099 != 0) goto <D.22110>; else goto <D.22111>;
    <D.22110>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (12);
      vinfo->info.status = 1;
      D.22112 = monoeg_g_strdup_printf ("Invalid data directory %d rva/size pair %x/%x", i, rva, size);
      vinfo->info.message = D.22112;
      vinfo->exception_type = 3;
      D.22103 = ctx->errors;
      D.22113 = monoeg_g_slist_prepend (D.22103, vinfo);
      ctx->errors = D.22113;
    }
    <D.22111>:
    ctx->valid = 0;
    return;
    <D.22109>:
    <D.22106>:
    ctx->data_directories[i].rva = rva;
    ctx->data_directories[i].size = size;
    D.22114 = translate_rva (ctx, rva);
    ctx->data_directories[i].translated_offset = D.22114;
    ptr = ptr + 8;
  }
  <D.20036>:
  i = i + 1;
  <D.20040>:
  if (i <= 15) goto <D.20039>; else goto <D.20041>;
  <D.20041>:
}


is_valid_data_directory (int i)
{
  gboolean D.22116;
  int iftmp.1;
  unsigned int i.2;
  unsigned int D.22122;
  _Bool D.22123;
  _Bool D.22124;
  _Bool D.22125;
  _Bool D.22127;
  _Bool D.22128;
  _Bool D.22129;
  _Bool D.22131;
  _Bool D.22132;
  _Bool D.22133;

  i.2 = (unsigned int) i;
  D.22122 = i.2 + 4294967295;
  D.22123 = D.22122 <= 1;
  D.22124 = i == 5;
  D.22125 = D.22123 | D.22124;
  if (D.22125 != 0) goto <D.22118>; else goto <D.22126>;
  <D.22126>:
  D.22127 = i == 12;
  D.22128 = i == 14;
  D.22129 = D.22127 | D.22128;
  if (D.22129 != 0) goto <D.22118>; else goto <D.22130>;
  <D.22130>:
  D.22131 = i == 4;
  D.22132 = i == 6;
  D.22133 = D.22131 | D.22132;
  if (D.22133 != 0) goto <D.22118>; else goto <D.22119>;
  <D.22118>:
  iftmp.1 = 1;
  goto <D.22120>;
  <D.22119>:
  iftmp.1 = 0;
  <D.22120>:
  D.22116 = iftmp.1;
  return D.22116;
}


bounds_check_virtual_address (struct VerifyContext * ctx, guint32 rva, guint32 size)
{
  unsigned int D.22135;
  gboolean D.22138;
  int D.22139;
  struct MonoImage * D.22142;
  unsigned int D.22143;
  struct SectionHeader * D.22148;
  unsigned int i.3;
  unsigned int D.22152;
  struct SectionHeader * D.22153;
  unsigned int D.22154;
  unsigned int D.22155;
  unsigned int i.4;
  unsigned int D.22161;
  int i;

  D.22135 = rva + size;
  if (D.22135 < rva) goto <D.22136>; else goto <D.22137>;
  <D.22136>:
  D.22138 = 0;
  return D.22138;
  <D.22137>:
  D.22139 = ctx->stage;
  if (D.22139 > 0) goto <D.22140>; else goto <D.22141>;
  <D.22140>:
  {
    struct MonoCLIImageInfo * iinfo;
    const int top;
    struct MonoSectionTable * tables;
    int i;

    D.22142 = ctx->image;
    iinfo = D.22142->image_info;
    top = iinfo->cli_section_count;
    tables = iinfo->cli_section_tables;
    i = 0;
    goto <D.19942>;
    <D.19941>:
    {
      guint32 base;
      guint32 end;

      base = tables->st_virtual_address;
      D.22143 = tables->st_raw_data_size;
      end = D.22143 + base;
      if (rva >= base) goto <D.22144>; else goto <D.22145>;
      <D.22144>:
      D.22135 = rva + size;
      if (D.22135 <= end) goto <D.22146>; else goto <D.22147>;
      <D.22146>:
      D.22138 = 1;
      return D.22138;
      <D.22147>:
      <D.22145>:
      tables = tables + 40;
    }
    i = i + 1;
    <D.19942>:
    if (i < top) goto <D.19941>; else goto <D.19943>;
    <D.19943>:
    D.22138 = 0;
    return D.22138;
  }
  <D.22141>:
  D.22148 = ctx->sections;
  if (D.22148 == 0B) goto <D.22149>; else goto <D.22150>;
  <D.22149>:
  D.22138 = 0;
  return D.22138;
  <D.22150>:
  i = 0;
  goto <D.19947>;
  <D.19946>:
  {
    guint32 base;
    guint32 end;

    D.22148 = ctx->sections;
    i.3 = (unsigned int) i;
    D.22152 = i.3 * 20;
    D.22153 = D.22148 + D.22152;
    base = D.22153->baseRVA;
    D.22148 = ctx->sections;
    i.3 = (unsigned int) i;
    D.22152 = i.3 * 20;
    D.22153 = D.22148 + D.22152;
    D.22154 = D.22153->baseRVA;
    D.22148 = ctx->sections;
    i.3 = (unsigned int) i;
    D.22152 = i.3 * 20;
    D.22153 = D.22148 + D.22152;
    D.22155 = D.22153->size;
    end = D.22154 + D.22155;
    if (rva >= base) goto <D.22156>; else goto <D.22157>;
    <D.22156>:
    D.22135 = rva + size;
    if (D.22135 <= end) goto <D.22158>; else goto <D.22159>;
    <D.22158>:
    D.22138 = 1;
    return D.22138;
    <D.22159>:
    <D.22157>:
  }
  i = i + 1;
  <D.19947>:
  i.4 = (unsigned int) i;
  D.22161 = ctx->section_count;
  if (i.4 < D.22161) goto <D.19946>; else goto <D.19948>;
  <D.19948>:
  D.22138 = 0;
  return D.22138;
}


translate_rva (struct VerifyContext * ctx, guint32 rva)
{
  int D.22163;
  guint32 D.22166;
  struct MonoImage * D.22167;
  struct SectionHeader * D.22168;
  unsigned int i.5;
  unsigned int D.22172;
  struct SectionHeader * D.22173;
  unsigned int D.22174;
  unsigned int D.22175;
  _Bool D.22176;
  _Bool D.22177;
  _Bool D.22178;
  unsigned int D.22181;
  unsigned int D.22182;
  guint32 iftmp.6;
  unsigned int D.22184;
  unsigned int i.7;
  unsigned int D.22189;
  int i;

  D.22163 = ctx->stage;
  if (D.22163 > 0) goto <D.22164>; else goto <D.22165>;
  <D.22164>:
  D.22167 = ctx->image;
  D.22166 = mono_cli_rva_image_map (D.22167, rva);
  return D.22166;
  <D.22165>:
  D.22168 = ctx->sections;
  if (D.22168 == 0B) goto <D.22169>; else goto <D.22170>;
  <D.22169>:
  D.22166 = 0;
  return D.22166;
  <D.22170>:
  i = 0;
  goto <D.19968>;
  <D.19967>:
  {
    guint32 base;
    guint32 end;

    D.22168 = ctx->sections;
    i.5 = (unsigned int) i;
    D.22172 = i.5 * 20;
    D.22173 = D.22168 + D.22172;
    base = D.22173->baseRVA;
    D.22168 = ctx->sections;
    i.5 = (unsigned int) i;
    D.22172 = i.5 * 20;
    D.22173 = D.22168 + D.22172;
    D.22174 = D.22173->baseRVA;
    D.22168 = ctx->sections;
    i.5 = (unsigned int) i;
    D.22172 = i.5 * 20;
    D.22173 = D.22168 + D.22172;
    D.22175 = D.22173->size;
    end = D.22174 + D.22175;
    D.22176 = rva >= base;
    D.22177 = rva <= end;
    D.22178 = D.22176 & D.22177;
    if (D.22178 != 0) goto <D.22179>; else goto <D.22180>;
    <D.22179>:
    {
      guint32 res;

      D.22181 = rva - base;
      D.22168 = ctx->sections;
      i.5 = (unsigned int) i;
      D.22172 = i.5 * 20;
      D.22173 = D.22168 + D.22172;
      D.22182 = D.22173->baseOffset;
      res = D.22181 + D.22182;
      D.22184 = ctx->size;
      if (D.22184 > res) goto <D.22185>; else goto <D.22186>;
      <D.22185>:
      iftmp.6 = res;
      goto <D.22187>;
      <D.22186>:
      iftmp.6 = 4294967295;
      <D.22187>:
      D.22166 = iftmp.6;
      return D.22166;
    }
    <D.22180>:
  }
  i = i + 1;
  <D.19968>:
  i.7 = (unsigned int) i;
  D.22189 = ctx->section_count;
  if (i.7 < D.22189) goto <D.19967>; else goto <D.19969>;
  <D.19969>:
  D.22166 = 4294967295;
  return D.22166;
}


verify_import_table (struct VerifyContext * ctx)
{
  const char * D.22191;
  _Bool D.22192;
  long int D.22193;
  long int D.22194;
  unsigned int D.22197;
  int D.22200;
  gchar * D.22203;
  struct GSList * D.22204;
  struct GSList * D.22205;
  int D.22208;
  gchar * D.22213;
  struct GSList * D.22214;
  const unsigned char * D.22215;
  int D.22218;
  gchar * D.22223;
  struct GSList * D.22224;
  const unsigned char * D.22225;
  int D.22228;
  gchar * D.22233;
  struct GSList * D.22234;
  unsigned int D.22235;
  unsigned int D.22240;
  gchar * D.22241;
  struct GSList * D.22242;
  _Bool D.22245;
  long int D.22246;
  long int D.22247;
  int D.22250;
  gchar * D.22255;
  struct GSList * D.22256;
  int D.22259;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  guint32 name_rva;
  guint32 ilt_rva;
  guint32 iat_rva;

  try
    {
      it = ctx->data_directories[1];
      offset = it.translated_offset;
      D.22191 = ctx->data;
      ptr = D.22191 + offset;
      D.22192 = offset == 4294967295;
      D.22193 = (long int) D.22192;
      D.22194 = __builtin_expect (D.22193, 0);
      if (D.22194 != 0) goto <D.22195>; else goto <D.22196>;
      <D.22195>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 612, "offset != INVALID_OFFSET");
      <D.22196>:
      D.22197 = it.size;
      if (D.22197 <= 39) goto <D.22198>; else goto <D.22199>;
      <D.22198>:
      D.22200 = ctx->report_error;
      if (D.22200 != 0) goto <D.22201>; else goto <D.22202>;
      <D.22201>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22197 = it.size;
        D.22203 = monoeg_g_strdup_printf ("Import table size %d is smaller than 40", D.22197);
        vinfo->info.message = D.22203;
        vinfo->exception_type = 3;
        D.22204 = ctx->errors;
        D.22205 = monoeg_g_slist_prepend (D.22204, vinfo);
        ctx->errors = D.22205;
      }
      <D.22202>:
      ctx->valid = 0;
      return;
      <D.22199>:
      ilt_rva = mono_read32 (ptr);
      if (ilt_rva != 0) goto <D.22206>; else goto <D.22207>;
      <D.22206>:
      D.22208 = bounds_check_virtual_address (ctx, ilt_rva, 8);
      if (D.22208 == 0) goto <D.22209>; else goto <D.22210>;
      <D.22209>:
      D.22200 = ctx->report_error;
      if (D.22200 != 0) goto <D.22211>; else goto <D.22212>;
      <D.22211>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22213 = monoeg_g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva);
        vinfo->info.message = D.22213;
        vinfo->exception_type = 3;
        D.22204 = ctx->errors;
        D.22214 = monoeg_g_slist_prepend (D.22204, vinfo);
        ctx->errors = D.22214;
      }
      <D.22212>:
      ctx->valid = 0;
      return;
      <D.22210>:
      <D.22207>:
      D.22215 = ptr + 12;
      name_rva = mono_read32 (D.22215);
      if (name_rva != 0) goto <D.22216>; else goto <D.22217>;
      <D.22216>:
      D.22218 = bounds_check_virtual_address (ctx, name_rva, 12);
      if (D.22218 == 0) goto <D.22219>; else goto <D.22220>;
      <D.22219>:
      D.22200 = ctx->report_error;
      if (D.22200 != 0) goto <D.22221>; else goto <D.22222>;
      <D.22221>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22223 = monoeg_g_strdup_printf ("Invalid Import Table Name rva %x", name_rva);
        vinfo->info.message = D.22223;
        vinfo->exception_type = 3;
        D.22204 = ctx->errors;
        D.22224 = monoeg_g_slist_prepend (D.22204, vinfo);
        ctx->errors = D.22224;
      }
      <D.22222>:
      ctx->valid = 0;
      return;
      <D.22220>:
      <D.22217>:
      D.22225 = ptr + 16;
      iat_rva = mono_read32 (D.22225);
      if (iat_rva != 0) goto <D.22226>; else goto <D.22227>;
      <D.22226>:
      D.22228 = bounds_check_virtual_address (ctx, iat_rva, 8);
      if (D.22228 == 0) goto <D.22229>; else goto <D.22230>;
      <D.22229>:
      D.22200 = ctx->report_error;
      if (D.22200 != 0) goto <D.22231>; else goto <D.22232>;
      <D.22231>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22233 = monoeg_g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva);
        vinfo->info.message = D.22233;
        vinfo->exception_type = 3;
        D.22204 = ctx->errors;
        D.22234 = monoeg_g_slist_prepend (D.22204, vinfo);
        ctx->errors = D.22234;
      }
      <D.22232>:
      ctx->valid = 0;
      return;
      <D.22230>:
      D.22235 = ctx->data_directories[12].rva;
      if (D.22235 != iat_rva) goto <D.22236>; else goto <D.22237>;
      <D.22236>:
      D.22200 = ctx->report_error;
      if (D.22200 != 0) goto <D.22238>; else goto <D.22239>;
      <D.22238>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22225 = ptr + 16;
        D.22240 = mono_read32 (D.22225);
        D.22235 = ctx->data_directories[12].rva;
        D.22241 = monoeg_g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", D.22240, D.22235);
        vinfo->info.message = D.22241;
        vinfo->exception_type = 3;
        D.22204 = ctx->errors;
        D.22242 = monoeg_g_slist_prepend (D.22204, vinfo);
        ctx->errors = D.22242;
      }
      <D.22239>:
      ctx->valid = 0;
      return;
      <D.22237>:
      <D.22227>:
      if (name_rva != 0) goto <D.22243>; else goto <D.22244>;
      <D.22243>:
      name_rva = translate_rva (ctx, name_rva);
      D.22245 = name_rva == 4294967295;
      D.22246 = (long int) D.22245;
      D.22247 = __builtin_expect (D.22246, 0);
      if (D.22247 != 0) goto <D.22248>; else goto <D.22249>;
      <D.22248>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 636, "name_rva != INVALID_OFFSET");
      <D.22249>:
      D.22191 = ctx->data;
      ptr = D.22191 + name_rva;
      D.22250 = memcmp ("mscoree.dll", ptr, 12);
      if (D.22250 != 0) goto <D.22251>; else goto <D.22252>;
      <D.22251>:
      {
        char name[12];

        try
          {
            memcpy (&name, ptr, 12);
            name[11] = 0;
            D.22200 = ctx->report_error;
            if (D.22200 != 0) goto <D.22253>; else goto <D.22254>;
            <D.22253>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.22255 = monoeg_g_strdup_printf ("Invalid Import Table Name: \'%s\'", &name);
              vinfo->info.message = D.22255;
              vinfo->exception_type = 3;
              D.22204 = ctx->errors;
              D.22256 = monoeg_g_slist_prepend (D.22204, vinfo);
              ctx->errors = D.22256;
            }
            <D.22254>:
            ctx->valid = 0;
            return;
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      <D.22252>:
      <D.22244>:
      if (ilt_rva != 0) goto <D.22257>; else goto <D.22258>;
      <D.22257>:
      verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
      D.22259 = ctx->valid;
      if (D.22259 == 0) goto <D.22260>; else goto <D.22261>;
      <D.22260>:
      return;
      <D.22261>:
      <D.22258>:
      if (iat_rva != 0) goto <D.22262>; else goto <D.22263>;
      <D.22262>:
      verify_hint_name_table (ctx, iat_rva, "Import Address Table");
      <D.22263>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.22268;
  unsigned int D.22269;

  D.22269 = __builtin_object_size (__dest, 0);
  D.22268 = __builtin___memcpy_chk (__dest, __src, __len, D.22269);
  return D.22268;
}


verify_hint_name_table (struct VerifyContext * ctx, guint32 import_rva, const char * table_name)
{
  _Bool D.22271;
  long int D.22272;
  long int D.22273;
  const char * D.22276;
  const unsigned char * D.22277;
  int D.22278;
  int D.22281;
  gchar * D.22284;
  struct GSList * D.22285;
  struct GSList * D.22286;
  _Bool D.22287;
  long int D.22288;
  long int D.22289;
  sizetype D.22292;
  int D.22293;
  int D.22296;
  gchar * D.22301;
  struct GSList * D.22302;
  const char * ptr;
  guint32 hint_table_rva;

  import_rva = translate_rva (ctx, import_rva);
  D.22271 = import_rva == 4294967295;
  D.22272 = (long int) D.22271;
  D.22273 = __builtin_expect (D.22272, 0);
  if (D.22273 != 0) goto <D.22274>; else goto <D.22275>;
  <D.22274>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 586, "import_rva != INVALID_OFFSET");
  <D.22275>:
  D.22276 = ctx->data;
  D.22277 = D.22276 + import_rva;
  hint_table_rva = mono_read32 (D.22277);
  D.22278 = bounds_check_virtual_address (ctx, hint_table_rva, 14);
  if (D.22278 == 0) goto <D.22279>; else goto <D.22280>;
  <D.22279>:
  D.22281 = ctx->report_error;
  if (D.22281 != 0) goto <D.22282>; else goto <D.22283>;
  <D.22282>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.22284 = monoeg_g_strdup_printf ("Invalid Hint/Name rva %d for %s", hint_table_rva, table_name);
    vinfo->info.message = D.22284;
    vinfo->exception_type = 3;
    D.22285 = ctx->errors;
    D.22286 = monoeg_g_slist_prepend (D.22285, vinfo);
    ctx->errors = D.22286;
  }
  <D.22283>:
  ctx->valid = 0;
  return;
  <D.22280>:
  hint_table_rva = translate_rva (ctx, hint_table_rva);
  D.22287 = hint_table_rva == 4294967295;
  D.22288 = (long int) D.22287;
  D.22289 = __builtin_expect (D.22288, 0);
  if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
  <D.22290>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 593, "hint_table_rva != INVALID_OFFSET");
  <D.22291>:
  D.22276 = ctx->data;
  D.22292 = hint_table_rva + 2;
  ptr = D.22276 + D.22292;
  D.22293 = memcmp ("_CorExeMain", ptr, 12);
  if (D.22293 != 0) goto <D.22294>; else goto <D.22295>;
  <D.22294>:
  D.22296 = memcmp ("_CorDllMain", ptr, 12);
  if (D.22296 != 0) goto <D.22297>; else goto <D.22298>;
  <D.22297>:
  {
    char name[12];

    try
      {
        memcpy (&name, ptr, 12);
        name[11] = 0;
        D.22281 = ctx->report_error;
        if (D.22281 != 0) goto <D.22299>; else goto <D.22300>;
        <D.22299>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22301 = monoeg_g_strdup_printf ("Invalid Hint / Name: \'%s\'", &name);
          vinfo->info.message = D.22301;
          vinfo->exception_type = 3;
          D.22285 = ctx->errors;
          D.22302 = monoeg_g_slist_prepend (D.22285, vinfo);
          ctx->errors = D.22302;
        }
        <D.22300>:
        ctx->valid = 0;
        return;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.22298>:
  <D.22295>:
}


verify_resources_table (struct VerifyContext * ctx)
{
  unsigned int D.22305;
  unsigned int D.22308;
  int D.22311;
  gchar * D.22314;
  struct GSList * D.22315;
  struct GSList * D.22316;
  const char * D.22317;
  _Bool D.22318;
  long int D.22319;
  long int D.22320;
  const unsigned char * D.22323;
  const unsigned char * D.22324;
  int D.22325;
  int D.22326;
  int D.22327;
  int D.22328;
  int D.22329;
  unsigned int D.22330;
  gchar * D.22335;
  struct GSList * D.22336;
  struct DataDirectory it;
  guint32 offset;
  guint16 named_entries;
  guint16 id_entries;
  const char * ptr;
  const char * root;
  const char * end;

  try
    {
      it = ctx->data_directories[2];
      D.22305 = it.rva;
      if (D.22305 == 0) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      return;
      <D.22307>:
      D.22308 = it.size;
      if (D.22308 <= 15) goto <D.22309>; else goto <D.22310>;
      <D.22309>:
      D.22311 = ctx->report_error;
      if (D.22311 != 0) goto <D.22312>; else goto <D.22313>;
      <D.22312>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22308 = it.size;
        D.22314 = monoeg_g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it\'s %d long", D.22308);
        vinfo->info.message = D.22314;
        vinfo->exception_type = 3;
        D.22315 = ctx->errors;
        D.22316 = monoeg_g_slist_prepend (D.22315, vinfo);
        ctx->errors = D.22316;
      }
      <D.22313>:
      ctx->valid = 0;
      return;
      <D.22310>:
      offset = it.translated_offset;
      D.22317 = ctx->data;
      ptr = D.22317 + offset;
      root = ptr;
      D.22308 = it.size;
      end = root + D.22308;
      D.22318 = offset == 4294967295;
      D.22319 = (long int) D.22318;
      D.22320 = __builtin_expect (D.22319, 0);
      if (D.22320 != 0) goto <D.22321>; else goto <D.22322>;
      <D.22321>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 674, "offset != INVALID_OFFSET");
      <D.22322>:
      D.22323 = ptr + 12;
      named_entries = mono_read16 (D.22323);
      D.22324 = ptr + 14;
      id_entries = mono_read16 (D.22324);
      D.22325 = (int) named_entries;
      D.22326 = (int) id_entries;
      D.22327 = D.22325 + D.22326;
      D.22328 = D.22327 + 2;
      D.22329 = D.22328 * 8;
      D.22330 = (unsigned int) D.22329;
      D.22308 = it.size;
      if (D.22330 > D.22308) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      D.22311 = ctx->report_error;
      if (D.22311 != 0) goto <D.22333>; else goto <D.22334>;
      <D.22333>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22325 = (int) named_entries;
        D.22326 = (int) id_entries;
        D.22327 = D.22325 + D.22326;
        D.22308 = it.size;
        D.22335 = monoeg_g_strdup_printf ("Resource section is too small, the number of entries (%d) doesn\'t fit on it\'s size %d", D.22327, D.22308);
        vinfo->info.message = D.22335;
        vinfo->exception_type = 3;
        D.22315 = ctx->errors;
        D.22336 = monoeg_g_slist_prepend (D.22315, vinfo);
        ctx->errors = D.22336;
      }
      <D.22334>:
      ctx->valid = 0;
      return;
      <D.22332>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


cleanup_context (struct VerifyContext * ctx, struct GSList * * error_list)
{
  struct SectionHeader * D.22340;
  struct GSList * D.22343;
  gboolean D.22345;

  D.22340 = ctx->sections;
  monoeg_g_free (D.22340);
  if (error_list != 0B) goto <D.22341>; else goto <D.22342>;
  <D.22341>:
  D.22343 = ctx->errors;
  *error_list = D.22343;
  goto <D.22344>;
  <D.22342>:
  D.22343 = ctx->errors;
  mono_free_verify_list (D.22343);
  <D.22344>:
  D.22345 = ctx->valid;
  return D.22345;
}


mono_verifier_verify_cli_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.22347;
  gboolean D.22350;
  _Bool D.22351;
  int D.22352;
  int D.22353;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.22347 = mono_verifier_is_enabled_for_image (image);
      if (D.22347 == 0) goto <D.22348>; else goto <D.22349>;
      <D.22348>:
      D.22350 = 1;
      return D.22350;
      <D.22349>:
      D.22351 = error_list != 0B;
      D.22352 = (int) D.22351;
      init_verify_context (&ctx, image, D.22352);
      ctx.stage = 1;
      verify_cli_header (&ctx);
      D.22353 = ctx.valid;
      if (D.22353 == 0) goto cleanup; else goto <D.22354>;
      <D.22354>:
      verify_metadata_header (&ctx);
      D.22353 = ctx.valid;
      if (D.22353 == 0) goto cleanup; else goto <D.22355>;
      <D.22355>:
      verify_tables_schema (&ctx);
      cleanup:
      D.22350 = cleanup_context (&ctx, error_list);
      return D.22350;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_cli_header (struct VerifyContext * ctx)
{
  unsigned int D.22358;
  int D.22361;
  gchar * D.22364;
  struct GSList * D.22365;
  struct GSList * D.22366;
  unsigned int D.22367;
  gchar * D.22372;
  struct GSList * D.22373;
  const char * D.22374;
  _Bool D.22375;
  long int D.22376;
  long int D.22377;
  short unsigned int D.22380;
  short unsigned int D.22385;
  int D.22386;
  gchar * D.22387;
  struct GSList * D.22388;
  const unsigned char * D.22389;
  unsigned int D.22390;
  const unsigned char * D.22391;
  unsigned int D.22392;
  int D.22393;
  unsigned int D.22398;
  unsigned int D.22399;
  gchar * D.22400;
  struct GSList * D.22401;
  unsigned int D.22404;
  unsigned int D.22406;
  gchar * D.22409;
  struct GSList * D.22410;
  const unsigned char * D.22411;
  unsigned int D.22412;
  unsigned int D.22413;
  gchar * D.22418;
  struct GSList * D.22419;
  const unsigned char * D.22420;
  int D.22423;
  gchar * D.22428;
  struct GSList * D.22429;
  _Bool D.22430;
  _Bool D.22431;
  _Bool D.22432;
  gchar * D.22437;
  struct GSList * D.22438;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  int i;

  try
    {
      it = get_data_dir (ctx, 14); [return slot optimization]
      D.22358 = it.rva;
      if (D.22358 == 0) goto <D.22359>; else goto <D.22360>;
      <D.22359>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22362>; else goto <D.22363>;
      <D.22362>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22364 = monoeg_g_strdup_printf ("CLI header missing");
        vinfo->info.message = D.22364;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22366 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22366;
      }
      <D.22363>:
      ctx->valid = 0;
      return;
      <D.22360>:
      D.22367 = it.size;
      if (D.22367 != 72) goto <D.22368>; else goto <D.22369>;
      <D.22368>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22370>; else goto <D.22371>;
      <D.22370>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22367 = it.size;
        D.22372 = monoeg_g_strdup_printf ("Invalid cli header size in data directory %d must be 72", D.22367);
        vinfo->info.message = D.22372;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22373 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22373;
      }
      <D.22371>:
      ctx->valid = 0;
      return;
      <D.22369>:
      offset = it.translated_offset;
      D.22374 = ctx->data;
      ptr = D.22374 + offset;
      D.22375 = offset == 4294967295;
      D.22376 = (long int) D.22375;
      D.22377 = __builtin_expect (D.22376, 0);
      if (D.22377 != 0) goto <D.22378>; else goto <D.22379>;
      <D.22378>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 721, "offset != INVALID_OFFSET");
      <D.22379>:
      D.22380 = mono_read16 (ptr);
      if (D.22380 != 72) goto <D.22381>; else goto <D.22382>;
      <D.22381>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22383>; else goto <D.22384>;
      <D.22383>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22385 = mono_read16 (ptr);
        D.22386 = (int) D.22385;
        D.22387 = monoeg_g_strdup_printf ("Invalid cli header size %d must be 72", D.22386);
        vinfo->info.message = D.22387;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22388 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22388;
      }
      <D.22384>:
      ctx->valid = 0;
      return;
      <D.22382>:
      D.22389 = ptr + 8;
      D.22390 = mono_read32 (D.22389);
      D.22391 = ptr + 12;
      D.22392 = mono_read32 (D.22391);
      D.22393 = bounds_check_virtual_address (ctx, D.22390, D.22392);
      if (D.22393 == 0) goto <D.22394>; else goto <D.22395>;
      <D.22394>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22396>; else goto <D.22397>;
      <D.22396>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22389 = ptr + 8;
        D.22398 = mono_read32 (D.22389);
        D.22391 = ptr + 12;
        D.22399 = mono_read32 (D.22391);
        D.22400 = monoeg_g_strdup_printf ("Invalid medatata section rva/size pair %x/%x", D.22398, D.22399);
        vinfo->info.message = D.22400;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22401 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22401;
      }
      <D.22397>:
      ctx->valid = 0;
      return;
      <D.22395>:
      D.22389 = ptr + 8;
      D.22404 = mono_read32 (D.22389);
      if (D.22404 == 0) goto <D.22402>; else goto <D.22405>;
      <D.22405>:
      D.22391 = ptr + 12;
      D.22406 = mono_read32 (D.22391);
      if (D.22406 == 0) goto <D.22402>; else goto <D.22403>;
      <D.22402>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22407>; else goto <D.22408>;
      <D.22407>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22409 = monoeg_g_strdup_printf ("Missing medatata section in the CLI header");
        vinfo->info.message = D.22409;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22410 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22410;
      }
      <D.22408>:
      ctx->valid = 0;
      return;
      <D.22403>:
      D.22411 = ptr + 16;
      D.22412 = mono_read32 (D.22411);
      D.22413 = D.22412 & 4294901748;
      if (D.22413 != 0) goto <D.22414>; else goto <D.22415>;
      <D.22414>:
      D.22361 = ctx->report_error;
      if (D.22361 != 0) goto <D.22416>; else goto <D.22417>;
      <D.22416>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22418 = monoeg_g_strdup_printf ("Invalid CLI header flags");
        vinfo->info.message = D.22418;
        vinfo->exception_type = 3;
        D.22365 = ctx->errors;
        D.22419 = monoeg_g_slist_prepend (D.22365, vinfo);
        ctx->errors = D.22419;
      }
      <D.22417>:
      ctx->valid = 0;
      return;
      <D.22415>:
      ptr = ptr + 24;
      i = 0;
      goto <D.20105>;
      <D.20104>:
      {
        guint32 rva;
        guint32 size;

        rva = mono_read32 (ptr);
        D.22420 = ptr + 4;
        size = mono_read32 (D.22420);
        if (rva != 0) goto <D.22421>; else goto <D.22422>;
        <D.22421>:
        D.22423 = bounds_check_virtual_address (ctx, rva, size);
        if (D.22423 == 0) goto <D.22424>; else goto <D.22425>;
        <D.22424>:
        D.22361 = ctx->report_error;
        if (D.22361 != 0) goto <D.22426>; else goto <D.22427>;
        <D.22426>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22428 = monoeg_g_strdup_printf ("Invalid cli section %i rva/size pair %x/%x", i, rva, size);
          vinfo->info.message = D.22428;
          vinfo->exception_type = 3;
          D.22365 = ctx->errors;
          D.22429 = monoeg_g_slist_prepend (D.22365, vinfo);
          ctx->errors = D.22429;
        }
        <D.22427>:
        ctx->valid = 0;
        return;
        <D.22425>:
        <D.22422>:
        ptr = ptr + 8;
        D.22430 = rva != 0;
        D.22431 = i > 1;
        D.22432 = D.22430 & D.22431;
        if (D.22432 != 0) goto <D.22433>; else goto <D.22434>;
        <D.22433>:
        D.22361 = ctx->report_error;
        if (D.22361 != 0) goto <D.22435>; else goto <D.22436>;
        <D.22435>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22437 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t support cli header section %d", i);
          vinfo->info.message = D.22437;
          vinfo->exception_type = 3;
          D.22365 = ctx->errors;
          D.22438 = monoeg_g_slist_prepend (D.22365, vinfo);
          ctx->errors = D.22438;
        }
        <D.22436>:
        ctx->valid = 0;
        return;
        <D.22434>:
      }
      i = i + 1;
      <D.20105>:
      if (i <= 5) goto <D.20104>; else goto <D.20106>;
      <D.20106>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


get_data_dir (struct VerifyContext * ctx, int idx)
{
  struct MonoImage * D.22443;
  unsigned int idx.8;
  unsigned int D.22445;
  unsigned int D.22446;
  unsigned int D.22447;
  unsigned int D.22448;
  unsigned int D.22449;
  struct MonoCLIImageInfo * iinfo;
  struct MonoPEDirEntry * entry;
  struct DataDirectory res;

  try
    {
      D.22443 = ctx->image;
      iinfo = D.22443->image_info;
      entry = &iinfo->cli_header.datadir.pe_export_table;
      idx.8 = (unsigned int) idx;
      D.22445 = idx.8 * 8;
      entry = entry + D.22445;
      D.22446 = entry->rva;
      res.rva = D.22446;
      D.22447 = entry->size;
      res.size = D.22447;
      D.22448 = res.rva;
      D.22449 = translate_rva (ctx, D.22448);
      res.translated_offset = D.22449;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


verify_metadata_header (struct VerifyContext * ctx)
{
  const char * D.22452;
  _Bool D.22453;
  long int D.22454;
  long int D.22455;
  unsigned int D.22458;
  unsigned int D.22459;
  unsigned int D.22460;
  unsigned int D.22463;
  int D.22466;
  gchar * D.22469;
  struct GSList * D.22470;
  struct GSList * D.22471;
  unsigned int D.22472;
  unsigned int D.22477;
  gchar * D.22478;
  struct GSList * D.22479;
  const unsigned char * D.22480;
  unsigned int D.22481;
  unsigned int D.22482;
  unsigned int D.22483;
  int D.22484;
  unsigned int D.22489;
  unsigned int D.22490;
  unsigned int D.22491;
  gchar * D.22492;
  struct GSList * D.22493;
  const unsigned char * D.22494;
  short unsigned int D.22495;
  gchar * D.22500;
  struct GSList * D.22501;
  int D.22502;
  unsigned int D.22507;
  gchar * D.22508;
  struct GSList * D.22509;
  unsigned int D.22510;
  const unsigned char * D.22511;
  int D.22512;
  gchar * D.22517;
  struct GSList * D.22518;
  unsigned int offset.9;
  int D.22520;
  gchar * D.22525;
  struct GSList * D.22526;
  sizetype string_size.10;
  const char * D.22528;
  char D.22529;
  gchar * D.22535;
  struct GSList * D.22536;
  int D.20141;
  int iftmp.11;
  int D.20137;
  const char[9] * D.22540;
  unsigned char D.22541;
  int D.22542;
  unsigned char D.22543;
  int D.22544;
  _Bool D.22545;
  _Bool D.22546;
  _Bool D.22547;
  const unsigned char * D.22550;
  unsigned char D.22551;
  int D.22552;
  const unsigned char * D.22553;
  unsigned char D.22554;
  int D.22555;
  _Bool D.22556;
  _Bool D.22557;
  const unsigned char * D.22560;
  unsigned char D.22561;
  int D.22562;
  const unsigned char * D.22563;
  unsigned char D.22564;
  int D.22565;
  _Bool D.22566;
  _Bool D.22567;
  const unsigned char * D.22570;
  unsigned char D.22571;
  int D.22572;
  const unsigned char * D.22573;
  unsigned char D.22574;
  int D.22575;
  int D.20150;
  int iftmp.12;
  int D.20146;
  const char[4] * D.22583;
  unsigned char D.22584;
  int D.22585;
  unsigned char D.22586;
  int D.22587;
  _Bool D.22588;
  _Bool D.22589;
  _Bool D.22590;
  const unsigned char * D.22593;
  unsigned char D.22594;
  int D.22595;
  const unsigned char * D.22596;
  unsigned char D.22597;
  int D.22598;
  _Bool D.22599;
  _Bool D.22600;
  const unsigned char * D.22603;
  unsigned char D.22604;
  int D.22605;
  const unsigned char * D.22606;
  unsigned char D.22607;
  int D.22608;
  _Bool D.22609;
  _Bool D.22610;
  const unsigned char * D.22613;
  unsigned char D.22614;
  int D.22615;
  const unsigned char * D.22616;
  unsigned char D.22617;
  int D.22618;
  int D.20159;
  int iftmp.13;
  int D.20155;
  const char[6] * D.22626;
  unsigned char D.22627;
  int D.22628;
  unsigned char D.22629;
  int D.22630;
  _Bool D.22631;
  _Bool D.22632;
  _Bool D.22633;
  const unsigned char * D.22636;
  unsigned char D.22637;
  int D.22638;
  const unsigned char * D.22639;
  unsigned char D.22640;
  int D.22641;
  _Bool D.22642;
  _Bool D.22643;
  const unsigned char * D.22646;
  unsigned char D.22647;
  int D.22648;
  const unsigned char * D.22649;
  unsigned char D.22650;
  int D.22651;
  _Bool D.22652;
  _Bool D.22653;
  const unsigned char * D.22656;
  unsigned char D.22657;
  int D.22658;
  const unsigned char * D.22659;
  unsigned char D.22660;
  int D.22661;
  int D.20168;
  int iftmp.14;
  int D.20164;
  const char[6] * D.22669;
  unsigned char D.22670;
  int D.22671;
  unsigned char D.22672;
  int D.22673;
  _Bool D.22674;
  _Bool D.22675;
  _Bool D.22676;
  const unsigned char * D.22679;
  unsigned char D.22680;
  int D.22681;
  const unsigned char * D.22682;
  unsigned char D.22683;
  int D.22684;
  _Bool D.22685;
  _Bool D.22686;
  const unsigned char * D.22689;
  unsigned char D.22690;
  int D.22691;
  const unsigned char * D.22692;
  unsigned char D.22693;
  int D.22694;
  _Bool D.22695;
  _Bool D.22696;
  const unsigned char * D.22699;
  unsigned char D.22700;
  int D.22701;
  const unsigned char * D.22702;
  unsigned char D.22703;
  int D.22704;
  int D.20177;
  int iftmp.15;
  int D.20173;
  const char[3] * D.22712;
  unsigned char D.22713;
  int D.22714;
  unsigned char D.22715;
  int D.22716;
  _Bool D.22717;
  _Bool D.22718;
  _Bool D.22719;
  const unsigned char * D.22722;
  unsigned char D.22723;
  int D.22724;
  const unsigned char * D.22725;
  unsigned char D.22726;
  int D.22727;
  _Bool D.22728;
  _Bool D.22729;
  const unsigned char * D.22732;
  unsigned char D.22733;
  int D.22734;
  const unsigned char * D.22735;
  unsigned char D.22736;
  int D.22737;
  _Bool D.22738;
  _Bool D.22739;
  const unsigned char * D.22742;
  unsigned char D.22743;
  int D.22744;
  const unsigned char * D.22745;
  unsigned char D.22746;
  int D.22747;
  int D.22752;
  gchar * D.22755;
  struct GSList * D.22756;
  unsigned int D.22757;
  gchar * D.22762;
  struct GSList * D.22763;
  unsigned int i.16;
  unsigned int D.22765;
  gchar * D.22770;
  struct GSList * D.22771;
  unsigned int D.22772;
  gchar * D.22777;
  struct GSList * D.22778;
  int i;
  struct DataDirectory it;
  guint32 offset;
  guint32 section_count;
  const char * ptr;

  try
    {
      it = get_data_dir (ctx, 14); [return slot optimization]
      offset = it.translated_offset;
      D.22452 = ctx->data;
      ptr = D.22452 + offset;
      D.22453 = offset == 4294967295;
      D.22454 = (long int) D.22453;
      D.22455 = __builtin_expect (D.22454, 0);
      if (D.22455 != 0) goto <D.22456>; else goto <D.22457>;
      <D.22456>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 769, "offset != INVALID_OFFSET");
      <D.22457>:
      ptr = ptr + 8;
      D.22458 = mono_read32 (ptr);
      it.rva = D.22458;
      ptr = ptr + 4;
      D.22459 = mono_read32 (ptr);
      it.size = D.22459;
      D.22460 = it.rva;
      offset = translate_rva (ctx, D.22460);
      it.translated_offset = offset;
      D.22452 = ctx->data;
      ptr = D.22452 + offset;
      D.22453 = offset == 4294967295;
      D.22454 = (long int) D.22453;
      D.22455 = __builtin_expect (D.22454, 0);
      if (D.22455 != 0) goto <D.22461>; else goto <D.22462>;
      <D.22461>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 779, "offset != INVALID_OFFSET");
      <D.22462>:
      D.22463 = it.size;
      if (D.22463 <= 19) goto <D.22464>; else goto <D.22465>;
      <D.22464>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22467>; else goto <D.22468>;
      <D.22467>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22463 = it.size;
        D.22469 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least 20 bytes required for initial decoding)", D.22463);
        vinfo->info.message = D.22469;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22471 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22471;
      }
      <D.22468>:
      ctx->valid = 0;
      return;
      <D.22465>:
      D.22472 = mono_read32 (ptr);
      if (D.22472 != 1112167234) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22475>; else goto <D.22476>;
      <D.22475>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22477 = mono_read32 (ptr);
        D.22478 = monoeg_g_strdup_printf ("Invalid metadata signature, expected 0x424A5342 but got %08x", D.22477);
        vinfo->info.message = D.22478;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22479 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22479;
      }
      <D.22476>:
      ctx->valid = 0;
      return;
      <D.22474>:
      D.22480 = ptr + 12;
      D.22481 = mono_read32 (D.22480);
      D.22482 = D.22481 + offset;
      D.22483 = D.22482 + 16;
      offset = pad4 (D.22483);
      D.22484 = bounds_check_datadir (&it, offset, 4);
      if (D.22484 == 0) goto <D.22485>; else goto <D.22486>;
      <D.22485>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22487>; else goto <D.22488>;
      <D.22487>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22463 = it.size;
        D.22489 = it.translated_offset;
        D.22490 = offset - D.22489;
        D.22491 = D.22490 + 4;
        D.22492 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least %d bytes required for flags decoding)", D.22463, D.22491);
        vinfo->info.message = D.22492;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22493 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22493;
      }
      <D.22488>:
      ctx->valid = 0;
      return;
      <D.22486>:
      D.22452 = ctx->data;
      ptr = D.22452 + offset;
      D.22494 = ptr + 2;
      D.22495 = mono_read16 (D.22494);
      section_count = (guint32) D.22495;
      if (section_count <= 1) goto <D.22496>; else goto <D.22497>;
      <D.22496>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22498>; else goto <D.22499>;
      <D.22498>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22500 = monoeg_g_strdup_printf ("Metadata root section must have at least 2 streams (#~ and #GUID)");
        vinfo->info.message = D.22500;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22501 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22501;
      }
      <D.22499>:
      ctx->valid = 0;
      return;
      <D.22497>:
      ptr = ptr + 4;
      offset = offset + 4;
      i = 0;
      goto <D.20182>;
      <D.20181>:
      {
        guint32 stream_off;
        guint32 stream_size;
        int string_size;
        int stream_idx;

        D.22502 = bounds_check_datadir (&it, offset, 8);
        if (D.22502 == 0) goto <D.22503>; else goto <D.22504>;
        <D.22503>:
        D.22466 = ctx->report_error;
        if (D.22466 != 0) goto <D.22505>; else goto <D.22506>;
        <D.22505>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22489 = it.translated_offset;
          D.22490 = offset - D.22489;
          D.22507 = D.22490 + 9;
          D.22508 = monoeg_g_strdup_printf ("Metadata root section is too small for initial decode of stream header %d, missing %d bytes", i, D.22507);
          vinfo->info.message = D.22508;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22509 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22509;
        }
        <D.22506>:
        ctx->valid = 0;
        return;
        <D.22504>:
        D.22489 = it.translated_offset;
        D.22510 = mono_read32 (ptr);
        stream_off = D.22489 + D.22510;
        D.22511 = ptr + 4;
        stream_size = mono_read32 (D.22511);
        D.22512 = bounds_check_datadir (&it, stream_off, stream_size);
        if (D.22512 == 0) goto <D.22513>; else goto <D.22514>;
        <D.22513>:
        D.22466 = ctx->report_error;
        if (D.22466 != 0) goto <D.22515>; else goto <D.22516>;
        <D.22515>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22517 = monoeg_g_strdup_printf ("Invalid stream header %d offset/size pair %x/%x", 0, stream_off, stream_size);
          vinfo->info.message = D.22517;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22518 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22518;
        }
        <D.22516>:
        ctx->valid = 0;
        return;
        <D.22514>:
        ptr = ptr + 8;
        offset = offset + 8;
        string_size = 0;
        goto <D.20131>;
        <D.20130>:
        offset.9 = offset;
        offset = offset.9 + 1;
        D.22520 = bounds_check_datadir (&it, offset.9, 1);
        if (D.22520 == 0) goto <D.22521>; else goto <D.22522>;
        <D.22521>:
        D.22466 = ctx->report_error;
        if (D.22466 != 0) goto <D.22523>; else goto <D.22524>;
        <D.22523>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22525 = monoeg_g_strdup_printf ("Metadata root section is too small to decode stream header %d name", i);
          vinfo->info.message = D.22525;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22526 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22526;
        }
        <D.22524>:
        ctx->valid = 0;
        return;
        <D.22522>:
        string_size.10 = (sizetype) string_size;
        D.22528 = ptr + string_size.10;
        D.22529 = *D.22528;
        if (D.22529 == 0) goto <D.20129>; else goto <D.22530>;
        <D.22530>:
        string_size = string_size + 1;
        <D.20131>:
        if (string_size <= 31) goto <D.20130>; else goto <D.20129>;
        <D.20129>:
        string_size.10 = (sizetype) string_size;
        D.22528 = ptr + string_size.10;
        D.22529 = *D.22528;
        if (D.22529 != 0) goto <D.22531>; else goto <D.22532>;
        <D.22531>:
        D.22466 = ctx->report_error;
        if (D.22466 != 0) goto <D.22533>; else goto <D.22534>;
        <D.22533>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22535 = monoeg_g_strdup_printf ("Metadata stream header %d name larger than 32 bytes", i);
          vinfo->info.message = D.22535;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22536 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22536;
        }
        <D.22534>:
        ctx->valid = 0;
        return;
        <D.22532>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s1_len = 8;
          if (__s1_len <= 3) goto <D.22538>; else goto <D.22539>;
          <D.22538>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = ptr;
            D.22540 = "#Strings";
            D.22541 = MEM[(const unsigned char *)D.22540];
            D.22542 = (int) D.22541;
            D.22543 = *__s2;
            D.22544 = (int) D.22543;
            __result = D.22542 - D.22544;
            {
              D.22545 = __s1_len != 0;
              D.22546 = __result == 0;
              D.22547 = D.22545 & D.22546;
              if (D.22547 != 0) goto <D.22548>; else goto <D.22549>;
              <D.22548>:
              D.22550 = &MEM[(void *)"#Strings" + 1B];
              D.22551 = *D.22550;
              D.22552 = (int) D.22551;
              D.22553 = __s2 + 1;
              D.22554 = *D.22553;
              D.22555 = (int) D.22554;
              __result = D.22552 - D.22555;
              D.22556 = __s1_len > 1;
              D.22546 = __result == 0;
              D.22557 = D.22556 & D.22546;
              if (D.22557 != 0) goto <D.22558>; else goto <D.22559>;
              <D.22558>:
              D.22560 = &MEM[(void *)"#Strings" + 2B];
              D.22561 = *D.22560;
              D.22562 = (int) D.22561;
              D.22563 = __s2 + 2;
              D.22564 = *D.22563;
              D.22565 = (int) D.22564;
              __result = D.22562 - D.22565;
              D.22566 = __s1_len > 2;
              D.22546 = __result == 0;
              D.22567 = D.22566 & D.22546;
              if (D.22567 != 0) goto <D.22568>; else goto <D.22569>;
              <D.22568>:
              D.22570 = &MEM[(void *)"#Strings" + 3B];
              D.22571 = *D.22570;
              D.22572 = (int) D.22571;
              D.22573 = __s2 + 3;
              D.22574 = *D.22573;
              D.22575 = (int) D.22574;
              __result = D.22572 - D.22575;
              <D.22569>:
              <D.22559>:
              <D.22549>:
            }
            D.20137 = __result;
          }
          iftmp.11 = D.20137;
          goto <D.22576>;
          <D.22539>:
          iftmp.11 = __builtin_strcmp ("#Strings", ptr);
          <D.22576>:
          D.20141 = iftmp.11;
        }
        if (D.20141 == 0) goto <D.22577>; else goto <D.22578>;
        <D.22577>:
        stream_idx = 0;
        goto <D.22579>;
        <D.22578>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s1_len = 3;
          if (__s1_len <= 3) goto <D.22581>; else goto <D.22582>;
          <D.22581>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = ptr;
            D.22583 = "#US";
            D.22584 = MEM[(const unsigned char *)D.22583];
            D.22585 = (int) D.22584;
            D.22586 = *__s2;
            D.22587 = (int) D.22586;
            __result = D.22585 - D.22587;
            {
              D.22588 = __s1_len != 0;
              D.22589 = __result == 0;
              D.22590 = D.22588 & D.22589;
              if (D.22590 != 0) goto <D.22591>; else goto <D.22592>;
              <D.22591>:
              D.22593 = &MEM[(void *)"#US" + 1B];
              D.22594 = *D.22593;
              D.22595 = (int) D.22594;
              D.22596 = __s2 + 1;
              D.22597 = *D.22596;
              D.22598 = (int) D.22597;
              __result = D.22595 - D.22598;
              D.22599 = __s1_len > 1;
              D.22589 = __result == 0;
              D.22600 = D.22599 & D.22589;
              if (D.22600 != 0) goto <D.22601>; else goto <D.22602>;
              <D.22601>:
              D.22603 = &MEM[(void *)"#US" + 2B];
              D.22604 = *D.22603;
              D.22605 = (int) D.22604;
              D.22606 = __s2 + 2;
              D.22607 = *D.22606;
              D.22608 = (int) D.22607;
              __result = D.22605 - D.22608;
              D.22609 = __s1_len > 2;
              D.22589 = __result == 0;
              D.22610 = D.22609 & D.22589;
              if (D.22610 != 0) goto <D.22611>; else goto <D.22612>;
              <D.22611>:
              D.22613 = &MEM[(void *)"#US" + 3B];
              D.22614 = *D.22613;
              D.22615 = (int) D.22614;
              D.22616 = __s2 + 3;
              D.22617 = *D.22616;
              D.22618 = (int) D.22617;
              __result = D.22615 - D.22618;
              <D.22612>:
              <D.22602>:
              <D.22592>:
            }
            D.20146 = __result;
          }
          iftmp.12 = D.20146;
          goto <D.22619>;
          <D.22582>:
          iftmp.12 = __builtin_strcmp ("#US", ptr);
          <D.22619>:
          D.20150 = iftmp.12;
        }
        if (D.20150 == 0) goto <D.22620>; else goto <D.22621>;
        <D.22620>:
        stream_idx = 1;
        goto <D.22622>;
        <D.22621>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s1_len = 5;
          if (__s1_len <= 3) goto <D.22624>; else goto <D.22625>;
          <D.22624>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = ptr;
            D.22626 = "#Blob";
            D.22627 = MEM[(const unsigned char *)D.22626];
            D.22628 = (int) D.22627;
            D.22629 = *__s2;
            D.22630 = (int) D.22629;
            __result = D.22628 - D.22630;
            {
              D.22631 = __s1_len != 0;
              D.22632 = __result == 0;
              D.22633 = D.22631 & D.22632;
              if (D.22633 != 0) goto <D.22634>; else goto <D.22635>;
              <D.22634>:
              D.22636 = &MEM[(void *)"#Blob" + 1B];
              D.22637 = *D.22636;
              D.22638 = (int) D.22637;
              D.22639 = __s2 + 1;
              D.22640 = *D.22639;
              D.22641 = (int) D.22640;
              __result = D.22638 - D.22641;
              D.22642 = __s1_len > 1;
              D.22632 = __result == 0;
              D.22643 = D.22642 & D.22632;
              if (D.22643 != 0) goto <D.22644>; else goto <D.22645>;
              <D.22644>:
              D.22646 = &MEM[(void *)"#Blob" + 2B];
              D.22647 = *D.22646;
              D.22648 = (int) D.22647;
              D.22649 = __s2 + 2;
              D.22650 = *D.22649;
              D.22651 = (int) D.22650;
              __result = D.22648 - D.22651;
              D.22652 = __s1_len > 2;
              D.22632 = __result == 0;
              D.22653 = D.22652 & D.22632;
              if (D.22653 != 0) goto <D.22654>; else goto <D.22655>;
              <D.22654>:
              D.22656 = &MEM[(void *)"#Blob" + 3B];
              D.22657 = *D.22656;
              D.22658 = (int) D.22657;
              D.22659 = __s2 + 3;
              D.22660 = *D.22659;
              D.22661 = (int) D.22660;
              __result = D.22658 - D.22661;
              <D.22655>:
              <D.22645>:
              <D.22635>:
            }
            D.20155 = __result;
          }
          iftmp.13 = D.20155;
          goto <D.22662>;
          <D.22625>:
          iftmp.13 = __builtin_strcmp ("#Blob", ptr);
          <D.22662>:
          D.20159 = iftmp.13;
        }
        if (D.20159 == 0) goto <D.22663>; else goto <D.22664>;
        <D.22663>:
        stream_idx = 2;
        goto <D.22665>;
        <D.22664>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s1_len = 5;
          if (__s1_len <= 3) goto <D.22667>; else goto <D.22668>;
          <D.22667>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = ptr;
            D.22669 = "#GUID";
            D.22670 = MEM[(const unsigned char *)D.22669];
            D.22671 = (int) D.22670;
            D.22672 = *__s2;
            D.22673 = (int) D.22672;
            __result = D.22671 - D.22673;
            {
              D.22674 = __s1_len != 0;
              D.22675 = __result == 0;
              D.22676 = D.22674 & D.22675;
              if (D.22676 != 0) goto <D.22677>; else goto <D.22678>;
              <D.22677>:
              D.22679 = &MEM[(void *)"#GUID" + 1B];
              D.22680 = *D.22679;
              D.22681 = (int) D.22680;
              D.22682 = __s2 + 1;
              D.22683 = *D.22682;
              D.22684 = (int) D.22683;
              __result = D.22681 - D.22684;
              D.22685 = __s1_len > 1;
              D.22675 = __result == 0;
              D.22686 = D.22685 & D.22675;
              if (D.22686 != 0) goto <D.22687>; else goto <D.22688>;
              <D.22687>:
              D.22689 = &MEM[(void *)"#GUID" + 2B];
              D.22690 = *D.22689;
              D.22691 = (int) D.22690;
              D.22692 = __s2 + 2;
              D.22693 = *D.22692;
              D.22694 = (int) D.22693;
              __result = D.22691 - D.22694;
              D.22695 = __s1_len > 2;
              D.22675 = __result == 0;
              D.22696 = D.22695 & D.22675;
              if (D.22696 != 0) goto <D.22697>; else goto <D.22698>;
              <D.22697>:
              D.22699 = &MEM[(void *)"#GUID" + 3B];
              D.22700 = *D.22699;
              D.22701 = (int) D.22700;
              D.22702 = __s2 + 3;
              D.22703 = *D.22702;
              D.22704 = (int) D.22703;
              __result = D.22701 - D.22704;
              <D.22698>:
              <D.22688>:
              <D.22678>:
            }
            D.20164 = __result;
          }
          iftmp.14 = D.20164;
          goto <D.22705>;
          <D.22668>:
          iftmp.14 = __builtin_strcmp ("#GUID", ptr);
          <D.22705>:
          D.20168 = iftmp.14;
        }
        if (D.20168 == 0) goto <D.22706>; else goto <D.22707>;
        <D.22706>:
        stream_idx = 3;
        goto <D.22708>;
        <D.22707>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s1_len = 2;
          if (__s1_len <= 3) goto <D.22710>; else goto <D.22711>;
          <D.22710>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = ptr;
            D.22712 = "#~";
            D.22713 = MEM[(const unsigned char *)D.22712];
            D.22714 = (int) D.22713;
            D.22715 = *__s2;
            D.22716 = (int) D.22715;
            __result = D.22714 - D.22716;
            {
              D.22717 = __s1_len != 0;
              D.22718 = __result == 0;
              D.22719 = D.22717 & D.22718;
              if (D.22719 != 0) goto <D.22720>; else goto <D.22721>;
              <D.22720>:
              D.22722 = &MEM[(void *)"#~" + 1B];
              D.22723 = *D.22722;
              D.22724 = (int) D.22723;
              D.22725 = __s2 + 1;
              D.22726 = *D.22725;
              D.22727 = (int) D.22726;
              __result = D.22724 - D.22727;
              D.22728 = __s1_len > 1;
              D.22718 = __result == 0;
              D.22729 = D.22728 & D.22718;
              if (D.22729 != 0) goto <D.22730>; else goto <D.22731>;
              <D.22730>:
              D.22732 = &MEM[(void *)"#~" + 2B];
              D.22733 = *D.22732;
              D.22734 = (int) D.22733;
              D.22735 = __s2 + 2;
              D.22736 = *D.22735;
              D.22737 = (int) D.22736;
              __result = D.22734 - D.22737;
              D.22738 = __s1_len > 2;
              D.22718 = __result == 0;
              D.22739 = D.22738 & D.22718;
              if (D.22739 != 0) goto <D.22740>; else goto <D.22741>;
              <D.22740>:
              D.22742 = &MEM[(void *)"#~" + 3B];
              D.22743 = *D.22742;
              D.22744 = (int) D.22743;
              D.22745 = __s2 + 3;
              D.22746 = *D.22745;
              D.22747 = (int) D.22746;
              __result = D.22744 - D.22747;
              <D.22741>:
              <D.22731>:
              <D.22721>:
            }
            D.20173 = __result;
          }
          iftmp.15 = D.20173;
          goto <D.22748>;
          <D.22711>:
          iftmp.15 = __builtin_strcmp ("#~", ptr);
          <D.22748>:
          D.20177 = iftmp.15;
        }
        if (D.20177 == 0) goto <D.22749>; else goto <D.22750>;
        <D.22749>:
        stream_idx = 4;
        goto <D.22751>;
        <D.22750>:
        D.22752 = ctx->report_warning;
        if (D.22752 != 0) goto <D.22753>; else goto <D.22754>;
        <D.22753>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 2;
          D.22755 = monoeg_g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr);
          vinfo->info.message = D.22755;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22756 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22756;
        }
        ctx->valid = 0;
        return;
        <D.22754>:
        offset = pad4 (offset);
        D.22452 = ctx->data;
        ptr = D.22452 + offset;
        // predicted unlikely by continue predictor.
        goto <D.20179>;
        <D.22751>:
        <D.22708>:
        <D.22665>:
        <D.22622>:
        <D.22579>:
        D.22757 = ctx->metadata_streams[stream_idx].offset;
        if (D.22757 != 0) goto <D.22758>; else goto <D.22759>;
        <D.22758>:
        D.22466 = ctx->report_error;
        if (D.22466 != 0) goto <D.22760>; else goto <D.22761>;
        <D.22760>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22762 = monoeg_g_strdup_printf ("Duplicated metadata stream header %s", ptr);
          vinfo->info.message = D.22762;
          vinfo->exception_type = 3;
          D.22470 = ctx->errors;
          D.22763 = monoeg_g_slist_prepend (D.22470, vinfo);
          ctx->errors = D.22763;
        }
        <D.22761>:
        ctx->valid = 0;
        return;
        <D.22759>:
        ctx->metadata_streams[stream_idx].offset = stream_off;
        ctx->metadata_streams[stream_idx].size = stream_size;
        offset = pad4 (offset);
        D.22452 = ctx->data;
        ptr = D.22452 + offset;
      }
      <D.20179>:
      i = i + 1;
      <D.20182>:
      i.16 = (unsigned int) i;
      if (i.16 < section_count) goto <D.20181>; else goto <D.20183>;
      <D.20183>:
      D.22765 = ctx->metadata_streams[4].size;
      if (D.22765 == 0) goto <D.22766>; else goto <D.22767>;
      <D.22766>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22768>; else goto <D.22769>;
      <D.22768>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22770 = monoeg_g_strdup_printf ("Metadata #~ stream missing");
        vinfo->info.message = D.22770;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22771 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22771;
      }
      <D.22769>:
      ctx->valid = 0;
      return;
      <D.22767>:
      D.22772 = ctx->metadata_streams[3].size;
      if (D.22772 == 0) goto <D.22773>; else goto <D.22774>;
      <D.22773>:
      D.22466 = ctx->report_error;
      if (D.22466 != 0) goto <D.22775>; else goto <D.22776>;
      <D.22775>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22777 = monoeg_g_strdup_printf ("Metadata guid stream missing");
        vinfo->info.message = D.22777;
        vinfo->exception_type = 3;
        D.22470 = ctx->errors;
        D.22778 = monoeg_g_slist_prepend (D.22470, vinfo);
        ctx->errors = D.22778;
      }
      <D.22776>:
      ctx->valid = 0;
      return;
      <D.22774>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


bounds_check_datadir (struct DataDirectory * dir, guint32 offset, guint32 size)
{
  unsigned int D.22782;
  gboolean D.22785;
  unsigned int D.22786;
  unsigned int D.22789;
  unsigned int D.22790;
  _Bool D.22791;

  D.22782 = dir->translated_offset;
  if (D.22782 > offset) goto <D.22783>; else goto <D.22784>;
  <D.22783>:
  D.22785 = 0;
  return D.22785;
  <D.22784>:
  D.22786 = dir->size;
  if (D.22786 < size) goto <D.22787>; else goto <D.22788>;
  <D.22787>:
  D.22785 = 0;
  return D.22785;
  <D.22788>:
  D.22789 = offset + size;
  D.22782 = dir->translated_offset;
  D.22786 = dir->size;
  D.22790 = D.22782 + D.22786;
  D.22791 = D.22789 <= D.22790;
  D.22785 = (gboolean) D.22791;
  return D.22785;
}


pad4 (guint32 offset)
{
  unsigned int D.22793;
  unsigned int D.22796;
  guint32 D.22797;

  D.22793 = offset & 3;
  if (D.22793 != 0) goto <D.22794>; else goto <D.22795>;
  <D.22794>:
  D.22796 = offset & 4294967292;
  offset = D.22796 + 4;
  <D.22795>:
  D.22797 = offset;
  return D.22797;
}


verify_tables_schema (struct VerifyContext * ctx)
{
  const char * D.22799;
  unsigned int D.22800;
  int D.22803;
  gchar * D.22806;
  struct GSList * D.22807;
  struct GSList * D.22808;
  const char * D.22809;
  char D.22810;
  char D.22811;
  int D.22816;
  gchar * D.22817;
  struct GSList * D.22818;
  const char * D.22819;
  char D.22820;
  int D.22825;
  gchar * D.22826;
  struct GSList * D.22827;
  const char * D.22828;
  char D.22829;
  int D.22830;
  int D.22831;
  unsigned char * D.22836;
  unsigned char D.22837;
  int D.22838;
  gchar * D.22839;
  struct GSList * D.22840;
  const unsigned char * D.22841;
  long long unsigned int D.22842;
  long long unsigned int D.22843;
  _Bool D.22848;
  _Bool D.22849;
  _Bool D.22850;
  _Bool D.22852;
  _Bool D.22853;
  _Bool D.22854;
  gchar * D.22858;
  struct GSList * D.22859;
  unsigned int i.17;
  unsigned int D.22861;
  _Bool D.22862;
  _Bool D.22863;
  _Bool D.22864;
  gchar * D.22869;
  struct GSList * D.22870;
  unsigned int D.22871;
  unsigned int D.22872;
  gchar * D.22877;
  struct GSList * D.22878;
  gchar * D.22885;
  struct GSList * D.22886;
  struct OffsetAndSize tables_area;
  unsigned int offset;
  const char * ptr;
  guint64 valid_tables;
  guint32 count;
  int i;

  try
    {
      tables_area = ctx->metadata_streams[4];
      offset = tables_area.offset;
      D.22799 = ctx->data;
      ptr = D.22799 + offset;
      D.22800 = tables_area.size;
      if (D.22800 <= 23) goto <D.22801>; else goto <D.22802>;
      <D.22801>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22804>; else goto <D.22805>;
      <D.22804>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22800 = tables_area.size;
        D.22806 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for initial decoding (requires 24 bytes)", D.22800);
        vinfo->info.message = D.22806;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22808 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22808;
      }
      <D.22805>:
      ctx->valid = 0;
      return;
      <D.22802>:
      D.22809 = ptr + 4;
      D.22810 = *D.22809;
      D.22811 = D.22810 + 255;
      if (D.22811 > 1) goto <D.22812>; else goto <D.22813>;
      <D.22812>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22814>; else goto <D.22815>;
      <D.22814>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22809 = ptr + 4;
        D.22810 = *D.22809;
        D.22816 = (int) D.22810;
        D.22817 = monoeg_g_strdup_printf ("Invalid table schemata major version %d, expected 2", D.22816);
        vinfo->info.message = D.22817;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22818 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22818;
      }
      <D.22815>:
      ctx->valid = 0;
      return;
      <D.22813>:
      D.22819 = ptr + 5;
      D.22820 = *D.22819;
      if (D.22820 != 0) goto <D.22821>; else goto <D.22822>;
      <D.22821>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22823>; else goto <D.22824>;
      <D.22823>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22819 = ptr + 5;
        D.22820 = *D.22819;
        D.22825 = (int) D.22820;
        D.22826 = monoeg_g_strdup_printf ("Invalid table schemata minor version %d, expected 0", D.22825);
        vinfo->info.message = D.22826;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22827 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22827;
      }
      <D.22824>:
      ctx->valid = 0;
      return;
      <D.22822>:
      D.22828 = ptr + 6;
      D.22829 = *D.22828;
      D.22830 = (int) D.22829;
      D.22831 = D.22830 & -8;
      if (D.22831 != 0) goto <D.22832>; else goto <D.22833>;
      <D.22832>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22834>; else goto <D.22835>;
      <D.22834>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22836 = ptr + 6;
        D.22837 = *D.22836;
        D.22838 = (int) D.22837;
        D.22839 = monoeg_g_strdup_printf ("Invalid table schemata heap sizes 0x%02x, only bits 0, 1 and 2 can be set", D.22838);
        vinfo->info.message = D.22839;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22840 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22840;
      }
      <D.22835>:
      ctx->valid = 0;
      return;
      <D.22833>:
      D.22841 = ptr + 8;
      valid_tables = mono_read64 (D.22841);
      count = 0;
      i = 0;
      goto <D.20203>;
      <D.20202>:
      D.22842 = valid_tables >> i;
      D.22843 = D.22842 & 1;
      if (D.22843 == 0) goto <D.22844>; else goto <D.22845>;
      <D.22844>:
      // predicted unlikely by continue predictor.
      goto <D.20199>;
      <D.22845>:
      D.22848 = i == 3;
      D.22849 = i == 5;
      D.22850 = D.22848 | D.22849;
      if (D.22850 != 0) goto <D.22846>; else goto <D.22851>;
      <D.22851>:
      D.22852 = i == 7;
      D.22853 = i == 19;
      D.22854 = D.22852 | D.22853;
      if (D.22854 != 0) goto <D.22846>; else goto <D.22855>;
      <D.22855>:
      if (i == 22) goto <D.22846>; else goto <D.22847>;
      <D.22846>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22856>; else goto <D.22857>;
      <D.22856>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22858 = monoeg_g_strdup_printf ("The metadata verifier doesn\'t support MS specific table %x", i);
        vinfo->info.message = D.22858;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22859 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22859;
      }
      <D.22857>:
      ctx->valid = 0;
      return;
      <D.22847>:
      i.17 = (unsigned int) i;
      D.22861 = i.17 + 4294967266;
      D.22862 = D.22861 <= 1;
      D.22863 = i > 44;
      D.22864 = D.22862 | D.22863;
      if (D.22864 != 0) goto <D.22865>; else goto <D.22866>;
      <D.22865>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22867>; else goto <D.22868>;
      <D.22867>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22869 = monoeg_g_strdup_printf ("Invalid table %x", i);
        vinfo->info.message = D.22869;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22870 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22870;
      }
      <D.22868>:
      ctx->valid = 0;
      return;
      <D.22866>:
      count = count + 1;
      <D.20199>:
      i = i + 1;
      <D.20203>:
      if (i <= 63) goto <D.20202>; else goto <D.20204>;
      <D.20204>:
      D.22800 = tables_area.size;
      D.22871 = count + 6;
      D.22872 = D.22871 * 4;
      if (D.22800 < D.22872) goto <D.22873>; else goto <D.22874>;
      <D.22873>:
      D.22803 = ctx->report_error;
      if (D.22803 != 0) goto <D.22875>; else goto <D.22876>;
      <D.22875>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22800 = tables_area.size;
        D.22871 = count + 6;
        D.22872 = D.22871 * 4;
        D.22877 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for decoding row counts (requires %d bytes)", D.22800, D.22872);
        vinfo->info.message = D.22877;
        vinfo->exception_type = 3;
        D.22807 = ctx->errors;
        D.22878 = monoeg_g_slist_prepend (D.22807, vinfo);
        ctx->errors = D.22878;
      }
      <D.22876>:
      ctx->valid = 0;
      return;
      <D.22874>:
      ptr = ptr + 24;
      i = 0;
      goto <D.20209>;
      <D.20208>:
      D.22842 = valid_tables >> i;
      D.22843 = D.22842 & 1;
      if (D.22843 != 0) goto <D.22879>; else goto <D.22880>;
      <D.22879>:
      {
        guint32 row_count;

        row_count = mono_read32 (ptr);
        if (row_count > 16777215) goto <D.22881>; else goto <D.22882>;
        <D.22881>:
        D.22803 = ctx->report_error;
        if (D.22803 != 0) goto <D.22883>; else goto <D.22884>;
        <D.22883>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.22885 = monoeg_g_strdup_printf ("Invalid Table %d row count: %d. Mono only supports 16777215 rows", i, row_count);
          vinfo->info.message = D.22885;
          vinfo->exception_type = 3;
          D.22807 = ctx->errors;
          D.22886 = monoeg_g_slist_prepend (D.22807, vinfo);
          ctx->errors = D.22886;
        }
        <D.22884>:
        ctx->valid = 0;
        return;
        <D.22882>:
        ptr = ptr + 4;
      }
      <D.22880>:
      i = i + 1;
      <D.20209>:
      if (i <= 63) goto <D.20208>; else goto <D.20210>;
      <D.20210>:
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


mono_verifier_verify_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.22890;
  gboolean D.22893;
  _Bool D.22894;
  int D.22895;
  struct VerifyContext ctx;

  try
    {
      D.22890 = mono_verifier_is_enabled_for_image (image);
      if (D.22890 == 0) goto <D.22891>; else goto <D.22892>;
      <D.22891>:
      D.22893 = 1;
      return D.22893;
      <D.22892>:
      D.22894 = error_list != 0B;
      D.22895 = (int) D.22894;
      init_verify_context (&ctx, image, D.22895);
      ctx.stage = 2;
      verify_tables_data (&ctx);
      D.22893 = cleanup_context (&ctx, error_list);
      return D.22893;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_tables_data (struct VerifyContext * ctx)
{
  struct MonoImage * D.22898;
  struct MonoStreamHeader * D.22899;
  unsigned char D.22900;
  unsigned int D.22901;
  <unnamed-unsigned:24> D.22902;
  unsigned int D.22903;
  unsigned int D.22904;
  int D.22909;
  gchar * D.22912;
  struct GSList * D.22913;
  struct GSList * D.22914;
  const char * D.22915;
  int D.22916;
  const char * D.22917;
  int D.22918;
  int D.22919;
  int D.22920;
  unsigned int D.22925;
  unsigned int D.22926;
  unsigned int D.22927;
  unsigned int D.22928;
  gchar * D.22929;
  struct GSList * D.22930;
  int D.22931;
  struct OffsetAndSize tables_area;
  guint32 size;
  guint32 tables_offset;
  int i;

  try
    {
      D.22898 = ctx->image;
      D.22899 = &D.22898->heap_tables;
      tables_area = get_metadata_stream (ctx, D.22899); [return slot optimization]
      size = 0;
      i = 0;
      goto <D.21675>;
      <D.21674>:
      {
        struct MonoTableInfo * table;
        guint32 tmp_size;

        D.22898 = ctx->image;
        table = &D.22898->tables[i];
        D.22900 = table->row_size;
        D.22901 = (unsigned int) D.22900;
        D.22902 = table->rows;
        D.22903 = (unsigned int) D.22902;
        D.22904 = D.22901 * D.22903;
        tmp_size = D.22904 + size;
        if (tmp_size < size) goto <D.22905>; else goto <D.22906>;
        <D.22905>:
        size = 0;
        goto <D.21673>;
        <D.22906>:
        size = tmp_size;
      }
      i = i + 1;
      <D.21675>:
      if (i <= 44) goto <D.21674>; else goto <D.21673>;
      <D.21673>:
      if (size == 0) goto <D.22907>; else goto <D.22908>;
      <D.22907>:
      D.22909 = ctx->report_error;
      if (D.22909 != 0) goto <D.22910>; else goto <D.22911>;
      <D.22910>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22912 = monoeg_g_strdup_printf ("table space is either empty or overflowed");
        vinfo->info.message = D.22912;
        vinfo->exception_type = 3;
        D.22913 = ctx->errors;
        D.22914 = monoeg_g_slist_prepend (D.22913, vinfo);
        ctx->errors = D.22914;
      }
      <D.22911>:
      ctx->valid = 0;
      return;
      <D.22908>:
      D.22898 = ctx->image;
      D.22915 = D.22898->tables_base;
      D.22916 = (int) D.22915;
      D.22917 = ctx->data;
      D.22918 = (int) D.22917;
      D.22919 = D.22916 - D.22918;
      tables_offset = (guint32) D.22919;
      D.22920 = bounds_check_offset (&tables_area, tables_offset, size);
      if (D.22920 == 0) goto <D.22921>; else goto <D.22922>;
      <D.22921>:
      D.22909 = ctx->report_error;
      if (D.22909 != 0) goto <D.22923>; else goto <D.22924>;
      <D.22923>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.22925 = tables_area.size;
        D.22926 = tables_area.offset;
        D.22927 = D.22926 - tables_offset;
        D.22928 = D.22925 + D.22927;
        D.22929 = monoeg_g_strdup_printf ("Tables data require %d bytes but the only %d are available in the #~ stream", size, D.22928);
        vinfo->info.message = D.22929;
        vinfo->exception_type = 3;
        D.22913 = ctx->errors;
        D.22930 = monoeg_g_slist_prepend (D.22913, vinfo);
        ctx->errors = D.22930;
      }
      <D.22924>:
      ctx->valid = 0;
      return;
      <D.22922>:
      verify_module_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22932>; else goto <D.22933>;
      <D.22932>:
      return;
      <D.22933>:
      verify_typedef_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22934>; else goto <D.22935>;
      <D.22934>:
      return;
      <D.22935>:
      verify_field_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22936>; else goto <D.22937>;
      <D.22936>:
      return;
      <D.22937>:
      verify_method_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22938>; else goto <D.22939>;
      <D.22938>:
      return;
      <D.22939>:
      verify_param_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22940>; else goto <D.22941>;
      <D.22940>:
      return;
      <D.22941>:
      verify_interfaceimpl_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22942>; else goto <D.22943>;
      <D.22942>:
      return;
      <D.22943>:
      verify_memberref_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22944>; else goto <D.22945>;
      <D.22944>:
      return;
      <D.22945>:
      verify_constant_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22946>; else goto <D.22947>;
      <D.22946>:
      return;
      <D.22947>:
      verify_cattr_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22948>; else goto <D.22949>;
      <D.22948>:
      return;
      <D.22949>:
      verify_field_marshal_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22950>; else goto <D.22951>;
      <D.22950>:
      return;
      <D.22951>:
      verify_decl_security_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22952>; else goto <D.22953>;
      <D.22952>:
      return;
      <D.22953>:
      verify_class_layout_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22954>; else goto <D.22955>;
      <D.22954>:
      return;
      <D.22955>:
      verify_field_layout_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22956>; else goto <D.22957>;
      <D.22956>:
      return;
      <D.22957>:
      verify_standalonesig_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22958>; else goto <D.22959>;
      <D.22958>:
      return;
      <D.22959>:
      verify_eventmap_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22960>; else goto <D.22961>;
      <D.22960>:
      return;
      <D.22961>:
      verify_event_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22962>; else goto <D.22963>;
      <D.22962>:
      return;
      <D.22963>:
      verify_propertymap_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      return;
      <D.22965>:
      verify_property_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22966>; else goto <D.22967>;
      <D.22966>:
      return;
      <D.22967>:
      verify_methodimpl_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22968>; else goto <D.22969>;
      <D.22968>:
      return;
      <D.22969>:
      verify_moduleref_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22970>; else goto <D.22971>;
      <D.22970>:
      return;
      <D.22971>:
      verify_typespec_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22972>; else goto <D.22973>;
      <D.22972>:
      return;
      <D.22973>:
      verify_implmap_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22974>; else goto <D.22975>;
      <D.22974>:
      return;
      <D.22975>:
      verify_fieldrva_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22976>; else goto <D.22977>;
      <D.22976>:
      return;
      <D.22977>:
      verify_assembly_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22978>; else goto <D.22979>;
      <D.22978>:
      return;
      <D.22979>:
      verify_assemblyref_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22980>; else goto <D.22981>;
      <D.22980>:
      return;
      <D.22981>:
      verify_file_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22982>; else goto <D.22983>;
      <D.22982>:
      return;
      <D.22983>:
      verify_exportedtype_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22984>; else goto <D.22985>;
      <D.22984>:
      return;
      <D.22985>:
      verify_manifest_resource_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22986>; else goto <D.22987>;
      <D.22986>:
      return;
      <D.22987>:
      verify_nested_class_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22988>; else goto <D.22989>;
      <D.22988>:
      return;
      <D.22989>:
      verify_generic_param_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      return;
      <D.22991>:
      verify_method_spec_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22992>; else goto <D.22993>;
      <D.22992>:
      return;
      <D.22993>:
      verify_generic_param_constraint_table (ctx);
      D.22931 = ctx->valid;
      if (D.22931 == 0) goto <D.22994>; else goto <D.22995>;
      <D.22994>:
      return;
      <D.22995>:
      verify_tables_data_global_constraints (ctx);
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


get_metadata_stream (struct VerifyContext * ctx, struct MonoStreamHeader * header)
{
  const char * D.23000;
  int D.23001;
  const char * D.23002;
  int D.23003;
  int D.23004;
  unsigned int D.23005;
  unsigned int D.23006;
  struct OffsetAndSize res;

  try
    {
      D.23000 = header->data;
      D.23001 = (int) D.23000;
      D.23002 = ctx->data;
      D.23003 = (int) D.23002;
      D.23004 = D.23001 - D.23003;
      D.23005 = (unsigned int) D.23004;
      res.offset = D.23005;
      D.23006 = header->size;
      res.size = D.23006;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


bounds_check_offset (struct OffsetAndSize * off, guint32 offset, guint32 size)
{
  unsigned int D.23009;
  gboolean D.23012;
  unsigned int D.23013;
  unsigned int D.23016;
  unsigned int D.23017;
  _Bool D.23018;

  D.23009 = off->offset;
  if (D.23009 > offset) goto <D.23010>; else goto <D.23011>;
  <D.23010>:
  D.23012 = 0;
  return D.23012;
  <D.23011>:
  D.23013 = off->size;
  if (D.23013 < size) goto <D.23014>; else goto <D.23015>;
  <D.23014>:
  D.23012 = 0;
  return D.23012;
  <D.23015>:
  D.23016 = offset + size;
  D.23009 = off->offset;
  D.23013 = off->size;
  D.23017 = D.23009 + D.23013;
  D.23018 = D.23016 <= D.23017;
  D.23012 = (gboolean) D.23018;
  return D.23012;
}


verify_module_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23020;
  unsigned int D.23021;
  unsigned int D.23022;
  int D.23025;
  <unnamed-unsigned:24> D.23028;
  int D.23029;
  gchar * D.23030;
  struct GSList * D.23031;
  struct GSList * D.23032;
  unsigned int D.23033;
  int D.23034;
  gchar * D.23039;
  struct GSList * D.23040;
  unsigned int D.23041;
  int D.23042;
  gchar * D.23047;
  struct GSList * D.23048;
  unsigned int D.23049;
  gchar * D.23054;
  struct GSList * D.23055;
  unsigned int D.23056;
  gchar * D.23061;
  struct GSList * D.23062;
  struct MonoTableInfo * table;
  guint32 data[5];

  try
    {
      D.23020 = ctx->image;
      table = &D.23020->tables[0];
      D.23021 = BIT_FIELD_REF <*table, 32, 32>;
      D.23022 = D.23021 & 16777215;
      if (D.23022 != 1) goto <D.23023>; else goto <D.23024>;
      <D.23023>:
      D.23025 = ctx->report_error;
      if (D.23025 != 0) goto <D.23026>; else goto <D.23027>;
      <D.23026>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23028 = table->rows;
        D.23029 = (int) D.23028;
        D.23030 = monoeg_g_strdup_printf ("Module table must have exactly one row, but have %d", D.23029);
        vinfo->info.message = D.23030;
        vinfo->exception_type = 3;
        D.23031 = ctx->errors;
        D.23032 = monoeg_g_slist_prepend (D.23031, vinfo);
        ctx->errors = D.23032;
      }
      <D.23027>:
      ctx->valid = 0;
      return;
      <D.23024>:
      mono_metadata_decode_row (table, 0, &data, 5);
      D.23033 = data[1];
      D.23034 = is_valid_non_empty_string (ctx, D.23033);
      if (D.23034 == 0) goto <D.23035>; else goto <D.23036>;
      <D.23035>:
      D.23025 = ctx->report_error;
      if (D.23025 != 0) goto <D.23037>; else goto <D.23038>;
      <D.23037>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23033 = data[1];
        D.23039 = monoeg_g_strdup_printf ("Module has an invalid name, string index 0x%08x", D.23033);
        vinfo->info.message = D.23039;
        vinfo->exception_type = 3;
        D.23031 = ctx->errors;
        D.23040 = monoeg_g_slist_prepend (D.23031, vinfo);
        ctx->errors = D.23040;
      }
      <D.23038>:
      ctx->valid = 0;
      return;
      <D.23036>:
      D.23041 = data[2];
      D.23042 = is_valid_guid (ctx, D.23041);
      if (D.23042 == 0) goto <D.23043>; else goto <D.23044>;
      <D.23043>:
      D.23025 = ctx->report_error;
      if (D.23025 != 0) goto <D.23045>; else goto <D.23046>;
      <D.23045>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23041 = data[2];
        D.23047 = monoeg_g_strdup_printf ("Module has an invalid Mvid, guid index %x", D.23041);
        vinfo->info.message = D.23047;
        vinfo->exception_type = 3;
        D.23031 = ctx->errors;
        D.23048 = monoeg_g_slist_prepend (D.23031, vinfo);
        ctx->errors = D.23048;
      }
      <D.23046>:
      ctx->valid = 0;
      return;
      <D.23044>:
      D.23049 = data[3];
      if (D.23049 != 0) goto <D.23050>; else goto <D.23051>;
      <D.23050>:
      D.23025 = ctx->report_error;
      if (D.23025 != 0) goto <D.23052>; else goto <D.23053>;
      <D.23052>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23049 = data[3];
        D.23054 = monoeg_g_strdup_printf ("Module has a non zero Enc field %x", D.23049);
        vinfo->info.message = D.23054;
        vinfo->exception_type = 3;
        D.23031 = ctx->errors;
        D.23055 = monoeg_g_slist_prepend (D.23031, vinfo);
        ctx->errors = D.23055;
      }
      <D.23053>:
      ctx->valid = 0;
      return;
      <D.23051>:
      D.23056 = data[4];
      if (D.23056 != 0) goto <D.23057>; else goto <D.23058>;
      <D.23057>:
      D.23025 = ctx->report_error;
      if (D.23025 != 0) goto <D.23059>; else goto <D.23060>;
      <D.23059>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23056 = data[4];
        D.23061 = monoeg_g_strdup_printf ("Module has a non zero EncBase field %x", D.23056);
        vinfo->info.message = D.23061;
        vinfo->exception_type = 3;
        D.23031 = ctx->errors;
        D.23062 = monoeg_g_slist_prepend (D.23031, vinfo);
        ctx->errors = D.23062;
      }
      <D.23060>:
      ctx->valid = 0;
      return;
      <D.23058>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_non_empty_string (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.23066;

  D.23066 = is_valid_string_full (ctx, offset, 0);
  return D.23066;
}


is_valid_string_full (struct VerifyContext * ctx, guint32 offset, gboolean allow_empty)
{
  gboolean D.23068;
  struct MonoImage * D.23069;

  D.23069 = ctx->image;
  D.23068 = is_valid_string_full_with_image (D.23069, offset, allow_empty);
  return D.23068;
}


is_valid_string_full_with_image (struct MonoImage * image, guint32 offset, gboolean allow_empty)
{
  const char * D.23071;
  int D.23072;
  char * D.23073;
  int D.23074;
  int D.23075;
  gboolean D.23078;
  unsigned int D.23079;
  unsigned int data.18;
  const gchar * D.23083;
  unsigned int D.23084;
  long int D.23085;
  int D.23086;
  int iftmp.19;
  long int length.20;
  guint32 heap_offset;
  guint32 heap_size;
  glong length;
  const char * data;

  try
    {
      D.23071 = image->heap_strings.data;
      D.23072 = (int) D.23071;
      D.23073 = image->raw_data;
      D.23074 = (int) D.23073;
      D.23075 = D.23072 - D.23074;
      heap_offset = (guint32) D.23075;
      heap_size = image->heap_strings.size;
      D.23073 = image->raw_data;
      data = D.23073 + heap_offset;
      if (offset >= heap_size) goto <D.23076>; else goto <D.23077>;
      <D.23076>:
      D.23078 = 0;
      return D.23078;
      <D.23077>:
      D.23079 = ~offset;
      data.18 = (unsigned int) data;
      if (D.23079 < data.18) goto <D.23081>; else goto <D.23082>;
      <D.23081>:
      D.23078 = 0;
      return D.23078;
      <D.23082>:
      D.23083 = data + offset;
      D.23084 = heap_size - offset;
      D.23085 = (long int) D.23084;
      D.23086 = mono_utf8_validate_and_len_with_bounds (D.23083, D.23085, &length, 0B);
      if (D.23086 == 0) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      D.23078 = 0;
      return D.23078;
      <D.23088>:
      if (allow_empty != 0) goto <D.23090>; else goto <D.23093>;
      <D.23093>:
      length.20 = length;
      if (length.20 > 0) goto <D.23090>; else goto <D.23091>;
      <D.23090>:
      iftmp.19 = 1;
      goto <D.23092>;
      <D.23091>:
      iftmp.19 = 0;
      <D.23092>:
      D.23078 = iftmp.19;
      return D.23078;
    }
  finally
    {
      length = {CLOBBER};
    }
}


is_valid_guid (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.23097;
  struct MonoStreamHeader * D.23098;
  gboolean D.23099;
  int iftmp.21;
  unsigned int D.23103;
  unsigned int D.23105;
  struct OffsetAndSize guids;

  try
    {
      D.23097 = ctx->image;
      D.23098 = &D.23097->heap_guid;
      guids = get_metadata_stream (ctx, D.23098); [return slot optimization]
      D.23103 = guids.size;
      if (D.23103 > 7) goto <D.23104>; else goto <D.23101>;
      <D.23104>:
      D.23103 = guids.size;
      D.23105 = D.23103 + 4294967288;
      if (D.23105 >= offset) goto <D.23106>; else goto <D.23101>;
      <D.23106>:
      iftmp.21 = 1;
      goto <D.23102>;
      <D.23101>:
      iftmp.21 = 0;
      <D.23102>:
      D.23099 = iftmp.21;
      return D.23099;
    }
  finally
    {
      guids = {CLOBBER};
    }
}


verify_typedef_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23109;
  unsigned int D.23110;
  unsigned int D.23111;
  int D.23114;
  gchar * D.23117;
  struct GSList * D.23118;
  struct GSList * D.23119;
  unsigned int D.23120;
  unsigned int D.23121;
  gchar * D.23126;
  struct GSList * D.23127;
  unsigned int D.23128;
  gchar * D.23133;
  struct GSList * D.23134;
  unsigned int D.23135;
  gchar * D.23140;
  struct GSList * D.23141;
  unsigned int D.23142;
  gchar * D.23147;
  struct GSList * D.23148;
  unsigned int D.23149;
  unsigned int D.23150;
  gchar * D.23155;
  struct GSList * D.23156;
  unsigned int D.23159;
  int D.23161;
  gchar * D.23164;
  struct GSList * D.23165;
  unsigned int D.23166;
  int D.23169;
  gchar * D.23174;
  struct GSList * D.23175;
  unsigned int D.23176;
  int D.23179;
  gchar * D.23184;
  struct GSList * D.23185;
  unsigned int D.23188;
  gchar * D.23193;
  struct GSList * D.23194;
  unsigned int D.23195;
  int D.23198;
  unsigned int D.23199;
  int D.23200;
  gchar * D.23205;
  struct GSList * D.23206;
  unsigned int D.23207;
  gchar * D.23212;
  struct GSList * D.23213;
  <unnamed-unsigned:24> D.23214;
  int D.23215;
  int D.23216;
  unsigned int D.23217;
  gchar * D.23222;
  struct GSList * D.23223;
  gchar * D.23228;
  struct GSList * D.23229;
  unsigned int D.23230;
  gchar * D.23235;
  struct GSList * D.23236;
  <unnamed-unsigned:24> D.23237;
  int D.23238;
  int D.23239;
  unsigned int D.23240;
  gchar * D.23245;
  struct GSList * D.23246;
  gchar * D.23251;
  struct GSList * D.23252;
  <unnamed-unsigned:24> D.23253;
  int D.23254;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 fieldlist;
  guint32 methodlist;
  guint32 visibility;
  int i;

  try
    {
      D.23109 = ctx->image;
      table = &D.23109->tables[2];
      fieldlist = 1;
      methodlist = 1;
      D.23110 = BIT_FIELD_REF <*table, 32, 32>;
      D.23111 = D.23110 & 16777215;
      if (D.23111 == 0) goto <D.23112>; else goto <D.23113>;
      <D.23112>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23115>; else goto <D.23116>;
      <D.23115>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23117 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.23117;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23119 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23119;
      }
      <D.23116>:
      ctx->valid = 0;
      return;
      <D.23113>:
      i = 0;
      goto <D.20962>;
      <D.20961>:
      mono_metadata_decode_row (table, i, &data, 6);
      D.23120 = data[0];
      D.23121 = D.23120 & 4280861248;
      if (D.23121 != 0) goto <D.23122>; else goto <D.23123>;
      <D.23122>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23124>; else goto <D.23125>;
      <D.23124>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23120 = data[0];
        D.23126 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid flags field 0x%08x", i, D.23120);
        vinfo->info.message = D.23126;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23127 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23127;
      }
      <D.23125>:
      ctx->valid = 0;
      return;
      <D.23123>:
      D.23120 = data[0];
      D.23128 = D.23120 & 24;
      if (D.23128 == 24) goto <D.23129>; else goto <D.23130>;
      <D.23129>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23131>; else goto <D.23132>;
      <D.23131>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23133 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid class layout 0x18", i);
        vinfo->info.message = D.23133;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23134 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23134;
      }
      <D.23132>:
      ctx->valid = 0;
      return;
      <D.23130>:
      D.23120 = data[0];
      D.23135 = D.23120 & 196608;
      if (D.23135 == 196608) goto <D.23136>; else goto <D.23137>;
      <D.23136>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23138>; else goto <D.23139>;
      <D.23138>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23140 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.23140;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23141 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23141;
      }
      <D.23139>:
      ctx->valid = 0;
      return;
      <D.23137>:
      D.23120 = data[0];
      D.23142 = D.23120 & 12582912;
      if (D.23142 != 0) goto <D.23143>; else goto <D.23144>;
      <D.23143>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23145>; else goto <D.23146>;
      <D.23145>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23147 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.23147;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23148 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23148;
      }
      <D.23146>:
      ctx->valid = 0;
      return;
      <D.23144>:
      D.23149 = BIT_FIELD_REF <data, 32, 0>;
      D.23150 = D.23149 & 160;
      if (D.23150 == 32) goto <D.23151>; else goto <D.23152>;
      <D.23151>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23153>; else goto <D.23154>;
      <D.23153>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23155 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i);
        vinfo->info.message = D.23155;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23156 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23156;
      }
      <D.23154>:
      ctx->valid = 0;
      return;
      <D.23152>:
      D.23159 = data[1];
      if (D.23159 == 0) goto <D.23157>; else goto <D.23160>;
      <D.23160>:
      D.23159 = data[1];
      D.23161 = is_valid_non_empty_string (ctx, D.23159);
      if (D.23161 == 0) goto <D.23157>; else goto <D.23158>;
      <D.23157>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23162>; else goto <D.23163>;
      <D.23162>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23159 = data[1];
        D.23164 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, D.23159);
        vinfo->info.message = D.23164;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23165 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23165;
      }
      <D.23163>:
      ctx->valid = 0;
      return;
      <D.23158>:
      D.23166 = data[2];
      if (D.23166 != 0) goto <D.23167>; else goto <D.23168>;
      <D.23167>:
      D.23166 = data[2];
      D.23169 = is_valid_non_empty_string (ctx, D.23166);
      if (D.23169 == 0) goto <D.23170>; else goto <D.23171>;
      <D.23170>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23172>; else goto <D.23173>;
      <D.23172>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23166 = data[2];
        D.23174 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, D.23166);
        vinfo->info.message = D.23174;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23175 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23175;
      }
      <D.23173>:
      ctx->valid = 0;
      return;
      <D.23171>:
      <D.23168>:
      D.23176 = data[3];
      if (D.23176 != 0) goto <D.23177>; else goto <D.23178>;
      <D.23177>:
      D.23176 = data[3];
      D.23179 = is_valid_coded_index (ctx, 0, D.23176);
      if (D.23179 == 0) goto <D.23180>; else goto <D.23181>;
      <D.23180>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23182>; else goto <D.23183>;
      <D.23182>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23176 = data[3];
        D.23184 = monoeg_g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, D.23176);
        vinfo->info.message = D.23184;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23185 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23185;
      }
      <D.23183>:
      ctx->valid = 0;
      return;
      <D.23181>:
      <D.23178>:
      D.23176 = data[3];
      if (D.23176 != 0) goto <D.23186>; else goto <D.23187>;
      <D.23186>:
      D.23176 = data[3];
      D.23188 = get_coded_index_token (0, D.23176);
      if (D.23188 == 0) goto <D.23189>; else goto <D.23190>;
      <D.23189>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23191>; else goto <D.23192>;
      <D.23191>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23176 = data[3];
        D.23193 = monoeg_g_strdup_printf ("Invalid typedef row %d zero coded extend field coded index 0x%08x", i, D.23176);
        vinfo->info.message = D.23193;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23194 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23194;
      }
      <D.23192>:
      ctx->valid = 0;
      return;
      <D.23190>:
      <D.23187>:
      D.23120 = data[0];
      visibility = D.23120 & 7;
      D.23195 = visibility + 4294967294;
      if (D.23195 <= 5) goto <D.23196>; else goto <D.23197>;
      <D.23196>:
      D.23198 = i + 1;
      D.23199 = (unsigned int) D.23198;
      D.23200 = search_sorted_table (ctx, 41, 0, D.23199);
      if (D.23200 == -1) goto <D.23201>; else goto <D.23202>;
      <D.23201>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23203>; else goto <D.23204>;
      <D.23203>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23205 = monoeg_g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i);
        vinfo->info.message = D.23205;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23206 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23206;
      }
      <D.23204>:
      ctx->valid = 0;
      return;
      <D.23202>:
      <D.23197>:
      D.23207 = data[4];
      if (D.23207 == 0) goto <D.23208>; else goto <D.23209>;
      <D.23208>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23210>; else goto <D.23211>;
      <D.23210>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23212 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i);
        vinfo->info.message = D.23212;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23213 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23213;
      }
      <D.23211>:
      ctx->valid = 0;
      return;
      <D.23209>:
      D.23207 = data[4];
      D.23109 = ctx->image;
      D.23214 = D.23109->tables[4].rows;
      D.23215 = (int) D.23214;
      D.23216 = D.23215 + 1;
      D.23217 = (unsigned int) D.23216;
      if (D.23207 > D.23217) goto <D.23218>; else goto <D.23219>;
      <D.23218>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23220>; else goto <D.23221>;
      <D.23220>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23207 = data[4];
        D.23222 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x is out of range", i, D.23207);
        vinfo->info.message = D.23222;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23223 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23223;
      }
      <D.23221>:
      ctx->valid = 0;
      return;
      <D.23219>:
      D.23207 = data[4];
      if (D.23207 < fieldlist) goto <D.23224>; else goto <D.23225>;
      <D.23224>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23226>; else goto <D.23227>;
      <D.23226>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23207 = data[4];
        D.23228 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.23207, fieldlist);
        vinfo->info.message = D.23228;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23229 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23229;
      }
      <D.23227>:
      ctx->valid = 0;
      return;
      <D.23225>:
      D.23230 = data[5];
      if (D.23230 == 0) goto <D.23231>; else goto <D.23232>;
      <D.23231>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23233>; else goto <D.23234>;
      <D.23233>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23235 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList be be >= 1", i);
        vinfo->info.message = D.23235;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23236 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23236;
      }
      <D.23234>:
      ctx->valid = 0;
      return;
      <D.23232>:
      D.23230 = data[5];
      D.23109 = ctx->image;
      D.23237 = D.23109->tables[6].rows;
      D.23238 = (int) D.23237;
      D.23239 = D.23238 + 1;
      D.23240 = (unsigned int) D.23239;
      if (D.23230 > D.23240) goto <D.23241>; else goto <D.23242>;
      <D.23241>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23243>; else goto <D.23244>;
      <D.23243>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23230 = data[5];
        D.23245 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x is out of range", i, D.23230);
        vinfo->info.message = D.23245;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23246 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23246;
      }
      <D.23244>:
      ctx->valid = 0;
      return;
      <D.23242>:
      D.23230 = data[5];
      if (D.23230 < methodlist) goto <D.23247>; else goto <D.23248>;
      <D.23247>:
      D.23114 = ctx->report_error;
      if (D.23114 != 0) goto <D.23249>; else goto <D.23250>;
      <D.23249>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23230 = data[5];
        D.23251 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.23230, methodlist);
        vinfo->info.message = D.23251;
        vinfo->exception_type = 3;
        D.23118 = ctx->errors;
        D.23252 = monoeg_g_slist_prepend (D.23118, vinfo);
        ctx->errors = D.23252;
      }
      <D.23250>:
      ctx->valid = 0;
      return;
      <D.23248>:
      fieldlist = data[4];
      methodlist = data[5];
      i = i + 1;
      <D.20962>:
      D.23253 = table->rows;
      D.23254 = (int) D.23253;
      if (D.23254 > i) goto <D.20961>; else goto <D.20963>;
      <D.20963>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_coded_index (struct VerifyContext * ctx, int token_kind, guint32 coded_token)
{
  gboolean D.23258;
  struct MonoImage * D.23259;

  D.23259 = ctx->image;
  D.23258 = is_valid_coded_index_with_image (D.23259, token_kind, coded_token);
  return D.23258;
}


is_valid_coded_index_with_image (struct MonoImage * image, int token_kind, guint32 coded_token)
{
  int token_kind.22;
  unsigned char D.23262;
  int token_kind.23;
  unsigned char D.23264;
  int bits.24;
  int D.23266;
  int D.23267;
  unsigned int D.23268;
  gboolean D.23271;
  unsigned int token_kind.25;
  unsigned int D.23273;
  unsigned char D.23274;
  <unnamed-unsigned:24> D.23277;
  unsigned int D.23278;
  _Bool D.23279;
  guint32 bits;
  guint32 table_count;
  guint32 table;
  guint32 token;

  token_kind.22 = token_kind;
  token_kind = token_kind.22 + 1;
  D.23262 = coded_index_desc[token_kind.22];
  bits = (guint32) D.23262;
  token_kind.23 = token_kind;
  token_kind = token_kind.23 + 1;
  D.23264 = coded_index_desc[token_kind.23];
  table_count = (guint32) D.23264;
  bits.24 = (int) bits;
  D.23266 = 1 << bits.24;
  D.23267 = D.23266 + -1;
  D.23268 = (unsigned int) D.23267;
  table = D.23268 & coded_token;
  bits.24 = (int) bits;
  token = coded_token >> bits.24;
  if (table >= table_count) goto <D.23269>; else goto <D.23270>;
  <D.23269>:
  D.23271 = 0;
  return D.23271;
  <D.23270>:
  token_kind.25 = (unsigned int) token_kind;
  D.23273 = token_kind.25 + table;
  D.23274 = coded_index_desc[D.23273];
  table = (guint32) D.23274;
  if (table == 255) goto <D.23275>; else goto <D.23276>;
  <D.23275>:
  D.23271 = 0;
  return D.23271;
  <D.23276>:
  D.23277 = image->tables[table].rows;
  D.23278 = (unsigned int) D.23277;
  D.23279 = D.23278 >= token;
  D.23271 = (gboolean) D.23279;
  return D.23271;
}


get_coded_index_token (int token_kind, guint32 coded_token)
{
  unsigned char D.23281;
  guint32 D.23282;
  int bits.26;
  guint32 bits;

  D.23281 = coded_index_desc[token_kind];
  bits = (guint32) D.23281;
  bits.26 = (int) bits;
  D.23282 = coded_token >> bits.26;
  return D.23282;
}


search_sorted_table (struct VerifyContext * ctx, int table, int column, guint32 coded_token)
{
  struct MonoImage * D.23285;
  unsigned int D.23286;
  unsigned int D.23287;
  <unnamed-unsigned:24> D.23288;
  unsigned int D.23289;
  unsigned char D.23290;
  unsigned int D.23291;
  int D.23294;
  int res.27;
  int base.28;
  int D.23297;
  int D.23298;
  struct MonoTableInfo * tinfo;
  struct RowLocator locator;
  const char * res;
  const char * base;

  try
    {
      D.23285 = ctx->image;
      tinfo = &D.23285->tables[table];
      locator.token = coded_token;
      D.23286 = get_col_offset (ctx, table, column);
      locator.col_offset = D.23286;
      D.23287 = get_col_size (ctx, table, column);
      locator.col_size = D.23287;
      locator.table = tinfo;
      base = tinfo->base;
      D.23288 = tinfo->rows;
      D.23289 = (unsigned int) D.23288;
      D.23290 = tinfo->row_size;
      D.23291 = (unsigned int) D.23290;
      res = mono_binary_search (&locator, base, D.23289, D.23291, token_locator);
      if (res == 0B) goto <D.23292>; else goto <D.23293>;
      <D.23292>:
      D.23294 = -1;
      return D.23294;
      <D.23293>:
      res.27 = (int) res;
      base.28 = (int) base;
      D.23297 = res.27 - base.28;
      D.23290 = tinfo->row_size;
      D.23298 = (int) D.23290;
      D.23294 = D.23297 / D.23298;
      return D.23294;
    }
  finally
    {
      locator = {CLOBBER};
    }
}


token_locator (const void * a, const void * b)
{
  guint32 iftmp.29;
  unsigned int D.23302;
  unsigned int D.23305;
  const unsigned char * D.23306;
  short unsigned int D.23307;
  int D.23309;
  unsigned int D.23310;
  int D.23311;
  int token.30;
  struct RowLocator * loc;
  const unsigned char * row;
  guint32 token;

  loc = a;
  row = b;
  D.23302 = loc->col_size;
  if (D.23302 == 2) goto <D.23303>; else goto <D.23304>;
  <D.23303>:
  D.23305 = loc->col_offset;
  D.23306 = row + D.23305;
  D.23307 = mono_read16 (D.23306);
  iftmp.29 = (guint32) D.23307;
  goto <D.23308>;
  <D.23304>:
  D.23305 = loc->col_offset;
  D.23306 = row + D.23305;
  iftmp.29 = mono_read32 (D.23306);
  <D.23308>:
  token = iftmp.29;
  D.23310 = loc->token;
  D.23311 = (int) D.23310;
  token.30 = (int) token;
  D.23309 = D.23311 - token.30;
  return D.23309;
}


get_col_offset (struct VerifyContext * ctx, int table, int column)
{
  struct MonoImage * D.23314;
  int D.23315;
  unsigned int D.23316;
  unsigned int D.23317;
  unsigned int D.23318;
  int column.31;
  guint32 D.23320;
  guint32 bitfield;
  guint32 offset;

  D.23314 = ctx->image;
  bitfield = D.23314->tables[table].size_bitfield;
  offset = 0;
  goto <D.20219>;
  <D.20218>:
  D.23315 = column * 2;
  D.23316 = bitfield >> D.23315;
  D.23317 = D.23316 & 3;
  D.23318 = D.23317 + offset;
  offset = D.23318 + 1;
  <D.20219>:
  column.31 = column;
  column = column.31 + -1;
  if (column.31 > 0) goto <D.20218>; else goto <D.20220>;
  <D.20220>:
  D.23320 = offset;
  return D.23320;
}


get_col_size (struct VerifyContext * ctx, int table, int column)
{
  guint32 D.23322;
  struct MonoImage * D.23323;
  unsigned int D.23324;
  int D.23325;
  unsigned int D.23326;
  unsigned int D.23327;

  D.23323 = ctx->image;
  D.23324 = D.23323->tables[table].size_bitfield;
  D.23325 = column * 2;
  D.23326 = D.23324 >> D.23325;
  D.23327 = D.23326 & 3;
  D.23322 = D.23327 + 1;
  return D.23322;
}


verify_field_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23329;
  <unnamed-unsigned:24> D.23330;
  int D.23331;
  unsigned int D.23334;
  int D.23337;
  gchar * D.23340;
  struct GSList * D.23341;
  struct GSList * D.23342;
  unsigned int D.23343;
  gchar * D.23348;
  struct GSList * D.23349;
  unsigned int D.23350;
  gchar * D.23355;
  struct GSList * D.23356;
  unsigned int D.23357;
  gchar * D.23362;
  struct GSList * D.23363;
  unsigned int D.23364;
  gchar * D.23369;
  struct GSList * D.23370;
  unsigned int D.23371;
  unsigned int i.32;
  unsigned int D.23375;
  int D.23376;
  gchar * D.23381;
  struct GSList * D.23382;
  unsigned int D.23383;
  unsigned int D.23386;
  int D.23387;
  gchar * D.23392;
  struct GSList * D.23393;
  unsigned int D.23394;
  unsigned int D.23397;
  int D.23398;
  gchar * D.23403;
  struct GSList * D.23404;
  unsigned int D.23405;
  int D.23408;
  unsigned int D.23409;
  int D.23410;
  gchar * D.23415;
  struct GSList * D.23416;
  unsigned int D.23419;
  int D.23421;
  gchar * D.23424;
  struct GSList * D.23425;
  unsigned int D.23426;
  int D.23429;
  gchar * D.23434;
  struct GSList * D.23435;
  unsigned int D.23438;
  gchar * D.23443;
  struct GSList * D.23444;
  _Bool D.23445;
  _Bool D.23446;
  _Bool D.23447;
  gchar * D.23452;
  struct GSList * D.23453;
  <unnamed-unsigned:24> D.23454;
  int D.23455;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 module_field_list;
  int i;

  try
    {
      D.23329 = ctx->image;
      table = &D.23329->tables[4];
      module_field_list = 4294967295;
      D.23329 = ctx->image;
      D.23330 = D.23329->tables[2].rows;
      D.23331 = (int) D.23330;
      if (D.23331 > 1) goto <D.23332>; else goto <D.23333>;
      <D.23332>:
      {
        struct MonoTableInfo * type;

        D.23329 = ctx->image;
        type = &D.23329->tables[2];
        module_field_list = mono_metadata_decode_row_col (type, 1, 4);
      }
      <D.23333>:
      i = 0;
      goto <D.21004>;
      <D.21003>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.23334 = flags & 18440;
      if (D.23334 != 0) goto <D.23335>; else goto <D.23336>;
      <D.23335>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23338>; else goto <D.23339>;
      <D.23338>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23340 = monoeg_g_strdup_printf ("Invalid field row %d invalid flags field 0x%08x", i, flags);
        vinfo->info.message = D.23340;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23342 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23342;
      }
      <D.23339>:
      ctx->valid = 0;
      return;
      <D.23336>:
      D.23343 = flags & 7;
      if (D.23343 == 7) goto <D.23344>; else goto <D.23345>;
      <D.23344>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23346>; else goto <D.23347>;
      <D.23346>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23348 = monoeg_g_strdup_printf ("Invalid field row %d invalid field visibility 0x7", i);
        vinfo->info.message = D.23348;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23349 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23349;
      }
      <D.23347>:
      ctx->valid = 0;
      return;
      <D.23345>:
      D.23350 = flags & 96;
      if (D.23350 == 96) goto <D.23351>; else goto <D.23352>;
      <D.23351>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23353>; else goto <D.23354>;
      <D.23353>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23355 = monoeg_g_strdup_printf ("Invalid field row %d cannot be InitOnly and Literal at the same time", i);
        vinfo->info.message = D.23355;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23356 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23356;
      }
      <D.23354>:
      ctx->valid = 0;
      return;
      <D.23352>:
      D.23357 = flags & 1536;
      if (D.23357 == 1024) goto <D.23358>; else goto <D.23359>;
      <D.23358>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23360>; else goto <D.23361>;
      <D.23360>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23362 = monoeg_g_strdup_printf ("Invalid field row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.23362;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23363 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23363;
      }
      <D.23361>:
      ctx->valid = 0;
      return;
      <D.23359>:
      D.23364 = flags & 80;
      if (D.23364 == 64) goto <D.23365>; else goto <D.23366>;
      <D.23365>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23367>; else goto <D.23368>;
      <D.23367>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23369 = monoeg_g_strdup_printf ("Invalid field row %d is Literal but not Static", i);
        vinfo->info.message = D.23369;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23370 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23370;
      }
      <D.23368>:
      ctx->valid = 0;
      return;
      <D.23366>:
      D.23371 = flags & 4096;
      if (D.23371 != 0) goto <D.23372>; else goto <D.23373>;
      <D.23372>:
      i.32 = (unsigned int) i;
      D.23375 = make_coded_token (32, 4, i.32);
      D.23376 = search_sorted_table (ctx, 13, 0, D.23375);
      if (D.23376 == -1) goto <D.23377>; else goto <D.23378>;
      <D.23377>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23379>; else goto <D.23380>;
      <D.23379>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23381 = monoeg_g_strdup_printf ("Invalid field row %d has FieldMarshal but there is no corresponding row in the FieldMarshal table", i);
        vinfo->info.message = D.23381;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23382 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23382;
      }
      <D.23380>:
      ctx->valid = 0;
      return;
      <D.23378>:
      <D.23373>:
      D.23383 = flags & 32768;
      if (D.23383 != 0) goto <D.23384>; else goto <D.23385>;
      <D.23384>:
      i.32 = (unsigned int) i;
      D.23386 = make_coded_token (5, 4, i.32);
      D.23387 = search_sorted_table (ctx, 11, 2, D.23386);
      if (D.23387 == -1) goto <D.23388>; else goto <D.23389>;
      <D.23388>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23390>; else goto <D.23391>;
      <D.23390>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23392 = monoeg_g_strdup_printf ("Invalid field row %d has Default but there is no corresponding row in the Constant table", i);
        vinfo->info.message = D.23392;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23393 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23393;
      }
      <D.23391>:
      ctx->valid = 0;
      return;
      <D.23389>:
      <D.23385>:
      D.23394 = flags & 64;
      if (D.23394 != 0) goto <D.23395>; else goto <D.23396>;
      <D.23395>:
      i.32 = (unsigned int) i;
      D.23397 = make_coded_token (5, 4, i.32);
      D.23398 = search_sorted_table (ctx, 11, 2, D.23397);
      if (D.23398 == -1) goto <D.23399>; else goto <D.23400>;
      <D.23399>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23401>; else goto <D.23402>;
      <D.23401>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23403 = monoeg_g_strdup_printf ("Invalid field row %d is Literal but there is no corresponding row in the Constant table", i);
        vinfo->info.message = D.23403;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23404 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23404;
      }
      <D.23402>:
      ctx->valid = 0;
      return;
      <D.23400>:
      <D.23396>:
      D.23405 = flags & 256;
      if (D.23405 != 0) goto <D.23406>; else goto <D.23407>;
      <D.23406>:
      D.23408 = i + 1;
      D.23409 = (unsigned int) D.23408;
      D.23410 = search_sorted_table (ctx, 29, 1, D.23409);
      if (D.23410 == -1) goto <D.23411>; else goto <D.23412>;
      <D.23411>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23413>; else goto <D.23414>;
      <D.23413>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23415 = monoeg_g_strdup_printf ("Invalid field row %d has Default but there is no corresponding row in the Constant table", i);
        vinfo->info.message = D.23415;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23416 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23416;
      }
      <D.23414>:
      ctx->valid = 0;
      return;
      <D.23412>:
      <D.23407>:
      D.23419 = data[1];
      if (D.23419 == 0) goto <D.23417>; else goto <D.23420>;
      <D.23420>:
      D.23419 = data[1];
      D.23421 = is_valid_non_empty_string (ctx, D.23419);
      if (D.23421 == 0) goto <D.23417>; else goto <D.23418>;
      <D.23417>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23422>; else goto <D.23423>;
      <D.23422>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23419 = data[1];
        D.23424 = monoeg_g_strdup_printf ("Invalid field row %d invalid name token %08x", i, D.23419);
        vinfo->info.message = D.23424;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23425 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23425;
      }
      <D.23423>:
      ctx->valid = 0;
      return;
      <D.23418>:
      D.23426 = data[2];
      if (D.23426 != 0) goto <D.23427>; else goto <D.23428>;
      <D.23427>:
      D.23426 = data[2];
      D.23429 = is_valid_blob_object (ctx, D.23426, 1);
      if (D.23429 == 0) goto <D.23430>; else goto <D.23431>;
      <D.23430>:
      D.23337 = ctx->report_error;
      if (D.23337 != 0) goto <D.23432>; else goto <D.23433>;
      <D.23432>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23426 = data[2];
        D.23434 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, D.23426);
        vinfo->info.message = D.23434;
        vinfo->exception_type = 3;
        D.23341 = ctx->errors;
        D.23435 = monoeg_g_slist_prepend (D.23341, vinfo);
        ctx->errors = D.23435;
      }
      <D.23433>:
      ctx->valid = 0;
      return;
      <D.23431>:
      <D.23428>:
      D.23408 = i + 1;
      D.23409 = (unsigned int) D.23408;
      if (D.23409 < module_field_list) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      {
        guint32 access;

        access = flags & 7;
        D.23438 = flags & 16;
        if (D.23438 == 0) goto <D.23439>; else goto <D.23440>;
        <D.23439>:
        D.23337 = ctx->report_error;
        if (D.23337 != 0) goto <D.23441>; else goto <D.23442>;
        <D.23441>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23443 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but is not static", i);
          vinfo->info.message = D.23443;
          vinfo->exception_type = 3;
          D.23341 = ctx->errors;
          D.23444 = monoeg_g_slist_prepend (D.23341, vinfo);
          ctx->errors = D.23444;
        }
        <D.23442>:
        ctx->valid = 0;
        return;
        <D.23440>:
        D.23445 = access > 1;
        D.23446 = access != 6;
        D.23447 = D.23445 & D.23446;
        if (D.23447 != 0) goto <D.23448>; else goto <D.23449>;
        <D.23448>:
        D.23337 = ctx->report_error;
        if (D.23337 != 0) goto <D.23450>; else goto <D.23451>;
        <D.23450>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.23452 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but have wrong visibility %x", i, access);
          vinfo->info.message = D.23452;
          vinfo->exception_type = 3;
          D.23341 = ctx->errors;
          D.23453 = monoeg_g_slist_prepend (D.23341, vinfo);
          ctx->errors = D.23453;
        }
        <D.23451>:
        ctx->valid = 0;
        return;
        <D.23449>:
      }
      <D.23437>:
      i = i + 1;
      <D.21004>:
      D.23454 = table->rows;
      D.23455 = (int) D.23454;
      if (D.23455 > i) goto <D.21003>; else goto <D.21005>;
      <D.21005>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


make_coded_token (int kind, guint32 table, guint32 table_idx)
{
  int kind.33;
  unsigned char D.23460;
  int kind.34;
  unsigned char D.23462;
  int kind.35;
  unsigned char D.23464;
  unsigned int D.23465;
  guint32 D.23468;
  unsigned int D.23469;
  int bits.36;
  unsigned int D.23471;
  guint32 bits;
  guint32 tables;
  guint32 i;

  kind.33 = kind;
  kind = kind.33 + 1;
  D.23460 = coded_index_desc[kind.33];
  bits = (guint32) D.23460;
  kind.34 = kind;
  kind = kind.34 + 1;
  D.23462 = coded_index_desc[kind.34];
  tables = (guint32) D.23462;
  i = 0;
  goto <D.20278>;
  <D.20277>:
  kind.35 = kind;
  kind = kind.35 + 1;
  D.23464 = coded_index_desc[kind.35];
  D.23465 = (unsigned int) D.23464;
  if (D.23465 == table) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  D.23469 = table_idx + 1;
  bits.36 = (int) bits;
  D.23471 = D.23469 << bits.36;
  D.23468 = D.23471 | i;
  return D.23468;
  <D.23467>:
  i = i + 1;
  <D.20278>:
  if (i < tables) goto <D.20277>; else goto <D.20279>;
  <D.20279>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 1012);
  D.23468 = 4294967295;
  return D.23468;
}


is_valid_blob_object (struct VerifyContext * ctx, guint32 offset, guint32 minsize)
{
  struct MonoImage * D.23473;
  struct MonoStreamHeader * D.23474;
  unsigned int D.23475;
  gboolean D.23478;
  const char * D.23479;
  unsigned int D.23480;
  sizetype D.23481;
  const char * D.23482;
  unsigned int D.23483;
  int D.23484;
  unsigned int entry_size.37;
  unsigned int bytes.38;
  unsigned int D.23491;
  unsigned int entry_size.39;
  int iftmp.40;
  unsigned int D.23498;
  unsigned int D.23500;
  struct OffsetAndSize blob;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.23473 = ctx->image;
      D.23474 = &D.23473->heap_blob;
      blob = get_metadata_stream (ctx, D.23474); [return slot optimization]
      D.23475 = blob.size;
      if (D.23475 < offset) goto <D.23476>; else goto <D.23477>;
      <D.23476>:
      D.23478 = 0;
      return D.23478;
      <D.23477>:
      D.23479 = ctx->data;
      D.23480 = blob.offset;
      D.23481 = D.23480 + offset;
      D.23482 = D.23479 + D.23481;
      D.23475 = blob.size;
      D.23480 = blob.offset;
      D.23483 = D.23475 - D.23480;
      D.23484 = decode_value (D.23482, D.23483, &entry_size, &bytes);
      if (D.23484 == 0) goto <D.23485>; else goto <D.23486>;
      <D.23485>:
      D.23478 = 0;
      return D.23478;
      <D.23486>:
      entry_size.37 = entry_size;
      if (entry_size.37 < minsize) goto <D.23488>; else goto <D.23489>;
      <D.23488>:
      D.23478 = 0;
      return D.23478;
      <D.23489>:
      bytes.38 = bytes;
      D.23491 = ~bytes.38;
      entry_size.37 = entry_size;
      if (D.23491 < entry_size.37) goto <D.23492>; else goto <D.23493>;
      <D.23492>:
      D.23478 = 0;
      return D.23478;
      <D.23493>:
      entry_size.37 = entry_size;
      bytes.38 = bytes;
      entry_size.39 = entry_size.37 + bytes.38;
      entry_size = entry_size.39;
      entry_size.37 = entry_size;
      D.23498 = offset + entry_size.37;
      D.23475 = blob.size;
      if (D.23498 <= D.23475) goto <D.23499>; else goto <D.23496>;
      <D.23499>:
      entry_size.37 = entry_size;
      D.23500 = ~entry_size.37;
      if (D.23500 >= offset) goto <D.23501>; else goto <D.23496>;
      <D.23501>:
      iftmp.40 = 1;
      goto <D.23497>;
      <D.23496>:
      iftmp.40 = 0;
      <D.23497>:
      D.23478 = iftmp.40;
      return D.23478;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


decode_value (const char * _ptr, unsigned int available, unsigned int * value, unsigned int * size)
{
  gboolean D.23506;
  unsigned int D.23507;
  signed char b.41;
  unsigned int D.23511;
  int D.23513;
  int D.23514;
  int D.23519;
  int D.23520;
  const unsigned char * D.23521;
  unsigned char D.23522;
  int D.23523;
  int D.23524;
  unsigned int D.23525;
  int D.23529;
  int D.23530;
  int D.23531;
  int D.23532;
  const unsigned char * D.23533;
  unsigned char D.23534;
  int D.23535;
  int D.23536;
  int D.23537;
  const unsigned char * D.23538;
  unsigned char D.23539;
  int D.23540;
  int D.23541;
  unsigned int D.23542;
  unsigned char b;
  const unsigned char * ptr;

  ptr = _ptr;
  if (available == 0) goto <D.23504>; else goto <D.23505>;
  <D.23504>:
  D.23506 = 0;
  return D.23506;
  <D.23505>:
  b = *ptr;
  *size = 0;
  D.23507 = *size;
  *value = D.23507;
  b.41 = (signed char) b;
  if (b.41 >= 0) goto <D.23509>; else goto <D.23510>;
  <D.23509>:
  *size = 1;
  D.23511 = (unsigned int) b;
  *value = D.23511;
  goto <D.23512>;
  <D.23510>:
  D.23513 = (int) b;
  D.23514 = D.23513 & 64;
  if (D.23514 == 0) goto <D.23515>; else goto <D.23516>;
  <D.23515>:
  if (available <= 1) goto <D.23517>; else goto <D.23518>;
  <D.23517>:
  D.23506 = 0;
  return D.23506;
  <D.23518>:
  *size = 2;
  D.23513 = (int) b;
  D.23519 = D.23513 & 63;
  D.23520 = D.23519 << 8;
  D.23521 = ptr + 1;
  D.23522 = *D.23521;
  D.23523 = (int) D.23522;
  D.23524 = D.23520 | D.23523;
  D.23525 = (unsigned int) D.23524;
  *value = D.23525;
  goto <D.23526>;
  <D.23516>:
  if (available <= 3) goto <D.23527>; else goto <D.23528>;
  <D.23527>:
  D.23506 = 0;
  return D.23506;
  <D.23528>:
  *size = 4;
  D.23513 = (int) b;
  D.23529 = D.23513 & 31;
  D.23530 = D.23529 << 24;
  D.23521 = ptr + 1;
  D.23522 = *D.23521;
  D.23523 = (int) D.23522;
  D.23531 = D.23523 << 16;
  D.23532 = D.23530 | D.23531;
  D.23533 = ptr + 2;
  D.23534 = *D.23533;
  D.23535 = (int) D.23534;
  D.23536 = D.23535 << 8;
  D.23537 = D.23532 | D.23536;
  D.23538 = ptr + 3;
  D.23539 = *D.23538;
  D.23540 = (int) D.23539;
  D.23541 = D.23537 | D.23540;
  D.23542 = (unsigned int) D.23541;
  *value = D.23542;
  <D.23526>:
  <D.23512>:
  D.23506 = 1;
  return D.23506;
}


verify_method_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23544;
  <unnamed-unsigned:24> D.23545;
  int D.23546;
  unsigned int D.23549;
  int D.23552;
  gchar * D.23555;
  struct GSList * D.23556;
  struct GSList * D.23557;
  gchar * D.23562;
  struct GSList * D.23563;
  unsigned int D.23566;
  int D.23568;
  gchar * D.23571;
  struct GSList * D.23572;
  int D.21044;
  int iftmp.42;
  int D.21040;
  const char[6] * D.23576;
  unsigned char D.23577;
  int D.23578;
  unsigned char D.23579;
  int D.23580;
  _Bool D.23581;
  _Bool D.23582;
  _Bool D.23583;
  const unsigned char * D.23586;
  unsigned char D.23587;
  int D.23588;
  const unsigned char * D.23589;
  unsigned char D.23590;
  int D.23591;
  _Bool D.23592;
  _Bool D.23593;
  const unsigned char * D.23596;
  unsigned char D.23597;
  int D.23598;
  const unsigned char * D.23599;
  unsigned char D.23600;
  int D.23601;
  _Bool D.23602;
  _Bool D.23603;
  const unsigned char * D.23606;
  unsigned char D.23607;
  int D.23608;
  const unsigned char * D.23609;
  unsigned char D.23610;
  int D.23611;
  _Bool D.23613;
  int D.21053;
  int iftmp.43;
  int D.21049;
  const char[7] * D.23617;
  unsigned char D.23618;
  int D.23619;
  unsigned char D.23620;
  int D.23621;
  _Bool D.23622;
  _Bool D.23623;
  _Bool D.23624;
  const unsigned char * D.23627;
  unsigned char D.23628;
  int D.23629;
  const unsigned char * D.23630;
  unsigned char D.23631;
  int D.23632;
  _Bool D.23633;
  _Bool D.23634;
  const unsigned char * D.23637;
  unsigned char D.23638;
  int D.23639;
  const unsigned char * D.23640;
  unsigned char D.23641;
  int D.23642;
  _Bool D.23643;
  _Bool D.23644;
  const unsigned char * D.23647;
  unsigned char D.23648;
  int D.23649;
  const unsigned char * D.23650;
  unsigned char D.23651;
  int D.23652;
  _Bool D.23654;
  int D.23655;
  unsigned int i.44;
  unsigned int D.23659;
  int D.23660;
  gchar * D.23665;
  struct GSList * D.23666;
  unsigned int D.23667;
  unsigned int D.23670;
  gchar * D.23675;
  struct GSList * D.23676;
  unsigned int D.23677;
  unsigned int D.23680;
  gchar * D.23685;
  struct GSList * D.23686;
  unsigned int D.23687;
  gchar * D.23692;
  struct GSList * D.23693;
  unsigned int D.23694;
  gchar * D.23699;
  struct GSList * D.23700;
  unsigned int D.23703;
  int D.23706;
  gchar * D.23709;
  struct GSList * D.23710;
  unsigned int D.23711;
  gchar * D.23716;
  struct GSList * D.23717;
  int D.23718;
  unsigned int D.23719;
  gchar * D.23726;
  struct GSList * D.23727;
  unsigned int D.23728;
  gchar * D.23733;
  struct GSList * D.23734;
  _Bool D.23737;
  _Bool D.23738;
  _Bool D.23739;
  gchar * D.23743;
  struct GSList * D.23744;
  unsigned int D.23745;
  gchar * D.23752;
  struct GSList * D.23753;
  gchar * D.23760;
  struct GSList * D.23761;
  gchar * D.23766;
  struct GSList * D.23767;
  unsigned int D.23768;
  unsigned int D.23773;
  gchar * D.23780;
  struct GSList * D.23781;
  unsigned int D.23782;
  gchar * D.23789;
  struct GSList * D.23790;
  unsigned int D.23795;
  gchar * D.23799;
  struct GSList * D.23800;
  gchar * D.23805;
  struct GSList * D.23806;
  gchar * D.23816;
  struct GSList * D.23817;
  gchar * D.23824;
  struct GSList * D.23825;
  unsigned int D.23826;
  int D.23827;
  gchar * D.23832;
  struct GSList * D.23833;
  unsigned int D.23834;
  gchar * D.23841;
  struct GSList * D.23842;
  gchar * D.23849;
  struct GSList * D.23850;
  unsigned int D.23851;
  int D.23854;
  gchar * D.23859;
  struct GSList * D.23860;
  unsigned int D.23861;
  gchar * D.23866;
  struct GSList * D.23867;
  gchar * D.23872;
  struct GSList * D.23873;
  <unnamed-unsigned:24> D.23874;
  int D.23875;
  int D.23876;
  unsigned int D.23877;
  gchar * D.23882;
  struct GSList * D.23883;
  <unnamed-unsigned:24> D.23884;
  int D.23885;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 flags;
  guint32 implflags;
  guint32 rva;
  guint32 module_method_list;
  guint32 access;
  guint32 code_type;
  guint32 paramlist;
  gboolean is_ctor;
  gboolean is_cctor;
  const char * name;
  int i;

  try
    {
      D.23544 = ctx->image;
      table = &D.23544->tables[6];
      paramlist = 1;
      module_method_list = 4294967295;
      D.23544 = ctx->image;
      D.23545 = D.23544->tables[2].rows;
      D.23546 = (int) D.23545;
      if (D.23546 > 1) goto <D.23547>; else goto <D.23548>;
      <D.23547>:
      {
        struct MonoTableInfo * type;

        D.23544 = ctx->image;
        type = &D.23544->tables[2];
        module_method_list = mono_metadata_decode_row_col (type, 1, 5);
      }
      <D.23548>:
      i = 0;
      goto <D.21081>;
      <D.21080>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      implflags = data[1];
      flags = data[2];
      access = flags & 7;
      code_type = implflags & 3;
      D.23549 = implflags & 60928;
      if (D.23549 != 0) goto <D.23550>; else goto <D.23551>;
      <D.23550>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23553>; else goto <D.23554>;
      <D.23553>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23555 = monoeg_g_strdup_printf ("Invalid method row %d invalid implflags field 0x%08x", i, implflags);
        vinfo->info.message = D.23555;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23557 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23557;
      }
      <D.23554>:
      ctx->valid = 0;
      return;
      <D.23551>:
      if (access == 7) goto <D.23558>; else goto <D.23559>;
      <D.23558>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23560>; else goto <D.23561>;
      <D.23560>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23562 = monoeg_g_strdup_printf ("Invalid method row %d invalid MemberAccessMask 0x7", i);
        vinfo->info.message = D.23562;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23563 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23563;
      }
      <D.23561>:
      ctx->valid = 0;
      return;
      <D.23559>:
      D.23566 = data[3];
      if (D.23566 == 0) goto <D.23564>; else goto <D.23567>;
      <D.23567>:
      D.23566 = data[3];
      D.23568 = is_valid_non_empty_string (ctx, D.23566);
      if (D.23568 == 0) goto <D.23564>; else goto <D.23565>;
      <D.23564>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23569>; else goto <D.23570>;
      <D.23569>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23566 = data[3];
        D.23571 = monoeg_g_strdup_printf ("Invalid method row %d invalid name field 0x%08x", i, D.23566);
        vinfo->info.message = D.23571;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23572 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23572;
      }
      <D.23570>:
      ctx->valid = 0;
      return;
      <D.23565>:
      D.23566 = data[3];
      name = get_string_ptr (ctx, D.23566);
      {
        size_t __s1_len;
        size_t __s2_len;

        __s1_len = 5;
        if (__s1_len <= 3) goto <D.23574>; else goto <D.23575>;
        <D.23574>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = name;
          D.23576 = ".ctor";
          D.23577 = MEM[(const unsigned char *)D.23576];
          D.23578 = (int) D.23577;
          D.23579 = *__s2;
          D.23580 = (int) D.23579;
          __result = D.23578 - D.23580;
          {
            D.23581 = __s1_len != 0;
            D.23582 = __result == 0;
            D.23583 = D.23581 & D.23582;
            if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
            <D.23584>:
            D.23586 = &MEM[(void *)".ctor" + 1B];
            D.23587 = *D.23586;
            D.23588 = (int) D.23587;
            D.23589 = __s2 + 1;
            D.23590 = *D.23589;
            D.23591 = (int) D.23590;
            __result = D.23588 - D.23591;
            D.23592 = __s1_len > 1;
            D.23582 = __result == 0;
            D.23593 = D.23592 & D.23582;
            if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
            <D.23594>:
            D.23596 = &MEM[(void *)".ctor" + 2B];
            D.23597 = *D.23596;
            D.23598 = (int) D.23597;
            D.23599 = __s2 + 2;
            D.23600 = *D.23599;
            D.23601 = (int) D.23600;
            __result = D.23598 - D.23601;
            D.23602 = __s1_len > 2;
            D.23582 = __result == 0;
            D.23603 = D.23602 & D.23582;
            if (D.23603 != 0) goto <D.23604>; else goto <D.23605>;
            <D.23604>:
            D.23606 = &MEM[(void *)".ctor" + 3B];
            D.23607 = *D.23606;
            D.23608 = (int) D.23607;
            D.23609 = __s2 + 3;
            D.23610 = *D.23609;
            D.23611 = (int) D.23610;
            __result = D.23608 - D.23611;
            <D.23605>:
            <D.23595>:
            <D.23585>:
          }
          D.21040 = __result;
        }
        iftmp.42 = D.21040;
        goto <D.23612>;
        <D.23575>:
        iftmp.42 = __builtin_strcmp (".ctor", name);
        <D.23612>:
        D.21044 = iftmp.42;
      }
      D.23613 = D.21044 == 0;
      is_ctor = (gboolean) D.23613;
      {
        size_t __s1_len;
        size_t __s2_len;

        __s1_len = 6;
        if (__s1_len <= 3) goto <D.23615>; else goto <D.23616>;
        <D.23615>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = name;
          D.23617 = ".cctor";
          D.23618 = MEM[(const unsigned char *)D.23617];
          D.23619 = (int) D.23618;
          D.23620 = *__s2;
          D.23621 = (int) D.23620;
          __result = D.23619 - D.23621;
          {
            D.23622 = __s1_len != 0;
            D.23623 = __result == 0;
            D.23624 = D.23622 & D.23623;
            if (D.23624 != 0) goto <D.23625>; else goto <D.23626>;
            <D.23625>:
            D.23627 = &MEM[(void *)".cctor" + 1B];
            D.23628 = *D.23627;
            D.23629 = (int) D.23628;
            D.23630 = __s2 + 1;
            D.23631 = *D.23630;
            D.23632 = (int) D.23631;
            __result = D.23629 - D.23632;
            D.23633 = __s1_len > 1;
            D.23623 = __result == 0;
            D.23634 = D.23633 & D.23623;
            if (D.23634 != 0) goto <D.23635>; else goto <D.23636>;
            <D.23635>:
            D.23637 = &MEM[(void *)".cctor" + 2B];
            D.23638 = *D.23637;
            D.23639 = (int) D.23638;
            D.23640 = __s2 + 2;
            D.23641 = *D.23640;
            D.23642 = (int) D.23641;
            __result = D.23639 - D.23642;
            D.23643 = __s1_len > 2;
            D.23623 = __result == 0;
            D.23644 = D.23643 & D.23623;
            if (D.23644 != 0) goto <D.23645>; else goto <D.23646>;
            <D.23645>:
            D.23647 = &MEM[(void *)".cctor" + 3B];
            D.23648 = *D.23647;
            D.23649 = (int) D.23648;
            D.23650 = __s2 + 3;
            D.23651 = *D.23650;
            D.23652 = (int) D.23651;
            __result = D.23649 - D.23652;
            <D.23646>:
            <D.23636>:
            <D.23626>:
          }
          D.21049 = __result;
        }
        iftmp.43 = D.21049;
        goto <D.23653>;
        <D.23616>:
        iftmp.43 = __builtin_strcmp (".cctor", name);
        <D.23653>:
        D.21053 = iftmp.43;
      }
      D.23654 = D.21053 == 0;
      is_cctor = (gboolean) D.23654;
      D.23655 = is_ctor | is_cctor;
      if (D.23655 != 0) goto <D.23656>; else goto <D.23657>;
      <D.23656>:
      i.44 = (unsigned int) i;
      D.23659 = make_coded_token (78, 6, i.44);
      D.23660 = search_sorted_table (ctx, 42, 2, D.23659);
      if (D.23660 != -1) goto <D.23661>; else goto <D.23662>;
      <D.23661>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23663>; else goto <D.23664>;
      <D.23663>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23665 = monoeg_g_strdup_printf ("Invalid method row %d .ctor or .cctor has generic param", i);
        vinfo->info.message = D.23665;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23666 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23666;
      }
      <D.23664>:
      ctx->valid = 0;
      return;
      <D.23662>:
      <D.23657>:
      D.23667 = flags & 16;
      if (D.23667 != 0) goto <D.23668>; else goto <D.23669>;
      <D.23668>:
      D.23670 = flags & 352;
      if (D.23670 != 0) goto <D.23671>; else goto <D.23672>;
      <D.23671>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23673>; else goto <D.23674>;
      <D.23673>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23675 = monoeg_g_strdup_printf ("Invalid method row %d is static and (final, virtual or new slot)", i);
        vinfo->info.message = D.23675;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23676 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23676;
      }
      <D.23674>:
      ctx->valid = 0;
      return;
      <D.23672>:
      <D.23669>:
      D.23677 = flags & 1024;
      if (D.23677 != 0) goto <D.23678>; else goto <D.23679>;
      <D.23678>:
      D.23680 = flags & 8192;
      if (D.23680 != 0) goto <D.23681>; else goto <D.23682>;
      <D.23681>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23683>; else goto <D.23684>;
      <D.23683>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23685 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i);
        vinfo->info.message = D.23685;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23686 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23686;
      }
      <D.23684>:
      ctx->valid = 0;
      return;
      <D.23682>:
      D.23687 = flags & 32;
      if (D.23687 != 0) goto <D.23688>; else goto <D.23689>;
      <D.23688>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23690>; else goto <D.23691>;
      <D.23690>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23692 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and Final", i);
        vinfo->info.message = D.23692;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23693 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23693;
      }
      <D.23691>:
      ctx->valid = 0;
      return;
      <D.23689>:
      D.23694 = flags & 64;
      if (D.23694 == 0) goto <D.23695>; else goto <D.23696>;
      <D.23695>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23697>; else goto <D.23698>;
      <D.23697>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23699 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract but not Virtual", i);
        vinfo->info.message = D.23699;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23700 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23700;
      }
      <D.23698>:
      ctx->valid = 0;
      return;
      <D.23696>:
      <D.23679>:
      if (access == 0) goto <D.23701>; else goto <D.23702>;
      <D.23701>:
      D.23703 = flags & 6144;
      if (D.23703 != 0) goto <D.23704>; else goto <D.23705>;
      <D.23704>:
      D.23706 = ctx->report_warning;
      if (D.23706 != 0) goto <D.23707>; else goto <D.23708>;
      <D.23707>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 2;
        D.23709 = monoeg_g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i);
        vinfo->info.message = D.23709;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23710 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23710;
      }
      ctx->valid = 0;
      return;
      <D.23708>:
      <D.23705>:
      <D.23702>:
      D.23711 = flags & 6144;
      if (D.23711 == 4096) goto <D.23712>; else goto <D.23713>;
      <D.23712>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23714>; else goto <D.23715>;
      <D.23714>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23716 = monoeg_g_strdup_printf ("Invalid method row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.23716;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23717 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23717;
      }
      <D.23715>:
      ctx->valid = 0;
      return;
      <D.23713>:
      D.23718 = i + 1;
      D.23719 = (unsigned int) D.23718;
      if (D.23719 < module_method_list) goto <D.23720>; else goto <D.23721>;
      <D.23720>:
      D.23667 = flags & 16;
      if (D.23667 == 0) goto <D.23722>; else goto <D.23723>;
      <D.23722>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23724>; else goto <D.23725>;
      <D.23724>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23726 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not Static", i);
        vinfo->info.message = D.23726;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23727 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23727;
      }
      <D.23725>:
      ctx->valid = 0;
      return;
      <D.23723>:
      D.23728 = flags & 1088;
      if (D.23728 != 0) goto <D.23729>; else goto <D.23730>;
      <D.23729>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23731>; else goto <D.23732>;
      <D.23731>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23733 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but is Abstract or Virtual", i);
        vinfo->info.message = D.23733;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23734 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23734;
      }
      <D.23732>:
      ctx->valid = 0;
      return;
      <D.23730>:
      D.23737 = access == 4;
      D.23738 = access == 2;
      D.23739 = D.23737 | D.23738;
      if (D.23739 != 0) goto <D.23735>; else goto <D.23740>;
      <D.23740>:
      if (access == 5) goto <D.23735>; else goto <D.23736>;
      <D.23735>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23741>; else goto <D.23742>;
      <D.23741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23743 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not CompilerControled, Public, Private or Assembly", i);
        vinfo->info.message = D.23743;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23744 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23744;
      }
      <D.23742>:
      ctx->valid = 0;
      return;
      <D.23736>:
      <D.23721>:
      D.23745 = flags & 800;
      if (D.23745 != 0) goto <D.23746>; else goto <D.23747>;
      <D.23746>:
      D.23694 = flags & 64;
      if (D.23694 == 0) goto <D.23748>; else goto <D.23749>;
      <D.23748>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23750>; else goto <D.23751>;
      <D.23750>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23752 = monoeg_g_strdup_printf ("Invalid method row %d is (Final, NewSlot or Strict) but not Virtual", i);
        vinfo->info.message = D.23752;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23753 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23753;
      }
      <D.23751>:
      ctx->valid = 0;
      return;
      <D.23749>:
      <D.23747>:
      D.23680 = flags & 8192;
      if (D.23680 != 0) goto <D.23754>; else goto <D.23755>;
      <D.23754>:
      D.23694 = flags & 64;
      if (D.23694 != 0) goto <D.23756>; else goto <D.23757>;
      <D.23756>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23758>; else goto <D.23759>;
      <D.23758>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23760 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i);
        vinfo->info.message = D.23760;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23761 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23761;
      }
      <D.23759>:
      ctx->valid = 0;
      return;
      <D.23757>:
      D.23667 = flags & 16;
      if (D.23667 == 0) goto <D.23762>; else goto <D.23763>;
      <D.23762>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23764>; else goto <D.23765>;
      <D.23764>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23766 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i);
        vinfo->info.message = D.23766;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23767 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23767;
      }
      <D.23765>:
      ctx->valid = 0;
      return;
      <D.23763>:
      <D.23755>:
      D.23677 = flags & 1024;
      D.23768 = D.23677 | rva;
      if (D.23768 == 0) goto <D.23769>; else goto <D.23770>;
      <D.23769>:
      D.23680 = flags & 8192;
      if (D.23680 == 0) goto <D.23771>; else goto <D.23772>;
      <D.23771>:
      D.23773 = implflags & 4096;
      if (D.23773 == 0) goto <D.23774>; else goto <D.23775>;
      <D.23774>:
      if (code_type != 3) goto <D.23776>; else goto <D.23777>;
      <D.23776>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23778>; else goto <D.23779>;
      <D.23778>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23780 = monoeg_g_strdup_printf ("Invalid method row %d is not Abstract and neither PinvokeImpl, Runtime, InternalCall or with RVA != 0", i);
        vinfo->info.message = D.23780;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23781 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23781;
      }
      <D.23779>:
      ctx->valid = 0;
      return;
      <D.23777>:
      <D.23775>:
      <D.23772>:
      <D.23770>:
      D.23782 = access | rva;
      if (D.23782 == 0) goto <D.23783>; else goto <D.23784>;
      <D.23783>:
      D.23680 = flags & 8192;
      if (D.23680 == 0) goto <D.23785>; else goto <D.23786>;
      <D.23785>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23787>; else goto <D.23788>;
      <D.23787>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23789 = monoeg_g_strdup_printf ("Invalid method row %d is CompilerControlled but neither RVA != 0 or PinvokeImpl", i);
        vinfo->info.message = D.23789;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23790 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23790;
      }
      <D.23788>:
      ctx->valid = 0;
      return;
      <D.23786>:
      <D.23784>:
      if (rva != 0) goto <D.23791>; else goto <D.23792>;
      <D.23791>:
      D.23795 = flags & 9216;
      if (D.23795 != 0) goto <D.23793>; else goto <D.23796>;
      <D.23796>:
      D.23773 = implflags & 4096;
      if (D.23773 != 0) goto <D.23793>; else goto <D.23794>;
      <D.23793>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23797>; else goto <D.23798>;
      <D.23797>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23799 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is either Abstract, InternalCall or PinvokeImpl", i);
        vinfo->info.message = D.23799;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23800 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23800;
      }
      <D.23798>:
      ctx->valid = 0;
      return;
      <D.23794>:
      if (code_type == 2) goto <D.23801>; else goto <D.23802>;
      <D.23801>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23803>; else goto <D.23804>;
      <D.23803>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23805 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is CodeTypeMask is neither Native, CIL or Runtime", i);
        vinfo->info.message = D.23805;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23806 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23806;
      }
      <D.23804>:
      ctx->valid = 0;
      return;
      <D.23802>:
      goto <D.23807>;
      <D.23792>:
      D.23795 = flags & 9216;
      if (D.23795 == 0) goto <D.23808>; else goto <D.23809>;
      <D.23808>:
      D.23773 = implflags & 4096;
      if (D.23773 == 0) goto <D.23810>; else goto <D.23811>;
      <D.23810>:
      if (code_type != 3) goto <D.23812>; else goto <D.23813>;
      <D.23812>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23814>; else goto <D.23815>;
      <D.23814>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23816 = monoeg_g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i);
        vinfo->info.message = D.23816;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23817 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23817;
      }
      <D.23815>:
      ctx->valid = 0;
      return;
      <D.23813>:
      <D.23811>:
      <D.23809>:
      <D.23807>:
      D.23680 = flags & 8192;
      if (D.23680 != 0) goto <D.23818>; else goto <D.23819>;
      <D.23818>:
      if (rva != 0) goto <D.23820>; else goto <D.23821>;
      <D.23820>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23822>; else goto <D.23823>;
      <D.23822>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23824 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has RVA != 0", i);
        vinfo->info.message = D.23824;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23825 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23825;
      }
      <D.23823>:
      ctx->valid = 0;
      return;
      <D.23821>:
      i.44 = (unsigned int) i;
      D.23826 = make_coded_token (56, 6, i.44);
      D.23827 = search_sorted_table (ctx, 28, 1, D.23826);
      if (D.23827 == -1) goto <D.23828>; else goto <D.23829>;
      <D.23828>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23830>; else goto <D.23831>;
      <D.23830>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23832 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has no row in the ImplMap table", i);
        vinfo->info.message = D.23832;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23833 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23833;
      }
      <D.23831>:
      ctx->valid = 0;
      return;
      <D.23829>:
      <D.23819>:
      D.23834 = flags & 4096;
      if (D.23834 != 0) goto <D.23835>; else goto <D.23836>;
      <D.23835>:
      D.23655 = is_ctor | is_cctor;
      if (D.23655 == 0) goto <D.23837>; else goto <D.23838>;
      <D.23837>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23839>; else goto <D.23840>;
      <D.23839>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23841 = monoeg_g_strdup_printf ("Invalid method row %d is RtSpecialName but not named .ctor or .cctor", i);
        vinfo->info.message = D.23841;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23842 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23842;
      }
      <D.23840>:
      ctx->valid = 0;
      return;
      <D.23838>:
      <D.23836>:
      D.23655 = is_ctor | is_cctor;
      if (D.23655 != 0) goto <D.23843>; else goto <D.23844>;
      <D.23843>:
      D.23834 = flags & 4096;
      if (D.23834 == 0) goto <D.23845>; else goto <D.23846>;
      <D.23845>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23847>; else goto <D.23848>;
      <D.23847>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23849 = monoeg_g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i);
        vinfo->info.message = D.23849;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23850 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23850;
      }
      <D.23848>:
      ctx->valid = 0;
      return;
      <D.23846>:
      <D.23844>:
      D.23851 = data[4];
      if (D.23851 != 0) goto <D.23852>; else goto <D.23853>;
      <D.23852>:
      D.23851 = data[4];
      D.23854 = is_valid_blob_object (ctx, D.23851, 1);
      if (D.23854 == 0) goto <D.23855>; else goto <D.23856>;
      <D.23855>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23857>; else goto <D.23858>;
      <D.23857>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23851 = data[4];
        D.23859 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, D.23851);
        vinfo->info.message = D.23859;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23860 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23860;
      }
      <D.23858>:
      ctx->valid = 0;
      return;
      <D.23856>:
      <D.23853>:
      D.23861 = data[5];
      if (D.23861 == 0) goto <D.23862>; else goto <D.23863>;
      <D.23862>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23864>; else goto <D.23865>;
      <D.23864>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23866 = monoeg_g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i);
        vinfo->info.message = D.23866;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23867 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23867;
      }
      <D.23865>:
      ctx->valid = 0;
      return;
      <D.23863>:
      D.23861 = data[5];
      if (D.23861 < paramlist) goto <D.23868>; else goto <D.23869>;
      <D.23868>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23870>; else goto <D.23871>;
      <D.23870>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23861 = data[5];
        D.23872 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.23861, paramlist);
        vinfo->info.message = D.23872;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23873 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23873;
      }
      <D.23871>:
      ctx->valid = 0;
      return;
      <D.23869>:
      D.23861 = data[5];
      D.23544 = ctx->image;
      D.23874 = D.23544->tables[8].rows;
      D.23875 = (int) D.23874;
      D.23876 = D.23875 + 1;
      D.23877 = (unsigned int) D.23876;
      if (D.23861 > D.23877) goto <D.23878>; else goto <D.23879>;
      <D.23878>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23880>; else goto <D.23881>;
      <D.23880>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23861 = data[5];
        D.23882 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x is out of range", i, D.23861);
        vinfo->info.message = D.23882;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23883 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23883;
      }
      <D.23881>:
      ctx->valid = 0;
      return;
      <D.23879>:
      paramlist = data[5];
      i = i + 1;
      <D.21081>:
      D.23884 = table->rows;
      D.23885 = (int) D.23884;
      if (D.23885 > i) goto <D.21080>; else goto <D.21082>;
      <D.21082>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


get_string_ptr (struct VerifyContext * ctx, guint offset)
{
  const char * D.23889;
  struct MonoImage * D.23890;
  const char * D.23891;

  D.23890 = ctx->image;
  D.23891 = D.23890->heap_strings.data;
  D.23889 = D.23891 + offset;
  return D.23889;
}


verify_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23893;
  unsigned int D.23894;
  unsigned int D.23895;
  <unnamed-unsigned:24> D.23898;
  int D.23899;
  int D.23902;
  gchar * D.23905;
  struct GSList * D.23906;
  struct GSList * D.23907;
  unsigned int D.23908;
  gchar * D.23913;
  struct GSList * D.23914;
  unsigned int i.45;
  unsigned int D.23916;
  int D.23917;
  unsigned int D.23920;
  gchar * D.23925;
  struct GSList * D.23926;
  gchar * D.23932;
  struct GSList * D.23933;
  unsigned int D.23934;
  unsigned int D.23937;
  int D.23938;
  gchar * D.23943;
  struct GSList * D.23944;
  unsigned int D.23945;
  int D.23946;
  gchar * D.23951;
  struct GSList * D.23952;
  unsigned int D.23955;
  gchar * D.23960;
  struct GSList * D.23961;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 sequence;
  guint32 remaining_params;
  guint32 current_method;
  gboolean first_param;
  int i;

  try
    {
      D.23893 = ctx->image;
      table = &D.23893->tables[8];
      sequence = 0;
      current_method = 0;
      first_param = 1;
      D.23893 = ctx->image;
      D.23894 = BIT_FIELD_REF <*D.23893, 32, 1408>;
      D.23895 = D.23894 & 16777215;
      if (D.23895 == 0) goto <D.23896>; else goto <D.23897>;
      <D.23896>:
      D.23898 = table->rows;
      D.23899 = (int) D.23898;
      if (D.23899 > 0) goto <D.23900>; else goto <D.23901>;
      <D.23900>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23903>; else goto <D.23904>;
      <D.23903>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23905 = monoeg_strdup ("Param table has rows while the method table has zero");
        vinfo->info.message = D.23905;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23907 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23907;
      }
      <D.23904>:
      ctx->valid = 0;
      return;
      <D.23901>:
      return;
      <D.23897>:
      remaining_params = get_next_param_count (ctx, &current_method);
      i = 0;
      goto <D.21126>;
      <D.21125>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.23908 = flags & 53228;
      if (D.23908 != 0) goto <D.23909>; else goto <D.23910>;
      <D.23909>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23911>; else goto <D.23912>;
      <D.23911>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23913 = monoeg_g_strdup_printf ("Invalid param row %d bad Flags value 0x%08x", i, flags);
        vinfo->info.message = D.23913;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23914 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23914;
      }
      <D.23912>:
      ctx->valid = 0;
      return;
      <D.23910>:
      i.45 = (unsigned int) i;
      D.23916 = make_coded_token (5, 8, i.45);
      D.23917 = search_sorted_table (ctx, 11, 2, D.23916);
      if (D.23917 == -1) goto <D.23918>; else goto <D.23919>;
      <D.23918>:
      D.23920 = flags & 4096;
      if (D.23920 != 0) goto <D.23921>; else goto <D.23922>;
      <D.23921>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23923>; else goto <D.23924>;
      <D.23923>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23925 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 1 but no owned row in Contant table", i);
        vinfo->info.message = D.23925;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23926 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23926;
      }
      <D.23924>:
      ctx->valid = 0;
      return;
      <D.23922>:
      goto <D.23927>;
      <D.23919>:
      D.23920 = flags & 4096;
      if (D.23920 == 0) goto <D.23928>; else goto <D.23929>;
      <D.23928>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23930>; else goto <D.23931>;
      <D.23930>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23932 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 0 but has owned row in Contant table", i);
        vinfo->info.message = D.23932;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23933 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23933;
      }
      <D.23931>:
      ctx->valid = 0;
      return;
      <D.23929>:
      <D.23927>:
      D.23934 = flags & 8192;
      if (D.23934 != 0) goto <D.23935>; else goto <D.23936>;
      <D.23935>:
      i.45 = (unsigned int) i;
      D.23937 = make_coded_token (32, 8, i.45);
      D.23938 = search_sorted_table (ctx, 13, 0, D.23937);
      if (D.23938 == -1) goto <D.23939>; else goto <D.23940>;
      <D.23939>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23941>; else goto <D.23942>;
      <D.23941>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23943 = monoeg_g_strdup_printf ("Invalid param row %d HasFieldMarshal = 1 but no owned row in FieldMarshal table", i);
        vinfo->info.message = D.23943;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23944 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23944;
      }
      <D.23942>:
      ctx->valid = 0;
      return;
      <D.23940>:
      <D.23936>:
      D.23945 = data[2];
      D.23946 = is_valid_string (ctx, D.23945);
      if (D.23946 == 0) goto <D.23947>; else goto <D.23948>;
      <D.23947>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23949>; else goto <D.23950>;
      <D.23949>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23945 = data[2];
        D.23951 = monoeg_g_strdup_printf ("Invalid param row %d Name = 1 bad token 0x%08x", i, D.23945);
        vinfo->info.message = D.23951;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23952 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23952;
      }
      <D.23950>:
      ctx->valid = 0;
      return;
      <D.23948>:
      if (first_param == 0) goto <D.23953>; else goto <D.23954>;
      <D.23953>:
      D.23955 = data[1];
      if (D.23955 <= sequence) goto <D.23956>; else goto <D.23957>;
      <D.23956>:
      D.23902 = ctx->report_error;
      if (D.23902 != 0) goto <D.23958>; else goto <D.23959>;
      <D.23958>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23955 = data[1];
        D.23960 = monoeg_g_strdup_printf ("Invalid param row %d sequece = %d previus param has %d", i, D.23955, sequence);
        vinfo->info.message = D.23960;
        vinfo->exception_type = 3;
        D.23906 = ctx->errors;
        D.23961 = monoeg_g_slist_prepend (D.23906, vinfo);
        ctx->errors = D.23961;
      }
      <D.23959>:
      ctx->valid = 0;
      return;
      <D.23957>:
      <D.23954>:
      first_param = 0;
      sequence = data[1];
      remaining_params = remaining_params + 4294967295;
      if (remaining_params == 0) goto <D.23962>; else goto <D.23963>;
      <D.23962>:
      remaining_params = get_next_param_count (ctx, &current_method);
      first_param = 1;
      <D.23963>:
      i = i + 1;
      <D.21126>:
      D.23898 = table->rows;
      D.23899 = (int) D.23898;
      if (D.23899 > i) goto <D.21125>; else goto <D.21127>;
      <D.21127>:
    }
  finally
    {
      data = {CLOBBER};
      current_method = {CLOBBER};
    }
}


is_valid_string (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.23967;

  D.23967 = is_valid_string_full (ctx, offset, 1);
  return D.23967;
}


get_next_param_count (struct VerifyContext * ctx, guint32 * current_method)
{
  struct MonoImage * D.23969;
  unsigned int row.46;
  int row.47;
  int row.48;
  guint32 D.23975;
  <unnamed-unsigned:24> D.23976;
  unsigned int D.23977;
  struct MonoTableInfo * table;
  guint32 row;
  guint32 paramlist;
  guint32 tmp;

  D.23969 = ctx->image;
  table = &D.23969->tables[6];
  row = *current_method;
  row.46 = row;
  row = row.46 + 1;
  row.47 = (int) row.46;
  paramlist = mono_metadata_decode_row_col (table, row.47, 5);
  goto <D.21105>;
  <D.21104>:
  row.48 = (int) row;
  tmp = mono_metadata_decode_row_col (table, row.48, 5);
  if (tmp > paramlist) goto <D.23973>; else goto <D.23974>;
  <D.23973>:
  *current_method = row;
  D.23975 = tmp - paramlist;
  return D.23975;
  <D.23974>:
  row = row + 1;
  <D.21105>:
  D.23976 = table->rows;
  D.23977 = (unsigned int) D.23976;
  if (D.23977 > row) goto <D.21104>; else goto <D.21106>;
  <D.21106>:
  D.23976 = table->rows;
  D.23977 = (unsigned int) D.23976;
  *current_method = D.23977;
  D.23975 = 4294967295;
  return D.23975;
}


verify_interfaceimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23979;
  unsigned int D.23980;
  <unnamed-unsigned:24> D.23983;
  unsigned int D.23984;
  int D.23987;
  gchar * D.23990;
  struct GSList * D.23991;
  struct GSList * D.23992;
  unsigned int D.23993;
  int D.23994;
  gchar * D.23999;
  struct GSList * D.24000;
  unsigned int D.24001;
  gchar * D.24006;
  struct GSList * D.24007;
  <unnamed-unsigned:24> D.24008;
  int D.24009;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23979 = ctx->image;
      table = &D.23979->tables[9];
      i = 0;
      goto <D.21138>;
      <D.21137>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23980 = data[0];
      if (D.23980 != 0) goto <D.23981>; else goto <D.23982>;
      <D.23981>:
      D.23980 = data[0];
      D.23979 = ctx->image;
      D.23983 = D.23979->tables[2].rows;
      D.23984 = (unsigned int) D.23983;
      if (D.23980 > D.23984) goto <D.23985>; else goto <D.23986>;
      <D.23985>:
      D.23987 = ctx->report_error;
      if (D.23987 != 0) goto <D.23988>; else goto <D.23989>;
      <D.23988>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23980 = data[0];
        D.23990 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Class field 0x%08x", i, D.23980);
        vinfo->info.message = D.23990;
        vinfo->exception_type = 3;
        D.23991 = ctx->errors;
        D.23992 = monoeg_g_slist_prepend (D.23991, vinfo);
        ctx->errors = D.23992;
      }
      <D.23989>:
      ctx->valid = 0;
      return;
      <D.23986>:
      <D.23982>:
      D.23993 = data[1];
      D.23994 = is_valid_coded_index (ctx, 0, D.23993);
      if (D.23994 == 0) goto <D.23995>; else goto <D.23996>;
      <D.23995>:
      D.23987 = ctx->report_error;
      if (D.23987 != 0) goto <D.23997>; else goto <D.23998>;
      <D.23997>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.23993 = data[1];
        D.23999 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field coded index 0x%08x", i, D.23993);
        vinfo->info.message = D.23999;
        vinfo->exception_type = 3;
        D.23991 = ctx->errors;
        D.24000 = monoeg_g_slist_prepend (D.23991, vinfo);
        ctx->errors = D.24000;
      }
      <D.23998>:
      ctx->valid = 0;
      return;
      <D.23996>:
      D.23993 = data[1];
      D.24001 = get_coded_index_token (0, D.23993);
      if (D.24001 == 0) goto <D.24002>; else goto <D.24003>;
      <D.24002>:
      D.23987 = ctx->report_error;
      if (D.23987 != 0) goto <D.24004>; else goto <D.24005>;
      <D.24004>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24006 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field is null", i);
        vinfo->info.message = D.24006;
        vinfo->exception_type = 3;
        D.23991 = ctx->errors;
        D.24007 = monoeg_g_slist_prepend (D.23991, vinfo);
        ctx->errors = D.24007;
      }
      <D.24005>:
      ctx->valid = 0;
      return;
      <D.24003>:
      i = i + 1;
      <D.21138>:
      D.24008 = table->rows;
      D.24009 = (int) D.24008;
      if (D.24009 > i) goto <D.21137>; else goto <D.21139>;
      <D.21139>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_memberref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24013;
  unsigned int D.24014;
  int D.24015;
  int D.24018;
  gchar * D.24021;
  struct GSList * D.24022;
  struct GSList * D.24023;
  unsigned int D.24024;
  gchar * D.24029;
  struct GSList * D.24030;
  unsigned int D.24031;
  int D.24032;
  gchar * D.24037;
  struct GSList * D.24038;
  unsigned int D.24039;
  int D.24042;
  gchar * D.24047;
  struct GSList * D.24048;
  <unnamed-unsigned:24> D.24049;
  int D.24050;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24013 = ctx->image;
      table = &D.24013->tables[10];
      i = 0;
      goto <D.21151>;
      <D.21150>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24014 = data[0];
      D.24015 = is_valid_coded_index (ctx, 41, D.24014);
      if (D.24015 == 0) goto <D.24016>; else goto <D.24017>;
      <D.24016>:
      D.24018 = ctx->report_error;
      if (D.24018 != 0) goto <D.24019>; else goto <D.24020>;
      <D.24019>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24014 = data[0];
        D.24021 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded index 0x%08x", i, D.24014);
        vinfo->info.message = D.24021;
        vinfo->exception_type = 3;
        D.24022 = ctx->errors;
        D.24023 = monoeg_g_slist_prepend (D.24022, vinfo);
        ctx->errors = D.24023;
      }
      <D.24020>:
      ctx->valid = 0;
      return;
      <D.24017>:
      D.24014 = data[0];
      D.24024 = get_coded_index_token (41, D.24014);
      if (D.24024 == 0) goto <D.24025>; else goto <D.24026>;
      <D.24025>:
      D.24018 = ctx->report_error;
      if (D.24018 != 0) goto <D.24027>; else goto <D.24028>;
      <D.24027>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24029 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded is null", i);
        vinfo->info.message = D.24029;
        vinfo->exception_type = 3;
        D.24022 = ctx->errors;
        D.24030 = monoeg_g_slist_prepend (D.24022, vinfo);
        ctx->errors = D.24030;
      }
      <D.24028>:
      ctx->valid = 0;
      return;
      <D.24026>:
      D.24031 = data[1];
      D.24032 = is_valid_non_empty_string (ctx, D.24031);
      if (D.24032 == 0) goto <D.24033>; else goto <D.24034>;
      <D.24033>:
      D.24018 = ctx->report_error;
      if (D.24018 != 0) goto <D.24035>; else goto <D.24036>;
      <D.24035>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24031 = data[1];
        D.24037 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, D.24031);
        vinfo->info.message = D.24037;
        vinfo->exception_type = 3;
        D.24022 = ctx->errors;
        D.24038 = monoeg_g_slist_prepend (D.24022, vinfo);
        ctx->errors = D.24038;
      }
      <D.24036>:
      ctx->valid = 0;
      return;
      <D.24034>:
      D.24039 = data[2];
      if (D.24039 != 0) goto <D.24040>; else goto <D.24041>;
      <D.24040>:
      D.24039 = data[2];
      D.24042 = is_valid_blob_object (ctx, D.24039, 1);
      if (D.24042 == 0) goto <D.24043>; else goto <D.24044>;
      <D.24043>:
      D.24018 = ctx->report_error;
      if (D.24018 != 0) goto <D.24045>; else goto <D.24046>;
      <D.24045>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24039 = data[2];
        D.24047 = monoeg_g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, D.24039);
        vinfo->info.message = D.24047;
        vinfo->exception_type = 3;
        D.24022 = ctx->errors;
        D.24048 = monoeg_g_slist_prepend (D.24022, vinfo);
        ctx->errors = D.24048;
      }
      <D.24046>:
      ctx->valid = 0;
      return;
      <D.24044>:
      <D.24041>:
      i = i + 1;
      <D.21151>:
      D.24049 = table->rows;
      D.24050 = (int) D.24049;
      if (D.24050 > i) goto <D.21150>; else goto <D.21152>;
      <D.21152>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_constant_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24054;
  unsigned int D.24055;
  _Bool D.24056;
  _Bool D.24057;
  _Bool D.24058;
  int D.24061;
  gchar * D.24064;
  struct GSList * D.24065;
  struct GSList * D.24066;
  unsigned int D.24067;
  int D.24068;
  gchar * D.24073;
  struct GSList * D.24074;
  unsigned int D.24075;
  gchar * D.24080;
  struct GSList * D.24081;
  unsigned int D.24082;
  int D.24083;
  gchar * D.24088;
  struct GSList * D.24089;
  <unnamed-unsigned:24> D.24090;
  int D.24091;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 type;
  int i;

  try
    {
      D.24054 = ctx->image;
      table = &D.24054->tables[11];
      i = 0;
      goto <D.21175>;
      <D.21174>:
      mono_metadata_decode_row (table, i, &data, 4);
      type = data[0];
      D.24055 = type + 4294967294;
      D.24056 = D.24055 > 12;
      D.24057 = type != 18;
      D.24058 = D.24056 & D.24057;
      if (D.24058 != 0) goto <D.24059>; else goto <D.24060>;
      <D.24059>:
      D.24061 = ctx->report_error;
      if (D.24061 != 0) goto <D.24062>; else goto <D.24063>;
      <D.24062>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24064 = monoeg_g_strdup_printf ("Invalid Constant row %d Type field 0x%08x", i, type);
        vinfo->info.message = D.24064;
        vinfo->exception_type = 3;
        D.24065 = ctx->errors;
        D.24066 = monoeg_g_slist_prepend (D.24065, vinfo);
        ctx->errors = D.24066;
      }
      <D.24063>:
      ctx->valid = 0;
      return;
      <D.24060>:
      D.24067 = data[2];
      D.24068 = is_valid_coded_index (ctx, 5, D.24067);
      if (D.24068 == 0) goto <D.24069>; else goto <D.24070>;
      <D.24069>:
      D.24061 = ctx->report_error;
      if (D.24061 != 0) goto <D.24071>; else goto <D.24072>;
      <D.24071>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24067 = data[2];
        D.24073 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded index 0x%08x", i, D.24067);
        vinfo->info.message = D.24073;
        vinfo->exception_type = 3;
        D.24065 = ctx->errors;
        D.24074 = monoeg_g_slist_prepend (D.24065, vinfo);
        ctx->errors = D.24074;
      }
      <D.24072>:
      ctx->valid = 0;
      return;
      <D.24070>:
      D.24067 = data[2];
      D.24075 = get_coded_index_token (5, D.24067);
      if (D.24075 == 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      D.24061 = ctx->report_error;
      if (D.24061 != 0) goto <D.24078>; else goto <D.24079>;
      <D.24078>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24080 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded is null", i);
        vinfo->info.message = D.24080;
        vinfo->exception_type = 3;
        D.24065 = ctx->errors;
        D.24081 = monoeg_g_slist_prepend (D.24065, vinfo);
        ctx->errors = D.24081;
      }
      <D.24079>:
      ctx->valid = 0;
      return;
      <D.24077>:
      D.24082 = data[3];
      D.24083 = is_valid_constant (ctx, type, D.24082);
      if (D.24083 == 0) goto <D.24084>; else goto <D.24085>;
      <D.24084>:
      D.24061 = ctx->report_error;
      if (D.24061 != 0) goto <D.24086>; else goto <D.24087>;
      <D.24086>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24082 = data[3];
        D.24088 = monoeg_g_strdup_printf ("Invalid Constant row %d Value field 0x%08x", i, D.24082);
        vinfo->info.message = D.24088;
        vinfo->exception_type = 3;
        D.24065 = ctx->errors;
        D.24089 = monoeg_g_slist_prepend (D.24065, vinfo);
        ctx->errors = D.24089;
      }
      <D.24087>:
      ctx->valid = 0;
      return;
      <D.24085>:
      i = i + 1;
      <D.21175>:
      D.24090 = table->rows;
      D.24091 = (int) D.24090;
      if (D.24091 > i) goto <D.21174>; else goto <D.21176>;
      <D.21176>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_constant (struct VerifyContext * ctx, guint32 type, guint32 offset)
{
  struct MonoImage * D.24095;
  struct MonoStreamHeader * D.24096;
  unsigned int D.24097;
  int D.24100;
  gchar * D.24103;
  struct GSList * D.24104;
  struct GSList * D.24105;
  gboolean D.24106;
  const char * D.24107;
  unsigned int D.24108;
  sizetype D.24109;
  const char * D.24110;
  unsigned int D.24111;
  int D.24112;
  gchar * D.24117;
  struct GSList * D.24118;
  unsigned int bytes.49;
  unsigned int entry_size.50;
  unsigned int D.24125;
  unsigned int D.24127;
  unsigned int D.24130;
  unsigned int D.24131;
  gchar * D.24132;
  struct GSList * D.24133;
  gchar * D.24138;
  struct GSList * D.24139;
  unsigned int D.24142;
  unsigned int D.24144;
  gchar * D.24147;
  struct GSList * D.24148;
  unsigned int D.24151;
  gchar * D.24156;
  struct GSList * D.24157;
  struct OffsetAndSize blob;
  guint32 size;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.24095 = ctx->image;
      D.24096 = &D.24095->heap_blob;
      blob = get_metadata_stream (ctx, D.24096); [return slot optimization]
      D.24097 = blob.size;
      if (D.24097 < offset) goto <D.24098>; else goto <D.24099>;
      <D.24098>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24101>; else goto <D.24102>;
      <D.24101>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24103 = monoeg_strdup ("ContantValue: invalid offset");
        vinfo->info.message = D.24103;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24105 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24105;
      }
      <D.24102>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24099>:
      D.24107 = ctx->data;
      D.24108 = blob.offset;
      D.24109 = D.24108 + offset;
      D.24110 = D.24107 + D.24109;
      D.24097 = blob.size;
      D.24108 = blob.offset;
      D.24111 = D.24097 - D.24108;
      D.24112 = decode_value (D.24110, D.24111, &entry_size, &bytes);
      if (D.24112 == 0) goto <D.24113>; else goto <D.24114>;
      <D.24113>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24115>; else goto <D.24116>;
      <D.24115>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24117 = monoeg_strdup ("ContantValue: not enough space to decode size");
        vinfo->info.message = D.24117;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24118 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24118;
      }
      <D.24116>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24114>:
      if (type == 14) goto <D.24119>; else goto <D.24120>;
      <D.24119>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      entry_size.50 = entry_size;
      D.24125 = offset + entry_size.50;
      D.24097 = blob.size;
      if (D.24125 > D.24097) goto <D.24122>; else goto <D.24126>;
      <D.24126>:
      entry_size.50 = entry_size;
      D.24127 = ~entry_size.50;
      if (D.24127 < offset) goto <D.24122>; else goto <D.24123>;
      <D.24122>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24128>; else goto <D.24129>;
      <D.24128>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        entry_size.50 = entry_size;
        D.24130 = entry_size.50 * 2;
        D.24097 = blob.size;
        D.24131 = D.24097 - offset;
        D.24132 = monoeg_g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", D.24130, D.24131);
        vinfo->info.message = D.24132;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24133 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24133;
      }
      <D.24129>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24123>:
      D.24106 = 1;
      return D.24106;
      <D.24120>:
      switch (type) <default: <D.20860>, case 2: <D.20846>, case 3: <D.20850>, case 4: <D.20847>, case 5: <D.20848>, case 6: <D.20851>, case 7: <D.20852>, case 8: <D.20853>, case 9: <D.20854>, case 10: <D.20857>, case 11: <D.20858>, case 12: <D.20855>, case 13: <D.20859>, case 18: <D.20856>>
      <D.20846>:
      <D.20847>:
      <D.20848>:
      size = 1;
      goto <D.20849>;
      <D.20850>:
      <D.20851>:
      <D.20852>:
      size = 2;
      goto <D.20849>;
      <D.20853>:
      <D.20854>:
      <D.20855>:
      <D.20856>:
      size = 4;
      goto <D.20849>;
      <D.20857>:
      <D.20858>:
      <D.20859>:
      size = 8;
      goto <D.20849>;
      <D.20860>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 2221);
      <D.20849>:
      entry_size.50 = entry_size;
      if (size != entry_size.50) goto <D.24134>; else goto <D.24135>;
      <D.24134>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24136>; else goto <D.24137>;
      <D.24136>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        entry_size.50 = entry_size;
        D.24138 = monoeg_g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size.50);
        vinfo->info.message = D.24138;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24139 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24139;
      }
      <D.24137>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24135>:
      bytes.49 = bytes;
      offset = offset + bytes.49;
      D.24142 = offset + size;
      D.24097 = blob.size;
      if (D.24142 > D.24097) goto <D.24140>; else goto <D.24143>;
      <D.24143>:
      D.24144 = ~size;
      if (D.24144 < offset) goto <D.24140>; else goto <D.24141>;
      <D.24140>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24145>; else goto <D.24146>;
      <D.24145>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24097 = blob.size;
        D.24131 = D.24097 - offset;
        D.24147 = monoeg_g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, D.24131);
        vinfo->info.message = D.24147;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24148 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24148;
      }
      <D.24146>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24141>:
      if (type == 18) goto <D.24149>; else goto <D.24150>;
      <D.24149>:
      D.24107 = ctx->data;
      D.24108 = blob.offset;
      D.24109 = D.24108 + offset;
      D.24110 = D.24107 + D.24109;
      D.24151 = mono_read32 (D.24110);
      if (D.24151 != 0) goto <D.24152>; else goto <D.24153>;
      <D.24152>:
      D.24100 = ctx->report_error;
      if (D.24100 != 0) goto <D.24154>; else goto <D.24155>;
      <D.24154>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24156 = monoeg_g_strdup_printf ("ContantValue: Type is class but value is not null");
        vinfo->info.message = D.24156;
        vinfo->exception_type = 3;
        D.24104 = ctx->errors;
        D.24157 = monoeg_g_slist_prepend (D.24104, vinfo);
        ctx->errors = D.24157;
      }
      <D.24155>:
      ctx->valid = 0;
      D.24106 = 0;
      return D.24106;
      <D.24153>:
      <D.24150>:
      D.24106 = 1;
      return D.24106;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


verify_cattr_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24160;
  unsigned int D.24161;
  int D.24162;
  int D.24165;
  gchar * D.24168;
  struct GSList * D.24169;
  struct GSList * D.24170;
  unsigned int D.24173;
  int D.24174;
  unsigned int D.24176;
  gchar * D.24179;
  struct GSList * D.24180;
  unsigned int D.24181;
  int D.24184;
  gchar * D.24189;
  struct GSList * D.24190;
  <unnamed-unsigned:24> D.24191;
  int D.24192;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24160 = ctx->image;
      table = &D.24160->tables[12];
      i = 0;
      goto <D.21187>;
      <D.21186>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24161 = data[0];
      D.24162 = is_valid_coded_index (ctx, 10, D.24161);
      if (D.24162 == 0) goto <D.24163>; else goto <D.24164>;
      <D.24163>:
      D.24165 = ctx->report_error;
      if (D.24165 != 0) goto <D.24166>; else goto <D.24167>;
      <D.24166>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24161 = data[0];
        D.24168 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, D.24161);
        vinfo->info.message = D.24168;
        vinfo->exception_type = 3;
        D.24169 = ctx->errors;
        D.24170 = monoeg_g_slist_prepend (D.24169, vinfo);
        ctx->errors = D.24170;
      }
      <D.24167>:
      ctx->valid = 0;
      return;
      <D.24164>:
      D.24173 = data[1];
      D.24174 = is_valid_coded_index (ctx, 65, D.24173);
      if (D.24174 == 0) goto <D.24171>; else goto <D.24175>;
      <D.24175>:
      D.24173 = data[1];
      D.24176 = get_coded_index_token (65, D.24173);
      if (D.24176 == 0) goto <D.24171>; else goto <D.24172>;
      <D.24171>:
      D.24165 = ctx->report_error;
      if (D.24165 != 0) goto <D.24177>; else goto <D.24178>;
      <D.24177>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24173 = data[1];
        D.24179 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Type field 0x%08x", i, D.24173);
        vinfo->info.message = D.24179;
        vinfo->exception_type = 3;
        D.24169 = ctx->errors;
        D.24180 = monoeg_g_slist_prepend (D.24169, vinfo);
        ctx->errors = D.24180;
      }
      <D.24178>:
      ctx->valid = 0;
      return;
      <D.24172>:
      D.24181 = data[2];
      if (D.24181 != 0) goto <D.24182>; else goto <D.24183>;
      <D.24182>:
      D.24181 = data[2];
      D.24184 = is_valid_blob_object (ctx, D.24181, 0);
      if (D.24184 == 0) goto <D.24185>; else goto <D.24186>;
      <D.24185>:
      D.24165 = ctx->report_error;
      if (D.24165 != 0) goto <D.24187>; else goto <D.24188>;
      <D.24187>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24181 = data[2];
        D.24189 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, D.24181);
        vinfo->info.message = D.24189;
        vinfo->exception_type = 3;
        D.24169 = ctx->errors;
        D.24190 = monoeg_g_slist_prepend (D.24169, vinfo);
        ctx->errors = D.24190;
      }
      <D.24188>:
      ctx->valid = 0;
      return;
      <D.24186>:
      <D.24183>:
      i = i + 1;
      <D.21187>:
      D.24191 = table->rows;
      D.24192 = (int) D.24191;
      if (D.24192 > i) goto <D.21186>; else goto <D.21188>;
      <D.21188>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_marshal_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24196;
  unsigned int D.24197;
  int D.24198;
  int D.24201;
  gchar * D.24204;
  struct GSList * D.24205;
  struct GSList * D.24206;
  unsigned int D.24207;
  gchar * D.24212;
  struct GSList * D.24213;
  unsigned int D.24214;
  gchar * D.24219;
  struct GSList * D.24220;
  int D.24221;
  gchar * D.24226;
  struct GSList * D.24227;
  <unnamed-unsigned:24> D.24228;
  int D.24229;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24196 = ctx->image;
      table = &D.24196->tables[13];
      i = 0;
      goto <D.21220>;
      <D.21219>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24197 = data[0];
      D.24198 = is_valid_coded_index (ctx, 32, D.24197);
      if (D.24198 == 0) goto <D.24199>; else goto <D.24200>;
      <D.24199>:
      D.24201 = ctx->report_error;
      if (D.24201 != 0) goto <D.24202>; else goto <D.24203>;
      <D.24202>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24197 = data[0];
        D.24204 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field 0x%08x", i, D.24197);
        vinfo->info.message = D.24204;
        vinfo->exception_type = 3;
        D.24205 = ctx->errors;
        D.24206 = monoeg_g_slist_prepend (D.24205, vinfo);
        ctx->errors = D.24206;
      }
      <D.24203>:
      ctx->valid = 0;
      return;
      <D.24200>:
      D.24197 = data[0];
      D.24207 = get_coded_index_token (32, D.24197);
      if (D.24207 == 0) goto <D.24208>; else goto <D.24209>;
      <D.24208>:
      D.24201 = ctx->report_error;
      if (D.24201 != 0) goto <D.24210>; else goto <D.24211>;
      <D.24210>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24212 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field is null", i);
        vinfo->info.message = D.24212;
        vinfo->exception_type = 3;
        D.24205 = ctx->errors;
        D.24213 = monoeg_g_slist_prepend (D.24205, vinfo);
        ctx->errors = D.24213;
      }
      <D.24211>:
      ctx->valid = 0;
      return;
      <D.24209>:
      D.24214 = data[1];
      if (D.24214 == 0) goto <D.24215>; else goto <D.24216>;
      <D.24215>:
      D.24201 = ctx->report_error;
      if (D.24201 != 0) goto <D.24217>; else goto <D.24218>;
      <D.24217>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24219 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i);
        vinfo->info.message = D.24219;
        vinfo->exception_type = 3;
        D.24205 = ctx->errors;
        D.24220 = monoeg_g_slist_prepend (D.24205, vinfo);
        ctx->errors = D.24220;
      }
      <D.24218>:
      ctx->valid = 0;
      return;
      <D.24216>:
      D.24214 = data[1];
      D.24221 = is_valid_blob_object (ctx, D.24214, 1);
      if (D.24221 == 0) goto <D.24222>; else goto <D.24223>;
      <D.24222>:
      D.24201 = ctx->report_error;
      if (D.24201 != 0) goto <D.24224>; else goto <D.24225>;
      <D.24224>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24214 = data[1];
        D.24226 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, D.24214);
        vinfo->info.message = D.24226;
        vinfo->exception_type = 3;
        D.24205 = ctx->errors;
        D.24227 = monoeg_g_slist_prepend (D.24205, vinfo);
        ctx->errors = D.24227;
      }
      <D.24225>:
      ctx->valid = 0;
      return;
      <D.24223>:
      i = i + 1;
      <D.21220>:
      D.24228 = table->rows;
      D.24229 = (int) D.24228;
      if (D.24229 > i) goto <D.21219>; else goto <D.21221>;
      <D.21221>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_decl_security_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24233;
  unsigned int D.24234;
  int D.24235;
  int D.24238;
  gchar * D.24241;
  struct GSList * D.24242;
  struct GSList * D.24243;
  unsigned int D.24244;
  gchar * D.24249;
  struct GSList * D.24250;
  unsigned int D.24251;
  gchar * D.24256;
  struct GSList * D.24257;
  <unnamed-unsigned:24> D.24258;
  int D.24259;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24233 = ctx->image;
      table = &D.24233->tables[14];
      i = 0;
      goto <D.21242>;
      <D.21241>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24234 = data[1];
      D.24235 = is_valid_coded_index (ctx, 36, D.24234);
      if (D.24235 == 0) goto <D.24236>; else goto <D.24237>;
      <D.24236>:
      D.24238 = ctx->report_error;
      if (D.24238 != 0) goto <D.24239>; else goto <D.24240>;
      <D.24239>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24234 = data[1];
        D.24241 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field 0x%08x", i, D.24234);
        vinfo->info.message = D.24241;
        vinfo->exception_type = 3;
        D.24242 = ctx->errors;
        D.24243 = monoeg_g_slist_prepend (D.24242, vinfo);
        ctx->errors = D.24243;
      }
      <D.24240>:
      ctx->valid = 0;
      return;
      <D.24237>:
      D.24234 = data[1];
      D.24244 = get_coded_index_token (36, D.24234);
      if (D.24244 == 0) goto <D.24245>; else goto <D.24246>;
      <D.24245>:
      D.24238 = ctx->report_error;
      if (D.24238 != 0) goto <D.24247>; else goto <D.24248>;
      <D.24247>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24249 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field is null", i);
        vinfo->info.message = D.24249;
        vinfo->exception_type = 3;
        D.24242 = ctx->errors;
        D.24250 = monoeg_g_slist_prepend (D.24242, vinfo);
        ctx->errors = D.24250;
      }
      <D.24248>:
      ctx->valid = 0;
      return;
      <D.24246>:
      D.24251 = data[2];
      if (D.24251 == 0) goto <D.24252>; else goto <D.24253>;
      <D.24252>:
      D.24238 = ctx->report_error;
      if (D.24238 != 0) goto <D.24254>; else goto <D.24255>;
      <D.24254>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24256 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i);
        vinfo->info.message = D.24256;
        vinfo->exception_type = 3;
        D.24242 = ctx->errors;
        D.24257 = monoeg_g_slist_prepend (D.24242, vinfo);
        ctx->errors = D.24257;
      }
      <D.24255>:
      ctx->valid = 0;
      return;
      <D.24253>:
      i = i + 1;
      <D.21242>:
      D.24258 = table->rows;
      D.24259 = (int) D.24258;
      if (D.24259 > i) goto <D.21241>; else goto <D.21243>;
      <D.21243>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_class_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24263;
  unsigned int D.24266;
  <unnamed-unsigned:24> D.24268;
  int D.24269;
  int D.24270;
  unsigned int D.24271;
  int D.24272;
  gchar * D.24275;
  struct GSList * D.24276;
  struct GSList * D.24277;
  unsigned int D.24278;
  gchar * D.24281;
  struct GSList * D.24282;
  <unnamed-unsigned:24> D.24283;
  int D.24284;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24263 = ctx->image;
      table = &D.24263->tables[15];
      i = 0;
      goto <D.21274>;
      <D.21273>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24266 = data[2];
      if (D.24266 == 0) goto <D.24264>; else goto <D.24267>;
      <D.24267>:
      D.24266 = data[2];
      D.24263 = ctx->image;
      D.24268 = D.24263->tables[2].rows;
      D.24269 = (int) D.24268;
      D.24270 = D.24269 + 1;
      D.24271 = (unsigned int) D.24270;
      if (D.24266 > D.24271) goto <D.24264>; else goto <D.24265>;
      <D.24264>:
      D.24272 = ctx->report_error;
      if (D.24272 != 0) goto <D.24273>; else goto <D.24274>;
      <D.24273>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24266 = data[2];
        D.24275 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Parent field 0x%08x", i, D.24266);
        vinfo->info.message = D.24275;
        vinfo->exception_type = 3;
        D.24276 = ctx->errors;
        D.24277 = monoeg_g_slist_prepend (D.24276, vinfo);
        ctx->errors = D.24277;
      }
      <D.24274>:
      ctx->valid = 0;
      return;
      <D.24265>:
      D.24278 = data[0];
      switch (D.24278) <default: <D.21271>, case 0: <D.21261>, case 1: <D.21262>, case 2: <D.21263>, case 4: <D.21264>, case 8: <D.21265>, case 16: <D.21266>, case 32: <D.21267>, case 64: <D.21268>, case 128: <D.21269>>
      <D.21261>:
      <D.21262>:
      <D.21263>:
      <D.21264>:
      <D.21265>:
      <D.21266>:
      <D.21267>:
      <D.21268>:
      <D.21269>:
      goto <D.21270>;
      <D.21271>:
      D.24272 = ctx->report_error;
      if (D.24272 != 0) goto <D.24279>; else goto <D.24280>;
      <D.24279>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24278 = data[0];
        D.24281 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Packing field %d", i, D.24278);
        vinfo->info.message = D.24281;
        vinfo->exception_type = 3;
        D.24276 = ctx->errors;
        D.24282 = monoeg_g_slist_prepend (D.24276, vinfo);
        ctx->errors = D.24282;
      }
      <D.24280>:
      ctx->valid = 0;
      return;
      <D.21270>:
      i = i + 1;
      <D.21274>:
      D.24283 = table->rows;
      D.24284 = (int) D.24283;
      if (D.24284 > i) goto <D.21273>; else goto <D.21275>;
      <D.21275>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24289;
  unsigned int D.24292;
  <unnamed-unsigned:24> D.24294;
  int D.24295;
  int D.24296;
  unsigned int D.24297;
  int D.24298;
  gchar * D.24301;
  struct GSList * D.24302;
  struct GSList * D.24303;
  <unnamed-unsigned:24> D.24304;
  int D.24305;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24289 = ctx->image;
      table = &D.24289->tables[16];
      i = 0;
      goto <D.21284>;
      <D.21283>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24292 = data[1];
      if (D.24292 == 0) goto <D.24290>; else goto <D.24293>;
      <D.24293>:
      D.24292 = data[1];
      D.24289 = ctx->image;
      D.24294 = D.24289->tables[4].rows;
      D.24295 = (int) D.24294;
      D.24296 = D.24295 + 1;
      D.24297 = (unsigned int) D.24296;
      if (D.24292 > D.24297) goto <D.24290>; else goto <D.24291>;
      <D.24290>:
      D.24298 = ctx->report_error;
      if (D.24298 != 0) goto <D.24299>; else goto <D.24300>;
      <D.24299>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24292 = data[1];
        D.24301 = monoeg_g_strdup_printf ("Invalid FieldLayout row %d Field field 0x%08x", i, D.24292);
        vinfo->info.message = D.24301;
        vinfo->exception_type = 3;
        D.24302 = ctx->errors;
        D.24303 = monoeg_g_slist_prepend (D.24302, vinfo);
        ctx->errors = D.24303;
      }
      <D.24300>:
      ctx->valid = 0;
      return;
      <D.24291>:
      i = i + 1;
      <D.21284>:
      D.24304 = table->rows;
      D.24305 = (int) D.24304;
      if (D.24305 > i) goto <D.21283>; else goto <D.21285>;
      <D.21285>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_standalonesig_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24309;
  unsigned int D.24310;
  int D.24313;
  int D.24316;
  gchar * D.24319;
  struct GSList * D.24320;
  struct GSList * D.24321;
  <unnamed-unsigned:24> D.24322;
  int D.24323;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24309 = ctx->image;
      table = &D.24309->tables[17];
      i = 0;
      goto <D.21294>;
      <D.21293>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24310 = data[0];
      if (D.24310 != 0) goto <D.24311>; else goto <D.24312>;
      <D.24311>:
      D.24310 = data[0];
      D.24313 = is_valid_blob_object (ctx, D.24310, 1);
      if (D.24313 == 0) goto <D.24314>; else goto <D.24315>;
      <D.24314>:
      D.24316 = ctx->report_error;
      if (D.24316 != 0) goto <D.24317>; else goto <D.24318>;
      <D.24317>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24310 = data[0];
        D.24319 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, D.24310);
        vinfo->info.message = D.24319;
        vinfo->exception_type = 3;
        D.24320 = ctx->errors;
        D.24321 = monoeg_g_slist_prepend (D.24320, vinfo);
        ctx->errors = D.24321;
      }
      <D.24318>:
      ctx->valid = 0;
      return;
      <D.24315>:
      <D.24312>:
      i = i + 1;
      <D.21294>:
      D.24322 = table->rows;
      D.24323 = (int) D.24322;
      if (D.24323 > i) goto <D.21293>; else goto <D.21295>;
      <D.21295>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_eventmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24327;
  unsigned int D.24330;
  <unnamed-unsigned:24> D.24332;
  int D.24333;
  int D.24334;
  unsigned int D.24335;
  int D.24336;
  gchar * D.24339;
  struct GSList * D.24340;
  struct GSList * D.24341;
  unsigned int D.24344;
  gchar * D.24348;
  struct GSList * D.24349;
  <unnamed-unsigned:24> D.24350;
  int D.24351;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 eventlist;
  int i;

  try
    {
      D.24327 = ctx->image;
      table = &D.24327->tables[18];
      eventlist = 0;
      i = 0;
      goto <D.21316>;
      <D.21315>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24330 = data[0];
      if (D.24330 == 0) goto <D.24328>; else goto <D.24331>;
      <D.24331>:
      D.24330 = data[0];
      D.24327 = ctx->image;
      D.24332 = D.24327->tables[2].rows;
      D.24333 = (int) D.24332;
      D.24334 = D.24333 + 1;
      D.24335 = (unsigned int) D.24334;
      if (D.24330 > D.24335) goto <D.24328>; else goto <D.24329>;
      <D.24328>:
      D.24336 = ctx->report_error;
      if (D.24336 != 0) goto <D.24337>; else goto <D.24338>;
      <D.24337>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24330 = data[0];
        D.24339 = monoeg_g_strdup_printf ("Invalid EventMap row %d Parent field 0x%08x", i, D.24330);
        vinfo->info.message = D.24339;
        vinfo->exception_type = 3;
        D.24340 = ctx->errors;
        D.24341 = monoeg_g_slist_prepend (D.24340, vinfo);
        ctx->errors = D.24341;
      }
      <D.24338>:
      ctx->valid = 0;
      return;
      <D.24329>:
      D.24344 = data[1];
      if (D.24344 == 0) goto <D.24342>; else goto <D.24345>;
      <D.24345>:
      D.24344 = data[1];
      if (D.24344 <= eventlist) goto <D.24342>; else goto <D.24343>;
      <D.24342>:
      D.24336 = ctx->report_error;
      if (D.24336 != 0) goto <D.24346>; else goto <D.24347>;
      <D.24346>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24344 = data[1];
        D.24348 = monoeg_g_strdup_printf ("Invalid EventMap row %d EventList field %d", i, D.24344);
        vinfo->info.message = D.24348;
        vinfo->exception_type = 3;
        D.24340 = ctx->errors;
        D.24349 = monoeg_g_slist_prepend (D.24340, vinfo);
        ctx->errors = D.24349;
      }
      <D.24347>:
      ctx->valid = 0;
      return;
      <D.24343>:
      eventlist = data[1];
      i = i + 1;
      <D.21316>:
      D.24350 = table->rows;
      D.24351 = (int) D.24350;
      if (D.24351 > i) goto <D.21315>; else goto <D.21317>;
      <D.21317>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_event_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24355;
  unsigned int D.24356;
  unsigned int D.24357;
  int D.24360;
  gchar * D.24363;
  struct GSList * D.24364;
  struct GSList * D.24365;
  unsigned int D.24366;
  int D.24367;
  gchar * D.24372;
  struct GSList * D.24373;
  unsigned int D.24374;
  int D.24375;
  gchar * D.24380;
  struct GSList * D.24381;
  <unnamed-unsigned:24> D.24382;
  int D.24383;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24355 = ctx->image;
      table = &D.24355->tables[20];
      i = 0;
      goto <D.21328>;
      <D.21327>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24356 = data[0];
      D.24357 = D.24356 & 4294965759;
      if (D.24357 != 0) goto <D.24358>; else goto <D.24359>;
      <D.24358>:
      D.24360 = ctx->report_error;
      if (D.24360 != 0) goto <D.24361>; else goto <D.24362>;
      <D.24361>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24356 = data[0];
        D.24363 = monoeg_g_strdup_printf ("Invalid Event row %d EventFlags field %08x", i, D.24356);
        vinfo->info.message = D.24363;
        vinfo->exception_type = 3;
        D.24364 = ctx->errors;
        D.24365 = monoeg_g_slist_prepend (D.24364, vinfo);
        ctx->errors = D.24365;
      }
      <D.24362>:
      ctx->valid = 0;
      return;
      <D.24359>:
      D.24366 = data[1];
      D.24367 = is_valid_non_empty_string (ctx, D.24366);
      if (D.24367 == 0) goto <D.24368>; else goto <D.24369>;
      <D.24368>:
      D.24360 = ctx->report_error;
      if (D.24360 != 0) goto <D.24370>; else goto <D.24371>;
      <D.24370>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24366 = data[1];
        D.24372 = monoeg_g_strdup_printf ("Invalid Event row %d Name field %08x", i, D.24366);
        vinfo->info.message = D.24372;
        vinfo->exception_type = 3;
        D.24364 = ctx->errors;
        D.24373 = monoeg_g_slist_prepend (D.24364, vinfo);
        ctx->errors = D.24373;
      }
      <D.24371>:
      ctx->valid = 0;
      return;
      <D.24369>:
      D.24374 = data[2];
      D.24375 = is_valid_coded_index (ctx, 0, D.24374);
      if (D.24375 == 0) goto <D.24376>; else goto <D.24377>;
      <D.24376>:
      D.24360 = ctx->report_error;
      if (D.24360 != 0) goto <D.24378>; else goto <D.24379>;
      <D.24378>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24374 = data[2];
        D.24380 = monoeg_g_strdup_printf ("Invalid Event row %d EventType field %08x", i, D.24374);
        vinfo->info.message = D.24380;
        vinfo->exception_type = 3;
        D.24364 = ctx->errors;
        D.24381 = monoeg_g_slist_prepend (D.24364, vinfo);
        ctx->errors = D.24381;
      }
      <D.24379>:
      ctx->valid = 0;
      return;
      <D.24377>:
      i = i + 1;
      <D.21328>:
      D.24382 = table->rows;
      D.24383 = (int) D.24382;
      if (D.24383 > i) goto <D.21327>; else goto <D.21329>;
      <D.21329>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_propertymap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24387;
  unsigned int D.24390;
  <unnamed-unsigned:24> D.24392;
  int D.24393;
  int D.24394;
  unsigned int D.24395;
  int D.24396;
  gchar * D.24399;
  struct GSList * D.24400;
  struct GSList * D.24401;
  unsigned int D.24404;
  gchar * D.24408;
  struct GSList * D.24409;
  <unnamed-unsigned:24> D.24410;
  int D.24411;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 propertylist;
  int i;

  try
    {
      D.24387 = ctx->image;
      table = &D.24387->tables[21];
      propertylist = 0;
      i = 0;
      goto <D.21364>;
      <D.21363>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24390 = data[0];
      if (D.24390 == 0) goto <D.24388>; else goto <D.24391>;
      <D.24391>:
      D.24390 = data[0];
      D.24387 = ctx->image;
      D.24392 = D.24387->tables[2].rows;
      D.24393 = (int) D.24392;
      D.24394 = D.24393 + 1;
      D.24395 = (unsigned int) D.24394;
      if (D.24390 > D.24395) goto <D.24388>; else goto <D.24389>;
      <D.24388>:
      D.24396 = ctx->report_error;
      if (D.24396 != 0) goto <D.24397>; else goto <D.24398>;
      <D.24397>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24390 = data[0];
        D.24399 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d Parent field 0x%08x", i, D.24390);
        vinfo->info.message = D.24399;
        vinfo->exception_type = 3;
        D.24400 = ctx->errors;
        D.24401 = monoeg_g_slist_prepend (D.24400, vinfo);
        ctx->errors = D.24401;
      }
      <D.24398>:
      ctx->valid = 0;
      return;
      <D.24389>:
      D.24404 = data[1];
      if (D.24404 == 0) goto <D.24402>; else goto <D.24405>;
      <D.24405>:
      D.24404 = data[1];
      if (D.24404 <= propertylist) goto <D.24402>; else goto <D.24403>;
      <D.24402>:
      D.24396 = ctx->report_error;
      if (D.24396 != 0) goto <D.24406>; else goto <D.24407>;
      <D.24406>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24404 = data[1];
        D.24408 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d PropertyList field %d", i, D.24404);
        vinfo->info.message = D.24408;
        vinfo->exception_type = 3;
        D.24400 = ctx->errors;
        D.24409 = monoeg_g_slist_prepend (D.24400, vinfo);
        ctx->errors = D.24409;
      }
      <D.24407>:
      ctx->valid = 0;
      return;
      <D.24403>:
      propertylist = data[1];
      i = i + 1;
      <D.21364>:
      D.24410 = table->rows;
      D.24411 = (int) D.24410;
      if (D.24411 > i) goto <D.21363>; else goto <D.21365>;
      <D.21365>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_property_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.24415;
  unsigned int D.24416;
  unsigned int D.24417;
  int D.24420;
  gchar * D.24423;
  struct GSList * D.24424;
  struct GSList * D.24425;
  unsigned int D.24426;
  int D.24427;
  gchar * D.24432;
  struct GSList * D.24433;
  unsigned int D.24434;
  int D.24435;
  gchar * D.24440;
  struct GSList * D.24441;
  unsigned int D.24442;
  unsigned int i.51;
  unsigned int D.24446;
  int D.24447;
  gchar * D.24452;
  struct GSList * D.24453;
  <unnamed-unsigned:24> D.24454;
  int D.24455;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24415 = ctx->image;
      table = &D.24415->tables[23];
      i = 0;
      goto <D.21377>;
      <D.21376>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24416 = data[0];
      D.24417 = D.24416 & 4294961663;
      if (D.24417 != 0) goto <D.24418>; else goto <D.24419>;
      <D.24418>:
      D.24420 = ctx->report_error;
      if (D.24420 != 0) goto <D.24421>; else goto <D.24422>;
      <D.24421>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24416 = data[0];
        D.24423 = monoeg_g_strdup_printf ("Invalid Property row %d PropertyFlags field %08x", i, D.24416);
        vinfo->info.message = D.24423;
        vinfo->exception_type = 3;
        D.24424 = ctx->errors;
        D.24425 = monoeg_g_slist_prepend (D.24424, vinfo);
        ctx->errors = D.24425;
      }
      <D.24422>:
      ctx->valid = 0;
      return;
      <D.24419>:
      D.24426 = data[1];
      D.24427 = is_valid_non_empty_string (ctx, D.24426);
      if (D.24427 == 0) goto <D.24428>; else goto <D.24429>;
      <D.24428>:
      D.24420 = ctx->report_error;
      if (D.24420 != 0) goto <D.24430>; else goto <D.24431>;
      <D.24430>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24426 = data[1];
        D.24432 = monoeg_g_strdup_printf ("Invalid Property row %d Name field %08x", i, D.24426);
        vinfo->info.message = D.24432;
        vinfo->exception_type = 3;
        D.24424 = ctx->errors;
        D.24433 = monoeg_g_slist_prepend (D.24424, vinfo);
        ctx->errors = D.24433;
      }
      <D.24431>:
      ctx->valid = 0;
      return;
      <D.24429>:
      D.24434 = data[2];
      D.24435 = is_valid_property_sig_blob (ctx, D.24434);
      if (D.24435 == 0) goto <D.24436>; else goto <D.24437>;
      <D.24436>:
      D.24420 = ctx->report_error;
      if (D.24420 != 0) goto <D.24438>; else goto <D.24439>;
      <D.24438>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24434 = data[2];
        D.24440 = monoeg_g_strdup_printf ("Invalid Property row %d Type field %08x", i, D.24434);
        vinfo->info.message = D.24440;
        vinfo->exception_type = 3;
        D.24424 = ctx->errors;
        D.24441 = monoeg_g_slist_prepend (D.24424, vinfo);
        ctx->errors = D.24441;
      }
      <D.24439>:
      ctx->valid = 0;
      return;
      <D.24437>:
      D.24416 = data[0];
      D.24442 = D.24416 & 4096;
      if (D.24442 != 0) goto <D.24443>; else goto <D.24444>;
      <D.24443>:
      i.51 = (unsigned int) i;
      D.24446 = make_coded_token (5, 23, i.51);
      D.24447 = search_sorted_table (ctx, 11, 2, D.24446);
      if (D.24447 == -1) goto <D.24448>; else goto <D.24449>;
      <D.24448>:
      D.24420 = ctx->report_error;
      if (D.24420 != 0) goto <D.24450>; else goto <D.24451>;
      <D.24450>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24452 = monoeg_g_strdup_printf ("Invalid Property row %d has HasDefault but there is no corresponding row in the Constant table", i);
        vinfo->info.message = D.24452;
        vinfo->exception_type = 3;
        D.24424 = ctx->errors;
        D.24453 = monoeg_g_slist_prepend (D.24424, vinfo);
        ctx->errors = D.24453;
      }
      <D.24451>:
      ctx->valid = 0;
      return;
      <D.24449>:
      <D.24444>:
      i = i + 1;
      <D.21377>:
      D.24454 = table->rows;
      D.24455 = (int) D.24454;
      if (D.24455 > i) goto <D.21376>; else goto <D.21378>;
      <D.21378>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_property_sig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24459;
  int D.24462;
  gchar * D.24465;
  struct GSList * D.24466;
  struct GSList * D.24467;
  gboolean D.24468;
  const char * ptr.52;
  unsigned int size.53;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.24459 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24459 == 0) goto <D.24460>; else goto <D.24461>;
      <D.24460>:
      D.24462 = ctx->report_error;
      if (D.24462 != 0) goto <D.24463>; else goto <D.24464>;
      <D.24463>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24465 = monoeg_strdup ("PropertySig: Could not decode signature header");
        vinfo->info.message = D.24465;
        vinfo->exception_type = 3;
        D.24466 = ctx->errors;
        D.24467 = monoeg_g_slist_prepend (D.24466, vinfo);
        ctx->errors = D.24467;
      }
      <D.24464>:
      ctx->valid = 0;
      D.24468 = 0;
      return D.24468;
      <D.24461>:
      ptr.52 = ptr;
      size.53 = size;
      end = ptr.52 + size.53;
      D.24468 = parse_property_signature (ctx, &ptr, end);
      return D.24468;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


decode_signature_header (struct VerifyContext * ctx, guint32 offset, guint32 * size, const char * * first_byte)
{
  struct MonoImage * D.24473;
  unsigned int D.24474;
  gboolean D.24477;
  const char * D.24478;
  const char * D.24479;
  unsigned int D.24480;
  int D.24481;
  unsigned int enc_size.54;
  unsigned int D.24485;
  unsigned int value.55;
  unsigned int D.24491;
  unsigned int D.24493;
  struct MonoStreamHeader blob;
  guint32 value;
  guint32 enc_size;

  try
    {
      D.24473 = ctx->image;
      blob = D.24473->heap_blob;
      D.24474 = blob.size;
      if (D.24474 <= offset) goto <D.24475>; else goto <D.24476>;
      <D.24475>:
      D.24477 = 0;
      return D.24477;
      <D.24476>:
      D.24478 = blob.data;
      D.24479 = D.24478 + offset;
      D.24474 = blob.size;
      D.24480 = D.24474 - offset;
      D.24481 = decode_value (D.24479, D.24480, &value, &enc_size);
      if (D.24481 == 0) goto <D.24482>; else goto <D.24483>;
      <D.24482>:
      D.24477 = 0;
      return D.24477;
      <D.24483>:
      enc_size.54 = enc_size;
      D.24485 = ~enc_size.54;
      if (D.24485 < offset) goto <D.24486>; else goto <D.24487>;
      <D.24486>:
      D.24477 = 0;
      return D.24477;
      <D.24487>:
      enc_size.54 = enc_size;
      offset = offset + enc_size.54;
      value.55 = value;
      D.24491 = offset + value.55;
      D.24474 = blob.size;
      if (D.24491 > D.24474) goto <D.24488>; else goto <D.24492>;
      <D.24492>:
      value.55 = value;
      D.24493 = ~value.55;
      if (D.24493 < offset) goto <D.24488>; else goto <D.24489>;
      <D.24488>:
      D.24477 = 0;
      return D.24477;
      <D.24489>:
      value.55 = value;
      *size = value.55;
      D.24478 = blob.data;
      D.24479 = D.24478 + offset;
      *first_byte = D.24479;
      D.24477 = 1;
      return D.24477;
    }
  finally
    {
      blob = {CLOBBER};
      value = {CLOBBER};
      enc_size = {CLOBBER};
    }
}


parse_property_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.56;
  int D.24497;
  int D.24500;
  gchar * D.24503;
  struct GSList * D.24504;
  struct GSList * D.24505;
  gboolean D.24506;
  unsigned int sig.57;
  _Bool D.24508;
  _Bool D.24509;
  _Bool D.24510;
  unsigned int sig.58;
  gchar * D.24516;
  struct GSList * D.24517;
  int D.24518;
  gchar * D.24523;
  struct GSList * D.24524;
  int D.24525;
  int D.24528;
  gchar * D.24533;
  struct GSList * D.24534;
  int D.24535;
  gchar * D.24540;
  struct GSList * D.24541;
  int D.24542;
  gchar * D.24547;
  struct GSList * D.24548;
  unsigned int param_count.59;
  const char * ptr.60;
  unsigned int sig;
  unsigned int param_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      param_count = 0;
      ptr.56 = *_ptr;
      ptr = ptr.56;
      D.24497 = safe_read (&ptr, end, &sig, 1);
      if (D.24497 == 0) goto <D.24498>; else goto <D.24499>;
      <D.24498>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24501>; else goto <D.24502>;
      <D.24501>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24503 = monoeg_strdup ("PropertySig: Not enough room for signature");
        vinfo->info.message = D.24503;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24505 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24505;
      }
      <D.24502>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24499>:
      sig.57 = sig;
      D.24508 = sig.57 != 8;
      D.24509 = sig.57 != 40;
      D.24510 = D.24508 & D.24509;
      if (D.24510 != 0) goto <D.24511>; else goto <D.24512>;
      <D.24511>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24513>; else goto <D.24514>;
      <D.24513>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.58 = sig;
        D.24516 = monoeg_g_strdup_printf ("PropertySig: Signature is not 0x28 or 0x08: %x", sig.58);
        vinfo->info.message = D.24516;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24517 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24517;
      }
      <D.24514>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24512>:
      D.24518 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.24518 == 0) goto <D.24519>; else goto <D.24520>;
      <D.24519>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24521>; else goto <D.24522>;
      <D.24521>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24523 = monoeg_strdup ("PropertySig: Not enough room for the param count");
        vinfo->info.message = D.24523;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24524 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24524;
      }
      <D.24522>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24520>:
      D.24525 = parse_custom_mods (ctx, &ptr, end);
      if (D.24525 == 0) goto <D.24526>; else goto <D.24527>;
      <D.24526>:
      D.24506 = 0;
      return D.24506;
      <D.24527>:
      D.24528 = parse_type (ctx, &ptr, end);
      if (D.24528 == 0) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24531>; else goto <D.24532>;
      <D.24531>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24533 = monoeg_strdup ("PropertySig: Could not parse property type");
        vinfo->info.message = D.24533;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24534 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24534;
      }
      <D.24532>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24530>:
      i = 0;
      goto <D.20560>;
      <D.20559>:
      D.24535 = parse_custom_mods (ctx, &ptr, end);
      if (D.24535 == 0) goto <D.24536>; else goto <D.24537>;
      <D.24536>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24538>; else goto <D.24539>;
      <D.24538>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24540 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.24540;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24541 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24541;
      }
      <D.24539>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24537>:
      D.24542 = parse_type (ctx, &ptr, end);
      if (D.24542 == 0) goto <D.24543>; else goto <D.24544>;
      <D.24543>:
      D.24500 = ctx->report_error;
      if (D.24500 != 0) goto <D.24545>; else goto <D.24546>;
      <D.24545>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24547 = monoeg_g_strdup_printf ("PropertySig: Error parsing arg %d", i);
        vinfo->info.message = D.24547;
        vinfo->exception_type = 3;
        D.24504 = ctx->errors;
        D.24548 = monoeg_g_slist_prepend (D.24504, vinfo);
        ctx->errors = D.24548;
      }
      <D.24546>:
      ctx->valid = 0;
      D.24506 = 0;
      return D.24506;
      <D.24544>:
      i = i + 1;
      <D.20560>:
      param_count.59 = param_count;
      if (i < param_count.59) goto <D.20559>; else goto <D.20561>;
      <D.20561>:
      ptr.60 = ptr;
      *_ptr = ptr.60;
      D.24506 = 1;
      return D.24506;
    }
  finally
    {
      sig = {CLOBBER};
      param_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


safe_read (const char * * _ptr, const char * limit, unsigned int * dest, int size)
{
  sizetype size.61;
  const char * D.24554;
  gboolean D.24557;
  unsigned char D.24558;
  unsigned int D.24559;
  short unsigned int D.24560;
  unsigned int D.24561;
  unsigned int D.24562;
  const char * ptr;

  ptr = *_ptr;
  size.61 = (sizetype) size;
  D.24554 = ptr + size.61;
  if (D.24554 > limit) goto <D.24555>; else goto <D.24556>;
  <D.24555>:
  D.24557 = 0;
  return D.24557;
  <D.24556>:
  switch (size) <default: <D.24563>, case 1: <D.20385>, case 2: <D.20387>, case 4: <D.20388>>
  <D.20385>:
  D.24558 = MEM[(guint8 *)ptr];
  D.24559 = (unsigned int) D.24558;
  *dest = D.24559;
  ptr = ptr + 1;
  goto <D.20386>;
  <D.20387>:
  D.24560 = mono_read16 (ptr);
  D.24561 = (unsigned int) D.24560;
  *dest = D.24561;
  ptr = ptr + 2;
  goto <D.20386>;
  <D.20388>:
  D.24562 = mono_read32 (ptr);
  *dest = D.24562;
  ptr = ptr + 4;
  goto <D.20386>;
  <D.24563>:
  <D.20386>:
  *_ptr = ptr;
  D.24557 = 1;
  return D.24557;
}


safe_read_compressed_int (const char * * _ptr, const char * limit, unsigned int * dest)
{
  int limit.62;
  int ptr.63;
  int D.24567;
  unsigned int D.24568;
  unsigned int size.64;
  const char * D.24570;
  gboolean D.24571;
  unsigned int size;
  const char * ptr;
  gboolean res;

  try
    {
      size = 0;
      ptr = *_ptr;
      limit.62 = (int) limit;
      ptr.63 = (int) ptr;
      D.24567 = limit.62 - ptr.63;
      D.24568 = (unsigned int) D.24567;
      res = decode_value (ptr, D.24568, dest, &size);
      size.64 = size;
      D.24570 = ptr + size.64;
      *_ptr = D.24570;
      D.24571 = res;
      return D.24571;
    }
  finally
    {
      size = {CLOBBER};
    }
}


parse_custom_mods (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.65;
  int D.24575;
  int D.24578;
  gchar * D.24581;
  struct GSList * D.24582;
  struct GSList * D.24583;
  gboolean D.24584;
  unsigned int type.66;
  unsigned int D.24586;
  const char * ptr.67;
  const char * ptr.68;
  int D.24591;
  gchar * D.24596;
  struct GSList * D.24597;
  unsigned int token.69;
  int D.24601;
  unsigned int D.24603;
  gchar * D.24606;
  struct GSList * D.24607;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.65 = *_ptr;
      ptr = ptr.65;
      type = 0;
      token = 0;
      <D.20419>:
      D.24575 = safe_read (&ptr, end, &type, 1);
      if (D.24575 == 0) goto <D.24576>; else goto <D.24577>;
      <D.24576>:
      D.24578 = ctx->report_error;
      if (D.24578 != 0) goto <D.24579>; else goto <D.24580>;
      <D.24579>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24581 = monoeg_strdup ("CustomMod: Not enough room for the type");
        vinfo->info.message = D.24581;
        vinfo->exception_type = 3;
        D.24582 = ctx->errors;
        D.24583 = monoeg_g_slist_prepend (D.24582, vinfo);
        ctx->errors = D.24583;
      }
      <D.24580>:
      ctx->valid = 0;
      D.24584 = 0;
      return D.24584;
      <D.24577>:
      type.66 = type;
      D.24586 = type.66 + 4294967265;
      if (D.24586 > 1) goto <D.24587>; else goto <D.24588>;
      <D.24587>:
      ptr.67 = ptr;
      ptr.68 = ptr.67 + 4294967295;
      ptr = ptr.68;
      goto <D.20416>;
      <D.24588>:
      D.24591 = safe_read_compressed_int (&ptr, end, &token);
      if (D.24591 == 0) goto <D.24592>; else goto <D.24593>;
      <D.24592>:
      D.24578 = ctx->report_error;
      if (D.24578 != 0) goto <D.24594>; else goto <D.24595>;
      <D.24594>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24596 = monoeg_strdup ("CustomMod: Not enough room for the token");
        vinfo->info.message = D.24596;
        vinfo->exception_type = 3;
        D.24582 = ctx->errors;
        D.24597 = monoeg_g_slist_prepend (D.24582, vinfo);
        ctx->errors = D.24597;
      }
      <D.24595>:
      ctx->valid = 0;
      D.24584 = 0;
      return D.24584;
      <D.24593>:
      token.69 = token;
      D.24601 = is_valid_coded_index (ctx, 0, token.69);
      if (D.24601 == 0) goto <D.24598>; else goto <D.24602>;
      <D.24602>:
      token.69 = token;
      D.24603 = get_coded_index_token (0, token.69);
      if (D.24603 == 0) goto <D.24598>; else goto <D.24599>;
      <D.24598>:
      D.24578 = ctx->report_error;
      if (D.24578 != 0) goto <D.24604>; else goto <D.24605>;
      <D.24604>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.69 = token;
        D.24606 = monoeg_g_strdup_printf ("CustomMod: invalid TypeDefOrRef token %x", token.69);
        vinfo->info.message = D.24606;
        vinfo->exception_type = 3;
        D.24582 = ctx->errors;
        D.24607 = monoeg_g_slist_prepend (D.24582, vinfo);
        ctx->errors = D.24607;
      }
      <D.24605>:
      ctx->valid = 0;
      D.24584 = 0;
      return D.24584;
      <D.24599>:
      goto <D.20419>;
      <D.20416>:
      ptr.67 = ptr;
      *_ptr = ptr.67;
      D.24584 = 1;
      return D.24584;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.70;
  int D.24611;
  int D.24614;
  gchar * D.24617;
  struct GSList * D.24618;
  struct GSList * D.24619;
  gboolean D.24620;
  unsigned int type.71;
  unsigned int D.24622;
  _Bool D.24623;
  unsigned int D.24624;
  _Bool D.24625;
  _Bool D.24626;
  unsigned int type.72;
  unsigned int D.24630;
  unsigned int D.24633;
  gchar * D.24638;
  struct GSList * D.24639;
  int D.24640;
  gchar * D.24645;
  struct GSList * D.24646;
  int D.24647;
  gchar * D.24652;
  struct GSList * D.24653;
  const char * ptr.73;
  const char * ptr.74;
  int D.24658;
  gchar * D.24663;
  struct GSList * D.24664;
  int D.24665;
  gchar * D.24670;
  struct GSList * D.24671;
  unsigned int token.75;
  int D.24675;
  unsigned int D.24677;
  gchar * D.24680;
  struct GSList * D.24681;
  unsigned int D.24682;
  gchar * D.24687;
  struct GSList * D.24688;
  unsigned int D.24689;
  unsigned int D.24692;
  unsigned int D.24693;
  unsigned int D.24696;
  unsigned int D.24697;
  gchar * D.24702;
  struct GSList * D.24703;
  int D.24704;
  gchar * D.24709;
  struct GSList * D.24710;
  int D.24711;
  gchar * D.24716;
  struct GSList * D.24717;
  int D.24718;
  gchar * D.24723;
  struct GSList * D.24724;
  int D.24725;
  gchar * D.24730;
  struct GSList * D.24731;
  int D.24732;
  gchar * D.24737;
  struct GSList * D.24738;
  int D.24739;
  gchar * D.24744;
  struct GSList * D.24745;
  int D.24746;
  gchar * D.24751;
  struct GSList * D.24752;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.70 = *_ptr;
      ptr = ptr.70;
      token = 0;
      D.24611 = safe_read (&ptr, end, &type, 1);
      if (D.24611 == 0) goto <D.24612>; else goto <D.24613>;
      <D.24612>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24615>; else goto <D.24616>;
      <D.24615>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24617 = monoeg_strdup ("Type: Not enough room for the type");
        vinfo->info.message = D.24617;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24619 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24619;
      }
      <D.24616>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24613>:
      type.71 = type;
      D.24622 = type.71 + 4294967294;
      D.24623 = D.24622 > 13;
      D.24624 = type.71 + 4294967279;
      D.24625 = D.24624 > 4;
      D.24626 = D.24623 & D.24625;
      if (D.24626 != 0) goto <D.24627>; else goto <D.24628>;
      <D.24627>:
      type.72 = type;
      D.24630 = type.72 + 4294967272;
      if (D.24630 > 1) goto <D.24631>; else goto <D.24632>;
      <D.24631>:
      type.72 = type;
      D.24633 = type.72 + 4294967269;
      if (D.24633 > 3) goto <D.24634>; else goto <D.24635>;
      <D.24634>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24636>; else goto <D.24637>;
      <D.24636>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.72 = type;
        D.24638 = monoeg_g_strdup_printf ("Type: Invalid type kind %x\n", type.72);
        vinfo->info.message = D.24638;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24639 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24639;
      }
      <D.24637>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24635>:
      <D.24632>:
      <D.24628>:
      type.72 = type;
      switch (type.72) <default: <D.24753>, case 15: <D.20474>, case 17: <D.20479>, case 18: <D.20480>, case 19: <D.20485>, case 20: <D.20488>, case 21: <D.20491>, case 27: <D.20493>, case 29: <D.20495>, case 30: <D.20486>>
      <D.20474>:
      D.24640 = parse_custom_mods (ctx, &ptr, end);
      if (D.24640 == 0) goto <D.24641>; else goto <D.24642>;
      <D.24641>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24643>; else goto <D.24644>;
      <D.24643>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24645 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.24645;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24646 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24646;
      }
      <D.24644>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24642>:
      D.24647 = safe_read (&ptr, end, &type, 1);
      if (D.24647 == 0) goto <D.24648>; else goto <D.24649>;
      <D.24648>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24650>; else goto <D.24651>;
      <D.24650>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24652 = monoeg_strdup ("Type: Not enough room to parse the pointer type");
        vinfo->info.message = D.24652;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24653 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24653;
      }
      <D.24651>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24649>:
      type.72 = type;
      if (type.72 != 1) goto <D.24654>; else goto <D.24655>;
      <D.24654>:
      ptr.73 = ptr;
      ptr.74 = ptr.73 + 4294967295;
      ptr = ptr.74;
      D.24658 = parse_type (ctx, &ptr, end);
      if (D.24658 == 0) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24661>; else goto <D.24662>;
      <D.24661>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24663 = monoeg_strdup ("Type: Could not parse pointer type");
        vinfo->info.message = D.24663;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24664 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24664;
      }
      <D.24662>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24660>:
      <D.24655>:
      goto <D.20478>;
      <D.20479>:
      <D.20480>:
      D.24665 = safe_read_compressed_int (&ptr, end, &token);
      if (D.24665 == 0) goto <D.24666>; else goto <D.24667>;
      <D.24666>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24668>; else goto <D.24669>;
      <D.24668>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24670 = monoeg_strdup ("Type: Not enough room for the type token");
        vinfo->info.message = D.24670;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24671 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24671;
      }
      <D.24669>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24667>:
      token.75 = token;
      D.24675 = is_valid_coded_index (ctx, 0, token.75);
      if (D.24675 == 0) goto <D.24672>; else goto <D.24676>;
      <D.24676>:
      token.75 = token;
      D.24677 = get_coded_index_token (0, token.75);
      if (D.24677 == 0) goto <D.24672>; else goto <D.24673>;
      <D.24672>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24678>; else goto <D.24679>;
      <D.24678>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.75 = token;
        D.24680 = monoeg_g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token.75);
        vinfo->info.message = D.24680;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24681 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24681;
      }
      <D.24679>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24673>:
      token.75 = token;
      D.24682 = get_coded_index_token (0, token.75);
      if (D.24682 == 0) goto <D.24683>; else goto <D.24684>;
      <D.24683>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24685>; else goto <D.24686>;
      <D.24685>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.75 = token;
        D.24687 = monoeg_g_strdup_printf ("Type: zero TypeDefOrRef token %x", token.75);
        vinfo->info.message = D.24687;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24688 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24688;
      }
      <D.24686>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24684>:
      D.24689 = ctx->token;
      if (D.24689 != 0) goto <D.24690>; else goto <D.24691>;
      <D.24690>:
      D.24689 = ctx->token;
      D.24692 = D.24689 & 16777215;
      token.75 = token;
      D.24693 = get_coded_index_token (0, token.75);
      if (D.24692 == D.24693) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      D.24689 = ctx->token;
      D.24696 = D.24689 >> 24;
      token.75 = token;
      D.24697 = get_coded_index_table (0, token.75);
      if (D.24696 == D.24697) goto <D.24698>; else goto <D.24699>;
      <D.24698>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24700>; else goto <D.24701>;
      <D.24700>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24689 = ctx->token;
        D.24702 = monoeg_g_strdup_printf ("Type: Recursive type specification (%x). A type signature can\'t reference itself", D.24689);
        vinfo->info.message = D.24702;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24703 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24703;
      }
      <D.24701>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24699>:
      <D.24695>:
      <D.24691>:
      goto <D.20478>;
      <D.20485>:
      <D.20486>:
      D.24704 = safe_read_compressed_int (&ptr, end, &token);
      if (D.24704 == 0) goto <D.24705>; else goto <D.24706>;
      <D.24705>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24707>; else goto <D.24708>;
      <D.24707>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24709 = monoeg_strdup ("Type: Not enough room for to decode generic argument number");
        vinfo->info.message = D.24709;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24710 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24710;
      }
      <D.24708>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24706>:
      goto <D.20478>;
      <D.20488>:
      D.24711 = parse_type (ctx, &ptr, end);
      if (D.24711 == 0) goto <D.24712>; else goto <D.24713>;
      <D.24712>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24714>; else goto <D.24715>;
      <D.24714>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24716 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.24716;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24717 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24717;
      }
      <D.24715>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24713>:
      D.24718 = parse_array_shape (ctx, &ptr, end);
      if (D.24718 == 0) goto <D.24719>; else goto <D.24720>;
      <D.24719>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24721>; else goto <D.24722>;
      <D.24721>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24723 = monoeg_strdup ("Type: Could not parse array shape");
        vinfo->info.message = D.24723;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24724 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24724;
      }
      <D.24722>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24720>:
      goto <D.20478>;
      <D.20491>:
      D.24725 = parse_generic_inst (ctx, &ptr, end);
      if (D.24725 == 0) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24728>; else goto <D.24729>;
      <D.24728>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24730 = monoeg_strdup ("Type: Could not parse generic inst");
        vinfo->info.message = D.24730;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24731 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24731;
      }
      <D.24729>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24727>:
      goto <D.20478>;
      <D.20493>:
      D.24732 = parse_method_signature (ctx, &ptr, end, 1, 1);
      if (D.24732 == 0) goto <D.24733>; else goto <D.24734>;
      <D.24733>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24735>; else goto <D.24736>;
      <D.24735>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24737 = monoeg_strdup ("Type: Could not parse method pointer signature");
        vinfo->info.message = D.24737;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24738 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24738;
      }
      <D.24736>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24734>:
      goto <D.20478>;
      <D.20495>:
      D.24739 = parse_custom_mods (ctx, &ptr, end);
      if (D.24739 == 0) goto <D.24740>; else goto <D.24741>;
      <D.24740>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24742>; else goto <D.24743>;
      <D.24742>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24744 = monoeg_strdup ("Type: Failed to parse array element custom attr");
        vinfo->info.message = D.24744;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24745 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24745;
      }
      <D.24743>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24741>:
      D.24746 = parse_type (ctx, &ptr, end);
      if (D.24746 == 0) goto <D.24747>; else goto <D.24748>;
      <D.24747>:
      D.24614 = ctx->report_error;
      if (D.24614 != 0) goto <D.24749>; else goto <D.24750>;
      <D.24749>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24751 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.24751;
        vinfo->exception_type = 3;
        D.24618 = ctx->errors;
        D.24752 = monoeg_g_slist_prepend (D.24618, vinfo);
        ctx->errors = D.24752;
      }
      <D.24750>:
      ctx->valid = 0;
      D.24620 = 0;
      return D.24620;
      <D.24748>:
      goto <D.20478>;
      <D.24753>:
      <D.20478>:
      ptr.73 = ptr;
      *_ptr = ptr.73;
      D.24620 = 1;
      return D.24620;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


get_coded_index_table (int kind, guint32 coded_token)
{
  unsigned char D.24756;
  int bits.76;
  int D.24758;
  int D.24759;
  unsigned int D.24760;
  guint32 D.24761;
  unsigned int kind.77;
  unsigned int D.24763;
  unsigned char D.24764;
  guint32 idx;
  guint32 bits;

  D.24756 = coded_index_desc[kind];
  bits = (guint32) D.24756;
  kind = kind + 2;
  bits.76 = (int) bits;
  D.24758 = 1 << bits.76;
  D.24759 = D.24758 + -1;
  D.24760 = (unsigned int) D.24759;
  idx = D.24760 & coded_token;
  kind.77 = (unsigned int) kind;
  D.24763 = kind.77 + idx;
  D.24764 = coded_index_desc[D.24763];
  D.24761 = (guint32) D.24764;
  return D.24761;
}


parse_array_shape (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.78;
  int D.24767;
  int D.24770;
  gchar * D.24773;
  struct GSList * D.24774;
  struct GSList * D.24775;
  gboolean D.24776;
  unsigned int val.79;
  gchar * D.24782;
  struct GSList * D.24783;
  int D.24784;
  gchar * D.24789;
  struct GSList * D.24790;
  int D.24791;
  unsigned int D.24796;
  gchar * D.24797;
  struct GSList * D.24798;
  unsigned int size.80;
  int D.24800;
  gchar * D.24805;
  struct GSList * D.24806;
  int D.24807;
  gchar * D.24812;
  struct GSList * D.24813;
  const char * ptr.81;
  const char * ptr;
  unsigned int val;
  unsigned int size;
  unsigned int num;
  unsigned int i;

  try
    {
      ptr.78 = *_ptr;
      ptr = ptr.78;
      val = 0;
      D.24767 = safe_read (&ptr, end, &val, 1);
      if (D.24767 == 0) goto <D.24768>; else goto <D.24769>;
      <D.24768>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24771>; else goto <D.24772>;
      <D.24771>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24773 = monoeg_strdup ("ArrayShape: Not enough room for Rank");
        vinfo->info.message = D.24773;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24775 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24775;
      }
      <D.24772>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24769>:
      val.79 = val;
      if (val.79 == 0) goto <D.24778>; else goto <D.24779>;
      <D.24778>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24780>; else goto <D.24781>;
      <D.24780>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24782 = monoeg_strdup ("ArrayShape: Invalid shape with zero Rank");
        vinfo->info.message = D.24782;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24783 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24783;
      }
      <D.24781>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24779>:
      D.24784 = safe_read_compressed_int (&ptr, end, &size);
      if (D.24784 == 0) goto <D.24785>; else goto <D.24786>;
      <D.24785>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24787>; else goto <D.24788>;
      <D.24787>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24789 = monoeg_strdup ("ArrayShape: Not enough room for NumSizes");
        vinfo->info.message = D.24789;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24790 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24790;
      }
      <D.24788>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24786>:
      i = 0;
      goto <D.20435>;
      <D.20434>:
      D.24791 = safe_read_compressed_int (&ptr, end, &num);
      if (D.24791 == 0) goto <D.24792>; else goto <D.24793>;
      <D.24792>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24794>; else goto <D.24795>;
      <D.24794>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24796 = i + 1;
        D.24797 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for Size of rank %d", D.24796);
        vinfo->info.message = D.24797;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24798 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24798;
      }
      <D.24795>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24793>:
      i = i + 1;
      <D.20435>:
      size.80 = size;
      if (i < size.80) goto <D.20434>; else goto <D.20436>;
      <D.20436>:
      D.24800 = safe_read_compressed_int (&ptr, end, &size);
      if (D.24800 == 0) goto <D.24801>; else goto <D.24802>;
      <D.24801>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24803>; else goto <D.24804>;
      <D.24803>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24805 = monoeg_strdup ("ArrayShape: Not enough room for NumLoBounds");
        vinfo->info.message = D.24805;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24806 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24806;
      }
      <D.24804>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24802>:
      i = 0;
      goto <D.20440>;
      <D.20439>:
      D.24807 = safe_read_compressed_int (&ptr, end, &num);
      if (D.24807 == 0) goto <D.24808>; else goto <D.24809>;
      <D.24808>:
      D.24770 = ctx->report_error;
      if (D.24770 != 0) goto <D.24810>; else goto <D.24811>;
      <D.24810>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24796 = i + 1;
        D.24812 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for LoBound of rank %d", D.24796);
        vinfo->info.message = D.24812;
        vinfo->exception_type = 3;
        D.24774 = ctx->errors;
        D.24813 = monoeg_g_slist_prepend (D.24774, vinfo);
        ctx->errors = D.24813;
      }
      <D.24811>:
      ctx->valid = 0;
      D.24776 = 0;
      return D.24776;
      <D.24809>:
      i = i + 1;
      <D.20440>:
      size.80 = size;
      if (i < size.80) goto <D.20439>; else goto <D.20441>;
      <D.20441>:
      ptr.81 = ptr;
      *_ptr = ptr.81;
      D.24776 = 1;
      return D.24776;
    }
  finally
    {
      ptr = {CLOBBER};
      val = {CLOBBER};
      size = {CLOBBER};
      num = {CLOBBER};
    }
}


parse_generic_inst (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.82;
  int D.24818;
  int D.24821;
  gchar * D.24824;
  struct GSList * D.24825;
  struct GSList * D.24826;
  gboolean D.24827;
  unsigned int type.83;
  unsigned int D.24829;
  gchar * D.24834;
  struct GSList * D.24835;
  int D.24836;
  gchar * D.24841;
  struct GSList * D.24842;
  unsigned int token.84;
  int D.24846;
  unsigned int D.24848;
  gchar * D.24851;
  struct GSList * D.24852;
  unsigned int D.24853;
  unsigned int D.24856;
  unsigned int D.24857;
  unsigned int D.24860;
  unsigned int D.24861;
  gchar * D.24866;
  struct GSList * D.24867;
  int D.24868;
  gchar * D.24873;
  struct GSList * D.24874;
  unsigned int count.85;
  gchar * D.24880;
  struct GSList * D.24881;
  int D.24882;
  gchar * D.24887;
  struct GSList * D.24888;
  int D.24889;
  unsigned int D.24894;
  gchar * D.24895;
  struct GSList * D.24896;
  const char * ptr.86;
  const char * ptr;
  unsigned int type;
  unsigned int count;
  unsigned int token;
  unsigned int i;

  try
    {
      ptr.82 = *_ptr;
      ptr = ptr.82;
      D.24818 = safe_read (&ptr, end, &type, 1);
      if (D.24818 == 0) goto <D.24819>; else goto <D.24820>;
      <D.24819>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24822>; else goto <D.24823>;
      <D.24822>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24824 = monoeg_strdup ("GenericInst: Not enough room for kind");
        vinfo->info.message = D.24824;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24826 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24826;
      }
      <D.24823>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24820>:
      type.83 = type;
      D.24829 = type.83 + 4294967279;
      if (D.24829 > 1) goto <D.24830>; else goto <D.24831>;
      <D.24830>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24832>; else goto <D.24833>;
      <D.24832>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.83 = type;
        D.24834 = monoeg_g_strdup_printf ("GenericInst: Invalid GenericInst kind %x\n", type.83);
        vinfo->info.message = D.24834;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24835 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24835;
      }
      <D.24833>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24831>:
      D.24836 = safe_read_compressed_int (&ptr, end, &token);
      if (D.24836 == 0) goto <D.24837>; else goto <D.24838>;
      <D.24837>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24839>; else goto <D.24840>;
      <D.24839>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24841 = monoeg_strdup ("GenericInst: Not enough room for type token");
        vinfo->info.message = D.24841;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24842 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24842;
      }
      <D.24840>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24838>:
      token.84 = token;
      D.24846 = is_valid_coded_index (ctx, 0, token.84);
      if (D.24846 == 0) goto <D.24843>; else goto <D.24847>;
      <D.24847>:
      token.84 = token;
      D.24848 = get_coded_index_token (0, token.84);
      if (D.24848 == 0) goto <D.24843>; else goto <D.24844>;
      <D.24843>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24849>; else goto <D.24850>;
      <D.24849>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        token.84 = token;
        D.24851 = monoeg_g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token.84);
        vinfo->info.message = D.24851;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24852 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24852;
      }
      <D.24850>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24844>:
      D.24853 = ctx->token;
      if (D.24853 != 0) goto <D.24854>; else goto <D.24855>;
      <D.24854>:
      D.24853 = ctx->token;
      D.24856 = D.24853 & 16777215;
      token.84 = token;
      D.24857 = get_coded_index_token (0, token.84);
      if (D.24856 == D.24857) goto <D.24858>; else goto <D.24859>;
      <D.24858>:
      D.24853 = ctx->token;
      D.24860 = D.24853 >> 24;
      token.84 = token;
      D.24861 = get_coded_index_table (0, token.84);
      if (D.24860 == D.24861) goto <D.24862>; else goto <D.24863>;
      <D.24862>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24864>; else goto <D.24865>;
      <D.24864>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24853 = ctx->token;
        D.24866 = monoeg_g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can\'t reference itself", D.24853);
        vinfo->info.message = D.24866;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24867 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24867;
      }
      <D.24865>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24863>:
      <D.24859>:
      <D.24855>:
      D.24868 = safe_read_compressed_int (&ptr, end, &count);
      if (D.24868 == 0) goto <D.24869>; else goto <D.24870>;
      <D.24869>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24871>; else goto <D.24872>;
      <D.24871>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24873 = monoeg_strdup ("GenericInst: Not enough room for argument count");
        vinfo->info.message = D.24873;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24874 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24874;
      }
      <D.24872>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24870>:
      count.85 = count;
      if (count.85 == 0) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24878>; else goto <D.24879>;
      <D.24878>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24880 = monoeg_strdup ("GenericInst: Zero arguments generic instance");
        vinfo->info.message = D.24880;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24881 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24881;
      }
      <D.24879>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24877>:
      i = 0;
      goto <D.20462>;
      <D.20461>:
      D.24882 = parse_custom_mods (ctx, &ptr, end);
      if (D.24882 == 0) goto <D.24883>; else goto <D.24884>;
      <D.24883>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24885>; else goto <D.24886>;
      <D.24885>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24887 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.24887;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24888 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24888;
      }
      <D.24886>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24884>:
      D.24889 = parse_type (ctx, &ptr, end);
      if (D.24889 == 0) goto <D.24890>; else goto <D.24891>;
      <D.24890>:
      D.24821 = ctx->report_error;
      if (D.24821 != 0) goto <D.24892>; else goto <D.24893>;
      <D.24892>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24894 = i + 1;
        D.24895 = monoeg_g_strdup_printf ("GenericInst: invalid generic argument %d", D.24894);
        vinfo->info.message = D.24895;
        vinfo->exception_type = 3;
        D.24825 = ctx->errors;
        D.24896 = monoeg_g_slist_prepend (D.24825, vinfo);
        ctx->errors = D.24896;
      }
      <D.24893>:
      ctx->valid = 0;
      D.24827 = 0;
      return D.24827;
      <D.24891>:
      i = i + 1;
      <D.20462>:
      count.85 = count;
      if (i < count.85) goto <D.20461>; else goto <D.20463>;
      <D.20463>:
      ptr.86 = ptr;
      *_ptr = ptr.86;
      D.24827 = 1;
      return D.24827;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      count = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_method_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end, gboolean allow_sentinel, gboolean allow_unmanaged)
{
  const char * ptr.87;
  int D.24901;
  int D.24904;
  gchar * D.24907;
  struct GSList * D.24908;
  struct GSList * D.24909;
  gboolean D.24910;
  unsigned int cconv.88;
  unsigned int D.24912;
  gchar * D.24917;
  struct GSList * D.24918;
  unsigned int D.24921;
  gchar * D.24926;
  struct GSList * D.24927;
  unsigned int D.24929;
  _Bool D.24930;
  _Bool D.24931;
  _Bool D.24932;
  gchar * D.24937;
  struct GSList * D.24938;
  unsigned int D.24939;
  int D.24942;
  gchar * D.24947;
  struct GSList * D.24948;
  unsigned int gparam_count.89;
  gchar * D.24956;
  struct GSList * D.24957;
  gchar * D.24964;
  struct GSList * D.24965;
  int D.24966;
  gchar * D.24971;
  struct GSList * D.24972;
  int D.24973;
  gchar * D.24978;
  struct GSList * D.24979;
  int D.24982;
  gchar * D.24987;
  struct GSList * D.24988;
  unsigned int type.90;
  gchar * D.24996;
  struct GSList * D.24997;
  gchar * D.25002;
  struct GSList * D.25003;
  const char * ptr.91;
  const char * ptr.92;
  int D.25007;
  gchar * D.25012;
  struct GSList * D.25013;
  unsigned int param_count.93;
  unsigned int cconv;
  unsigned int param_count;
  unsigned int gparam_count;
  unsigned int type;
  unsigned int i;
  const char * ptr;
  gboolean saw_sentinel;

  try
    {
      cconv = 0;
      param_count = 0;
      gparam_count = 0;
      type = 0;
      ptr.87 = *_ptr;
      ptr = ptr.87;
      saw_sentinel = 0;
      D.24901 = safe_read (&ptr, end, &cconv, 1);
      if (D.24901 == 0) goto <D.24902>; else goto <D.24903>;
      <D.24902>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24905>; else goto <D.24906>;
      <D.24905>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24907 = monoeg_strdup ("MethodSig: Not enough room for the call conv");
        vinfo->info.message = D.24907;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24909 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24909;
      }
      <D.24906>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24903>:
      cconv.88 = cconv;
      D.24912 = cconv.88 & 128;
      if (D.24912 != 0) goto <D.24913>; else goto <D.24914>;
      <D.24913>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24915>; else goto <D.24916>;
      <D.24915>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24917 = monoeg_strdup ("MethodSig: CallConv has 0x80 set");
        vinfo->info.message = D.24917;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24918 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24918;
      }
      <D.24916>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24914>:
      if (allow_unmanaged != 0) goto <D.24919>; else goto <D.24920>;
      <D.24919>:
      cconv.88 = cconv;
      D.24921 = cconv.88 & 15;
      if (D.24921 > 5) goto <D.24922>; else goto <D.24923>;
      <D.24922>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24924>; else goto <D.24925>;
      <D.24924>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.88 = cconv;
        D.24921 = cconv.88 & 15;
        D.24926 = monoeg_g_strdup_printf ("MethodSig: CallConv is not valid, it\'s %x", D.24921);
        vinfo->info.message = D.24926;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24927 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24927;
      }
      <D.24925>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24923>:
      goto <D.24928>;
      <D.24920>:
      cconv.88 = cconv;
      D.24929 = cconv.88 & 15;
      D.24930 = D.24929 != 0;
      D.24931 = D.24929 != 5;
      D.24932 = D.24930 & D.24931;
      if (D.24932 != 0) goto <D.24933>; else goto <D.24934>;
      <D.24933>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24935>; else goto <D.24936>;
      <D.24935>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        cconv.88 = cconv;
        D.24921 = cconv.88 & 15;
        D.24937 = monoeg_g_strdup_printf ("MethodSig: CallConv is not Default or Vararg, it\'s %x", D.24921);
        vinfo->info.message = D.24937;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24938 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24938;
      }
      <D.24936>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24934>:
      <D.24928>:
      cconv.88 = cconv;
      D.24939 = cconv.88 & 16;
      if (D.24939 != 0) goto <D.24940>; else goto <D.24941>;
      <D.24940>:
      D.24942 = safe_read_compressed_int (&ptr, end, &gparam_count);
      if (D.24942 == 0) goto <D.24943>; else goto <D.24944>;
      <D.24943>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24945>; else goto <D.24946>;
      <D.24945>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24947 = monoeg_strdup ("MethodSig: Not enough room for the generic param count");
        vinfo->info.message = D.24947;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24948 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24948;
      }
      <D.24946>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24944>:
      <D.24941>:
      cconv.88 = cconv;
      D.24939 = cconv.88 & 16;
      if (D.24939 != 0) goto <D.24949>; else goto <D.24950>;
      <D.24949>:
      gparam_count.89 = gparam_count;
      if (gparam_count.89 == 0) goto <D.24952>; else goto <D.24953>;
      <D.24952>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24954>; else goto <D.24955>;
      <D.24954>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24956 = monoeg_strdup ("MethodSig: Signature with generics but zero arity");
        vinfo->info.message = D.24956;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24957 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24957;
      }
      <D.24955>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24953>:
      <D.24950>:
      if (allow_unmanaged != 0) goto <D.24958>; else goto <D.24959>;
      <D.24958>:
      cconv.88 = cconv;
      D.24939 = cconv.88 & 16;
      if (D.24939 != 0) goto <D.24960>; else goto <D.24961>;
      <D.24960>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24962>; else goto <D.24963>;
      <D.24962>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24964 = monoeg_strdup ("MethodSig: Standalone signature with generic params");
        vinfo->info.message = D.24964;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24965 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24965;
      }
      <D.24963>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24961>:
      <D.24959>:
      D.24966 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.24966 == 0) goto <D.24967>; else goto <D.24968>;
      <D.24967>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24969>; else goto <D.24970>;
      <D.24969>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24971 = monoeg_strdup ("MethodSig: Not enough room for the param count");
        vinfo->info.message = D.24971;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24972 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24972;
      }
      <D.24970>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24968>:
      D.24973 = parse_return_type (ctx, &ptr, end);
      if (D.24973 == 0) goto <D.24974>; else goto <D.24975>;
      <D.24974>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24976>; else goto <D.24977>;
      <D.24976>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24978 = monoeg_strdup ("MethodSig: Error parsing return type");
        vinfo->info.message = D.24978;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24979 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24979;
      }
      <D.24977>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24975>:
      i = 0;
      goto <D.20542>;
      <D.20541>:
      if (allow_sentinel != 0) goto <D.24980>; else goto <D.24981>;
      <D.24980>:
      D.24982 = safe_read (&ptr, end, &type, 1);
      if (D.24982 == 0) goto <D.24983>; else goto <D.24984>;
      <D.24983>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24985>; else goto <D.24986>;
      <D.24985>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24987 = monoeg_g_strdup_printf ("MethodSig: Not enough room for param %d type", i);
        vinfo->info.message = D.24987;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24988 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24988;
      }
      <D.24986>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24984>:
      type.90 = type;
      if (type.90 == 65) goto <D.24990>; else goto <D.24991>;
      <D.24990>:
      cconv.88 = cconv;
      D.24921 = cconv.88 & 15;
      if (D.24921 != 5) goto <D.24992>; else goto <D.24993>;
      <D.24992>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.24994>; else goto <D.24995>;
      <D.24994>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.24996 = monoeg_strdup ("MethodSig: Found sentinel but signature is not vararg");
        vinfo->info.message = D.24996;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.24997 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.24997;
      }
      <D.24995>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24993>:
      if (saw_sentinel != 0) goto <D.24998>; else goto <D.24999>;
      <D.24998>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.25000>; else goto <D.25001>;
      <D.25000>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25002 = monoeg_strdup ("MethodSig: More than one sentinel type");
        vinfo->info.message = D.25002;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.25003 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.25003;
      }
      <D.25001>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.24999>:
      saw_sentinel = 1;
      goto <D.25004>;
      <D.24991>:
      ptr.91 = ptr;
      ptr.92 = ptr.91 + 4294967295;
      ptr = ptr.92;
      <D.25004>:
      <D.24981>:
      D.25007 = parse_param (ctx, &ptr, end);
      if (D.25007 == 0) goto <D.25008>; else goto <D.25009>;
      <D.25008>:
      D.24904 = ctx->report_error;
      if (D.24904 != 0) goto <D.25010>; else goto <D.25011>;
      <D.25010>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25012 = monoeg_g_strdup_printf ("MethodSig: Error parsing arg %d", i);
        vinfo->info.message = D.25012;
        vinfo->exception_type = 3;
        D.24908 = ctx->errors;
        D.25013 = monoeg_g_slist_prepend (D.24908, vinfo);
        ctx->errors = D.25013;
      }
      <D.25011>:
      ctx->valid = 0;
      D.24910 = 0;
      return D.24910;
      <D.25009>:
      i = i + 1;
      <D.20542>:
      param_count.93 = param_count;
      if (i < param_count.93) goto <D.20541>; else goto <D.20543>;
      <D.20543>:
      ptr.91 = ptr;
      *_ptr = ptr.91;
      D.24910 = 1;
      return D.24910;
    }
  finally
    {
      cconv = {CLOBBER};
      param_count = {CLOBBER};
      gparam_count = {CLOBBER};
      type = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_return_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.25017;
  gboolean D.25020;
  const char * ptr.94;
  int D.25022;
  int D.25025;
  gchar * D.25028;
  struct GSList * D.25029;
  struct GSList * D.25030;
  unsigned int type.95;
  _Bool D.25032;
  _Bool D.25033;
  _Bool D.25034;
  const char * ptr.96;
  unsigned int type.97;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.25017 = parse_custom_mods (ctx, _ptr, end);
      if (D.25017 == 0) goto <D.25018>; else goto <D.25019>;
      <D.25018>:
      D.25020 = 0;
      return D.25020;
      <D.25019>:
      ptr.94 = *_ptr;
      ptr = ptr.94;
      D.25022 = safe_read (&ptr, end, &type, 1);
      if (D.25022 == 0) goto <D.25023>; else goto <D.25024>;
      <D.25023>:
      D.25025 = ctx->report_error;
      if (D.25025 != 0) goto <D.25026>; else goto <D.25027>;
      <D.25026>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25028 = monoeg_strdup ("ReturnType: Not enough room for the type");
        vinfo->info.message = D.25028;
        vinfo->exception_type = 3;
        D.25029 = ctx->errors;
        D.25030 = monoeg_g_slist_prepend (D.25029, vinfo);
        ctx->errors = D.25030;
      }
      <D.25027>:
      ctx->valid = 0;
      D.25020 = 0;
      return D.25020;
      <D.25024>:
      type.95 = type;
      D.25032 = type.95 == 1;
      D.25033 = type.95 == 22;
      D.25034 = D.25032 | D.25033;
      if (D.25034 != 0) goto <D.25035>; else goto <D.25036>;
      <D.25035>:
      ptr.96 = ptr;
      *_ptr = ptr.96;
      D.25020 = 1;
      return D.25020;
      <D.25036>:
      type.97 = type;
      if (type.97 == 16) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      ptr.96 = ptr;
      *_ptr = ptr.96;
      <D.25040>:
      D.25020 = parse_type (ctx, _ptr, end);
      return D.25020;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


parse_param (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.25043;
  gboolean D.25046;
  const char * ptr.98;
  int D.25048;
  int D.25051;
  gchar * D.25054;
  struct GSList * D.25055;
  struct GSList * D.25056;
  unsigned int type.99;
  const char * ptr.100;
  int D.25063;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.25043 = parse_custom_mods (ctx, _ptr, end);
      if (D.25043 == 0) goto <D.25044>; else goto <D.25045>;
      <D.25044>:
      D.25046 = 0;
      return D.25046;
      <D.25045>:
      ptr.98 = *_ptr;
      ptr = ptr.98;
      D.25048 = safe_read (&ptr, end, &type, 1);
      if (D.25048 == 0) goto <D.25049>; else goto <D.25050>;
      <D.25049>:
      D.25051 = ctx->report_error;
      if (D.25051 != 0) goto <D.25052>; else goto <D.25053>;
      <D.25052>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25054 = monoeg_strdup ("Param: Not enough room for the type");
        vinfo->info.message = D.25054;
        vinfo->exception_type = 3;
        D.25055 = ctx->errors;
        D.25056 = monoeg_g_slist_prepend (D.25055, vinfo);
        ctx->errors = D.25056;
      }
      <D.25053>:
      ctx->valid = 0;
      D.25046 = 0;
      return D.25046;
      <D.25050>:
      type.99 = type;
      if (type.99 == 22) goto <D.25058>; else goto <D.25059>;
      <D.25058>:
      ptr.100 = ptr;
      *_ptr = ptr.100;
      D.25046 = 1;
      return D.25046;
      <D.25059>:
      type.99 = type;
      if (type.99 == 16) goto <D.25061>; else goto <D.25062>;
      <D.25061>:
      ptr.100 = ptr;
      *_ptr = ptr.100;
      D.25063 = parse_custom_mods (ctx, _ptr, end);
      if (D.25063 == 0) goto <D.25064>; else goto <D.25065>;
      <D.25064>:
      D.25046 = 0;
      return D.25046;
      <D.25065>:
      <D.25062>:
      D.25046 = parse_type (ctx, _ptr, end);
      return D.25046;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_methodimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25068;
  unsigned int D.25071;
  <unnamed-unsigned:24> D.25073;
  int D.25074;
  int D.25075;
  unsigned int D.25076;
  int D.25077;
  unsigned int D.25080;
  gchar * D.25081;
  struct GSList * D.25082;
  struct GSList * D.25083;
  unsigned int D.25084;
  unsigned int D.25085;
  gchar * D.25090;
  struct GSList * D.25091;
  int D.25092;
  gchar * D.25097;
  struct GSList * D.25098;
  unsigned int D.25099;
  gchar * D.25104;
  struct GSList * D.25105;
  int D.25106;
  gchar * D.25111;
  struct GSList * D.25112;
  <unnamed-unsigned:24> D.25113;
  int D.25114;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.25068 = ctx->image;
      table = &D.25068->tables[25];
      i = 0;
      goto <D.21391>;
      <D.21390>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.25071 = data[0];
      if (D.25071 == 0) goto <D.25069>; else goto <D.25072>;
      <D.25072>:
      D.25071 = data[0];
      D.25068 = ctx->image;
      D.25073 = D.25068->tables[2].rows;
      D.25074 = (int) D.25073;
      D.25075 = D.25074 + 1;
      D.25076 = (unsigned int) D.25075;
      if (D.25071 > D.25076) goto <D.25069>; else goto <D.25070>;
      <D.25069>:
      D.25077 = ctx->report_error;
      if (D.25077 != 0) goto <D.25078>; else goto <D.25079>;
      <D.25078>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25080 = data[2];
        D.25081 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d Class field %08x", i, D.25080);
        vinfo->info.message = D.25081;
        vinfo->exception_type = 3;
        D.25082 = ctx->errors;
        D.25083 = monoeg_g_slist_prepend (D.25082, vinfo);
        ctx->errors = D.25083;
      }
      <D.25079>:
      ctx->valid = 0;
      return;
      <D.25070>:
      D.25084 = data[1];
      D.25085 = get_coded_index_token (52, D.25084);
      if (D.25085 == 0) goto <D.25086>; else goto <D.25087>;
      <D.25086>:
      D.25077 = ctx->report_error;
      if (D.25077 != 0) goto <D.25088>; else goto <D.25089>;
      <D.25088>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25084 = data[1];
        D.25090 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.25084);
        vinfo->info.message = D.25090;
        vinfo->exception_type = 3;
        D.25082 = ctx->errors;
        D.25091 = monoeg_g_slist_prepend (D.25082, vinfo);
        ctx->errors = D.25091;
      }
      <D.25089>:
      ctx->valid = 0;
      return;
      <D.25087>:
      D.25084 = data[1];
      D.25092 = is_valid_coded_index (ctx, 52, D.25084);
      if (D.25092 == 0) goto <D.25093>; else goto <D.25094>;
      <D.25093>:
      D.25077 = ctx->report_error;
      if (D.25077 != 0) goto <D.25095>; else goto <D.25096>;
      <D.25095>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25084 = data[1];
        D.25097 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.25084);
        vinfo->info.message = D.25097;
        vinfo->exception_type = 3;
        D.25082 = ctx->errors;
        D.25098 = monoeg_g_slist_prepend (D.25082, vinfo);
        ctx->errors = D.25098;
      }
      <D.25096>:
      ctx->valid = 0;
      return;
      <D.25094>:
      D.25080 = data[2];
      D.25099 = get_coded_index_token (52, D.25080);
      if (D.25099 == 0) goto <D.25100>; else goto <D.25101>;
      <D.25100>:
      D.25077 = ctx->report_error;
      if (D.25077 != 0) goto <D.25102>; else goto <D.25103>;
      <D.25102>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25080 = data[2];
        D.25104 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.25080);
        vinfo->info.message = D.25104;
        vinfo->exception_type = 3;
        D.25082 = ctx->errors;
        D.25105 = monoeg_g_slist_prepend (D.25082, vinfo);
        ctx->errors = D.25105;
      }
      <D.25103>:
      ctx->valid = 0;
      return;
      <D.25101>:
      D.25080 = data[2];
      D.25106 = is_valid_coded_index (ctx, 52, D.25080);
      if (D.25106 == 0) goto <D.25107>; else goto <D.25108>;
      <D.25107>:
      D.25077 = ctx->report_error;
      if (D.25077 != 0) goto <D.25109>; else goto <D.25110>;
      <D.25109>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25080 = data[2];
        D.25111 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.25080);
        vinfo->info.message = D.25111;
        vinfo->exception_type = 3;
        D.25082 = ctx->errors;
        D.25112 = monoeg_g_slist_prepend (D.25082, vinfo);
        ctx->errors = D.25112;
      }
      <D.25110>:
      ctx->valid = 0;
      return;
      <D.25108>:
      i = i + 1;
      <D.21391>:
      D.25113 = table->rows;
      D.25114 = (int) D.25113;
      if (D.25114 > i) goto <D.21390>; else goto <D.21392>;
      <D.21392>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_moduleref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25118;
  unsigned int D.25119;
  int D.25120;
  int D.25123;
  gchar * D.25126;
  struct GSList * D.25127;
  struct GSList * D.25128;
  <unnamed-unsigned:24> D.25129;
  int D.25130;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.25118 = ctx->image;
      table = &D.25118->tables[26];
      i = 0;
      goto <D.21401>;
      <D.21400>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.25119 = data[0];
      D.25120 = is_valid_non_empty_string (ctx, D.25119);
      if (D.25120 == 0) goto <D.25121>; else goto <D.25122>;
      <D.25121>:
      D.25123 = ctx->report_error;
      if (D.25123 != 0) goto <D.25124>; else goto <D.25125>;
      <D.25124>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25119 = data[0];
        D.25126 = monoeg_g_strdup_printf ("Invalid ModuleRef row %d name field %08x", i, D.25119);
        vinfo->info.message = D.25126;
        vinfo->exception_type = 3;
        D.25127 = ctx->errors;
        D.25128 = monoeg_g_slist_prepend (D.25127, vinfo);
        ctx->errors = D.25128;
      }
      <D.25125>:
      ctx->valid = 0;
      return;
      <D.25122>:
      i = i + 1;
      <D.21401>:
      D.25129 = table->rows;
      D.25130 = (int) D.25129;
      if (D.25130 > i) goto <D.21400>; else goto <D.21402>;
      <D.21402>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_typespec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25134;
  unsigned int D.25135;
  int D.25138;
  int D.25141;
  gchar * D.25144;
  struct GSList * D.25145;
  struct GSList * D.25146;
  <unnamed-unsigned:24> D.25147;
  int D.25148;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.25134 = ctx->image;
      table = &D.25134->tables[27];
      i = 0;
      goto <D.21411>;
      <D.21410>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.25135 = data[0];
      if (D.25135 != 0) goto <D.25136>; else goto <D.25137>;
      <D.25136>:
      D.25135 = data[0];
      D.25138 = is_valid_blob_object (ctx, D.25135, 1);
      if (D.25138 == 0) goto <D.25139>; else goto <D.25140>;
      <D.25139>:
      D.25141 = ctx->report_error;
      if (D.25141 != 0) goto <D.25142>; else goto <D.25143>;
      <D.25142>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25135 = data[0];
        D.25144 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.25135);
        vinfo->info.message = D.25144;
        vinfo->exception_type = 3;
        D.25145 = ctx->errors;
        D.25146 = monoeg_g_slist_prepend (D.25145, vinfo);
        ctx->errors = D.25146;
      }
      <D.25143>:
      ctx->valid = 0;
      return;
      <D.25140>:
      <D.25137>:
      i = i + 1;
      <D.21411>:
      D.25147 = table->rows;
      D.25148 = (int) D.25147;
      if (D.25148 > i) goto <D.21410>; else goto <D.21412>;
      <D.21412>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_implmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25152;
  unsigned int D.25153;
  unsigned int D.25154;
  int D.25157;
  gchar * D.25160;
  struct GSList * D.25161;
  struct GSList * D.25162;
  _Bool D.25165;
  _Bool D.25166;
  _Bool D.25167;
  gchar * D.25171;
  struct GSList * D.25172;
  unsigned int D.25173;
  int D.25174;
  gchar * D.25179;
  struct GSList * D.25180;
  unsigned int D.25181;
  gchar * D.25186;
  struct GSList * D.25187;
  unsigned int D.25188;
  gchar * D.25193;
  struct GSList * D.25194;
  unsigned int D.25195;
  int D.25196;
  gchar * D.25201;
  struct GSList * D.25202;
  unsigned int D.25205;
  <unnamed-unsigned:24> D.25207;
  unsigned int D.25208;
  gchar * D.25211;
  struct GSList * D.25212;
  <unnamed-unsigned:24> D.25213;
  int D.25214;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 cconv;
  int i;

  try
    {
      D.25152 = ctx->image;
      table = &D.25152->tables[28];
      i = 0;
      goto <D.21438>;
      <D.21437>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.25153 = data[0];
      D.25154 = D.25153 & 4294953096;
      if (D.25154 != 0) goto <D.25155>; else goto <D.25156>;
      <D.25155>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25158>; else goto <D.25159>;
      <D.25158>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25153 = data[0];
        D.25160 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Flags field %08x", i, D.25153);
        vinfo->info.message = D.25160;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25162 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25162;
      }
      <D.25159>:
      ctx->valid = 0;
      return;
      <D.25156>:
      D.25153 = data[0];
      cconv = D.25153 & 1792;
      D.25165 = cconv == 0;
      D.25166 = cconv == 1536;
      D.25167 = D.25165 | D.25166;
      if (D.25167 != 0) goto <D.25163>; else goto <D.25168>;
      <D.25168>:
      if (cconv == 1792) goto <D.25163>; else goto <D.25164>;
      <D.25163>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25169>; else goto <D.25170>;
      <D.25169>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25171 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid call conv field %x", i, cconv);
        vinfo->info.message = D.25171;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25172 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25172;
      }
      <D.25170>:
      ctx->valid = 0;
      return;
      <D.25164>:
      D.25173 = data[1];
      D.25174 = is_valid_coded_index (ctx, 56, D.25173);
      if (D.25174 == 0) goto <D.25175>; else goto <D.25176>;
      <D.25175>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25177>; else goto <D.25178>;
      <D.25177>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25173 = data[1];
        D.25179 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid MemberForward token %x", i, D.25173);
        vinfo->info.message = D.25179;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25180 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25180;
      }
      <D.25178>:
      ctx->valid = 0;
      return;
      <D.25176>:
      D.25173 = data[1];
      D.25181 = get_coded_index_table (56, D.25173);
      if (D.25181 != 6) goto <D.25182>; else goto <D.25183>;
      <D.25182>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25184>; else goto <D.25185>;
      <D.25184>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25173 = data[1];
        D.25186 = monoeg_g_strdup_printf ("Invalid ImplMap row %d only methods are supported token %x", i, D.25173);
        vinfo->info.message = D.25186;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25187 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25187;
      }
      <D.25185>:
      ctx->valid = 0;
      return;
      <D.25183>:
      D.25173 = data[1];
      D.25188 = get_coded_index_token (56, D.25173);
      if (D.25188 == 0) goto <D.25189>; else goto <D.25190>;
      <D.25189>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25191>; else goto <D.25192>;
      <D.25191>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25193 = monoeg_g_strdup_printf ("Invalid ImplMap row %d null token", i);
        vinfo->info.message = D.25193;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25194 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25194;
      }
      <D.25192>:
      ctx->valid = 0;
      return;
      <D.25190>:
      D.25195 = data[2];
      D.25196 = is_valid_non_empty_string (ctx, D.25195);
      if (D.25196 == 0) goto <D.25197>; else goto <D.25198>;
      <D.25197>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25199>; else goto <D.25200>;
      <D.25199>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25195 = data[2];
        D.25201 = monoeg_g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, D.25195);
        vinfo->info.message = D.25201;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25202 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25202;
      }
      <D.25200>:
      ctx->valid = 0;
      return;
      <D.25198>:
      D.25205 = data[3];
      if (D.25205 == 0) goto <D.25203>; else goto <D.25206>;
      <D.25206>:
      D.25205 = data[3];
      D.25152 = ctx->image;
      D.25207 = D.25152->tables[26].rows;
      D.25208 = (unsigned int) D.25207;
      if (D.25205 > D.25208) goto <D.25203>; else goto <D.25204>;
      <D.25203>:
      D.25157 = ctx->report_error;
      if (D.25157 != 0) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25205 = data[3];
        D.25211 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, D.25205);
        vinfo->info.message = D.25211;
        vinfo->exception_type = 3;
        D.25161 = ctx->errors;
        D.25212 = monoeg_g_slist_prepend (D.25161, vinfo);
        ctx->errors = D.25212;
      }
      <D.25210>:
      ctx->valid = 0;
      return;
      <D.25204>:
      i = i + 1;
      <D.21438>:
      D.25213 = table->rows;
      D.25214 = (int) D.25213;
      if (D.25214 > i) goto <D.21437>; else goto <D.21439>;
      <D.21439>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_fieldrva_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25218;
  unsigned int D.25221;
  unsigned int D.25223;
  int D.25224;
  gchar * D.25227;
  struct GSList * D.25228;
  struct GSList * D.25229;
  unsigned int D.25232;
  <unnamed-unsigned:24> D.25234;
  int D.25235;
  int D.25236;
  unsigned int D.25237;
  gchar * D.25240;
  struct GSList * D.25241;
  <unnamed-unsigned:24> D.25242;
  int D.25243;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.25218 = ctx->image;
      table = &D.25218->tables[29];
      i = 0;
      goto <D.21449>;
      <D.21448>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25221 = data[0];
      if (D.25221 == 0) goto <D.25219>; else goto <D.25222>;
      <D.25222>:
      D.25218 = ctx->image;
      D.25221 = data[0];
      D.25223 = mono_cli_rva_image_map (D.25218, D.25221);
      if (D.25223 == 4294967295) goto <D.25219>; else goto <D.25220>;
      <D.25219>:
      D.25224 = ctx->report_error;
      if (D.25224 != 0) goto <D.25225>; else goto <D.25226>;
      <D.25225>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25221 = data[0];
        D.25227 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d RVA %08x", i, D.25221);
        vinfo->info.message = D.25227;
        vinfo->exception_type = 3;
        D.25228 = ctx->errors;
        D.25229 = monoeg_g_slist_prepend (D.25228, vinfo);
        ctx->errors = D.25229;
      }
      <D.25226>:
      ctx->valid = 0;
      return;
      <D.25220>:
      D.25232 = data[1];
      if (D.25232 == 0) goto <D.25230>; else goto <D.25233>;
      <D.25233>:
      D.25232 = data[1];
      D.25218 = ctx->image;
      D.25234 = D.25218->tables[4].rows;
      D.25235 = (int) D.25234;
      D.25236 = D.25235 + 1;
      D.25237 = (unsigned int) D.25236;
      if (D.25232 > D.25237) goto <D.25230>; else goto <D.25231>;
      <D.25230>:
      D.25224 = ctx->report_error;
      if (D.25224 != 0) goto <D.25238>; else goto <D.25239>;
      <D.25238>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25232 = data[1];
        D.25240 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d Field %08x", i, D.25232);
        vinfo->info.message = D.25240;
        vinfo->exception_type = 3;
        D.25228 = ctx->errors;
        D.25241 = monoeg_g_slist_prepend (D.25228, vinfo);
        ctx->errors = D.25241;
      }
      <D.25239>:
      ctx->valid = 0;
      return;
      <D.25231>:
      i = i + 1;
      <D.21449>:
      D.25242 = table->rows;
      D.25243 = (int) D.25242;
      if (D.25243 > i) goto <D.21448>; else goto <D.21450>;
      <D.21450>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assembly_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25247;
  <unnamed-unsigned:24> D.25248;
  int D.25249;
  int D.25252;
  gchar * D.25255;
  struct GSList * D.25256;
  struct GSList * D.25257;
  _Bool D.25258;
  _Bool D.25259;
  _Bool D.25260;
  gchar * D.25267;
  struct GSList * D.25268;
  unsigned int D.25269;
  unsigned int D.25270;
  gchar * D.25275;
  struct GSList * D.25276;
  unsigned int D.25277;
  int D.25280;
  gchar * D.25285;
  struct GSList * D.25286;
  unsigned int D.25287;
  int D.25288;
  gchar * D.25293;
  struct GSList * D.25294;
  unsigned int D.25295;
  int D.25298;
  gchar * D.25303;
  struct GSList * D.25304;
  struct MonoTableInfo * table;
  guint32 data[9];
  guint32 hash;
  int i;

  try
    {
      D.25247 = ctx->image;
      table = &D.25247->tables[32];
      D.25248 = table->rows;
      D.25249 = (int) D.25248;
      if (D.25249 > 1) goto <D.25250>; else goto <D.25251>;
      <D.25250>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25253>; else goto <D.25254>;
      <D.25253>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25248 = table->rows;
        D.25249 = (int) D.25248;
        D.25255 = monoeg_g_strdup_printf ("Assembly table can have zero or one rows, but now %d", D.25249);
        vinfo->info.message = D.25255;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25257 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25257;
      }
      <D.25254>:
      ctx->valid = 0;
      return;
      <D.25251>:
      i = 0;
      goto <D.21465>;
      <D.21464>:
      mono_metadata_decode_row (table, i, &data, 9);
      hash = data[0];
      D.25258 = hash != 0;
      D.25259 = hash != 32771;
      D.25260 = D.25258 & D.25259;
      if (D.25260 != 0) goto <D.25261>; else goto <D.25262>;
      <D.25261>:
      if (hash != 32772) goto <D.25263>; else goto <D.25264>;
      <D.25263>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25265>; else goto <D.25266>;
      <D.25265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25267 = monoeg_g_strdup_printf ("Assembly table row %d has invalid HashAlgId %x", i, hash);
        vinfo->info.message = D.25267;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25268 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25268;
      }
      <D.25266>:
      ctx->valid = 0;
      return;
      <D.25264>:
      <D.25262>:
      D.25269 = data[5];
      D.25270 = D.25269 & 4294917646;
      if (D.25270 != 0) goto <D.25271>; else goto <D.25272>;
      <D.25271>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25273>; else goto <D.25274>;
      <D.25273>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25269 = data[5];
        D.25275 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, D.25269);
        vinfo->info.message = D.25275;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25276 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25276;
      }
      <D.25274>:
      ctx->valid = 0;
      return;
      <D.25272>:
      D.25277 = data[6];
      if (D.25277 != 0) goto <D.25278>; else goto <D.25279>;
      <D.25278>:
      D.25277 = data[6];
      D.25280 = is_valid_blob_object (ctx, D.25277, 1);
      if (D.25280 == 0) goto <D.25281>; else goto <D.25282>;
      <D.25281>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25283>; else goto <D.25284>;
      <D.25283>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25269 = data[5];
        D.25285 = monoeg_g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, D.25269);
        vinfo->info.message = D.25285;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25286 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25286;
      }
      <D.25284>:
      ctx->valid = 0;
      return;
      <D.25282>:
      <D.25279>:
      D.25287 = data[7];
      D.25288 = is_valid_non_empty_string (ctx, D.25287);
      if (D.25288 == 0) goto <D.25289>; else goto <D.25290>;
      <D.25289>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25291>; else goto <D.25292>;
      <D.25291>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25287 = data[7];
        D.25293 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Name %08x", i, D.25287);
        vinfo->info.message = D.25293;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25294 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25294;
      }
      <D.25292>:
      ctx->valid = 0;
      return;
      <D.25290>:
      D.25295 = data[8];
      if (D.25295 != 0) goto <D.25296>; else goto <D.25297>;
      <D.25296>:
      D.25295 = data[8];
      D.25298 = is_valid_string (ctx, D.25295);
      if (D.25298 == 0) goto <D.25299>; else goto <D.25300>;
      <D.25299>:
      D.25252 = ctx->report_error;
      if (D.25252 != 0) goto <D.25301>; else goto <D.25302>;
      <D.25301>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25295 = data[8];
        D.25303 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Culture %08x", i, D.25295);
        vinfo->info.message = D.25303;
        vinfo->exception_type = 3;
        D.25256 = ctx->errors;
        D.25304 = monoeg_g_slist_prepend (D.25256, vinfo);
        ctx->errors = D.25304;
      }
      <D.25302>:
      ctx->valid = 0;
      return;
      <D.25300>:
      <D.25297>:
      i = i + 1;
      <D.21465>:
      D.25248 = table->rows;
      D.25249 = (int) D.25248;
      if (D.25249 > i) goto <D.21464>; else goto <D.21466>;
      <D.21466>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assemblyref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25308;
  unsigned int D.25309;
  unsigned int D.25310;
  int D.25313;
  gchar * D.25316;
  struct GSList * D.25317;
  struct GSList * D.25318;
  unsigned int D.25319;
  int D.25322;
  gchar * D.25327;
  struct GSList * D.25328;
  unsigned int D.25329;
  int D.25330;
  gchar * D.25335;
  struct GSList * D.25336;
  unsigned int D.25337;
  int D.25340;
  gchar * D.25345;
  struct GSList * D.25346;
  unsigned int D.25347;
  int D.25350;
  gchar * D.25355;
  struct GSList * D.25356;
  <unnamed-unsigned:24> D.25357;
  int D.25358;
  struct MonoTableInfo * table;
  guint32 data[9];
  int i;

  try
    {
      D.25308 = ctx->image;
      table = &D.25308->tables[35];
      i = 0;
      goto <D.21479>;
      <D.21478>:
      mono_metadata_decode_row (table, i, &data, 9);
      D.25309 = data[4];
      D.25310 = D.25309 & 4294917886;
      if (D.25310 != 0) goto <D.25311>; else goto <D.25312>;
      <D.25311>:
      D.25313 = ctx->report_error;
      if (D.25313 != 0) goto <D.25314>; else goto <D.25315>;
      <D.25314>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25309 = data[4];
        D.25316 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Flags %08x", i, D.25309);
        vinfo->info.message = D.25316;
        vinfo->exception_type = 3;
        D.25317 = ctx->errors;
        D.25318 = monoeg_g_slist_prepend (D.25317, vinfo);
        ctx->errors = D.25318;
      }
      <D.25315>:
      ctx->valid = 0;
      return;
      <D.25312>:
      D.25319 = data[5];
      if (D.25319 != 0) goto <D.25320>; else goto <D.25321>;
      <D.25320>:
      D.25319 = data[5];
      D.25322 = is_valid_blob_object (ctx, D.25319, 1);
      if (D.25322 == 0) goto <D.25323>; else goto <D.25324>;
      <D.25323>:
      D.25313 = ctx->report_error;
      if (D.25313 != 0) goto <D.25325>; else goto <D.25326>;
      <D.25325>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25319 = data[5];
        D.25327 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, D.25319);
        vinfo->info.message = D.25327;
        vinfo->exception_type = 3;
        D.25317 = ctx->errors;
        D.25328 = monoeg_g_slist_prepend (D.25317, vinfo);
        ctx->errors = D.25328;
      }
      <D.25326>:
      ctx->valid = 0;
      return;
      <D.25324>:
      <D.25321>:
      D.25329 = data[6];
      D.25330 = is_valid_non_empty_string (ctx, D.25329);
      if (D.25330 == 0) goto <D.25331>; else goto <D.25332>;
      <D.25331>:
      D.25313 = ctx->report_error;
      if (D.25313 != 0) goto <D.25333>; else goto <D.25334>;
      <D.25333>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25329 = data[6];
        D.25335 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Name %08x", i, D.25329);
        vinfo->info.message = D.25335;
        vinfo->exception_type = 3;
        D.25317 = ctx->errors;
        D.25336 = monoeg_g_slist_prepend (D.25317, vinfo);
        ctx->errors = D.25336;
      }
      <D.25334>:
      ctx->valid = 0;
      return;
      <D.25332>:
      D.25337 = data[7];
      if (D.25337 != 0) goto <D.25338>; else goto <D.25339>;
      <D.25338>:
      D.25337 = data[7];
      D.25340 = is_valid_string (ctx, D.25337);
      if (D.25340 == 0) goto <D.25341>; else goto <D.25342>;
      <D.25341>:
      D.25313 = ctx->report_error;
      if (D.25313 != 0) goto <D.25343>; else goto <D.25344>;
      <D.25343>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25337 = data[7];
        D.25345 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, D.25337);
        vinfo->info.message = D.25345;
        vinfo->exception_type = 3;
        D.25317 = ctx->errors;
        D.25346 = monoeg_g_slist_prepend (D.25317, vinfo);
        ctx->errors = D.25346;
      }
      <D.25344>:
      ctx->valid = 0;
      return;
      <D.25342>:
      <D.25339>:
      D.25347 = data[8];
      if (D.25347 != 0) goto <D.25348>; else goto <D.25349>;
      <D.25348>:
      D.25347 = data[8];
      D.25350 = is_valid_blob_object (ctx, D.25347, 1);
      if (D.25350 == 0) goto <D.25351>; else goto <D.25352>;
      <D.25351>:
      D.25313 = ctx->report_error;
      if (D.25313 != 0) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25347 = data[8];
        D.25355 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, D.25347);
        vinfo->info.message = D.25355;
        vinfo->exception_type = 3;
        D.25317 = ctx->errors;
        D.25356 = monoeg_g_slist_prepend (D.25317, vinfo);
        ctx->errors = D.25356;
      }
      <D.25354>:
      ctx->valid = 0;
      return;
      <D.25352>:
      <D.25349>:
      i = i + 1;
      <D.21479>:
      D.25357 = table->rows;
      D.25358 = (int) D.25357;
      if (D.25358 > i) goto <D.21478>; else goto <D.21480>;
      <D.21480>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_file_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25362;
  unsigned int D.25363;
  unsigned int D.25364;
  int D.25367;
  gchar * D.25370;
  struct GSList * D.25371;
  struct GSList * D.25372;
  unsigned int D.25373;
  int D.25374;
  gchar * D.25379;
  struct GSList * D.25380;
  unsigned int D.25383;
  int D.25385;
  gchar * D.25388;
  struct GSList * D.25389;
  <unnamed-unsigned:24> D.25390;
  int D.25391;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.25362 = ctx->image;
      table = &D.25362->tables[38];
      i = 0;
      goto <D.21491>;
      <D.21490>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.25363 = data[0];
      D.25364 = D.25363 & 4294967294;
      if (D.25364 != 0) goto <D.25365>; else goto <D.25366>;
      <D.25365>:
      D.25367 = ctx->report_error;
      if (D.25367 != 0) goto <D.25368>; else goto <D.25369>;
      <D.25368>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25363 = data[0];
        D.25370 = monoeg_g_strdup_printf ("File table row %d has invalid Flags %08x", i, D.25363);
        vinfo->info.message = D.25370;
        vinfo->exception_type = 3;
        D.25371 = ctx->errors;
        D.25372 = monoeg_g_slist_prepend (D.25371, vinfo);
        ctx->errors = D.25372;
      }
      <D.25369>:
      ctx->valid = 0;
      return;
      <D.25366>:
      D.25373 = data[1];
      D.25374 = is_valid_non_empty_string (ctx, D.25373);
      if (D.25374 == 0) goto <D.25375>; else goto <D.25376>;
      <D.25375>:
      D.25367 = ctx->report_error;
      if (D.25367 != 0) goto <D.25377>; else goto <D.25378>;
      <D.25377>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25373 = data[1];
        D.25379 = monoeg_g_strdup_printf ("File table row %d has invalid Name %08x", i, D.25373);
        vinfo->info.message = D.25379;
        vinfo->exception_type = 3;
        D.25371 = ctx->errors;
        D.25380 = monoeg_g_slist_prepend (D.25371, vinfo);
        ctx->errors = D.25380;
      }
      <D.25378>:
      ctx->valid = 0;
      return;
      <D.25376>:
      D.25383 = data[2];
      if (D.25383 == 0) goto <D.25381>; else goto <D.25384>;
      <D.25384>:
      D.25383 = data[2];
      D.25385 = is_valid_blob_object (ctx, D.25383, 1);
      if (D.25385 == 0) goto <D.25381>; else goto <D.25382>;
      <D.25381>:
      D.25367 = ctx->report_error;
      if (D.25367 != 0) goto <D.25386>; else goto <D.25387>;
      <D.25386>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25383 = data[2];
        D.25388 = monoeg_g_strdup_printf ("File table row %d has invalid HashValue %08x", i, D.25383);
        vinfo->info.message = D.25388;
        vinfo->exception_type = 3;
        D.25371 = ctx->errors;
        D.25389 = monoeg_g_slist_prepend (D.25371, vinfo);
        ctx->errors = D.25389;
      }
      <D.25387>:
      ctx->valid = 0;
      return;
      <D.25382>:
      i = i + 1;
      <D.21491>:
      D.25390 = table->rows;
      D.25391 = (int) D.25390;
      if (D.25391 > i) goto <D.21490>; else goto <D.21492>;
      <D.21492>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_exportedtype_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25395;
  unsigned int D.25396;
  unsigned int D.25397;
  int D.25400;
  gchar * D.25403;
  struct GSList * D.25404;
  struct GSList * D.25405;
  unsigned int D.25406;
  int D.25407;
  unsigned int D.25412;
  gchar * D.25413;
  struct GSList * D.25414;
  unsigned int D.25415;
  int D.25418;
  gchar * D.25423;
  struct GSList * D.25424;
  unsigned int D.25425;
  int D.25426;
  gchar * D.25431;
  struct GSList * D.25432;
  unsigned int D.25433;
  gchar * D.25438;
  struct GSList * D.25439;
  unsigned int D.25440;
  gchar * D.25447;
  struct GSList * D.25448;
  <unnamed-unsigned:24> D.25449;
  int D.25450;
  struct MonoTableInfo * table;
  guint32 data[5];
  int i;

  try
    {
      D.25395 = ctx->image;
      table = &D.25395->tables[39];
      i = 0;
      goto <D.21506>;
      <D.21505>:
      mono_metadata_decode_row (table, i, &data, 5);
      D.25396 = data[0];
      D.25397 = D.25396 & 4278764096;
      if (D.25397 != 0) goto <D.25398>; else goto <D.25399>;
      <D.25398>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25401>; else goto <D.25402>;
      <D.25401>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25396 = data[0];
        D.25403 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Flags %08x", i, D.25396);
        vinfo->info.message = D.25403;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25405 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25405;
      }
      <D.25402>:
      ctx->valid = 0;
      return;
      <D.25399>:
      D.25406 = data[2];
      D.25407 = is_valid_non_empty_string (ctx, D.25406);
      if (D.25407 == 0) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25410>; else goto <D.25411>;
      <D.25410>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25412 = data[1];
        D.25413 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeName %08x", i, D.25412);
        vinfo->info.message = D.25413;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25414 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25414;
      }
      <D.25411>:
      ctx->valid = 0;
      return;
      <D.25409>:
      D.25415 = data[3];
      if (D.25415 != 0) goto <D.25416>; else goto <D.25417>;
      <D.25416>:
      D.25415 = data[3];
      D.25418 = is_valid_string (ctx, D.25415);
      if (D.25418 == 0) goto <D.25419>; else goto <D.25420>;
      <D.25419>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25421>; else goto <D.25422>;
      <D.25421>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25415 = data[3];
        D.25423 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeNamespace %08x", i, D.25415);
        vinfo->info.message = D.25423;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25424 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25424;
      }
      <D.25422>:
      ctx->valid = 0;
      return;
      <D.25420>:
      <D.25417>:
      D.25425 = data[4];
      D.25426 = is_valid_coded_index (ctx, 60, D.25425);
      if (D.25426 == 0) goto <D.25427>; else goto <D.25428>;
      <D.25427>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25429>; else goto <D.25430>;
      <D.25429>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25425 = data[4];
        D.25431 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Implementation token %08x", i, D.25425);
        vinfo->info.message = D.25431;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25432 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25432;
      }
      <D.25430>:
      ctx->valid = 0;
      return;
      <D.25428>:
      D.25425 = data[4];
      D.25433 = get_coded_index_token (60, D.25425);
      if (D.25433 == 0) goto <D.25434>; else goto <D.25435>;
      <D.25434>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25436>; else goto <D.25437>;
      <D.25436>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25438 = monoeg_g_strdup_printf ("ExportedType table row %d has null Implementation token", i);
        vinfo->info.message = D.25438;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25439 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25439;
      }
      <D.25437>:
      ctx->valid = 0;
      return;
      <D.25435>:
      D.25425 = data[4];
      D.25440 = get_coded_index_table (60, D.25425);
      if (D.25440 == 39) goto <D.25441>; else goto <D.25442>;
      <D.25441>:
      D.25415 = data[3];
      if (D.25415 != 0) goto <D.25443>; else goto <D.25444>;
      <D.25443>:
      D.25400 = ctx->report_error;
      if (D.25400 != 0) goto <D.25445>; else goto <D.25446>;
      <D.25445>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25447 = monoeg_g_strdup_printf ("ExportedType table row %d has denotes a nested type but has a non null TypeNamespace", i);
        vinfo->info.message = D.25447;
        vinfo->exception_type = 3;
        D.25404 = ctx->errors;
        D.25448 = monoeg_g_slist_prepend (D.25404, vinfo);
        ctx->errors = D.25448;
      }
      <D.25446>:
      ctx->valid = 0;
      return;
      <D.25444>:
      <D.25442>:
      i = i + 1;
      <D.21506>:
      D.25449 = table->rows;
      D.25450 = (int) D.25449;
      if (D.25450 > i) goto <D.21505>; else goto <D.21507>;
      <D.21507>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_manifest_resource_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25454;
  unsigned int D.25455;
  unsigned int D.25456;
  int D.25459;
  gchar * D.25462;
  struct GSList * D.25463;
  struct GSList * D.25464;
  unsigned int D.25465;
  gchar * D.25470;
  struct GSList * D.25471;
  unsigned int D.25472;
  int D.25473;
  gchar * D.25478;
  struct GSList * D.25479;
  unsigned int D.25480;
  int D.25481;
  gchar * D.25486;
  struct GSList * D.25487;
  unsigned int D.25492;
  gchar * D.25493;
  struct GSList * D.25494;
  _Bool D.25495;
  _Bool D.25496;
  _Bool D.25497;
  unsigned int D.25500;
  gchar * D.25505;
  struct GSList * D.25506;
  gchar * D.25513;
  struct GSList * D.25514;
  <unnamed-unsigned:24> D.25515;
  int D.25516;
  struct MonoCLIImageInfo * iinfo;
  struct MonoCLIHeader * ch;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 impl_table;
  guint32 token;
  guint32 resources_size;
  int i;

  try
    {
      D.25454 = ctx->image;
      iinfo = D.25454->image_info;
      ch = &iinfo->cli_cli_header;
      D.25454 = ctx->image;
      table = &D.25454->tables[40];
      resources_size = ch->ch_resources.size;
      i = 0;
      goto <D.21527>;
      <D.21526>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.25455 = data[1];
      D.25456 = D.25455 & 4294967288;
      if (D.25456 != 0) goto <D.25457>; else goto <D.25458>;
      <D.25457>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25460>; else goto <D.25461>;
      <D.25460>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25455 = data[1];
        D.25462 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags %08x", i, D.25455);
        vinfo->info.message = D.25462;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25464 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25464;
      }
      <D.25461>:
      ctx->valid = 0;
      return;
      <D.25458>:
      D.25455 = data[1];
      D.25465 = D.25455 + 4294967295;
      if (D.25465 > 1) goto <D.25466>; else goto <D.25467>;
      <D.25466>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25468>; else goto <D.25469>;
      <D.25468>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25455 = data[1];
        D.25470 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags VisibilityMask %08x", i, D.25455);
        vinfo->info.message = D.25470;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25471 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25471;
      }
      <D.25469>:
      ctx->valid = 0;
      return;
      <D.25467>:
      D.25472 = data[2];
      D.25473 = is_valid_non_empty_string (ctx, D.25472);
      if (D.25473 == 0) goto <D.25474>; else goto <D.25475>;
      <D.25474>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25476>; else goto <D.25477>;
      <D.25476>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25472 = data[2];
        D.25478 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Name %08x", i, D.25472);
        vinfo->info.message = D.25478;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25479 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25479;
      }
      <D.25477>:
      ctx->valid = 0;
      return;
      <D.25475>:
      D.25480 = data[3];
      D.25481 = is_valid_coded_index (ctx, 60, D.25480);
      if (D.25481 == 0) goto <D.25482>; else goto <D.25483>;
      <D.25482>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25484>; else goto <D.25485>;
      <D.25484>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25480 = data[3];
        D.25486 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token %08x", i, D.25480);
        vinfo->info.message = D.25486;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25487 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25487;
      }
      <D.25485>:
      ctx->valid = 0;
      return;
      <D.25483>:
      D.25480 = data[3];
      impl_table = get_coded_index_table (60, D.25480);
      D.25480 = data[3];
      token = get_coded_index_token (60, D.25480);
      if (impl_table == 39) goto <D.25488>; else goto <D.25489>;
      <D.25488>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25490>; else goto <D.25491>;
      <D.25490>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25480 = data[3];
        D.25492 = get_coded_index_table (60, D.25480);
        D.25493 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token table %08x", i, D.25492);
        vinfo->info.message = D.25493;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25494 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25494;
      }
      <D.25491>:
      ctx->valid = 0;
      return;
      <D.25489>:
      D.25495 = impl_table == 38;
      D.25496 = token != 0;
      D.25497 = D.25495 & D.25496;
      if (D.25497 != 0) goto <D.25498>; else goto <D.25499>;
      <D.25498>:
      D.25500 = data[0];
      if (D.25500 != 0) goto <D.25501>; else goto <D.25502>;
      <D.25501>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25503>; else goto <D.25504>;
      <D.25503>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25505 = monoeg_g_strdup_printf ("ManifestResource table row %d points to a file but has non-zero offset", i);
        vinfo->info.message = D.25505;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25506 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25506;
      }
      <D.25504>:
      ctx->valid = 0;
      return;
      <D.25502>:
      <D.25499>:
      if (token == 0) goto <D.25507>; else goto <D.25508>;
      <D.25507>:
      D.25500 = data[0];
      if (D.25500 >= resources_size) goto <D.25509>; else goto <D.25510>;
      <D.25509>:
      D.25459 = ctx->report_error;
      if (D.25459 != 0) goto <D.25511>; else goto <D.25512>;
      <D.25511>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25500 = data[0];
        D.25513 = monoeg_g_strdup_printf ("ManifestResource table row %d invalid Offset field %08x ", i, D.25500);
        vinfo->info.message = D.25513;
        vinfo->exception_type = 3;
        D.25463 = ctx->errors;
        D.25514 = monoeg_g_slist_prepend (D.25463, vinfo);
        ctx->errors = D.25514;
      }
      <D.25512>:
      ctx->valid = 0;
      return;
      <D.25510>:
      <D.25508>:
      i = i + 1;
      <D.21527>:
      D.25515 = table->rows;
      D.25516 = (int) D.25515;
      if (D.25516 > i) goto <D.21526>; else goto <D.21528>;
      <D.21528>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_nested_class_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25520;
  unsigned int D.25523;
  <unnamed-unsigned:24> D.25525;
  unsigned int D.25526;
  int D.25527;
  gchar * D.25530;
  struct GSList * D.25531;
  struct GSList * D.25532;
  unsigned int D.25535;
  gchar * D.25539;
  struct GSList * D.25540;
  gchar * D.25545;
  struct GSList * D.25546;
  <unnamed-unsigned:24> D.25547;
  int D.25548;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.25520 = ctx->image;
      table = &D.25520->tables[41];
      i = 0;
      goto <D.21539>;
      <D.21538>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25523 = data[0];
      if (D.25523 == 0) goto <D.25521>; else goto <D.25524>;
      <D.25524>:
      D.25523 = data[0];
      D.25520 = ctx->image;
      D.25525 = D.25520->tables[2].rows;
      D.25526 = (unsigned int) D.25525;
      if (D.25523 > D.25526) goto <D.25521>; else goto <D.25522>;
      <D.25521>:
      D.25527 = ctx->report_error;
      if (D.25527 != 0) goto <D.25528>; else goto <D.25529>;
      <D.25528>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25523 = data[0];
        D.25530 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid NestedClass token %08x", i, D.25523);
        vinfo->info.message = D.25530;
        vinfo->exception_type = 3;
        D.25531 = ctx->errors;
        D.25532 = monoeg_g_slist_prepend (D.25531, vinfo);
        ctx->errors = D.25532;
      }
      <D.25529>:
      ctx->valid = 0;
      return;
      <D.25522>:
      D.25535 = data[1];
      if (D.25535 == 0) goto <D.25533>; else goto <D.25536>;
      <D.25536>:
      D.25535 = data[1];
      D.25520 = ctx->image;
      D.25525 = D.25520->tables[2].rows;
      D.25526 = (unsigned int) D.25525;
      if (D.25535 > D.25526) goto <D.25533>; else goto <D.25534>;
      <D.25533>:
      D.25527 = ctx->report_error;
      if (D.25527 != 0) goto <D.25537>; else goto <D.25538>;
      <D.25537>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25535 = data[1];
        D.25539 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid EnclosingClass token %08x", i, D.25535);
        vinfo->info.message = D.25539;
        vinfo->exception_type = 3;
        D.25531 = ctx->errors;
        D.25540 = monoeg_g_slist_prepend (D.25531, vinfo);
        ctx->errors = D.25540;
      }
      <D.25538>:
      ctx->valid = 0;
      return;
      <D.25534>:
      D.25535 = data[1];
      D.25523 = data[0];
      if (D.25535 == D.25523) goto <D.25541>; else goto <D.25542>;
      <D.25541>:
      D.25527 = ctx->report_error;
      if (D.25527 != 0) goto <D.25543>; else goto <D.25544>;
      <D.25543>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25535 = data[1];
        D.25545 = monoeg_g_strdup_printf ("NestedClass table row %d has same token for NestedClass  and EnclosingClass %08x", i, D.25535);
        vinfo->info.message = D.25545;
        vinfo->exception_type = 3;
        D.25531 = ctx->errors;
        D.25546 = monoeg_g_slist_prepend (D.25531, vinfo);
        ctx->errors = D.25546;
      }
      <D.25544>:
      ctx->valid = 0;
      return;
      <D.25542>:
      i = i + 1;
      <D.21539>:
      D.25547 = table->rows;
      D.25548 = (int) D.25547;
      if (D.25548 > i) goto <D.21538>; else goto <D.21540>;
      <D.21540>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25552;
  unsigned int D.25553;
  unsigned int D.25554;
  int D.25557;
  gchar * D.25560;
  struct GSList * D.25561;
  struct GSList * D.25562;
  unsigned int D.25563;
  gchar * D.25568;
  struct GSList * D.25569;
  unsigned int D.25570;
  int D.25571;
  gchar * D.25576;
  struct GSList * D.25577;
  int D.25578;
  gchar * D.25583;
  struct GSList * D.25584;
  unsigned int D.25585;
  gchar * D.25590;
  struct GSList * D.25591;
  unsigned int D.25594;
  unsigned int param_number.101;
  gchar * D.25600;
  struct GSList * D.25601;
  <unnamed-unsigned:24> D.25602;
  int D.25603;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 token;
  guint32 last_token;
  int i;
  int param_number;

  try
    {
      D.25552 = ctx->image;
      table = &D.25552->tables[42];
      last_token = 0;
      param_number = 0;
      i = 0;
      goto <D.21557>;
      <D.21556>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.25553 = data[1];
      D.25554 = D.25553 & 4294967264;
      if (D.25554 != 0) goto <D.25555>; else goto <D.25556>;
      <D.25555>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25558>; else goto <D.25559>;
      <D.25558>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25553 = data[1];
        D.25560 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Flags token %08x", i, D.25553);
        vinfo->info.message = D.25560;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25562 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25562;
      }
      <D.25559>:
      ctx->valid = 0;
      return;
      <D.25556>:
      D.25553 = data[1];
      D.25563 = D.25553 & 3;
      if (D.25563 == 3) goto <D.25564>; else goto <D.25565>;
      <D.25564>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25566>; else goto <D.25567>;
      <D.25566>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25568 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid VarianceMask 0x3", i);
        vinfo->info.message = D.25568;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25569 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25569;
      }
      <D.25567>:
      ctx->valid = 0;
      return;
      <D.25565>:
      D.25570 = data[3];
      D.25571 = is_valid_non_empty_string (ctx, D.25570);
      if (D.25571 == 0) goto <D.25572>; else goto <D.25573>;
      <D.25572>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25574>; else goto <D.25575>;
      <D.25574>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25570 = data[3];
        D.25576 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Name token %08x", i, D.25570);
        vinfo->info.message = D.25576;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25577 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25577;
      }
      <D.25575>:
      ctx->valid = 0;
      return;
      <D.25573>:
      token = data[2];
      D.25578 = is_valid_coded_index (ctx, 78, token);
      if (D.25578 == 0) goto <D.25579>; else goto <D.25580>;
      <D.25579>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25581>; else goto <D.25582>;
      <D.25581>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25583 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Owner token %08x", i, token);
        vinfo->info.message = D.25583;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25584 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25584;
      }
      <D.25582>:
      ctx->valid = 0;
      return;
      <D.25580>:
      D.25585 = get_coded_index_token (78, token);
      if (D.25585 == 0) goto <D.25586>; else goto <D.25587>;
      <D.25586>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25588>; else goto <D.25589>;
      <D.25588>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25590 = monoeg_g_strdup_printf ("GenericParam table row %d has null Owner token", i);
        vinfo->info.message = D.25590;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25591 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25591;
      }
      <D.25589>:
      ctx->valid = 0;
      return;
      <D.25587>:
      if (token != last_token) goto <D.25592>; else goto <D.25593>;
      <D.25592>:
      param_number = 0;
      last_token = token;
      <D.25593>:
      D.25594 = data[0];
      param_number.101 = (unsigned int) param_number;
      if (D.25594 != param_number.101) goto <D.25596>; else goto <D.25597>;
      <D.25596>:
      D.25557 = ctx->report_error;
      if (D.25557 != 0) goto <D.25598>; else goto <D.25599>;
      <D.25598>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25594 = data[0];
        D.25600 = monoeg_g_strdup_printf ("GenericParam table row %d Number is out of order %d expected %d", i, D.25594, param_number);
        vinfo->info.message = D.25600;
        vinfo->exception_type = 3;
        D.25561 = ctx->errors;
        D.25601 = monoeg_g_slist_prepend (D.25561, vinfo);
        ctx->errors = D.25601;
      }
      <D.25599>:
      ctx->valid = 0;
      return;
      <D.25597>:
      param_number = param_number + 1;
      i = i + 1;
      <D.21557>:
      D.25602 = table->rows;
      D.25603 = (int) D.25602;
      if (D.25603 > i) goto <D.21556>; else goto <D.21558>;
      <D.21558>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_method_spec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25607;
  unsigned int D.25608;
  int D.25609;
  int D.25612;
  gchar * D.25615;
  struct GSList * D.25616;
  struct GSList * D.25617;
  unsigned int D.25618;
  gchar * D.25623;
  struct GSList * D.25624;
  unsigned int D.25625;
  int D.25628;
  gchar * D.25633;
  struct GSList * D.25634;
  <unnamed-unsigned:24> D.25635;
  int D.25636;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.25607 = ctx->image;
      table = &D.25607->tables[43];
      i = 0;
      goto <D.21569>;
      <D.21568>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25608 = data[0];
      D.25609 = is_valid_coded_index (ctx, 52, D.25608);
      if (D.25609 == 0) goto <D.25610>; else goto <D.25611>;
      <D.25610>:
      D.25612 = ctx->report_error;
      if (D.25612 != 0) goto <D.25613>; else goto <D.25614>;
      <D.25613>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25608 = data[0];
        D.25615 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Method token %08x", i, D.25608);
        vinfo->info.message = D.25615;
        vinfo->exception_type = 3;
        D.25616 = ctx->errors;
        D.25617 = monoeg_g_slist_prepend (D.25616, vinfo);
        ctx->errors = D.25617;
      }
      <D.25614>:
      ctx->valid = 0;
      return;
      <D.25611>:
      D.25608 = data[0];
      D.25618 = get_coded_index_token (52, D.25608);
      if (D.25618 == 0) goto <D.25619>; else goto <D.25620>;
      <D.25619>:
      D.25612 = ctx->report_error;
      if (D.25612 != 0) goto <D.25621>; else goto <D.25622>;
      <D.25621>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25623 = monoeg_g_strdup_printf ("MethodSpec table row %d has null Method token", i);
        vinfo->info.message = D.25623;
        vinfo->exception_type = 3;
        D.25616 = ctx->errors;
        D.25624 = monoeg_g_slist_prepend (D.25616, vinfo);
        ctx->errors = D.25624;
      }
      <D.25622>:
      ctx->valid = 0;
      return;
      <D.25620>:
      D.25625 = data[1];
      if (D.25625 != 0) goto <D.25626>; else goto <D.25627>;
      <D.25626>:
      D.25625 = data[1];
      D.25628 = is_valid_blob_object (ctx, D.25625, 1);
      if (D.25628 == 0) goto <D.25629>; else goto <D.25630>;
      <D.25629>:
      D.25612 = ctx->report_error;
      if (D.25612 != 0) goto <D.25631>; else goto <D.25632>;
      <D.25631>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25625 = data[1];
        D.25633 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, D.25625);
        vinfo->info.message = D.25633;
        vinfo->exception_type = 3;
        D.25616 = ctx->errors;
        D.25634 = monoeg_g_slist_prepend (D.25616, vinfo);
        ctx->errors = D.25634;
      }
      <D.25632>:
      ctx->valid = 0;
      return;
      <D.25630>:
      <D.25627>:
      i = i + 1;
      <D.21569>:
      D.25635 = table->rows;
      D.25636 = (int) D.25635;
      if (D.25636 > i) goto <D.21568>; else goto <D.21570>;
      <D.21570>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_constraint_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.25640;
  unsigned int D.25643;
  <unnamed-unsigned:24> D.25645;
  unsigned int D.25646;
  int D.25647;
  gchar * D.25650;
  struct GSList * D.25651;
  struct GSList * D.25652;
  unsigned int D.25653;
  int D.25654;
  gchar * D.25659;
  struct GSList * D.25660;
  unsigned int D.25661;
  gchar * D.25666;
  struct GSList * D.25667;
  gchar * D.25672;
  struct GSList * D.25673;
  gchar * D.25680;
  struct GSList * D.25681;
  <unnamed-unsigned:24> D.25683;
  int D.25684;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;
  guint32 last_owner;
  guint32 last_constraint;

  try
    {
      D.25640 = ctx->image;
      table = &D.25640->tables[44];
      last_owner = 0;
      last_constraint = 0;
      i = 0;
      goto <D.21595>;
      <D.21594>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25643 = data[0];
      if (D.25643 == 0) goto <D.25641>; else goto <D.25644>;
      <D.25644>:
      D.25643 = data[0];
      D.25640 = ctx->image;
      D.25645 = D.25640->tables[42].rows;
      D.25646 = (unsigned int) D.25645;
      if (D.25643 > D.25646) goto <D.25641>; else goto <D.25642>;
      <D.25641>:
      D.25647 = ctx->report_error;
      if (D.25647 != 0) goto <D.25648>; else goto <D.25649>;
      <D.25648>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25643 = data[0];
        D.25650 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Owner token %08x", i, D.25643);
        vinfo->info.message = D.25650;
        vinfo->exception_type = 3;
        D.25651 = ctx->errors;
        D.25652 = monoeg_g_slist_prepend (D.25651, vinfo);
        ctx->errors = D.25652;
      }
      <D.25649>:
      ctx->valid = 0;
      return;
      <D.25642>:
      D.25653 = data[1];
      D.25654 = is_valid_coded_index (ctx, 0, D.25653);
      if (D.25654 == 0) goto <D.25655>; else goto <D.25656>;
      <D.25655>:
      D.25647 = ctx->report_error;
      if (D.25647 != 0) goto <D.25657>; else goto <D.25658>;
      <D.25657>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25653 = data[1];
        D.25659 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Constraint token %08x", i, D.25653);
        vinfo->info.message = D.25659;
        vinfo->exception_type = 3;
        D.25651 = ctx->errors;
        D.25660 = monoeg_g_slist_prepend (D.25651, vinfo);
        ctx->errors = D.25660;
      }
      <D.25658>:
      ctx->valid = 0;
      return;
      <D.25656>:
      D.25653 = data[1];
      D.25661 = get_coded_index_token (0, D.25653);
      if (D.25661 == 0) goto <D.25662>; else goto <D.25663>;
      <D.25662>:
      D.25647 = ctx->report_error;
      if (D.25647 != 0) goto <D.25664>; else goto <D.25665>;
      <D.25664>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25666 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has null Constraint token", i);
        vinfo->info.message = D.25666;
        vinfo->exception_type = 3;
        D.25651 = ctx->errors;
        D.25667 = monoeg_g_slist_prepend (D.25651, vinfo);
        ctx->errors = D.25667;
      }
      <D.25665>:
      ctx->valid = 0;
      return;
      <D.25663>:
      D.25643 = data[0];
      if (D.25643 < last_owner) goto <D.25668>; else goto <D.25669>;
      <D.25668>:
      D.25647 = ctx->report_error;
      if (D.25647 != 0) goto <D.25670>; else goto <D.25671>;
      <D.25670>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25643 = data[0];
        D.25672 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d is not properly sorted. Previous value of the owner column is 0x%08x current value is 0x%08x", i, last_owner, D.25643);
        vinfo->info.message = D.25672;
        vinfo->exception_type = 3;
        D.25651 = ctx->errors;
        D.25673 = monoeg_g_slist_prepend (D.25651, vinfo);
        ctx->errors = D.25673;
      }
      <D.25671>:
      ctx->valid = 0;
      return;
      <D.25669>:
      D.25643 = data[0];
      if (D.25643 == last_owner) goto <D.25674>; else goto <D.25675>;
      <D.25674>:
      D.25653 = data[1];
      if (D.25653 == last_constraint) goto <D.25676>; else goto <D.25677>;
      <D.25676>:
      D.25647 = ctx->report_error;
      if (D.25647 != 0) goto <D.25678>; else goto <D.25679>;
      <D.25678>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25680 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has duplicate constraint 0x%08x", i, last_constraint);
        vinfo->info.message = D.25680;
        vinfo->exception_type = 3;
        D.25651 = ctx->errors;
        D.25681 = monoeg_g_slist_prepend (D.25651, vinfo);
        ctx->errors = D.25681;
      }
      <D.25679>:
      ctx->valid = 0;
      return;
      <D.25677>:
      goto <D.25682>;
      <D.25675>:
      last_owner = data[0];
      <D.25682>:
      last_constraint = data[1];
      i = i + 1;
      <D.21595>:
      D.25683 = table->rows;
      D.25684 = (int) D.25683;
      if (D.25684 > i) goto <D.21594>; else goto <D.21596>;
      <D.21596>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_tables_data_global_constraints (struct VerifyContext * ctx)
{
  verify_typedef_table_global_constraints (ctx);
}


verify_typedef_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.25688;
  unsigned int D.25689;
  const char * D.25690;
  unsigned int D.25691;
  const char * D.25692;
  unsigned int D.25693;
  unsigned int D.25694;
  int D.25697;
  unsigned int D.25698;
  _Bool D.25699;
  long int D.25700;
  long int D.25701;
  unsigned int D.25704;
  void * D.25705;
  int D.25708;
  const char * D.25711;
  const char * D.25712;
  unsigned int D.25713;
  gchar * D.25714;
  struct GSList * D.25715;
  struct GSList * D.25716;
  <unnamed-unsigned:24> D.25717;
  int D.25718;
  int i;
  guint32 data[6];
  guint32 nested_data[2];
  struct MonoTableInfo * table;
  struct MonoTableInfo * nested_table;
  struct GHashTable * unique_types;

  try
    {
      D.25688 = ctx->image;
      table = &D.25688->tables[2];
      D.25688 = ctx->image;
      nested_table = &D.25688->tables[41];
      unique_types = monoeg_g_hash_table_new_full (typedef_hash, typedef_equals, monoeg_g_free, 0B);
      i = 0;
      goto <D.21644>;
      <D.21643>:
      {
        guint visibility;
        struct TypeDefUniqueId * type;

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 6);
        D.25688 = ctx->image;
        D.25689 = data[1];
        D.25690 = mono_metadata_string_heap (D.25688, D.25689);
        type->name = D.25690;
        D.25688 = ctx->image;
        D.25691 = data[2];
        D.25692 = mono_metadata_string_heap (D.25688, D.25691);
        type->name_space = D.25692;
        type->resolution_scope = 0;
        D.25693 = data[0];
        visibility = D.25693 & 7;
        D.25694 = visibility + 4294967294;
        if (D.25694 <= 5) goto <D.25695>; else goto <D.25696>;
        <D.25695>:
        {
          int res;

          D.25697 = i + 1;
          D.25698 = (unsigned int) D.25697;
          res = search_sorted_table (ctx, 41, 0, D.25698);
          D.25699 = res < 0;
          D.25700 = (long int) D.25699;
          D.25701 = __builtin_expect (D.25700, 0);
          if (D.25701 != 0) goto <D.25702>; else goto <D.25703>;
          <D.25702>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 3700, "res >= 0");
          <D.25703>:
          mono_metadata_decode_row (nested_table, res, &nested_data, 2);
          D.25704 = nested_data[1];
          type->resolution_scope = D.25704;
        }
        <D.25696>:
        D.25705 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.25705 != 0B) goto <D.25706>; else goto <D.25707>;
        <D.25706>:
        D.25708 = ctx->report_error;
        if (D.25708 != 0) goto <D.25709>; else goto <D.25710>;
        <D.25709>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.25711 = type->name;
          D.25712 = type->name_space;
          D.25713 = type->resolution_scope;
          D.25714 = monoeg_g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, D.25711, D.25712, D.25713);
          vinfo->info.message = D.25714;
          vinfo->exception_type = 3;
          D.25715 = ctx->errors;
          D.25716 = monoeg_g_slist_prepend (D.25715, vinfo);
          ctx->errors = D.25716;
        }
        <D.25710>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.25707>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.21644>:
      D.25717 = table->rows;
      D.25718 = (int) D.25717;
      if (D.25718 > i) goto <D.21643>; else goto <D.21645>;
      <D.21645>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
      nested_data = {CLOBBER};
    }
}


typedef_equals (const void * _a, const void * _b)
{
  gboolean D.25722;
  int iftmp.102;
  int D.21620;
  const char * D.25726;
  const char * D.25727;
  int D.21629;
  const char * D.25729;
  const char * D.25730;
  unsigned int D.25732;
  unsigned int D.25733;
  const struct TypeDefUniqueId * a;
  const struct TypeDefUniqueId * b;

  a = _a;
  b = _b;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25726 = a->name;
    D.25727 = b->name;
    D.21620 = __builtin_strcmp (D.25726, D.25727);
  }
  if (D.21620 == 0) goto <D.25728>; else goto <D.25724>;
  <D.25728>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25729 = a->name_space;
    D.25730 = b->name_space;
    D.21629 = __builtin_strcmp (D.25729, D.25730);
  }
  if (D.21629 == 0) goto <D.25731>; else goto <D.25724>;
  <D.25731>:
  D.25732 = a->resolution_scope;
  D.25733 = b->resolution_scope;
  if (D.25732 == D.25733) goto <D.25734>; else goto <D.25724>;
  <D.25734>:
  iftmp.102 = 1;
  goto <D.25725>;
  <D.25724>:
  iftmp.102 = 0;
  <D.25725>:
  D.25722 = iftmp.102;
  return D.25722;
}


typedef_hash (const void * _key)
{
  guint D.25736;
  const char * D.25737;
  unsigned int D.25738;
  const char * D.25739;
  unsigned int D.25740;
  unsigned int D.25741;
  unsigned int D.25742;
  const struct TypeDefUniqueId * key;

  key = _key;
  D.25737 = key->name;
  D.25738 = monoeg_g_str_hash (D.25737);
  D.25739 = key->name_space;
  D.25740 = monoeg_g_str_hash (D.25739);
  D.25741 = D.25738 ^ D.25740;
  D.25742 = key->resolution_scope;
  D.25736 = D.25741 ^ D.25742;
  return D.25736;
}


mono_verifier_verify_full_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.25744;
  gboolean D.25747;
  _Bool D.25748;
  int D.25749;
  int D.25750;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.25744 = mono_verifier_is_enabled_for_image (image);
      if (D.25744 == 0) goto <D.25745>; else goto <D.25746>;
      <D.25745>:
      D.25747 = 1;
      return D.25747;
      <D.25746>:
      D.25748 = error_list != 0B;
      D.25749 = (int) D.25748;
      init_verify_context (&ctx, image, D.25749);
      ctx.stage = 2;
      verify_typedef_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25751>;
      <D.25751>:
      verify_field_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25752>;
      <D.25752>:
      verify_method_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25753>;
      <D.25753>:
      verify_memberref_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25754>;
      <D.25754>:
      verify_cattr_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25755>;
      <D.25755>:
      verify_field_marshal_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25756>;
      <D.25756>:
      verify_decl_security_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25757>;
      <D.25757>:
      verify_standalonesig_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25758>;
      <D.25758>:
      verify_event_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25759>;
      <D.25759>:
      verify_typespec_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25760>;
      <D.25760>:
      verify_method_spec_table_full (&ctx);
      D.25750 = ctx.valid;
      if (D.25750 == 0) goto cleanup; else goto <D.25761>;
      <D.25761>:
      verify_tables_data_global_constraints_full (&ctx);
      cleanup:
      D.25747 = cleanup_context (&ctx, error_list);
      return D.25747;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_typedef_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25764;
  unsigned int D.25765;
  unsigned int D.25766;
  int D.25769;
  gchar * D.25772;
  struct GSList * D.25773;
  struct GSList * D.25774;
  unsigned int D.25777;
  unsigned int D.25778;
  unsigned int D.25781;
  gchar * D.25786;
  struct GSList * D.25787;
  unsigned int D.25789;
  _Bool D.25790;
  gchar * D.25797;
  struct GSList * D.25798;
  gchar * D.25804;
  struct GSList * D.25805;
  <unnamed-unsigned:24> D.25806;
  int D.25807;
  struct MonoTableInfo * table;
  guint32 data[6];
  int i;

  try
    {
      D.25764 = ctx->image;
      table = &D.25764->tables[2];
      D.25765 = BIT_FIELD_REF <*table, 32, 32>;
      D.25766 = D.25765 & 16777215;
      if (D.25766 == 0) goto <D.25767>; else goto <D.25768>;
      <D.25767>:
      D.25769 = ctx->report_error;
      if (D.25769 != 0) goto <D.25770>; else goto <D.25771>;
      <D.25770>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25772 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.25772;
        vinfo->exception_type = 3;
        D.25773 = ctx->errors;
        D.25774 = monoeg_g_slist_prepend (D.25773, vinfo);
        ctx->errors = D.25774;
      }
      <D.25771>:
      ctx->valid = 0;
      return;
      <D.25768>:
      i = 0;
      goto <D.20978>;
      <D.20977>:
      mono_metadata_decode_row (table, i, &data, 6);
      if (i == 0) goto <D.25775>; else goto <D.25776>;
      <D.25775>:
      // predicted unlikely by continue predictor.
      goto <D.20971>;
      <D.25776>:
      D.25777 = data[0];
      D.25778 = D.25777 & 32;
      if (D.25778 != 0) goto <D.25779>; else goto <D.25780>;
      <D.25779>:
      D.25781 = data[3];
      if (D.25781 != 0) goto <D.25782>; else goto <D.25783>;
      <D.25782>:
      D.25769 = ctx->report_error;
      if (D.25769 != 0) goto <D.25784>; else goto <D.25785>;
      <D.25784>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25786 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i);
        vinfo->info.message = D.25786;
        vinfo->exception_type = 3;
        D.25773 = ctx->errors;
        D.25787 = monoeg_g_slist_prepend (D.25773, vinfo);
        ctx->errors = D.25787;
      }
      <D.25785>:
      ctx->valid = 0;
      return;
      <D.25783>:
      goto <D.25788>;
      <D.25780>:
      {
        gboolean is_sys_obj;
        gboolean has_parent;

        is_sys_obj = typedef_is_system_object (ctx, &data);
        D.25781 = data[3];
        D.25789 = get_coded_index_token (0, D.25781);
        D.25790 = D.25789 != 0;
        has_parent = (gboolean) D.25790;
        if (is_sys_obj != 0) goto <D.25791>; else goto <D.25792>;
        <D.25791>:
        if (has_parent != 0) goto <D.25793>; else goto <D.25794>;
        <D.25793>:
        D.25769 = ctx->report_error;
        if (D.25769 != 0) goto <D.25795>; else goto <D.25796>;
        <D.25795>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.25797 = monoeg_g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i);
          vinfo->info.message = D.25797;
          vinfo->exception_type = 3;
          D.25773 = ctx->errors;
          D.25798 = monoeg_g_slist_prepend (D.25773, vinfo);
          ctx->errors = D.25798;
        }
        <D.25796>:
        ctx->valid = 0;
        return;
        <D.25794>:
        goto <D.25799>;
        <D.25792>:
        if (has_parent == 0) goto <D.25800>; else goto <D.25801>;
        <D.25800>:
        D.25769 = ctx->report_error;
        if (D.25769 != 0) goto <D.25802>; else goto <D.25803>;
        <D.25802>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.25804 = monoeg_g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i);
          vinfo->info.message = D.25804;
          vinfo->exception_type = 3;
          D.25773 = ctx->errors;
          D.25805 = monoeg_g_slist_prepend (D.25773, vinfo);
          ctx->errors = D.25805;
        }
        <D.25803>:
        ctx->valid = 0;
        return;
        <D.25801>:
        <D.25799>:
      }
      <D.25788>:
      <D.20971>:
      i = i + 1;
      <D.20978>:
      D.25806 = table->rows;
      D.25807 = (int) D.25806;
      if (D.25807 > i) goto <D.20977>; else goto <D.20979>;
      <D.20979>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


typedef_is_system_object (struct VerifyContext * ctx, guint32 * data)
{
  gboolean D.25811;
  int iftmp.103;
  struct MonoImage * D.25815;
  int D.25816;
  guint32 * D.25818;
  unsigned int D.25819;
  int D.25820;
  guint32 * D.25822;
  unsigned int D.25823;
  int D.25824;

  D.25815 = ctx->image;
  D.25816 = mono_verifier_is_corlib (D.25815);
  if (D.25816 != 0) goto <D.25817>; else goto <D.25813>;
  <D.25817>:
  D.25818 = data + 8;
  D.25819 = *D.25818;
  D.25820 = string_cmp (ctx, "System", D.25819);
  if (D.25820 == 0) goto <D.25821>; else goto <D.25813>;
  <D.25821>:
  D.25822 = data + 4;
  D.25823 = *D.25822;
  D.25824 = string_cmp (ctx, "Object", D.25823);
  if (D.25824 == 0) goto <D.25825>; else goto <D.25813>;
  <D.25825>:
  iftmp.103 = 1;
  goto <D.25814>;
  <D.25813>:
  iftmp.103 = 0;
  <D.25814>:
  D.25811 = iftmp.103;
  return D.25811;
}


mono_verifier_is_corlib (struct MonoImage * image)
{
  int iftmp.104;
  <unnamed type> D.25828;
  gboolean D.25832;
  int iftmp.105;
  const char * D.25837;
  int D.20356;
  int iftmp.106;
  int D.20352;
  const char[13] * D.25842;
  unsigned char D.25843;
  int D.25844;
  unsigned char D.25845;
  int D.25846;
  _Bool D.25847;
  _Bool D.25848;
  _Bool D.25849;
  const unsigned char * D.25852;
  unsigned char D.25853;
  int D.25854;
  const unsigned char * D.25855;
  unsigned char D.25856;
  int D.25857;
  _Bool D.25858;
  _Bool D.25859;
  const unsigned char * D.25862;
  unsigned char D.25863;
  int D.25864;
  const unsigned char * D.25865;
  unsigned char D.25866;
  int D.25867;
  _Bool D.25868;
  _Bool D.25869;
  const unsigned char * D.25872;
  unsigned char D.25873;
  int D.25874;
  const unsigned char * D.25875;
  unsigned char D.25876;
  int D.25877;
  gboolean trusted_location;

  D.25828 = mono_security_get_mode ();
  if (D.25828 == 1) goto <D.25829>; else goto <D.25830>;
  <D.25829>:
  iftmp.104 = mono_security_core_clr_is_platform_image (image);
  goto <D.25831>;
  <D.25830>:
  iftmp.104 = 1;
  <D.25831>:
  trusted_location = iftmp.104;
  if (trusted_location != 0) goto <D.25836>; else goto <D.25834>;
  <D.25836>:
  D.25837 = image->module_name;
  if (D.25837 != 0B) goto <D.25838>; else goto <D.25834>;
  <D.25838>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 12;
    if (__s1_len <= 3) goto <D.25840>; else goto <D.25841>;
    <D.25840>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = image->module_name;
      D.25842 = "mscorlib.dll";
      D.25843 = MEM[(const unsigned char *)D.25842];
      D.25844 = (int) D.25843;
      D.25845 = *__s2;
      D.25846 = (int) D.25845;
      __result = D.25844 - D.25846;
      {
        D.25847 = __s1_len != 0;
        D.25848 = __result == 0;
        D.25849 = D.25847 & D.25848;
        if (D.25849 != 0) goto <D.25850>; else goto <D.25851>;
        <D.25850>:
        D.25852 = &MEM[(void *)"mscorlib.dll" + 1B];
        D.25853 = *D.25852;
        D.25854 = (int) D.25853;
        D.25855 = __s2 + 1;
        D.25856 = *D.25855;
        D.25857 = (int) D.25856;
        __result = D.25854 - D.25857;
        D.25858 = __s1_len > 1;
        D.25848 = __result == 0;
        D.25859 = D.25858 & D.25848;
        if (D.25859 != 0) goto <D.25860>; else goto <D.25861>;
        <D.25860>:
        D.25862 = &MEM[(void *)"mscorlib.dll" + 2B];
        D.25863 = *D.25862;
        D.25864 = (int) D.25863;
        D.25865 = __s2 + 2;
        D.25866 = *D.25865;
        D.25867 = (int) D.25866;
        __result = D.25864 - D.25867;
        D.25868 = __s1_len > 2;
        D.25848 = __result == 0;
        D.25869 = D.25868 & D.25848;
        if (D.25869 != 0) goto <D.25870>; else goto <D.25871>;
        <D.25870>:
        D.25872 = &MEM[(void *)"mscorlib.dll" + 3B];
        D.25873 = *D.25872;
        D.25874 = (int) D.25873;
        D.25875 = __s2 + 3;
        D.25876 = *D.25875;
        D.25877 = (int) D.25876;
        __result = D.25874 - D.25877;
        <D.25871>:
        <D.25861>:
        <D.25851>:
      }
      D.20352 = __result;
    }
    iftmp.106 = D.20352;
    goto <D.25878>;
    <D.25841>:
    D.25837 = image->module_name;
    iftmp.106 = __builtin_strcmp ("mscorlib.dll", D.25837);
    <D.25878>:
    D.20356 = iftmp.106;
  }
  if (D.20356 == 0) goto <D.25879>; else goto <D.25834>;
  <D.25879>:
  iftmp.105 = 1;
  goto <D.25835>;
  <D.25834>:
  iftmp.105 = 0;
  <D.25835>:
  D.25832 = iftmp.105;
  return D.25832;
}


string_cmp (struct VerifyContext * ctx, const char * str, guint offset)
{
  int D.25883;
  int D.20334;
  int iftmp.107;
  int D.20333;
  const char[1] * D.25887;
  unsigned char D.25888;
  int D.25889;
  unsigned char D.25890;
  int D.25891;
  _Bool D.25892;
  _Bool D.25893;
  _Bool D.25894;
  const unsigned char * D.25897;
  unsigned char D.25898;
  int D.25899;
  const unsigned char * D.25900;
  unsigned char D.25901;
  int D.25902;
  _Bool D.25903;
  _Bool D.25904;
  const unsigned char * D.25907;
  unsigned char D.25908;
  int D.25909;
  const unsigned char * D.25910;
  unsigned char D.25911;
  int D.25912;
  _Bool D.25913;
  _Bool D.25914;
  const unsigned char * D.25917;
  unsigned char D.25918;
  int D.25919;
  const unsigned char * D.25920;
  unsigned char D.25921;
  int D.25922;
  unsigned char D.25924;
  int D.20343;
  const char * D.25925;

  if (offset == 0) goto <D.25881>; else goto <D.25882>;
  <D.25881>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 0;
    if (__s2_len <= 3) goto <D.25885>; else goto <D.25886>;
    <D.25885>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = str;
      D.25887 = "";
      D.25888 = MEM[(const unsigned char *)D.25887];
      D.25889 = (int) D.25888;
      D.25890 = *__s2;
      D.25891 = (int) D.25890;
      __result = D.25889 - D.25891;
      {
        D.25892 = __s2_len != 0;
        D.25893 = __result == 0;
        D.25894 = D.25892 & D.25893;
        if (D.25894 != 0) goto <D.25895>; else goto <D.25896>;
        <D.25895>:
        D.25897 = &MEM[(void *)"" + 1B];
        D.25898 = *D.25897;
        D.25899 = (int) D.25898;
        D.25900 = __s2 + 1;
        D.25901 = *D.25900;
        D.25902 = (int) D.25901;
        __result = D.25899 - D.25902;
        D.25903 = __s2_len > 1;
        D.25893 = __result == 0;
        D.25904 = D.25903 & D.25893;
        if (D.25904 != 0) goto <D.25905>; else goto <D.25906>;
        <D.25905>:
        D.25907 = &MEM[(void *)"" + 2B];
        D.25908 = *D.25907;
        D.25909 = (int) D.25908;
        D.25910 = __s2 + 2;
        D.25911 = *D.25910;
        D.25912 = (int) D.25911;
        __result = D.25909 - D.25912;
        D.25913 = __s2_len > 2;
        D.25893 = __result == 0;
        D.25914 = D.25913 & D.25893;
        if (D.25914 != 0) goto <D.25915>; else goto <D.25916>;
        <D.25915>:
        D.25917 = &MEM[(void *)"" + 3B];
        D.25918 = *D.25917;
        D.25919 = (int) D.25918;
        D.25920 = __s2 + 3;
        D.25921 = *D.25920;
        D.25922 = (int) D.25921;
        __result = D.25919 - D.25922;
        <D.25916>:
        <D.25906>:
        <D.25896>:
      }
      D.20333 = __result;
    }
    iftmp.107 = -D.20333;
    goto <D.25923>;
    <D.25886>:
    D.25924 = MEM[(const unsigned char * {ref-all})str];
    iftmp.107 = (int) D.25924;
    <D.25923>:
    D.20334 = iftmp.107;
  }
  D.25883 = D.20334;
  return D.25883;
  <D.25882>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25925 = get_string_ptr (ctx, offset);
    D.20343 = __builtin_strcmp (str, D.25925);
  }
  D.25883 = D.20343;
  return D.25883;
}


verify_field_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25927;
  unsigned int D.25930;
  int D.25932;
  int D.25933;
  gchar * D.25936;
  struct GSList * D.25937;
  struct GSList * D.25938;
  <unnamed-unsigned:24> D.25939;
  int D.25940;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.25927 = ctx->image;
      table = &D.25927->tables[4];
      i = 0;
      goto <D.21014>;
      <D.21013>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.25930 = data[2];
      if (D.25930 == 0) goto <D.25928>; else goto <D.25931>;
      <D.25931>:
      D.25930 = data[2];
      D.25932 = is_valid_field_signature (ctx, D.25930);
      if (D.25932 == 0) goto <D.25928>; else goto <D.25929>;
      <D.25928>:
      D.25933 = ctx->report_error;
      if (D.25933 != 0) goto <D.25934>; else goto <D.25935>;
      <D.25934>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25930 = data[2];
        D.25936 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, D.25930);
        vinfo->info.message = D.25936;
        vinfo->exception_type = 3;
        D.25937 = ctx->errors;
        D.25938 = monoeg_g_slist_prepend (D.25937, vinfo);
        ctx->errors = D.25938;
      }
      <D.25935>:
      ctx->valid = 0;
      return;
      <D.25929>:
      i = i + 1;
      <D.21014>:
      D.25939 = table->rows;
      D.25940 = (int) D.25939;
      if (D.25940 > i) goto <D.21013>; else goto <D.21015>;
      <D.21015>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.25944;
  int D.25947;
  gchar * D.25950;
  struct GSList * D.25951;
  struct GSList * D.25952;
  gboolean D.25953;
  const char * ptr.108;
  unsigned int size.109;
  int D.25956;
  gchar * D.25961;
  struct GSList * D.25962;
  unsigned int signature.110;
  gchar * D.25968;
  struct GSList * D.25969;
  const char * ptr.111;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.25944 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25944 == 0) goto <D.25945>; else goto <D.25946>;
      <D.25945>:
      D.25947 = ctx->report_error;
      if (D.25947 != 0) goto <D.25948>; else goto <D.25949>;
      <D.25948>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25950 = monoeg_strdup ("FieldSig: Could not decode signature header");
        vinfo->info.message = D.25950;
        vinfo->exception_type = 3;
        D.25951 = ctx->errors;
        D.25952 = monoeg_g_slist_prepend (D.25951, vinfo);
        ctx->errors = D.25952;
      }
      <D.25949>:
      ctx->valid = 0;
      D.25953 = 0;
      return D.25953;
      <D.25946>:
      ptr.108 = ptr;
      size.109 = size;
      end = ptr.108 + size.109;
      D.25956 = safe_read (&ptr, end, &signature, 1);
      if (D.25956 == 0) goto <D.25957>; else goto <D.25958>;
      <D.25957>:
      D.25947 = ctx->report_error;
      if (D.25947 != 0) goto <D.25959>; else goto <D.25960>;
      <D.25959>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25961 = monoeg_strdup ("FieldSig: Not enough room for the signature");
        vinfo->info.message = D.25961;
        vinfo->exception_type = 3;
        D.25951 = ctx->errors;
        D.25962 = monoeg_g_slist_prepend (D.25951, vinfo);
        ctx->errors = D.25962;
      }
      <D.25960>:
      ctx->valid = 0;
      D.25953 = 0;
      return D.25953;
      <D.25958>:
      signature.110 = signature;
      if (signature.110 != 6) goto <D.25964>; else goto <D.25965>;
      <D.25964>:
      D.25947 = ctx->report_error;
      if (D.25947 != 0) goto <D.25966>; else goto <D.25967>;
      <D.25966>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.110 = signature;
        D.25968 = monoeg_g_strdup_printf ("FieldSig: Invalid signature %x", signature.110);
        vinfo->info.message = D.25968;
        vinfo->exception_type = 3;
        D.25951 = ctx->errors;
        D.25969 = monoeg_g_slist_prepend (D.25951, vinfo);
        ctx->errors = D.25969;
      }
      <D.25967>:
      ctx->valid = 0;
      D.25953 = 0;
      return D.25953;
      <D.25965>:
      ptr.108 = ptr;
      ptr.111 = ptr.108 + 4294967295;
      ptr = ptr.111;
      D.25953 = parse_field (ctx, &ptr, end);
      return D.25953;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_field (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.112;
  int D.25974;
  int D.25977;
  gchar * D.25980;
  struct GSList * D.25981;
  struct GSList * D.25982;
  gboolean D.25983;
  unsigned int signature.113;
  gchar * D.25989;
  struct GSList * D.25990;
  int D.25991;
  int D.25994;
  const char * ptr.114;
  const char * ptr.115;
  const char * ptr;
  unsigned int signature;

  try
    {
      ptr.112 = *_ptr;
      ptr = ptr.112;
      signature = 0;
      D.25974 = safe_read (&ptr, end, &signature, 1);
      if (D.25974 == 0) goto <D.25975>; else goto <D.25976>;
      <D.25975>:
      D.25977 = ctx->report_error;
      if (D.25977 != 0) goto <D.25978>; else goto <D.25979>;
      <D.25978>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.25980 = monoeg_strdup ("Field: Not enough room for field signature");
        vinfo->info.message = D.25980;
        vinfo->exception_type = 3;
        D.25981 = ctx->errors;
        D.25982 = monoeg_g_slist_prepend (D.25981, vinfo);
        ctx->errors = D.25982;
      }
      <D.25979>:
      ctx->valid = 0;
      D.25983 = 0;
      return D.25983;
      <D.25976>:
      signature.113 = signature;
      if (signature.113 != 6) goto <D.25985>; else goto <D.25986>;
      <D.25985>:
      D.25977 = ctx->report_error;
      if (D.25977 != 0) goto <D.25987>; else goto <D.25988>;
      <D.25987>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        signature.113 = signature;
        D.25989 = monoeg_g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature.113);
        vinfo->info.message = D.25989;
        vinfo->exception_type = 3;
        D.25981 = ctx->errors;
        D.25990 = monoeg_g_slist_prepend (D.25981, vinfo);
        ctx->errors = D.25990;
      }
      <D.25988>:
      ctx->valid = 0;
      D.25983 = 0;
      return D.25983;
      <D.25986>:
      D.25991 = parse_custom_mods (ctx, &ptr, end);
      if (D.25991 == 0) goto <D.25992>; else goto <D.25993>;
      <D.25992>:
      D.25983 = 0;
      return D.25983;
      <D.25993>:
      D.25994 = safe_read (&ptr, end, &signature, 1);
      if (D.25994 != 0) goto <D.25995>; else goto <D.25996>;
      <D.25995>:
      signature.113 = signature;
      if (signature.113 != 16) goto <D.25997>; else goto <D.25998>;
      <D.25997>:
      ptr.114 = ptr;
      ptr.115 = ptr.114 + 4294967295;
      ptr = ptr.115;
      <D.25998>:
      <D.25996>:
      ptr.114 = ptr;
      *_ptr = ptr.114;
      D.25983 = parse_type (ctx, _ptr, end);
      return D.25983;
    }
  finally
    {
      ptr = {CLOBBER};
      signature = {CLOBBER};
    }
}


verify_method_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26003;
  unsigned int D.26006;
  int D.26008;
  int D.26009;
  gchar * D.26012;
  struct GSList * D.26013;
  struct GSList * D.26014;
  int D.26017;
  gchar * D.26022;
  struct GSList * D.26023;
  <unnamed-unsigned:24> D.26024;
  int D.26025;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 rva;
  guint32 locals_token;
  int i;

  try
    {
      D.26003 = ctx->image;
      table = &D.26003->tables[6];
      i = 0;
      goto <D.21094>;
      <D.21093>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      D.26006 = data[4];
      if (D.26006 == 0) goto <D.26004>; else goto <D.26007>;
      <D.26007>:
      D.26006 = data[4];
      D.26008 = is_valid_method_signature (ctx, D.26006);
      if (D.26008 == 0) goto <D.26004>; else goto <D.26005>;
      <D.26004>:
      D.26009 = ctx->report_error;
      if (D.26009 != 0) goto <D.26010>; else goto <D.26011>;
      <D.26010>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26006 = data[4];
        D.26012 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, D.26006);
        vinfo->info.message = D.26012;
        vinfo->exception_type = 3;
        D.26013 = ctx->errors;
        D.26014 = monoeg_g_slist_prepend (D.26013, vinfo);
        ctx->errors = D.26014;
      }
      <D.26011>:
      ctx->valid = 0;
      return;
      <D.26005>:
      if (rva != 0) goto <D.26015>; else goto <D.26016>;
      <D.26015>:
      D.26017 = is_valid_method_header (ctx, rva, &locals_token);
      if (D.26017 == 0) goto <D.26018>; else goto <D.26019>;
      <D.26018>:
      D.26009 = ctx->report_error;
      if (D.26009 != 0) goto <D.26020>; else goto <D.26021>;
      <D.26020>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26022 = monoeg_g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i);
        vinfo->info.message = D.26022;
        vinfo->exception_type = 3;
        D.26013 = ctx->errors;
        D.26023 = monoeg_g_slist_prepend (D.26013, vinfo);
        ctx->errors = D.26023;
      }
      <D.26021>:
      ctx->valid = 0;
      return;
      <D.26019>:
      <D.26016>:
      i = i + 1;
      <D.21094>:
      D.26024 = table->rows;
      D.26025 = (int) D.26024;
      if (D.26025 > i) goto <D.21093>; else goto <D.21095>;
      <D.21095>:
    }
  finally
    {
      data = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


is_valid_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.26029;
  int D.26032;
  gchar * D.26035;
  struct GSList * D.26036;
  struct GSList * D.26037;
  gboolean D.26038;
  const char * ptr.116;
  unsigned int size.117;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.26029 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.26029 == 0) goto <D.26030>; else goto <D.26031>;
      <D.26030>:
      D.26032 = ctx->report_error;
      if (D.26032 != 0) goto <D.26033>; else goto <D.26034>;
      <D.26033>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26035 = monoeg_strdup ("MethodSig: Could not decode signature header");
        vinfo->info.message = D.26035;
        vinfo->exception_type = 3;
        D.26036 = ctx->errors;
        D.26037 = monoeg_g_slist_prepend (D.26036, vinfo);
        ctx->errors = D.26037;
      }
      <D.26034>:
      ctx->valid = 0;
      D.26038 = 0;
      return D.26038;
      <D.26031>:
      ptr.116 = ptr;
      size.117 = size;
      end = ptr.116 + size.117;
      D.26038 = parse_method_signature (ctx, &ptr, end, 0, 0);
      return D.26038;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_method_header (struct VerifyContext * ctx, guint32 rva, guint32 * locals_token)
{
  struct MonoImage * D.26043;
  int D.26046;
  gchar * D.26049;
  struct GSList * D.26050;
  struct GSList * D.26051;
  gboolean D.26052;
  const char * D.26053;
  const char * ptr.118;
  unsigned int D.26055;
  int D.26056;
  gchar * D.26061;
  struct GSList * D.26062;
  unsigned int header.119;
  unsigned int D.26064;
  gchar * D.26067;
  struct GSList * D.26068;
  unsigned int header.120;
  const char * ptr.121;
  const char * D.26073;
  unsigned int D.26075;
  unsigned int ptr.122;
  int end.123;
  int ptr.124;
  int D.26081;
  gchar * D.26082;
  struct GSList * D.26083;
  const char * ptr.125;
  int D.26086;
  gchar * D.26091;
  struct GSList * D.26092;
  unsigned int fat_header.126;
  unsigned int D.26094;
  gchar * D.26099;
  struct GSList * D.26100;
  int D.26101;
  gchar * D.26106;
  struct GSList * D.26107;
  int D.26108;
  gchar * D.26113;
  struct GSList * D.26114;
  int D.26115;
  gchar * D.26120;
  struct GSList * D.26121;
  unsigned int local_vars_tok.127;
  unsigned int D.26125;
  gchar * D.26130;
  struct GSList * D.26131;
  unsigned int D.26132;
  <unnamed-unsigned:24> D.26133;
  unsigned int D.26134;
  gchar * D.26139;
  struct GSList * D.26140;
  gchar * D.26145;
  struct GSList * D.26146;
  unsigned int D.26147;
  gchar * D.26152;
  struct GSList * D.26153;
  unsigned int code_size.128;
  const char * ptr.129;
  unsigned int D.26159;
  gchar * D.26162;
  struct GSList * D.26163;
  unsigned int D.26164;
  const char * ptr.130;
  int D.26168;
  gchar * D.26173;
  struct GSList * D.26174;
  unsigned int section_header.131;
  unsigned int D.26176;
  gchar * D.26181;
  struct GSList * D.26182;
  unsigned int D.26183;
  _Bool D.26184;
  unsigned int D.26185;
  unsigned int iftmp.132;
  gchar * D.26194;
  struct GSList * D.26195;
  sizetype D.26198;
  const char * D.26199;
  unsigned int D.26201;
  unsigned int D.26202;
  gchar * D.26205;
  struct GSList * D.26206;
  unsigned int D.26207;
  unsigned int iftmp.133;
  guint32 iftmp.134;
  unsigned int D.26218;
  guint32 iftmp.135;
  unsigned int D.26225;
  unsigned int D.26226;
  guint32 iftmp.136;
  unsigned int D.26235;
  gchar * D.26236;
  struct GSList * D.26237;
  unsigned char D.26238;
  sizetype iftmp.137;
  const char * ptr.138;
  int D.26244;
  gchar * D.26249;
  struct GSList * D.26250;
  unsigned int class_token.139;
  unsigned int D.26256;
  _Bool D.26257;
  _Bool D.26258;
  _Bool D.26259;
  gchar * D.26264;
  struct GSList * D.26265;
  unsigned int D.26266;
  <unnamed-unsigned:24> D.26267;
  unsigned int D.26268;
  gchar * D.26273;
  struct GSList * D.26274;
  unsigned int D.26275;
  unsigned int local_vars_tok;
  unsigned int code_size;
  unsigned int offset;
  unsigned int header;
  unsigned int fat_header;
  unsigned int size;
  unsigned int max_stack;
  const char * ptr;
  const char * end;

  try
    {
      D.26043 = ctx->image;
      offset = mono_cli_rva_image_map (D.26043, rva);
      header = 0;
      fat_header = 0;
      size = 0;
      ptr = 0B;
      *locals_token = 0;
      if (offset == 4294967295) goto <D.26044>; else goto <D.26045>;
      <D.26044>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26047>; else goto <D.26048>;
      <D.26047>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26049 = monoeg_strdup ("MethodHeader: Invalid RVA");
        vinfo->info.message = D.26049;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26051 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26051;
      }
      <D.26048>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26045>:
      D.26053 = ctx->data;
      ptr.118 = D.26053 + offset;
      ptr = ptr.118;
      D.26053 = ctx->data;
      D.26055 = ctx->size;
      end = D.26053 + D.26055;
      D.26056 = safe_read (&ptr, end, &header, 1);
      if (D.26056 == 0) goto <D.26057>; else goto <D.26058>;
      <D.26057>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26059>; else goto <D.26060>;
      <D.26059>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26061 = monoeg_strdup ("MethodHeader: Not enough room for header");
        vinfo->info.message = D.26061;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26062 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26062;
      }
      <D.26060>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26058>:
      header.119 = header;
      D.26064 = header.119 & 3;
      switch (D.26064) <default: <D.26084>, case 0: <D.20880>, case 1: <D.20881>, case 2: <D.20883>>
      <D.20880>:
      <D.20881>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26065>; else goto <D.26066>;
      <D.26065>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        header.119 = header;
        D.26064 = header.119 & 3;
        D.26067 = monoeg_g_strdup_printf ("MethodHeader: Invalid header type 0x%x", D.26064);
        vinfo->info.message = D.26067;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26068 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26068;
      }
      <D.26066>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.20883>:
      header.119 = header;
      header.120 = header.119 >> 2;
      header = header.120;
      ptr.121 = ptr;
      header.119 = header;
      D.26073 = ptr.121 + header.119;
      if (D.26073 > end) goto <D.26070>; else goto <D.26074>;
      <D.26074>:
      header.119 = header;
      D.26075 = ~header.119;
      ptr.121 = ptr;
      ptr.122 = (unsigned int) ptr.121;
      if (D.26075 < ptr.122) goto <D.26070>; else goto <D.26071>;
      <D.26070>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26077>; else goto <D.26078>;
      <D.26077>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        header.119 = header;
        end.123 = (int) end;
        ptr.121 = ptr;
        ptr.124 = (int) ptr.121;
        D.26081 = end.123 - ptr.124;
        D.26082 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header.119, D.26081);
        vinfo->info.message = D.26082;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26083 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26083;
      }
      <D.26078>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26071>:
      D.26052 = 1;
      return D.26052;
      <D.26084>:
      ptr.121 = ptr;
      ptr.125 = ptr.121 + 4294967295;
      ptr = ptr.125;
      D.26086 = safe_read (&ptr, end, &fat_header, 2);
      if (D.26086 == 0) goto <D.26087>; else goto <D.26088>;
      <D.26087>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26089>; else goto <D.26090>;
      <D.26089>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26091 = monoeg_strdup ("MethodHeader: Not enough room for fat header");
        vinfo->info.message = D.26091;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26092 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26092;
      }
      <D.26090>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26088>:
      fat_header.126 = fat_header;
      D.26094 = fat_header.126 >> 12;
      size = D.26094 & 15;
      if (size != 3) goto <D.26095>; else goto <D.26096>;
      <D.26095>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26097>; else goto <D.26098>;
      <D.26097>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26099 = monoeg_strdup ("MethodHeader: header size must be 3");
        vinfo->info.message = D.26099;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26100 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26100;
      }
      <D.26098>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26096>:
      D.26101 = safe_read (&ptr, end, &max_stack, 2);
      if (D.26101 == 0) goto <D.26102>; else goto <D.26103>;
      <D.26102>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26104>; else goto <D.26105>;
      <D.26104>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26106 = monoeg_strdup ("MethodHeader: Not enough room for max stack");
        vinfo->info.message = D.26106;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26107 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26107;
      }
      <D.26105>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26103>:
      D.26108 = safe_read (&ptr, end, &code_size, 4);
      if (D.26108 == 0) goto <D.26109>; else goto <D.26110>;
      <D.26109>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26111>; else goto <D.26112>;
      <D.26111>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26113 = monoeg_strdup ("MethodHeader: Not enough room for code size");
        vinfo->info.message = D.26113;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26114 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26114;
      }
      <D.26112>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26110>:
      D.26115 = safe_read (&ptr, end, &local_vars_tok, 4);
      if (D.26115 == 0) goto <D.26116>; else goto <D.26117>;
      <D.26116>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26118>; else goto <D.26119>;
      <D.26118>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26120 = monoeg_strdup ("MethodHeader: Not enough room for local vars tok");
        vinfo->info.message = D.26120;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26121 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26121;
      }
      <D.26119>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26117>:
      local_vars_tok.127 = local_vars_tok;
      if (local_vars_tok.127 != 0) goto <D.26123>; else goto <D.26124>;
      <D.26123>:
      local_vars_tok.127 = local_vars_tok;
      D.26125 = local_vars_tok.127 >> 24;
      if (D.26125 != 17) goto <D.26126>; else goto <D.26127>;
      <D.26126>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26128>; else goto <D.26129>;
      <D.26128>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.127 = local_vars_tok;
        D.26125 = local_vars_tok.127 >> 24;
        D.26130 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", D.26125);
        vinfo->info.message = D.26130;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26131 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26131;
      }
      <D.26129>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26127>:
      local_vars_tok.127 = local_vars_tok;
      D.26132 = local_vars_tok.127 & 16777215;
      D.26043 = ctx->image;
      D.26133 = D.26043->tables[17].rows;
      D.26134 = (unsigned int) D.26133;
      if (D.26132 > D.26134) goto <D.26135>; else goto <D.26136>;
      <D.26135>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26137>; else goto <D.26138>;
      <D.26137>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        local_vars_tok.127 = local_vars_tok;
        D.26132 = local_vars_tok.127 & 16777215;
        D.26139 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", D.26132);
        vinfo->info.message = D.26139;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26140 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26140;
      }
      <D.26138>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26136>:
      local_vars_tok.127 = local_vars_tok;
      D.26132 = local_vars_tok.127 & 16777215;
      if (D.26132 == 0) goto <D.26141>; else goto <D.26142>;
      <D.26141>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26143>; else goto <D.26144>;
      <D.26143>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26145 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature with zero index");
        vinfo->info.message = D.26145;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26146 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26146;
      }
      <D.26144>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26142>:
      local_vars_tok.127 = local_vars_tok;
      D.26132 = local_vars_tok.127 & 16777215;
      *locals_token = D.26132;
      <D.26124>:
      fat_header.126 = fat_header;
      D.26147 = fat_header.126 & 4294905828;
      if (D.26147 != 0) goto <D.26148>; else goto <D.26149>;
      <D.26148>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26150>; else goto <D.26151>;
      <D.26150>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        fat_header.126 = fat_header;
        D.26147 = fat_header.126 & 4294905828;
        D.26152 = monoeg_g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", D.26147);
        vinfo->info.message = D.26152;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26153 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26153;
      }
      <D.26151>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26149>:
      ptr.121 = ptr;
      code_size.128 = code_size;
      ptr.129 = ptr.121 + code_size.128;
      if (ptr.129 > end) goto <D.26154>; else goto <D.26158>;
      <D.26158>:
      code_size.128 = code_size;
      D.26159 = ~code_size.128;
      ptr.121 = ptr;
      ptr.122 = (unsigned int) ptr.121;
      if (D.26159 < ptr.122) goto <D.26154>; else goto <D.26155>;
      <D.26154>:
      D.26046 = ctx->report_error;
      if (D.26046 != 0) goto <D.26160>; else goto <D.26161>;
      <D.26160>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        code_size.128 = code_size;
        D.26162 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size.128);
        vinfo->info.message = D.26162;
        vinfo->exception_type = 3;
        D.26050 = ctx->errors;
        D.26163 = monoeg_g_slist_prepend (D.26050, vinfo);
        ctx->errors = D.26163;
      }
      <D.26161>:
      ctx->valid = 0;
      D.26052 = 0;
      return D.26052;
      <D.26155>:
      fat_header.126 = fat_header;
      D.26164 = fat_header.126 & 8;
      if (D.26164 == 0) goto <D.26165>; else goto <D.26166>;
      <D.26165>:
      D.26052 = 1;
      return D.26052;
      <D.26166>:
      ptr.121 = ptr;
      code_size.128 = code_size;
      ptr.129 = ptr.121 + code_size.128;
      ptr = ptr.129;
      <D.20915>:
      {
        unsigned int section_header;
        unsigned int section_size;
        gboolean is_fat;

        try
          {
            section_header = 0;
            section_size = 0;
            ptr.121 = ptr;
            ptr.130 = dword_align (ptr.121);
            ptr = ptr.130;
            D.26168 = safe_read (&ptr, end, &section_header, 4);
            if (D.26168 == 0) goto <D.26169>; else goto <D.26170>;
            <D.26169>:
            D.26046 = ctx->report_error;
            if (D.26046 != 0) goto <D.26171>; else goto <D.26172>;
            <D.26171>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26173 = monoeg_strdup ("MethodHeader: Not enough room for data section header");
              vinfo->info.message = D.26173;
              vinfo->exception_type = 3;
              D.26050 = ctx->errors;
              D.26174 = monoeg_g_slist_prepend (D.26050, vinfo);
              ctx->errors = D.26174;
            }
            <D.26172>:
            ctx->valid = 0;
            D.26052 = 0;
            return D.26052;
            <D.26170>:
            section_header.131 = section_header;
            D.26176 = section_header.131 & 62;
            if (D.26176 != 0) goto <D.26177>; else goto <D.26178>;
            <D.26177>:
            D.26046 = ctx->report_error;
            if (D.26046 != 0) goto <D.26179>; else goto <D.26180>;
            <D.26179>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              section_header.131 = section_header;
              D.26176 = section_header.131 & 62;
              D.26181 = monoeg_g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", D.26176);
              vinfo->info.message = D.26181;
              vinfo->exception_type = 3;
              D.26050 = ctx->errors;
              D.26182 = monoeg_g_slist_prepend (D.26050, vinfo);
              ctx->errors = D.26182;
            }
            <D.26180>:
            ctx->valid = 0;
            D.26052 = 0;
            return D.26052;
            <D.26178>:
            section_header.131 = section_header;
            D.26183 = section_header.131 & 64;
            D.26184 = D.26183 != 0;
            is_fat = (gboolean) D.26184;
            section_header.131 = section_header;
            D.26185 = section_header.131 >> 8;
            if (is_fat != 0) goto <D.26187>; else goto <D.26188>;
            <D.26187>:
            iftmp.132 = 16777215;
            goto <D.26189>;
            <D.26188>:
            iftmp.132 = 255;
            <D.26189>:
            section_size = D.26185 & iftmp.132;
            if (section_size <= 3) goto <D.26190>; else goto <D.26191>;
            <D.26190>:
            D.26046 = ctx->report_error;
            if (D.26046 != 0) goto <D.26192>; else goto <D.26193>;
            <D.26192>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26194 = monoeg_g_strdup_printf ("MethodHeader: Section size too small");
              vinfo->info.message = D.26194;
              vinfo->exception_type = 3;
              D.26050 = ctx->errors;
              D.26195 = monoeg_g_slist_prepend (D.26050, vinfo);
              ctx->errors = D.26195;
            }
            <D.26193>:
            ctx->valid = 0;
            D.26052 = 0;
            return D.26052;
            <D.26191>:
            ptr.121 = ptr;
            D.26198 = section_size + 4294967292;
            D.26199 = ptr.121 + D.26198;
            if (D.26199 > end) goto <D.26196>; else goto <D.26200>;
            <D.26200>:
            D.26201 = section_size + 4294967292;
            D.26202 = ~D.26201;
            ptr.121 = ptr;
            ptr.122 = (unsigned int) ptr.121;
            if (D.26202 < ptr.122) goto <D.26196>; else goto <D.26197>;
            <D.26196>:
            D.26046 = ctx->report_error;
            if (D.26046 != 0) goto <D.26203>; else goto <D.26204>;
            <D.26203>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26205 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size);
              vinfo->info.message = D.26205;
              vinfo->exception_type = 3;
              D.26050 = ctx->errors;
              D.26206 = monoeg_g_slist_prepend (D.26050, vinfo);
              ctx->errors = D.26206;
            }
            <D.26204>:
            ctx->valid = 0;
            D.26052 = 0;
            return D.26052;
            <D.26197>:
            section_header.131 = section_header;
            D.26207 = section_header.131 & 1;
            if (D.26207 != 0) goto <D.26208>; else goto <D.26209>;
            <D.26208>:
            {
              guint32 i;
              guint32 clauses;

              if (is_fat != 0) goto <D.26211>; else goto <D.26212>;
              <D.26211>:
              iftmp.133 = 24;
              goto <D.26213>;
              <D.26212>:
              iftmp.133 = 12;
              <D.26213>:
              clauses = section_size / iftmp.133;
              if (is_fat != 0) goto <D.26215>; else goto <D.26216>;
              <D.26215>:
              iftmp.134 = 24;
              goto <D.26217>;
              <D.26216>:
              iftmp.134 = 12;
              <D.26217>:
              D.26218 = iftmp.134 * clauses;
              if (D.26218 != section_size) goto <D.26219>; else goto <D.26220>;
              <D.26219>:
              if (is_fat != 0) goto <D.26222>; else goto <D.26223>;
              <D.26222>:
              iftmp.135 = 24;
              goto <D.26224>;
              <D.26223>:
              iftmp.135 = 12;
              <D.26224>:
              D.26225 = iftmp.135 * clauses;
              D.26226 = D.26225 + 4;
              if (D.26226 != section_size) goto <D.26227>; else goto <D.26228>;
              <D.26227>:
              D.26046 = ctx->report_error;
              if (D.26046 != 0) goto <D.26229>; else goto <D.26230>;
              <D.26229>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (12);
                vinfo->info.status = 1;
                if (is_fat != 0) goto <D.26232>; else goto <D.26233>;
                <D.26232>:
                iftmp.136 = 24;
                goto <D.26234>;
                <D.26233>:
                iftmp.136 = 12;
                <D.26234>:
                D.26235 = iftmp.136 * clauses;
                D.26236 = monoeg_g_strdup_printf ("MethodHeader: Invalid EH section size %d, it\'s not of the expected size %d", section_size, D.26235);
                vinfo->info.message = D.26236;
                vinfo->exception_type = 3;
                D.26050 = ctx->errors;
                D.26237 = monoeg_g_slist_prepend (D.26050, vinfo);
                ctx->errors = D.26237;
              }
              <D.26230>:
              ctx->valid = 0;
              D.26052 = 0;
              return D.26052;
              <D.26228>:
              <D.26220>:
              i = 0;
              goto <D.20912>;
              <D.20911>:
              {
                unsigned int flags;
                unsigned int class_token;

                try
                  {
                    ptr.121 = ptr;
                    D.26238 = MEM[(unsigned char *)ptr.121];
                    flags = (unsigned int) D.26238;
                    class_token = 0;
                    ptr.121 = ptr;
                    if (is_fat != 0) goto <D.26240>; else goto <D.26241>;
                    <D.26240>:
                    iftmp.137 = 20;
                    goto <D.26242>;
                    <D.26241>:
                    iftmp.137 = 8;
                    <D.26242>:
                    ptr.138 = ptr.121 + iftmp.137;
                    ptr = ptr.138;
                    D.26244 = safe_read (&ptr, end, &class_token, 4);
                    if (D.26244 == 0) goto <D.26245>; else goto <D.26246>;
                    <D.26245>:
                    D.26046 = ctx->report_error;
                    if (D.26046 != 0) goto <D.26247>; else goto <D.26248>;
                    <D.26247>:
                    {
                      struct MonoVerifyInfoExtended * vinfo;

                      vinfo = monoeg_malloc (12);
                      vinfo->info.status = 1;
                      D.26249 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section %d", i);
                      vinfo->info.message = D.26249;
                      vinfo->exception_type = 3;
                      D.26050 = ctx->errors;
                      D.26250 = monoeg_g_slist_prepend (D.26050, vinfo);
                      ctx->errors = D.26250;
                    }
                    <D.26248>:
                    ctx->valid = 0;
                    D.26052 = 0;
                    return D.26052;
                    <D.26246>:
                    if (flags == 0) goto <D.26251>; else goto <D.26252>;
                    <D.26251>:
                    class_token.139 = class_token;
                    if (class_token.139 != 0) goto <D.26254>; else goto <D.26255>;
                    <D.26254>:
                    {
                      guint table;

                      class_token.139 = class_token;
                      table = class_token.139 >> 24;
                      D.26256 = table + 4294967295;
                      D.26257 = D.26256 > 1;
                      D.26258 = table != 27;
                      D.26259 = D.26257 & D.26258;
                      if (D.26259 != 0) goto <D.26260>; else goto <D.26261>;
                      <D.26260>:
                      D.26046 = ctx->report_error;
                      if (D.26046 != 0) goto <D.26262>; else goto <D.26263>;
                      <D.26262>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        D.26264 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table);
                        vinfo->info.message = D.26264;
                        vinfo->exception_type = 3;
                        D.26050 = ctx->errors;
                        D.26265 = monoeg_g_slist_prepend (D.26050, vinfo);
                        ctx->errors = D.26265;
                      }
                      <D.26263>:
                      ctx->valid = 0;
                      D.26052 = 0;
                      return D.26052;
                      <D.26261>:
                      class_token.139 = class_token;
                      D.26266 = class_token.139 & 16777215;
                      D.26043 = ctx->image;
                      D.26267 = D.26043->tables[table].rows;
                      D.26268 = (unsigned int) D.26267;
                      if (D.26266 > D.26268) goto <D.26269>; else goto <D.26270>;
                      <D.26269>:
                      D.26046 = ctx->report_error;
                      if (D.26046 != 0) goto <D.26271>; else goto <D.26272>;
                      <D.26271>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (12);
                        vinfo->info.status = 1;
                        class_token.139 = class_token;
                        D.26266 = class_token.139 & 16777215;
                        D.26273 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, D.26266);
                        vinfo->info.message = D.26273;
                        vinfo->exception_type = 3;
                        D.26050 = ctx->errors;
                        D.26274 = monoeg_g_slist_prepend (D.26050, vinfo);
                        ctx->errors = D.26274;
                      }
                      <D.26272>:
                      ctx->valid = 0;
                      D.26052 = 0;
                      return D.26052;
                      <D.26270>:
                    }
                    <D.26255>:
                    <D.26252>:
                  }
                finally
                  {
                    class_token = {CLOBBER};
                  }
              }
              i = i + 1;
              <D.20912>:
              if (i < clauses) goto <D.20911>; else goto <D.20913>;
              <D.20913>:
            }
            <D.26209>:
            section_header.131 = section_header;
            D.26275 = section_header.131 & 128;
            if (D.26275 == 0) goto <D.20914>; else goto <D.26276>;
            <D.26276>:
          }
        finally
          {
            section_header = {CLOBBER};
          }
      }
      goto <D.20915>;
      <D.20914>:
      D.26052 = 1;
      return D.26052;
    }
  finally
    {
      local_vars_tok = {CLOBBER};
      code_size = {CLOBBER};
      header = {CLOBBER};
      fat_header = {CLOBBER};
      max_stack = {CLOBBER};
      ptr = {CLOBBER};
    }
}


dword_align (const char * ptr)
{
  const char * D.26284;
  const char * D.26285;
  unsigned int D.26286;
  unsigned int D.26287;

  D.26285 = ptr + 3;
  D.26286 = (unsigned int) D.26285;
  D.26287 = D.26286 & 4294967292;
  D.26284 = (const char *) D.26287;
  return D.26284;
}


verify_memberref_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26289;
  unsigned int D.26290;
  int D.26291;
  int D.26294;
  gchar * D.26297;
  struct GSList * D.26298;
  struct GSList * D.26299;
  <unnamed-unsigned:24> D.26300;
  int D.26301;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.26289 = ctx->image;
      table = &D.26289->tables[10];
      i = 0;
      goto <D.21161>;
      <D.21160>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.26290 = data[2];
      D.26291 = is_valid_method_or_field_signature (ctx, D.26290);
      if (D.26291 == 0) goto <D.26292>; else goto <D.26293>;
      <D.26292>:
      D.26294 = ctx->report_error;
      if (D.26294 != 0) goto <D.26295>; else goto <D.26296>;
      <D.26295>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26290 = data[2];
        D.26297 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, D.26290);
        vinfo->info.message = D.26297;
        vinfo->exception_type = 3;
        D.26298 = ctx->errors;
        D.26299 = monoeg_g_slist_prepend (D.26298, vinfo);
        ctx->errors = D.26299;
      }
      <D.26296>:
      ctx->valid = 0;
      return;
      <D.26293>:
      i = i + 1;
      <D.21161>:
      D.26300 = table->rows;
      D.26301 = (int) D.26300;
      if (D.26301 > i) goto <D.21160>; else goto <D.21162>;
      <D.21162>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_method_or_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.26305;
  int D.26308;
  gchar * D.26311;
  struct GSList * D.26312;
  struct GSList * D.26313;
  gboolean D.26314;
  const char * ptr.140;
  unsigned int size.141;
  int D.26317;
  gchar * D.26322;
  struct GSList * D.26323;
  const char * ptr.142;
  unsigned int signature.143;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.26305 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.26305 == 0) goto <D.26306>; else goto <D.26307>;
      <D.26306>:
      D.26308 = ctx->report_error;
      if (D.26308 != 0) goto <D.26309>; else goto <D.26310>;
      <D.26309>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26311 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.26311;
        vinfo->exception_type = 3;
        D.26312 = ctx->errors;
        D.26313 = monoeg_g_slist_prepend (D.26312, vinfo);
        ctx->errors = D.26313;
      }
      <D.26310>:
      ctx->valid = 0;
      D.26314 = 0;
      return D.26314;
      <D.26307>:
      ptr.140 = ptr;
      size.141 = size;
      end = ptr.140 + size.141;
      D.26317 = safe_read (&ptr, end, &signature, 1);
      if (D.26317 == 0) goto <D.26318>; else goto <D.26319>;
      <D.26318>:
      D.26308 = ctx->report_error;
      if (D.26308 != 0) goto <D.26320>; else goto <D.26321>;
      <D.26320>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26322 = monoeg_strdup ("MemberRefSig: Not enough room for the call conv");
        vinfo->info.message = D.26322;
        vinfo->exception_type = 3;
        D.26312 = ctx->errors;
        D.26323 = monoeg_g_slist_prepend (D.26312, vinfo);
        ctx->errors = D.26323;
      }
      <D.26321>:
      ctx->valid = 0;
      D.26314 = 0;
      return D.26314;
      <D.26319>:
      ptr.140 = ptr;
      ptr.142 = ptr.140 + 4294967295;
      ptr = ptr.142;
      signature.143 = signature;
      if (signature.143 == 6) goto <D.26326>; else goto <D.26327>;
      <D.26326>:
      D.26314 = parse_field (ctx, &ptr, end);
      return D.26314;
      <D.26327>:
      D.26314 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.26314;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_cattr_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26330;
  unsigned int D.26331;
  int D.26332;
  int D.26335;
  gchar * D.26338;
  struct GSList * D.26339;
  struct GSList * D.26340;
  unsigned int D.26341;
  unsigned int D.26342;
  gchar * D.26345;
  struct GSList * D.26346;
  int D.26347;
  _Bool D.26348;
  long int D.26349;
  long int D.26350;
  const char * ptr.144;
  unsigned int size.145;
  int D.26355;
  gchar * D.26360;
  struct GSList * D.26361;
  <unnamed-unsigned:24> D.26362;
  int D.26363;
  struct MonoTableInfo * table;
  struct MonoMethod * ctor;
  const char * ptr;
  guint32 data[3];
  guint32 mtoken;
  guint32 size;
  int i;

  try
    {
      D.26330 = ctx->image;
      table = &D.26330->tables[12];
      i = 0;
      goto <D.21207>;
      <D.21206>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.26331 = data[2];
      D.26332 = is_valid_cattr_blob (ctx, D.26331);
      if (D.26332 == 0) goto <D.26333>; else goto <D.26334>;
      <D.26333>:
      D.26335 = ctx->report_error;
      if (D.26335 != 0) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26331 = data[2];
        D.26338 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, D.26331);
        vinfo->info.message = D.26338;
        vinfo->exception_type = 3;
        D.26339 = ctx->errors;
        D.26340 = monoeg_g_slist_prepend (D.26339, vinfo);
        ctx->errors = D.26340;
      }
      <D.26337>:
      ctx->valid = 0;
      return;
      <D.26334>:
      D.26341 = data[1];
      mtoken = D.26341 >> 3;
      D.26341 = data[1];
      D.26342 = D.26341 & 7;
      switch (D.26342) <default: <D.21203>, case 2: <D.21200>, case 3: <D.21202>>
      <D.21200>:
      mtoken = mtoken | 100663296;
      goto <D.21201>;
      <D.21202>:
      mtoken = mtoken | 167772160;
      goto <D.21201>;
      <D.21203>:
      D.26335 = ctx->report_error;
      if (D.26335 != 0) goto <D.26343>; else goto <D.26344>;
      <D.26343>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26341 = data[1];
        D.26345 = monoeg_g_strdup_printf ("Invalid CustomAttribute constructor row %d Token 0x%08x", i, D.26341);
        vinfo->info.message = D.26345;
        vinfo->exception_type = 3;
        D.26339 = ctx->errors;
        D.26346 = monoeg_g_slist_prepend (D.26339, vinfo);
        ctx->errors = D.26346;
      }
      <D.26344>:
      ctx->valid = 0;
      return;
      <D.21201>:
      D.26330 = ctx->image;
      ctor = mono_get_method (D.26330, mtoken, 0B);
      D.26331 = data[2];
      D.26347 = decode_signature_header (ctx, D.26331, &size, &ptr);
      D.26348 = D.26347 == 0;
      D.26349 = (long int) D.26348;
      D.26350 = __builtin_expect (D.26349, 0);
      if (D.26350 != 0) goto <D.26351>; else goto <D.26352>;
      <D.26351>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 2956, "decode_signature_header (ctx, data [MONO_CUSTOM_ATTR_VALUE], &size, &ptr)");
      <D.26352>:
      ptr.144 = ptr;
      size.145 = size;
      D.26355 = is_valid_cattr_content (ctx, ctor, ptr.144, size.145);
      if (D.26355 == 0) goto <D.26356>; else goto <D.26357>;
      <D.26356>:
      D.26335 = ctx->report_error;
      if (D.26335 != 0) goto <D.26358>; else goto <D.26359>;
      <D.26358>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26331 = data[2];
        D.26360 = monoeg_g_strdup_printf ("Invalid CustomAttribute content row %d Value field 0x%08x", i, D.26331);
        vinfo->info.message = D.26360;
        vinfo->exception_type = 3;
        D.26339 = ctx->errors;
        D.26361 = monoeg_g_slist_prepend (D.26339, vinfo);
        ctx->errors = D.26361;
      }
      <D.26359>:
      ctx->valid = 0;
      return;
      <D.26357>:
      i = i + 1;
      <D.21207>:
      D.26362 = table->rows;
      D.26363 = (int) D.26362;
      if (D.26363 > i) goto <D.21206>; else goto <D.21208>;
      <D.21208>:
    }
  finally
    {
      ptr = {CLOBBER};
      data = {CLOBBER};
      size = {CLOBBER};
    }
}


is_valid_cattr_blob (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.26369;
  int D.26370;
  int D.26373;
  gchar * D.26376;
  struct GSList * D.26377;
  struct GSList * D.26378;
  const char * ptr.146;
  unsigned int size.147;
  int D.26381;
  gchar * D.26386;
  struct GSList * D.26387;
  unsigned int prolog.148;
  gchar * D.26393;
  struct GSList * D.26394;
  guint32 size;
  unsigned int prolog;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      prolog = 0;
      ptr = 0B;
      if (offset == 0) goto <D.26367>; else goto <D.26368>;
      <D.26367>:
      D.26369 = 1;
      return D.26369;
      <D.26368>:
      D.26370 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.26370 == 0) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      D.26373 = ctx->report_error;
      if (D.26373 != 0) goto <D.26374>; else goto <D.26375>;
      <D.26374>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26376 = monoeg_strdup ("CustomAttribute: Could not decode signature header");
        vinfo->info.message = D.26376;
        vinfo->exception_type = 3;
        D.26377 = ctx->errors;
        D.26378 = monoeg_g_slist_prepend (D.26377, vinfo);
        ctx->errors = D.26378;
      }
      <D.26375>:
      ctx->valid = 0;
      D.26369 = 0;
      return D.26369;
      <D.26372>:
      ptr.146 = ptr;
      size.147 = size;
      end = ptr.146 + size.147;
      D.26381 = safe_read (&ptr, end, &prolog, 2);
      if (D.26381 == 0) goto <D.26382>; else goto <D.26383>;
      <D.26382>:
      D.26373 = ctx->report_error;
      if (D.26373 != 0) goto <D.26384>; else goto <D.26385>;
      <D.26384>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26386 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.26386;
        vinfo->exception_type = 3;
        D.26377 = ctx->errors;
        D.26387 = monoeg_g_slist_prepend (D.26377, vinfo);
        ctx->errors = D.26387;
      }
      <D.26385>:
      ctx->valid = 0;
      D.26369 = 0;
      return D.26369;
      <D.26383>:
      prolog.148 = prolog;
      if (prolog.148 != 1) goto <D.26389>; else goto <D.26390>;
      <D.26389>:
      D.26373 = ctx->report_error;
      if (D.26373 != 0) goto <D.26391>; else goto <D.26392>;
      <D.26391>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.148 = prolog;
        D.26393 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.148);
        vinfo->info.message = D.26393;
        vinfo->exception_type = 3;
        D.26377 = ctx->errors;
        D.26394 = monoeg_g_slist_prepend (D.26377, vinfo);
        ctx->errors = D.26394;
      }
      <D.26392>:
      ctx->valid = 0;
      D.26369 = 0;
      return D.26369;
      <D.26390>:
      D.26369 = 1;
      return D.26369;
    }
  finally
    {
      size = {CLOBBER};
      prolog = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_cattr_content (struct VerifyContext * ctx, struct MonoMethod * ctor, const char * ptr, guint32 size)
{
  int D.26399;
  gchar * D.26402;
  struct GSList * D.26403;
  struct GSList * D.26404;
  gboolean D.26405;
  int D.26406;
  const char * D.26411;
  gchar * D.26412;
  struct GSList * D.26413;
  short int D.26416;
  unsigned char D.26418;
  unsigned char D.26419;
  gchar * D.26422;
  struct GSList * D.26423;
  const char * ptr.149;
  int D.26425;
  gchar * D.26430;
  struct GSList * D.26431;
  unsigned int prolog.150;
  gchar * D.26437;
  struct GSList * D.26438;
  short unsigned int D.26439;
  int D.26440;
  int D.26443;
  gchar * D.26448;
  struct GSList * D.26449;
  int D.26450;
  gchar * D.26455;
  struct GSList * D.26456;
  unsigned int kind.151;
  unsigned int D.26458;
  gchar * D.26463;
  struct GSList * D.26464;
  int D.26465;
  gchar * D.26470;
  struct GSList * D.26471;
  unsigned int D.26472;
  unsigned char D.26475;
  struct MonoClass * D.26484;
  struct MonoClass * D.26488;
  int D.26492;
  gchar * D.26497;
  struct GSList * D.26498;
  unsigned int etype.152;
  unsigned int etype.153;
  _Bool D.26506;
  _Bool D.26507;
  _Bool D.26508;
  unsigned int etype.154;
  unsigned int D.26513;
  _Bool D.26514;
  _Bool D.26515;
  _Bool D.26516;
  unsigned char iftmp.155;
  gchar * D.26526;
  struct GSList * D.26527;
  struct MonoClass * D.26528;
  gchar * D.26532;
  struct GSList * D.26533;
  int D.26534;
  int D.26537;
  unsigned int i.156;
  unsigned int num_named.157;
  struct MonoError error;
  unsigned int prolog;
  const char * end;
  struct MonoMethodSignature * sig;
  int args;
  int i;
  unsigned int num_named;

  try
    {
      prolog = 0;
      if (ctor == 0B) goto <D.26397>; else goto <D.26398>;
      <D.26397>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26400>; else goto <D.26401>;
      <D.26400>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26402 = monoeg_strdup ("CustomAttribute: Invalid constructor");
        vinfo->info.message = D.26402;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26404 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26404;
      }
      <D.26401>:
      ctx->valid = 0;
      D.26405 = 0;
      return D.26405;
      <D.26398>:
      sig = mono_method_signature_checked (ctor, &error);
      D.26406 = mono_error_ok (&error);
      if (D.26406 == 0) goto <D.26407>; else goto <D.26408>;
      <D.26407>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26409>; else goto <D.26410>;
      <D.26409>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26411 = mono_error_get_message (&error);
        D.26412 = monoeg_g_strdup_printf ("CustomAttribute: Invalid constructor signature %s", D.26411);
        vinfo->info.message = D.26412;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26413 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26413;
      }
      <D.26410>:
      ctx->valid = 0;
      mono_error_cleanup (&error);
      D.26405 = 0;
      return D.26405;
      <D.26408>:
      D.26416 = sig->sentinelpos;
      if (D.26416 != -1) goto <D.26414>; else goto <D.26417>;
      <D.26417>:
      D.26418 = BIT_FIELD_REF <*sig, 8, 80>;
      D.26419 = D.26418 & 63;
      if (D.26419 == 5) goto <D.26414>; else goto <D.26415>;
      <D.26414>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26422 = monoeg_strdup ("CustomAttribute: Constructor cannot have VARAG signature");
        vinfo->info.message = D.26422;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26423 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26423;
      }
      <D.26421>:
      ctx->valid = 0;
      D.26405 = 0;
      return D.26405;
      <D.26415>:
      ptr.149 = ptr;
      end = ptr.149 + size;
      D.26425 = safe_read (&ptr, end, &prolog, 2);
      if (D.26425 == 0) goto <D.26426>; else goto <D.26427>;
      <D.26426>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26428>; else goto <D.26429>;
      <D.26428>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26430 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.26430;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26431 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26431;
      }
      <D.26429>:
      ctx->valid = 0;
      D.26405 = 0;
      return D.26405;
      <D.26427>:
      prolog.150 = prolog;
      if (prolog.150 != 1) goto <D.26433>; else goto <D.26434>;
      <D.26433>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26435>; else goto <D.26436>;
      <D.26435>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        prolog.150 = prolog;
        D.26437 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.150);
        vinfo->info.message = D.26437;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26438 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26438;
      }
      <D.26436>:
      ctx->valid = 0;
      D.26405 = 0;
      return D.26405;
      <D.26434>:
      D.26439 = sig->param_count;
      args = (int) D.26439;
      i = 0;
      goto <D.20749>;
      <D.20748>:
      {
        struct MonoType * arg_type;

        arg_type = sig->params[i];
        D.26440 = is_valid_fixed_param (ctx, arg_type, &ptr, end);
        if (D.26440 == 0) goto <D.26441>; else goto <D.26442>;
        <D.26441>:
        D.26405 = 0;
        return D.26405;
        <D.26442>:
      }
      i = i + 1;
      <D.20749>:
      if (i < args) goto <D.20748>; else goto <D.20750>;
      <D.20750>:
      D.26443 = safe_read (&ptr, end, &num_named, 2);
      if (D.26443 == 0) goto <D.26444>; else goto <D.26445>;
      <D.26444>:
      D.26399 = ctx->report_error;
      if (D.26399 != 0) goto <D.26446>; else goto <D.26447>;
      <D.26446>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26448 = monoeg_strdup ("CustomAttribute: Not enough space for num_named field");
        vinfo->info.message = D.26448;
        vinfo->exception_type = 3;
        D.26403 = ctx->errors;
        D.26449 = monoeg_g_slist_prepend (D.26403, vinfo);
        ctx->errors = D.26449;
      }
      <D.26447>:
      ctx->valid = 0;
      D.26405 = 0;
      return D.26405;
      <D.26445>:
      i = 0;
      goto <D.20765>;
      <D.20764>:
      {
        struct MonoType * type;
        struct MonoType simple_type;
        unsigned int kind;

        try
          {
            simple_type = {};
            D.26450 = safe_read (&ptr, end, &kind, 1);
            if (D.26450 == 0) goto <D.26451>; else goto <D.26452>;
            <D.26451>:
            D.26399 = ctx->report_error;
            if (D.26399 != 0) goto <D.26453>; else goto <D.26454>;
            <D.26453>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26455 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d kind", i);
              vinfo->info.message = D.26455;
              vinfo->exception_type = 3;
              D.26403 = ctx->errors;
              D.26456 = monoeg_g_slist_prepend (D.26403, vinfo);
              ctx->errors = D.26456;
            }
            <D.26454>:
            ctx->valid = 0;
            D.26405 = 0;
            return D.26405;
            <D.26452>:
            kind.151 = kind;
            D.26458 = kind.151 + 4294967213;
            if (D.26458 > 1) goto <D.26459>; else goto <D.26460>;
            <D.26459>:
            D.26399 = ctx->report_error;
            if (D.26399 != 0) goto <D.26461>; else goto <D.26462>;
            <D.26461>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.151 = kind;
              D.26463 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter %d kind %x", i, kind.151);
              vinfo->info.message = D.26463;
              vinfo->exception_type = 3;
              D.26403 = ctx->errors;
              D.26464 = monoeg_g_slist_prepend (D.26403, vinfo);
              ctx->errors = D.26464;
            }
            <D.26462>:
            ctx->valid = 0;
            D.26405 = 0;
            return D.26405;
            <D.26460>:
            D.26465 = safe_read (&ptr, end, &kind, 1);
            if (D.26465 == 0) goto <D.26466>; else goto <D.26467>;
            <D.26466>:
            D.26399 = ctx->report_error;
            if (D.26399 != 0) goto <D.26468>; else goto <D.26469>;
            <D.26468>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26470 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i);
              vinfo->info.message = D.26470;
              vinfo->exception_type = 3;
              D.26403 = ctx->errors;
              D.26471 = monoeg_g_slist_prepend (D.26403, vinfo);
              ctx->errors = D.26471;
            }
            <D.26469>:
            ctx->valid = 0;
            D.26405 = 0;
            return D.26405;
            <D.26467>:
            kind.151 = kind;
            D.26472 = kind.151 + 4294967294;
            if (D.26472 <= 12) goto <D.26473>; else goto <D.26474>;
            <D.26473>:
            kind.151 = kind;
            D.26475 = (unsigned char) kind.151;
            simple_type.type = D.26475;
            type = &simple_type;
            goto <D.26476>;
            <D.26474>:
            kind.151 = kind;
            if (kind.151 == 85) goto <D.26477>; else goto <D.26478>;
            <D.26477>:
            {
              struct MonoClass * klass;

              klass = get_enum_by_encoded_name (ctx, &ptr, end);
              if (klass == 0B) goto <D.26479>; else goto <D.26480>;
              <D.26479>:
              D.26405 = 0;
              return D.26405;
              <D.26480>:
              type = &klass->byval_arg;
            }
            goto <D.26481>;
            <D.26478>:
            kind.151 = kind;
            if (kind.151 == 80) goto <D.26482>; else goto <D.26483>;
            <D.26482>:
            D.26484 = mono_defaults.systemtype_class;
            type = &D.26484->byval_arg;
            goto <D.26485>;
            <D.26483>:
            kind.151 = kind;
            if (kind.151 == 81) goto <D.26486>; else goto <D.26487>;
            <D.26486>:
            D.26488 = mono_defaults.object_class;
            type = &D.26488->byval_arg;
            goto <D.26489>;
            <D.26487>:
            kind.151 = kind;
            if (kind.151 == 29) goto <D.26490>; else goto <D.26491>;
            <D.26490>:
            {
              struct MonoClass * klass;
              unsigned int etype;

              try
                {
                  etype = 0;
                  D.26492 = safe_read (&ptr, end, &etype, 1);
                  if (D.26492 == 0) goto <D.26493>; else goto <D.26494>;
                  <D.26493>:
                  D.26399 = ctx->report_error;
                  if (D.26399 != 0) goto <D.26495>; else goto <D.26496>;
                  <D.26495>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.26497 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.26497;
                    vinfo->exception_type = 3;
                    D.26403 = ctx->errors;
                    D.26498 = monoeg_g_slist_prepend (D.26403, vinfo);
                    ctx->errors = D.26498;
                  }
                  <D.26496>:
                  ctx->valid = 0;
                  D.26405 = 0;
                  return D.26405;
                  <D.26494>:
                  etype.152 = etype;
                  if (etype.152 == 85) goto <D.26500>; else goto <D.26501>;
                  <D.26500>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.26502>; else goto <D.26503>;
                  <D.26502>:
                  D.26405 = 0;
                  return D.26405;
                  <D.26503>:
                  goto <D.26504>;
                  <D.26501>:
                  etype.153 = etype;
                  D.26506 = etype.153 == 80;
                  D.26507 = etype.153 == 18;
                  D.26508 = D.26506 | D.26507;
                  if (D.26508 != 0) goto <D.26509>; else goto <D.26510>;
                  <D.26509>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.26511>;
                  <D.26510>:
                  etype.154 = etype;
                  D.26513 = etype.154 + 4294967294;
                  D.26514 = D.26513 <= 12;
                  D.26515 = etype.154 == 81;
                  D.26516 = D.26514 | D.26515;
                  if (D.26516 != 0) goto <D.26517>; else goto <D.26518>;
                  <D.26517>:
                  etype.152 = etype;
                  if (etype.152 != 81) goto <D.26520>; else goto <D.26521>;
                  <D.26520>:
                  etype.152 = etype;
                  iftmp.155 = (unsigned char) etype.152;
                  goto <D.26522>;
                  <D.26521>:
                  iftmp.155 = 28;
                  <D.26522>:
                  simple_type.type = iftmp.155;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.26523>;
                  <D.26518>:
                  D.26399 = ctx->report_error;
                  if (D.26399 != 0) goto <D.26524>; else goto <D.26525>;
                  <D.26524>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.152 = etype;
                    D.26526 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.152);
                    vinfo->info.message = D.26526;
                    vinfo->exception_type = 3;
                    D.26403 = ctx->errors;
                    D.26527 = monoeg_g_slist_prepend (D.26403, vinfo);
                    ctx->errors = D.26527;
                  }
                  <D.26525>:
                  ctx->valid = 0;
                  D.26405 = 0;
                  return D.26405;
                  <D.26523>:
                  <D.26511>:
                  <D.26504>:
                  D.26528 = mono_array_class_get (klass, 1);
                  type = &D.26528->byval_arg;
                }
              finally
                {
                  etype = {CLOBBER};
                }
            }
            goto <D.26529>;
            <D.26491>:
            D.26399 = ctx->report_error;
            if (D.26399 != 0) goto <D.26530>; else goto <D.26531>;
            <D.26530>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              kind.151 = kind;
              D.26532 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter type %x", kind.151);
              vinfo->info.message = D.26532;
              vinfo->exception_type = 3;
              D.26403 = ctx->errors;
              D.26533 = monoeg_g_slist_prepend (D.26403, vinfo);
              ctx->errors = D.26533;
            }
            <D.26531>:
            ctx->valid = 0;
            D.26405 = 0;
            return D.26405;
            <D.26529>:
            <D.26489>:
            <D.26485>:
            <D.26481>:
            <D.26476>:
            D.26534 = is_valid_ser_string (ctx, &ptr, end);
            if (D.26534 == 0) goto <D.26535>; else goto <D.26536>;
            <D.26535>:
            D.26405 = 0;
            return D.26405;
            <D.26536>:
            D.26537 = is_valid_fixed_param (ctx, type, &ptr, end);
            if (D.26537 == 0) goto <D.26538>; else goto <D.26539>;
            <D.26538>:
            D.26405 = 0;
            return D.26405;
            <D.26539>:
          }
        finally
          {
            simple_type = {CLOBBER};
            kind = {CLOBBER};
          }
      }
      i = i + 1;
      <D.20765>:
      i.156 = (unsigned int) i;
      num_named.157 = num_named;
      if (i.156 < num_named.157) goto <D.20764>; else goto <D.20766>;
      <D.20766>:
      D.26405 = 1;
      return D.26405;
    }
  finally
    {
      error = {CLOBBER};
      prolog = {CLOBBER};
      num_named = {CLOBBER};
    }
}


get_enum_by_encoded_name (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.158;
  int D.26549;
  struct MonoClass * D.26552;
  const char * str_start.159;
  unsigned int str_len.160;
  int D.26558;
  gchar * D.26561;
  struct GSList * D.26562;
  struct GSList * D.26563;
  unsigned int D.26564;
  char * D.26565;
  struct MonoImage * D.26566;
  gchar * D.26571;
  struct GSList * D.26572;
  unsigned char D.26576;
  unsigned char D.26577;
  const char * D.26580;
  const char * D.26581;
  gchar * D.26582;
  struct GSList * D.26583;
  const char * ptr.161;
  struct MonoType * type;
  struct MonoClass * klass;
  const char * str_start;
  const char * ptr;
  char * enum_name;
  guint32 str_len;

  try
    {
      str_start = 0B;
      ptr.158 = *_ptr;
      ptr = ptr.158;
      str_len = 0;
      D.26549 = is_valid_ser_string_full (ctx, &str_start, &str_len, &ptr, end);
      if (D.26549 == 0) goto <D.26550>; else goto <D.26551>;
      <D.26550>:
      D.26552 = 0B;
      return D.26552;
      <D.26551>:
      str_start.159 = str_start;
      if (str_start.159 == 0B) goto <D.26553>; else goto <D.26556>;
      <D.26556>:
      str_len.160 = str_len;
      if (str_len.160 == 0) goto <D.26553>; else goto <D.26554>;
      <D.26553>:
      D.26558 = ctx->report_error;
      if (D.26558 != 0) goto <D.26559>; else goto <D.26560>;
      <D.26559>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26561 = monoeg_strdup ("CustomAttribute: Null or empty enum name");
        vinfo->info.message = D.26561;
        vinfo->exception_type = 3;
        D.26562 = ctx->errors;
        D.26563 = monoeg_g_slist_prepend (D.26562, vinfo);
        ctx->errors = D.26563;
      }
      <D.26560>:
      ctx->valid = 0;
      D.26552 = 0B;
      return D.26552;
      <D.26554>:
      str_start.159 = str_start;
      str_len.160 = str_len;
      D.26564 = str_len.160 + 1;
      enum_name = monoeg_g_memdup (str_start.159, D.26564);
      str_len.160 = str_len;
      D.26565 = enum_name + str_len.160;
      *D.26565 = 0;
      D.26566 = ctx->image;
      type = mono_reflection_type_from_name (enum_name, D.26566);
      if (type == 0B) goto <D.26567>; else goto <D.26568>;
      <D.26567>:
      D.26558 = ctx->report_error;
      if (D.26558 != 0) goto <D.26569>; else goto <D.26570>;
      <D.26569>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26571 = monoeg_g_strdup_printf ("CustomAttribute: Invalid enum class %s", enum_name);
        vinfo->info.message = D.26571;
        vinfo->exception_type = 3;
        D.26562 = ctx->errors;
        D.26572 = monoeg_g_slist_prepend (D.26562, vinfo);
        ctx->errors = D.26572;
      }
      <D.26570>:
      ctx->valid = 0;
      monoeg_g_free (enum_name);
      D.26552 = 0B;
      return D.26552;
      <D.26568>:
      monoeg_g_free (enum_name);
      klass = mono_class_from_mono_type (type);
      if (klass == 0B) goto <D.26573>; else goto <D.26575>;
      <D.26575>:
      D.26576 = BIT_FIELD_REF <*klass, 8, 160>;
      D.26577 = D.26576 & 16;
      if (D.26577 == 0) goto <D.26573>; else goto <D.26574>;
      <D.26573>:
      D.26558 = ctx->report_error;
      if (D.26558 != 0) goto <D.26578>; else goto <D.26579>;
      <D.26578>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26580 = klass->name_space;
        D.26581 = klass->name;
        D.26582 = monoeg_g_strdup_printf ("CustomAttribute:Class %s::%s is not an enum", D.26580, D.26581);
        vinfo->info.message = D.26582;
        vinfo->exception_type = 3;
        D.26562 = ctx->errors;
        D.26583 = monoeg_g_slist_prepend (D.26562, vinfo);
        ctx->errors = D.26583;
      }
      <D.26579>:
      ctx->valid = 0;
      D.26552 = 0B;
      return D.26552;
      <D.26574>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.26552 = klass;
      return D.26552;
    }
  finally
    {
      str_start = {CLOBBER};
      ptr = {CLOBBER};
      str_len = {CLOBBER};
    }
}


is_valid_ser_string_full (struct VerifyContext * ctx, const char * * str_start, guint32 * str_len, const char * * _ptr, const char * end)
{
  const char * ptr.162;
  const char * ptr.163;
  int D.26591;
  gchar * D.26594;
  struct GSList * D.26595;
  struct GSList * D.26596;
  gboolean D.26597;
  char D.26598;
  const char * D.26601;
  int D.26602;
  gchar * D.26607;
  struct GSList * D.26608;
  unsigned int size.164;
  const char * D.26612;
  unsigned int D.26614;
  unsigned int ptr.165;
  gchar * D.26618;
  struct GSList * D.26619;
  guint32 size;
  const char * ptr;

  try
    {
      size = 0;
      ptr.162 = *_ptr;
      ptr = ptr.162;
      *str_start = 0B;
      *str_len = 0;
      ptr.163 = ptr;
      if (ptr.163 >= end) goto <D.26589>; else goto <D.26590>;
      <D.26589>:
      D.26591 = ctx->report_error;
      if (D.26591 != 0) goto <D.26592>; else goto <D.26593>;
      <D.26592>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26594 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.26594;
        vinfo->exception_type = 3;
        D.26595 = ctx->errors;
        D.26596 = monoeg_g_slist_prepend (D.26595, vinfo);
        ctx->errors = D.26596;
      }
      <D.26593>:
      ctx->valid = 0;
      D.26597 = 0;
      return D.26597;
      <D.26590>:
      ptr.163 = ptr;
      D.26598 = *ptr.163;
      if (D.26598 == 255) goto <D.26599>; else goto <D.26600>;
      <D.26599>:
      ptr.163 = ptr;
      D.26601 = ptr.163 + 1;
      *_ptr = D.26601;
      D.26597 = 1;
      return D.26597;
      <D.26600>:
      D.26602 = safe_read_compressed_int (&ptr, end, &size);
      if (D.26602 == 0) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      D.26591 = ctx->report_error;
      if (D.26591 != 0) goto <D.26605>; else goto <D.26606>;
      <D.26605>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26607 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.26607;
        vinfo->exception_type = 3;
        D.26595 = ctx->errors;
        D.26608 = monoeg_g_slist_prepend (D.26595, vinfo);
        ctx->errors = D.26608;
      }
      <D.26606>:
      ctx->valid = 0;
      D.26597 = 0;
      return D.26597;
      <D.26604>:
      ptr.163 = ptr;
      size.164 = size;
      D.26612 = ptr.163 + size.164;
      if (D.26612 > end) goto <D.26609>; else goto <D.26613>;
      <D.26613>:
      size.164 = size;
      D.26614 = ~size.164;
      ptr.163 = ptr;
      ptr.165 = (unsigned int) ptr.163;
      if (D.26614 < ptr.165) goto <D.26609>; else goto <D.26610>;
      <D.26609>:
      D.26591 = ctx->report_error;
      if (D.26591 != 0) goto <D.26616>; else goto <D.26617>;
      <D.26616>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26618 = monoeg_strdup ("CustomAttribute: Not enough room for string");
        vinfo->info.message = D.26618;
        vinfo->exception_type = 3;
        D.26595 = ctx->errors;
        D.26619 = monoeg_g_slist_prepend (D.26595, vinfo);
        ctx->errors = D.26619;
      }
      <D.26617>:
      ctx->valid = 0;
      D.26597 = 0;
      return D.26597;
      <D.26610>:
      ptr.163 = ptr;
      *str_start = ptr.163;
      size.164 = size;
      *str_len = size.164;
      ptr.163 = ptr;
      size.164 = size;
      D.26612 = ptr.163 + size.164;
      *_ptr = D.26612;
      D.26597 = 1;
      return D.26597;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_ser_string (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  gboolean D.26622;
  const char * dummy_str;
  guint32 dummy_int;

  try
    {
      D.26622 = is_valid_ser_string_full (ctx, &dummy_str, &dummy_int, _ptr, end);
      return D.26622;
    }
  finally
    {
      dummy_str = {CLOBBER};
      dummy_int = {CLOBBER};
    }
}


is_valid_fixed_param (struct VerifyContext * ctx, struct MonoType * mono_type, const char * * _ptr, const char * end)
{
  const char * ptr.166;
  unsigned char D.26626;
  const char * ptr.167;
  gboolean D.26628;
  int D.26629;
  int D.26632;
  gchar * D.26635;
  struct GSList * D.26636;
  struct GSList * D.26637;
  unsigned int sub_type.168;
  unsigned int D.26639;
  unsigned char D.26646;
  int D.26651;
  gchar * D.26656;
  struct GSList * D.26657;
  unsigned int etype.169;
  unsigned int etype.170;
  _Bool D.26665;
  _Bool D.26666;
  _Bool D.26667;
  unsigned int etype.171;
  unsigned int D.26672;
  _Bool D.26673;
  _Bool D.26674;
  _Bool D.26675;
  unsigned char iftmp.172;
  gchar * D.26685;
  struct GSList * D.26686;
  gchar * D.26689;
  struct GSList * D.26690;
  struct MonoClass * D.26691;
  const char * D.26696;
  const char * D.26697;
  gchar * D.26698;
  struct GSList * D.26699;
  unsigned char D.26703;
  unsigned char D.26704;
  gchar * D.26707;
  struct GSList * D.26708;
  int D.26709;
  gchar * D.26714;
  struct GSList * D.26715;
  int D.26716;
  gchar * D.26721;
  struct GSList * D.26722;
  unsigned int element_count.173;
  int D.26726;
  gchar * D.26731;
  struct GSList * D.26732;
  sizetype elem_size.174;
  const char * D.26736;
  unsigned int elem_size.175;
  unsigned int D.26739;
  unsigned int ptr.176;
  gchar * D.26743;
  struct GSList * D.26744;
  struct MonoClass * klass;
  const char * ptr;
  int elem_size;
  guint32 element_count;
  guint32 i;
  int type;
  void handle_enum = <<< error >>>;

  try
    {
      ptr.166 = *_ptr;
      ptr = ptr.166;
      elem_size = 0;
      klass = mono_type->data.klass;
      D.26626 = mono_type->type;
      type = (int) D.26626;
      handle_enum:
      switch (type) <default: <D.20726>, case 2: <D.20694>, case 3: <D.20700>, case 4: <D.20695>, case 5: <D.20696>, case 6: <D.20698>, case 7: <D.20699>, case 8: <D.20701>, case 9: <D.20702>, case 10: <D.20704>, case 11: <D.20705>, case 12: <D.20703>, case 13: <D.20706>, case 14: <D.20707>, case 17: <D.20718>, case 18: <D.20716>, case 28: <D.20708>, case 29: <D.20720>>
      <D.20694>:
      <D.20695>:
      <D.20696>:
      elem_size = 1;
      goto <D.20697>;
      <D.20698>:
      <D.20699>:
      <D.20700>:
      elem_size = 2;
      goto <D.20697>;
      <D.20701>:
      <D.20702>:
      <D.20703>:
      elem_size = 4;
      goto <D.20697>;
      <D.20704>:
      <D.20705>:
      <D.20706>:
      elem_size = 8;
      goto <D.20697>;
      <D.20707>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.26628 = is_valid_ser_string (ctx, _ptr, end);
      return D.26628;
      <D.20708>:
      {
        unsigned int sub_type;

        try
          {
            sub_type = 0;
            D.26629 = safe_read (&ptr, end, &sub_type, 1);
            if (D.26629 == 0) goto <D.26630>; else goto <D.26631>;
            <D.26630>:
            D.26632 = ctx->report_error;
            if (D.26632 != 0) goto <D.26633>; else goto <D.26634>;
            <D.26633>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              D.26635 = monoeg_strdup ("CustomAttribute: Not enough room for array type");
              vinfo->info.message = D.26635;
              vinfo->exception_type = 3;
              D.26636 = ctx->errors;
              D.26637 = monoeg_g_slist_prepend (D.26636, vinfo);
              ctx->errors = D.26637;
            }
            <D.26634>:
            ctx->valid = 0;
            D.26628 = 0;
            return D.26628;
            <D.26631>:
            sub_type.168 = sub_type;
            D.26639 = sub_type.168 + 4294967294;
            if (D.26639 <= 12) goto <D.26640>; else goto <D.26641>;
            <D.26640>:
            sub_type.168 = sub_type;
            type = (int) sub_type.168;
            goto handle_enum;
            <D.26641>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 85) goto <D.26642>; else goto <D.26643>;
            <D.26642>:
            klass = get_enum_by_encoded_name (ctx, &ptr, end);
            if (klass == 0B) goto <D.26644>; else goto <D.26645>;
            <D.26644>:
            D.26628 = 0;
            return D.26628;
            <D.26645>:
            klass = klass->element_class;
            D.26646 = klass->byval_arg.type;
            type = (int) D.26646;
            goto handle_enum;
            <D.26643>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 80) goto <D.26647>; else goto <D.26648>;
            <D.26647>:
            ptr.167 = ptr;
            *_ptr = ptr.167;
            D.26628 = is_valid_ser_string (ctx, _ptr, end);
            return D.26628;
            <D.26648>:
            sub_type.168 = sub_type;
            if (sub_type.168 == 29) goto <D.26649>; else goto <D.26650>;
            <D.26649>:
            {
              struct MonoType simple_type;
              unsigned int etype;

              try
                {
                  simple_type = {};
                  etype = 0;
                  D.26651 = safe_read (&ptr, end, &etype, 1);
                  if (D.26651 == 0) goto <D.26652>; else goto <D.26653>;
                  <D.26652>:
                  D.26632 = ctx->report_error;
                  if (D.26632 != 0) goto <D.26654>; else goto <D.26655>;
                  <D.26654>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    D.26656 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.26656;
                    vinfo->exception_type = 3;
                    D.26636 = ctx->errors;
                    D.26657 = monoeg_g_slist_prepend (D.26636, vinfo);
                    ctx->errors = D.26657;
                  }
                  <D.26655>:
                  ctx->valid = 0;
                  D.26628 = 0;
                  return D.26628;
                  <D.26653>:
                  etype.169 = etype;
                  if (etype.169 == 85) goto <D.26659>; else goto <D.26660>;
                  <D.26659>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.26661>; else goto <D.26662>;
                  <D.26661>:
                  D.26628 = 0;
                  return D.26628;
                  <D.26662>:
                  goto <D.26663>;
                  <D.26660>:
                  etype.170 = etype;
                  D.26665 = etype.170 == 80;
                  D.26666 = etype.170 == 18;
                  D.26667 = D.26665 | D.26666;
                  if (D.26667 != 0) goto <D.26668>; else goto <D.26669>;
                  <D.26668>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.26670>;
                  <D.26669>:
                  etype.171 = etype;
                  D.26672 = etype.171 + 4294967294;
                  D.26673 = D.26672 <= 12;
                  D.26674 = etype.171 == 81;
                  D.26675 = D.26673 | D.26674;
                  if (D.26675 != 0) goto <D.26676>; else goto <D.26677>;
                  <D.26676>:
                  etype.169 = etype;
                  if (etype.169 != 81) goto <D.26679>; else goto <D.26680>;
                  <D.26679>:
                  etype.169 = etype;
                  iftmp.172 = (unsigned char) etype.169;
                  goto <D.26681>;
                  <D.26680>:
                  iftmp.172 = 28;
                  <D.26681>:
                  simple_type.type = iftmp.172;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.26682>;
                  <D.26677>:
                  D.26632 = ctx->report_error;
                  if (D.26632 != 0) goto <D.26683>; else goto <D.26684>;
                  <D.26683>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (12);
                    vinfo->info.status = 1;
                    etype.169 = etype;
                    D.26685 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.169);
                    vinfo->info.message = D.26685;
                    vinfo->exception_type = 3;
                    D.26636 = ctx->errors;
                    D.26686 = monoeg_g_slist_prepend (D.26636, vinfo);
                    ctx->errors = D.26686;
                  }
                  <D.26684>:
                  ctx->valid = 0;
                  D.26628 = 0;
                  return D.26628;
                  <D.26682>:
                  <D.26670>:
                  <D.26663>:
                  type = 29;
                  goto handle_enum;
                }
              finally
                {
                  simple_type = {CLOBBER};
                  etype = {CLOBBER};
                }
            }
            <D.26650>:
            D.26632 = ctx->report_error;
            if (D.26632 != 0) goto <D.26687>; else goto <D.26688>;
            <D.26687>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (12);
              vinfo->info.status = 1;
              sub_type.168 = sub_type;
              D.26689 = monoeg_g_strdup_printf ("CustomAttribute: Invalid boxed object type %x", sub_type.168);
              vinfo->info.message = D.26689;
              vinfo->exception_type = 3;
              D.26636 = ctx->errors;
              D.26690 = monoeg_g_slist_prepend (D.26636, vinfo);
              ctx->errors = D.26690;
            }
            <D.26688>:
            ctx->valid = 0;
            D.26628 = 0;
            return D.26628;
          }
        finally
          {
            sub_type = {CLOBBER};
          }
      }
      <D.20716>:
      D.26691 = mono_defaults.systemtype_class;
      if (D.26691 != klass) goto <D.26692>; else goto <D.26693>;
      <D.26692>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26696 = klass->name_space;
        D.26697 = klass->name;
        D.26698 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.26696, D.26697);
        vinfo->info.message = D.26698;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26699 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26699;
      }
      <D.26695>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.26693>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.26628 = is_valid_ser_string (ctx, _ptr, end);
      return D.26628;
      <D.20718>:
      if (klass == 0B) goto <D.26700>; else goto <D.26702>;
      <D.26702>:
      D.26703 = BIT_FIELD_REF <*klass, 8, 160>;
      D.26704 = D.26703 & 16;
      if (D.26704 == 0) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26705>; else goto <D.26706>;
      <D.26705>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26696 = klass->name_space;
        D.26697 = klass->name;
        D.26707 = monoeg_g_strdup_printf ("CustomAttribute: Invalid valuetype parameter expected enum %s:%s ", D.26696, D.26697);
        vinfo->info.message = D.26707;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26708 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26708;
      }
      <D.26706>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.26701>:
      klass = klass->element_class;
      D.26646 = klass->byval_arg.type;
      type = (int) D.26646;
      goto handle_enum;
      <D.20720>:
      mono_type = &klass->byval_arg;
      D.26709 = is_valid_cattr_type (mono_type);
      if (D.26709 == 0) goto <D.26710>; else goto <D.26711>;
      <D.26710>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26712>; else goto <D.26713>;
      <D.26712>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26696 = klass->name_space;
        D.26697 = klass->name;
        D.26714 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %s:%s ", D.26696, D.26697);
        vinfo->info.message = D.26714;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26715 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26715;
      }
      <D.26713>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.26711>:
      D.26716 = safe_read (&ptr, end, &element_count, 4);
      if (D.26716 == 0) goto <D.26717>; else goto <D.26718>;
      <D.26717>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26719>; else goto <D.26720>;
      <D.26719>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26696 = klass->name_space;
        D.26697 = klass->name;
        D.26721 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.26696, D.26697);
        vinfo->info.message = D.26721;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26722 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26722;
      }
      <D.26720>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.26718>:
      element_count.173 = element_count;
      if (element_count.173 == 4294967295) goto <D.26724>; else goto <D.26725>;
      <D.26724>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.26628 = 1;
      return D.26628;
      <D.26725>:
      i = 0;
      goto <D.20724>;
      <D.20723>:
      D.26726 = is_valid_fixed_param (ctx, mono_type, &ptr, end);
      if (D.26726 == 0) goto <D.26727>; else goto <D.26728>;
      <D.26727>:
      D.26628 = 0;
      return D.26628;
      <D.26728>:
      i = i + 1;
      <D.20724>:
      element_count.173 = element_count;
      if (i < element_count.173) goto <D.20723>; else goto <D.20725>;
      <D.20725>:
      ptr.167 = ptr;
      *_ptr = ptr.167;
      D.26628 = 1;
      return D.26628;
      <D.20726>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26729>; else goto <D.26730>;
      <D.26729>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26731 = monoeg_g_strdup_printf ("CustomAttribute: Invalid parameter type %x ", type);
        vinfo->info.message = D.26731;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26732 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26732;
      }
      <D.26730>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.20697>:
      ptr.167 = ptr;
      elem_size.174 = (sizetype) elem_size;
      D.26736 = ptr.167 + elem_size.174;
      if (D.26736 > end) goto <D.26733>; else goto <D.26737>;
      <D.26737>:
      elem_size.175 = (unsigned int) elem_size;
      D.26739 = ~elem_size.175;
      ptr.167 = ptr;
      ptr.176 = (unsigned int) ptr.167;
      if (D.26739 < ptr.176) goto <D.26733>; else goto <D.26734>;
      <D.26733>:
      D.26632 = ctx->report_error;
      if (D.26632 != 0) goto <D.26741>; else goto <D.26742>;
      <D.26741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26743 = monoeg_strdup ("CustomAttribute: Not enough space for element");
        vinfo->info.message = D.26743;
        vinfo->exception_type = 3;
        D.26636 = ctx->errors;
        D.26744 = monoeg_g_slist_prepend (D.26636, vinfo);
        ctx->errors = D.26744;
      }
      <D.26742>:
      ctx->valid = 0;
      D.26628 = 0;
      return D.26628;
      <D.26734>:
      ptr.167 = ptr;
      elem_size.174 = (sizetype) elem_size;
      D.26736 = ptr.167 + elem_size.174;
      *_ptr = D.26736;
      D.26628 = 1;
      return D.26628;
    }
  finally
    {
      ptr = {CLOBBER};
      element_count = {CLOBBER};
    }
}


is_valid_cattr_type (struct MonoType * type)
{
  unsigned char D.26751;
  _Bool D.26752;
  unsigned char D.26753;
  _Bool D.26754;
  _Bool D.26755;
  gboolean D.26758;
  unsigned char D.26759;
  int iftmp.177;
  unsigned char D.26766;
  unsigned char D.26767;
  struct MonoClass * D.26771;
  struct MonoClass * D.26772;
  _Bool D.26773;
  struct MonoClass * klass;

  D.26751 = type->type;
  D.26752 = D.26751 == 28;
  D.26753 = D.26751 + 254;
  D.26754 = D.26753 <= 12;
  D.26755 = D.26752 | D.26754;
  if (D.26755 != 0) goto <D.26756>; else goto <D.26757>;
  <D.26756>:
  D.26758 = 1;
  return D.26758;
  <D.26757>:
  D.26759 = type->type;
  if (D.26759 == 17) goto <D.26760>; else goto <D.26761>;
  <D.26760>:
  klass = mono_class_from_mono_type (type);
  if (klass != 0B) goto <D.26765>; else goto <D.26763>;
  <D.26765>:
  D.26766 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26767 = D.26766 & 16;
  if (D.26767 != 0) goto <D.26768>; else goto <D.26763>;
  <D.26768>:
  iftmp.177 = 1;
  goto <D.26764>;
  <D.26763>:
  iftmp.177 = 0;
  <D.26764>:
  D.26758 = iftmp.177;
  return D.26758;
  <D.26761>:
  D.26759 = type->type;
  if (D.26759 == 18) goto <D.26769>; else goto <D.26770>;
  <D.26769>:
  D.26771 = mono_class_from_mono_type (type);
  D.26772 = mono_defaults.systemtype_class;
  D.26773 = D.26771 == D.26772;
  D.26758 = (gboolean) D.26773;
  return D.26758;
  <D.26770>:
  D.26758 = 0;
  return D.26758;
}


verify_field_marshal_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26775;
  unsigned int D.26776;
  int D.26777;
  int D.26780;
  gchar * D.26783;
  struct GSList * D.26784;
  struct GSList * D.26785;
  <unnamed-unsigned:24> D.26786;
  int D.26787;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.26775 = ctx->image;
      table = &D.26775->tables[13];
      i = 0;
      goto <D.21230>;
      <D.21229>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.26776 = data[1];
      D.26777 = is_valid_marshal_spec (ctx, D.26776);
      if (D.26777 == 0) goto <D.26778>; else goto <D.26779>;
      <D.26778>:
      D.26780 = ctx->report_error;
      if (D.26780 != 0) goto <D.26781>; else goto <D.26782>;
      <D.26781>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26776 = data[1];
        D.26783 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, D.26776);
        vinfo->info.message = D.26783;
        vinfo->exception_type = 3;
        D.26784 = ctx->errors;
        D.26785 = monoeg_g_slist_prepend (D.26784, vinfo);
        ctx->errors = D.26785;
      }
      <D.26782>:
      ctx->valid = 0;
      return;
      <D.26779>:
      i = i + 1;
      <D.21230>:
      D.26786 = table->rows;
      D.26787 = (int) D.26786;
      if (D.26787 > i) goto <D.21229>; else goto <D.21231>;
      <D.21231>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_marshal_spec (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.26791;
  struct MonoStreamHeader * D.26792;
  gboolean D.26793;
  int iftmp.178;
  unsigned int D.26797;
  unsigned int D.26799;
  struct OffsetAndSize blob;

  try
    {
      D.26791 = ctx->image;
      D.26792 = &D.26791->heap_blob;
      blob = get_metadata_stream (ctx, D.26792); [return slot optimization]
      D.26797 = blob.size;
      if (D.26797 != 0) goto <D.26798>; else goto <D.26795>;
      <D.26798>:
      D.26797 = blob.size;
      D.26799 = D.26797 + 4294967295;
      if (D.26799 >= offset) goto <D.26800>; else goto <D.26795>;
      <D.26800>:
      iftmp.178 = 1;
      goto <D.26796>;
      <D.26795>:
      iftmp.178 = 0;
      <D.26796>:
      D.26793 = iftmp.178;
      return D.26793;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_decl_security_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26803;
  unsigned int D.26804;
  int D.26805;
  int D.26808;
  gchar * D.26811;
  struct GSList * D.26812;
  struct GSList * D.26813;
  <unnamed-unsigned:24> D.26814;
  int D.26815;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.26803 = ctx->image;
      table = &D.26803->tables[14];
      i = 0;
      goto <D.21252>;
      <D.21251>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.26804 = data[2];
      D.26805 = is_valid_permission_set (ctx, D.26804);
      if (D.26805 == 0) goto <D.26806>; else goto <D.26807>;
      <D.26806>:
      D.26808 = ctx->report_error;
      if (D.26808 != 0) goto <D.26809>; else goto <D.26810>;
      <D.26809>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26804 = data[2];
        D.26811 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, D.26804);
        vinfo->info.message = D.26811;
        vinfo->exception_type = 3;
        D.26812 = ctx->errors;
        D.26813 = monoeg_g_slist_prepend (D.26812, vinfo);
        ctx->errors = D.26813;
      }
      <D.26810>:
      ctx->valid = 0;
      return;
      <D.26807>:
      i = i + 1;
      <D.21252>:
      D.26814 = table->rows;
      D.26815 = (int) D.26814;
      if (D.26815 > i) goto <D.21251>; else goto <D.21253>;
      <D.21253>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_permission_set (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.26819;
  struct MonoStreamHeader * D.26820;
  gboolean D.26821;
  int iftmp.179;
  unsigned int D.26825;
  unsigned int D.26827;
  struct OffsetAndSize blob;

  try
    {
      D.26819 = ctx->image;
      D.26820 = &D.26819->heap_blob;
      blob = get_metadata_stream (ctx, D.26820); [return slot optimization]
      D.26825 = blob.size;
      if (D.26825 != 0) goto <D.26826>; else goto <D.26823>;
      <D.26826>:
      D.26825 = blob.size;
      D.26827 = D.26825 + 4294967295;
      if (D.26827 >= offset) goto <D.26828>; else goto <D.26823>;
      <D.26828>:
      iftmp.179 = 1;
      goto <D.26824>;
      <D.26823>:
      iftmp.179 = 0;
      <D.26824>:
      D.26821 = iftmp.179;
      return D.26821;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_standalonesig_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26831;
  unsigned int D.26832;
  int D.26833;
  int D.26836;
  gchar * D.26839;
  struct GSList * D.26840;
  struct GSList * D.26841;
  <unnamed-unsigned:24> D.26842;
  int D.26843;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.26831 = ctx->image;
      table = &D.26831->tables[17];
      i = 0;
      goto <D.21304>;
      <D.21303>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.26832 = data[0];
      D.26833 = is_valid_standalonesig_blob (ctx, D.26832);
      if (D.26833 == 0) goto <D.26834>; else goto <D.26835>;
      <D.26834>:
      D.26836 = ctx->report_error;
      if (D.26836 != 0) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26832 = data[0];
        D.26839 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d Signature field 0x%08x", i, D.26832);
        vinfo->info.message = D.26839;
        vinfo->exception_type = 3;
        D.26840 = ctx->errors;
        D.26841 = monoeg_g_slist_prepend (D.26840, vinfo);
        ctx->errors = D.26841;
      }
      <D.26838>:
      ctx->valid = 0;
      return;
      <D.26835>:
      i = i + 1;
      <D.21304>:
      D.26842 = table->rows;
      D.26843 = (int) D.26842;
      if (D.26843 > i) goto <D.21303>; else goto <D.21305>;
      <D.21305>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_standalonesig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.26847;
  int D.26850;
  gchar * D.26853;
  struct GSList * D.26854;
  struct GSList * D.26855;
  gboolean D.26856;
  const char * ptr.180;
  unsigned int size.181;
  int D.26859;
  gchar * D.26864;
  struct GSList * D.26865;
  const char * ptr.182;
  unsigned int signature.183;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.26847 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.26847 == 0) goto <D.26848>; else goto <D.26849>;
      <D.26848>:
      D.26850 = ctx->report_error;
      if (D.26850 != 0) goto <D.26851>; else goto <D.26852>;
      <D.26851>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26853 = monoeg_strdup ("StandAloneSig: Could not decode signature header");
        vinfo->info.message = D.26853;
        vinfo->exception_type = 3;
        D.26854 = ctx->errors;
        D.26855 = monoeg_g_slist_prepend (D.26854, vinfo);
        ctx->errors = D.26855;
      }
      <D.26852>:
      ctx->valid = 0;
      D.26856 = 0;
      return D.26856;
      <D.26849>:
      ptr.180 = ptr;
      size.181 = size;
      end = ptr.180 + size.181;
      D.26859 = safe_read (&ptr, end, &signature, 1);
      if (D.26859 == 0) goto <D.26860>; else goto <D.26861>;
      <D.26860>:
      D.26850 = ctx->report_error;
      if (D.26850 != 0) goto <D.26862>; else goto <D.26863>;
      <D.26862>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26864 = monoeg_strdup ("StandAloneSig: Not enough room for the call conv");
        vinfo->info.message = D.26864;
        vinfo->exception_type = 3;
        D.26854 = ctx->errors;
        D.26865 = monoeg_g_slist_prepend (D.26854, vinfo);
        ctx->errors = D.26865;
      }
      <D.26863>:
      ctx->valid = 0;
      D.26856 = 0;
      return D.26856;
      <D.26861>:
      ptr.180 = ptr;
      ptr.182 = ptr.180 + 4294967295;
      ptr = ptr.182;
      signature.183 = signature;
      if (signature.183 == 7) goto <D.26868>; else goto <D.26869>;
      <D.26868>:
      D.26856 = parse_locals_signature (ctx, &ptr, end);
      return D.26856;
      <D.26869>:
      signature.183 = signature;
      if (signature.183 == 6) goto <D.26870>; else goto <D.26871>;
      <D.26870>:
      D.26856 = parse_field (ctx, &ptr, end);
      return D.26856;
      <D.26871>:
      D.26856 = parse_method_signature (ctx, &ptr, end, 1, 1);
      return D.26856;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_locals_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.184;
  int D.26875;
  int D.26878;
  gchar * D.26881;
  struct GSList * D.26882;
  struct GSList * D.26883;
  gboolean D.26884;
  unsigned int sig.185;
  gchar * D.26890;
  struct GSList * D.26891;
  int D.26892;
  gchar * D.26897;
  struct GSList * D.26898;
  int D.26899;
  gchar * D.26904;
  struct GSList * D.26905;
  int D.26908;
  gchar * D.26913;
  struct GSList * D.26914;
  int D.26915;
  gchar * D.26920;
  struct GSList * D.26921;
  unsigned int sig.186;
  unsigned int D.26923;
  _Bool D.26924;
  _Bool D.26925;
  _Bool D.26926;
  int D.26929;
  gchar * D.26934;
  struct GSList * D.26935;
  gchar * D.26940;
  struct GSList * D.26941;
  const char * ptr.187;
  const char * ptr.188;
  int D.26946;
  gchar * D.26951;
  struct GSList * D.26952;
  unsigned int locals_count.189;
  unsigned int sig;
  unsigned int locals_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      locals_count = 0;
      ptr.184 = *_ptr;
      ptr = ptr.184;
      D.26875 = safe_read (&ptr, end, &sig, 1);
      if (D.26875 == 0) goto <D.26876>; else goto <D.26877>;
      <D.26876>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26879>; else goto <D.26880>;
      <D.26879>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26881 = monoeg_strdup ("LocalsSig: Not enough room for signature");
        vinfo->info.message = D.26881;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26883 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26883;
      }
      <D.26880>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26877>:
      sig.185 = sig;
      if (sig.185 != 7) goto <D.26886>; else goto <D.26887>;
      <D.26886>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26888>; else goto <D.26889>;
      <D.26888>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        sig.185 = sig;
        D.26890 = monoeg_g_strdup_printf ("LocalsSig: Signature is not 0x28 or 0x08: %x", sig.185);
        vinfo->info.message = D.26890;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26891 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26891;
      }
      <D.26889>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26887>:
      D.26892 = safe_read_compressed_int (&ptr, end, &locals_count);
      if (D.26892 == 0) goto <D.26893>; else goto <D.26894>;
      <D.26893>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26895>; else goto <D.26896>;
      <D.26895>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26897 = monoeg_strdup ("LocalsSig: Not enough room for the param count");
        vinfo->info.message = D.26897;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26898 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26898;
      }
      <D.26896>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26894>:
      i = 0;
      goto <D.20594>;
      <D.20593>:
      D.26899 = safe_read (&ptr, end, &sig, 1);
      if (D.26899 == 0) goto <D.26900>; else goto <D.26901>;
      <D.26900>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26902>; else goto <D.26903>;
      <D.26902>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26904 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.26904;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26905 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26905;
      }
      <D.26903>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26901>:
      goto <D.20587>;
      <D.20586>:
      sig.185 = sig;
      if (sig.185 != 69) goto <D.26906>; else goto <D.26907>;
      <D.26906>:
      D.26908 = parse_custom_mods (ctx, &ptr, end);
      if (D.26908 == 0) goto <D.26909>; else goto <D.26910>;
      <D.26909>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26911>; else goto <D.26912>;
      <D.26911>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26913 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.26913;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26914 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26914;
      }
      <D.26912>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26910>:
      <D.26907>:
      D.26915 = safe_read (&ptr, end, &sig, 1);
      if (D.26915 == 0) goto <D.26916>; else goto <D.26917>;
      <D.26916>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26918>; else goto <D.26919>;
      <D.26918>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26920 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.26920;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26921 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26921;
      }
      <D.26919>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26917>:
      <D.20587>:
      sig.186 = sig;
      D.26923 = sig.186 + 4294967265;
      D.26924 = D.26923 <= 1;
      D.26925 = sig.186 == 69;
      D.26926 = D.26924 | D.26925;
      if (D.26926 != 0) goto <D.20586>; else goto <D.20588>;
      <D.20588>:
      sig.185 = sig;
      if (sig.185 == 16) goto <D.26927>; else goto <D.26928>;
      <D.26927>:
      D.26929 = safe_read (&ptr, end, &sig, 1);
      if (D.26929 == 0) goto <D.26930>; else goto <D.26931>;
      <D.26930>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26932>; else goto <D.26933>;
      <D.26932>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26934 = monoeg_g_strdup_printf ("Type: Not enough room for byref type for local %d", i);
        vinfo->info.message = D.26934;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26935 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26935;
      }
      <D.26933>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26931>:
      sig.185 = sig;
      if (sig.185 == 22) goto <D.26936>; else goto <D.26937>;
      <D.26936>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26938>; else goto <D.26939>;
      <D.26938>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26940 = monoeg_g_strdup_printf ("Type: Invalid type typedref& for local %d", i);
        vinfo->info.message = D.26940;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26941 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26941;
      }
      <D.26939>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26937>:
      <D.26928>:
      sig.185 = sig;
      if (sig.185 == 22) goto <D.26942>; else goto <D.26943>;
      <D.26942>:
      // predicted unlikely by continue predictor.
      goto <D.20591>;
      <D.26943>:
      ptr.187 = ptr;
      ptr.188 = ptr.187 + 4294967295;
      ptr = ptr.188;
      D.26946 = parse_type (ctx, &ptr, end);
      if (D.26946 == 0) goto <D.26947>; else goto <D.26948>;
      <D.26947>:
      D.26878 = ctx->report_error;
      if (D.26878 != 0) goto <D.26949>; else goto <D.26950>;
      <D.26949>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26951 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.26951;
        vinfo->exception_type = 3;
        D.26882 = ctx->errors;
        D.26952 = monoeg_g_slist_prepend (D.26882, vinfo);
        ctx->errors = D.26952;
      }
      <D.26950>:
      ctx->valid = 0;
      D.26884 = 0;
      return D.26884;
      <D.26948>:
      <D.20591>:
      i = i + 1;
      <D.20594>:
      locals_count.189 = locals_count;
      if (i < locals_count.189) goto <D.20593>; else goto <D.20595>;
      <D.20595>:
      ptr.187 = ptr;
      *_ptr = ptr.187;
      D.26884 = 1;
      return D.26884;
    }
  finally
    {
      sig = {CLOBBER};
      locals_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_event_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.26956;
  unsigned int i.190;
  int D.26960;
  gchar * D.26963;
  struct GSList * D.26964;
  struct GSList * D.26965;
  int D.26966;
  unsigned int D.26967;
  unsigned int D.26969;
  unsigned int D.26971;
  unsigned int D.26972;
  unsigned int D.26975;
  _Bool D.26978;
  _Bool D.26979;
  _Bool D.26980;
  <unnamed-unsigned:24> D.26982;
  int D.26983;
  gchar * D.26988;
  struct GSList * D.26989;
  gchar * D.26994;
  struct GSList * D.26995;
  <unnamed-unsigned:24> D.26996;
  int D.26997;
  struct MonoTableInfo * table;
  struct MonoTableInfo * sema_table;
  guint32 data[3];
  guint32 sema_data[3];
  guint32 token;
  gboolean found_add;
  gboolean found_remove;
  int i;
  int idx;

  try
    {
      D.26956 = ctx->image;
      table = &D.26956->tables[20];
      D.26956 = ctx->image;
      sema_table = &D.26956->tables[24];
      i = 0;
      goto <D.21352>;
      <D.21351>:
      mono_metadata_decode_row (table, i, &data, 3);
      i.190 = (unsigned int) i;
      token = make_coded_token (48, 20, i.190);
      idx = search_sorted_table (ctx, 24, 2, token);
      if (idx == -1) goto <D.26958>; else goto <D.26959>;
      <D.26958>:
      D.26960 = ctx->report_error;
      if (D.26960 != 0) goto <D.26961>; else goto <D.26962>;
      <D.26961>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26963 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn or RemoveOn associated methods", i);
        vinfo->info.message = D.26963;
        vinfo->exception_type = 3;
        D.26964 = ctx->errors;
        D.26965 = monoeg_g_slist_prepend (D.26964, vinfo);
        ctx->errors = D.26965;
      }
      <D.26962>:
      ctx->valid = 0;
      return;
      <D.26959>:
      goto <D.21345>;
      <D.21344>:
      D.26966 = idx + -1;
      D.26967 = mono_metadata_decode_row_col (sema_table, D.26966, 2);
      if (D.26967 != token) goto <D.21343>; else goto <D.26968>;
      <D.26968>:
      idx = idx + -1;
      <D.21345>:
      if (idx > 0) goto <D.21344>; else goto <D.21343>;
      <D.21343>:
      found_remove = 0;
      found_add = found_remove;
      goto <D.21348>;
      <D.21347>:
      mono_metadata_decode_row (sema_table, idx, &sema_data, 3);
      D.26969 = sema_data[2];
      if (D.26969 != token) goto <D.21346>; else goto <D.26970>;
      <D.26970>:
      D.26971 = sema_data[0];
      D.26972 = D.26971 & 8;
      if (D.26972 != 0) goto <D.26973>; else goto <D.26974>;
      <D.26973>:
      found_add = 1;
      <D.26974>:
      D.26971 = sema_data[0];
      D.26975 = D.26971 & 16;
      if (D.26975 != 0) goto <D.26976>; else goto <D.26977>;
      <D.26976>:
      found_remove = 1;
      <D.26977>:
      D.26978 = found_add != 0;
      D.26979 = found_remove != 0;
      D.26980 = D.26978 & D.26979;
      if (D.26980 != 0) goto <D.21346>; else goto <D.26981>;
      <D.26981>:
      idx = idx + 1;
      <D.21348>:
      D.26982 = sema_table->rows;
      D.26983 = (int) D.26982;
      if (D.26983 > idx) goto <D.21347>; else goto <D.21346>;
      <D.21346>:
      if (found_add == 0) goto <D.26984>; else goto <D.26985>;
      <D.26984>:
      D.26960 = ctx->report_error;
      if (D.26960 != 0) goto <D.26986>; else goto <D.26987>;
      <D.26986>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26988 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn associated method", i);
        vinfo->info.message = D.26988;
        vinfo->exception_type = 3;
        D.26964 = ctx->errors;
        D.26989 = monoeg_g_slist_prepend (D.26964, vinfo);
        ctx->errors = D.26989;
      }
      <D.26987>:
      ctx->valid = 0;
      return;
      <D.26985>:
      if (found_remove == 0) goto <D.26990>; else goto <D.26991>;
      <D.26990>:
      D.26960 = ctx->report_error;
      if (D.26960 != 0) goto <D.26992>; else goto <D.26993>;
      <D.26992>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.26994 = monoeg_g_strdup_printf ("Invalid Event row %d has no RemoveOn associated method", i);
        vinfo->info.message = D.26994;
        vinfo->exception_type = 3;
        D.26964 = ctx->errors;
        D.26995 = monoeg_g_slist_prepend (D.26964, vinfo);
        ctx->errors = D.26995;
      }
      <D.26993>:
      ctx->valid = 0;
      return;
      <D.26991>:
      i = i + 1;
      <D.21352>:
      D.26996 = table->rows;
      D.26997 = (int) D.26996;
      if (D.26997 > i) goto <D.21351>; else goto <D.21353>;
      <D.21353>:
    }
  finally
    {
      data = {CLOBBER};
      sema_data = {CLOBBER};
    }
}


verify_typespec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.27001;
  int D.27002;
  int D.27003;
  unsigned int D.27004;
  unsigned int D.27005;
  int D.27006;
  int D.27009;
  gchar * D.27012;
  struct GSList * D.27013;
  struct GSList * D.27014;
  <unnamed-unsigned:24> D.27015;
  int D.27016;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.27001 = ctx->image;
      table = &D.27001->tables[27];
      i = 0;
      goto <D.21421>;
      <D.21420>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.27002 = i + 1;
      D.27003 = D.27002 | 452984832;
      D.27004 = (unsigned int) D.27003;
      ctx->token = D.27004;
      D.27005 = data[0];
      D.27006 = is_valid_typespec_blob (ctx, D.27005);
      if (D.27006 == 0) goto <D.27007>; else goto <D.27008>;
      <D.27007>:
      D.27009 = ctx->report_error;
      if (D.27009 != 0) goto <D.27010>; else goto <D.27011>;
      <D.27010>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27005 = data[0];
        D.27012 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.27005);
        vinfo->info.message = D.27012;
        vinfo->exception_type = 3;
        D.27013 = ctx->errors;
        D.27014 = monoeg_g_slist_prepend (D.27013, vinfo);
        ctx->errors = D.27014;
      }
      <D.27011>:
      ctx->valid = 0;
      return;
      <D.27008>:
      i = i + 1;
      <D.21421>:
      D.27015 = table->rows;
      D.27016 = (int) D.27015;
      if (D.27016 > i) goto <D.21420>; else goto <D.21422>;
      <D.21422>:
      ctx->token = 0;
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_typespec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.27020;
  int D.27023;
  gchar * D.27026;
  struct GSList * D.27027;
  struct GSList * D.27028;
  gboolean D.27029;
  const char * ptr.191;
  unsigned int size.192;
  int D.27032;
  int D.27035;
  gchar * D.27040;
  struct GSList * D.27041;
  unsigned int type.193;
  int D.27045;
  gchar * D.27050;
  struct GSList * D.27051;
  gchar * D.27056;
  struct GSList * D.27057;
  const char * ptr.194;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      D.27020 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.27020 == 0) goto <D.27021>; else goto <D.27022>;
      <D.27021>:
      D.27023 = ctx->report_error;
      if (D.27023 != 0) goto <D.27024>; else goto <D.27025>;
      <D.27024>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27026 = monoeg_strdup ("TypeSpec: Could not decode signature header");
        vinfo->info.message = D.27026;
        vinfo->exception_type = 3;
        D.27027 = ctx->errors;
        D.27028 = monoeg_g_slist_prepend (D.27027, vinfo);
        ctx->errors = D.27028;
      }
      <D.27025>:
      ctx->valid = 0;
      D.27029 = 0;
      return D.27029;
      <D.27022>:
      ptr.191 = ptr;
      size.192 = size;
      end = ptr.191 + size.192;
      D.27032 = parse_custom_mods (ctx, &ptr, end);
      if (D.27032 == 0) goto <D.27033>; else goto <D.27034>;
      <D.27033>:
      D.27029 = 0;
      return D.27029;
      <D.27034>:
      D.27035 = safe_read (&ptr, end, &type, 1);
      if (D.27035 == 0) goto <D.27036>; else goto <D.27037>;
      <D.27036>:
      D.27023 = ctx->report_error;
      if (D.27023 != 0) goto <D.27038>; else goto <D.27039>;
      <D.27038>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27040 = monoeg_strdup ("TypeSpec: Not enough room for type");
        vinfo->info.message = D.27040;
        vinfo->exception_type = 3;
        D.27027 = ctx->errors;
        D.27041 = monoeg_g_slist_prepend (D.27027, vinfo);
        ctx->errors = D.27041;
      }
      <D.27039>:
      ctx->valid = 0;
      D.27029 = 0;
      return D.27029;
      <D.27037>:
      type.193 = type;
      if (type.193 == 16) goto <D.27043>; else goto <D.27044>;
      <D.27043>:
      D.27045 = safe_read (&ptr, end, &type, 1);
      if (D.27045 == 0) goto <D.27046>; else goto <D.27047>;
      <D.27046>:
      D.27023 = ctx->report_error;
      if (D.27023 != 0) goto <D.27048>; else goto <D.27049>;
      <D.27048>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27050 = monoeg_strdup ("TypeSpec: Not enough room for byref type");
        vinfo->info.message = D.27050;
        vinfo->exception_type = 3;
        D.27027 = ctx->errors;
        D.27051 = monoeg_g_slist_prepend (D.27027, vinfo);
        ctx->errors = D.27051;
      }
      <D.27049>:
      ctx->valid = 0;
      D.27029 = 0;
      return D.27029;
      <D.27047>:
      type.193 = type;
      if (type.193 == 22) goto <D.27052>; else goto <D.27053>;
      <D.27052>:
      D.27023 = ctx->report_error;
      if (D.27023 != 0) goto <D.27054>; else goto <D.27055>;
      <D.27054>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27056 = monoeg_strdup ("TypeSpec: Invalid type typedref&");
        vinfo->info.message = D.27056;
        vinfo->exception_type = 3;
        D.27027 = ctx->errors;
        D.27057 = monoeg_g_slist_prepend (D.27027, vinfo);
        ctx->errors = D.27057;
      }
      <D.27055>:
      ctx->valid = 0;
      D.27029 = 0;
      return D.27029;
      <D.27053>:
      <D.27044>:
      type.193 = type;
      if (type.193 == 22) goto <D.27058>; else goto <D.27059>;
      <D.27058>:
      D.27029 = 1;
      return D.27029;
      <D.27059>:
      ptr.191 = ptr;
      ptr.194 = ptr.191 + 4294967295;
      ptr = ptr.194;
      D.27029 = parse_type (ctx, &ptr, end);
      return D.27029;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_method_spec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.27063;
  unsigned int D.27064;
  int D.27065;
  int D.27068;
  gchar * D.27071;
  struct GSList * D.27072;
  struct GSList * D.27073;
  <unnamed-unsigned:24> D.27074;
  int D.27075;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.27063 = ctx->image;
      table = &D.27063->tables[43];
      i = 0;
      goto <D.21579>;
      <D.21578>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.27064 = data[1];
      D.27065 = is_valid_methodspec_blob (ctx, D.27064);
      if (D.27065 == 0) goto <D.27066>; else goto <D.27067>;
      <D.27066>:
      D.27068 = ctx->report_error;
      if (D.27068 != 0) goto <D.27069>; else goto <D.27070>;
      <D.27069>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27064 = data[1];
        D.27071 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, D.27064);
        vinfo->info.message = D.27071;
        vinfo->exception_type = 3;
        D.27072 = ctx->errors;
        D.27073 = monoeg_g_slist_prepend (D.27072, vinfo);
        ctx->errors = D.27073;
      }
      <D.27070>:
      ctx->valid = 0;
      return;
      <D.27067>:
      i = i + 1;
      <D.21579>:
      D.27074 = table->rows;
      D.27075 = (int) D.27074;
      if (D.27075 > i) goto <D.21578>; else goto <D.21580>;
      <D.21580>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_methodspec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.27079;
  int D.27082;
  gchar * D.27085;
  struct GSList * D.27086;
  struct GSList * D.27087;
  gboolean D.27088;
  const char * ptr.195;
  unsigned int size.196;
  int D.27091;
  gchar * D.27096;
  struct GSList * D.27097;
  unsigned int type.197;
  gchar * D.27103;
  struct GSList * D.27104;
  int D.27105;
  gchar * D.27110;
  struct GSList * D.27111;
  unsigned int count.198;
  gchar * D.27117;
  struct GSList * D.27118;
  int D.27119;
  int D.27122;
  unsigned int D.27127;
  gchar * D.27128;
  struct GSList * D.27129;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;
  unsigned int count;
  unsigned int i;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      count = 0;
      D.27079 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.27079 == 0) goto <D.27080>; else goto <D.27081>;
      <D.27080>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27083>; else goto <D.27084>;
      <D.27083>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27085 = monoeg_strdup ("MethodSpec: Could not decode signature header");
        vinfo->info.message = D.27085;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27087 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27087;
      }
      <D.27084>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27081>:
      ptr.195 = ptr;
      size.196 = size;
      end = ptr.195 + size.196;
      D.27091 = safe_read (&ptr, end, &type, 1);
      if (D.27091 == 0) goto <D.27092>; else goto <D.27093>;
      <D.27092>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27094>; else goto <D.27095>;
      <D.27094>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27096 = monoeg_strdup ("MethodSpec: Not enough room for call convention");
        vinfo->info.message = D.27096;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27097 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27097;
      }
      <D.27095>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27093>:
      type.197 = type;
      if (type.197 != 10) goto <D.27099>; else goto <D.27100>;
      <D.27099>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27101>; else goto <D.27102>;
      <D.27101>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        type.197 = type;
        D.27103 = monoeg_g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type.197);
        vinfo->info.message = D.27103;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27104 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27104;
      }
      <D.27102>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27100>:
      D.27105 = safe_read_compressed_int (&ptr, end, &count);
      if (D.27105 == 0) goto <D.27106>; else goto <D.27107>;
      <D.27106>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27108>; else goto <D.27109>;
      <D.27108>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27110 = monoeg_strdup ("MethodSpec: Not enough room for parameter count");
        vinfo->info.message = D.27110;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27111 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27111;
      }
      <D.27109>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27107>:
      count.198 = count;
      if (count.198 == 0) goto <D.27113>; else goto <D.27114>;
      <D.27113>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27115>; else goto <D.27116>;
      <D.27115>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27117 = monoeg_strdup ("MethodSpec: Zero generic argument count");
        vinfo->info.message = D.27117;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27118 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27118;
      }
      <D.27116>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27114>:
      i = 0;
      goto <D.20824>;
      <D.20823>:
      D.27119 = parse_custom_mods (ctx, &ptr, end);
      if (D.27119 == 0) goto <D.27120>; else goto <D.27121>;
      <D.27120>:
      D.27088 = 0;
      return D.27088;
      <D.27121>:
      D.27122 = parse_type (ctx, &ptr, end);
      if (D.27122 == 0) goto <D.27123>; else goto <D.27124>;
      <D.27123>:
      D.27082 = ctx->report_error;
      if (D.27082 != 0) goto <D.27125>; else goto <D.27126>;
      <D.27125>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27127 = i + 1;
        D.27128 = monoeg_g_strdup_printf ("MethodSpec: Could not parse parameter %d", D.27127);
        vinfo->info.message = D.27128;
        vinfo->exception_type = 3;
        D.27086 = ctx->errors;
        D.27129 = monoeg_g_slist_prepend (D.27086, vinfo);
        ctx->errors = D.27129;
      }
      <D.27126>:
      ctx->valid = 0;
      D.27088 = 0;
      return D.27088;
      <D.27124>:
      i = i + 1;
      <D.20824>:
      count.198 = count;
      if (i < count.198) goto <D.20823>; else goto <D.20825>;
      <D.20825>:
      D.27088 = 1;
      return D.27088;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
      count = {CLOBBER};
    }
}


verify_tables_data_global_constraints_full (struct VerifyContext * ctx)
{
  verify_typeref_table (ctx);
  verify_typeref_table_global_constraints (ctx);
}


verify_typeref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.27132;
  <unnamed-unsigned:24> D.27133;
  unsigned int D.27134;
  struct MonoTableInfo * table;
  struct MonoError error;
  guint32 i;

  try
    {
      D.27132 = ctx->image;
      table = &D.27132->tables[1];
      i = 0;
      goto <D.20933>;
      <D.20932>:
      D.27132 = ctx->image;
      mono_verifier_verify_typeref_row (D.27132, i, &error);
      add_from_mono_error (ctx, &error);
      i = i + 1;
      <D.20933>:
      D.27133 = table->rows;
      D.27134 = (unsigned int) D.27133;
      if (D.27134 > i) goto <D.20932>; else goto <D.20934>;
      <D.20934>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


add_from_mono_error (struct VerifyContext * ctx, struct MonoError * error)
{
  int D.27135;
  int D.27138;
  const char * D.27141;
  gchar * D.27142;
  struct GSList * D.27143;
  struct GSList * D.27144;

  D.27135 = mono_error_ok (error);
  if (D.27135 != 0) goto <D.27136>; else goto <D.27137>;
  <D.27136>:
  return;
  <D.27137>:
  D.27138 = ctx->report_error;
  if (D.27138 != 0) goto <D.27139>; else goto <D.27140>;
  <D.27139>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (12);
    vinfo->info.status = 1;
    D.27141 = mono_error_get_message (error);
    D.27142 = monoeg_strdup (D.27141);
    vinfo->info.message = D.27142;
    vinfo->exception_type = 3;
    D.27143 = ctx->errors;
    D.27144 = monoeg_g_slist_prepend (D.27143, vinfo);
    ctx->errors = D.27144;
  }
  <D.27140>:
  ctx->valid = 0;
  return;
  mono_error_cleanup (error);
}


verify_typeref_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.27146;
  unsigned int D.27147;
  unsigned int D.27148;
  const char * D.27149;
  unsigned int D.27150;
  const char * D.27151;
  void * D.27152;
  int D.27155;
  const char * D.27158;
  const char * D.27159;
  unsigned int D.27160;
  gchar * D.27161;
  struct GSList * D.27162;
  struct GSList * D.27163;
  <unnamed-unsigned:24> D.27164;
  int D.27165;
  int i;
  guint32 data[3];
  struct MonoTableInfo * table;
  struct GHashTable * unique_types;

  try
    {
      D.27146 = ctx->image;
      table = &D.27146->tables[1];
      unique_types = monoeg_g_hash_table_new_full (typedef_hash, typedef_equals, monoeg_g_free, 0B);
      i = 0;
      goto <D.21656>;
      <D.21655>:
      {
        struct TypeDefUniqueId * type;

        type = monoeg_malloc (12);
        mono_metadata_decode_row (table, i, &data, 3);
        D.27147 = data[0];
        type->resolution_scope = D.27147;
        D.27146 = ctx->image;
        D.27148 = data[1];
        D.27149 = mono_metadata_string_heap (D.27146, D.27148);
        type->name = D.27149;
        D.27146 = ctx->image;
        D.27150 = data[2];
        D.27151 = mono_metadata_string_heap (D.27146, D.27150);
        type->name_space = D.27151;
        D.27152 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.27152 != 0B) goto <D.27153>; else goto <D.27154>;
        <D.27153>:
        D.27155 = ctx->report_error;
        if (D.27155 != 0) goto <D.27156>; else goto <D.27157>;
        <D.27156>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (12);
          vinfo->info.status = 1;
          D.27158 = type->name;
          D.27159 = type->name_space;
          D.27160 = type->resolution_scope;
          D.27161 = monoeg_g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, D.27158, D.27159, D.27160);
          vinfo->info.message = D.27161;
          vinfo->exception_type = 3;
          D.27162 = ctx->errors;
          D.27163 = monoeg_g_slist_prepend (D.27162, vinfo);
          ctx->errors = D.27163;
        }
        <D.27157>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.27154>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.21656>:
      D.27164 = table->rows;
      D.27165 = (int) D.27164;
      if (D.27165 > i) goto <D.21655>; else goto <D.21657>;
      <D.21657>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27169;
  gboolean D.27172;
  _Bool D.27173;
  int D.27174;
  struct VerifyContext ctx;

  try
    {
      D.27169 = mono_verifier_is_enabled_for_image (image);
      if (D.27169 == 0) goto <D.27170>; else goto <D.27171>;
      <D.27170>:
      D.27172 = 1;
      return D.27172;
      <D.27171>:
      D.27173 = error_list != 0B;
      D.27174 = (int) D.27173;
      init_verify_context (&ctx, image, D.27174);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.27172 = cleanup_context (&ctx, error_list);
      return D.27172;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_method_header (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27177;
  gboolean D.27180;
  _Bool D.27181;
  int D.27182;
  unsigned int locals_token.199;
  struct MonoTableInfo * D.27186;
  unsigned int D.27187;
  int D.27188;
  struct VerifyContext ctx;
  guint32 locals_token;

  try
    {
      D.27177 = mono_verifier_is_enabled_for_image (image);
      if (D.27177 == 0) goto <D.27178>; else goto <D.27179>;
      <D.27178>:
      D.27180 = 1;
      return D.27180;
      <D.27179>:
      D.27181 = error_list != 0B;
      D.27182 = (int) D.27181;
      init_verify_context (&ctx, image, D.27182);
      ctx.stage = 2;
      is_valid_method_header (&ctx, offset, &locals_token);
      locals_token.199 = locals_token;
      if (locals_token.199 != 0) goto <D.27184>; else goto <D.27185>;
      <D.27184>:
      {
        guint32 sig_offset;

        D.27186 = &image->tables[17];
        locals_token.199 = locals_token;
        D.27187 = locals_token.199 + 4294967295;
        D.27188 = (int) D.27187;
        sig_offset = mono_metadata_decode_row_col (D.27186, D.27188, 0);
        is_valid_standalonesig_blob (&ctx, sig_offset);
      }
      <D.27185>:
      D.27180 = cleanup_context (&ctx, error_list);
      return D.27180;
    }
  finally
    {
      ctx = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


mono_verifier_verify_method_signature (struct MonoImage * image, guint32 offset, struct MonoError * error)
{
  int D.27191;
  gboolean D.27194;
  struct VerifyContext ctx;

  try
    {
      mono_error_init (error);
      D.27191 = mono_verifier_is_enabled_for_image (image);
      if (D.27191 == 0) goto <D.27192>; else goto <D.27193>;
      <D.27192>:
      D.27194 = 1;
      return D.27194;
      <D.27193>:
      init_verify_context (&ctx, image, 1);
      ctx.stage = 2;
      is_valid_method_signature (&ctx, offset);
      D.27194 = cleanup_context_checked (&ctx, error);
      return D.27194;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


cleanup_context_checked (struct VerifyContext * ctx, struct MonoError * error)
{
  struct SectionHeader * D.27197;
  struct GSList * D.27198;
  struct MonoImage * D.27201;
  char * D.27202;
  gboolean D.27203;

  D.27197 = ctx->sections;
  monoeg_g_free (D.27197);
  D.27198 = ctx->errors;
  if (D.27198 != 0B) goto <D.27199>; else goto <D.27200>;
  <D.27199>:
  {
    struct MonoVerifyInfo * info;

    D.27198 = ctx->errors;
    info = D.27198->data;
    D.27201 = ctx->image;
    D.27202 = info->message;
    mono_error_set_bad_image (error, D.27201, "%s", D.27202);
    D.27198 = ctx->errors;
    mono_free_verify_list (D.27198);
  }
  <D.27200>:
  D.27203 = ctx->valid;
  return D.27203;
}


mono_verifier_verify_memberref_method_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27205;
  gboolean D.27208;
  _Bool D.27209;
  int D.27210;
  struct VerifyContext ctx;

  try
    {
      D.27205 = mono_verifier_is_enabled_for_image (image);
      if (D.27205 == 0) goto <D.27206>; else goto <D.27207>;
      <D.27206>:
      D.27208 = 1;
      return D.27208;
      <D.27207>:
      D.27209 = error_list != 0B;
      D.27210 = (int) D.27209;
      init_verify_context (&ctx, image, D.27210);
      ctx.stage = 2;
      is_valid_memberref_method_signature (&ctx, offset);
      D.27208 = cleanup_context (&ctx, error_list);
      return D.27208;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


is_valid_memberref_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.27213;
  int D.27216;
  gchar * D.27219;
  struct GSList * D.27220;
  struct GSList * D.27221;
  gboolean D.27222;
  const char * ptr.200;
  unsigned int size.201;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.27213 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.27213 == 0) goto <D.27214>; else goto <D.27215>;
      <D.27214>:
      D.27216 = ctx->report_error;
      if (D.27216 != 0) goto <D.27217>; else goto <D.27218>;
      <D.27217>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27219 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.27219;
        vinfo->exception_type = 3;
        D.27220 = ctx->errors;
        D.27221 = monoeg_g_slist_prepend (D.27220, vinfo);
        ctx->errors = D.27221;
      }
      <D.27218>:
      ctx->valid = 0;
      D.27222 = 0;
      return D.27222;
      <D.27215>:
      ptr.200 = ptr;
      size.201 = size;
      end = ptr.200 + size.201;
      D.27222 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.27222;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_verifier_verify_memberref_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27227;
  gboolean D.27230;
  _Bool D.27231;
  int D.27232;
  struct VerifyContext ctx;

  try
    {
      D.27227 = mono_verifier_is_enabled_for_image (image);
      if (D.27227 == 0) goto <D.27228>; else goto <D.27229>;
      <D.27228>:
      D.27230 = 1;
      return D.27230;
      <D.27229>:
      D.27231 = error_list != 0B;
      D.27232 = (int) D.27231;
      init_verify_context (&ctx, image, D.27232);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.27230 = cleanup_context (&ctx, error_list);
      return D.27230;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_standalone_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27235;
  gboolean D.27238;
  _Bool D.27239;
  int D.27240;
  struct VerifyContext ctx;

  try
    {
      D.27235 = mono_verifier_is_enabled_for_image (image);
      if (D.27235 == 0) goto <D.27236>; else goto <D.27237>;
      <D.27236>:
      D.27238 = 1;
      return D.27238;
      <D.27237>:
      D.27239 = error_list != 0B;
      D.27240 = (int) D.27239;
      init_verify_context (&ctx, image, D.27240);
      ctx.stage = 2;
      is_valid_standalonesig_blob (&ctx, offset);
      D.27238 = cleanup_context (&ctx, error_list);
      return D.27238;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_typespec_signature (struct MonoImage * image, guint32 offset, guint32 token, struct GSList * * error_list)
{
  int D.27243;
  gboolean D.27246;
  _Bool D.27247;
  int D.27248;
  struct VerifyContext ctx;

  try
    {
      D.27243 = mono_verifier_is_enabled_for_image (image);
      if (D.27243 == 0) goto <D.27244>; else goto <D.27245>;
      <D.27244>:
      D.27246 = 1;
      return D.27246;
      <D.27245>:
      D.27247 = error_list != 0B;
      D.27248 = (int) D.27247;
      init_verify_context (&ctx, image, D.27248);
      ctx.stage = 2;
      ctx.token = token;
      is_valid_typespec_blob (&ctx, offset);
      D.27246 = cleanup_context (&ctx, error_list);
      return D.27246;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_methodspec_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27251;
  gboolean D.27254;
  _Bool D.27255;
  int D.27256;
  struct VerifyContext ctx;

  try
    {
      D.27251 = mono_verifier_is_enabled_for_image (image);
      if (D.27251 == 0) goto <D.27252>; else goto <D.27253>;
      <D.27252>:
      D.27254 = 1;
      return D.27254;
      <D.27253>:
      D.27255 = error_list != 0B;
      D.27256 = (int) D.27255;
      init_verify_context (&ctx, image, D.27256);
      ctx.stage = 2;
      is_valid_methodspec_blob (&ctx, offset);
      D.27254 = cleanup_context (&ctx, error_list);
      return D.27254;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_string_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27259;
  gboolean D.27262;
  _Bool D.27263;
  int D.27264;
  struct VerifyContext ctx;

  try
    {
      D.27259 = mono_verifier_is_enabled_for_image (image);
      if (D.27259 == 0) goto <D.27260>; else goto <D.27261>;
      <D.27260>:
      D.27262 = 1;
      return D.27262;
      <D.27261>:
      D.27263 = error_list != 0B;
      D.27264 = (int) D.27263;
      init_verify_context (&ctx, image, D.27264);
      ctx.stage = 2;
      verify_user_string (&ctx, offset);
      D.27262 = cleanup_context (&ctx, error_list);
      return D.27262;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_user_string (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.27267;
  struct MonoStreamHeader * D.27268;
  unsigned int D.27269;
  int D.27272;
  gchar * D.27275;
  struct GSList * D.27276;
  struct GSList * D.27277;
  const char * D.27278;
  unsigned int D.27279;
  sizetype D.27280;
  const char * D.27281;
  unsigned int D.27282;
  int D.27283;
  gchar * D.27288;
  struct GSList * D.27289;
  unsigned int bytes.202;
  unsigned int D.27291;
  unsigned int entry_size.203;
  gchar * D.27297;
  struct GSList * D.27298;
  unsigned int entry_size.204;
  unsigned int D.27302;
  unsigned int D.27304;
  gchar * D.27307;
  struct GSList * D.27308;
  struct OffsetAndSize heap_us;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.27267 = ctx->image;
      D.27268 = &D.27267->heap_us;
      heap_us = get_metadata_stream (ctx, D.27268); [return slot optimization]
      D.27269 = heap_us.size;
      if (D.27269 < offset) goto <D.27270>; else goto <D.27271>;
      <D.27270>:
      D.27272 = ctx->report_error;
      if (D.27272 != 0) goto <D.27273>; else goto <D.27274>;
      <D.27273>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27275 = monoeg_strdup ("User string offset beyond heap_us size");
        vinfo->info.message = D.27275;
        vinfo->exception_type = 3;
        D.27276 = ctx->errors;
        D.27277 = monoeg_g_slist_prepend (D.27276, vinfo);
        ctx->errors = D.27277;
      }
      <D.27274>:
      ctx->valid = 0;
      return;
      <D.27271>:
      D.27278 = ctx->data;
      D.27279 = heap_us.offset;
      D.27280 = D.27279 + offset;
      D.27281 = D.27278 + D.27280;
      D.27269 = heap_us.size;
      D.27279 = heap_us.offset;
      D.27282 = D.27269 - D.27279;
      D.27283 = decode_value (D.27281, D.27282, &entry_size, &bytes);
      if (D.27283 == 0) goto <D.27284>; else goto <D.27285>;
      <D.27284>:
      D.27272 = ctx->report_error;
      if (D.27272 != 0) goto <D.27286>; else goto <D.27287>;
      <D.27286>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27288 = monoeg_strdup ("Could not decode user string blob size");
        vinfo->info.message = D.27288;
        vinfo->exception_type = 3;
        D.27276 = ctx->errors;
        D.27289 = monoeg_g_slist_prepend (D.27276, vinfo);
        ctx->errors = D.27289;
      }
      <D.27287>:
      ctx->valid = 0;
      return;
      <D.27285>:
      bytes.202 = bytes;
      D.27291 = ~bytes.202;
      entry_size.203 = entry_size;
      if (D.27291 < entry_size.203) goto <D.27293>; else goto <D.27294>;
      <D.27293>:
      D.27272 = ctx->report_error;
      if (D.27272 != 0) goto <D.27295>; else goto <D.27296>;
      <D.27295>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27297 = monoeg_strdup ("User string size overflow");
        vinfo->info.message = D.27297;
        vinfo->exception_type = 3;
        D.27276 = ctx->errors;
        D.27298 = monoeg_g_slist_prepend (D.27276, vinfo);
        ctx->errors = D.27298;
      }
      <D.27296>:
      ctx->valid = 0;
      return;
      <D.27294>:
      entry_size.203 = entry_size;
      bytes.202 = bytes;
      entry_size.204 = entry_size.203 + bytes.202;
      entry_size = entry_size.204;
      entry_size.203 = entry_size;
      D.27302 = offset + entry_size.203;
      D.27269 = heap_us.size;
      if (D.27302 > D.27269) goto <D.27300>; else goto <D.27303>;
      <D.27303>:
      entry_size.203 = entry_size;
      D.27304 = ~entry_size.203;
      if (D.27304 < offset) goto <D.27300>; else goto <D.27301>;
      <D.27300>:
      D.27272 = ctx->report_error;
      if (D.27272 != 0) goto <D.27305>; else goto <D.27306>;
      <D.27305>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (12);
        vinfo->info.status = 1;
        D.27307 = monoeg_strdup ("User string oveflow heap_us");
        vinfo->info.message = D.27307;
        vinfo->exception_type = 3;
        D.27276 = ctx->errors;
        D.27308 = monoeg_g_slist_prepend (D.27276, vinfo);
        ctx->errors = D.27308;
      }
      <D.27306>:
      ctx->valid = 0;
      return;
      <D.27301>:
    }
  finally
    {
      heap_us = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


mono_verifier_verify_cattr_blob (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.27312;
  gboolean D.27315;
  _Bool D.27316;
  int D.27317;
  struct VerifyContext ctx;

  try
    {
      D.27312 = mono_verifier_is_enabled_for_image (image);
      if (D.27312 == 0) goto <D.27313>; else goto <D.27314>;
      <D.27313>:
      D.27315 = 1;
      return D.27315;
      <D.27314>:
      D.27316 = error_list != 0B;
      D.27317 = (int) D.27316;
      init_verify_context (&ctx, image, D.27317);
      ctx.stage = 2;
      is_valid_cattr_blob (&ctx, offset);
      D.27315 = cleanup_context (&ctx, error_list);
      return D.27315;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_cattr_content (struct MonoImage * image, struct MonoMethod * ctor, const guchar * data, guint32 size, struct GSList * * error_list)
{
  int D.27320;
  gboolean D.27323;
  _Bool D.27324;
  int D.27325;
  struct VerifyContext ctx;

  try
    {
      D.27320 = mono_verifier_is_enabled_for_image (image);
      if (D.27320 == 0) goto <D.27321>; else goto <D.27322>;
      <D.27321>:
      D.27323 = 1;
      return D.27323;
      <D.27322>:
      D.27324 = error_list != 0B;
      D.27325 = (int) D.27324;
      init_verify_context (&ctx, image, D.27325);
      ctx.stage = 2;
      is_valid_cattr_content (&ctx, ctor, data, size);
      D.27323 = cleanup_context (&ctx, error_list);
      return D.27323;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_is_sig_compatible (struct MonoImage * image, struct MonoMethod * method, struct MonoMethodSignature * signature)
{
  int D.27328;
  gboolean D.27331;
  unsigned char D.27332;
  unsigned char D.27333;
  unsigned char D.27336;
  unsigned char D.27337;
  unsigned char D.27338;
  unsigned char D.27341;
  signed char D.27344;
  unsigned char D.27349;
  unsigned char D.27350;
  unsigned char D.27351;
  unsigned char D.27352;
  short int D.27355;
  short int D.27356;
  int D.27360;
  struct MonoMethodSignature * original_sig;

  D.27328 = mono_verifier_is_enabled_for_image (image);
  if (D.27328 == 0) goto <D.27329>; else goto <D.27330>;
  <D.27329>:
  D.27331 = 1;
  return D.27331;
  <D.27330>:
  original_sig = mono_method_signature (method);
  D.27332 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.27333 = D.27332 & 63;
  if (D.27333 == 5) goto <D.27334>; else goto <D.27335>;
  <D.27334>:
  D.27332 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.27336 = BIT_FIELD_REF <*signature, 8, 80>;
  D.27337 = D.27332 ^ D.27336;
  D.27338 = D.27337 & 64;
  if (D.27338 != 0) goto <D.27339>; else goto <D.27340>;
  <D.27339>:
  D.27331 = 0;
  return D.27331;
  <D.27340>:
  D.27332 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.27336 = BIT_FIELD_REF <*signature, 8, 80>;
  D.27337 = D.27332 ^ D.27336;
  D.27341 = D.27337 & 63;
  if (D.27341 != 0) goto <D.27342>; else goto <D.27343>;
  <D.27342>:
  D.27331 = 0;
  return D.27331;
  <D.27343>:
  D.27332 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.27336 = BIT_FIELD_REF <*signature, 8, 80>;
  D.27337 = D.27332 ^ D.27336;
  D.27344 = (signed char) D.27337;
  if (D.27344 < 0) goto <D.27345>; else goto <D.27346>;
  <D.27345>:
  D.27331 = 0;
  return D.27331;
  <D.27346>:
  D.27332 = BIT_FIELD_REF <*original_sig, 8, 80>;
  D.27336 = BIT_FIELD_REF <*signature, 8, 80>;
  D.27337 = D.27332 ^ D.27336;
  D.27341 = D.27337 & 63;
  if (D.27341 != 0) goto <D.27347>; else goto <D.27348>;
  <D.27347>:
  D.27331 = 0;
  return D.27331;
  <D.27348>:
  D.27349 = BIT_FIELD_REF <*original_sig, 8, 88>;
  D.27350 = BIT_FIELD_REF <*signature, 8, 88>;
  D.27351 = D.27349 ^ D.27350;
  D.27352 = D.27351 & 1;
  if (D.27352 != 0) goto <D.27353>; else goto <D.27354>;
  <D.27353>:
  D.27331 = 0;
  return D.27331;
  <D.27354>:
  D.27355 = original_sig->sentinelpos;
  D.27356 = signature->sentinelpos;
  if (D.27355 != D.27356) goto <D.27357>; else goto <D.27358>;
  <D.27357>:
  D.27331 = 0;
  return D.27331;
  <D.27358>:
  goto <D.27359>;
  <D.27335>:
  D.27360 = mono_metadata_signature_equal (signature, original_sig);
  if (D.27360 == 0) goto <D.27361>; else goto <D.27362>;
  <D.27361>:
  D.27331 = 0;
  return D.27331;
  <D.27362>:
  <D.27359>:
  D.27331 = 1;
  return D.27331;
}


mono_verifier_verify_typeref_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.27364;
  gboolean D.27367;
  <unnamed-unsigned:24> D.27368;
  unsigned int D.27369;
  int D.27372;
  int row.205;
  unsigned int D.27374;
  int D.27375;
  unsigned int D.27378;
  unsigned int D.27383;
  int D.27385;
  unsigned int D.27386;
  int D.27389;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[1];
      mono_error_init (error);
      D.27364 = mono_verifier_is_enabled_for_image (image);
      if (D.27364 == 0) goto <D.27365>; else goto <D.27366>;
      <D.27365>:
      D.27367 = 1;
      return D.27367;
      <D.27366>:
      D.27368 = table->rows;
      D.27369 = (unsigned int) D.27368;
      if (D.27369 <= row) goto <D.27370>; else goto <D.27371>;
      <D.27370>:
      D.27368 = table->rows;
      D.27372 = (int) D.27368;
      mono_error_set_bad_image (error, image, "Invalid typeref row %d - table has %d rows", row, D.27372);
      D.27367 = 0;
      return D.27367;
      <D.27371>:
      row.205 = (int) row;
      mono_metadata_decode_row (table, row.205, &data, 3);
      D.27374 = data[0];
      D.27375 = is_valid_coded_index_with_image (image, 72, D.27374);
      if (D.27375 == 0) goto <D.27376>; else goto <D.27377>;
      <D.27376>:
      D.27374 = data[0];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d coded index 0x%08x", row, D.27374);
      D.27367 = 0;
      return D.27367;
      <D.27377>:
      D.27374 = data[0];
      D.27378 = get_coded_index_token (72, D.27374);
      if (D.27378 == 0) goto <D.27379>; else goto <D.27380>;
      <D.27379>:
      mono_error_set_bad_image (error, image, "The metadata verifier doesn\'t support null ResolutionScope tokens for typeref row %d", row);
      D.27367 = 0;
      return D.27367;
      <D.27380>:
      D.27383 = data[1];
      if (D.27383 == 0) goto <D.27381>; else goto <D.27384>;
      <D.27384>:
      D.27383 = data[1];
      D.27385 = is_valid_string_full_with_image (image, D.27383, 0);
      if (D.27385 == 0) goto <D.27381>; else goto <D.27382>;
      <D.27381>:
      D.27383 = data[1];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d name token 0x%08x", row, D.27383);
      D.27367 = 0;
      return D.27367;
      <D.27382>:
      D.27386 = data[2];
      if (D.27386 != 0) goto <D.27387>; else goto <D.27388>;
      <D.27387>:
      D.27386 = data[2];
      D.27389 = is_valid_string_full_with_image (image, D.27386, 0);
      if (D.27389 == 0) goto <D.27390>; else goto <D.27391>;
      <D.27390>:
      D.27386 = data[2];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d namespace token 0x%08x", row, D.27386);
      D.27367 = 0;
      return D.27367;
      <D.27391>:
      <D.27388>:
      D.27367 = 1;
      return D.27367;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_methodimpl_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.27394;
  gboolean D.27397;
  <unnamed-unsigned:24> D.27398;
  unsigned int D.27399;
  int D.27402;
  int row.206;
  unsigned int D.27404;
  struct MonoLoaderError * D.27408;
  unsigned int D.27409;
  struct MonoLoaderError * D.27413;
  int D.27418;
  struct MonoMethod * declaration;
  struct MonoMethod * body;
  struct MonoMethodSignature * body_sig;
  struct MonoMethodSignature * decl_sig;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[25];
      mono_error_init (error);
      D.27394 = mono_verifier_is_enabled_for_image (image);
      if (D.27394 == 0) goto <D.27395>; else goto <D.27396>;
      <D.27395>:
      D.27397 = 1;
      return D.27397;
      <D.27396>:
      D.27398 = table->rows;
      D.27399 = (unsigned int) D.27398;
      if (D.27399 <= row) goto <D.27400>; else goto <D.27401>;
      <D.27400>:
      D.27398 = table->rows;
      D.27402 = (int) D.27398;
      mono_error_set_bad_image (error, image, "Invalid methodimpl row %d - table has %d rows", row, D.27402);
      D.27397 = 0;
      return D.27397;
      <D.27401>:
      row.206 = (int) row;
      mono_metadata_decode_row (table, row.206, &data, 3);
      D.27404 = data[1];
      body = method_from_method_def_or_ref (image, D.27404, 0B);
      if (body == 0B) goto <D.27405>; else goto <D.27407>;
      <D.27407>:
      D.27408 = mono_loader_get_last_error ();
      if (D.27408 != 0B) goto <D.27405>; else goto <D.27406>;
      <D.27405>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl body for row %x", row);
      D.27397 = 0;
      return D.27397;
      <D.27406>:
      D.27409 = data[2];
      declaration = method_from_method_def_or_ref (image, D.27409, 0B);
      if (declaration == 0B) goto <D.27410>; else goto <D.27412>;
      <D.27412>:
      D.27413 = mono_loader_get_last_error ();
      if (D.27413 != 0B) goto <D.27410>; else goto <D.27411>;
      <D.27410>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl declaration for row %x", row);
      D.27397 = 0;
      return D.27397;
      <D.27411>:
      body_sig = mono_method_signature_checked (body, error);
      if (body_sig == 0B) goto <D.27414>; else goto <D.27415>;
      <D.27414>:
      D.27397 = 0;
      return D.27397;
      <D.27415>:
      decl_sig = mono_method_signature_checked (declaration, error);
      if (decl_sig == 0B) goto <D.27416>; else goto <D.27417>;
      <D.27416>:
      D.27397 = 0;
      return D.27397;
      <D.27417>:
      D.27418 = mono_verifier_is_signature_compatible (decl_sig, body_sig);
      if (D.27418 == 0) goto <D.27419>; else goto <D.27420>;
      <D.27419>:
      mono_error_set_bad_image (error, image, "Invalid methodimpl body signature not compatible with declaration row %x", row);
      D.27397 = 0;
      return D.27397;
      <D.27420>:
      D.27397 = 1;
      return D.27397;
    }
  finally
    {
      data = {CLOBBER};
    }
}