mono_verifier_verify_pe_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.19631;
  gboolean D.19634;
  _Bool D.19635;
  int D.19636;
  int D.19637;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.19631 = mono_verifier_is_enabled_for_image (image);
      if (D.19631 == 0) goto <D.19632>; else goto <D.19633>;
      <D.19632>:
      D.19634 = 1;
      return D.19634;
      <D.19633>:
      D.19635 = error_list != 0B;
      D.19636 = (int) D.19635;
      init_verify_context (&ctx, image, D.19636);
      ctx.stage = 0;
      verify_msdos_header (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19638>;
      <D.19638>:
      verify_pe_header (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19639>;
      <D.19639>:
      verify_pe_optional_header (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19640>;
      <D.19640>:
      load_section_table (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19641>;
      <D.19641>:
      load_data_directories (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19642>;
      <D.19642>:
      verify_import_table (&ctx);
      D.19637 = ctx.valid;
      if (D.19637 == 0) goto cleanup; else goto <D.19643>;
      <D.19643>:
      verify_resources_table (&ctx);
      cleanup:
      D.19634 = cleanup_context (&ctx, error_list);
      return D.19634;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


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

  memset (ctx, 0, 296);
  ctx->image = image;
  ctx->report_error = report_error;
  ctx->report_warning = 0;
  ctx->valid = 1;
  D.19646 = image->raw_data_len;
  ctx->size = D.19646;
  D.19647 = image->raw_data;
  ctx->data = D.19647;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.19650;
  int D.19655;
  void * D.19657;
  long unsigned int D.19658;

  D.19650 = __builtin_constant_p (__len);
  if (D.19650 != 0) goto <D.19651>; else goto <D.19652>;
  <D.19651>:
  if (__len == 0) goto <D.19653>; else goto <D.19654>;
  <D.19653>:
  D.19655 = __builtin_constant_p (__ch);
  if (D.19655 == 0) goto <D.19648>; else goto <D.19656>;
  <D.19656>:
  if (__ch != 0) goto <D.19648>; else goto <D.19649>;
  <D.19648>:
  __warn_memset_zero_len ();
  D.19657 = __dest;
  return D.19657;
  <D.19649>:
  <D.19654>:
  <D.19652>:
  D.19658 = __builtin_object_size (__dest, 0);
  D.19657 = __builtin___memset_chk (__dest, __ch, __len, D.19658);
  return D.19657;
}


verify_msdos_header (struct VerifyContext * ctx)
{
  unsigned int D.19660;
  int D.19663;
  gchar * D.19666;
  struct GSList * D.19667;
  struct GSList * D.19668;
  const char * D.19671;
  char D.19672;
  const char * D.19674;
  char D.19675;
  gchar * D.19678;
  struct GSList * D.19679;
  unsigned int D.19680;
  gchar * D.19685;
  struct GSList * D.19686;
  guint32 lfanew;

  D.19660 = ctx->size;
  if (D.19660 <= 127) goto <D.19661>; else goto <D.19662>;
  <D.19661>:
  D.19663 = ctx->report_error;
  if (D.19663 != 0) goto <D.19664>; else goto <D.19665>;
  <D.19664>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19666 = monoeg_strdup ("Not enough space for the MS-DOS header");
    vinfo->info.message = D.19666;
    vinfo->exception_type = 3;
    D.19667 = ctx->errors;
    D.19668 = monoeg_g_slist_prepend (D.19667, vinfo);
    ctx->errors = D.19668;
  }
  <D.19665>:
  ctx->valid = 0;
  return;
  <D.19662>:
  D.19671 = ctx->data;
  D.19672 = *D.19671;
  if (D.19672 != 77) goto <D.19669>; else goto <D.19673>;
  <D.19673>:
  D.19671 = ctx->data;
  D.19674 = D.19671 + 1;
  D.19675 = *D.19674;
  if (D.19675 != 90) goto <D.19669>; else goto <D.19670>;
  <D.19669>:
  D.19663 = ctx->report_error;
  if (D.19663 != 0) goto <D.19676>; else goto <D.19677>;
  <D.19676>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19678 = monoeg_strdup ("Invalid MS-DOS watermark");
    vinfo->info.message = D.19678;
    vinfo->exception_type = 3;
    D.19667 = ctx->errors;
    D.19679 = monoeg_g_slist_prepend (D.19667, vinfo);
    ctx->errors = D.19679;
  }
  <D.19677>:
  ctx->valid = 0;
  return;
  <D.19670>:
  lfanew = pe_signature_offset (ctx);
  D.19660 = ctx->size;
  D.19680 = D.19660 + 4294967292;
  if (D.19680 < lfanew) goto <D.19681>; else goto <D.19682>;
  <D.19681>:
  D.19663 = ctx->report_error;
  if (D.19663 != 0) goto <D.19683>; else goto <D.19684>;
  <D.19683>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19685 = monoeg_strdup ("MS-DOS lfanew offset points to outside of the file");
    vinfo->info.message = D.19685;
    vinfo->exception_type = 3;
    D.19667 = ctx->errors;
    D.19686 = monoeg_g_slist_prepend (D.19667, vinfo);
    ctx->errors = D.19686;
  }
  <D.19684>:
  ctx->valid = 0;
  return;
  <D.19682>:
}


pe_signature_offset (struct VerifyContext * ctx)
{
  guint32 D.19688;
  const char * D.19689;
  const guint32 * D.19690;

  D.19689 = ctx->data;
  D.19690 = D.19689 + 60;
  D.19688 = *D.19690;
  return D.19688;
}


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

  if (str != 0B) goto <D.19692>; else goto <D.19693>;
  <D.19692>:
  D.19694 = __strdup (str);
  return D.19694;
  <D.19693>:
  D.19694 = 0B;
  return D.19694;
}


verify_pe_header (struct VerifyContext * ctx)
{
  const char * D.19696;
  sizetype D.19697;
  char D.19700;
  const char * D.19702;
  char D.19703;
  const char * D.19705;
  char D.19706;
  const char * D.19708;
  char D.19709;
  int D.19710;
  gchar * D.19713;
  struct GSList * D.19714;
  struct GSList * D.19715;
  unsigned int D.19716;
  unsigned int D.19717;
  gchar * D.19722;
  struct GSList * D.19723;
  short unsigned int D.19724;
  gchar * D.19729;
  struct GSList * D.19730;
  guint32 offset;
  const char * pe_header;

  offset = pe_signature_offset (ctx);
  D.19696 = ctx->data;
  D.19697 = (sizetype) offset;
  pe_header = D.19696 + D.19697;
  D.19700 = *pe_header;
  if (D.19700 != 80) goto <D.19698>; else goto <D.19701>;
  <D.19701>:
  D.19702 = pe_header + 1;
  D.19703 = *D.19702;
  if (D.19703 != 69) goto <D.19698>; else goto <D.19704>;
  <D.19704>:
  D.19705 = pe_header + 2;
  D.19706 = *D.19705;
  if (D.19706 != 0) goto <D.19698>; else goto <D.19707>;
  <D.19707>:
  D.19708 = pe_header + 3;
  D.19709 = *D.19708;
  if (D.19709 != 0) goto <D.19698>; else goto <D.19699>;
  <D.19698>:
  D.19710 = ctx->report_error;
  if (D.19710 != 0) goto <D.19711>; else goto <D.19712>;
  <D.19711>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19713 = monoeg_strdup ("Invalid PE header watermark");
    vinfo->info.message = D.19713;
    vinfo->exception_type = 3;
    D.19714 = ctx->errors;
    D.19715 = monoeg_g_slist_prepend (D.19714, vinfo);
    ctx->errors = D.19715;
  }
  <D.19712>:
  ctx->valid = 0;
  return;
  <D.19699>:
  pe_header = pe_header + 4;
  offset = offset + 4;
  D.19716 = ctx->size;
  D.19717 = D.19716 + 4294967276;
  if (D.19717 < offset) goto <D.19718>; else goto <D.19719>;
  <D.19718>:
  D.19710 = ctx->report_error;
  if (D.19710 != 0) goto <D.19720>; else goto <D.19721>;
  <D.19720>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19722 = monoeg_strdup ("File with truncated pe header");
    vinfo->info.message = D.19722;
    vinfo->exception_type = 3;
    D.19714 = ctx->errors;
    D.19723 = monoeg_g_slist_prepend (D.19714, vinfo);
    ctx->errors = D.19723;
  }
  <D.19721>:
  ctx->valid = 0;
  return;
  <D.19719>:
  D.19724 = MEM[(const guint16 *)pe_header];
  if (D.19724 != 332) goto <D.19725>; else goto <D.19726>;
  <D.19725>:
  D.19710 = ctx->report_error;
  if (D.19710 != 0) goto <D.19727>; else goto <D.19728>;
  <D.19727>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19729 = monoeg_strdup ("Invalid PE header Machine value");
    vinfo->info.message = D.19729;
    vinfo->exception_type = 3;
    D.19714 = ctx->errors;
    D.19730 = monoeg_g_slist_prepend (D.19714, vinfo);
    ctx->errors = D.19730;
  }
  <D.19728>:
  ctx->valid = 0;
  return;
  <D.19726>:
}


verify_pe_optional_header (struct VerifyContext * ctx)
{
  const char * D.19732;
  sizetype D.19733;
  const guint16 * D.19734;
  short unsigned int D.19735;
  int D.19738;
  gchar * D.19741;
  struct GSList * D.19742;
  struct GSList * D.19743;
  unsigned int D.19746;
  unsigned int D.19747;
  gchar * D.19751;
  struct GSList * D.19752;
  short unsigned int D.19753;
  gchar * D.19760;
  struct GSList * D.19761;
  const guint32 * D.19762;
  unsigned int D.19763;
  gchar * D.19768;
  struct GSList * D.19769;
  _Bool D.19770;
  _Bool D.19771;
  _Bool D.19772;
  gchar * D.19777;
  struct GSList * D.19778;
  const guint32 * D.19779;
  unsigned int D.19780;
  gchar * D.19785;
  struct GSList * D.19786;
  gchar * D.19792;
  struct GSList * D.19793;
  int D.19796;
  gchar * D.19797;
  struct GSList * D.19798;
  guint32 offset;
  guint32 header_size;
  guint32 file_alignment;
  const char * pe_header;
  const char * pe_optional_header;

  offset = pe_header_offset (ctx);
  D.19732 = ctx->data;
  D.19733 = (sizetype) offset;
  pe_header = D.19732 + D.19733;
  pe_optional_header = pe_header + 20;
  D.19734 = pe_header + 16;
  D.19735 = *D.19734;
  header_size = (guint32) D.19735;
  offset = offset + 20;
  if (header_size <= 1) goto <D.19736>; else goto <D.19737>;
  <D.19736>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19739>; else goto <D.19740>;
  <D.19739>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19741 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19741;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19743 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19743;
  }
  <D.19740>:
  ctx->valid = 0;
  return;
  <D.19737>:
  D.19746 = ctx->size;
  D.19747 = D.19746 - header_size;
  if (D.19747 < offset) goto <D.19744>; else goto <D.19748>;
  <D.19748>:
  D.19746 = ctx->size;
  if (D.19746 < header_size) goto <D.19744>; else goto <D.19745>;
  <D.19744>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19749>; else goto <D.19750>;
  <D.19749>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19751 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19751;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19752 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19752;
  }
  <D.19750>:
  ctx->valid = 0;
  return;
  <D.19745>:
  D.19753 = MEM[(const guint16 *)pe_optional_header];
  if (D.19753 == 267) goto <D.19754>; else goto <D.19755>;
  <D.19754>:
  if (header_size != 224) goto <D.19756>; else goto <D.19757>;
  <D.19756>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19758>; else goto <D.19759>;
  <D.19758>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19760 = monoeg_g_strdup_printf ("Invalid optional header size %d", header_size);
    vinfo->info.message = D.19760;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19761 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19761;
  }
  <D.19759>:
  ctx->valid = 0;
  return;
  <D.19757>:
  D.19762 = pe_optional_header + 32;
  D.19763 = *D.19762;
  if (D.19763 != 8192) goto <D.19764>; else goto <D.19765>;
  <D.19764>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19766>; else goto <D.19767>;
  <D.19766>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19762 = pe_optional_header + 32;
    D.19763 = *D.19762;
    D.19768 = monoeg_g_strdup_printf ("Invalid Section Aligmnent %x", D.19763);
    vinfo->info.message = D.19768;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19769 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19769;
  }
  <D.19767>:
  ctx->valid = 0;
  return;
  <D.19765>:
  file_alignment = MEM[(const guint32 *)pe_optional_header + 36B];
  D.19770 = file_alignment != 512;
  D.19771 = file_alignment != 4096;
  D.19772 = D.19770 & D.19771;
  if (D.19772 != 0) goto <D.19773>; else goto <D.19774>;
  <D.19773>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19775>; else goto <D.19776>;
  <D.19775>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19777 = monoeg_g_strdup_printf ("Invalid file Aligmnent %x", file_alignment);
    vinfo->info.message = D.19777;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19778 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19778;
  }
  <D.19776>:
  ctx->valid = 0;
  return;
  <D.19774>:
  D.19779 = pe_optional_header + 92;
  D.19780 = *D.19779;
  if (D.19780 > 16) goto <D.19781>; else goto <D.19782>;
  <D.19781>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19783>; else goto <D.19784>;
  <D.19783>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19779 = pe_optional_header + 92;
    D.19780 = *D.19779;
    D.19785 = monoeg_g_strdup_printf ("Too many data directories %x", D.19780);
    vinfo->info.message = D.19785;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19786 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19786;
  }
  <D.19784>:
  ctx->valid = 0;
  return;
  <D.19782>:
  goto <D.19787>;
  <D.19755>:
  D.19753 = MEM[(const guint16 *)pe_optional_header];
  if (D.19753 == 523) goto <D.19788>; else goto <D.19789>;
  <D.19788>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19790>; else goto <D.19791>;
  <D.19790>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19792 = monoeg_strdup ("Metadata verifier doesn\'t handle PE32+");
    vinfo->info.message = D.19792;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19793 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19793;
  }
  <D.19791>:
  ctx->valid = 0;
  return;
  <D.19789>:
  D.19738 = ctx->report_error;
  if (D.19738 != 0) goto <D.19794>; else goto <D.19795>;
  <D.19794>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19753 = MEM[(const guint16 *)pe_optional_header];
    D.19796 = (int) D.19753;
    D.19797 = monoeg_g_strdup_printf ("Invalid optional header magic %d", D.19796);
    vinfo->info.message = D.19797;
    vinfo->exception_type = 3;
    D.19742 = ctx->errors;
    D.19798 = monoeg_g_slist_prepend (D.19742, vinfo);
    ctx->errors = D.19798;
  }
  <D.19795>:
  ctx->valid = 0;
  return;
  <D.19787>:
}


pe_header_offset (struct VerifyContext * ctx)
{
  guint32 D.19800;
  const char * D.19801;
  const guint32 * D.19802;
  unsigned int D.19803;

  D.19801 = ctx->data;
  D.19802 = D.19801 + 60;
  D.19803 = *D.19802;
  D.19800 = D.19803 + 4;
  return D.19800;
}


load_section_table (struct VerifyContext * ctx)
{
  const char * D.19805;
  sizetype D.19806;
  const guint16 * D.19807;
  short unsigned int D.19808;
  unsigned int D.19809;
  unsigned int D.19810;
  int D.19811;
  int D.19812;
  unsigned int D.19813;
  unsigned int D.19814;
  unsigned int D.19815;
  int D.19818;
  gchar * D.19821;
  struct GSList * D.19822;
  struct GSList * D.19823;
  long unsigned int D.19824;
  long unsigned int D.19825;
  void * D.19826;
  long unsigned int D.19827;
  long unsigned int D.19828;
  struct SectionHeader * D.19829;
  unsigned int D.19830;
  unsigned int D.19831;
  unsigned int D.19832;
  unsigned int D.19833;
  short unsigned int D.19834;
  unsigned int D.19835;
  gchar * D.19840;
  struct GSList * D.19841;
  gchar * D.19846;
  struct GSList * D.19847;
  unsigned int D.19848;
  unsigned int D.19849;
  gchar * D.19854;
  struct GSList * D.19855;
  gchar * D.19860;
  struct GSList * D.19861;
  gchar * D.19866;
  struct GSList * D.19867;
  unsigned int D.19870;
  short unsigned int D.19872;
  gchar * D.19875;
  struct GSList * D.19876;
  unsigned int D.19880;
  gchar * D.19883;
  struct GSList * D.19884;
  int i;
  struct SectionHeader * sections;
  guint32 offset;
  const char * ptr;
  guint16 num_sections;

  offset = pe_header_offset (ctx);
  D.19805 = ctx->data;
  D.19806 = (sizetype) offset;
  ptr = D.19805 + D.19806;
  D.19807 = ptr + 2;
  D.19808 = *D.19807;
  D.19809 = (unsigned int) D.19808;
  ctx->section_count = D.19809;
  D.19810 = ctx->section_count;
  num_sections = (guint16) D.19810;
  offset = offset + 244;
  ptr = ptr + 244;
  D.19811 = (int) num_sections;
  D.19812 = D.19811 * 40;
  D.19813 = (unsigned int) D.19812;
  D.19814 = ctx->size;
  D.19815 = D.19814 - offset;
  if (D.19813 > D.19815) goto <D.19816>; else goto <D.19817>;
  <D.19816>:
  D.19818 = ctx->report_error;
  if (D.19818 != 0) goto <D.19819>; else goto <D.19820>;
  <D.19819>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.19821 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.19821;
    vinfo->exception_type = 3;
    D.19822 = ctx->errors;
    D.19823 = monoeg_g_slist_prepend (D.19822, vinfo);
    ctx->errors = D.19823;
  }
  <D.19820>:
  ctx->valid = 0;
  return;
  <D.19817>:
  D.19824 = (long unsigned int) num_sections;
  D.19825 = D.19824 * 20;
  D.19826 = monoeg_malloc0 (D.19825);
  ctx->sections = D.19826;
  sections = ctx->sections;
  i = 0;
  goto <D.17820>;
  <D.17819>:
  D.19827 = (long unsigned int) i;
  D.19828 = D.19827 * 20;
  D.19829 = sections + D.19828;
  D.19830 = MEM[(const guint32 *)ptr + 8B];
  D.19829->size = D.19830;
  D.19827 = (long unsigned int) i;
  D.19828 = D.19827 * 20;
  D.19829 = sections + D.19828;
  D.19831 = MEM[(const guint32 *)ptr + 12B];
  D.19829->baseRVA = D.19831;
  D.19827 = (long unsigned int) i;
  D.19828 = D.19827 * 20;
  D.19829 = sections + D.19828;
  D.19832 = MEM[(const guint32 *)ptr + 20B];
  D.19829->baseOffset = D.19832;
  D.19827 = (long unsigned int) i;
  D.19828 = D.19827 * 20;
  D.19829 = sections + D.19828;
  D.19833 = MEM[(const guint32 *)ptr + 24B];
  D.19829->rellocationsRVA = D.19833;
  D.19827 = (long unsigned int) i;
  D.19828 = D.19827 * 20;
  D.19829 = sections + D.19828;
  D.19834 = MEM[(const guint16 *)ptr + 32B];
  D.19829->numberOfRelocations = D.19834;
  ptr = ptr + 40;
  i = i + 1;
  <D.17820>:
  D.19811 = (int) num_sections;
  if (D.19811 > i) goto <D.17819>; else goto <D.17821>;
  <D.17821>:
  D.19805 = ctx->data;
  D.19806 = (sizetype) offset;
  ptr = D.19805 + D.19806;
  i = 0;
  goto <D.17832>;
  <D.17831>:
  {
    guint32 raw_size;
    guint32 flags;

    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19835 = D.19829->baseOffset;
    if (D.19835 == 0) goto <D.19836>; else goto <D.19837>;
    <D.19836>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19838>; else goto <D.19839>;
    <D.19838>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19840 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with intialized data only");
      vinfo->info.message = D.19840;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19841 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19841;
    }
    <D.19839>:
    ctx->valid = 0;
    return;
    <D.19837>:
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19835 = D.19829->baseOffset;
    D.19814 = ctx->size;
    if (D.19835 >= D.19814) goto <D.19842>; else goto <D.19843>;
    <D.19842>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19844>; else goto <D.19845>;
    <D.19844>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19827 = (long unsigned int) i;
      D.19828 = D.19827 * 20;
      D.19829 = sections + D.19828;
      D.19835 = D.19829->baseOffset;
      D.19846 = monoeg_g_strdup_printf ("Invalid PointerToRawData %x points beyond EOF", D.19835);
      vinfo->info.message = D.19846;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19847 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19847;
    }
    <D.19845>:
    ctx->valid = 0;
    return;
    <D.19843>:
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19848 = D.19829->size;
    D.19814 = ctx->size;
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19835 = D.19829->baseOffset;
    D.19849 = D.19814 - D.19835;
    if (D.19848 > D.19849) goto <D.19850>; else goto <D.19851>;
    <D.19850>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19852>; else goto <D.19853>;
    <D.19852>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19854 = monoeg_strdup ("Invalid VirtualSize points beyond EOF");
      vinfo->info.message = D.19854;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19855 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19855;
    }
    <D.19853>:
    ctx->valid = 0;
    return;
    <D.19851>:
    raw_size = MEM[(const guint32 *)ptr + 16B];
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19848 = D.19829->size;
    if (D.19848 > raw_size) goto <D.19856>; else goto <D.19857>;
    <D.19856>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19858>; else goto <D.19859>;
    <D.19858>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19860 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with SizeOfRawData < VirtualSize");
      vinfo->info.message = D.19860;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19861 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19861;
    }
    <D.19859>:
    ctx->valid = 0;
    return;
    <D.19857>:
    D.19814 = ctx->size;
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19835 = D.19829->baseOffset;
    D.19849 = D.19814 - D.19835;
    if (D.19849 < raw_size) goto <D.19862>; else goto <D.19863>;
    <D.19862>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19864>; else goto <D.19865>;
    <D.19864>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19866 = monoeg_g_strdup_printf ("Invalid SizeOfRawData %x points beyond EOF", raw_size);
      vinfo->info.message = D.19866;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19867 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19867;
    }
    <D.19865>:
    ctx->valid = 0;
    return;
    <D.19863>:
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19870 = D.19829->rellocationsRVA;
    if (D.19870 != 0) goto <D.19868>; else goto <D.19871>;
    <D.19871>:
    D.19827 = (long unsigned int) i;
    D.19828 = D.19827 * 20;
    D.19829 = sections + D.19828;
    D.19872 = D.19829->numberOfRelocations;
    if (D.19872 != 0) goto <D.19868>; else goto <D.19869>;
    <D.19868>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19873>; else goto <D.19874>;
    <D.19873>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19875 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t handle section relocation");
      vinfo->info.message = D.19875;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19876 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19876;
    }
    <D.19874>:
    ctx->valid = 0;
    return;
    <D.19869>:
    flags = MEM[(const guint32 *)ptr + 36B];
    if (flags == 0) goto <D.19877>; else goto <D.19879>;
    <D.19879>:
    D.19880 = flags & 33554207;
    if (D.19880 != 0) goto <D.19877>; else goto <D.19878>;
    <D.19877>:
    D.19818 = ctx->report_error;
    if (D.19818 != 0) goto <D.19881>; else goto <D.19882>;
    <D.19881>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19883 = monoeg_g_strdup_printf ("Invalid section flags %x", flags);
      vinfo->info.message = D.19883;
      vinfo->exception_type = 3;
      D.19822 = ctx->errors;
      D.19884 = monoeg_g_slist_prepend (D.19822, vinfo);
      ctx->errors = D.19884;
    }
    <D.19882>:
    ctx->valid = 0;
    return;
    <D.19878>:
    ptr = ptr + 40;
  }
  i = i + 1;
  <D.17832>:
  D.19811 = (int) num_sections;
  if (D.19811 > i) goto <D.17831>; else goto <D.17833>;
  <D.17833>:
}


load_data_directories (struct VerifyContext * ctx)
{
  unsigned int D.19886;
  const char * D.19887;
  sizetype D.19888;
  unsigned int D.19891;
  int D.19894;
  int D.19897;
  gchar * D.19900;
  struct GSList * D.19901;
  struct GSList * D.19902;
  int D.19905;
  gchar * D.19910;
  struct GSList * D.19911;
  unsigned int D.19912;
  guint32 offset;
  const char * ptr;
  int i;

  D.19886 = pe_header_offset (ctx);
  offset = D.19886 + 116;
  D.19887 = ctx->data;
  D.19888 = (sizetype) offset;
  ptr = D.19887 + D.19888;
  i = 0;
  goto <D.17849>;
  <D.17848>:
  {
    guint32 rva;
    guint32 size;

    rva = MEM[(const guint32 *)ptr];
    size = MEM[(const guint32 *)ptr + 4B];
    if (i == 4) goto <D.19889>; else goto <D.19890>;
    <D.19889>:
    ptr = ptr + 8;
    // predicted unlikely by continue predictor.
    goto <D.17845>;
    <D.19890>:
    D.19891 = rva | size;
    if (D.19891 != 0) goto <D.19892>; else goto <D.19893>;
    <D.19892>:
    D.19894 = is_valid_data_directory (i);
    if (D.19894 == 0) goto <D.19895>; else goto <D.19896>;
    <D.19895>:
    D.19897 = ctx->report_error;
    if (D.19897 != 0) goto <D.19898>; else goto <D.19899>;
    <D.19898>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19900 = monoeg_g_strdup_printf ("Invalid data directory %d", i);
      vinfo->info.message = D.19900;
      vinfo->exception_type = 3;
      D.19901 = ctx->errors;
      D.19902 = monoeg_g_slist_prepend (D.19901, vinfo);
      ctx->errors = D.19902;
    }
    <D.19899>:
    ctx->valid = 0;
    return;
    <D.19896>:
    <D.19893>:
    if (rva != 0) goto <D.19903>; else goto <D.19904>;
    <D.19903>:
    D.19905 = bounds_check_virtual_address (ctx, rva, size);
    if (D.19905 == 0) goto <D.19906>; else goto <D.19907>;
    <D.19906>:
    D.19897 = ctx->report_error;
    if (D.19897 != 0) goto <D.19908>; else goto <D.19909>;
    <D.19908>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.19910 = monoeg_g_strdup_printf ("Invalid data directory %d rva/size pair %x/%x", i, rva, size);
      vinfo->info.message = D.19910;
      vinfo->exception_type = 3;
      D.19901 = ctx->errors;
      D.19911 = monoeg_g_slist_prepend (D.19901, vinfo);
      ctx->errors = D.19911;
    }
    <D.19909>:
    ctx->valid = 0;
    return;
    <D.19907>:
    <D.19904>:
    ctx->data_directories[i].rva = rva;
    ctx->data_directories[i].size = size;
    D.19912 = translate_rva (ctx, rva);
    ctx->data_directories[i].translated_offset = D.19912;
    ptr = ptr + 8;
  }
  <D.17845>:
  i = i + 1;
  <D.17849>:
  if (i <= 15) goto <D.17848>; else goto <D.17850>;
  <D.17850>:
}


is_valid_data_directory (int i)
{
  gboolean D.19914;
  int iftmp.0;
  unsigned int i.1;
  unsigned int D.19920;
  _Bool D.19921;
  _Bool D.19922;
  _Bool D.19923;
  _Bool D.19925;
  _Bool D.19926;
  _Bool D.19927;
  _Bool D.19929;
  _Bool D.19930;
  _Bool D.19931;

  i.1 = (unsigned int) i;
  D.19920 = i.1 + 4294967295;
  D.19921 = D.19920 <= 1;
  D.19922 = i == 5;
  D.19923 = D.19921 | D.19922;
  if (D.19923 != 0) goto <D.19916>; else goto <D.19924>;
  <D.19924>:
  D.19925 = i == 12;
  D.19926 = i == 14;
  D.19927 = D.19925 | D.19926;
  if (D.19927 != 0) goto <D.19916>; else goto <D.19928>;
  <D.19928>:
  D.19929 = i == 4;
  D.19930 = i == 6;
  D.19931 = D.19929 | D.19930;
  if (D.19931 != 0) goto <D.19916>; else goto <D.19917>;
  <D.19916>:
  iftmp.0 = 1;
  goto <D.19918>;
  <D.19917>:
  iftmp.0 = 0;
  <D.19918>:
  D.19914 = iftmp.0;
  return D.19914;
}


bounds_check_virtual_address (struct VerifyContext * ctx, guint32 rva, guint32 size)
{
  unsigned int D.19933;
  gboolean D.19936;
  int D.19937;
  struct MonoImage * D.19940;
  unsigned int D.19941;
  struct SectionHeader * D.19946;
  long unsigned int D.19949;
  long unsigned int D.19950;
  struct SectionHeader * D.19951;
  unsigned int D.19952;
  unsigned int D.19953;
  unsigned int i.2;
  unsigned int D.19959;
  int i;

  D.19933 = rva + size;
  if (D.19933 < rva) goto <D.19934>; else goto <D.19935>;
  <D.19934>:
  D.19936 = 0;
  return D.19936;
  <D.19935>:
  D.19937 = ctx->stage;
  if (D.19937 > 0) goto <D.19938>; else goto <D.19939>;
  <D.19938>:
  {
    struct MonoCLIImageInfo * iinfo;
    const int top;
    struct MonoSectionTable * tables;
    int i;

    D.19940 = ctx->image;
    iinfo = D.19940->image_info;
    top = iinfo->cli_section_count;
    tables = iinfo->cli_section_tables;
    i = 0;
    goto <D.17751>;
    <D.17750>:
    {
      guint32 base;
      guint32 end;

      base = tables->st_virtual_address;
      D.19941 = tables->st_raw_data_size;
      end = D.19941 + base;
      if (rva >= base) goto <D.19942>; else goto <D.19943>;
      <D.19942>:
      D.19933 = rva + size;
      if (D.19933 <= end) goto <D.19944>; else goto <D.19945>;
      <D.19944>:
      D.19936 = 1;
      return D.19936;
      <D.19945>:
      <D.19943>:
      tables = tables + 40;
    }
    i = i + 1;
    <D.17751>:
    if (i < top) goto <D.17750>; else goto <D.17752>;
    <D.17752>:
    D.19936 = 0;
    return D.19936;
  }
  <D.19939>:
  D.19946 = ctx->sections;
  if (D.19946 == 0B) goto <D.19947>; else goto <D.19948>;
  <D.19947>:
  D.19936 = 0;
  return D.19936;
  <D.19948>:
  i = 0;
  goto <D.17756>;
  <D.17755>:
  {
    guint32 base;
    guint32 end;

    D.19946 = ctx->sections;
    D.19949 = (long unsigned int) i;
    D.19950 = D.19949 * 20;
    D.19951 = D.19946 + D.19950;
    base = D.19951->baseRVA;
    D.19946 = ctx->sections;
    D.19949 = (long unsigned int) i;
    D.19950 = D.19949 * 20;
    D.19951 = D.19946 + D.19950;
    D.19952 = D.19951->baseRVA;
    D.19946 = ctx->sections;
    D.19949 = (long unsigned int) i;
    D.19950 = D.19949 * 20;
    D.19951 = D.19946 + D.19950;
    D.19953 = D.19951->size;
    end = D.19952 + D.19953;
    if (rva >= base) goto <D.19954>; else goto <D.19955>;
    <D.19954>:
    D.19933 = rva + size;
    if (D.19933 <= end) goto <D.19956>; else goto <D.19957>;
    <D.19956>:
    D.19936 = 1;
    return D.19936;
    <D.19957>:
    <D.19955>:
  }
  i = i + 1;
  <D.17756>:
  i.2 = (unsigned int) i;
  D.19959 = ctx->section_count;
  if (i.2 < D.19959) goto <D.17755>; else goto <D.17757>;
  <D.17757>:
  D.19936 = 0;
  return D.19936;
}


translate_rva (struct VerifyContext * ctx, guint32 rva)
{
  int D.19961;
  guint32 D.19964;
  struct MonoImage * D.19965;
  struct SectionHeader * D.19966;
  long unsigned int D.19969;
  long unsigned int D.19970;
  struct SectionHeader * D.19971;
  unsigned int D.19972;
  unsigned int D.19973;
  _Bool D.19974;
  _Bool D.19975;
  _Bool D.19976;
  unsigned int D.19979;
  unsigned int D.19980;
  guint32 iftmp.3;
  unsigned int D.19982;
  unsigned int i.4;
  unsigned int D.19987;
  int i;

  D.19961 = ctx->stage;
  if (D.19961 > 0) goto <D.19962>; else goto <D.19963>;
  <D.19962>:
  D.19965 = ctx->image;
  D.19964 = mono_cli_rva_image_map (D.19965, rva);
  return D.19964;
  <D.19963>:
  D.19966 = ctx->sections;
  if (D.19966 == 0B) goto <D.19967>; else goto <D.19968>;
  <D.19967>:
  D.19964 = 0;
  return D.19964;
  <D.19968>:
  i = 0;
  goto <D.17777>;
  <D.17776>:
  {
    guint32 base;
    guint32 end;

    D.19966 = ctx->sections;
    D.19969 = (long unsigned int) i;
    D.19970 = D.19969 * 20;
    D.19971 = D.19966 + D.19970;
    base = D.19971->baseRVA;
    D.19966 = ctx->sections;
    D.19969 = (long unsigned int) i;
    D.19970 = D.19969 * 20;
    D.19971 = D.19966 + D.19970;
    D.19972 = D.19971->baseRVA;
    D.19966 = ctx->sections;
    D.19969 = (long unsigned int) i;
    D.19970 = D.19969 * 20;
    D.19971 = D.19966 + D.19970;
    D.19973 = D.19971->size;
    end = D.19972 + D.19973;
    D.19974 = rva >= base;
    D.19975 = rva <= end;
    D.19976 = D.19974 & D.19975;
    if (D.19976 != 0) goto <D.19977>; else goto <D.19978>;
    <D.19977>:
    {
      guint32 res;

      D.19979 = rva - base;
      D.19966 = ctx->sections;
      D.19969 = (long unsigned int) i;
      D.19970 = D.19969 * 20;
      D.19971 = D.19966 + D.19970;
      D.19980 = D.19971->baseOffset;
      res = D.19979 + D.19980;
      D.19982 = ctx->size;
      if (D.19982 > res) goto <D.19983>; else goto <D.19984>;
      <D.19983>:
      iftmp.3 = res;
      goto <D.19985>;
      <D.19984>:
      iftmp.3 = 4294967295;
      <D.19985>:
      D.19964 = iftmp.3;
      return D.19964;
    }
    <D.19978>:
  }
  i = i + 1;
  <D.17777>:
  i.4 = (unsigned int) i;
  D.19987 = ctx->section_count;
  if (i.4 < D.19987) goto <D.17776>; else goto <D.17778>;
  <D.17778>:
  D.19964 = 4294967295;
  return D.19964;
}


verify_import_table (struct VerifyContext * ctx)
{
  const char * D.19989;
  sizetype D.19990;
  _Bool D.19991;
  long int D.19992;
  long int D.19993;
  unsigned int D.19996;
  int D.19999;
  gchar * D.20002;
  struct GSList * D.20003;
  struct GSList * D.20004;
  int D.20007;
  gchar * D.20012;
  struct GSList * D.20013;
  int D.20016;
  gchar * D.20021;
  struct GSList * D.20022;
  int D.20025;
  gchar * D.20030;
  struct GSList * D.20031;
  unsigned int D.20032;
  const guint32 * D.20037;
  unsigned int D.20038;
  gchar * D.20039;
  struct GSList * D.20040;
  _Bool D.20043;
  long int D.20044;
  long int D.20045;
  sizetype D.20048;
  int D.20049;
  gchar * D.20054;
  struct GSList * D.20055;
  int D.20058;
  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.19989 = ctx->data;
      D.19990 = (sizetype) offset;
      ptr = D.19989 + D.19990;
      D.19991 = offset == 4294967295;
      D.19992 = (long int) D.19991;
      D.19993 = __builtin_expect (D.19992, 0);
      if (D.19993 != 0) goto <D.19994>; else goto <D.19995>;
      <D.19994>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 612, "offset != INVALID_OFFSET");
      <D.19995>:
      D.19996 = it.size;
      if (D.19996 <= 39) goto <D.19997>; else goto <D.19998>;
      <D.19997>:
      D.19999 = ctx->report_error;
      if (D.19999 != 0) goto <D.20000>; else goto <D.20001>;
      <D.20000>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.19996 = it.size;
        D.20002 = monoeg_g_strdup_printf ("Import table size %d is smaller than 40", D.19996);
        vinfo->info.message = D.20002;
        vinfo->exception_type = 3;
        D.20003 = ctx->errors;
        D.20004 = monoeg_g_slist_prepend (D.20003, vinfo);
        ctx->errors = D.20004;
      }
      <D.20001>:
      ctx->valid = 0;
      return;
      <D.19998>:
      ilt_rva = MEM[(const guint32 *)ptr];
      if (ilt_rva != 0) goto <D.20005>; else goto <D.20006>;
      <D.20005>:
      D.20007 = bounds_check_virtual_address (ctx, ilt_rva, 8);
      if (D.20007 == 0) goto <D.20008>; else goto <D.20009>;
      <D.20008>:
      D.19999 = ctx->report_error;
      if (D.19999 != 0) goto <D.20010>; else goto <D.20011>;
      <D.20010>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20012 = monoeg_g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva);
        vinfo->info.message = D.20012;
        vinfo->exception_type = 3;
        D.20003 = ctx->errors;
        D.20013 = monoeg_g_slist_prepend (D.20003, vinfo);
        ctx->errors = D.20013;
      }
      <D.20011>:
      ctx->valid = 0;
      return;
      <D.20009>:
      <D.20006>:
      name_rva = MEM[(const guint32 *)ptr + 12B];
      if (name_rva != 0) goto <D.20014>; else goto <D.20015>;
      <D.20014>:
      D.20016 = bounds_check_virtual_address (ctx, name_rva, 12);
      if (D.20016 == 0) goto <D.20017>; else goto <D.20018>;
      <D.20017>:
      D.19999 = ctx->report_error;
      if (D.19999 != 0) goto <D.20019>; else goto <D.20020>;
      <D.20019>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20021 = monoeg_g_strdup_printf ("Invalid Import Table Name rva %x", name_rva);
        vinfo->info.message = D.20021;
        vinfo->exception_type = 3;
        D.20003 = ctx->errors;
        D.20022 = monoeg_g_slist_prepend (D.20003, vinfo);
        ctx->errors = D.20022;
      }
      <D.20020>:
      ctx->valid = 0;
      return;
      <D.20018>:
      <D.20015>:
      iat_rva = MEM[(const guint32 *)ptr + 16B];
      if (iat_rva != 0) goto <D.20023>; else goto <D.20024>;
      <D.20023>:
      D.20025 = bounds_check_virtual_address (ctx, iat_rva, 8);
      if (D.20025 == 0) goto <D.20026>; else goto <D.20027>;
      <D.20026>:
      D.19999 = ctx->report_error;
      if (D.19999 != 0) goto <D.20028>; else goto <D.20029>;
      <D.20028>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20030 = monoeg_g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva);
        vinfo->info.message = D.20030;
        vinfo->exception_type = 3;
        D.20003 = ctx->errors;
        D.20031 = monoeg_g_slist_prepend (D.20003, vinfo);
        ctx->errors = D.20031;
      }
      <D.20029>:
      ctx->valid = 0;
      return;
      <D.20027>:
      D.20032 = ctx->data_directories[12].rva;
      if (D.20032 != iat_rva) goto <D.20033>; else goto <D.20034>;
      <D.20033>:
      D.19999 = ctx->report_error;
      if (D.19999 != 0) goto <D.20035>; else goto <D.20036>;
      <D.20035>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20032 = ctx->data_directories[12].rva;
        D.20037 = ptr + 16;
        D.20038 = *D.20037;
        D.20039 = monoeg_g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", D.20038, D.20032);
        vinfo->info.message = D.20039;
        vinfo->exception_type = 3;
        D.20003 = ctx->errors;
        D.20040 = monoeg_g_slist_prepend (D.20003, vinfo);
        ctx->errors = D.20040;
      }
      <D.20036>:
      ctx->valid = 0;
      return;
      <D.20034>:
      <D.20024>:
      if (name_rva != 0) goto <D.20041>; else goto <D.20042>;
      <D.20041>:
      name_rva = translate_rva (ctx, name_rva);
      D.20043 = name_rva == 4294967295;
      D.20044 = (long int) D.20043;
      D.20045 = __builtin_expect (D.20044, 0);
      if (D.20045 != 0) goto <D.20046>; else goto <D.20047>;
      <D.20046>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 636, "name_rva != INVALID_OFFSET");
      <D.20047>:
      D.19989 = ctx->data;
      D.20048 = (sizetype) name_rva;
      ptr = D.19989 + D.20048;
      D.20049 = memcmp ("mscoree.dll", ptr, 12);
      if (D.20049 != 0) goto <D.20050>; else goto <D.20051>;
      <D.20050>:
      {
        char name[12];

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

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.20054 = monoeg_g_strdup_printf ("Invalid Import Table Name: \'%s\'", &name);
              vinfo->info.message = D.20054;
              vinfo->exception_type = 3;
              D.20003 = ctx->errors;
              D.20055 = monoeg_g_slist_prepend (D.20003, vinfo);
              ctx->errors = D.20055;
            }
            <D.20053>:
            ctx->valid = 0;
            return;
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      <D.20051>:
      <D.20042>:
      if (ilt_rva != 0) goto <D.20056>; else goto <D.20057>;
      <D.20056>:
      verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
      D.20058 = ctx->valid;
      if (D.20058 == 0) goto <D.20059>; else goto <D.20060>;
      <D.20059>:
      return;
      <D.20060>:
      <D.20057>:
      if (iat_rva != 0) goto <D.20061>; else goto <D.20062>;
      <D.20061>:
      verify_hint_name_table (ctx, iat_rva, "Import Address Table");
      <D.20062>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.20067;
  long unsigned int D.20068;

  D.20068 = __builtin_object_size (__dest, 0);
  D.20067 = __builtin___memcpy_chk (__dest, __src, __len, D.20068);
  return D.20067;
}


verify_hint_name_table (struct VerifyContext * ctx, guint32 import_rva, const char * table_name)
{
  _Bool D.20070;
  long int D.20071;
  long int D.20072;
  const char * D.20075;
  sizetype D.20076;
  const guint32 * D.20077;
  int D.20078;
  int D.20081;
  gchar * D.20084;
  struct GSList * D.20085;
  struct GSList * D.20086;
  _Bool D.20087;
  long int D.20088;
  long int D.20089;
  sizetype D.20092;
  sizetype D.20093;
  int D.20094;
  int D.20097;
  gchar * D.20102;
  struct GSList * D.20103;
  const char * ptr;
  guint32 hint_table_rva;

  import_rva = translate_rva (ctx, import_rva);
  D.20070 = import_rva == 4294967295;
  D.20071 = (long int) D.20070;
  D.20072 = __builtin_expect (D.20071, 0);
  if (D.20072 != 0) goto <D.20073>; else goto <D.20074>;
  <D.20073>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 586, "import_rva != INVALID_OFFSET");
  <D.20074>:
  D.20075 = ctx->data;
  D.20076 = (sizetype) import_rva;
  D.20077 = D.20075 + D.20076;
  hint_table_rva = *D.20077;
  D.20078 = bounds_check_virtual_address (ctx, hint_table_rva, 14);
  if (D.20078 == 0) goto <D.20079>; else goto <D.20080>;
  <D.20079>:
  D.20081 = ctx->report_error;
  if (D.20081 != 0) goto <D.20082>; else goto <D.20083>;
  <D.20082>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20084 = monoeg_g_strdup_printf ("Invalid Hint/Name rva %d for %s", hint_table_rva, table_name);
    vinfo->info.message = D.20084;
    vinfo->exception_type = 3;
    D.20085 = ctx->errors;
    D.20086 = monoeg_g_slist_prepend (D.20085, vinfo);
    ctx->errors = D.20086;
  }
  <D.20083>:
  ctx->valid = 0;
  return;
  <D.20080>:
  hint_table_rva = translate_rva (ctx, hint_table_rva);
  D.20087 = hint_table_rva == 4294967295;
  D.20088 = (long int) D.20087;
  D.20089 = __builtin_expect (D.20088, 0);
  if (D.20089 != 0) goto <D.20090>; else goto <D.20091>;
  <D.20090>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 593, "hint_table_rva != INVALID_OFFSET");
  <D.20091>:
  D.20075 = ctx->data;
  D.20092 = (sizetype) hint_table_rva;
  D.20093 = D.20092 + 2;
  ptr = D.20075 + D.20093;
  D.20094 = memcmp ("_CorExeMain", ptr, 12);
  if (D.20094 != 0) goto <D.20095>; else goto <D.20096>;
  <D.20095>:
  D.20097 = memcmp ("_CorDllMain", ptr, 12);
  if (D.20097 != 0) goto <D.20098>; else goto <D.20099>;
  <D.20098>:
  {
    char name[12];

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

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20102 = monoeg_g_strdup_printf ("Invalid Hint / Name: \'%s\'", &name);
          vinfo->info.message = D.20102;
          vinfo->exception_type = 3;
          D.20085 = ctx->errors;
          D.20103 = monoeg_g_slist_prepend (D.20085, vinfo);
          ctx->errors = D.20103;
        }
        <D.20101>:
        ctx->valid = 0;
        return;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.20099>:
  <D.20096>:
}


verify_resources_table (struct VerifyContext * ctx)
{
  unsigned int D.20106;
  unsigned int D.20109;
  int D.20112;
  gchar * D.20115;
  struct GSList * D.20116;
  struct GSList * D.20117;
  const char * D.20118;
  sizetype D.20119;
  sizetype D.20120;
  _Bool D.20121;
  long int D.20122;
  long int D.20123;
  int D.20126;
  int D.20127;
  int D.20128;
  int D.20129;
  int D.20130;
  unsigned int D.20131;
  gchar * D.20136;
  struct GSList * D.20137;
  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.20106 = it.rva;
      if (D.20106 == 0) goto <D.20107>; else goto <D.20108>;
      <D.20107>:
      return;
      <D.20108>:
      D.20109 = it.size;
      if (D.20109 <= 15) goto <D.20110>; else goto <D.20111>;
      <D.20110>:
      D.20112 = ctx->report_error;
      if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
      <D.20113>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20109 = it.size;
        D.20115 = monoeg_g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it\'s %d long", D.20109);
        vinfo->info.message = D.20115;
        vinfo->exception_type = 3;
        D.20116 = ctx->errors;
        D.20117 = monoeg_g_slist_prepend (D.20116, vinfo);
        ctx->errors = D.20117;
      }
      <D.20114>:
      ctx->valid = 0;
      return;
      <D.20111>:
      offset = it.translated_offset;
      D.20118 = ctx->data;
      D.20119 = (sizetype) offset;
      ptr = D.20118 + D.20119;
      root = ptr;
      D.20109 = it.size;
      D.20120 = (sizetype) D.20109;
      end = root + D.20120;
      D.20121 = offset == 4294967295;
      D.20122 = (long int) D.20121;
      D.20123 = __builtin_expect (D.20122, 0);
      if (D.20123 != 0) goto <D.20124>; else goto <D.20125>;
      <D.20124>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 674, "offset != INVALID_OFFSET");
      <D.20125>:
      named_entries = MEM[(const guint16 *)ptr + 12B];
      id_entries = MEM[(const guint16 *)ptr + 14B];
      D.20126 = (int) named_entries;
      D.20127 = (int) id_entries;
      D.20128 = D.20126 + D.20127;
      D.20129 = D.20128 + 2;
      D.20130 = D.20129 * 8;
      D.20131 = (unsigned int) D.20130;
      D.20109 = it.size;
      if (D.20131 > D.20109) goto <D.20132>; else goto <D.20133>;
      <D.20132>:
      D.20112 = ctx->report_error;
      if (D.20112 != 0) goto <D.20134>; else goto <D.20135>;
      <D.20134>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20109 = it.size;
        D.20126 = (int) named_entries;
        D.20127 = (int) id_entries;
        D.20128 = D.20126 + D.20127;
        D.20136 = monoeg_g_strdup_printf ("Resource section is too small, the number of entries (%d) doesn\'t fit on it\'s size %d", D.20128, D.20109);
        vinfo->info.message = D.20136;
        vinfo->exception_type = 3;
        D.20116 = ctx->errors;
        D.20137 = monoeg_g_slist_prepend (D.20116, vinfo);
        ctx->errors = D.20137;
      }
      <D.20135>:
      ctx->valid = 0;
      return;
      <D.20133>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


cleanup_context (struct VerifyContext * ctx, struct GSList * * error_list)
{
  struct SectionHeader * D.20141;
  struct GSList * D.20144;
  gboolean D.20146;

  D.20141 = ctx->sections;
  monoeg_g_free (D.20141);
  if (error_list != 0B) goto <D.20142>; else goto <D.20143>;
  <D.20142>:
  D.20144 = ctx->errors;
  *error_list = D.20144;
  goto <D.20145>;
  <D.20143>:
  D.20144 = ctx->errors;
  mono_free_verify_list (D.20144);
  <D.20145>:
  D.20146 = ctx->valid;
  return D.20146;
}


mono_verifier_verify_cli_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20148;
  gboolean D.20151;
  _Bool D.20152;
  int D.20153;
  int D.20154;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.20148 = mono_verifier_is_enabled_for_image (image);
      if (D.20148 == 0) goto <D.20149>; else goto <D.20150>;
      <D.20149>:
      D.20151 = 1;
      return D.20151;
      <D.20150>:
      D.20152 = error_list != 0B;
      D.20153 = (int) D.20152;
      init_verify_context (&ctx, image, D.20153);
      ctx.stage = 1;
      verify_cli_header (&ctx);
      D.20154 = ctx.valid;
      if (D.20154 == 0) goto cleanup; else goto <D.20155>;
      <D.20155>:
      verify_metadata_header (&ctx);
      D.20154 = ctx.valid;
      if (D.20154 == 0) goto cleanup; else goto <D.20156>;
      <D.20156>:
      verify_tables_schema (&ctx);
      cleanup:
      D.20151 = cleanup_context (&ctx, error_list);
      return D.20151;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_cli_header (struct VerifyContext * ctx)
{
  unsigned int D.20159;
  int D.20162;
  gchar * D.20165;
  struct GSList * D.20166;
  struct GSList * D.20167;
  unsigned int D.20168;
  gchar * D.20173;
  struct GSList * D.20174;
  const char * D.20175;
  sizetype D.20176;
  _Bool D.20177;
  long int D.20178;
  long int D.20179;
  short unsigned int D.20182;
  int D.20187;
  gchar * D.20188;
  struct GSList * D.20189;
  const guint32 * D.20190;
  unsigned int D.20191;
  const guint32 * D.20192;
  unsigned int D.20193;
  int D.20194;
  gchar * D.20199;
  struct GSList * D.20200;
  gchar * D.20206;
  struct GSList * D.20207;
  const guint32 * D.20208;
  unsigned int D.20209;
  unsigned int D.20210;
  gchar * D.20215;
  struct GSList * D.20216;
  int D.20219;
  gchar * D.20224;
  struct GSList * D.20225;
  _Bool D.20226;
  _Bool D.20227;
  _Bool D.20228;
  gchar * D.20233;
  struct GSList * D.20234;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  int i;

  try
    {
      it = get_data_dir (ctx, 14);
      D.20159 = it.rva;
      if (D.20159 == 0) goto <D.20160>; else goto <D.20161>;
      <D.20160>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20163>; else goto <D.20164>;
      <D.20163>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20165 = monoeg_g_strdup_printf ("CLI header missing");
        vinfo->info.message = D.20165;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20167 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20167;
      }
      <D.20164>:
      ctx->valid = 0;
      return;
      <D.20161>:
      D.20168 = it.size;
      if (D.20168 != 72) goto <D.20169>; else goto <D.20170>;
      <D.20169>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20171>; else goto <D.20172>;
      <D.20171>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20168 = it.size;
        D.20173 = monoeg_g_strdup_printf ("Invalid cli header size in data directory %d must be 72", D.20168);
        vinfo->info.message = D.20173;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20174 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20174;
      }
      <D.20172>:
      ctx->valid = 0;
      return;
      <D.20170>:
      offset = it.translated_offset;
      D.20175 = ctx->data;
      D.20176 = (sizetype) offset;
      ptr = D.20175 + D.20176;
      D.20177 = offset == 4294967295;
      D.20178 = (long int) D.20177;
      D.20179 = __builtin_expect (D.20178, 0);
      if (D.20179 != 0) goto <D.20180>; else goto <D.20181>;
      <D.20180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 721, "offset != INVALID_OFFSET");
      <D.20181>:
      D.20182 = MEM[(const guint16 *)ptr];
      if (D.20182 != 72) goto <D.20183>; else goto <D.20184>;
      <D.20183>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20185>; else goto <D.20186>;
      <D.20185>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20182 = MEM[(const guint16 *)ptr];
        D.20187 = (int) D.20182;
        D.20188 = monoeg_g_strdup_printf ("Invalid cli header size %d must be 72", D.20187);
        vinfo->info.message = D.20188;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20189 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20189;
      }
      <D.20186>:
      ctx->valid = 0;
      return;
      <D.20184>:
      D.20190 = ptr + 12;
      D.20191 = *D.20190;
      D.20192 = ptr + 8;
      D.20193 = *D.20192;
      D.20194 = bounds_check_virtual_address (ctx, D.20193, D.20191);
      if (D.20194 == 0) goto <D.20195>; else goto <D.20196>;
      <D.20195>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20197>; else goto <D.20198>;
      <D.20197>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20190 = ptr + 12;
        D.20191 = *D.20190;
        D.20192 = ptr + 8;
        D.20193 = *D.20192;
        D.20199 = monoeg_g_strdup_printf ("Invalid medatata section rva/size pair %x/%x", D.20193, D.20191);
        vinfo->info.message = D.20199;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20200 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20200;
      }
      <D.20198>:
      ctx->valid = 0;
      return;
      <D.20196>:
      D.20192 = ptr + 8;
      D.20193 = *D.20192;
      if (D.20193 == 0) goto <D.20201>; else goto <D.20203>;
      <D.20203>:
      D.20190 = ptr + 12;
      D.20191 = *D.20190;
      if (D.20191 == 0) goto <D.20201>; else goto <D.20202>;
      <D.20201>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20204>; else goto <D.20205>;
      <D.20204>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20206 = monoeg_g_strdup_printf ("Missing medatata section in the CLI header");
        vinfo->info.message = D.20206;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20207 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20207;
      }
      <D.20205>:
      ctx->valid = 0;
      return;
      <D.20202>:
      D.20208 = ptr + 16;
      D.20209 = *D.20208;
      D.20210 = D.20209 & 4294901748;
      if (D.20210 != 0) goto <D.20211>; else goto <D.20212>;
      <D.20211>:
      D.20162 = ctx->report_error;
      if (D.20162 != 0) goto <D.20213>; else goto <D.20214>;
      <D.20213>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20215 = monoeg_g_strdup_printf ("Invalid CLI header flags");
        vinfo->info.message = D.20215;
        vinfo->exception_type = 3;
        D.20166 = ctx->errors;
        D.20216 = monoeg_g_slist_prepend (D.20166, vinfo);
        ctx->errors = D.20216;
      }
      <D.20214>:
      ctx->valid = 0;
      return;
      <D.20212>:
      ptr = ptr + 24;
      i = 0;
      goto <D.17914>;
      <D.17913>:
      {
        guint32 rva;
        guint32 size;

        rva = MEM[(const guint32 *)ptr];
        size = MEM[(const guint32 *)ptr + 4B];
        if (rva != 0) goto <D.20217>; else goto <D.20218>;
        <D.20217>:
        D.20219 = bounds_check_virtual_address (ctx, rva, size);
        if (D.20219 == 0) goto <D.20220>; else goto <D.20221>;
        <D.20220>:
        D.20162 = ctx->report_error;
        if (D.20162 != 0) goto <D.20222>; else goto <D.20223>;
        <D.20222>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20224 = monoeg_g_strdup_printf ("Invalid cli section %i rva/size pair %x/%x", i, rva, size);
          vinfo->info.message = D.20224;
          vinfo->exception_type = 3;
          D.20166 = ctx->errors;
          D.20225 = monoeg_g_slist_prepend (D.20166, vinfo);
          ctx->errors = D.20225;
        }
        <D.20223>:
        ctx->valid = 0;
        return;
        <D.20221>:
        <D.20218>:
        ptr = ptr + 8;
        D.20226 = rva != 0;
        D.20227 = i > 1;
        D.20228 = D.20226 & D.20227;
        if (D.20228 != 0) goto <D.20229>; else goto <D.20230>;
        <D.20229>:
        D.20162 = ctx->report_error;
        if (D.20162 != 0) goto <D.20231>; else goto <D.20232>;
        <D.20231>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20233 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t support cli header section %d", i);
          vinfo->info.message = D.20233;
          vinfo->exception_type = 3;
          D.20166 = ctx->errors;
          D.20234 = monoeg_g_slist_prepend (D.20166, vinfo);
          ctx->errors = D.20234;
        }
        <D.20232>:
        ctx->valid = 0;
        return;
        <D.20230>:
      }
      i = i + 1;
      <D.17914>:
      if (i <= 5) goto <D.17913>; else goto <D.17915>;
      <D.17915>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


get_data_dir (struct VerifyContext * ctx, int idx)
{
  struct MonoImage * D.20238;
  long unsigned int D.20239;
  long unsigned int D.20240;
  unsigned int D.20241;
  unsigned int D.20242;
  unsigned int D.20243;
  unsigned int D.20244;
  struct DataDirectory D.20245;
  struct MonoCLIImageInfo * iinfo;
  struct MonoPEDirEntry * entry;
  struct DataDirectory res;

  try
    {
      D.20238 = ctx->image;
      iinfo = D.20238->image_info;
      entry = &iinfo->cli_header.datadir.pe_export_table;
      D.20239 = (long unsigned int) idx;
      D.20240 = D.20239 * 8;
      entry = entry + D.20240;
      D.20241 = entry->rva;
      res.rva = D.20241;
      D.20242 = entry->size;
      res.size = D.20242;
      D.20243 = res.rva;
      D.20244 = translate_rva (ctx, D.20243);
      res.translated_offset = D.20244;
      D.20245 = res;
      return D.20245;
    }
  finally
    {
      res = {CLOBBER};
    }
}


verify_metadata_header (struct VerifyContext * ctx)
{
  const char * D.20248;
  sizetype D.20249;
  _Bool D.20250;
  long int D.20251;
  long int D.20252;
  unsigned int D.20255;
  unsigned int D.20256;
  unsigned int D.20259;
  int D.20262;
  gchar * D.20265;
  struct GSList * D.20266;
  struct GSList * D.20267;
  gchar * D.20272;
  struct GSList * D.20273;
  const guint32 * D.20274;
  unsigned int D.20275;
  unsigned int D.20276;
  unsigned int D.20277;
  int D.20278;
  unsigned int D.20283;
  unsigned int D.20284;
  unsigned int D.20285;
  gchar * D.20286;
  struct GSList * D.20287;
  const guint16 * D.20288;
  short unsigned int D.20289;
  gchar * D.20294;
  struct GSList * D.20295;
  int D.20296;
  unsigned int D.20301;
  gchar * D.20302;
  struct GSList * D.20303;
  int D.20304;
  gchar * D.20309;
  struct GSList * D.20310;
  unsigned int offset.5;
  int D.20312;
  gchar * D.20317;
  struct GSList * D.20318;
  sizetype D.20319;
  const char * D.20320;
  char D.20321;
  gchar * D.20327;
  struct GSList * D.20328;
  int D.17950;
  int iftmp.6;
  int D.17946;
  const char[9] * D.20332;
  unsigned char D.20333;
  int D.20334;
  unsigned char D.20335;
  int D.20336;
  _Bool D.20337;
  _Bool D.20338;
  _Bool D.20339;
  const unsigned char * D.20342;
  unsigned char D.20343;
  int D.20344;
  const unsigned char * D.20345;
  unsigned char D.20346;
  int D.20347;
  _Bool D.20348;
  _Bool D.20349;
  const unsigned char * D.20352;
  unsigned char D.20353;
  int D.20354;
  const unsigned char * D.20355;
  unsigned char D.20356;
  int D.20357;
  _Bool D.20358;
  _Bool D.20359;
  const unsigned char * D.20362;
  unsigned char D.20363;
  int D.20364;
  const unsigned char * D.20365;
  unsigned char D.20366;
  int D.20367;
  int D.17959;
  int iftmp.7;
  int D.17955;
  const char[4] * D.20375;
  unsigned char D.20376;
  int D.20377;
  unsigned char D.20378;
  int D.20379;
  _Bool D.20380;
  _Bool D.20381;
  _Bool D.20382;
  const unsigned char * D.20385;
  unsigned char D.20386;
  int D.20387;
  const unsigned char * D.20388;
  unsigned char D.20389;
  int D.20390;
  _Bool D.20391;
  _Bool D.20392;
  const unsigned char * D.20395;
  unsigned char D.20396;
  int D.20397;
  const unsigned char * D.20398;
  unsigned char D.20399;
  int D.20400;
  _Bool D.20401;
  _Bool D.20402;
  const unsigned char * D.20405;
  unsigned char D.20406;
  int D.20407;
  const unsigned char * D.20408;
  unsigned char D.20409;
  int D.20410;
  int D.17968;
  int iftmp.8;
  int D.17964;
  const char[6] * D.20418;
  unsigned char D.20419;
  int D.20420;
  unsigned char D.20421;
  int D.20422;
  _Bool D.20423;
  _Bool D.20424;
  _Bool D.20425;
  const unsigned char * D.20428;
  unsigned char D.20429;
  int D.20430;
  const unsigned char * D.20431;
  unsigned char D.20432;
  int D.20433;
  _Bool D.20434;
  _Bool D.20435;
  const unsigned char * D.20438;
  unsigned char D.20439;
  int D.20440;
  const unsigned char * D.20441;
  unsigned char D.20442;
  int D.20443;
  _Bool D.20444;
  _Bool D.20445;
  const unsigned char * D.20448;
  unsigned char D.20449;
  int D.20450;
  const unsigned char * D.20451;
  unsigned char D.20452;
  int D.20453;
  int D.17977;
  int iftmp.9;
  int D.17973;
  const char[6] * D.20461;
  unsigned char D.20462;
  int D.20463;
  unsigned char D.20464;
  int D.20465;
  _Bool D.20466;
  _Bool D.20467;
  _Bool D.20468;
  const unsigned char * D.20471;
  unsigned char D.20472;
  int D.20473;
  const unsigned char * D.20474;
  unsigned char D.20475;
  int D.20476;
  _Bool D.20477;
  _Bool D.20478;
  const unsigned char * D.20481;
  unsigned char D.20482;
  int D.20483;
  const unsigned char * D.20484;
  unsigned char D.20485;
  int D.20486;
  _Bool D.20487;
  _Bool D.20488;
  const unsigned char * D.20491;
  unsigned char D.20492;
  int D.20493;
  const unsigned char * D.20494;
  unsigned char D.20495;
  int D.20496;
  int D.17986;
  int iftmp.10;
  int D.17982;
  const char[3] * D.20504;
  unsigned char D.20505;
  int D.20506;
  unsigned char D.20507;
  int D.20508;
  _Bool D.20509;
  _Bool D.20510;
  _Bool D.20511;
  const unsigned char * D.20514;
  unsigned char D.20515;
  int D.20516;
  const unsigned char * D.20517;
  unsigned char D.20518;
  int D.20519;
  _Bool D.20520;
  _Bool D.20521;
  const unsigned char * D.20524;
  unsigned char D.20525;
  int D.20526;
  const unsigned char * D.20527;
  unsigned char D.20528;
  int D.20529;
  _Bool D.20530;
  _Bool D.20531;
  const unsigned char * D.20534;
  unsigned char D.20535;
  int D.20536;
  const unsigned char * D.20537;
  unsigned char D.20538;
  int D.20539;
  int D.20544;
  gchar * D.20547;
  struct GSList * D.20548;
  unsigned int D.20549;
  gchar * D.20554;
  struct GSList * D.20555;
  unsigned int i.11;
  unsigned int D.20557;
  gchar * D.20562;
  struct GSList * D.20563;
  unsigned int D.20564;
  gchar * D.20569;
  struct GSList * D.20570;
  int i;
  struct DataDirectory it;
  guint32 offset;
  guint32 section_count;
  const char * ptr;

  try
    {
      it = get_data_dir (ctx, 14);
      offset = it.translated_offset;
      D.20248 = ctx->data;
      D.20249 = (sizetype) offset;
      ptr = D.20248 + D.20249;
      D.20250 = offset == 4294967295;
      D.20251 = (long int) D.20250;
      D.20252 = __builtin_expect (D.20251, 0);
      if (D.20252 != 0) goto <D.20253>; else goto <D.20254>;
      <D.20253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 769, "offset != INVALID_OFFSET");
      <D.20254>:
      ptr = ptr + 8;
      D.20255 = MEM[(const guint32 *)ptr];
      it.rva = D.20255;
      ptr = ptr + 4;
      D.20255 = MEM[(const guint32 *)ptr];
      it.size = D.20255;
      D.20256 = it.rva;
      offset = translate_rva (ctx, D.20256);
      it.translated_offset = offset;
      D.20248 = ctx->data;
      D.20249 = (sizetype) offset;
      ptr = D.20248 + D.20249;
      D.20250 = offset == 4294967295;
      D.20251 = (long int) D.20250;
      D.20252 = __builtin_expect (D.20251, 0);
      if (D.20252 != 0) goto <D.20257>; else goto <D.20258>;
      <D.20257>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 779, "offset != INVALID_OFFSET");
      <D.20258>:
      D.20259 = it.size;
      if (D.20259 <= 19) goto <D.20260>; else goto <D.20261>;
      <D.20260>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20263>; else goto <D.20264>;
      <D.20263>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20259 = it.size;
        D.20265 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least 20 bytes required for initial decoding)", D.20259);
        vinfo->info.message = D.20265;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20267 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20267;
      }
      <D.20264>:
      ctx->valid = 0;
      return;
      <D.20261>:
      D.20255 = MEM[(const guint32 *)ptr];
      if (D.20255 != 1112167234) goto <D.20268>; else goto <D.20269>;
      <D.20268>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20270>; else goto <D.20271>;
      <D.20270>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20255 = MEM[(const guint32 *)ptr];
        D.20272 = monoeg_g_strdup_printf ("Invalid metadata signature, expected 0x424A5342 but got %08x", D.20255);
        vinfo->info.message = D.20272;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20273 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20273;
      }
      <D.20271>:
      ctx->valid = 0;
      return;
      <D.20269>:
      D.20274 = ptr + 12;
      D.20275 = *D.20274;
      D.20276 = D.20275 + offset;
      D.20277 = D.20276 + 16;
      offset = pad4 (D.20277);
      D.20278 = bounds_check_datadir (&it, offset, 4);
      if (D.20278 == 0) goto <D.20279>; else goto <D.20280>;
      <D.20279>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20281>; else goto <D.20282>;
      <D.20281>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20283 = it.translated_offset;
        D.20284 = offset - D.20283;
        D.20285 = D.20284 + 4;
        D.20259 = it.size;
        D.20286 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least %d bytes required for flags decoding)", D.20259, D.20285);
        vinfo->info.message = D.20286;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20287 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20287;
      }
      <D.20282>:
      ctx->valid = 0;
      return;
      <D.20280>:
      D.20248 = ctx->data;
      D.20249 = (sizetype) offset;
      ptr = D.20248 + D.20249;
      D.20288 = ptr + 2;
      D.20289 = *D.20288;
      section_count = (guint32) D.20289;
      if (section_count <= 1) goto <D.20290>; else goto <D.20291>;
      <D.20290>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20292>; else goto <D.20293>;
      <D.20292>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20294 = monoeg_g_strdup_printf ("Metadata root section must have at least 2 streams (#~ and #GUID)");
        vinfo->info.message = D.20294;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20295 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20295;
      }
      <D.20293>:
      ctx->valid = 0;
      return;
      <D.20291>:
      ptr = ptr + 4;
      offset = offset + 4;
      i = 0;
      goto <D.17991>;
      <D.17990>:
      {
        guint32 stream_off;
        guint32 stream_size;
        int string_size;
        int stream_idx;

        D.20296 = bounds_check_datadir (&it, offset, 8);
        if (D.20296 == 0) goto <D.20297>; else goto <D.20298>;
        <D.20297>:
        D.20262 = ctx->report_error;
        if (D.20262 != 0) goto <D.20299>; else goto <D.20300>;
        <D.20299>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20283 = it.translated_offset;
          D.20284 = offset - D.20283;
          D.20301 = D.20284 + 9;
          D.20302 = monoeg_g_strdup_printf ("Metadata root section is too small for initial decode of stream header %d, missing %d bytes", i, D.20301);
          vinfo->info.message = D.20302;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20303 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20303;
        }
        <D.20300>:
        ctx->valid = 0;
        return;
        <D.20298>:
        D.20283 = it.translated_offset;
        D.20255 = MEM[(const guint32 *)ptr];
        stream_off = D.20283 + D.20255;
        stream_size = MEM[(const guint32 *)ptr + 4B];
        D.20304 = bounds_check_datadir (&it, stream_off, stream_size);
        if (D.20304 == 0) goto <D.20305>; else goto <D.20306>;
        <D.20305>:
        D.20262 = ctx->report_error;
        if (D.20262 != 0) goto <D.20307>; else goto <D.20308>;
        <D.20307>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20309 = monoeg_g_strdup_printf ("Invalid stream header %d offset/size pair %x/%x", 0, stream_off, stream_size);
          vinfo->info.message = D.20309;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20310 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20310;
        }
        <D.20308>:
        ctx->valid = 0;
        return;
        <D.20306>:
        ptr = ptr + 8;
        offset = offset + 8;
        string_size = 0;
        goto <D.17940>;
        <D.17939>:
        offset.5 = offset;
        offset = offset.5 + 1;
        D.20312 = bounds_check_datadir (&it, offset.5, 1);
        if (D.20312 == 0) goto <D.20313>; else goto <D.20314>;
        <D.20313>:
        D.20262 = ctx->report_error;
        if (D.20262 != 0) goto <D.20315>; else goto <D.20316>;
        <D.20315>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20317 = monoeg_g_strdup_printf ("Metadata root section is too small to decode stream header %d name", i);
          vinfo->info.message = D.20317;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20318 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20318;
        }
        <D.20316>:
        ctx->valid = 0;
        return;
        <D.20314>:
        D.20319 = (sizetype) string_size;
        D.20320 = ptr + D.20319;
        D.20321 = *D.20320;
        if (D.20321 == 0) goto <D.17938>; else goto <D.20322>;
        <D.20322>:
        string_size = string_size + 1;
        <D.17940>:
        if (string_size <= 31) goto <D.17939>; else goto <D.17938>;
        <D.17938>:
        D.20319 = (sizetype) string_size;
        D.20320 = ptr + D.20319;
        D.20321 = *D.20320;
        if (D.20321 != 0) goto <D.20323>; else goto <D.20324>;
        <D.20323>:
        D.20262 = ctx->report_error;
        if (D.20262 != 0) goto <D.20325>; else goto <D.20326>;
        <D.20325>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20327 = monoeg_g_strdup_printf ("Metadata stream header %d name larger than 32 bytes", i);
          vinfo->info.message = D.20327;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20328 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20328;
        }
        <D.20326>:
        ctx->valid = 0;
        return;
        <D.20324>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20332 = "#Strings";
            D.20333 = MEM[(const unsigned char *)D.20332];
            D.20334 = (int) D.20333;
            D.20335 = *__s2;
            D.20336 = (int) D.20335;
            __result = D.20334 - D.20336;
            {
              D.20337 = __s1_len != 0;
              D.20338 = __result == 0;
              D.20339 = D.20337 & D.20338;
              if (D.20339 != 0) goto <D.20340>; else goto <D.20341>;
              <D.20340>:
              D.20342 = &MEM[(void *)"#Strings" + 1B];
              D.20343 = *D.20342;
              D.20344 = (int) D.20343;
              D.20345 = __s2 + 1;
              D.20346 = *D.20345;
              D.20347 = (int) D.20346;
              __result = D.20344 - D.20347;
              D.20348 = __s1_len > 1;
              D.20338 = __result == 0;
              D.20349 = D.20348 & D.20338;
              if (D.20349 != 0) goto <D.20350>; else goto <D.20351>;
              <D.20350>:
              D.20352 = &MEM[(void *)"#Strings" + 2B];
              D.20353 = *D.20352;
              D.20354 = (int) D.20353;
              D.20355 = __s2 + 2;
              D.20356 = *D.20355;
              D.20357 = (int) D.20356;
              __result = D.20354 - D.20357;
              D.20358 = __s1_len > 2;
              D.20338 = __result == 0;
              D.20359 = D.20358 & D.20338;
              if (D.20359 != 0) goto <D.20360>; else goto <D.20361>;
              <D.20360>:
              D.20362 = &MEM[(void *)"#Strings" + 3B];
              D.20363 = *D.20362;
              D.20364 = (int) D.20363;
              D.20365 = __s2 + 3;
              D.20366 = *D.20365;
              D.20367 = (int) D.20366;
              __result = D.20364 - D.20367;
              <D.20361>:
              <D.20351>:
              <D.20341>:
            }
            D.17946 = __result;
          }
          iftmp.6 = D.17946;
          goto <D.20368>;
          <D.20331>:
          iftmp.6 = __builtin_strcmp ("#Strings", ptr);
          <D.20368>:
          D.17950 = iftmp.6;
        }
        if (D.17950 == 0) goto <D.20369>; else goto <D.20370>;
        <D.20369>:
        stream_idx = 0;
        goto <D.20371>;
        <D.20370>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20375 = "#US";
            D.20376 = MEM[(const unsigned char *)D.20375];
            D.20377 = (int) D.20376;
            D.20378 = *__s2;
            D.20379 = (int) D.20378;
            __result = D.20377 - D.20379;
            {
              D.20380 = __s1_len != 0;
              D.20381 = __result == 0;
              D.20382 = D.20380 & D.20381;
              if (D.20382 != 0) goto <D.20383>; else goto <D.20384>;
              <D.20383>:
              D.20385 = &MEM[(void *)"#US" + 1B];
              D.20386 = *D.20385;
              D.20387 = (int) D.20386;
              D.20388 = __s2 + 1;
              D.20389 = *D.20388;
              D.20390 = (int) D.20389;
              __result = D.20387 - D.20390;
              D.20391 = __s1_len > 1;
              D.20381 = __result == 0;
              D.20392 = D.20391 & D.20381;
              if (D.20392 != 0) goto <D.20393>; else goto <D.20394>;
              <D.20393>:
              D.20395 = &MEM[(void *)"#US" + 2B];
              D.20396 = *D.20395;
              D.20397 = (int) D.20396;
              D.20398 = __s2 + 2;
              D.20399 = *D.20398;
              D.20400 = (int) D.20399;
              __result = D.20397 - D.20400;
              D.20401 = __s1_len > 2;
              D.20381 = __result == 0;
              D.20402 = D.20401 & D.20381;
              if (D.20402 != 0) goto <D.20403>; else goto <D.20404>;
              <D.20403>:
              D.20405 = &MEM[(void *)"#US" + 3B];
              D.20406 = *D.20405;
              D.20407 = (int) D.20406;
              D.20408 = __s2 + 3;
              D.20409 = *D.20408;
              D.20410 = (int) D.20409;
              __result = D.20407 - D.20410;
              <D.20404>:
              <D.20394>:
              <D.20384>:
            }
            D.17955 = __result;
          }
          iftmp.7 = D.17955;
          goto <D.20411>;
          <D.20374>:
          iftmp.7 = __builtin_strcmp ("#US", ptr);
          <D.20411>:
          D.17959 = iftmp.7;
        }
        if (D.17959 == 0) goto <D.20412>; else goto <D.20413>;
        <D.20412>:
        stream_idx = 1;
        goto <D.20414>;
        <D.20413>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20418 = "#Blob";
            D.20419 = MEM[(const unsigned char *)D.20418];
            D.20420 = (int) D.20419;
            D.20421 = *__s2;
            D.20422 = (int) D.20421;
            __result = D.20420 - D.20422;
            {
              D.20423 = __s1_len != 0;
              D.20424 = __result == 0;
              D.20425 = D.20423 & D.20424;
              if (D.20425 != 0) goto <D.20426>; else goto <D.20427>;
              <D.20426>:
              D.20428 = &MEM[(void *)"#Blob" + 1B];
              D.20429 = *D.20428;
              D.20430 = (int) D.20429;
              D.20431 = __s2 + 1;
              D.20432 = *D.20431;
              D.20433 = (int) D.20432;
              __result = D.20430 - D.20433;
              D.20434 = __s1_len > 1;
              D.20424 = __result == 0;
              D.20435 = D.20434 & D.20424;
              if (D.20435 != 0) goto <D.20436>; else goto <D.20437>;
              <D.20436>:
              D.20438 = &MEM[(void *)"#Blob" + 2B];
              D.20439 = *D.20438;
              D.20440 = (int) D.20439;
              D.20441 = __s2 + 2;
              D.20442 = *D.20441;
              D.20443 = (int) D.20442;
              __result = D.20440 - D.20443;
              D.20444 = __s1_len > 2;
              D.20424 = __result == 0;
              D.20445 = D.20444 & D.20424;
              if (D.20445 != 0) goto <D.20446>; else goto <D.20447>;
              <D.20446>:
              D.20448 = &MEM[(void *)"#Blob" + 3B];
              D.20449 = *D.20448;
              D.20450 = (int) D.20449;
              D.20451 = __s2 + 3;
              D.20452 = *D.20451;
              D.20453 = (int) D.20452;
              __result = D.20450 - D.20453;
              <D.20447>:
              <D.20437>:
              <D.20427>:
            }
            D.17964 = __result;
          }
          iftmp.8 = D.17964;
          goto <D.20454>;
          <D.20417>:
          iftmp.8 = __builtin_strcmp ("#Blob", ptr);
          <D.20454>:
          D.17968 = iftmp.8;
        }
        if (D.17968 == 0) goto <D.20455>; else goto <D.20456>;
        <D.20455>:
        stream_idx = 2;
        goto <D.20457>;
        <D.20456>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20461 = "#GUID";
            D.20462 = MEM[(const unsigned char *)D.20461];
            D.20463 = (int) D.20462;
            D.20464 = *__s2;
            D.20465 = (int) D.20464;
            __result = D.20463 - D.20465;
            {
              D.20466 = __s1_len != 0;
              D.20467 = __result == 0;
              D.20468 = D.20466 & D.20467;
              if (D.20468 != 0) goto <D.20469>; else goto <D.20470>;
              <D.20469>:
              D.20471 = &MEM[(void *)"#GUID" + 1B];
              D.20472 = *D.20471;
              D.20473 = (int) D.20472;
              D.20474 = __s2 + 1;
              D.20475 = *D.20474;
              D.20476 = (int) D.20475;
              __result = D.20473 - D.20476;
              D.20477 = __s1_len > 1;
              D.20467 = __result == 0;
              D.20478 = D.20477 & D.20467;
              if (D.20478 != 0) goto <D.20479>; else goto <D.20480>;
              <D.20479>:
              D.20481 = &MEM[(void *)"#GUID" + 2B];
              D.20482 = *D.20481;
              D.20483 = (int) D.20482;
              D.20484 = __s2 + 2;
              D.20485 = *D.20484;
              D.20486 = (int) D.20485;
              __result = D.20483 - D.20486;
              D.20487 = __s1_len > 2;
              D.20467 = __result == 0;
              D.20488 = D.20487 & D.20467;
              if (D.20488 != 0) goto <D.20489>; else goto <D.20490>;
              <D.20489>:
              D.20491 = &MEM[(void *)"#GUID" + 3B];
              D.20492 = *D.20491;
              D.20493 = (int) D.20492;
              D.20494 = __s2 + 3;
              D.20495 = *D.20494;
              D.20496 = (int) D.20495;
              __result = D.20493 - D.20496;
              <D.20490>:
              <D.20480>:
              <D.20470>:
            }
            D.17973 = __result;
          }
          iftmp.9 = D.17973;
          goto <D.20497>;
          <D.20460>:
          iftmp.9 = __builtin_strcmp ("#GUID", ptr);
          <D.20497>:
          D.17977 = iftmp.9;
        }
        if (D.17977 == 0) goto <D.20498>; else goto <D.20499>;
        <D.20498>:
        stream_idx = 3;
        goto <D.20500>;
        <D.20499>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20504 = "#~";
            D.20505 = MEM[(const unsigned char *)D.20504];
            D.20506 = (int) D.20505;
            D.20507 = *__s2;
            D.20508 = (int) D.20507;
            __result = D.20506 - D.20508;
            {
              D.20509 = __s1_len != 0;
              D.20510 = __result == 0;
              D.20511 = D.20509 & D.20510;
              if (D.20511 != 0) goto <D.20512>; else goto <D.20513>;
              <D.20512>:
              D.20514 = &MEM[(void *)"#~" + 1B];
              D.20515 = *D.20514;
              D.20516 = (int) D.20515;
              D.20517 = __s2 + 1;
              D.20518 = *D.20517;
              D.20519 = (int) D.20518;
              __result = D.20516 - D.20519;
              D.20520 = __s1_len > 1;
              D.20510 = __result == 0;
              D.20521 = D.20520 & D.20510;
              if (D.20521 != 0) goto <D.20522>; else goto <D.20523>;
              <D.20522>:
              D.20524 = &MEM[(void *)"#~" + 2B];
              D.20525 = *D.20524;
              D.20526 = (int) D.20525;
              D.20527 = __s2 + 2;
              D.20528 = *D.20527;
              D.20529 = (int) D.20528;
              __result = D.20526 - D.20529;
              D.20530 = __s1_len > 2;
              D.20510 = __result == 0;
              D.20531 = D.20530 & D.20510;
              if (D.20531 != 0) goto <D.20532>; else goto <D.20533>;
              <D.20532>:
              D.20534 = &MEM[(void *)"#~" + 3B];
              D.20535 = *D.20534;
              D.20536 = (int) D.20535;
              D.20537 = __s2 + 3;
              D.20538 = *D.20537;
              D.20539 = (int) D.20538;
              __result = D.20536 - D.20539;
              <D.20533>:
              <D.20523>:
              <D.20513>:
            }
            D.17982 = __result;
          }
          iftmp.10 = D.17982;
          goto <D.20540>;
          <D.20503>:
          iftmp.10 = __builtin_strcmp ("#~", ptr);
          <D.20540>:
          D.17986 = iftmp.10;
        }
        if (D.17986 == 0) goto <D.20541>; else goto <D.20542>;
        <D.20541>:
        stream_idx = 4;
        goto <D.20543>;
        <D.20542>:
        D.20544 = ctx->report_warning;
        if (D.20544 != 0) goto <D.20545>; else goto <D.20546>;
        <D.20545>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 2;
          D.20547 = monoeg_g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr);
          vinfo->info.message = D.20547;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20548 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20548;
        }
        ctx->valid = 0;
        return;
        <D.20546>:
        offset = pad4 (offset);
        D.20248 = ctx->data;
        D.20249 = (sizetype) offset;
        ptr = D.20248 + D.20249;
        // predicted unlikely by continue predictor.
        goto <D.17988>;
        <D.20543>:
        <D.20500>:
        <D.20457>:
        <D.20414>:
        <D.20371>:
        D.20549 = ctx->metadata_streams[stream_idx].offset;
        if (D.20549 != 0) goto <D.20550>; else goto <D.20551>;
        <D.20550>:
        D.20262 = ctx->report_error;
        if (D.20262 != 0) goto <D.20552>; else goto <D.20553>;
        <D.20552>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20554 = monoeg_g_strdup_printf ("Duplicated metadata stream header %s", ptr);
          vinfo->info.message = D.20554;
          vinfo->exception_type = 3;
          D.20266 = ctx->errors;
          D.20555 = monoeg_g_slist_prepend (D.20266, vinfo);
          ctx->errors = D.20555;
        }
        <D.20553>:
        ctx->valid = 0;
        return;
        <D.20551>:
        ctx->metadata_streams[stream_idx].offset = stream_off;
        ctx->metadata_streams[stream_idx].size = stream_size;
        offset = pad4 (offset);
        D.20248 = ctx->data;
        D.20249 = (sizetype) offset;
        ptr = D.20248 + D.20249;
      }
      <D.17988>:
      i = i + 1;
      <D.17991>:
      i.11 = (unsigned int) i;
      if (i.11 < section_count) goto <D.17990>; else goto <D.17992>;
      <D.17992>:
      D.20557 = ctx->metadata_streams[4].size;
      if (D.20557 == 0) goto <D.20558>; else goto <D.20559>;
      <D.20558>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20560>; else goto <D.20561>;
      <D.20560>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20562 = monoeg_g_strdup_printf ("Metadata #~ stream missing");
        vinfo->info.message = D.20562;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20563 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20563;
      }
      <D.20561>:
      ctx->valid = 0;
      return;
      <D.20559>:
      D.20564 = ctx->metadata_streams[3].size;
      if (D.20564 == 0) goto <D.20565>; else goto <D.20566>;
      <D.20565>:
      D.20262 = ctx->report_error;
      if (D.20262 != 0) goto <D.20567>; else goto <D.20568>;
      <D.20567>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20569 = monoeg_g_strdup_printf ("Metadata guid stream missing");
        vinfo->info.message = D.20569;
        vinfo->exception_type = 3;
        D.20266 = ctx->errors;
        D.20570 = monoeg_g_slist_prepend (D.20266, vinfo);
        ctx->errors = D.20570;
      }
      <D.20568>:
      ctx->valid = 0;
      return;
      <D.20566>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


bounds_check_datadir (struct DataDirectory * dir, guint32 offset, guint32 size)
{
  unsigned int D.20574;
  gboolean D.20577;
  unsigned int D.20578;
  unsigned int D.20581;
  unsigned int D.20582;
  _Bool D.20583;

  D.20574 = dir->translated_offset;
  if (D.20574 > offset) goto <D.20575>; else goto <D.20576>;
  <D.20575>:
  D.20577 = 0;
  return D.20577;
  <D.20576>:
  D.20578 = dir->size;
  if (D.20578 < size) goto <D.20579>; else goto <D.20580>;
  <D.20579>:
  D.20577 = 0;
  return D.20577;
  <D.20580>:
  D.20581 = offset + size;
  D.20574 = dir->translated_offset;
  D.20578 = dir->size;
  D.20582 = D.20574 + D.20578;
  D.20583 = D.20581 <= D.20582;
  D.20577 = (gboolean) D.20583;
  return D.20577;
}


pad4 (guint32 offset)
{
  unsigned int D.20585;
  unsigned int D.20588;
  guint32 D.20589;

  D.20585 = offset & 3;
  if (D.20585 != 0) goto <D.20586>; else goto <D.20587>;
  <D.20586>:
  D.20588 = offset & 4294967292;
  offset = D.20588 + 4;
  <D.20587>:
  D.20589 = offset;
  return D.20589;
}


verify_tables_schema (struct VerifyContext * ctx)
{
  const char * D.20591;
  sizetype D.20592;
  unsigned int D.20593;
  int D.20596;
  gchar * D.20599;
  struct GSList * D.20600;
  struct GSList * D.20601;
  const char * D.20602;
  char D.20603;
  unsigned char D.20604;
  unsigned char D.20605;
  int D.20610;
  gchar * D.20611;
  struct GSList * D.20612;
  const char * D.20613;
  char D.20614;
  int D.20619;
  gchar * D.20620;
  struct GSList * D.20621;
  const char * D.20622;
  char D.20623;
  signed char D.20624;
  unsigned char * D.20629;
  unsigned char D.20630;
  int D.20631;
  gchar * D.20632;
  struct GSList * D.20633;
  long unsigned int D.20634;
  long unsigned int D.20635;
  _Bool D.20640;
  _Bool D.20641;
  _Bool D.20642;
  _Bool D.20644;
  _Bool D.20645;
  _Bool D.20646;
  gchar * D.20650;
  struct GSList * D.20651;
  unsigned int i.12;
  unsigned int D.20653;
  _Bool D.20654;
  _Bool D.20655;
  _Bool D.20656;
  gchar * D.20661;
  struct GSList * D.20662;
  unsigned int D.20663;
  unsigned int D.20664;
  gchar * D.20669;
  struct GSList * D.20670;
  gchar * D.20677;
  struct GSList * D.20678;
  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.20591 = ctx->data;
      D.20592 = (sizetype) offset;
      ptr = D.20591 + D.20592;
      D.20593 = tables_area.size;
      if (D.20593 <= 23) goto <D.20594>; else goto <D.20595>;
      <D.20594>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20597>; else goto <D.20598>;
      <D.20597>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20593 = tables_area.size;
        D.20599 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for initial decoding (requires 24 bytes)", D.20593);
        vinfo->info.message = D.20599;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20601 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20601;
      }
      <D.20598>:
      ctx->valid = 0;
      return;
      <D.20595>:
      D.20602 = ptr + 4;
      D.20603 = *D.20602;
      D.20604 = (unsigned char) D.20603;
      D.20605 = D.20604 + 255;
      if (D.20605 > 1) goto <D.20606>; else goto <D.20607>;
      <D.20606>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20608>; else goto <D.20609>;
      <D.20608>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20602 = ptr + 4;
        D.20603 = *D.20602;
        D.20610 = (int) D.20603;
        D.20611 = monoeg_g_strdup_printf ("Invalid table schemata major version %d, expected 2", D.20610);
        vinfo->info.message = D.20611;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20612 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20612;
      }
      <D.20609>:
      ctx->valid = 0;
      return;
      <D.20607>:
      D.20613 = ptr + 5;
      D.20614 = *D.20613;
      if (D.20614 != 0) goto <D.20615>; else goto <D.20616>;
      <D.20615>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20617>; else goto <D.20618>;
      <D.20617>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20613 = ptr + 5;
        D.20614 = *D.20613;
        D.20619 = (int) D.20614;
        D.20620 = monoeg_g_strdup_printf ("Invalid table schemata minor version %d, expected 0", D.20619);
        vinfo->info.message = D.20620;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20621 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20621;
      }
      <D.20618>:
      ctx->valid = 0;
      return;
      <D.20616>:
      D.20622 = ptr + 6;
      D.20623 = *D.20622;
      D.20624 = D.20623 & -8;
      if (D.20624 != 0) goto <D.20625>; else goto <D.20626>;
      <D.20625>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20627>; else goto <D.20628>;
      <D.20627>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20629 = ptr + 6;
        D.20630 = *D.20629;
        D.20631 = (int) D.20630;
        D.20632 = monoeg_g_strdup_printf ("Invalid table schemata heap sizes 0x%02x, only bits 0, 1 and 2 can be set", D.20631);
        vinfo->info.message = D.20632;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20633 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20633;
      }
      <D.20628>:
      ctx->valid = 0;
      return;
      <D.20626>:
      valid_tables = MEM[(const guint64 *)ptr + 8B];
      count = 0;
      i = 0;
      goto <D.18012>;
      <D.18011>:
      D.20634 = valid_tables >> i;
      D.20635 = D.20634 & 1;
      if (D.20635 == 0) goto <D.20636>; else goto <D.20637>;
      <D.20636>:
      // predicted unlikely by continue predictor.
      goto <D.18008>;
      <D.20637>:
      D.20640 = i == 3;
      D.20641 = i == 5;
      D.20642 = D.20640 | D.20641;
      if (D.20642 != 0) goto <D.20638>; else goto <D.20643>;
      <D.20643>:
      D.20644 = i == 7;
      D.20645 = i == 19;
      D.20646 = D.20644 | D.20645;
      if (D.20646 != 0) goto <D.20638>; else goto <D.20647>;
      <D.20647>:
      if (i == 22) goto <D.20638>; else goto <D.20639>;
      <D.20638>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20648>; else goto <D.20649>;
      <D.20648>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20650 = monoeg_g_strdup_printf ("The metadata verifier doesn\'t support MS specific table %x", i);
        vinfo->info.message = D.20650;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20651 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20651;
      }
      <D.20649>:
      ctx->valid = 0;
      return;
      <D.20639>:
      i.12 = (unsigned int) i;
      D.20653 = i.12 + 4294967266;
      D.20654 = D.20653 <= 1;
      D.20655 = i > 44;
      D.20656 = D.20654 | D.20655;
      if (D.20656 != 0) goto <D.20657>; else goto <D.20658>;
      <D.20657>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20659>; else goto <D.20660>;
      <D.20659>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20661 = monoeg_g_strdup_printf ("Invalid table %x", i);
        vinfo->info.message = D.20661;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20662 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20662;
      }
      <D.20660>:
      ctx->valid = 0;
      return;
      <D.20658>:
      count = count + 1;
      <D.18008>:
      i = i + 1;
      <D.18012>:
      if (i <= 63) goto <D.18011>; else goto <D.18013>;
      <D.18013>:
      D.20593 = tables_area.size;
      D.20663 = count + 6;
      D.20664 = D.20663 * 4;
      if (D.20593 < D.20664) goto <D.20665>; else goto <D.20666>;
      <D.20665>:
      D.20596 = ctx->report_error;
      if (D.20596 != 0) goto <D.20667>; else goto <D.20668>;
      <D.20667>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20663 = count + 6;
        D.20664 = D.20663 * 4;
        D.20593 = tables_area.size;
        D.20669 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for decoding row counts (requires %d bytes)", D.20593, D.20664);
        vinfo->info.message = D.20669;
        vinfo->exception_type = 3;
        D.20600 = ctx->errors;
        D.20670 = monoeg_g_slist_prepend (D.20600, vinfo);
        ctx->errors = D.20670;
      }
      <D.20668>:
      ctx->valid = 0;
      return;
      <D.20666>:
      ptr = ptr + 24;
      i = 0;
      goto <D.18018>;
      <D.18017>:
      D.20634 = valid_tables >> i;
      D.20635 = D.20634 & 1;
      if (D.20635 != 0) goto <D.20671>; else goto <D.20672>;
      <D.20671>:
      {
        guint32 row_count;

        row_count = MEM[(const guint32 *)ptr];
        if (row_count > 16777215) goto <D.20673>; else goto <D.20674>;
        <D.20673>:
        D.20596 = ctx->report_error;
        if (D.20596 != 0) goto <D.20675>; else goto <D.20676>;
        <D.20675>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20677 = monoeg_g_strdup_printf ("Invalid Table %d row count: %d. Mono only supports 16777215 rows", i, row_count);
          vinfo->info.message = D.20677;
          vinfo->exception_type = 3;
          D.20600 = ctx->errors;
          D.20678 = monoeg_g_slist_prepend (D.20600, vinfo);
          ctx->errors = D.20678;
        }
        <D.20676>:
        ctx->valid = 0;
        return;
        <D.20674>:
        ptr = ptr + 4;
      }
      <D.20672>:
      i = i + 1;
      <D.18018>:
      if (i <= 63) goto <D.18017>; else goto <D.18019>;
      <D.18019>:
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


mono_verifier_verify_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20682;
  gboolean D.20685;
  _Bool D.20686;
  int D.20687;
  struct VerifyContext ctx;

  try
    {
      D.20682 = mono_verifier_is_enabled_for_image (image);
      if (D.20682 == 0) goto <D.20683>; else goto <D.20684>;
      <D.20683>:
      D.20685 = 1;
      return D.20685;
      <D.20684>:
      D.20686 = error_list != 0B;
      D.20687 = (int) D.20686;
      init_verify_context (&ctx, image, D.20687);
      ctx.stage = 2;
      verify_tables_data (&ctx);
      D.20685 = cleanup_context (&ctx, error_list);
      return D.20685;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_tables_data (struct VerifyContext * ctx)
{
  struct MonoImage * D.20690;
  struct MonoStreamHeader * D.20691;
  unsigned char D.20692;
  unsigned int D.20693;
  <unnamed-unsigned:24> D.20694;
  unsigned int D.20695;
  unsigned int D.20696;
  int D.20701;
  gchar * D.20704;
  struct GSList * D.20705;
  struct GSList * D.20706;
  const char * D.20707;
  long int D.20708;
  const char * D.20709;
  long int D.20710;
  long int D.20711;
  int D.20712;
  unsigned int D.20717;
  unsigned int D.20718;
  unsigned int D.20719;
  unsigned int D.20720;
  gchar * D.20721;
  struct GSList * D.20722;
  int D.20723;
  struct OffsetAndSize tables_area;
  guint32 size;
  guint32 tables_offset;
  int i;

  try
    {
      D.20690 = ctx->image;
      D.20691 = &D.20690->heap_tables;
      tables_area = get_metadata_stream (ctx, D.20691);
      size = 0;
      i = 0;
      goto <D.19484>;
      <D.19483>:
      {
        struct MonoTableInfo * table;
        guint32 tmp_size;

        D.20690 = ctx->image;
        table = &D.20690->tables[i];
        D.20692 = table->row_size;
        D.20693 = (unsigned int) D.20692;
        D.20694 = table->rows;
        D.20695 = (unsigned int) D.20694;
        D.20696 = D.20693 * D.20695;
        tmp_size = D.20696 + size;
        if (tmp_size < size) goto <D.20697>; else goto <D.20698>;
        <D.20697>:
        size = 0;
        goto <D.19482>;
        <D.20698>:
        size = tmp_size;
      }
      i = i + 1;
      <D.19484>:
      if (i <= 44) goto <D.19483>; else goto <D.19482>;
      <D.19482>:
      if (size == 0) goto <D.20699>; else goto <D.20700>;
      <D.20699>:
      D.20701 = ctx->report_error;
      if (D.20701 != 0) goto <D.20702>; else goto <D.20703>;
      <D.20702>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20704 = monoeg_g_strdup_printf ("table space is either empty or overflowed");
        vinfo->info.message = D.20704;
        vinfo->exception_type = 3;
        D.20705 = ctx->errors;
        D.20706 = monoeg_g_slist_prepend (D.20705, vinfo);
        ctx->errors = D.20706;
      }
      <D.20703>:
      ctx->valid = 0;
      return;
      <D.20700>:
      D.20690 = ctx->image;
      D.20707 = D.20690->tables_base;
      D.20708 = (long int) D.20707;
      D.20709 = ctx->data;
      D.20710 = (long int) D.20709;
      D.20711 = D.20708 - D.20710;
      tables_offset = (guint32) D.20711;
      D.20712 = bounds_check_offset (&tables_area, tables_offset, size);
      if (D.20712 == 0) goto <D.20713>; else goto <D.20714>;
      <D.20713>:
      D.20701 = ctx->report_error;
      if (D.20701 != 0) goto <D.20715>; else goto <D.20716>;
      <D.20715>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20717 = tables_area.size;
        D.20718 = tables_area.offset;
        D.20719 = D.20718 - tables_offset;
        D.20720 = D.20717 + D.20719;
        D.20721 = monoeg_g_strdup_printf ("Tables data require %d bytes but the only %d are available in the #~ stream", size, D.20720);
        vinfo->info.message = D.20721;
        vinfo->exception_type = 3;
        D.20705 = ctx->errors;
        D.20722 = monoeg_g_slist_prepend (D.20705, vinfo);
        ctx->errors = D.20722;
      }
      <D.20716>:
      ctx->valid = 0;
      return;
      <D.20714>:
      verify_module_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20724>; else goto <D.20725>;
      <D.20724>:
      return;
      <D.20725>:
      verify_typedef_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20726>; else goto <D.20727>;
      <D.20726>:
      return;
      <D.20727>:
      verify_field_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20728>; else goto <D.20729>;
      <D.20728>:
      return;
      <D.20729>:
      verify_method_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20730>; else goto <D.20731>;
      <D.20730>:
      return;
      <D.20731>:
      verify_param_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20732>; else goto <D.20733>;
      <D.20732>:
      return;
      <D.20733>:
      verify_interfaceimpl_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20734>; else goto <D.20735>;
      <D.20734>:
      return;
      <D.20735>:
      verify_memberref_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20736>; else goto <D.20737>;
      <D.20736>:
      return;
      <D.20737>:
      verify_constant_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20738>; else goto <D.20739>;
      <D.20738>:
      return;
      <D.20739>:
      verify_cattr_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20740>; else goto <D.20741>;
      <D.20740>:
      return;
      <D.20741>:
      verify_field_marshal_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20742>; else goto <D.20743>;
      <D.20742>:
      return;
      <D.20743>:
      verify_decl_security_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20744>; else goto <D.20745>;
      <D.20744>:
      return;
      <D.20745>:
      verify_class_layout_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20746>; else goto <D.20747>;
      <D.20746>:
      return;
      <D.20747>:
      verify_field_layout_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20748>; else goto <D.20749>;
      <D.20748>:
      return;
      <D.20749>:
      verify_standalonesig_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20750>; else goto <D.20751>;
      <D.20750>:
      return;
      <D.20751>:
      verify_eventmap_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20752>; else goto <D.20753>;
      <D.20752>:
      return;
      <D.20753>:
      verify_event_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20754>; else goto <D.20755>;
      <D.20754>:
      return;
      <D.20755>:
      verify_propertymap_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20756>; else goto <D.20757>;
      <D.20756>:
      return;
      <D.20757>:
      verify_property_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20758>; else goto <D.20759>;
      <D.20758>:
      return;
      <D.20759>:
      verify_methodimpl_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20760>; else goto <D.20761>;
      <D.20760>:
      return;
      <D.20761>:
      verify_moduleref_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20762>; else goto <D.20763>;
      <D.20762>:
      return;
      <D.20763>:
      verify_typespec_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20764>; else goto <D.20765>;
      <D.20764>:
      return;
      <D.20765>:
      verify_implmap_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20766>; else goto <D.20767>;
      <D.20766>:
      return;
      <D.20767>:
      verify_fieldrva_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20768>; else goto <D.20769>;
      <D.20768>:
      return;
      <D.20769>:
      verify_assembly_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20770>; else goto <D.20771>;
      <D.20770>:
      return;
      <D.20771>:
      verify_assemblyref_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20772>; else goto <D.20773>;
      <D.20772>:
      return;
      <D.20773>:
      verify_file_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20774>; else goto <D.20775>;
      <D.20774>:
      return;
      <D.20775>:
      verify_exportedtype_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20776>; else goto <D.20777>;
      <D.20776>:
      return;
      <D.20777>:
      verify_manifest_resource_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20778>; else goto <D.20779>;
      <D.20778>:
      return;
      <D.20779>:
      verify_nested_class_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20780>; else goto <D.20781>;
      <D.20780>:
      return;
      <D.20781>:
      verify_generic_param_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20782>; else goto <D.20783>;
      <D.20782>:
      return;
      <D.20783>:
      verify_method_spec_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20784>; else goto <D.20785>;
      <D.20784>:
      return;
      <D.20785>:
      verify_generic_param_constraint_table (ctx);
      D.20723 = ctx->valid;
      if (D.20723 == 0) goto <D.20786>; else goto <D.20787>;
      <D.20786>:
      return;
      <D.20787>:
      verify_tables_data_global_constraints (ctx);
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


get_metadata_stream (struct VerifyContext * ctx, struct MonoStreamHeader * header)
{
  const char * D.20791;
  long int D.20792;
  const char * D.20793;
  long int D.20794;
  long int D.20795;
  unsigned int D.20796;
  unsigned int D.20797;
  struct OffsetAndSize D.20798;
  struct OffsetAndSize res;

  try
    {
      D.20791 = header->data;
      D.20792 = (long int) D.20791;
      D.20793 = ctx->data;
      D.20794 = (long int) D.20793;
      D.20795 = D.20792 - D.20794;
      D.20796 = (unsigned int) D.20795;
      res.offset = D.20796;
      D.20797 = header->size;
      res.size = D.20797;
      D.20798 = res;
      return D.20798;
    }
  finally
    {
      res = {CLOBBER};
    }
}


bounds_check_offset (struct OffsetAndSize * off, guint32 offset, guint32 size)
{
  unsigned int D.20801;
  gboolean D.20804;
  unsigned int D.20805;
  unsigned int D.20808;
  unsigned int D.20809;
  _Bool D.20810;

  D.20801 = off->offset;
  if (D.20801 > offset) goto <D.20802>; else goto <D.20803>;
  <D.20802>:
  D.20804 = 0;
  return D.20804;
  <D.20803>:
  D.20805 = off->size;
  if (D.20805 < size) goto <D.20806>; else goto <D.20807>;
  <D.20806>:
  D.20804 = 0;
  return D.20804;
  <D.20807>:
  D.20808 = offset + size;
  D.20801 = off->offset;
  D.20805 = off->size;
  D.20809 = D.20801 + D.20805;
  D.20810 = D.20808 <= D.20809;
  D.20804 = (gboolean) D.20810;
  return D.20804;
}


verify_module_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20812;
  unsigned int D.20813;
  unsigned int D.20814;
  int D.20817;
  <unnamed-unsigned:24> D.20820;
  int D.20821;
  gchar * D.20822;
  struct GSList * D.20823;
  struct GSList * D.20824;
  unsigned int D.20825;
  int D.20826;
  gchar * D.20831;
  struct GSList * D.20832;
  unsigned int D.20833;
  int D.20834;
  gchar * D.20839;
  struct GSList * D.20840;
  unsigned int D.20841;
  gchar * D.20846;
  struct GSList * D.20847;
  unsigned int D.20848;
  gchar * D.20853;
  struct GSList * D.20854;
  struct MonoTableInfo * table;
  guint32 data[5];

  try
    {
      D.20812 = ctx->image;
      table = &D.20812->tables[0];
      D.20813 = BIT_FIELD_REF <*table, 32, 64>;
      D.20814 = D.20813 & 16777215;
      if (D.20814 != 1) goto <D.20815>; else goto <D.20816>;
      <D.20815>:
      D.20817 = ctx->report_error;
      if (D.20817 != 0) goto <D.20818>; else goto <D.20819>;
      <D.20818>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20820 = table->rows;
        D.20821 = (int) D.20820;
        D.20822 = monoeg_g_strdup_printf ("Module table must have exactly one row, but have %d", D.20821);
        vinfo->info.message = D.20822;
        vinfo->exception_type = 3;
        D.20823 = ctx->errors;
        D.20824 = monoeg_g_slist_prepend (D.20823, vinfo);
        ctx->errors = D.20824;
      }
      <D.20819>:
      ctx->valid = 0;
      return;
      <D.20816>:
      mono_metadata_decode_row (table, 0, &data, 5);
      D.20825 = data[1];
      D.20826 = is_valid_non_empty_string (ctx, D.20825);
      if (D.20826 == 0) goto <D.20827>; else goto <D.20828>;
      <D.20827>:
      D.20817 = ctx->report_error;
      if (D.20817 != 0) goto <D.20829>; else goto <D.20830>;
      <D.20829>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20825 = data[1];
        D.20831 = monoeg_g_strdup_printf ("Module has an invalid name, string index 0x%08x", D.20825);
        vinfo->info.message = D.20831;
        vinfo->exception_type = 3;
        D.20823 = ctx->errors;
        D.20832 = monoeg_g_slist_prepend (D.20823, vinfo);
        ctx->errors = D.20832;
      }
      <D.20830>:
      ctx->valid = 0;
      return;
      <D.20828>:
      D.20833 = data[2];
      D.20834 = is_valid_guid (ctx, D.20833);
      if (D.20834 == 0) goto <D.20835>; else goto <D.20836>;
      <D.20835>:
      D.20817 = ctx->report_error;
      if (D.20817 != 0) goto <D.20837>; else goto <D.20838>;
      <D.20837>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20833 = data[2];
        D.20839 = monoeg_g_strdup_printf ("Module has an invalid Mvid, guid index %x", D.20833);
        vinfo->info.message = D.20839;
        vinfo->exception_type = 3;
        D.20823 = ctx->errors;
        D.20840 = monoeg_g_slist_prepend (D.20823, vinfo);
        ctx->errors = D.20840;
      }
      <D.20838>:
      ctx->valid = 0;
      return;
      <D.20836>:
      D.20841 = data[3];
      if (D.20841 != 0) goto <D.20842>; else goto <D.20843>;
      <D.20842>:
      D.20817 = ctx->report_error;
      if (D.20817 != 0) goto <D.20844>; else goto <D.20845>;
      <D.20844>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20841 = data[3];
        D.20846 = monoeg_g_strdup_printf ("Module has a non zero Enc field %x", D.20841);
        vinfo->info.message = D.20846;
        vinfo->exception_type = 3;
        D.20823 = ctx->errors;
        D.20847 = monoeg_g_slist_prepend (D.20823, vinfo);
        ctx->errors = D.20847;
      }
      <D.20845>:
      ctx->valid = 0;
      return;
      <D.20843>:
      D.20848 = data[4];
      if (D.20848 != 0) goto <D.20849>; else goto <D.20850>;
      <D.20849>:
      D.20817 = ctx->report_error;
      if (D.20817 != 0) goto <D.20851>; else goto <D.20852>;
      <D.20851>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20848 = data[4];
        D.20853 = monoeg_g_strdup_printf ("Module has a non zero EncBase field %x", D.20848);
        vinfo->info.message = D.20853;
        vinfo->exception_type = 3;
        D.20823 = ctx->errors;
        D.20854 = monoeg_g_slist_prepend (D.20823, vinfo);
        ctx->errors = D.20854;
      }
      <D.20852>:
      ctx->valid = 0;
      return;
      <D.20850>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


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

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


is_valid_string_full_with_image (struct MonoImage * image, guint32 offset, gboolean allow_empty)
{
  const char * D.20863;
  long int D.20864;
  char * D.20865;
  long int D.20866;
  long int D.20867;
  sizetype D.20868;
  gboolean D.20871;
  long unsigned int D.20872;
  long unsigned int D.20873;
  long unsigned int data.13;
  unsigned int D.20877;
  long int D.20878;
  sizetype D.20879;
  const gchar * D.20880;
  int D.20881;
  int iftmp.14;
  long int length.15;
  guint32 heap_offset;
  guint32 heap_size;
  glong length;
  const char * data;

  try
    {
      D.20863 = image->heap_strings.data;
      D.20864 = (long int) D.20863;
      D.20865 = image->raw_data;
      D.20866 = (long int) D.20865;
      D.20867 = D.20864 - D.20866;
      heap_offset = (guint32) D.20867;
      heap_size = image->heap_strings.size;
      D.20865 = image->raw_data;
      D.20868 = (sizetype) heap_offset;
      data = D.20865 + D.20868;
      if (offset >= heap_size) goto <D.20869>; else goto <D.20870>;
      <D.20869>:
      D.20871 = 0;
      return D.20871;
      <D.20870>:
      D.20872 = (long unsigned int) offset;
      D.20873 = ~D.20872;
      data.13 = (long unsigned int) data;
      if (D.20873 < data.13) goto <D.20875>; else goto <D.20876>;
      <D.20875>:
      D.20871 = 0;
      return D.20871;
      <D.20876>:
      D.20877 = heap_size - offset;
      D.20878 = (long int) D.20877;
      D.20879 = (sizetype) offset;
      D.20880 = data + D.20879;
      D.20881 = mono_utf8_validate_and_len_with_bounds (D.20880, D.20878, &length, 0B);
      if (D.20881 == 0) goto <D.20882>; else goto <D.20883>;
      <D.20882>:
      D.20871 = 0;
      return D.20871;
      <D.20883>:
      if (allow_empty != 0) goto <D.20885>; else goto <D.20888>;
      <D.20888>:
      length.15 = length;
      if (length.15 > 0) goto <D.20885>; else goto <D.20886>;
      <D.20885>:
      iftmp.14 = 1;
      goto <D.20887>;
      <D.20886>:
      iftmp.14 = 0;
      <D.20887>:
      D.20871 = iftmp.14;
      return D.20871;
    }
  finally
    {
      length = {CLOBBER};
    }
}


is_valid_guid (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.20892;
  struct MonoStreamHeader * D.20893;
  gboolean D.20894;
  int iftmp.16;
  unsigned int D.20898;
  unsigned int D.20900;
  struct OffsetAndSize guids;

  try
    {
      D.20892 = ctx->image;
      D.20893 = &D.20892->heap_guid;
      guids = get_metadata_stream (ctx, D.20893);
      D.20898 = guids.size;
      if (D.20898 > 7) goto <D.20899>; else goto <D.20896>;
      <D.20899>:
      D.20898 = guids.size;
      D.20900 = D.20898 + 4294967288;
      if (D.20900 >= offset) goto <D.20901>; else goto <D.20896>;
      <D.20901>:
      iftmp.16 = 1;
      goto <D.20897>;
      <D.20896>:
      iftmp.16 = 0;
      <D.20897>:
      D.20894 = iftmp.16;
      return D.20894;
    }
  finally
    {
      guids = {CLOBBER};
    }
}


verify_typedef_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.20904;
  unsigned int D.20905;
  unsigned int D.20906;
  int D.20909;
  gchar * D.20912;
  struct GSList * D.20913;
  struct GSList * D.20914;
  unsigned int D.20915;
  unsigned int D.20916;
  gchar * D.20921;
  struct GSList * D.20922;
  unsigned int D.20923;
  gchar * D.20928;
  struct GSList * D.20929;
  unsigned int D.20930;
  gchar * D.20935;
  struct GSList * D.20936;
  unsigned int D.20937;
  gchar * D.20942;
  struct GSList * D.20943;
  unsigned int D.20944;
  unsigned int D.20945;
  gchar * D.20950;
  struct GSList * D.20951;
  unsigned int D.20954;
  int D.20956;
  gchar * D.20959;
  struct GSList * D.20960;
  unsigned int D.20961;
  int D.20964;
  gchar * D.20969;
  struct GSList * D.20970;
  unsigned int D.20971;
  int D.20974;
  gchar * D.20979;
  struct GSList * D.20980;
  unsigned int D.20983;
  gchar * D.20988;
  struct GSList * D.20989;
  unsigned int D.20990;
  int D.20993;
  unsigned int D.20994;
  int D.20995;
  gchar * D.21000;
  struct GSList * D.21001;
  unsigned int D.21002;
  gchar * D.21007;
  struct GSList * D.21008;
  <unnamed-unsigned:24> D.21009;
  int D.21010;
  int D.21011;
  unsigned int D.21012;
  gchar * D.21017;
  struct GSList * D.21018;
  gchar * D.21023;
  struct GSList * D.21024;
  unsigned int D.21025;
  gchar * D.21030;
  struct GSList * D.21031;
  <unnamed-unsigned:24> D.21032;
  int D.21033;
  int D.21034;
  unsigned int D.21035;
  gchar * D.21040;
  struct GSList * D.21041;
  gchar * D.21046;
  struct GSList * D.21047;
  <unnamed-unsigned:24> D.21048;
  int D.21049;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 fieldlist;
  guint32 methodlist;
  guint32 visibility;
  int i;

  try
    {
      D.20904 = ctx->image;
      table = &D.20904->tables[2];
      fieldlist = 1;
      methodlist = 1;
      D.20905 = BIT_FIELD_REF <*table, 32, 64>;
      D.20906 = D.20905 & 16777215;
      if (D.20906 == 0) goto <D.20907>; else goto <D.20908>;
      <D.20907>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20910>; else goto <D.20911>;
      <D.20910>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20912 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.20912;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20914 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20914;
      }
      <D.20911>:
      ctx->valid = 0;
      return;
      <D.20908>:
      i = 0;
      goto <D.18771>;
      <D.18770>:
      mono_metadata_decode_row (table, i, &data, 6);
      D.20915 = data[0];
      D.20916 = D.20915 & 4280861248;
      if (D.20916 != 0) goto <D.20917>; else goto <D.20918>;
      <D.20917>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20919>; else goto <D.20920>;
      <D.20919>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20915 = data[0];
        D.20921 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid flags field 0x%08x", i, D.20915);
        vinfo->info.message = D.20921;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20922 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20922;
      }
      <D.20920>:
      ctx->valid = 0;
      return;
      <D.20918>:
      D.20915 = data[0];
      D.20923 = D.20915 & 24;
      if (D.20923 == 24) goto <D.20924>; else goto <D.20925>;
      <D.20924>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20926>; else goto <D.20927>;
      <D.20926>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20928 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid class layout 0x18", i);
        vinfo->info.message = D.20928;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20929 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20929;
      }
      <D.20927>:
      ctx->valid = 0;
      return;
      <D.20925>:
      D.20915 = data[0];
      D.20930 = D.20915 & 196608;
      if (D.20930 == 196608) goto <D.20931>; else goto <D.20932>;
      <D.20931>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20933>; else goto <D.20934>;
      <D.20933>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20935 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20935;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20936 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20936;
      }
      <D.20934>:
      ctx->valid = 0;
      return;
      <D.20932>:
      D.20915 = data[0];
      D.20937 = D.20915 & 12582912;
      if (D.20937 != 0) goto <D.20938>; else goto <D.20939>;
      <D.20938>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20940>; else goto <D.20941>;
      <D.20940>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20942 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.20942;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20943 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20943;
      }
      <D.20941>:
      ctx->valid = 0;
      return;
      <D.20939>:
      D.20944 = BIT_FIELD_REF <data, 32, 0>;
      D.20945 = D.20944 & 160;
      if (D.20945 == 32) goto <D.20946>; else goto <D.20947>;
      <D.20946>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20948>; else goto <D.20949>;
      <D.20948>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20950 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i);
        vinfo->info.message = D.20950;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20951 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20951;
      }
      <D.20949>:
      ctx->valid = 0;
      return;
      <D.20947>:
      D.20954 = data[1];
      if (D.20954 == 0) goto <D.20952>; else goto <D.20955>;
      <D.20955>:
      D.20954 = data[1];
      D.20956 = is_valid_non_empty_string (ctx, D.20954);
      if (D.20956 == 0) goto <D.20952>; else goto <D.20953>;
      <D.20952>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20957>; else goto <D.20958>;
      <D.20957>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20954 = data[1];
        D.20959 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, D.20954);
        vinfo->info.message = D.20959;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20960 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20960;
      }
      <D.20958>:
      ctx->valid = 0;
      return;
      <D.20953>:
      D.20961 = data[2];
      if (D.20961 != 0) goto <D.20962>; else goto <D.20963>;
      <D.20962>:
      D.20961 = data[2];
      D.20964 = is_valid_non_empty_string (ctx, D.20961);
      if (D.20964 == 0) goto <D.20965>; else goto <D.20966>;
      <D.20965>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20967>; else goto <D.20968>;
      <D.20967>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20961 = data[2];
        D.20969 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, D.20961);
        vinfo->info.message = D.20969;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20970 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20970;
      }
      <D.20968>:
      ctx->valid = 0;
      return;
      <D.20966>:
      <D.20963>:
      D.20971 = data[3];
      if (D.20971 != 0) goto <D.20972>; else goto <D.20973>;
      <D.20972>:
      D.20971 = data[3];
      D.20974 = is_valid_coded_index (ctx, 0, D.20971);
      if (D.20974 == 0) goto <D.20975>; else goto <D.20976>;
      <D.20975>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20977>; else goto <D.20978>;
      <D.20977>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20971 = data[3];
        D.20979 = monoeg_g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, D.20971);
        vinfo->info.message = D.20979;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20980 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20980;
      }
      <D.20978>:
      ctx->valid = 0;
      return;
      <D.20976>:
      <D.20973>:
      D.20971 = data[3];
      if (D.20971 != 0) goto <D.20981>; else goto <D.20982>;
      <D.20981>:
      D.20971 = data[3];
      D.20983 = get_coded_index_token (0, D.20971);
      if (D.20983 == 0) goto <D.20984>; else goto <D.20985>;
      <D.20984>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20986>; else goto <D.20987>;
      <D.20986>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20971 = data[3];
        D.20988 = monoeg_g_strdup_printf ("Invalid typedef row %d zero coded extend field coded index 0x%08x", i, D.20971);
        vinfo->info.message = D.20988;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.20989 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.20989;
      }
      <D.20987>:
      ctx->valid = 0;
      return;
      <D.20985>:
      <D.20982>:
      D.20915 = data[0];
      visibility = D.20915 & 7;
      D.20990 = visibility + 4294967294;
      if (D.20990 <= 5) goto <D.20991>; else goto <D.20992>;
      <D.20991>:
      D.20993 = i + 1;
      D.20994 = (unsigned int) D.20993;
      D.20995 = search_sorted_table (ctx, 41, 0, D.20994);
      if (D.20995 == -1) goto <D.20996>; else goto <D.20997>;
      <D.20996>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.20998>; else goto <D.20999>;
      <D.20998>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21000 = monoeg_g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i);
        vinfo->info.message = D.21000;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21001 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21001;
      }
      <D.20999>:
      ctx->valid = 0;
      return;
      <D.20997>:
      <D.20992>:
      D.21002 = data[4];
      if (D.21002 == 0) goto <D.21003>; else goto <D.21004>;
      <D.21003>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21005>; else goto <D.21006>;
      <D.21005>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21007 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i);
        vinfo->info.message = D.21007;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21008 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21008;
      }
      <D.21006>:
      ctx->valid = 0;
      return;
      <D.21004>:
      D.21002 = data[4];
      D.20904 = ctx->image;
      D.21009 = D.20904->tables[4].rows;
      D.21010 = (int) D.21009;
      D.21011 = D.21010 + 1;
      D.21012 = (unsigned int) D.21011;
      if (D.21002 > D.21012) goto <D.21013>; else goto <D.21014>;
      <D.21013>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21015>; else goto <D.21016>;
      <D.21015>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21002 = data[4];
        D.21017 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x is out of range", i, D.21002);
        vinfo->info.message = D.21017;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21018 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21018;
      }
      <D.21016>:
      ctx->valid = 0;
      return;
      <D.21014>:
      D.21002 = data[4];
      if (D.21002 < fieldlist) goto <D.21019>; else goto <D.21020>;
      <D.21019>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21021>; else goto <D.21022>;
      <D.21021>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21002 = data[4];
        D.21023 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21002, fieldlist);
        vinfo->info.message = D.21023;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21024 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21024;
      }
      <D.21022>:
      ctx->valid = 0;
      return;
      <D.21020>:
      D.21025 = data[5];
      if (D.21025 == 0) goto <D.21026>; else goto <D.21027>;
      <D.21026>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21028>; else goto <D.21029>;
      <D.21028>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21030 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList be be >= 1", i);
        vinfo->info.message = D.21030;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21031 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21031;
      }
      <D.21029>:
      ctx->valid = 0;
      return;
      <D.21027>:
      D.21025 = data[5];
      D.20904 = ctx->image;
      D.21032 = D.20904->tables[6].rows;
      D.21033 = (int) D.21032;
      D.21034 = D.21033 + 1;
      D.21035 = (unsigned int) D.21034;
      if (D.21025 > D.21035) goto <D.21036>; else goto <D.21037>;
      <D.21036>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21038>; else goto <D.21039>;
      <D.21038>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21025 = data[5];
        D.21040 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x is out of range", i, D.21025);
        vinfo->info.message = D.21040;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21041 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21041;
      }
      <D.21039>:
      ctx->valid = 0;
      return;
      <D.21037>:
      D.21025 = data[5];
      if (D.21025 < methodlist) goto <D.21042>; else goto <D.21043>;
      <D.21042>:
      D.20909 = ctx->report_error;
      if (D.20909 != 0) goto <D.21044>; else goto <D.21045>;
      <D.21044>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21025 = data[5];
        D.21046 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21025, methodlist);
        vinfo->info.message = D.21046;
        vinfo->exception_type = 3;
        D.20913 = ctx->errors;
        D.21047 = monoeg_g_slist_prepend (D.20913, vinfo);
        ctx->errors = D.21047;
      }
      <D.21045>:
      ctx->valid = 0;
      return;
      <D.21043>:
      fieldlist = data[4];
      methodlist = data[5];
      i = i + 1;
      <D.18771>:
      D.21048 = table->rows;
      D.21049 = (int) D.21048;
      if (D.21049 > i) goto <D.18770>; else goto <D.18772>;
      <D.18772>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


is_valid_coded_index_with_image (struct MonoImage * image, int token_kind, guint32 coded_token)
{
  int token_kind.17;
  unsigned char D.21057;
  int token_kind.18;
  unsigned char D.21059;
  int bits.19;
  int D.21061;
  int D.21062;
  unsigned int D.21063;
  gboolean D.21066;
  unsigned int token_kind.20;
  unsigned int D.21068;
  unsigned char D.21069;
  <unnamed-unsigned:24> D.21072;
  unsigned int D.21073;
  _Bool D.21074;
  guint32 bits;
  guint32 table_count;
  guint32 table;
  guint32 token;

  token_kind.17 = token_kind;
  token_kind = token_kind.17 + 1;
  D.21057 = coded_index_desc[token_kind.17];
  bits = (guint32) D.21057;
  token_kind.18 = token_kind;
  token_kind = token_kind.18 + 1;
  D.21059 = coded_index_desc[token_kind.18];
  table_count = (guint32) D.21059;
  bits.19 = (int) bits;
  D.21061 = 1 << bits.19;
  D.21062 = D.21061 + -1;
  D.21063 = (unsigned int) D.21062;
  table = D.21063 & coded_token;
  bits.19 = (int) bits;
  token = coded_token >> bits.19;
  if (table >= table_count) goto <D.21064>; else goto <D.21065>;
  <D.21064>:
  D.21066 = 0;
  return D.21066;
  <D.21065>:
  token_kind.20 = (unsigned int) token_kind;
  D.21068 = token_kind.20 + table;
  D.21069 = coded_index_desc[D.21068];
  table = (guint32) D.21069;
  if (table == 255) goto <D.21070>; else goto <D.21071>;
  <D.21070>:
  D.21066 = 0;
  return D.21066;
  <D.21071>:
  D.21072 = image->tables[table].rows;
  D.21073 = (unsigned int) D.21072;
  D.21074 = D.21073 >= token;
  D.21066 = (gboolean) D.21074;
  return D.21066;
}


get_coded_index_token (int token_kind, guint32 coded_token)
{
  unsigned char D.21076;
  guint32 D.21077;
  int bits.21;
  guint32 bits;

  D.21076 = coded_index_desc[token_kind];
  bits = (guint32) D.21076;
  bits.21 = (int) bits;
  D.21077 = coded_token >> bits.21;
  return D.21077;
}


search_sorted_table (struct VerifyContext * ctx, int table, int column, guint32 coded_token)
{
  struct MonoImage * D.21080;
  unsigned int D.21081;
  unsigned int D.21082;
  unsigned char D.21083;
  long unsigned int D.21084;
  <unnamed-unsigned:24> D.21085;
  long unsigned int D.21086;
  int D.21089;
  long int res.22;
  long int base.23;
  long int D.21092;
  long int D.21093;
  long int D.21094;
  struct MonoTableInfo * tinfo;
  struct RowLocator locator;
  const char * res;
  const char * base;

  try
    {
      D.21080 = ctx->image;
      tinfo = &D.21080->tables[table];
      locator.token = coded_token;
      D.21081 = get_col_offset (ctx, table, column);
      locator.col_offset = D.21081;
      D.21082 = get_col_size (ctx, table, column);
      locator.col_size = D.21082;
      locator.table = tinfo;
      base = tinfo->base;
      D.21083 = tinfo->row_size;
      D.21084 = (long unsigned int) D.21083;
      D.21085 = tinfo->rows;
      D.21086 = (long unsigned int) D.21085;
      res = mono_binary_search (&locator, base, D.21086, D.21084, token_locator);
      if (res == 0B) goto <D.21087>; else goto <D.21088>;
      <D.21087>:
      D.21089 = -1;
      return D.21089;
      <D.21088>:
      res.22 = (long int) res;
      base.23 = (long int) base;
      D.21092 = res.22 - base.23;
      D.21083 = tinfo->row_size;
      D.21093 = (long int) D.21083;
      D.21094 = D.21092 / D.21093;
      D.21089 = (int) D.21094;
      return D.21089;
    }
  finally
    {
      locator = {CLOBBER};
    }
}


token_locator (const void * a, const void * b)
{
  const unsigned int iftmp.24;
  unsigned int D.21098;
  unsigned int D.21101;
  sizetype D.21102;
  const guint16 * D.21103;
  short unsigned int D.21104;
  const guint32 * D.21106;
  int D.21107;
  unsigned int D.21108;
  int D.21109;
  int token.25;
  struct RowLocator * loc;
  const unsigned char * row;
  guint32 token;

  loc = a;
  row = b;
  D.21098 = loc->col_size;
  if (D.21098 == 2) goto <D.21099>; else goto <D.21100>;
  <D.21099>:
  D.21101 = loc->col_offset;
  D.21102 = (sizetype) D.21101;
  D.21103 = row + D.21102;
  D.21104 = *D.21103;
  iftmp.24 = (const unsigned int) D.21104;
  goto <D.21105>;
  <D.21100>:
  D.21101 = loc->col_offset;
  D.21102 = (sizetype) D.21101;
  D.21106 = row + D.21102;
  iftmp.24 = *D.21106;
  <D.21105>:
  token = iftmp.24;
  D.21108 = loc->token;
  D.21109 = (int) D.21108;
  token.25 = (int) token;
  D.21107 = D.21109 - token.25;
  return D.21107;
}


get_col_offset (struct VerifyContext * ctx, int table, int column)
{
  struct MonoImage * D.21112;
  int D.21113;
  unsigned int D.21114;
  unsigned int D.21115;
  unsigned int D.21116;
  int column.26;
  guint32 D.21118;
  guint32 bitfield;
  guint32 offset;

  D.21112 = ctx->image;
  bitfield = D.21112->tables[table].size_bitfield;
  offset = 0;
  goto <D.18028>;
  <D.18027>:
  D.21113 = column * 2;
  D.21114 = bitfield >> D.21113;
  D.21115 = D.21114 & 3;
  D.21116 = D.21115 + offset;
  offset = D.21116 + 1;
  <D.18028>:
  column.26 = column;
  column = column.26 + -1;
  if (column.26 > 0) goto <D.18027>; else goto <D.18029>;
  <D.18029>:
  D.21118 = offset;
  return D.21118;
}


get_col_size (struct VerifyContext * ctx, int table, int column)
{
  guint32 D.21120;
  struct MonoImage * D.21121;
  unsigned int D.21122;
  int D.21123;
  unsigned int D.21124;
  unsigned int D.21125;

  D.21121 = ctx->image;
  D.21122 = D.21121->tables[table].size_bitfield;
  D.21123 = column * 2;
  D.21124 = D.21122 >> D.21123;
  D.21125 = D.21124 & 3;
  D.21120 = D.21125 + 1;
  return D.21120;
}


verify_field_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21127;
  <unnamed-unsigned:24> D.21128;
  int D.21129;
  unsigned int D.21132;
  int D.21135;
  gchar * D.21138;
  struct GSList * D.21139;
  struct GSList * D.21140;
  unsigned int D.21141;
  gchar * D.21146;
  struct GSList * D.21147;
  unsigned int D.21148;
  gchar * D.21153;
  struct GSList * D.21154;
  unsigned int D.21155;
  gchar * D.21160;
  struct GSList * D.21161;
  unsigned int D.21162;
  gchar * D.21167;
  struct GSList * D.21168;
  unsigned int D.21169;
  unsigned int i.27;
  unsigned int D.21173;
  int D.21174;
  gchar * D.21179;
  struct GSList * D.21180;
  unsigned int D.21181;
  unsigned int D.21184;
  int D.21185;
  gchar * D.21190;
  struct GSList * D.21191;
  unsigned int D.21192;
  unsigned int D.21195;
  int D.21196;
  gchar * D.21201;
  struct GSList * D.21202;
  unsigned int D.21203;
  int D.21206;
  unsigned int D.21207;
  int D.21208;
  gchar * D.21213;
  struct GSList * D.21214;
  unsigned int D.21217;
  int D.21219;
  gchar * D.21222;
  struct GSList * D.21223;
  unsigned int D.21224;
  int D.21227;
  gchar * D.21232;
  struct GSList * D.21233;
  unsigned int D.21236;
  gchar * D.21241;
  struct GSList * D.21242;
  _Bool D.21243;
  _Bool D.21244;
  _Bool D.21245;
  gchar * D.21250;
  struct GSList * D.21251;
  <unnamed-unsigned:24> D.21252;
  int D.21253;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 module_field_list;
  int i;

  try
    {
      D.21127 = ctx->image;
      table = &D.21127->tables[4];
      module_field_list = 4294967295;
      D.21127 = ctx->image;
      D.21128 = D.21127->tables[2].rows;
      D.21129 = (int) D.21128;
      if (D.21129 > 1) goto <D.21130>; else goto <D.21131>;
      <D.21130>:
      {
        struct MonoTableInfo * type;

        D.21127 = ctx->image;
        type = &D.21127->tables[2];
        module_field_list = mono_metadata_decode_row_col (type, 1, 4);
      }
      <D.21131>:
      i = 0;
      goto <D.18813>;
      <D.18812>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.21132 = flags & 18440;
      if (D.21132 != 0) goto <D.21133>; else goto <D.21134>;
      <D.21133>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21136>; else goto <D.21137>;
      <D.21136>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21138 = monoeg_g_strdup_printf ("Invalid field row %d invalid flags field 0x%08x", i, flags);
        vinfo->info.message = D.21138;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21140 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21140;
      }
      <D.21137>:
      ctx->valid = 0;
      return;
      <D.21134>:
      D.21141 = flags & 7;
      if (D.21141 == 7) goto <D.21142>; else goto <D.21143>;
      <D.21142>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21144>; else goto <D.21145>;
      <D.21144>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21146 = monoeg_g_strdup_printf ("Invalid field row %d invalid field visibility 0x7", i);
        vinfo->info.message = D.21146;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21147 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21147;
      }
      <D.21145>:
      ctx->valid = 0;
      return;
      <D.21143>:
      D.21148 = flags & 96;
      if (D.21148 == 96) goto <D.21149>; else goto <D.21150>;
      <D.21149>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21151>; else goto <D.21152>;
      <D.21151>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21153 = monoeg_g_strdup_printf ("Invalid field row %d cannot be InitOnly and Literal at the same time", i);
        vinfo->info.message = D.21153;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21154 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21154;
      }
      <D.21152>:
      ctx->valid = 0;
      return;
      <D.21150>:
      D.21155 = flags & 1536;
      if (D.21155 == 1024) goto <D.21156>; else goto <D.21157>;
      <D.21156>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21158>; else goto <D.21159>;
      <D.21158>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21160 = monoeg_g_strdup_printf ("Invalid field row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.21160;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21161 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21161;
      }
      <D.21159>:
      ctx->valid = 0;
      return;
      <D.21157>:
      D.21162 = flags & 80;
      if (D.21162 == 64) goto <D.21163>; else goto <D.21164>;
      <D.21163>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21165>; else goto <D.21166>;
      <D.21165>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21167 = monoeg_g_strdup_printf ("Invalid field row %d is Literal but not Static", i);
        vinfo->info.message = D.21167;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21168 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21168;
      }
      <D.21166>:
      ctx->valid = 0;
      return;
      <D.21164>:
      D.21169 = flags & 4096;
      if (D.21169 != 0) goto <D.21170>; else goto <D.21171>;
      <D.21170>:
      i.27 = (unsigned int) i;
      D.21173 = make_coded_token (32, 4, i.27);
      D.21174 = search_sorted_table (ctx, 13, 0, D.21173);
      if (D.21174 == -1) goto <D.21175>; else goto <D.21176>;
      <D.21175>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21177>; else goto <D.21178>;
      <D.21177>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21179 = 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.21179;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21180 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21180;
      }
      <D.21178>:
      ctx->valid = 0;
      return;
      <D.21176>:
      <D.21171>:
      D.21181 = flags & 32768;
      if (D.21181 != 0) goto <D.21182>; else goto <D.21183>;
      <D.21182>:
      i.27 = (unsigned int) i;
      D.21184 = make_coded_token (5, 4, i.27);
      D.21185 = search_sorted_table (ctx, 11, 2, D.21184);
      if (D.21185 == -1) goto <D.21186>; else goto <D.21187>;
      <D.21186>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21188>; else goto <D.21189>;
      <D.21188>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21190 = 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.21190;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21191 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21191;
      }
      <D.21189>:
      ctx->valid = 0;
      return;
      <D.21187>:
      <D.21183>:
      D.21192 = flags & 64;
      if (D.21192 != 0) goto <D.21193>; else goto <D.21194>;
      <D.21193>:
      i.27 = (unsigned int) i;
      D.21195 = make_coded_token (5, 4, i.27);
      D.21196 = search_sorted_table (ctx, 11, 2, D.21195);
      if (D.21196 == -1) goto <D.21197>; else goto <D.21198>;
      <D.21197>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21199>; else goto <D.21200>;
      <D.21199>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21201 = 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.21201;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21202 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21202;
      }
      <D.21200>:
      ctx->valid = 0;
      return;
      <D.21198>:
      <D.21194>:
      D.21203 = flags & 256;
      if (D.21203 != 0) goto <D.21204>; else goto <D.21205>;
      <D.21204>:
      D.21206 = i + 1;
      D.21207 = (unsigned int) D.21206;
      D.21208 = search_sorted_table (ctx, 29, 1, D.21207);
      if (D.21208 == -1) goto <D.21209>; else goto <D.21210>;
      <D.21209>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21211>; else goto <D.21212>;
      <D.21211>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21213 = 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.21213;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21214 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21214;
      }
      <D.21212>:
      ctx->valid = 0;
      return;
      <D.21210>:
      <D.21205>:
      D.21217 = data[1];
      if (D.21217 == 0) goto <D.21215>; else goto <D.21218>;
      <D.21218>:
      D.21217 = data[1];
      D.21219 = is_valid_non_empty_string (ctx, D.21217);
      if (D.21219 == 0) goto <D.21215>; else goto <D.21216>;
      <D.21215>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21220>; else goto <D.21221>;
      <D.21220>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21217 = data[1];
        D.21222 = monoeg_g_strdup_printf ("Invalid field row %d invalid name token %08x", i, D.21217);
        vinfo->info.message = D.21222;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21223 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21223;
      }
      <D.21221>:
      ctx->valid = 0;
      return;
      <D.21216>:
      D.21224 = data[2];
      if (D.21224 != 0) goto <D.21225>; else goto <D.21226>;
      <D.21225>:
      D.21224 = data[2];
      D.21227 = is_valid_blob_object (ctx, D.21224, 1);
      if (D.21227 == 0) goto <D.21228>; else goto <D.21229>;
      <D.21228>:
      D.21135 = ctx->report_error;
      if (D.21135 != 0) goto <D.21230>; else goto <D.21231>;
      <D.21230>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21224 = data[2];
        D.21232 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, D.21224);
        vinfo->info.message = D.21232;
        vinfo->exception_type = 3;
        D.21139 = ctx->errors;
        D.21233 = monoeg_g_slist_prepend (D.21139, vinfo);
        ctx->errors = D.21233;
      }
      <D.21231>:
      ctx->valid = 0;
      return;
      <D.21229>:
      <D.21226>:
      D.21206 = i + 1;
      D.21207 = (unsigned int) D.21206;
      if (D.21207 < module_field_list) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      {
        guint32 access;

        access = flags & 7;
        D.21236 = flags & 16;
        if (D.21236 == 0) goto <D.21237>; else goto <D.21238>;
        <D.21237>:
        D.21135 = ctx->report_error;
        if (D.21135 != 0) goto <D.21239>; else goto <D.21240>;
        <D.21239>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21241 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but is not static", i);
          vinfo->info.message = D.21241;
          vinfo->exception_type = 3;
          D.21139 = ctx->errors;
          D.21242 = monoeg_g_slist_prepend (D.21139, vinfo);
          ctx->errors = D.21242;
        }
        <D.21240>:
        ctx->valid = 0;
        return;
        <D.21238>:
        D.21243 = access > 1;
        D.21244 = access != 6;
        D.21245 = D.21243 & D.21244;
        if (D.21245 != 0) goto <D.21246>; else goto <D.21247>;
        <D.21246>:
        D.21135 = ctx->report_error;
        if (D.21135 != 0) goto <D.21248>; else goto <D.21249>;
        <D.21248>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21250 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but have wrong visibility %x", i, access);
          vinfo->info.message = D.21250;
          vinfo->exception_type = 3;
          D.21139 = ctx->errors;
          D.21251 = monoeg_g_slist_prepend (D.21139, vinfo);
          ctx->errors = D.21251;
        }
        <D.21249>:
        ctx->valid = 0;
        return;
        <D.21247>:
      }
      <D.21235>:
      i = i + 1;
      <D.18813>:
      D.21252 = table->rows;
      D.21253 = (int) D.21252;
      if (D.21253 > i) goto <D.18812>; else goto <D.18814>;
      <D.18814>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


make_coded_token (int kind, guint32 table, guint32 table_idx)
{
  int kind.28;
  unsigned char D.21258;
  int kind.29;
  unsigned char D.21260;
  int kind.30;
  unsigned char D.21262;
  unsigned int D.21263;
  guint32 D.21266;
  unsigned int D.21267;
  int bits.31;
  unsigned int D.21269;
  guint32 bits;
  guint32 tables;
  guint32 i;

  kind.28 = kind;
  kind = kind.28 + 1;
  D.21258 = coded_index_desc[kind.28];
  bits = (guint32) D.21258;
  kind.29 = kind;
  kind = kind.29 + 1;
  D.21260 = coded_index_desc[kind.29];
  tables = (guint32) D.21260;
  i = 0;
  goto <D.18087>;
  <D.18086>:
  kind.30 = kind;
  kind = kind.30 + 1;
  D.21262 = coded_index_desc[kind.30];
  D.21263 = (unsigned int) D.21262;
  if (D.21263 == table) goto <D.21264>; else goto <D.21265>;
  <D.21264>:
  D.21267 = table_idx + 1;
  bits.31 = (int) bits;
  D.21269 = D.21267 << bits.31;
  D.21266 = D.21269 | i;
  return D.21266;
  <D.21265>:
  i = i + 1;
  <D.18087>:
  if (i < tables) goto <D.18086>; else goto <D.18088>;
  <D.18088>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 1012);
  D.21266 = 4294967295;
  return D.21266;
}


is_valid_blob_object (struct VerifyContext * ctx, guint32 offset, guint32 minsize)
{
  struct MonoImage * D.21271;
  struct MonoStreamHeader * D.21272;
  unsigned int D.21273;
  gboolean D.21276;
  unsigned int D.21277;
  unsigned int D.21278;
  const char * D.21279;
  sizetype D.21280;
  sizetype D.21281;
  sizetype D.21282;
  const char * D.21283;
  int D.21284;
  unsigned int entry_size.32;
  unsigned int bytes.33;
  unsigned int D.21291;
  unsigned int entry_size.34;
  int iftmp.35;
  unsigned int D.21298;
  unsigned int D.21300;
  struct OffsetAndSize blob;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.21271 = ctx->image;
      D.21272 = &D.21271->heap_blob;
      blob = get_metadata_stream (ctx, D.21272);
      D.21273 = blob.size;
      if (D.21273 < offset) goto <D.21274>; else goto <D.21275>;
      <D.21274>:
      D.21276 = 0;
      return D.21276;
      <D.21275>:
      D.21273 = blob.size;
      D.21277 = blob.offset;
      D.21278 = D.21273 - D.21277;
      D.21279 = ctx->data;
      D.21280 = (sizetype) offset;
      D.21277 = blob.offset;
      D.21281 = (sizetype) D.21277;
      D.21282 = D.21280 + D.21281;
      D.21283 = D.21279 + D.21282;
      D.21284 = decode_value (D.21283, D.21278, &entry_size, &bytes);
      if (D.21284 == 0) goto <D.21285>; else goto <D.21286>;
      <D.21285>:
      D.21276 = 0;
      return D.21276;
      <D.21286>:
      entry_size.32 = entry_size;
      if (entry_size.32 < minsize) goto <D.21288>; else goto <D.21289>;
      <D.21288>:
      D.21276 = 0;
      return D.21276;
      <D.21289>:
      bytes.33 = bytes;
      D.21291 = ~bytes.33;
      entry_size.32 = entry_size;
      if (D.21291 < entry_size.32) goto <D.21292>; else goto <D.21293>;
      <D.21292>:
      D.21276 = 0;
      return D.21276;
      <D.21293>:
      entry_size.32 = entry_size;
      bytes.33 = bytes;
      entry_size.34 = entry_size.32 + bytes.33;
      entry_size = entry_size.34;
      entry_size.32 = entry_size;
      D.21298 = offset + entry_size.32;
      D.21273 = blob.size;
      if (D.21298 <= D.21273) goto <D.21299>; else goto <D.21296>;
      <D.21299>:
      entry_size.32 = entry_size;
      D.21300 = ~entry_size.32;
      if (D.21300 >= offset) goto <D.21301>; else goto <D.21296>;
      <D.21301>:
      iftmp.35 = 1;
      goto <D.21297>;
      <D.21296>:
      iftmp.35 = 0;
      <D.21297>:
      D.21276 = iftmp.35;
      return D.21276;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


decode_value (const char * _ptr, unsigned int available, unsigned int * value, unsigned int * size)
{
  gboolean D.21306;
  unsigned int D.21307;
  signed char b.36;
  unsigned int D.21311;
  int D.21313;
  int D.21314;
  int D.21319;
  int D.21320;
  const unsigned char * D.21321;
  unsigned char D.21322;
  int D.21323;
  int D.21324;
  unsigned int D.21325;
  int D.21329;
  int D.21330;
  int D.21331;
  int D.21332;
  const unsigned char * D.21333;
  unsigned char D.21334;
  int D.21335;
  int D.21336;
  int D.21337;
  const unsigned char * D.21338;
  unsigned char D.21339;
  int D.21340;
  int D.21341;
  unsigned int D.21342;
  unsigned char b;
  const unsigned char * ptr;

  ptr = _ptr;
  if (available == 0) goto <D.21304>; else goto <D.21305>;
  <D.21304>:
  D.21306 = 0;
  return D.21306;
  <D.21305>:
  b = *ptr;
  *size = 0;
  D.21307 = *size;
  *value = D.21307;
  b.36 = (signed char) b;
  if (b.36 >= 0) goto <D.21309>; else goto <D.21310>;
  <D.21309>:
  *size = 1;
  D.21311 = (unsigned int) b;
  *value = D.21311;
  goto <D.21312>;
  <D.21310>:
  D.21313 = (int) b;
  D.21314 = D.21313 & 64;
  if (D.21314 == 0) goto <D.21315>; else goto <D.21316>;
  <D.21315>:
  if (available <= 1) goto <D.21317>; else goto <D.21318>;
  <D.21317>:
  D.21306 = 0;
  return D.21306;
  <D.21318>:
  *size = 2;
  D.21313 = (int) b;
  D.21319 = D.21313 & 63;
  D.21320 = D.21319 << 8;
  D.21321 = ptr + 1;
  D.21322 = *D.21321;
  D.21323 = (int) D.21322;
  D.21324 = D.21320 | D.21323;
  D.21325 = (unsigned int) D.21324;
  *value = D.21325;
  goto <D.21326>;
  <D.21316>:
  if (available <= 3) goto <D.21327>; else goto <D.21328>;
  <D.21327>:
  D.21306 = 0;
  return D.21306;
  <D.21328>:
  *size = 4;
  D.21313 = (int) b;
  D.21329 = D.21313 & 31;
  D.21330 = D.21329 << 24;
  D.21321 = ptr + 1;
  D.21322 = *D.21321;
  D.21323 = (int) D.21322;
  D.21331 = D.21323 << 16;
  D.21332 = D.21330 | D.21331;
  D.21333 = ptr + 2;
  D.21334 = *D.21333;
  D.21335 = (int) D.21334;
  D.21336 = D.21335 << 8;
  D.21337 = D.21332 | D.21336;
  D.21338 = ptr + 3;
  D.21339 = *D.21338;
  D.21340 = (int) D.21339;
  D.21341 = D.21337 | D.21340;
  D.21342 = (unsigned int) D.21341;
  *value = D.21342;
  <D.21326>:
  <D.21312>:
  D.21306 = 1;
  return D.21306;
}


verify_method_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21344;
  <unnamed-unsigned:24> D.21345;
  int D.21346;
  unsigned int D.21349;
  int D.21352;
  gchar * D.21355;
  struct GSList * D.21356;
  struct GSList * D.21357;
  gchar * D.21362;
  struct GSList * D.21363;
  unsigned int D.21366;
  int D.21368;
  gchar * D.21371;
  struct GSList * D.21372;
  int D.18853;
  int iftmp.37;
  int D.18849;
  const char[6] * D.21376;
  unsigned char D.21377;
  int D.21378;
  unsigned char D.21379;
  int D.21380;
  _Bool D.21381;
  _Bool D.21382;
  _Bool D.21383;
  const unsigned char * D.21386;
  unsigned char D.21387;
  int D.21388;
  const unsigned char * D.21389;
  unsigned char D.21390;
  int D.21391;
  _Bool D.21392;
  _Bool D.21393;
  const unsigned char * D.21396;
  unsigned char D.21397;
  int D.21398;
  const unsigned char * D.21399;
  unsigned char D.21400;
  int D.21401;
  _Bool D.21402;
  _Bool D.21403;
  const unsigned char * D.21406;
  unsigned char D.21407;
  int D.21408;
  const unsigned char * D.21409;
  unsigned char D.21410;
  int D.21411;
  _Bool D.21413;
  int D.18862;
  int iftmp.38;
  int D.18858;
  const char[7] * D.21417;
  unsigned char D.21418;
  int D.21419;
  unsigned char D.21420;
  int D.21421;
  _Bool D.21422;
  _Bool D.21423;
  _Bool D.21424;
  const unsigned char * D.21427;
  unsigned char D.21428;
  int D.21429;
  const unsigned char * D.21430;
  unsigned char D.21431;
  int D.21432;
  _Bool D.21433;
  _Bool D.21434;
  const unsigned char * D.21437;
  unsigned char D.21438;
  int D.21439;
  const unsigned char * D.21440;
  unsigned char D.21441;
  int D.21442;
  _Bool D.21443;
  _Bool D.21444;
  const unsigned char * D.21447;
  unsigned char D.21448;
  int D.21449;
  const unsigned char * D.21450;
  unsigned char D.21451;
  int D.21452;
  _Bool D.21454;
  int D.21455;
  unsigned int i.39;
  unsigned int D.21459;
  int D.21460;
  gchar * D.21465;
  struct GSList * D.21466;
  unsigned int D.21467;
  unsigned int D.21470;
  gchar * D.21475;
  struct GSList * D.21476;
  unsigned int D.21477;
  unsigned int D.21480;
  gchar * D.21485;
  struct GSList * D.21486;
  unsigned int D.21487;
  gchar * D.21492;
  struct GSList * D.21493;
  unsigned int D.21494;
  gchar * D.21499;
  struct GSList * D.21500;
  unsigned int D.21503;
  int D.21506;
  gchar * D.21509;
  struct GSList * D.21510;
  unsigned int D.21511;
  gchar * D.21516;
  struct GSList * D.21517;
  int D.21518;
  unsigned int D.21519;
  gchar * D.21526;
  struct GSList * D.21527;
  unsigned int D.21528;
  gchar * D.21533;
  struct GSList * D.21534;
  _Bool D.21537;
  _Bool D.21538;
  _Bool D.21539;
  gchar * D.21543;
  struct GSList * D.21544;
  unsigned int D.21545;
  gchar * D.21552;
  struct GSList * D.21553;
  gchar * D.21560;
  struct GSList * D.21561;
  gchar * D.21566;
  struct GSList * D.21567;
  unsigned int D.21568;
  unsigned int D.21573;
  gchar * D.21580;
  struct GSList * D.21581;
  unsigned int D.21582;
  gchar * D.21589;
  struct GSList * D.21590;
  unsigned int D.21595;
  gchar * D.21599;
  struct GSList * D.21600;
  gchar * D.21605;
  struct GSList * D.21606;
  gchar * D.21616;
  struct GSList * D.21617;
  gchar * D.21624;
  struct GSList * D.21625;
  unsigned int D.21626;
  int D.21627;
  gchar * D.21632;
  struct GSList * D.21633;
  unsigned int D.21634;
  gchar * D.21641;
  struct GSList * D.21642;
  gchar * D.21649;
  struct GSList * D.21650;
  unsigned int D.21651;
  int D.21654;
  gchar * D.21659;
  struct GSList * D.21660;
  unsigned int D.21661;
  gchar * D.21666;
  struct GSList * D.21667;
  gchar * D.21672;
  struct GSList * D.21673;
  <unnamed-unsigned:24> D.21674;
  int D.21675;
  int D.21676;
  unsigned int D.21677;
  gchar * D.21682;
  struct GSList * D.21683;
  <unnamed-unsigned:24> D.21684;
  int D.21685;
  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.21344 = ctx->image;
      table = &D.21344->tables[6];
      paramlist = 1;
      module_method_list = 4294967295;
      D.21344 = ctx->image;
      D.21345 = D.21344->tables[2].rows;
      D.21346 = (int) D.21345;
      if (D.21346 > 1) goto <D.21347>; else goto <D.21348>;
      <D.21347>:
      {
        struct MonoTableInfo * type;

        D.21344 = ctx->image;
        type = &D.21344->tables[2];
        module_method_list = mono_metadata_decode_row_col (type, 1, 5);
      }
      <D.21348>:
      i = 0;
      goto <D.18890>;
      <D.18889>:
      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.21349 = implflags & 60928;
      if (D.21349 != 0) goto <D.21350>; else goto <D.21351>;
      <D.21350>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21353>; else goto <D.21354>;
      <D.21353>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21355 = monoeg_g_strdup_printf ("Invalid method row %d invalid implflags field 0x%08x", i, implflags);
        vinfo->info.message = D.21355;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21357 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21357;
      }
      <D.21354>:
      ctx->valid = 0;
      return;
      <D.21351>:
      if (access == 7) goto <D.21358>; else goto <D.21359>;
      <D.21358>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21360>; else goto <D.21361>;
      <D.21360>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21362 = monoeg_g_strdup_printf ("Invalid method row %d invalid MemberAccessMask 0x7", i);
        vinfo->info.message = D.21362;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21363 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21363;
      }
      <D.21361>:
      ctx->valid = 0;
      return;
      <D.21359>:
      D.21366 = data[3];
      if (D.21366 == 0) goto <D.21364>; else goto <D.21367>;
      <D.21367>:
      D.21366 = data[3];
      D.21368 = is_valid_non_empty_string (ctx, D.21366);
      if (D.21368 == 0) goto <D.21364>; else goto <D.21365>;
      <D.21364>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21369>; else goto <D.21370>;
      <D.21369>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21366 = data[3];
        D.21371 = monoeg_g_strdup_printf ("Invalid method row %d invalid name field 0x%08x", i, D.21366);
        vinfo->info.message = D.21371;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21372 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21372;
      }
      <D.21370>:
      ctx->valid = 0;
      return;
      <D.21365>:
      D.21366 = data[3];
      name = get_string_ptr (ctx, D.21366);
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21376 = ".ctor";
          D.21377 = MEM[(const unsigned char *)D.21376];
          D.21378 = (int) D.21377;
          D.21379 = *__s2;
          D.21380 = (int) D.21379;
          __result = D.21378 - D.21380;
          {
            D.21381 = __s1_len != 0;
            D.21382 = __result == 0;
            D.21383 = D.21381 & D.21382;
            if (D.21383 != 0) goto <D.21384>; else goto <D.21385>;
            <D.21384>:
            D.21386 = &MEM[(void *)".ctor" + 1B];
            D.21387 = *D.21386;
            D.21388 = (int) D.21387;
            D.21389 = __s2 + 1;
            D.21390 = *D.21389;
            D.21391 = (int) D.21390;
            __result = D.21388 - D.21391;
            D.21392 = __s1_len > 1;
            D.21382 = __result == 0;
            D.21393 = D.21392 & D.21382;
            if (D.21393 != 0) goto <D.21394>; else goto <D.21395>;
            <D.21394>:
            D.21396 = &MEM[(void *)".ctor" + 2B];
            D.21397 = *D.21396;
            D.21398 = (int) D.21397;
            D.21399 = __s2 + 2;
            D.21400 = *D.21399;
            D.21401 = (int) D.21400;
            __result = D.21398 - D.21401;
            D.21402 = __s1_len > 2;
            D.21382 = __result == 0;
            D.21403 = D.21402 & D.21382;
            if (D.21403 != 0) goto <D.21404>; else goto <D.21405>;
            <D.21404>:
            D.21406 = &MEM[(void *)".ctor" + 3B];
            D.21407 = *D.21406;
            D.21408 = (int) D.21407;
            D.21409 = __s2 + 3;
            D.21410 = *D.21409;
            D.21411 = (int) D.21410;
            __result = D.21408 - D.21411;
            <D.21405>:
            <D.21395>:
            <D.21385>:
          }
          D.18849 = __result;
        }
        iftmp.37 = D.18849;
        goto <D.21412>;
        <D.21375>:
        iftmp.37 = __builtin_strcmp (".ctor", name);
        <D.21412>:
        D.18853 = iftmp.37;
      }
      D.21413 = D.18853 == 0;
      is_ctor = (gboolean) D.21413;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21417 = ".cctor";
          D.21418 = MEM[(const unsigned char *)D.21417];
          D.21419 = (int) D.21418;
          D.21420 = *__s2;
          D.21421 = (int) D.21420;
          __result = D.21419 - D.21421;
          {
            D.21422 = __s1_len != 0;
            D.21423 = __result == 0;
            D.21424 = D.21422 & D.21423;
            if (D.21424 != 0) goto <D.21425>; else goto <D.21426>;
            <D.21425>:
            D.21427 = &MEM[(void *)".cctor" + 1B];
            D.21428 = *D.21427;
            D.21429 = (int) D.21428;
            D.21430 = __s2 + 1;
            D.21431 = *D.21430;
            D.21432 = (int) D.21431;
            __result = D.21429 - D.21432;
            D.21433 = __s1_len > 1;
            D.21423 = __result == 0;
            D.21434 = D.21433 & D.21423;
            if (D.21434 != 0) goto <D.21435>; else goto <D.21436>;
            <D.21435>:
            D.21437 = &MEM[(void *)".cctor" + 2B];
            D.21438 = *D.21437;
            D.21439 = (int) D.21438;
            D.21440 = __s2 + 2;
            D.21441 = *D.21440;
            D.21442 = (int) D.21441;
            __result = D.21439 - D.21442;
            D.21443 = __s1_len > 2;
            D.21423 = __result == 0;
            D.21444 = D.21443 & D.21423;
            if (D.21444 != 0) goto <D.21445>; else goto <D.21446>;
            <D.21445>:
            D.21447 = &MEM[(void *)".cctor" + 3B];
            D.21448 = *D.21447;
            D.21449 = (int) D.21448;
            D.21450 = __s2 + 3;
            D.21451 = *D.21450;
            D.21452 = (int) D.21451;
            __result = D.21449 - D.21452;
            <D.21446>:
            <D.21436>:
            <D.21426>:
          }
          D.18858 = __result;
        }
        iftmp.38 = D.18858;
        goto <D.21453>;
        <D.21416>:
        iftmp.38 = __builtin_strcmp (".cctor", name);
        <D.21453>:
        D.18862 = iftmp.38;
      }
      D.21454 = D.18862 == 0;
      is_cctor = (gboolean) D.21454;
      D.21455 = is_ctor | is_cctor;
      if (D.21455 != 0) goto <D.21456>; else goto <D.21457>;
      <D.21456>:
      i.39 = (unsigned int) i;
      D.21459 = make_coded_token (78, 6, i.39);
      D.21460 = search_sorted_table (ctx, 42, 2, D.21459);
      if (D.21460 != -1) goto <D.21461>; else goto <D.21462>;
      <D.21461>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21463>; else goto <D.21464>;
      <D.21463>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21465 = monoeg_g_strdup_printf ("Invalid method row %d .ctor or .cctor has generic param", i);
        vinfo->info.message = D.21465;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21466 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21466;
      }
      <D.21464>:
      ctx->valid = 0;
      return;
      <D.21462>:
      <D.21457>:
      D.21467 = flags & 16;
      if (D.21467 != 0) goto <D.21468>; else goto <D.21469>;
      <D.21468>:
      D.21470 = flags & 352;
      if (D.21470 != 0) goto <D.21471>; else goto <D.21472>;
      <D.21471>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21473>; else goto <D.21474>;
      <D.21473>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21475 = monoeg_g_strdup_printf ("Invalid method row %d is static and (final, virtual or new slot)", i);
        vinfo->info.message = D.21475;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21476 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21476;
      }
      <D.21474>:
      ctx->valid = 0;
      return;
      <D.21472>:
      <D.21469>:
      D.21477 = flags & 1024;
      if (D.21477 != 0) goto <D.21478>; else goto <D.21479>;
      <D.21478>:
      D.21480 = flags & 8192;
      if (D.21480 != 0) goto <D.21481>; else goto <D.21482>;
      <D.21481>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21483>; else goto <D.21484>;
      <D.21483>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21485 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i);
        vinfo->info.message = D.21485;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21486 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21486;
      }
      <D.21484>:
      ctx->valid = 0;
      return;
      <D.21482>:
      D.21487 = flags & 32;
      if (D.21487 != 0) goto <D.21488>; else goto <D.21489>;
      <D.21488>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21490>; else goto <D.21491>;
      <D.21490>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21492 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and Final", i);
        vinfo->info.message = D.21492;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21493 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21493;
      }
      <D.21491>:
      ctx->valid = 0;
      return;
      <D.21489>:
      D.21494 = flags & 64;
      if (D.21494 == 0) goto <D.21495>; else goto <D.21496>;
      <D.21495>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21497>; else goto <D.21498>;
      <D.21497>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21499 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract but not Virtual", i);
        vinfo->info.message = D.21499;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21500 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21500;
      }
      <D.21498>:
      ctx->valid = 0;
      return;
      <D.21496>:
      <D.21479>:
      if (access == 0) goto <D.21501>; else goto <D.21502>;
      <D.21501>:
      D.21503 = flags & 6144;
      if (D.21503 != 0) goto <D.21504>; else goto <D.21505>;
      <D.21504>:
      D.21506 = ctx->report_warning;
      if (D.21506 != 0) goto <D.21507>; else goto <D.21508>;
      <D.21507>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 2;
        D.21509 = monoeg_g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i);
        vinfo->info.message = D.21509;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21510 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21510;
      }
      ctx->valid = 0;
      return;
      <D.21508>:
      <D.21505>:
      <D.21502>:
      D.21511 = flags & 6144;
      if (D.21511 == 4096) goto <D.21512>; else goto <D.21513>;
      <D.21512>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21514>; else goto <D.21515>;
      <D.21514>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21516 = monoeg_g_strdup_printf ("Invalid method row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.21516;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21517 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21517;
      }
      <D.21515>:
      ctx->valid = 0;
      return;
      <D.21513>:
      D.21518 = i + 1;
      D.21519 = (unsigned int) D.21518;
      if (D.21519 < module_method_list) goto <D.21520>; else goto <D.21521>;
      <D.21520>:
      D.21467 = flags & 16;
      if (D.21467 == 0) goto <D.21522>; else goto <D.21523>;
      <D.21522>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21524>; else goto <D.21525>;
      <D.21524>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21526 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not Static", i);
        vinfo->info.message = D.21526;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21527 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21527;
      }
      <D.21525>:
      ctx->valid = 0;
      return;
      <D.21523>:
      D.21528 = flags & 1088;
      if (D.21528 != 0) goto <D.21529>; else goto <D.21530>;
      <D.21529>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21531>; else goto <D.21532>;
      <D.21531>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21533 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but is Abstract or Virtual", i);
        vinfo->info.message = D.21533;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21534 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21534;
      }
      <D.21532>:
      ctx->valid = 0;
      return;
      <D.21530>:
      D.21537 = access == 4;
      D.21538 = access == 2;
      D.21539 = D.21537 | D.21538;
      if (D.21539 != 0) goto <D.21535>; else goto <D.21540>;
      <D.21540>:
      if (access == 5) goto <D.21535>; else goto <D.21536>;
      <D.21535>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21541>; else goto <D.21542>;
      <D.21541>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21543 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not CompilerControled, Public, Private or Assembly", i);
        vinfo->info.message = D.21543;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21544 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21544;
      }
      <D.21542>:
      ctx->valid = 0;
      return;
      <D.21536>:
      <D.21521>:
      D.21545 = flags & 800;
      if (D.21545 != 0) goto <D.21546>; else goto <D.21547>;
      <D.21546>:
      D.21494 = flags & 64;
      if (D.21494 == 0) goto <D.21548>; else goto <D.21549>;
      <D.21548>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21550>; else goto <D.21551>;
      <D.21550>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21552 = monoeg_g_strdup_printf ("Invalid method row %d is (Final, NewSlot or Strict) but not Virtual", i);
        vinfo->info.message = D.21552;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21553 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21553;
      }
      <D.21551>:
      ctx->valid = 0;
      return;
      <D.21549>:
      <D.21547>:
      D.21480 = flags & 8192;
      if (D.21480 != 0) goto <D.21554>; else goto <D.21555>;
      <D.21554>:
      D.21494 = flags & 64;
      if (D.21494 != 0) goto <D.21556>; else goto <D.21557>;
      <D.21556>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21558>; else goto <D.21559>;
      <D.21558>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21560 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i);
        vinfo->info.message = D.21560;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21561 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21561;
      }
      <D.21559>:
      ctx->valid = 0;
      return;
      <D.21557>:
      D.21467 = flags & 16;
      if (D.21467 == 0) goto <D.21562>; else goto <D.21563>;
      <D.21562>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21564>; else goto <D.21565>;
      <D.21564>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21566 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i);
        vinfo->info.message = D.21566;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21567 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21567;
      }
      <D.21565>:
      ctx->valid = 0;
      return;
      <D.21563>:
      <D.21555>:
      D.21477 = flags & 1024;
      D.21568 = D.21477 | rva;
      if (D.21568 == 0) goto <D.21569>; else goto <D.21570>;
      <D.21569>:
      D.21480 = flags & 8192;
      if (D.21480 == 0) goto <D.21571>; else goto <D.21572>;
      <D.21571>:
      D.21573 = implflags & 4096;
      if (D.21573 == 0) goto <D.21574>; else goto <D.21575>;
      <D.21574>:
      if (code_type != 3) goto <D.21576>; else goto <D.21577>;
      <D.21576>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21578>; else goto <D.21579>;
      <D.21578>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21580 = 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.21580;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21581 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21581;
      }
      <D.21579>:
      ctx->valid = 0;
      return;
      <D.21577>:
      <D.21575>:
      <D.21572>:
      <D.21570>:
      D.21582 = access | rva;
      if (D.21582 == 0) goto <D.21583>; else goto <D.21584>;
      <D.21583>:
      D.21480 = flags & 8192;
      if (D.21480 == 0) goto <D.21585>; else goto <D.21586>;
      <D.21585>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21587>; else goto <D.21588>;
      <D.21587>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21589 = monoeg_g_strdup_printf ("Invalid method row %d is CompilerControlled but neither RVA != 0 or PinvokeImpl", i);
        vinfo->info.message = D.21589;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21590 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21590;
      }
      <D.21588>:
      ctx->valid = 0;
      return;
      <D.21586>:
      <D.21584>:
      if (rva != 0) goto <D.21591>; else goto <D.21592>;
      <D.21591>:
      D.21595 = flags & 9216;
      if (D.21595 != 0) goto <D.21593>; else goto <D.21596>;
      <D.21596>:
      D.21573 = implflags & 4096;
      if (D.21573 != 0) goto <D.21593>; else goto <D.21594>;
      <D.21593>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21597>; else goto <D.21598>;
      <D.21597>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21599 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is either Abstract, InternalCall or PinvokeImpl", i);
        vinfo->info.message = D.21599;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21600 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21600;
      }
      <D.21598>:
      ctx->valid = 0;
      return;
      <D.21594>:
      if (code_type == 2) goto <D.21601>; else goto <D.21602>;
      <D.21601>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21603>; else goto <D.21604>;
      <D.21603>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21605 = 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.21605;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21606 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21606;
      }
      <D.21604>:
      ctx->valid = 0;
      return;
      <D.21602>:
      goto <D.21607>;
      <D.21592>:
      D.21595 = flags & 9216;
      if (D.21595 == 0) goto <D.21608>; else goto <D.21609>;
      <D.21608>:
      D.21573 = implflags & 4096;
      if (D.21573 == 0) goto <D.21610>; else goto <D.21611>;
      <D.21610>:
      if (code_type != 3) goto <D.21612>; else goto <D.21613>;
      <D.21612>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21614>; else goto <D.21615>;
      <D.21614>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21616 = monoeg_g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i);
        vinfo->info.message = D.21616;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21617 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21617;
      }
      <D.21615>:
      ctx->valid = 0;
      return;
      <D.21613>:
      <D.21611>:
      <D.21609>:
      <D.21607>:
      D.21480 = flags & 8192;
      if (D.21480 != 0) goto <D.21618>; else goto <D.21619>;
      <D.21618>:
      if (rva != 0) goto <D.21620>; else goto <D.21621>;
      <D.21620>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21622>; else goto <D.21623>;
      <D.21622>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21624 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has RVA != 0", i);
        vinfo->info.message = D.21624;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21625 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21625;
      }
      <D.21623>:
      ctx->valid = 0;
      return;
      <D.21621>:
      i.39 = (unsigned int) i;
      D.21626 = make_coded_token (56, 6, i.39);
      D.21627 = search_sorted_table (ctx, 28, 1, D.21626);
      if (D.21627 == -1) goto <D.21628>; else goto <D.21629>;
      <D.21628>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21630>; else goto <D.21631>;
      <D.21630>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21632 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has no row in the ImplMap table", i);
        vinfo->info.message = D.21632;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21633 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21633;
      }
      <D.21631>:
      ctx->valid = 0;
      return;
      <D.21629>:
      <D.21619>:
      D.21634 = flags & 4096;
      if (D.21634 != 0) goto <D.21635>; else goto <D.21636>;
      <D.21635>:
      D.21455 = is_ctor | is_cctor;
      if (D.21455 == 0) goto <D.21637>; else goto <D.21638>;
      <D.21637>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21639>; else goto <D.21640>;
      <D.21639>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21641 = monoeg_g_strdup_printf ("Invalid method row %d is RtSpecialName but not named .ctor or .cctor", i);
        vinfo->info.message = D.21641;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21642 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21642;
      }
      <D.21640>:
      ctx->valid = 0;
      return;
      <D.21638>:
      <D.21636>:
      D.21455 = is_ctor | is_cctor;
      if (D.21455 != 0) goto <D.21643>; else goto <D.21644>;
      <D.21643>:
      D.21634 = flags & 4096;
      if (D.21634 == 0) goto <D.21645>; else goto <D.21646>;
      <D.21645>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21647>; else goto <D.21648>;
      <D.21647>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21649 = monoeg_g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i);
        vinfo->info.message = D.21649;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21650 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21650;
      }
      <D.21648>:
      ctx->valid = 0;
      return;
      <D.21646>:
      <D.21644>:
      D.21651 = data[4];
      if (D.21651 != 0) goto <D.21652>; else goto <D.21653>;
      <D.21652>:
      D.21651 = data[4];
      D.21654 = is_valid_blob_object (ctx, D.21651, 1);
      if (D.21654 == 0) goto <D.21655>; else goto <D.21656>;
      <D.21655>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21657>; else goto <D.21658>;
      <D.21657>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21651 = data[4];
        D.21659 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, D.21651);
        vinfo->info.message = D.21659;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21660 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21660;
      }
      <D.21658>:
      ctx->valid = 0;
      return;
      <D.21656>:
      <D.21653>:
      D.21661 = data[5];
      if (D.21661 == 0) goto <D.21662>; else goto <D.21663>;
      <D.21662>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21664>; else goto <D.21665>;
      <D.21664>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21666 = monoeg_g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i);
        vinfo->info.message = D.21666;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21667 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21667;
      }
      <D.21665>:
      ctx->valid = 0;
      return;
      <D.21663>:
      D.21661 = data[5];
      if (D.21661 < paramlist) goto <D.21668>; else goto <D.21669>;
      <D.21668>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21670>; else goto <D.21671>;
      <D.21670>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21661 = data[5];
        D.21672 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21661, paramlist);
        vinfo->info.message = D.21672;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21673 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21673;
      }
      <D.21671>:
      ctx->valid = 0;
      return;
      <D.21669>:
      D.21661 = data[5];
      D.21344 = ctx->image;
      D.21674 = D.21344->tables[8].rows;
      D.21675 = (int) D.21674;
      D.21676 = D.21675 + 1;
      D.21677 = (unsigned int) D.21676;
      if (D.21661 > D.21677) goto <D.21678>; else goto <D.21679>;
      <D.21678>:
      D.21352 = ctx->report_error;
      if (D.21352 != 0) goto <D.21680>; else goto <D.21681>;
      <D.21680>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21661 = data[5];
        D.21682 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x is out of range", i, D.21661);
        vinfo->info.message = D.21682;
        vinfo->exception_type = 3;
        D.21356 = ctx->errors;
        D.21683 = monoeg_g_slist_prepend (D.21356, vinfo);
        ctx->errors = D.21683;
      }
      <D.21681>:
      ctx->valid = 0;
      return;
      <D.21679>:
      paramlist = data[5];
      i = i + 1;
      <D.18890>:
      D.21684 = table->rows;
      D.21685 = (int) D.21684;
      if (D.21685 > i) goto <D.18889>; else goto <D.18891>;
      <D.18891>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


get_string_ptr (struct VerifyContext * ctx, guint offset)
{
  const char * D.21689;
  struct MonoImage * D.21690;
  const char * D.21691;
  sizetype D.21692;

  D.21690 = ctx->image;
  D.21691 = D.21690->heap_strings.data;
  D.21692 = (sizetype) offset;
  D.21689 = D.21691 + D.21692;
  return D.21689;
}


verify_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21694;
  unsigned int D.21695;
  unsigned int D.21696;
  <unnamed-unsigned:24> D.21699;
  int D.21700;
  int D.21703;
  gchar * D.21706;
  struct GSList * D.21707;
  struct GSList * D.21708;
  unsigned int D.21709;
  gchar * D.21714;
  struct GSList * D.21715;
  unsigned int i.40;
  unsigned int D.21717;
  int D.21718;
  unsigned int D.21721;
  gchar * D.21726;
  struct GSList * D.21727;
  gchar * D.21733;
  struct GSList * D.21734;
  unsigned int D.21735;
  unsigned int D.21738;
  int D.21739;
  gchar * D.21744;
  struct GSList * D.21745;
  unsigned int D.21746;
  int D.21747;
  gchar * D.21752;
  struct GSList * D.21753;
  unsigned int D.21756;
  gchar * D.21761;
  struct GSList * D.21762;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 sequence;
  guint32 remaining_params;
  guint32 current_method;
  gboolean first_param;
  int i;

  try
    {
      D.21694 = ctx->image;
      table = &D.21694->tables[8];
      sequence = 0;
      current_method = 0;
      first_param = 1;
      D.21694 = ctx->image;
      D.21695 = BIT_FIELD_REF <*D.21694, 32, 2368>;
      D.21696 = D.21695 & 16777215;
      if (D.21696 == 0) goto <D.21697>; else goto <D.21698>;
      <D.21697>:
      D.21699 = table->rows;
      D.21700 = (int) D.21699;
      if (D.21700 > 0) goto <D.21701>; else goto <D.21702>;
      <D.21701>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21704>; else goto <D.21705>;
      <D.21704>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21706 = monoeg_strdup ("Param table has rows while the method table has zero");
        vinfo->info.message = D.21706;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21708 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21708;
      }
      <D.21705>:
      ctx->valid = 0;
      return;
      <D.21702>:
      return;
      <D.21698>:
      remaining_params = get_next_param_count (ctx, &current_method);
      i = 0;
      goto <D.18935>;
      <D.18934>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.21709 = flags & 53228;
      if (D.21709 != 0) goto <D.21710>; else goto <D.21711>;
      <D.21710>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21712>; else goto <D.21713>;
      <D.21712>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21714 = monoeg_g_strdup_printf ("Invalid param row %d bad Flags value 0x%08x", i, flags);
        vinfo->info.message = D.21714;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21715 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21715;
      }
      <D.21713>:
      ctx->valid = 0;
      return;
      <D.21711>:
      i.40 = (unsigned int) i;
      D.21717 = make_coded_token (5, 8, i.40);
      D.21718 = search_sorted_table (ctx, 11, 2, D.21717);
      if (D.21718 == -1) goto <D.21719>; else goto <D.21720>;
      <D.21719>:
      D.21721 = flags & 4096;
      if (D.21721 != 0) goto <D.21722>; else goto <D.21723>;
      <D.21722>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21724>; else goto <D.21725>;
      <D.21724>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21726 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 1 but no owned row in Contant table", i);
        vinfo->info.message = D.21726;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21727 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21727;
      }
      <D.21725>:
      ctx->valid = 0;
      return;
      <D.21723>:
      goto <D.21728>;
      <D.21720>:
      D.21721 = flags & 4096;
      if (D.21721 == 0) goto <D.21729>; else goto <D.21730>;
      <D.21729>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21731>; else goto <D.21732>;
      <D.21731>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21733 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 0 but has owned row in Contant table", i);
        vinfo->info.message = D.21733;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21734 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21734;
      }
      <D.21732>:
      ctx->valid = 0;
      return;
      <D.21730>:
      <D.21728>:
      D.21735 = flags & 8192;
      if (D.21735 != 0) goto <D.21736>; else goto <D.21737>;
      <D.21736>:
      i.40 = (unsigned int) i;
      D.21738 = make_coded_token (32, 8, i.40);
      D.21739 = search_sorted_table (ctx, 13, 0, D.21738);
      if (D.21739 == -1) goto <D.21740>; else goto <D.21741>;
      <D.21740>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21742>; else goto <D.21743>;
      <D.21742>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21744 = monoeg_g_strdup_printf ("Invalid param row %d HasFieldMarshal = 1 but no owned row in FieldMarshal table", i);
        vinfo->info.message = D.21744;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21745 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21745;
      }
      <D.21743>:
      ctx->valid = 0;
      return;
      <D.21741>:
      <D.21737>:
      D.21746 = data[2];
      D.21747 = is_valid_string (ctx, D.21746);
      if (D.21747 == 0) goto <D.21748>; else goto <D.21749>;
      <D.21748>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21750>; else goto <D.21751>;
      <D.21750>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21746 = data[2];
        D.21752 = monoeg_g_strdup_printf ("Invalid param row %d Name = 1 bad token 0x%08x", i, D.21746);
        vinfo->info.message = D.21752;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21753 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21753;
      }
      <D.21751>:
      ctx->valid = 0;
      return;
      <D.21749>:
      if (first_param == 0) goto <D.21754>; else goto <D.21755>;
      <D.21754>:
      D.21756 = data[1];
      if (D.21756 <= sequence) goto <D.21757>; else goto <D.21758>;
      <D.21757>:
      D.21703 = ctx->report_error;
      if (D.21703 != 0) goto <D.21759>; else goto <D.21760>;
      <D.21759>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21756 = data[1];
        D.21761 = monoeg_g_strdup_printf ("Invalid param row %d sequece = %d previus param has %d", i, D.21756, sequence);
        vinfo->info.message = D.21761;
        vinfo->exception_type = 3;
        D.21707 = ctx->errors;
        D.21762 = monoeg_g_slist_prepend (D.21707, vinfo);
        ctx->errors = D.21762;
      }
      <D.21760>:
      ctx->valid = 0;
      return;
      <D.21758>:
      <D.21755>:
      first_param = 0;
      sequence = data[1];
      remaining_params = remaining_params + 4294967295;
      if (remaining_params == 0) goto <D.21763>; else goto <D.21764>;
      <D.21763>:
      remaining_params = get_next_param_count (ctx, &current_method);
      first_param = 1;
      <D.21764>:
      i = i + 1;
      <D.18935>:
      D.21699 = table->rows;
      D.21700 = (int) D.21699;
      if (D.21700 > i) goto <D.18934>; else goto <D.18936>;
      <D.18936>:
    }
  finally
    {
      data = {CLOBBER};
      current_method = {CLOBBER};
    }
}


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

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


get_next_param_count (struct VerifyContext * ctx, guint32 * current_method)
{
  struct MonoImage * D.21770;
  unsigned int row.41;
  int row.42;
  int row.43;
  guint32 D.21776;
  <unnamed-unsigned:24> D.21777;
  unsigned int D.21778;
  struct MonoTableInfo * table;
  guint32 row;
  guint32 paramlist;
  guint32 tmp;

  D.21770 = ctx->image;
  table = &D.21770->tables[6];
  row = *current_method;
  row.41 = row;
  row = row.41 + 1;
  row.42 = (int) row.41;
  paramlist = mono_metadata_decode_row_col (table, row.42, 5);
  goto <D.18914>;
  <D.18913>:
  row.43 = (int) row;
  tmp = mono_metadata_decode_row_col (table, row.43, 5);
  if (tmp > paramlist) goto <D.21774>; else goto <D.21775>;
  <D.21774>:
  *current_method = row;
  D.21776 = tmp - paramlist;
  return D.21776;
  <D.21775>:
  row = row + 1;
  <D.18914>:
  D.21777 = table->rows;
  D.21778 = (unsigned int) D.21777;
  if (D.21778 > row) goto <D.18913>; else goto <D.18915>;
  <D.18915>:
  D.21777 = table->rows;
  D.21778 = (unsigned int) D.21777;
  *current_method = D.21778;
  D.21776 = 4294967295;
  return D.21776;
}


verify_interfaceimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21780;
  unsigned int D.21781;
  <unnamed-unsigned:24> D.21784;
  unsigned int D.21785;
  int D.21788;
  gchar * D.21791;
  struct GSList * D.21792;
  struct GSList * D.21793;
  unsigned int D.21794;
  int D.21795;
  gchar * D.21800;
  struct GSList * D.21801;
  unsigned int D.21802;
  gchar * D.21807;
  struct GSList * D.21808;
  <unnamed-unsigned:24> D.21809;
  int D.21810;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21780 = ctx->image;
      table = &D.21780->tables[9];
      i = 0;
      goto <D.18947>;
      <D.18946>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.21781 = data[0];
      if (D.21781 != 0) goto <D.21782>; else goto <D.21783>;
      <D.21782>:
      D.21781 = data[0];
      D.21780 = ctx->image;
      D.21784 = D.21780->tables[2].rows;
      D.21785 = (unsigned int) D.21784;
      if (D.21781 > D.21785) goto <D.21786>; else goto <D.21787>;
      <D.21786>:
      D.21788 = ctx->report_error;
      if (D.21788 != 0) goto <D.21789>; else goto <D.21790>;
      <D.21789>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21781 = data[0];
        D.21791 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Class field 0x%08x", i, D.21781);
        vinfo->info.message = D.21791;
        vinfo->exception_type = 3;
        D.21792 = ctx->errors;
        D.21793 = monoeg_g_slist_prepend (D.21792, vinfo);
        ctx->errors = D.21793;
      }
      <D.21790>:
      ctx->valid = 0;
      return;
      <D.21787>:
      <D.21783>:
      D.21794 = data[1];
      D.21795 = is_valid_coded_index (ctx, 0, D.21794);
      if (D.21795 == 0) goto <D.21796>; else goto <D.21797>;
      <D.21796>:
      D.21788 = ctx->report_error;
      if (D.21788 != 0) goto <D.21798>; else goto <D.21799>;
      <D.21798>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21794 = data[1];
        D.21800 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field coded index 0x%08x", i, D.21794);
        vinfo->info.message = D.21800;
        vinfo->exception_type = 3;
        D.21792 = ctx->errors;
        D.21801 = monoeg_g_slist_prepend (D.21792, vinfo);
        ctx->errors = D.21801;
      }
      <D.21799>:
      ctx->valid = 0;
      return;
      <D.21797>:
      D.21794 = data[1];
      D.21802 = get_coded_index_token (0, D.21794);
      if (D.21802 == 0) goto <D.21803>; else goto <D.21804>;
      <D.21803>:
      D.21788 = ctx->report_error;
      if (D.21788 != 0) goto <D.21805>; else goto <D.21806>;
      <D.21805>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21807 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field is null", i);
        vinfo->info.message = D.21807;
        vinfo->exception_type = 3;
        D.21792 = ctx->errors;
        D.21808 = monoeg_g_slist_prepend (D.21792, vinfo);
        ctx->errors = D.21808;
      }
      <D.21806>:
      ctx->valid = 0;
      return;
      <D.21804>:
      i = i + 1;
      <D.18947>:
      D.21809 = table->rows;
      D.21810 = (int) D.21809;
      if (D.21810 > i) goto <D.18946>; else goto <D.18948>;
      <D.18948>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_memberref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21814;
  unsigned int D.21815;
  int D.21816;
  int D.21819;
  gchar * D.21822;
  struct GSList * D.21823;
  struct GSList * D.21824;
  unsigned int D.21825;
  gchar * D.21830;
  struct GSList * D.21831;
  unsigned int D.21832;
  int D.21833;
  gchar * D.21838;
  struct GSList * D.21839;
  unsigned int D.21840;
  int D.21843;
  gchar * D.21848;
  struct GSList * D.21849;
  <unnamed-unsigned:24> D.21850;
  int D.21851;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21814 = ctx->image;
      table = &D.21814->tables[10];
      i = 0;
      goto <D.18960>;
      <D.18959>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21815 = data[0];
      D.21816 = is_valid_coded_index (ctx, 41, D.21815);
      if (D.21816 == 0) goto <D.21817>; else goto <D.21818>;
      <D.21817>:
      D.21819 = ctx->report_error;
      if (D.21819 != 0) goto <D.21820>; else goto <D.21821>;
      <D.21820>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21815 = data[0];
        D.21822 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded index 0x%08x", i, D.21815);
        vinfo->info.message = D.21822;
        vinfo->exception_type = 3;
        D.21823 = ctx->errors;
        D.21824 = monoeg_g_slist_prepend (D.21823, vinfo);
        ctx->errors = D.21824;
      }
      <D.21821>:
      ctx->valid = 0;
      return;
      <D.21818>:
      D.21815 = data[0];
      D.21825 = get_coded_index_token (41, D.21815);
      if (D.21825 == 0) goto <D.21826>; else goto <D.21827>;
      <D.21826>:
      D.21819 = ctx->report_error;
      if (D.21819 != 0) goto <D.21828>; else goto <D.21829>;
      <D.21828>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21830 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded is null", i);
        vinfo->info.message = D.21830;
        vinfo->exception_type = 3;
        D.21823 = ctx->errors;
        D.21831 = monoeg_g_slist_prepend (D.21823, vinfo);
        ctx->errors = D.21831;
      }
      <D.21829>:
      ctx->valid = 0;
      return;
      <D.21827>:
      D.21832 = data[1];
      D.21833 = is_valid_non_empty_string (ctx, D.21832);
      if (D.21833 == 0) goto <D.21834>; else goto <D.21835>;
      <D.21834>:
      D.21819 = ctx->report_error;
      if (D.21819 != 0) goto <D.21836>; else goto <D.21837>;
      <D.21836>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21832 = data[1];
        D.21838 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, D.21832);
        vinfo->info.message = D.21838;
        vinfo->exception_type = 3;
        D.21823 = ctx->errors;
        D.21839 = monoeg_g_slist_prepend (D.21823, vinfo);
        ctx->errors = D.21839;
      }
      <D.21837>:
      ctx->valid = 0;
      return;
      <D.21835>:
      D.21840 = data[2];
      if (D.21840 != 0) goto <D.21841>; else goto <D.21842>;
      <D.21841>:
      D.21840 = data[2];
      D.21843 = is_valid_blob_object (ctx, D.21840, 1);
      if (D.21843 == 0) goto <D.21844>; else goto <D.21845>;
      <D.21844>:
      D.21819 = ctx->report_error;
      if (D.21819 != 0) goto <D.21846>; else goto <D.21847>;
      <D.21846>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21840 = data[2];
        D.21848 = monoeg_g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, D.21840);
        vinfo->info.message = D.21848;
        vinfo->exception_type = 3;
        D.21823 = ctx->errors;
        D.21849 = monoeg_g_slist_prepend (D.21823, vinfo);
        ctx->errors = D.21849;
      }
      <D.21847>:
      ctx->valid = 0;
      return;
      <D.21845>:
      <D.21842>:
      i = i + 1;
      <D.18960>:
      D.21850 = table->rows;
      D.21851 = (int) D.21850;
      if (D.21851 > i) goto <D.18959>; else goto <D.18961>;
      <D.18961>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_constant_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21855;
  unsigned int D.21856;
  _Bool D.21857;
  _Bool D.21858;
  _Bool D.21859;
  int D.21862;
  gchar * D.21865;
  struct GSList * D.21866;
  struct GSList * D.21867;
  unsigned int D.21868;
  int D.21869;
  gchar * D.21874;
  struct GSList * D.21875;
  unsigned int D.21876;
  gchar * D.21881;
  struct GSList * D.21882;
  unsigned int D.21883;
  int D.21884;
  gchar * D.21889;
  struct GSList * D.21890;
  <unnamed-unsigned:24> D.21891;
  int D.21892;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 type;
  int i;

  try
    {
      D.21855 = ctx->image;
      table = &D.21855->tables[11];
      i = 0;
      goto <D.18984>;
      <D.18983>:
      mono_metadata_decode_row (table, i, &data, 4);
      type = data[0];
      D.21856 = type + 4294967294;
      D.21857 = D.21856 > 12;
      D.21858 = type != 18;
      D.21859 = D.21857 & D.21858;
      if (D.21859 != 0) goto <D.21860>; else goto <D.21861>;
      <D.21860>:
      D.21862 = ctx->report_error;
      if (D.21862 != 0) goto <D.21863>; else goto <D.21864>;
      <D.21863>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21865 = monoeg_g_strdup_printf ("Invalid Constant row %d Type field 0x%08x", i, type);
        vinfo->info.message = D.21865;
        vinfo->exception_type = 3;
        D.21866 = ctx->errors;
        D.21867 = monoeg_g_slist_prepend (D.21866, vinfo);
        ctx->errors = D.21867;
      }
      <D.21864>:
      ctx->valid = 0;
      return;
      <D.21861>:
      D.21868 = data[2];
      D.21869 = is_valid_coded_index (ctx, 5, D.21868);
      if (D.21869 == 0) goto <D.21870>; else goto <D.21871>;
      <D.21870>:
      D.21862 = ctx->report_error;
      if (D.21862 != 0) goto <D.21872>; else goto <D.21873>;
      <D.21872>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21868 = data[2];
        D.21874 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded index 0x%08x", i, D.21868);
        vinfo->info.message = D.21874;
        vinfo->exception_type = 3;
        D.21866 = ctx->errors;
        D.21875 = monoeg_g_slist_prepend (D.21866, vinfo);
        ctx->errors = D.21875;
      }
      <D.21873>:
      ctx->valid = 0;
      return;
      <D.21871>:
      D.21868 = data[2];
      D.21876 = get_coded_index_token (5, D.21868);
      if (D.21876 == 0) goto <D.21877>; else goto <D.21878>;
      <D.21877>:
      D.21862 = ctx->report_error;
      if (D.21862 != 0) goto <D.21879>; else goto <D.21880>;
      <D.21879>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21881 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded is null", i);
        vinfo->info.message = D.21881;
        vinfo->exception_type = 3;
        D.21866 = ctx->errors;
        D.21882 = monoeg_g_slist_prepend (D.21866, vinfo);
        ctx->errors = D.21882;
      }
      <D.21880>:
      ctx->valid = 0;
      return;
      <D.21878>:
      D.21883 = data[3];
      D.21884 = is_valid_constant (ctx, type, D.21883);
      if (D.21884 == 0) goto <D.21885>; else goto <D.21886>;
      <D.21885>:
      D.21862 = ctx->report_error;
      if (D.21862 != 0) goto <D.21887>; else goto <D.21888>;
      <D.21887>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21883 = data[3];
        D.21889 = monoeg_g_strdup_printf ("Invalid Constant row %d Value field 0x%08x", i, D.21883);
        vinfo->info.message = D.21889;
        vinfo->exception_type = 3;
        D.21866 = ctx->errors;
        D.21890 = monoeg_g_slist_prepend (D.21866, vinfo);
        ctx->errors = D.21890;
      }
      <D.21888>:
      ctx->valid = 0;
      return;
      <D.21886>:
      i = i + 1;
      <D.18984>:
      D.21891 = table->rows;
      D.21892 = (int) D.21891;
      if (D.21892 > i) goto <D.18983>; else goto <D.18985>;
      <D.18985>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_constant (struct VerifyContext * ctx, guint32 type, guint32 offset)
{
  struct MonoImage * D.21896;
  struct MonoStreamHeader * D.21897;
  unsigned int D.21898;
  int D.21901;
  gchar * D.21904;
  struct GSList * D.21905;
  struct GSList * D.21906;
  gboolean D.21907;
  unsigned int D.21908;
  unsigned int D.21909;
  const char * D.21910;
  sizetype D.21911;
  sizetype D.21912;
  sizetype D.21913;
  const char * D.21914;
  int D.21915;
  gchar * D.21920;
  struct GSList * D.21921;
  unsigned int bytes.44;
  unsigned int entry_size.45;
  unsigned int D.21928;
  unsigned int D.21930;
  unsigned int D.21933;
  unsigned int D.21934;
  gchar * D.21935;
  struct GSList * D.21936;
  gchar * D.21941;
  struct GSList * D.21942;
  unsigned int D.21945;
  unsigned int D.21947;
  gchar * D.21950;
  struct GSList * D.21951;
  unsigned int D.21954;
  gchar * D.21959;
  struct GSList * D.21960;
  struct OffsetAndSize blob;
  guint32 size;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.21896 = ctx->image;
      D.21897 = &D.21896->heap_blob;
      blob = get_metadata_stream (ctx, D.21897);
      D.21898 = blob.size;
      if (D.21898 < offset) goto <D.21899>; else goto <D.21900>;
      <D.21899>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21902>; else goto <D.21903>;
      <D.21902>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21904 = monoeg_strdup ("ContantValue: invalid offset");
        vinfo->info.message = D.21904;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21906 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21906;
      }
      <D.21903>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21900>:
      D.21898 = blob.size;
      D.21908 = blob.offset;
      D.21909 = D.21898 - D.21908;
      D.21910 = ctx->data;
      D.21911 = (sizetype) offset;
      D.21908 = blob.offset;
      D.21912 = (sizetype) D.21908;
      D.21913 = D.21911 + D.21912;
      D.21914 = D.21910 + D.21913;
      D.21915 = decode_value (D.21914, D.21909, &entry_size, &bytes);
      if (D.21915 == 0) goto <D.21916>; else goto <D.21917>;
      <D.21916>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21918>; else goto <D.21919>;
      <D.21918>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21920 = monoeg_strdup ("ContantValue: not enough space to decode size");
        vinfo->info.message = D.21920;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21921 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21921;
      }
      <D.21919>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21917>:
      if (type == 14) goto <D.21922>; else goto <D.21923>;
      <D.21922>:
      bytes.44 = bytes;
      offset = offset + bytes.44;
      entry_size.45 = entry_size;
      D.21928 = offset + entry_size.45;
      D.21898 = blob.size;
      if (D.21928 > D.21898) goto <D.21925>; else goto <D.21929>;
      <D.21929>:
      entry_size.45 = entry_size;
      D.21930 = ~entry_size.45;
      if (D.21930 < offset) goto <D.21925>; else goto <D.21926>;
      <D.21925>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21931>; else goto <D.21932>;
      <D.21931>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21898 = blob.size;
        D.21933 = D.21898 - offset;
        entry_size.45 = entry_size;
        D.21934 = entry_size.45 * 2;
        D.21935 = monoeg_g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", D.21934, D.21933);
        vinfo->info.message = D.21935;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21936 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21936;
      }
      <D.21932>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21926>:
      D.21907 = 1;
      return D.21907;
      <D.21923>:
      switch (type) <default: <D.18669>, case 2: <D.18655>, case 3: <D.18659>, case 4: <D.18656>, case 5: <D.18657>, case 6: <D.18660>, case 7: <D.18661>, case 8: <D.18662>, case 9: <D.18663>, case 10: <D.18666>, case 11: <D.18667>, case 12: <D.18664>, case 13: <D.18668>, case 18: <D.18665>>
      <D.18655>:
      <D.18656>:
      <D.18657>:
      size = 1;
      goto <D.18658>;
      <D.18659>:
      <D.18660>:
      <D.18661>:
      size = 2;
      goto <D.18658>;
      <D.18662>:
      <D.18663>:
      <D.18664>:
      <D.18665>:
      size = 4;
      goto <D.18658>;
      <D.18666>:
      <D.18667>:
      <D.18668>:
      size = 8;
      goto <D.18658>;
      <D.18669>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 2221);
      <D.18658>:
      entry_size.45 = entry_size;
      if (size != entry_size.45) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21939>; else goto <D.21940>;
      <D.21939>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        entry_size.45 = entry_size;
        D.21941 = monoeg_g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size.45);
        vinfo->info.message = D.21941;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21942 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21942;
      }
      <D.21940>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21938>:
      bytes.44 = bytes;
      offset = offset + bytes.44;
      D.21945 = offset + size;
      D.21898 = blob.size;
      if (D.21945 > D.21898) goto <D.21943>; else goto <D.21946>;
      <D.21946>:
      D.21947 = ~size;
      if (D.21947 < offset) goto <D.21943>; else goto <D.21944>;
      <D.21943>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21948>; else goto <D.21949>;
      <D.21948>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21898 = blob.size;
        D.21933 = D.21898 - offset;
        D.21950 = monoeg_g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, D.21933);
        vinfo->info.message = D.21950;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21951 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21951;
      }
      <D.21949>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21944>:
      if (type == 18) goto <D.21952>; else goto <D.21953>;
      <D.21952>:
      D.21910 = ctx->data;
      D.21908 = blob.offset;
      D.21912 = (sizetype) D.21908;
      D.21911 = (sizetype) offset;
      D.21913 = D.21912 + D.21911;
      D.21914 = D.21910 + D.21913;
      D.21954 = MEM[(const guint32 *)D.21914];
      if (D.21954 != 0) goto <D.21955>; else goto <D.21956>;
      <D.21955>:
      D.21901 = ctx->report_error;
      if (D.21901 != 0) goto <D.21957>; else goto <D.21958>;
      <D.21957>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21959 = monoeg_g_strdup_printf ("ContantValue: Type is class but value is not null");
        vinfo->info.message = D.21959;
        vinfo->exception_type = 3;
        D.21905 = ctx->errors;
        D.21960 = monoeg_g_slist_prepend (D.21905, vinfo);
        ctx->errors = D.21960;
      }
      <D.21958>:
      ctx->valid = 0;
      D.21907 = 0;
      return D.21907;
      <D.21956>:
      <D.21953>:
      D.21907 = 1;
      return D.21907;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


verify_cattr_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21963;
  unsigned int D.21964;
  int D.21965;
  int D.21968;
  gchar * D.21971;
  struct GSList * D.21972;
  struct GSList * D.21973;
  unsigned int D.21976;
  int D.21977;
  unsigned int D.21979;
  gchar * D.21982;
  struct GSList * D.21983;
  unsigned int D.21984;
  int D.21987;
  gchar * D.21992;
  struct GSList * D.21993;
  <unnamed-unsigned:24> D.21994;
  int D.21995;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.21963 = ctx->image;
      table = &D.21963->tables[12];
      i = 0;
      goto <D.18996>;
      <D.18995>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.21964 = data[0];
      D.21965 = is_valid_coded_index (ctx, 10, D.21964);
      if (D.21965 == 0) goto <D.21966>; else goto <D.21967>;
      <D.21966>:
      D.21968 = ctx->report_error;
      if (D.21968 != 0) goto <D.21969>; else goto <D.21970>;
      <D.21969>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21964 = data[0];
        D.21971 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, D.21964);
        vinfo->info.message = D.21971;
        vinfo->exception_type = 3;
        D.21972 = ctx->errors;
        D.21973 = monoeg_g_slist_prepend (D.21972, vinfo);
        ctx->errors = D.21973;
      }
      <D.21970>:
      ctx->valid = 0;
      return;
      <D.21967>:
      D.21976 = data[1];
      D.21977 = is_valid_coded_index (ctx, 65, D.21976);
      if (D.21977 == 0) goto <D.21974>; else goto <D.21978>;
      <D.21978>:
      D.21976 = data[1];
      D.21979 = get_coded_index_token (65, D.21976);
      if (D.21979 == 0) goto <D.21974>; else goto <D.21975>;
      <D.21974>:
      D.21968 = ctx->report_error;
      if (D.21968 != 0) goto <D.21980>; else goto <D.21981>;
      <D.21980>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21976 = data[1];
        D.21982 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Type field 0x%08x", i, D.21976);
        vinfo->info.message = D.21982;
        vinfo->exception_type = 3;
        D.21972 = ctx->errors;
        D.21983 = monoeg_g_slist_prepend (D.21972, vinfo);
        ctx->errors = D.21983;
      }
      <D.21981>:
      ctx->valid = 0;
      return;
      <D.21975>:
      D.21984 = data[2];
      if (D.21984 != 0) goto <D.21985>; else goto <D.21986>;
      <D.21985>:
      D.21984 = data[2];
      D.21987 = is_valid_blob_object (ctx, D.21984, 0);
      if (D.21987 == 0) goto <D.21988>; else goto <D.21989>;
      <D.21988>:
      D.21968 = ctx->report_error;
      if (D.21968 != 0) goto <D.21990>; else goto <D.21991>;
      <D.21990>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21984 = data[2];
        D.21992 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, D.21984);
        vinfo->info.message = D.21992;
        vinfo->exception_type = 3;
        D.21972 = ctx->errors;
        D.21993 = monoeg_g_slist_prepend (D.21972, vinfo);
        ctx->errors = D.21993;
      }
      <D.21991>:
      ctx->valid = 0;
      return;
      <D.21989>:
      <D.21986>:
      i = i + 1;
      <D.18996>:
      D.21994 = table->rows;
      D.21995 = (int) D.21994;
      if (D.21995 > i) goto <D.18995>; else goto <D.18997>;
      <D.18997>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_marshal_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21999;
  unsigned int D.22000;
  int D.22001;
  int D.22004;
  gchar * D.22007;
  struct GSList * D.22008;
  struct GSList * D.22009;
  unsigned int D.22010;
  gchar * D.22015;
  struct GSList * D.22016;
  unsigned int D.22017;
  gchar * D.22022;
  struct GSList * D.22023;
  int D.22024;
  gchar * D.22029;
  struct GSList * D.22030;
  <unnamed-unsigned:24> D.22031;
  int D.22032;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.21999 = ctx->image;
      table = &D.21999->tables[13];
      i = 0;
      goto <D.19029>;
      <D.19028>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22000 = data[0];
      D.22001 = is_valid_coded_index (ctx, 32, D.22000);
      if (D.22001 == 0) goto <D.22002>; else goto <D.22003>;
      <D.22002>:
      D.22004 = ctx->report_error;
      if (D.22004 != 0) goto <D.22005>; else goto <D.22006>;
      <D.22005>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22000 = data[0];
        D.22007 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field 0x%08x", i, D.22000);
        vinfo->info.message = D.22007;
        vinfo->exception_type = 3;
        D.22008 = ctx->errors;
        D.22009 = monoeg_g_slist_prepend (D.22008, vinfo);
        ctx->errors = D.22009;
      }
      <D.22006>:
      ctx->valid = 0;
      return;
      <D.22003>:
      D.22000 = data[0];
      D.22010 = get_coded_index_token (32, D.22000);
      if (D.22010 == 0) goto <D.22011>; else goto <D.22012>;
      <D.22011>:
      D.22004 = ctx->report_error;
      if (D.22004 != 0) goto <D.22013>; else goto <D.22014>;
      <D.22013>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22015 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field is null", i);
        vinfo->info.message = D.22015;
        vinfo->exception_type = 3;
        D.22008 = ctx->errors;
        D.22016 = monoeg_g_slist_prepend (D.22008, vinfo);
        ctx->errors = D.22016;
      }
      <D.22014>:
      ctx->valid = 0;
      return;
      <D.22012>:
      D.22017 = data[1];
      if (D.22017 == 0) goto <D.22018>; else goto <D.22019>;
      <D.22018>:
      D.22004 = ctx->report_error;
      if (D.22004 != 0) goto <D.22020>; else goto <D.22021>;
      <D.22020>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22022 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i);
        vinfo->info.message = D.22022;
        vinfo->exception_type = 3;
        D.22008 = ctx->errors;
        D.22023 = monoeg_g_slist_prepend (D.22008, vinfo);
        ctx->errors = D.22023;
      }
      <D.22021>:
      ctx->valid = 0;
      return;
      <D.22019>:
      D.22017 = data[1];
      D.22024 = is_valid_blob_object (ctx, D.22017, 1);
      if (D.22024 == 0) goto <D.22025>; else goto <D.22026>;
      <D.22025>:
      D.22004 = ctx->report_error;
      if (D.22004 != 0) goto <D.22027>; else goto <D.22028>;
      <D.22027>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22017 = data[1];
        D.22029 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, D.22017);
        vinfo->info.message = D.22029;
        vinfo->exception_type = 3;
        D.22008 = ctx->errors;
        D.22030 = monoeg_g_slist_prepend (D.22008, vinfo);
        ctx->errors = D.22030;
      }
      <D.22028>:
      ctx->valid = 0;
      return;
      <D.22026>:
      i = i + 1;
      <D.19029>:
      D.22031 = table->rows;
      D.22032 = (int) D.22031;
      if (D.22032 > i) goto <D.19028>; else goto <D.19030>;
      <D.19030>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_decl_security_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22036;
  unsigned int D.22037;
  int D.22038;
  int D.22041;
  gchar * D.22044;
  struct GSList * D.22045;
  struct GSList * D.22046;
  unsigned int D.22047;
  gchar * D.22052;
  struct GSList * D.22053;
  unsigned int D.22054;
  gchar * D.22059;
  struct GSList * D.22060;
  <unnamed-unsigned:24> D.22061;
  int D.22062;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22036 = ctx->image;
      table = &D.22036->tables[14];
      i = 0;
      goto <D.19051>;
      <D.19050>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22037 = data[1];
      D.22038 = is_valid_coded_index (ctx, 36, D.22037);
      if (D.22038 == 0) goto <D.22039>; else goto <D.22040>;
      <D.22039>:
      D.22041 = ctx->report_error;
      if (D.22041 != 0) goto <D.22042>; else goto <D.22043>;
      <D.22042>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22037 = data[1];
        D.22044 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field 0x%08x", i, D.22037);
        vinfo->info.message = D.22044;
        vinfo->exception_type = 3;
        D.22045 = ctx->errors;
        D.22046 = monoeg_g_slist_prepend (D.22045, vinfo);
        ctx->errors = D.22046;
      }
      <D.22043>:
      ctx->valid = 0;
      return;
      <D.22040>:
      D.22037 = data[1];
      D.22047 = get_coded_index_token (36, D.22037);
      if (D.22047 == 0) goto <D.22048>; else goto <D.22049>;
      <D.22048>:
      D.22041 = ctx->report_error;
      if (D.22041 != 0) goto <D.22050>; else goto <D.22051>;
      <D.22050>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22052 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field is null", i);
        vinfo->info.message = D.22052;
        vinfo->exception_type = 3;
        D.22045 = ctx->errors;
        D.22053 = monoeg_g_slist_prepend (D.22045, vinfo);
        ctx->errors = D.22053;
      }
      <D.22051>:
      ctx->valid = 0;
      return;
      <D.22049>:
      D.22054 = data[2];
      if (D.22054 == 0) goto <D.22055>; else goto <D.22056>;
      <D.22055>:
      D.22041 = ctx->report_error;
      if (D.22041 != 0) goto <D.22057>; else goto <D.22058>;
      <D.22057>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22059 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i);
        vinfo->info.message = D.22059;
        vinfo->exception_type = 3;
        D.22045 = ctx->errors;
        D.22060 = monoeg_g_slist_prepend (D.22045, vinfo);
        ctx->errors = D.22060;
      }
      <D.22058>:
      ctx->valid = 0;
      return;
      <D.22056>:
      i = i + 1;
      <D.19051>:
      D.22061 = table->rows;
      D.22062 = (int) D.22061;
      if (D.22062 > i) goto <D.19050>; else goto <D.19052>;
      <D.19052>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_class_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22066;
  unsigned int D.22069;
  <unnamed-unsigned:24> D.22071;
  int D.22072;
  int D.22073;
  unsigned int D.22074;
  int D.22075;
  gchar * D.22078;
  struct GSList * D.22079;
  struct GSList * D.22080;
  unsigned int D.22081;
  gchar * D.22084;
  struct GSList * D.22085;
  <unnamed-unsigned:24> D.22086;
  int D.22087;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22066 = ctx->image;
      table = &D.22066->tables[15];
      i = 0;
      goto <D.19083>;
      <D.19082>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22069 = data[2];
      if (D.22069 == 0) goto <D.22067>; else goto <D.22070>;
      <D.22070>:
      D.22069 = data[2];
      D.22066 = ctx->image;
      D.22071 = D.22066->tables[2].rows;
      D.22072 = (int) D.22071;
      D.22073 = D.22072 + 1;
      D.22074 = (unsigned int) D.22073;
      if (D.22069 > D.22074) goto <D.22067>; else goto <D.22068>;
      <D.22067>:
      D.22075 = ctx->report_error;
      if (D.22075 != 0) goto <D.22076>; else goto <D.22077>;
      <D.22076>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22069 = data[2];
        D.22078 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Parent field 0x%08x", i, D.22069);
        vinfo->info.message = D.22078;
        vinfo->exception_type = 3;
        D.22079 = ctx->errors;
        D.22080 = monoeg_g_slist_prepend (D.22079, vinfo);
        ctx->errors = D.22080;
      }
      <D.22077>:
      ctx->valid = 0;
      return;
      <D.22068>:
      D.22081 = data[0];
      switch (D.22081) <default: <D.19080>, case 0: <D.19070>, case 1: <D.19071>, case 2: <D.19072>, case 4: <D.19073>, case 8: <D.19074>, case 16: <D.19075>, case 32: <D.19076>, case 64: <D.19077>, case 128: <D.19078>>
      <D.19070>:
      <D.19071>:
      <D.19072>:
      <D.19073>:
      <D.19074>:
      <D.19075>:
      <D.19076>:
      <D.19077>:
      <D.19078>:
      goto <D.19079>;
      <D.19080>:
      D.22075 = ctx->report_error;
      if (D.22075 != 0) goto <D.22082>; else goto <D.22083>;
      <D.22082>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22081 = data[0];
        D.22084 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Packing field %d", i, D.22081);
        vinfo->info.message = D.22084;
        vinfo->exception_type = 3;
        D.22079 = ctx->errors;
        D.22085 = monoeg_g_slist_prepend (D.22079, vinfo);
        ctx->errors = D.22085;
      }
      <D.22083>:
      ctx->valid = 0;
      return;
      <D.19079>:
      i = i + 1;
      <D.19083>:
      D.22086 = table->rows;
      D.22087 = (int) D.22086;
      if (D.22087 > i) goto <D.19082>; else goto <D.19084>;
      <D.19084>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22092;
  unsigned int D.22095;
  <unnamed-unsigned:24> D.22097;
  int D.22098;
  int D.22099;
  unsigned int D.22100;
  int D.22101;
  gchar * D.22104;
  struct GSList * D.22105;
  struct GSList * D.22106;
  <unnamed-unsigned:24> D.22107;
  int D.22108;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22092 = ctx->image;
      table = &D.22092->tables[16];
      i = 0;
      goto <D.19093>;
      <D.19092>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22095 = data[1];
      if (D.22095 == 0) goto <D.22093>; else goto <D.22096>;
      <D.22096>:
      D.22095 = data[1];
      D.22092 = ctx->image;
      D.22097 = D.22092->tables[4].rows;
      D.22098 = (int) D.22097;
      D.22099 = D.22098 + 1;
      D.22100 = (unsigned int) D.22099;
      if (D.22095 > D.22100) goto <D.22093>; else goto <D.22094>;
      <D.22093>:
      D.22101 = ctx->report_error;
      if (D.22101 != 0) goto <D.22102>; else goto <D.22103>;
      <D.22102>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22095 = data[1];
        D.22104 = monoeg_g_strdup_printf ("Invalid FieldLayout row %d Field field 0x%08x", i, D.22095);
        vinfo->info.message = D.22104;
        vinfo->exception_type = 3;
        D.22105 = ctx->errors;
        D.22106 = monoeg_g_slist_prepend (D.22105, vinfo);
        ctx->errors = D.22106;
      }
      <D.22103>:
      ctx->valid = 0;
      return;
      <D.22094>:
      i = i + 1;
      <D.19093>:
      D.22107 = table->rows;
      D.22108 = (int) D.22107;
      if (D.22108 > i) goto <D.19092>; else goto <D.19094>;
      <D.19094>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_standalonesig_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22112;
  unsigned int D.22113;
  int D.22116;
  int D.22119;
  gchar * D.22122;
  struct GSList * D.22123;
  struct GSList * D.22124;
  <unnamed-unsigned:24> D.22125;
  int D.22126;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22112 = ctx->image;
      table = &D.22112->tables[17];
      i = 0;
      goto <D.19103>;
      <D.19102>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22113 = data[0];
      if (D.22113 != 0) goto <D.22114>; else goto <D.22115>;
      <D.22114>:
      D.22113 = data[0];
      D.22116 = is_valid_blob_object (ctx, D.22113, 1);
      if (D.22116 == 0) goto <D.22117>; else goto <D.22118>;
      <D.22117>:
      D.22119 = ctx->report_error;
      if (D.22119 != 0) goto <D.22120>; else goto <D.22121>;
      <D.22120>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22113 = data[0];
        D.22122 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, D.22113);
        vinfo->info.message = D.22122;
        vinfo->exception_type = 3;
        D.22123 = ctx->errors;
        D.22124 = monoeg_g_slist_prepend (D.22123, vinfo);
        ctx->errors = D.22124;
      }
      <D.22121>:
      ctx->valid = 0;
      return;
      <D.22118>:
      <D.22115>:
      i = i + 1;
      <D.19103>:
      D.22125 = table->rows;
      D.22126 = (int) D.22125;
      if (D.22126 > i) goto <D.19102>; else goto <D.19104>;
      <D.19104>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_eventmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22130;
  unsigned int D.22133;
  <unnamed-unsigned:24> D.22135;
  int D.22136;
  int D.22137;
  unsigned int D.22138;
  int D.22139;
  gchar * D.22142;
  struct GSList * D.22143;
  struct GSList * D.22144;
  unsigned int D.22147;
  gchar * D.22151;
  struct GSList * D.22152;
  <unnamed-unsigned:24> D.22153;
  int D.22154;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 eventlist;
  int i;

  try
    {
      D.22130 = ctx->image;
      table = &D.22130->tables[18];
      eventlist = 0;
      i = 0;
      goto <D.19125>;
      <D.19124>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22133 = data[0];
      if (D.22133 == 0) goto <D.22131>; else goto <D.22134>;
      <D.22134>:
      D.22133 = data[0];
      D.22130 = ctx->image;
      D.22135 = D.22130->tables[2].rows;
      D.22136 = (int) D.22135;
      D.22137 = D.22136 + 1;
      D.22138 = (unsigned int) D.22137;
      if (D.22133 > D.22138) goto <D.22131>; else goto <D.22132>;
      <D.22131>:
      D.22139 = ctx->report_error;
      if (D.22139 != 0) goto <D.22140>; else goto <D.22141>;
      <D.22140>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22133 = data[0];
        D.22142 = monoeg_g_strdup_printf ("Invalid EventMap row %d Parent field 0x%08x", i, D.22133);
        vinfo->info.message = D.22142;
        vinfo->exception_type = 3;
        D.22143 = ctx->errors;
        D.22144 = monoeg_g_slist_prepend (D.22143, vinfo);
        ctx->errors = D.22144;
      }
      <D.22141>:
      ctx->valid = 0;
      return;
      <D.22132>:
      D.22147 = data[1];
      if (D.22147 == 0) goto <D.22145>; else goto <D.22148>;
      <D.22148>:
      D.22147 = data[1];
      if (D.22147 <= eventlist) goto <D.22145>; else goto <D.22146>;
      <D.22145>:
      D.22139 = ctx->report_error;
      if (D.22139 != 0) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22147 = data[1];
        D.22151 = monoeg_g_strdup_printf ("Invalid EventMap row %d EventList field %d", i, D.22147);
        vinfo->info.message = D.22151;
        vinfo->exception_type = 3;
        D.22143 = ctx->errors;
        D.22152 = monoeg_g_slist_prepend (D.22143, vinfo);
        ctx->errors = D.22152;
      }
      <D.22150>:
      ctx->valid = 0;
      return;
      <D.22146>:
      eventlist = data[1];
      i = i + 1;
      <D.19125>:
      D.22153 = table->rows;
      D.22154 = (int) D.22153;
      if (D.22154 > i) goto <D.19124>; else goto <D.19126>;
      <D.19126>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_event_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22158;
  unsigned int D.22159;
  unsigned int D.22160;
  int D.22163;
  gchar * D.22166;
  struct GSList * D.22167;
  struct GSList * D.22168;
  unsigned int D.22169;
  int D.22170;
  gchar * D.22175;
  struct GSList * D.22176;
  unsigned int D.22177;
  int D.22178;
  gchar * D.22183;
  struct GSList * D.22184;
  <unnamed-unsigned:24> D.22185;
  int D.22186;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22158 = ctx->image;
      table = &D.22158->tables[20];
      i = 0;
      goto <D.19137>;
      <D.19136>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22159 = data[0];
      D.22160 = D.22159 & 4294965759;
      if (D.22160 != 0) goto <D.22161>; else goto <D.22162>;
      <D.22161>:
      D.22163 = ctx->report_error;
      if (D.22163 != 0) goto <D.22164>; else goto <D.22165>;
      <D.22164>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22159 = data[0];
        D.22166 = monoeg_g_strdup_printf ("Invalid Event row %d EventFlags field %08x", i, D.22159);
        vinfo->info.message = D.22166;
        vinfo->exception_type = 3;
        D.22167 = ctx->errors;
        D.22168 = monoeg_g_slist_prepend (D.22167, vinfo);
        ctx->errors = D.22168;
      }
      <D.22165>:
      ctx->valid = 0;
      return;
      <D.22162>:
      D.22169 = data[1];
      D.22170 = is_valid_non_empty_string (ctx, D.22169);
      if (D.22170 == 0) goto <D.22171>; else goto <D.22172>;
      <D.22171>:
      D.22163 = ctx->report_error;
      if (D.22163 != 0) goto <D.22173>; else goto <D.22174>;
      <D.22173>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22169 = data[1];
        D.22175 = monoeg_g_strdup_printf ("Invalid Event row %d Name field %08x", i, D.22169);
        vinfo->info.message = D.22175;
        vinfo->exception_type = 3;
        D.22167 = ctx->errors;
        D.22176 = monoeg_g_slist_prepend (D.22167, vinfo);
        ctx->errors = D.22176;
      }
      <D.22174>:
      ctx->valid = 0;
      return;
      <D.22172>:
      D.22177 = data[2];
      D.22178 = is_valid_coded_index (ctx, 0, D.22177);
      if (D.22178 == 0) goto <D.22179>; else goto <D.22180>;
      <D.22179>:
      D.22163 = ctx->report_error;
      if (D.22163 != 0) goto <D.22181>; else goto <D.22182>;
      <D.22181>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22177 = data[2];
        D.22183 = monoeg_g_strdup_printf ("Invalid Event row %d EventType field %08x", i, D.22177);
        vinfo->info.message = D.22183;
        vinfo->exception_type = 3;
        D.22167 = ctx->errors;
        D.22184 = monoeg_g_slist_prepend (D.22167, vinfo);
        ctx->errors = D.22184;
      }
      <D.22182>:
      ctx->valid = 0;
      return;
      <D.22180>:
      i = i + 1;
      <D.19137>:
      D.22185 = table->rows;
      D.22186 = (int) D.22185;
      if (D.22186 > i) goto <D.19136>; else goto <D.19138>;
      <D.19138>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_propertymap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22190;
  unsigned int D.22193;
  <unnamed-unsigned:24> D.22195;
  int D.22196;
  int D.22197;
  unsigned int D.22198;
  int D.22199;
  gchar * D.22202;
  struct GSList * D.22203;
  struct GSList * D.22204;
  unsigned int D.22207;
  gchar * D.22211;
  struct GSList * D.22212;
  <unnamed-unsigned:24> D.22213;
  int D.22214;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 propertylist;
  int i;

  try
    {
      D.22190 = ctx->image;
      table = &D.22190->tables[21];
      propertylist = 0;
      i = 0;
      goto <D.19173>;
      <D.19172>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22193 = data[0];
      if (D.22193 == 0) goto <D.22191>; else goto <D.22194>;
      <D.22194>:
      D.22193 = data[0];
      D.22190 = ctx->image;
      D.22195 = D.22190->tables[2].rows;
      D.22196 = (int) D.22195;
      D.22197 = D.22196 + 1;
      D.22198 = (unsigned int) D.22197;
      if (D.22193 > D.22198) goto <D.22191>; else goto <D.22192>;
      <D.22191>:
      D.22199 = ctx->report_error;
      if (D.22199 != 0) goto <D.22200>; else goto <D.22201>;
      <D.22200>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22193 = data[0];
        D.22202 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d Parent field 0x%08x", i, D.22193);
        vinfo->info.message = D.22202;
        vinfo->exception_type = 3;
        D.22203 = ctx->errors;
        D.22204 = monoeg_g_slist_prepend (D.22203, vinfo);
        ctx->errors = D.22204;
      }
      <D.22201>:
      ctx->valid = 0;
      return;
      <D.22192>:
      D.22207 = data[1];
      if (D.22207 == 0) goto <D.22205>; else goto <D.22208>;
      <D.22208>:
      D.22207 = data[1];
      if (D.22207 <= propertylist) goto <D.22205>; else goto <D.22206>;
      <D.22205>:
      D.22199 = ctx->report_error;
      if (D.22199 != 0) goto <D.22209>; else goto <D.22210>;
      <D.22209>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22207 = data[1];
        D.22211 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d PropertyList field %d", i, D.22207);
        vinfo->info.message = D.22211;
        vinfo->exception_type = 3;
        D.22203 = ctx->errors;
        D.22212 = monoeg_g_slist_prepend (D.22203, vinfo);
        ctx->errors = D.22212;
      }
      <D.22210>:
      ctx->valid = 0;
      return;
      <D.22206>:
      propertylist = data[1];
      i = i + 1;
      <D.19173>:
      D.22213 = table->rows;
      D.22214 = (int) D.22213;
      if (D.22214 > i) goto <D.19172>; else goto <D.19174>;
      <D.19174>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_property_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22218;
  unsigned int D.22219;
  unsigned int D.22220;
  int D.22223;
  gchar * D.22226;
  struct GSList * D.22227;
  struct GSList * D.22228;
  unsigned int D.22229;
  int D.22230;
  gchar * D.22235;
  struct GSList * D.22236;
  unsigned int D.22237;
  int D.22238;
  gchar * D.22243;
  struct GSList * D.22244;
  unsigned int D.22245;
  unsigned int i.46;
  unsigned int D.22249;
  int D.22250;
  gchar * D.22255;
  struct GSList * D.22256;
  <unnamed-unsigned:24> D.22257;
  int D.22258;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22218 = ctx->image;
      table = &D.22218->tables[23];
      i = 0;
      goto <D.19186>;
      <D.19185>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22219 = data[0];
      D.22220 = D.22219 & 4294961663;
      if (D.22220 != 0) goto <D.22221>; else goto <D.22222>;
      <D.22221>:
      D.22223 = ctx->report_error;
      if (D.22223 != 0) goto <D.22224>; else goto <D.22225>;
      <D.22224>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22219 = data[0];
        D.22226 = monoeg_g_strdup_printf ("Invalid Property row %d PropertyFlags field %08x", i, D.22219);
        vinfo->info.message = D.22226;
        vinfo->exception_type = 3;
        D.22227 = ctx->errors;
        D.22228 = monoeg_g_slist_prepend (D.22227, vinfo);
        ctx->errors = D.22228;
      }
      <D.22225>:
      ctx->valid = 0;
      return;
      <D.22222>:
      D.22229 = data[1];
      D.22230 = is_valid_non_empty_string (ctx, D.22229);
      if (D.22230 == 0) goto <D.22231>; else goto <D.22232>;
      <D.22231>:
      D.22223 = ctx->report_error;
      if (D.22223 != 0) goto <D.22233>; else goto <D.22234>;
      <D.22233>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22229 = data[1];
        D.22235 = monoeg_g_strdup_printf ("Invalid Property row %d Name field %08x", i, D.22229);
        vinfo->info.message = D.22235;
        vinfo->exception_type = 3;
        D.22227 = ctx->errors;
        D.22236 = monoeg_g_slist_prepend (D.22227, vinfo);
        ctx->errors = D.22236;
      }
      <D.22234>:
      ctx->valid = 0;
      return;
      <D.22232>:
      D.22237 = data[2];
      D.22238 = is_valid_property_sig_blob (ctx, D.22237);
      if (D.22238 == 0) goto <D.22239>; else goto <D.22240>;
      <D.22239>:
      D.22223 = ctx->report_error;
      if (D.22223 != 0) goto <D.22241>; else goto <D.22242>;
      <D.22241>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22237 = data[2];
        D.22243 = monoeg_g_strdup_printf ("Invalid Property row %d Type field %08x", i, D.22237);
        vinfo->info.message = D.22243;
        vinfo->exception_type = 3;
        D.22227 = ctx->errors;
        D.22244 = monoeg_g_slist_prepend (D.22227, vinfo);
        ctx->errors = D.22244;
      }
      <D.22242>:
      ctx->valid = 0;
      return;
      <D.22240>:
      D.22219 = data[0];
      D.22245 = D.22219 & 4096;
      if (D.22245 != 0) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      i.46 = (unsigned int) i;
      D.22249 = make_coded_token (5, 23, i.46);
      D.22250 = search_sorted_table (ctx, 11, 2, D.22249);
      if (D.22250 == -1) goto <D.22251>; else goto <D.22252>;
      <D.22251>:
      D.22223 = ctx->report_error;
      if (D.22223 != 0) goto <D.22253>; else goto <D.22254>;
      <D.22253>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22255 = 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.22255;
        vinfo->exception_type = 3;
        D.22227 = ctx->errors;
        D.22256 = monoeg_g_slist_prepend (D.22227, vinfo);
        ctx->errors = D.22256;
      }
      <D.22254>:
      ctx->valid = 0;
      return;
      <D.22252>:
      <D.22247>:
      i = i + 1;
      <D.19186>:
      D.22257 = table->rows;
      D.22258 = (int) D.22257;
      if (D.22258 > i) goto <D.19185>; else goto <D.19187>;
      <D.19187>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_property_sig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.22262;
  int D.22265;
  gchar * D.22268;
  struct GSList * D.22269;
  struct GSList * D.22270;
  gboolean D.22271;
  const char * ptr.47;
  unsigned int size.48;
  sizetype D.22274;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.22262 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.22262 == 0) goto <D.22263>; else goto <D.22264>;
      <D.22263>:
      D.22265 = ctx->report_error;
      if (D.22265 != 0) goto <D.22266>; else goto <D.22267>;
      <D.22266>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22268 = monoeg_strdup ("PropertySig: Could not decode signature header");
        vinfo->info.message = D.22268;
        vinfo->exception_type = 3;
        D.22269 = ctx->errors;
        D.22270 = monoeg_g_slist_prepend (D.22269, vinfo);
        ctx->errors = D.22270;
      }
      <D.22267>:
      ctx->valid = 0;
      D.22271 = 0;
      return D.22271;
      <D.22264>:
      ptr.47 = ptr;
      size.48 = size;
      D.22274 = (sizetype) size.48;
      end = ptr.47 + D.22274;
      D.22271 = parse_property_signature (ctx, &ptr, end);
      return D.22271;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


decode_signature_header (struct VerifyContext * ctx, guint32 offset, guint32 * size, const char * * first_byte)
{
  struct MonoImage * D.22277;
  unsigned int D.22278;
  gboolean D.22281;
  unsigned int D.22282;
  const char * D.22283;
  sizetype D.22284;
  const char * D.22285;
  int D.22286;
  unsigned int enc_size.49;
  unsigned int D.22290;
  unsigned int value.50;
  unsigned int D.22296;
  unsigned int D.22298;
  struct MonoStreamHeader blob;
  guint32 value;
  guint32 enc_size;

  try
    {
      D.22277 = ctx->image;
      blob = D.22277->heap_blob;
      D.22278 = blob.size;
      if (D.22278 <= offset) goto <D.22279>; else goto <D.22280>;
      <D.22279>:
      D.22281 = 0;
      return D.22281;
      <D.22280>:
      D.22278 = blob.size;
      D.22282 = D.22278 - offset;
      D.22283 = blob.data;
      D.22284 = (sizetype) offset;
      D.22285 = D.22283 + D.22284;
      D.22286 = decode_value (D.22285, D.22282, &value, &enc_size);
      if (D.22286 == 0) goto <D.22287>; else goto <D.22288>;
      <D.22287>:
      D.22281 = 0;
      return D.22281;
      <D.22288>:
      enc_size.49 = enc_size;
      D.22290 = ~enc_size.49;
      if (D.22290 < offset) goto <D.22291>; else goto <D.22292>;
      <D.22291>:
      D.22281 = 0;
      return D.22281;
      <D.22292>:
      enc_size.49 = enc_size;
      offset = offset + enc_size.49;
      value.50 = value;
      D.22296 = offset + value.50;
      D.22278 = blob.size;
      if (D.22296 > D.22278) goto <D.22293>; else goto <D.22297>;
      <D.22297>:
      value.50 = value;
      D.22298 = ~value.50;
      if (D.22298 < offset) goto <D.22293>; else goto <D.22294>;
      <D.22293>:
      D.22281 = 0;
      return D.22281;
      <D.22294>:
      value.50 = value;
      *size = value.50;
      D.22283 = blob.data;
      D.22284 = (sizetype) offset;
      D.22285 = D.22283 + D.22284;
      *first_byte = D.22285;
      D.22281 = 1;
      return D.22281;
    }
  finally
    {
      blob = {CLOBBER};
      value = {CLOBBER};
      enc_size = {CLOBBER};
    }
}


parse_property_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.51;
  int D.22302;
  int D.22305;
  gchar * D.22308;
  struct GSList * D.22309;
  struct GSList * D.22310;
  gboolean D.22311;
  unsigned int sig.52;
  _Bool D.22313;
  _Bool D.22314;
  _Bool D.22315;
  unsigned int sig.53;
  gchar * D.22321;
  struct GSList * D.22322;
  int D.22323;
  gchar * D.22328;
  struct GSList * D.22329;
  int D.22330;
  int D.22333;
  gchar * D.22338;
  struct GSList * D.22339;
  int D.22340;
  gchar * D.22345;
  struct GSList * D.22346;
  int D.22347;
  gchar * D.22352;
  struct GSList * D.22353;
  unsigned int param_count.54;
  const char * ptr.55;
  unsigned int sig;
  unsigned int param_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      param_count = 0;
      ptr.51 = *_ptr;
      ptr = ptr.51;
      D.22302 = safe_read (&ptr, end, &sig, 1);
      if (D.22302 == 0) goto <D.22303>; else goto <D.22304>;
      <D.22303>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22306>; else goto <D.22307>;
      <D.22306>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22308 = monoeg_strdup ("PropertySig: Not enough room for signature");
        vinfo->info.message = D.22308;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22310 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22310;
      }
      <D.22307>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22304>:
      sig.52 = sig;
      D.22313 = sig.52 != 8;
      D.22314 = sig.52 != 40;
      D.22315 = D.22313 & D.22314;
      if (D.22315 != 0) goto <D.22316>; else goto <D.22317>;
      <D.22316>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22318>; else goto <D.22319>;
      <D.22318>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        sig.53 = sig;
        D.22321 = monoeg_g_strdup_printf ("PropertySig: Signature is not 0x28 or 0x08: %x", sig.53);
        vinfo->info.message = D.22321;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22322 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22322;
      }
      <D.22319>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22317>:
      D.22323 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.22323 == 0) goto <D.22324>; else goto <D.22325>;
      <D.22324>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22326>; else goto <D.22327>;
      <D.22326>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22328 = monoeg_strdup ("PropertySig: Not enough room for the param count");
        vinfo->info.message = D.22328;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22329 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22329;
      }
      <D.22327>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22325>:
      D.22330 = parse_custom_mods (ctx, &ptr, end);
      if (D.22330 == 0) goto <D.22331>; else goto <D.22332>;
      <D.22331>:
      D.22311 = 0;
      return D.22311;
      <D.22332>:
      D.22333 = parse_type (ctx, &ptr, end);
      if (D.22333 == 0) goto <D.22334>; else goto <D.22335>;
      <D.22334>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22336>; else goto <D.22337>;
      <D.22336>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22338 = monoeg_strdup ("PropertySig: Could not parse property type");
        vinfo->info.message = D.22338;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22339 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22339;
      }
      <D.22337>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22335>:
      i = 0;
      goto <D.18369>;
      <D.18368>:
      D.22340 = parse_custom_mods (ctx, &ptr, end);
      if (D.22340 == 0) goto <D.22341>; else goto <D.22342>;
      <D.22341>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22343>; else goto <D.22344>;
      <D.22343>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22345 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22345;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22346 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22346;
      }
      <D.22344>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22342>:
      D.22347 = parse_type (ctx, &ptr, end);
      if (D.22347 == 0) goto <D.22348>; else goto <D.22349>;
      <D.22348>:
      D.22305 = ctx->report_error;
      if (D.22305 != 0) goto <D.22350>; else goto <D.22351>;
      <D.22350>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22352 = monoeg_g_strdup_printf ("PropertySig: Error parsing arg %d", i);
        vinfo->info.message = D.22352;
        vinfo->exception_type = 3;
        D.22309 = ctx->errors;
        D.22353 = monoeg_g_slist_prepend (D.22309, vinfo);
        ctx->errors = D.22353;
      }
      <D.22351>:
      ctx->valid = 0;
      D.22311 = 0;
      return D.22311;
      <D.22349>:
      i = i + 1;
      <D.18369>:
      param_count.54 = param_count;
      if (i < param_count.54) goto <D.18368>; else goto <D.18370>;
      <D.18370>:
      ptr.55 = ptr;
      *_ptr = ptr.55;
      D.22311 = 1;
      return D.22311;
    }
  finally
    {
      sig = {CLOBBER};
      param_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


safe_read (const char * * _ptr, const char * limit, unsigned int * dest, int size)
{
  sizetype D.22358;
  const char * D.22359;
  gboolean D.22362;
  unsigned char D.22363;
  unsigned int D.22364;
  short unsigned int D.22365;
  unsigned int D.22366;
  unsigned int D.22367;
  const char * ptr;

  ptr = *_ptr;
  D.22358 = (sizetype) size;
  D.22359 = ptr + D.22358;
  if (D.22359 > limit) goto <D.22360>; else goto <D.22361>;
  <D.22360>:
  D.22362 = 0;
  return D.22362;
  <D.22361>:
  switch (size) <default: <D.22368>, case 1: <D.18194>, case 2: <D.18196>, case 4: <D.18197>>
  <D.18194>:
  D.22363 = MEM[(guint8 *)ptr];
  D.22364 = (unsigned int) D.22363;
  *dest = D.22364;
  ptr = ptr + 1;
  goto <D.18195>;
  <D.18196>:
  D.22365 = MEM[(const guint16 *)ptr];
  D.22366 = (unsigned int) D.22365;
  *dest = D.22366;
  ptr = ptr + 2;
  goto <D.18195>;
  <D.18197>:
  D.22367 = MEM[(const guint32 *)ptr];
  *dest = D.22367;
  ptr = ptr + 4;
  goto <D.18195>;
  <D.22368>:
  <D.18195>:
  *_ptr = ptr;
  D.22362 = 1;
  return D.22362;
}


safe_read_compressed_int (const char * * _ptr, const char * limit, unsigned int * dest)
{
  long int limit.56;
  long int ptr.57;
  long int D.22372;
  unsigned int D.22373;
  unsigned int size.58;
  sizetype D.22375;
  const char * D.22376;
  gboolean D.22377;
  unsigned int size;
  const char * ptr;
  gboolean res;

  try
    {
      size = 0;
      ptr = *_ptr;
      limit.56 = (long int) limit;
      ptr.57 = (long int) ptr;
      D.22372 = limit.56 - ptr.57;
      D.22373 = (unsigned int) D.22372;
      res = decode_value (ptr, D.22373, dest, &size);
      size.58 = size;
      D.22375 = (sizetype) size.58;
      D.22376 = ptr + D.22375;
      *_ptr = D.22376;
      D.22377 = res;
      return D.22377;
    }
  finally
    {
      size = {CLOBBER};
    }
}


parse_custom_mods (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.59;
  int D.22381;
  int D.22384;
  gchar * D.22387;
  struct GSList * D.22388;
  struct GSList * D.22389;
  gboolean D.22390;
  unsigned int type.60;
  unsigned int D.22392;
  const char * ptr.61;
  const char * ptr.62;
  int D.22397;
  gchar * D.22402;
  struct GSList * D.22403;
  unsigned int token.63;
  int D.22407;
  unsigned int D.22409;
  gchar * D.22412;
  struct GSList * D.22413;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.59 = *_ptr;
      ptr = ptr.59;
      type = 0;
      token = 0;
      <D.18228>:
      D.22381 = safe_read (&ptr, end, &type, 1);
      if (D.22381 == 0) goto <D.22382>; else goto <D.22383>;
      <D.22382>:
      D.22384 = ctx->report_error;
      if (D.22384 != 0) goto <D.22385>; else goto <D.22386>;
      <D.22385>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22387 = monoeg_strdup ("CustomMod: Not enough room for the type");
        vinfo->info.message = D.22387;
        vinfo->exception_type = 3;
        D.22388 = ctx->errors;
        D.22389 = monoeg_g_slist_prepend (D.22388, vinfo);
        ctx->errors = D.22389;
      }
      <D.22386>:
      ctx->valid = 0;
      D.22390 = 0;
      return D.22390;
      <D.22383>:
      type.60 = type;
      D.22392 = type.60 + 4294967265;
      if (D.22392 > 1) goto <D.22393>; else goto <D.22394>;
      <D.22393>:
      ptr.61 = ptr;
      ptr.62 = ptr.61 + 18446744073709551615;
      ptr = ptr.62;
      goto <D.18225>;
      <D.22394>:
      D.22397 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22397 == 0) goto <D.22398>; else goto <D.22399>;
      <D.22398>:
      D.22384 = ctx->report_error;
      if (D.22384 != 0) goto <D.22400>; else goto <D.22401>;
      <D.22400>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22402 = monoeg_strdup ("CustomMod: Not enough room for the token");
        vinfo->info.message = D.22402;
        vinfo->exception_type = 3;
        D.22388 = ctx->errors;
        D.22403 = monoeg_g_slist_prepend (D.22388, vinfo);
        ctx->errors = D.22403;
      }
      <D.22401>:
      ctx->valid = 0;
      D.22390 = 0;
      return D.22390;
      <D.22399>:
      token.63 = token;
      D.22407 = is_valid_coded_index (ctx, 0, token.63);
      if (D.22407 == 0) goto <D.22404>; else goto <D.22408>;
      <D.22408>:
      token.63 = token;
      D.22409 = get_coded_index_token (0, token.63);
      if (D.22409 == 0) goto <D.22404>; else goto <D.22405>;
      <D.22404>:
      D.22384 = ctx->report_error;
      if (D.22384 != 0) goto <D.22410>; else goto <D.22411>;
      <D.22410>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.63 = token;
        D.22412 = monoeg_g_strdup_printf ("CustomMod: invalid TypeDefOrRef token %x", token.63);
        vinfo->info.message = D.22412;
        vinfo->exception_type = 3;
        D.22388 = ctx->errors;
        D.22413 = monoeg_g_slist_prepend (D.22388, vinfo);
        ctx->errors = D.22413;
      }
      <D.22411>:
      ctx->valid = 0;
      D.22390 = 0;
      return D.22390;
      <D.22405>:
      goto <D.18228>;
      <D.18225>:
      ptr.61 = ptr;
      *_ptr = ptr.61;
      D.22390 = 1;
      return D.22390;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.64;
  int D.22417;
  int D.22420;
  gchar * D.22423;
  struct GSList * D.22424;
  struct GSList * D.22425;
  gboolean D.22426;
  unsigned int type.65;
  unsigned int D.22428;
  _Bool D.22429;
  unsigned int D.22430;
  _Bool D.22431;
  _Bool D.22432;
  unsigned int type.66;
  unsigned int D.22436;
  unsigned int D.22439;
  gchar * D.22444;
  struct GSList * D.22445;
  int D.22446;
  gchar * D.22451;
  struct GSList * D.22452;
  int D.22453;
  gchar * D.22458;
  struct GSList * D.22459;
  const char * ptr.67;
  const char * ptr.68;
  int D.22464;
  gchar * D.22469;
  struct GSList * D.22470;
  int D.22471;
  gchar * D.22476;
  struct GSList * D.22477;
  unsigned int token.69;
  int D.22481;
  unsigned int D.22483;
  gchar * D.22486;
  struct GSList * D.22487;
  unsigned int D.22488;
  gchar * D.22493;
  struct GSList * D.22494;
  unsigned int D.22495;
  unsigned int D.22498;
  unsigned int D.22499;
  unsigned int D.22502;
  unsigned int D.22503;
  gchar * D.22508;
  struct GSList * D.22509;
  int D.22510;
  gchar * D.22515;
  struct GSList * D.22516;
  int D.22517;
  gchar * D.22522;
  struct GSList * D.22523;
  int D.22524;
  gchar * D.22529;
  struct GSList * D.22530;
  int D.22531;
  gchar * D.22536;
  struct GSList * D.22537;
  int D.22538;
  gchar * D.22543;
  struct GSList * D.22544;
  int D.22545;
  gchar * D.22550;
  struct GSList * D.22551;
  int D.22552;
  gchar * D.22557;
  struct GSList * D.22558;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.64 = *_ptr;
      ptr = ptr.64;
      token = 0;
      D.22417 = safe_read (&ptr, end, &type, 1);
      if (D.22417 == 0) goto <D.22418>; else goto <D.22419>;
      <D.22418>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22421>; else goto <D.22422>;
      <D.22421>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22423 = monoeg_strdup ("Type: Not enough room for the type");
        vinfo->info.message = D.22423;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22425 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22425;
      }
      <D.22422>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22419>:
      type.65 = type;
      D.22428 = type.65 + 4294967294;
      D.22429 = D.22428 > 13;
      D.22430 = type.65 + 4294967279;
      D.22431 = D.22430 > 4;
      D.22432 = D.22429 & D.22431;
      if (D.22432 != 0) goto <D.22433>; else goto <D.22434>;
      <D.22433>:
      type.66 = type;
      D.22436 = type.66 + 4294967272;
      if (D.22436 > 1) goto <D.22437>; else goto <D.22438>;
      <D.22437>:
      type.66 = type;
      D.22439 = type.66 + 4294967269;
      if (D.22439 > 3) goto <D.22440>; else goto <D.22441>;
      <D.22440>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22442>; else goto <D.22443>;
      <D.22442>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.66 = type;
        D.22444 = monoeg_g_strdup_printf ("Type: Invalid type kind %x\n", type.66);
        vinfo->info.message = D.22444;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22445 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22445;
      }
      <D.22443>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22441>:
      <D.22438>:
      <D.22434>:
      type.66 = type;
      switch (type.66) <default: <D.22559>, case 15: <D.18283>, case 17: <D.18288>, case 18: <D.18289>, case 19: <D.18294>, case 20: <D.18297>, case 21: <D.18300>, case 27: <D.18302>, case 29: <D.18304>, case 30: <D.18295>>
      <D.18283>:
      D.22446 = parse_custom_mods (ctx, &ptr, end);
      if (D.22446 == 0) goto <D.22447>; else goto <D.22448>;
      <D.22447>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22449>; else goto <D.22450>;
      <D.22449>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22451 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22451;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22452 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22452;
      }
      <D.22450>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22448>:
      D.22453 = safe_read (&ptr, end, &type, 1);
      if (D.22453 == 0) goto <D.22454>; else goto <D.22455>;
      <D.22454>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22456>; else goto <D.22457>;
      <D.22456>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22458 = monoeg_strdup ("Type: Not enough room to parse the pointer type");
        vinfo->info.message = D.22458;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22459 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22459;
      }
      <D.22457>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22455>:
      type.66 = type;
      if (type.66 != 1) goto <D.22460>; else goto <D.22461>;
      <D.22460>:
      ptr.67 = ptr;
      ptr.68 = ptr.67 + 18446744073709551615;
      ptr = ptr.68;
      D.22464 = parse_type (ctx, &ptr, end);
      if (D.22464 == 0) goto <D.22465>; else goto <D.22466>;
      <D.22465>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22467>; else goto <D.22468>;
      <D.22467>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22469 = monoeg_strdup ("Type: Could not parse pointer type");
        vinfo->info.message = D.22469;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22470 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22470;
      }
      <D.22468>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22466>:
      <D.22461>:
      goto <D.18287>;
      <D.18288>:
      <D.18289>:
      D.22471 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22471 == 0) goto <D.22472>; else goto <D.22473>;
      <D.22472>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22474>; else goto <D.22475>;
      <D.22474>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22476 = monoeg_strdup ("Type: Not enough room for the type token");
        vinfo->info.message = D.22476;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22477 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22477;
      }
      <D.22475>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22473>:
      token.69 = token;
      D.22481 = is_valid_coded_index (ctx, 0, token.69);
      if (D.22481 == 0) goto <D.22478>; else goto <D.22482>;
      <D.22482>:
      token.69 = token;
      D.22483 = get_coded_index_token (0, token.69);
      if (D.22483 == 0) goto <D.22478>; else goto <D.22479>;
      <D.22478>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22484>; else goto <D.22485>;
      <D.22484>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.69 = token;
        D.22486 = monoeg_g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token.69);
        vinfo->info.message = D.22486;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22487 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22487;
      }
      <D.22485>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22479>:
      token.69 = token;
      D.22488 = get_coded_index_token (0, token.69);
      if (D.22488 == 0) goto <D.22489>; else goto <D.22490>;
      <D.22489>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22491>; else goto <D.22492>;
      <D.22491>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.69 = token;
        D.22493 = monoeg_g_strdup_printf ("Type: zero TypeDefOrRef token %x", token.69);
        vinfo->info.message = D.22493;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22494 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22494;
      }
      <D.22492>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22490>:
      D.22495 = ctx->token;
      if (D.22495 != 0) goto <D.22496>; else goto <D.22497>;
      <D.22496>:
      D.22495 = ctx->token;
      D.22498 = D.22495 & 16777215;
      token.69 = token;
      D.22499 = get_coded_index_token (0, token.69);
      if (D.22498 == D.22499) goto <D.22500>; else goto <D.22501>;
      <D.22500>:
      D.22495 = ctx->token;
      D.22502 = D.22495 >> 24;
      token.69 = token;
      D.22503 = get_coded_index_table (0, token.69);
      if (D.22502 == D.22503) goto <D.22504>; else goto <D.22505>;
      <D.22504>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22506>; else goto <D.22507>;
      <D.22506>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22495 = ctx->token;
        D.22508 = monoeg_g_strdup_printf ("Type: Recursive type specification (%x). A type signature can\'t reference itself", D.22495);
        vinfo->info.message = D.22508;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22509 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22509;
      }
      <D.22507>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22505>:
      <D.22501>:
      <D.22497>:
      goto <D.18287>;
      <D.18294>:
      <D.18295>:
      D.22510 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22510 == 0) goto <D.22511>; else goto <D.22512>;
      <D.22511>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22513>; else goto <D.22514>;
      <D.22513>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22515 = monoeg_strdup ("Type: Not enough room for to decode generic argument number");
        vinfo->info.message = D.22515;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22516 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22516;
      }
      <D.22514>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22512>:
      goto <D.18287>;
      <D.18297>:
      D.22517 = parse_type (ctx, &ptr, end);
      if (D.22517 == 0) goto <D.22518>; else goto <D.22519>;
      <D.22518>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22520>; else goto <D.22521>;
      <D.22520>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22522 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22522;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22523 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22523;
      }
      <D.22521>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22519>:
      D.22524 = parse_array_shape (ctx, &ptr, end);
      if (D.22524 == 0) goto <D.22525>; else goto <D.22526>;
      <D.22525>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22527>; else goto <D.22528>;
      <D.22527>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22529 = monoeg_strdup ("Type: Could not parse array shape");
        vinfo->info.message = D.22529;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22530 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22530;
      }
      <D.22528>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22526>:
      goto <D.18287>;
      <D.18300>:
      D.22531 = parse_generic_inst (ctx, &ptr, end);
      if (D.22531 == 0) goto <D.22532>; else goto <D.22533>;
      <D.22532>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22534>; else goto <D.22535>;
      <D.22534>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22536 = monoeg_strdup ("Type: Could not parse generic inst");
        vinfo->info.message = D.22536;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22537 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22537;
      }
      <D.22535>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22533>:
      goto <D.18287>;
      <D.18302>:
      D.22538 = parse_method_signature (ctx, &ptr, end, 1, 1);
      if (D.22538 == 0) goto <D.22539>; else goto <D.22540>;
      <D.22539>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22541>; else goto <D.22542>;
      <D.22541>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22543 = monoeg_strdup ("Type: Could not parse method pointer signature");
        vinfo->info.message = D.22543;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22544 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22544;
      }
      <D.22542>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22540>:
      goto <D.18287>;
      <D.18304>:
      D.22545 = parse_custom_mods (ctx, &ptr, end);
      if (D.22545 == 0) goto <D.22546>; else goto <D.22547>;
      <D.22546>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22548>; else goto <D.22549>;
      <D.22548>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22550 = monoeg_strdup ("Type: Failed to parse array element custom attr");
        vinfo->info.message = D.22550;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22551 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22551;
      }
      <D.22549>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22547>:
      D.22552 = parse_type (ctx, &ptr, end);
      if (D.22552 == 0) goto <D.22553>; else goto <D.22554>;
      <D.22553>:
      D.22420 = ctx->report_error;
      if (D.22420 != 0) goto <D.22555>; else goto <D.22556>;
      <D.22555>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22557 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.22557;
        vinfo->exception_type = 3;
        D.22424 = ctx->errors;
        D.22558 = monoeg_g_slist_prepend (D.22424, vinfo);
        ctx->errors = D.22558;
      }
      <D.22556>:
      ctx->valid = 0;
      D.22426 = 0;
      return D.22426;
      <D.22554>:
      goto <D.18287>;
      <D.22559>:
      <D.18287>:
      ptr.67 = ptr;
      *_ptr = ptr.67;
      D.22426 = 1;
      return D.22426;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


get_coded_index_table (int kind, guint32 coded_token)
{
  unsigned char D.22562;
  int bits.70;
  int D.22564;
  int D.22565;
  unsigned int D.22566;
  guint32 D.22567;
  unsigned int kind.71;
  unsigned int D.22569;
  unsigned char D.22570;
  guint32 idx;
  guint32 bits;

  D.22562 = coded_index_desc[kind];
  bits = (guint32) D.22562;
  kind = kind + 2;
  bits.70 = (int) bits;
  D.22564 = 1 << bits.70;
  D.22565 = D.22564 + -1;
  D.22566 = (unsigned int) D.22565;
  idx = D.22566 & coded_token;
  kind.71 = (unsigned int) kind;
  D.22569 = kind.71 + idx;
  D.22570 = coded_index_desc[D.22569];
  D.22567 = (guint32) D.22570;
  return D.22567;
}


parse_array_shape (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.72;
  int D.22573;
  int D.22576;
  gchar * D.22579;
  struct GSList * D.22580;
  struct GSList * D.22581;
  gboolean D.22582;
  unsigned int val.73;
  gchar * D.22588;
  struct GSList * D.22589;
  int D.22590;
  gchar * D.22595;
  struct GSList * D.22596;
  int D.22597;
  unsigned int D.22602;
  gchar * D.22603;
  struct GSList * D.22604;
  unsigned int size.74;
  int D.22606;
  gchar * D.22611;
  struct GSList * D.22612;
  int D.22613;
  gchar * D.22618;
  struct GSList * D.22619;
  const char * ptr.75;
  const char * ptr;
  unsigned int val;
  unsigned int size;
  unsigned int num;
  unsigned int i;

  try
    {
      ptr.72 = *_ptr;
      ptr = ptr.72;
      val = 0;
      D.22573 = safe_read (&ptr, end, &val, 1);
      if (D.22573 == 0) goto <D.22574>; else goto <D.22575>;
      <D.22574>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22577>; else goto <D.22578>;
      <D.22577>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22579 = monoeg_strdup ("ArrayShape: Not enough room for Rank");
        vinfo->info.message = D.22579;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22581 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22581;
      }
      <D.22578>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22575>:
      val.73 = val;
      if (val.73 == 0) goto <D.22584>; else goto <D.22585>;
      <D.22584>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22586>; else goto <D.22587>;
      <D.22586>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22588 = monoeg_strdup ("ArrayShape: Invalid shape with zero Rank");
        vinfo->info.message = D.22588;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22589 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22589;
      }
      <D.22587>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22585>:
      D.22590 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22590 == 0) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22593>; else goto <D.22594>;
      <D.22593>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22595 = monoeg_strdup ("ArrayShape: Not enough room for NumSizes");
        vinfo->info.message = D.22595;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22596 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22596;
      }
      <D.22594>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22592>:
      i = 0;
      goto <D.18244>;
      <D.18243>:
      D.22597 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22597 == 0) goto <D.22598>; else goto <D.22599>;
      <D.22598>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22600>; else goto <D.22601>;
      <D.22600>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22602 = i + 1;
        D.22603 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for Size of rank %d", D.22602);
        vinfo->info.message = D.22603;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22604 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22604;
      }
      <D.22601>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22599>:
      i = i + 1;
      <D.18244>:
      size.74 = size;
      if (i < size.74) goto <D.18243>; else goto <D.18245>;
      <D.18245>:
      D.22606 = safe_read_compressed_int (&ptr, end, &size);
      if (D.22606 == 0) goto <D.22607>; else goto <D.22608>;
      <D.22607>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22609>; else goto <D.22610>;
      <D.22609>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22611 = monoeg_strdup ("ArrayShape: Not enough room for NumLoBounds");
        vinfo->info.message = D.22611;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22612 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22612;
      }
      <D.22610>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22608>:
      i = 0;
      goto <D.18249>;
      <D.18248>:
      D.22613 = safe_read_compressed_int (&ptr, end, &num);
      if (D.22613 == 0) goto <D.22614>; else goto <D.22615>;
      <D.22614>:
      D.22576 = ctx->report_error;
      if (D.22576 != 0) goto <D.22616>; else goto <D.22617>;
      <D.22616>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22602 = i + 1;
        D.22618 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for LoBound of rank %d", D.22602);
        vinfo->info.message = D.22618;
        vinfo->exception_type = 3;
        D.22580 = ctx->errors;
        D.22619 = monoeg_g_slist_prepend (D.22580, vinfo);
        ctx->errors = D.22619;
      }
      <D.22617>:
      ctx->valid = 0;
      D.22582 = 0;
      return D.22582;
      <D.22615>:
      i = i + 1;
      <D.18249>:
      size.74 = size;
      if (i < size.74) goto <D.18248>; else goto <D.18250>;
      <D.18250>:
      ptr.75 = ptr;
      *_ptr = ptr.75;
      D.22582 = 1;
      return D.22582;
    }
  finally
    {
      ptr = {CLOBBER};
      val = {CLOBBER};
      size = {CLOBBER};
      num = {CLOBBER};
    }
}


parse_generic_inst (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.76;
  int D.22624;
  int D.22627;
  gchar * D.22630;
  struct GSList * D.22631;
  struct GSList * D.22632;
  gboolean D.22633;
  unsigned int type.77;
  unsigned int D.22635;
  gchar * D.22640;
  struct GSList * D.22641;
  int D.22642;
  gchar * D.22647;
  struct GSList * D.22648;
  unsigned int token.78;
  int D.22652;
  unsigned int D.22654;
  gchar * D.22657;
  struct GSList * D.22658;
  unsigned int D.22659;
  unsigned int D.22662;
  unsigned int D.22663;
  unsigned int D.22666;
  unsigned int D.22667;
  gchar * D.22672;
  struct GSList * D.22673;
  int D.22674;
  gchar * D.22679;
  struct GSList * D.22680;
  unsigned int count.79;
  gchar * D.22686;
  struct GSList * D.22687;
  int D.22688;
  gchar * D.22693;
  struct GSList * D.22694;
  int D.22695;
  unsigned int D.22700;
  gchar * D.22701;
  struct GSList * D.22702;
  const char * ptr.80;
  const char * ptr;
  unsigned int type;
  unsigned int count;
  unsigned int token;
  unsigned int i;

  try
    {
      ptr.76 = *_ptr;
      ptr = ptr.76;
      D.22624 = safe_read (&ptr, end, &type, 1);
      if (D.22624 == 0) goto <D.22625>; else goto <D.22626>;
      <D.22625>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22628>; else goto <D.22629>;
      <D.22628>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22630 = monoeg_strdup ("GenericInst: Not enough room for kind");
        vinfo->info.message = D.22630;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22632 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22632;
      }
      <D.22629>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22626>:
      type.77 = type;
      D.22635 = type.77 + 4294967279;
      if (D.22635 > 1) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22638>; else goto <D.22639>;
      <D.22638>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.77 = type;
        D.22640 = monoeg_g_strdup_printf ("GenericInst: Invalid GenericInst kind %x\n", type.77);
        vinfo->info.message = D.22640;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22641 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22641;
      }
      <D.22639>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22637>:
      D.22642 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22642 == 0) goto <D.22643>; else goto <D.22644>;
      <D.22643>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22645>; else goto <D.22646>;
      <D.22645>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22647 = monoeg_strdup ("GenericInst: Not enough room for type token");
        vinfo->info.message = D.22647;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22648 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22648;
      }
      <D.22646>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22644>:
      token.78 = token;
      D.22652 = is_valid_coded_index (ctx, 0, token.78);
      if (D.22652 == 0) goto <D.22649>; else goto <D.22653>;
      <D.22653>:
      token.78 = token;
      D.22654 = get_coded_index_token (0, token.78);
      if (D.22654 == 0) goto <D.22649>; else goto <D.22650>;
      <D.22649>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22655>; else goto <D.22656>;
      <D.22655>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.78 = token;
        D.22657 = monoeg_g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token.78);
        vinfo->info.message = D.22657;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22658 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22658;
      }
      <D.22656>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22650>:
      D.22659 = ctx->token;
      if (D.22659 != 0) goto <D.22660>; else goto <D.22661>;
      <D.22660>:
      D.22659 = ctx->token;
      D.22662 = D.22659 & 16777215;
      token.78 = token;
      D.22663 = get_coded_index_token (0, token.78);
      if (D.22662 == D.22663) goto <D.22664>; else goto <D.22665>;
      <D.22664>:
      D.22659 = ctx->token;
      D.22666 = D.22659 >> 24;
      token.78 = token;
      D.22667 = get_coded_index_table (0, token.78);
      if (D.22666 == D.22667) goto <D.22668>; else goto <D.22669>;
      <D.22668>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22670>; else goto <D.22671>;
      <D.22670>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22659 = ctx->token;
        D.22672 = monoeg_g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can\'t reference itself", D.22659);
        vinfo->info.message = D.22672;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22673 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22673;
      }
      <D.22671>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22669>:
      <D.22665>:
      <D.22661>:
      D.22674 = safe_read_compressed_int (&ptr, end, &count);
      if (D.22674 == 0) goto <D.22675>; else goto <D.22676>;
      <D.22675>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22677>; else goto <D.22678>;
      <D.22677>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22679 = monoeg_strdup ("GenericInst: Not enough room for argument count");
        vinfo->info.message = D.22679;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22680 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22680;
      }
      <D.22678>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22676>:
      count.79 = count;
      if (count.79 == 0) goto <D.22682>; else goto <D.22683>;
      <D.22682>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22684>; else goto <D.22685>;
      <D.22684>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22686 = monoeg_strdup ("GenericInst: Zero arguments generic instance");
        vinfo->info.message = D.22686;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22687 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22687;
      }
      <D.22685>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22683>:
      i = 0;
      goto <D.18271>;
      <D.18270>:
      D.22688 = parse_custom_mods (ctx, &ptr, end);
      if (D.22688 == 0) goto <D.22689>; else goto <D.22690>;
      <D.22689>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22691>; else goto <D.22692>;
      <D.22691>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22693 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22693;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22694 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22694;
      }
      <D.22692>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22690>:
      D.22695 = parse_type (ctx, &ptr, end);
      if (D.22695 == 0) goto <D.22696>; else goto <D.22697>;
      <D.22696>:
      D.22627 = ctx->report_error;
      if (D.22627 != 0) goto <D.22698>; else goto <D.22699>;
      <D.22698>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22700 = i + 1;
        D.22701 = monoeg_g_strdup_printf ("GenericInst: invalid generic argument %d", D.22700);
        vinfo->info.message = D.22701;
        vinfo->exception_type = 3;
        D.22631 = ctx->errors;
        D.22702 = monoeg_g_slist_prepend (D.22631, vinfo);
        ctx->errors = D.22702;
      }
      <D.22699>:
      ctx->valid = 0;
      D.22633 = 0;
      return D.22633;
      <D.22697>:
      i = i + 1;
      <D.18271>:
      count.79 = count;
      if (i < count.79) goto <D.18270>; else goto <D.18272>;
      <D.18272>:
      ptr.80 = ptr;
      *_ptr = ptr.80;
      D.22633 = 1;
      return D.22633;
    }
  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.81;
  int D.22707;
  int D.22710;
  gchar * D.22713;
  struct GSList * D.22714;
  struct GSList * D.22715;
  gboolean D.22716;
  unsigned int cconv.82;
  unsigned int D.22718;
  gchar * D.22723;
  struct GSList * D.22724;
  unsigned int D.22727;
  gchar * D.22732;
  struct GSList * D.22733;
  unsigned int D.22735;
  _Bool D.22736;
  _Bool D.22737;
  _Bool D.22738;
  gchar * D.22743;
  struct GSList * D.22744;
  unsigned int D.22745;
  int D.22748;
  gchar * D.22753;
  struct GSList * D.22754;
  unsigned int gparam_count.83;
  gchar * D.22762;
  struct GSList * D.22763;
  gchar * D.22770;
  struct GSList * D.22771;
  int D.22772;
  gchar * D.22777;
  struct GSList * D.22778;
  int D.22779;
  gchar * D.22784;
  struct GSList * D.22785;
  int D.22788;
  gchar * D.22793;
  struct GSList * D.22794;
  unsigned int type.84;
  gchar * D.22802;
  struct GSList * D.22803;
  gchar * D.22808;
  struct GSList * D.22809;
  const char * ptr.85;
  const char * ptr.86;
  int D.22813;
  gchar * D.22818;
  struct GSList * D.22819;
  unsigned int param_count.87;
  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.81 = *_ptr;
      ptr = ptr.81;
      saw_sentinel = 0;
      D.22707 = safe_read (&ptr, end, &cconv, 1);
      if (D.22707 == 0) goto <D.22708>; else goto <D.22709>;
      <D.22708>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22711>; else goto <D.22712>;
      <D.22711>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22713 = monoeg_strdup ("MethodSig: Not enough room for the call conv");
        vinfo->info.message = D.22713;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22715 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22715;
      }
      <D.22712>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22709>:
      cconv.82 = cconv;
      D.22718 = cconv.82 & 128;
      if (D.22718 != 0) goto <D.22719>; else goto <D.22720>;
      <D.22719>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22721>; else goto <D.22722>;
      <D.22721>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22723 = monoeg_strdup ("MethodSig: CallConv has 0x80 set");
        vinfo->info.message = D.22723;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22724 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22724;
      }
      <D.22722>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22720>:
      if (allow_unmanaged != 0) goto <D.22725>; else goto <D.22726>;
      <D.22725>:
      cconv.82 = cconv;
      D.22727 = cconv.82 & 15;
      if (D.22727 > 5) goto <D.22728>; else goto <D.22729>;
      <D.22728>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22730>; else goto <D.22731>;
      <D.22730>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        cconv.82 = cconv;
        D.22727 = cconv.82 & 15;
        D.22732 = monoeg_g_strdup_printf ("MethodSig: CallConv is not valid, it\'s %x", D.22727);
        vinfo->info.message = D.22732;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22733 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22733;
      }
      <D.22731>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22729>:
      goto <D.22734>;
      <D.22726>:
      cconv.82 = cconv;
      D.22735 = cconv.82 & 15;
      D.22736 = D.22735 != 0;
      D.22737 = D.22735 != 5;
      D.22738 = D.22736 & D.22737;
      if (D.22738 != 0) goto <D.22739>; else goto <D.22740>;
      <D.22739>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22741>; else goto <D.22742>;
      <D.22741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        cconv.82 = cconv;
        D.22727 = cconv.82 & 15;
        D.22743 = monoeg_g_strdup_printf ("MethodSig: CallConv is not Default or Vararg, it\'s %x", D.22727);
        vinfo->info.message = D.22743;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22744 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22744;
      }
      <D.22742>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22740>:
      <D.22734>:
      cconv.82 = cconv;
      D.22745 = cconv.82 & 16;
      if (D.22745 != 0) goto <D.22746>; else goto <D.22747>;
      <D.22746>:
      D.22748 = safe_read_compressed_int (&ptr, end, &gparam_count);
      if (D.22748 == 0) goto <D.22749>; else goto <D.22750>;
      <D.22749>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22751>; else goto <D.22752>;
      <D.22751>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22753 = monoeg_strdup ("MethodSig: Not enough room for the generic param count");
        vinfo->info.message = D.22753;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22754 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22754;
      }
      <D.22752>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22750>:
      <D.22747>:
      cconv.82 = cconv;
      D.22745 = cconv.82 & 16;
      if (D.22745 != 0) goto <D.22755>; else goto <D.22756>;
      <D.22755>:
      gparam_count.83 = gparam_count;
      if (gparam_count.83 == 0) goto <D.22758>; else goto <D.22759>;
      <D.22758>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22760>; else goto <D.22761>;
      <D.22760>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22762 = monoeg_strdup ("MethodSig: Signature with generics but zero arity");
        vinfo->info.message = D.22762;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22763 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22763;
      }
      <D.22761>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22759>:
      <D.22756>:
      if (allow_unmanaged != 0) goto <D.22764>; else goto <D.22765>;
      <D.22764>:
      cconv.82 = cconv;
      D.22745 = cconv.82 & 16;
      if (D.22745 != 0) goto <D.22766>; else goto <D.22767>;
      <D.22766>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22768>; else goto <D.22769>;
      <D.22768>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22770 = monoeg_strdup ("MethodSig: Standalone signature with generic params");
        vinfo->info.message = D.22770;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22771 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22771;
      }
      <D.22769>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22767>:
      <D.22765>:
      D.22772 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.22772 == 0) goto <D.22773>; else goto <D.22774>;
      <D.22773>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22775>; else goto <D.22776>;
      <D.22775>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22777 = monoeg_strdup ("MethodSig: Not enough room for the param count");
        vinfo->info.message = D.22777;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22778 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22778;
      }
      <D.22776>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22774>:
      D.22779 = parse_return_type (ctx, &ptr, end);
      if (D.22779 == 0) goto <D.22780>; else goto <D.22781>;
      <D.22780>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22782>; else goto <D.22783>;
      <D.22782>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22784 = monoeg_strdup ("MethodSig: Error parsing return type");
        vinfo->info.message = D.22784;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22785 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22785;
      }
      <D.22783>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22781>:
      i = 0;
      goto <D.18351>;
      <D.18350>:
      if (allow_sentinel != 0) goto <D.22786>; else goto <D.22787>;
      <D.22786>:
      D.22788 = safe_read (&ptr, end, &type, 1);
      if (D.22788 == 0) goto <D.22789>; else goto <D.22790>;
      <D.22789>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22791>; else goto <D.22792>;
      <D.22791>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22793 = monoeg_g_strdup_printf ("MethodSig: Not enough room for param %d type", i);
        vinfo->info.message = D.22793;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22794 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22794;
      }
      <D.22792>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22790>:
      type.84 = type;
      if (type.84 == 65) goto <D.22796>; else goto <D.22797>;
      <D.22796>:
      cconv.82 = cconv;
      D.22727 = cconv.82 & 15;
      if (D.22727 != 5) goto <D.22798>; else goto <D.22799>;
      <D.22798>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22800>; else goto <D.22801>;
      <D.22800>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22802 = monoeg_strdup ("MethodSig: Found sentinel but signature is not vararg");
        vinfo->info.message = D.22802;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22803 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22803;
      }
      <D.22801>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22799>:
      if (saw_sentinel != 0) goto <D.22804>; else goto <D.22805>;
      <D.22804>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22806>; else goto <D.22807>;
      <D.22806>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22808 = monoeg_strdup ("MethodSig: More than one sentinel type");
        vinfo->info.message = D.22808;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22809 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22809;
      }
      <D.22807>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22805>:
      saw_sentinel = 1;
      goto <D.22810>;
      <D.22797>:
      ptr.85 = ptr;
      ptr.86 = ptr.85 + 18446744073709551615;
      ptr = ptr.86;
      <D.22810>:
      <D.22787>:
      D.22813 = parse_param (ctx, &ptr, end);
      if (D.22813 == 0) goto <D.22814>; else goto <D.22815>;
      <D.22814>:
      D.22710 = ctx->report_error;
      if (D.22710 != 0) goto <D.22816>; else goto <D.22817>;
      <D.22816>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22818 = monoeg_g_strdup_printf ("MethodSig: Error parsing arg %d", i);
        vinfo->info.message = D.22818;
        vinfo->exception_type = 3;
        D.22714 = ctx->errors;
        D.22819 = monoeg_g_slist_prepend (D.22714, vinfo);
        ctx->errors = D.22819;
      }
      <D.22817>:
      ctx->valid = 0;
      D.22716 = 0;
      return D.22716;
      <D.22815>:
      i = i + 1;
      <D.18351>:
      param_count.87 = param_count;
      if (i < param_count.87) goto <D.18350>; else goto <D.18352>;
      <D.18352>:
      ptr.85 = ptr;
      *_ptr = ptr.85;
      D.22716 = 1;
      return D.22716;
    }
  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.22823;
  gboolean D.22826;
  const char * ptr.88;
  int D.22828;
  int D.22831;
  gchar * D.22834;
  struct GSList * D.22835;
  struct GSList * D.22836;
  unsigned int type.89;
  _Bool D.22838;
  _Bool D.22839;
  _Bool D.22840;
  const char * ptr.90;
  unsigned int type.91;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22823 = parse_custom_mods (ctx, _ptr, end);
      if (D.22823 == 0) goto <D.22824>; else goto <D.22825>;
      <D.22824>:
      D.22826 = 0;
      return D.22826;
      <D.22825>:
      ptr.88 = *_ptr;
      ptr = ptr.88;
      D.22828 = safe_read (&ptr, end, &type, 1);
      if (D.22828 == 0) goto <D.22829>; else goto <D.22830>;
      <D.22829>:
      D.22831 = ctx->report_error;
      if (D.22831 != 0) goto <D.22832>; else goto <D.22833>;
      <D.22832>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22834 = monoeg_strdup ("ReturnType: Not enough room for the type");
        vinfo->info.message = D.22834;
        vinfo->exception_type = 3;
        D.22835 = ctx->errors;
        D.22836 = monoeg_g_slist_prepend (D.22835, vinfo);
        ctx->errors = D.22836;
      }
      <D.22833>:
      ctx->valid = 0;
      D.22826 = 0;
      return D.22826;
      <D.22830>:
      type.89 = type;
      D.22838 = type.89 == 1;
      D.22839 = type.89 == 22;
      D.22840 = D.22838 | D.22839;
      if (D.22840 != 0) goto <D.22841>; else goto <D.22842>;
      <D.22841>:
      ptr.90 = ptr;
      *_ptr = ptr.90;
      D.22826 = 1;
      return D.22826;
      <D.22842>:
      type.91 = type;
      if (type.91 == 16) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      ptr.90 = ptr;
      *_ptr = ptr.90;
      <D.22846>:
      D.22826 = parse_type (ctx, _ptr, end);
      return D.22826;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


parse_param (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.22849;
  gboolean D.22852;
  const char * ptr.92;
  int D.22854;
  int D.22857;
  gchar * D.22860;
  struct GSList * D.22861;
  struct GSList * D.22862;
  unsigned int type.93;
  const char * ptr.94;
  int D.22869;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.22849 = parse_custom_mods (ctx, _ptr, end);
      if (D.22849 == 0) goto <D.22850>; else goto <D.22851>;
      <D.22850>:
      D.22852 = 0;
      return D.22852;
      <D.22851>:
      ptr.92 = *_ptr;
      ptr = ptr.92;
      D.22854 = safe_read (&ptr, end, &type, 1);
      if (D.22854 == 0) goto <D.22855>; else goto <D.22856>;
      <D.22855>:
      D.22857 = ctx->report_error;
      if (D.22857 != 0) goto <D.22858>; else goto <D.22859>;
      <D.22858>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22860 = monoeg_strdup ("Param: Not enough room for the type");
        vinfo->info.message = D.22860;
        vinfo->exception_type = 3;
        D.22861 = ctx->errors;
        D.22862 = monoeg_g_slist_prepend (D.22861, vinfo);
        ctx->errors = D.22862;
      }
      <D.22859>:
      ctx->valid = 0;
      D.22852 = 0;
      return D.22852;
      <D.22856>:
      type.93 = type;
      if (type.93 == 22) goto <D.22864>; else goto <D.22865>;
      <D.22864>:
      ptr.94 = ptr;
      *_ptr = ptr.94;
      D.22852 = 1;
      return D.22852;
      <D.22865>:
      type.93 = type;
      if (type.93 == 16) goto <D.22867>; else goto <D.22868>;
      <D.22867>:
      ptr.94 = ptr;
      *_ptr = ptr.94;
      D.22869 = parse_custom_mods (ctx, _ptr, end);
      if (D.22869 == 0) goto <D.22870>; else goto <D.22871>;
      <D.22870>:
      D.22852 = 0;
      return D.22852;
      <D.22871>:
      <D.22868>:
      D.22852 = parse_type (ctx, _ptr, end);
      return D.22852;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_methodimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22874;
  unsigned int D.22877;
  <unnamed-unsigned:24> D.22879;
  int D.22880;
  int D.22881;
  unsigned int D.22882;
  int D.22883;
  unsigned int D.22886;
  gchar * D.22887;
  struct GSList * D.22888;
  struct GSList * D.22889;
  unsigned int D.22890;
  unsigned int D.22891;
  gchar * D.22896;
  struct GSList * D.22897;
  int D.22898;
  gchar * D.22903;
  struct GSList * D.22904;
  unsigned int D.22905;
  gchar * D.22910;
  struct GSList * D.22911;
  int D.22912;
  gchar * D.22917;
  struct GSList * D.22918;
  <unnamed-unsigned:24> D.22919;
  int D.22920;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22874 = ctx->image;
      table = &D.22874->tables[25];
      i = 0;
      goto <D.19200>;
      <D.19199>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22877 = data[0];
      if (D.22877 == 0) goto <D.22875>; else goto <D.22878>;
      <D.22878>:
      D.22877 = data[0];
      D.22874 = ctx->image;
      D.22879 = D.22874->tables[2].rows;
      D.22880 = (int) D.22879;
      D.22881 = D.22880 + 1;
      D.22882 = (unsigned int) D.22881;
      if (D.22877 > D.22882) goto <D.22875>; else goto <D.22876>;
      <D.22875>:
      D.22883 = ctx->report_error;
      if (D.22883 != 0) goto <D.22884>; else goto <D.22885>;
      <D.22884>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22886 = data[2];
        D.22887 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d Class field %08x", i, D.22886);
        vinfo->info.message = D.22887;
        vinfo->exception_type = 3;
        D.22888 = ctx->errors;
        D.22889 = monoeg_g_slist_prepend (D.22888, vinfo);
        ctx->errors = D.22889;
      }
      <D.22885>:
      ctx->valid = 0;
      return;
      <D.22876>:
      D.22890 = data[1];
      D.22891 = get_coded_index_token (52, D.22890);
      if (D.22891 == 0) goto <D.22892>; else goto <D.22893>;
      <D.22892>:
      D.22883 = ctx->report_error;
      if (D.22883 != 0) goto <D.22894>; else goto <D.22895>;
      <D.22894>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22890 = data[1];
        D.22896 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22890);
        vinfo->info.message = D.22896;
        vinfo->exception_type = 3;
        D.22888 = ctx->errors;
        D.22897 = monoeg_g_slist_prepend (D.22888, vinfo);
        ctx->errors = D.22897;
      }
      <D.22895>:
      ctx->valid = 0;
      return;
      <D.22893>:
      D.22890 = data[1];
      D.22898 = is_valid_coded_index (ctx, 52, D.22890);
      if (D.22898 == 0) goto <D.22899>; else goto <D.22900>;
      <D.22899>:
      D.22883 = ctx->report_error;
      if (D.22883 != 0) goto <D.22901>; else goto <D.22902>;
      <D.22901>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22890 = data[1];
        D.22903 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.22890);
        vinfo->info.message = D.22903;
        vinfo->exception_type = 3;
        D.22888 = ctx->errors;
        D.22904 = monoeg_g_slist_prepend (D.22888, vinfo);
        ctx->errors = D.22904;
      }
      <D.22902>:
      ctx->valid = 0;
      return;
      <D.22900>:
      D.22886 = data[2];
      D.22905 = get_coded_index_token (52, D.22886);
      if (D.22905 == 0) goto <D.22906>; else goto <D.22907>;
      <D.22906>:
      D.22883 = ctx->report_error;
      if (D.22883 != 0) goto <D.22908>; else goto <D.22909>;
      <D.22908>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22886 = data[2];
        D.22910 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22886);
        vinfo->info.message = D.22910;
        vinfo->exception_type = 3;
        D.22888 = ctx->errors;
        D.22911 = monoeg_g_slist_prepend (D.22888, vinfo);
        ctx->errors = D.22911;
      }
      <D.22909>:
      ctx->valid = 0;
      return;
      <D.22907>:
      D.22886 = data[2];
      D.22912 = is_valid_coded_index (ctx, 52, D.22886);
      if (D.22912 == 0) goto <D.22913>; else goto <D.22914>;
      <D.22913>:
      D.22883 = ctx->report_error;
      if (D.22883 != 0) goto <D.22915>; else goto <D.22916>;
      <D.22915>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22886 = data[2];
        D.22917 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.22886);
        vinfo->info.message = D.22917;
        vinfo->exception_type = 3;
        D.22888 = ctx->errors;
        D.22918 = monoeg_g_slist_prepend (D.22888, vinfo);
        ctx->errors = D.22918;
      }
      <D.22916>:
      ctx->valid = 0;
      return;
      <D.22914>:
      i = i + 1;
      <D.19200>:
      D.22919 = table->rows;
      D.22920 = (int) D.22919;
      if (D.22920 > i) goto <D.19199>; else goto <D.19201>;
      <D.19201>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_moduleref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22924;
  unsigned int D.22925;
  int D.22926;
  int D.22929;
  gchar * D.22932;
  struct GSList * D.22933;
  struct GSList * D.22934;
  <unnamed-unsigned:24> D.22935;
  int D.22936;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22924 = ctx->image;
      table = &D.22924->tables[26];
      i = 0;
      goto <D.19210>;
      <D.19209>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22925 = data[0];
      D.22926 = is_valid_non_empty_string (ctx, D.22925);
      if (D.22926 == 0) goto <D.22927>; else goto <D.22928>;
      <D.22927>:
      D.22929 = ctx->report_error;
      if (D.22929 != 0) goto <D.22930>; else goto <D.22931>;
      <D.22930>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22925 = data[0];
        D.22932 = monoeg_g_strdup_printf ("Invalid ModuleRef row %d name field %08x", i, D.22925);
        vinfo->info.message = D.22932;
        vinfo->exception_type = 3;
        D.22933 = ctx->errors;
        D.22934 = monoeg_g_slist_prepend (D.22933, vinfo);
        ctx->errors = D.22934;
      }
      <D.22931>:
      ctx->valid = 0;
      return;
      <D.22928>:
      i = i + 1;
      <D.19210>:
      D.22935 = table->rows;
      D.22936 = (int) D.22935;
      if (D.22936 > i) goto <D.19209>; else goto <D.19211>;
      <D.19211>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_typespec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22940;
  unsigned int D.22941;
  int D.22944;
  int D.22947;
  gchar * D.22950;
  struct GSList * D.22951;
  struct GSList * D.22952;
  <unnamed-unsigned:24> D.22953;
  int D.22954;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22940 = ctx->image;
      table = &D.22940->tables[27];
      i = 0;
      goto <D.19220>;
      <D.19219>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22941 = data[0];
      if (D.22941 != 0) goto <D.22942>; else goto <D.22943>;
      <D.22942>:
      D.22941 = data[0];
      D.22944 = is_valid_blob_object (ctx, D.22941, 1);
      if (D.22944 == 0) goto <D.22945>; else goto <D.22946>;
      <D.22945>:
      D.22947 = ctx->report_error;
      if (D.22947 != 0) goto <D.22948>; else goto <D.22949>;
      <D.22948>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22941 = data[0];
        D.22950 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.22941);
        vinfo->info.message = D.22950;
        vinfo->exception_type = 3;
        D.22951 = ctx->errors;
        D.22952 = monoeg_g_slist_prepend (D.22951, vinfo);
        ctx->errors = D.22952;
      }
      <D.22949>:
      ctx->valid = 0;
      return;
      <D.22946>:
      <D.22943>:
      i = i + 1;
      <D.19220>:
      D.22953 = table->rows;
      D.22954 = (int) D.22953;
      if (D.22954 > i) goto <D.19219>; else goto <D.19221>;
      <D.19221>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_implmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22958;
  unsigned int D.22959;
  unsigned int D.22960;
  int D.22963;
  gchar * D.22966;
  struct GSList * D.22967;
  struct GSList * D.22968;
  _Bool D.22971;
  _Bool D.22972;
  _Bool D.22973;
  gchar * D.22977;
  struct GSList * D.22978;
  unsigned int D.22979;
  int D.22980;
  gchar * D.22985;
  struct GSList * D.22986;
  unsigned int D.22987;
  gchar * D.22992;
  struct GSList * D.22993;
  unsigned int D.22994;
  gchar * D.22999;
  struct GSList * D.23000;
  unsigned int D.23001;
  int D.23002;
  gchar * D.23007;
  struct GSList * D.23008;
  unsigned int D.23011;
  <unnamed-unsigned:24> D.23013;
  unsigned int D.23014;
  gchar * D.23017;
  struct GSList * D.23018;
  <unnamed-unsigned:24> D.23019;
  int D.23020;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 cconv;
  int i;

  try
    {
      D.22958 = ctx->image;
      table = &D.22958->tables[28];
      i = 0;
      goto <D.19247>;
      <D.19246>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.22959 = data[0];
      D.22960 = D.22959 & 4294953096;
      if (D.22960 != 0) goto <D.22961>; else goto <D.22962>;
      <D.22961>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22959 = data[0];
        D.22966 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Flags field %08x", i, D.22959);
        vinfo->info.message = D.22966;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.22968 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.22968;
      }
      <D.22965>:
      ctx->valid = 0;
      return;
      <D.22962>:
      D.22959 = data[0];
      cconv = D.22959 & 1792;
      D.22971 = cconv == 0;
      D.22972 = cconv == 1536;
      D.22973 = D.22971 | D.22972;
      if (D.22973 != 0) goto <D.22969>; else goto <D.22974>;
      <D.22974>:
      if (cconv == 1792) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.22975>; else goto <D.22976>;
      <D.22975>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22977 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid call conv field %x", i, cconv);
        vinfo->info.message = D.22977;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.22978 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.22978;
      }
      <D.22976>:
      ctx->valid = 0;
      return;
      <D.22970>:
      D.22979 = data[1];
      D.22980 = is_valid_coded_index (ctx, 56, D.22979);
      if (D.22980 == 0) goto <D.22981>; else goto <D.22982>;
      <D.22981>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.22983>; else goto <D.22984>;
      <D.22983>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22979 = data[1];
        D.22985 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid MemberForward token %x", i, D.22979);
        vinfo->info.message = D.22985;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.22986 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.22986;
      }
      <D.22984>:
      ctx->valid = 0;
      return;
      <D.22982>:
      D.22979 = data[1];
      D.22987 = get_coded_index_table (56, D.22979);
      if (D.22987 != 6) goto <D.22988>; else goto <D.22989>;
      <D.22988>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22979 = data[1];
        D.22992 = monoeg_g_strdup_printf ("Invalid ImplMap row %d only methods are supported token %x", i, D.22979);
        vinfo->info.message = D.22992;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.22993 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.22993;
      }
      <D.22991>:
      ctx->valid = 0;
      return;
      <D.22989>:
      D.22979 = data[1];
      D.22994 = get_coded_index_token (56, D.22979);
      if (D.22994 == 0) goto <D.22995>; else goto <D.22996>;
      <D.22995>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.22997>; else goto <D.22998>;
      <D.22997>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22999 = monoeg_g_strdup_printf ("Invalid ImplMap row %d null token", i);
        vinfo->info.message = D.22999;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.23000 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.23000;
      }
      <D.22998>:
      ctx->valid = 0;
      return;
      <D.22996>:
      D.23001 = data[2];
      D.23002 = is_valid_non_empty_string (ctx, D.23001);
      if (D.23002 == 0) goto <D.23003>; else goto <D.23004>;
      <D.23003>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23001 = data[2];
        D.23007 = monoeg_g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, D.23001);
        vinfo->info.message = D.23007;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.23008 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.23008;
      }
      <D.23006>:
      ctx->valid = 0;
      return;
      <D.23004>:
      D.23011 = data[3];
      if (D.23011 == 0) goto <D.23009>; else goto <D.23012>;
      <D.23012>:
      D.23011 = data[3];
      D.22958 = ctx->image;
      D.23013 = D.22958->tables[26].rows;
      D.23014 = (unsigned int) D.23013;
      if (D.23011 > D.23014) goto <D.23009>; else goto <D.23010>;
      <D.23009>:
      D.22963 = ctx->report_error;
      if (D.22963 != 0) goto <D.23015>; else goto <D.23016>;
      <D.23015>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23011 = data[3];
        D.23017 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, D.23011);
        vinfo->info.message = D.23017;
        vinfo->exception_type = 3;
        D.22967 = ctx->errors;
        D.23018 = monoeg_g_slist_prepend (D.22967, vinfo);
        ctx->errors = D.23018;
      }
      <D.23016>:
      ctx->valid = 0;
      return;
      <D.23010>:
      i = i + 1;
      <D.19247>:
      D.23019 = table->rows;
      D.23020 = (int) D.23019;
      if (D.23020 > i) goto <D.19246>; else goto <D.19248>;
      <D.19248>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_fieldrva_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23024;
  unsigned int D.23027;
  unsigned int D.23029;
  int D.23030;
  gchar * D.23033;
  struct GSList * D.23034;
  struct GSList * D.23035;
  unsigned int D.23038;
  <unnamed-unsigned:24> D.23040;
  int D.23041;
  int D.23042;
  unsigned int D.23043;
  gchar * D.23046;
  struct GSList * D.23047;
  <unnamed-unsigned:24> D.23048;
  int D.23049;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23024 = ctx->image;
      table = &D.23024->tables[29];
      i = 0;
      goto <D.19258>;
      <D.19257>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23027 = data[0];
      if (D.23027 == 0) goto <D.23025>; else goto <D.23028>;
      <D.23028>:
      D.23027 = data[0];
      D.23024 = ctx->image;
      D.23029 = mono_cli_rva_image_map (D.23024, D.23027);
      if (D.23029 == 4294967295) goto <D.23025>; else goto <D.23026>;
      <D.23025>:
      D.23030 = ctx->report_error;
      if (D.23030 != 0) goto <D.23031>; else goto <D.23032>;
      <D.23031>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23027 = data[0];
        D.23033 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d RVA %08x", i, D.23027);
        vinfo->info.message = D.23033;
        vinfo->exception_type = 3;
        D.23034 = ctx->errors;
        D.23035 = monoeg_g_slist_prepend (D.23034, vinfo);
        ctx->errors = D.23035;
      }
      <D.23032>:
      ctx->valid = 0;
      return;
      <D.23026>:
      D.23038 = data[1];
      if (D.23038 == 0) goto <D.23036>; else goto <D.23039>;
      <D.23039>:
      D.23038 = data[1];
      D.23024 = ctx->image;
      D.23040 = D.23024->tables[4].rows;
      D.23041 = (int) D.23040;
      D.23042 = D.23041 + 1;
      D.23043 = (unsigned int) D.23042;
      if (D.23038 > D.23043) goto <D.23036>; else goto <D.23037>;
      <D.23036>:
      D.23030 = ctx->report_error;
      if (D.23030 != 0) goto <D.23044>; else goto <D.23045>;
      <D.23044>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23038 = data[1];
        D.23046 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d Field %08x", i, D.23038);
        vinfo->info.message = D.23046;
        vinfo->exception_type = 3;
        D.23034 = ctx->errors;
        D.23047 = monoeg_g_slist_prepend (D.23034, vinfo);
        ctx->errors = D.23047;
      }
      <D.23045>:
      ctx->valid = 0;
      return;
      <D.23037>:
      i = i + 1;
      <D.19258>:
      D.23048 = table->rows;
      D.23049 = (int) D.23048;
      if (D.23049 > i) goto <D.19257>; else goto <D.19259>;
      <D.19259>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assembly_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23053;
  <unnamed-unsigned:24> D.23054;
  int D.23055;
  int D.23058;
  gchar * D.23061;
  struct GSList * D.23062;
  struct GSList * D.23063;
  _Bool D.23064;
  _Bool D.23065;
  _Bool D.23066;
  gchar * D.23073;
  struct GSList * D.23074;
  unsigned int D.23075;
  unsigned int D.23076;
  gchar * D.23081;
  struct GSList * D.23082;
  unsigned int D.23083;
  int D.23086;
  gchar * D.23091;
  struct GSList * D.23092;
  unsigned int D.23093;
  int D.23094;
  gchar * D.23099;
  struct GSList * D.23100;
  unsigned int D.23101;
  int D.23104;
  gchar * D.23109;
  struct GSList * D.23110;
  struct MonoTableInfo * table;
  guint32 data[9];
  guint32 hash;
  int i;

  try
    {
      D.23053 = ctx->image;
      table = &D.23053->tables[32];
      D.23054 = table->rows;
      D.23055 = (int) D.23054;
      if (D.23055 > 1) goto <D.23056>; else goto <D.23057>;
      <D.23056>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23059>; else goto <D.23060>;
      <D.23059>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23054 = table->rows;
        D.23055 = (int) D.23054;
        D.23061 = monoeg_g_strdup_printf ("Assembly table can have zero or one rows, but now %d", D.23055);
        vinfo->info.message = D.23061;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23063 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23063;
      }
      <D.23060>:
      ctx->valid = 0;
      return;
      <D.23057>:
      i = 0;
      goto <D.19274>;
      <D.19273>:
      mono_metadata_decode_row (table, i, &data, 9);
      hash = data[0];
      D.23064 = hash != 0;
      D.23065 = hash != 32771;
      D.23066 = D.23064 & D.23065;
      if (D.23066 != 0) goto <D.23067>; else goto <D.23068>;
      <D.23067>:
      if (hash != 32772) goto <D.23069>; else goto <D.23070>;
      <D.23069>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23071>; else goto <D.23072>;
      <D.23071>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23073 = monoeg_g_strdup_printf ("Assembly table row %d has invalid HashAlgId %x", i, hash);
        vinfo->info.message = D.23073;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23074 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23074;
      }
      <D.23072>:
      ctx->valid = 0;
      return;
      <D.23070>:
      <D.23068>:
      D.23075 = data[5];
      D.23076 = D.23075 & 4294917646;
      if (D.23076 != 0) goto <D.23077>; else goto <D.23078>;
      <D.23077>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23079>; else goto <D.23080>;
      <D.23079>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23075 = data[5];
        D.23081 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, D.23075);
        vinfo->info.message = D.23081;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23082 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23082;
      }
      <D.23080>:
      ctx->valid = 0;
      return;
      <D.23078>:
      D.23083 = data[6];
      if (D.23083 != 0) goto <D.23084>; else goto <D.23085>;
      <D.23084>:
      D.23083 = data[6];
      D.23086 = is_valid_blob_object (ctx, D.23083, 1);
      if (D.23086 == 0) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23089>; else goto <D.23090>;
      <D.23089>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23075 = data[5];
        D.23091 = monoeg_g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, D.23075);
        vinfo->info.message = D.23091;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23092 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23092;
      }
      <D.23090>:
      ctx->valid = 0;
      return;
      <D.23088>:
      <D.23085>:
      D.23093 = data[7];
      D.23094 = is_valid_non_empty_string (ctx, D.23093);
      if (D.23094 == 0) goto <D.23095>; else goto <D.23096>;
      <D.23095>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23097>; else goto <D.23098>;
      <D.23097>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23093 = data[7];
        D.23099 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Name %08x", i, D.23093);
        vinfo->info.message = D.23099;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23100 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23100;
      }
      <D.23098>:
      ctx->valid = 0;
      return;
      <D.23096>:
      D.23101 = data[8];
      if (D.23101 != 0) goto <D.23102>; else goto <D.23103>;
      <D.23102>:
      D.23101 = data[8];
      D.23104 = is_valid_string (ctx, D.23101);
      if (D.23104 == 0) goto <D.23105>; else goto <D.23106>;
      <D.23105>:
      D.23058 = ctx->report_error;
      if (D.23058 != 0) goto <D.23107>; else goto <D.23108>;
      <D.23107>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23101 = data[8];
        D.23109 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Culture %08x", i, D.23101);
        vinfo->info.message = D.23109;
        vinfo->exception_type = 3;
        D.23062 = ctx->errors;
        D.23110 = monoeg_g_slist_prepend (D.23062, vinfo);
        ctx->errors = D.23110;
      }
      <D.23108>:
      ctx->valid = 0;
      return;
      <D.23106>:
      <D.23103>:
      i = i + 1;
      <D.19274>:
      D.23054 = table->rows;
      D.23055 = (int) D.23054;
      if (D.23055 > i) goto <D.19273>; else goto <D.19275>;
      <D.19275>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assemblyref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23114;
  unsigned int D.23115;
  unsigned int D.23116;
  int D.23119;
  gchar * D.23122;
  struct GSList * D.23123;
  struct GSList * D.23124;
  unsigned int D.23125;
  int D.23128;
  gchar * D.23133;
  struct GSList * D.23134;
  unsigned int D.23135;
  int D.23136;
  gchar * D.23141;
  struct GSList * D.23142;
  unsigned int D.23143;
  int D.23146;
  gchar * D.23151;
  struct GSList * D.23152;
  unsigned int D.23153;
  int D.23156;
  gchar * D.23161;
  struct GSList * D.23162;
  <unnamed-unsigned:24> D.23163;
  int D.23164;
  struct MonoTableInfo * table;
  guint32 data[9];
  int i;

  try
    {
      D.23114 = ctx->image;
      table = &D.23114->tables[35];
      i = 0;
      goto <D.19288>;
      <D.19287>:
      mono_metadata_decode_row (table, i, &data, 9);
      D.23115 = data[4];
      D.23116 = D.23115 & 4294917886;
      if (D.23116 != 0) goto <D.23117>; else goto <D.23118>;
      <D.23117>:
      D.23119 = ctx->report_error;
      if (D.23119 != 0) goto <D.23120>; else goto <D.23121>;
      <D.23120>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23115 = data[4];
        D.23122 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Flags %08x", i, D.23115);
        vinfo->info.message = D.23122;
        vinfo->exception_type = 3;
        D.23123 = ctx->errors;
        D.23124 = monoeg_g_slist_prepend (D.23123, vinfo);
        ctx->errors = D.23124;
      }
      <D.23121>:
      ctx->valid = 0;
      return;
      <D.23118>:
      D.23125 = data[5];
      if (D.23125 != 0) goto <D.23126>; else goto <D.23127>;
      <D.23126>:
      D.23125 = data[5];
      D.23128 = is_valid_blob_object (ctx, D.23125, 1);
      if (D.23128 == 0) goto <D.23129>; else goto <D.23130>;
      <D.23129>:
      D.23119 = ctx->report_error;
      if (D.23119 != 0) goto <D.23131>; else goto <D.23132>;
      <D.23131>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23125 = data[5];
        D.23133 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, D.23125);
        vinfo->info.message = D.23133;
        vinfo->exception_type = 3;
        D.23123 = ctx->errors;
        D.23134 = monoeg_g_slist_prepend (D.23123, vinfo);
        ctx->errors = D.23134;
      }
      <D.23132>:
      ctx->valid = 0;
      return;
      <D.23130>:
      <D.23127>:
      D.23135 = data[6];
      D.23136 = is_valid_non_empty_string (ctx, D.23135);
      if (D.23136 == 0) goto <D.23137>; else goto <D.23138>;
      <D.23137>:
      D.23119 = ctx->report_error;
      if (D.23119 != 0) goto <D.23139>; else goto <D.23140>;
      <D.23139>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23135 = data[6];
        D.23141 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Name %08x", i, D.23135);
        vinfo->info.message = D.23141;
        vinfo->exception_type = 3;
        D.23123 = ctx->errors;
        D.23142 = monoeg_g_slist_prepend (D.23123, vinfo);
        ctx->errors = D.23142;
      }
      <D.23140>:
      ctx->valid = 0;
      return;
      <D.23138>:
      D.23143 = data[7];
      if (D.23143 != 0) goto <D.23144>; else goto <D.23145>;
      <D.23144>:
      D.23143 = data[7];
      D.23146 = is_valid_string (ctx, D.23143);
      if (D.23146 == 0) goto <D.23147>; else goto <D.23148>;
      <D.23147>:
      D.23119 = ctx->report_error;
      if (D.23119 != 0) goto <D.23149>; else goto <D.23150>;
      <D.23149>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23143 = data[7];
        D.23151 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, D.23143);
        vinfo->info.message = D.23151;
        vinfo->exception_type = 3;
        D.23123 = ctx->errors;
        D.23152 = monoeg_g_slist_prepend (D.23123, vinfo);
        ctx->errors = D.23152;
      }
      <D.23150>:
      ctx->valid = 0;
      return;
      <D.23148>:
      <D.23145>:
      D.23153 = data[8];
      if (D.23153 != 0) goto <D.23154>; else goto <D.23155>;
      <D.23154>:
      D.23153 = data[8];
      D.23156 = is_valid_blob_object (ctx, D.23153, 1);
      if (D.23156 == 0) goto <D.23157>; else goto <D.23158>;
      <D.23157>:
      D.23119 = ctx->report_error;
      if (D.23119 != 0) goto <D.23159>; else goto <D.23160>;
      <D.23159>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23153 = data[8];
        D.23161 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, D.23153);
        vinfo->info.message = D.23161;
        vinfo->exception_type = 3;
        D.23123 = ctx->errors;
        D.23162 = monoeg_g_slist_prepend (D.23123, vinfo);
        ctx->errors = D.23162;
      }
      <D.23160>:
      ctx->valid = 0;
      return;
      <D.23158>:
      <D.23155>:
      i = i + 1;
      <D.19288>:
      D.23163 = table->rows;
      D.23164 = (int) D.23163;
      if (D.23164 > i) goto <D.19287>; else goto <D.19289>;
      <D.19289>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_file_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23168;
  unsigned int D.23169;
  unsigned int D.23170;
  int D.23173;
  gchar * D.23176;
  struct GSList * D.23177;
  struct GSList * D.23178;
  unsigned int D.23179;
  int D.23180;
  gchar * D.23185;
  struct GSList * D.23186;
  unsigned int D.23189;
  int D.23191;
  gchar * D.23194;
  struct GSList * D.23195;
  <unnamed-unsigned:24> D.23196;
  int D.23197;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23168 = ctx->image;
      table = &D.23168->tables[38];
      i = 0;
      goto <D.19300>;
      <D.19299>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23169 = data[0];
      D.23170 = D.23169 & 4294967294;
      if (D.23170 != 0) goto <D.23171>; else goto <D.23172>;
      <D.23171>:
      D.23173 = ctx->report_error;
      if (D.23173 != 0) goto <D.23174>; else goto <D.23175>;
      <D.23174>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23169 = data[0];
        D.23176 = monoeg_g_strdup_printf ("File table row %d has invalid Flags %08x", i, D.23169);
        vinfo->info.message = D.23176;
        vinfo->exception_type = 3;
        D.23177 = ctx->errors;
        D.23178 = monoeg_g_slist_prepend (D.23177, vinfo);
        ctx->errors = D.23178;
      }
      <D.23175>:
      ctx->valid = 0;
      return;
      <D.23172>:
      D.23179 = data[1];
      D.23180 = is_valid_non_empty_string (ctx, D.23179);
      if (D.23180 == 0) goto <D.23181>; else goto <D.23182>;
      <D.23181>:
      D.23173 = ctx->report_error;
      if (D.23173 != 0) goto <D.23183>; else goto <D.23184>;
      <D.23183>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23179 = data[1];
        D.23185 = monoeg_g_strdup_printf ("File table row %d has invalid Name %08x", i, D.23179);
        vinfo->info.message = D.23185;
        vinfo->exception_type = 3;
        D.23177 = ctx->errors;
        D.23186 = monoeg_g_slist_prepend (D.23177, vinfo);
        ctx->errors = D.23186;
      }
      <D.23184>:
      ctx->valid = 0;
      return;
      <D.23182>:
      D.23189 = data[2];
      if (D.23189 == 0) goto <D.23187>; else goto <D.23190>;
      <D.23190>:
      D.23189 = data[2];
      D.23191 = is_valid_blob_object (ctx, D.23189, 1);
      if (D.23191 == 0) goto <D.23187>; else goto <D.23188>;
      <D.23187>:
      D.23173 = ctx->report_error;
      if (D.23173 != 0) goto <D.23192>; else goto <D.23193>;
      <D.23192>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23189 = data[2];
        D.23194 = monoeg_g_strdup_printf ("File table row %d has invalid HashValue %08x", i, D.23189);
        vinfo->info.message = D.23194;
        vinfo->exception_type = 3;
        D.23177 = ctx->errors;
        D.23195 = monoeg_g_slist_prepend (D.23177, vinfo);
        ctx->errors = D.23195;
      }
      <D.23193>:
      ctx->valid = 0;
      return;
      <D.23188>:
      i = i + 1;
      <D.19300>:
      D.23196 = table->rows;
      D.23197 = (int) D.23196;
      if (D.23197 > i) goto <D.19299>; else goto <D.19301>;
      <D.19301>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_exportedtype_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23201;
  unsigned int D.23202;
  unsigned int D.23203;
  int D.23206;
  gchar * D.23209;
  struct GSList * D.23210;
  struct GSList * D.23211;
  unsigned int D.23212;
  int D.23213;
  unsigned int D.23218;
  gchar * D.23219;
  struct GSList * D.23220;
  unsigned int D.23221;
  int D.23224;
  gchar * D.23229;
  struct GSList * D.23230;
  unsigned int D.23231;
  int D.23232;
  gchar * D.23237;
  struct GSList * D.23238;
  unsigned int D.23239;
  gchar * D.23244;
  struct GSList * D.23245;
  unsigned int D.23246;
  gchar * D.23253;
  struct GSList * D.23254;
  <unnamed-unsigned:24> D.23255;
  int D.23256;
  struct MonoTableInfo * table;
  guint32 data[5];
  int i;

  try
    {
      D.23201 = ctx->image;
      table = &D.23201->tables[39];
      i = 0;
      goto <D.19315>;
      <D.19314>:
      mono_metadata_decode_row (table, i, &data, 5);
      D.23202 = data[0];
      D.23203 = D.23202 & 4278764096;
      if (D.23203 != 0) goto <D.23204>; else goto <D.23205>;
      <D.23204>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23207>; else goto <D.23208>;
      <D.23207>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23202 = data[0];
        D.23209 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Flags %08x", i, D.23202);
        vinfo->info.message = D.23209;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23211 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23211;
      }
      <D.23208>:
      ctx->valid = 0;
      return;
      <D.23205>:
      D.23212 = data[2];
      D.23213 = is_valid_non_empty_string (ctx, D.23212);
      if (D.23213 == 0) goto <D.23214>; else goto <D.23215>;
      <D.23214>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23216>; else goto <D.23217>;
      <D.23216>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23218 = data[1];
        D.23219 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeName %08x", i, D.23218);
        vinfo->info.message = D.23219;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23220 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23220;
      }
      <D.23217>:
      ctx->valid = 0;
      return;
      <D.23215>:
      D.23221 = data[3];
      if (D.23221 != 0) goto <D.23222>; else goto <D.23223>;
      <D.23222>:
      D.23221 = data[3];
      D.23224 = is_valid_string (ctx, D.23221);
      if (D.23224 == 0) goto <D.23225>; else goto <D.23226>;
      <D.23225>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23227>; else goto <D.23228>;
      <D.23227>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23221 = data[3];
        D.23229 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeNamespace %08x", i, D.23221);
        vinfo->info.message = D.23229;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23230 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23230;
      }
      <D.23228>:
      ctx->valid = 0;
      return;
      <D.23226>:
      <D.23223>:
      D.23231 = data[4];
      D.23232 = is_valid_coded_index (ctx, 60, D.23231);
      if (D.23232 == 0) goto <D.23233>; else goto <D.23234>;
      <D.23233>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23235>; else goto <D.23236>;
      <D.23235>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23231 = data[4];
        D.23237 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Implementation token %08x", i, D.23231);
        vinfo->info.message = D.23237;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23238 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23238;
      }
      <D.23236>:
      ctx->valid = 0;
      return;
      <D.23234>:
      D.23231 = data[4];
      D.23239 = get_coded_index_token (60, D.23231);
      if (D.23239 == 0) goto <D.23240>; else goto <D.23241>;
      <D.23240>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23242>; else goto <D.23243>;
      <D.23242>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23244 = monoeg_g_strdup_printf ("ExportedType table row %d has null Implementation token", i);
        vinfo->info.message = D.23244;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23245 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23245;
      }
      <D.23243>:
      ctx->valid = 0;
      return;
      <D.23241>:
      D.23231 = data[4];
      D.23246 = get_coded_index_table (60, D.23231);
      if (D.23246 == 39) goto <D.23247>; else goto <D.23248>;
      <D.23247>:
      D.23221 = data[3];
      if (D.23221 != 0) goto <D.23249>; else goto <D.23250>;
      <D.23249>:
      D.23206 = ctx->report_error;
      if (D.23206 != 0) goto <D.23251>; else goto <D.23252>;
      <D.23251>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23253 = monoeg_g_strdup_printf ("ExportedType table row %d has denotes a nested type but has a non null TypeNamespace", i);
        vinfo->info.message = D.23253;
        vinfo->exception_type = 3;
        D.23210 = ctx->errors;
        D.23254 = monoeg_g_slist_prepend (D.23210, vinfo);
        ctx->errors = D.23254;
      }
      <D.23252>:
      ctx->valid = 0;
      return;
      <D.23250>:
      <D.23248>:
      i = i + 1;
      <D.19315>:
      D.23255 = table->rows;
      D.23256 = (int) D.23255;
      if (D.23256 > i) goto <D.19314>; else goto <D.19316>;
      <D.19316>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_manifest_resource_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23260;
  unsigned int D.23261;
  unsigned int D.23262;
  int D.23265;
  gchar * D.23268;
  struct GSList * D.23269;
  struct GSList * D.23270;
  unsigned int D.23271;
  gchar * D.23276;
  struct GSList * D.23277;
  unsigned int D.23278;
  int D.23279;
  gchar * D.23284;
  struct GSList * D.23285;
  unsigned int D.23286;
  int D.23287;
  gchar * D.23292;
  struct GSList * D.23293;
  unsigned int D.23298;
  gchar * D.23299;
  struct GSList * D.23300;
  _Bool D.23301;
  _Bool D.23302;
  _Bool D.23303;
  unsigned int D.23306;
  gchar * D.23311;
  struct GSList * D.23312;
  gchar * D.23319;
  struct GSList * D.23320;
  <unnamed-unsigned:24> D.23321;
  int D.23322;
  struct MonoCLIImageInfo * iinfo;
  struct MonoCLIHeader * ch;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 impl_table;
  guint32 token;
  guint32 resources_size;
  int i;

  try
    {
      D.23260 = ctx->image;
      iinfo = D.23260->image_info;
      ch = &iinfo->cli_cli_header;
      D.23260 = ctx->image;
      table = &D.23260->tables[40];
      resources_size = ch->ch_resources.size;
      i = 0;
      goto <D.19336>;
      <D.19335>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.23261 = data[1];
      D.23262 = D.23261 & 4294967288;
      if (D.23262 != 0) goto <D.23263>; else goto <D.23264>;
      <D.23263>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23266>; else goto <D.23267>;
      <D.23266>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23261 = data[1];
        D.23268 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags %08x", i, D.23261);
        vinfo->info.message = D.23268;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23270 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23270;
      }
      <D.23267>:
      ctx->valid = 0;
      return;
      <D.23264>:
      D.23261 = data[1];
      D.23271 = D.23261 + 4294967295;
      if (D.23271 > 1) goto <D.23272>; else goto <D.23273>;
      <D.23272>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23274>; else goto <D.23275>;
      <D.23274>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23261 = data[1];
        D.23276 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags VisibilityMask %08x", i, D.23261);
        vinfo->info.message = D.23276;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23277 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23277;
      }
      <D.23275>:
      ctx->valid = 0;
      return;
      <D.23273>:
      D.23278 = data[2];
      D.23279 = is_valid_non_empty_string (ctx, D.23278);
      if (D.23279 == 0) goto <D.23280>; else goto <D.23281>;
      <D.23280>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23282>; else goto <D.23283>;
      <D.23282>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23278 = data[2];
        D.23284 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Name %08x", i, D.23278);
        vinfo->info.message = D.23284;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23285 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23285;
      }
      <D.23283>:
      ctx->valid = 0;
      return;
      <D.23281>:
      D.23286 = data[3];
      D.23287 = is_valid_coded_index (ctx, 60, D.23286);
      if (D.23287 == 0) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23290>; else goto <D.23291>;
      <D.23290>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23286 = data[3];
        D.23292 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token %08x", i, D.23286);
        vinfo->info.message = D.23292;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23293 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23293;
      }
      <D.23291>:
      ctx->valid = 0;
      return;
      <D.23289>:
      D.23286 = data[3];
      impl_table = get_coded_index_table (60, D.23286);
      D.23286 = data[3];
      token = get_coded_index_token (60, D.23286);
      if (impl_table == 39) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23296>; else goto <D.23297>;
      <D.23296>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23286 = data[3];
        D.23298 = get_coded_index_table (60, D.23286);
        D.23299 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token table %08x", i, D.23298);
        vinfo->info.message = D.23299;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23300 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23300;
      }
      <D.23297>:
      ctx->valid = 0;
      return;
      <D.23295>:
      D.23301 = impl_table == 38;
      D.23302 = token != 0;
      D.23303 = D.23301 & D.23302;
      if (D.23303 != 0) goto <D.23304>; else goto <D.23305>;
      <D.23304>:
      D.23306 = data[0];
      if (D.23306 != 0) goto <D.23307>; else goto <D.23308>;
      <D.23307>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23309>; else goto <D.23310>;
      <D.23309>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23311 = monoeg_g_strdup_printf ("ManifestResource table row %d points to a file but has non-zero offset", i);
        vinfo->info.message = D.23311;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23312 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23312;
      }
      <D.23310>:
      ctx->valid = 0;
      return;
      <D.23308>:
      <D.23305>:
      if (token == 0) goto <D.23313>; else goto <D.23314>;
      <D.23313>:
      D.23306 = data[0];
      if (D.23306 >= resources_size) goto <D.23315>; else goto <D.23316>;
      <D.23315>:
      D.23265 = ctx->report_error;
      if (D.23265 != 0) goto <D.23317>; else goto <D.23318>;
      <D.23317>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23306 = data[0];
        D.23319 = monoeg_g_strdup_printf ("ManifestResource table row %d invalid Offset field %08x ", i, D.23306);
        vinfo->info.message = D.23319;
        vinfo->exception_type = 3;
        D.23269 = ctx->errors;
        D.23320 = monoeg_g_slist_prepend (D.23269, vinfo);
        ctx->errors = D.23320;
      }
      <D.23318>:
      ctx->valid = 0;
      return;
      <D.23316>:
      <D.23314>:
      i = i + 1;
      <D.19336>:
      D.23321 = table->rows;
      D.23322 = (int) D.23321;
      if (D.23322 > i) goto <D.19335>; else goto <D.19337>;
      <D.19337>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_nested_class_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23326;
  unsigned int D.23329;
  <unnamed-unsigned:24> D.23331;
  unsigned int D.23332;
  int D.23333;
  gchar * D.23336;
  struct GSList * D.23337;
  struct GSList * D.23338;
  unsigned int D.23341;
  gchar * D.23345;
  struct GSList * D.23346;
  gchar * D.23351;
  struct GSList * D.23352;
  <unnamed-unsigned:24> D.23353;
  int D.23354;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23326 = ctx->image;
      table = &D.23326->tables[41];
      i = 0;
      goto <D.19348>;
      <D.19347>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23329 = data[0];
      if (D.23329 == 0) goto <D.23327>; else goto <D.23330>;
      <D.23330>:
      D.23329 = data[0];
      D.23326 = ctx->image;
      D.23331 = D.23326->tables[2].rows;
      D.23332 = (unsigned int) D.23331;
      if (D.23329 > D.23332) goto <D.23327>; else goto <D.23328>;
      <D.23327>:
      D.23333 = ctx->report_error;
      if (D.23333 != 0) goto <D.23334>; else goto <D.23335>;
      <D.23334>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23329 = data[0];
        D.23336 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid NestedClass token %08x", i, D.23329);
        vinfo->info.message = D.23336;
        vinfo->exception_type = 3;
        D.23337 = ctx->errors;
        D.23338 = monoeg_g_slist_prepend (D.23337, vinfo);
        ctx->errors = D.23338;
      }
      <D.23335>:
      ctx->valid = 0;
      return;
      <D.23328>:
      D.23341 = data[1];
      if (D.23341 == 0) goto <D.23339>; else goto <D.23342>;
      <D.23342>:
      D.23341 = data[1];
      D.23326 = ctx->image;
      D.23331 = D.23326->tables[2].rows;
      D.23332 = (unsigned int) D.23331;
      if (D.23341 > D.23332) goto <D.23339>; else goto <D.23340>;
      <D.23339>:
      D.23333 = ctx->report_error;
      if (D.23333 != 0) goto <D.23343>; else goto <D.23344>;
      <D.23343>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23341 = data[1];
        D.23345 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid EnclosingClass token %08x", i, D.23341);
        vinfo->info.message = D.23345;
        vinfo->exception_type = 3;
        D.23337 = ctx->errors;
        D.23346 = monoeg_g_slist_prepend (D.23337, vinfo);
        ctx->errors = D.23346;
      }
      <D.23344>:
      ctx->valid = 0;
      return;
      <D.23340>:
      D.23341 = data[1];
      D.23329 = data[0];
      if (D.23341 == D.23329) goto <D.23347>; else goto <D.23348>;
      <D.23347>:
      D.23333 = ctx->report_error;
      if (D.23333 != 0) goto <D.23349>; else goto <D.23350>;
      <D.23349>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23341 = data[1];
        D.23351 = monoeg_g_strdup_printf ("NestedClass table row %d has same token for NestedClass  and EnclosingClass %08x", i, D.23341);
        vinfo->info.message = D.23351;
        vinfo->exception_type = 3;
        D.23337 = ctx->errors;
        D.23352 = monoeg_g_slist_prepend (D.23337, vinfo);
        ctx->errors = D.23352;
      }
      <D.23350>:
      ctx->valid = 0;
      return;
      <D.23348>:
      i = i + 1;
      <D.19348>:
      D.23353 = table->rows;
      D.23354 = (int) D.23353;
      if (D.23354 > i) goto <D.19347>; else goto <D.19349>;
      <D.19349>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23358;
  unsigned int D.23359;
  unsigned int D.23360;
  int D.23363;
  gchar * D.23366;
  struct GSList * D.23367;
  struct GSList * D.23368;
  unsigned int D.23369;
  gchar * D.23374;
  struct GSList * D.23375;
  unsigned int D.23376;
  int D.23377;
  gchar * D.23382;
  struct GSList * D.23383;
  int D.23384;
  gchar * D.23389;
  struct GSList * D.23390;
  unsigned int D.23391;
  gchar * D.23396;
  struct GSList * D.23397;
  unsigned int D.23400;
  unsigned int param_number.95;
  gchar * D.23406;
  struct GSList * D.23407;
  <unnamed-unsigned:24> D.23408;
  int D.23409;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 token;
  guint32 last_token;
  int i;
  int param_number;

  try
    {
      D.23358 = ctx->image;
      table = &D.23358->tables[42];
      last_token = 0;
      param_number = 0;
      i = 0;
      goto <D.19366>;
      <D.19365>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.23359 = data[1];
      D.23360 = D.23359 & 4294967264;
      if (D.23360 != 0) goto <D.23361>; else goto <D.23362>;
      <D.23361>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23364>; else goto <D.23365>;
      <D.23364>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23359 = data[1];
        D.23366 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Flags token %08x", i, D.23359);
        vinfo->info.message = D.23366;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23368 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23368;
      }
      <D.23365>:
      ctx->valid = 0;
      return;
      <D.23362>:
      D.23359 = data[1];
      D.23369 = D.23359 & 3;
      if (D.23369 == 3) goto <D.23370>; else goto <D.23371>;
      <D.23370>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23372>; else goto <D.23373>;
      <D.23372>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23374 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid VarianceMask 0x3", i);
        vinfo->info.message = D.23374;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23375 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23375;
      }
      <D.23373>:
      ctx->valid = 0;
      return;
      <D.23371>:
      D.23376 = data[3];
      D.23377 = is_valid_non_empty_string (ctx, D.23376);
      if (D.23377 == 0) goto <D.23378>; else goto <D.23379>;
      <D.23378>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23380>; else goto <D.23381>;
      <D.23380>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23376 = data[3];
        D.23382 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Name token %08x", i, D.23376);
        vinfo->info.message = D.23382;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23383 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23383;
      }
      <D.23381>:
      ctx->valid = 0;
      return;
      <D.23379>:
      token = data[2];
      D.23384 = is_valid_coded_index (ctx, 78, token);
      if (D.23384 == 0) goto <D.23385>; else goto <D.23386>;
      <D.23385>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23387>; else goto <D.23388>;
      <D.23387>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23389 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Owner token %08x", i, token);
        vinfo->info.message = D.23389;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23390 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23390;
      }
      <D.23388>:
      ctx->valid = 0;
      return;
      <D.23386>:
      D.23391 = get_coded_index_token (78, token);
      if (D.23391 == 0) goto <D.23392>; else goto <D.23393>;
      <D.23392>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23394>; else goto <D.23395>;
      <D.23394>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23396 = monoeg_g_strdup_printf ("GenericParam table row %d has null Owner token", i);
        vinfo->info.message = D.23396;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23397 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23397;
      }
      <D.23395>:
      ctx->valid = 0;
      return;
      <D.23393>:
      if (token != last_token) goto <D.23398>; else goto <D.23399>;
      <D.23398>:
      param_number = 0;
      last_token = token;
      <D.23399>:
      D.23400 = data[0];
      param_number.95 = (unsigned int) param_number;
      if (D.23400 != param_number.95) goto <D.23402>; else goto <D.23403>;
      <D.23402>:
      D.23363 = ctx->report_error;
      if (D.23363 != 0) goto <D.23404>; else goto <D.23405>;
      <D.23404>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23400 = data[0];
        D.23406 = monoeg_g_strdup_printf ("GenericParam table row %d Number is out of order %d expected %d", i, D.23400, param_number);
        vinfo->info.message = D.23406;
        vinfo->exception_type = 3;
        D.23367 = ctx->errors;
        D.23407 = monoeg_g_slist_prepend (D.23367, vinfo);
        ctx->errors = D.23407;
      }
      <D.23405>:
      ctx->valid = 0;
      return;
      <D.23403>:
      param_number = param_number + 1;
      i = i + 1;
      <D.19366>:
      D.23408 = table->rows;
      D.23409 = (int) D.23408;
      if (D.23409 > i) goto <D.19365>; else goto <D.19367>;
      <D.19367>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_method_spec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23413;
  unsigned int D.23414;
  int D.23415;
  int D.23418;
  gchar * D.23421;
  struct GSList * D.23422;
  struct GSList * D.23423;
  unsigned int D.23424;
  gchar * D.23429;
  struct GSList * D.23430;
  unsigned int D.23431;
  int D.23434;
  gchar * D.23439;
  struct GSList * D.23440;
  <unnamed-unsigned:24> D.23441;
  int D.23442;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23413 = ctx->image;
      table = &D.23413->tables[43];
      i = 0;
      goto <D.19378>;
      <D.19377>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23414 = data[0];
      D.23415 = is_valid_coded_index (ctx, 52, D.23414);
      if (D.23415 == 0) goto <D.23416>; else goto <D.23417>;
      <D.23416>:
      D.23418 = ctx->report_error;
      if (D.23418 != 0) goto <D.23419>; else goto <D.23420>;
      <D.23419>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23414 = data[0];
        D.23421 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Method token %08x", i, D.23414);
        vinfo->info.message = D.23421;
        vinfo->exception_type = 3;
        D.23422 = ctx->errors;
        D.23423 = monoeg_g_slist_prepend (D.23422, vinfo);
        ctx->errors = D.23423;
      }
      <D.23420>:
      ctx->valid = 0;
      return;
      <D.23417>:
      D.23414 = data[0];
      D.23424 = get_coded_index_token (52, D.23414);
      if (D.23424 == 0) goto <D.23425>; else goto <D.23426>;
      <D.23425>:
      D.23418 = ctx->report_error;
      if (D.23418 != 0) goto <D.23427>; else goto <D.23428>;
      <D.23427>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23429 = monoeg_g_strdup_printf ("MethodSpec table row %d has null Method token", i);
        vinfo->info.message = D.23429;
        vinfo->exception_type = 3;
        D.23422 = ctx->errors;
        D.23430 = monoeg_g_slist_prepend (D.23422, vinfo);
        ctx->errors = D.23430;
      }
      <D.23428>:
      ctx->valid = 0;
      return;
      <D.23426>:
      D.23431 = data[1];
      if (D.23431 != 0) goto <D.23432>; else goto <D.23433>;
      <D.23432>:
      D.23431 = data[1];
      D.23434 = is_valid_blob_object (ctx, D.23431, 1);
      if (D.23434 == 0) goto <D.23435>; else goto <D.23436>;
      <D.23435>:
      D.23418 = ctx->report_error;
      if (D.23418 != 0) goto <D.23437>; else goto <D.23438>;
      <D.23437>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23431 = data[1];
        D.23439 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, D.23431);
        vinfo->info.message = D.23439;
        vinfo->exception_type = 3;
        D.23422 = ctx->errors;
        D.23440 = monoeg_g_slist_prepend (D.23422, vinfo);
        ctx->errors = D.23440;
      }
      <D.23438>:
      ctx->valid = 0;
      return;
      <D.23436>:
      <D.23433>:
      i = i + 1;
      <D.19378>:
      D.23441 = table->rows;
      D.23442 = (int) D.23441;
      if (D.23442 > i) goto <D.19377>; else goto <D.19379>;
      <D.19379>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_constraint_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23446;
  unsigned int D.23449;
  <unnamed-unsigned:24> D.23451;
  unsigned int D.23452;
  int D.23453;
  gchar * D.23456;
  struct GSList * D.23457;
  struct GSList * D.23458;
  unsigned int D.23459;
  int D.23460;
  gchar * D.23465;
  struct GSList * D.23466;
  unsigned int D.23467;
  gchar * D.23472;
  struct GSList * D.23473;
  gchar * D.23478;
  struct GSList * D.23479;
  gchar * D.23486;
  struct GSList * D.23487;
  <unnamed-unsigned:24> D.23489;
  int D.23490;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;
  guint32 last_owner;
  guint32 last_constraint;

  try
    {
      D.23446 = ctx->image;
      table = &D.23446->tables[44];
      last_owner = 0;
      last_constraint = 0;
      i = 0;
      goto <D.19404>;
      <D.19403>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23449 = data[0];
      if (D.23449 == 0) goto <D.23447>; else goto <D.23450>;
      <D.23450>:
      D.23449 = data[0];
      D.23446 = ctx->image;
      D.23451 = D.23446->tables[42].rows;
      D.23452 = (unsigned int) D.23451;
      if (D.23449 > D.23452) goto <D.23447>; else goto <D.23448>;
      <D.23447>:
      D.23453 = ctx->report_error;
      if (D.23453 != 0) goto <D.23454>; else goto <D.23455>;
      <D.23454>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23449 = data[0];
        D.23456 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Owner token %08x", i, D.23449);
        vinfo->info.message = D.23456;
        vinfo->exception_type = 3;
        D.23457 = ctx->errors;
        D.23458 = monoeg_g_slist_prepend (D.23457, vinfo);
        ctx->errors = D.23458;
      }
      <D.23455>:
      ctx->valid = 0;
      return;
      <D.23448>:
      D.23459 = data[1];
      D.23460 = is_valid_coded_index (ctx, 0, D.23459);
      if (D.23460 == 0) goto <D.23461>; else goto <D.23462>;
      <D.23461>:
      D.23453 = ctx->report_error;
      if (D.23453 != 0) goto <D.23463>; else goto <D.23464>;
      <D.23463>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23459 = data[1];
        D.23465 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Constraint token %08x", i, D.23459);
        vinfo->info.message = D.23465;
        vinfo->exception_type = 3;
        D.23457 = ctx->errors;
        D.23466 = monoeg_g_slist_prepend (D.23457, vinfo);
        ctx->errors = D.23466;
      }
      <D.23464>:
      ctx->valid = 0;
      return;
      <D.23462>:
      D.23459 = data[1];
      D.23467 = get_coded_index_token (0, D.23459);
      if (D.23467 == 0) goto <D.23468>; else goto <D.23469>;
      <D.23468>:
      D.23453 = ctx->report_error;
      if (D.23453 != 0) goto <D.23470>; else goto <D.23471>;
      <D.23470>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23472 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has null Constraint token", i);
        vinfo->info.message = D.23472;
        vinfo->exception_type = 3;
        D.23457 = ctx->errors;
        D.23473 = monoeg_g_slist_prepend (D.23457, vinfo);
        ctx->errors = D.23473;
      }
      <D.23471>:
      ctx->valid = 0;
      return;
      <D.23469>:
      D.23449 = data[0];
      if (D.23449 < last_owner) goto <D.23474>; else goto <D.23475>;
      <D.23474>:
      D.23453 = ctx->report_error;
      if (D.23453 != 0) goto <D.23476>; else goto <D.23477>;
      <D.23476>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23449 = data[0];
        D.23478 = 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.23449);
        vinfo->info.message = D.23478;
        vinfo->exception_type = 3;
        D.23457 = ctx->errors;
        D.23479 = monoeg_g_slist_prepend (D.23457, vinfo);
        ctx->errors = D.23479;
      }
      <D.23477>:
      ctx->valid = 0;
      return;
      <D.23475>:
      D.23449 = data[0];
      if (D.23449 == last_owner) goto <D.23480>; else goto <D.23481>;
      <D.23480>:
      D.23459 = data[1];
      if (D.23459 == last_constraint) goto <D.23482>; else goto <D.23483>;
      <D.23482>:
      D.23453 = ctx->report_error;
      if (D.23453 != 0) goto <D.23484>; else goto <D.23485>;
      <D.23484>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23486 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has duplicate constraint 0x%08x", i, last_constraint);
        vinfo->info.message = D.23486;
        vinfo->exception_type = 3;
        D.23457 = ctx->errors;
        D.23487 = monoeg_g_slist_prepend (D.23457, vinfo);
        ctx->errors = D.23487;
      }
      <D.23485>:
      ctx->valid = 0;
      return;
      <D.23483>:
      goto <D.23488>;
      <D.23481>:
      last_owner = data[0];
      <D.23488>:
      last_constraint = data[1];
      i = i + 1;
      <D.19404>:
      D.23489 = table->rows;
      D.23490 = (int) D.23489;
      if (D.23490 > i) goto <D.19403>; else goto <D.19405>;
      <D.19405>:
    }
  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.23494;
  unsigned int D.23495;
  const char * D.23496;
  unsigned int D.23497;
  const char * D.23498;
  unsigned int D.23499;
  unsigned int D.23500;
  int D.23503;
  unsigned int D.23504;
  _Bool D.23505;
  long int D.23506;
  long int D.23507;
  unsigned int D.23510;
  void * D.23511;
  int D.23514;
  unsigned int D.23517;
  const char * D.23518;
  const char * D.23519;
  gchar * D.23520;
  struct GSList * D.23521;
  struct GSList * D.23522;
  <unnamed-unsigned:24> D.23523;
  int D.23524;
  int i;
  guint32 data[6];
  guint32 nested_data[2];
  struct MonoTableInfo * table;
  struct MonoTableInfo * nested_table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (24);
        mono_metadata_decode_row (table, i, &data, 6);
        D.23495 = data[1];
        D.23494 = ctx->image;
        D.23496 = mono_metadata_string_heap (D.23494, D.23495);
        type->name = D.23496;
        D.23497 = data[2];
        D.23494 = ctx->image;
        D.23498 = mono_metadata_string_heap (D.23494, D.23497);
        type->name_space = D.23498;
        type->resolution_scope = 0;
        D.23499 = data[0];
        visibility = D.23499 & 7;
        D.23500 = visibility + 4294967294;
        if (D.23500 <= 5) goto <D.23501>; else goto <D.23502>;
        <D.23501>:
        {
          int res;

          D.23503 = i + 1;
          D.23504 = (unsigned int) D.23503;
          res = search_sorted_table (ctx, 41, 0, D.23504);
          D.23505 = res < 0;
          D.23506 = (long int) D.23505;
          D.23507 = __builtin_expect (D.23506, 0);
          if (D.23507 != 0) goto <D.23508>; else goto <D.23509>;
          <D.23508>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 3700, "res >= 0");
          <D.23509>:
          mono_metadata_decode_row (nested_table, res, &nested_data, 2);
          D.23510 = nested_data[1];
          type->resolution_scope = D.23510;
        }
        <D.23502>:
        D.23511 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.23511 != 0B) goto <D.23512>; else goto <D.23513>;
        <D.23512>:
        D.23514 = ctx->report_error;
        if (D.23514 != 0) goto <D.23515>; else goto <D.23516>;
        <D.23515>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.23517 = type->resolution_scope;
          D.23518 = type->name_space;
          D.23519 = type->name;
          D.23520 = monoeg_g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, D.23519, D.23518, D.23517);
          vinfo->info.message = D.23520;
          vinfo->exception_type = 3;
          D.23521 = ctx->errors;
          D.23522 = monoeg_g_slist_prepend (D.23521, vinfo);
          ctx->errors = D.23522;
        }
        <D.23516>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.23513>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19453>:
      D.23523 = table->rows;
      D.23524 = (int) D.23523;
      if (D.23524 > i) goto <D.19452>; else goto <D.19454>;
      <D.19454>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
      nested_data = {CLOBBER};
    }
}


typedef_equals (const void * _a, const void * _b)
{
  gboolean D.23528;
  int iftmp.96;
  int D.19429;
  const char * D.23532;
  const char * D.23533;
  int D.19438;
  const char * D.23535;
  const char * D.23536;
  unsigned int D.23538;
  unsigned int D.23539;
  const struct TypeDefUniqueId * a;
  const struct TypeDefUniqueId * b;

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

    D.23532 = b->name;
    D.23533 = a->name;
    D.19429 = __builtin_strcmp (D.23533, D.23532);
  }
  if (D.19429 == 0) goto <D.23534>; else goto <D.23530>;
  <D.23534>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23535 = b->name_space;
    D.23536 = a->name_space;
    D.19438 = __builtin_strcmp (D.23536, D.23535);
  }
  if (D.19438 == 0) goto <D.23537>; else goto <D.23530>;
  <D.23537>:
  D.23538 = a->resolution_scope;
  D.23539 = b->resolution_scope;
  if (D.23538 == D.23539) goto <D.23540>; else goto <D.23530>;
  <D.23540>:
  iftmp.96 = 1;
  goto <D.23531>;
  <D.23530>:
  iftmp.96 = 0;
  <D.23531>:
  D.23528 = iftmp.96;
  return D.23528;
}


typedef_hash (const void * _key)
{
  guint D.23542;
  const char * D.23543;
  unsigned int D.23544;
  const char * D.23545;
  unsigned int D.23546;
  unsigned int D.23547;
  unsigned int D.23548;
  const struct TypeDefUniqueId * key;

  key = _key;
  D.23543 = key->name;
  D.23544 = monoeg_g_str_hash (D.23543);
  D.23545 = key->name_space;
  D.23546 = monoeg_g_str_hash (D.23545);
  D.23547 = D.23544 ^ D.23546;
  D.23548 = key->resolution_scope;
  D.23542 = D.23547 ^ D.23548;
  return D.23542;
}


mono_verifier_verify_full_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.23550;
  gboolean D.23553;
  _Bool D.23554;
  int D.23555;
  int D.23556;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.23550 = mono_verifier_is_enabled_for_image (image);
      if (D.23550 == 0) goto <D.23551>; else goto <D.23552>;
      <D.23551>:
      D.23553 = 1;
      return D.23553;
      <D.23552>:
      D.23554 = error_list != 0B;
      D.23555 = (int) D.23554;
      init_verify_context (&ctx, image, D.23555);
      ctx.stage = 2;
      verify_typedef_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23557>;
      <D.23557>:
      verify_field_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23558>;
      <D.23558>:
      verify_method_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23559>;
      <D.23559>:
      verify_memberref_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23560>;
      <D.23560>:
      verify_cattr_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23561>;
      <D.23561>:
      verify_field_marshal_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23562>;
      <D.23562>:
      verify_decl_security_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23563>;
      <D.23563>:
      verify_standalonesig_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23564>;
      <D.23564>:
      verify_event_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23565>;
      <D.23565>:
      verify_typespec_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23566>;
      <D.23566>:
      verify_method_spec_table_full (&ctx);
      D.23556 = ctx.valid;
      if (D.23556 == 0) goto cleanup; else goto <D.23567>;
      <D.23567>:
      verify_tables_data_global_constraints_full (&ctx);
      cleanup:
      D.23553 = cleanup_context (&ctx, error_list);
      return D.23553;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_typedef_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23570;
  unsigned int D.23571;
  unsigned int D.23572;
  int D.23575;
  gchar * D.23578;
  struct GSList * D.23579;
  struct GSList * D.23580;
  unsigned int D.23583;
  unsigned int D.23584;
  unsigned int D.23587;
  gchar * D.23592;
  struct GSList * D.23593;
  unsigned int D.23595;
  _Bool D.23596;
  gchar * D.23603;
  struct GSList * D.23604;
  gchar * D.23610;
  struct GSList * D.23611;
  <unnamed-unsigned:24> D.23612;
  int D.23613;
  struct MonoTableInfo * table;
  guint32 data[6];
  int i;

  try
    {
      D.23570 = ctx->image;
      table = &D.23570->tables[2];
      D.23571 = BIT_FIELD_REF <*table, 32, 64>;
      D.23572 = D.23571 & 16777215;
      if (D.23572 == 0) goto <D.23573>; else goto <D.23574>;
      <D.23573>:
      D.23575 = ctx->report_error;
      if (D.23575 != 0) goto <D.23576>; else goto <D.23577>;
      <D.23576>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23578 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.23578;
        vinfo->exception_type = 3;
        D.23579 = ctx->errors;
        D.23580 = monoeg_g_slist_prepend (D.23579, vinfo);
        ctx->errors = D.23580;
      }
      <D.23577>:
      ctx->valid = 0;
      return;
      <D.23574>:
      i = 0;
      goto <D.18787>;
      <D.18786>:
      mono_metadata_decode_row (table, i, &data, 6);
      if (i == 0) goto <D.23581>; else goto <D.23582>;
      <D.23581>:
      // predicted unlikely by continue predictor.
      goto <D.18780>;
      <D.23582>:
      D.23583 = data[0];
      D.23584 = D.23583 & 32;
      if (D.23584 != 0) goto <D.23585>; else goto <D.23586>;
      <D.23585>:
      D.23587 = data[3];
      if (D.23587 != 0) goto <D.23588>; else goto <D.23589>;
      <D.23588>:
      D.23575 = ctx->report_error;
      if (D.23575 != 0) goto <D.23590>; else goto <D.23591>;
      <D.23590>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23592 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i);
        vinfo->info.message = D.23592;
        vinfo->exception_type = 3;
        D.23579 = ctx->errors;
        D.23593 = monoeg_g_slist_prepend (D.23579, vinfo);
        ctx->errors = D.23593;
      }
      <D.23591>:
      ctx->valid = 0;
      return;
      <D.23589>:
      goto <D.23594>;
      <D.23586>:
      {
        gboolean is_sys_obj;
        gboolean has_parent;

        is_sys_obj = typedef_is_system_object (ctx, &data);
        D.23587 = data[3];
        D.23595 = get_coded_index_token (0, D.23587);
        D.23596 = D.23595 != 0;
        has_parent = (gboolean) D.23596;
        if (is_sys_obj != 0) goto <D.23597>; else goto <D.23598>;
        <D.23597>:
        if (has_parent != 0) goto <D.23599>; else goto <D.23600>;
        <D.23599>:
        D.23575 = ctx->report_error;
        if (D.23575 != 0) goto <D.23601>; else goto <D.23602>;
        <D.23601>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.23603 = monoeg_g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i);
          vinfo->info.message = D.23603;
          vinfo->exception_type = 3;
          D.23579 = ctx->errors;
          D.23604 = monoeg_g_slist_prepend (D.23579, vinfo);
          ctx->errors = D.23604;
        }
        <D.23602>:
        ctx->valid = 0;
        return;
        <D.23600>:
        goto <D.23605>;
        <D.23598>:
        if (has_parent == 0) goto <D.23606>; else goto <D.23607>;
        <D.23606>:
        D.23575 = ctx->report_error;
        if (D.23575 != 0) goto <D.23608>; else goto <D.23609>;
        <D.23608>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.23610 = monoeg_g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i);
          vinfo->info.message = D.23610;
          vinfo->exception_type = 3;
          D.23579 = ctx->errors;
          D.23611 = monoeg_g_slist_prepend (D.23579, vinfo);
          ctx->errors = D.23611;
        }
        <D.23609>:
        ctx->valid = 0;
        return;
        <D.23607>:
        <D.23605>:
      }
      <D.23594>:
      <D.18780>:
      i = i + 1;
      <D.18787>:
      D.23612 = table->rows;
      D.23613 = (int) D.23612;
      if (D.23613 > i) goto <D.18786>; else goto <D.18788>;
      <D.18788>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


typedef_is_system_object (struct VerifyContext * ctx, guint32 * data)
{
  gboolean D.23617;
  int iftmp.97;
  struct MonoImage * D.23621;
  int D.23622;
  guint32 * D.23624;
  unsigned int D.23625;
  int D.23626;
  guint32 * D.23628;
  unsigned int D.23629;
  int D.23630;

  D.23621 = ctx->image;
  D.23622 = mono_verifier_is_corlib (D.23621);
  if (D.23622 != 0) goto <D.23623>; else goto <D.23619>;
  <D.23623>:
  D.23624 = data + 8;
  D.23625 = *D.23624;
  D.23626 = string_cmp (ctx, "System", D.23625);
  if (D.23626 == 0) goto <D.23627>; else goto <D.23619>;
  <D.23627>:
  D.23628 = data + 4;
  D.23629 = *D.23628;
  D.23630 = string_cmp (ctx, "Object", D.23629);
  if (D.23630 == 0) goto <D.23631>; else goto <D.23619>;
  <D.23631>:
  iftmp.97 = 1;
  goto <D.23620>;
  <D.23619>:
  iftmp.97 = 0;
  <D.23620>:
  D.23617 = iftmp.97;
  return D.23617;
}


mono_verifier_is_corlib (struct MonoImage * image)
{
  int iftmp.98;
  <unnamed type> D.23634;
  gboolean D.23638;
  int iftmp.99;
  const char * D.23643;
  int D.18165;
  int iftmp.100;
  int D.18161;
  const char[13] * D.23648;
  unsigned char D.23649;
  int D.23650;
  unsigned char D.23651;
  int D.23652;
  _Bool D.23653;
  _Bool D.23654;
  _Bool D.23655;
  const unsigned char * D.23658;
  unsigned char D.23659;
  int D.23660;
  const unsigned char * D.23661;
  unsigned char D.23662;
  int D.23663;
  _Bool D.23664;
  _Bool D.23665;
  const unsigned char * D.23668;
  unsigned char D.23669;
  int D.23670;
  const unsigned char * D.23671;
  unsigned char D.23672;
  int D.23673;
  _Bool D.23674;
  _Bool D.23675;
  const unsigned char * D.23678;
  unsigned char D.23679;
  int D.23680;
  const unsigned char * D.23681;
  unsigned char D.23682;
  int D.23683;
  gboolean trusted_location;

  D.23634 = mono_security_get_mode ();
  if (D.23634 == 1) goto <D.23635>; else goto <D.23636>;
  <D.23635>:
  iftmp.98 = mono_security_core_clr_is_platform_image (image);
  goto <D.23637>;
  <D.23636>:
  iftmp.98 = 1;
  <D.23637>:
  trusted_location = iftmp.98;
  if (trusted_location != 0) goto <D.23642>; else goto <D.23640>;
  <D.23642>:
  D.23643 = image->module_name;
  if (D.23643 != 0B) goto <D.23644>; else goto <D.23640>;
  <D.23644>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = image->module_name;
      D.23648 = "mscorlib.dll";
      D.23649 = MEM[(const unsigned char *)D.23648];
      D.23650 = (int) D.23649;
      D.23651 = *__s2;
      D.23652 = (int) D.23651;
      __result = D.23650 - D.23652;
      {
        D.23653 = __s1_len != 0;
        D.23654 = __result == 0;
        D.23655 = D.23653 & D.23654;
        if (D.23655 != 0) goto <D.23656>; else goto <D.23657>;
        <D.23656>:
        D.23658 = &MEM[(void *)"mscorlib.dll" + 1B];
        D.23659 = *D.23658;
        D.23660 = (int) D.23659;
        D.23661 = __s2 + 1;
        D.23662 = *D.23661;
        D.23663 = (int) D.23662;
        __result = D.23660 - D.23663;
        D.23664 = __s1_len > 1;
        D.23654 = __result == 0;
        D.23665 = D.23664 & D.23654;
        if (D.23665 != 0) goto <D.23666>; else goto <D.23667>;
        <D.23666>:
        D.23668 = &MEM[(void *)"mscorlib.dll" + 2B];
        D.23669 = *D.23668;
        D.23670 = (int) D.23669;
        D.23671 = __s2 + 2;
        D.23672 = *D.23671;
        D.23673 = (int) D.23672;
        __result = D.23670 - D.23673;
        D.23674 = __s1_len > 2;
        D.23654 = __result == 0;
        D.23675 = D.23674 & D.23654;
        if (D.23675 != 0) goto <D.23676>; else goto <D.23677>;
        <D.23676>:
        D.23678 = &MEM[(void *)"mscorlib.dll" + 3B];
        D.23679 = *D.23678;
        D.23680 = (int) D.23679;
        D.23681 = __s2 + 3;
        D.23682 = *D.23681;
        D.23683 = (int) D.23682;
        __result = D.23680 - D.23683;
        <D.23677>:
        <D.23667>:
        <D.23657>:
      }
      D.18161 = __result;
    }
    iftmp.100 = D.18161;
    goto <D.23684>;
    <D.23647>:
    D.23643 = image->module_name;
    iftmp.100 = __builtin_strcmp ("mscorlib.dll", D.23643);
    <D.23684>:
    D.18165 = iftmp.100;
  }
  if (D.18165 == 0) goto <D.23685>; else goto <D.23640>;
  <D.23685>:
  iftmp.99 = 1;
  goto <D.23641>;
  <D.23640>:
  iftmp.99 = 0;
  <D.23641>:
  D.23638 = iftmp.99;
  return D.23638;
}


string_cmp (struct VerifyContext * ctx, const char * str, guint offset)
{
  int D.23689;
  int D.18143;
  int iftmp.101;
  int D.18142;
  const char[1] * D.23693;
  unsigned char D.23694;
  int D.23695;
  unsigned char D.23696;
  int D.23697;
  _Bool D.23698;
  _Bool D.23699;
  _Bool D.23700;
  const unsigned char * D.23703;
  unsigned char D.23704;
  int D.23705;
  const unsigned char * D.23706;
  unsigned char D.23707;
  int D.23708;
  _Bool D.23709;
  _Bool D.23710;
  const unsigned char * D.23713;
  unsigned char D.23714;
  int D.23715;
  const unsigned char * D.23716;
  unsigned char D.23717;
  int D.23718;
  _Bool D.23719;
  _Bool D.23720;
  const unsigned char * D.23723;
  unsigned char D.23724;
  int D.23725;
  const unsigned char * D.23726;
  unsigned char D.23727;
  int D.23728;
  unsigned char D.23730;
  int D.18152;
  const char * D.23731;

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

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

      __s2 = str;
      D.23693 = "";
      D.23694 = MEM[(const unsigned char *)D.23693];
      D.23695 = (int) D.23694;
      D.23696 = *__s2;
      D.23697 = (int) D.23696;
      __result = D.23695 - D.23697;
      {
        D.23698 = __s2_len != 0;
        D.23699 = __result == 0;
        D.23700 = D.23698 & D.23699;
        if (D.23700 != 0) goto <D.23701>; else goto <D.23702>;
        <D.23701>:
        D.23703 = &MEM[(void *)"" + 1B];
        D.23704 = *D.23703;
        D.23705 = (int) D.23704;
        D.23706 = __s2 + 1;
        D.23707 = *D.23706;
        D.23708 = (int) D.23707;
        __result = D.23705 - D.23708;
        D.23709 = __s2_len > 1;
        D.23699 = __result == 0;
        D.23710 = D.23709 & D.23699;
        if (D.23710 != 0) goto <D.23711>; else goto <D.23712>;
        <D.23711>:
        D.23713 = &MEM[(void *)"" + 2B];
        D.23714 = *D.23713;
        D.23715 = (int) D.23714;
        D.23716 = __s2 + 2;
        D.23717 = *D.23716;
        D.23718 = (int) D.23717;
        __result = D.23715 - D.23718;
        D.23719 = __s2_len > 2;
        D.23699 = __result == 0;
        D.23720 = D.23719 & D.23699;
        if (D.23720 != 0) goto <D.23721>; else goto <D.23722>;
        <D.23721>:
        D.23723 = &MEM[(void *)"" + 3B];
        D.23724 = *D.23723;
        D.23725 = (int) D.23724;
        D.23726 = __s2 + 3;
        D.23727 = *D.23726;
        D.23728 = (int) D.23727;
        __result = D.23725 - D.23728;
        <D.23722>:
        <D.23712>:
        <D.23702>:
      }
      D.18142 = __result;
    }
    iftmp.101 = -D.18142;
    goto <D.23729>;
    <D.23692>:
    D.23730 = MEM[(const unsigned char * {ref-all})str];
    iftmp.101 = (int) D.23730;
    <D.23729>:
    D.18143 = iftmp.101;
  }
  D.23689 = D.18143;
  return D.23689;
  <D.23688>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23731 = get_string_ptr (ctx, offset);
    D.18152 = __builtin_strcmp (str, D.23731);
  }
  D.23689 = D.18152;
  return D.23689;
}


verify_field_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23733;
  unsigned int D.23736;
  int D.23738;
  int D.23739;
  gchar * D.23742;
  struct GSList * D.23743;
  struct GSList * D.23744;
  <unnamed-unsigned:24> D.23745;
  int D.23746;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23733 = ctx->image;
      table = &D.23733->tables[4];
      i = 0;
      goto <D.18823>;
      <D.18822>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23736 = data[2];
      if (D.23736 == 0) goto <D.23734>; else goto <D.23737>;
      <D.23737>:
      D.23736 = data[2];
      D.23738 = is_valid_field_signature (ctx, D.23736);
      if (D.23738 == 0) goto <D.23734>; else goto <D.23735>;
      <D.23734>:
      D.23739 = ctx->report_error;
      if (D.23739 != 0) goto <D.23740>; else goto <D.23741>;
      <D.23740>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23736 = data[2];
        D.23742 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, D.23736);
        vinfo->info.message = D.23742;
        vinfo->exception_type = 3;
        D.23743 = ctx->errors;
        D.23744 = monoeg_g_slist_prepend (D.23743, vinfo);
        ctx->errors = D.23744;
      }
      <D.23741>:
      ctx->valid = 0;
      return;
      <D.23735>:
      i = i + 1;
      <D.18823>:
      D.23745 = table->rows;
      D.23746 = (int) D.23745;
      if (D.23746 > i) goto <D.18822>; else goto <D.18824>;
      <D.18824>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23750;
  int D.23753;
  gchar * D.23756;
  struct GSList * D.23757;
  struct GSList * D.23758;
  gboolean D.23759;
  const char * ptr.102;
  unsigned int size.103;
  sizetype D.23762;
  int D.23763;
  gchar * D.23768;
  struct GSList * D.23769;
  unsigned int signature.104;
  gchar * D.23775;
  struct GSList * D.23776;
  const char * ptr.105;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.23750 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23750 == 0) goto <D.23751>; else goto <D.23752>;
      <D.23751>:
      D.23753 = ctx->report_error;
      if (D.23753 != 0) goto <D.23754>; else goto <D.23755>;
      <D.23754>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23756 = monoeg_strdup ("FieldSig: Could not decode signature header");
        vinfo->info.message = D.23756;
        vinfo->exception_type = 3;
        D.23757 = ctx->errors;
        D.23758 = monoeg_g_slist_prepend (D.23757, vinfo);
        ctx->errors = D.23758;
      }
      <D.23755>:
      ctx->valid = 0;
      D.23759 = 0;
      return D.23759;
      <D.23752>:
      ptr.102 = ptr;
      size.103 = size;
      D.23762 = (sizetype) size.103;
      end = ptr.102 + D.23762;
      D.23763 = safe_read (&ptr, end, &signature, 1);
      if (D.23763 == 0) goto <D.23764>; else goto <D.23765>;
      <D.23764>:
      D.23753 = ctx->report_error;
      if (D.23753 != 0) goto <D.23766>; else goto <D.23767>;
      <D.23766>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23768 = monoeg_strdup ("FieldSig: Not enough room for the signature");
        vinfo->info.message = D.23768;
        vinfo->exception_type = 3;
        D.23757 = ctx->errors;
        D.23769 = monoeg_g_slist_prepend (D.23757, vinfo);
        ctx->errors = D.23769;
      }
      <D.23767>:
      ctx->valid = 0;
      D.23759 = 0;
      return D.23759;
      <D.23765>:
      signature.104 = signature;
      if (signature.104 != 6) goto <D.23771>; else goto <D.23772>;
      <D.23771>:
      D.23753 = ctx->report_error;
      if (D.23753 != 0) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        signature.104 = signature;
        D.23775 = monoeg_g_strdup_printf ("FieldSig: Invalid signature %x", signature.104);
        vinfo->info.message = D.23775;
        vinfo->exception_type = 3;
        D.23757 = ctx->errors;
        D.23776 = monoeg_g_slist_prepend (D.23757, vinfo);
        ctx->errors = D.23776;
      }
      <D.23774>:
      ctx->valid = 0;
      D.23759 = 0;
      return D.23759;
      <D.23772>:
      ptr.102 = ptr;
      ptr.105 = ptr.102 + 18446744073709551615;
      ptr = ptr.105;
      D.23759 = parse_field (ctx, &ptr, end);
      return D.23759;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_field (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.106;
  int D.23781;
  int D.23784;
  gchar * D.23787;
  struct GSList * D.23788;
  struct GSList * D.23789;
  gboolean D.23790;
  unsigned int signature.107;
  gchar * D.23796;
  struct GSList * D.23797;
  int D.23798;
  int D.23801;
  const char * ptr.108;
  const char * ptr.109;
  const char * ptr;
  unsigned int signature;

  try
    {
      ptr.106 = *_ptr;
      ptr = ptr.106;
      signature = 0;
      D.23781 = safe_read (&ptr, end, &signature, 1);
      if (D.23781 == 0) goto <D.23782>; else goto <D.23783>;
      <D.23782>:
      D.23784 = ctx->report_error;
      if (D.23784 != 0) goto <D.23785>; else goto <D.23786>;
      <D.23785>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23787 = monoeg_strdup ("Field: Not enough room for field signature");
        vinfo->info.message = D.23787;
        vinfo->exception_type = 3;
        D.23788 = ctx->errors;
        D.23789 = monoeg_g_slist_prepend (D.23788, vinfo);
        ctx->errors = D.23789;
      }
      <D.23786>:
      ctx->valid = 0;
      D.23790 = 0;
      return D.23790;
      <D.23783>:
      signature.107 = signature;
      if (signature.107 != 6) goto <D.23792>; else goto <D.23793>;
      <D.23792>:
      D.23784 = ctx->report_error;
      if (D.23784 != 0) goto <D.23794>; else goto <D.23795>;
      <D.23794>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        signature.107 = signature;
        D.23796 = monoeg_g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature.107);
        vinfo->info.message = D.23796;
        vinfo->exception_type = 3;
        D.23788 = ctx->errors;
        D.23797 = monoeg_g_slist_prepend (D.23788, vinfo);
        ctx->errors = D.23797;
      }
      <D.23795>:
      ctx->valid = 0;
      D.23790 = 0;
      return D.23790;
      <D.23793>:
      D.23798 = parse_custom_mods (ctx, &ptr, end);
      if (D.23798 == 0) goto <D.23799>; else goto <D.23800>;
      <D.23799>:
      D.23790 = 0;
      return D.23790;
      <D.23800>:
      D.23801 = safe_read (&ptr, end, &signature, 1);
      if (D.23801 != 0) goto <D.23802>; else goto <D.23803>;
      <D.23802>:
      signature.107 = signature;
      if (signature.107 != 16) goto <D.23804>; else goto <D.23805>;
      <D.23804>:
      ptr.108 = ptr;
      ptr.109 = ptr.108 + 18446744073709551615;
      ptr = ptr.109;
      <D.23805>:
      <D.23803>:
      ptr.108 = ptr;
      *_ptr = ptr.108;
      D.23790 = parse_type (ctx, _ptr, end);
      return D.23790;
    }
  finally
    {
      ptr = {CLOBBER};
      signature = {CLOBBER};
    }
}


verify_method_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.23810;
  unsigned int D.23813;
  int D.23815;
  int D.23816;
  gchar * D.23819;
  struct GSList * D.23820;
  struct GSList * D.23821;
  int D.23824;
  gchar * D.23829;
  struct GSList * D.23830;
  <unnamed-unsigned:24> D.23831;
  int D.23832;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 rva;
  guint32 locals_token;
  int i;

  try
    {
      D.23810 = ctx->image;
      table = &D.23810->tables[6];
      i = 0;
      goto <D.18903>;
      <D.18902>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      D.23813 = data[4];
      if (D.23813 == 0) goto <D.23811>; else goto <D.23814>;
      <D.23814>:
      D.23813 = data[4];
      D.23815 = is_valid_method_signature (ctx, D.23813);
      if (D.23815 == 0) goto <D.23811>; else goto <D.23812>;
      <D.23811>:
      D.23816 = ctx->report_error;
      if (D.23816 != 0) goto <D.23817>; else goto <D.23818>;
      <D.23817>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23813 = data[4];
        D.23819 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, D.23813);
        vinfo->info.message = D.23819;
        vinfo->exception_type = 3;
        D.23820 = ctx->errors;
        D.23821 = monoeg_g_slist_prepend (D.23820, vinfo);
        ctx->errors = D.23821;
      }
      <D.23818>:
      ctx->valid = 0;
      return;
      <D.23812>:
      if (rva != 0) goto <D.23822>; else goto <D.23823>;
      <D.23822>:
      D.23824 = is_valid_method_header (ctx, rva, &locals_token);
      if (D.23824 == 0) goto <D.23825>; else goto <D.23826>;
      <D.23825>:
      D.23816 = ctx->report_error;
      if (D.23816 != 0) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23829 = monoeg_g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i);
        vinfo->info.message = D.23829;
        vinfo->exception_type = 3;
        D.23820 = ctx->errors;
        D.23830 = monoeg_g_slist_prepend (D.23820, vinfo);
        ctx->errors = D.23830;
      }
      <D.23828>:
      ctx->valid = 0;
      return;
      <D.23826>:
      <D.23823>:
      i = i + 1;
      <D.18903>:
      D.23831 = table->rows;
      D.23832 = (int) D.23831;
      if (D.23832 > i) goto <D.18902>; else goto <D.18904>;
      <D.18904>:
    }
  finally
    {
      data = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


is_valid_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.23836;
  int D.23839;
  gchar * D.23842;
  struct GSList * D.23843;
  struct GSList * D.23844;
  gboolean D.23845;
  const char * ptr.110;
  unsigned int size.111;
  sizetype D.23848;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.23836 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.23836 == 0) goto <D.23837>; else goto <D.23838>;
      <D.23837>:
      D.23839 = ctx->report_error;
      if (D.23839 != 0) goto <D.23840>; else goto <D.23841>;
      <D.23840>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23842 = monoeg_strdup ("MethodSig: Could not decode signature header");
        vinfo->info.message = D.23842;
        vinfo->exception_type = 3;
        D.23843 = ctx->errors;
        D.23844 = monoeg_g_slist_prepend (D.23843, vinfo);
        ctx->errors = D.23844;
      }
      <D.23841>:
      ctx->valid = 0;
      D.23845 = 0;
      return D.23845;
      <D.23838>:
      ptr.110 = ptr;
      size.111 = size;
      D.23848 = (sizetype) size.111;
      end = ptr.110 + D.23848;
      D.23845 = parse_method_signature (ctx, &ptr, end, 0, 0);
      return D.23845;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_method_header (struct VerifyContext * ctx, guint32 rva, guint32 * locals_token)
{
  struct MonoImage * D.23851;
  int D.23854;
  gchar * D.23857;
  struct GSList * D.23858;
  struct GSList * D.23859;
  gboolean D.23860;
  const char * D.23861;
  sizetype D.23862;
  const char * ptr.112;
  unsigned int D.23864;
  sizetype D.23865;
  int D.23866;
  gchar * D.23871;
  struct GSList * D.23872;
  unsigned int header.113;
  unsigned int D.23874;
  gchar * D.23877;
  struct GSList * D.23878;
  unsigned int header.114;
  const char * ptr.115;
  sizetype D.23883;
  const char * D.23884;
  long unsigned int D.23886;
  long unsigned int D.23887;
  long unsigned int ptr.116;
  long int end.117;
  long int ptr.118;
  long int D.23893;
  int D.23894;
  gchar * D.23895;
  struct GSList * D.23896;
  const char * ptr.119;
  int D.23899;
  gchar * D.23904;
  struct GSList * D.23905;
  unsigned int fat_header.120;
  unsigned int D.23907;
  gchar * D.23912;
  struct GSList * D.23913;
  int D.23914;
  gchar * D.23919;
  struct GSList * D.23920;
  int D.23921;
  gchar * D.23926;
  struct GSList * D.23927;
  int D.23928;
  gchar * D.23933;
  struct GSList * D.23934;
  unsigned int local_vars_tok.121;
  unsigned int D.23938;
  gchar * D.23943;
  struct GSList * D.23944;
  unsigned int D.23945;
  <unnamed-unsigned:24> D.23946;
  unsigned int D.23947;
  gchar * D.23952;
  struct GSList * D.23953;
  gchar * D.23958;
  struct GSList * D.23959;
  unsigned int D.23960;
  gchar * D.23965;
  struct GSList * D.23966;
  unsigned int code_size.122;
  sizetype D.23970;
  const char * ptr.123;
  long unsigned int D.23973;
  long unsigned int D.23974;
  gchar * D.23977;
  struct GSList * D.23978;
  unsigned int D.23979;
  const char * ptr.124;
  int D.23983;
  gchar * D.23988;
  struct GSList * D.23989;
  unsigned int section_header.125;
  unsigned int D.23991;
  gchar * D.23996;
  struct GSList * D.23997;
  unsigned int D.23998;
  _Bool D.23999;
  unsigned int D.24000;
  unsigned int iftmp.126;
  gchar * D.24009;
  struct GSList * D.24010;
  unsigned int D.24013;
  sizetype D.24014;
  const char * D.24015;
  long unsigned int D.24017;
  long unsigned int D.24018;
  gchar * D.24021;
  struct GSList * D.24022;
  unsigned int D.24023;
  unsigned int iftmp.127;
  guint32 iftmp.128;
  unsigned int D.24034;
  guint32 iftmp.129;
  unsigned int D.24041;
  unsigned int D.24042;
  guint32 iftmp.130;
  unsigned int D.24051;
  gchar * D.24052;
  struct GSList * D.24053;
  unsigned char D.24054;
  sizetype iftmp.131;
  const char * ptr.132;
  int D.24060;
  gchar * D.24065;
  struct GSList * D.24066;
  unsigned int class_token.133;
  unsigned int D.24072;
  _Bool D.24073;
  _Bool D.24074;
  _Bool D.24075;
  gchar * D.24080;
  struct GSList * D.24081;
  unsigned int D.24082;
  <unnamed-unsigned:24> D.24083;
  unsigned int D.24084;
  gchar * D.24089;
  struct GSList * D.24090;
  unsigned int D.24091;
  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.23851 = ctx->image;
      offset = mono_cli_rva_image_map (D.23851, rva);
      header = 0;
      fat_header = 0;
      size = 0;
      ptr = 0B;
      *locals_token = 0;
      if (offset == 4294967295) goto <D.23852>; else goto <D.23853>;
      <D.23852>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23855>; else goto <D.23856>;
      <D.23855>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23857 = monoeg_strdup ("MethodHeader: Invalid RVA");
        vinfo->info.message = D.23857;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23859 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23859;
      }
      <D.23856>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23853>:
      D.23861 = ctx->data;
      D.23862 = (sizetype) offset;
      ptr.112 = D.23861 + D.23862;
      ptr = ptr.112;
      D.23861 = ctx->data;
      D.23864 = ctx->size;
      D.23865 = (sizetype) D.23864;
      end = D.23861 + D.23865;
      D.23866 = safe_read (&ptr, end, &header, 1);
      if (D.23866 == 0) goto <D.23867>; else goto <D.23868>;
      <D.23867>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23869>; else goto <D.23870>;
      <D.23869>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23871 = monoeg_strdup ("MethodHeader: Not enough room for header");
        vinfo->info.message = D.23871;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23872 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23872;
      }
      <D.23870>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23868>:
      header.113 = header;
      D.23874 = header.113 & 3;
      switch (D.23874) <default: <D.23897>, case 0: <D.18689>, case 1: <D.18690>, case 2: <D.18692>>
      <D.18689>:
      <D.18690>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23875>; else goto <D.23876>;
      <D.23875>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        header.113 = header;
        D.23874 = header.113 & 3;
        D.23877 = monoeg_g_strdup_printf ("MethodHeader: Invalid header type 0x%x", D.23874);
        vinfo->info.message = D.23877;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23878 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23878;
      }
      <D.23876>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.18692>:
      header.113 = header;
      header.114 = header.113 >> 2;
      header = header.114;
      ptr.115 = ptr;
      header.113 = header;
      D.23883 = (sizetype) header.113;
      D.23884 = ptr.115 + D.23883;
      if (D.23884 > end) goto <D.23880>; else goto <D.23885>;
      <D.23885>:
      header.113 = header;
      D.23886 = (long unsigned int) header.113;
      D.23887 = ~D.23886;
      ptr.115 = ptr;
      ptr.116 = (long unsigned int) ptr.115;
      if (D.23887 < ptr.116) goto <D.23880>; else goto <D.23881>;
      <D.23880>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23889>; else goto <D.23890>;
      <D.23889>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        end.117 = (long int) end;
        ptr.115 = ptr;
        ptr.118 = (long int) ptr.115;
        D.23893 = end.117 - ptr.118;
        D.23894 = (int) D.23893;
        header.113 = header;
        D.23895 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header.113, D.23894);
        vinfo->info.message = D.23895;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23896 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23896;
      }
      <D.23890>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23881>:
      D.23860 = 1;
      return D.23860;
      <D.23897>:
      ptr.115 = ptr;
      ptr.119 = ptr.115 + 18446744073709551615;
      ptr = ptr.119;
      D.23899 = safe_read (&ptr, end, &fat_header, 2);
      if (D.23899 == 0) goto <D.23900>; else goto <D.23901>;
      <D.23900>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23902>; else goto <D.23903>;
      <D.23902>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23904 = monoeg_strdup ("MethodHeader: Not enough room for fat header");
        vinfo->info.message = D.23904;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23905 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23905;
      }
      <D.23903>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23901>:
      fat_header.120 = fat_header;
      D.23907 = fat_header.120 >> 12;
      size = D.23907 & 15;
      if (size != 3) goto <D.23908>; else goto <D.23909>;
      <D.23908>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23910>; else goto <D.23911>;
      <D.23910>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23912 = monoeg_strdup ("MethodHeader: header size must be 3");
        vinfo->info.message = D.23912;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23913 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23913;
      }
      <D.23911>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23909>:
      D.23914 = safe_read (&ptr, end, &max_stack, 2);
      if (D.23914 == 0) goto <D.23915>; else goto <D.23916>;
      <D.23915>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23917>; else goto <D.23918>;
      <D.23917>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23919 = monoeg_strdup ("MethodHeader: Not enough room for max stack");
        vinfo->info.message = D.23919;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23920 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23920;
      }
      <D.23918>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23916>:
      D.23921 = safe_read (&ptr, end, &code_size, 4);
      if (D.23921 == 0) goto <D.23922>; else goto <D.23923>;
      <D.23922>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23924>; else goto <D.23925>;
      <D.23924>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23926 = monoeg_strdup ("MethodHeader: Not enough room for code size");
        vinfo->info.message = D.23926;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23927 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23927;
      }
      <D.23925>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23923>:
      D.23928 = safe_read (&ptr, end, &local_vars_tok, 4);
      if (D.23928 == 0) goto <D.23929>; else goto <D.23930>;
      <D.23929>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23931>; else goto <D.23932>;
      <D.23931>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23933 = monoeg_strdup ("MethodHeader: Not enough room for local vars tok");
        vinfo->info.message = D.23933;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23934 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23934;
      }
      <D.23932>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23930>:
      local_vars_tok.121 = local_vars_tok;
      if (local_vars_tok.121 != 0) goto <D.23936>; else goto <D.23937>;
      <D.23936>:
      local_vars_tok.121 = local_vars_tok;
      D.23938 = local_vars_tok.121 >> 24;
      if (D.23938 != 17) goto <D.23939>; else goto <D.23940>;
      <D.23939>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23941>; else goto <D.23942>;
      <D.23941>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        local_vars_tok.121 = local_vars_tok;
        D.23938 = local_vars_tok.121 >> 24;
        D.23943 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", D.23938);
        vinfo->info.message = D.23943;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23944 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23944;
      }
      <D.23942>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23940>:
      local_vars_tok.121 = local_vars_tok;
      D.23945 = local_vars_tok.121 & 16777215;
      D.23851 = ctx->image;
      D.23946 = D.23851->tables[17].rows;
      D.23947 = (unsigned int) D.23946;
      if (D.23945 > D.23947) goto <D.23948>; else goto <D.23949>;
      <D.23948>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23950>; else goto <D.23951>;
      <D.23950>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        local_vars_tok.121 = local_vars_tok;
        D.23945 = local_vars_tok.121 & 16777215;
        D.23952 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", D.23945);
        vinfo->info.message = D.23952;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23953 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23953;
      }
      <D.23951>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23949>:
      local_vars_tok.121 = local_vars_tok;
      D.23945 = local_vars_tok.121 & 16777215;
      if (D.23945 == 0) goto <D.23954>; else goto <D.23955>;
      <D.23954>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23956>; else goto <D.23957>;
      <D.23956>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23958 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature with zero index");
        vinfo->info.message = D.23958;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23959 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23959;
      }
      <D.23957>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23955>:
      local_vars_tok.121 = local_vars_tok;
      D.23945 = local_vars_tok.121 & 16777215;
      *locals_token = D.23945;
      <D.23937>:
      fat_header.120 = fat_header;
      D.23960 = fat_header.120 & 4294905828;
      if (D.23960 != 0) goto <D.23961>; else goto <D.23962>;
      <D.23961>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23963>; else goto <D.23964>;
      <D.23963>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        fat_header.120 = fat_header;
        D.23960 = fat_header.120 & 4294905828;
        D.23965 = monoeg_g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", D.23960);
        vinfo->info.message = D.23965;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23966 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23966;
      }
      <D.23964>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23962>:
      ptr.115 = ptr;
      code_size.122 = code_size;
      D.23970 = (sizetype) code_size.122;
      ptr.123 = ptr.115 + D.23970;
      if (ptr.123 > end) goto <D.23967>; else goto <D.23972>;
      <D.23972>:
      code_size.122 = code_size;
      D.23973 = (long unsigned int) code_size.122;
      D.23974 = ~D.23973;
      ptr.115 = ptr;
      ptr.116 = (long unsigned int) ptr.115;
      if (D.23974 < ptr.116) goto <D.23967>; else goto <D.23968>;
      <D.23967>:
      D.23854 = ctx->report_error;
      if (D.23854 != 0) goto <D.23975>; else goto <D.23976>;
      <D.23975>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        code_size.122 = code_size;
        D.23977 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size.122);
        vinfo->info.message = D.23977;
        vinfo->exception_type = 3;
        D.23858 = ctx->errors;
        D.23978 = monoeg_g_slist_prepend (D.23858, vinfo);
        ctx->errors = D.23978;
      }
      <D.23976>:
      ctx->valid = 0;
      D.23860 = 0;
      return D.23860;
      <D.23968>:
      fat_header.120 = fat_header;
      D.23979 = fat_header.120 & 8;
      if (D.23979 == 0) goto <D.23980>; else goto <D.23981>;
      <D.23980>:
      D.23860 = 1;
      return D.23860;
      <D.23981>:
      ptr.115 = ptr;
      code_size.122 = code_size;
      D.23970 = (sizetype) code_size.122;
      ptr.123 = ptr.115 + D.23970;
      ptr = ptr.123;
      <D.18724>:
      {
        unsigned int section_header;
        unsigned int section_size;
        gboolean is_fat;

        try
          {
            section_header = 0;
            section_size = 0;
            ptr.115 = ptr;
            ptr.124 = dword_align (ptr.115);
            ptr = ptr.124;
            D.23983 = safe_read (&ptr, end, &section_header, 4);
            if (D.23983 == 0) goto <D.23984>; else goto <D.23985>;
            <D.23984>:
            D.23854 = ctx->report_error;
            if (D.23854 != 0) goto <D.23986>; else goto <D.23987>;
            <D.23986>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.23988 = monoeg_strdup ("MethodHeader: Not enough room for data section header");
              vinfo->info.message = D.23988;
              vinfo->exception_type = 3;
              D.23858 = ctx->errors;
              D.23989 = monoeg_g_slist_prepend (D.23858, vinfo);
              ctx->errors = D.23989;
            }
            <D.23987>:
            ctx->valid = 0;
            D.23860 = 0;
            return D.23860;
            <D.23985>:
            section_header.125 = section_header;
            D.23991 = section_header.125 & 62;
            if (D.23991 != 0) goto <D.23992>; else goto <D.23993>;
            <D.23992>:
            D.23854 = ctx->report_error;
            if (D.23854 != 0) goto <D.23994>; else goto <D.23995>;
            <D.23994>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              section_header.125 = section_header;
              D.23991 = section_header.125 & 62;
              D.23996 = monoeg_g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", D.23991);
              vinfo->info.message = D.23996;
              vinfo->exception_type = 3;
              D.23858 = ctx->errors;
              D.23997 = monoeg_g_slist_prepend (D.23858, vinfo);
              ctx->errors = D.23997;
            }
            <D.23995>:
            ctx->valid = 0;
            D.23860 = 0;
            return D.23860;
            <D.23993>:
            section_header.125 = section_header;
            D.23998 = section_header.125 & 64;
            D.23999 = D.23998 != 0;
            is_fat = (gboolean) D.23999;
            section_header.125 = section_header;
            D.24000 = section_header.125 >> 8;
            if (is_fat != 0) goto <D.24002>; else goto <D.24003>;
            <D.24002>:
            iftmp.126 = 16777215;
            goto <D.24004>;
            <D.24003>:
            iftmp.126 = 255;
            <D.24004>:
            section_size = D.24000 & iftmp.126;
            if (section_size <= 3) goto <D.24005>; else goto <D.24006>;
            <D.24005>:
            D.23854 = ctx->report_error;
            if (D.23854 != 0) goto <D.24007>; else goto <D.24008>;
            <D.24007>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24009 = monoeg_g_strdup_printf ("MethodHeader: Section size too small");
              vinfo->info.message = D.24009;
              vinfo->exception_type = 3;
              D.23858 = ctx->errors;
              D.24010 = monoeg_g_slist_prepend (D.23858, vinfo);
              ctx->errors = D.24010;
            }
            <D.24008>:
            ctx->valid = 0;
            D.23860 = 0;
            return D.23860;
            <D.24006>:
            ptr.115 = ptr;
            D.24013 = section_size + 4294967292;
            D.24014 = (sizetype) D.24013;
            D.24015 = ptr.115 + D.24014;
            if (D.24015 > end) goto <D.24011>; else goto <D.24016>;
            <D.24016>:
            D.24013 = section_size + 4294967292;
            D.24017 = (long unsigned int) D.24013;
            D.24018 = ~D.24017;
            ptr.115 = ptr;
            ptr.116 = (long unsigned int) ptr.115;
            if (D.24018 < ptr.116) goto <D.24011>; else goto <D.24012>;
            <D.24011>:
            D.23854 = ctx->report_error;
            if (D.23854 != 0) goto <D.24019>; else goto <D.24020>;
            <D.24019>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24021 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size);
              vinfo->info.message = D.24021;
              vinfo->exception_type = 3;
              D.23858 = ctx->errors;
              D.24022 = monoeg_g_slist_prepend (D.23858, vinfo);
              ctx->errors = D.24022;
            }
            <D.24020>:
            ctx->valid = 0;
            D.23860 = 0;
            return D.23860;
            <D.24012>:
            section_header.125 = section_header;
            D.24023 = section_header.125 & 1;
            if (D.24023 != 0) goto <D.24024>; else goto <D.24025>;
            <D.24024>:
            {
              guint32 i;
              guint32 clauses;

              if (is_fat != 0) goto <D.24027>; else goto <D.24028>;
              <D.24027>:
              iftmp.127 = 24;
              goto <D.24029>;
              <D.24028>:
              iftmp.127 = 12;
              <D.24029>:
              clauses = section_size / iftmp.127;
              if (is_fat != 0) goto <D.24031>; else goto <D.24032>;
              <D.24031>:
              iftmp.128 = 24;
              goto <D.24033>;
              <D.24032>:
              iftmp.128 = 12;
              <D.24033>:
              D.24034 = iftmp.128 * clauses;
              if (D.24034 != section_size) goto <D.24035>; else goto <D.24036>;
              <D.24035>:
              if (is_fat != 0) goto <D.24038>; else goto <D.24039>;
              <D.24038>:
              iftmp.129 = 24;
              goto <D.24040>;
              <D.24039>:
              iftmp.129 = 12;
              <D.24040>:
              D.24041 = iftmp.129 * clauses;
              D.24042 = D.24041 + 4;
              if (D.24042 != section_size) goto <D.24043>; else goto <D.24044>;
              <D.24043>:
              D.23854 = ctx->report_error;
              if (D.23854 != 0) goto <D.24045>; else goto <D.24046>;
              <D.24045>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (24);
                vinfo->info.status = 1;
                if (is_fat != 0) goto <D.24048>; else goto <D.24049>;
                <D.24048>:
                iftmp.130 = 24;
                goto <D.24050>;
                <D.24049>:
                iftmp.130 = 12;
                <D.24050>:
                D.24051 = iftmp.130 * clauses;
                D.24052 = monoeg_g_strdup_printf ("MethodHeader: Invalid EH section size %d, it\'s not of the expected size %d", section_size, D.24051);
                vinfo->info.message = D.24052;
                vinfo->exception_type = 3;
                D.23858 = ctx->errors;
                D.24053 = monoeg_g_slist_prepend (D.23858, vinfo);
                ctx->errors = D.24053;
              }
              <D.24046>:
              ctx->valid = 0;
              D.23860 = 0;
              return D.23860;
              <D.24044>:
              <D.24036>:
              i = 0;
              goto <D.18721>;
              <D.18720>:
              {
                unsigned int flags;
                unsigned int class_token;

                try
                  {
                    ptr.115 = ptr;
                    D.24054 = MEM[(unsigned char *)ptr.115];
                    flags = (unsigned int) D.24054;
                    class_token = 0;
                    ptr.115 = ptr;
                    if (is_fat != 0) goto <D.24056>; else goto <D.24057>;
                    <D.24056>:
                    iftmp.131 = 20;
                    goto <D.24058>;
                    <D.24057>:
                    iftmp.131 = 8;
                    <D.24058>:
                    ptr.132 = ptr.115 + iftmp.131;
                    ptr = ptr.132;
                    D.24060 = safe_read (&ptr, end, &class_token, 4);
                    if (D.24060 == 0) goto <D.24061>; else goto <D.24062>;
                    <D.24061>:
                    D.23854 = ctx->report_error;
                    if (D.23854 != 0) goto <D.24063>; else goto <D.24064>;
                    <D.24063>:
                    {
                      struct MonoVerifyInfoExtended * vinfo;

                      vinfo = monoeg_malloc (24);
                      vinfo->info.status = 1;
                      D.24065 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section %d", i);
                      vinfo->info.message = D.24065;
                      vinfo->exception_type = 3;
                      D.23858 = ctx->errors;
                      D.24066 = monoeg_g_slist_prepend (D.23858, vinfo);
                      ctx->errors = D.24066;
                    }
                    <D.24064>:
                    ctx->valid = 0;
                    D.23860 = 0;
                    return D.23860;
                    <D.24062>:
                    if (flags == 0) goto <D.24067>; else goto <D.24068>;
                    <D.24067>:
                    class_token.133 = class_token;
                    if (class_token.133 != 0) goto <D.24070>; else goto <D.24071>;
                    <D.24070>:
                    {
                      guint table;

                      class_token.133 = class_token;
                      table = class_token.133 >> 24;
                      D.24072 = table + 4294967295;
                      D.24073 = D.24072 > 1;
                      D.24074 = table != 27;
                      D.24075 = D.24073 & D.24074;
                      if (D.24075 != 0) goto <D.24076>; else goto <D.24077>;
                      <D.24076>:
                      D.23854 = ctx->report_error;
                      if (D.23854 != 0) goto <D.24078>; else goto <D.24079>;
                      <D.24078>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (24);
                        vinfo->info.status = 1;
                        D.24080 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table);
                        vinfo->info.message = D.24080;
                        vinfo->exception_type = 3;
                        D.23858 = ctx->errors;
                        D.24081 = monoeg_g_slist_prepend (D.23858, vinfo);
                        ctx->errors = D.24081;
                      }
                      <D.24079>:
                      ctx->valid = 0;
                      D.23860 = 0;
                      return D.23860;
                      <D.24077>:
                      class_token.133 = class_token;
                      D.24082 = class_token.133 & 16777215;
                      D.23851 = ctx->image;
                      D.24083 = D.23851->tables[table].rows;
                      D.24084 = (unsigned int) D.24083;
                      if (D.24082 > D.24084) goto <D.24085>; else goto <D.24086>;
                      <D.24085>:
                      D.23854 = ctx->report_error;
                      if (D.23854 != 0) goto <D.24087>; else goto <D.24088>;
                      <D.24087>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (24);
                        vinfo->info.status = 1;
                        class_token.133 = class_token;
                        D.24082 = class_token.133 & 16777215;
                        D.24089 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, D.24082);
                        vinfo->info.message = D.24089;
                        vinfo->exception_type = 3;
                        D.23858 = ctx->errors;
                        D.24090 = monoeg_g_slist_prepend (D.23858, vinfo);
                        ctx->errors = D.24090;
                      }
                      <D.24088>:
                      ctx->valid = 0;
                      D.23860 = 0;
                      return D.23860;
                      <D.24086>:
                    }
                    <D.24071>:
                    <D.24068>:
                  }
                finally
                  {
                    class_token = {CLOBBER};
                  }
              }
              i = i + 1;
              <D.18721>:
              if (i < clauses) goto <D.18720>; else goto <D.18722>;
              <D.18722>:
            }
            <D.24025>:
            section_header.125 = section_header;
            D.24091 = section_header.125 & 128;
            if (D.24091 == 0) goto <D.18723>; else goto <D.24092>;
            <D.24092>:
          }
        finally
          {
            section_header = {CLOBBER};
          }
      }
      goto <D.18724>;
      <D.18723>:
      D.23860 = 1;
      return D.23860;
    }
  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.24100;
  const char * D.24101;
  long unsigned int D.24102;
  long unsigned int D.24103;

  D.24101 = ptr + 3;
  D.24102 = (long unsigned int) D.24101;
  D.24103 = D.24102 & 18446744073709551612;
  D.24100 = (const char *) D.24103;
  return D.24100;
}


verify_memberref_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24105;
  unsigned int D.24106;
  int D.24107;
  int D.24110;
  gchar * D.24113;
  struct GSList * D.24114;
  struct GSList * D.24115;
  <unnamed-unsigned:24> D.24116;
  int D.24117;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24105 = ctx->image;
      table = &D.24105->tables[10];
      i = 0;
      goto <D.18970>;
      <D.18969>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24106 = data[2];
      D.24107 = is_valid_method_or_field_signature (ctx, D.24106);
      if (D.24107 == 0) goto <D.24108>; else goto <D.24109>;
      <D.24108>:
      D.24110 = ctx->report_error;
      if (D.24110 != 0) goto <D.24111>; else goto <D.24112>;
      <D.24111>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24106 = data[2];
        D.24113 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, D.24106);
        vinfo->info.message = D.24113;
        vinfo->exception_type = 3;
        D.24114 = ctx->errors;
        D.24115 = monoeg_g_slist_prepend (D.24114, vinfo);
        ctx->errors = D.24115;
      }
      <D.24112>:
      ctx->valid = 0;
      return;
      <D.24109>:
      i = i + 1;
      <D.18970>:
      D.24116 = table->rows;
      D.24117 = (int) D.24116;
      if (D.24117 > i) goto <D.18969>; else goto <D.18971>;
      <D.18971>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_method_or_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24121;
  int D.24124;
  gchar * D.24127;
  struct GSList * D.24128;
  struct GSList * D.24129;
  gboolean D.24130;
  const char * ptr.134;
  unsigned int size.135;
  sizetype D.24133;
  int D.24134;
  gchar * D.24139;
  struct GSList * D.24140;
  const char * ptr.136;
  unsigned int signature.137;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24121 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24121 == 0) goto <D.24122>; else goto <D.24123>;
      <D.24122>:
      D.24124 = ctx->report_error;
      if (D.24124 != 0) goto <D.24125>; else goto <D.24126>;
      <D.24125>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24127 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.24127;
        vinfo->exception_type = 3;
        D.24128 = ctx->errors;
        D.24129 = monoeg_g_slist_prepend (D.24128, vinfo);
        ctx->errors = D.24129;
      }
      <D.24126>:
      ctx->valid = 0;
      D.24130 = 0;
      return D.24130;
      <D.24123>:
      ptr.134 = ptr;
      size.135 = size;
      D.24133 = (sizetype) size.135;
      end = ptr.134 + D.24133;
      D.24134 = safe_read (&ptr, end, &signature, 1);
      if (D.24134 == 0) goto <D.24135>; else goto <D.24136>;
      <D.24135>:
      D.24124 = ctx->report_error;
      if (D.24124 != 0) goto <D.24137>; else goto <D.24138>;
      <D.24137>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24139 = monoeg_strdup ("MemberRefSig: Not enough room for the call conv");
        vinfo->info.message = D.24139;
        vinfo->exception_type = 3;
        D.24128 = ctx->errors;
        D.24140 = monoeg_g_slist_prepend (D.24128, vinfo);
        ctx->errors = D.24140;
      }
      <D.24138>:
      ctx->valid = 0;
      D.24130 = 0;
      return D.24130;
      <D.24136>:
      ptr.134 = ptr;
      ptr.136 = ptr.134 + 18446744073709551615;
      ptr = ptr.136;
      signature.137 = signature;
      if (signature.137 == 6) goto <D.24143>; else goto <D.24144>;
      <D.24143>:
      D.24130 = parse_field (ctx, &ptr, end);
      return D.24130;
      <D.24144>:
      D.24130 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.24130;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_cattr_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24147;
  unsigned int D.24148;
  int D.24149;
  int D.24152;
  gchar * D.24155;
  struct GSList * D.24156;
  struct GSList * D.24157;
  unsigned int D.24158;
  unsigned int D.24159;
  gchar * D.24162;
  struct GSList * D.24163;
  int D.24164;
  _Bool D.24165;
  long int D.24166;
  long int D.24167;
  unsigned int size.138;
  const char * ptr.139;
  int D.24172;
  gchar * D.24177;
  struct GSList * D.24178;
  <unnamed-unsigned:24> D.24179;
  int D.24180;
  struct MonoTableInfo * table;
  struct MonoMethod * ctor;
  const char * ptr;
  guint32 data[3];
  guint32 mtoken;
  guint32 size;
  int i;

  try
    {
      D.24147 = ctx->image;
      table = &D.24147->tables[12];
      i = 0;
      goto <D.19016>;
      <D.19015>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24148 = data[2];
      D.24149 = is_valid_cattr_blob (ctx, D.24148);
      if (D.24149 == 0) goto <D.24150>; else goto <D.24151>;
      <D.24150>:
      D.24152 = ctx->report_error;
      if (D.24152 != 0) goto <D.24153>; else goto <D.24154>;
      <D.24153>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24148 = data[2];
        D.24155 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, D.24148);
        vinfo->info.message = D.24155;
        vinfo->exception_type = 3;
        D.24156 = ctx->errors;
        D.24157 = monoeg_g_slist_prepend (D.24156, vinfo);
        ctx->errors = D.24157;
      }
      <D.24154>:
      ctx->valid = 0;
      return;
      <D.24151>:
      D.24158 = data[1];
      mtoken = D.24158 >> 3;
      D.24158 = data[1];
      D.24159 = D.24158 & 7;
      switch (D.24159) <default: <D.19012>, case 2: <D.19009>, case 3: <D.19011>>
      <D.19009>:
      mtoken = mtoken | 100663296;
      goto <D.19010>;
      <D.19011>:
      mtoken = mtoken | 167772160;
      goto <D.19010>;
      <D.19012>:
      D.24152 = ctx->report_error;
      if (D.24152 != 0) goto <D.24160>; else goto <D.24161>;
      <D.24160>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24158 = data[1];
        D.24162 = monoeg_g_strdup_printf ("Invalid CustomAttribute constructor row %d Token 0x%08x", i, D.24158);
        vinfo->info.message = D.24162;
        vinfo->exception_type = 3;
        D.24156 = ctx->errors;
        D.24163 = monoeg_g_slist_prepend (D.24156, vinfo);
        ctx->errors = D.24163;
      }
      <D.24161>:
      ctx->valid = 0;
      return;
      <D.19010>:
      D.24147 = ctx->image;
      ctor = mono_get_method (D.24147, mtoken, 0B);
      D.24148 = data[2];
      D.24164 = decode_signature_header (ctx, D.24148, &size, &ptr);
      D.24165 = D.24164 == 0;
      D.24166 = (long int) D.24165;
      D.24167 = __builtin_expect (D.24166, 0);
      if (D.24167 != 0) goto <D.24168>; else goto <D.24169>;
      <D.24168>:
      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.24169>:
      size.138 = size;
      ptr.139 = ptr;
      D.24172 = is_valid_cattr_content (ctx, ctor, ptr.139, size.138);
      if (D.24172 == 0) goto <D.24173>; else goto <D.24174>;
      <D.24173>:
      D.24152 = ctx->report_error;
      if (D.24152 != 0) goto <D.24175>; else goto <D.24176>;
      <D.24175>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24148 = data[2];
        D.24177 = monoeg_g_strdup_printf ("Invalid CustomAttribute content row %d Value field 0x%08x", i, D.24148);
        vinfo->info.message = D.24177;
        vinfo->exception_type = 3;
        D.24156 = ctx->errors;
        D.24178 = monoeg_g_slist_prepend (D.24156, vinfo);
        ctx->errors = D.24178;
      }
      <D.24176>:
      ctx->valid = 0;
      return;
      <D.24174>:
      i = i + 1;
      <D.19016>:
      D.24179 = table->rows;
      D.24180 = (int) D.24179;
      if (D.24180 > i) goto <D.19015>; else goto <D.19017>;
      <D.19017>:
    }
  finally
    {
      ptr = {CLOBBER};
      data = {CLOBBER};
      size = {CLOBBER};
    }
}


is_valid_cattr_blob (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.24186;
  int D.24187;
  int D.24190;
  gchar * D.24193;
  struct GSList * D.24194;
  struct GSList * D.24195;
  const char * ptr.140;
  unsigned int size.141;
  sizetype D.24198;
  int D.24199;
  gchar * D.24204;
  struct GSList * D.24205;
  unsigned int prolog.142;
  gchar * D.24211;
  struct GSList * D.24212;
  guint32 size;
  unsigned int prolog;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      prolog = 0;
      ptr = 0B;
      if (offset == 0) goto <D.24184>; else goto <D.24185>;
      <D.24184>:
      D.24186 = 1;
      return D.24186;
      <D.24185>:
      D.24187 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24187 == 0) goto <D.24188>; else goto <D.24189>;
      <D.24188>:
      D.24190 = ctx->report_error;
      if (D.24190 != 0) goto <D.24191>; else goto <D.24192>;
      <D.24191>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24193 = monoeg_strdup ("CustomAttribute: Could not decode signature header");
        vinfo->info.message = D.24193;
        vinfo->exception_type = 3;
        D.24194 = ctx->errors;
        D.24195 = monoeg_g_slist_prepend (D.24194, vinfo);
        ctx->errors = D.24195;
      }
      <D.24192>:
      ctx->valid = 0;
      D.24186 = 0;
      return D.24186;
      <D.24189>:
      ptr.140 = ptr;
      size.141 = size;
      D.24198 = (sizetype) size.141;
      end = ptr.140 + D.24198;
      D.24199 = safe_read (&ptr, end, &prolog, 2);
      if (D.24199 == 0) goto <D.24200>; else goto <D.24201>;
      <D.24200>:
      D.24190 = ctx->report_error;
      if (D.24190 != 0) goto <D.24202>; else goto <D.24203>;
      <D.24202>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24204 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.24204;
        vinfo->exception_type = 3;
        D.24194 = ctx->errors;
        D.24205 = monoeg_g_slist_prepend (D.24194, vinfo);
        ctx->errors = D.24205;
      }
      <D.24203>:
      ctx->valid = 0;
      D.24186 = 0;
      return D.24186;
      <D.24201>:
      prolog.142 = prolog;
      if (prolog.142 != 1) goto <D.24207>; else goto <D.24208>;
      <D.24207>:
      D.24190 = ctx->report_error;
      if (D.24190 != 0) goto <D.24209>; else goto <D.24210>;
      <D.24209>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        prolog.142 = prolog;
        D.24211 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.142);
        vinfo->info.message = D.24211;
        vinfo->exception_type = 3;
        D.24194 = ctx->errors;
        D.24212 = monoeg_g_slist_prepend (D.24194, vinfo);
        ctx->errors = D.24212;
      }
      <D.24210>:
      ctx->valid = 0;
      D.24186 = 0;
      return D.24186;
      <D.24208>:
      D.24186 = 1;
      return D.24186;
    }
  finally
    {
      size = {CLOBBER};
      prolog = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_cattr_content (struct VerifyContext * ctx, struct MonoMethod * ctor, const char * ptr, guint32 size)
{
  int D.24217;
  gchar * D.24220;
  struct GSList * D.24221;
  struct GSList * D.24222;
  gboolean D.24223;
  int D.24224;
  const char * D.24229;
  gchar * D.24230;
  struct GSList * D.24231;
  short int D.24234;
  unsigned char D.24236;
  unsigned char D.24237;
  gchar * D.24240;
  struct GSList * D.24241;
  const char * ptr.143;
  sizetype D.24243;
  int D.24244;
  gchar * D.24249;
  struct GSList * D.24250;
  unsigned int prolog.144;
  gchar * D.24256;
  struct GSList * D.24257;
  short unsigned int D.24258;
  int D.24259;
  int D.24262;
  gchar * D.24267;
  struct GSList * D.24268;
  int D.24269;
  gchar * D.24274;
  struct GSList * D.24275;
  unsigned int kind.145;
  unsigned int D.24277;
  gchar * D.24282;
  struct GSList * D.24283;
  int D.24284;
  gchar * D.24289;
  struct GSList * D.24290;
  unsigned int D.24291;
  unsigned char D.24294;
  struct MonoClass * D.24303;
  struct MonoClass * D.24307;
  int D.24311;
  gchar * D.24316;
  struct GSList * D.24317;
  unsigned int etype.146;
  unsigned int etype.147;
  _Bool D.24325;
  _Bool D.24326;
  _Bool D.24327;
  unsigned int etype.148;
  unsigned int D.24332;
  _Bool D.24333;
  _Bool D.24334;
  _Bool D.24335;
  unsigned char iftmp.149;
  gchar * D.24345;
  struct GSList * D.24346;
  struct MonoClass * D.24347;
  gchar * D.24351;
  struct GSList * D.24352;
  int D.24353;
  int D.24356;
  unsigned int i.150;
  unsigned int num_named.151;
  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.24215>; else goto <D.24216>;
      <D.24215>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24218>; else goto <D.24219>;
      <D.24218>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24220 = monoeg_strdup ("CustomAttribute: Invalid constructor");
        vinfo->info.message = D.24220;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24222 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24222;
      }
      <D.24219>:
      ctx->valid = 0;
      D.24223 = 0;
      return D.24223;
      <D.24216>:
      sig = mono_method_signature_checked (ctor, &error);
      D.24224 = mono_error_ok (&error);
      if (D.24224 == 0) goto <D.24225>; else goto <D.24226>;
      <D.24225>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24227>; else goto <D.24228>;
      <D.24227>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24229 = mono_error_get_message (&error);
        D.24230 = monoeg_g_strdup_printf ("CustomAttribute: Invalid constructor signature %s", D.24229);
        vinfo->info.message = D.24230;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24231 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24231;
      }
      <D.24228>:
      ctx->valid = 0;
      mono_error_cleanup (&error);
      D.24223 = 0;
      return D.24223;
      <D.24226>:
      D.24234 = sig->sentinelpos;
      if (D.24234 != -1) goto <D.24232>; else goto <D.24235>;
      <D.24235>:
      D.24236 = BIT_FIELD_REF <*sig, 8, 112>;
      D.24237 = D.24236 & 63;
      if (D.24237 == 5) goto <D.24232>; else goto <D.24233>;
      <D.24232>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24238>; else goto <D.24239>;
      <D.24238>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24240 = monoeg_strdup ("CustomAttribute: Constructor cannot have VARAG signature");
        vinfo->info.message = D.24240;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24241 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24241;
      }
      <D.24239>:
      ctx->valid = 0;
      D.24223 = 0;
      return D.24223;
      <D.24233>:
      ptr.143 = ptr;
      D.24243 = (sizetype) size;
      end = ptr.143 + D.24243;
      D.24244 = safe_read (&ptr, end, &prolog, 2);
      if (D.24244 == 0) goto <D.24245>; else goto <D.24246>;
      <D.24245>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24247>; else goto <D.24248>;
      <D.24247>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24249 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.24249;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24250 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24250;
      }
      <D.24248>:
      ctx->valid = 0;
      D.24223 = 0;
      return D.24223;
      <D.24246>:
      prolog.144 = prolog;
      if (prolog.144 != 1) goto <D.24252>; else goto <D.24253>;
      <D.24252>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24254>; else goto <D.24255>;
      <D.24254>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        prolog.144 = prolog;
        D.24256 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.144);
        vinfo->info.message = D.24256;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24257 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24257;
      }
      <D.24255>:
      ctx->valid = 0;
      D.24223 = 0;
      return D.24223;
      <D.24253>:
      D.24258 = sig->param_count;
      args = (int) D.24258;
      i = 0;
      goto <D.18558>;
      <D.18557>:
      {
        struct MonoType * arg_type;

        arg_type = sig->params[i];
        D.24259 = is_valid_fixed_param (ctx, arg_type, &ptr, end);
        if (D.24259 == 0) goto <D.24260>; else goto <D.24261>;
        <D.24260>:
        D.24223 = 0;
        return D.24223;
        <D.24261>:
      }
      i = i + 1;
      <D.18558>:
      if (i < args) goto <D.18557>; else goto <D.18559>;
      <D.18559>:
      D.24262 = safe_read (&ptr, end, &num_named, 2);
      if (D.24262 == 0) goto <D.24263>; else goto <D.24264>;
      <D.24263>:
      D.24217 = ctx->report_error;
      if (D.24217 != 0) goto <D.24265>; else goto <D.24266>;
      <D.24265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24267 = monoeg_strdup ("CustomAttribute: Not enough space for num_named field");
        vinfo->info.message = D.24267;
        vinfo->exception_type = 3;
        D.24221 = ctx->errors;
        D.24268 = monoeg_g_slist_prepend (D.24221, vinfo);
        ctx->errors = D.24268;
      }
      <D.24266>:
      ctx->valid = 0;
      D.24223 = 0;
      return D.24223;
      <D.24264>:
      i = 0;
      goto <D.18574>;
      <D.18573>:
      {
        struct MonoType * type;
        struct MonoType simple_type;
        unsigned int kind;

        try
          {
            simple_type = {};
            D.24269 = safe_read (&ptr, end, &kind, 1);
            if (D.24269 == 0) goto <D.24270>; else goto <D.24271>;
            <D.24270>:
            D.24217 = ctx->report_error;
            if (D.24217 != 0) goto <D.24272>; else goto <D.24273>;
            <D.24272>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24274 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d kind", i);
              vinfo->info.message = D.24274;
              vinfo->exception_type = 3;
              D.24221 = ctx->errors;
              D.24275 = monoeg_g_slist_prepend (D.24221, vinfo);
              ctx->errors = D.24275;
            }
            <D.24273>:
            ctx->valid = 0;
            D.24223 = 0;
            return D.24223;
            <D.24271>:
            kind.145 = kind;
            D.24277 = kind.145 + 4294967213;
            if (D.24277 > 1) goto <D.24278>; else goto <D.24279>;
            <D.24278>:
            D.24217 = ctx->report_error;
            if (D.24217 != 0) goto <D.24280>; else goto <D.24281>;
            <D.24280>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              kind.145 = kind;
              D.24282 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter %d kind %x", i, kind.145);
              vinfo->info.message = D.24282;
              vinfo->exception_type = 3;
              D.24221 = ctx->errors;
              D.24283 = monoeg_g_slist_prepend (D.24221, vinfo);
              ctx->errors = D.24283;
            }
            <D.24281>:
            ctx->valid = 0;
            D.24223 = 0;
            return D.24223;
            <D.24279>:
            D.24284 = safe_read (&ptr, end, &kind, 1);
            if (D.24284 == 0) goto <D.24285>; else goto <D.24286>;
            <D.24285>:
            D.24217 = ctx->report_error;
            if (D.24217 != 0) goto <D.24287>; else goto <D.24288>;
            <D.24287>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24289 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i);
              vinfo->info.message = D.24289;
              vinfo->exception_type = 3;
              D.24221 = ctx->errors;
              D.24290 = monoeg_g_slist_prepend (D.24221, vinfo);
              ctx->errors = D.24290;
            }
            <D.24288>:
            ctx->valid = 0;
            D.24223 = 0;
            return D.24223;
            <D.24286>:
            kind.145 = kind;
            D.24291 = kind.145 + 4294967294;
            if (D.24291 <= 12) goto <D.24292>; else goto <D.24293>;
            <D.24292>:
            kind.145 = kind;
            D.24294 = (unsigned char) kind.145;
            simple_type.type = D.24294;
            type = &simple_type;
            goto <D.24295>;
            <D.24293>:
            kind.145 = kind;
            if (kind.145 == 85) goto <D.24296>; else goto <D.24297>;
            <D.24296>:
            {
              struct MonoClass * klass;

              klass = get_enum_by_encoded_name (ctx, &ptr, end);
              if (klass == 0B) goto <D.24298>; else goto <D.24299>;
              <D.24298>:
              D.24223 = 0;
              return D.24223;
              <D.24299>:
              type = &klass->byval_arg;
            }
            goto <D.24300>;
            <D.24297>:
            kind.145 = kind;
            if (kind.145 == 80) goto <D.24301>; else goto <D.24302>;
            <D.24301>:
            D.24303 = mono_defaults.systemtype_class;
            type = &D.24303->byval_arg;
            goto <D.24304>;
            <D.24302>:
            kind.145 = kind;
            if (kind.145 == 81) goto <D.24305>; else goto <D.24306>;
            <D.24305>:
            D.24307 = mono_defaults.object_class;
            type = &D.24307->byval_arg;
            goto <D.24308>;
            <D.24306>:
            kind.145 = kind;
            if (kind.145 == 29) goto <D.24309>; else goto <D.24310>;
            <D.24309>:
            {
              struct MonoClass * klass;
              unsigned int etype;

              try
                {
                  etype = 0;
                  D.24311 = safe_read (&ptr, end, &etype, 1);
                  if (D.24311 == 0) goto <D.24312>; else goto <D.24313>;
                  <D.24312>:
                  D.24217 = ctx->report_error;
                  if (D.24217 != 0) goto <D.24314>; else goto <D.24315>;
                  <D.24314>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    D.24316 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24316;
                    vinfo->exception_type = 3;
                    D.24221 = ctx->errors;
                    D.24317 = monoeg_g_slist_prepend (D.24221, vinfo);
                    ctx->errors = D.24317;
                  }
                  <D.24315>:
                  ctx->valid = 0;
                  D.24223 = 0;
                  return D.24223;
                  <D.24313>:
                  etype.146 = etype;
                  if (etype.146 == 85) goto <D.24319>; else goto <D.24320>;
                  <D.24319>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24321>; else goto <D.24322>;
                  <D.24321>:
                  D.24223 = 0;
                  return D.24223;
                  <D.24322>:
                  goto <D.24323>;
                  <D.24320>:
                  etype.147 = etype;
                  D.24325 = etype.147 == 80;
                  D.24326 = etype.147 == 18;
                  D.24327 = D.24325 | D.24326;
                  if (D.24327 != 0) goto <D.24328>; else goto <D.24329>;
                  <D.24328>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24330>;
                  <D.24329>:
                  etype.148 = etype;
                  D.24332 = etype.148 + 4294967294;
                  D.24333 = D.24332 <= 12;
                  D.24334 = etype.148 == 81;
                  D.24335 = D.24333 | D.24334;
                  if (D.24335 != 0) goto <D.24336>; else goto <D.24337>;
                  <D.24336>:
                  etype.146 = etype;
                  if (etype.146 != 81) goto <D.24339>; else goto <D.24340>;
                  <D.24339>:
                  etype.146 = etype;
                  iftmp.149 = (unsigned char) etype.146;
                  goto <D.24341>;
                  <D.24340>:
                  iftmp.149 = 28;
                  <D.24341>:
                  simple_type.type = iftmp.149;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24342>;
                  <D.24337>:
                  D.24217 = ctx->report_error;
                  if (D.24217 != 0) goto <D.24343>; else goto <D.24344>;
                  <D.24343>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    etype.146 = etype;
                    D.24345 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.146);
                    vinfo->info.message = D.24345;
                    vinfo->exception_type = 3;
                    D.24221 = ctx->errors;
                    D.24346 = monoeg_g_slist_prepend (D.24221, vinfo);
                    ctx->errors = D.24346;
                  }
                  <D.24344>:
                  ctx->valid = 0;
                  D.24223 = 0;
                  return D.24223;
                  <D.24342>:
                  <D.24330>:
                  <D.24323>:
                  D.24347 = mono_array_class_get (klass, 1);
                  type = &D.24347->byval_arg;
                }
              finally
                {
                  etype = {CLOBBER};
                }
            }
            goto <D.24348>;
            <D.24310>:
            D.24217 = ctx->report_error;
            if (D.24217 != 0) goto <D.24349>; else goto <D.24350>;
            <D.24349>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              kind.145 = kind;
              D.24351 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter type %x", kind.145);
              vinfo->info.message = D.24351;
              vinfo->exception_type = 3;
              D.24221 = ctx->errors;
              D.24352 = monoeg_g_slist_prepend (D.24221, vinfo);
              ctx->errors = D.24352;
            }
            <D.24350>:
            ctx->valid = 0;
            D.24223 = 0;
            return D.24223;
            <D.24348>:
            <D.24308>:
            <D.24304>:
            <D.24300>:
            <D.24295>:
            D.24353 = is_valid_ser_string (ctx, &ptr, end);
            if (D.24353 == 0) goto <D.24354>; else goto <D.24355>;
            <D.24354>:
            D.24223 = 0;
            return D.24223;
            <D.24355>:
            D.24356 = is_valid_fixed_param (ctx, type, &ptr, end);
            if (D.24356 == 0) goto <D.24357>; else goto <D.24358>;
            <D.24357>:
            D.24223 = 0;
            return D.24223;
            <D.24358>:
          }
        finally
          {
            simple_type = {CLOBBER};
            kind = {CLOBBER};
          }
      }
      i = i + 1;
      <D.18574>:
      i.150 = (unsigned int) i;
      num_named.151 = num_named;
      if (i.150 < num_named.151) goto <D.18573>; else goto <D.18575>;
      <D.18575>:
      D.24223 = 1;
      return D.24223;
    }
  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.152;
  int D.24368;
  struct MonoClass * D.24371;
  const char * str_start.153;
  unsigned int str_len.154;
  int D.24377;
  gchar * D.24380;
  struct GSList * D.24381;
  struct GSList * D.24382;
  unsigned int D.24383;
  sizetype D.24384;
  char * D.24385;
  struct MonoImage * D.24386;
  gchar * D.24391;
  struct GSList * D.24392;
  unsigned char D.24396;
  unsigned char D.24397;
  const char * D.24400;
  const char * D.24401;
  gchar * D.24402;
  struct GSList * D.24403;
  const char * ptr.155;
  struct MonoType * type;
  struct MonoClass * klass;
  const char * str_start;
  const char * ptr;
  char * enum_name;
  guint32 str_len;

  try
    {
      str_start = 0B;
      ptr.152 = *_ptr;
      ptr = ptr.152;
      str_len = 0;
      D.24368 = is_valid_ser_string_full (ctx, &str_start, &str_len, &ptr, end);
      if (D.24368 == 0) goto <D.24369>; else goto <D.24370>;
      <D.24369>:
      D.24371 = 0B;
      return D.24371;
      <D.24370>:
      str_start.153 = str_start;
      if (str_start.153 == 0B) goto <D.24372>; else goto <D.24375>;
      <D.24375>:
      str_len.154 = str_len;
      if (str_len.154 == 0) goto <D.24372>; else goto <D.24373>;
      <D.24372>:
      D.24377 = ctx->report_error;
      if (D.24377 != 0) goto <D.24378>; else goto <D.24379>;
      <D.24378>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24380 = monoeg_strdup ("CustomAttribute: Null or empty enum name");
        vinfo->info.message = D.24380;
        vinfo->exception_type = 3;
        D.24381 = ctx->errors;
        D.24382 = monoeg_g_slist_prepend (D.24381, vinfo);
        ctx->errors = D.24382;
      }
      <D.24379>:
      ctx->valid = 0;
      D.24371 = 0B;
      return D.24371;
      <D.24373>:
      str_len.154 = str_len;
      D.24383 = str_len.154 + 1;
      str_start.153 = str_start;
      enum_name = monoeg_g_memdup (str_start.153, D.24383);
      str_len.154 = str_len;
      D.24384 = (sizetype) str_len.154;
      D.24385 = enum_name + D.24384;
      *D.24385 = 0;
      D.24386 = ctx->image;
      type = mono_reflection_type_from_name (enum_name, D.24386);
      if (type == 0B) goto <D.24387>; else goto <D.24388>;
      <D.24387>:
      D.24377 = ctx->report_error;
      if (D.24377 != 0) goto <D.24389>; else goto <D.24390>;
      <D.24389>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24391 = monoeg_g_strdup_printf ("CustomAttribute: Invalid enum class %s", enum_name);
        vinfo->info.message = D.24391;
        vinfo->exception_type = 3;
        D.24381 = ctx->errors;
        D.24392 = monoeg_g_slist_prepend (D.24381, vinfo);
        ctx->errors = D.24392;
      }
      <D.24390>:
      ctx->valid = 0;
      monoeg_g_free (enum_name);
      D.24371 = 0B;
      return D.24371;
      <D.24388>:
      monoeg_g_free (enum_name);
      klass = mono_class_from_mono_type (type);
      if (klass == 0B) goto <D.24393>; else goto <D.24395>;
      <D.24395>:
      D.24396 = BIT_FIELD_REF <*klass, 8, 256>;
      D.24397 = D.24396 & 16;
      if (D.24397 == 0) goto <D.24393>; else goto <D.24394>;
      <D.24393>:
      D.24377 = ctx->report_error;
      if (D.24377 != 0) goto <D.24398>; else goto <D.24399>;
      <D.24398>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24400 = klass->name;
        D.24401 = klass->name_space;
        D.24402 = monoeg_g_strdup_printf ("CustomAttribute:Class %s::%s is not an enum", D.24401, D.24400);
        vinfo->info.message = D.24402;
        vinfo->exception_type = 3;
        D.24381 = ctx->errors;
        D.24403 = monoeg_g_slist_prepend (D.24381, vinfo);
        ctx->errors = D.24403;
      }
      <D.24399>:
      ctx->valid = 0;
      D.24371 = 0B;
      return D.24371;
      <D.24394>:
      ptr.155 = ptr;
      *_ptr = ptr.155;
      D.24371 = klass;
      return D.24371;
    }
  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.156;
  const char * ptr.157;
  int D.24411;
  gchar * D.24414;
  struct GSList * D.24415;
  struct GSList * D.24416;
  gboolean D.24417;
  char D.24418;
  const char * D.24421;
  int D.24422;
  gchar * D.24427;
  struct GSList * D.24428;
  unsigned int size.158;
  sizetype D.24432;
  const char * D.24433;
  long unsigned int D.24435;
  long unsigned int D.24436;
  long unsigned int ptr.159;
  gchar * D.24440;
  struct GSList * D.24441;
  guint32 size;
  const char * ptr;

  try
    {
      size = 0;
      ptr.156 = *_ptr;
      ptr = ptr.156;
      *str_start = 0B;
      *str_len = 0;
      ptr.157 = ptr;
      if (ptr.157 >= end) goto <D.24409>; else goto <D.24410>;
      <D.24409>:
      D.24411 = ctx->report_error;
      if (D.24411 != 0) goto <D.24412>; else goto <D.24413>;
      <D.24412>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24414 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24414;
        vinfo->exception_type = 3;
        D.24415 = ctx->errors;
        D.24416 = monoeg_g_slist_prepend (D.24415, vinfo);
        ctx->errors = D.24416;
      }
      <D.24413>:
      ctx->valid = 0;
      D.24417 = 0;
      return D.24417;
      <D.24410>:
      ptr.157 = ptr;
      D.24418 = *ptr.157;
      if (D.24418 == -1) goto <D.24419>; else goto <D.24420>;
      <D.24419>:
      ptr.157 = ptr;
      D.24421 = ptr.157 + 1;
      *_ptr = D.24421;
      D.24417 = 1;
      return D.24417;
      <D.24420>:
      D.24422 = safe_read_compressed_int (&ptr, end, &size);
      if (D.24422 == 0) goto <D.24423>; else goto <D.24424>;
      <D.24423>:
      D.24411 = ctx->report_error;
      if (D.24411 != 0) goto <D.24425>; else goto <D.24426>;
      <D.24425>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24427 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24427;
        vinfo->exception_type = 3;
        D.24415 = ctx->errors;
        D.24428 = monoeg_g_slist_prepend (D.24415, vinfo);
        ctx->errors = D.24428;
      }
      <D.24426>:
      ctx->valid = 0;
      D.24417 = 0;
      return D.24417;
      <D.24424>:
      ptr.157 = ptr;
      size.158 = size;
      D.24432 = (sizetype) size.158;
      D.24433 = ptr.157 + D.24432;
      if (D.24433 > end) goto <D.24429>; else goto <D.24434>;
      <D.24434>:
      size.158 = size;
      D.24435 = (long unsigned int) size.158;
      D.24436 = ~D.24435;
      ptr.157 = ptr;
      ptr.159 = (long unsigned int) ptr.157;
      if (D.24436 < ptr.159) goto <D.24429>; else goto <D.24430>;
      <D.24429>:
      D.24411 = ctx->report_error;
      if (D.24411 != 0) goto <D.24438>; else goto <D.24439>;
      <D.24438>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24440 = monoeg_strdup ("CustomAttribute: Not enough room for string");
        vinfo->info.message = D.24440;
        vinfo->exception_type = 3;
        D.24415 = ctx->errors;
        D.24441 = monoeg_g_slist_prepend (D.24415, vinfo);
        ctx->errors = D.24441;
      }
      <D.24439>:
      ctx->valid = 0;
      D.24417 = 0;
      return D.24417;
      <D.24430>:
      ptr.157 = ptr;
      *str_start = ptr.157;
      size.158 = size;
      *str_len = size.158;
      ptr.157 = ptr;
      size.158 = size;
      D.24432 = (sizetype) size.158;
      D.24433 = ptr.157 + D.24432;
      *_ptr = D.24433;
      D.24417 = 1;
      return D.24417;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

  try
    {
      D.24444 = is_valid_ser_string_full (ctx, &dummy_str, &dummy_int, _ptr, end);
      return D.24444;
    }
  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.160;
  unsigned char D.24448;
  const char * ptr.161;
  gboolean D.24450;
  int D.24451;
  int D.24454;
  gchar * D.24457;
  struct GSList * D.24458;
  struct GSList * D.24459;
  unsigned int sub_type.162;
  unsigned int D.24461;
  unsigned char D.24468;
  int D.24473;
  gchar * D.24478;
  struct GSList * D.24479;
  unsigned int etype.163;
  unsigned int etype.164;
  _Bool D.24487;
  _Bool D.24488;
  _Bool D.24489;
  unsigned int etype.165;
  unsigned int D.24494;
  _Bool D.24495;
  _Bool D.24496;
  _Bool D.24497;
  unsigned char iftmp.166;
  gchar * D.24507;
  struct GSList * D.24508;
  gchar * D.24511;
  struct GSList * D.24512;
  struct MonoClass * D.24513;
  const char * D.24518;
  const char * D.24519;
  gchar * D.24520;
  struct GSList * D.24521;
  unsigned char D.24525;
  unsigned char D.24526;
  gchar * D.24529;
  struct GSList * D.24530;
  int D.24531;
  gchar * D.24536;
  struct GSList * D.24537;
  int D.24538;
  gchar * D.24543;
  struct GSList * D.24544;
  unsigned int element_count.167;
  int D.24548;
  gchar * D.24553;
  struct GSList * D.24554;
  sizetype D.24557;
  const char * D.24558;
  long unsigned int D.24560;
  long unsigned int D.24561;
  long unsigned int ptr.168;
  gchar * D.24565;
  struct GSList * D.24566;
  struct MonoClass * klass;
  const char * ptr;
  int elem_size;
  guint32 element_count;
  guint32 i;
  int type;
  void handle_enum = <<< error >>>;

  try
    {
      ptr.160 = *_ptr;
      ptr = ptr.160;
      elem_size = 0;
      klass = mono_type->data.klass;
      D.24448 = mono_type->type;
      type = (int) D.24448;
      handle_enum:
      switch (type) <default: <D.18535>, case 2: <D.18503>, case 3: <D.18509>, case 4: <D.18504>, case 5: <D.18505>, case 6: <D.18507>, case 7: <D.18508>, case 8: <D.18510>, case 9: <D.18511>, case 10: <D.18513>, case 11: <D.18514>, case 12: <D.18512>, case 13: <D.18515>, case 14: <D.18516>, case 17: <D.18527>, case 18: <D.18525>, case 28: <D.18517>, case 29: <D.18529>>
      <D.18503>:
      <D.18504>:
      <D.18505>:
      elem_size = 1;
      goto <D.18506>;
      <D.18507>:
      <D.18508>:
      <D.18509>:
      elem_size = 2;
      goto <D.18506>;
      <D.18510>:
      <D.18511>:
      <D.18512>:
      elem_size = 4;
      goto <D.18506>;
      <D.18513>:
      <D.18514>:
      <D.18515>:
      elem_size = 8;
      goto <D.18506>;
      <D.18516>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.24450 = is_valid_ser_string (ctx, _ptr, end);
      return D.24450;
      <D.18517>:
      {
        unsigned int sub_type;

        try
          {
            sub_type = 0;
            D.24451 = safe_read (&ptr, end, &sub_type, 1);
            if (D.24451 == 0) goto <D.24452>; else goto <D.24453>;
            <D.24452>:
            D.24454 = ctx->report_error;
            if (D.24454 != 0) goto <D.24455>; else goto <D.24456>;
            <D.24455>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24457 = monoeg_strdup ("CustomAttribute: Not enough room for array type");
              vinfo->info.message = D.24457;
              vinfo->exception_type = 3;
              D.24458 = ctx->errors;
              D.24459 = monoeg_g_slist_prepend (D.24458, vinfo);
              ctx->errors = D.24459;
            }
            <D.24456>:
            ctx->valid = 0;
            D.24450 = 0;
            return D.24450;
            <D.24453>:
            sub_type.162 = sub_type;
            D.24461 = sub_type.162 + 4294967294;
            if (D.24461 <= 12) goto <D.24462>; else goto <D.24463>;
            <D.24462>:
            sub_type.162 = sub_type;
            type = (int) sub_type.162;
            goto handle_enum;
            <D.24463>:
            sub_type.162 = sub_type;
            if (sub_type.162 == 85) goto <D.24464>; else goto <D.24465>;
            <D.24464>:
            klass = get_enum_by_encoded_name (ctx, &ptr, end);
            if (klass == 0B) goto <D.24466>; else goto <D.24467>;
            <D.24466>:
            D.24450 = 0;
            return D.24450;
            <D.24467>:
            klass = klass->element_class;
            D.24468 = klass->byval_arg.type;
            type = (int) D.24468;
            goto handle_enum;
            <D.24465>:
            sub_type.162 = sub_type;
            if (sub_type.162 == 80) goto <D.24469>; else goto <D.24470>;
            <D.24469>:
            ptr.161 = ptr;
            *_ptr = ptr.161;
            D.24450 = is_valid_ser_string (ctx, _ptr, end);
            return D.24450;
            <D.24470>:
            sub_type.162 = sub_type;
            if (sub_type.162 == 29) goto <D.24471>; else goto <D.24472>;
            <D.24471>:
            {
              struct MonoType simple_type;
              unsigned int etype;

              try
                {
                  simple_type = {};
                  etype = 0;
                  D.24473 = safe_read (&ptr, end, &etype, 1);
                  if (D.24473 == 0) goto <D.24474>; else goto <D.24475>;
                  <D.24474>:
                  D.24454 = ctx->report_error;
                  if (D.24454 != 0) goto <D.24476>; else goto <D.24477>;
                  <D.24476>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    D.24478 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24478;
                    vinfo->exception_type = 3;
                    D.24458 = ctx->errors;
                    D.24479 = monoeg_g_slist_prepend (D.24458, vinfo);
                    ctx->errors = D.24479;
                  }
                  <D.24477>:
                  ctx->valid = 0;
                  D.24450 = 0;
                  return D.24450;
                  <D.24475>:
                  etype.163 = etype;
                  if (etype.163 == 85) goto <D.24481>; else goto <D.24482>;
                  <D.24481>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24483>; else goto <D.24484>;
                  <D.24483>:
                  D.24450 = 0;
                  return D.24450;
                  <D.24484>:
                  goto <D.24485>;
                  <D.24482>:
                  etype.164 = etype;
                  D.24487 = etype.164 == 80;
                  D.24488 = etype.164 == 18;
                  D.24489 = D.24487 | D.24488;
                  if (D.24489 != 0) goto <D.24490>; else goto <D.24491>;
                  <D.24490>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24492>;
                  <D.24491>:
                  etype.165 = etype;
                  D.24494 = etype.165 + 4294967294;
                  D.24495 = D.24494 <= 12;
                  D.24496 = etype.165 == 81;
                  D.24497 = D.24495 | D.24496;
                  if (D.24497 != 0) goto <D.24498>; else goto <D.24499>;
                  <D.24498>:
                  etype.163 = etype;
                  if (etype.163 != 81) goto <D.24501>; else goto <D.24502>;
                  <D.24501>:
                  etype.163 = etype;
                  iftmp.166 = (unsigned char) etype.163;
                  goto <D.24503>;
                  <D.24502>:
                  iftmp.166 = 28;
                  <D.24503>:
                  simple_type.type = iftmp.166;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24504>;
                  <D.24499>:
                  D.24454 = ctx->report_error;
                  if (D.24454 != 0) goto <D.24505>; else goto <D.24506>;
                  <D.24505>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    etype.163 = etype;
                    D.24507 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.163);
                    vinfo->info.message = D.24507;
                    vinfo->exception_type = 3;
                    D.24458 = ctx->errors;
                    D.24508 = monoeg_g_slist_prepend (D.24458, vinfo);
                    ctx->errors = D.24508;
                  }
                  <D.24506>:
                  ctx->valid = 0;
                  D.24450 = 0;
                  return D.24450;
                  <D.24504>:
                  <D.24492>:
                  <D.24485>:
                  type = 29;
                  goto handle_enum;
                }
              finally
                {
                  simple_type = {CLOBBER};
                  etype = {CLOBBER};
                }
            }
            <D.24472>:
            D.24454 = ctx->report_error;
            if (D.24454 != 0) goto <D.24509>; else goto <D.24510>;
            <D.24509>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              sub_type.162 = sub_type;
              D.24511 = monoeg_g_strdup_printf ("CustomAttribute: Invalid boxed object type %x", sub_type.162);
              vinfo->info.message = D.24511;
              vinfo->exception_type = 3;
              D.24458 = ctx->errors;
              D.24512 = monoeg_g_slist_prepend (D.24458, vinfo);
              ctx->errors = D.24512;
            }
            <D.24510>:
            ctx->valid = 0;
            D.24450 = 0;
            return D.24450;
          }
        finally
          {
            sub_type = {CLOBBER};
          }
      }
      <D.18525>:
      D.24513 = mono_defaults.systemtype_class;
      if (D.24513 != klass) goto <D.24514>; else goto <D.24515>;
      <D.24514>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24516>; else goto <D.24517>;
      <D.24516>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24518 = klass->name;
        D.24519 = klass->name_space;
        D.24520 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24519, D.24518);
        vinfo->info.message = D.24520;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24521 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24521;
      }
      <D.24517>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.24515>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.24450 = is_valid_ser_string (ctx, _ptr, end);
      return D.24450;
      <D.18527>:
      if (klass == 0B) goto <D.24522>; else goto <D.24524>;
      <D.24524>:
      D.24525 = BIT_FIELD_REF <*klass, 8, 256>;
      D.24526 = D.24525 & 16;
      if (D.24526 == 0) goto <D.24522>; else goto <D.24523>;
      <D.24522>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24527>; else goto <D.24528>;
      <D.24527>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24518 = klass->name;
        D.24519 = klass->name_space;
        D.24529 = monoeg_g_strdup_printf ("CustomAttribute: Invalid valuetype parameter expected enum %s:%s ", D.24519, D.24518);
        vinfo->info.message = D.24529;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24530 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24530;
      }
      <D.24528>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.24523>:
      klass = klass->element_class;
      D.24468 = klass->byval_arg.type;
      type = (int) D.24468;
      goto handle_enum;
      <D.18529>:
      mono_type = &klass->byval_arg;
      D.24531 = is_valid_cattr_type (mono_type);
      if (D.24531 == 0) goto <D.24532>; else goto <D.24533>;
      <D.24532>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24534>; else goto <D.24535>;
      <D.24534>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24518 = klass->name;
        D.24519 = klass->name_space;
        D.24536 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %s:%s ", D.24519, D.24518);
        vinfo->info.message = D.24536;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24537 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24537;
      }
      <D.24535>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.24533>:
      D.24538 = safe_read (&ptr, end, &element_count, 4);
      if (D.24538 == 0) goto <D.24539>; else goto <D.24540>;
      <D.24539>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24541>; else goto <D.24542>;
      <D.24541>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24518 = klass->name;
        D.24519 = klass->name_space;
        D.24543 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24519, D.24518);
        vinfo->info.message = D.24543;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24544 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24544;
      }
      <D.24542>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.24540>:
      element_count.167 = element_count;
      if (element_count.167 == 4294967295) goto <D.24546>; else goto <D.24547>;
      <D.24546>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.24450 = 1;
      return D.24450;
      <D.24547>:
      i = 0;
      goto <D.18533>;
      <D.18532>:
      D.24548 = is_valid_fixed_param (ctx, mono_type, &ptr, end);
      if (D.24548 == 0) goto <D.24549>; else goto <D.24550>;
      <D.24549>:
      D.24450 = 0;
      return D.24450;
      <D.24550>:
      i = i + 1;
      <D.18533>:
      element_count.167 = element_count;
      if (i < element_count.167) goto <D.18532>; else goto <D.18534>;
      <D.18534>:
      ptr.161 = ptr;
      *_ptr = ptr.161;
      D.24450 = 1;
      return D.24450;
      <D.18535>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24551>; else goto <D.24552>;
      <D.24551>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24553 = monoeg_g_strdup_printf ("CustomAttribute: Invalid parameter type %x ", type);
        vinfo->info.message = D.24553;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24554 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24554;
      }
      <D.24552>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.18506>:
      ptr.161 = ptr;
      D.24557 = (sizetype) elem_size;
      D.24558 = ptr.161 + D.24557;
      if (D.24558 > end) goto <D.24555>; else goto <D.24559>;
      <D.24559>:
      D.24560 = (long unsigned int) elem_size;
      D.24561 = ~D.24560;
      ptr.161 = ptr;
      ptr.168 = (long unsigned int) ptr.161;
      if (D.24561 < ptr.168) goto <D.24555>; else goto <D.24556>;
      <D.24555>:
      D.24454 = ctx->report_error;
      if (D.24454 != 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24565 = monoeg_strdup ("CustomAttribute: Not enough space for element");
        vinfo->info.message = D.24565;
        vinfo->exception_type = 3;
        D.24458 = ctx->errors;
        D.24566 = monoeg_g_slist_prepend (D.24458, vinfo);
        ctx->errors = D.24566;
      }
      <D.24564>:
      ctx->valid = 0;
      D.24450 = 0;
      return D.24450;
      <D.24556>:
      ptr.161 = ptr;
      D.24557 = (sizetype) elem_size;
      D.24558 = ptr.161 + D.24557;
      *_ptr = D.24558;
      D.24450 = 1;
      return D.24450;
    }
  finally
    {
      ptr = {CLOBBER};
      element_count = {CLOBBER};
    }
}


is_valid_cattr_type (struct MonoType * type)
{
  unsigned char D.24573;
  _Bool D.24574;
  unsigned char D.24575;
  _Bool D.24576;
  _Bool D.24577;
  gboolean D.24580;
  unsigned char D.24581;
  int iftmp.169;
  unsigned char D.24588;
  unsigned char D.24589;
  struct MonoClass * D.24593;
  struct MonoClass * D.24594;
  _Bool D.24595;
  struct MonoClass * klass;

  D.24573 = type->type;
  D.24574 = D.24573 == 28;
  D.24575 = D.24573 + 254;
  D.24576 = D.24575 <= 12;
  D.24577 = D.24574 | D.24576;
  if (D.24577 != 0) goto <D.24578>; else goto <D.24579>;
  <D.24578>:
  D.24580 = 1;
  return D.24580;
  <D.24579>:
  D.24581 = type->type;
  if (D.24581 == 17) goto <D.24582>; else goto <D.24583>;
  <D.24582>:
  klass = mono_class_from_mono_type (type);
  if (klass != 0B) goto <D.24587>; else goto <D.24585>;
  <D.24587>:
  D.24588 = BIT_FIELD_REF <*klass, 8, 256>;
  D.24589 = D.24588 & 16;
  if (D.24589 != 0) goto <D.24590>; else goto <D.24585>;
  <D.24590>:
  iftmp.169 = 1;
  goto <D.24586>;
  <D.24585>:
  iftmp.169 = 0;
  <D.24586>:
  D.24580 = iftmp.169;
  return D.24580;
  <D.24583>:
  D.24581 = type->type;
  if (D.24581 == 18) goto <D.24591>; else goto <D.24592>;
  <D.24591>:
  D.24593 = mono_class_from_mono_type (type);
  D.24594 = mono_defaults.systemtype_class;
  D.24595 = D.24593 == D.24594;
  D.24580 = (gboolean) D.24595;
  return D.24580;
  <D.24592>:
  D.24580 = 0;
  return D.24580;
}


verify_field_marshal_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24597;
  unsigned int D.24598;
  int D.24599;
  int D.24602;
  gchar * D.24605;
  struct GSList * D.24606;
  struct GSList * D.24607;
  <unnamed-unsigned:24> D.24608;
  int D.24609;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24597 = ctx->image;
      table = &D.24597->tables[13];
      i = 0;
      goto <D.19039>;
      <D.19038>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24598 = data[1];
      D.24599 = is_valid_marshal_spec (ctx, D.24598);
      if (D.24599 == 0) goto <D.24600>; else goto <D.24601>;
      <D.24600>:
      D.24602 = ctx->report_error;
      if (D.24602 != 0) goto <D.24603>; else goto <D.24604>;
      <D.24603>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24598 = data[1];
        D.24605 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, D.24598);
        vinfo->info.message = D.24605;
        vinfo->exception_type = 3;
        D.24606 = ctx->errors;
        D.24607 = monoeg_g_slist_prepend (D.24606, vinfo);
        ctx->errors = D.24607;
      }
      <D.24604>:
      ctx->valid = 0;
      return;
      <D.24601>:
      i = i + 1;
      <D.19039>:
      D.24608 = table->rows;
      D.24609 = (int) D.24608;
      if (D.24609 > i) goto <D.19038>; else goto <D.19040>;
      <D.19040>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_marshal_spec (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24613;
  struct MonoStreamHeader * D.24614;
  gboolean D.24615;
  int iftmp.170;
  unsigned int D.24619;
  unsigned int D.24621;
  struct OffsetAndSize blob;

  try
    {
      D.24613 = ctx->image;
      D.24614 = &D.24613->heap_blob;
      blob = get_metadata_stream (ctx, D.24614);
      D.24619 = blob.size;
      if (D.24619 != 0) goto <D.24620>; else goto <D.24617>;
      <D.24620>:
      D.24619 = blob.size;
      D.24621 = D.24619 + 4294967295;
      if (D.24621 >= offset) goto <D.24622>; else goto <D.24617>;
      <D.24622>:
      iftmp.170 = 1;
      goto <D.24618>;
      <D.24617>:
      iftmp.170 = 0;
      <D.24618>:
      D.24615 = iftmp.170;
      return D.24615;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_decl_security_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24625;
  unsigned int D.24626;
  int D.24627;
  int D.24630;
  gchar * D.24633;
  struct GSList * D.24634;
  struct GSList * D.24635;
  <unnamed-unsigned:24> D.24636;
  int D.24637;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24625 = ctx->image;
      table = &D.24625->tables[14];
      i = 0;
      goto <D.19061>;
      <D.19060>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24626 = data[2];
      D.24627 = is_valid_permission_set (ctx, D.24626);
      if (D.24627 == 0) goto <D.24628>; else goto <D.24629>;
      <D.24628>:
      D.24630 = ctx->report_error;
      if (D.24630 != 0) goto <D.24631>; else goto <D.24632>;
      <D.24631>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24626 = data[2];
        D.24633 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, D.24626);
        vinfo->info.message = D.24633;
        vinfo->exception_type = 3;
        D.24634 = ctx->errors;
        D.24635 = monoeg_g_slist_prepend (D.24634, vinfo);
        ctx->errors = D.24635;
      }
      <D.24632>:
      ctx->valid = 0;
      return;
      <D.24629>:
      i = i + 1;
      <D.19061>:
      D.24636 = table->rows;
      D.24637 = (int) D.24636;
      if (D.24637 > i) goto <D.19060>; else goto <D.19062>;
      <D.19062>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_permission_set (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.24641;
  struct MonoStreamHeader * D.24642;
  gboolean D.24643;
  int iftmp.171;
  unsigned int D.24647;
  unsigned int D.24649;
  struct OffsetAndSize blob;

  try
    {
      D.24641 = ctx->image;
      D.24642 = &D.24641->heap_blob;
      blob = get_metadata_stream (ctx, D.24642);
      D.24647 = blob.size;
      if (D.24647 != 0) goto <D.24648>; else goto <D.24645>;
      <D.24648>:
      D.24647 = blob.size;
      D.24649 = D.24647 + 4294967295;
      if (D.24649 >= offset) goto <D.24650>; else goto <D.24645>;
      <D.24650>:
      iftmp.171 = 1;
      goto <D.24646>;
      <D.24645>:
      iftmp.171 = 0;
      <D.24646>:
      D.24643 = iftmp.171;
      return D.24643;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_standalonesig_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24653;
  unsigned int D.24654;
  int D.24655;
  int D.24658;
  gchar * D.24661;
  struct GSList * D.24662;
  struct GSList * D.24663;
  <unnamed-unsigned:24> D.24664;
  int D.24665;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24653 = ctx->image;
      table = &D.24653->tables[17];
      i = 0;
      goto <D.19113>;
      <D.19112>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24654 = data[0];
      D.24655 = is_valid_standalonesig_blob (ctx, D.24654);
      if (D.24655 == 0) goto <D.24656>; else goto <D.24657>;
      <D.24656>:
      D.24658 = ctx->report_error;
      if (D.24658 != 0) goto <D.24659>; else goto <D.24660>;
      <D.24659>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24654 = data[0];
        D.24661 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d Signature field 0x%08x", i, D.24654);
        vinfo->info.message = D.24661;
        vinfo->exception_type = 3;
        D.24662 = ctx->errors;
        D.24663 = monoeg_g_slist_prepend (D.24662, vinfo);
        ctx->errors = D.24663;
      }
      <D.24660>:
      ctx->valid = 0;
      return;
      <D.24657>:
      i = i + 1;
      <D.19113>:
      D.24664 = table->rows;
      D.24665 = (int) D.24664;
      if (D.24665 > i) goto <D.19112>; else goto <D.19114>;
      <D.19114>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_standalonesig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24669;
  int D.24672;
  gchar * D.24675;
  struct GSList * D.24676;
  struct GSList * D.24677;
  gboolean D.24678;
  const char * ptr.172;
  unsigned int size.173;
  sizetype D.24681;
  int D.24682;
  gchar * D.24687;
  struct GSList * D.24688;
  const char * ptr.174;
  unsigned int signature.175;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24669 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24669 == 0) goto <D.24670>; else goto <D.24671>;
      <D.24670>:
      D.24672 = ctx->report_error;
      if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
      <D.24673>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24675 = monoeg_strdup ("StandAloneSig: Could not decode signature header");
        vinfo->info.message = D.24675;
        vinfo->exception_type = 3;
        D.24676 = ctx->errors;
        D.24677 = monoeg_g_slist_prepend (D.24676, vinfo);
        ctx->errors = D.24677;
      }
      <D.24674>:
      ctx->valid = 0;
      D.24678 = 0;
      return D.24678;
      <D.24671>:
      ptr.172 = ptr;
      size.173 = size;
      D.24681 = (sizetype) size.173;
      end = ptr.172 + D.24681;
      D.24682 = safe_read (&ptr, end, &signature, 1);
      if (D.24682 == 0) goto <D.24683>; else goto <D.24684>;
      <D.24683>:
      D.24672 = ctx->report_error;
      if (D.24672 != 0) goto <D.24685>; else goto <D.24686>;
      <D.24685>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24687 = monoeg_strdup ("StandAloneSig: Not enough room for the call conv");
        vinfo->info.message = D.24687;
        vinfo->exception_type = 3;
        D.24676 = ctx->errors;
        D.24688 = monoeg_g_slist_prepend (D.24676, vinfo);
        ctx->errors = D.24688;
      }
      <D.24686>:
      ctx->valid = 0;
      D.24678 = 0;
      return D.24678;
      <D.24684>:
      ptr.172 = ptr;
      ptr.174 = ptr.172 + 18446744073709551615;
      ptr = ptr.174;
      signature.175 = signature;
      if (signature.175 == 7) goto <D.24691>; else goto <D.24692>;
      <D.24691>:
      D.24678 = parse_locals_signature (ctx, &ptr, end);
      return D.24678;
      <D.24692>:
      signature.175 = signature;
      if (signature.175 == 6) goto <D.24693>; else goto <D.24694>;
      <D.24693>:
      D.24678 = parse_field (ctx, &ptr, end);
      return D.24678;
      <D.24694>:
      D.24678 = parse_method_signature (ctx, &ptr, end, 1, 1);
      return D.24678;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_locals_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.176;
  int D.24698;
  int D.24701;
  gchar * D.24704;
  struct GSList * D.24705;
  struct GSList * D.24706;
  gboolean D.24707;
  unsigned int sig.177;
  gchar * D.24713;
  struct GSList * D.24714;
  int D.24715;
  gchar * D.24720;
  struct GSList * D.24721;
  int D.24722;
  gchar * D.24727;
  struct GSList * D.24728;
  int D.24731;
  gchar * D.24736;
  struct GSList * D.24737;
  int D.24738;
  gchar * D.24743;
  struct GSList * D.24744;
  unsigned int sig.178;
  unsigned int D.24746;
  _Bool D.24747;
  _Bool D.24748;
  _Bool D.24749;
  int D.24752;
  gchar * D.24757;
  struct GSList * D.24758;
  gchar * D.24763;
  struct GSList * D.24764;
  const char * ptr.179;
  const char * ptr.180;
  int D.24769;
  gchar * D.24774;
  struct GSList * D.24775;
  unsigned int locals_count.181;
  unsigned int sig;
  unsigned int locals_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      locals_count = 0;
      ptr.176 = *_ptr;
      ptr = ptr.176;
      D.24698 = safe_read (&ptr, end, &sig, 1);
      if (D.24698 == 0) goto <D.24699>; else goto <D.24700>;
      <D.24699>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24702>; else goto <D.24703>;
      <D.24702>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24704 = monoeg_strdup ("LocalsSig: Not enough room for signature");
        vinfo->info.message = D.24704;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24706 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24706;
      }
      <D.24703>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24700>:
      sig.177 = sig;
      if (sig.177 != 7) goto <D.24709>; else goto <D.24710>;
      <D.24709>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24711>; else goto <D.24712>;
      <D.24711>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        sig.177 = sig;
        D.24713 = monoeg_g_strdup_printf ("LocalsSig: Signature is not 0x28 or 0x08: %x", sig.177);
        vinfo->info.message = D.24713;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24714 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24714;
      }
      <D.24712>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24710>:
      D.24715 = safe_read_compressed_int (&ptr, end, &locals_count);
      if (D.24715 == 0) goto <D.24716>; else goto <D.24717>;
      <D.24716>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24718>; else goto <D.24719>;
      <D.24718>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24720 = monoeg_strdup ("LocalsSig: Not enough room for the param count");
        vinfo->info.message = D.24720;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24721 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24721;
      }
      <D.24719>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24717>:
      i = 0;
      goto <D.18403>;
      <D.18402>:
      D.24722 = safe_read (&ptr, end, &sig, 1);
      if (D.24722 == 0) goto <D.24723>; else goto <D.24724>;
      <D.24723>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24725>; else goto <D.24726>;
      <D.24725>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24727 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24727;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24728 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24728;
      }
      <D.24726>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24724>:
      goto <D.18396>;
      <D.18395>:
      sig.177 = sig;
      if (sig.177 != 69) goto <D.24729>; else goto <D.24730>;
      <D.24729>:
      D.24731 = parse_custom_mods (ctx, &ptr, end);
      if (D.24731 == 0) goto <D.24732>; else goto <D.24733>;
      <D.24732>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24734>; else goto <D.24735>;
      <D.24734>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24736 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24736;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24737 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24737;
      }
      <D.24735>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24733>:
      <D.24730>:
      D.24738 = safe_read (&ptr, end, &sig, 1);
      if (D.24738 == 0) goto <D.24739>; else goto <D.24740>;
      <D.24739>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24741>; else goto <D.24742>;
      <D.24741>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24743 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.24743;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24744 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24744;
      }
      <D.24742>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24740>:
      <D.18396>:
      sig.178 = sig;
      D.24746 = sig.178 + 4294967265;
      D.24747 = D.24746 <= 1;
      D.24748 = sig.178 == 69;
      D.24749 = D.24747 | D.24748;
      if (D.24749 != 0) goto <D.18395>; else goto <D.18397>;
      <D.18397>:
      sig.177 = sig;
      if (sig.177 == 16) goto <D.24750>; else goto <D.24751>;
      <D.24750>:
      D.24752 = safe_read (&ptr, end, &sig, 1);
      if (D.24752 == 0) goto <D.24753>; else goto <D.24754>;
      <D.24753>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24755>; else goto <D.24756>;
      <D.24755>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24757 = monoeg_g_strdup_printf ("Type: Not enough room for byref type for local %d", i);
        vinfo->info.message = D.24757;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24758 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24758;
      }
      <D.24756>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24754>:
      sig.177 = sig;
      if (sig.177 == 22) goto <D.24759>; else goto <D.24760>;
      <D.24759>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24761>; else goto <D.24762>;
      <D.24761>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24763 = monoeg_g_strdup_printf ("Type: Invalid type typedref& for local %d", i);
        vinfo->info.message = D.24763;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24764 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24764;
      }
      <D.24762>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24760>:
      <D.24751>:
      sig.177 = sig;
      if (sig.177 == 22) goto <D.24765>; else goto <D.24766>;
      <D.24765>:
      // predicted unlikely by continue predictor.
      goto <D.18400>;
      <D.24766>:
      ptr.179 = ptr;
      ptr.180 = ptr.179 + 18446744073709551615;
      ptr = ptr.180;
      D.24769 = parse_type (ctx, &ptr, end);
      if (D.24769 == 0) goto <D.24770>; else goto <D.24771>;
      <D.24770>:
      D.24701 = ctx->report_error;
      if (D.24701 != 0) goto <D.24772>; else goto <D.24773>;
      <D.24772>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24774 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.24774;
        vinfo->exception_type = 3;
        D.24705 = ctx->errors;
        D.24775 = monoeg_g_slist_prepend (D.24705, vinfo);
        ctx->errors = D.24775;
      }
      <D.24773>:
      ctx->valid = 0;
      D.24707 = 0;
      return D.24707;
      <D.24771>:
      <D.18400>:
      i = i + 1;
      <D.18403>:
      locals_count.181 = locals_count;
      if (i < locals_count.181) goto <D.18402>; else goto <D.18404>;
      <D.18404>:
      ptr.179 = ptr;
      *_ptr = ptr.179;
      D.24707 = 1;
      return D.24707;
    }
  finally
    {
      sig = {CLOBBER};
      locals_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_event_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24779;
  unsigned int i.182;
  int D.24783;
  gchar * D.24786;
  struct GSList * D.24787;
  struct GSList * D.24788;
  int D.24789;
  unsigned int D.24790;
  unsigned int D.24792;
  unsigned int D.24794;
  unsigned int D.24795;
  unsigned int D.24798;
  _Bool D.24801;
  _Bool D.24802;
  _Bool D.24803;
  <unnamed-unsigned:24> D.24805;
  int D.24806;
  gchar * D.24811;
  struct GSList * D.24812;
  gchar * D.24817;
  struct GSList * D.24818;
  <unnamed-unsigned:24> D.24819;
  int D.24820;
  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.24779 = ctx->image;
      table = &D.24779->tables[20];
      D.24779 = ctx->image;
      sema_table = &D.24779->tables[24];
      i = 0;
      goto <D.19161>;
      <D.19160>:
      mono_metadata_decode_row (table, i, &data, 3);
      i.182 = (unsigned int) i;
      token = make_coded_token (48, 20, i.182);
      idx = search_sorted_table (ctx, 24, 2, token);
      if (idx == -1) goto <D.24781>; else goto <D.24782>;
      <D.24781>:
      D.24783 = ctx->report_error;
      if (D.24783 != 0) goto <D.24784>; else goto <D.24785>;
      <D.24784>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24786 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn or RemoveOn associated methods", i);
        vinfo->info.message = D.24786;
        vinfo->exception_type = 3;
        D.24787 = ctx->errors;
        D.24788 = monoeg_g_slist_prepend (D.24787, vinfo);
        ctx->errors = D.24788;
      }
      <D.24785>:
      ctx->valid = 0;
      return;
      <D.24782>:
      goto <D.19154>;
      <D.19153>:
      D.24789 = idx + -1;
      D.24790 = mono_metadata_decode_row_col (sema_table, D.24789, 2);
      if (D.24790 != token) goto <D.19152>; else goto <D.24791>;
      <D.24791>:
      idx = idx + -1;
      <D.19154>:
      if (idx > 0) goto <D.19153>; else goto <D.19152>;
      <D.19152>:
      found_remove = 0;
      found_add = found_remove;
      goto <D.19157>;
      <D.19156>:
      mono_metadata_decode_row (sema_table, idx, &sema_data, 3);
      D.24792 = sema_data[2];
      if (D.24792 != token) goto <D.19155>; else goto <D.24793>;
      <D.24793>:
      D.24794 = sema_data[0];
      D.24795 = D.24794 & 8;
      if (D.24795 != 0) goto <D.24796>; else goto <D.24797>;
      <D.24796>:
      found_add = 1;
      <D.24797>:
      D.24794 = sema_data[0];
      D.24798 = D.24794 & 16;
      if (D.24798 != 0) goto <D.24799>; else goto <D.24800>;
      <D.24799>:
      found_remove = 1;
      <D.24800>:
      D.24801 = found_add != 0;
      D.24802 = found_remove != 0;
      D.24803 = D.24801 & D.24802;
      if (D.24803 != 0) goto <D.19155>; else goto <D.24804>;
      <D.24804>:
      idx = idx + 1;
      <D.19157>:
      D.24805 = sema_table->rows;
      D.24806 = (int) D.24805;
      if (D.24806 > idx) goto <D.19156>; else goto <D.19155>;
      <D.19155>:
      if (found_add == 0) goto <D.24807>; else goto <D.24808>;
      <D.24807>:
      D.24783 = ctx->report_error;
      if (D.24783 != 0) goto <D.24809>; else goto <D.24810>;
      <D.24809>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24811 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn associated method", i);
        vinfo->info.message = D.24811;
        vinfo->exception_type = 3;
        D.24787 = ctx->errors;
        D.24812 = monoeg_g_slist_prepend (D.24787, vinfo);
        ctx->errors = D.24812;
      }
      <D.24810>:
      ctx->valid = 0;
      return;
      <D.24808>:
      if (found_remove == 0) goto <D.24813>; else goto <D.24814>;
      <D.24813>:
      D.24783 = ctx->report_error;
      if (D.24783 != 0) goto <D.24815>; else goto <D.24816>;
      <D.24815>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24817 = monoeg_g_strdup_printf ("Invalid Event row %d has no RemoveOn associated method", i);
        vinfo->info.message = D.24817;
        vinfo->exception_type = 3;
        D.24787 = ctx->errors;
        D.24818 = monoeg_g_slist_prepend (D.24787, vinfo);
        ctx->errors = D.24818;
      }
      <D.24816>:
      ctx->valid = 0;
      return;
      <D.24814>:
      i = i + 1;
      <D.19161>:
      D.24819 = table->rows;
      D.24820 = (int) D.24819;
      if (D.24820 > i) goto <D.19160>; else goto <D.19162>;
      <D.19162>:
    }
  finally
    {
      data = {CLOBBER};
      sema_data = {CLOBBER};
    }
}


verify_typespec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24824;
  int D.24825;
  int D.24826;
  unsigned int D.24827;
  unsigned int D.24828;
  int D.24829;
  int D.24832;
  gchar * D.24835;
  struct GSList * D.24836;
  struct GSList * D.24837;
  <unnamed-unsigned:24> D.24838;
  int D.24839;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.24824 = ctx->image;
      table = &D.24824->tables[27];
      i = 0;
      goto <D.19230>;
      <D.19229>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.24825 = i + 1;
      D.24826 = D.24825 | 452984832;
      D.24827 = (unsigned int) D.24826;
      ctx->token = D.24827;
      D.24828 = data[0];
      D.24829 = is_valid_typespec_blob (ctx, D.24828);
      if (D.24829 == 0) goto <D.24830>; else goto <D.24831>;
      <D.24830>:
      D.24832 = ctx->report_error;
      if (D.24832 != 0) goto <D.24833>; else goto <D.24834>;
      <D.24833>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24828 = data[0];
        D.24835 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.24828);
        vinfo->info.message = D.24835;
        vinfo->exception_type = 3;
        D.24836 = ctx->errors;
        D.24837 = monoeg_g_slist_prepend (D.24836, vinfo);
        ctx->errors = D.24837;
      }
      <D.24834>:
      ctx->valid = 0;
      return;
      <D.24831>:
      i = i + 1;
      <D.19230>:
      D.24838 = table->rows;
      D.24839 = (int) D.24838;
      if (D.24839 > i) goto <D.19229>; else goto <D.19231>;
      <D.19231>:
      ctx->token = 0;
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_typespec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24843;
  int D.24846;
  gchar * D.24849;
  struct GSList * D.24850;
  struct GSList * D.24851;
  gboolean D.24852;
  const char * ptr.183;
  unsigned int size.184;
  sizetype D.24855;
  int D.24856;
  int D.24859;
  gchar * D.24864;
  struct GSList * D.24865;
  unsigned int type.185;
  int D.24869;
  gchar * D.24874;
  struct GSList * D.24875;
  gchar * D.24880;
  struct GSList * D.24881;
  const char * ptr.186;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      D.24843 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24843 == 0) goto <D.24844>; else goto <D.24845>;
      <D.24844>:
      D.24846 = ctx->report_error;
      if (D.24846 != 0) goto <D.24847>; else goto <D.24848>;
      <D.24847>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24849 = monoeg_strdup ("TypeSpec: Could not decode signature header");
        vinfo->info.message = D.24849;
        vinfo->exception_type = 3;
        D.24850 = ctx->errors;
        D.24851 = monoeg_g_slist_prepend (D.24850, vinfo);
        ctx->errors = D.24851;
      }
      <D.24848>:
      ctx->valid = 0;
      D.24852 = 0;
      return D.24852;
      <D.24845>:
      ptr.183 = ptr;
      size.184 = size;
      D.24855 = (sizetype) size.184;
      end = ptr.183 + D.24855;
      D.24856 = parse_custom_mods (ctx, &ptr, end);
      if (D.24856 == 0) goto <D.24857>; else goto <D.24858>;
      <D.24857>:
      D.24852 = 0;
      return D.24852;
      <D.24858>:
      D.24859 = safe_read (&ptr, end, &type, 1);
      if (D.24859 == 0) goto <D.24860>; else goto <D.24861>;
      <D.24860>:
      D.24846 = ctx->report_error;
      if (D.24846 != 0) goto <D.24862>; else goto <D.24863>;
      <D.24862>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24864 = monoeg_strdup ("TypeSpec: Not enough room for type");
        vinfo->info.message = D.24864;
        vinfo->exception_type = 3;
        D.24850 = ctx->errors;
        D.24865 = monoeg_g_slist_prepend (D.24850, vinfo);
        ctx->errors = D.24865;
      }
      <D.24863>:
      ctx->valid = 0;
      D.24852 = 0;
      return D.24852;
      <D.24861>:
      type.185 = type;
      if (type.185 == 16) goto <D.24867>; else goto <D.24868>;
      <D.24867>:
      D.24869 = safe_read (&ptr, end, &type, 1);
      if (D.24869 == 0) goto <D.24870>; else goto <D.24871>;
      <D.24870>:
      D.24846 = ctx->report_error;
      if (D.24846 != 0) goto <D.24872>; else goto <D.24873>;
      <D.24872>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24874 = monoeg_strdup ("TypeSpec: Not enough room for byref type");
        vinfo->info.message = D.24874;
        vinfo->exception_type = 3;
        D.24850 = ctx->errors;
        D.24875 = monoeg_g_slist_prepend (D.24850, vinfo);
        ctx->errors = D.24875;
      }
      <D.24873>:
      ctx->valid = 0;
      D.24852 = 0;
      return D.24852;
      <D.24871>:
      type.185 = type;
      if (type.185 == 22) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      D.24846 = ctx->report_error;
      if (D.24846 != 0) goto <D.24878>; else goto <D.24879>;
      <D.24878>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24880 = monoeg_strdup ("TypeSpec: Invalid type typedref&");
        vinfo->info.message = D.24880;
        vinfo->exception_type = 3;
        D.24850 = ctx->errors;
        D.24881 = monoeg_g_slist_prepend (D.24850, vinfo);
        ctx->errors = D.24881;
      }
      <D.24879>:
      ctx->valid = 0;
      D.24852 = 0;
      return D.24852;
      <D.24877>:
      <D.24868>:
      type.185 = type;
      if (type.185 == 22) goto <D.24882>; else goto <D.24883>;
      <D.24882>:
      D.24852 = 1;
      return D.24852;
      <D.24883>:
      ptr.183 = ptr;
      ptr.186 = ptr.183 + 18446744073709551615;
      ptr = ptr.186;
      D.24852 = parse_type (ctx, &ptr, end);
      return D.24852;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_method_spec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24887;
  unsigned int D.24888;
  int D.24889;
  int D.24892;
  gchar * D.24895;
  struct GSList * D.24896;
  struct GSList * D.24897;
  <unnamed-unsigned:24> D.24898;
  int D.24899;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.24887 = ctx->image;
      table = &D.24887->tables[43];
      i = 0;
      goto <D.19388>;
      <D.19387>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.24888 = data[1];
      D.24889 = is_valid_methodspec_blob (ctx, D.24888);
      if (D.24889 == 0) goto <D.24890>; else goto <D.24891>;
      <D.24890>:
      D.24892 = ctx->report_error;
      if (D.24892 != 0) goto <D.24893>; else goto <D.24894>;
      <D.24893>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24888 = data[1];
        D.24895 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, D.24888);
        vinfo->info.message = D.24895;
        vinfo->exception_type = 3;
        D.24896 = ctx->errors;
        D.24897 = monoeg_g_slist_prepend (D.24896, vinfo);
        ctx->errors = D.24897;
      }
      <D.24894>:
      ctx->valid = 0;
      return;
      <D.24891>:
      i = i + 1;
      <D.19388>:
      D.24898 = table->rows;
      D.24899 = (int) D.24898;
      if (D.24899 > i) goto <D.19387>; else goto <D.19389>;
      <D.19389>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_methodspec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.24903;
  int D.24906;
  gchar * D.24909;
  struct GSList * D.24910;
  struct GSList * D.24911;
  gboolean D.24912;
  const char * ptr.187;
  unsigned int size.188;
  sizetype D.24915;
  int D.24916;
  gchar * D.24921;
  struct GSList * D.24922;
  unsigned int type.189;
  gchar * D.24928;
  struct GSList * D.24929;
  int D.24930;
  gchar * D.24935;
  struct GSList * D.24936;
  unsigned int count.190;
  gchar * D.24942;
  struct GSList * D.24943;
  int D.24944;
  int D.24947;
  unsigned int D.24952;
  gchar * D.24953;
  struct GSList * D.24954;
  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.24903 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24903 == 0) goto <D.24904>; else goto <D.24905>;
      <D.24904>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24907>; else goto <D.24908>;
      <D.24907>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24909 = monoeg_strdup ("MethodSpec: Could not decode signature header");
        vinfo->info.message = D.24909;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24911 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24911;
      }
      <D.24908>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24905>:
      ptr.187 = ptr;
      size.188 = size;
      D.24915 = (sizetype) size.188;
      end = ptr.187 + D.24915;
      D.24916 = safe_read (&ptr, end, &type, 1);
      if (D.24916 == 0) goto <D.24917>; else goto <D.24918>;
      <D.24917>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24919>; else goto <D.24920>;
      <D.24919>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24921 = monoeg_strdup ("MethodSpec: Not enough room for call convention");
        vinfo->info.message = D.24921;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24922 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24922;
      }
      <D.24920>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24918>:
      type.189 = type;
      if (type.189 != 10) goto <D.24924>; else goto <D.24925>;
      <D.24924>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24926>; else goto <D.24927>;
      <D.24926>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.189 = type;
        D.24928 = monoeg_g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type.189);
        vinfo->info.message = D.24928;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24929 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24929;
      }
      <D.24927>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24925>:
      D.24930 = safe_read_compressed_int (&ptr, end, &count);
      if (D.24930 == 0) goto <D.24931>; else goto <D.24932>;
      <D.24931>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24933>; else goto <D.24934>;
      <D.24933>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24935 = monoeg_strdup ("MethodSpec: Not enough room for parameter count");
        vinfo->info.message = D.24935;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24936 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24936;
      }
      <D.24934>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24932>:
      count.190 = count;
      if (count.190 == 0) goto <D.24938>; else goto <D.24939>;
      <D.24938>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24940>; else goto <D.24941>;
      <D.24940>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24942 = monoeg_strdup ("MethodSpec: Zero generic argument count");
        vinfo->info.message = D.24942;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24943 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24943;
      }
      <D.24941>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24939>:
      i = 0;
      goto <D.18633>;
      <D.18632>:
      D.24944 = parse_custom_mods (ctx, &ptr, end);
      if (D.24944 == 0) goto <D.24945>; else goto <D.24946>;
      <D.24945>:
      D.24912 = 0;
      return D.24912;
      <D.24946>:
      D.24947 = parse_type (ctx, &ptr, end);
      if (D.24947 == 0) goto <D.24948>; else goto <D.24949>;
      <D.24948>:
      D.24906 = ctx->report_error;
      if (D.24906 != 0) goto <D.24950>; else goto <D.24951>;
      <D.24950>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24952 = i + 1;
        D.24953 = monoeg_g_strdup_printf ("MethodSpec: Could not parse parameter %d", D.24952);
        vinfo->info.message = D.24953;
        vinfo->exception_type = 3;
        D.24910 = ctx->errors;
        D.24954 = monoeg_g_slist_prepend (D.24910, vinfo);
        ctx->errors = D.24954;
      }
      <D.24951>:
      ctx->valid = 0;
      D.24912 = 0;
      return D.24912;
      <D.24949>:
      i = i + 1;
      <D.18633>:
      count.190 = count;
      if (i < count.190) goto <D.18632>; else goto <D.18634>;
      <D.18634>:
      D.24912 = 1;
      return D.24912;
    }
  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.24957;
  <unnamed-unsigned:24> D.24958;
  unsigned int D.24959;
  struct MonoTableInfo * table;
  struct MonoError error;
  guint32 i;

  try
    {
      D.24957 = ctx->image;
      table = &D.24957->tables[1];
      i = 0;
      goto <D.18742>;
      <D.18741>:
      D.24957 = ctx->image;
      mono_verifier_verify_typeref_row (D.24957, i, &error);
      add_from_mono_error (ctx, &error);
      i = i + 1;
      <D.18742>:
      D.24958 = table->rows;
      D.24959 = (unsigned int) D.24958;
      if (D.24959 > i) goto <D.18741>; else goto <D.18743>;
      <D.18743>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


add_from_mono_error (struct VerifyContext * ctx, struct MonoError * error)
{
  int D.24960;
  int D.24963;
  const char * D.24966;
  gchar * D.24967;
  struct GSList * D.24968;
  struct GSList * D.24969;

  D.24960 = mono_error_ok (error);
  if (D.24960 != 0) goto <D.24961>; else goto <D.24962>;
  <D.24961>:
  return;
  <D.24962>:
  D.24963 = ctx->report_error;
  if (D.24963 != 0) goto <D.24964>; else goto <D.24965>;
  <D.24964>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.24966 = mono_error_get_message (error);
    D.24967 = monoeg_strdup (D.24966);
    vinfo->info.message = D.24967;
    vinfo->exception_type = 3;
    D.24968 = ctx->errors;
    D.24969 = monoeg_g_slist_prepend (D.24968, vinfo);
    ctx->errors = D.24969;
  }
  <D.24965>:
  ctx->valid = 0;
  return;
  mono_error_cleanup (error);
}


verify_typeref_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.24971;
  unsigned int D.24972;
  unsigned int D.24973;
  const char * D.24974;
  unsigned int D.24975;
  const char * D.24976;
  void * D.24977;
  int D.24980;
  unsigned int D.24983;
  const char * D.24984;
  const char * D.24985;
  gchar * D.24986;
  struct GSList * D.24987;
  struct GSList * D.24988;
  <unnamed-unsigned:24> D.24989;
  int D.24990;
  int i;
  guint32 data[3];
  struct MonoTableInfo * table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (24);
        mono_metadata_decode_row (table, i, &data, 3);
        D.24972 = data[0];
        type->resolution_scope = D.24972;
        D.24973 = data[1];
        D.24971 = ctx->image;
        D.24974 = mono_metadata_string_heap (D.24971, D.24973);
        type->name = D.24974;
        D.24975 = data[2];
        D.24971 = ctx->image;
        D.24976 = mono_metadata_string_heap (D.24971, D.24975);
        type->name_space = D.24976;
        D.24977 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.24977 != 0B) goto <D.24978>; else goto <D.24979>;
        <D.24978>:
        D.24980 = ctx->report_error;
        if (D.24980 != 0) goto <D.24981>; else goto <D.24982>;
        <D.24981>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.24983 = type->resolution_scope;
          D.24984 = type->name_space;
          D.24985 = type->name;
          D.24986 = monoeg_g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, D.24985, D.24984, D.24983);
          vinfo->info.message = D.24986;
          vinfo->exception_type = 3;
          D.24987 = ctx->errors;
          D.24988 = monoeg_g_slist_prepend (D.24987, vinfo);
          ctx->errors = D.24988;
        }
        <D.24982>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.24979>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19465>:
      D.24989 = table->rows;
      D.24990 = (int) D.24989;
      if (D.24990 > i) goto <D.19464>; else goto <D.19466>;
      <D.19466>:
      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.24994;
  gboolean D.24997;
  _Bool D.24998;
  int D.24999;
  struct VerifyContext ctx;

  try
    {
      D.24994 = mono_verifier_is_enabled_for_image (image);
      if (D.24994 == 0) goto <D.24995>; else goto <D.24996>;
      <D.24995>:
      D.24997 = 1;
      return D.24997;
      <D.24996>:
      D.24998 = error_list != 0B;
      D.24999 = (int) D.24998;
      init_verify_context (&ctx, image, D.24999);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.24997 = cleanup_context (&ctx, error_list);
      return D.24997;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_method_header (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25002;
  gboolean D.25005;
  _Bool D.25006;
  int D.25007;
  unsigned int locals_token.191;
  unsigned int D.25011;
  int D.25012;
  struct MonoTableInfo * D.25013;
  struct VerifyContext ctx;
  guint32 locals_token;

  try
    {
      D.25002 = mono_verifier_is_enabled_for_image (image);
      if (D.25002 == 0) goto <D.25003>; else goto <D.25004>;
      <D.25003>:
      D.25005 = 1;
      return D.25005;
      <D.25004>:
      D.25006 = error_list != 0B;
      D.25007 = (int) D.25006;
      init_verify_context (&ctx, image, D.25007);
      ctx.stage = 2;
      is_valid_method_header (&ctx, offset, &locals_token);
      locals_token.191 = locals_token;
      if (locals_token.191 != 0) goto <D.25009>; else goto <D.25010>;
      <D.25009>:
      {
        guint32 sig_offset;

        locals_token.191 = locals_token;
        D.25011 = locals_token.191 + 4294967295;
        D.25012 = (int) D.25011;
        D.25013 = &image->tables[17];
        sig_offset = mono_metadata_decode_row_col (D.25013, D.25012, 0);
        is_valid_standalonesig_blob (&ctx, sig_offset);
      }
      <D.25010>:
      D.25005 = cleanup_context (&ctx, error_list);
      return D.25005;
    }
  finally
    {
      ctx = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


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

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


cleanup_context_checked (struct VerifyContext * ctx, struct MonoError * error)
{
  struct SectionHeader * D.25022;
  struct GSList * D.25023;
  char * D.25026;
  struct MonoImage * D.25027;
  gboolean D.25028;

  D.25022 = ctx->sections;
  monoeg_g_free (D.25022);
  D.25023 = ctx->errors;
  if (D.25023 != 0B) goto <D.25024>; else goto <D.25025>;
  <D.25024>:
  {
    struct MonoVerifyInfo * info;

    D.25023 = ctx->errors;
    info = D.25023->data;
    D.25026 = info->message;
    D.25027 = ctx->image;
    mono_error_set_bad_image (error, D.25027, "%s", D.25026);
    D.25023 = ctx->errors;
    mono_free_verify_list (D.25023);
  }
  <D.25025>:
  D.25028 = ctx->valid;
  return D.25028;
}


mono_verifier_verify_memberref_method_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25030;
  gboolean D.25033;
  _Bool D.25034;
  int D.25035;
  struct VerifyContext ctx;

  try
    {
      D.25030 = mono_verifier_is_enabled_for_image (image);
      if (D.25030 == 0) goto <D.25031>; else goto <D.25032>;
      <D.25031>:
      D.25033 = 1;
      return D.25033;
      <D.25032>:
      D.25034 = error_list != 0B;
      D.25035 = (int) D.25034;
      init_verify_context (&ctx, image, D.25035);
      ctx.stage = 2;
      is_valid_memberref_method_signature (&ctx, offset);
      D.25033 = cleanup_context (&ctx, error_list);
      return D.25033;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


is_valid_memberref_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.25038;
  int D.25041;
  gchar * D.25044;
  struct GSList * D.25045;
  struct GSList * D.25046;
  gboolean D.25047;
  const char * ptr.192;
  unsigned int size.193;
  sizetype D.25050;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.25038 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25038 == 0) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      D.25041 = ctx->report_error;
      if (D.25041 != 0) goto <D.25042>; else goto <D.25043>;
      <D.25042>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25044 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.25044;
        vinfo->exception_type = 3;
        D.25045 = ctx->errors;
        D.25046 = monoeg_g_slist_prepend (D.25045, vinfo);
        ctx->errors = D.25046;
      }
      <D.25043>:
      ctx->valid = 0;
      D.25047 = 0;
      return D.25047;
      <D.25040>:
      ptr.192 = ptr;
      size.193 = size;
      D.25050 = (sizetype) size.193;
      end = ptr.192 + D.25050;
      D.25047 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.25047;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_verifier_verify_memberref_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25053;
  gboolean D.25056;
  _Bool D.25057;
  int D.25058;
  struct VerifyContext ctx;

  try
    {
      D.25053 = mono_verifier_is_enabled_for_image (image);
      if (D.25053 == 0) goto <D.25054>; else goto <D.25055>;
      <D.25054>:
      D.25056 = 1;
      return D.25056;
      <D.25055>:
      D.25057 = error_list != 0B;
      D.25058 = (int) D.25057;
      init_verify_context (&ctx, image, D.25058);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.25056 = cleanup_context (&ctx, error_list);
      return D.25056;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_standalone_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25061;
  gboolean D.25064;
  _Bool D.25065;
  int D.25066;
  struct VerifyContext ctx;

  try
    {
      D.25061 = mono_verifier_is_enabled_for_image (image);
      if (D.25061 == 0) goto <D.25062>; else goto <D.25063>;
      <D.25062>:
      D.25064 = 1;
      return D.25064;
      <D.25063>:
      D.25065 = error_list != 0B;
      D.25066 = (int) D.25065;
      init_verify_context (&ctx, image, D.25066);
      ctx.stage = 2;
      is_valid_standalonesig_blob (&ctx, offset);
      D.25064 = cleanup_context (&ctx, error_list);
      return D.25064;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_typespec_signature (struct MonoImage * image, guint32 offset, guint32 token, struct GSList * * error_list)
{
  int D.25069;
  gboolean D.25072;
  _Bool D.25073;
  int D.25074;
  struct VerifyContext ctx;

  try
    {
      D.25069 = mono_verifier_is_enabled_for_image (image);
      if (D.25069 == 0) goto <D.25070>; else goto <D.25071>;
      <D.25070>:
      D.25072 = 1;
      return D.25072;
      <D.25071>:
      D.25073 = error_list != 0B;
      D.25074 = (int) D.25073;
      init_verify_context (&ctx, image, D.25074);
      ctx.stage = 2;
      ctx.token = token;
      is_valid_typespec_blob (&ctx, offset);
      D.25072 = cleanup_context (&ctx, error_list);
      return D.25072;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_methodspec_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25077;
  gboolean D.25080;
  _Bool D.25081;
  int D.25082;
  struct VerifyContext ctx;

  try
    {
      D.25077 = mono_verifier_is_enabled_for_image (image);
      if (D.25077 == 0) goto <D.25078>; else goto <D.25079>;
      <D.25078>:
      D.25080 = 1;
      return D.25080;
      <D.25079>:
      D.25081 = error_list != 0B;
      D.25082 = (int) D.25081;
      init_verify_context (&ctx, image, D.25082);
      ctx.stage = 2;
      is_valid_methodspec_blob (&ctx, offset);
      D.25080 = cleanup_context (&ctx, error_list);
      return D.25080;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_string_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25085;
  gboolean D.25088;
  _Bool D.25089;
  int D.25090;
  struct VerifyContext ctx;

  try
    {
      D.25085 = mono_verifier_is_enabled_for_image (image);
      if (D.25085 == 0) goto <D.25086>; else goto <D.25087>;
      <D.25086>:
      D.25088 = 1;
      return D.25088;
      <D.25087>:
      D.25089 = error_list != 0B;
      D.25090 = (int) D.25089;
      init_verify_context (&ctx, image, D.25090);
      ctx.stage = 2;
      verify_user_string (&ctx, offset);
      D.25088 = cleanup_context (&ctx, error_list);
      return D.25088;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_user_string (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.25093;
  struct MonoStreamHeader * D.25094;
  unsigned int D.25095;
  int D.25098;
  gchar * D.25101;
  struct GSList * D.25102;
  struct GSList * D.25103;
  unsigned int D.25104;
  unsigned int D.25105;
  const char * D.25106;
  sizetype D.25107;
  sizetype D.25108;
  sizetype D.25109;
  const char * D.25110;
  int D.25111;
  gchar * D.25116;
  struct GSList * D.25117;
  unsigned int bytes.194;
  unsigned int D.25119;
  unsigned int entry_size.195;
  gchar * D.25125;
  struct GSList * D.25126;
  unsigned int entry_size.196;
  unsigned int D.25130;
  unsigned int D.25132;
  gchar * D.25135;
  struct GSList * D.25136;
  struct OffsetAndSize heap_us;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.25093 = ctx->image;
      D.25094 = &D.25093->heap_us;
      heap_us = get_metadata_stream (ctx, D.25094);
      D.25095 = heap_us.size;
      if (D.25095 < offset) goto <D.25096>; else goto <D.25097>;
      <D.25096>:
      D.25098 = ctx->report_error;
      if (D.25098 != 0) goto <D.25099>; else goto <D.25100>;
      <D.25099>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25101 = monoeg_strdup ("User string offset beyond heap_us size");
        vinfo->info.message = D.25101;
        vinfo->exception_type = 3;
        D.25102 = ctx->errors;
        D.25103 = monoeg_g_slist_prepend (D.25102, vinfo);
        ctx->errors = D.25103;
      }
      <D.25100>:
      ctx->valid = 0;
      return;
      <D.25097>:
      D.25095 = heap_us.size;
      D.25104 = heap_us.offset;
      D.25105 = D.25095 - D.25104;
      D.25106 = ctx->data;
      D.25107 = (sizetype) offset;
      D.25104 = heap_us.offset;
      D.25108 = (sizetype) D.25104;
      D.25109 = D.25107 + D.25108;
      D.25110 = D.25106 + D.25109;
      D.25111 = decode_value (D.25110, D.25105, &entry_size, &bytes);
      if (D.25111 == 0) goto <D.25112>; else goto <D.25113>;
      <D.25112>:
      D.25098 = ctx->report_error;
      if (D.25098 != 0) goto <D.25114>; else goto <D.25115>;
      <D.25114>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25116 = monoeg_strdup ("Could not decode user string blob size");
        vinfo->info.message = D.25116;
        vinfo->exception_type = 3;
        D.25102 = ctx->errors;
        D.25117 = monoeg_g_slist_prepend (D.25102, vinfo);
        ctx->errors = D.25117;
      }
      <D.25115>:
      ctx->valid = 0;
      return;
      <D.25113>:
      bytes.194 = bytes;
      D.25119 = ~bytes.194;
      entry_size.195 = entry_size;
      if (D.25119 < entry_size.195) goto <D.25121>; else goto <D.25122>;
      <D.25121>:
      D.25098 = ctx->report_error;
      if (D.25098 != 0) goto <D.25123>; else goto <D.25124>;
      <D.25123>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25125 = monoeg_strdup ("User string size overflow");
        vinfo->info.message = D.25125;
        vinfo->exception_type = 3;
        D.25102 = ctx->errors;
        D.25126 = monoeg_g_slist_prepend (D.25102, vinfo);
        ctx->errors = D.25126;
      }
      <D.25124>:
      ctx->valid = 0;
      return;
      <D.25122>:
      entry_size.195 = entry_size;
      bytes.194 = bytes;
      entry_size.196 = entry_size.195 + bytes.194;
      entry_size = entry_size.196;
      entry_size.195 = entry_size;
      D.25130 = offset + entry_size.195;
      D.25095 = heap_us.size;
      if (D.25130 > D.25095) goto <D.25128>; else goto <D.25131>;
      <D.25131>:
      entry_size.195 = entry_size;
      D.25132 = ~entry_size.195;
      if (D.25132 < offset) goto <D.25128>; else goto <D.25129>;
      <D.25128>:
      D.25098 = ctx->report_error;
      if (D.25098 != 0) goto <D.25133>; else goto <D.25134>;
      <D.25133>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25135 = monoeg_strdup ("User string oveflow heap_us");
        vinfo->info.message = D.25135;
        vinfo->exception_type = 3;
        D.25102 = ctx->errors;
        D.25136 = monoeg_g_slist_prepend (D.25102, vinfo);
        ctx->errors = D.25136;
      }
      <D.25134>:
      ctx->valid = 0;
      return;
      <D.25129>:
    }
  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.25140;
  gboolean D.25143;
  _Bool D.25144;
  int D.25145;
  struct VerifyContext ctx;

  try
    {
      D.25140 = mono_verifier_is_enabled_for_image (image);
      if (D.25140 == 0) goto <D.25141>; else goto <D.25142>;
      <D.25141>:
      D.25143 = 1;
      return D.25143;
      <D.25142>:
      D.25144 = error_list != 0B;
      D.25145 = (int) D.25144;
      init_verify_context (&ctx, image, D.25145);
      ctx.stage = 2;
      is_valid_cattr_blob (&ctx, offset);
      D.25143 = cleanup_context (&ctx, error_list);
      return D.25143;
    }
  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.25148;
  gboolean D.25151;
  _Bool D.25152;
  int D.25153;
  struct VerifyContext ctx;

  try
    {
      D.25148 = mono_verifier_is_enabled_for_image (image);
      if (D.25148 == 0) goto <D.25149>; else goto <D.25150>;
      <D.25149>:
      D.25151 = 1;
      return D.25151;
      <D.25150>:
      D.25152 = error_list != 0B;
      D.25153 = (int) D.25152;
      init_verify_context (&ctx, image, D.25153);
      ctx.stage = 2;
      is_valid_cattr_content (&ctx, ctor, data, size);
      D.25151 = cleanup_context (&ctx, error_list);
      return D.25151;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_is_sig_compatible (struct MonoImage * image, struct MonoMethod * method, struct MonoMethodSignature * signature)
{
  int D.25156;
  gboolean D.25159;
  unsigned char D.25160;
  unsigned char D.25161;
  unsigned char D.25164;
  unsigned char D.25165;
  unsigned char D.25166;
  unsigned char D.25169;
  signed char D.25172;
  unsigned char D.25177;
  unsigned char D.25178;
  unsigned char D.25179;
  unsigned char D.25180;
  short int D.25183;
  short int D.25184;
  int D.25188;
  struct MonoMethodSignature * original_sig;

  D.25156 = mono_verifier_is_enabled_for_image (image);
  if (D.25156 == 0) goto <D.25157>; else goto <D.25158>;
  <D.25157>:
  D.25159 = 1;
  return D.25159;
  <D.25158>:
  original_sig = mono_method_signature (method);
  D.25160 = BIT_FIELD_REF <*original_sig, 8, 112>;
  D.25161 = D.25160 & 63;
  if (D.25161 == 5) goto <D.25162>; else goto <D.25163>;
  <D.25162>:
  D.25160 = BIT_FIELD_REF <*original_sig, 8, 112>;
  D.25164 = BIT_FIELD_REF <*signature, 8, 112>;
  D.25165 = D.25160 ^ D.25164;
  D.25166 = D.25165 & 64;
  if (D.25166 != 0) goto <D.25167>; else goto <D.25168>;
  <D.25167>:
  D.25159 = 0;
  return D.25159;
  <D.25168>:
  D.25160 = BIT_FIELD_REF <*original_sig, 8, 112>;
  D.25164 = BIT_FIELD_REF <*signature, 8, 112>;
  D.25165 = D.25160 ^ D.25164;
  D.25169 = D.25165 & 63;
  if (D.25169 != 0) goto <D.25170>; else goto <D.25171>;
  <D.25170>:
  D.25159 = 0;
  return D.25159;
  <D.25171>:
  D.25160 = BIT_FIELD_REF <*original_sig, 8, 112>;
  D.25164 = BIT_FIELD_REF <*signature, 8, 112>;
  D.25165 = D.25160 ^ D.25164;
  D.25172 = (signed char) D.25165;
  if (D.25172 < 0) goto <D.25173>; else goto <D.25174>;
  <D.25173>:
  D.25159 = 0;
  return D.25159;
  <D.25174>:
  D.25160 = BIT_FIELD_REF <*original_sig, 8, 112>;
  D.25164 = BIT_FIELD_REF <*signature, 8, 112>;
  D.25165 = D.25160 ^ D.25164;
  D.25169 = D.25165 & 63;
  if (D.25169 != 0) goto <D.25175>; else goto <D.25176>;
  <D.25175>:
  D.25159 = 0;
  return D.25159;
  <D.25176>:
  D.25177 = BIT_FIELD_REF <*original_sig, 8, 120>;
  D.25178 = BIT_FIELD_REF <*signature, 8, 120>;
  D.25179 = D.25177 ^ D.25178;
  D.25180 = D.25179 & 1;
  if (D.25180 != 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  D.25159 = 0;
  return D.25159;
  <D.25182>:
  D.25183 = original_sig->sentinelpos;
  D.25184 = signature->sentinelpos;
  if (D.25183 != D.25184) goto <D.25185>; else goto <D.25186>;
  <D.25185>:
  D.25159 = 0;
  return D.25159;
  <D.25186>:
  goto <D.25187>;
  <D.25163>:
  D.25188 = mono_metadata_signature_equal (signature, original_sig);
  if (D.25188 == 0) goto <D.25189>; else goto <D.25190>;
  <D.25189>:
  D.25159 = 0;
  return D.25159;
  <D.25190>:
  <D.25187>:
  D.25159 = 1;
  return D.25159;
}


mono_verifier_verify_typeref_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.25192;
  gboolean D.25195;
  <unnamed-unsigned:24> D.25196;
  unsigned int D.25197;
  int D.25200;
  int row.197;
  unsigned int D.25202;
  int D.25203;
  unsigned int D.25206;
  unsigned int D.25211;
  int D.25213;
  unsigned int D.25214;
  int D.25217;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[1];
      mono_error_init (error);
      D.25192 = mono_verifier_is_enabled_for_image (image);
      if (D.25192 == 0) goto <D.25193>; else goto <D.25194>;
      <D.25193>:
      D.25195 = 1;
      return D.25195;
      <D.25194>:
      D.25196 = table->rows;
      D.25197 = (unsigned int) D.25196;
      if (D.25197 <= row) goto <D.25198>; else goto <D.25199>;
      <D.25198>:
      D.25196 = table->rows;
      D.25200 = (int) D.25196;
      mono_error_set_bad_image (error, image, "Invalid typeref row %d - table has %d rows", row, D.25200);
      D.25195 = 0;
      return D.25195;
      <D.25199>:
      row.197 = (int) row;
      mono_metadata_decode_row (table, row.197, &data, 3);
      D.25202 = data[0];
      D.25203 = is_valid_coded_index_with_image (image, 72, D.25202);
      if (D.25203 == 0) goto <D.25204>; else goto <D.25205>;
      <D.25204>:
      D.25202 = data[0];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d coded index 0x%08x", row, D.25202);
      D.25195 = 0;
      return D.25195;
      <D.25205>:
      D.25202 = data[0];
      D.25206 = get_coded_index_token (72, D.25202);
      if (D.25206 == 0) goto <D.25207>; else goto <D.25208>;
      <D.25207>:
      mono_error_set_bad_image (error, image, "The metadata verifier doesn\'t support null ResolutionScope tokens for typeref row %d", row);
      D.25195 = 0;
      return D.25195;
      <D.25208>:
      D.25211 = data[1];
      if (D.25211 == 0) goto <D.25209>; else goto <D.25212>;
      <D.25212>:
      D.25211 = data[1];
      D.25213 = is_valid_string_full_with_image (image, D.25211, 0);
      if (D.25213 == 0) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      D.25211 = data[1];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d name token 0x%08x", row, D.25211);
      D.25195 = 0;
      return D.25195;
      <D.25210>:
      D.25214 = data[2];
      if (D.25214 != 0) goto <D.25215>; else goto <D.25216>;
      <D.25215>:
      D.25214 = data[2];
      D.25217 = is_valid_string_full_with_image (image, D.25214, 0);
      if (D.25217 == 0) goto <D.25218>; else goto <D.25219>;
      <D.25218>:
      D.25214 = data[2];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d namespace token 0x%08x", row, D.25214);
      D.25195 = 0;
      return D.25195;
      <D.25219>:
      <D.25216>:
      D.25195 = 1;
      return D.25195;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_methodimpl_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.25222;
  gboolean D.25225;
  <unnamed-unsigned:24> D.25226;
  unsigned int D.25227;
  int D.25230;
  int row.198;
  unsigned int D.25232;
  struct MonoLoaderError * D.25236;
  unsigned int D.25237;
  struct MonoLoaderError * D.25241;
  int D.25246;
  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.25222 = mono_verifier_is_enabled_for_image (image);
      if (D.25222 == 0) goto <D.25223>; else goto <D.25224>;
      <D.25223>:
      D.25225 = 1;
      return D.25225;
      <D.25224>:
      D.25226 = table->rows;
      D.25227 = (unsigned int) D.25226;
      if (D.25227 <= row) goto <D.25228>; else goto <D.25229>;
      <D.25228>:
      D.25226 = table->rows;
      D.25230 = (int) D.25226;
      mono_error_set_bad_image (error, image, "Invalid methodimpl row %d - table has %d rows", row, D.25230);
      D.25225 = 0;
      return D.25225;
      <D.25229>:
      row.198 = (int) row;
      mono_metadata_decode_row (table, row.198, &data, 3);
      D.25232 = data[1];
      body = method_from_method_def_or_ref (image, D.25232, 0B);
      if (body == 0B) goto <D.25233>; else goto <D.25235>;
      <D.25235>:
      D.25236 = mono_loader_get_last_error ();
      if (D.25236 != 0B) goto <D.25233>; else goto <D.25234>;
      <D.25233>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl body for row %x", row);
      D.25225 = 0;
      return D.25225;
      <D.25234>:
      D.25237 = data[2];
      declaration = method_from_method_def_or_ref (image, D.25237, 0B);
      if (declaration == 0B) goto <D.25238>; else goto <D.25240>;
      <D.25240>:
      D.25241 = mono_loader_get_last_error ();
      if (D.25241 != 0B) goto <D.25238>; else goto <D.25239>;
      <D.25238>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl declaration for row %x", row);
      D.25225 = 0;
      return D.25225;
      <D.25239>:
      body_sig = mono_method_signature_checked (body, error);
      if (body_sig == 0B) goto <D.25242>; else goto <D.25243>;
      <D.25242>:
      D.25225 = 0;
      return D.25225;
      <D.25243>:
      decl_sig = mono_method_signature_checked (declaration, error);
      if (decl_sig == 0B) goto <D.25244>; else goto <D.25245>;
      <D.25244>:
      D.25225 = 0;
      return D.25225;
      <D.25245>:
      D.25246 = mono_verifier_is_signature_compatible (decl_sig, body_sig);
      if (D.25246 == 0) goto <D.25247>; else goto <D.25248>;
      <D.25247>:
      mono_error_set_bad_image (error, image, "Invalid methodimpl body signature not compatible with declaration row %x", row);
      D.25225 = 0;
      return D.25225;
      <D.25248>:
      D.25225 = 1;
      return D.25225;
    }
  finally
    {
      data = {CLOBBER};
    }
}