mono_verifier_verify_pe_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20161;
  gboolean D.20164;
  _Bool D.20165;
  int D.20166;
  int D.20167;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.20161 = mono_verifier_is_enabled_for_image (image);
      if (D.20161 == 0) goto <D.20162>; else goto <D.20163>;
      <D.20162>:
      D.20164 = 1;
      return D.20164;
      <D.20163>:
      D.20165 = error_list != 0B;
      D.20166 = (int) D.20165;
      init_verify_context (&ctx, image, D.20166);
      ctx.stage = 0;
      verify_msdos_header (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20168>;
      <D.20168>:
      verify_pe_header (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20169>;
      <D.20169>:
      verify_pe_optional_header (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20170>;
      <D.20170>:
      load_section_table (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20171>;
      <D.20171>:
      load_data_directories (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20172>;
      <D.20172>:
      verify_import_table (&ctx);
      D.20167 = ctx.valid;
      if (D.20167 == 0) goto cleanup; else goto <D.20173>;
      <D.20173>:
      verify_resources_table (&ctx);
      cleanup:
      D.20164 = cleanup_context (&ctx, error_list);
      return D.20164;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.20180;
  int D.20185;
  void * D.20187;
  long unsigned int D.20188;

  D.20180 = __builtin_constant_p (__len);
  if (D.20180 != 0) goto <D.20181>; else goto <D.20182>;
  <D.20181>:
  if (__len == 0) goto <D.20183>; else goto <D.20184>;
  <D.20183>:
  D.20185 = __builtin_constant_p (__ch);
  if (D.20185 == 0) goto <D.20178>; else goto <D.20186>;
  <D.20186>:
  if (__ch != 0) goto <D.20178>; else goto <D.20179>;
  <D.20178>:
  __warn_memset_zero_len ();
  D.20187 = __dest;
  return D.20187;
  <D.20179>:
  <D.20184>:
  <D.20182>:
  D.20188 = __builtin_object_size (__dest, 0);
  D.20187 = __builtin___memset_chk (__dest, __ch, __len, D.20188);
  return D.20187;
}


verify_msdos_header (struct VerifyContext * ctx)
{
  unsigned int D.20190;
  int D.20193;
  gchar * D.20196;
  struct GSList * D.20197;
  struct GSList * D.20198;
  const char * D.20201;
  char D.20202;
  const char * D.20204;
  char D.20205;
  gchar * D.20208;
  struct GSList * D.20209;
  unsigned int D.20210;
  gchar * D.20215;
  struct GSList * D.20216;
  guint32 lfanew;

  D.20190 = ctx->size;
  if (D.20190 <= 127) goto <D.20191>; else goto <D.20192>;
  <D.20191>:
  D.20193 = ctx->report_error;
  if (D.20193 != 0) goto <D.20194>; else goto <D.20195>;
  <D.20194>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20196 = monoeg_strdup ("Not enough space for the MS-DOS header");
    vinfo->info.message = D.20196;
    vinfo->exception_type = 3;
    D.20197 = ctx->errors;
    D.20198 = monoeg_g_slist_prepend (D.20197, vinfo);
    ctx->errors = D.20198;
  }
  <D.20195>:
  ctx->valid = 0;
  return;
  <D.20192>:
  D.20201 = ctx->data;
  D.20202 = *D.20201;
  if (D.20202 != 77) goto <D.20199>; else goto <D.20203>;
  <D.20203>:
  D.20201 = ctx->data;
  D.20204 = D.20201 + 1;
  D.20205 = *D.20204;
  if (D.20205 != 90) goto <D.20199>; else goto <D.20200>;
  <D.20199>:
  D.20193 = ctx->report_error;
  if (D.20193 != 0) goto <D.20206>; else goto <D.20207>;
  <D.20206>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20208 = monoeg_strdup ("Invalid MS-DOS watermark");
    vinfo->info.message = D.20208;
    vinfo->exception_type = 3;
    D.20197 = ctx->errors;
    D.20209 = monoeg_g_slist_prepend (D.20197, vinfo);
    ctx->errors = D.20209;
  }
  <D.20207>:
  ctx->valid = 0;
  return;
  <D.20200>:
  lfanew = pe_signature_offset (ctx);
  D.20190 = ctx->size;
  D.20210 = D.20190 + 4294967292;
  if (D.20210 < lfanew) goto <D.20211>; else goto <D.20212>;
  <D.20211>:
  D.20193 = ctx->report_error;
  if (D.20193 != 0) goto <D.20213>; else goto <D.20214>;
  <D.20213>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20215 = monoeg_strdup ("MS-DOS lfanew offset points to outside of the file");
    vinfo->info.message = D.20215;
    vinfo->exception_type = 3;
    D.20197 = ctx->errors;
    D.20216 = monoeg_g_slist_prepend (D.20197, vinfo);
    ctx->errors = D.20216;
  }
  <D.20214>:
  ctx->valid = 0;
  return;
  <D.20212>:
}


pe_signature_offset (struct VerifyContext * ctx)
{
  guint32 D.20218;
  const char * D.20219;
  const guint32 * D.20220;

  D.20219 = ctx->data;
  D.20220 = D.20219 + 60;
  D.20218 = *D.20220;
  return D.20218;
}


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

  if (str != 0B) goto <D.20222>; else goto <D.20223>;
  <D.20222>:
  D.20224 = __strdup (str);
  return D.20224;
  <D.20223>:
  D.20224 = 0B;
  return D.20224;
}


verify_pe_header (struct VerifyContext * ctx)
{
  const char * D.20226;
  sizetype D.20227;
  char D.20230;
  const char * D.20232;
  char D.20233;
  const char * D.20235;
  char D.20236;
  const char * D.20238;
  char D.20239;
  int D.20240;
  gchar * D.20243;
  struct GSList * D.20244;
  struct GSList * D.20245;
  unsigned int D.20246;
  unsigned int D.20247;
  gchar * D.20252;
  struct GSList * D.20253;
  short unsigned int D.20254;
  gchar * D.20259;
  struct GSList * D.20260;
  guint32 offset;
  const char * pe_header;

  offset = pe_signature_offset (ctx);
  D.20226 = ctx->data;
  D.20227 = (sizetype) offset;
  pe_header = D.20226 + D.20227;
  D.20230 = *pe_header;
  if (D.20230 != 80) goto <D.20228>; else goto <D.20231>;
  <D.20231>:
  D.20232 = pe_header + 1;
  D.20233 = *D.20232;
  if (D.20233 != 69) goto <D.20228>; else goto <D.20234>;
  <D.20234>:
  D.20235 = pe_header + 2;
  D.20236 = *D.20235;
  if (D.20236 != 0) goto <D.20228>; else goto <D.20237>;
  <D.20237>:
  D.20238 = pe_header + 3;
  D.20239 = *D.20238;
  if (D.20239 != 0) goto <D.20228>; else goto <D.20229>;
  <D.20228>:
  D.20240 = ctx->report_error;
  if (D.20240 != 0) goto <D.20241>; else goto <D.20242>;
  <D.20241>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20243 = monoeg_strdup ("Invalid PE header watermark");
    vinfo->info.message = D.20243;
    vinfo->exception_type = 3;
    D.20244 = ctx->errors;
    D.20245 = monoeg_g_slist_prepend (D.20244, vinfo);
    ctx->errors = D.20245;
  }
  <D.20242>:
  ctx->valid = 0;
  return;
  <D.20229>:
  pe_header = pe_header + 4;
  offset = offset + 4;
  D.20246 = ctx->size;
  D.20247 = D.20246 + 4294967276;
  if (D.20247 < offset) goto <D.20248>; else goto <D.20249>;
  <D.20248>:
  D.20240 = ctx->report_error;
  if (D.20240 != 0) goto <D.20250>; else goto <D.20251>;
  <D.20250>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20252 = monoeg_strdup ("File with truncated pe header");
    vinfo->info.message = D.20252;
    vinfo->exception_type = 3;
    D.20244 = ctx->errors;
    D.20253 = monoeg_g_slist_prepend (D.20244, vinfo);
    ctx->errors = D.20253;
  }
  <D.20251>:
  ctx->valid = 0;
  return;
  <D.20249>:
  D.20254 = MEM[(const guint16 *)pe_header];
  if (D.20254 != 332) goto <D.20255>; else goto <D.20256>;
  <D.20255>:
  D.20240 = ctx->report_error;
  if (D.20240 != 0) goto <D.20257>; else goto <D.20258>;
  <D.20257>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20259 = monoeg_strdup ("Invalid PE header Machine value");
    vinfo->info.message = D.20259;
    vinfo->exception_type = 3;
    D.20244 = ctx->errors;
    D.20260 = monoeg_g_slist_prepend (D.20244, vinfo);
    ctx->errors = D.20260;
  }
  <D.20258>:
  ctx->valid = 0;
  return;
  <D.20256>:
}


verify_pe_optional_header (struct VerifyContext * ctx)
{
  const char * D.20262;
  sizetype D.20263;
  const guint16 * D.20264;
  short unsigned int D.20265;
  int D.20268;
  gchar * D.20271;
  struct GSList * D.20272;
  struct GSList * D.20273;
  unsigned int D.20276;
  unsigned int D.20277;
  gchar * D.20281;
  struct GSList * D.20282;
  short unsigned int D.20283;
  gchar * D.20290;
  struct GSList * D.20291;
  const guint32 * D.20292;
  unsigned int D.20293;
  gchar * D.20298;
  struct GSList * D.20299;
  gchar * D.20306;
  struct GSList * D.20307;
  const guint32 * D.20308;
  unsigned int D.20309;
  gchar * D.20314;
  struct GSList * D.20315;
  gchar * D.20321;
  struct GSList * D.20322;
  int D.20325;
  gchar * D.20326;
  struct GSList * D.20327;
  guint32 offset;
  guint32 header_size;
  guint32 file_alignment;
  const char * pe_header;
  const char * pe_optional_header;

  offset = pe_header_offset (ctx);
  D.20262 = ctx->data;
  D.20263 = (sizetype) offset;
  pe_header = D.20262 + D.20263;
  pe_optional_header = pe_header + 20;
  D.20264 = pe_header + 16;
  D.20265 = *D.20264;
  header_size = (guint32) D.20265;
  offset = offset + 20;
  if (header_size <= 1) goto <D.20266>; else goto <D.20267>;
  <D.20266>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20269>; else goto <D.20270>;
  <D.20269>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20271 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.20271;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20273 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20273;
  }
  <D.20270>:
  ctx->valid = 0;
  return;
  <D.20267>:
  D.20276 = ctx->size;
  D.20277 = D.20276 - header_size;
  if (D.20277 < offset) goto <D.20274>; else goto <D.20278>;
  <D.20278>:
  D.20276 = ctx->size;
  if (D.20276 < header_size) goto <D.20274>; else goto <D.20275>;
  <D.20274>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20279>; else goto <D.20280>;
  <D.20279>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20281 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.20281;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20282 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20282;
  }
  <D.20280>:
  ctx->valid = 0;
  return;
  <D.20275>:
  D.20283 = MEM[(const guint16 *)pe_optional_header];
  if (D.20283 == 267) goto <D.20284>; else goto <D.20285>;
  <D.20284>:
  if (header_size != 224) goto <D.20286>; else goto <D.20287>;
  <D.20286>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20288>; else goto <D.20289>;
  <D.20288>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20290 = monoeg_g_strdup_printf ("Invalid optional header size %d", header_size);
    vinfo->info.message = D.20290;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20291 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20291;
  }
  <D.20289>:
  ctx->valid = 0;
  return;
  <D.20287>:
  D.20292 = pe_optional_header + 32;
  D.20293 = *D.20292;
  if (D.20293 != 8192) goto <D.20294>; else goto <D.20295>;
  <D.20294>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20296>; else goto <D.20297>;
  <D.20296>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20292 = pe_optional_header + 32;
    D.20293 = *D.20292;
    D.20298 = monoeg_g_strdup_printf ("Invalid Section Aligmnent %x", D.20293);
    vinfo->info.message = D.20298;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20299 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20299;
  }
  <D.20297>:
  ctx->valid = 0;
  return;
  <D.20295>:
  file_alignment = MEM[(const guint32 *)pe_optional_header + 36B];
  if (file_alignment != 512) goto <D.20300>; else goto <D.20301>;
  <D.20300>:
  if (file_alignment != 4096) goto <D.20302>; else goto <D.20303>;
  <D.20302>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20304>; else goto <D.20305>;
  <D.20304>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20306 = monoeg_g_strdup_printf ("Invalid file Aligmnent %x", file_alignment);
    vinfo->info.message = D.20306;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20307 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20307;
  }
  <D.20305>:
  ctx->valid = 0;
  return;
  <D.20303>:
  <D.20301>:
  D.20308 = pe_optional_header + 92;
  D.20309 = *D.20308;
  if (D.20309 > 16) goto <D.20310>; else goto <D.20311>;
  <D.20310>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20312>; else goto <D.20313>;
  <D.20312>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20308 = pe_optional_header + 92;
    D.20309 = *D.20308;
    D.20314 = monoeg_g_strdup_printf ("Too many data directories %x", D.20309);
    vinfo->info.message = D.20314;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20315 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20315;
  }
  <D.20313>:
  ctx->valid = 0;
  return;
  <D.20311>:
  goto <D.20316>;
  <D.20285>:
  D.20283 = MEM[(const guint16 *)pe_optional_header];
  if (D.20283 == 523) goto <D.20317>; else goto <D.20318>;
  <D.20317>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20319>; else goto <D.20320>;
  <D.20319>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20321 = monoeg_strdup ("Metadata verifier doesn\'t handle PE32+");
    vinfo->info.message = D.20321;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20322 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20322;
  }
  <D.20320>:
  ctx->valid = 0;
  return;
  <D.20318>:
  D.20268 = ctx->report_error;
  if (D.20268 != 0) goto <D.20323>; else goto <D.20324>;
  <D.20323>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20283 = MEM[(const guint16 *)pe_optional_header];
    D.20325 = (int) D.20283;
    D.20326 = monoeg_g_strdup_printf ("Invalid optional header magic %d", D.20325);
    vinfo->info.message = D.20326;
    vinfo->exception_type = 3;
    D.20272 = ctx->errors;
    D.20327 = monoeg_g_slist_prepend (D.20272, vinfo);
    ctx->errors = D.20327;
  }
  <D.20324>:
  ctx->valid = 0;
  return;
  <D.20316>:
}


pe_header_offset (struct VerifyContext * ctx)
{
  guint32 D.20329;
  const char * D.20330;
  const guint32 * D.20331;
  unsigned int D.20332;

  D.20330 = ctx->data;
  D.20331 = D.20330 + 60;
  D.20332 = *D.20331;
  D.20329 = D.20332 + 4;
  return D.20329;
}


load_section_table (struct VerifyContext * ctx)
{
  const char * D.20334;
  sizetype D.20335;
  const guint16 * D.20336;
  short unsigned int D.20337;
  unsigned int D.20338;
  unsigned int D.20339;
  int D.20340;
  int D.20341;
  unsigned int D.20342;
  unsigned int D.20343;
  unsigned int D.20344;
  int D.20347;
  gchar * D.20350;
  struct GSList * D.20351;
  struct GSList * D.20352;
  long unsigned int D.20353;
  long unsigned int D.20354;
  void * D.20355;
  long unsigned int D.20356;
  long unsigned int D.20357;
  struct SectionHeader * D.20358;
  unsigned int D.20359;
  unsigned int D.20360;
  unsigned int D.20361;
  unsigned int D.20362;
  short unsigned int D.20363;
  unsigned int D.20364;
  gchar * D.20369;
  struct GSList * D.20370;
  gchar * D.20375;
  struct GSList * D.20376;
  unsigned int D.20377;
  unsigned int D.20378;
  gchar * D.20383;
  struct GSList * D.20384;
  gchar * D.20389;
  struct GSList * D.20390;
  gchar * D.20395;
  struct GSList * D.20396;
  unsigned int D.20399;
  short unsigned int D.20401;
  gchar * D.20404;
  struct GSList * D.20405;
  unsigned int D.20409;
  gchar * D.20412;
  struct GSList * D.20413;
  int i;
  struct SectionHeader * sections;
  guint32 offset;
  const char * ptr;
  guint16 num_sections;

  offset = pe_header_offset (ctx);
  D.20334 = ctx->data;
  D.20335 = (sizetype) offset;
  ptr = D.20334 + D.20335;
  D.20336 = ptr + 2;
  D.20337 = *D.20336;
  D.20338 = (unsigned int) D.20337;
  ctx->section_count = D.20338;
  D.20339 = ctx->section_count;
  num_sections = (guint16) D.20339;
  offset = offset + 244;
  ptr = ptr + 244;
  D.20340 = (int) num_sections;
  D.20341 = D.20340 * 40;
  D.20342 = (unsigned int) D.20341;
  D.20343 = ctx->size;
  D.20344 = D.20343 - offset;
  if (D.20342 > D.20344) goto <D.20345>; else goto <D.20346>;
  <D.20345>:
  D.20347 = ctx->report_error;
  if (D.20347 != 0) goto <D.20348>; else goto <D.20349>;
  <D.20348>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20350 = monoeg_strdup ("Invalid PE optional header size");
    vinfo->info.message = D.20350;
    vinfo->exception_type = 3;
    D.20351 = ctx->errors;
    D.20352 = monoeg_g_slist_prepend (D.20351, vinfo);
    ctx->errors = D.20352;
  }
  <D.20349>:
  ctx->valid = 0;
  return;
  <D.20346>:
  D.20353 = (long unsigned int) num_sections;
  D.20354 = D.20353 * 20;
  D.20355 = monoeg_malloc0 (D.20354);
  ctx->sections = D.20355;
  sections = ctx->sections;
  i = 0;
  goto <D.18350>;
  <D.18349>:
  D.20356 = (long unsigned int) i;
  D.20357 = D.20356 * 20;
  D.20358 = sections + D.20357;
  D.20359 = MEM[(const guint32 *)ptr + 8B];
  D.20358->size = D.20359;
  D.20356 = (long unsigned int) i;
  D.20357 = D.20356 * 20;
  D.20358 = sections + D.20357;
  D.20360 = MEM[(const guint32 *)ptr + 12B];
  D.20358->baseRVA = D.20360;
  D.20356 = (long unsigned int) i;
  D.20357 = D.20356 * 20;
  D.20358 = sections + D.20357;
  D.20361 = MEM[(const guint32 *)ptr + 20B];
  D.20358->baseOffset = D.20361;
  D.20356 = (long unsigned int) i;
  D.20357 = D.20356 * 20;
  D.20358 = sections + D.20357;
  D.20362 = MEM[(const guint32 *)ptr + 24B];
  D.20358->rellocationsRVA = D.20362;
  D.20356 = (long unsigned int) i;
  D.20357 = D.20356 * 20;
  D.20358 = sections + D.20357;
  D.20363 = MEM[(const guint16 *)ptr + 32B];
  D.20358->numberOfRelocations = D.20363;
  ptr = ptr + 40;
  i = i + 1;
  <D.18350>:
  D.20340 = (int) num_sections;
  if (D.20340 > i) goto <D.18349>; else goto <D.18351>;
  <D.18351>:
  D.20334 = ctx->data;
  D.20335 = (sizetype) offset;
  ptr = D.20334 + D.20335;
  i = 0;
  goto <D.18362>;
  <D.18361>:
  {
    guint32 raw_size;
    guint32 flags;

    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20364 = D.20358->baseOffset;
    if (D.20364 == 0) goto <D.20365>; else goto <D.20366>;
    <D.20365>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20367>; else goto <D.20368>;
    <D.20367>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20369 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with intialized data only");
      vinfo->info.message = D.20369;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20370 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20370;
    }
    <D.20368>:
    ctx->valid = 0;
    return;
    <D.20366>:
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20364 = D.20358->baseOffset;
    D.20343 = ctx->size;
    if (D.20364 >= D.20343) goto <D.20371>; else goto <D.20372>;
    <D.20371>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20373>; else goto <D.20374>;
    <D.20373>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20356 = (long unsigned int) i;
      D.20357 = D.20356 * 20;
      D.20358 = sections + D.20357;
      D.20364 = D.20358->baseOffset;
      D.20375 = monoeg_g_strdup_printf ("Invalid PointerToRawData %x points beyond EOF", D.20364);
      vinfo->info.message = D.20375;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20376 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20376;
    }
    <D.20374>:
    ctx->valid = 0;
    return;
    <D.20372>:
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20377 = D.20358->size;
    D.20343 = ctx->size;
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20364 = D.20358->baseOffset;
    D.20378 = D.20343 - D.20364;
    if (D.20377 > D.20378) goto <D.20379>; else goto <D.20380>;
    <D.20379>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20381>; else goto <D.20382>;
    <D.20381>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20383 = monoeg_strdup ("Invalid VirtualSize points beyond EOF");
      vinfo->info.message = D.20383;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20384 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20384;
    }
    <D.20382>:
    ctx->valid = 0;
    return;
    <D.20380>:
    raw_size = MEM[(const guint32 *)ptr + 16B];
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20377 = D.20358->size;
    if (D.20377 > raw_size) goto <D.20385>; else goto <D.20386>;
    <D.20385>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20387>; else goto <D.20388>;
    <D.20387>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20389 = monoeg_strdup ("Metadata verifier doesn\'t handle sections with SizeOfRawData < VirtualSize");
      vinfo->info.message = D.20389;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20390 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20390;
    }
    <D.20388>:
    ctx->valid = 0;
    return;
    <D.20386>:
    D.20343 = ctx->size;
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20364 = D.20358->baseOffset;
    D.20378 = D.20343 - D.20364;
    if (D.20378 < raw_size) goto <D.20391>; else goto <D.20392>;
    <D.20391>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20393>; else goto <D.20394>;
    <D.20393>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20395 = monoeg_g_strdup_printf ("Invalid SizeOfRawData %x points beyond EOF", raw_size);
      vinfo->info.message = D.20395;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20396 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20396;
    }
    <D.20394>:
    ctx->valid = 0;
    return;
    <D.20392>:
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20399 = D.20358->rellocationsRVA;
    if (D.20399 != 0) goto <D.20397>; else goto <D.20400>;
    <D.20400>:
    D.20356 = (long unsigned int) i;
    D.20357 = D.20356 * 20;
    D.20358 = sections + D.20357;
    D.20401 = D.20358->numberOfRelocations;
    if (D.20401 != 0) goto <D.20397>; else goto <D.20398>;
    <D.20397>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20402>; else goto <D.20403>;
    <D.20402>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20404 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t handle section relocation");
      vinfo->info.message = D.20404;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20405 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20405;
    }
    <D.20403>:
    ctx->valid = 0;
    return;
    <D.20398>:
    flags = MEM[(const guint32 *)ptr + 36B];
    if (flags == 0) goto <D.20406>; else goto <D.20408>;
    <D.20408>:
    D.20409 = flags & 33554207;
    if (D.20409 != 0) goto <D.20406>; else goto <D.20407>;
    <D.20406>:
    D.20347 = ctx->report_error;
    if (D.20347 != 0) goto <D.20410>; else goto <D.20411>;
    <D.20410>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20412 = monoeg_g_strdup_printf ("Invalid section flags %x", flags);
      vinfo->info.message = D.20412;
      vinfo->exception_type = 3;
      D.20351 = ctx->errors;
      D.20413 = monoeg_g_slist_prepend (D.20351, vinfo);
      ctx->errors = D.20413;
    }
    <D.20411>:
    ctx->valid = 0;
    return;
    <D.20407>:
    ptr = ptr + 40;
  }
  i = i + 1;
  <D.18362>:
  D.20340 = (int) num_sections;
  if (D.20340 > i) goto <D.18361>; else goto <D.18363>;
  <D.18363>:
}


load_data_directories (struct VerifyContext * ctx)
{
  unsigned int D.20415;
  const char * D.20416;
  sizetype D.20417;
  unsigned int D.20420;
  int D.20423;
  int D.20426;
  gchar * D.20429;
  struct GSList * D.20430;
  struct GSList * D.20431;
  int D.20434;
  gchar * D.20439;
  struct GSList * D.20440;
  unsigned int D.20441;
  guint32 offset;
  const char * ptr;
  int i;

  D.20415 = pe_header_offset (ctx);
  offset = D.20415 + 116;
  D.20416 = ctx->data;
  D.20417 = (sizetype) offset;
  ptr = D.20416 + D.20417;
  i = 0;
  goto <D.18379>;
  <D.18378>:
  {
    guint32 rva;
    guint32 size;

    rva = MEM[(const guint32 *)ptr];
    size = MEM[(const guint32 *)ptr + 4B];
    if (i == 4) goto <D.20418>; else goto <D.20419>;
    <D.20418>:
    ptr = ptr + 8;
    // predicted unlikely by continue predictor.
    goto <D.18375>;
    <D.20419>:
    D.20420 = rva | size;
    if (D.20420 != 0) goto <D.20421>; else goto <D.20422>;
    <D.20421>:
    D.20423 = is_valid_data_directory (i);
    if (D.20423 == 0) goto <D.20424>; else goto <D.20425>;
    <D.20424>:
    D.20426 = ctx->report_error;
    if (D.20426 != 0) goto <D.20427>; else goto <D.20428>;
    <D.20427>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20429 = monoeg_g_strdup_printf ("Invalid data directory %d", i);
      vinfo->info.message = D.20429;
      vinfo->exception_type = 3;
      D.20430 = ctx->errors;
      D.20431 = monoeg_g_slist_prepend (D.20430, vinfo);
      ctx->errors = D.20431;
    }
    <D.20428>:
    ctx->valid = 0;
    return;
    <D.20425>:
    <D.20422>:
    if (rva != 0) goto <D.20432>; else goto <D.20433>;
    <D.20432>:
    D.20434 = bounds_check_virtual_address (ctx, rva, size);
    if (D.20434 == 0) goto <D.20435>; else goto <D.20436>;
    <D.20435>:
    D.20426 = ctx->report_error;
    if (D.20426 != 0) goto <D.20437>; else goto <D.20438>;
    <D.20437>:
    {
      struct MonoVerifyInfoExtended * vinfo;

      vinfo = monoeg_malloc (24);
      vinfo->info.status = 1;
      D.20439 = monoeg_g_strdup_printf ("Invalid data directory %d rva/size pair %x/%x", i, rva, size);
      vinfo->info.message = D.20439;
      vinfo->exception_type = 3;
      D.20430 = ctx->errors;
      D.20440 = monoeg_g_slist_prepend (D.20430, vinfo);
      ctx->errors = D.20440;
    }
    <D.20438>:
    ctx->valid = 0;
    return;
    <D.20436>:
    <D.20433>:
    ctx->data_directories[i].rva = rva;
    ctx->data_directories[i].size = size;
    D.20441 = translate_rva (ctx, rva);
    ctx->data_directories[i].translated_offset = D.20441;
    ptr = ptr + 8;
  }
  <D.18375>:
  i = i + 1;
  <D.18379>:
  if (i <= 15) goto <D.18378>; else goto <D.18380>;
  <D.18380>:
}


is_valid_data_directory (int i)
{
  gboolean D.20443;
  int iftmp.0;
  unsigned int i.1;
  unsigned int D.20449;

  i.1 = (unsigned int) i;
  D.20449 = i.1 + 4294967295;
  if (D.20449 <= 1) goto <D.20445>; else goto <D.20450>;
  <D.20450>:
  if (i == 5) goto <D.20445>; else goto <D.20451>;
  <D.20451>:
  if (i == 12) goto <D.20445>; else goto <D.20452>;
  <D.20452>:
  if (i == 14) goto <D.20445>; else goto <D.20453>;
  <D.20453>:
  if (i == 4) goto <D.20445>; else goto <D.20454>;
  <D.20454>:
  if (i == 6) goto <D.20445>; else goto <D.20446>;
  <D.20445>:
  iftmp.0 = 1;
  goto <D.20447>;
  <D.20446>:
  iftmp.0 = 0;
  <D.20447>:
  D.20443 = iftmp.0;
  return D.20443;
}


bounds_check_virtual_address (struct VerifyContext * ctx, guint32 rva, guint32 size)
{
  unsigned int D.20456;
  gboolean D.20459;
  int D.20460;
  struct MonoImage * D.20463;
  unsigned int D.20464;
  struct SectionHeader * D.20469;
  long unsigned int D.20472;
  long unsigned int D.20473;
  struct SectionHeader * D.20474;
  unsigned int D.20475;
  unsigned int D.20476;
  unsigned int i.2;
  unsigned int D.20482;
  int i;

  D.20456 = rva + size;
  if (D.20456 < rva) goto <D.20457>; else goto <D.20458>;
  <D.20457>:
  D.20459 = 0;
  return D.20459;
  <D.20458>:
  D.20460 = ctx->stage;
  if (D.20460 > 0) goto <D.20461>; else goto <D.20462>;
  <D.20461>:
  {
    struct MonoCLIImageInfo * iinfo;
    const int top;
    struct MonoSectionTable * tables;
    int i;

    D.20463 = ctx->image;
    iinfo = D.20463->image_info;
    top = iinfo->cli_section_count;
    tables = iinfo->cli_section_tables;
    i = 0;
    goto <D.18281>;
    <D.18280>:
    {
      guint32 base;
      guint32 end;

      base = tables->st_virtual_address;
      D.20464 = tables->st_raw_data_size;
      end = D.20464 + base;
      if (rva >= base) goto <D.20465>; else goto <D.20466>;
      <D.20465>:
      D.20456 = rva + size;
      if (D.20456 <= end) goto <D.20467>; else goto <D.20468>;
      <D.20467>:
      D.20459 = 1;
      return D.20459;
      <D.20468>:
      <D.20466>:
      tables = tables + 40;
    }
    i = i + 1;
    <D.18281>:
    if (i < top) goto <D.18280>; else goto <D.18282>;
    <D.18282>:
    D.20459 = 0;
    return D.20459;
  }
  <D.20462>:
  D.20469 = ctx->sections;
  if (D.20469 == 0B) goto <D.20470>; else goto <D.20471>;
  <D.20470>:
  D.20459 = 0;
  return D.20459;
  <D.20471>:
  i = 0;
  goto <D.18286>;
  <D.18285>:
  {
    guint32 base;
    guint32 end;

    D.20469 = ctx->sections;
    D.20472 = (long unsigned int) i;
    D.20473 = D.20472 * 20;
    D.20474 = D.20469 + D.20473;
    base = D.20474->baseRVA;
    D.20469 = ctx->sections;
    D.20472 = (long unsigned int) i;
    D.20473 = D.20472 * 20;
    D.20474 = D.20469 + D.20473;
    D.20475 = D.20474->baseRVA;
    D.20469 = ctx->sections;
    D.20472 = (long unsigned int) i;
    D.20473 = D.20472 * 20;
    D.20474 = D.20469 + D.20473;
    D.20476 = D.20474->size;
    end = D.20475 + D.20476;
    if (rva >= base) goto <D.20477>; else goto <D.20478>;
    <D.20477>:
    D.20456 = rva + size;
    if (D.20456 <= end) goto <D.20479>; else goto <D.20480>;
    <D.20479>:
    D.20459 = 1;
    return D.20459;
    <D.20480>:
    <D.20478>:
  }
  i = i + 1;
  <D.18286>:
  i.2 = (unsigned int) i;
  D.20482 = ctx->section_count;
  if (i.2 < D.20482) goto <D.18285>; else goto <D.18287>;
  <D.18287>:
  D.20459 = 0;
  return D.20459;
}


translate_rva (struct VerifyContext * ctx, guint32 rva)
{
  int D.20484;
  guint32 D.20487;
  struct MonoImage * D.20488;
  struct SectionHeader * D.20489;
  long unsigned int D.20492;
  long unsigned int D.20493;
  struct SectionHeader * D.20494;
  unsigned int D.20495;
  unsigned int D.20496;
  unsigned int D.20501;
  unsigned int D.20502;
  guint32 iftmp.3;
  unsigned int D.20504;
  unsigned int i.4;
  unsigned int D.20509;
  int i;

  D.20484 = ctx->stage;
  if (D.20484 > 0) goto <D.20485>; else goto <D.20486>;
  <D.20485>:
  D.20488 = ctx->image;
  D.20487 = mono_cli_rva_image_map (D.20488, rva);
  return D.20487;
  <D.20486>:
  D.20489 = ctx->sections;
  if (D.20489 == 0B) goto <D.20490>; else goto <D.20491>;
  <D.20490>:
  D.20487 = 0;
  return D.20487;
  <D.20491>:
  i = 0;
  goto <D.18307>;
  <D.18306>:
  {
    guint32 base;
    guint32 end;

    D.20489 = ctx->sections;
    D.20492 = (long unsigned int) i;
    D.20493 = D.20492 * 20;
    D.20494 = D.20489 + D.20493;
    base = D.20494->baseRVA;
    D.20489 = ctx->sections;
    D.20492 = (long unsigned int) i;
    D.20493 = D.20492 * 20;
    D.20494 = D.20489 + D.20493;
    D.20495 = D.20494->baseRVA;
    D.20489 = ctx->sections;
    D.20492 = (long unsigned int) i;
    D.20493 = D.20492 * 20;
    D.20494 = D.20489 + D.20493;
    D.20496 = D.20494->size;
    end = D.20495 + D.20496;
    if (rva >= base) goto <D.20497>; else goto <D.20498>;
    <D.20497>:
    if (rva <= end) goto <D.20499>; else goto <D.20500>;
    <D.20499>:
    {
      guint32 res;

      D.20501 = rva - base;
      D.20489 = ctx->sections;
      D.20492 = (long unsigned int) i;
      D.20493 = D.20492 * 20;
      D.20494 = D.20489 + D.20493;
      D.20502 = D.20494->baseOffset;
      res = D.20501 + D.20502;
      D.20504 = ctx->size;
      if (D.20504 > res) goto <D.20505>; else goto <D.20506>;
      <D.20505>:
      iftmp.3 = res;
      goto <D.20507>;
      <D.20506>:
      iftmp.3 = 4294967295;
      <D.20507>:
      D.20487 = iftmp.3;
      return D.20487;
    }
    <D.20500>:
    <D.20498>:
  }
  i = i + 1;
  <D.18307>:
  i.4 = (unsigned int) i;
  D.20509 = ctx->section_count;
  if (i.4 < D.20509) goto <D.18306>; else goto <D.18308>;
  <D.18308>:
  D.20487 = 4294967295;
  return D.20487;
}


verify_import_table (struct VerifyContext * ctx)
{
  const char * D.20511;
  sizetype D.20512;
  _Bool D.20513;
  long int D.20514;
  long int D.20515;
  unsigned int D.20518;
  int D.20521;
  gchar * D.20524;
  struct GSList * D.20525;
  struct GSList * D.20526;
  int D.20529;
  gchar * D.20534;
  struct GSList * D.20535;
  int D.20538;
  gchar * D.20543;
  struct GSList * D.20544;
  int D.20547;
  gchar * D.20552;
  struct GSList * D.20553;
  unsigned int D.20554;
  const guint32 * D.20559;
  unsigned int D.20560;
  gchar * D.20561;
  struct GSList * D.20562;
  _Bool D.20565;
  long int D.20566;
  long int D.20567;
  sizetype D.20570;
  int D.20571;
  gchar * D.20576;
  struct GSList * D.20577;
  int D.20580;
  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.20511 = ctx->data;
      D.20512 = (sizetype) offset;
      ptr = D.20511 + D.20512;
      D.20513 = offset == 4294967295;
      D.20514 = (long int) D.20513;
      D.20515 = __builtin_expect (D.20514, 0);
      if (D.20515 != 0) goto <D.20516>; else goto <D.20517>;
      <D.20516>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 612, "offset != INVALID_OFFSET");
      <D.20517>:
      D.20518 = it.size;
      if (D.20518 <= 39) goto <D.20519>; else goto <D.20520>;
      <D.20519>:
      D.20521 = ctx->report_error;
      if (D.20521 != 0) goto <D.20522>; else goto <D.20523>;
      <D.20522>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20518 = it.size;
        D.20524 = monoeg_g_strdup_printf ("Import table size %d is smaller than 40", D.20518);
        vinfo->info.message = D.20524;
        vinfo->exception_type = 3;
        D.20525 = ctx->errors;
        D.20526 = monoeg_g_slist_prepend (D.20525, vinfo);
        ctx->errors = D.20526;
      }
      <D.20523>:
      ctx->valid = 0;
      return;
      <D.20520>:
      ilt_rva = MEM[(const guint32 *)ptr];
      if (ilt_rva != 0) goto <D.20527>; else goto <D.20528>;
      <D.20527>:
      D.20529 = bounds_check_virtual_address (ctx, ilt_rva, 8);
      if (D.20529 == 0) goto <D.20530>; else goto <D.20531>;
      <D.20530>:
      D.20521 = ctx->report_error;
      if (D.20521 != 0) goto <D.20532>; else goto <D.20533>;
      <D.20532>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20534 = monoeg_g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva);
        vinfo->info.message = D.20534;
        vinfo->exception_type = 3;
        D.20525 = ctx->errors;
        D.20535 = monoeg_g_slist_prepend (D.20525, vinfo);
        ctx->errors = D.20535;
      }
      <D.20533>:
      ctx->valid = 0;
      return;
      <D.20531>:
      <D.20528>:
      name_rva = MEM[(const guint32 *)ptr + 12B];
      if (name_rva != 0) goto <D.20536>; else goto <D.20537>;
      <D.20536>:
      D.20538 = bounds_check_virtual_address (ctx, name_rva, 12);
      if (D.20538 == 0) goto <D.20539>; else goto <D.20540>;
      <D.20539>:
      D.20521 = ctx->report_error;
      if (D.20521 != 0) goto <D.20541>; else goto <D.20542>;
      <D.20541>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20543 = monoeg_g_strdup_printf ("Invalid Import Table Name rva %x", name_rva);
        vinfo->info.message = D.20543;
        vinfo->exception_type = 3;
        D.20525 = ctx->errors;
        D.20544 = monoeg_g_slist_prepend (D.20525, vinfo);
        ctx->errors = D.20544;
      }
      <D.20542>:
      ctx->valid = 0;
      return;
      <D.20540>:
      <D.20537>:
      iat_rva = MEM[(const guint32 *)ptr + 16B];
      if (iat_rva != 0) goto <D.20545>; else goto <D.20546>;
      <D.20545>:
      D.20547 = bounds_check_virtual_address (ctx, iat_rva, 8);
      if (D.20547 == 0) goto <D.20548>; else goto <D.20549>;
      <D.20548>:
      D.20521 = ctx->report_error;
      if (D.20521 != 0) goto <D.20550>; else goto <D.20551>;
      <D.20550>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20552 = monoeg_g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva);
        vinfo->info.message = D.20552;
        vinfo->exception_type = 3;
        D.20525 = ctx->errors;
        D.20553 = monoeg_g_slist_prepend (D.20525, vinfo);
        ctx->errors = D.20553;
      }
      <D.20551>:
      ctx->valid = 0;
      return;
      <D.20549>:
      D.20554 = ctx->data_directories[12].rva;
      if (D.20554 != iat_rva) goto <D.20555>; else goto <D.20556>;
      <D.20555>:
      D.20521 = ctx->report_error;
      if (D.20521 != 0) goto <D.20557>; else goto <D.20558>;
      <D.20557>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20559 = ptr + 16;
        D.20560 = *D.20559;
        D.20554 = ctx->data_directories[12].rva;
        D.20561 = monoeg_g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", D.20560, D.20554);
        vinfo->info.message = D.20561;
        vinfo->exception_type = 3;
        D.20525 = ctx->errors;
        D.20562 = monoeg_g_slist_prepend (D.20525, vinfo);
        ctx->errors = D.20562;
      }
      <D.20558>:
      ctx->valid = 0;
      return;
      <D.20556>:
      <D.20546>:
      if (name_rva != 0) goto <D.20563>; else goto <D.20564>;
      <D.20563>:
      name_rva = translate_rva (ctx, name_rva);
      D.20565 = name_rva == 4294967295;
      D.20566 = (long int) D.20565;
      D.20567 = __builtin_expect (D.20566, 0);
      if (D.20567 != 0) goto <D.20568>; else goto <D.20569>;
      <D.20568>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 636, "name_rva != INVALID_OFFSET");
      <D.20569>:
      D.20511 = ctx->data;
      D.20570 = (sizetype) name_rva;
      ptr = D.20511 + D.20570;
      D.20571 = memcmp ("mscoree.dll", ptr, 12);
      if (D.20571 != 0) goto <D.20572>; else goto <D.20573>;
      <D.20572>:
      {
        char name[12];

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

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.20576 = monoeg_g_strdup_printf ("Invalid Import Table Name: \'%s\'", &name);
              vinfo->info.message = D.20576;
              vinfo->exception_type = 3;
              D.20525 = ctx->errors;
              D.20577 = monoeg_g_slist_prepend (D.20525, vinfo);
              ctx->errors = D.20577;
            }
            <D.20575>:
            ctx->valid = 0;
            return;
          }
        finally
          {
            name = {CLOBBER};
          }
      }
      <D.20573>:
      <D.20564>:
      if (ilt_rva != 0) goto <D.20578>; else goto <D.20579>;
      <D.20578>:
      verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
      D.20580 = ctx->valid;
      if (D.20580 == 0) goto <D.20581>; else goto <D.20582>;
      <D.20581>:
      return;
      <D.20582>:
      <D.20579>:
      if (iat_rva != 0) goto <D.20583>; else goto <D.20584>;
      <D.20583>:
      verify_hint_name_table (ctx, iat_rva, "Import Address Table");
      <D.20584>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


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

  D.20590 = __builtin_object_size (__dest, 0);
  D.20589 = __builtin___memcpy_chk (__dest, __src, __len, D.20590);
  return D.20589;
}


verify_hint_name_table (struct VerifyContext * ctx, guint32 import_rva, const char * table_name)
{
  _Bool D.20592;
  long int D.20593;
  long int D.20594;
  const char * D.20597;
  sizetype D.20598;
  const guint32 * D.20599;
  int D.20600;
  int D.20603;
  gchar * D.20606;
  struct GSList * D.20607;
  struct GSList * D.20608;
  _Bool D.20609;
  long int D.20610;
  long int D.20611;
  sizetype D.20614;
  sizetype D.20615;
  int D.20616;
  int D.20619;
  gchar * D.20624;
  struct GSList * D.20625;
  const char * ptr;
  guint32 hint_table_rva;

  import_rva = translate_rva (ctx, import_rva);
  D.20592 = import_rva == 4294967295;
  D.20593 = (long int) D.20592;
  D.20594 = __builtin_expect (D.20593, 0);
  if (D.20594 != 0) goto <D.20595>; else goto <D.20596>;
  <D.20595>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 586, "import_rva != INVALID_OFFSET");
  <D.20596>:
  D.20597 = ctx->data;
  D.20598 = (sizetype) import_rva;
  D.20599 = D.20597 + D.20598;
  hint_table_rva = *D.20599;
  D.20600 = bounds_check_virtual_address (ctx, hint_table_rva, 14);
  if (D.20600 == 0) goto <D.20601>; else goto <D.20602>;
  <D.20601>:
  D.20603 = ctx->report_error;
  if (D.20603 != 0) goto <D.20604>; else goto <D.20605>;
  <D.20604>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.20606 = monoeg_g_strdup_printf ("Invalid Hint/Name rva %d for %s", hint_table_rva, table_name);
    vinfo->info.message = D.20606;
    vinfo->exception_type = 3;
    D.20607 = ctx->errors;
    D.20608 = monoeg_g_slist_prepend (D.20607, vinfo);
    ctx->errors = D.20608;
  }
  <D.20605>:
  ctx->valid = 0;
  return;
  <D.20602>:
  hint_table_rva = translate_rva (ctx, hint_table_rva);
  D.20609 = hint_table_rva == 4294967295;
  D.20610 = (long int) D.20609;
  D.20611 = __builtin_expect (D.20610, 0);
  if (D.20611 != 0) goto <D.20612>; else goto <D.20613>;
  <D.20612>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 593, "hint_table_rva != INVALID_OFFSET");
  <D.20613>:
  D.20597 = ctx->data;
  D.20614 = (sizetype) hint_table_rva;
  D.20615 = D.20614 + 2;
  ptr = D.20597 + D.20615;
  D.20616 = memcmp ("_CorExeMain", ptr, 12);
  if (D.20616 != 0) goto <D.20617>; else goto <D.20618>;
  <D.20617>:
  D.20619 = memcmp ("_CorDllMain", ptr, 12);
  if (D.20619 != 0) goto <D.20620>; else goto <D.20621>;
  <D.20620>:
  {
    char name[12];

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

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20624 = monoeg_g_strdup_printf ("Invalid Hint / Name: \'%s\'", &name);
          vinfo->info.message = D.20624;
          vinfo->exception_type = 3;
          D.20607 = ctx->errors;
          D.20625 = monoeg_g_slist_prepend (D.20607, vinfo);
          ctx->errors = D.20625;
        }
        <D.20623>:
        ctx->valid = 0;
        return;
      }
    finally
      {
        name = {CLOBBER};
      }
  }
  <D.20621>:
  <D.20618>:
}


verify_resources_table (struct VerifyContext * ctx)
{
  unsigned int D.20628;
  unsigned int D.20631;
  int D.20634;
  gchar * D.20637;
  struct GSList * D.20638;
  struct GSList * D.20639;
  const char * D.20640;
  sizetype D.20641;
  sizetype D.20642;
  _Bool D.20643;
  long int D.20644;
  long int D.20645;
  int D.20648;
  int D.20649;
  int D.20650;
  int D.20651;
  int D.20652;
  unsigned int D.20653;
  gchar * D.20658;
  struct GSList * D.20659;
  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.20628 = it.rva;
      if (D.20628 == 0) goto <D.20629>; else goto <D.20630>;
      <D.20629>:
      return;
      <D.20630>:
      D.20631 = it.size;
      if (D.20631 <= 15) goto <D.20632>; else goto <D.20633>;
      <D.20632>:
      D.20634 = ctx->report_error;
      if (D.20634 != 0) goto <D.20635>; else goto <D.20636>;
      <D.20635>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20631 = it.size;
        D.20637 = monoeg_g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it\'s %d long", D.20631);
        vinfo->info.message = D.20637;
        vinfo->exception_type = 3;
        D.20638 = ctx->errors;
        D.20639 = monoeg_g_slist_prepend (D.20638, vinfo);
        ctx->errors = D.20639;
      }
      <D.20636>:
      ctx->valid = 0;
      return;
      <D.20633>:
      offset = it.translated_offset;
      D.20640 = ctx->data;
      D.20641 = (sizetype) offset;
      ptr = D.20640 + D.20641;
      root = ptr;
      D.20631 = it.size;
      D.20642 = (sizetype) D.20631;
      end = root + D.20642;
      D.20643 = offset == 4294967295;
      D.20644 = (long int) D.20643;
      D.20645 = __builtin_expect (D.20644, 0);
      if (D.20645 != 0) goto <D.20646>; else goto <D.20647>;
      <D.20646>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 674, "offset != INVALID_OFFSET");
      <D.20647>:
      named_entries = MEM[(const guint16 *)ptr + 12B];
      id_entries = MEM[(const guint16 *)ptr + 14B];
      D.20648 = (int) named_entries;
      D.20649 = (int) id_entries;
      D.20650 = D.20648 + D.20649;
      D.20651 = D.20650 + 2;
      D.20652 = D.20651 * 8;
      D.20653 = (unsigned int) D.20652;
      D.20631 = it.size;
      if (D.20653 > D.20631) goto <D.20654>; else goto <D.20655>;
      <D.20654>:
      D.20634 = ctx->report_error;
      if (D.20634 != 0) goto <D.20656>; else goto <D.20657>;
      <D.20656>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20648 = (int) named_entries;
        D.20649 = (int) id_entries;
        D.20650 = D.20648 + D.20649;
        D.20631 = it.size;
        D.20658 = monoeg_g_strdup_printf ("Resource section is too small, the number of entries (%d) doesn\'t fit on it\'s size %d", D.20650, D.20631);
        vinfo->info.message = D.20658;
        vinfo->exception_type = 3;
        D.20638 = ctx->errors;
        D.20659 = monoeg_g_slist_prepend (D.20638, vinfo);
        ctx->errors = D.20659;
      }
      <D.20657>:
      ctx->valid = 0;
      return;
      <D.20655>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


cleanup_context (struct VerifyContext * ctx, struct GSList * * error_list)
{
  struct SectionHeader * D.20663;
  struct GSList * D.20666;
  gboolean D.20668;

  D.20663 = ctx->sections;
  monoeg_g_free (D.20663);
  if (error_list != 0B) goto <D.20664>; else goto <D.20665>;
  <D.20664>:
  D.20666 = ctx->errors;
  *error_list = D.20666;
  goto <D.20667>;
  <D.20665>:
  D.20666 = ctx->errors;
  mono_free_verify_list (D.20666);
  <D.20667>:
  D.20668 = ctx->valid;
  return D.20668;
}


mono_verifier_verify_cli_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.20670;
  gboolean D.20673;
  _Bool D.20674;
  int D.20675;
  int D.20676;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.20670 = mono_verifier_is_enabled_for_image (image);
      if (D.20670 == 0) goto <D.20671>; else goto <D.20672>;
      <D.20671>:
      D.20673 = 1;
      return D.20673;
      <D.20672>:
      D.20674 = error_list != 0B;
      D.20675 = (int) D.20674;
      init_verify_context (&ctx, image, D.20675);
      ctx.stage = 1;
      verify_cli_header (&ctx);
      D.20676 = ctx.valid;
      if (D.20676 == 0) goto cleanup; else goto <D.20677>;
      <D.20677>:
      verify_metadata_header (&ctx);
      D.20676 = ctx.valid;
      if (D.20676 == 0) goto cleanup; else goto <D.20678>;
      <D.20678>:
      verify_tables_schema (&ctx);
      cleanup:
      D.20673 = cleanup_context (&ctx, error_list);
      return D.20673;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_cli_header (struct VerifyContext * ctx)
{
  unsigned int D.20681;
  int D.20684;
  gchar * D.20687;
  struct GSList * D.20688;
  struct GSList * D.20689;
  unsigned int D.20690;
  gchar * D.20695;
  struct GSList * D.20696;
  const char * D.20697;
  sizetype D.20698;
  _Bool D.20699;
  long int D.20700;
  long int D.20701;
  short unsigned int D.20704;
  int D.20709;
  gchar * D.20710;
  struct GSList * D.20711;
  const guint32 * D.20712;
  unsigned int D.20713;
  const guint32 * D.20714;
  unsigned int D.20715;
  int D.20716;
  gchar * D.20721;
  struct GSList * D.20722;
  gchar * D.20728;
  struct GSList * D.20729;
  const guint32 * D.20730;
  unsigned int D.20731;
  unsigned int D.20732;
  gchar * D.20737;
  struct GSList * D.20738;
  int D.20741;
  gchar * D.20746;
  struct GSList * D.20747;
  gchar * D.20754;
  struct GSList * D.20755;
  struct DataDirectory it;
  guint32 offset;
  const char * ptr;
  int i;

  try
    {
      it = get_data_dir (ctx, 14);
      D.20681 = it.rva;
      if (D.20681 == 0) goto <D.20682>; else goto <D.20683>;
      <D.20682>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20685>; else goto <D.20686>;
      <D.20685>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20687 = monoeg_g_strdup_printf ("CLI header missing");
        vinfo->info.message = D.20687;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20689 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20689;
      }
      <D.20686>:
      ctx->valid = 0;
      return;
      <D.20683>:
      D.20690 = it.size;
      if (D.20690 != 72) goto <D.20691>; else goto <D.20692>;
      <D.20691>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20693>; else goto <D.20694>;
      <D.20693>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20690 = it.size;
        D.20695 = monoeg_g_strdup_printf ("Invalid cli header size in data directory %d must be 72", D.20690);
        vinfo->info.message = D.20695;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20696 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20696;
      }
      <D.20694>:
      ctx->valid = 0;
      return;
      <D.20692>:
      offset = it.translated_offset;
      D.20697 = ctx->data;
      D.20698 = (sizetype) offset;
      ptr = D.20697 + D.20698;
      D.20699 = offset == 4294967295;
      D.20700 = (long int) D.20699;
      D.20701 = __builtin_expect (D.20700, 0);
      if (D.20701 != 0) goto <D.20702>; else goto <D.20703>;
      <D.20702>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 721, "offset != INVALID_OFFSET");
      <D.20703>:
      D.20704 = MEM[(const guint16 *)ptr];
      if (D.20704 != 72) goto <D.20705>; else goto <D.20706>;
      <D.20705>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20707>; else goto <D.20708>;
      <D.20707>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20704 = MEM[(const guint16 *)ptr];
        D.20709 = (int) D.20704;
        D.20710 = monoeg_g_strdup_printf ("Invalid cli header size %d must be 72", D.20709);
        vinfo->info.message = D.20710;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20711 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20711;
      }
      <D.20708>:
      ctx->valid = 0;
      return;
      <D.20706>:
      D.20712 = ptr + 8;
      D.20713 = *D.20712;
      D.20714 = ptr + 12;
      D.20715 = *D.20714;
      D.20716 = bounds_check_virtual_address (ctx, D.20713, D.20715);
      if (D.20716 == 0) goto <D.20717>; else goto <D.20718>;
      <D.20717>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20719>; else goto <D.20720>;
      <D.20719>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20712 = ptr + 8;
        D.20713 = *D.20712;
        D.20714 = ptr + 12;
        D.20715 = *D.20714;
        D.20721 = monoeg_g_strdup_printf ("Invalid medatata section rva/size pair %x/%x", D.20713, D.20715);
        vinfo->info.message = D.20721;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20722 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20722;
      }
      <D.20720>:
      ctx->valid = 0;
      return;
      <D.20718>:
      D.20712 = ptr + 8;
      D.20713 = *D.20712;
      if (D.20713 == 0) goto <D.20723>; else goto <D.20725>;
      <D.20725>:
      D.20714 = ptr + 12;
      D.20715 = *D.20714;
      if (D.20715 == 0) goto <D.20723>; else goto <D.20724>;
      <D.20723>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20726>; else goto <D.20727>;
      <D.20726>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20728 = monoeg_g_strdup_printf ("Missing medatata section in the CLI header");
        vinfo->info.message = D.20728;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20729 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20729;
      }
      <D.20727>:
      ctx->valid = 0;
      return;
      <D.20724>:
      D.20730 = ptr + 16;
      D.20731 = *D.20730;
      D.20732 = D.20731 & 4294901748;
      if (D.20732 != 0) goto <D.20733>; else goto <D.20734>;
      <D.20733>:
      D.20684 = ctx->report_error;
      if (D.20684 != 0) goto <D.20735>; else goto <D.20736>;
      <D.20735>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20737 = monoeg_g_strdup_printf ("Invalid CLI header flags");
        vinfo->info.message = D.20737;
        vinfo->exception_type = 3;
        D.20688 = ctx->errors;
        D.20738 = monoeg_g_slist_prepend (D.20688, vinfo);
        ctx->errors = D.20738;
      }
      <D.20736>:
      ctx->valid = 0;
      return;
      <D.20734>:
      ptr = ptr + 24;
      i = 0;
      goto <D.18444>;
      <D.18443>:
      {
        guint32 rva;
        guint32 size;

        rva = MEM[(const guint32 *)ptr];
        size = MEM[(const guint32 *)ptr + 4B];
        if (rva != 0) goto <D.20739>; else goto <D.20740>;
        <D.20739>:
        D.20741 = bounds_check_virtual_address (ctx, rva, size);
        if (D.20741 == 0) goto <D.20742>; else goto <D.20743>;
        <D.20742>:
        D.20684 = ctx->report_error;
        if (D.20684 != 0) goto <D.20744>; else goto <D.20745>;
        <D.20744>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20746 = monoeg_g_strdup_printf ("Invalid cli section %i rva/size pair %x/%x", i, rva, size);
          vinfo->info.message = D.20746;
          vinfo->exception_type = 3;
          D.20688 = ctx->errors;
          D.20747 = monoeg_g_slist_prepend (D.20688, vinfo);
          ctx->errors = D.20747;
        }
        <D.20745>:
        ctx->valid = 0;
        return;
        <D.20743>:
        <D.20740>:
        ptr = ptr + 8;
        if (rva != 0) goto <D.20748>; else goto <D.20749>;
        <D.20748>:
        if (i > 1) goto <D.20750>; else goto <D.20751>;
        <D.20750>:
        D.20684 = ctx->report_error;
        if (D.20684 != 0) goto <D.20752>; else goto <D.20753>;
        <D.20752>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20754 = monoeg_g_strdup_printf ("Metadata verifier doesn\'t support cli header section %d", i);
          vinfo->info.message = D.20754;
          vinfo->exception_type = 3;
          D.20688 = ctx->errors;
          D.20755 = monoeg_g_slist_prepend (D.20688, vinfo);
          ctx->errors = D.20755;
        }
        <D.20753>:
        ctx->valid = 0;
        return;
        <D.20751>:
        <D.20749>:
      }
      i = i + 1;
      <D.18444>:
      if (i <= 5) goto <D.18443>; else goto <D.18445>;
      <D.18445>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


get_data_dir (struct VerifyContext * ctx, int idx)
{
  struct MonoImage * D.20759;
  long unsigned int D.20760;
  long unsigned int D.20761;
  unsigned int D.20762;
  unsigned int D.20763;
  unsigned int D.20764;
  unsigned int D.20765;
  struct DataDirectory D.20766;
  struct MonoCLIImageInfo * iinfo;
  struct MonoPEDirEntry * entry;
  struct DataDirectory res;

  try
    {
      D.20759 = ctx->image;
      iinfo = D.20759->image_info;
      entry = &iinfo->cli_header.datadir.pe_export_table;
      D.20760 = (long unsigned int) idx;
      D.20761 = D.20760 * 8;
      entry = entry + D.20761;
      D.20762 = entry->rva;
      res.rva = D.20762;
      D.20763 = entry->size;
      res.size = D.20763;
      D.20764 = res.rva;
      D.20765 = translate_rva (ctx, D.20764);
      res.translated_offset = D.20765;
      D.20766 = res;
      return D.20766;
    }
  finally
    {
      res = {CLOBBER};
    }
}


verify_metadata_header (struct VerifyContext * ctx)
{
  const char * D.20769;
  sizetype D.20770;
  _Bool D.20771;
  long int D.20772;
  long int D.20773;
  unsigned int D.20776;
  unsigned int D.20777;
  unsigned int D.20780;
  int D.20783;
  gchar * D.20786;
  struct GSList * D.20787;
  struct GSList * D.20788;
  gchar * D.20793;
  struct GSList * D.20794;
  const guint32 * D.20795;
  unsigned int D.20796;
  unsigned int D.20797;
  unsigned int D.20798;
  int D.20799;
  unsigned int D.20804;
  unsigned int D.20805;
  unsigned int D.20806;
  gchar * D.20807;
  struct GSList * D.20808;
  const guint16 * D.20809;
  short unsigned int D.20810;
  gchar * D.20815;
  struct GSList * D.20816;
  int D.20817;
  unsigned int D.20822;
  gchar * D.20823;
  struct GSList * D.20824;
  int D.20825;
  gchar * D.20830;
  struct GSList * D.20831;
  unsigned int offset.5;
  int D.20833;
  gchar * D.20838;
  struct GSList * D.20839;
  sizetype D.20840;
  const char * D.20841;
  char D.20842;
  gchar * D.20848;
  struct GSList * D.20849;
  int D.18480;
  int iftmp.6;
  int D.18476;
  const char[9] * D.20853;
  unsigned char D.20854;
  int D.20855;
  unsigned char D.20856;
  int D.20857;
  const unsigned char * D.20862;
  unsigned char D.20863;
  int D.20864;
  const unsigned char * D.20865;
  unsigned char D.20866;
  int D.20867;
  const unsigned char * D.20872;
  unsigned char D.20873;
  int D.20874;
  const unsigned char * D.20875;
  unsigned char D.20876;
  int D.20877;
  const unsigned char * D.20882;
  unsigned char D.20883;
  int D.20884;
  const unsigned char * D.20885;
  unsigned char D.20886;
  int D.20887;
  int D.18489;
  int iftmp.7;
  int D.18485;
  const char[4] * D.20895;
  unsigned char D.20896;
  int D.20897;
  unsigned char D.20898;
  int D.20899;
  const unsigned char * D.20904;
  unsigned char D.20905;
  int D.20906;
  const unsigned char * D.20907;
  unsigned char D.20908;
  int D.20909;
  const unsigned char * D.20914;
  unsigned char D.20915;
  int D.20916;
  const unsigned char * D.20917;
  unsigned char D.20918;
  int D.20919;
  const unsigned char * D.20924;
  unsigned char D.20925;
  int D.20926;
  const unsigned char * D.20927;
  unsigned char D.20928;
  int D.20929;
  int D.18498;
  int iftmp.8;
  int D.18494;
  const char[6] * D.20937;
  unsigned char D.20938;
  int D.20939;
  unsigned char D.20940;
  int D.20941;
  const unsigned char * D.20946;
  unsigned char D.20947;
  int D.20948;
  const unsigned char * D.20949;
  unsigned char D.20950;
  int D.20951;
  const unsigned char * D.20956;
  unsigned char D.20957;
  int D.20958;
  const unsigned char * D.20959;
  unsigned char D.20960;
  int D.20961;
  const unsigned char * D.20966;
  unsigned char D.20967;
  int D.20968;
  const unsigned char * D.20969;
  unsigned char D.20970;
  int D.20971;
  int D.18507;
  int iftmp.9;
  int D.18503;
  const char[6] * D.20979;
  unsigned char D.20980;
  int D.20981;
  unsigned char D.20982;
  int D.20983;
  const unsigned char * D.20988;
  unsigned char D.20989;
  int D.20990;
  const unsigned char * D.20991;
  unsigned char D.20992;
  int D.20993;
  const unsigned char * D.20998;
  unsigned char D.20999;
  int D.21000;
  const unsigned char * D.21001;
  unsigned char D.21002;
  int D.21003;
  const unsigned char * D.21008;
  unsigned char D.21009;
  int D.21010;
  const unsigned char * D.21011;
  unsigned char D.21012;
  int D.21013;
  int D.18516;
  int iftmp.10;
  int D.18512;
  const char[3] * D.21021;
  unsigned char D.21022;
  int D.21023;
  unsigned char D.21024;
  int D.21025;
  const unsigned char * D.21030;
  unsigned char D.21031;
  int D.21032;
  const unsigned char * D.21033;
  unsigned char D.21034;
  int D.21035;
  const unsigned char * D.21040;
  unsigned char D.21041;
  int D.21042;
  const unsigned char * D.21043;
  unsigned char D.21044;
  int D.21045;
  const unsigned char * D.21050;
  unsigned char D.21051;
  int D.21052;
  const unsigned char * D.21053;
  unsigned char D.21054;
  int D.21055;
  int D.21060;
  gchar * D.21063;
  struct GSList * D.21064;
  unsigned int D.21065;
  gchar * D.21070;
  struct GSList * D.21071;
  unsigned int i.11;
  unsigned int D.21073;
  gchar * D.21078;
  struct GSList * D.21079;
  unsigned int D.21080;
  gchar * D.21085;
  struct GSList * D.21086;
  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.20769 = ctx->data;
      D.20770 = (sizetype) offset;
      ptr = D.20769 + D.20770;
      D.20771 = offset == 4294967295;
      D.20772 = (long int) D.20771;
      D.20773 = __builtin_expect (D.20772, 0);
      if (D.20773 != 0) goto <D.20774>; else goto <D.20775>;
      <D.20774>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 769, "offset != INVALID_OFFSET");
      <D.20775>:
      ptr = ptr + 8;
      D.20776 = MEM[(const guint32 *)ptr];
      it.rva = D.20776;
      ptr = ptr + 4;
      D.20776 = MEM[(const guint32 *)ptr];
      it.size = D.20776;
      D.20777 = it.rva;
      offset = translate_rva (ctx, D.20777);
      it.translated_offset = offset;
      D.20769 = ctx->data;
      D.20770 = (sizetype) offset;
      ptr = D.20769 + D.20770;
      D.20771 = offset == 4294967295;
      D.20772 = (long int) D.20771;
      D.20773 = __builtin_expect (D.20772, 0);
      if (D.20773 != 0) goto <D.20778>; else goto <D.20779>;
      <D.20778>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 779, "offset != INVALID_OFFSET");
      <D.20779>:
      D.20780 = it.size;
      if (D.20780 <= 19) goto <D.20781>; else goto <D.20782>;
      <D.20781>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.20784>; else goto <D.20785>;
      <D.20784>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20780 = it.size;
        D.20786 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least 20 bytes required for initial decoding)", D.20780);
        vinfo->info.message = D.20786;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.20788 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.20788;
      }
      <D.20785>:
      ctx->valid = 0;
      return;
      <D.20782>:
      D.20776 = MEM[(const guint32 *)ptr];
      if (D.20776 != 1112167234) goto <D.20789>; else goto <D.20790>;
      <D.20789>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.20791>; else goto <D.20792>;
      <D.20791>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20776 = MEM[(const guint32 *)ptr];
        D.20793 = monoeg_g_strdup_printf ("Invalid metadata signature, expected 0x424A5342 but got %08x", D.20776);
        vinfo->info.message = D.20793;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.20794 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.20794;
      }
      <D.20792>:
      ctx->valid = 0;
      return;
      <D.20790>:
      D.20795 = ptr + 12;
      D.20796 = *D.20795;
      D.20797 = D.20796 + offset;
      D.20798 = D.20797 + 16;
      offset = pad4 (D.20798);
      D.20799 = bounds_check_datadir (&it, offset, 4);
      if (D.20799 == 0) goto <D.20800>; else goto <D.20801>;
      <D.20800>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.20802>; else goto <D.20803>;
      <D.20802>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20780 = it.size;
        D.20804 = it.translated_offset;
        D.20805 = offset - D.20804;
        D.20806 = D.20805 + 4;
        D.20807 = monoeg_g_strdup_printf ("Metadata root section is too small %d (at least %d bytes required for flags decoding)", D.20780, D.20806);
        vinfo->info.message = D.20807;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.20808 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.20808;
      }
      <D.20803>:
      ctx->valid = 0;
      return;
      <D.20801>:
      D.20769 = ctx->data;
      D.20770 = (sizetype) offset;
      ptr = D.20769 + D.20770;
      D.20809 = ptr + 2;
      D.20810 = *D.20809;
      section_count = (guint32) D.20810;
      if (section_count <= 1) goto <D.20811>; else goto <D.20812>;
      <D.20811>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.20813>; else goto <D.20814>;
      <D.20813>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.20815 = monoeg_g_strdup_printf ("Metadata root section must have at least 2 streams (#~ and #GUID)");
        vinfo->info.message = D.20815;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.20816 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.20816;
      }
      <D.20814>:
      ctx->valid = 0;
      return;
      <D.20812>:
      ptr = ptr + 4;
      offset = offset + 4;
      i = 0;
      goto <D.18521>;
      <D.18520>:
      {
        guint32 stream_off;
        guint32 stream_size;
        int string_size;
        int stream_idx;

        D.20817 = bounds_check_datadir (&it, offset, 8);
        if (D.20817 == 0) goto <D.20818>; else goto <D.20819>;
        <D.20818>:
        D.20783 = ctx->report_error;
        if (D.20783 != 0) goto <D.20820>; else goto <D.20821>;
        <D.20820>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20804 = it.translated_offset;
          D.20805 = offset - D.20804;
          D.20822 = D.20805 + 9;
          D.20823 = monoeg_g_strdup_printf ("Metadata root section is too small for initial decode of stream header %d, missing %d bytes", i, D.20822);
          vinfo->info.message = D.20823;
          vinfo->exception_type = 3;
          D.20787 = ctx->errors;
          D.20824 = monoeg_g_slist_prepend (D.20787, vinfo);
          ctx->errors = D.20824;
        }
        <D.20821>:
        ctx->valid = 0;
        return;
        <D.20819>:
        D.20804 = it.translated_offset;
        D.20776 = MEM[(const guint32 *)ptr];
        stream_off = D.20804 + D.20776;
        stream_size = MEM[(const guint32 *)ptr + 4B];
        D.20825 = bounds_check_datadir (&it, stream_off, stream_size);
        if (D.20825 == 0) goto <D.20826>; else goto <D.20827>;
        <D.20826>:
        D.20783 = ctx->report_error;
        if (D.20783 != 0) goto <D.20828>; else goto <D.20829>;
        <D.20828>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20830 = monoeg_g_strdup_printf ("Invalid stream header %d offset/size pair %x/%x", 0, stream_off, stream_size);
          vinfo->info.message = D.20830;
          vinfo->exception_type = 3;
          D.20787 = ctx->errors;
          D.20831 = monoeg_g_slist_prepend (D.20787, vinfo);
          ctx->errors = D.20831;
        }
        <D.20829>:
        ctx->valid = 0;
        return;
        <D.20827>:
        ptr = ptr + 8;
        offset = offset + 8;
        string_size = 0;
        goto <D.18470>;
        <D.18469>:
        offset.5 = offset;
        offset = offset.5 + 1;
        D.20833 = bounds_check_datadir (&it, offset.5, 1);
        if (D.20833 == 0) goto <D.20834>; else goto <D.20835>;
        <D.20834>:
        D.20783 = ctx->report_error;
        if (D.20783 != 0) goto <D.20836>; else goto <D.20837>;
        <D.20836>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.20838 = monoeg_g_strdup_printf ("Metadata root section is too small to decode stream header %d name", i);
          vinfo->info.message = D.20838;
          vinfo->exception_type = 3;
          D.20787 = ctx->errors;
          D.20839 = monoeg_g_slist_prepend (D.20787, vinfo);
          ctx->errors = D.20839;
        }
        <D.20837>:
        ctx->valid = 0;
        return;
        <D.20835>:
        D.20840 = (sizetype) string_size;
        D.20841 = ptr + D.20840;
        D.20842 = *D.20841;
        if (D.20842 == 0) goto <D.18468>; else goto <D.20843>;
        <D.20843>:
        string_size = string_size + 1;
        <D.18470>:
        if (string_size <= 31) goto <D.18469>; else goto <D.18468>;
        <D.18468>:
        D.20840 = (sizetype) string_size;
        D.20841 = ptr + D.20840;
        D.20842 = *D.20841;
        if (D.20842 != 0) goto <D.20844>; else goto <D.20845>;
        <D.20844>:
        D.20783 = ctx->report_error;
        if (D.20783 != 0) goto <D.20846>; else goto <D.20847>;
        <D.20846>:
        {
          struct MonoVerifyInfoExtended * vinfo;

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

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

            __s2 = ptr;
            D.20853 = "#Strings";
            D.20854 = MEM[(const unsigned char *)D.20853];
            D.20855 = (int) D.20854;
            D.20856 = *__s2;
            D.20857 = (int) D.20856;
            __result = D.20855 - D.20857;
            {
              if (__s1_len != 0) goto <D.20858>; else goto <D.20859>;
              <D.20858>:
              if (__result == 0) goto <D.20860>; else goto <D.20861>;
              <D.20860>:
              D.20862 = &MEM[(void *)"#Strings" + 1B];
              D.20863 = *D.20862;
              D.20864 = (int) D.20863;
              D.20865 = __s2 + 1;
              D.20866 = *D.20865;
              D.20867 = (int) D.20866;
              __result = D.20864 - D.20867;
              if (__s1_len > 1) goto <D.20868>; else goto <D.20869>;
              <D.20868>:
              if (__result == 0) goto <D.20870>; else goto <D.20871>;
              <D.20870>:
              D.20872 = &MEM[(void *)"#Strings" + 2B];
              D.20873 = *D.20872;
              D.20874 = (int) D.20873;
              D.20875 = __s2 + 2;
              D.20876 = *D.20875;
              D.20877 = (int) D.20876;
              __result = D.20874 - D.20877;
              if (__s1_len > 2) goto <D.20878>; else goto <D.20879>;
              <D.20878>:
              if (__result == 0) goto <D.20880>; else goto <D.20881>;
              <D.20880>:
              D.20882 = &MEM[(void *)"#Strings" + 3B];
              D.20883 = *D.20882;
              D.20884 = (int) D.20883;
              D.20885 = __s2 + 3;
              D.20886 = *D.20885;
              D.20887 = (int) D.20886;
              __result = D.20884 - D.20887;
              <D.20881>:
              <D.20879>:
              <D.20871>:
              <D.20869>:
              <D.20861>:
              <D.20859>:
            }
            D.18476 = __result;
          }
          iftmp.6 = D.18476;
          goto <D.20888>;
          <D.20852>:
          iftmp.6 = __builtin_strcmp ("#Strings", ptr);
          <D.20888>:
          D.18480 = iftmp.6;
        }
        if (D.18480 == 0) goto <D.20889>; else goto <D.20890>;
        <D.20889>:
        stream_idx = 0;
        goto <D.20891>;
        <D.20890>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20895 = "#US";
            D.20896 = MEM[(const unsigned char *)D.20895];
            D.20897 = (int) D.20896;
            D.20898 = *__s2;
            D.20899 = (int) D.20898;
            __result = D.20897 - D.20899;
            {
              if (__s1_len != 0) goto <D.20900>; else goto <D.20901>;
              <D.20900>:
              if (__result == 0) goto <D.20902>; else goto <D.20903>;
              <D.20902>:
              D.20904 = &MEM[(void *)"#US" + 1B];
              D.20905 = *D.20904;
              D.20906 = (int) D.20905;
              D.20907 = __s2 + 1;
              D.20908 = *D.20907;
              D.20909 = (int) D.20908;
              __result = D.20906 - D.20909;
              if (__s1_len > 1) goto <D.20910>; else goto <D.20911>;
              <D.20910>:
              if (__result == 0) goto <D.20912>; else goto <D.20913>;
              <D.20912>:
              D.20914 = &MEM[(void *)"#US" + 2B];
              D.20915 = *D.20914;
              D.20916 = (int) D.20915;
              D.20917 = __s2 + 2;
              D.20918 = *D.20917;
              D.20919 = (int) D.20918;
              __result = D.20916 - D.20919;
              if (__s1_len > 2) goto <D.20920>; else goto <D.20921>;
              <D.20920>:
              if (__result == 0) goto <D.20922>; else goto <D.20923>;
              <D.20922>:
              D.20924 = &MEM[(void *)"#US" + 3B];
              D.20925 = *D.20924;
              D.20926 = (int) D.20925;
              D.20927 = __s2 + 3;
              D.20928 = *D.20927;
              D.20929 = (int) D.20928;
              __result = D.20926 - D.20929;
              <D.20923>:
              <D.20921>:
              <D.20913>:
              <D.20911>:
              <D.20903>:
              <D.20901>:
            }
            D.18485 = __result;
          }
          iftmp.7 = D.18485;
          goto <D.20930>;
          <D.20894>:
          iftmp.7 = __builtin_strcmp ("#US", ptr);
          <D.20930>:
          D.18489 = iftmp.7;
        }
        if (D.18489 == 0) goto <D.20931>; else goto <D.20932>;
        <D.20931>:
        stream_idx = 1;
        goto <D.20933>;
        <D.20932>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20937 = "#Blob";
            D.20938 = MEM[(const unsigned char *)D.20937];
            D.20939 = (int) D.20938;
            D.20940 = *__s2;
            D.20941 = (int) D.20940;
            __result = D.20939 - D.20941;
            {
              if (__s1_len != 0) goto <D.20942>; else goto <D.20943>;
              <D.20942>:
              if (__result == 0) goto <D.20944>; else goto <D.20945>;
              <D.20944>:
              D.20946 = &MEM[(void *)"#Blob" + 1B];
              D.20947 = *D.20946;
              D.20948 = (int) D.20947;
              D.20949 = __s2 + 1;
              D.20950 = *D.20949;
              D.20951 = (int) D.20950;
              __result = D.20948 - D.20951;
              if (__s1_len > 1) goto <D.20952>; else goto <D.20953>;
              <D.20952>:
              if (__result == 0) goto <D.20954>; else goto <D.20955>;
              <D.20954>:
              D.20956 = &MEM[(void *)"#Blob" + 2B];
              D.20957 = *D.20956;
              D.20958 = (int) D.20957;
              D.20959 = __s2 + 2;
              D.20960 = *D.20959;
              D.20961 = (int) D.20960;
              __result = D.20958 - D.20961;
              if (__s1_len > 2) goto <D.20962>; else goto <D.20963>;
              <D.20962>:
              if (__result == 0) goto <D.20964>; else goto <D.20965>;
              <D.20964>:
              D.20966 = &MEM[(void *)"#Blob" + 3B];
              D.20967 = *D.20966;
              D.20968 = (int) D.20967;
              D.20969 = __s2 + 3;
              D.20970 = *D.20969;
              D.20971 = (int) D.20970;
              __result = D.20968 - D.20971;
              <D.20965>:
              <D.20963>:
              <D.20955>:
              <D.20953>:
              <D.20945>:
              <D.20943>:
            }
            D.18494 = __result;
          }
          iftmp.8 = D.18494;
          goto <D.20972>;
          <D.20936>:
          iftmp.8 = __builtin_strcmp ("#Blob", ptr);
          <D.20972>:
          D.18498 = iftmp.8;
        }
        if (D.18498 == 0) goto <D.20973>; else goto <D.20974>;
        <D.20973>:
        stream_idx = 2;
        goto <D.20975>;
        <D.20974>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.20979 = "#GUID";
            D.20980 = MEM[(const unsigned char *)D.20979];
            D.20981 = (int) D.20980;
            D.20982 = *__s2;
            D.20983 = (int) D.20982;
            __result = D.20981 - D.20983;
            {
              if (__s1_len != 0) goto <D.20984>; else goto <D.20985>;
              <D.20984>:
              if (__result == 0) goto <D.20986>; else goto <D.20987>;
              <D.20986>:
              D.20988 = &MEM[(void *)"#GUID" + 1B];
              D.20989 = *D.20988;
              D.20990 = (int) D.20989;
              D.20991 = __s2 + 1;
              D.20992 = *D.20991;
              D.20993 = (int) D.20992;
              __result = D.20990 - D.20993;
              if (__s1_len > 1) goto <D.20994>; else goto <D.20995>;
              <D.20994>:
              if (__result == 0) goto <D.20996>; else goto <D.20997>;
              <D.20996>:
              D.20998 = &MEM[(void *)"#GUID" + 2B];
              D.20999 = *D.20998;
              D.21000 = (int) D.20999;
              D.21001 = __s2 + 2;
              D.21002 = *D.21001;
              D.21003 = (int) D.21002;
              __result = D.21000 - D.21003;
              if (__s1_len > 2) goto <D.21004>; else goto <D.21005>;
              <D.21004>:
              if (__result == 0) goto <D.21006>; else goto <D.21007>;
              <D.21006>:
              D.21008 = &MEM[(void *)"#GUID" + 3B];
              D.21009 = *D.21008;
              D.21010 = (int) D.21009;
              D.21011 = __s2 + 3;
              D.21012 = *D.21011;
              D.21013 = (int) D.21012;
              __result = D.21010 - D.21013;
              <D.21007>:
              <D.21005>:
              <D.20997>:
              <D.20995>:
              <D.20987>:
              <D.20985>:
            }
            D.18503 = __result;
          }
          iftmp.9 = D.18503;
          goto <D.21014>;
          <D.20978>:
          iftmp.9 = __builtin_strcmp ("#GUID", ptr);
          <D.21014>:
          D.18507 = iftmp.9;
        }
        if (D.18507 == 0) goto <D.21015>; else goto <D.21016>;
        <D.21015>:
        stream_idx = 3;
        goto <D.21017>;
        <D.21016>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ptr;
            D.21021 = "#~";
            D.21022 = MEM[(const unsigned char *)D.21021];
            D.21023 = (int) D.21022;
            D.21024 = *__s2;
            D.21025 = (int) D.21024;
            __result = D.21023 - D.21025;
            {
              if (__s1_len != 0) goto <D.21026>; else goto <D.21027>;
              <D.21026>:
              if (__result == 0) goto <D.21028>; else goto <D.21029>;
              <D.21028>:
              D.21030 = &MEM[(void *)"#~" + 1B];
              D.21031 = *D.21030;
              D.21032 = (int) D.21031;
              D.21033 = __s2 + 1;
              D.21034 = *D.21033;
              D.21035 = (int) D.21034;
              __result = D.21032 - D.21035;
              if (__s1_len > 1) goto <D.21036>; else goto <D.21037>;
              <D.21036>:
              if (__result == 0) goto <D.21038>; else goto <D.21039>;
              <D.21038>:
              D.21040 = &MEM[(void *)"#~" + 2B];
              D.21041 = *D.21040;
              D.21042 = (int) D.21041;
              D.21043 = __s2 + 2;
              D.21044 = *D.21043;
              D.21045 = (int) D.21044;
              __result = D.21042 - D.21045;
              if (__s1_len > 2) goto <D.21046>; else goto <D.21047>;
              <D.21046>:
              if (__result == 0) goto <D.21048>; else goto <D.21049>;
              <D.21048>:
              D.21050 = &MEM[(void *)"#~" + 3B];
              D.21051 = *D.21050;
              D.21052 = (int) D.21051;
              D.21053 = __s2 + 3;
              D.21054 = *D.21053;
              D.21055 = (int) D.21054;
              __result = D.21052 - D.21055;
              <D.21049>:
              <D.21047>:
              <D.21039>:
              <D.21037>:
              <D.21029>:
              <D.21027>:
            }
            D.18512 = __result;
          }
          iftmp.10 = D.18512;
          goto <D.21056>;
          <D.21020>:
          iftmp.10 = __builtin_strcmp ("#~", ptr);
          <D.21056>:
          D.18516 = iftmp.10;
        }
        if (D.18516 == 0) goto <D.21057>; else goto <D.21058>;
        <D.21057>:
        stream_idx = 4;
        goto <D.21059>;
        <D.21058>:
        D.21060 = ctx->report_warning;
        if (D.21060 != 0) goto <D.21061>; else goto <D.21062>;
        <D.21061>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 2;
          D.21063 = monoeg_g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr);
          vinfo->info.message = D.21063;
          vinfo->exception_type = 3;
          D.20787 = ctx->errors;
          D.21064 = monoeg_g_slist_prepend (D.20787, vinfo);
          ctx->errors = D.21064;
        }
        ctx->valid = 0;
        return;
        <D.21062>:
        offset = pad4 (offset);
        D.20769 = ctx->data;
        D.20770 = (sizetype) offset;
        ptr = D.20769 + D.20770;
        // predicted unlikely by continue predictor.
        goto <D.18518>;
        <D.21059>:
        <D.21017>:
        <D.20975>:
        <D.20933>:
        <D.20891>:
        D.21065 = ctx->metadata_streams[stream_idx].offset;
        if (D.21065 != 0) goto <D.21066>; else goto <D.21067>;
        <D.21066>:
        D.20783 = ctx->report_error;
        if (D.20783 != 0) goto <D.21068>; else goto <D.21069>;
        <D.21068>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21070 = monoeg_g_strdup_printf ("Duplicated metadata stream header %s", ptr);
          vinfo->info.message = D.21070;
          vinfo->exception_type = 3;
          D.20787 = ctx->errors;
          D.21071 = monoeg_g_slist_prepend (D.20787, vinfo);
          ctx->errors = D.21071;
        }
        <D.21069>:
        ctx->valid = 0;
        return;
        <D.21067>:
        ctx->metadata_streams[stream_idx].offset = stream_off;
        ctx->metadata_streams[stream_idx].size = stream_size;
        offset = pad4 (offset);
        D.20769 = ctx->data;
        D.20770 = (sizetype) offset;
        ptr = D.20769 + D.20770;
      }
      <D.18518>:
      i = i + 1;
      <D.18521>:
      i.11 = (unsigned int) i;
      if (i.11 < section_count) goto <D.18520>; else goto <D.18522>;
      <D.18522>:
      D.21073 = ctx->metadata_streams[4].size;
      if (D.21073 == 0) goto <D.21074>; else goto <D.21075>;
      <D.21074>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.21076>; else goto <D.21077>;
      <D.21076>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21078 = monoeg_g_strdup_printf ("Metadata #~ stream missing");
        vinfo->info.message = D.21078;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.21079 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.21079;
      }
      <D.21077>:
      ctx->valid = 0;
      return;
      <D.21075>:
      D.21080 = ctx->metadata_streams[3].size;
      if (D.21080 == 0) goto <D.21081>; else goto <D.21082>;
      <D.21081>:
      D.20783 = ctx->report_error;
      if (D.20783 != 0) goto <D.21083>; else goto <D.21084>;
      <D.21083>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21085 = monoeg_g_strdup_printf ("Metadata guid stream missing");
        vinfo->info.message = D.21085;
        vinfo->exception_type = 3;
        D.20787 = ctx->errors;
        D.21086 = monoeg_g_slist_prepend (D.20787, vinfo);
        ctx->errors = D.21086;
      }
      <D.21084>:
      ctx->valid = 0;
      return;
      <D.21082>:
    }
  finally
    {
      it = {CLOBBER};
    }
}


bounds_check_datadir (struct DataDirectory * dir, guint32 offset, guint32 size)
{
  unsigned int D.21090;
  gboolean D.21093;
  unsigned int D.21094;
  unsigned int D.21097;
  unsigned int D.21098;
  _Bool D.21099;

  D.21090 = dir->translated_offset;
  if (D.21090 > offset) goto <D.21091>; else goto <D.21092>;
  <D.21091>:
  D.21093 = 0;
  return D.21093;
  <D.21092>:
  D.21094 = dir->size;
  if (D.21094 < size) goto <D.21095>; else goto <D.21096>;
  <D.21095>:
  D.21093 = 0;
  return D.21093;
  <D.21096>:
  D.21097 = offset + size;
  D.21090 = dir->translated_offset;
  D.21094 = dir->size;
  D.21098 = D.21090 + D.21094;
  D.21099 = D.21097 <= D.21098;
  D.21093 = (gboolean) D.21099;
  return D.21093;
}


pad4 (guint32 offset)
{
  unsigned int D.21101;
  unsigned int D.21104;
  guint32 D.21105;

  D.21101 = offset & 3;
  if (D.21101 != 0) goto <D.21102>; else goto <D.21103>;
  <D.21102>:
  D.21104 = offset & 4294967292;
  offset = D.21104 + 4;
  <D.21103>:
  D.21105 = offset;
  return D.21105;
}


verify_tables_schema (struct VerifyContext * ctx)
{
  const char * D.21107;
  sizetype D.21108;
  unsigned int D.21109;
  int D.21112;
  gchar * D.21115;
  struct GSList * D.21116;
  struct GSList * D.21117;
  const char * D.21118;
  char D.21119;
  char D.21120;
  int D.21125;
  gchar * D.21126;
  struct GSList * D.21127;
  const char * D.21128;
  char D.21129;
  int D.21134;
  gchar * D.21135;
  struct GSList * D.21136;
  const char * D.21137;
  char D.21138;
  int D.21139;
  int D.21140;
  unsigned char * D.21145;
  unsigned char D.21146;
  int D.21147;
  gchar * D.21148;
  struct GSList * D.21149;
  long unsigned int D.21150;
  long unsigned int D.21151;
  gchar * D.21162;
  struct GSList * D.21163;
  unsigned int i.12;
  unsigned int D.21167;
  gchar * D.21171;
  struct GSList * D.21172;
  unsigned int D.21173;
  unsigned int D.21174;
  gchar * D.21179;
  struct GSList * D.21180;
  gchar * D.21187;
  struct GSList * D.21188;
  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.21107 = ctx->data;
      D.21108 = (sizetype) offset;
      ptr = D.21107 + D.21108;
      D.21109 = tables_area.size;
      if (D.21109 <= 23) goto <D.21110>; else goto <D.21111>;
      <D.21110>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21113>; else goto <D.21114>;
      <D.21113>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21109 = tables_area.size;
        D.21115 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for initial decoding (requires 24 bytes)", D.21109);
        vinfo->info.message = D.21115;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21117 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21117;
      }
      <D.21114>:
      ctx->valid = 0;
      return;
      <D.21111>:
      D.21118 = ptr + 4;
      D.21119 = *D.21118;
      D.21120 = D.21119 + 255;
      if (D.21120 > 1) goto <D.21121>; else goto <D.21122>;
      <D.21121>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21123>; else goto <D.21124>;
      <D.21123>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21118 = ptr + 4;
        D.21119 = *D.21118;
        D.21125 = (int) D.21119;
        D.21126 = monoeg_g_strdup_printf ("Invalid table schemata major version %d, expected 2", D.21125);
        vinfo->info.message = D.21126;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21127 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21127;
      }
      <D.21124>:
      ctx->valid = 0;
      return;
      <D.21122>:
      D.21128 = ptr + 5;
      D.21129 = *D.21128;
      if (D.21129 != 0) goto <D.21130>; else goto <D.21131>;
      <D.21130>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21132>; else goto <D.21133>;
      <D.21132>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21128 = ptr + 5;
        D.21129 = *D.21128;
        D.21134 = (int) D.21129;
        D.21135 = monoeg_g_strdup_printf ("Invalid table schemata minor version %d, expected 0", D.21134);
        vinfo->info.message = D.21135;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21136 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21136;
      }
      <D.21133>:
      ctx->valid = 0;
      return;
      <D.21131>:
      D.21137 = ptr + 6;
      D.21138 = *D.21137;
      D.21139 = (int) D.21138;
      D.21140 = D.21139 & -8;
      if (D.21140 != 0) goto <D.21141>; else goto <D.21142>;
      <D.21141>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21143>; else goto <D.21144>;
      <D.21143>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21145 = ptr + 6;
        D.21146 = *D.21145;
        D.21147 = (int) D.21146;
        D.21148 = monoeg_g_strdup_printf ("Invalid table schemata heap sizes 0x%02x, only bits 0, 1 and 2 can be set", D.21147);
        vinfo->info.message = D.21148;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21149 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21149;
      }
      <D.21144>:
      ctx->valid = 0;
      return;
      <D.21142>:
      valid_tables = MEM[(const guint64 *)ptr + 8B];
      count = 0;
      i = 0;
      goto <D.18542>;
      <D.18541>:
      D.21150 = valid_tables >> i;
      D.21151 = D.21150 & 1;
      if (D.21151 == 0) goto <D.21152>; else goto <D.21153>;
      <D.21152>:
      // predicted unlikely by continue predictor.
      goto <D.18538>;
      <D.21153>:
      if (i == 3) goto <D.21154>; else goto <D.21156>;
      <D.21156>:
      if (i == 5) goto <D.21154>; else goto <D.21157>;
      <D.21157>:
      if (i == 7) goto <D.21154>; else goto <D.21158>;
      <D.21158>:
      if (i == 19) goto <D.21154>; else goto <D.21159>;
      <D.21159>:
      if (i == 22) goto <D.21154>; else goto <D.21155>;
      <D.21154>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21160>; else goto <D.21161>;
      <D.21160>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21162 = monoeg_g_strdup_printf ("The metadata verifier doesn\'t support MS specific table %x", i);
        vinfo->info.message = D.21162;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21163 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21163;
      }
      <D.21161>:
      ctx->valid = 0;
      return;
      <D.21155>:
      i.12 = (unsigned int) i;
      D.21167 = i.12 + 4294967266;
      if (D.21167 <= 1) goto <D.21164>; else goto <D.21168>;
      <D.21168>:
      if (i > 44) goto <D.21164>; else goto <D.21165>;
      <D.21164>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21169>; else goto <D.21170>;
      <D.21169>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21171 = monoeg_g_strdup_printf ("Invalid table %x", i);
        vinfo->info.message = D.21171;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21172 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21172;
      }
      <D.21170>:
      ctx->valid = 0;
      return;
      <D.21165>:
      count = count + 1;
      <D.18538>:
      i = i + 1;
      <D.18542>:
      if (i <= 63) goto <D.18541>; else goto <D.18543>;
      <D.18543>:
      D.21109 = tables_area.size;
      D.21173 = count + 6;
      D.21174 = D.21173 * 4;
      if (D.21109 < D.21174) goto <D.21175>; else goto <D.21176>;
      <D.21175>:
      D.21112 = ctx->report_error;
      if (D.21112 != 0) goto <D.21177>; else goto <D.21178>;
      <D.21177>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21109 = tables_area.size;
        D.21173 = count + 6;
        D.21174 = D.21173 * 4;
        D.21179 = monoeg_g_strdup_printf ("Table schemata size (%d) too small to for decoding row counts (requires %d bytes)", D.21109, D.21174);
        vinfo->info.message = D.21179;
        vinfo->exception_type = 3;
        D.21116 = ctx->errors;
        D.21180 = monoeg_g_slist_prepend (D.21116, vinfo);
        ctx->errors = D.21180;
      }
      <D.21178>:
      ctx->valid = 0;
      return;
      <D.21176>:
      ptr = ptr + 24;
      i = 0;
      goto <D.18548>;
      <D.18547>:
      D.21150 = valid_tables >> i;
      D.21151 = D.21150 & 1;
      if (D.21151 != 0) goto <D.21181>; else goto <D.21182>;
      <D.21181>:
      {
        guint32 row_count;

        row_count = MEM[(const guint32 *)ptr];
        if (row_count > 16777215) goto <D.21183>; else goto <D.21184>;
        <D.21183>:
        D.21112 = ctx->report_error;
        if (D.21112 != 0) goto <D.21185>; else goto <D.21186>;
        <D.21185>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21187 = monoeg_g_strdup_printf ("Invalid Table %d row count: %d. Mono only supports 16777215 rows", i, row_count);
          vinfo->info.message = D.21187;
          vinfo->exception_type = 3;
          D.21116 = ctx->errors;
          D.21188 = monoeg_g_slist_prepend (D.21116, vinfo);
          ctx->errors = D.21188;
        }
        <D.21186>:
        ctx->valid = 0;
        return;
        <D.21184>:
        ptr = ptr + 4;
      }
      <D.21182>:
      i = i + 1;
      <D.18548>:
      if (i <= 63) goto <D.18547>; else goto <D.18549>;
      <D.18549>:
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


mono_verifier_verify_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.21192;
  gboolean D.21195;
  _Bool D.21196;
  int D.21197;
  struct VerifyContext ctx;

  try
    {
      D.21192 = mono_verifier_is_enabled_for_image (image);
      if (D.21192 == 0) goto <D.21193>; else goto <D.21194>;
      <D.21193>:
      D.21195 = 1;
      return D.21195;
      <D.21194>:
      D.21196 = error_list != 0B;
      D.21197 = (int) D.21196;
      init_verify_context (&ctx, image, D.21197);
      ctx.stage = 2;
      verify_tables_data (&ctx);
      D.21195 = cleanup_context (&ctx, error_list);
      return D.21195;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_tables_data (struct VerifyContext * ctx)
{
  struct MonoImage * D.21200;
  struct MonoStreamHeader * D.21201;
  unsigned char D.21202;
  unsigned int D.21203;
  <unnamed-unsigned:24> D.21204;
  unsigned int D.21205;
  unsigned int D.21206;
  int D.21211;
  gchar * D.21214;
  struct GSList * D.21215;
  struct GSList * D.21216;
  const char * D.21217;
  long int D.21218;
  const char * D.21219;
  long int D.21220;
  long int D.21221;
  int D.21222;
  unsigned int D.21227;
  unsigned int D.21228;
  unsigned int D.21229;
  unsigned int D.21230;
  gchar * D.21231;
  struct GSList * D.21232;
  int D.21233;
  struct OffsetAndSize tables_area;
  guint32 size;
  guint32 tables_offset;
  int i;

  try
    {
      D.21200 = ctx->image;
      D.21201 = &D.21200->heap_tables;
      tables_area = get_metadata_stream (ctx, D.21201);
      size = 0;
      i = 0;
      goto <D.20014>;
      <D.20013>:
      {
        struct MonoTableInfo * table;
        guint32 tmp_size;

        D.21200 = ctx->image;
        table = &D.21200->tables[i];
        D.21202 = table->row_size;
        D.21203 = (unsigned int) D.21202;
        D.21204 = table->rows;
        D.21205 = (unsigned int) D.21204;
        D.21206 = D.21203 * D.21205;
        tmp_size = D.21206 + size;
        if (tmp_size < size) goto <D.21207>; else goto <D.21208>;
        <D.21207>:
        size = 0;
        goto <D.20012>;
        <D.21208>:
        size = tmp_size;
      }
      i = i + 1;
      <D.20014>:
      if (i <= 44) goto <D.20013>; else goto <D.20012>;
      <D.20012>:
      if (size == 0) goto <D.21209>; else goto <D.21210>;
      <D.21209>:
      D.21211 = ctx->report_error;
      if (D.21211 != 0) goto <D.21212>; else goto <D.21213>;
      <D.21212>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21214 = monoeg_g_strdup_printf ("table space is either empty or overflowed");
        vinfo->info.message = D.21214;
        vinfo->exception_type = 3;
        D.21215 = ctx->errors;
        D.21216 = monoeg_g_slist_prepend (D.21215, vinfo);
        ctx->errors = D.21216;
      }
      <D.21213>:
      ctx->valid = 0;
      return;
      <D.21210>:
      D.21200 = ctx->image;
      D.21217 = D.21200->tables_base;
      D.21218 = (long int) D.21217;
      D.21219 = ctx->data;
      D.21220 = (long int) D.21219;
      D.21221 = D.21218 - D.21220;
      tables_offset = (guint32) D.21221;
      D.21222 = bounds_check_offset (&tables_area, tables_offset, size);
      if (D.21222 == 0) goto <D.21223>; else goto <D.21224>;
      <D.21223>:
      D.21211 = ctx->report_error;
      if (D.21211 != 0) goto <D.21225>; else goto <D.21226>;
      <D.21225>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21227 = tables_area.size;
        D.21228 = tables_area.offset;
        D.21229 = D.21228 - tables_offset;
        D.21230 = D.21227 + D.21229;
        D.21231 = monoeg_g_strdup_printf ("Tables data require %d bytes but the only %d are available in the #~ stream", size, D.21230);
        vinfo->info.message = D.21231;
        vinfo->exception_type = 3;
        D.21215 = ctx->errors;
        D.21232 = monoeg_g_slist_prepend (D.21215, vinfo);
        ctx->errors = D.21232;
      }
      <D.21226>:
      ctx->valid = 0;
      return;
      <D.21224>:
      verify_module_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21234>; else goto <D.21235>;
      <D.21234>:
      return;
      <D.21235>:
      verify_typedef_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21236>; else goto <D.21237>;
      <D.21236>:
      return;
      <D.21237>:
      verify_field_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21238>; else goto <D.21239>;
      <D.21238>:
      return;
      <D.21239>:
      verify_method_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21240>; else goto <D.21241>;
      <D.21240>:
      return;
      <D.21241>:
      verify_param_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21242>; else goto <D.21243>;
      <D.21242>:
      return;
      <D.21243>:
      verify_interfaceimpl_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21244>; else goto <D.21245>;
      <D.21244>:
      return;
      <D.21245>:
      verify_memberref_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21246>; else goto <D.21247>;
      <D.21246>:
      return;
      <D.21247>:
      verify_constant_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21248>; else goto <D.21249>;
      <D.21248>:
      return;
      <D.21249>:
      verify_cattr_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21250>; else goto <D.21251>;
      <D.21250>:
      return;
      <D.21251>:
      verify_field_marshal_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21252>; else goto <D.21253>;
      <D.21252>:
      return;
      <D.21253>:
      verify_decl_security_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21254>; else goto <D.21255>;
      <D.21254>:
      return;
      <D.21255>:
      verify_class_layout_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21256>; else goto <D.21257>;
      <D.21256>:
      return;
      <D.21257>:
      verify_field_layout_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21258>; else goto <D.21259>;
      <D.21258>:
      return;
      <D.21259>:
      verify_standalonesig_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21260>; else goto <D.21261>;
      <D.21260>:
      return;
      <D.21261>:
      verify_eventmap_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21262>; else goto <D.21263>;
      <D.21262>:
      return;
      <D.21263>:
      verify_event_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21264>; else goto <D.21265>;
      <D.21264>:
      return;
      <D.21265>:
      verify_propertymap_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21266>; else goto <D.21267>;
      <D.21266>:
      return;
      <D.21267>:
      verify_property_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21268>; else goto <D.21269>;
      <D.21268>:
      return;
      <D.21269>:
      verify_methodimpl_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21270>; else goto <D.21271>;
      <D.21270>:
      return;
      <D.21271>:
      verify_moduleref_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21272>; else goto <D.21273>;
      <D.21272>:
      return;
      <D.21273>:
      verify_typespec_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21274>; else goto <D.21275>;
      <D.21274>:
      return;
      <D.21275>:
      verify_implmap_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21276>; else goto <D.21277>;
      <D.21276>:
      return;
      <D.21277>:
      verify_fieldrva_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21278>; else goto <D.21279>;
      <D.21278>:
      return;
      <D.21279>:
      verify_assembly_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21280>; else goto <D.21281>;
      <D.21280>:
      return;
      <D.21281>:
      verify_assemblyref_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21282>; else goto <D.21283>;
      <D.21282>:
      return;
      <D.21283>:
      verify_file_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21284>; else goto <D.21285>;
      <D.21284>:
      return;
      <D.21285>:
      verify_exportedtype_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21286>; else goto <D.21287>;
      <D.21286>:
      return;
      <D.21287>:
      verify_manifest_resource_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21288>; else goto <D.21289>;
      <D.21288>:
      return;
      <D.21289>:
      verify_nested_class_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21290>; else goto <D.21291>;
      <D.21290>:
      return;
      <D.21291>:
      verify_generic_param_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21292>; else goto <D.21293>;
      <D.21292>:
      return;
      <D.21293>:
      verify_method_spec_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21294>; else goto <D.21295>;
      <D.21294>:
      return;
      <D.21295>:
      verify_generic_param_constraint_table (ctx);
      D.21233 = ctx->valid;
      if (D.21233 == 0) goto <D.21296>; else goto <D.21297>;
      <D.21296>:
      return;
      <D.21297>:
      verify_tables_data_global_constraints (ctx);
    }
  finally
    {
      tables_area = {CLOBBER};
    }
}


get_metadata_stream (struct VerifyContext * ctx, struct MonoStreamHeader * header)
{
  const char * D.21301;
  long int D.21302;
  const char * D.21303;
  long int D.21304;
  long int D.21305;
  unsigned int D.21306;
  unsigned int D.21307;
  struct OffsetAndSize D.21308;
  struct OffsetAndSize res;

  try
    {
      D.21301 = header->data;
      D.21302 = (long int) D.21301;
      D.21303 = ctx->data;
      D.21304 = (long int) D.21303;
      D.21305 = D.21302 - D.21304;
      D.21306 = (unsigned int) D.21305;
      res.offset = D.21306;
      D.21307 = header->size;
      res.size = D.21307;
      D.21308 = res;
      return D.21308;
    }
  finally
    {
      res = {CLOBBER};
    }
}


bounds_check_offset (struct OffsetAndSize * off, guint32 offset, guint32 size)
{
  unsigned int D.21311;
  gboolean D.21314;
  unsigned int D.21315;
  unsigned int D.21318;
  unsigned int D.21319;
  _Bool D.21320;

  D.21311 = off->offset;
  if (D.21311 > offset) goto <D.21312>; else goto <D.21313>;
  <D.21312>:
  D.21314 = 0;
  return D.21314;
  <D.21313>:
  D.21315 = off->size;
  if (D.21315 < size) goto <D.21316>; else goto <D.21317>;
  <D.21316>:
  D.21314 = 0;
  return D.21314;
  <D.21317>:
  D.21318 = offset + size;
  D.21311 = off->offset;
  D.21315 = off->size;
  D.21319 = D.21311 + D.21315;
  D.21320 = D.21318 <= D.21319;
  D.21314 = (gboolean) D.21320;
  return D.21314;
}


verify_module_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21322;
  long unsigned int D.21323;
  long unsigned int D.21324;
  int D.21327;
  <unnamed-unsigned:24> D.21330;
  int D.21331;
  gchar * D.21332;
  struct GSList * D.21333;
  struct GSList * D.21334;
  unsigned int D.21335;
  int D.21336;
  gchar * D.21341;
  struct GSList * D.21342;
  unsigned int D.21343;
  int D.21344;
  gchar * D.21349;
  struct GSList * D.21350;
  unsigned int D.21351;
  gchar * D.21356;
  struct GSList * D.21357;
  unsigned int D.21358;
  gchar * D.21363;
  struct GSList * D.21364;
  struct MonoTableInfo * table;
  guint32 data[5];

  try
    {
      D.21322 = ctx->image;
      table = &D.21322->tables[0];
      D.21323 = BIT_FIELD_REF <*table, 64, 64>;
      D.21324 = D.21323 & 16777215;
      if (D.21324 != 1) goto <D.21325>; else goto <D.21326>;
      <D.21325>:
      D.21327 = ctx->report_error;
      if (D.21327 != 0) goto <D.21328>; else goto <D.21329>;
      <D.21328>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21330 = table->rows;
        D.21331 = (int) D.21330;
        D.21332 = monoeg_g_strdup_printf ("Module table must have exactly one row, but have %d", D.21331);
        vinfo->info.message = D.21332;
        vinfo->exception_type = 3;
        D.21333 = ctx->errors;
        D.21334 = monoeg_g_slist_prepend (D.21333, vinfo);
        ctx->errors = D.21334;
      }
      <D.21329>:
      ctx->valid = 0;
      return;
      <D.21326>:
      mono_metadata_decode_row (table, 0, &data, 5);
      D.21335 = data[1];
      D.21336 = is_valid_non_empty_string (ctx, D.21335);
      if (D.21336 == 0) goto <D.21337>; else goto <D.21338>;
      <D.21337>:
      D.21327 = ctx->report_error;
      if (D.21327 != 0) goto <D.21339>; else goto <D.21340>;
      <D.21339>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21335 = data[1];
        D.21341 = monoeg_g_strdup_printf ("Module has an invalid name, string index 0x%08x", D.21335);
        vinfo->info.message = D.21341;
        vinfo->exception_type = 3;
        D.21333 = ctx->errors;
        D.21342 = monoeg_g_slist_prepend (D.21333, vinfo);
        ctx->errors = D.21342;
      }
      <D.21340>:
      ctx->valid = 0;
      return;
      <D.21338>:
      D.21343 = data[2];
      D.21344 = is_valid_guid (ctx, D.21343);
      if (D.21344 == 0) goto <D.21345>; else goto <D.21346>;
      <D.21345>:
      D.21327 = ctx->report_error;
      if (D.21327 != 0) goto <D.21347>; else goto <D.21348>;
      <D.21347>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21343 = data[2];
        D.21349 = monoeg_g_strdup_printf ("Module has an invalid Mvid, guid index %x", D.21343);
        vinfo->info.message = D.21349;
        vinfo->exception_type = 3;
        D.21333 = ctx->errors;
        D.21350 = monoeg_g_slist_prepend (D.21333, vinfo);
        ctx->errors = D.21350;
      }
      <D.21348>:
      ctx->valid = 0;
      return;
      <D.21346>:
      D.21351 = data[3];
      if (D.21351 != 0) goto <D.21352>; else goto <D.21353>;
      <D.21352>:
      D.21327 = ctx->report_error;
      if (D.21327 != 0) goto <D.21354>; else goto <D.21355>;
      <D.21354>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21351 = data[3];
        D.21356 = monoeg_g_strdup_printf ("Module has a non zero Enc field %x", D.21351);
        vinfo->info.message = D.21356;
        vinfo->exception_type = 3;
        D.21333 = ctx->errors;
        D.21357 = monoeg_g_slist_prepend (D.21333, vinfo);
        ctx->errors = D.21357;
      }
      <D.21355>:
      ctx->valid = 0;
      return;
      <D.21353>:
      D.21358 = data[4];
      if (D.21358 != 0) goto <D.21359>; else goto <D.21360>;
      <D.21359>:
      D.21327 = ctx->report_error;
      if (D.21327 != 0) goto <D.21361>; else goto <D.21362>;
      <D.21361>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21358 = data[4];
        D.21363 = monoeg_g_strdup_printf ("Module has a non zero EncBase field %x", D.21358);
        vinfo->info.message = D.21363;
        vinfo->exception_type = 3;
        D.21333 = ctx->errors;
        D.21364 = monoeg_g_slist_prepend (D.21333, vinfo);
        ctx->errors = D.21364;
      }
      <D.21362>:
      ctx->valid = 0;
      return;
      <D.21360>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


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

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


is_valid_string_full_with_image (struct MonoImage * image, guint32 offset, gboolean allow_empty)
{
  const char * D.21373;
  long int D.21374;
  char * D.21375;
  long int D.21376;
  long int D.21377;
  sizetype D.21378;
  gboolean D.21381;
  long unsigned int D.21382;
  long unsigned int D.21383;
  long unsigned int data.13;
  sizetype D.21387;
  const gchar * D.21388;
  unsigned int D.21389;
  long int D.21390;
  int D.21391;
  int iftmp.14;
  long int length.15;
  guint32 heap_offset;
  guint32 heap_size;
  glong length;
  const char * data;

  try
    {
      D.21373 = image->heap_strings.data;
      D.21374 = (long int) D.21373;
      D.21375 = image->raw_data;
      D.21376 = (long int) D.21375;
      D.21377 = D.21374 - D.21376;
      heap_offset = (guint32) D.21377;
      heap_size = image->heap_strings.size;
      D.21375 = image->raw_data;
      D.21378 = (sizetype) heap_offset;
      data = D.21375 + D.21378;
      if (offset >= heap_size) goto <D.21379>; else goto <D.21380>;
      <D.21379>:
      D.21381 = 0;
      return D.21381;
      <D.21380>:
      D.21382 = (long unsigned int) offset;
      D.21383 = ~D.21382;
      data.13 = (long unsigned int) data;
      if (D.21383 < data.13) goto <D.21385>; else goto <D.21386>;
      <D.21385>:
      D.21381 = 0;
      return D.21381;
      <D.21386>:
      D.21387 = (sizetype) offset;
      D.21388 = data + D.21387;
      D.21389 = heap_size - offset;
      D.21390 = (long int) D.21389;
      D.21391 = mono_utf8_validate_and_len_with_bounds (D.21388, D.21390, &length, 0B);
      if (D.21391 == 0) goto <D.21392>; else goto <D.21393>;
      <D.21392>:
      D.21381 = 0;
      return D.21381;
      <D.21393>:
      if (allow_empty != 0) goto <D.21395>; else goto <D.21398>;
      <D.21398>:
      length.15 = length;
      if (length.15 > 0) goto <D.21395>; else goto <D.21396>;
      <D.21395>:
      iftmp.14 = 1;
      goto <D.21397>;
      <D.21396>:
      iftmp.14 = 0;
      <D.21397>:
      D.21381 = iftmp.14;
      return D.21381;
    }
  finally
    {
      length = {CLOBBER};
    }
}


is_valid_guid (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.21402;
  struct MonoStreamHeader * D.21403;
  gboolean D.21404;
  int iftmp.16;
  unsigned int D.21408;
  unsigned int D.21410;
  struct OffsetAndSize guids;

  try
    {
      D.21402 = ctx->image;
      D.21403 = &D.21402->heap_guid;
      guids = get_metadata_stream (ctx, D.21403);
      D.21408 = guids.size;
      if (D.21408 > 7) goto <D.21409>; else goto <D.21406>;
      <D.21409>:
      D.21408 = guids.size;
      D.21410 = D.21408 + 4294967288;
      if (D.21410 >= offset) goto <D.21411>; else goto <D.21406>;
      <D.21411>:
      iftmp.16 = 1;
      goto <D.21407>;
      <D.21406>:
      iftmp.16 = 0;
      <D.21407>:
      D.21404 = iftmp.16;
      return D.21404;
    }
  finally
    {
      guids = {CLOBBER};
    }
}


verify_typedef_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21414;
  long unsigned int D.21415;
  long unsigned int D.21416;
  int D.21419;
  gchar * D.21422;
  struct GSList * D.21423;
  struct GSList * D.21424;
  unsigned int D.21425;
  unsigned int D.21426;
  gchar * D.21431;
  struct GSList * D.21432;
  unsigned int D.21433;
  gchar * D.21438;
  struct GSList * D.21439;
  unsigned int D.21440;
  gchar * D.21445;
  struct GSList * D.21446;
  unsigned int D.21447;
  gchar * D.21452;
  struct GSList * D.21453;
  unsigned int D.21454;
  unsigned int D.21455;
  gchar * D.21460;
  struct GSList * D.21461;
  unsigned int D.21464;
  int D.21466;
  gchar * D.21469;
  struct GSList * D.21470;
  unsigned int D.21471;
  int D.21474;
  gchar * D.21479;
  struct GSList * D.21480;
  unsigned int D.21481;
  int D.21484;
  gchar * D.21489;
  struct GSList * D.21490;
  unsigned int D.21493;
  gchar * D.21498;
  struct GSList * D.21499;
  unsigned int D.21500;
  int D.21503;
  unsigned int D.21504;
  int D.21505;
  gchar * D.21510;
  struct GSList * D.21511;
  unsigned int D.21512;
  gchar * D.21517;
  struct GSList * D.21518;
  <unnamed-unsigned:24> D.21519;
  int D.21520;
  int D.21521;
  unsigned int D.21522;
  gchar * D.21527;
  struct GSList * D.21528;
  gchar * D.21533;
  struct GSList * D.21534;
  unsigned int D.21535;
  gchar * D.21540;
  struct GSList * D.21541;
  <unnamed-unsigned:24> D.21542;
  int D.21543;
  int D.21544;
  unsigned int D.21545;
  gchar * D.21550;
  struct GSList * D.21551;
  gchar * D.21556;
  struct GSList * D.21557;
  <unnamed-unsigned:24> D.21558;
  int D.21559;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 fieldlist;
  guint32 methodlist;
  guint32 visibility;
  int i;

  try
    {
      D.21414 = ctx->image;
      table = &D.21414->tables[2];
      fieldlist = 1;
      methodlist = 1;
      D.21415 = BIT_FIELD_REF <*table, 64, 64>;
      D.21416 = D.21415 & 16777215;
      if (D.21416 == 0) goto <D.21417>; else goto <D.21418>;
      <D.21417>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21420>; else goto <D.21421>;
      <D.21420>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21422 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.21422;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21424 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21424;
      }
      <D.21421>:
      ctx->valid = 0;
      return;
      <D.21418>:
      i = 0;
      goto <D.19301>;
      <D.19300>:
      mono_metadata_decode_row (table, i, &data, 6);
      D.21425 = data[0];
      D.21426 = D.21425 & 4280861248;
      if (D.21426 != 0) goto <D.21427>; else goto <D.21428>;
      <D.21427>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21429>; else goto <D.21430>;
      <D.21429>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21425 = data[0];
        D.21431 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid flags field 0x%08x", i, D.21425);
        vinfo->info.message = D.21431;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21432 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21432;
      }
      <D.21430>:
      ctx->valid = 0;
      return;
      <D.21428>:
      D.21425 = data[0];
      D.21433 = D.21425 & 24;
      if (D.21433 == 24) goto <D.21434>; else goto <D.21435>;
      <D.21434>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21436>; else goto <D.21437>;
      <D.21436>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21438 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid class layout 0x18", i);
        vinfo->info.message = D.21438;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21439 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21439;
      }
      <D.21437>:
      ctx->valid = 0;
      return;
      <D.21435>:
      D.21425 = data[0];
      D.21440 = D.21425 & 196608;
      if (D.21440 == 196608) goto <D.21441>; else goto <D.21442>;
      <D.21441>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21443>; else goto <D.21444>;
      <D.21443>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21445 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.21445;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21446 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21446;
      }
      <D.21444>:
      ctx->valid = 0;
      return;
      <D.21442>:
      D.21425 = data[0];
      D.21447 = D.21425 & 12582912;
      if (D.21447 != 0) goto <D.21448>; else goto <D.21449>;
      <D.21448>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21450>; else goto <D.21451>;
      <D.21450>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21452 = monoeg_g_strdup_printf ("Invalid typedef row %d mono doesn\'t support custom string format", i);
        vinfo->info.message = D.21452;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21453 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21453;
      }
      <D.21451>:
      ctx->valid = 0;
      return;
      <D.21449>:
      D.21454 = BIT_FIELD_REF <data, 32, 0>;
      D.21455 = D.21454 & 160;
      if (D.21455 == 32) goto <D.21456>; else goto <D.21457>;
      <D.21456>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21458>; else goto <D.21459>;
      <D.21458>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21460 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i);
        vinfo->info.message = D.21460;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21461 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21461;
      }
      <D.21459>:
      ctx->valid = 0;
      return;
      <D.21457>:
      D.21464 = data[1];
      if (D.21464 == 0) goto <D.21462>; else goto <D.21465>;
      <D.21465>:
      D.21464 = data[1];
      D.21466 = is_valid_non_empty_string (ctx, D.21464);
      if (D.21466 == 0) goto <D.21462>; else goto <D.21463>;
      <D.21462>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21467>; else goto <D.21468>;
      <D.21467>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21464 = data[1];
        D.21469 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, D.21464);
        vinfo->info.message = D.21469;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21470 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21470;
      }
      <D.21468>:
      ctx->valid = 0;
      return;
      <D.21463>:
      D.21471 = data[2];
      if (D.21471 != 0) goto <D.21472>; else goto <D.21473>;
      <D.21472>:
      D.21471 = data[2];
      D.21474 = is_valid_non_empty_string (ctx, D.21471);
      if (D.21474 == 0) goto <D.21475>; else goto <D.21476>;
      <D.21475>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21477>; else goto <D.21478>;
      <D.21477>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21471 = data[2];
        D.21479 = monoeg_g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, D.21471);
        vinfo->info.message = D.21479;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21480 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21480;
      }
      <D.21478>:
      ctx->valid = 0;
      return;
      <D.21476>:
      <D.21473>:
      D.21481 = data[3];
      if (D.21481 != 0) goto <D.21482>; else goto <D.21483>;
      <D.21482>:
      D.21481 = data[3];
      D.21484 = is_valid_coded_index (ctx, 0, D.21481);
      if (D.21484 == 0) goto <D.21485>; else goto <D.21486>;
      <D.21485>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21487>; else goto <D.21488>;
      <D.21487>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21481 = data[3];
        D.21489 = monoeg_g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, D.21481);
        vinfo->info.message = D.21489;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21490 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21490;
      }
      <D.21488>:
      ctx->valid = 0;
      return;
      <D.21486>:
      <D.21483>:
      D.21481 = data[3];
      if (D.21481 != 0) goto <D.21491>; else goto <D.21492>;
      <D.21491>:
      D.21481 = data[3];
      D.21493 = get_coded_index_token (0, D.21481);
      if (D.21493 == 0) goto <D.21494>; else goto <D.21495>;
      <D.21494>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21496>; else goto <D.21497>;
      <D.21496>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21481 = data[3];
        D.21498 = monoeg_g_strdup_printf ("Invalid typedef row %d zero coded extend field coded index 0x%08x", i, D.21481);
        vinfo->info.message = D.21498;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21499 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21499;
      }
      <D.21497>:
      ctx->valid = 0;
      return;
      <D.21495>:
      <D.21492>:
      D.21425 = data[0];
      visibility = D.21425 & 7;
      D.21500 = visibility + 4294967294;
      if (D.21500 <= 5) goto <D.21501>; else goto <D.21502>;
      <D.21501>:
      D.21503 = i + 1;
      D.21504 = (unsigned int) D.21503;
      D.21505 = search_sorted_table (ctx, 41, 0, D.21504);
      if (D.21505 == -1) goto <D.21506>; else goto <D.21507>;
      <D.21506>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21508>; else goto <D.21509>;
      <D.21508>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21510 = monoeg_g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i);
        vinfo->info.message = D.21510;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21511 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21511;
      }
      <D.21509>:
      ctx->valid = 0;
      return;
      <D.21507>:
      <D.21502>:
      D.21512 = data[4];
      if (D.21512 == 0) goto <D.21513>; else goto <D.21514>;
      <D.21513>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21515>; else goto <D.21516>;
      <D.21515>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21517 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i);
        vinfo->info.message = D.21517;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21518 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21518;
      }
      <D.21516>:
      ctx->valid = 0;
      return;
      <D.21514>:
      D.21512 = data[4];
      D.21414 = ctx->image;
      D.21519 = D.21414->tables[4].rows;
      D.21520 = (int) D.21519;
      D.21521 = D.21520 + 1;
      D.21522 = (unsigned int) D.21521;
      if (D.21512 > D.21522) goto <D.21523>; else goto <D.21524>;
      <D.21523>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21525>; else goto <D.21526>;
      <D.21525>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21512 = data[4];
        D.21527 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x is out of range", i, D.21512);
        vinfo->info.message = D.21527;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21528 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21528;
      }
      <D.21526>:
      ctx->valid = 0;
      return;
      <D.21524>:
      D.21512 = data[4];
      if (D.21512 < fieldlist) goto <D.21529>; else goto <D.21530>;
      <D.21529>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21531>; else goto <D.21532>;
      <D.21531>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21512 = data[4];
        D.21533 = monoeg_g_strdup_printf ("Invalid typedef row %d FieldList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21512, fieldlist);
        vinfo->info.message = D.21533;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21534 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21534;
      }
      <D.21532>:
      ctx->valid = 0;
      return;
      <D.21530>:
      D.21535 = data[5];
      if (D.21535 == 0) goto <D.21536>; else goto <D.21537>;
      <D.21536>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21538>; else goto <D.21539>;
      <D.21538>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21540 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList be be >= 1", i);
        vinfo->info.message = D.21540;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21541 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21541;
      }
      <D.21539>:
      ctx->valid = 0;
      return;
      <D.21537>:
      D.21535 = data[5];
      D.21414 = ctx->image;
      D.21542 = D.21414->tables[6].rows;
      D.21543 = (int) D.21542;
      D.21544 = D.21543 + 1;
      D.21545 = (unsigned int) D.21544;
      if (D.21535 > D.21545) goto <D.21546>; else goto <D.21547>;
      <D.21546>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21548>; else goto <D.21549>;
      <D.21548>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21535 = data[5];
        D.21550 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x is out of range", i, D.21535);
        vinfo->info.message = D.21550;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21551 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21551;
      }
      <D.21549>:
      ctx->valid = 0;
      return;
      <D.21547>:
      D.21535 = data[5];
      if (D.21535 < methodlist) goto <D.21552>; else goto <D.21553>;
      <D.21552>:
      D.21419 = ctx->report_error;
      if (D.21419 != 0) goto <D.21554>; else goto <D.21555>;
      <D.21554>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21535 = data[5];
        D.21556 = monoeg_g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.21535, methodlist);
        vinfo->info.message = D.21556;
        vinfo->exception_type = 3;
        D.21423 = ctx->errors;
        D.21557 = monoeg_g_slist_prepend (D.21423, vinfo);
        ctx->errors = D.21557;
      }
      <D.21555>:
      ctx->valid = 0;
      return;
      <D.21553>:
      fieldlist = data[4];
      methodlist = data[5];
      i = i + 1;
      <D.19301>:
      D.21558 = table->rows;
      D.21559 = (int) D.21558;
      if (D.21559 > i) goto <D.19300>; else goto <D.19302>;
      <D.19302>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


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

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


is_valid_coded_index_with_image (struct MonoImage * image, int token_kind, guint32 coded_token)
{
  int token_kind.17;
  unsigned char D.21567;
  int token_kind.18;
  unsigned char D.21569;
  int bits.19;
  int D.21571;
  int D.21572;
  unsigned int D.21573;
  gboolean D.21576;
  unsigned int token_kind.20;
  unsigned int D.21578;
  unsigned char D.21579;
  <unnamed-unsigned:24> D.21582;
  unsigned int D.21583;
  _Bool D.21584;
  guint32 bits;
  guint32 table_count;
  guint32 table;
  guint32 token;

  token_kind.17 = token_kind;
  token_kind = token_kind.17 + 1;
  D.21567 = coded_index_desc[token_kind.17];
  bits = (guint32) D.21567;
  token_kind.18 = token_kind;
  token_kind = token_kind.18 + 1;
  D.21569 = coded_index_desc[token_kind.18];
  table_count = (guint32) D.21569;
  bits.19 = (int) bits;
  D.21571 = 1 << bits.19;
  D.21572 = D.21571 + -1;
  D.21573 = (unsigned int) D.21572;
  table = D.21573 & coded_token;
  bits.19 = (int) bits;
  token = coded_token >> bits.19;
  if (table >= table_count) goto <D.21574>; else goto <D.21575>;
  <D.21574>:
  D.21576 = 0;
  return D.21576;
  <D.21575>:
  token_kind.20 = (unsigned int) token_kind;
  D.21578 = token_kind.20 + table;
  D.21579 = coded_index_desc[D.21578];
  table = (guint32) D.21579;
  if (table == 255) goto <D.21580>; else goto <D.21581>;
  <D.21580>:
  D.21576 = 0;
  return D.21576;
  <D.21581>:
  D.21582 = image->tables[table].rows;
  D.21583 = (unsigned int) D.21582;
  D.21584 = D.21583 >= token;
  D.21576 = (gboolean) D.21584;
  return D.21576;
}


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

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


search_sorted_table (struct VerifyContext * ctx, int table, int column, guint32 coded_token)
{
  struct MonoImage * D.21590;
  unsigned int D.21591;
  unsigned int D.21592;
  <unnamed-unsigned:24> D.21593;
  long unsigned int D.21594;
  unsigned char D.21595;
  long unsigned int D.21596;
  int D.21599;
  long int res.22;
  long int base.23;
  long int D.21602;
  long int D.21603;
  long int D.21604;
  struct MonoTableInfo * tinfo;
  struct RowLocator locator;
  const char * res;
  const char * base;

  try
    {
      D.21590 = ctx->image;
      tinfo = &D.21590->tables[table];
      locator.token = coded_token;
      D.21591 = get_col_offset (ctx, table, column);
      locator.col_offset = D.21591;
      D.21592 = get_col_size (ctx, table, column);
      locator.col_size = D.21592;
      locator.table = tinfo;
      base = tinfo->base;
      D.21593 = tinfo->rows;
      D.21594 = (long unsigned int) D.21593;
      D.21595 = tinfo->row_size;
      D.21596 = (long unsigned int) D.21595;
      res = mono_binary_search (&locator, base, D.21594, D.21596, token_locator);
      if (res == 0B) goto <D.21597>; else goto <D.21598>;
      <D.21597>:
      D.21599 = -1;
      return D.21599;
      <D.21598>:
      res.22 = (long int) res;
      base.23 = (long int) base;
      D.21602 = res.22 - base.23;
      D.21595 = tinfo->row_size;
      D.21603 = (long int) D.21595;
      D.21604 = D.21602 / D.21603;
      D.21599 = (int) D.21604;
      return D.21599;
    }
  finally
    {
      locator = {CLOBBER};
    }
}


token_locator (const void * a, const void * b)
{
  const unsigned int iftmp.24;
  unsigned int D.21608;
  unsigned int D.21611;
  sizetype D.21612;
  const guint16 * D.21613;
  short unsigned int D.21614;
  const guint32 * D.21616;
  int D.21617;
  unsigned int D.21618;
  int D.21619;
  int token.25;
  struct RowLocator * loc;
  const unsigned char * row;
  guint32 token;

  loc = a;
  row = b;
  D.21608 = loc->col_size;
  if (D.21608 == 2) goto <D.21609>; else goto <D.21610>;
  <D.21609>:
  D.21611 = loc->col_offset;
  D.21612 = (sizetype) D.21611;
  D.21613 = row + D.21612;
  D.21614 = *D.21613;
  iftmp.24 = (const unsigned int) D.21614;
  goto <D.21615>;
  <D.21610>:
  D.21611 = loc->col_offset;
  D.21612 = (sizetype) D.21611;
  D.21616 = row + D.21612;
  iftmp.24 = *D.21616;
  <D.21615>:
  token = iftmp.24;
  D.21618 = loc->token;
  D.21619 = (int) D.21618;
  token.25 = (int) token;
  D.21617 = D.21619 - token.25;
  return D.21617;
}


get_col_offset (struct VerifyContext * ctx, int table, int column)
{
  struct MonoImage * D.21622;
  int D.21623;
  unsigned int D.21624;
  unsigned int D.21625;
  unsigned int D.21626;
  int column.26;
  guint32 D.21628;
  guint32 bitfield;
  guint32 offset;

  D.21622 = ctx->image;
  bitfield = D.21622->tables[table].size_bitfield;
  offset = 0;
  goto <D.18558>;
  <D.18557>:
  D.21623 = column * 2;
  D.21624 = bitfield >> D.21623;
  D.21625 = D.21624 & 3;
  D.21626 = D.21625 + offset;
  offset = D.21626 + 1;
  <D.18558>:
  column.26 = column;
  column = column.26 + -1;
  if (column.26 > 0) goto <D.18557>; else goto <D.18559>;
  <D.18559>:
  D.21628 = offset;
  return D.21628;
}


get_col_size (struct VerifyContext * ctx, int table, int column)
{
  guint32 D.21630;
  struct MonoImage * D.21631;
  unsigned int D.21632;
  int D.21633;
  unsigned int D.21634;
  unsigned int D.21635;

  D.21631 = ctx->image;
  D.21632 = D.21631->tables[table].size_bitfield;
  D.21633 = column * 2;
  D.21634 = D.21632 >> D.21633;
  D.21635 = D.21634 & 3;
  D.21630 = D.21635 + 1;
  return D.21630;
}


verify_field_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21637;
  <unnamed-unsigned:24> D.21638;
  int D.21639;
  unsigned int D.21642;
  int D.21645;
  gchar * D.21648;
  struct GSList * D.21649;
  struct GSList * D.21650;
  unsigned int D.21651;
  gchar * D.21656;
  struct GSList * D.21657;
  unsigned int D.21658;
  gchar * D.21663;
  struct GSList * D.21664;
  unsigned int D.21665;
  gchar * D.21670;
  struct GSList * D.21671;
  unsigned int D.21672;
  gchar * D.21677;
  struct GSList * D.21678;
  unsigned int D.21679;
  unsigned int i.27;
  unsigned int D.21683;
  int D.21684;
  gchar * D.21689;
  struct GSList * D.21690;
  unsigned int D.21691;
  unsigned int D.21694;
  int D.21695;
  gchar * D.21700;
  struct GSList * D.21701;
  unsigned int D.21702;
  unsigned int D.21705;
  int D.21706;
  gchar * D.21711;
  struct GSList * D.21712;
  unsigned int D.21713;
  int D.21716;
  unsigned int D.21717;
  int D.21718;
  gchar * D.21723;
  struct GSList * D.21724;
  unsigned int D.21727;
  int D.21729;
  gchar * D.21732;
  struct GSList * D.21733;
  unsigned int D.21734;
  int D.21737;
  gchar * D.21742;
  struct GSList * D.21743;
  unsigned int D.21746;
  gchar * D.21751;
  struct GSList * D.21752;
  gchar * D.21759;
  struct GSList * D.21760;
  <unnamed-unsigned:24> D.21761;
  int D.21762;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 module_field_list;
  int i;

  try
    {
      D.21637 = ctx->image;
      table = &D.21637->tables[4];
      module_field_list = 4294967295;
      D.21637 = ctx->image;
      D.21638 = D.21637->tables[2].rows;
      D.21639 = (int) D.21638;
      if (D.21639 > 1) goto <D.21640>; else goto <D.21641>;
      <D.21640>:
      {
        struct MonoTableInfo * type;

        D.21637 = ctx->image;
        type = &D.21637->tables[2];
        module_field_list = mono_metadata_decode_row_col (type, 1, 4);
      }
      <D.21641>:
      i = 0;
      goto <D.19343>;
      <D.19342>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.21642 = flags & 18440;
      if (D.21642 != 0) goto <D.21643>; else goto <D.21644>;
      <D.21643>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21646>; else goto <D.21647>;
      <D.21646>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21648 = monoeg_g_strdup_printf ("Invalid field row %d invalid flags field 0x%08x", i, flags);
        vinfo->info.message = D.21648;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21650 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21650;
      }
      <D.21647>:
      ctx->valid = 0;
      return;
      <D.21644>:
      D.21651 = flags & 7;
      if (D.21651 == 7) goto <D.21652>; else goto <D.21653>;
      <D.21652>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21654>; else goto <D.21655>;
      <D.21654>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21656 = monoeg_g_strdup_printf ("Invalid field row %d invalid field visibility 0x7", i);
        vinfo->info.message = D.21656;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21657 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21657;
      }
      <D.21655>:
      ctx->valid = 0;
      return;
      <D.21653>:
      D.21658 = flags & 96;
      if (D.21658 == 96) goto <D.21659>; else goto <D.21660>;
      <D.21659>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21661>; else goto <D.21662>;
      <D.21661>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21663 = monoeg_g_strdup_printf ("Invalid field row %d cannot be InitOnly and Literal at the same time", i);
        vinfo->info.message = D.21663;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21664 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21664;
      }
      <D.21662>:
      ctx->valid = 0;
      return;
      <D.21660>:
      D.21665 = flags & 1536;
      if (D.21665 == 1024) goto <D.21666>; else goto <D.21667>;
      <D.21666>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21668>; else goto <D.21669>;
      <D.21668>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21670 = monoeg_g_strdup_printf ("Invalid field row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.21670;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21671 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21671;
      }
      <D.21669>:
      ctx->valid = 0;
      return;
      <D.21667>:
      D.21672 = flags & 80;
      if (D.21672 == 64) goto <D.21673>; else goto <D.21674>;
      <D.21673>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21675>; else goto <D.21676>;
      <D.21675>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21677 = monoeg_g_strdup_printf ("Invalid field row %d is Literal but not Static", i);
        vinfo->info.message = D.21677;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21678 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21678;
      }
      <D.21676>:
      ctx->valid = 0;
      return;
      <D.21674>:
      D.21679 = flags & 4096;
      if (D.21679 != 0) goto <D.21680>; else goto <D.21681>;
      <D.21680>:
      i.27 = (unsigned int) i;
      D.21683 = make_coded_token (32, 4, i.27);
      D.21684 = search_sorted_table (ctx, 13, 0, D.21683);
      if (D.21684 == -1) goto <D.21685>; else goto <D.21686>;
      <D.21685>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21687>; else goto <D.21688>;
      <D.21687>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21689 = 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.21689;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21690 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21690;
      }
      <D.21688>:
      ctx->valid = 0;
      return;
      <D.21686>:
      <D.21681>:
      D.21691 = flags & 32768;
      if (D.21691 != 0) goto <D.21692>; else goto <D.21693>;
      <D.21692>:
      i.27 = (unsigned int) i;
      D.21694 = make_coded_token (5, 4, i.27);
      D.21695 = search_sorted_table (ctx, 11, 2, D.21694);
      if (D.21695 == -1) goto <D.21696>; else goto <D.21697>;
      <D.21696>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21698>; else goto <D.21699>;
      <D.21698>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21700 = 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.21700;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21701 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21701;
      }
      <D.21699>:
      ctx->valid = 0;
      return;
      <D.21697>:
      <D.21693>:
      D.21702 = flags & 64;
      if (D.21702 != 0) goto <D.21703>; else goto <D.21704>;
      <D.21703>:
      i.27 = (unsigned int) i;
      D.21705 = make_coded_token (5, 4, i.27);
      D.21706 = search_sorted_table (ctx, 11, 2, D.21705);
      if (D.21706 == -1) goto <D.21707>; else goto <D.21708>;
      <D.21707>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21709>; else goto <D.21710>;
      <D.21709>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21711 = 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.21711;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21712 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21712;
      }
      <D.21710>:
      ctx->valid = 0;
      return;
      <D.21708>:
      <D.21704>:
      D.21713 = flags & 256;
      if (D.21713 != 0) goto <D.21714>; else goto <D.21715>;
      <D.21714>:
      D.21716 = i + 1;
      D.21717 = (unsigned int) D.21716;
      D.21718 = search_sorted_table (ctx, 29, 1, D.21717);
      if (D.21718 == -1) goto <D.21719>; else goto <D.21720>;
      <D.21719>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21721>; else goto <D.21722>;
      <D.21721>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21723 = 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.21723;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21724 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21724;
      }
      <D.21722>:
      ctx->valid = 0;
      return;
      <D.21720>:
      <D.21715>:
      D.21727 = data[1];
      if (D.21727 == 0) goto <D.21725>; else goto <D.21728>;
      <D.21728>:
      D.21727 = data[1];
      D.21729 = is_valid_non_empty_string (ctx, D.21727);
      if (D.21729 == 0) goto <D.21725>; else goto <D.21726>;
      <D.21725>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21730>; else goto <D.21731>;
      <D.21730>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21727 = data[1];
        D.21732 = monoeg_g_strdup_printf ("Invalid field row %d invalid name token %08x", i, D.21727);
        vinfo->info.message = D.21732;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21733 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21733;
      }
      <D.21731>:
      ctx->valid = 0;
      return;
      <D.21726>:
      D.21734 = data[2];
      if (D.21734 != 0) goto <D.21735>; else goto <D.21736>;
      <D.21735>:
      D.21734 = data[2];
      D.21737 = is_valid_blob_object (ctx, D.21734, 1);
      if (D.21737 == 0) goto <D.21738>; else goto <D.21739>;
      <D.21738>:
      D.21645 = ctx->report_error;
      if (D.21645 != 0) goto <D.21740>; else goto <D.21741>;
      <D.21740>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21734 = data[2];
        D.21742 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, D.21734);
        vinfo->info.message = D.21742;
        vinfo->exception_type = 3;
        D.21649 = ctx->errors;
        D.21743 = monoeg_g_slist_prepend (D.21649, vinfo);
        ctx->errors = D.21743;
      }
      <D.21741>:
      ctx->valid = 0;
      return;
      <D.21739>:
      <D.21736>:
      D.21716 = i + 1;
      D.21717 = (unsigned int) D.21716;
      if (D.21717 < module_field_list) goto <D.21744>; else goto <D.21745>;
      <D.21744>:
      {
        guint32 access;

        access = flags & 7;
        D.21746 = flags & 16;
        if (D.21746 == 0) goto <D.21747>; else goto <D.21748>;
        <D.21747>:
        D.21645 = ctx->report_error;
        if (D.21645 != 0) goto <D.21749>; else goto <D.21750>;
        <D.21749>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21751 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but is not static", i);
          vinfo->info.message = D.21751;
          vinfo->exception_type = 3;
          D.21649 = ctx->errors;
          D.21752 = monoeg_g_slist_prepend (D.21649, vinfo);
          ctx->errors = D.21752;
        }
        <D.21750>:
        ctx->valid = 0;
        return;
        <D.21748>:
        if (access > 1) goto <D.21753>; else goto <D.21754>;
        <D.21753>:
        if (access != 6) goto <D.21755>; else goto <D.21756>;
        <D.21755>:
        D.21645 = ctx->report_error;
        if (D.21645 != 0) goto <D.21757>; else goto <D.21758>;
        <D.21757>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.21759 = monoeg_g_strdup_printf ("Invalid field row %d is a global variable but have wrong visibility %x", i, access);
          vinfo->info.message = D.21759;
          vinfo->exception_type = 3;
          D.21649 = ctx->errors;
          D.21760 = monoeg_g_slist_prepend (D.21649, vinfo);
          ctx->errors = D.21760;
        }
        <D.21758>:
        ctx->valid = 0;
        return;
        <D.21756>:
        <D.21754>:
      }
      <D.21745>:
      i = i + 1;
      <D.19343>:
      D.21761 = table->rows;
      D.21762 = (int) D.21761;
      if (D.21762 > i) goto <D.19342>; else goto <D.19344>;
      <D.19344>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


make_coded_token (int kind, guint32 table, guint32 table_idx)
{
  int kind.28;
  unsigned char D.21767;
  int kind.29;
  unsigned char D.21769;
  int kind.30;
  unsigned char D.21771;
  unsigned int D.21772;
  guint32 D.21775;
  unsigned int D.21776;
  int bits.31;
  unsigned int D.21778;
  guint32 bits;
  guint32 tables;
  guint32 i;

  kind.28 = kind;
  kind = kind.28 + 1;
  D.21767 = coded_index_desc[kind.28];
  bits = (guint32) D.21767;
  kind.29 = kind;
  kind = kind.29 + 1;
  D.21769 = coded_index_desc[kind.29];
  tables = (guint32) D.21769;
  i = 0;
  goto <D.18617>;
  <D.18616>:
  kind.30 = kind;
  kind = kind.30 + 1;
  D.21771 = coded_index_desc[kind.30];
  D.21772 = (unsigned int) D.21771;
  if (D.21772 == table) goto <D.21773>; else goto <D.21774>;
  <D.21773>:
  D.21776 = table_idx + 1;
  bits.31 = (int) bits;
  D.21778 = D.21776 << bits.31;
  D.21775 = D.21778 | i;
  return D.21775;
  <D.21774>:
  i = i + 1;
  <D.18617>:
  if (i < tables) goto <D.18616>; else goto <D.18618>;
  <D.18618>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 1012);
  D.21775 = 4294967295;
  return D.21775;
}


is_valid_blob_object (struct VerifyContext * ctx, guint32 offset, guint32 minsize)
{
  struct MonoImage * D.21780;
  struct MonoStreamHeader * D.21781;
  unsigned int D.21782;
  gboolean D.21785;
  const char * D.21786;
  sizetype D.21787;
  unsigned int D.21788;
  sizetype D.21789;
  sizetype D.21790;
  const char * D.21791;
  unsigned int D.21792;
  int D.21793;
  unsigned int entry_size.32;
  unsigned int bytes.33;
  unsigned int D.21800;
  unsigned int entry_size.34;
  int iftmp.35;
  unsigned int D.21807;
  unsigned int D.21809;
  struct OffsetAndSize blob;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.21780 = ctx->image;
      D.21781 = &D.21780->heap_blob;
      blob = get_metadata_stream (ctx, D.21781);
      D.21782 = blob.size;
      if (D.21782 < offset) goto <D.21783>; else goto <D.21784>;
      <D.21783>:
      D.21785 = 0;
      return D.21785;
      <D.21784>:
      D.21786 = ctx->data;
      D.21787 = (sizetype) offset;
      D.21788 = blob.offset;
      D.21789 = (sizetype) D.21788;
      D.21790 = D.21787 + D.21789;
      D.21791 = D.21786 + D.21790;
      D.21782 = blob.size;
      D.21788 = blob.offset;
      D.21792 = D.21782 - D.21788;
      D.21793 = decode_value (D.21791, D.21792, &entry_size, &bytes);
      if (D.21793 == 0) goto <D.21794>; else goto <D.21795>;
      <D.21794>:
      D.21785 = 0;
      return D.21785;
      <D.21795>:
      entry_size.32 = entry_size;
      if (entry_size.32 < minsize) goto <D.21797>; else goto <D.21798>;
      <D.21797>:
      D.21785 = 0;
      return D.21785;
      <D.21798>:
      bytes.33 = bytes;
      D.21800 = ~bytes.33;
      entry_size.32 = entry_size;
      if (D.21800 < entry_size.32) goto <D.21801>; else goto <D.21802>;
      <D.21801>:
      D.21785 = 0;
      return D.21785;
      <D.21802>:
      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.21807 = offset + entry_size.32;
      D.21782 = blob.size;
      if (D.21807 <= D.21782) goto <D.21808>; else goto <D.21805>;
      <D.21808>:
      entry_size.32 = entry_size;
      D.21809 = ~entry_size.32;
      if (D.21809 >= offset) goto <D.21810>; else goto <D.21805>;
      <D.21810>:
      iftmp.35 = 1;
      goto <D.21806>;
      <D.21805>:
      iftmp.35 = 0;
      <D.21806>:
      D.21785 = iftmp.35;
      return D.21785;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


decode_value (const char * _ptr, unsigned int available, unsigned int * value, unsigned int * size)
{
  gboolean D.21815;
  unsigned int D.21816;
  signed char b.36;
  unsigned int D.21820;
  int D.21822;
  int D.21823;
  int D.21828;
  int D.21829;
  const unsigned char * D.21830;
  unsigned char D.21831;
  int D.21832;
  int D.21833;
  unsigned int D.21834;
  int D.21838;
  int D.21839;
  int D.21840;
  int D.21841;
  const unsigned char * D.21842;
  unsigned char D.21843;
  int D.21844;
  int D.21845;
  int D.21846;
  const unsigned char * D.21847;
  unsigned char D.21848;
  int D.21849;
  int D.21850;
  unsigned int D.21851;
  unsigned char b;
  const unsigned char * ptr;

  ptr = _ptr;
  if (available == 0) goto <D.21813>; else goto <D.21814>;
  <D.21813>:
  D.21815 = 0;
  return D.21815;
  <D.21814>:
  b = *ptr;
  *size = 0;
  D.21816 = *size;
  *value = D.21816;
  b.36 = (signed char) b;
  if (b.36 >= 0) goto <D.21818>; else goto <D.21819>;
  <D.21818>:
  *size = 1;
  D.21820 = (unsigned int) b;
  *value = D.21820;
  goto <D.21821>;
  <D.21819>:
  D.21822 = (int) b;
  D.21823 = D.21822 & 64;
  if (D.21823 == 0) goto <D.21824>; else goto <D.21825>;
  <D.21824>:
  if (available <= 1) goto <D.21826>; else goto <D.21827>;
  <D.21826>:
  D.21815 = 0;
  return D.21815;
  <D.21827>:
  *size = 2;
  D.21822 = (int) b;
  D.21828 = D.21822 & 63;
  D.21829 = D.21828 << 8;
  D.21830 = ptr + 1;
  D.21831 = *D.21830;
  D.21832 = (int) D.21831;
  D.21833 = D.21829 | D.21832;
  D.21834 = (unsigned int) D.21833;
  *value = D.21834;
  goto <D.21835>;
  <D.21825>:
  if (available <= 3) goto <D.21836>; else goto <D.21837>;
  <D.21836>:
  D.21815 = 0;
  return D.21815;
  <D.21837>:
  *size = 4;
  D.21822 = (int) b;
  D.21838 = D.21822 & 31;
  D.21839 = D.21838 << 24;
  D.21830 = ptr + 1;
  D.21831 = *D.21830;
  D.21832 = (int) D.21831;
  D.21840 = D.21832 << 16;
  D.21841 = D.21839 | D.21840;
  D.21842 = ptr + 2;
  D.21843 = *D.21842;
  D.21844 = (int) D.21843;
  D.21845 = D.21844 << 8;
  D.21846 = D.21841 | D.21845;
  D.21847 = ptr + 3;
  D.21848 = *D.21847;
  D.21849 = (int) D.21848;
  D.21850 = D.21846 | D.21849;
  D.21851 = (unsigned int) D.21850;
  *value = D.21851;
  <D.21835>:
  <D.21821>:
  D.21815 = 1;
  return D.21815;
}


verify_method_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.21853;
  <unnamed-unsigned:24> D.21854;
  int D.21855;
  unsigned int D.21858;
  int D.21861;
  gchar * D.21864;
  struct GSList * D.21865;
  struct GSList * D.21866;
  gchar * D.21871;
  struct GSList * D.21872;
  unsigned int D.21875;
  int D.21877;
  gchar * D.21880;
  struct GSList * D.21881;
  int D.19383;
  int iftmp.37;
  int D.19379;
  const char[6] * D.21885;
  unsigned char D.21886;
  int D.21887;
  unsigned char D.21888;
  int D.21889;
  const unsigned char * D.21894;
  unsigned char D.21895;
  int D.21896;
  const unsigned char * D.21897;
  unsigned char D.21898;
  int D.21899;
  const unsigned char * D.21904;
  unsigned char D.21905;
  int D.21906;
  const unsigned char * D.21907;
  unsigned char D.21908;
  int D.21909;
  const unsigned char * D.21914;
  unsigned char D.21915;
  int D.21916;
  const unsigned char * D.21917;
  unsigned char D.21918;
  int D.21919;
  _Bool D.21921;
  int D.19392;
  int iftmp.38;
  int D.19388;
  const char[7] * D.21925;
  unsigned char D.21926;
  int D.21927;
  unsigned char D.21928;
  int D.21929;
  const unsigned char * D.21934;
  unsigned char D.21935;
  int D.21936;
  const unsigned char * D.21937;
  unsigned char D.21938;
  int D.21939;
  const unsigned char * D.21944;
  unsigned char D.21945;
  int D.21946;
  const unsigned char * D.21947;
  unsigned char D.21948;
  int D.21949;
  const unsigned char * D.21954;
  unsigned char D.21955;
  int D.21956;
  const unsigned char * D.21957;
  unsigned char D.21958;
  int D.21959;
  _Bool D.21961;
  int D.21962;
  unsigned int i.39;
  unsigned int D.21966;
  int D.21967;
  gchar * D.21972;
  struct GSList * D.21973;
  unsigned int D.21974;
  unsigned int D.21977;
  gchar * D.21982;
  struct GSList * D.21983;
  unsigned int D.21984;
  unsigned int D.21987;
  gchar * D.21992;
  struct GSList * D.21993;
  unsigned int D.21994;
  gchar * D.21999;
  struct GSList * D.22000;
  unsigned int D.22001;
  gchar * D.22006;
  struct GSList * D.22007;
  unsigned int D.22010;
  int D.22013;
  gchar * D.22016;
  struct GSList * D.22017;
  unsigned int D.22018;
  gchar * D.22023;
  struct GSList * D.22024;
  int D.22025;
  unsigned int D.22026;
  gchar * D.22033;
  struct GSList * D.22034;
  unsigned int D.22035;
  gchar * D.22040;
  struct GSList * D.22041;
  gchar * D.22048;
  struct GSList * D.22049;
  unsigned int D.22050;
  gchar * D.22057;
  struct GSList * D.22058;
  gchar * D.22065;
  struct GSList * D.22066;
  gchar * D.22071;
  struct GSList * D.22072;
  unsigned int D.22073;
  unsigned int D.22078;
  gchar * D.22085;
  struct GSList * D.22086;
  gchar * D.22095;
  struct GSList * D.22096;
  unsigned int D.22101;
  gchar * D.22105;
  struct GSList * D.22106;
  gchar * D.22111;
  struct GSList * D.22112;
  gchar * D.22122;
  struct GSList * D.22123;
  gchar * D.22130;
  struct GSList * D.22131;
  unsigned int D.22132;
  int D.22133;
  gchar * D.22138;
  struct GSList * D.22139;
  unsigned int D.22140;
  gchar * D.22147;
  struct GSList * D.22148;
  gchar * D.22155;
  struct GSList * D.22156;
  unsigned int D.22157;
  int D.22160;
  gchar * D.22165;
  struct GSList * D.22166;
  unsigned int D.22167;
  gchar * D.22172;
  struct GSList * D.22173;
  gchar * D.22178;
  struct GSList * D.22179;
  <unnamed-unsigned:24> D.22180;
  int D.22181;
  int D.22182;
  unsigned int D.22183;
  gchar * D.22188;
  struct GSList * D.22189;
  <unnamed-unsigned:24> D.22190;
  int D.22191;
  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.21853 = ctx->image;
      table = &D.21853->tables[6];
      paramlist = 1;
      module_method_list = 4294967295;
      D.21853 = ctx->image;
      D.21854 = D.21853->tables[2].rows;
      D.21855 = (int) D.21854;
      if (D.21855 > 1) goto <D.21856>; else goto <D.21857>;
      <D.21856>:
      {
        struct MonoTableInfo * type;

        D.21853 = ctx->image;
        type = &D.21853->tables[2];
        module_method_list = mono_metadata_decode_row_col (type, 1, 5);
      }
      <D.21857>:
      i = 0;
      goto <D.19420>;
      <D.19419>:
      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.21858 = implflags & 60928;
      if (D.21858 != 0) goto <D.21859>; else goto <D.21860>;
      <D.21859>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21862>; else goto <D.21863>;
      <D.21862>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21864 = monoeg_g_strdup_printf ("Invalid method row %d invalid implflags field 0x%08x", i, implflags);
        vinfo->info.message = D.21864;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.21866 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.21866;
      }
      <D.21863>:
      ctx->valid = 0;
      return;
      <D.21860>:
      if (access == 7) goto <D.21867>; else goto <D.21868>;
      <D.21867>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21871 = monoeg_g_strdup_printf ("Invalid method row %d invalid MemberAccessMask 0x7", i);
        vinfo->info.message = D.21871;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.21872 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.21872;
      }
      <D.21870>:
      ctx->valid = 0;
      return;
      <D.21868>:
      D.21875 = data[3];
      if (D.21875 == 0) goto <D.21873>; else goto <D.21876>;
      <D.21876>:
      D.21875 = data[3];
      D.21877 = is_valid_non_empty_string (ctx, D.21875);
      if (D.21877 == 0) goto <D.21873>; else goto <D.21874>;
      <D.21873>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21878>; else goto <D.21879>;
      <D.21878>:
      {
        struct MonoVerifyInfoExtended * vinfo;

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

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

          __s2 = name;
          D.21885 = ".ctor";
          D.21886 = MEM[(const unsigned char *)D.21885];
          D.21887 = (int) D.21886;
          D.21888 = *__s2;
          D.21889 = (int) D.21888;
          __result = D.21887 - D.21889;
          {
            if (__s1_len != 0) goto <D.21890>; else goto <D.21891>;
            <D.21890>:
            if (__result == 0) goto <D.21892>; else goto <D.21893>;
            <D.21892>:
            D.21894 = &MEM[(void *)".ctor" + 1B];
            D.21895 = *D.21894;
            D.21896 = (int) D.21895;
            D.21897 = __s2 + 1;
            D.21898 = *D.21897;
            D.21899 = (int) D.21898;
            __result = D.21896 - D.21899;
            if (__s1_len > 1) goto <D.21900>; else goto <D.21901>;
            <D.21900>:
            if (__result == 0) goto <D.21902>; else goto <D.21903>;
            <D.21902>:
            D.21904 = &MEM[(void *)".ctor" + 2B];
            D.21905 = *D.21904;
            D.21906 = (int) D.21905;
            D.21907 = __s2 + 2;
            D.21908 = *D.21907;
            D.21909 = (int) D.21908;
            __result = D.21906 - D.21909;
            if (__s1_len > 2) goto <D.21910>; else goto <D.21911>;
            <D.21910>:
            if (__result == 0) goto <D.21912>; else goto <D.21913>;
            <D.21912>:
            D.21914 = &MEM[(void *)".ctor" + 3B];
            D.21915 = *D.21914;
            D.21916 = (int) D.21915;
            D.21917 = __s2 + 3;
            D.21918 = *D.21917;
            D.21919 = (int) D.21918;
            __result = D.21916 - D.21919;
            <D.21913>:
            <D.21911>:
            <D.21903>:
            <D.21901>:
            <D.21893>:
            <D.21891>:
          }
          D.19379 = __result;
        }
        iftmp.37 = D.19379;
        goto <D.21920>;
        <D.21884>:
        iftmp.37 = __builtin_strcmp (".ctor", name);
        <D.21920>:
        D.19383 = iftmp.37;
      }
      D.21921 = D.19383 == 0;
      is_ctor = (gboolean) D.21921;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21925 = ".cctor";
          D.21926 = MEM[(const unsigned char *)D.21925];
          D.21927 = (int) D.21926;
          D.21928 = *__s2;
          D.21929 = (int) D.21928;
          __result = D.21927 - D.21929;
          {
            if (__s1_len != 0) goto <D.21930>; else goto <D.21931>;
            <D.21930>:
            if (__result == 0) goto <D.21932>; else goto <D.21933>;
            <D.21932>:
            D.21934 = &MEM[(void *)".cctor" + 1B];
            D.21935 = *D.21934;
            D.21936 = (int) D.21935;
            D.21937 = __s2 + 1;
            D.21938 = *D.21937;
            D.21939 = (int) D.21938;
            __result = D.21936 - D.21939;
            if (__s1_len > 1) goto <D.21940>; else goto <D.21941>;
            <D.21940>:
            if (__result == 0) goto <D.21942>; else goto <D.21943>;
            <D.21942>:
            D.21944 = &MEM[(void *)".cctor" + 2B];
            D.21945 = *D.21944;
            D.21946 = (int) D.21945;
            D.21947 = __s2 + 2;
            D.21948 = *D.21947;
            D.21949 = (int) D.21948;
            __result = D.21946 - D.21949;
            if (__s1_len > 2) goto <D.21950>; else goto <D.21951>;
            <D.21950>:
            if (__result == 0) goto <D.21952>; else goto <D.21953>;
            <D.21952>:
            D.21954 = &MEM[(void *)".cctor" + 3B];
            D.21955 = *D.21954;
            D.21956 = (int) D.21955;
            D.21957 = __s2 + 3;
            D.21958 = *D.21957;
            D.21959 = (int) D.21958;
            __result = D.21956 - D.21959;
            <D.21953>:
            <D.21951>:
            <D.21943>:
            <D.21941>:
            <D.21933>:
            <D.21931>:
          }
          D.19388 = __result;
        }
        iftmp.38 = D.19388;
        goto <D.21960>;
        <D.21924>:
        iftmp.38 = __builtin_strcmp (".cctor", name);
        <D.21960>:
        D.19392 = iftmp.38;
      }
      D.21961 = D.19392 == 0;
      is_cctor = (gboolean) D.21961;
      D.21962 = is_ctor | is_cctor;
      if (D.21962 != 0) goto <D.21963>; else goto <D.21964>;
      <D.21963>:
      i.39 = (unsigned int) i;
      D.21966 = make_coded_token (78, 6, i.39);
      D.21967 = search_sorted_table (ctx, 42, 2, D.21966);
      if (D.21967 != -1) goto <D.21968>; else goto <D.21969>;
      <D.21968>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21970>; else goto <D.21971>;
      <D.21970>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21972 = monoeg_g_strdup_printf ("Invalid method row %d .ctor or .cctor has generic param", i);
        vinfo->info.message = D.21972;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.21973 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.21973;
      }
      <D.21971>:
      ctx->valid = 0;
      return;
      <D.21969>:
      <D.21964>:
      D.21974 = flags & 16;
      if (D.21974 != 0) goto <D.21975>; else goto <D.21976>;
      <D.21975>:
      D.21977 = flags & 352;
      if (D.21977 != 0) goto <D.21978>; else goto <D.21979>;
      <D.21978>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21980>; else goto <D.21981>;
      <D.21980>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21982 = monoeg_g_strdup_printf ("Invalid method row %d is static and (final, virtual or new slot)", i);
        vinfo->info.message = D.21982;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.21983 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.21983;
      }
      <D.21981>:
      ctx->valid = 0;
      return;
      <D.21979>:
      <D.21976>:
      D.21984 = flags & 1024;
      if (D.21984 != 0) goto <D.21985>; else goto <D.21986>;
      <D.21985>:
      D.21987 = flags & 8192;
      if (D.21987 != 0) goto <D.21988>; else goto <D.21989>;
      <D.21988>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21990>; else goto <D.21991>;
      <D.21990>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21992 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i);
        vinfo->info.message = D.21992;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.21993 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.21993;
      }
      <D.21991>:
      ctx->valid = 0;
      return;
      <D.21989>:
      D.21994 = flags & 32;
      if (D.21994 != 0) goto <D.21995>; else goto <D.21996>;
      <D.21995>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.21997>; else goto <D.21998>;
      <D.21997>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.21999 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract and Final", i);
        vinfo->info.message = D.21999;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22000 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22000;
      }
      <D.21998>:
      ctx->valid = 0;
      return;
      <D.21996>:
      D.22001 = flags & 64;
      if (D.22001 == 0) goto <D.22002>; else goto <D.22003>;
      <D.22002>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22004>; else goto <D.22005>;
      <D.22004>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22006 = monoeg_g_strdup_printf ("Invalid method row %d is Abstract but not Virtual", i);
        vinfo->info.message = D.22006;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22007 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22007;
      }
      <D.22005>:
      ctx->valid = 0;
      return;
      <D.22003>:
      <D.21986>:
      if (access == 0) goto <D.22008>; else goto <D.22009>;
      <D.22008>:
      D.22010 = flags & 6144;
      if (D.22010 != 0) goto <D.22011>; else goto <D.22012>;
      <D.22011>:
      D.22013 = ctx->report_warning;
      if (D.22013 != 0) goto <D.22014>; else goto <D.22015>;
      <D.22014>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 2;
        D.22016 = monoeg_g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i);
        vinfo->info.message = D.22016;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22017 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22017;
      }
      ctx->valid = 0;
      return;
      <D.22015>:
      <D.22012>:
      <D.22009>:
      D.22018 = flags & 6144;
      if (D.22018 == 4096) goto <D.22019>; else goto <D.22020>;
      <D.22019>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22021>; else goto <D.22022>;
      <D.22021>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22023 = monoeg_g_strdup_printf ("Invalid method row %d is RTSpecialName but not SpecialName", i);
        vinfo->info.message = D.22023;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22024 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22024;
      }
      <D.22022>:
      ctx->valid = 0;
      return;
      <D.22020>:
      D.22025 = i + 1;
      D.22026 = (unsigned int) D.22025;
      if (D.22026 < module_method_list) goto <D.22027>; else goto <D.22028>;
      <D.22027>:
      D.21974 = flags & 16;
      if (D.21974 == 0) goto <D.22029>; else goto <D.22030>;
      <D.22029>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22031>; else goto <D.22032>;
      <D.22031>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22033 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not Static", i);
        vinfo->info.message = D.22033;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22034 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22034;
      }
      <D.22032>:
      ctx->valid = 0;
      return;
      <D.22030>:
      D.22035 = flags & 1088;
      if (D.22035 != 0) goto <D.22036>; else goto <D.22037>;
      <D.22036>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22038>; else goto <D.22039>;
      <D.22038>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22040 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but is Abstract or Virtual", i);
        vinfo->info.message = D.22040;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22041 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22041;
      }
      <D.22039>:
      ctx->valid = 0;
      return;
      <D.22037>:
      if (access == 4) goto <D.22042>; else goto <D.22044>;
      <D.22044>:
      if (access == 2) goto <D.22042>; else goto <D.22045>;
      <D.22045>:
      if (access == 5) goto <D.22042>; else goto <D.22043>;
      <D.22042>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22046>; else goto <D.22047>;
      <D.22046>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22048 = monoeg_g_strdup_printf ("Invalid method row %d is a global method but not CompilerControled, Public, Private or Assembly", i);
        vinfo->info.message = D.22048;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22049 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22049;
      }
      <D.22047>:
      ctx->valid = 0;
      return;
      <D.22043>:
      <D.22028>:
      D.22050 = flags & 800;
      if (D.22050 != 0) goto <D.22051>; else goto <D.22052>;
      <D.22051>:
      D.22001 = flags & 64;
      if (D.22001 == 0) goto <D.22053>; else goto <D.22054>;
      <D.22053>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22055>; else goto <D.22056>;
      <D.22055>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22057 = monoeg_g_strdup_printf ("Invalid method row %d is (Final, NewSlot or Strict) but not Virtual", i);
        vinfo->info.message = D.22057;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22058 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22058;
      }
      <D.22056>:
      ctx->valid = 0;
      return;
      <D.22054>:
      <D.22052>:
      D.21987 = flags & 8192;
      if (D.21987 != 0) goto <D.22059>; else goto <D.22060>;
      <D.22059>:
      D.22001 = flags & 64;
      if (D.22001 != 0) goto <D.22061>; else goto <D.22062>;
      <D.22061>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22063>; else goto <D.22064>;
      <D.22063>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22065 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i);
        vinfo->info.message = D.22065;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22066 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22066;
      }
      <D.22064>:
      ctx->valid = 0;
      return;
      <D.22062>:
      D.21974 = flags & 16;
      if (D.21974 == 0) goto <D.22067>; else goto <D.22068>;
      <D.22067>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22069>; else goto <D.22070>;
      <D.22069>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22071 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i);
        vinfo->info.message = D.22071;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22072 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22072;
      }
      <D.22070>:
      ctx->valid = 0;
      return;
      <D.22068>:
      <D.22060>:
      D.21984 = flags & 1024;
      D.22073 = D.21984 | rva;
      if (D.22073 == 0) goto <D.22074>; else goto <D.22075>;
      <D.22074>:
      D.21987 = flags & 8192;
      if (D.21987 == 0) goto <D.22076>; else goto <D.22077>;
      <D.22076>:
      D.22078 = implflags & 4096;
      if (D.22078 == 0) goto <D.22079>; else goto <D.22080>;
      <D.22079>:
      if (code_type != 3) goto <D.22081>; else goto <D.22082>;
      <D.22081>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22083>; else goto <D.22084>;
      <D.22083>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22085 = 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.22085;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22086 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22086;
      }
      <D.22084>:
      ctx->valid = 0;
      return;
      <D.22082>:
      <D.22080>:
      <D.22077>:
      <D.22075>:
      if (access == 0) goto <D.22087>; else goto <D.22088>;
      <D.22087>:
      if (rva == 0) goto <D.22089>; else goto <D.22090>;
      <D.22089>:
      D.21987 = flags & 8192;
      if (D.21987 == 0) goto <D.22091>; else goto <D.22092>;
      <D.22091>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22093>; else goto <D.22094>;
      <D.22093>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22095 = monoeg_g_strdup_printf ("Invalid method row %d is CompilerControlled but neither RVA != 0 or PinvokeImpl", i);
        vinfo->info.message = D.22095;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22096 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22096;
      }
      <D.22094>:
      ctx->valid = 0;
      return;
      <D.22092>:
      <D.22090>:
      <D.22088>:
      if (rva != 0) goto <D.22097>; else goto <D.22098>;
      <D.22097>:
      D.22101 = flags & 9216;
      if (D.22101 != 0) goto <D.22099>; else goto <D.22102>;
      <D.22102>:
      D.22078 = implflags & 4096;
      if (D.22078 != 0) goto <D.22099>; else goto <D.22100>;
      <D.22099>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22103>; else goto <D.22104>;
      <D.22103>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22105 = monoeg_g_strdup_printf ("Invalid method row %d has RVA != 0 but is either Abstract, InternalCall or PinvokeImpl", i);
        vinfo->info.message = D.22105;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22106 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22106;
      }
      <D.22104>:
      ctx->valid = 0;
      return;
      <D.22100>:
      if (code_type == 2) goto <D.22107>; else goto <D.22108>;
      <D.22107>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22109>; else goto <D.22110>;
      <D.22109>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22111 = 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.22111;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22112 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22112;
      }
      <D.22110>:
      ctx->valid = 0;
      return;
      <D.22108>:
      goto <D.22113>;
      <D.22098>:
      D.22101 = flags & 9216;
      if (D.22101 == 0) goto <D.22114>; else goto <D.22115>;
      <D.22114>:
      D.22078 = implflags & 4096;
      if (D.22078 == 0) goto <D.22116>; else goto <D.22117>;
      <D.22116>:
      if (code_type != 3) goto <D.22118>; else goto <D.22119>;
      <D.22118>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22120>; else goto <D.22121>;
      <D.22120>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22122 = monoeg_g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i);
        vinfo->info.message = D.22122;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22123 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22123;
      }
      <D.22121>:
      ctx->valid = 0;
      return;
      <D.22119>:
      <D.22117>:
      <D.22115>:
      <D.22113>:
      D.21987 = flags & 8192;
      if (D.21987 != 0) goto <D.22124>; else goto <D.22125>;
      <D.22124>:
      if (rva != 0) goto <D.22126>; else goto <D.22127>;
      <D.22126>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22128>; else goto <D.22129>;
      <D.22128>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22130 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has RVA != 0", i);
        vinfo->info.message = D.22130;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22131 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22131;
      }
      <D.22129>:
      ctx->valid = 0;
      return;
      <D.22127>:
      i.39 = (unsigned int) i;
      D.22132 = make_coded_token (56, 6, i.39);
      D.22133 = search_sorted_table (ctx, 28, 1, D.22132);
      if (D.22133 == -1) goto <D.22134>; else goto <D.22135>;
      <D.22134>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22136>; else goto <D.22137>;
      <D.22136>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22138 = monoeg_g_strdup_printf ("Invalid method row %d is PinvokeImpl but has no row in the ImplMap table", i);
        vinfo->info.message = D.22138;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22139 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22139;
      }
      <D.22137>:
      ctx->valid = 0;
      return;
      <D.22135>:
      <D.22125>:
      D.22140 = flags & 4096;
      if (D.22140 != 0) goto <D.22141>; else goto <D.22142>;
      <D.22141>:
      D.21962 = is_ctor | is_cctor;
      if (D.21962 == 0) goto <D.22143>; else goto <D.22144>;
      <D.22143>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22145>; else goto <D.22146>;
      <D.22145>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22147 = monoeg_g_strdup_printf ("Invalid method row %d is RtSpecialName but not named .ctor or .cctor", i);
        vinfo->info.message = D.22147;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22148 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22148;
      }
      <D.22146>:
      ctx->valid = 0;
      return;
      <D.22144>:
      <D.22142>:
      D.21962 = is_ctor | is_cctor;
      if (D.21962 != 0) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      D.22140 = flags & 4096;
      if (D.22140 == 0) goto <D.22151>; else goto <D.22152>;
      <D.22151>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22153>; else goto <D.22154>;
      <D.22153>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22155 = monoeg_g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i);
        vinfo->info.message = D.22155;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22156 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22156;
      }
      <D.22154>:
      ctx->valid = 0;
      return;
      <D.22152>:
      <D.22150>:
      D.22157 = data[4];
      if (D.22157 != 0) goto <D.22158>; else goto <D.22159>;
      <D.22158>:
      D.22157 = data[4];
      D.22160 = is_valid_blob_object (ctx, D.22157, 1);
      if (D.22160 == 0) goto <D.22161>; else goto <D.22162>;
      <D.22161>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22163>; else goto <D.22164>;
      <D.22163>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22157 = data[4];
        D.22165 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, D.22157);
        vinfo->info.message = D.22165;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22166 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22166;
      }
      <D.22164>:
      ctx->valid = 0;
      return;
      <D.22162>:
      <D.22159>:
      D.22167 = data[5];
      if (D.22167 == 0) goto <D.22168>; else goto <D.22169>;
      <D.22168>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22170>; else goto <D.22171>;
      <D.22170>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22172 = monoeg_g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i);
        vinfo->info.message = D.22172;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22173 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22173;
      }
      <D.22171>:
      ctx->valid = 0;
      return;
      <D.22169>:
      D.22167 = data[5];
      if (D.22167 < paramlist) goto <D.22174>; else goto <D.22175>;
      <D.22174>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22176>; else goto <D.22177>;
      <D.22176>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22167 = data[5];
        D.22178 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x can\'t be smaller than of previous row 0x%08x", i, D.22167, paramlist);
        vinfo->info.message = D.22178;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22179 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22179;
      }
      <D.22177>:
      ctx->valid = 0;
      return;
      <D.22175>:
      D.22167 = data[5];
      D.21853 = ctx->image;
      D.22180 = D.21853->tables[8].rows;
      D.22181 = (int) D.22180;
      D.22182 = D.22181 + 1;
      D.22183 = (unsigned int) D.22182;
      if (D.22167 > D.22183) goto <D.22184>; else goto <D.22185>;
      <D.22184>:
      D.21861 = ctx->report_error;
      if (D.21861 != 0) goto <D.22186>; else goto <D.22187>;
      <D.22186>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22167 = data[5];
        D.22188 = monoeg_g_strdup_printf ("Invalid method row %d ParamList rowid 0x%08x is out of range", i, D.22167);
        vinfo->info.message = D.22188;
        vinfo->exception_type = 3;
        D.21865 = ctx->errors;
        D.22189 = monoeg_g_slist_prepend (D.21865, vinfo);
        ctx->errors = D.22189;
      }
      <D.22187>:
      ctx->valid = 0;
      return;
      <D.22185>:
      paramlist = data[5];
      i = i + 1;
      <D.19420>:
      D.22190 = table->rows;
      D.22191 = (int) D.22190;
      if (D.22191 > i) goto <D.19419>; else goto <D.19421>;
      <D.19421>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


get_string_ptr (struct VerifyContext * ctx, guint offset)
{
  const char * D.22195;
  struct MonoImage * D.22196;
  const char * D.22197;
  sizetype D.22198;

  D.22196 = ctx->image;
  D.22197 = D.22196->heap_strings.data;
  D.22198 = (sizetype) offset;
  D.22195 = D.22197 + D.22198;
  return D.22195;
}


verify_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22200;
  long unsigned int D.22201;
  long unsigned int D.22202;
  <unnamed-unsigned:24> D.22205;
  int D.22206;
  int D.22209;
  gchar * D.22212;
  struct GSList * D.22213;
  struct GSList * D.22214;
  unsigned int D.22215;
  gchar * D.22220;
  struct GSList * D.22221;
  unsigned int i.40;
  unsigned int D.22223;
  int D.22224;
  unsigned int D.22227;
  gchar * D.22232;
  struct GSList * D.22233;
  gchar * D.22239;
  struct GSList * D.22240;
  unsigned int D.22241;
  unsigned int D.22244;
  int D.22245;
  gchar * D.22250;
  struct GSList * D.22251;
  unsigned int D.22252;
  int D.22253;
  gchar * D.22258;
  struct GSList * D.22259;
  unsigned int D.22262;
  gchar * D.22267;
  struct GSList * D.22268;
  struct MonoTableInfo * table;
  guint32 data[3];
  guint32 flags;
  guint32 sequence;
  guint32 remaining_params;
  guint32 current_method;
  gboolean first_param;
  int i;

  try
    {
      D.22200 = ctx->image;
      table = &D.22200->tables[8];
      sequence = 0;
      current_method = 0;
      first_param = 1;
      D.22200 = ctx->image;
      D.22201 = BIT_FIELD_REF <*D.22200, 64, 2368>;
      D.22202 = D.22201 & 16777215;
      if (D.22202 == 0) goto <D.22203>; else goto <D.22204>;
      <D.22203>:
      D.22205 = table->rows;
      D.22206 = (int) D.22205;
      if (D.22206 > 0) goto <D.22207>; else goto <D.22208>;
      <D.22207>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22210>; else goto <D.22211>;
      <D.22210>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22212 = monoeg_strdup ("Param table has rows while the method table has zero");
        vinfo->info.message = D.22212;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22214 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22214;
      }
      <D.22211>:
      ctx->valid = 0;
      return;
      <D.22208>:
      return;
      <D.22204>:
      remaining_params = get_next_param_count (ctx, &current_method);
      i = 0;
      goto <D.19465>;
      <D.19464>:
      mono_metadata_decode_row (table, i, &data, 3);
      flags = data[0];
      D.22215 = flags & 53228;
      if (D.22215 != 0) goto <D.22216>; else goto <D.22217>;
      <D.22216>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22218>; else goto <D.22219>;
      <D.22218>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22220 = monoeg_g_strdup_printf ("Invalid param row %d bad Flags value 0x%08x", i, flags);
        vinfo->info.message = D.22220;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22221 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22221;
      }
      <D.22219>:
      ctx->valid = 0;
      return;
      <D.22217>:
      i.40 = (unsigned int) i;
      D.22223 = make_coded_token (5, 8, i.40);
      D.22224 = search_sorted_table (ctx, 11, 2, D.22223);
      if (D.22224 == -1) goto <D.22225>; else goto <D.22226>;
      <D.22225>:
      D.22227 = flags & 4096;
      if (D.22227 != 0) goto <D.22228>; else goto <D.22229>;
      <D.22228>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22230>; else goto <D.22231>;
      <D.22230>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22232 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 1 but no owned row in Contant table", i);
        vinfo->info.message = D.22232;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22233 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22233;
      }
      <D.22231>:
      ctx->valid = 0;
      return;
      <D.22229>:
      goto <D.22234>;
      <D.22226>:
      D.22227 = flags & 4096;
      if (D.22227 == 0) goto <D.22235>; else goto <D.22236>;
      <D.22235>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22237>; else goto <D.22238>;
      <D.22237>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22239 = monoeg_g_strdup_printf ("Invalid param row %d HasDefault = 0 but has owned row in Contant table", i);
        vinfo->info.message = D.22239;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22240 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22240;
      }
      <D.22238>:
      ctx->valid = 0;
      return;
      <D.22236>:
      <D.22234>:
      D.22241 = flags & 8192;
      if (D.22241 != 0) goto <D.22242>; else goto <D.22243>;
      <D.22242>:
      i.40 = (unsigned int) i;
      D.22244 = make_coded_token (32, 8, i.40);
      D.22245 = search_sorted_table (ctx, 13, 0, D.22244);
      if (D.22245 == -1) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22248>; else goto <D.22249>;
      <D.22248>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22250 = monoeg_g_strdup_printf ("Invalid param row %d HasFieldMarshal = 1 but no owned row in FieldMarshal table", i);
        vinfo->info.message = D.22250;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22251 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22251;
      }
      <D.22249>:
      ctx->valid = 0;
      return;
      <D.22247>:
      <D.22243>:
      D.22252 = data[2];
      D.22253 = is_valid_string (ctx, D.22252);
      if (D.22253 == 0) goto <D.22254>; else goto <D.22255>;
      <D.22254>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22256>; else goto <D.22257>;
      <D.22256>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22252 = data[2];
        D.22258 = monoeg_g_strdup_printf ("Invalid param row %d Name = 1 bad token 0x%08x", i, D.22252);
        vinfo->info.message = D.22258;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22259 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22259;
      }
      <D.22257>:
      ctx->valid = 0;
      return;
      <D.22255>:
      if (first_param == 0) goto <D.22260>; else goto <D.22261>;
      <D.22260>:
      D.22262 = data[1];
      if (D.22262 <= sequence) goto <D.22263>; else goto <D.22264>;
      <D.22263>:
      D.22209 = ctx->report_error;
      if (D.22209 != 0) goto <D.22265>; else goto <D.22266>;
      <D.22265>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22262 = data[1];
        D.22267 = monoeg_g_strdup_printf ("Invalid param row %d sequece = %d previus param has %d", i, D.22262, sequence);
        vinfo->info.message = D.22267;
        vinfo->exception_type = 3;
        D.22213 = ctx->errors;
        D.22268 = monoeg_g_slist_prepend (D.22213, vinfo);
        ctx->errors = D.22268;
      }
      <D.22266>:
      ctx->valid = 0;
      return;
      <D.22264>:
      <D.22261>:
      first_param = 0;
      sequence = data[1];
      remaining_params = remaining_params + 4294967295;
      if (remaining_params == 0) goto <D.22269>; else goto <D.22270>;
      <D.22269>:
      remaining_params = get_next_param_count (ctx, &current_method);
      first_param = 1;
      <D.22270>:
      i = i + 1;
      <D.19465>:
      D.22205 = table->rows;
      D.22206 = (int) D.22205;
      if (D.22206 > i) goto <D.19464>; else goto <D.19466>;
      <D.19466>:
    }
  finally
    {
      data = {CLOBBER};
      current_method = {CLOBBER};
    }
}


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

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


get_next_param_count (struct VerifyContext * ctx, guint32 * current_method)
{
  struct MonoImage * D.22276;
  unsigned int row.41;
  int row.42;
  int row.43;
  guint32 D.22282;
  <unnamed-unsigned:24> D.22283;
  unsigned int D.22284;
  struct MonoTableInfo * table;
  guint32 row;
  guint32 paramlist;
  guint32 tmp;

  D.22276 = ctx->image;
  table = &D.22276->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.19444>;
  <D.19443>:
  row.43 = (int) row;
  tmp = mono_metadata_decode_row_col (table, row.43, 5);
  if (tmp > paramlist) goto <D.22280>; else goto <D.22281>;
  <D.22280>:
  *current_method = row;
  D.22282 = tmp - paramlist;
  return D.22282;
  <D.22281>:
  row = row + 1;
  <D.19444>:
  D.22283 = table->rows;
  D.22284 = (unsigned int) D.22283;
  if (D.22284 > row) goto <D.19443>; else goto <D.19445>;
  <D.19445>:
  D.22283 = table->rows;
  D.22284 = (unsigned int) D.22283;
  *current_method = D.22284;
  D.22282 = 4294967295;
  return D.22282;
}


verify_interfaceimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22286;
  unsigned int D.22287;
  <unnamed-unsigned:24> D.22290;
  unsigned int D.22291;
  int D.22294;
  gchar * D.22297;
  struct GSList * D.22298;
  struct GSList * D.22299;
  unsigned int D.22300;
  int D.22301;
  gchar * D.22306;
  struct GSList * D.22307;
  unsigned int D.22308;
  gchar * D.22313;
  struct GSList * D.22314;
  <unnamed-unsigned:24> D.22315;
  int D.22316;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22286 = ctx->image;
      table = &D.22286->tables[9];
      i = 0;
      goto <D.19477>;
      <D.19476>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22287 = data[0];
      if (D.22287 != 0) goto <D.22288>; else goto <D.22289>;
      <D.22288>:
      D.22287 = data[0];
      D.22286 = ctx->image;
      D.22290 = D.22286->tables[2].rows;
      D.22291 = (unsigned int) D.22290;
      if (D.22287 > D.22291) goto <D.22292>; else goto <D.22293>;
      <D.22292>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22295>; else goto <D.22296>;
      <D.22295>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22287 = data[0];
        D.22297 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Class field 0x%08x", i, D.22287);
        vinfo->info.message = D.22297;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22299 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22299;
      }
      <D.22296>:
      ctx->valid = 0;
      return;
      <D.22293>:
      <D.22289>:
      D.22300 = data[1];
      D.22301 = is_valid_coded_index (ctx, 0, D.22300);
      if (D.22301 == 0) goto <D.22302>; else goto <D.22303>;
      <D.22302>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22304>; else goto <D.22305>;
      <D.22304>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22300 = data[1];
        D.22306 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field coded index 0x%08x", i, D.22300);
        vinfo->info.message = D.22306;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22307 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22307;
      }
      <D.22305>:
      ctx->valid = 0;
      return;
      <D.22303>:
      D.22300 = data[1];
      D.22308 = get_coded_index_token (0, D.22300);
      if (D.22308 == 0) goto <D.22309>; else goto <D.22310>;
      <D.22309>:
      D.22294 = ctx->report_error;
      if (D.22294 != 0) goto <D.22311>; else goto <D.22312>;
      <D.22311>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22313 = monoeg_g_strdup_printf ("Invalid InterfaceImpl row %d Inteface field is null", i);
        vinfo->info.message = D.22313;
        vinfo->exception_type = 3;
        D.22298 = ctx->errors;
        D.22314 = monoeg_g_slist_prepend (D.22298, vinfo);
        ctx->errors = D.22314;
      }
      <D.22312>:
      ctx->valid = 0;
      return;
      <D.22310>:
      i = i + 1;
      <D.19477>:
      D.22315 = table->rows;
      D.22316 = (int) D.22315;
      if (D.22316 > i) goto <D.19476>; else goto <D.19478>;
      <D.19478>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_memberref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22320;
  unsigned int D.22321;
  int D.22322;
  int D.22325;
  gchar * D.22328;
  struct GSList * D.22329;
  struct GSList * D.22330;
  unsigned int D.22331;
  gchar * D.22336;
  struct GSList * D.22337;
  unsigned int D.22338;
  int D.22339;
  gchar * D.22344;
  struct GSList * D.22345;
  unsigned int D.22346;
  int D.22349;
  gchar * D.22354;
  struct GSList * D.22355;
  <unnamed-unsigned:24> D.22356;
  int D.22357;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22320 = ctx->image;
      table = &D.22320->tables[10];
      i = 0;
      goto <D.19490>;
      <D.19489>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22321 = data[0];
      D.22322 = is_valid_coded_index (ctx, 41, D.22321);
      if (D.22322 == 0) goto <D.22323>; else goto <D.22324>;
      <D.22323>:
      D.22325 = ctx->report_error;
      if (D.22325 != 0) goto <D.22326>; else goto <D.22327>;
      <D.22326>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22321 = data[0];
        D.22328 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded index 0x%08x", i, D.22321);
        vinfo->info.message = D.22328;
        vinfo->exception_type = 3;
        D.22329 = ctx->errors;
        D.22330 = monoeg_g_slist_prepend (D.22329, vinfo);
        ctx->errors = D.22330;
      }
      <D.22327>:
      ctx->valid = 0;
      return;
      <D.22324>:
      D.22321 = data[0];
      D.22331 = get_coded_index_token (41, D.22321);
      if (D.22331 == 0) goto <D.22332>; else goto <D.22333>;
      <D.22332>:
      D.22325 = ctx->report_error;
      if (D.22325 != 0) goto <D.22334>; else goto <D.22335>;
      <D.22334>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22336 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Class field coded is null", i);
        vinfo->info.message = D.22336;
        vinfo->exception_type = 3;
        D.22329 = ctx->errors;
        D.22337 = monoeg_g_slist_prepend (D.22329, vinfo);
        ctx->errors = D.22337;
      }
      <D.22335>:
      ctx->valid = 0;
      return;
      <D.22333>:
      D.22338 = data[1];
      D.22339 = is_valid_non_empty_string (ctx, D.22338);
      if (D.22339 == 0) goto <D.22340>; else goto <D.22341>;
      <D.22340>:
      D.22325 = ctx->report_error;
      if (D.22325 != 0) goto <D.22342>; else goto <D.22343>;
      <D.22342>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22338 = data[1];
        D.22344 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, D.22338);
        vinfo->info.message = D.22344;
        vinfo->exception_type = 3;
        D.22329 = ctx->errors;
        D.22345 = monoeg_g_slist_prepend (D.22329, vinfo);
        ctx->errors = D.22345;
      }
      <D.22343>:
      ctx->valid = 0;
      return;
      <D.22341>:
      D.22346 = data[2];
      if (D.22346 != 0) goto <D.22347>; else goto <D.22348>;
      <D.22347>:
      D.22346 = data[2];
      D.22349 = is_valid_blob_object (ctx, D.22346, 1);
      if (D.22349 == 0) goto <D.22350>; else goto <D.22351>;
      <D.22350>:
      D.22325 = ctx->report_error;
      if (D.22325 != 0) goto <D.22352>; else goto <D.22353>;
      <D.22352>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22346 = data[2];
        D.22354 = monoeg_g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, D.22346);
        vinfo->info.message = D.22354;
        vinfo->exception_type = 3;
        D.22329 = ctx->errors;
        D.22355 = monoeg_g_slist_prepend (D.22329, vinfo);
        ctx->errors = D.22355;
      }
      <D.22353>:
      ctx->valid = 0;
      return;
      <D.22351>:
      <D.22348>:
      i = i + 1;
      <D.19490>:
      D.22356 = table->rows;
      D.22357 = (int) D.22356;
      if (D.22357 > i) goto <D.19489>; else goto <D.19491>;
      <D.19491>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_constant_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22361;
  unsigned int D.22362;
  int D.22367;
  gchar * D.22370;
  struct GSList * D.22371;
  struct GSList * D.22372;
  unsigned int D.22373;
  int D.22374;
  gchar * D.22379;
  struct GSList * D.22380;
  unsigned int D.22381;
  gchar * D.22386;
  struct GSList * D.22387;
  unsigned int D.22388;
  int D.22389;
  gchar * D.22394;
  struct GSList * D.22395;
  <unnamed-unsigned:24> D.22396;
  int D.22397;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 type;
  int i;

  try
    {
      D.22361 = ctx->image;
      table = &D.22361->tables[11];
      i = 0;
      goto <D.19514>;
      <D.19513>:
      mono_metadata_decode_row (table, i, &data, 4);
      type = data[0];
      D.22362 = type + 4294967294;
      if (D.22362 > 12) goto <D.22363>; else goto <D.22364>;
      <D.22363>:
      if (type != 18) goto <D.22365>; else goto <D.22366>;
      <D.22365>:
      D.22367 = ctx->report_error;
      if (D.22367 != 0) goto <D.22368>; else goto <D.22369>;
      <D.22368>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22370 = monoeg_g_strdup_printf ("Invalid Constant row %d Type field 0x%08x", i, type);
        vinfo->info.message = D.22370;
        vinfo->exception_type = 3;
        D.22371 = ctx->errors;
        D.22372 = monoeg_g_slist_prepend (D.22371, vinfo);
        ctx->errors = D.22372;
      }
      <D.22369>:
      ctx->valid = 0;
      return;
      <D.22366>:
      <D.22364>:
      D.22373 = data[2];
      D.22374 = is_valid_coded_index (ctx, 5, D.22373);
      if (D.22374 == 0) goto <D.22375>; else goto <D.22376>;
      <D.22375>:
      D.22367 = ctx->report_error;
      if (D.22367 != 0) goto <D.22377>; else goto <D.22378>;
      <D.22377>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22373 = data[2];
        D.22379 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded index 0x%08x", i, D.22373);
        vinfo->info.message = D.22379;
        vinfo->exception_type = 3;
        D.22371 = ctx->errors;
        D.22380 = monoeg_g_slist_prepend (D.22371, vinfo);
        ctx->errors = D.22380;
      }
      <D.22378>:
      ctx->valid = 0;
      return;
      <D.22376>:
      D.22373 = data[2];
      D.22381 = get_coded_index_token (5, D.22373);
      if (D.22381 == 0) goto <D.22382>; else goto <D.22383>;
      <D.22382>:
      D.22367 = ctx->report_error;
      if (D.22367 != 0) goto <D.22384>; else goto <D.22385>;
      <D.22384>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22386 = monoeg_g_strdup_printf ("Invalid Constant row %d Parent field coded is null", i);
        vinfo->info.message = D.22386;
        vinfo->exception_type = 3;
        D.22371 = ctx->errors;
        D.22387 = monoeg_g_slist_prepend (D.22371, vinfo);
        ctx->errors = D.22387;
      }
      <D.22385>:
      ctx->valid = 0;
      return;
      <D.22383>:
      D.22388 = data[3];
      D.22389 = is_valid_constant (ctx, type, D.22388);
      if (D.22389 == 0) goto <D.22390>; else goto <D.22391>;
      <D.22390>:
      D.22367 = ctx->report_error;
      if (D.22367 != 0) goto <D.22392>; else goto <D.22393>;
      <D.22392>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22388 = data[3];
        D.22394 = monoeg_g_strdup_printf ("Invalid Constant row %d Value field 0x%08x", i, D.22388);
        vinfo->info.message = D.22394;
        vinfo->exception_type = 3;
        D.22371 = ctx->errors;
        D.22395 = monoeg_g_slist_prepend (D.22371, vinfo);
        ctx->errors = D.22395;
      }
      <D.22393>:
      ctx->valid = 0;
      return;
      <D.22391>:
      i = i + 1;
      <D.19514>:
      D.22396 = table->rows;
      D.22397 = (int) D.22396;
      if (D.22397 > i) goto <D.19513>; else goto <D.19515>;
      <D.19515>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_constant (struct VerifyContext * ctx, guint32 type, guint32 offset)
{
  struct MonoImage * D.22401;
  struct MonoStreamHeader * D.22402;
  unsigned int D.22403;
  int D.22406;
  gchar * D.22409;
  struct GSList * D.22410;
  struct GSList * D.22411;
  gboolean D.22412;
  const char * D.22413;
  sizetype D.22414;
  unsigned int D.22415;
  sizetype D.22416;
  sizetype D.22417;
  const char * D.22418;
  unsigned int D.22419;
  int D.22420;
  gchar * D.22425;
  struct GSList * D.22426;
  unsigned int bytes.44;
  unsigned int entry_size.45;
  unsigned int D.22433;
  unsigned int D.22435;
  unsigned int D.22438;
  unsigned int D.22439;
  gchar * D.22440;
  struct GSList * D.22441;
  gchar * D.22446;
  struct GSList * D.22447;
  unsigned int D.22450;
  unsigned int D.22452;
  gchar * D.22455;
  struct GSList * D.22456;
  unsigned int D.22459;
  gchar * D.22464;
  struct GSList * D.22465;
  struct OffsetAndSize blob;
  guint32 size;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.22401 = ctx->image;
      D.22402 = &D.22401->heap_blob;
      blob = get_metadata_stream (ctx, D.22402);
      D.22403 = blob.size;
      if (D.22403 < offset) goto <D.22404>; else goto <D.22405>;
      <D.22404>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22407>; else goto <D.22408>;
      <D.22407>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22409 = monoeg_strdup ("ContantValue: invalid offset");
        vinfo->info.message = D.22409;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22411 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22411;
      }
      <D.22408>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22405>:
      D.22413 = ctx->data;
      D.22414 = (sizetype) offset;
      D.22415 = blob.offset;
      D.22416 = (sizetype) D.22415;
      D.22417 = D.22414 + D.22416;
      D.22418 = D.22413 + D.22417;
      D.22403 = blob.size;
      D.22415 = blob.offset;
      D.22419 = D.22403 - D.22415;
      D.22420 = decode_value (D.22418, D.22419, &entry_size, &bytes);
      if (D.22420 == 0) goto <D.22421>; else goto <D.22422>;
      <D.22421>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22423>; else goto <D.22424>;
      <D.22423>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22425 = monoeg_strdup ("ContantValue: not enough space to decode size");
        vinfo->info.message = D.22425;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22426 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22426;
      }
      <D.22424>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22422>:
      if (type == 14) goto <D.22427>; else goto <D.22428>;
      <D.22427>:
      bytes.44 = bytes;
      offset = offset + bytes.44;
      entry_size.45 = entry_size;
      D.22433 = offset + entry_size.45;
      D.22403 = blob.size;
      if (D.22433 > D.22403) goto <D.22430>; else goto <D.22434>;
      <D.22434>:
      entry_size.45 = entry_size;
      D.22435 = ~entry_size.45;
      if (D.22435 < offset) goto <D.22430>; else goto <D.22431>;
      <D.22430>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22436>; else goto <D.22437>;
      <D.22436>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        entry_size.45 = entry_size;
        D.22438 = entry_size.45 * 2;
        D.22403 = blob.size;
        D.22439 = D.22403 - offset;
        D.22440 = monoeg_g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", D.22438, D.22439);
        vinfo->info.message = D.22440;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22441 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22441;
      }
      <D.22437>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22431>:
      D.22412 = 1;
      return D.22412;
      <D.22428>:
      switch (type) <default: <D.19199>, case 2: <D.19185>, case 3: <D.19189>, case 4: <D.19186>, case 5: <D.19187>, case 6: <D.19190>, case 7: <D.19191>, case 8: <D.19192>, case 9: <D.19193>, case 10: <D.19196>, case 11: <D.19197>, case 12: <D.19194>, case 13: <D.19198>, case 18: <D.19195>>
      <D.19185>:
      <D.19186>:
      <D.19187>:
      size = 1;
      goto <D.19188>;
      <D.19189>:
      <D.19190>:
      <D.19191>:
      size = 2;
      goto <D.19188>;
      <D.19192>:
      <D.19193>:
      <D.19194>:
      <D.19195>:
      size = 4;
      goto <D.19188>;
      <D.19196>:
      <D.19197>:
      <D.19198>:
      size = 8;
      goto <D.19188>;
      <D.19199>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "metadata-verify.c", 2221);
      <D.19188>:
      entry_size.45 = entry_size;
      if (size != entry_size.45) goto <D.22442>; else goto <D.22443>;
      <D.22442>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22444>; else goto <D.22445>;
      <D.22444>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        entry_size.45 = entry_size;
        D.22446 = monoeg_g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size.45);
        vinfo->info.message = D.22446;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22447 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22447;
      }
      <D.22445>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22443>:
      bytes.44 = bytes;
      offset = offset + bytes.44;
      D.22450 = offset + size;
      D.22403 = blob.size;
      if (D.22450 > D.22403) goto <D.22448>; else goto <D.22451>;
      <D.22451>:
      D.22452 = ~size;
      if (D.22452 < offset) goto <D.22448>; else goto <D.22449>;
      <D.22448>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22453>; else goto <D.22454>;
      <D.22453>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22403 = blob.size;
        D.22439 = D.22403 - offset;
        D.22455 = monoeg_g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, D.22439);
        vinfo->info.message = D.22455;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22456 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22456;
      }
      <D.22454>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22449>:
      if (type == 18) goto <D.22457>; else goto <D.22458>;
      <D.22457>:
      D.22413 = ctx->data;
      D.22415 = blob.offset;
      D.22416 = (sizetype) D.22415;
      D.22414 = (sizetype) offset;
      D.22417 = D.22416 + D.22414;
      D.22418 = D.22413 + D.22417;
      D.22459 = MEM[(const guint32 *)D.22418];
      if (D.22459 != 0) goto <D.22460>; else goto <D.22461>;
      <D.22460>:
      D.22406 = ctx->report_error;
      if (D.22406 != 0) goto <D.22462>; else goto <D.22463>;
      <D.22462>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22464 = monoeg_g_strdup_printf ("ContantValue: Type is class but value is not null");
        vinfo->info.message = D.22464;
        vinfo->exception_type = 3;
        D.22410 = ctx->errors;
        D.22465 = monoeg_g_slist_prepend (D.22410, vinfo);
        ctx->errors = D.22465;
      }
      <D.22463>:
      ctx->valid = 0;
      D.22412 = 0;
      return D.22412;
      <D.22461>:
      <D.22458>:
      D.22412 = 1;
      return D.22412;
    }
  finally
    {
      blob = {CLOBBER};
      entry_size = {CLOBBER};
      bytes = {CLOBBER};
    }
}


verify_cattr_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22468;
  unsigned int D.22469;
  int D.22470;
  int D.22473;
  gchar * D.22476;
  struct GSList * D.22477;
  struct GSList * D.22478;
  unsigned int D.22481;
  int D.22482;
  unsigned int D.22484;
  gchar * D.22487;
  struct GSList * D.22488;
  unsigned int D.22489;
  int D.22492;
  gchar * D.22497;
  struct GSList * D.22498;
  <unnamed-unsigned:24> D.22499;
  int D.22500;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22468 = ctx->image;
      table = &D.22468->tables[12];
      i = 0;
      goto <D.19526>;
      <D.19525>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22469 = data[0];
      D.22470 = is_valid_coded_index (ctx, 10, D.22469);
      if (D.22470 == 0) goto <D.22471>; else goto <D.22472>;
      <D.22471>:
      D.22473 = ctx->report_error;
      if (D.22473 != 0) goto <D.22474>; else goto <D.22475>;
      <D.22474>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22469 = data[0];
        D.22476 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, D.22469);
        vinfo->info.message = D.22476;
        vinfo->exception_type = 3;
        D.22477 = ctx->errors;
        D.22478 = monoeg_g_slist_prepend (D.22477, vinfo);
        ctx->errors = D.22478;
      }
      <D.22475>:
      ctx->valid = 0;
      return;
      <D.22472>:
      D.22481 = data[1];
      D.22482 = is_valid_coded_index (ctx, 65, D.22481);
      if (D.22482 == 0) goto <D.22479>; else goto <D.22483>;
      <D.22483>:
      D.22481 = data[1];
      D.22484 = get_coded_index_token (65, D.22481);
      if (D.22484 == 0) goto <D.22479>; else goto <D.22480>;
      <D.22479>:
      D.22473 = ctx->report_error;
      if (D.22473 != 0) goto <D.22485>; else goto <D.22486>;
      <D.22485>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22481 = data[1];
        D.22487 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Type field 0x%08x", i, D.22481);
        vinfo->info.message = D.22487;
        vinfo->exception_type = 3;
        D.22477 = ctx->errors;
        D.22488 = monoeg_g_slist_prepend (D.22477, vinfo);
        ctx->errors = D.22488;
      }
      <D.22486>:
      ctx->valid = 0;
      return;
      <D.22480>:
      D.22489 = data[2];
      if (D.22489 != 0) goto <D.22490>; else goto <D.22491>;
      <D.22490>:
      D.22489 = data[2];
      D.22492 = is_valid_blob_object (ctx, D.22489, 0);
      if (D.22492 == 0) goto <D.22493>; else goto <D.22494>;
      <D.22493>:
      D.22473 = ctx->report_error;
      if (D.22473 != 0) goto <D.22495>; else goto <D.22496>;
      <D.22495>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22489 = data[2];
        D.22497 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, D.22489);
        vinfo->info.message = D.22497;
        vinfo->exception_type = 3;
        D.22477 = ctx->errors;
        D.22498 = monoeg_g_slist_prepend (D.22477, vinfo);
        ctx->errors = D.22498;
      }
      <D.22496>:
      ctx->valid = 0;
      return;
      <D.22494>:
      <D.22491>:
      i = i + 1;
      <D.19526>:
      D.22499 = table->rows;
      D.22500 = (int) D.22499;
      if (D.22500 > i) goto <D.19525>; else goto <D.19527>;
      <D.19527>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_marshal_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22504;
  unsigned int D.22505;
  int D.22506;
  int D.22509;
  gchar * D.22512;
  struct GSList * D.22513;
  struct GSList * D.22514;
  unsigned int D.22515;
  gchar * D.22520;
  struct GSList * D.22521;
  unsigned int D.22522;
  gchar * D.22527;
  struct GSList * D.22528;
  int D.22529;
  gchar * D.22534;
  struct GSList * D.22535;
  <unnamed-unsigned:24> D.22536;
  int D.22537;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22504 = ctx->image;
      table = &D.22504->tables[13];
      i = 0;
      goto <D.19559>;
      <D.19558>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22505 = data[0];
      D.22506 = is_valid_coded_index (ctx, 32, D.22505);
      if (D.22506 == 0) goto <D.22507>; else goto <D.22508>;
      <D.22507>:
      D.22509 = ctx->report_error;
      if (D.22509 != 0) goto <D.22510>; else goto <D.22511>;
      <D.22510>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22505 = data[0];
        D.22512 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field 0x%08x", i, D.22505);
        vinfo->info.message = D.22512;
        vinfo->exception_type = 3;
        D.22513 = ctx->errors;
        D.22514 = monoeg_g_slist_prepend (D.22513, vinfo);
        ctx->errors = D.22514;
      }
      <D.22511>:
      ctx->valid = 0;
      return;
      <D.22508>:
      D.22505 = data[0];
      D.22515 = get_coded_index_token (32, D.22505);
      if (D.22515 == 0) goto <D.22516>; else goto <D.22517>;
      <D.22516>:
      D.22509 = ctx->report_error;
      if (D.22509 != 0) goto <D.22518>; else goto <D.22519>;
      <D.22518>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22520 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d Parent field is null", i);
        vinfo->info.message = D.22520;
        vinfo->exception_type = 3;
        D.22513 = ctx->errors;
        D.22521 = monoeg_g_slist_prepend (D.22513, vinfo);
        ctx->errors = D.22521;
      }
      <D.22519>:
      ctx->valid = 0;
      return;
      <D.22517>:
      D.22522 = data[1];
      if (D.22522 == 0) goto <D.22523>; else goto <D.22524>;
      <D.22523>:
      D.22509 = ctx->report_error;
      if (D.22509 != 0) goto <D.22525>; else goto <D.22526>;
      <D.22525>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22527 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i);
        vinfo->info.message = D.22527;
        vinfo->exception_type = 3;
        D.22513 = ctx->errors;
        D.22528 = monoeg_g_slist_prepend (D.22513, vinfo);
        ctx->errors = D.22528;
      }
      <D.22526>:
      ctx->valid = 0;
      return;
      <D.22524>:
      D.22522 = data[1];
      D.22529 = is_valid_blob_object (ctx, D.22522, 1);
      if (D.22529 == 0) goto <D.22530>; else goto <D.22531>;
      <D.22530>:
      D.22509 = ctx->report_error;
      if (D.22509 != 0) goto <D.22532>; else goto <D.22533>;
      <D.22532>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22522 = data[1];
        D.22534 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, D.22522);
        vinfo->info.message = D.22534;
        vinfo->exception_type = 3;
        D.22513 = ctx->errors;
        D.22535 = monoeg_g_slist_prepend (D.22513, vinfo);
        ctx->errors = D.22535;
      }
      <D.22533>:
      ctx->valid = 0;
      return;
      <D.22531>:
      i = i + 1;
      <D.19559>:
      D.22536 = table->rows;
      D.22537 = (int) D.22536;
      if (D.22537 > i) goto <D.19558>; else goto <D.19560>;
      <D.19560>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_decl_security_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22541;
  unsigned int D.22542;
  int D.22543;
  int D.22546;
  gchar * D.22549;
  struct GSList * D.22550;
  struct GSList * D.22551;
  unsigned int D.22552;
  gchar * D.22557;
  struct GSList * D.22558;
  unsigned int D.22559;
  gchar * D.22564;
  struct GSList * D.22565;
  <unnamed-unsigned:24> D.22566;
  int D.22567;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22541 = ctx->image;
      table = &D.22541->tables[14];
      i = 0;
      goto <D.19581>;
      <D.19580>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22542 = data[1];
      D.22543 = is_valid_coded_index (ctx, 36, D.22542);
      if (D.22543 == 0) goto <D.22544>; else goto <D.22545>;
      <D.22544>:
      D.22546 = ctx->report_error;
      if (D.22546 != 0) goto <D.22547>; else goto <D.22548>;
      <D.22547>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22542 = data[1];
        D.22549 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field 0x%08x", i, D.22542);
        vinfo->info.message = D.22549;
        vinfo->exception_type = 3;
        D.22550 = ctx->errors;
        D.22551 = monoeg_g_slist_prepend (D.22550, vinfo);
        ctx->errors = D.22551;
      }
      <D.22548>:
      ctx->valid = 0;
      return;
      <D.22545>:
      D.22542 = data[1];
      D.22552 = get_coded_index_token (36, D.22542);
      if (D.22552 == 0) goto <D.22553>; else goto <D.22554>;
      <D.22553>:
      D.22546 = ctx->report_error;
      if (D.22546 != 0) goto <D.22555>; else goto <D.22556>;
      <D.22555>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22557 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d Parent field is null", i);
        vinfo->info.message = D.22557;
        vinfo->exception_type = 3;
        D.22550 = ctx->errors;
        D.22558 = monoeg_g_slist_prepend (D.22550, vinfo);
        ctx->errors = D.22558;
      }
      <D.22556>:
      ctx->valid = 0;
      return;
      <D.22554>:
      D.22559 = data[2];
      if (D.22559 == 0) goto <D.22560>; else goto <D.22561>;
      <D.22560>:
      D.22546 = ctx->report_error;
      if (D.22546 != 0) goto <D.22562>; else goto <D.22563>;
      <D.22562>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22564 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i);
        vinfo->info.message = D.22564;
        vinfo->exception_type = 3;
        D.22550 = ctx->errors;
        D.22565 = monoeg_g_slist_prepend (D.22550, vinfo);
        ctx->errors = D.22565;
      }
      <D.22563>:
      ctx->valid = 0;
      return;
      <D.22561>:
      i = i + 1;
      <D.19581>:
      D.22566 = table->rows;
      D.22567 = (int) D.22566;
      if (D.22567 > i) goto <D.19580>; else goto <D.19582>;
      <D.19582>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_class_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22571;
  unsigned int D.22574;
  <unnamed-unsigned:24> D.22576;
  int D.22577;
  int D.22578;
  unsigned int D.22579;
  int D.22580;
  gchar * D.22583;
  struct GSList * D.22584;
  struct GSList * D.22585;
  unsigned int D.22586;
  gchar * D.22589;
  struct GSList * D.22590;
  <unnamed-unsigned:24> D.22591;
  int D.22592;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22571 = ctx->image;
      table = &D.22571->tables[15];
      i = 0;
      goto <D.19613>;
      <D.19612>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22574 = data[2];
      if (D.22574 == 0) goto <D.22572>; else goto <D.22575>;
      <D.22575>:
      D.22574 = data[2];
      D.22571 = ctx->image;
      D.22576 = D.22571->tables[2].rows;
      D.22577 = (int) D.22576;
      D.22578 = D.22577 + 1;
      D.22579 = (unsigned int) D.22578;
      if (D.22574 > D.22579) goto <D.22572>; else goto <D.22573>;
      <D.22572>:
      D.22580 = ctx->report_error;
      if (D.22580 != 0) goto <D.22581>; else goto <D.22582>;
      <D.22581>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22574 = data[2];
        D.22583 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Parent field 0x%08x", i, D.22574);
        vinfo->info.message = D.22583;
        vinfo->exception_type = 3;
        D.22584 = ctx->errors;
        D.22585 = monoeg_g_slist_prepend (D.22584, vinfo);
        ctx->errors = D.22585;
      }
      <D.22582>:
      ctx->valid = 0;
      return;
      <D.22573>:
      D.22586 = data[0];
      switch (D.22586) <default: <D.19610>, case 0: <D.19600>, case 1: <D.19601>, case 2: <D.19602>, case 4: <D.19603>, case 8: <D.19604>, case 16: <D.19605>, case 32: <D.19606>, case 64: <D.19607>, case 128: <D.19608>>
      <D.19600>:
      <D.19601>:
      <D.19602>:
      <D.19603>:
      <D.19604>:
      <D.19605>:
      <D.19606>:
      <D.19607>:
      <D.19608>:
      goto <D.19609>;
      <D.19610>:
      D.22580 = ctx->report_error;
      if (D.22580 != 0) goto <D.22587>; else goto <D.22588>;
      <D.22587>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22586 = data[0];
        D.22589 = monoeg_g_strdup_printf ("Invalid ClassLayout row %d Packing field %d", i, D.22586);
        vinfo->info.message = D.22589;
        vinfo->exception_type = 3;
        D.22584 = ctx->errors;
        D.22590 = monoeg_g_slist_prepend (D.22584, vinfo);
        ctx->errors = D.22590;
      }
      <D.22588>:
      ctx->valid = 0;
      return;
      <D.19609>:
      i = i + 1;
      <D.19613>:
      D.22591 = table->rows;
      D.22592 = (int) D.22591;
      if (D.22592 > i) goto <D.19612>; else goto <D.19614>;
      <D.19614>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_field_layout_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22597;
  unsigned int D.22600;
  <unnamed-unsigned:24> D.22602;
  int D.22603;
  int D.22604;
  unsigned int D.22605;
  int D.22606;
  gchar * D.22609;
  struct GSList * D.22610;
  struct GSList * D.22611;
  <unnamed-unsigned:24> D.22612;
  int D.22613;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.22597 = ctx->image;
      table = &D.22597->tables[16];
      i = 0;
      goto <D.19623>;
      <D.19622>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22600 = data[1];
      if (D.22600 == 0) goto <D.22598>; else goto <D.22601>;
      <D.22601>:
      D.22600 = data[1];
      D.22597 = ctx->image;
      D.22602 = D.22597->tables[4].rows;
      D.22603 = (int) D.22602;
      D.22604 = D.22603 + 1;
      D.22605 = (unsigned int) D.22604;
      if (D.22600 > D.22605) goto <D.22598>; else goto <D.22599>;
      <D.22598>:
      D.22606 = ctx->report_error;
      if (D.22606 != 0) goto <D.22607>; else goto <D.22608>;
      <D.22607>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22600 = data[1];
        D.22609 = monoeg_g_strdup_printf ("Invalid FieldLayout row %d Field field 0x%08x", i, D.22600);
        vinfo->info.message = D.22609;
        vinfo->exception_type = 3;
        D.22610 = ctx->errors;
        D.22611 = monoeg_g_slist_prepend (D.22610, vinfo);
        ctx->errors = D.22611;
      }
      <D.22608>:
      ctx->valid = 0;
      return;
      <D.22599>:
      i = i + 1;
      <D.19623>:
      D.22612 = table->rows;
      D.22613 = (int) D.22612;
      if (D.22613 > i) goto <D.19622>; else goto <D.19624>;
      <D.19624>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_standalonesig_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22617;
  unsigned int D.22618;
  int D.22621;
  int D.22624;
  gchar * D.22627;
  struct GSList * D.22628;
  struct GSList * D.22629;
  <unnamed-unsigned:24> D.22630;
  int D.22631;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.22617 = ctx->image;
      table = &D.22617->tables[17];
      i = 0;
      goto <D.19633>;
      <D.19632>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.22618 = data[0];
      if (D.22618 != 0) goto <D.22619>; else goto <D.22620>;
      <D.22619>:
      D.22618 = data[0];
      D.22621 = is_valid_blob_object (ctx, D.22618, 1);
      if (D.22621 == 0) goto <D.22622>; else goto <D.22623>;
      <D.22622>:
      D.22624 = ctx->report_error;
      if (D.22624 != 0) goto <D.22625>; else goto <D.22626>;
      <D.22625>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22618 = data[0];
        D.22627 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, D.22618);
        vinfo->info.message = D.22627;
        vinfo->exception_type = 3;
        D.22628 = ctx->errors;
        D.22629 = monoeg_g_slist_prepend (D.22628, vinfo);
        ctx->errors = D.22629;
      }
      <D.22626>:
      ctx->valid = 0;
      return;
      <D.22623>:
      <D.22620>:
      i = i + 1;
      <D.19633>:
      D.22630 = table->rows;
      D.22631 = (int) D.22630;
      if (D.22631 > i) goto <D.19632>; else goto <D.19634>;
      <D.19634>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_eventmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22635;
  unsigned int D.22638;
  <unnamed-unsigned:24> D.22640;
  int D.22641;
  int D.22642;
  unsigned int D.22643;
  int D.22644;
  gchar * D.22647;
  struct GSList * D.22648;
  struct GSList * D.22649;
  unsigned int D.22652;
  gchar * D.22656;
  struct GSList * D.22657;
  <unnamed-unsigned:24> D.22658;
  int D.22659;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 eventlist;
  int i;

  try
    {
      D.22635 = ctx->image;
      table = &D.22635->tables[18];
      eventlist = 0;
      i = 0;
      goto <D.19655>;
      <D.19654>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22638 = data[0];
      if (D.22638 == 0) goto <D.22636>; else goto <D.22639>;
      <D.22639>:
      D.22638 = data[0];
      D.22635 = ctx->image;
      D.22640 = D.22635->tables[2].rows;
      D.22641 = (int) D.22640;
      D.22642 = D.22641 + 1;
      D.22643 = (unsigned int) D.22642;
      if (D.22638 > D.22643) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      D.22644 = ctx->report_error;
      if (D.22644 != 0) goto <D.22645>; else goto <D.22646>;
      <D.22645>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22638 = data[0];
        D.22647 = monoeg_g_strdup_printf ("Invalid EventMap row %d Parent field 0x%08x", i, D.22638);
        vinfo->info.message = D.22647;
        vinfo->exception_type = 3;
        D.22648 = ctx->errors;
        D.22649 = monoeg_g_slist_prepend (D.22648, vinfo);
        ctx->errors = D.22649;
      }
      <D.22646>:
      ctx->valid = 0;
      return;
      <D.22637>:
      D.22652 = data[1];
      if (D.22652 == 0) goto <D.22650>; else goto <D.22653>;
      <D.22653>:
      D.22652 = data[1];
      if (D.22652 <= eventlist) goto <D.22650>; else goto <D.22651>;
      <D.22650>:
      D.22644 = ctx->report_error;
      if (D.22644 != 0) goto <D.22654>; else goto <D.22655>;
      <D.22654>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22652 = data[1];
        D.22656 = monoeg_g_strdup_printf ("Invalid EventMap row %d EventList field %d", i, D.22652);
        vinfo->info.message = D.22656;
        vinfo->exception_type = 3;
        D.22648 = ctx->errors;
        D.22657 = monoeg_g_slist_prepend (D.22648, vinfo);
        ctx->errors = D.22657;
      }
      <D.22655>:
      ctx->valid = 0;
      return;
      <D.22651>:
      eventlist = data[1];
      i = i + 1;
      <D.19655>:
      D.22658 = table->rows;
      D.22659 = (int) D.22658;
      if (D.22659 > i) goto <D.19654>; else goto <D.19656>;
      <D.19656>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_event_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22663;
  unsigned int D.22664;
  unsigned int D.22665;
  int D.22668;
  gchar * D.22671;
  struct GSList * D.22672;
  struct GSList * D.22673;
  unsigned int D.22674;
  int D.22675;
  gchar * D.22680;
  struct GSList * D.22681;
  unsigned int D.22682;
  int D.22683;
  gchar * D.22688;
  struct GSList * D.22689;
  <unnamed-unsigned:24> D.22690;
  int D.22691;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22663 = ctx->image;
      table = &D.22663->tables[20];
      i = 0;
      goto <D.19667>;
      <D.19666>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22664 = data[0];
      D.22665 = D.22664 & 4294965759;
      if (D.22665 != 0) goto <D.22666>; else goto <D.22667>;
      <D.22666>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22669>; else goto <D.22670>;
      <D.22669>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22664 = data[0];
        D.22671 = monoeg_g_strdup_printf ("Invalid Event row %d EventFlags field %08x", i, D.22664);
        vinfo->info.message = D.22671;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22673 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22673;
      }
      <D.22670>:
      ctx->valid = 0;
      return;
      <D.22667>:
      D.22674 = data[1];
      D.22675 = is_valid_non_empty_string (ctx, D.22674);
      if (D.22675 == 0) goto <D.22676>; else goto <D.22677>;
      <D.22676>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22678>; else goto <D.22679>;
      <D.22678>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22674 = data[1];
        D.22680 = monoeg_g_strdup_printf ("Invalid Event row %d Name field %08x", i, D.22674);
        vinfo->info.message = D.22680;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22681 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22681;
      }
      <D.22679>:
      ctx->valid = 0;
      return;
      <D.22677>:
      D.22682 = data[2];
      D.22683 = is_valid_coded_index (ctx, 0, D.22682);
      if (D.22683 == 0) goto <D.22684>; else goto <D.22685>;
      <D.22684>:
      D.22668 = ctx->report_error;
      if (D.22668 != 0) goto <D.22686>; else goto <D.22687>;
      <D.22686>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22682 = data[2];
        D.22688 = monoeg_g_strdup_printf ("Invalid Event row %d EventType field %08x", i, D.22682);
        vinfo->info.message = D.22688;
        vinfo->exception_type = 3;
        D.22672 = ctx->errors;
        D.22689 = monoeg_g_slist_prepend (D.22672, vinfo);
        ctx->errors = D.22689;
      }
      <D.22687>:
      ctx->valid = 0;
      return;
      <D.22685>:
      i = i + 1;
      <D.19667>:
      D.22690 = table->rows;
      D.22691 = (int) D.22690;
      if (D.22691 > i) goto <D.19666>; else goto <D.19668>;
      <D.19668>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_propertymap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22695;
  unsigned int D.22698;
  <unnamed-unsigned:24> D.22700;
  int D.22701;
  int D.22702;
  unsigned int D.22703;
  int D.22704;
  gchar * D.22707;
  struct GSList * D.22708;
  struct GSList * D.22709;
  unsigned int D.22712;
  gchar * D.22716;
  struct GSList * D.22717;
  <unnamed-unsigned:24> D.22718;
  int D.22719;
  struct MonoTableInfo * table;
  guint32 data[2];
  guint32 propertylist;
  int i;

  try
    {
      D.22695 = ctx->image;
      table = &D.22695->tables[21];
      propertylist = 0;
      i = 0;
      goto <D.19703>;
      <D.19702>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.22698 = data[0];
      if (D.22698 == 0) goto <D.22696>; else goto <D.22699>;
      <D.22699>:
      D.22698 = data[0];
      D.22695 = ctx->image;
      D.22700 = D.22695->tables[2].rows;
      D.22701 = (int) D.22700;
      D.22702 = D.22701 + 1;
      D.22703 = (unsigned int) D.22702;
      if (D.22698 > D.22703) goto <D.22696>; else goto <D.22697>;
      <D.22696>:
      D.22704 = ctx->report_error;
      if (D.22704 != 0) goto <D.22705>; else goto <D.22706>;
      <D.22705>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22698 = data[0];
        D.22707 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d Parent field 0x%08x", i, D.22698);
        vinfo->info.message = D.22707;
        vinfo->exception_type = 3;
        D.22708 = ctx->errors;
        D.22709 = monoeg_g_slist_prepend (D.22708, vinfo);
        ctx->errors = D.22709;
      }
      <D.22706>:
      ctx->valid = 0;
      return;
      <D.22697>:
      D.22712 = data[1];
      if (D.22712 == 0) goto <D.22710>; else goto <D.22713>;
      <D.22713>:
      D.22712 = data[1];
      if (D.22712 <= propertylist) goto <D.22710>; else goto <D.22711>;
      <D.22710>:
      D.22704 = ctx->report_error;
      if (D.22704 != 0) goto <D.22714>; else goto <D.22715>;
      <D.22714>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22712 = data[1];
        D.22716 = monoeg_g_strdup_printf ("Invalid PropertyMap row %d PropertyList field %d", i, D.22712);
        vinfo->info.message = D.22716;
        vinfo->exception_type = 3;
        D.22708 = ctx->errors;
        D.22717 = monoeg_g_slist_prepend (D.22708, vinfo);
        ctx->errors = D.22717;
      }
      <D.22715>:
      ctx->valid = 0;
      return;
      <D.22711>:
      propertylist = data[1];
      i = i + 1;
      <D.19703>:
      D.22718 = table->rows;
      D.22719 = (int) D.22718;
      if (D.22719 > i) goto <D.19702>; else goto <D.19704>;
      <D.19704>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_property_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.22723;
  unsigned int D.22724;
  unsigned int D.22725;
  int D.22728;
  gchar * D.22731;
  struct GSList * D.22732;
  struct GSList * D.22733;
  unsigned int D.22734;
  int D.22735;
  gchar * D.22740;
  struct GSList * D.22741;
  unsigned int D.22742;
  int D.22743;
  gchar * D.22748;
  struct GSList * D.22749;
  unsigned int D.22750;
  unsigned int i.46;
  unsigned int D.22754;
  int D.22755;
  gchar * D.22760;
  struct GSList * D.22761;
  <unnamed-unsigned:24> D.22762;
  int D.22763;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.22723 = ctx->image;
      table = &D.22723->tables[23];
      i = 0;
      goto <D.19716>;
      <D.19715>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.22724 = data[0];
      D.22725 = D.22724 & 4294961663;
      if (D.22725 != 0) goto <D.22726>; else goto <D.22727>;
      <D.22726>:
      D.22728 = ctx->report_error;
      if (D.22728 != 0) goto <D.22729>; else goto <D.22730>;
      <D.22729>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22724 = data[0];
        D.22731 = monoeg_g_strdup_printf ("Invalid Property row %d PropertyFlags field %08x", i, D.22724);
        vinfo->info.message = D.22731;
        vinfo->exception_type = 3;
        D.22732 = ctx->errors;
        D.22733 = monoeg_g_slist_prepend (D.22732, vinfo);
        ctx->errors = D.22733;
      }
      <D.22730>:
      ctx->valid = 0;
      return;
      <D.22727>:
      D.22734 = data[1];
      D.22735 = is_valid_non_empty_string (ctx, D.22734);
      if (D.22735 == 0) goto <D.22736>; else goto <D.22737>;
      <D.22736>:
      D.22728 = ctx->report_error;
      if (D.22728 != 0) goto <D.22738>; else goto <D.22739>;
      <D.22738>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22734 = data[1];
        D.22740 = monoeg_g_strdup_printf ("Invalid Property row %d Name field %08x", i, D.22734);
        vinfo->info.message = D.22740;
        vinfo->exception_type = 3;
        D.22732 = ctx->errors;
        D.22741 = monoeg_g_slist_prepend (D.22732, vinfo);
        ctx->errors = D.22741;
      }
      <D.22739>:
      ctx->valid = 0;
      return;
      <D.22737>:
      D.22742 = data[2];
      D.22743 = is_valid_property_sig_blob (ctx, D.22742);
      if (D.22743 == 0) goto <D.22744>; else goto <D.22745>;
      <D.22744>:
      D.22728 = ctx->report_error;
      if (D.22728 != 0) goto <D.22746>; else goto <D.22747>;
      <D.22746>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22742 = data[2];
        D.22748 = monoeg_g_strdup_printf ("Invalid Property row %d Type field %08x", i, D.22742);
        vinfo->info.message = D.22748;
        vinfo->exception_type = 3;
        D.22732 = ctx->errors;
        D.22749 = monoeg_g_slist_prepend (D.22732, vinfo);
        ctx->errors = D.22749;
      }
      <D.22747>:
      ctx->valid = 0;
      return;
      <D.22745>:
      D.22724 = data[0];
      D.22750 = D.22724 & 4096;
      if (D.22750 != 0) goto <D.22751>; else goto <D.22752>;
      <D.22751>:
      i.46 = (unsigned int) i;
      D.22754 = make_coded_token (5, 23, i.46);
      D.22755 = search_sorted_table (ctx, 11, 2, D.22754);
      if (D.22755 == -1) goto <D.22756>; else goto <D.22757>;
      <D.22756>:
      D.22728 = ctx->report_error;
      if (D.22728 != 0) goto <D.22758>; else goto <D.22759>;
      <D.22758>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22760 = 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.22760;
        vinfo->exception_type = 3;
        D.22732 = ctx->errors;
        D.22761 = monoeg_g_slist_prepend (D.22732, vinfo);
        ctx->errors = D.22761;
      }
      <D.22759>:
      ctx->valid = 0;
      return;
      <D.22757>:
      <D.22752>:
      i = i + 1;
      <D.19716>:
      D.22762 = table->rows;
      D.22763 = (int) D.22762;
      if (D.22763 > i) goto <D.19715>; else goto <D.19717>;
      <D.19717>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_property_sig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.22767;
  int D.22770;
  gchar * D.22773;
  struct GSList * D.22774;
  struct GSList * D.22775;
  gboolean D.22776;
  const char * ptr.47;
  unsigned int size.48;
  sizetype D.22779;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.22767 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.22767 == 0) goto <D.22768>; else goto <D.22769>;
      <D.22768>:
      D.22770 = ctx->report_error;
      if (D.22770 != 0) goto <D.22771>; else goto <D.22772>;
      <D.22771>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22773 = monoeg_strdup ("PropertySig: Could not decode signature header");
        vinfo->info.message = D.22773;
        vinfo->exception_type = 3;
        D.22774 = ctx->errors;
        D.22775 = monoeg_g_slist_prepend (D.22774, vinfo);
        ctx->errors = D.22775;
      }
      <D.22772>:
      ctx->valid = 0;
      D.22776 = 0;
      return D.22776;
      <D.22769>:
      ptr.47 = ptr;
      size.48 = size;
      D.22779 = (sizetype) size.48;
      end = ptr.47 + D.22779;
      D.22776 = parse_property_signature (ctx, &ptr, end);
      return D.22776;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


decode_signature_header (struct VerifyContext * ctx, guint32 offset, guint32 * size, const char * * first_byte)
{
  struct MonoImage * D.22782;
  unsigned int D.22783;
  gboolean D.22786;
  const char * D.22787;
  sizetype D.22788;
  const char * D.22789;
  unsigned int D.22790;
  int D.22791;
  unsigned int enc_size.49;
  unsigned int D.22795;
  unsigned int value.50;
  unsigned int D.22801;
  unsigned int D.22803;
  struct MonoStreamHeader blob;
  guint32 value;
  guint32 enc_size;

  try
    {
      D.22782 = ctx->image;
      blob = D.22782->heap_blob;
      D.22783 = blob.size;
      if (D.22783 <= offset) goto <D.22784>; else goto <D.22785>;
      <D.22784>:
      D.22786 = 0;
      return D.22786;
      <D.22785>:
      D.22787 = blob.data;
      D.22788 = (sizetype) offset;
      D.22789 = D.22787 + D.22788;
      D.22783 = blob.size;
      D.22790 = D.22783 - offset;
      D.22791 = decode_value (D.22789, D.22790, &value, &enc_size);
      if (D.22791 == 0) goto <D.22792>; else goto <D.22793>;
      <D.22792>:
      D.22786 = 0;
      return D.22786;
      <D.22793>:
      enc_size.49 = enc_size;
      D.22795 = ~enc_size.49;
      if (D.22795 < offset) goto <D.22796>; else goto <D.22797>;
      <D.22796>:
      D.22786 = 0;
      return D.22786;
      <D.22797>:
      enc_size.49 = enc_size;
      offset = offset + enc_size.49;
      value.50 = value;
      D.22801 = offset + value.50;
      D.22783 = blob.size;
      if (D.22801 > D.22783) goto <D.22798>; else goto <D.22802>;
      <D.22802>:
      value.50 = value;
      D.22803 = ~value.50;
      if (D.22803 < offset) goto <D.22798>; else goto <D.22799>;
      <D.22798>:
      D.22786 = 0;
      return D.22786;
      <D.22799>:
      value.50 = value;
      *size = value.50;
      D.22787 = blob.data;
      D.22788 = (sizetype) offset;
      D.22789 = D.22787 + D.22788;
      *first_byte = D.22789;
      D.22786 = 1;
      return D.22786;
    }
  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.22807;
  int D.22810;
  gchar * D.22813;
  struct GSList * D.22814;
  struct GSList * D.22815;
  gboolean D.22816;
  unsigned int sig.52;
  gchar * D.22824;
  struct GSList * D.22825;
  int D.22826;
  gchar * D.22831;
  struct GSList * D.22832;
  int D.22833;
  int D.22836;
  gchar * D.22841;
  struct GSList * D.22842;
  int D.22843;
  gchar * D.22848;
  struct GSList * D.22849;
  int D.22850;
  gchar * D.22855;
  struct GSList * D.22856;
  unsigned int param_count.53;
  const char * ptr.54;
  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.22807 = safe_read (&ptr, end, &sig, 1);
      if (D.22807 == 0) goto <D.22808>; else goto <D.22809>;
      <D.22808>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22811>; else goto <D.22812>;
      <D.22811>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22813 = monoeg_strdup ("PropertySig: Not enough room for signature");
        vinfo->info.message = D.22813;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22815 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22815;
      }
      <D.22812>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22809>:
      sig.52 = sig;
      if (sig.52 != 8) goto <D.22818>; else goto <D.22819>;
      <D.22818>:
      sig.52 = sig;
      if (sig.52 != 40) goto <D.22820>; else goto <D.22821>;
      <D.22820>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22822>; else goto <D.22823>;
      <D.22822>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        sig.52 = sig;
        D.22824 = monoeg_g_strdup_printf ("PropertySig: Signature is not 0x28 or 0x08: %x", sig.52);
        vinfo->info.message = D.22824;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22825 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22825;
      }
      <D.22823>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22821>:
      <D.22819>:
      D.22826 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.22826 == 0) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22829>; else goto <D.22830>;
      <D.22829>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22831 = monoeg_strdup ("PropertySig: Not enough room for the param count");
        vinfo->info.message = D.22831;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22832 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22832;
      }
      <D.22830>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22828>:
      D.22833 = parse_custom_mods (ctx, &ptr, end);
      if (D.22833 == 0) goto <D.22834>; else goto <D.22835>;
      <D.22834>:
      D.22816 = 0;
      return D.22816;
      <D.22835>:
      D.22836 = parse_type (ctx, &ptr, end);
      if (D.22836 == 0) goto <D.22837>; else goto <D.22838>;
      <D.22837>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22839>; else goto <D.22840>;
      <D.22839>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22841 = monoeg_strdup ("PropertySig: Could not parse property type");
        vinfo->info.message = D.22841;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22842 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22842;
      }
      <D.22840>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22838>:
      i = 0;
      goto <D.18899>;
      <D.18898>:
      D.22843 = parse_custom_mods (ctx, &ptr, end);
      if (D.22843 == 0) goto <D.22844>; else goto <D.22845>;
      <D.22844>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22846>; else goto <D.22847>;
      <D.22846>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22848 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22848;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22849 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22849;
      }
      <D.22847>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22845>:
      D.22850 = parse_type (ctx, &ptr, end);
      if (D.22850 == 0) goto <D.22851>; else goto <D.22852>;
      <D.22851>:
      D.22810 = ctx->report_error;
      if (D.22810 != 0) goto <D.22853>; else goto <D.22854>;
      <D.22853>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22855 = monoeg_g_strdup_printf ("PropertySig: Error parsing arg %d", i);
        vinfo->info.message = D.22855;
        vinfo->exception_type = 3;
        D.22814 = ctx->errors;
        D.22856 = monoeg_g_slist_prepend (D.22814, vinfo);
        ctx->errors = D.22856;
      }
      <D.22854>:
      ctx->valid = 0;
      D.22816 = 0;
      return D.22816;
      <D.22852>:
      i = i + 1;
      <D.18899>:
      param_count.53 = param_count;
      if (i < param_count.53) goto <D.18898>; else goto <D.18900>;
      <D.18900>:
      ptr.54 = ptr;
      *_ptr = ptr.54;
      D.22816 = 1;
      return D.22816;
    }
  finally
    {
      sig = {CLOBBER};
      param_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


safe_read (const char * * _ptr, const char * limit, unsigned int * dest, int size)
{
  sizetype D.22861;
  const char * D.22862;
  gboolean D.22865;
  unsigned char D.22866;
  unsigned int D.22867;
  short unsigned int D.22868;
  unsigned int D.22869;
  unsigned int D.22870;
  const char * ptr;

  ptr = *_ptr;
  D.22861 = (sizetype) size;
  D.22862 = ptr + D.22861;
  if (D.22862 > limit) goto <D.22863>; else goto <D.22864>;
  <D.22863>:
  D.22865 = 0;
  return D.22865;
  <D.22864>:
  switch (size) <default: <D.22871>, case 1: <D.18724>, case 2: <D.18726>, case 4: <D.18727>>
  <D.18724>:
  D.22866 = MEM[(guint8 *)ptr];
  D.22867 = (unsigned int) D.22866;
  *dest = D.22867;
  ptr = ptr + 1;
  goto <D.18725>;
  <D.18726>:
  D.22868 = MEM[(const guint16 *)ptr];
  D.22869 = (unsigned int) D.22868;
  *dest = D.22869;
  ptr = ptr + 2;
  goto <D.18725>;
  <D.18727>:
  D.22870 = MEM[(const guint32 *)ptr];
  *dest = D.22870;
  ptr = ptr + 4;
  goto <D.18725>;
  <D.22871>:
  <D.18725>:
  *_ptr = ptr;
  D.22865 = 1;
  return D.22865;
}


safe_read_compressed_int (const char * * _ptr, const char * limit, unsigned int * dest)
{
  long int limit.55;
  long int ptr.56;
  long int D.22875;
  unsigned int D.22876;
  unsigned int size.57;
  sizetype D.22878;
  const char * D.22879;
  gboolean D.22880;
  unsigned int size;
  const char * ptr;
  gboolean res;

  try
    {
      size = 0;
      ptr = *_ptr;
      limit.55 = (long int) limit;
      ptr.56 = (long int) ptr;
      D.22875 = limit.55 - ptr.56;
      D.22876 = (unsigned int) D.22875;
      res = decode_value (ptr, D.22876, dest, &size);
      size.57 = size;
      D.22878 = (sizetype) size.57;
      D.22879 = ptr + D.22878;
      *_ptr = D.22879;
      D.22880 = res;
      return D.22880;
    }
  finally
    {
      size = {CLOBBER};
    }
}


parse_custom_mods (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.58;
  int D.22884;
  int D.22887;
  gchar * D.22890;
  struct GSList * D.22891;
  struct GSList * D.22892;
  gboolean D.22893;
  unsigned int type.59;
  unsigned int D.22895;
  const char * ptr.60;
  const char * ptr.61;
  int D.22900;
  gchar * D.22905;
  struct GSList * D.22906;
  unsigned int token.62;
  int D.22910;
  unsigned int D.22912;
  gchar * D.22915;
  struct GSList * D.22916;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.58 = *_ptr;
      ptr = ptr.58;
      type = 0;
      token = 0;
      <D.18758>:
      D.22884 = safe_read (&ptr, end, &type, 1);
      if (D.22884 == 0) goto <D.22885>; else goto <D.22886>;
      <D.22885>:
      D.22887 = ctx->report_error;
      if (D.22887 != 0) goto <D.22888>; else goto <D.22889>;
      <D.22888>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22890 = monoeg_strdup ("CustomMod: Not enough room for the type");
        vinfo->info.message = D.22890;
        vinfo->exception_type = 3;
        D.22891 = ctx->errors;
        D.22892 = monoeg_g_slist_prepend (D.22891, vinfo);
        ctx->errors = D.22892;
      }
      <D.22889>:
      ctx->valid = 0;
      D.22893 = 0;
      return D.22893;
      <D.22886>:
      type.59 = type;
      D.22895 = type.59 + 4294967265;
      if (D.22895 > 1) goto <D.22896>; else goto <D.22897>;
      <D.22896>:
      ptr.60 = ptr;
      ptr.61 = ptr.60 + 18446744073709551615;
      ptr = ptr.61;
      goto <D.18755>;
      <D.22897>:
      D.22900 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22900 == 0) goto <D.22901>; else goto <D.22902>;
      <D.22901>:
      D.22887 = ctx->report_error;
      if (D.22887 != 0) goto <D.22903>; else goto <D.22904>;
      <D.22903>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22905 = monoeg_strdup ("CustomMod: Not enough room for the token");
        vinfo->info.message = D.22905;
        vinfo->exception_type = 3;
        D.22891 = ctx->errors;
        D.22906 = monoeg_g_slist_prepend (D.22891, vinfo);
        ctx->errors = D.22906;
      }
      <D.22904>:
      ctx->valid = 0;
      D.22893 = 0;
      return D.22893;
      <D.22902>:
      token.62 = token;
      D.22910 = is_valid_coded_index (ctx, 0, token.62);
      if (D.22910 == 0) goto <D.22907>; else goto <D.22911>;
      <D.22911>:
      token.62 = token;
      D.22912 = get_coded_index_token (0, token.62);
      if (D.22912 == 0) goto <D.22907>; else goto <D.22908>;
      <D.22907>:
      D.22887 = ctx->report_error;
      if (D.22887 != 0) goto <D.22913>; else goto <D.22914>;
      <D.22913>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.62 = token;
        D.22915 = monoeg_g_strdup_printf ("CustomMod: invalid TypeDefOrRef token %x", token.62);
        vinfo->info.message = D.22915;
        vinfo->exception_type = 3;
        D.22891 = ctx->errors;
        D.22916 = monoeg_g_slist_prepend (D.22891, vinfo);
        ctx->errors = D.22916;
      }
      <D.22914>:
      ctx->valid = 0;
      D.22893 = 0;
      return D.22893;
      <D.22908>:
      goto <D.18758>;
      <D.18755>:
      ptr.60 = ptr;
      *_ptr = ptr.60;
      D.22893 = 1;
      return D.22893;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


parse_type (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.63;
  int D.22920;
  int D.22923;
  gchar * D.22926;
  struct GSList * D.22927;
  struct GSList * D.22928;
  gboolean D.22929;
  unsigned int type.64;
  unsigned int D.22931;
  unsigned int D.22934;
  unsigned int D.22937;
  unsigned int D.22940;
  gchar * D.22945;
  struct GSList * D.22946;
  int D.22947;
  gchar * D.22952;
  struct GSList * D.22953;
  int D.22954;
  gchar * D.22959;
  struct GSList * D.22960;
  const char * ptr.65;
  const char * ptr.66;
  int D.22965;
  gchar * D.22970;
  struct GSList * D.22971;
  int D.22972;
  gchar * D.22977;
  struct GSList * D.22978;
  unsigned int token.67;
  int D.22982;
  unsigned int D.22984;
  gchar * D.22987;
  struct GSList * D.22988;
  unsigned int D.22989;
  gchar * D.22994;
  struct GSList * D.22995;
  unsigned int D.22996;
  unsigned int D.22999;
  unsigned int D.23000;
  unsigned int D.23003;
  unsigned int D.23004;
  gchar * D.23009;
  struct GSList * D.23010;
  int D.23011;
  gchar * D.23016;
  struct GSList * D.23017;
  int D.23018;
  gchar * D.23023;
  struct GSList * D.23024;
  int D.23025;
  gchar * D.23030;
  struct GSList * D.23031;
  int D.23032;
  gchar * D.23037;
  struct GSList * D.23038;
  int D.23039;
  gchar * D.23044;
  struct GSList * D.23045;
  int D.23046;
  gchar * D.23051;
  struct GSList * D.23052;
  int D.23053;
  gchar * D.23058;
  struct GSList * D.23059;
  const char * ptr;
  unsigned int type;
  unsigned int token;

  try
    {
      ptr.63 = *_ptr;
      ptr = ptr.63;
      token = 0;
      D.22920 = safe_read (&ptr, end, &type, 1);
      if (D.22920 == 0) goto <D.22921>; else goto <D.22922>;
      <D.22921>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22924>; else goto <D.22925>;
      <D.22924>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22926 = monoeg_strdup ("Type: Not enough room for the type");
        vinfo->info.message = D.22926;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22928 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22928;
      }
      <D.22925>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22922>:
      type.64 = type;
      D.22931 = type.64 + 4294967294;
      if (D.22931 > 13) goto <D.22932>; else goto <D.22933>;
      <D.22932>:
      type.64 = type;
      D.22934 = type.64 + 4294967279;
      if (D.22934 > 4) goto <D.22935>; else goto <D.22936>;
      <D.22935>:
      type.64 = type;
      D.22937 = type.64 + 4294967272;
      if (D.22937 > 1) goto <D.22938>; else goto <D.22939>;
      <D.22938>:
      type.64 = type;
      D.22940 = type.64 + 4294967269;
      if (D.22940 > 3) goto <D.22941>; else goto <D.22942>;
      <D.22941>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22943>; else goto <D.22944>;
      <D.22943>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.64 = type;
        D.22945 = monoeg_g_strdup_printf ("Type: Invalid type kind %x\n", type.64);
        vinfo->info.message = D.22945;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22946 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22946;
      }
      <D.22944>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22942>:
      <D.22939>:
      <D.22936>:
      <D.22933>:
      type.64 = type;
      switch (type.64) <default: <D.23060>, case 15: <D.18813>, case 17: <D.18818>, case 18: <D.18819>, case 19: <D.18824>, case 20: <D.18827>, case 21: <D.18830>, case 27: <D.18832>, case 29: <D.18834>, case 30: <D.18825>>
      <D.18813>:
      D.22947 = parse_custom_mods (ctx, &ptr, end);
      if (D.22947 == 0) goto <D.22948>; else goto <D.22949>;
      <D.22948>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22950>; else goto <D.22951>;
      <D.22950>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22952 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.22952;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22953 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22953;
      }
      <D.22951>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22949>:
      D.22954 = safe_read (&ptr, end, &type, 1);
      if (D.22954 == 0) goto <D.22955>; else goto <D.22956>;
      <D.22955>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22957>; else goto <D.22958>;
      <D.22957>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22959 = monoeg_strdup ("Type: Not enough room to parse the pointer type");
        vinfo->info.message = D.22959;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22960 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22960;
      }
      <D.22958>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22956>:
      type.64 = type;
      if (type.64 != 1) goto <D.22961>; else goto <D.22962>;
      <D.22961>:
      ptr.65 = ptr;
      ptr.66 = ptr.65 + 18446744073709551615;
      ptr = ptr.66;
      D.22965 = parse_type (ctx, &ptr, end);
      if (D.22965 == 0) goto <D.22966>; else goto <D.22967>;
      <D.22966>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22968>; else goto <D.22969>;
      <D.22968>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22970 = monoeg_strdup ("Type: Could not parse pointer type");
        vinfo->info.message = D.22970;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22971 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22971;
      }
      <D.22969>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22967>:
      <D.22962>:
      goto <D.18817>;
      <D.18818>:
      <D.18819>:
      D.22972 = safe_read_compressed_int (&ptr, end, &token);
      if (D.22972 == 0) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22975>; else goto <D.22976>;
      <D.22975>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22977 = monoeg_strdup ("Type: Not enough room for the type token");
        vinfo->info.message = D.22977;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22978 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22978;
      }
      <D.22976>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22974>:
      token.67 = token;
      D.22982 = is_valid_coded_index (ctx, 0, token.67);
      if (D.22982 == 0) goto <D.22979>; else goto <D.22983>;
      <D.22983>:
      token.67 = token;
      D.22984 = get_coded_index_token (0, token.67);
      if (D.22984 == 0) goto <D.22979>; else goto <D.22980>;
      <D.22979>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22985>; else goto <D.22986>;
      <D.22985>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.67 = token;
        D.22987 = monoeg_g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token.67);
        vinfo->info.message = D.22987;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22988 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22988;
      }
      <D.22986>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22980>:
      token.67 = token;
      D.22989 = get_coded_index_token (0, token.67);
      if (D.22989 == 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.22992>; else goto <D.22993>;
      <D.22992>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.67 = token;
        D.22994 = monoeg_g_strdup_printf ("Type: zero TypeDefOrRef token %x", token.67);
        vinfo->info.message = D.22994;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.22995 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.22995;
      }
      <D.22993>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.22991>:
      D.22996 = ctx->token;
      if (D.22996 != 0) goto <D.22997>; else goto <D.22998>;
      <D.22997>:
      D.22996 = ctx->token;
      D.22999 = D.22996 & 16777215;
      token.67 = token;
      D.23000 = get_coded_index_token (0, token.67);
      if (D.22999 == D.23000) goto <D.23001>; else goto <D.23002>;
      <D.23001>:
      D.22996 = ctx->token;
      D.23003 = D.22996 >> 24;
      token.67 = token;
      D.23004 = get_coded_index_table (0, token.67);
      if (D.23003 == D.23004) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23007>; else goto <D.23008>;
      <D.23007>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.22996 = ctx->token;
        D.23009 = monoeg_g_strdup_printf ("Type: Recursive type specification (%x). A type signature can\'t reference itself", D.22996);
        vinfo->info.message = D.23009;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23010 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23010;
      }
      <D.23008>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23006>:
      <D.23002>:
      <D.22998>:
      goto <D.18817>;
      <D.18824>:
      <D.18825>:
      D.23011 = safe_read_compressed_int (&ptr, end, &token);
      if (D.23011 == 0) goto <D.23012>; else goto <D.23013>;
      <D.23012>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23014>; else goto <D.23015>;
      <D.23014>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23016 = monoeg_strdup ("Type: Not enough room for to decode generic argument number");
        vinfo->info.message = D.23016;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23017 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23017;
      }
      <D.23015>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23013>:
      goto <D.18817>;
      <D.18827>:
      D.23018 = parse_type (ctx, &ptr, end);
      if (D.23018 == 0) goto <D.23019>; else goto <D.23020>;
      <D.23019>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23021>; else goto <D.23022>;
      <D.23021>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23023 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.23023;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23024 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23024;
      }
      <D.23022>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23020>:
      D.23025 = parse_array_shape (ctx, &ptr, end);
      if (D.23025 == 0) goto <D.23026>; else goto <D.23027>;
      <D.23026>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23028>; else goto <D.23029>;
      <D.23028>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23030 = monoeg_strdup ("Type: Could not parse array shape");
        vinfo->info.message = D.23030;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23031 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23031;
      }
      <D.23029>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23027>:
      goto <D.18817>;
      <D.18830>:
      D.23032 = parse_generic_inst (ctx, &ptr, end);
      if (D.23032 == 0) goto <D.23033>; else goto <D.23034>;
      <D.23033>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23035>; else goto <D.23036>;
      <D.23035>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23037 = monoeg_strdup ("Type: Could not parse generic inst");
        vinfo->info.message = D.23037;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23038 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23038;
      }
      <D.23036>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23034>:
      goto <D.18817>;
      <D.18832>:
      D.23039 = parse_method_signature (ctx, &ptr, end, 1, 1);
      if (D.23039 == 0) goto <D.23040>; else goto <D.23041>;
      <D.23040>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23042>; else goto <D.23043>;
      <D.23042>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23044 = monoeg_strdup ("Type: Could not parse method pointer signature");
        vinfo->info.message = D.23044;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23045 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23045;
      }
      <D.23043>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23041>:
      goto <D.18817>;
      <D.18834>:
      D.23046 = parse_custom_mods (ctx, &ptr, end);
      if (D.23046 == 0) goto <D.23047>; else goto <D.23048>;
      <D.23047>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23049>; else goto <D.23050>;
      <D.23049>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23051 = monoeg_strdup ("Type: Failed to parse array element custom attr");
        vinfo->info.message = D.23051;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23052 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23052;
      }
      <D.23050>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23048>:
      D.23053 = parse_type (ctx, &ptr, end);
      if (D.23053 == 0) goto <D.23054>; else goto <D.23055>;
      <D.23054>:
      D.22923 = ctx->report_error;
      if (D.22923 != 0) goto <D.23056>; else goto <D.23057>;
      <D.23056>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23058 = monoeg_strdup ("Type: Could not parse array type");
        vinfo->info.message = D.23058;
        vinfo->exception_type = 3;
        D.22927 = ctx->errors;
        D.23059 = monoeg_g_slist_prepend (D.22927, vinfo);
        ctx->errors = D.23059;
      }
      <D.23057>:
      ctx->valid = 0;
      D.22929 = 0;
      return D.22929;
      <D.23055>:
      goto <D.18817>;
      <D.23060>:
      <D.18817>:
      ptr.65 = ptr;
      *_ptr = ptr.65;
      D.22929 = 1;
      return D.22929;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
      token = {CLOBBER};
    }
}


get_coded_index_table (int kind, guint32 coded_token)
{
  unsigned char D.23063;
  int bits.68;
  int D.23065;
  int D.23066;
  unsigned int D.23067;
  guint32 D.23068;
  unsigned int kind.69;
  unsigned int D.23070;
  unsigned char D.23071;
  guint32 idx;
  guint32 bits;

  D.23063 = coded_index_desc[kind];
  bits = (guint32) D.23063;
  kind = kind + 2;
  bits.68 = (int) bits;
  D.23065 = 1 << bits.68;
  D.23066 = D.23065 + -1;
  D.23067 = (unsigned int) D.23066;
  idx = D.23067 & coded_token;
  kind.69 = (unsigned int) kind;
  D.23070 = kind.69 + idx;
  D.23071 = coded_index_desc[D.23070];
  D.23068 = (guint32) D.23071;
  return D.23068;
}


parse_array_shape (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.70;
  int D.23074;
  int D.23077;
  gchar * D.23080;
  struct GSList * D.23081;
  struct GSList * D.23082;
  gboolean D.23083;
  unsigned int val.71;
  gchar * D.23089;
  struct GSList * D.23090;
  int D.23091;
  gchar * D.23096;
  struct GSList * D.23097;
  int D.23098;
  unsigned int D.23103;
  gchar * D.23104;
  struct GSList * D.23105;
  unsigned int size.72;
  int D.23107;
  gchar * D.23112;
  struct GSList * D.23113;
  int D.23114;
  gchar * D.23119;
  struct GSList * D.23120;
  const char * ptr.73;
  const char * ptr;
  unsigned int val;
  unsigned int size;
  unsigned int num;
  unsigned int i;

  try
    {
      ptr.70 = *_ptr;
      ptr = ptr.70;
      val = 0;
      D.23074 = safe_read (&ptr, end, &val, 1);
      if (D.23074 == 0) goto <D.23075>; else goto <D.23076>;
      <D.23075>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23078>; else goto <D.23079>;
      <D.23078>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23080 = monoeg_strdup ("ArrayShape: Not enough room for Rank");
        vinfo->info.message = D.23080;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23082 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23082;
      }
      <D.23079>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23076>:
      val.71 = val;
      if (val.71 == 0) goto <D.23085>; else goto <D.23086>;
      <D.23085>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23089 = monoeg_strdup ("ArrayShape: Invalid shape with zero Rank");
        vinfo->info.message = D.23089;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23090 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23090;
      }
      <D.23088>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23086>:
      D.23091 = safe_read_compressed_int (&ptr, end, &size);
      if (D.23091 == 0) goto <D.23092>; else goto <D.23093>;
      <D.23092>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23094>; else goto <D.23095>;
      <D.23094>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23096 = monoeg_strdup ("ArrayShape: Not enough room for NumSizes");
        vinfo->info.message = D.23096;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23097 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23097;
      }
      <D.23095>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23093>:
      i = 0;
      goto <D.18774>;
      <D.18773>:
      D.23098 = safe_read_compressed_int (&ptr, end, &num);
      if (D.23098 == 0) goto <D.23099>; else goto <D.23100>;
      <D.23099>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23101>; else goto <D.23102>;
      <D.23101>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23103 = i + 1;
        D.23104 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for Size of rank %d", D.23103);
        vinfo->info.message = D.23104;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23105 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23105;
      }
      <D.23102>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23100>:
      i = i + 1;
      <D.18774>:
      size.72 = size;
      if (i < size.72) goto <D.18773>; else goto <D.18775>;
      <D.18775>:
      D.23107 = safe_read_compressed_int (&ptr, end, &size);
      if (D.23107 == 0) goto <D.23108>; else goto <D.23109>;
      <D.23108>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23110>; else goto <D.23111>;
      <D.23110>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23112 = monoeg_strdup ("ArrayShape: Not enough room for NumLoBounds");
        vinfo->info.message = D.23112;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23113 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23113;
      }
      <D.23111>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23109>:
      i = 0;
      goto <D.18779>;
      <D.18778>:
      D.23114 = safe_read_compressed_int (&ptr, end, &num);
      if (D.23114 == 0) goto <D.23115>; else goto <D.23116>;
      <D.23115>:
      D.23077 = ctx->report_error;
      if (D.23077 != 0) goto <D.23117>; else goto <D.23118>;
      <D.23117>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23103 = i + 1;
        D.23119 = monoeg_g_strdup_printf ("ArrayShape: Not enough room for LoBound of rank %d", D.23103);
        vinfo->info.message = D.23119;
        vinfo->exception_type = 3;
        D.23081 = ctx->errors;
        D.23120 = monoeg_g_slist_prepend (D.23081, vinfo);
        ctx->errors = D.23120;
      }
      <D.23118>:
      ctx->valid = 0;
      D.23083 = 0;
      return D.23083;
      <D.23116>:
      i = i + 1;
      <D.18779>:
      size.72 = size;
      if (i < size.72) goto <D.18778>; else goto <D.18780>;
      <D.18780>:
      ptr.73 = ptr;
      *_ptr = ptr.73;
      D.23083 = 1;
      return D.23083;
    }
  finally
    {
      ptr = {CLOBBER};
      val = {CLOBBER};
      size = {CLOBBER};
      num = {CLOBBER};
    }
}


parse_generic_inst (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.74;
  int D.23125;
  int D.23128;
  gchar * D.23131;
  struct GSList * D.23132;
  struct GSList * D.23133;
  gboolean D.23134;
  unsigned int type.75;
  unsigned int D.23136;
  gchar * D.23141;
  struct GSList * D.23142;
  int D.23143;
  gchar * D.23148;
  struct GSList * D.23149;
  unsigned int token.76;
  int D.23153;
  unsigned int D.23155;
  gchar * D.23158;
  struct GSList * D.23159;
  unsigned int D.23160;
  unsigned int D.23163;
  unsigned int D.23164;
  unsigned int D.23167;
  unsigned int D.23168;
  gchar * D.23173;
  struct GSList * D.23174;
  int D.23175;
  gchar * D.23180;
  struct GSList * D.23181;
  unsigned int count.77;
  gchar * D.23187;
  struct GSList * D.23188;
  int D.23189;
  gchar * D.23194;
  struct GSList * D.23195;
  int D.23196;
  unsigned int D.23201;
  gchar * D.23202;
  struct GSList * D.23203;
  const char * ptr.78;
  const char * ptr;
  unsigned int type;
  unsigned int count;
  unsigned int token;
  unsigned int i;

  try
    {
      ptr.74 = *_ptr;
      ptr = ptr.74;
      D.23125 = safe_read (&ptr, end, &type, 1);
      if (D.23125 == 0) goto <D.23126>; else goto <D.23127>;
      <D.23126>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23129>; else goto <D.23130>;
      <D.23129>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23131 = monoeg_strdup ("GenericInst: Not enough room for kind");
        vinfo->info.message = D.23131;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23133 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23133;
      }
      <D.23130>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23127>:
      type.75 = type;
      D.23136 = type.75 + 4294967279;
      if (D.23136 > 1) goto <D.23137>; else goto <D.23138>;
      <D.23137>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23139>; else goto <D.23140>;
      <D.23139>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.75 = type;
        D.23141 = monoeg_g_strdup_printf ("GenericInst: Invalid GenericInst kind %x\n", type.75);
        vinfo->info.message = D.23141;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23142 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23142;
      }
      <D.23140>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23138>:
      D.23143 = safe_read_compressed_int (&ptr, end, &token);
      if (D.23143 == 0) goto <D.23144>; else goto <D.23145>;
      <D.23144>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23146>; else goto <D.23147>;
      <D.23146>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23148 = monoeg_strdup ("GenericInst: Not enough room for type token");
        vinfo->info.message = D.23148;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23149 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23149;
      }
      <D.23147>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23145>:
      token.76 = token;
      D.23153 = is_valid_coded_index (ctx, 0, token.76);
      if (D.23153 == 0) goto <D.23150>; else goto <D.23154>;
      <D.23154>:
      token.76 = token;
      D.23155 = get_coded_index_token (0, token.76);
      if (D.23155 == 0) goto <D.23150>; else goto <D.23151>;
      <D.23150>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23156>; else goto <D.23157>;
      <D.23156>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        token.76 = token;
        D.23158 = monoeg_g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token.76);
        vinfo->info.message = D.23158;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23159 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23159;
      }
      <D.23157>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23151>:
      D.23160 = ctx->token;
      if (D.23160 != 0) goto <D.23161>; else goto <D.23162>;
      <D.23161>:
      D.23160 = ctx->token;
      D.23163 = D.23160 & 16777215;
      token.76 = token;
      D.23164 = get_coded_index_token (0, token.76);
      if (D.23163 == D.23164) goto <D.23165>; else goto <D.23166>;
      <D.23165>:
      D.23160 = ctx->token;
      D.23167 = D.23160 >> 24;
      token.76 = token;
      D.23168 = get_coded_index_table (0, token.76);
      if (D.23167 == D.23168) goto <D.23169>; else goto <D.23170>;
      <D.23169>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23171>; else goto <D.23172>;
      <D.23171>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23160 = ctx->token;
        D.23173 = monoeg_g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can\'t reference itself", D.23160);
        vinfo->info.message = D.23173;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23174 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23174;
      }
      <D.23172>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23170>:
      <D.23166>:
      <D.23162>:
      D.23175 = safe_read_compressed_int (&ptr, end, &count);
      if (D.23175 == 0) goto <D.23176>; else goto <D.23177>;
      <D.23176>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23178>; else goto <D.23179>;
      <D.23178>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23180 = monoeg_strdup ("GenericInst: Not enough room for argument count");
        vinfo->info.message = D.23180;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23181 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23181;
      }
      <D.23179>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23177>:
      count.77 = count;
      if (count.77 == 0) goto <D.23183>; else goto <D.23184>;
      <D.23183>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23185>; else goto <D.23186>;
      <D.23185>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23187 = monoeg_strdup ("GenericInst: Zero arguments generic instance");
        vinfo->info.message = D.23187;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23188 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23188;
      }
      <D.23186>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23184>:
      i = 0;
      goto <D.18801>;
      <D.18800>:
      D.23189 = parse_custom_mods (ctx, &ptr, end);
      if (D.23189 == 0) goto <D.23190>; else goto <D.23191>;
      <D.23190>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23192>; else goto <D.23193>;
      <D.23192>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23194 = monoeg_strdup ("Type: Failed to parse pointer custom attr");
        vinfo->info.message = D.23194;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23195 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23195;
      }
      <D.23193>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23191>:
      D.23196 = parse_type (ctx, &ptr, end);
      if (D.23196 == 0) goto <D.23197>; else goto <D.23198>;
      <D.23197>:
      D.23128 = ctx->report_error;
      if (D.23128 != 0) goto <D.23199>; else goto <D.23200>;
      <D.23199>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23201 = i + 1;
        D.23202 = monoeg_g_strdup_printf ("GenericInst: invalid generic argument %d", D.23201);
        vinfo->info.message = D.23202;
        vinfo->exception_type = 3;
        D.23132 = ctx->errors;
        D.23203 = monoeg_g_slist_prepend (D.23132, vinfo);
        ctx->errors = D.23203;
      }
      <D.23200>:
      ctx->valid = 0;
      D.23134 = 0;
      return D.23134;
      <D.23198>:
      i = i + 1;
      <D.18801>:
      count.77 = count;
      if (i < count.77) goto <D.18800>; else goto <D.18802>;
      <D.18802>:
      ptr.78 = ptr;
      *_ptr = ptr.78;
      D.23134 = 1;
      return D.23134;
    }
  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.79;
  int D.23208;
  int D.23211;
  gchar * D.23214;
  struct GSList * D.23215;
  struct GSList * D.23216;
  gboolean D.23217;
  unsigned int cconv.80;
  unsigned int D.23219;
  gchar * D.23224;
  struct GSList * D.23225;
  unsigned int D.23228;
  gchar * D.23233;
  struct GSList * D.23234;
  gchar * D.23242;
  struct GSList * D.23243;
  unsigned int D.23244;
  int D.23247;
  gchar * D.23252;
  struct GSList * D.23253;
  unsigned int gparam_count.81;
  gchar * D.23261;
  struct GSList * D.23262;
  gchar * D.23269;
  struct GSList * D.23270;
  int D.23271;
  gchar * D.23276;
  struct GSList * D.23277;
  int D.23278;
  gchar * D.23283;
  struct GSList * D.23284;
  int D.23287;
  gchar * D.23292;
  struct GSList * D.23293;
  unsigned int type.82;
  gchar * D.23301;
  struct GSList * D.23302;
  gchar * D.23307;
  struct GSList * D.23308;
  const char * ptr.83;
  const char * ptr.84;
  int D.23312;
  gchar * D.23317;
  struct GSList * D.23318;
  unsigned int param_count.85;
  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.79 = *_ptr;
      ptr = ptr.79;
      saw_sentinel = 0;
      D.23208 = safe_read (&ptr, end, &cconv, 1);
      if (D.23208 == 0) goto <D.23209>; else goto <D.23210>;
      <D.23209>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23212>; else goto <D.23213>;
      <D.23212>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23214 = monoeg_strdup ("MethodSig: Not enough room for the call conv");
        vinfo->info.message = D.23214;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23216 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23216;
      }
      <D.23213>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23210>:
      cconv.80 = cconv;
      D.23219 = cconv.80 & 128;
      if (D.23219 != 0) goto <D.23220>; else goto <D.23221>;
      <D.23220>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23222>; else goto <D.23223>;
      <D.23222>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23224 = monoeg_strdup ("MethodSig: CallConv has 0x80 set");
        vinfo->info.message = D.23224;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23225 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23225;
      }
      <D.23223>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23221>:
      if (allow_unmanaged != 0) goto <D.23226>; else goto <D.23227>;
      <D.23226>:
      cconv.80 = cconv;
      D.23228 = cconv.80 & 15;
      if (D.23228 > 5) goto <D.23229>; else goto <D.23230>;
      <D.23229>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23231>; else goto <D.23232>;
      <D.23231>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        cconv.80 = cconv;
        D.23228 = cconv.80 & 15;
        D.23233 = monoeg_g_strdup_printf ("MethodSig: CallConv is not valid, it\'s %x", D.23228);
        vinfo->info.message = D.23233;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23234 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23234;
      }
      <D.23232>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23230>:
      goto <D.23235>;
      <D.23227>:
      cconv.80 = cconv;
      D.23228 = cconv.80 & 15;
      if (D.23228 != 0) goto <D.23236>; else goto <D.23237>;
      <D.23236>:
      cconv.80 = cconv;
      D.23228 = cconv.80 & 15;
      if (D.23228 != 5) goto <D.23238>; else goto <D.23239>;
      <D.23238>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23240>; else goto <D.23241>;
      <D.23240>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        cconv.80 = cconv;
        D.23228 = cconv.80 & 15;
        D.23242 = monoeg_g_strdup_printf ("MethodSig: CallConv is not Default or Vararg, it\'s %x", D.23228);
        vinfo->info.message = D.23242;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23243 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23243;
      }
      <D.23241>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23239>:
      <D.23237>:
      <D.23235>:
      cconv.80 = cconv;
      D.23244 = cconv.80 & 16;
      if (D.23244 != 0) goto <D.23245>; else goto <D.23246>;
      <D.23245>:
      D.23247 = safe_read_compressed_int (&ptr, end, &gparam_count);
      if (D.23247 == 0) goto <D.23248>; else goto <D.23249>;
      <D.23248>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23250>; else goto <D.23251>;
      <D.23250>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23252 = monoeg_strdup ("MethodSig: Not enough room for the generic param count");
        vinfo->info.message = D.23252;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23253 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23253;
      }
      <D.23251>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23249>:
      <D.23246>:
      cconv.80 = cconv;
      D.23244 = cconv.80 & 16;
      if (D.23244 != 0) goto <D.23254>; else goto <D.23255>;
      <D.23254>:
      gparam_count.81 = gparam_count;
      if (gparam_count.81 == 0) goto <D.23257>; else goto <D.23258>;
      <D.23257>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23259>; else goto <D.23260>;
      <D.23259>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23261 = monoeg_strdup ("MethodSig: Signature with generics but zero arity");
        vinfo->info.message = D.23261;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23262 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23262;
      }
      <D.23260>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23258>:
      <D.23255>:
      if (allow_unmanaged != 0) goto <D.23263>; else goto <D.23264>;
      <D.23263>:
      cconv.80 = cconv;
      D.23244 = cconv.80 & 16;
      if (D.23244 != 0) goto <D.23265>; else goto <D.23266>;
      <D.23265>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23267>; else goto <D.23268>;
      <D.23267>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23269 = monoeg_strdup ("MethodSig: Standalone signature with generic params");
        vinfo->info.message = D.23269;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23270 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23270;
      }
      <D.23268>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23266>:
      <D.23264>:
      D.23271 = safe_read_compressed_int (&ptr, end, &param_count);
      if (D.23271 == 0) goto <D.23272>; else goto <D.23273>;
      <D.23272>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23274>; else goto <D.23275>;
      <D.23274>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23276 = monoeg_strdup ("MethodSig: Not enough room for the param count");
        vinfo->info.message = D.23276;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23277 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23277;
      }
      <D.23275>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23273>:
      D.23278 = parse_return_type (ctx, &ptr, end);
      if (D.23278 == 0) goto <D.23279>; else goto <D.23280>;
      <D.23279>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23281>; else goto <D.23282>;
      <D.23281>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23283 = monoeg_strdup ("MethodSig: Error parsing return type");
        vinfo->info.message = D.23283;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23284 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23284;
      }
      <D.23282>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23280>:
      i = 0;
      goto <D.18881>;
      <D.18880>:
      if (allow_sentinel != 0) goto <D.23285>; else goto <D.23286>;
      <D.23285>:
      D.23287 = safe_read (&ptr, end, &type, 1);
      if (D.23287 == 0) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23290>; else goto <D.23291>;
      <D.23290>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23292 = monoeg_g_strdup_printf ("MethodSig: Not enough room for param %d type", i);
        vinfo->info.message = D.23292;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23293 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23293;
      }
      <D.23291>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23289>:
      type.82 = type;
      if (type.82 == 65) goto <D.23295>; else goto <D.23296>;
      <D.23295>:
      cconv.80 = cconv;
      D.23228 = cconv.80 & 15;
      if (D.23228 != 5) goto <D.23297>; else goto <D.23298>;
      <D.23297>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23299>; else goto <D.23300>;
      <D.23299>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23301 = monoeg_strdup ("MethodSig: Found sentinel but signature is not vararg");
        vinfo->info.message = D.23301;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23302 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23302;
      }
      <D.23300>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23298>:
      if (saw_sentinel != 0) goto <D.23303>; else goto <D.23304>;
      <D.23303>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23305>; else goto <D.23306>;
      <D.23305>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23307 = monoeg_strdup ("MethodSig: More than one sentinel type");
        vinfo->info.message = D.23307;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23308 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23308;
      }
      <D.23306>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23304>:
      saw_sentinel = 1;
      goto <D.23309>;
      <D.23296>:
      ptr.83 = ptr;
      ptr.84 = ptr.83 + 18446744073709551615;
      ptr = ptr.84;
      <D.23309>:
      <D.23286>:
      D.23312 = parse_param (ctx, &ptr, end);
      if (D.23312 == 0) goto <D.23313>; else goto <D.23314>;
      <D.23313>:
      D.23211 = ctx->report_error;
      if (D.23211 != 0) goto <D.23315>; else goto <D.23316>;
      <D.23315>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23317 = monoeg_g_strdup_printf ("MethodSig: Error parsing arg %d", i);
        vinfo->info.message = D.23317;
        vinfo->exception_type = 3;
        D.23215 = ctx->errors;
        D.23318 = monoeg_g_slist_prepend (D.23215, vinfo);
        ctx->errors = D.23318;
      }
      <D.23316>:
      ctx->valid = 0;
      D.23217 = 0;
      return D.23217;
      <D.23314>:
      i = i + 1;
      <D.18881>:
      param_count.85 = param_count;
      if (i < param_count.85) goto <D.18880>; else goto <D.18882>;
      <D.18882>:
      ptr.83 = ptr;
      *_ptr = ptr.83;
      D.23217 = 1;
      return D.23217;
    }
  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.23322;
  gboolean D.23325;
  const char * ptr.86;
  int D.23327;
  int D.23330;
  gchar * D.23333;
  struct GSList * D.23334;
  struct GSList * D.23335;
  unsigned int type.87;
  const char * ptr.88;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.23322 = parse_custom_mods (ctx, _ptr, end);
      if (D.23322 == 0) goto <D.23323>; else goto <D.23324>;
      <D.23323>:
      D.23325 = 0;
      return D.23325;
      <D.23324>:
      ptr.86 = *_ptr;
      ptr = ptr.86;
      D.23327 = safe_read (&ptr, end, &type, 1);
      if (D.23327 == 0) goto <D.23328>; else goto <D.23329>;
      <D.23328>:
      D.23330 = ctx->report_error;
      if (D.23330 != 0) goto <D.23331>; else goto <D.23332>;
      <D.23331>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23333 = monoeg_strdup ("ReturnType: Not enough room for the type");
        vinfo->info.message = D.23333;
        vinfo->exception_type = 3;
        D.23334 = ctx->errors;
        D.23335 = monoeg_g_slist_prepend (D.23334, vinfo);
        ctx->errors = D.23335;
      }
      <D.23332>:
      ctx->valid = 0;
      D.23325 = 0;
      return D.23325;
      <D.23329>:
      type.87 = type;
      if (type.87 == 1) goto <D.23336>; else goto <D.23339>;
      <D.23339>:
      type.87 = type;
      if (type.87 == 22) goto <D.23336>; else goto <D.23337>;
      <D.23336>:
      ptr.88 = ptr;
      *_ptr = ptr.88;
      D.23325 = 1;
      return D.23325;
      <D.23337>:
      type.87 = type;
      if (type.87 == 16) goto <D.23341>; else goto <D.23342>;
      <D.23341>:
      ptr.88 = ptr;
      *_ptr = ptr.88;
      <D.23342>:
      D.23325 = parse_type (ctx, _ptr, end);
      return D.23325;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


parse_param (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  int D.23345;
  gboolean D.23348;
  const char * ptr.89;
  int D.23350;
  int D.23353;
  gchar * D.23356;
  struct GSList * D.23357;
  struct GSList * D.23358;
  unsigned int type.90;
  const char * ptr.91;
  int D.23365;
  const char * ptr;
  unsigned int type;

  try
    {
      type = 0;
      D.23345 = parse_custom_mods (ctx, _ptr, end);
      if (D.23345 == 0) goto <D.23346>; else goto <D.23347>;
      <D.23346>:
      D.23348 = 0;
      return D.23348;
      <D.23347>:
      ptr.89 = *_ptr;
      ptr = ptr.89;
      D.23350 = safe_read (&ptr, end, &type, 1);
      if (D.23350 == 0) goto <D.23351>; else goto <D.23352>;
      <D.23351>:
      D.23353 = ctx->report_error;
      if (D.23353 != 0) goto <D.23354>; else goto <D.23355>;
      <D.23354>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23356 = monoeg_strdup ("Param: Not enough room for the type");
        vinfo->info.message = D.23356;
        vinfo->exception_type = 3;
        D.23357 = ctx->errors;
        D.23358 = monoeg_g_slist_prepend (D.23357, vinfo);
        ctx->errors = D.23358;
      }
      <D.23355>:
      ctx->valid = 0;
      D.23348 = 0;
      return D.23348;
      <D.23352>:
      type.90 = type;
      if (type.90 == 22) goto <D.23360>; else goto <D.23361>;
      <D.23360>:
      ptr.91 = ptr;
      *_ptr = ptr.91;
      D.23348 = 1;
      return D.23348;
      <D.23361>:
      type.90 = type;
      if (type.90 == 16) goto <D.23363>; else goto <D.23364>;
      <D.23363>:
      ptr.91 = ptr;
      *_ptr = ptr.91;
      D.23365 = parse_custom_mods (ctx, _ptr, end);
      if (D.23365 == 0) goto <D.23366>; else goto <D.23367>;
      <D.23366>:
      D.23348 = 0;
      return D.23348;
      <D.23367>:
      <D.23364>:
      D.23348 = parse_type (ctx, _ptr, end);
      return D.23348;
    }
  finally
    {
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_methodimpl_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23370;
  unsigned int D.23373;
  <unnamed-unsigned:24> D.23375;
  int D.23376;
  int D.23377;
  unsigned int D.23378;
  int D.23379;
  unsigned int D.23382;
  gchar * D.23383;
  struct GSList * D.23384;
  struct GSList * D.23385;
  unsigned int D.23386;
  unsigned int D.23387;
  gchar * D.23392;
  struct GSList * D.23393;
  int D.23394;
  gchar * D.23399;
  struct GSList * D.23400;
  unsigned int D.23401;
  gchar * D.23406;
  struct GSList * D.23407;
  int D.23408;
  gchar * D.23413;
  struct GSList * D.23414;
  <unnamed-unsigned:24> D.23415;
  int D.23416;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23370 = ctx->image;
      table = &D.23370->tables[25];
      i = 0;
      goto <D.19730>;
      <D.19729>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23373 = data[0];
      if (D.23373 == 0) goto <D.23371>; else goto <D.23374>;
      <D.23374>:
      D.23373 = data[0];
      D.23370 = ctx->image;
      D.23375 = D.23370->tables[2].rows;
      D.23376 = (int) D.23375;
      D.23377 = D.23376 + 1;
      D.23378 = (unsigned int) D.23377;
      if (D.23373 > D.23378) goto <D.23371>; else goto <D.23372>;
      <D.23371>:
      D.23379 = ctx->report_error;
      if (D.23379 != 0) goto <D.23380>; else goto <D.23381>;
      <D.23380>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23382 = data[2];
        D.23383 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d Class field %08x", i, D.23382);
        vinfo->info.message = D.23383;
        vinfo->exception_type = 3;
        D.23384 = ctx->errors;
        D.23385 = monoeg_g_slist_prepend (D.23384, vinfo);
        ctx->errors = D.23385;
      }
      <D.23381>:
      ctx->valid = 0;
      return;
      <D.23372>:
      D.23386 = data[1];
      D.23387 = get_coded_index_token (52, D.23386);
      if (D.23387 == 0) goto <D.23388>; else goto <D.23389>;
      <D.23388>:
      D.23379 = ctx->report_error;
      if (D.23379 != 0) goto <D.23390>; else goto <D.23391>;
      <D.23390>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23386 = data[1];
        D.23392 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.23386);
        vinfo->info.message = D.23392;
        vinfo->exception_type = 3;
        D.23384 = ctx->errors;
        D.23393 = monoeg_g_slist_prepend (D.23384, vinfo);
        ctx->errors = D.23393;
      }
      <D.23391>:
      ctx->valid = 0;
      return;
      <D.23389>:
      D.23386 = data[1];
      D.23394 = is_valid_coded_index (ctx, 52, D.23386);
      if (D.23394 == 0) goto <D.23395>; else goto <D.23396>;
      <D.23395>:
      D.23379 = ctx->report_error;
      if (D.23379 != 0) goto <D.23397>; else goto <D.23398>;
      <D.23397>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23386 = data[1];
        D.23399 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodBody field %08x", i, D.23386);
        vinfo->info.message = D.23399;
        vinfo->exception_type = 3;
        D.23384 = ctx->errors;
        D.23400 = monoeg_g_slist_prepend (D.23384, vinfo);
        ctx->errors = D.23400;
      }
      <D.23398>:
      ctx->valid = 0;
      return;
      <D.23396>:
      D.23382 = data[2];
      D.23401 = get_coded_index_token (52, D.23382);
      if (D.23401 == 0) goto <D.23402>; else goto <D.23403>;
      <D.23402>:
      D.23379 = ctx->report_error;
      if (D.23379 != 0) goto <D.23404>; else goto <D.23405>;
      <D.23404>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23382 = data[2];
        D.23406 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.23382);
        vinfo->info.message = D.23406;
        vinfo->exception_type = 3;
        D.23384 = ctx->errors;
        D.23407 = monoeg_g_slist_prepend (D.23384, vinfo);
        ctx->errors = D.23407;
      }
      <D.23405>:
      ctx->valid = 0;
      return;
      <D.23403>:
      D.23382 = data[2];
      D.23408 = is_valid_coded_index (ctx, 52, D.23382);
      if (D.23408 == 0) goto <D.23409>; else goto <D.23410>;
      <D.23409>:
      D.23379 = ctx->report_error;
      if (D.23379 != 0) goto <D.23411>; else goto <D.23412>;
      <D.23411>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23382 = data[2];
        D.23413 = monoeg_g_strdup_printf ("Invalid MethodImpl row %d MethodDeclaration field %08x", i, D.23382);
        vinfo->info.message = D.23413;
        vinfo->exception_type = 3;
        D.23384 = ctx->errors;
        D.23414 = monoeg_g_slist_prepend (D.23384, vinfo);
        ctx->errors = D.23414;
      }
      <D.23412>:
      ctx->valid = 0;
      return;
      <D.23410>:
      i = i + 1;
      <D.19730>:
      D.23415 = table->rows;
      D.23416 = (int) D.23415;
      if (D.23416 > i) goto <D.19729>; else goto <D.19731>;
      <D.19731>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_moduleref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23420;
  unsigned int D.23421;
  int D.23422;
  int D.23425;
  gchar * D.23428;
  struct GSList * D.23429;
  struct GSList * D.23430;
  <unnamed-unsigned:24> D.23431;
  int D.23432;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.23420 = ctx->image;
      table = &D.23420->tables[26];
      i = 0;
      goto <D.19740>;
      <D.19739>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.23421 = data[0];
      D.23422 = is_valid_non_empty_string (ctx, D.23421);
      if (D.23422 == 0) goto <D.23423>; else goto <D.23424>;
      <D.23423>:
      D.23425 = ctx->report_error;
      if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23421 = data[0];
        D.23428 = monoeg_g_strdup_printf ("Invalid ModuleRef row %d name field %08x", i, D.23421);
        vinfo->info.message = D.23428;
        vinfo->exception_type = 3;
        D.23429 = ctx->errors;
        D.23430 = monoeg_g_slist_prepend (D.23429, vinfo);
        ctx->errors = D.23430;
      }
      <D.23427>:
      ctx->valid = 0;
      return;
      <D.23424>:
      i = i + 1;
      <D.19740>:
      D.23431 = table->rows;
      D.23432 = (int) D.23431;
      if (D.23432 > i) goto <D.19739>; else goto <D.19741>;
      <D.19741>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_typespec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23436;
  unsigned int D.23437;
  int D.23440;
  int D.23443;
  gchar * D.23446;
  struct GSList * D.23447;
  struct GSList * D.23448;
  <unnamed-unsigned:24> D.23449;
  int D.23450;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.23436 = ctx->image;
      table = &D.23436->tables[27];
      i = 0;
      goto <D.19750>;
      <D.19749>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.23437 = data[0];
      if (D.23437 != 0) goto <D.23438>; else goto <D.23439>;
      <D.23438>:
      D.23437 = data[0];
      D.23440 = is_valid_blob_object (ctx, D.23437, 1);
      if (D.23440 == 0) goto <D.23441>; else goto <D.23442>;
      <D.23441>:
      D.23443 = ctx->report_error;
      if (D.23443 != 0) goto <D.23444>; else goto <D.23445>;
      <D.23444>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23437 = data[0];
        D.23446 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.23437);
        vinfo->info.message = D.23446;
        vinfo->exception_type = 3;
        D.23447 = ctx->errors;
        D.23448 = monoeg_g_slist_prepend (D.23447, vinfo);
        ctx->errors = D.23448;
      }
      <D.23445>:
      ctx->valid = 0;
      return;
      <D.23442>:
      <D.23439>:
      i = i + 1;
      <D.19750>:
      D.23449 = table->rows;
      D.23450 = (int) D.23449;
      if (D.23450 > i) goto <D.19749>; else goto <D.19751>;
      <D.19751>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_implmap_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23454;
  unsigned int D.23455;
  unsigned int D.23456;
  int D.23459;
  gchar * D.23462;
  struct GSList * D.23463;
  struct GSList * D.23464;
  gchar * D.23471;
  struct GSList * D.23472;
  unsigned int D.23473;
  int D.23474;
  gchar * D.23479;
  struct GSList * D.23480;
  unsigned int D.23481;
  gchar * D.23486;
  struct GSList * D.23487;
  unsigned int D.23488;
  gchar * D.23493;
  struct GSList * D.23494;
  unsigned int D.23495;
  int D.23496;
  gchar * D.23501;
  struct GSList * D.23502;
  unsigned int D.23505;
  <unnamed-unsigned:24> D.23507;
  unsigned int D.23508;
  gchar * D.23511;
  struct GSList * D.23512;
  <unnamed-unsigned:24> D.23513;
  int D.23514;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 cconv;
  int i;

  try
    {
      D.23454 = ctx->image;
      table = &D.23454->tables[28];
      i = 0;
      goto <D.19777>;
      <D.19776>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.23455 = data[0];
      D.23456 = D.23455 & 4294953096;
      if (D.23456 != 0) goto <D.23457>; else goto <D.23458>;
      <D.23457>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23460>; else goto <D.23461>;
      <D.23460>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23455 = data[0];
        D.23462 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Flags field %08x", i, D.23455);
        vinfo->info.message = D.23462;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23464 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23464;
      }
      <D.23461>:
      ctx->valid = 0;
      return;
      <D.23458>:
      D.23455 = data[0];
      cconv = D.23455 & 1792;
      if (cconv == 0) goto <D.23465>; else goto <D.23467>;
      <D.23467>:
      if (cconv == 1536) goto <D.23465>; else goto <D.23468>;
      <D.23468>:
      if (cconv == 1792) goto <D.23465>; else goto <D.23466>;
      <D.23465>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23469>; else goto <D.23470>;
      <D.23469>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23471 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid call conv field %x", i, cconv);
        vinfo->info.message = D.23471;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23472 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23472;
      }
      <D.23470>:
      ctx->valid = 0;
      return;
      <D.23466>:
      D.23473 = data[1];
      D.23474 = is_valid_coded_index (ctx, 56, D.23473);
      if (D.23474 == 0) goto <D.23475>; else goto <D.23476>;
      <D.23475>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23477>; else goto <D.23478>;
      <D.23477>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23473 = data[1];
        D.23479 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid MemberForward token %x", i, D.23473);
        vinfo->info.message = D.23479;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23480 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23480;
      }
      <D.23478>:
      ctx->valid = 0;
      return;
      <D.23476>:
      D.23473 = data[1];
      D.23481 = get_coded_index_table (56, D.23473);
      if (D.23481 != 6) goto <D.23482>; else goto <D.23483>;
      <D.23482>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23484>; else goto <D.23485>;
      <D.23484>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23473 = data[1];
        D.23486 = monoeg_g_strdup_printf ("Invalid ImplMap row %d only methods are supported token %x", i, D.23473);
        vinfo->info.message = D.23486;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23487 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23487;
      }
      <D.23485>:
      ctx->valid = 0;
      return;
      <D.23483>:
      D.23473 = data[1];
      D.23488 = get_coded_index_token (56, D.23473);
      if (D.23488 == 0) goto <D.23489>; else goto <D.23490>;
      <D.23489>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23491>; else goto <D.23492>;
      <D.23491>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23493 = monoeg_g_strdup_printf ("Invalid ImplMap row %d null token", i);
        vinfo->info.message = D.23493;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23494 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23494;
      }
      <D.23492>:
      ctx->valid = 0;
      return;
      <D.23490>:
      D.23495 = data[2];
      D.23496 = is_valid_non_empty_string (ctx, D.23495);
      if (D.23496 == 0) goto <D.23497>; else goto <D.23498>;
      <D.23497>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23499>; else goto <D.23500>;
      <D.23499>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23495 = data[2];
        D.23501 = monoeg_g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, D.23495);
        vinfo->info.message = D.23501;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23502 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23502;
      }
      <D.23500>:
      ctx->valid = 0;
      return;
      <D.23498>:
      D.23505 = data[3];
      if (D.23505 == 0) goto <D.23503>; else goto <D.23506>;
      <D.23506>:
      D.23505 = data[3];
      D.23454 = ctx->image;
      D.23507 = D.23454->tables[26].rows;
      D.23508 = (unsigned int) D.23507;
      if (D.23505 > D.23508) goto <D.23503>; else goto <D.23504>;
      <D.23503>:
      D.23459 = ctx->report_error;
      if (D.23459 != 0) goto <D.23509>; else goto <D.23510>;
      <D.23509>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23505 = data[3];
        D.23511 = monoeg_g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, D.23505);
        vinfo->info.message = D.23511;
        vinfo->exception_type = 3;
        D.23463 = ctx->errors;
        D.23512 = monoeg_g_slist_prepend (D.23463, vinfo);
        ctx->errors = D.23512;
      }
      <D.23510>:
      ctx->valid = 0;
      return;
      <D.23504>:
      i = i + 1;
      <D.19777>:
      D.23513 = table->rows;
      D.23514 = (int) D.23513;
      if (D.23514 > i) goto <D.19776>; else goto <D.19778>;
      <D.19778>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_fieldrva_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23518;
  unsigned int D.23521;
  unsigned int D.23523;
  int D.23524;
  gchar * D.23527;
  struct GSList * D.23528;
  struct GSList * D.23529;
  unsigned int D.23532;
  <unnamed-unsigned:24> D.23534;
  int D.23535;
  int D.23536;
  unsigned int D.23537;
  gchar * D.23540;
  struct GSList * D.23541;
  <unnamed-unsigned:24> D.23542;
  int D.23543;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23518 = ctx->image;
      table = &D.23518->tables[29];
      i = 0;
      goto <D.19788>;
      <D.19787>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23521 = data[0];
      if (D.23521 == 0) goto <D.23519>; else goto <D.23522>;
      <D.23522>:
      D.23518 = ctx->image;
      D.23521 = data[0];
      D.23523 = mono_cli_rva_image_map (D.23518, D.23521);
      if (D.23523 == 4294967295) goto <D.23519>; else goto <D.23520>;
      <D.23519>:
      D.23524 = ctx->report_error;
      if (D.23524 != 0) goto <D.23525>; else goto <D.23526>;
      <D.23525>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23521 = data[0];
        D.23527 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d RVA %08x", i, D.23521);
        vinfo->info.message = D.23527;
        vinfo->exception_type = 3;
        D.23528 = ctx->errors;
        D.23529 = monoeg_g_slist_prepend (D.23528, vinfo);
        ctx->errors = D.23529;
      }
      <D.23526>:
      ctx->valid = 0;
      return;
      <D.23520>:
      D.23532 = data[1];
      if (D.23532 == 0) goto <D.23530>; else goto <D.23533>;
      <D.23533>:
      D.23532 = data[1];
      D.23518 = ctx->image;
      D.23534 = D.23518->tables[4].rows;
      D.23535 = (int) D.23534;
      D.23536 = D.23535 + 1;
      D.23537 = (unsigned int) D.23536;
      if (D.23532 > D.23537) goto <D.23530>; else goto <D.23531>;
      <D.23530>:
      D.23524 = ctx->report_error;
      if (D.23524 != 0) goto <D.23538>; else goto <D.23539>;
      <D.23538>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23532 = data[1];
        D.23540 = monoeg_g_strdup_printf ("Invalid FieldRVA row %d Field %08x", i, D.23532);
        vinfo->info.message = D.23540;
        vinfo->exception_type = 3;
        D.23528 = ctx->errors;
        D.23541 = monoeg_g_slist_prepend (D.23528, vinfo);
        ctx->errors = D.23541;
      }
      <D.23539>:
      ctx->valid = 0;
      return;
      <D.23531>:
      i = i + 1;
      <D.19788>:
      D.23542 = table->rows;
      D.23543 = (int) D.23542;
      if (D.23543 > i) goto <D.19787>; else goto <D.19789>;
      <D.19789>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assembly_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23547;
  <unnamed-unsigned:24> D.23548;
  int D.23549;
  int D.23552;
  gchar * D.23555;
  struct GSList * D.23556;
  struct GSList * D.23557;
  gchar * D.23566;
  struct GSList * D.23567;
  unsigned int D.23568;
  unsigned int D.23569;
  gchar * D.23574;
  struct GSList * D.23575;
  unsigned int D.23576;
  int D.23579;
  gchar * D.23584;
  struct GSList * D.23585;
  unsigned int D.23586;
  int D.23587;
  gchar * D.23592;
  struct GSList * D.23593;
  unsigned int D.23594;
  int D.23597;
  gchar * D.23602;
  struct GSList * D.23603;
  struct MonoTableInfo * table;
  guint32 data[9];
  guint32 hash;
  int i;

  try
    {
      D.23547 = ctx->image;
      table = &D.23547->tables[32];
      D.23548 = table->rows;
      D.23549 = (int) D.23548;
      if (D.23549 > 1) goto <D.23550>; else goto <D.23551>;
      <D.23550>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23553>; else goto <D.23554>;
      <D.23553>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23548 = table->rows;
        D.23549 = (int) D.23548;
        D.23555 = monoeg_g_strdup_printf ("Assembly table can have zero or one rows, but now %d", D.23549);
        vinfo->info.message = D.23555;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23557 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23557;
      }
      <D.23554>:
      ctx->valid = 0;
      return;
      <D.23551>:
      i = 0;
      goto <D.19804>;
      <D.19803>:
      mono_metadata_decode_row (table, i, &data, 9);
      hash = data[0];
      if (hash != 0) goto <D.23558>; else goto <D.23559>;
      <D.23558>:
      if (hash != 32771) goto <D.23560>; else goto <D.23561>;
      <D.23560>:
      if (hash != 32772) goto <D.23562>; else goto <D.23563>;
      <D.23562>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23564>; else goto <D.23565>;
      <D.23564>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23566 = monoeg_g_strdup_printf ("Assembly table row %d has invalid HashAlgId %x", i, hash);
        vinfo->info.message = D.23566;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23567 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23567;
      }
      <D.23565>:
      ctx->valid = 0;
      return;
      <D.23563>:
      <D.23561>:
      <D.23559>:
      D.23568 = data[5];
      D.23569 = D.23568 & 4294917646;
      if (D.23569 != 0) goto <D.23570>; else goto <D.23571>;
      <D.23570>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23572>; else goto <D.23573>;
      <D.23572>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23568 = data[5];
        D.23574 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, D.23568);
        vinfo->info.message = D.23574;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23575 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23575;
      }
      <D.23573>:
      ctx->valid = 0;
      return;
      <D.23571>:
      D.23576 = data[6];
      if (D.23576 != 0) goto <D.23577>; else goto <D.23578>;
      <D.23577>:
      D.23576 = data[6];
      D.23579 = is_valid_blob_object (ctx, D.23576, 1);
      if (D.23579 == 0) goto <D.23580>; else goto <D.23581>;
      <D.23580>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23582>; else goto <D.23583>;
      <D.23582>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23568 = data[5];
        D.23584 = monoeg_g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, D.23568);
        vinfo->info.message = D.23584;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23585 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23585;
      }
      <D.23583>:
      ctx->valid = 0;
      return;
      <D.23581>:
      <D.23578>:
      D.23586 = data[7];
      D.23587 = is_valid_non_empty_string (ctx, D.23586);
      if (D.23587 == 0) goto <D.23588>; else goto <D.23589>;
      <D.23588>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23590>; else goto <D.23591>;
      <D.23590>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23586 = data[7];
        D.23592 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Name %08x", i, D.23586);
        vinfo->info.message = D.23592;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23593 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23593;
      }
      <D.23591>:
      ctx->valid = 0;
      return;
      <D.23589>:
      D.23594 = data[8];
      if (D.23594 != 0) goto <D.23595>; else goto <D.23596>;
      <D.23595>:
      D.23594 = data[8];
      D.23597 = is_valid_string (ctx, D.23594);
      if (D.23597 == 0) goto <D.23598>; else goto <D.23599>;
      <D.23598>:
      D.23552 = ctx->report_error;
      if (D.23552 != 0) goto <D.23600>; else goto <D.23601>;
      <D.23600>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23594 = data[8];
        D.23602 = monoeg_g_strdup_printf ("Assembly table row %d has invalid Culture %08x", i, D.23594);
        vinfo->info.message = D.23602;
        vinfo->exception_type = 3;
        D.23556 = ctx->errors;
        D.23603 = monoeg_g_slist_prepend (D.23556, vinfo);
        ctx->errors = D.23603;
      }
      <D.23601>:
      ctx->valid = 0;
      return;
      <D.23599>:
      <D.23596>:
      i = i + 1;
      <D.19804>:
      D.23548 = table->rows;
      D.23549 = (int) D.23548;
      if (D.23549 > i) goto <D.19803>; else goto <D.19805>;
      <D.19805>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_assemblyref_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23607;
  unsigned int D.23608;
  unsigned int D.23609;
  int D.23612;
  gchar * D.23615;
  struct GSList * D.23616;
  struct GSList * D.23617;
  unsigned int D.23618;
  int D.23621;
  gchar * D.23626;
  struct GSList * D.23627;
  unsigned int D.23628;
  int D.23629;
  gchar * D.23634;
  struct GSList * D.23635;
  unsigned int D.23636;
  int D.23639;
  gchar * D.23644;
  struct GSList * D.23645;
  unsigned int D.23646;
  int D.23649;
  gchar * D.23654;
  struct GSList * D.23655;
  <unnamed-unsigned:24> D.23656;
  int D.23657;
  struct MonoTableInfo * table;
  guint32 data[9];
  int i;

  try
    {
      D.23607 = ctx->image;
      table = &D.23607->tables[35];
      i = 0;
      goto <D.19818>;
      <D.19817>:
      mono_metadata_decode_row (table, i, &data, 9);
      D.23608 = data[4];
      D.23609 = D.23608 & 4294917886;
      if (D.23609 != 0) goto <D.23610>; else goto <D.23611>;
      <D.23610>:
      D.23612 = ctx->report_error;
      if (D.23612 != 0) goto <D.23613>; else goto <D.23614>;
      <D.23613>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23608 = data[4];
        D.23615 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Flags %08x", i, D.23608);
        vinfo->info.message = D.23615;
        vinfo->exception_type = 3;
        D.23616 = ctx->errors;
        D.23617 = monoeg_g_slist_prepend (D.23616, vinfo);
        ctx->errors = D.23617;
      }
      <D.23614>:
      ctx->valid = 0;
      return;
      <D.23611>:
      D.23618 = data[5];
      if (D.23618 != 0) goto <D.23619>; else goto <D.23620>;
      <D.23619>:
      D.23618 = data[5];
      D.23621 = is_valid_blob_object (ctx, D.23618, 1);
      if (D.23621 == 0) goto <D.23622>; else goto <D.23623>;
      <D.23622>:
      D.23612 = ctx->report_error;
      if (D.23612 != 0) goto <D.23624>; else goto <D.23625>;
      <D.23624>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23618 = data[5];
        D.23626 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, D.23618);
        vinfo->info.message = D.23626;
        vinfo->exception_type = 3;
        D.23616 = ctx->errors;
        D.23627 = monoeg_g_slist_prepend (D.23616, vinfo);
        ctx->errors = D.23627;
      }
      <D.23625>:
      ctx->valid = 0;
      return;
      <D.23623>:
      <D.23620>:
      D.23628 = data[6];
      D.23629 = is_valid_non_empty_string (ctx, D.23628);
      if (D.23629 == 0) goto <D.23630>; else goto <D.23631>;
      <D.23630>:
      D.23612 = ctx->report_error;
      if (D.23612 != 0) goto <D.23632>; else goto <D.23633>;
      <D.23632>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23628 = data[6];
        D.23634 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Name %08x", i, D.23628);
        vinfo->info.message = D.23634;
        vinfo->exception_type = 3;
        D.23616 = ctx->errors;
        D.23635 = monoeg_g_slist_prepend (D.23616, vinfo);
        ctx->errors = D.23635;
      }
      <D.23633>:
      ctx->valid = 0;
      return;
      <D.23631>:
      D.23636 = data[7];
      if (D.23636 != 0) goto <D.23637>; else goto <D.23638>;
      <D.23637>:
      D.23636 = data[7];
      D.23639 = is_valid_string (ctx, D.23636);
      if (D.23639 == 0) goto <D.23640>; else goto <D.23641>;
      <D.23640>:
      D.23612 = ctx->report_error;
      if (D.23612 != 0) goto <D.23642>; else goto <D.23643>;
      <D.23642>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23636 = data[7];
        D.23644 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, D.23636);
        vinfo->info.message = D.23644;
        vinfo->exception_type = 3;
        D.23616 = ctx->errors;
        D.23645 = monoeg_g_slist_prepend (D.23616, vinfo);
        ctx->errors = D.23645;
      }
      <D.23643>:
      ctx->valid = 0;
      return;
      <D.23641>:
      <D.23638>:
      D.23646 = data[8];
      if (D.23646 != 0) goto <D.23647>; else goto <D.23648>;
      <D.23647>:
      D.23646 = data[8];
      D.23649 = is_valid_blob_object (ctx, D.23646, 1);
      if (D.23649 == 0) goto <D.23650>; else goto <D.23651>;
      <D.23650>:
      D.23612 = ctx->report_error;
      if (D.23612 != 0) goto <D.23652>; else goto <D.23653>;
      <D.23652>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23646 = data[8];
        D.23654 = monoeg_g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, D.23646);
        vinfo->info.message = D.23654;
        vinfo->exception_type = 3;
        D.23616 = ctx->errors;
        D.23655 = monoeg_g_slist_prepend (D.23616, vinfo);
        ctx->errors = D.23655;
      }
      <D.23653>:
      ctx->valid = 0;
      return;
      <D.23651>:
      <D.23648>:
      i = i + 1;
      <D.19818>:
      D.23656 = table->rows;
      D.23657 = (int) D.23656;
      if (D.23657 > i) goto <D.19817>; else goto <D.19819>;
      <D.19819>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_file_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23661;
  unsigned int D.23662;
  unsigned int D.23663;
  int D.23666;
  gchar * D.23669;
  struct GSList * D.23670;
  struct GSList * D.23671;
  unsigned int D.23672;
  int D.23673;
  gchar * D.23678;
  struct GSList * D.23679;
  unsigned int D.23682;
  int D.23684;
  gchar * D.23687;
  struct GSList * D.23688;
  <unnamed-unsigned:24> D.23689;
  int D.23690;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.23661 = ctx->image;
      table = &D.23661->tables[38];
      i = 0;
      goto <D.19830>;
      <D.19829>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.23662 = data[0];
      D.23663 = D.23662 & 4294967294;
      if (D.23663 != 0) goto <D.23664>; else goto <D.23665>;
      <D.23664>:
      D.23666 = ctx->report_error;
      if (D.23666 != 0) goto <D.23667>; else goto <D.23668>;
      <D.23667>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23662 = data[0];
        D.23669 = monoeg_g_strdup_printf ("File table row %d has invalid Flags %08x", i, D.23662);
        vinfo->info.message = D.23669;
        vinfo->exception_type = 3;
        D.23670 = ctx->errors;
        D.23671 = monoeg_g_slist_prepend (D.23670, vinfo);
        ctx->errors = D.23671;
      }
      <D.23668>:
      ctx->valid = 0;
      return;
      <D.23665>:
      D.23672 = data[1];
      D.23673 = is_valid_non_empty_string (ctx, D.23672);
      if (D.23673 == 0) goto <D.23674>; else goto <D.23675>;
      <D.23674>:
      D.23666 = ctx->report_error;
      if (D.23666 != 0) goto <D.23676>; else goto <D.23677>;
      <D.23676>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23672 = data[1];
        D.23678 = monoeg_g_strdup_printf ("File table row %d has invalid Name %08x", i, D.23672);
        vinfo->info.message = D.23678;
        vinfo->exception_type = 3;
        D.23670 = ctx->errors;
        D.23679 = monoeg_g_slist_prepend (D.23670, vinfo);
        ctx->errors = D.23679;
      }
      <D.23677>:
      ctx->valid = 0;
      return;
      <D.23675>:
      D.23682 = data[2];
      if (D.23682 == 0) goto <D.23680>; else goto <D.23683>;
      <D.23683>:
      D.23682 = data[2];
      D.23684 = is_valid_blob_object (ctx, D.23682, 1);
      if (D.23684 == 0) goto <D.23680>; else goto <D.23681>;
      <D.23680>:
      D.23666 = ctx->report_error;
      if (D.23666 != 0) goto <D.23685>; else goto <D.23686>;
      <D.23685>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23682 = data[2];
        D.23687 = monoeg_g_strdup_printf ("File table row %d has invalid HashValue %08x", i, D.23682);
        vinfo->info.message = D.23687;
        vinfo->exception_type = 3;
        D.23670 = ctx->errors;
        D.23688 = monoeg_g_slist_prepend (D.23670, vinfo);
        ctx->errors = D.23688;
      }
      <D.23686>:
      ctx->valid = 0;
      return;
      <D.23681>:
      i = i + 1;
      <D.19830>:
      D.23689 = table->rows;
      D.23690 = (int) D.23689;
      if (D.23690 > i) goto <D.19829>; else goto <D.19831>;
      <D.19831>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_exportedtype_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23694;
  unsigned int D.23695;
  unsigned int D.23696;
  int D.23699;
  gchar * D.23702;
  struct GSList * D.23703;
  struct GSList * D.23704;
  unsigned int D.23705;
  int D.23706;
  unsigned int D.23711;
  gchar * D.23712;
  struct GSList * D.23713;
  unsigned int D.23714;
  int D.23717;
  gchar * D.23722;
  struct GSList * D.23723;
  unsigned int D.23724;
  int D.23725;
  gchar * D.23730;
  struct GSList * D.23731;
  unsigned int D.23732;
  gchar * D.23737;
  struct GSList * D.23738;
  unsigned int D.23739;
  gchar * D.23746;
  struct GSList * D.23747;
  <unnamed-unsigned:24> D.23748;
  int D.23749;
  struct MonoTableInfo * table;
  guint32 data[5];
  int i;

  try
    {
      D.23694 = ctx->image;
      table = &D.23694->tables[39];
      i = 0;
      goto <D.19845>;
      <D.19844>:
      mono_metadata_decode_row (table, i, &data, 5);
      D.23695 = data[0];
      D.23696 = D.23695 & 4278764096;
      if (D.23696 != 0) goto <D.23697>; else goto <D.23698>;
      <D.23697>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23700>; else goto <D.23701>;
      <D.23700>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23695 = data[0];
        D.23702 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Flags %08x", i, D.23695);
        vinfo->info.message = D.23702;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23704 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23704;
      }
      <D.23701>:
      ctx->valid = 0;
      return;
      <D.23698>:
      D.23705 = data[2];
      D.23706 = is_valid_non_empty_string (ctx, D.23705);
      if (D.23706 == 0) goto <D.23707>; else goto <D.23708>;
      <D.23707>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23709>; else goto <D.23710>;
      <D.23709>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23711 = data[1];
        D.23712 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeName %08x", i, D.23711);
        vinfo->info.message = D.23712;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23713 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23713;
      }
      <D.23710>:
      ctx->valid = 0;
      return;
      <D.23708>:
      D.23714 = data[3];
      if (D.23714 != 0) goto <D.23715>; else goto <D.23716>;
      <D.23715>:
      D.23714 = data[3];
      D.23717 = is_valid_string (ctx, D.23714);
      if (D.23717 == 0) goto <D.23718>; else goto <D.23719>;
      <D.23718>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23720>; else goto <D.23721>;
      <D.23720>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23714 = data[3];
        D.23722 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid TypeNamespace %08x", i, D.23714);
        vinfo->info.message = D.23722;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23723 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23723;
      }
      <D.23721>:
      ctx->valid = 0;
      return;
      <D.23719>:
      <D.23716>:
      D.23724 = data[4];
      D.23725 = is_valid_coded_index (ctx, 60, D.23724);
      if (D.23725 == 0) goto <D.23726>; else goto <D.23727>;
      <D.23726>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23728>; else goto <D.23729>;
      <D.23728>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23724 = data[4];
        D.23730 = monoeg_g_strdup_printf ("ExportedType table row %d has invalid Implementation token %08x", i, D.23724);
        vinfo->info.message = D.23730;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23731 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23731;
      }
      <D.23729>:
      ctx->valid = 0;
      return;
      <D.23727>:
      D.23724 = data[4];
      D.23732 = get_coded_index_token (60, D.23724);
      if (D.23732 == 0) goto <D.23733>; else goto <D.23734>;
      <D.23733>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23735>; else goto <D.23736>;
      <D.23735>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23737 = monoeg_g_strdup_printf ("ExportedType table row %d has null Implementation token", i);
        vinfo->info.message = D.23737;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23738 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23738;
      }
      <D.23736>:
      ctx->valid = 0;
      return;
      <D.23734>:
      D.23724 = data[4];
      D.23739 = get_coded_index_table (60, D.23724);
      if (D.23739 == 39) goto <D.23740>; else goto <D.23741>;
      <D.23740>:
      D.23714 = data[3];
      if (D.23714 != 0) goto <D.23742>; else goto <D.23743>;
      <D.23742>:
      D.23699 = ctx->report_error;
      if (D.23699 != 0) goto <D.23744>; else goto <D.23745>;
      <D.23744>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23746 = monoeg_g_strdup_printf ("ExportedType table row %d has denotes a nested type but has a non null TypeNamespace", i);
        vinfo->info.message = D.23746;
        vinfo->exception_type = 3;
        D.23703 = ctx->errors;
        D.23747 = monoeg_g_slist_prepend (D.23703, vinfo);
        ctx->errors = D.23747;
      }
      <D.23745>:
      ctx->valid = 0;
      return;
      <D.23743>:
      <D.23741>:
      i = i + 1;
      <D.19845>:
      D.23748 = table->rows;
      D.23749 = (int) D.23748;
      if (D.23749 > i) goto <D.19844>; else goto <D.19846>;
      <D.19846>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_manifest_resource_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23753;
  unsigned int D.23754;
  unsigned int D.23755;
  int D.23758;
  gchar * D.23761;
  struct GSList * D.23762;
  struct GSList * D.23763;
  unsigned int D.23764;
  gchar * D.23769;
  struct GSList * D.23770;
  unsigned int D.23771;
  int D.23772;
  gchar * D.23777;
  struct GSList * D.23778;
  unsigned int D.23779;
  int D.23780;
  gchar * D.23785;
  struct GSList * D.23786;
  unsigned int D.23791;
  gchar * D.23792;
  struct GSList * D.23793;
  unsigned int D.23798;
  gchar * D.23803;
  struct GSList * D.23804;
  gchar * D.23811;
  struct GSList * D.23812;
  <unnamed-unsigned:24> D.23813;
  int D.23814;
  struct MonoCLIImageInfo * iinfo;
  struct MonoCLIHeader * ch;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 impl_table;
  guint32 token;
  guint32 resources_size;
  int i;

  try
    {
      D.23753 = ctx->image;
      iinfo = D.23753->image_info;
      ch = &iinfo->cli_cli_header;
      D.23753 = ctx->image;
      table = &D.23753->tables[40];
      resources_size = ch->ch_resources.size;
      i = 0;
      goto <D.19866>;
      <D.19865>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.23754 = data[1];
      D.23755 = D.23754 & 4294967288;
      if (D.23755 != 0) goto <D.23756>; else goto <D.23757>;
      <D.23756>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23754 = data[1];
        D.23761 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags %08x", i, D.23754);
        vinfo->info.message = D.23761;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23763 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23763;
      }
      <D.23760>:
      ctx->valid = 0;
      return;
      <D.23757>:
      D.23754 = data[1];
      D.23764 = D.23754 + 4294967295;
      if (D.23764 > 1) goto <D.23765>; else goto <D.23766>;
      <D.23765>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23767>; else goto <D.23768>;
      <D.23767>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23754 = data[1];
        D.23769 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Flags VisibilityMask %08x", i, D.23754);
        vinfo->info.message = D.23769;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23770 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23770;
      }
      <D.23768>:
      ctx->valid = 0;
      return;
      <D.23766>:
      D.23771 = data[2];
      D.23772 = is_valid_non_empty_string (ctx, D.23771);
      if (D.23772 == 0) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23775>; else goto <D.23776>;
      <D.23775>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23771 = data[2];
        D.23777 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Name %08x", i, D.23771);
        vinfo->info.message = D.23777;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23778 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23778;
      }
      <D.23776>:
      ctx->valid = 0;
      return;
      <D.23774>:
      D.23779 = data[3];
      D.23780 = is_valid_coded_index (ctx, 60, D.23779);
      if (D.23780 == 0) goto <D.23781>; else goto <D.23782>;
      <D.23781>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23783>; else goto <D.23784>;
      <D.23783>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23779 = data[3];
        D.23785 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token %08x", i, D.23779);
        vinfo->info.message = D.23785;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23786 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23786;
      }
      <D.23784>:
      ctx->valid = 0;
      return;
      <D.23782>:
      D.23779 = data[3];
      impl_table = get_coded_index_table (60, D.23779);
      D.23779 = data[3];
      token = get_coded_index_token (60, D.23779);
      if (impl_table == 39) goto <D.23787>; else goto <D.23788>;
      <D.23787>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23789>; else goto <D.23790>;
      <D.23789>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23779 = data[3];
        D.23791 = get_coded_index_table (60, D.23779);
        D.23792 = monoeg_g_strdup_printf ("ManifestResource table row %d has invalid Implementation token table %08x", i, D.23791);
        vinfo->info.message = D.23792;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23793 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23793;
      }
      <D.23790>:
      ctx->valid = 0;
      return;
      <D.23788>:
      if (impl_table == 38) goto <D.23794>; else goto <D.23795>;
      <D.23794>:
      if (token != 0) goto <D.23796>; else goto <D.23797>;
      <D.23796>:
      D.23798 = data[0];
      if (D.23798 != 0) goto <D.23799>; else goto <D.23800>;
      <D.23799>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23801>; else goto <D.23802>;
      <D.23801>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23803 = monoeg_g_strdup_printf ("ManifestResource table row %d points to a file but has non-zero offset", i);
        vinfo->info.message = D.23803;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23804 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23804;
      }
      <D.23802>:
      ctx->valid = 0;
      return;
      <D.23800>:
      <D.23797>:
      <D.23795>:
      if (token == 0) goto <D.23805>; else goto <D.23806>;
      <D.23805>:
      D.23798 = data[0];
      if (D.23798 >= resources_size) goto <D.23807>; else goto <D.23808>;
      <D.23807>:
      D.23758 = ctx->report_error;
      if (D.23758 != 0) goto <D.23809>; else goto <D.23810>;
      <D.23809>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23798 = data[0];
        D.23811 = monoeg_g_strdup_printf ("ManifestResource table row %d invalid Offset field %08x ", i, D.23798);
        vinfo->info.message = D.23811;
        vinfo->exception_type = 3;
        D.23762 = ctx->errors;
        D.23812 = monoeg_g_slist_prepend (D.23762, vinfo);
        ctx->errors = D.23812;
      }
      <D.23810>:
      ctx->valid = 0;
      return;
      <D.23808>:
      <D.23806>:
      i = i + 1;
      <D.19866>:
      D.23813 = table->rows;
      D.23814 = (int) D.23813;
      if (D.23814 > i) goto <D.19865>; else goto <D.19867>;
      <D.19867>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_nested_class_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23818;
  unsigned int D.23821;
  <unnamed-unsigned:24> D.23823;
  unsigned int D.23824;
  int D.23825;
  gchar * D.23828;
  struct GSList * D.23829;
  struct GSList * D.23830;
  unsigned int D.23833;
  gchar * D.23837;
  struct GSList * D.23838;
  gchar * D.23843;
  struct GSList * D.23844;
  <unnamed-unsigned:24> D.23845;
  int D.23846;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23818 = ctx->image;
      table = &D.23818->tables[41];
      i = 0;
      goto <D.19878>;
      <D.19877>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23821 = data[0];
      if (D.23821 == 0) goto <D.23819>; else goto <D.23822>;
      <D.23822>:
      D.23821 = data[0];
      D.23818 = ctx->image;
      D.23823 = D.23818->tables[2].rows;
      D.23824 = (unsigned int) D.23823;
      if (D.23821 > D.23824) goto <D.23819>; else goto <D.23820>;
      <D.23819>:
      D.23825 = ctx->report_error;
      if (D.23825 != 0) goto <D.23826>; else goto <D.23827>;
      <D.23826>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23821 = data[0];
        D.23828 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid NestedClass token %08x", i, D.23821);
        vinfo->info.message = D.23828;
        vinfo->exception_type = 3;
        D.23829 = ctx->errors;
        D.23830 = monoeg_g_slist_prepend (D.23829, vinfo);
        ctx->errors = D.23830;
      }
      <D.23827>:
      ctx->valid = 0;
      return;
      <D.23820>:
      D.23833 = data[1];
      if (D.23833 == 0) goto <D.23831>; else goto <D.23834>;
      <D.23834>:
      D.23833 = data[1];
      D.23818 = ctx->image;
      D.23823 = D.23818->tables[2].rows;
      D.23824 = (unsigned int) D.23823;
      if (D.23833 > D.23824) goto <D.23831>; else goto <D.23832>;
      <D.23831>:
      D.23825 = ctx->report_error;
      if (D.23825 != 0) goto <D.23835>; else goto <D.23836>;
      <D.23835>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23833 = data[1];
        D.23837 = monoeg_g_strdup_printf ("NestedClass table row %d has invalid EnclosingClass token %08x", i, D.23833);
        vinfo->info.message = D.23837;
        vinfo->exception_type = 3;
        D.23829 = ctx->errors;
        D.23838 = monoeg_g_slist_prepend (D.23829, vinfo);
        ctx->errors = D.23838;
      }
      <D.23836>:
      ctx->valid = 0;
      return;
      <D.23832>:
      D.23833 = data[1];
      D.23821 = data[0];
      if (D.23833 == D.23821) goto <D.23839>; else goto <D.23840>;
      <D.23839>:
      D.23825 = ctx->report_error;
      if (D.23825 != 0) goto <D.23841>; else goto <D.23842>;
      <D.23841>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23833 = data[1];
        D.23843 = monoeg_g_strdup_printf ("NestedClass table row %d has same token for NestedClass  and EnclosingClass %08x", i, D.23833);
        vinfo->info.message = D.23843;
        vinfo->exception_type = 3;
        D.23829 = ctx->errors;
        D.23844 = monoeg_g_slist_prepend (D.23829, vinfo);
        ctx->errors = D.23844;
      }
      <D.23842>:
      ctx->valid = 0;
      return;
      <D.23840>:
      i = i + 1;
      <D.19878>:
      D.23845 = table->rows;
      D.23846 = (int) D.23845;
      if (D.23846 > i) goto <D.19877>; else goto <D.19879>;
      <D.19879>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23850;
  unsigned int D.23851;
  unsigned int D.23852;
  int D.23855;
  gchar * D.23858;
  struct GSList * D.23859;
  struct GSList * D.23860;
  unsigned int D.23861;
  gchar * D.23866;
  struct GSList * D.23867;
  unsigned int D.23868;
  int D.23869;
  gchar * D.23874;
  struct GSList * D.23875;
  int D.23876;
  gchar * D.23881;
  struct GSList * D.23882;
  unsigned int D.23883;
  gchar * D.23888;
  struct GSList * D.23889;
  unsigned int D.23892;
  unsigned int param_number.92;
  gchar * D.23898;
  struct GSList * D.23899;
  <unnamed-unsigned:24> D.23900;
  int D.23901;
  struct MonoTableInfo * table;
  guint32 data[4];
  guint32 token;
  guint32 last_token;
  int i;
  int param_number;

  try
    {
      D.23850 = ctx->image;
      table = &D.23850->tables[42];
      last_token = 0;
      param_number = 0;
      i = 0;
      goto <D.19896>;
      <D.19895>:
      mono_metadata_decode_row (table, i, &data, 4);
      D.23851 = data[1];
      D.23852 = D.23851 & 4294967264;
      if (D.23852 != 0) goto <D.23853>; else goto <D.23854>;
      <D.23853>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23856>; else goto <D.23857>;
      <D.23856>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23851 = data[1];
        D.23858 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Flags token %08x", i, D.23851);
        vinfo->info.message = D.23858;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23860 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23860;
      }
      <D.23857>:
      ctx->valid = 0;
      return;
      <D.23854>:
      D.23851 = data[1];
      D.23861 = D.23851 & 3;
      if (D.23861 == 3) goto <D.23862>; else goto <D.23863>;
      <D.23862>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23864>; else goto <D.23865>;
      <D.23864>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23866 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid VarianceMask 0x3", i);
        vinfo->info.message = D.23866;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23867 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23867;
      }
      <D.23865>:
      ctx->valid = 0;
      return;
      <D.23863>:
      D.23868 = data[3];
      D.23869 = is_valid_non_empty_string (ctx, D.23868);
      if (D.23869 == 0) goto <D.23870>; else goto <D.23871>;
      <D.23870>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23872>; else goto <D.23873>;
      <D.23872>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23868 = data[3];
        D.23874 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Name token %08x", i, D.23868);
        vinfo->info.message = D.23874;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23875 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23875;
      }
      <D.23873>:
      ctx->valid = 0;
      return;
      <D.23871>:
      token = data[2];
      D.23876 = is_valid_coded_index (ctx, 78, token);
      if (D.23876 == 0) goto <D.23877>; else goto <D.23878>;
      <D.23877>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23879>; else goto <D.23880>;
      <D.23879>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23881 = monoeg_g_strdup_printf ("GenericParam table row %d has invalid Owner token %08x", i, token);
        vinfo->info.message = D.23881;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23882 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23882;
      }
      <D.23880>:
      ctx->valid = 0;
      return;
      <D.23878>:
      D.23883 = get_coded_index_token (78, token);
      if (D.23883 == 0) goto <D.23884>; else goto <D.23885>;
      <D.23884>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23886>; else goto <D.23887>;
      <D.23886>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23888 = monoeg_g_strdup_printf ("GenericParam table row %d has null Owner token", i);
        vinfo->info.message = D.23888;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23889 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23889;
      }
      <D.23887>:
      ctx->valid = 0;
      return;
      <D.23885>:
      if (token != last_token) goto <D.23890>; else goto <D.23891>;
      <D.23890>:
      param_number = 0;
      last_token = token;
      <D.23891>:
      D.23892 = data[0];
      param_number.92 = (unsigned int) param_number;
      if (D.23892 != param_number.92) goto <D.23894>; else goto <D.23895>;
      <D.23894>:
      D.23855 = ctx->report_error;
      if (D.23855 != 0) goto <D.23896>; else goto <D.23897>;
      <D.23896>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23892 = data[0];
        D.23898 = monoeg_g_strdup_printf ("GenericParam table row %d Number is out of order %d expected %d", i, D.23892, param_number);
        vinfo->info.message = D.23898;
        vinfo->exception_type = 3;
        D.23859 = ctx->errors;
        D.23899 = monoeg_g_slist_prepend (D.23859, vinfo);
        ctx->errors = D.23899;
      }
      <D.23897>:
      ctx->valid = 0;
      return;
      <D.23895>:
      param_number = param_number + 1;
      i = i + 1;
      <D.19896>:
      D.23900 = table->rows;
      D.23901 = (int) D.23900;
      if (D.23901 > i) goto <D.19895>; else goto <D.19897>;
      <D.19897>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_method_spec_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23905;
  unsigned int D.23906;
  int D.23907;
  int D.23910;
  gchar * D.23913;
  struct GSList * D.23914;
  struct GSList * D.23915;
  unsigned int D.23916;
  gchar * D.23921;
  struct GSList * D.23922;
  unsigned int D.23923;
  int D.23926;
  gchar * D.23931;
  struct GSList * D.23932;
  <unnamed-unsigned:24> D.23933;
  int D.23934;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.23905 = ctx->image;
      table = &D.23905->tables[43];
      i = 0;
      goto <D.19908>;
      <D.19907>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23906 = data[0];
      D.23907 = is_valid_coded_index (ctx, 52, D.23906);
      if (D.23907 == 0) goto <D.23908>; else goto <D.23909>;
      <D.23908>:
      D.23910 = ctx->report_error;
      if (D.23910 != 0) goto <D.23911>; else goto <D.23912>;
      <D.23911>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23906 = data[0];
        D.23913 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Method token %08x", i, D.23906);
        vinfo->info.message = D.23913;
        vinfo->exception_type = 3;
        D.23914 = ctx->errors;
        D.23915 = monoeg_g_slist_prepend (D.23914, vinfo);
        ctx->errors = D.23915;
      }
      <D.23912>:
      ctx->valid = 0;
      return;
      <D.23909>:
      D.23906 = data[0];
      D.23916 = get_coded_index_token (52, D.23906);
      if (D.23916 == 0) goto <D.23917>; else goto <D.23918>;
      <D.23917>:
      D.23910 = ctx->report_error;
      if (D.23910 != 0) goto <D.23919>; else goto <D.23920>;
      <D.23919>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23921 = monoeg_g_strdup_printf ("MethodSpec table row %d has null Method token", i);
        vinfo->info.message = D.23921;
        vinfo->exception_type = 3;
        D.23914 = ctx->errors;
        D.23922 = monoeg_g_slist_prepend (D.23914, vinfo);
        ctx->errors = D.23922;
      }
      <D.23920>:
      ctx->valid = 0;
      return;
      <D.23918>:
      D.23923 = data[1];
      if (D.23923 != 0) goto <D.23924>; else goto <D.23925>;
      <D.23924>:
      D.23923 = data[1];
      D.23926 = is_valid_blob_object (ctx, D.23923, 1);
      if (D.23926 == 0) goto <D.23927>; else goto <D.23928>;
      <D.23927>:
      D.23910 = ctx->report_error;
      if (D.23910 != 0) goto <D.23929>; else goto <D.23930>;
      <D.23929>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23923 = data[1];
        D.23931 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, D.23923);
        vinfo->info.message = D.23931;
        vinfo->exception_type = 3;
        D.23914 = ctx->errors;
        D.23932 = monoeg_g_slist_prepend (D.23914, vinfo);
        ctx->errors = D.23932;
      }
      <D.23930>:
      ctx->valid = 0;
      return;
      <D.23928>:
      <D.23925>:
      i = i + 1;
      <D.19908>:
      D.23933 = table->rows;
      D.23934 = (int) D.23933;
      if (D.23934 > i) goto <D.19907>; else goto <D.19909>;
      <D.19909>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


verify_generic_param_constraint_table (struct VerifyContext * ctx)
{
  struct MonoImage * D.23938;
  unsigned int D.23941;
  <unnamed-unsigned:24> D.23943;
  unsigned int D.23944;
  int D.23945;
  gchar * D.23948;
  struct GSList * D.23949;
  struct GSList * D.23950;
  unsigned int D.23951;
  int D.23952;
  gchar * D.23957;
  struct GSList * D.23958;
  unsigned int D.23959;
  gchar * D.23964;
  struct GSList * D.23965;
  gchar * D.23970;
  struct GSList * D.23971;
  gchar * D.23978;
  struct GSList * D.23979;
  <unnamed-unsigned:24> D.23981;
  int D.23982;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;
  guint32 last_owner;
  guint32 last_constraint;

  try
    {
      D.23938 = ctx->image;
      table = &D.23938->tables[44];
      last_owner = 0;
      last_constraint = 0;
      i = 0;
      goto <D.19934>;
      <D.19933>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.23941 = data[0];
      if (D.23941 == 0) goto <D.23939>; else goto <D.23942>;
      <D.23942>:
      D.23941 = data[0];
      D.23938 = ctx->image;
      D.23943 = D.23938->tables[42].rows;
      D.23944 = (unsigned int) D.23943;
      if (D.23941 > D.23944) goto <D.23939>; else goto <D.23940>;
      <D.23939>:
      D.23945 = ctx->report_error;
      if (D.23945 != 0) goto <D.23946>; else goto <D.23947>;
      <D.23946>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23941 = data[0];
        D.23948 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Owner token %08x", i, D.23941);
        vinfo->info.message = D.23948;
        vinfo->exception_type = 3;
        D.23949 = ctx->errors;
        D.23950 = monoeg_g_slist_prepend (D.23949, vinfo);
        ctx->errors = D.23950;
      }
      <D.23947>:
      ctx->valid = 0;
      return;
      <D.23940>:
      D.23951 = data[1];
      D.23952 = is_valid_coded_index (ctx, 0, D.23951);
      if (D.23952 == 0) goto <D.23953>; else goto <D.23954>;
      <D.23953>:
      D.23945 = ctx->report_error;
      if (D.23945 != 0) goto <D.23955>; else goto <D.23956>;
      <D.23955>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23951 = data[1];
        D.23957 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has invalid Constraint token %08x", i, D.23951);
        vinfo->info.message = D.23957;
        vinfo->exception_type = 3;
        D.23949 = ctx->errors;
        D.23958 = monoeg_g_slist_prepend (D.23949, vinfo);
        ctx->errors = D.23958;
      }
      <D.23956>:
      ctx->valid = 0;
      return;
      <D.23954>:
      D.23951 = data[1];
      D.23959 = get_coded_index_token (0, D.23951);
      if (D.23959 == 0) goto <D.23960>; else goto <D.23961>;
      <D.23960>:
      D.23945 = ctx->report_error;
      if (D.23945 != 0) goto <D.23962>; else goto <D.23963>;
      <D.23962>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23964 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has null Constraint token", i);
        vinfo->info.message = D.23964;
        vinfo->exception_type = 3;
        D.23949 = ctx->errors;
        D.23965 = monoeg_g_slist_prepend (D.23949, vinfo);
        ctx->errors = D.23965;
      }
      <D.23963>:
      ctx->valid = 0;
      return;
      <D.23961>:
      D.23941 = data[0];
      if (D.23941 < last_owner) goto <D.23966>; else goto <D.23967>;
      <D.23966>:
      D.23945 = ctx->report_error;
      if (D.23945 != 0) goto <D.23968>; else goto <D.23969>;
      <D.23968>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23941 = data[0];
        D.23970 = 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.23941);
        vinfo->info.message = D.23970;
        vinfo->exception_type = 3;
        D.23949 = ctx->errors;
        D.23971 = monoeg_g_slist_prepend (D.23949, vinfo);
        ctx->errors = D.23971;
      }
      <D.23969>:
      ctx->valid = 0;
      return;
      <D.23967>:
      D.23941 = data[0];
      if (D.23941 == last_owner) goto <D.23972>; else goto <D.23973>;
      <D.23972>:
      D.23951 = data[1];
      if (D.23951 == last_constraint) goto <D.23974>; else goto <D.23975>;
      <D.23974>:
      D.23945 = ctx->report_error;
      if (D.23945 != 0) goto <D.23976>; else goto <D.23977>;
      <D.23976>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.23978 = monoeg_g_strdup_printf ("GenericParamConstraint table row %d has duplicate constraint 0x%08x", i, last_constraint);
        vinfo->info.message = D.23978;
        vinfo->exception_type = 3;
        D.23949 = ctx->errors;
        D.23979 = monoeg_g_slist_prepend (D.23949, vinfo);
        ctx->errors = D.23979;
      }
      <D.23977>:
      ctx->valid = 0;
      return;
      <D.23975>:
      goto <D.23980>;
      <D.23973>:
      last_owner = data[0];
      <D.23980>:
      last_constraint = data[1];
      i = i + 1;
      <D.19934>:
      D.23981 = table->rows;
      D.23982 = (int) D.23981;
      if (D.23982 > i) goto <D.19933>; else goto <D.19935>;
      <D.19935>:
    }
  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.23986;
  unsigned int D.23987;
  const char * D.23988;
  unsigned int D.23989;
  const char * D.23990;
  unsigned int D.23991;
  unsigned int D.23992;
  int D.23995;
  unsigned int D.23996;
  _Bool D.23997;
  long int D.23998;
  long int D.23999;
  unsigned int D.24002;
  void * D.24003;
  int D.24006;
  const char * D.24009;
  const char * D.24010;
  unsigned int D.24011;
  gchar * D.24012;
  struct GSList * D.24013;
  struct GSList * D.24014;
  <unnamed-unsigned:24> D.24015;
  int D.24016;
  int i;
  guint32 data[6];
  guint32 nested_data[2];
  struct MonoTableInfo * table;
  struct MonoTableInfo * nested_table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (24);
        mono_metadata_decode_row (table, i, &data, 6);
        D.23986 = ctx->image;
        D.23987 = data[1];
        D.23988 = mono_metadata_string_heap (D.23986, D.23987);
        type->name = D.23988;
        D.23986 = ctx->image;
        D.23989 = data[2];
        D.23990 = mono_metadata_string_heap (D.23986, D.23989);
        type->name_space = D.23990;
        type->resolution_scope = 0;
        D.23991 = data[0];
        visibility = D.23991 & 7;
        D.23992 = visibility + 4294967294;
        if (D.23992 <= 5) goto <D.23993>; else goto <D.23994>;
        <D.23993>:
        {
          int res;

          D.23995 = i + 1;
          D.23996 = (unsigned int) D.23995;
          res = search_sorted_table (ctx, 41, 0, D.23996);
          D.23997 = res < 0;
          D.23998 = (long int) D.23997;
          D.23999 = __builtin_expect (D.23998, 0);
          if (D.23999 != 0) goto <D.24000>; else goto <D.24001>;
          <D.24000>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "metadata-verify.c", 3700, "res >= 0");
          <D.24001>:
          mono_metadata_decode_row (nested_table, res, &nested_data, 2);
          D.24002 = nested_data[1];
          type->resolution_scope = D.24002;
        }
        <D.23994>:
        D.24003 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.24003 != 0B) goto <D.24004>; else goto <D.24005>;
        <D.24004>:
        D.24006 = ctx->report_error;
        if (D.24006 != 0) goto <D.24007>; else goto <D.24008>;
        <D.24007>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.24009 = type->name;
          D.24010 = type->name_space;
          D.24011 = type->resolution_scope;
          D.24012 = monoeg_g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, D.24009, D.24010, D.24011);
          vinfo->info.message = D.24012;
          vinfo->exception_type = 3;
          D.24013 = ctx->errors;
          D.24014 = monoeg_g_slist_prepend (D.24013, vinfo);
          ctx->errors = D.24014;
        }
        <D.24008>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.24005>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19983>:
      D.24015 = table->rows;
      D.24016 = (int) D.24015;
      if (D.24016 > i) goto <D.19982>; else goto <D.19984>;
      <D.19984>:
      monoeg_g_hash_table_destroy (unique_types);
    }
  finally
    {
      data = {CLOBBER};
      nested_data = {CLOBBER};
    }
}


typedef_equals (const void * _a, const void * _b)
{
  gboolean D.24020;
  int iftmp.93;
  int D.19959;
  const char * D.24024;
  const char * D.24025;
  int D.19968;
  const char * D.24027;
  const char * D.24028;
  unsigned int D.24030;
  unsigned int D.24031;
  const struct TypeDefUniqueId * a;
  const struct TypeDefUniqueId * b;

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

    D.24024 = a->name;
    D.24025 = b->name;
    D.19959 = __builtin_strcmp (D.24024, D.24025);
  }
  if (D.19959 == 0) goto <D.24026>; else goto <D.24022>;
  <D.24026>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.24027 = a->name_space;
    D.24028 = b->name_space;
    D.19968 = __builtin_strcmp (D.24027, D.24028);
  }
  if (D.19968 == 0) goto <D.24029>; else goto <D.24022>;
  <D.24029>:
  D.24030 = a->resolution_scope;
  D.24031 = b->resolution_scope;
  if (D.24030 == D.24031) goto <D.24032>; else goto <D.24022>;
  <D.24032>:
  iftmp.93 = 1;
  goto <D.24023>;
  <D.24022>:
  iftmp.93 = 0;
  <D.24023>:
  D.24020 = iftmp.93;
  return D.24020;
}


typedef_hash (const void * _key)
{
  guint D.24034;
  const char * D.24035;
  unsigned int D.24036;
  const char * D.24037;
  unsigned int D.24038;
  unsigned int D.24039;
  unsigned int D.24040;
  const struct TypeDefUniqueId * key;

  key = _key;
  D.24035 = key->name;
  D.24036 = monoeg_g_str_hash (D.24035);
  D.24037 = key->name_space;
  D.24038 = monoeg_g_str_hash (D.24037);
  D.24039 = D.24036 ^ D.24038;
  D.24040 = key->resolution_scope;
  D.24034 = D.24039 ^ D.24040;
  return D.24034;
}


mono_verifier_verify_full_table_data (struct MonoImage * image, struct GSList * * error_list)
{
  int D.24042;
  gboolean D.24045;
  _Bool D.24046;
  int D.24047;
  int D.24048;
  struct VerifyContext ctx;
  void cleanup = <<< error >>>;

  try
    {
      D.24042 = mono_verifier_is_enabled_for_image (image);
      if (D.24042 == 0) goto <D.24043>; else goto <D.24044>;
      <D.24043>:
      D.24045 = 1;
      return D.24045;
      <D.24044>:
      D.24046 = error_list != 0B;
      D.24047 = (int) D.24046;
      init_verify_context (&ctx, image, D.24047);
      ctx.stage = 2;
      verify_typedef_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24049>;
      <D.24049>:
      verify_field_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24050>;
      <D.24050>:
      verify_method_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24051>;
      <D.24051>:
      verify_memberref_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24052>;
      <D.24052>:
      verify_cattr_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24053>;
      <D.24053>:
      verify_field_marshal_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24054>;
      <D.24054>:
      verify_decl_security_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24055>;
      <D.24055>:
      verify_standalonesig_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24056>;
      <D.24056>:
      verify_event_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24057>;
      <D.24057>:
      verify_typespec_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24058>;
      <D.24058>:
      verify_method_spec_table_full (&ctx);
      D.24048 = ctx.valid;
      if (D.24048 == 0) goto cleanup; else goto <D.24059>;
      <D.24059>:
      verify_tables_data_global_constraints_full (&ctx);
      cleanup:
      D.24045 = cleanup_context (&ctx, error_list);
      return D.24045;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_typedef_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24062;
  long unsigned int D.24063;
  long unsigned int D.24064;
  int D.24067;
  gchar * D.24070;
  struct GSList * D.24071;
  struct GSList * D.24072;
  unsigned int D.24075;
  unsigned int D.24076;
  unsigned int D.24079;
  gchar * D.24084;
  struct GSList * D.24085;
  unsigned int D.24087;
  _Bool D.24088;
  gchar * D.24095;
  struct GSList * D.24096;
  gchar * D.24102;
  struct GSList * D.24103;
  <unnamed-unsigned:24> D.24104;
  int D.24105;
  struct MonoTableInfo * table;
  guint32 data[6];
  int i;

  try
    {
      D.24062 = ctx->image;
      table = &D.24062->tables[2];
      D.24063 = BIT_FIELD_REF <*table, 64, 64>;
      D.24064 = D.24063 & 16777215;
      if (D.24064 == 0) goto <D.24065>; else goto <D.24066>;
      <D.24065>:
      D.24067 = ctx->report_error;
      if (D.24067 != 0) goto <D.24068>; else goto <D.24069>;
      <D.24068>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24070 = monoeg_g_strdup_printf ("Typedef table must have exactly at least one row");
        vinfo->info.message = D.24070;
        vinfo->exception_type = 3;
        D.24071 = ctx->errors;
        D.24072 = monoeg_g_slist_prepend (D.24071, vinfo);
        ctx->errors = D.24072;
      }
      <D.24069>:
      ctx->valid = 0;
      return;
      <D.24066>:
      i = 0;
      goto <D.19317>;
      <D.19316>:
      mono_metadata_decode_row (table, i, &data, 6);
      if (i == 0) goto <D.24073>; else goto <D.24074>;
      <D.24073>:
      // predicted unlikely by continue predictor.
      goto <D.19310>;
      <D.24074>:
      D.24075 = data[0];
      D.24076 = D.24075 & 32;
      if (D.24076 != 0) goto <D.24077>; else goto <D.24078>;
      <D.24077>:
      D.24079 = data[3];
      if (D.24079 != 0) goto <D.24080>; else goto <D.24081>;
      <D.24080>:
      D.24067 = ctx->report_error;
      if (D.24067 != 0) goto <D.24082>; else goto <D.24083>;
      <D.24082>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24084 = monoeg_g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i);
        vinfo->info.message = D.24084;
        vinfo->exception_type = 3;
        D.24071 = ctx->errors;
        D.24085 = monoeg_g_slist_prepend (D.24071, vinfo);
        ctx->errors = D.24085;
      }
      <D.24083>:
      ctx->valid = 0;
      return;
      <D.24081>:
      goto <D.24086>;
      <D.24078>:
      {
        gboolean is_sys_obj;
        gboolean has_parent;

        is_sys_obj = typedef_is_system_object (ctx, &data);
        D.24079 = data[3];
        D.24087 = get_coded_index_token (0, D.24079);
        D.24088 = D.24087 != 0;
        has_parent = (gboolean) D.24088;
        if (is_sys_obj != 0) goto <D.24089>; else goto <D.24090>;
        <D.24089>:
        if (has_parent != 0) goto <D.24091>; else goto <D.24092>;
        <D.24091>:
        D.24067 = ctx->report_error;
        if (D.24067 != 0) goto <D.24093>; else goto <D.24094>;
        <D.24093>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.24095 = monoeg_g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i);
          vinfo->info.message = D.24095;
          vinfo->exception_type = 3;
          D.24071 = ctx->errors;
          D.24096 = monoeg_g_slist_prepend (D.24071, vinfo);
          ctx->errors = D.24096;
        }
        <D.24094>:
        ctx->valid = 0;
        return;
        <D.24092>:
        goto <D.24097>;
        <D.24090>:
        if (has_parent == 0) goto <D.24098>; else goto <D.24099>;
        <D.24098>:
        D.24067 = ctx->report_error;
        if (D.24067 != 0) goto <D.24100>; else goto <D.24101>;
        <D.24100>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.24102 = monoeg_g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i);
          vinfo->info.message = D.24102;
          vinfo->exception_type = 3;
          D.24071 = ctx->errors;
          D.24103 = monoeg_g_slist_prepend (D.24071, vinfo);
          ctx->errors = D.24103;
        }
        <D.24101>:
        ctx->valid = 0;
        return;
        <D.24099>:
        <D.24097>:
      }
      <D.24086>:
      <D.19310>:
      i = i + 1;
      <D.19317>:
      D.24104 = table->rows;
      D.24105 = (int) D.24104;
      if (D.24105 > i) goto <D.19316>; else goto <D.19318>;
      <D.19318>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


typedef_is_system_object (struct VerifyContext * ctx, guint32 * data)
{
  gboolean D.24109;
  int iftmp.94;
  struct MonoImage * D.24113;
  int D.24114;
  guint32 * D.24116;
  unsigned int D.24117;
  int D.24118;
  guint32 * D.24120;
  unsigned int D.24121;
  int D.24122;

  D.24113 = ctx->image;
  D.24114 = mono_verifier_is_corlib (D.24113);
  if (D.24114 != 0) goto <D.24115>; else goto <D.24111>;
  <D.24115>:
  D.24116 = data + 8;
  D.24117 = *D.24116;
  D.24118 = string_cmp (ctx, "System", D.24117);
  if (D.24118 == 0) goto <D.24119>; else goto <D.24111>;
  <D.24119>:
  D.24120 = data + 4;
  D.24121 = *D.24120;
  D.24122 = string_cmp (ctx, "Object", D.24121);
  if (D.24122 == 0) goto <D.24123>; else goto <D.24111>;
  <D.24123>:
  iftmp.94 = 1;
  goto <D.24112>;
  <D.24111>:
  iftmp.94 = 0;
  <D.24112>:
  D.24109 = iftmp.94;
  return D.24109;
}


mono_verifier_is_corlib (struct MonoImage * image)
{
  int iftmp.95;
  <unnamed type> D.24126;
  gboolean D.24130;
  int iftmp.96;
  const char * D.24135;
  int D.18695;
  int iftmp.97;
  int D.18691;
  const char[13] * D.24140;
  unsigned char D.24141;
  int D.24142;
  unsigned char D.24143;
  int D.24144;
  const unsigned char * D.24149;
  unsigned char D.24150;
  int D.24151;
  const unsigned char * D.24152;
  unsigned char D.24153;
  int D.24154;
  const unsigned char * D.24159;
  unsigned char D.24160;
  int D.24161;
  const unsigned char * D.24162;
  unsigned char D.24163;
  int D.24164;
  const unsigned char * D.24169;
  unsigned char D.24170;
  int D.24171;
  const unsigned char * D.24172;
  unsigned char D.24173;
  int D.24174;
  gboolean trusted_location;

  D.24126 = mono_security_get_mode ();
  if (D.24126 == 1) goto <D.24127>; else goto <D.24128>;
  <D.24127>:
  iftmp.95 = mono_security_core_clr_is_platform_image (image);
  goto <D.24129>;
  <D.24128>:
  iftmp.95 = 1;
  <D.24129>:
  trusted_location = iftmp.95;
  if (trusted_location != 0) goto <D.24134>; else goto <D.24132>;
  <D.24134>:
  D.24135 = image->module_name;
  if (D.24135 != 0B) goto <D.24136>; else goto <D.24132>;
  <D.24136>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = image->module_name;
      D.24140 = "mscorlib.dll";
      D.24141 = MEM[(const unsigned char *)D.24140];
      D.24142 = (int) D.24141;
      D.24143 = *__s2;
      D.24144 = (int) D.24143;
      __result = D.24142 - D.24144;
      {
        if (__s1_len != 0) goto <D.24145>; else goto <D.24146>;
        <D.24145>:
        if (__result == 0) goto <D.24147>; else goto <D.24148>;
        <D.24147>:
        D.24149 = &MEM[(void *)"mscorlib.dll" + 1B];
        D.24150 = *D.24149;
        D.24151 = (int) D.24150;
        D.24152 = __s2 + 1;
        D.24153 = *D.24152;
        D.24154 = (int) D.24153;
        __result = D.24151 - D.24154;
        if (__s1_len > 1) goto <D.24155>; else goto <D.24156>;
        <D.24155>:
        if (__result == 0) goto <D.24157>; else goto <D.24158>;
        <D.24157>:
        D.24159 = &MEM[(void *)"mscorlib.dll" + 2B];
        D.24160 = *D.24159;
        D.24161 = (int) D.24160;
        D.24162 = __s2 + 2;
        D.24163 = *D.24162;
        D.24164 = (int) D.24163;
        __result = D.24161 - D.24164;
        if (__s1_len > 2) goto <D.24165>; else goto <D.24166>;
        <D.24165>:
        if (__result == 0) goto <D.24167>; else goto <D.24168>;
        <D.24167>:
        D.24169 = &MEM[(void *)"mscorlib.dll" + 3B];
        D.24170 = *D.24169;
        D.24171 = (int) D.24170;
        D.24172 = __s2 + 3;
        D.24173 = *D.24172;
        D.24174 = (int) D.24173;
        __result = D.24171 - D.24174;
        <D.24168>:
        <D.24166>:
        <D.24158>:
        <D.24156>:
        <D.24148>:
        <D.24146>:
      }
      D.18691 = __result;
    }
    iftmp.97 = D.18691;
    goto <D.24175>;
    <D.24139>:
    D.24135 = image->module_name;
    iftmp.97 = __builtin_strcmp ("mscorlib.dll", D.24135);
    <D.24175>:
    D.18695 = iftmp.97;
  }
  if (D.18695 == 0) goto <D.24176>; else goto <D.24132>;
  <D.24176>:
  iftmp.96 = 1;
  goto <D.24133>;
  <D.24132>:
  iftmp.96 = 0;
  <D.24133>:
  D.24130 = iftmp.96;
  return D.24130;
}


string_cmp (struct VerifyContext * ctx, const char * str, guint offset)
{
  int D.24180;
  int D.18673;
  int iftmp.98;
  int D.18672;
  const char[1] * D.24184;
  unsigned char D.24185;
  int D.24186;
  unsigned char D.24187;
  int D.24188;
  const unsigned char * D.24193;
  unsigned char D.24194;
  int D.24195;
  const unsigned char * D.24196;
  unsigned char D.24197;
  int D.24198;
  const unsigned char * D.24203;
  unsigned char D.24204;
  int D.24205;
  const unsigned char * D.24206;
  unsigned char D.24207;
  int D.24208;
  const unsigned char * D.24213;
  unsigned char D.24214;
  int D.24215;
  const unsigned char * D.24216;
  unsigned char D.24217;
  int D.24218;
  unsigned char D.24220;
  int D.18682;
  const char * D.24221;

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

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

      __s2 = str;
      D.24184 = "";
      D.24185 = MEM[(const unsigned char *)D.24184];
      D.24186 = (int) D.24185;
      D.24187 = *__s2;
      D.24188 = (int) D.24187;
      __result = D.24186 - D.24188;
      {
        if (__s2_len != 0) goto <D.24189>; else goto <D.24190>;
        <D.24189>:
        if (__result == 0) goto <D.24191>; else goto <D.24192>;
        <D.24191>:
        D.24193 = &MEM[(void *)"" + 1B];
        D.24194 = *D.24193;
        D.24195 = (int) D.24194;
        D.24196 = __s2 + 1;
        D.24197 = *D.24196;
        D.24198 = (int) D.24197;
        __result = D.24195 - D.24198;
        if (__s2_len > 1) goto <D.24199>; else goto <D.24200>;
        <D.24199>:
        if (__result == 0) goto <D.24201>; else goto <D.24202>;
        <D.24201>:
        D.24203 = &MEM[(void *)"" + 2B];
        D.24204 = *D.24203;
        D.24205 = (int) D.24204;
        D.24206 = __s2 + 2;
        D.24207 = *D.24206;
        D.24208 = (int) D.24207;
        __result = D.24205 - D.24208;
        if (__s2_len > 2) goto <D.24209>; else goto <D.24210>;
        <D.24209>:
        if (__result == 0) goto <D.24211>; else goto <D.24212>;
        <D.24211>:
        D.24213 = &MEM[(void *)"" + 3B];
        D.24214 = *D.24213;
        D.24215 = (int) D.24214;
        D.24216 = __s2 + 3;
        D.24217 = *D.24216;
        D.24218 = (int) D.24217;
        __result = D.24215 - D.24218;
        <D.24212>:
        <D.24210>:
        <D.24202>:
        <D.24200>:
        <D.24192>:
        <D.24190>:
      }
      D.18672 = __result;
    }
    iftmp.98 = -D.18672;
    goto <D.24219>;
    <D.24183>:
    D.24220 = MEM[(const unsigned char * {ref-all})str];
    iftmp.98 = (int) D.24220;
    <D.24219>:
    D.18673 = iftmp.98;
  }
  D.24180 = D.18673;
  return D.24180;
  <D.24179>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.24221 = get_string_ptr (ctx, offset);
    D.18682 = __builtin_strcmp (str, D.24221);
  }
  D.24180 = D.18682;
  return D.24180;
}


verify_field_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24223;
  unsigned int D.24226;
  int D.24228;
  int D.24229;
  gchar * D.24232;
  struct GSList * D.24233;
  struct GSList * D.24234;
  <unnamed-unsigned:24> D.24235;
  int D.24236;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24223 = ctx->image;
      table = &D.24223->tables[4];
      i = 0;
      goto <D.19353>;
      <D.19352>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24226 = data[2];
      if (D.24226 == 0) goto <D.24224>; else goto <D.24227>;
      <D.24227>:
      D.24226 = data[2];
      D.24228 = is_valid_field_signature (ctx, D.24226);
      if (D.24228 == 0) goto <D.24224>; else goto <D.24225>;
      <D.24224>:
      D.24229 = ctx->report_error;
      if (D.24229 != 0) goto <D.24230>; else goto <D.24231>;
      <D.24230>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24226 = data[2];
        D.24232 = monoeg_g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, D.24226);
        vinfo->info.message = D.24232;
        vinfo->exception_type = 3;
        D.24233 = ctx->errors;
        D.24234 = monoeg_g_slist_prepend (D.24233, vinfo);
        ctx->errors = D.24234;
      }
      <D.24231>:
      ctx->valid = 0;
      return;
      <D.24225>:
      i = i + 1;
      <D.19353>:
      D.24235 = table->rows;
      D.24236 = (int) D.24235;
      if (D.24236 > i) goto <D.19352>; else goto <D.19354>;
      <D.19354>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24240;
  int D.24243;
  gchar * D.24246;
  struct GSList * D.24247;
  struct GSList * D.24248;
  gboolean D.24249;
  const char * ptr.99;
  unsigned int size.100;
  sizetype D.24252;
  int D.24253;
  gchar * D.24258;
  struct GSList * D.24259;
  unsigned int signature.101;
  gchar * D.24265;
  struct GSList * D.24266;
  const char * ptr.102;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24240 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24240 == 0) goto <D.24241>; else goto <D.24242>;
      <D.24241>:
      D.24243 = ctx->report_error;
      if (D.24243 != 0) goto <D.24244>; else goto <D.24245>;
      <D.24244>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24246 = monoeg_strdup ("FieldSig: Could not decode signature header");
        vinfo->info.message = D.24246;
        vinfo->exception_type = 3;
        D.24247 = ctx->errors;
        D.24248 = monoeg_g_slist_prepend (D.24247, vinfo);
        ctx->errors = D.24248;
      }
      <D.24245>:
      ctx->valid = 0;
      D.24249 = 0;
      return D.24249;
      <D.24242>:
      ptr.99 = ptr;
      size.100 = size;
      D.24252 = (sizetype) size.100;
      end = ptr.99 + D.24252;
      D.24253 = safe_read (&ptr, end, &signature, 1);
      if (D.24253 == 0) goto <D.24254>; else goto <D.24255>;
      <D.24254>:
      D.24243 = ctx->report_error;
      if (D.24243 != 0) goto <D.24256>; else goto <D.24257>;
      <D.24256>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24258 = monoeg_strdup ("FieldSig: Not enough room for the signature");
        vinfo->info.message = D.24258;
        vinfo->exception_type = 3;
        D.24247 = ctx->errors;
        D.24259 = monoeg_g_slist_prepend (D.24247, vinfo);
        ctx->errors = D.24259;
      }
      <D.24257>:
      ctx->valid = 0;
      D.24249 = 0;
      return D.24249;
      <D.24255>:
      signature.101 = signature;
      if (signature.101 != 6) goto <D.24261>; else goto <D.24262>;
      <D.24261>:
      D.24243 = ctx->report_error;
      if (D.24243 != 0) goto <D.24263>; else goto <D.24264>;
      <D.24263>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        signature.101 = signature;
        D.24265 = monoeg_g_strdup_printf ("FieldSig: Invalid signature %x", signature.101);
        vinfo->info.message = D.24265;
        vinfo->exception_type = 3;
        D.24247 = ctx->errors;
        D.24266 = monoeg_g_slist_prepend (D.24247, vinfo);
        ctx->errors = D.24266;
      }
      <D.24264>:
      ctx->valid = 0;
      D.24249 = 0;
      return D.24249;
      <D.24262>:
      ptr.99 = ptr;
      ptr.102 = ptr.99 + 18446744073709551615;
      ptr = ptr.102;
      D.24249 = parse_field (ctx, &ptr, end);
      return D.24249;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_field (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.103;
  int D.24271;
  int D.24274;
  gchar * D.24277;
  struct GSList * D.24278;
  struct GSList * D.24279;
  gboolean D.24280;
  unsigned int signature.104;
  gchar * D.24286;
  struct GSList * D.24287;
  int D.24288;
  int D.24291;
  const char * ptr.105;
  const char * ptr.106;
  const char * ptr;
  unsigned int signature;

  try
    {
      ptr.103 = *_ptr;
      ptr = ptr.103;
      signature = 0;
      D.24271 = safe_read (&ptr, end, &signature, 1);
      if (D.24271 == 0) goto <D.24272>; else goto <D.24273>;
      <D.24272>:
      D.24274 = ctx->report_error;
      if (D.24274 != 0) goto <D.24275>; else goto <D.24276>;
      <D.24275>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24277 = monoeg_strdup ("Field: Not enough room for field signature");
        vinfo->info.message = D.24277;
        vinfo->exception_type = 3;
        D.24278 = ctx->errors;
        D.24279 = monoeg_g_slist_prepend (D.24278, vinfo);
        ctx->errors = D.24279;
      }
      <D.24276>:
      ctx->valid = 0;
      D.24280 = 0;
      return D.24280;
      <D.24273>:
      signature.104 = signature;
      if (signature.104 != 6) goto <D.24282>; else goto <D.24283>;
      <D.24282>:
      D.24274 = ctx->report_error;
      if (D.24274 != 0) goto <D.24284>; else goto <D.24285>;
      <D.24284>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        signature.104 = signature;
        D.24286 = monoeg_g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature.104);
        vinfo->info.message = D.24286;
        vinfo->exception_type = 3;
        D.24278 = ctx->errors;
        D.24287 = monoeg_g_slist_prepend (D.24278, vinfo);
        ctx->errors = D.24287;
      }
      <D.24285>:
      ctx->valid = 0;
      D.24280 = 0;
      return D.24280;
      <D.24283>:
      D.24288 = parse_custom_mods (ctx, &ptr, end);
      if (D.24288 == 0) goto <D.24289>; else goto <D.24290>;
      <D.24289>:
      D.24280 = 0;
      return D.24280;
      <D.24290>:
      D.24291 = safe_read (&ptr, end, &signature, 1);
      if (D.24291 != 0) goto <D.24292>; else goto <D.24293>;
      <D.24292>:
      signature.104 = signature;
      if (signature.104 != 16) goto <D.24294>; else goto <D.24295>;
      <D.24294>:
      ptr.105 = ptr;
      ptr.106 = ptr.105 + 18446744073709551615;
      ptr = ptr.106;
      <D.24295>:
      <D.24293>:
      ptr.105 = ptr;
      *_ptr = ptr.105;
      D.24280 = parse_type (ctx, _ptr, end);
      return D.24280;
    }
  finally
    {
      ptr = {CLOBBER};
      signature = {CLOBBER};
    }
}


verify_method_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24300;
  unsigned int D.24303;
  int D.24305;
  int D.24306;
  gchar * D.24309;
  struct GSList * D.24310;
  struct GSList * D.24311;
  int D.24314;
  gchar * D.24319;
  struct GSList * D.24320;
  <unnamed-unsigned:24> D.24321;
  int D.24322;
  struct MonoTableInfo * table;
  guint32 data[6];
  guint32 rva;
  guint32 locals_token;
  int i;

  try
    {
      D.24300 = ctx->image;
      table = &D.24300->tables[6];
      i = 0;
      goto <D.19433>;
      <D.19432>:
      mono_metadata_decode_row (table, i, &data, 6);
      rva = data[0];
      D.24303 = data[4];
      if (D.24303 == 0) goto <D.24301>; else goto <D.24304>;
      <D.24304>:
      D.24303 = data[4];
      D.24305 = is_valid_method_signature (ctx, D.24303);
      if (D.24305 == 0) goto <D.24301>; else goto <D.24302>;
      <D.24301>:
      D.24306 = ctx->report_error;
      if (D.24306 != 0) goto <D.24307>; else goto <D.24308>;
      <D.24307>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24303 = data[4];
        D.24309 = monoeg_g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, D.24303);
        vinfo->info.message = D.24309;
        vinfo->exception_type = 3;
        D.24310 = ctx->errors;
        D.24311 = monoeg_g_slist_prepend (D.24310, vinfo);
        ctx->errors = D.24311;
      }
      <D.24308>:
      ctx->valid = 0;
      return;
      <D.24302>:
      if (rva != 0) goto <D.24312>; else goto <D.24313>;
      <D.24312>:
      D.24314 = is_valid_method_header (ctx, rva, &locals_token);
      if (D.24314 == 0) goto <D.24315>; else goto <D.24316>;
      <D.24315>:
      D.24306 = ctx->report_error;
      if (D.24306 != 0) goto <D.24317>; else goto <D.24318>;
      <D.24317>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24319 = monoeg_g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i);
        vinfo->info.message = D.24319;
        vinfo->exception_type = 3;
        D.24310 = ctx->errors;
        D.24320 = monoeg_g_slist_prepend (D.24310, vinfo);
        ctx->errors = D.24320;
      }
      <D.24318>:
      ctx->valid = 0;
      return;
      <D.24316>:
      <D.24313>:
      i = i + 1;
      <D.19433>:
      D.24321 = table->rows;
      D.24322 = (int) D.24321;
      if (D.24322 > i) goto <D.19432>; else goto <D.19434>;
      <D.19434>:
    }
  finally
    {
      data = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


is_valid_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24326;
  int D.24329;
  gchar * D.24332;
  struct GSList * D.24333;
  struct GSList * D.24334;
  gboolean D.24335;
  const char * ptr.107;
  unsigned int size.108;
  sizetype D.24338;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.24326 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24326 == 0) goto <D.24327>; else goto <D.24328>;
      <D.24327>:
      D.24329 = ctx->report_error;
      if (D.24329 != 0) goto <D.24330>; else goto <D.24331>;
      <D.24330>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24332 = monoeg_strdup ("MethodSig: Could not decode signature header");
        vinfo->info.message = D.24332;
        vinfo->exception_type = 3;
        D.24333 = ctx->errors;
        D.24334 = monoeg_g_slist_prepend (D.24333, vinfo);
        ctx->errors = D.24334;
      }
      <D.24331>:
      ctx->valid = 0;
      D.24335 = 0;
      return D.24335;
      <D.24328>:
      ptr.107 = ptr;
      size.108 = size;
      D.24338 = (sizetype) size.108;
      end = ptr.107 + D.24338;
      D.24335 = parse_method_signature (ctx, &ptr, end, 0, 0);
      return D.24335;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_method_header (struct VerifyContext * ctx, guint32 rva, guint32 * locals_token)
{
  struct MonoImage * D.24341;
  int D.24344;
  gchar * D.24347;
  struct GSList * D.24348;
  struct GSList * D.24349;
  gboolean D.24350;
  const char * D.24351;
  sizetype D.24352;
  const char * ptr.109;
  unsigned int D.24354;
  sizetype D.24355;
  int D.24356;
  gchar * D.24361;
  struct GSList * D.24362;
  unsigned int header.110;
  unsigned int D.24364;
  gchar * D.24367;
  struct GSList * D.24368;
  unsigned int header.111;
  const char * ptr.112;
  sizetype D.24373;
  const char * D.24374;
  long unsigned int D.24376;
  long unsigned int D.24377;
  long unsigned int ptr.113;
  long int end.114;
  long int ptr.115;
  long int D.24383;
  int D.24384;
  gchar * D.24385;
  struct GSList * D.24386;
  const char * ptr.116;
  int D.24389;
  gchar * D.24394;
  struct GSList * D.24395;
  unsigned int fat_header.117;
  unsigned int D.24397;
  gchar * D.24402;
  struct GSList * D.24403;
  int D.24404;
  gchar * D.24409;
  struct GSList * D.24410;
  int D.24411;
  gchar * D.24416;
  struct GSList * D.24417;
  int D.24418;
  gchar * D.24423;
  struct GSList * D.24424;
  unsigned int local_vars_tok.118;
  unsigned int D.24428;
  gchar * D.24433;
  struct GSList * D.24434;
  unsigned int D.24435;
  <unnamed-unsigned:24> D.24436;
  unsigned int D.24437;
  gchar * D.24442;
  struct GSList * D.24443;
  gchar * D.24448;
  struct GSList * D.24449;
  unsigned int D.24450;
  gchar * D.24455;
  struct GSList * D.24456;
  unsigned int code_size.119;
  sizetype D.24460;
  const char * ptr.120;
  long unsigned int D.24463;
  long unsigned int D.24464;
  gchar * D.24467;
  struct GSList * D.24468;
  unsigned int D.24469;
  const char * ptr.121;
  int D.24473;
  gchar * D.24478;
  struct GSList * D.24479;
  unsigned int section_header.122;
  unsigned int D.24481;
  gchar * D.24486;
  struct GSList * D.24487;
  unsigned int D.24488;
  _Bool D.24489;
  unsigned int D.24490;
  unsigned int iftmp.123;
  gchar * D.24499;
  struct GSList * D.24500;
  unsigned int D.24503;
  sizetype D.24504;
  const char * D.24505;
  long unsigned int D.24507;
  long unsigned int D.24508;
  gchar * D.24511;
  struct GSList * D.24512;
  unsigned int D.24513;
  unsigned int iftmp.124;
  guint32 iftmp.125;
  unsigned int D.24524;
  guint32 iftmp.126;
  unsigned int D.24531;
  unsigned int D.24532;
  guint32 iftmp.127;
  unsigned int D.24541;
  gchar * D.24542;
  struct GSList * D.24543;
  unsigned char D.24544;
  sizetype iftmp.128;
  const char * ptr.129;
  int D.24550;
  gchar * D.24555;
  struct GSList * D.24556;
  unsigned int class_token.130;
  unsigned int D.24562;
  gchar * D.24569;
  struct GSList * D.24570;
  unsigned int D.24571;
  <unnamed-unsigned:24> D.24572;
  unsigned int D.24573;
  gchar * D.24578;
  struct GSList * D.24579;
  unsigned int D.24580;
  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.24341 = ctx->image;
      offset = mono_cli_rva_image_map (D.24341, rva);
      header = 0;
      fat_header = 0;
      size = 0;
      ptr = 0B;
      *locals_token = 0;
      if (offset == 4294967295) goto <D.24342>; else goto <D.24343>;
      <D.24342>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24345>; else goto <D.24346>;
      <D.24345>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24347 = monoeg_strdup ("MethodHeader: Invalid RVA");
        vinfo->info.message = D.24347;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24349 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24349;
      }
      <D.24346>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24343>:
      D.24351 = ctx->data;
      D.24352 = (sizetype) offset;
      ptr.109 = D.24351 + D.24352;
      ptr = ptr.109;
      D.24351 = ctx->data;
      D.24354 = ctx->size;
      D.24355 = (sizetype) D.24354;
      end = D.24351 + D.24355;
      D.24356 = safe_read (&ptr, end, &header, 1);
      if (D.24356 == 0) goto <D.24357>; else goto <D.24358>;
      <D.24357>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24359>; else goto <D.24360>;
      <D.24359>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24361 = monoeg_strdup ("MethodHeader: Not enough room for header");
        vinfo->info.message = D.24361;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24362 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24362;
      }
      <D.24360>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24358>:
      header.110 = header;
      D.24364 = header.110 & 3;
      switch (D.24364) <default: <D.24387>, case 0: <D.19219>, case 1: <D.19220>, case 2: <D.19222>>
      <D.19219>:
      <D.19220>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24365>; else goto <D.24366>;
      <D.24365>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        header.110 = header;
        D.24364 = header.110 & 3;
        D.24367 = monoeg_g_strdup_printf ("MethodHeader: Invalid header type 0x%x", D.24364);
        vinfo->info.message = D.24367;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24368 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24368;
      }
      <D.24366>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.19222>:
      header.110 = header;
      header.111 = header.110 >> 2;
      header = header.111;
      ptr.112 = ptr;
      header.110 = header;
      D.24373 = (sizetype) header.110;
      D.24374 = ptr.112 + D.24373;
      if (D.24374 > end) goto <D.24370>; else goto <D.24375>;
      <D.24375>:
      header.110 = header;
      D.24376 = (long unsigned int) header.110;
      D.24377 = ~D.24376;
      ptr.112 = ptr;
      ptr.113 = (long unsigned int) ptr.112;
      if (D.24377 < ptr.113) goto <D.24370>; else goto <D.24371>;
      <D.24370>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24379>; else goto <D.24380>;
      <D.24379>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        header.110 = header;
        end.114 = (long int) end;
        ptr.112 = ptr;
        ptr.115 = (long int) ptr.112;
        D.24383 = end.114 - ptr.115;
        D.24384 = (int) D.24383;
        D.24385 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header.110, D.24384);
        vinfo->info.message = D.24385;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24386 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24386;
      }
      <D.24380>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24371>:
      D.24350 = 1;
      return D.24350;
      <D.24387>:
      ptr.112 = ptr;
      ptr.116 = ptr.112 + 18446744073709551615;
      ptr = ptr.116;
      D.24389 = safe_read (&ptr, end, &fat_header, 2);
      if (D.24389 == 0) goto <D.24390>; else goto <D.24391>;
      <D.24390>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24392>; else goto <D.24393>;
      <D.24392>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24394 = monoeg_strdup ("MethodHeader: Not enough room for fat header");
        vinfo->info.message = D.24394;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24395 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24395;
      }
      <D.24393>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24391>:
      fat_header.117 = fat_header;
      D.24397 = fat_header.117 >> 12;
      size = D.24397 & 15;
      if (size != 3) goto <D.24398>; else goto <D.24399>;
      <D.24398>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24400>; else goto <D.24401>;
      <D.24400>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24402 = monoeg_strdup ("MethodHeader: header size must be 3");
        vinfo->info.message = D.24402;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24403 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24403;
      }
      <D.24401>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24399>:
      D.24404 = safe_read (&ptr, end, &max_stack, 2);
      if (D.24404 == 0) goto <D.24405>; else goto <D.24406>;
      <D.24405>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24407>; else goto <D.24408>;
      <D.24407>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24409 = monoeg_strdup ("MethodHeader: Not enough room for max stack");
        vinfo->info.message = D.24409;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24410 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24410;
      }
      <D.24408>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24406>:
      D.24411 = safe_read (&ptr, end, &code_size, 4);
      if (D.24411 == 0) goto <D.24412>; else goto <D.24413>;
      <D.24412>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24414>; else goto <D.24415>;
      <D.24414>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24416 = monoeg_strdup ("MethodHeader: Not enough room for code size");
        vinfo->info.message = D.24416;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24417 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24417;
      }
      <D.24415>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24413>:
      D.24418 = safe_read (&ptr, end, &local_vars_tok, 4);
      if (D.24418 == 0) goto <D.24419>; else goto <D.24420>;
      <D.24419>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24421>; else goto <D.24422>;
      <D.24421>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24423 = monoeg_strdup ("MethodHeader: Not enough room for local vars tok");
        vinfo->info.message = D.24423;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24424 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24424;
      }
      <D.24422>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24420>:
      local_vars_tok.118 = local_vars_tok;
      if (local_vars_tok.118 != 0) goto <D.24426>; else goto <D.24427>;
      <D.24426>:
      local_vars_tok.118 = local_vars_tok;
      D.24428 = local_vars_tok.118 >> 24;
      if (D.24428 != 17) goto <D.24429>; else goto <D.24430>;
      <D.24429>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24431>; else goto <D.24432>;
      <D.24431>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        local_vars_tok.118 = local_vars_tok;
        D.24428 = local_vars_tok.118 >> 24;
        D.24433 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", D.24428);
        vinfo->info.message = D.24433;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24434 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24434;
      }
      <D.24432>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24430>:
      local_vars_tok.118 = local_vars_tok;
      D.24435 = local_vars_tok.118 & 16777215;
      D.24341 = ctx->image;
      D.24436 = D.24341->tables[17].rows;
      D.24437 = (unsigned int) D.24436;
      if (D.24435 > D.24437) goto <D.24438>; else goto <D.24439>;
      <D.24438>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24440>; else goto <D.24441>;
      <D.24440>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        local_vars_tok.118 = local_vars_tok;
        D.24435 = local_vars_tok.118 & 16777215;
        D.24442 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", D.24435);
        vinfo->info.message = D.24442;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24443 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24443;
      }
      <D.24441>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24439>:
      local_vars_tok.118 = local_vars_tok;
      D.24435 = local_vars_tok.118 & 16777215;
      if (D.24435 == 0) goto <D.24444>; else goto <D.24445>;
      <D.24444>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24446>; else goto <D.24447>;
      <D.24446>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24448 = monoeg_g_strdup_printf ("MethodHeader: Invalid local vars signature with zero index");
        vinfo->info.message = D.24448;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24449 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24449;
      }
      <D.24447>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24445>:
      local_vars_tok.118 = local_vars_tok;
      D.24435 = local_vars_tok.118 & 16777215;
      *locals_token = D.24435;
      <D.24427>:
      fat_header.117 = fat_header;
      D.24450 = fat_header.117 & 4294905828;
      if (D.24450 != 0) goto <D.24451>; else goto <D.24452>;
      <D.24451>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24453>; else goto <D.24454>;
      <D.24453>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        fat_header.117 = fat_header;
        D.24450 = fat_header.117 & 4294905828;
        D.24455 = monoeg_g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", D.24450);
        vinfo->info.message = D.24455;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24456 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24456;
      }
      <D.24454>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24452>:
      ptr.112 = ptr;
      code_size.119 = code_size;
      D.24460 = (sizetype) code_size.119;
      ptr.120 = ptr.112 + D.24460;
      if (ptr.120 > end) goto <D.24457>; else goto <D.24462>;
      <D.24462>:
      code_size.119 = code_size;
      D.24463 = (long unsigned int) code_size.119;
      D.24464 = ~D.24463;
      ptr.112 = ptr;
      ptr.113 = (long unsigned int) ptr.112;
      if (D.24464 < ptr.113) goto <D.24457>; else goto <D.24458>;
      <D.24457>:
      D.24344 = ctx->report_error;
      if (D.24344 != 0) goto <D.24465>; else goto <D.24466>;
      <D.24465>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        code_size.119 = code_size;
        D.24467 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size.119);
        vinfo->info.message = D.24467;
        vinfo->exception_type = 3;
        D.24348 = ctx->errors;
        D.24468 = monoeg_g_slist_prepend (D.24348, vinfo);
        ctx->errors = D.24468;
      }
      <D.24466>:
      ctx->valid = 0;
      D.24350 = 0;
      return D.24350;
      <D.24458>:
      fat_header.117 = fat_header;
      D.24469 = fat_header.117 & 8;
      if (D.24469 == 0) goto <D.24470>; else goto <D.24471>;
      <D.24470>:
      D.24350 = 1;
      return D.24350;
      <D.24471>:
      ptr.112 = ptr;
      code_size.119 = code_size;
      D.24460 = (sizetype) code_size.119;
      ptr.120 = ptr.112 + D.24460;
      ptr = ptr.120;
      <D.19254>:
      {
        unsigned int section_header;
        unsigned int section_size;
        gboolean is_fat;

        try
          {
            section_header = 0;
            section_size = 0;
            ptr.112 = ptr;
            ptr.121 = dword_align (ptr.112);
            ptr = ptr.121;
            D.24473 = safe_read (&ptr, end, &section_header, 4);
            if (D.24473 == 0) goto <D.24474>; else goto <D.24475>;
            <D.24474>:
            D.24344 = ctx->report_error;
            if (D.24344 != 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 ("MethodHeader: Not enough room for data section header");
              vinfo->info.message = D.24478;
              vinfo->exception_type = 3;
              D.24348 = ctx->errors;
              D.24479 = monoeg_g_slist_prepend (D.24348, vinfo);
              ctx->errors = D.24479;
            }
            <D.24477>:
            ctx->valid = 0;
            D.24350 = 0;
            return D.24350;
            <D.24475>:
            section_header.122 = section_header;
            D.24481 = section_header.122 & 62;
            if (D.24481 != 0) goto <D.24482>; else goto <D.24483>;
            <D.24482>:
            D.24344 = ctx->report_error;
            if (D.24344 != 0) goto <D.24484>; else goto <D.24485>;
            <D.24484>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              section_header.122 = section_header;
              D.24481 = section_header.122 & 62;
              D.24486 = monoeg_g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", D.24481);
              vinfo->info.message = D.24486;
              vinfo->exception_type = 3;
              D.24348 = ctx->errors;
              D.24487 = monoeg_g_slist_prepend (D.24348, vinfo);
              ctx->errors = D.24487;
            }
            <D.24485>:
            ctx->valid = 0;
            D.24350 = 0;
            return D.24350;
            <D.24483>:
            section_header.122 = section_header;
            D.24488 = section_header.122 & 64;
            D.24489 = D.24488 != 0;
            is_fat = (gboolean) D.24489;
            section_header.122 = section_header;
            D.24490 = section_header.122 >> 8;
            if (is_fat != 0) goto <D.24492>; else goto <D.24493>;
            <D.24492>:
            iftmp.123 = 16777215;
            goto <D.24494>;
            <D.24493>:
            iftmp.123 = 255;
            <D.24494>:
            section_size = D.24490 & iftmp.123;
            if (section_size <= 3) goto <D.24495>; else goto <D.24496>;
            <D.24495>:
            D.24344 = ctx->report_error;
            if (D.24344 != 0) goto <D.24497>; else goto <D.24498>;
            <D.24497>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24499 = monoeg_g_strdup_printf ("MethodHeader: Section size too small");
              vinfo->info.message = D.24499;
              vinfo->exception_type = 3;
              D.24348 = ctx->errors;
              D.24500 = monoeg_g_slist_prepend (D.24348, vinfo);
              ctx->errors = D.24500;
            }
            <D.24498>:
            ctx->valid = 0;
            D.24350 = 0;
            return D.24350;
            <D.24496>:
            ptr.112 = ptr;
            D.24503 = section_size + 4294967292;
            D.24504 = (sizetype) D.24503;
            D.24505 = ptr.112 + D.24504;
            if (D.24505 > end) goto <D.24501>; else goto <D.24506>;
            <D.24506>:
            D.24503 = section_size + 4294967292;
            D.24507 = (long unsigned int) D.24503;
            D.24508 = ~D.24507;
            ptr.112 = ptr;
            ptr.113 = (long unsigned int) ptr.112;
            if (D.24508 < ptr.113) goto <D.24501>; else goto <D.24502>;
            <D.24501>:
            D.24344 = ctx->report_error;
            if (D.24344 != 0) goto <D.24509>; else goto <D.24510>;
            <D.24509>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24511 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size);
              vinfo->info.message = D.24511;
              vinfo->exception_type = 3;
              D.24348 = ctx->errors;
              D.24512 = monoeg_g_slist_prepend (D.24348, vinfo);
              ctx->errors = D.24512;
            }
            <D.24510>:
            ctx->valid = 0;
            D.24350 = 0;
            return D.24350;
            <D.24502>:
            section_header.122 = section_header;
            D.24513 = section_header.122 & 1;
            if (D.24513 != 0) goto <D.24514>; else goto <D.24515>;
            <D.24514>:
            {
              guint32 i;
              guint32 clauses;

              if (is_fat != 0) goto <D.24517>; else goto <D.24518>;
              <D.24517>:
              iftmp.124 = 24;
              goto <D.24519>;
              <D.24518>:
              iftmp.124 = 12;
              <D.24519>:
              clauses = section_size / iftmp.124;
              if (is_fat != 0) goto <D.24521>; else goto <D.24522>;
              <D.24521>:
              iftmp.125 = 24;
              goto <D.24523>;
              <D.24522>:
              iftmp.125 = 12;
              <D.24523>:
              D.24524 = iftmp.125 * clauses;
              if (D.24524 != section_size) goto <D.24525>; else goto <D.24526>;
              <D.24525>:
              if (is_fat != 0) goto <D.24528>; else goto <D.24529>;
              <D.24528>:
              iftmp.126 = 24;
              goto <D.24530>;
              <D.24529>:
              iftmp.126 = 12;
              <D.24530>:
              D.24531 = iftmp.126 * clauses;
              D.24532 = D.24531 + 4;
              if (D.24532 != section_size) goto <D.24533>; else goto <D.24534>;
              <D.24533>:
              D.24344 = ctx->report_error;
              if (D.24344 != 0) goto <D.24535>; else goto <D.24536>;
              <D.24535>:
              {
                struct MonoVerifyInfoExtended * vinfo;

                vinfo = monoeg_malloc (24);
                vinfo->info.status = 1;
                if (is_fat != 0) goto <D.24538>; else goto <D.24539>;
                <D.24538>:
                iftmp.127 = 24;
                goto <D.24540>;
                <D.24539>:
                iftmp.127 = 12;
                <D.24540>:
                D.24541 = iftmp.127 * clauses;
                D.24542 = monoeg_g_strdup_printf ("MethodHeader: Invalid EH section size %d, it\'s not of the expected size %d", section_size, D.24541);
                vinfo->info.message = D.24542;
                vinfo->exception_type = 3;
                D.24348 = ctx->errors;
                D.24543 = monoeg_g_slist_prepend (D.24348, vinfo);
                ctx->errors = D.24543;
              }
              <D.24536>:
              ctx->valid = 0;
              D.24350 = 0;
              return D.24350;
              <D.24534>:
              <D.24526>:
              i = 0;
              goto <D.19251>;
              <D.19250>:
              {
                unsigned int flags;
                unsigned int class_token;

                try
                  {
                    ptr.112 = ptr;
                    D.24544 = MEM[(unsigned char *)ptr.112];
                    flags = (unsigned int) D.24544;
                    class_token = 0;
                    ptr.112 = ptr;
                    if (is_fat != 0) goto <D.24546>; else goto <D.24547>;
                    <D.24546>:
                    iftmp.128 = 20;
                    goto <D.24548>;
                    <D.24547>:
                    iftmp.128 = 8;
                    <D.24548>:
                    ptr.129 = ptr.112 + iftmp.128;
                    ptr = ptr.129;
                    D.24550 = safe_read (&ptr, end, &class_token, 4);
                    if (D.24550 == 0) goto <D.24551>; else goto <D.24552>;
                    <D.24551>:
                    D.24344 = ctx->report_error;
                    if (D.24344 != 0) goto <D.24553>; else goto <D.24554>;
                    <D.24553>:
                    {
                      struct MonoVerifyInfoExtended * vinfo;

                      vinfo = monoeg_malloc (24);
                      vinfo->info.status = 1;
                      D.24555 = monoeg_g_strdup_printf ("MethodHeader: Not enough room for section %d", i);
                      vinfo->info.message = D.24555;
                      vinfo->exception_type = 3;
                      D.24348 = ctx->errors;
                      D.24556 = monoeg_g_slist_prepend (D.24348, vinfo);
                      ctx->errors = D.24556;
                    }
                    <D.24554>:
                    ctx->valid = 0;
                    D.24350 = 0;
                    return D.24350;
                    <D.24552>:
                    if (flags == 0) goto <D.24557>; else goto <D.24558>;
                    <D.24557>:
                    class_token.130 = class_token;
                    if (class_token.130 != 0) goto <D.24560>; else goto <D.24561>;
                    <D.24560>:
                    {
                      guint table;

                      class_token.130 = class_token;
                      table = class_token.130 >> 24;
                      D.24562 = table + 4294967295;
                      if (D.24562 > 1) goto <D.24563>; else goto <D.24564>;
                      <D.24563>:
                      if (table != 27) goto <D.24565>; else goto <D.24566>;
                      <D.24565>:
                      D.24344 = ctx->report_error;
                      if (D.24344 != 0) goto <D.24567>; else goto <D.24568>;
                      <D.24567>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (24);
                        vinfo->info.status = 1;
                        D.24569 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table);
                        vinfo->info.message = D.24569;
                        vinfo->exception_type = 3;
                        D.24348 = ctx->errors;
                        D.24570 = monoeg_g_slist_prepend (D.24348, vinfo);
                        ctx->errors = D.24570;
                      }
                      <D.24568>:
                      ctx->valid = 0;
                      D.24350 = 0;
                      return D.24350;
                      <D.24566>:
                      <D.24564>:
                      class_token.130 = class_token;
                      D.24571 = class_token.130 & 16777215;
                      D.24341 = ctx->image;
                      D.24572 = D.24341->tables[table].rows;
                      D.24573 = (unsigned int) D.24572;
                      if (D.24571 > D.24573) goto <D.24574>; else goto <D.24575>;
                      <D.24574>:
                      D.24344 = ctx->report_error;
                      if (D.24344 != 0) goto <D.24576>; else goto <D.24577>;
                      <D.24576>:
                      {
                        struct MonoVerifyInfoExtended * vinfo;

                        vinfo = monoeg_malloc (24);
                        vinfo->info.status = 1;
                        class_token.130 = class_token;
                        D.24571 = class_token.130 & 16777215;
                        D.24578 = monoeg_g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, D.24571);
                        vinfo->info.message = D.24578;
                        vinfo->exception_type = 3;
                        D.24348 = ctx->errors;
                        D.24579 = monoeg_g_slist_prepend (D.24348, vinfo);
                        ctx->errors = D.24579;
                      }
                      <D.24577>:
                      ctx->valid = 0;
                      D.24350 = 0;
                      return D.24350;
                      <D.24575>:
                    }
                    <D.24561>:
                    <D.24558>:
                  }
                finally
                  {
                    class_token = {CLOBBER};
                  }
              }
              i = i + 1;
              <D.19251>:
              if (i < clauses) goto <D.19250>; else goto <D.19252>;
              <D.19252>:
            }
            <D.24515>:
            section_header.122 = section_header;
            D.24580 = section_header.122 & 128;
            if (D.24580 == 0) goto <D.19253>; else goto <D.24581>;
            <D.24581>:
          }
        finally
          {
            section_header = {CLOBBER};
          }
      }
      goto <D.19254>;
      <D.19253>:
      D.24350 = 1;
      return D.24350;
    }
  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.24589;
  const char * D.24590;
  long unsigned int D.24591;
  long unsigned int D.24592;

  D.24590 = ptr + 3;
  D.24591 = (long unsigned int) D.24590;
  D.24592 = D.24591 & 18446744073709551612;
  D.24589 = (const char *) D.24592;
  return D.24589;
}


verify_memberref_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24594;
  unsigned int D.24595;
  int D.24596;
  int D.24599;
  gchar * D.24602;
  struct GSList * D.24603;
  struct GSList * D.24604;
  <unnamed-unsigned:24> D.24605;
  int D.24606;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.24594 = ctx->image;
      table = &D.24594->tables[10];
      i = 0;
      goto <D.19500>;
      <D.19499>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24595 = data[2];
      D.24596 = is_valid_method_or_field_signature (ctx, D.24595);
      if (D.24596 == 0) goto <D.24597>; else goto <D.24598>;
      <D.24597>:
      D.24599 = ctx->report_error;
      if (D.24599 != 0) goto <D.24600>; else goto <D.24601>;
      <D.24600>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24595 = data[2];
        D.24602 = monoeg_g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, D.24595);
        vinfo->info.message = D.24602;
        vinfo->exception_type = 3;
        D.24603 = ctx->errors;
        D.24604 = monoeg_g_slist_prepend (D.24603, vinfo);
        ctx->errors = D.24604;
      }
      <D.24601>:
      ctx->valid = 0;
      return;
      <D.24598>:
      i = i + 1;
      <D.19500>:
      D.24605 = table->rows;
      D.24606 = (int) D.24605;
      if (D.24606 > i) goto <D.19499>; else goto <D.19501>;
      <D.19501>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_method_or_field_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.24610;
  int D.24613;
  gchar * D.24616;
  struct GSList * D.24617;
  struct GSList * D.24618;
  gboolean D.24619;
  const char * ptr.131;
  unsigned int size.132;
  sizetype D.24622;
  int D.24623;
  gchar * D.24628;
  struct GSList * D.24629;
  const char * ptr.133;
  unsigned int signature.134;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.24610 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24610 == 0) goto <D.24611>; else goto <D.24612>;
      <D.24611>:
      D.24613 = ctx->report_error;
      if (D.24613 != 0) goto <D.24614>; else goto <D.24615>;
      <D.24614>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24616 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.24616;
        vinfo->exception_type = 3;
        D.24617 = ctx->errors;
        D.24618 = monoeg_g_slist_prepend (D.24617, vinfo);
        ctx->errors = D.24618;
      }
      <D.24615>:
      ctx->valid = 0;
      D.24619 = 0;
      return D.24619;
      <D.24612>:
      ptr.131 = ptr;
      size.132 = size;
      D.24622 = (sizetype) size.132;
      end = ptr.131 + D.24622;
      D.24623 = safe_read (&ptr, end, &signature, 1);
      if (D.24623 == 0) goto <D.24624>; else goto <D.24625>;
      <D.24624>:
      D.24613 = ctx->report_error;
      if (D.24613 != 0) goto <D.24626>; else goto <D.24627>;
      <D.24626>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24628 = monoeg_strdup ("MemberRefSig: Not enough room for the call conv");
        vinfo->info.message = D.24628;
        vinfo->exception_type = 3;
        D.24617 = ctx->errors;
        D.24629 = monoeg_g_slist_prepend (D.24617, vinfo);
        ctx->errors = D.24629;
      }
      <D.24627>:
      ctx->valid = 0;
      D.24619 = 0;
      return D.24619;
      <D.24625>:
      ptr.131 = ptr;
      ptr.133 = ptr.131 + 18446744073709551615;
      ptr = ptr.133;
      signature.134 = signature;
      if (signature.134 == 6) goto <D.24632>; else goto <D.24633>;
      <D.24632>:
      D.24619 = parse_field (ctx, &ptr, end);
      return D.24619;
      <D.24633>:
      D.24619 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.24619;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_cattr_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.24636;
  unsigned int D.24637;
  int D.24638;
  int D.24641;
  gchar * D.24644;
  struct GSList * D.24645;
  struct GSList * D.24646;
  unsigned int D.24647;
  unsigned int D.24648;
  gchar * D.24651;
  struct GSList * D.24652;
  int D.24653;
  _Bool D.24654;
  long int D.24655;
  long int D.24656;
  const char * ptr.135;
  unsigned int size.136;
  int D.24661;
  gchar * D.24666;
  struct GSList * D.24667;
  <unnamed-unsigned:24> D.24668;
  int D.24669;
  struct MonoTableInfo * table;
  struct MonoMethod * ctor;
  const char * ptr;
  guint32 data[3];
  guint32 mtoken;
  guint32 size;
  int i;

  try
    {
      D.24636 = ctx->image;
      table = &D.24636->tables[12];
      i = 0;
      goto <D.19546>;
      <D.19545>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.24637 = data[2];
      D.24638 = is_valid_cattr_blob (ctx, D.24637);
      if (D.24638 == 0) goto <D.24639>; else goto <D.24640>;
      <D.24639>:
      D.24641 = ctx->report_error;
      if (D.24641 != 0) goto <D.24642>; else goto <D.24643>;
      <D.24642>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24637 = data[2];
        D.24644 = monoeg_g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, D.24637);
        vinfo->info.message = D.24644;
        vinfo->exception_type = 3;
        D.24645 = ctx->errors;
        D.24646 = monoeg_g_slist_prepend (D.24645, vinfo);
        ctx->errors = D.24646;
      }
      <D.24643>:
      ctx->valid = 0;
      return;
      <D.24640>:
      D.24647 = data[1];
      mtoken = D.24647 >> 3;
      D.24647 = data[1];
      D.24648 = D.24647 & 7;
      switch (D.24648) <default: <D.19542>, case 2: <D.19539>, case 3: <D.19541>>
      <D.19539>:
      mtoken = mtoken | 100663296;
      goto <D.19540>;
      <D.19541>:
      mtoken = mtoken | 167772160;
      goto <D.19540>;
      <D.19542>:
      D.24641 = ctx->report_error;
      if (D.24641 != 0) goto <D.24649>; else goto <D.24650>;
      <D.24649>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24647 = data[1];
        D.24651 = monoeg_g_strdup_printf ("Invalid CustomAttribute constructor row %d Token 0x%08x", i, D.24647);
        vinfo->info.message = D.24651;
        vinfo->exception_type = 3;
        D.24645 = ctx->errors;
        D.24652 = monoeg_g_slist_prepend (D.24645, vinfo);
        ctx->errors = D.24652;
      }
      <D.24650>:
      ctx->valid = 0;
      return;
      <D.19540>:
      D.24636 = ctx->image;
      ctor = mono_get_method (D.24636, mtoken, 0B);
      D.24637 = data[2];
      D.24653 = decode_signature_header (ctx, D.24637, &size, &ptr);
      D.24654 = D.24653 == 0;
      D.24655 = (long int) D.24654;
      D.24656 = __builtin_expect (D.24655, 0);
      if (D.24656 != 0) goto <D.24657>; else goto <D.24658>;
      <D.24657>:
      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.24658>:
      ptr.135 = ptr;
      size.136 = size;
      D.24661 = is_valid_cattr_content (ctx, ctor, ptr.135, size.136);
      if (D.24661 == 0) goto <D.24662>; else goto <D.24663>;
      <D.24662>:
      D.24641 = ctx->report_error;
      if (D.24641 != 0) goto <D.24664>; else goto <D.24665>;
      <D.24664>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24637 = data[2];
        D.24666 = monoeg_g_strdup_printf ("Invalid CustomAttribute content row %d Value field 0x%08x", i, D.24637);
        vinfo->info.message = D.24666;
        vinfo->exception_type = 3;
        D.24645 = ctx->errors;
        D.24667 = monoeg_g_slist_prepend (D.24645, vinfo);
        ctx->errors = D.24667;
      }
      <D.24665>:
      ctx->valid = 0;
      return;
      <D.24663>:
      i = i + 1;
      <D.19546>:
      D.24668 = table->rows;
      D.24669 = (int) D.24668;
      if (D.24669 > i) goto <D.19545>; else goto <D.19547>;
      <D.19547>:
    }
  finally
    {
      ptr = {CLOBBER};
      data = {CLOBBER};
      size = {CLOBBER};
    }
}


is_valid_cattr_blob (struct VerifyContext * ctx, guint32 offset)
{
  gboolean D.24675;
  int D.24676;
  int D.24679;
  gchar * D.24682;
  struct GSList * D.24683;
  struct GSList * D.24684;
  const char * ptr.137;
  unsigned int size.138;
  sizetype D.24687;
  int D.24688;
  gchar * D.24693;
  struct GSList * D.24694;
  unsigned int prolog.139;
  gchar * D.24700;
  struct GSList * D.24701;
  guint32 size;
  unsigned int prolog;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      prolog = 0;
      ptr = 0B;
      if (offset == 0) goto <D.24673>; else goto <D.24674>;
      <D.24673>:
      D.24675 = 1;
      return D.24675;
      <D.24674>:
      D.24676 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.24676 == 0) goto <D.24677>; else goto <D.24678>;
      <D.24677>:
      D.24679 = ctx->report_error;
      if (D.24679 != 0) goto <D.24680>; else goto <D.24681>;
      <D.24680>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24682 = monoeg_strdup ("CustomAttribute: Could not decode signature header");
        vinfo->info.message = D.24682;
        vinfo->exception_type = 3;
        D.24683 = ctx->errors;
        D.24684 = monoeg_g_slist_prepend (D.24683, vinfo);
        ctx->errors = D.24684;
      }
      <D.24681>:
      ctx->valid = 0;
      D.24675 = 0;
      return D.24675;
      <D.24678>:
      ptr.137 = ptr;
      size.138 = size;
      D.24687 = (sizetype) size.138;
      end = ptr.137 + D.24687;
      D.24688 = safe_read (&ptr, end, &prolog, 2);
      if (D.24688 == 0) goto <D.24689>; else goto <D.24690>;
      <D.24689>:
      D.24679 = ctx->report_error;
      if (D.24679 != 0) goto <D.24691>; else goto <D.24692>;
      <D.24691>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24693 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.24693;
        vinfo->exception_type = 3;
        D.24683 = ctx->errors;
        D.24694 = monoeg_g_slist_prepend (D.24683, vinfo);
        ctx->errors = D.24694;
      }
      <D.24692>:
      ctx->valid = 0;
      D.24675 = 0;
      return D.24675;
      <D.24690>:
      prolog.139 = prolog;
      if (prolog.139 != 1) goto <D.24696>; else goto <D.24697>;
      <D.24696>:
      D.24679 = ctx->report_error;
      if (D.24679 != 0) goto <D.24698>; else goto <D.24699>;
      <D.24698>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        prolog.139 = prolog;
        D.24700 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.139);
        vinfo->info.message = D.24700;
        vinfo->exception_type = 3;
        D.24683 = ctx->errors;
        D.24701 = monoeg_g_slist_prepend (D.24683, vinfo);
        ctx->errors = D.24701;
      }
      <D.24699>:
      ctx->valid = 0;
      D.24675 = 0;
      return D.24675;
      <D.24697>:
      D.24675 = 1;
      return D.24675;
    }
  finally
    {
      size = {CLOBBER};
      prolog = {CLOBBER};
      ptr = {CLOBBER};
    }
}


is_valid_cattr_content (struct VerifyContext * ctx, struct MonoMethod * ctor, const char * ptr, guint32 size)
{
  int D.24706;
  gchar * D.24709;
  struct GSList * D.24710;
  struct GSList * D.24711;
  gboolean D.24712;
  int D.24713;
  const char * D.24718;
  gchar * D.24719;
  struct GSList * D.24720;
  short int D.24723;
  long unsigned int D.24725;
  long unsigned int D.24726;
  gchar * D.24729;
  struct GSList * D.24730;
  const char * ptr.140;
  sizetype D.24732;
  int D.24733;
  gchar * D.24738;
  struct GSList * D.24739;
  unsigned int prolog.141;
  gchar * D.24745;
  struct GSList * D.24746;
  short unsigned int D.24747;
  int D.24748;
  int D.24751;
  gchar * D.24756;
  struct GSList * D.24757;
  int D.24758;
  gchar * D.24763;
  struct GSList * D.24764;
  unsigned int kind.142;
  unsigned int D.24766;
  gchar * D.24771;
  struct GSList * D.24772;
  int D.24773;
  gchar * D.24778;
  struct GSList * D.24779;
  unsigned int D.24780;
  unsigned char D.24783;
  struct MonoClass * D.24792;
  struct MonoClass * D.24796;
  int D.24800;
  gchar * D.24805;
  struct GSList * D.24806;
  unsigned int etype.143;
  unsigned int D.24820;
  unsigned char iftmp.144;
  gchar * D.24828;
  struct GSList * D.24829;
  struct MonoClass * D.24830;
  gchar * D.24834;
  struct GSList * D.24835;
  int D.24836;
  int D.24839;
  unsigned int i.145;
  unsigned int num_named.146;
  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.24704>; else goto <D.24705>;
      <D.24704>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24707>; else goto <D.24708>;
      <D.24707>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24709 = monoeg_strdup ("CustomAttribute: Invalid constructor");
        vinfo->info.message = D.24709;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24711 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24711;
      }
      <D.24708>:
      ctx->valid = 0;
      D.24712 = 0;
      return D.24712;
      <D.24705>:
      sig = mono_method_signature_checked (ctor, &error);
      D.24713 = mono_error_ok (&error);
      if (D.24713 == 0) goto <D.24714>; else goto <D.24715>;
      <D.24714>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24716>; else goto <D.24717>;
      <D.24716>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24718 = mono_error_get_message (&error);
        D.24719 = monoeg_g_strdup_printf ("CustomAttribute: Invalid constructor signature %s", D.24718);
        vinfo->info.message = D.24719;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24720 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24720;
      }
      <D.24717>:
      ctx->valid = 0;
      mono_error_cleanup (&error);
      D.24712 = 0;
      return D.24712;
      <D.24715>:
      D.24723 = sig->sentinelpos;
      if (D.24723 != -1) goto <D.24721>; else goto <D.24724>;
      <D.24724>:
      D.24725 = BIT_FIELD_REF <*sig, 64, 64>;
      D.24726 = D.24725 & 17732923532771328;
      if (D.24726 == 1407374883553280) goto <D.24721>; else goto <D.24722>;
      <D.24721>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24727>; else goto <D.24728>;
      <D.24727>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24729 = monoeg_strdup ("CustomAttribute: Constructor cannot have VARAG signature");
        vinfo->info.message = D.24729;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24730 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24730;
      }
      <D.24728>:
      ctx->valid = 0;
      D.24712 = 0;
      return D.24712;
      <D.24722>:
      ptr.140 = ptr;
      D.24732 = (sizetype) size;
      end = ptr.140 + D.24732;
      D.24733 = safe_read (&ptr, end, &prolog, 2);
      if (D.24733 == 0) goto <D.24734>; else goto <D.24735>;
      <D.24734>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24736>; else goto <D.24737>;
      <D.24736>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24738 = monoeg_strdup ("CustomAttribute: Not enough room for prolog");
        vinfo->info.message = D.24738;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24739 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24739;
      }
      <D.24737>:
      ctx->valid = 0;
      D.24712 = 0;
      return D.24712;
      <D.24735>:
      prolog.141 = prolog;
      if (prolog.141 != 1) goto <D.24741>; else goto <D.24742>;
      <D.24741>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24743>; else goto <D.24744>;
      <D.24743>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        prolog.141 = prolog;
        D.24745 = monoeg_g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog.141);
        vinfo->info.message = D.24745;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24746 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24746;
      }
      <D.24744>:
      ctx->valid = 0;
      D.24712 = 0;
      return D.24712;
      <D.24742>:
      D.24747 = sig->param_count;
      args = (int) D.24747;
      i = 0;
      goto <D.19088>;
      <D.19087>:
      {
        struct MonoType * arg_type;

        arg_type = sig->params[i];
        D.24748 = is_valid_fixed_param (ctx, arg_type, &ptr, end);
        if (D.24748 == 0) goto <D.24749>; else goto <D.24750>;
        <D.24749>:
        D.24712 = 0;
        return D.24712;
        <D.24750>:
      }
      i = i + 1;
      <D.19088>:
      if (i < args) goto <D.19087>; else goto <D.19089>;
      <D.19089>:
      D.24751 = safe_read (&ptr, end, &num_named, 2);
      if (D.24751 == 0) goto <D.24752>; else goto <D.24753>;
      <D.24752>:
      D.24706 = ctx->report_error;
      if (D.24706 != 0) goto <D.24754>; else goto <D.24755>;
      <D.24754>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24756 = monoeg_strdup ("CustomAttribute: Not enough space for num_named field");
        vinfo->info.message = D.24756;
        vinfo->exception_type = 3;
        D.24710 = ctx->errors;
        D.24757 = monoeg_g_slist_prepend (D.24710, vinfo);
        ctx->errors = D.24757;
      }
      <D.24755>:
      ctx->valid = 0;
      D.24712 = 0;
      return D.24712;
      <D.24753>:
      i = 0;
      goto <D.19104>;
      <D.19103>:
      {
        struct MonoType * type;
        struct MonoType simple_type;
        unsigned int kind;

        try
          {
            simple_type = {};
            D.24758 = safe_read (&ptr, end, &kind, 1);
            if (D.24758 == 0) goto <D.24759>; else goto <D.24760>;
            <D.24759>:
            D.24706 = ctx->report_error;
            if (D.24706 != 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 ("CustomAttribute: Not enough space for named parameter %d kind", i);
              vinfo->info.message = D.24763;
              vinfo->exception_type = 3;
              D.24710 = ctx->errors;
              D.24764 = monoeg_g_slist_prepend (D.24710, vinfo);
              ctx->errors = D.24764;
            }
            <D.24762>:
            ctx->valid = 0;
            D.24712 = 0;
            return D.24712;
            <D.24760>:
            kind.142 = kind;
            D.24766 = kind.142 + 4294967213;
            if (D.24766 > 1) goto <D.24767>; else goto <D.24768>;
            <D.24767>:
            D.24706 = ctx->report_error;
            if (D.24706 != 0) goto <D.24769>; else goto <D.24770>;
            <D.24769>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              kind.142 = kind;
              D.24771 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter %d kind %x", i, kind.142);
              vinfo->info.message = D.24771;
              vinfo->exception_type = 3;
              D.24710 = ctx->errors;
              D.24772 = monoeg_g_slist_prepend (D.24710, vinfo);
              ctx->errors = D.24772;
            }
            <D.24770>:
            ctx->valid = 0;
            D.24712 = 0;
            return D.24712;
            <D.24768>:
            D.24773 = safe_read (&ptr, end, &kind, 1);
            if (D.24773 == 0) goto <D.24774>; else goto <D.24775>;
            <D.24774>:
            D.24706 = ctx->report_error;
            if (D.24706 != 0) goto <D.24776>; else goto <D.24777>;
            <D.24776>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24778 = monoeg_g_strdup_printf ("CustomAttribute: Not enough space for named parameter %d type", i);
              vinfo->info.message = D.24778;
              vinfo->exception_type = 3;
              D.24710 = ctx->errors;
              D.24779 = monoeg_g_slist_prepend (D.24710, vinfo);
              ctx->errors = D.24779;
            }
            <D.24777>:
            ctx->valid = 0;
            D.24712 = 0;
            return D.24712;
            <D.24775>:
            kind.142 = kind;
            D.24780 = kind.142 + 4294967294;
            if (D.24780 <= 12) goto <D.24781>; else goto <D.24782>;
            <D.24781>:
            kind.142 = kind;
            D.24783 = (unsigned char) kind.142;
            simple_type.type = D.24783;
            type = &simple_type;
            goto <D.24784>;
            <D.24782>:
            kind.142 = kind;
            if (kind.142 == 85) goto <D.24785>; else goto <D.24786>;
            <D.24785>:
            {
              struct MonoClass * klass;

              klass = get_enum_by_encoded_name (ctx, &ptr, end);
              if (klass == 0B) goto <D.24787>; else goto <D.24788>;
              <D.24787>:
              D.24712 = 0;
              return D.24712;
              <D.24788>:
              type = &klass->byval_arg;
            }
            goto <D.24789>;
            <D.24786>:
            kind.142 = kind;
            if (kind.142 == 80) goto <D.24790>; else goto <D.24791>;
            <D.24790>:
            D.24792 = mono_defaults.systemtype_class;
            type = &D.24792->byval_arg;
            goto <D.24793>;
            <D.24791>:
            kind.142 = kind;
            if (kind.142 == 81) goto <D.24794>; else goto <D.24795>;
            <D.24794>:
            D.24796 = mono_defaults.object_class;
            type = &D.24796->byval_arg;
            goto <D.24797>;
            <D.24795>:
            kind.142 = kind;
            if (kind.142 == 29) goto <D.24798>; else goto <D.24799>;
            <D.24798>:
            {
              struct MonoClass * klass;
              unsigned int etype;

              try
                {
                  etype = 0;
                  D.24800 = safe_read (&ptr, end, &etype, 1);
                  if (D.24800 == 0) goto <D.24801>; else goto <D.24802>;
                  <D.24801>:
                  D.24706 = ctx->report_error;
                  if (D.24706 != 0) goto <D.24803>; else goto <D.24804>;
                  <D.24803>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    D.24805 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24805;
                    vinfo->exception_type = 3;
                    D.24710 = ctx->errors;
                    D.24806 = monoeg_g_slist_prepend (D.24710, vinfo);
                    ctx->errors = D.24806;
                  }
                  <D.24804>:
                  ctx->valid = 0;
                  D.24712 = 0;
                  return D.24712;
                  <D.24802>:
                  etype.143 = etype;
                  if (etype.143 == 85) goto <D.24808>; else goto <D.24809>;
                  <D.24808>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24810>; else goto <D.24811>;
                  <D.24810>:
                  D.24712 = 0;
                  return D.24712;
                  <D.24811>:
                  goto <D.24812>;
                  <D.24809>:
                  etype.143 = etype;
                  if (etype.143 == 80) goto <D.24813>; else goto <D.24816>;
                  <D.24816>:
                  etype.143 = etype;
                  if (etype.143 == 18) goto <D.24813>; else goto <D.24814>;
                  <D.24813>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24815>;
                  <D.24814>:
                  etype.143 = etype;
                  D.24820 = etype.143 + 4294967294;
                  if (D.24820 <= 12) goto <D.24817>; else goto <D.24821>;
                  <D.24821>:
                  etype.143 = etype;
                  if (etype.143 == 81) goto <D.24817>; else goto <D.24818>;
                  <D.24817>:
                  etype.143 = etype;
                  if (etype.143 != 81) goto <D.24823>; else goto <D.24824>;
                  <D.24823>:
                  etype.143 = etype;
                  iftmp.144 = (unsigned char) etype.143;
                  goto <D.24825>;
                  <D.24824>:
                  iftmp.144 = 28;
                  <D.24825>:
                  simple_type.type = iftmp.144;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24819>;
                  <D.24818>:
                  D.24706 = ctx->report_error;
                  if (D.24706 != 0) goto <D.24826>; else goto <D.24827>;
                  <D.24826>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    etype.143 = etype;
                    D.24828 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.143);
                    vinfo->info.message = D.24828;
                    vinfo->exception_type = 3;
                    D.24710 = ctx->errors;
                    D.24829 = monoeg_g_slist_prepend (D.24710, vinfo);
                    ctx->errors = D.24829;
                  }
                  <D.24827>:
                  ctx->valid = 0;
                  D.24712 = 0;
                  return D.24712;
                  <D.24819>:
                  <D.24815>:
                  <D.24812>:
                  D.24830 = mono_array_class_get (klass, 1);
                  type = &D.24830->byval_arg;
                }
              finally
                {
                  etype = {CLOBBER};
                }
            }
            goto <D.24831>;
            <D.24799>:
            D.24706 = ctx->report_error;
            if (D.24706 != 0) goto <D.24832>; else goto <D.24833>;
            <D.24832>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              kind.142 = kind;
              D.24834 = monoeg_g_strdup_printf ("CustomAttribute: Invalid named parameter type %x", kind.142);
              vinfo->info.message = D.24834;
              vinfo->exception_type = 3;
              D.24710 = ctx->errors;
              D.24835 = monoeg_g_slist_prepend (D.24710, vinfo);
              ctx->errors = D.24835;
            }
            <D.24833>:
            ctx->valid = 0;
            D.24712 = 0;
            return D.24712;
            <D.24831>:
            <D.24797>:
            <D.24793>:
            <D.24789>:
            <D.24784>:
            D.24836 = is_valid_ser_string (ctx, &ptr, end);
            if (D.24836 == 0) goto <D.24837>; else goto <D.24838>;
            <D.24837>:
            D.24712 = 0;
            return D.24712;
            <D.24838>:
            D.24839 = is_valid_fixed_param (ctx, type, &ptr, end);
            if (D.24839 == 0) goto <D.24840>; else goto <D.24841>;
            <D.24840>:
            D.24712 = 0;
            return D.24712;
            <D.24841>:
          }
        finally
          {
            simple_type = {CLOBBER};
            kind = {CLOBBER};
          }
      }
      i = i + 1;
      <D.19104>:
      i.145 = (unsigned int) i;
      num_named.146 = num_named;
      if (i.145 < num_named.146) goto <D.19103>; else goto <D.19105>;
      <D.19105>:
      D.24712 = 1;
      return D.24712;
    }
  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.147;
  int D.24851;
  struct MonoClass * D.24854;
  const char * str_start.148;
  unsigned int str_len.149;
  int D.24860;
  gchar * D.24863;
  struct GSList * D.24864;
  struct GSList * D.24865;
  unsigned int D.24866;
  sizetype D.24867;
  char * D.24868;
  struct MonoImage * D.24869;
  gchar * D.24874;
  struct GSList * D.24875;
  long unsigned int D.24879;
  long unsigned int D.24880;
  const char * D.24883;
  const char * D.24884;
  gchar * D.24885;
  struct GSList * D.24886;
  const char * ptr.150;
  struct MonoType * type;
  struct MonoClass * klass;
  const char * str_start;
  const char * ptr;
  char * enum_name;
  guint32 str_len;

  try
    {
      str_start = 0B;
      ptr.147 = *_ptr;
      ptr = ptr.147;
      str_len = 0;
      D.24851 = is_valid_ser_string_full (ctx, &str_start, &str_len, &ptr, end);
      if (D.24851 == 0) goto <D.24852>; else goto <D.24853>;
      <D.24852>:
      D.24854 = 0B;
      return D.24854;
      <D.24853>:
      str_start.148 = str_start;
      if (str_start.148 == 0B) goto <D.24855>; else goto <D.24858>;
      <D.24858>:
      str_len.149 = str_len;
      if (str_len.149 == 0) goto <D.24855>; else goto <D.24856>;
      <D.24855>:
      D.24860 = ctx->report_error;
      if (D.24860 != 0) goto <D.24861>; else goto <D.24862>;
      <D.24861>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24863 = monoeg_strdup ("CustomAttribute: Null or empty enum name");
        vinfo->info.message = D.24863;
        vinfo->exception_type = 3;
        D.24864 = ctx->errors;
        D.24865 = monoeg_g_slist_prepend (D.24864, vinfo);
        ctx->errors = D.24865;
      }
      <D.24862>:
      ctx->valid = 0;
      D.24854 = 0B;
      return D.24854;
      <D.24856>:
      str_start.148 = str_start;
      str_len.149 = str_len;
      D.24866 = str_len.149 + 1;
      enum_name = monoeg_g_memdup (str_start.148, D.24866);
      str_len.149 = str_len;
      D.24867 = (sizetype) str_len.149;
      D.24868 = enum_name + D.24867;
      *D.24868 = 0;
      D.24869 = ctx->image;
      type = mono_reflection_type_from_name (enum_name, D.24869);
      if (type == 0B) goto <D.24870>; else goto <D.24871>;
      <D.24870>:
      D.24860 = ctx->report_error;
      if (D.24860 != 0) goto <D.24872>; else goto <D.24873>;
      <D.24872>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24874 = monoeg_g_strdup_printf ("CustomAttribute: Invalid enum class %s", enum_name);
        vinfo->info.message = D.24874;
        vinfo->exception_type = 3;
        D.24864 = ctx->errors;
        D.24875 = monoeg_g_slist_prepend (D.24864, vinfo);
        ctx->errors = D.24875;
      }
      <D.24873>:
      ctx->valid = 0;
      monoeg_g_free (enum_name);
      D.24854 = 0B;
      return D.24854;
      <D.24871>:
      monoeg_g_free (enum_name);
      klass = mono_class_from_mono_type (type);
      if (klass == 0B) goto <D.24876>; else goto <D.24878>;
      <D.24878>:
      D.24879 = BIT_FIELD_REF <*klass, 64, 256>;
      D.24880 = D.24879 & 16;
      if (D.24880 == 0) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      D.24860 = ctx->report_error;
      if (D.24860 != 0) goto <D.24881>; else goto <D.24882>;
      <D.24881>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24883 = klass->name_space;
        D.24884 = klass->name;
        D.24885 = monoeg_g_strdup_printf ("CustomAttribute:Class %s::%s is not an enum", D.24883, D.24884);
        vinfo->info.message = D.24885;
        vinfo->exception_type = 3;
        D.24864 = ctx->errors;
        D.24886 = monoeg_g_slist_prepend (D.24864, vinfo);
        ctx->errors = D.24886;
      }
      <D.24882>:
      ctx->valid = 0;
      D.24854 = 0B;
      return D.24854;
      <D.24877>:
      ptr.150 = ptr;
      *_ptr = ptr.150;
      D.24854 = klass;
      return D.24854;
    }
  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.151;
  const char * ptr.152;
  int D.24894;
  gchar * D.24897;
  struct GSList * D.24898;
  struct GSList * D.24899;
  gboolean D.24900;
  char D.24901;
  const char * D.24904;
  int D.24905;
  gchar * D.24910;
  struct GSList * D.24911;
  unsigned int size.153;
  sizetype D.24915;
  const char * D.24916;
  long unsigned int D.24918;
  long unsigned int D.24919;
  long unsigned int ptr.154;
  gchar * D.24923;
  struct GSList * D.24924;
  guint32 size;
  const char * ptr;

  try
    {
      size = 0;
      ptr.151 = *_ptr;
      ptr = ptr.151;
      *str_start = 0B;
      *str_len = 0;
      ptr.152 = ptr;
      if (ptr.152 >= end) goto <D.24892>; else goto <D.24893>;
      <D.24892>:
      D.24894 = ctx->report_error;
      if (D.24894 != 0) goto <D.24895>; else goto <D.24896>;
      <D.24895>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24897 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24897;
        vinfo->exception_type = 3;
        D.24898 = ctx->errors;
        D.24899 = monoeg_g_slist_prepend (D.24898, vinfo);
        ctx->errors = D.24899;
      }
      <D.24896>:
      ctx->valid = 0;
      D.24900 = 0;
      return D.24900;
      <D.24893>:
      ptr.152 = ptr;
      D.24901 = *ptr.152;
      if (D.24901 == 255) goto <D.24902>; else goto <D.24903>;
      <D.24902>:
      ptr.152 = ptr;
      D.24904 = ptr.152 + 1;
      *_ptr = D.24904;
      D.24900 = 1;
      return D.24900;
      <D.24903>:
      D.24905 = safe_read_compressed_int (&ptr, end, &size);
      if (D.24905 == 0) goto <D.24906>; else goto <D.24907>;
      <D.24906>:
      D.24894 = ctx->report_error;
      if (D.24894 != 0) goto <D.24908>; else goto <D.24909>;
      <D.24908>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24910 = monoeg_strdup ("CustomAttribute: Not enough room for string size");
        vinfo->info.message = D.24910;
        vinfo->exception_type = 3;
        D.24898 = ctx->errors;
        D.24911 = monoeg_g_slist_prepend (D.24898, vinfo);
        ctx->errors = D.24911;
      }
      <D.24909>:
      ctx->valid = 0;
      D.24900 = 0;
      return D.24900;
      <D.24907>:
      ptr.152 = ptr;
      size.153 = size;
      D.24915 = (sizetype) size.153;
      D.24916 = ptr.152 + D.24915;
      if (D.24916 > end) goto <D.24912>; else goto <D.24917>;
      <D.24917>:
      size.153 = size;
      D.24918 = (long unsigned int) size.153;
      D.24919 = ~D.24918;
      ptr.152 = ptr;
      ptr.154 = (long unsigned int) ptr.152;
      if (D.24919 < ptr.154) goto <D.24912>; else goto <D.24913>;
      <D.24912>:
      D.24894 = ctx->report_error;
      if (D.24894 != 0) goto <D.24921>; else goto <D.24922>;
      <D.24921>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24923 = monoeg_strdup ("CustomAttribute: Not enough room for string");
        vinfo->info.message = D.24923;
        vinfo->exception_type = 3;
        D.24898 = ctx->errors;
        D.24924 = monoeg_g_slist_prepend (D.24898, vinfo);
        ctx->errors = D.24924;
      }
      <D.24922>:
      ctx->valid = 0;
      D.24900 = 0;
      return D.24900;
      <D.24913>:
      ptr.152 = ptr;
      *str_start = ptr.152;
      size.153 = size;
      *str_len = size.153;
      ptr.152 = ptr;
      size.153 = size;
      D.24915 = (sizetype) size.153;
      D.24916 = ptr.152 + D.24915;
      *_ptr = D.24916;
      D.24900 = 1;
      return D.24900;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


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

  try
    {
      D.24927 = is_valid_ser_string_full (ctx, &dummy_str, &dummy_int, _ptr, end);
      return D.24927;
    }
  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.155;
  unsigned char D.24931;
  const char * ptr.156;
  gboolean D.24933;
  int D.24934;
  int D.24937;
  gchar * D.24940;
  struct GSList * D.24941;
  struct GSList * D.24942;
  unsigned int sub_type.157;
  unsigned int D.24944;
  unsigned char D.24951;
  int D.24956;
  gchar * D.24961;
  struct GSList * D.24962;
  unsigned int etype.158;
  unsigned int D.24976;
  unsigned char iftmp.159;
  gchar * D.24984;
  struct GSList * D.24985;
  gchar * D.24988;
  struct GSList * D.24989;
  struct MonoClass * D.24990;
  const char * D.24995;
  const char * D.24996;
  gchar * D.24997;
  struct GSList * D.24998;
  long unsigned int D.25002;
  long unsigned int D.25003;
  gchar * D.25006;
  struct GSList * D.25007;
  int D.25008;
  gchar * D.25013;
  struct GSList * D.25014;
  int D.25015;
  gchar * D.25020;
  struct GSList * D.25021;
  unsigned int element_count.160;
  int D.25025;
  gchar * D.25030;
  struct GSList * D.25031;
  sizetype D.25034;
  const char * D.25035;
  long unsigned int D.25037;
  long unsigned int D.25038;
  long unsigned int ptr.161;
  gchar * D.25042;
  struct GSList * D.25043;
  struct MonoClass * klass;
  const char * ptr;
  int elem_size;
  guint32 element_count;
  guint32 i;
  int type;
  void handle_enum = <<< error >>>;

  try
    {
      ptr.155 = *_ptr;
      ptr = ptr.155;
      elem_size = 0;
      klass = mono_type->data.klass;
      D.24931 = mono_type->type;
      type = (int) D.24931;
      handle_enum:
      switch (type) <default: <D.19065>, case 2: <D.19033>, case 3: <D.19039>, case 4: <D.19034>, case 5: <D.19035>, case 6: <D.19037>, case 7: <D.19038>, case 8: <D.19040>, case 9: <D.19041>, case 10: <D.19043>, case 11: <D.19044>, case 12: <D.19042>, case 13: <D.19045>, case 14: <D.19046>, case 17: <D.19057>, case 18: <D.19055>, case 28: <D.19047>, case 29: <D.19059>>
      <D.19033>:
      <D.19034>:
      <D.19035>:
      elem_size = 1;
      goto <D.19036>;
      <D.19037>:
      <D.19038>:
      <D.19039>:
      elem_size = 2;
      goto <D.19036>;
      <D.19040>:
      <D.19041>:
      <D.19042>:
      elem_size = 4;
      goto <D.19036>;
      <D.19043>:
      <D.19044>:
      <D.19045>:
      elem_size = 8;
      goto <D.19036>;
      <D.19046>:
      ptr.156 = ptr;
      *_ptr = ptr.156;
      D.24933 = is_valid_ser_string (ctx, _ptr, end);
      return D.24933;
      <D.19047>:
      {
        unsigned int sub_type;

        try
          {
            sub_type = 0;
            D.24934 = safe_read (&ptr, end, &sub_type, 1);
            if (D.24934 == 0) goto <D.24935>; else goto <D.24936>;
            <D.24935>:
            D.24937 = ctx->report_error;
            if (D.24937 != 0) goto <D.24938>; else goto <D.24939>;
            <D.24938>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              D.24940 = monoeg_strdup ("CustomAttribute: Not enough room for array type");
              vinfo->info.message = D.24940;
              vinfo->exception_type = 3;
              D.24941 = ctx->errors;
              D.24942 = monoeg_g_slist_prepend (D.24941, vinfo);
              ctx->errors = D.24942;
            }
            <D.24939>:
            ctx->valid = 0;
            D.24933 = 0;
            return D.24933;
            <D.24936>:
            sub_type.157 = sub_type;
            D.24944 = sub_type.157 + 4294967294;
            if (D.24944 <= 12) goto <D.24945>; else goto <D.24946>;
            <D.24945>:
            sub_type.157 = sub_type;
            type = (int) sub_type.157;
            goto handle_enum;
            <D.24946>:
            sub_type.157 = sub_type;
            if (sub_type.157 == 85) goto <D.24947>; else goto <D.24948>;
            <D.24947>:
            klass = get_enum_by_encoded_name (ctx, &ptr, end);
            if (klass == 0B) goto <D.24949>; else goto <D.24950>;
            <D.24949>:
            D.24933 = 0;
            return D.24933;
            <D.24950>:
            klass = klass->element_class;
            D.24951 = klass->byval_arg.type;
            type = (int) D.24951;
            goto handle_enum;
            <D.24948>:
            sub_type.157 = sub_type;
            if (sub_type.157 == 80) goto <D.24952>; else goto <D.24953>;
            <D.24952>:
            ptr.156 = ptr;
            *_ptr = ptr.156;
            D.24933 = is_valid_ser_string (ctx, _ptr, end);
            return D.24933;
            <D.24953>:
            sub_type.157 = sub_type;
            if (sub_type.157 == 29) goto <D.24954>; else goto <D.24955>;
            <D.24954>:
            {
              struct MonoType simple_type;
              unsigned int etype;

              try
                {
                  simple_type = {};
                  etype = 0;
                  D.24956 = safe_read (&ptr, end, &etype, 1);
                  if (D.24956 == 0) goto <D.24957>; else goto <D.24958>;
                  <D.24957>:
                  D.24937 = ctx->report_error;
                  if (D.24937 != 0) goto <D.24959>; else goto <D.24960>;
                  <D.24959>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    D.24961 = monoeg_strdup ("CustomAttribute: Not enough room for array element type");
                    vinfo->info.message = D.24961;
                    vinfo->exception_type = 3;
                    D.24941 = ctx->errors;
                    D.24962 = monoeg_g_slist_prepend (D.24941, vinfo);
                    ctx->errors = D.24962;
                  }
                  <D.24960>:
                  ctx->valid = 0;
                  D.24933 = 0;
                  return D.24933;
                  <D.24958>:
                  etype.158 = etype;
                  if (etype.158 == 85) goto <D.24964>; else goto <D.24965>;
                  <D.24964>:
                  klass = get_enum_by_encoded_name (ctx, &ptr, end);
                  if (klass == 0B) goto <D.24966>; else goto <D.24967>;
                  <D.24966>:
                  D.24933 = 0;
                  return D.24933;
                  <D.24967>:
                  goto <D.24968>;
                  <D.24965>:
                  etype.158 = etype;
                  if (etype.158 == 80) goto <D.24969>; else goto <D.24972>;
                  <D.24972>:
                  etype.158 = etype;
                  if (etype.158 == 18) goto <D.24969>; else goto <D.24970>;
                  <D.24969>:
                  klass = mono_defaults.systemtype_class;
                  goto <D.24971>;
                  <D.24970>:
                  etype.158 = etype;
                  D.24976 = etype.158 + 4294967294;
                  if (D.24976 <= 12) goto <D.24973>; else goto <D.24977>;
                  <D.24977>:
                  etype.158 = etype;
                  if (etype.158 == 81) goto <D.24973>; else goto <D.24974>;
                  <D.24973>:
                  etype.158 = etype;
                  if (etype.158 != 81) goto <D.24979>; else goto <D.24980>;
                  <D.24979>:
                  etype.158 = etype;
                  iftmp.159 = (unsigned char) etype.158;
                  goto <D.24981>;
                  <D.24980>:
                  iftmp.159 = 28;
                  <D.24981>:
                  simple_type.type = iftmp.159;
                  klass = mono_class_from_mono_type (&simple_type);
                  goto <D.24975>;
                  <D.24974>:
                  D.24937 = ctx->report_error;
                  if (D.24937 != 0) goto <D.24982>; else goto <D.24983>;
                  <D.24982>:
                  {
                    struct MonoVerifyInfoExtended * vinfo;

                    vinfo = monoeg_malloc (24);
                    vinfo->info.status = 1;
                    etype.158 = etype;
                    D.24984 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %x", etype.158);
                    vinfo->info.message = D.24984;
                    vinfo->exception_type = 3;
                    D.24941 = ctx->errors;
                    D.24985 = monoeg_g_slist_prepend (D.24941, vinfo);
                    ctx->errors = D.24985;
                  }
                  <D.24983>:
                  ctx->valid = 0;
                  D.24933 = 0;
                  return D.24933;
                  <D.24975>:
                  <D.24971>:
                  <D.24968>:
                  type = 29;
                  goto handle_enum;
                }
              finally
                {
                  simple_type = {CLOBBER};
                  etype = {CLOBBER};
                }
            }
            <D.24955>:
            D.24937 = ctx->report_error;
            if (D.24937 != 0) goto <D.24986>; else goto <D.24987>;
            <D.24986>:
            {
              struct MonoVerifyInfoExtended * vinfo;

              vinfo = monoeg_malloc (24);
              vinfo->info.status = 1;
              sub_type.157 = sub_type;
              D.24988 = monoeg_g_strdup_printf ("CustomAttribute: Invalid boxed object type %x", sub_type.157);
              vinfo->info.message = D.24988;
              vinfo->exception_type = 3;
              D.24941 = ctx->errors;
              D.24989 = monoeg_g_slist_prepend (D.24941, vinfo);
              ctx->errors = D.24989;
            }
            <D.24987>:
            ctx->valid = 0;
            D.24933 = 0;
            return D.24933;
          }
        finally
          {
            sub_type = {CLOBBER};
          }
      }
      <D.19055>:
      D.24990 = mono_defaults.systemtype_class;
      if (D.24990 != klass) goto <D.24991>; else goto <D.24992>;
      <D.24991>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.24993>; else goto <D.24994>;
      <D.24993>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24995 = klass->name_space;
        D.24996 = klass->name;
        D.24997 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24995, D.24996);
        vinfo->info.message = D.24997;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.24998 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.24998;
      }
      <D.24994>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.24992>:
      ptr.156 = ptr;
      *_ptr = ptr.156;
      D.24933 = is_valid_ser_string (ctx, _ptr, end);
      return D.24933;
      <D.19057>:
      if (klass == 0B) goto <D.24999>; else goto <D.25001>;
      <D.25001>:
      D.25002 = BIT_FIELD_REF <*klass, 64, 256>;
      D.25003 = D.25002 & 16;
      if (D.25003 == 0) goto <D.24999>; else goto <D.25000>;
      <D.24999>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.25004>; else goto <D.25005>;
      <D.25004>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24995 = klass->name_space;
        D.24996 = klass->name;
        D.25006 = monoeg_g_strdup_printf ("CustomAttribute: Invalid valuetype parameter expected enum %s:%s ", D.24995, D.24996);
        vinfo->info.message = D.25006;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.25007 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.25007;
      }
      <D.25005>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.25000>:
      klass = klass->element_class;
      D.24951 = klass->byval_arg.type;
      type = (int) D.24951;
      goto handle_enum;
      <D.19059>:
      mono_type = &klass->byval_arg;
      D.25008 = is_valid_cattr_type (mono_type);
      if (D.25008 == 0) goto <D.25009>; else goto <D.25010>;
      <D.25009>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.25011>; else goto <D.25012>;
      <D.25011>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24995 = klass->name_space;
        D.24996 = klass->name;
        D.25013 = monoeg_g_strdup_printf ("CustomAttribute: Invalid array element type %s:%s ", D.24995, D.24996);
        vinfo->info.message = D.25013;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.25014 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.25014;
      }
      <D.25012>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.25010>:
      D.25015 = safe_read (&ptr, end, &element_count, 4);
      if (D.25015 == 0) goto <D.25016>; else goto <D.25017>;
      <D.25016>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.25018>; else goto <D.25019>;
      <D.25018>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.24995 = klass->name_space;
        D.24996 = klass->name;
        D.25020 = monoeg_g_strdup_printf ("CustomAttribute: Invalid class parameter type %s:%s ", D.24995, D.24996);
        vinfo->info.message = D.25020;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.25021 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.25021;
      }
      <D.25019>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.25017>:
      element_count.160 = element_count;
      if (element_count.160 == 4294967295) goto <D.25023>; else goto <D.25024>;
      <D.25023>:
      ptr.156 = ptr;
      *_ptr = ptr.156;
      D.24933 = 1;
      return D.24933;
      <D.25024>:
      i = 0;
      goto <D.19063>;
      <D.19062>:
      D.25025 = is_valid_fixed_param (ctx, mono_type, &ptr, end);
      if (D.25025 == 0) goto <D.25026>; else goto <D.25027>;
      <D.25026>:
      D.24933 = 0;
      return D.24933;
      <D.25027>:
      i = i + 1;
      <D.19063>:
      element_count.160 = element_count;
      if (i < element_count.160) goto <D.19062>; else goto <D.19064>;
      <D.19064>:
      ptr.156 = ptr;
      *_ptr = ptr.156;
      D.24933 = 1;
      return D.24933;
      <D.19065>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.25028>; else goto <D.25029>;
      <D.25028>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25030 = monoeg_g_strdup_printf ("CustomAttribute: Invalid parameter type %x ", type);
        vinfo->info.message = D.25030;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.25031 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.25031;
      }
      <D.25029>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.19036>:
      ptr.156 = ptr;
      D.25034 = (sizetype) elem_size;
      D.25035 = ptr.156 + D.25034;
      if (D.25035 > end) goto <D.25032>; else goto <D.25036>;
      <D.25036>:
      D.25037 = (long unsigned int) elem_size;
      D.25038 = ~D.25037;
      ptr.156 = ptr;
      ptr.161 = (long unsigned int) ptr.156;
      if (D.25038 < ptr.161) goto <D.25032>; else goto <D.25033>;
      <D.25032>:
      D.24937 = ctx->report_error;
      if (D.24937 != 0) goto <D.25040>; else goto <D.25041>;
      <D.25040>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25042 = monoeg_strdup ("CustomAttribute: Not enough space for element");
        vinfo->info.message = D.25042;
        vinfo->exception_type = 3;
        D.24941 = ctx->errors;
        D.25043 = monoeg_g_slist_prepend (D.24941, vinfo);
        ctx->errors = D.25043;
      }
      <D.25041>:
      ctx->valid = 0;
      D.24933 = 0;
      return D.24933;
      <D.25033>:
      ptr.156 = ptr;
      D.25034 = (sizetype) elem_size;
      D.25035 = ptr.156 + D.25034;
      *_ptr = D.25035;
      D.24933 = 1;
      return D.24933;
    }
  finally
    {
      ptr = {CLOBBER};
      element_count = {CLOBBER};
    }
}


is_valid_cattr_type (struct MonoType * type)
{
  unsigned char D.25052;
  unsigned char D.25054;
  gboolean D.25055;
  int iftmp.162;
  long unsigned int D.25062;
  long unsigned int D.25063;
  struct MonoClass * D.25067;
  struct MonoClass * D.25068;
  _Bool D.25069;
  struct MonoClass * klass;

  D.25052 = type->type;
  if (D.25052 == 28) goto <D.25050>; else goto <D.25053>;
  <D.25053>:
  D.25052 = type->type;
  D.25054 = D.25052 + 254;
  if (D.25054 <= 12) goto <D.25050>; else goto <D.25051>;
  <D.25050>:
  D.25055 = 1;
  return D.25055;
  <D.25051>:
  D.25052 = type->type;
  if (D.25052 == 17) goto <D.25056>; else goto <D.25057>;
  <D.25056>:
  klass = mono_class_from_mono_type (type);
  if (klass != 0B) goto <D.25061>; else goto <D.25059>;
  <D.25061>:
  D.25062 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25063 = D.25062 & 16;
  if (D.25063 != 0) goto <D.25064>; else goto <D.25059>;
  <D.25064>:
  iftmp.162 = 1;
  goto <D.25060>;
  <D.25059>:
  iftmp.162 = 0;
  <D.25060>:
  D.25055 = iftmp.162;
  return D.25055;
  <D.25057>:
  D.25052 = type->type;
  if (D.25052 == 18) goto <D.25065>; else goto <D.25066>;
  <D.25065>:
  D.25067 = mono_class_from_mono_type (type);
  D.25068 = mono_defaults.systemtype_class;
  D.25069 = D.25067 == D.25068;
  D.25055 = (gboolean) D.25069;
  return D.25055;
  <D.25066>:
  D.25055 = 0;
  return D.25055;
}


verify_field_marshal_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25071;
  unsigned int D.25072;
  int D.25073;
  int D.25076;
  gchar * D.25079;
  struct GSList * D.25080;
  struct GSList * D.25081;
  <unnamed-unsigned:24> D.25082;
  int D.25083;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.25071 = ctx->image;
      table = &D.25071->tables[13];
      i = 0;
      goto <D.19569>;
      <D.19568>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25072 = data[1];
      D.25073 = is_valid_marshal_spec (ctx, D.25072);
      if (D.25073 == 0) goto <D.25074>; else goto <D.25075>;
      <D.25074>:
      D.25076 = ctx->report_error;
      if (D.25076 != 0) goto <D.25077>; else goto <D.25078>;
      <D.25077>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25072 = data[1];
        D.25079 = monoeg_g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, D.25072);
        vinfo->info.message = D.25079;
        vinfo->exception_type = 3;
        D.25080 = ctx->errors;
        D.25081 = monoeg_g_slist_prepend (D.25080, vinfo);
        ctx->errors = D.25081;
      }
      <D.25078>:
      ctx->valid = 0;
      return;
      <D.25075>:
      i = i + 1;
      <D.19569>:
      D.25082 = table->rows;
      D.25083 = (int) D.25082;
      if (D.25083 > i) goto <D.19568>; else goto <D.19570>;
      <D.19570>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_marshal_spec (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.25087;
  struct MonoStreamHeader * D.25088;
  gboolean D.25089;
  int iftmp.163;
  unsigned int D.25093;
  unsigned int D.25095;
  struct OffsetAndSize blob;

  try
    {
      D.25087 = ctx->image;
      D.25088 = &D.25087->heap_blob;
      blob = get_metadata_stream (ctx, D.25088);
      D.25093 = blob.size;
      if (D.25093 != 0) goto <D.25094>; else goto <D.25091>;
      <D.25094>:
      D.25093 = blob.size;
      D.25095 = D.25093 + 4294967295;
      if (D.25095 >= offset) goto <D.25096>; else goto <D.25091>;
      <D.25096>:
      iftmp.163 = 1;
      goto <D.25092>;
      <D.25091>:
      iftmp.163 = 0;
      <D.25092>:
      D.25089 = iftmp.163;
      return D.25089;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_decl_security_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25099;
  unsigned int D.25100;
  int D.25101;
  int D.25104;
  gchar * D.25107;
  struct GSList * D.25108;
  struct GSList * D.25109;
  <unnamed-unsigned:24> D.25110;
  int D.25111;
  struct MonoTableInfo * table;
  guint32 data[3];
  int i;

  try
    {
      D.25099 = ctx->image;
      table = &D.25099->tables[14];
      i = 0;
      goto <D.19591>;
      <D.19590>:
      mono_metadata_decode_row (table, i, &data, 3);
      D.25100 = data[2];
      D.25101 = is_valid_permission_set (ctx, D.25100);
      if (D.25101 == 0) goto <D.25102>; else goto <D.25103>;
      <D.25102>:
      D.25104 = ctx->report_error;
      if (D.25104 != 0) goto <D.25105>; else goto <D.25106>;
      <D.25105>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25100 = data[2];
        D.25107 = monoeg_g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, D.25100);
        vinfo->info.message = D.25107;
        vinfo->exception_type = 3;
        D.25108 = ctx->errors;
        D.25109 = monoeg_g_slist_prepend (D.25108, vinfo);
        ctx->errors = D.25109;
      }
      <D.25106>:
      ctx->valid = 0;
      return;
      <D.25103>:
      i = i + 1;
      <D.19591>:
      D.25110 = table->rows;
      D.25111 = (int) D.25110;
      if (D.25111 > i) goto <D.19590>; else goto <D.19592>;
      <D.19592>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_permission_set (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.25115;
  struct MonoStreamHeader * D.25116;
  gboolean D.25117;
  int iftmp.164;
  unsigned int D.25121;
  unsigned int D.25123;
  struct OffsetAndSize blob;

  try
    {
      D.25115 = ctx->image;
      D.25116 = &D.25115->heap_blob;
      blob = get_metadata_stream (ctx, D.25116);
      D.25121 = blob.size;
      if (D.25121 != 0) goto <D.25122>; else goto <D.25119>;
      <D.25122>:
      D.25121 = blob.size;
      D.25123 = D.25121 + 4294967295;
      if (D.25123 >= offset) goto <D.25124>; else goto <D.25119>;
      <D.25124>:
      iftmp.164 = 1;
      goto <D.25120>;
      <D.25119>:
      iftmp.164 = 0;
      <D.25120>:
      D.25117 = iftmp.164;
      return D.25117;
    }
  finally
    {
      blob = {CLOBBER};
    }
}


verify_standalonesig_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25127;
  unsigned int D.25128;
  int D.25129;
  int D.25132;
  gchar * D.25135;
  struct GSList * D.25136;
  struct GSList * D.25137;
  <unnamed-unsigned:24> D.25138;
  int D.25139;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.25127 = ctx->image;
      table = &D.25127->tables[17];
      i = 0;
      goto <D.19643>;
      <D.19642>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.25128 = data[0];
      D.25129 = is_valid_standalonesig_blob (ctx, D.25128);
      if (D.25129 == 0) goto <D.25130>; else goto <D.25131>;
      <D.25130>:
      D.25132 = ctx->report_error;
      if (D.25132 != 0) goto <D.25133>; else goto <D.25134>;
      <D.25133>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25128 = data[0];
        D.25135 = monoeg_g_strdup_printf ("Invalid StandAloneSig row %d Signature field 0x%08x", i, D.25128);
        vinfo->info.message = D.25135;
        vinfo->exception_type = 3;
        D.25136 = ctx->errors;
        D.25137 = monoeg_g_slist_prepend (D.25136, vinfo);
        ctx->errors = D.25137;
      }
      <D.25134>:
      ctx->valid = 0;
      return;
      <D.25131>:
      i = i + 1;
      <D.19643>:
      D.25138 = table->rows;
      D.25139 = (int) D.25138;
      if (D.25139 > i) goto <D.19642>; else goto <D.19644>;
      <D.19644>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_standalonesig_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.25143;
  int D.25146;
  gchar * D.25149;
  struct GSList * D.25150;
  struct GSList * D.25151;
  gboolean D.25152;
  const char * ptr.165;
  unsigned int size.166;
  sizetype D.25155;
  int D.25156;
  gchar * D.25161;
  struct GSList * D.25162;
  const char * ptr.167;
  unsigned int signature.168;
  guint32 size;
  unsigned int signature;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      signature = 0;
      ptr = 0B;
      D.25143 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25143 == 0) goto <D.25144>; else goto <D.25145>;
      <D.25144>:
      D.25146 = ctx->report_error;
      if (D.25146 != 0) goto <D.25147>; else goto <D.25148>;
      <D.25147>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25149 = monoeg_strdup ("StandAloneSig: Could not decode signature header");
        vinfo->info.message = D.25149;
        vinfo->exception_type = 3;
        D.25150 = ctx->errors;
        D.25151 = monoeg_g_slist_prepend (D.25150, vinfo);
        ctx->errors = D.25151;
      }
      <D.25148>:
      ctx->valid = 0;
      D.25152 = 0;
      return D.25152;
      <D.25145>:
      ptr.165 = ptr;
      size.166 = size;
      D.25155 = (sizetype) size.166;
      end = ptr.165 + D.25155;
      D.25156 = safe_read (&ptr, end, &signature, 1);
      if (D.25156 == 0) goto <D.25157>; else goto <D.25158>;
      <D.25157>:
      D.25146 = ctx->report_error;
      if (D.25146 != 0) goto <D.25159>; else goto <D.25160>;
      <D.25159>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25161 = monoeg_strdup ("StandAloneSig: Not enough room for the call conv");
        vinfo->info.message = D.25161;
        vinfo->exception_type = 3;
        D.25150 = ctx->errors;
        D.25162 = monoeg_g_slist_prepend (D.25150, vinfo);
        ctx->errors = D.25162;
      }
      <D.25160>:
      ctx->valid = 0;
      D.25152 = 0;
      return D.25152;
      <D.25158>:
      ptr.165 = ptr;
      ptr.167 = ptr.165 + 18446744073709551615;
      ptr = ptr.167;
      signature.168 = signature;
      if (signature.168 == 7) goto <D.25165>; else goto <D.25166>;
      <D.25165>:
      D.25152 = parse_locals_signature (ctx, &ptr, end);
      return D.25152;
      <D.25166>:
      signature.168 = signature;
      if (signature.168 == 6) goto <D.25167>; else goto <D.25168>;
      <D.25167>:
      D.25152 = parse_field (ctx, &ptr, end);
      return D.25152;
      <D.25168>:
      D.25152 = parse_method_signature (ctx, &ptr, end, 1, 1);
      return D.25152;
    }
  finally
    {
      size = {CLOBBER};
      signature = {CLOBBER};
      ptr = {CLOBBER};
    }
}


parse_locals_signature (struct VerifyContext * ctx, const char * * _ptr, const char * end)
{
  const char * ptr.169;
  int D.25172;
  int D.25175;
  gchar * D.25178;
  struct GSList * D.25179;
  struct GSList * D.25180;
  gboolean D.25181;
  unsigned int sig.170;
  gchar * D.25187;
  struct GSList * D.25188;
  int D.25189;
  gchar * D.25194;
  struct GSList * D.25195;
  int D.25196;
  gchar * D.25201;
  struct GSList * D.25202;
  int D.25205;
  gchar * D.25210;
  struct GSList * D.25211;
  int D.25212;
  gchar * D.25217;
  struct GSList * D.25218;
  unsigned int D.25219;
  int D.25223;
  gchar * D.25228;
  struct GSList * D.25229;
  gchar * D.25234;
  struct GSList * D.25235;
  const char * ptr.171;
  const char * ptr.172;
  int D.25240;
  gchar * D.25245;
  struct GSList * D.25246;
  unsigned int locals_count.173;
  unsigned int sig;
  unsigned int locals_count;
  unsigned int i;
  const char * ptr;

  try
    {
      sig = 0;
      locals_count = 0;
      ptr.169 = *_ptr;
      ptr = ptr.169;
      D.25172 = safe_read (&ptr, end, &sig, 1);
      if (D.25172 == 0) goto <D.25173>; else goto <D.25174>;
      <D.25173>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25176>; else goto <D.25177>;
      <D.25176>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25178 = monoeg_strdup ("LocalsSig: Not enough room for signature");
        vinfo->info.message = D.25178;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25180 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25180;
      }
      <D.25177>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25174>:
      sig.170 = sig;
      if (sig.170 != 7) goto <D.25183>; else goto <D.25184>;
      <D.25183>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25185>; else goto <D.25186>;
      <D.25185>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        sig.170 = sig;
        D.25187 = monoeg_g_strdup_printf ("LocalsSig: Signature is not 0x28 or 0x08: %x", sig.170);
        vinfo->info.message = D.25187;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25188 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25188;
      }
      <D.25186>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25184>:
      D.25189 = safe_read_compressed_int (&ptr, end, &locals_count);
      if (D.25189 == 0) goto <D.25190>; else goto <D.25191>;
      <D.25190>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25192>; else goto <D.25193>;
      <D.25192>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25194 = monoeg_strdup ("LocalsSig: Not enough room for the param count");
        vinfo->info.message = D.25194;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25195 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25195;
      }
      <D.25193>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25191>:
      i = 0;
      goto <D.18933>;
      <D.18932>:
      D.25196 = safe_read (&ptr, end, &sig, 1);
      if (D.25196 == 0) goto <D.25197>; else goto <D.25198>;
      <D.25197>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25199>; else goto <D.25200>;
      <D.25199>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25201 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.25201;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25202 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25202;
      }
      <D.25200>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25198>:
      goto <D.18926>;
      <D.18925>:
      sig.170 = sig;
      if (sig.170 != 69) goto <D.25203>; else goto <D.25204>;
      <D.25203>:
      D.25205 = parse_custom_mods (ctx, &ptr, end);
      if (D.25205 == 0) goto <D.25206>; else goto <D.25207>;
      <D.25206>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25208>; else goto <D.25209>;
      <D.25208>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25210 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.25210;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25211 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25211;
      }
      <D.25209>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25207>:
      <D.25204>:
      D.25212 = safe_read (&ptr, end, &sig, 1);
      if (D.25212 == 0) goto <D.25213>; else goto <D.25214>;
      <D.25213>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25215>; else goto <D.25216>;
      <D.25215>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25217 = monoeg_strdup ("LocalsSig: Not enough room for type");
        vinfo->info.message = D.25217;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25218 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25218;
      }
      <D.25216>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25214>:
      <D.18926>:
      sig.170 = sig;
      D.25219 = sig.170 + 4294967265;
      if (D.25219 <= 1) goto <D.18925>; else goto <D.25220>;
      <D.25220>:
      sig.170 = sig;
      if (sig.170 == 69) goto <D.18925>; else goto <D.18927>;
      <D.18927>:
      sig.170 = sig;
      if (sig.170 == 16) goto <D.25221>; else goto <D.25222>;
      <D.25221>:
      D.25223 = safe_read (&ptr, end, &sig, 1);
      if (D.25223 == 0) goto <D.25224>; else goto <D.25225>;
      <D.25224>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25226>; else goto <D.25227>;
      <D.25226>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25228 = monoeg_g_strdup_printf ("Type: Not enough room for byref type for local %d", i);
        vinfo->info.message = D.25228;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25229 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25229;
      }
      <D.25227>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25225>:
      sig.170 = sig;
      if (sig.170 == 22) goto <D.25230>; else goto <D.25231>;
      <D.25230>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25232>; else goto <D.25233>;
      <D.25232>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25234 = monoeg_g_strdup_printf ("Type: Invalid type typedref& for local %d", i);
        vinfo->info.message = D.25234;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25235 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25235;
      }
      <D.25233>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25231>:
      <D.25222>:
      sig.170 = sig;
      if (sig.170 == 22) goto <D.25236>; else goto <D.25237>;
      <D.25236>:
      // predicted unlikely by continue predictor.
      goto <D.18930>;
      <D.25237>:
      ptr.171 = ptr;
      ptr.172 = ptr.171 + 18446744073709551615;
      ptr = ptr.172;
      D.25240 = parse_type (ctx, &ptr, end);
      if (D.25240 == 0) goto <D.25241>; else goto <D.25242>;
      <D.25241>:
      D.25175 = ctx->report_error;
      if (D.25175 != 0) goto <D.25243>; else goto <D.25244>;
      <D.25243>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25245 = monoeg_g_strdup_printf ("LocalsSig: Error parsing local %d", i);
        vinfo->info.message = D.25245;
        vinfo->exception_type = 3;
        D.25179 = ctx->errors;
        D.25246 = monoeg_g_slist_prepend (D.25179, vinfo);
        ctx->errors = D.25246;
      }
      <D.25244>:
      ctx->valid = 0;
      D.25181 = 0;
      return D.25181;
      <D.25242>:
      <D.18930>:
      i = i + 1;
      <D.18933>:
      locals_count.173 = locals_count;
      if (i < locals_count.173) goto <D.18932>; else goto <D.18934>;
      <D.18934>:
      ptr.171 = ptr;
      *_ptr = ptr.171;
      D.25181 = 1;
      return D.25181;
    }
  finally
    {
      sig = {CLOBBER};
      locals_count = {CLOBBER};
      ptr = {CLOBBER};
    }
}


verify_event_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25250;
  unsigned int i.174;
  int D.25254;
  gchar * D.25257;
  struct GSList * D.25258;
  struct GSList * D.25259;
  int D.25260;
  unsigned int D.25261;
  unsigned int D.25263;
  unsigned int D.25265;
  unsigned int D.25266;
  unsigned int D.25269;
  <unnamed-unsigned:24> D.25275;
  int D.25276;
  gchar * D.25281;
  struct GSList * D.25282;
  gchar * D.25287;
  struct GSList * D.25288;
  <unnamed-unsigned:24> D.25289;
  int D.25290;
  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.25250 = ctx->image;
      table = &D.25250->tables[20];
      D.25250 = ctx->image;
      sema_table = &D.25250->tables[24];
      i = 0;
      goto <D.19691>;
      <D.19690>:
      mono_metadata_decode_row (table, i, &data, 3);
      i.174 = (unsigned int) i;
      token = make_coded_token (48, 20, i.174);
      idx = search_sorted_table (ctx, 24, 2, token);
      if (idx == -1) goto <D.25252>; else goto <D.25253>;
      <D.25252>:
      D.25254 = ctx->report_error;
      if (D.25254 != 0) goto <D.25255>; else goto <D.25256>;
      <D.25255>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25257 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn or RemoveOn associated methods", i);
        vinfo->info.message = D.25257;
        vinfo->exception_type = 3;
        D.25258 = ctx->errors;
        D.25259 = monoeg_g_slist_prepend (D.25258, vinfo);
        ctx->errors = D.25259;
      }
      <D.25256>:
      ctx->valid = 0;
      return;
      <D.25253>:
      goto <D.19684>;
      <D.19683>:
      D.25260 = idx + -1;
      D.25261 = mono_metadata_decode_row_col (sema_table, D.25260, 2);
      if (D.25261 != token) goto <D.19682>; else goto <D.25262>;
      <D.25262>:
      idx = idx + -1;
      <D.19684>:
      if (idx > 0) goto <D.19683>; else goto <D.19682>;
      <D.19682>:
      found_remove = 0;
      found_add = found_remove;
      goto <D.19687>;
      <D.19686>:
      mono_metadata_decode_row (sema_table, idx, &sema_data, 3);
      D.25263 = sema_data[2];
      if (D.25263 != token) goto <D.19685>; else goto <D.25264>;
      <D.25264>:
      D.25265 = sema_data[0];
      D.25266 = D.25265 & 8;
      if (D.25266 != 0) goto <D.25267>; else goto <D.25268>;
      <D.25267>:
      found_add = 1;
      <D.25268>:
      D.25265 = sema_data[0];
      D.25269 = D.25265 & 16;
      if (D.25269 != 0) goto <D.25270>; else goto <D.25271>;
      <D.25270>:
      found_remove = 1;
      <D.25271>:
      if (found_add != 0) goto <D.25272>; else goto <D.25273>;
      <D.25272>:
      if (found_remove != 0) goto <D.19685>; else goto <D.25274>;
      <D.25274>:
      <D.25273>:
      idx = idx + 1;
      <D.19687>:
      D.25275 = sema_table->rows;
      D.25276 = (int) D.25275;
      if (D.25276 > idx) goto <D.19686>; else goto <D.19685>;
      <D.19685>:
      if (found_add == 0) goto <D.25277>; else goto <D.25278>;
      <D.25277>:
      D.25254 = ctx->report_error;
      if (D.25254 != 0) goto <D.25279>; else goto <D.25280>;
      <D.25279>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25281 = monoeg_g_strdup_printf ("Invalid Event row %d has no AddOn associated method", i);
        vinfo->info.message = D.25281;
        vinfo->exception_type = 3;
        D.25258 = ctx->errors;
        D.25282 = monoeg_g_slist_prepend (D.25258, vinfo);
        ctx->errors = D.25282;
      }
      <D.25280>:
      ctx->valid = 0;
      return;
      <D.25278>:
      if (found_remove == 0) goto <D.25283>; else goto <D.25284>;
      <D.25283>:
      D.25254 = ctx->report_error;
      if (D.25254 != 0) goto <D.25285>; else goto <D.25286>;
      <D.25285>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25287 = monoeg_g_strdup_printf ("Invalid Event row %d has no RemoveOn associated method", i);
        vinfo->info.message = D.25287;
        vinfo->exception_type = 3;
        D.25258 = ctx->errors;
        D.25288 = monoeg_g_slist_prepend (D.25258, vinfo);
        ctx->errors = D.25288;
      }
      <D.25286>:
      ctx->valid = 0;
      return;
      <D.25284>:
      i = i + 1;
      <D.19691>:
      D.25289 = table->rows;
      D.25290 = (int) D.25289;
      if (D.25290 > i) goto <D.19690>; else goto <D.19692>;
      <D.19692>:
    }
  finally
    {
      data = {CLOBBER};
      sema_data = {CLOBBER};
    }
}


verify_typespec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25294;
  int D.25295;
  int D.25296;
  unsigned int D.25297;
  unsigned int D.25298;
  int D.25299;
  int D.25302;
  gchar * D.25305;
  struct GSList * D.25306;
  struct GSList * D.25307;
  <unnamed-unsigned:24> D.25308;
  int D.25309;
  struct MonoTableInfo * table;
  guint32 data[1];
  int i;

  try
    {
      D.25294 = ctx->image;
      table = &D.25294->tables[27];
      i = 0;
      goto <D.19760>;
      <D.19759>:
      mono_metadata_decode_row (table, i, &data, 1);
      D.25295 = i + 1;
      D.25296 = D.25295 | 452984832;
      D.25297 = (unsigned int) D.25296;
      ctx->token = D.25297;
      D.25298 = data[0];
      D.25299 = is_valid_typespec_blob (ctx, D.25298);
      if (D.25299 == 0) goto <D.25300>; else goto <D.25301>;
      <D.25300>:
      D.25302 = ctx->report_error;
      if (D.25302 != 0) goto <D.25303>; else goto <D.25304>;
      <D.25303>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25298 = data[0];
        D.25305 = monoeg_g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, D.25298);
        vinfo->info.message = D.25305;
        vinfo->exception_type = 3;
        D.25306 = ctx->errors;
        D.25307 = monoeg_g_slist_prepend (D.25306, vinfo);
        ctx->errors = D.25307;
      }
      <D.25304>:
      ctx->valid = 0;
      return;
      <D.25301>:
      i = i + 1;
      <D.19760>:
      D.25308 = table->rows;
      D.25309 = (int) D.25308;
      if (D.25309 > i) goto <D.19759>; else goto <D.19761>;
      <D.19761>:
      ctx->token = 0;
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_typespec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.25313;
  int D.25316;
  gchar * D.25319;
  struct GSList * D.25320;
  struct GSList * D.25321;
  gboolean D.25322;
  const char * ptr.175;
  unsigned int size.176;
  sizetype D.25325;
  int D.25326;
  int D.25329;
  gchar * D.25334;
  struct GSList * D.25335;
  unsigned int type.177;
  int D.25339;
  gchar * D.25344;
  struct GSList * D.25345;
  gchar * D.25350;
  struct GSList * D.25351;
  const char * ptr.178;
  guint32 size;
  const char * ptr;
  const char * end;
  unsigned int type;

  try
    {
      size = 0;
      ptr = 0B;
      type = 0;
      D.25313 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25313 == 0) goto <D.25314>; else goto <D.25315>;
      <D.25314>:
      D.25316 = ctx->report_error;
      if (D.25316 != 0) goto <D.25317>; else goto <D.25318>;
      <D.25317>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25319 = monoeg_strdup ("TypeSpec: Could not decode signature header");
        vinfo->info.message = D.25319;
        vinfo->exception_type = 3;
        D.25320 = ctx->errors;
        D.25321 = monoeg_g_slist_prepend (D.25320, vinfo);
        ctx->errors = D.25321;
      }
      <D.25318>:
      ctx->valid = 0;
      D.25322 = 0;
      return D.25322;
      <D.25315>:
      ptr.175 = ptr;
      size.176 = size;
      D.25325 = (sizetype) size.176;
      end = ptr.175 + D.25325;
      D.25326 = parse_custom_mods (ctx, &ptr, end);
      if (D.25326 == 0) goto <D.25327>; else goto <D.25328>;
      <D.25327>:
      D.25322 = 0;
      return D.25322;
      <D.25328>:
      D.25329 = safe_read (&ptr, end, &type, 1);
      if (D.25329 == 0) goto <D.25330>; else goto <D.25331>;
      <D.25330>:
      D.25316 = ctx->report_error;
      if (D.25316 != 0) goto <D.25332>; else goto <D.25333>;
      <D.25332>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25334 = monoeg_strdup ("TypeSpec: Not enough room for type");
        vinfo->info.message = D.25334;
        vinfo->exception_type = 3;
        D.25320 = ctx->errors;
        D.25335 = monoeg_g_slist_prepend (D.25320, vinfo);
        ctx->errors = D.25335;
      }
      <D.25333>:
      ctx->valid = 0;
      D.25322 = 0;
      return D.25322;
      <D.25331>:
      type.177 = type;
      if (type.177 == 16) goto <D.25337>; else goto <D.25338>;
      <D.25337>:
      D.25339 = safe_read (&ptr, end, &type, 1);
      if (D.25339 == 0) goto <D.25340>; else goto <D.25341>;
      <D.25340>:
      D.25316 = ctx->report_error;
      if (D.25316 != 0) goto <D.25342>; else goto <D.25343>;
      <D.25342>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25344 = monoeg_strdup ("TypeSpec: Not enough room for byref type");
        vinfo->info.message = D.25344;
        vinfo->exception_type = 3;
        D.25320 = ctx->errors;
        D.25345 = monoeg_g_slist_prepend (D.25320, vinfo);
        ctx->errors = D.25345;
      }
      <D.25343>:
      ctx->valid = 0;
      D.25322 = 0;
      return D.25322;
      <D.25341>:
      type.177 = type;
      if (type.177 == 22) goto <D.25346>; else goto <D.25347>;
      <D.25346>:
      D.25316 = ctx->report_error;
      if (D.25316 != 0) goto <D.25348>; else goto <D.25349>;
      <D.25348>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25350 = monoeg_strdup ("TypeSpec: Invalid type typedref&");
        vinfo->info.message = D.25350;
        vinfo->exception_type = 3;
        D.25320 = ctx->errors;
        D.25351 = monoeg_g_slist_prepend (D.25320, vinfo);
        ctx->errors = D.25351;
      }
      <D.25349>:
      ctx->valid = 0;
      D.25322 = 0;
      return D.25322;
      <D.25347>:
      <D.25338>:
      type.177 = type;
      if (type.177 == 22) goto <D.25352>; else goto <D.25353>;
      <D.25352>:
      D.25322 = 1;
      return D.25322;
      <D.25353>:
      ptr.175 = ptr;
      ptr.178 = ptr.175 + 18446744073709551615;
      ptr = ptr.178;
      D.25322 = parse_type (ctx, &ptr, end);
      return D.25322;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
      type = {CLOBBER};
    }
}


verify_method_spec_table_full (struct VerifyContext * ctx)
{
  struct MonoImage * D.25357;
  unsigned int D.25358;
  int D.25359;
  int D.25362;
  gchar * D.25365;
  struct GSList * D.25366;
  struct GSList * D.25367;
  <unnamed-unsigned:24> D.25368;
  int D.25369;
  struct MonoTableInfo * table;
  guint32 data[2];
  int i;

  try
    {
      D.25357 = ctx->image;
      table = &D.25357->tables[43];
      i = 0;
      goto <D.19918>;
      <D.19917>:
      mono_metadata_decode_row (table, i, &data, 2);
      D.25358 = data[1];
      D.25359 = is_valid_methodspec_blob (ctx, D.25358);
      if (D.25359 == 0) goto <D.25360>; else goto <D.25361>;
      <D.25360>:
      D.25362 = ctx->report_error;
      if (D.25362 != 0) goto <D.25363>; else goto <D.25364>;
      <D.25363>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25358 = data[1];
        D.25365 = monoeg_g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, D.25358);
        vinfo->info.message = D.25365;
        vinfo->exception_type = 3;
        D.25366 = ctx->errors;
        D.25367 = monoeg_g_slist_prepend (D.25366, vinfo);
        ctx->errors = D.25367;
      }
      <D.25364>:
      ctx->valid = 0;
      return;
      <D.25361>:
      i = i + 1;
      <D.19918>:
      D.25368 = table->rows;
      D.25369 = (int) D.25368;
      if (D.25369 > i) goto <D.19917>; else goto <D.19919>;
      <D.19919>:
    }
  finally
    {
      data = {CLOBBER};
    }
}


is_valid_methodspec_blob (struct VerifyContext * ctx, guint32 offset)
{
  int D.25373;
  int D.25376;
  gchar * D.25379;
  struct GSList * D.25380;
  struct GSList * D.25381;
  gboolean D.25382;
  const char * ptr.179;
  unsigned int size.180;
  sizetype D.25385;
  int D.25386;
  gchar * D.25391;
  struct GSList * D.25392;
  unsigned int type.181;
  gchar * D.25398;
  struct GSList * D.25399;
  int D.25400;
  gchar * D.25405;
  struct GSList * D.25406;
  unsigned int count.182;
  gchar * D.25412;
  struct GSList * D.25413;
  int D.25414;
  int D.25417;
  unsigned int D.25422;
  gchar * D.25423;
  struct GSList * D.25424;
  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.25373 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25373 == 0) goto <D.25374>; else goto <D.25375>;
      <D.25374>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25377>; else goto <D.25378>;
      <D.25377>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25379 = monoeg_strdup ("MethodSpec: Could not decode signature header");
        vinfo->info.message = D.25379;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25381 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25381;
      }
      <D.25378>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25375>:
      ptr.179 = ptr;
      size.180 = size;
      D.25385 = (sizetype) size.180;
      end = ptr.179 + D.25385;
      D.25386 = safe_read (&ptr, end, &type, 1);
      if (D.25386 == 0) goto <D.25387>; else goto <D.25388>;
      <D.25387>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25389>; else goto <D.25390>;
      <D.25389>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25391 = monoeg_strdup ("MethodSpec: Not enough room for call convention");
        vinfo->info.message = D.25391;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25392 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25392;
      }
      <D.25390>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25388>:
      type.181 = type;
      if (type.181 != 10) goto <D.25394>; else goto <D.25395>;
      <D.25394>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25396>; else goto <D.25397>;
      <D.25396>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        type.181 = type;
        D.25398 = monoeg_g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type.181);
        vinfo->info.message = D.25398;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25399 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25399;
      }
      <D.25397>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25395>:
      D.25400 = safe_read_compressed_int (&ptr, end, &count);
      if (D.25400 == 0) goto <D.25401>; else goto <D.25402>;
      <D.25401>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25403>; else goto <D.25404>;
      <D.25403>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25405 = monoeg_strdup ("MethodSpec: Not enough room for parameter count");
        vinfo->info.message = D.25405;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25406 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25406;
      }
      <D.25404>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25402>:
      count.182 = count;
      if (count.182 == 0) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25410>; else goto <D.25411>;
      <D.25410>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25412 = monoeg_strdup ("MethodSpec: Zero generic argument count");
        vinfo->info.message = D.25412;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25413 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25413;
      }
      <D.25411>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25409>:
      i = 0;
      goto <D.19163>;
      <D.19162>:
      D.25414 = parse_custom_mods (ctx, &ptr, end);
      if (D.25414 == 0) goto <D.25415>; else goto <D.25416>;
      <D.25415>:
      D.25382 = 0;
      return D.25382;
      <D.25416>:
      D.25417 = parse_type (ctx, &ptr, end);
      if (D.25417 == 0) goto <D.25418>; else goto <D.25419>;
      <D.25418>:
      D.25376 = ctx->report_error;
      if (D.25376 != 0) goto <D.25420>; else goto <D.25421>;
      <D.25420>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25422 = i + 1;
        D.25423 = monoeg_g_strdup_printf ("MethodSpec: Could not parse parameter %d", D.25422);
        vinfo->info.message = D.25423;
        vinfo->exception_type = 3;
        D.25380 = ctx->errors;
        D.25424 = monoeg_g_slist_prepend (D.25380, vinfo);
        ctx->errors = D.25424;
      }
      <D.25421>:
      ctx->valid = 0;
      D.25382 = 0;
      return D.25382;
      <D.25419>:
      i = i + 1;
      <D.19163>:
      count.182 = count;
      if (i < count.182) goto <D.19162>; else goto <D.19164>;
      <D.19164>:
      D.25382 = 1;
      return D.25382;
    }
  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.25427;
  <unnamed-unsigned:24> D.25428;
  unsigned int D.25429;
  struct MonoTableInfo * table;
  struct MonoError error;
  guint32 i;

  try
    {
      D.25427 = ctx->image;
      table = &D.25427->tables[1];
      i = 0;
      goto <D.19272>;
      <D.19271>:
      D.25427 = ctx->image;
      mono_verifier_verify_typeref_row (D.25427, i, &error);
      add_from_mono_error (ctx, &error);
      i = i + 1;
      <D.19272>:
      D.25428 = table->rows;
      D.25429 = (unsigned int) D.25428;
      if (D.25429 > i) goto <D.19271>; else goto <D.19273>;
      <D.19273>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


add_from_mono_error (struct VerifyContext * ctx, struct MonoError * error)
{
  int D.25430;
  int D.25433;
  const char * D.25436;
  gchar * D.25437;
  struct GSList * D.25438;
  struct GSList * D.25439;

  D.25430 = mono_error_ok (error);
  if (D.25430 != 0) goto <D.25431>; else goto <D.25432>;
  <D.25431>:
  return;
  <D.25432>:
  D.25433 = ctx->report_error;
  if (D.25433 != 0) goto <D.25434>; else goto <D.25435>;
  <D.25434>:
  {
    struct MonoVerifyInfoExtended * vinfo;

    vinfo = monoeg_malloc (24);
    vinfo->info.status = 1;
    D.25436 = mono_error_get_message (error);
    D.25437 = monoeg_strdup (D.25436);
    vinfo->info.message = D.25437;
    vinfo->exception_type = 3;
    D.25438 = ctx->errors;
    D.25439 = monoeg_g_slist_prepend (D.25438, vinfo);
    ctx->errors = D.25439;
  }
  <D.25435>:
  ctx->valid = 0;
  return;
  mono_error_cleanup (error);
}


verify_typeref_table_global_constraints (struct VerifyContext * ctx)
{
  struct MonoImage * D.25441;
  unsigned int D.25442;
  unsigned int D.25443;
  const char * D.25444;
  unsigned int D.25445;
  const char * D.25446;
  void * D.25447;
  int D.25450;
  const char * D.25453;
  const char * D.25454;
  unsigned int D.25455;
  gchar * D.25456;
  struct GSList * D.25457;
  struct GSList * D.25458;
  <unnamed-unsigned:24> D.25459;
  int D.25460;
  int i;
  guint32 data[3];
  struct MonoTableInfo * table;
  struct GHashTable * unique_types;

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

        type = monoeg_malloc (24);
        mono_metadata_decode_row (table, i, &data, 3);
        D.25442 = data[0];
        type->resolution_scope = D.25442;
        D.25441 = ctx->image;
        D.25443 = data[1];
        D.25444 = mono_metadata_string_heap (D.25441, D.25443);
        type->name = D.25444;
        D.25441 = ctx->image;
        D.25445 = data[2];
        D.25446 = mono_metadata_string_heap (D.25441, D.25445);
        type->name_space = D.25446;
        D.25447 = monoeg_g_hash_table_lookup (unique_types, type);
        if (D.25447 != 0B) goto <D.25448>; else goto <D.25449>;
        <D.25448>:
        D.25450 = ctx->report_error;
        if (D.25450 != 0) goto <D.25451>; else goto <D.25452>;
        <D.25451>:
        {
          struct MonoVerifyInfoExtended * vinfo;

          vinfo = monoeg_malloc (24);
          vinfo->info.status = 1;
          D.25453 = type->name;
          D.25454 = type->name_space;
          D.25455 = type->resolution_scope;
          D.25456 = monoeg_g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, D.25453, D.25454, D.25455);
          vinfo->info.message = D.25456;
          vinfo->exception_type = 3;
          D.25457 = ctx->errors;
          D.25458 = monoeg_g_slist_prepend (D.25457, vinfo);
          ctx->errors = D.25458;
        }
        <D.25452>:
        ctx->valid = 0;
        monoeg_g_hash_table_destroy (unique_types);
        monoeg_g_free (type);
        return;
        <D.25449>:
        monoeg_g_hash_table_insert_replace (unique_types, type, 1B, 0);
      }
      i = i + 1;
      <D.19995>:
      D.25459 = table->rows;
      D.25460 = (int) D.25459;
      if (D.25460 > i) goto <D.19994>; else goto <D.19996>;
      <D.19996>:
      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.25464;
  gboolean D.25467;
  _Bool D.25468;
  int D.25469;
  struct VerifyContext ctx;

  try
    {
      D.25464 = mono_verifier_is_enabled_for_image (image);
      if (D.25464 == 0) goto <D.25465>; else goto <D.25466>;
      <D.25465>:
      D.25467 = 1;
      return D.25467;
      <D.25466>:
      D.25468 = error_list != 0B;
      D.25469 = (int) D.25468;
      init_verify_context (&ctx, image, D.25469);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.25467 = cleanup_context (&ctx, error_list);
      return D.25467;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_method_header (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25472;
  gboolean D.25475;
  _Bool D.25476;
  int D.25477;
  unsigned int locals_token.183;
  struct MonoTableInfo * D.25481;
  unsigned int D.25482;
  int D.25483;
  struct VerifyContext ctx;
  guint32 locals_token;

  try
    {
      D.25472 = mono_verifier_is_enabled_for_image (image);
      if (D.25472 == 0) goto <D.25473>; else goto <D.25474>;
      <D.25473>:
      D.25475 = 1;
      return D.25475;
      <D.25474>:
      D.25476 = error_list != 0B;
      D.25477 = (int) D.25476;
      init_verify_context (&ctx, image, D.25477);
      ctx.stage = 2;
      is_valid_method_header (&ctx, offset, &locals_token);
      locals_token.183 = locals_token;
      if (locals_token.183 != 0) goto <D.25479>; else goto <D.25480>;
      <D.25479>:
      {
        guint32 sig_offset;

        D.25481 = &image->tables[17];
        locals_token.183 = locals_token;
        D.25482 = locals_token.183 + 4294967295;
        D.25483 = (int) D.25482;
        sig_offset = mono_metadata_decode_row_col (D.25481, D.25483, 0);
        is_valid_standalonesig_blob (&ctx, sig_offset);
      }
      <D.25480>:
      D.25475 = cleanup_context (&ctx, error_list);
      return D.25475;
    }
  finally
    {
      ctx = {CLOBBER};
      locals_token = {CLOBBER};
    }
}


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

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


cleanup_context_checked (struct VerifyContext * ctx, struct MonoError * error)
{
  struct SectionHeader * D.25492;
  struct GSList * D.25493;
  struct MonoImage * D.25496;
  char * D.25497;
  gboolean D.25498;

  D.25492 = ctx->sections;
  monoeg_g_free (D.25492);
  D.25493 = ctx->errors;
  if (D.25493 != 0B) goto <D.25494>; else goto <D.25495>;
  <D.25494>:
  {
    struct MonoVerifyInfo * info;

    D.25493 = ctx->errors;
    info = D.25493->data;
    D.25496 = ctx->image;
    D.25497 = info->message;
    mono_error_set_bad_image (error, D.25496, "%s", D.25497);
    D.25493 = ctx->errors;
    mono_free_verify_list (D.25493);
  }
  <D.25495>:
  D.25498 = ctx->valid;
  return D.25498;
}


mono_verifier_verify_memberref_method_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25500;
  gboolean D.25503;
  _Bool D.25504;
  int D.25505;
  struct VerifyContext ctx;

  try
    {
      D.25500 = mono_verifier_is_enabled_for_image (image);
      if (D.25500 == 0) goto <D.25501>; else goto <D.25502>;
      <D.25501>:
      D.25503 = 1;
      return D.25503;
      <D.25502>:
      D.25504 = error_list != 0B;
      D.25505 = (int) D.25504;
      init_verify_context (&ctx, image, D.25505);
      ctx.stage = 2;
      is_valid_memberref_method_signature (&ctx, offset);
      D.25503 = cleanup_context (&ctx, error_list);
      return D.25503;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


is_valid_memberref_method_signature (struct VerifyContext * ctx, guint32 offset)
{
  int D.25508;
  int D.25511;
  gchar * D.25514;
  struct GSList * D.25515;
  struct GSList * D.25516;
  gboolean D.25517;
  const char * ptr.184;
  unsigned int size.185;
  sizetype D.25520;
  guint32 size;
  const char * ptr;
  const char * end;

  try
    {
      size = 0;
      ptr = 0B;
      D.25508 = decode_signature_header (ctx, offset, &size, &ptr);
      if (D.25508 == 0) goto <D.25509>; else goto <D.25510>;
      <D.25509>:
      D.25511 = ctx->report_error;
      if (D.25511 != 0) goto <D.25512>; else goto <D.25513>;
      <D.25512>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25514 = monoeg_strdup ("MemberRefSig: Could not decode signature header");
        vinfo->info.message = D.25514;
        vinfo->exception_type = 3;
        D.25515 = ctx->errors;
        D.25516 = monoeg_g_slist_prepend (D.25515, vinfo);
        ctx->errors = D.25516;
      }
      <D.25513>:
      ctx->valid = 0;
      D.25517 = 0;
      return D.25517;
      <D.25510>:
      ptr.184 = ptr;
      size.185 = size;
      D.25520 = (sizetype) size.185;
      end = ptr.184 + D.25520;
      D.25517 = parse_method_signature (ctx, &ptr, end, 1, 0);
      return D.25517;
    }
  finally
    {
      size = {CLOBBER};
      ptr = {CLOBBER};
    }
}


mono_verifier_verify_memberref_field_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25523;
  gboolean D.25526;
  _Bool D.25527;
  int D.25528;
  struct VerifyContext ctx;

  try
    {
      D.25523 = mono_verifier_is_enabled_for_image (image);
      if (D.25523 == 0) goto <D.25524>; else goto <D.25525>;
      <D.25524>:
      D.25526 = 1;
      return D.25526;
      <D.25525>:
      D.25527 = error_list != 0B;
      D.25528 = (int) D.25527;
      init_verify_context (&ctx, image, D.25528);
      ctx.stage = 2;
      is_valid_field_signature (&ctx, offset);
      D.25526 = cleanup_context (&ctx, error_list);
      return D.25526;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_standalone_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25531;
  gboolean D.25534;
  _Bool D.25535;
  int D.25536;
  struct VerifyContext ctx;

  try
    {
      D.25531 = mono_verifier_is_enabled_for_image (image);
      if (D.25531 == 0) goto <D.25532>; else goto <D.25533>;
      <D.25532>:
      D.25534 = 1;
      return D.25534;
      <D.25533>:
      D.25535 = error_list != 0B;
      D.25536 = (int) D.25535;
      init_verify_context (&ctx, image, D.25536);
      ctx.stage = 2;
      is_valid_standalonesig_blob (&ctx, offset);
      D.25534 = cleanup_context (&ctx, error_list);
      return D.25534;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_typespec_signature (struct MonoImage * image, guint32 offset, guint32 token, struct GSList * * error_list)
{
  int D.25539;
  gboolean D.25542;
  _Bool D.25543;
  int D.25544;
  struct VerifyContext ctx;

  try
    {
      D.25539 = mono_verifier_is_enabled_for_image (image);
      if (D.25539 == 0) goto <D.25540>; else goto <D.25541>;
      <D.25540>:
      D.25542 = 1;
      return D.25542;
      <D.25541>:
      D.25543 = error_list != 0B;
      D.25544 = (int) D.25543;
      init_verify_context (&ctx, image, D.25544);
      ctx.stage = 2;
      ctx.token = token;
      is_valid_typespec_blob (&ctx, offset);
      D.25542 = cleanup_context (&ctx, error_list);
      return D.25542;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_methodspec_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25547;
  gboolean D.25550;
  _Bool D.25551;
  int D.25552;
  struct VerifyContext ctx;

  try
    {
      D.25547 = mono_verifier_is_enabled_for_image (image);
      if (D.25547 == 0) goto <D.25548>; else goto <D.25549>;
      <D.25548>:
      D.25550 = 1;
      return D.25550;
      <D.25549>:
      D.25551 = error_list != 0B;
      D.25552 = (int) D.25551;
      init_verify_context (&ctx, image, D.25552);
      ctx.stage = 2;
      is_valid_methodspec_blob (&ctx, offset);
      D.25550 = cleanup_context (&ctx, error_list);
      return D.25550;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_verify_string_signature (struct MonoImage * image, guint32 offset, struct GSList * * error_list)
{
  int D.25555;
  gboolean D.25558;
  _Bool D.25559;
  int D.25560;
  struct VerifyContext ctx;

  try
    {
      D.25555 = mono_verifier_is_enabled_for_image (image);
      if (D.25555 == 0) goto <D.25556>; else goto <D.25557>;
      <D.25556>:
      D.25558 = 1;
      return D.25558;
      <D.25557>:
      D.25559 = error_list != 0B;
      D.25560 = (int) D.25559;
      init_verify_context (&ctx, image, D.25560);
      ctx.stage = 2;
      verify_user_string (&ctx, offset);
      D.25558 = cleanup_context (&ctx, error_list);
      return D.25558;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


verify_user_string (struct VerifyContext * ctx, guint32 offset)
{
  struct MonoImage * D.25563;
  struct MonoStreamHeader * D.25564;
  unsigned int D.25565;
  int D.25568;
  gchar * D.25571;
  struct GSList * D.25572;
  struct GSList * D.25573;
  const char * D.25574;
  sizetype D.25575;
  unsigned int D.25576;
  sizetype D.25577;
  sizetype D.25578;
  const char * D.25579;
  unsigned int D.25580;
  int D.25581;
  gchar * D.25586;
  struct GSList * D.25587;
  unsigned int bytes.186;
  unsigned int D.25589;
  unsigned int entry_size.187;
  gchar * D.25595;
  struct GSList * D.25596;
  unsigned int entry_size.188;
  unsigned int D.25600;
  unsigned int D.25602;
  gchar * D.25605;
  struct GSList * D.25606;
  struct OffsetAndSize heap_us;
  guint32 entry_size;
  guint32 bytes;

  try
    {
      D.25563 = ctx->image;
      D.25564 = &D.25563->heap_us;
      heap_us = get_metadata_stream (ctx, D.25564);
      D.25565 = heap_us.size;
      if (D.25565 < offset) goto <D.25566>; else goto <D.25567>;
      <D.25566>:
      D.25568 = ctx->report_error;
      if (D.25568 != 0) goto <D.25569>; else goto <D.25570>;
      <D.25569>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25571 = monoeg_strdup ("User string offset beyond heap_us size");
        vinfo->info.message = D.25571;
        vinfo->exception_type = 3;
        D.25572 = ctx->errors;
        D.25573 = monoeg_g_slist_prepend (D.25572, vinfo);
        ctx->errors = D.25573;
      }
      <D.25570>:
      ctx->valid = 0;
      return;
      <D.25567>:
      D.25574 = ctx->data;
      D.25575 = (sizetype) offset;
      D.25576 = heap_us.offset;
      D.25577 = (sizetype) D.25576;
      D.25578 = D.25575 + D.25577;
      D.25579 = D.25574 + D.25578;
      D.25565 = heap_us.size;
      D.25576 = heap_us.offset;
      D.25580 = D.25565 - D.25576;
      D.25581 = decode_value (D.25579, D.25580, &entry_size, &bytes);
      if (D.25581 == 0) goto <D.25582>; else goto <D.25583>;
      <D.25582>:
      D.25568 = ctx->report_error;
      if (D.25568 != 0) goto <D.25584>; else goto <D.25585>;
      <D.25584>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25586 = monoeg_strdup ("Could not decode user string blob size");
        vinfo->info.message = D.25586;
        vinfo->exception_type = 3;
        D.25572 = ctx->errors;
        D.25587 = monoeg_g_slist_prepend (D.25572, vinfo);
        ctx->errors = D.25587;
      }
      <D.25585>:
      ctx->valid = 0;
      return;
      <D.25583>:
      bytes.186 = bytes;
      D.25589 = ~bytes.186;
      entry_size.187 = entry_size;
      if (D.25589 < entry_size.187) goto <D.25591>; else goto <D.25592>;
      <D.25591>:
      D.25568 = ctx->report_error;
      if (D.25568 != 0) goto <D.25593>; else goto <D.25594>;
      <D.25593>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25595 = monoeg_strdup ("User string size overflow");
        vinfo->info.message = D.25595;
        vinfo->exception_type = 3;
        D.25572 = ctx->errors;
        D.25596 = monoeg_g_slist_prepend (D.25572, vinfo);
        ctx->errors = D.25596;
      }
      <D.25594>:
      ctx->valid = 0;
      return;
      <D.25592>:
      entry_size.187 = entry_size;
      bytes.186 = bytes;
      entry_size.188 = entry_size.187 + bytes.186;
      entry_size = entry_size.188;
      entry_size.187 = entry_size;
      D.25600 = offset + entry_size.187;
      D.25565 = heap_us.size;
      if (D.25600 > D.25565) goto <D.25598>; else goto <D.25601>;
      <D.25601>:
      entry_size.187 = entry_size;
      D.25602 = ~entry_size.187;
      if (D.25602 < offset) goto <D.25598>; else goto <D.25599>;
      <D.25598>:
      D.25568 = ctx->report_error;
      if (D.25568 != 0) goto <D.25603>; else goto <D.25604>;
      <D.25603>:
      {
        struct MonoVerifyInfoExtended * vinfo;

        vinfo = monoeg_malloc (24);
        vinfo->info.status = 1;
        D.25605 = monoeg_strdup ("User string oveflow heap_us");
        vinfo->info.message = D.25605;
        vinfo->exception_type = 3;
        D.25572 = ctx->errors;
        D.25606 = monoeg_g_slist_prepend (D.25572, vinfo);
        ctx->errors = D.25606;
      }
      <D.25604>:
      ctx->valid = 0;
      return;
      <D.25599>:
    }
  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.25610;
  gboolean D.25613;
  _Bool D.25614;
  int D.25615;
  struct VerifyContext ctx;

  try
    {
      D.25610 = mono_verifier_is_enabled_for_image (image);
      if (D.25610 == 0) goto <D.25611>; else goto <D.25612>;
      <D.25611>:
      D.25613 = 1;
      return D.25613;
      <D.25612>:
      D.25614 = error_list != 0B;
      D.25615 = (int) D.25614;
      init_verify_context (&ctx, image, D.25615);
      ctx.stage = 2;
      is_valid_cattr_blob (&ctx, offset);
      D.25613 = cleanup_context (&ctx, error_list);
      return D.25613;
    }
  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.25618;
  gboolean D.25621;
  _Bool D.25622;
  int D.25623;
  struct VerifyContext ctx;

  try
    {
      D.25618 = mono_verifier_is_enabled_for_image (image);
      if (D.25618 == 0) goto <D.25619>; else goto <D.25620>;
      <D.25619>:
      D.25621 = 1;
      return D.25621;
      <D.25620>:
      D.25622 = error_list != 0B;
      D.25623 = (int) D.25622;
      init_verify_context (&ctx, image, D.25623);
      ctx.stage = 2;
      is_valid_cattr_content (&ctx, ctor, data, size);
      D.25621 = cleanup_context (&ctx, error_list);
      return D.25621;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_verifier_is_sig_compatible (struct MonoImage * image, struct MonoMethod * method, struct MonoMethodSignature * signature)
{
  int D.25626;
  gboolean D.25629;
  long unsigned int D.25630;
  long unsigned int D.25631;
  long unsigned int D.25634;
  long unsigned int D.25635;
  long unsigned int D.25636;
  long unsigned int D.25639;
  long unsigned int D.25642;
  long unsigned int D.25647;
  short int D.25650;
  short int D.25651;
  int D.25655;
  struct MonoMethodSignature * original_sig;

  D.25626 = mono_verifier_is_enabled_for_image (image);
  if (D.25626 == 0) goto <D.25627>; else goto <D.25628>;
  <D.25627>:
  D.25629 = 1;
  return D.25629;
  <D.25628>:
  original_sig = mono_method_signature (method);
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25631 = D.25630 & 17732923532771328;
  if (D.25631 == 1407374883553280) goto <D.25632>; else goto <D.25633>;
  <D.25632>:
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25634 = BIT_FIELD_REF <*signature, 64, 64>;
  D.25635 = D.25630 ^ D.25634;
  D.25636 = D.25635 & 18014398509481984;
  if (D.25636 != 0) goto <D.25637>; else goto <D.25638>;
  <D.25637>:
  D.25629 = 0;
  return D.25629;
  <D.25638>:
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25634 = BIT_FIELD_REF <*signature, 64, 64>;
  D.25635 = D.25630 ^ D.25634;
  D.25639 = D.25635 & 17732923532771328;
  if (D.25639 != 0) goto <D.25640>; else goto <D.25641>;
  <D.25640>:
  D.25629 = 0;
  return D.25629;
  <D.25641>:
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25634 = BIT_FIELD_REF <*signature, 64, 64>;
  D.25635 = D.25630 ^ D.25634;
  D.25642 = D.25635 & 36028797018963968;
  if (D.25642 != 0) goto <D.25643>; else goto <D.25644>;
  <D.25643>:
  D.25629 = 0;
  return D.25629;
  <D.25644>:
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25634 = BIT_FIELD_REF <*signature, 64, 64>;
  D.25635 = D.25630 ^ D.25634;
  D.25639 = D.25635 & 17732923532771328;
  if (D.25639 != 0) goto <D.25645>; else goto <D.25646>;
  <D.25645>:
  D.25629 = 0;
  return D.25629;
  <D.25646>:
  D.25630 = BIT_FIELD_REF <*original_sig, 64, 64>;
  D.25634 = BIT_FIELD_REF <*signature, 64, 64>;
  D.25635 = D.25630 ^ D.25634;
  D.25647 = D.25635 & 72057594037927936;
  if (D.25647 != 0) goto <D.25648>; else goto <D.25649>;
  <D.25648>:
  D.25629 = 0;
  return D.25629;
  <D.25649>:
  D.25650 = original_sig->sentinelpos;
  D.25651 = signature->sentinelpos;
  if (D.25650 != D.25651) goto <D.25652>; else goto <D.25653>;
  <D.25652>:
  D.25629 = 0;
  return D.25629;
  <D.25653>:
  goto <D.25654>;
  <D.25633>:
  D.25655 = mono_metadata_signature_equal (signature, original_sig);
  if (D.25655 == 0) goto <D.25656>; else goto <D.25657>;
  <D.25656>:
  D.25629 = 0;
  return D.25629;
  <D.25657>:
  <D.25654>:
  D.25629 = 1;
  return D.25629;
}


mono_verifier_verify_typeref_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.25659;
  gboolean D.25662;
  <unnamed-unsigned:24> D.25663;
  unsigned int D.25664;
  int D.25667;
  int row.189;
  unsigned int D.25669;
  int D.25670;
  unsigned int D.25673;
  unsigned int D.25678;
  int D.25680;
  unsigned int D.25681;
  int D.25684;
  struct MonoTableInfo * table;
  guint32 data[3];

  try
    {
      table = &image->tables[1];
      mono_error_init (error);
      D.25659 = mono_verifier_is_enabled_for_image (image);
      if (D.25659 == 0) goto <D.25660>; else goto <D.25661>;
      <D.25660>:
      D.25662 = 1;
      return D.25662;
      <D.25661>:
      D.25663 = table->rows;
      D.25664 = (unsigned int) D.25663;
      if (D.25664 <= row) goto <D.25665>; else goto <D.25666>;
      <D.25665>:
      D.25663 = table->rows;
      D.25667 = (int) D.25663;
      mono_error_set_bad_image (error, image, "Invalid typeref row %d - table has %d rows", row, D.25667);
      D.25662 = 0;
      return D.25662;
      <D.25666>:
      row.189 = (int) row;
      mono_metadata_decode_row (table, row.189, &data, 3);
      D.25669 = data[0];
      D.25670 = is_valid_coded_index_with_image (image, 72, D.25669);
      if (D.25670 == 0) goto <D.25671>; else goto <D.25672>;
      <D.25671>:
      D.25669 = data[0];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d coded index 0x%08x", row, D.25669);
      D.25662 = 0;
      return D.25662;
      <D.25672>:
      D.25669 = data[0];
      D.25673 = get_coded_index_token (72, D.25669);
      if (D.25673 == 0) goto <D.25674>; else goto <D.25675>;
      <D.25674>:
      mono_error_set_bad_image (error, image, "The metadata verifier doesn\'t support null ResolutionScope tokens for typeref row %d", row);
      D.25662 = 0;
      return D.25662;
      <D.25675>:
      D.25678 = data[1];
      if (D.25678 == 0) goto <D.25676>; else goto <D.25679>;
      <D.25679>:
      D.25678 = data[1];
      D.25680 = is_valid_string_full_with_image (image, D.25678, 0);
      if (D.25680 == 0) goto <D.25676>; else goto <D.25677>;
      <D.25676>:
      D.25678 = data[1];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d name token 0x%08x", row, D.25678);
      D.25662 = 0;
      return D.25662;
      <D.25677>:
      D.25681 = data[2];
      if (D.25681 != 0) goto <D.25682>; else goto <D.25683>;
      <D.25682>:
      D.25681 = data[2];
      D.25684 = is_valid_string_full_with_image (image, D.25681, 0);
      if (D.25684 == 0) goto <D.25685>; else goto <D.25686>;
      <D.25685>:
      D.25681 = data[2];
      mono_error_set_bad_image (error, image, "Invalid typeref row %d namespace token 0x%08x", row, D.25681);
      D.25662 = 0;
      return D.25662;
      <D.25686>:
      <D.25683>:
      D.25662 = 1;
      return D.25662;
    }
  finally
    {
      data = {CLOBBER};
    }
}


mono_verifier_verify_methodimpl_row (struct MonoImage * image, guint32 row, struct MonoError * error)
{
  int D.25689;
  gboolean D.25692;
  <unnamed-unsigned:24> D.25693;
  unsigned int D.25694;
  int D.25697;
  int row.190;
  unsigned int D.25699;
  struct MonoLoaderError * D.25703;
  unsigned int D.25704;
  struct MonoLoaderError * D.25708;
  int D.25713;
  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.25689 = mono_verifier_is_enabled_for_image (image);
      if (D.25689 == 0) goto <D.25690>; else goto <D.25691>;
      <D.25690>:
      D.25692 = 1;
      return D.25692;
      <D.25691>:
      D.25693 = table->rows;
      D.25694 = (unsigned int) D.25693;
      if (D.25694 <= row) goto <D.25695>; else goto <D.25696>;
      <D.25695>:
      D.25693 = table->rows;
      D.25697 = (int) D.25693;
      mono_error_set_bad_image (error, image, "Invalid methodimpl row %d - table has %d rows", row, D.25697);
      D.25692 = 0;
      return D.25692;
      <D.25696>:
      row.190 = (int) row;
      mono_metadata_decode_row (table, row.190, &data, 3);
      D.25699 = data[1];
      body = method_from_method_def_or_ref (image, D.25699, 0B);
      if (body == 0B) goto <D.25700>; else goto <D.25702>;
      <D.25702>:
      D.25703 = mono_loader_get_last_error ();
      if (D.25703 != 0B) goto <D.25700>; else goto <D.25701>;
      <D.25700>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl body for row %x", row);
      D.25692 = 0;
      return D.25692;
      <D.25701>:
      D.25704 = data[2];
      declaration = method_from_method_def_or_ref (image, D.25704, 0B);
      if (declaration == 0B) goto <D.25705>; else goto <D.25707>;
      <D.25707>:
      D.25708 = mono_loader_get_last_error ();
      if (D.25708 != 0B) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      mono_loader_clear_error ();
      mono_error_set_bad_image (error, image, "Invalid methodimpl declaration for row %x", row);
      D.25692 = 0;
      return D.25692;
      <D.25706>:
      body_sig = mono_method_signature_checked (body, error);
      if (body_sig == 0B) goto <D.25709>; else goto <D.25710>;
      <D.25709>:
      D.25692 = 0;
      return D.25692;
      <D.25710>:
      decl_sig = mono_method_signature_checked (declaration, error);
      if (decl_sig == 0B) goto <D.25711>; else goto <D.25712>;
      <D.25711>:
      D.25692 = 0;
      return D.25692;
      <D.25712>:
      D.25713 = mono_verifier_is_signature_compatible (decl_sig, body_sig);
      if (D.25713 == 0) goto <D.25714>; else goto <D.25715>;
      <D.25714>:
      mono_error_set_bad_image (error, image, "Invalid methodimpl body signature not compatible with declaration row %x", row);
      D.25692 = 0;
      return D.25692;
      <D.25715>:
      D.25692 = 1;
      return D.25692;
    }
  finally
    {
      data = {CLOBBER};
    }
}